multi_compress 0.3.2 → 0.3.4

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

@@ -7,34 +7,32 @@
 /* Implementation of Brotli compressor. */
 
 #include <brotli/encode.h>
-#include <brotli/shared_dictionary.h>
-#include <brotli/types.h>
-
-#include <stdlib.h>  /* free, malloc */
-#include <string.h>  /* memcpy, memset */
 
 #include "../common/constants.h"
 #include "../common/context.h"
 #include "../common/platform.h"
+#include <brotli/shared_dictionary.h>
 #include "../common/version.h"
-#include "backward_references.h"
 #include "backward_references_hq.h"
+#include "backward_references.h"
 #include "bit_cost.h"
 #include "brotli_bit_stream.h"
-#include "compress_fragment.h"
+#include "command.h"
+#include "compound_dictionary.h"
 #include "compress_fragment_two_pass.h"
+#include "compress_fragment.h"
 #include "dictionary_hash.h"
 #include "encoder_dict.h"
-#include "entropy_encode.h"
 #include "fast_log.h"
 #include "hash.h"
 #include "histogram.h"
 #include "memory.h"
 #include "metablock.h"
-#include "prefix.h"
-#include "state.h"
+#include "params.h"
 #include "quality.h"
 #include "ringbuffer.h"
+#include "state.h"
+#include "static_init.h"
 #include "utf8_util.h"
 #include "write_bits.h"
 
@@ -202,7 +200,7 @@ static void EncodeWindowBits(int lgwin, BROTLI_BOOL large_window,
 /* TODO(eustas): move to compress_fragment.c? */
 /* Initializes the command and distance prefix codes for the first block. */
 static void InitCommandPrefixCodes(BrotliOnePassArena* s) {
-  static const uint8_t kDefaultCommandDepths[128] = {
+  static const BROTLI_MODEL("small") uint8_t kDefaultCommandDepths[128] = {
     0, 4, 4, 5, 6, 6, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8,
     0, 0, 0, 4, 4, 4, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7,
     7, 7, 10, 10, 10, 10, 10, 10, 0, 4, 4, 5, 5, 5, 6, 6,
@@ -212,7 +210,7 @@ static void InitCommandPrefixCodes(BrotliOnePassArena* s) {
     4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 7, 7, 7, 8, 10,
     12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
   };
-  static const uint16_t kDefaultCommandBits[128] = {
+  static const BROTLI_MODEL("small") uint16_t kDefaultCommandBits[128] = {
     0,   0,   8,   9,   3,  35,   7,   71,
     39, 103,  23,  47, 175, 111, 239,   31,
     0,   0,   0,   4,  12,   2,  10,    6,
@@ -226,7 +224,7 @@ static void InitCommandPrefixCodes(BrotliOnePassArena* s) {
     2, 10, 6, 21, 13, 29, 3, 19, 11, 15, 47, 31, 95, 63, 127, 255,
     767, 2815, 1791, 3839, 511, 2559, 1535, 3583, 1023, 3071, 2047, 4095,
   };
-  static const uint8_t kDefaultCommandCode[] = {
+  static const BROTLI_MODEL("small") uint8_t kDefaultCommandCode[] = {
     0xff, 0x77, 0xd5, 0xbf, 0xe7, 0xde, 0xea, 0x9e, 0x51, 0x5d, 0xde, 0xc6,
     0x70, 0x57, 0xbc, 0x58, 0x58, 0x58, 0xd8, 0xd8, 0x58, 0xd5, 0xcb, 0x8c,
     0xea, 0xe0, 0xc3, 0x87, 0x1f, 0x83, 0xc1, 0x60, 0x1c, 0x67, 0xb2, 0xaa,
@@ -243,24 +241,39 @@ static void InitCommandPrefixCodes(BrotliOnePassArena* s) {
   s->cmd_code_numbits = kDefaultCommandCodeNumBits;
 }
 
+/* TODO(eustas): avoid FP calculations. */
+static double EstimateEntropy(const uint32_t* population, size_t size) {
+  size_t total = 0;
+  double result = 0;
+  for (size_t i = 0; i < size; ++i) {
+    uint32_t p = population[i];
+    total += p;
+    result += (double)p * FastLog2(p);
+  }
+  result = (double)total * FastLog2(total) - result;
+  return result;
+}
+
 /* Decide about the context map based on the ability of the prediction
    ability of the previous byte UTF8-prefix on the next byte. The
    prediction ability is calculated as Shannon entropy. Here we need
-   Shannon entropy instead of 'BitsEntropy' since the prefix will be
+   Shannon entropy instead of 'BrotliBitsEntropy' since the prefix will be
    encoded with the remaining 6 bits of the following byte, and
-   BitsEntropy will assume that symbol to be stored alone using Huffman
+   BrotliBitsEntropy will assume that symbol to be stored alone using Huffman
    coding. */
 static void ChooseContextMap(int quality,
                              uint32_t* bigram_histo,
                              size_t* num_literal_contexts,
                              const uint32_t** literal_context_map) {
-  static const uint32_t kStaticContextMapContinuation[64] = {
+  static const BROTLI_MODEL("small")
+  uint32_t kStaticContextMapContinuation[64] = {
     1, 1, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
   };
-  static const uint32_t kStaticContextMapSimpleUTF8[64] = {
+  static const BROTLI_MODEL("small")
+  uint32_t kStaticContextMapSimpleUTF8[64] = {
     0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
@@ -271,18 +284,17 @@ static void ChooseContextMap(int quality,
   uint32_t two_prefix_histo[6] = { 0 };
   size_t total;
   size_t i;
-  size_t dummy;
   double entropy[4];
   for (i = 0; i < 9; ++i) {
     monogram_histo[i % 3] += bigram_histo[i];
     two_prefix_histo[i % 6] += bigram_histo[i];
   }
-  entropy[1] = ShannonEntropy(monogram_histo, 3, &dummy);
-  entropy[2] = (ShannonEntropy(two_prefix_histo, 3, &dummy) +
-                ShannonEntropy(two_prefix_histo + 3, 3, &dummy));
+  entropy[1] = EstimateEntropy(monogram_histo, 3);
+  entropy[2] = (EstimateEntropy(two_prefix_histo, 3) +
+                EstimateEntropy(two_prefix_histo + 3, 3));
   entropy[3] = 0;
   for (i = 0; i < 3; ++i) {
-    entropy[3] += ShannonEntropy(bigram_histo + 3 * i, 3, &dummy);
+    entropy[3] += EstimateEntropy(bigram_histo + 3 * i, 3);
   }
 
   total = monogram_histo[0] + monogram_histo[1] + monogram_histo[2];
@@ -317,7 +329,8 @@ static BROTLI_BOOL ShouldUseComplexStaticContextMap(const uint8_t* input,
     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,
     uint32_t* arena) {
-  static const uint32_t kStaticContextMapComplexUTF8[64] = {
+  static const BROTLI_MODEL("small")
+  uint32_t kStaticContextMapComplexUTF8[64] = {
     11, 11, 12, 12, /* 0 special */
     0, 0, 0, 0, /* 4 lf */
     1, 1, 9, 9, /* 8 space */
@@ -348,10 +361,9 @@ static BROTLI_BOOL ShouldUseComplexStaticContextMap(const uint8_t* input,
     uint32_t* BROTLI_RESTRICT const context_histo = arena + 32;
     uint32_t total = 0;
     double entropy[3];
-    size_t dummy;
     size_t i;
     ContextLut utf8_lut = BROTLI_CONTEXT_LUT(CONTEXT_UTF8);
-    memset(arena, 0, sizeof(arena[0]) * 32 * 14);
+    memset(arena, 0, sizeof(arena[0]) * 32 * (BROTLI_MAX_STATIC_CONTEXTS + 1));
     for (; start_pos + 64 <= end_pos; start_pos += 4096) {
       const size_t stride_end_pos = start_pos + 64;
       uint8_t prev2 = input[start_pos & mask];
@@ -370,10 +382,10 @@ static BROTLI_BOOL ShouldUseComplexStaticContextMap(const uint8_t* input,
         prev1 = literal;
       }
     }
-    entropy[1] = ShannonEntropy(combined_histo, 32, &dummy);
+    entropy[1] = EstimateEntropy(combined_histo, 32);
     entropy[2] = 0;
-    for (i = 0; i < 13; ++i) {
-      entropy[2] += ShannonEntropy(context_histo + (i << 5), 32, &dummy);
+    for (i = 0; i < BROTLI_MAX_STATIC_CONTEXTS; ++i) {
+      entropy[2] += EstimateEntropy(context_histo + (i << 5), 32);
     }
     entropy[0] = 1.0 / (double)total;
     entropy[1] *= entropy[0];
@@ -388,7 +400,7 @@ static BROTLI_BOOL ShouldUseComplexStaticContextMap(const uint8_t* input,
     if (entropy[2] > 3.0 || entropy[1] - entropy[2] < 0.2) {
       return BROTLI_FALSE;
     } else {
-      *num_literal_contexts = 13;
+      *num_literal_contexts = BROTLI_MAX_STATIC_CONTEXTS;
       *literal_context_map = kStaticContextMapComplexUTF8;
       return BROTLI_TRUE;
     }
@@ -437,9 +449,10 @@ static BROTLI_BOOL ShouldCompress(
     if ((double)num_literals > 0.99 * (double)bytes) {
       uint32_t literal_histo[256] = { 0 };
       static const uint32_t kSampleRate = 13;
+      static const double kInvSampleRate = 1.0 / 13.0;
       static const double kMinEntropy = 7.92;
       const double bit_cost_threshold =
-          (double)bytes * kMinEntropy / kSampleRate;
+          (double)bytes * kMinEntropy * kInvSampleRate;
       size_t t = (bytes + kSampleRate - 1) / kSampleRate;
       uint32_t pos = (uint32_t)last_flush_pos;
       size_t i;
@@ -447,7 +460,7 @@ static BROTLI_BOOL ShouldCompress(
         ++literal_histo[data[pos & mask]];
         pos += kSampleRate;
       }
-      if (BitsEntropy(literal_histo, 256) > bit_cost_threshold) {
+      if (BrotliBitsEntropy(literal_histo, 256) > bit_cost_threshold) {
         return BROTLI_FALSE;
       }
     }
@@ -532,7 +545,8 @@ static void WriteMetaBlockInternal(MemoryManager* m,
       const uint32_t* literal_context_map = NULL;
       if (!params->disable_literal_context_modeling) {
         /* TODO(eustas): pull to higher level and reuse. */
-        uint32_t* arena = BROTLI_ALLOC(m, uint32_t, 14 * 32);
+        uint32_t* arena =
+            BROTLI_ALLOC(m, uint32_t, 32 * (BROTLI_MAX_STATIC_CONTEXTS + 1));
         if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(arena)) return;
         DecideOverLiteralContextModeling(
             data, wrapped_last_flush_pos, bytes, mask, params->quality,
@@ -686,7 +700,23 @@ static void BrotliEncoderCleanupParams(MemoryManager* m,
   BrotliCleanupSharedEncoderDictionary(m, &params->dictionary);
 }
 
+#ifdef BROTLI_REPORTING
+/* When BROTLI_REPORTING is defined extra reporting module have to be linked. */
+void BrotliEncoderOnStart(const BrotliEncoderState* s);
+void BrotliEncoderOnFinish(const BrotliEncoderState* s);
+#define BROTLI_ENCODER_ON_START(s) BrotliEncoderOnStart(s);
+#define BROTLI_ENCODER_ON_FINISH(s) BrotliEncoderOnFinish(s);
+#else
+#if !defined(BROTLI_ENCODER_ON_START)
+#define BROTLI_ENCODER_ON_START(s) (void)(s);
+#endif
+#if !defined(BROTLI_ENCODER_ON_FINISH)
+#define BROTLI_ENCODER_ON_FINISH(s) (void)(s);
+#endif
+#endif
+
 static void BrotliEncoderInitState(BrotliEncoderState* s) {
+  BROTLI_ENCODER_ON_START(s);
   BrotliEncoderInitParams(&s->params);
   s->input_pos_ = 0;
   s->num_commands_ = 0;
@@ -730,6 +760,10 @@ static void BrotliEncoderInitState(BrotliEncoderState* s) {
 
 BrotliEncoderState* BrotliEncoderCreateInstance(
     brotli_alloc_func alloc_func, brotli_free_func free_func, void* opaque) {
+  BROTLI_BOOL healthy = BrotliEncoderEnsureStaticInit();
+  if (!healthy) {
+    return 0;
+  }
   BrotliEncoderState* state = (BrotliEncoderState*)BrotliBootstrapAlloc(
       sizeof(BrotliEncoderState), alloc_func, free_func, opaque);
   if (state == NULL) {
@@ -742,16 +776,6 @@ BrotliEncoderState* BrotliEncoderCreateInstance(
   return state;
 }
 
-#ifdef BROTLI_REPORTING
-/* When BROTLI_REPORTING is defined extra reporting module have to be linked. */
-void BrotliEncoderOnFinish(const BrotliEncoderState* s);
-#define BROTLI_ENCODER_ON_FINISH(s) BrotliEncoderOnFinish(s);
-#else
-#if !defined(BROTLI_ENCODER_ON_FINISH)
-#define BROTLI_ENCODER_ON_FINISH(s) (void)(s);
-#endif
-#endif
-
 static void BrotliEncoderCleanupState(BrotliEncoderState* s) {
   MemoryManager* m = &s->memory_manager_;
 
@@ -817,7 +841,7 @@ static void CopyInputToRingBuffer(BrotliEncoderState* s,
      reading new bytes from the input. However, at the last few indexes of
      the ring buffer, there are not enough bytes to build full-length
      substrings from. Since the hash table always contains full-length
-     substrings, we erase with dummy zeros here to make sure that those
+     substrings, we overwrite with zeros here to make sure that those
      substrings will contain zeros at the end instead of uninitialized
      data.
 
@@ -1750,7 +1774,7 @@ BrotliEncoderPreparedDictionary* BrotliEncoderPrepareDictionary(
   return (BrotliEncoderPreparedDictionary*)managed_dictionary;
 }
 
-void BrotliEncoderDestroyPreparedDictionary(
+void BROTLI_COLD BrotliEncoderDestroyPreparedDictionary(
     BrotliEncoderPreparedDictionary* dictionary) {
   ManagedDictionary* dict = (ManagedDictionary*)dictionary;
   if (!dictionary) return;
@@ -1776,7 +1800,8 @@ void BrotliEncoderDestroyPreparedDictionary(
   BrotliDestroyManagedDictionary(dict);
 }
 
-BROTLI_BOOL BrotliEncoderAttachPreparedDictionary(BrotliEncoderState* state,
+BROTLI_BOOL BROTLI_COLD BrotliEncoderAttachPreparedDictionary(
+    BrotliEncoderState* state,
     const BrotliEncoderPreparedDictionary* dictionary) {
   /* First field of dictionary structs */
   const BrotliEncoderPreparedDictionary* dict = dictionary;
@@ -1833,8 +1858,8 @@ BROTLI_BOOL BrotliEncoderAttachPreparedDictionary(BrotliEncoderState* state,
   return BROTLI_TRUE;
 }
 
-size_t BrotliEncoderEstimatePeakMemoryUsage(int quality, int lgwin,
-                                            size_t input_size) {
+size_t BROTLI_COLD BrotliEncoderEstimatePeakMemoryUsage(int quality, int lgwin,
+                                                        size_t input_size) {
   BrotliEncoderParams params;
   size_t memory_manager_slots = BROTLI_ENCODER_MEMORY_MANAGER_SLOTS;
   size_t memory_manager_size = memory_manager_slots * sizeof(void*);
@@ -1849,7 +1874,7 @@ size_t BrotliEncoderEstimatePeakMemoryUsage(int quality, int lgwin,
   if (params.quality == FAST_ONE_PASS_COMPRESSION_QUALITY ||
       params.quality == FAST_TWO_PASS_COMPRESSION_QUALITY) {
     size_t state_size = sizeof(BrotliEncoderState);
-    size_t block_size = BROTLI_MIN(size_t, input_size, (1ul << params.lgwin));
+    size_t block_size = BROTLI_MIN(size_t, input_size, ((size_t)1ul << params.lgwin));
     size_t hash_table_size =
         HashTableSize(MaxHashTableSize(params.quality), block_size);
     size_t hash_size =
@@ -1866,7 +1891,7 @@ size_t BrotliEncoderEstimatePeakMemoryUsage(int quality, int lgwin,
     size_t short_ringbuffer_size = (size_t)1 << params.lgblock;
     int ringbuffer_bits = ComputeRbBits(&params);
     size_t ringbuffer_size = input_size < short_ringbuffer_size ?
-        input_size : (1u << ringbuffer_bits) + short_ringbuffer_size;
+        input_size : ((size_t)1u << ringbuffer_bits) + short_ringbuffer_size;
     size_t hash_size[4] = {0};
     size_t metablock_size =
         BROTLI_MIN(size_t, input_size, MaxMetablockSize(&params));
@@ -1901,7 +1926,7 @@ size_t BrotliEncoderEstimatePeakMemoryUsage(int quality, int lgwin,
             histogram_size);
   }
 }
-size_t BrotliEncoderGetPreparedDictionarySize(
+size_t BROTLI_COLD BrotliEncoderGetPreparedDictionarySize(
     const BrotliEncoderPreparedDictionary* prepared_dictionary) {
   /* First field of dictionary structs */
   const BrotliEncoderPreparedDictionary* prepared = prepared_dictionary;
@@ -1984,8 +2009,8 @@ size_t BrotliEncoderGetPreparedDictionarySize(
 }
 
 #if defined(BROTLI_TEST)
-size_t MakeUncompressedStreamForTest(const uint8_t*, size_t, uint8_t*);
-size_t MakeUncompressedStreamForTest(
+size_t BrotliMakeUncompressedStreamForTest(const uint8_t*, size_t, uint8_t*);
+size_t BrotliMakeUncompressedStreamForTest(
     const uint8_t* input, size_t input_size, uint8_t* output) {
   return MakeUncompressedStream(input, input_size, output);
 }

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

@@ -6,17 +6,19 @@
 
 #include "encoder_dict.h"
 
-#include <stdlib.h>  /* malloc, free */
-
 #include "../common/dictionary.h"
 #include "../common/platform.h"
+#include <brotli/shared_dictionary.h>
 #include "../common/shared_dictionary_internal.h"
 #include "../common/transform.h"
+#include <brotli/encode.h>
 #include "compound_dictionary.h"
 #include "dictionary_hash.h"
+#include "hash_base.h"
+#include "hash.h"
 #include "memory.h"
 #include "quality.h"
-#include "hash.h"
+#include "static_dict_lut.h"
 
 #if defined(__cplusplus) || defined(c_plusplus)
 extern "C" {
@@ -118,8 +120,8 @@ static uint32_t BrotliTrieAlloc(MemoryManager* m, size_t num, BrotliTrie* trie,
     keep_index = (uint32_t)(*keep - trie->pool);
   }
   if (trie->pool_size == 0) {
-    /* Have a dummy node in the front. We do not want the result to be 0, it
-    must be at least 1, 0 represents "null pointer" */
+    /* Have a placeholder node in the front. We do not want the result to be 0,
+       it must be at least 1, 0 represents "null pointer" */
     trie->pool_size = 1;
   }
   BROTLI_ENSURE_CAPACITY(m, BrotliTrieNode, trie->pool, trie->pool_capacity,
@@ -629,8 +631,8 @@ void BrotliDestroyManagedDictionary(ManagedDictionary* dictionary) {
 
 /* Escalate internal functions visibility; for testing purposes only. */
 #if defined(BROTLI_TEST)
-void InitEncoderDictionaryForTest(BrotliEncoderDictionary*);
-void InitEncoderDictionaryForTest(BrotliEncoderDictionary* d) {
+void BrotliInitEncoderDictionaryForTest(BrotliEncoderDictionary*);
+void BrotliInitEncoderDictionaryForTest(BrotliEncoderDictionary* d) {
   InitEncoderDictionary(d);
 }
 #endif

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

@@ -7,10 +7,8 @@
 #ifndef BROTLI_ENC_ENCODER_DICT_H_
 #define BROTLI_ENC_ENCODER_DICT_H_
 
-#include <brotli/shared_dictionary.h>
-#include <brotli/types.h>
-
 #include "../common/dictionary.h"
+#include <brotli/shared_dictionary.h>
 #include "../common/platform.h"
 #include "compound_dictionary.h"
 #include "memory.h"
@@ -30,7 +28,7 @@ Dictionary hierarchy for Encoder:
 ---BrotliEncoderDictionary [up to 64x]
    = for each context, precomputed static dictionary with words + transforms
 
-Dictionary hiearchy from common: similar, but without precomputed hashes
+Dictionary hierarchy from common: similar, but without precomputed hashes
 -BrotliSharedDictionary
 --BrotliDictionary [up to 64x]
 --BrotliTransforms [up to 64x]

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

@@ -8,10 +8,6 @@
 
 #include "entropy_encode.h"
 
-#include <string.h>  /* memset */
-
-#include <brotli/types.h>
-
 #include "../common/constants.h"
 #include "../common/platform.h"
 
@@ -19,7 +15,7 @@
 extern "C" {
 #endif
 
-const size_t kBrotliShellGaps[] = {132, 57, 23, 10, 4, 1};
+const BROTLI_MODEL("small") size_t kBrotliShellGaps[] = {132, 57, 23, 10, 4, 1};
 
 BROTLI_BOOL BrotliSetDepth(
     int p0, HuffmanTree* pool, uint8_t* depth, int max_depth) {
@@ -456,7 +452,8 @@ void BrotliWriteHuffmanTree(const uint8_t* depth,
 }
 
 static uint16_t BrotliReverseBits(size_t num_bits, uint16_t bits) {
-  static const size_t kLut[16] = {  /* Pre-reversed 4-bit values. */
+  static const size_t BROTLI_MODEL("small") kLut[16] =
+  {  /* Pre-reversed 4-bit values. */
     0x00, 0x08, 0x04, 0x0C, 0x02, 0x0A, 0x06, 0x0E,
     0x01, 0x09, 0x05, 0x0D, 0x03, 0x0B, 0x07, 0x0F
   };

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

@@ -9,8 +9,6 @@
 #ifndef BROTLI_ENC_ENTROPY_ENCODE_H_
 #define BROTLI_ENC_ENTROPY_ENCODE_H_
 
-#include <brotli/types.h>
-
 #include "../common/platform.h"
 
 #if defined(__cplusplus) || defined(c_plusplus)
@@ -67,7 +65,7 @@ BROTLI_INTERNAL void BrotliOptimizeHuffmanCountsForRle(
    of a Huffman tree. The generated Huffman tree is to be compressed once
    more using a Huffman tree */
 BROTLI_INTERNAL void BrotliWriteHuffmanTree(const uint8_t* depth,
-                                            size_t num,
+                                            size_t length,
                                             size_t* tree_size,
                                             uint8_t* tree,
                                             uint8_t* extra_bits_data);
@@ -77,7 +75,7 @@ BROTLI_INTERNAL void BrotliConvertBitDepthsToSymbols(const uint8_t* depth,
                                                      size_t len,
                                                      uint16_t* bits);
 
-BROTLI_INTERNAL extern const size_t kBrotliShellGaps[6];
+BROTLI_INTERNAL extern BROTLI_MODEL("small") const size_t kBrotliShellGaps[6];
 /* Input size optimized Shell sort. */
 typedef BROTLI_BOOL (*HuffmanTreeComparator)(
     const HuffmanTree*, const HuffmanTree*);

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

@@ -9,8 +9,6 @@
 #ifndef BROTLI_ENC_ENTROPY_ENCODE_STATIC_H_
 #define BROTLI_ENC_ENTROPY_ENCODE_STATIC_H_
 
-#include <brotli/types.h>
-
 #include "../common/constants.h"
 #include "../common/platform.h"
 #include "write_bits.h"
@@ -19,11 +17,12 @@
 extern "C" {
 #endif
 
-static const uint8_t kCodeLengthDepth[18] = {
+static const BROTLI_MODEL("small") uint8_t kCodeLengthDepth[18] = {
   4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 0, 4, 4,
 };
 
-static const uint8_t kStaticCommandCodeDepth[BROTLI_NUM_COMMAND_SYMBOLS] = {
+static const BROTLI_MODEL("small")
+uint8_t kStaticCommandCodeDepth[BROTLI_NUM_COMMAND_SYMBOLS] = {
    9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
    9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
    9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
@@ -70,7 +69,8 @@ static const uint8_t kStaticCommandCodeDepth[BROTLI_NUM_COMMAND_SYMBOLS] = {
   11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
 };
 
-static const uint8_t kStaticDistanceCodeDepth[64] = {
+static const BROTLI_MODEL("small")
+uint8_t kStaticDistanceCodeDepth[64] = {
   6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
   6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
   6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
@@ -78,7 +78,8 @@ static const uint8_t kStaticDistanceCodeDepth[64] = {
 };
 
 /* GENERATED CODE START */
-static const uint32_t kCodeLengthBits[18] = {
+static const BROTLI_MODEL("small")
+uint32_t kCodeLengthBits[18] = {
   0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 15, 31, 0, 11, 7,
 };
 
@@ -88,7 +89,8 @@ static BROTLI_INLINE void StoreStaticCodeLengthCode(
       40, BROTLI_MAKE_UINT64_T(0x0000FFu, 0x55555554u), storage_ix, storage);
 }
 
-static const uint64_t kZeroRepsBits[BROTLI_NUM_COMMAND_SYMBOLS] = {
+static const BROTLI_MODEL("small")
+uint64_t kZeroRepsBits[BROTLI_NUM_COMMAND_SYMBOLS] = {
   0x00000000, 0x00000000, 0x00000000, 0x00000007, 0x00000017, 0x00000027,
   0x00000037, 0x00000047, 0x00000057, 0x00000067, 0x00000077, 0x00000770,
   0x00000b87, 0x00001387, 0x00001b87, 0x00002387, 0x00002b87, 0x00003387,
@@ -209,7 +211,8 @@ static const uint64_t kZeroRepsBits[BROTLI_NUM_COMMAND_SYMBOLS] = {
   0x06f9cb87, 0x08f9cb87,
 };
 
-static const uint32_t kZeroRepsDepth[BROTLI_NUM_COMMAND_SYMBOLS] = {
+static const BROTLI_MODEL("small")
+uint32_t kZeroRepsDepth[BROTLI_NUM_COMMAND_SYMBOLS] = {
    0,  4,  8,  7,  7,  7,  7,  7,  7,  7,  7, 11, 14, 14, 14, 14,
   14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
   14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
@@ -256,7 +259,8 @@ static const uint32_t kZeroRepsDepth[BROTLI_NUM_COMMAND_SYMBOLS] = {
   28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
 };
 
-static const uint64_t kNonZeroRepsBits[BROTLI_NUM_COMMAND_SYMBOLS] = {
+static const BROTLI_MODEL("small")
+uint64_t kNonZeroRepsBits[BROTLI_NUM_COMMAND_SYMBOLS] = {
   0x0000000b, 0x0000001b, 0x0000002b, 0x0000003b, 0x000002cb, 0x000006cb,
   0x00000acb, 0x00000ecb, 0x000002db, 0x000006db, 0x00000adb, 0x00000edb,
   0x000002eb, 0x000006eb, 0x00000aeb, 0x00000eeb, 0x000002fb, 0x000006fb,
@@ -377,7 +381,8 @@ static const uint64_t kNonZeroRepsBits[BROTLI_NUM_COMMAND_SYMBOLS] = {
   0x2baeb6db, 0x3baeb6db,
 };
 
-static const uint32_t kNonZeroRepsDepth[BROTLI_NUM_COMMAND_SYMBOLS] = {
+static const BROTLI_MODEL("small")
+uint32_t kNonZeroRepsDepth[BROTLI_NUM_COMMAND_SYMBOLS] = {
    6,  6,  6,  6, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
   12, 12, 12, 12, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
   18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
@@ -424,7 +429,8 @@ static const uint32_t kNonZeroRepsDepth[BROTLI_NUM_COMMAND_SYMBOLS] = {
   30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
 };
 
-static const uint16_t kStaticCommandCodeBits[BROTLI_NUM_COMMAND_SYMBOLS] = {
+static const BROTLI_MODEL("small")
+uint16_t kStaticCommandCodeBits[BROTLI_NUM_COMMAND_SYMBOLS] = {
     0,  256,  128,  384,   64,  320,  192,  448,
    32,  288,  160,  416,   96,  352,  224,  480,
    16,  272,  144,  400,   80,  336,  208,  464,
@@ -522,7 +528,7 @@ static BROTLI_INLINE void StoreStaticCommandHuffmanTree(
   BrotliWriteBits(3, 0x00000000U, storage_ix, storage);
 }
 
-static const uint16_t kStaticDistanceCodeBits[64] = {
+static const BROTLI_MODEL("small") uint16_t kStaticDistanceCodeBits[64] = {
    0, 32, 16, 48,  8, 40, 24, 56,  4, 36, 20, 52, 12, 44, 28, 60,
    2, 34, 18, 50, 10, 42, 26, 58,  6, 38, 22, 54, 14, 46, 30, 62,
    1, 33, 17, 49,  9, 41, 25, 57,  5, 37, 21, 53, 13, 45, 29, 61,

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

@@ -11,7 +11,7 @@ extern "C" {
 #endif
 
 /* ", ".join(["%.16ff" % x for x in [0.0]+[log2(x) for x in range(1, 256)]]) */
-const double kBrotliLog2Table[BROTLI_LOG2_TABLE_SIZE] = {
+const BROTLI_MODEL("small") double kBrotliLog2Table[BROTLI_LOG2_TABLE_SIZE] = {
   0.0000000000000000f, 0.0000000000000000f, 1.0000000000000000f,
   1.5849625007211563f, 2.0000000000000000f, 2.3219280948873622f,
   2.5849625007211561f, 2.8073549220576042f, 3.0000000000000000f,

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

@@ -11,8 +11,6 @@
 
 #include <math.h>
 
-#include <brotli/types.h>
-
 #include "../common/platform.h"
 
 #if defined(__cplusplus) || defined(c_plusplus)
@@ -33,7 +31,8 @@ static BROTLI_INLINE uint32_t Log2FloorNonZero(size_t n) {
 
 /* A lookup table for small values of log2(int) to be used in entropy
    computation. */
-BROTLI_INTERNAL extern const double kBrotliLog2Table[BROTLI_LOG2_TABLE_SIZE];
+BROTLI_INTERNAL extern const BROTLI_MODEL("small")
+double kBrotliLog2Table[BROTLI_LOG2_TABLE_SIZE];
 
 /* Visual Studio 2012 and Android API levels < 18 do not have the log2()
  * function defined, so we use log() and a multiplication instead. */

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

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