brotli 0.1.8 → 0.2.0

data/vendor/brotli/{enc → c/enc}/metablock.h

@@ -10,7 +10,7 @@
 #ifndef BROTLI_ENC_METABLOCK_H_
 #define BROTLI_ENC_METABLOCK_H_
 
-#include "../common/types.h"
+#include <brotli/types.h>
 #include "./block_splitter.h"
 #include "./command.h"
 #include "./context.h"
@@ -80,20 +80,10 @@ BROTLI_INTERNAL void BrotliBuildMetaBlock(MemoryManager* m,
                                           ContextType literal_context_mode,
                                           MetaBlockSplit* mb);
 
-/* Uses a fast greedy block splitter that tries to merge current block with the
-   last or the second last block and does not do any context modeling. */
-BROTLI_INTERNAL void BrotliBuildMetaBlockGreedy(MemoryManager* m,
-                                                const uint8_t* ringbuffer,
-                                                size_t pos,
-                                                size_t mask,
-                                                const Command* commands,
-                                                size_t n_commands,
-                                                MetaBlockSplit* mb);
-
 /* Uses a fast greedy block splitter that tries to merge current block with the
    last or the second last block and uses a static context clustering which
    is the same for all block types. */
-BROTLI_INTERNAL void BrotliBuildMetaBlockGreedyWithContexts(
+BROTLI_INTERNAL void BrotliBuildMetaBlockGreedy(
     MemoryManager* m, const uint8_t* ringbuffer, size_t pos, size_t mask,
     uint8_t prev_byte, uint8_t prev_byte2, ContextType literal_context_mode,
     size_t num_contexts, const uint32_t* static_context_map,

data/vendor/brotli/{enc → c/enc}/port.h

@@ -12,8 +12,8 @@
 #include <assert.h>
 #include <string.h>  /* memcpy */
 
-#include "../common/port.h"
-#include "../common/types.h"
+#include <brotli/port.h>
+#include <brotli/types.h>
 
 #if defined OS_LINUX || defined OS_CYGWIN
 #include <endian.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,36 +109,55 @@ 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;
 }
 
-#endif
+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 */
 
-#if !defined(__cplusplus) && !defined(c_plusplus) && __STDC_VERSION__ >= 199901L
-#define BROTLI_RESTRICT restrict
-#elif BROTLI_GCC_VERSION > 295 || defined(__llvm__)
-#define BROTLI_RESTRICT __restrict
-#else
-#define BROTLI_RESTRICT
 #endif
 
-#define _TEMPLATE(T)                                                           \
+#define TEMPLATE_(T)                                                           \
   static BROTLI_INLINE T brotli_min_ ## T (T a, T b) { return a < b ? a : b; } \
   static BROTLI_INLINE T brotli_max_ ## T (T a, T b) { return a > b ? a : b; }
-_TEMPLATE(double) _TEMPLATE(float) _TEMPLATE(int)
-_TEMPLATE(size_t) _TEMPLATE(uint32_t) _TEMPLATE(uint8_t)
-#undef _TEMPLATE
+TEMPLATE_(double) TEMPLATE_(float) TEMPLATE_(int)
+TEMPLATE_(size_t) TEMPLATE_(uint32_t) TEMPLATE_(uint8_t)
+#undef TEMPLATE_
 #define BROTLI_MIN(T, A, B) (brotli_min_ ## T((A), (B)))
 #define BROTLI_MAX(T, A, B) (brotli_max_ ## T((A), (B)))
 

data/vendor/brotli/{enc → c/enc}/prefix.h

@@ -11,14 +11,16 @@
 #define BROTLI_ENC_PREFIX_H_
 
 #include "../common/constants.h"
-#include "../common/port.h"
-#include "../common/types.h"
+#include <brotli/port.h>
+#include <brotli/types.h>
 #include "./fast_log.h"
 
 #if defined(__cplusplus) || defined(c_plusplus)
 extern "C" {
 #endif
 
+/* Here distance_code is an intermediate code, i.e. one of the special codes or
+   the actual distance increased by BROTLI_NUM_DISTANCE_SHORT_CODES - 1. */
 static BROTLI_INLINE void PrefixEncodeCopyDistance(size_t distance_code,
                                                    size_t num_direct_codes,
                                                    size_t postfix_bits,

data/vendor/brotli/{enc → c/enc}/quality.h

@@ -10,14 +10,14 @@
 #ifndef BROTLI_ENC_QUALITY_H_
 #define BROTLI_ENC_QUALITY_H_
 
-#include "./encode.h"
+#include <brotli/encode.h>
 
 #define FAST_ONE_PASS_COMPRESSION_QUALITY 0
 #define FAST_TWO_PASS_COMPRESSION_QUALITY 1
 #define ZOPFLIFICATION_QUALITY 10
 #define HQ_ZOPFLIFICATION_QUALITY 11
 
-#define MAX_QUALITY_FOR_STATIC_ENRTOPY_CODES 2
+#define MAX_QUALITY_FOR_STATIC_ENTROPY_CODES 2
 #define MIN_QUALITY_FOR_BLOCK_SPLIT 4
 #define MIN_QUALITY_FOR_OPTIMIZE_HISTOGRAMS 4
 #define MIN_QUALITY_FOR_EXTENSIVE_REFERENCE_SEARCH 5
@@ -31,15 +31,26 @@
    so we buffer at most this much literals and commands. */
 #define MAX_NUM_DELAYED_SYMBOLS 0x2fff
 
+typedef struct BrotliHasherParams {
+  int type;
+  int bucket_bits;
+  int block_bits;
+  int hash_len;
+  int num_last_distances_to_check;
+} BrotliHasherParams;
+
 /* Encoding parameters */
 typedef struct BrotliEncoderParams {
   BrotliEncoderMode mode;
   int quality;
   int lgwin;
   int lgblock;
+  size_t size_hint;
+  BROTLI_BOOL disable_literal_context_modeling;
+  BrotliHasherParams hasher;
 } BrotliEncoderParams;
 
-/* Returns hashtable size for quality levels 0 and 1. */
+/* Returns hash-table size for quality levels 0 and 1. */
 static BROTLI_INLINE size_t MaxHashTableSize(int quality) {
   return quality == FAST_ONE_PASS_COMPRESSION_QUALITY ? 1 << 15 : 1 << 17;
 }
@@ -48,13 +59,16 @@ static BROTLI_INLINE size_t MaxHashTableSize(int quality) {
 #define MAX_ZOPFLI_LEN_QUALITY_10 150
 #define MAX_ZOPFLI_LEN_QUALITY_11 325
 
+/* Do not thoroughly search when a long copy is found. */
+#define BROTLI_LONG_COPY_QUICK_STEP 16384
+
 static BROTLI_INLINE size_t MaxZopfliLen(const BrotliEncoderParams* params) {
   return params->quality <= 10 ?
       MAX_ZOPFLI_LEN_QUALITY_10 :
       MAX_ZOPFLI_LEN_QUALITY_11;
 }
 
-/* Number of best candidates to evaluate to expand zopfli chain. */
+/* Number of best candidates to evaluate to expand Zopfli chain. */
 static BROTLI_INLINE size_t MaxZopfliCandidates(
   const BrotliEncoderParams* params) {
   return params->quality <= 10 ? 1 : 5;
@@ -63,10 +77,10 @@ static BROTLI_INLINE size_t MaxZopfliCandidates(
 static BROTLI_INLINE void SanitizeParams(BrotliEncoderParams* params) {
   params->quality = BROTLI_MIN(int, BROTLI_MAX_QUALITY,
       BROTLI_MAX(int, BROTLI_MIN_QUALITY, params->quality));
-  if (params->lgwin < kBrotliMinWindowBits) {
-    params->lgwin = kBrotliMinWindowBits;
-  } else if (params->lgwin > kBrotliMaxWindowBits) {
-    params->lgwin = kBrotliMaxWindowBits;
+  if (params->lgwin < BROTLI_MIN_WINDOW_BITS) {
+    params->lgwin = BROTLI_MIN_WINDOW_BITS;
+  } else if (params->lgwin > BROTLI_MAX_WINDOW_BITS) {
+    params->lgwin = BROTLI_MAX_WINDOW_BITS;
   }
 }
 
@@ -84,8 +98,8 @@ static BROTLI_INLINE int ComputeLgBlock(const BrotliEncoderParams* params) {
       lgblock = BROTLI_MIN(int, 18, params->lgwin);
     }
   } else {
-    lgblock = BROTLI_MIN(int, kBrotliMaxInputBlockBits,
-        BROTLI_MAX(int, kBrotliMinInputBlockBits, lgblock));
+    lgblock = BROTLI_MIN(int, BROTLI_MAX_INPUT_BLOCK_BITS,
+        BROTLI_MAX(int, BROTLI_MIN_INPUT_BLOCK_BITS, lgblock));
   }
   return lgblock;
 }
@@ -94,14 +108,15 @@ static BROTLI_INLINE int ComputeLgBlock(const BrotliEncoderParams* params) {
    Allocate at least lgwin + 1 bits for the ring buffer so that the newly
    added block fits there completely and we still get lgwin bits and at least
    read_block_size_bits + 1 bits because the copy tail length needs to be
-   smaller than ringbuffer size. */
+   smaller than ring-buffer size. */
 static BROTLI_INLINE int ComputeRbBits(const BrotliEncoderParams* params) {
   return 1 + BROTLI_MAX(int, params->lgwin, params->lgblock);
 }
 
 static BROTLI_INLINE size_t MaxMetablockSize(
     const BrotliEncoderParams* params) {
-  int bits = BROTLI_MIN(int, ComputeRbBits(params), kBrotliMaxInputBlockBits);
+  int bits =
+      BROTLI_MIN(int, ComputeRbBits(params), BROTLI_MAX_INPUT_BLOCK_BITS);
   return (size_t)1 << bits;
 }
 
@@ -116,15 +131,30 @@ static BROTLI_INLINE size_t LiteralSpreeLengthForSparseSearch(
   return params->quality < 9 ? 64 : 512;
 }
 
-static BROTLI_INLINE int ChooseHasher(const BrotliEncoderParams* params) {
+static BROTLI_INLINE void ChooseHasher(const BrotliEncoderParams* params,
+                                       BrotliHasherParams* hparams) {
   if (params->quality > 9) {
-    return 10;
+    hparams->type = 10;
+  } else if (params->quality == 4 && params->size_hint >= (1 << 20)) {
+    hparams->type = 54;
   } else if (params->quality < 5) {
-    return params->quality;
+    hparams->type = params->quality;
   } else if (params->lgwin <= 16) {
-    return params->quality < 7 ? 40 : params->quality < 9 ? 41 : 42;
+    hparams->type = params->quality < 7 ? 40 : params->quality < 9 ? 41 : 42;
+  } else if (params->size_hint >= (1 << 20) && params->lgwin >= 19) {
+    hparams->type = 6;
+    hparams->block_bits = params->quality - 1;
+    hparams->bucket_bits = 15;
+    hparams->hash_len = 5;
+    hparams->num_last_distances_to_check =
+        params->quality < 7 ? 4 : params->quality < 9 ? 10 : 16;
+  } else {
+    hparams->type = 5;
+    hparams->block_bits = params->quality - 1;
+    hparams->bucket_bits = params->quality < 7 ? 14 : 15;
+    hparams->num_last_distances_to_check =
+        params->quality < 7 ? 4 : params->quality < 9 ? 10 : 16;
   }
-  return params->quality;
 }
 
 #endif  /* BROTLI_ENC_QUALITY_H_ */

data/vendor/brotli/{enc → c/enc}/ringbuffer.h

@@ -11,7 +11,7 @@
 
 #include <string.h>  /* memcpy */
 
-#include "../common/types.h"
+#include <brotli/types.h>
 #include "./memory.h"
 #include "./port.h"
 #include "./quality.h"
@@ -30,7 +30,7 @@ extern "C" {
      buffer_[-1] == buffer_[(1 << window_bits) - 1] and
      buffer_[-2] == buffer_[(1 << window_bits) - 2]. */
 typedef struct RingBuffer {
-  /* Size of the ringbuffer is (1 << window_bits) + tail_size_. */
+  /* Size of the ring-buffer is (1 << window_bits) + tail_size_. */
   const uint32_t size_;
   const uint32_t mask_;
   const uint32_t tail_size_;
@@ -42,7 +42,7 @@ typedef struct RingBuffer {
   /* The actual ring buffer containing the copy of the last two bytes, the data,
      and the copy of the beginning as a tail. */
   uint8_t *data_;
-  /* The start of the ringbuffer. */
+  /* The start of the ring-buffer. */
   uint8_t *buffer_;
 } RingBuffer;
 
@@ -93,7 +93,7 @@ static BROTLI_INLINE void RingBufferInitBuffer(
 static BROTLI_INLINE void RingBufferWriteTail(
     const uint8_t *bytes, size_t n, RingBuffer* rb) {
   const size_t masked_pos = rb->pos_ & rb->mask_;
-  if (PREDICT_FALSE(masked_pos < rb->tail_size_)) {
+  if (BROTLI_PREDICT_FALSE(masked_pos < rb->tail_size_)) {
     /* Just fill the tail buffer with the beginning data. */
     const size_t p = rb->size_ + masked_pos;
     memcpy(&rb->buffer_[p], bytes,
@@ -106,7 +106,7 @@ static BROTLI_INLINE void RingBufferWrite(
     MemoryManager* m, const uint8_t *bytes, size_t n, RingBuffer* rb) {
   if (rb->pos_ == 0 && n < rb->tail_size_) {
     /* Special case for the first write: to process the first block, we don't
-       need to allocate the whole ringbuffer and we don't need the tail
+       need to allocate the whole ring-buffer and we don't need the tail
        either. However, we do this memory usage optimization only if the
        first write is less than the tail size, which is also the input block
        size, otherwise it is likely that other blocks will follow and we
@@ -131,7 +131,7 @@ static BROTLI_INLINE void RingBufferWrite(
     /* The length of the writes is limited so that we do not need to worry
        about a write */
     RingBufferWriteTail(bytes, n, rb);
-    if (PREDICT_TRUE(masked_pos + n <= rb->size_)) {
+    if (BROTLI_PREDICT_TRUE(masked_pos + n <= rb->size_)) {
       /* A single write fits. */
       memcpy(&rb->buffer_[masked_pos], bytes, n);
     } else {

data/vendor/brotli/{enc → c/enc}/static_dict.c

@@ -33,23 +33,24 @@ static BROTLI_INLINE void AddMatch(size_t distance, size_t len, size_t len_code,
   matches[len] = BROTLI_MIN(uint32_t, matches[len], match);
 }
 
-static BROTLI_INLINE size_t DictMatchLength(const uint8_t* data,
+static BROTLI_INLINE size_t DictMatchLength(const BrotliDictionary* dictionary,
+                                            const uint8_t* data,
                                             size_t id,
                                             size_t len,
                                             size_t maxlen) {
-  const size_t offset = kBrotliDictionaryOffsetsByLength[len] + len * id;
-  return FindMatchLengthWithLimit(&kBrotliDictionary[offset], data,
+  const size_t offset = dictionary->offsets_by_length[len] + len * id;
+  return FindMatchLengthWithLimit(&dictionary->data[offset], data,
                                   BROTLI_MIN(size_t, len, maxlen));
 }
 
-static BROTLI_INLINE BROTLI_BOOL IsMatch(
+static BROTLI_INLINE BROTLI_BOOL IsMatch(const BrotliDictionary* dictionary,
     DictWord w, const uint8_t* data, size_t max_length) {
   if (w.len > max_length) {
     return BROTLI_FALSE;
   } else {
-    const size_t offset = kBrotliDictionaryOffsetsByLength[w.len] +
+    const size_t offset = dictionary->offsets_by_length[w.len] +
         (size_t)w.len * (size_t)w.idx;
-    const uint8_t* dict = &kBrotliDictionary[offset];
+    const uint8_t* dict = &dictionary->data[offset];
     if (w.transform == 0) {
       /* Match against base dictionary word. */
       return
@@ -78,21 +79,22 @@ static BROTLI_INLINE BROTLI_BOOL IsMatch(
 }
 
 BROTLI_BOOL BrotliFindAllStaticDictionaryMatches(
-    const uint8_t* data, size_t min_length, size_t max_length,
-    uint32_t* matches) {
+    const BrotliDictionary* dictionary, const uint8_t* data, size_t min_length,
+    size_t max_length, uint32_t* matches) {
   BROTLI_BOOL has_found_match = BROTLI_FALSE;
   {
     size_t offset = kStaticDictionaryBuckets[Hash(data)];
     BROTLI_BOOL end = !offset;
     while (!end) {
       DictWord w = kStaticDictionaryWords[offset++];
-      const size_t l = w.len & 0x7F;
-      const size_t n = (size_t)1 << kBrotliDictionarySizeBitsByLength[l];
+      const size_t l = w.len & 0x1F;
+      const size_t n = (size_t)1 << dictionary->size_bits_by_length[l];
       const size_t id = w.idx;
       end = !!(w.len & 0x80);
       w.len = (uint8_t)l;
       if (w.transform == 0) {
-        const size_t matchlen = DictMatchLength(data, id, l, max_length);
+        const size_t matchlen =
+            DictMatchLength(dictionary, data, id, l, max_length);
         const uint8_t* s;
         size_t minlen;
         size_t maxlen;
@@ -276,7 +278,7 @@ BROTLI_BOOL BrotliFindAllStaticDictionaryMatches(
         const BROTLI_BOOL is_all_caps =
             TO_BROTLI_BOOL(w.transform != kUppercaseFirst);
         const uint8_t* s;
-        if (!IsMatch(w, data, max_length)) {
+        if (!IsMatch(dictionary, w, data, max_length)) {
           continue;
         }
         /* Transform "" + kUppercase{First,All} + "" */
@@ -325,14 +327,14 @@ BROTLI_BOOL BrotliFindAllStaticDictionaryMatches(
     BROTLI_BOOL end = !offset;
     while (!end) {
       DictWord w = kStaticDictionaryWords[offset++];
-      const size_t l = w.len & 0x7F;
-      const size_t n = (size_t)1 << kBrotliDictionarySizeBitsByLength[l];
+      const size_t l = w.len & 0x1F;
+      const size_t n = (size_t)1 << dictionary->size_bits_by_length[l];
       const size_t id = w.idx;
       end = !!(w.len & 0x80);
       w.len = (uint8_t)l;
       if (w.transform == 0) {
         const uint8_t* s;
-        if (!IsMatch(w, &data[1], max_length - 1)) {
+        if (!IsMatch(dictionary, w, &data[1], max_length - 1)) {
           continue;
         }
         /* Transforms " " + kIdentity + "" and "." + kIdentity + "" */
@@ -373,7 +375,7 @@ BROTLI_BOOL BrotliFindAllStaticDictionaryMatches(
         const BROTLI_BOOL is_all_caps =
             TO_BROTLI_BOOL(w.transform != kUppercaseFirst);
         const uint8_t* s;
-        if (!IsMatch(w, &data[1], max_length - 1)) {
+        if (!IsMatch(dictionary, w, &data[1], max_length - 1)) {
           continue;
         }
         /* Transforms " " + kUppercase{First,All} + "" */
@@ -417,12 +419,13 @@ BROTLI_BOOL BrotliFindAllStaticDictionaryMatches(
       BROTLI_BOOL end = !offset;
       while (!end) {
         DictWord w = kStaticDictionaryWords[offset++];
-        const size_t l = w.len & 0x7F;
-        const size_t n = (size_t)1 << kBrotliDictionarySizeBitsByLength[l];
+        const size_t l = w.len & 0x1F;
+        const size_t n = (size_t)1 << dictionary->size_bits_by_length[l];
         const size_t id = w.idx;
         end = !!(w.len & 0x80);
         w.len = (uint8_t)l;
-        if (w.transform == 0 && IsMatch(w, &data[2], max_length - 2)) {
+        if (w.transform == 0 &&
+            IsMatch(dictionary, w, &data[2], max_length - 2)) {
           if (data[0] == 0xc2) {
             AddMatch(id + 102 * n, l + 2, l, matches);
             has_found_match = BROTLI_TRUE;
@@ -445,12 +448,13 @@ BROTLI_BOOL BrotliFindAllStaticDictionaryMatches(
       BROTLI_BOOL end = !offset;
       while (!end) {
         DictWord w = kStaticDictionaryWords[offset++];
-        const size_t l = w.len & 0x7F;
-        const size_t n = (size_t)1 << kBrotliDictionarySizeBitsByLength[l];
+        const size_t l = w.len & 0x1F;
+        const size_t n = (size_t)1 << dictionary->size_bits_by_length[l];
         const size_t id = w.idx;
         end = !!(w.len & 0x80);
         w.len = (uint8_t)l;
-        if (w.transform == 0 && IsMatch(w, &data[5], max_length - 5)) {
+        if (w.transform == 0 &&
+            IsMatch(dictionary, w, &data[5], max_length - 5)) {
           AddMatch(id + (data[0] == ' ' ? 41 : 72) * n, l + 5, l, matches);
           has_found_match = BROTLI_TRUE;
           if (l + 5 < max_length) {