brotli 0.2.3 → 0.5.0

data/vendor/brotli/c/enc/hash_composite_inc.h

@@ -28,108 +28,112 @@ static BROTLI_INLINE size_t FN(StoreLookahead)(void) {
 }
 
 typedef struct HashComposite {
-  HasherHandle ha;
-  HasherHandle hb;
+  HASHER_A ha;
+  HASHER_B hb;
+  HasherCommon ha_common;
+  HasherCommon hb_common;
+
+  /* Shortcuts. */
+  HasherCommon* common;
+
+  BROTLI_BOOL fresh;
   const BrotliEncoderParams* params;
 } HashComposite;
 
-static BROTLI_INLINE HashComposite* FN(Self)(HasherHandle handle) {
-  return (HashComposite*)&(GetHasherCommon(handle)[1]);
-}
+static void FN(Initialize)(HasherCommon* common,
+    HashComposite* BROTLI_RESTRICT self, const BrotliEncoderParams* params) {
+  self->common = common;
 
-static void FN(Initialize)(
-    HasherHandle handle, const BrotliEncoderParams* params) {
-  HashComposite* self = FN(Self)(handle);
-  self->ha = 0;
-  self->hb = 0;
+  self->ha_common = *self->common;
+  self->hb_common = *self->common;
+  self->fresh = BROTLI_TRUE;
   self->params = params;
-  /* TODO: Initialize of the hashers is defered to Prepare (and params
+  /* TODO(lode): Initialize of the hashers is deferred to Prepare (and params
      remembered here) because we don't get the one_shot and input_size params
      here that are needed to know the memory size of them. Instead provide
      those params to all hashers FN(Initialize) */
 }
 
-static void FN(Prepare)(HasherHandle handle, BROTLI_BOOL one_shot,
-    size_t input_size, const uint8_t* data) {
-  HashComposite* self = FN(Self)(handle);
-  if (!self->ha) {
-    HasherCommon* common_a;
-    HasherCommon* common_b;
-
-    self->ha = handle + sizeof(HasherCommon) + sizeof(HashComposite);
-    common_a = (HasherCommon*)self->ha;
-    common_a->params = self->params->hasher;
-    common_a->is_prepared_ = BROTLI_FALSE;
-    common_a->dict_num_lookups = 0;
-    common_a->dict_num_matches = 0;
-    FN_A(Initialize)(self->ha, self->params);
-
-    self->hb = self->ha + sizeof(HasherCommon) + FN_A(HashMemAllocInBytes)(
-        self->params, one_shot, input_size);
-    common_b = (HasherCommon*)self->hb;
-    common_b->params = self->params->hasher;
-    common_b->is_prepared_ = BROTLI_FALSE;
-    common_b->dict_num_lookups = 0;
-    common_b->dict_num_matches = 0;
-    FN_B(Initialize)(self->hb, self->params);
+static void FN(Prepare)(
+    HashComposite* BROTLI_RESTRICT self, BROTLI_BOOL one_shot,
+    size_t input_size, const uint8_t* BROTLI_RESTRICT data) {
+  if (self->fresh) {
+    self->fresh = BROTLI_FALSE;
+    self->ha_common.extra[0] = self->common->extra[0];
+    self->ha_common.extra[1] = self->common->extra[1];
+    self->ha_common.extra[2] = NULL;
+    self->ha_common.extra[3] = NULL;
+    self->hb_common.extra[0] = self->common->extra[2];
+    self->hb_common.extra[1] = self->common->extra[3];
+    self->hb_common.extra[2] = NULL;
+    self->hb_common.extra[3] = NULL;
+
+    FN_A(Initialize)(&self->ha_common, &self->ha, self->params);
+    FN_B(Initialize)(&self->hb_common, &self->hb, self->params);
   }
-  FN_A(Prepare)(self->ha, one_shot, input_size, data);
-  FN_B(Prepare)(self->hb, one_shot, input_size, data);
+  FN_A(Prepare)(&self->ha, one_shot, input_size, data);
+  FN_B(Prepare)(&self->hb, one_shot, input_size, data);
 }
 
-static BROTLI_INLINE size_t FN(HashMemAllocInBytes)(
+static BROTLI_INLINE void FN(HashMemAllocInBytes)(
     const BrotliEncoderParams* params, BROTLI_BOOL one_shot,
-    size_t input_size) {
-  return sizeof(HashComposite) + 2 * sizeof(HasherCommon) +
-      FN_A(HashMemAllocInBytes)(params, one_shot, input_size) +
-      FN_B(HashMemAllocInBytes)(params, one_shot, input_size);
+    size_t input_size, size_t* alloc_size) {
+  size_t alloc_size_a[4] = {0};
+  size_t alloc_size_b[4] = {0};
+  FN_A(HashMemAllocInBytes)(params, one_shot, input_size, alloc_size_a);
+  FN_B(HashMemAllocInBytes)(params, one_shot, input_size, alloc_size_b);
+  /* Should never happen. */
+  if (alloc_size_a[2] != 0 || alloc_size_a[3] != 0) exit(EXIT_FAILURE);
+  if (alloc_size_b[2] != 0 || alloc_size_b[3] != 0) exit(EXIT_FAILURE);
+  alloc_size[0] = alloc_size_a[0];
+  alloc_size[1] = alloc_size_a[1];
+  alloc_size[2] = alloc_size_b[0];
+  alloc_size[3] = alloc_size_b[1];
 }
 
-static BROTLI_INLINE void FN(Store)(HasherHandle BROTLI_RESTRICT handle,
+static BROTLI_INLINE void FN(Store)(HashComposite* BROTLI_RESTRICT self,
     const uint8_t* BROTLI_RESTRICT data, const size_t mask, const size_t ix) {
-  HashComposite* self = FN(Self)(handle);
-  FN_A(Store)(self->ha, data, mask, ix);
-  FN_B(Store)(self->hb, data, mask, ix);
+  FN_A(Store)(&self->ha, data, mask, ix);
+  FN_B(Store)(&self->hb, data, mask, ix);
 }
 
-static BROTLI_INLINE void FN(StoreRange)(HasherHandle handle,
-    const uint8_t* data, const size_t mask, const size_t ix_start,
+static BROTLI_INLINE void FN(StoreRange)(
+    HashComposite* BROTLI_RESTRICT self, const uint8_t* BROTLI_RESTRICT data,
+    const size_t mask, const size_t ix_start,
     const size_t ix_end) {
-  HashComposite* self = FN(Self)(handle);
-  FN_A(StoreRange)(self->ha, data, mask, ix_start, ix_end);
-  FN_B(StoreRange)(self->hb, data, mask, ix_start, ix_end);
+  FN_A(StoreRange)(&self->ha, data, mask, ix_start, ix_end);
+  FN_B(StoreRange)(&self->hb, data, mask, ix_start, ix_end);
 }
 
-static BROTLI_INLINE void FN(StitchToPreviousBlock)(HasherHandle handle,
+static BROTLI_INLINE void FN(StitchToPreviousBlock)(
+    HashComposite* BROTLI_RESTRICT self,
     size_t num_bytes, size_t position, const uint8_t* ringbuffer,
     size_t ring_buffer_mask) {
-  HashComposite* self = FN(Self)(handle);
-  FN_A(StitchToPreviousBlock)(self->ha, num_bytes, position, ringbuffer,
-      ring_buffer_mask);
-  FN_B(StitchToPreviousBlock)(self->hb, num_bytes, position, ringbuffer,
-      ring_buffer_mask);
+  FN_A(StitchToPreviousBlock)(&self->ha, num_bytes, position,
+      ringbuffer, ring_buffer_mask);
+  FN_B(StitchToPreviousBlock)(&self->hb, num_bytes, position,
+      ringbuffer, ring_buffer_mask);
 }
 
 static BROTLI_INLINE void FN(PrepareDistanceCache)(
-    HasherHandle handle, int* BROTLI_RESTRICT distance_cache) {
-  HashComposite* self = FN(Self)(handle);
-  FN_A(PrepareDistanceCache)(self->ha, distance_cache);
-  FN_B(PrepareDistanceCache)(self->hb, distance_cache);
+    HashComposite* BROTLI_RESTRICT self, int* BROTLI_RESTRICT distance_cache) {
+  FN_A(PrepareDistanceCache)(&self->ha, distance_cache);
+  FN_B(PrepareDistanceCache)(&self->hb, distance_cache);
 }
 
-static BROTLI_INLINE void FN(FindLongestMatch)(HasherHandle handle,
+static BROTLI_INLINE void FN(FindLongestMatch)(
+    HashComposite* BROTLI_RESTRICT self,
     const BrotliEncoderDictionary* dictionary,
     const uint8_t* BROTLI_RESTRICT data, const size_t ring_buffer_mask,
     const int* BROTLI_RESTRICT distance_cache, const size_t cur_ix,
     const size_t max_length, const size_t max_backward,
-    const size_t gap, const size_t max_distance,
+    const size_t dictionary_distance, const size_t max_distance,
     HasherSearchResult* BROTLI_RESTRICT out) {
-  HashComposite* self = FN(Self)(handle);
-  FN_A(FindLongestMatch)(self->ha, dictionary, data, ring_buffer_mask,
-      distance_cache, cur_ix, max_length, max_backward, gap,
+  FN_A(FindLongestMatch)(&self->ha, dictionary, data, ring_buffer_mask,
+      distance_cache, cur_ix, max_length, max_backward, dictionary_distance,
       max_distance, out);
-  FN_B(FindLongestMatch)(self->hb, dictionary, data, ring_buffer_mask,
-      distance_cache, cur_ix, max_length, max_backward, gap,
+  FN_B(FindLongestMatch)(&self->hb, dictionary, data, ring_buffer_mask,
+      distance_cache, cur_ix, max_length, max_backward, dictionary_distance,
       max_distance, out);
 }
 

data/vendor/brotli/c/enc/hash_forgetful_chain_inc.h

@@ -28,7 +28,7 @@ static BROTLI_INLINE size_t FN(HashTypeLength)(void) { return 4; }
 static BROTLI_INLINE size_t FN(StoreLookahead)(void) { return 4; }
 
 /* HashBytes is the function that chooses the bucket to place the address in.*/
-static BROTLI_INLINE size_t FN(HashBytes)(const uint8_t* data) {
+static BROTLI_INLINE size_t FN(HashBytes)(const uint8_t* BROTLI_RESTRICT data) {
   const uint32_t h = BROTLI_UNALIGNED_LOAD32LE(data) * kHashMul32;
   /* The higher bits contain more mixture from the multiplication,
      so we take our results from there. */
@@ -45,28 +45,57 @@ typedef struct FN(Bank) {
 } FN(Bank);
 
 typedef struct HashForgetfulChain {
-  uint32_t addr[BUCKET_SIZE];
-  uint16_t head[BUCKET_SIZE];
-  /* Truncated hash used for quick rejection of "distance cache" candidates. */
-  uint8_t tiny_hash[65536];
-  FN(Bank) banks[NUM_BANKS];
-  uint16_t free_slot_idx[NUM_BANKS];
+  uint16_t free_slot_idx[NUM_BANKS];  /* Up to 1KiB. Move to dynamic? */
   size_t max_hops;
+
+  /* Shortcuts. */
+  void* extra[2];
+  HasherCommon* common;
+
+  /* --- Dynamic size members --- */
+
+  /* uint32_t addr[BUCKET_SIZE]; */
+
+  /* uint16_t head[BUCKET_SIZE]; */
+
+  /* Truncated hash used for quick rejection of "distance cache" candidates. */
+  /* uint8_t tiny_hash[65536];*/
+
+  /* FN(Bank) banks[NUM_BANKS]; */
 } HashForgetfulChain;
 
-static BROTLI_INLINE HashForgetfulChain* FN(Self)(HasherHandle handle) {
-  return (HashForgetfulChain*)&(GetHasherCommon(handle)[1]);
+static uint32_t* FN(Addr)(void* extra) {
+  return (uint32_t*)extra;
+}
+
+static uint16_t* FN(Head)(void* extra) {
+  return (uint16_t*)(&FN(Addr)(extra)[BUCKET_SIZE]);
+}
+
+static uint8_t* FN(TinyHash)(void* extra) {
+  return (uint8_t*)(&FN(Head)(extra)[BUCKET_SIZE]);
+}
+
+static FN(Bank)* FN(Banks)(void* extra) {
+  return (FN(Bank)*)(extra);
 }
 
 static void FN(Initialize)(
-    HasherHandle handle, const BrotliEncoderParams* params) {
-  FN(Self)(handle)->max_hops =
-      (params->quality > 6 ? 7u : 8u) << (params->quality - 4);
+    HasherCommon* common, HashForgetfulChain* BROTLI_RESTRICT self,
+    const BrotliEncoderParams* params) {
+  self->common = common;
+  self->extra[0] = common->extra[0];
+  self->extra[1] = common->extra[1];
+
+  self->max_hops = (params->quality > 6 ? 7u : 8u) << (params->quality - 4);
 }
 
-static void FN(Prepare)(HasherHandle handle, BROTLI_BOOL one_shot,
-    size_t input_size, const uint8_t* data) {
-  HashForgetfulChain* self = FN(Self)(handle);
+static void FN(Prepare)(
+    HashForgetfulChain* BROTLI_RESTRICT self, BROTLI_BOOL one_shot,
+    size_t input_size, const uint8_t* BROTLI_RESTRICT data) {
+  uint32_t* BROTLI_RESTRICT addr = FN(Addr)(self->extra[0]);
+  uint16_t* BROTLI_RESTRICT head = FN(Head)(self->extra[0]);
+  uint8_t* BROTLI_RESTRICT tiny_hash = FN(TinyHash)(self->extra[0]);
   /* Partial preparation is 100 times slower (per socket). */
   size_t partial_prepare_threshold = BUCKET_SIZE >> 6;
   if (one_shot && input_size <= partial_prepare_threshold) {
@@ -74,71 +103,79 @@ static void FN(Prepare)(HasherHandle handle, BROTLI_BOOL one_shot,
     for (i = 0; i < input_size; ++i) {
       size_t bucket = FN(HashBytes)(&data[i]);
       /* See InitEmpty comment. */
-      self->addr[bucket] = 0xCCCCCCCC;
-      self->head[bucket] = 0xCCCC;
+      addr[bucket] = 0xCCCCCCCC;
+      head[bucket] = 0xCCCC;
     }
   } else {
     /* Fill |addr| array with 0xCCCCCCCC value. Because of wrapping, position
        processed by hasher never reaches 3GB + 64M; this makes all new chains
        to be terminated after the first node. */
-    memset(self->addr, 0xCC, sizeof(self->addr));
-    memset(self->head, 0, sizeof(self->head));
+    memset(addr, 0xCC, sizeof(uint32_t) * BUCKET_SIZE);
+    memset(head, 0, sizeof(uint16_t) * BUCKET_SIZE);
   }
-  memset(self->tiny_hash, 0, sizeof(self->tiny_hash));
+  memset(tiny_hash, 0, sizeof(uint8_t) * 65536);
   memset(self->free_slot_idx, 0, sizeof(self->free_slot_idx));
 }
 
-static BROTLI_INLINE size_t FN(HashMemAllocInBytes)(
+static BROTLI_INLINE void FN(HashMemAllocInBytes)(
     const BrotliEncoderParams* params, BROTLI_BOOL one_shot,
-    size_t input_size) {
+    size_t input_size, size_t* alloc_size) {
   BROTLI_UNUSED(params);
   BROTLI_UNUSED(one_shot);
   BROTLI_UNUSED(input_size);
-  return sizeof(HashForgetfulChain);
+  alloc_size[0] = sizeof(uint32_t) * BUCKET_SIZE +
+                  sizeof(uint16_t) * BUCKET_SIZE + sizeof(uint8_t) * 65536;
+  alloc_size[1] = sizeof(FN(Bank)) * NUM_BANKS;
 }
 
 /* Look at 4 bytes at &data[ix & mask]. Compute a hash from these, and prepend
    node to corresponding chain; also update tiny_hash for current position. */
-static BROTLI_INLINE void FN(Store)(HasherHandle BROTLI_RESTRICT handle,
+static BROTLI_INLINE void FN(Store)(HashForgetfulChain* BROTLI_RESTRICT self,
     const uint8_t* BROTLI_RESTRICT data, const size_t mask, const size_t ix) {
-  HashForgetfulChain* self = FN(Self)(handle);
+  uint32_t* BROTLI_RESTRICT addr = FN(Addr)(self->extra[0]);
+  uint16_t* BROTLI_RESTRICT head = FN(Head)(self->extra[0]);
+  uint8_t* BROTLI_RESTRICT tiny_hash = FN(TinyHash)(self->extra[0]);
+  FN(Bank)* BROTLI_RESTRICT banks = FN(Banks)(self->extra[1]);
   const size_t key = FN(HashBytes)(&data[ix & mask]);
   const size_t bank = key & (NUM_BANKS - 1);
   const size_t idx = self->free_slot_idx[bank]++ & (BANK_SIZE - 1);
-  size_t delta = ix - self->addr[key];
-  self->tiny_hash[(uint16_t)ix] = (uint8_t)key;
+  size_t delta = ix - addr[key];
+  tiny_hash[(uint16_t)ix] = (uint8_t)key;
   if (delta > 0xFFFF) delta = CAPPED_CHAINS ? 0 : 0xFFFF;
-  self->banks[bank].slots[idx].delta = (uint16_t)delta;
-  self->banks[bank].slots[idx].next = self->head[key];
-  self->addr[key] = (uint32_t)ix;
-  self->head[key] = (uint16_t)idx;
+  banks[bank].slots[idx].delta = (uint16_t)delta;
+  banks[bank].slots[idx].next = head[key];
+  addr[key] = (uint32_t)ix;
+  head[key] = (uint16_t)idx;
 }
 
-static BROTLI_INLINE void FN(StoreRange)(HasherHandle handle,
-    const uint8_t* data, const size_t mask, const size_t ix_start,
-    const size_t ix_end) {
+static BROTLI_INLINE void FN(StoreRange)(
+    HashForgetfulChain* BROTLI_RESTRICT self,
+    const uint8_t* BROTLI_RESTRICT data, const size_t mask,
+    const size_t ix_start, const size_t ix_end) {
   size_t i;
   for (i = ix_start; i < ix_end; ++i) {
-    FN(Store)(handle, data, mask, i);
+    FN(Store)(self, data, mask, i);
   }
 }
 
-static BROTLI_INLINE void FN(StitchToPreviousBlock)(HasherHandle handle,
+static BROTLI_INLINE void FN(StitchToPreviousBlock)(
+    HashForgetfulChain* BROTLI_RESTRICT self,
     size_t num_bytes, size_t position, const uint8_t* ringbuffer,
     size_t ring_buffer_mask) {
   if (num_bytes >= FN(HashTypeLength)() - 1 && position >= 3) {
     /* Prepare the hashes for three last bytes of the last write.
        These could not be calculated before, since they require knowledge
        of both the previous and the current block. */
-    FN(Store)(handle, ringbuffer, ring_buffer_mask, position - 3);
-    FN(Store)(handle, ringbuffer, ring_buffer_mask, position - 2);
-    FN(Store)(handle, ringbuffer, ring_buffer_mask, position - 1);
+    FN(Store)(self, ringbuffer, ring_buffer_mask, position - 3);
+    FN(Store)(self, ringbuffer, ring_buffer_mask, position - 2);
+    FN(Store)(self, ringbuffer, ring_buffer_mask, position - 1);
   }
 }
 
 static BROTLI_INLINE void FN(PrepareDistanceCache)(
-    HasherHandle handle, int* BROTLI_RESTRICT distance_cache) {
-  BROTLI_UNUSED(handle);
+    HashForgetfulChain* BROTLI_RESTRICT self,
+    int* BROTLI_RESTRICT distance_cache) {
+  BROTLI_UNUSED(self);
   PrepareDistanceCache(distance_cache, NUM_LAST_DISTANCES_TO_CHECK);
 }
 
@@ -153,14 +190,18 @@ static BROTLI_INLINE void FN(PrepareDistanceCache)(
    Does not look for matches further away than max_backward.
    Writes the best match into |out|.
    |out|->score is updated only if a better match is found. */
-static BROTLI_INLINE void FN(FindLongestMatch)(HasherHandle handle,
+static BROTLI_INLINE void FN(FindLongestMatch)(
+    HashForgetfulChain* BROTLI_RESTRICT self,
     const BrotliEncoderDictionary* dictionary,
     const uint8_t* BROTLI_RESTRICT data, const size_t ring_buffer_mask,
     const int* BROTLI_RESTRICT distance_cache,
     const size_t cur_ix, const size_t max_length, const size_t max_backward,
-    const size_t gap, const size_t max_distance,
+    const size_t dictionary_distance, const size_t max_distance,
     HasherSearchResult* BROTLI_RESTRICT out) {
-  HashForgetfulChain* self = FN(Self)(handle);
+  uint32_t* BROTLI_RESTRICT addr = FN(Addr)(self->extra[0]);
+  uint16_t* BROTLI_RESTRICT head = FN(Head)(self->extra[0]);
+  uint8_t* BROTLI_RESTRICT tiny_hashes = FN(TinyHash)(self->extra[0]);
+  FN(Bank)* BROTLI_RESTRICT banks = FN(Banks)(self->extra[1]);
   const size_t cur_ix_masked = cur_ix & ring_buffer_mask;
   /* Don't accept a short copy from far away. */
   score_t min_score = out->score;
@@ -176,7 +217,7 @@ static BROTLI_INLINE void FN(FindLongestMatch)(HasherHandle handle,
     const size_t backward = (size_t)distance_cache[i];
     size_t prev_ix = (cur_ix - backward);
     /* For distance code 0 we want to consider 2-byte matches. */
-    if (i > 0 && self->tiny_hash[(uint16_t)prev_ix] != tiny_hash) continue;
+    if (i > 0 && tiny_hashes[(uint16_t)prev_ix] != tiny_hash) continue;
     if (prev_ix >= cur_ix || backward > max_backward) {
       continue;
     }
@@ -204,16 +245,16 @@ static BROTLI_INLINE void FN(FindLongestMatch)(HasherHandle handle,
     const size_t bank = key & (NUM_BANKS - 1);
     size_t backward = 0;
     size_t hops = self->max_hops;
-    size_t delta = cur_ix - self->addr[key];
-    size_t slot = self->head[key];
+    size_t delta = cur_ix - addr[key];
+    size_t slot = head[key];
     while (hops--) {
       size_t prev_ix;
       size_t last = slot;
       backward += delta;
       if (backward > max_backward || (CAPPED_CHAINS && !delta)) break;
       prev_ix = (cur_ix - backward) & ring_buffer_mask;
-      slot = self->banks[bank].slots[last].next;
-      delta = self->banks[bank].slots[last].delta;
+      slot = banks[bank].slots[last].next;
+      delta = banks[bank].slots[last].delta;
       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]) {
@@ -238,11 +279,11 @@ static BROTLI_INLINE void FN(FindLongestMatch)(HasherHandle handle,
         }
       }
     }
-    FN(Store)(handle, data, ring_buffer_mask, cur_ix);
+    FN(Store)(self, data, ring_buffer_mask, cur_ix);
   }
   if (out->score == min_score) {
     SearchInStaticDictionary(dictionary,
-        handle, &data[cur_ix_masked], max_length, max_backward + gap,
+        self->common, &data[cur_ix_masked], max_length, dictionary_distance,
         max_distance, out, BROTLI_FALSE);
   }
 }