brotli 0.1.1 → 0.1.2

data/vendor/brotli/dec/decode.h

@@ -9,135 +9,117 @@
 #ifndef BROTLI_DEC_DECODE_H_
 #define BROTLI_DEC_DECODE_H_
 
-#include "./state.h"
-#include "./streams.h"
 #include "./types.h"
 
 #if defined(__cplusplus) || defined(c_plusplus)
 extern "C" {
 #endif
 
+typedef struct BrotliStateStruct BrotliState;
+
 typedef enum {
-  /* Decoding error, e.g. corrupt input or no memory */
+  /* Decoding error, e.g. corrupt input or memory allocation problem */
   BROTLI_RESULT_ERROR = 0,
-  /* Successfully completely done */
+  /* Decoding successfully completed */
   BROTLI_RESULT_SUCCESS = 1,
-  /* Partially done, but must be called again with more input */
+  /* Partially done; should be called again with more input */
   BROTLI_RESULT_NEEDS_MORE_INPUT = 2,
-  /* Partially done, but must be called again with more output */
+  /* Partially done; should be called again with more output */
   BROTLI_RESULT_NEEDS_MORE_OUTPUT = 3
 } BrotliResult;
 
-/* BROTLI_FAILURE macro unwraps to BROTLI_RESULT_ERROR in non-debug build. */
-/* In debug build it dumps file name, line and pretty function name. */
-#if defined(_MSC_VER) || !defined(BROTLI_DEBUG)
-#define BROTLI_FAILURE() BROTLI_RESULT_ERROR
-#else
-#define BROTLI_FAILURE() \
-    BrotliFailure(__FILE__, __LINE__, __PRETTY_FUNCTION__)
-static inline BrotliResult BrotliFailure(const char *f, int l, const char *fn) {
-  fprintf(stderr, "ERROR at %s:%d (%s)\n", f, l, fn);
-  fflush(stderr);
-  return BROTLI_RESULT_ERROR;
-}
-#endif
+#define BROTLI_ERROR_CODES_LIST(BROTLI_ERROR_CODE, SEPARATOR)              \
+  BROTLI_ERROR_CODE(_, NO_ERROR, 0) SEPARATOR                              \
+  /* Same as BrotliResult values */                                        \
+  BROTLI_ERROR_CODE(_, SUCCESS, 1) SEPARATOR                               \
+  BROTLI_ERROR_CODE(_, NEEDS_MORE_INPUT, 2) SEPARATOR                      \
+  BROTLI_ERROR_CODE(_, NEEDS_MORE_OUTPUT, 3) SEPARATOR                     \
+                                                                           \
+  /* Errors caused by invalid input */                                     \
+  BROTLI_ERROR_CODE(_ERROR_FORMAT_, EXUBERANT_NIBBLE, -1) SEPARATOR        \
+  BROTLI_ERROR_CODE(_ERROR_FORMAT_, RESERVED, -2) SEPARATOR                \
+  BROTLI_ERROR_CODE(_ERROR_FORMAT_, EXUBERANT_META_NIBBLE, -3) SEPARATOR   \
+  BROTLI_ERROR_CODE(_ERROR_FORMAT_, SIMPLE_HUFFMAN_ALPHABET, -4) SEPARATOR \
+  BROTLI_ERROR_CODE(_ERROR_FORMAT_, SIMPLE_HUFFMAN_SAME, -5) SEPARATOR     \
+  BROTLI_ERROR_CODE(_ERROR_FORMAT_, CL_SPACE, -6) SEPARATOR                \
+  BROTLI_ERROR_CODE(_ERROR_FORMAT_, HUFFMAN_SPACE, -7) SEPARATOR           \
+  BROTLI_ERROR_CODE(_ERROR_FORMAT_, CONTEXT_MAP_REPEAT, -8) SEPARATOR      \
+  BROTLI_ERROR_CODE(_ERROR_FORMAT_, BLOCK_LENGTH_1, -9) SEPARATOR          \
+  BROTLI_ERROR_CODE(_ERROR_FORMAT_, BLOCK_LENGTH_2, -10) SEPARATOR         \
+  BROTLI_ERROR_CODE(_ERROR_FORMAT_, TRANSFORM, -11) SEPARATOR              \
+  BROTLI_ERROR_CODE(_ERROR_FORMAT_, DICTIONARY, -12) SEPARATOR             \
+  BROTLI_ERROR_CODE(_ERROR_FORMAT_, WINDOW_BITS, -13) SEPARATOR            \
+  BROTLI_ERROR_CODE(_ERROR_FORMAT_, PADDING_1, -14) SEPARATOR              \
+  BROTLI_ERROR_CODE(_ERROR_FORMAT_, PADDING_2, -15) SEPARATOR              \
+                                                                           \
+  /* -16..-20 codes are reserved */                                        \
+                                                                           \
+  /* Memory allocation problems */                                         \
+  BROTLI_ERROR_CODE(_ERROR_ALLOC_, CONTEXT_MODES, -21) SEPARATOR           \
+  /* Literal, insert and distance trees together */                        \
+  BROTLI_ERROR_CODE(_ERROR_ALLOC_, TREE_GROUPS, -22) SEPARATOR             \
+  /* -23..-24 codes are reserved for distinct tree groups */               \
+  BROTLI_ERROR_CODE(_ERROR_ALLOC_, CONTEXT_MAP, -25) SEPARATOR             \
+  BROTLI_ERROR_CODE(_ERROR_ALLOC_, RING_BUFFER_1, -26) SEPARATOR           \
+  BROTLI_ERROR_CODE(_ERROR_ALLOC_, RING_BUFFER_2, -27) SEPARATOR           \
+  /* -28..-29 codes are reserved for dynamic ringbuffer allocation */      \
+  BROTLI_ERROR_CODE(_ERROR_ALLOC_, BLOCK_TYPE_TREES, -30) SEPARATOR        \
+                                                                           \
+  /* "Impossible" states */                                                \
+  BROTLI_ERROR_CODE(_ERROR_, UNREACHABLE, -31)
 
-/* 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 zero,
-   default memory allocators are used. opaque parameter is passed to alloc_func
-   and free_func when they are called. */
+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)
+#undef _BROTLI_ERROR_CODE_ENUM_ITEM
+#undef _BROTLI_COMMA
+} BrotliErrorCode;
+
+#define BROTLI_LAST_ERROR_CODE BROTLI_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
+   zero, default memory allocators are used. |opaque| is passed to |alloc_func|
+   and |free_func| when they are called. */
 BrotliState* BrotliCreateState(
     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. */
+/* 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);
 
-/* Decompresses the data in encoded_buffer into decoded_buffer, and sets */
-/* *decoded_size to the decompressed length. */
+/* 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);
 
-/* Same as above, but uses the specified input and output callbacks instead */
-/* of reading from and writing to pre-allocated memory buffers. */
-/* DEPRECATED */
-BrotliResult BrotliDecompress(BrotliInput input, BrotliOutput output);
-
-/* Same as above, but supports the caller to call the decoder repeatedly with
-   partial data to support streaming. The state must be initialized with
-   BrotliStateInit and reused with every call for the same stream.
-   Return values:
-   0: failure.
-   1: success, and done.
-   2: success so far, end not reached so should call again with more input.
-   The finish parameter is used as follows, for a series of calls with the
-   same state:
-   0: Every call except the last one must be called with finish set to 0. The
-      last call may have finish set to either 0 or 1. Only if finish is 0, can
-      the function return 2. It may also return 0 or 1, in that case no more
-      calls (even with finish 1) may be made.
-   1: Only the last call may have finish set to 1. It's ok to give empty input
-      if all input was already given to previous calls. It is also ok to have
-      only one single call in total, with finish 1, and with all input
-      available immediately. That matches the non-streaming case. If finish is
-      1, the function can only return 0 or 1, never 2. After a finish, no more
-      calls may be done.
-   After everything is done, the state must be cleaned with BrotliStateCleanup
-   to free allocated resources.
-   The given BrotliOutput must always accept all output and make enough space,
-   it returning a smaller value than the amount of bytes to write always results
-   in an error.
-*/
-/* DEPRECATED */
-BrotliResult BrotliDecompressStreaming(BrotliInput input, BrotliOutput output,
-                                       int finish, BrotliState* s);
-
-/* Same as above, but with memory buffers.
-   Must be called with an allocated input buffer in *next_in and an allocated
-   output buffer in *next_out. The values *available_in and *available_out
-   must specify the allocated size in *next_in and *next_out respectively.
-   The value *total_out must be 0 initially, and will be summed with the
-   amount of output bytes written after each call, so that at the end it
-   gives the complete decoded size.
-   After each call, *available_in will be decremented by the amount of input
-   bytes consumed, and the *next_in pointer will be incremented by that amount.
-   Similarly, *available_out will be decremented by the amount of output
-   bytes written, and the *next_out pointer will be incremented by that
-   amount.
-
-   The input may be partial. With each next function call, *next_in and
-   *available_in must be updated to point to a next part of the compressed
-   input. The current implementation will always consume all input unless
-   an error occurs, so normally *available_in will always be 0 after
-   calling this function and the next adjacent part of input is desired.
-
-   In the current implementation, the function requires that there is enough
-   output buffer size to write all currently processed input, so
-   *available_out must be large enough. Since the function updates *next_out
-   each time, as long as the output buffer is large enough you can keep
-   reusing this variable. It is also possible to update *next_out and
-   *available_out yourself before a next call, e.g. to point to a new larger
-   buffer.
-*/
-/* DEPRECATED */
-BrotliResult BrotliDecompressBufferStreaming(size_t* available_in,
-                                             const uint8_t** next_in,
-                                             int finish,
-                                             size_t* available_out,
-                                             uint8_t** next_out,
-                                             size_t* total_out,
-                                             BrotliState* s);
+/* Decompresses the data. Supports partial input and output.
 
+   Must be called with an allocated input buffer in |*next_in| and an allocated
+   output buffer in |*next_out|. The values |*available_in| and |*available_out|
+   must specify the allocated size in |*next_in| and |*next_out| respectively.
+
+   After each call, |*available_in| will be decremented by the amount of input
+   bytes consumed, and the |*next_in| pointer will be incremented by that
+   amount. Similarly, |*available_out| will be decremented by the amount of
+   output bytes written, and the |*next_out| pointer will be incremented by that
+   amount. |total_out|, if it is not a null-pointer, will be set to the number
+   of bytes decompressed since the last state initialization.
+
+   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,
@@ -148,16 +130,30 @@ BrotliResult BrotliDecompressStream(size_t* available_in,
 /* Fills the new state with a dictionary for LZ77, warming up the ringbuffer,
    e.g. for custom static dictionaries for data formats.
    Not to be confused with the built-in transformable dictionary of Brotli.
-   The dictionary must exist in memory until decoding is done and is owned by
-   the caller. To use:
-   -initialize state with BrotliStateInit
-   -use BrotliSetCustomDictionary
-   -use BrotliDecompressBufferStreaming
-   -clean up with BrotliStateCleanup
+   |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
+    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);
 
+/* 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 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 detailed error code after BrotliDecompressStream returns
+   BROTLI_RESULT_ERROR. */
+BrotliErrorCode BrotliGetErrorCode(const BrotliState* s);
+
+const char* BrotliErrorString(BrotliErrorCode c);
 
 #if defined(__cplusplus) || defined(c_plusplus)
 } /* extern "C" */

data/vendor/brotli/dec/dictionary.c

@@ -9462,5 +9462,5 @@ const uint8_t kBrotliDictionary[122784] = {
 };
 
 #if defined(__cplusplus) || defined(c_plusplus)
-}    /* extern "C" */
+}  /* extern "C" */
 #endif

data/vendor/brotli/dec/dictionary.h

@@ -17,23 +17,22 @@ extern "C" {
 
 extern const uint8_t kBrotliDictionary[122784];
 
-static const int kBrotliDictionaryOffsetsByLength[] = {
-     0,     0,     0,     0,     0,  4096,  9216, 21504, 35840, 44032,
- 53248, 63488, 74752, 87040, 93696, 100864, 104704, 106752, 108928, 113536,
- 115968, 118528, 119872, 121280, 122016,
+static const uint32_t kBrotliDictionaryOffsetsByLength[] = {
+  0, 0, 0, 0, 0, 4096, 9216, 21504, 35840, 44032, 53248, 63488, 74752, 87040,
+  93696, 100864, 104704, 106752, 108928, 113536, 115968, 118528, 119872, 121280,
+  122016
 };
 
 static const uint8_t kBrotliDictionarySizeBitsByLength[] = {
-  0,  0,  0,  0, 10, 10, 11, 11, 10, 10,
- 10, 10, 10,  9,  9,  8,  7,  7,  8,  7,
-  7,  6,  6,  5,  5,
+  0, 0, 0, 0, 10, 10, 11, 11, 10, 10, 10, 10, 10,
+  9, 9, 8, 7, 7,  8,  7,  7,  6,  6,  5,  5,
 };
 
 static const int kBrotliMinDictionaryWordLength = 4;
 static const int kBrotliMaxDictionaryWordLength = 24;
 
 #if defined(__cplusplus) || defined(c_plusplus)
-}    /* extern "C" */
+}  /* extern "C" */
 #endif
 
 #endif  /* BROTLI_DEC_DICTIONARY_H_ */

data/vendor/brotli/dec/huffman.c

@@ -6,11 +6,12 @@
 
 /* Utilities for building Huffman decoding tables. */
 
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
 #include "./huffman.h"
+
+#include <string.h>  /* memcpy, memset */
+
 #include "./port.h"
+#include "./types.h"
 
 #if defined(__cplusplus) || defined(c_plusplus)
 extern "C" {
@@ -23,43 +24,43 @@ extern "C" {
 #else
 #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
+  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 */
+#endif  /* BROTLI_RBIT */
 
 #define BROTLI_REVERSE_BITS_LOWEST \
-    (1U << (BROTLI_REVERSE_BITS_MAX - 1 + BROTLI_REVERSE_BITS_BASE))
+  (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
@@ -98,23 +99,22 @@ static BROTLI_INLINE int NextTableBitSize(const uint16_t* const count,
   return len - root_bits;
 }
 
-
 void BrotliBuildCodeLengthsHuffmanTable(HuffmanCode* table,
                                         const uint8_t* const code_lengths,
-                                        uint16_t *count) {
-  HuffmanCode code;    /* current table entry */
-  int symbol;          /* symbol index in original or sorted table */
-  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 */
+                                        uint16_t* count) {
+  HuffmanCode code;   /* current table entry */
+  int symbol;         /* symbol index in original or sorted table */
+  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 */
   /* offsets in sorted table for each length */
   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);
+  BROTLI_DCHECK(BROTLI_HUFFMAN_MAX_CODE_LENGTH_CODE_LENGTH <=
+                BROTLI_REVERSE_BITS_MAX);
 
   /* generate offsets into sorted symbol table by code length */
   symbol = -1;
@@ -169,26 +169,26 @@ void BrotliBuildCodeLengthsHuffmanTable(HuffmanCode* table,
 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 */
-  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 */
-  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 */
+                                 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 */
+  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 */
+  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 */
   int max_length = -1;
   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);
+  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;
@@ -237,7 +237,7 @@ uint32_t BrotliBuildHuffmanTable(HuffmanCode* root_table,
   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 (sub_key == (uint32_t)(BROTLI_REVERSE_BITS_LOWEST << 1)) {
+      if (sub_key == (BROTLI_REVERSE_BITS_LOWEST << 1U)) {
         table += table_size;
         table_bits = NextTableBitSize(count, len, root_bits);
         table_size = 1 << table_bits;
@@ -245,8 +245,8 @@ uint32_t BrotliBuildHuffmanTable(HuffmanCode* root_table,
         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);
+        root_table[sub_key].value =
+            (uint16_t)(((size_t)(table - root_table)) - sub_key);
         sub_key = 0;
       }
       code.bits = (uint8_t)(len - root_bits);
@@ -264,7 +264,7 @@ uint32_t BrotliBuildHuffmanTable(HuffmanCode* root_table,
 
 uint32_t BrotliBuildSimpleHuffmanTable(HuffmanCode* table,
                                        int root_bits,
-                                       uint16_t *val,
+                                       uint16_t* val,
                                        uint32_t num_symbols) {
   uint32_t table_size = 1;
   const uint32_t goal_size = 1U << root_bits;
@@ -301,49 +301,47 @@ uint32_t BrotliBuildSimpleHuffmanTable(HuffmanCode* table,
       table[3].bits = 2;
       table_size = 4;
       break;
-    case 3:
-      {
-        int i, k;
-        for (i = 0; i < 3; ++i) {
-          for (k = i + 1; k < 4; ++k) {
-            if (val[k] < val[i]) {
-              uint16_t t = val[k];
-              val[k] = val[i];
-              val[i] = t;
-            }
+    case 3: {
+      int i, k;
+      for (i = 0; i < 3; ++i) {
+        for (k = i + 1; k < 4; ++k) {
+          if (val[k] < val[i]) {
+            uint16_t t = val[k];
+            val[k] = val[i];
+            val[i] = t;
           }
         }
-        for (i = 0; i < 4; ++i) {
-          table[i].bits = 2;
-        }
-        table[0].value = val[0];
-        table[2].value = val[1];
-        table[1].value = val[2];
-        table[3].value = val[3];
-        table_size = 4;
       }
+      for (i = 0; i < 4; ++i) {
+        table[i].bits = 2;
+      }
+      table[0].value = val[0];
+      table[2].value = val[1];
+      table[1].value = val[2];
+      table[3].value = val[3];
+      table_size = 4;
       break;
-    case 4:
-      {
-        int i;
-        if (val[3] < val[2]) {
-          uint16_t t = val[3];
-          val[3] = val[2];
-          val[2] = t;
-        }
-        for (i = 0; i < 7; ++i) {
-          table[i].value = val[0];
-          table[i].bits = (uint8_t)(1 + (i & 1));
-        }
-        table[1].value = val[1];
-        table[3].value = val[2];
-        table[5].value = val[1];
-        table[7].value = val[3];
-        table[3].bits = 3;
-        table[7].bits = 3;
-        table_size = 8;
+    }
+    case 4: {
+      int i;
+      if (val[3] < val[2]) {
+        uint16_t t = val[3];
+        val[3] = val[2];
+        val[2] = t;
       }
+      for (i = 0; i < 7; ++i) {
+        table[i].value = val[0];
+        table[i].bits = (uint8_t)(1 + (i & 1));
+      }
+      table[1].value = val[1];
+      table[3].value = val[2];
+      table[5].value = val[1];
+      table[7].value = val[3];
+      table[3].bits = 3;
+      table[7].bits = 3;
+      table_size = 8;
       break;
+    }
   }
   while (table_size != goal_size) {
     memcpy(&table[table_size], &table[0],
@@ -354,5 +352,5 @@ uint32_t BrotliBuildSimpleHuffmanTable(HuffmanCode* table,
 }
 
 #if defined(__cplusplus) || defined(c_plusplus)
-}    /* extern "C" */
+}  /* extern "C" */
 #endif

data/vendor/brotli/dec/huffman.h

@@ -10,6 +10,7 @@
 #define BROTLI_DEC_HUFFMAN_H_
 
 #include "./types.h"
+#include "./port.h"
 
 #if defined(__cplusplus) || defined(c_plusplus)
 extern "C" {
@@ -20,38 +21,37 @@ extern "C" {
 /* 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 704, max code
- * length 15 and root table bits 8. */
-#define BROTLI_HUFFMAN_MAX_TABLE_SIZE 1080
+/* 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};
+#define BROTLI_HUFFMAN_MAX_SIZE_26 396
+#define BROTLI_HUFFMAN_MAX_SIZE_258 632
+#define BROTLI_HUFFMAN_MAX_SIZE_272 646
 
 #define BROTLI_HUFFMAN_MAX_CODE_LENGTH_CODE_LENGTH 5
 
 typedef struct {
-  uint8_t bits;     /* number of bits used for this symbol */
-  uint16_t value;   /* symbol value or table offset */
+  uint8_t bits;    /* number of bits used for this symbol */
+  uint16_t value;  /* symbol value or table offset */
 } HuffmanCode;
 
-
 /* Builds Huffman lookup table assuming code lengths are in symbol order. */
-void BrotliBuildCodeLengthsHuffmanTable(HuffmanCode* root_table,
-                                        const uint8_t* const code_lengths,
-                                        uint16_t *count);
+BROTLI_INTERNAL void BrotliBuildCodeLengthsHuffmanTable(HuffmanCode* root_table,
+    const uint8_t* const code_lengths, uint16_t* count);
 
 /* Builds Huffman lookup table assuming code lengths are in symbol order. */
 /* Returns size of resulting table. */
-uint32_t BrotliBuildHuffmanTable(HuffmanCode* root_table,
-                                 int root_bits,
-                                 const uint16_t* const symbol_lists,
-                                 uint16_t *count_arg);
+BROTLI_INTERNAL 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);
+BROTLI_INTERNAL 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 {
@@ -62,7 +62,7 @@ typedef struct {
 } HuffmanTreeGroup;
 
 #if defined(__cplusplus) || defined(c_plusplus)
-}    /* extern "C" */
+}  /* extern "C" */
 #endif
 
 #endif  /* BROTLI_DEC_HUFFMAN_H_ */