brotli 0.1.3 → 0.1.4

data/vendor/brotli/dec/decode.h

@@ -9,28 +9,28 @@
 #ifndef BROTLI_DEC_DECODE_H_
 #define BROTLI_DEC_DECODE_H_
 
-#include "./types.h"
+#include "../common/types.h"
 
 #if defined(__cplusplus) || defined(c_plusplus)
 extern "C" {
 #endif
 
-typedef struct BrotliStateStruct BrotliState;
+typedef struct BrotliDecoderStateStruct BrotliDecoderState;
 
 typedef enum {
   /* Decoding error, e.g. corrupt input or memory allocation problem */
-  BROTLI_RESULT_ERROR = 0,
+  BROTLI_DECODER_RESULT_ERROR = 0,
   /* Decoding successfully completed */
-  BROTLI_RESULT_SUCCESS = 1,
+  BROTLI_DECODER_RESULT_SUCCESS = 1,
   /* Partially done; should be called again with more input */
-  BROTLI_RESULT_NEEDS_MORE_INPUT = 2,
+  BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT = 2,
   /* Partially done; should be called again with more output */
-  BROTLI_RESULT_NEEDS_MORE_OUTPUT = 3
-} BrotliResult;
+  BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT = 3
+} BrotliDecoderResult;
 
-#define BROTLI_ERROR_CODES_LIST(BROTLI_ERROR_CODE, SEPARATOR)              \
+#define BROTLI_DECODER_ERROR_CODES_LIST(BROTLI_ERROR_CODE, SEPARATOR)      \
   BROTLI_ERROR_CODE(_, NO_ERROR, 0) SEPARATOR                              \
-  /* Same as BrotliResult values */                                        \
+  /* Same as BrotliDecoderResult values */                                 \
   BROTLI_ERROR_CODE(_, SUCCESS, 1) SEPARATOR                               \
   BROTLI_ERROR_CODE(_, NEEDS_MORE_INPUT, 2) SEPARATOR                      \
   BROTLI_ERROR_CODE(_, NEEDS_MORE_OUTPUT, 3) SEPARATOR                     \
@@ -71,39 +71,29 @@ typedef enum {
 typedef enum {
 #define _BROTLI_COMMA ,
 #define _BROTLI_ERROR_CODE_ENUM_ITEM(PREFIX, NAME, CODE) \
-    BROTLI ## PREFIX ## NAME = CODE
-  BROTLI_ERROR_CODES_LIST(_BROTLI_ERROR_CODE_ENUM_ITEM, _BROTLI_COMMA)
+    BROTLI_DECODER ## PREFIX ## NAME = CODE
+  BROTLI_DECODER_ERROR_CODES_LIST(_BROTLI_ERROR_CODE_ENUM_ITEM, _BROTLI_COMMA)
 #undef _BROTLI_ERROR_CODE_ENUM_ITEM
 #undef _BROTLI_COMMA
-} BrotliErrorCode;
+} BrotliDecoderErrorCode;
 
-#define BROTLI_LAST_ERROR_CODE BROTLI_ERROR_UNREACHABLE
+#define BROTLI_LAST_ERROR_CODE BROTLI_DECODER_ERROR_UNREACHABLE
 
-/* Creates the instance of BrotliState and initializes it. |alloc_func| and
-   |free_func| MUST be both zero or both non-zero. In the case they are both
+/* Creates the instance of BrotliDecoderState and initializes it. |alloc_func|
+   and |free_func| MUST be both zero or both non-zero. In the case they are both
    zero, default memory allocators are used. |opaque| is passed to |alloc_func|
    and |free_func| when they are called. */
-BrotliState* BrotliCreateState(
+BrotliDecoderState* BrotliDecoderCreateInstance(
     brotli_alloc_func alloc_func, brotli_free_func free_func, void* opaque);
 
-/* Deinitializes and frees BrotliState instance. */
-void BrotliDestroyState(BrotliState* state);
-
-/* Sets |*decoded_size| to the decompressed size of the given encoded stream.
-   This function only works if the encoded buffer has a single meta block,
-   or if it has two meta-blocks, where the first is uncompressed and the
-   second is empty.
-   Returns 1 on success, 0 on failure. */
-int BrotliDecompressedSize(size_t encoded_size,
-                           const uint8_t* encoded_buffer,
-                           size_t* decoded_size);
+/* Deinitializes and frees BrotliDecoderState instance. */
+void BrotliDecoderDestroyInstance(BrotliDecoderState* state);
 
 /* Decompresses the data in |encoded_buffer| into |decoded_buffer|, and sets
    |*decoded_size| to the decompressed length. */
-BrotliResult BrotliDecompressBuffer(size_t encoded_size,
-                                    const uint8_t* encoded_buffer,
-                                    size_t* decoded_size,
-                                    uint8_t* decoded_buffer);
+BrotliDecoderResult BrotliDecoderDecompress(
+    size_t encoded_size, const uint8_t* encoded_buffer, size_t* decoded_size,
+    uint8_t* decoded_buffer);
 
 /* Decompresses the data. Supports partial input and output.
 
@@ -120,12 +110,9 @@ BrotliResult BrotliDecompressBuffer(size_t encoded_size,
 
    Input is never overconsumed, so |next_in| and |available_in| could be passed
    to the next consumer after decoding is complete. */
-BrotliResult BrotliDecompressStream(size_t* available_in,
-                                    const uint8_t** next_in,
-                                    size_t* available_out,
-                                    uint8_t** next_out,
-                                    size_t* total_out,
-                                    BrotliState* s);
+BrotliDecoderResult BrotliDecoderDecompressStream(
+  BrotliDecoderState* s, size_t* available_in, const uint8_t** next_in,
+  size_t* available_out, uint8_t** next_out, size_t* total_out);
 
 /* Fills the new state with a dictionary for LZ77, warming up the ringbuffer,
    e.g. for custom static dictionaries for data formats.
@@ -133,27 +120,66 @@ BrotliResult BrotliDecompressStream(size_t* available_in,
    |size| should be less or equal to 2^24 (16MiB), otherwise the dictionary will
    be ignored. The dictionary must exist in memory until decoding is done and
    is owned by the caller. To use:
-    1) Allocate and initialize state with BrotliCreateState
+    1) Allocate and initialize state with BrotliCreateInstance
     2) Use BrotliSetCustomDictionary
     3) Use BrotliDecompressStream
     4) Clean up and free state with BrotliDestroyState
 */
-void BrotliSetCustomDictionary(
-    size_t size, const uint8_t* dict, BrotliState* s);
+void BrotliDecoderSetCustomDictionary(
+    BrotliDecoderState* s, size_t size, const uint8_t* dict);
+
+/* Returns true, if decoder has some unconsumed output.
+   Otherwise returns false. */
+BROTLI_BOOL BrotliDecoderHasMoreOutput(const BrotliDecoderState* s);
 
-/* Returns 1, if s is in a state where we have not read any input bytes yet,
-   and 0 otherwise */
-int BrotliStateIsStreamStart(const BrotliState* s);
+/* Returns true, if decoder has already received some input bytes.
+   Otherwise returns false. */
+BROTLI_BOOL BrotliDecoderIsUsed(const BrotliDecoderState* s);
 
-/* Returns 1, if s is in a state where we reached the end of the input and
-   produced all of the output, and 0 otherwise. */
-int BrotliStateIsStreamEnd(const BrotliState* s);
+/* Returns true, if decoder is in a state where we reached the end of the input
+   and produced all of the output; returns false otherwise. */
+BROTLI_BOOL BrotliDecoderIsFinished(const BrotliDecoderState* s);
 
 /* Returns detailed error code after BrotliDecompressStream returns
-   BROTLI_RESULT_ERROR. */
-BrotliErrorCode BrotliGetErrorCode(const BrotliState* s);
+   BROTLI_DECODER_RESULT_ERROR. */
+BrotliDecoderErrorCode BrotliDecoderGetErrorCode(const BrotliDecoderState* s);
+
+const char* BrotliDecoderErrorString(BrotliDecoderErrorCode c);
 
+/* DEPRECATED >>> */
+typedef enum {
+  BROTLI_RESULT_ERROR = 0,
+  BROTLI_RESULT_SUCCESS = 1,
+  BROTLI_RESULT_NEEDS_MORE_INPUT = 2,
+  BROTLI_RESULT_NEEDS_MORE_OUTPUT = 3
+} BrotliResult;
+typedef enum {
+#define _BROTLI_COMMA ,
+#define _BROTLI_ERROR_CODE_ENUM_ITEM(PREFIX, NAME, CODE) \
+    BROTLI ## PREFIX ## NAME = CODE
+  BROTLI_DECODER_ERROR_CODES_LIST(_BROTLI_ERROR_CODE_ENUM_ITEM, _BROTLI_COMMA)
+#undef _BROTLI_ERROR_CODE_ENUM_ITEM
+#undef _BROTLI_COMMA
+} BrotliErrorCode;
+typedef struct BrotliStateStruct BrotliState;
+BrotliState* BrotliCreateState(
+    brotli_alloc_func alloc, brotli_free_func free, void* opaque);
+void BrotliDestroyState(BrotliState* state);
+BROTLI_BOOL BrotliDecompressedSize(
+    size_t encoded_size, const uint8_t* encoded_buffer, size_t* decoded_size);
+BrotliResult BrotliDecompressBuffer(
+    size_t encoded_size, const uint8_t* encoded_buffer, size_t* decoded_size,
+    uint8_t* decoded_buffer);
+BrotliResult BrotliDecompressStream(
+    size_t* available_in, const uint8_t** next_in, size_t* available_out,
+    uint8_t** next_out, size_t* total_out, BrotliState* s);
+void BrotliSetCustomDictionary(
+    size_t size, const uint8_t* dict, BrotliState* s);
+BROTLI_BOOL BrotliStateIsStreamStart(const BrotliState* s);
+BROTLI_BOOL BrotliStateIsStreamEnd(const BrotliState* s);
+BrotliErrorCode BrotliGetErrorCode(const BrotliState* s);
 const char* BrotliErrorString(BrotliErrorCode c);
+/* <<< DEPRECATED */
 
 #if defined(__cplusplus) || defined(c_plusplus)
 } /* extern "C" */

data/vendor/brotli/dec/huffman.c

@@ -10,8 +10,9 @@
 
 #include <string.h>  /* memcpy, memset */
 
+#include "../common/constants.h"
+#include "../common/types.h"
 #include "./port.h"
-#include "./types.h"
 
 #if defined(__cplusplus) || defined(c_plusplus)
 extern "C" {
@@ -108,7 +109,7 @@ void BrotliBuildCodeLengthsHuffmanTable(HuffmanCode* table,
   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 */
+  int sorted[BROTLI_CODE_LENGTH_CODES];  /* symbols sorted by code length */
   /* offsets in sorted table for each length */
   int offset[BROTLI_HUFFMAN_MAX_CODE_LENGTH_CODE_LENGTH + 1];
   int bits;
@@ -125,10 +126,10 @@ void BrotliBuildCodeLengthsHuffmanTable(HuffmanCode* table,
     bits++;
   });
   /* Symbols with code length 0 are placed after all other symbols. */
-  offset[0] = 17;
+  offset[0] = BROTLI_CODE_LENGTH_CODES - 1;
 
   /* sort symbols by length, by symbol order within each length */
-  symbol = 18;
+  symbol = BROTLI_CODE_LENGTH_CODES;
   do {
     BROTLI_REPEAT(6, {
       symbol--;

data/vendor/brotli/dec/huffman.h

@@ -9,7 +9,7 @@
 #ifndef BROTLI_DEC_HUFFMAN_H_
 #define BROTLI_DEC_HUFFMAN_H_
 
-#include "./types.h"
+#include "../common/types.h"
 #include "./port.h"
 
 #if defined(__cplusplus) || defined(c_plusplus)
@@ -18,16 +18,16 @@ extern "C" {
 
 #define BROTLI_HUFFMAN_MAX_CODE_LENGTH 15
 
-/* For current format this constant equals to kNumInsertAndCopyCodes */
-#define BROTLI_HUFFMAN_MAX_CODE_LENGTHS_SIZE 704
-
 /* Maximum possible Huffman table size for an alphabet size of (index * 32),
  * max code length 15 and root table bits 8. */
 static const uint16_t kMaxHuffmanTableSize[] = {
   256, 402, 436, 468, 500, 534, 566, 598, 630, 662, 694, 726, 758, 790, 822,
   854, 886, 920, 952, 984, 1016, 1048, 1080};
+/* BROTLI_NUM_BLOCK_LEN_SYMBOLS == 26 */
 #define BROTLI_HUFFMAN_MAX_SIZE_26 396
+/* BROTLI_MAX_BLOCK_TYPE_SYMBOLS == 258 */
 #define BROTLI_HUFFMAN_MAX_SIZE_258 632
+/* BROTLI_MAX_CONTEXT_MAP_SYMBOLS == 272 */
 #define BROTLI_HUFFMAN_MAX_SIZE_272 646
 
 #define BROTLI_HUFFMAN_MAX_CODE_LENGTH_CODE_LENGTH 5

data/vendor/brotli/dec/port.h

@@ -29,18 +29,7 @@
 #include <stdio.h>
 #endif
 
-/* Compatibility with non-clang compilers. */
-#ifndef __has_builtin
-#define __has_builtin(x) 0
-#endif
-
-#ifndef __has_attribute
-#define __has_attribute(x) 0
-#endif
-
-#ifndef __has_feature
-#define __has_feature(x) 0
-#endif
+#include "../common/port.h"
 
 #if defined(__arm__) || defined(__thumb__) || \
     defined(_M_ARM) || defined(_M_ARMT)
@@ -66,26 +55,6 @@
 #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
-
 #ifdef BROTLI_BUILD_PORTABLE
 #define BROTLI_ALIGNED_READ (!!1)
 #elif defined(BROTLI_TARGET_X86) || defined(BROTLI_TARGET_X64) || \
@@ -96,31 +65,6 @@
 #define BROTLI_ALIGNED_READ (!!1)
 #endif
 
-/* Define "PREDICT_TRUE" and "PREDICT_FALSE" macros for capable compilers.
-
-To apply compiler hint, enclose the branching condition into macros, like this:
-
-  if (PREDICT_TRUE(zero == 0)) {
-    // main execution path
-  } else {
-    // compiler should place this code outside of main execution path
-  }
-
-OR:
-
-  if (PREDICT_FALSE(something_rare_or_unexpected_happens)) {
-    // compiler should place this code outside of main execution path
-  }
-
-*/
-#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
-#define PREDICT_FALSE(x) (x)
-#define PREDICT_TRUE(x) (x)
-#endif
-
 /* IS_CONSTANT macros returns true for compile-time constant expressions. */
 #if BROTLI_MODERN_COMPILER || __has_builtin(__builtin_constant_p)
 #define IS_CONSTANT(x) (!!__builtin_constant_p(x))
@@ -128,35 +72,6 @@ OR:
 #define IS_CONSTANT(x) (!!0)
 #endif
 
-#if BROTLI_MODERN_COMPILER || __has_attribute(always_inline)
-#define ATTRIBUTE_ALWAYS_INLINE __attribute__ ((always_inline))
-#else
-#define ATTRIBUTE_ALWAYS_INLINE
-#endif
-
-#if defined(_WIN32) || defined(__CYGWIN__)
-#define ATTRIBUTE_VISIBILITY_HIDDEN
-#elif BROTLI_MODERN_COMPILER || __has_attribute(visibility)
-#define ATTRIBUTE_VISIBILITY_HIDDEN __attribute__ ((visibility ("hidden")))
-#else
-#define ATTRIBUTE_VISIBILITY_HIDDEN
-#endif
-
-#ifndef BROTLI_INTERNAL
-#define BROTLI_INTERNAL ATTRIBUTE_VISIBILITY_HIDDEN
-#endif
-
-#ifndef _MSC_VER
-#if defined(__cplusplus) || !defined(__STRICT_ANSI__) || \
-    __STDC_VERSION__ >= 199901L
-#define BROTLI_INLINE inline ATTRIBUTE_ALWAYS_INLINE
-#else
-#define BROTLI_INLINE
-#endif
-#else  /* _MSC_VER */
-#define BROTLI_INLINE __forceinline
-#endif  /* _MSC_VER */
-
 #ifdef BROTLI_ENABLE_LOG
 #define BROTLI_DCHECK(x) assert(x)
 #define BROTLI_LOG(x) printf x
@@ -166,7 +81,7 @@ OR:
 #endif
 
 #if defined(BROTLI_DEBUG) || defined(BROTLI_ENABLE_LOG)
-static inline void BrotliDump(const char* f, int l, const char* fn) {
+static BROTLI_INLINE void BrotliDump(const char* f, int l, const char* fn) {
   fprintf(stderr, "%s:%d (%s)\n", f, l, fn);
   fflush(stderr);
 }
@@ -211,12 +126,6 @@ static inline void BrotliDump(const char* f, int l, const char* fn) {
 #define BROTLI_LITTLE_ENDIAN 0
 #endif
 
-#if BROTLI_MODERN_COMPILER || __has_attribute(noinline)
-#define BROTLI_NOINLINE __attribute__((noinline))
-#else
-#define BROTLI_NOINLINE
-#endif
-
 #define BROTLI_REPEAT(N, X) {     \
   if ((N & 1) != 0) {X;}          \
   if ((N & 2) != 0) {X; X;}       \
@@ -247,6 +156,4 @@ static BROTLI_INLINE unsigned BrotliRBit(unsigned input) {
   X = NULL;                                  \
 }
 
-#define BROTLI_UNUSED(X) (void)(X)
-
 #endif  /* BROTLI_DEC_PORT_H_ */

data/vendor/brotli/dec/prefix.h

@@ -11,7 +11,8 @@
 #ifndef BROTLI_DEC_PREFIX_H_
 #define BROTLI_DEC_PREFIX_H_
 
-#include "./types.h"
+#include "../common/constants.h"
+#include "../common/types.h"
 
 /* Represents the range of values belonging to a prefix code: */
 /* [offset, offset + 2^nbits) */
@@ -20,7 +21,8 @@ struct PrefixCodeRange {
   uint8_t nbits;
 };
 
-static const struct PrefixCodeRange kBlockLengthPrefixCode[] = {
+static const struct PrefixCodeRange
+    kBlockLengthPrefixCode[BROTLI_NUM_BLOCK_LEN_SYMBOLS] = {
   {   1,  2}, {    5,  2}, {  9,   2}, {  13,  2},
   {  17,  3}, {   25,  3}, {  33,  3}, {  41,  3},
   {  49,  4}, {   65,  4}, {  81,  4}, {  97,  4},
@@ -39,7 +41,7 @@ typedef struct CmdLutElement {
   uint16_t copy_len_offset;
 } CmdLutElement;
 
-static const CmdLutElement kCmdLut[704] = {
+static const CmdLutElement kCmdLut[BROTLI_NUM_COMMAND_SYMBOLS] = {
   { 0x00, 0x00, 0, 0x00, 0x0000, 0x0002 },
   { 0x00, 0x00, 0, 0x01, 0x0000, 0x0003 },
   { 0x00, 0x00, 0, 0x02, 0x0000, 0x0004 },

data/vendor/brotli/dec/state.c

@@ -8,17 +8,13 @@
 
 #include <stdlib.h>  /* free, malloc */
 
+#include "../common/types.h"
 #include "./huffman.h"
-#include "./types.h"
 
 #if defined(__cplusplus) || defined(c_plusplus)
 extern "C" {
 #endif
 
-/* Declared in decode.h */
-int BrotliStateIsStreamStart(const BrotliState* s);
-int BrotliStateIsStreamEnd(const BrotliState* s);
-
 static void* DefaultAllocFunc(void* opaque, size_t size) {
   BROTLI_UNUSED(opaque);
   return malloc(size);
@@ -29,11 +25,11 @@ static void DefaultFreeFunc(void* opaque, void* address) {
   free(address);
 }
 
-void BrotliStateInit(BrotliState* s) {
-  BrotliStateInitWithCustomAllocators(s, 0, 0, 0);
+void BrotliDecoderStateInit(BrotliDecoderState* s) {
+  BrotliDecoderStateInitWithCustomAllocators(s, 0, 0, 0);
 }
 
-void BrotliStateInitWithCustomAllocators(BrotliState* s,
+void BrotliDecoderStateInitWithCustomAllocators(BrotliDecoderState* s,
     brotli_alloc_func alloc_func, brotli_free_func free_func, void* opaque) {
   if (!alloc_func) {
     s->alloc_func = DefaultAllocFunc;
@@ -100,7 +96,7 @@ void BrotliStateInitWithCustomAllocators(BrotliState* s,
   s->mtf_upper_bound = 255;
 }
 
-void BrotliStateMetablockBegin(BrotliState* s) {
+void BrotliDecoderStateMetablockBegin(BrotliDecoderState* s) {
   s->meta_block_remaining_len = 0;
   s->block_length[0] = 1U << 28;
   s->block_length[1] = 1U << 28;
@@ -131,34 +127,25 @@ void BrotliStateMetablockBegin(BrotliState* s) {
   s->distance_hgroup.htrees = NULL;
 }
 
-void BrotliStateCleanupAfterMetablock(BrotliState* s) {
+void BrotliDecoderStateCleanupAfterMetablock(BrotliDecoderState* s) {
   BROTLI_FREE(s, s->context_modes);
   BROTLI_FREE(s, s->context_map);
   BROTLI_FREE(s, s->dist_context_map);
 
-  BrotliHuffmanTreeGroupRelease(s, &s->literal_hgroup);
-  BrotliHuffmanTreeGroupRelease(s, &s->insert_copy_hgroup);
-  BrotliHuffmanTreeGroupRelease(s, &s->distance_hgroup);
+  BrotliDecoderHuffmanTreeGroupRelease(s, &s->literal_hgroup);
+  BrotliDecoderHuffmanTreeGroupRelease(s, &s->insert_copy_hgroup);
+  BrotliDecoderHuffmanTreeGroupRelease(s, &s->distance_hgroup);
 }
 
-void BrotliStateCleanup(BrotliState* s) {
-  BrotliStateCleanupAfterMetablock(s);
+void BrotliDecoderStateCleanup(BrotliDecoderState* s) {
+  BrotliDecoderStateCleanupAfterMetablock(s);
 
   BROTLI_FREE(s, s->ringbuffer);
   BROTLI_FREE(s, s->block_type_trees);
 }
 
-int BrotliStateIsStreamStart(const BrotliState* s) {
-  return (s->state == BROTLI_STATE_UNINITED &&
-      BrotliGetAvailableBits(&s->br) == 0);
-}
-
-int BrotliStateIsStreamEnd(const BrotliState* s) {
-  return s->state == BROTLI_STATE_DONE;
-}
-
-void BrotliHuffmanTreeGroupInit(BrotliState* s, HuffmanTreeGroup* group,
-    uint32_t alphabet_size, uint32_t ntrees) {
+void BrotliDecoderHuffmanTreeGroupInit(BrotliDecoderState* s,
+    HuffmanTreeGroup* group, uint32_t alphabet_size, uint32_t ntrees) {
   /* Pack two allocations into one */
   const size_t max_table_size = kMaxHuffmanTableSize[(alphabet_size + 31) >> 5];
   const size_t code_size = sizeof(HuffmanCode) * ntrees * max_table_size;
@@ -170,7 +157,8 @@ void BrotliHuffmanTreeGroupInit(BrotliState* s, HuffmanTreeGroup* group,
   group->htrees = (HuffmanCode**)(p + code_size);
 }
 
-void BrotliHuffmanTreeGroupRelease(BrotliState* s, HuffmanTreeGroup* group) {
+void BrotliDecoderHuffmanTreeGroupRelease(
+    BrotliDecoderState* s, HuffmanTreeGroup* group) {
   BROTLI_FREE(s, group->codes);
   group->htrees = NULL;
 }

data/vendor/brotli/dec/state.h

@@ -9,9 +9,10 @@
 #ifndef BROTLI_DEC_STATE_H_
 #define BROTLI_DEC_STATE_H_
 
+#include "../common/constants.h"
+#include "../common/types.h"
 #include "./bit_reader.h"
 #include "./huffman.h"
-#include "./types.h"
 #include "./port.h"
 
 #if defined(__cplusplus) || defined(c_plusplus)
@@ -93,7 +94,7 @@ typedef enum {
   BROTLI_STATE_READ_BLOCK_LENGTH_SUFFIX
 } BrotliRunningReadBlockLengthState;
 
-struct BrotliStateStruct {
+struct BrotliDecoderStateStruct {
   BrotliRunningState state;
 
   /* This counter is reused for several disjoint loops. */
@@ -173,10 +174,10 @@ struct BrotliStateStruct {
   uint16_t* symbol_lists;
   /* Storage from symbol_lists. */
   uint16_t symbols_lists_array[BROTLI_HUFFMAN_MAX_CODE_LENGTH + 1 +
-                               BROTLI_HUFFMAN_MAX_CODE_LENGTHS_SIZE];
+                               BROTLI_NUM_COMMAND_SYMBOLS];
   /* Tails of symbol chains. */
   int next_symbol[32];
-  uint8_t code_length_code_lengths[18];
+  uint8_t code_length_code_lengths[BROTLI_CODE_LENGTH_CODES];
   /* Population counts for the code lengths */
   uint16_t code_length_histo[16];
 
@@ -221,19 +222,22 @@ struct BrotliStateStruct {
   uint32_t trivial_literal_contexts[8];  /* 256 bits */
 };
 
-typedef struct BrotliStateStruct BrotliStateInternal;
-#define BrotliState BrotliStateInternal
-
-BROTLI_INTERNAL void BrotliStateInit(BrotliState* s);
-BROTLI_INTERNAL void BrotliStateInitWithCustomAllocators(BrotliState* s,
-    brotli_alloc_func alloc_func, brotli_free_func free_func, void* opaque);
-BROTLI_INTERNAL void BrotliStateCleanup(BrotliState* s);
-BROTLI_INTERNAL void BrotliStateMetablockBegin(BrotliState* s);
-BROTLI_INTERNAL void BrotliStateCleanupAfterMetablock(BrotliState* s);
-BROTLI_INTERNAL void BrotliHuffmanTreeGroupInit(BrotliState* s,
-    HuffmanTreeGroup* group, uint32_t alphabet_size, uint32_t ntrees);
-BROTLI_INTERNAL void BrotliHuffmanTreeGroupRelease(BrotliState* s,
-    HuffmanTreeGroup* group);
+typedef struct BrotliDecoderStateStruct BrotliDecoderStateInternal;
+#define BrotliDecoderState BrotliDecoderStateInternal
+
+BROTLI_INTERNAL void BrotliDecoderStateInit(BrotliDecoderState* s);
+BROTLI_INTERNAL void BrotliDecoderStateInitWithCustomAllocators(
+    BrotliDecoderState* s, brotli_alloc_func alloc_func,
+    brotli_free_func free_func, void* opaque);
+BROTLI_INTERNAL void BrotliDecoderStateCleanup(BrotliDecoderState* s);
+BROTLI_INTERNAL void BrotliDecoderStateMetablockBegin(BrotliDecoderState* s);
+BROTLI_INTERNAL void BrotliDecoderStateCleanupAfterMetablock(
+    BrotliDecoderState* s);
+BROTLI_INTERNAL void BrotliDecoderHuffmanTreeGroupInit(
+    BrotliDecoderState* s, HuffmanTreeGroup* group, uint32_t alphabet_size,
+    uint32_t ntrees);
+BROTLI_INTERNAL void BrotliDecoderHuffmanTreeGroupRelease(
+    BrotliDecoderState* s, HuffmanTreeGroup* group);
 
 #if defined(__cplusplus) || defined(c_plusplus)
 }  /* extern "C" */

data/vendor/brotli/dec/transform.h

@@ -9,8 +9,8 @@
 #ifndef BROTLI_DEC_TRANSFORM_H_
 #define BROTLI_DEC_TRANSFORM_H_
 
+#include "../common/types.h"
 #include "./port.h"
-#include "./types.h"
 
 #if defined(__cplusplus) || defined(c_plusplus)
 extern "C" {