brotli 0.1.0 → 0.1.1

data/vendor/brotli/enc/hash.h

@@ -1,25 +1,15 @@
-// Copyright 2010 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 2010 Google Inc. All Rights Reserved.
+
+   Distributed under MIT license.
+   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+*/
+
 // A (forgetful) hash table to the data seen by the compressor, to
 // help create backward references to previous data.
 
 #ifndef BROTLI_ENC_HASH_H_
 #define BROTLI_ENC_HASH_H_
 
-#include <stddef.h>
-#include <stdint.h>
 #include <string.h>
 #include <sys/types.h>
 #include <algorithm>
@@ -34,6 +24,7 @@
 #include "./prefix.h"
 #include "./static_dict.h"
 #include "./transform.h"
+#include "./types.h"
 
 namespace brotli {
 
@@ -137,20 +128,13 @@ class HashLongestMatchQuickly {
   // Look at 4 bytes at data.
   // Compute a hash from these, and store the value somewhere within
   // [ix .. ix+3].
-  inline void Store(const uint8_t *data, const int ix) {
+  inline void Store(const uint8_t *data, const uint32_t ix) {
     const uint32_t key = HashBytes(data);
     // Wiggle the value with the bucket sweep range.
-    const uint32_t off = (static_cast<uint32_t>(ix) >> 3) % kBucketSweep;
+    const uint32_t off = (ix >> 3) % kBucketSweep;
     buckets_[key + off] = ix;
   }
 
-  // Store hashes for a range of data.
-  void StoreHashes(const uint8_t *data, size_t len, int startix, int mask) {
-    for (int p = 0; p < len; ++p) {
-      Store(&data[p & mask], startix + p);
-    }
-  }
-
   // Find a longest backward match of &ring_buffer[cur_ix & ring_buffer_mask]
   // up to the length of max_length.
   //
@@ -163,22 +147,22 @@ class HashLongestMatchQuickly {
                                const size_t ring_buffer_mask,
                                const int* __restrict distance_cache,
                                const uint32_t cur_ix,
-                               const uint32_t max_length,
+                               const int max_length,
                                const uint32_t max_backward,
                                int * __restrict best_len_out,
                                int * __restrict best_len_code_out,
                                int * __restrict best_distance_out,
                                double* __restrict best_score_out) {
     const int best_len_in = *best_len_out;
-    const int cur_ix_masked = cur_ix & ring_buffer_mask;
+    const size_t cur_ix_masked = cur_ix & ring_buffer_mask;
     int compare_char = ring_buffer[cur_ix_masked + best_len_in];
     double best_score = *best_score_out;
     int best_len = best_len_in;
-    int backward = distance_cache[0];
-    size_t prev_ix = cur_ix - backward;
+    int cached_backward = distance_cache[0];
+    uint32_t prev_ix = cur_ix - cached_backward;
     bool match_found = false;
     if (prev_ix < cur_ix) {
-      prev_ix &= ring_buffer_mask;
+      prev_ix &= static_cast<uint32_t>(ring_buffer_mask);
       if (compare_char == ring_buffer[prev_ix + best_len]) {
         int len = FindMatchLengthWithLimit(&ring_buffer[prev_ix],
                                            &ring_buffer[cur_ix_masked],
@@ -188,7 +172,7 @@ class HashLongestMatchQuickly {
           best_len = len;
           *best_len_out = len;
           *best_len_code_out = len;
-          *best_distance_out = backward;
+          *best_distance_out = cached_backward;
           *best_score_out = best_score;
           compare_char = ring_buffer[cur_ix_masked + best_len];
           if (kBucketSweep == 1) {
@@ -203,8 +187,8 @@ class HashLongestMatchQuickly {
     if (kBucketSweep == 1) {
       // Only one to look for, don't bother to prepare for a loop.
       prev_ix = buckets_[key];
-      backward = cur_ix - prev_ix;
-      prev_ix &= ring_buffer_mask;
+      uint32_t backward = cur_ix - prev_ix;
+      prev_ix &= static_cast<uint32_t>(ring_buffer_mask);
       if (compare_char != ring_buffer[prev_ix + best_len_in]) {
         return false;
       }
@@ -225,8 +209,8 @@ class HashLongestMatchQuickly {
       uint32_t *bucket = buckets_ + key;
       prev_ix = *bucket++;
       for (int i = 0; i < kBucketSweep; ++i, prev_ix = *bucket++) {
-        const int backward = cur_ix - prev_ix;
-        prev_ix &= ring_buffer_mask;
+        const uint32_t backward = cur_ix - prev_ix;
+        prev_ix &= static_cast<uint32_t>(ring_buffer_mask);
         if (compare_char != ring_buffer[prev_ix + best_len]) {
           continue;
         }
@@ -255,8 +239,8 @@ class HashLongestMatchQuickly {
     if (kUseDictionary && !match_found &&
         num_dict_matches_ >= (num_dict_lookups_ >> 7)) {
       ++num_dict_lookups_;
-      const uint32_t key = Hash<14>(&ring_buffer[cur_ix_masked]) << 1;
-      const uint16_t v = kStaticDictionaryHash[key];
+      const uint32_t dict_key = Hash<14>(&ring_buffer[cur_ix_masked]) << 1;
+      const uint16_t v = kStaticDictionaryHash[dict_key];
       if (v > 0) {
         const int len = v & 31;
         const int dist = v >> 5;
@@ -270,7 +254,7 @@ class HashLongestMatchQuickly {
             const int word_id =
                 transform_id * (1 << kBrotliDictionarySizeBitsByLength[len]) +
                 dist;
-            const size_t backward = max_backward + word_id + 1;
+            const int backward = max_backward + word_id + 1;
             const double score = BackwardReferenceScore(matchlen, backward);
             if (best_score < score) {
               ++num_dict_matches_;
@@ -297,11 +281,10 @@ class HashLongestMatchQuickly {
   static uint32_t HashBytes(const uint8_t *data) {
     // Computing a hash based on 5 bytes works much better for
     // qualities 1 and 3, where the next hash value is likely to replace
-    static const uint32_t kHashMul32 = 0x1e35a7bd;
     uint64_t h = (BROTLI_UNALIGNED_LOAD64(data) << 24) * kHashMul32;
     // The higher bits contain more mixture from the multiplication,
     // so we take our results from there.
-    return h >> (64 - kBucketBits);
+    return static_cast<uint32_t>(h >> (64 - kBucketBits));
   }
 
  private:
@@ -337,20 +320,13 @@ class HashLongestMatch {
 
   // Look at 3 bytes at data.
   // Compute a hash from these, and store the value of ix at that position.
-  inline void Store(const uint8_t *data, const int ix) {
+  inline void Store(const uint8_t *data, const uint32_t ix) {
     const uint32_t key = HashBytes(data);
     const int minor_ix = num_[key] & kBlockMask;
     buckets_[key][minor_ix] = ix;
     ++num_[key];
   }
 
-  // Store hashes for a range of data.
-  void StoreHashes(const uint8_t *data, size_t len, int startix, int mask) {
-    for (int p = 0; p < len; ++p) {
-      Store(&data[p & mask], startix + p);
-    }
-  }
-
   // Find a longest backward match of &data[cur_ix] up to the length of
   // max_length.
   //
@@ -364,7 +340,7 @@ class HashLongestMatch {
                         const size_t ring_buffer_mask,
                         const int* __restrict distance_cache,
                         const uint32_t cur_ix,
-                        uint32_t max_length,
+                        const int max_length,
                         const uint32_t max_backward,
                         int * __restrict best_len_out,
                         int * __restrict best_len_code_out,
@@ -381,21 +357,21 @@ class HashLongestMatch {
     for (int i = 0; i < kNumLastDistancesToCheck; ++i) {
       const int idx = kDistanceCacheIndex[i];
       const int backward = distance_cache[idx] + kDistanceCacheOffset[i];
-      size_t prev_ix = cur_ix - backward;
+      uint32_t prev_ix = cur_ix - backward;
       if (prev_ix >= cur_ix) {
         continue;
       }
-      if (PREDICT_FALSE(backward > max_backward)) {
+      if (PREDICT_FALSE(backward > (int)max_backward)) {
         continue;
       }
-      prev_ix &= ring_buffer_mask;
+      prev_ix &= static_cast<uint32_t>(ring_buffer_mask);
 
       if (cur_ix_masked + best_len > ring_buffer_mask ||
           prev_ix + best_len > ring_buffer_mask ||
           data[cur_ix_masked + best_len] != data[prev_ix + best_len]) {
         continue;
       }
-      const size_t len =
+      const int len =
           FindMatchLengthWithLimit(&data[prev_ix], &data[cur_ix_masked],
                                    max_length);
       if (len >= 3 || (len == 2 && i < 2)) {
@@ -415,46 +391,44 @@ class HashLongestMatch {
       }
     }
     const uint32_t key = HashBytes(&data[cur_ix_masked]);
-    const int * __restrict const bucket = &buckets_[key][0];
+    const uint32_t * __restrict const bucket = &buckets_[key][0];
     const int down = (num_[key] > kBlockSize) ? (num_[key] - kBlockSize) : 0;
     for (int i = num_[key] - 1; i >= down; --i) {
-      int prev_ix = bucket[i & kBlockMask];
-      if (prev_ix >= 0) {
-        const size_t backward = cur_ix - prev_ix;
-        if (PREDICT_FALSE(backward > max_backward)) {
-          break;
-        }
-        prev_ix &= ring_buffer_mask;
-        if (cur_ix_masked + best_len > ring_buffer_mask ||
-            prev_ix + best_len > ring_buffer_mask ||
-            data[cur_ix_masked + best_len] != data[prev_ix + best_len]) {
-          continue;
-        }
-        const size_t len =
-            FindMatchLengthWithLimit(&data[prev_ix], &data[cur_ix_masked],
-                                     max_length);
-        if (len >= 4) {
-          // Comparing for >= 3 does not change the semantics, but just saves
-          // for a few unnecessary binary logarithms in backward reference
-          // score, since we are not interested in such short matches.
-          double score = BackwardReferenceScore(len, backward);
-          if (best_score < score) {
-            best_score = score;
-            best_len = len;
-            *best_len_out = best_len;
-            *best_len_code_out = best_len;
-            *best_distance_out = backward;
-            *best_score_out = best_score;
-            match_found = true;
-          }
+      uint32_t prev_ix = bucket[i & kBlockMask];
+      const uint32_t backward = cur_ix - prev_ix;
+      if (PREDICT_FALSE(backward == 0 || backward > max_backward)) {
+        break;
+      }
+      prev_ix &= static_cast<uint32_t>(ring_buffer_mask);
+      if (cur_ix_masked + best_len > ring_buffer_mask ||
+          prev_ix + best_len > ring_buffer_mask ||
+          data[cur_ix_masked + best_len] != data[prev_ix + best_len]) {
+        continue;
+      }
+      const int len =
+          FindMatchLengthWithLimit(&data[prev_ix], &data[cur_ix_masked],
+                                   max_length);
+      if (len >= 4) {
+        // Comparing for >= 3 does not change the semantics, but just saves
+        // for a few unnecessary binary logarithms in backward reference
+        // score, since we are not interested in such short matches.
+        double score = BackwardReferenceScore(len, backward);
+        if (best_score < score) {
+          best_score = score;
+          best_len = len;
+          *best_len_out = best_len;
+          *best_len_code_out = best_len;
+          *best_distance_out = backward;
+          *best_score_out = best_score;
+          match_found = true;
         }
       }
     }
     if (!match_found && num_dict_matches_ >= (num_dict_lookups_ >> 7)) {
-      uint32_t key = Hash<14>(&data[cur_ix_masked]) << 1;
-      for (int k = 0; k < 2; ++k, ++key) {
+      uint32_t dict_key = Hash<14>(&data[cur_ix_masked]) << 1;
+      for (int k = 0; k < 2; ++k, ++dict_key) {
         ++num_dict_lookups_;
-        const uint16_t v = kStaticDictionaryHash[key];
+        const uint16_t v = kStaticDictionaryHash[dict_key];
         if (v > 0) {
           const int len = v & 31;
           const int dist = v >> 5;
@@ -468,7 +442,7 @@ class HashLongestMatch {
               const int word_id =
                   transform_id * (1 << kBrotliDictionarySizeBitsByLength[len]) +
                   dist;
-              const size_t backward = max_backward + word_id + 1;
+              const int backward = max_backward + word_id + 1;
               double score = BackwardReferenceScore(matchlen, backward);
               if (best_score < score) {
                 ++num_dict_matches_;
@@ -500,7 +474,7 @@ class HashLongestMatch {
   void FindAllMatches(const uint8_t* data,
                       const size_t ring_buffer_mask,
                       const uint32_t cur_ix,
-                      uint32_t max_length,
+                      const int max_length,
                       const uint32_t max_backward,
                       int* num_matches,
                       BackwardMatch* matches) const {
@@ -520,7 +494,7 @@ class HashLongestMatch {
           data[cur_ix_masked + 1] != data[prev_ix + 1]) {
         continue;
       }
-      const size_t len =
+      const int len =
           FindMatchLengthWithLimit(&data[prev_ix], &data[cur_ix_masked],
                                    max_length);
       if (len > best_len) {
@@ -528,35 +502,33 @@ class HashLongestMatch {
         if (len > kMaxZopfliLen) {
           matches = orig_matches;
         }
-        *matches++ = BackwardMatch(backward, len);
+        *matches++ = BackwardMatch(static_cast<int>(backward), len);
       }
     }
     const uint32_t key = HashBytes(&data[cur_ix_masked]);
-    const int * __restrict const bucket = &buckets_[key][0];
+    const uint32_t * __restrict const bucket = &buckets_[key][0];
     const int down = (num_[key] > kBlockSize) ? (num_[key] - kBlockSize) : 0;
     for (int i = num_[key] - 1; i >= down; --i) {
-      int prev_ix = bucket[i & kBlockMask];
-      if (prev_ix >= 0) {
-        const size_t backward = cur_ix - prev_ix;
-        if (PREDICT_FALSE(backward > max_backward)) {
-          break;
-        }
-        prev_ix &= ring_buffer_mask;
-        if (cur_ix_masked + best_len > ring_buffer_mask ||
-            prev_ix + best_len > ring_buffer_mask ||
-            data[cur_ix_masked + best_len] != data[prev_ix + best_len]) {
-          continue;
-        }
-        const size_t len =
-            FindMatchLengthWithLimit(&data[prev_ix], &data[cur_ix_masked],
-                                     max_length);
-        if (len > best_len) {
-          best_len = len;
-          if (len > kMaxZopfliLen) {
-            matches = orig_matches;
-          }
-          *matches++ = BackwardMatch(backward, len);
+      uint32_t prev_ix = bucket[i & kBlockMask];
+      const uint32_t backward = cur_ix - prev_ix;
+      if (PREDICT_FALSE(backward == 0 || backward > max_backward)) {
+        break;
+      }
+      prev_ix &= static_cast<uint32_t>(ring_buffer_mask);
+      if (cur_ix_masked + best_len > ring_buffer_mask ||
+          prev_ix + best_len > ring_buffer_mask ||
+          data[cur_ix_masked + best_len] != data[prev_ix + best_len]) {
+        continue;
+      }
+      const int len =
+          FindMatchLengthWithLimit(&data[prev_ix], &data[cur_ix_masked],
+                                   max_length);
+      if (len > best_len) {
+        best_len = len;
+        if (len > kMaxZopfliLen) {
+          matches = orig_matches;
         }
+        *matches++ = BackwardMatch(backward, len);
       }
     }
     std::vector<int> dict_matches(kMaxDictionaryMatchLen + 1, kInvalidMatch);
@@ -572,7 +544,7 @@ class HashLongestMatch {
         }
       }
     }
-    *num_matches += matches - orig_matches;
+    *num_matches += static_cast<int>(matches - orig_matches);
   }
 
   enum { kHashLength = 4 };
@@ -582,14 +554,6 @@ class HashLongestMatch {
   // the address in. The HashLongestMatch and HashLongestMatchQuickly
   // classes have separate, different implementations of hashing.
   static uint32_t HashBytes(const uint8_t *data) {
-    // kHashMul32 multiplier has these properties:
-    // * The multiplier must be odd. Otherwise we may lose the highest bit.
-    // * No long streaks of 1s or 0s.
-    // * Is not unfortunate (see the unittest) for the English language.
-    // * There is no effort to ensure that it is a prime, the oddity is enough
-    //   for this use.
-    // * The number has been tuned heuristically against compression benchmarks.
-    static const uint32_t kHashMul32 = 0x1e35a7bd;
     uint32_t h = BROTLI_UNALIGNED_LOAD32(data) * kHashMul32;
     // The higher bits contain more mixture from the multiplication,
     // so we take our results from there.
@@ -611,7 +575,7 @@ class HashLongestMatch {
   uint16_t num_[kBucketSize];
 
   // Buckets containing kBlockSize of backward references.
-  int buckets_[kBucketSize][kBlockSize];
+  uint32_t buckets_[kBucketSize][kBlockSize];
 
   size_t num_dict_lookups_;
   size_t num_dict_matches_;
@@ -631,17 +595,32 @@ struct Hashers {
   typedef HashLongestMatch<15, 7, 10> H8;
   typedef HashLongestMatch<15, 8, 16> H9;
 
+  Hashers() : hash_h1(0), hash_h2(0), hash_h3(0), hash_h4(0), hash_h5(0),
+              hash_h6(0), hash_h7(0), hash_h8(0), hash_h9(0) {}
+
+  ~Hashers() {
+    delete hash_h1;
+    delete hash_h2;
+    delete hash_h3;
+    delete hash_h4;
+    delete hash_h5;
+    delete hash_h6;
+    delete hash_h7;
+    delete hash_h8;
+    delete hash_h9;
+  }
+
   void Init(int type) {
     switch (type) {
-      case 1: hash_h1.reset(new H1); break;
-      case 2: hash_h2.reset(new H2); break;
-      case 3: hash_h3.reset(new H3); break;
-      case 4: hash_h4.reset(new H4); break;
-      case 5: hash_h5.reset(new H5); break;
-      case 6: hash_h6.reset(new H6); break;
-      case 7: hash_h7.reset(new H7); break;
-      case 8: hash_h8.reset(new H8); break;
-      case 9: hash_h9.reset(new H9); break;
+      case 1: hash_h1 = new H1; break;
+      case 2: hash_h2 = new H2; break;
+      case 3: hash_h3 = new H3; break;
+      case 4: hash_h4 = new H4; break;
+      case 5: hash_h5 = new H5; break;
+      case 6: hash_h6 = new H6; break;
+      case 7: hash_h7 = new H7; break;
+      case 8: hash_h8 = new H8; break;
+      case 9: hash_h9 = new H9; break;
       default: break;
     }
   }
@@ -649,7 +628,7 @@ struct Hashers {
   template<typename Hasher>
   void WarmupHash(const size_t size, const uint8_t* dict, Hasher* hasher) {
     for (size_t i = 0; i + Hasher::kHashTypeLength - 1 < size; i++) {
-      hasher->Store(dict, i);
+      hasher->Store(&dict[i], static_cast<uint32_t>(i));
     }
   }
 
@@ -657,28 +636,29 @@ struct Hashers {
   void PrependCustomDictionary(
       int type, const size_t size, const uint8_t* dict) {
     switch (type) {
-      case 1: WarmupHash(size, dict, hash_h1.get()); break;
-      case 2: WarmupHash(size, dict, hash_h2.get()); break;
-      case 3: WarmupHash(size, dict, hash_h3.get()); break;
-      case 4: WarmupHash(size, dict, hash_h4.get()); break;
-      case 5: WarmupHash(size, dict, hash_h5.get()); break;
-      case 6: WarmupHash(size, dict, hash_h6.get()); break;
-      case 7: WarmupHash(size, dict, hash_h7.get()); break;
-      case 8: WarmupHash(size, dict, hash_h8.get()); break;
-      case 9: WarmupHash(size, dict, hash_h9.get()); break;
+      case 1: WarmupHash(size, dict, hash_h1); break;
+      case 2: WarmupHash(size, dict, hash_h2); break;
+      case 3: WarmupHash(size, dict, hash_h3); break;
+      case 4: WarmupHash(size, dict, hash_h4); break;
+      case 5: WarmupHash(size, dict, hash_h5); break;
+      case 6: WarmupHash(size, dict, hash_h6); break;
+      case 7: WarmupHash(size, dict, hash_h7); break;
+      case 8: WarmupHash(size, dict, hash_h8); break;
+      case 9: WarmupHash(size, dict, hash_h9); break;
       default: break;
     }
   }
 
-  std::unique_ptr<H1> hash_h1;
-  std::unique_ptr<H2> hash_h2;
-  std::unique_ptr<H3> hash_h3;
-  std::unique_ptr<H4> hash_h4;
-  std::unique_ptr<H5> hash_h5;
-  std::unique_ptr<H6> hash_h6;
-  std::unique_ptr<H7> hash_h7;
-  std::unique_ptr<H8> hash_h8;
-  std::unique_ptr<H9> hash_h9;
+
+  H1* hash_h1;
+  H2* hash_h2;
+  H3* hash_h3;
+  H4* hash_h4;
+  H5* hash_h5;
+  H6* hash_h6;
+  H7* hash_h7;
+  H8* hash_h8;
+  H9* hash_h9;
 };
 
 }  // namespace brotli

data/vendor/brotli/enc/histogram.cc

@@ -1,22 +1,13 @@
-// 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
+*/
+
 // Build per-context histograms of literals, commands and distance codes.
 
 #include "./histogram.h"
 
-#include <stdint.h>
 #include <cmath>
 
 #include "./block_splitter.h"
@@ -45,7 +36,7 @@ void BuildHistograms(
   BlockSplitIterator literal_it(literal_split);
   BlockSplitIterator insert_and_copy_it(insert_and_copy_split);
   BlockSplitIterator dist_it(dist_split);
-  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_it.Next();
     (*insert_and_copy_histograms)[insert_and_copy_it.type_].Add(

data/vendor/brotli/enc/histogram.h

@@ -1,33 +1,26 @@
-// 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
+*/
+
 // Models the histograms of literals, commands and distance codes.
 
 #ifndef BROTLI_ENC_HISTOGRAM_H_
 #define BROTLI_ENC_HISTOGRAM_H_
 
-#include <stdint.h>
 #include <string.h>
+#include <limits>
 #include <vector>
 #include <utility>
 #include "./command.h"
 #include "./fast_log.h"
 #include "./prefix.h"
+#include "./types.h"
 
 namespace brotli {
 
-class BlockSplit;
+struct BlockSplit;
 
 // A simple container for histograms of data in blocks.
 template<int kDataSize>
@@ -38,6 +31,7 @@ struct Histogram {
   void Clear() {
     memset(data_, 0, sizeof(data_));
     total_count_ = 0;
+    bit_cost_ = std::numeric_limits<double>::infinity();
   }
   void Add(int val) {
     ++data_[val];
@@ -49,7 +43,7 @@ struct Histogram {
   }
   template<typename DataType>
   void Add(const DataType *p, size_t n) {
-    total_count_ += n;
+    total_count_ += static_cast<int>(n);
     n += 1;
     while(--n) ++data_[*p++];
   }