Bug 1402350 - Update Brotli library to release 1.0.1. r=glandium
authorJonathan Kew <jkew@mozilla.com>
Thu, 28 Sep 2017 08:58:54 +0100
changeset 383555 82c4de44f947e5bb0f9210658c0be6b1c3c753e8
parent 383554 1c88159ec23c58bed3bd8fe7e4edac67db3033fb
child 383556 55795addb20e552ebd55834bed45324207cd57a2
push id32595
push userkwierso@gmail.com
push dateThu, 28 Sep 2017 23:57:40 +0000
treeherdermozilla-central@e6c32278f32c [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersglandium
bugs1402350
milestone58.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1402350 - Update Brotli library to release 1.0.1. r=glandium
modules/brotli/README.mozilla
modules/brotli/common/constants.h
modules/brotli/common/dictionary.bin
modules/brotli/common/dictionary.c
modules/brotli/common/dictionary.h
modules/brotli/common/version.h
modules/brotli/dec/decode.c
modules/brotli/dec/state.c
modules/brotli/dec/state.h
modules/brotli/enc/backward_references.c
modules/brotli/enc/backward_references_hq.c
modules/brotli/enc/backward_references_hq.h
modules/brotli/enc/backward_references_inc.h
modules/brotli/enc/block_splitter.c
modules/brotli/enc/block_splitter_inc.h
modules/brotli/enc/brotli_bit_stream.c
modules/brotli/enc/brotli_bit_stream.h
modules/brotli/enc/cluster_inc.h
modules/brotli/enc/command.h
modules/brotli/enc/compress_fragment.c
modules/brotli/enc/compress_fragment_two_pass.c
modules/brotli/enc/encode.c
modules/brotli/enc/fast_log.h
modules/brotli/enc/find_match_length.h
modules/brotli/enc/hash.h
modules/brotli/enc/hash_forgetful_chain_inc.h
modules/brotli/enc/hash_longest_match64_inc.h
modules/brotli/enc/hash_longest_match_inc.h
modules/brotli/enc/hash_longest_match_quickly_inc.h
modules/brotli/enc/hash_to_binary_tree_inc.h
modules/brotli/enc/memory.h
modules/brotli/enc/port.h
modules/brotli/enc/write_bits.h
modules/brotli/include/brotli/decode.h
modules/brotli/include/brotli/encode.h
modules/brotli/moz.build
modules/brotli/tools/bro.c
modules/brotli/tools/brotli.c
modules/brotli/tools/brotli.md
modules/brotli/update.sh
--- a/modules/brotli/README.mozilla
+++ b/modules/brotli/README.mozilla
@@ -9,9 +9,9 @@ Upstream code can be viewed at
 
 and cloned by
   git clone https://github.com/google/brotli
 
 The in-tree copy is updated by running
   sh update.sh
 from within the modules/brotli directory.
 
-Current version: [commit 46c1a881b41bb638c76247558aa04b1591af3aa7].
+Current version: [commit 5b4769990dc14a2bd466d2599c946c5652cba4b2].
--- a/modules/brotli/common/constants.h
+++ b/modules/brotli/common/constants.h
@@ -33,16 +33,18 @@
 #define BROTLI_MAX_NPOSTFIX 3
 #define BROTLI_MAX_NDIRECT 120
 #define BROTLI_MAX_DISTANCE_BITS 24U
 /* BROTLI_NUM_DISTANCE_SYMBOLS == 520 */
 #define BROTLI_NUM_DISTANCE_SYMBOLS (BROTLI_NUM_DISTANCE_SHORT_CODES + \
                                      BROTLI_MAX_NDIRECT +              \
                                      (BROTLI_MAX_DISTANCE_BITS <<      \
                                       (BROTLI_MAX_NPOSTFIX + 1)))
+/* Distance that is guaranteed to be representable in any stream. */
+#define BROTLI_MAX_DISTANCE 0x3FFFFFC
 
 /* 7.1. Context modes and context ID lookup for literals */
 /* "context IDs for literals are in the range of 0..63" */
 #define BROTLI_LITERAL_CONTEXT_BITS 6
 
 /* 7.2. Context ID for distances */
 #define BROTLI_DISTANCE_CONTEXT_BITS 2
 
new file mode 100755
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..a585c0e292eba19e594ef95f5c4fb38fcb1f7a84
GIT binary patch
literal 122784
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
--- a/modules/brotli/common/dictionary.c
+++ b/modules/brotli/common/dictionary.c
@@ -5,34 +5,18 @@
 */
 
 #include "./dictionary.h"
 
 #if defined(__cplusplus) || defined(c_plusplus)
 extern "C" {
 #endif
 
-static const BrotliDictionary kBrotliDictionary = {
-  /* size_bits_by_length */
-  {
-    0, 0, 0, 0, 10, 10, 11, 11,
-    10, 10, 10, 10, 10, 9, 9, 8,
-    7, 7, 8, 7, 7, 6, 6, 5,
-    5, 0, 0, 0, 0, 0, 0, 0
-  },
-
-  /* offsets_by_length */
-  {
-    0, 0, 0, 0, 0, 4096, 9216, 21504,
-    35840, 44032, 53248, 63488, 74752, 87040, 93696, 100864,
-    104704, 106752, 108928, 113536, 115968, 118528, 119872, 121280,
-    122016, 122784, 122784, 122784, 122784, 122784, 122784, 122784
-  },
-
-  /* data */
+#ifndef BROTLI_EXTERNAL_DICTIONARY_DATA
+static const uint8_t kBrotliDictionaryData[] =
 {
 116,105,109,101,100,111,119,110,108,105,102,101,108,101,102,116,98,97,99,107,99,
 111,100,101,100,97,116,97,115,104,111,119,111,110,108,121,115,105,116,101,99,105
 ,116,121,111,112,101,110,106,117,115,116,108,105,107,101,102,114,101,101,119,111
 ,114,107,116,101,120,116,121,101,97,114,111,118,101,114,98,111,100,121,108,111,
 118,101,102,111,114,109,98,111,111,107,112,108,97,121,108,105,118,101,108,105,
 110,101,104,101,108,112,104,111,109,101,115,105,100,101,109,111,114,101,119,111,
 114,100,108,111,110,103,116,104,101,109,118,105,101,119,102,105,110,100,112,97,
@@ -5870,17 +5854,52 @@ 39,116,101,120,116,47,106,97,118,97,115,
 ,224,164,184,224,164,191,224,164,130,224,164,151,224,164,184,224,165,129,224,164
 ,176,224,164,149,224,165,141,224,164,183,224,164,191,224,164,164,224,164,149,224
 ,165,137,224,164,170,224,165,128,224,164,176,224,164,190,224,164,135,224,164,159
 ,224,164,181,224,164,191,224,164,156,224,165,141,224,164,158,224,164,190,224,164
 ,170,224,164,168,224,164,149,224,164,190,224,164,176,224,165,141,224,164,176,224
 ,164,181,224,164,190,224,164,136,224,164,184,224,164,149,224,165,141,224,164,176
 ,224,164,191,224,164,175,224,164,164,224,164,190
 }
+;
+#endif  /* !BROTLI_EXTERNAL_DICTIONARY_DATA */
+
+static BrotliDictionary kBrotliDictionary = {
+  /* size_bits_by_length */
+  {
+    0, 0, 0, 0, 10, 10, 11, 11,
+    10, 10, 10, 10, 10, 9, 9, 8,
+    7, 7, 8, 7, 7, 6, 6, 5,
+    5, 0, 0, 0, 0, 0, 0, 0
+  },
+
+  /* offsets_by_length */
+  {
+    0, 0, 0, 0, 0, 4096, 9216, 21504,
+    35840, 44032, 53248, 63488, 74752, 87040, 93696, 100864,
+    104704, 106752, 108928, 113536, 115968, 118528, 119872, 121280,
+    122016, 122784, 122784, 122784, 122784, 122784, 122784, 122784
+  },
+
+  /* data_size ==  sizeof(kBrotliDictionaryData) */
+  122784,
+
+  /* data */
+#ifdef BROTLI_EXTERNAL_DICTIONARY_DATA
+  NULL
+#else
+  kBrotliDictionaryData
+#endif
 };
 
 const BrotliDictionary* BrotliGetDictionary() {
   return &kBrotliDictionary;
 }
 
+void BrotliSetDictionaryData(const uint8_t* data) {
+  if (!!data && !kBrotliDictionary.data) {
+    kBrotliDictionary.data = data;
+  }
+}
+
 #if defined(__cplusplus) || defined(c_plusplus)
 }  /* extern "C" */
 #endif
--- a/modules/brotli/common/dictionary.h
+++ b/modules/brotli/common/dictionary.h
@@ -22,29 +22,43 @@ typedef struct BrotliDictionary {
    *
    * Specification: Appendix A. Static Dictionary Data
    *
    * Words in a dictionary are bucketed by length.
    * @c 0 means that there are no words of a given length.
    * Dictionary consists of words with length of [4..24] bytes.
    * Values at [0..3] and [25..31] indices should not be addressed.
    */
-  uint8_t size_bits_by_length[32];
+  const uint8_t size_bits_by_length[32];
 
   /* assert(offset[i + 1] == offset[i] + (bits[i] ? (i << bits[i]) : 0)) */
-  uint32_t offsets_by_length[32];
+  const uint32_t offsets_by_length[32];
+
+  /* assert(data_size == offsets_by_length[31]) */
+  const size_t data_size;
 
   /* Data array is not bound, and should obey to size_bits_by_length values.
-     Specified size matches default (RFC 7932) dictionary. */
-  /* assert(sizeof(data) == offsets_by_length[31]) */
-  uint8_t data[122784];
+     Specified size matches default (RFC 7932) dictionary. Its size is
+     defined by data_size */
+  const uint8_t* data;
 } BrotliDictionary;
 
 BROTLI_COMMON_API extern const BrotliDictionary* BrotliGetDictionary(void);
 
+/**
+ * Sets dictionary data.
+ *
+ * When dictionary data is already set / present, this method is no-op.
+ *
+ * Dictionary data MUST be provided before BrotliGetDictionary is invoked.
+ * This method is used ONLY in multi-client environment (e.g. C + Java),
+ * to reduce storage by sharing single dictionary between implementations.
+ */
+BROTLI_COMMON_API void BrotliSetDictionaryData(const uint8_t* data);
+
 #define BROTLI_MIN_DICTIONARY_WORD_LENGTH 4
 #define BROTLI_MAX_DICTIONARY_WORD_LENGTH 24
 
 #if defined(__cplusplus) || defined(c_plusplus)
 }  /* extern "C" */
 #endif
 
 #endif  /* BROTLI_COMMON_DICTIONARY_H_ */
--- a/modules/brotli/common/version.h
+++ b/modules/brotli/common/version.h
@@ -9,11 +9,11 @@
 #ifndef BROTLI_COMMON_VERSION_H_
 #define BROTLI_COMMON_VERSION_H_
 
 /* This macro should only be used when library is compiled together with client.
    If library is dynamically linked, use BrotliDecoderVersion and
    BrotliEncoderVersion methods. */
 
 /* Semantic version, calculated as (MAJOR << 24) | (MINOR << 12) | PATCH */
-#define BROTLI_VERSION 0x0006000
+#define BROTLI_VERSION 0x1000001
 
 #endif  /* BROTLI_COMMON_VERSION_H_ */
--- a/modules/brotli/dec/decode.c
+++ b/modules/brotli/dec/decode.c
@@ -34,44 +34,59 @@ extern "C" {
   BROTLI_LOG(("[%s] %s = %lu\n", __func__, #name, (unsigned long)(name)))
 #define BROTLI_LOG_ARRAY_INDEX(array_name, idx)                     \
   BROTLI_LOG(("[%s] %s[%lu] = %lu\n", __func__, #array_name,        \
          (unsigned long)(idx), (unsigned long)array_name[idx]))
 
 #define HUFFMAN_TABLE_BITS 8U
 #define HUFFMAN_TABLE_MASK 0xff
 
+/* We need the slack region for the following reasons:
+    - doing up to two 16-byte copies for fast backward copying
+    - inserting transformed dictionary word (5 prefix + 24 base + 8 suffix) */
+static const uint32_t kRingBufferWriteAheadSlack = 42;
+
 static const uint8_t kCodeLengthCodeOrder[BROTLI_CODE_LENGTH_CODES] = {
   1, 2, 3, 4, 0, 5, 17, 6, 16, 7, 8, 9, 10, 11, 12, 13, 14, 15,
 };
 
 /* Static prefix code for the complex code length code lengths. */
 static const uint8_t kCodeLengthPrefixLength[16] = {
   2, 2, 2, 3, 2, 2, 2, 4, 2, 2, 2, 3, 2, 2, 2, 4,
 };
 
 static const uint8_t kCodeLengthPrefixValue[16] = {
   0, 4, 3, 2, 0, 4, 3, 1, 0, 4, 3, 2, 0, 4, 3, 5,
 };
 
+BROTLI_BOOL BrotliDecoderSetParameter(
+    BrotliDecoderState* state, BrotliDecoderParameter p, uint32_t value) {
+  switch (p) {
+    case BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION:
+      state->canny_ringbuffer_allocation = !!value ? 0 : 1;
+      return BROTLI_TRUE;
+
+    default: return BROTLI_FALSE;
+  }
+}
+
 BrotliDecoderState* BrotliDecoderCreateInstance(
     brotli_alloc_func alloc_func, brotli_free_func free_func, void* opaque) {
   BrotliDecoderState* state = 0;
   if (!alloc_func && !free_func) {
     state = (BrotliDecoderState*)malloc(sizeof(BrotliDecoderState));
   } else if (alloc_func && free_func) {
     state = (BrotliDecoderState*)alloc_func(opaque, sizeof(BrotliDecoderState));
   }
   if (state == 0) {
     BROTLI_DUMP();
     return 0;
   }
   BrotliDecoderStateInitWithCustomAllocators(
       state, alloc_func, free_func, opaque);
-  state->error_code = BROTLI_DECODER_NO_ERROR;
   return state;
 }
 
 /* Deinitializes and frees BrotliDecoderState instance. */
 void BrotliDecoderDestroyInstance(BrotliDecoderState* state) {
   if (!state) {
     return;
   } else {
@@ -1206,17 +1221,19 @@ static BrotliDecoderErrorCode BROTLI_NOI
       memcpy(*next_out, start, num_written);
       *next_out += num_written;
     }
   }
   *available_out -= num_written;
   BROTLI_LOG_UINT(to_write);
   BROTLI_LOG_UINT(num_written);
   s->partial_pos_out += num_written;
-  if (total_out) *total_out = s->partial_pos_out - (size_t)s->custom_dict_size;
+  if (total_out) {
+    *total_out = s->partial_pos_out;
+  }
   if (num_written < to_write) {
     if (s->ringbuffer_size == (1 << s->window_bits) || force) {
       return BROTLI_DECODER_NEEDS_MORE_OUTPUT;
     } else {
       return BROTLI_DECODER_SUCCESS;
     }
   }
   /* Wrap ring buffer only if it has reached its maximal size. */
@@ -1238,47 +1255,35 @@ static void BROTLI_NOINLINE WrapRingBuff
 
 /* Allocates ring-buffer.
 
    s->ringbuffer_size MUST be updated by BrotliCalculateRingBufferSize before
    this function is called.
 
    Last two bytes of ring-buffer are initialized to 0, so context calculation
    could be done uniformly for the first two and all other positions.
-
-   Custom dictionary, if any, is copied to the end of ring-buffer.
 */
 static BROTLI_BOOL BROTLI_NOINLINE BrotliEnsureRingBuffer(
     BrotliDecoderState* s) {
-  /* We need the slack region for the following reasons:
-      - doing up to two 16-byte copies for fast backward copying
-      - inserting transformed dictionary word (5 prefix + 24 base + 8 suffix) */
-  static const int kRingBufferWriteAheadSlack = 42;
   uint8_t* old_ringbuffer = s->ringbuffer;
   if (s->ringbuffer_size == s->new_ringbuffer_size) {
     return BROTLI_TRUE;
   }
 
-  s->ringbuffer = (uint8_t*)BROTLI_ALLOC(s, (size_t)(s->new_ringbuffer_size +
-      kRingBufferWriteAheadSlack));
+  s->ringbuffer = (uint8_t*)BROTLI_ALLOC(s, (size_t)(s->new_ringbuffer_size) +
+      kRingBufferWriteAheadSlack);
   if (s->ringbuffer == 0) {
     /* Restore previous value. */
     s->ringbuffer = old_ringbuffer;
     return BROTLI_FALSE;
   }
   s->ringbuffer[s->new_ringbuffer_size - 2] = 0;
   s->ringbuffer[s->new_ringbuffer_size - 1] = 0;
 
-  if (!old_ringbuffer) {
-    if (s->custom_dict) {
-      memcpy(s->ringbuffer, s->custom_dict, (size_t)s->custom_dict_size);
-      s->partial_pos_out = (size_t)s->custom_dict_size;
-      s->pos = s->custom_dict_size;
-    }
-  } else {
+  if (!!old_ringbuffer) {
     memcpy(s->ringbuffer, old_ringbuffer, (size_t)s->pos);
     BROTLI_FREE(s, old_ringbuffer);
   }
 
   s->ringbuffer_size = s->new_ringbuffer_size;
   s->ringbuffer_mask = s->new_ringbuffer_size - 1;
   s->ringbuffer_end = s->ringbuffer + s->ringbuffer_size;
 
@@ -1357,26 +1362,30 @@ static void BROTLI_NOINLINE BrotliCalcul
   }
 
   /* Metadata blocks does not touch ring buffer. */
   if (s->is_metadata) {
     return;
   }
 
   if (!s->ringbuffer) {
-    /* Custom dictionary counts as a "virtual" output. */
-    output_size = s->custom_dict_size;
+    output_size = 0;
   } else {
     output_size = s->pos;
   }
   output_size += s->meta_block_remaining_len;
   min_size = min_size < output_size ? output_size : min_size;
 
-  while ((new_ringbuffer_size >> 1) >= min_size) {
-    new_ringbuffer_size >>= 1;
+  if (!!s->canny_ringbuffer_allocation) {
+    /* Reduce ring buffer size to save memory when server is unscrupulous.
+       In worst case memory usage might be 1.5x bigger for a short period of
+       ring buffer reallocation.*/
+    while ((new_ringbuffer_size >> 1) >= min_size) {
+      new_ringbuffer_size >>= 1;
+    }
   }
 
   s->new_ringbuffer_size = new_ringbuffer_size;
 }
 
 /* Reads 1..256 2-bit context modes. */
 static BrotliDecoderErrorCode ReadContextModes(BrotliDecoderState* s) {
   BrotliBitReader* br = &s->br;
@@ -1731,27 +1740,30 @@ CommandPostDecodeLiterals:
   if (s->max_distance != s->max_backward_distance) {
     s->max_distance =
         (pos < s->max_backward_distance) ? pos : s->max_backward_distance;
   }
   i = s->copy_length;
   /* Apply copy of LZ77 back-reference, or static dictionary reference if
   the distance is larger than the max LZ77 distance */
   if (s->distance_code > s->max_distance) {
+    int address = s->distance_code - s->max_distance - 1;
     if (i >= BROTLI_MIN_DICTIONARY_WORD_LENGTH &&
         i <= BROTLI_MAX_DICTIONARY_WORD_LENGTH) {
       int offset = (int)s->dictionary->offsets_by_length[i];
-      int word_id = s->distance_code - s->max_distance - 1;
       uint32_t shift = s->dictionary->size_bits_by_length[i];
       int mask = (int)BitMask(shift);
-      int word_idx = word_id & mask;
-      int transform_idx = word_id >> shift;
+      int word_idx = address & mask;
+      int transform_idx = address >> shift;
       /* Compensate double distance-ring-buffer roll. */
       s->dist_rb_idx += s->distance_context;
       offset += word_idx * i;
+      if (BROTLI_PREDICT_FALSE(!s->dictionary->data)) {
+        return BROTLI_FAILURE(BROTLI_DECODER_ERROR_DICTIONARY_NOT_SET);
+      }
       if (transform_idx < kNumTransforms) {
         const uint8_t* word = &s->dictionary->data[offset];
         int len = i;
         if (transform_idx == 0) {
           memcpy(&s->ringbuffer[pos], word, (size_t)len);
           BROTLI_LOG(("[ProcessCommandsInternal] dictionary word: [%.*s]\n",
                       len, word));
         } else {
@@ -1894,16 +1906,20 @@ BrotliDecoderResult BrotliDecoderDecompr
     * when result is "success" decoder MUST return all unused data back to input
       buffer; this is possible because the invariant is hold on enter
 */
 BrotliDecoderResult BrotliDecoderDecompressStream(
     BrotliDecoderState* s, size_t* available_in, const uint8_t** next_in,
     size_t* available_out, uint8_t** next_out, size_t* total_out) {
   BrotliDecoderErrorCode result = BROTLI_DECODER_SUCCESS;
   BrotliBitReader* br = &s->br;
+  /* Do not try to process further in a case of unrecoverable error. */
+  if ((int)s->error_code < 0) {
+    return BROTLI_DECODER_RESULT_ERROR;
+  }
   if (*available_out && (!next_out || !*next_out)) {
     return SaveErrorCode(
         s, BROTLI_FAILURE(BROTLI_DECODER_ERROR_INVALID_ARGUMENTS));
   }
   if (!*available_out) next_out = 0;
   if (s->buffer_length == 0) { /* Just connect bit reader to input stream. */
     br->avail_in = *available_in;
     br->next_in = *next_in;
@@ -1914,17 +1930,23 @@ BrotliDecoderResult BrotliDecoderDecompr
     result = BROTLI_DECODER_NEEDS_MORE_INPUT;
     br->next_in = &s->buffer.u8[0];
   }
   /* State machine */
   for (;;) {
     if (result != BROTLI_DECODER_SUCCESS) { /* Error, needs more input/output */
       if (result == BROTLI_DECODER_NEEDS_MORE_INPUT) {
         if (s->ringbuffer != 0) { /* Pro-actively push output. */
-          WriteRingBuffer(s, available_out, next_out, total_out, BROTLI_TRUE);
+          BrotliDecoderErrorCode intermediate_result = WriteRingBuffer(s,
+              available_out, next_out, total_out, BROTLI_TRUE);
+          /* WriteRingBuffer checks s->meta_block_remaining_len validity. */
+          if ((int)intermediate_result < 0) {
+            result = intermediate_result;
+            break;
+          }
         }
         if (s->buffer_length != 0) { /* Used with internal buffer. */
           if (br->avail_in == 0) { /* Successfully finished read transaction. */
             /* Accumulator contains less than 8 bits, because internal buffer
                is expanded byte-by-byte until it is enough to complete read. */
             s->buffer_length = 0;
             /* Switch to input stream and restart. */
             result = BROTLI_DECODER_SUCCESS;
@@ -1988,21 +2010,16 @@ BrotliDecoderResult BrotliDecoderDecompr
         BROTLI_LOG_UINT(s->window_bits);
         if (s->window_bits == 9) {
           /* Value 9 is reserved for future use. */
           result = BROTLI_FAILURE(BROTLI_DECODER_ERROR_FORMAT_WINDOW_BITS);
           break;
         }
         /* Maximum distance, see section 9.1. of the spec. */
         s->max_backward_distance = (1 << s->window_bits) - BROTLI_WINDOW_GAP;
-        /* Limit custom dictionary size. */
-        if (s->custom_dict_size >= s->max_backward_distance) {
-          s->custom_dict += s->custom_dict_size - s->max_backward_distance;
-          s->custom_dict_size = s->max_backward_distance;
-        }
 
         /* Allocate memory for both block_type_trees and block_len_trees. */
         s->block_type_trees = (HuffmanCode*)BROTLI_ALLOC(s,
             sizeof(HuffmanCode) * 3 *
                 (BROTLI_HUFFMAN_MAX_SIZE_258 + BROTLI_HUFFMAN_MAX_SIZE_26));
         if (s->block_type_trees == 0) {
           result = BROTLI_FAILURE(BROTLI_DECODER_ERROR_ALLOC_BLOCK_TYPE_TREES);
           break;
@@ -2289,46 +2306,44 @@ BrotliDecoderResult BrotliDecoderDecompr
           }
         }
         return SaveErrorCode(s, result);
     }
   }
   return SaveErrorCode(s, result);
 }
 
-void BrotliDecoderSetCustomDictionary(
-    BrotliDecoderState* s, size_t size, const uint8_t* dict) {
-  if (size > (1u << 24)) {
-    return;
+BROTLI_BOOL BrotliDecoderHasMoreOutput(const BrotliDecoderState* s) {
+  /* After unrecoverable error remaining output is considered nonsensical. */
+  if ((int)s->error_code < 0) {
+    return BROTLI_FALSE;
   }
-  s->custom_dict = dict;
-  s->custom_dict_size = (int)size;
-}
-
-BROTLI_BOOL BrotliDecoderHasMoreOutput(const BrotliDecoderState* s) {
   return TO_BROTLI_BOOL(
       s->ringbuffer != 0 && UnwrittenBytes(s, BROTLI_FALSE) != 0);
 }
 
 const uint8_t* BrotliDecoderTakeOutput(BrotliDecoderState* s, size_t* size) {
   uint8_t* result = 0;
   size_t available_out = *size ? *size : 1u << 24;
   size_t requested_out = available_out;
   BrotliDecoderErrorCode status;
-  if (s->ringbuffer == 0) {
+  if ((s->ringbuffer == 0) || ((int)s->error_code < 0)) {
     *size = 0;
     return 0;
   }
   WrapRingBuffer(s);
   status = WriteRingBuffer(s, &available_out, &result, 0, BROTLI_TRUE);
+  /* Either WriteRingBuffer returns those "success" codes... */
   if (status == BROTLI_DECODER_SUCCESS ||
       status == BROTLI_DECODER_NEEDS_MORE_OUTPUT) {
     *size = requested_out - available_out;
   } else {
-    /* This might happen if previous decoder error code was ignored. */
+    /* ... or stream is broken. Normally this should be caught by
+       BrotliDecoderDecompressStream, this is just a safeguard. */
+    if ((int)status < 0) SaveErrorCode(s, status);
     *size = 0;
     result = 0;
   }
   return result;
 }
 
 BROTLI_BOOL BrotliDecoderIsUsed(const BrotliDecoderState* s) {
   return TO_BROTLI_BOOL(s->state != BROTLI_STATE_UNINITED ||
--- a/modules/brotli/dec/state.c
+++ b/modules/brotli/dec/state.c
@@ -36,16 +36,18 @@ void BrotliDecoderStateInitWithCustomAll
     s->free_func = DefaultFreeFunc;
     s->memory_manager_opaque = 0;
   } else {
     s->alloc_func = alloc_func;
     s->free_func = free_func;
     s->memory_manager_opaque = opaque;
   }
 
+  s->error_code = 0; /* BROTLI_DECODER_NO_ERROR */
+
   BrotliInitBitReader(&s->br);
   s->state = BROTLI_STATE_UNINITED;
   s->substate_metablock_header = BROTLI_STATE_METABLOCK_HEADER_NONE;
   s->substate_tree_group = BROTLI_STATE_TREE_GROUP_NONE;
   s->substate_context_map = BROTLI_STATE_CONTEXT_MAP_NONE;
   s->substate_uncompressed = BROTLI_STATE_UNCOMPRESSED_NONE;
   s->substate_huffman = BROTLI_STATE_HUFFMAN_NONE;
   s->substate_decode_uint8 = BROTLI_STATE_DECODE_UINT8_NONE;
@@ -76,21 +78,22 @@ void BrotliDecoderStateInitWithCustomAll
 
   s->literal_hgroup.codes = NULL;
   s->literal_hgroup.htrees = NULL;
   s->insert_copy_hgroup.codes = NULL;
   s->insert_copy_hgroup.htrees = NULL;
   s->distance_hgroup.codes = NULL;
   s->distance_hgroup.htrees = NULL;
 
-  s->custom_dict = NULL;
-  s->custom_dict_size = 0;
+  s->is_last_metablock = 0;
+  s->is_uncompressed = 0;
+  s->is_metadata = 0;
+  s->should_wrap_ringbuffer = 0;
+  s->canny_ringbuffer_allocation = 1;
 
-  s->is_last_metablock = 0;
-  s->should_wrap_ringbuffer = 0;
   s->window_bits = 0;
   s->max_distance = 0;
   s->dist_rb[0] = 16;
   s->dist_rb[1] = 15;
   s->dist_rb[2] = 11;
   s->dist_rb[3] = 4;
   s->dist_rb_idx = 0;
   s->block_type_trees = NULL;
--- a/modules/brotli/dec/state.h
+++ b/modules/brotli/dec/state.h
@@ -167,17 +167,17 @@ struct BrotliDecoderStateStruct {
   size_t partial_pos_out;  /* How much output to the user in total */
 
   /* For ReadHuffmanCode */
   uint32_t symbol;
   uint32_t repeat;
   uint32_t space;
 
   HuffmanCode table[32];
-  /* List of of symbol chains. */
+  /* List of heads of symbol chains. */
   uint16_t* symbol_lists;
   /* Storage from symbol_lists. */
   uint16_t symbols_lists_array[BROTLI_HUFFMAN_MAX_CODE_LENGTH + 1 +
                                BROTLI_NUM_COMMAND_SYMBOLS];
   /* Tails of symbol chains. */
   int next_symbol[32];
   uint8_t code_length_code_lengths[BROTLI_CODE_LENGTH_CODES];
   /* Population counts for the code lengths */
@@ -192,34 +192,31 @@ struct BrotliDecoderStateStruct {
   uint32_t max_run_length_prefix;
   uint32_t code;
   HuffmanCode context_map_table[BROTLI_HUFFMAN_MAX_SIZE_272];
 
   /* For InverseMoveToFrontTransform */
   uint32_t mtf_upper_bound;
   uint32_t mtf[64 + 1];
 
-  /* For custom dictionaries */
-  const uint8_t* custom_dict;
-  int custom_dict_size;
-
   /* less used attributes are in the end of this struct */
   /* States inside function calls */
   BrotliRunningMetablockHeaderState substate_metablock_header;
   BrotliRunningTreeGroupState substate_tree_group;
   BrotliRunningContextMapState substate_context_map;
   BrotliRunningUncompressedState substate_uncompressed;
   BrotliRunningHuffmanState substate_huffman;
   BrotliRunningDecodeUint8State substate_decode_uint8;
   BrotliRunningReadBlockLengthState substate_read_block_length;
 
   unsigned int is_last_metablock : 1;
   unsigned int is_uncompressed : 1;
   unsigned int is_metadata : 1;
   unsigned int should_wrap_ringbuffer : 1;
+  unsigned int canny_ringbuffer_allocation : 1;
   unsigned int size_nibbles : 8;
   uint32_t window_bits;
 
   int new_ringbuffer_size;
 
   uint32_t num_literal_htrees;
   uint8_t* context_map;
   uint8_t* context_modes;
--- a/modules/brotli/enc/backward_references.c
+++ b/modules/brotli/enc/backward_references.c
@@ -43,16 +43,18 @@ static BROTLI_INLINE size_t ComputeDista
     }
   }
   return distance + BROTLI_NUM_DISTANCE_SHORT_CODES - 1;
 }
 
 #define EXPAND_CAT(a, b) CAT(a, b)
 #define CAT(a, b) a ## b
 #define FN(X) EXPAND_CAT(X, HASHER())
+#define EXPORT_FN(X) EXPAND_CAT(X, EXPAND_CAT(PREFIX(), HASHER()))
+#define PREFIX() N
 
 #define HASHER() H2
 /* NOLINTNEXTLINE(build/include) */
 #include "./backward_references_inc.h"
 #undef HASHER
 
 #define HASHER() H3
 /* NOLINTNEXTLINE(build/include) */
@@ -89,16 +91,18 @@ static BROTLI_INLINE size_t ComputeDista
 #include "./backward_references_inc.h"
 #undef HASHER
 
 #define HASHER() H54
 /* NOLINTNEXTLINE(build/include) */
 #include "./backward_references_inc.h"
 #undef HASHER
 
+#undef PREFIX
+#undef EXPORT_FN
 #undef FN
 #undef CAT
 #undef EXPAND_CAT
 
 void BrotliCreateBackwardReferences(const BrotliDictionary* dictionary,
                                     size_t num_bytes,
                                     size_t position,
                                     const uint8_t* ringbuffer,
@@ -108,21 +112,21 @@ void BrotliCreateBackwardReferences(cons
                                     int* dist_cache,
                                     size_t* last_insert_len,
                                     Command* commands,
                                     size_t* num_commands,
                                     size_t* num_literals) {
   switch (params->hasher.type) {
 #define CASE_(N)                                                  \
     case N:                                                       \
-      CreateBackwardReferencesH ## N(dictionary,                  \
+      CreateBackwardReferencesNH ## N(dictionary,                 \
           kStaticDictionaryHash, num_bytes, position, ringbuffer, \
           ringbuffer_mask, params, hasher, dist_cache,            \
           last_insert_len, commands, num_commands, num_literals); \
-      break;
+      return;
     FOR_GENERIC_HASHERS(CASE_)
 #undef CASE_
     default:
       break;
   }
 }
 
 #if defined(__cplusplus) || defined(c_plusplus)
--- a/modules/brotli/enc/backward_references_hq.c
+++ b/modules/brotli/enc/backward_references_hq.c
@@ -295,29 +295,30 @@ static size_t ComputeMinimumCopyLength(c
   return len;
 }
 
 /* REQUIRES: nodes[pos].cost < kInfinity
    REQUIRES: nodes[0..pos] satisfies that "ZopfliNode array invariant". */
 static uint32_t ComputeDistanceShortcut(const size_t block_start,
                                         const size_t pos,
                                         const size_t max_backward,
+                                        const size_t gap,
                                         const ZopfliNode* nodes) {
   const size_t clen = ZopfliNodeCopyLength(&nodes[pos]);
   const size_t ilen = nodes[pos].insert_length;
   const size_t dist = ZopfliNodeCopyDistance(&nodes[pos]);
   /* Since |block_start + pos| is the end position of the command, the copy part
      starts from |block_start + pos - clen|. Distances that are greater than
      this or greater than |max_backward| are static dictionary references, and
      do not update the last distances. Also distance code 0 (last distance)
      does not update the last distances. */
   if (pos == 0) {
     return 0;
-  } else if (dist + clen <= block_start + pos &&
-             dist <= max_backward &&
+  } else if (dist + clen <= block_start + pos + gap &&
+             dist <= max_backward + gap &&
              ZopfliNodeDistanceCode(&nodes[pos]) > 0) {
     return (uint32_t)pos;
   } else {
     return nodes[pos - clen - ilen].u.shortcut;
   }
 }
 
 /* Fills in dist_cache[0..3] with the last four distances (as defined by
@@ -345,22 +346,22 @@ static void ComputeDistanceCache(const s
     dist_cache[idx] = *starting_dist_cache++;
   }
 }
 
 /* Maintains "ZopfliNode array invariant" and pushes node to the queue, if it
    is eligible. */
 static void EvaluateNode(
     const size_t block_start, const size_t pos, const size_t max_backward_limit,
-    const int* starting_dist_cache, const ZopfliCostModel* model,
-    StartPosQueue* queue, ZopfliNode* nodes) {
+    const size_t gap, const int* starting_dist_cache,
+    const ZopfliCostModel* model, StartPosQueue* queue, ZopfliNode* nodes) {
   /* Save cost, because ComputeDistanceCache invalidates it. */
   float node_cost = nodes[pos].u.cost;
   nodes[pos].u.shortcut = ComputeDistanceShortcut(
-      block_start, pos, max_backward_limit, nodes);
+      block_start, pos, max_backward_limit, gap, nodes);
   if (node_cost <= ZopfliCostModelGetLiteralCosts(model, 0, pos)) {
     PosData posdata;
     posdata.pos = pos;
     posdata.cost = node_cost;
     posdata.costdiff = node_cost -
         ZopfliCostModelGetLiteralCosts(model, 0, pos);
     ComputeDistanceCache(
         pos, starting_dist_cache, nodes, posdata.distance_cache);
@@ -380,19 +381,20 @@ static size_t UpdateNodes(
   const size_t cur_ix_masked = cur_ix & ringbuffer_mask;
   const size_t max_distance = BROTLI_MIN(size_t, cur_ix, max_backward_limit);
   const size_t max_len = num_bytes - pos;
   const size_t max_zopfli_len = MaxZopfliLen(params);
   const size_t max_iters = MaxZopfliCandidates(params);
   size_t min_len;
   size_t result = 0;
   size_t k;
+  size_t gap = 0;
 
-  EvaluateNode(block_start, pos, max_backward_limit, starting_dist_cache, model,
-               queue, nodes);
+  EvaluateNode(block_start, pos, max_backward_limit, gap, starting_dist_cache,
+      model, queue, nodes);
 
   {
     const PosData* posdata = StartPosQueueAt(queue, 0);
     float min_cost = (posdata->cost + ZopfliCostModelGetMinCostCmd(model) +
         ZopfliCostModelGetLiteralCosts(model, posdata->pos, pos));
     min_len = ComputeMinimumCopyLength(min_cost, nodes, num_bytes, pos);
   }
 
@@ -410,35 +412,41 @@ static size_t UpdateNodes(
        starting position. */
     size_t best_len = min_len - 1;
     size_t j = 0;
     for (; j < BROTLI_NUM_DISTANCE_SHORT_CODES && best_len < max_len; ++j) {
       const size_t idx = kDistanceCacheIndex[j];
       const size_t backward =
           (size_t)(posdata->distance_cache[idx] + kDistanceCacheOffset[j]);
       size_t prev_ix = cur_ix - backward;
-      if (prev_ix >= cur_ix) {
-        continue;
+      size_t len = 0;
+      uint8_t continuation = ringbuffer[cur_ix_masked + best_len];
+      if (cur_ix_masked + best_len > ringbuffer_mask) {
+        break;
       }
-      if (BROTLI_PREDICT_FALSE(backward > max_distance)) {
+      if (BROTLI_PREDICT_FALSE(backward > max_distance + gap)) {
         continue;
       }
-      prev_ix &= ringbuffer_mask;
+      if (backward <= max_distance) {
+        if (prev_ix >= cur_ix) {
+          continue;
+        }
 
-      if (cur_ix_masked + best_len > ringbuffer_mask ||
-          prev_ix + best_len > ringbuffer_mask ||
-          ringbuffer[cur_ix_masked + best_len] !=
-              ringbuffer[prev_ix + best_len]) {
+        prev_ix &= ringbuffer_mask;
+        if (prev_ix + best_len > ringbuffer_mask ||
+            continuation != ringbuffer[prev_ix + best_len]) {
+          continue;
+        }
+        len = FindMatchLengthWithLimit(&ringbuffer[prev_ix],
+                                       &ringbuffer[cur_ix_masked],
+                                       max_len);
+      } else {
         continue;
       }
       {
-        const size_t len =
-            FindMatchLengthWithLimit(&ringbuffer[prev_ix],
-                                     &ringbuffer[cur_ix_masked],
-                                     max_len);
         const float dist_cost = base_cost +
             ZopfliCostModelGetDistanceCost(model, j);
         size_t l;
         for (l = best_len + 1; l <= len; ++l) {
           const uint16_t copycode = GetCopyLengthCode(l);
           const uint16_t cmdcode =
               CombineLengthCodes(inscode, copycode, j == 0);
           const float cost = (cmdcode < 128 ? base_cost : dist_cost) +
@@ -459,17 +467,18 @@ static size_t UpdateNodes(
     if (k >= 2) continue;
 
     {
       /* Loop through all possible copy lengths at this position. */
       size_t len = min_len;
       for (j = 0; j < num_matches; ++j) {
         BackwardMatch match = matches[j];
         size_t dist = match.distance;
-        BROTLI_BOOL is_dictionary_match = TO_BROTLI_BOOL(dist > max_distance);
+        BROTLI_BOOL is_dictionary_match =
+            TO_BROTLI_BOOL(dist > max_distance + gap);
         /* We already tried all possible last distance matches, so we can use
            normal distance code here. */
         size_t dist_code = dist + BROTLI_NUM_DISTANCE_SHORT_CODES - 1;
         uint16_t dist_symbol;
         uint32_t distextra;
         uint32_t distnumextra;
         float dist_cost;
         size_t max_match_len;
@@ -521,41 +530,44 @@ static size_t ComputeShortestPathFromNod
 
 /* REQUIRES: nodes != NULL and len(nodes) >= num_bytes + 1 */
 void BrotliZopfliCreateCommands(const size_t num_bytes,
                                 const size_t block_start,
                                 const size_t max_backward_limit,
                                 const ZopfliNode* nodes,
                                 int* dist_cache,
                                 size_t* last_insert_len,
+                                const BrotliEncoderParams* params,
                                 Command* commands,
                                 size_t* num_literals) {
   size_t pos = 0;
   uint32_t offset = nodes[0].u.next;
   size_t i;
+  size_t gap = 0;
+  BROTLI_UNUSED(params);
   for (i = 0; offset != BROTLI_UINT32_MAX; i++) {
     const ZopfliNode* next = &nodes[pos + offset];
     size_t copy_length = ZopfliNodeCopyLength(next);
     size_t insert_length = next->insert_length;
     pos += insert_length;
     offset = next->u.next;
     if (i == 0) {
       insert_length += *last_insert_len;
       *last_insert_len = 0;
     }
     {
       size_t distance = ZopfliNodeCopyDistance(next);
       size_t len_code = ZopfliNodeLengthCode(next);
       size_t max_distance =
           BROTLI_MIN(size_t, block_start + pos, max_backward_limit);
-      BROTLI_BOOL is_dictionary = TO_BROTLI_BOOL(distance > max_distance);
+      BROTLI_BOOL is_dictionary = TO_BROTLI_BOOL(distance > max_distance + gap);
       size_t dist_code = ZopfliNodeDistanceCode(next);
 
-      InitCommand(
-          &commands[i], insert_length, copy_length, len_code, dist_code);
+      InitCommand(&commands[i], insert_length,
+          copy_length, (int)len_code - (int)copy_length, dist_code);
 
       if (!is_dictionary && dist_code > 0) {
         dist_cache[3] = dist_cache[2];
         dist_cache[2] = dist_cache[1];
         dist_cache[1] = dist_cache[0];
         dist_cache[0] = (int)distance;
       }
     }
@@ -567,16 +579,17 @@ void BrotliZopfliCreateCommands(const si
 }
 
 static size_t ZopfliIterate(size_t num_bytes,
                             size_t position,
                             const uint8_t* ringbuffer,
                             size_t ringbuffer_mask,
                             const BrotliEncoderParams* params,
                             const size_t max_backward_limit,
+                            const size_t gap,
                             const int* dist_cache,
                             const ZopfliCostModel* model,
                             const uint32_t* num_matches,
                             const BackwardMatch* matches,
                             ZopfliNode* nodes) {
   const size_t max_zopfli_len = MaxZopfliLen(params);
   StartPosQueue queue;
   size_t cur_match_pos = 0;
@@ -595,18 +608,18 @@ static size_t ZopfliIterate(size_t num_b
       skip = BROTLI_MAX(size_t,
           BackwardMatchLength(&matches[cur_match_pos - 1]), skip);
     }
     if (skip > 1) {
       skip--;
       while (skip) {
         i++;
         if (i + 3 >= num_bytes) break;
-        EvaluateNode(
-            position, i, max_backward_limit, dist_cache, model, &queue, nodes);
+        EvaluateNode(position, i, max_backward_limit, gap, dist_cache, model,
+            &queue, nodes);
         cur_match_pos += num_matches[i];
         skip--;
       }
     }
   }
   return ComputeShortestPathFromNodes(num_bytes, nodes);
 }
 
@@ -624,28 +637,30 @@ size_t BrotliZopfliComputeShortestPath(M
                                        ZopfliNode* nodes) {
   const size_t max_zopfli_len = MaxZopfliLen(params);
   ZopfliCostModel model;
   StartPosQueue queue;
   BackwardMatch matches[MAX_NUM_MATCHES_H10];
   const size_t store_end = num_bytes >= StoreLookaheadH10() ?
       position + num_bytes - StoreLookaheadH10() + 1 : position;
   size_t i;
+  size_t gap = 0;
   nodes[0].length = 0;
   nodes[0].u.cost = 0;
   InitZopfliCostModel(m, &model, num_bytes);
   if (BROTLI_IS_OOM(m)) return 0;
   ZopfliCostModelSetFromLiteralCosts(
       &model, position, ringbuffer, ringbuffer_mask);
   InitStartPosQueue(&queue);
   for (i = 0; i + HashTypeLengthH10() - 1 < num_bytes; i++) {
     const size_t pos = position + i;
     const size_t max_distance = BROTLI_MIN(size_t, pos, max_backward_limit);
     size_t num_matches = FindAllMatchesH10(hasher, dictionary, ringbuffer,
-        ringbuffer_mask, pos, num_bytes - i, max_distance, params, matches);
+        ringbuffer_mask, pos, num_bytes - i, max_distance, gap, params,
+        matches);
     size_t skip;
     if (num_matches > 0 &&
         BackwardMatchLength(&matches[num_matches - 1]) > max_zopfli_len) {
       matches[0] = matches[num_matches - 1];
       num_matches = 1;
     }
     skip = UpdateNodes(num_bytes, position, i, ringbuffer, ringbuffer_mask,
         params, max_backward_limit, dist_cache, num_matches, matches, &model,
@@ -657,18 +672,18 @@ size_t BrotliZopfliComputeShortestPath(M
     if (skip > 1) {
       /* Add the tail of the copy to the hasher. */
       StoreRangeH10(hasher, ringbuffer, ringbuffer_mask, pos + 1, BROTLI_MIN(
           size_t, pos + skip, store_end));
       skip--;
       while (skip) {
         i++;
         if (i + HashTypeLengthH10() - 1 >= num_bytes) break;
-        EvaluateNode(
-            position, i, max_backward_limit, dist_cache, &model, &queue, nodes);
+        EvaluateNode(position, i, max_backward_limit, gap, dist_cache, &model,
+            &queue, nodes);
         skip--;
       }
     }
   }
   CleanupZopfliCostModel(m, &model);
   return ComputeShortestPathFromNodes(num_bytes, nodes);
 }
 
@@ -683,17 +698,17 @@ void BrotliCreateZopfliBackwardReference
   nodes = BROTLI_ALLOC(m, ZopfliNode, num_bytes + 1);
   if (BROTLI_IS_OOM(m)) return;
   BrotliInitZopfliNodes(nodes, num_bytes + 1);
   *num_commands += BrotliZopfliComputeShortestPath(m, dictionary, num_bytes,
       position, ringbuffer, ringbuffer_mask, params, max_backward_limit,
       dist_cache, hasher, nodes);
   if (BROTLI_IS_OOM(m)) return;
   BrotliZopfliCreateCommands(num_bytes, position, max_backward_limit, nodes,
-      dist_cache, last_insert_len, commands, num_literals);
+      dist_cache, last_insert_len, params, commands, num_literals);
   BROTLI_FREE(m, nodes);
 }
 
 void BrotliCreateHqZopfliBackwardReferences(
     MemoryManager* m, const BrotliDictionary* dictionary, size_t num_bytes,
     size_t position, const uint8_t* ringbuffer, size_t ringbuffer_mask,
     const BrotliEncoderParams* params, HasherHandle hasher, int* dist_cache,
     size_t* last_insert_len, Command* commands, size_t* num_commands,
@@ -707,37 +722,36 @@ void BrotliCreateHqZopfliBackwardReferen
   size_t i;
   size_t orig_num_literals;
   size_t orig_last_insert_len;
   int orig_dist_cache[4];
   size_t orig_num_commands;
   ZopfliCostModel model;
   ZopfliNode* nodes;
   BackwardMatch* matches = BROTLI_ALLOC(m, BackwardMatch, matches_size);
+  size_t gap = 0;
   if (BROTLI_IS_OOM(m)) return;
   for (i = 0; i + HashTypeLengthH10() - 1 < num_bytes; ++i) {
     const size_t pos = position + i;
     size_t max_distance = BROTLI_MIN(size_t, pos, max_backward_limit);
     size_t max_length = num_bytes - i;
     size_t num_found_matches;
     size_t cur_match_end;
     size_t j;
     /* Ensure that we have enough free slots. */
     BROTLI_ENSURE_CAPACITY(m, BackwardMatch, matches, matches_size,
         cur_match_pos + MAX_NUM_MATCHES_H10);
     if (BROTLI_IS_OOM(m)) return;
     num_found_matches = FindAllMatchesH10(hasher, dictionary, ringbuffer,
-        ringbuffer_mask, pos, max_length, max_distance, params,
+        ringbuffer_mask, pos, max_length, max_distance, gap, params,
         &matches[cur_match_pos]);
     cur_match_end = cur_match_pos + num_found_matches;
     for (j = cur_match_pos; j + 1 < cur_match_end; ++j) {
-      assert(BackwardMatchLength(&matches[j]) <
+      assert(BackwardMatchLength(&matches[j]) <=
           BackwardMatchLength(&matches[j + 1]));
-      assert(matches[j].distance > max_distance ||
-             matches[j].distance <= matches[j + 1].distance);
     }
     num_matches[i] = (uint32_t)num_found_matches;
     if (num_found_matches > 0) {
       const size_t match_len = BackwardMatchLength(&matches[cur_match_end - 1]);
       if (match_len > MAX_ZOPFLI_LEN_QUALITY_11) {
         const size_t skip = match_len - 1;
         matches[cur_match_pos++] = matches[cur_match_end - 1];
         num_matches[i] = 1;
@@ -769,20 +783,20 @@ void BrotliCreateHqZopfliBackwardReferen
           ringbuffer_mask, commands, *num_commands - orig_num_commands,
           orig_last_insert_len);
     }
     *num_commands = orig_num_commands;
     *num_literals = orig_num_literals;
     *last_insert_len = orig_last_insert_len;
     memcpy(dist_cache, orig_dist_cache, 4 * sizeof(dist_cache[0]));
     *num_commands += ZopfliIterate(num_bytes, position, ringbuffer,
-        ringbuffer_mask, params, max_backward_limit, dist_cache,
+        ringbuffer_mask, params, max_backward_limit, gap, dist_cache,
         &model, num_matches, matches, nodes);
     BrotliZopfliCreateCommands(num_bytes, position, max_backward_limit,
-        nodes, dist_cache, last_insert_len, commands, num_literals);
+        nodes, dist_cache, last_insert_len, params, commands, num_literals);
   }
   CleanupZopfliCostModel(m, &model);
   BROTLI_FREE(m, nodes);
   BROTLI_FREE(m, matches);
   BROTLI_FREE(m, num_matches);
 }
 
 #if defined(__cplusplus) || defined(c_plusplus)
--- a/modules/brotli/enc/backward_references_hq.h
+++ b/modules/brotli/enc/backward_references_hq.h
@@ -78,22 +78,19 @@ BROTLI_INTERNAL void BrotliInitZopfliNod
      (2) nodes[i].command_length() <= i and
      (3) nodes[i - nodes[i].command_length()].cost < kInfinity */
 BROTLI_INTERNAL size_t BrotliZopfliComputeShortestPath(
     MemoryManager* m, const BrotliDictionary* dictionary, size_t num_bytes,
     size_t position, const uint8_t* ringbuffer, size_t ringbuffer_mask,
     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" */
 #endif
 
 #endif  /* BROTLI_ENC_BACKWARD_REFERENCES_HQ_H_ */
--- a/modules/brotli/enc/backward_references_inc.h
+++ b/modules/brotli/enc/backward_references_inc.h
@@ -1,20 +1,20 @@
 /* NOLINT(build/header_guard) */
 /* Copyright 2013 Google Inc. All Rights Reserved.
 
    Distributed under MIT license.
    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,
     size_t* num_literals) {
   /* Set maximum distance, see section 9.1. of the spec. */
   const size_t max_backward_limit = BROTLI_MAX_BACKWARD_LIMIT(params->lgwin);
 
   const Command* const orig_commands = commands;
@@ -22,50 +22,51 @@ static BROTLI_NOINLINE void FN(CreateBac
   const size_t pos_end = position + num_bytes;
   const size_t store_end = num_bytes >= FN(StoreLookahead)() ?
       position + num_bytes - FN(StoreLookahead)() + 1 : position;
 
   /* For speed up heuristics for random data. */
   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;
 
   FN(PrepareDistanceCache)(hasher, dist_cache);
 
   while (position + FN(HashTypeLength)() < pos_end) {
     size_t max_length = pos_end - position;
     size_t max_distance = BROTLI_MIN(size_t, position, max_backward_limit);
     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;
           ++insert_length;
           sr = sr2;
           if (++delayed_backward_references_in_row < 4 &&
               position + FN(HashTypeLength)() < pos_end) {
             continue;
@@ -75,34 +76,43 @@ static BROTLI_NOINLINE void FN(CreateBac
       }
       apply_random_heuristics =
           position + 2 * sr.len + random_heuristics_window_size;
       max_distance = BROTLI_MIN(size_t, position, max_backward_limit);
       {
         /* The first 16 codes are special short-codes,
            and the minimum offset is 1. */
         size_t distance_code =
-            ComputeDistanceCode(sr.distance, max_distance, 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;
       ++position;
       /* If we have not seen matches for a long time, we can skip some
          match lookups. Unsuccessful match lookups are very very expensive
          and this kind of a heuristic speeds up compression quite
          a lot. */
--- a/modules/brotli/enc/block_splitter.c
+++ b/modules/brotli/enc/block_splitter.c
@@ -69,21 +69,19 @@ static void CopyLiteralsToByteArray(cons
     if (insert_len > 0) {
       memcpy(literals + pos, data + from_pos, insert_len);
       pos += insert_len;
     }
     from_pos = (from_pos + insert_len + CommandCopyLen(&cmds[i])) & mask;
   }
 }
 
-static BROTLI_INLINE unsigned int MyRand(unsigned int* seed) {
+static BROTLI_INLINE uint32_t MyRand(uint32_t* seed) {
+  /* Initial seed should be 7. In this case, loop length is (1 << 29). */
   *seed *= 16807U;
-  if (*seed == 0) {
-    *seed = 1;
-  }
   return *seed;
 }
 
 static BROTLI_INLINE double BitCost(size_t count) {
   return count == 0 ? -2.0 : FastLog2(count);
 }
 
 #define HISTOGRAMS_PER_BATCH 64
--- a/modules/brotli/enc/block_splitter_inc.h
+++ b/modules/brotli/enc/block_splitter_inc.h
@@ -8,54 +8,53 @@
 /* template parameters: FN, DataType */
 
 #define HistogramType FN(Histogram)
 
 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);
   for (i = 0; i < num_histograms; ++i) {
     size_t pos = length * i / num_histograms;
     if (i != 0) {
       pos += MyRand(&seed) % block_length;
     }
     if (pos + stride >= length) {
       pos = length - stride - 1;
     }
     FN(HistogramAddVector)(&histograms[i], data + pos, stride);
   }
 }
 
-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);
   }
   FN(HistogramAddVector)(sample, data + pos, stride);
 }
 
 static void FN(RefineEntropyCodes)(const DataType* data, size_t length,
                                    size_t stride,
                                    size_t num_histograms,
                                    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) {
     HistogramType sample;
     FN(HistogramClear)(&sample);
     FN(RandomSample)(&seed, data, length, stride, &sample);
     FN(HistogramAddHistogram)(&histograms[iter % num_histograms], &sample);
   }
--- a/modules/brotli/enc/brotli_bit_stream.c
+++ b/modules/brotli/enc/brotli_bit_stream.c
@@ -1320,22 +1320,11 @@ void BrotliStoreUncompressedMetaBlock(BR
      empty one after this. */
   if (is_final_block) {
     BrotliWriteBits(1, 1, storage_ix, storage);  /* islast */
     BrotliWriteBits(1, 1, storage_ix, storage);  /* isempty */
     JumpToByteBoundary(storage_ix, storage);
   }
 }
 
-void BrotliStoreSyncMetaBlock(size_t* BROTLI_RESTRICT storage_ix,
-                              uint8_t* BROTLI_RESTRICT storage) {
-  /* Empty metadata meta-block bit pattern:
-       1 bit:  is_last (0)
-       2 bits: num nibbles (3)
-       1 bit:  reserved (0)
-       2 bits: metadata length bytes (0) */
-  BrotliWriteBits(6, 6, storage_ix, storage);
-  JumpToByteBoundary(storage_ix, storage);
-}
-
 #if defined(__cplusplus) || defined(c_plusplus)
 }  /* extern "C" */
 #endif
--- a/modules/brotli/enc/brotli_bit_stream.h
+++ b/modules/brotli/enc/brotli_bit_stream.h
@@ -91,17 +91,13 @@ BROTLI_INTERNAL void BrotliStoreMetaBloc
 /* This is for storing uncompressed blocks (simple raw storage of
    bytes-as-bytes).
    REQUIRES: length > 0
    REQUIRES: length <= (1 << 24) */
 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
 
 #endif  /* BROTLI_ENC_BROTLI_BIT_STREAM_H_ */
--- a/modules/brotli/enc/cluster_inc.h
+++ b/modules/brotli/enc/cluster_inc.h
@@ -12,16 +12,18 @@
 /* Computes the bit cost reduction by combining out[idx1] and out[idx2] and if
    it is below a threshold, stores the pair (idx1, idx2) in the *pairs queue. */
 BROTLI_INTERNAL void FN(BrotliCompareAndPushToQueue)(
     const HistogramType* out, const uint32_t* cluster_size, uint32_t idx1,
     uint32_t idx2, size_t max_num_pairs, HistogramPair* pairs,
     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;
   }
   if (idx2 < idx1) {
     uint32_t t = idx2;
     idx2 = idx1;
     idx1 = t;
   }
--- a/modules/brotli/enc/command.h
+++ b/modules/brotli/enc/command.h
@@ -109,27 +109,29 @@ typedef struct Command {
   uint32_t copy_len_;
   uint32_t dist_extra_;
   uint16_t cmd_prefix_;
   uint16_t dist_prefix_;
 } 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) {
   self->insert_len_ = (uint32_t)insertlen;
   self->copy_len_ = 4 << 24;
   self->dist_extra_ = 0;
   self->dist_prefix_ = BROTLI_NUM_DISTANCE_SHORT_CODES;
   GetLengthCode(insertlen, 4, BROTLI_FALSE, &self->cmd_prefix_);
@@ -162,16 +164,17 @@ static BROTLI_INLINE uint32_t CommandDis
   return 3;
 }
 
 static BROTLI_INLINE uint32_t CommandCopyLen(const Command* self) {
   return self->copy_len_ & 0xFFFFFF;
 }
 
 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)
 }  /* extern "C" */
 #endif
 
 #endif  /* BROTLI_ENC_COMMAND_H_ */
--- a/modules/brotli/enc/compress_fragment.c
+++ b/modules/brotli/enc/compress_fragment.c
@@ -37,17 +37,17 @@ extern "C" {
    * The multiplier must be odd. Otherwise we may lose the highest bit.
    * No long streaks of ones or zeros.
    * 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;
 
 static BROTLI_INLINE uint32_t Hash(const uint8_t* p, size_t shift) {
-  const uint64_t h = (BROTLI_UNALIGNED_LOAD64(p) << 24) * kHashMul32;
+  const uint64_t h = (BROTLI_UNALIGNED_LOAD64LE(p) << 24) * kHashMul32;
   return (uint32_t)(h >> shift);
 }
 
 static BROTLI_INLINE uint32_t HashBytesAtOffset(
     uint64_t v, int offset, size_t shift) {
   assert(offset >= 0);
   assert(offset <= 3);
   {
@@ -598,17 +598,17 @@ trawl:
         next_emit = ip;
         if (BROTLI_PREDICT_FALSE(ip >= ip_limit)) {
           goto emit_remainder;
         }
         /* We could immediately start working at ip now, but to improve
            compression we first update "table" with the hashes of some positions
            within the last copy. */
         {
-          uint64_t input_bytes = BROTLI_UNALIGNED_LOAD64(ip - 3);
+          uint64_t input_bytes = BROTLI_UNALIGNED_LOAD64LE(ip - 3);
           uint32_t prev_hash = HashBytesAtOffset(input_bytes, 0, shift);
           uint32_t cur_hash = HashBytesAtOffset(input_bytes, 3, shift);
           table[prev_hash] = (int)(ip - base_ip - 3);
           prev_hash = HashBytesAtOffset(input_bytes, 1, shift);
           table[prev_hash] = (int)(ip - base_ip - 2);
           prev_hash = HashBytesAtOffset(input_bytes, 2, shift);
           table[prev_hash] = (int)(ip - base_ip - 1);
 
@@ -635,17 +635,17 @@ trawl:
         next_emit = ip;
         if (BROTLI_PREDICT_FALSE(ip >= ip_limit)) {
           goto emit_remainder;
         }
         /* We could immediately start working at ip now, but to improve
            compression we first update "table" with the hashes of some positions
            within the last copy. */
         {
-          uint64_t input_bytes = BROTLI_UNALIGNED_LOAD64(ip - 3);
+          uint64_t input_bytes = BROTLI_UNALIGNED_LOAD64LE(ip - 3);
           uint32_t prev_hash = HashBytesAtOffset(input_bytes, 0, shift);
           uint32_t cur_hash = HashBytesAtOffset(input_bytes, 3, shift);
           table[prev_hash] = (int)(ip - base_ip - 3);
           prev_hash = HashBytesAtOffset(input_bytes, 1, shift);
           table[prev_hash] = (int)(ip - base_ip - 2);
           prev_hash = HashBytesAtOffset(input_bytes, 2, shift);
           table[prev_hash] = (int)(ip - base_ip - 1);
 
--- a/modules/brotli/enc/compress_fragment_two_pass.c
+++ b/modules/brotli/enc/compress_fragment_two_pass.c
@@ -36,17 +36,17 @@ extern "C" {
    * The multiplier must be odd. Otherwise we may lose the highest bit.
    * No long streaks of ones or zeros.
    * 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;
 
 static BROTLI_INLINE uint32_t Hash(const uint8_t* p, size_t shift) {
-  const uint64_t h = (BROTLI_UNALIGNED_LOAD64(p) << 16) * kHashMul32;
+  const uint64_t h = (BROTLI_UNALIGNED_LOAD64LE(p) << 16) * kHashMul32;
   return (uint32_t)(h >> shift);
 }
 
 static BROTLI_INLINE uint32_t HashBytesAtOffset(
     uint64_t v, int offset, size_t shift) {
   assert(offset >= 0);
   assert(offset <= 2);
   {
@@ -341,25 +341,25 @@ trawl:
         next_emit = ip;
         if (BROTLI_PREDICT_FALSE(ip >= ip_limit)) {
           goto emit_remainder;
         }
         {
           /* We could immediately start working at ip now, but to improve
              compression we first update "table" with the hashes of some
              positions within the last copy. */
-          uint64_t input_bytes = BROTLI_UNALIGNED_LOAD64(ip - 5);
+          uint64_t input_bytes = BROTLI_UNALIGNED_LOAD64LE(ip - 5);
           uint32_t prev_hash = HashBytesAtOffset(input_bytes, 0, shift);
           uint32_t cur_hash;
           table[prev_hash] = (int)(ip - base_ip - 5);
           prev_hash = HashBytesAtOffset(input_bytes, 1, shift);
           table[prev_hash] = (int)(ip - base_ip - 4);
           prev_hash = HashBytesAtOffset(input_bytes, 2, shift);
           table[prev_hash] = (int)(ip - base_ip - 3);
-          input_bytes = BROTLI_UNALIGNED_LOAD64(ip - 2);
+          input_bytes = BROTLI_UNALIGNED_LOAD64LE(ip - 2);
           cur_hash = HashBytesAtOffset(input_bytes, 2, shift);
           prev_hash = HashBytesAtOffset(input_bytes, 0, shift);
           table[prev_hash] = (int)(ip - base_ip - 2);
           prev_hash = HashBytesAtOffset(input_bytes, 1, shift);
           table[prev_hash] = (int)(ip - base_ip - 1);
 
           candidate = base_ip + table[cur_hash];
           table[cur_hash] = (int)(ip - base_ip);
@@ -381,25 +381,25 @@ trawl:
         next_emit = ip;
         if (BROTLI_PREDICT_FALSE(ip >= ip_limit)) {
           goto emit_remainder;
         }
         {
           /* We could immediately start working at ip now, but to improve
              compression we first update "table" with the hashes of some
              positions within the last copy. */
-          uint64_t input_bytes = BROTLI_UNALIGNED_LOAD64(ip - 5);
+          uint64_t input_bytes = BROTLI_UNALIGNED_LOAD64LE(ip - 5);
           uint32_t prev_hash = HashBytesAtOffset(input_bytes, 0, shift);
           uint32_t cur_hash;
           table[prev_hash] = (int)(ip - base_ip - 5);
           prev_hash = HashBytesAtOffset(input_bytes, 1, shift);
           table[prev_hash] = (int)(ip - base_ip - 4);
           prev_hash = HashBytesAtOffset(input_bytes, 2, shift);
           table[prev_hash] = (int)(ip - base_ip - 3);
-          input_bytes = BROTLI_UNALIGNED_LOAD64(ip - 2);
+          input_bytes = BROTLI_UNALIGNED_LOAD64LE(ip - 2);
           cur_hash = HashBytesAtOffset(input_bytes, 2, shift);
           prev_hash = HashBytesAtOffset(input_bytes, 0, shift);
           table[prev_hash] = (int)(ip - base_ip - 2);
           prev_hash = HashBytesAtOffset(input_bytes, 1, shift);
           table[prev_hash] = (int)(ip - base_ip - 1);
 
           candidate = base_ip + table[cur_hash];
           table[cur_hash] = (int)(ip - base_ip);
--- a/modules/brotli/enc/encode.c
+++ b/modules/brotli/enc/encode.c
@@ -380,18 +380,17 @@ static void ChooseContextMap(int quality
     *literal_context_map = kStaticContextMapContinuation;
   }
 }
 
 /* Decide if we want to use a more complex static context map containing 13
    context values, based on the entropy reduction of histograms over the
    first 5 bits of literals. */
 static BROTLI_BOOL ShouldUseComplexStaticContextMap(const uint8_t* input,
-    size_t start_pos, size_t length, size_t mask, int quality,
-    size_t size_hint, ContextType* literal_context_mode,
+    size_t start_pos, size_t length, size_t mask, int quality, size_t size_hint,
     size_t* num_literal_contexts, const uint32_t** literal_context_map) {
   static const uint32_t kStaticContextMapComplexUTF8[64] = {
     11, 11, 12, 12, /* 0 special */
     0, 0, 0, 0, /* 4 lf */
     1, 1, 9, 9, /* 8 space */
     2, 2, 2, 2, /* !, first after space/lf and after something else. */
     1, 1, 1, 1, /* " */
     8, 3, 3, 3, /* % */
@@ -452,32 +451,30 @@ static BROTLI_BOOL ShouldUseComplexStati
        for not very well compressible input (i.e. entropy using context modeling
        is 60% of maximal entropy) or if expected savings by symbol are less
        than 0.2 bits, then in every case when it triggers, the final compression
        ratio is improved. Note however that this heuristics might be too strict
        for some cases and could be tuned further. */
     if (entropy[2] > 3.0 || entropy[1] - entropy[2] < 0.2) {
       return BROTLI_FALSE;
     } else {
-      *literal_context_mode = CONTEXT_UTF8;
       *num_literal_contexts = 13;
       *literal_context_map = kStaticContextMapComplexUTF8;
       return BROTLI_TRUE;
     }
   }
 }
 
 static void DecideOverLiteralContextModeling(const uint8_t* input,
-    size_t start_pos, size_t length, size_t mask, int quality,
-    size_t size_hint, ContextType* literal_context_mode,
+    size_t start_pos, size_t length, size_t mask, int quality, size_t size_hint,
     size_t* num_literal_contexts, const uint32_t** literal_context_map) {
   if (quality < MIN_QUALITY_FOR_CONTEXT_MODELING || length < 64) {
     return;
   } else if (ShouldUseComplexStaticContextMap(
-      input, start_pos, length, mask, quality, size_hint, literal_context_mode,
+      input, start_pos, length, mask, quality, size_hint,
       num_literal_contexts, literal_context_map)) {
     /* Context map was already set, nothing else to do. */
   } else {
     /* Gather bi-gram data of the UTF8 byte prefixes. To make the analysis of
        UTF8 data faster we only examine 64 byte long strides at every 4kB
        intervals. */
     const size_t end_pos = start_pos + length;
     uint32_t bigram_prefix_histo[9] = { 0 };
@@ -487,17 +484,16 @@ static void DecideOverLiteralContextMode
       int prev = lut[input[start_pos & mask] >> 6] * 3;
       size_t pos;
       for (pos = start_pos + 1; pos < stride_end_pos; ++pos) {
         const uint8_t literal = input[pos & mask];
         ++bigram_prefix_histo[prev + lut[literal >> 6]];
         prev = lut[literal >> 6] * 3;
       }
     }
-    *literal_context_mode = CONTEXT_UTF8;
     ChooseContextMap(quality, &bigram_prefix_histo[0], num_literal_contexts,
                      literal_context_map);
   }
 }
 
 static BROTLI_BOOL ShouldCompress(
     const uint8_t* data, const size_t mask, const uint64_t last_flush_pos,
     const size_t bytes, const size_t num_literals, const size_t num_commands) {
@@ -591,17 +587,17 @@ static void WriteMetaBlockInternal(Memor
     MetaBlockSplit mb;
     InitMetaBlockSplit(&mb);
     if (params->quality < MIN_QUALITY_FOR_HQ_BLOCK_SPLITTING) {
       size_t num_literal_contexts = 1;
       const uint32_t* literal_context_map = NULL;
       if (!params->disable_literal_context_modeling) {
         DecideOverLiteralContextModeling(
             data, wrapped_last_flush_pos, bytes, mask, params->quality,
-            params->size_hint, &literal_context_mode, &num_literal_contexts,
+            params->size_hint, &num_literal_contexts,
             &literal_context_map);
       }
       BrotliBuildMetaBlockGreedy(m, data, wrapped_last_flush_pos, mask,
           prev_byte, prev_byte2, literal_context_mode, num_literal_contexts,
           literal_context_map, commands, num_commands, &mb);
       if (BROTLI_IS_OOM(m)) return;
     } else {
       if (!BrotliIsMostlyUTF8(data, wrapped_last_flush_pos, mask, bytes,
@@ -827,46 +823,16 @@ static void CopyInputToRingBuffer(Brotli
        we have exactly defined behavior and don't read uninitialized
        memory. Due to performance reasons, hashing reads data using a
        LOAD64, which can go 7 bytes beyond the bytes written in the
        ring-buffer. */
     memset(ringbuffer_->buffer_ + ringbuffer_->pos_, 0, 7);
   }
 }
 
-void BrotliEncoderSetCustomDictionary(BrotliEncoderState* s, size_t size,
-                                      const uint8_t* dict) {
-  size_t max_dict_size = BROTLI_MAX_BACKWARD_LIMIT(s->params.lgwin);
-  size_t dict_size = size;
-  MemoryManager* m = &s->memory_manager_;
-
-  if (!EnsureInitialized(s)) return;
-
-  if (dict_size == 0 ||
-      s->params.quality == FAST_ONE_PASS_COMPRESSION_QUALITY ||
-      s->params.quality == FAST_TWO_PASS_COMPRESSION_QUALITY) {
-    return;
-  }
-  if (size > max_dict_size) {
-    dict += size - max_dict_size;
-    dict_size = max_dict_size;
-  }
-  CopyInputToRingBuffer(s, dict_size, dict);
-  s->last_flush_pos_ = dict_size;
-  s->last_processed_pos_ = dict_size;
-  if (dict_size > 0) {
-    s->prev_byte_ = dict[dict_size - 1];
-  }
-  if (dict_size > 1) {
-    s->prev_byte2_ = dict[dict_size - 2];
-  }
-  HasherPrependCustomDictionary(m, &s->hasher_, &s->params, dict_size, dict);
-  if (BROTLI_IS_OOM(m)) return;
-}
-
 /* Marks all input as processed.
    Returns true if position wrapping occurs. */
 static BROTLI_BOOL UpdateLastProcessedPos(BrotliEncoderState* s) {
   uint32_t wrapped_last_processed_pos = WrapPosition(s->last_processed_pos_);
   uint32_t wrapped_input_pos = WrapPosition(s->input_pos_);
   s->last_processed_pos_ = s->input_pos_;
   return TO_BROTLI_BOOL(wrapped_input_pos < wrapped_last_processed_pos);
 }
@@ -1203,17 +1169,18 @@ static BROTLI_BOOL BrotliCompressBufferQ
         if (commands) {
           memcpy(new_commands, commands, sizeof(Command) * num_commands);
           BROTLI_FREE(m, commands);
         }
         commands = new_commands;
       }
       BrotliZopfliCreateCommands(block_size, block_start, max_backward_limit,
                                  &nodes[0], dist_cache, &last_insert_len,
-                                 &commands[num_commands], &num_literals);
+                                 &params, &commands[num_commands],
+                                 &num_literals);
       num_commands += path_size;
       block_start += block_size;
       metablock_size += block_size;
       BROTLI_FREE(m, nodes);
       if (num_literals > max_literals_per_metablock ||
           num_commands > max_commands_per_metablock) {
         break;
       }
@@ -1787,28 +1754,11 @@ const uint8_t* BrotliEncoderTakeOutput(B
   }
   return result;
 }
 
 uint32_t BrotliEncoderVersion(void) {
   return BROTLI_VERSION;
 }
 
-
-/* DEPRECATED >>> */
-size_t BrotliEncoderInputBlockSize(BrotliEncoderState* s) {
-  return InputBlockSize(s);
-}
-void BrotliEncoderCopyInputToRingBuffer(BrotliEncoderState* s,
-                                        const size_t input_size,
-                                        const uint8_t* input_buffer) {
-  CopyInputToRingBuffer(s, input_size, input_buffer);
-}
-BROTLI_BOOL BrotliEncoderWriteData(
-    BrotliEncoderState* s, const BROTLI_BOOL is_last,
-    const BROTLI_BOOL force_flush, size_t* out_size, uint8_t** output) {
-  return EncodeData(s, is_last, force_flush, out_size, output);
-}
-/* <<< DEPRECATED */
-
 #if defined(__cplusplus) || defined(c_plusplus)
 }  /* extern "C" */
 #endif
old mode 100755
new mode 100644
--- a/modules/brotli/enc/find_match_length.h
+++ b/modules/brotli/enc/find_match_length.h
@@ -12,31 +12,31 @@
 #include <brotli/types.h>
 #include "./port.h"
 
 #if defined(__cplusplus) || defined(c_plusplus)
 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,
                                                      size_t limit) {
   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;
     }
   }
   limit = (limit & 7) + 1;  /* + 1 is for pre-decrement in while */
   while (--limit) {
     if (BROTLI_PREDICT_TRUE(s1[matched] == *s2)) {
--- a/modules/brotli/enc/hash.h
+++ b/modules/brotli/enc/hash.h
@@ -57,19 +57,19 @@ static BROTLI_INLINE HasherCommon* GetHa
 static const uint32_t kCutoffTransformsCount = 10;
 /*   0,  12,   27,    23,    42,    63,    56,    48,    59,    64 */
 /* 0+0, 4+8, 8+19, 12+11, 16+26, 20+43, 24+32, 28+20, 32+27, 36+28 */
 static const uint64_t kCutoffTransforms =
     BROTLI_MAKE_UINT64_T(0x071B520A, 0xDA2D3200);
 
 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:
    * The multiplier must be odd. Otherwise we may lose the highest bit.
    * No long streaks of ones or zeros.
    * 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. */
@@ -168,52 +168,52 @@ static BROTLI_INLINE BROTLI_BOOL TestSta
   }
   {
     size_t cut = len - matchlen;
     size_t transform_id =
         (cut << 2) + (size_t)((kCutoffTransforms >> (cut * 6)) & 0x3F);
     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) {
     size_t item = dictionary_hash[key];
     self->dict_num_lookups++;
     if (item != 0) {
       BROTLI_BOOL item_matches = TestStaticDictionaryItem(
           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 {
   uint32_t distance;
   uint32_t length_and_code;
 } BackwardMatch;
 
 static BROTLI_INLINE void InitBackwardMatch(BackwardMatch* self,
@@ -415,40 +415,16 @@ static BROTLI_INLINE void HasherSetup(Me
     if (position == 0) {
         common->dict_num_lookups = 0;
         common->dict_num_matches = 0;
     }
     common->is_prepared_ = BROTLI_TRUE;
   }
 }
 
-/* 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,
     BROTLI_BOOL is_last) {
   HasherHandle self;
   HasherSetup(m, handle, params, data, position, input_size, is_last);
   if (BROTLI_IS_OOM(m)) return;
   self = *handle;
--- a/modules/brotli/enc/hash_forgetful_chain_inc.h
+++ b/modules/brotli/enc/hash_forgetful_chain_inc.h
@@ -147,34 +147,34 @@ static BROTLI_INLINE void FN(PrepareDist
 
    REQUIRES: FN(PrepareDistanceCache) must be invoked for current distance cache
              values; if this method is invoked repeatedly with the same distance
              cache values, it is enough to invoke FN(PrepareDistanceCache) once.
 
    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];
     size_t prev_ix = (cur_ix - backward);
     /* For distance code 0 we want to consider 2-byte matches. */
     if (i > 0 && self->tiny_hash[(uint16_t)prev_ix] != tiny_hash) continue;
     if (prev_ix >= cur_ix || backward > max_backward) {
       continue;
@@ -189,17 +189,16 @@ static BROTLI_INLINE BROTLI_BOOL FN(Find
         if (best_score < score) {
           if (i != 0) score -= BackwardReferencePenaltyUsingLastDistance(i);
           if (best_score < score) {
             best_score = score;
             best_len = len;
             out->len = best_len;
             out->distance = backward;
             out->score = best_score;
-            is_match_found = BROTLI_TRUE;
           }
         }
       }
     }
   }
   {
     const size_t bank = key & (NUM_BANKS - 1);
     size_t backward = 0;
@@ -229,28 +228,26 @@ static BROTLI_INLINE BROTLI_BOOL FN(Find
              score, since we are not interested in such short matches. */
           score_t score = BackwardReferenceScore(len, backward);
           if (best_score < score) {
             best_score = score;
             best_len = len;
             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
 #undef BUCKET_SIZE
 #undef CAPPED_CHAINS
 
 #undef HashForgetfulChain
--- a/modules/brotli/enc/hash_longest_match64_inc.h
+++ b/modules/brotli/enc/hash_longest_match64_inc.h
@@ -18,17 +18,17 @@
 
 static BROTLI_INLINE size_t FN(HashTypeLength)(void) { return 8; }
 static BROTLI_INLINE size_t FN(StoreLookahead)(void) { return 8; }
 
 /* HashBytes is the function that chooses the bucket to place the address in. */
 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);
 }
 
 typedef struct HashLongestMatch {
   /* Number of hash buckets. */
   size_t bucket_size_;
@@ -151,35 +151,35 @@ static BROTLI_INLINE void FN(PrepareDist
 
    REQUIRES: FN(PrepareDistanceCache) must be invoked for current distance cache
              values; if this method is invoked repeatedly with the same distance
              cache values, it is enough to invoke FN(PrepareDistanceCache) once.
 
    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];
     size_t prev_ix = (size_t)(cur_ix - backward);
     if (prev_ix >= cur_ix) {
       continue;
     }
     if (BROTLI_PREDICT_FALSE(backward > max_backward)) {
@@ -204,17 +204,16 @@ static BROTLI_INLINE BROTLI_BOOL FN(Find
         if (best_score < score) {
           if (i != 0) score -= BackwardReferencePenaltyUsingLastDistance(i);
           if (best_score < score) {
             best_score = score;
             best_len = len;
             out->len = best_len;
             out->distance = backward;
             out->score = best_score;
-            is_match_found = BROTLI_TRUE;
           }
         }
       }
     }
   }
   {
     const uint32_t key = FN(HashBytes)(
         &data[cur_ix_masked], self->hash_mask_, self->hash_shift_);
@@ -245,25 +244,23 @@ static BROTLI_INLINE BROTLI_BOOL FN(Find
              score, since we are not interested in such short matches. */
           score_t score = BackwardReferenceScore(len, backward);
           if (best_score < score) {
             best_score = score;
             best_len = len;
             out->len = best_len;
             out->distance = backward;
             out->score = best_score;
-            is_match_found = BROTLI_TRUE;
           }
         }
       }
     }
     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/modules/brotli/enc/hash_longest_match_inc.h
+++ b/modules/brotli/enc/hash_longest_match_inc.h
@@ -144,35 +144,35 @@ static BROTLI_INLINE void FN(PrepareDist
 
    REQUIRES: FN(PrepareDistanceCache) must be invoked for current distance cache
              values; if this method is invoked repeatedly with the same distance
              cache values, it is enough to invoke FN(PrepareDistanceCache) once.
 
    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];
     size_t prev_ix = (size_t)(cur_ix - backward);
     if (prev_ix >= cur_ix) {
       continue;
     }
     if (BROTLI_PREDICT_FALSE(backward > max_backward)) {
@@ -197,17 +197,16 @@ static BROTLI_INLINE BROTLI_BOOL FN(Find
         if (best_score < score) {
           if (i != 0) score -= BackwardReferencePenaltyUsingLastDistance(i);
           if (best_score < score) {
             best_score = score;
             best_len = len;
             out->len = best_len;
             out->distance = backward;
             out->score = best_score;
-            is_match_found = BROTLI_TRUE;
           }
         }
       }
     }
   }
   {
     const uint32_t key =
         FN(HashBytes)(&data[cur_ix_masked], self->hash_shift_);
@@ -237,25 +236,23 @@ static BROTLI_INLINE BROTLI_BOOL FN(Find
              score, since we are not interested in such short matches. */
           score_t score = BackwardReferenceScore(len, backward);
           if (best_score < score) {
             best_score = score;
             best_len = len;
             out->len = best_len;
             out->distance = backward;
             out->score = best_score;
-            is_match_found = BROTLI_TRUE;
           }
         }
       }
     }
     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/modules/brotli/enc/hash_longest_match_quickly_inc.h
+++ b/modules/brotli/enc/hash_longest_match_quickly_inc.h
@@ -17,17 +17,17 @@
 
 static BROTLI_INLINE size_t FN(HashTypeLength)(void) { return 8; }
 static BROTLI_INLINE size_t FN(StoreLookahead)(void) { return 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 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. */
   return (uint32_t)(h >> (64 - BUCKET_BITS));
 }
 
 /* A (forgetful) hash table to the data seen by the compressor, to
    help create backward references to previous data.
@@ -118,78 +118,82 @@ static BROTLI_INLINE void FN(PrepareDist
 
 /* Find a longest backward match of &data[cur_ix & ring_buffer_mask]
    up to the length of max_length and stores the position cur_ix in the
    hash table.
 
    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]) {
       size_t len = FindMatchLengthWithLimit(&data[prev_ix],
                                             &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;
+          }
         }
       }
     }
   }
   if (BUCKET_SWEEP == 1) {
     size_t backward;
     size_t len;
     /* Only one to look for, don't bother to prepare for a loop. */
     prev_ix = self->buckets_[key];
     self->buckets_[key] = (uint32_t)cur_ix;
     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;
     int i;
     prev_ix = *bucket++;
     for (i = 0; i < BUCKET_SWEEP; ++i, prev_ix = *bucket++) {
       const size_t backward = cur_ix - prev_ix;
       size_t len;
@@ -207,26 +211,24 @@ static BROTLI_INLINE BROTLI_BOOL FN(Find
         const score_t score = BackwardReferenceScore(len, backward);
         if (best_score < score) {
           best_score = score;
           best_len = len;
           out->len = best_len;
           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
 #undef BUCKET_SIZE
 
 #undef HashLongestMatchQuickly
--- a/modules/brotli/enc/hash_to_binary_tree_inc.h
+++ b/modules/brotli/enc/hash_to_binary_tree_inc.h
@@ -14,18 +14,20 @@
    position in the input data. The binary tree is sorted by the lexicographic
    order of the sequences, and it is also a max-heap with respect to the
    starting positions. */
 
 #define HashToBinaryTree HASHER()
 
 #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;
   /* The higher bits contain more mixture from the multiplication,
      so we take our results from there. */
   return h >> (32 - BUCKET_BITS);
 }
 
@@ -194,17 +196,17 @@ static BROTLI_INLINE BackwardMatch* FN(S
 
    Sets *num_matches to the number of matches found, and stores the found
    matches in matches[0] to matches[*num_matches - 1]. The matches will be
    sorted by strictly increasing length and (non-strictly) increasing
    distance. */
 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;
   size_t best_len = 1;
   const size_t short_match_max_backward =
       params->quality != HQ_ZOPFLIFICATION_QUALITY ? 16 : 64;
   size_t stop = cur_ix - short_match_max_backward;
   uint32_t dict_matches[BROTLI_MAX_STATIC_DICTIONARY_MATCH_LEN + 1];
@@ -243,18 +245,20 @@ static BROTLI_INLINE size_t FN(FindAllMa
     if (BrotliFindAllStaticDictionaryMatches(dictionary,
         &data[cur_ix_masked], minlen, max_length, &dict_matches[0])) {
       size_t maxlen = BROTLI_MIN(
           size_t, BROTLI_MAX_STATIC_DICTIONARY_MATCH_LEN, max_length);
       size_t l;
       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);
+          }
         }
       }
     }
   }
   return (size_t)(matches - orig_matches);
 }
 
 /* Stores the hash of the next 4 bytes and re-roots the binary tree at the
--- a/modules/brotli/enc/memory.h
+++ b/modules/brotli/enc/memory.h
@@ -35,17 +35,17 @@ typedef struct MemoryManager {
 } MemoryManager;
 
 BROTLI_INTERNAL void BrotliInitMemoryManager(
     MemoryManager* m, brotli_alloc_func alloc_func, brotli_free_func free_func,
     void* opaque);
 
 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) { \
   BrotliFree((M), (P));     \
   P = NULL;                 \
 }
 
 #if defined(BROTLI_ENCODER_EXIT_ON_OOM)
--- a/modules/brotli/enc/port.h
+++ b/modules/brotli/enc/port.h
@@ -21,61 +21,60 @@
 #include <machine/endian.h>
 #elif defined OS_MACOSX
 #include <machine/endian.h>
 /* Let's try and follow the Linux convention */
 #define __BYTE_ORDER  BYTE_ORDER
 #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;
    but note: the FPU still sends unaligned loads and stores to a trap handler!
 */
 
 #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__) && \
   !defined(__ARM_ARCH_5TEJ__) && \
   !defined(__ARM_ARCH_6__) && \
   !defined(__ARM_ARCH_6J__) && \
   !defined(__ARM_ARCH_6K__) && \
   !defined(__ARM_ARCH_6Z__) && \
@@ -83,54 +82,79 @@
   !defined(__ARM_ARCH_6T2__)
 
 /* ARMv7 and newer support native unaligned accesses, but only of 16-bit
    and 32-bit values (not 64-bit); older versions either raise a fatal signal,
    do an unaligned read and rotate the words around a bit, or do the reads very
    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);
 }
 
 #else
 
 /* These functions are provided for architectures that don't support */
 /* unaligned loads and stores. */
 
 static BROTLI_INLINE uint32_t BROTLI_UNALIGNED_LOAD32(const void *p) {
   uint32_t t;
   memcpy(&t, p, sizeof t);
   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)                                                           \
   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_
--- a/modules/brotli/enc/write_bits.h
+++ b/modules/brotli/enc/write_bits.h
@@ -35,31 +35,31 @@ extern "C" {
    and OR'ing to BYTE-0.
 
    For n bits, we take the last 5 bits, OR that with high bits in BYTE-0,
    and locate the rest in BYTE+1, BYTE+2, etc. */
 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
      bits are in *p and we write 57 bits, then the next write will
      access a byte that was never initialized). */
   uint8_t *p = &array[*pos >> 3];
   uint64_t v = *p;
 #ifdef BIT_WRITER_DEBUG
   printf("WriteBits  %2d  0x%016llx  %10d\n", n_bits, bits, *pos);
 #endif
   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 */
   uint8_t *array_pos = &array[*pos >> 3];
   const size_t bits_reserved_in_first_byte = (*pos & 7);
   size_t bits_left_to_write;
   bits <<= bits_reserved_in_first_byte;
   *array_pos++ |= (uint8_t)bits;
--- a/modules/brotli/include/brotli/decode.h
+++ b/modules/brotli/include/brotli/decode.h
@@ -79,18 +79,20 @@ typedef enum {
   BROTLI_ERROR_CODE(_ERROR_FORMAT_, BLOCK_LENGTH_1, -9) SEPARATOR          \
   BROTLI_ERROR_CODE(_ERROR_FORMAT_, BLOCK_LENGTH_2, -10) SEPARATOR         \
   BROTLI_ERROR_CODE(_ERROR_FORMAT_, TRANSFORM, -11) SEPARATOR              \
   BROTLI_ERROR_CODE(_ERROR_FORMAT_, DICTIONARY, -12) SEPARATOR             \
   BROTLI_ERROR_CODE(_ERROR_FORMAT_, WINDOW_BITS, -13) SEPARATOR            \
   BROTLI_ERROR_CODE(_ERROR_FORMAT_, PADDING_1, -14) SEPARATOR              \
   BROTLI_ERROR_CODE(_ERROR_FORMAT_, PADDING_2, -15) SEPARATOR              \
                                                                            \
-  /* -16..-19 codes are reserved */                                        \
+  /* -16..-17 codes are reserved */                                        \
                                                                            \
+  BROTLI_ERROR_CODE(_ERROR_, COMPOUND_DICTIONARY, -18) SEPARATOR           \
+  BROTLI_ERROR_CODE(_ERROR_, DICTIONARY_NOT_SET, -19) SEPARATOR            \
   BROTLI_ERROR_CODE(_ERROR_, INVALID_ARGUMENTS, -20) SEPARATOR             \
                                                                            \
   /* Memory allocation problems */                                         \
   BROTLI_ERROR_CODE(_ERROR_ALLOC_, CONTEXT_MODES, -21) SEPARATOR           \
   /* Literal, insert and distance trees together */                        \
   BROTLI_ERROR_CODE(_ERROR_ALLOC_, TREE_GROUPS, -22) SEPARATOR             \
   /* -23..-24 codes are reserved for distinct tree groups */               \
   BROTLI_ERROR_CODE(_ERROR_ALLOC_, CONTEXT_MAP, -25) SEPARATOR             \
@@ -120,16 +122,39 @@ typedef enum {
  * The value of the last error code, negative integer.
  *
  * All other error code values are in the range from ::BROTLI_LAST_ERROR_CODE
  * to @c -1. There are also 4 other possible non-error codes @c 0 .. @c 3 in
  * ::BrotliDecoderErrorCode enumeration.
  */
 #define BROTLI_LAST_ERROR_CODE BROTLI_DECODER_ERROR_UNREACHABLE
 
+/** Options to be used with ::BrotliDecoderSetParameter. */
+typedef enum BrotliDecoderParameter {
+  /**
+   * Disable "canny" ring buffer allocation strategy.
+   *
+   * Ring buffer is allocated according to window size, despite the real size of
+   * the content.
+   */
+  BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION = 0
+} BrotliDecoderParameter;
+
+/**
+ * Sets the specified parameter to the given decoder instance.
+ *
+ * @param state decoder instance
+ * @param param parameter to set
+ * @param value new parameter value
+ * @returns ::BROTLI_FALSE if parameter is unrecognized, or value is invalid
+ * @returns ::BROTLI_TRUE if value is accepted
+ */
+BROTLI_DEC_API BROTLI_BOOL BrotliDecoderSetParameter(
+    BrotliDecoderState* state, BrotliDecoderParameter param, uint32_t value);
+
 /**
  * Creates an instance of ::BrotliDecoderState and initializes it.
  *
  * The instance can be used once for decoding and should then be destroyed with
  * ::BrotliDecoderDestroyInstance, it cannot be reused for a new decoding
  * session.
  *
  * @p alloc_func and @p free_func @b MUST be both zero or both non-zero. In the
@@ -202,52 +227,27 @@ BROTLI_DEC_API BrotliDecoderResult Brotl
  *                 @b out: remaining size of output buffer
  * @param[in, out] next_out output buffer cursor;
  *                 can be @c NULL if @p available_out is @c 0
  * @param[out] total_out number of bytes decompressed so far; can be @c NULL
  * @returns ::BROTLI_DECODER_RESULT_ERROR if input is corrupted, memory
  *          allocation failed, arguments were invalid, etc.;
  *          use ::BrotliDecoderGetErrorCode to get detailed error code
  * @returns ::BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT decoding is blocked until
- *          more output space is provided
+ *          more input data is provided
  * @returns ::BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT decoding is blocked until
- *          more input data is provided
+ *          more output space is provided
  * @returns ::BROTLI_DECODER_RESULT_SUCCESS decoding is finished, no more
  *          input might be consumed and no more output will be produced
  */
 BROTLI_DEC_API BrotliDecoderResult BrotliDecoderDecompressStream(
   BrotliDecoderState* state, size_t* available_in, const uint8_t** next_in,
   size_t* available_out, uint8_t** next_out, size_t* total_out);
 
 /**
- * Prepends LZ77 dictionary.
- *
- * Fills the fresh ::BrotliDecoderState with additional data corpus for LZ77
- * backward references.
- *
- * @note Not to be confused with the static dictionary (see RFC7932 section 8).
- * @warning The dictionary must exist in memory until decoding is done and
- *          is owned by the caller.
- *
- * Workflow:
- *  -# Allocate and initialize state with ::BrotliDecoderCreateInstance
- *  -# Invoke ::BrotliDecoderSetCustomDictionary
- *  -# Use ::BrotliDecoderDecompressStream
- *  -# Clean up and free state with ::BrotliDecoderDestroyInstance
- *
- * @param state decoder instance
- * @param size length of @p dict; should be less or equal to 2^24 (16MiB),
- *        otherwise the dictionary will be ignored
- * @param dict "dictionary"; @b MUST be the same as used during compression
- */
-BROTLI_DEC_API void BrotliDecoderSetCustomDictionary(
-    BrotliDecoderState* state, size_t size,
-    const uint8_t dict[BROTLI_ARRAY_PARAM(size)]);
-
-/**
  * Checks if decoder has more output.
  *
  * @param state decoder instance
  * @returns ::BROTLI_TRUE, if decoder has some unconsumed output
  * @returns ::BROTLI_FALSE otherwise
  */
 BROTLI_DEC_API BROTLI_BOOL BrotliDecoderHasMoreOutput(
     const BrotliDecoderState* state);
@@ -298,30 +298,31 @@ BROTLI_DEC_API BROTLI_BOOL BrotliDecoder
 /**
  * Checks if decoder instance reached the final state.
  *
  * @param state decoder instance
  * @returns ::BROTLI_TRUE if decoder is in a state where it reached the end of
  *          the input and produced all of the output
  * @returns ::BROTLI_FALSE otherwise
  */
-BROTLI_BOOL BrotliDecoderIsFinished(const BrotliDecoderState* state);
+BROTLI_DEC_API BROTLI_BOOL BrotliDecoderIsFinished(
+    const BrotliDecoderState* state);
 
 /**
  * Acquires a detailed error code.
  *
  * Should be used only after ::BrotliDecoderDecompressStream returns
  * ::BROTLI_DECODER_RESULT_ERROR.
  *
  * See also ::BrotliDecoderErrorString
  *
  * @param state decoder instance
  * @returns last saved error code
  */
-BrotliDecoderErrorCode BrotliDecoderGetErrorCode(
+BROTLI_DEC_API BrotliDecoderErrorCode BrotliDecoderGetErrorCode(
     const BrotliDecoderState* state);
 
 /**
  * Converts error code to a c-string.
  */
 BROTLI_DEC_API const char* BrotliDecoderErrorString(BrotliDecoderErrorCode c);
 
 /**
--- a/modules/brotli/include/brotli/encode.h
+++ b/modules/brotli/include/brotli/encode.h
@@ -31,21 +31,16 @@ extern "C" {
 #define BROTLI_MIN_INPUT_BLOCK_BITS 16
 /** Maximal value for ::BROTLI_PARAM_LGBLOCK parameter. */
 #define BROTLI_MAX_INPUT_BLOCK_BITS 24
 /** Minimal value for ::BROTLI_PARAM_QUALITY parameter. */
 #define BROTLI_MIN_QUALITY 0
 /** Maximal value for ::BROTLI_PARAM_QUALITY parameter. */
 #define BROTLI_MAX_QUALITY 11
 
-BROTLI_DEPRECATED static const int kBrotliMinWindowBits =
-    BROTLI_MIN_WINDOW_BITS;
-BROTLI_DEPRECATED static const int kBrotliMaxWindowBits =
-    BROTLI_MAX_WINDOW_BITS;
-
 /** Options for ::BROTLI_PARAM_MODE parameter. */
 typedef enum BrotliEncoderMode {
   /**
    * Default compression mode.
    *
    * In this mode compressor does not know anything in advance about the
    * properties of the input.
    */
@@ -72,32 +67,36 @@ typedef enum BrotliEncoderOperation {
    */
   BROTLI_OPERATION_PROCESS = 0,
   /**
    * Produce output for all processed input.
    *
    * Actual flush is performed when input stream is depleted and there is enough
    * space in output stream. This means that client should repeat
    * ::BROTLI_OPERATION_FLUSH operation until @p available_in becomes @c 0, and
-   * ::BrotliEncoderHasMoreOutput returns ::BROTLI_FALSE.
+   * ::BrotliEncoderHasMoreOutput returns ::BROTLI_FALSE. If output is acquired
+   * via ::BrotliEncoderTakeOutput, then operation should be repeated after
+   * output buffer is drained.
    *
    * @warning Until flush is complete, client @b SHOULD @b NOT swap,
    *          reduce or extend input stream.
    *
    * When flush is complete, output data will be sufficient for decoder to
    * reproduce all the given input.
    */
   BROTLI_OPERATION_FLUSH = 1,
   /**
    * Finalize the stream.
    *
    * Actual finalization is performed when input stream is depleted and there is
    * enough space in output stream. This means that client should repeat
-   * ::BROTLI_OPERATION_FLUSH operation until @p available_in becomes @c 0, and
-   * ::BrotliEncoderHasMoreOutput returns ::BROTLI_FALSE.
+   * ::BROTLI_OPERATION_FINISH operation until @p available_in becomes @c 0, and
+   * ::BrotliEncoderHasMoreOutput returns ::BROTLI_FALSE. If output is acquired
+   * via ::BrotliEncoderTakeOutput, then operation should be repeated after
+   * output buffer is drained.
    *
    * @warning Until finalization is complete, client @b SHOULD @b NOT swap,
    *          reduce or extend input stream.
    *
    * Helper function ::BrotliEncoderIsFinished checks if stream is finalized and
    * output fully dumped.
    *
    * Adding more input data to finalized stream is impossible.
@@ -223,53 +222,16 @@ BROTLI_ENC_API BrotliEncoderState* Brotl
 
 /**
  * Deinitializes and frees ::BrotliEncoderState instance.
  *
  * @param state decoder instance to be cleaned up and deallocated
  */
 BROTLI_ENC_API void BrotliEncoderDestroyInstance(BrotliEncoderState* state);
 
-/* Calculates maximum input size that can be processed at once. */
-BROTLI_DEPRECATED BROTLI_ENC_API size_t BrotliEncoderInputBlockSize(
-    BrotliEncoderState* state);
-
-/* Copies the given input data to the internal ring buffer. */
-BROTLI_DEPRECATED BROTLI_ENC_API void BrotliEncoderCopyInputToRingBuffer(
-    BrotliEncoderState* state, const size_t input_size,
-    const uint8_t* input_buffer);
-
-/* Processes the accumulated input. */
-BROTLI_DEPRECATED BROTLI_ENC_API BROTLI_BOOL BrotliEncoderWriteData(
-    BrotliEncoderState* state, const BROTLI_BOOL is_last,
-    const BROTLI_BOOL force_flush, size_t* out_size, uint8_t** output);
-
-/**
- * Prepends imaginary LZ77 dictionary.
- *
- * Fills the fresh ::BrotliEncoderState with additional data corpus for LZ77
- * backward references.
- *
- * @note Not to be confused with the static dictionary (see RFC7932 section 8).
- *
- * Workflow:
- *  -# Allocate and initialize state with ::BrotliEncoderCreateInstance
- *  -# Set ::BROTLI_PARAM_LGWIN parameter
- *  -# Invoke ::BrotliEncoderSetCustomDictionary
- *  -# Use ::BrotliEncoderCompressStream
- *  -# Clean up and free state with ::BrotliEncoderDestroyInstance
- *
- * @param state encoder instance
- * @param size length of @p dict; at most "window size" bytes are used
- * @param dict "dictionary"; @b MUST use same dictionary during decompression
- */
-BROTLI_ENC_API void BrotliEncoderSetCustomDictionary(
-    BrotliEncoderState* state, size_t size,
-    const uint8_t dict[BROTLI_ARRAY_PARAM(size)]);
-
 /**
  * Calculates the output size bound for the given @p input_size.
  *
  * @warning Result is not applicable to ::BrotliEncoderCompressStream output,
  *          because every "flush" adds extra overhead bytes, and some encoder
  *          settings (e.g. quality @c 0 and @c 1) might imply a "soft flush"
  *          after every chunk of input.
  *
--- a/modules/brotli/moz.build
+++ b/modules/brotli/moz.build
@@ -24,17 +24,17 @@ UNIFIED_SOURCES += [
 
 # We allow warnings for third-party code that can be updated from upstream.
 ALLOW_COMPILER_WARNINGS = True
 
 CFLAGS += ['-DBROTLI_BUILD_PORTABLE']
 
 Library('brotli')
 
-HostProgram('bro')
+HostProgram('brotli')
 
 HOST_SOURCES += UNIFIED_SOURCES
 
 HOST_SOURCES += [
     'enc/backward_references.c',
     'enc/backward_references_hq.c',
     'enc/bit_cost.c',
     'enc/block_splitter.c',
@@ -46,15 +46,15 @@ HOST_SOURCES += [
     'enc/encode.c',
     'enc/entropy_encode.c',
     'enc/histogram.c',
     'enc/literal_cost.c',
     'enc/memory.c',
     'enc/metablock.c',
     'enc/static_dict.c',
     'enc/utf8_util.c',
-    'tools/bro.c',
+    'tools/brotli.c',
 ]
 
 if CONFIG['HOST_CC_TYPE'] not in ('msvc', 'clang-cl'):
     HOST_OS_LIBS += [
         'm' # for log2() function used by Brotli encoder
     ]
deleted file mode 100644
--- a/modules/brotli/tools/bro.c
+++ /dev/null
@@ -1,521 +0,0 @@
-/* Copyright 2014 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* Example main() function for Brotli library. */
-
-#include <fcntl.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <time.h>
-
-#include <brotli/decode.h>
-#include <brotli/encode.h>
-
-#if !defined(_WIN32)
-#include <unistd.h>
-#include <utime.h>
-#else
-#include <io.h>
-#include <share.h>
-#include <sys/utime.h>
-
-#define MAKE_BINARY(FILENO) (_setmode((FILENO), _O_BINARY), (FILENO))
-
-#if !defined(__MINGW32__)
-#define STDIN_FILENO MAKE_BINARY(_fileno(stdin))
-#define STDOUT_FILENO MAKE_BINARY(_fileno(stdout))
-#define S_IRUSR S_IREAD
-#define S_IWUSR S_IWRITE
-#endif
-
-#define fdopen _fdopen
-#define unlink _unlink
-#define utimbuf _utimbuf
-#define utime _utime
-
-#define fopen ms_fopen
-#define open ms_open
-
-#define chmod(F, P) (0)
-#define chown(F, O, G) (0)
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1400)
-#define fseek _fseeki64
-#define ftell _ftelli64
-#endif
-
-static FILE* ms_fopen(const char *filename, const char *mode) {
-  FILE* result = 0;
-  fopen_s(&result, filename, mode);
-  return result;
-}
-
-static int ms_open(const char *filename, int oflag, int pmode) {
-  int result = -1;
-  _sopen_s(&result, filename, oflag | O_BINARY, _SH_DENYNO, pmode);
-  return result;
-}
-#endif  /* WIN32 */
-
-static int ParseQuality(const char* s, int* quality) {
-  if (s[0] >= '0' && s[0] <= '9') {
-    *quality = s[0] - '0';
-    if (s[1] >= '0' && s[1] <= '9') {
-      *quality = *quality * 10 + s[1] - '0';
-      return (s[2] == 0) ? 1 : 0;
-    }
-    return (s[1] == 0) ? 1 : 0;
-  }
-  return 0;
-}
-
-static void ParseArgv(int argc, char **argv,
-                      char **input_path,
-                      char **output_path,
-                      char **dictionary_path,
-                      int *force,
-                      int *quality,
-                      int *decompress,
-                      int *repeat,
-                      int *verbose,
-                      int *lgwin,
-                      int *copy_stat) {
-  int k;
-  *force = 0;
-  *input_path = 0;
-  *output_path = 0;
-  *repeat = 1;
-  *verbose = 0;
-  *lgwin = 22;
-  *copy_stat = 1;
-  {
-    size_t argv0_len = strlen(argv[0]);
-    *decompress =
-        argv0_len >= 5 && strcmp(&argv[0][argv0_len - 5], "unbro") == 0;
-  }
-  for (k = 1; k < argc; ++k) {
-    if (!strcmp("--force", argv[k]) ||
-        !strcmp("-f", argv[k])) {
-      if (*force != 0) {
-        goto error;
-      }
-      *force = 1;
-      continue;
-    } else if (!strcmp("--decompress", argv[k]) ||
-               !strcmp("--uncompress", argv[k]) ||
-               !strcmp("-d", argv[k])) {
-      *decompress = 1;
-      continue;
-    } else if (!strcmp("--verbose", argv[k]) ||
-               !strcmp("-v", argv[k])) {
-      if (*verbose != 0) {
-        goto error;
-      }
-      *verbose = 1;
-      continue;
-    } else if (!strcmp("--no-copy-stat", argv[k])) {
-      if (*copy_stat == 0) {
-        goto error;
-      }
-      *copy_stat = 0;
-      continue;
-    }
-    if (k < argc - 1) {
-      if (!strcmp("--input", argv[k]) ||
-          !strcmp("--in", argv[k]) ||
-          !strcmp("-i", argv[k])) {
-        if (*input_path != 0) {
-          goto error;
-        }
-        *input_path = argv[k + 1];
-        ++k;
-        continue;
-      } else if (!strcmp("--output", argv[k]) ||
-                 !strcmp("--out", argv[k]) ||
-                 !strcmp("-o", argv[k])) {
-        if (*output_path != 0) {
-          goto error;
-        }
-        *output_path = argv[k + 1];
-        ++k;
-        continue;
-      } else if (!strcmp("--custom-dictionary", argv[k])) {
-        if (*dictionary_path != 0) {
-          goto error;
-        }
-        *dictionary_path = argv[k + 1];
-        ++k;
-        continue;
-      } else if (!strcmp("--quality", argv[k]) ||
-                 !strcmp("-q", argv[k])) {
-        if (!ParseQuality(argv[k + 1], quality)) {
-          goto error;
-        }
-        ++k;
-        continue;
-      } else if (!strcmp("--repeat", argv[k]) ||
-                 !strcmp("-r", argv[k])) {
-        if (!ParseQuality(argv[k + 1], repeat)) {
-          goto error;
-        }
-        ++k;
-        continue;
-      } else if (!strcmp("--window", argv[k]) ||
-                  !strcmp("-w", argv[k])) {
-        if (!ParseQuality(argv[k + 1], lgwin)) {
-          goto error;
-        }
-        if (*lgwin < 10 || *lgwin >= 25) {
-          goto error;
-        }
-        ++k;
-        continue;
-      }
-    }
-    goto error;
-  }
-  return;
-error:
-  fprintf(stderr,
-          "Usage: %s [--force] [--quality n] [--decompress]"
-          " [--input filename] [--output filename] [--repeat iters]"
-          " [--verbose] [--window n] [--custom-dictionary filename]"
-          " [--no-copy-stat]\n",
-          argv[0]);
-  exit(1);
-}
-
-static FILE* OpenInputFile(const char* input_path) {
-  FILE* f;
-  if (input_path == 0) {
-    return fdopen(STDIN_FILENO, "rb");
-  }
-  f = fopen(input_path, "rb");
-  if (f == 0) {
-    perror("fopen");
-    exit(1);
-  }
-  return f;
-}
-
-static FILE *OpenOutputFile(const char *output_path, const int force) {
-  int fd;
-  if (output_path == 0) {
-    return fdopen(STDOUT_FILENO, "wb");
-  }
-  fd = open(output_path, O_CREAT | (force ? 0 : O_EXCL) | O_WRONLY | O_TRUNC,
-            S_IRUSR | S_IWUSR);
-  if (fd < 0) {
-    if (!force) {
-      struct stat statbuf;
-      if (stat(output_path, &statbuf) == 0) {
-        fprintf(stderr, "output file exists\n");
-        exit(1);
-      }
-    }
-    perror("open");
-    exit(1);
-  }
-  return fdopen(fd, "wb");
-}
-
-static int64_t FileSize(const char *path) {
-  FILE *f = fopen(path, "rb");
-  int64_t retval;
-  if (f == NULL) {
-    return -1;
-  }
-  if (fseek(f, 0L, SEEK_END) != 0) {
-    fclose(f);
-    return -1;
-  }
-  retval = ftell(f);
-  if (fclose(f) != 0) {
-    return -1;
-  }
-  return retval;
-}
-
-/* Copy file times and permissions.
-   TODO: this is a "best effort" implementation; honest cross-platform
-   fully featured implementation is way too hacky; add more hacks by request. */
-static void CopyStat(const char* input_path, const char* output_path) {
-  struct stat statbuf;
-  struct utimbuf times;
-  int res;
-  if (input_path == 0 || output_path == 0) {
-    return;
-  }
-  if (stat(input_path, &statbuf) != 0) {
-    return;
-  }
-  times.actime = statbuf.st_atime;
-  times.modtime = statbuf.st_mtime;
-  utime(output_path, &times);
-  res = chmod(output_path, statbuf.st_mode & (S_IRWXU | S_IRWXG | S_IRWXO));
-  if (res != 0)
-    perror("chmod failed");
-  res = chown(output_path, (uid_t)-1, statbuf.st_gid);
-  if (res != 0)
-    perror("chown failed");
-  res = chown(output_path, statbuf.st_uid, (gid_t)-1);
-  if (res != 0)
-    perror("chown failed");
-}
-
-/* Result ownersip is passed to caller.
-   |*dictionary_size| is set to resulting buffer size. */
-static uint8_t* ReadDictionary(const char* path, size_t* dictionary_size) {
-  static const int kMaxDictionarySize = (1 << 24) - 16;
-  FILE *f = fopen(path, "rb");
-  int64_t file_size_64;
-  uint8_t* buffer;
-  size_t bytes_read;
-
-  if (f == NULL) {
-    perror("fopen");
-    exit(1);
-  }
-
-  file_size_64 = FileSize(path);
-  if (file_size_64 == -1) {
-    fprintf(stderr, "could not get size of dictionary file");
-    exit(1);
-  }
-
-  if (file_size_64 > kMaxDictionarySize) {
-    fprintf(stderr, "dictionary is larger than maximum allowed: %d\n",
-            kMaxDictionarySize);
-    exit(1);
-  }
-  *dictionary_size = (size_t)file_size_64;
-
-  buffer = (uint8_t*)malloc(*dictionary_size);
-  if (!buffer) {
-    fprintf(stderr, "could not read dictionary: out of memory\n");
-    exit(1);
-  }
-  bytes_read = fread(buffer, sizeof(uint8_t), *dictionary_size, f);
-  if (bytes_read != *dictionary_size) {
-    fprintf(stderr, "could not read dictionary\n");
-    exit(1);
-  }
-  fclose(f);
-  return buffer;
-}
-
-static const size_t kFileBufferSize = 65536;
-
-static int Decompress(FILE* fin, FILE* fout, const char* dictionary_path) {
-  /* Dictionary should be kept during first rounds of decompression. */
-  uint8_t* dictionary = NULL;
-  uint8_t* input;
-  uint8_t* output;
-  size_t available_in;
-  const uint8_t* next_in;
-  size_t available_out = kFileBufferSize;
-  uint8_t* next_out;
-  BrotliDecoderResult result = BROTLI_DECODER_RESULT_ERROR;
-  BrotliDecoderState* s = BrotliDecoderCreateInstance(NULL, NULL, NULL);
-  if (!s) {
-    fprintf(stderr, "out of memory\n");
-    return 0;
-  }
-  if (dictionary_path != NULL) {
-    size_t dictionary_size = 0;
-    dictionary = ReadDictionary(dictionary_path, &dictionary_size);
-    BrotliDecoderSetCustomDictionary(s, dictionary_size, dictionary);
-  }
-  input = (uint8_t*)malloc(kFileBufferSize);
-  output = (uint8_t*)malloc(kFileBufferSize);
-  if (!input || !output) {
-    fprintf(stderr, "out of memory\n");
-    goto end;
-  }
-  next_out = output;
-  result = BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT;
-  while (1) {
-    if (result == BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT) {
-      if (feof(fin)) {
-        break;
-      }
-      available_in = fread(input, 1, kFileBufferSize, fin);
-      next_in = input;
-      if (ferror(fin)) {
-        break;
-      }
-    } else if (result == BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT) {
-      fwrite(output, 1, kFileBufferSize, fout);
-      if (ferror(fout)) {
-        break;
-      }
-      available_out = kFileBufferSize;
-      next_out = output;
-    } else {
-      break; /* Error or success. */
-    }
-    result = BrotliDecoderDecompressStream(
-        s, &available_in, &next_in, &available_out, &next_out, 0);
-  }
-  if (next_out != output) {
-    fwrite(output, 1, (size_t)(next_out - output), fout);
-  }
-
-  if ((result == BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT) || ferror(fout)) {
-    fprintf(stderr, "failed to write output\n");
-  } else if (result != BROTLI_DECODER_RESULT_SUCCESS) {
-    /* Error or needs more input. */
-    fprintf(stderr, "corrupt input\n");
-  }
-
-end:
-  free(dictionary);
-  free(input);
-  free(output);
-  BrotliDecoderDestroyInstance(s);
-  return (result == BROTLI_DECODER_RESULT_SUCCESS) ? 1 : 0;
-}
-
-static int Compress(int quality, int lgwin, FILE* fin, FILE* fout,
-    const char *dictionary_path) {
-  BrotliEncoderState* s = BrotliEncoderCreateInstance(0, 0, 0);
-  uint8_t* buffer = (uint8_t*)malloc(kFileBufferSize << 1);
-  uint8_t* input = buffer;
-  uint8_t* output = buffer + kFileBufferSize;
-  size_t available_in = 0;
-  const uint8_t* next_in = NULL;
-  size_t available_out = kFileBufferSize;
-  uint8_t* next_out = output;
-  int is_eof = 0;
-  int is_ok = 1;
-
-  if (!s || !buffer) {
-    is_ok = 0;
-    goto finish;
-  }
-
-  BrotliEncoderSetParameter(s, BROTLI_PARAM_QUALITY, (uint32_t)quality);
-  BrotliEncoderSetParameter(s, BROTLI_PARAM_LGWIN, (uint32_t)lgwin);
-  if (dictionary_path != NULL) {
-    size_t dictionary_size = 0;
-    uint8_t* dictionary = ReadDictionary(dictionary_path, &dictionary_size);
-    BrotliEncoderSetCustomDictionary(s, dictionary_size, dictionary);
-    free(dictionary);
-  }
-
-  while (1) {
-    if (available_in == 0 && !is_eof) {
-      available_in = fread(input, 1, kFileBufferSize, fin);
-      next_in = input;
-      if (ferror(fin)) break;
-      is_eof = feof(fin);
-    }
-
-    if (!BrotliEncoderCompressStream(s,
-        is_eof ? BROTLI_OPERATION_FINISH : BROTLI_OPERATION_PROCESS,
-        &available_in, &next_in, &available_out, &next_out, NULL)) {
-      is_ok = 0;
-      break;
-    }
-
-    if (available_out != kFileBufferSize) {
-      size_t out_size = kFileBufferSize - available_out;
-      fwrite(output, 1, out_size, fout);
-      if (ferror(fout)) break;
-      available_out = kFileBufferSize;
-      next_out = output;
-    }
-
-    if (BrotliEncoderIsFinished(s)) break;
-  }
-
-finish:
-  free(buffer);
-  BrotliEncoderDestroyInstance(s);
-
-  if (!is_ok) {
-    /* Should detect OOM? */
-    fprintf(stderr, "failed to compress data\n");
-    return 0;
-  } else if (ferror(fout)) {
-    fprintf(stderr, "failed to write output\n");
-    return 0;
-  } else if (ferror(fin)) {
-    fprintf(stderr, "failed to read input\n");
-    return 0;
-  }
-  return 1;
-}
-
-int main(int argc, char** argv) {
-  char *input_path = 0;
-  char *output_path = 0;
-  char *dictionary_path = 0;
-  int force = 0;
-  int quality = 11;
-  int decompress = 0;
-  int repeat = 1;
-  int verbose = 0;
-  int lgwin = 0;
-  int copy_stat = 1;
-  clock_t clock_start;
-  int i;
-  ParseArgv(argc, argv, &input_path, &output_path, &dictionary_path, &force,
-            &quality, &decompress, &repeat, &verbose, &lgwin, &copy_stat);
-  clock_start = clock();
-  for (i = 0; i < repeat; ++i) {
-    FILE* fin = OpenInputFile(input_path);
-    FILE* fout = OpenOutputFile(output_path, force || (repeat > 1));
-    int is_ok = 0;
-    if (decompress) {
-      is_ok = Decompress(fin, fout, dictionary_path);
-    } else {
-      is_ok = Compress(quality, lgwin, fin, fout, dictionary_path);
-    }
-    if (!is_ok) {
-      unlink(output_path);
-      exit(1);
-    }
-    if (fclose(fout) != 0) {
-      perror("fclose");
-      exit(1);
-    }
-    /* TOCTOU violation, but otherwise it is impossible to set file times. */
-    if (copy_stat && (i + 1 == repeat)) {
-      CopyStat(input_path, output_path);
-    }
-    if (fclose(fin) != 0) {
-      perror("fclose");
-      exit(1);
-    }
-  }
-  if (verbose) {
-    clock_t clock_end = clock();
-    double duration = (double)(clock_end - clock_start) / CLOCKS_PER_SEC;
-    int64_t uncompressed_size;
-    double uncompressed_bytes_in_MB;
-    if (duration < 1e-9) {
-      duration = 1e-9;
-    }
-    uncompressed_size = FileSize(decompress ? output_path : input_path);
-    if (uncompressed_size == -1) {
-      fprintf(stderr, "failed to determine uncompressed file size\n");
-      exit(1);
-    }
-    uncompressed_bytes_in_MB =
-        (double)(repeat * uncompressed_size) / (1024.0 * 1024.0);
-    if (decompress) {
-      printf("Brotli decompression speed: ");
-    } else {
-      printf("Brotli compression speed: ");
-    }
-    printf("%g MB/s\n", uncompressed_bytes_in_MB / duration);
-  }
-  return 0;
-}
new file mode 100755
--- /dev/null
+++ b/modules/brotli/tools/brotli.c
@@ -0,0 +1,861 @@
+/* Copyright 2014 Google Inc. All Rights Reserved.
+
+   Distributed under MIT license.
+   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+*/
+
+/* Command line interface for Brotli library. */
+
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <time.h>
+
+#include "../common/constants.h"
+#include "../common/version.h"
+#include <brotli/decode.h>
+#include <brotli/encode.h>
+
+#if !defined(_WIN32)
+#include <unistd.h>
+#include <utime.h>
+#define MAKE_BINARY(FILENO) (FILENO)
+#else
+#include <io.h>
+#include <share.h>
+#include <sys/utime.h>
+
+#define MAKE_BINARY(FILENO) (_setmode((FILENO), _O_BINARY), (FILENO))
+
+#if !defined(__MINGW32__)
+#define STDIN_FILENO _fileno(stdin)
+#define STDOUT_FILENO _fileno(stdout)
+#define S_IRUSR S_IREAD
+#define S_IWUSR S_IWRITE
+#endif
+
+#define fdopen _fdopen
+#define isatty _isatty
+#define unlink _unlink
+#define utimbuf _utimbuf
+#define utime _utime
+
+#define fopen ms_fopen
+#define open ms_open
+
+#define chmod(F, P) (0)
+#define chown(F, O, G) (0)
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1400)
+#define fseek _fseeki64
+#define ftell _ftelli64
+#endif
+
+static FILE* ms_fopen(const char* filename, const char* mode) {
+  FILE* result = 0;
+  fopen_s(&result, filename, mode);
+  return result;
+}
+
+static int ms_open(const char* filename, int oflag, int pmode) {
+  int result = -1;
+  _sopen_s(&result, filename, oflag | O_BINARY, _SH_DENYNO, pmode);
+  return result;
+}
+#endif  /* WIN32 */
+
+typedef enum {
+  COMMAND_COMPRESS,
+  COMMAND_DECOMPRESS,
+  COMMAND_HELP,
+  COMMAND_INVALID,
+  COMMAND_TEST_INTEGRITY,
+  COMMAND_NOOP,
+  COMMAND_VERSION
+} Command;
+
+#define DEFAULT_LGWIN 22
+#define DEFAULT_SUFFIX ".br"
+#define MAX_OPTIONS 20
+
+typedef struct {
+  /* Parameters */
+  int quality;
+  int lgwin;
+  BROTLI_BOOL force_overwrite;
+  BROTLI_BOOL junk_source;
+  BROTLI_BOOL copy_stat;
+  BROTLI_BOOL verbose;
+  BROTLI_BOOL write_to_stdout;
+  BROTLI_BOOL test_integrity;
+  BROTLI_BOOL decompress;
+  const char* output_path;
+  const char* suffix;
+  int not_input_indices[MAX_OPTIONS];
+  size_t longest_path_len;
+  size_t input_count;
+
+  /* Inner state */
+  int argc;
+  char** argv;
+  char* modified_path;  /* Storage for path with appended / cut suffix */
+  int iterator;
+  int ignore;
+  BROTLI_BOOL iterator_error;
+  uint8_t* buffer;
+  uint8_t* input;
+  uint8_t* output;
+  const char* current_input_path;
+  const char* current_output_path;
+  FILE* fin;
+  FILE* fout;
+} Context;
+
+/* Parse up to 5 decimal digits. */
+static BROTLI_BOOL ParseInt(const char* s, int low, int high, int* result) {
+  int value = 0;
+  int i;
+  for (i = 0; i < 5; ++i) {
+    char c = s[i];
+    if (c == 0) break;
+    if (s[i] < '0' || s[i] > '9') return BROTLI_FALSE;
+    value = (10 * value) + (c - '0');
+  }
+  if (i == 0) return BROTLI_FALSE;
+  if (i > 1 && s[0] == '0') return BROTLI_FALSE;
+  if (s[i] != 0) return BROTLI_FALSE;
+  if (value < low || value > high) return BROTLI_FALSE;
+  *result = value;
+  return BROTLI_TRUE;
+}
+
+/* Returns "base file name" or its tail, if it contains '/' or '\'. */
+static const char* FileName(const char* path) {
+  const char* separator_position = strrchr(path, '/');
+  if (separator_position) path = separator_position + 1;
+  separator_position = strrchr(path, '\\');
+  if (separator_position) path = separator_position + 1;
+  return path;
+}
+
+/* Detect if the program name is a special alias that infers a command type. */
+static Command ParseAlias(const char* name) {
+  /* TODO: cast name to lower case? */
+  const char* unbrotli = "unbrotli";
+  size_t unbrotli_len = strlen(unbrotli);
+  name = FileName(name);
+  /* Partial comparison. On Windows there could be ".exe" suffix. */
+  if (strncmp(name, unbrotli, unbrotli_len) == 0) {
+    char terminator = name[unbrotli_len];
+    if (terminator == 0 || terminator == '.') return COMMAND_DECOMPRESS;
+  }
+  return COMMAND_COMPRESS;
+}
+
+static Command ParseParams(Context* params) {
+  int argc = params->argc;
+  char** argv = params->argv;
+  int i;
+  int next_option_index = 0;
+  size_t input_count = 0;
+  size_t longest_path_len = 1;
+  BROTLI_BOOL command_set = BROTLI_FALSE;
+  BROTLI_BOOL quality_set = BROTLI_FALSE;
+  BROTLI_BOOL output_set = BROTLI_FALSE;
+  BROTLI_BOOL keep_set = BROTLI_FALSE;
+  BROTLI_BOOL lgwin_set = BROTLI_FALSE;
+  BROTLI_BOOL suffix_set = BROTLI_FALSE;
+  BROTLI_BOOL after_dash_dash = BROTLI_FALSE;
+  Command command = ParseAlias(argv[0]);
+
+  for (i = 1; i < argc; ++i) {
+    const char* arg = argv[i];
+    /* C99 5.1.2.2.1: "members argv[0] through argv[argc-1] inclusive shall
+       contain pointers to strings"; NULL and 0-length are not forbidden. */
+    size_t arg_len = arg ? strlen(arg) : 0;
+
+    if (arg_len == 0) {
+      params->not_input_indices[next_option_index++] = i;
+      continue;
+    }
+
+    /* Too many options. The expected longest option list is:
+       "-q 0 -w 10 -o f -D d -S b -d -f -k -n -v --", i.e. 16 items in total.
+       This check is an additinal guard that is never triggered, but provides an
+       additional guard for future changes. */
+    if (next_option_index > (MAX_OPTIONS - 2)) {
+      return COMMAND_INVALID;
+    }
+
+    /* Input file entry. */
+    if (after_dash_dash || arg[0] != '-' || arg_len == 1) {
+      input_count++;
+      if (longest_path_len < arg_len) longest_path_len = arg_len;
+      continue;
+    }
+
+    /* Not a file entry. */
+    params->not_input_indices[next_option_index++] = i;
+
+    /* '--' entry stop parsing arguments. */
+    if (arg_len == 2 && arg[1] == '-') {
+      after_dash_dash = BROTLI_TRUE;
+      continue;
+    }
+
+    /* Simple / coalesced options. */
+    if (arg[1] != '-') {
+      size_t j;
+      for (j = 1; j < arg_len; ++j) {
+        char c = arg[j];
+        if (c >= '0' && c <= '9') {
+          if (quality_set) return COMMAND_INVALID;
+          quality_set = BROTLI_TRUE;
+          params->quality = c - '0';
+          continue;
+        } else if (c == 'c') {
+          if (output_set) return COMMAND_INVALID;
+          output_set = BROTLI_TRUE;
+          params->write_to_stdout = BROTLI_TRUE;
+          continue;
+        } else if (c == 'd') {
+          if (command_set) return COMMAND_INVALID;
+          command_set = BROTLI_TRUE;
+          command = COMMAND_DECOMPRESS;
+          continue;
+        } else if (c == 'f') {
+          if (params->force_overwrite) return COMMAND_INVALID;
+          params->force_overwrite = BROTLI_TRUE;
+          continue;
+        } else if (c == 'h') {
+          /* Don't parse further. */
+          return COMMAND_HELP;
+        } else if (c == 'j' || c == 'k') {
+          if (keep_set) return COMMAND_INVALID;
+          keep_set = BROTLI_TRUE;
+          params->junk_source = TO_BROTLI_BOOL(c == 'j');
+          continue;
+        } else if (c == 'n') {
+          if (!params->copy_stat) return COMMAND_INVALID;
+          params->copy_stat = BROTLI_FALSE;
+          continue;
+        } else if (c == 't') {
+          if (command_set) return COMMAND_INVALID;
+          command_set = BROTLI_TRUE;
+          command = COMMAND_TEST_INTEGRITY;
+          continue;
+        } else if (c == 'v') {
+          if (params->verbose) return COMMAND_INVALID;
+          params->verbose = BROTLI_TRUE;
+          continue;
+        } else if (c == 'V') {
+          /* Don't parse further. */
+          return COMMAND_VERSION;
+        } else if (c == 'Z') {
+          if (quality_set) return COMMAND_INVALID;
+          quality_set = BROTLI_TRUE;
+          params->quality = 11;
+          continue;
+        }
+        /* o/q/w/D/S with parameter is expected */
+        if (c != 'o' && c != 'q' && c != 'w' && c != 'D' && c != 'S') {
+          return COMMAND_INVALID;
+        }
+        if (j + 1 != arg_len) return COMMAND_INVALID;
+        i++;
+        if (i == argc || !argv[i] || argv[i][0] == 0) return COMMAND_INVALID;
+        params->not_input_indices[next_option_index++] = i;
+        if (c == 'o') {
+          if (output_set) return COMMAND_INVALID;
+          params->output_path = argv[i];
+        } else if (c == 'q') {
+          if (quality_set) return COMMAND_INVALID;
+          quality_set = ParseInt(argv[i], BROTLI_MIN_QUALITY,
+                                 BROTLI_MAX_QUALITY, &params->quality);
+          if (!quality_set) return COMMAND_INVALID;
+        } else if (c == 'w') {
+          if (lgwin_set) return COMMAND_INVALID;
+          lgwin_set = ParseInt(argv[i], 0,
+                               BROTLI_MAX_WINDOW_BITS, &params->lgwin);
+          if (!lgwin_set) return COMMAND_INVALID;
+          if (params->lgwin != 0 && params->lgwin < BROTLI_MIN_WINDOW_BITS) {
+            return COMMAND_INVALID;
+          }
+        } else if (c == 'S') {
+          if (suffix_set) return COMMAND_INVALID;
+          suffix_set = BROTLI_TRUE;
+          params->suffix = argv[i];
+        }
+      }
+    } else {  /* Double-dash. */
+      arg = &arg[2];
+      if (strcmp("best", arg) == 0) {
+        if (quality_set) return COMMAND_INVALID;
+        quality_set = BROTLI_TRUE;
+        params->quality = 11;
+      } else if (strcmp("decompress", arg) == 0) {
+        if (command_set) return COMMAND_INVALID;
+        command_set = BROTLI_TRUE;
+        command = COMMAND_DECOMPRESS;
+      } else if (strcmp("force", arg) == 0) {
+        if (params->force_overwrite) return COMMAND_INVALID;
+        params->force_overwrite = BROTLI_TRUE;
+      } else if (strcmp("help", arg) == 0) {
+        /* Don't parse further. */
+        return COMMAND_HELP;
+      } else if (strcmp("keep", arg) == 0) {
+        if (keep_set) return COMMAND_INVALID;
+        keep_set = BROTLI_TRUE;
+        params->junk_source = BROTLI_FALSE;
+      } else if (strcmp("no-copy-stat", arg) == 0) {
+        if (!params->copy_stat) return COMMAND_INVALID;
+        params->copy_stat = BROTLI_FALSE;
+      } else if (strcmp("rm", arg) == 0) {
+        if (keep_set) return COMMAND_INVALID;
+        keep_set = BROTLI_TRUE;
+        params->junk_source = BROTLI_TRUE;
+      } else if (strcmp("stdout", arg) == 0) {
+        if (output_set) return COMMAND_INVALID;
+        output_set = BROTLI_TRUE;
+        params->write_to_stdout = BROTLI_TRUE;
+      } else if (strcmp("test", arg) == 0) {
+        if (command_set) return COMMAND_INVALID;
+        command_set = BROTLI_TRUE;
+        command = COMMAND_TEST_INTEGRITY;
+      } else if (strcmp("verbose", arg) == 0) {
+        if (params->verbose) return COMMAND_INVALID;
+        params->verbose = BROTLI_TRUE;
+      } else if (strcmp("version", arg) == 0) {
+        /* Don't parse further. */
+        return COMMAND_VERSION;
+      } else {
+        /* key=value */
+        const char* value = strrchr(arg, '=');
+        size_t key_len;
+        if (!value || value[1] == 0) return COMMAND_INVALID;
+        key_len = (size_t)(value - arg);
+        value++;
+        if (strncmp("lgwin", arg, key_len) == 0) {
+          if (lgwin_set) return COMMAND_INVALID;
+          lgwin_set = ParseInt(value, 0,
+                               BROTLI_MAX_WINDOW_BITS, &params->lgwin);
+          if (!lgwin_set) return COMMAND_INVALID;
+          if (params->lgwin != 0 && params->lgwin < BROTLI_MIN_WINDOW_BITS) {
+            return COMMAND_INVALID;
+          }
+        } else if (strncmp("output", arg, key_len) == 0) {
+          if (output_set) return COMMAND_INVALID;
+          params->output_path = value;
+        } else if (strncmp("quality", arg, key_len) == 0) {
+          if (quality_set) return COMMAND_INVALID;
+          quality_set = ParseInt(value, BROTLI_MIN_QUALITY,
+                                 BROTLI_MAX_QUALITY, &params->quality);
+          if (!quality_set) return COMMAND_INVALID;
+        } else if (strncmp("suffix", arg, key_len) == 0) {
+          if (suffix_set) return COMMAND_INVALID;
+          suffix_set = BROTLI_TRUE;
+          params->suffix = value;
+        } else {
+          return COMMAND_INVALID;
+        }
+      }
+    }
+  }
+
+  params->input_count = input_count;
+  params->longest_path_len = longest_path_len;
+  params->decompress = (command == COMMAND_DECOMPRESS);
+  params->test_integrity = (command == COMMAND_TEST_INTEGRITY);
+
+  if (input_count > 1 && output_set) return COMMAND_INVALID;
+  if (params->test_integrity) {
+    if (params->output_path) return COMMAND_INVALID;
+    if (params->write_to_stdout) return COMMAND_INVALID;
+  }
+  if (strchr(params->suffix, '/') || strchr(params->suffix, '\\')) {
+    return COMMAND_INVALID;
+  }
+
+  return command;
+}
+
+static void PrintVersion(void) {
+  int major = BROTLI_VERSION >> 24;
+  int minor = (BROTLI_VERSION >> 12) & 0xFFF;
+  int patch = BROTLI_VERSION & 0xFFF;
+  fprintf(stdout, "brotli %d.%d.%d\n", major, minor, patch);
+}
+
+static void PrintHelp(const char* name) {
+  /* String is cut to pieces with length less than 509, to conform C90 spec. */
+  fprintf(stdout,
+"Usage: %s [OPTION]... [FILE]...\n",
+          name);
+  fprintf(stdout,
+"Options:\n"
+"  -#                          compression level (0-9)\n"
+"  -c, --stdout                write on standard output\n"
+"  -d, --decompress            decompress\n"
+"  -f, --force                 force output file overwrite\n"
+"  -h, --help                  display this help and exit\n");
+  fprintf(stdout,
+"  -j, --rm                    remove source file(s)\n"
+"  -k, --keep                  keep source file(s) (default)\n"
+"  -n, --no-copy-stat          do not copy source file(s) attributes\n"
+"  -o FILE, --output=FILE      output file (only if 1 input file)\n");
+  fprintf(stdout,
+"  -q NUM, --quality=NUM       compression level (%d-%d)\n",
+          BROTLI_MIN_QUALITY, BROTLI_MAX_QUALITY);
+  fprintf(stdout,
+"  -t, --test                  test compressed file integrity\n"
+"  -v, --verbose               verbose mode\n");
+  fprintf(stdout,
+"  -w NUM, --lgwin=NUM         set LZ77 window size (0, %d-%d) (default:%d)\n",
+          BROTLI_MIN_WINDOW_BITS, BROTLI_MAX_WINDOW_BITS, DEFAULT_LGWIN);
+  fprintf(stdout,
+"                              window size = 2**NUM - 16\n"
+"                              0 lets compressor choose the optimal value\n");
+  fprintf(stdout,
+"  -S SUF, --suffix=SUF        output file suffix (default:'%s')\n",
+          DEFAULT_SUFFIX);
+  fprintf(stdout,
+"  -V, --version               display version and exit\n"
+"  -Z, --best                  use best compression level (11) (default)\n"
+"Simple options could be coalesced, i.e. '-9kf' is equivalent to '-9 -k -f'.\n"
+"With no FILE, or when FILE is -, read standard input.\n"
+"All arguments after '--' are treated as files.\n");
+}
+
+static const char* PrintablePath(const char* path) {
+  return path ? path : "con";
+}
+
+static BROTLI_BOOL OpenInputFile(const char* input_path, FILE** f) {
+  *f = NULL;
+  if (!input_path) {
+    *f = fdopen(MAKE_BINARY(STDIN_FILENO), "rb");
+    return BROTLI_TRUE;
+  }
+  *f = fopen(input_path, "rb");
+  if (!*f) {
+    fprintf(stderr, "failed to open input file [%s]: %s\n",
+            PrintablePath(input_path), strerror(errno));
+    return BROTLI_FALSE;
+  }
+  return BROTLI_TRUE;
+}
+
+static BROTLI_BOOL OpenOutputFile(const char* output_path, FILE** f,
+                                  BROTLI_BOOL force) {
+  int fd;
+  *f = NULL;
+  if (!output_path) {
+    *f = fdopen(MAKE_BINARY(STDOUT_FILENO), "wb");
+    return BROTLI_TRUE;
+  }
+  fd = open(output_path, O_CREAT | (force ? 0 : O_EXCL) | O_WRONLY | O_TRUNC,
+            S_IRUSR | S_IWUSR);
+  if (fd < 0) {
+    fprintf(stderr, "failed to open output file [%s]: %s\n",
+            PrintablePath(output_path), strerror(errno));
+    return BROTLI_FALSE;
+  }
+  *f = fdopen(fd, "wb");
+  if (!*f) {
+    fprintf(stderr, "failed to open output file [%s]: %s\n",
+            PrintablePath(output_path), strerror(errno));
+    return BROTLI_FALSE;
+  }
+  return BROTLI_TRUE;
+}
+
+/* Copy file times and permissions.
+   TODO: this is a "best effort" implementation; honest cross-platform
+   fully featured implementation is way too hacky; add more hacks by request. */
+static void CopyStat(const char* input_path, const char* output_path) {
+  struct stat statbuf;
+  struct utimbuf times;
+  int res;
+  if (input_path == 0 || output_path == 0) {
+    return;
+  }
+  if (stat(input_path, &statbuf) != 0) {
+    return;
+  }
+  times.actime = statbuf.st_atime;
+  times.modtime = statbuf.st_mtime;
+  utime(output_path, &times);
+  res = chmod(output_path, statbuf.st_mode & (S_IRWXU | S_IRWXG | S_IRWXO));
+  if (res != 0) {
+    fprintf(stderr, "setting access bits failed for [%s]: %s\n",
+            PrintablePath(output_path), strerror(errno));
+  }
+  res = chown(output_path, (uid_t)-1, statbuf.st_gid);
+  if (res != 0) {
+    fprintf(stderr, "setting group failed for [%s]: %s\n",
+            PrintablePath(output_path), strerror(errno));
+  }
+  res = chown(output_path, statbuf.st_uid, (gid_t)-1);
+  if (res != 0) {
+    fprintf(stderr, "setting user failed for [%s]: %s\n",
+            PrintablePath(output_path), strerror(errno));
+  }
+}
+
+static BROTLI_BOOL NextFile(Context* context) {
+  const char* arg;
+  size_t arg_len;
+
+  /* Iterator points to last used arg; increment to search for the next one. */
+  context->iterator++;
+
+  /* No input path; read from console. */
+  if (context->input_count == 0) {
+    if (context->iterator > 1) return BROTLI_FALSE;
+    context->current_input_path = NULL;
+    /* Either write to the specified path, or to console. */
+    context->current_output_path = context->output_path;
+    return BROTLI_TRUE;
+  }
+
+  /* Skip option arguments. */
+  while (context->iterator == context->not_input_indices[context->ignore]) {
+    context->iterator++;
+    context->ignore++;
+  }
+
+  /* All args are scanned already. */
+  if (context->iterator >= context->argc) return BROTLI_FALSE;
+
+  /* Iterator now points to the input file name. */
+  arg = context->argv[context->iterator];
+  arg_len = strlen(arg);
+  /* Read from console. */
+  if (arg_len == 1 && arg[0] == '-') {
+    context->current_input_path = NULL;
+    context->current_output_path = context->output_path;
+    return BROTLI_TRUE;
+  }
+
+  context->current_input_path = arg;
+  context->current_output_path = context->output_path;
+
+  if (context->output_path) return BROTLI_TRUE;
+  if (context->write_to_stdout) return BROTLI_TRUE;
+
+  strcpy(context->modified_path, arg);
+  context->current_output_path = context->modified_path;
+  /* If output is not specified, input path suffix should match. */
+  if (context->decompress) {
+    size_t suffix_len = strlen(context->suffix);
+    char* name = (char*)FileName(context->modified_path);
+    char* name_suffix;
+    size_t name_len = strlen(name);
+    if (name_len < suffix_len + 1) {
+      fprintf(stderr, "empty output file name for [%s] input file\n",
+              PrintablePath(arg));
+      context->iterator_error = BROTLI_TRUE;
+      return BROTLI_FALSE;
+    }
+    name_suffix = name + name_len - suffix_len;
+    if (strcmp(context->suffix, name_suffix) != 0) {
+      fprintf(stderr, "input file [%s] suffix mismatch\n",
+              PrintablePath(arg));
+      context->iterator_error = BROTLI_TRUE;
+      return BROTLI_FALSE;
+    }
+    name_suffix[0] = 0;
+    return BROTLI_TRUE;
+  } else {
+    strcpy(context->modified_path + arg_len, context->suffix);
+    return BROTLI_TRUE;
+  }
+}
+
+static BROTLI_BOOL OpenFiles(Context* context) {
+  BROTLI_BOOL is_ok = OpenInputFile(context->current_input_path, &context->fin);
+  if (!context->test_integrity && is_ok) {
+    is_ok = OpenOutputFile(
+        context->current_output_path, &context->fout, context->force_overwrite);
+  }
+  return is_ok;
+}
+
+static BROTLI_BOOL CloseFiles(Context* context, BROTLI_BOOL success) {
+  BROTLI_BOOL is_ok = BROTLI_TRUE;
+  if (!context->test_integrity && context->fout) {
+    if (!success && context->current_output_path) {
+      unlink(context->current_output_path);
+    }
+    if (fclose(context->fout) != 0) {
+      if (success) {
+        fprintf(stderr, "fclose failed [%s]: %s\n",
+                PrintablePath(context->current_output_path), strerror(errno));
+      }
+      is_ok = BROTLI_FALSE;
+    }
+
+    /* TOCTOU violation, but otherwise it is impossible to set file times. */
+    if (success && is_ok && context->copy_stat) {
+      CopyStat(context->current_input_path, context->current_output_path);
+    }
+  }
+
+  if (context->fin) {
+    if (fclose(context->fin) != 0) {
+      if (is_ok) {
+        fprintf(stderr, "fclose failed [%s]: %s\n",
+                PrintablePath(context->current_input_path), strerror(errno));
+      }
+      is_ok = BROTLI_FALSE;
+    }
+  }
+  if (success && context->junk_source && context->current_input_path) {
+    unlink(context->current_input_path);
+  }
+
+  context->fin = NULL;
+  context->fout = NULL;
+
+  return is_ok;
+}
+
+static const size_t kFileBufferSize = 1 << 16;
+
+static BROTLI_BOOL DecompressFile(Context* context, BrotliDecoderState* s) {
+  size_t available_in = 0;
+  const uint8_t* next_in = NULL;
+  size_t available_out = kFileBufferSize;
+  uint8_t* next_out = context->output;
+  BrotliDecoderResult result = BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT;
+  for (;;) {
+    if (next_out != context->output) {
+      if (!context->test_integrity) {
+        size_t out_size = (size_t)(next_out - context->output);
+        fwrite(context->output, 1, out_size, context->fout);
+        if (ferror(context->fout)) {
+          fprintf(stderr, "failed to write output [%s]: %s\n",
+                  PrintablePath(context->current_output_path), strerror(errno));
+          return BROTLI_FALSE;
+        }
+      }
+      available_out = kFileBufferSize;
+      next_out = context->output;
+    }
+
+    if (result == BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT) {
+      if (feof(context->fin)) {
+        fprintf(stderr, "corrupt input [%s]\n",
+                PrintablePath(context->current_input_path));
+        return BROTLI_FALSE;
+      }
+      available_in = fread(context->input, 1, kFileBufferSize, context->fin);
+      next_in = context->input;
+      if (ferror(context->fin)) {
+        fprintf(stderr, "failed to read input [%s]: %s\n",
+                PrintablePath(context->current_input_path), strerror(errno));
+      return BROTLI_FALSE;
+      }
+    } else if (result == BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT) {
+      /* Nothing to do - output is already written. */
+    } else if (result == BROTLI_DECODER_RESULT_SUCCESS) {
+      if (available_in != 0 || !feof(context->fin)) {
+        fprintf(stderr, "corrupt input [%s]\n",
+                PrintablePath(context->current_input_path));
+        return BROTLI_FALSE;
+      }
+      return BROTLI_TRUE;
+    } else {
+      fprintf(stderr, "corrupt input [%s]\n",
+              PrintablePath(context->current_input_path));
+      return BROTLI_FALSE;
+    }
+
+    result = BrotliDecoderDecompressStream(
+        s, &available_in, &next_in, &available_out, &next_out, 0);
+  }
+}
+
+static BROTLI_BOOL DecompressFiles(Context* context) {
+  while (NextFile(context)) {
+    BROTLI_BOOL is_ok = BROTLI_TRUE;
+    BrotliDecoderState* s = BrotliDecoderCreateInstance(NULL, NULL, NULL);
+    if (!s) {
+      fprintf(stderr, "out of memory\n");
+      return BROTLI_FALSE;
+    }
+    is_ok = OpenFiles(context);
+    if (is_ok && !context->current_input_path &&
+        !context->force_overwrite && isatty(STDIN_FILENO)) {
+      fprintf(stderr, "Use -h help. Use -f to force input from a terminal.\n");
+      is_ok = BROTLI_FALSE;
+    }
+    if (is_ok) is_ok = DecompressFile(context, s);
+    BrotliDecoderDestroyInstance(s);
+    if (!CloseFiles(context, is_ok)) is_ok = BROTLI_FALSE;
+    if (!is_ok) return BROTLI_FALSE;
+  }
+  return BROTLI_TRUE;
+}
+
+static BROTLI_BOOL CompressFile(Context* context, BrotliEncoderState* s) {
+  size_t available_in = 0;
+  const uint8_t* next_in = NULL;
+  size_t available_out = kFileBufferSize;
+  uint8_t* next_out = context->output;
+  BROTLI_BOOL is_eof = BROTLI_FALSE;
+
+  for (;;) {
+    if (available_in == 0 && !is_eof) {
+      available_in = fread(context->input, 1, kFileBufferSize, context->fin);
+      next_in = context->input;
+      if (ferror(context->fin)) {
+        fprintf(stderr, "failed to read input [%s]: %s\n",
+                PrintablePath(context->current_input_path), strerror(errno));
+        return BROTLI_FALSE;
+      }
+      is_eof = feof(context->fin) ? BROTLI_TRUE : BROTLI_FALSE;
+    }
+
+    if (!BrotliEncoderCompressStream(s,
+        is_eof ? BROTLI_OPERATION_FINISH : BROTLI_OPERATION_PROCESS,
+        &available_in, &next_in, &available_out, &next_out, NULL)) {
+      /* Should detect OOM? */
+      fprintf(stderr, "failed to compress data [%s]\n",
+              PrintablePath(context->current_input_path));
+      return BROTLI_FALSE;
+    }
+
+    if (available_out != kFileBufferSize) {
+      size_t out_size = kFileBufferSize - available_out;
+      fwrite(context->output, 1, out_size, context->fout);
+      if (ferror(context->fout)) {
+        fprintf(stderr, "failed to write output [%s]: %s\n",
+                PrintablePath(context->current_output_path), strerror(errno));
+        return BROTLI_FALSE;
+      }
+      available_out = kFileBufferSize;
+      next_out = context->output;
+    }
+
+    if (BrotliEncoderIsFinished(s)) return BROTLI_TRUE;
+  }
+}
+
+static BROTLI_BOOL CompressFiles(Context* context) {
+  while (NextFile(context)) {
+    BROTLI_BOOL is_ok = BROTLI_TRUE;
+    BrotliEncoderState* s = BrotliEncoderCreateInstance(NULL, NULL, NULL);
+    if (!s) {
+      fprintf(stderr, "out of memory\n");
+      return BROTLI_FALSE;
+    }
+    BrotliEncoderSetParameter(s,
+        BROTLI_PARAM_QUALITY, (uint32_t)context->quality);
+    BrotliEncoderSetParameter(s,
+        BROTLI_PARAM_LGWIN, (uint32_t)context->lgwin);
+    is_ok = OpenFiles(context);
+    if (is_ok && !context->current_output_path &&
+        !context->force_overwrite && isatty(STDOUT_FILENO)) {
+      fprintf(stderr, "Use -h help. Use -f to force output to a terminal.\n");
+      is_ok = BROTLI_FALSE;
+    }
+    if (is_ok) is_ok = CompressFile(context, s);
+    BrotliEncoderDestroyInstance(s);
+    if (!CloseFiles(context, is_ok)) is_ok = BROTLI_FALSE;
+    if (!is_ok) return BROTLI_FALSE;
+  }
+  return BROTLI_TRUE;
+}
+
+int main(int argc, char** argv) {
+  Command command;
+  Context context;
+  BROTLI_BOOL is_ok = BROTLI_TRUE;
+  int i;
+
+  context.quality = 11;
+  context.lgwin = DEFAULT_LGWIN;
+  context.force_overwrite = BROTLI_FALSE;
+  context.junk_source = BROTLI_FALSE;
+  context.copy_stat = BROTLI_TRUE;
+  context.test_integrity = BROTLI_FALSE;
+  context.verbose = BROTLI_FALSE;
+  context.write_to_stdout = BROTLI_FALSE;
+  context.decompress = BROTLI_FALSE;
+  context.output_path = NULL;
+  context.suffix = DEFAULT_SUFFIX;
+  for (i = 0; i < MAX_OPTIONS; ++i) context.not_input_indices[i] = 0;
+  context.longest_path_len = 1;
+  context.input_count = 0;
+
+  context.argc = argc;
+  context.argv = argv;
+  context.modified_path = NULL;
+  context.iterator = 0;
+  context.ignore = 0;
+  context.iterator_error = BROTLI_FALSE;
+  context.buffer = NULL;
+  context.current_input_path = NULL;
+  context.current_output_path = NULL;
+  context.fin = NULL;
+  context.fout = NULL;
+
+  command = ParseParams(&context);
+
+  if (command == COMMAND_COMPRESS || command == COMMAND_DECOMPRESS ||
+      command == COMMAND_TEST_INTEGRITY) {
+    if (is_ok) {
+      size_t modified_path_len =
+          context.longest_path_len + strlen(context.suffix) + 1;
+      context.modified_path = (char*)malloc(modified_path_len);
+      context.buffer = (uint8_t*)malloc(kFileBufferSize * 2);
+      if (!context.modified_path || !context.buffer) {
+        fprintf(stderr, "out of memory\n");
+        is_ok = BROTLI_FALSE;
+      } else {
+        context.input = context.buffer;
+        context.output = context.buffer + kFileBufferSize;
+      }
+    }
+  }
+
+  if (!is_ok) command = COMMAND_NOOP;
+
+  switch (command) {
+    case COMMAND_NOOP:
+      break;
+
+    case COMMAND_VERSION:
+      PrintVersion();
+      break;
+
+    case COMMAND_COMPRESS:
+      is_ok = CompressFiles(&context);
+      break;
+
+    case COMMAND_DECOMPRESS:
+    case COMMAND_TEST_INTEGRITY:
+      is_ok = DecompressFiles(&context);
+      break;
+
+    case COMMAND_HELP:
+    case COMMAND_INVALID:
+    default:
+      PrintHelp(FileName(argv[0]));
+      is_ok = (command == COMMAND_HELP);
+      break;
+  }
+
+  if (context.iterator_error) is_ok = BROTLI_FALSE;
+
+  free(context.modified_path);
+  free(context.buffer);
+
+  if (!is_ok) exit(1);
+  return 0;
+}
new file mode 100755
--- /dev/null
+++ b/modules/brotli/tools/brotli.md
@@ -0,0 +1,107 @@
+brotli(1) -- brotli, unbrotli - compress or decompress files
+================================================================
+
+SYNOPSIS
+--------
+
+`brotli` [*OPTION|FILE*]...
+
+`unbrotli` is equivalent to `brotli --decompress`
+
+DESCRIPTION
+-----------
+`brotli` is a generic-purpose lossless compression algorithm that compresses
+data using a combination of a modern variant of the **LZ77** algorithm, Huffman
+coding and 2-nd order context modeling, with a compression ratio comparable to
+the best currently available general-purpose compression methods. It is similar
+in speed with deflate but offers more dense compression.
+
+`brotli` command line syntax similar to `gzip (1)` and `zstd (1)`.
+Unlike `gzip (1)`, source files are preserved by default. It is possible to
+remove them after processing by using the `--rm` _option_.
+
+Arguments that look like "`--name`" or "`--name=value`" are _options_. Every
+_option_ has a short form "`-x`" or "`-x value`". Multiple short form _options_
+could be coalesced:
+
+* "`--decompress --stdout --suffix=.b`" works the same as
+* "`-d -s -S .b`" and
+* "`-dsS .b`"
+
+`brotli` has 3 operation modes:
+
+* default mode is compression;
+* `--decompress` option activates decompression mode;
+* `--test` option switches to integrity test mode; this option is equivalent to
+  "`--decompress --stdout`" except that the decompressed data is discarded
+  instead of being written to standard output.
+
+Every non-option argument is a _file_ entry. If no _files_ are given or _file_
+is "`-`", `brotli` reads from standard input. All arguments after "`--`" are
+_file_ entries.
+
+Unless `--stdout` or `--output` is specified, _files_ are written to a new file
+whose name is derived from the source _file_ name:
+
+* when compressing, a suffix is appended to the source filename to
+  get the target filename
+* when decompressing, a suffix is removed from the source filename to
+  get the target filename
+
+Default suffix is `.br`, but it could be specified with `--suffix` option.
+
+Conflicting or duplicate _options_ are not allowed.
+
+OPTIONS
+-------
+
+* `-#`:
+    compression level (0-9); bigger values cause denser, but slower compression
+* `-c`, `--stdout`:
+    write on standard output
+* `-d`, `--decompress`:
+    decompress mode
+* `-f`, `--force`:
+    force output file overwrite
+* `-h`, `--help`:
+    display this help and exit
+* `-j`, `--rm`:
+    remove source file(s); `gzip (1)`-like behaviour
+* `-k`, `--keep`:
+    keep source file(s); `zstd (1)`-like behaviour
+* `-n`, `--no-copy-stat`:
+    do not copy source file(s) attributes
+* `-o FILE`, `--output=FILE`
+    output file; valid only if there is a single input entry
+* `-q NUM`, `--quality=NUM`:
+    compression level (0-11); bigger values cause denser, but slower compression
+* `-t`, `--test`:
+    test file integrity mode
+* `-v`, `--verbose`:
+    increase output verbosity
+* `-w NUM`, `--lgwin=NUM`:
+    set LZ77 window size (0, 10-24) (default: 22); window size is
+    `(2**NUM - 16)`; 0 lets compressor decide over the optimal value; bigger
+    windows size improve density; decoder might require up to window size
+    memory to operate
+* `-S SUF`, `--suffix=SUF`:
+    output file suffix (default: `.br`)
+* `-V`, `--version`:
+    display version and exit
+* `-Z`, `--best`:
+    use best compression level (default); same as "`-q 11`"
+
+SEE ALSO
+--------
+
+`brotli` file format is defined in
+[RFC 7932](https://www.ietf.org/rfc/rfc7932.txt).
+
+`brotli` is open-sourced under the
+[MIT License](https://opensource.org/licenses/MIT).
+
+Mailing list: https://groups.google.com/forum/#!forum/brotli
+
+BUGS
+----
+Report bugs at: https://github.com/google/brotli/issues
--- a/modules/brotli/update.sh
+++ b/modules/brotli/update.sh
@@ -1,26 +1,26 @@
 #!/bin/sh
 
 # Script to update the mozilla in-tree copy of the Brotli decompressor.
 # Run this within the /modules/brotli directory of the source tree.
 
 MY_TEMP_DIR=`mktemp -d -t brotli_update.XXXXXX` || exit 1
 
 git clone https://github.com/google/brotli ${MY_TEMP_DIR}/brotli
-git -C ${MY_TEMP_DIR}/brotli checkout v0.6.0
+git -C ${MY_TEMP_DIR}/brotli checkout v1.0.1
 
 COMMIT=$(git -C ${MY_TEMP_DIR}/brotli rev-parse HEAD)
 perl -p -i -e "s/\[commit [0-9a-f]{40}\]/[commit ${COMMIT}]/" README.mozilla;
 
 DIRS="common dec enc include tools"
 
 for d in $DIRS; do
 	rm -rf $d
-	mv ${MY_TEMP_DIR}/brotli/$d $d
+	mv ${MY_TEMP_DIR}/brotli/c/$d $d
 done
 rm -rf ${MY_TEMP_DIR}
 
 hg addremove $DIRS
 
 echo "###"
 echo "### Updated brotli/dec to $COMMIT."
 echo "### Remember to verify and commit the changes to source control!"