1 files changed, 24 insertions, 14 deletions

diff --git a/modules/brotli/enc/backward_references_inc.h b/modules/brotli/enc/backward_references_inc.h
index c18cdb00c..766bf91ff 100644
--- a/modules/brotli/enc/backward_references_inc.h
+++ b/modules/brotli/enc/backward_references_inc.h
@@ -10,11 +10,13 @@
 static BROTLI_NOINLINE void EXPORT_FN(CreateBackwardReferences)(
     size_t num_bytes, size_t position,
     const uint8_t* ringbuffer, size_t ringbuffer_mask,
-    const BrotliEncoderParams* params,
-    HasherHandle hasher, int* dist_cache, size_t* last_insert_len,
+    ContextLut literal_context_lut, const BrotliEncoderParams* params,
+    Hasher* hasher, int* dist_cache, size_t* last_insert_len,
     Command* commands, size_t* num_commands, size_t* num_literals) {
+  HASHER()* privat = &hasher->privat.FN(_);
   /* Set maximum distance, see section 9.1. of the spec. */
   const size_t max_backward_limit = BROTLI_MAX_BACKWARD_LIMIT(params->lgwin);
+  const size_t position_offset = params->stream_offset;
 
   const Command* const orig_commands = commands;
   size_t insert_length = *last_insert_len;
@@ -31,19 +33,23 @@ static BROTLI_NOINLINE void EXPORT_FN(CreateBackwardReferences)(
   /* Minimum score to accept a backward reference. */
   const score_t kMinScore = BROTLI_SCORE_BASE + 100;
 
-  FN(PrepareDistanceCache)(hasher, dist_cache);
+  BROTLI_UNUSED(literal_context_lut);
+
+  FN(PrepareDistanceCache)(privat, dist_cache);
 
   while (position + FN(HashTypeLength)() < pos_end) {
     size_t max_length = pos_end - position;
     size_t max_distance = BROTLI_MIN(size_t, position, max_backward_limit);
+    size_t dictionary_start = BROTLI_MIN(size_t,
+        position + position_offset, max_backward_limit);
     HasherSearchResult sr;
     sr.len = 0;
     sr.len_code_delta = 0;
     sr.distance = 0;
     sr.score = kMinScore;
-    FN(FindLongestMatch)(hasher, &params->dictionary,
+    FN(FindLongestMatch)(privat, &params->dictionary,
         ringbuffer, ringbuffer_mask, dist_cache, position, max_length,
-        max_distance, gap, params->dist.max_distance, &sr);
+        max_distance, dictionary_start + gap, params->dist.max_distance, &sr);
     if (sr.score > kMinScore) {
       /* Found a match. Let's look for something even better ahead. */
       int delayed_backward_references_in_row = 0;
@@ -57,10 +63,13 @@ static BROTLI_NOINLINE void EXPORT_FN(CreateBackwardReferences)(
         sr2.distance = 0;
         sr2.score = kMinScore;
         max_distance = BROTLI_MIN(size_t, position + 1, max_backward_limit);
-        FN(FindLongestMatch)(hasher,
+        dictionary_start = BROTLI_MIN(size_t,
+            position + 1 + position_offset, max_backward_limit);
+        FN(FindLongestMatch)(privat,
             &params->dictionary,
             ringbuffer, ringbuffer_mask, dist_cache, position + 1, max_length,
-            max_distance, gap, params->dist.max_distance, &sr2);
+            max_distance, dictionary_start + gap, params->dist.max_distance,
+            &sr2);
         if (sr2.score >= sr.score + cost_diff_lazy) {
           /* Ok, let's just write one byte for now and start a match from the
              next byte. */
@@ -76,18 +85,19 @@ static BROTLI_NOINLINE void EXPORT_FN(CreateBackwardReferences)(
       }
       apply_random_heuristics =
           position + 2 * sr.len + random_heuristics_window_size;
-      max_distance = BROTLI_MIN(size_t, position, max_backward_limit);
+      dictionary_start = BROTLI_MIN(size_t,
+          position + position_offset, max_backward_limit);
       {
         /* The first 16 codes are special short-codes,
            and the minimum offset is 1. */
         size_t distance_code = ComputeDistanceCode(
-            sr.distance, max_distance + gap, dist_cache);
-        if ((sr.distance <= (max_distance + gap)) && distance_code > 0) {
+            sr.distance, dictionary_start + gap, dist_cache);
+        if ((sr.distance <= (dictionary_start + gap)) && distance_code > 0) {
           dist_cache[3] = dist_cache[2];
           dist_cache[2] = dist_cache[1];
           dist_cache[1] = dist_cache[0];
           dist_cache[0] = (int)sr.distance;
-          FN(PrepareDistanceCache)(hasher, dist_cache);
+          FN(PrepareDistanceCache)(privat, dist_cache);
         }
         InitCommand(commands++, &params->dist, insert_length,
             sr.len, sr.len_code_delta, distance_code);
@@ -105,7 +115,7 @@ static BROTLI_NOINLINE void EXPORT_FN(CreateBackwardReferences)(
           range_start = BROTLI_MIN(size_t, range_end, BROTLI_MAX(size_t,
               range_start, position + sr.len - (sr.distance << 2)));
         }
-        FN(StoreRange)(hasher, ringbuffer, ringbuffer_mask, range_start,
+        FN(StoreRange)(privat, ringbuffer, ringbuffer_mask, range_start,
                        range_end);
       }
       position += sr.len;
@@ -131,7 +141,7 @@ static BROTLI_NOINLINE void EXPORT_FN(CreateBackwardReferences)(
           size_t pos_jump =
               BROTLI_MIN(size_t, position + 16, pos_end - kMargin);
           for (; position < pos_jump; position += 4) {
-            FN(Store)(hasher, ringbuffer, ringbuffer_mask, position);
+            FN(Store)(privat, ringbuffer, ringbuffer_mask, position);
             insert_length += 4;
           }
         } else {
@@ -140,7 +150,7 @@ static BROTLI_NOINLINE void EXPORT_FN(CreateBackwardReferences)(
           size_t pos_jump =
               BROTLI_MIN(size_t, position + 8, pos_end - kMargin);
           for (; position < pos_jump; position += 2) {
-            FN(Store)(hasher, ringbuffer, ringbuffer_mask, position);
+            FN(Store)(privat, ringbuffer, ringbuffer_mask, position);
             insert_length += 2;
           }
         }