extbrotli 0.0.1.PROTOTYPE

data/contrib/brotli/enc/entropy_encode.h

@@ -0,0 +1,88 @@
+// Copyright 2010 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Entropy encoding (Huffman) utilities.
+
+#ifndef BROTLI_ENC_ENTROPY_ENCODE_H_
+#define BROTLI_ENC_ENTROPY_ENCODE_H_
+
+#include <stdint.h>
+#include <string.h>
+#include <vector>
+#include "./histogram.h"
+#include "./prefix.h"
+
+namespace brotli {
+
+// This function will create a Huffman tree.
+//
+// The (data,length) contains the population counts.
+// The tree_limit is the maximum bit depth of the Huffman codes.
+//
+// The depth contains the tree, i.e., how many bits are used for
+// the symbol.
+//
+// See http://en.wikipedia.org/wiki/Huffman_coding
+void CreateHuffmanTree(const int *data,
+                       const int length,
+                       const int tree_limit,
+                       uint8_t *depth);
+
+// Change the population counts in a way that the consequent
+// Huffman tree compression, especially its rle-part will be more
+// likely to compress this data more efficiently.
+//
+// length contains the size of the histogram.
+// counts contains the population counts.
+int OptimizeHuffmanCountsForRle(int length, int* counts);
+
+// Write a huffman tree from bit depths into the bitstream representation
+// of a Huffman tree. The generated Huffman tree is to be compressed once
+// more using a Huffman tree
+void WriteHuffmanTree(const uint8_t* depth,
+                      uint32_t num,
+                      std::vector<uint8_t> *tree,
+                      std::vector<uint8_t> *extra_bits_data);
+
+// Get the actual bit values for a tree of bit depths.
+void ConvertBitDepthsToSymbols(const uint8_t *depth, int len, uint16_t *bits);
+
+template<int kSize>
+struct EntropyCode {
+  // How many bits for symbol.
+  uint8_t depth_[kSize];
+  // Actual bits used to represent the symbol.
+  uint16_t bits_[kSize];
+  // How many non-zero depth.
+  int count_;
+  // First four symbols with non-zero depth.
+  int symbols_[4];
+};
+
+static const int kCodeLengthCodes = 18;
+
+// Literal entropy code.
+typedef EntropyCode<256> EntropyCodeLiteral;
+// Prefix entropy codes.
+typedef EntropyCode<kNumCommandPrefixes> EntropyCodeCommand;
+typedef EntropyCode<kNumDistancePrefixes> EntropyCodeDistance;
+typedef EntropyCode<kNumBlockLenPrefixes> EntropyCodeBlockLength;
+// Context map entropy code, 256 Huffman tree indexes + 16 run length codes.
+typedef EntropyCode<272> EntropyCodeContextMap;
+// Block type entropy code, 256 block types + 2 special symbols.
+typedef EntropyCode<258> EntropyCodeBlockType;
+
+}  // namespace brotli
+
+#endif  // BROTLI_ENC_ENTROPY_ENCODE_H_

data/contrib/brotli/enc/fast_log.h

@@ -0,0 +1,179 @@
+// Copyright 2013 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Utilities for fast computation of logarithms.
+
+#ifndef BROTLI_ENC_FAST_LOG_H_
+#define BROTLI_ENC_FAST_LOG_H_
+
+#include <assert.h>
+#include <math.h>
+#include <stdint.h>
+
+namespace brotli {
+
+// Return floor(log2(n)) for positive integer n.  Returns -1 iff n == 0.
+inline int Log2Floor(uint32_t n) {
+#if defined(__clang__) ||                       \
+  (defined(__GNUC__) &&                                         \
+   ((__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || __GNUC__ >= 4))
+  return n == 0 ? -1 : 31 ^ __builtin_clz(n);
+#else
+  if (n == 0)
+    return -1;
+  int log = 0;
+  uint32_t value = n;
+  for (int i = 4; i >= 0; --i) {
+    int shift = (1 << i);
+    uint32_t x = value >> shift;
+    if (x != 0) {
+      value = x;
+      log += shift;
+    }
+  }
+  assert(value == 1);
+  return log;
+#endif
+}
+
+static inline int Log2FloorNonZero(uint32_t n) {
+#ifdef __GNUC__
+  return 31 ^ __builtin_clz(n);
+#else
+  unsigned int result = 0;
+  while (n >>= 1) result++;
+  return result;
+#endif
+}
+
+// Return ceiling(log2(n)) for positive integer n.  Returns -1 iff n == 0.
+inline int Log2Ceiling(uint32_t n) {
+  int floor = Log2Floor(n);
+  if (n == (n &~ (n - 1)))              // zero or a power of two
+    return floor;
+  else
+    return floor + 1;
+}
+
+// A lookup table for small values of log2(int) to be used in entropy
+// computation.
+//
+// ", ".join(["%.16ff" % x for x in [0.0]+[log2(x) for x in range(1, 256)]])
+static const float kLog2Table[] = {
+  0.0000000000000000f, 0.0000000000000000f, 1.0000000000000000f,
+  1.5849625007211563f, 2.0000000000000000f, 2.3219280948873622f,
+  2.5849625007211561f, 2.8073549220576042f, 3.0000000000000000f,
+  3.1699250014423126f, 3.3219280948873626f, 3.4594316186372978f,
+  3.5849625007211565f, 3.7004397181410922f, 3.8073549220576037f,
+  3.9068905956085187f, 4.0000000000000000f, 4.0874628412503400f,
+  4.1699250014423122f, 4.2479275134435852f, 4.3219280948873626f,
+  4.3923174227787607f, 4.4594316186372973f, 4.5235619560570131f,
+  4.5849625007211570f, 4.6438561897747244f, 4.7004397181410926f,
+  4.7548875021634691f, 4.8073549220576037f, 4.8579809951275728f,
+  4.9068905956085187f, 4.9541963103868758f, 5.0000000000000000f,
+  5.0443941193584534f, 5.0874628412503400f, 5.1292830169449664f,
+  5.1699250014423122f, 5.2094533656289501f, 5.2479275134435852f,
+  5.2854022188622487f, 5.3219280948873626f, 5.3575520046180838f,
+  5.3923174227787607f, 5.4262647547020979f, 5.4594316186372973f,
+  5.4918530963296748f, 5.5235619560570131f, 5.5545888516776376f,
+  5.5849625007211570f, 5.6147098441152083f, 5.6438561897747244f,
+  5.6724253419714961f, 5.7004397181410926f, 5.7279204545631996f,
+  5.7548875021634691f, 5.7813597135246599f, 5.8073549220576046f,
+  5.8328900141647422f, 5.8579809951275719f, 5.8826430493618416f,
+  5.9068905956085187f, 5.9307373375628867f, 5.9541963103868758f,
+  5.9772799234999168f, 6.0000000000000000f, 6.0223678130284544f,
+  6.0443941193584534f, 6.0660891904577721f, 6.0874628412503400f,
+  6.1085244567781700f, 6.1292830169449672f, 6.1497471195046822f,
+  6.1699250014423122f, 6.1898245588800176f, 6.2094533656289510f,
+  6.2288186904958804f, 6.2479275134435861f, 6.2667865406949019f,
+  6.2854022188622487f, 6.3037807481771031f, 6.3219280948873617f,
+  6.3398500028846252f, 6.3575520046180847f, 6.3750394313469254f,
+  6.3923174227787598f, 6.4093909361377026f, 6.4262647547020979f,
+  6.4429434958487288f, 6.4594316186372982f, 6.4757334309663976f,
+  6.4918530963296748f, 6.5077946401986964f, 6.5235619560570131f,
+  6.5391588111080319f, 6.5545888516776376f, 6.5698556083309478f,
+  6.5849625007211561f, 6.5999128421871278f, 6.6147098441152092f,
+  6.6293566200796095f, 6.6438561897747253f, 6.6582114827517955f,
+  6.6724253419714952f, 6.6865005271832185f, 6.7004397181410917f,
+  6.7142455176661224f, 6.7279204545631988f, 6.7414669864011465f,
+  6.7548875021634691f, 6.7681843247769260f, 6.7813597135246599f,
+  6.7944158663501062f, 6.8073549220576037f, 6.8201789624151887f,
+  6.8328900141647422f, 6.8454900509443757f, 6.8579809951275719f,
+  6.8703647195834048f, 6.8826430493618416f, 6.8948177633079437f,
+  6.9068905956085187f, 6.9188632372745955f, 6.9307373375628867f,
+  6.9425145053392399f, 6.9541963103868758f, 6.9657842846620879f,
+  6.9772799234999168f, 6.9886846867721664f, 7.0000000000000000f,
+  7.0112272554232540f, 7.0223678130284544f, 7.0334230015374501f,
+  7.0443941193584534f, 7.0552824355011898f, 7.0660891904577721f,
+  7.0768155970508317f, 7.0874628412503400f, 7.0980320829605272f,
+  7.1085244567781700f, 7.1189410727235076f, 7.1292830169449664f,
+  7.1395513523987937f, 7.1497471195046822f, 7.1598713367783891f,
+  7.1699250014423130f, 7.1799090900149345f, 7.1898245588800176f,
+  7.1996723448363644f, 7.2094533656289492f, 7.2191685204621621f,
+  7.2288186904958804f, 7.2384047393250794f, 7.2479275134435861f,
+  7.2573878426926521f, 7.2667865406949019f, 7.2761244052742384f,
+  7.2854022188622487f, 7.2946207488916270f, 7.3037807481771031f,
+  7.3128829552843557f, 7.3219280948873617f, 7.3309168781146177f,
+  7.3398500028846243f, 7.3487281542310781f, 7.3575520046180847f,
+  7.3663222142458151f, 7.3750394313469254f, 7.3837042924740528f,
+  7.3923174227787607f, 7.4008794362821844f, 7.4093909361377026f,
+  7.4178525148858991f, 7.4262647547020979f, 7.4346282276367255f,
+  7.4429434958487288f, 7.4512111118323299f, 7.4594316186372973f,
+  7.4676055500829976f, 7.4757334309663976f, 7.4838157772642564f,
+  7.4918530963296748f, 7.4998458870832057f, 7.5077946401986964f,
+  7.5156998382840436f, 7.5235619560570131f, 7.5313814605163119f,
+  7.5391588111080319f, 7.5468944598876373f, 7.5545888516776376f,
+  7.5622424242210728f, 7.5698556083309478f, 7.5774288280357487f,
+  7.5849625007211561f, 7.5924570372680806f, 7.5999128421871278f,
+  7.6073303137496113f, 7.6147098441152075f, 7.6220518194563764f,
+  7.6293566200796095f, 7.6366246205436488f, 7.6438561897747244f,
+  7.6510516911789290f, 7.6582114827517955f, 7.6653359171851765f,
+  7.6724253419714952f, 7.6794800995054464f, 7.6865005271832185f,
+  7.6934869574993252f, 7.7004397181410926f, 7.7073591320808825f,
+  7.7142455176661224f, 7.7210991887071856f, 7.7279204545631996f,
+  7.7347096202258392f, 7.7414669864011465f, 7.7481928495894596f,
+  7.7548875021634691f, 7.7615512324444795f, 7.7681843247769260f,
+  7.7747870596011737f, 7.7813597135246608f, 7.7879025593914317f,
+  7.7944158663501062f, 7.8008998999203047f, 7.8073549220576037f,
+  7.8137811912170374f, 7.8201789624151887f, 7.8265484872909159f,
+  7.8328900141647422f, 7.8392037880969445f, 7.8454900509443757f,
+  7.8517490414160571f, 7.8579809951275719f, 7.8641861446542798f,
+  7.8703647195834048f, 7.8765169465650002f, 7.8826430493618425f,
+  7.8887432488982601f, 7.8948177633079446f, 7.9008668079807496f,
+  7.9068905956085187f, 7.9128893362299619f, 7.9188632372745955f,
+  7.9248125036057813f, 7.9307373375628867f, 7.9366379390025719f,
+  7.9425145053392399f, 7.9483672315846778f, 7.9541963103868758f,
+  7.9600019320680806f, 7.9657842846620870f, 7.9715435539507720f,
+  7.9772799234999168f, 7.9829935746943104f, 7.9886846867721664f,
+  7.9943534368588578f
+};
+
+// Faster logarithm for small integers, with the property of log2(0) == 0.
+static inline double FastLog2(int v) {
+  if (v < (int)(sizeof(kLog2Table) / sizeof(kLog2Table[0]))) {
+    return kLog2Table[v];
+  }
+#if defined(_MSC_VER) && _MSC_VER <= 1600
+  // Visual Studio 2010 does not have the log2() function defined, so we use
+  // log() and a multiplication instead.
+  static const double kLog2Inv = 1.4426950408889634f;
+  return log(static_cast<double>(v)) * kLog2Inv;
+#else
+  return log2(static_cast<double>(v));
+#endif
+}
+
+}  // namespace brotli
+
+#endif  // BROTLI_ENC_FAST_LOG_H_

data/contrib/brotli/enc/find_match_length.h

@@ -0,0 +1,87 @@
+// Copyright 2010 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Function to find maximal matching prefixes of strings.
+
+#ifndef BROTLI_ENC_FIND_MATCH_LENGTH_H_
+#define BROTLI_ENC_FIND_MATCH_LENGTH_H_
+
+#include <stdint.h>
+
+#include <stddef.h>
+
+#include "./port.h"
+
+namespace brotli {
+
+// Separate implementation for little-endian 64-bit targets, for speed.
+#if defined(__GNUC__) && defined(_LP64) && defined(IS_LITTLE_ENDIAN)
+
+static inline int FindMatchLengthWithLimit(const uint8_t* s1,
+                                           const uint8_t* s2,
+                                           size_t limit) {
+  int matched = 0;
+  size_t limit2 = (limit >> 3) + 1;  // + 1 is for pre-decrement in while
+  while (PREDICT_TRUE(--limit2)) {
+    if (PREDICT_FALSE(BROTLI_UNALIGNED_LOAD64(s2) ==
+                      BROTLI_UNALIGNED_LOAD64(s1 + matched))) {
+      s2 += 8;
+      matched += 8;
+    } else {
+      uint64_t x =
+          BROTLI_UNALIGNED_LOAD64(s2) ^ BROTLI_UNALIGNED_LOAD64(s1 + matched);
+      int matching_bits =  __builtin_ctzll(x);
+      matched += matching_bits >> 3;
+      return matched;
+    }
+  }
+  limit = (limit & 7) + 1;  // + 1 is for pre-decrement in while
+  while (--limit) {
+    if (PREDICT_TRUE(s1[matched] == *s2)) {
+      ++s2;
+      ++matched;
+    } else {
+      return matched;
+    }
+  }
+  return matched;
+}
+#else
+static inline int FindMatchLengthWithLimit(const uint8_t* s1,
+                                           const uint8_t* s2,
+                                           size_t limit) {
+  int matched = 0;
+  const uint8_t* s2_limit = s2 + limit;
+  const uint8_t* s2_ptr = s2;
+  // Find out how long the match is. We loop over the data 32 bits at a
+  // time until we find a 32-bit block that doesn't match; then we find
+  // the first non-matching bit and use that to calculate the total
+  // length of the match.
+  while (s2_ptr <= s2_limit - 4 &&
+         BROTLI_UNALIGNED_LOAD32(s2_ptr) ==
+         BROTLI_UNALIGNED_LOAD32(s1 + matched)) {
+    s2_ptr += 4;
+    matched += 4;
+  }
+  while ((s2_ptr < s2_limit) && (s1[matched] == *s2_ptr)) {
+    ++s2_ptr;
+    ++matched;
+  }
+  return matched;
+}
+#endif
+
+}  // namespace brotli
+
+#endif  // BROTLI_ENC_FIND_MATCH_LENGTH_H_

data/contrib/brotli/enc/hash.h

@@ -0,0 +1,686 @@
+// Copyright 2010 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// A (forgetful) hash table to the data seen by the compressor, to
+// help create backward references to previous data.
+
+#ifndef BROTLI_ENC_HASH_H_
+#define BROTLI_ENC_HASH_H_
+
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+#include <sys/types.h>
+#include <algorithm>
+#include <cstdlib>
+#include <memory>
+#include <string>
+
+#include "./dictionary_hash.h"
+#include "./fast_log.h"
+#include "./find_match_length.h"
+#include "./port.h"
+#include "./prefix.h"
+#include "./static_dict.h"
+#include "./transform.h"
+
+namespace brotli {
+
+static const int 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
+};
+
+static const int kCutoffTransformsCount = 10;
+static const int kCutoffTransforms[] = {0, 12, 27, 23, 42, 63, 56, 48, 59, 64};
+
+// kHashMul32 multiplier has these properties:
+// * The multiplier must be odd. Otherwise we may lose the highest bit.
+// * No long streaks of 1s or 0s.
+// * There is no effort to ensure that it is a prime, the oddity is enough
+//   for this use.
+// * The number has been tuned heuristically against compression benchmarks.
+static const uint32_t kHashMul32 = 0x1e35a7bd;
+
+template<int kShiftBits>
+inline uint32_t Hash(const uint8_t *data) {
+  uint32_t h = BROTLI_UNALIGNED_LOAD32(data) * kHashMul32;
+  // The higher bits contain more mixture from the multiplication,
+  // so we take our results from there.
+  return h >> (32 - kShiftBits);
+}
+
+// Usually, we always choose the longest backward reference. This function
+// allows for the exception of that rule.
+//
+// If we choose a backward reference that is further away, it will
+// usually be coded with more bits. We approximate this by assuming
+// log2(distance). If the distance can be expressed in terms of the
+// last four distances, we use some heuristic constants to estimate
+// the bits cost. For the first up to four literals we use the bit
+// cost of the literals from the literal cost model, after that we
+// use the average bit cost of the cost model.
+//
+// This function is used to sometimes discard a longer backward reference
+// when it is not much longer and the bit cost for encoding it is more
+// than the saved literals.
+inline double BackwardReferenceScore(int copy_length,
+                                     int backward_reference_offset) {
+  return 5.4 * copy_length - 1.20 * Log2Floor(backward_reference_offset);
+}
+
+inline double BackwardReferenceScoreUsingLastDistance(int copy_length,
+                                                      int distance_short_code) {
+  static const double kDistanceShortCodeBitCost[16] = {
+    -0.6, 0.95, 1.17, 1.27,
+    0.93, 0.93, 0.96, 0.96, 0.99, 0.99,
+    1.05, 1.05, 1.15, 1.15, 1.25, 1.25
+  };
+  return 5.4 * copy_length - kDistanceShortCodeBitCost[distance_short_code];
+}
+
+struct BackwardMatch {
+  BackwardMatch() : distance(0), length_and_code(0) {}
+
+  BackwardMatch(int dist, int len)
+      : distance(dist), length_and_code((len << 5)) {}
+
+  BackwardMatch(int dist, int len, int len_code)
+      : distance(dist),
+        length_and_code((len << 5) | (len == len_code ? 0 : len_code)) {}
+
+  int length() const {
+    return length_and_code >> 5;
+  }
+  int length_code() const {
+    int code = length_and_code & 31;
+    return code ? code : length();
+  }
+
+  int distance;
+  int length_and_code;
+};
+
+// A (forgetful) hash table to the data seen by the compressor, to
+// help create backward references to previous data.
+//
+// This is a hash map of fixed size (kBucketSize). Starting from the
+// given index, kBucketSweep buckets are used to store values of a key.
+template <int kBucketBits, int kBucketSweep, bool kUseDictionary>
+class HashLongestMatchQuickly {
+ public:
+  HashLongestMatchQuickly() {
+    Reset();
+  }
+  void Reset() {
+    // It is not strictly necessary to fill this buffer here, but
+    // not filling will make the results of the compression stochastic
+    // (but correct). This is because random data would cause the
+    // system to find accidentally good backward references here and there.
+    memset(&buckets_[0], 0, sizeof(buckets_));
+    num_dict_lookups_ = 0;
+    num_dict_matches_ = 0;
+  }
+  // Look at 4 bytes at data.
+  // Compute a hash from these, and store the value somewhere within
+  // [ix .. ix+3].
+  inline void Store(const uint8_t *data, const int ix) {
+    const uint32_t key = HashBytes(data);
+    // Wiggle the value with the bucket sweep range.
+    const uint32_t off = (static_cast<uint32_t>(ix) >> 3) % kBucketSweep;
+    buckets_[key + off] = ix;
+  }
+
+  // Store hashes for a range of data.
+  void StoreHashes(const uint8_t *data, size_t len, int startix, int mask) {
+    for (int p = 0; p < len; ++p) {
+      Store(&data[p & mask], startix + p);
+    }
+  }
+
+  // Find a longest backward match of &ring_buffer[cur_ix & ring_buffer_mask]
+  // up to the length of max_length.
+  //
+  // Does not look for matches longer than max_length.
+  // Does not look for matches further away than max_backward.
+  // Writes the best found match length into best_len_out.
+  // Writes the index (&data[index]) of the start of the best match into
+  // best_distance_out.
+  inline bool FindLongestMatch(const uint8_t * __restrict ring_buffer,
+                               const size_t ring_buffer_mask,
+                               const int* __restrict distance_cache,
+                               const uint32_t cur_ix,
+                               const uint32_t max_length,
+                               const uint32_t max_backward,
+                               int * __restrict best_len_out,
+                               int * __restrict best_len_code_out,
+                               int * __restrict best_distance_out,
+                               double* __restrict best_score_out) {
+    const int best_len_in = *best_len_out;
+    const int cur_ix_masked = cur_ix & ring_buffer_mask;
+    int compare_char = ring_buffer[cur_ix_masked + best_len_in];
+    double best_score = *best_score_out;
+    int best_len = best_len_in;
+    int backward = distance_cache[0];
+    size_t prev_ix = cur_ix - backward;
+    bool match_found = false;
+    if (prev_ix < cur_ix) {
+      prev_ix &= ring_buffer_mask;
+      if (compare_char == ring_buffer[prev_ix + best_len]) {
+        int len = FindMatchLengthWithLimit(&ring_buffer[prev_ix],
+                                           &ring_buffer[cur_ix_masked],
+                                           max_length);
+        if (len >= 4) {
+          best_score = BackwardReferenceScoreUsingLastDistance(len, 0);
+          best_len = len;
+          *best_len_out = len;
+          *best_len_code_out = len;
+          *best_distance_out = backward;
+          *best_score_out = best_score;
+          compare_char = ring_buffer[cur_ix_masked + best_len];
+          if (kBucketSweep == 1) {
+            return true;
+          } else {
+            match_found = true;
+          }
+        }
+      }
+    }
+    const uint32_t key = HashBytes(&ring_buffer[cur_ix_masked]);
+    if (kBucketSweep == 1) {
+      // Only one to look for, don't bother to prepare for a loop.
+      prev_ix = buckets_[key];
+      backward = cur_ix - prev_ix;
+      prev_ix &= ring_buffer_mask;
+      if (compare_char != ring_buffer[prev_ix + best_len_in]) {
+        return false;
+      }
+      if (PREDICT_FALSE(backward == 0 || backward > max_backward)) {
+        return false;
+      }
+      const int len = FindMatchLengthWithLimit(&ring_buffer[prev_ix],
+                                               &ring_buffer[cur_ix_masked],
+                                               max_length);
+      if (len >= 4) {
+        *best_len_out = len;
+        *best_len_code_out = len;
+        *best_distance_out = backward;
+        *best_score_out = BackwardReferenceScore(len, backward);
+        return true;
+      }
+    } else {
+      uint32_t *bucket = buckets_ + key;
+      prev_ix = *bucket++;
+      for (int i = 0; i < kBucketSweep; ++i, prev_ix = *bucket++) {
+        const int backward = cur_ix - prev_ix;
+        prev_ix &= ring_buffer_mask;
+        if (compare_char != ring_buffer[prev_ix + best_len]) {
+          continue;
+        }
+        if (PREDICT_FALSE(backward == 0 || backward > max_backward)) {
+          continue;
+        }
+        const int len =
+            FindMatchLengthWithLimit(&ring_buffer[prev_ix],
+                                     &ring_buffer[cur_ix_masked],
+                                     max_length);
+        if (len >= 4) {
+          const double score = BackwardReferenceScore(len, backward);
+          if (best_score < score) {
+            best_score = score;
+            best_len = len;
+            *best_len_out = best_len;
+            *best_len_code_out = best_len;
+            *best_distance_out = backward;
+            *best_score_out = score;
+            compare_char = ring_buffer[cur_ix_masked + best_len];
+            match_found = true;
+          }
+        }
+      }
+    }
+    if (kUseDictionary && !match_found &&
+        num_dict_matches_ >= (num_dict_lookups_ >> 7)) {
+      ++num_dict_lookups_;
+      const uint32_t key = Hash<14>(&ring_buffer[cur_ix_masked]) << 1;
+      const uint16_t v = kStaticDictionaryHash[key];
+      if (v > 0) {
+        const int len = v & 31;
+        const int dist = v >> 5;
+        const int offset = kBrotliDictionaryOffsetsByLength[len] + len * dist;
+        if (len <= max_length) {
+          const int matchlen =
+              FindMatchLengthWithLimit(&ring_buffer[cur_ix_masked],
+                                       &kBrotliDictionary[offset], len);
+          if (matchlen > len - kCutoffTransformsCount && matchlen > 0) {
+            const int transform_id = kCutoffTransforms[len - matchlen];
+            const int word_id =
+                transform_id * (1 << kBrotliDictionarySizeBitsByLength[len]) +
+                dist;
+            const size_t backward = max_backward + word_id + 1;
+            const double score = BackwardReferenceScore(matchlen, backward);
+            if (best_score < score) {
+              ++num_dict_matches_;
+              best_score = score;
+              best_len = matchlen;
+              *best_len_out = best_len;
+              *best_len_code_out = len;
+              *best_distance_out = backward;
+              *best_score_out = best_score;
+              return true;
+            }
+          }
+        }
+      }
+    }
+    return match_found;
+  }
+
+  enum { kHashLength = 5 };
+  enum { kHashTypeLength = 8 };
+  // HashBytes is the function that chooses the bucket to place
+  // the address in. The HashLongestMatch and HashLongestMatchQuickly
+  // classes have separate, different implementations of hashing.
+  static uint32_t HashBytes(const uint8_t *data) {
+    // Computing a hash based on 5 bytes works much better for
+    // qualities 1 and 3, where the next hash value is likely to replace
+    static const uint32_t kHashMul32 = 0x1e35a7bd;
+    uint64_t h = (BROTLI_UNALIGNED_LOAD64(data) << 24) * kHashMul32;
+    // The higher bits contain more mixture from the multiplication,
+    // so we take our results from there.
+    return h >> (64 - kBucketBits);
+  }
+
+ private:
+  static const uint32_t kBucketSize = 1 << kBucketBits;
+  uint32_t buckets_[kBucketSize + kBucketSweep];
+  size_t num_dict_lookups_;
+  size_t num_dict_matches_;
+};
+
+// The maximum length for which the zopflification uses distinct distances.
+static const int kMaxZopfliLen = 325;
+
+// A (forgetful) hash table to the data seen by the compressor, to
+// help create backward references to previous data.
+//
+// This is a hash map of fixed size (kBucketSize) to a ring buffer of
+// fixed size (kBlockSize). The ring buffer contains the last kBlockSize
+// index positions of the given hash key in the compressed data.
+template <int kBucketBits,
+          int kBlockBits,
+          int kNumLastDistancesToCheck>
+class HashLongestMatch {
+ public:
+  HashLongestMatch() {
+    Reset();
+  }
+
+  void Reset() {
+    memset(&num_[0], 0, sizeof(num_));
+    num_dict_lookups_ = 0;
+    num_dict_matches_ = 0;
+  }
+
+  // Look at 3 bytes at data.
+  // Compute a hash from these, and store the value of ix at that position.
+  inline void Store(const uint8_t *data, const int ix) {
+    const uint32_t key = HashBytes(data);
+    const int minor_ix = num_[key] & kBlockMask;
+    buckets_[key][minor_ix] = ix;
+    ++num_[key];
+  }
+
+  // Store hashes for a range of data.
+  void StoreHashes(const uint8_t *data, size_t len, int startix, int mask) {
+    for (int p = 0; p < len; ++p) {
+      Store(&data[p & mask], startix + p);
+    }
+  }
+
+  // Find a longest backward match of &data[cur_ix] up to the length of
+  // max_length.
+  //
+  // Does not look for matches longer than max_length.
+  // Does not look for matches further away than max_backward.
+  // Writes the best found match length into best_len_out.
+  // Writes the index (&data[index]) offset from the start of the best match
+  // into best_distance_out.
+  // Write the score of the best match into best_score_out.
+  bool FindLongestMatch(const uint8_t * __restrict data,
+                        const size_t ring_buffer_mask,
+                        const int* __restrict distance_cache,
+                        const uint32_t cur_ix,
+                        uint32_t max_length,
+                        const uint32_t max_backward,
+                        int * __restrict best_len_out,
+                        int * __restrict best_len_code_out,
+                        int * __restrict best_distance_out,
+                        double * __restrict best_score_out) {
+    *best_len_code_out = 0;
+    const size_t cur_ix_masked = cur_ix & ring_buffer_mask;
+    bool match_found = false;
+    // Don't accept a short copy from far away.
+    double best_score = *best_score_out;
+    int best_len = *best_len_out;
+    *best_len_out = 0;
+    // Try last distance first.
+    for (int i = 0; i < kNumLastDistancesToCheck; ++i) {
+      const int idx = kDistanceCacheIndex[i];
+      const int backward = distance_cache[idx] + kDistanceCacheOffset[i];
+      size_t prev_ix = cur_ix - backward;
+      if (prev_ix >= cur_ix) {
+        continue;
+      }
+      if (PREDICT_FALSE(backward > max_backward)) {
+        continue;
+      }
+      prev_ix &= ring_buffer_mask;
+
+      if (cur_ix_masked + best_len > ring_buffer_mask ||
+          prev_ix + best_len > ring_buffer_mask ||
+          data[cur_ix_masked + best_len] != data[prev_ix + best_len]) {
+        continue;
+      }
+      const size_t len =
+          FindMatchLengthWithLimit(&data[prev_ix], &data[cur_ix_masked],
+                                   max_length);
+      if (len >= 3 || (len == 2 && i < 2)) {
+        // Comparing for >= 2 does not change the semantics, but just saves for
+        // a few unnecessary binary logarithms in backward reference score,
+        // since we are not interested in such short matches.
+        double score = BackwardReferenceScoreUsingLastDistance(len, i);
+        if (best_score < score) {
+          best_score = score;
+          best_len = len;
+          *best_len_out = best_len;
+          *best_len_code_out = best_len;
+          *best_distance_out = backward;
+          *best_score_out = best_score;
+          match_found = true;
+        }
+      }
+    }
+    const uint32_t key = HashBytes(&data[cur_ix_masked]);
+    const int * __restrict const bucket = &buckets_[key][0];
+    const int down = (num_[key] > kBlockSize) ? (num_[key] - kBlockSize) : 0;
+    for (int i = num_[key] - 1; i >= down; --i) {
+      int prev_ix = bucket[i & kBlockMask];
+      if (prev_ix >= 0) {
+        const size_t backward = cur_ix - prev_ix;
+        if (PREDICT_FALSE(backward > max_backward)) {
+          break;
+        }
+        prev_ix &= ring_buffer_mask;
+        if (cur_ix_masked + best_len > ring_buffer_mask ||
+            prev_ix + best_len > ring_buffer_mask ||
+            data[cur_ix_masked + best_len] != data[prev_ix + best_len]) {
+          continue;
+        }
+        const size_t len =
+            FindMatchLengthWithLimit(&data[prev_ix], &data[cur_ix_masked],
+                                     max_length);
+        if (len >= 4) {
+          // Comparing for >= 3 does not change the semantics, but just saves
+          // for a few unnecessary binary logarithms in backward reference
+          // score, since we are not interested in such short matches.
+          double score = BackwardReferenceScore(len, backward);
+          if (best_score < score) {
+            best_score = score;
+            best_len = len;
+            *best_len_out = best_len;
+            *best_len_code_out = best_len;
+            *best_distance_out = backward;
+            *best_score_out = best_score;
+            match_found = true;
+          }
+        }
+      }
+    }
+    if (!match_found && num_dict_matches_ >= (num_dict_lookups_ >> 7)) {
+      uint32_t key = Hash<14>(&data[cur_ix_masked]) << 1;
+      for (int k = 0; k < 2; ++k, ++key) {
+        ++num_dict_lookups_;
+        const uint16_t v = kStaticDictionaryHash[key];
+        if (v > 0) {
+          const int len = v & 31;
+          const int dist = v >> 5;
+          const int offset = kBrotliDictionaryOffsetsByLength[len] + len * dist;
+          if (len <= max_length) {
+            const int matchlen =
+                FindMatchLengthWithLimit(&data[cur_ix_masked],
+                                         &kBrotliDictionary[offset], len);
+            if (matchlen > len - kCutoffTransformsCount && matchlen > 0) {
+              const int transform_id = kCutoffTransforms[len - matchlen];
+              const int word_id =
+                  transform_id * (1 << kBrotliDictionarySizeBitsByLength[len]) +
+                  dist;
+              const size_t backward = max_backward + word_id + 1;
+              double score = BackwardReferenceScore(matchlen, backward);
+              if (best_score < score) {
+                ++num_dict_matches_;
+                best_score = score;
+                best_len = matchlen;
+                *best_len_out = best_len;
+                *best_len_code_out = len;
+                *best_distance_out = backward;
+                *best_score_out = best_score;
+                match_found = true;
+              }
+            }
+          }
+        }
+      }
+    }
+    return match_found;
+  }
+
+  // Similar to FindLongestMatch(), but finds all matches.
+  //
+  // Sets *num_matches to the number of matches found, and stores the found
+  // matches in matches[0] to matches[*num_matches - 1].
+  //
+  // If the longest match is longer than kMaxZopfliLen, returns only this
+  // longest match.
+  //
+  // Requires that at least kMaxZopfliLen space is available in matches.
+  void FindAllMatches(const uint8_t* data,
+                      const size_t ring_buffer_mask,
+                      const uint32_t cur_ix,
+                      uint32_t max_length,
+                      const uint32_t max_backward,
+                      int* num_matches,
+                      BackwardMatch* matches) const {
+    BackwardMatch* const orig_matches = matches;
+    const size_t cur_ix_masked = cur_ix & ring_buffer_mask;
+    int best_len = 1;
+    int stop = static_cast<int>(cur_ix) - 64;
+    if (stop < 0) { stop = 0; }
+    for (int i = cur_ix - 1; i > stop && best_len <= 2; --i) {
+      size_t prev_ix = i;
+      const size_t backward = cur_ix - prev_ix;
+      if (PREDICT_FALSE(backward > max_backward)) {
+        break;
+      }
+      prev_ix &= ring_buffer_mask;
+      if (data[cur_ix_masked] != data[prev_ix] ||
+          data[cur_ix_masked + 1] != data[prev_ix + 1]) {
+        continue;
+      }
+      const size_t len =
+          FindMatchLengthWithLimit(&data[prev_ix], &data[cur_ix_masked],
+                                   max_length);
+      if (len > best_len) {
+        best_len = len;
+        if (len > kMaxZopfliLen) {
+          matches = orig_matches;
+        }
+        *matches++ = BackwardMatch(backward, len);
+      }
+    }
+    const uint32_t key = HashBytes(&data[cur_ix_masked]);
+    const int * __restrict const bucket = &buckets_[key][0];
+    const int down = (num_[key] > kBlockSize) ? (num_[key] - kBlockSize) : 0;
+    for (int i = num_[key] - 1; i >= down; --i) {
+      int prev_ix = bucket[i & kBlockMask];
+      if (prev_ix >= 0) {
+        const size_t backward = cur_ix - prev_ix;
+        if (PREDICT_FALSE(backward > max_backward)) {
+          break;
+        }
+        prev_ix &= ring_buffer_mask;
+        if (cur_ix_masked + best_len > ring_buffer_mask ||
+            prev_ix + best_len > ring_buffer_mask ||
+            data[cur_ix_masked + best_len] != data[prev_ix + best_len]) {
+          continue;
+        }
+        const size_t len =
+            FindMatchLengthWithLimit(&data[prev_ix], &data[cur_ix_masked],
+                                     max_length);
+        if (len > best_len) {
+          best_len = len;
+          if (len > kMaxZopfliLen) {
+            matches = orig_matches;
+          }
+          *matches++ = BackwardMatch(backward, len);
+        }
+      }
+    }
+    std::vector<int> dict_matches(kMaxDictionaryMatchLen + 1, kInvalidMatch);
+    int minlen = std::max<int>(4, best_len + 1);
+    if (FindAllStaticDictionaryMatches(&data[cur_ix_masked], minlen, max_length,
+                                       &dict_matches[0])) {
+      int maxlen = std::min<int>(kMaxDictionaryMatchLen, max_length);
+      for (int l = minlen; l <= maxlen; ++l) {
+        int dict_id = dict_matches[l];
+        if (dict_id < kInvalidMatch) {
+          *matches++ = BackwardMatch(max_backward + (dict_id >> 5) + 1, l,
+                                     dict_id & 31);
+        }
+      }
+    }
+    *num_matches += matches - orig_matches;
+  }
+
+  enum { kHashLength = 4 };
+  enum { kHashTypeLength = 4 };
+
+  // HashBytes is the function that chooses the bucket to place
+  // the address in. The HashLongestMatch and HashLongestMatchQuickly
+  // classes have separate, different implementations of hashing.
+  static uint32_t HashBytes(const uint8_t *data) {
+    // kHashMul32 multiplier has these properties:
+    // * The multiplier must be odd. Otherwise we may lose the highest bit.
+    // * No long streaks of 1s or 0s.
+    // * Is not unfortunate (see the unittest) for the English language.
+    // * There is no effort to ensure that it is a prime, the oddity is enough
+    //   for this use.
+    // * The number has been tuned heuristically against compression benchmarks.
+    static const uint32_t kHashMul32 = 0x1e35a7bd;
+    uint32_t h = BROTLI_UNALIGNED_LOAD32(data) * kHashMul32;
+    // The higher bits contain more mixture from the multiplication,
+    // so we take our results from there.
+    return h >> (32 - kBucketBits);
+  }
+
+ private:
+  // Number of hash buckets.
+  static const uint32_t kBucketSize = 1 << kBucketBits;
+
+  // Only kBlockSize newest backward references are kept,
+  // and the older are forgotten.
+  static const uint32_t kBlockSize = 1 << kBlockBits;
+
+  // Mask for accessing entries in a block (in a ringbuffer manner).
+  static const uint32_t kBlockMask = (1 << kBlockBits) - 1;
+
+  // Number of entries in a particular bucket.
+  uint16_t num_[kBucketSize];
+
+  // Buckets containing kBlockSize of backward references.
+  int buckets_[kBucketSize][kBlockSize];
+
+  size_t num_dict_lookups_;
+  size_t num_dict_matches_;
+};
+
+struct Hashers {
+  // For kBucketSweep == 1, enabling the dictionary lookup makes compression
+  // a little faster (0.5% - 1%) and it compresses 0.15% better on small text
+  // and html inputs.
+  typedef HashLongestMatchQuickly<16, 1, true> H1;
+  typedef HashLongestMatchQuickly<16, 2, false> H2;
+  typedef HashLongestMatchQuickly<16, 4, false> H3;
+  typedef HashLongestMatchQuickly<17, 4, true> H4;
+  typedef HashLongestMatch<14, 4, 4> H5;
+  typedef HashLongestMatch<14, 5, 4> H6;
+  typedef HashLongestMatch<15, 6, 10> H7;
+  typedef HashLongestMatch<15, 7, 10> H8;
+  typedef HashLongestMatch<15, 8, 16> H9;
+
+  void Init(int type) {
+    switch (type) {
+      case 1: hash_h1.reset(new H1); break;
+      case 2: hash_h2.reset(new H2); break;
+      case 3: hash_h3.reset(new H3); break;
+      case 4: hash_h4.reset(new H4); break;
+      case 5: hash_h5.reset(new H5); break;
+      case 6: hash_h6.reset(new H6); break;
+      case 7: hash_h7.reset(new H7); break;
+      case 8: hash_h8.reset(new H8); break;
+      case 9: hash_h9.reset(new H9); break;
+      default: break;
+    }
+  }
+
+  template<typename Hasher>
+  void WarmupHash(const size_t size, const uint8_t* dict, Hasher* hasher) {
+    for (size_t i = 0; i + Hasher::kHashTypeLength - 1 < size; i++) {
+      hasher->Store(dict, i);
+    }
+  }
+
+  // Custom LZ77 window.
+  void PrependCustomDictionary(
+      int type, const size_t size, const uint8_t* dict) {
+    switch (type) {
+      case 1: WarmupHash(size, dict, hash_h1.get()); break;
+      case 2: WarmupHash(size, dict, hash_h2.get()); break;
+      case 3: WarmupHash(size, dict, hash_h3.get()); break;
+      case 4: WarmupHash(size, dict, hash_h4.get()); break;
+      case 5: WarmupHash(size, dict, hash_h5.get()); break;
+      case 6: WarmupHash(size, dict, hash_h6.get()); break;
+      case 7: WarmupHash(size, dict, hash_h7.get()); break;
+      case 8: WarmupHash(size, dict, hash_h8.get()); break;
+      case 9: WarmupHash(size, dict, hash_h9.get()); break;
+      default: break;
+    }
+  }
+
+  std::unique_ptr<H1> hash_h1;
+  std::unique_ptr<H2> hash_h2;
+  std::unique_ptr<H3> hash_h3;
+  std::unique_ptr<H4> hash_h4;
+  std::unique_ptr<H5> hash_h5;
+  std::unique_ptr<H6> hash_h6;
+  std::unique_ptr<H7> hash_h7;
+  std::unique_ptr<H8> hash_h8;
+  std::unique_ptr<H9> hash_h9;
+};
+
+}  // namespace brotli
+
+#endif  // BROTLI_ENC_HASH_H_