lz_decoder.c File Reference

LZ out window. More...

#include "lz_decoder.h"

Go to the source code of this file.

Classes
struct	lzma_coder

Functions
static void	lz_decoder_reset (lzma_coder *coder)
static lzma_ret	decode_buffer (lzma_coder *coder, const uint8_t *restrict in, size_t *restrict in_pos, size_t in_size, uint8_t *restrict out, size_t *restrict out_pos, size_t out_size)
static lzma_ret	lz_decode (void *coder_ptr, const lzma_allocator *allocator, const uint8_t *restrict in, size_t *restrict in_pos, size_t in_size, uint8_t *restrict out, size_t *restrict out_pos, size_t out_size, lzma_action action)
static void	lz_decoder_end (void *coder_ptr, const lzma_allocator *allocator)
lzma_ret	lzma_lz_decoder_init (lzma_next_coder *next, const lzma_allocator *allocator, const lzma_filter_info *filters, lzma_ret(*lz_init)(lzma_lz_decoder *lz, const lzma_allocator *allocator, const void *options, lzma_lz_options *lz_options))
uint64_t	lzma_lz_decoder_memusage (size_t dictionary_size)
void	lzma_lz_decoder_uncompressed (void *coder_ptr, lzma_vli uncompressed_size)

Detailed Description

LZ out window.

Definition in file lz_decoder.c.

Function Documentation

decode_buffer()

static lzma_ret decode_buffer ( lzma_coder *  coder, const uint8_t *restrict  in, size_t *restrict  in_pos, size_t  in_size, uint8_t *restrict  out, size_t *restrict  out_pos, size_t  out_size  )

static

Definition at line 66 of file lz_decoder.c.

{
    while (true) {
        // Wrap the dictionary if needed.
        if (coder->dict.pos == coder->dict.size)
            coder->dict.pos = 0;
 
        // Store the current dictionary position. It is needed to know
        // where to start copying to the out[] buffer.
        const size_t dict_start = coder->dict.pos;
 
        // Calculate how much we allow coder->lz.code() to decode.
        // It must not decode past the end of the dictionary
        // buffer, and we don't want it to decode more than is
        // actually needed to fill the out[] buffer.
        coder->dict.limit = coder->dict.pos
                + my_min(out_size - *out_pos,
                    coder->dict.size - coder->dict.pos);
 
        // Call the coder->lz.code() to do the actual decoding.
        const lzma_ret ret = coder->lz.code(
                coder->lz.coder, &coder->dict,
                in, in_pos, in_size);
 
        // Copy the decoded data from the dictionary to the out[]
        // buffer. Do it conditionally because out can be NULL
        // (in which case copy_size is always 0). Calling memcpy()
        // with a null-pointer is undefined even if the third
        // argument is 0.
        const size_t copy_size = coder->dict.pos - dict_start;
        assert(copy_size <= out_size - *out_pos);
 
        if (copy_size > 0)
            memcpy(out + *out_pos, coder->dict.buf + dict_start,
                    copy_size);
 
        *out_pos += copy_size;
 
        // Reset the dictionary if so requested by coder->lz.code().
        if (coder->dict.need_reset) {
            lz_decoder_reset(coder);
 
            // Since we reset dictionary, we don't check if
            // dictionary became full.
            if (ret != LZMA_OK || *out_pos == out_size)
                return ret;
        } else {
            // Return if everything got decoded or an error
            // occurred, or if there's no more data to decode.
            //
            // Note that detecting if there's something to decode
            // is done by looking if dictionary become full
            // instead of looking if *in_pos == in_size. This
            // is because it is possible that all the input was
            // consumed already but some data is pending to be
            // written to the dictionary.
            if (ret != LZMA_OK || *out_pos == out_size
                    || coder->dict.pos < coder->dict.size)
                return ret;
        }
    }
}

References assert(), lzma_dict::buf, lzma_lz_decoder::code, lzma_lz_decoder::coder, lzma_coder::dict, in, in_pos, in_size, lzma_dict::limit, lzma_coder::lz, lz_decoder_reset(), LZMA_OK, memcpy(), my_min, lzma_dict::need_reset, out, out_pos, lzma_dict::pos, and lzma_dict::size.

Referenced by lz_decode().

lz_decode()

static lzma_ret lz_decode ( void *  coder_ptr, const lzma_allocator *  allocator, const uint8_t *restrict  in, size_t *restrict  in_pos, size_t  in_size, uint8_t *restrict  out, size_t *restrict  out_pos, size_t  out_size, lzma_action  action  )

static

Definition at line 134 of file lz_decoder.c.

{
    lzma_coder *coder = coder_ptr;
 
    if (coder->next.code == NULL)
        return decode_buffer(coder, in, in_pos, in_size,
                out, out_pos, out_size);
 
    // We aren't the last coder in the chain, we need to decode
    // our input to a temporary buffer.
    while (*out_pos < out_size) {
        // Fill the temporary buffer if it is empty.
        if (!coder->next_finished
                && coder->temp.pos == coder->temp.size) {
            coder->temp.pos = 0;
            coder->temp.size = 0;
 
            const lzma_ret ret = coder->next.code(
                    coder->next.coder,
                    allocator, in, in_pos, in_size,
                    coder->temp.buffer, &coder->temp.size,
                    LZMA_BUFFER_SIZE, action);
 
            if (ret == LZMA_STREAM_END)
                coder->next_finished = true;
            else if (ret != LZMA_OK || coder->temp.size == 0)
                return ret;
        }
 
        if (coder->this_finished) {
            if (coder->temp.size != 0)
                return LZMA_DATA_ERROR;
 
            if (coder->next_finished)
                return LZMA_STREAM_END;
 
            return LZMA_OK;
        }
 
        const lzma_ret ret = decode_buffer(coder, coder->temp.buffer,
                &coder->temp.pos, coder->temp.size,
                out, out_pos, out_size);
 
        if (ret == LZMA_STREAM_END)
            coder->this_finished = true;
        else if (ret != LZMA_OK)
            return ret;
        else if (coder->next_finished && *out_pos < out_size)
            return LZMA_DATA_ERROR;
    }
 
    return LZMA_OK;
}

References test-lz4-speed::action, allocator, lzma_coder::buffer, lzma_next_coder_s::code, lzma_next_coder_s::coder, decode_buffer(), in, in_pos, in_size, LZMA_BUFFER_SIZE, LZMA_DATA_ERROR, LZMA_OK, LZMA_STREAM_END, lzma_coder::next, lzma_coder::next_finished, NULL, out, out_pos, lzma_coder::pos, lzma_coder::size, lzma_coder::temp, and lzma_coder::this_finished.

Referenced by lzma_lz_decoder_init().

lz_decoder_end()

static void lz_decoder_end ( void *  coder_ptr, const lzma_allocator *  allocator  )

static

Definition at line 194 of file lz_decoder.c.

{
    lzma_coder *coder = coder_ptr;
 
    lzma_next_end(&coder->next, allocator);
    lzma_free(coder->dict.buf, allocator);
 
    if (coder->lz.end != NULL)
        coder->lz.end(coder->lz.coder, allocator);
    else
        lzma_free(coder->lz.coder, allocator);
 
    lzma_free(coder, allocator);
    return;
}

References allocator, lzma_dict::buf, lzma_lz_decoder::coder, lzma_coder::dict, lzma_lz_decoder::end, lzma_coder::lz, lzma_free(), lzma_next_end(), lzma_coder::next, and NULL.

Referenced by lzma_lz_decoder_init().

lz_decoder_reset()

static void lz_decoder_reset ( lzma_coder *  coder )

static

Definition at line 55 of file lz_decoder.c.

{
    coder->dict.pos = 0;
    coder->dict.full = 0;
    coder->dict.buf[coder->dict.size - 1] = '\0';
    coder->dict.need_reset = false;
    return;
}

References lzma_dict::buf, lzma_coder::dict, lzma_dict::full, lzma_dict::need_reset, lzma_dict::pos, and lzma_dict::size.

Referenced by decode_buffer(), and lzma_lz_decoder_init().

lzma_lz_decoder_init()

lzma_ret lzma_lz_decoder_init	(	lzma_next_coder *	next,
		const lzma_allocator *	allocator,
		const lzma_filter_info *	filters,
		lzma_ret(*)(lzma_lz_decoder *lz, const lzma_allocator *allocator, const void *options, lzma_lz_options *lz_options)	lz_init
	)

Definition at line 212 of file lz_decoder.c.

{
    // Allocate the base structure if it isn't already allocated.
    lzma_coder *coder = next->coder;
    if (coder == NULL) {
        coder = lzma_alloc(sizeof(lzma_coder), allocator);
        if (coder == NULL)
            return LZMA_MEM_ERROR;
 
        next->coder = coder;
        next->code = &lz_decode;
        next->end = &lz_decoder_end;
 
        coder->dict.buf = NULL;
        coder->dict.size = 0;
        coder->lz = LZMA_LZ_DECODER_INIT;
        coder->next = LZMA_NEXT_CODER_INIT;
    }
 
    // Allocate and initialize the LZ-based decoder. It will also give
    // us the dictionary size.
    lzma_lz_options lz_options;
    return_if_error(lz_init(&coder->lz, allocator,
            filters[0].options, &lz_options));
 
    // If the dictionary size is very small, increase it to 4096 bytes.
    // This is to prevent constant wrapping of the dictionary, which
    // would slow things down. The downside is that since we don't check
    // separately for the real dictionary size, we may happily accept
    // corrupt files.
    if (lz_options.dict_size < 4096)
        lz_options.dict_size = 4096;
 
    // Make dictionary size a multiple of 16. Some LZ-based decoders like
    // LZMA use the lowest bits lzma_dict.pos to know the alignment of the
    // data. Aligned buffer is also good when memcpying from the
    // dictionary to the output buffer, since applications are
    // recommended to give aligned buffers to liblzma.
    //
    // Avoid integer overflow.
    if (lz_options.dict_size > SIZE_MAX - 15)
        return LZMA_MEM_ERROR;
 
    lz_options.dict_size = (lz_options.dict_size + 15) & ~((size_t)(15));
 
    // Allocate and initialize the dictionary.
    if (coder->dict.size != lz_options.dict_size) {
        lzma_free(coder->dict.buf, allocator);
        coder->dict.buf
                = lzma_alloc(lz_options.dict_size, allocator);
        if (coder->dict.buf == NULL)
            return LZMA_MEM_ERROR;
 
        coder->dict.size = lz_options.dict_size;
    }
 
    lz_decoder_reset(next->coder);
 
    // Use the preset dictionary if it was given to us.
    if (lz_options.preset_dict != NULL
            && lz_options.preset_dict_size > 0) {
        // If the preset dictionary is bigger than the actual
        // dictionary, copy only the tail.
        const size_t copy_size = my_min(lz_options.preset_dict_size,
                lz_options.dict_size);
        const size_t offset = lz_options.preset_dict_size - copy_size;
        memcpy(coder->dict.buf, lz_options.preset_dict + offset,
                copy_size);
        coder->dict.pos = copy_size;
        coder->dict.full = copy_size;
    }
 
    // Miscellaneous initializations
    coder->next_finished = false;
    coder->this_finished = false;
    coder->temp.pos = 0;
    coder->temp.size = 0;
 
    // Initialize the next filter in the chain, if any.
    return lzma_next_filter_init(&coder->next, allocator, filters + 1);
}

References allocator, lzma_dict::buf, lzma_next_coder_s::code, lzma_next_coder_s::coder, lzma_coder::dict, lzma_lz_options::dict_size, lzma_next_coder_s::end, filters, lzma_dict::full, lzma_coder::lz, lz_decode(), lz_decoder_end(), lz_decoder_reset(), lzma_alloc(), lzma_free(), LZMA_LZ_DECODER_INIT, LZMA_MEM_ERROR, LZMA_NEXT_CODER_INIT, lzma_next_filter_init(), memcpy(), my_min, lzma_coder::next, lzma_coder::next_finished, NULL, lzma_filter::options, lzma_coder::pos, lzma_dict::pos, lzma_lz_options::preset_dict, lzma_lz_options::preset_dict_size, return_if_error, lzma_coder::size, lzma_dict::size, SIZE_MAX, lzma_coder::temp, and lzma_coder::this_finished.

Referenced by lzma_lzma2_decoder_init(), and lzma_lzma_decoder_init().

lzma_lz_decoder_memusage()

uint64_t lzma_lz_decoder_memusage

(

size_t

dictionary_size

)

Definition at line 300 of file lz_decoder.c.

{
    return sizeof(lzma_coder) + (uint64_t)(dictionary_size);
}

Referenced by lzma_lzma_decoder_memusage_nocheck().

lzma_lz_decoder_uncompressed()

void lzma_lz_decoder_uncompressed	(	void *	coder_ptr,
		lzma_vli	uncompressed_size
	)

Definition at line 307 of file lz_decoder.c.

{
    lzma_coder *coder = coder_ptr;
    coder->lz.set_uncompressed(coder->lz.coder, uncompressed_size);
}

References lzma_lz_decoder::coder, lzma_coder::lz, lzma_lz_decoder::set_uncompressed, and uncompressed_size.

Referenced by alone_decode().