brotli 0.1.0 → 0.1.1

data/vendor/brotli/enc/literal_cost.cc

@@ -1,26 +1,19 @@
-// 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
+*/
+
 // Literal cost model to allow backward reference replacement to be efficient.
 
 #include "./literal_cost.h"
 
 #include <math.h>
-#include <stdint.h>
 #include <algorithm>
 
 #include "./fast_log.h"
+#include "./types.h"
+#include "./utf8_util.h"
 
 namespace brotli {
 
@@ -45,7 +38,7 @@ static int DecideMultiByteStatsLevel(size_t pos, size_t len, size_t mask,
   int max_utf8 = 1;  // should be 2, but 1 compresses better.
   int last_c = 0;
   int utf8_pos = 0;
-  for (int i = 0; i < len; ++i) {
+  for (size_t i = 0; i < len; ++i) {
     int c = data[(pos + i) & mask];
     utf8_pos = UTF8Position(last_c, c, 2);
     ++counts[utf8_pos];
@@ -61,15 +54,14 @@ static int DecideMultiByteStatsLevel(size_t pos, size_t len, size_t mask,
 }
 
 void EstimateBitCostsForLiteralsUTF8(size_t pos, size_t len, size_t mask,
-                                     size_t cost_mask, const uint8_t *data,
-                                     float *cost) {
+                                     const uint8_t *data, float *cost) {
 
   // max_utf8 is 0 (normal ascii single byte modeling),
   // 1 (for 2-byte utf-8 modeling), or 2 (for 3-byte utf-8 modeling).
   const int max_utf8 = DecideMultiByteStatsLevel(pos, len, mask, data);
   int histogram[3][256] = { { 0 } };
   int window_half = 495;
-  int in_window = std::min(static_cast<size_t>(window_half), len);
+  int in_window = std::min(window_half, static_cast<int>(len));
   int in_window_utf8[3] = { 0 };
 
   // Bootstrap histograms.
@@ -84,7 +76,7 @@ void EstimateBitCostsForLiteralsUTF8(size_t pos, size_t len, size_t mask,
   }
 
   // Compute bit costs with sliding window.
-  for (int i = 0; i < len; ++i) {
+  for (int i = 0; i < static_cast<int>(len); ++i) {
     if (i - window_half >= 0) {
       // Remove a byte in the past.
       int c = (i - window_half - 1) < 0 ?
@@ -95,12 +87,10 @@ void EstimateBitCostsForLiteralsUTF8(size_t pos, size_t len, size_t mask,
       --histogram[utf8_pos2][data[(pos + i - window_half) & mask]];
       --in_window_utf8[utf8_pos2];
     }
-    if (i + window_half < len) {
+    if (i + window_half < static_cast<int>(len)) {
       // Add a byte in the future.
-      int c = (i + window_half - 1) < 0 ?
-          0 : data[(pos + i + window_half - 1) & mask];
-      int last_c = (i + window_half - 2) < 0 ?
-          0 : data[(pos + i + window_half - 2) & mask];
+      int c = data[(pos + i + window_half - 1) & mask];
+      int last_c = data[(pos + i + window_half - 2) & mask];
       int utf8_pos2 = UTF8Position(last_c, c, max_utf8);
       ++histogram[utf8_pos2][data[(pos + i + window_half) & mask]];
       ++in_window_utf8[utf8_pos2];
@@ -108,12 +98,12 @@ void EstimateBitCostsForLiteralsUTF8(size_t pos, size_t len, size_t mask,
     int c = i < 1 ? 0 : data[(pos + i - 1) & mask];
     int last_c = i < 2 ? 0 : data[(pos + i - 2) & mask];
     int utf8_pos = UTF8Position(last_c, c, max_utf8);
-    int masked_pos = (pos + i) & mask;
+    size_t masked_pos = (pos + i) & mask;
     int histo = histogram[utf8_pos][data[masked_pos]];
     if (histo == 0) {
       histo = 1;
     }
-    float lit_cost = FastLog2(in_window_utf8[utf8_pos]) - FastLog2(histo);
+    double lit_cost = FastLog2(in_window_utf8[utf8_pos]) - FastLog2(histo);
     lit_cost += 0.02905;
     if (lit_cost < 1.0) {
       lit_cost *= 0.5;
@@ -126,16 +116,19 @@ void EstimateBitCostsForLiteralsUTF8(size_t pos, size_t len, size_t mask,
     if (i < 2000) {
       lit_cost += 0.7 - ((2000 - i) / 2000.0 * 0.35);
     }
-    cost[(pos + i) & cost_mask] = lit_cost;
+    cost[i] = static_cast<float>(lit_cost);
   }
 }
 
 void EstimateBitCostsForLiterals(size_t pos, size_t len, size_t mask,
-                                 size_t cost_mask, const uint8_t *data,
-                                 float *cost) {
+                                 const uint8_t *data, float *cost) {
+  if (IsMostlyUTF8(data, pos, mask, len, kMinUTF8Ratio)) {
+    EstimateBitCostsForLiteralsUTF8(pos, len, mask, data, cost);
+    return;
+  }
   int histogram[256] = { 0 };
   int window_half = 2000;
-  int in_window = std::min(static_cast<size_t>(window_half), len);
+  int in_window = std::min(window_half, static_cast<int>(len));
 
   // Bootstrap histogram.
   for (int i = 0; i < in_window; ++i) {
@@ -143,13 +136,13 @@ void EstimateBitCostsForLiterals(size_t pos, size_t len, size_t mask,
   }
 
   // Compute bit costs with sliding window.
-  for (int i = 0; i < len; ++i) {
+  for (int i = 0; i < static_cast<int>(len); ++i) {
     if (i - window_half >= 0) {
       // Remove a byte in the past.
       --histogram[data[(pos + i - window_half) & mask]];
       --in_window;
     }
-    if (i + window_half < len) {
+    if (i + window_half < static_cast<int>(len)) {
       // Add a byte in the future.
       ++histogram[data[(pos + i + window_half) & mask]];
       ++in_window;
@@ -158,13 +151,13 @@ void EstimateBitCostsForLiterals(size_t pos, size_t len, size_t mask,
     if (histo == 0) {
       histo = 1;
     }
-    float lit_cost = FastLog2(in_window) - FastLog2(histo);
+    double lit_cost = FastLog2(in_window) - FastLog2(histo);
     lit_cost += 0.029;
     if (lit_cost < 1.0) {
       lit_cost *= 0.5;
       lit_cost += 0.5;
     }
-    cost[(pos + i) & cost_mask] = lit_cost;
+    cost[i] = static_cast<float>(lit_cost);
   }
 }
 

data/vendor/brotli/enc/literal_cost.h

@@ -1,37 +1,23 @@
-// 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
+*/
+
 // Literal cost model to allow backward reference replacement to be efficient.
 
 #ifndef BROTLI_ENC_LITERAL_COST_H_
 #define BROTLI_ENC_LITERAL_COST_H_
 
-#include <stddef.h>
-#include <stdint.h>
+#include "./types.h"
 
 namespace brotli {
 
 // Estimates how many bits the literals in the interval [pos, pos + len) in the
 // ringbuffer (data, mask) will take entropy coded and writes these estimates
-// to the ringbuffer (cost, mask).
+// to the cost[0..len) array.
 void EstimateBitCostsForLiterals(size_t pos, size_t len, size_t mask,
-                                 size_t cost_mask, const uint8_t *data,
-                                 float *cost);
-
-void EstimateBitCostsForLiteralsUTF8(size_t pos, size_t len, size_t mask,
-                                     size_t cost_mask, const uint8_t *data,
-                                     float *cost);
+                                 const uint8_t *data, float *cost);
 
 }  // namespace brotli
 

data/vendor/brotli/enc/metablock.cc

@@ -1,17 +1,9 @@
-// Copyright 2015 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 2015 Google Inc. All Rights Reserved.
+
+   Distributed under MIT license.
+   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+*/
+
 // Algorithms for distributing the literals and commands of a metablock between
 // block types and contexts.
 
@@ -64,7 +56,7 @@ void BuildMetaBlock(const uint8_t* ringbuffer,
                   &distance_histograms);
 
   // Histogram ids need to fit in one byte.
-  static const int kMaxNumberOfHistograms = 256;
+  static const size_t kMaxNumberOfHistograms = 256;
 
   mb->literal_histograms = literal_histograms;
   ClusterHistograms(literal_histograms,
@@ -247,7 +239,7 @@ void BuildMetaBlockGreedy(const uint8_t* ringbuffer,
                           size_t n_commands,
                           MetaBlockSplit* mb) {
   int num_literals = 0;
-  for (int i = 0; i < n_commands; ++i) {
+  for (size_t i = 0; i < n_commands; ++i) {
     num_literals += commands[i].insert_len_;
   }
 
@@ -255,13 +247,13 @@ 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, n_commands,
+      kNumCommandPrefixes, 1024, 500.0, static_cast<int>(n_commands),
       &mb->command_split, &mb->command_histograms);
   BlockSplitter<HistogramDistance> dist_blocks(
-      64, 512, 100.0, n_commands,
+      64, 512, 100.0, static_cast<int>(n_commands),
       &mb->distance_split, &mb->distance_histograms);
 
-  for (int i = 0; i < n_commands; ++i) {
+  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) {
@@ -473,7 +465,7 @@ void BuildMetaBlockGreedyWithContexts(const uint8_t* ringbuffer,
                                       size_t n_commands,
                                       MetaBlockSplit* mb) {
   int num_literals = 0;
-  for (int i = 0; i < n_commands; ++i) {
+  for (size_t i = 0; i < n_commands; ++i) {
     num_literals += commands[i].insert_len_;
   }
 
@@ -481,13 +473,13 @@ 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, n_commands,
+      kNumCommandPrefixes, 1024, 500.0, static_cast<int>(n_commands),
       &mb->command_split, &mb->command_histograms);
   BlockSplitter<HistogramDistance> dist_blocks(
-      64, 512, 100.0, n_commands,
+      64, 512, 100.0, static_cast<int>(n_commands),
       &mb->distance_split, &mb->distance_histograms);
 
-  for (int i = 0; i < n_commands; ++i) {
+  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) {
@@ -525,17 +517,17 @@ void BuildMetaBlockGreedyWithContexts(const uint8_t* ringbuffer,
 void OptimizeHistograms(int num_direct_distance_codes,
                         int distance_postfix_bits,
                         MetaBlockSplit* mb) {
-  for (int i = 0; i < mb->literal_histograms.size(); ++i) {
+  for (size_t i = 0; i < mb->literal_histograms.size(); ++i) {
     OptimizeHuffmanCountsForRle(256, &mb->literal_histograms[i].data_[0]);
   }
-  for (int i = 0; i < mb->command_histograms.size(); ++i) {
+  for (size_t i = 0; i < mb->command_histograms.size(); ++i) {
     OptimizeHuffmanCountsForRle(kNumCommandPrefixes,
                                 &mb->command_histograms[i].data_[0]);
   }
   int num_distance_codes =
       kNumDistanceShortCodes + num_direct_distance_codes +
       (48 << distance_postfix_bits);
-  for (int i = 0; i < mb->distance_histograms.size(); ++i) {
+  for (size_t i = 0; i < mb->distance_histograms.size(); ++i) {
     OptimizeHuffmanCountsForRle(num_distance_codes,
                                 &mb->distance_histograms[i].data_[0]);
   }

data/vendor/brotli/enc/metablock.h

@@ -1,17 +1,9 @@
-// Copyright 2015 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 2015 Google Inc. All Rights Reserved.
+
+   Distributed under MIT license.
+   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+*/
+
 // Algorithms for distributing the literals and commands of a metablock between
 // block types and contexts.
 

data/vendor/brotli/enc/port.h

@@ -1,23 +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
+*/
+
 // Macros for endianness, branch prediction and unaligned loads and stores.
 
 #ifndef BROTLI_ENC_PORT_H_
 #define BROTLI_ENC_PORT_H_
 
+#include <assert.h>
 #include <string.h>
+#include "./types.h"
 
 #if defined OS_LINUX || defined OS_CYGWIN
 #include <endian.h>
@@ -148,4 +142,10 @@ 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

@@ -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
+*/
+
 // Functions for encoding of integers into prefix codes the amount of extra
 // bits, and the actual values of the extra bits.
 
 #ifndef BROTLI_ENC_PREFIX_H_
 #define BROTLI_ENC_PREFIX_H_
 
-#include <stdint.h>
 #include "./fast_log.h"
+#include "./types.h"
 
 namespace brotli {
 
@@ -63,7 +55,7 @@ inline void PrefixEncodeCopyDistance(int distance_code,
                                      uint16_t* code,
                                      uint32_t* extra_bits) {
   if (distance_code < kNumDistanceShortCodes + num_direct_codes) {
-    *code = distance_code;
+    *code = static_cast<uint16_t>(distance_code);
     *extra_bits = 0;
     return;
   }
@@ -75,8 +67,9 @@ inline void PrefixEncodeCopyDistance(int distance_code,
   int prefix = (distance_code >> bucket) & 1;
   int offset = (2 + prefix) << bucket;
   int nbits = bucket - postfix_bits;
-  *code = kNumDistanceShortCodes + num_direct_codes +
-      ((2 * (nbits - 1) + prefix) << postfix_bits) + postfix;
+  *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);
 }
 

data/vendor/brotli/enc/ringbuffer.h

@@ -1,26 +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
+*/
+
 // Sliding window over the input data.
 
 #ifndef BROTLI_ENC_RINGBUFFER_H_
 #define BROTLI_ENC_RINGBUFFER_H_
 
-#include <stddef.h>
-#include <stdint.h>
 
 #include "./port.h"
+#include "./types.h"
 
 namespace brotli {
 
@@ -32,12 +23,12 @@ namespace brotli {
 class RingBuffer {
  public:
   RingBuffer(int window_bits, int tail_bits)
-      : window_bits_(window_bits),
-        mask_((1 << window_bits) - 1),
-        tail_size_(1 << tail_bits),
+      : size_((size_t(1) << window_bits)),
+        mask_((size_t(1) << window_bits) - 1),
+        tail_size_(size_t(1) << tail_bits),
         pos_(0) {
     static const int kSlackForEightByteHashingEverywhere = 7;
-    const int buflen = (1 << window_bits_) + tail_size_;
+    const size_t buflen = size_ + tail_size_;
     buffer_ = new uint8_t[buflen + kSlackForEightByteHashingEverywhere];
     for (int i = 0; i < kSlackForEightByteHashingEverywhere; ++i) {
       buffer_[buflen + i] = 0;
@@ -53,17 +44,17 @@ class RingBuffer {
     // The length of the writes is limited so that we do not need to worry
     // about a write
     WriteTail(bytes, n);
-    if (PREDICT_TRUE(masked_pos + n <= (1 << window_bits_))) {
+    if (PREDICT_TRUE(masked_pos + n <= size_)) {
       // A single write fits.
       memcpy(&buffer_[masked_pos], bytes, n);
     } else {
       // Split into two writes.
       // Copy into the end of the buffer, including the tail buffer.
       memcpy(&buffer_[masked_pos], bytes,
-             std::min(n, ((1 << window_bits_) + tail_size_) - masked_pos));
-      // Copy into the begining of the buffer
-      memcpy(&buffer_[0], bytes + ((1 << window_bits_) - masked_pos),
-             n - ((1 << window_bits_) - masked_pos));
+             std::min(n, (size_ + tail_size_) - masked_pos));
+      // Copy into the beginning of the buffer
+      memcpy(&buffer_[0], bytes + (size_ - masked_pos),
+             n - (size_ - masked_pos));
     }
     pos_ += n;
   }
@@ -86,13 +77,13 @@ class RingBuffer {
     const size_t masked_pos = pos_ & mask_;
     if (PREDICT_FALSE(masked_pos < tail_size_)) {
       // Just fill the tail buffer with the beginning data.
-      const size_t p = (1 << window_bits_) + masked_pos;
+      const size_t p = size_ + masked_pos;
       memcpy(&buffer_[p], bytes, std::min(n, tail_size_ - masked_pos));
     }
   }
 
   // Size of the ringbuffer is (1 << window_bits) + tail_size_.
-  const int window_bits_;
+  const size_t size_;
   const size_t mask_;
   const size_t tail_size_;
 

data/vendor/brotli/enc/static_dict.cc

@@ -1,3 +1,9 @@
+/* Copyright 2013 Google Inc. All Rights Reserved.
+
+   Distributed under MIT license.
+   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+*/
+
 #include "./static_dict.h"
 
 #include <algorithm>
@@ -76,7 +82,7 @@ bool FindAllStaticDictionaryMatches(const uint8_t* data,
           AddMatch(id, l, l, matches);
           found_match = true;
         }
-        // Transfroms "" + kOmitLast1 + "" and "" + kOmitLast1 + "ing "
+        // Transforms "" + kOmitLast1 + "" and "" + kOmitLast1 + "ing "
         if (matchlen >= l - 1) {
           AddMatch(id + 12 * n, l - 1, l, matches);
           if (l + 2 < max_length &&

data/vendor/brotli/enc/static_dict.h

@@ -1,23 +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
+*/
+
 // Class to model the static dictionary.
 
 #ifndef BROTLI_ENC_STATIC_DICT_H_
 #define BROTLI_ENC_STATIC_DICT_H_
 
-#include <stdint.h>
+#include "./types.h"
 
 namespace brotli {
 

data/vendor/brotli/enc/static_dict_lut.h

@@ -1,23 +1,15 @@
-// Copyright 2015 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 2015 Google Inc. All Rights Reserved.
+
+   Distributed under MIT license.
+   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+*/
+
 // Lookup table for static dictionary and transforms.
 
 #ifndef BROTLI_ENC_DICTIONARY_LUT_H_
 #define BROTLI_ENC_DICTIONARY_LUT_H_
 
-#include <stdint.h>
+#include "./types.h"
 
 namespace brotli {