Merge tag 'upstream/1.5'

[debian/gzip] / deflate.c

diff --git a/deflate.c b/deflate.c
index 5405f10eff3f1ec546d00dfe4a57aeb9e4f04243..4a0f3d37b28278a00695d6440c7993d91e6e5845 100644 (file)
--- a/deflate.c
+++ b/deflate.c
@@ -131,6 +131,14 @@
 #endif
 /* Matches of length 3 are discarded if their distance exceeds TOO_FAR */
 
+#ifndef RSYNC_WIN
+#  define RSYNC_WIN 8192
+#endif
+/* Size of rsync window, must be < MAX_DIST */
+
+#define RSYNC_SUM_MATCH(sum) (((sum) & (RSYNC_WIN - 1)) == 0)
+/* Whether window sum matches magic value */
+
 /* ===========================================================================
  * Local data used by the "longest match" routines.
  */
@@ -212,6 +220,8 @@ local int compr_level;
 unsigned good_match;
 /* Use a faster search when the previous match is longer than this */
 
+local ulg rsync_sum;  /* rolling sum of rsync window */
+local ulg rsync_chunk_end; /* next rsync sequence point */
 
 /* Values for max_lazy_match, good_match and max_chain_length, depending on
  * the desired pack level (0..9). The values given below have been tuned to
@@ -314,6 +324,10 @@ void lm_init (pack_level, flags)
 #endif
     /* prev will be initialized on the fly */
 
+    /* rsync params */
+    rsync_chunk_end = 0xFFFFFFFFUL;
+    rsync_sum = 0;
+
     /* Set the default configuration parameters:
      */
     max_lazy_match   = configuration_table[pack_level].max_lazy;
@@ -331,6 +345,7 @@ void lm_init (pack_level, flags)
 
     strstart = 0;
     block_start = 0L;
+    rsync_chunk_end = 0xFFFFFFFFUL;
 #ifdef ASMV
     match_init(); /* initialize the asm code */
 #endif
@@ -550,6 +565,8 @@ local void fill_window()
         memcpy((char*)window, (char*)window+WSIZE, (unsigned)WSIZE);
         match_start -= WSIZE;
         strstart    -= WSIZE; /* we now have strstart >= MAX_DIST: */
+       if (rsync_chunk_end != 0xFFFFFFFFUL)
+           rsync_chunk_end -= WSIZE;
 
         block_start -= (long) WSIZE;
 
@@ -579,6 +596,39 @@ local void fill_window()
     }
 }
 
+local void rsync_roll(start, num)
+    unsigned start;
+    unsigned num;
+{
+    unsigned i;
+
+    if (start < RSYNC_WIN) {
+       /* before window fills. */
+       for (i = start; i < RSYNC_WIN; i++) {
+           if (i == start + num) return;
+           rsync_sum += (ulg)window[i];
+       }
+       num -= (RSYNC_WIN - start);
+       start = RSYNC_WIN;
+    }
+
+    /* buffer after window full */
+    for (i = start; i < start+num; i++) {
+       /* New character in */
+       rsync_sum += (ulg)window[i];
+       /* Old character out */
+       rsync_sum -= (ulg)window[i - RSYNC_WIN];
+       if (rsync_chunk_end == 0xFFFFFFFFUL && RSYNC_SUM_MATCH(rsync_sum))
+           rsync_chunk_end = i;
+    }
+}
+
+/* ===========================================================================
+ * Set rsync_chunk_end if window sum matches magic value.
+ */
+#define RSYNC_ROLL(s, n) \
+   do { if (rsync) rsync_roll((s), (n)); } while(0)
+
 /* ===========================================================================
  * Flush the current block, with given end-of-file flag.
  * IN assertion: strstart is set to the end of the current match.
@@ -626,7 +676,8 @@ local off_t deflate_fast()
 
             lookahead -= match_length;
 
-            /* Insert new strings in the hash table only if the match length
+           RSYNC_ROLL(strstart, match_length);
+           /* Insert new strings in the hash table only if the match length
              * is not too large. This saves time but degrades compression.
              */
             if (match_length <= max_insert_length) {
@@ -654,9 +705,18 @@ local off_t deflate_fast()
             /* No match, output a literal byte */
             Tracevv((stderr,"%c",window[strstart]));
             flush = ct_tally (0, window[strstart]);
+           RSYNC_ROLL(strstart, 1);
             lookahead--;
             strstart++;
         }
+        if (rsync && strstart > rsync_chunk_end) {
+            ush  attr = 0;          /* ascii/binary flag */
+
+            flush = 1;
+            /* Reset huffman tree */
+            ct_init(&attr, &method);
+            rsync_chunk_end = 0xFFFFFFFFUL;
+        }
         if (flush) FLUSH_BLOCK(0), block_start = strstart;
 
         /* Make sure that we always have enough lookahead, except
@@ -730,6 +790,7 @@ off_t deflate()
              */
             lookahead -= prev_length-1;
             prev_length -= 2;
+           RSYNC_ROLL(strstart, prev_length+1);
             do {
                 strstart++;
                 INSERT_STRING(strstart, hash_head);
@@ -742,24 +803,51 @@ off_t deflate()
             match_available = 0;
             match_length = MIN_MATCH-1;
             strstart++;
-            if (flush) FLUSH_BLOCK(0), block_start = strstart;
 
+           if (rsync && strstart > rsync_chunk_end) {
+               ush  attr = 0;          /* ascii/binary flag */
+
+               /* Reset huffman tree */
+               ct_init(&attr, &method);
+               rsync_chunk_end = 0xFFFFFFFFUL;
+               flush = 1;
+           }
+            if (flush) FLUSH_BLOCK(0), block_start = strstart;
         } else if (match_available) {
             /* If there was no match at the previous position, output a
              * single literal. If there was a match but the current match
              * is longer, truncate the previous match to a single literal.
              */
             Tracevv((stderr,"%c",window[strstart-1]));
-            if (ct_tally (0, window[strstart-1])) {
-                FLUSH_BLOCK(0), block_start = strstart;
-            }
+           flush = ct_tally (0, window[strstart-1]);
+           if (rsync && strstart > rsync_chunk_end) {
+               ush  attr = 0;          /* ascii/binary flag */
+
+               /* Reset huffman tree */
+               ct_init(&attr, &method);
+               rsync_chunk_end = 0xFFFFFFFFUL;
+
+               flush = 1;
+           }
+            if (flush) FLUSH_BLOCK(0), block_start = strstart;
+           RSYNC_ROLL(strstart, 1);
             strstart++;
             lookahead--;
         } else {
             /* There is no previous match to compare with, wait for
              * the next step to decide.
              */
+           if (rsync && strstart > rsync_chunk_end) {
+               ush  attr = 0;          /* ascii/binary flag */
+
+               /* Reset huffman tree */
+               ct_init(&attr, &method);
+               rsync_chunk_end = 0xFFFFFFFFUL;
+
+               FLUSH_BLOCK(0), block_start = strstart;
+           }
             match_available = 1;
+           RSYNC_ROLL(strstart, 1);
             strstart++;
             lookahead--;
         }