LCOV - code coverage report
Current view: directory - modules/zlib/src - deflate.c (source / functions) Found Hit Coverage
Test: app.info Lines: 662 357 53.9 %
Date: 2012-06-02 Functions: 23 12 52.2 %

       1                 : /* deflate.c -- compress data using the deflation algorithm
       2                 :  * Copyright (C) 1995-2010 Jean-loup Gailly and Mark Adler
       3                 :  * For conditions of distribution and use, see copyright notice in zlib.h
       4                 :  */
       5                 : 
       6                 : /*
       7                 :  *  ALGORITHM
       8                 :  *
       9                 :  *      The "deflation" process depends on being able to identify portions
      10                 :  *      of the input text which are identical to earlier input (within a
      11                 :  *      sliding window trailing behind the input currently being processed).
      12                 :  *
      13                 :  *      The most straightforward technique turns out to be the fastest for
      14                 :  *      most input files: try all possible matches and select the longest.
      15                 :  *      The key feature of this algorithm is that insertions into the string
      16                 :  *      dictionary are very simple and thus fast, and deletions are avoided
      17                 :  *      completely. Insertions are performed at each input character, whereas
      18                 :  *      string matches are performed only when the previous match ends. So it
      19                 :  *      is preferable to spend more time in matches to allow very fast string
      20                 :  *      insertions and avoid deletions. The matching algorithm for small
      21                 :  *      strings is inspired from that of Rabin & Karp. A brute force approach
      22                 :  *      is used to find longer strings when a small match has been found.
      23                 :  *      A similar algorithm is used in comic (by Jan-Mark Wams) and freeze
      24                 :  *      (by Leonid Broukhis).
      25                 :  *         A previous version of this file used a more sophisticated algorithm
      26                 :  *      (by Fiala and Greene) which is guaranteed to run in linear amortized
      27                 :  *      time, but has a larger average cost, uses more memory and is patented.
      28                 :  *      However the F&G algorithm may be faster for some highly redundant
      29                 :  *      files if the parameter max_chain_length (described below) is too large.
      30                 :  *
      31                 :  *  ACKNOWLEDGEMENTS
      32                 :  *
      33                 :  *      The idea of lazy evaluation of matches is due to Jan-Mark Wams, and
      34                 :  *      I found it in 'freeze' written by Leonid Broukhis.
      35                 :  *      Thanks to many people for bug reports and testing.
      36                 :  *
      37                 :  *  REFERENCES
      38                 :  *
      39                 :  *      Deutsch, L.P.,"DEFLATE Compressed Data Format Specification".
      40                 :  *      Available in http://www.ietf.org/rfc/rfc1951.txt
      41                 :  *
      42                 :  *      A description of the Rabin and Karp algorithm is given in the book
      43                 :  *         "Algorithms" by R. Sedgewick, Addison-Wesley, p252.
      44                 :  *
      45                 :  *      Fiala,E.R., and Greene,D.H.
      46                 :  *         Data Compression with Finite Windows, Comm.ACM, 32,4 (1989) 490-595
      47                 :  *
      48                 :  */
      49                 : 
      50                 : /* @(#) $Id$ */
      51                 : 
      52                 : #include "deflate.h"
      53                 : 
      54                 : const char deflate_copyright[] =
      55                 :    " deflate 1.2.5 Copyright 1995-2010 Jean-loup Gailly and Mark Adler ";
      56                 : /*
      57                 :   If you use the zlib library in a product, an acknowledgment is welcome
      58                 :   in the documentation of your product. If for some reason you cannot
      59                 :   include such an acknowledgment, I would appreciate that you keep this
      60                 :   copyright string in the executable of your product.
      61                 :  */
      62                 : 
      63                 : /* ===========================================================================
      64                 :  *  Function prototypes.
      65                 :  */
      66                 : typedef enum {
      67                 :     need_more,      /* block not completed, need more input or more output */
      68                 :     block_done,     /* block flush performed */
      69                 :     finish_started, /* finish started, need only more output at next deflate */
      70                 :     finish_done     /* finish done, accept no more input or output */
      71                 : } block_state;
      72                 : 
      73                 : typedef block_state (*compress_func) OF((deflate_state *s, int flush));
      74                 : /* Compression function. Returns the block state after the call. */
      75                 : 
      76                 : local void fill_window    OF((deflate_state *s));
      77                 : local block_state deflate_stored OF((deflate_state *s, int flush));
      78                 : local block_state deflate_fast   OF((deflate_state *s, int flush));
      79                 : #ifndef FASTEST
      80                 : local block_state deflate_slow   OF((deflate_state *s, int flush));
      81                 : #endif
      82                 : local block_state deflate_rle    OF((deflate_state *s, int flush));
      83                 : local block_state deflate_huff   OF((deflate_state *s, int flush));
      84                 : local void lm_init        OF((deflate_state *s));
      85                 : local void putShortMSB    OF((deflate_state *s, uInt b));
      86                 : local void flush_pending  OF((z_streamp strm));
      87                 : local int read_buf        OF((z_streamp strm, Bytef *buf, unsigned size));
      88                 : #ifdef ASMV
      89                 :       void match_init OF((void)); /* asm code initialization */
      90                 :       uInt longest_match  OF((deflate_state *s, IPos cur_match));
      91                 : #else
      92                 : local uInt longest_match  OF((deflate_state *s, IPos cur_match));
      93                 : #endif
      94                 : 
      95                 : #ifdef DEBUG
      96                 : local  void check_match OF((deflate_state *s, IPos start, IPos match,
      97                 :                             int length));
      98                 : #endif
      99                 : 
     100                 : /* ===========================================================================
     101                 :  * Local data
     102                 :  */
     103                 : 
     104                 : #define NIL 0
     105                 : /* Tail of hash chains */
     106                 : 
     107                 : #ifndef TOO_FAR
     108                 : #  define TOO_FAR 4096
     109                 : #endif
     110                 : /* Matches of length 3 are discarded if their distance exceeds TOO_FAR */
     111                 : 
     112                 : /* Values for max_lazy_match, good_match and max_chain_length, depending on
     113                 :  * the desired pack level (0..9). The values given below have been tuned to
     114                 :  * exclude worst case performance for pathological files. Better values may be
     115                 :  * found for specific files.
     116                 :  */
     117                 : typedef struct config_s {
     118                 :    ush good_length; /* reduce lazy search above this match length */
     119                 :    ush max_lazy;    /* do not perform lazy search above this match length */
     120                 :    ush nice_length; /* quit search above this match length */
     121                 :    ush max_chain;
     122                 :    compress_func func;
     123                 : } config;
     124                 : 
     125                 : #ifdef FASTEST
     126                 : local const config configuration_table[2] = {
     127                 : /*      good lazy nice chain */
     128                 : /* 0 */ {0,    0,  0,    0, deflate_stored},  /* store only */
     129                 : /* 1 */ {4,    4,  8,    4, deflate_fast}}; /* max speed, no lazy matches */
     130                 : #else
     131                 : local const config configuration_table[10] = {
     132                 : /*      good lazy nice chain */
     133                 : /* 0 */ {0,    0,  0,    0, deflate_stored},  /* store only */
     134                 : /* 1 */ {4,    4,  8,    4, deflate_fast}, /* max speed, no lazy matches */
     135                 : /* 2 */ {4,    5, 16,    8, deflate_fast},
     136                 : /* 3 */ {4,    6, 32,   32, deflate_fast},
     137                 : 
     138                 : /* 4 */ {4,    4, 16,   16, deflate_slow},  /* lazy matches */
     139                 : /* 5 */ {8,   16, 32,   32, deflate_slow},
     140                 : /* 6 */ {8,   16, 128, 128, deflate_slow},
     141                 : /* 7 */ {8,   32, 128, 256, deflate_slow},
     142                 : /* 8 */ {32, 128, 258, 1024, deflate_slow},
     143                 : /* 9 */ {32, 258, 258, 4096, deflate_slow}}; /* max compression */
     144                 : #endif
     145                 : 
     146                 : /* Note: the deflate() code requires max_lazy >= MIN_MATCH and max_chain >= 4
     147                 :  * For deflate_fast() (levels <= 3) good is ignored and lazy has a different
     148                 :  * meaning.
     149                 :  */
     150                 : 
     151                 : #define EQUAL 0
     152                 : /* result of memcmp for equal strings */
     153                 : 
     154                 : #ifndef NO_DUMMY_DECL
     155                 : struct static_tree_desc_s {int dummy;}; /* for buggy compilers */
     156                 : #endif
     157                 : 
     158                 : /* ===========================================================================
     159                 :  * Update a hash value with the given input byte
     160                 :  * IN  assertion: all calls to to UPDATE_HASH are made with consecutive
     161                 :  *    input characters, so that a running hash key can be computed from the
     162                 :  *    previous key instead of complete recalculation each time.
     163                 :  */
     164                 : #define UPDATE_HASH(s,h,c) (h = (((h)<<s->hash_shift) ^ (c)) & s->hash_mask)
     165                 : 
     166                 : 
     167                 : /* ===========================================================================
     168                 :  * Insert string str in the dictionary and set match_head to the previous head
     169                 :  * of the hash chain (the most recent string with same hash key). Return
     170                 :  * the previous length of the hash chain.
     171                 :  * If this file is compiled with -DFASTEST, the compression level is forced
     172                 :  * to 1, and no hash chains are maintained.
     173                 :  * IN  assertion: all calls to to INSERT_STRING are made with consecutive
     174                 :  *    input characters and the first MIN_MATCH bytes of str are valid
     175                 :  *    (except for the last MIN_MATCH-1 bytes of the input file).
     176                 :  */
     177                 : #ifdef FASTEST
     178                 : #define INSERT_STRING(s, str, match_head) \
     179                 :    (UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \
     180                 :     match_head = s->head[s->ins_h], \
     181                 :     s->head[s->ins_h] = (Pos)(str))
     182                 : #else
     183                 : #define INSERT_STRING(s, str, match_head) \
     184                 :    (UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \
     185                 :     match_head = s->prev[(str) & s->w_mask] = s->head[s->ins_h], \
     186                 :     s->head[s->ins_h] = (Pos)(str))
     187                 : #endif
     188                 : 
     189                 : /* ===========================================================================
     190                 :  * Initialize the hash table (avoiding 64K overflow for 16 bit systems).
     191                 :  * prev[] will be initialized on the fly.
     192                 :  */
     193                 : #define CLEAR_HASH(s) \
     194                 :     s->head[s->hash_size-1] = NIL; \
     195                 :     zmemzero((Bytef *)s->head, (unsigned)(s->hash_size-1)*sizeof(*s->head));
     196                 : 
     197                 : /* ========================================================================= */
     198               0 : int ZEXPORT deflateInit_(strm, level, version, stream_size)
     199                 :     z_streamp strm;
     200                 :     int level;
     201                 :     const char *version;
     202                 :     int stream_size;
     203                 : {
     204               0 :     return deflateInit2_(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL,
     205                 :                          Z_DEFAULT_STRATEGY, version, stream_size);
     206                 :     /* To do: ignore strm->next_in if we use it as window */
     207                 : }
     208                 : 
     209                 : /* ========================================================================= */
     210            5178 : int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy,
     211                 :                   version, stream_size)
     212                 :     z_streamp strm;
     213                 :     int  level;
     214                 :     int  method;
     215                 :     int  windowBits;
     216                 :     int  memLevel;
     217                 :     int  strategy;
     218                 :     const char *version;
     219                 :     int stream_size;
     220                 : {
     221                 :     deflate_state *s;
     222            5178 :     int wrap = 1;
     223                 :     static const char my_version[] = ZLIB_VERSION;
     224                 : 
     225                 :     ushf *overlay;
     226                 :     /* We overlay pending_buf and d_buf+l_buf. This works since the average
     227                 :      * output size for (length,distance) codes is <= 24 bits.
     228                 :      */
     229                 : 
     230            5178 :     if (version == Z_NULL || version[0] != my_version[0] ||
     231                 :         stream_size != sizeof(z_stream)) {
     232               0 :         return Z_VERSION_ERROR;
     233                 :     }
     234            5178 :     if (strm == Z_NULL) return Z_STREAM_ERROR;
     235                 : 
     236            5178 :     strm->msg = Z_NULL;
     237            5178 :     if (strm->zalloc == (alloc_func)0) {
     238            5152 :         strm->zalloc = zcalloc;
     239            5152 :         strm->opaque = (voidpf)0;
     240                 :     }
     241            5178 :     if (strm->zfree == (free_func)0) strm->zfree = zcfree;
     242                 : 
     243                 : #ifdef FASTEST
     244                 :     if (level != 0) level = 1;
     245                 : #else
     246            5178 :     if (level == Z_DEFAULT_COMPRESSION) level = 6;
     247                 : #endif
     248                 : 
     249            5178 :     if (windowBits < 0) { /* suppress zlib wrapper */
     250            5146 :         wrap = 0;
     251            5146 :         windowBits = -windowBits;
     252                 :     }
     253                 : #ifdef GZIP
     254              32 :     else if (windowBits > 15) {
     255               5 :         wrap = 2;       /* write gzip wrapper instead */
     256               5 :         windowBits -= 16;
     257                 :     }
     258                 : #endif
     259            5178 :     if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method != Z_DEFLATED ||
     260            5178 :         windowBits < 8 || windowBits > 15 || level < 0 || level > 9 ||
     261            5178 :         strategy < 0 || strategy > Z_FIXED) {
     262               0 :         return Z_STREAM_ERROR;
     263                 :     }
     264            5178 :     if (windowBits == 8) windowBits = 9;  /* until 256-byte window bug fixed */
     265            5178 :     s = (deflate_state *) ZALLOC(strm, 1, sizeof(deflate_state));
     266            5178 :     if (s == Z_NULL) return Z_MEM_ERROR;
     267            5178 :     strm->state = (struct internal_state FAR *)s;
     268            5178 :     s->strm = strm;
     269                 : 
     270            5178 :     s->wrap = wrap;
     271            5178 :     s->gzhead = Z_NULL;
     272            5178 :     s->w_bits = windowBits;
     273            5178 :     s->w_size = 1 << s->w_bits;
     274            5178 :     s->w_mask = s->w_size - 1;
     275                 : 
     276            5178 :     s->hash_bits = memLevel + 7;
     277            5178 :     s->hash_size = 1 << s->hash_bits;
     278            5178 :     s->hash_mask = s->hash_size - 1;
     279            5178 :     s->hash_shift =  ((s->hash_bits+MIN_MATCH-1)/MIN_MATCH);
     280                 : 
     281            5178 :     s->window = (Bytef *) ZALLOC(strm, s->w_size, 2*sizeof(Byte));
     282            5178 :     s->prev   = (Posf *)  ZALLOC(strm, s->w_size, sizeof(Pos));
     283            5178 :     s->head   = (Posf *)  ZALLOC(strm, s->hash_size, sizeof(Pos));
     284                 : 
     285            5178 :     s->high_water = 0;      /* nothing written to s->window yet */
     286                 : 
     287            5178 :     s->lit_bufsize = 1 << (memLevel + 6); /* 16K elements by default */
     288                 : 
     289            5178 :     overlay = (ushf *) ZALLOC(strm, s->lit_bufsize, sizeof(ush)+2);
     290            5178 :     s->pending_buf = (uchf *) overlay;
     291            5178 :     s->pending_buf_size = (ulg)s->lit_bufsize * (sizeof(ush)+2L);
     292                 : 
     293           10356 :     if (s->window == Z_NULL || s->prev == Z_NULL || s->head == Z_NULL ||
     294            5178 :         s->pending_buf == Z_NULL) {
     295               0 :         s->status = FINISH_STATE;
     296               0 :         strm->msg = (char*)ERR_MSG(Z_MEM_ERROR);
     297               0 :         deflateEnd (strm);
     298               0 :         return Z_MEM_ERROR;
     299                 :     }
     300            5178 :     s->d_buf = overlay + s->lit_bufsize/sizeof(ush);
     301            5178 :     s->l_buf = s->pending_buf + (1+sizeof(ush))*s->lit_bufsize;
     302                 : 
     303            5178 :     s->level = level;
     304            5178 :     s->strategy = strategy;
     305            5178 :     s->method = (Byte)method;
     306                 : 
     307            5178 :     return deflateReset(strm);
     308                 : }
     309                 : 
     310                 : /* ========================================================================= */
     311               0 : int ZEXPORT deflateSetDictionary (strm, dictionary, dictLength)
     312                 :     z_streamp strm;
     313                 :     const Bytef *dictionary;
     314                 :     uInt  dictLength;
     315                 : {
     316                 :     deflate_state *s;
     317               0 :     uInt length = dictLength;
     318                 :     uInt n;
     319               0 :     IPos hash_head = 0;
     320                 : 
     321               0 :     if (strm == Z_NULL || strm->state == Z_NULL || dictionary == Z_NULL ||
     322               0 :         strm->state->wrap == 2 ||
     323               0 :         (strm->state->wrap == 1 && strm->state->status != INIT_STATE))
     324               0 :         return Z_STREAM_ERROR;
     325                 : 
     326               0 :     s = strm->state;
     327               0 :     if (s->wrap)
     328               0 :         strm->adler = adler32(strm->adler, dictionary, dictLength);
     329                 : 
     330               0 :     if (length < MIN_MATCH) return Z_OK;
     331               0 :     if (length > s->w_size) {
     332               0 :         length = s->w_size;
     333               0 :         dictionary += dictLength - length; /* use the tail of the dictionary */
     334                 :     }
     335               0 :     zmemcpy(s->window, dictionary, length);
     336               0 :     s->strstart = length;
     337               0 :     s->block_start = (long)length;
     338                 : 
     339                 :     /* Insert all strings in the hash table (except for the last two bytes).
     340                 :      * s->lookahead stays null, so s->ins_h will be recomputed at the next
     341                 :      * call of fill_window.
     342                 :      */
     343               0 :     s->ins_h = s->window[0];
     344               0 :     UPDATE_HASH(s, s->ins_h, s->window[1]);
     345               0 :     for (n = 0; n <= length - MIN_MATCH; n++) {
     346               0 :         INSERT_STRING(s, n, hash_head);
     347                 :     }
     348               0 :     if (hash_head) hash_head = 0;  /* to make compiler happy */
     349               0 :     return Z_OK;
     350                 : }
     351                 : 
     352                 : /* ========================================================================= */
     353            5217 : int ZEXPORT deflateReset (strm)
     354                 :     z_streamp strm;
     355                 : {
     356                 :     deflate_state *s;
     357                 : 
     358           10434 :     if (strm == Z_NULL || strm->state == Z_NULL ||
     359           10434 :         strm->zalloc == (alloc_func)0 || strm->zfree == (free_func)0) {
     360               0 :         return Z_STREAM_ERROR;
     361                 :     }
     362                 : 
     363            5217 :     strm->total_in = strm->total_out = 0;
     364            5217 :     strm->msg = Z_NULL; /* use zfree if we ever allocate msg dynamically */
     365            5217 :     strm->data_type = Z_UNKNOWN;
     366                 : 
     367            5217 :     s = (deflate_state *)strm->state;
     368            5217 :     s->pending = 0;
     369            5217 :     s->pending_out = s->pending_buf;
     370                 : 
     371            5217 :     if (s->wrap < 0) {
     372              39 :         s->wrap = -s->wrap; /* was made negative by deflate(..., Z_FINISH); */
     373                 :     }
     374            5217 :     s->status = s->wrap ? INIT_STATE : BUSY_STATE;
     375            5217 :     strm->adler =
     376                 : #ifdef GZIP
     377            5217 :         s->wrap == 2 ? crc32(0L, Z_NULL, 0) :
     378                 : #endif
     379                 :         adler32(0L, Z_NULL, 0);
     380            5217 :     s->last_flush = Z_NO_FLUSH;
     381                 : 
     382            5217 :     _tr_init(s);
     383            5217 :     lm_init(s);
     384                 : 
     385            5217 :     return Z_OK;
     386                 : }
     387                 : 
     388                 : /* ========================================================================= */
     389               0 : int ZEXPORT deflateSetHeader (strm, head)
     390                 :     z_streamp strm;
     391                 :     gz_headerp head;
     392                 : {
     393               0 :     if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
     394               0 :     if (strm->state->wrap != 2) return Z_STREAM_ERROR;
     395               0 :     strm->state->gzhead = head;
     396               0 :     return Z_OK;
     397                 : }
     398                 : 
     399                 : /* ========================================================================= */
     400               0 : int ZEXPORT deflatePrime (strm, bits, value)
     401                 :     z_streamp strm;
     402                 :     int bits;
     403                 :     int value;
     404                 : {
     405               0 :     if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
     406               0 :     strm->state->bi_valid = bits;
     407               0 :     strm->state->bi_buf = (ush)(value & ((1 << bits) - 1));
     408               0 :     return Z_OK;
     409                 : }
     410                 : 
     411                 : /* ========================================================================= */
     412               0 : int ZEXPORT deflateParams(strm, level, strategy)
     413                 :     z_streamp strm;
     414                 :     int level;
     415                 :     int strategy;
     416                 : {
     417                 :     deflate_state *s;
     418                 :     compress_func func;
     419               0 :     int err = Z_OK;
     420                 : 
     421               0 :     if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
     422               0 :     s = strm->state;
     423                 : 
     424                 : #ifdef FASTEST
     425                 :     if (level != 0) level = 1;
     426                 : #else
     427               0 :     if (level == Z_DEFAULT_COMPRESSION) level = 6;
     428                 : #endif
     429               0 :     if (level < 0 || level > 9 || strategy < 0 || strategy > Z_FIXED) {
     430               0 :         return Z_STREAM_ERROR;
     431                 :     }
     432               0 :     func = configuration_table[s->level].func;
     433                 : 
     434               0 :     if ((strategy != s->strategy || func != configuration_table[level].func) &&
     435               0 :         strm->total_in != 0) {
     436                 :         /* Flush the last buffer: */
     437               0 :         err = deflate(strm, Z_BLOCK);
     438                 :     }
     439               0 :     if (s->level != level) {
     440               0 :         s->level = level;
     441               0 :         s->max_lazy_match   = configuration_table[level].max_lazy;
     442               0 :         s->good_match       = configuration_table[level].good_length;
     443               0 :         s->nice_match       = configuration_table[level].nice_length;
     444               0 :         s->max_chain_length = configuration_table[level].max_chain;
     445                 :     }
     446               0 :     s->strategy = strategy;
     447               0 :     return err;
     448                 : }
     449                 : 
     450                 : /* ========================================================================= */
     451               0 : int ZEXPORT deflateTune(strm, good_length, max_lazy, nice_length, max_chain)
     452                 :     z_streamp strm;
     453                 :     int good_length;
     454                 :     int max_lazy;
     455                 :     int nice_length;
     456                 :     int max_chain;
     457                 : {
     458                 :     deflate_state *s;
     459                 : 
     460               0 :     if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
     461               0 :     s = strm->state;
     462               0 :     s->good_match = good_length;
     463               0 :     s->max_lazy_match = max_lazy;
     464               0 :     s->nice_match = nice_length;
     465               0 :     s->max_chain_length = max_chain;
     466               0 :     return Z_OK;
     467                 : }
     468                 : 
     469                 : /* =========================================================================
     470                 :  * For the default windowBits of 15 and memLevel of 8, this function returns
     471                 :  * a close to exact, as well as small, upper bound on the compressed size.
     472                 :  * They are coded as constants here for a reason--if the #define's are
     473                 :  * changed, then this function needs to be changed as well.  The return
     474                 :  * value for 15 and 8 only works for those exact settings.
     475                 :  *
     476                 :  * For any setting other than those defaults for windowBits and memLevel,
     477                 :  * the value returned is a conservative worst case for the maximum expansion
     478                 :  * resulting from using fixed blocks instead of stored blocks, which deflate
     479                 :  * can emit on compressed data for some combinations of the parameters.
     480                 :  *
     481                 :  * This function could be more sophisticated to provide closer upper bounds for
     482                 :  * every combination of windowBits and memLevel.  But even the conservative
     483                 :  * upper bound of about 14% expansion does not seem onerous for output buffer
     484                 :  * allocation.
     485                 :  */
     486               0 : uLong ZEXPORT deflateBound(strm, sourceLen)
     487                 :     z_streamp strm;
     488                 :     uLong sourceLen;
     489                 : {
     490                 :     deflate_state *s;
     491                 :     uLong complen, wraplen;
     492                 :     Bytef *str;
     493                 : 
     494                 :     /* conservative upper bound for compressed data */
     495               0 :     complen = sourceLen +
     496               0 :               ((sourceLen + 7) >> 3) + ((sourceLen + 63) >> 6) + 5;
     497                 : 
     498                 :     /* if can't get parameters, return conservative bound plus zlib wrapper */
     499               0 :     if (strm == Z_NULL || strm->state == Z_NULL)
     500               0 :         return complen + 6;
     501                 : 
     502                 :     /* compute wrapper length */
     503               0 :     s = strm->state;
     504               0 :     switch (s->wrap) {
     505                 :     case 0:                                 /* raw deflate */
     506               0 :         wraplen = 0;
     507               0 :         break;
     508                 :     case 1:                                 /* zlib wrapper */
     509               0 :         wraplen = 6 + (s->strstart ? 4 : 0);
     510               0 :         break;
     511                 :     case 2:                                 /* gzip wrapper */
     512               0 :         wraplen = 18;
     513               0 :         if (s->gzhead != Z_NULL) {          /* user-supplied gzip header */
     514               0 :             if (s->gzhead->extra != Z_NULL)
     515               0 :                 wraplen += 2 + s->gzhead->extra_len;
     516               0 :             str = s->gzhead->name;
     517               0 :             if (str != Z_NULL)
     518                 :                 do {
     519               0 :                     wraplen++;
     520               0 :                 } while (*str++);
     521               0 :             str = s->gzhead->comment;
     522               0 :             if (str != Z_NULL)
     523                 :                 do {
     524               0 :                     wraplen++;
     525               0 :                 } while (*str++);
     526               0 :             if (s->gzhead->hcrc)
     527               0 :                 wraplen += 2;
     528                 :         }
     529               0 :         break;
     530                 :     default:                                /* for compiler happiness */
     531               0 :         wraplen = 6;
     532                 :     }
     533                 : 
     534                 :     /* if not default parameters, return conservative bound */
     535               0 :     if (s->w_bits != 15 || s->hash_bits != 8 + 7)
     536               0 :         return complen + wraplen;
     537                 : 
     538                 :     /* default settings: return tight bound for that case */
     539               0 :     return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) +
     540               0 :            (sourceLen >> 25) + 13 - 6 + wraplen;
     541                 : }
     542                 : 
     543                 : /* =========================================================================
     544                 :  * Put a short in the pending buffer. The 16-bit value is put in MSB order.
     545                 :  * IN assertion: the stream state is correct and there is enough room in
     546                 :  * pending_buf.
     547                 :  */
     548             120 : local void putShortMSB (s, b)
     549                 :     deflate_state *s;
     550                 :     uInt b;
     551                 : {
     552             120 :     put_byte(s, (Byte)(b >> 8));
     553             120 :     put_byte(s, (Byte)(b & 0xff));
     554             120 : }
     555                 : 
     556                 : /* =========================================================================
     557                 :  * Flush as much pending output as possible. All deflate() output goes
     558                 :  * through this function so some applications may wish to modify it
     559                 :  * to avoid allocating a large strm->next_out buffer and copying into it.
     560                 :  * (See also read_buf()).
     561                 :  */
     562           35695 : local void flush_pending(strm)
     563                 :     z_streamp strm;
     564                 : {
     565           35695 :     unsigned len = strm->state->pending;
     566                 : 
     567           35695 :     if (len > strm->avail_out) len = strm->avail_out;
     568           35695 :     if (len == 0) return;
     569                 : 
     570           35695 :     zmemcpy(strm->next_out, strm->state->pending_out, len);
     571           35695 :     strm->next_out  += len;
     572           35695 :     strm->state->pending_out  += len;
     573           35695 :     strm->total_out += len;
     574           35695 :     strm->avail_out  -= len;
     575           35695 :     strm->state->pending -= len;
     576           35695 :     if (strm->state->pending == 0) {
     577            7858 :         strm->state->pending_out = strm->state->pending_buf;
     578                 :     }
     579                 : }
     580                 : 
     581                 : /* ========================================================================= */
     582          195039 : int ZEXPORT deflate (strm, flush)
     583                 :     z_streamp strm;
     584                 :     int flush;
     585                 : {
     586                 :     int old_flush; /* value of flush param for previous deflate call */
     587                 :     deflate_state *s;
     588                 : 
     589          195039 :     if (strm == Z_NULL || strm->state == Z_NULL ||
     590          195039 :         flush > Z_BLOCK || flush < 0) {
     591               0 :         return Z_STREAM_ERROR;
     592                 :     }
     593          195039 :     s = strm->state;
     594                 : 
     595          390078 :     if (strm->next_out == Z_NULL ||
     596          390080 :         (strm->next_in == Z_NULL && strm->avail_in != 0) ||
     597          204897 :         (s->status == FINISH_STATE && flush != Z_FINISH)) {
     598               0 :         ERR_RETURN(strm, Z_STREAM_ERROR);
     599                 :     }
     600          195039 :     if (strm->avail_out == 0) ERR_RETURN(strm, Z_BUF_ERROR);
     601                 : 
     602          195039 :     s->strm = strm; /* just in case */
     603          195039 :     old_flush = s->last_flush;
     604          195039 :     s->last_flush = flush;
     605                 : 
     606                 :     /* Write the header */
     607          195039 :     if (s->status == INIT_STATE) {
     608                 : #ifdef GZIP
     609              45 :         if (s->wrap == 2) {
     610               5 :             strm->adler = crc32(0L, Z_NULL, 0);
     611               5 :             put_byte(s, 31);
     612               5 :             put_byte(s, 139);
     613               5 :             put_byte(s, 8);
     614               5 :             if (s->gzhead == Z_NULL) {
     615               5 :                 put_byte(s, 0);
     616               5 :                 put_byte(s, 0);
     617               5 :                 put_byte(s, 0);
     618               5 :                 put_byte(s, 0);
     619               5 :                 put_byte(s, 0);
     620               5 :                 put_byte(s, s->level == 9 ? 2 :
     621                 :                             (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ?
     622                 :                              4 : 0));
     623               5 :                 put_byte(s, OS_CODE);
     624               5 :                 s->status = BUSY_STATE;
     625                 :             }
     626                 :             else {
     627               0 :                 put_byte(s, (s->gzhead->text ? 1 : 0) +
     628                 :                             (s->gzhead->hcrc ? 2 : 0) +
     629                 :                             (s->gzhead->extra == Z_NULL ? 0 : 4) +
     630                 :                             (s->gzhead->name == Z_NULL ? 0 : 8) +
     631                 :                             (s->gzhead->comment == Z_NULL ? 0 : 16)
     632                 :                         );
     633               0 :                 put_byte(s, (Byte)(s->gzhead->time & 0xff));
     634               0 :                 put_byte(s, (Byte)((s->gzhead->time >> 8) & 0xff));
     635               0 :                 put_byte(s, (Byte)((s->gzhead->time >> 16) & 0xff));
     636               0 :                 put_byte(s, (Byte)((s->gzhead->time >> 24) & 0xff));
     637               0 :                 put_byte(s, s->level == 9 ? 2 :
     638                 :                             (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ?
     639                 :                              4 : 0));
     640               0 :                 put_byte(s, s->gzhead->os & 0xff);
     641               0 :                 if (s->gzhead->extra != Z_NULL) {
     642               0 :                     put_byte(s, s->gzhead->extra_len & 0xff);
     643               0 :                     put_byte(s, (s->gzhead->extra_len >> 8) & 0xff);
     644                 :                 }
     645               0 :                 if (s->gzhead->hcrc)
     646               0 :                     strm->adler = crc32(strm->adler, s->pending_buf,
     647                 :                                         s->pending);
     648               0 :                 s->gzindex = 0;
     649               0 :                 s->status = EXTRA_STATE;
     650                 :             }
     651                 :         }
     652                 :         else
     653                 : #endif
     654                 :         {
     655              40 :             uInt header = (Z_DEFLATED + ((s->w_bits-8)<<4)) << 8;
     656                 :             uInt level_flags;
     657                 : 
     658              40 :             if (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2)
     659               0 :                 level_flags = 0;
     660              40 :             else if (s->level < 6)
     661               0 :                 level_flags = 1;
     662              40 :             else if (s->level == 6)
     663              40 :                 level_flags = 2;
     664                 :             else
     665               0 :                 level_flags = 3;
     666              40 :             header |= (level_flags << 6);
     667              40 :             if (s->strstart != 0) header |= PRESET_DICT;
     668              40 :             header += 31 - (header % 31);
     669                 : 
     670              40 :             s->status = BUSY_STATE;
     671              40 :             putShortMSB(s, header);
     672                 : 
     673                 :             /* Save the adler32 of the preset dictionary: */
     674              40 :             if (s->strstart != 0) {
     675               0 :                 putShortMSB(s, (uInt)(strm->adler >> 16));
     676               0 :                 putShortMSB(s, (uInt)(strm->adler & 0xffff));
     677                 :             }
     678              40 :             strm->adler = adler32(0L, Z_NULL, 0);
     679                 :         }
     680                 :     }
     681                 : #ifdef GZIP
     682          195039 :     if (s->status == EXTRA_STATE) {
     683               0 :         if (s->gzhead->extra != Z_NULL) {
     684               0 :             uInt beg = s->pending;  /* start of bytes to update crc */
     685                 : 
     686               0 :             while (s->gzindex < (s->gzhead->extra_len & 0xffff)) {
     687               0 :                 if (s->pending == s->pending_buf_size) {
     688               0 :                     if (s->gzhead->hcrc && s->pending > beg)
     689               0 :                         strm->adler = crc32(strm->adler, s->pending_buf + beg,
     690               0 :                                             s->pending - beg);
     691               0 :                     flush_pending(strm);
     692               0 :                     beg = s->pending;
     693               0 :                     if (s->pending == s->pending_buf_size)
     694               0 :                         break;
     695                 :                 }
     696               0 :                 put_byte(s, s->gzhead->extra[s->gzindex]);
     697               0 :                 s->gzindex++;
     698                 :             }
     699               0 :             if (s->gzhead->hcrc && s->pending > beg)
     700               0 :                 strm->adler = crc32(strm->adler, s->pending_buf + beg,
     701               0 :                                     s->pending - beg);
     702               0 :             if (s->gzindex == s->gzhead->extra_len) {
     703               0 :                 s->gzindex = 0;
     704               0 :                 s->status = NAME_STATE;
     705                 :             }
     706                 :         }
     707                 :         else
     708               0 :             s->status = NAME_STATE;
     709                 :     }
     710          195039 :     if (s->status == NAME_STATE) {
     711               0 :         if (s->gzhead->name != Z_NULL) {
     712               0 :             uInt beg = s->pending;  /* start of bytes to update crc */
     713                 :             int val;
     714                 : 
     715                 :             do {
     716               0 :                 if (s->pending == s->pending_buf_size) {
     717               0 :                     if (s->gzhead->hcrc && s->pending > beg)
     718               0 :                         strm->adler = crc32(strm->adler, s->pending_buf + beg,
     719               0 :                                             s->pending - beg);
     720               0 :                     flush_pending(strm);
     721               0 :                     beg = s->pending;
     722               0 :                     if (s->pending == s->pending_buf_size) {
     723               0 :                         val = 1;
     724               0 :                         break;
     725                 :                     }
     726                 :                 }
     727               0 :                 val = s->gzhead->name[s->gzindex++];
     728               0 :                 put_byte(s, val);
     729               0 :             } while (val != 0);
     730               0 :             if (s->gzhead->hcrc && s->pending > beg)
     731               0 :                 strm->adler = crc32(strm->adler, s->pending_buf + beg,
     732               0 :                                     s->pending - beg);
     733               0 :             if (val == 0) {
     734               0 :                 s->gzindex = 0;
     735               0 :                 s->status = COMMENT_STATE;
     736                 :             }
     737                 :         }
     738                 :         else
     739               0 :             s->status = COMMENT_STATE;
     740                 :     }
     741          195039 :     if (s->status == COMMENT_STATE) {
     742               0 :         if (s->gzhead->comment != Z_NULL) {
     743               0 :             uInt beg = s->pending;  /* start of bytes to update crc */
     744                 :             int val;
     745                 : 
     746                 :             do {
     747               0 :                 if (s->pending == s->pending_buf_size) {
     748               0 :                     if (s->gzhead->hcrc && s->pending > beg)
     749               0 :                         strm->adler = crc32(strm->adler, s->pending_buf + beg,
     750               0 :                                             s->pending - beg);
     751               0 :                     flush_pending(strm);
     752               0 :                     beg = s->pending;
     753               0 :                     if (s->pending == s->pending_buf_size) {
     754               0 :                         val = 1;
     755               0 :                         break;
     756                 :                     }
     757                 :                 }
     758               0 :                 val = s->gzhead->comment[s->gzindex++];
     759               0 :                 put_byte(s, val);
     760               0 :             } while (val != 0);
     761               0 :             if (s->gzhead->hcrc && s->pending > beg)
     762               0 :                 strm->adler = crc32(strm->adler, s->pending_buf + beg,
     763               0 :                                     s->pending - beg);
     764               0 :             if (val == 0)
     765               0 :                 s->status = HCRC_STATE;
     766                 :         }
     767                 :         else
     768               0 :             s->status = HCRC_STATE;
     769                 :     }
     770          195039 :     if (s->status == HCRC_STATE) {
     771               0 :         if (s->gzhead->hcrc) {
     772               0 :             if (s->pending + 2 > s->pending_buf_size)
     773               0 :                 flush_pending(strm);
     774               0 :             if (s->pending + 2 <= s->pending_buf_size) {
     775               0 :                 put_byte(s, (Byte)(strm->adler & 0xff));
     776               0 :                 put_byte(s, (Byte)((strm->adler >> 8) & 0xff));
     777               0 :                 strm->adler = crc32(0L, Z_NULL, 0);
     778               0 :                 s->status = BUSY_STATE;
     779                 :             }
     780                 :         }
     781                 :         else
     782               0 :             s->status = BUSY_STATE;
     783                 :     }
     784                 : #endif
     785                 : 
     786                 :     /* Flush as much pending output as possible */
     787          195039 :     if (s->pending != 0) {
     788           27882 :         flush_pending(strm);
     789           27882 :         if (strm->avail_out == 0) {
     790                 :             /* Since avail_out is 0, deflate will be called again with
     791                 :              * more output space, but possibly with both pending and
     792                 :              * avail_in equal to zero. There won't be anything to do,
     793                 :              * but this is not an error situation so make sure we
     794                 :              * return OK instead of BUF_ERROR at next call of deflate:
     795                 :              */
     796           21795 :             s->last_flush = -1;
     797           21795 :             return Z_OK;
     798                 :         }
     799                 : 
     800                 :     /* Make sure there is something to do and avoid duplicate consecutive
     801                 :      * flushes. For repeated and useless calls with Z_FINISH, we keep
     802                 :      * returning Z_STREAM_END instead of Z_BUF_ERROR.
     803                 :      */
     804          167157 :     } else if (strm->avail_in == 0 && flush <= old_flush &&
     805                 :                flush != Z_FINISH) {
     806               0 :         ERR_RETURN(strm, Z_BUF_ERROR);
     807                 :     }
     808                 : 
     809                 :     /* User must not provide more input after the first FINISH: */
     810          173244 :     if (s->status == FINISH_STATE && strm->avail_in != 0) {
     811               0 :         ERR_RETURN(strm, Z_BUF_ERROR);
     812                 :     }
     813                 : 
     814                 :     /* Start a new block or continue the current one.
     815                 :      */
     816          173244 :     if (strm->avail_in != 0 || s->lookahead != 0 ||
     817            3468 :         (flush != Z_NO_FLUSH && s->status != FINISH_STATE)) {
     818                 :         block_state bstate;
     819                 : 
     820          509334 :         bstate = s->strategy == Z_HUFFMAN_ONLY ? deflate_huff(s, flush) :
     821          169778 :                     (s->strategy == Z_RLE ? deflate_rle(s, flush) :
     822          169778 :                         (*(configuration_table[s->level].func))(s, flush));
     823                 : 
     824          169778 :         if (bstate == finish_started || bstate == finish_done) {
     825            5191 :             s->status = FINISH_STATE;
     826                 :         }
     827          169778 :         if (bstate == need_more || bstate == finish_started) {
     828          168053 :             if (strm->avail_out == 0) {
     829            6043 :                 s->last_flush = -1; /* avoid BUF_ERROR next call, see above */
     830                 :             }
     831          168053 :             return Z_OK;
     832                 :             /* If flush != Z_NO_FLUSH && avail_out == 0, the next call
     833                 :              * of deflate should use the same flush parameter to make sure
     834                 :              * that the flush is complete. So we don't have to output an
     835                 :              * empty block here, this will be done at next call. This also
     836                 :              * ensures that for a very small output buffer, we emit at most
     837                 :              * one empty block.
     838                 :              */
     839                 :         }
     840            1725 :         if (bstate == block_done) {
     841               0 :             if (flush == Z_PARTIAL_FLUSH) {
     842               0 :                 _tr_align(s);
     843               0 :             } else if (flush != Z_BLOCK) { /* FULL_FLUSH or SYNC_FLUSH */
     844               0 :                 _tr_stored_block(s, (char*)0, 0L, 0);
     845                 :                 /* For a full flush, this empty block will be recognized
     846                 :                  * as a special marker by inflate_sync().
     847                 :                  */
     848               0 :                 if (flush == Z_FULL_FLUSH) {
     849               0 :                     CLEAR_HASH(s);             /* forget history */
     850               0 :                     if (s->lookahead == 0) {
     851               0 :                         s->strstart = 0;
     852               0 :                         s->block_start = 0L;
     853                 :                     }
     854                 :                 }
     855                 :             }
     856               0 :             flush_pending(strm);
     857               0 :             if (strm->avail_out == 0) {
     858               0 :               s->last_flush = -1; /* avoid BUF_ERROR at next call, see above */
     859               0 :               return Z_OK;
     860                 :             }
     861                 :         }
     862                 :     }
     863                 :     Assert(strm->avail_out > 0, "bug2");
     864                 : 
     865            5191 :     if (flush != Z_FINISH) return Z_OK;
     866            5191 :     if (s->wrap <= 0) return Z_STREAM_END;
     867                 : 
     868                 :     /* Write the trailer */
     869                 : #ifdef GZIP
     870              45 :     if (s->wrap == 2) {
     871               5 :         put_byte(s, (Byte)(strm->adler & 0xff));
     872               5 :         put_byte(s, (Byte)((strm->adler >> 8) & 0xff));
     873               5 :         put_byte(s, (Byte)((strm->adler >> 16) & 0xff));
     874               5 :         put_byte(s, (Byte)((strm->adler >> 24) & 0xff));
     875               5 :         put_byte(s, (Byte)(strm->total_in & 0xff));
     876               5 :         put_byte(s, (Byte)((strm->total_in >> 8) & 0xff));
     877               5 :         put_byte(s, (Byte)((strm->total_in >> 16) & 0xff));
     878               5 :         put_byte(s, (Byte)((strm->total_in >> 24) & 0xff));
     879                 :     }
     880                 :     else
     881                 : #endif
     882                 :     {
     883              40 :         putShortMSB(s, (uInt)(strm->adler >> 16));
     884              40 :         putShortMSB(s, (uInt)(strm->adler & 0xffff));
     885                 :     }
     886              45 :     flush_pending(strm);
     887                 :     /* If avail_out is zero, the application will call deflate again
     888                 :      * to flush the rest.
     889                 :      */
     890              45 :     if (s->wrap > 0) s->wrap = -s->wrap; /* write the trailer only once! */
     891              45 :     return s->pending != 0 ? Z_OK : Z_STREAM_END;
     892                 : }
     893                 : 
     894                 : /* ========================================================================= */
     895            5178 : int ZEXPORT deflateEnd (strm)
     896                 :     z_streamp strm;
     897                 : {
     898                 :     int status;
     899                 : 
     900            5178 :     if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
     901                 : 
     902            5178 :     status = strm->state->status;
     903            5178 :     if (status != INIT_STATE &&
     904            5152 :         status != EXTRA_STATE &&
     905            5152 :         status != NAME_STATE &&
     906            5152 :         status != COMMENT_STATE &&
     907            5152 :         status != HCRC_STATE &&
     908            5152 :         status != BUSY_STATE &&
     909                 :         status != FINISH_STATE) {
     910               0 :       return Z_STREAM_ERROR;
     911                 :     }
     912                 : 
     913                 :     /* Deallocate in reverse order of allocations: */
     914            5178 :     TRY_FREE(strm, strm->state->pending_buf);
     915            5178 :     TRY_FREE(strm, strm->state->head);
     916            5178 :     TRY_FREE(strm, strm->state->prev);
     917            5178 :     TRY_FREE(strm, strm->state->window);
     918                 : 
     919            5178 :     ZFREE(strm, strm->state);
     920            5178 :     strm->state = Z_NULL;
     921                 : 
     922            5178 :     return status == BUSY_STATE ? Z_DATA_ERROR : Z_OK;
     923                 : }
     924                 : 
     925                 : /* =========================================================================
     926                 :  * Copy the source state to the destination state.
     927                 :  * To simplify the source, this is not supported for 16-bit MSDOS (which
     928                 :  * doesn't have enough memory anyway to duplicate compression states).
     929                 :  */
     930               0 : int ZEXPORT deflateCopy (dest, source)
     931                 :     z_streamp dest;
     932                 :     z_streamp source;
     933                 : {
     934                 : #ifdef MAXSEG_64K
     935                 :     return Z_STREAM_ERROR;
     936                 : #else
     937                 :     deflate_state *ds;
     938                 :     deflate_state *ss;
     939                 :     ushf *overlay;
     940                 : 
     941                 : 
     942               0 :     if (source == Z_NULL || dest == Z_NULL || source->state == Z_NULL) {
     943               0 :         return Z_STREAM_ERROR;
     944                 :     }
     945                 : 
     946               0 :     ss = source->state;
     947                 : 
     948               0 :     zmemcpy(dest, source, sizeof(z_stream));
     949                 : 
     950               0 :     ds = (deflate_state *) ZALLOC(dest, 1, sizeof(deflate_state));
     951               0 :     if (ds == Z_NULL) return Z_MEM_ERROR;
     952               0 :     dest->state = (struct internal_state FAR *) ds;
     953               0 :     zmemcpy(ds, ss, sizeof(deflate_state));
     954               0 :     ds->strm = dest;
     955                 : 
     956               0 :     ds->window = (Bytef *) ZALLOC(dest, ds->w_size, 2*sizeof(Byte));
     957               0 :     ds->prev   = (Posf *)  ZALLOC(dest, ds->w_size, sizeof(Pos));
     958               0 :     ds->head   = (Posf *)  ZALLOC(dest, ds->hash_size, sizeof(Pos));
     959               0 :     overlay = (ushf *) ZALLOC(dest, ds->lit_bufsize, sizeof(ush)+2);
     960               0 :     ds->pending_buf = (uchf *) overlay;
     961                 : 
     962               0 :     if (ds->window == Z_NULL || ds->prev == Z_NULL || ds->head == Z_NULL ||
     963               0 :         ds->pending_buf == Z_NULL) {
     964               0 :         deflateEnd (dest);
     965               0 :         return Z_MEM_ERROR;
     966                 :     }
     967                 :     /* following zmemcpy do not work for 16-bit MSDOS */
     968               0 :     zmemcpy(ds->window, ss->window, ds->w_size * 2 * sizeof(Byte));
     969               0 :     zmemcpy(ds->prev, ss->prev, ds->w_size * sizeof(Pos));
     970               0 :     zmemcpy(ds->head, ss->head, ds->hash_size * sizeof(Pos));
     971               0 :     zmemcpy(ds->pending_buf, ss->pending_buf, (uInt)ds->pending_buf_size);
     972                 : 
     973               0 :     ds->pending_out = ds->pending_buf + (ss->pending_out - ss->pending_buf);
     974               0 :     ds->d_buf = overlay + ds->lit_bufsize/sizeof(ush);
     975               0 :     ds->l_buf = ds->pending_buf + (1+sizeof(ush))*ds->lit_bufsize;
     976                 : 
     977               0 :     ds->l_desc.dyn_tree = ds->dyn_ltree;
     978               0 :     ds->d_desc.dyn_tree = ds->dyn_dtree;
     979               0 :     ds->bl_desc.dyn_tree = ds->bl_tree;
     980                 : 
     981               0 :     return Z_OK;
     982                 : #endif /* MAXSEG_64K */
     983                 : }
     984                 : 
     985                 : /* ===========================================================================
     986                 :  * Read a new buffer from the current input stream, update the adler32
     987                 :  * and total number of bytes read.  All deflate() input goes through
     988                 :  * this function so some applications may wish to modify it to avoid
     989                 :  * allocating a large strm->next_in buffer and copying from it.
     990                 :  * (See also flush_pending()).
     991                 :  */
     992          162010 : local int read_buf(strm, buf, size)
     993                 :     z_streamp strm;
     994                 :     Bytef *buf;
     995                 :     unsigned size;
     996                 : {
     997          162010 :     unsigned len = strm->avail_in;
     998                 : 
     999          162010 :     if (len > size) len = size;
    1000          162010 :     if (len == 0) return 0;
    1001                 : 
    1002          162010 :     strm->avail_in  -= len;
    1003                 : 
    1004          162010 :     if (strm->state->wrap == 1) {
    1005             300 :         strm->adler = adler32(strm->adler, strm->next_in, len);
    1006                 :     }
    1007                 : #ifdef GZIP
    1008          161710 :     else if (strm->state->wrap == 2) {
    1009               5 :         strm->adler = crc32(strm->adler, strm->next_in, len);
    1010                 :     }
    1011                 : #endif
    1012          162010 :     zmemcpy(buf, strm->next_in, len);
    1013          162010 :     strm->next_in  += len;
    1014          162010 :     strm->total_in += len;
    1015                 : 
    1016          162010 :     return (int)len;
    1017                 : }
    1018                 : 
    1019                 : /* ===========================================================================
    1020                 :  * Initialize the "longest match" routines for a new zlib stream
    1021                 :  */
    1022            5217 : local void lm_init (s)
    1023                 :     deflate_state *s;
    1024                 : {
    1025            5217 :     s->window_size = (ulg)2L*s->w_size;
    1026                 : 
    1027            5217 :     CLEAR_HASH(s);
    1028                 : 
    1029                 :     /* Set the default configuration parameters:
    1030                 :      */
    1031            5217 :     s->max_lazy_match   = configuration_table[s->level].max_lazy;
    1032            5217 :     s->good_match       = configuration_table[s->level].good_length;
    1033            5217 :     s->nice_match       = configuration_table[s->level].nice_length;
    1034            5217 :     s->max_chain_length = configuration_table[s->level].max_chain;
    1035                 : 
    1036            5217 :     s->strstart = 0;
    1037            5217 :     s->block_start = 0L;
    1038            5217 :     s->lookahead = 0;
    1039            5217 :     s->match_length = s->prev_length = MIN_MATCH-1;
    1040            5217 :     s->match_available = 0;
    1041            5217 :     s->ins_h = 0;
    1042                 : #ifndef FASTEST
    1043                 : #ifdef ASMV
    1044                 :     match_init(); /* initialize the asm code */
    1045                 : #endif
    1046                 : #endif
    1047            5217 : }
    1048                 : 
    1049                 : #ifndef FASTEST
    1050                 : /* ===========================================================================
    1051                 :  * Set match_start to the longest match starting at the given string and
    1052                 :  * return its length. Matches shorter or equal to prev_length are discarded,
    1053                 :  * in which case the result is equal to prev_length and match_start is
    1054                 :  * garbage.
    1055                 :  * IN assertions: cur_match is the head of the hash chain for the current
    1056                 :  *   string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1
    1057                 :  * OUT assertion: the match length is not greater than s->lookahead.
    1058                 :  */
    1059                 : #ifndef ASMV
    1060                 : /* For 80x86 and 680x0, an optimized version will be provided in match.asm or
    1061                 :  * match.S. The code will be functionally equivalent.
    1062                 :  */
    1063        57471294 : local uInt longest_match(s, cur_match)
    1064                 :     deflate_state *s;
    1065                 :     IPos cur_match;                             /* current match */
    1066                 : {
    1067        57471294 :     unsigned chain_length = s->max_chain_length;/* max hash chain length */
    1068        57471294 :     register Bytef *scan = s->window + s->strstart; /* current string */
    1069                 :     register Bytef *match;                       /* matched string */
    1070                 :     register int len;                           /* length of current match */
    1071        57471294 :     int best_len = s->prev_length;              /* best match length so far */
    1072        57471294 :     int nice_match = s->nice_match;             /* stop if match long enough */
    1073       114942588 :     IPos limit = s->strstart > (IPos)MAX_DIST(s) ?
    1074        57471294 :         s->strstart - (IPos)MAX_DIST(s) : NIL;
    1075                 :     /* Stop when cur_match becomes <= limit. To simplify the code,
    1076                 :      * we prevent matches with the string of window index 0.
    1077                 :      */
    1078        57471294 :     Posf *prev = s->prev;
    1079        57471294 :     uInt wmask = s->w_mask;
    1080                 : 
    1081                 : #ifdef UNALIGNED_OK
    1082                 :     /* Compare two bytes at a time. Note: this is not always beneficial.
    1083                 :      * Try with and without -DUNALIGNED_OK to check.
    1084                 :      */
    1085                 :     register Bytef *strend = s->window + s->strstart + MAX_MATCH - 1;
    1086                 :     register ush scan_start = *(ushf*)scan;
    1087                 :     register ush scan_end   = *(ushf*)(scan+best_len-1);
    1088                 : #else
    1089        57471294 :     register Bytef *strend = s->window + s->strstart + MAX_MATCH;
    1090        57471294 :     register Byte scan_end1  = scan[best_len-1];
    1091        57471294 :     register Byte scan_end   = scan[best_len];
    1092                 : #endif
    1093                 : 
    1094                 :     /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.
    1095                 :      * It is easy to get rid of this optimization if necessary.
    1096                 :      */
    1097                 :     Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever");
    1098                 : 
    1099                 :     /* Do not waste too much time if we already have a good match: */
    1100        57471294 :     if (s->prev_length >= s->good_match) {
    1101             654 :         chain_length >>= 2;
    1102                 :     }
    1103                 :     /* Do not look for matches beyond the end of the input. This is necessary
    1104                 :      * to make deflate deterministic.
    1105                 :      */
    1106        57471294 :     if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead;
    1107                 : 
    1108                 :     Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead");
    1109                 : 
    1110                 :     do {
    1111                 :         Assert(cur_match < s->strstart, "no future");
    1112       159656033 :         match = s->window + cur_match;
    1113                 : 
    1114                 :         /* Skip to next match if the match length cannot increase
    1115                 :          * or if the match length is less than 2.  Note that the checks below
    1116                 :          * for insufficient lookahead only occur occasionally for performance
    1117                 :          * reasons.  Therefore uninitialized memory will be accessed, and
    1118                 :          * conditional jumps will be made that depend on those values.
    1119                 :          * However the length of the match is limited to the lookahead, so
    1120                 :          * the output of deflate is not affected by the uninitialized values.
    1121                 :          */
    1122                 : #if (defined(UNALIGNED_OK) && MAX_MATCH == 258)
    1123                 :         /* This code assumes sizeof(unsigned short) == 2. Do not use
    1124                 :          * UNALIGNED_OK if your compiler uses a different size.
    1125                 :          */
    1126                 :         if (*(ushf*)(match+best_len-1) != scan_end ||
    1127                 :             *(ushf*)match != scan_start) continue;
    1128                 : 
    1129                 :         /* It is not necessary to compare scan[2] and match[2] since they are
    1130                 :          * always equal when the other bytes match, given that the hash keys
    1131                 :          * are equal and that HASH_BITS >= 8. Compare 2 bytes at a time at
    1132                 :          * strstart+3, +5, ... up to strstart+257. We check for insufficient
    1133                 :          * lookahead only every 4th comparison; the 128th check will be made
    1134                 :          * at strstart+257. If MAX_MATCH-2 is not a multiple of 8, it is
    1135                 :          * necessary to put more guard bytes at the end of the window, or
    1136                 :          * to check more often for insufficient lookahead.
    1137                 :          */
    1138                 :         Assert(scan[2] == match[2], "scan[2]?");
    1139                 :         scan++, match++;
    1140                 :         do {
    1141                 :         } while (*(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
    1142                 :                  *(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
    1143                 :                  *(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
    1144                 :                  *(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
    1145                 :                  scan < strend);
    1146                 :         /* The funny "do {}" generates better code on most compilers */
    1147                 : 
    1148                 :         /* Here, scan <= window+strstart+257 */
    1149                 :         Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
    1150                 :         if (*scan == *match) scan++;
    1151                 : 
    1152                 :         len = (MAX_MATCH - 1) - (int)(strend-scan);
    1153                 :         scan = strend - (MAX_MATCH-1);
    1154                 : 
    1155                 : #else /* UNALIGNED_OK */
    1156                 : 
    1157       253558659 :         if (match[best_len]   != scan_end  ||
    1158       183849595 :             match[best_len-1] != scan_end1 ||
    1159       197393187 :             *match            != *scan     ||
    1160       159662829 :             *++match          != scan[1])      continue;
    1161                 : 
    1162                 :         /* The check at best_len-1 can be removed because it will be made
    1163                 :          * again later. (This heuristic is not always a win.)
    1164                 :          * It is not necessary to compare scan[2] and match[2] since they
    1165                 :          * are always equal when the other bytes match, given that
    1166                 :          * the hash keys are equal and that HASH_BITS >= 8.
    1167                 :          */
    1168        53716313 :         scan += 2, match++;
    1169                 :         Assert(*scan == *match, "match[2]?");
    1170                 : 
    1171                 :         /* We check for insufficient lookahead only every 8th comparison;
    1172                 :          * the 256th check will be made at strstart+258.
    1173                 :          */
    1174                 :         do {
    1175       431376401 :         } while (*++scan == *++match && *++scan == *++match &&
    1176       327597227 :                  *++scan == *++match && *++scan == *++match &&
    1177       282333135 :                  *++scan == *++match && *++scan == *++match &&
    1178       154648274 :                  *++scan == *++match && *++scan == *++match &&
    1179       301913985 :                  scan < strend);
    1180                 : 
    1181                 :         Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
    1182                 : 
    1183        53716313 :         len = MAX_MATCH - (int)(strend - scan);
    1184        53716313 :         scan = strend - MAX_MATCH;
    1185                 : 
    1186                 : #endif /* UNALIGNED_OK */
    1187                 : 
    1188        53716313 :         if (len > best_len) {
    1189        53475627 :             s->match_start = cur_match;
    1190        53475627 :             best_len = len;
    1191        53475627 :             if (len >= nice_match) break;
    1192                 : #ifdef UNALIGNED_OK
    1193                 :             scan_end = *(ushf*)(scan+best_len-1);
    1194                 : #else
    1195        34266605 :             scan_end1  = scan[best_len-1];
    1196        34266605 :             scan_end   = scan[best_len];
    1197                 : #endif
    1198                 :         }
    1199       140447011 :     } while ((cur_match = prev[cur_match & wmask]) > limit
    1200       140447011 :              && --chain_length != 0);
    1201                 : 
    1202        57471294 :     if ((uInt)best_len <= s->lookahead) return (uInt)best_len;
    1203             536 :     return s->lookahead;
    1204                 : }
    1205                 : #endif /* ASMV */
    1206                 : 
    1207                 : #else /* FASTEST */
    1208                 : 
    1209                 : /* ---------------------------------------------------------------------------
    1210                 :  * Optimized version for FASTEST only
    1211                 :  */
    1212                 : local uInt longest_match(s, cur_match)
    1213                 :     deflate_state *s;
    1214                 :     IPos cur_match;                             /* current match */
    1215                 : {
    1216                 :     register Bytef *scan = s->window + s->strstart; /* current string */
    1217                 :     register Bytef *match;                       /* matched string */
    1218                 :     register int len;                           /* length of current match */
    1219                 :     register Bytef *strend = s->window + s->strstart + MAX_MATCH;
    1220                 : 
    1221                 :     /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.
    1222                 :      * It is easy to get rid of this optimization if necessary.
    1223                 :      */
    1224                 :     Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever");
    1225                 : 
    1226                 :     Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead");
    1227                 : 
    1228                 :     Assert(cur_match < s->strstart, "no future");
    1229                 : 
    1230                 :     match = s->window + cur_match;
    1231                 : 
    1232                 :     /* Return failure if the match length is less than 2:
    1233                 :      */
    1234                 :     if (match[0] != scan[0] || match[1] != scan[1]) return MIN_MATCH-1;
    1235                 : 
    1236                 :     /* The check at best_len-1 can be removed because it will be made
    1237                 :      * again later. (This heuristic is not always a win.)
    1238                 :      * It is not necessary to compare scan[2] and match[2] since they
    1239                 :      * are always equal when the other bytes match, given that
    1240                 :      * the hash keys are equal and that HASH_BITS >= 8.
    1241                 :      */
    1242                 :     scan += 2, match += 2;
    1243                 :     Assert(*scan == *match, "match[2]?");
    1244                 : 
    1245                 :     /* We check for insufficient lookahead only every 8th comparison;
    1246                 :      * the 256th check will be made at strstart+258.
    1247                 :      */
    1248                 :     do {
    1249                 :     } while (*++scan == *++match && *++scan == *++match &&
    1250                 :              *++scan == *++match && *++scan == *++match &&
    1251                 :              *++scan == *++match && *++scan == *++match &&
    1252                 :              *++scan == *++match && *++scan == *++match &&
    1253                 :              scan < strend);
    1254                 : 
    1255                 :     Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
    1256                 : 
    1257                 :     len = MAX_MATCH - (int)(strend - scan);
    1258                 : 
    1259                 :     if (len < MIN_MATCH) return MIN_MATCH - 1;
    1260                 : 
    1261                 :     s->match_start = cur_match;
    1262                 :     return (uInt)len <= s->lookahead ? (uInt)len : s->lookahead;
    1263                 : }
    1264                 : 
    1265                 : #endif /* FASTEST */
    1266                 : 
    1267                 : #ifdef DEBUG
    1268                 : /* ===========================================================================
    1269                 :  * Check that the match at match_start is indeed a match.
    1270                 :  */
    1271                 : local void check_match(s, start, match, length)
    1272                 :     deflate_state *s;
    1273                 :     IPos start, match;
    1274                 :     int length;
    1275                 : {
    1276                 :     /* check that the match is indeed a match */
    1277                 :     if (zmemcmp(s->window + match,
    1278                 :                 s->window + start, length) != EQUAL) {
    1279                 :         fprintf(stderr, " start %u, match %u, length %d\n",
    1280                 :                 start, match, length);
    1281                 :         do {
    1282                 :             fprintf(stderr, "%c%c", s->window[match++], s->window[start++]);
    1283                 :         } while (--length != 0);
    1284                 :         z_error("invalid match");
    1285                 :     }
    1286                 :     if (z_verbose > 1) {
    1287                 :         fprintf(stderr,"\\[%d,%d]", start-match, length);
    1288                 :         do { putc(s->window[start++], stderr); } while (--length != 0);
    1289                 :     }
    1290                 : }
    1291                 : #else
    1292                 : #  define check_match(s, start, match, length)
    1293                 : #endif /* DEBUG */
    1294                 : 
    1295                 : /* ===========================================================================
    1296                 :  * Fill the window when the lookahead becomes insufficient.
    1297                 :  * Updates strstart and lookahead.
    1298                 :  *
    1299                 :  * IN assertion: lookahead < MIN_LOOKAHEAD
    1300                 :  * OUT assertions: strstart <= window_size-MIN_LOOKAHEAD
    1301                 :  *    At least one byte has been read, or avail_in == 0; reads are
    1302                 :  *    performed for at least two bytes (required for the zip translate_eol
    1303                 :  *    option -- not supported here).
    1304                 :  */
    1305          543431 : local void fill_window(s)
    1306                 :     deflate_state *s;
    1307                 : {
    1308                 :     register unsigned n, m;
    1309                 :     register Posf *p;
    1310                 :     unsigned more;    /* Amount of free space at the end of the window. */
    1311          543431 :     uInt wsize = s->w_size;
    1312                 : 
    1313                 :     do {
    1314          543431 :         more = (unsigned)(s->window_size -(ulg)s->lookahead -(ulg)s->strstart);
    1315                 : 
    1316                 :         /* Deal with !@#$% 64K limit: */
    1317                 :         if (sizeof(int) <= 2) {
    1318                 :             if (more == 0 && s->strstart == 0 && s->lookahead == 0) {
    1319                 :                 more = wsize;
    1320                 : 
    1321                 :             } else if (more == (unsigned)(-1)) {
    1322                 :                 /* Very unlikely, but possible on 16 bit machine if
    1323                 :                  * strstart == 0 && lookahead == 1 (input done a byte at time)
    1324                 :                  */
    1325                 :                 more--;
    1326                 :             }
    1327                 :         }
    1328                 : 
    1329                 :         /* If the window is almost full and there is insufficient lookahead,
    1330                 :          * move the upper half to the lower one to make room in the upper half.
    1331                 :          */
    1332          543431 :         if (s->strstart >= wsize+MAX_DIST(s)) {
    1333                 : 
    1334           14331 :             zmemcpy(s->window, s->window+wsize, (unsigned)wsize);
    1335           14331 :             s->match_start -= wsize;
    1336           14331 :             s->strstart    -= wsize; /* we now have strstart >= MAX_DIST */
    1337           14331 :             s->block_start -= (long) wsize;
    1338                 : 
    1339                 :             /* Slide the hash table (could be avoided with 32 bit values
    1340                 :                at the expense of memory usage). We slide even when level == 0
    1341                 :                to keep the hash table consistent if we switch back to level > 0
    1342                 :                later. (Using level 0 permanently is not an optimal usage of
    1343                 :                zlib, so we don't care about this pathological case.)
    1344                 :              */
    1345           14331 :             n = s->hash_size;
    1346           14331 :             p = &s->head[n];
    1347                 :             do {
    1348       469598208 :                 m = *--p;
    1349       469598208 :                 *p = (Pos)(m >= wsize ? m-wsize : NIL);
    1350       469598208 :             } while (--n);
    1351                 : 
    1352           14331 :             n = wsize;
    1353                 : #ifndef FASTEST
    1354           14331 :             p = &s->prev[n];
    1355                 :             do {
    1356       469598208 :                 m = *--p;
    1357       469598208 :                 *p = (Pos)(m >= wsize ? m-wsize : NIL);
    1358                 :                 /* If n is not on any hash chain, prev[n] is garbage but
    1359                 :                  * its value will never be used.
    1360                 :                  */
    1361       469598208 :             } while (--n);
    1362                 : #endif
    1363           14331 :             more += wsize;
    1364                 :         }
    1365          543431 :         if (s->strm->avail_in == 0) return;
    1366                 : 
    1367                 :         /* If there was no sliding:
    1368                 :          *    strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 &&
    1369                 :          *    more == window_size - lookahead - strstart
    1370                 :          * => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1)
    1371                 :          * => more >= window_size - 2*WSIZE + 2
    1372                 :          * In the BIG_MEM or MMAP case (not yet supported),
    1373                 :          *   window_size == input_size + MIN_LOOKAHEAD  &&
    1374                 :          *   strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD.
    1375                 :          * Otherwise, window_size == 2*WSIZE so more >= 2.
    1376                 :          * If there was sliding, more >= WSIZE. So in all cases, more >= 2.
    1377                 :          */
    1378                 :         Assert(more >= 2, "more < 2");
    1379                 : 
    1380          162010 :         n = read_buf(s->strm, s->window + s->strstart + s->lookahead, more);
    1381          162010 :         s->lookahead += n;
    1382                 : 
    1383                 :         /* Initialize the hash value now that we have some input: */
    1384          162010 :         if (s->lookahead >= MIN_MATCH) {
    1385          162010 :             s->ins_h = s->window[s->strstart];
    1386          162010 :             UPDATE_HASH(s, s->ins_h, s->window[s->strstart+1]);
    1387                 : #if MIN_MATCH != 3
    1388                 :             Call UPDATE_HASH() MIN_MATCH-3 more times
    1389                 : #endif
    1390                 :         }
    1391                 :         /* If the whole input has less than MIN_MATCH bytes, ins_h is garbage,
    1392                 :          * but this is not important since only literal bytes will be emitted.
    1393                 :          */
    1394                 : 
    1395          162010 :     } while (s->lookahead < MIN_LOOKAHEAD && s->strm->avail_in != 0);
    1396                 : 
    1397                 :     /* If the WIN_INIT bytes after the end of the current data have never been
    1398                 :      * written, then zero those bytes in order to avoid memory check reports of
    1399                 :      * the use of uninitialized (or uninitialised as Julian writes) bytes by
    1400                 :      * the longest match routines.  Update the high water mark for the next
    1401                 :      * time through here.  WIN_INIT is set to MAX_MATCH since the longest match
    1402                 :      * routines allow scanning to strstart + MAX_MATCH, ignoring lookahead.
    1403                 :      */
    1404          162010 :     if (s->high_water < s->window_size) {
    1405           55805 :         ulg curr = s->strstart + (ulg)(s->lookahead);
    1406                 :         ulg init;
    1407                 : 
    1408           55805 :         if (s->high_water < curr) {
    1409                 :             /* Previous high water mark below current data -- zero WIN_INIT
    1410                 :              * bytes or up to end of window, whichever is less.
    1411                 :              */
    1412           55474 :             init = s->window_size - curr;
    1413           55474 :             if (init > WIN_INIT)
    1414           53029 :                 init = WIN_INIT;
    1415           55474 :             zmemzero(s->window + curr, (unsigned)init);
    1416           55474 :             s->high_water = curr + init;
    1417                 :         }
    1418             331 :         else if (s->high_water < (ulg)curr + WIN_INIT) {
    1419                 :             /* High water mark at or above current data, but below current data
    1420                 :              * plus WIN_INIT -- zero out to current data plus WIN_INIT, or up
    1421                 :              * to end of window, whichever is less.
    1422                 :              */
    1423             298 :             init = (ulg)curr + WIN_INIT - s->high_water;
    1424             298 :             if (init > s->window_size - s->high_water)
    1425               0 :                 init = s->window_size - s->high_water;
    1426             298 :             zmemzero(s->window + s->high_water, (unsigned)init);
    1427             298 :             s->high_water += init;
    1428                 :         }
    1429                 :     }
    1430                 : }
    1431                 : 
    1432                 : /* ===========================================================================
    1433                 :  * Flush the current block, with given end-of-file flag.
    1434                 :  * IN assertion: strstart is set to the end of the current match.
    1435                 :  */
    1436                 : #define FLUSH_BLOCK_ONLY(s, last) { \
    1437                 :    _tr_flush_block(s, (s->block_start >= 0L ? \
    1438                 :                    (charf *)&s->window[(unsigned)s->block_start] : \
    1439                 :                    (charf *)Z_NULL), \
    1440                 :                 (ulg)((long)s->strstart - s->block_start), \
    1441                 :                 (last)); \
    1442                 :    s->block_start = s->strstart; \
    1443                 :    flush_pending(s->strm); \
    1444                 :    Tracev((stderr,"[FLUSH]")); \
    1445                 : }
    1446                 : 
    1447                 : /* Same but force premature exit if necessary. */
    1448                 : #define FLUSH_BLOCK(s, last) { \
    1449                 :    FLUSH_BLOCK_ONLY(s, last); \
    1450                 :    if (s->strm->avail_out == 0) return (last) ? finish_started : need_more; \
    1451                 : }
    1452                 : 
    1453                 : /* ===========================================================================
    1454                 :  * Copy without compression as much as possible from the input stream, return
    1455                 :  * the current block state.
    1456                 :  * This function does not insert new strings in the dictionary since
    1457                 :  * uncompressible data is probably not useful. This function is used
    1458                 :  * only for the level=0 compression option.
    1459                 :  * NOTE: this function should be optimized to avoid extra copying from
    1460                 :  * window to pending_buf.
    1461                 :  */
    1462               0 : local block_state deflate_stored(s, flush)
    1463                 :     deflate_state *s;
    1464                 :     int flush;
    1465                 : {
    1466                 :     /* Stored blocks are limited to 0xffff bytes, pending_buf is limited
    1467                 :      * to pending_buf_size, and each stored block has a 5 byte header:
    1468                 :      */
    1469               0 :     ulg max_block_size = 0xffff;
    1470                 :     ulg max_start;
    1471                 : 
    1472               0 :     if (max_block_size > s->pending_buf_size - 5) {
    1473               0 :         max_block_size = s->pending_buf_size - 5;
    1474                 :     }
    1475                 : 
    1476                 :     /* Copy as much as possible from input to output: */
    1477                 :     for (;;) {
    1478                 :         /* Fill the window as much as possible: */
    1479               0 :         if (s->lookahead <= 1) {
    1480                 : 
    1481                 :             Assert(s->strstart < s->w_size+MAX_DIST(s) ||
    1482                 :                    s->block_start >= (long)s->w_size, "slide too late");
    1483                 : 
    1484               0 :             fill_window(s);
    1485               0 :             if (s->lookahead == 0 && flush == Z_NO_FLUSH) return need_more;
    1486                 : 
    1487               0 :             if (s->lookahead == 0) break; /* flush the current block */
    1488                 :         }
    1489                 :         Assert(s->block_start >= 0L, "block gone");
    1490                 : 
    1491               0 :         s->strstart += s->lookahead;
    1492               0 :         s->lookahead = 0;
    1493                 : 
    1494                 :         /* Emit a stored block if pending_buf will be full: */
    1495               0 :         max_start = s->block_start + max_block_size;
    1496               0 :         if (s->strstart == 0 || (ulg)s->strstart >= max_start) {
    1497                 :             /* strstart == 0 is possible when wraparound on 16-bit machine */
    1498               0 :             s->lookahead = (uInt)(s->strstart - max_start);
    1499               0 :             s->strstart = (uInt)max_start;
    1500               0 :             FLUSH_BLOCK(s, 0);
    1501                 :         }
    1502                 :         /* Flush if we may have to slide, otherwise block_start may become
    1503                 :          * negative and the data will be gone:
    1504                 :          */
    1505               0 :         if (s->strstart - (uInt)s->block_start >= MAX_DIST(s)) {
    1506               0 :             FLUSH_BLOCK(s, 0);
    1507                 :         }
    1508               0 :     }
    1509               0 :     FLUSH_BLOCK(s, flush == Z_FINISH);
    1510               0 :     return flush == Z_FINISH ? finish_done : block_done;
    1511                 : }
    1512                 : 
    1513                 : /* ===========================================================================
    1514                 :  * Compress as much as possible from the input stream, return the current
    1515                 :  * block state.
    1516                 :  * This function does not perform lazy evaluation of matches and inserts
    1517                 :  * new strings in the dictionary only for unmatched strings or for short
    1518                 :  * matches. It is used only for the fast compression options.
    1519                 :  */
    1520        69900590 : local block_state deflate_fast(s, flush)
    1521                 :     deflate_state *s;
    1522                 :     int flush;
    1523                 : {
    1524                 :     IPos hash_head;       /* head of the hash chain */
    1525                 :     int bflush;           /* set if current block must be flushed */
    1526                 : 
    1527                 :     for (;;) {
    1528                 :         /* Make sure that we always have enough lookahead, except
    1529                 :          * at the end of the input file. We need MAX_MATCH bytes
    1530                 :          * for the next match, plus MIN_MATCH bytes to insert the
    1531                 :          * string following the next match.
    1532                 :          */
    1533        69900590 :         if (s->lookahead < MIN_LOOKAHEAD) {
    1534          540536 :             fill_window(s);
    1535          540536 :             if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) {
    1536          161702 :                 return need_more;
    1537                 :             }
    1538          378834 :             if (s->lookahead == 0) break; /* flush the current block */
    1539                 :         }
    1540                 : 
    1541                 :         /* Insert the string window[strstart .. strstart+2] in the
    1542                 :          * dictionary, and set hash_head to the head of the hash chain:
    1543                 :          */
    1544        69733746 :         hash_head = NIL;
    1545        69733746 :         if (s->lookahead >= MIN_MATCH) {
    1546        69731857 :             INSERT_STRING(s, s->strstart, hash_head);
    1547                 :         }
    1548                 : 
    1549                 :         /* Find the longest match, discarding those <= prev_length.
    1550                 :          * At this point we have always match_length < MIN_MATCH
    1551                 :          */
    1552        69733746 :         if (hash_head != NIL && s->strstart - hash_head <= MAX_DIST(s)) {
    1553                 :             /* To simplify the code, we prevent matches with the string
    1554                 :              * of window index 0 (in particular we have to avoid a match
    1555                 :              * of the string with itself at the start of the input file).
    1556                 :              */
    1557        57463510 :             s->match_length = longest_match (s, hash_head);
    1558                 :             /* longest_match() sets match_start */
    1559                 :         }
    1560        69733746 :         if (s->match_length >= MIN_MATCH) {
    1561                 :             check_match(s, s->strstart, s->match_start, s->match_length);
    1562                 : 
    1563        46897321 :             _tr_tally_dist(s, s->strstart - s->match_start,
    1564                 :                            s->match_length - MIN_MATCH, bflush);
    1565                 : 
    1566        46897321 :             s->lookahead -= s->match_length;
    1567                 : 
    1568                 :             /* Insert new strings in the hash table only if the match length
    1569                 :              * is not too large. This saves time but degrades compression.
    1570                 :              */
    1571                 : #ifndef FASTEST
    1572        67721326 :             if (s->match_length <= s->max_insert_length &&
    1573        20824005 :                 s->lookahead >= MIN_MATCH) {
    1574        20819810 :                 s->match_length--; /* string at strstart already in table */
    1575                 :                 do {
    1576        54953209 :                     s->strstart++;
    1577        54953209 :                     INSERT_STRING(s, s->strstart, hash_head);
    1578                 :                     /* strstart never exceeds WSIZE-MAX_MATCH, so there are
    1579                 :                      * always MIN_MATCH bytes ahead.
    1580                 :                      */
    1581        54953209 :                 } while (--s->match_length != 0);
    1582        20819810 :                 s->strstart++;
    1583                 :             } else
    1584                 : #endif
    1585                 :             {
    1586        26077511 :                 s->strstart += s->match_length;
    1587        26077511 :                 s->match_length = 0;
    1588        26077511 :                 s->ins_h = s->window[s->strstart];
    1589        26077511 :                 UPDATE_HASH(s, s->ins_h, s->window[s->strstart+1]);
    1590                 : #if MIN_MATCH != 3
    1591                 :                 Call UPDATE_HASH() MIN_MATCH-3 more times
    1592                 : #endif
    1593                 :                 /* If lookahead < MIN_MATCH, ins_h is garbage, but it does not
    1594                 :                  * matter since it will be recomputed at next deflate call.
    1595                 :                  */
    1596                 :             }
    1597                 :         } else {
    1598                 :             /* No match, output a literal byte */
    1599                 :             Tracevv((stderr,"%c", s->window[s->strstart]));
    1600        22836425 :             _tr_tally_lit (s, s->window[s->strstart], bflush);
    1601        22836425 :             s->lookahead--;
    1602        22836425 :             s->strstart++;
    1603                 :         }
    1604        69733746 :         if (bflush) FLUSH_BLOCK(s, 0);
    1605        69731169 :     }
    1606            9001 :     FLUSH_BLOCK(s, flush == Z_FINISH);
    1607            1677 :     return flush == Z_FINISH ? finish_done : block_done;
    1608                 : }
    1609                 : 
    1610                 : #ifndef FASTEST
    1611                 : /* ===========================================================================
    1612                 :  * Same as above, but achieves better compression. We use a lazy
    1613                 :  * evaluation for matches: a match is finally adopted only if there is
    1614                 :  * no better match at the next window position.
    1615                 :  */
    1616           25011 : local block_state deflate_slow(s, flush)
    1617                 :     deflate_state *s;
    1618                 :     int flush;
    1619                 : {
    1620                 :     IPos hash_head;          /* head of hash chain */
    1621                 :     int bflush;              /* set if current block must be flushed */
    1622                 : 
    1623                 :     /* Process the input block. */
    1624                 :     for (;;) {
    1625                 :         /* Make sure that we always have enough lookahead, except
    1626                 :          * at the end of the input file. We need MAX_MATCH bytes
    1627                 :          * for the next match, plus MIN_MATCH bytes to insert the
    1628                 :          * string following the next match.
    1629                 :          */
    1630           25011 :         if (s->lookahead < MIN_LOOKAHEAD) {
    1631            2895 :             fill_window(s);
    1632            2895 :             if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) {
    1633             308 :                 return need_more;
    1634                 :             }
    1635            2587 :             if (s->lookahead == 0) break; /* flush the current block */
    1636                 :         }
    1637                 : 
    1638                 :         /* Insert the string window[strstart .. strstart+2] in the
    1639                 :          * dictionary, and set hash_head to the head of the hash chain:
    1640                 :          */
    1641           24654 :         hash_head = NIL;
    1642           24654 :         if (s->lookahead >= MIN_MATCH) {
    1643           24624 :             INSERT_STRING(s, s->strstart, hash_head);
    1644                 :         }
    1645                 : 
    1646                 :         /* Find the longest match, discarding those <= prev_length.
    1647                 :          */
    1648           24654 :         s->prev_length = s->match_length, s->prev_match = s->match_start;
    1649           24654 :         s->match_length = MIN_MATCH-1;
    1650                 : 
    1651           32438 :         if (hash_head != NIL && s->prev_length < s->max_lazy_match &&
    1652            7784 :             s->strstart - hash_head <= MAX_DIST(s)) {
    1653                 :             /* To simplify the code, we prevent matches with the string
    1654                 :              * of window index 0 (in particular we have to avoid a match
    1655                 :              * of the string with itself at the start of the input file).
    1656                 :              */
    1657            7784 :             s->match_length = longest_match (s, hash_head);
    1658                 :             /* longest_match() sets match_start */
    1659                 : 
    1660            7784 :             if (s->match_length <= 5 && (s->strategy == Z_FILTERED
    1661                 : #if TOO_FAR <= 32767
    1662            3566 :                 || (s->match_length == MIN_MATCH &&
    1663             942 :                     s->strstart - s->match_start > TOO_FAR)
    1664                 : #endif
    1665                 :                 )) {
    1666                 : 
    1667                 :                 /* If prev_match is also MIN_MATCH, match_start is garbage
    1668                 :                  * but we will ignore the current match anyway.
    1669                 :                  */
    1670            2390 :                 s->match_length = MIN_MATCH-1;
    1671                 :             }
    1672                 :         }
    1673                 :         /* If there was a match at the previous step and the current
    1674                 :          * match is not better, output the previous match:
    1675                 :          */
    1676           27396 :         if (s->prev_length >= MIN_MATCH && s->match_length <= s->prev_length) {
    1677            2742 :             uInt max_insert = s->strstart + s->lookahead - MIN_MATCH;
    1678                 :             /* Do not insert strings in hash table beyond this. */
    1679                 : 
    1680                 :             check_match(s, s->strstart-1, s->prev_match, s->prev_length);
    1681                 : 
    1682            2742 :             _tr_tally_dist(s, s->strstart -1 - s->prev_match,
    1683                 :                            s->prev_length - MIN_MATCH, bflush);
    1684                 : 
    1685                 :             /* Insert in hash table all strings up to the end of the match.
    1686                 :              * strstart-1 and strstart are already inserted. If there is not
    1687                 :              * enough lookahead, the last two strings are not inserted in
    1688                 :              * the hash table.
    1689                 :              */
    1690            2742 :             s->lookahead -= s->prev_length-1;
    1691            2742 :             s->prev_length -= 2;
    1692                 :             do {
    1693           36736 :                 if (++s->strstart <= max_insert) {
    1694           36672 :                     INSERT_STRING(s, s->strstart, hash_head);
    1695                 :                 }
    1696           36736 :             } while (--s->prev_length != 0);
    1697            2742 :             s->match_available = 0;
    1698            2742 :             s->match_length = MIN_MATCH-1;
    1699            2742 :             s->strstart++;
    1700                 : 
    1701            2742 :             if (bflush) FLUSH_BLOCK(s, 0);
    1702                 : 
    1703           21912 :         } else if (s->match_available) {
    1704                 :             /* If there was no match at the previous position, output a
    1705                 :              * single literal. If there was a match but the current match
    1706                 :              * is longer, truncate the previous match to a single literal.
    1707                 :              */
    1708                 :             Tracevv((stderr,"%c", s->window[s->strstart-1]));
    1709           19155 :             _tr_tally_lit(s, s->window[s->strstart-1], bflush);
    1710           19155 :             if (bflush) {
    1711               0 :                 FLUSH_BLOCK_ONLY(s, 0);
    1712                 :             }
    1713           19155 :             s->strstart++;
    1714           19155 :             s->lookahead--;
    1715           19155 :             if (s->strm->avail_out == 0) return need_more;
    1716                 :         } else {
    1717                 :             /* There is no previous match to compare with, wait for
    1718                 :              * the next step to decide.
    1719                 :              */
    1720            2757 :             s->match_available = 1;
    1721            2757 :             s->strstart++;
    1722            2757 :             s->lookahead--;
    1723                 :         }
    1724           24654 :     }
    1725                 :     Assert (flush != Z_NO_FLUSH, "no flush?");
    1726              49 :     if (s->match_available) {
    1727                 :         Tracevv((stderr,"%c", s->window[s->strstart-1]));
    1728              15 :         _tr_tally_lit(s, s->window[s->strstart-1], bflush);
    1729              15 :         s->match_available = 0;
    1730                 :     }
    1731              49 :     FLUSH_BLOCK(s, flush == Z_FINISH);
    1732              48 :     return flush == Z_FINISH ? finish_done : block_done;
    1733                 : }
    1734                 : #endif /* FASTEST */
    1735                 : 
    1736                 : /* ===========================================================================
    1737                 :  * For Z_RLE, simply look for runs of bytes, generate matches only of distance
    1738                 :  * one.  Do not maintain a hash table.  (It will be regenerated if this run of
    1739                 :  * deflate switches away from Z_RLE.)
    1740                 :  */
    1741               0 : local block_state deflate_rle(s, flush)
    1742                 :     deflate_state *s;
    1743                 :     int flush;
    1744                 : {
    1745                 :     int bflush;             /* set if current block must be flushed */
    1746                 :     uInt prev;              /* byte at distance one to match */
    1747                 :     Bytef *scan, *strend;   /* scan goes up to strend for length of run */
    1748                 : 
    1749                 :     for (;;) {
    1750                 :         /* Make sure that we always have enough lookahead, except
    1751                 :          * at the end of the input file. We need MAX_MATCH bytes
    1752                 :          * for the longest encodable run.
    1753                 :          */
    1754               0 :         if (s->lookahead < MAX_MATCH) {
    1755               0 :             fill_window(s);
    1756               0 :             if (s->lookahead < MAX_MATCH && flush == Z_NO_FLUSH) {
    1757               0 :                 return need_more;
    1758                 :             }
    1759               0 :             if (s->lookahead == 0) break; /* flush the current block */
    1760                 :         }
    1761                 : 
    1762                 :         /* See how many times the previous byte repeats */
    1763               0 :         s->match_length = 0;
    1764               0 :         if (s->lookahead >= MIN_MATCH && s->strstart > 0) {
    1765               0 :             scan = s->window + s->strstart - 1;
    1766               0 :             prev = *scan;
    1767               0 :             if (prev == *++scan && prev == *++scan && prev == *++scan) {
    1768               0 :                 strend = s->window + s->strstart + MAX_MATCH;
    1769                 :                 do {
    1770               0 :                 } while (prev == *++scan && prev == *++scan &&
    1771               0 :                          prev == *++scan && prev == *++scan &&
    1772               0 :                          prev == *++scan && prev == *++scan &&
    1773               0 :                          prev == *++scan && prev == *++scan &&
    1774               0 :                          scan < strend);
    1775               0 :                 s->match_length = MAX_MATCH - (int)(strend - scan);
    1776               0 :                 if (s->match_length > s->lookahead)
    1777               0 :                     s->match_length = s->lookahead;
    1778                 :             }
    1779                 :         }
    1780                 : 
    1781                 :         /* Emit match if have run of MIN_MATCH or longer, else emit literal */
    1782               0 :         if (s->match_length >= MIN_MATCH) {
    1783                 :             check_match(s, s->strstart, s->strstart - 1, s->match_length);
    1784                 : 
    1785               0 :             _tr_tally_dist(s, 1, s->match_length - MIN_MATCH, bflush);
    1786                 : 
    1787               0 :             s->lookahead -= s->match_length;
    1788               0 :             s->strstart += s->match_length;
    1789               0 :             s->match_length = 0;
    1790                 :         } else {
    1791                 :             /* No match, output a literal byte */
    1792                 :             Tracevv((stderr,"%c", s->window[s->strstart]));
    1793               0 :             _tr_tally_lit (s, s->window[s->strstart], bflush);
    1794               0 :             s->lookahead--;
    1795               0 :             s->strstart++;
    1796                 :         }
    1797               0 :         if (bflush) FLUSH_BLOCK(s, 0);
    1798               0 :     }
    1799               0 :     FLUSH_BLOCK(s, flush == Z_FINISH);
    1800               0 :     return flush == Z_FINISH ? finish_done : block_done;
    1801                 : }
    1802                 : 
    1803                 : /* ===========================================================================
    1804                 :  * For Z_HUFFMAN_ONLY, do not look for matches.  Do not maintain a hash table.
    1805                 :  * (It will be regenerated if this run of deflate switches away from Huffman.)
    1806                 :  */
    1807               0 : local block_state deflate_huff(s, flush)
    1808                 :     deflate_state *s;
    1809                 :     int flush;
    1810                 : {
    1811                 :     int bflush;             /* set if current block must be flushed */
    1812                 : 
    1813                 :     for (;;) {
    1814                 :         /* Make sure that we have a literal to write. */
    1815               0 :         if (s->lookahead == 0) {
    1816               0 :             fill_window(s);
    1817               0 :             if (s->lookahead == 0) {
    1818               0 :                 if (flush == Z_NO_FLUSH)
    1819               0 :                     return need_more;
    1820                 :                 break;      /* flush the current block */
    1821                 :             }
    1822                 :         }
    1823                 : 
    1824                 :         /* Output a literal byte */
    1825               0 :         s->match_length = 0;
    1826                 :         Tracevv((stderr,"%c", s->window[s->strstart]));
    1827               0 :         _tr_tally_lit (s, s->window[s->strstart], bflush);
    1828               0 :         s->lookahead--;
    1829               0 :         s->strstart++;
    1830               0 :         if (bflush) FLUSH_BLOCK(s, 0);
    1831               0 :     }
    1832               0 :     FLUSH_BLOCK(s, flush == Z_FINISH);
    1833               0 :     return flush == Z_FINISH ? finish_done : block_done;
    1834                 : }

Generated by: LCOV version 1.7