brotli 0.1.3 → 0.1.4

data/vendor/brotli/enc/entropy_encode.h

@@ -4,101 +4,119 @@
    See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
 */
 
-// Entropy encoding (Huffman) utilities.
+/* Entropy encoding (Huffman) utilities. */
 
 #ifndef BROTLI_ENC_ENTROPY_ENCODE_H_
 #define BROTLI_ENC_ENTROPY_ENCODE_H_
 
-#include <string.h>
-#include "./histogram.h"
-#include "./prefix.h"
-#include "./types.h"
+#include "../common/types.h"
+#include "./port.h"
 
-namespace brotli {
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
 
-// A node of a Huffman tree.
-struct HuffmanTree {
-  HuffmanTree() {}
-  HuffmanTree(uint32_t count, int16_t left, int16_t right)
-      : total_count_(count),
-        index_left_(left),
-        index_right_or_value_(right) {
-  }
+/* A node of a Huffman tree. */
+typedef struct HuffmanTree {
   uint32_t total_count_;
   int16_t index_left_;
   int16_t index_right_or_value_;
-};
-
-void SetDepth(const HuffmanTree &p, HuffmanTree *pool,
-              uint8_t *depth, uint8_t level);
-
-// This function will create a Huffman tree.
-//
-// The (data,length) contains the population counts.
-// The tree_limit is the maximum bit depth of the Huffman codes.
-//
-// The depth contains the tree, i.e., how many bits are used for
-// the symbol.
-//
-// The actual Huffman tree is constructed in the tree[] array, which has to
-// be at least 2 * length + 1 long.
-//
-// See http://en.wikipedia.org/wiki/Huffman_coding
-void CreateHuffmanTree(const uint32_t *data,
-                       const size_t length,
-                       const int tree_limit,
-                       HuffmanTree* tree,
-                       uint8_t *depth);
-
-// Change the population counts in a way that the consequent
-// Huffman tree compression, especially its rle-part will be more
-// likely to compress this data more efficiently.
-//
-// length contains the size of the histogram.
-// counts contains the population counts.
-// good_for_rle is a buffer of at least length size
-void OptimizeHuffmanCountsForRle(size_t length, uint32_t* counts,
-                                 uint8_t* good_for_rle);
-
-// Write a Huffman tree from bit depths into the bitstream representation
-// of a Huffman tree. The generated Huffman tree is to be compressed once
-// more using a Huffman tree
-void WriteHuffmanTree(const uint8_t* depth,
-                      size_t num,
-                      size_t* tree_size,
-                      uint8_t* tree,
-                      uint8_t* extra_bits_data);
-
-// Get the actual bit values for a tree of bit depths.
-void ConvertBitDepthsToSymbols(const uint8_t *depth,
-                               size_t len,
-                               uint16_t *bits);
-
-template<int kSize>
-struct EntropyCode {
-  // How many bits for symbol.
-  uint8_t depth_[kSize];
-  // Actual bits used to represent the symbol.
-  uint16_t bits_[kSize];
-  // How many non-zero depth.
-  int count_;
-  // First four symbols with non-zero depth.
-  int symbols_[4];
-};
-
-static const int kCodeLengthCodes = 18;
-
-// Literal entropy code.
-typedef EntropyCode<256> EntropyCodeLiteral;
-// Prefix entropy codes.
-typedef EntropyCode<kNumCommandPrefixes> EntropyCodeCommand;
-typedef EntropyCode<kNumDistancePrefixes> EntropyCodeDistance;
-typedef EntropyCode<kNumBlockLenPrefixes> EntropyCodeBlockLength;
-// Context map entropy code, 256 Huffman tree indexes + 16 run length codes.
-typedef EntropyCode<272> EntropyCodeContextMap;
-// Block type entropy code, 256 block types + 2 special symbols.
-typedef EntropyCode<258> EntropyCodeBlockType;
-
-}  // namespace brotli
-
-#endif  // BROTLI_ENC_ENTROPY_ENCODE_H_
+} HuffmanTree;
+
+static BROTLI_INLINE void InitHuffmanTree(HuffmanTree* self, uint32_t count,
+    int16_t left, int16_t right) {
+  self->total_count_ = count;
+  self->index_left_ = left;
+  self->index_right_or_value_ = right;
+}
+
+/* Returns 1 is assignment of depths succeded, otherwise 0. */
+BROTLI_INTERNAL BROTLI_BOOL BrotliSetDepth(
+    int p, HuffmanTree* pool, uint8_t* depth, int max_depth);
+
+/* This function will create a Huffman tree.
+
+   The (data,length) contains the population counts.
+   The tree_limit is the maximum bit depth of the Huffman codes.
+
+   The depth contains the tree, i.e., how many bits are used for
+   the symbol.
+
+   The actual Huffman tree is constructed in the tree[] array, which has to
+   be at least 2 * length + 1 long.
+
+   See http://en.wikipedia.org/wiki/Huffman_coding */
+BROTLI_INTERNAL void BrotliCreateHuffmanTree(const uint32_t *data,
+                                             const size_t length,
+                                             const int tree_limit,
+                                             HuffmanTree* tree,
+                                             uint8_t *depth);
+
+/* Change the population counts in a way that the consequent
+   Huffman tree compression, especially its rle-part will be more
+   likely to compress this data more efficiently.
+
+   length contains the size of the histogram.
+   counts contains the population counts.
+   good_for_rle is a buffer of at least length size */
+BROTLI_INTERNAL void BrotliOptimizeHuffmanCountsForRle(
+    size_t length, uint32_t* counts, uint8_t* good_for_rle);
+
+/* Write a Huffman tree from bit depths into the bitstream representation
+   of a Huffman tree. The generated Huffman tree is to be compressed once
+   more using a Huffman tree */
+BROTLI_INTERNAL void BrotliWriteHuffmanTree(const uint8_t* depth,
+                                            size_t num,
+                                            size_t* tree_size,
+                                            uint8_t* tree,
+                                            uint8_t* extra_bits_data);
+
+/* Get the actual bit values for a tree of bit depths. */
+BROTLI_INTERNAL void BrotliConvertBitDepthsToSymbols(const uint8_t *depth,
+                                                     size_t len,
+                                                     uint16_t *bits);
+
+/* Input size optimized Shell sort. */
+typedef BROTLI_BOOL (*HuffmanTreeComparator)(
+    const HuffmanTree*, const HuffmanTree*);
+static BROTLI_INLINE void SortHuffmanTreeItems(HuffmanTree* items,
+    const size_t n, HuffmanTreeComparator comparator) {
+  static const size_t gaps[] = {132, 57, 23, 10, 4, 1};
+  if (n < 13) {
+    /* Insertion sort. */
+    size_t i;
+    for (i = 1; i < n; ++i) {
+      HuffmanTree tmp = items[i];
+      size_t k = i;
+      size_t j = i - 1;
+      while (comparator(&tmp, &items[j])) {
+        items[k] = items[j];
+        k = j;
+        if (!j--) break;
+      }
+      items[k] = tmp;
+    }
+    return;
+  } else {
+    /* Shell sort. */
+    int g = n < 57 ? 2 : 0;
+    for (; g < 6; ++g) {
+      size_t gap = gaps[g];
+      size_t i;
+      for (i = gap; i < n; ++i) {
+        size_t j = i;
+        HuffmanTree tmp = items[i];
+        for (; j >= gap && comparator(&tmp, &items[j - gap]); j -= gap) {
+          items[j] = items[j - gap];
+        }
+        items[j] = tmp;
+      }
+    }
+  }
+}
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}  /* extern "C" */
+#endif
+
+#endif  /* BROTLI_ENC_ENTROPY_ENCODE_H_ */

data/vendor/brotli/enc/entropy_encode_static.h

@@ -4,22 +4,25 @@
    See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
 */
 
-// Static entropy codes used for faster meta-block encoding.
+/* Static entropy codes used for faster meta-block encoding. */
 
 #ifndef BROTLI_ENC_ENTROPY_ENCODE_STATIC_H_
 #define BROTLI_ENC_ENTROPY_ENCODE_STATIC_H_
 
-#include "./prefix.h"
-#include "./types.h"
+#include "../common/constants.h"
+#include "../common/port.h"
+#include "../common/types.h"
 #include "./write_bits.h"
 
-namespace brotli {
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
 
 static const uint8_t kCodeLengthDepth[18] = {
   4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 0, 4, 4,
 };
 
-static const uint8_t kStaticCommandCodeDepth[kNumCommandPrefixes] = {
+static const uint8_t kStaticCommandCodeDepth[BROTLI_NUM_COMMAND_SYMBOLS] = {
    9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
    9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
    9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
@@ -77,11 +80,13 @@ static const uint32_t kCodeLengthBits[18] = {
   0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 15, 31, 0, 11, 7,
 };
 
-inline void StoreStaticCodeLengthCode(size_t* storage_ix, uint8_t* storage) {
-  WriteBits(40, MAKE_UINT64_T(0xff, 0x55555554), storage_ix, storage);
+static BROTLI_INLINE void StoreStaticCodeLengthCode(
+    size_t* storage_ix, uint8_t* storage) {
+  BrotliWriteBits(
+      40, MAKE_UINT64_T(0x0000ffU, 0x55555554U), storage_ix, storage);
 }
 
-static const uint64_t kZeroRepsBits[704] = {
+static const uint64_t kZeroRepsBits[BROTLI_NUM_COMMAND_SYMBOLS] = {
   0x00000000, 0x00000000, 0x00000000, 0x00000007, 0x00000017, 0x00000027,
   0x00000037, 0x00000047, 0x00000057, 0x00000067, 0x00000077, 0x00000770,
   0x00000b87, 0x00001387, 0x00001b87, 0x00002387, 0x00002b87, 0x00003387,
@@ -202,7 +207,7 @@ static const uint64_t kZeroRepsBits[704] = {
   0x06f9cb87, 0x08f9cb87,
 };
 
-static const uint32_t kZeroRepsDepth[704] = {
+static const uint32_t kZeroRepsDepth[BROTLI_NUM_COMMAND_SYMBOLS] = {
    0,  4,  8,  7,  7,  7,  7,  7,  7,  7,  7, 11, 14, 14, 14, 14,
   14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
   14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
@@ -249,7 +254,7 @@ static const uint32_t kZeroRepsDepth[704] = {
   28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
 };
 
-static const uint64_t kNonZeroRepsBits[704] = {
+static const uint64_t kNonZeroRepsBits[BROTLI_NUM_COMMAND_SYMBOLS] = {
   0x0000000b, 0x0000001b, 0x0000002b, 0x0000003b, 0x000002cb, 0x000006cb,
   0x00000acb, 0x00000ecb, 0x000002db, 0x000006db, 0x00000adb, 0x00000edb,
   0x000002eb, 0x000006eb, 0x00000aeb, 0x00000eeb, 0x000002fb, 0x000006fb,
@@ -370,7 +375,7 @@ static const uint64_t kNonZeroRepsBits[704] = {
   0x2baeb6db, 0x3baeb6db,
 };
 
-static const uint32_t kNonZeroRepsDepth[704] = {
+static const uint32_t kNonZeroRepsDepth[BROTLI_NUM_COMMAND_SYMBOLS] = {
    6,  6,  6,  6, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
   12, 12, 12, 12, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
   18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
@@ -417,47 +422,7 @@ static const uint32_t kNonZeroRepsDepth[704] = {
   30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
 };
 
-static const uint16_t kStaticLiteralCodeBits[256] = {
-    0,  128,   64,  192,   32,  160,   96,  224,
-   16,  144,   80,  208,   48,  176,  112,  240,
-    8,  136,   72,  200,   40,  168,  104,  232,
-   24,  152,   88,  216,   56,  184,  120,  248,
-    4,  132,   68,  196,   36,  164,  100,  228,
-   20,  148,   84,  212,   52,  180,  116,  244,
-   12,  140,   76,  204,   44,  172,  108,  236,
-   28,  156,   92,  220,   60,  188,  124,  252,
-    2,  130,   66,  194,   34,  162,   98,  226,
-   18,  146,   82,  210,   50,  178,  114,  242,
-   10,  138,   74,  202,   42,  170,  106,  234,
-   26,  154,   90,  218,   58,  186,  122,  250,
-    6,  134,   70,  198,   38,  166,  102,  230,
-   22,  150,   86,  214,   54,  182,  118,  246,
-   14,  142,   78,  206,   46,  174,  110,  238,
-   30,  158,   94,  222,   62,  190,  126,  254,
-    1,  129,   65,  193,   33,  161,   97,  225,
-   17,  145,   81,  209,   49,  177,  113,  241,
-    9,  137,   73,  201,   41,  169,  105,  233,
-   25,  153,   89,  217,   57,  185,  121,  249,
-    5,  133,   69,  197,   37,  165,  101,  229,
-   21,  149,   85,  213,   53,  181,  117,  245,
-   13,  141,   77,  205,   45,  173,  109,  237,
-   29,  157,   93,  221,   61,  189,  125,  253,
-    3,  131,   67,  195,   35,  163,   99,  227,
-   19,  147,   83,  211,   51,  179,  115,  243,
-   11,  139,   75,  203,   43,  171,  107,  235,
-   27,  155,   91,  219,   59,  187,  123,  251,
-    7,  135,   71,  199,   39,  167,  103,  231,
-   23,  151,   87,  215,   55,  183,  119,  247,
-   15,  143,   79,  207,   47,  175,  111,  239,
-   31,  159,   95,  223,   63,  191,  127,  255,
-};
-
-inline void StoreStaticLiteralHuffmanTree(size_t* storage_ix,
-                                          uint8_t* storage) {
-  WriteBits(32, 0x00010003U, storage_ix, storage);
-}
-
-static const uint16_t kStaticCommandCodeBits[kNumCommandPrefixes] = {
+static const uint16_t kStaticCommandCodeBits[BROTLI_NUM_COMMAND_SYMBOLS] = {
     0,  256,  128,  384,   64,  320,  192,  448,
    32,  288,  160,  416,   96,  352,  224,  480,
    16,  272,  144,  400,   80,  336,  208,  464,
@@ -548,10 +513,11 @@ static const uint16_t kStaticCommandCodeBits[kNumCommandPrefixes] = {
   255, 1279,  767, 1791,  511, 1535, 1023, 2047,
 };
 
-inline void StoreStaticCommandHuffmanTree(size_t* storage_ix,
-                                          uint8_t* storage) {
-  WriteBits(28, 0x0000000006307003U, storage_ix, storage);
-  WriteBits(31, 0x0000000009262441U, storage_ix, storage);
+static BROTLI_INLINE void StoreStaticCommandHuffmanTree(
+    size_t* storage_ix, uint8_t* storage) {
+  BrotliWriteBits(
+      56, MAKE_UINT64_T(0x926244U, 0x16307003U), storage_ix, storage);
+  BrotliWriteBits(3, 0x00000000U, storage_ix, storage);
 }
 
 static const uint16_t kStaticDistanceCodeBits[64] = {
@@ -561,12 +527,13 @@ static const uint16_t kStaticDistanceCodeBits[64] = {
    3, 35, 19, 51, 11, 43, 27, 59,  7, 39, 23, 55, 15, 47, 31, 63,
 };
 
-inline void StoreStaticDistanceHuffmanTree(size_t* storage_ix,
-                                           uint8_t* storage) {
-  WriteBits(18, 0x000000000001dc03U, storage_ix, storage);
-  WriteBits(10, 0x00000000000000daU, storage_ix, storage);
+static BROTLI_INLINE void StoreStaticDistanceHuffmanTree(
+    size_t* storage_ix, uint8_t* storage) {
+  BrotliWriteBits(28, 0x0369dc03U, storage_ix, storage);
 }
 
-}  // namespace brotli
+#if defined(__cplusplus) || defined(c_plusplus)
+}  /* extern "C" */
+#endif
 
-#endif  // BROTLI_ENC_ENTROPY_ENCODE_STATIC_H_
+#endif  /* BROTLI_ENC_ENTROPY_ENCODE_STATIC_H_ */

data/vendor/brotli/enc/fast_log.h

@@ -4,21 +4,23 @@
    See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
 */
 
-// Utilities for fast computation of logarithms.
+/* Utilities for fast computation of logarithms. */
 
 #ifndef BROTLI_ENC_FAST_LOG_H_
 #define BROTLI_ENC_FAST_LOG_H_
 
-#include <assert.h>
 #include <math.h>
 
-#include "./types.h"
+#include "../common/types.h"
+#include "../common/port.h"
 
-namespace brotli {
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
 
-static inline uint32_t Log2FloorNonZero(size_t n) {
+static BROTLI_INLINE uint32_t Log2FloorNonZero(size_t n) {
 #ifdef __GNUC__
-  return 31u ^ static_cast<uint32_t>(__builtin_clz(static_cast<uint32_t>(n)));
+  return 31u ^ (uint32_t)__builtin_clz((uint32_t)n);
 #else
   uint32_t result = 0;
   while (n >>= 1) result++;
@@ -26,10 +28,10 @@ static inline uint32_t Log2FloorNonZero(size_t n) {
 #endif
 }
 
-// A lookup table for small values of log2(int) to be used in entropy
-// computation.
-//
-// ", ".join(["%.16ff" % x for x in [0.0]+[log2(x) for x in range(1, 256)]])
+/* A lookup table for small values of log2(int) to be used in entropy
+   computation.
+
+   ", ".join(["%.16ff" % x for x in [0.0]+[log2(x) for x in range(1, 256)]]) */
 static const float kLog2Table[] = {
   0.0000000000000000f, 0.0000000000000000f, 1.0000000000000000f,
   1.5849625007211563f, 2.0000000000000000f, 2.3219280948873622f,
@@ -119,21 +121,25 @@ static const float kLog2Table[] = {
   7.9943534368588578f
 };
 
-// Faster logarithm for small integers, with the property of log2(0) == 0.
-static inline double FastLog2(size_t v) {
+#define LOG_2_INV 1.4426950408889634
+
+/* Faster logarithm for small integers, with the property of log2(0) == 0. */
+static BROTLI_INLINE double FastLog2(size_t v) {
   if (v < sizeof(kLog2Table) / sizeof(kLog2Table[0])) {
     return kLog2Table[v];
   }
-#if defined(_MSC_VER) && _MSC_VER <= 1700
-  // Visual Studio 2012 does not have the log2() function defined, so we use
-  // log() and a multiplication instead.
-  static const double kLog2Inv = 1.4426950408889634f;
-  return log(static_cast<double>(v)) * kLog2Inv;
+#if (defined(_MSC_VER) && _MSC_VER <= 1700) || \
+    (defined(__ANDROID_API__) && __ANDROID_API__ < 18)
+  /* Visual Studio 2012 and Android API levels < 18 do not have the log2()
+   * function defined, so we use log() and a multiplication instead. */
+  return log((double)v) * LOG_2_INV;
 #else
-  return log2(static_cast<double>(v));
+  return log2((double)v);
 #endif
 }
 
-}  // namespace brotli
+#if defined(__cplusplus) || defined(c_plusplus)
+}  /* extern "C" */
+#endif
 
-#endif  // BROTLI_ENC_FAST_LOG_H_
+#endif  /* BROTLI_ENC_FAST_LOG_H_ */

data/vendor/brotli/enc/find_match_length.h

@@ -4,25 +4,26 @@
    See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
 */
 
-// Function to find maximal matching prefixes of strings.
+/* Function to find maximal matching prefixes of strings. */
 
 #ifndef BROTLI_ENC_FIND_MATCH_LENGTH_H_
 #define BROTLI_ENC_FIND_MATCH_LENGTH_H_
 
-
+#include "../common/types.h"
 #include "./port.h"
-#include "./types.h"
 
-namespace brotli {
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
 
-// Separate implementation for little-endian 64-bit targets, for speed.
+/* Separate implementation for little-endian 64-bit targets, for speed. */
 #if defined(__GNUC__) && defined(_LP64) && defined(IS_LITTLE_ENDIAN)
 
-static inline size_t FindMatchLengthWithLimit(const uint8_t* s1,
-                                              const uint8_t* s2,
-                                              size_t limit) {
+static BROTLI_INLINE size_t FindMatchLengthWithLimit(const uint8_t* s1,
+                                                     const uint8_t* s2,
+                                                     size_t limit) {
   size_t matched = 0;
-  size_t limit2 = (limit >> 3) + 1;  // + 1 is for pre-decrement in while
+  size_t limit2 = (limit >> 3) + 1;  /* + 1 is for pre-decrement in while */
   while (PREDICT_TRUE(--limit2)) {
     if (PREDICT_FALSE(BROTLI_UNALIGNED_LOAD64(s2) ==
                       BROTLI_UNALIGNED_LOAD64(s1 + matched))) {
@@ -31,12 +32,12 @@ static inline size_t FindMatchLengthWithLimit(const uint8_t* s1,
     } else {
       uint64_t x =
           BROTLI_UNALIGNED_LOAD64(s2) ^ BROTLI_UNALIGNED_LOAD64(s1 + matched);
-      size_t matching_bits = static_cast<size_t>(__builtin_ctzll(x));
+      size_t matching_bits = (size_t)__builtin_ctzll(x);
       matched += matching_bits >> 3;
       return matched;
     }
   }
-  limit = (limit & 7) + 1;  // + 1 is for pre-decrement in while
+  limit = (limit & 7) + 1;  /* + 1 is for pre-decrement in while */
   while (--limit) {
     if (PREDICT_TRUE(s1[matched] == *s2)) {
       ++s2;
@@ -48,16 +49,16 @@ static inline size_t FindMatchLengthWithLimit(const uint8_t* s1,
   return matched;
 }
 #else
-static inline size_t FindMatchLengthWithLimit(const uint8_t* s1,
-                                             const uint8_t* s2,
-                                             size_t limit) {
+static BROTLI_INLINE size_t FindMatchLengthWithLimit(const uint8_t* s1,
+                                                     const uint8_t* s2,
+                                                     size_t limit) {
   size_t matched = 0;
   const uint8_t* s2_limit = s2 + limit;
   const uint8_t* s2_ptr = s2;
-  // Find out how long the match is. We loop over the data 32 bits at a
-  // time until we find a 32-bit block that doesn't match; then we find
-  // the first non-matching bit and use that to calculate the total
-  // length of the match.
+  /* Find out how long the match is. We loop over the data 32 bits at a
+     time until we find a 32-bit block that doesn't match; then we find
+     the first non-matching bit and use that to calculate the total
+     length of the match. */
   while (s2_ptr <= s2_limit - 4 &&
          BROTLI_UNALIGNED_LOAD32(s2_ptr) ==
          BROTLI_UNALIGNED_LOAD32(s1 + matched)) {
@@ -72,6 +73,8 @@ static inline size_t FindMatchLengthWithLimit(const uint8_t* s1,
 }
 #endif
 
-}  // namespace brotli
+#if defined(__cplusplus) || defined(c_plusplus)
+}  /* extern "C" */
+#endif
 
-#endif  // BROTLI_ENC_FIND_MATCH_LENGTH_H_
+#endif  /* BROTLI_ENC_FIND_MATCH_LENGTH_H_ */