brotli 0.1.0 → 0.1.1

data/vendor/brotli/dec/huffman.c

@@ -1,16 +1,7 @@
 /* Copyright 2013 Google Inc. All Rights Reserved.
 
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-   http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
+   Distributed under MIT license.
+   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
 */
 
 /* Utilities for building Huffman decoding tables. */
@@ -25,17 +16,59 @@
 extern "C" {
 #endif
 
-/* Returns reverse(reverse(key, len) + 1, len), where reverse(key, len) is the
-   bit-wise reversal of the len least significant bits of key. */
-static BROTLI_INLINE uint32_t GetNextKey(uint32_t key, int len) {
+#define BROTLI_REVERSE_BITS_MAX 8
+
 #ifdef BROTLI_RBIT
-  return BROTLI_RBIT(BROTLI_RBIT(key) + (1 << (8 * sizeof(unsigned) - len)));
+#define BROTLI_REVERSE_BITS_BASE (32 - BROTLI_REVERSE_BITS_MAX)
 #else
-  unsigned step = (unsigned)(1 << (len - 1));
-  while (key & step) {
-    step >>= 1;
-  }
-  return (key & (step - 1)) + step;
+#define BROTLI_REVERSE_BITS_BASE 0
+static uint8_t kReverseBits[1 << BROTLI_REVERSE_BITS_MAX] = {
+    0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0,
+    0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0,
+    0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8,
+    0x18, 0x98, 0x58, 0xD8, 0x38, 0xB8, 0x78, 0xF8,
+    0x04, 0x84, 0x44, 0xC4, 0x24, 0xA4, 0x64, 0xE4,
+    0x14, 0x94, 0x54, 0xD4, 0x34, 0xB4, 0x74, 0xF4,
+    0x0C, 0x8C, 0x4C, 0xCC, 0x2C, 0xAC, 0x6C, 0xEC,
+    0x1C, 0x9C, 0x5C, 0xDC, 0x3C, 0xBC, 0x7C, 0xFC,
+    0x02, 0x82, 0x42, 0xC2, 0x22, 0xA2, 0x62, 0xE2,
+    0x12, 0x92, 0x52, 0xD2, 0x32, 0xB2, 0x72, 0xF2,
+    0x0A, 0x8A, 0x4A, 0xCA, 0x2A, 0xAA, 0x6A, 0xEA,
+    0x1A, 0x9A, 0x5A, 0xDA, 0x3A, 0xBA, 0x7A, 0xFA,
+    0x06, 0x86, 0x46, 0xC6, 0x26, 0xA6, 0x66, 0xE6,
+    0x16, 0x96, 0x56, 0xD6, 0x36, 0xB6, 0x76, 0xF6,
+    0x0E, 0x8E, 0x4E, 0xCE, 0x2E, 0xAE, 0x6E, 0xEE,
+    0x1E, 0x9E, 0x5E, 0xDE, 0x3E, 0xBE, 0x7E, 0xFE,
+    0x01, 0x81, 0x41, 0xC1, 0x21, 0xA1, 0x61, 0xE1,
+    0x11, 0x91, 0x51, 0xD1, 0x31, 0xB1, 0x71, 0xF1,
+    0x09, 0x89, 0x49, 0xC9, 0x29, 0xA9, 0x69, 0xE9,
+    0x19, 0x99, 0x59, 0xD9, 0x39, 0xB9, 0x79, 0xF9,
+    0x05, 0x85, 0x45, 0xC5, 0x25, 0xA5, 0x65, 0xE5,
+    0x15, 0x95, 0x55, 0xD5, 0x35, 0xB5, 0x75, 0xF5,
+    0x0D, 0x8D, 0x4D, 0xCD, 0x2D, 0xAD, 0x6D, 0xED,
+    0x1D, 0x9D, 0x5D, 0xDD, 0x3D, 0xBD, 0x7D, 0xFD,
+    0x03, 0x83, 0x43, 0xC3, 0x23, 0xA3, 0x63, 0xE3,
+    0x13, 0x93, 0x53, 0xD3, 0x33, 0xB3, 0x73, 0xF3,
+    0x0B, 0x8B, 0x4B, 0xCB, 0x2B, 0xAB, 0x6B, 0xEB,
+    0x1B, 0x9B, 0x5B, 0xDB, 0x3B, 0xBB, 0x7B, 0xFB,
+    0x07, 0x87, 0x47, 0xC7, 0x27, 0xA7, 0x67, 0xE7,
+    0x17, 0x97, 0x57, 0xD7, 0x37, 0xB7, 0x77, 0xF7,
+    0x0F, 0x8F, 0x4F, 0xCF, 0x2F, 0xAF, 0x6F, 0xEF,
+    0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF
+};
+#endif /* BROTLI_RBIT */
+
+#define BROTLI_REVERSE_BITS_LOWEST \
+    (1U << (BROTLI_REVERSE_BITS_MAX - 1 + BROTLI_REVERSE_BITS_BASE))
+
+/* Returns reverse(num >> BROTLI_REVERSE_BITS_BASE, BROTLI_REVERSE_BITS_MAX),
+   where reverse(value, len) is the bit-wise reversal of the len least
+   significant bits of value. */
+static BROTLI_INLINE uint32_t BrotliReverseBits(uint32_t num) {
+#ifdef BROTLI_RBIT
+  return BROTLI_RBIT(num);
+#else
+  return kReverseBits[num];
 #endif
 }
 
@@ -71,7 +104,8 @@ void BrotliBuildCodeLengthsHuffmanTable(HuffmanCode* table,
                                         uint16_t *count) {
   HuffmanCode code;    /* current table entry */
   int symbol;          /* symbol index in original or sorted table */
-  unsigned key;        /* reversed prefix code */
+  uint32_t key;        /* prefix code */
+  uint32_t key_step;   /* prefix code addend */
   int step;            /* step size to replicate values in current table */
   int table_size;      /* size of current table */
   int sorted[18];      /* symbols sorted by code length */
@@ -79,6 +113,8 @@ void BrotliBuildCodeLengthsHuffmanTable(HuffmanCode* table,
   int offset[BROTLI_HUFFMAN_MAX_CODE_LENGTH_CODE_LENGTH + 1];
   int bits;
   int bits_count;
+  BROTLI_DCHECK(
+      BROTLI_HUFFMAN_MAX_CODE_LENGTH_CODE_LENGTH <= BROTLI_REVERSE_BITS_MAX);
 
   /* generate offsets into sorted symbol table by code length */
   symbol = -1;
@@ -88,6 +124,7 @@ void BrotliBuildCodeLengthsHuffmanTable(HuffmanCode* table,
     offset[bits] = symbol;
     bits++;
   });
+  /* Symbols with code length 0 are placed after all other symbols. */
   offset[0] = 17;
 
   /* sort symbols by length, by symbol order within each length */
@@ -101,11 +138,11 @@ void BrotliBuildCodeLengthsHuffmanTable(HuffmanCode* table,
 
   table_size = 1 << BROTLI_HUFFMAN_MAX_CODE_LENGTH_CODE_LENGTH;
 
-  /* special case code with only one value */
-  if (offset[BROTLI_HUFFMAN_MAX_CODE_LENGTH_CODE_LENGTH] == 0) {
+  /* Special case: all symbols but one have 0 code length. */
+  if (offset[0] == 0) {
     code.bits = 0;
     code.value = (uint16_t)sorted[0];
-    for (key = 0; key < table_size; ++key) {
+    for (key = 0; key < (uint32_t)table_size; ++key) {
       table[key] = code;
     }
     return;
@@ -113,6 +150,7 @@ void BrotliBuildCodeLengthsHuffmanTable(HuffmanCode* table,
 
   /* fill in table */
   key = 0;
+  key_step = BROTLI_REVERSE_BITS_LOWEST;
   symbol = 0;
   bits = 1;
   step = 2;
@@ -120,25 +158,27 @@ void BrotliBuildCodeLengthsHuffmanTable(HuffmanCode* table,
     code.bits = (uint8_t)bits;
     for (bits_count = count[bits]; bits_count != 0; --bits_count) {
       code.value = (uint16_t)sorted[symbol++];
-      ReplicateValue(&table[key], step, table_size, code);
-      key = GetNextKey(key, bits);
+      ReplicateValue(&table[BrotliReverseBits(key)], step, table_size, code);
+      key += key_step;
     }
     step <<= 1;
+    key_step >>= 1;
   } while (++bits <= BROTLI_HUFFMAN_MAX_CODE_LENGTH_CODE_LENGTH);
 }
 
-int BrotliBuildHuffmanTable(HuffmanCode* root_table,
-                            int root_bits,
-                            const uint16_t* const symbol_lists,
-                            uint16_t *count) {
+uint32_t BrotliBuildHuffmanTable(HuffmanCode* root_table,
+                                 int root_bits,
+                                 const uint16_t* const symbol_lists,
+                                 uint16_t *count) {
   HuffmanCode code;    /* current table entry */
   HuffmanCode* table;  /* next available space in table */
   int len;             /* current code length */
   int symbol;          /* symbol index in original or sorted table */
-  unsigned key;        /* reversed prefix code */
+  uint32_t key;        /* prefix code */
+  uint32_t key_step;   /* prefix code addend */
+  uint32_t sub_key;    /* 2nd level table prefix code */
+  uint32_t sub_key_step;/* 2nd level table prefix code addend */
   int step;            /* step size to replicate values in current table */
-  unsigned low;        /* low bits for current root entry */
-  unsigned mask;       /* mask for low bits */
   int table_bits;      /* key length of current table */
   int table_size;      /* size of current table */
   int total_size;      /* sum of root table size and 2nd level table sizes */
@@ -146,6 +186,10 @@ int BrotliBuildHuffmanTable(HuffmanCode* root_table,
   int bits;
   int bits_count;
 
+  BROTLI_DCHECK(root_bits <= BROTLI_REVERSE_BITS_MAX);
+  BROTLI_DCHECK(
+      BROTLI_HUFFMAN_MAX_CODE_LENGTH - root_bits <= BROTLI_REVERSE_BITS_MAX);
+
   while (symbol_lists[max_length] == 0xFFFF) max_length--;
   max_length += BROTLI_HUFFMAN_MAX_CODE_LENGTH + 1;
 
@@ -162,6 +206,7 @@ int BrotliBuildHuffmanTable(HuffmanCode* root_table,
     table_size = 1 << table_bits;
   }
   key = 0;
+  key_step = BROTLI_REVERSE_BITS_LOWEST;
   bits = 1;
   step = 2;
   do {
@@ -170,10 +215,11 @@ int BrotliBuildHuffmanTable(HuffmanCode* root_table,
     for (bits_count = count[bits]; bits_count != 0; --bits_count) {
       symbol = symbol_lists[symbol];
       code.value = (uint16_t)symbol;
-      ReplicateValue(&table[key], step, table_size, code);
-      key = GetNextKey(key, bits);
+      ReplicateValue(&table[BrotliReverseBits(key)], step, table_size, code);
+      key += key_step;
     }
     step <<= 1;
+    key_step >>= 1;
   } while (++bits <= table_bits);
 
   /* if root_bits != table_bits we only created one fraction of the */
@@ -185,37 +231,43 @@ int BrotliBuildHuffmanTable(HuffmanCode* root_table,
   }
 
   /* fill in 2nd level tables and add pointers to root table */
-  mask = (unsigned)(total_size - 1);
-  low = (unsigned)-1;
-  for (len = root_bits + 1, step = 2; len <= max_length; ++len, step <<= 1) {
+  key_step = BROTLI_REVERSE_BITS_LOWEST >> (root_bits - 1);
+  sub_key = (BROTLI_REVERSE_BITS_LOWEST << 1);
+  sub_key_step = BROTLI_REVERSE_BITS_LOWEST;
+  for (len = root_bits + 1, step = 2; len <= max_length; ++len) {
     symbol = len - (BROTLI_HUFFMAN_MAX_CODE_LENGTH + 1);
     for (; count[len] != 0; --count[len]) {
-      if ((key & mask) != low) {
+      if (sub_key == (uint32_t)(BROTLI_REVERSE_BITS_LOWEST << 1)) {
         table += table_size;
         table_bits = NextTableBitSize(count, len, root_bits);
         table_size = 1 << table_bits;
         total_size += table_size;
-        low = key & mask;
-        root_table[low].bits = (uint8_t)(table_bits + root_bits);
-        root_table[low].value = (uint16_t)(
-            ((size_t)(table - root_table)) - low);
+        sub_key = BrotliReverseBits(key);
+        key += key_step;
+        root_table[sub_key].bits = (uint8_t)(table_bits + root_bits);
+        root_table[sub_key].value = (uint16_t)(
+            ((size_t)(table - root_table)) - sub_key);
+        sub_key = 0;
       }
       code.bits = (uint8_t)(len - root_bits);
       symbol = symbol_lists[symbol];
       code.value = (uint16_t)symbol;
-      ReplicateValue(&table[key >> root_bits], step, table_size, code);
-      key = GetNextKey(key, len);
+      ReplicateValue(
+          &table[BrotliReverseBits(sub_key)], step, table_size, code);
+      sub_key += sub_key_step;
     }
+    step <<= 1;
+    sub_key_step >>= 1;
   }
-  return total_size;
+  return (uint32_t)total_size;
 }
 
-int BrotliBuildSimpleHuffmanTable(HuffmanCode* table,
-                                  int root_bits,
-                                  uint16_t *val,
-                                  uint32_t num_symbols) {
-  int table_size = 1;
-  const int goal_size = 1 << root_bits;
+uint32_t BrotliBuildSimpleHuffmanTable(HuffmanCode* table,
+                                       int root_bits,
+                                       uint16_t *val,
+                                       uint32_t num_symbols) {
+  uint32_t table_size = 1;
+  const uint32_t goal_size = 1U << root_bits;
   switch (num_symbols) {
     case 0:
       table[0].bits = 0;
@@ -301,25 +353,6 @@ int BrotliBuildSimpleHuffmanTable(HuffmanCode* table,
   return goal_size;
 }
 
-void BrotliHuffmanTreeGroupInit(HuffmanTreeGroup* group, int alphabet_size,
-                                int ntrees) {
-  /* Pack two mallocs into one */
-  const size_t code_size =
-      sizeof(HuffmanCode) * (size_t)(ntrees * BROTLI_HUFFMAN_MAX_TABLE_SIZE);
-  const size_t htree_size = sizeof(HuffmanCode*) * (size_t)ntrees;
-  char *p = (char*)malloc(code_size + htree_size);
-  group->alphabet_size = (int16_t)alphabet_size;
-  group->num_htrees = (int16_t)ntrees;
-  group->codes = (HuffmanCode*)p;
-  group->htrees = (HuffmanCode**)(p + code_size);
-}
-
-void BrotliHuffmanTreeGroupRelease(HuffmanTreeGroup* group) {
-  if (group->codes) {
-    free(group->codes);
-  }
-}
-
 #if defined(__cplusplus) || defined(c_plusplus)
 }    /* extern "C" */
 #endif

data/vendor/brotli/dec/huffman.h

@@ -1,16 +1,7 @@
 /* Copyright 2013 Google Inc. All Rights Reserved.
 
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-   http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
+   Distributed under MIT license.
+   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
 */
 
 /* Utilities for building Huffman decoding tables. */
@@ -48,28 +39,28 @@ void BrotliBuildCodeLengthsHuffmanTable(HuffmanCode* root_table,
 
 /* Builds Huffman lookup table assuming code lengths are in symbol order. */
 /* Returns size of resulting table. */
-int BrotliBuildHuffmanTable(HuffmanCode* root_table,
-                            int root_bits,
-                            const uint16_t* const symbol_lists,
-                            uint16_t *count_arg);
-
-int BrotliBuildSimpleHuffmanTable(HuffmanCode* table,
-                                  int root_bits,
-                                  uint16_t *symbols,
-                                  uint32_t num_symbols);
-
-/* Contains a collection of huffman trees with the same alphabet size. */
+uint32_t BrotliBuildHuffmanTable(HuffmanCode* root_table,
+                                 int root_bits,
+                                 const uint16_t* const symbol_lists,
+                                 uint16_t *count_arg);
+
+/* Builds a simple Huffman table. The num_symbols parameter is to be */
+/* interpreted as follows: 0 means 1 symbol, 1 means 2 symbols, 2 means 3 */
+/* symbols, 3 means 4 symbols with lengths 2,2,2,2, 4 means 4 symbols with */
+/* lengths 1,2,3,3. */
+uint32_t BrotliBuildSimpleHuffmanTable(HuffmanCode* table,
+                                       int root_bits,
+                                       uint16_t *symbols,
+                                       uint32_t num_symbols);
+
+/* Contains a collection of Huffman trees with the same alphabet size. */
 typedef struct {
   HuffmanCode** htrees;
   HuffmanCode* codes;
-  int16_t alphabet_size;
-  int16_t num_htrees;
+  uint16_t alphabet_size;
+  uint16_t num_htrees;
 } HuffmanTreeGroup;
 
-void BrotliHuffmanTreeGroupInit(HuffmanTreeGroup* group,
-                                int alphabet_size, int ntrees);
-void BrotliHuffmanTreeGroupRelease(HuffmanTreeGroup* group);
-
 #if defined(__cplusplus) || defined(c_plusplus)
 }    /* extern "C" */
 #endif

data/vendor/brotli/dec/port.h

@@ -1,19 +1,25 @@
 /* Copyright 2015 Google Inc. All Rights Reserved.
 
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-   http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
+   Distributed under MIT license.
+   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
 */
 
-/* Macros for branch prediction. */
+/* Macros for compiler / platform specific features and build options.
+
+   Build options are:
+    * BROTLI_BUILD_32_BIT disables 64-bit optimizations
+    * BROTLI_BUILD_64_BIT forces to use 64-bit optimizations
+    * BROTLI_BUILD_BIG_ENDIAN forces to use big-endian optimizations
+    * BROTLI_BUILD_ENDIAN_NEUTRAL disables endian-aware optimizations
+    * BROTLI_BUILD_LITTLE_ENDIAN forces to use little-endian optimizations
+    * BROTLI_BUILD_MODERN_COMPILER forces to use modern compilers built-ins,
+      features and attributes
+    * BROTLI_BUILD_PORTABLE disables dangerous optimizations, like unaligned
+      read and overlapping memcpy; this reduces decompression speed by 5%
+    * BROTLI_DEBUG dumps file name and line number when decoder detects stream
+      or memory error
+    * BROTLI_DECODE_DEBUG enables asserts and dumps various state information
+ */
 
 #ifndef BROTLI_DEC_PORT_H_
 #define BROTLI_DEC_PORT_H_
@@ -33,6 +39,67 @@
 #define __has_feature(x) 0
 #endif
 
+#if defined(__sparc)
+#define BROTLI_TARGET_SPARC
+#endif
+
+#if defined(__arm__) || defined(__thumb__) || \
+    defined(_M_ARM) || defined(_M_ARMT)
+#define BROTLI_TARGET_ARM
+#if (defined(__ARM_ARCH) && (__ARM_ARCH >= 7)) || \
+    (defined(M_ARM) && (M_ARM >= 7))
+#define BROTLI_TARGET_ARMV7
+#endif  /* ARMv7 */
+#if defined(__aarch64__)
+#define BROTLI_TARGET_ARMV8
+#endif  /* ARMv8 */
+#endif  /* ARM */
+
+#if defined(__x86_64__) || defined(_M_X64)
+#define BROTLI_TARGET_X64
+#endif
+
+#if defined(__PPC64__)
+#define BROTLI_TARGET_POWERPC64
+#endif
+
+#if defined(__GNUC__) && defined(__GNUC_MINOR__)
+#define BROTLI_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
+#else
+#define BROTLI_GCC_VERSION 0
+#endif
+
+#if defined(__ICC)
+#define BROTLI_ICC_VERSION __ICC
+#else
+#define BROTLI_ICC_VERSION 0
+#endif
+
+#if defined(BROTLI_BUILD_MODERN_COMPILER)
+#define BROTLI_MODERN_COMPILER 1
+#elif (BROTLI_GCC_VERSION > 300) || (BROTLI_ICC_VERSION >= 1600)
+#define BROTLI_MODERN_COMPILER 1
+#else
+#define BROTLI_MODERN_COMPILER 0
+#endif
+
+/* SPARC and ARMv6 don't support unaligned read.
+   Choose portable build for them. */
+#if !defined(BROTLI_BUILD_PORTABLE)
+#if defined(BROTLI_TARGET_SPARC) || \
+    (defined(BROTLI_TARGET_ARM) && !defined(BROTLI_TARGET_ARMV7))
+#define BROTLI_BUILD_PORTABLE
+#endif  /* SPARK or ARMv6 */
+#endif  /* portable build */
+
+#ifdef BROTLI_BUILD_PORTABLE
+#define BROTLI_ALIGNED_READ 1
+#define BROTLI_SAFE_MEMMOVE 1
+#else
+#define BROTLI_ALIGNED_READ 0
+#define BROTLI_SAFE_MEMMOVE 0
+#endif
+
 #define BROTLI_ASAN_BUILD __has_feature(address_sanitizer)
 
 /* Define "PREDICT_TRUE" and "PREDICT_FALSE" macros for capable compilers.
@@ -52,8 +119,7 @@ OR:
   }
 
 */
-#if (__GNUC__ > 2) || (__GNUC__ == 2 && __GNUC_MINOR__ > 95) || \
-    (defined(__llvm__) && __has_builtin(__builtin_expect))
+#if BROTLI_MODERN_COMPILER || __has_builtin(__builtin_expect)
 #define PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
 #define PREDICT_FALSE(x) (__builtin_expect(x, 0))
 #else
@@ -62,15 +128,13 @@ OR:
 #endif
 
 /* IS_CONSTANT macros returns true for compile-time constant expressions. */
-#if (__GNUC__ > 3) || (__GNUC__ == 3 && __GNUC_MINOR__ > 0) || \
-    (defined(__llvm__) && __has_builtin(__builtin_constant_p))
+#if BROTLI_MODERN_COMPILER || __has_builtin(__builtin_constant_p)
 #define IS_CONSTANT(x) __builtin_constant_p(x)
 #else
 #define IS_CONSTANT(x) 0
 #endif
 
-#if (__GNUC__ > 3) || (__GNUC__ == 3 && __GNUC_MINOR__ > 0) || \
-    (defined(__llvm__) && __has_attribute(always_inline))
+#if BROTLI_MODERN_COMPILER || __has_attribute(always_inline)
 #define ATTRIBUTE_ALWAYS_INLINE __attribute__ ((always_inline))
 #else
 #define ATTRIBUTE_ALWAYS_INLINE
@@ -93,36 +157,49 @@ OR:
 #define BROTLI_DCHECK(x)
 #endif
 
-#if (defined(__x86_64__) || defined(_M_X64) || defined(__aarch64__) || \
-     defined(__PPC64__))
+#if defined(BROTLI_BUILD_64_BIT)
+#define BROTLI_64_BITS 1
+#elif defined(BROTLI_BUILD_32_BIT)
+#define BROTLI_64_BITS 0
+#elif defined(BROTLI_TARGET_X64) || defined(BROTLI_TARGET_ARMV8) || \
+    defined(BROTLI_TARGET_POWERPC64)
 #define BROTLI_64_BITS 1
 #else
 #define BROTLI_64_BITS 0
 #endif
 
-#if (defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__))
+#if defined(BROTLI_BUILD_BIG_ENDIAN)
+#define BROTLI_LITTLE_ENDIAN 0
+#define BROTLI_BIG_ENDIAN 1
+#elif defined(BROTLI_BUILD_LITTLE_ENDIAN)
 #define BROTLI_LITTLE_ENDIAN 1
+#define BROTLI_BIG_ENDIAN 0
+#elif defined(BROTLI_BUILD_ENDIAN_NEUTRAL)
+#define BROTLI_LITTLE_ENDIAN 0
+#define BROTLI_BIG_ENDIAN 0
+#elif defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
+#define BROTLI_LITTLE_ENDIAN 1
+#define BROTLI_BIG_ENDIAN 0
 #elif defined(_WIN32)
 /* Win32 can currently always be assumed to be little endian */
 #define BROTLI_LITTLE_ENDIAN 1
+#define BROTLI_BIG_ENDIAN 0
 #else
-#define BROTLI_LITTLE_ENDIAN 0
-#endif
-
-#if (BROTLI_64_BITS && BROTLI_LITTLE_ENDIAN)
-#define BROTLI_64_BITS_LITTLE_ENDIAN 1
+#if (defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__))
+#define BROTLI_BIG_ENDIAN 1
 #else
-#define BROTLI_64_BITS_LITTLE_ENDIAN 0
+#define BROTLI_BIG_ENDIAN 0
+#endif
+#define BROTLI_LITTLE_ENDIAN 0
 #endif
 
-#if (__GNUC__ > 3) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1) || \
-    (defined(__llvm__) && __has_attribute(noinline))
+#if BROTLI_MODERN_COMPILER || __has_attribute(noinline)
 #define BROTLI_NOINLINE __attribute__ ((noinline))
 #else
 #define BROTLI_NOINLINE
 #endif
 
-#if BROTLI_ASAN_BUILD
+#if BROTLI_ASAN_BUILD && !defined(BROTLI_BUILD_PORTABLE)
 #define BROTLI_NO_ASAN __attribute__((no_sanitize("address"))) BROTLI_NOINLINE
 #else
 #define BROTLI_NO_ASAN
@@ -134,8 +211,8 @@ OR:
   if ((N & 4) != 0) {X; X; X; X;} \
 }
 
-#if (__GNUC__ > 2) || defined(__llvm__)
-#if (defined(__ARM_ARCH) && (__ARM_ARCH >= 7))
+#if BROTLI_MODERN_COMPILER || defined(__llvm__)
+#if defined(BROTLI_TARGET_ARMV7)
 static BROTLI_INLINE unsigned BrotliRBit(unsigned input) {
   unsigned output;
   __asm__("rbit %0, %1\n" : "=r"(output) : "r"(input));
@@ -145,4 +222,19 @@ static BROTLI_INLINE unsigned BrotliRBit(unsigned input) {
 #endif  /* armv7 */
 #endif  /* gcc || clang */
 
+#if defined(BROTLI_TARGET_ARM)
+#define BROTLI_HAS_UBFX 1
+#else
+#define BROTLI_HAS_UBFX 0
+#endif
+
+#define BROTLI_ALLOC(S, L) S->alloc_func(S->memory_manager_opaque, L)
+
+#define BROTLI_FREE(S, X) { \
+  S->free_func(S->memory_manager_opaque, X); \
+  X = NULL; \
+}
+
+#define BROTLI_UNUSED(X) (void)(X)
+
 #endif  /* BROTLI_DEC_PORT_H_ */

data/vendor/brotli/dec/prefix.h

@@ -1,16 +1,7 @@
 /* Copyright 2013 Google Inc. All Rights Reserved.
 
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-   http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
+   Distributed under MIT license.
+   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
 */
 
 /* Lookup tables to map prefix codes to value ranges. This is used during
@@ -23,8 +14,8 @@
 /* Represents the range of values belonging to a prefix code: */
 /* [offset, offset + 2^nbits) */
 struct PrefixCodeRange {
-  int16_t offset;
-  int8_t nbits;
+  uint16_t offset;
+  uint8_t nbits;
 };
 
 static const struct PrefixCodeRange kBlockLengthPrefixCode[] = {