1194 lines
43 KiB
C++
1194 lines
43 KiB
C++
/* DEC/CMS REPLACEMENT HISTORY, Element TREES.C */
|
|
/* *1 14-NOV-1996 10:26:31 ANIGBOGU "[113914]Functions to output deflated data using Huffman encoding" */
|
|
/* DEC/CMS REPLACEMENT HISTORY, Element TREES.C */
|
|
/* PRIVATE FILE
|
|
******************************************************************************
|
|
**
|
|
** (c) Copyright Schlumberger Technology Corp., unpublished work, created 1996.
|
|
**
|
|
** This computer program includes Confidential, Proprietary Information and is
|
|
** a Trade Secret of Schlumberger Technology Corp. All use, disclosure, and/or
|
|
** reproduction is prohibited unless authorized in writing by Schlumberger.
|
|
** All Rights Reserved.
|
|
**
|
|
******************************************************************************
|
|
**
|
|
** compress/trees.c
|
|
**
|
|
** PURPOSE
|
|
**
|
|
** Output deflated data using Huffman coding
|
|
**
|
|
** DISCUSSION
|
|
**
|
|
** The PKZIP "deflation" process uses several Huffman trees. The more
|
|
** common source values are represented by shorter bit sequences.
|
|
**
|
|
** Each code tree is stored in the ZIP file in a compressed form
|
|
** which is itself a Huffman encoding of the lengths of
|
|
** all the code strings (in ascending order by source values).
|
|
** The actual code strings are reconstructed from the lengths in
|
|
** the UNZIP process, as described in the "application note"
|
|
** (APPNOTE.TXT) distributed as part of PKWARE's PKZIP program.
|
|
**
|
|
** REFERENCES
|
|
**
|
|
** Lynch, Thomas J.
|
|
** Data Compression: Techniques and Applications, pp. 53-55.
|
|
** Lifetime Learning Publications, 1985. ISBN 0-534-03418-7.
|
|
**
|
|
** Storer, James A.
|
|
** Data Compression: Methods and Theory, pp. 49-50.
|
|
** Computer Science Press, 1988. ISBN 0-7167-8156-5.
|
|
**
|
|
** Sedgewick, R.
|
|
** Algorithms, p290.
|
|
** Addison-Wesley, 1983. ISBN 0-201-06672-6.
|
|
**
|
|
** INTERFACE
|
|
**
|
|
** void InitMatchBuffer(void)
|
|
** Allocate the match buffer, initialize the various tables.
|
|
**
|
|
** void TallyFrequencies(int Dist, int MatchLength, int Level, DeflateParam_t
|
|
** *Defl, CompParam_t *Comp);
|
|
** Save the match info and tally the frequency counts.
|
|
**
|
|
** long FlushBlock(char *buf, ulg stored_len, int Eof,
|
|
** LocalBits_t *Bits, CompParam_t *Comp)
|
|
** Determine the best encoding for the current block: dynamic trees,
|
|
** static trees or store, and output the encoded block to the zip
|
|
** file. Returns the total compressed length for the file so far.
|
|
**
|
|
** SPECIAL REQUIREMENTS & NOTES
|
|
**
|
|
** AUTHOR
|
|
**
|
|
** J. C. Anigbogu
|
|
** Austin Systems Center
|
|
** Nov 1996
|
|
**
|
|
******************************************************************************
|
|
*/
|
|
|
|
#include "comppriv.h"
|
|
|
|
/* ===========================================================================
|
|
* Constants
|
|
*/
|
|
|
|
#define MAX_BITS 15
|
|
/* All codes must not exceed MAX_BITS bits */
|
|
|
|
#define MAX_BL_BITS 7
|
|
/* Bit length codes must not exceed MAX_BL_BITS bits */
|
|
|
|
#define LENGTH_CODES 29
|
|
/* number of length codes, not counting the special END_BLOCK code */
|
|
|
|
#define LITERALS 256
|
|
/* number of literal bytes 0..255 */
|
|
|
|
#define END_BLOCK 256
|
|
/* end of block literal code */
|
|
|
|
#define L_CODES (LITERALS+1+LENGTH_CODES)
|
|
/* number of Literal or Length codes, including the END_BLOCK code */
|
|
|
|
#define D_CODES 30
|
|
/* number of distance codes */
|
|
|
|
#define BL_CODES 19
|
|
/* number of codes used to transfer the bit lengths */
|
|
|
|
/* extra bits for each length code */
|
|
static unsigned ExtraLBits[LENGTH_CODES] =
|
|
{
|
|
0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0
|
|
};
|
|
|
|
/* extra bits for each distance code */
|
|
static unsigned ExtraDBits[D_CODES] =
|
|
{
|
|
0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13
|
|
};
|
|
|
|
/* extra bits for each bit length code */
|
|
static unsigned ExtraBlBits[BL_CODES] =
|
|
{
|
|
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7
|
|
};
|
|
|
|
#define LIT_BUFSIZE 0x8000
|
|
|
|
#ifndef DIST_BUFSIZE
|
|
# define DIST_BUFSIZE LIT_BUFSIZE
|
|
#endif
|
|
/* Sizes of match buffers for literals/lengths and distances. There are
|
|
* 4 reasons for limiting LIT_BUFSIZE to 64K:
|
|
* - frequencies can be kept in 16 bit counters
|
|
* - if compression is not successful for the first block, all input data is
|
|
* still in the window so we can still emit a stored block even when input
|
|
* comes from standard input. (This can also be done for all blocks if
|
|
* LIT_BUFSIZE is not greater than 32K.)
|
|
* - if compression is not successful for a file smaller than 64K, we can
|
|
* even emit a stored file instead of a stored block (saving 5 bytes).
|
|
* - creating new Huffman trees less frequently may not provide fast
|
|
* adaptation to changes in the input data statistics. (Take for
|
|
* example a binary file with poorly compressible code followed by
|
|
* a highly compressible string table.) Smaller buffer sizes give
|
|
* fast adaptation but have of course the overhead of transmitting trees
|
|
* more frequently.
|
|
* - I can't count above 4
|
|
* The current code is general and allows DIST_BUFSIZE < LIT_BUFSIZE (to save
|
|
* memory at the expense of compression). Some optimizations would be possible
|
|
* if we rely on DIST_BUFSIZE == LIT_BUFSIZE.
|
|
*/
|
|
|
|
#define REP_3_6 16
|
|
/* repeat previous bit length 3-6 times (2 bits of repeat count) */
|
|
|
|
#define REPZ_3_10 17
|
|
/* repeat a zero length 3-10 times (3 bits of repeat count) */
|
|
|
|
#define REPZ_11_138 18
|
|
/* repeat a zero length 11-138 times (7 bits of repeat count) */
|
|
|
|
/* ===========================================================================
|
|
* Local data
|
|
*/
|
|
|
|
/* Data structure describing a single value and its code string. */
|
|
typedef struct ValueCodeString
|
|
{
|
|
union
|
|
{
|
|
unsigned short Frequency; /* frequency count */
|
|
unsigned short Code; /* bit string */
|
|
} FrequencyCode;
|
|
union
|
|
{
|
|
unsigned short Father; /* father node in Huffman tree */
|
|
unsigned short Length; /* length of bit string */
|
|
} FatherLength;
|
|
} ValueCodeString_t;
|
|
|
|
#define HEAP_SIZE (2*L_CODES+1)
|
|
/* maximum heap size */
|
|
|
|
static ValueCodeString_t DynLiteralTree[HEAP_SIZE]; /* literal and length tree */
|
|
static ValueCodeString_t DynDistanceTree[2*D_CODES+1]; /* distance tree */
|
|
|
|
static ValueCodeString_t StaticLiteralTree[L_CODES+2];
|
|
/* The static literal tree. Since the bit lengths are imposed, there is no
|
|
* need for the L_CODES extra codes used during heap construction. However
|
|
* The codes 286 and 287 are needed to build a canonical tree (see ct_init
|
|
* below).
|
|
*/
|
|
|
|
static ValueCodeString_t StaticDistanceTree[D_CODES];
|
|
/* The static distance tree. (Actually a trivial tree since all codes use
|
|
* 5 bits.)
|
|
*/
|
|
|
|
static ValueCodeString_t BitLengthsTree[2*BL_CODES+1];
|
|
/* Huffman tree for the bit lengths */
|
|
|
|
typedef struct TreeDesc
|
|
{
|
|
ValueCodeString_t *DynamicTree; /* the dynamic tree */
|
|
ValueCodeString_t *StaticTree; /* corresponding static tree or NULL */
|
|
unsigned int *ExtraBits; /* extra bits for each code or NULL */
|
|
int ExtraBase; /* base index for Extrabits */
|
|
int Elements; /* max number of elements in the tree */
|
|
int MaxLength; /* max bit length for the codes */
|
|
int MaxCode; /* largest code with non zero frequency */
|
|
} TreeDesc_t;
|
|
|
|
static TreeDesc_t LengthDesc =
|
|
{
|
|
DynLiteralTree, StaticLiteralTree, ExtraLBits, LITERALS+1, L_CODES,
|
|
MAX_BITS, 0
|
|
};
|
|
|
|
static TreeDesc_t DistanceDesc =
|
|
{
|
|
DynDistanceTree, StaticDistanceTree, ExtraDBits, 0, D_CODES, MAX_BITS, 0
|
|
};
|
|
|
|
static TreeDesc_t BitLengthsDesc =
|
|
{
|
|
BitLengthsTree, (ValueCodeString_t *)0, ExtraBlBits, 0, BL_CODES, MAX_BL_BITS, 0
|
|
};
|
|
|
|
|
|
static unsigned short BitLengthsCount[MAX_BITS+1];
|
|
/* number of codes at each bit length for an optimal tree */
|
|
|
|
static unsigned char BitLengthsOrder[BL_CODES] =
|
|
{
|
|
16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15
|
|
};
|
|
/* The lengths of the bit length codes are sent in order of decreasing
|
|
* probability, to avoid transmitting the lengths for unused bit length codes.
|
|
*/
|
|
|
|
static unsigned int Heap[2*L_CODES+1]; /* heap used to build the Huffman trees */
|
|
static unsigned int HeapLength; /* number of elements in the heap */
|
|
static unsigned int HeapMax; /* element of largest frequency */
|
|
/* The sons of Heap[n] are Heap[2*n] and Heap[2*n+1]. Heap[0] is not used.
|
|
* The same heap array is used to build all trees.
|
|
*/
|
|
|
|
static unsigned char Depth[2*L_CODES+1];
|
|
/* Depth of each subtree used as tie breaker for trees of equal frequency */
|
|
|
|
static unsigned char LengthCode[MAX_MATCH-MIN_MATCH+1];
|
|
/* length code for each normalized match length (0 == MIN_MATCH) */
|
|
|
|
static unsigned char DistanceCode[512];
|
|
/* distance codes. The first 256 values correspond to the distances
|
|
* 3 .. 258, the last 256 values correspond to the top 8 bits of
|
|
* the 15 bit distances.
|
|
*/
|
|
|
|
static int BaseLength[LENGTH_CODES];
|
|
/* First normalized length for each code (0 = MIN_MATCH) */
|
|
|
|
static unsigned int BaseDistance[D_CODES];
|
|
/* First normalized distance for each code (0 = distance of 1) */
|
|
|
|
/* unsigned char Input[LIT_BUFSIZE]; buffer for literals or lengths */
|
|
|
|
/* unsigned short DistBuffer[DIST_BUFSIZE]; buffer for distances */
|
|
|
|
static unsigned char FlagBuffer[(LIT_BUFSIZE/8)];
|
|
/* FlagBuffer is a bit array distinguishing literals from lengths in
|
|
* Input, thus indicating the presence or absence of a distance.
|
|
*/
|
|
|
|
typedef struct LocalTree
|
|
{
|
|
unsigned int InputIndex; /* running index in Input */
|
|
unsigned int DistIndex; /* running index in DistBuffer */
|
|
unsigned int FlagIndex; /* running index in FlagBuffer */
|
|
unsigned char Flags; /* current flags not yet saved in FlagBuffer */
|
|
unsigned char FlagBit; /* current bit used in Flags */
|
|
unsigned long OptimalLength; /* bit length of current block with optimal trees */
|
|
unsigned long StaticLength; /* bit length of current block with static trees */
|
|
unsigned long CompressedLength; /* total bit length of compressed file */
|
|
unsigned long InputLength; /* total byte length of input file */
|
|
} LocalTree_t;
|
|
|
|
/* InputLength is for debugging only since we can get it by other means. */
|
|
|
|
/* bits are filled in Flags starting at bit 0 (least significant).
|
|
* Note: these flags are overkill in the current code since we don't
|
|
* take advantage of DIST_BUFSIZE == LIT_BUFSIZE.
|
|
*/
|
|
|
|
static LocalTree_t Xtree;
|
|
|
|
/* ===========================================================================
|
|
* Local (static) routines in this file.
|
|
*/
|
|
|
|
static void InitializeBlock(void);
|
|
static void RestoreHeap(ValueCodeString_t *Tree, int Node);
|
|
static void GenerateBitLengths(TreeDesc_t *Desc);
|
|
static void GenerateCodes(ValueCodeString_t *Tree, int MaxCode);
|
|
static void BuildTree(TreeDesc_t *Desc);
|
|
static void ScanTree(ValueCodeString_t *Tree, int MaxCode);
|
|
static void SendTree(ValueCodeString_t *Tree, int MaxCode,
|
|
LocalBits_t *Bits, CompParam_t *Comp);
|
|
static int BuildBitLengthsTree(void);
|
|
static void SendAllTrees(int LCodes, int DCodes, int BlCodes,
|
|
LocalBits_t *Bits, CompParam_t *Comp);
|
|
static void CompressBlock(ValueCodeString_t *LTree, ValueCodeString_t *DTree,
|
|
LocalBits_t *Bits, CompParam_t *Comp);
|
|
|
|
|
|
#define SendCode(c, Tree, Bits, Comp) \
|
|
SendBits(Tree[c].FrequencyCode.Code, Tree[c].FatherLength.Length, Bits, Comp)
|
|
/* Send a code of the given tree. c and Tree must not have side effects */
|
|
|
|
#define DistCode(Dist) \
|
|
((Dist) < 256 ? DistanceCode[Dist] : DistanceCode[256+((Dist)>>7)])
|
|
/* Mapping from a distance to a distance code. dist is the distance - 1 and
|
|
* must not have side effects. DistanceCode[256] and DistanceCode[257] are never
|
|
* used.
|
|
*/
|
|
|
|
/* ===========================================================================
|
|
* Allocate the match buffer, initialize the various tables
|
|
*/
|
|
void
|
|
InitMatchBuffer(
|
|
void
|
|
)
|
|
{
|
|
unsigned int Count; /* iterates over tree elements */
|
|
int Bits; /* bit counter */
|
|
int Length; /* length value */
|
|
unsigned int Code; /* code value */
|
|
unsigned int Dist; /* distance index */
|
|
|
|
Xtree.CompressedLength = Xtree.InputLength = 0L;
|
|
|
|
if (StaticDistanceTree[0].FatherLength.Length != 0)
|
|
return; /* InitMatchBuffer already called */
|
|
|
|
/* Initialize the mapping length (0..255) -> length code (0..28) */
|
|
Length = 0;
|
|
for (Code = 0; Code < LENGTH_CODES-1; Code++)
|
|
{
|
|
BaseLength[Code] = Length;
|
|
for (Count = 0; Count < (unsigned int)(1<<ExtraLBits[Code]); Count++)
|
|
{
|
|
LengthCode[Length++] = (unsigned char)Code;
|
|
}
|
|
}
|
|
Assert (Length == 256, "InitMatchBuffer: Length != 256");
|
|
/* Note that the length 255 (match length 258) can be represented
|
|
* in two different ways: code 284 + 5 bits or code 285, so we
|
|
* overwrite LengthCode[255] to use the best encoding:
|
|
*/
|
|
LengthCode[Length-1] = (unsigned char)Code;
|
|
|
|
/* Initialize the mapping dist (0..32K) -> dist code (0..29) */
|
|
Dist = 0;
|
|
for (Code = 0 ; Code < 16; Code++)
|
|
{
|
|
BaseDistance[Code] = Dist;
|
|
for (Count = 0; Count < (unsigned int)(1<<ExtraDBits[Code]); Count++)
|
|
{
|
|
DistanceCode[Dist++] = (unsigned char)Code;
|
|
}
|
|
}
|
|
Assert (Dist == 256, "InitMatchBuffer: Dist != 256");
|
|
Dist >>= 7; /* from now on, all distances are divided by 128 */
|
|
for ( ; Code < D_CODES; Code++)
|
|
{
|
|
BaseDistance[Code] = Dist << 7;
|
|
for (Count = 0; Count < (unsigned int)(1<<(ExtraDBits[Code]-7)); Count++)
|
|
{
|
|
DistanceCode[256 + Dist++] = (unsigned char)Code;
|
|
}
|
|
}
|
|
Assert (Dist == 256, "InitMatchBuffer: 256+Dist != 512");
|
|
|
|
/* Construct the codes of the static literal tree */
|
|
for (Bits = 0; Bits <= MAX_BITS; Bits++)
|
|
BitLengthsCount[Bits] = 0;
|
|
Count = 0;
|
|
while (Count <= 143)
|
|
{
|
|
StaticLiteralTree[Count++].FatherLength.Length = 8;
|
|
BitLengthsCount[8]++;
|
|
}
|
|
while (Count <= 255)
|
|
{
|
|
StaticLiteralTree[Count++].FatherLength.Length = 9;
|
|
BitLengthsCount[9]++;
|
|
}
|
|
while (Count <= 279)
|
|
{
|
|
StaticLiteralTree[Count++].FatherLength.Length = 7;
|
|
BitLengthsCount[7]++;
|
|
}
|
|
while (Count <= 287)
|
|
{
|
|
StaticLiteralTree[Count++].FatherLength.Length = 8;
|
|
BitLengthsCount[8]++;
|
|
}
|
|
/* Codes 286 and 287 do not exist, but we must include them in the
|
|
* tree construction to get a canonical Huffman tree (longest code
|
|
* all ones)
|
|
*/
|
|
GenerateCodes((ValueCodeString_t *)StaticLiteralTree, L_CODES+1);
|
|
|
|
/* The static distance tree is trivial: */
|
|
for (Count = 0; Count < D_CODES; Count++)
|
|
{
|
|
StaticDistanceTree[Count].FatherLength.Length = 5;
|
|
StaticDistanceTree[Count].FrequencyCode.Code =
|
|
(unsigned short)ReverseBits(Count, 5);
|
|
}
|
|
|
|
/* Initialize the first block of the first file: */
|
|
InitializeBlock();
|
|
}
|
|
|
|
/* ===========================================================================
|
|
* Initialize a new block.
|
|
*/
|
|
static void
|
|
InitializeBlock(
|
|
void
|
|
)
|
|
{
|
|
int Count; /* iterates over tree elements */
|
|
|
|
/* Initialize the trees. */
|
|
for (Count = 0; Count < L_CODES; Count++)
|
|
DynLiteralTree[Count].FrequencyCode.Frequency = 0;
|
|
for (Count = 0; Count < D_CODES; Count++)
|
|
DynDistanceTree[Count].FrequencyCode.Frequency = 0;
|
|
for (Count = 0; Count < BL_CODES; Count++)
|
|
BitLengthsTree[Count].FrequencyCode.Frequency = 0;
|
|
|
|
DynLiteralTree[END_BLOCK].FrequencyCode.Frequency = 1;
|
|
Xtree.OptimalLength = Xtree.StaticLength = 0L;
|
|
Xtree.InputIndex = Xtree.DistIndex = Xtree.FlagIndex = 0;
|
|
Xtree.Flags = 0; Xtree.FlagBit = 1;
|
|
}
|
|
|
|
#define SMALLEST 1
|
|
/* Index within the heap array of least frequent node in the Huffman tree */
|
|
|
|
|
|
/* ===========================================================================
|
|
* Remove the smallest element from the heap and recreate the heap with
|
|
* one less element. Updates Heap and HeapLength.
|
|
*/
|
|
#define RecreateHeap(Tree, Top) \
|
|
{\
|
|
Top = Heap[SMALLEST]; \
|
|
Heap[SMALLEST] = Heap[HeapLength--]; \
|
|
RestoreHeap(Tree, SMALLEST); \
|
|
}
|
|
|
|
/* ===========================================================================
|
|
* Compares to subtrees, using the tree depth as tie breaker when
|
|
* the subtrees have equal frequency. This minimizes the worst case length.
|
|
*/
|
|
#define Smaller(Tree, Tmp1, Tmp2) \
|
|
(Tree[Tmp1].FrequencyCode.Frequency < Tree[Tmp2].FrequencyCode.Frequency || \
|
|
(Tree[Tmp1].FrequencyCode.Frequency == Tree[Tmp2].FrequencyCode.Frequency \
|
|
&& Depth[Tmp1] <= Depth[Tmp2]))
|
|
|
|
/* ===========================================================================
|
|
* Restore the heap property by moving down the tree starting at node Node,
|
|
* exchanging a node with the smallest of its two sons if necessary, stopping
|
|
* when the heap property is re-established (each father smaller than its
|
|
* two sons).
|
|
*/
|
|
static void
|
|
RestoreHeap(
|
|
ValueCodeString_t *Tree, /* the tree to restore */
|
|
int Node /* node to move down */
|
|
)
|
|
{
|
|
unsigned int Father = Heap[Node];
|
|
unsigned int LeftSon = (unsigned int)Node << 1; /* left son of Node */
|
|
while (LeftSon <= HeapLength)
|
|
{
|
|
/* Set LeftSon to the smallest of the two sons: */
|
|
if (LeftSon < HeapLength && (unsigned int)Smaller(Tree, Heap[LeftSon+1], Heap[LeftSon]))
|
|
LeftSon++;
|
|
|
|
/* Exit if Father is smaller than both sons */
|
|
if (Smaller(Tree, Father, Heap[LeftSon]))
|
|
break;
|
|
|
|
/* Exchange Father with the smallest son */
|
|
Heap[Node] = Heap[LeftSon]; Node = (int)LeftSon;
|
|
|
|
/* And continue down the tree, setting LeftSon to the left son of Node */
|
|
LeftSon <<= 1;
|
|
}
|
|
Heap[Node] = Father;
|
|
}
|
|
|
|
/* ===========================================================================
|
|
* Compute the optimal bit lengths for a tree and update the total bit length
|
|
* for the current block.
|
|
* IN assertion: the fields FrequencyCode.Frequency and FatherLength.Father are set, heap[HeapMax] and
|
|
* above are the tree nodes sorted by increasing frequency.
|
|
* OUT assertions: the field len is set to the optimal bit length, the
|
|
* array BitLengthsCount contains the frequencies for each bit length.
|
|
* The length OptimalLength is updated; StaticLength is also updated if stree is
|
|
* not null.
|
|
*/
|
|
static void
|
|
GenerateBitLengths(
|
|
TreeDesc_t *Desc /* the tree descriptor */
|
|
)
|
|
{
|
|
ValueCodeString_t *Tree = Desc->DynamicTree;
|
|
int *Extra = (int *)Desc->ExtraBits;
|
|
int Base = Desc->ExtraBase;
|
|
int MaxCode = Desc->MaxCode;
|
|
int MaxLength = Desc->MaxLength;
|
|
ValueCodeString_t *Stree = Desc->StaticTree;
|
|
unsigned int HeapIndex; /* heap index */
|
|
unsigned int Tmp1, Tmp2; /* iterate over the tree elements */
|
|
int Bits; /* bit length */
|
|
int Xbits; /* extra bits */
|
|
unsigned short Frequency; /* frequency */
|
|
int Overflow = 0; /* number of elements with bit length too large */
|
|
|
|
for (Bits = 0; Bits <= MAX_BITS; Bits++)
|
|
BitLengthsCount[Bits] = 0;
|
|
|
|
/* In a first pass, compute the optimal bit lengths (which may
|
|
* overflow in the case of the bit length tree).
|
|
*/
|
|
Tree[Heap[HeapMax]].FatherLength.Length = 0; /* root of the heap */
|
|
|
|
for (HeapIndex = HeapMax+1; HeapIndex < HEAP_SIZE; HeapIndex++)
|
|
{
|
|
Tmp1 = Heap[HeapIndex];
|
|
Bits = Tree[Tree[Tmp1].FatherLength.Father].FatherLength.Length + 1;
|
|
if (Bits > MaxLength)
|
|
Bits = MaxLength, Overflow++;
|
|
Tree[Tmp1].FatherLength.Length = (unsigned short)Bits;
|
|
/* We overwrite tree[n].Dad which is no longer needed */
|
|
|
|
if (Tmp1 > (unsigned int)MaxCode)
|
|
continue; /* not a leaf node */
|
|
|
|
BitLengthsCount[Bits]++;
|
|
Xbits = 0;
|
|
if (Tmp1 >= (unsigned int)Base)
|
|
Xbits = (int)Extra[Tmp1-(unsigned int)Base];
|
|
Frequency = Tree[Tmp1].FrequencyCode.Frequency;
|
|
Xtree.OptimalLength += (unsigned long)(Frequency * (Bits + Xbits));
|
|
if (Stree)
|
|
Xtree.StaticLength += (unsigned long)(Frequency * (Stree[Tmp1].FatherLength.Length + Xbits));
|
|
}
|
|
if (Overflow == 0)
|
|
return;
|
|
|
|
/* This happens for example on obj2 and pic of the Calgary corpus */
|
|
|
|
/* Find the first bit length which could increase: */
|
|
do
|
|
{
|
|
Bits = MaxLength - 1;
|
|
while (BitLengthsCount[Bits] == 0)
|
|
Bits--;
|
|
BitLengthsCount[Bits]--; /* move one leaf down the tree */
|
|
BitLengthsCount[Bits+1] += 2; /* move one overflow item as its brother */
|
|
BitLengthsCount[MaxLength]--;
|
|
/* The brother of the overflow item also moves one step up,
|
|
* but this does not affect BitLengthsCount[MaxLength]
|
|
*/
|
|
Overflow -= 2;
|
|
} while (Overflow > 0);
|
|
|
|
/* Now recompute all bit lengths, scanning in increasing frequency.
|
|
* h is still equal to HEAP_SIZE. (It is simpler to reconstruct all
|
|
* lengths instead of fixing only the wrong ones. This idea is taken
|
|
* from 'ar' written by Haruhiko Okumura.)
|
|
*/
|
|
for (Bits = MaxLength; Bits != 0; Bits--)
|
|
{
|
|
Tmp1 = BitLengthsCount[Bits];
|
|
while (Tmp1 != 0)
|
|
{
|
|
Tmp2 = Heap[--HeapIndex];
|
|
if (Tmp2 > (unsigned int)MaxCode)
|
|
continue;
|
|
if (Tree[Tmp2].FatherLength.Length != (unsigned int) Bits)
|
|
{
|
|
Xtree.OptimalLength += (unsigned long)((long)Bits -
|
|
(long)Tree[Tmp2].FatherLength.Length)*(long)Tree[Tmp2].FrequencyCode.Frequency;
|
|
Tree[Tmp2].FatherLength.Length = (unsigned short)Bits;
|
|
}
|
|
Tmp1--;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* ===========================================================================
|
|
* Generate the codes for a given tree and bit counts (which need not be
|
|
* optimal).
|
|
* IN assertion: the array BitLengthsCount contains the bit length statistics for
|
|
* the given tree and the field len is set for all tree elements.
|
|
* OUT assertion: the field code is set for all tree elements of non
|
|
* zero code length.
|
|
*/
|
|
static void
|
|
GenerateCodes(
|
|
ValueCodeString_t *Tree, /* the tree to decorate */
|
|
int MaxCode /* largest code with non zero frequency */
|
|
)
|
|
{
|
|
unsigned short NextCode[MAX_BITS+1]; /* next code value for each bit length */
|
|
unsigned short Code = 0; /* running code value */
|
|
int BitIndex; /* bit index */
|
|
int CodeIndex; /* code index */
|
|
|
|
/* The distribution counts are first used to generate the code values
|
|
* without bit reversal.
|
|
*/
|
|
NextCode[0] = 0; /* For lint error 771 */
|
|
for (BitIndex = 1; BitIndex <= MAX_BITS; BitIndex++)
|
|
{
|
|
NextCode[BitIndex] = Code = (unsigned short)((Code + BitLengthsCount[BitIndex-1]) << 1);
|
|
}
|
|
/* Check that the bit counts in BitLengthsCount are consistent. The last code
|
|
* must be all ones.
|
|
*/
|
|
Assert(Code + BitLengthsCount[MAX_BITS]-1 == (1<<MAX_BITS)-1,
|
|
"inconsistent bit counts");
|
|
|
|
for (CodeIndex = 0; CodeIndex <= MaxCode; CodeIndex++)
|
|
{
|
|
int Length = Tree[CodeIndex].FatherLength.Length;
|
|
if (Length == 0)
|
|
continue;
|
|
/* Now reverse the bits */
|
|
Tree[CodeIndex].FrequencyCode.Code = (unsigned short)ReverseBits((unsigned int)NextCode[Length]++, Length);
|
|
}
|
|
}
|
|
|
|
/* ===========================================================================
|
|
* Construct one Huffman tree and assign the code bit strings and lengths.
|
|
* Update the total bit length for the current block.
|
|
* IN assertion: the field FrequencyCode.Frequency is set for all tree elements.
|
|
* OUT assertions: the fields len and code are set to the optimal bit length
|
|
* and corresponding code. The length OptimalLength is updated; StaticLength is
|
|
* also updated if stree is not null. The field MaxCode is set.
|
|
*/
|
|
static void
|
|
BuildTree(
|
|
TreeDesc_t *Desc /* the tree descriptor */
|
|
)
|
|
{
|
|
ValueCodeString_t *Tree = Desc->DynamicTree;
|
|
ValueCodeString_t *Stree = Desc->StaticTree;
|
|
int Elements = Desc->Elements;
|
|
unsigned int Tmp1, Tmp2; /* iterate over heap elements */
|
|
int MaxCode = -1; /* largest code with non zero frequency */
|
|
int Node = Elements; /* next internal node of the tree */
|
|
|
|
/* Construct the initial heap, with least frequent element in
|
|
* Heap[SMALLEST]. The sons of Heap[n] are Heap[2*n] and Heap[2*n+1].
|
|
* Heap[0] is not used.
|
|
*/
|
|
HeapLength = 0;
|
|
HeapMax = HEAP_SIZE;
|
|
|
|
for (Tmp1 = 0; Tmp1 < (unsigned int)Elements; Tmp1++)
|
|
{
|
|
if (Tree[Tmp1].FrequencyCode.Frequency != 0)
|
|
{
|
|
Heap[++HeapLength] = Tmp1;
|
|
MaxCode = (int)Tmp1;
|
|
Depth[Tmp1] = 0;
|
|
}
|
|
else
|
|
{
|
|
Tree[Tmp1].FatherLength.Length = 0;
|
|
}
|
|
}
|
|
|
|
/* The pkzip format requires that at least one distance code exists,
|
|
* and that at least one bit should be sent even if there is only one
|
|
* possible code. So to avoid special checks later on we force at least
|
|
* two codes of non zero frequency.
|
|
*/
|
|
while (HeapLength < 2)
|
|
{
|
|
unsigned int New = Heap[++HeapLength] = (unsigned int)(MaxCode < 2 ? ++MaxCode : 0);
|
|
Tree[New].FrequencyCode.Frequency = 1;
|
|
Depth[New] = 0;
|
|
Xtree.OptimalLength--;
|
|
if (Stree)
|
|
Xtree.StaticLength -= Stree[New].FatherLength.Length;
|
|
/* new is 0 or 1 so it does not have extra bits */
|
|
}
|
|
Desc->MaxCode = MaxCode;
|
|
|
|
/* The elements Heap[HeapLength/2+1 .. HeapLength] are leaves of the tree,
|
|
* establish sub-heaps of increasing lengths:
|
|
*/
|
|
for (Tmp1 = HeapLength/2; Tmp1 >= 1; Tmp1--)
|
|
RestoreHeap(Tree, (int)Tmp1);
|
|
|
|
/* Construct the Huffman tree by repeatedly combining the least two
|
|
* frequent nodes.
|
|
*/
|
|
do
|
|
{
|
|
RecreateHeap(Tree, Tmp1); /* Tmp1 = node of least frequency */
|
|
Tmp2 = Heap[SMALLEST]; /* Tmp2 = node of next least frequency */
|
|
|
|
Heap[--HeapMax] = Tmp1; /* keep the nodes sorted by frequency */
|
|
Heap[--HeapMax] = Tmp2;
|
|
|
|
/* Create a new node father of Tmp1 and Tmp2 */
|
|
Tree[Node].FrequencyCode.Frequency = (unsigned short)(Tree[Tmp1].FrequencyCode.Frequency +
|
|
Tree[Tmp2].FrequencyCode.Frequency);
|
|
Depth[Node] = (unsigned char) (MAX(Depth[Tmp1], Depth[Tmp2]) + 1);
|
|
Tree[Tmp1].FatherLength.Father = Tree[Tmp2].FatherLength.Father = (unsigned short)Node;
|
|
|
|
/* and insert the new node in the Heap */
|
|
Heap[SMALLEST] = (unsigned int)Node++;
|
|
RestoreHeap(Tree, SMALLEST);
|
|
|
|
} while (HeapLength >= 2);
|
|
|
|
Heap[--HeapMax] = Heap[SMALLEST];
|
|
|
|
/* At this point, the fields FrequencyCode.Frequency and FatherLength.Father are set. We can now
|
|
* generate the bit lengths.
|
|
*/
|
|
GenerateBitLengths((TreeDesc_t *)Desc);
|
|
|
|
/* The field len is now set, we can generate the bit codes */
|
|
GenerateCodes ((ValueCodeString_t *)Tree, MaxCode);
|
|
}
|
|
|
|
/* ===========================================================================
|
|
* Scan a literal or distance tree to determine the frequencies of the codes
|
|
* in the bit length tree. Updates OptimalLength to take into account the repeat
|
|
* counts. (The contribution of the bit length codes will be added later
|
|
* during the construction of BitLengthsTree.)
|
|
*/
|
|
static void
|
|
ScanTree(
|
|
ValueCodeString_t *Tree, /* the tree to be scanned */
|
|
int MaxCode /* and its largest code of non zero frequency */
|
|
)
|
|
{
|
|
int Iter; /* iterates over all tree elements */
|
|
int PrevLength = -1; /* last emitted length */
|
|
int CurLength; /* length of current code */
|
|
int NextLength = Tree[0].FatherLength.Length; /* length of next code */
|
|
int Count = 0; /* repeat count of the current code */
|
|
int MaxCount = 7; /* max repeat count */
|
|
int MinCount = 4; /* min repeat count */
|
|
|
|
if (NextLength == 0)
|
|
{
|
|
MaxCount = 138;
|
|
MinCount = 3;
|
|
}
|
|
Tree[MaxCode+1].FatherLength.Length = (unsigned short)0xffff; /* guard */
|
|
|
|
for (Iter = 0; Iter <= MaxCode; Iter++)
|
|
{
|
|
CurLength = NextLength;
|
|
NextLength = Tree[Iter+1].FatherLength.Length;
|
|
if (++Count < MaxCount && CurLength == NextLength)
|
|
continue;
|
|
else if (Count < MinCount)
|
|
BitLengthsTree[CurLength].FrequencyCode.Frequency += (unsigned short)Count;
|
|
else if (CurLength != 0)
|
|
{
|
|
if (CurLength != PrevLength)
|
|
BitLengthsTree[CurLength].FrequencyCode.Frequency++;
|
|
BitLengthsTree[REP_3_6].FrequencyCode.Frequency++;
|
|
}
|
|
else if (Count <= 10)
|
|
BitLengthsTree[REPZ_3_10].FrequencyCode.Frequency++;
|
|
else
|
|
BitLengthsTree[REPZ_11_138].FrequencyCode.Frequency++;
|
|
Count = 0;
|
|
PrevLength = CurLength;
|
|
if (NextLength == 0)
|
|
{
|
|
MaxCount = 13;
|
|
MinCount = 3;
|
|
}
|
|
else if (CurLength == NextLength)
|
|
{
|
|
MaxCount = 6;
|
|
MinCount = 3;
|
|
}
|
|
else
|
|
{
|
|
MaxCount = 7;
|
|
MinCount = 4;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* ===========================================================================
|
|
* Send a literal or distance tree in compressed form, using the codes in
|
|
* BitLengthsTree.
|
|
*/
|
|
static void
|
|
SendTree(
|
|
ValueCodeString_t *Tree, /* the tree to be scanned */
|
|
int MaxCode, /* and its largest code of non zero frequency */
|
|
LocalBits_t *Bits,
|
|
CompParam_t *Comp
|
|
)
|
|
{
|
|
int Iter; /* iterates over all tree elements */
|
|
int PrevLength = -1; /* last emitted length */
|
|
int CurLength; /* length of current code */
|
|
int NextLength = Tree[0].FatherLength.Length; /* length of next code */
|
|
int Count = 0; /* repeat count of the current code */
|
|
int MaxCount = 7; /* max repeat count */
|
|
int MinCount = 4; /* min repeat count */
|
|
|
|
/* tree[MaxCode+1].FatherLength.Length = -1; */ /* guard already set */
|
|
if (NextLength == 0)
|
|
{
|
|
MaxCount = 138;
|
|
MinCount = 3;
|
|
}
|
|
|
|
for (Iter = 0; Iter <= MaxCode; Iter++)
|
|
{
|
|
CurLength = NextLength;
|
|
NextLength = Tree[Iter+1].FatherLength.Length;
|
|
if (++Count < MaxCount && CurLength == NextLength)
|
|
continue;
|
|
else if (Count < MinCount)
|
|
{
|
|
do
|
|
{
|
|
SendCode(CurLength, BitLengthsTree, Bits, Comp);
|
|
} while (--Count != 0);
|
|
}
|
|
else if (CurLength != 0)
|
|
{
|
|
if (CurLength != PrevLength)
|
|
{
|
|
SendCode(CurLength, BitLengthsTree, Bits, Comp);
|
|
Count--;
|
|
}
|
|
Assert(Count >= 3 && Count <= 6, " 3_6?");
|
|
SendCode(REP_3_6, BitLengthsTree, Bits, Comp);
|
|
SendBits(Count-3, 2, Bits, Comp);
|
|
}
|
|
else if (Count <= 10)
|
|
{
|
|
SendCode(REPZ_3_10, BitLengthsTree, Bits, Comp);
|
|
SendBits(Count-3, 3, Bits, Comp);
|
|
|
|
}
|
|
else
|
|
{
|
|
SendCode(REPZ_11_138, BitLengthsTree, Bits, Comp);
|
|
SendBits(Count-11, 7, Bits, Comp);
|
|
}
|
|
Count = 0;
|
|
PrevLength = CurLength;
|
|
if (NextLength == 0)
|
|
{
|
|
MaxCount = 138;
|
|
MinCount = 3;
|
|
}
|
|
else if (CurLength == NextLength)
|
|
{
|
|
MaxCount = 6;
|
|
MinCount = 3;
|
|
}
|
|
else
|
|
{
|
|
MaxCount = 7;
|
|
MinCount = 4;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* ===========================================================================
|
|
* Construct the Huffman tree for the bit lengths and return the index in
|
|
* BitLengthsOrder of the last bit length code to send.
|
|
*/
|
|
static int
|
|
BuildBitLengthsTree(
|
|
void
|
|
)
|
|
{
|
|
int MaxIndex; /* index of last bit length code of non zero FrequencyCode.Frequency */
|
|
|
|
/* Determine the bit length frequencies for literal and distance trees */
|
|
ScanTree((ValueCodeString_t *)DynLiteralTree, LengthDesc.MaxCode);
|
|
ScanTree((ValueCodeString_t *)DynDistanceTree, DistanceDesc.MaxCode);
|
|
|
|
/* Build the bit length tree: */
|
|
BuildTree((TreeDesc_t *)(&BitLengthsDesc));
|
|
/* OptimalLength now includes the length of the tree representations, except
|
|
* the lengths of the bit lengths codes and the 5+5+4 bits for the counts.
|
|
*/
|
|
|
|
/* Determine the number of bit length codes to send. The pkzip format
|
|
* requires that at least 4 bit length codes be sent. (appnote.txt says
|
|
* 3 but the actual value used is 4.)
|
|
*/
|
|
for (MaxIndex = BL_CODES-1; MaxIndex >= 3; MaxIndex--)
|
|
{
|
|
if (BitLengthsTree[BitLengthsOrder[MaxIndex]].FatherLength.Length != 0)
|
|
break;
|
|
}
|
|
/* Update OptimalLength to include the bit length tree and counts */
|
|
Xtree.OptimalLength += (unsigned long)(3*(MaxIndex+1) + 5+5+4);
|
|
|
|
return MaxIndex;
|
|
}
|
|
|
|
/* ===========================================================================
|
|
* Send the header for a block using dynamic Huffman trees: the counts, the
|
|
* lengths of the bit length codes, the literal tree and the distance tree.
|
|
* IN assertion: LCodes >= 257, DCodes >= 1, BlCodes >= 4.
|
|
*/
|
|
static void
|
|
SendAllTrees(
|
|
int LCodes,
|
|
int DCodes,
|
|
int BlCodes, /* number of codes for each tree */
|
|
LocalBits_t *Bits,
|
|
CompParam_t *Comp
|
|
)
|
|
{
|
|
int Rank; /* index in BitLengthsOrder */
|
|
|
|
Assert (LCodes >= 257 && DCodes >= 1 && BlCodes >= 4,
|
|
"not enough codes");
|
|
Assert (LCodes <= L_CODES && DCodes <= D_CODES && BlCodes <= BL_CODES,
|
|
"too many codes");
|
|
|
|
SendBits(LCodes-257, 5, Bits, Comp); /* not +255 as stated in appnote.txt */
|
|
SendBits(DCodes-1, 5, Bits, Comp);
|
|
SendBits(BlCodes-4, 4, Bits, Comp); /* not -3 as stated in appnote.txt */
|
|
for (Rank = 0; Rank < BlCodes; Rank++)
|
|
{
|
|
SendBits(BitLengthsTree[BitLengthsOrder[Rank]].FatherLength.Length, 3, Bits, Comp);
|
|
}
|
|
|
|
SendTree((ValueCodeString_t *)DynLiteralTree, LCodes-1, Bits, Comp);
|
|
/* send the literal tree */
|
|
|
|
SendTree((ValueCodeString_t *)DynDistanceTree, DCodes-1, Bits, Comp); /* send the distance tree */
|
|
}
|
|
|
|
/* ===========================================================================
|
|
* Determine the best encoding for the current block: dynamic trees, static
|
|
* trees or store, and output the encoded block to the zip buffer. This function
|
|
* returns the total compressed length for the data so far.
|
|
*/
|
|
unsigned long
|
|
FlushBlock(
|
|
char *Input, /* input block, or NULL if too old */
|
|
unsigned long StoredLength, /* length of input block */
|
|
int Eof, /* true if this is the last block for a buffer */
|
|
LocalBits_t *Bits,
|
|
CompParam_t *Comp
|
|
)
|
|
{
|
|
unsigned long OptLengthb, StaticLengthb;
|
|
/* OptLength and StaticLength in bytes */
|
|
int MaxIndex; /* index of last bit length code of non zero FrequencyCode.Frequency */
|
|
|
|
FlagBuffer[Xtree.FlagIndex] = Xtree.Flags; /* Save the flags for the last 8 items */
|
|
|
|
/* Construct the literal and distance trees */
|
|
BuildTree((TreeDesc_t *)(&LengthDesc));
|
|
|
|
BuildTree((TreeDesc_t *)(&DistanceDesc));
|
|
/* At this point, OptimalLength and StaticLength are the total bit lengths of
|
|
* the compressed block data, excluding the tree representations.
|
|
*/
|
|
|
|
/* Build the bit length tree for the above two trees, and get the index
|
|
* in BitLengthsOrder of the last bit length code to send.
|
|
*/
|
|
MaxIndex = BuildBitLengthsTree();
|
|
|
|
/* Determine the best encoding. Compute first the block length in bytes */
|
|
OptLengthb = (Xtree.OptimalLength+3+7)>>3;
|
|
StaticLengthb = (Xtree.StaticLength+3+7)>>3;
|
|
Xtree.InputLength += StoredLength; /* for debugging only */
|
|
|
|
if (StaticLengthb <= OptLengthb)
|
|
OptLengthb = StaticLengthb;
|
|
|
|
/* If compression failed and this is the first and last block,
|
|
* the whole buffer is transformed into a stored buffer:
|
|
*/
|
|
|
|
if (StoredLength <= OptLengthb && Eof && Xtree.CompressedLength == 0L)
|
|
{
|
|
/* Since LIT_BUFSIZE <= 2*WSIZE, the input data must be there: */
|
|
if (Input == (char *)0)
|
|
return BLOCK_VANISHED;
|
|
|
|
CopyBlock(Input, (unsigned int)StoredLength, 0, Bits, Comp);
|
|
/* without header */
|
|
Xtree.CompressedLength = StoredLength << 3;
|
|
|
|
}
|
|
else if (StoredLength+4 <= OptLengthb && Input != (char *)0)
|
|
{
|
|
/* 4: two words for the lengths */
|
|
|
|
/* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE.
|
|
* Otherwise we can't have processed more than WSIZE input bytes since
|
|
* the last block flush, because compression would have been
|
|
* successful. If LIT_BUFSIZE <= WSIZE, it is never too late to
|
|
* transform a block into a stored block.
|
|
*/
|
|
SendBits((STORED_BLOCK<<1)+Eof, 3, Bits, Comp); /* send block type */
|
|
Xtree.CompressedLength = (Xtree.CompressedLength + 3 + 7) & ~7L;
|
|
Xtree.CompressedLength += (StoredLength + 4) << 3;
|
|
|
|
CopyBlock(Input, (unsigned int)StoredLength, 1, Bits, Comp); /* with header */
|
|
|
|
}
|
|
else if (StaticLengthb == OptLengthb)
|
|
{
|
|
SendBits((STATIC_TREES<<1)+Eof, 3, Bits, Comp);
|
|
CompressBlock((ValueCodeString_t *)StaticLiteralTree, (ValueCodeString_t *)StaticDistanceTree, Bits,
|
|
Comp);
|
|
Xtree.CompressedLength += 3 + Xtree.StaticLength;
|
|
}
|
|
else
|
|
{
|
|
SendBits((DYN_TREES<<1)+Eof, 3, Bits, Comp);
|
|
SendAllTrees(LengthDesc.MaxCode+1, DistanceDesc.MaxCode+1,
|
|
MaxIndex+1, Bits, Comp);
|
|
CompressBlock((ValueCodeString_t *)DynLiteralTree, (ValueCodeString_t *)DynDistanceTree,
|
|
Bits, Comp);
|
|
Xtree.CompressedLength += 3 + Xtree.OptimalLength;
|
|
}
|
|
Assert (Xtree.CompressedLength == bits_sent, "bad compressed size");
|
|
InitializeBlock();
|
|
|
|
if (Eof)
|
|
{
|
|
Assert (Xtree.InputLength == Comp->InputSize, "bad input size");
|
|
WindupBits(Bits, Comp);
|
|
Xtree.CompressedLength += 7; /* align on byte boundary */
|
|
}
|
|
|
|
return Xtree.CompressedLength >> 3;
|
|
}
|
|
|
|
/* ===========================================================================
|
|
* Save the match info and tally the frequency counts. Return true if
|
|
* the current block must be flushed.
|
|
*/
|
|
int
|
|
TallyFrequencies(
|
|
int Dist, /* distance of matched string */
|
|
int LengthC, /* match length-MIN_MATCH or unmatched char (if dist==0) */
|
|
int Level, /* compression level */
|
|
DeflateParam_t *Defl,
|
|
CompParam_t *Comp
|
|
)
|
|
{
|
|
Comp->Input[Xtree.InputIndex++] = (unsigned char)LengthC;
|
|
if (Dist == 0)
|
|
{
|
|
/* LengthC is the unmatched char */
|
|
DynLiteralTree[LengthC].FrequencyCode.Frequency++;
|
|
}
|
|
else
|
|
{
|
|
/* Here, LengthC is the match length - MIN_MATCH */
|
|
Dist--; /* dist = match distance - 1 */
|
|
Assert((unsigned short)Dist < (unsigned short)MAX_DIST &&
|
|
(unsigned short)LengthC <= (unsigned short)(MAX_MATCH-MIN_MATCH) &&
|
|
(unsigned short)DistCode(Dist) < (unsigned short)D_CODES,
|
|
"TallyFrequencies: bad match");
|
|
|
|
DynLiteralTree[LengthCode[LengthC]+LITERALS+1].FrequencyCode.Frequency++;
|
|
DynDistanceTree[DistCode((unsigned int)Dist)].FrequencyCode.Frequency++;
|
|
|
|
Comp->DistBuffer[Xtree.DistIndex++] = (unsigned short)Dist;
|
|
Xtree.Flags |= Xtree.FlagBit;
|
|
}
|
|
Xtree.FlagBit <<= 1;
|
|
|
|
/* Output the flags if they fill a byte: */
|
|
if ((Xtree.InputIndex & 7) == 0)
|
|
{
|
|
FlagBuffer[Xtree.FlagIndex++] = Xtree.Flags;
|
|
Xtree.Flags = 0;
|
|
Xtree.FlagBit = 1;
|
|
}
|
|
/* Try to guess if it is profitable to stop the current block here */
|
|
if (Level > 2 && (Xtree.InputIndex & 0xfff) == 0)
|
|
{
|
|
/* Compute an upper bound for the compressed length */
|
|
unsigned long OutLength = (unsigned long)Xtree.InputIndex*8L;
|
|
unsigned long InLength = (unsigned long)((long)Defl->StringStart-Defl->BlockStart);
|
|
int DCode;
|
|
for (DCode = 0; DCode < D_CODES; DCode++)
|
|
{
|
|
OutLength += (unsigned long)(DynDistanceTree[DCode].FrequencyCode.Frequency*(5L+ExtraDBits[DCode]));
|
|
}
|
|
OutLength >>= 3;
|
|
|
|
if (Xtree.DistIndex < Xtree.InputIndex/2 && OutLength < InLength/2)
|
|
return 1;
|
|
}
|
|
return (Xtree.InputIndex == LIT_BUFSIZE-1 || Xtree.DistIndex == DIST_BUFSIZE);
|
|
/* We avoid equality with LIT_BUFSIZE because of wraparound at 64K
|
|
* on 16 bit machines and because stored blocks are restricted to
|
|
* 64K-1 bytes.
|
|
*/
|
|
}
|
|
|
|
/* ===========================================================================
|
|
* Send the block data compressed using the given Huffman trees
|
|
*/
|
|
static void
|
|
CompressBlock(
|
|
ValueCodeString_t *LTree, /* literal tree */
|
|
ValueCodeString_t *DTree, /* distance tree */
|
|
LocalBits_t *Bits,
|
|
CompParam_t *Comp
|
|
)
|
|
{
|
|
unsigned int Distance; /* distance of matched string */
|
|
int MatchLength; /* match length or unmatched char (if Distance == 0) */
|
|
unsigned int InputIndex = 0; /* running index in Input */
|
|
unsigned int DistIndex = 0; /* running index in DistBuffer */
|
|
unsigned int FlagIndex = 0; /* running index in FlagBuffer */
|
|
unsigned char Flag = 0; /* current flags */
|
|
unsigned int Code; /* the code to send */
|
|
int Extra; /* number of extra bits to send */
|
|
|
|
if (Xtree.InputIndex != 0)
|
|
do
|
|
{
|
|
if ((InputIndex & 7) == 0)
|
|
Flag = FlagBuffer[FlagIndex++];
|
|
MatchLength = Comp->Input[InputIndex++];
|
|
if ((Flag & 1) == 0)
|
|
{
|
|
SendCode(MatchLength, LTree, Bits, Comp); /* send a literal byte */
|
|
}
|
|
else
|
|
{
|
|
/* Here, MatchLength is the match length - MIN_MATCH */
|
|
Code = LengthCode[MatchLength];
|
|
/* send the length code */
|
|
SendCode(Code + LITERALS + 1, LTree, Bits, Comp);
|
|
Extra = (int)ExtraLBits[Code];
|
|
if (Extra != 0)
|
|
{
|
|
MatchLength -= BaseLength[Code];
|
|
SendBits(MatchLength, Extra, Bits, Comp);
|
|
/* send the extra length bits */
|
|
}
|
|
Distance = Comp->DistBuffer[DistIndex++];
|
|
/* Here, Distance is the match distance - 1 */
|
|
Code = DistCode(Distance);
|
|
Assert (Code < D_CODES, "bad DistCode");
|
|
|
|
/* send the distance code */
|
|
SendCode((int)Code, DTree, Bits, Comp);
|
|
Extra = (int)ExtraDBits[Code];
|
|
if (Extra != 0)
|
|
{
|
|
Distance -= BaseDistance[Code];
|
|
SendBits((int)Distance, Extra, Bits, Comp);
|
|
/* send the extra distance bits */
|
|
}
|
|
} /* literal or match pair ? */
|
|
Flag >>= 1;
|
|
} while (InputIndex < Xtree.InputIndex);
|
|
|
|
SendCode(END_BLOCK, LTree, Bits, Comp);
|
|
}
|