brotli 0.1.0 → 0.1.1

data/vendor/brotli/enc/block_splitter.cc

@@ -1,21 +1,14 @@
-// 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.
-//
+/* Copyright 2013 Google Inc. All Rights Reserved.
+
+   Distributed under MIT license.
+   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+*/
+
 // Block split point selection utilities.
 
 #include "./block_splitter.h"
 
+#include <assert.h>
 #include <math.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -53,7 +46,7 @@ void CopyLiteralsToByteArray(const Command* cmds,
                              std::vector<uint8_t>* literals) {
   // Count how many we have.
   size_t total_length = 0;
-  for (int i = 0; i < num_commands; ++i) {
+  for (size_t i = 0; i < num_commands; ++i) {
     total_length += cmds[i].insert_len_;
   }
   if (total_length == 0) {
@@ -66,7 +59,7 @@ void CopyLiteralsToByteArray(const Command* cmds,
   // Loop again, and copy this time.
   size_t pos = 0;
   size_t from_pos = offset & mask;
-  for (int i = 0; i < num_commands && pos < total_length; ++i) {
+  for (size_t i = 0; i < num_commands && pos < total_length; ++i) {
     size_t insert_len = cmds[i].insert_len_;
     if (from_pos + insert_len > mask) {
       size_t head_size = mask + 1 - from_pos;
@@ -87,7 +80,7 @@ void CopyCommandsToByteArray(const Command* cmds,
                              const size_t num_commands,
                              std::vector<uint16_t>* insert_and_copy_codes,
                              std::vector<uint16_t>* distance_prefixes) {
-  for (int i = 0; i < num_commands; ++i) {
+  for (size_t i = 0; i < num_commands; ++i) {
     const Command& cmd = cmds[i];
     insert_and_copy_codes->push_back(cmd.cmd_prefix_);
     if (cmd.copy_len_ > 0 && cmd.cmd_prefix_ >= 128) {
@@ -110,14 +103,14 @@ void InitialEntropyCodes(const DataType* data, size_t length,
                          int max_histograms,
                          size_t stride,
                          std::vector<HistogramType>* vec) {
-  int total_histograms = length / literals_per_histogram + 1;
+  int total_histograms = static_cast<int>(length) / literals_per_histogram + 1;
   if (total_histograms > max_histograms) {
     total_histograms = max_histograms;
   }
   unsigned int seed = 7;
-  int block_length = length / total_histograms;
+  size_t block_length = length / total_histograms;
   for (int i = 0; i < total_histograms; ++i) {
-    int pos = length * i / total_histograms;
+    size_t pos = length * i / total_histograms;
     if (i != 0) {
       pos += MyRand(&seed) % block_length;
     }
@@ -150,19 +143,19 @@ template<typename HistogramType, typename DataType>
 void RefineEntropyCodes(const DataType* data, size_t length,
                         size_t stride,
                         std::vector<HistogramType>* vec) {
-  int iters =
+  size_t iters =
       kIterMulForRefining * length / stride + kMinItersForRefining;
   unsigned int seed = 7;
   iters = ((iters + vec->size() - 1) / vec->size()) * vec->size();
-  for (int iter = 0; iter < iters; ++iter) {
+  for (size_t iter = 0; iter < iters; ++iter) {
     HistogramType sample;
     RandomSample(&seed, data, length, stride, &sample);
-    int ix = iter % vec->size();
+    size_t ix = iter % vec->size();
     (*vec)[ix].AddHistogram(sample);
   }
 }
 
-inline static float BitCost(int count) {
+inline static double BitCost(int count) {
   return count == 0 ? -2 : FastLog2(count);
 }
 
@@ -172,12 +165,13 @@ void FindBlocks(const DataType* data, const size_t length,
                 const std::vector<Histogram<kSize> > &vec,
                 uint8_t *block_id) {
   if (vec.size() <= 1) {
-    for (int i = 0; i < length; ++i) {
+    for (size_t i = 0; i < length; ++i) {
       block_id[i] = 0;
     }
     return;
   }
-  int vecsize = vec.size();
+  int vecsize = static_cast<int>(vec.size());
+  assert(vecsize <= 256);
   double* insert_cost = new double[kSize * vecsize];
   memset(insert_cost, 0, sizeof(insert_cost[0]) * kSize * vecsize);
   for (int j = 0; j < vecsize; ++j) {
@@ -199,7 +193,7 @@ void FindBlocks(const DataType* data, const size_t length,
   // reaches block switch cost, it means that when we trace back from the last
   // position, we need to switch here.
   for (size_t byte_ix = 0; byte_ix < length; ++byte_ix) {
-    int ix = byte_ix * vecsize;
+    size_t ix = byte_ix * vecsize;
     int insert_cost_ix = data[byte_ix] * vecsize;
     double min_cost = 1e99;
     for (int k = 0; k < vecsize; ++k) {
@@ -207,7 +201,7 @@ void FindBlocks(const DataType* data, const size_t length,
       cost[k] += insert_cost[insert_cost_ix + k];
       if (cost[k] < min_cost) {
         min_cost = cost[k];
-        block_id[byte_ix] = k;
+        block_id[byte_ix] = static_cast<uint8_t>(k);
       }
     }
     double block_switch_cost = block_switch_bitcost;
@@ -224,9 +218,9 @@ void FindBlocks(const DataType* data, const size_t length,
     }
   }
   // Now trace back from the last position and switch at the marked places.
-  int byte_ix = length - 1;
-  int ix = byte_ix * vecsize;
-  int cur_id = block_id[byte_ix];
+  size_t byte_ix = length - 1;
+  size_t ix = byte_ix * vecsize;
+  uint8_t cur_id = block_id[byte_ix];
   while (byte_ix > 0) {
     --byte_ix;
     ix -= vecsize;
@@ -243,13 +237,13 @@ void FindBlocks(const DataType* data, const size_t length,
 int RemapBlockIds(uint8_t* block_ids, const size_t length) {
   std::map<uint8_t, uint8_t> new_id;
   int next_id = 0;
-  for (int i = 0; i < length; ++i) {
+  for (size_t i = 0; i < length; ++i) {
     if (new_id.find(block_ids[i]) == new_id.end()) {
-      new_id[block_ids[i]] = next_id;
+      new_id[block_ids[i]] = static_cast<uint8_t>(next_id);
       ++next_id;
     }
   }
-  for (int i = 0; i < length; ++i) {
+  for (size_t i = 0; i < length; ++i) {
     block_ids[i] = new_id[block_ids[i]];
   }
   return next_id;
@@ -260,9 +254,10 @@ void BuildBlockHistograms(const DataType* data, const size_t length,
                           uint8_t* block_ids,
                           std::vector<HistogramType>* histograms) {
   int num_types = RemapBlockIds(block_ids, length);
+  assert(num_types <= 256);
   histograms->clear();
   histograms->resize(num_types);
-  for (int i = 0; i < length; ++i) {
+  for (size_t i = 0; i < length; ++i) {
     (*histograms)[block_ids[i]].Add(data[i]);
   }
 }
@@ -274,7 +269,7 @@ void ClusterBlocks(const DataType* data, const size_t length,
   std::vector<int> block_index(length);
   int cur_idx = 0;
   HistogramType cur_histogram;
-  for (int i = 0; i < length; ++i) {
+  for (size_t i = 0; i < length; ++i) {
     bool block_boundary = (i + 1 == length || block_ids[i] != block_ids[i + 1]);
     block_index[i] = cur_idx;
     cur_histogram.Add(data[i]);
@@ -287,13 +282,13 @@ void ClusterBlocks(const DataType* data, const size_t length,
   std::vector<HistogramType> clustered_histograms;
   std::vector<int> histogram_symbols;
   // Block ids need to fit in one byte.
-  static const int kMaxNumberOfBlockTypes = 256;
-  ClusterHistograms(histograms, 1, histograms.size(),
+  static const size_t kMaxNumberOfBlockTypes = 256;
+  ClusterHistograms(histograms, 1, static_cast<int>(histograms.size()),
                     kMaxNumberOfBlockTypes,
                     &clustered_histograms,
                     &histogram_symbols);
-  for (int i = 0; i < length; ++i) {
-    block_ids[i] = histogram_symbols[block_index[i]];
+  for (size_t i = 0; i < length; ++i) {
+    block_ids[i] = static_cast<uint8_t>(histogram_symbols[block_index[i]]);
   }
 }
 
@@ -301,7 +296,7 @@ void BuildBlockSplit(const std::vector<uint8_t>& block_ids, BlockSplit* split) {
   int cur_id = block_ids[0];
   int cur_length = 1;
   split->num_types = -1;
-  for (int i = 1; i < block_ids.size(); ++i) {
+  for (size_t i = 1; i < block_ids.size(); ++i) {
     if (block_ids[i] != cur_id) {
       split->types.push_back(cur_id);
       split->lengths.push_back(cur_length);
@@ -330,29 +325,29 @@ void SplitByteVector(const std::vector<DataType>& data,
   } else if (data.size() < kMinLengthForBlockSplitting) {
     split->num_types = 1;
     split->types.push_back(0);
-    split->lengths.push_back(data.size());
+    split->lengths.push_back(static_cast<int>(data.size()));
     return;
   }
   std::vector<HistogramType> histograms;
   // Find good entropy codes.
-  InitialEntropyCodes(data.data(), data.size(),
+  InitialEntropyCodes(&data[0], data.size(),
                       literals_per_histogram,
                       max_histograms,
                       sampling_stride_length,
                       &histograms);
-  RefineEntropyCodes(data.data(), data.size(),
+  RefineEntropyCodes(&data[0], data.size(),
                      sampling_stride_length,
                      &histograms);
   // Find a good path through literals with the good entropy codes.
   std::vector<uint8_t> block_ids(data.size());
   for (int i = 0; i < 10; ++i) {
-    FindBlocks(data.data(), data.size(),
+    FindBlocks(&data[0], data.size(),
                block_switch_cost,
                histograms,
                &block_ids[0]);
-    BuildBlockHistograms(data.data(), data.size(), &block_ids[0], &histograms);
+    BuildBlockHistograms(&data[0], data.size(), &block_ids[0], &histograms);
   }
-  ClusterBlocks<HistogramType>(data.data(), data.size(), &block_ids[0]);
+  ClusterBlocks<HistogramType>(&data[0], data.size(), &block_ids[0]);
   BuildBlockSplit(block_ids, split);
 }
 
@@ -401,7 +396,7 @@ void SplitBlockByTotalLength(const Command* all_commands,
   int length_limit = input_size / num_blocks + 1;
   int total_length = 0;
   std::vector<Command> cur_block;
-  for (int i = 0; i < num_commands; ++i) {
+  for (size_t i = 0; i < num_commands; ++i) {
     const Command& cmd = all_commands[i];
     int cmd_length = cmd.insert_len_ + cmd.copy_len_;
     if (total_length > length_limit) {

data/vendor/brotli/enc/block_splitter.h

@@ -1,30 +1,21 @@
-// 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.
-//
+/* Copyright 2013 Google Inc. All Rights Reserved.
+
+   Distributed under MIT license.
+   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+*/
+
 // Block split point selection utilities.
 
 #ifndef BROTLI_ENC_BLOCK_SPLITTER_H_
 #define BROTLI_ENC_BLOCK_SPLITTER_H_
 
-#include <stddef.h>
-#include <stdint.h>
 #include <string.h>
 #include <vector>
 #include <utility>
 
 #include "./command.h"
 #include "./metablock.h"
+#include "./types.h"
 
 namespace brotli {
 

data/vendor/brotli/enc/brotli_bit_stream.cc

@@ -1,17 +1,9 @@
-// Copyright 2014 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.
-//
+/* Copyright 2014 Google Inc. All Rights Reserved.
+
+   Distributed under MIT license.
+   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+*/
+
 // Brotli bit stream functions to support the low level format. There are no
 // compression algorithms here, just the right ordering of bits to match the
 // specs.
@@ -28,19 +20,21 @@
 #include "./fast_log.h"
 #include "./prefix.h"
 #include "./write_bits.h"
-
 namespace brotli {
 
 // returns false if fail
 // nibblesbits represents the 2 bits to encode MNIBBLES (0-3)
 bool EncodeMlen(size_t length, int* bits, int* numbits, int* nibblesbits) {
+  if (length > (1 << 24)) {
+    return false;
+  }
   length--;  // MLEN - 1 is encoded
-  int lg = length == 0 ? 1 : Log2Floor(length) + 1;
-  if (lg > 24) return false;
+  int lg = length == 0 ? 1 : Log2Floor(static_cast<uint32_t>(length)) + 1;
+  assert(lg <= 24);
   int mnibbles = (lg < 16 ? 16 : (lg + 3)) / 4;
   *nibblesbits = mnibbles - 4;
   *numbits = mnibbles * 4;
-  *bits = length;
+  *bits = static_cast<int>(length);
   return true;
 }
 
@@ -166,7 +160,7 @@ void StoreHuffmanTreeToBitMask(
     const std::vector<uint16_t> &code_length_bitdepth_symbols,
     int * __restrict storage_ix,
     uint8_t * __restrict storage) {
-  for (int i = 0; i < huffman_tree.size(); ++i) {
+  for (size_t i = 0; i < huffman_tree.size(); ++i) {
     int ix = huffman_tree[i];
     WriteBits(code_length_bitdepth[ix], code_length_bitdepth_symbols[ix],
               storage_ix, storage);
@@ -219,7 +213,7 @@ void StoreSimpleHuffmanTree(const uint8_t* depths,
 
 // num = alphabet size
 // depths = symbol depths
-void StoreHuffmanTree(const uint8_t* depths, size_t num,
+void StoreHuffmanTree(const uint8_t* depths, int num,
                       int *storage_ix, uint8_t *storage) {
   // Write the Huffman tree into the brotli-representation.
   std::vector<uint8_t> huffman_tree;
@@ -231,7 +225,7 @@ void StoreHuffmanTree(const uint8_t* depths, size_t num,
 
   // Calculate the statistics of the Huffman tree in brotli-representation.
   int huffman_tree_histogram[kCodeLengthCodes] = { 0 };
-  for (int i = 0; i < huffman_tree.size(); ++i) {
+  for (size_t i = 0; i < huffman_tree.size(); ++i) {
     ++huffman_tree_histogram[huffman_tree[i]];
   }
 
@@ -257,7 +251,7 @@ void StoreHuffmanTree(const uint8_t* depths, size_t num,
   CreateHuffmanTree(&huffman_tree_histogram[0], kCodeLengthCodes,
                     5, &code_length_bitdepth[0]);
   ConvertBitDepthsToSymbols(code_length_bitdepth, kCodeLengthCodes,
-                            code_length_bitdepth_symbols.data());
+                            &code_length_bitdepth_symbols[0]);
 
   // Now, we have all the data, let's start storing it
   StoreHuffmanTreeOfHuffmanTreeToBitMask(num_codes, code_length_bitdepth,
@@ -275,6 +269,7 @@ void StoreHuffmanTree(const uint8_t* depths, size_t num,
                             storage_ix, storage);
 }
 
+
 void BuildAndStoreHuffmanTree(const int *histogram,
                               const int length,
                               uint8_t* depth,
@@ -283,7 +278,7 @@ void BuildAndStoreHuffmanTree(const int *histogram,
                               uint8_t* storage) {
   int count = 0;
   int s4[4] = { 0 };
-  for (size_t i = 0; i < length; i++) {
+  for (int i = 0; i < length; i++) {
     if (histogram[i]) {
       if (count < 4) {
         s4[count] = i;
@@ -318,7 +313,7 @@ void BuildAndStoreHuffmanTree(const int *histogram,
 }
 
 int IndexOf(const std::vector<int>& v, int value) {
-  for (int i = 0; i < v.size(); ++i) {
+  for (int i = 0; i < static_cast<int>(v.size()); ++i) {
     if (v[i] == value) return i;
   }
   return -1;
@@ -335,10 +330,11 @@ void MoveToFront(std::vector<int>* v, int index) {
 std::vector<int> MoveToFrontTransform(const std::vector<int>& v) {
   if (v.empty()) return v;
   std::vector<int> mtf(*std::max_element(v.begin(), v.end()) + 1);
-  for (int i = 0; i < mtf.size(); ++i) mtf[i] = i;
+  for (int i = 0; i < static_cast<int>(mtf.size()); ++i) mtf[i] = i;
   std::vector<int> result(v.size());
-  for (int i = 0; i < v.size(); ++i) {
+  for (size_t i = 0; i < v.size(); ++i) {
     int index = IndexOf(mtf, v[i]);
+    assert(index >= 0);
     result[i] = index;
     MoveToFront(&mtf, index);
   }
@@ -356,7 +352,7 @@ void RunLengthCodeZeros(const std::vector<int>& v_in,
                         std::vector<int>* v_out,
                         std::vector<int>* extra_bits) {
   int max_reps = 0;
-  for (int i = 0; i < v_in.size();) {
+  for (size_t i = 0; i < v_in.size();) {
     for (; i < v_in.size() && v_in[i] != 0; ++i) ;
     int reps = 0;
     for (; i < v_in.size() && v_in[i] == 0; ++i) {
@@ -366,14 +362,14 @@ void RunLengthCodeZeros(const std::vector<int>& v_in,
   }
   int max_prefix = max_reps > 0 ? Log2Floor(max_reps) : 0;
   *max_run_length_prefix = std::min(max_prefix, *max_run_length_prefix);
-  for (int i = 0; i < v_in.size();) {
+  for (size_t i = 0; i < v_in.size();) {
     if (v_in[i] != 0) {
       v_out->push_back(v_in[i] + *max_run_length_prefix);
       extra_bits->push_back(0);
       ++i;
     } else {
       int reps = 1;
-      for (uint32_t k = i + 1; k < v_in.size() && v_in[k] == 0; ++k) {
+      for (size_t k = i + 1; k < v_in.size() && v_in[k] == 0; ++k) {
         ++reps;
       }
       i += reps;
@@ -409,7 +405,7 @@ void EncodeContextMap(const std::vector<int>& context_map,
   RunLengthCodeZeros(transformed_symbols, &max_run_length_prefix,
                      &rle_symbols, &extra_bits);
   HistogramContextMap symbol_histogram;
-  for (int i = 0; i < rle_symbols.size(); ++i) {
+  for (size_t i = 0; i < rle_symbols.size(); ++i) {
     symbol_histogram.Add(rle_symbols[i]);
   }
   bool use_rle = max_run_length_prefix > 0;
@@ -424,7 +420,7 @@ void EncodeContextMap(const std::vector<int>& context_map,
                            num_clusters + max_run_length_prefix,
                            symbol_code.depth_, symbol_code.bits_,
                            storage_ix, storage);
-  for (int i = 0; i < rle_symbols.size(); ++i) {
+  for (size_t i = 0; i < rle_symbols.size(); ++i) {
     WriteBits(symbol_code.depth_[rle_symbols[i]],
               symbol_code.bits_[rle_symbols[i]],
               storage_ix, storage);
@@ -457,7 +453,7 @@ void BuildAndStoreBlockSplitCode(const std::vector<int>& types,
                                  BlockSplitCode* code,
                                  int* storage_ix,
                                  uint8_t* storage) {
-  const int num_blocks = types.size();
+  const int num_blocks = static_cast<int>(types.size());
   std::vector<int> type_histo(num_types + 2);
   std::vector<int> length_histo(26);
   int last_type = 1;
@@ -562,8 +558,8 @@ class BlockEncoder {
       int* storage_ix, uint8_t* storage) {
     depths_.resize(histograms.size() * alphabet_size_);
     bits_.resize(histograms.size() * alphabet_size_);
-    for (int i = 0; i < histograms.size(); ++i) {
-      int ix = i * alphabet_size_;
+    for (size_t i = 0; i < histograms.size(); ++i) {
+      size_t ix = i * alphabet_size_;
       BuildAndStoreHuffmanTree(&histograms[i].data_[0], alphabet_size_,
                                &depths_[ix], &bits_[ix],
                                storage_ix, storage);
@@ -674,19 +670,21 @@ bool StoreMetaBlock(const uint8_t* input,
     WriteBits(2, literal_context_mode, storage_ix, storage);
   }
 
+  int num_literal_histograms = static_cast<int>(mb.literal_histograms.size());
   if (mb.literal_context_map.empty()) {
-    StoreTrivialContextMap(mb.literal_histograms.size(), kLiteralContextBits,
+    StoreTrivialContextMap(num_literal_histograms, kLiteralContextBits,
                            storage_ix, storage);
   } else {
-    EncodeContextMap(mb.literal_context_map, mb.literal_histograms.size(),
+    EncodeContextMap(mb.literal_context_map, num_literal_histograms,
                      storage_ix, storage);
   }
 
+  int num_dist_histograms = static_cast<int>(mb.distance_histograms.size());
   if (mb.distance_context_map.empty()) {
-    StoreTrivialContextMap(mb.distance_histograms.size(), kDistanceContextBits,
+    StoreTrivialContextMap(num_dist_histograms, kDistanceContextBits,
                            storage_ix, storage);
   } else {
-    EncodeContextMap(mb.distance_context_map, mb.distance_histograms.size(),
+    EncodeContextMap(mb.distance_context_map, num_dist_histograms,
                      storage_ix, storage);
   }
 
@@ -698,11 +696,11 @@ bool StoreMetaBlock(const uint8_t* input,
                                          storage_ix, storage);
 
   size_t pos = start_pos;
-  for (int i = 0; i < n_commands; ++i) {
+  for (size_t i = 0; i < n_commands; ++i) {
     const Command cmd = commands[i];
     int cmd_code = cmd.cmd_prefix_;
-    int lennumextra = cmd.cmd_extra_ >> 48;
-    uint64_t lenextra = cmd.cmd_extra_ & 0xffffffffffffULL;
+    int lennumextra = static_cast<int>(cmd.cmd_extra_ >> 48);
+    uint64_t lenextra = cmd.cmd_extra_ & 0xffffffffffffUL;
     command_enc.StoreSymbol(cmd_code, storage_ix, storage);
     WriteBits(lennumextra, lenextra, storage_ix, storage);
     if (mb.literal_context_map.empty()) {
@@ -714,7 +712,7 @@ bool StoreMetaBlock(const uint8_t* input,
       for (int j = 0; j < cmd.insert_len_; ++j) {
         int context = Context(prev_byte, prev_byte2,
                               literal_context_mode);
-        int literal = input[pos & mask];
+        uint8_t literal = input[pos & mask];
         literal_enc.StoreSymbolWithContext<kLiteralContextBits>(
             literal, context, mb.literal_context_map, storage_ix, storage);
         prev_byte2 = prev_byte;
@@ -771,7 +769,7 @@ bool StoreMetaBlockTrivial(const uint8_t* input,
   HistogramDistance dist_histo;
 
   size_t pos = start_pos;
-  for (int i = 0; i < n_commands; ++i) {
+  for (size_t i = 0; i < n_commands; ++i) {
     const Command cmd = commands[i];
     cmd_histo.Add(cmd.cmd_prefix_);
     for (int j = 0; j < cmd.insert_len_; ++j) {
@@ -804,11 +802,11 @@ bool StoreMetaBlockTrivial(const uint8_t* input,
                            storage_ix, storage);
 
   pos = start_pos;
-  for (int i = 0; i < n_commands; ++i) {
+  for (size_t i = 0; i < n_commands; ++i) {
     const Command cmd = commands[i];
     const int cmd_code = cmd.cmd_prefix_;
-    const int lennumextra = cmd.cmd_extra_ >> 48;
-    const uint64_t lenextra = cmd.cmd_extra_ & 0xffffffffffffULL;
+    const int lennumextra = static_cast<int>(cmd.cmd_extra_ >> 48);
+    const uint64_t lenextra = cmd.cmd_extra_ & 0xffffffffffffUL;
     WriteBits(cmd_depth[cmd_code], cmd_bits[cmd_code], storage_ix, storage);
     WriteBits(lennumextra, lenextra, storage_ix, storage);
     for (int j = 0; j < cmd.insert_len_; j++) {
@@ -849,19 +847,19 @@ bool StoreUncompressedMetaBlock(bool final_block,
   if (masked_pos + len > mask + 1) {
     size_t len1 = mask + 1 - masked_pos;
     memcpy(&storage[*storage_ix >> 3], &input[masked_pos], len1);
-    *storage_ix += len1 << 3;
+    *storage_ix += static_cast<int>(len1 << 3);
     len -= len1;
     masked_pos = 0;
   }
   memcpy(&storage[*storage_ix >> 3], &input[masked_pos], len);
-  *storage_ix += len << 3;
+  *storage_ix += static_cast<int>(len << 3);
 
   // We need to clear the next 4 bytes to continue to be
   // compatible with WriteBits.
   brotli::WriteBitsPrepareStorage(*storage_ix, storage);
 
-  // Since the uncomressed block itself may not be the final block, add an empty
-  // one after this.
+  // Since the uncompressed block itself may not be the final block, add an
+  // empty one after this.
   if (final_block) {
     brotli::WriteBits(1, 1, storage_ix, storage);  // islast
     brotli::WriteBits(1, 1, storage_ix, storage);  // isempty

data/vendor/brotli/enc/brotli_bit_stream.h

@@ -1,17 +1,9 @@
-// Copyright 2014 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.
-//
+/* Copyright 2014 Google Inc. All Rights Reserved.
+
+   Distributed under MIT license.
+   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+*/
+
 // Functions to convert brotli-related data structures into the
 // brotli bit stream. The functions here operate under
 // assumption that there is enough space in the storage, i.e., there are
@@ -24,11 +16,10 @@
 #ifndef BROTLI_ENC_BROTLI_BIT_STREAM_H_
 #define BROTLI_ENC_BROTLI_BIT_STREAM_H_
 
-#include <stddef.h>
-#include <stdint.h>
 #include <vector>
 
 #include "./metablock.h"
+#include "./types.h"
 
 namespace brotli {