brotli 0.1.1 → 0.1.2

data/vendor/brotli/enc/metablock.cc

@@ -23,7 +23,7 @@ void BuildMetaBlock(const uint8_t* ringbuffer,
                     uint8_t prev_byte2,
                     const Command* cmds,
                     size_t num_commands,
-                    int literal_context_mode,
+                    ContextType literal_context_mode,
                     MetaBlockSplit* mb) {
   SplitBlock(cmds, num_commands,
              ringbuffer, pos, mask,
@@ -31,12 +31,12 @@ void BuildMetaBlock(const uint8_t* ringbuffer,
              &mb->command_split,
              &mb->distance_split);
 
-  std::vector<int> literal_context_modes(mb->literal_split.num_types,
-                                         literal_context_mode);
+  std::vector<ContextType> literal_context_modes(mb->literal_split.num_types,
+                                                 literal_context_mode);
 
-  int num_literal_contexts =
+  size_t num_literal_contexts =
       mb->literal_split.num_types << kLiteralContextBits;
-  int num_distance_contexts =
+  size_t num_distance_contexts =
       mb->distance_split.num_types << kDistanceContextBits;
   std::vector<HistogramLiteral> literal_histograms(num_literal_contexts);
   mb->command_histograms.resize(mb->command_split.num_types);
@@ -58,17 +58,15 @@ void BuildMetaBlock(const uint8_t* ringbuffer,
   // Histogram ids need to fit in one byte.
   static const size_t kMaxNumberOfHistograms = 256;
 
-  mb->literal_histograms = literal_histograms;
   ClusterHistograms(literal_histograms,
-                    1 << kLiteralContextBits,
+                    1u << kLiteralContextBits,
                     mb->literal_split.num_types,
                     kMaxNumberOfHistograms,
                     &mb->literal_histograms,
                     &mb->literal_context_map);
 
-  mb->distance_histograms = distance_histograms;
   ClusterHistograms(distance_histograms,
-                    1 << kDistanceContextBits,
+                    1u << kDistanceContextBits,
                     mb->distance_split.num_types,
                     kMaxNumberOfHistograms,
                     &mb->distance_histograms,
@@ -79,10 +77,10 @@ void BuildMetaBlock(const uint8_t* ringbuffer,
 template<typename HistogramType>
 class BlockSplitter {
  public:
-  BlockSplitter(int alphabet_size,
-                int min_block_size,
+  BlockSplitter(size_t alphabet_size,
+                size_t min_block_size,
                 double split_threshold,
-                int num_symbols,
+                size_t num_symbols,
                 BlockSplit* split,
                 std::vector<HistogramType>* histograms)
       : alphabet_size_(alphabet_size),
@@ -95,10 +93,10 @@ class BlockSplitter {
         block_size_(0),
         curr_histogram_ix_(0),
         merge_last_count_(0) {
-    int max_num_blocks = num_symbols / min_block_size + 1;
+    size_t max_num_blocks = num_symbols / min_block_size + 1;
     // We have to allocate one more histogram than the maximum number of block
     // types for the current histogram when the meta-block is too big.
-    int max_num_types = std::min(max_num_blocks, kMaxBlockTypes + 1);
+    size_t max_num_types = std::min<size_t>(max_num_blocks, kMaxBlockTypes + 1);
     split_->lengths.resize(max_num_blocks);
     split_->types.resize(max_num_blocks);
     histograms_->resize(max_num_types);
@@ -107,7 +105,7 @@ class BlockSplitter {
 
   // Adds the next symbol to the current histogram. When the current histogram
   // reaches the target size, decides on merging the block.
-  void AddSymbol(int symbol) {
+  void AddSymbol(size_t symbol) {
     (*histograms_)[curr_histogram_ix_].Add(symbol);
     ++block_size_;
     if (block_size_ == target_block_size_) {
@@ -125,7 +123,7 @@ class BlockSplitter {
     }
     if (num_blocks_ == 0) {
       // Create first block.
-      split_->lengths[0] = block_size_;
+      split_->lengths[0] = static_cast<uint32_t>(block_size_);
       split_->types[0] = 0;
       last_entropy_[0] =
           BitsEntropy(&(*histograms_)[0].data_[0], alphabet_size_);
@@ -140,8 +138,8 @@ class BlockSplitter {
       HistogramType combined_histo[2];
       double combined_entropy[2];
       double diff[2];
-      for (int j = 0; j < 2; ++j) {
-        int last_histogram_ix = last_histogram_ix_[j];
+      for (size_t j = 0; j < 2; ++j) {
+        size_t last_histogram_ix = last_histogram_ix_[j];
         combined_histo[j] = (*histograms_)[curr_histogram_ix_];
         combined_histo[j].AddHistogram((*histograms_)[last_histogram_ix]);
         combined_entropy[j] = BitsEntropy(
@@ -153,10 +151,10 @@ class BlockSplitter {
           diff[0] > split_threshold_ &&
           diff[1] > split_threshold_) {
         // Create new block.
-        split_->lengths[num_blocks_] = block_size_;
-        split_->types[num_blocks_] = split_->num_types;
+        split_->lengths[num_blocks_] = static_cast<uint32_t>(block_size_);
+        split_->types[num_blocks_] = static_cast<uint8_t>(split_->num_types);
         last_histogram_ix_[1] = last_histogram_ix_[0];
-        last_histogram_ix_[0] = split_->num_types;
+        last_histogram_ix_[0] = static_cast<uint8_t>(split_->num_types);
         last_entropy_[1] = last_entropy_[0];
         last_entropy_[0] = entropy;
         ++num_blocks_;
@@ -167,7 +165,7 @@ class BlockSplitter {
         target_block_size_ = min_block_size_;
       } else if (diff[1] < diff[0] - 20.0) {
         // Combine this block with second last block.
-        split_->lengths[num_blocks_] = block_size_;
+        split_->lengths[num_blocks_] = static_cast<uint32_t>(block_size_);
         split_->types[num_blocks_] = split_->types[num_blocks_ - 2];
         std::swap(last_histogram_ix_[0], last_histogram_ix_[1]);
         (*histograms_)[last_histogram_ix_[0]] = combined_histo[1];
@@ -180,7 +178,7 @@ class BlockSplitter {
         target_block_size_ = min_block_size_;
       } else {
         // Combine this block with last block.
-        split_->lengths[num_blocks_ - 1] += block_size_;
+        split_->lengths[num_blocks_ - 1] += static_cast<uint32_t>(block_size_);
         (*histograms_)[last_histogram_ix_[0]] = combined_histo[0];
         last_entropy_[0] = combined_entropy[0];
         if (split_->num_types == 1) {
@@ -201,35 +199,35 @@ class BlockSplitter {
   }
 
  private:
-  static const int kMaxBlockTypes = 256;
+  static const uint16_t kMaxBlockTypes = 256;
 
   // Alphabet size of particular block category.
-  const int alphabet_size_;
+  const size_t alphabet_size_;
   // We collect at least this many symbols for each block.
-  const int min_block_size_;
+  const size_t min_block_size_;
   // We merge histograms A and B if
   //   entropy(A+B) < entropy(A) + entropy(B) + split_threshold_,
   // where A is the current histogram and B is the histogram of the last or the
   // second last block type.
   const double split_threshold_;
 
-  int num_blocks_;
+  size_t num_blocks_;
   BlockSplit* split_;  // not owned
   std::vector<HistogramType>* histograms_;  // not owned
 
   // The number of symbols that we want to collect before deciding on whether
   // or not to merge the block with a previous one or emit a new block.
-  int target_block_size_;
+  size_t target_block_size_;
   // The number of symbols in the current histogram.
-  int block_size_;
+  size_t block_size_;
   // Offset of the current histogram.
-  int curr_histogram_ix_;
+  size_t curr_histogram_ix_;
   // Offset of the histograms of the previous two block types.
-  int last_histogram_ix_[2];
+  size_t last_histogram_ix_[2];
   // Entropy of the previous two block types.
   double last_entropy_[2];
   // The number of times we merged the current block with the last one.
-  int merge_last_count_;
+  size_t merge_last_count_;
 };
 
 void BuildMetaBlockGreedy(const uint8_t* ringbuffer,
@@ -238,7 +236,7 @@ void BuildMetaBlockGreedy(const uint8_t* ringbuffer,
                           const Command *commands,
                           size_t n_commands,
                           MetaBlockSplit* mb) {
-  int num_literals = 0;
+  size_t num_literals = 0;
   for (size_t i = 0; i < n_commands; ++i) {
     num_literals += commands[i].insert_len_;
   }
@@ -247,21 +245,21 @@ void BuildMetaBlockGreedy(const uint8_t* ringbuffer,
       256, 512, 400.0, num_literals,
       &mb->literal_split, &mb->literal_histograms);
   BlockSplitter<HistogramCommand> cmd_blocks(
-      kNumCommandPrefixes, 1024, 500.0, static_cast<int>(n_commands),
+      kNumCommandPrefixes, 1024, 500.0, n_commands,
       &mb->command_split, &mb->command_histograms);
   BlockSplitter<HistogramDistance> dist_blocks(
-      64, 512, 100.0, static_cast<int>(n_commands),
+      64, 512, 100.0, n_commands,
       &mb->distance_split, &mb->distance_histograms);
 
   for (size_t i = 0; i < n_commands; ++i) {
     const Command cmd = commands[i];
     cmd_blocks.AddSymbol(cmd.cmd_prefix_);
-    for (int j = 0; j < cmd.insert_len_; ++j) {
+    for (size_t j = cmd.insert_len_; j != 0; --j) {
       lit_blocks.AddSymbol(ringbuffer[pos & mask]);
       ++pos;
     }
-    pos += cmd.copy_len_;
-    if (cmd.copy_len_ > 0 && cmd.cmd_prefix_ >= 128) {
+    pos += cmd.copy_len();
+    if (cmd.copy_len() && cmd.cmd_prefix_ >= 128) {
       dist_blocks.AddSymbol(cmd.dist_prefix_);
     }
   }
@@ -276,11 +274,11 @@ void BuildMetaBlockGreedy(const uint8_t* ringbuffer,
 template<typename HistogramType>
 class ContextBlockSplitter {
  public:
-  ContextBlockSplitter(int alphabet_size,
-                       int num_contexts,
-                       int min_block_size,
+  ContextBlockSplitter(size_t alphabet_size,
+                       size_t num_contexts,
+                       size_t min_block_size,
                        double split_threshold,
-                       int num_symbols,
+                       size_t num_symbols,
                        BlockSplit* split,
                        std::vector<HistogramType>* histograms)
       : alphabet_size_(alphabet_size),
@@ -296,10 +294,10 @@ class ContextBlockSplitter {
         curr_histogram_ix_(0),
         last_entropy_(2 * num_contexts),
         merge_last_count_(0) {
-    int max_num_blocks = num_symbols / min_block_size + 1;
+    size_t max_num_blocks = num_symbols / min_block_size + 1;
     // We have to allocate one more histogram than the maximum number of block
     // types for the current histogram when the meta-block is too big.
-    int max_num_types = std::min(max_num_blocks, max_block_types_ + 1);
+    size_t max_num_types = std::min(max_num_blocks, max_block_types_ + 1);
     split_->lengths.resize(max_num_blocks);
     split_->types.resize(max_num_blocks);
     histograms_->resize(max_num_types * num_contexts);
@@ -308,7 +306,7 @@ class ContextBlockSplitter {
 
   // Adds the next symbol to the current block type and context. When the
   // current block reaches the target size, decides on merging the block.
-  void AddSymbol(int symbol, int context) {
+  void AddSymbol(size_t symbol, size_t context) {
     (*histograms_)[curr_histogram_ix_ + context].Add(symbol);
     ++block_size_;
     if (block_size_ == target_block_size_) {
@@ -326,9 +324,9 @@ class ContextBlockSplitter {
     }
     if (num_blocks_ == 0) {
       // Create first block.
-      split_->lengths[0] = block_size_;
+      split_->lengths[0] = static_cast<uint32_t>(block_size_);
       split_->types[0] = 0;
-      for (int i = 0; i < num_contexts_; ++i) {
+      for (size_t i = 0; i < num_contexts_; ++i) {
         last_entropy_[i] =
             BitsEntropy(&(*histograms_)[i].data_[0], alphabet_size_);
         last_entropy_[num_contexts_ + i] = last_entropy_[i];
@@ -346,13 +344,13 @@ class ContextBlockSplitter {
       std::vector<HistogramType> combined_histo(2 * num_contexts_);
       std::vector<double> combined_entropy(2 * num_contexts_);
       double diff[2] = { 0.0 };
-      for (int i = 0; i < num_contexts_; ++i) {
-        int curr_histo_ix = curr_histogram_ix_ + i;
+      for (size_t i = 0; i < num_contexts_; ++i) {
+        size_t curr_histo_ix = curr_histogram_ix_ + i;
         entropy[i] = BitsEntropy(&(*histograms_)[curr_histo_ix].data_[0],
                                  alphabet_size_);
-        for (int j = 0; j < 2; ++j) {
-          int jx = j * num_contexts_ + i;
-          int last_histogram_ix = last_histogram_ix_[j] + i;
+        for (size_t j = 0; j < 2; ++j) {
+          size_t jx = j * num_contexts_ + i;
+          size_t last_histogram_ix = last_histogram_ix_[j] + i;
           combined_histo[jx] = (*histograms_)[curr_histo_ix];
           combined_histo[jx].AddHistogram((*histograms_)[last_histogram_ix]);
           combined_entropy[jx] = BitsEntropy(
@@ -365,11 +363,11 @@ class ContextBlockSplitter {
           diff[0] > split_threshold_ &&
           diff[1] > split_threshold_) {
         // Create new block.
-        split_->lengths[num_blocks_] = block_size_;
-        split_->types[num_blocks_] = split_->num_types;
+        split_->lengths[num_blocks_] = static_cast<uint32_t>(block_size_);
+        split_->types[num_blocks_] = static_cast<uint8_t>(split_->num_types);
         last_histogram_ix_[1] = last_histogram_ix_[0];
         last_histogram_ix_[0] = split_->num_types * num_contexts_;
-        for (int i = 0; i < num_contexts_; ++i) {
+        for (size_t i = 0; i < num_contexts_; ++i) {
           last_entropy_[num_contexts_ + i] = last_entropy_[i];
           last_entropy_[i] = entropy[i];
         }
@@ -381,10 +379,10 @@ class ContextBlockSplitter {
         target_block_size_ = min_block_size_;
       } else if (diff[1] < diff[0] - 20.0) {
         // Combine this block with second last block.
-        split_->lengths[num_blocks_] = block_size_;
+        split_->lengths[num_blocks_] = static_cast<uint32_t>(block_size_);
         split_->types[num_blocks_] = split_->types[num_blocks_ - 2];
         std::swap(last_histogram_ix_[0], last_histogram_ix_[1]);
-        for (int i = 0; i < num_contexts_; ++i) {
+        for (size_t i = 0; i < num_contexts_; ++i) {
           (*histograms_)[last_histogram_ix_[0] + i] =
               combined_histo[num_contexts_ + i];
           last_entropy_[num_contexts_ + i] = last_entropy_[i];
@@ -397,8 +395,8 @@ class ContextBlockSplitter {
         target_block_size_ = min_block_size_;
       } else {
         // Combine this block with last block.
-        split_->lengths[num_blocks_ - 1] += block_size_;
-        for (int i = 0; i < num_contexts_; ++i) {
+        split_->lengths[num_blocks_ - 1] += static_cast<uint32_t>(block_size_);
+        for (size_t i = 0; i < num_contexts_; ++i) {
           (*histograms_)[last_histogram_ix_[0] + i] = combined_histo[i];
           last_entropy_[i] = combined_entropy[i];
           if (split_->num_types == 1) {
@@ -423,34 +421,34 @@ class ContextBlockSplitter {
   static const int kMaxBlockTypes = 256;
 
   // Alphabet size of particular block category.
-  const int alphabet_size_;
-  const int num_contexts_;
-  const int max_block_types_;
+  const size_t alphabet_size_;
+  const size_t num_contexts_;
+  const size_t max_block_types_;
   // We collect at least this many symbols for each block.
-  const int min_block_size_;
+  const size_t min_block_size_;
   // We merge histograms A and B if
   //   entropy(A+B) < entropy(A) + entropy(B) + split_threshold_,
   // where A is the current histogram and B is the histogram of the last or the
   // second last block type.
   const double split_threshold_;
 
-  int num_blocks_;
+  size_t num_blocks_;
   BlockSplit* split_;  // not owned
   std::vector<HistogramType>* histograms_;  // not owned
 
   // The number of symbols that we want to collect before deciding on whether
   // or not to merge the block with a previous one or emit a new block.
-  int target_block_size_;
+  size_t target_block_size_;
   // The number of symbols in the current histogram.
-  int block_size_;
+  size_t block_size_;
   // Offset of the current histogram.
-  int curr_histogram_ix_;
+  size_t curr_histogram_ix_;
   // Offset of the histograms of the previous two block types.
-  int last_histogram_ix_[2];
+  size_t last_histogram_ix_[2];
   // Entropy of the previous two block types.
   std::vector<double> last_entropy_;
   // The number of times we merged the current block with the last one.
-  int merge_last_count_;
+  size_t merge_last_count_;
 };
 
 void BuildMetaBlockGreedyWithContexts(const uint8_t* ringbuffer,
@@ -458,13 +456,13 @@ void BuildMetaBlockGreedyWithContexts(const uint8_t* ringbuffer,
                                       size_t mask,
                                       uint8_t prev_byte,
                                       uint8_t prev_byte2,
-                                      int literal_context_mode,
-                                      int num_contexts,
-                                      const int* static_context_map,
+                                      ContextType literal_context_mode,
+                                      size_t num_contexts,
+                                      const uint32_t* static_context_map,
                                       const Command *commands,
                                       size_t n_commands,
                                       MetaBlockSplit* mb) {
-  int num_literals = 0;
+  size_t num_literals = 0;
   for (size_t i = 0; i < n_commands; ++i) {
     num_literals += commands[i].insert_len_;
   }
@@ -473,25 +471,25 @@ void BuildMetaBlockGreedyWithContexts(const uint8_t* ringbuffer,
       256, num_contexts, 512, 400.0, num_literals,
       &mb->literal_split, &mb->literal_histograms);
   BlockSplitter<HistogramCommand> cmd_blocks(
-      kNumCommandPrefixes, 1024, 500.0, static_cast<int>(n_commands),
+      kNumCommandPrefixes, 1024, 500.0, n_commands,
       &mb->command_split, &mb->command_histograms);
   BlockSplitter<HistogramDistance> dist_blocks(
-      64, 512, 100.0, static_cast<int>(n_commands),
+      64, 512, 100.0, n_commands,
       &mb->distance_split, &mb->distance_histograms);
 
   for (size_t i = 0; i < n_commands; ++i) {
     const Command cmd = commands[i];
     cmd_blocks.AddSymbol(cmd.cmd_prefix_);
-    for (int j = 0; j < cmd.insert_len_; ++j) {
-      int context = Context(prev_byte, prev_byte2, literal_context_mode);
+    for (size_t j = cmd.insert_len_; j != 0; --j) {
+      size_t context = Context(prev_byte, prev_byte2, literal_context_mode);
       uint8_t literal = ringbuffer[pos & mask];
       lit_blocks.AddSymbol(literal, static_context_map[context]);
       prev_byte2 = prev_byte;
       prev_byte = literal;
       ++pos;
     }
-    pos += cmd.copy_len_;
-    if (cmd.copy_len_ > 0) {
+    pos += cmd.copy_len();
+    if (cmd.copy_len()) {
       prev_byte2 = ringbuffer[(pos - 2) & mask];
       prev_byte = ringbuffer[(pos - 1) & mask];
       if (cmd.cmd_prefix_ >= 128) {
@@ -506,31 +504,36 @@ void BuildMetaBlockGreedyWithContexts(const uint8_t* ringbuffer,
 
   mb->literal_context_map.resize(
       mb->literal_split.num_types << kLiteralContextBits);
-  for (int i = 0; i < mb->literal_split.num_types; ++i) {
-    for (int j = 0; j < (1 << kLiteralContextBits); ++j) {
+  for (size_t i = 0; i < mb->literal_split.num_types; ++i) {
+    for (size_t j = 0; j < (1u << kLiteralContextBits); ++j) {
       mb->literal_context_map[(i << kLiteralContextBits) + j] =
-          i * num_contexts + static_context_map[j];
+          static_cast<uint32_t>(i * num_contexts) + static_context_map[j];
     }
   }
 }
 
-void OptimizeHistograms(int num_direct_distance_codes,
-                        int distance_postfix_bits,
+void OptimizeHistograms(size_t num_direct_distance_codes,
+                        size_t distance_postfix_bits,
                         MetaBlockSplit* mb) {
+  uint8_t* good_for_rle = new uint8_t[kNumCommandPrefixes];
   for (size_t i = 0; i < mb->literal_histograms.size(); ++i) {
-    OptimizeHuffmanCountsForRle(256, &mb->literal_histograms[i].data_[0]);
+    OptimizeHuffmanCountsForRle(256, &mb->literal_histograms[i].data_[0],
+                                good_for_rle);
   }
   for (size_t i = 0; i < mb->command_histograms.size(); ++i) {
     OptimizeHuffmanCountsForRle(kNumCommandPrefixes,
-                                &mb->command_histograms[i].data_[0]);
+                                &mb->command_histograms[i].data_[0],
+                                good_for_rle);
   }
-  int num_distance_codes =
+  size_t num_distance_codes =
       kNumDistanceShortCodes + num_direct_distance_codes +
-      (48 << distance_postfix_bits);
+      (48u << distance_postfix_bits);
   for (size_t i = 0; i < mb->distance_histograms.size(); ++i) {
     OptimizeHuffmanCountsForRle(num_distance_codes,
-                                &mb->distance_histograms[i].data_[0]);
+                                &mb->distance_histograms[i].data_[0],
+                                good_for_rle);
   }
+  delete[] good_for_rle;
 }
 
 }  // namespace brotli

data/vendor/brotli/enc/metablock.h

@@ -18,19 +18,19 @@
 namespace brotli {
 
 struct BlockSplit {
-  BlockSplit() : num_types(0) {}
+  BlockSplit(void) : num_types(0) {}
 
-  int num_types;
-  std::vector<int> types;
-  std::vector<int> lengths;
+  size_t num_types;
+  std::vector<uint8_t> types;
+  std::vector<uint32_t> lengths;
 };
 
 struct MetaBlockSplit {
   BlockSplit literal_split;
   BlockSplit command_split;
   BlockSplit distance_split;
-  std::vector<int> literal_context_map;
-  std::vector<int> distance_context_map;
+  std::vector<uint32_t> literal_context_map;
+  std::vector<uint32_t> distance_context_map;
   std::vector<HistogramLiteral> literal_histograms;
   std::vector<HistogramCommand> command_histograms;
   std::vector<HistogramDistance> distance_histograms;
@@ -44,7 +44,7 @@ void BuildMetaBlock(const uint8_t* ringbuffer,
                     uint8_t prev_byte2,
                     const Command* cmds,
                     size_t num_commands,
-                    int literal_context_mode,
+                    ContextType literal_context_mode,
                     MetaBlockSplit* mb);
 
 // Uses a fast greedy block splitter that tries to merge current block with the
@@ -64,15 +64,15 @@ void BuildMetaBlockGreedyWithContexts(const uint8_t* ringbuffer,
                                       size_t mask,
                                       uint8_t prev_byte,
                                       uint8_t prev_byte2,
-                                      int literal_context_mode,
-                                      int num_contexts,
-                                      const int* static_context_map,
+                                      ContextType literal_context_mode,
+                                      size_t num_contexts,
+                                      const uint32_t* static_context_map,
                                       const Command *commands,
                                       size_t n_commands,
                                       MetaBlockSplit* mb);
 
-void OptimizeHistograms(int num_direct_distance_codes,
-                        int distance_postfix_bits,
+void OptimizeHistograms(size_t num_direct_distance_codes,
+                        size_t distance_postfix_bits,
                         MetaBlockSplit* mb);
 
 }  // namespace brotli

data/vendor/brotli/enc/port.h

@@ -22,10 +22,9 @@
 /* Let's try and follow the Linux convention */
 #define __BYTE_ORDER  BYTE_ORDER
 #define __LITTLE_ENDIAN LITTLE_ENDIAN
-#define __BIG_ENDIAN BIG_ENDIAN
 #endif
 
-// define the macros IS_LITTLE_ENDIAN or IS_BIG_ENDIAN
+// define the macro IS_LITTLE_ENDIAN
 // using the above endian definitions from endian.h if
 // endian.h was included
 #ifdef __BYTE_ORDER
@@ -33,19 +32,17 @@
 #define IS_LITTLE_ENDIAN
 #endif
 
-#if __BYTE_ORDER == __BIG_ENDIAN
-#define IS_BIG_ENDIAN
-#endif
-
 #else
 
 #if defined(__LITTLE_ENDIAN__)
 #define IS_LITTLE_ENDIAN
-#elif defined(__BIG_ENDIAN__)
-#define IS_BIG_ENDIAN
 #endif
 #endif  // __BYTE_ORDER
 
+#if defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
+#define IS_LITTLE_ENDIAN
+#endif
+
 // Enable little-endian optimization for x64 architecture on Windows.
 #if (defined(_WIN32) || defined(_WIN64)) && defined(_M_X64)
 #define IS_LITTLE_ENDIAN
@@ -69,8 +66,8 @@
 // On some platforms, like ARM, the copy functions can be more efficient
 // then a load and a store.
 
-#if defined(ARCH_PIII) || defined(ARCH_ATHLON) || \
-  defined(ARCH_K8) || defined(_ARCH_PPC)
+#if defined(ARCH_PIII) || \
+  defined(ARCH_ATHLON) || defined(ARCH_K8) || defined(_ARCH_PPC)
 
 // x86 and x86-64 can perform unaligned loads/stores directly;
 // modern PowerPC hardware can also do unaligned integer loads and stores;
@@ -142,10 +139,4 @@ inline void BROTLI_UNALIGNED_STORE64(void *p, uint64_t v) {
 
 #endif
 
-#ifdef BROTLI_ENCODE_DEBUG
-#define BROTLI_DCHECK(x) assert(x)
-#else
-#define BROTLI_DCHECK(x)
-#endif
-
 #endif  // BROTLI_ENC_PORT_H_

data/vendor/brotli/enc/prefix.h

@@ -15,18 +15,18 @@
 
 namespace brotli {
 
-static const int kNumInsertLenPrefixes = 24;
-static const int kNumCopyLenPrefixes = 24;
-static const int kNumCommandPrefixes = 704;
-static const int kNumBlockLenPrefixes = 26;
-static const int kNumDistanceShortCodes = 16;
-static const int kNumDistancePrefixes = 520;
+static const uint32_t kNumInsertLenPrefixes = 24;
+static const uint32_t kNumCopyLenPrefixes = 24;
+static const uint32_t kNumCommandPrefixes = 704;
+static const uint32_t kNumBlockLenPrefixes = 26;
+static const uint32_t kNumDistanceShortCodes = 16;
+static const uint32_t kNumDistancePrefixes = 520;
 
 // Represents the range of values belonging to a prefix code:
 // [offset, offset + 2^nbits)
 struct PrefixCodeRange {
-  int offset;
-  int nbits;
+  uint32_t offset;
+  uint32_t nbits;
 };
 
 static const PrefixCodeRange kBlockLengthPrefixCode[kNumBlockLenPrefixes] = {
@@ -39,8 +39,8 @@ static const PrefixCodeRange kBlockLengthPrefixCode[kNumBlockLenPrefixes] = {
   {8433, 13}, {16625, 24}
 };
 
-inline void GetBlockLengthPrefixCode(int len,
-                                     int* code, int* n_extra, int* extra) {
+inline void GetBlockLengthPrefixCode(uint32_t len, uint32_t* code,
+                                     uint32_t* n_extra, uint32_t* extra) {
   *code = 0;
   while (*code < 25 && len >= kBlockLengthPrefixCode[*code + 1].offset) {
     ++(*code);
@@ -49,9 +49,9 @@ inline void GetBlockLengthPrefixCode(int len,
   *extra = len - kBlockLengthPrefixCode[*code].offset;
 }
 
-inline void PrefixEncodeCopyDistance(int distance_code,
-                                     int num_direct_codes,
-                                     int postfix_bits,
+inline void PrefixEncodeCopyDistance(size_t distance_code,
+                                     size_t num_direct_codes,
+                                     size_t postfix_bits,
                                      uint16_t* code,
                                      uint32_t* extra_bits) {
   if (distance_code < kNumDistanceShortCodes + num_direct_codes) {
@@ -59,18 +59,19 @@ inline void PrefixEncodeCopyDistance(int distance_code,
     *extra_bits = 0;
     return;
   }
-  distance_code -= kNumDistanceShortCodes + num_direct_codes;
-  distance_code += (1 << (postfix_bits + 2));
-  int bucket = Log2Floor(distance_code) - 1;
-  int postfix_mask = (1 << postfix_bits) - 1;
-  int postfix = distance_code & postfix_mask;
-  int prefix = (distance_code >> bucket) & 1;
-  int offset = (2 + prefix) << bucket;
-  int nbits = bucket - postfix_bits;
+  distance_code -= kNumDistanceShortCodes + num_direct_codes;  /* >= 0 */
+  distance_code += (1u << (postfix_bits + 2u));  /* > 0 */
+  size_t bucket = Log2FloorNonZero(distance_code) - 1;
+  size_t postfix_mask = (1 << postfix_bits) - 1;
+  size_t postfix = distance_code & postfix_mask;
+  size_t prefix = (distance_code >> bucket) & 1;
+  size_t offset = (2 + prefix) << bucket;
+  size_t nbits = bucket - postfix_bits;
   *code = static_cast<uint16_t>(
       (kNumDistanceShortCodes + num_direct_codes +
        ((2 * (nbits - 1) + prefix) << postfix_bits) + postfix));
-  *extra_bits = (nbits << 24) | ((distance_code - offset) >> postfix_bits);
+  *extra_bits = static_cast<uint32_t>(
+      (nbits << 24) | ((distance_code - offset) >> postfix_bits));
 }
 
 }  // namespace brotli