multi_compress 0.3.2 → 0.3.4

data/ext/multi_compress/vendor/brotli/c/enc/hash_longest_match_simd_inc.h

@@ -0,0 +1,278 @@
+/* NOLINT(build/header_guard) */
+/* Copyright 2010 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 */
+/* A (forgetful) hash table to the data seen by the compressor, to
+   help create backward references to previous data.
+   This is a hash map of fixed size (bucket_size_) to a ring buffer of
+   fixed size (block_size_). The ring buffer contains the last block_size_
+   index positions of the given hash key in the compressed data. */
+#define HashLongestMatch HASHER()
+#define TAG_HASH_BITS 8
+#define TAG_HASH_MASK ((1 << TAG_HASH_BITS) - 1)
+static BROTLI_INLINE size_t FN(HashTypeLength)(void) { return 4; }
+static BROTLI_INLINE size_t FN(StoreLookahead)(void) { return 4; }
+/* HashBytes is the function that chooses the bucket to place the address in. */
+static uint32_t FN(HashBytes)(
+    const uint8_t* BROTLI_RESTRICT data, const int shift) {
+  uint32_t h = BROTLI_UNALIGNED_LOAD32LE(data) * kHashMul32;
+  /* 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_;
+  /* Only block_size_ newest backward references are kept,
+     and the older are forgotten. */
+  size_t block_size_;
+  /* Left-shift for computing hash bucket index from hash value. */
+  int hash_shift_;
+  /* Mask for accessing entries in a block (in a ring-buffer manner). */
+  uint32_t block_mask_;
+  int block_bits_;
+  int num_last_distances_to_check_;
+  /* Shortcuts. */
+  HasherCommon* common_;
+  /* --- Dynamic size members --- */
+  /* Number of entries in a particular bucket. */
+  uint16_t* num_;  /* uint16_t[bucket_size]; */
+  uint8_t* tags_;
+  /* Buckets containing block_size_ of backward references. */
+  uint32_t* buckets_;  /* uint32_t[bucket_size * block_size]; */
+} HashLongestMatch;
+static void FN(Initialize)(
+    HasherCommon* common, HashLongestMatch* BROTLI_RESTRICT self,
+    const BrotliEncoderParams* params) {
+  self->common_ = common;
+  BROTLI_UNUSED(params);
+  self->hash_shift_ = 32 - common->params.bucket_bits - TAG_HASH_BITS;
+  self->bucket_size_ = (size_t)1 << common->params.bucket_bits;
+  self->block_size_ = (size_t)1 << common->params.block_bits;
+  self->block_mask_ = (uint32_t)(self->block_size_ - 1);
+  self->num_ = (uint16_t*)common->extra[0];
+  self->tags_ = (uint8_t*)common->extra[1];
+  self->buckets_ = (uint32_t*)common->extra[2];
+  self->block_bits_ = common->params.block_bits;
+  self->num_last_distances_to_check_ =
+      common->params.num_last_distances_to_check;
+}
+static void FN(Prepare)(
+    HashLongestMatch* BROTLI_RESTRICT self, BROTLI_BOOL one_shot,
+    size_t input_size, const uint8_t* BROTLI_RESTRICT data) {
+  uint16_t* BROTLI_RESTRICT num = self->num_;
+  /* Partial preparation is 100 times slower (per socket). */
+  size_t partial_prepare_threshold = self->bucket_size_ >> 6;
+  if (one_shot && input_size <= partial_prepare_threshold) {
+    size_t i;
+    for (i = 0; i < input_size; ++i) {
+      const uint32_t hash = FN(HashBytes)(&data[i], self->hash_shift_);
+      const uint32_t key = hash >> TAG_HASH_BITS;
+      num[key] = 65535;
+    }
+  } else {
+    /* Set all the bytes of num to 255, which makes each uint16_t 65535. */
+    memset(num, 255, self->bucket_size_ * sizeof(num[0]));
+  }
+}
+static BROTLI_INLINE void FN(HashMemAllocInBytes)(
+    const BrotliEncoderParams* params, BROTLI_BOOL one_shot,
+    size_t input_size, size_t* alloc_size) {
+  size_t bucket_size = (size_t)1 << params->hasher.bucket_bits;
+  size_t block_size = (size_t)1 << params->hasher.block_bits;
+  BROTLI_UNUSED(one_shot);
+  BROTLI_UNUSED(input_size);
+  alloc_size[0] = sizeof(uint16_t) * bucket_size;
+  alloc_size[1] = sizeof(uint8_t) * bucket_size * block_size;
+  alloc_size[2] = sizeof(uint32_t) * bucket_size * block_size;
+}
+/* Look at 4 bytes at &data[ix & mask].
+   Compute a hash from these, and store the value of ix at that position. */
+static BROTLI_INLINE void FN(Store)(
+    HashLongestMatch* BROTLI_RESTRICT self, const uint8_t* BROTLI_RESTRICT data,
+    const size_t mask, const size_t ix) {
+  uint16_t* BROTLI_RESTRICT num = self->num_;
+  uint8_t* BROTLI_RESTRICT tags = self->tags_;
+  uint32_t* BROTLI_RESTRICT buckets = self->buckets_;
+  const size_t hash = FN(HashBytes)(&data[ix & mask], self->hash_shift_);
+  const size_t key = hash >> TAG_HASH_BITS;
+  const uint8_t tag = hash & TAG_HASH_MASK;
+  const size_t minor_ix = num[key] & self->block_mask_;
+  const size_t offset = minor_ix + (key << self->block_bits_);
+  --num[key];
+  buckets[offset] = (uint32_t)ix;
+  tags[offset] = tag;
+}
+static BROTLI_INLINE void FN(StoreRange)(HashLongestMatch* BROTLI_RESTRICT self,
+    const uint8_t* BROTLI_RESTRICT data, const size_t mask,
+    const size_t ix_start, const size_t ix_end) {
+  size_t i;
+  for (i = ix_start; i < ix_end; ++i) {
+    FN(Store)(self, data, mask, i);
+  }
+}
+static BROTLI_INLINE void FN(StitchToPreviousBlock)(
+    HashLongestMatch* BROTLI_RESTRICT self,
+    size_t num_bytes, size_t position, const uint8_t* ringbuffer,
+    size_t ringbuffer_mask) {
+  if (num_bytes >= FN(HashTypeLength)() - 1 && position >= 3) {
+    /* Prepare the hashes for three last bytes of the last write.
+       These could not be calculated before, since they require knowledge
+       of both the previous and the current block. */
+    FN(Store)(self, ringbuffer, ringbuffer_mask, position - 3);
+    FN(Store)(self, ringbuffer, ringbuffer_mask, position - 2);
+    FN(Store)(self, ringbuffer, ringbuffer_mask, position - 1);
+  }
+}
+static BROTLI_INLINE void FN(PrepareDistanceCache)(
+    HashLongestMatch* BROTLI_RESTRICT self,
+    int* BROTLI_RESTRICT distance_cache) {
+  PrepareDistanceCache(distance_cache, self->num_last_distances_to_check_);
+}
+
+/* Find a longest backward match of &data[cur_ix] up to the length of
+   max_length and stores the position cur_ix in the hash table.
+   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|.
+   |out|->score is updated only if a better match is found. */
+static BROTLI_INLINE void FN(FindLongestMatch)(
+    HashLongestMatch* BROTLI_RESTRICT self,
+    const BrotliEncoderDictionary* dictionary,
+    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 dictionary_distance, const size_t max_distance,
+    HasherSearchResult* BROTLI_RESTRICT out) {
+  uint16_t* BROTLI_RESTRICT num = self->num_;
+  uint32_t* BROTLI_RESTRICT buckets = self->buckets_;
+  uint8_t* BROTLI_RESTRICT tags = self->tags_;
+  const size_t cur_ix_masked = cur_ix & ring_buffer_mask;
+  /* 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;
+  /* Precalculate the hash key and prefetch the bucket. */
+  const uint32_t hash =
+      FN(HashBytes)(&data[cur_ix_masked], self->hash_shift_);
+  const uint32_t key = hash >> TAG_HASH_BITS;
+  uint32_t* BROTLI_RESTRICT bucket = &buckets[key << self->block_bits_];
+  uint8_t* BROTLI_RESTRICT tag_bucket = &tags[key << self->block_bits_];
+  PREFETCH_L1(bucket);
+  PREFETCH_L1(tag_bucket);
+  if (self->block_bits_ > 4) PREFETCH_L1(bucket + 16);
+  out->len = 0;
+  out->len_code_delta = 0;
+
+  BROTLI_DCHECK(cur_ix_masked + max_length <= ring_buffer_mask);
+
+  /* Try last distance first. */
+  for (i = 0; i < (size_t)self->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)) {
+      continue;
+    }
+    prev_ix &= ring_buffer_mask;
+
+    if (cur_ix_masked + best_len > ring_buffer_mask) {
+      break;
+    }
+    if (prev_ix + best_len > ring_buffer_mask ||
+        data[cur_ix_masked + best_len] != data[prev_ix + best_len]) {
+      continue;
+    }
+    {
+      const size_t len = FindMatchLengthWithLimit(&data[prev_ix],
+                                                  &data[cur_ix_masked],
+                                                  max_length);
+      if (len >= 3 || (len == 2 && i < 2)) {
+        /* Comparing for >= 2 does not change the semantics, but just saves for
+           a few unnecessary binary logarithms in backward reference score,
+           since we are not interested in such short matches. */
+        score_t score = BackwardReferenceScoreUsingLastDistance(len);
+        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;
+          }
+        }
+      }
+    }
+  }
+  /* we require matches of len >4, so increase best_len to 3, so we can compare
+   * 4 bytes all the time. */
+  if (best_len < 3) {
+    best_len = 3;
+  }
+  {
+    const uint8_t tag = hash & TAG_HASH_MASK;
+    const size_t head = (num[key] + 1) & self->block_mask_;
+    uint64_t matches =
+        GetMatchingTagMask(self->block_size_ / 16, tag, tag_bucket, head);
+    /* Mask off any matches from uninitialized tags. */
+    uint16_t n = 65535 - num[key];
+    uint64_t block_has_unused_slots = self->block_size_ > n;
+    uint64_t mask = (block_has_unused_slots << (n & (64 - 1))) - 1;
+    matches &= mask;
+    for (; matches > 0; matches &= (matches - 1)) {
+      const size_t rb_index =
+          (head + (size_t)BROTLI_TZCNT64(matches)) & self->block_mask_;
+      size_t prev_ix = bucket[rb_index];
+      const size_t backward = cur_ix - prev_ix;
+      if (BROTLI_PREDICT_FALSE(backward > max_backward)) {
+        break;
+      }
+      prev_ix &= ring_buffer_mask;
+      if (cur_ix_masked + best_len > ring_buffer_mask) {
+        break;
+      }
+      if (prev_ix + best_len > ring_buffer_mask ||
+          /* compare 4 bytes ending at best_len + 1 */
+          BrotliUnalignedRead32(&data[cur_ix_masked + best_len - 3]) !=
+              BrotliUnalignedRead32(&data[prev_ix + best_len - 3])) {
+        continue;
+      }
+      {
+        const size_t len = FindMatchLengthWithLimit(&data[prev_ix],
+                                                    &data[cur_ix_masked],
+                                                    max_length);
+        if (len >= 4) {
+          /* Comparing for >= 3 does not change the semantics, but just saves
+             for a few unnecessary binary logarithms in backward reference
+             score, since we are not interested in such short matches. */
+          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;
+          }
+        }
+      }
+    }
+    bucket[num[key] & self->block_mask_] = (uint32_t)cur_ix;
+    tag_bucket[num[key] & self->block_mask_] = tag;
+    --num[key];
+  }
+  if (min_score == out->score) {
+    SearchInStaticDictionary(dictionary,
+        self->common_, &data[cur_ix_masked], max_length, dictionary_distance,
+        max_distance, out, BROTLI_FALSE);
+  }
+}
+#undef HashLongestMatch

data/ext/multi_compress/vendor/brotli/c/enc/histogram.c

@@ -9,6 +9,7 @@
 #include "histogram.h"
 
 #include "../common/context.h"
+#include "../common/platform.h"
 #include "block_splitter.h"
 #include "command.h"
 

data/ext/multi_compress/vendor/brotli/c/enc/histogram.h

@@ -9,10 +9,6 @@
 #ifndef BROTLI_ENC_HISTOGRAM_H_
 #define BROTLI_ENC_HISTOGRAM_H_
 
-#include <string.h>  /* memset */
-
-#include <brotli/types.h>
-
 #include "../common/constants.h"
 #include "../common/context.h"
 #include "../common/platform.h"

data/ext/multi_compress/vendor/brotli/c/enc/literal_cost.c

@@ -9,10 +9,6 @@
 
 #include "literal_cost.h"
 
-#include <string.h>  /* memset */
-
-#include <brotli/types.h>
-
 #include "../common/platform.h"
 #include "fast_log.h"
 #include "utf8_util.h"
@@ -106,6 +102,8 @@ static void EstimateBitCostsForLiteralsUTF8(size_t pos, size_t len, size_t mask,
       size_t utf8_pos = UTF8Position(last_c, c, max_utf8);
       size_t masked_pos = (pos + i) & mask;
       size_t histo = histogram[256 * utf8_pos + data[masked_pos]];
+      static const size_t prologue_length = 2000;
+      static const double multiplier = 0.35 / 2000;
       double lit_cost;
       if (histo == 0) {
         histo = 1;
@@ -120,8 +118,8 @@ static void EstimateBitCostsForLiteralsUTF8(size_t pos, size_t len, size_t mask,
          Perhaps because the entropy source is changing its properties
          rapidly in the beginning of the file, perhaps because the beginning
          of the data is a statistical "anomaly". */
-      if (i < 2000) {
-        lit_cost += 0.7 - ((double)(2000 - i) / 2000.0 * 0.35);
+      if (i < prologue_length) {
+        lit_cost += 0.35 + multiplier * (double)i;
       }
       cost[i] = (float)lit_cost;
     }

data/ext/multi_compress/vendor/brotli/c/enc/literal_cost.h

@@ -10,8 +10,6 @@
 #ifndef BROTLI_ENC_LITERAL_COST_H_
 #define BROTLI_ENC_LITERAL_COST_H_
 
-#include <brotli/types.h>
-
 #include "../common/platform.h"
 
 #if defined(__cplusplus) || defined(c_plusplus)

data/ext/multi_compress/vendor/brotli/c/enc/matching_tag_mask.h

@@ -0,0 +1,69 @@
+#ifndef THIRD_PARTY_BROTLI_ENC_MATCHING_TAG_MASK_H_
+#define THIRD_PARTY_BROTLI_ENC_MATCHING_TAG_MASK_H_
+
+#include "../common/platform.h"
+
+#if defined(__SSE2__) || defined(_M_AMD64) || \
+    (defined(_M_IX86) && defined(_M_IX86_FP) && (_M_IX86_FP >= 2))
+#define SUPPORTS_SSE_2
+#endif
+
+#if defined(SUPPORTS_SSE_2)
+#include <immintrin.h>
+#endif
+
+
+static BROTLI_INLINE uint64_t GetMatchingTagMask(
+    size_t chunk_count, const uint8_t tag,
+    const uint8_t* BROTLI_RESTRICT tag_bucket, const size_t head) {
+  uint64_t matches = 0;
+#if defined(SUPPORTS_SSE_2)
+  const __m128i comparison_mask = _mm_set1_epi8((char)tag);
+  size_t i;
+  for (i = 0; i < chunk_count && i < 4; i++) {
+    const __m128i chunk =
+        _mm_loadu_si128((const __m128i*)(const void*)(tag_bucket + 16 * i));
+    const __m128i equal_mask = _mm_cmpeq_epi8(chunk, comparison_mask);
+    matches |= (uint64_t)_mm_movemask_epi8(equal_mask) << 16 * i;
+  }
+#else
+  const int chunk_size = sizeof(size_t);
+  const size_t shift_amount = ((chunk_size * 8) - chunk_size);
+  const size_t xFF = ~((size_t)0);
+  const size_t x01 = xFF / 0xFF;
+  const size_t x80 = x01 << 7;
+  const size_t splat_char = tag * x01;
+  int i = ((int)chunk_count * 16) - chunk_size;
+  BROTLI_DCHECK((sizeof(size_t) == 4) || (sizeof(size_t) == 8));
+#if BROTLI_LITTLE_ENDIAN
+  const size_t extractMagic = (xFF / 0x7F) >> chunk_size;
+  do {
+      size_t chunk = BrotliUnalignedReadSizeT(&tag_bucket[i]);
+      chunk ^= splat_char;
+      chunk = (((chunk | x80) - x01) | chunk) & x80;
+      matches <<= chunk_size;
+      matches |= (chunk * extractMagic) >> shift_amount;
+      i -= chunk_size;
+  } while (i >= 0);
+#else
+  const size_t msb = xFF ^ (xFF >> 1);
+  const size_t extractMagic = (msb / 0x1FF) | msb;
+  do {
+      size_t chunk = BrotliUnalignedReadSizeT(&tag_bucket[i]);
+      chunk ^= splat_char;
+      chunk = (((chunk | x80) - x01) | chunk) & x80;
+      matches <<= chunk_size;
+      matches |= ((chunk >> 7) * extractMagic) >> shift_amount;
+      i -= chunk_size;
+  } while (i >= 0);
+#endif
+  matches = ~matches;
+#endif
+  if (chunk_count == 1) return BrotliRotateRight16((uint16_t)matches, head);
+  if (chunk_count == 2) return BrotliRotateRight32((uint32_t)matches, head);
+  return BrotliRotateRight64(matches, head);
+}
+
+#undef SUPPORTS_SSE_2
+
+#endif  // THIRD_PARTY_BROTLI_ENC_MATCHING_TAG_MASK_H_

data/ext/multi_compress/vendor/brotli/c/enc/memory.c

@@ -9,11 +9,6 @@
 
 #include "memory.h"
 
-#include <stdlib.h>  /* exit, free, malloc */
-#include <string.h>  /* memcpy */
-
-#include <brotli/types.h>
-
 #include "../common/platform.h"
 
 #if defined(__cplusplus) || defined(c_plusplus)

data/ext/multi_compress/vendor/brotli/c/enc/memory.h

@@ -9,10 +9,6 @@
 #ifndef BROTLI_ENC_MEMORY_H_
 #define BROTLI_ENC_MEMORY_H_
 
-#include <string.h>  /* memcpy */
-
-#include <brotli/types.h>
-
 #include "../common/platform.h"
 
 #if defined(__cplusplus) || defined(c_plusplus)

data/ext/multi_compress/vendor/brotli/c/enc/metablock.c

@@ -9,18 +9,18 @@
 
 #include "metablock.h"
 
-#include <brotli/types.h>
-
 #include "../common/constants.h"
 #include "../common/context.h"
 #include "../common/platform.h"
 #include "bit_cost.h"
 #include "block_splitter.h"
 #include "cluster.h"
+#include "command.h"
 #include "entropy_encode.h"
 #include "histogram.h"
 #include "memory.h"
-#include "quality.h"
+#include "params.h"
+#include "prefix.h"
 
 #if defined(__cplusplus) || defined(c_plusplus)
 extern "C" {
@@ -298,8 +298,6 @@ void BrotliBuildMetaBlock(MemoryManager* m,
 #include "metablock_inc.h"  /* NOLINT(build/include) */
 #undef FN
 
-#define BROTLI_MAX_STATIC_CONTEXTS 13
-
 /* Greedy block splitter for one block category (literal, command or distance).
    Gathers histograms for all context buckets. */
 typedef struct ContextBlockSplitter {
@@ -400,7 +398,7 @@ static void ContextBlockSplitterFinishBlock(
 
     for (i = 0; i < num_contexts; ++i) {
       last_entropy[i] =
-          BitsEntropy(histograms[i].data_, self->alphabet_size_);
+          BrotliBitsEntropy(histograms[i].data_, self->alphabet_size_);
       last_entropy[num_contexts + i] = last_entropy[i];
     }
     ++self->num_blocks_;
@@ -426,15 +424,15 @@ static void ContextBlockSplitterFinishBlock(
     for (i = 0; i < num_contexts; ++i) {
       size_t curr_histo_ix = self->curr_histogram_ix_ + i;
       size_t j;
-      entropy[i] = BitsEntropy(histograms[curr_histo_ix].data_,
-                               self->alphabet_size_);
+      entropy[i] = BrotliBitsEntropy(histograms[curr_histo_ix].data_,
+                                     self->alphabet_size_);
       for (j = 0; j < 2; ++j) {
         size_t jx = j * num_contexts + i;
         size_t last_histogram_ix = self->last_histogram_ix_[j] + i;
         combined_histo[jx] = histograms[curr_histo_ix];
         HistogramAddHistogramLiteral(&combined_histo[jx],
             &histograms[last_histogram_ix]);
-        combined_entropy[jx] = BitsEntropy(
+        combined_entropy[jx] = BrotliBitsEntropy(
             &combined_histo[jx].data_[0], self->alphabet_size_);
         diff[j] += combined_entropy[jx] - entropy[i] - last_entropy[jx];
       }

data/ext/multi_compress/vendor/brotli/c/enc/metablock.h

@@ -10,20 +10,20 @@
 #ifndef BROTLI_ENC_METABLOCK_H_
 #define BROTLI_ENC_METABLOCK_H_
 
-#include <brotli/types.h>
-
 #include "../common/context.h"
 #include "../common/platform.h"
 #include "block_splitter.h"
 #include "command.h"
 #include "histogram.h"
 #include "memory.h"
-#include "quality.h"
+#include "params.h"
 
 #if defined(__cplusplus) || defined(c_plusplus)
 extern "C" {
 #endif
 
+#define BROTLI_MAX_STATIC_CONTEXTS 13
+
 typedef struct MetaBlockSplit {
   BlockSplit literal_split;
   BlockSplit command_split;

data/ext/multi_compress/vendor/brotli/c/enc/metablock_inc.h

@@ -96,7 +96,7 @@ static void FN(BlockSplitterFinishBlock)(
     split->lengths[0] = (uint32_t)self->block_size_;
     split->types[0] = 0;
     last_entropy[0] =
-        BitsEntropy(histograms[0].data_, self->alphabet_size_);
+        BrotliBitsEntropy(histograms[0].data_, self->alphabet_size_);
     last_entropy[1] = last_entropy[0];
     ++self->num_blocks_;
     ++split->num_types;
@@ -105,8 +105,8 @@ static void FN(BlockSplitterFinishBlock)(
       FN(HistogramClear)(&histograms[self->curr_histogram_ix_]);
     self->block_size_ = 0;
   } else if (self->block_size_ > 0) {
-    double entropy = BitsEntropy(histograms[self->curr_histogram_ix_].data_,
-                                 self->alphabet_size_);
+    double entropy = BrotliBitsEntropy(
+        histograms[self->curr_histogram_ix_].data_, self->alphabet_size_);
     double combined_entropy[2];
     double diff[2];
     size_t j;
@@ -115,7 +115,7 @@ static void FN(BlockSplitterFinishBlock)(
       self->combined_histo[j] = histograms[self->curr_histogram_ix_];
       FN(HistogramAddHistogram)(&self->combined_histo[j],
           &histograms[last_histogram_ix]);
-      combined_entropy[j] = BitsEntropy(
+      combined_entropy[j] = BrotliBitsEntropy(
           &self->combined_histo[j].data_[0], self->alphabet_size_);
       diff[j] = combined_entropy[j] - entropy - last_entropy[j];
     }

data/ext/multi_compress/vendor/brotli/c/enc/params.h

@@ -10,7 +10,6 @@
 #define BROTLI_ENC_PARAMS_H_
 
 #include <brotli/encode.h>
-
 #include "encoder_dict.h"
 
 typedef struct BrotliHasherParams {

data/ext/multi_compress/vendor/brotli/c/enc/prefix.h

@@ -10,8 +10,6 @@
 #ifndef BROTLI_ENC_PREFIX_H_
 #define BROTLI_ENC_PREFIX_H_
 
-#include <brotli/types.h>
-
 #include "../common/constants.h"
 #include "../common/platform.h"
 #include "fast_log.h"

data/ext/multi_compress/vendor/brotli/c/enc/quality.h

@@ -10,9 +10,8 @@
 #ifndef BROTLI_ENC_QUALITY_H_
 #define BROTLI_ENC_QUALITY_H_
 
-#include <brotli/encode.h>
-
 #include "../common/platform.h"
+#include <brotli/encode.h>
 #include "params.h"
 
 #define FAST_ONE_PASS_COMPRESSION_QUALITY 0
@@ -128,16 +127,16 @@ static BROTLI_INLINE size_t LiteralSpreeLengthForSparseSearch(
    - q04: h04 (longest_match_quickly), b17, l5
    - q04: h54 (longest_match_quickly), b20, l7 | for large files
 
-   - q05: h05 (longest_match        ), b14, l4
-   - q05: h06 (longest_match64      ), b15, l5 | for large files
+   - q05: h58 (longest_match_simd   ), b14, l4
+   - q05: h68 (longest_match64_simd ), b15, l5 | for large files
    - q05: h40 (forgetful_chain      ), b15, l4 | for small window
 
-   - q06: h05 (longest_match        ), b14, l4
-   - q06: h06 (longest_match64      ), b15, l5 | for large files
+   - q06: h58 (longest_match_simd   ), b14, l4
+   - q06: h68 (longest_match64_simd ), b15, l5 | for large files
    - q06: h40 (forgetful_chain      ), b15, l4 | for small window
 
-   - q07: h05 (longest_match        ), b15, l4
-   - q07: h06 (longest_match64      ), b15, l5 | for large files
+   - q07: h58 (longest_match_simd   ), b15, l4
+   - q07: h68 (longest_match64_simd ), b15, l5 | for large files
    - q07: h41 (forgetful_chain      ), b15, l4 | for small window
 
    - q08: h05 (longest_match        ), b15, l4
@@ -165,7 +164,11 @@ static BROTLI_INLINE void ChooseHasher(const BrotliEncoderParams* params,
   } else if (params->lgwin <= 16) {
     hparams->type = params->quality < 7 ? 40 : params->quality < 9 ? 41 : 42;
   } else if (params->size_hint >= (1 << 20) && params->lgwin >= 19) {
+#if defined(BROTLI_MAX_SIMD_QUALITY)
+    hparams->type = params->quality <= BROTLI_MAX_SIMD_QUALITY ? 68 : 6;
+#else
     hparams->type = 6;
+#endif
     hparams->block_bits = params->quality - 1;
     hparams->bucket_bits = 15;
     hparams->num_last_distances_to_check =
@@ -173,7 +176,11 @@ static BROTLI_INLINE void ChooseHasher(const BrotliEncoderParams* params,
   } else {
     /* TODO(eustas): often previous setting (H6) is faster and denser; consider
                      adding an option to use it. */
+#if defined(BROTLI_MAX_SIMD_QUALITY)
+    hparams->type = params->quality <= BROTLI_MAX_SIMD_QUALITY ? 58 : 5;
+#else
     hparams->type = 5;
+#endif
     hparams->block_bits = params->quality - 1;
     hparams->bucket_bits = params->quality < 7 ? 14 : 15;
     hparams->num_last_distances_to_check =
@@ -186,14 +193,14 @@ static BROTLI_INLINE void ChooseHasher(const BrotliEncoderParams* params,
        hasher already works well with large window. So the changes are:
        H3 --> H35: for quality 3.
        H54 --> H55: for quality 4 with size hint > 1MB
-       H6 --> H65: for qualities 5, 6, 7, 8, 9. */
+       H6/H68 --> H65: for qualities 5, 6, 7, 8, 9. */
     if (hparams->type == 3) {
       hparams->type = 35;
     }
     if (hparams->type == 54) {
       hparams->type = 55;
     }
-    if (hparams->type == 6) {
+    if (hparams->type == 6 || hparams->type == 68) {
       hparams->type = 65;
     }
   }

data/ext/multi_compress/vendor/brotli/c/enc/ringbuffer.h

@@ -9,12 +9,9 @@
 #ifndef BROTLI_ENC_RINGBUFFER_H_
 #define BROTLI_ENC_RINGBUFFER_H_
 
-#include <string.h>  /* memcpy */
-
-#include <brotli/types.h>
-
 #include "../common/platform.h"
 #include "memory.h"
+#include "params.h"
 #include "quality.h"
 
 #if defined(__cplusplus) || defined(c_plusplus)

data/ext/multi_compress/vendor/brotli/c/enc/state.h

@@ -9,8 +9,8 @@
 #ifndef BROTLI_ENC_STATE_H_
 #define BROTLI_ENC_STATE_H_
 
-#include <brotli/types.h>
-
+#include "../common/constants.h"
+#include "../common/platform.h"
 #include "command.h"
 #include "compress_fragment.h"
 #include "compress_fragment_two_pass.h"