/* NOLINT(build/header_guard) */ | |
/* Copyright 2013 Google Inc. All Rights Reserved. | |
Distributed under MIT license. | |
See file LICENSE for detail or copy at https://opensource.org/licenses/MIT | |
*/ | |
/* template parameters: FN, DataType */ | |
#define HistogramType FN(Histogram) | |
static void FN(InitialEntropyCodes)(const DataType* data, size_t length, | |
size_t stride, | |
size_t num_histograms, | |
HistogramType* histograms) { | |
unsigned int seed = 7; | |
size_t block_length = length / num_histograms; | |
size_t i; | |
FN(ClearHistograms)(histograms, num_histograms); | |
for (i = 0; i < num_histograms; ++i) { | |
size_t pos = length * i / num_histograms; | |
if (i != 0) { | |
pos += MyRand(&seed) % block_length; | |
} | |
if (pos + stride >= length) { | |
pos = length - stride - 1; | |
} | |
FN(HistogramAddVector)(&histograms[i], data + pos, stride); | |
} | |
} | |
static void FN(RandomSample)(unsigned int* seed, | |
const DataType* data, | |
size_t length, | |
size_t stride, | |
HistogramType* sample) { | |
size_t pos = 0; | |
if (stride >= length) { | |
pos = 0; | |
stride = length; | |
} else { | |
pos = MyRand(seed) % (length - stride + 1); | |
} | |
FN(HistogramAddVector)(sample, data + pos, stride); | |
} | |
static void FN(RefineEntropyCodes)(const DataType* data, size_t length, | |
size_t stride, | |
size_t num_histograms, | |
HistogramType* histograms) { | |
size_t iters = | |
kIterMulForRefining * length / stride + kMinItersForRefining; | |
unsigned int seed = 7; | |
size_t iter; | |
iters = ((iters + num_histograms - 1) / num_histograms) * num_histograms; | |
for (iter = 0; iter < iters; ++iter) { | |
HistogramType sample; | |
FN(HistogramClear)(&sample); | |
FN(RandomSample)(&seed, data, length, stride, &sample); | |
FN(HistogramAddHistogram)(&histograms[iter % num_histograms], &sample); | |
} | |
} | |
/* Assigns a block id from the range [0, vec.size()) to each data element | |
in data[0..length) and fills in block_id[0..length) with the assigned values. | |
Returns the number of blocks, i.e. one plus the number of block switches. */ | |
static size_t FN(FindBlocks)(const DataType* data, const size_t length, | |
const double block_switch_bitcost, | |
const size_t num_histograms, | |
const HistogramType* histograms, | |
double* insert_cost, | |
double* cost, | |
uint8_t* switch_signal, | |
uint8_t *block_id) { | |
const size_t data_size = FN(HistogramDataSize)(); | |
const size_t bitmaplen = (num_histograms + 7) >> 3; | |
size_t num_blocks = 1; | |
size_t i; | |
size_t j; | |
assert(num_histograms <= 256); | |
if (num_histograms <= 1) { | |
for (i = 0; i < length; ++i) { | |
block_id[i] = 0; | |
} | |
return 1; | |
} | |
memset(insert_cost, 0, sizeof(insert_cost[0]) * data_size * num_histograms); | |
for (i = 0; i < num_histograms; ++i) { | |
insert_cost[i] = FastLog2((uint32_t)histograms[i].total_count_); | |
} | |
for (i = data_size; i != 0;) { | |
--i; | |
for (j = 0; j < num_histograms; ++j) { | |
insert_cost[i * num_histograms + j] = | |
insert_cost[j] - BitCost(histograms[j].data_[i]); | |
} | |
} | |
memset(cost, 0, sizeof(cost[0]) * num_histograms); | |
memset(switch_signal, 0, sizeof(switch_signal[0]) * length * bitmaplen); | |
/* After each iteration of this loop, cost[k] will contain the difference | |
between the minimum cost of arriving at the current byte position using | |
entropy code k, and the minimum cost of arriving at the current byte | |
position. This difference is capped at the block switch cost, and if it | |
reaches block switch cost, it means that when we trace back from the last | |
position, we need to switch here. */ | |
for (i = 0; i < length; ++i) { | |
const size_t byte_ix = i; | |
size_t ix = byte_ix * bitmaplen; | |
size_t insert_cost_ix = data[byte_ix] * num_histograms; | |
double min_cost = 1e99; | |
double block_switch_cost = block_switch_bitcost; | |
size_t k; | |
for (k = 0; k < num_histograms; ++k) { | |
/* We are coding the symbol in data[byte_ix] with entropy code k. */ | |
cost[k] += insert_cost[insert_cost_ix + k]; | |
if (cost[k] < min_cost) { | |
min_cost = cost[k]; | |
block_id[byte_ix] = (uint8_t)k; | |
} | |
} | |
/* More blocks for the beginning. */ | |
if (byte_ix < 2000) { | |
block_switch_cost *= 0.77 + 0.07 * (double)byte_ix / 2000; | |
} | |
for (k = 0; k < num_histograms; ++k) { | |
cost[k] -= min_cost; | |
if (cost[k] >= block_switch_cost) { | |
const uint8_t mask = (uint8_t)(1u << (k & 7)); | |
cost[k] = block_switch_cost; | |
assert((k >> 3) < bitmaplen); | |
switch_signal[ix + (k >> 3)] |= mask; | |
} | |
} | |
} | |
{ /* Trace back from the last position and switch at the marked places. */ | |
size_t byte_ix = length - 1; | |
size_t ix = byte_ix * bitmaplen; | |
uint8_t cur_id = block_id[byte_ix]; | |
while (byte_ix > 0) { | |
const uint8_t mask = (uint8_t)(1u << (cur_id & 7)); | |
assert(((size_t)cur_id >> 3) < bitmaplen); | |
--byte_ix; | |
ix -= bitmaplen; | |
if (switch_signal[ix + (cur_id >> 3)] & mask) { | |
if (cur_id != block_id[byte_ix]) { | |
cur_id = block_id[byte_ix]; | |
++num_blocks; | |
} | |
} | |
block_id[byte_ix] = cur_id; | |
} | |
} | |
return num_blocks; | |
} | |
static size_t FN(RemapBlockIds)(uint8_t* block_ids, const size_t length, | |
uint16_t* new_id, const size_t num_histograms) { | |
static const uint16_t kInvalidId = 256; | |
uint16_t next_id = 0; | |
size_t i; | |
for (i = 0; i < num_histograms; ++i) { | |
new_id[i] = kInvalidId; | |
} | |
for (i = 0; i < length; ++i) { | |
assert(block_ids[i] < num_histograms); | |
if (new_id[block_ids[i]] == kInvalidId) { | |
new_id[block_ids[i]] = next_id++; | |
} | |
} | |
for (i = 0; i < length; ++i) { | |
block_ids[i] = (uint8_t)new_id[block_ids[i]]; | |
assert(block_ids[i] < num_histograms); | |
} | |
assert(next_id <= num_histograms); | |
return next_id; | |
} | |
static void FN(BuildBlockHistograms)(const DataType* data, const size_t length, | |
const uint8_t* block_ids, | |
const size_t num_histograms, | |
HistogramType* histograms) { | |
size_t i; | |
FN(ClearHistograms)(histograms, num_histograms); | |
for (i = 0; i < length; ++i) { | |
FN(HistogramAdd)(&histograms[block_ids[i]], data[i]); | |
} | |
} | |
static void FN(ClusterBlocks)(MemoryManager* m, | |
const DataType* data, const size_t length, | |
const size_t num_blocks, | |
uint8_t* block_ids, | |
BlockSplit* split) { | |
uint32_t* histogram_symbols = BROTLI_ALLOC(m, uint32_t, num_blocks); | |
uint32_t* block_lengths = BROTLI_ALLOC(m, uint32_t, num_blocks); | |
const size_t expected_num_clusters = CLUSTERS_PER_BATCH * | |
(num_blocks + HISTOGRAMS_PER_BATCH - 1) / HISTOGRAMS_PER_BATCH; | |
size_t all_histograms_size = 0; | |
size_t all_histograms_capacity = expected_num_clusters; | |
HistogramType* all_histograms = | |
BROTLI_ALLOC(m, HistogramType, all_histograms_capacity); | |
size_t cluster_size_size = 0; | |
size_t cluster_size_capacity = expected_num_clusters; | |
uint32_t* cluster_size = BROTLI_ALLOC(m, uint32_t, cluster_size_capacity); | |
size_t num_clusters = 0; | |
HistogramType* histograms = BROTLI_ALLOC(m, HistogramType, | |
BROTLI_MIN(size_t, num_blocks, HISTOGRAMS_PER_BATCH)); | |
size_t max_num_pairs = | |
HISTOGRAMS_PER_BATCH * HISTOGRAMS_PER_BATCH / 2; | |
size_t pairs_capacity = max_num_pairs + 1; | |
HistogramPair* pairs = BROTLI_ALLOC(m, HistogramPair, pairs_capacity); | |
size_t pos = 0; | |
uint32_t* clusters; | |
size_t num_final_clusters; | |
static const uint32_t kInvalidIndex = BROTLI_UINT32_MAX; | |
uint32_t* new_index; | |
uint8_t max_type = 0; | |
size_t i; | |
uint32_t sizes[HISTOGRAMS_PER_BATCH] = { 0 }; | |
uint32_t new_clusters[HISTOGRAMS_PER_BATCH] = { 0 }; | |
uint32_t symbols[HISTOGRAMS_PER_BATCH] = { 0 }; | |
uint32_t remap[HISTOGRAMS_PER_BATCH] = { 0 }; | |
if (BROTLI_IS_OOM(m)) return; | |
memset(block_lengths, 0, num_blocks * sizeof(uint32_t)); | |
{ | |
size_t block_idx = 0; | |
for (i = 0; i < length; ++i) { | |
assert(block_idx < num_blocks); | |
++block_lengths[block_idx]; | |
if (i + 1 == length || block_ids[i] != block_ids[i + 1]) { | |
++block_idx; | |
} | |
} | |
assert(block_idx == num_blocks); | |
} | |
for (i = 0; i < num_blocks; i += HISTOGRAMS_PER_BATCH) { | |
const size_t num_to_combine = | |
BROTLI_MIN(size_t, num_blocks - i, HISTOGRAMS_PER_BATCH); | |
size_t num_new_clusters; | |
size_t j; | |
for (j = 0; j < num_to_combine; ++j) { | |
size_t k; | |
FN(HistogramClear)(&histograms[j]); | |
for (k = 0; k < block_lengths[i + j]; ++k) { | |
FN(HistogramAdd)(&histograms[j], data[pos++]); | |
} | |
histograms[j].bit_cost_ = FN(BrotliPopulationCost)(&histograms[j]); | |
new_clusters[j] = (uint32_t)j; | |
symbols[j] = (uint32_t)j; | |
sizes[j] = 1; | |
} | |
num_new_clusters = FN(BrotliHistogramCombine)( | |
histograms, sizes, symbols, new_clusters, pairs, num_to_combine, | |
num_to_combine, HISTOGRAMS_PER_BATCH, max_num_pairs); | |
BROTLI_ENSURE_CAPACITY(m, HistogramType, all_histograms, | |
all_histograms_capacity, all_histograms_size + num_new_clusters); | |
BROTLI_ENSURE_CAPACITY(m, uint32_t, cluster_size, | |
cluster_size_capacity, cluster_size_size + num_new_clusters); | |
if (BROTLI_IS_OOM(m)) return; | |
for (j = 0; j < num_new_clusters; ++j) { | |
all_histograms[all_histograms_size++] = histograms[new_clusters[j]]; | |
cluster_size[cluster_size_size++] = sizes[new_clusters[j]]; | |
remap[new_clusters[j]] = (uint32_t)j; | |
} | |
for (j = 0; j < num_to_combine; ++j) { | |
histogram_symbols[i + j] = (uint32_t)num_clusters + remap[symbols[j]]; | |
} | |
num_clusters += num_new_clusters; | |
assert(num_clusters == cluster_size_size); | |
assert(num_clusters == all_histograms_size); | |
} | |
BROTLI_FREE(m, histograms); | |
max_num_pairs = | |
BROTLI_MIN(size_t, 64 * num_clusters, (num_clusters / 2) * num_clusters); | |
if (pairs_capacity < max_num_pairs + 1) { | |
BROTLI_FREE(m, pairs); | |
pairs = BROTLI_ALLOC(m, HistogramPair, max_num_pairs + 1); | |
if (BROTLI_IS_OOM(m)) return; | |
} | |
clusters = BROTLI_ALLOC(m, uint32_t, num_clusters); | |
if (BROTLI_IS_OOM(m)) return; | |
for (i = 0; i < num_clusters; ++i) { | |
clusters[i] = (uint32_t)i; | |
} | |
num_final_clusters = FN(BrotliHistogramCombine)( | |
all_histograms, cluster_size, histogram_symbols, clusters, pairs, | |
num_clusters, num_blocks, BROTLI_MAX_NUMBER_OF_BLOCK_TYPES, | |
max_num_pairs); | |
BROTLI_FREE(m, pairs); | |
BROTLI_FREE(m, cluster_size); | |
new_index = BROTLI_ALLOC(m, uint32_t, num_clusters); | |
if (BROTLI_IS_OOM(m)) return; | |
for (i = 0; i < num_clusters; ++i) new_index[i] = kInvalidIndex; | |
pos = 0; | |
{ | |
uint32_t next_index = 0; | |
for (i = 0; i < num_blocks; ++i) { | |
HistogramType histo; | |
size_t j; | |
uint32_t best_out; | |
double best_bits; | |
FN(HistogramClear)(&histo); | |
for (j = 0; j < block_lengths[i]; ++j) { | |
FN(HistogramAdd)(&histo, data[pos++]); | |
} | |
best_out = (i == 0) ? histogram_symbols[0] : histogram_symbols[i - 1]; | |
best_bits = | |
FN(BrotliHistogramBitCostDistance)(&histo, &all_histograms[best_out]); | |
for (j = 0; j < num_final_clusters; ++j) { | |
const double cur_bits = FN(BrotliHistogramBitCostDistance)( | |
&histo, &all_histograms[clusters[j]]); | |
if (cur_bits < best_bits) { | |
best_bits = cur_bits; | |
best_out = clusters[j]; | |
} | |
} | |
histogram_symbols[i] = best_out; | |
if (new_index[best_out] == kInvalidIndex) { | |
new_index[best_out] = next_index++; | |
} | |
} | |
} | |
BROTLI_FREE(m, clusters); | |
BROTLI_FREE(m, all_histograms); | |
BROTLI_ENSURE_CAPACITY( | |
m, uint8_t, split->types, split->types_alloc_size, num_blocks); | |
BROTLI_ENSURE_CAPACITY( | |
m, uint32_t, split->lengths, split->lengths_alloc_size, num_blocks); | |
if (BROTLI_IS_OOM(m)) return; | |
{ | |
uint32_t cur_length = 0; | |
size_t block_idx = 0; | |
for (i = 0; i < num_blocks; ++i) { | |
cur_length += block_lengths[i]; | |
if (i + 1 == num_blocks || | |
histogram_symbols[i] != histogram_symbols[i + 1]) { | |
const uint8_t id = (uint8_t)new_index[histogram_symbols[i]]; | |
split->types[block_idx] = id; | |
split->lengths[block_idx] = cur_length; | |
max_type = BROTLI_MAX(uint8_t, max_type, id); | |
cur_length = 0; | |
++block_idx; | |
} | |
} | |
split->num_blocks = block_idx; | |
split->num_types = (size_t)max_type + 1; | |
} | |
BROTLI_FREE(m, new_index); | |
BROTLI_FREE(m, block_lengths); | |
BROTLI_FREE(m, histogram_symbols); | |
} | |
static void FN(SplitByteVector)(MemoryManager* m, | |
const DataType* data, const size_t length, | |
const size_t literals_per_histogram, | |
const size_t max_histograms, | |
const size_t sampling_stride_length, | |
const double block_switch_cost, | |
const BrotliEncoderParams* params, | |
BlockSplit* split) { | |
const size_t data_size = FN(HistogramDataSize)(); | |
size_t num_histograms = length / literals_per_histogram + 1; | |
HistogramType* histograms; | |
if (num_histograms > max_histograms) { | |
num_histograms = max_histograms; | |
} | |
if (length == 0) { | |
split->num_types = 1; | |
return; | |
} else if (length < kMinLengthForBlockSplitting) { | |
BROTLI_ENSURE_CAPACITY(m, uint8_t, | |
split->types, split->types_alloc_size, split->num_blocks + 1); | |
BROTLI_ENSURE_CAPACITY(m, uint32_t, | |
split->lengths, split->lengths_alloc_size, split->num_blocks + 1); | |
if (BROTLI_IS_OOM(m)) return; | |
split->num_types = 1; | |
split->types[split->num_blocks] = 0; | |
split->lengths[split->num_blocks] = (uint32_t)length; | |
split->num_blocks++; | |
return; | |
} | |
histograms = BROTLI_ALLOC(m, HistogramType, num_histograms); | |
if (BROTLI_IS_OOM(m)) return; | |
/* Find good entropy codes. */ | |
FN(InitialEntropyCodes)(data, length, | |
sampling_stride_length, | |
num_histograms, histograms); | |
FN(RefineEntropyCodes)(data, length, | |
sampling_stride_length, | |
num_histograms, histograms); | |
{ | |
/* Find a good path through literals with the good entropy codes. */ | |
uint8_t* block_ids = BROTLI_ALLOC(m, uint8_t, length); | |
size_t num_blocks; | |
const size_t bitmaplen = (num_histograms + 7) >> 3; | |
double* insert_cost = BROTLI_ALLOC(m, double, data_size * num_histograms); | |
double* cost = BROTLI_ALLOC(m, double, num_histograms); | |
uint8_t* switch_signal = BROTLI_ALLOC(m, uint8_t, length * bitmaplen); | |
uint16_t* new_id = BROTLI_ALLOC(m, uint16_t, num_histograms); | |
const size_t iters = params->quality < HQ_ZOPFLIFICATION_QUALITY ? 3 : 10; | |
size_t i; | |
if (BROTLI_IS_OOM(m)) return; | |
for (i = 0; i < iters; ++i) { | |
num_blocks = FN(FindBlocks)(data, length, | |
block_switch_cost, | |
num_histograms, histograms, | |
insert_cost, cost, switch_signal, | |
block_ids); | |
num_histograms = FN(RemapBlockIds)(block_ids, length, | |
new_id, num_histograms); | |
FN(BuildBlockHistograms)(data, length, block_ids, | |
num_histograms, histograms); | |
} | |
BROTLI_FREE(m, insert_cost); | |
BROTLI_FREE(m, cost); | |
BROTLI_FREE(m, switch_signal); | |
BROTLI_FREE(m, new_id); | |
BROTLI_FREE(m, histograms); | |
FN(ClusterBlocks)(m, data, length, num_blocks, block_ids, split); | |
if (BROTLI_IS_OOM(m)) return; | |
BROTLI_FREE(m, block_ids); | |
} | |
} | |
#undef HistogramType |