huff.c

一个Huffman的例子

/*
 *	7-5-95	5:26	
 *
 *	StaticHuff v4.0
 *
 *	uses Huffman2
 * 
 *	codes are assigned w/ non huffman-method
 *
 *	it works!
 *
 *
 *	7-6-95 FastDecode !  It works!
 *
 */

/*** config defines ***/

// #define DONT_TIME_INIT
#define USE_MACROS
#define FAST_DECODE
#define FAST_DECODE_ARRAY

/*** end config defines ***/

#include <crbinc/inc.h>
#include <crbinc/strutil.h>
#include <crbinc/fileutil.h>
#include <crbinc/memutil.h>
#include <crbinc/lbitio.h>
#include <crbinc/timer.h>
#include <crbinc/Huffman2.h>
#include <crbinc/cindcatr.h>

//globals:
clock_t StartClock,StopClock;
long RawFileLen;
long HuffArrayLen,RawArrayLen;

//exit-freed globals:
BPTR InFH  = NULL;
BPTR OutFH = NULL;
struct LBitIOInfo * BII = NULL;
struct Huff2Info * HI = NULL;
ubyte * HuffArray = NULL;
ubyte * RawArray = NULL;
long * CharCounts = NULL;

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

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

errputs("StaticHuff v4.0 copyright (c) 1995 Charles Bloom");

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

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 )
  {
  errputs("Decoding file...");

	Read(InFH,&RawFileLen,4);
	fprintf(stderr,"Decompressing to %lu bytes.\n",RawFileLen);
	}
else //Encode
  {
  printf("Encoding file : %s\n",argv[1]);

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

HuffArrayLen = RawFileLen+512;
RawArrayLen = RawFileLen + 512;

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

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

if ( (CharCounts = AllocMem(256*sizeof(long),MEMF_ANY)) == NULL )
	CleanUp("AllocMem failed!");

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

if ( (HI = Huff2_Init(256,BII,HUFF2_SORT_RADIX)) == NULL )
	CleanUp("Huff2_Init failed!");


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

#ifndef DONT_TIME_INIT
	StartClock = clock();
#endif

	LBitIO_InitRead(BII);

	Huff2_UnPackCodeLens(HI);
#ifdef FAST_DECODE
	Huff2_BuildFastDecodeTable(HI);
#else
	Huff2_BuildDecodeTable(HI);
#endif

#ifdef DONT_TIME_INIT
	StartClock = clock();
#endif

#ifdef FAST_DECODE_ARRAY

	Huff2_FastDecodeArray_Ubyte(HI,RawArray,RawFileLen);

#else

#ifdef FAST_DECODE
#ifdef USE_MACROS
	Huff2_FastDecodeC_Macro_Init(HI);

	for(i=0;i<RawFileLen;i++)
		{
		Huff2_FastDecodeC_Macro(HI,RawArray[i]);
		}

	Huff2_FastDecodeC_Macro_Done(HI);
#else
	for(i=0;i<RawFileLen;i++)
		{
		RawArray[i] = Huff2_FastDecodeC(HI);
		}
#endif
#else
#ifdef USE_MACROS
	Huff2_DecodeC_Macro_Init(HI);

	for(i=0;i<RawFileLen;i++)
		{
		Huff2_DecodeC_Macro(HI,RawArray[i]);
		}

	Huff2_DecodeC_Macro_Done(HI);
#else
	for(i=0;i<RawFileLen;i++)
		{
		RawArray[i] = Huff2_DecodeC(HI);
		}
#endif
#endif

#endif

	StopClock = clock();

	Write(OutFH,RawArray,RawFileLen);

	printf(" %lu byps\n",NumPerSec(RawFileLen,StopClock-StartClock));
  }
else //Encode
	{
	long CompressedCountsLen,SaveLen;

	Read(InFH,RawArray,RawFileLen);

#ifndef DONT_TIME_INIT
  StartClock = clock();
#endif

	MemClear(CharCounts,256*sizeof(long));
	for(i=0;i<RawFileLen;i++)
		CharCounts[RawArray[i]] ++;

	Huff2_ScaleCounts(HI,CharCounts,256);
	Huff2_BuildCodeLens(HI,CharCounts);

	SaveLen = LBitIO_GetPos(BII);

	Huff2_PackCodeLens(HI);

	CompressedCountsLen = LBitIO_GetPos(BII) - SaveLen;

	Huff2_BuildEncodeTable(HI);

#ifdef DONT_TIME_INIT
	StartClock = clock();
#endif

#ifdef USE_MACROS
	Huff2_EncodeC_Macro_Init(HI);

	for(i=0;i<RawFileLen;i++)
		{
		Huff2_EncodeC_Macro(HI,RawArray[i]);
		}

	Huff2_EncodeC_Macro_Done(HI);
#else
	for(i=0;i<RawFileLen;i++)
		{
		Huff2_EncodeC(HI,RawArray[i]);
		}
#endif

	StopClock = clock();

	HuffLen = LBitIO_FlushWrite(BII);

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

	printf("%-20s : ",FilePart(argv[1]));
	TheCompressionIndicator(RawFileLen,HuffLen+CompressedCountsLen,stdout);
	printf(" %lu byps\n",NumPerSec(RawFileLen,(StopClock-StartClock)));
  }

CleanUp(NULL);
return 0;
}

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

SmartFree(HuffArray,HuffArrayLen);
SmartFree(RawArray,RawArrayLen);
SmartFree(CharCounts,256*sizeof(long));

if ( HI ) Huff2_CleanUp(HI);
if ( BII ) LBitIO_CleanUp(BII);

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

}

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

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