brotli 0.1.8 → 0.2.0

data/vendor/brotli/{enc → c/enc}/brotli_bit_stream.h

@@ -16,7 +16,7 @@
 #ifndef BROTLI_ENC_BROTLI_BIT_STREAM_H_
 #define BROTLI_ENC_BROTLI_BIT_STREAM_H_
 
-#include "../common/types.h"
+#include <brotli/types.h>
 #include "./command.h"
 #include "./context.h"
 #include "./entropy_encode.h"
@@ -96,10 +96,6 @@ BROTLI_INTERNAL void BrotliStoreUncompressedMetaBlock(
     BROTLI_BOOL is_final_block, const uint8_t* input, size_t position,
     size_t mask, size_t len, size_t* storage_ix, uint8_t* storage);
 
-/* Stores an empty metadata meta-block and syncs to a byte boundary. */
-BROTLI_INTERNAL void BrotliStoreSyncMetaBlock(size_t* storage_ix,
-                                              uint8_t* storage);
-
 #if defined(__cplusplus) || defined(c_plusplus)
 }  /* extern "C" */
 #endif

data/vendor/brotli/{enc → c/enc}/cluster.c

@@ -8,7 +8,7 @@
 
 #include "./cluster.h"
 
-#include "../common/types.h"
+#include <brotli/types.h>
 #include "./bit_cost.h"  /* BrotliPopulationCost */
 #include "./fast_log.h"
 #include "./histogram.h"

data/vendor/brotli/{enc → c/enc}/cluster.h

@@ -9,7 +9,7 @@
 #ifndef BROTLI_ENC_CLUSTER_H_
 #define BROTLI_ENC_CLUSTER_H_
 
-#include "../common/types.h"
+#include <brotli/types.h>
 #include "./histogram.h"
 #include "./memory.h"
 #include "./port.h"

data/vendor/brotli/{enc → c/enc}/cluster_inc.h

@@ -17,6 +17,8 @@ BROTLI_INTERNAL void FN(BrotliCompareAndPushToQueue)(
     size_t* num_pairs) CODE({
   BROTLI_BOOL is_good_pair = BROTLI_FALSE;
   HistogramPair p;
+  p.idx1 = p.idx2 = 0;
+  p.cost_diff = p.cost_combo = 0;
   if (idx1 == idx2) {
     return;
   }

data/vendor/brotli/{enc → c/enc}/command.h

@@ -9,8 +9,9 @@
 #ifndef BROTLI_ENC_COMMAND_H_
 #define BROTLI_ENC_COMMAND_H_
 
-#include "../common/types.h"
-#include "../common/port.h"
+#include "../common/constants.h"
+#include <brotli/port.h>
+#include <brotli/types.h>
 #include "./fast_log.h"
 #include "./prefix.h"
 
@@ -64,11 +65,17 @@ static BROTLI_INLINE uint16_t CombineLengthCodes(
   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 uint16_t cells[9] = { 128u, 192u, 384u, 256u, 320u, 512u,
-                                       448u, 576u, 640u };
-    return cells[(copycode >> 3) + 3 * (inscode >> 3)] | bits64;
+    /* Specification: 5 Encoding of ... (last table) */
+    /* offset = 2 * index, where index is in range [0..8] */
+    int offset = 2 * ((copycode >> 3) + 3 * (inscode >> 3));
+    /* All values in specification are K * 64,
+       where   K = [2, 3, 6, 4, 5, 8, 7, 9, 10],
+           i + 1 = [1, 2, 3, 4, 5, 6, 7, 8,  9],
+       K - i - 1 = [1, 1, 3, 0, 0, 2, 0, 1,  2] = D.
+       All values in D require only 2 bits to encode.
+       Magic constant is shifted 6 bits left, to avoid final multiplication. */
+    offset = (offset << 5) + 0x40 + ((0x520D40 >> offset) & 0xC0);
+    return (uint16_t)offset | bits64;
   }
 }
 
@@ -107,35 +114,44 @@ typedef struct Command {
 
 /* distance_code is e.g. 0 for same-as-last short code, or 16 for offset 1. */
 static BROTLI_INLINE void InitCommand(Command* self, size_t insertlen,
-    size_t copylen, size_t copylen_code, size_t distance_code) {
+    size_t copylen, int copylen_code_delta, size_t distance_code) {
+  /* Don't rely on signed int representation, use honest casts. */
+  uint32_t delta = (uint8_t)((int8_t)copylen_code_delta);
   self->insert_len_ = (uint32_t)insertlen;
-  self->copy_len_ = (uint32_t)(copylen | ((copylen_code ^ copylen) << 24));
+  self->copy_len_ = (uint32_t)(copylen | (delta << 24));
   /* The distance prefix and extra bits are stored in this Command as if
      npostfix and ndirect were 0, they are only recomputed later after the
      clustering if needed. */
   PrefixEncodeCopyDistance(
       distance_code, 0, 0, &self->dist_prefix_, &self->dist_extra_);
   GetLengthCode(
-      insertlen, copylen_code, TO_BROTLI_BOOL(self->dist_prefix_ == 0),
-      &self->cmd_prefix_);
+      insertlen, (size_t)((int)copylen + copylen_code_delta),
+      TO_BROTLI_BOOL(self->dist_prefix_ == 0), &self->cmd_prefix_);
 }
 
 static BROTLI_INLINE void InitInsertCommand(Command* self, size_t insertlen) {
   self->insert_len_ = (uint32_t)insertlen;
   self->copy_len_ = 4 << 24;
   self->dist_extra_ = 0;
-  self->dist_prefix_ = 16;
+  self->dist_prefix_ = BROTLI_NUM_DISTANCE_SHORT_CODES;
   GetLengthCode(insertlen, 4, BROTLI_FALSE, &self->cmd_prefix_);
 }
 
-static BROTLI_INLINE uint32_t CommandDistanceCode(const Command* self) {
-  if (self->dist_prefix_ < 16) {
+static BROTLI_INLINE uint32_t CommandRestoreDistanceCode(const Command* self) {
+  if (self->dist_prefix_ < BROTLI_NUM_DISTANCE_SHORT_CODES) {
     return self->dist_prefix_;
   } else {
     uint32_t nbits = self->dist_extra_ >> 24;
     uint32_t extra = self->dist_extra_ & 0xffffff;
-    uint32_t prefix = self->dist_prefix_ - 12u - 2u * nbits;
-    return (prefix << nbits) + extra + 12;
+    /* It is assumed that the distance was first encoded with NPOSTFIX = 0 and
+       NDIRECT = 0, so the code itself is of this form:
+         BROTLI_NUM_DISTANCE_SHORT_CODES + 2 * (nbits - 1) + prefix_bit
+       Therefore, the following expression results in (2 + prefix_bit). */
+    uint32_t prefix =
+        self->dist_prefix_ + 4u - BROTLI_NUM_DISTANCE_SHORT_CODES - 2u * nbits;
+    /* Subtract 4 for offset (Chapter 4.) and
+       increase by BROTLI_NUM_DISTANCE_SHORT_CODES - 1  */
+    return (prefix << nbits) + extra + BROTLI_NUM_DISTANCE_SHORT_CODES - 4u;
   }
 }
 
@@ -153,7 +169,8 @@ static BROTLI_INLINE uint32_t CommandCopyLen(const Command* self) {
 }
 
 static BROTLI_INLINE uint32_t CommandCopyLenCode(const Command* self) {
-  return (self->copy_len_ & 0xFFFFFF) ^ (self->copy_len_ >> 24);
+  int32_t delta = (int8_t)((uint8_t)(self->copy_len_ >> 24));
+  return (uint32_t)((int32_t)(self->copy_len_ & 0xFFFFFF) + delta);
 }
 
 #if defined(__cplusplus) || defined(c_plusplus)

data/vendor/brotli/{enc → c/enc}/compress_fragment.c

@@ -16,7 +16,8 @@
 
 #include <string.h>  /* memcmp, memcpy, memset */
 
-#include "../common/types.h"
+#include "../common/constants.h"
+#include <brotli/types.h>
 #include "./brotli_bit_stream.h"
 #include "./entropy_encode.h"
 #include "./fast_log.h"
@@ -30,16 +31,18 @@
 extern "C" {
 #endif
 
+#define MAX_DISTANCE (long)BROTLI_MAX_BACKWARD_LIMIT(18)
+
 /* kHashMul32 multiplier has these properties:
    * The multiplier must be odd. Otherwise we may lose the highest bit.
-   * No long streaks of 1s or 0s.
+   * No long streaks of ones or zeros.
    * 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;
 
 static BROTLI_INLINE uint32_t Hash(const uint8_t* p, size_t shift) {
-  const uint64_t h = (BROTLI_UNALIGNED_LOAD64(p) << 24) * kHashMul32;
+  const uint64_t h = (BROTLI_UNALIGNED_LOAD64LE(p) << 24) * kHashMul32;
   return (uint32_t)(h >> shift);
 }
 
@@ -132,7 +135,7 @@ static void BuildAndStoreCommandPrefixCode(const uint32_t histogram[128],
 
   BrotliCreateHuffmanTree(histogram, 64, 15, tree, depth);
   BrotliCreateHuffmanTree(&histogram[64], 64, 14, tree, &depth[64]);
-  /* We have to jump through a few hoopes here in order to compute
+  /* We have to jump through a few hoops here in order to compute
      the command bits because the symbols are in a different order than in
      the full alphabet. This looks complicated, but having the symbols
      in this order in the command bits saves a few branches in the Emit*
@@ -322,21 +325,20 @@ static BROTLI_INLINE void EmitLiterals(const uint8_t* input, const size_t len,
   }
 }
 
-/* REQUIRES: len <= 1 << 20. */
+/* REQUIRES: len <= 1 << 24. */
 static void BrotliStoreMetaBlockHeader(
     size_t len, BROTLI_BOOL is_uncompressed, size_t* storage_ix,
     uint8_t* storage) {
+  size_t nibbles = 6;
   /* ISLAST */
   BrotliWriteBits(1, 0, storage_ix, storage);
   if (len <= (1U << 16)) {
-    /* MNIBBLES is 4 */
-    BrotliWriteBits(2, 0, storage_ix, storage);
-    BrotliWriteBits(16, len - 1, storage_ix, storage);
-  } else {
-    /* MNIBBLES is 5 */
-    BrotliWriteBits(2, 1, storage_ix, storage);
-    BrotliWriteBits(20, len - 1, storage_ix, storage);
+    nibbles = 4;
+  } else if (len <= (1U << 20)) {
+    nibbles = 5;
   }
+  BrotliWriteBits(2, nibbles - 4, storage_ix, storage);
+  BrotliWriteBits(nibbles * 4, len - 1, storage_ix, storage);
   /* ISUNCOMPRESSED */
   BrotliWriteBits(1, (uint64_t)is_uncompressed, storage_ix, storage);
 }
@@ -421,13 +423,11 @@ static uint32_t kCmdHistoSeed[128] = {
   1, 1, 1, 1, 0, 0, 0, 0,
 };
 
-void BrotliCompressFragmentFast(MemoryManager* m,
-                                const uint8_t* input, size_t input_size,
-                                BROTLI_BOOL is_last,
-                                int* table, size_t table_size,
-                                uint8_t cmd_depth[128], uint16_t cmd_bits[128],
-                                size_t* cmd_code_numbits, uint8_t* cmd_code,
-                                size_t* storage_ix, uint8_t* storage) {
+static BROTLI_INLINE void BrotliCompressFragmentFastImpl(
+    MemoryManager* m, const uint8_t* input, size_t input_size,
+    BROTLI_BOOL is_last, int* table, size_t table_bits, uint8_t cmd_depth[128],
+    uint16_t cmd_bits[128], size_t* cmd_code_numbits, uint8_t* cmd_code,
+    size_t* storage_ix, uint8_t* storage) {
   uint32_t cmd_histo[128];
   const uint8_t* ip_end;
 
@@ -442,7 +442,7 @@ void BrotliCompressFragmentFast(MemoryManager* m,
   static const size_t kFirstBlockSize = 3 << 15;
   static const size_t kMergeBlockSize = 1 << 16;
 
-  const size_t kInputMarginBytes = 16;
+  const size_t kInputMarginBytes = BROTLI_WINDOW_GAP;
   const size_t kMinMatchLen = 5;
 
   const uint8_t* metablock_start = input;
@@ -460,21 +460,7 @@ void BrotliCompressFragmentFast(MemoryManager* m,
   const uint8_t* ip;
   int last_distance;
 
-  const size_t shift = 64u - Log2FloorNonZero(table_size);
-  assert(table_size);
-  assert(table_size <= (1u << 31));
-  /* table must be power of two */
-  assert((table_size & (table_size - 1)) == 0);
-  assert(table_size - 1 ==
-      (size_t)(MAKE_UINT64_T(0xFFFFFFFF, 0xFFFFFF) >> shift));
-
-  if (input_size == 0) {
-    assert(is_last);
-    BrotliWriteBits(1, 1, storage_ix, storage);  /* islast */
-    BrotliWriteBits(1, 1, storage_ix, storage);  /* isempty */
-    *storage_ix = (*storage_ix + 7u) & ~7u;
-    return;
-  }
+  const size_t shift = 64u - table_bits;
 
   BrotliStoreMetaBlockHeader(block_size, 0, storage_ix, storage);
   /* No block splits, no contexts. */
@@ -506,7 +492,7 @@ void BrotliCompressFragmentFast(MemoryManager* m,
   last_distance = -1;
   ip_end = input + block_size;
 
-  if (PREDICT_TRUE(block_size >= kInputMarginBytes)) {
+  if (BROTLI_PREDICT_TRUE(block_size >= kInputMarginBytes)) {
     /* For the last block, we need to keep a 16 bytes margin so that we can be
        sure that all distances are at most window size - 16.
        For all other blocks, we only need to keep a margin of 5 bytes so that
@@ -530,27 +516,27 @@ void BrotliCompressFragmentFast(MemoryManager* m,
          and doesn't bother looking for matches everywhere.
 
          The "skip" variable keeps track of how many bytes there are since the
-         last match; dividing it by 32 (ie. right-shifting by five) gives the
+         last match; dividing it by 32 (i.e. right-shifting by five) gives the
          number of bytes to move ahead for each iteration. */
       uint32_t skip = 32;
 
       const uint8_t* next_ip = ip;
       const uint8_t* candidate;
       assert(next_emit < ip);
-
+trawl:
       do {
         uint32_t hash = next_hash;
         uint32_t bytes_between_hash_lookups = skip++ >> 5;
         assert(hash == Hash(next_ip, shift));
         ip = next_ip;
         next_ip = ip + bytes_between_hash_lookups;
-        if (PREDICT_FALSE(next_ip > ip_limit)) {
+        if (BROTLI_PREDICT_FALSE(next_ip > ip_limit)) {
           goto emit_remainder;
         }
         next_hash = Hash(next_ip, shift);
         candidate = ip - last_distance;
         if (IsMatch(ip, candidate)) {
-          if (PREDICT_TRUE(candidate < ip)) {
+          if (BROTLI_PREDICT_TRUE(candidate < ip)) {
             table[hash] = (int)(ip - base_ip);
             break;
           }
@@ -560,10 +546,14 @@ void BrotliCompressFragmentFast(MemoryManager* m,
         assert(candidate < ip);
 
         table[hash] = (int)(ip - base_ip);
-      } while (PREDICT_TRUE(!IsMatch(ip, candidate)));
+      } while (BROTLI_PREDICT_TRUE(!IsMatch(ip, candidate)));
+
+      /* Check copy distance. If candidate is not feasible, continue search.
+         Checking is done outside of hot loop to reduce overhead. */
+      if (ip - candidate > MAX_DISTANCE) goto trawl;
 
       /* Step 2: Emit the found match together with the literal bytes from
-         "next_emit" to the bit stream, and then see if we can find a next macth
+         "next_emit" to the bit stream, and then see if we can find a next match
          immediately afterwards. Repeat until we find no match for the input
          without emitting some literal bytes. */
 
@@ -577,7 +567,7 @@ void BrotliCompressFragmentFast(MemoryManager* m,
         size_t insert = (size_t)(base - next_emit);
         ip += matched;
         assert(0 == memcmp(base, candidate, matched));
-        if (PREDICT_TRUE(insert < 6210)) {
+        if (BROTLI_PREDICT_TRUE(insert < 6210)) {
           EmitInsertLen(insert, cmd_depth, cmd_bits, cmd_histo,
                         storage_ix, storage);
         } else if (ShouldUseUncompressedMode(metablock_start, next_emit, insert,
@@ -606,14 +596,14 @@ void BrotliCompressFragmentFast(MemoryManager* m,
                                 storage_ix, storage);
 
         next_emit = ip;
-        if (PREDICT_FALSE(ip >= ip_limit)) {
+        if (BROTLI_PREDICT_FALSE(ip >= ip_limit)) {
           goto emit_remainder;
         }
         /* We could immediately start working at ip now, but to improve
            compression we first update "table" with the hashes of some positions
            within the last copy. */
         {
-          uint64_t input_bytes = BROTLI_UNALIGNED_LOAD64(ip - 3);
+          uint64_t input_bytes = BROTLI_UNALIGNED_LOAD64LE(ip - 3);
           uint32_t prev_hash = HashBytesAtOffset(input_bytes, 0, shift);
           uint32_t cur_hash = HashBytesAtOffset(input_bytes, 3, shift);
           table[prev_hash] = (int)(ip - base_ip - 3);
@@ -633,6 +623,7 @@ void BrotliCompressFragmentFast(MemoryManager* m,
         const uint8_t* base = ip;
         size_t matched = 5 + FindMatchLengthWithLimit(
             candidate + 5, ip + 5, (size_t)(ip_end - ip) - 5);
+        if (ip - candidate > MAX_DISTANCE) break;
         ip += matched;
         last_distance = (int)(base - candidate);  /* > 0 */
         assert(0 == memcmp(base, candidate, matched));
@@ -642,14 +633,14 @@ void BrotliCompressFragmentFast(MemoryManager* m,
                      cmd_histo, storage_ix, storage);
 
         next_emit = ip;
-        if (PREDICT_FALSE(ip >= ip_limit)) {
+        if (BROTLI_PREDICT_FALSE(ip >= ip_limit)) {
           goto emit_remainder;
         }
         /* We could immediately start working at ip now, but to improve
            compression we first update "table" with the hashes of some positions
            within the last copy. */
         {
-          uint64_t input_bytes = BROTLI_UNALIGNED_LOAD64(ip - 3);
+          uint64_t input_bytes = BROTLI_UNALIGNED_LOAD64LE(ip - 3);
           uint32_t prev_hash = HashBytesAtOffset(input_bytes, 0, shift);
           uint32_t cur_hash = HashBytesAtOffset(input_bytes, 3, shift);
           table[prev_hash] = (int)(ip - base_ip - 3);
@@ -690,7 +681,7 @@ void BrotliCompressFragmentFast(MemoryManager* m,
   /* Emit the remaining bytes as literals. */
   if (next_emit < ip_end) {
     const size_t insert = (size_t)(ip_end - next_emit);
-    if (PREDICT_TRUE(insert < 6210)) {
+    if (BROTLI_PREDICT_TRUE(insert < 6210)) {
       EmitInsertLen(insert, cmd_depth, cmd_bits, cmd_histo,
                     storage_ix, storage);
       EmitLiterals(next_emit, insert, lit_depth, lit_bits, storage_ix, storage);
@@ -728,11 +719,7 @@ next_block:
     goto emit_commands;
   }
 
-  if (is_last) {
-    BrotliWriteBits(1, 1, storage_ix, storage);  /* islast */
-    BrotliWriteBits(1, 1, storage_ix, storage);  /* isempty */
-    *storage_ix = (*storage_ix + 7u) & ~7u;
-  } else {
+  if (!is_last) {
     /* If this is not the last block, update the command and distance prefix
        codes for the next block and store the compressed forms. */
     cmd_code[0] = 0;
@@ -742,6 +729,63 @@ next_block:
   }
 }
 
+#define FOR_TABLE_BITS_(X) X(9) X(11) X(13) X(15)
+
+#define BAKE_METHOD_PARAM_(B) \
+static BROTLI_NOINLINE void BrotliCompressFragmentFastImpl ## B(             \
+    MemoryManager* m, const uint8_t* input, size_t input_size,               \
+    BROTLI_BOOL is_last, int* table, uint8_t cmd_depth[128],                 \
+    uint16_t cmd_bits[128], size_t* cmd_code_numbits, uint8_t* cmd_code,     \
+    size_t* storage_ix, uint8_t* storage) {                                  \
+  BrotliCompressFragmentFastImpl(m, input, input_size, is_last, table, B,    \
+      cmd_depth, cmd_bits, cmd_code_numbits, cmd_code, storage_ix, storage); \
+}
+FOR_TABLE_BITS_(BAKE_METHOD_PARAM_)
+#undef BAKE_METHOD_PARAM_
+
+void BrotliCompressFragmentFast(
+    MemoryManager* m, const uint8_t* input, size_t input_size,
+    BROTLI_BOOL is_last, int* table, size_t table_size, uint8_t cmd_depth[128],
+    uint16_t cmd_bits[128], size_t* cmd_code_numbits, uint8_t* cmd_code,
+    size_t* storage_ix, uint8_t* storage) {
+  const size_t initial_storage_ix = *storage_ix;
+  const size_t table_bits = Log2FloorNonZero(table_size);
+
+  if (input_size == 0) {
+    assert(is_last);
+    BrotliWriteBits(1, 1, storage_ix, storage);  /* islast */
+    BrotliWriteBits(1, 1, storage_ix, storage);  /* isempty */
+    *storage_ix = (*storage_ix + 7u) & ~7u;
+    return;
+  }
+
+  switch (table_bits) {
+#define CASE_(B)                                                     \
+    case B:                                                          \
+      BrotliCompressFragmentFastImpl ## B(                           \
+          m, input, input_size, is_last, table, cmd_depth, cmd_bits, \
+          cmd_code_numbits, cmd_code, storage_ix, storage);          \
+      break;
+    FOR_TABLE_BITS_(CASE_)
+#undef CASE_
+    default: assert(0); break;
+  }
+
+  /* If output is larger than single uncompressed block, rewrite it. */
+  if (*storage_ix - initial_storage_ix > 31 + (input_size << 3)) {
+    EmitUncompressedMetaBlock(input, input + input_size, initial_storage_ix,
+                              storage_ix, storage);
+  }
+
+  if (is_last) {
+    BrotliWriteBits(1, 1, storage_ix, storage);  /* islast */
+    BrotliWriteBits(1, 1, storage_ix, storage);  /* isempty */
+    *storage_ix = (*storage_ix + 7u) & ~7u;
+  }
+}
+
+#undef FOR_TABLE_BITS_
+
 #if defined(__cplusplus) || defined(c_plusplus)
 }  /* extern "C" */
 #endif