///////////////////////////////////////////////////////////////////////////////

//

/// \file lzma_decoder.c

/// \brief LZMA decoder

///

// Authors: Igor Pavlov

// Lasse Collin

//

// This file has been put into the public domain.

// You can do whatever you want with this file.

//

///////////////////////////////////////////////////////////////////////////////

#include "lz_decoder.h"

#include "lzma_common.h"

#include "lzma_decoder.h"

#include "range_decoder.h"

#ifdef HAVE_SMALL

// Macros for (somewhat) size-optimized code.

#define seq_4(seq) seq

#define seq_6(seq) seq

#define seq_8(seq) seq

#define seq_len(seq) \

seq ## _CHOICE, \

seq ## _CHOICE2, \

seq ## _BITTREE

#define len_decode(target, ld, pos_state, seq) \

do { \

case seq ## _CHOICE: \

rc_if_0(ld.choice, seq ## _CHOICE) { \

rc_update_0(ld.choice); \

probs = ld.low[pos_state];\

limit = LEN_LOW_SYMBOLS; \

target = MATCH_LEN_MIN; \

} else { \

rc_update_1(ld.choice); \

case seq ## _CHOICE2: \

rc_if_0(ld.choice2, seq ## _CHOICE2) { \

rc_update_0(ld.choice2); \

probs = ld.mid[pos_state]; \

limit = LEN_MID_SYMBOLS; \

target = MATCH_LEN_MIN + LEN_LOW_SYMBOLS; \

} else { \

rc_update_1(ld.choice2); \

probs = ld.high; \

limit = LEN_HIGH_SYMBOLS; \

target = MATCH_LEN_MIN + LEN_LOW_SYMBOLS \

+ LEN_MID_SYMBOLS; \

} \

} \

symbol = 1; \

case seq ## _BITTREE: \

do { \

rc_bit(probs[symbol], , , seq ## _BITTREE); \

} while (symbol < limit); \

target += symbol - limit; \

} while (0)

#else // HAVE_SMALL

// Unrolled versions

#define seq_4(seq) \

seq ## 0, \

seq ## 1, \

seq ## 2, \

seq ## 3

#define seq_6(seq) \

seq ## 0, \

seq ## 1, \

seq ## 2, \

seq ## 3, \

seq ## 4, \

seq ## 5

#define seq_8(seq) \

seq ## 0, \

seq ## 1, \

seq ## 2, \

seq ## 3, \

seq ## 4, \

seq ## 5, \

seq ## 6, \

seq ## 7

#define seq_len(seq) \

seq ## _CHOICE, \

seq ## _LOW0, \

seq ## _LOW1, \

seq ## _LOW2, \

seq ## _CHOICE2, \

seq ## _MID0, \

seq ## _MID1, \

seq ## _MID2, \

seq ## _HIGH0, \

seq ## _HIGH1, \

seq ## _HIGH2, \

seq ## _HIGH3, \

seq ## _HIGH4, \

seq ## _HIGH5, \

seq ## _HIGH6, \

seq ## _HIGH7

#define len_decode(target, ld, pos_state, seq) \

do { \

symbol = 1; \

case seq ## _CHOICE: \

rc_if_0(ld.choice, seq ## _CHOICE) { \

rc_update_0(ld.choice); \

rc_bit_case(ld.low[pos_state][symbol], , , seq ## _LOW0); \

rc_bit_case(ld.low[pos_state][symbol], , , seq ## _LOW1); \

rc_bit_case(ld.low[pos_state][symbol], , , seq ## _LOW2); \

target = symbol - LEN_LOW_SYMBOLS + MATCH_LEN_MIN; \

} else { \

rc_update_1(ld.choice); \

case seq ## _CHOICE2: \

rc_if_0(ld.choice2, seq ## _CHOICE2) { \

rc_update_0(ld.choice2); \

rc_bit_case(ld.mid[pos_state][symbol], , , \

seq ## _MID0); \

rc_bit_case(ld.mid[pos_state][symbol], , , \

seq ## _MID1); \

rc_bit_case(ld.mid[pos_state][symbol], , , \

seq ## _MID2); \

target = symbol - LEN_MID_SYMBOLS \

+ MATCH_LEN_MIN + LEN_LOW_SYMBOLS; \

} else { \

rc_update_1(ld.choice2); \

rc_bit_case(ld.high[symbol], , , seq ## _HIGH0); \

rc_bit_case(ld.high[symbol], , , seq ## _HIGH1); \

rc_bit_case(ld.high[symbol], , , seq ## _HIGH2); \

rc_bit_case(ld.high[symbol], , , seq ## _HIGH3); \

rc_bit_case(ld.high[symbol], , , seq ## _HIGH4); \

rc_bit_case(ld.high[symbol], , , seq ## _HIGH5); \

rc_bit_case(ld.high[symbol], , , seq ## _HIGH6); \

rc_bit_case(ld.high[symbol], , , seq ## _HIGH7); \

target = symbol - LEN_HIGH_SYMBOLS \

+ MATCH_LEN_MIN \

+ LEN_LOW_SYMBOLS + LEN_MID_SYMBOLS; \

} \

} \

} while (0)

#endif // HAVE_SMALL

/// Length decoder probabilities; see comments in lzma_common.h.

typedef struct {

probability choice;

probability choice2;

probability low[POS_STATES_MAX][LEN_LOW_SYMBOLS];

probability mid[POS_STATES_MAX][LEN_MID_SYMBOLS];

probability high[LEN_HIGH_SYMBOLS];

} lzma_length_decoder;

struct lzma_coder_s {

};

static lzma_ret

lzma_decode(lzma_coder *restrict coder, lzma_dict *restrict dictptr,

const uint8_t *restrict in,

size_t *restrict in_pos, size_t in_size)

{

////////////////////

// Initialization //

////////////////////

if (!rc_read_init(&coder->rc, in, in_pos, in_size))

return LZMA_OK;

///////////////

// Variables //

///////////////

// Making local copies of often-used variables improves both

// speed and readability.

lzma_dict dict = *dictptr;

const size_t dict_start = dict.pos;

// Range decoder

rc_to_local(coder->rc, *in_pos);

// State

uint32_t state = coder->state;

uint32_t rep0 = coder->rep0;

uint32_t rep1 = coder->rep1;

uint32_t rep2 = coder->rep2;

uint32_t rep3 = coder->rep3;

const uint32_t pos_mask = coder->pos_mask;

// These variables are actually needed only if we last time ran

// out of input in the middle of the decoder loop.

probability *probs = coder->probs;

uint32_t symbol = coder->symbol;

uint32_t limit = coder->limit;

uint32_t offset = coder->offset;

uint32_t len = coder->len;

const uint32_t literal_pos_mask = coder->literal_pos_mask;

const uint32_t literal_context_bits = coder->literal_context_bits;

// Temporary variables

uint32_t pos_state = dict.pos & pos_mask;

lzma_ret ret = LZMA_OK;

// If uncompressed size is known, there must be no end of payload

// marker.

const bool no_eopm = coder->uncompressed_size

!= LZMA_VLI_UNKNOWN;

if (no_eopm && coder->uncompressed_size < dict.limit - dict.pos)

dict.limit = dict.pos + (size_t)(coder->uncompressed_size);

// The main decoder loop. The "switch" is used to restart the decoder at

// correct location. Once restarted, the "switch" is no longer used.

switch (coder->sequence)

while (true) {

// Calculate new pos_state. This is skipped on the first loop

// since we already calculated it when setting up the local

// variables.

pos_state = dict.pos & pos_mask;

case SEQ_NORMALIZE:

case SEQ_IS_MATCH:

if (unlikely(no_eopm && dict.pos == dict.limit))

break;

rc_if_0(coder->is_match[state][pos_state], SEQ_IS_MATCH) {

rc_update_0(coder->is_match[state][pos_state]);

// It's a literal i.e. a single 8-bit byte.

probs = literal_subcoder(coder->literal,

literal_context_bits, literal_pos_mask,

dict.pos, dict_get(&dict, 0));

symbol = 1;

if (is_literal_state(state)) {

// Decode literal without match byte.

#ifdef HAVE_SMALL

case SEQ_LITERAL:

do {

rc_bit(probs[symbol], , , SEQ_LITERAL);

} while (symbol < (1 << 8));

#else

rc_bit_case(probs[symbol], , , SEQ_LITERAL0);

rc_bit_case(probs[symbol], , , SEQ_LITERAL1);

rc_bit_case(probs[symbol], , , SEQ_LITERAL2);

rc_bit_case(probs[symbol], , , SEQ_LITERAL3);

rc_bit_case(probs[symbol], , , SEQ_LITERAL4);

rc_bit_case(probs[symbol], , , SEQ_LITERAL5);

rc_bit_case(probs[symbol], , , SEQ_LITERAL6);

rc_bit_case(probs[symbol], , , SEQ_LITERAL7);

#endif

} else {

// Decode literal with match byte.

//

// We store the byte we compare against

// ("match byte") to "len" to minimize the

// number of variables we need to store

// between decoder calls.

len = dict_get(&dict, rep0) << 1;

// The usage of "offset" allows omitting some

// branches, which should give tiny speed

// improvement on some CPUs. "offset" gets

// set to zero if match_bit didn't match.

offset = 0x100;

#ifdef HAVE_SMALL

case SEQ_LITERAL_MATCHED:

do {

const uint32_t match_bit

= len & offset;

const uint32_t subcoder_index

= offset + match_bit

+ symbol;

rc_bit(probs[subcoder_index],

offset &= ~match_bit,

offset &= match_bit,

SEQ_LITERAL_MATCHED);

// It seems to be faster to do this

// here instead of putting it to the

// beginning of the loop and then

// putting the "case" in the middle

// of the loop.

len <<= 1;

} while (symbol < (1 << 8));

#else

// Unroll the loop.

uint32_t match_bit;

uint32_t subcoder_index;

# define d(seq) \

case seq: \

match_bit = len & offset; \

subcoder_index = offset + match_bit + symbol; \

rc_bit(probs[subcoder_index], \

offset &= ~match_bit, \

offset &= match_bit, \

seq)

d(SEQ_LITERAL_MATCHED0);

len <<= 1;

d(SEQ_LITERAL_MATCHED1);

len <<= 1;

d(SEQ_LITERAL_MATCHED2);

len <<= 1;

d(SEQ_LITERAL_MATCHED3);

len <<= 1;

d(SEQ_LITERAL_MATCHED4);

len <<= 1;

d(SEQ_LITERAL_MATCHED5);

len <<= 1;

d(SEQ_LITERAL_MATCHED6);

len <<= 1;

d(SEQ_LITERAL_MATCHED7);

# undef d

#endif

}

//update_literal(state);

// Use a lookup table to update to literal state,

// since compared to other state updates, this would

// need two branches.

static const lzma_lzma_state next_state[] = {

STATE_LIT_LIT,

STATE_LIT_LIT,

STATE_LIT_LIT,

STATE_LIT_LIT,

STATE_MATCH_LIT_LIT,

STATE_REP_LIT_LIT,

STATE_SHORTREP_LIT_LIT,

STATE_MATCH_LIT,

STATE_REP_LIT,

STATE_SHORTREP_LIT,

STATE_MATCH_LIT,

STATE_REP_LIT

};

state = next_state[state];

case SEQ_LITERAL_WRITE:

if (unlikely(dict_put(&dict, symbol))) {

coder->sequence = SEQ_LITERAL_WRITE;

goto out;

}

continue;

}

// Instead of a new byte we are going to get a byte range

// (distance and length) which will be repeated from our

// output history.

rc_update_1(coder->is_match[state][pos_state]);

case SEQ_IS_REP:

rc_if_0(coder->is_rep[state], SEQ_IS_REP) {

// Not a repeated match

rc_update_0(coder->is_rep[state]);

update_match(state);

// The latest three match distances are kept in

// memory in case there are repeated matches.

rep3 = rep2;

rep2 = rep1;

rep1 = rep0;

// Decode the length of the match.

len_decode(len, coder->match_len_decoder,

pos_state, SEQ_MATCH_LEN);

// Prepare to decode the highest two bits of the

// match distance.

probs = coder->pos_slot[get_len_to_pos_state(len)];

symbol = 1;

#ifdef HAVE_SMALL

case SEQ_POS_SLOT:

do {

rc_bit(probs[symbol], , , SEQ_POS_SLOT);

} while (symbol < POS_SLOTS);

#else

rc_bit_case(probs[symbol], , , SEQ_POS_SLOT0);

rc_bit_case(probs[symbol], , , SEQ_POS_SLOT1);

rc_bit_case(probs[symbol], , , SEQ_POS_SLOT2);

rc_bit_case(probs[symbol], , , SEQ_POS_SLOT3);

rc_bit_case(probs[symbol], , , SEQ_POS_SLOT4);

rc_bit_case(probs[symbol], , , SEQ_POS_SLOT5);

#endif

// Get rid of the highest bit that was needed for

// indexing of the probability array.

symbol -= POS_SLOTS;

assert(symbol <= 63);

if (symbol < START_POS_MODEL_INDEX) {

// Match distances [0, 3] have only two bits.

rep0 = symbol;

} else {

// Decode the lowest [1, 29] bits of

// the match distance.

limit = (symbol >> 1) - 1;

assert(limit >= 1 && limit <= 30);

rep0 = 2 + (symbol & 1);

if (symbol < END_POS_MODEL_INDEX) {

// Prepare to decode the low bits for

// a distance of [4, 127].

assert(limit <= 5);

rep0 <<= limit;

assert(rep0 <= 96);

// -1 is fine, because we start

// decoding at probs[1], not probs[0].

// NOTE: This violates the C standard,

// since we are doing pointer

// arithmetic past the beginning of

// the array.

assert((int32_t)(rep0 - symbol - 1)

>= -1);

assert((int32_t)(rep0 - symbol - 1)

<= 82);

probs = coder->pos_special + rep0

- symbol - 1;

symbol = 1;

offset = 0;

case SEQ_POS_MODEL:

#ifdef HAVE_SMALL

do {

rc_bit(probs[symbol], ,

rep0 += 1 << offset,

SEQ_POS_MODEL);

} while (++offset < limit);

#else

switch (limit) {

case 5:

assert(offset == 0);

rc_bit(probs[symbol], ,

rep0 += 1,

SEQ_POS_MODEL);

++offset;

--limit;

case 4:

rc_bit(probs[symbol], ,

rep0 += 1 << offset,

SEQ_POS_MODEL);

++offset;

--limit;

case 3:

rc_bit(probs[symbol], ,

rep0 += 1 << offset,

SEQ_POS_MODEL);

++offset;

--limit;

case 2:

rc_bit(probs[symbol], ,

rep0 += 1 << offset,

SEQ_POS_MODEL);

++offset;

--limit;

case 1:

// We need "symbol" only for

// indexing the probability

// array, thus we can use

// rc_bit_last() here to omit

// the unneeded updating of

// "symbol".

rc_bit_last(probs[symbol], ,

rep0 += 1 << offset,

SEQ_POS_MODEL);

}

#endif

} else {

// The distance is >= 128. Decode the

// lower bits without probabilities

// except the lowest four bits.

assert(symbol >= 14);

assert(limit >= 6);

limit -= ALIGN_BITS;

assert(limit >= 2);

case SEQ_DIRECT:

// Not worth manual unrolling

do {

rc_direct(rep0, SEQ_DIRECT);

} while (--limit > 0);

// Decode the lowest four bits using

// probabilities.

rep0 <<= ALIGN_BITS;

symbol = 1;

#ifdef HAVE_SMALL

offset = 0;

case SEQ_ALIGN:

do {

rc_bit(coder->pos_align[

symbol], ,

rep0 += 1 << offset,

SEQ_ALIGN);

} while (++offset < ALIGN_BITS);

#else

case SEQ_ALIGN0:

rc_bit(coder->pos_align[symbol], ,

rep0 += 1, SEQ_ALIGN0);

case SEQ_ALIGN1:

rc_bit(coder->pos_align[symbol], ,

rep0 += 2, SEQ_ALIGN1);

case SEQ_ALIGN2:

rc_bit(coder->pos_align[symbol], ,

rep0 += 4, SEQ_ALIGN2);

case SEQ_ALIGN3:

// Like in SEQ_POS_MODEL, we don't

// need "symbol" for anything else

// than indexing the probability array.

rc_bit_last(coder->pos_align[symbol], ,

rep0 += 8, SEQ_ALIGN3);

#endif

if (rep0 == UINT32_MAX) {

// End of payload marker was

// found. It must not be

// present if uncompressed

// size is known.

if (coder->uncompressed_size

!= LZMA_VLI_UNKNOWN) {

ret = LZMA_DATA_ERROR;

goto out;

}

case SEQ_EOPM:

// LZMA1 stream with

// end-of-payload marker.

rc_normalize(SEQ_EOPM);

ret = LZMA_STREAM_END;

goto out;

}

}

}

// Validate the distance we just decoded.

if (unlikely(!dict_is_distance_valid(&dict, rep0))) {

ret = LZMA_DATA_ERROR;

goto out;

}

} else {

rc_update_1(coder->is_rep[state]);

// Repeated match

//

// The match distance is a value that we have had

// earlier. The latest four match distances are

// available as rep0, rep1, rep2 and rep3. We will

// now decode which of them is the new distance.

//

// There cannot be a match if we haven't produced

// any output, so check that first.

if (unlikely(!dict_is_distance_valid(&dict, 0))) {

ret = LZMA_DATA_ERROR;

goto out;

}

case SEQ_IS_REP0:

rc_if_0(coder->is_rep0[state], SEQ_IS_REP0) {

rc_update_0(coder->is_rep0[state]);

// The distance is rep0.

case SEQ_IS_REP0_LONG:

rc_if_0(coder->is_rep0_long[state][pos_state],

SEQ_IS_REP0_LONG) {

rc_update_0(coder->is_rep0_long[

state][pos_state]);

update_short_rep(state);

case SEQ_SHORTREP:

if (unlikely(dict_put(&dict, dict_get(

&dict, rep0)))) {

coder->sequence = SEQ_SHORTREP;

goto out;

}

continue;

}

// Repeating more than one byte at

// distance of rep0.

rc_update_1(coder->is_rep0_long[

state][pos_state]);

} else {

rc_update_1(coder->is_rep0[state]);

case SEQ_IS_REP1:

// The distance is rep1, rep2 or rep3. Once

// we find out which one of these three, it

// is stored to rep0 and rep1, rep2 and rep3

// are updated accordingly.

rc_if_0(coder->is_rep1[state], SEQ_IS_REP1) {

rc_update_0(coder->is_rep1[state]);

const uint32_t distance = rep1;

rep1 = rep0;

rep0 = distance;

} else {

rc_update_1(coder->is_rep1[state]);

case SEQ_IS_REP2:

rc_if_0(coder->is_rep2[state],

SEQ_IS_REP2) {

rc_update_0(coder->is_rep2[

state]);

const uint32_t distance = rep2;

rep2 = rep1;

rep1 = rep0;

rep0 = distance;

} else {

rc_update_1(coder->is_rep2[

state]);

const uint32_t distance = rep3;

rep3 = rep2;

rep2 = rep1;

rep1 = rep0;

rep0 = distance;

}

}

}

update_long_rep(state);

// Decode the length of the repeated match.

len_decode(len, coder->rep_len_decoder,

pos_state, SEQ_REP_LEN);

}

/////////////////////////////////

// Repeat from history buffer. //

/////////////////////////////////

// The length is always between these limits. There is no way

// to trigger the algorithm to set len outside this range.

assert(len >= MATCH_LEN_MIN);

assert(len <= MATCH_LEN_MAX);

case SEQ_COPY:

// Repeat len bytes from distance of rep0.

if (unlikely(dict_repeat(&dict, rep0, &len))) {

coder->sequence = SEQ_COPY;

goto out;

}

}

rc_normalize(SEQ_NORMALIZE);

coder->sequence = SEQ_IS_MATCH;

out:

// Save state

// NOTE: Must not copy dict.limit.

dictptr->pos = dict.pos;

dictptr->full = dict.full;

rc_from_local(coder->rc, *in_pos);

coder->state = state;

coder->rep0 = rep0;

coder->rep1 = rep1;

coder->rep2 = rep2;

coder->rep3 = rep3;

coder->probs = probs;

coder->symbol = symbol;

coder->limit = limit;

coder->offset = offset;

coder->len = len;

// Update the remaining amount of uncompressed data if uncompressed

// size was known.

if (coder->uncompressed_size != LZMA_VLI_UNKNOWN) {

coder->uncompressed_size -= dict.pos - dict_start;

// Since there cannot be end of payload marker if the

// uncompressed size was known, we check here if we

// finished decoding.

if (coder->uncompressed_size == 0 && ret == LZMA_OK

&& coder->sequence != SEQ_NORMALIZE)

ret = coder->sequence == SEQ_IS_MATCH

? LZMA_STREAM_END : LZMA_DATA_ERROR;

}

// We can do an additional check in the range decoder to catch some

// corrupted files.

if (ret == LZMA_STREAM_END) {

if (!rc_is_finished(coder->rc))

ret = LZMA_DATA_ERROR;

// Reset the range decoder so that it is ready to reinitialize

// for a new LZMA2 chunk.

rc_reset(coder->rc);

}

return ret;

}

static void

lzma_decoder_uncompressed(lzma_coder *coder, lzma_vli uncompressed_size)

{

coder->uncompressed_size = uncompressed_size;

}

/*

extern void

lzma_lzma_decoder_uncompressed(void *coder_ptr, lzma_vli uncompressed_size)

{

// This is hack.

(*(lzma_coder **)(coder))->uncompressed_size = uncompressed_size;

}

*/

static void

lzma_decoder_reset(lzma_coder *coder, const void *opt)

{

const lzma_options_lzma *options = opt;

#if __MOJOSETUP__

uint32_t i, j, pos_state;

#endif

// NOTE: We assume that lc/lp/pb are valid since they were

// successfully decoded with lzma_lzma_decode_properties().

// Calculate pos_mask. We don't need pos_bits as is for anything.

coder->pos_mask = (1U << options->pb) - 1;

// Initialize the literal decoder.

literal_init(coder->literal, options->lc, options->lp);

coder->literal_context_bits = options->lc;

coder->literal_pos_mask = (1U << options->lp) - 1;

// State

coder->state = STATE_LIT_LIT;

coder->rep0 = 0;

coder->rep1 = 0;

coder->rep2 = 0;

coder->rep3 = 0;

coder->pos_mask = (1U << options->pb) - 1;

// Range decoder

rc_reset(coder->rc);

// Bit and bittree decoders

#if __MOJOSETUP__

for (i = 0; i < STATES; ++i) {

for (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 (i = 0; i < LEN_TO_POS_STATES; ++i)

bittree_reset(coder->pos_slot[i], POS_SLOT_BITS);

for (i = 0; i < FULL_DISTANCES - END_POS_MODEL_INDEX; ++i)

bit_reset(coder->pos_special[i]);

#else

for (uint32_t i = 0; i < STATES; ++i) {

for (uint32_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 (uint32_t i = 0; i < LEN_TO_POS_STATES; ++i)

bittree_reset(coder->pos_slot[i], POS_SLOT_BITS);

for (uint32_t i = 0; i < FULL_DISTANCES - END_POS_MODEL_INDEX; ++i)

bit_reset(coder->pos_special[i]);

#endif

bittree_reset(coder->pos_align, ALIGN_BITS);

// Len decoders (also bit/bittree)

const uint32_t num_pos_states = 1U << options->pb;

bit_reset(coder->match_len_decoder.choice);

bit_reset(coder->match_len_decoder.choice2);

bit_reset(coder->rep_len_decoder.choice);

bit_reset(coder->rep_len_decoder.choice2);

#if __MOJOSETUP__

for (pos_state = 0; pos_state < num_pos_states; ++pos_state) {

#else

for (uint32_t pos_state = 0; pos_state < num_pos_states; ++pos_state) {

#endif

bittree_reset(coder->match_len_decoder.low[pos_state],

LEN_LOW_BITS);

bittree_reset(coder->match_len_decoder.mid[pos_state],

LEN_MID_BITS);

bittree_reset(coder->rep_len_decoder.low[pos_state],

LEN_LOW_BITS);

bittree_reset(coder->rep_len_decoder.mid[pos_state],

LEN_MID_BITS);

}

bittree_reset(coder->match_len_decoder.high, LEN_HIGH_BITS);

bittree_reset(coder->rep_len_decoder.high, LEN_HIGH_BITS);

coder->sequence = SEQ_IS_MATCH;

coder->probs = NULL;

coder->symbol = 0;

coder->limit = 0;

coder->offset = 0;

coder->len = 0;

return;

}

extern lzma_ret

lzma_lzma_decoder_create(lzma_lz_decoder *lz, lzma_allocator *allocator,

const void *opt, lzma_lz_options *lz_options)

{

if (lz->coder == NULL) {

lz->coder = lzma_alloc(sizeof(lzma_coder), allocator);

if (lz->coder == NULL)

return LZMA_MEM_ERROR;

lz->code = &lzma_decode;

lz->reset = &lzma_decoder_reset;

lz->set_uncompressed = &lzma_decoder_uncompressed;

}

// All dictionary sizes are OK here. LZ decoder will take care of

// the special cases.

const lzma_options_lzma *options = opt;

lz_options->dict_size = options->dict_size;

lz_options->preset_dict = options->preset_dict;

lz_options->preset_dict_size = options->preset_dict_size;

return LZMA_OK;

}

/// Allocate and initialize LZMA decoder. This is used only via LZ

/// initialization (lzma_lzma_decoder_init() passes function pointer to

/// the LZ initialization).

static lzma_ret

lzma_decoder_init(lzma_lz_decoder *lz, lzma_allocator *allocator,

const void *options, lzma_lz_options *lz_options)

{

if (!is_lclppb_valid(options))

return LZMA_PROG_ERROR;

return_if_error(lzma_lzma_decoder_create(

lz, allocator, options, lz_options));

lzma_decoder_reset(lz->coder, options);