Update Brotli to v1.0.1

- update README.md to the new versions (LZ4, Brotli)
2025-12-15 04:11:46 -06:00 · 2017-09-28 09:33:27 +02:00
parent 699a608314
commit a818384b05
39 changed files with 463 additions and 432 deletions
--- a/C/brotli/enc/backward_references_hq.h
+++ b/C/brotli/enc/backward_references_hq.h
@@ -83,14 +83,11 @@ BROTLI_INTERNAL size_t BrotliZopfliComputeShortestPath(
    const BrotliEncoderParams* params, const size_t max_backward_limit,
    const int* dist_cache, HasherHandle hasher, ZopfliNode* nodes);

-BROTLI_INTERNAL 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,
-                                                Command* commands,
-                                                size_t* num_literals);
+BROTLI_INTERNAL 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);

 #if defined(__cplusplus) || defined(c_plusplus)
 }  /* extern "C" */
--- a/C/brotli/enc/backward_references_inc.h
+++ b/C/brotli/enc/backward_references_inc.h
@@ -5,11 +5,11 @@
   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
 */

-/* template parameters: FN */
+/* template parameters: EXPORT_FN, FN */

-static BROTLI_NOINLINE void FN(CreateBackwardReferences)(
-    const BrotliDictionary* dictionary, const uint16_t* dictionary_hash,
-    size_t num_bytes, size_t position,
+static BROTLI_NOINLINE void EXPORT_FN(CreateBackwardReferences)(
+    const BrotliDictionary* dictionary,
+    const uint16_t* dictionary_hash, 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,
@@ -27,6 +27,7 @@ static BROTLI_NOINLINE void FN(CreateBackwardReferences)(
  const size_t random_heuristics_window_size =
      LiteralSpreeLengthForSparseSearch(params);
  size_t apply_random_heuristics = position + random_heuristics_window_size;
+  const size_t gap = 0;

  /* Minimum score to accept a backward reference. */
  const score_t kMinScore = BROTLI_SCORE_BASE + 100;
@@ -38,29 +39,29 @@ static BROTLI_NOINLINE void FN(CreateBackwardReferences)(
    size_t max_distance = BROTLI_MIN(size_t, position, max_backward_limit);
    HasherSearchResult sr;
    sr.len = 0;
-    sr.len_x_code = 0;
+    sr.len_code_delta = 0;
    sr.distance = 0;
    sr.score = kMinScore;
-    if (FN(FindLongestMatch)(hasher, dictionary, dictionary_hash,
-                             ringbuffer, ringbuffer_mask, dist_cache,
-                             position, max_length, max_distance, &sr)) {
+    FN(FindLongestMatch)(hasher, dictionary, dictionary_hash, ringbuffer,
+                         ringbuffer_mask, dist_cache, position,
+                         max_length, max_distance, gap, &sr);
+    if (sr.score > kMinScore) {
      /* Found a match. Let's look for something even better ahead. */
      int delayed_backward_references_in_row = 0;
      --max_length;
      for (;; --max_length) {
        const score_t cost_diff_lazy = 175;
-        BROTLI_BOOL is_match_found;
        HasherSearchResult sr2;
        sr2.len = params->quality < MIN_QUALITY_FOR_EXTENSIVE_REFERENCE_SEARCH ?
            BROTLI_MIN(size_t, sr.len - 1, max_length) : 0;
-        sr2.len_x_code = 0;
+        sr2.len_code_delta = 0;
        sr2.distance = 0;
        sr2.score = kMinScore;
        max_distance = BROTLI_MIN(size_t, position + 1, max_backward_limit);
-        is_match_found = FN(FindLongestMatch)(hasher, dictionary,
-            dictionary_hash, ringbuffer, ringbuffer_mask, dist_cache,
-            position + 1, max_length, max_distance, &sr2);
-        if (is_match_found && sr2.score >= sr.score + cost_diff_lazy) {
+        FN(FindLongestMatch)(hasher, dictionary, dictionary_hash, ringbuffer,
+                             ringbuffer_mask, dist_cache, position + 1,
+                             max_length, max_distance, gap, &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. */
          ++position;
@@ -80,24 +81,33 @@ static BROTLI_NOINLINE void FN(CreateBackwardReferences)(
        /* The first 16 codes are special short-codes,
           and the minimum offset is 1. */
        size_t distance_code =
-            ComputeDistanceCode(sr.distance, max_distance, dist_cache);
-        if (sr.distance <= max_distance && distance_code > 0) {
+            ComputeDistanceCode(sr.distance, max_distance + gap, dist_cache);
+        if ((sr.distance <= (max_distance + 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);
        }
-        InitCommand(commands++, insert_length, sr.len, sr.len ^ sr.len_x_code,
+        InitCommand(commands++, insert_length, sr.len, sr.len_code_delta,
            distance_code);
      }
      *num_literals += insert_length;
      insert_length = 0;
      /* Put the hash keys into the table, if there are enough bytes left.
         Depending on the hasher implementation, it can push all positions
-         in the given range or only a subset of them. */
-      FN(StoreRange)(hasher, ringbuffer, ringbuffer_mask, position + 2,
-                     BROTLI_MIN(size_t, position + sr.len, store_end));
+         in the given range or only a subset of them.
+         Avoid hash poisoning with RLE data. */
+      {
+        size_t range_start = position + 2;
+        size_t range_end = BROTLI_MIN(size_t, position + sr.len, store_end);
+        if (sr.distance < (sr.len >> 2)) {
+          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,
+                       range_end);
+      }
      position += sr.len;
    } else {
      ++insert_length;
--- a/C/brotli/enc/block_splitter_inc.h
+++ b/C/brotli/enc/block_splitter_inc.h
@@ -13,7 +13,7 @@ static void FN(InitialEntropyCodes)(const DataType* data, size_t length,
                                    size_t stride,
                                    size_t num_histograms,
                                    HistogramType* histograms) {
-  unsigned int seed = 7;
+  uint32_t seed = 7;
  size_t block_length = length / num_histograms;
  size_t i;
  FN(ClearHistograms)(histograms, num_histograms);
@@ -29,14 +29,13 @@ static void FN(InitialEntropyCodes)(const DataType* data, size_t length,
  }
 }

-static void FN(RandomSample)(unsigned int* seed,
+static void FN(RandomSample)(uint32_t* seed,
                             const DataType* data,
                             size_t length,
                             size_t stride,
                             HistogramType* sample) {
  size_t pos = 0;
  if (stride >= length) {
-    pos = 0;
    stride = length;
  } else {
    pos = MyRand(seed) % (length - stride + 1);
@@ -50,7 +49,7 @@ static void FN(RefineEntropyCodes)(const DataType* data, size_t length,
                                   HistogramType* histograms) {
  size_t iters =
      kIterMulForRefining * length / stride + kMinItersForRefining;
-  unsigned int seed = 7;
+  uint32_t seed = 7;
  size_t iter;
  iters = ((iters + num_histograms - 1) / num_histograms) * num_histograms;
  for (iter = 0; iter < iters; ++iter) {
--- a/C/brotli/enc/brotli_bit_stream.h
+++ b/C/brotli/enc/brotli_bit_stream.h
@@ -96,10 +96,6 @@ BROTLI_INTERNAL void BrotliStoreUncompressedMetaBlock(
    BROTLI_BOOL is_final_block, const uint8_t* input, size_t position,
    size_t mask, size_t len, size_t* storage_ix, uint8_t* storage);

-/* Stores an empty metadata meta-block and syncs to a byte boundary. */
-BROTLI_INTERNAL void BrotliStoreSyncMetaBlock(size_t* storage_ix,
-                                              uint8_t* storage);
-
 #if defined(__cplusplus) || defined(c_plusplus)
 }  /* extern "C" */
 #endif
--- a/C/brotli/enc/cluster_inc.h
+++ b/C/brotli/enc/cluster_inc.h
@@ -17,6 +17,8 @@ BROTLI_INTERNAL void FN(BrotliCompareAndPushToQueue)(
    size_t* num_pairs) CODE({
  BROTLI_BOOL is_good_pair = BROTLI_FALSE;
  HistogramPair p;
+  p.idx1 = p.idx2 = 0;
+  p.cost_diff = p.cost_combo = 0;
  if (idx1 == idx2) {
    return;
  }
--- a/C/brotli/enc/command.h
+++ b/C/brotli/enc/command.h
@@ -114,17 +114,19 @@ typedef struct Command {

 /* distance_code is e.g. 0 for same-as-last short code, or 16 for offset 1. */
 static BROTLI_INLINE void InitCommand(Command* self, size_t insertlen,
-    size_t copylen, size_t copylen_code, size_t distance_code) {
+    size_t copylen, int copylen_code_delta, size_t distance_code) {
+  /* Don't rely on signed int representation, use honest casts. */
+  uint32_t delta = (uint8_t)((int8_t)copylen_code_delta);
  self->insert_len_ = (uint32_t)insertlen;
-  self->copy_len_ = (uint32_t)(copylen | ((copylen_code ^ copylen) << 24));
+  self->copy_len_ = (uint32_t)(copylen | (delta << 24));
  /* The distance prefix and extra bits are stored in this Command as if
     npostfix and ndirect were 0, they are only recomputed later after the
     clustering if needed. */
  PrefixEncodeCopyDistance(
      distance_code, 0, 0, &self->dist_prefix_, &self->dist_extra_);
  GetLengthCode(
-      insertlen, copylen_code, TO_BROTLI_BOOL(self->dist_prefix_ == 0),
-      &self->cmd_prefix_);
+      insertlen, (size_t)((int)copylen + copylen_code_delta),
+      TO_BROTLI_BOOL(self->dist_prefix_ == 0), &self->cmd_prefix_);
 }

 static BROTLI_INLINE void InitInsertCommand(Command* self, size_t insertlen) {
@@ -167,7 +169,8 @@ static BROTLI_INLINE uint32_t CommandCopyLen(const Command* self) {
 }

 static BROTLI_INLINE uint32_t CommandCopyLenCode(const Command* self) {
-  return (self->copy_len_ & 0xFFFFFF) ^ (self->copy_len_ >> 24);
+  int32_t delta = (int8_t)((uint8_t)(self->copy_len_ >> 24));
+  return (uint32_t)((int32_t)(self->copy_len_ & 0xFFFFFF) + delta);
 }

 #if defined(__cplusplus) || defined(c_plusplus)
--- a/C/brotli/enc/find_match_length.h
+++ b/C/brotli/enc/find_match_length.h
@@ -17,7 +17,7 @@ extern "C" {
 #endif

 /* Separate implementation for little-endian 64-bit targets, for speed. */
-#if defined(__GNUC__) && defined(_LP64) && defined(IS_LITTLE_ENDIAN)
+#if defined(__GNUC__) && defined(_LP64) && defined(BROTLI_LITTLE_ENDIAN)

 static BROTLI_INLINE size_t FindMatchLengthWithLimit(const uint8_t* s1,
                                                     const uint8_t* s2,
@@ -25,13 +25,13 @@ static BROTLI_INLINE size_t FindMatchLengthWithLimit(const uint8_t* s1,
  size_t matched = 0;
  size_t limit2 = (limit >> 3) + 1;  /* + 1 is for pre-decrement in while */
  while (BROTLI_PREDICT_TRUE(--limit2)) {
-    if (BROTLI_PREDICT_FALSE(BROTLI_UNALIGNED_LOAD64(s2) ==
-                      BROTLI_UNALIGNED_LOAD64(s1 + matched))) {
+    if (BROTLI_PREDICT_FALSE(BROTLI_UNALIGNED_LOAD64LE(s2) ==
+                      BROTLI_UNALIGNED_LOAD64LE(s1 + matched))) {
      s2 += 8;
      matched += 8;
    } else {
-      uint64_t x =
-          BROTLI_UNALIGNED_LOAD64(s2) ^ BROTLI_UNALIGNED_LOAD64(s1 + matched);
+      uint64_t x = BROTLI_UNALIGNED_LOAD64LE(s2) ^
+          BROTLI_UNALIGNED_LOAD64LE(s1 + matched);
      size_t matching_bits = (size_t)__builtin_ctzll(x);
      matched += matching_bits >> 3;
      return matched;
--- a/C/brotli/enc/hash.h
+++ b/C/brotli/enc/hash.h
@@ -62,9 +62,9 @@ static const uint64_t kCutoffTransforms =

 typedef struct HasherSearchResult {
  size_t len;
-  size_t len_x_code; /* == len ^ len_code */
  size_t distance;
  score_t score;
+  int len_code_delta; /* == len_code - len */
 } HasherSearchResult;

 /* kHashMul32 multiplier has these properties:
@@ -173,27 +173,29 @@ static BROTLI_INLINE BROTLI_BOOL TestStaticDictionaryItem(
    backward = max_backward + dist + 1 +
        (transform_id << dictionary->size_bits_by_length[len]);
  }
+  if (backward >= BROTLI_MAX_DISTANCE) {
+    return BROTLI_FALSE;
+  }
  score = BackwardReferenceScore(matchlen, backward);
  if (score < out->score) {
    return BROTLI_FALSE;
  }
  out->len = matchlen;
-  out->len_x_code = len ^ matchlen;
+  out->len_code_delta = (int)len - (int)matchlen;
  out->distance = backward;
  out->score = score;
  return BROTLI_TRUE;
 }

-static BROTLI_INLINE BROTLI_BOOL SearchInStaticDictionary(
+static BROTLI_INLINE void SearchInStaticDictionary(
    const BrotliDictionary* dictionary, const uint16_t* dictionary_hash,
    HasherHandle handle, const uint8_t* data, size_t max_length,
    size_t max_backward, HasherSearchResult* out, BROTLI_BOOL shallow) {
  size_t key;
  size_t i;
-  BROTLI_BOOL is_match_found = BROTLI_FALSE;
  HasherCommon* self = GetHasherCommon(handle);
  if (self->dict_num_matches < (self->dict_num_lookups >> 7)) {
-    return BROTLI_FALSE;
+    return;
  }
  key = Hash14(data) << 1;
  for (i = 0; i < (shallow ? 1u : 2u); ++i, ++key) {
@@ -204,11 +206,9 @@ static BROTLI_INLINE BROTLI_BOOL SearchInStaticDictionary(
          dictionary, item, data, max_length, max_backward, out);
      if (item_matches) {
        self->dict_num_matches++;
-        is_match_found = BROTLI_TRUE;
      }
    }
  }
-  return is_match_found;
 }

 typedef struct BackwardMatch {
@@ -420,30 +420,6 @@ static BROTLI_INLINE void HasherSetup(MemoryManager* m, HasherHandle* handle,
  }
 }

-/* Custom LZ77 window. */
-static BROTLI_INLINE void HasherPrependCustomDictionary(
-    MemoryManager* m, HasherHandle* handle, BrotliEncoderParams* params,
-    const size_t size, const uint8_t* dict) {
-  size_t overlap;
-  size_t i;
-  HasherHandle self;
-  HasherSetup(m, handle, params, dict, 0, size, BROTLI_FALSE);
-  if (BROTLI_IS_OOM(m)) return;
-  self = *handle;
-  switch (GetHasherCommon(self)->params.type) {
-#define PREPEND_(N)                             \
-    case N:                                     \
-      overlap = (StoreLookaheadH ## N()) - 1;   \
-      for (i = 0; i + overlap < size; i++) {    \
-        StoreH ## N(self, dict, ~(size_t)0, i); \
-      }                                         \
-      break;
-    FOR_ALL_HASHERS(PREPEND_)
-#undef PREPEND_
-    default: break;
-  }
-}
-
 static BROTLI_INLINE void InitOrStitchToPreviousBlock(
    MemoryManager* m, HasherHandle* handle, const uint8_t* data, size_t mask,
    BrotliEncoderParams* params, size_t position, size_t input_size,
--- a/C/brotli/enc/hash_forgetful_chain_inc.h
+++ b/C/brotli/enc/hash_forgetful_chain_inc.h
@@ -152,24 +152,24 @@ static BROTLI_INLINE void FN(PrepareDistanceCache)(
   Does not look for matches longer than max_length.
   Does not look for matches further away than max_backward.
   Writes the best match into |out|.
-   Returns 1 when match is found, otherwise 0. */
-static BROTLI_INLINE BROTLI_BOOL FN(FindLongestMatch)(HasherHandle handle,
+   |out|->score is updated only if a better match is found. */
+static BROTLI_INLINE void FN(FindLongestMatch)(HasherHandle handle,
    const BrotliDictionary* dictionary, const uint16_t* dictionary_hash,
    const uint8_t* BROTLI_RESTRICT data, const size_t ring_buffer_mask,
    const int* BROTLI_RESTRICT distance_cache,
    const size_t cur_ix, const size_t max_length, const size_t max_backward,
-    HasherSearchResult* BROTLI_RESTRICT out) {
+    const size_t gap, HasherSearchResult* BROTLI_RESTRICT out) {
  HashForgetfulChain* self = FN(Self)(handle);
  const size_t cur_ix_masked = cur_ix & ring_buffer_mask;
-  BROTLI_BOOL is_match_found = BROTLI_FALSE;
  /* Don't accept a short copy from far away. */
+  score_t min_score = out->score;
  score_t best_score = out->score;
  size_t best_len = out->len;
  size_t i;
  const size_t key = FN(HashBytes)(&data[cur_ix_masked]);
  const uint8_t tiny_hash = (uint8_t)(key);
  out->len = 0;
-  out->len_x_code = 0;
+  out->len_code_delta = 0;
  /* Try last distance first. */
  for (i = 0; i < NUM_LAST_DISTANCES_TO_CHECK; ++i) {
    const size_t backward = (size_t)distance_cache[i];
@@ -194,7 +194,6 @@ static BROTLI_INLINE BROTLI_BOOL FN(FindLongestMatch)(HasherHandle handle,
            out->len = best_len;
            out->distance = backward;
            out->score = best_score;
-            is_match_found = BROTLI_TRUE;
          }
        }
      }
@@ -234,19 +233,17 @@ static BROTLI_INLINE BROTLI_BOOL FN(FindLongestMatch)(HasherHandle handle,
            out->len = best_len;
            out->distance = backward;
            out->score = best_score;
-            is_match_found = BROTLI_TRUE;
          }
        }
      }
    }
    FN(Store)(handle, data, ring_buffer_mask, cur_ix);
  }
-  if (!is_match_found) {
-    is_match_found = SearchInStaticDictionary(dictionary, dictionary_hash,
-        handle, &data[cur_ix_masked], max_length, max_backward, out,
+  if (out->score == min_score) {
+    SearchInStaticDictionary(dictionary, dictionary_hash,
+        handle, &data[cur_ix_masked], max_length, max_backward + gap, out,
        BROTLI_FALSE);
  }
-  return is_match_found;
 }

 #undef BANK_SIZE
--- a/C/brotli/enc/hash_longest_match64_inc.h
+++ b/C/brotli/enc/hash_longest_match64_inc.h
@@ -23,7 +23,7 @@ static BROTLI_INLINE size_t FN(StoreLookahead)(void) { return 8; }
 static BROTLI_INLINE uint32_t FN(HashBytes)(const uint8_t *data,
                                            const uint64_t mask,
                                            const int shift) {
-  const uint64_t h = (BROTLI_UNALIGNED_LOAD64(data) & mask) * kHashMul64Long;
+  const uint64_t h = (BROTLI_UNALIGNED_LOAD64LE(data) & mask) * kHashMul64Long;
  /* The higher bits contain more mixture from the multiplication,
     so we take our results from there. */
  return (uint32_t)(h >> shift);
@@ -156,25 +156,25 @@ static BROTLI_INLINE void FN(PrepareDistanceCache)(
   Does not look for matches longer than max_length.
   Does not look for matches further away than max_backward.
   Writes the best match into |out|.
-   Returns true when match is found, otherwise false. */
-static BROTLI_INLINE BROTLI_BOOL FN(FindLongestMatch)(HasherHandle handle,
+   |out|->score is updated only if a better match is found. */
+static BROTLI_INLINE void FN(FindLongestMatch)(HasherHandle handle,
    const BrotliDictionary* dictionary, const uint16_t* dictionary_hash,
    const uint8_t* BROTLI_RESTRICT data, const size_t ring_buffer_mask,
    const int* BROTLI_RESTRICT distance_cache, const size_t cur_ix,
-    const size_t max_length, const size_t max_backward,
+    const size_t max_length, const size_t max_backward, const size_t gap,
    HasherSearchResult* BROTLI_RESTRICT out) {
  HasherCommon* common = GetHasherCommon(handle);
  HashLongestMatch* self = FN(Self)(handle);
  uint16_t* num = FN(Num)(self);
  uint32_t* buckets = FN(Buckets)(self);
  const size_t cur_ix_masked = cur_ix & ring_buffer_mask;
-  BROTLI_BOOL is_match_found = BROTLI_FALSE;
  /* Don't accept a short copy from far away. */
+  score_t min_score = out->score;
  score_t best_score = out->score;
  size_t best_len = out->len;
  size_t i;
  out->len = 0;
-  out->len_x_code = 0;
+  out->len_code_delta = 0;
  /* Try last distance first. */
  for (i = 0; i < (size_t)common->params.num_last_distances_to_check; ++i) {
    const size_t backward = (size_t)distance_cache[i];
@@ -209,7 +209,6 @@ static BROTLI_INLINE BROTLI_BOOL FN(FindLongestMatch)(HasherHandle handle,
            out->len = best_len;
            out->distance = backward;
            out->score = best_score;
-            is_match_found = BROTLI_TRUE;
          }
        }
      }
@@ -250,7 +249,6 @@ static BROTLI_INLINE BROTLI_BOOL FN(FindLongestMatch)(HasherHandle handle,
            out->len = best_len;
            out->distance = backward;
            out->score = best_score;
-            is_match_found = BROTLI_TRUE;
          }
        }
      }
@@ -258,12 +256,11 @@ static BROTLI_INLINE BROTLI_BOOL FN(FindLongestMatch)(HasherHandle handle,
    bucket[num[key] & self->block_mask_] = (uint32_t)cur_ix;
    ++num[key];
  }
-  if (!is_match_found) {
-    is_match_found = SearchInStaticDictionary(dictionary, dictionary_hash,
-        handle, &data[cur_ix_masked], max_length, max_backward, out,
+  if (min_score == out->score) {
+    SearchInStaticDictionary(dictionary, dictionary_hash,
+        handle, &data[cur_ix_masked], max_length, max_backward + gap, out,
        BROTLI_FALSE);
  }
-  return is_match_found;
 }

 #undef HashLongestMatch
--- a/C/brotli/enc/hash_longest_match_inc.h
+++ b/C/brotli/enc/hash_longest_match_inc.h
@@ -149,25 +149,25 @@ static BROTLI_INLINE void FN(PrepareDistanceCache)(
   Does not look for matches longer than max_length.
   Does not look for matches further away than max_backward.
   Writes the best match into |out|.
-   Returns true when match is found, otherwise false. */
-static BROTLI_INLINE BROTLI_BOOL FN(FindLongestMatch)(HasherHandle handle,
+   |out|->score is updated only if a better match is found. */
+static BROTLI_INLINE void FN(FindLongestMatch)(HasherHandle handle,
    const BrotliDictionary* dictionary, const uint16_t* dictionary_hash,
    const uint8_t* BROTLI_RESTRICT data, const size_t ring_buffer_mask,
    const int* BROTLI_RESTRICT distance_cache, const size_t cur_ix,
-    const size_t max_length, const size_t max_backward,
+    const size_t max_length, const size_t max_backward, const size_t gap,
    HasherSearchResult* BROTLI_RESTRICT out) {
  HasherCommon* common = GetHasherCommon(handle);
  HashLongestMatch* self = FN(Self)(handle);
  uint16_t* num = FN(Num)(self);
  uint32_t* buckets = FN(Buckets)(self);
  const size_t cur_ix_masked = cur_ix & ring_buffer_mask;
-  BROTLI_BOOL is_match_found = BROTLI_FALSE;
  /* Don't accept a short copy from far away. */
+  score_t min_score = out->score;
  score_t best_score = out->score;
  size_t best_len = out->len;
  size_t i;
  out->len = 0;
-  out->len_x_code = 0;
+  out->len_code_delta = 0;
  /* Try last distance first. */
  for (i = 0; i < (size_t)common->params.num_last_distances_to_check; ++i) {
    const size_t backward = (size_t)distance_cache[i];
@@ -202,7 +202,6 @@ static BROTLI_INLINE BROTLI_BOOL FN(FindLongestMatch)(HasherHandle handle,
            out->len = best_len;
            out->distance = backward;
            out->score = best_score;
-            is_match_found = BROTLI_TRUE;
          }
        }
      }
@@ -242,7 +241,6 @@ static BROTLI_INLINE BROTLI_BOOL FN(FindLongestMatch)(HasherHandle handle,
            out->len = best_len;
            out->distance = backward;
            out->score = best_score;
-            is_match_found = BROTLI_TRUE;
          }
        }
      }
@@ -250,12 +248,11 @@ static BROTLI_INLINE BROTLI_BOOL FN(FindLongestMatch)(HasherHandle handle,
    bucket[num[key] & self->block_mask_] = (uint32_t)cur_ix;
    ++num[key];
  }
-  if (!is_match_found) {
-    is_match_found = SearchInStaticDictionary(dictionary, dictionary_hash,
-        handle, &data[cur_ix_masked], max_length, max_backward, out,
+  if (min_score == out->score) {
+    SearchInStaticDictionary(dictionary, dictionary_hash,
+        handle, &data[cur_ix_masked], max_length, max_backward + gap, out,
        BROTLI_FALSE);
  }
-  return is_match_found;
 }

 #undef HashLongestMatch
--- a/C/brotli/enc/hash_longest_match_quickly_inc.h
+++ b/C/brotli/enc/hash_longest_match_quickly_inc.h
@@ -22,7 +22,7 @@ static BROTLI_INLINE size_t FN(StoreLookahead)(void) { return 8; }
   the address in. The HashLongestMatch and HashLongestMatchQuickly
   classes have separate, different implementations of hashing. */
 static uint32_t FN(HashBytes)(const uint8_t* data) {
-  const uint64_t h = ((BROTLI_UNALIGNED_LOAD64(data) << (64 - 8 * HASH_LEN)) *
+  const uint64_t h = ((BROTLI_UNALIGNED_LOAD64LE(data) << (64 - 8 * HASH_LEN)) *
                      kHashMul64);
  /* The higher bits contain more mixture from the multiplication,
     so we take our results from there. */
@@ -123,24 +123,24 @@ static BROTLI_INLINE void FN(PrepareDistanceCache)(
   Does not look for matches longer than max_length.
   Does not look for matches further away than max_backward.
   Writes the best match into |out|.
-   Returns true if match is found, otherwise false. */
-static BROTLI_INLINE BROTLI_BOOL FN(FindLongestMatch)(
+   |out|->score is updated only if a better match is found. */
+static BROTLI_INLINE void FN(FindLongestMatch)(
    HasherHandle handle, const BrotliDictionary* dictionary,
    const uint16_t* dictionary_hash, const uint8_t* BROTLI_RESTRICT data,
    const size_t ring_buffer_mask, const int* BROTLI_RESTRICT distance_cache,
    const size_t cur_ix, const size_t max_length, const size_t max_backward,
-    HasherSearchResult* BROTLI_RESTRICT out) {
+    const size_t gap, HasherSearchResult* BROTLI_RESTRICT out) {
  HashLongestMatchQuickly* self = FN(Self)(handle);
  const size_t best_len_in = out->len;
  const size_t cur_ix_masked = cur_ix & ring_buffer_mask;
  const uint32_t key = FN(HashBytes)(&data[cur_ix_masked]);
  int compare_char = data[cur_ix_masked + best_len_in];
+  score_t min_score = out->score;
  score_t best_score = out->score;
  size_t best_len = best_len_in;
  size_t cached_backward = (size_t)distance_cache[0];
  size_t prev_ix = cur_ix - cached_backward;
-  BROTLI_BOOL is_match_found = BROTLI_FALSE;
-  out->len_x_code = 0;
+  out->len_code_delta = 0;
  if (prev_ix < cur_ix) {
    prev_ix &= (uint32_t)ring_buffer_mask;
    if (compare_char == data[prev_ix + best_len]) {
@@ -148,17 +148,18 @@ static BROTLI_INLINE BROTLI_BOOL FN(FindLongestMatch)(
                                            &data[cur_ix_masked],
                                            max_length);
      if (len >= 4) {
-        best_score = BackwardReferenceScoreUsingLastDistance(len);
-        best_len = len;
-        out->len = len;
-        out->distance = cached_backward;
-        out->score = best_score;
-        compare_char = data[cur_ix_masked + best_len];
-        if (BUCKET_SWEEP == 1) {
-          self->buckets_[key] = (uint32_t)cur_ix;
-          return BROTLI_TRUE;
-        } else {
-          is_match_found = BROTLI_TRUE;
+        const score_t score = BackwardReferenceScoreUsingLastDistance(len);
+        if (best_score < score) {
+          best_score = score;
+          best_len = len;
+          out->len = len;
+          out->distance = cached_backward;
+          out->score = best_score;
+          compare_char = data[cur_ix_masked + best_len];
+          if (BUCKET_SWEEP == 1) {
+            self->buckets_[key] = (uint32_t)cur_ix;
+            return;
+          }
        }
      }
    }
@@ -172,19 +173,22 @@ static BROTLI_INLINE BROTLI_BOOL FN(FindLongestMatch)(
    backward = cur_ix - prev_ix;
    prev_ix &= (uint32_t)ring_buffer_mask;
    if (compare_char != data[prev_ix + best_len_in]) {
-      return BROTLI_FALSE;
+      return;
    }
    if (BROTLI_PREDICT_FALSE(backward == 0 || backward > max_backward)) {
-      return BROTLI_FALSE;
+      return;
    }
    len = FindMatchLengthWithLimit(&data[prev_ix],
                                   &data[cur_ix_masked],
                                   max_length);
    if (len >= 4) {
-      out->len = len;
-      out->distance = backward;
-      out->score = BackwardReferenceScore(len, backward);
-      return BROTLI_TRUE;
+      const score_t score = BackwardReferenceScore(len, backward);
+      if (best_score < score) {
+        out->len = len;
+        out->distance = backward;
+        out->score = score;
+        return;
+      }
    }
  } else {
    uint32_t *bucket = self->buckets_ + key;
@@ -212,18 +216,16 @@ static BROTLI_INLINE BROTLI_BOOL FN(FindLongestMatch)(
          out->distance = backward;
          out->score = score;
          compare_char = data[cur_ix_masked + best_len];
-          is_match_found = BROTLI_TRUE;
        }
      }
    }
  }
-  if (USE_DICTIONARY && !is_match_found) {
-    is_match_found = SearchInStaticDictionary(dictionary, dictionary_hash,
-        handle, &data[cur_ix_masked], max_length, max_backward, out,
+  if (USE_DICTIONARY && min_score == out->score) {
+    SearchInStaticDictionary(dictionary, dictionary_hash,
+        handle, &data[cur_ix_masked], max_length, max_backward + gap, out,
        BROTLI_TRUE);
  }
  self->buckets_[key + ((cur_ix >> 3) % BUCKET_SWEEP)] = (uint32_t)cur_ix;
-  return is_match_found;
 }

 #undef HASH_MAP_SIZE
--- a/C/brotli/enc/hash_to_binary_tree_inc.h
+++ b/C/brotli/enc/hash_to_binary_tree_inc.h
@@ -19,8 +19,10 @@

 #define BUCKET_SIZE (1 << BUCKET_BITS)

-static size_t FN(HashTypeLength)(void) { return 4; }
-static size_t FN(StoreLookahead)(void) { return MAX_TREE_COMP_LENGTH; }
+static BROTLI_INLINE size_t FN(HashTypeLength)(void) { return 4; }
+static BROTLI_INLINE size_t FN(StoreLookahead)(void) {
+  return MAX_TREE_COMP_LENGTH;
+}

 static uint32_t FN(HashBytes)(const uint8_t *data) {
  uint32_t h = BROTLI_UNALIGNED_LOAD32(data) * kHashMul32;
@@ -199,7 +201,7 @@ static BROTLI_INLINE BackwardMatch* FN(StoreAndFindMatches)(
 static BROTLI_INLINE size_t FN(FindAllMatches)(HasherHandle handle,
    const BrotliDictionary* dictionary, const uint8_t* data,
    const size_t ring_buffer_mask, const size_t cur_ix,
-    const size_t max_length, const size_t max_backward,
+    const size_t max_length, const size_t max_backward, const size_t gap,
    const BrotliEncoderParams* params, BackwardMatch* matches) {
  BackwardMatch* const orig_matches = matches;
  const size_t cur_ix_masked = cur_ix & ring_buffer_mask;
@@ -248,8 +250,10 @@ static BROTLI_INLINE size_t FN(FindAllMatches)(HasherHandle handle,
      for (l = minlen; l <= maxlen; ++l) {
        uint32_t dict_id = dict_matches[l];
        if (dict_id < kInvalidMatch) {
-          InitDictionaryBackwardMatch(matches++,
-              max_backward + (dict_id >> 5) + 1, l, dict_id & 31);
+          size_t distance = max_backward + gap + (dict_id >> 5) + 1;
+          if (distance < BROTLI_MAX_DISTANCE) {
+            InitDictionaryBackwardMatch(matches++, distance, l, dict_id & 31);
+          }
        }
      }
    }
--- a/C/brotli/enc/memory.h
+++ b/C/brotli/enc/memory.h
@@ -40,7 +40,7 @@ BROTLI_INTERNAL void BrotliInitMemoryManager(

 BROTLI_INTERNAL void* BrotliAllocate(MemoryManager* m, size_t n);
 #define BROTLI_ALLOC(M, T, N)                               \
-  ((N) ? ((T*)BrotliAllocate((M), (N) * sizeof(T))) : NULL)
+  ((N) > 0 ? ((T*)BrotliAllocate((M), (N) * sizeof(T))) : NULL)

 BROTLI_INTERNAL void BrotliFree(MemoryManager* m, void* p);
 #define BROTLI_FREE(M, P) { \
--- a/C/brotli/enc/port.h
+++ b/C/brotli/enc/port.h
@@ -26,36 +26,37 @@
 #define __LITTLE_ENDIAN LITTLE_ENDIAN
 #endif

-/* define the macro IS_LITTLE_ENDIAN
+/* define the macro BROTLI_LITTLE_ENDIAN
   using the above endian definitions from endian.h if
   endian.h was included */
 #ifdef __BYTE_ORDER
 #if __BYTE_ORDER == __LITTLE_ENDIAN
-#define IS_LITTLE_ENDIAN
+#define BROTLI_LITTLE_ENDIAN
 #endif

 #else

 #if defined(__LITTLE_ENDIAN__)
-#define IS_LITTLE_ENDIAN
+#define BROTLI_LITTLE_ENDIAN
 #endif
 #endif  /* __BYTE_ORDER */

 #if defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
-#define IS_LITTLE_ENDIAN
+#define BROTLI_LITTLE_ENDIAN
 #endif

 /* Enable little-endian optimization for x64 architecture on Windows. */
 #if (defined(_WIN32) || defined(_WIN64)) && defined(_M_X64)
-#define IS_LITTLE_ENDIAN
+#define BROTLI_LITTLE_ENDIAN
 #endif

 /* Portable handling of unaligned loads, stores, and copies.
   On some platforms, like ARM, the copy functions can be more efficient
   then a load and a store. */

-#if defined(ARCH_PIII) || \
-  defined(ARCH_ATHLON) || defined(ARCH_K8) || defined(_ARCH_PPC)
+#if defined(BROTLI_LITTLE_ENDIAN) && (\
+    defined(ARCH_PIII) || defined(ARCH_ATHLON) || \
+    defined(ARCH_K8) || defined(_ARCH_PPC))

 /* x86 and x86-64 can perform unaligned loads/stores directly;
   modern PowerPC hardware can also do unaligned integer loads and stores;
@@ -63,14 +64,12 @@
 */

 #define BROTLI_UNALIGNED_LOAD32(_p) (*(const uint32_t *)(_p))
-#define BROTLI_UNALIGNED_LOAD64(_p) (*(const uint64_t *)(_p))
+#define BROTLI_UNALIGNED_LOAD64LE(_p) (*(const uint64_t *)(_p))

-#define BROTLI_UNALIGNED_STORE32(_p, _val) \
-  (*(uint32_t *)(_p) = (_val))
-#define BROTLI_UNALIGNED_STORE64(_p, _val) \
+#define BROTLI_UNALIGNED_STORE64LE(_p, _val) \
  (*(uint64_t *)(_p) = (_val))

-#elif defined(__arm__) && \
+#elif defined(BROTLI_LITTLE_ENDIAN) && defined(__arm__) && \
  !defined(__ARM_ARCH_5__) && \
  !defined(__ARM_ARCH_5T__) && \
  !defined(__ARM_ARCH_5TE__) && \
@@ -88,16 +87,14 @@
   slowly (trip through kernel mode). */

 #define BROTLI_UNALIGNED_LOAD32(_p) (*(const uint32_t *)(_p))
-#define BROTLI_UNALIGNED_STORE32(_p, _val) \
-  (*(uint32_t *)(_p) = (_val))

-static BROTLI_INLINE uint64_t BROTLI_UNALIGNED_LOAD64(const void *p) {
+static BROTLI_INLINE uint64_t BROTLI_UNALIGNED_LOAD64LE(const void *p) {
  uint64_t t;
  memcpy(&t, p, sizeof t);
  return t;
 }

-static BROTLI_INLINE void BROTLI_UNALIGNED_STORE64(void *p, uint64_t v) {
+static BROTLI_INLINE void BROTLI_UNALIGNED_STORE64LE(void *p, uint64_t v) {
  memcpy(p, &v, sizeof v);
 }

@@ -112,20 +109,47 @@ static BROTLI_INLINE uint32_t BROTLI_UNALIGNED_LOAD32(const void *p) {
  return t;
 }

-static BROTLI_INLINE uint64_t BROTLI_UNALIGNED_LOAD64(const void *p) {
+#if defined(BROTLI_LITTLE_ENDIAN)
+
+static BROTLI_INLINE uint64_t BROTLI_UNALIGNED_LOAD64LE(const void *p) {
  uint64_t t;
  memcpy(&t, p, sizeof t);
  return t;
 }

-static BROTLI_INLINE void BROTLI_UNALIGNED_STORE32(void *p, uint32_t v) {
+static BROTLI_INLINE void BROTLI_UNALIGNED_STORE64LE(void *p, uint64_t v) {
  memcpy(p, &v, sizeof v);
 }

-static BROTLI_INLINE void BROTLI_UNALIGNED_STORE64(void *p, uint64_t v) {
-  memcpy(p, &v, sizeof v);
+#else  /* BROTLI_LITTLE_ENDIAN */
+
+static BROTLI_INLINE uint64_t BROTLI_UNALIGNED_LOAD64LE(const void *p) {
+  const uint8_t* in = (const uint8_t*)p;
+  uint64_t value = (uint64_t)(in[0]);
+  value |= (uint64_t)(in[1]) << 8;
+  value |= (uint64_t)(in[2]) << 16;
+  value |= (uint64_t)(in[3]) << 24;
+  value |= (uint64_t)(in[4]) << 32;
+  value |= (uint64_t)(in[5]) << 40;
+  value |= (uint64_t)(in[6]) << 48;
+  value |= (uint64_t)(in[7]) << 56;
+  return value;
 }

+static BROTLI_INLINE void BROTLI_UNALIGNED_STORE64LE(void *p, uint64_t v) {
+  uint8_t* out = (uint8_t*)p;
+  out[0] = (uint8_t)v;
+  out[1] = (uint8_t)(v >> 8);
+  out[2] = (uint8_t)(v >> 16);
+  out[3] = (uint8_t)(v >> 24);
+  out[4] = (uint8_t)(v >> 32);
+  out[5] = (uint8_t)(v >> 40);
+  out[6] = (uint8_t)(v >> 48);
+  out[7] = (uint8_t)(v >> 56);
+}
+
+#endif  /* BROTLI_LITTLE_ENDIAN */
+
 #endif

 #define TEMPLATE_(T)                                                           \
--- a/C/brotli/enc/write_bits.h
+++ b/C/brotli/enc/write_bits.h
@@ -40,7 +40,7 @@ static BROTLI_INLINE void BrotliWriteBits(size_t n_bits,
                                          uint64_t bits,
                                          size_t * BROTLI_RESTRICT pos,
                                          uint8_t * BROTLI_RESTRICT array) {
-#ifdef IS_LITTLE_ENDIAN
+#ifdef BROTLI_LITTLE_ENDIAN
  /* This branch of the code can write up to 56 bits at a time,
     7 bits are lost by being perhaps already in *p and at least
     1 bit is needed to initialize the bit-stream ahead (i.e. if 7
@@ -54,7 +54,7 @@ static BROTLI_INLINE void BrotliWriteBits(size_t n_bits,
  assert((bits >> n_bits) == 0);
  assert(n_bits <= 56);
  v |= bits << (*pos & 7);
-  BROTLI_UNALIGNED_STORE64(p, v);  /* Set some bits. */
+  BROTLI_UNALIGNED_STORE64LE(p, v);  /* Set some bits. */
  *pos += n_bits;
 #else
  /* implicit & 0xff is assumed for uint8_t arithmetics */