brotli 0.1.0

data/vendor/brotli/dec/huffman.c

@@ -0,0 +1,325 @@
+/* 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.
+*/
+
+/* Utilities for building Huffman decoding tables. */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include "./huffman.h"
+#include "./port.h"
+
+#if defined(__cplusplus) || defined(c_plusplus)
+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) {
+#ifdef BROTLI_RBIT
+  return BROTLI_RBIT(BROTLI_RBIT(key) + (1 << (8 * sizeof(unsigned) - len)));
+#else
+  unsigned step = (unsigned)(1 << (len - 1));
+  while (key & step) {
+    step >>= 1;
+  }
+  return (key & (step - 1)) + step;
+#endif
+}
+
+/* Stores code in table[0], table[step], table[2*step], ..., table[end] */
+/* Assumes that end is an integer multiple of step */
+static BROTLI_INLINE void ReplicateValue(HuffmanCode* table,
+                                         int step, int end,
+                                         HuffmanCode code) {
+  do {
+    end -= step;
+    table[end] = code;
+  } while (end > 0);
+}
+
+/* Returns the table width of the next 2nd level table. count is the histogram
+   of bit lengths for the remaining symbols, len is the code length of the next
+   processed symbol */
+static BROTLI_INLINE int NextTableBitSize(const uint16_t* const count,
+                                          int len, int root_bits) {
+  int left = 1 << (len - root_bits);
+  while (len < BROTLI_HUFFMAN_MAX_CODE_LENGTH) {
+    left -= count[len];
+    if (left <= 0) break;
+    ++len;
+    left <<= 1;
+  }
+  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 */
+  unsigned key;        /* reversed prefix code */
+  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;
+
+  /* generate offsets into sorted symbol table by code length */
+  symbol = -1;
+  bits = 1;
+  BROTLI_REPEAT(BROTLI_HUFFMAN_MAX_CODE_LENGTH_CODE_LENGTH, {
+    symbol += count[bits];
+    offset[bits] = symbol;
+    bits++;
+  });
+  offset[0] = 17;
+
+  /* sort symbols by length, by symbol order within each length */
+  symbol = 18;
+  do {
+    BROTLI_REPEAT(6, {
+      symbol--;
+      sorted[offset[code_lengths[symbol]]--] = symbol;
+    });
+  } while (symbol != 0);
+
+  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) {
+    code.bits = 0;
+    code.value = (uint16_t)sorted[0];
+    for (key = 0; key < table_size; ++key) {
+      table[key] = code;
+    }
+    return;
+  }
+
+  /* fill in table */
+  key = 0;
+  symbol = 0;
+  bits = 1;
+  step = 2;
+  do {
+    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);
+    }
+    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) {
+  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 */
+  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 */
+  int max_length = -1;
+  int bits;
+  int bits_count;
+
+  while (symbol_lists[max_length] == 0xFFFF) max_length--;
+  max_length += BROTLI_HUFFMAN_MAX_CODE_LENGTH + 1;
+
+  table = root_table;
+  table_bits = root_bits;
+  table_size = 1 << table_bits;
+  total_size = table_size;
+
+  /* fill in root table */
+  /* let's reduce the table size to a smaller size if possible, and */
+  /* create the repetitions by memcpy if possible in the coming loop */
+  if (table_bits > max_length) {
+    table_bits = max_length;
+    table_size = 1 << table_bits;
+  }
+  key = 0;
+  bits = 1;
+  step = 2;
+  do {
+    code.bits = (uint8_t)bits;
+    symbol = bits - (BROTLI_HUFFMAN_MAX_CODE_LENGTH + 1);
+    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);
+    }
+    step <<= 1;
+  } while (++bits <= table_bits);
+
+  /* if root_bits != table_bits we only created one fraction of the */
+  /* table, and we need to replicate it now. */
+  while (total_size != table_size) {
+    memcpy(&table[table_size], &table[0],
+           (size_t)table_size * sizeof(table[0]));
+    table_size <<= 1;
+  }
+
+  /* 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) {
+    symbol = len - (BROTLI_HUFFMAN_MAX_CODE_LENGTH + 1);
+    for (; count[len] != 0; --count[len]) {
+      if ((key & mask) != low) {
+        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);
+      }
+      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);
+    }
+  }
+  return 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;
+  switch (num_symbols) {
+    case 0:
+      table[0].bits = 0;
+      table[0].value = val[0];
+      break;
+    case 1:
+      table[0].bits = 1;
+      table[1].bits = 1;
+      if (val[1] > val[0]) {
+        table[0].value = val[0];
+        table[1].value = val[1];
+      } else {
+        table[0].value = val[1];
+        table[1].value = val[0];
+      }
+      table_size = 2;
+      break;
+    case 2:
+      table[0].bits = 1;
+      table[0].value = val[0];
+      table[2].bits = 1;
+      table[2].value = val[0];
+      if (val[2] > val[1]) {
+        table[1].value = val[1];
+        table[3].value = val[2];
+      } else {
+        table[1].value = val[2];
+        table[3].value = val[1];
+      }
+      table[1].bits = 2;
+      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;
+            }
+          }
+        }
+        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;
+      }
+      break;
+  }
+  while (table_size != goal_size) {
+    memcpy(&table[table_size], &table[0],
+           (size_t)table_size * sizeof(table[0]));
+    table_size <<= 1;
+  }
+  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

@@ -0,0 +1,77 @@
+/* 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.
+*/
+
+/* Utilities for building Huffman decoding tables. */
+
+#ifndef BROTLI_DEC_HUFFMAN_H_
+#define BROTLI_DEC_HUFFMAN_H_
+
+#include "./types.h"
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+#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 704, max code
+ * length 15 and root table bits 8. */
+#define BROTLI_HUFFMAN_MAX_TABLE_SIZE 1080
+
+#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 */
+} 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);
+
+/* 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. */
+typedef struct {
+  HuffmanCode** htrees;
+  HuffmanCode* codes;
+  int16_t alphabet_size;
+  int16_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
+
+#endif  /* BROTLI_DEC_HUFFMAN_H_ */

data/vendor/brotli/dec/port.h

@@ -0,0 +1,148 @@
+/* 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.
+*/
+
+/* Macros for branch prediction. */
+
+#ifndef BROTLI_DEC_PORT_H_
+#define BROTLI_DEC_PORT_H_
+
+#include<assert.h>
+
+/* 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
+
+#define BROTLI_ASAN_BUILD __has_feature(address_sanitizer)
+
+/* 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 (__GNUC__ > 2) || (__GNUC__ == 2 && __GNUC_MINOR__ > 95) || \
+    (defined(__llvm__) && __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 (__GNUC__ > 3) || (__GNUC__ == 3 && __GNUC_MINOR__ > 0) || \
+    (defined(__llvm__) && __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))
+#define ATTRIBUTE_ALWAYS_INLINE __attribute__ ((always_inline))
+#else
+#define ATTRIBUTE_ALWAYS_INLINE
+#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_DECODE_DEBUG
+#define BROTLI_DCHECK(x) assert(x)
+#else
+#define BROTLI_DCHECK(x)
+#endif
+
+#if (defined(__x86_64__) || defined(_M_X64) || defined(__aarch64__) || \
+     defined(__PPC64__))
+#define BROTLI_64_BITS 1
+#else
+#define BROTLI_64_BITS 0
+#endif
+
+#if (defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__))
+#define BROTLI_LITTLE_ENDIAN 1
+#elif defined(_WIN32)
+/* Win32 can currently always be assumed to be little endian */
+#define BROTLI_LITTLE_ENDIAN 1
+#else
+#define BROTLI_LITTLE_ENDIAN 0
+#endif
+
+#if (BROTLI_64_BITS && BROTLI_LITTLE_ENDIAN)
+#define BROTLI_64_BITS_LITTLE_ENDIAN 1
+#else
+#define BROTLI_64_BITS_LITTLE_ENDIAN 0
+#endif
+
+#if (__GNUC__ > 3) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1) || \
+    (defined(__llvm__) && __has_attribute(noinline))
+#define BROTLI_NOINLINE __attribute__ ((noinline))
+#else
+#define BROTLI_NOINLINE
+#endif
+
+#if BROTLI_ASAN_BUILD
+#define BROTLI_NO_ASAN __attribute__((no_sanitize("address"))) BROTLI_NOINLINE
+#else
+#define BROTLI_NO_ASAN
+#endif
+
+#define BROTLI_REPEAT(N, X) { \
+  if ((N & 1) != 0) {X;} \
+  if ((N & 2) != 0) {X; X;} \
+  if ((N & 4) != 0) {X; X; X; X;} \
+}
+
+#if (__GNUC__ > 2) || defined(__llvm__)
+#if (defined(__ARM_ARCH) && (__ARM_ARCH >= 7))
+static BROTLI_INLINE unsigned BrotliRBit(unsigned input) {
+  unsigned output;
+  __asm__("rbit %0, %1\n" : "=r"(output) : "r"(input));
+  return output;
+}
+#define BROTLI_RBIT(x) BrotliRBit(x)
+#endif  /* armv7 */
+#endif  /* gcc || clang */
+
+#endif  /* BROTLI_DEC_PORT_H_ */