brotli 0.1.0 → 0.1.1

data/vendor/brotli/enc/cluster.h

@@ -1,24 +1,15 @@
-// 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
+*/
+
 // Functions for clustering similar histograms together.
 
 #ifndef BROTLI_ENC_CLUSTER_H_
 #define BROTLI_ENC_CLUSTER_H_
 
 #include <math.h>
-#include <stdint.h>
 #include <stdio.h>
 #include <algorithm>
 #include <complex>
@@ -31,6 +22,8 @@
 #include "./entropy_encode.h"
 #include "./fast_log.h"
 #include "./histogram.h"
+#include "./port.h"
+#include "./types.h"
 
 namespace brotli {
 
@@ -111,22 +104,25 @@ void HistogramCombine(HistogramType* out,
                       int* cluster_size,
                       int* symbols,
                       int symbols_size,
-                      int max_clusters) {
+                      size_t max_clusters) {
   double cost_diff_threshold = 0.0;
-  int min_cluster_size = 1;
+  size_t min_cluster_size = 1;
   std::set<int> all_symbols;
   std::vector<int> clusters;
   for (int i = 0; i < symbols_size; ++i) {
     if (all_symbols.find(symbols[i]) == all_symbols.end()) {
       all_symbols.insert(symbols[i]);
+      if (!clusters.empty()) {
+        BROTLI_DCHECK(clusters.back() < symbols[i]);
+      }
       clusters.push_back(symbols[i]);
     }
   }
 
   // We maintain a heap of histogram pairs, ordered by the bit cost reduction.
   std::vector<HistogramPair> pairs;
-  for (int idx1 = 0; idx1 < clusters.size(); ++idx1) {
-    for (int idx2 = idx1 + 1; idx2 < clusters.size(); ++idx2) {
+  for (size_t idx1 = 0; idx1 < clusters.size(); ++idx1) {
+    for (size_t idx2 = idx1 + 1; idx2 < clusters.size(); ++idx2) {
       CompareAndPushToHeap(out, cluster_size, clusters[idx1], clusters[idx2],
                            &pairs);
     }
@@ -149,14 +145,14 @@ void HistogramCombine(HistogramType* out,
         symbols[i] = best_idx1;
       }
     }
-    for (int i = 0; i + 1 < clusters.size(); ++i) {
+    for (size_t i = 0; i + 1 < clusters.size(); ++i) {
       if (clusters[i] >= best_idx2) {
         clusters[i] = clusters[i + 1];
       }
     }
     clusters.pop_back();
     // Invalidate pairs intersecting the just combined best pair.
-    for (int i = 0; i < pairs.size(); ++i) {
+    for (size_t i = 0; i < pairs.size(); ++i) {
       HistogramPair& p = pairs[i];
       if (p.idx1 == best_idx1 || p.idx2 == best_idx1 ||
           p.idx1 == best_idx2 || p.idx2 == best_idx2) {
@@ -169,7 +165,7 @@ void HistogramCombine(HistogramType* out,
       pairs.pop_back();
     }
     // Push new pairs formed with the combined histogram to the heap.
-    for (int i = 0; i < clusters.size(); ++i) {
+    for (size_t i = 0; i < clusters.size(); ++i) {
       CompareAndPushToHeap(out, cluster_size, best_idx1, clusters[i], &pairs);
     }
   }
@@ -232,7 +228,7 @@ void HistogramReindex(std::vector<HistogramType>* out,
   std::vector<HistogramType> tmp(*out);
   std::map<int, int> new_index;
   int next_index = 0;
-  for (int i = 0; i < symbols->size(); ++i) {
+  for (size_t i = 0; i < symbols->size(); ++i) {
     if (new_index.find((*symbols)[i]) == new_index.end()) {
       new_index[(*symbols)[i]] = next_index;
       (*out)[next_index] = tmp[(*symbols)[i]];
@@ -240,7 +236,7 @@ void HistogramReindex(std::vector<HistogramType>* out,
     }
   }
   out->resize(next_index);
-  for (int i = 0; i < symbols->size(); ++i) {
+  for (size_t i = 0; i < symbols->size(); ++i) {
     (*symbols)[i] = new_index[(*symbols)[i]];
   }
 }
@@ -251,10 +247,11 @@ void HistogramReindex(std::vector<HistogramType>* out,
 template<typename HistogramType>
 void ClusterHistograms(const std::vector<HistogramType>& in,
                        int num_contexts, int num_blocks,
-                       int max_histograms,
+                       size_t max_histograms,
                        std::vector<HistogramType>* out,
                        std::vector<int>* histogram_symbols) {
   const int in_size = num_contexts * num_blocks;
+  BROTLI_DCHECK(in_size == in.size());
   std::vector<int> cluster_size(in_size, 1);
   out->resize(in_size);
   histogram_symbols->resize(in_size);
@@ -264,6 +261,7 @@ void ClusterHistograms(const std::vector<HistogramType>& in,
     (*histogram_symbols)[i] = i;
   }
 
+
   const int max_input_histograms = 64;
   for (int i = 0; i < in_size; i += max_input_histograms) {
     int num_to_combine = std::min(in_size - i, max_input_histograms);
@@ -282,6 +280,7 @@ void ClusterHistograms(const std::vector<HistogramType>& in,
 
   // Convert the context map to a canonical form.
   HistogramReindex(out, histogram_symbols);
+
 }
 
 

data/vendor/brotli/enc/command.h

@@ -1,25 +1,17 @@
-// 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
+*/
+
 // This class models a sequence of literals and a backward reference copy.
 
 #ifndef BROTLI_ENC_COMMAND_H_
 #define BROTLI_ENC_COMMAND_H_
 
-#include <stdint.h>
 #include "./fast_log.h"
 #include "./prefix.h"
+#include "./types.h"
 
 namespace brotli {
 
@@ -32,66 +24,67 @@ static int copybase[] =  { 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 14, 18, 22, 30, 38,
 static int copyextra[] = { 0, 0, 0, 0, 0, 0, 0, 0,  1,  1,  2,  2,  3,  3,  4,
     4,   5,   5,   6,   7,   8,     9,   10,    24 };
 
-static inline int GetInsertLengthCode(int insertlen) {
+static inline uint16_t GetInsertLengthCode(int insertlen) {
   if (insertlen < 6) {
-    return insertlen;
+    return static_cast<uint16_t>(insertlen);
   } else if (insertlen < 130) {
     insertlen -= 2;
     int nbits = Log2FloorNonZero(insertlen) - 1;
-    return (nbits << 1) + (insertlen >> nbits) + 2;
+    return static_cast<uint16_t>((nbits << 1) + (insertlen >> nbits) + 2);
   } else if (insertlen < 2114) {
-    return Log2FloorNonZero(insertlen - 66) + 10;
+    return static_cast<uint16_t>(Log2FloorNonZero(insertlen - 66) + 10);
   } else if (insertlen < 6210) {
-    return 21;
+    return 21u;
   } else if (insertlen < 22594) {
-    return 22;
+    return 22u;
   } else {
-    return 23;
+    return 23u;
   }
 }
 
-static inline int GetCopyLengthCode(int copylen) {
+static inline uint16_t GetCopyLengthCode(int copylen) {
   if (copylen < 10) {
-    return copylen - 2;
+    return static_cast<uint16_t>(copylen - 2);
   } else if (copylen < 134) {
     copylen -= 6;
     int nbits = Log2FloorNonZero(copylen) - 1;
-    return (nbits << 1) + (copylen >> nbits) + 4;
+    return static_cast<uint16_t>((nbits << 1) + (copylen >> nbits) + 4);
   } else if (copylen < 2118) {
-    return Log2FloorNonZero(copylen - 70) + 12;
+    return static_cast<uint16_t>(Log2FloorNonZero(copylen - 70) + 12);
   } else {
-    return 23;
+    return 23u;
   }
 }
 
-static inline int CombineLengthCodes(
-    int inscode, int copycode, int distancecode) {
-  int bits64 = (copycode & 0x7u) | ((inscode & 0x7u) << 3);
-  if (distancecode == 0 && inscode < 8 && copycode < 16) {
+static inline uint16_t CombineLengthCodes(
+    uint16_t inscode, uint16_t copycode, bool use_last_distance) {
+  uint16_t bits64 =
+      static_cast<uint16_t>((copycode & 0x7u) | ((inscode & 0x7u) << 3));
+  if (use_last_distance && inscode < 8 && copycode < 16) {
     return (copycode < 8) ? bits64 : (bits64 | 64);
   } else {
     // "To convert an insert-and-copy length code to an insert length code and
     // a copy length code, the following table can be used"
-    static const int cells[9] = { 2, 3, 6, 4, 5, 8, 7, 9, 10 };
-    return (cells[(copycode >> 3) + 3 * (inscode >> 3)] << 6) | bits64;
+    static const uint16_t cells[9] = { 128u, 192u, 384u, 256u, 320u, 512u,
+                                       448u, 576u, 640u };
+    return cells[(copycode >> 3) + 3 * (inscode >> 3)] | bits64;
   }
 }
 
-static inline void GetLengthCode(int insertlen, int copylen, int distancecode,
+static inline void GetLengthCode(int insertlen, int copylen,
+                                 bool use_last_distance,
                                  uint16_t* code, uint64_t* extra) {
-  int inscode = GetInsertLengthCode(insertlen);
-  int copycode = GetCopyLengthCode(copylen);
+  uint16_t inscode = GetInsertLengthCode(insertlen);
+  uint16_t copycode = GetCopyLengthCode(copylen);
   uint64_t insnumextra = insextra[inscode];
   uint64_t numextra = insnumextra + copyextra[copycode];
   uint64_t insextraval = insertlen - insbase[inscode];
   uint64_t copyextraval = copylen - copybase[copycode];
-  *code = CombineLengthCodes(inscode, copycode, distancecode);
+  *code = CombineLengthCodes(inscode, copycode, use_last_distance);
   *extra = (numextra << 48) | (copyextraval << insnumextra) | insextraval;
 }
 
 struct Command {
-  Command() {}
-
   // distance_code is e.g. 0 for same-as-last short code, or 16 for offset 1.
   Command(int insertlen, int copylen, int copylen_code, int distance_code)
       : insert_len_(insertlen), copy_len_(copylen) {
@@ -99,13 +92,13 @@ struct Command {
     // npostfix and ndirect were 0, they are only recomputed later after the
     // clustering if needed.
     PrefixEncodeCopyDistance(distance_code, 0, 0, &dist_prefix_, &dist_extra_);
-    GetLengthCode(insertlen, copylen_code, dist_prefix_,
+    GetLengthCode(insertlen, copylen_code, dist_prefix_ == 0,
                   &cmd_prefix_, &cmd_extra_);
   }
 
   Command(int insertlen)
       : insert_len_(insertlen), copy_len_(0), dist_prefix_(16), dist_extra_(0) {
-    GetLengthCode(insertlen, 4, dist_prefix_, &cmd_prefix_, &cmd_extra_);
+    GetLengthCode(insertlen, 4, dist_prefix_ == 0, &cmd_prefix_, &cmd_extra_);
   }
 
   int DistanceCode() const {

data/vendor/brotli/enc/context.h

@@ -1,29 +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
+*/
+
 // Functions to map previous bytes into a context id.
 
 #ifndef BROTLI_ENC_CONTEXT_H_
 #define BROTLI_ENC_CONTEXT_H_
 
-#include <stdint.h>
+#include "./types.h"
 
 namespace brotli {
 
 // Second-order context lookup table for UTF8 byte streams.
 //
-// If p1 and p2 are the previous two bytes, we calcualte the context as
+// If p1 and p2 are the previous two bytes, we calculate the context as
 //
 //   context = kUTF8ContextLookup[p1] | kUTF8ContextLookup[p2 + 256].
 //
@@ -170,11 +162,12 @@ static inline uint8_t Context(uint8_t p1, uint8_t p2, int mode) {
     case CONTEXT_LSB6:
       return p1 & 0x3f;
     case CONTEXT_MSB6:
-      return p1 >> 2;
+      return static_cast<uint8_t>(p1 >> 2);
     case CONTEXT_UTF8:
       return kUTF8ContextLookup[p1] | kUTF8ContextLookup[p2 + 256];
     case CONTEXT_SIGNED:
-      return (kSigned3BitContextLookup[p1] << 3) + kSigned3BitContextLookup[p2];
+      return static_cast<uint8_t>((kSigned3BitContextLookup[p1] << 3) +
+                                  kSigned3BitContextLookup[p2]);
     default:
       return 0;
   }