WebSVN – Kolibri OS – Diff – /programs/develop/libraries/zlib/deflate.c

 /* deflate.c -- compress data using the deflation algorithm
- * Copyright (C) 1995-2010 Jean-loup Gailly and Mark Adler
+ * Copyright (C) 1995-2013 Jean-loup Gailly and Mark Adler
  * For conditions of distribution and use, see copyright notice in zlib.h
  */
 /*
  *      Thanks to many people for bug reports and testing.
+ *
  *  REFERENCES
+ *
  *      Deutsch, L.P.,"DEFLATE Compressed Data Format Specification".
- *      Available in http://www.ietf.org/rfc/rfc1951.txt
+ *      Available in http://tools.ietf.org/html/rfc1951
+ *
  *      A description of the Rabin and Karp algorithm is given in the book
  *         "Algorithms" by R. Sedgewick, Addison-Wesley, p252.
+ *
  *      Fiala,E.R., and Greene,D.H.
 /* @(#) $Id$ */
 #include "deflate.h"
 const char deflate_copyright[] =
-   " deflate 1.2.5 Copyright 1995-2010 Jean-loup Gailly and Mark Adler ";
+   " deflate 1.2.8 Copyright 1995-2013 Jean-loup Gailly and Mark Adler ";
 /*
   If you use the zlib library in a product, an acknowledgment is welcome
   in the documentation of your product. If for some reason you cannot
 #ifndef NO_DUMMY_DECL
 struct static_tree_desc_s {int dummy;}; /* for buggy compilers */
+#endif
+/* rank Z_BLOCK between Z_NO_FLUSH and Z_PARTIAL_FLUSH */
-#endif
+#define RANK(f) (((f) << 1) - ((f) > 4 ? 9 : 0))
 /* ===========================================================================
  * Update a hash value with the given input byte
  * IN  assertion: all calls to to UPDATE_HASH are made with consecutive
+    }
     if (strm == Z_NULL) return Z_STREAM_ERROR;
     strm->msg = Z_NULL;
+    if (strm->zalloc == (alloc_func)0) {
+#ifdef Z_SOLO
+        return Z_STREAM_ERROR;
-    if (strm->zalloc == (alloc_func)0) {
+#else
         strm->zalloc = zcalloc;
+        strm->opaque = (voidpf)0;
-        strm->opaque = (voidpf)0;
+#endif
     }
+    if (strm->zfree == (free_func)0)
+#ifdef Z_SOLO
+        return Z_STREAM_ERROR;
+#else
+        strm->zfree = zcfree;
-    if (strm->zfree == (free_func)0) strm->zfree = zcfree;
+#endif
 #ifdef FASTEST
     if (level != 0) level = 1;
     s->pending_buf_size = (ulg)s->lit_bufsize * (sizeof(ush)+2L);
     if (s->window == Z_NULL || s->prev == Z_NULL || s->head == Z_NULL ||
         s->pending_buf == Z_NULL) {
         s->status = FINISH_STATE;
-        strm->msg = (char*)ERR_MSG(Z_MEM_ERROR);
+        strm->msg = ERR_MSG(Z_MEM_ERROR);
         deflateEnd (strm);
         return Z_MEM_ERROR;
+    }
     s->d_buf = overlay + s->lit_bufsize/sizeof(ush);
     z_streamp strm;
     const Bytef *dictionary;
     uInt  dictLength;
+{
     deflate_state *s;
-    uInt length = dictLength;
+    uInt str, n;
-    uInt n;
+    int wrap;
-    IPos hash_head = 0;
+    unsigned avail;
-    if (strm == Z_NULL || strm->state == Z_NULL || dictionary == Z_NULL ||
-        strm->state->wrap == 2 ||
+    z_const unsigned char *next;
-        (strm->state->wrap == 1 && strm->state->status != INIT_STATE))
-        return Z_STREAM_ERROR;
+    if (strm == Z_NULL || strm->state == Z_NULL || dictionary == Z_NULL)
         return Z_STREAM_ERROR;
     s = strm->state;
+    wrap = s->wrap;
+    if (wrap == 2 || (wrap == 1 && s->status != INIT_STATE) || s->lookahead)
+        return Z_STREAM_ERROR;
+    /* when using zlib wrappers, compute Adler-32 for provided dictionary */
-    if (s->wrap)
+    if (wrap == 1)
+        strm->adler = adler32(strm->adler, dictionary, dictLength);
-        strm->adler = adler32(strm->adler, dictionary, dictLength);
+    s->wrap = 0;                    /* avoid computing Adler-32 in read_buf */
-    if (length < MIN_MATCH) return Z_OK;
-    if (length > s->w_size) {
+    /* if dictionary would fill window, just replace the history */
-        length = s->w_size;
-        dictionary += dictLength - length; /* use the tail of the dictionary */
+    if (dictLength >= s->w_size) {
-    }
+        if (wrap == 0) {            /* already empty otherwise */
-    zmemcpy(s->window, dictionary, length);
+            CLEAR_HASH(s);
-    s->strstart = length;
-    s->block_start = (long)length;
-    /* Insert all strings in the hash table (except for the last two bytes).
-     * s->lookahead stays null, so s->ins_h will be recomputed at the next
-     * call of fill_window.
+            s->strstart = 0;
-     */
-    s->ins_h = s->window[0];
-    UPDATE_HASH(s, s->ins_h, s->window[1]);
-    for (n = 0; n <= length - MIN_MATCH; n++) {
+            s->block_start = 0L;
+            s->insert = 0;
+        }
+        dictionary += dictLength - s->w_size;  /* use the tail */
+        dictLength = s->w_size;
-        INSERT_STRING(s, n, hash_head);
+    }
+    /* insert dictionary into window and hash */
+    avail = strm->avail_in;
+    next = strm->next_in;
+    strm->avail_in = dictLength;
+    strm->next_in = (z_const Bytef *)dictionary;
+    fill_window(s);
+    while (s->lookahead >= MIN_MATCH) {
+        str = s->strstart;
+        n = s->lookahead - (MIN_MATCH-1);
+        do {
+            UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]);
+#ifndef FASTEST
+            s->prev[str & s->w_mask] = s->head[s->ins_h];
+#endif
+            s->head[s->ins_h] = (Pos)str;
+            str++;
+        } while (--n);
+        s->strstart = str;
+        s->lookahead = MIN_MATCH-1;
+        fill_window(s);
+    }
+    s->strstart += s->lookahead;
+    s->block_start = (long)s->strstart;
+    s->insert = s->lookahead;
+    s->lookahead = 0;
+    s->match_length = s->prev_length = MIN_MATCH-1;
+    s->match_available = 0;
+    strm->next_in = next;
     strm->avail_in = avail;
-    if (hash_head) hash_head = 0;  /* to make compiler happy */
+    s->wrap = wrap;
     return Z_OK;
 }
 /* ========================================================================= */
-int ZEXPORT deflateReset (strm)
+int ZEXPORT deflateResetKeep (strm)
     z_streamp strm;
 #endif
         adler32(0L, Z_NULL, 0);
     s->last_flush = Z_NO_FLUSH;
-    _tr_init(s);
-    lm_init(s);
+    _tr_init(s);
     return Z_OK;
+}
+/* ========================================================================= */
+int ZEXPORT deflateReset (strm)
+    z_streamp strm;
+{
+    int ret;
+    ret = deflateResetKeep(strm);
+    if (ret == Z_OK)
+        lm_init(strm->state);
+    return ret;
+}
 /* ========================================================================= */
 int ZEXPORT deflateSetHeader (strm, head)
     z_streamp strm;
     strm->state->gzhead = head;
     return Z_OK;
+}
+/* ========================================================================= */
+int ZEXPORT deflatePending (strm, pending, bits)
+    unsigned *pending;
+    int *bits;
+    z_streamp strm;
+{
+    if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+    if (pending != Z_NULL)
+        *pending = strm->state->pending;
+    if (bits != Z_NULL)
+        *bits = strm->state->bi_valid;
+    return Z_OK;
+}
 /* ========================================================================= */
 int ZEXPORT deflatePrime (strm, bits, value)
     z_streamp strm;
     int bits;
     int value;
+{
+    deflate_state *s;
+    int put;
+    if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+    s = strm->state;
+    if ((Bytef *)(s->d_buf) < s->pending_out + ((Buf_size + 7) >> 3))
+        return Z_BUF_ERROR;
+    do {
+        put = Buf_size - s->bi_valid;
-    if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+        if (put > bits)
-    strm->state->bi_valid = bits;
+            put = bits;
+        s->bi_buf |= (ush)((value & ((1 << put) - 1)) << s->bi_valid);
+        s->bi_valid += put;
+        _tr_flush_bits(s);
+        value >>= put;
+        bits -= put;
-    strm->state->bi_buf = (ush)(value & ((1 << bits) - 1));
+    } while (bits);
     return Z_OK;
+}
     if ((strategy != s->strategy || func != configuration_table[level].func) &&
         strm->total_in != 0) {
         /* Flush the last buffer: */
+        err = deflate(strm, Z_BLOCK);
+        if (err == Z_BUF_ERROR && s->pending == 0)
-        err = deflate(strm, Z_BLOCK);
+            err = Z_OK;
+    }
     if (s->level != level) {
         s->level = level;
         s->max_lazy_match   = configuration_table[level].max_lazy;
  * (See also read_buf()).
  */
 local void flush_pending(strm)
     z_streamp strm;
+{
+    unsigned len;
-    unsigned len = strm->state->pending;
+    deflate_state *s = strm->state;
+    _tr_flush_bits(s);
     len = s->pending;
     if (len > strm->avail_out) len = strm->avail_out;
     if (len == 0) return;
-    zmemcpy(strm->next_out, strm->state->pending_out, len);
+    zmemcpy(strm->next_out, s->pending_out, len);
     strm->next_out  += len;
-    strm->state->pending_out  += len;
+    s->pending_out  += len;
     strm->total_out += len;
     strm->avail_out  -= len;
-    strm->state->pending -= len;
+    s->pending -= len;
-    if (strm->state->pending == 0) {
+    if (s->pending == 0) {
-        strm->state->pending_out = strm->state->pending_buf;
+        s->pending_out = s->pending_buf;
+    }
+}
     /* Make sure there is something to do and avoid duplicate consecutive
      * flushes. For repeated and useless calls with Z_FINISH, we keep
      * returning Z_STREAM_END instead of Z_BUF_ERROR.
      */
-    } else if (strm->avail_in == 0 && flush <= old_flush &&
+    } else if (strm->avail_in == 0 && RANK(flush) <= RANK(old_flush) &&
                flush != Z_FINISH) {
         ERR_RETURN(strm, Z_BUF_ERROR);
+    }
                 if (flush == Z_FULL_FLUSH) {
                     CLEAR_HASH(s);             /* forget history */
                     if (s->lookahead == 0) {
                         s->strstart = 0;
                         s->block_start = 0L;
+                        s->insert = 0;
+                    }
+                }
+            }
             flush_pending(strm);
             if (strm->avail_out == 0) {
         return Z_STREAM_ERROR;
+    }
     ss = source->state;
-    zmemcpy(dest, source, sizeof(z_stream));
+    zmemcpy((voidpf)dest, (voidpf)source, sizeof(z_stream));
     ds = (deflate_state *) ZALLOC(dest, 1, sizeof(deflate_state));
     if (ds == Z_NULL) return Z_MEM_ERROR;
     dest->state = (struct internal_state FAR *) ds;
-    zmemcpy(ds, ss, sizeof(deflate_state));
+    zmemcpy((voidpf)ds, (voidpf)ss, sizeof(deflate_state));
     ds->strm = dest;
         deflateEnd (dest);
         return Z_MEM_ERROR;
+    }
     /* following zmemcpy do not work for 16-bit MSDOS */
     zmemcpy(ds->window, ss->window, ds->w_size * 2 * sizeof(Byte));
-    zmemcpy(ds->prev, ss->prev, ds->w_size * sizeof(Pos));
+    zmemcpy((voidpf)ds->prev, (voidpf)ss->prev, ds->w_size * sizeof(Pos));
-    zmemcpy(ds->head, ss->head, ds->hash_size * sizeof(Pos));
+    zmemcpy((voidpf)ds->head, (voidpf)ss->head, ds->hash_size * sizeof(Pos));
     zmemcpy(ds->pending_buf, ss->pending_buf, (uInt)ds->pending_buf_size);
     ds->pending_out = ds->pending_buf + (ss->pending_out - ss->pending_buf);
     ds->d_buf = overlay + ds->lit_bufsize/sizeof(ush);
     if (len > size) len = size;
     if (len == 0) return 0;
+    strm->avail_in  -= len;
     strm->avail_in  -= len;
+    zmemcpy(buf, strm->next_in, len);
     if (strm->state->wrap == 1) {
-        strm->adler = adler32(strm->adler, strm->next_in, len);
+        strm->adler = adler32(strm->adler, buf, len);
+    }
 #ifdef GZIP
     else if (strm->state->wrap == 2) {
-        strm->adler = crc32(strm->adler, strm->next_in, len);
+        strm->adler = crc32(strm->adler, buf, len);
-    }
 #endif
-    zmemcpy(buf, strm->next_in, len);
+#endif
     strm->next_in  += len;
     strm->total_in += len;
     s->max_chain_length = configuration_table[s->level].max_chain;
     s->strstart = 0;
     s->block_start = 0L;
+    s->lookahead = 0;
-    s->lookahead = 0;
+    s->insert = 0;
     s->match_length = s->prev_length = MIN_MATCH-1;
     s->match_available = 0;
     s->ins_h = 0;
 #ifndef FASTEST
     register unsigned n, m;
     register Posf *p;
     unsigned more;    /* Amount of free space at the end of the window. */
     uInt wsize = s->w_size;
+    Assert(s->lookahead < MIN_LOOKAHEAD, "already enough lookahead");
     do {
         more = (unsigned)(s->window_size -(ulg)s->lookahead -(ulg)s->strstart);
                  */
             } while (--n);
 #endif
             more += wsize;
+        }
-        if (s->strm->avail_in == 0) return;
+        if (s->strm->avail_in == 0) break;
         /* If there was no sliding:
          *    strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 &&
          *    more == window_size - lookahead - strstart
         n = read_buf(s->strm, s->window + s->strstart + s->lookahead, more);
         s->lookahead += n;
+        /* Initialize the hash value now that we have some input: */
-        /* Initialize the hash value now that we have some input: */
+        if (s->lookahead + s->insert >= MIN_MATCH) {
-        if (s->lookahead >= MIN_MATCH) {
+            uInt str = s->strstart - s->insert;
-            s->ins_h = s->window[s->strstart];
+            s->ins_h = s->window[str];
-            UPDATE_HASH(s, s->ins_h, s->window[s->strstart+1]);
+            UPDATE_HASH(s, s->ins_h, s->window[str + 1]);
 #if MIN_MATCH != 3
+            Call UPDATE_HASH() MIN_MATCH-3 more times
+#endif
+            while (s->insert) {
+                UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]);
+#ifndef FASTEST
+                s->prev[str & s->w_mask] = s->head[s->ins_h];
+#endif
+                s->head[s->ins_h] = (Pos)str;
+                str++;
+                s->insert--;
+                if (s->lookahead + s->insert < MIN_MATCH)
-            Call UPDATE_HASH() MIN_MATCH-3 more times
+                    break;
 #endif
+        }
         /* If the whole input has less than MIN_MATCH bytes, ins_h is garbage,
                 init = s->window_size - s->high_water;
             zmemzero(s->window + s->high_water, (unsigned)init);
             s->high_water += init;
+        }
+    }
+    Assert((ulg)s->strstart <= s->window_size - MIN_LOOKAHEAD,
+           "not enough room for search");
+}
 /* ===========================================================================
  * Flush the current block, with given end-of-file flag.
          */
         if (s->strstart - (uInt)s->block_start >= MAX_DIST(s)) {
             FLUSH_BLOCK(s, 0);
+        }
+    }
+    s->insert = 0;
-    FLUSH_BLOCK(s, flush == Z_FINISH);
+    if (flush == Z_FINISH) {
+        FLUSH_BLOCK(s, 1);
-    return flush == Z_FINISH ? finish_done : block_done;
+        return finish_done;
+    }
+    if ((long)s->strstart > s->block_start)
+        FLUSH_BLOCK(s, 0);
+    return block_done;
+}
 /* ===========================================================================
  * Compress as much as possible from the input stream, return the current
             s->lookahead--;
             s->strstart++;
+        }
         if (bflush) FLUSH_BLOCK(s, 0);
+    }
+    s->insert = s->strstart < MIN_MATCH-1 ? s->strstart : MIN_MATCH-1;
-    FLUSH_BLOCK(s, flush == Z_FINISH);
+    if (flush == Z_FINISH) {
+        FLUSH_BLOCK(s, 1);
-    return flush == Z_FINISH ? finish_done : block_done;
+        return finish_done;
+    }
+    if (s->last_lit)
+        FLUSH_BLOCK(s, 0);
+    return block_done;
+}
 #ifndef FASTEST
 /* ===========================================================================
     if (s->match_available) {
         Tracevv((stderr,"%c", s->window[s->strstart-1]));
         _tr_tally_lit(s, s->window[s->strstart-1], bflush);
         s->match_available = 0;
+    }
+    s->insert = s->strstart < MIN_MATCH-1 ? s->strstart : MIN_MATCH-1;
-    FLUSH_BLOCK(s, flush == Z_FINISH);
+    if (flush == Z_FINISH) {
+        FLUSH_BLOCK(s, 1);
-    return flush == Z_FINISH ? finish_done : block_done;
+        return finish_done;
+    }
+    if (s->last_lit)
+        FLUSH_BLOCK(s, 0);
+    return block_done;
+}
 #endif /* FASTEST */
 /* ===========================================================================
     Bytef *scan, *strend;   /* scan goes up to strend for length of run */
     for (;;) {
         /* Make sure that we always have enough lookahead, except
          * at the end of the input file. We need MAX_MATCH bytes
-         * for the longest encodable run.
+         * for the longest run, plus one for the unrolled loop.
          */
-        if (s->lookahead < MAX_MATCH) {
+        if (s->lookahead <= MAX_MATCH) {
             fill_window(s);
-            if (s->lookahead < MAX_MATCH && flush == Z_NO_FLUSH) {
+            if (s->lookahead <= MAX_MATCH && flush == Z_NO_FLUSH) {
                 return need_more;
+            }
             if (s->lookahead == 0) break; /* flush the current block */
                          scan < strend);
                 s->match_length = MAX_MATCH - (int)(strend - scan);
                 if (s->match_length > s->lookahead)
                     s->match_length = s->lookahead;
+            }
+            Assert(scan <= s->window+(uInt)(s->window_size-1), "wild scan");
+        }
         /* Emit match if have run of MIN_MATCH or longer, else emit literal */
         if (s->match_length >= MIN_MATCH) {
             s->lookahead--;
             s->strstart++;
+        }
         if (bflush) FLUSH_BLOCK(s, 0);
+    }
+    s->insert = 0;
-    FLUSH_BLOCK(s, flush == Z_FINISH);
+    if (flush == Z_FINISH) {
+        FLUSH_BLOCK(s, 1);
-    return flush == Z_FINISH ? finish_done : block_done;
+        return finish_done;
+    }
+    if (s->last_lit)
+        FLUSH_BLOCK(s, 0);
+    return block_done;
+}
 /* ===========================================================================
  * For Z_HUFFMAN_ONLY, do not look for matches.  Do not maintain a hash table.
         _tr_tally_lit (s, s->window[s->strstart], bflush);
         s->lookahead--;
         s->strstart++;
         if (bflush) FLUSH_BLOCK(s, 0);
+    }
+    s->insert = 0;
-    FLUSH_BLOCK(s, flush == Z_FINISH);
+    if (flush == Z_FINISH) {
+        FLUSH_BLOCK(s, 1);
-    return flush == Z_FINISH ? finish_done : block_done;
+        return finish_done;
+    }
+    if (s->last_lit)
+        FLUSH_BLOCK(s, 0);
+    return block_done;
+}

Subversion Repositories Kolibri OS

(root)/programs/develop/libraries/zlib/deflate.c – Rev 1896 → 3926