brotli 0.1.8 → 0.2.0

data/vendor/brotli/{dec → c/dec}/huffman.c

@@ -11,7 +11,7 @@
 #include <string.h>  /* memcpy, memset */
 
 #include "../common/constants.h"
-#include "../common/types.h"
+#include <brotli/types.h>
 #include "./port.h"
 
 #if defined(__cplusplus) || defined(c_plusplus)
@@ -21,7 +21,8 @@ extern "C" {
 #define BROTLI_REVERSE_BITS_MAX 8
 
 #ifdef BROTLI_RBIT
-#define BROTLI_REVERSE_BITS_BASE (32 - BROTLI_REVERSE_BITS_MAX)
+#define BROTLI_REVERSE_BITS_BASE \
+  ((sizeof(reg_t) << 3) - BROTLI_REVERSE_BITS_MAX)
 #else
 #define BROTLI_REVERSE_BITS_BASE 0
 static uint8_t kReverseBits[1 << BROTLI_REVERSE_BITS_MAX] = {
@@ -61,12 +62,12 @@ static uint8_t kReverseBits[1 << BROTLI_REVERSE_BITS_MAX] = {
 #endif  /* BROTLI_RBIT */
 
 #define BROTLI_REVERSE_BITS_LOWEST \
-  (1U << (BROTLI_REVERSE_BITS_MAX - 1 + BROTLI_REVERSE_BITS_BASE))
+  ((reg_t)1 << (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) {
+static BROTLI_INLINE reg_t BrotliReverseBits(reg_t num) {
 #ifdef BROTLI_RBIT
   return BROTLI_RBIT(num);
 #else
@@ -103,12 +104,12 @@ static BROTLI_INLINE int NextTableBitSize(const uint16_t* const count,
 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 */
+  HuffmanCode code; /* current table entry */
+  int symbol;       /* symbol index in original or sorted table */
+  reg_t key;        /* prefix code */
+  reg_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[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];
@@ -143,7 +144,7 @@ void BrotliBuildCodeLengthsHuffmanTable(HuffmanCode* table,
   if (offset[0] == 0) {
     code.bits = 0;
     code.value = (uint16_t)sorted[0];
-    for (key = 0; key < (uint32_t)table_size; ++key) {
+    for (key = 0; key < (reg_t)table_size; ++key) {
       table[key] = code;
     }
     return;
@@ -171,18 +172,18 @@ 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 */
+  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 */
+  reg_t key;           /* prefix code */
+  reg_t key_step;      /* prefix code addend */
+  reg_t sub_key;       /* 2nd level table prefix code */
+  reg_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;

data/vendor/brotli/{dec → c/dec}/huffman.h

@@ -9,7 +9,7 @@
 #ifndef BROTLI_DEC_HUFFMAN_H_
 #define BROTLI_DEC_HUFFMAN_H_
 
-#include "../common/types.h"
+#include <brotli/types.h>
 #include "./port.h"
 
 #if defined(__cplusplus) || defined(c_plusplus)

data/vendor/brotli/{dec → c/dec}/port.h

@@ -16,6 +16,7 @@
       features and attributes
     * BROTLI_BUILD_PORTABLE disables dangerous optimizations, like unaligned
       read and overlapping memcpy; this reduces decompression speed by 5%
+    * BROTLI_BUILD_NO_RBIT disables "rbit" optimization for ARM CPUs
     * BROTLI_DEBUG dumps file name and line number when decoder detects stream
       or memory error
     * BROTLI_ENABLE_LOG enables asserts and dumps various state information
@@ -29,16 +30,16 @@
 #include <stdio.h>
 #endif
 
-#include "../common/port.h"
+#include <brotli/port.h>
 
 #if defined(__arm__) || defined(__thumb__) || \
-    defined(_M_ARM) || defined(_M_ARMT)
+    defined(_M_ARM) || defined(_M_ARMT) || defined(__ARM64_ARCH_8__)
 #define BROTLI_TARGET_ARM
-#if (defined(__ARM_ARCH) && (__ARM_ARCH >= 7)) || \
-    (defined(M_ARM) && (M_ARM >= 7))
+#if (defined(__ARM_ARCH) && (__ARM_ARCH == 7)) || \
+    (defined(M_ARM) && (M_ARM == 7))
 #define BROTLI_TARGET_ARMV7
 #endif  /* ARMv7 */
-#if defined(__aarch64__)
+#if defined(__aarch64__) || defined(__ARM64_ARCH_8__)
 #define BROTLI_TARGET_ARMV8
 #endif  /* ARMv8 */
 #endif  /* ARM */
@@ -59,7 +60,7 @@
 #define BROTLI_ALIGNED_READ (!!1)
 #elif defined(BROTLI_TARGET_X86) || defined(BROTLI_TARGET_X64) || \
      defined(BROTLI_TARGET_ARMV7) || defined(BROTLI_TARGET_ARMV8)
-/* Allow unaligned read only for whitelisted CPUs. */
+/* Allow unaligned read only for white-listed CPUs. */
 #define BROTLI_ALIGNED_READ (!!0)
 #else
 #define BROTLI_ALIGNED_READ (!!1)
@@ -101,6 +102,12 @@ static BROTLI_INLINE void BrotliDump(const char* f, int l, const char* fn) {
 #define BROTLI_64_BITS 0
 #endif
 
+#if (BROTLI_64_BITS)
+#define reg_t uint64_t
+#else
+#define reg_t uint32_t
+#endif
+
 #if defined(BROTLI_BUILD_BIG_ENDIAN)
 #define BROTLI_LITTLE_ENDIAN 0
 #define BROTLI_BIG_ENDIAN 1
@@ -132,10 +139,12 @@ static BROTLI_INLINE void BrotliDump(const char* f, int l, const char* fn) {
   if ((N & 4) != 0) {X; X; X; X;} \
 }
 
-#if BROTLI_MODERN_COMPILER || defined(__llvm__)
-#if defined(BROTLI_TARGET_ARMV7)
-static BROTLI_INLINE unsigned BrotliRBit(unsigned input) {
-  unsigned output;
+#if (BROTLI_MODERN_COMPILER || defined(__llvm__)) && \
+    !defined(BROTLI_BUILD_NO_RBIT)
+#if defined(BROTLI_TARGET_ARMV7) || defined(BROTLI_TARGET_ARMV8)
+/* TODO: detect ARMv6T2 and enable this code for it. */
+static BROTLI_INLINE reg_t BrotliRBit(reg_t input) {
+  reg_t output;
   __asm__("rbit %0, %1\n" : "=r"(output) : "r"(input));
   return output;
 }

data/vendor/brotli/{dec → c/dec}/prefix.h

@@ -12,7 +12,7 @@
 #define BROTLI_DEC_PREFIX_H_
 
 #include "../common/constants.h"
-#include "../common/types.h"
+#include <brotli/types.h>
 
 /* Represents the range of values belonging to a prefix code: */
 /* [offset, offset + 2^nbits) */

data/vendor/brotli/{dec → c/dec}/state.c

@@ -8,7 +8,7 @@
 
 #include <stdlib.h>  /* free, malloc */
 
-#include "../common/types.h"
+#include <brotli/types.h>
 #include "./huffman.h"
 
 #if defined(__cplusplus) || defined(c_plusplus)
@@ -41,6 +41,8 @@ void BrotliDecoderStateInitWithCustomAllocators(BrotliDecoderState* s,
     s->memory_manager_opaque = opaque;
   }
 
+  s->error_code = 0; /* BROTLI_DECODER_NO_ERROR */
+
   BrotliInitBitReader(&s->br);
   s->state = BROTLI_STATE_UNINITED;
   s->substate_metablock_header = BROTLI_STATE_METABLOCK_HEADER_NONE;
@@ -51,6 +53,8 @@ void BrotliDecoderStateInitWithCustomAllocators(BrotliDecoderState* s,
   s->substate_decode_uint8 = BROTLI_STATE_DECODE_UINT8_NONE;
   s->substate_read_block_length = BROTLI_STATE_READ_BLOCK_LENGTH_NONE;
 
+  s->dictionary = BrotliGetDictionary();
+
   s->buffer_length = 0;
   s->loop_counter = 0;
   s->pos = 0;
@@ -60,6 +64,9 @@ void BrotliDecoderStateInitWithCustomAllocators(BrotliDecoderState* s,
   s->block_type_trees = NULL;
   s->block_len_trees = NULL;
   s->ringbuffer = NULL;
+  s->ringbuffer_size = 0;
+  s->new_ringbuffer_size = 0;
+  s->ringbuffer_mask = 0;
 
   s->context_map = NULL;
   s->context_modes = NULL;
@@ -76,10 +83,12 @@ void BrotliDecoderStateInitWithCustomAllocators(BrotliDecoderState* s,
   s->distance_hgroup.codes = NULL;
   s->distance_hgroup.htrees = NULL;
 
-  s->custom_dict = NULL;
-  s->custom_dict_size = 0;
-
   s->is_last_metablock = 0;
+  s->is_uncompressed = 0;
+  s->is_metadata = 0;
+  s->should_wrap_ringbuffer = 0;
+  s->canny_ringbuffer_allocation = 1;
+
   s->window_bits = 0;
   s->max_distance = 0;
   s->dist_rb[0] = 16;
@@ -93,7 +102,7 @@ void BrotliDecoderStateInitWithCustomAllocators(BrotliDecoderState* s,
   /* Make small negative indexes addressable. */
   s->symbol_lists = &s->symbols_lists_array[BROTLI_HUFFMAN_MAX_CODE_LENGTH + 1];
 
-  s->mtf_upper_bound = 255;
+  s->mtf_upper_bound = 63;
 }
 
 void BrotliDecoderStateMetablockBegin(BrotliDecoderState* s) {
@@ -131,10 +140,9 @@ void BrotliDecoderStateCleanupAfterMetablock(BrotliDecoderState* s) {
   BROTLI_FREE(s, s->context_modes);
   BROTLI_FREE(s, s->context_map);
   BROTLI_FREE(s, s->dist_context_map);
-
-  BrotliDecoderHuffmanTreeGroupRelease(s, &s->literal_hgroup);
-  BrotliDecoderHuffmanTreeGroupRelease(s, &s->insert_copy_hgroup);
-  BrotliDecoderHuffmanTreeGroupRelease(s, &s->distance_hgroup);
+  BROTLI_FREE(s, s->literal_hgroup.htrees);
+  BROTLI_FREE(s, s->insert_copy_hgroup.htrees);
+  BROTLI_FREE(s, s->distance_hgroup.htrees);
 }
 
 void BrotliDecoderStateCleanup(BrotliDecoderState* s) {
@@ -144,23 +152,19 @@ void BrotliDecoderStateCleanup(BrotliDecoderState* s) {
   BROTLI_FREE(s, s->block_type_trees);
 }
 
-void BrotliDecoderHuffmanTreeGroupInit(BrotliDecoderState* s,
+BROTLI_BOOL 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;
   const size_t htree_size = sizeof(HuffmanCode*) * ntrees;
-  char* p = (char*)BROTLI_ALLOC(s, code_size + htree_size);
+  /* Pointer alignment is, hopefully, wider than sizeof(HuffmanCode). */
+  HuffmanCode** p = (HuffmanCode**)BROTLI_ALLOC(s, code_size + htree_size);
   group->alphabet_size = (uint16_t)alphabet_size;
   group->num_htrees = (uint16_t)ntrees;
-  group->codes = (HuffmanCode*)p;
-  group->htrees = (HuffmanCode**)(p + code_size);
-}
-
-void BrotliDecoderHuffmanTreeGroupRelease(
-    BrotliDecoderState* s, HuffmanTreeGroup* group) {
-  BROTLI_FREE(s, group->codes);
-  group->htrees = NULL;
+  group->htrees = p;
+  group->codes = (HuffmanCode*)(&p[ntrees]);
+  return !!p;
 }
 
 #if defined(__cplusplus) || defined(c_plusplus)

data/vendor/brotli/{dec → c/dec}/state.h

@@ -10,7 +10,8 @@
 #define BROTLI_DEC_STATE_H_
 
 #include "../common/constants.h"
-#include "../common/types.h"
+#include "../common/dictionary.h"
+#include <brotli/types.h>
 #include "./bit_reader.h"
 #include "./huffman.h"
 #include "./port.h"
@@ -115,7 +116,6 @@ struct BrotliDecoderStateStruct {
 
   int pos;
   int max_backward_distance;
-  int max_backward_distance_minus_custom_dict_size;
   int max_distance;
   int ringbuffer_size;
   int ringbuffer_mask;
@@ -141,6 +141,8 @@ struct BrotliDecoderStateStruct {
   /* This is true if the literal context map histogram type always matches the
   block type. It is then not needed to keep the context (faster decoding). */
   int trivial_literal_context;
+  /* Distance context is actual after command is decoded and before distance
+  is computed. After distance computation it is used as a temporary variable. */
   int distance_context;
   int meta_block_remaining_len;
   uint32_t block_length_index;
@@ -161,8 +163,8 @@ struct BrotliDecoderStateStruct {
   int distance_code;
 
   /* For partial write operations */
-  size_t rb_roundtrips;  /* How many times we went around the ringbuffer */
-  size_t partial_pos_out;  /* How much output to the user in total (<= rb) */
+  size_t rb_roundtrips;  /* How many times we went around the ring-buffer */
+  size_t partial_pos_out;  /* How much output to the user in total */
 
   /* For ReadHuffmanCode */
   uint32_t symbol;
@@ -170,7 +172,7 @@ struct BrotliDecoderStateStruct {
   uint32_t space;
 
   HuffmanCode table[32];
-  /* List of of symbol chains. */
+  /* List of heads of symbol chains. */
   uint16_t* symbol_lists;
   /* Storage from symbol_lists. */
   uint16_t symbols_lists_array[BROTLI_HUFFMAN_MAX_CODE_LENGTH + 1 +
@@ -193,11 +195,7 @@ struct BrotliDecoderStateStruct {
 
   /* For InverseMoveToFrontTransform */
   uint32_t mtf_upper_bound;
-  uint8_t mtf[256 + 4];
-
-  /* For custom dictionaries */
-  const uint8_t* custom_dict;
-  int custom_dict_size;
+  uint32_t mtf[64 + 1];
 
   /* less used attributes are in the end of this struct */
   /* States inside function calls */
@@ -209,15 +207,20 @@ struct BrotliDecoderStateStruct {
   BrotliRunningDecodeUint8State substate_decode_uint8;
   BrotliRunningReadBlockLengthState substate_read_block_length;
 
-  uint8_t is_last_metablock;
-  uint8_t is_uncompressed;
-  uint8_t is_metadata;
-  uint8_t size_nibbles;
+  unsigned int is_last_metablock : 1;
+  unsigned int is_uncompressed : 1;
+  unsigned int is_metadata : 1;
+  unsigned int should_wrap_ringbuffer : 1;
+  unsigned int canny_ringbuffer_allocation : 1;
+  unsigned int size_nibbles : 8;
   uint32_t window_bits;
 
+  int new_ringbuffer_size;
+
   uint32_t num_literal_htrees;
   uint8_t* context_map;
   uint8_t* context_modes;
+  const BrotliDictionary* dictionary;
 
   uint32_t trivial_literal_contexts[8];  /* 256 bits */
 };
@@ -233,11 +236,9 @@ BROTLI_INTERNAL void BrotliDecoderStateCleanup(BrotliDecoderState* s);
 BROTLI_INTERNAL void BrotliDecoderStateMetablockBegin(BrotliDecoderState* s);
 BROTLI_INTERNAL void BrotliDecoderStateCleanupAfterMetablock(
     BrotliDecoderState* s);
-BROTLI_INTERNAL void BrotliDecoderHuffmanTreeGroupInit(
+BROTLI_INTERNAL BROTLI_BOOL 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 → c/dec}/transform.h

@@ -9,7 +9,7 @@
 #ifndef BROTLI_DEC_TRANSFORM_H_
 #define BROTLI_DEC_TRANSFORM_H_
 
-#include "../common/types.h"
+#include <brotli/types.h>
 #include "./port.h"
 
 #if defined(__cplusplus) || defined(c_plusplus)
@@ -247,7 +247,7 @@ static int ToUpperCase(uint8_t* p) {
     }
     return 1;
   }
-  /* An overly simplified uppercasing model for utf-8. */
+  /* An overly simplified uppercasing model for UTF-8. */
   if (p[0] < 0xe0) {
     p[1] ^= 32;
     return 2;

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

@@ -0,0 +1,134 @@
+/* Copyright 2013 Google Inc. All Rights Reserved.
+
+   Distributed under MIT license.
+   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+*/
+
+/* Function to find backward reference copies. */
+
+#include "./backward_references.h"
+
+#include "../common/constants.h"
+#include "../common/dictionary.h"
+#include <brotli/types.h>
+#include "./command.h"
+#include "./dictionary_hash.h"
+#include "./memory.h"
+#include "./port.h"
+#include "./quality.h"
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+static BROTLI_INLINE size_t ComputeDistanceCode(size_t distance,
+                                                size_t max_distance,
+                                                const int* dist_cache) {
+  if (distance <= max_distance) {
+    size_t distance_plus_3 = distance + 3;
+    size_t offset0 = distance_plus_3 - (size_t)dist_cache[0];
+    size_t offset1 = distance_plus_3 - (size_t)dist_cache[1];
+    if (distance == (size_t)dist_cache[0]) {
+      return 0;
+    } else if (distance == (size_t)dist_cache[1]) {
+      return 1;
+    } else if (offset0 < 7) {
+      return (0x9750468 >> (4 * offset0)) & 0xF;
+    } else if (offset1 < 7) {
+      return (0xFDB1ACE >> (4 * offset1)) & 0xF;
+    } else if (distance == (size_t)dist_cache[2]) {
+      return 2;
+    } else if (distance == (size_t)dist_cache[3]) {
+      return 3;
+    }
+  }
+  return distance + BROTLI_NUM_DISTANCE_SHORT_CODES - 1;
+}
+
+#define EXPAND_CAT(a, b) CAT(a, b)
+#define CAT(a, b) a ## b
+#define FN(X) EXPAND_CAT(X, HASHER())
+#define EXPORT_FN(X) EXPAND_CAT(X, EXPAND_CAT(PREFIX(), HASHER()))
+#define PREFIX() N
+
+#define HASHER() H2
+/* NOLINTNEXTLINE(build/include) */
+#include "./backward_references_inc.h"
+#undef HASHER
+
+#define HASHER() H3
+/* NOLINTNEXTLINE(build/include) */
+#include "./backward_references_inc.h"
+#undef HASHER
+
+#define HASHER() H4
+/* NOLINTNEXTLINE(build/include) */
+#include "./backward_references_inc.h"
+#undef HASHER
+
+#define HASHER() H5
+/* NOLINTNEXTLINE(build/include) */
+#include "./backward_references_inc.h"
+#undef HASHER
+
+#define HASHER() H6
+/* NOLINTNEXTLINE(build/include) */
+#include "./backward_references_inc.h"
+#undef HASHER
+
+#define HASHER() H40
+/* NOLINTNEXTLINE(build/include) */
+#include "./backward_references_inc.h"
+#undef HASHER
+
+#define HASHER() H41
+/* NOLINTNEXTLINE(build/include) */
+#include "./backward_references_inc.h"
+#undef HASHER
+
+#define HASHER() H42
+/* NOLINTNEXTLINE(build/include) */
+#include "./backward_references_inc.h"
+#undef HASHER
+
+#define HASHER() H54
+/* NOLINTNEXTLINE(build/include) */
+#include "./backward_references_inc.h"
+#undef HASHER
+
+#undef PREFIX
+#undef EXPORT_FN
+#undef FN
+#undef CAT
+#undef EXPAND_CAT
+
+void BrotliCreateBackwardReferences(const BrotliDictionary* dictionary,
+                                    size_t num_bytes,
+                                    size_t position,
+                                    const uint8_t* ringbuffer,
+                                    size_t ringbuffer_mask,
+                                    const BrotliEncoderParams* params,
+                                    HasherHandle hasher,
+                                    int* dist_cache,
+                                    size_t* last_insert_len,
+                                    Command* commands,
+                                    size_t* num_commands,
+                                    size_t* num_literals) {
+  switch (params->hasher.type) {
+#define CASE_(N)                                                  \
+    case N:                                                       \
+      CreateBackwardReferencesNH ## N(dictionary,                 \
+          kStaticDictionaryHash, num_bytes, position, ringbuffer, \
+          ringbuffer_mask, params, hasher, dist_cache,            \
+          last_insert_len, commands, num_commands, num_literals); \
+      return;
+    FOR_GENERIC_HASHERS(CASE_)
+#undef CASE_
+    default:
+      break;
+  }
+}
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}  /* extern "C" */
+#endif