static void
length_update_prices(lzma_length_encoder *lc, const uint32_t pos_state)
{
const uint32_t table_size = lc->table_size;
lc->counters[pos_state] = table_size;
const uint32_t a0 = rc_bit_0_price(lc->choice);
const uint32_t a1 = rc_bit_1_price(lc->choice);
const uint32_t b0 = a1 + rc_bit_0_price(lc->choice2);
const uint32_t b1 = a1 + rc_bit_1_price(lc->choice2);
uint32_t *const prices = lc->prices[pos_state];
uint32_t i;
for (i = 0; i < table_size && i < LEN_LOW_SYMBOLS; ++i)
prices[i] = a0 + rc_bittree_price(lc->low[pos_state],
LEN_LOW_BITS, i);
for (; i < table_size && i < LEN_LOW_SYMBOLS + LEN_MID_SYMBOLS; ++i)
prices[i] = b0 + rc_bittree_price(lc->mid[pos_state],
LEN_MID_BITS, i - LEN_LOW_SYMBOLS);
for (; i < table_size; ++i)
prices[i] = b1 + rc_bittree_price(lc->high, LEN_HIGH_BITS,
i - LEN_LOW_SYMBOLS - LEN_MID_SYMBOLS);
return;
}
static uint32_t
get_literal_price(const lzma_coder *const coder, const uint32_t pos,
const uint32_t prev_byte, const bool match_mode,
uint32_t match_byte, uint32_t symbol)
{
const probability *const subcoder = literal_subcoder(coder->literal,
coder->literal_context_bits, coder->literal_pos_mask,
pos, prev_byte);
uint32_t price = 0;
if (!match_mode) {
price = rc_bittree_price(subcoder, 8, symbol);
} else {
uint32_t offset = 0x100;
symbol += UINT32_C(1) << 8;
do {
match_byte <<= 1;
const uint32_t match_bit = match_byte & offset;
const uint32_t subcoder_index
= offset + match_bit + (symbol >> 8);
const uint32_t bit = (symbol >> 7) & 1;
price += rc_bit_price(subcoder[subcoder_index], bit);
symbol <<= 1;
offset &= ~(match_byte ^ symbol);
} while (symbol < (UINT32_C(1) << 16));
}
return price;
}
static void
fill_distances_prices(lzma_coder *coder)
{
for (uint32_t len_to_pos_state = 0;
len_to_pos_state < LEN_TO_POS_STATES;
++len_to_pos_state) {
uint32_t *const pos_slot_prices
= coder->pos_slot_prices[len_to_pos_state];
// Price to encode the pos_slot.
for (uint32_t pos_slot = 0;
pos_slot < coder->dist_table_size; ++pos_slot)
pos_slot_prices[pos_slot] = rc_bittree_price(
coder->pos_slot[len_to_pos_state],
POS_SLOT_BITS, pos_slot);
// For matches with distance >= FULL_DISTANCES, add the price
// of the direct bits part of the match distance. (Align bits
// are handled by fill_align_prices()).
for (uint32_t pos_slot = END_POS_MODEL_INDEX;
pos_slot < coder->dist_table_size; ++pos_slot)
pos_slot_prices[pos_slot] += rc_direct_price(
((pos_slot >> 1) - 1) - ALIGN_BITS);
// Distances in the range [0, 3] are fully encoded with
// pos_slot, so they are used for coder->distances_prices
// as is.
for (uint32_t i = 0; i < START_POS_MODEL_INDEX; ++i)
coder->distances_prices[len_to_pos_state][i]
= pos_slot_prices[i];
}
// Distances in the range [4, 127] depend on pos_slot and pos_special.
// We do this in a loop separate from the above loop to avoid
// redundant calls to get_pos_slot().
for (uint32_t i = START_POS_MODEL_INDEX; i < FULL_DISTANCES; ++i) {
const uint32_t pos_slot = get_pos_slot(i);
const uint32_t footer_bits = ((pos_slot >> 1) - 1);
const uint32_t base = (2 | (pos_slot & 1)) << footer_bits;
const uint32_t price = rc_bittree_reverse_price(
coder->pos_special + base - pos_slot - 1,
footer_bits, i - base);
for (uint32_t len_to_pos_state = 0;
len_to_pos_state < LEN_TO_POS_STATES;
++len_to_pos_state)
coder->distances_prices[len_to_pos_state][i]
= price + coder->pos_slot_prices[
len_to_pos_state][pos_slot];
}
coder->match_price_count = 0;
return;
}