brotli 0.1.0 → 0.1.1

data/vendor/brotli/dec/bit_reader.h

@@ -1,16 +1,7 @@
 /* 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.
+   Distributed under MIT license.
+   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
 */
 
 /* Bit reading helpers */
@@ -18,126 +9,179 @@
 #ifndef BROTLI_DEC_BIT_READER_H_
 #define BROTLI_DEC_BIT_READER_H_
 
+#include <stdio.h>
 #include <string.h>
 #include "./port.h"
-#include "./streams.h"
 #include "./types.h"
 
 #if defined(__cplusplus) || defined(c_plusplus)
 extern "C" {
 #endif
 
-#define BROTLI_MAX_NUM_BIT_READ   25
-#define BROTLI_READ_SIZE          1024
-#define BROTLI_IMPLICIT_ZEROES    128
-#define BROTLI_IBUF_SIZE          (BROTLI_READ_SIZE + BROTLI_IMPLICIT_ZEROES)
-#define BROTLI_IBUF_MASK          (BROTLI_READ_SIZE - 1)
+#if (BROTLI_64_BITS)
+#define BROTLI_SHORT_FILL_BIT_WINDOW_READ 4
+typedef uint64_t reg_t;
+#else
+#define BROTLI_SHORT_FILL_BIT_WINDOW_READ 2
+typedef uint32_t reg_t;
+#endif
+
+static const uint32_t kBitMask[33] = { 0x0000,
+    0x00000001, 0x00000003, 0x00000007, 0x0000000F,
+    0x0000001F, 0x0000003F, 0x0000007F, 0x000000FF,
+    0x000001FF, 0x000003FF, 0x000007FF, 0x00000FFF,
+    0x00001FFF, 0x00003FFF, 0x00007FFF, 0x0000FFFF,
+    0x0001FFFF, 0x0003FFFF, 0x0007FFFF, 0x000FFFFF,
+    0x001FFFFF, 0x003FFFFF, 0x007FFFFF, 0x00FFFFFF,
+    0x01FFFFFF, 0x03FFFFFF, 0x07FFFFFF, 0x0FFFFFFF,
+    0x1FFFFFFF, 0x3FFFFFFF, 0x7FFFFFFF, 0xFFFFFFFF
+};
 
-/* Masking with this expression turns to a single "Unsigned Bit Field Extract"
-   UBFX instruction on ARM. */
-static BROTLI_INLINE uint32_t BitMask(int n) { return ~((0xffffffff) << n); }
+static BROTLI_INLINE uint32_t BitMask(uint32_t n) {
+  if (IS_CONSTANT(n) || BROTLI_HAS_UBFX) {
+    /* Masking with this expression turns to a single
+       "Unsigned Bit Field Extract" UBFX instruction on ARM. */
+    return ~((0xffffffffU) << n);
+  } else {
+    return kBitMask[n];
+  }
+}
 
 typedef struct {
-#if (BROTLI_64_BITS_LITTLE_ENDIAN)
-  uint64_t    val_;          /* pre-fetched bits */
-#else
-  uint32_t    val_;          /* pre-fetched bits */
-#endif
+  reg_t       val_;          /* pre-fetched bits */
   uint32_t    bit_pos_;      /* current bit-reading position in val_ */
-  uint8_t*    next_in;       /* the byte we're reading from */
-  uint32_t    avail_in;
-  int         eos_;          /* input stream is finished */
-  BrotliInput input_;        /* input callback */
-
-  /* Input byte buffer, consist of a ringbuffer and a "slack" region where */
-  /* bytes from the start of the ringbuffer are copied. */
-  uint8_t buf_[BROTLI_IBUF_SIZE];
+  const uint8_t* next_in;    /* the byte we're reading from */
+  size_t      avail_in;
 } BrotliBitReader;
 
-/* Initializes the bitreader fields. After this, BrotliReadInput then
-   BrotliWarmupBitReader must be used. */
-void BrotliInitBitReader(BrotliBitReader* const br, BrotliInput input);
+typedef struct {
+  reg_t    val_;
+  uint32_t bit_pos_;
+  const uint8_t* next_in;
+  size_t   avail_in;
+} BrotliBitReaderState;
 
-/* Initializes bit reading and bit position with the first input data available.
-   Requires that there is enough input available (BrotliCheckInputAmount). */
-void BrotliWarmupBitReader(BrotliBitReader* const br);
+/* Initializes the bitreader fields. */
+void BrotliInitBitReader(BrotliBitReader* const br);
 
-/* Pulls data from the input to the the read buffer.
+/* Ensures that accumulator is not empty. May consume one byte of input.
+   Returns 0 if data is required but there is no input available.
+   For BROTLI_BUILD_PORTABLE this function also prepares bit reader for aligned
+   reading. */
+int BrotliWarmupBitReader(BrotliBitReader* const br);
 
-   Returns 0 if one of:
-    - the input callback returned an error, or
-    - there is no more input and the position is past the end of the stream.
-    - finish is false and less than BROTLI_READ_SIZE are available - a next call
-      when more data is available makes it continue including the partially read
-      data
+static BROTLI_INLINE void BrotliBitReaderSaveState(
+    BrotliBitReader* const from, BrotliBitReaderState* to) {
+  to->val_ = from->val_;
+  to->bit_pos_ = from->bit_pos_;
+  to->next_in = from->next_in;
+  to->avail_in = from->avail_in;
+}
 
-   If finish is true and the end of the stream is reached,
-   BROTLI_IMPLICIT_ZEROES additional zero bytes are copied to the ringbuffer.
-*/
-static BROTLI_INLINE int BrotliReadInput(
-    BrotliBitReader* const br, int finish) {
-  if (PREDICT_FALSE(br->eos_)) {
-    return 0;
-  } else {
-    size_t i;
-    int bytes_read;
-    if (br->next_in != br->buf_) {
-      for (i = 0; i < br->avail_in; i++) {
-        br->buf_[i] = br->next_in[i];
-      }
-      br->next_in = br->buf_;
-    }
-    bytes_read = BrotliRead(br->input_, br->next_in + br->avail_in,
-        (size_t)(BROTLI_READ_SIZE - br->avail_in));
-    if (bytes_read < 0) {
-      return 0;
-    }
-    br->avail_in += (uint32_t)bytes_read;
-    if (br->avail_in < BROTLI_READ_SIZE) {
-      if (!finish) {
-        return 0;
-      }
-      br->eos_ = 1;
-      /* Store BROTLI_IMPLICIT_ZEROES bytes of zero after the stream end. */
-      memset(br->next_in + br->avail_in, 0, BROTLI_IMPLICIT_ZEROES);
-      br->avail_in += BROTLI_IMPLICIT_ZEROES;
-    }
-    return 1;
-  }
+static BROTLI_INLINE void BrotliBitReaderRestoreState(
+    BrotliBitReader* const to, BrotliBitReaderState* from) {
+  to->val_ = from->val_;
+  to->bit_pos_ = from->bit_pos_;
+  to->next_in = from->next_in;
+  to->avail_in = from->avail_in;
+}
+
+static BROTLI_INLINE uint32_t BrotliGetAvailableBits(
+    const BrotliBitReader* br) {
+  return (BROTLI_64_BITS ? 64 : 32) - br->bit_pos_;
 }
 
 /* Returns amount of unread bytes the bit reader still has buffered from the
    BrotliInput, including whole bytes in br->val_. */
 static BROTLI_INLINE size_t BrotliGetRemainingBytes(BrotliBitReader* br) {
-  return br->avail_in + sizeof(br->val_) - (br->bit_pos_ >> 3);
+  return br->avail_in + (BrotliGetAvailableBits(br) >> 3);
 }
 
 /* Checks if there is at least num bytes left in the input ringbuffer (excluding
-   the bits remaining in br->val_). The maximum value for num is
-   BROTLI_IMPLICIT_ZEROES bytes. */
+   the bits remaining in br->val_). */
 static BROTLI_INLINE int BrotliCheckInputAmount(
     BrotliBitReader* const br, size_t num) {
   return br->avail_in >= num;
 }
 
-/* Guarantees that there are at least n_bits in the buffer.
-   n_bits should be in the range [1..24] */
+static BROTLI_INLINE uint16_t BrotliLoad16LE(const uint8_t* in) {
+  if (BROTLI_LITTLE_ENDIAN) {
+    return *((const uint16_t*)in);
+  } else if (BROTLI_BIG_ENDIAN) {
+    uint16_t value = *((const uint16_t*)in);
+    return (uint16_t)(
+        ((value & 0xFFU) << 8) |
+        ((value & 0xFF00U) >> 8));
+  } else {
+    return (uint16_t)(in[0] | (in[1] << 8));
+  }
+}
+
+static BROTLI_INLINE uint32_t BrotliLoad32LE(const uint8_t* in) {
+  if (BROTLI_LITTLE_ENDIAN) {
+    return *((const uint32_t*)in);
+  } else if (BROTLI_BIG_ENDIAN) {
+    uint32_t value = *((const uint32_t*)in);
+    return ((value & 0xFFU) << 24) | ((value & 0xFF00U) << 8) |
+        ((value & 0xFF0000U) >> 8) | ((value & 0xFF000000U) >> 24);
+  } else {
+    uint32_t value = (uint32_t)(*(in++));
+    value |= (uint32_t)(*(in++)) << 8;
+    value |= (uint32_t)(*(in++)) << 16;
+    value |= (uint32_t)(*(in++)) << 24;
+    return value;
+  }
+}
+
+#if (BROTLI_64_BITS)
+static BROTLI_INLINE uint64_t BrotliLoad64LE(const uint8_t* in) {
+  if (BROTLI_LITTLE_ENDIAN) {
+    return *((const uint64_t*)in);
+  } else if (BROTLI_BIG_ENDIAN) {
+    uint64_t value = *((const uint64_t*)in);
+    return
+        ((value & 0xFFU) << 56) |
+        ((value & 0xFF00U) << 40) |
+        ((value & 0xFF0000U) << 24) |
+        ((value & 0xFF000000U) << 8) |
+        ((value & 0xFF00000000U) >> 8) |
+        ((value & 0xFF0000000000U) >> 24) |
+        ((value & 0xFF000000000000U) >> 40) |
+        ((value & 0xFF00000000000000U) >> 56);
+  } else {
+    uint64_t value = (uint64_t)(*(in++));
+    value |= (uint64_t)(*(in++)) << 8;
+    value |= (uint64_t)(*(in++)) << 16;
+    value |= (uint64_t)(*(in++)) << 24;
+    value |= (uint64_t)(*(in++)) << 32;
+    value |= (uint64_t)(*(in++)) << 40;
+    value |= (uint64_t)(*(in++)) << 48;
+    value |= (uint64_t)(*(in++)) << 56;
+    return value;
+  }
+}
+#endif
+
+/* Guarantees that there are at least n_bits + 1 bits in accumulator.
+   Precondition: accumulator contains at least 1 bit.
+   n_bits should be in the range [1..24] for regular build. For portable
+   non-64-bit little endian build only 16 bits are safe to request. */
 static BROTLI_INLINE void BrotliFillBitWindow(
-    BrotliBitReader* const br, int n_bits) {
-#if (BROTLI_64_BITS_LITTLE_ENDIAN)
-  if (IS_CONSTANT(n_bits) && n_bits <= 8) {
+    BrotliBitReader* const br, uint32_t n_bits) {
+#if (BROTLI_64_BITS)
+  if (!BROTLI_ALIGNED_READ && IS_CONSTANT(n_bits) && (n_bits <= 8)) {
     if (br->bit_pos_ >= 56) {
       br->val_ >>= 56;
       br->bit_pos_ ^= 56;  /* here same as -= 56 because of the if condition */
-      br->val_ |= (*(const uint64_t*)(br->next_in)) << 8;
+      br->val_ |= BrotliLoad64LE(br->next_in) << 8;
       br->avail_in -= 7;
       br->next_in += 7;
     }
-  } else if (IS_CONSTANT(n_bits) && n_bits <= 16) {
+  } else if (!BROTLI_ALIGNED_READ && IS_CONSTANT(n_bits) && (n_bits <= 16)) {
     if (br->bit_pos_ >= 48) {
       br->val_ >>= 48;
       br->bit_pos_ ^= 48;  /* here same as -= 48 because of the if condition */
-      br->val_ |= (*(const uint64_t*)(br->next_in)) << 16;
+      br->val_ |= BrotliLoad64LE(br->next_in) << 16;
       br->avail_in -= 6;
       br->next_in += 6;
     }
@@ -145,17 +189,17 @@ static BROTLI_INLINE void BrotliFillBitWindow(
     if (br->bit_pos_ >= 32) {
       br->val_ >>= 32;
       br->bit_pos_ ^= 32;  /* here same as -= 32 because of the if condition */
-      br->val_ |= ((uint64_t)(*(const uint32_t*)(br->next_in))) << 32;
-      br->avail_in -= 4;
-      br->next_in += 4;
+      br->val_ |= ((uint64_t)BrotliLoad32LE(br->next_in)) << 32;
+      br->avail_in -= BROTLI_SHORT_FILL_BIT_WINDOW_READ;
+      br->next_in += BROTLI_SHORT_FILL_BIT_WINDOW_READ;
     }
   }
-#elif (BROTLI_LITTLE_ENDIAN)
-  if (IS_CONSTANT(n_bits) && n_bits <= 8) {
+#else
+  if (!BROTLI_ALIGNED_READ && IS_CONSTANT(n_bits) && (n_bits <= 8)) {
     if (br->bit_pos_ >= 24) {
       br->val_ >>= 24;
       br->bit_pos_ ^= 24;  /* here same as -= 24 because of the if condition */
-      br->val_ |= (*(const uint32_t*)(br->next_in)) << 8;
+      br->val_ |= BrotliLoad32LE(br->next_in) << 8;
       br->avail_in -= 3;
       br->next_in += 3;
     }
@@ -163,90 +207,175 @@ static BROTLI_INLINE void BrotliFillBitWindow(
     if (br->bit_pos_ >= 16) {
       br->val_ >>= 16;
       br->bit_pos_ ^= 16;  /* here same as -= 16 because of the if condition */
-      br->val_ |= ((uint32_t)(*(const uint16_t*)(br->next_in))) << 16;
-      br->avail_in -= 2;
-      br->next_in += 2;
-    }
-    if (!IS_CONSTANT(n_bits) || (n_bits > 16)) {
-      if (br->bit_pos_ >= 8) {
-        br->val_ >>= 8;
-        br->bit_pos_ ^= 8;  /* here same as -= 8 because of the if condition */
-        br->val_ |= ((uint32_t)*br->next_in) << 24;
-        --br->avail_in;
-        ++br->next_in;
-      }
+      br->val_ |= ((uint32_t)BrotliLoad16LE(br->next_in)) << 16;
+      br->avail_in -= BROTLI_SHORT_FILL_BIT_WINDOW_READ;
+      br->next_in += BROTLI_SHORT_FILL_BIT_WINDOW_READ;
     }
   }
+#endif
+}
+
+/* Mosltly like BrotliFillBitWindow, but guarantees only 16 bits and reads no
+   more than BROTLI_SHORT_FILL_BIT_WINDOW_READ bytes of input. */
+static BROTLI_INLINE void BrotliFillBitWindow16(BrotliBitReader* const br) {
+  BrotliFillBitWindow(br, 17);
+}
+
+/* Pulls one byte of input to accumulator. */
+static BROTLI_INLINE int BrotliPullByte(BrotliBitReader* const br) {
+  if (br->avail_in == 0) {
+    return 0;
+  }
+  br->val_ >>= 8;
+#if (BROTLI_64_BITS)
+    br->val_ |= ((uint64_t)*br->next_in) << 56;
 #else
-  while (br->bit_pos_ >= 8) {
-    br->val_ >>= 8;
     br->val_ |= ((uint32_t)*br->next_in) << 24;
-    br->bit_pos_ -= 8;
-    --br->avail_in;
-    ++br->next_in;
-  }
 #endif
+  br->bit_pos_ -= 8;
+  --br->avail_in;
+  ++br->next_in;
+  return 1;
 }
 
-/* Like BrotliGetBits, but does not mask the result, it is only guaranteed
-that it has minimum n_bits. */
-static BROTLI_INLINE uint32_t BrotliGetBitsUnmasked(
-    BrotliBitReader* const br, int n_bits) {
-  BrotliFillBitWindow(br, n_bits);
-  return (uint32_t)(br->val_ >> br->bit_pos_);
+/* Returns currently available bits.
+   The number of valid bits could be calclulated by BrotliGetAvailableBits. */
+static BROTLI_INLINE reg_t BrotliGetBitsUnmasked(BrotliBitReader* const br) {
+  return br->val_ >> br->bit_pos_;
+}
+
+/* Like BrotliGetBits, but does not mask the result.
+   The result contains at least 16 valid bits. */
+static BROTLI_INLINE uint32_t BrotliGet16BitsUnmasked(
+    BrotliBitReader* const br) {
+  BrotliFillBitWindow(br, 16);
+  return (uint32_t)BrotliGetBitsUnmasked(br);
 }
 
 /* Returns the specified number of bits from br without advancing bit pos. */
 static BROTLI_INLINE uint32_t BrotliGetBits(
-    BrotliBitReader* const br, int n_bits) {
+    BrotliBitReader* const br, uint32_t n_bits) {
   BrotliFillBitWindow(br, n_bits);
-  return (uint32_t)(br->val_ >> br->bit_pos_) & BitMask(n_bits);
+  return (uint32_t)BrotliGetBitsUnmasked(br) & BitMask(n_bits);
+}
+
+/* Tries to peek the specified amount of bits. Returns 0, if there is not
+   enough input. */
+static BROTLI_INLINE int BrotliSafeGetBits(
+  BrotliBitReader* const br, uint32_t n_bits, uint32_t* val) {
+  while (BrotliGetAvailableBits(br) < n_bits) {
+    if (!BrotliPullByte(br)) {
+      return 0;
+    }
+  }
+  *val = (uint32_t)BrotliGetBitsUnmasked(br) & BitMask(n_bits);
+  return 1;
 }
 
 /* Advances the bit pos by n_bits. */
 static BROTLI_INLINE void BrotliDropBits(
-    BrotliBitReader* const br, int n_bits) {
-  br->bit_pos_ += (uint32_t)n_bits;
+    BrotliBitReader* const br, uint32_t n_bits) {
+  br->bit_pos_ += n_bits;
 }
 
-/* Reads the specified number of bits from br and advances the bit pos. */
-static BROTLI_INLINE uint32_t BrotliReadBits(
-    BrotliBitReader* const br, int n_bits) {
-  uint32_t val;
-  BrotliFillBitWindow(br, n_bits);
-  val = (uint32_t)(br->val_ >> br->bit_pos_) & BitMask(n_bits);
+static BROTLI_INLINE void BrotliBitReaderUnload(BrotliBitReader* br) {
+  uint32_t unused_bytes = BrotliGetAvailableBits(br) >> 3;
+  uint32_t unused_bits = unused_bytes << 3;
+  br->avail_in += unused_bytes;
+  br->next_in -= unused_bytes;
+  br->val_ <<= unused_bits;
+  br->bit_pos_ += unused_bits;
+}
+
+/* Reads the specified number of bits from br and advances the bit pos.
+   Precondition: accumulator MUST contain at least n_bits. */
+static BROTLI_INLINE void BrotliTakeBits(
+  BrotliBitReader* const br, uint32_t n_bits, uint32_t* val) {
+  *val = (uint32_t)BrotliGetBitsUnmasked(br) & BitMask(n_bits);
 #ifdef BROTLI_DECODE_DEBUG
   printf("[BrotliReadBits]  %d %d %d val: %6x\n",
-         (int)br->avail_in, (int)br->bit_pos_, n_bits, val);
+         (int)br->avail_in, (int)br->bit_pos_, n_bits, (int)*val);
 #endif
-  br->bit_pos_ += (uint32_t)n_bits;
-  return val;
+  BrotliDropBits(br, n_bits);
+}
+
+/* Reads the specified number of bits from br and advances the bit pos.
+   Assumes that there is enough input to perform BrotliFillBitWindow. */
+static BROTLI_INLINE uint32_t BrotliReadBits(
+    BrotliBitReader* const br, uint32_t n_bits) {
+  if (BROTLI_64_BITS || (n_bits <= 16)) {
+    uint32_t val;
+    BrotliFillBitWindow(br, n_bits);
+    BrotliTakeBits(br, n_bits, &val);
+    return val;
+  } else {
+    uint32_t low_val;
+    uint32_t high_val;
+    BrotliFillBitWindow(br, 16);
+    BrotliTakeBits(br, 16, &low_val);
+    BrotliFillBitWindow(br, 8);
+    BrotliTakeBits(br, n_bits - 16, &high_val);
+    return low_val | (high_val << 16);
+  }
+}
+
+/* Tries to read the specified amount of bits. Returns 0, if there is not
+   enough input. n_bits MUST be positive. */
+static BROTLI_INLINE int BrotliSafeReadBits(
+  BrotliBitReader* const br, uint32_t n_bits, uint32_t* val) {
+  while (BrotliGetAvailableBits(br) < n_bits) {
+    if (!BrotliPullByte(br)) {
+      return 0;
+    }
+  }
+  BrotliTakeBits(br, n_bits, val);
+  return 1;
 }
 
 /* Advances the bit reader position to the next byte boundary and verifies
    that any skipped bits are set to zero. */
 static BROTLI_INLINE int BrotliJumpToByteBoundary(BrotliBitReader* br) {
-  uint32_t new_bit_pos = (br->bit_pos_ + 7) & (uint32_t)(~7UL);
-  uint32_t pad_bits = BrotliReadBits(br, (int)(new_bit_pos - br->bit_pos_));
+  uint32_t pad_bits_count = BrotliGetAvailableBits(br) & 0x7;
+  uint32_t pad_bits = 0;
+  if (pad_bits_count != 0) {
+    BrotliTakeBits(br, pad_bits_count, &pad_bits);
+  }
   return pad_bits == 0;
 }
 
+/* Peeks a byte at specified offset.
+   Precondition: bit reader is parked to a byte boundary.
+   Returns -1 if operation is not feasible. */
+static BROTLI_INLINE int BrotliPeekByte(BrotliBitReader* br, size_t offset) {
+  uint32_t available_bits = BrotliGetAvailableBits(br);
+  size_t bytes_left = available_bits >> 3;
+  if (available_bits & 7) {
+    return -1;
+  }
+  if (offset < bytes_left) {
+    return (BrotliGetBitsUnmasked(br) >> (unsigned)(offset << 3)) & 0xFF;
+  }
+  offset -= bytes_left;
+  if (offset < br->avail_in) {
+    return br->next_in[offset];
+  }
+  return -1;
+}
+
 /* Copies remaining input bytes stored in the bit reader to the output. Value
    num may not be larger than BrotliGetRemainingBytes. The bit reader must be
    warmed up again after this. */
 static BROTLI_INLINE void BrotliCopyBytes(uint8_t* dest,
                                           BrotliBitReader* br, size_t num) {
-  while (br->bit_pos_ + 8 <= (BROTLI_64_BITS_LITTLE_ENDIAN ? 64 : 32)
-      && num > 0) {
-    *dest = (uint8_t)(br->val_ >> br->bit_pos_);
-    br->bit_pos_ += 8;
+  while (BrotliGetAvailableBits(br) >= 8 && num > 0) {
+    *dest = (uint8_t)BrotliGetBitsUnmasked(br);
+    BrotliDropBits(br, 8);
     ++dest;
     --num;
   }
   memcpy(dest, br->next_in, num);
-  br->avail_in -= (uint32_t)num;
+  br->avail_in -= num;
   br->next_in += num;
-  br->bit_pos_ = 0;
 }
 
 #if defined(__cplusplus) || defined(c_plusplus)

data/vendor/brotli/dec/context.h

@@ -1,16 +1,7 @@
 /* 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.
+   Distributed under MIT license.
+   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
 */
 
 /* Lookup table to map the previous two bytes to a context id.
@@ -22,7 +13,7 @@
      CONTEXT_SIGNED: second-order context model tuned for signed integers.
 
    The context id for the UTF8 context model is calculated as follows. If p1
-   and p2 are the previous two bytes, we calcualte the context as
+   and p2 are the previous two bytes, we calculate the context as
 
      context = kContextLookup[p1] | kContextLookup[p2 + 256].