adaptivehuff.c

数据压缩Huffman算法

/*
 * 6-19-95 IT WORKS!
 *											 AHuff			ApproxAE		FastAE
 * speed of compression: 18k bps 		16k					13k
 *
 * compression performance : identical to arith (order-0) !
 *
 */

#include <simple/inc.h>
#include <simple/exec.h>
#include <simple/dos.h>
#include <crb/strutil.h>
#include <crb/fileutil.h>
#include <crb/MemUtil.h>
#include <crb/BitIO.h>
#include <dos.h>
#include <time.h>

#include "AHuff.h"

//globals:
long RawFileLen;
long HuffArrayLen;

//exit-freed globals:
BPTR InFH  = NULL;
BPTR OutFH = NULL;
struct BitIOInfo * BII = NULL;
struct AHuffInfo * AHI = NULL;
ulong * HuffArray = NULL;
ubyte * RawArray = NULL;

//protos:
void CleanUp(char * ExitMess);
int BreakFunc(void);
void ExitFunc(void);

int main(int argc,char *argv[])
{
unsigned int StartClock[2],StopClock[2];
bool GotDecompressFlag;
long HuffLen;
long i;

puts("AdaptiveHuff v1.0 copyright (c) 1995 Charles Bloom");

if ( argc < 3 )
  CleanUp("Usage: AdaptiveHuff <infile> <outfile> [decompress flag]");

if ( onbreak(BreakFunc) )
  CleanUp("Couldn't install break trap!");
if ( atexit(ExitFunc) )
  CleanUp("Couldn't install exit trap!");

if ( (InFH = Open(argv[1],MODE_OLDFILE)) == NULL )
  CleanUp("Error opening input file");

if ( (OutFH = Open(argv[2],MODE_NEWFILE)) == NULL )
  CleanUp("Error creating output file");

GotDecompressFlag = 0;
if ( argc == 4 )
	{
	if ( strichr(argv[3],'d') )
		{
		GotDecompressFlag = 1;
		}
	}

if ( GotDecompressFlag )
  {
  puts("Decoding file...");

	Read(InFH,(APTR)&RawFileLen,4);
	printf("Decompressing to %lu bytes.\n",RawFileLen);
	}
else //Encode
  {
  puts("Encoding file...");

	RawFileLen = FileLengthofFH(InFH);
	Write(OutFH,(APTR)&RawFileLen,4);
	}

HuffArrayLen = PaddedSize(RawFileLen) + 1024;

if ( (HuffArray = AllocMem(HuffArrayLen,MEMF_ANY)) == NULL )
	CleanUp("AllocMem failed!");

if ( (RawArray = AllocMem(RawFileLen,MEMF_ANY)) == NULL )
	CleanUp("AllocMem failed!");

if ( (BII = BitIO_Init(HuffArray)) == NULL )
	CleanUp("BitIO_Init failed!");

if ( (AHI = AHuff_Init(BII,256)) == NULL )
	CleanUp("Huff_Init failed!");

if ( GotDecompressFlag )
	{
	Read(InFH,(APTR)&HuffLen,4);
	Read(InFH,HuffArray,HuffLen);

	BitIO_InitRead(BII);

	timer(StartClock);

	for(i=0;i<RawFileLen;i++)
		RawArray[i] = AHuff_DecodeC(AHI);
		
	timer(StopClock);

	Write(OutFH,RawArray,RawFileLen);
  }
else //Encode
	{
	Read(InFH,RawArray,RawFileLen);

	timer(StartClock);

	for(i=0;i<RawFileLen;i++)
		AHuff_EncodeC(AHI,RawArray[i]);

	timer(StopClock);

	HuffLen = BitIO_FlushWrite(BII);

	Write(OutFH,(APTR)&HuffLen,4);
	Write(OutFH,HuffArray,HuffLen);
  }

/* */
	{
	long Ratio,RatioDec;
	long BytesPerSecond;
	long BPB,BPBdec;

	Ratio = RawFileLen*1000 / (HuffLen + 8);
	RatioDec = Ratio - ( Ratio / 1000 ) * 1000;
	Ratio /= 1000;
	
	BPB = 8000*HuffLen / RawFileLen;
	if ( BPB < 0 )
		{
		BPB = 8000000 / (Ratio*1000 + RatioDec);
		}
	BPBdec = BPB - (BPB/1000)*1000;
	BPB /= 1000;

	printf("  %ld -> %ld = %ld.%03ld to 1 = %ld.%03ld bpb\n",
		RawFileLen,HuffLen,Ratio,RatioDec,BPB,BPBdec);
	
	BytesPerSecond =  (( RawFileLen * 1000 ) /
	         ( (long)( StopClock[0] - StartClock[0] ) * 1000 +
						 ( (long)StopClock[1] - (long)StartClock[1] ) / 1000 ));
	printf("BytesPerSecond = %ld\n",BytesPerSecond);
	}
/* */

CleanUp(NULL);
}

void ExitFunc(void)
{
puts("Performing custom exit handler.");

SmartFree(HuffArray,HuffArrayLen);
SmartFree(RawArray,RawFileLen);

if ( AHI ) AHuff_CleanUp(AHI);
if ( BII ) BitIO_CleanUp(BII);

if ( InFH  ) Close(InFH);
if ( OutFH ) Close(OutFH);

}

void CleanUp(char * ExitMess)
{
if ( ExitMess )
  {
  puts(ExitMess);
  exit(10);
  }
else
  {
	puts("Standard exit.");
  exit(0);
  }
}

int BreakFunc(void)
{
return(1);
}