brotli 0.1.1 → 0.1.2

data/vendor/brotli/enc/entropy_encode.cc

@@ -10,7 +10,6 @@
 
 #include <algorithm>
 #include <limits>
-#include <vector>
 #include <cstdlib>
 
 #include "./histogram.h"
@@ -19,24 +18,6 @@
 
 namespace brotli {
 
-namespace {
-
-struct HuffmanTree {
-  HuffmanTree(int count, int16_t left, int16_t right)
-      : total_count_(count),
-        index_left_(left),
-        index_right_or_value_(right) {
-  }
-  int total_count_;
-  int16_t index_left_;
-  int16_t index_right_or_value_;
-};
-
-// Sort the root nodes, least popular first.
-bool SortHuffmanTree(const HuffmanTree &v0, const HuffmanTree &v1) {
-  return v0.total_count_ < v1.total_count_;
-}
-
 void SetDepth(const HuffmanTree &p,
               HuffmanTree *pool,
               uint8_t *depth,
@@ -50,7 +31,14 @@ void SetDepth(const HuffmanTree &p,
   }
 }
 
-}  // namespace
+// Sort the root nodes, least popular first.
+static inline bool SortHuffmanTree(const HuffmanTree& v0,
+                                   const HuffmanTree& v1) {
+  if (v0.total_count_ != v1.total_count_) {
+    return v0.total_count_ < v1.total_count_;
+  }
+  return v0.index_right_or_value_ > v1.index_right_or_value_;
+}
 
 // This function will create a Huffman tree.
 //
@@ -67,32 +55,31 @@ void SetDepth(const HuffmanTree &p,
 // we are not planning to use this with extremely long blocks.
 //
 // See http://en.wikipedia.org/wiki/Huffman_coding
-void CreateHuffmanTree(const int *data,
-                       const int length,
+void CreateHuffmanTree(const uint32_t *data,
+                       const size_t length,
                        const int tree_limit,
+                       HuffmanTree* tree,
                        uint8_t *depth) {
   // For block sizes below 64 kB, we never need to do a second iteration
   // of this loop. Probably all of our block sizes will be smaller than
   // that, so this loop is mostly of academic interest. If we actually
   // would need this, we would be better off with the Katajainen algorithm.
-  for (int count_limit = 1; ; count_limit *= 2) {
-    std::vector<HuffmanTree> tree;
-    tree.reserve(2 * length + 1);
-
-    for (int i = length - 1; i >= 0; --i) {
+  for (uint32_t count_limit = 1; ; count_limit *= 2) {
+    size_t n = 0;
+    for (size_t i = length; i != 0;) {
+      --i;
       if (data[i]) {
-        const int count = std::max(data[i], count_limit);
-        tree.push_back(HuffmanTree(count, -1, static_cast<int16_t>(i)));
+        const uint32_t count = std::max(data[i], count_limit);
+        tree[n++] = HuffmanTree(count, -1, static_cast<int16_t>(i));
       }
     }
 
-    const int n = static_cast<int>(tree.size());
     if (n == 1) {
       depth[tree[0].index_right_or_value_] = 1;      // Only one element.
       break;
     }
 
-    std::stable_sort(tree.begin(), tree.end(), SortHuffmanTree);
+    std::sort(tree, tree + n, SortHuffmanTree);
 
     // The nodes are:
     // [0, n): the sorted leaf nodes that we start with.
@@ -101,14 +88,14 @@ void CreateHuffmanTree(const int *data,
     //              (n+1). These are naturally in ascending order.
     // [2n]: we add a sentinel at the end as well.
     // There will be (2n+1) elements at the end.
-    const HuffmanTree sentinel(std::numeric_limits<int>::max(), -1, -1);
-    tree.push_back(sentinel);
-    tree.push_back(sentinel);
-
-    int i = 0;      // Points to the next leaf node.
-    int j = n + 1;  // Points to the next non-leaf node.
-    for (int k = n - 1; k > 0; --k) {
-      int left, right;
+    const HuffmanTree sentinel(std::numeric_limits<uint32_t>::max(), -1, -1);
+    tree[n] = sentinel;
+    tree[n + 1] = sentinel;
+
+    size_t i = 0;      // Points to the next leaf node.
+    size_t j = n + 1;  // Points to the next non-leaf node.
+    for (size_t k = n - 1; k != 0; --k) {
+      size_t left, right;
       if (tree[i].total_count_ <= tree[j].total_count_) {
         left = i;
         ++i;
@@ -125,16 +112,15 @@ void CreateHuffmanTree(const int *data,
       }
 
       // The sentinel node becomes the parent node.
-      int j_end = static_cast<int>(tree.size()) - 1;
+      size_t j_end = 2 * n - k;
       tree[j_end].total_count_ =
           tree[left].total_count_ + tree[right].total_count_;
       tree[j_end].index_left_ = static_cast<int16_t>(left);
       tree[j_end].index_right_or_value_ = static_cast<int16_t>(right);
 
       // Add back the last sentinel node.
-      tree.push_back(sentinel);
+      tree[j_end + 1] = sentinel;
     }
-    BROTLI_DCHECK(tree.size() == 2 * n + 1);
     SetDepth(tree[2 * n - 1], &tree[0], depth, 0);
 
     // We need to pack the Huffman tree in tree_limit bits.
@@ -146,108 +132,123 @@ void CreateHuffmanTree(const int *data,
   }
 }
 
-void Reverse(std::vector<uint8_t>* v, int start, int end) {
+static void Reverse(uint8_t* v, size_t start, size_t end) {
   --end;
   while (start < end) {
-    uint8_t tmp = (*v)[start];
-    (*v)[start] = (*v)[end];
-    (*v)[end] = tmp;
+    uint8_t tmp = v[start];
+    v[start] = v[end];
+    v[end] = tmp;
     ++start;
     --end;
   }
 }
 
-void WriteHuffmanTreeRepetitions(
+static void WriteHuffmanTreeRepetitions(
     const uint8_t previous_value,
     const uint8_t value,
-    int repetitions,
-    std::vector<uint8_t> *tree,
-    std::vector<uint8_t> *extra_bits_data) {
+    size_t repetitions,
+    size_t* tree_size,
+    uint8_t* tree,
+    uint8_t* extra_bits_data) {
+  assert(repetitions > 0);
   if (previous_value != value) {
-    tree->push_back(value);
-    extra_bits_data->push_back(0);
+    tree[*tree_size] = value;
+    extra_bits_data[*tree_size] = 0;
+    ++(*tree_size);
     --repetitions;
   }
   if (repetitions == 7) {
-    tree->push_back(value);
-    extra_bits_data->push_back(0);
+    tree[*tree_size] = value;
+    extra_bits_data[*tree_size] = 0;
+    ++(*tree_size);
     --repetitions;
   }
   if (repetitions < 3) {
-    for (int i = 0; i < repetitions; ++i) {
-      tree->push_back(value);
-      extra_bits_data->push_back(0);
+    for (size_t i = 0; i < repetitions; ++i) {
+      tree[*tree_size] = value;
+      extra_bits_data[*tree_size] = 0;
+      ++(*tree_size);
     }
   } else {
     repetitions -= 3;
-    int start = static_cast<int>(tree->size());
-    while (repetitions >= 0) {
-      tree->push_back(16);
-      extra_bits_data->push_back(repetitions & 0x3);
+    size_t start = *tree_size;
+    while (true) {
+      tree[*tree_size] = 16;
+      extra_bits_data[*tree_size] = repetitions & 0x3;
+      ++(*tree_size);
       repetitions >>= 2;
+      if (repetitions == 0) {
+        break;
+      }
       --repetitions;
     }
-    Reverse(tree, start, static_cast<int>(tree->size()));
-    Reverse(extra_bits_data, start, static_cast<int>(tree->size()));
+    Reverse(tree, start, *tree_size);
+    Reverse(extra_bits_data, start, *tree_size);
   }
 }
 
-void WriteHuffmanTreeRepetitionsZeros(
-    int repetitions,
-    std::vector<uint8_t> *tree,
-    std::vector<uint8_t> *extra_bits_data) {
+static void WriteHuffmanTreeRepetitionsZeros(
+    size_t repetitions,
+    size_t* tree_size,
+    uint8_t* tree,
+    uint8_t* extra_bits_data) {
   if (repetitions == 11) {
-    tree->push_back(0);
-    extra_bits_data->push_back(0);
+    tree[*tree_size] = 0;
+    extra_bits_data[*tree_size] = 0;
+    ++(*tree_size);
     --repetitions;
   }
   if (repetitions < 3) {
-    for (int i = 0; i < repetitions; ++i) {
-      tree->push_back(0);
-      extra_bits_data->push_back(0);
+    for (size_t i = 0; i < repetitions; ++i) {
+      tree[*tree_size] = 0;
+      extra_bits_data[*tree_size] = 0;
+      ++(*tree_size);
     }
   } else {
     repetitions -= 3;
-    int start = static_cast<int>(tree->size());
-    while (repetitions >= 0) {
-      tree->push_back(17);
-      extra_bits_data->push_back(repetitions & 0x7);
+    size_t start = *tree_size;
+    while (true) {
+      tree[*tree_size] = 17;
+      extra_bits_data[*tree_size] = repetitions & 0x7;
+      ++(*tree_size);
       repetitions >>= 3;
+      if (repetitions == 0) {
+        break;
+      }
       --repetitions;
     }
-    Reverse(tree, start, static_cast<int>(tree->size()));
-    Reverse(extra_bits_data, start, static_cast<int>(tree->size()));
+    Reverse(tree, start, *tree_size);
+    Reverse(extra_bits_data, start, *tree_size);
   }
 }
 
-int OptimizeHuffmanCountsForRle(int length, int* counts) {
-  int nonzero_count = 0;
-  int stride;
-  int limit;
-  int sum;
-  uint8_t* good_for_rle;
+void OptimizeHuffmanCountsForRle(size_t length, uint32_t* counts,
+                                 uint8_t* good_for_rle) {
+  size_t nonzero_count = 0;
+  size_t stride;
+  size_t limit;
+  size_t sum;
+  const size_t streak_limit = 1240;
   // Let's make the Huffman code more compatible with rle encoding.
-  int i;
+  size_t i;
   for (i = 0; i < length; i++) {
     if (counts[i]) {
       ++nonzero_count;
     }
   }
   if (nonzero_count < 16) {
-    return 1;
+    return;
   }
-  for (; length >= 0; --length) {
-    if (length == 0) {
-      return 1;  // All zeros.
-    }
-    if (counts[length - 1] != 0) {
-      // Now counts[0..length - 1] does not have trailing zeros.
-      break;
-    }
+  while (length != 0 && counts[length - 1] == 0) {
+    --length;
+  }
+  if (length == 0) {
+    return;  // All zeros.
   }
+  // Now counts[0..length - 1] does not have trailing zeros.
   {
-    int nonzeros = 0;
-    int smallest_nonzero = 1 << 30;
+    size_t nonzeros = 0;
+    uint32_t smallest_nonzero = 1 << 30;
     for (i = 0; i < length; ++i) {
       if (counts[i] != 0) {
         ++nonzeros;
@@ -258,9 +259,9 @@ int OptimizeHuffmanCountsForRle(int length, int* counts) {
     }
     if (nonzeros < 5) {
       // Small histogram will model it well.
-      return 1;
+      return;
     }
-    int zeros = length - nonzeros;
+    size_t zeros = length - nonzeros;
     if (smallest_nonzero < 4) {
       if (zeros < 6) {
         for (i = 1; i < length - 1; ++i) {
@@ -271,54 +272,50 @@ int OptimizeHuffmanCountsForRle(int length, int* counts) {
       }
     }
     if (nonzeros < 28) {
-      return 1;
+      return;
     }
   }
   // 2) Let's mark all population counts that already can be encoded
   // with an rle code.
-  good_for_rle = (uint8_t*)calloc(length, 1);
-  if (good_for_rle == NULL) {
-    return 0;
-  }
+  memset(good_for_rle, 0, length);
   {
     // Let's not spoil any of the existing good rle codes.
     // Mark any seq of 0's that is longer as 5 as a good_for_rle.
     // Mark any seq of non-0's that is longer as 7 as a good_for_rle.
-    int symbol = counts[0];
-    int stride = 0;
-    for (i = 0; i < length + 1; ++i) {
+    uint32_t symbol = counts[0];
+    size_t step = 0;
+    for (i = 0; i <= length; ++i) {
       if (i == length || counts[i] != symbol) {
-        if ((symbol == 0 && stride >= 5) ||
-            (symbol != 0 && stride >= 7)) {
-          int k;
-          for (k = 0; k < stride; ++k) {
+        if ((symbol == 0 && step >= 5) ||
+            (symbol != 0 && step >= 7)) {
+          size_t k;
+          for (k = 0; k < step; ++k) {
             good_for_rle[i - k - 1] = 1;
           }
         }
-        stride = 1;
+        step = 1;
         if (i != length) {
           symbol = counts[i];
         }
       } else {
-        ++stride;
+        ++step;
       }
     }
   }
   // 3) Let's replace those population counts that lead to more rle codes.
   // Math here is in 24.8 fixed point representation.
-  const int streak_limit = 1240;
   stride = 0;
   limit = 256 * (counts[0] + counts[1] + counts[2]) / 3 + 420;
   sum = 0;
-  for (i = 0; i < length + 1; ++i) {
+  for (i = 0; i <= length; ++i) {
     if (i == length || good_for_rle[i] ||
         (i != 0 && good_for_rle[i - 1]) ||
-        abs(256 * counts[i] - limit) >= streak_limit) {
+        (256 * counts[i] - limit + streak_limit) >= 2 * streak_limit) {
       if (stride >= 4 || (stride >= 3 && sum == 0)) {
-        int k;
+        size_t k;
         // The stride must end, collapse what we have, if we have enough (4).
-        int count = (sum + stride / 2) / stride;
-        if (count < 1) {
+        size_t count = (sum + stride / 2) / stride;
+        if (count == 0) {
           count = 1;
         }
         if (sum == 0) {
@@ -328,7 +325,7 @@ int OptimizeHuffmanCountsForRle(int length, int* counts) {
         for (k = 0; k < stride; ++k) {
           // We don't want to change value at counts[i],
           // that is already belonging to the next stride. Thus - 1.
-          counts[i - k - 1] = count;
+          counts[i - k - 1] = static_cast<uint32_t>(count);
         }
       }
       stride = 0;
@@ -354,21 +351,19 @@ int OptimizeHuffmanCountsForRle(int length, int* counts) {
       }
     }
   }
-  free(good_for_rle);
-  return 1;
 }
 
-static void DecideOverRleUse(const uint8_t* depth, const int length,
+static void DecideOverRleUse(const uint8_t* depth, const size_t length,
                              bool *use_rle_for_non_zero,
                              bool *use_rle_for_zero) {
-  int total_reps_zero = 0;
-  int total_reps_non_zero = 0;
-  int count_reps_zero = 0;
-  int count_reps_non_zero = 0;
-  for (int i = 0; i < length;) {
-    const int value = depth[i];
-    int reps = 1;
-    for (int k = i + 1; k < length && depth[k] == value; ++k) {
+  size_t total_reps_zero = 0;
+  size_t total_reps_non_zero = 0;
+  size_t count_reps_zero = 1;
+  size_t count_reps_non_zero = 1;
+  for (size_t i = 0; i < length;) {
+    const uint8_t value = depth[i];
+    size_t reps = 1;
+    for (size_t k = i + 1; k < length && depth[k] == value; ++k) {
       ++reps;
     }
     if (reps >= 3 && value == 0) {
@@ -381,21 +376,20 @@ static void DecideOverRleUse(const uint8_t* depth, const int length,
     }
     i += reps;
   }
-  total_reps_non_zero -= count_reps_non_zero * 2;
-  total_reps_zero -= count_reps_zero * 2;
-  *use_rle_for_non_zero = total_reps_non_zero > 2;
-  *use_rle_for_zero = total_reps_zero > 2;
+  *use_rle_for_non_zero = total_reps_non_zero > count_reps_non_zero * 2;
+  *use_rle_for_zero = total_reps_zero > count_reps_zero * 2;
 }
 
 void WriteHuffmanTree(const uint8_t* depth,
-                      uint32_t length,
-                      std::vector<uint8_t> *tree,
-                      std::vector<uint8_t> *extra_bits_data) {
+                      size_t length,
+                      size_t* tree_size,
+                      uint8_t* tree,
+                      uint8_t* extra_bits_data) {
   uint8_t previous_value = 8;
 
   // Throw away trailing zeros.
-  uint32_t new_length = length;
-  for (uint32_t i = 0; i < length; ++i) {
+  size_t new_length = length;
+  for (size_t i = 0; i < length; ++i) {
     if (depth[length - i - 1] == 0) {
       --new_length;
     } else {
@@ -414,20 +408,21 @@ void WriteHuffmanTree(const uint8_t* depth,
   }
 
   // Actual rle coding.
-  for (uint32_t i = 0; i < new_length;) {
+  for (size_t i = 0; i < new_length;) {
     const uint8_t value = depth[i];
-    int reps = 1;
+    size_t reps = 1;
     if ((value != 0 && use_rle_for_non_zero) ||
         (value == 0 && use_rle_for_zero)) {
-      for (uint32_t k = i + 1; k < new_length && depth[k] == value; ++k) {
+      for (size_t k = i + 1; k < new_length && depth[k] == value; ++k) {
         ++reps;
       }
     }
     if (value == 0) {
-      WriteHuffmanTreeRepetitionsZeros(reps, tree, extra_bits_data);
+      WriteHuffmanTreeRepetitionsZeros(reps, tree_size, tree, extra_bits_data);
     } else {
       WriteHuffmanTreeRepetitions(previous_value,
-                                  value, reps, tree, extra_bits_data);
+                                  value, reps, tree_size,
+                                  tree, extra_bits_data);
       previous_value = value;
     }
     i += reps;
@@ -453,13 +448,15 @@ uint16_t ReverseBits(int num_bits, uint16_t bits) {
 
 }  // namespace
 
-void ConvertBitDepthsToSymbols(const uint8_t *depth, int len, uint16_t *bits) {
+void ConvertBitDepthsToSymbols(const uint8_t *depth,
+                               size_t len,
+                               uint16_t *bits) {
   // In Brotli, all bit depths are [1..15]
   // 0 bit depth means that the symbol does not exist.
   const int kMaxBits = 16;  // 0..15 are values for bits
   uint16_t bl_count[kMaxBits] = { 0 };
   {
-    for (int i = 0; i < len; ++i) {
+    for (size_t i = 0; i < len; ++i) {
       ++bl_count[depth[i]];
     }
     bl_count[0] = 0;
@@ -473,7 +470,7 @@ void ConvertBitDepthsToSymbols(const uint8_t *depth, int len, uint16_t *bits) {
       next_code[bits] = static_cast<uint16_t>(code);
     }
   }
-  for (int i = 0; i < len; ++i) {
+  for (size_t i = 0; i < len; ++i) {
     if (depth[i]) {
       bits[i] = ReverseBits(depth[i], next_code[depth[i]]++);
     }

data/vendor/brotli/enc/entropy_encode.h

@@ -10,13 +10,28 @@
 #define BROTLI_ENC_ENTROPY_ENCODE_H_
 
 #include <string.h>
-#include <vector>
 #include "./histogram.h"
 #include "./prefix.h"
 #include "./types.h"
 
 namespace brotli {
 
+// 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) {
+  }
+  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.
@@ -25,10 +40,14 @@ namespace brotli {
 // 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 int *data,
-                       const int length,
+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
@@ -37,18 +56,23 @@ void CreateHuffmanTree(const int *data,
 //
 // length contains the size of the histogram.
 // counts contains the population counts.
-int OptimizeHuffmanCountsForRle(int length, int* 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,
-                      uint32_t num,
-                      std::vector<uint8_t> *tree,
-                      std::vector<uint8_t> *extra_bits_data);
+                      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, int len, uint16_t *bits);
+void ConvertBitDepthsToSymbols(const uint8_t *depth,
+                               size_t len,
+                               uint16_t *bits);
 
 template<int kSize>
 struct EntropyCode {