You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
726 lines
28 KiB
726 lines
28 KiB
/* DEC/CMS REPLACEMENT HISTORY, Element DEFLATE.C */
|
|
/* *1 14-NOV-1996 10:26:16 ANIGBOGU "[113914]Data compression functions using the deflate algorithm" */
|
|
/* DEC/CMS REPLACEMENT HISTORY, Element DEFLATE.C */
|
|
/* PRIVATE FILE
|
|
******************************************************************************
|
|
**
|
|
** (c) Copyright Schlumberg.er Technology Cop., 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/deflate.c
|
|
**
|
|
** PURPOSE
|
|
**
|
|
** Compress data using the def.lation algorithm.
|
|
** Identify new text as repetitions of old text within a fixed-
|
|
** length sliding window trailing behind the new text.
|
|
**
|
|
** DISCUSSION
|
|
**
|
|
** The "deflation" process depends on being able to identify portions
|
|
** of the input data which are identical to earlier input (within a
|
|
** sliding window trailing behind the input currently being processed).
|
|
**
|
|
** The most straightforward technique turns out to be the fastest for
|
|
** most input files: try all possible matches and select the longest.
|
|
** The key feature of this algorithm is that insertions into the string
|
|
** dictionary are very simple and thus fast, and deletions are avoided
|
|
** completely. Insertions are performed at each input character, whereas
|
|
** string matches are performed only when the previous match ends. So it
|
|
** is preferable to spend more time in matches to allow very fast string
|
|
** insertions and avoid deletions. The matching algorithm for small
|
|
** strings is inspired from that of Rabin & Karp. A brute force approach
|
|
** is used to find longer strings when a small match has been found.
|
|
** A similar algorithm is used in comic (by Jan-Mark Wams) and freeze
|
|
** (by Leonid Broukhis).
|
|
** A previous version of this file used a more sophisticated algorithm
|
|
** (by Fiala and Greene) which is guaranteed to run in linear amortized
|
|
** time, but has a larger average cost, uses more memory and is patented.
|
|
** However the F&G algorithm may be faster for some highly redundant
|
|
** data if the parameter MaxChainLength (described below) is too large.
|
|
**
|
|
** ACKNOWLEDGEMENTS
|
|
**
|
|
** The idea of lazy evaluation of matches is due to Jan-Mark Wams, and
|
|
** I found it in 'freeze' written by Leonid Broukhis.
|
|
**
|
|
** REFERENCES
|
|
**
|
|
** APPNOTE.TXT documentation file in PKZIP 1.93a distribution.
|
|
**
|
|
** A description of the Rabin and .Karp algorithm is given in the book
|
|
** "Algorithms" by R. Sedgewick, Addison-Wesley, p252.
|
|
**
|
|
** Fiala,E.R., and Greene,D.H.
|
|
** Data Compression with Finite Windows, Comm.ACM, 32,4 (1989) 490-595
|
|
**
|
|
** INTERFACE
|
|
**
|
|
** int InitLongestMatch(int PackLevel, unsigned short *flags, DeflateParam_t
|
|
** *Defl, LocalDef_t *Deflt, CompParam_t *Comp)
|
|
** Initialize the "longest match" routines for a new buffer
|
|
**
|
|
** unsigned long Deflate(int Level, LocalBits_t *Bits, DeflateParam_t *Defl,
|
|
** LocalDef_t *Deflt, CompParam_t *Comp)
|
|
** Processes a new input buffer and return its compressed length. Sets
|
|
** the compressed length, crc, deflate flags and internal buffer
|
|
** attributes.
|
|
** AUTHOR
|
|
**
|
|
** J. C. Anigbogu
|
|
** Austin Systems Center
|
|
** Nov 1996
|
|
**
|
|
******************************************************************************
|
|
*/
|
|
|
|
#include "comppriv.h"
|
|
|
|
/* ===========================================================================
|
|
* Configuration parameters
|
|
*/
|
|
|
|
#ifndef HASH_BITS
|
|
#define HASH_BITS 15
|
|
#endif
|
|
|
|
#define HASH_SIZE (unsigned int)(1<<HASH_BITS)
|
|
#define HASH_MASK (HASH_SIZE-1)
|
|
#define WMASK (WSIZE-1)
|
|
/* HASH_SIZE and WSIZE must be powers of two */
|
|
|
|
#define NIL 0
|
|
/* Tail of hash chains */
|
|
|
|
#define FAST 4
|
|
#define SLOW 2
|
|
/* speed options for the general purpose bit flag */
|
|
|
|
#ifndef TOO_FAR
|
|
#define TOO_FAR 4096
|
|
#endif
|
|
/* Matches of length 3 are discarded if their distance exceeds TOO_FAR */
|
|
|
|
/* ===========================================================================
|
|
* Local data used by the "longest match" routines.
|
|
*/
|
|
|
|
typedef unsigned short Pos;
|
|
typedef unsigned int IPos;
|
|
/* A Pos is an index in the character window. We use short instead of int to
|
|
* save space in the various tables. IPos is used only for parameter passing.
|
|
*/
|
|
|
|
/* unsigned char Window[2L*WSIZE]; */
|
|
/* Sliding window. Input bytes are read into the second half of the window,
|
|
* and moved to the first half later to keep a dictionary of at least WSIZE
|
|
* bytes. With this organization, matches are limited to a distance of
|
|
* WSIZE-MAX_MATCH bytes, but this ensures that IO is always
|
|
* performed with a length multiple of the block size.
|
|
*/
|
|
|
|
/* Pos HashLink[WSIZE]; */
|
|
/* Link to older string with same hash index. To limit the size of this
|
|
* array to 64K, this link is maintained only for the last 32K strings.
|
|
* An index in this array is thus a window index modulo 32K.
|
|
*/
|
|
|
|
/* Pos head[1<<HASH_BITS]; */
|
|
/* Heads of the hash chains or NIL. */
|
|
|
|
#define H_SHIFT ((HASH_BITS+MIN_MATCH-1)/MIN_MATCH)
|
|
/* Number of bits by which ins_h and del_h must be shifted at each
|
|
* input step. It must be such that after MIN_MATCH steps, the oldest
|
|
* byte no longer takes part in the hash key, that is:
|
|
* H_SHIFT * MIN_MATCH >= HASH_BITS
|
|
*/
|
|
|
|
typedef struct Configuration
|
|
{
|
|
unsigned short GoodLength; /* reduce lazy search above this match length */
|
|
unsigned short MaxLazy; /* do not perform lazy search above this match length */
|
|
unsigned short NiceLength; /* quit search above this match length */
|
|
unsigned short MaxChain;
|
|
} Configuration_t;
|
|
|
|
static Configuration_t ConfigTable[10] =
|
|
{
|
|
/* good lazy nice chain */
|
|
/* 0 */
|
|
{
|
|
0, 0, 0, 0
|
|
}, /* store only */
|
|
/* 1 */
|
|
{
|
|
4, 4, 8, 4
|
|
}, /* maximum speed, no lazy matches */
|
|
/* 2 */
|
|
{
|
|
4, 5, 16, 8
|
|
},
|
|
/* 3 */
|
|
{
|
|
4, 6, 32, 32
|
|
},
|
|
/* 4 */
|
|
{
|
|
4, 4, 16, 16
|
|
}, /* lazy matches */
|
|
/* 5 */
|
|
{
|
|
8, 16, 32, 32
|
|
},
|
|
/* 6 */
|
|
{
|
|
8, 16, 128, 128
|
|
},
|
|
/* 7 */
|
|
{
|
|
8, 32, 128, 256
|
|
},
|
|
/* 8 */
|
|
{
|
|
32, 128, 258, 1024
|
|
},
|
|
/* 9 */
|
|
{
|
|
32, 258, 258, 4096
|
|
}
|
|
}; /* maximum compression */
|
|
|
|
/* Note: the Deflate() code requires max_lazy >= MIN_ATCH and max_chain >= 4
|
|
* For DeflateFast() (levels <= 3) good is ignored and lazy has a different
|
|
* meaning.
|
|
*/
|
|
|
|
/* ===========================================================================
|
|
* Prototypes for local functions.
|
|
*/
|
|
static void FillWindow(DeflateParam_t *Defl, LocalDef_t *Deflt,
|
|
CompParam_t *Comp);
|
|
static unsigned long DeflateFast(int Level, LocalBits_t *Bits, DeflateParam_t *Defl,
|
|
LocalDef_t *Deflt, CompParam_t *Comp);
|
|
|
|
int LongestMatch(IPos CurMatch, DeflateParam_t *Defl, CompParam_t *Comp);
|
|
|
|
|
|
/* ===========================================================================
|
|
* Update a hash value with the given input byte
|
|
* IN assertion: all calls to to UPDATE_HASH are made with consecutive
|
|
* input characters, so that a running hash key can be computed from the
|
|
* previous key instead of complete recalculation each time.
|
|
*/
|
|
#define UPDATE_HASH(h,c) (h = (((h)<<H_SHIFT) ^ (c)) & HASH_MASK)
|
|
|
|
/* ===========================================================================
|
|
* Insert string s in the dictionary and set match_head to the previous head
|
|
* of the hash chain (the most recent string with same hash key). Return
|
|
* the previous length of the hash chain.
|
|
* IN assertion: all calls to to INSERT_STRING are made with consecutive
|
|
* input characters and the first MIN_MATCH bytes of String are valid
|
|
* (except for the last MIN_MATCH-1 bytes of the input file).
|
|
*/
|
|
#define INSERT_STRING(s, MatchHead, h, Window, HashLink, Head) \
|
|
(UPDATE_HASH(h, Window[(int)(s) + MIN_MATCH-1]), \
|
|
HashLink[(int)(s) & WMASK] = Head[h], \
|
|
MatchHead = (unsigned int)Head[h], \
|
|
Head[h] = (unsigned short)(s))
|
|
|
|
/* ===========================================================================
|
|
* Initialize the "longest match" routines for new data
|
|
*/
|
|
CompressStatus_t
|
|
InitLongestMatch(
|
|
int PackLevel, /* 0: store, 1: best speed, 9: best compression */
|
|
unsigned short *Flags, /* general purpose bit flag */
|
|
DeflateParam_t *Defl,
|
|
LocalDef_t *Deflt,
|
|
CompParam_t *Comp
|
|
)
|
|
{
|
|
unsigned int Counter;
|
|
|
|
if (PackLevel < 1 || PackLevel > 9)
|
|
return BAD_COMPRESSION_LEVEL;
|
|
|
|
Deflt->CompLevel = PackLevel;
|
|
|
|
/* Initialize the hash table. */
|
|
|
|
memzero((char *)(Comp->HashLink+WSIZE), HASH_SIZE*sizeof(*(Comp->HashLink+WSIZE)));
|
|
|
|
/* HashLink will be initialized on the fly */
|
|
|
|
/* Set the default configuration parameters: */
|
|
|
|
Defl->MaxLazyMatch = ConfigTable[PackLevel].MaxLazy;
|
|
Defl->GoodMatch = ConfigTable[PackLevel].GoodLength;
|
|
Defl->NiceMatch = ConfigTable[PackLevel].NiceLength;
|
|
Defl->MaxChainLength = ConfigTable[PackLevel].MaxChain;
|
|
|
|
Defl->MatchStart = WSIZE;
|
|
if (PackLevel == 1)
|
|
*Flags |= FAST;
|
|
else if (PackLevel == 9)
|
|
*Flags |= SLOW;
|
|
|
|
/* ??? reduce MaxChainLength for binary data */
|
|
|
|
Defl->StringStart = 0;
|
|
Defl->BlockStart = 0L;
|
|
Defl->PrevLength = 0;
|
|
Defl->MatchStart = 0;
|
|
|
|
Deflt->Lookahead = (unsigned int)ReadBuffer((char *)Comp->Window,
|
|
(unsigned int)(sizeof(int) <= 2 ? WSIZE : 2*WSIZE), Comp);
|
|
|
|
if (Deflt->Lookahead == 0 || Deflt->Lookahead == (unsigned int)EOF)
|
|
{
|
|
Deflt->EndOfInput = 1;
|
|
Deflt->Lookahead = 0;
|
|
return COMPRESS_OK;
|
|
}
|
|
Deflt->EndOfInput = 0;
|
|
/* Make sure that we always have enough lookahead. */
|
|
while (Deflt->Lookahead < MIN_LOOKAHEAD && !Deflt->EndOfInput)
|
|
FillWindow(Defl, Deflt, Comp);
|
|
|
|
Deflt->HashIndex = 0;
|
|
for (Counter=0; Counter<MIN_MATCH-1; Counter++)
|
|
UPDATE_HASH(Deflt->HashIndex, Comp->Window[Counter]);
|
|
/* If Lookahead < MIN_MATCH, Deflt->HashIndex is garbage, but this is
|
|
* not important since only literal bytes will be emitted.
|
|
*/
|
|
return COMPRESS_OK;
|
|
}
|
|
|
|
/* ===========================================================================
|
|
* Set match_start to the longest match starting at the given string and
|
|
* return its length. Matches shorter or equal to PrevLength are discarded,
|
|
* in which case the result is equal to PrevLength and MatchStart is
|
|
* garbage.
|
|
* IN assertions: CurMatch is the head of the hash chain for the current
|
|
* string (StringStart) and its distance is <= MAX_DIST, and PrevLength >= 1
|
|
*/
|
|
|
|
int
|
|
LongestMatch(
|
|
IPos CurMatch, /* current match */
|
|
DeflateParam_t *Defl,
|
|
CompParam_t *Comp
|
|
)
|
|
{
|
|
unsigned int ChainLength = Defl->MaxChainLength; /* max hash chain length */
|
|
unsigned char *Scan = Comp->Window + Defl->StringStart; /* current string */
|
|
unsigned char *Match; /* matched string */
|
|
int Length; /* length of current match */
|
|
int BestLength = (int)Defl->PrevLength; /* best match length so far */
|
|
IPos Limit = Defl->StringStart > (IPos)MAX_DIST ? Defl->StringStart - (IPos)MAX_DIST : NIL;
|
|
/* Stop when CurMatch becomes <= Limit. To simplify the code,
|
|
* we prevent matches with the string of window index 0.
|
|
*/
|
|
|
|
/* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.
|
|
* It is easy to get rid of this optimization if necessary.
|
|
*/
|
|
#if HASH_BITS < 8 || MAX_MATCH != 258
|
|
error: Code too clever
|
|
#endif
|
|
|
|
unsigned char *Strend = Comp->Window + Defl->StringStart + MAX_MATCH;
|
|
unsigned char ScanEnd1 = Scan[BestLength-1];
|
|
unsigned char ScanEnd = Scan[BestLength];
|
|
|
|
/* Do not waste too much time if we already have a good match: */
|
|
if (Defl->PrevLength >= Defl->GoodMatch)
|
|
{
|
|
ChainLength >>= 2;
|
|
}
|
|
Assert(Defl->StringStart <= Comp->WindowSize - MIN_LOOKAHEAD, "insufficient lookahead");
|
|
|
|
do
|
|
{
|
|
Assert(CurMatch < Defl->StringStart, "no future");
|
|
Match = Comp->Window + CurMatch;
|
|
|
|
/* Skip to next match if the match length cannot increase
|
|
* or if the match length is less than 2:
|
|
*/
|
|
|
|
if (Match[BestLength] != ScanEnd || Match[BestLength-1] != ScanEnd1 ||
|
|
*Match != *Scan || *++Match != Scan[1])
|
|
continue;
|
|
|
|
/* The check at BestLength-1 can be removed because it will be made
|
|
* again later. (This heuristic is not always a win.)
|
|
* It is not necessary to compare Scan[2] and Match[2] since they
|
|
* are always equal when the other bytes match, given that
|
|
* the hash keys are equal and that HASH_BITS >= 8.
|
|
*/
|
|
Scan += 2;
|
|
Match++;
|
|
|
|
/* We check for insufficient lookahead only every 8th comparison;
|
|
* the 256th check will be made at StringStart+258.
|
|
*/
|
|
do
|
|
{
|
|
} while (*++Scan == *++Match && *++Scan == *++Match &&
|
|
*++Scan == *++Match && *++Scan == *++Match &&
|
|
*++Scan == *++Match && *++Scan == *++Match &&
|
|
*++Scan == *++Match && *++Scan == *++Match &&
|
|
Scan < Strend);
|
|
|
|
Length = MAX_MATCH - (int)(Strend - Scan);
|
|
Scan = Strend - MAX_MATCH;
|
|
|
|
if (Length > BestLength)
|
|
{
|
|
Defl->MatchStart = CurMatch;
|
|
BestLength = Length;
|
|
if (Length >= Defl->NiceMatch)
|
|
break;
|
|
ScanEnd1 = Scan[BestLength-1];
|
|
ScanEnd = Scan[BestLength];
|
|
}
|
|
} while ((CurMatch = Comp->HashLink[CurMatch & WMASK]) > Limit
|
|
&& --ChainLength != 0);
|
|
|
|
return BestLength;
|
|
}
|
|
|
|
/* ===========================================================================
|
|
* Fill the window when the Lookahead becomes insufficient.
|
|
* Updates StringStart and Lookahead, and sets EndOfInput if end of input buffer.
|
|
* IN assertion: Lookahead < MIN_LOOKAHEAD && StringStart + Lookahead > 0
|
|
* OUT assertions: at least one byte has been read, or EndOfInput is set;
|
|
* buffer reads are performed for at least two bytes
|
|
*/
|
|
static void
|
|
FillWindow(
|
|
DeflateParam_t *Defl,
|
|
LocalDef_t *Deflt,
|
|
CompParam_t *Comp
|
|
)
|
|
{
|
|
unsigned int Tmp1, Tmp2;
|
|
unsigned int More = (unsigned int)(Comp->WindowSize -
|
|
(unsigned long)Deflt->Lookahead -
|
|
(unsigned long)Defl->StringStart);
|
|
/* Amount of free space at the end of the window. */
|
|
|
|
/* If the window is almost full and there is insufficient lookahead,
|
|
* move the upper half to the lower one to make room in the upper half.
|
|
*/
|
|
if (More == (unsigned int)EOF)
|
|
{
|
|
/* Very unlikely, but possible on 16 bit machine if StringStart == 0
|
|
* and lookahead == 1 (input done one byte at a time)
|
|
*/
|
|
More--;
|
|
}
|
|
else if (Defl->StringStart >= (unsigned int)(WSIZE+MAX_DIST))
|
|
{
|
|
/* By the IN assertion, the window is not empty so we can't confuse
|
|
* More == 0 with More == 64K on a 16 bit machine.
|
|
*/
|
|
Assert(Comp->WindowSize == (unsigned long)(2*WSIZE), "no sliding");
|
|
|
|
memcpy((char *)Comp->Window, (char *)Comp->Window+WSIZE, WSIZE);
|
|
Defl->MatchStart -= (unsigned int)WSIZE;
|
|
Defl->StringStart -= (unsigned int)WSIZE;
|
|
/* we now have StringStart >= MAX_DIST: */
|
|
|
|
Defl->BlockStart -= (long) WSIZE;
|
|
|
|
for (Tmp1 = 0; Tmp1 < (unsigned int)HASH_SIZE; Tmp1++)
|
|
{
|
|
Tmp2 = (Comp->HashLink+WSIZE)[Tmp1];
|
|
(Comp->HashLink+WSIZE)[Tmp1] = (Pos)(Tmp2 >= (unsigned int)WSIZE ?
|
|
Tmp2-(unsigned int)WSIZE : NIL);
|
|
}
|
|
|
|
for (Tmp1 = 0; Tmp1 < WSIZE; Tmp1++)
|
|
{
|
|
Tmp2 = Comp->HashLink[Tmp1];
|
|
Comp->HashLink[Tmp1] = (Pos)(Tmp2 >= WSIZE ? Tmp2-WSIZE : NIL);
|
|
/* If n is not on any hash chain, HashLink[n] is garbage but
|
|
* its value will never be used.
|
|
*/
|
|
}
|
|
More += (unsigned int)WSIZE;
|
|
}
|
|
/* At this point, more >= 2 */
|
|
|
|
if (!Deflt->EndOfInput)
|
|
{
|
|
Tmp1 = (unsigned int)ReadBuffer((char*)Comp->Window + Defl->StringStart +
|
|
Deflt->Lookahead, More, Comp);
|
|
if (Tmp1 == 0 || Tmp1 == (unsigned int)EOF)
|
|
Deflt->EndOfInput = 1;
|
|
else
|
|
Deflt->Lookahead += Tmp1;
|
|
}
|
|
}
|
|
|
|
/* ===========================================================================
|
|
* Flush the current block, with given end-of-file flag.
|
|
* IN assertion: StringStart is set to the end of the current match.
|
|
*/
|
|
#define FLUSH_BLOCK(Eof, Bits, Defl, Comp) \
|
|
FlushBlock(Defl->BlockStart >= 0L ? (char *)&Comp->Window[(unsigned int)Defl->BlockStart] : \
|
|
(char *)NULL, (unsigned long)((long)Defl->StringStart - Defl->BlockStart), \
|
|
Eof, Bits, Comp)
|
|
|
|
/* ===========================================================================
|
|
* Processes a new input buffer and return its compressed length. This
|
|
* function does not perform lazy evaluation of matches and inserts
|
|
* new strings in the dictionary only for umatched strings or for short
|
|
* matches. It is used only for the fast compression options.
|
|
*/
|
|
static unsigned long
|
|
DeflateFast(
|
|
int Level,
|
|
LocalBits_t *Bits,
|
|
DeflateParam_t *Defl,
|
|
LocalDef_t *Deflt,
|
|
CompParam_t *Comp
|
|
)
|
|
{
|
|
IPos HashHead; /* head of the hash chain */
|
|
int Flush; /* set if current block must be flushed */
|
|
unsigned int MatchLength = 0; /* length of best match */
|
|
|
|
Defl->PrevLength = MIN_MATCH-1;
|
|
while (Deflt->Lookahead != 0)
|
|
{
|
|
/* Insert the string Window[StringStart .. StringStart+2] in the
|
|
* dictionary, and set hash_head to the head of the hash chain:
|
|
*/
|
|
INSERT_STRING(Defl->StringStart, HashHead, Deflt->HashIndex, Comp->Window,
|
|
Comp->HashLink, (Comp->HashLink + WSIZE));
|
|
|
|
/* Find the longest match, discarding those <= PrevLength.
|
|
* At this point we have always MatchLength < MIN_MATCH
|
|
*/
|
|
if (HashHead != NIL && Defl->StringStart - HashHead <= MAX_DIST)
|
|
{
|
|
/* To simplify the code, we prevent matches with the string
|
|
* of window index 0 (in particular we have to avoid a match
|
|
* of the string with itself at the start of the input buffer).
|
|
*/
|
|
MatchLength = (unsigned int)LongestMatch(HashHead, Defl, Comp);
|
|
/* longest_match() sets match_start */
|
|
if (MatchLength > Deflt->Lookahead)
|
|
MatchLength = Deflt->Lookahead;
|
|
}
|
|
|
|
if (MatchLength >= MIN_MATCH)
|
|
{
|
|
Flush = TallyFrequencies((int)(Defl->StringStart-Defl->MatchStart),
|
|
(int)MatchLength - MIN_MATCH, Level, Defl, Comp);
|
|
|
|
Deflt->Lookahead -= MatchLength;
|
|
|
|
/* Insert new strings in the hash table only if the match length
|
|
* is not greater than this length. This saves time but degrades
|
|
* compression. MaxLazyMatch is used only for compression levels <= 3.
|
|
*/
|
|
|
|
if (MatchLength <= Defl->MaxLazyMatch)
|
|
{
|
|
MatchLength--; /* string at StringStart already in hash table */
|
|
do
|
|
{
|
|
Defl->StringStart++;
|
|
INSERT_STRING(Defl->StringStart, HashHead, Deflt->HashIndex,
|
|
Comp->Window, Comp->HashLink,
|
|
(Comp->HashLink + WSIZE));
|
|
/* StringStart never exceeds WSIZE-MAX_MATCH, so there are
|
|
* always MIN_MATCH bytes ahead. If lookahead < MIN_MATCH
|
|
* these bytes are garbage, but it does not matter since
|
|
* the next lookahead bytes will be emitted as literals.
|
|
*/
|
|
} while (--MatchLength != 0);
|
|
Defl->StringStart++;
|
|
}
|
|
else
|
|
{
|
|
Defl->StringStart += MatchLength;
|
|
MatchLength = 0;
|
|
Deflt->HashIndex = Comp->Window[Defl->StringStart];
|
|
UPDATE_HASH(Deflt->HashIndex, Comp->Window[Defl->StringStart+1]);
|
|
#if MIN_MATCH != 3
|
|
Call UPDATE_HASH() MIN_MATCH-3 more times
|
|
#endif
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* No match, output a literal byte */
|
|
Flush = TallyFrequencies(0, Comp->Window[Defl->StringStart], Level, Defl, Comp);
|
|
Deflt->Lookahead--;
|
|
Defl->StringStart++;
|
|
}
|
|
|
|
if (Flush)
|
|
{
|
|
(void)FLUSH_BLOCK(0, Bits, Defl, Comp);
|
|
Defl->BlockStart = (long)Defl->StringStart;
|
|
}
|
|
|
|
/* Make sure that we always have enough lookahead, except
|
|
* at the end of the input buffer. We need MAX_MATCH bytes
|
|
* for the next match, pls MIN_MATCH bytes to insert the
|
|
* string following the next match.
|
|
*/
|
|
while (Deflt->Lookahead < MIN_LOOKAHEAD && !Deflt->EndOfInput)
|
|
FillWindow(Defl, Deflt, Comp);
|
|
|
|
}
|
|
return FLUSH_BLOCK(1, Bits, Defl, Comp); /* end of buffer (eof) */
|
|
}
|
|
|
|
/* ===========================================================================
|
|
* Same as above, but achieves better compression. We use a lazy
|
|
* evaluation for matches: a match is finally adopted only if there is
|
|
* no beter match at the next window position.
|
|
*/
|
|
unsigned long
|
|
Deflate(
|
|
int Level,
|
|
LocalBits_t *Bits,
|
|
DeflateParam_t *Defl,
|
|
LocalDef_t *Deflt,
|
|
CompParam_t *Comp
|
|
)
|
|
{
|
|
IPos HashHead; /* head of hash chain */
|
|
IPos PrevMatch; /* previous match */
|
|
int Flush; /* set if current block must be flushed */
|
|
int MatchAvailable = 0; /* set if previous match exists */
|
|
unsigned int MatchLength = MIN_MATCH-1; /* length of best match */
|
|
|
|
if (Deflt->CompLevel <= 3)
|
|
return DeflateFast(Level, Bits, Defl, Deflt, Comp); /* optimized for speed */
|
|
|
|
/* Process the input block. */
|
|
while (Deflt->Lookahead != 0)
|
|
{
|
|
/* Insert the string Window[StringStart .. StringStart+2] in the
|
|
* dictionary, and set hash_head to the head of the hash chain:
|
|
*/
|
|
INSERT_STRING(Defl->StringStart, HashHead, Deflt->HashIndex,
|
|
Comp->Window, Comp->HashLink, (Comp->HashLink + WSIZE));
|
|
|
|
/* Find the longest match, discarding those<= PrevLength.
|
|
*/
|
|
Defl->PrevLength = MatchLength;
|
|
PrevMatch = Defl->MatchStart;
|
|
MatchLength = MIN_MATCH-1;
|
|
|
|
if (HashHead != NIL && Defl->PrevLength < Defl->MaxLazyMatch &&
|
|
Defl->StringStart - HashHead <= MAX_DIST)
|
|
{
|
|
/* To simplify the code, we prevent matches with the string
|
|
* of window index 0 (in particular we have to avoid a match
|
|
* of the string with itself at the start of the input buffer).
|
|
*/
|
|
MatchLength = (unsigned int)LongestMatch(HashHead, Defl, Comp);
|
|
/* LongestMatch() sets MatchStart */
|
|
if (MatchLength > Deflt->Lookahead)
|
|
MatchLength = Deflt->Lookahead;
|
|
|
|
/* Ignore a length 3 match if it is too distant: */
|
|
if (MatchLength == MIN_MATCH &&
|
|
Defl->StringStart - Defl->MatchStart > TOO_FAR)
|
|
{
|
|
/* If prev_match is also MIN_MATCH, match_start is garbage
|
|
* but we will ignore the current match anyway.
|
|
*/
|
|
MatchLength--;
|
|
}
|
|
}
|
|
/* If there was a match at the previous step and the current
|
|
* match is not better, output the previous match:
|
|
*/
|
|
if (Defl->PrevLength >= MIN_MATCH && MatchLength <= Defl->PrevLength)
|
|
{
|
|
Flush = TallyFrequencies((int)(Defl->StringStart - 1 - PrevMatch),
|
|
(int)((int)Defl->PrevLength - MIN_MATCH),
|
|
Level, Defl, Comp);
|
|
|
|
/* Insert in hash table all strings up to the end of the match.
|
|
* StringStart-1 and StringStart are already inserted.
|
|
*/
|
|
Deflt->Lookahead -= Defl->PrevLength-1;
|
|
Defl->PrevLength -= 2;
|
|
do
|
|
{
|
|
Defl->StringStart++;
|
|
INSERT_STRING(Defl->StringStart, HashHead, Deflt->HashIndex,
|
|
Comp->Window, Comp->HashLink, (Comp->HashLink + WSIZE));
|
|
/* StringStart never exceeds WSIZE-MAX_MATCH, so there are
|
|
* always MIN_MATCH bytes ahead. If lookahead < MIN_MATCH
|
|
* these bytes are garbage, but it does not matter since the
|
|
* next lookahead bytes will always be emitted as literals.
|
|
*/
|
|
} while (--Defl->PrevLength != 0);
|
|
MatchAvailable = 0;
|
|
MatchLength = MIN_MATCH-1;
|
|
Defl->StringStart++;
|
|
if (Flush)
|
|
{
|
|
(void)FLUSH_BLOCK(0, Bits, Defl, Comp);
|
|
Defl->BlockStart = (long)Defl->StringStart;
|
|
}
|
|
|
|
}
|
|
else if (MatchAvailable)
|
|
{
|
|
/* If there was no match at the previous position, output a
|
|
* single literal. If there was a match but the current match
|
|
* is longer, truncate the previous match to a single literal.
|
|
*/
|
|
if (TallyFrequencies(0, Comp->Window[Defl->StringStart-1], Level, Defl, Comp))
|
|
{
|
|
(void)FLUSH_BLOCK(0, Bits, Defl, Comp);
|
|
Defl->BlockStart = (long)Defl->StringStart;
|
|
}
|
|
Defl->StringStart++;
|
|
Deflt->Lookahead--;
|
|
}
|
|
else
|
|
{
|
|
/* There is no previous match to compare with, wait for
|
|
* the next step to decide.
|
|
*/
|
|
MatchAvailable = 1;
|
|
Defl->StringStart++;
|
|
Deflt->Lookahead--;
|
|
}
|
|
|
|
Assert (Defl->StringStart <= Comp->BytesIn && Deflt->Lookahead
|
|
<= Comp->BytesIn, "a bit too far");
|
|
|
|
/* Make sure that we always have enough lookahead, except
|
|
* at the end of the input buffer. We need MAX_MATCH bytes
|
|
* for the next match, plus MIN_MATCH bytes to insert the
|
|
* string following the next match.
|
|
*/
|
|
while (Deflt->Lookahead < MIN_LOOKAHEAD && !Deflt->EndOfInput)
|
|
FillWindow(Defl, Deflt, Comp);
|
|
}
|
|
if (MatchAvailable)
|
|
(void)TallyFrequencies(0, Comp->Window[Defl->StringStart-1], Level, Defl, Comp);
|
|
|
|
return FLUSH_BLOCK(1, Bits, Defl, Comp); /* end of buffer (eof) */
|
|
}
|
|
|
|
|