multi_compress 0.3.2 → 0.3.4

data/ext/multi_compress/vendor/brotli/c/dec/state.c

@@ -6,19 +6,32 @@
 
 #include "state.h"
 
-#include <stdlib.h>  /* free, malloc */
-
-#include <brotli/types.h>
-
 #include "../common/dictionary.h"
+#include "../common/platform.h"
 #include "huffman.h"
 
 #if defined(__cplusplus) || defined(c_plusplus)
 extern "C" {
 #endif
 
+#ifdef BROTLI_REPORTING
+/* When BROTLI_REPORTING is defined extra reporting module have to be linked. */
+void BrotliDecoderOnStart(const BrotliDecoderState* s);
+void BrotliDecoderOnFinish(const BrotliDecoderState* s);
+#define BROTLI_DECODER_ON_START(s) BrotliDecoderOnStart(s);
+#define BROTLI_DECODER_ON_FINISH(s) BrotliDecoderOnFinish(s);
+#else
+#if !defined(BROTLI_DECODER_ON_START)
+#define BROTLI_DECODER_ON_START(s) (void)(s);
+#endif
+#if !defined(BROTLI_DECODER_ON_FINISH)
+#define BROTLI_DECODER_ON_FINISH(s) (void)(s);
+#endif
+#endif
+
 BROTLI_BOOL BrotliDecoderStateInit(BrotliDecoderState* s,
     brotli_alloc_func alloc_func, brotli_free_func free_func, void* opaque) {
+  BROTLI_DECODER_ON_START(s);
   if (!alloc_func) {
     s->alloc_func = BrotliDefaultAllocFunc;
     s->free_func = BrotliDefaultFreeFunc;
@@ -135,16 +148,6 @@ void BrotliDecoderStateCleanupAfterMetablock(BrotliDecoderState* s) {
   BROTLI_DECODER_FREE(s, s->distance_hgroup.htrees);
 }
 
-#ifdef BROTLI_REPORTING
-/* When BROTLI_REPORTING is defined extra reporting module have to be linked. */
-void BrotliDecoderOnFinish(const BrotliDecoderState* s);
-#define BROTLI_DECODER_ON_FINISH(s) BrotliDecoderOnFinish(s);
-#else
-#if !defined(BROTLI_DECODER_ON_FINISH)
-#define BROTLI_DECODER_ON_FINISH(s) (void)(s);
-#endif
-#endif
-
 void BrotliDecoderStateCleanup(BrotliDecoderState* s) {
   BrotliDecoderStateCleanupAfterMetablock(s);
 
@@ -174,7 +177,7 @@ BROTLI_BOOL BrotliDecoderHuffmanTreeGroupInit(BrotliDecoderState* s,
   group->alphabet_size_limit = (uint16_t)alphabet_size_limit;
   group->num_htrees = (uint16_t)ntrees;
   group->htrees = p;
-  group->codes = (HuffmanCode*)(&p[ntrees]);
+  group->codes = p ? (HuffmanCode*)(&p[ntrees]) : NULL;
   return !!p;
 }
 

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

@@ -9,14 +9,10 @@
 #ifndef BROTLI_DEC_STATE_H_
 #define BROTLI_DEC_STATE_H_
 
-#include <brotli/decode.h>
-#include <brotli/shared_dictionary.h>
-#include <brotli/types.h>
-
 #include "../common/constants.h"
-#include "../common/dictionary.h"
 #include "../common/platform.h"
-#include "../common/transform.h"
+#include <brotli/shared_dictionary.h>
+#include <brotli/decode.h>
 #include "bit_reader.h"
 #include "huffman.h"
 

data/ext/multi_compress/vendor/brotli/c/dec/static_init.c

@@ -0,0 +1,53 @@
+/* Copyright 2025 Google Inc. All Rights Reserved.
+
+   Distributed under MIT license.
+   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+*/
+
+#include "static_init.h"
+
+#include "../common/platform.h"
+#include "../common/static_init.h"
+
+#if (BROTLI_STATIC_INIT != BROTLI_STATIC_INIT_NONE)
+#include "../common/dictionary.h"
+#include "prefix.h"
+#endif
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+#if (BROTLI_STATIC_INIT != BROTLI_STATIC_INIT_NONE)
+static BROTLI_BOOL DoBrotliDecoderStaticInit(void) {
+  BROTLI_BOOL ok = BrotliDecoderInitCmdLut(kCmdLut);
+  if (!ok) return BROTLI_FALSE;
+  return BROTLI_TRUE;
+}
+#endif  /* BROTLI_STATIC_INIT_NONE */
+
+#if (BROTLI_STATIC_INIT == BROTLI_STATIC_INIT_EARLY)
+static BROTLI_BOOL kEarlyInitOk;
+static __attribute__((constructor)) void BrotliDecoderStaticInitEarly(void) {
+  kEarlyInitOk = DoBrotliDecoderStaticInit();
+}
+#elif (BROTLI_STATIC_INIT == BROTLI_STATIC_INIT_LAZY)
+static BROTLI_BOOL kLazyInitOk;
+void BrotliDecoderLazyStaticInitInner(void) {
+  kLazyInitOk = DoBrotliDecoderStaticInit();
+}
+#endif  /* BROTLI_STATIC_INIT_EARLY */
+
+BROTLI_BOOL BrotliDecoderEnsureStaticInit(void) {
+#if (BROTLI_STATIC_INIT == BROTLI_STATIC_INIT_NONE)
+  return BROTLI_TRUE;
+#elif (BROTLI_STATIC_INIT == BROTLI_STATIC_INIT_EARLY)
+  return kEarlyInitOk;
+#else
+  return kLazyInitOk;
+#endif
+}
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}  /* extern "C" */
+#endif

data/ext/multi_compress/vendor/brotli/c/dec/static_init.h

@@ -0,0 +1,30 @@
+/* Copyright 2025 Google Inc. All Rights Reserved.
+
+   Distributed under MIT license.
+   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+*/
+
+/* Central point for static initialization. */
+
+#ifndef THIRD_PARTY_BROTLI_DEC_STATIC_INIT_H_
+#define THIRD_PARTY_BROTLI_DEC_STATIC_INIT_H_
+
+#include "../common/platform.h"
+#include "../common/static_init.h"
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+#if (BROTLI_STATIC_INIT == BROTLI_STATIC_INIT_LAZY)
+BROTLI_INTERNAL void BrotliDecoderLazyStaticInitInner(void);
+BROTLI_INTERNAL void BrotliDecoderLazyStaticInit(void);
+#endif  /* BROTLI_STATIC_INIT */
+
+BROTLI_INTERNAL BROTLI_BOOL BrotliDecoderEnsureStaticInit(void);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}  /* extern "C" */
+#endif
+
+#endif  // THIRD_PARTY_BROTLI_DEC_STATIC_INIT_H_

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

@@ -8,17 +8,15 @@
 
 #include "backward_references.h"
 
-#include <brotli/types.h>
-
 #include "../common/constants.h"
-#include "../common/dictionary.h"
+#include "../common/context.h"
 #include "../common/platform.h"
 #include "command.h"
 #include "compound_dictionary.h"
-#include "dictionary_hash.h"
 #include "encoder_dict.h"
-#include "memory.h"
-#include "quality.h"
+#include "hash.h"
+#include "params.h"
+#include "quality.h"  /* IWYU pragma: keep for inc */
 
 #if defined(__cplusplus) || defined(c_plusplus)
 extern "C" {
@@ -116,6 +114,18 @@ static BROTLI_INLINE size_t ComputeDistanceCode(size_t distance,
 #include "backward_references_inc.h"
 #undef HASHER
 
+#if defined(BROTLI_MAX_SIMD_QUALITY)
+#define HASHER() H58
+/* NOLINTNEXTLINE(build/include) */
+#include "backward_references_inc.h"
+#undef HASHER
+
+#define HASHER() H68
+/* NOLINTNEXTLINE(build/include) */
+#include "backward_references_inc.h"
+#undef HASHER
+#endif
+
 #undef ENABLE_COMPOUND_DICTIONARY
 #undef PREFIX
 #define PREFIX() D
@@ -149,6 +159,16 @@ static BROTLI_INLINE size_t ComputeDistanceCode(size_t distance,
 /* NOLINTNEXTLINE(build/include) */
 #include "backward_references_inc.h"
 #undef HASHER
+#if defined(BROTLI_MAX_SIMD_QUALITY)
+#define HASHER() H58
+/* NOLINTNEXTLINE(build/include) */
+#include "backward_references_inc.h"
+#undef HASHER
+#define HASHER() H68
+/* NOLINTNEXTLINE(build/include) */
+#include "backward_references_inc.h"
+#undef HASHER
+#endif
 
 #undef ENABLE_COMPOUND_DICTIONARY
 #undef PREFIX
@@ -174,6 +194,10 @@ void BrotliCreateBackwardReferences(size_t num_bytes,
         return;
       CASE_(5)
       CASE_(6)
+#if defined(BROTLI_MAX_SIMD_QUALITY)
+      CASE_(58)
+      CASE_(68)
+#endif
       CASE_(40)
       CASE_(41)
       CASE_(42)
@@ -181,7 +205,7 @@ void BrotliCreateBackwardReferences(size_t num_bytes,
       CASE_(65)
 #undef CASE_
       default:
-        BROTLI_DCHECK(false);
+        BROTLI_DCHECK(BROTLI_FALSE);
         break;
     }
   }
@@ -197,7 +221,7 @@ void BrotliCreateBackwardReferences(size_t num_bytes,
     FOR_GENERIC_HASHERS(CASE_)
 #undef CASE_
     default:
-      BROTLI_DCHECK(false);
+      BROTLI_DCHECK(BROTLI_FALSE);
       break;
   }
 }

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

@@ -9,15 +9,11 @@
 #ifndef BROTLI_ENC_BACKWARD_REFERENCES_H_
 #define BROTLI_ENC_BACKWARD_REFERENCES_H_
 
-#include <brotli/types.h>
-
-#include "../common/constants.h"
 #include "../common/context.h"
-#include "../common/dictionary.h"
 #include "../common/platform.h"
 #include "command.h"
 #include "hash.h"
-#include "quality.h"
+#include "params.h"
 
 #if defined(__cplusplus) || defined(c_plusplus)
 extern "C" {

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

@@ -8,17 +8,15 @@
 
 #include "backward_references_hq.h"
 
-#include <string.h>  /* memcpy, memset */
-
-#include <brotli/types.h>
-
 #include "../common/constants.h"
+#include "../common/context.h"
 #include "../common/platform.h"
 #include "command.h"
 #include "compound_dictionary.h"
 #include "encoder_dict.h"
 #include "fast_log.h"
 #include "find_match_length.h"
+#include "hash.h"
 #include "literal_cost.h"
 #include "memory.h"
 #include "params.h"
@@ -34,10 +32,10 @@ extern "C" {
 
 static const float kInfinity = 1.7e38f;  /* ~= 2 ^ 127 */
 
-static const uint32_t kDistanceCacheIndex[] = {
+static const BROTLI_MODEL("small") uint32_t kDistanceCacheIndex[] = {
   0, 1, 2, 3, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1,
 };
-static const int kDistanceCacheOffset[] = {
+static const BROTLI_MODEL("small") int kDistanceCacheOffset[] = {
   0, 0, 0, 0, -1, 1, -2, 2, -3, 3, -1, 1, -2, 2, -3, 3
 };
 
@@ -345,22 +343,22 @@ static uint32_t ComputeDistanceShortcut(const size_t block_start,
                                         const size_t max_backward_limit,
                                         const size_t gap,
                                         const ZopfliNode* nodes) {
-  const size_t clen = ZopfliNodeCopyLength(&nodes[pos]);
-  const size_t ilen = nodes[pos].dcode_insert_length & 0x7FFFFFF;
+  const size_t c_len = ZopfliNodeCopyLength(&nodes[pos]);
+  const size_t i_len = nodes[pos].dcode_insert_length & 0x7FFFFFF;
   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
+     starts from |block_start + pos - c_len|. Distances that are greater than
      this or greater than |max_backward_limit| + |gap| 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 + gap &&
+  } else if (dist + c_len <= block_start + pos + gap &&
              dist <= max_backward_limit + gap &&
              ZopfliNodeDistanceCode(&nodes[pos]) > 0) {
     return (uint32_t)pos;
   } else {
-    return nodes[pos - clen - ilen].u.shortcut;
+    return nodes[pos - c_len - i_len].u.shortcut;
   }
 }
 
@@ -378,12 +376,12 @@ static void ComputeDistanceCache(const size_t pos,
   int idx = 0;
   size_t p = nodes[pos].u.shortcut;
   while (idx < 4 && p > 0) {
-    const size_t ilen = nodes[p].dcode_insert_length & 0x7FFFFFF;
-    const size_t clen = ZopfliNodeCopyLength(&nodes[p]);
+    const size_t i_len = nodes[p].dcode_insert_length & 0x7FFFFFF;
+    const size_t c_len = ZopfliNodeCopyLength(&nodes[p]);
     const size_t dist = ZopfliNodeCopyDistance(&nodes[p]);
     dist_cache[idx++] = (int)dist;
-    /* Because of prerequisite, p >= clen + ilen >= 2. */
-    p = nodes[p - clen - ilen].u.shortcut;
+    /* Because of prerequisite, p >= c_len + i_len >= 2. */
+    p = nodes[p - c_len - i_len].u.shortcut;
   }
   for (; idx < 4; ++idx) {
     dist_cache[idx] = *starting_dist_cache++;
@@ -435,6 +433,8 @@ static size_t UpdateNodes(
   const CompoundDictionary* addon = &params->dictionary.compound;
   size_t gap = addon->total_size;
 
+  BROTLI_DCHECK(cur_ix_masked + max_len <= ringbuffer_mask);
+
   EvaluateNode(block_start + stream_offset, pos, max_backward_limit, gap,
       starting_dist_cache, model, queue, nodes);
 

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

@@ -9,16 +9,12 @@
 #ifndef BROTLI_ENC_BACKWARD_REFERENCES_HQ_H_
 #define BROTLI_ENC_BACKWARD_REFERENCES_HQ_H_
 
-#include <brotli/types.h>
-
-#include "../common/constants.h"
 #include "../common/context.h"
-#include "../common/dictionary.h"
 #include "../common/platform.h"
 #include "command.h"
 #include "hash.h"
 #include "memory.h"
-#include "quality.h"
+#include "params.h"
 
 #if defined(__cplusplus) || defined(c_plusplus)
 extern "C" {

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

@@ -8,17 +8,41 @@
 
 #include "bit_cost.h"
 
-#include <brotli/types.h>
-
-#include "../common/constants.h"
 #include "../common/platform.h"
 #include "fast_log.h"
-#include "histogram.h"
 
 #if defined(__cplusplus) || defined(c_plusplus)
 extern "C" {
 #endif
 
+double BrotliBitsEntropy(const uint32_t* population, size_t size) {
+  size_t sum = 0;
+  double retval = 0;
+  const uint32_t* population_end = population + size;
+  size_t p;
+  if (size & 1) {
+    goto odd_number_of_elements_left;
+  }
+  while (population < population_end) {
+    p = *population++;
+    sum += p;
+    retval -= (double)p * FastLog2(p);
+ odd_number_of_elements_left:
+    p = *population++;
+    sum += p;
+    retval -= (double)p * FastLog2(p);
+  }
+  if (sum) retval += (double)sum * FastLog2(sum);
+
+  if (retval < (double)sum) {
+    /* TODO(eustas): consider doing that per-symbol? */
+    /* At least one bit per literal is needed. */
+    retval = (double)sum;
+  }
+
+  return retval;
+}
+
 #define FN(X) X ## Literal
 #include "bit_cost_inc.h"  /* NOLINT(build/include) */
 #undef FN

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

@@ -9,53 +9,21 @@
 #ifndef BROTLI_ENC_BIT_COST_H_
 #define BROTLI_ENC_BIT_COST_H_
 
-#include <brotli/types.h>
-
 #include "../common/platform.h"
-#include "fast_log.h"
 #include "histogram.h"
 
 #if defined(__cplusplus) || defined(c_plusplus)
 extern "C" {
 #endif
 
-static BROTLI_INLINE double ShannonEntropy(
-    const uint32_t* population, size_t size, size_t* total) {
-  size_t sum = 0;
-  double retval = 0;
-  const uint32_t* population_end = population + size;
-  size_t p;
-  if (size & 1) {
-    goto odd_number_of_elements_left;
-  }
-  while (population < population_end) {
-    p = *population++;
-    sum += p;
-    retval -= (double)p * FastLog2(p);
- odd_number_of_elements_left:
-    p = *population++;
-    sum += p;
-    retval -= (double)p * FastLog2(p);
-  }
-  if (sum) retval += (double)sum * FastLog2(sum);
-  *total = sum;
-  return retval;
-}
-
-static BROTLI_INLINE double BitsEntropy(
-    const uint32_t* population, size_t size) {
-  size_t sum;
-  double retval = ShannonEntropy(population, size, &sum);
-  if (retval < (double)sum) {
-    /* At least one bit per literal is needed. */
-    retval = (double)sum;
-  }
-  return retval;
-}
-
-BROTLI_INTERNAL double BrotliPopulationCostLiteral(const HistogramLiteral*);
-BROTLI_INTERNAL double BrotliPopulationCostCommand(const HistogramCommand*);
-BROTLI_INTERNAL double BrotliPopulationCostDistance(const HistogramDistance*);
+BROTLI_INTERNAL double BrotliBitsEntropy(
+    const uint32_t* population, size_t size);
+BROTLI_INTERNAL double BrotliPopulationCostLiteral(
+    const HistogramLiteral* histogram);
+BROTLI_INTERNAL double BrotliPopulationCostCommand(
+    const HistogramCommand* histogram);
+BROTLI_INTERNAL double BrotliPopulationCostDistance(
+    const HistogramDistance* histogram);
 
 #if defined(__cplusplus) || defined(c_plusplus)
 }  /* extern "C" */

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

@@ -119,7 +119,7 @@ double FN(BrotliPopulationCost)(const HistogramType* histogram) {
     /* Add the estimated encoding cost of the code length code histogram. */
     bits += (double)(18 + 2 * max_depth);
     /* Add the entropy of the code length code histogram. */
-    bits += BitsEntropy(depth_histo, BROTLI_CODE_LENGTH_CODES);
+    bits += BrotliBitsEntropy(depth_histo, BROTLI_CODE_LENGTH_CODES);
   }
   return bits;
 }

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

@@ -8,8 +8,6 @@
 
 #include "block_splitter.h"
 
-#include <string.h>  /* memcpy, memset */
-
 #include "../common/platform.h"
 #include "bit_cost.h"
 #include "cluster.h"
@@ -140,7 +138,7 @@ void BrotliSplitBlock(MemoryManager* m,
     CopyLiteralsToByteArray(cmds, num_commands, data, pos, mask, literals);
     /* Create the block split on the array of literals.
      * Literal histograms can have alphabet size up to 256.
-     * Though, to accomodate context modeling, less than half of maximum size
+     * Though, to accommodate context modeling, less than half of maximum size
      * is allowed. */
     SplitByteVectorLiteral(
         m, literals, literals_count,
@@ -150,7 +148,7 @@ void BrotliSplitBlock(MemoryManager* m,
     if (BROTLI_IS_OOM(m)) return;
     BROTLI_FREE(m, literals);
     /* NB: this might be a good place for injecting extra splitting without
-     *     increasing encoder complexity; however, output parition would be less
+     *     increasing encoder complexity; however, output partition would be less
      *     optimal than one produced with forced splitting inside
      *     SplitByteVector (FindBlocks / ClusterBlocks). */
   }
@@ -198,16 +196,15 @@ void BrotliSplitBlock(MemoryManager* m,
 }
 
 #if defined(BROTLI_TEST)
-size_t CountLiteralsForTest(const Command*, const size_t);
-size_t CountLiteralsForTest(const Command* cmds, const size_t num_commands) {
+size_t BrotliCountLiteralsForTest(const Command*, size_t);
+size_t BrotliCountLiteralsForTest(const Command* cmds, size_t num_commands) {
   return CountLiterals(cmds, num_commands);
 }
-
-void CopyLiteralsToByteArrayForTest(const Command*,
-    const size_t, const uint8_t*, const size_t, const size_t, uint8_t*);
-void CopyLiteralsToByteArrayForTest(const Command* cmds,
-    const size_t num_commands, const uint8_t* data, const size_t offset,
-    const size_t mask, uint8_t* literals) {
+void BrotliCopyLiteralsToByteArrayForTest(
+    const Command*, size_t, const uint8_t*, size_t, size_t, uint8_t*);
+void BrotliCopyLiteralsToByteArrayForTest(const Command* cmds,
+    size_t num_commands, const uint8_t* data, size_t offset, size_t mask,
+    uint8_t* literals) {
   CopyLiteralsToByteArray(cmds, num_commands, data, offset, mask, literals);
 }
 #endif

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

@@ -9,12 +9,9 @@
 #ifndef BROTLI_ENC_BLOCK_SPLITTER_H_
 #define BROTLI_ENC_BLOCK_SPLITTER_H_
 
-#include <brotli/types.h>
-
 #include "../common/platform.h"
 #include "command.h"
 #include "memory.h"
-#include "quality.h"
 
 #if defined(__cplusplus) || defined(c_plusplus)
 extern "C" {

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

@@ -79,7 +79,7 @@ static size_t FN(FindBlocks)(const DataType* data, const size_t length,
   size_t j;
   BROTLI_DCHECK(num_histograms <= 256);
 
-  /* Trivial case: single historgram -> single block type. */
+  /* Trivial case: single histogram -> single block type. */
   if (num_histograms <= 1) {
     for (i = 0; i < length; ++i) {
       block_id[i] = 0;
@@ -118,6 +118,8 @@ static size_t FN(FindBlocks)(const DataType* data, const size_t length,
     size_t insert_cost_ix = symbol * num_histograms;
     double min_cost = 1e99;
     double block_switch_cost = block_switch_bitcost;
+    static const size_t prologue_length = 2000;
+    static const double multiplier = 0.07 / 2000;
     size_t k;
     for (k = 0; k < num_histograms; ++k) {
       /* We are coding the symbol with entropy code k. */
@@ -128,8 +130,8 @@ static size_t FN(FindBlocks)(const DataType* data, const size_t length,
       }
     }
     /* More blocks for the beginning. */
-    if (byte_ix < 2000) {
-      block_switch_cost *= 0.77 + 0.07 * (double)byte_ix / 2000;
+    if (byte_ix < prologue_length) {
+      block_switch_cost *= 0.77 + multiplier * (double)byte_ix;
     }
     for (k = 0; k < num_histograms; ++k) {
       cost[k] -= min_cost;
@@ -228,12 +230,16 @@ static void FN(ClusterBlocks)(MemoryManager* m,
   static const uint32_t kInvalidIndex = BROTLI_UINT32_MAX;
   uint32_t* new_index;
   size_t i;
-  uint32_t* BROTLI_RESTRICT const sizes = u32 + 0 * HISTOGRAMS_PER_BATCH;
-  uint32_t* BROTLI_RESTRICT const new_clusters = u32 + 1 * HISTOGRAMS_PER_BATCH;
-  uint32_t* BROTLI_RESTRICT const symbols = u32 + 2 * HISTOGRAMS_PER_BATCH;
-  uint32_t* BROTLI_RESTRICT const remap = u32 + 3 * HISTOGRAMS_PER_BATCH;
+  uint32_t* BROTLI_RESTRICT const sizes =
+      u32 ? (u32 + 0 * HISTOGRAMS_PER_BATCH) : NULL;
+  uint32_t* BROTLI_RESTRICT const new_clusters =
+      u32 ? (u32 + 1 * HISTOGRAMS_PER_BATCH) : NULL;
+  uint32_t* BROTLI_RESTRICT const symbols =
+      u32 ? (u32 + 2 * HISTOGRAMS_PER_BATCH) : NULL;
+  uint32_t* BROTLI_RESTRICT const remap =
+      u32 ? (u32 + 3 * HISTOGRAMS_PER_BATCH) : NULL;
   uint32_t* BROTLI_RESTRICT const block_lengths =
-      u32 + 4 * HISTOGRAMS_PER_BATCH;
+      u32 ? (u32 + 4 * HISTOGRAMS_PER_BATCH) : NULL;
   /* TODO(eustas): move to arena? */
   HistogramType* tmp = BROTLI_ALLOC(m, HistogramType, 2);
 

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

@@ -10,10 +10,6 @@
 
 #include "brotli_bit_stream.h"
 
-#include <string.h>  /* memcpy, memset */
-
-#include <brotli/types.h>
-
 #include "../common/constants.h"
 #include "../common/context.h"
 #include "../common/platform.h"
@@ -169,7 +165,8 @@ static void BrotliStoreUncompressedMetaBlockHeader(size_t length,
 static void BrotliStoreHuffmanTreeOfHuffmanTreeToBitMask(
     const int num_codes, const uint8_t* code_length_bitdepth,
     size_t* storage_ix, uint8_t* storage) {
-  static const uint8_t kStorageOrder[BROTLI_CODE_LENGTH_CODES] = {
+  static const BROTLI_MODEL("small")
+  uint8_t kStorageOrder[BROTLI_CODE_LENGTH_CODES] = {
     1, 2, 3, 4, 0, 5, 17, 6, 16, 7, 8, 9, 10, 11, 12, 13, 14, 15
   };
   /* The bit lengths of the Huffman code over the code length alphabet
@@ -182,10 +179,12 @@ static void BrotliStoreHuffmanTreeOfHuffmanTreeToBitMask(
        3          01
        4          10
        5        1111 */
-  static const uint8_t kHuffmanBitLengthHuffmanCodeSymbols[6] = {
+  static const BROTLI_MODEL("small")
+  uint8_t kHuffmanBitLengthHuffmanCodeSymbols[6] = {
      0, 7, 3, 2, 1, 15
   };
-  static const uint8_t kHuffmanBitLengthHuffmanCodeBitLengths[6] = {
+  static const BROTLI_MODEL("small")
+  uint8_t kHuffmanBitLengthHuffmanCodeBitLengths[6] = {
     2, 4, 3, 2, 2, 4
   };
 
@@ -1325,8 +1324,10 @@ void BrotliStoreUncompressedMetaBlock(BROTLI_BOOL is_final_block,
 }
 
 #if defined(BROTLI_TEST)
-void GetBlockLengthPrefixCodeForTest(uint32_t len, size_t* code,
-                                     uint32_t* n_extra, uint32_t* extra) {
+void BrotliGetBlockLengthPrefixCodeForTest(uint32_t len, size_t* code,
+                                           uint32_t* n_extra, uint32_t* extra);
+void BrotliGetBlockLengthPrefixCodeForTest(uint32_t len, size_t* code,
+                                           uint32_t* n_extra, uint32_t* extra) {
   GetBlockLengthPrefixCode(len, code, n_extra, extra);
 }
 #endif

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

@@ -16,8 +16,6 @@
 #ifndef BROTLI_ENC_BROTLI_BIT_STREAM_H_
 #define BROTLI_ENC_BROTLI_BIT_STREAM_H_
 
-#include <brotli/types.h>
-
 #include "../common/context.h"
 #include "../common/platform.h"
 #include "command.h"
@@ -78,10 +76,6 @@ BROTLI_INTERNAL void BrotliStoreUncompressedMetaBlock(
     size_t position, size_t mask, size_t len,
     size_t* BROTLI_RESTRICT storage_ix, uint8_t* BROTLI_RESTRICT storage);
 
-#if defined(BROTLI_TEST)
-void GetBlockLengthPrefixCodeForTest(uint32_t, size_t*, uint32_t*, uint32_t*);
-#endif
-
 #if defined(__cplusplus) || defined(c_plusplus)
 }  /* extern "C" */
 #endif