LZMA encoder. More...

#include "lzma2_encoder.h"
#include "lzma_encoder_private.h"
#include "fastpos.h"

Macros
#define	LOOP_INPUT_MAX (OPTS + 1)

Functions
static void	literal_matched (lzma_range_encoder rc, probability subcoder, uint32_t match_byte, uint32_t symbol)

static void	literal (lzma_lzma1_encoder coder, lzma_mf mf, uint32_t position)

static void	length_update_prices (lzma_length_encoder *lc, const uint32_t pos_state)

static void	length (lzma_range_encoder rc, lzma_length_encoder lc, const uint32_t pos_state, uint32_t len, const bool fast_mode)

static void	match (lzma_lzma1_encoder *coder, const uint32_t pos_state, const uint32_t distance, const uint32_t len)

static void	rep_match (lzma_lzma1_encoder *coder, const uint32_t pos_state, const uint32_t rep, const uint32_t len)

static void	encode_symbol (lzma_lzma1_encoder coder, lzma_mf mf, uint32_t back, uint32_t len, uint32_t position)

static bool	encode_init (lzma_lzma1_encoder coder, lzma_mf mf)

static void	encode_eopm (lzma_lzma1_encoder *coder, uint32_t position)

lzma_ret	lzma_lzma_encode (lzma_lzma1_encoder restrict coder, lzma_mf restrict mf, uint8_t restrict out, size_t restrict out_pos, size_t out_size, uint32_t limit)

static lzma_ret	lzma_encode (void coder, lzma_mf restrict mf, uint8_t restrict out, size_t restrict out_pos, size_t out_size)

static bool	is_options_valid (const lzma_options_lzma *options)

static void	set_lz_options (lzma_lz_options lz_options, const lzma_options_lzma options)

static void	length_encoder_reset (lzma_length_encoder *lencoder, const uint32_t num_pos_states, const bool fast_mode)

lzma_ret	lzma_lzma_encoder_reset (lzma_lzma1_encoder coder, const lzma_options_lzma options)

lzma_ret	lzma_lzma_encoder_create (void *coder_ptr, const lzma_allocator allocator, const lzma_options_lzma options, lzma_lz_options lz_options)

static lzma_ret	lzma_encoder_init (lzma_lz_encoder lz, const lzma_allocator allocator, const void options, lzma_lz_options lz_options)

lzma_ret	lzma_lzma_encoder_init (lzma_next_coder next, const lzma_allocator allocator, const lzma_filter_info *filters)

uint64_t	lzma_lzma_encoder_memusage (const void *options)

bool	lzma_lzma_lclppb_encode (const lzma_options_lzma options, uint8_t byte)
	Encodes lc/lp/pb into one byte. Returns false on success and true on error. More...

	LZMA_API (lzma_bool)

Detailed Description

LZMA encoder.

Definition in file lzma_encoder.c.

Macro Definition Documentation

◆ LOOP_INPUT_MAX

#define LOOP_INPUT_MAX (OPTS + 1)

Number of bytes that a single encoding loop in lzma_lzma_encode() can consume from the dictionary. This limit comes from lzma_lzma_optimum() and may need to be updated if that function is significantly modified.

Definition at line 308 of file lzma_encoder.c.

Function Documentation

◆ encode_eopm()

static void encode_eopm	(	lzma_lzma1_encoder *	coder,
		uint32_t	position
	)

static

Definition at line 296 of file lzma_encoder.c.

 {
     const uint32_t pos_state = position & coder->pos_mask;
     rc_bit(&coder->rc, &coder->is_match[coder->state][pos_state], 1);
     rc_bit(&coder->rc, &coder->is_rep[coder->state], 0);
     match(coder, pos_state, UINT32_MAX, MATCH_LEN_MIN);
 }

References lzma_lzma1_encoder_s::is_match, lzma_lzma1_encoder_s::is_rep, match(), MATCH_LEN_MIN, lzma_lzma1_encoder_s::pos_mask, lzma_lzma1_encoder_s::rc, rc_bit, lzma_lzma1_encoder_s::state, and UINT32_MAX.

Referenced by lzma_lzma_encode().

◆ encode_init()

static bool encode_init	(	lzma_lzma1_encoder *	coder,
		lzma_mf *	mf
	)

static

Definition at line 268 of file lzma_encoder.c.

 {
     assert(mf_position(mf) == 0);
  
     if (mf->read_pos == mf->read_limit) {
         if (mf->action == LZMA_RUN)
             return false; // We cannot do anything.
  
         // We are finishing (we cannot get here when flushing).
         assert(mf->write_pos == mf->read_pos);
         assert(mf->action == LZMA_FINISH);
     } else {
         // Do the actual initialization. The first LZMA symbol must
         // always be a literal.
         mf_skip(mf, 1);
         mf->read_ahead = 0;
         rc_bit(&coder->rc, &coder->is_match[0][0], 0);
         rc_bittree(&coder->rc, coder->literal[0], 8, mf->buffer[0]);
     }
  
     // Initialization is done (except if empty file).
     coder->is_initialized = true;
  
     return true;
 }

References lzma_mf_s::action, assert(), lzma_mf_s::buffer, lzma_lzma1_encoder_s::is_initialized, lzma_lzma1_encoder_s::is_match, lzma_lzma1_encoder_s::literal, LZMA_FINISH, LZMA_RUN, mf_position(), mf_skip(), lzma_lzma1_encoder_s::rc, rc_bit, rc_bittree(), lzma_mf_s::read_ahead, lzma_mf_s::read_limit, lzma_mf_s::read_pos, and lzma_mf_s::write_pos.

Referenced by lzma_lzma_encode().

◆ encode_symbol()

static void encode_symbol	(	lzma_lzma1_encoder *	coder,
		lzma_mf *	mf,
		uint32_t	back,
		uint32_t	len,
		uint32_t	position
	)

static

Definition at line 234 of file lzma_encoder.c.

 {
     const uint32_t pos_state = position & coder->pos_mask;
  
     if (back == UINT32_MAX) {
         // Literal i.e. eight-bit byte
         assert(len == 1);
         rc_bit(&coder->rc,
                 &coder->is_match[coder->state][pos_state], 0);
         literal(coder, mf, position);
     } else {
         // Some type of match
         rc_bit(&coder->rc,
             &coder->is_match[coder->state][pos_state], 1);
  
         if (back < REPS) {
             // It's a repeated match i.e. the same distance
             // has been used earlier.
             rc_bit(&coder->rc, &coder->is_rep[coder->state], 1);
             rep_match(coder, pos_state, back, len);
         } else {
             // Normal match
             rc_bit(&coder->rc, &coder->is_rep[coder->state], 0);
             match(coder, pos_state, back - REPS, len);
         }
     }
  
     assert(mf->read_ahead >= len);
     mf->read_ahead -= len;
 }

References assert(), lzma_lzma1_encoder_s::is_match, lzma_lzma1_encoder_s::is_rep, len, literal(), match(), lzma_lzma1_encoder_s::pos_mask, lzma_lzma1_encoder_s::rc, rc_bit, lzma_mf_s::read_ahead, rep_match(), REPS, lzma_lzma1_encoder_s::state, and UINT32_MAX.

Referenced by lzma_lzma_encode().

◆ is_options_valid()

static bool is_options_valid ( const lzma_options_lzma * options )

static

Definition at line 422 of file lzma_encoder.c.

 {
     // Validate some of the options. LZ encoder validates nice_len too
     // but we need a valid value here earlier.
     return is_lclppb_valid(options)
             && options->nice_len >= MATCH_LEN_MIN
             && options->nice_len <= MATCH_LEN_MAX
             && (options->mode == LZMA_MODE_FAST
                 || options->mode == LZMA_MODE_NORMAL);
 }

References is_lclppb_valid(), LZMA_MODE_FAST, LZMA_MODE_NORMAL, MATCH_LEN_MAX, MATCH_LEN_MIN, and options.

Referenced by lzma_lzma_encoder_memusage(), and lzma_lzma_encoder_reset().

◆ length()

static void length	(	lzma_range_encoder *	rc,
		lzma_length_encoder *	lc,
		const uint32_t	pos_state,
		uint32_t	len,
		const bool	fast_mode
	)

inlinestatic

Definition at line 107 of file lzma_encoder.c.

 {
     assert(len <= MATCH_LEN_MAX);
     len -= MATCH_LEN_MIN;
  
     if (len < LEN_LOW_SYMBOLS) {
         rc_bit(rc, &lc->choice, 0);
         rc_bittree(rc, lc->low[pos_state], LEN_LOW_BITS, len);
     } else {
         rc_bit(rc, &lc->choice, 1);
         len -= LEN_LOW_SYMBOLS;
  
         if (len < LEN_MID_SYMBOLS) {
             rc_bit(rc, &lc->choice2, 0);
             rc_bittree(rc, lc->mid[pos_state], LEN_MID_BITS, len);
         } else {
             rc_bit(rc, &lc->choice2, 1);
             len -= LEN_MID_SYMBOLS;
             rc_bittree(rc, lc->high, LEN_HIGH_BITS, len);
         }
     }
  
     // Only getoptimum uses the prices so don't update the table when
     // in fast mode.
     if (!fast_mode)
         if (--lc->counters[pos_state] == 0)
             length_update_prices(lc, pos_state);
 }

References assert(), lzma_length_encoder::choice, lzma_length_encoder::choice2, lzma_length_encoder::counters, lzma_length_encoder::high, len, LEN_HIGH_BITS, LEN_LOW_BITS, LEN_LOW_SYMBOLS, LEN_MID_BITS, LEN_MID_SYMBOLS, length_update_prices(), lzma_length_encoder::low, MATCH_LEN_MAX, MATCH_LEN_MIN, lzma_length_encoder::mid, rc_bit, and rc_bittree().

Referenced by match(), and rep_match().

◆ length_encoder_reset()

static void length_encoder_reset	(	lzma_length_encoder *	lencoder,
		const uint32_t	num_pos_states,
		const bool	fast_mode
	)

static

Definition at line 453 of file lzma_encoder.c.

 {
     bit_reset(lencoder->choice);
     bit_reset(lencoder->choice2);
  
     for (size_t pos_state = 0; pos_state < num_pos_states; ++pos_state) {
         bittree_reset(lencoder->low[pos_state], LEN_LOW_BITS);
         bittree_reset(lencoder->mid[pos_state], LEN_MID_BITS);
     }
  
     bittree_reset(lencoder->high, LEN_HIGH_BITS);
  
     if (!fast_mode)
         for (uint32_t pos_state = 0; pos_state < num_pos_states;
                 ++pos_state)
             length_update_prices(lencoder, pos_state);
  
     return;
 }

References bit_reset, bittree_reset, lzma_length_encoder::choice, lzma_length_encoder::choice2, lzma_length_encoder::high, LEN_HIGH_BITS, LEN_LOW_BITS, LEN_MID_BITS, length_update_prices(), lzma_length_encoder::low, and lzma_length_encoder::mid.

Referenced by lzma_lzma_encoder_reset().

◆ length_update_prices()

static void length_update_prices	(	lzma_length_encoder *	lc,
		const uint32_t	pos_state
	)

static

Definition at line 78 of file lzma_encoder.c.

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

References a0, b1, lzma_length_encoder::choice, lzma_length_encoder::choice2, lzma_length_encoder::counters, lzma_length_encoder::high, i, LEN_HIGH_BITS, LEN_LOW_BITS, LEN_LOW_SYMBOLS, LEN_MID_BITS, LEN_MID_SYMBOLS, lzma_length_encoder::low, lzma_length_encoder::mid, lzma_length_encoder::prices, rc_bit_0_price(), rc_bit_1_price(), rc_bittree_price(), and lzma_length_encoder::table_size.

Referenced by length(), and length_encoder_reset().

◆ literal()

static void literal	(	lzma_lzma1_encoder *	coder,
		lzma_mf *	mf,
		uint32_t	position
	)

inlinestatic

Definition at line 46 of file lzma_encoder.c.

 {
     // Locate the literal byte to be encoded and the subcoder.
     const uint8_t cur_byte = mf->buffer[
             mf->read_pos - mf->read_ahead];
     probability *subcoder = literal_subcoder(coder->literal,
             coder->literal_context_bits, coder->literal_pos_mask,
             position, mf->buffer[mf->read_pos - mf->read_ahead - 1]);
  
     if (is_literal_state(coder->state)) {
         // Previous LZMA-symbol was a literal. Encode a normal
         // literal without a match byte.
         rc_bittree(&coder->rc, subcoder, 8, cur_byte);
     } else {
         // Previous LZMA-symbol was a match. Use the last byte of
         // the match as a "match byte". That is, compare the bits
         // of the current literal and the match byte.
         const uint8_t match_byte = mf->buffer[
                 mf->read_pos - coder->reps[0] - 1
                 - mf->read_ahead];
         literal_matched(&coder->rc, subcoder, match_byte, cur_byte);
     }
  
     update_literal(coder->state);
 }

References lzma_mf_s::buffer, is_literal_state, lzma_lzma1_encoder_s::literal, lzma_lzma1_encoder_s::literal_context_bits, literal_matched(), lzma_lzma1_encoder_s::literal_pos_mask, literal_subcoder, lzma_lzma1_encoder_s::rc, rc_bittree(), lzma_mf_s::read_ahead, lzma_mf_s::read_pos, lzma_lzma1_encoder_s::reps, lzma_lzma1_encoder_s::state, and update_literal.

Referenced by encode_symbol().

◆ literal_matched()

static void literal_matched	(	lzma_range_encoder *	rc,
		probability *	subcoder,
		uint32_t	match_byte,
		uint32_t	symbol
	)

inlinestatic

Definition at line 24 of file lzma_encoder.c.

 {
     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;
         rc_bit(rc, &subcoder[subcoder_index], bit);
  
         symbol <<= 1;
         offset &= ~(match_byte ^ symbol);
  
     } while (symbol < (UINT32_C(1) << 16));
 }

References bit, rc_bit, and UINT32_C.

Referenced by literal().

◆ LZMA_API()

LZMA_API ( lzma_bool )

Definition at line 673 of file lzma_encoder.c.

 {
     return mode == LZMA_MODE_FAST || mode == LZMA_MODE_NORMAL;
 }

References LZMA_MODE_FAST, and LZMA_MODE_NORMAL.

◆ lzma_encode()

static lzma_ret lzma_encode	(	void *	coder,
		lzma_mf *restrict	mf,
		uint8_t *restrict	out,
		size_t *restrict	out_pos,
		size_t	out_size
	)

static

Definition at line 405 of file lzma_encoder.c.

 {
     // Plain LZMA has no support for sync-flushing.
     if (unlikely(mf->action == LZMA_SYNC_FLUSH))
         return LZMA_OPTIONS_ERROR;
  
     return lzma_lzma_encode(coder, mf, out, out_pos, out_size, UINT32_MAX);
 }

References lzma_lzma_encode(), LZMA_OPTIONS_ERROR, LZMA_SYNC_FLUSH, out, out_pos, UINT32_MAX, and unlikely.

Referenced by lzma_encoder_init().

◆ lzma_encoder_init()

static lzma_ret lzma_encoder_init	(	lzma_lz_encoder *	lz,
		const lzma_allocator *	allocator,
		const void *	options,
		lzma_lz_options *	lz_options
	)

static

Definition at line 609 of file lzma_encoder.c.

 {
     lz->code = &lzma_encode;
     return lzma_lzma_encoder_create(
             &lz->coder, allocator, options, lz_options);
 }

References allocator, lzma_lz_encoder::code, lzma_lz_encoder::coder, lzma_encode(), lzma_lzma_encoder_create(), and options.

Referenced by lzma_lzma_encoder_init().

◆ lzma_lzma_encode()

lzma_ret lzma_lzma_encode	(	lzma_lzma1_encoder *restrict	coder,
		lzma_mf *restrict	mf,
		uint8_t *restrict	out,
		size_t *restrict	out_pos,
		size_t	out_size,
		uint32_t	limit
	)

Definition at line 312 of file lzma_encoder.c.

 {
     // Initialize the stream if no data has been encoded yet.
     if (!coder->is_initialized && !encode_init(coder, mf))
         return LZMA_OK;
  
     // Get the lowest bits of the uncompressed offset from the LZ layer.
     uint32_t position = mf_position(mf);
  
     while (true) {
         // Encode pending bits, if any. Calling this before encoding
         // the next symbol is needed only with plain LZMA, since
         // LZMA2 always provides big enough buffer to flush
         // everything out from the range encoder. For the same reason,
         // rc_encode() never returns true when this function is used
         // as part of LZMA2 encoder.
         if (rc_encode(&coder->rc, out, out_pos, out_size)) {
             assert(limit == UINT32_MAX);
             return LZMA_OK;
         }
  
         // With LZMA2 we need to take care that compressed size of
         // a chunk doesn't get too big.
         // FIXME? Check if this could be improved.
         if (limit != UINT32_MAX
                 && (mf->read_pos - mf->read_ahead >= limit
                     || *out_pos + rc_pending(&coder->rc)
                         >= LZMA2_CHUNK_MAX
                             - LOOP_INPUT_MAX))
             break;
  
         // Check that there is some input to process.
         if (mf->read_pos >= mf->read_limit) {
             if (mf->action == LZMA_RUN)
                 return LZMA_OK;
  
             if (mf->read_ahead == 0)
                 break;
         }
  
         // Get optimal match (repeat position and length).
         // Value ranges for pos:
         //   - [0, REPS): repeated match
         //   - [REPS, UINT32_MAX):
         //     match at (pos - REPS)
         //   - UINT32_MAX: not a match but a literal
         // Value ranges for len:
         //   - [MATCH_LEN_MIN, MATCH_LEN_MAX]
         uint32_t len;
         uint32_t back;
  
         if (coder->fast_mode)
             lzma_lzma_optimum_fast(coder, mf, &back, &len);
         else
             lzma_lzma_optimum_normal(
                     coder, mf, &back, &len, position);
  
         encode_symbol(coder, mf, back, len, position);
  
         position += len;
     }
  
     if (!coder->is_flushed) {
         coder->is_flushed = true;
  
         // We don't support encoding plain LZMA streams without EOPM,
         // and LZMA2 doesn't use EOPM at LZMA level.
         if (limit == UINT32_MAX)
             encode_eopm(coder, position);
  
         // Flush the remaining bytes from the range encoder.
         rc_flush(&coder->rc);
  
         // Copy the remaining bytes to the output buffer. If there
         // isn't enough output space, we will copy out the remaining
         // bytes on the next call to this function by using
         // the rc_encode() call in the encoding loop above.
         if (rc_encode(&coder->rc, out, out_pos, out_size)) {
             assert(limit == UINT32_MAX);
             return LZMA_OK;
         }
     }
  
     // Make it ready for the next LZMA2 chunk.
     coder->is_flushed = false;
  
     return LZMA_STREAM_END;
 }

References assert(), encode_eopm(), encode_init(), encode_symbol(), len, limit, LOOP_INPUT_MAX, LZMA2_CHUNK_MAX, lzma_lzma_optimum_fast(), lzma_lzma_optimum_normal(), LZMA_OK, LZMA_RUN, LZMA_STREAM_END, mf_position(), out, out_pos, rc_encode(), rc_flush(), rc_pending(), and UINT32_MAX.

Referenced by lzma2_encode(), and lzma_encode().

◆ lzma_lzma_encoder_create()

lzma_ret lzma_lzma_encoder_create	(	void **	coder_ptr,
		const lzma_allocator *	allocator,
		const lzma_options_lzma *	options,
		lzma_lz_options *	lz_options
	)

Definition at line 549 of file lzma_encoder.c.

 {
     // Allocate lzma_lzma1_encoder if it wasn't already allocated.
     if (*coder_ptr == NULL) {
         *coder_ptr = lzma_alloc(sizeof(lzma_lzma1_encoder), allocator);
         if (*coder_ptr == NULL)
             return LZMA_MEM_ERROR;
     }
  
     lzma_lzma1_encoder *coder = *coder_ptr;
  
     // Set compression mode. We haven't validates the options yet,
     // but it's OK here, since nothing bad happens with invalid
     // options in the code below, and they will get rejected by
     // lzma_lzma_encoder_reset() call at the end of this function.
     switch (options->mode) {
         case LZMA_MODE_FAST:
             coder->fast_mode = true;
             break;
  
         case LZMA_MODE_NORMAL: {
             coder->fast_mode = false;
  
             // Set dist_table_size.
             // Round the dictionary size up to next 2^n.
             uint32_t log_size = 0;
             while ((UINT32_C(1) << log_size) < options->dict_size)
                 ++log_size;
  
             coder->dist_table_size = log_size * 2;
  
             // Length encoders' price table size
             coder->match_len_encoder.table_size
                 = options->nice_len + 1 - MATCH_LEN_MIN;
             coder->rep_len_encoder.table_size
                 = options->nice_len + 1 - MATCH_LEN_MIN;
             break;
         }
  
         default:
             return LZMA_OPTIONS_ERROR;
     }
  
     // We don't need to write the first byte as literal if there is
     // a non-empty preset dictionary. encode_init() wouldn't even work
     // if there is a non-empty preset dictionary, because encode_init()
     // assumes that position is zero and previous byte is also zero.
     coder->is_initialized = options->preset_dict != NULL
             && options->preset_dict_size > 0;
     coder->is_flushed = false;
  
     set_lz_options(lz_options, options);
  
     return lzma_lzma_encoder_reset(coder, options);
 }

References allocator, lzma_lzma1_encoder_s::dist_table_size, lzma_lzma1_encoder_s::fast_mode, lzma_lzma1_encoder_s::is_flushed, lzma_lzma1_encoder_s::is_initialized, lzma_alloc(), lzma_lzma_encoder_reset(), LZMA_MEM_ERROR, LZMA_MODE_FAST, LZMA_MODE_NORMAL, LZMA_OPTIONS_ERROR, lzma_lzma1_encoder_s::match_len_encoder, MATCH_LEN_MIN, NULL, options, lzma_lzma1_encoder_s::rep_len_encoder, set_lz_options(), lzma_length_encoder::table_size, and UINT32_C.

Referenced by lzma2_encoder_init(), and lzma_encoder_init().

◆ lzma_lzma_encoder_init()

lzma_ret lzma_lzma_encoder_init	(	lzma_next_coder *	next,
		const lzma_allocator *	allocator,
		const lzma_filter_info *	filters
	)

Definition at line 619 of file lzma_encoder.c.

 {
     return lzma_lz_encoder_init(
             next, allocator, filters, &lzma_encoder_init);
 }

References allocator, filters, lzma_encoder_init(), and lzma_lz_encoder_init().

Referenced by alone_encoder_init().

◆ lzma_lzma_encoder_memusage()

uint64_t lzma_lzma_encoder_memusage ( const void * options )

Definition at line 628 of file lzma_encoder.c.

 {
     if (!is_options_valid(options))
         return UINT64_MAX;
  
     lzma_lz_options lz_options;
     set_lz_options(&lz_options, options);
  
     const uint64_t lz_memusage = lzma_lz_encoder_memusage(&lz_options);
     if (lz_memusage == UINT64_MAX)
         return UINT64_MAX;
  
     return (uint64_t)(sizeof(lzma_lzma1_encoder)) + lz_memusage;
 }

References is_options_valid(), lzma_lz_encoder_memusage(), options, set_lz_options(), and UINT64_MAX.

Referenced by lzma_lzma2_encoder_memusage().

◆ lzma_lzma_encoder_reset()

lzma_ret lzma_lzma_encoder_reset	(	lzma_lzma1_encoder *	coder,
		const lzma_options_lzma *	options
	)

Definition at line 476 of file lzma_encoder.c.

 {
     if (!is_options_valid(options))
         return LZMA_OPTIONS_ERROR;
  
     coder->pos_mask = (1U << options->pb) - 1;
     coder->literal_context_bits = options->lc;
     coder->literal_pos_mask = (1U << options->lp) - 1;
  
     // Range coder
     rc_reset(&coder->rc);
  
     // State
     coder->state = STATE_LIT_LIT;
     for (size_t i = 0; i < REPS; ++i)
         coder->reps[i] = 0;
  
     literal_init(coder->literal, options->lc, options->lp);
  
     // Bit encoders
     for (size_t i = 0; i < STATES; ++i) {
         for (size_t j = 0; j <= coder->pos_mask; ++j) {
             bit_reset(coder->is_match[i][j]);
             bit_reset(coder->is_rep0_long[i][j]);
         }
  
         bit_reset(coder->is_rep[i]);
         bit_reset(coder->is_rep0[i]);
         bit_reset(coder->is_rep1[i]);
         bit_reset(coder->is_rep2[i]);
     }
  
     for (size_t i = 0; i < FULL_DISTANCES - DIST_MODEL_END; ++i)
         bit_reset(coder->dist_special[i]);
  
     // Bit tree encoders
     for (size_t i = 0; i < DIST_STATES; ++i)
         bittree_reset(coder->dist_slot[i], DIST_SLOT_BITS);
  
     bittree_reset(coder->dist_align, ALIGN_BITS);
  
     // Length encoders
     length_encoder_reset(&coder->match_len_encoder,
             1U << options->pb, coder->fast_mode);
  
     length_encoder_reset(&coder->rep_len_encoder,
             1U << options->pb, coder->fast_mode);
  
     // Price counts are incremented every time appropriate probabilities
     // are changed. price counts are set to zero when the price tables
     // are updated, which is done when the appropriate price counts have
     // big enough value, and lzma_mf.read_ahead == 0 which happens at
     // least every OPTS (a few thousand) possible price count increments.
     //
     // By resetting price counts to UINT32_MAX / 2, we make sure that the
     // price tables will be initialized before they will be used (since
     // the value is definitely big enough), and that it is OK to increment
     // price counts without risk of integer overflow (since UINT32_MAX / 2
     // is small enough). The current code doesn't increment price counts
     // before initializing price tables, but it maybe done in future if
     // we add support for saving the state between LZMA2 chunks.
     coder->match_price_count = UINT32_MAX / 2;
     coder->align_price_count = UINT32_MAX / 2;
  
     coder->opts_end_index = 0;
     coder->opts_current_index = 0;
  
     return LZMA_OK;
 }

Referenced by lzma2_encode(), and lzma_lzma_encoder_create().

◆ lzma_lzma_lclppb_encode()

bool lzma_lzma_lclppb_encode	(	const lzma_options_lzma *	options,
		uint8_t *	byte
	)

Encodes lc/lp/pb into one byte. Returns false on success and true on error.

Definition at line 645 of file lzma_encoder.c.

 {
     if (!is_lclppb_valid(options))
         return true;
  
     *byte = (options->pb * 5 + options->lp) * 9 + options->lc;
     assert(*byte <= (4 * 5 + 4) * 9 + 8);
  
     return false;
 }

References assert(), is_lclppb_valid(), and options.

Referenced by alone_encoder_init(), and lzma2_header_lzma().

◆ match()

static void match	(	lzma_lzma1_encoder *	coder,
		const uint32_t	pos_state,
		const uint32_t	distance,
		const uint32_t	len
	)

inlinestatic

Definition at line 143 of file lzma_encoder.c.

 {
     update_match(coder->state);
  
     length(&coder->rc, &coder->match_len_encoder, pos_state, len,
             coder->fast_mode);
  
     const uint32_t dist_slot = get_dist_slot(distance);
     const uint32_t dist_state = get_dist_state(len);
     rc_bittree(&coder->rc, coder->dist_slot[dist_state],
             DIST_SLOT_BITS, dist_slot);
  
     if (dist_slot >= DIST_MODEL_START) {
         const uint32_t footer_bits = (dist_slot >> 1) - 1;
         const uint32_t base = (2 | (dist_slot & 1)) << footer_bits;
         const uint32_t dist_reduced = distance - base;
  
         if (dist_slot < DIST_MODEL_END) {
             // Careful here: base - dist_slot - 1 can be -1, but
             // rc_bittree_reverse starts at probs[1], not probs[0].
             rc_bittree_reverse(&coder->rc,
                 coder->dist_special + base - dist_slot - 1,
                 footer_bits, dist_reduced);
         } else {
             rc_direct(&coder->rc, dist_reduced >> ALIGN_BITS,
                     footer_bits - ALIGN_BITS);
             rc_bittree_reverse(
                     &coder->rc, coder->dist_align,
                     ALIGN_BITS, dist_reduced & ALIGN_MASK);
             ++coder->align_price_count;
         }
     }
  
     coder->reps[3] = coder->reps[2];
     coder->reps[2] = coder->reps[1];
     coder->reps[1] = coder->reps[0];
     coder->reps[0] = distance;
     ++coder->match_price_count;
 }

Referenced by encode_eopm(), and encode_symbol().

◆ rep_match()

static void rep_match	(	lzma_lzma1_encoder *	coder,
		const uint32_t	pos_state,
		const uint32_t	rep,
		const uint32_t	len
	)

inlinestatic

Definition at line 190 of file lzma_encoder.c.

 {
     if (rep == 0) {
         rc_bit(&coder->rc, &coder->is_rep0[coder->state], 0);
         rc_bit(&coder->rc,
                 &coder->is_rep0_long[coder->state][pos_state],
                 len != 1);
     } else {
         const uint32_t distance = coder->reps[rep];
         rc_bit(&coder->rc, &coder->is_rep0[coder->state], 1);
  
         if (rep == 1) {
             rc_bit(&coder->rc, &coder->is_rep1[coder->state], 0);
         } else {
             rc_bit(&coder->rc, &coder->is_rep1[coder->state], 1);
             rc_bit(&coder->rc, &coder->is_rep2[coder->state],
                     rep - 2);
  
             if (rep == 3)
                 coder->reps[3] = coder->reps[2];
  
             coder->reps[2] = coder->reps[1];
         }
  
         coder->reps[1] = coder->reps[0];
         coder->reps[0] = distance;
     }
  
     if (len == 1) {
         update_short_rep(coder->state);
     } else {
         length(&coder->rc, &coder->rep_len_encoder, pos_state, len,
                 coder->fast_mode);
         update_long_rep(coder->state);
     }
 }

References lzma_lzma1_encoder_s::fast_mode, lzma_lzma1_encoder_s::is_rep0, lzma_lzma1_encoder_s::is_rep0_long, lzma_lzma1_encoder_s::is_rep1, lzma_lzma1_encoder_s::is_rep2, len, length(), lzma_lzma1_encoder_s::rc, rc_bit, lzma_lzma1_encoder_s::rep_len_encoder, lzma_lzma1_encoder_s::reps, lzma_lzma1_encoder_s::state, update_long_rep, and update_short_rep.

Referenced by encode_symbol().

◆ set_lz_options()

static void set_lz_options	(	lzma_lz_options *	lz_options,
		const lzma_options_lzma *	options
	)

static

Definition at line 435 of file lzma_encoder.c.

 {
     // LZ encoder initialization does the validation for these so we
     // don't need to validate here.
     lz_options->before_size = OPTS;
     lz_options->dict_size = options->dict_size;
     lz_options->after_size = LOOP_INPUT_MAX;
     lz_options->match_len_max = MATCH_LEN_MAX;
     lz_options->nice_len = options->nice_len;
     lz_options->match_finder = options->mf;
     lz_options->depth = options->depth;
     lz_options->preset_dict = options->preset_dict;
     lz_options->preset_dict_size = options->preset_dict_size;
     return;
 }

References lzma_lz_options::after_size, lzma_lz_options::before_size, lzma_lz_options::depth, lzma_lz_options::dict_size, LOOP_INPUT_MAX, lzma_lz_options::match_finder, lzma_lz_options::match_len_max, MATCH_LEN_MAX, lzma_lz_options::nice_len, options, OPTS, lzma_lz_options::preset_dict, and lzma_lz_options::preset_dict_size.

Referenced by lzma_lzma_encoder_create(), and lzma_lzma_encoder_memusage().

Macros

Functions

Detailed Description

Macro Definition Documentation

◆ LOOP_INPUT_MAX

Function Documentation

◆ encode_eopm()

◆ encode_init()

◆ encode_symbol()

◆ is_options_valid()

◆ length()

◆ length_encoder_reset()

◆ length_update_prices()

◆ literal()

◆ literal_matched()

◆ LZMA_API()

◆ lzma_encode()

◆ lzma_encoder_init()

◆ lzma_lzma_encode()

◆ lzma_lzma_encoder_create()

◆ lzma_lzma_encoder_init()

◆ lzma_lzma_encoder_memusage()

◆ lzma_lzma_encoder_reset()

◆ lzma_lzma_lclppb_encode()

◆ match()

◆ rep_match()

◆ set_lz_options()