/trunk/source/Engine/JetEngine/Bitmap/Compression/huffman2.cpp

/****************************************************************************************/

/*  HUFFMAN2.C                                                                          */

/*                                                                                      */

/*  Author:                                                                             */

/*  Description:                                                                        */

/*                                                                                      */

/*  The contents of this file are subject to the Jet3D Public License                   */

/*  Version 1.02 (the "License"); you may not use this file except in                   */

/*  compliance with the License. You may obtain a copy of the License at                */

/*  http://www.jet3d.com                                                                */

/*                                                                                      */

/*  Software distributed under the License is distributed on an "AS IS"                 */

/*  basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See                */

/*  the License for the specific language governing rights and limitations              */

/*  under the License.                                                                  */

/*                                                                                      */

/*  The Original Code is Jet3D, released December 12, 1999.                             */

/*  Copyright (C) 1996-1999 Eclipse Entertainment, L.L.C. All Rights Reserved           */

/*                                                                                      */

/****************************************************************************************/

/******



problem : 



encoding/decoding when GotNumSymbols == 1 needs to be handled as

a special case.



I think encoding is Ok, but DecodeBuildTree needs to set NodeBase->Char

to be the one char to code



--



Macros need to be updated to handle this case



*********/



/*

 * notez : there's kind of a bug in FastDecode :

 *	if the last code in decodes to more than one char, you might

 *	skip more bits than were written

 *

 * this can mess you up in merge-bit-stream cases

 *

 *

 * note: this is handled properly by FastDecodeArray

 *

 */



/*

 * notez : you must PackCodeLens BEFORE BuildEncodeTable

 *  in order to set Min & Max CodeLen

 * if you don't PackCodeLens, call SetMinMaxCodeLen

 */



/*

 *

 * Huffman2 :	7-5-96

 *

 *  not a general purpose Huffman utility

 *	does not generate Huffman codes.  Codes have same lengths, but

 *		values are ordered thus:

 *	for each code length, values are ordered by alphabetic order

 *

 * ---

 * 

 * Encode BuildTree time is nearly identical to old Huffman

 * Decode BuildTree time is MUCH shorter!

 * EncodeC time is identical

 * DecodeC time is shorter

 *

 * ---

 *

 *	7-6-95 : 

 *		FastDecode !  uses table lookup for multi-symbol-at-a-time operation!

 *	

 *	7-7-95

 *		I just peeked the IJG JPEG source & discovered that they use

 *			this method with MaxNumMadeChars = 1

 *

 */



//#define DEBUG



/* DEBUG toggles some tests which

	garauntee proper operation, but take some time to do */



//#define DO_MEMCLEARS



/* DO_MEMCLEARS toggles some unnecessary memclears 

	probably a good idea to turn it on for debug purposes */



#define PACKCODES_TOPSYM

/* if this is on, then in PackCodeLens, the value of the highest

	non-zero-count symbol is written, and codes are only written up

	to that symbol ; this helps compression a good deal in most cases */



/*

 *

 * Modularized Static Huffman encoding

 *

 * Notes: works on a LBitIOInfo structure

 *			this structure must be independently allocated and destroyd

 *

 *	Uses the O(n) Huffman algorithm with QuickSort, RadixSort, or NoSort

 *		NOTEZ: RadixSort assumes counts are bounded in the range [0,MaxCharCount]

 *	if AlphaSize > 64 or so, use the RadixSort

 *

 *	You are responsible for calling

 *		LBitIO_FlushWrite(HI->BII);

 *	yourself.  It is no longer done in EncodeCDone

 *

 *	You must also call

 *		LBitIO_InitRead(HI->BII);

 *	yourself before doing any reads.  It is no longer done in DecodeCInit

 *

 * 7-4-95 new stuff:

 *	1. charcounts are now packed as codelengths only (much better packing)

 *	2. this creates a problem : two chars with different counts but the

 *			same code length are no longer distinguishable by the decoder,

 *			but they were distinguished by the encoder!

 *	3. result : Huffman2 : uses manual code assignment

 *

 *

 */

#include "stdafx.h"

#include <limits.h>

#include "Utility.h"

#include "MemPool.h"

#include "lbitio.h"

#include "IntMath.h"



#pragma warning(disable : 4244)



#ifdef DEBUG

#include <stdio.h>

#endif



#include "huffman2.h"



#define memclearFast(m,s) memclear(m,s*4)

#define FreeMem(m,s)	destroy(m)



//protos:

struct Huff2Info * Huff2_Init(long NumSymbols,struct LBitIOInfo * BII,long SortType);

void Huff2_CleanUp(struct Huff2Info *HI);



void Huff2_GetMaxCharCount(struct Huff2Info *HI,long * CharCounts);

void Huff2_ScaleCounts(struct Huff2Info *HI,long * CharCounts,long MaxVal);

jeBoolean Huff2_BuildCodeLens(struct Huff2Info *HI,long *CharCounts);



jeBoolean Huff2_BuildEncodeTable(struct Huff2Info *HI);

jeBoolean Huff2_BuildDecodeTable(struct Huff2Info *HI);

jeBoolean Huff2_BuildFastDecodeTable(struct Huff2Info *HI);



void Huff2_EncodeC(struct Huff2Info *HI,uint16 C);

uint16 Huff2_DecodeC(struct Huff2Info *HI);

uint16 Huff2_FastDecodeC(struct Huff2Info *HI);

jeBoolean Huff2_FastDecodeArray(struct Huff2Info *HI,uint8 * Array,long ArrayLen);



jeBoolean Huff2_FindDecodeOne(struct Huff2Info *HI);



void Huff2_SetMinMaxCodeLen(struct Huff2Info *HI);



void Huff2_PackCodeLens(struct Huff2Info *HI);

void Huff2_UnPackCodeLens(struct Huff2Info *HI);                                      



void Huff2_PackCodeLens_Delta(struct Huff2Info *HI,long * LastCodeLens);

void Huff2_UnPackCodeLens_Delta(struct Huff2Info *HI,long * LastCodeLens);



//sort protos:

jeBoolean  Huff2RadixSort(struct Huff2CodeNode ** BucketArray,

	long MaxCharCount,struct Huff2CodeNode ** Array,long ArraySize);

void Huff2QuickSort(long Left,long Right);

struct Huff2CodeNode ** Huff2QuickSortArray; //global for recursion non-stacking



//functions:



/*

 */

struct Huff2Info * Huff2_Init(long NumSymbols,struct LBitIOInfo * BII,long SortType)

{

struct Huff2Info * HI;



if ( (HI = (struct Huff2Info *)JE_RAM_ALLOCATE_CLEAR(sizeof(struct Huff2Info))) == NULL )

	return(NULL);



HI->GotNumSymbols = 0;

HI->NumSymbols = NumSymbols;

HI->MaxCharCount = LONG_MAX;

HI->BII = BII;

HI->SortType = SortType;

HI->CodeNodeHunkI = 0;



if ( (HI->CodeLenTable = (long *)JE_RAM_ALLOCATE_CLEAR(HI->NumSymbols*sizeof(long))) == NULL )

	{

	Huff2_CleanUp(HI);

	return(NULL);

	}



if ( (HI->NumCodesOfLen = (long *)JE_RAM_ALLOCATE_CLEAR(32*sizeof(long))) == NULL )

	{

	Huff2_CleanUp(HI);

	return(NULL);

	}



if ( (HI->CodePrefixByLen = (uint32 *)JE_RAM_ALLOCATE_CLEAR(32*sizeof(uint32))) == NULL )

	{

	Huff2_CleanUp(HI);

	return(NULL);

	}



return(HI);

}



/*

 */

void Huff2_CleanUp(struct Huff2Info * HI)

{

FreeMem(HI->NodeWork,sizeofpointer*HI->NumSymbols);

FreeMem(HI->MadeNodeWork,sizeofpointer*HI->NumSymbols*2);

FreeMem(HI->CodeLenTable,HI->NumSymbols*sizeof(long));

FreeMem(HI->NumCodesOfLen,32*sizeof(long));

FreeMem(HI->CodePrefixByLen,32*sizeof(uint32));

FreeMem(HI->CodeNodeHunk,sizeof(struct Huff2CodeNode)*2*HI->NumSymbols);

FreeMem(HI->StackArray,2*(HI->NumSymbols)*sizeof(uint32));

FreeMem(HI->EnDe_codeTable,HI->EnDe_codeTableLen);



if ( HI->SortType == HUFF2_SORT_RADIX )

	{

	FreeMem(HI->SortWork,sizeofpointer*(HI->MaxCharCount + 1));

	}



FreeMem(HI,sizeof(struct Huff2Info));

}



/*

 *	Compute the codelens into Huff2Info from the CharCounts array

 *



NOTEZ: MadeNodeWork is large enough, but you may have the problem of looping

	i.e. ( (MadeNodeWorkIn - MadeNodeWorkOut) < NumSymbols )  is just fine, 

		the problem is ( MadeNodeWorkIn < NumSymbols ) isn't JE_TRUE

	thus all made-array lookups are done: [MadeNodeWorkIn % NumSymbols]



10-15-95 : alloced MadeNodeWork to double length so as to eliminate this.



 */



/*

 *

 * return values :

 *		1 = all ok

 *		0 = error

 *

 */

jeBoolean Huff2_BuildCodeLens(struct Huff2Info *HI,long *CharCounts)

{

register struct Huff2CodeNode * CurNode;

register struct Huff2CodeNode ** NodeWork;

register long i,NumSymbols,GotNumSymbols;

/*long swapchar;*/



if ( !HI->CodeNodeHunk ||	!HI->NodeWork || !HI->MadeNodeWork )

	{



	if ( HI->CodeNodeHunk || HI->NodeWork || HI->MadeNodeWork )

		{

		return(0);

		}



	HI->NodeWork = (struct Huff2CodeNode **)JE_RAM_ALLOCATE(sizeofpointer*HI->NumSymbols);

	HI->MadeNodeWork = (struct Huff2CodeNode **)JE_RAM_ALLOCATE(sizeofpointer*2*HI->NumSymbols);

	HI->CodeNodeHunk = (struct Huff2CodeNode *)JE_RAM_ALLOCATE(sizeof(struct Huff2CodeNode)*2*HI->NumSymbols);



	if ( !HI->CodeNodeHunk ||	!HI->NodeWork ||	!HI->MadeNodeWork )

		{

		return(0);

		}

	}



/* reset, if this is an already-used Huff2Info */

if ( HI->NodeBase )

	{

	HI->NodeBase = NULL;

	HI->CodeNodeHunkI = 0;



	HI->GotNumSymbols = 0;

	HI->MaxCharCount = LONG_MAX;

	HI->CodeNodeHunkI = 0;



	HI->MinCodeLen = HI->MaxCodeLen = 0;



#ifdef DO_MEMCLEARS

	memclearFast((long *)HI->CodeNodeHunk,sizeof(struct Huff2CodeNode)*HI->NumSymbols);

	memclearFast((long *)HI->NodeWork,HI->NumSymbols);

	memclearFast((long *)HI->MadeNodeWork,HI->NumSymbols);

#endif // DO_MEMCLEARS



	memclearFast((long *)HI->CodeLenTable,HI->NumSymbols);

	memclearFast((long *)HI->NumCodesOfLen,32);

	memclearFast((long *)HI->CodePrefixByLen,32);

	}



NodeWork = HI->NodeWork;

NumSymbols = HI->NumSymbols;



/*

 *	Read the chars into NodeWork

 *		packing out the NULLs

 *

 */

GotNumSymbols=0;

for(i=0;i<NumSymbols;i++) /* $ 12% !! */

	{

	if ( CharCounts[i] > 0 ) 

		{

		NodeWork[GotNumSymbols] = HI->CodeNodeHunk + HI->CodeNodeHunkI; HI->CodeNodeHunkI++;

		NodeWork[GotNumSymbols]->Char = i;

		NodeWork[GotNumSymbols]->Count = CharCounts[i];

		NodeWork[GotNumSymbols]->Up = NodeWork[GotNumSymbols]->Down = NULL;

		GotNumSymbols++;

		}

	}



/* !!!! you should not do any huffman coding if this ever happens ! */

/* NOTEZ: BuildEncodeTable WILL fail ! */

/* PackCodeLens & UnPackCodeLens will work */

HI->GotNumSymbols = GotNumSymbols;

if ( GotNumSymbols < 2 )

	{

	if ( GotNumSymbols == 0 )

		{

		return(1);

		}

	else

		{

		HI->NodeBase = NodeWork[0];

		HI->NodeBase->Up = NULL;

		HI->NodeBase->Down = NULL;

		HI->CodeLenTable[HI->NodeBase->Char] = 1;

		HI->NumCodesOfLen[1] = 1;

		/* call PackCodeLens anyway, so the decoder knows which char to copy */

		return(1);

		}

	}



/*

 *	sort NodeWork in order of ascending counts

 *

 */

switch(HI->SortType)

	{

	case HUFF2_SORT_NONE:

		break;

	case HUFF2_SORT_RADIX:

		if ( ! HI->SortWork )

			{

			if ( HI->MaxCharCount == LONG_MAX )

				{

				return(0);

				}

			if ( (HI->SortWork = JE_RAM_ALLOCATE(sizeofpointer*(HI->MaxCharCount + 1))) == NULL )

				{

				return(0);

				}

			}

		if ( ! Huff2RadixSort((struct Huff2CodeNode **)HI->SortWork,

			HI->MaxCharCount,NodeWork,GotNumSymbols) ) return(0);

		break;

	case HUFF2_SORT_QSORT:

		Huff2QuickSortArray = NodeWork;

		Huff2QuickSort(0,GotNumSymbols-1);

		break;

	default:

		return(0);

		break;

	}



/* sort puts lowest value of ->Count first */



/* register the tree-building variables */

 {

register long MadeNodeWorkIn,MadeNodeWorkOut,NodeWorkOut;

register struct Huff2CodeNode ** MadeNodeWork;



MadeNodeWork = HI->MadeNodeWork;

NodeWorkOut=0;

MadeNodeWorkIn  = 0;

MadeNodeWorkOut = 0;



/*

 *	Build the tree while there are more leaf-nodes to go

 *

 */

while( NodeWorkOut < (GotNumSymbols-1) ) /* $ 38 % */

	{



	CurNode = HI->CodeNodeHunk + HI->CodeNodeHunkI; HI->CodeNodeHunkI++;

	CurNode->Char = HUFF2_CODE_BRANCH;



#ifdef DEBUG

	if ( HI->CodeNodeHunkI >= (NumSymbols*2) )

		{

		BrandoError(" HI->CodeNodeHunkI >= (NumSymbols*2) !");	

		exit(1);

		}

#endif // DEBUG



	/*

   *	get the lowest two

   *  if counts are equal, use a madenode before a leafnode

   *

   */

	if ( MadeNodeWorkOut < MadeNodeWorkIn )

		{

		if ( NodeWork[NodeWorkOut]->Count < MadeNodeWork[MadeNodeWorkOut]->Count )

			{

			CurNode->Down = NodeWork[NodeWorkOut]; NodeWorkOut++;

			}

		else

			{

			CurNode->Down = MadeNodeWork[MadeNodeWorkOut]; MadeNodeWorkOut++;

			}

		if ( MadeNodeWorkOut < MadeNodeWorkIn )

			{

			if ( NodeWork[NodeWorkOut]->Count < MadeNodeWork[MadeNodeWorkOut]->Count )

				{

				CurNode->Up = NodeWork[NodeWorkOut]; NodeWorkOut++;

				}

			else

				{

				CurNode->Up = MadeNodeWork[MadeNodeWorkOut]; MadeNodeWorkOut++;

				}	

			}

		else

			{

			CurNode->Up = NodeWork[NodeWorkOut]; NodeWorkOut++;

			}

		}

	else

		{

		CurNode->Down = NodeWork[NodeWorkOut]; NodeWorkOut++;

		CurNode->Up 	= NodeWork[NodeWorkOut]; NodeWorkOut++;

		}



	/* ->Down gets the lower valued count & the lower valued character */



	/* make sure lower char is on the Down pointer */

	/* notez: this is only needed in encode ! */

 /*	don't bother swapping the counts, they're not needed anymore */

/*

	if ( CurNode->Down->Char != HUFF2_CODE_BRANCH &&

				CurNode->Up->Char != HUFF2_CODE_BRANCH )

		{

		if ( CurNode->Down->Char > CurNode->Up->Char )

			{

			swapchar = CurNode->Down->Char;

			CurNode->Down->Char = CurNode->Up->Char;

			CurNode->Up->Char = swapchar;

			}

		}

*/



  /*

   *	put them into a MadeNode

   *

   */

	MadeNodeWork[MadeNodeWorkIn] = CurNode;	MadeNodeWorkIn++;

	CurNode->Count = CurNode->Down->Count + CurNode->Up->Count;

	}



/*

 * we stop the prior loop when there are less than 2 nodework symbols left

 * if there is only one left, this loops until it is eaten off

 *

 */

while ( NodeWorkOut < GotNumSymbols && MadeNodeWorkOut < MadeNodeWorkIn )

	{

	CurNode = HI->CodeNodeHunk + HI->CodeNodeHunkI; HI->CodeNodeHunkI++;

	CurNode->Char = HUFF2_CODE_BRANCH;



#ifdef DEBUG

	if ( HI->CodeNodeHunkI >= (NumSymbols*2) )

		{

		BrandoError(" HI->CodeNodeHunkI >= (NumSymbols*2) !");	

		exit(1);

		}

#endif // DEBUG



	if ( NodeWork[NodeWorkOut]->Count < MadeNodeWork[MadeNodeWorkOut]->Count )

		{

		CurNode->Down = NodeWork[NodeWorkOut]; NodeWorkOut++;

		}

	else

		{

		CurNode->Down = MadeNodeWork[MadeNodeWorkOut]; MadeNodeWorkOut++;

		}



	if ( MadeNodeWorkOut < MadeNodeWorkIn )

		{

		if ( NodeWorkOut < GotNumSymbols ) 

			{

			if ( NodeWork[NodeWorkOut]->Count < MadeNodeWork[MadeNodeWorkOut]->Count )

				{

				CurNode->Up = NodeWork[NodeWorkOut]; NodeWorkOut++;

				}

			else

				{

				CurNode->Up = MadeNodeWork[MadeNodeWorkOut]; MadeNodeWorkOut++;

				}

			}

		else

			{

			CurNode->Up = MadeNodeWork[MadeNodeWorkOut]; MadeNodeWorkOut++;

			}

		}

	else

		{

		CurNode->Up = NodeWork[NodeWorkOut]; NodeWorkOut++;

		}



	MadeNodeWork[MadeNodeWorkIn] = CurNode;	MadeNodeWorkIn++;

	CurNode->Count = CurNode->Down->Count + CurNode->Up->Count;

	}



/*

 *	there may still be extras in MadeNodeWork

 *

 */

while ( MadeNodeWorkOut < (MadeNodeWorkIn-1) )

	{

	CurNode = HI->CodeNodeHunk + HI->CodeNodeHunkI; HI->CodeNodeHunkI++;

	CurNode->Char = HUFF2_CODE_BRANCH;

	CurNode->Down = MadeNodeWork[MadeNodeWorkOut]; MadeNodeWorkOut++;

	CurNode->Up = MadeNodeWork[MadeNodeWorkOut]; MadeNodeWorkOut++;



#ifdef DEBUG

	if ( HI->CodeNodeHunkI >= (NumSymbols*2) )

		{

		BrandoError(" HI->CodeNodeHunkI >= (NumSymbols*2) !");	

		exit(1);

		}

#endif // DEBUG



	MadeNodeWork[MadeNodeWorkIn] = CurNode;	MadeNodeWorkIn++;

	CurNode->Count = CurNode->Down->Count + CurNode->Up->Count;

	}



/*

 * grab the base node out

 *

 */

HI->NodeBase = MadeNodeWork[(MadeNodeWorkIn-1)];



if ( HI->NodeBase == NULL ) 

	{

	return(0); /* debugger catch point */

	}



 }

/* end tree-building registered variables */



/* now read out the codelens into an array */

  {

	long * CodeLenTable;

	long * NumCodesOfLen;

	register struct Huff2CodeNode * CurNode;

	register uint32 CurCodeLen;

	register uint32 GotC;

	register uint32 * StackArray;

	register long StackI;

	

	if ( ! HI->StackArray )

		{

		if ( (HI->StackArray = (uint32 *)JE_RAM_ALLOCATE(2*(HI->NumSymbols)*sizeof(uint32))) == NULL )

			return(0);

		}

	

	NumCodesOfLen = HI->NumCodesOfLen;

	CodeLenTable = HI->CodeLenTable; 

	StackArray = HI->StackArray;

	

	StackArray[0] = (uint32) HI->NodeBase;

	StackArray[1] = 0;

	StackI = 2;

	while ( StackI > 0 ) /* $ 15% */

		{

		StackI--;

		CurCodeLen = StackArray[StackI];

		StackI--;

		CurNode = (struct Huff2CodeNode *) StackArray[StackI];

	

	  /*	traverse all Up branches w/o Stack bumping

				remember the Down branches as you go

				once you reach the end of an Up, go back and get the	

				most recent Down & traverse it 

		*/

	

		while ( CurNode )

			{

			GotC = CurNode->Char;

			if ( GotC == HUFF2_CODE_BRANCH )

				{

				CurCodeLen++;		



#ifdef DEBUG

				if ( CurCodeLen > 31 )

					{

					fprintf(stderr,"CodeLen > 31 !");

					return(0);

					}

#endif



				if ( CurNode->Down )

					{

					GotC = CurNode->Down->Char;

					if ( GotC == HUFF2_CODE_BRANCH )

						{

						StackArray[StackI++] = (uint32) CurNode->Down;

						StackArray[StackI++] = CurCodeLen;

	

#ifdef DEBUG

						if ( StackI >= (HI->NumSymbols * 2) )

							{

							BrandoError("Stack usage higher than expected!");

							exit(10);

							}

#endif

	

						}

					else

						{

						CodeLenTable[GotC] = CurCodeLen;

						NumCodesOfLen[CurCodeLen] ++;

						}

					}

	

				CurNode = CurNode->Up;

				}

			else

				{

				CodeLenTable[GotC] = CurCodeLen;

				NumCodesOfLen[CurCodeLen] ++;

				CurNode = NULL;

				}

			}

	

		}

		

	}

/* end codelen-retrieval registered variables */



return(1);

}



/*

 * at this point CodeLenTable & NumCodesOfLen are filled out

 *

 */

jeBoolean Huff2_BuildEncodeTable(struct Huff2Info *HI)

{

uint32 LastCodePrefix;

uint32 * CodePrefixByLen;

uint32 * CharToCodeTable;

long * CodeLenTable;

long * NumCodesOfLen;

long NumSymbols;

long i;

long CurCodeLen;

uint32 CurCode;



if ( HI->GotNumSymbols < 2 ) return(1);



NumSymbols = HI->NumSymbols;



if ( HI->MaxCodeLen == 0 )

	return(0);

if ( HI->MaxCodeLen > 30 )

	return(0);



if ( HI->EnDe_codeTable )

	{

	CharToCodeTable = (uint32 *) HI->EnDe_codeTable;

	memclear((long *)CharToCodeTable,HI->EnDe_codeTableLen);

	}

else

	{

	if ( (CharToCodeTable = (uint32 *)JE_RAM_ALLOCATE_CLEAR(NumSymbols*sizeof(uint32))) == NULL )

		return(0);



	HI->EnDe_codeTable = (void *) CharToCodeTable;

	HI->EnDe_codeTableLen = NumSymbols*sizeof(uint32);

	}



CodePrefixByLen = HI->CodePrefixByLen;

CodeLenTable = HI->CodeLenTable;

NumCodesOfLen = HI->NumCodesOfLen;



LastCodePrefix = 0;

CodePrefixByLen[HI->MinCodeLen] = 0;

for(i=(HI->MinCodeLen);i<(HI->MaxCodeLen);)

	{

	LastCodePrefix = (LastCodePrefix + NumCodesOfLen[i]) << 1;

	i++;

	CodePrefixByLen[i] = LastCodePrefix;

	}



for(i=0;i<NumSymbols;i++)

	{

	CurCodeLen = CodeLenTable[i];

	if ( CurCodeLen > 0 )

		{

		CurCode = CodePrefixByLen[CurCodeLen]++;

		CharToCodeTable[i] = CurCode;

		}

	}



return(1);

}



/*

 * at this point CodeLenTable & NumCodesOfLen are filled out

 *

 */

jeBoolean Huff2_BuildDecodeTable(struct Huff2Info *HI)

{

uint32 BaseCodeByLen[32]; /* I'm lazy! So sue me! */

uint32 LastCodePrefix;

uint32 * CodePrefixByLen;

uint16 * DecodeTable;

long * CodeLenTable;

long * NumCodesOfLen;

long NumSymbols;

long i,CurCodeLen;

uint32 CurCode,PackedCode;

long NumCodesOfLowerLen;



if ( HI->GotNumSymbols < 2 ) return( Huff2_FindDecodeOne(HI) );



NumSymbols = HI->NumSymbols;



if ( HI->MaxCodeLen == 0 )

	return(0);

if ( HI->MaxCodeLen > 30 )

	return(0);



if ( HI->EnDe_codeTable )

	{

	DecodeTable = (uint16 *) HI->EnDe_codeTable;

	memclear((long *)DecodeTable,HI->EnDe_codeTableLen);

	}

else

	{

	HI->EnDe_codeTableLen = 2*NumSymbols*sizeof(uint16);

	if ( (DecodeTable = (uint16 *)JE_RAM_ALLOCATE_CLEAR(HI->EnDe_codeTableLen)) == NULL )

		return(0);



	HI->EnDe_codeTable = (void *) DecodeTable;

	}



CodePrefixByLen = HI->CodePrefixByLen;

CodeLenTable = HI->CodeLenTable;

NumCodesOfLen = HI->NumCodesOfLen;



LastCodePrefix = 0;

NumCodesOfLowerLen = 0;

CodePrefixByLen[HI->MinCodeLen] = 0;

BaseCodeByLen[HI->MinCodeLen] = 0;

for(i=(HI->MinCodeLen);i<(HI->MaxCodeLen);)

	{

	LastCodePrefix = (LastCodePrefix + NumCodesOfLen[i]) << 1;

	NumCodesOfLowerLen += NumCodesOfLen[i];

	i++;

	CodePrefixByLen[i] = LastCodePrefix;

	BaseCodeByLen[i] = LastCodePrefix - NumCodesOfLowerLen;

	}



for(i=0;i<NumSymbols;i++)

	{

	CurCodeLen = CodeLenTable[i];

	if ( CurCodeLen > 0 )

		{

		CurCode = CodePrefixByLen[CurCodeLen]++;

		PackedCode = CurCode - BaseCodeByLen[CurCodeLen];

		DecodeTable[PackedCode] = CurCodeLen;

		DecodeTable[PackedCode+NumSymbols] = i;

		}

	}



for(i=(HI->MinCodeLen);i<=(HI->MaxCodeLen);i++)

	{

	CodePrefixByLen[i] = BaseCodeByLen[i];

	}



return(1);

}



/*

 * The FastDecodeTable is a raw 8 bit table (256 entries)

 *  it is indexed by the next 8 bits of the input bitstream

 *	and the value of the table is :

 *		number of bits used  (max of 8) = 3 bits -> 1byte

 *		number of chars made (max of 4) = 2 bits -> 1 byte

 *		values of chars made (max of 4) = 8 bytes

 * total size = 256*10 = 2560 bytes (not bad!)

 * 	( note that this could be as low as 256*5 = 1280 bytes )

 *

 * note that you must also keep the old decodetable around,

 *	in case the code is longer than 8 bits ( numberofcharsmade == 0 )

 * 

 * <> todo: make this routine take the number of bits of the table

 *	as a parameter

 *

 */



jeBoolean Huff2_BuildFastDecodeTable(struct Huff2Info *HI)

{

struct FastDecodeItem * FastDecodeTable;

uint16 * DecodeTable;

long NumSymbols;

long Huff2CodeLen;

uint32 CurCode,StartCode,Huff2Code,CheckCode,ReadCodeMask,PackedCode;

long DecodeTableLen,FastDecodeTableLen;

long MinCodeLen,NumBitsUsed;

uint16 GotChar;

uint32 * CodePrefixByLen;



if ( HI->GotNumSymbols < 2 ) return( Huff2_FindDecodeOne(HI) );



CodePrefixByLen = HI->CodePrefixByLen;

NumSymbols = HI->NumSymbols;

MinCodeLen = HI->MinCodeLen;



if ( HI->MaxCodeLen == 0 )

	return(0);

if ( HI->MaxCodeLen > 30 )

	return(0);



DecodeTableLen = 2*NumSymbols*sizeof(uint16);

FastDecodeTableLen = 256*sizeof(struct FastDecodeItem);



if ( HI->EnDe_codeTable )

	{

	DecodeTable = (uint16 *)HI->EnDe_codeTable;

	FastDecodeTable = (struct FastDecodeItem *) ( (char *)HI->EnDe_codeTable + DecodeTableLen );

	memclear((long *)DecodeTable,DecodeTableLen);

	memclear((long *)FastDecodeTable,FastDecodeTableLen);

	}

else

	{

	HI->EnDe_codeTableLen = DecodeTableLen + FastDecodeTableLen;

	if ( (HI->EnDe_codeTable = JE_RAM_ALLOCATE_CLEAR(HI->EnDe_codeTableLen)) == NULL )

		return(0);



	DecodeTable = (uint16 *)HI->EnDe_codeTable;

	FastDecodeTable = (struct FastDecodeItem *) ( ((char *)HI->EnDe_codeTable) + DecodeTableLen ); 

	}



/* build the old style table */

if ( ! Huff2_BuildDecodeTable(HI) )

	return(0);



/* now DecodeTable is filled out */



/* step through all the codes & find what chars correspond to them

		when you find a char for a code, propagate it through all codes which

			have that as a prefix

	 keep going until NumBitsFree < Huff2CodeLen  for all entries */

for(StartCode=0;StartCode<255;StartCode++)

	{

	NumBitsUsed = FastDecodeTable[StartCode].NumBitsUsed;

	while ( (8-NumBitsUsed) >= MinCodeLen && FastDecodeTable[StartCode].NumCharsMade < FD_MAXCHARSMADE )

		{

		CurCode = StartCode ;



		/* find char that encodes to curcode */

		Huff2CodeLen = MinCodeLen;

		Huff2Code = ( CurCode >> (8 - NumBitsUsed - Huff2CodeLen) ) & ( (1<<Huff2CodeLen) - 1 ) ;

		ReadCodeMask = 1 << ( 7 - NumBitsUsed - Huff2CodeLen ) ;

		PackedCode = Huff2Code;

		while( DecodeTable[PackedCode] != Huff2CodeLen )

			{

			Huff2Code += Huff2Code;

			if ( CurCode & ReadCodeMask ) Huff2Code++;

			ReadCodeMask >>= 1;

			Huff2CodeLen++;



			if ( ReadCodeMask == 0 )

				goto DoneWithCurCode;



			PackedCode = Huff2Code - CodePrefixByLen[Huff2CodeLen];			

			}



		if ( Huff2CodeLen > (8 - NumBitsUsed) )

			goto DoneWithCurCode;



		GotChar = DecodeTable[PackedCode+NumSymbols];



		/* step through while Huff2Code is the next code

				all occurances of Huff2Code will be contiguous */

		do

			{

			if ( FastDecodeTable[CurCode].NumCharsMade < FD_MAXCHARSMADE )

				{

				FastDecodeTable[CurCode].CharsMade[FastDecodeTable[CurCode].NumCharsMade] = GotChar;

				FastDecodeTable[CurCode].NumCharsMade++;

				FastDecodeTable[CurCode].NumBitsUsed = NumBitsUsed + Huff2CodeLen;

				}

			CurCode ++;

			NumBitsUsed = FastDecodeTable[CurCode].NumBitsUsed;

			if ( Huff2CodeLen > (8-NumBitsUsed) ) break;

			CheckCode = ( CurCode >> (8 - NumBitsUsed - Huff2CodeLen) ) & ( (1<<Huff2CodeLen) - 1 ) ;

			} while ( CheckCode == Huff2Code );



		NumBitsUsed = FastDecodeTable[StartCode].NumBitsUsed;

		}



	DoneWithCurCode: /* see Knuth : "Structured use of Goto" :^> */ 



	continue;



	}



HI->NumCharsWaiting = 0;



return(1);

}



void Huff2_EncodeC(struct Huff2Info *HI,uint16 Symbol)

{

register uint32 CurCode;

register long CurCodeLen;

register struct LBitIOInfo * BII;



if ( HI->GotNumSymbols < 2 ) return;



CurCode 	 = ((uint32 *)HI->EnDe_codeTable)[Symbol];

CurCodeLen = HI->CodeLenTable[Symbol];

BII 			 = HI->BII;



#ifdef DEBUG

if ( CurCodeLen == 0 )

	{

	BrandoError("Got EncodeC for CodeLen == 0 symbol!");

	exit(10);

	}

#endif



LBitIO_WriteBits(BII,CurCode,CurCodeLen);



}



#define FASTDECODE_PAD 6



jeBoolean Huff2_FastDecodeArray(struct Huff2Info *HI,uint8 * Array,long ArrayLen)

{

register uint32 PeekedCode;

register struct FastDecodeItem * FastDecodeTable;

long NumCharsMade;

uint16 * CharsMade;

long NumSymbols;

uint16 * DecodeTable;

uint32 * CodePrefixByLen;

uint32 CurCode,PackedCode;

long CurCodeLen;

jeBoolean bit;

uint8 *CurArrayPtr,*ArrayPtrDone;

LocalLBitIO_Variables();



if ( HI->GotNumSymbols < 2 )

	{

	if ( HI->GotNumSymbols == 0 ) return(0);

	else

		{

		while(ArrayLen--) *Array++ = HI->OneChar;

		}

	return(1);

	}



LocalLBitIO_GetState(HI->BII);

NumSymbols = HI->NumSymbols;

FastDecodeTable = (struct FastDecodeItem *) ( ((char *)HI->EnDe_codeTable) + 2*NumSymbols*sizeof(uint16) );

DecodeTable = (uint16 *)HI->EnDe_codeTable;

CodePrefixByLen = HI->CodePrefixByLen;

CurArrayPtr = Array;

ArrayPtrDone = Array + ArrayLen - FASTDECODE_PAD;



while ( CurArrayPtr < ArrayPtrDone )

	{

	LocalLBitIO_PeekBits(PeekedCode,8);

	

	NumCharsMade = FastDecodeTable[PeekedCode].NumCharsMade;

	if ( NumCharsMade > 0 )

		{

		CurCodeLen = FastDecodeTable[PeekedCode].NumBitsUsed;

		LocalLBitIO_SkipBits(CurCodeLen);

		switch ( NumCharsMade )

			{

			case 1:

				*CurArrayPtr++ = *(FastDecodeTable[PeekedCode].CharsMade);

				break;

			case 2:

				CharsMade = FastDecodeTable[PeekedCode].CharsMade;

				*CurArrayPtr++ = *CharsMade++;

				*CurArrayPtr++ = *CharsMade;

				break;

			case 3:

				CharsMade = FastDecodeTable[PeekedCode].CharsMade;

				*CurArrayPtr++ = *CharsMade++;

				*CurArrayPtr++ = *CharsMade++;

				*CurArrayPtr++ = *CharsMade;

				break;

			case 4:

				CharsMade = FastDecodeTable[PeekedCode].CharsMade;

				*CurArrayPtr++ = *CharsMade++;

				*CurArrayPtr++ = *CharsMade++;

				*CurArrayPtr++ = *CharsMade++;

				*CurArrayPtr++ = *CharsMade;

				break;

			}

		}

	else /* use old decode method, can read 9 bits automatically */

		{

		CurCodeLen = 8;

		CurCode = PeekedCode;

		LocalLBitIO_SkipBits(8);

		PackedCode = CurCode - CodePrefixByLen[CurCodeLen];

		

		/* could read another bit here, but who cares? */	



		while( DecodeTable[PackedCode] != CurCodeLen )

			{

			CurCode += CurCode;

			LocalLBitIO_ReadBit(bit);

			CurCode += bit;

			CurCodeLen++;

		

			PackedCode = CurCode - CodePrefixByLen[CurCodeLen];

			}

		

		*CurArrayPtr++ = DecodeTable[PackedCode+NumSymbols];

		}

	}



LocalLBitIO_PutState(HI->BII);



/* do normal decode for last several to make sure we don't go too far */



ArrayPtrDone += FASTDECODE_PAD;

while ( CurArrayPtr < ArrayPtrDone )

	{

	*CurArrayPtr++ = Huff2_DecodeC(HI);

	}



return(1);

}



jeBoolean Huff2_FindDecodeOne(struct Huff2Info *HI)

{

uint16 i;



for(i=0;i<HI->NumSymbols;i++)

	{

	if ( HI->CodeLenTable[i] > 0 )

		{

		HI->OneChar = i;

		return(1);

		}

	}

return(0);

}



uint16 Huff2_FastDecodeC(struct Huff2Info *HI)

{



if ( HI->GotNumSymbols < 2 ) return(HI->OneChar);



#if FD_MAXCHARSMADE_SUBONE > 0

if ( HI->NumCharsWaiting > 0 )

	{

	HI->NumCharsWaiting--;

	return(HI->CharsWaiting[HI->NumCharsWaiting]);

	}

#endif // FD_MAXCHARSMADE_SUBONE == 0



/* variables not init-ed if there are chars waiting */

 {

struct FastDecodeItem * FastDecodeTable;

uint32 PeekedCode;

struct LBitIOInfo * BII;

long NumSymbols;



NumSymbols = HI->NumSymbols;



FastDecodeTable = (struct FastDecodeItem *) ( ((char *)HI->EnDe_codeTable) + 2*NumSymbols*sizeof(uint16) );

BII = HI->BII;



LBitIO_PeekBits(BII,PeekedCode,8);



if ( FastDecodeTable[PeekedCode].NumCharsMade > 0 )

	{

	LBitIO_SkipBits(BII,FastDecodeTable[PeekedCode].NumBitsUsed);

#if FD_MAXCHARSMADE_SUBONE > 0

	HI->NumCharsWaiting = FastDecodeTable[PeekedCode].NumCharsMade - 1;

	switch ( HI->NumCharsWaiting ) /* !<>! */

		{

		case 0:

			break;

		case 1:

			HI->CharsWaiting[0] = FastDecodeTable[PeekedCode].CharsMade[1];

			break;

		case 2:

			HI->CharsWaiting[1] = FastDecodeTable[PeekedCode].CharsMade[1];

			HI->CharsWaiting[0] = FastDecodeTable[PeekedCode].CharsMade[2];

			break;

		case 3:

			HI->CharsWaiting[2] = FastDecodeTable[PeekedCode].CharsMade[1];

			HI->CharsWaiting[1] = FastDecodeTable[PeekedCode].CharsMade[2];

			HI->CharsWaiting[0] = FastDecodeTable[PeekedCode].CharsMade[3];

			break;

		}

#endif // FD_MAXCHARSMADE_SUBONE == 0

	return( FastDecodeTable[PeekedCode].CharsMade[0] );

	}

else /* use old decode method, can read 9 bits automatically */

	{

	uint16 * DecodeTable;

	uint32 * CodePrefixByLen;

	uint32 CurCode,PackedCode;

	long CurCodeLen;

	jeBoolean bit;

	

	DecodeTable = (uint16 *)HI->EnDe_codeTable;

	CodePrefixByLen = HI->CodePrefixByLen;

	

	CurCodeLen = 8;

	CurCode = PeekedCode;

	LBitIO_SkipBits(BII,8);

	PackedCode = CurCode - CodePrefixByLen[CurCodeLen];



	/* could read another bit here, but who cares? */	



	while( DecodeTable[PackedCode] != CurCodeLen )

		{

		CurCode += CurCode;

		LBitIO_ReadBit(BII,bit);

		CurCode += bit;

		CurCodeLen++;

	

		PackedCode = CurCode - CodePrefixByLen[CurCodeLen];

		}

	

#ifdef DEBUG

	if ( CurCodeLen > HI->MaxCodeLen )

		{

		BrandoError("Got code longer than MaxCodeLen!");

		exit(10);

		}

#endif

	

	return(DecodeTable[PackedCode+NumSymbols]);

	}



 }

/* end variable-space */



}



uint16 Huff2_DecodeC(struct Huff2Info *HI)

{

uint16 * DecodeTable;

long NumSymbols;

uint32 * CodePrefixByLen;

uint32 CurCode,PackedCode;

long CurCodeLen;

struct LBitIOInfo * BII;

jeBoolean bit;



if ( HI->GotNumSymbols < 2 ) return(HI->OneChar);



NumSymbols = HI->NumSymbols;

DecodeTable = (uint16 *) HI->EnDe_codeTable;

CodePrefixByLen = HI->CodePrefixByLen;

BII = HI->BII;



CurCodeLen = HI->MinCodeLen;

LBitIO_ReadBits(BII,CurCode,CurCodeLen);

PackedCode = CurCode;



while( DecodeTable[PackedCode] != CurCodeLen )

	{

	CurCode += CurCode;

	LBitIO_ReadBit(BII,bit);

	CurCode += bit;

	CurCodeLen++;



	PackedCode = CurCode - CodePrefixByLen[CurCodeLen];

	}



#ifdef DEBUG

if ( CurCodeLen > HI->MaxCodeLen )

	{

	BrandoError("Got code longer than MaxCodeLen!");

	exit(10);

	}

#endif



return(DecodeTable[PackedCode+NumSymbols]);

}



/*

 * Scale Counts to [0,MaxVal] 

 *  (brackets indicate the range is "inclusive")

 *

 * a count which was > 0 will not be scaled to 0

 *

 */

void Huff2_ScaleCounts(struct Huff2Info *HI,long * CharCounts,long MaxVal)

{

long MaxCharCount;

long NumSymbols,i;

long OutCharCount;



NumSymbols = HI->NumSymbols;



//get maxcharcount

MaxCharCount = 0;

for(i=0;i<NumSymbols;i++)

	{

	if ( CharCounts[i] > MaxCharCount ) MaxCharCount = CharCounts[i];

	}



//scale counts

if ( MaxCharCount > MaxVal )

	{

	for(i=0;i<NumSymbols;i++)

		{

		OutCharCount = ( (long)CharCounts[i] * MaxVal ) / MaxCharCount;

		if ( OutCharCount > MaxVal ) OutCharCount = MaxVal;

		else if ( CharCounts[i] && ! OutCharCount ) OutCharCount = 1;

		CharCounts[i] = OutCharCount;

		}

	}



if ( HI->MaxCharCount != MaxVal && HI->SortType == HUFF2_SORT_RADIX &&

			HI->SortWork != NULL )

	{

	FreeMem(HI->SortWork,sizeofpointer*(HI->MaxCharCount+1));

	HI->SortWork = NULL;

	}



HI->MaxCharCount = min(MaxCharCount,MaxVal);



}



/*

 * Sets ->MaxCharCount in HI

 *

 */

void Huff2_GetMaxCharCount(struct Huff2Info *HI,long * CharCounts)

{

long MaxCharCount;

long NumSymbols,i;



NumSymbols = HI->NumSymbols;



//get maxcharcount

MaxCharCount = 0;

for(i=0;i<NumSymbols;i++)

	{

	if ( CharCounts[i] > MaxCharCount ) MaxCharCount = CharCounts[i];

	}



if ( HI->MaxCharCount != MaxCharCount && HI->SortType == HUFF2_SORT_RADIX &&

			HI->SortWork != NULL )

	{

	FreeMem(HI->SortWork,sizeofpointer*(HI->MaxCharCount+1));

	HI->SortWork = NULL;

	}



HI->MaxCharCount = MaxCharCount;

}



/*

 * sets MinCodeLen & MaxCodeLen which must be set

 *	for BuildEncodeTable

 *

 */

void Huff2_SetMinMaxCodeLen(struct Huff2Info *HI)

{

long MinCodeLen,MaxCodeLen;



if ( HI->GotNumSymbols < 2 )

	{ HI->MinCodeLen = HI->MaxCodeLen = 1; return; }



MinCodeLen = 1;

while ( HI->NumCodesOfLen[MinCodeLen] == 0 ) MinCodeLen++;

MaxCodeLen = 31;

while ( HI->NumCodesOfLen[MaxCodeLen] == 0 ) MaxCodeLen--;



HI->MaxCodeLen = MaxCodeLen;

HI->MinCodeLen = MinCodeLen;

}



/*

 * Writes codelens out to the BII

 *

 * also sets MinCodeLen & MaxCodeLen which must be set

 *	for BuildEncodeTable

 *

 */

void Huff2_PackCodeLens(struct Huff2Info *HI)

{

long MinCodeLen,MaxCodeLen;

long i,j,GotNumSymbols;

uint8 RunData[32];

long RunLen;

long CurCodeLen;

struct LBitIOInfo * BII;



BII = HI->BII;



#ifdef PACKCODES_TOPSYM

GotNumSymbols = HI->NumSymbols;

while ( HI->CodeLenTable[GotNumSymbols-1] == 0 ) GotNumSymbols--;

if ( (HI->NumSymbols - GotNumSymbols) < 32 )

	{

	LBitIO_WriteBit(BII,0);

	GotNumSymbols = HI->NumSymbols;

	}

else

	{

	LBitIO_WriteBit(BII,1);

	CurCodeLen = intlog2(HI->NumSymbols);

	LBitIO_WriteBits(BII,GotNumSymbols,CurCodeLen);

	}

#else

GotNumSymbols = HI->NumSymbols;

#endif // PACKCODES_TOPSYM



MinCodeLen = 1;

while ( HI->NumCodesOfLen[MinCodeLen] == 0 ) MinCodeLen++;

MaxCodeLen = 31;

while ( HI->NumCodesOfLen[MaxCodeLen] == 0 ) MaxCodeLen--;



HI->MaxCodeLen = MaxCodeLen;

HI->MinCodeLen = MinCodeLen;



if ( MaxCodeLen >= 0xF ) {

	LBitIO_WriteBits(BII,0xF,4);

	LBitIO_WriteBits(BII,MaxCodeLen-0xF,4);

} else {

	LBitIO_WriteBits(BII,MaxCodeLen,4);

}



for(i=0;i<GotNumSymbols;) {

	RunLen = 0;

	while ( HI->CodeLenTable[i] == 0 && RunLen < 32 && i<GotNumSymbols ) {

		RunLen++;

		i++;

	}

	if ( RunLen > 0 ) {

		LBitIO_WriteBit(BII,0);

		LBitIO_WriteBits(BII,(RunLen-1),5);

	}



	RunLen = 0;

	while ( ( HI->CodeLenTable[i] != 0 || HI->CodeLenTable[i+1] != 0 ) && RunLen < 32 && i<GotNumSymbols )

		{

		RunData[RunLen] = HI->CodeLenTable[i];

		RunLen++; i++;

		}



	if ( RunLen > 0 )

		{

		LBitIO_WriteBit(BII,1);

		LBitIO_WriteBits(BII,(RunLen-1),5);



		for(j=0;j<RunLen;j++)

			{

			CurCodeLen = MaxCodeLen - RunData[j];

			while ( CurCodeLen >= 0x7 )

				{

				LBitIO_WriteBits(BII,0x7,3);

				CurCodeLen -= 0x7;

				}

			LBitIO_WriteBits(BII,CurCodeLen,3);

			}

		}

	}



}



/*

 * reads packed codelens to CodeLenTable

 *

 * also sets NumCodesOfLen

 *

 */

void Huff2_UnPackCodeLens(struct Huff2Info *HI)

{

long i,j,GotNumSymbols;

long MinCodeLen,MaxCodeLen,CurCodeLen;

long RunLen,CurCode;

struct LBitIOInfo * BII;

jeBoolean bit;



HI->GotNumSymbols = 0;



memclearFast(HI->CodeLenTable,HI->NumSymbols);

memclearFast(HI->NumCodesOfLen,32);

HI->MinCodeLen = HI->MaxCodeLen = 0;



BII = HI->BII;



#ifdef PACKCODES_TOPSYM

LBitIO_ReadBit(BII,bit);

if ( bit )

	{

	CurCodeLen = intlog2(HI->NumSymbols);

	LBitIO_ReadBits(BII,GotNumSymbols,CurCodeLen);

	}

else

	{

	GotNumSymbols = HI->NumSymbols;

	}

#else

GotNumSymbols = HI->NumSymbols;

#endif // PACKCODES_TOPSYM



LBitIO_ReadBits(BII,CurCode,4);

if ( CurCode == 0xF )

	{

	LBitIO_ReadBits(BII,CurCode,4);

	MaxCodeLen = CurCode + 0xF;

	}

else

	{

	MaxCodeLen = CurCode;

	}

HI->MaxCodeLen = MaxCodeLen;



MinCodeLen = MaxCodeLen;



for(i=0;i<GotNumSymbols; )

	{

	LBitIO_ReadBit(BII,bit);

	LBitIO_ReadBits(BII,RunLen,5);

	RunLen++;

	if ( bit == 0 )

		{

		for(j=0;j<RunLen;j++)

			{

			HI->CodeLenTable[i++] = 0;

			}

		}

	else

		{

		HI->GotNumSymbols += RunLen;

		for(j=0;j<RunLen;j++)

			{

			CurCodeLen = 0;

			LBitIO_ReadBits(BII,CurCode,3);

			while( CurCode == 0x7 )

				{

				CurCodeLen += 0x7;

				LBitIO_ReadBits(BII,CurCode,3);

				}

			CurCodeLen += CurCode;



			CurCodeLen = MaxCodeLen - CurCodeLen;



			HI->CodeLenTable[i++] = CurCodeLen;

			if ( CurCodeLen > 0 )	HI->NumCodesOfLen[CurCodeLen] ++;



			if ( CurCodeLen < MinCodeLen && CurCodeLen > 0 ) MinCodeLen = CurCodeLen;

			}

		}

	}



HI->MinCodeLen = MinCodeLen;

}



/*

 * Writes codelens out to the BII

 *

 *	compresses differences for an earlier huff build

 *	 you must allocate lastcodelens, & set to 0 initially

 *

 * also sets MinCodeLen & MaxCodeLen which must be set

 *	for BuildEncodeTable

 *

 */

void Huff2_PackCodeLens_Delta(struct Huff2Info *HI,long * LastCodeLens)

{

long MinCodeLen,MaxCodeLen;

long i,j,GotNumSymbols;

uint8 RunData[512],RunDataLast[512];

long RunLen;

long CurCodeLen;

struct LBitIOInfo * BII;



BII = HI->BII;



#ifdef PACKCODES_TOPSYM

GotNumSymbols = HI->NumSymbols;

while ( HI->CodeLenTable[GotNumSymbols-1] == 0 ) GotNumSymbols--;

if ( (HI->NumSymbols - GotNumSymbols) < 32 )

	{

	LBitIO_WriteBit(BII,0);

	GotNumSymbols = HI->NumSymbols;

	}

else

	{

	LBitIO_WriteBit(BII,1);

	CurCodeLen = intlog2(HI->NumSymbols);

	LBitIO_WriteBits(BII,GotNumSymbols,CurCodeLen);

	}

#else

GotNumSymbols = HI->NumSymbols;

#endif // PACKCODES_TOPSYM



MinCodeLen = 1;

while ( HI->NumCodesOfLen[MinCodeLen] == 0 ) MinCodeLen++;

MaxCodeLen = 31;

while ( HI->NumCodesOfLen[MaxCodeLen] == 0 ) MaxCodeLen--;



HI->MaxCodeLen = MaxCodeLen;

HI->MinCodeLen = MinCodeLen;



if ( MaxCodeLen >= 0xF )

	{

	LBitIO_WriteBits(BII,0xF,4);

	LBitIO_WriteBits(BII,MaxCodeLen-0xF,4);

	}

else

	{

	LBitIO_WriteBits(BII,MaxCodeLen,4);

	}



for(i=0;i<GotNumSymbols;)

	{

	RunLen = 0;

	while ( ( HI->CodeLenTable[i] - LastCodeLens[i] ) == 0 && i<GotNumSymbols )

		{

		RunLen++;

		i++;

		}

	if ( RunLen >= 0x03 )

		{

		LBitIO_WriteBits(BII,0x03,2);

		RunLen -= 0x3;

		if ( RunLen >= 0x07 )

			{

			long Thresh,Bits;



			LBitIO_WriteBits(BII,0x07,3);

			RunLen -= 0x7;



			Thresh = 0xF; Bits = 4;

			while ( RunLen >= Thresh )

				{

				LBitIO_WriteBits(BII,Thresh,Bits);

				RunLen -= Thresh;

				Thresh += Thresh + 1; Bits++;

				}

			LBitIO_WriteBits(BII,RunLen,Bits);

			}

		else

			{

			LBitIO_WriteBits(BII,RunLen,3);

			}	

		}

	else

		{

		LBitIO_WriteBits(BII,RunLen,2);

		}

	if ( i == GotNumSymbols ) break;



	RunLen = 0;

	while ( ( ( HI->CodeLenTable[i] - LastCodeLens[i] ) != 0 ) && i<GotNumSymbols )

		{

		RunData[RunLen] = HI->CodeLenTable[i];

		RunDataLast[RunLen] = LastCodeLens[i];

		RunLen++; i++;

		if ( RunLen == 512 ) return; /* BAD ! */

		}

	if ( RunLen >= 0x03 )

		{

		j = RunLen;

		LBitIO_WriteBits(BII,0x03,2);

		RunLen -= 0x3;

		if ( RunLen >= 0x07 )

			{

			long Thresh,Bits;



			LBitIO_WriteBits(BII,0x07,3);

			RunLen -= 0x7;



			Thresh = 0xF; Bits = 4;

			while ( RunLen >= Thresh )

				{

				LBitIO_WriteBits(BII,Thresh,Bits);

				RunLen -= Thresh;

				Thresh += Thresh + 1; Bits++;

				}

			LBitIO_WriteBits(BII,RunLen,Bits);

			}

		else

			{

			LBitIO_WriteBits(BII,RunLen,3);

			}	

		RunLen = j;

		}

	else

		{

		LBitIO_WriteBits(BII,RunLen,2);

		}



	if ( RunLen > 0 )

		{

		for(j=0;j<RunLen;j++)

			{

			if ( RunDataLast[j] == 0 )

				{

				CurCodeLen = MaxCodeLen - RunData[j];

				while ( CurCodeLen >= 0x7 )

					{

					LBitIO_WriteBits(BII,0x7,3);

					CurCodeLen -= 0x7;

					}

				LBitIO_WriteBits(BII,CurCodeLen,3);				

				}

			else

				{

				CurCodeLen = RunData[j] - RunDataLast[j];

				if ( CurCodeLen < 0 )

					{

					LBitIO_WriteBit(BII,0);

					CurCodeLen = - (CurCodeLen + 1);

					}

				else

					{

					LBitIO_WriteBit(BII,1);

					CurCodeLen--;

					}

				while ( CurCodeLen > 0 )

					{

					LBitIO_WriteBit(BII,0);

					CurCodeLen --;

					}

				LBitIO_WriteBit(BII,1);

				}

			}

		}

	}



for(i=0;i<HI->NumSymbols;i++)

	{

	LastCodeLens[i] = HI->CodeLenTable[i];

	}



}



/*

 * reads packed codelens to CodeLenTable

 *

 * also sets NumCodesOfLen

 *

 * <> doesn't decode new style of runlen yet

 *

 */

void Huff2_UnPackCodeLens_Delta(struct Huff2Info *HI,long * LastCodeLens)

{

long i,j,GotNumSymbols;

long MinCodeLen,MaxCodeLen,CurCodeLen;

long RunLen,CurCode;

struct LBitIOInfo * BII;

jeBoolean bit;

long sign;



BII = HI->BII;



memclear((long *)HI->NumCodesOfLen,32*sizeof(long));



#ifdef PACKCODES_TOPSYM

LBitIO_ReadBit(BII,bit);

if ( bit )

	{

	CurCodeLen = intlog2(HI->NumSymbols);

	LBitIO_ReadBits(BII,GotNumSymbols,CurCodeLen);

	}

else

	{

	GotNumSymbols = HI->NumSymbols;

	}

#else

GotNumSymbols = HI->NumSymbols;

#endif // PACKCODES_TOPSYM



LBitIO_ReadBits(BII,CurCode,4);

if ( CurCode == 0xF )

	{

	LBitIO_ReadBits(BII,CurCode,4);

	MaxCodeLen = CurCode + 0xF;

	}

else

	{

	MaxCodeLen = CurCode;

	}

HI->MaxCodeLen = MaxCodeLen;



MinCodeLen = MaxCodeLen;



for(i=0;i<GotNumSymbols; )

	{

	LBitIO_ReadBit(BII,bit);

	LBitIO_ReadBits(BII,RunLen,5);

	RunLen++;

	if ( bit == 0 )

		{

		for(j=0;j<RunLen;j++)

			{

			HI->CodeLenTable[i] = LastCodeLens[i]; i++;

			}

		}

	else

		{

		for(j=0;j<RunLen;j++)

			{

			if ( LastCodeLens[i] > 0 )

				{

				LBitIO_ReadBit(BII,bit);

				if ( bit ) sign = -1;

				else sign = 1;

				LBitIO_ReadBit(BII,bit);

				CurCodeLen = 1;

				while( bit == 0 )

					{

					CurCodeLen++;

					LBitIO_ReadBit(BII,bit);

					}



				CurCodeLen = CurCodeLen * sign + LastCodeLens[i];

				}

			else

				{

				CurCodeLen = 0;

				LBitIO_ReadBits(BII,CurCode,3);

				while( CurCode == 0x7 )

					{

					CurCodeLen += 0x7;

					LBitIO_ReadBits(BII,CurCode,3);

					}

				CurCodeLen += CurCode;

	

				CurCodeLen = MaxCodeLen - CurCodeLen;

				}



			HI->CodeLenTable[i++] = CurCodeLen;

			if ( CurCodeLen > 0 )	HI->NumCodesOfLen[CurCodeLen] ++;



			if ( CurCodeLen < MinCodeLen && CurCodeLen > 0 ) MinCodeLen = CurCodeLen;

			}

		}

	}



for(i=0;i<HI->NumSymbols;i++)

	{

	LastCodeLens[i] = HI->CodeLenTable[i];

	}



HI->MinCodeLen = MinCodeLen;

}





/*

 * QuickSort on the NodeWork array

 *  set Huff2QuickSortArray

 *

 */

void Huff2QuickSort(long Left,long Right)

{

if ( (Right - Left) > 1 )

	{

	long i;

		{

		long j;

		long pivot;

		struct Huff2CodeNode *swapper;

		register struct Huff2CodeNode ** Array;



		Array = Huff2QuickSortArray;



		pivot = Array[Right]->Count;

		i = Left-1;

		j = Right;

		for(;;)

			{

			/* could remove i < Right && j > Left checking by putting

				dummy array slots in [-1] and [GotNumSymbols] w/ Counts 0 and LONG_MAX */

			do ++i; while(Array[i]->Count < pivot && i < Right);

			do --j; while(Array[j]->Count > pivot && j > Left);

			if (i >= j) break;

			swapper  = Array[i];

			Array[i] = Array[j];

			Array[j] = swapper;

			}

		swapper  = Array[i];

		Array[i] = Array[Right];

		Array[Right] = swapper;

		}

	Huff2QuickSort(Left,i-1);

	Huff2QuickSort(i+1,Right);

	}

else

	{

	if ( Right > Left )

		{

		if ( Huff2QuickSortArray[Right]->Count < Huff2QuickSortArray[Left]->Count )

			{

			struct Huff2CodeNode *swapper;



			swapper  = Huff2QuickSortArray[Left];

			Huff2QuickSortArray[Left] = Huff2QuickSortArray[Right];

			Huff2QuickSortArray[Right] = swapper;

			}

		}

	}

}



/*

 * Radix sort on the NodeWork

 *	counts must be bounded by [0,MaxCharCount]

 * this is much faster than QuickSort for large NumSymbols

 *

 * I think NumSymbols as small as 256 is still faster here

 *	    Radix = O(256 + 2*NumSymbols)

 *	QuickSort = O(NumSymbols*log2(NumSymbols))

 * bigOs are equal for NumSymbols == 64

 *

 * NOTEZ: uses the ->Up in the codenode structure

 *  			resets ->Up to NULL when its done

 *

 */

jeBoolean  Huff2RadixSort(struct Huff2CodeNode ** BucketArray,

	long MaxCharCount,struct Huff2CodeNode ** Array,long ArraySize)

{

register struct Huff2CodeNode * CurNode;

register long i,j;



memclear((long *)BucketArray,sizeofpointer*(MaxCharCount+1));



/* go backwards so that alphabetic order is preserved */

for(i=(ArraySize-1);i>=0;i--)

	{

	Array[i]->Up = BucketArray[Array[i]->Count];

	BucketArray[Array[i]->Count] = Array[i];

	}



j=0;

for(i=0;i<=MaxCharCount;i++)

	{

	CurNode = BucketArray[i];

	while(CurNode) /* $ 15% */

		{

		Array[j] = CurNode;

		CurNode = CurNode->Up;

		Array[j]->Up = NULL;

		j++;

		}

	}



if ( j != ArraySize )

	{

	return(0);

	}



return(1);

}