Fix typo / minor formatting (#716)
* Fix typo / minor formatting / pull computable constant to the place of use.
diff --git a/c/common/transform.c b/c/common/transform.c
index 4184ae5..426e635 100755
--- a/c/common/transform.c
+++ b/c/common/transform.c
@@ -191,11 +191,11 @@
}
int BrotliTransformDictionaryWord(uint8_t* dst, const uint8_t* word, int len,
- const BrotliTransforms* transforms, int transfom_idx) {
+ const BrotliTransforms* transforms, int transform_idx) {
int idx = 0;
- const uint8_t* prefix = BROTLI_TRANSFORM_PREFIX(transforms, transfom_idx);
- uint8_t type = BROTLI_TRANSFORM_TYPE(transforms, transfom_idx);
- const uint8_t* suffix = BROTLI_TRANSFORM_SUFFIX(transforms, transfom_idx);
+ const uint8_t* prefix = BROTLI_TRANSFORM_PREFIX(transforms, transform_idx);
+ uint8_t type = BROTLI_TRANSFORM_TYPE(transforms, transform_idx);
+ const uint8_t* suffix = BROTLI_TRANSFORM_SUFFIX(transforms, transform_idx);
{
int prefix_len = *prefix++;
while (prefix_len--) { dst[idx++] = *prefix++; }
diff --git a/c/dec/huffman.c b/c/dec/huffman.c
index 9deb42c..30c40d3 100644
--- a/c/dec/huffman.c
+++ b/c/dec/huffman.c
@@ -157,8 +157,7 @@
step = 2;
do {
for (bits_count = count[bits]; bits_count != 0; --bits_count) {
- code = ConstructHuffmanCode((uint8_t)bits,
- (uint16_t)sorted[symbol++]);
+ code = ConstructHuffmanCode((uint8_t)bits, (uint16_t)sorted[symbol++]);
ReplicateValue(&table[BrotliReverseBits(key)], step, table_size, code);
key += key_step;
}
@@ -248,8 +247,7 @@
sub_key = 0;
}
symbol = symbol_lists[symbol];
- code = ConstructHuffmanCode((uint8_t)(len - root_bits),
- (uint16_t)symbol);
+ code = ConstructHuffmanCode((uint8_t)(len - root_bits), (uint16_t)symbol);
ReplicateValue(
&table[BrotliReverseBits(sub_key)], step, table_size, code);
sub_key += sub_key_step;
diff --git a/c/enc/backward_references_hq.c b/c/enc/backward_references_hq.c
index e7486c4..96b0e70 100644
--- a/c/enc/backward_references_hq.c
+++ b/c/enc/backward_references_hq.c
@@ -330,7 +330,7 @@
REQUIRES: nodes[0..pos] satisfies that "ZopfliNode array invariant". */
static uint32_t ComputeDistanceShortcut(const size_t block_start,
const size_t pos,
- const size_t max_backward,
+ const size_t max_backward_limit,
const size_t gap,
const ZopfliNode* nodes) {
const size_t clen = ZopfliNodeCopyLength(&nodes[pos]);
@@ -338,13 +338,13 @@
const size_t dist = ZopfliNodeCopyDistance(&nodes[pos]);
/* Since |block_start + pos| is the end position of the command, the copy part
starts from |block_start + pos - clen|. Distances that are greater than
- this or greater than |max_backward| are static dictionary references, and
- do not update the last distances. Also distance code 0 (last distance)
- does not update the last distances. */
+ this or greater than |max_backward_limit| + |gap| are static dictionary
+ references, and do not update the last distances.
+ Also distance code 0 (last distance) does not update the last distances. */
if (pos == 0) {
return 0;
} else if (dist + clen <= block_start + pos + gap &&
- dist <= max_backward + gap &&
+ dist <= max_backward_limit + gap &&
ZopfliNodeDistanceCode(&nodes[pos]) > 0) {
return (uint32_t)pos;
} else {
@@ -454,9 +454,11 @@
break;
}
if (BROTLI_PREDICT_FALSE(backward > max_distance + gap)) {
+ /* Word dictionary -> ignore. */
continue;
}
if (backward <= max_distance) {
+ /* Regular backward reference. */
if (prev_ix >= cur_ix) {
continue;
}
@@ -564,14 +566,10 @@
/* REQUIRES: nodes != NULL and len(nodes) >= num_bytes + 1 */
void BrotliZopfliCreateCommands(const size_t num_bytes,
- const size_t block_start,
- const size_t max_backward_limit,
- const ZopfliNode* nodes,
- int* dist_cache,
- size_t* last_insert_len,
- const BrotliEncoderParams* params,
- Command* commands,
- size_t* num_literals) {
+ const size_t block_start, const ZopfliNode* nodes, int* dist_cache,
+ size_t* last_insert_len, const BrotliEncoderParams* params,
+ Command* commands, size_t* num_literals) {
+ const size_t max_backward_limit = BROTLI_MAX_BACKWARD_LIMIT(params->lgwin);
size_t pos = 0;
uint32_t offset = nodes[0].u.next;
size_t i;
@@ -610,18 +608,12 @@
*last_insert_len += num_bytes - pos;
}
-static size_t ZopfliIterate(size_t num_bytes,
- size_t position,
- const uint8_t* ringbuffer,
- size_t ringbuffer_mask,
- const BrotliEncoderParams* params,
- const size_t max_backward_limit,
- const size_t gap,
- const int* dist_cache,
- const ZopfliCostModel* model,
- const uint32_t* num_matches,
- const BackwardMatch* matches,
- ZopfliNode* nodes) {
+static size_t ZopfliIterate(size_t num_bytes, size_t position,
+ const uint8_t* ringbuffer, size_t ringbuffer_mask,
+ const BrotliEncoderParams* params, const size_t gap, const int* dist_cache,
+ const ZopfliCostModel* model, const uint32_t* num_matches,
+ const BackwardMatch* matches, ZopfliNode* nodes) {
+ const size_t max_backward_limit = BROTLI_MAX_BACKWARD_LIMIT(params->lgwin);
const size_t max_zopfli_len = MaxZopfliLen(params);
StartPosQueue queue;
size_t cur_match_pos = 0;
@@ -645,8 +637,8 @@
while (skip) {
i++;
if (i + 3 >= num_bytes) break;
- EvaluateNode(position, i, max_backward_limit, gap, dist_cache, model,
- &queue, nodes);
+ EvaluateNode(position, i, max_backward_limit, gap,
+ dist_cache, model, &queue, nodes);
cur_match_pos += num_matches[i];
skip--;
}
@@ -656,11 +648,11 @@
}
/* REQUIRES: nodes != NULL and len(nodes) >= num_bytes + 1 */
-size_t BrotliZopfliComputeShortestPath(MemoryManager* m,
- size_t num_bytes, size_t position, const uint8_t* ringbuffer,
- size_t ringbuffer_mask, const BrotliEncoderParams* params,
- const size_t max_backward_limit, const int* dist_cache, HasherHandle hasher,
- ZopfliNode* nodes) {
+size_t BrotliZopfliComputeShortestPath(MemoryManager* m, size_t num_bytes,
+ size_t position, const uint8_t* ringbuffer, size_t ringbuffer_mask,
+ const BrotliEncoderParams* params,
+ const int* dist_cache, HasherHandle hasher, ZopfliNode* nodes) {
+ const size_t max_backward_limit = BROTLI_MAX_BACKWARD_LIMIT(params->lgwin);
const size_t max_zopfli_len = MaxZopfliLen(params);
ZopfliCostModel model;
StartPosQueue queue;
@@ -681,9 +673,11 @@
const size_t pos = position + i;
const size_t max_distance = BROTLI_MIN(size_t, pos, max_backward_limit);
size_t skip;
- size_t num_matches = FindAllMatchesH10(hasher, ¶ms->dictionary,
- ringbuffer, ringbuffer_mask, pos, num_bytes - i, max_distance, gap,
- params, &matches[lz_matches_offset]);
+ size_t num_matches;
+ num_matches = FindAllMatchesH10(hasher,
+ ¶ms->dictionary,
+ ringbuffer, ringbuffer_mask, pos, num_bytes - i, max_distance,
+ gap, params, &matches[lz_matches_offset]);
if (num_matches > 0 &&
BackwardMatchLength(&matches[num_matches - 1]) > max_zopfli_len) {
matches[0] = matches[num_matches - 1];
@@ -704,8 +698,8 @@
while (skip) {
i++;
if (i + HashTypeLengthH10() - 1 >= num_bytes) break;
- EvaluateNode(position, i, max_backward_limit, gap, dist_cache, &model,
- &queue, nodes);
+ EvaluateNode(position, i, max_backward_limit, gap,
+ dist_cache, &model, &queue, nodes);
skip--;
}
}
@@ -714,28 +708,27 @@
return ComputeShortestPathFromNodes(num_bytes, nodes);
}
-void BrotliCreateZopfliBackwardReferences(MemoryManager* m,
- size_t num_bytes, size_t position, const uint8_t* ringbuffer,
- size_t ringbuffer_mask, const BrotliEncoderParams* params,
+void BrotliCreateZopfliBackwardReferences(MemoryManager* m, size_t num_bytes,
+ size_t position, const uint8_t* ringbuffer, size_t ringbuffer_mask,
+ const BrotliEncoderParams* params,
HasherHandle hasher, int* dist_cache, size_t* last_insert_len,
Command* commands, size_t* num_commands, size_t* num_literals) {
- const size_t max_backward_limit = BROTLI_MAX_BACKWARD_LIMIT(params->lgwin);
ZopfliNode* nodes;
nodes = BROTLI_ALLOC(m, ZopfliNode, num_bytes + 1);
if (BROTLI_IS_OOM(m)) return;
BrotliInitZopfliNodes(nodes, num_bytes + 1);
- *num_commands += BrotliZopfliComputeShortestPath(m,
- num_bytes, position, ringbuffer, ringbuffer_mask,
- params, max_backward_limit, dist_cache, hasher, nodes);
+ *num_commands += BrotliZopfliComputeShortestPath(m, num_bytes,
+ position, ringbuffer, ringbuffer_mask, params,
+ dist_cache, hasher, nodes);
if (BROTLI_IS_OOM(m)) return;
- BrotliZopfliCreateCommands(num_bytes, position, max_backward_limit, nodes,
- dist_cache, last_insert_len, params, commands, num_literals);
+ BrotliZopfliCreateCommands(num_bytes, position, nodes, dist_cache,
+ last_insert_len, params, commands, num_literals);
BROTLI_FREE(m, nodes);
}
-void BrotliCreateHqZopfliBackwardReferences(MemoryManager* m,
- size_t num_bytes, size_t position, const uint8_t* ringbuffer,
- size_t ringbuffer_mask, const BrotliEncoderParams* params,
+void BrotliCreateHqZopfliBackwardReferences(MemoryManager* m, size_t num_bytes,
+ size_t position, const uint8_t* ringbuffer, size_t ringbuffer_mask,
+ const BrotliEncoderParams* params,
HasherHandle hasher, int* dist_cache, size_t* last_insert_len,
Command* commands, size_t* num_commands, size_t* num_literals) {
const size_t max_backward_limit = BROTLI_MAX_BACKWARD_LIMIT(params->lgwin);
@@ -767,8 +760,10 @@
cur_match_pos + MAX_NUM_MATCHES_H10 + shadow_matches);
if (BROTLI_IS_OOM(m)) return;
num_found_matches = FindAllMatchesH10(hasher,
- ¶ms->dictionary, ringbuffer, ringbuffer_mask, pos, max_length,
- max_distance, gap, params, &matches[cur_match_pos + shadow_matches]);
+ ¶ms->dictionary,
+ ringbuffer, ringbuffer_mask, pos, max_length,
+ max_distance, gap, params,
+ &matches[cur_match_pos + shadow_matches]);
cur_match_end = cur_match_pos + num_found_matches;
for (j = cur_match_pos; j + 1 < cur_match_end; ++j) {
BROTLI_DCHECK(BackwardMatchLength(&matches[j]) <=
@@ -814,10 +809,10 @@
*last_insert_len = orig_last_insert_len;
memcpy(dist_cache, orig_dist_cache, 4 * sizeof(dist_cache[0]));
*num_commands += ZopfliIterate(num_bytes, position, ringbuffer,
- ringbuffer_mask, params, max_backward_limit, gap, dist_cache,
- &model, num_matches, matches, nodes);
- BrotliZopfliCreateCommands(num_bytes, position, max_backward_limit,
- nodes, dist_cache, last_insert_len, params, commands, num_literals);
+ ringbuffer_mask, params, gap, dist_cache, &model, num_matches, matches,
+ nodes);
+ BrotliZopfliCreateCommands(num_bytes, position, nodes, dist_cache,
+ last_insert_len, params, commands, num_literals);
}
CleanupZopfliCostModel(m, &model);
BROTLI_FREE(m, nodes);
diff --git a/c/enc/backward_references_hq.h b/c/enc/backward_references_hq.h
index 7c38bd6..1e4275d 100644
--- a/c/enc/backward_references_hq.h
+++ b/c/enc/backward_references_hq.h
@@ -74,15 +74,14 @@
(1) nodes[i].copy_length() >= 2
(2) nodes[i].command_length() <= i and
(3) nodes[i - nodes[i].command_length()].cost < kInfinity */
-BROTLI_INTERNAL size_t BrotliZopfliComputeShortestPath(MemoryManager* m,
- size_t num_bytes, size_t position, const uint8_t* ringbuffer,
- size_t ringbuffer_mask, const BrotliEncoderParams* params,
- const size_t max_backward_limit, const int* dist_cache, HasherHandle hasher,
- ZopfliNode* nodes);
+BROTLI_INTERNAL size_t BrotliZopfliComputeShortestPath(
+ MemoryManager* m, size_t num_bytes,
+ size_t position, const uint8_t* ringbuffer, size_t ringbuffer_mask,
+ const BrotliEncoderParams* params,
+ const int* dist_cache, HasherHandle hasher, ZopfliNode* nodes);
BROTLI_INTERNAL void BrotliZopfliCreateCommands(
- const size_t num_bytes, const size_t block_start,
- const size_t max_backward_limit, const ZopfliNode* nodes,
+ const size_t num_bytes, const size_t block_start, const ZopfliNode* nodes,
int* dist_cache, size_t* last_insert_len, const BrotliEncoderParams* params,
Command* commands, size_t* num_literals);
diff --git a/c/enc/backward_references_inc.h b/c/enc/backward_references_inc.h
index 38a48d3..c18cdb0 100644
--- a/c/enc/backward_references_inc.h
+++ b/c/enc/backward_references_inc.h
@@ -10,9 +10,9 @@
static BROTLI_NOINLINE void EXPORT_FN(CreateBackwardReferences)(
size_t num_bytes, size_t position,
const uint8_t* ringbuffer, size_t ringbuffer_mask,
- const BrotliEncoderParams* params, HasherHandle hasher, int* dist_cache,
- size_t* last_insert_len, Command* commands, size_t* num_commands,
- size_t* num_literals) {
+ const BrotliEncoderParams* params,
+ HasherHandle hasher, int* dist_cache, size_t* last_insert_len,
+ Command* commands, size_t* num_commands, size_t* num_literals) {
/* Set maximum distance, see section 9.1. of the spec. */
const size_t max_backward_limit = BROTLI_MAX_BACKWARD_LIMIT(params->lgwin);
@@ -42,9 +42,8 @@
sr.distance = 0;
sr.score = kMinScore;
FN(FindLongestMatch)(hasher, ¶ms->dictionary,
- ringbuffer, ringbuffer_mask, dist_cache, position,
- max_length, max_distance, gap,
- params->dist.max_distance, &sr);
+ ringbuffer, ringbuffer_mask, dist_cache, position, max_length,
+ max_distance, gap, params->dist.max_distance, &sr);
if (sr.score > kMinScore) {
/* Found a match. Let's look for something even better ahead. */
int delayed_backward_references_in_row = 0;
@@ -58,7 +57,8 @@
sr2.distance = 0;
sr2.score = kMinScore;
max_distance = BROTLI_MIN(size_t, position + 1, max_backward_limit);
- FN(FindLongestMatch)(hasher, ¶ms->dictionary,
+ FN(FindLongestMatch)(hasher,
+ ¶ms->dictionary,
ringbuffer, ringbuffer_mask, dist_cache, position + 1, max_length,
max_distance, gap, params->dist.max_distance, &sr2);
if (sr2.score >= sr.score + cost_diff_lazy) {
@@ -80,8 +80,8 @@
{
/* The first 16 codes are special short-codes,
and the minimum offset is 1. */
- size_t distance_code =
- ComputeDistanceCode(sr.distance, max_distance + gap, dist_cache);
+ size_t distance_code = ComputeDistanceCode(
+ sr.distance, max_distance + gap, dist_cache);
if ((sr.distance <= (max_distance + gap)) && distance_code > 0) {
dist_cache[3] = dist_cache[2];
dist_cache[2] = dist_cache[1];
diff --git a/c/enc/encode.c b/c/enc/encode.c
index ec56da2..141e70a 100644
--- a/c/enc/encode.c
+++ b/c/enc/encode.c
@@ -496,6 +496,8 @@
static BROTLI_BOOL ShouldCompress(
const uint8_t* data, const size_t mask, const uint64_t last_flush_pos,
const size_t bytes, const size_t num_literals, const size_t num_commands) {
+ /* TODO: find more precise minimal block overhead. */
+ if (bytes <= 2) return BROTLI_FALSE;
if (num_commands < (bytes >> 8) + 2) {
if (num_literals > 0.99 * (double)bytes) {
uint32_t literal_histo[256] = { 0 };
@@ -674,12 +676,14 @@
if (BROTLI_IS_OOM(&s->memory_manager_)) return BROTLI_FALSE;
if (s->is_initialized_) return BROTLI_TRUE;
+ s->last_bytes_bits_ = 0;
+ s->last_bytes_ = 0;
+ s->remaining_metadata_bytes_ = BROTLI_UINT32_MAX;
+
SanitizeParams(&s->params);
s->params.lgblock = ComputeLgBlock(&s->params);
ChooseDistanceParams(&s->params);
- s->remaining_metadata_bytes_ = BROTLI_UINT32_MAX;
-
RingBufferSetup(&s->params, &s->ringbuffer_);
/* Initialize last byte with stream header. */
@@ -1029,23 +1033,20 @@
if (s->params.quality == ZOPFLIFICATION_QUALITY) {
BROTLI_DCHECK(s->params.hasher.type == 10);
- BrotliCreateZopfliBackwardReferences(m,
- bytes, wrapped_last_processed_pos,
+ BrotliCreateZopfliBackwardReferences(m, bytes, wrapped_last_processed_pos,
data, mask, &s->params, s->hasher_, s->dist_cache_,
&s->last_insert_len_, &s->commands_[s->num_commands_],
&s->num_commands_, &s->num_literals_);
if (BROTLI_IS_OOM(m)) return BROTLI_FALSE;
} else if (s->params.quality == HQ_ZOPFLIFICATION_QUALITY) {
BROTLI_DCHECK(s->params.hasher.type == 10);
- BrotliCreateHqZopfliBackwardReferences(m,
- bytes, wrapped_last_processed_pos,
+ BrotliCreateHqZopfliBackwardReferences(m, bytes, wrapped_last_processed_pos,
data, mask, &s->params, s->hasher_, s->dist_cache_,
&s->last_insert_len_, &s->commands_[s->num_commands_],
&s->num_commands_, &s->num_literals_);
if (BROTLI_IS_OOM(m)) return BROTLI_FALSE;
} else {
- BrotliCreateBackwardReferences(
- bytes, wrapped_last_processed_pos,
+ BrotliCreateBackwardReferences(bytes, wrapped_last_processed_pos,
data, mask, &s->params, s->hasher_, s->dist_cache_,
&s->last_insert_len_, &s->commands_[s->num_commands_],
&s->num_commands_, &s->num_literals_);
@@ -1166,7 +1167,6 @@
MemoryManager* m = &memory_manager;
const size_t mask = BROTLI_SIZE_MAX >> 1;
- const size_t max_backward_limit = BROTLI_MAX_BACKWARD_LIMIT(lgwin);
int dist_cache[4] = { 4, 11, 15, 16 };
int saved_dist_cache[4] = { 4, 11, 15, 16 };
BROTLI_BOOL ok = BROTLI_TRUE;
@@ -1176,8 +1176,8 @@
uint8_t last_bytes_bits;
HasherHandle hasher = NULL;
- const size_t hasher_eff_size =
- BROTLI_MIN(size_t, input_size, max_backward_limit + BROTLI_WINDOW_GAP);
+ const size_t hasher_eff_size = BROTLI_MIN(size_t,
+ input_size, BROTLI_MAX_BACKWARD_LIMIT(lgwin) + BROTLI_WINDOW_GAP);
BrotliEncoderParams params;
@@ -1238,9 +1238,9 @@
BrotliInitZopfliNodes(nodes, block_size + 1);
StitchToPreviousBlockH10(hasher, block_size, block_start,
input_buffer, mask);
- path_size = BrotliZopfliComputeShortestPath(m,
- block_size, block_start, input_buffer, mask, ¶ms,
- max_backward_limit, dist_cache, hasher, nodes);
+ path_size = BrotliZopfliComputeShortestPath(m, block_size, block_start,
+ input_buffer, mask, ¶ms, dist_cache, hasher,
+ nodes);
if (BROTLI_IS_OOM(m)) goto oom;
/* We allocate a command buffer in the first iteration of this loop that
will be likely big enough for the whole metablock, so that for most
@@ -1262,10 +1262,8 @@
}
commands = new_commands;
}
- BrotliZopfliCreateCommands(block_size, block_start, max_backward_limit,
- &nodes[0], dist_cache, &last_insert_len,
- ¶ms, &commands[num_commands],
- &num_literals);
+ BrotliZopfliCreateCommands(block_size, block_start, &nodes[0], dist_cache,
+ &last_insert_len, ¶ms, &commands[num_commands], &num_literals);
num_commands += path_size;
block_start += block_size;
metablock_size += block_size;
diff --git a/c/enc/hash.h b/c/enc/hash.h
index 2602490..8c5a7bb 100644
--- a/c/enc/hash.h
+++ b/c/enc/hash.h
@@ -149,9 +149,9 @@
}
static BROTLI_INLINE BROTLI_BOOL TestStaticDictionaryItem(
- const BrotliEncoderDictionary* dictionary, size_t item, const uint8_t* data,
- size_t max_length, size_t max_backward, size_t max_distance,
- HasherSearchResult* out) {
+ const BrotliEncoderDictionary* dictionary, size_t item,
+ const uint8_t* data, size_t max_length, size_t max_backward,
+ size_t max_distance, HasherSearchResult* out) {
size_t len;
size_t word_idx;
size_t offset;
@@ -208,7 +208,8 @@
self->dict_num_lookups++;
if (item != 0) {
BROTLI_BOOL item_matches = TestStaticDictionaryItem(
- dictionary, item, data, max_length, max_backward, max_distance, out);
+ dictionary, item, data,
+ max_length, max_backward, max_distance, out);
if (item_matches) {
self->dict_num_matches++;
}
diff --git a/c/enc/hash_composite_inc.h b/c/enc/hash_composite_inc.h
index f829a97..b266aa2 100755
--- a/c/enc/hash_composite_inc.h
+++ b/c/enc/hash_composite_inc.h
@@ -121,13 +121,16 @@
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, HasherSearchResult* BROTLI_RESTRICT out) {
+ const size_t max_length, const size_t max_backward,
+ const size_t gap, 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, max_distance, out);
+ distance_cache, cur_ix, max_length, max_backward, gap,
+ max_distance, out);
FN_B(FindLongestMatch)(self->hb, dictionary, data, ring_buffer_mask,
- distance_cache, cur_ix, max_length, max_backward, gap, max_distance, out);
+ distance_cache, cur_ix, max_length, max_backward, gap,
+ max_distance, out);
}
#undef HashComposite
diff --git a/c/enc/hash_longest_match64_inc.h b/c/enc/hash_longest_match64_inc.h
index e099edf..cb953a6 100644
--- a/c/enc/hash_longest_match64_inc.h
+++ b/c/enc/hash_longest_match64_inc.h
@@ -161,8 +161,9 @@
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, HasherSearchResult* BROTLI_RESTRICT out) {
+ const size_t max_length, const size_t max_backward,
+ const size_t gap, const size_t max_distance,
+ HasherSearchResult* BROTLI_RESTRICT out) {
HasherCommon* common = GetHasherCommon(handle);
HashLongestMatch* self = FN(Self)(handle);
uint16_t* num = FN(Num)(self);
diff --git a/c/enc/hash_longest_match_inc.h b/c/enc/hash_longest_match_inc.h
index 951d7a4..457f5a9 100644
--- a/c/enc/hash_longest_match_inc.h
+++ b/c/enc/hash_longest_match_inc.h
@@ -154,8 +154,9 @@
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, HasherSearchResult* BROTLI_RESTRICT out) {
+ const size_t max_length, const size_t max_backward,
+ const size_t gap, const size_t max_distance,
+ HasherSearchResult* BROTLI_RESTRICT out) {
HasherCommon* common = GetHasherCommon(handle);
HashLongestMatch* self = FN(Self)(handle);
uint16_t* num = FN(Num)(self);
diff --git a/c/enc/hash_rolling_inc.h b/c/enc/hash_rolling_inc.h
index 4d5d14a..17f8a40 100755
--- a/c/enc/hash_rolling_inc.h
+++ b/c/enc/hash_rolling_inc.h
@@ -155,8 +155,9 @@
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, HasherSearchResult* BROTLI_RESTRICT out) {
+ const size_t max_length, const size_t max_backward,
+ const size_t gap, const size_t max_distance,
+ HasherSearchResult* BROTLI_RESTRICT out) {
HashRolling* self = FN(Self)(handle);
const size_t cur_ix_masked = cur_ix & ring_buffer_mask;
size_t pos = self->next_ix;
diff --git a/c/enc/hash_to_binary_tree_inc.h b/c/enc/hash_to_binary_tree_inc.h
index 48097b1..7fb0356 100644
--- a/c/enc/hash_to_binary_tree_inc.h
+++ b/c/enc/hash_to_binary_tree_inc.h
@@ -202,8 +202,9 @@
static BROTLI_INLINE size_t FN(FindAllMatches)(HasherHandle handle,
const BrotliEncoderDictionary* dictionary, const uint8_t* data,
const size_t ring_buffer_mask, const size_t cur_ix,
- const size_t max_length, const size_t max_backward, const size_t gap,
- const BrotliEncoderParams* params, BackwardMatch* matches) {
+ const size_t max_length, const size_t max_backward,
+ const size_t gap, const BrotliEncoderParams* params,
+ BackwardMatch* matches) {
BackwardMatch* const orig_matches = matches;
const size_t cur_ix_masked = cur_ix & ring_buffer_mask;
size_t best_len = 1;
