C++ (Cpp) rc_bittree_price Examples

Example #1

File: lzma_encoder.c Project: rsenn/dirlist

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;
}

Example #2

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;
}

Example #3

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;
}