hondacrx
2299 lines
87 KiB
C#
2299 lines
87 KiB
C#
// deflate.cs -- internal compression state & compress data using the deflation algorithm
|
|
// Copyright (C) 1995-2010 Jean-loup Gailly.
|
|
// Copyright (C) 2007-2011 by the Authors
|
|
// For conditions of distribution and use, see copyright notice in License.txt
|
|
|
|
#region ALGORITHM , ACKNOWLEDGEMENTS & REFERENCES
|
|
// ALGORITHM
|
|
//
|
|
// The "deflation" process depends on being able to identify portions
|
|
// of the input text 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
|
|
// files if the parameter max_chain_length (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.
|
|
// Thanks to many people for bug reports and testing.
|
|
//
|
|
// REFERENCES
|
|
//
|
|
// Deutsch, L.P.,"DEFLATE Compressed Data Format Specification".
|
|
// Available in http://www.ietf.org/rfc/rfc1951.txt
|
|
//
|
|
// 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
|
|
#endregion
|
|
|
|
using System;
|
|
|
|
namespace Framework.IO
|
|
{
|
|
public static partial class ZLib
|
|
{
|
|
#region deflate.h
|
|
// ===========================================================================
|
|
// Internal compression state.
|
|
|
|
// number of length codes, not counting the special END_BLOCK code
|
|
private const int LENGTH_CODES=29;
|
|
|
|
// number of literal bytes 0..255
|
|
private const int LITERALS=256;
|
|
|
|
// number of Literal or Length codes, including the END_BLOCK code
|
|
private const int L_CODES=LITERALS+1+LENGTH_CODES;
|
|
|
|
// number of distance codes
|
|
private const int D_CODES=30;
|
|
|
|
// number of codes used to transfer the bit lengths
|
|
private const int BL_CODES=19;
|
|
|
|
// maximum heap size
|
|
private const int HEAP_SIZE=2*L_CODES+1;
|
|
|
|
// All codes must not exceed MAX_BITS bits
|
|
private const int MAX_BITS=15;
|
|
|
|
// Stream status
|
|
private const int INIT_STATE=42;
|
|
private const int EXTRA_STATE=69;
|
|
private const int NAME_STATE=73;
|
|
private const int COMMENT_STATE=91;
|
|
private const int HCRC_STATE=103;
|
|
private const int BUSY_STATE=113;
|
|
private const int FINISH_STATE=666;
|
|
|
|
// Data structure describing a single value and its code string.
|
|
struct ct_data
|
|
{
|
|
ushort freq;
|
|
public ushort Freq { get { return freq; } set { freq=value; } } // frequency count
|
|
public ushort Code { get { return freq; } set { freq=value; } } // bit string
|
|
|
|
ushort dad;
|
|
public ushort Dad { get { return dad; } set { dad=value; } } // father node in Huffman tree
|
|
public ushort Len { get { return dad; } set { dad=value; } } // length of bit string
|
|
|
|
public ct_data(ushort freq, ushort dad)
|
|
{
|
|
this.freq=freq;
|
|
this.dad=dad;
|
|
}
|
|
|
|
public ct_data(ct_data data)
|
|
{
|
|
freq=data.freq;
|
|
dad=data.dad;
|
|
}
|
|
}
|
|
|
|
struct tree_desc
|
|
{
|
|
public ct_data[] dyn_tree; // the dynamic tree
|
|
public int max_code; // largest code with non zero frequency
|
|
public static_tree_desc stat_desc; // the corresponding static tree
|
|
|
|
public tree_desc(tree_desc desc)
|
|
{
|
|
dyn_tree=desc.dyn_tree;
|
|
max_code=desc.max_code;
|
|
stat_desc=desc.stat_desc;
|
|
}
|
|
}
|
|
|
|
class deflate_state //internal_state
|
|
{
|
|
public z_stream strm; // pointer back to this zlib stream
|
|
public int status; // as the name implies
|
|
public byte[] pending_buf; // output still pending
|
|
public uint pending_buf_size; // size of pending_buf
|
|
|
|
public int pending_out; // next pending byte to output to the stream
|
|
|
|
public uint pending; // nb of bytes in the pending buffer
|
|
public int wrap; // bit 0 true for zlib, bit 1 true for gzip
|
|
public gz_header gzhead; // gzip header information to write
|
|
public uint gzindex; // where in extra, name, or comment
|
|
public byte method; // STORED (for zip only) or DEFLATED
|
|
public int last_flush; // value of flush param for previous deflate call
|
|
|
|
// used by deflate.c:
|
|
public uint w_size; // LZ77 window size (32K by default)
|
|
public uint w_bits; // log2(w_size) (8..16)
|
|
public uint w_mask; // w_size - 1
|
|
|
|
// Sliding window. Input bytes are read into the second half of the window,
|
|
// and move 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. Also, it limits
|
|
// the window size to 64K, which is quite useful on MSDOS.
|
|
// To do: use the user input buffer as sliding window.
|
|
public byte[] window;
|
|
|
|
// Actual size of window: 2*wSize, except when the user input buffer
|
|
// is directly used as sliding window.
|
|
public uint window_size;
|
|
|
|
// 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.
|
|
public ushort[] prev;
|
|
|
|
public ushort[] head; // Heads of the hash chains or NIL.
|
|
|
|
public uint ins_h; // hash index of string to be inserted
|
|
public uint hash_size; // number of elements in hash table
|
|
public uint hash_bits; // log2(hash_size)
|
|
public uint hash_mask; // hash_size-1
|
|
|
|
// Number of bits by which ins_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:
|
|
// hash_shift * MIN_MATCH >= hash_bits
|
|
public uint hash_shift;
|
|
|
|
// Window position at the beginning of the current output block. Gets
|
|
// negative when the window is moved backwards.
|
|
public int block_start;
|
|
|
|
public uint match_length; // length of best match
|
|
public uint prev_match; // previous match
|
|
public int match_available; // set if previous match exists
|
|
public uint strstart; // start of string to insert
|
|
public uint match_start; // start of matching string
|
|
public uint lookahead; // number of valid bytes ahead in window
|
|
|
|
// Length of the best match at previous step. Matches not greater than this
|
|
// are discarded. This is used in the lazy match evaluation.
|
|
public uint prev_length;
|
|
|
|
// To speed up deflation, hash chains are never searched beyond this
|
|
// length. A higher limit improves compression ratio but degrades the speed.
|
|
public uint max_chain_length;
|
|
|
|
// Attempt to find a better match only when the current match is strictly
|
|
// smaller than this value. This mechanism is used only for compression
|
|
// levels >= 4.
|
|
public uint max_lazy_match;
|
|
|
|
// Insert new strings in the hash table only if the match length is not
|
|
// greater than this length. This saves time but degrades compression.
|
|
// max_insert_length is used only for compression levels <= 3.
|
|
//#define max_insert_length max_lazy_match
|
|
|
|
public int level; // compression level (1..9)
|
|
public int strategy; // favor or force Huffman coding
|
|
|
|
public uint good_match; // Use a faster search when the previous match is longer than this
|
|
|
|
public int nice_match; // Stop searching when current match exceeds this
|
|
|
|
// used by trees.c:
|
|
public ct_data[] dyn_ltree=new ct_data[HEAP_SIZE]; // literal and length tree
|
|
public ct_data[] dyn_dtree=new ct_data[2*D_CODES+1]; // distance tree
|
|
public ct_data[] bl_tree=new ct_data[2*BL_CODES+1]; // Huffman tree for bit lengths
|
|
|
|
public tree_desc l_desc=new tree_desc(); // desc. for literal tree
|
|
public tree_desc d_desc=new tree_desc(); // desc. for distance tree
|
|
public tree_desc bl_desc=new tree_desc(); // desc. for bit length tree
|
|
|
|
// number of codes at each bit length for an optimal tree
|
|
public ushort[] bl_count=new ushort[MAX_BITS+1];
|
|
|
|
// 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.
|
|
public int[] heap=new int[2*L_CODES+1]; // heap used to build the Huffman trees
|
|
public int heap_len; // number of elements in the heap
|
|
public int heap_max; // element of largest frequency
|
|
|
|
// Depth of each subtree used as tie breaker for trees of equal frequency
|
|
public byte[] depth=new byte[2*L_CODES+1];
|
|
|
|
public byte[] l_buf; // buffer for literals or lengths
|
|
|
|
// Size of match buffer for literals/lengths. 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).
|
|
// This is applicable only for zip (not zlib).
|
|
// - 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
|
|
public uint lit_bufsize;
|
|
|
|
public uint last_lit; // running index in l_buf
|
|
|
|
// Buffer for distances. To simplify the code, d_buf and l_buf have
|
|
// the same number of elements. To use different lengths, an extra flag
|
|
// array would be necessary.
|
|
public ushort[] d_buf;
|
|
|
|
public uint opt_len; // bit length of current block with optimal trees
|
|
public uint static_len; // bit length of current block with static trees
|
|
public uint matches; // number of string matches in current block
|
|
public int last_eob_len; // bit length of EOB code for last block
|
|
|
|
// Output buffer. bits are inserted starting at the bottom (least
|
|
// significant bits).
|
|
public ushort bi_buf;
|
|
|
|
// Number of valid bits in bi_buf. All bits above the last valid bit
|
|
// are always zero.
|
|
public int bi_valid;
|
|
|
|
// High water mark offset in window for initialized bytes -- bytes above
|
|
// this are set to zero in order to avoid memory check warnings when
|
|
// longest match routines access bytes past the input. This is then
|
|
// updated to the new high water mark.
|
|
public uint high_water;
|
|
|
|
public deflate_state Clone()
|
|
{
|
|
deflate_state ret=(deflate_state)MemberwiseClone();
|
|
|
|
ret.dyn_ltree=new ct_data[HEAP_SIZE];
|
|
for(int i=0; i<HEAP_SIZE; i++) ret.dyn_ltree[i]=new ct_data(dyn_ltree[i]);
|
|
|
|
ret.dyn_dtree=new ct_data[2*D_CODES+1];
|
|
for(int i=0; i<(2*D_CODES+1); i++) ret.dyn_dtree[i]=new ct_data(dyn_dtree[i]);
|
|
|
|
ret.bl_tree=new ct_data[2*BL_CODES+1];
|
|
for(int i=0; i<(2*BL_CODES+1); i++) ret.bl_tree[i]=new ct_data(bl_tree[i]);
|
|
|
|
ret.bl_count=new ushort[MAX_BITS+1]; bl_count.CopyTo(ret.bl_count, 0);
|
|
ret.heap=new int[2*L_CODES+1]; heap.CopyTo(ret.heap, 0);
|
|
ret.depth=new byte[2*L_CODES+1]; depth.CopyTo(ret.depth, 0);
|
|
|
|
ret.l_desc=new tree_desc(l_desc); // desc. for literal tree
|
|
ret.d_desc=new tree_desc(d_desc); // desc. for distance tree
|
|
ret.bl_desc=new tree_desc(bl_desc);
|
|
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
// Output a byte on the stream.
|
|
// IN assertion: there is enough room in pending_buf.
|
|
//#define put_byte(s, c) {s.pending_buf[s.pending++] = (c);}
|
|
|
|
// Minimum amount of lookahead, except at the end of the input file.
|
|
// See deflate.c for comments about the MIN_MATCH+1.
|
|
private const int MIN_LOOKAHEAD=MAX_MATCH+MIN_MATCH+1;
|
|
|
|
// In order to simplify the code, particularly on 16 bit machines, match
|
|
// distances are limited to MAX_DIST instead of WSIZE.
|
|
//#define MAX_DIST(s) (s.w_size-MIN_LOOKAHEAD)
|
|
|
|
// Number of bytes after end of data in window to initialize in order to avoid
|
|
// memory checker errors from longest match routines
|
|
private const int WIN_INIT=MAX_MATCH;
|
|
|
|
// Mapping from a distance to a distance code. dist is the distance - 1 and
|
|
// must not have side effects. _dist_code[256] and _dist_code[257] are never
|
|
// used.
|
|
//#define d_code(dist) ((dist) < 256 ? _dist_code[dist] : _dist_code[256+((dist)>>7)])
|
|
|
|
#endregion
|
|
|
|
// If you use the zlib library in a product, an acknowledgment is welcome
|
|
// in the documentation of your product. If for some reason you cannot
|
|
// include such an acknowledgment, I would appreciate that you keep this
|
|
// copyright string in the executable of your product.
|
|
private const string deflate_copyright=" deflate 1.2.5 Copyright 1995-2010 Jean-loup Gailly ";
|
|
|
|
// ===========================================================================
|
|
// Function prototypes.
|
|
|
|
enum block_state
|
|
{
|
|
need_more, // block not completed, need more input or more output
|
|
block_done, // block flush performed
|
|
finish_started, // finish started, need only more output at next deflate
|
|
finish_done // finish done, accept no more input or output
|
|
}
|
|
|
|
// Compression function. Returns the block state after the call.
|
|
delegate block_state compress_func(deflate_state s, int flush);
|
|
|
|
// ===========================================================================
|
|
// Local data
|
|
|
|
// Tail of hash chains
|
|
private const int NIL=0;
|
|
|
|
// Matches of length 3 are discarded if their distance exceeds TOO_FAR
|
|
private const int TOO_FAR=4096;
|
|
|
|
// Values for max_lazy_match, good_match and max_chain_length, depending on
|
|
// the desired pack level (0..9). The values given below have been tuned to
|
|
// exclude worst case performance for pathological files. Better values may be
|
|
// found for specific files.
|
|
struct config
|
|
{
|
|
public ushort good_length; // reduce lazy search above this match length
|
|
public ushort max_lazy; // do not perform lazy search above this match length
|
|
public ushort nice_length; // quit search above this match length
|
|
public ushort max_chain;
|
|
public compress_func func;
|
|
|
|
public config(ushort good_length, ushort max_lazy, ushort nice_length, ushort max_chain, compress_func func)
|
|
{
|
|
this.good_length=good_length;
|
|
this.max_lazy=max_lazy;
|
|
this.nice_length=nice_length;
|
|
this.max_chain=max_chain;
|
|
this.func=func;
|
|
}
|
|
}
|
|
|
|
static readonly config[] configuration_table=new config[]
|
|
{ // good lazy nice chain
|
|
new config( 0, 0, 0, 0, deflate_stored), // store only
|
|
new config( 4, 4, 8, 4, deflate_fast), // max speed, no lazy matches
|
|
new config( 4, 5, 16, 8, deflate_fast),
|
|
new config( 4, 6, 32, 32, deflate_fast),
|
|
new config( 4, 4, 16, 16, deflate_slow), // lazy matches
|
|
new config( 8, 16, 32, 32, deflate_slow),
|
|
new config( 8, 16, 128, 128, deflate_slow),
|
|
new config( 8, 32, 128, 256, deflate_slow),
|
|
new config(32, 128, 258, 1024, deflate_slow),
|
|
new config(32, 258, 258, 4096, deflate_slow) // max compression
|
|
};
|
|
|
|
// Note: the deflate() code requires max_lazy >= MIN_MATCH and max_chain >= 4
|
|
// For deflate_fast() (levels <= 3) good is ignored and lazy has a different
|
|
// meaning.
|
|
|
|
// ===========================================================================
|
|
// 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(s,h,c) h = ((h<<s.hash_shift) ^ c) & s.hash_mask
|
|
|
|
// ===========================================================================
|
|
// Insert string str 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.
|
|
// If this file is compiled with -DFASTEST, the compression level is forced
|
|
// to 1, and no hash chains are maintained.
|
|
// IN assertion: all calls to to INSERT_STRING are made with consecutive
|
|
// input characters and the first MIN_MATCH bytes of str are valid
|
|
// (except for the last MIN_MATCH-1 bytes of the input file).
|
|
//#define INSERT_STRING(s, str, match_head) \
|
|
// s.ins_h = ((s.ins_h<<(int)s.hash_shift) ^ s.window[(str) + (MIN_MATCH-1)]) & s.hash_mask; \
|
|
// match_head = s.prev[(str) & s.w_mask] = s.head[s.ins_h]; \
|
|
// s.head[s.ins_h] = (unsigned short)str
|
|
|
|
// ===========================================================================
|
|
// Initialize the hash table (avoiding 64K overflow for 16 bit systems).
|
|
// prev[] will be initialized on the fly.
|
|
|
|
// =========================================================================
|
|
// Initializes the internal stream state for compression. The fields
|
|
// zalloc, zfree and opaque must be initialized before by the caller.
|
|
// If zalloc and zfree are set to Z_NULL, deflateInit updates them to
|
|
// use default allocation functions.
|
|
|
|
// The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9:
|
|
// 1 gives best speed, 9 gives best compression, 0 gives no compression at
|
|
// all (the input data is simply copied a block at a time).
|
|
// Z_DEFAULT_COMPRESSION requests a default compromise between speed and
|
|
// compression (currently equivalent to level 6).
|
|
|
|
// deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not
|
|
// enough memory, Z_STREAM_ERROR if level is not a valid compression level,
|
|
// Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible
|
|
// with the version assumed by the caller (ZLIB_VERSION).
|
|
// msg is set to null if there is no error message. deflateInit does not
|
|
// perform any compression: this will be done by deflate().
|
|
public static int deflateInit(z_stream strm, int level)
|
|
{
|
|
return deflateInit2(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY);
|
|
// Todo: ignore strm.next_in if we use it as window
|
|
}
|
|
|
|
// =========================================================================
|
|
// This is another version of deflateInit with more compression options. The
|
|
// fields next_in, zalloc, zfree and opaque must be initialized before by
|
|
// the caller.
|
|
|
|
// The method parameter is the compression method. It must be Z_DEFLATED in
|
|
// this version of the library.
|
|
|
|
// The windowBits parameter is the base two logarithm of the window size
|
|
// (the size of the history buffer). It should be in the range 8..15 for this
|
|
// version of the library. Larger values of this parameter result in better
|
|
// compression at the expense of memory usage. The default value is 15 if
|
|
// deflateInit is used instead.
|
|
|
|
// windowBits can also be -8..-15 for raw deflate. In this case, -windowBits
|
|
// determines the window size. deflate() will then generate raw deflate data
|
|
// with no zlib header or trailer, and will not compute an adler32 check value.
|
|
|
|
// windowBits can also be greater than 15 for optional gzip encoding. Add
|
|
// 16 to windowBits to write a simple gzip header and trailer around the
|
|
// compressed data instead of a zlib wrapper. The gzip header will have no
|
|
// file name, no extra data, no comment, no modification time (set to zero),
|
|
// no header crc, and the operating system will be set to 255 (unknown). If a
|
|
// gzip stream is being written, strm.adler is a crc32 instead of an adler32.
|
|
|
|
// The memLevel parameter specifies how much memory should be allocated
|
|
// for the internal compression state. memLevel=1 uses minimum memory but
|
|
// is slow and reduces compression ratio; memLevel=9 uses maximum memory
|
|
// for optimal speed. The default value is 8. See zconf.h for total memory
|
|
// usage as a function of windowBits and memLevel.
|
|
|
|
// The strategy parameter is used to tune the compression algorithm. Use the
|
|
// value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a
|
|
// filter (or predictor), Z_HUFFMAN_ONLY to force Huffman encoding only (no
|
|
// string match), or Z_RLE to limit match distances to one (run-length
|
|
// encoding). Filtered data consists mostly of small values with a somewhat
|
|
// random distribution. In this case, the compression algorithm is tuned to
|
|
// compress them better. The effect of Z_FILTERED is to force more Huffman
|
|
// coding and less string matching; it is somewhat intermediate between
|
|
// Z_DEFAULT and Z_HUFFMAN_ONLY. Z_RLE is designed to be almost as fast as
|
|
// Z_HUFFMAN_ONLY, but give better compression for PNG image data. The strategy
|
|
// parameter only affects the compression ratio but not the correctness of the
|
|
// compressed output even if it is not set appropriately. Z_FIXED prevents the
|
|
// use of dynamic Huffman codes, allowing for a simpler decoder for special
|
|
// applications.
|
|
|
|
// deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
|
|
// memory, Z_STREAM_ERROR if a parameter is invalid (such as an invalid
|
|
// method). msg is set to null if there is no error message. deflateInit2 does
|
|
// not perform any compression: this will be done by deflate().
|
|
|
|
public static int deflateInit2(z_stream strm, int level, int method, int windowBits, int memLevel, int strategy)
|
|
{
|
|
if(strm==null) return Z_STREAM_ERROR;
|
|
strm.msg=null;
|
|
|
|
if(level==Z_DEFAULT_COMPRESSION) level=6;
|
|
|
|
int wrap=1;
|
|
|
|
if(windowBits<0)
|
|
{ // suppress zlib wrapper
|
|
wrap=0;
|
|
windowBits=-windowBits;
|
|
}
|
|
else if(windowBits>15)
|
|
{
|
|
wrap=2; // write gzip wrapper instead
|
|
windowBits-=16;
|
|
}
|
|
|
|
if(memLevel<1||memLevel>MAX_MEM_LEVEL||method!=Z_DEFLATED||windowBits<8||windowBits>15||level<0||level>9||
|
|
strategy<0||strategy>Z_FIXED) return Z_STREAM_ERROR;
|
|
|
|
if(windowBits==8) windowBits=9; // until 256-byte window bug fixed
|
|
|
|
deflate_state s;
|
|
try
|
|
{
|
|
s=new deflate_state();
|
|
}
|
|
catch(Exception)
|
|
{
|
|
return Z_MEM_ERROR;
|
|
}
|
|
|
|
strm.state=s;
|
|
s.strm=strm;
|
|
|
|
s.wrap=wrap;
|
|
s.w_bits=(uint)windowBits;
|
|
s.w_size=1U<<(int)s.w_bits;
|
|
s.w_mask=s.w_size-1;
|
|
|
|
s.hash_bits=(uint)memLevel+7;
|
|
s.hash_size=1U<<(int)s.hash_bits;
|
|
s.hash_mask=s.hash_size-1;
|
|
s.hash_shift=(s.hash_bits+MIN_MATCH-1)/MIN_MATCH;
|
|
|
|
try
|
|
{
|
|
s.window=new byte[s.w_size*2];
|
|
s.prev=new ushort[s.w_size];
|
|
s.head=new ushort[s.hash_size];
|
|
s.high_water=0; // nothing written to s->window yet
|
|
|
|
s.lit_bufsize=1U<<(memLevel+6); // 16K elements by default
|
|
|
|
s.pending_buf=new byte[s.lit_bufsize*4];
|
|
s.pending_buf_size=s.lit_bufsize*4;
|
|
|
|
s.d_buf=new ushort[s.lit_bufsize];
|
|
s.l_buf=new byte[s.lit_bufsize];
|
|
}
|
|
catch(Exception)
|
|
{
|
|
s.status=FINISH_STATE;
|
|
strm.msg=zError(Z_MEM_ERROR);
|
|
deflateEnd(strm);
|
|
return Z_MEM_ERROR;
|
|
}
|
|
|
|
s.level=level;
|
|
s.strategy=strategy;
|
|
s.method=(byte)method;
|
|
|
|
return deflateReset(strm);
|
|
}
|
|
|
|
// =========================================================================
|
|
// Initializes the compression dictionary from the given byte sequence
|
|
// without producing any compressed output. This function must be called
|
|
// immediately after deflateInit, deflateInit2 or deflateReset, before any
|
|
// call of deflate. The compressor and decompressor must use exactly the same
|
|
// dictionary (see inflateSetDictionary).
|
|
|
|
// The dictionary should consist of strings (byte sequences) that are likely
|
|
// to be encountered later in the data to be compressed, with the most commonly
|
|
// used strings preferably put towards the end of the dictionary. Using a
|
|
// dictionary is most useful when the data to be compressed is short and can be
|
|
// predicted with good accuracy; the data can then be compressed better than
|
|
// with the default empty dictionary.
|
|
|
|
// Depending on the size of the compression data structures selected by
|
|
// deflateInit or deflateInit2, a part of the dictionary may in effect be
|
|
// discarded, for example if the dictionary is larger than the window size in
|
|
// deflate or deflate2. Thus the strings most likely to be useful should be
|
|
// put at the end of the dictionary, not at the front. In addition, the
|
|
// current implementation of deflate will use at most the window size minus
|
|
// 262 bytes of the provided dictionary.
|
|
|
|
// Upon return of this function, strm.adler is set to the adler32 value
|
|
// of the dictionary; the decompressor may later use this value to determine
|
|
// which dictionary has been used by the compressor. (The adler32 value
|
|
// applies to the whole dictionary even if only a subset of the dictionary is
|
|
// actually used by the compressor.) If a raw deflate was requested, then the
|
|
// adler32 value is not computed and strm.adler is not set.
|
|
|
|
// deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a
|
|
// parameter is invalid (such as NULL dictionary) or the stream state is
|
|
// inconsistent (for example if deflate has already been called for this stream
|
|
// or if the compression method is bsort). deflateSetDictionary does not
|
|
// perform any compression: this will be done by deflate().
|
|
|
|
public static int deflateSetDictionary(z_stream strm, byte[] dictionary, uint dictLength)
|
|
{
|
|
uint length=dictLength;
|
|
uint n;
|
|
uint hash_head=0;
|
|
|
|
if(strm==null||strm.state==null||dictionary==null) return Z_STREAM_ERROR;
|
|
|
|
deflate_state s=strm.state as deflate_state;
|
|
if(s==null||s.wrap==2||(s.wrap==1&&s.status!=INIT_STATE))
|
|
return Z_STREAM_ERROR;
|
|
|
|
if(s.wrap!=0) strm.adler=adler32(strm.adler, dictionary, dictLength);
|
|
|
|
if(length<MIN_MATCH) return Z_OK;
|
|
|
|
int dictionary_ind=0;
|
|
if(length>s.w_size)
|
|
{
|
|
length=s.w_size;
|
|
dictionary_ind=(int)(dictLength-length); // use the tail of the dictionary
|
|
}
|
|
|
|
//was memcpy(s.window, dictionary+dictionary_ind, length);
|
|
Array.Copy(dictionary, dictionary_ind, s.window, 0, length);
|
|
|
|
s.strstart=length;
|
|
s.block_start=(int)length;
|
|
|
|
// Insert all strings in the hash table (except for the last two bytes).
|
|
// s.lookahead stays null, so s.ins_h will be recomputed at the next
|
|
// call of fill_window.
|
|
s.ins_h=s.window[0];
|
|
|
|
//was UPDATE_HASH(s, s.ins_h, s.window[1]);
|
|
s.ins_h=((s.ins_h<<(int)s.hash_shift)^s.window[1])&s.hash_mask;
|
|
|
|
for(n=0; n<=length-MIN_MATCH; n++)
|
|
{
|
|
//was INSERT_STRING(s, n, hash_head);
|
|
s.ins_h=((s.ins_h<<(int)s.hash_shift)^s.window[n+(MIN_MATCH-1)])&s.hash_mask;
|
|
hash_head=s.prev[n&s.w_mask]=s.head[s.ins_h];
|
|
s.head[s.ins_h]=(ushort)n;
|
|
}
|
|
if(hash_head!=0) hash_head=0; // to make compiler happy
|
|
return Z_OK;
|
|
}
|
|
|
|
// =========================================================================
|
|
// This function is equivalent to deflateEnd followed by deflateInit,
|
|
// but does not free and reallocate all the internal compression state.
|
|
// The stream will keep the same compression level and any other attributes
|
|
// that may have been set by deflateInit2.
|
|
|
|
// deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
|
|
// stream state was inconsistent (such as zalloc or state being NULL).
|
|
public static int deflateReset(z_stream strm)
|
|
{
|
|
if(strm==null||strm.state==null) return Z_STREAM_ERROR;
|
|
|
|
strm.total_in=strm.total_out=0;
|
|
strm.msg=null;
|
|
|
|
deflate_state s=(deflate_state)strm.state;
|
|
s.pending=0;
|
|
s.pending_out=0;
|
|
|
|
if(s.wrap<0) s.wrap=-s.wrap; // was made negative by deflate(..., Z_FINISH);
|
|
|
|
s.status=s.wrap!=0?INIT_STATE:BUSY_STATE;
|
|
strm.adler=s.wrap==2?crc32(0, null, 0):adler32(0, null, 0);
|
|
s.last_flush=Z_NO_FLUSH;
|
|
|
|
_tr_init(s);
|
|
lm_init(s);
|
|
|
|
return Z_OK;
|
|
}
|
|
|
|
// =========================================================================
|
|
// deflateSetHeader() provides gzip header information for when a gzip
|
|
// stream is requested by deflateInit2(). deflateSetHeader() may be called
|
|
// after deflateInit2() or deflateReset() and before the first call of
|
|
// deflate(). The text, time, os, extra field, name, and comment information
|
|
// in the provided gz_header structure are written to the gzip header (xflag is
|
|
// ignored -- the extra flags are set according to the compression level). The
|
|
// caller must assure that, if not Z_NULL, name and comment are terminated with
|
|
// a zero byte, and that if extra is not Z_NULL, that extra_len bytes are
|
|
// available there. If hcrc is true, a gzip header crc is included. Note that
|
|
// the current versions of the command-line version of gzip (up through version
|
|
// 1.3.x) do not support header crc's, and will report that it is a "multi-part
|
|
// gzip file" and give up.
|
|
|
|
// If deflateSetHeader is not used, the default gzip header has text false,
|
|
// the time set to zero, and os set to 255, with no extra, name, or comment
|
|
// fields. The gzip header is returned to the default state by deflateReset().
|
|
|
|
// deflateSetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source
|
|
// stream state was inconsistent.
|
|
|
|
public static int deflateSetHeader(z_stream strm, gz_header head)
|
|
{
|
|
if(strm==null||strm.state==null) return Z_STREAM_ERROR;
|
|
deflate_state s=(deflate_state)strm.state;
|
|
if(s.wrap!=2) return Z_STREAM_ERROR;
|
|
s.gzhead=head;
|
|
return Z_OK;
|
|
}
|
|
|
|
// =========================================================================
|
|
// deflatePrime() inserts bits in the deflate output stream. The intent
|
|
// is that this function is used to start off the deflate output with the
|
|
// bits leftover from a previous deflate stream when appending to it. As such,
|
|
// this function can only be used for raw deflate, and must be used before the
|
|
// first deflate() call after a deflateInit2() or deflateReset(). bits must be
|
|
// less than or equal to 16, and that many of the least significant bits of
|
|
// value will be inserted in the output.
|
|
|
|
// deflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source
|
|
// stream state was inconsistent.
|
|
|
|
public static int deflatePrime(z_stream strm, int bits, int value)
|
|
{
|
|
if(strm==null||strm.state==null) return Z_STREAM_ERROR;
|
|
deflate_state s=(deflate_state)strm.state;
|
|
s.bi_valid=bits;
|
|
s.bi_buf=(ushort)(value&((1<<bits)-1));
|
|
return Z_OK;
|
|
}
|
|
|
|
// =========================================================================
|
|
// Dynamically update the compression level and compression strategy. The
|
|
// interpretation of level and strategy is as in deflateInit2. This can be
|
|
// used to switch between compression and straight copy of the input data, or
|
|
// to switch to a different kind of input data requiring a different
|
|
// strategy. If the compression level is changed, the input available so far
|
|
// is compressed with the old level (and may be flushed); the new level will
|
|
// take effect only at the next call of deflate().
|
|
|
|
// Before the call of deflateParams, the stream state must be set as for
|
|
// a call of deflate(), since the currently available input may have to
|
|
// be compressed and flushed. In particular, strm.avail_out must be non-zero.
|
|
|
|
// deflateParams returns Z_OK if success, Z_STREAM_ERROR if the source
|
|
// stream state was inconsistent or if a parameter was invalid, Z_BUF_ERROR
|
|
// if strm.avail_out was zero.
|
|
|
|
public static int deflateParams(z_stream strm, int level, int strategy)
|
|
{
|
|
if(strm==null||strm.state==null) return Z_STREAM_ERROR;
|
|
deflate_state s=(deflate_state)strm.state;
|
|
|
|
if(level==Z_DEFAULT_COMPRESSION) level=6;
|
|
if(level<0||level>9||strategy<0||strategy>Z_FIXED) return Z_STREAM_ERROR;
|
|
|
|
compress_func func=configuration_table[s.level].func;
|
|
int err=Z_OK;
|
|
|
|
if((strategy!=s.strategy||func!=configuration_table[level].func)&&strm.total_in!=0) // Flush the last buffer:
|
|
err=deflate(strm, Z_BLOCK);
|
|
|
|
if(s.level!=level)
|
|
{
|
|
s.level=level;
|
|
s.max_lazy_match=configuration_table[level].max_lazy;
|
|
s.good_match=configuration_table[level].good_length;
|
|
s.nice_match=configuration_table[level].nice_length;
|
|
s.max_chain_length=configuration_table[level].max_chain;
|
|
}
|
|
|
|
s.strategy=strategy;
|
|
return err;
|
|
}
|
|
|
|
// =========================================================================
|
|
// Fine tune deflate's internal compression parameters. This should only be
|
|
// used by someone who understands the algorithm used by zlib's deflate for
|
|
// searching for the best matching string, and even then only by the most
|
|
// fanatic optimizer trying to squeeze out the last compressed bit for their
|
|
// specific input data. Read the deflate.cs source code for the meaning of the
|
|
// max_lazy, good_length, nice_length, and max_chain parameters.
|
|
|
|
// deflateTune() can be called after deflateInit() or deflateInit2(), and
|
|
// returns Z_OK on success, or Z_STREAM_ERROR for an invalid deflate stream.
|
|
|
|
public static int deflateTune(z_stream strm, uint good_length, uint max_lazy, int nice_length, uint max_chain)
|
|
{
|
|
if(strm==null||strm.state==null) return Z_STREAM_ERROR;
|
|
deflate_state s=(deflate_state)strm.state;
|
|
s.good_match=good_length;
|
|
s.max_lazy_match=max_lazy;
|
|
s.nice_match=nice_length;
|
|
s.max_chain_length=max_chain;
|
|
return Z_OK;
|
|
}
|
|
|
|
// =========================================================================
|
|
// For the default windowBits of 15 and memLevel of 8, this function returns
|
|
// a close to exact, as well as small, upper bound on the compressed size.
|
|
// They are coded as constants here for a reason--if the #define's are
|
|
// changed, then this function needs to be changed as well. The return
|
|
// value for 15 and 8 only works for those exact settings.
|
|
//
|
|
// For any setting other than those defaults for windowBits and memLevel,
|
|
// the value returned is a conservative worst case for the maximum expansion
|
|
// resulting from using fixed blocks instead of stored blocks, which deflate
|
|
// can emit on compressed data for some combinations of the parameters.
|
|
//
|
|
// This function could be more sophisticated to provide closer upper bounds for
|
|
// every combination of windowBits and memLevel. But even the conservative
|
|
// upper bound of about 14% expansion does not seem onerous for output buffer
|
|
// allocation.
|
|
|
|
// deflateBound() returns an upper bound on the compressed size after
|
|
// deflation of sourceLen bytes. It must be called after deflateInit()
|
|
// or deflateInit2(). This would be used to allocate an output buffer
|
|
// for deflation in a single pass, and so would be called before deflate().
|
|
|
|
public static uint deflateBound(z_stream strm, uint sourceLen)
|
|
{
|
|
// conservative upper bound for compressed data
|
|
uint complen=sourceLen+((sourceLen+7)>>3)+((sourceLen+63)>>6)+5;
|
|
|
|
// if can't get parameters, return conservative bound plus zlib wrapper
|
|
if(strm==null||strm.state==null) return complen+6;
|
|
|
|
// compute wrapper length
|
|
deflate_state s=(deflate_state)strm.state;
|
|
uint wraplen;
|
|
byte[] str;
|
|
switch(s.wrap)
|
|
{
|
|
case 0: // raw deflate
|
|
wraplen=0;
|
|
break;
|
|
case 1: // zlib wrapper
|
|
wraplen=(uint)(6+(s.strstart!=0?4:0));
|
|
break;
|
|
case 2: // gzip wrapper
|
|
wraplen=18;
|
|
if(s.gzhead!=null) // user-supplied gzip header
|
|
{
|
|
if(s.gzhead.extra!=null) wraplen+=2+s.gzhead.extra_len;
|
|
str=s.gzhead.name;
|
|
int str_ind=0;
|
|
if(str!=null)
|
|
{
|
|
do
|
|
{
|
|
wraplen++;
|
|
} while(str[str_ind++]!=0);
|
|
}
|
|
str=s.gzhead.comment;
|
|
if(str!=null)
|
|
{
|
|
do
|
|
{
|
|
wraplen++;
|
|
} while(str[str_ind++]!=0);
|
|
}
|
|
if(s.gzhead.hcrc!=0) wraplen+=2;
|
|
}
|
|
break;
|
|
default: wraplen=6; break; // for compiler happiness
|
|
}
|
|
|
|
// if not default parameters, return conservative bound
|
|
if(s.w_bits!=15||s.hash_bits!=8+7) return complen+wraplen;
|
|
|
|
// default settings: return tight bound for that case
|
|
return sourceLen+(sourceLen>>12)+(sourceLen>>14)+(sourceLen>>25)+13-6+wraplen;
|
|
}
|
|
|
|
// =========================================================================
|
|
// Put a short in the pending buffer. The 16-bit value is put in MSB order.
|
|
// IN assertion: the stream state is correct and there is enough room in
|
|
// pending_buf.
|
|
static void putShortMSB(deflate_state s, uint b)
|
|
{
|
|
//was put_byte(s, (byte)(b >> 8));
|
|
s.pending_buf[s.pending++]=(byte)(b >> 8);
|
|
//was put_byte(s, (byte)(b & 0xff));
|
|
s.pending_buf[s.pending++]=(byte)(b & 0xff);
|
|
}
|
|
|
|
// =========================================================================
|
|
// Flush as much pending output as possible. All deflate() output goes
|
|
// through this function so some applications may wish to modify it
|
|
// to avoid allocating a large strm.next_out buffer and copying into it.
|
|
// (See also read_buf()).
|
|
static void flush_pending(z_stream strm)
|
|
{
|
|
deflate_state s=(deflate_state)strm.state;
|
|
uint len=s.pending;
|
|
|
|
if(len>strm.avail_out) len=strm.avail_out;
|
|
if(len==0) return;
|
|
|
|
//was memcpy(strm.next_out, s.pending_out, len);
|
|
Array.Copy(s.pending_buf, s.pending_out, strm.out_buf, strm.next_out, len);
|
|
|
|
strm.next_out+=(int)len;
|
|
s.pending_out+=(int)len;
|
|
strm.total_out+=len;
|
|
strm.avail_out-=len;
|
|
s.pending-=len;
|
|
if(s.pending==0) s.pending_out=0;
|
|
}
|
|
|
|
const int PRESET_DICT=0x20; // preset dictionary flag in zlib header
|
|
|
|
#region deflate
|
|
// =========================================================================
|
|
// deflate compresses as much data as possible, and stops when the input
|
|
// buffer becomes empty or the output buffer becomes full. It may introduce some
|
|
// output latency (reading input without producing any output) except when
|
|
// forced to flush.
|
|
|
|
// The detailed semantics are as follows. deflate performs one or both of the
|
|
// following actions:
|
|
|
|
// - Compress more input starting at next_in and update next_in and avail_in
|
|
// accordingly. If not all input can be processed (because there is not
|
|
// enough room in the output buffer), next_in and avail_in are updated and
|
|
// processing will resume at this point for the next call of deflate().
|
|
|
|
// - Provide more output starting at next_out and update next_out and avail_out
|
|
// accordingly. This action is forced if the parameter flush is non zero.
|
|
// Forcing flush frequently degrades the compression ratio, so this parameter
|
|
// should be set only when necessary (in interactive applications).
|
|
// Some output may be provided even if flush is not set.
|
|
|
|
// Before the call of deflate(), the application should ensure that at least
|
|
// one of the actions is possible, by providing more input and/or consuming
|
|
// more output, and updating avail_in or avail_out accordingly; avail_out
|
|
// should never be zero before the call. The application can consume the
|
|
// compressed output when it wants, for example when the output buffer is full
|
|
// (avail_out == 0), or after each call of deflate(). If deflate returns Z_OK
|
|
// and with zero avail_out, it must be called again after making room in the
|
|
// output buffer because there might be more output pending.
|
|
|
|
// Normally the parameter flush is set to Z_NO_FLUSH, which allows deflate to
|
|
// decide how much data to accumualte before producing output, in order to
|
|
// maximize compression.
|
|
|
|
// If the parameter flush is set to Z_SYNC_FLUSH, all pending output is
|
|
// flushed to the output buffer and the output is aligned on a byte boundary, so
|
|
// that the decompressor can get all input data available so far. (In particular
|
|
// avail_in is zero after the call if enough output space has been provided
|
|
// before the call.) Flushing may degrade compression for some compression
|
|
// algorithms and so it should be used only when necessary.
|
|
|
|
// If flush is set to Z_FULL_FLUSH, all output is flushed as with
|
|
// Z_SYNC_FLUSH, and the compression state is reset so that decompression can
|
|
// restart from this point if previous compressed data has been damaged or if
|
|
// random access is desired. Using Z_FULL_FLUSH too often can seriously degrade
|
|
// compression.
|
|
|
|
// If deflate returns with avail_out == 0, this function must be called again
|
|
// with the same value of the flush parameter and more output space (updated
|
|
// avail_out), until the flush is complete (deflate returns with non-zero
|
|
// avail_out). In the case of a Z_FULL_FLUSH or Z_SYNC_FLUSH, make sure that
|
|
// avail_out is greater than six to avoid repeated flush markers due to
|
|
// avail_out == 0 on return.
|
|
|
|
// If the parameter flush is set to Z_FINISH, pending input is processed,
|
|
// pending output is flushed and deflate returns with Z_STREAM_END if there
|
|
// was enough output space; if deflate returns with Z_OK, this function must be
|
|
// called again with Z_FINISH and more output space (updated avail_out) but no
|
|
// more input data, until it returns with Z_STREAM_END or an error. After
|
|
// deflate has returned Z_STREAM_END, the only possible operations on the
|
|
// stream are deflateReset or deflateEnd.
|
|
|
|
// Z_FINISH can be used immediately after deflateInit if all the compression
|
|
// is to be done in a single step. In this case, avail_out must be at least
|
|
// the value returned by deflateBound (see below). If deflate does not return
|
|
// Z_STREAM_END, then it must be called again as described above.
|
|
|
|
// deflate() sets strm.adler to the adler32 checksum of all input read
|
|
// so far (that is, total_in bytes).
|
|
|
|
// deflate() returns Z_OK if some progress has been made (more input
|
|
// processed or more output produced), Z_STREAM_END if all input has been
|
|
// consumed and all output has been produced (only when flush is set to
|
|
// Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example
|
|
// if next_in or next_out was NULL), Z_BUF_ERROR if no progress is possible
|
|
// (for example avail_in or avail_out was zero). Note that Z_BUF_ERROR is not
|
|
// fatal, and deflate() can be called again with more input and more output
|
|
// space to continue compressing.
|
|
|
|
public static int deflate(z_stream strm, int flush)
|
|
{
|
|
int old_flush; // value of flush param for previous deflate call
|
|
|
|
if(strm==null||strm.state==null||flush>Z_BLOCK||flush<0) return Z_STREAM_ERROR;
|
|
deflate_state s=(deflate_state)strm.state;
|
|
|
|
if(strm.out_buf==null||(strm.in_buf==null&&strm.avail_in!=0)||(s.status==FINISH_STATE&&flush!=Z_FINISH))
|
|
{
|
|
strm.msg=zError(Z_STREAM_ERROR);
|
|
return Z_STREAM_ERROR;
|
|
}
|
|
|
|
if(strm.avail_out==0)
|
|
{
|
|
strm.msg=zError(Z_BUF_ERROR);
|
|
return Z_BUF_ERROR;
|
|
}
|
|
|
|
s.strm=strm; // just in case
|
|
old_flush=s.last_flush;
|
|
s.last_flush=flush;
|
|
|
|
// Write the header
|
|
if(s.status==INIT_STATE)
|
|
{
|
|
if(s.wrap==2)
|
|
{
|
|
strm.adler=crc32(0, null, 0);
|
|
s.pending_buf[s.pending++]=31;
|
|
s.pending_buf[s.pending++]=139;
|
|
s.pending_buf[s.pending++]=8;
|
|
if(s.gzhead==null)
|
|
{
|
|
s.pending_buf[s.pending++]=0;
|
|
|
|
s.pending_buf[s.pending++]=0;
|
|
s.pending_buf[s.pending++]=0;
|
|
s.pending_buf[s.pending++]=0;
|
|
s.pending_buf[s.pending++]=0;
|
|
|
|
s.pending_buf[s.pending++]=(byte)(s.level==9?2:(s.strategy>=Z_HUFFMAN_ONLY||s.level<2?4:0));
|
|
s.pending_buf[s.pending++]=OS_CODE;
|
|
s.status=BUSY_STATE;
|
|
}
|
|
else
|
|
{
|
|
s.pending_buf[s.pending++]=(byte)((s.gzhead.text!=0?1:0)+(s.gzhead.hcrc!=0?2:0)+(s.gzhead.extra==null?0:4)+
|
|
(s.gzhead.name==null?0:8)+(s.gzhead.comment==null?0:16));
|
|
s.pending_buf[s.pending++]=(byte)(s.gzhead.time&0xff);
|
|
s.pending_buf[s.pending++]=(byte)((s.gzhead.time>>8)&0xff);
|
|
s.pending_buf[s.pending++]=(byte)((s.gzhead.time>>16)&0xff);
|
|
s.pending_buf[s.pending++]=(byte)((s.gzhead.time>>24)&0xff);
|
|
s.pending_buf[s.pending++]=(byte)(s.level==9?2:(s.strategy>=Z_HUFFMAN_ONLY||s.level<2?4:0));
|
|
s.pending_buf[s.pending++]=(byte)(s.gzhead.os&0xff);
|
|
if(s.gzhead.extra!=null)
|
|
{
|
|
s.pending_buf[s.pending++]=(byte)(s.gzhead.extra_len&0xff);
|
|
s.pending_buf[s.pending++]=(byte)((s.gzhead.extra_len>>8)&0xff);
|
|
}
|
|
if(s.gzhead.hcrc!=0) strm.adler=crc32(strm.adler, s.pending_buf, s.pending);
|
|
s.gzindex=0;
|
|
s.status=EXTRA_STATE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
uint header=(Z_DEFLATED+((s.w_bits-8)<<4))<<8;
|
|
uint level_flags;
|
|
|
|
if(s.strategy>=Z_HUFFMAN_ONLY||s.level<2) level_flags=0;
|
|
else if(s.level<6) level_flags=1;
|
|
else if(s.level==6) level_flags=2;
|
|
else level_flags=3;
|
|
|
|
header|=(level_flags<<6);
|
|
if(s.strstart!=0) header|=PRESET_DICT;
|
|
header+=31-(header%31);
|
|
|
|
s.status=BUSY_STATE;
|
|
putShortMSB(s, header);
|
|
|
|
// Save the adler32 of the preset dictionary:
|
|
if(s.strstart!=0)
|
|
{
|
|
putShortMSB(s, (uint)(strm.adler>>16));
|
|
putShortMSB(s, (uint)(strm.adler&0xffff));
|
|
}
|
|
strm.adler=adler32(0, null, 0);
|
|
}
|
|
}
|
|
if(s.status==EXTRA_STATE)
|
|
{
|
|
if(s.gzhead.extra!=null)
|
|
{
|
|
uint beg=s.pending; // start of bytes to update crc
|
|
|
|
while(s.gzindex<(s.gzhead.extra_len&0xffff))
|
|
{
|
|
if(s.pending==s.pending_buf_size)
|
|
{
|
|
if(s.gzhead.hcrc!=0&&s.pending>beg) strm.adler=crc32(strm.adler, s.pending_buf, beg, s.pending-beg);
|
|
flush_pending(strm);
|
|
beg=s.pending;
|
|
if(s.pending==s.pending_buf_size) break;
|
|
}
|
|
s.pending_buf[s.pending++]=s.gzhead.extra[s.gzindex];
|
|
s.gzindex++;
|
|
}
|
|
if(s.gzhead.hcrc!=0&&s.pending>beg) strm.adler=crc32(strm.adler, s.pending_buf, beg, s.pending-beg);
|
|
if(s.gzindex==s.gzhead.extra_len)
|
|
{
|
|
s.gzindex=0;
|
|
s.status=NAME_STATE;
|
|
}
|
|
}
|
|
else s.status=NAME_STATE;
|
|
}
|
|
if(s.status==NAME_STATE)
|
|
{
|
|
if(s.gzhead.name!=null)
|
|
{
|
|
uint beg=s.pending; // start of bytes to update crc
|
|
byte val;
|
|
|
|
do
|
|
{
|
|
if(s.pending==s.pending_buf_size)
|
|
{
|
|
if(s.gzhead.hcrc!=0&&s.pending>beg) strm.adler=crc32(strm.adler, s.pending_buf, beg, s.pending-beg);
|
|
flush_pending(strm);
|
|
beg=s.pending;
|
|
if(s.pending==s.pending_buf_size)
|
|
{
|
|
val=1;
|
|
break;
|
|
}
|
|
}
|
|
val=s.gzhead.name[s.gzindex++];
|
|
s.pending_buf[s.pending++]=val;
|
|
} while(val!=0);
|
|
if(s.gzhead.hcrc!=0&&s.pending>beg) strm.adler=crc32(strm.adler, s.pending_buf, beg, s.pending-beg);
|
|
if(val==0)
|
|
{
|
|
s.gzindex=0;
|
|
s.status=COMMENT_STATE;
|
|
}
|
|
}
|
|
else s.status=COMMENT_STATE;
|
|
}
|
|
if(s.status==COMMENT_STATE)
|
|
{
|
|
if(s.gzhead.comment!=null)
|
|
{
|
|
uint beg=s.pending; // start of bytes to update crc
|
|
byte val;
|
|
|
|
do
|
|
{
|
|
if(s.pending==s.pending_buf_size)
|
|
{
|
|
if(s.gzhead.hcrc!=0&&s.pending>beg) strm.adler=crc32(strm.adler, s.pending_buf, beg, s.pending-beg);
|
|
flush_pending(strm);
|
|
beg=s.pending;
|
|
if(s.pending==s.pending_buf_size)
|
|
{
|
|
val=1;
|
|
break;
|
|
}
|
|
}
|
|
val=s.gzhead.comment[s.gzindex++];
|
|
s.pending_buf[s.pending++]=val;
|
|
} while(val!=0);
|
|
if(s.gzhead.hcrc!=0&&s.pending>beg) strm.adler=crc32(strm.adler, s.pending_buf, beg, s.pending-beg);
|
|
if(val==0) s.status=HCRC_STATE;
|
|
}
|
|
else s.status=HCRC_STATE;
|
|
}
|
|
if(s.status==HCRC_STATE)
|
|
{
|
|
if(s.gzhead.hcrc!=0)
|
|
{
|
|
if(s.pending+2>s.pending_buf_size) flush_pending(strm);
|
|
if(s.pending+2<=s.pending_buf_size)
|
|
{
|
|
s.pending_buf[s.pending++]=(byte)(strm.adler&0xff);
|
|
s.pending_buf[s.pending++]=(byte)((strm.adler>>8)&0xff);
|
|
strm.adler=crc32(0, null, 0);
|
|
s.status=BUSY_STATE;
|
|
}
|
|
}
|
|
else s.status=BUSY_STATE;
|
|
}
|
|
|
|
// Flush as much pending output as possible
|
|
if(s.pending!=0)
|
|
{
|
|
flush_pending(strm);
|
|
if(strm.avail_out==0)
|
|
{
|
|
// Since avail_out is 0, deflate will be called again with
|
|
// more output space, but possibly with both pending and
|
|
// avail_in equal to zero. There won't be anything to do,
|
|
// but this is not an error situation so make sure we
|
|
// return OK instead of BUF_ERROR at next call of deflate:
|
|
s.last_flush=-1;
|
|
return Z_OK;
|
|
}
|
|
|
|
// Make sure there is something to do and avoid duplicate consecutive
|
|
// flushes. For repeated and useless calls with Z_FINISH, we keep
|
|
// returning Z_STREAM_END instead of Z_BUF_ERROR.
|
|
}
|
|
else if(strm.avail_in==0&&flush<=old_flush&&flush!=Z_FINISH)
|
|
{
|
|
strm.msg=zError(Z_BUF_ERROR);
|
|
return Z_BUF_ERROR;
|
|
}
|
|
|
|
// User must not provide more input after the first FINISH:
|
|
if(s.status==FINISH_STATE&&strm.avail_in!=0)
|
|
{
|
|
strm.msg=zError(Z_BUF_ERROR);
|
|
return Z_BUF_ERROR;
|
|
}
|
|
|
|
// Start a new block or continue the current one.
|
|
if(strm.avail_in!=0||s.lookahead!=0||(flush!=Z_NO_FLUSH&&s.status!=FINISH_STATE))
|
|
{
|
|
block_state bstate=s.strategy==Z_HUFFMAN_ONLY?deflate_huff(s, flush):(s.strategy==Z_RLE?deflate_rle(s, flush):configuration_table[s.level].func(s, flush));
|
|
|
|
if(bstate==block_state.finish_started||bstate==block_state.finish_done) s.status=FINISH_STATE;
|
|
if(bstate==block_state.need_more||bstate==block_state.finish_started)
|
|
{
|
|
if(strm.avail_out==0) s.last_flush=-1; // avoid BUF_ERROR next call, see above
|
|
return Z_OK;
|
|
// If flush != Z_NO_FLUSH && avail_out == 0, the next call
|
|
// of deflate should use the same flush parameter to make sure
|
|
// that the flush is complete. So we don't have to output an
|
|
// empty block here, this will be done at next call. This also
|
|
// ensures that for a very small output buffer, we emit at most
|
|
// one empty block.
|
|
}
|
|
if(bstate==block_state.block_done)
|
|
{
|
|
if(flush==Z_PARTIAL_FLUSH) _tr_align(s);
|
|
else if(flush!=Z_BLOCK)
|
|
{ // FULL_FLUSH or SYNC_FLUSH
|
|
_tr_stored_block(s, null, 0, 0);
|
|
// For a full flush, this empty block will be recognized
|
|
// as a special marker by inflate_sync().
|
|
if(flush==Z_FULL_FLUSH)
|
|
{
|
|
s.head[s.hash_size-1]=NIL; // forget history
|
|
|
|
//was memset((byte*)s.head, 0, (uint)(s.hash_size-1)*sizeof(*s.head));
|
|
for(int i=0; i<s.hash_size-1; i++) s.head[i]=0;
|
|
|
|
if(s.lookahead==0)
|
|
{
|
|
s.strstart=0;
|
|
s.block_start=0;
|
|
}
|
|
}
|
|
}
|
|
flush_pending(strm);
|
|
if(strm.avail_out==0)
|
|
{
|
|
s.last_flush=-1; // avoid BUF_ERROR at next call, see above
|
|
return Z_OK;
|
|
}
|
|
}
|
|
}
|
|
//Assert(strm.avail_out>0, "bug2");
|
|
|
|
if(flush!=Z_FINISH) return Z_OK;
|
|
if(s.wrap<=0) return Z_STREAM_END;
|
|
|
|
// Write the trailer
|
|
if(s.wrap==2)
|
|
{
|
|
s.pending_buf[s.pending++]=(byte)(strm.adler&0xff);
|
|
s.pending_buf[s.pending++]=(byte)((strm.adler>>8)&0xff);
|
|
s.pending_buf[s.pending++]=(byte)((strm.adler>>16)&0xff);
|
|
s.pending_buf[s.pending++]=(byte)((strm.adler>>24)&0xff);
|
|
s.pending_buf[s.pending++]=(byte)(strm.total_in&0xff);
|
|
s.pending_buf[s.pending++]=(byte)((strm.total_in>>8)&0xff);
|
|
s.pending_buf[s.pending++]=(byte)((strm.total_in>>16)&0xff);
|
|
s.pending_buf[s.pending++]=(byte)((strm.total_in>>24)&0xff);
|
|
}
|
|
else
|
|
{
|
|
putShortMSB(s, (uint)(strm.adler>>16));
|
|
putShortMSB(s, (uint)(strm.adler&0xffff));
|
|
}
|
|
|
|
flush_pending(strm);
|
|
// If avail_out is zero, the application will call deflate again
|
|
// to flush the rest.
|
|
if(s.wrap>0) s.wrap=-s.wrap; // write the trailer only once!
|
|
return s.pending!=0?Z_OK:Z_STREAM_END;
|
|
}
|
|
#endregion
|
|
|
|
// =========================================================================
|
|
// All dynamically allocated data structures for this stream are freed.
|
|
// This function discards any unprocessed input and does not flush any
|
|
// pending output.
|
|
|
|
// deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the
|
|
// stream state was inconsistent, Z_DATA_ERROR if the stream was freed
|
|
// prematurely (some input or output was discarded). In the error case,
|
|
// msg may be set but then points to a static string (which must not be
|
|
// deallocated).
|
|
|
|
public static int deflateEnd(z_stream strm)
|
|
{
|
|
if(strm==null||strm.state==null) return Z_STREAM_ERROR;
|
|
|
|
deflate_state s=(deflate_state)strm.state;
|
|
int status=s.status;
|
|
if(status!=INIT_STATE&& status!=EXTRA_STATE&& status!=NAME_STATE&& status!=COMMENT_STATE&&
|
|
status!=HCRC_STATE&& status!=BUSY_STATE&&status!=FINISH_STATE) return Z_STREAM_ERROR;
|
|
|
|
// Deallocate in reverse order of allocations:
|
|
//if(s.pending_buf!=null) free(s.pending_buf);
|
|
//if(s.l_buf!=null) free(s.l_buf);
|
|
//if(s.d_buf!=null) free(s.d_buf);
|
|
//if(s.head!=null) free(s.head);
|
|
//if(s.prev!=null) free(s.prev);
|
|
//if(s.window!=null) free(s.window);
|
|
s.pending_buf=s.l_buf=s.window=null;
|
|
s.d_buf=s.head=s.prev=null;
|
|
|
|
//free(strm.state);
|
|
strm.state=s=null;
|
|
|
|
return status==BUSY_STATE?Z_DATA_ERROR:Z_OK;
|
|
}
|
|
|
|
// =========================================================================
|
|
// Sets the destination stream as a complete copy of the source stream.
|
|
|
|
// This function can be useful when several compression strategies will be
|
|
// tried, for example when there are several ways of pre-processing the input
|
|
// data with a filter. The streams that will be discarded should then be freed
|
|
// by calling deflateEnd. Note that deflateCopy duplicates the internal
|
|
// compression state which can be quite large, so this strategy is slow and
|
|
// can consume lots of memory.
|
|
|
|
// deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not
|
|
// enough memory, Z_STREAM_ERROR if the source stream state was inconsistent
|
|
// (such as zalloc being NULL). msg is left unchanged in both source and
|
|
// destination.
|
|
|
|
// Copy the source state to the destination state.
|
|
public static int deflateCopy(z_stream dest, z_stream source)
|
|
{
|
|
if(source==null||dest==null||source.state==null) return Z_STREAM_ERROR;
|
|
|
|
deflate_state ss=(deflate_state)source.state;
|
|
|
|
//was memcpy(dest, source, sizeof(z_stream));
|
|
source.CopyTo(dest);
|
|
|
|
deflate_state ds;
|
|
try
|
|
{
|
|
ds=ss.Clone();
|
|
}
|
|
catch(Exception)
|
|
{
|
|
return Z_MEM_ERROR;
|
|
}
|
|
dest.state=ds;
|
|
//(done above) memcpy(ds, ss, sizeof(deflate_state));
|
|
ds.strm=dest;
|
|
|
|
try
|
|
{
|
|
ds.window=new byte[ds.w_size*2];
|
|
ds.prev=new ushort[ds.w_size];
|
|
ds.head=new ushort[ds.hash_size];
|
|
ds.pending_buf=new byte[ds.lit_bufsize*4];
|
|
ds.d_buf=new ushort[ds.lit_bufsize];
|
|
ds.l_buf=new byte[ds.lit_bufsize];
|
|
}
|
|
catch(Exception)
|
|
{
|
|
deflateEnd(dest);
|
|
return Z_MEM_ERROR;
|
|
}
|
|
|
|
//was memcpy(ds.window, ss.window, ds.w_size*2*sizeof(byte));
|
|
ss.window.CopyTo(ds.window, 0);
|
|
|
|
//was memcpy(ds.prev, ss.prev, ds.w_size*sizeof(ushort));
|
|
ss.prev.CopyTo(ds.prev, 0);
|
|
|
|
//was memcpy(ds.head, ss.head, ds.hash_size*sizeof(ushort));
|
|
ss.head.CopyTo(ds.head, 0);
|
|
|
|
//was memcpy(ds.pending_buf, ss.pending_buf, (uint)ds.pending_buf_size);
|
|
ss.pending_buf.CopyTo(ds.pending_buf, 0);
|
|
ss.d_buf.CopyTo(ds.d_buf, 0);
|
|
ss.l_buf.CopyTo(ds.l_buf, 0);
|
|
|
|
ds.l_desc.dyn_tree=ds.dyn_ltree;
|
|
ds.d_desc.dyn_tree=ds.dyn_dtree;
|
|
ds.bl_desc.dyn_tree=ds.bl_tree;
|
|
|
|
return Z_OK;
|
|
}
|
|
|
|
// ===========================================================================
|
|
// Read a new buffer from the current input stream, update the adler32
|
|
// and total number of bytes read. All deflate() input goes through
|
|
// this function so some applications may wish to modify it to avoid
|
|
// allocating a large strm.next_in buffer and copying from it.
|
|
// (See also flush_pending()).
|
|
static int read_buf(z_stream strm, byte[] buf, uint size)
|
|
{
|
|
return read_buf(strm, buf, 0, size);
|
|
}
|
|
|
|
static int read_buf(z_stream strm, byte[] buf, int buf_ind, uint size)
|
|
{
|
|
uint len=strm.avail_in;
|
|
|
|
if(len>size) len=size;
|
|
if(len==0) return 0;
|
|
|
|
strm.avail_in-=len;
|
|
|
|
deflate_state s=(deflate_state)strm.state;
|
|
|
|
if(s.wrap==1) strm.adler=adler32(strm.adler, strm.in_buf, (uint)strm.next_in, len);
|
|
else if(s.wrap==2) strm.adler=crc32(strm.adler, strm.in_buf, strm.next_in, len);
|
|
|
|
//was memcpy(buf, strm.in_buf+strm.next_in, len);
|
|
Array.Copy(strm.in_buf, strm.next_in, buf, buf_ind, len);
|
|
strm.next_in+=len;
|
|
strm.total_in+=len;
|
|
|
|
return (int)len;
|
|
}
|
|
|
|
// ===========================================================================
|
|
// Initialize the "longest match" routines for a new zlib stream
|
|
static void lm_init(deflate_state s)
|
|
{
|
|
s.window_size=(uint)2*s.w_size;
|
|
|
|
s.head[s.hash_size-1]=NIL;
|
|
|
|
//was memset((byte*)s.head, 0, (uint)(s.hash_size-1)*sizeof(*s.head));
|
|
for(int i=0; i<(s.hash_size-1); i++) s.head[i]=0;
|
|
|
|
// Set the default configuration parameters:
|
|
s.max_lazy_match=configuration_table[s.level].max_lazy;
|
|
s.good_match=configuration_table[s.level].good_length;
|
|
s.nice_match=configuration_table[s.level].nice_length;
|
|
s.max_chain_length=configuration_table[s.level].max_chain;
|
|
|
|
s.strstart=0;
|
|
s.block_start=0;
|
|
s.lookahead=0;
|
|
s.match_length=s.prev_length=MIN_MATCH-1;
|
|
s.match_available=0;
|
|
s.ins_h=0;
|
|
}
|
|
|
|
// ===========================================================================
|
|
// Set match_start to the longest match starting at the given string and
|
|
// return its length. Matches shorter or equal to prev_length are discarded,
|
|
// in which case the result is equal to prev_length and match_start is
|
|
// garbage.
|
|
// IN assertions: cur_match is the head of the hash chain for the current
|
|
// string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1
|
|
// OUT assertion: the match length is not greater than s.lookahead.
|
|
static uint longest_match(deflate_state s, uint cur_match)
|
|
{
|
|
uint chain_length=s.max_chain_length; // max hash chain length
|
|
byte[] scan=s.window; // current string
|
|
int scan_ind=(int)s.strstart;
|
|
int len; // length of current match
|
|
int best_len=(int)s.prev_length; // best match length so far
|
|
int nice_match=s.nice_match; // stop if match long enough
|
|
uint limit=s.strstart>(uint)(s.w_size-MIN_LOOKAHEAD)?s.strstart-(uint)(s.w_size-MIN_LOOKAHEAD):NIL;
|
|
// Stop when cur_match becomes <= limit. To simplify the code,
|
|
// we prevent matches with the string of window index 0.
|
|
ushort[] prev=s.prev;
|
|
uint wmask=s.w_mask;
|
|
|
|
int strend_ind=(int)s.strstart+MAX_MATCH;
|
|
byte scan_end1=scan[scan_ind+best_len-1];
|
|
byte scan_end=scan[scan_ind+best_len];
|
|
|
|
// 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.
|
|
//Assert(s.hash_bits >= 8 && MAX_MATCH == 258, "Code too clever");
|
|
|
|
// Do not waste too much time if we already have a good match:
|
|
if(s.prev_length>=s.good_match) chain_length>>=2;
|
|
|
|
// Do not look for matches beyond the end of the input. This is necessary
|
|
// to make deflate deterministic.
|
|
if((uint)nice_match>s.lookahead) nice_match=(int)s.lookahead;
|
|
|
|
//Assert((uint)s.strstart <= s.window_size-MIN_LOOKAHEAD, "need lookahead");
|
|
|
|
byte[] match=s.window;
|
|
do
|
|
{
|
|
//Assert(cur_match<s.strstart, "no future");
|
|
int match_ind=(int)cur_match;
|
|
|
|
// Skip to next match if the match length cannot increase
|
|
// or if the match length is less than 2. Note that the checks below
|
|
// for insufficient lookahead only occur occasionally for performance
|
|
// reasons. Therefore uninitialized memory will be accessed, and
|
|
// conditional jumps will be made that depend on those values.
|
|
// However the length of the match is limited to the lookahead, so
|
|
// the output of deflate is not affected by the uninitialized values.
|
|
if(match[match_ind+best_len]!=scan_end||match[match_ind+best_len-1]!=scan_end1||
|
|
match[match_ind]!=scan[scan_ind]||match[++match_ind]!=scan[scan_ind+1]) continue;
|
|
|
|
// The check at best_len-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_ind+=2;
|
|
match_ind++;
|
|
//Assert(scan[scan_ind]==match[match_ind], "match[2]?");
|
|
|
|
// We check for insufficient lookahead only every 8th comparison;
|
|
// the 256th check will be made at strstart+258.
|
|
do
|
|
{
|
|
} while(scan[++scan_ind]==match[++match_ind]&&scan[++scan_ind]==match[++match_ind]&&
|
|
scan[++scan_ind]==match[++match_ind]&&scan[++scan_ind]==match[++match_ind]&&
|
|
scan[++scan_ind]==match[++match_ind]&&scan[++scan_ind]==match[++match_ind]&&
|
|
scan[++scan_ind]==match[++match_ind]&&scan[++scan_ind]==match[++match_ind]&&
|
|
scan_ind<strend_ind);
|
|
|
|
//Assert(scan_ind <= (uint)(s.window_size-1), "wild scan");
|
|
|
|
len=MAX_MATCH-(int)(strend_ind-scan_ind);
|
|
scan_ind=strend_ind-MAX_MATCH;
|
|
|
|
if(len>best_len)
|
|
{
|
|
s.match_start=cur_match;
|
|
best_len=len;
|
|
if(len>=nice_match) break;
|
|
|
|
scan_end1=scan[scan_ind+best_len-1];
|
|
scan_end=scan[scan_ind+best_len];
|
|
}
|
|
} while((cur_match=prev[cur_match&wmask])>limit&&--chain_length!=0);
|
|
|
|
if((uint)best_len<=s.lookahead) return (uint)best_len;
|
|
return s.lookahead;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Optimized version for FASTEST only
|
|
static uint longest_match_fast(deflate_state s, uint cur_match)
|
|
{
|
|
byte[] scan=s.window;
|
|
int scan_ind=(int)s.strstart; // current string
|
|
int len; // length of current match
|
|
int strend_ind=(int)s.strstart+MAX_MATCH;
|
|
|
|
// 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.
|
|
//Assert(s.hash_bits >= 8 && MAX_MATCH == 258, "Code too clever");
|
|
|
|
//Assert((uint)s.strstart <= s.window_size-MIN_LOOKAHEAD, "need lookahead");
|
|
|
|
//Assert(cur_match < s.strstart, "no future");
|
|
|
|
byte[] match=s.window;
|
|
int match_ind=(int)cur_match;
|
|
|
|
// Return failure if the match length is less than 2:
|
|
if(match[match_ind]!=scan[scan_ind]||match[match_ind+1]!=scan[scan_ind+1]) return MIN_MATCH-1;
|
|
|
|
// The check at best_len-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_ind+=2;
|
|
match_ind+=2;
|
|
//Assert(scan[scan_ind] == match[match_ind], "match[2]?");
|
|
|
|
// We check for insufficient lookahead only every 8th comparison;
|
|
// the 256th check will be made at strstart+258.
|
|
do
|
|
{
|
|
} while(scan[++scan_ind]==match[++match_ind]&&scan[++scan_ind]==match[++match_ind]&&
|
|
scan[++scan_ind]==match[++match_ind]&&scan[++scan_ind]==match[++match_ind]&&
|
|
scan[++scan_ind]==match[++match_ind]&&scan[++scan_ind]==match[++match_ind]&&
|
|
scan[++scan_ind]==match[++match_ind]&&scan[++scan_ind]==match[++match_ind]&&
|
|
scan_ind<strend_ind);
|
|
|
|
//Assert(scan_ind <= (uint)(s.window_size-1), "wild scan");
|
|
|
|
len=MAX_MATCH-(int)(strend_ind-scan_ind);
|
|
|
|
if(len<MIN_MATCH) return MIN_MATCH-1;
|
|
|
|
s.match_start=cur_match;
|
|
return (uint)len<=s.lookahead?(uint)len:s.lookahead;
|
|
}
|
|
|
|
// ===========================================================================
|
|
// Fill the window when the lookahead becomes insufficient.
|
|
// Updates strstart and lookahead.
|
|
//
|
|
// IN assertion: lookahead < MIN_LOOKAHEAD
|
|
// OUT assertions: strstart <= window_size-MIN_LOOKAHEAD
|
|
// At least one byte has been read, or avail_in == 0; reads are
|
|
// performed for at least two bytes (required for the zip translate_eol
|
|
// option -- not supported here).
|
|
static void fill_window(deflate_state s)
|
|
{
|
|
uint n, m;
|
|
uint more; // Amount of free space at the end of the window.
|
|
uint wsize=s.w_size;
|
|
|
|
do
|
|
{
|
|
more=(uint)(s.window_size-(uint)s.lookahead-(uint)s.strstart);
|
|
|
|
// 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(s.strstart>=wsize+s.w_size-MIN_LOOKAHEAD)
|
|
{
|
|
//was memcpy(s.window, s.window+wsize, (uint)wsize);
|
|
Array.Copy(s.window, wsize, s.window, 0, wsize);
|
|
|
|
s.match_start-=wsize;
|
|
s.strstart-=wsize; // we now have strstart >= MAX_DIST
|
|
s.block_start-=(int)wsize;
|
|
|
|
// Slide the hash table (could be avoided with 32 bit values
|
|
// at the expense of memory usage). We slide even when level == 0
|
|
// to keep the hash table consistent if we switch back to level > 0
|
|
// later. (Using level 0 permanently is not an optimal usage of
|
|
// zlib, so we don't care about this pathological case.)
|
|
n=s.hash_size;
|
|
uint p=n;
|
|
do
|
|
{
|
|
m=s.head[--p];
|
|
s.head[p]=(ushort)(m>=wsize?m-wsize:NIL);
|
|
} while((--n)!=0);
|
|
|
|
n=wsize;
|
|
p=n;
|
|
do
|
|
{
|
|
m=s.prev[--p];
|
|
s.prev[p]=(ushort)(m>=wsize?m-wsize:NIL);
|
|
// If n is not on any hash chain, prev[n] is garbage but
|
|
// its value will never be used.
|
|
} while((--n)!=0);
|
|
more+=wsize;
|
|
}
|
|
if(s.strm.avail_in==0) return;
|
|
|
|
// If there was no sliding:
|
|
// strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 &&
|
|
// more == window_size - lookahead - strstart
|
|
// => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1)
|
|
// => more >= window_size - 2*WSIZE + 2
|
|
// In the BIG_MEM or MMAP case (not yet supported),
|
|
// window_size == input_size + MIN_LOOKAHEAD &&
|
|
// strstart + s.lookahead <= input_size => more >= MIN_LOOKAHEAD.
|
|
// Otherwise, window_size == 2*WSIZE so more >= 2.
|
|
// If there was sliding, more >= WSIZE. So in all cases, more >= 2.
|
|
//Assert(more>=2, "more < 2");
|
|
|
|
n=(uint)read_buf(s.strm, s.window, (int)(s.strstart+s.lookahead), more);
|
|
s.lookahead+=n;
|
|
|
|
// Initialize the hash value now that we have some input:
|
|
if(s.lookahead>=MIN_MATCH)
|
|
{
|
|
s.ins_h=s.window[s.strstart];
|
|
//was UPDATE_HASH(s, s.ins_h, s.window[s.strstart+1]);
|
|
s.ins_h=((s.ins_h<<(int)s.hash_shift)^s.window[s.strstart+1])&s.hash_mask;
|
|
|
|
}
|
|
// If the whole input has less than MIN_MATCH bytes, ins_h is garbage,
|
|
// but this is not important since only literal bytes will be emitted.
|
|
} while(s.lookahead<MIN_LOOKAHEAD&&s.strm.avail_in!=0);
|
|
|
|
// If the WIN_INIT bytes after the end of the current data have never been
|
|
// written, then zero those bytes in order to avoid memory check reports of
|
|
// the use of uninitialized (or uninitialised as Julian writes) bytes by
|
|
// the longest match routines. Update the high water mark for the next
|
|
// time through here. WIN_INIT is set to MAX_MATCH since the longest match
|
|
// routines allow scanning to strstart + MAX_MATCH, ignoring lookahead.
|
|
if(s.high_water<s.window_size)
|
|
{
|
|
uint curr=s.strstart+s.lookahead;
|
|
uint init;
|
|
|
|
if(s.high_water<curr)
|
|
{
|
|
// Previous high water mark below current data -- zero WIN_INIT
|
|
// bytes or up to end of window, whichever is less.
|
|
init=s.window_size-curr;
|
|
if(init>WIN_INIT) init=WIN_INIT;
|
|
for(int i=0; i<init; i++) s.window[curr+i]=0;
|
|
s.high_water=curr+init;
|
|
}
|
|
else if(s.high_water<curr+WIN_INIT)
|
|
{
|
|
// High water mark at or above current data, but below current data
|
|
// plus WIN_INIT -- zero out to current data plus WIN_INIT, or up
|
|
// to end of window, whichever is less.
|
|
init=curr+WIN_INIT-s.high_water;
|
|
if(init>s.window_size-s.high_water) init=s.window_size-s.high_water;
|
|
for(int i=0; i<init; i++) s.window[s.high_water+i]=0;
|
|
s.high_water+=init;
|
|
}
|
|
}
|
|
}
|
|
|
|
// ===========================================================================
|
|
// Flush the current block, with given end-of-file flag.
|
|
// IN assertion: strstart is set to the end of the current match.
|
|
//#define FLUSH_BLOCK_ONLY(s, last) \
|
|
//{ \
|
|
// _tr_flush_block(s, s.block_start >= 0 ? s.window : null, s.block_start >= 0?s.block_start:0, \
|
|
// (uint)((int)s.strstart - s.block_start), (last)); \
|
|
// s.block_start = s.strstart; \
|
|
// flush_pending(s.strm); \
|
|
// Tracev((stderr,"[FLUSH]")); \
|
|
//}
|
|
|
|
// Same but force premature exit if necessary.
|
|
//#define FLUSH_BLOCK(s, last) \
|
|
//{ \
|
|
// _tr_flush_block(s, s.block_start >= 0 ? s.window : null, s.block_start >= 0?s.block_start:0, \
|
|
// (uint)((int)s.strstart - s.block_start), (last)); \
|
|
// s.block_start = s.strstart; \
|
|
// flush_pending(s.strm); \
|
|
// Tracev((stderr,"[FLUSH]")); \
|
|
// if (s.strm.avail_out == 0) return (last) ? finish_started : need_more; \
|
|
//}
|
|
|
|
// ===========================================================================
|
|
// Copy without compression as much as possible from the input stream, return
|
|
// the current block state.
|
|
// This function does not insert new strings in the dictionary since
|
|
// uncompressible data is probably not useful. This function is used
|
|
// only for the level=0 compression option.
|
|
// NOTE: this function should be optimized to avoid extra copying from
|
|
// window to pending_buf.
|
|
static block_state deflate_stored(deflate_state s, int flush)
|
|
{
|
|
// Stored blocks are limited to 0xffff bytes, pending_buf is limited
|
|
// to pending_buf_size, and each stored block has a 5 byte header:
|
|
uint max_block_size=0xffff;
|
|
uint max_start;
|
|
|
|
if(max_block_size>s.pending_buf_size-5) max_block_size=s.pending_buf_size-5;
|
|
|
|
// Copy as much as possible from input to output:
|
|
for(; ; )
|
|
{
|
|
// Fill the window as much as possible:
|
|
if(s.lookahead<=1)
|
|
{
|
|
//Assert(s.strstart<s.w_size+MAX_DIST(s)||s.block_start>=(int)s.w_size, "slide too late");
|
|
|
|
fill_window(s);
|
|
if(s.lookahead==0&&flush==Z_NO_FLUSH) return block_state.need_more;
|
|
|
|
if(s.lookahead==0) break; // flush the current block
|
|
}
|
|
//Assert(s.block_start>=0, "block gone");
|
|
|
|
s.strstart+=s.lookahead;
|
|
s.lookahead=0;
|
|
|
|
// Emit a stored block if pending_buf will be full:
|
|
max_start=(uint)s.block_start+max_block_size;
|
|
if(s.strstart==0||(uint)s.strstart>=max_start)
|
|
{
|
|
// strstart == 0 is possible when wraparound on 16-bit machine
|
|
s.lookahead=(uint)(s.strstart-max_start);
|
|
s.strstart=(uint)max_start;
|
|
|
|
//was FLUSH_BLOCK(s, 0);
|
|
_tr_flush_block(s, s.block_start>=0?s.window:null, s.block_start>=0?s.block_start:0,
|
|
(uint)((int)s.strstart-s.block_start), 0);
|
|
s.block_start=(int)s.strstart;
|
|
flush_pending(s.strm);
|
|
//Tracev((stderr,"[FLUSH]"));
|
|
if(s.strm.avail_out==0) return block_state.need_more;
|
|
}
|
|
// Flush if we may have to slide, otherwise block_start may become
|
|
// negative and the data will be gone:
|
|
if(s.strstart-(uint)s.block_start>=(s.w_size-MIN_LOOKAHEAD))
|
|
{
|
|
//was FLUSH_BLOCK(s, 0);
|
|
_tr_flush_block(s, s.block_start >= 0 ? s.window : null, s.block_start >= 0?s.block_start:0,
|
|
(uint)((int)s.strstart - s.block_start), 0);
|
|
s.block_start = (int)s.strstart;
|
|
flush_pending(s.strm);
|
|
//Tracev((stderr,"[FLUSH]"));
|
|
if (s.strm.avail_out == 0) return block_state.need_more;
|
|
}
|
|
}
|
|
|
|
//was FLUSH_BLOCK(s, flush==Z_FINISH);
|
|
_tr_flush_block(s, s.block_start>=0?s.window:null, s.block_start>=0?s.block_start:0,
|
|
(uint)((int)s.strstart-s.block_start), flush==Z_FINISH?1:0);
|
|
s.block_start=(int)s.strstart;
|
|
flush_pending(s.strm);
|
|
//Tracev((stderr,"[FLUSH]"));
|
|
if(s.strm.avail_out==0) return flush==Z_FINISH?block_state.finish_started:block_state.need_more;
|
|
|
|
return flush==Z_FINISH?block_state.finish_done:block_state.block_done;
|
|
}
|
|
|
|
// ===========================================================================
|
|
// Compress as much as possible from the input stream, return the current
|
|
// block state.
|
|
// This function does not perform lazy evaluation of matches and inserts
|
|
// new strings in the dictionary only for unmatched strings or for short
|
|
// matches. It is used only for the fast compression options.
|
|
static block_state deflate_fast(deflate_state s, int flush)
|
|
{
|
|
uint hash_head=NIL; // head of the hash chain
|
|
int bflush; // set if current block must be flushed
|
|
|
|
for(; ; )
|
|
{
|
|
// Make sure that we always have enough lookahead, except
|
|
// at the end of the input file. We need MAX_MATCH bytes
|
|
// for the next match, plus MIN_MATCH bytes to insert the
|
|
// string following the next match.
|
|
if(s.lookahead<MIN_LOOKAHEAD)
|
|
{
|
|
fill_window(s);
|
|
if(s.lookahead<MIN_LOOKAHEAD&&flush==Z_NO_FLUSH) return block_state.need_more;
|
|
if(s.lookahead==0) break; // flush the current block
|
|
}
|
|
|
|
// Insert the string window[strstart .. strstart+2] in the
|
|
// dictionary, and set hash_head to the head of the hash chain:
|
|
hash_head=NIL;
|
|
if(s.lookahead>=MIN_MATCH)
|
|
{
|
|
//was INSERT_STRING(s, s.strstart, hash_head);
|
|
s.ins_h=((s.ins_h<<(int)s.hash_shift)^s.window[s.strstart+(MIN_MATCH-1)])&s.hash_mask;
|
|
hash_head=s.prev[s.strstart&s.w_mask]=s.head[s.ins_h];
|
|
s.head[s.ins_h]=(ushort)s.strstart;
|
|
}
|
|
|
|
// Find the longest match, discarding those <= prev_length.
|
|
// At this point we have always match_length < MIN_MATCH
|
|
if(hash_head!=NIL&&s.strstart-hash_head<=(s.w_size-MIN_LOOKAHEAD))
|
|
{
|
|
// 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 file).
|
|
s.match_length=longest_match_fast(s, hash_head);
|
|
// longest_match_fast() sets match_start
|
|
}
|
|
if(s.match_length>=MIN_MATCH)
|
|
{
|
|
//was _tr_tally_dist(s, s.strstart - s.match_start, s.match_length - MIN_MATCH, bflush);
|
|
{
|
|
byte len=(byte)(s.match_length-MIN_MATCH);
|
|
ushort dist=(ushort)(s.strstart-s.match_start);
|
|
s.d_buf[s.last_lit]=dist;
|
|
s.l_buf[s.last_lit++]=len;
|
|
dist--;
|
|
s.dyn_ltree[_length_code[len]+LITERALS+1].Freq++;
|
|
s.dyn_dtree[(dist<256?_dist_code[dist]:_dist_code[256+(dist>>7)])].Freq++;
|
|
bflush=(s.last_lit==s.lit_bufsize-1)?1:0;
|
|
}
|
|
|
|
s.lookahead-=s.match_length;
|
|
|
|
// Insert new strings in the hash table only if the match length
|
|
// is not too large. This saves time but degrades compression.
|
|
if(s.match_length<=s.max_lazy_match&&s.lookahead>=MIN_MATCH) // max_lazy_match was max_insert_length as #define
|
|
{
|
|
s.match_length--; // string at strstart already in table
|
|
do
|
|
{
|
|
s.strstart++;
|
|
//was INSERT_STRING(s, s.strstart, hash_head);
|
|
s.ins_h=((s.ins_h<<(int)s.hash_shift)^s.window[s.strstart+(MIN_MATCH-1)])&s.hash_mask;
|
|
hash_head=s.prev[s.strstart&s.w_mask]=s.head[s.ins_h];
|
|
s.head[s.ins_h]=(ushort)s.strstart;
|
|
|
|
// strstart never exceeds WSIZE-MAX_MATCH, so there are
|
|
// always MIN_MATCH bytes ahead.
|
|
} while(--s.match_length!=0);
|
|
s.strstart++;
|
|
}
|
|
else
|
|
{
|
|
s.strstart+=s.match_length;
|
|
s.match_length=0;
|
|
s.ins_h=s.window[s.strstart];
|
|
//was UPDATE_HASH(s, s.ins_h, s.window[s.strstart+1]);
|
|
s.ins_h=((s.ins_h<<(int)s.hash_shift)^s.window[s.strstart+1])&s.hash_mask;
|
|
|
|
// If lookahead < MIN_MATCH, ins_h is garbage, but it does not
|
|
// matter since it will be recomputed at next deflate call.
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// No match, output a literal byte
|
|
//Tracevv((stderr,"%c", s.window[s.strstart]));
|
|
|
|
//was _tr_tally_lit (s, s.window[s.strstart], bflush);
|
|
{
|
|
byte cc=s.window[s.strstart];
|
|
s.d_buf[s.last_lit]=0;
|
|
s.l_buf[s.last_lit++]=cc;
|
|
s.dyn_ltree[cc].Freq++;
|
|
bflush=(s.last_lit==s.lit_bufsize-1)?1:0;
|
|
}
|
|
|
|
s.lookahead--;
|
|
s.strstart++;
|
|
}
|
|
|
|
if(bflush!=0)
|
|
{
|
|
//was FLUSH_BLOCK(s, 0);
|
|
_tr_flush_block(s, s.block_start>=0?s.window:null, s.block_start>=0?s.block_start:0,
|
|
(uint)((int)s.strstart-s.block_start), 0);
|
|
s.block_start=(int)s.strstart;
|
|
flush_pending(s.strm);
|
|
//Tracev((stderr,"[FLUSH]"));
|
|
if(s.strm.avail_out==0) return block_state.need_more;
|
|
}
|
|
}
|
|
//was FLUSH_BLOCK(s, flush==Z_FINISH);
|
|
_tr_flush_block(s, s.block_start>=0?s.window:null, s.block_start>=0?s.block_start:0,
|
|
(uint)((int)s.strstart-s.block_start), flush==Z_FINISH?1:0);
|
|
s.block_start=(int)s.strstart;
|
|
flush_pending(s.strm);
|
|
//Tracev((stderr,"[FLUSH]"));
|
|
if(s.strm.avail_out==0) return flush==Z_FINISH?block_state.finish_started:block_state.need_more;
|
|
|
|
return flush==Z_FINISH?block_state.finish_done:block_state.block_done;
|
|
}
|
|
|
|
// ===========================================================================
|
|
// Same as above, but achieves better compression. We use a lazy
|
|
// evaluation for matches: a match is finally adopted only if there is
|
|
// no better match at the next window position.
|
|
static block_state deflate_slow(deflate_state s, int flush)
|
|
{
|
|
uint hash_head=NIL; // head of hash chain
|
|
int bflush; // set if current block must be flushed
|
|
|
|
// Process the input block.
|
|
for(; ; )
|
|
{
|
|
// Make sure that we always have enough lookahead, except
|
|
// at the end of the input file. We need MAX_MATCH bytes
|
|
// for the next match, plus MIN_MATCH bytes to insert the
|
|
// string following the next match.
|
|
if(s.lookahead<MIN_LOOKAHEAD)
|
|
{
|
|
fill_window(s);
|
|
if(s.lookahead<MIN_LOOKAHEAD&&flush==Z_NO_FLUSH) return block_state.need_more;
|
|
if(s.lookahead==0) break; // flush the current block
|
|
}
|
|
|
|
// Insert the string window[strstart .. strstart+2] in the
|
|
// dictionary, and set hash_head to the head of the hash chain:
|
|
hash_head=NIL;
|
|
if(s.lookahead>=MIN_MATCH)
|
|
{
|
|
//was INSERT_STRING(s, s.strstart, hash_head);
|
|
s.ins_h=((s.ins_h<<(int)s.hash_shift)^s.window[s.strstart+(MIN_MATCH-1)])&s.hash_mask;
|
|
hash_head=s.prev[s.strstart&s.w_mask]=s.head[s.ins_h];
|
|
s.head[s.ins_h]=(ushort)s.strstart;
|
|
}
|
|
|
|
// Find the longest match, discarding those <= prev_length.
|
|
s.prev_length=s.match_length;
|
|
s.prev_match=s.match_start;
|
|
s.match_length=MIN_MATCH-1;
|
|
|
|
if(hash_head!=NIL&&s.prev_length<s.max_lazy_match&&s.strstart-hash_head<=(s.w_size-MIN_LOOKAHEAD))
|
|
{
|
|
// 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 file).
|
|
s.match_length=longest_match(s, hash_head);
|
|
// longest_match() sets match_start
|
|
|
|
if(s.match_length<=5&&(s.strategy==Z_FILTERED||
|
|
(s.match_length==MIN_MATCH&&s.strstart-s.match_start>TOO_FAR)))
|
|
{
|
|
// If prev_match is also MIN_MATCH, match_start is garbage
|
|
// but we will ignore the current match anyway.
|
|
s.match_length=MIN_MATCH-1;
|
|
}
|
|
}
|
|
|
|
// If there was a match at the previous step and the current
|
|
// match is not better, output the previous match:
|
|
if(s.prev_length>=MIN_MATCH&&s.match_length<=s.prev_length)
|
|
{
|
|
uint max_insert=s.strstart+s.lookahead-MIN_MATCH;
|
|
// Do not insert strings in hash table beyond this.
|
|
|
|
//was _tr_tally_dist(s, s.strstart -1 - s.prev_match, s.prev_length - MIN_MATCH, bflush);
|
|
{
|
|
byte len=(byte)(s.prev_length-MIN_MATCH);
|
|
ushort dist=(ushort)(s.strstart-1-s.prev_match);
|
|
s.d_buf[s.last_lit]=dist;
|
|
s.l_buf[s.last_lit++]=len;
|
|
dist--;
|
|
s.dyn_ltree[_length_code[len]+LITERALS+1].Freq++;
|
|
s.dyn_dtree[(dist<256?_dist_code[dist]:_dist_code[256+(dist>>7)])].Freq++;
|
|
bflush=(s.last_lit==s.lit_bufsize-1)?1:0;
|
|
}
|
|
|
|
// Insert in hash table all strings up to the end of the match.
|
|
// strstart-1 and strstart are already inserted. If there is not
|
|
// enough lookahead, the last two strings are not inserted in
|
|
// the hash table.
|
|
s.lookahead-=s.prev_length-1;
|
|
s.prev_length-=2;
|
|
do
|
|
{
|
|
if(++s.strstart<=max_insert)
|
|
{
|
|
//was INSERT_STRING(s, s.strstart, hash_head);
|
|
s.ins_h=((s.ins_h<<(int)s.hash_shift)^s.window[s.strstart+(MIN_MATCH-1)])&s.hash_mask;
|
|
hash_head=s.prev[s.strstart&s.w_mask]=s.head[s.ins_h];
|
|
s.head[s.ins_h]=(ushort)s.strstart;
|
|
}
|
|
} while(--s.prev_length!=0);
|
|
s.match_available=0;
|
|
s.match_length=MIN_MATCH-1;
|
|
s.strstart++;
|
|
|
|
if(bflush!=0)
|
|
{
|
|
//was FLUSH_BLOCK(s, 0);
|
|
_tr_flush_block(s, s.block_start>=0?s.window:null, s.block_start>=0?s.block_start:0,
|
|
(uint)((int)s.strstart-s.block_start), 0);
|
|
s.block_start=(int)s.strstart;
|
|
flush_pending(s.strm);
|
|
//Tracev((stderr,"[FLUSH]"));
|
|
if(s.strm.avail_out==0) return block_state.need_more;
|
|
}
|
|
}
|
|
else if(s.match_available!=0)
|
|
{
|
|
// 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.
|
|
//Tracevv((stderr,"%c", s.window[s.strstart-1]));
|
|
|
|
//was _tr_tally_lit(s, s.window[s.strstart-1], bflush);
|
|
{
|
|
byte cc=s.window[s.strstart-1];
|
|
s.d_buf[s.last_lit]=0;
|
|
s.l_buf[s.last_lit++]=cc;
|
|
s.dyn_ltree[cc].Freq++;
|
|
bflush=(s.last_lit==s.lit_bufsize-1)?1:0;
|
|
}
|
|
|
|
if(bflush!=0)
|
|
{
|
|
//was FLUSH_BLOCK_ONLY(s, 0);
|
|
_tr_flush_block(s, s.block_start>=0?s.window:null, s.block_start>=0?s.block_start:0,
|
|
(uint)((int)s.strstart-s.block_start), 0);
|
|
s.block_start=(int)s.strstart;
|
|
flush_pending(s.strm);
|
|
//Tracev((stderr,"[FLUSH]"));
|
|
}
|
|
s.strstart++;
|
|
s.lookahead--;
|
|
if(s.strm.avail_out==0) return block_state.need_more;
|
|
}
|
|
else
|
|
{
|
|
// There is no previous match to compare with, wait for
|
|
// the next step to decide.
|
|
s.match_available=1;
|
|
s.strstart++;
|
|
s.lookahead--;
|
|
}
|
|
}
|
|
//Assert(flush!=Z_NO_FLUSH, "no flush?");
|
|
if(s.match_available!=0)
|
|
{
|
|
//Tracevv((stderr,"%c", s.window[s.strstart-1]));
|
|
|
|
//was _tr_tally_lit(s, s.window[s.strstart-1], bflush);
|
|
{
|
|
byte cc=s.window[s.strstart-1];
|
|
s.d_buf[s.last_lit]=0;
|
|
s.l_buf[s.last_lit++]=cc;
|
|
s.dyn_ltree[cc].Freq++;
|
|
bflush=(s.last_lit==s.lit_bufsize-1)?1:0;
|
|
}
|
|
|
|
s.match_available=0;
|
|
}
|
|
//was FLUSH_BLOCK(s, flush==Z_FINISH);
|
|
_tr_flush_block(s, s.block_start>=0?s.window:null, s.block_start>=0?s.block_start:0,
|
|
(uint)((int)s.strstart-s.block_start), flush==Z_FINISH?1:0);
|
|
s.block_start=(int)s.strstart;
|
|
flush_pending(s.strm);
|
|
//Tracev((stderr,"[FLUSH]"));
|
|
if(s.strm.avail_out==0) return flush==Z_FINISH?block_state.finish_started:block_state.need_more;
|
|
|
|
return flush==Z_FINISH?block_state.finish_done:block_state.block_done;
|
|
}
|
|
|
|
// ===========================================================================
|
|
// For Z_RLE, simply look for runs of bytes, generate matches only of distance
|
|
// one. Do not maintain a hash table. (It will be regenerated if this run of
|
|
// deflate switches away from Z_RLE.)
|
|
static block_state deflate_rle(deflate_state s, int flush)
|
|
{
|
|
bool bflush; // set if current block must be flushed
|
|
uint prev; // byte at distance one to match
|
|
int scan, strend; // scan goes up to strend for length of run
|
|
|
|
for(; ; )
|
|
{
|
|
// Make sure that we always have enough lookahead, except
|
|
// at the end of the input file. We need MAX_MATCH bytes
|
|
// for the longest encodable run.
|
|
if(s.lookahead<MAX_MATCH)
|
|
{
|
|
fill_window(s);
|
|
if(s.lookahead<MAX_MATCH&&flush==Z_NO_FLUSH) return block_state.need_more;
|
|
if(s.lookahead==0) break; // flush the current block
|
|
}
|
|
|
|
// See how many times the previous byte repeats
|
|
s.match_length=0;
|
|
if(s.lookahead>=MIN_MATCH&&s.strstart>0)
|
|
{
|
|
scan=(int)(s.strstart-1);
|
|
prev=s.window[scan];
|
|
if(prev==s.window[++scan]&&prev==s.window[++scan]&&prev==s.window[++scan])
|
|
{
|
|
strend=(int)(s.strstart+MAX_MATCH);
|
|
do
|
|
{
|
|
} while(prev==s.window[++scan]&&prev==s.window[++scan]&&
|
|
prev==s.window[++scan]&&prev==s.window[++scan]&&
|
|
prev==s.window[++scan]&&prev==s.window[++scan]&&
|
|
prev==s.window[++scan]&&prev==s.window[++scan]&&
|
|
scan<strend);
|
|
s.match_length=MAX_MATCH-(uint)(strend-scan);
|
|
if(s.match_length>s.lookahead) s.match_length=s.lookahead;
|
|
}
|
|
}
|
|
|
|
// Emit match if have run of MIN_MATCH or longer, else emit literal
|
|
if(s.match_length>=MIN_MATCH)
|
|
{
|
|
//was _tr_tally_dist(s, 1, s.match_length-MIN_MATCH, bflush);
|
|
{
|
|
byte len=(byte)(s.match_length-MIN_MATCH);
|
|
ushort dist=1;
|
|
s.d_buf[s.last_lit]=dist;
|
|
s.l_buf[s.last_lit++]=len;
|
|
dist--;
|
|
s.dyn_ltree[_length_code[len]+LITERALS+1].Freq++;
|
|
s.dyn_dtree[(dist<256?_dist_code[dist]:_dist_code[256+(dist>>7)])].Freq++;
|
|
bflush=(s.last_lit==s.lit_bufsize-1)?true:false;
|
|
}
|
|
|
|
s.lookahead-=s.match_length;
|
|
s.strstart+=s.match_length;
|
|
s.match_length=0;
|
|
}
|
|
else
|
|
{
|
|
// No match, output a literal byte
|
|
//Tracevv((stderr,"%c", s.window[s.strstart]));
|
|
//was _tr_tally_lit(s, s.window[s.strstart], bflush);
|
|
{
|
|
byte cc=s.window[s.strstart];
|
|
s.d_buf[s.last_lit]=0;
|
|
s.l_buf[s.last_lit++]=cc;
|
|
s.dyn_ltree[cc].Freq++;
|
|
bflush=(s.last_lit==s.lit_bufsize-1)?true:false;
|
|
}
|
|
|
|
s.lookahead--;
|
|
s.strstart++;
|
|
}
|
|
if(bflush)
|
|
{
|
|
// FLUSH_BLOCK(s, 0);
|
|
_tr_flush_block(s, s.block_start>=0?s.window:null, s.block_start>=0?s.block_start:0,
|
|
(uint)((int)s.strstart-s.block_start), 0);
|
|
s.block_start=(int)s.strstart;
|
|
flush_pending(s.strm);
|
|
//Tracev((stderr,"[FLUSH]"));
|
|
if(s.strm.avail_out==0) return block_state.need_more;
|
|
}
|
|
}
|
|
|
|
//was FLUSH_BLOCK(s, flush==Z_FINISH);
|
|
_tr_flush_block(s, s.block_start>=0?s.window:null, s.block_start>=0?s.block_start:0,
|
|
(uint)((int)s.strstart-s.block_start), flush==Z_FINISH?1:0);
|
|
s.block_start=(int)s.strstart;
|
|
flush_pending(s.strm);
|
|
//Tracev((stderr,"[FLUSH]"));
|
|
if(s.strm.avail_out==0) return flush==Z_FINISH?block_state.finish_started:block_state.need_more;
|
|
|
|
return flush==Z_FINISH?block_state.finish_done:block_state.block_done;
|
|
}
|
|
|
|
// ===========================================================================
|
|
// For Z_HUFFMAN_ONLY, do not look for matches. Do not maintain a hash table.
|
|
// (It will be regenerated if this run of deflate switches away from Huffman.)
|
|
static block_state deflate_huff(deflate_state s, int flush)
|
|
{
|
|
bool bflush; // set if current block must be flushed
|
|
|
|
for(; ; )
|
|
{
|
|
// Make sure that we have a literal to write.
|
|
if(s.lookahead==0)
|
|
{
|
|
fill_window(s);
|
|
if(s.lookahead==0)
|
|
{
|
|
if(flush==Z_NO_FLUSH)
|
|
return block_state.need_more;
|
|
break; // flush the current block
|
|
}
|
|
}
|
|
|
|
// Output a literal byte
|
|
s.match_length=0;
|
|
//Tracevv((stderr,"%c", s.window[s.strstart]));
|
|
|
|
//was _tr_tally_lit(s, s.window[s.strstart], bflush);
|
|
{
|
|
byte cc=s.window[s.strstart];
|
|
s.d_buf[s.last_lit]=0;
|
|
s.l_buf[s.last_lit++]=cc;
|
|
s.dyn_ltree[cc].Freq++;
|
|
bflush=(s.last_lit==s.lit_bufsize-1)?true:false;
|
|
}
|
|
|
|
s.lookahead--;
|
|
s.strstart++;
|
|
if(bflush)
|
|
{
|
|
// FLUSH_BLOCK(s, 0);
|
|
_tr_flush_block(s, s.block_start>=0?s.window:null, s.block_start>=0?s.block_start:0,
|
|
(uint)((int)s.strstart-s.block_start), 0);
|
|
s.block_start=(int)s.strstart;
|
|
flush_pending(s.strm);
|
|
//Tracev((stderr,"[FLUSH]"));
|
|
if(s.strm.avail_out==0) return block_state.need_more;
|
|
}
|
|
}
|
|
|
|
//was FLUSH_BLOCK(s, flush==Z_FINISH);
|
|
_tr_flush_block(s, s.block_start>=0?s.window:null, s.block_start>=0?s.block_start:0,
|
|
(uint)((int)s.strstart-s.block_start), flush==Z_FINISH?1:0);
|
|
s.block_start=(int)s.strstart;
|
|
flush_pending(s.strm);
|
|
//Tracev((stderr,"[FLUSH]"));
|
|
if(s.strm.avail_out==0) return flush==Z_FINISH?block_state.finish_started:block_state.need_more;
|
|
|
|
return flush==Z_FINISH?block_state.finish_done:block_state.block_done;
|
|
}
|
|
}
|
|
}
|