brotli 0.1.8 → 0.2.0

data/vendor/brotli/c/enc/backward_references.h

@@ -0,0 +1,39 @@
+/* Copyright 2013 Google Inc. All Rights Reserved.
+
+   Distributed under MIT license.
+   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+*/
+
+/* Function to find backward reference copies. */
+
+#ifndef BROTLI_ENC_BACKWARD_REFERENCES_H_
+#define BROTLI_ENC_BACKWARD_REFERENCES_H_
+
+#include "../common/constants.h"
+#include "../common/dictionary.h"
+#include <brotli/types.h>
+#include "./command.h"
+#include "./hash.h"
+#include "./port.h"
+#include "./quality.h"
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+/* "commands" points to the next output command to write to, "*num_commands" is
+   initially the total amount of commands output by previous
+   CreateBackwardReferences calls, and must be incremented by the amount written
+   by this call. */
+BROTLI_INTERNAL void BrotliCreateBackwardReferences(
+    const BrotliDictionary* dictionary, 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, Command* commands, size_t* num_commands,
+    size_t* num_literals);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}  /* extern "C" */
+#endif
+
+#endif  /* BROTLI_ENC_BACKWARD_REFERENCES_H_ */

data/vendor/brotli/{enc/backward_references.c → c/enc/backward_references_hq.c}

@@ -6,13 +6,12 @@
 
 /* Function to find backward reference copies. */
 
-#include "./backward_references.h"
+#include "./backward_references_hq.h"
 
-#include <math.h>  /* INFINITY */
 #include <string.h>  /* memcpy, memset */
 
 #include "../common/constants.h"
-#include "../common/types.h"
+#include <brotli/types.h>
 #include "./command.h"
 #include "./fast_log.h"
 #include "./find_match_length.h"
@@ -26,11 +25,14 @@
 extern "C" {
 #endif
 
-#ifdef INFINITY
-static const float kInfinity = INFINITY;
-#else
-static const float kInfinity = 3.4028e38f;
-#endif
+static const float kInfinity = 1.7e38f;  /* ~= 2 ^ 127 */
+
+static const uint32_t kDistanceCacheIndex[] = {
+  0, 1, 2, 3, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1,
+};
+static const int kDistanceCacheOffset[] = {
+  0, 0, 0, 0, -1, 1, -2, 2, -3, 3, -1, 1, -2, 2, -3, 3
+};
 
 void BrotliInitZopfliNodes(ZopfliNode* array, size_t length) {
   ZopfliNode stub;
@@ -57,7 +59,9 @@ static BROTLI_INLINE uint32_t ZopfliNodeCopyDistance(const ZopfliNode* self) {
 
 static BROTLI_INLINE uint32_t ZopfliNodeDistanceCode(const ZopfliNode* self) {
   const uint32_t short_code = self->distance >> 25;
-  return short_code == 0 ? ZopfliNodeCopyDistance(self) + 15 : short_code - 1;
+  return short_code == 0 ?
+      ZopfliNodeCopyDistance(self) + BROTLI_NUM_DISTANCE_SHORT_CODES - 1 :
+      short_code - 1;
 }
 
 static BROTLI_INLINE uint32_t ZopfliNodeCommandLength(const ZopfliNode* self) {
@@ -210,30 +214,6 @@ static BROTLI_INLINE float ZopfliCostModelGetMinCostCmd(
   return self->min_cost_cmd_;
 }
 
-static BROTLI_INLINE size_t ComputeDistanceCode(size_t distance,
-                                                size_t max_distance,
-                                                const int* dist_cache) {
-  if (distance <= max_distance) {
-    size_t distance_plus_3 = distance + 3;
-    size_t offset0 = distance_plus_3 - (size_t)dist_cache[0];
-    size_t offset1 = distance_plus_3 - (size_t)dist_cache[1];
-    if (distance == (size_t)dist_cache[0]) {
-      return 0;
-    } else if (distance == (size_t)dist_cache[1]) {
-      return 1;
-    } else if (offset0 < 7) {
-      return (0x9750468 >> (4 * offset0)) & 0xF;
-    } else if (offset1 < 7) {
-      return (0xFDB1ACE >> (4 * offset1)) & 0xF;
-    } else if (distance == (size_t)dist_cache[2]) {
-      return 2;
-    } else if (distance == (size_t)dist_cache[3]) {
-      return 3;
-    }
-  }
-  return distance + 15;
-}
-
 /* REQUIRES: len >= 2, start_pos <= pos */
 /* REQUIRES: cost < kInfinity, nodes[start_pos].cost < kInfinity */
 /* Maintains the "ZopfliNode array invariant". */
@@ -320,6 +300,7 @@ static size_t ComputeMinimumCopyLength(const float start_cost,
 static uint32_t ComputeDistanceShortcut(const size_t block_start,
                                         const size_t pos,
                                         const size_t max_backward,
+                                        const size_t gap,
                                         const ZopfliNode* nodes) {
   const size_t clen = ZopfliNodeCopyLength(&nodes[pos]);
   const size_t ilen = nodes[pos].insert_length;
@@ -331,8 +312,8 @@ static uint32_t ComputeDistanceShortcut(const size_t block_start,
      does not update the last distances. */
   if (pos == 0) {
     return 0;
-  } else if (dist + clen <= block_start + pos &&
-             dist <= max_backward &&
+  } else if (dist + clen <= block_start + pos + gap &&
+             dist <= max_backward + gap &&
              ZopfliNodeDistanceCode(&nodes[pos]) > 0) {
     return (uint32_t)pos;
   } else {
@@ -344,7 +325,7 @@ static uint32_t ComputeDistanceShortcut(const size_t block_start,
    Section 4. of the Spec) that would be used at (block_start + pos) if we
    used the shortest path of commands from block_start, computed from
    nodes[0..pos]. The last four distances at block_start are in
-   starting_dist_cach[0..3].
+   starting_dist_cache[0..3].
    REQUIRES: nodes[pos].cost < kInfinity
    REQUIRES: nodes[0..pos] satisfies that "ZopfliNode array invariant". */
 static void ComputeDistanceCache(const size_t pos,
@@ -366,19 +347,36 @@ static void ComputeDistanceCache(const size_t pos,
   }
 }
 
-static void UpdateNodes(const size_t num_bytes,
-                        const size_t block_start,
-                        const size_t pos,
-                        const uint8_t* ringbuffer,
-                        const size_t ringbuffer_mask,
-                        const BrotliEncoderParams* params,
-                        const size_t max_backward_limit,
-                        const int* starting_dist_cache,
-                        const size_t num_matches,
-                        const BackwardMatch* matches,
-                        const ZopfliCostModel* model,
-                        StartPosQueue* queue,
-                        ZopfliNode* nodes) {
+/* Maintains "ZopfliNode array invariant" and pushes node to the queue, if it
+   is eligible. */
+static void EvaluateNode(
+    const size_t block_start, const size_t pos, const size_t max_backward_limit,
+    const size_t gap, const int* starting_dist_cache,
+    const ZopfliCostModel* model, StartPosQueue* queue, ZopfliNode* nodes) {
+  /* Save cost, because ComputeDistanceCache invalidates it. */
+  float node_cost = nodes[pos].u.cost;
+  nodes[pos].u.shortcut = ComputeDistanceShortcut(
+      block_start, pos, max_backward_limit, gap, nodes);
+  if (node_cost <= ZopfliCostModelGetLiteralCosts(model, 0, pos)) {
+    PosData posdata;
+    posdata.pos = pos;
+    posdata.cost = node_cost;
+    posdata.costdiff = node_cost -
+        ZopfliCostModelGetLiteralCosts(model, 0, pos);
+    ComputeDistanceCache(
+        pos, starting_dist_cache, nodes, posdata.distance_cache);
+    StartPosQueuePush(queue, &posdata);
+  }
+}
+
+/* Returns longest copy length. */
+static size_t UpdateNodes(
+    const size_t num_bytes, const size_t block_start, const size_t pos,
+    const uint8_t* ringbuffer, const size_t ringbuffer_mask,
+    const BrotliEncoderParams* params, const size_t max_backward_limit,
+    const int* starting_dist_cache, const size_t num_matches,
+    const BackwardMatch* matches, const ZopfliCostModel* model,
+    StartPosQueue* queue, ZopfliNode* nodes) {
   const size_t cur_ix = block_start + pos;
   const size_t cur_ix_masked = cur_ix & ringbuffer_mask;
   const size_t max_distance = BROTLI_MIN(size_t, cur_ix, max_backward_limit);
@@ -386,24 +384,12 @@ static void UpdateNodes(const size_t num_bytes,
   const size_t max_zopfli_len = MaxZopfliLen(params);
   const size_t max_iters = MaxZopfliCandidates(params);
   size_t min_len;
+  size_t result = 0;
   size_t k;
+  size_t gap = 0;
 
-  {
-    /* Save cost, because ComputeDistanceCache invalidates it. */
-    float node_cost = nodes[pos].u.cost;
-    nodes[pos].u.shortcut = ComputeDistanceShortcut(
-        block_start, pos, max_backward_limit, nodes);
-    if (node_cost <= ZopfliCostModelGetLiteralCosts(model, 0, pos)) {
-      PosData posdata;
-      posdata.pos = pos;
-      posdata.cost = node_cost;
-      posdata.costdiff = node_cost -
-        ZopfliCostModelGetLiteralCosts(model, 0, pos);
-      ComputeDistanceCache(
-          pos, starting_dist_cache, nodes, posdata.distance_cache);
-      StartPosQueuePush(queue, &posdata);
-    }
-  }
+  EvaluateNode(block_start, pos, max_backward_limit, gap, starting_dist_cache,
+      model, queue, nodes);
 
   {
     const PosData* posdata = StartPosQueueAt(queue, 0);
@@ -431,25 +417,31 @@ static void UpdateNodes(const size_t num_bytes,
       const size_t backward =
           (size_t)(posdata->distance_cache[idx] + kDistanceCacheOffset[j]);
       size_t prev_ix = cur_ix - backward;
-      if (prev_ix >= cur_ix) {
-        continue;
+      size_t len = 0;
+      uint8_t continuation = ringbuffer[cur_ix_masked + best_len];
+      if (cur_ix_masked + best_len > ringbuffer_mask) {
+        break;
       }
-      if (PREDICT_FALSE(backward > max_distance)) {
+      if (BROTLI_PREDICT_FALSE(backward > max_distance + gap)) {
         continue;
       }
-      prev_ix &= ringbuffer_mask;
+      if (backward <= max_distance) {
+        if (prev_ix >= cur_ix) {
+          continue;
+        }
 
-      if (cur_ix_masked + best_len > ringbuffer_mask ||
-          prev_ix + best_len > ringbuffer_mask ||
-          ringbuffer[cur_ix_masked + best_len] !=
-              ringbuffer[prev_ix + best_len]) {
+        prev_ix &= ringbuffer_mask;
+        if (prev_ix + best_len > ringbuffer_mask ||
+            continuation != ringbuffer[prev_ix + best_len]) {
+          continue;
+        }
+        len = FindMatchLengthWithLimit(&ringbuffer[prev_ix],
+                                       &ringbuffer[cur_ix_masked],
+                                       max_len);
+      } else {
         continue;
       }
       {
-        const size_t len =
-            FindMatchLengthWithLimit(&ringbuffer[prev_ix],
-                                     &ringbuffer[cur_ix_masked],
-                                     max_len);
         const float dist_cost = base_cost +
             ZopfliCostModelGetDistanceCost(model, j);
         size_t l;
@@ -462,6 +454,7 @@ static void UpdateNodes(const size_t num_bytes,
               ZopfliCostModelGetCommandCost(model, cmdcode);
           if (cost < nodes[pos + l].u.cost) {
             UpdateZopfliNode(nodes, pos, start, l, l, backward, j + 1, cost);
+            result = BROTLI_MAX(size_t, result, l);
           }
           best_len = l;
         }
@@ -479,10 +472,11 @@ static void UpdateNodes(const size_t num_bytes,
       for (j = 0; j < num_matches; ++j) {
         BackwardMatch match = matches[j];
         size_t dist = match.distance;
-        BROTLI_BOOL is_dictionary_match = TO_BROTLI_BOOL(dist > max_distance);
+        BROTLI_BOOL is_dictionary_match =
+            TO_BROTLI_BOOL(dist > max_distance + gap);
         /* We already tried all possible last distance matches, so we can use
            normal distance code here. */
-        size_t dist_code = dist + 15;
+        size_t dist_code = dist + BROTLI_NUM_DISTANCE_SHORT_CODES - 1;
         uint16_t dist_symbol;
         uint32_t distextra;
         uint32_t distnumextra;
@@ -510,11 +504,13 @@ static void UpdateNodes(const size_t num_bytes,
               ZopfliCostModelGetCommandCost(model, cmdcode);
           if (cost < nodes[pos + len].u.cost) {
             UpdateZopfliNode(nodes, pos, start, len, len_code, dist, 0, cost);
+            result = BROTLI_MAX(size_t, result, len);
           }
         }
       }
     }
   }
+  return result;
 }
 
 static size_t ComputeShortestPathFromNodes(size_t num_bytes,
@@ -532,17 +528,21 @@ static size_t ComputeShortestPathFromNodes(size_t num_bytes,
   return num_commands;
 }
 
+/* REQUIRES: nodes != NULL and len(nodes) >= num_bytes + 1 */
 void BrotliZopfliCreateCommands(const size_t num_bytes,
                                 const size_t block_start,
                                 const size_t max_backward_limit,
                                 const ZopfliNode* nodes,
                                 int* dist_cache,
                                 size_t* last_insert_len,
+                                const BrotliEncoderParams* params,
                                 Command* commands,
                                 size_t* num_literals) {
   size_t pos = 0;
   uint32_t offset = nodes[0].u.next;
   size_t i;
+  size_t gap = 0;
+  BROTLI_UNUSED(params);
   for (i = 0; offset != BROTLI_UINT32_MAX; i++) {
     const ZopfliNode* next = &nodes[pos + offset];
     size_t copy_length = ZopfliNodeCopyLength(next);
@@ -558,11 +558,11 @@ void BrotliZopfliCreateCommands(const size_t num_bytes,
       size_t len_code = ZopfliNodeLengthCode(next);
       size_t max_distance =
           BROTLI_MIN(size_t, block_start + pos, max_backward_limit);
-      BROTLI_BOOL is_dictionary = TO_BROTLI_BOOL(distance > max_distance);
+      BROTLI_BOOL is_dictionary = TO_BROTLI_BOOL(distance > max_distance + gap);
       size_t dist_code = ZopfliNodeDistanceCode(next);
 
-      InitCommand(
-          &commands[i], insert_length, copy_length, len_code, dist_code);
+      InitCommand(&commands[i], insert_length,
+          copy_length, (int)len_code - (int)copy_length, dist_code);
 
       if (!is_dictionary && dist_code > 0) {
         dist_cache[3] = dist_cache[2];
@@ -584,6 +584,7 @@ static size_t ZopfliIterate(size_t num_bytes,
                             size_t ringbuffer_mask,
                             const BrotliEncoderParams* params,
                             const size_t max_backward_limit,
+                            const size_t gap,
                             const int* dist_cache,
                             const ZopfliCostModel* model,
                             const uint32_t* num_matches,
@@ -597,23 +598,34 @@ static size_t ZopfliIterate(size_t num_bytes,
   nodes[0].u.cost = 0;
   InitStartPosQueue(&queue);
   for (i = 0; i + 3 < num_bytes; i++) {
-    UpdateNodes(num_bytes, position, i, ringbuffer, ringbuffer_mask,
-                params, max_backward_limit, dist_cache, num_matches[i],
-                &matches[cur_match_pos], model, &queue, nodes);
+    size_t skip = UpdateNodes(num_bytes, position, i, ringbuffer,
+        ringbuffer_mask, params, max_backward_limit, dist_cache,
+        num_matches[i], &matches[cur_match_pos], model, &queue, nodes);
+    if (skip < BROTLI_LONG_COPY_QUICK_STEP) skip = 0;
     cur_match_pos += num_matches[i];
-    /* The zopflification can be too slow in case of very long lengths, so in
-       such case skip it all, it does not cost a lot of compression ratio. */
     if (num_matches[i] == 1 &&
         BackwardMatchLength(&matches[cur_match_pos - 1]) > max_zopfli_len) {
-      i += BackwardMatchLength(&matches[cur_match_pos - 1]) - 1;
-      InitStartPosQueue(&queue);
+      skip = BROTLI_MAX(size_t,
+          BackwardMatchLength(&matches[cur_match_pos - 1]), skip);
+    }
+    if (skip > 1) {
+      skip--;
+      while (skip) {
+        i++;
+        if (i + 3 >= num_bytes) break;
+        EvaluateNode(position, i, max_backward_limit, gap, dist_cache, model,
+            &queue, nodes);
+        cur_match_pos += num_matches[i];
+        skip--;
+      }
     }
   }
   return ComputeShortestPathFromNodes(num_bytes, nodes);
 }
 
-
+/* REQUIRES: nodes != NULL and len(nodes) >= num_bytes + 1 */
 size_t BrotliZopfliComputeShortestPath(MemoryManager* m,
+                                       const BrotliDictionary* dictionary,
                                        size_t num_bytes,
                                        size_t position,
                                        const uint8_t* ringbuffer,
@@ -621,7 +633,7 @@ size_t BrotliZopfliComputeShortestPath(MemoryManager* m,
                                        const BrotliEncoderParams* params,
                                        const size_t max_backward_limit,
                                        const int* dist_cache,
-                                       H10* hasher,
+                                       HasherHandle hasher,
                                        ZopfliNode* nodes) {
   const size_t max_zopfli_len = MaxZopfliLen(params);
   ZopfliCostModel model;
@@ -630,6 +642,7 @@ size_t BrotliZopfliComputeShortestPath(MemoryManager* m,
   const size_t store_end = num_bytes >= StoreLookaheadH10() ?
       position + num_bytes - StoreLookaheadH10() + 1 : position;
   size_t i;
+  size_t gap = 0;
   nodes[0].length = 0;
   nodes[0].u.cost = 0;
   InitZopfliCostModel(m, &model, num_bytes);
@@ -640,122 +653,67 @@ size_t BrotliZopfliComputeShortestPath(MemoryManager* m,
   for (i = 0; i + HashTypeLengthH10() - 1 < num_bytes; i++) {
     const size_t pos = position + i;
     const size_t max_distance = BROTLI_MIN(size_t, pos, max_backward_limit);
-    size_t num_matches = FindAllMatchesH10(hasher, ringbuffer, ringbuffer_mask,
-        pos, num_bytes - i, max_distance, params, matches);
+    size_t num_matches = FindAllMatchesH10(hasher, dictionary, ringbuffer,
+        ringbuffer_mask, pos, num_bytes - i, max_distance, gap, params,
+        matches);
+    size_t skip;
     if (num_matches > 0 &&
         BackwardMatchLength(&matches[num_matches - 1]) > max_zopfli_len) {
       matches[0] = matches[num_matches - 1];
       num_matches = 1;
     }
-    UpdateNodes(num_bytes, position, i, ringbuffer, ringbuffer_mask,
-                params, max_backward_limit, dist_cache, num_matches, matches,
-                &model, &queue, nodes);
+    skip = UpdateNodes(num_bytes, position, i, ringbuffer, ringbuffer_mask,
+        params, max_backward_limit, dist_cache, num_matches, matches, &model,
+        &queue, nodes);
+    if (skip < BROTLI_LONG_COPY_QUICK_STEP) skip = 0;
     if (num_matches == 1 && BackwardMatchLength(&matches[0]) > max_zopfli_len) {
+      skip = BROTLI_MAX(size_t, BackwardMatchLength(&matches[0]), skip);
+    }
+    if (skip > 1) {
       /* Add the tail of the copy to the hasher. */
       StoreRangeH10(hasher, ringbuffer, ringbuffer_mask, pos + 1, BROTLI_MIN(
-          size_t, pos + BackwardMatchLength(&matches[0]), store_end));
-      i += BackwardMatchLength(&matches[0]) - 1;
-      InitStartPosQueue(&queue);
+          size_t, pos + skip, store_end));
+      skip--;
+      while (skip) {
+        i++;
+        if (i + HashTypeLengthH10() - 1 >= num_bytes) break;
+        EvaluateNode(position, i, max_backward_limit, gap, dist_cache, &model,
+            &queue, nodes);
+        skip--;
+      }
     }
   }
   CleanupZopfliCostModel(m, &model);
   return ComputeShortestPathFromNodes(num_bytes, nodes);
 }
 
-#define EXPAND_CAT(a, b) CAT(a, b)
-#define CAT(a, b) a ## b
-#define FN(X) EXPAND_CAT(X, HASHER())
-
-#define HASHER() H2
-/* NOLINTNEXTLINE(build/include) */
-#include "./backward_references_inc.h"
-#undef HASHER
-
-#define HASHER() H3
-/* NOLINTNEXTLINE(build/include) */
-#include "./backward_references_inc.h"
-#undef HASHER
-
-#define HASHER() H4
-/* NOLINTNEXTLINE(build/include) */
-#include "./backward_references_inc.h"
-#undef HASHER
-
-#define HASHER() H5
-/* NOLINTNEXTLINE(build/include) */
-#include "./backward_references_inc.h"
-#undef HASHER
-
-#define HASHER() H6
-/* NOLINTNEXTLINE(build/include) */
-#include "./backward_references_inc.h"
-#undef HASHER
-
-#define HASHER() H7
-/* NOLINTNEXTLINE(build/include) */
-#include "./backward_references_inc.h"
-#undef HASHER
-
-#define HASHER() H8
-/* NOLINTNEXTLINE(build/include) */
-#include "./backward_references_inc.h"
-#undef HASHER
-
-#define HASHER() H9
-/* NOLINTNEXTLINE(build/include) */
-#include "./backward_references_inc.h"
-#undef HASHER
-
-#define HASHER() H40
-/* NOLINTNEXTLINE(build/include) */
-#include "./backward_references_inc.h"
-#undef HASHER
-
-#define HASHER() H41
-/* NOLINTNEXTLINE(build/include) */
-#include "./backward_references_inc.h"
-#undef HASHER
-
-#define HASHER() H42
-/* NOLINTNEXTLINE(build/include) */
-#include "./backward_references_inc.h"
-#undef HASHER
-
-#undef FN
-#undef CAT
-#undef EXPAND_CAT
-
-static BROTLI_NOINLINE void CreateZopfliBackwardReferences(
-    MemoryManager* m, size_t num_bytes, size_t position, BROTLI_BOOL is_last,
-    const uint8_t* ringbuffer, size_t ringbuffer_mask,
-    const BrotliEncoderParams* params, H10* hasher, int* dist_cache,
+void BrotliCreateZopfliBackwardReferences(
+    MemoryManager* m, const BrotliDictionary* dictionary, 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, Command* commands, size_t* num_commands,
     size_t* num_literals) {
-  const size_t max_backward_limit = MaxBackwardLimit(params->lgwin);
+  const size_t max_backward_limit = BROTLI_MAX_BACKWARD_LIMIT(params->lgwin);
   ZopfliNode* nodes;
-  InitH10(m, hasher, ringbuffer, params, position, num_bytes, is_last);
-  if (BROTLI_IS_OOM(m)) return;
-  StitchToPreviousBlockH10(hasher, num_bytes, position,
-                           ringbuffer, ringbuffer_mask);
   nodes = BROTLI_ALLOC(m, ZopfliNode, num_bytes + 1);
   if (BROTLI_IS_OOM(m)) return;
   BrotliInitZopfliNodes(nodes, num_bytes + 1);
-  *num_commands += BrotliZopfliComputeShortestPath(m, num_bytes, position,
-      ringbuffer, ringbuffer_mask, params, max_backward_limit,
+  *num_commands += BrotliZopfliComputeShortestPath(m, dictionary, num_bytes,
+      position, ringbuffer, ringbuffer_mask, params, max_backward_limit,
       dist_cache, hasher, nodes);
   if (BROTLI_IS_OOM(m)) return;
   BrotliZopfliCreateCommands(num_bytes, position, max_backward_limit, nodes,
-      dist_cache, last_insert_len, commands, num_literals);
+      dist_cache, last_insert_len, params, commands, num_literals);
   BROTLI_FREE(m, nodes);
 }
 
-static BROTLI_NOINLINE void CreateHqZopfliBackwardReferences(
-    MemoryManager* m, size_t num_bytes, size_t position, BROTLI_BOOL is_last,
-    const uint8_t* ringbuffer, size_t ringbuffer_mask,
-    const BrotliEncoderParams* params, H10* hasher, int* dist_cache,
+void BrotliCreateHqZopfliBackwardReferences(
+    MemoryManager* m, const BrotliDictionary* dictionary, 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, Command* commands, size_t* num_commands,
     size_t* num_literals) {
-  const size_t max_backward_limit = MaxBackwardLimit(params->lgwin);
+  const size_t max_backward_limit = BROTLI_MAX_BACKWARD_LIMIT(params->lgwin);
   uint32_t* num_matches = BROTLI_ALLOC(m, uint32_t, num_bytes);
   size_t matches_size = 4 * num_bytes;
   const size_t store_end = num_bytes >= StoreLookaheadH10() ?
@@ -769,11 +727,8 @@ static BROTLI_NOINLINE void CreateHqZopfliBackwardReferences(
   ZopfliCostModel model;
   ZopfliNode* nodes;
   BackwardMatch* matches = BROTLI_ALLOC(m, BackwardMatch, matches_size);
+  size_t gap = 0;
   if (BROTLI_IS_OOM(m)) return;
-  InitH10(m, hasher, ringbuffer, params, position, num_bytes, is_last);
-  if (BROTLI_IS_OOM(m)) return;
-  StitchToPreviousBlockH10(hasher, num_bytes, position,
-                           ringbuffer, ringbuffer_mask);
   for (i = 0; i + HashTypeLengthH10() - 1 < num_bytes; ++i) {
     const size_t pos = position + i;
     size_t max_distance = BROTLI_MIN(size_t, pos, max_backward_limit);
@@ -785,14 +740,13 @@ static BROTLI_NOINLINE void CreateHqZopfliBackwardReferences(
     BROTLI_ENSURE_CAPACITY(m, BackwardMatch, matches, matches_size,
         cur_match_pos + MAX_NUM_MATCHES_H10);
     if (BROTLI_IS_OOM(m)) return;
-    num_found_matches = FindAllMatchesH10(hasher, ringbuffer, ringbuffer_mask,
-        pos, max_length, max_distance, params, &matches[cur_match_pos]);
+    num_found_matches = FindAllMatchesH10(hasher, dictionary, ringbuffer,
+        ringbuffer_mask, pos, max_length, max_distance, gap, params,
+        &matches[cur_match_pos]);
     cur_match_end = cur_match_pos + num_found_matches;
     for (j = cur_match_pos; j + 1 < cur_match_end; ++j) {
-      assert(BackwardMatchLength(&matches[j]) <
+      assert(BackwardMatchLength(&matches[j]) <=
           BackwardMatchLength(&matches[j + 1]));
-      assert(matches[j].distance > max_distance ||
-             matches[j].distance <= matches[j + 1].distance);
     }
     num_matches[i] = (uint32_t)num_found_matches;
     if (num_found_matches > 0) {
@@ -834,10 +788,10 @@ static BROTLI_NOINLINE void CreateHqZopfliBackwardReferences(
     *last_insert_len = orig_last_insert_len;
     memcpy(dist_cache, orig_dist_cache, 4 * sizeof(dist_cache[0]));
     *num_commands += ZopfliIterate(num_bytes, position, ringbuffer,
-        ringbuffer_mask, params, max_backward_limit, dist_cache,
+        ringbuffer_mask, params, max_backward_limit, gap, dist_cache,
         &model, num_matches, matches, nodes);
     BrotliZopfliCreateCommands(num_bytes, position, max_backward_limit,
-        nodes, dist_cache, last_insert_len, commands, num_literals);
+        nodes, dist_cache, last_insert_len, params, commands, num_literals);
   }
   CleanupZopfliCostModel(m, &model);
   BROTLI_FREE(m, nodes);
@@ -845,48 +799,6 @@ static BROTLI_NOINLINE void CreateHqZopfliBackwardReferences(
   BROTLI_FREE(m, num_matches);
 }
 
-void BrotliCreateBackwardReferences(MemoryManager* m,
-                                    size_t num_bytes,
-                                    size_t position,
-                                    BROTLI_BOOL is_last,
-                                    const uint8_t* ringbuffer,
-                                    size_t ringbuffer_mask,
-                                    const BrotliEncoderParams* params,
-                                    Hashers* hashers,
-                                    int* dist_cache,
-                                    size_t* last_insert_len,
-                                    Command* commands,
-                                    size_t* num_commands,
-                                    size_t* num_literals) {
-  if (params->quality == ZOPFLIFICATION_QUALITY) {
-    CreateZopfliBackwardReferences(
-        m, num_bytes, position, is_last, ringbuffer, ringbuffer_mask,
-        params, hashers->h10, dist_cache,
-        last_insert_len, commands, num_commands, num_literals);
-    return;
-  } else if (params->quality == HQ_ZOPFLIFICATION_QUALITY) {
-    CreateHqZopfliBackwardReferences(
-        m, num_bytes, position, is_last, ringbuffer, ringbuffer_mask,
-        params, hashers->h10, dist_cache,
-        last_insert_len, commands, num_commands, num_literals);
-    return;
-  }
-
-  switch (ChooseHasher(params)) {
-#define _CASE(N)                                                            \
-    case N:                                                                 \
-      CreateBackwardReferencesH ## N(m, num_bytes, position, is_last,       \
-          ringbuffer, ringbuffer_mask, params, hashers->h ## N, dist_cache, \
-          last_insert_len, commands, num_commands, num_literals);           \
-      break;
-    FOR_GENERIC_HASHERS(_CASE)
-#undef _CASE
-    default:
-      break;
-  }
-  if (BROTLI_IS_OOM(m)) return;
-}
-
 #if defined(__cplusplus) || defined(c_plusplus)
 }  /* extern "C" */
 #endif