filter_common.h File Reference

Filter-specific stuff common for both encoder and decoder. More...

#include "common.h"

Go to the source code of this file.

Classes
struct	lzma_filter_coder
	Both lzma_filter_encoder and lzma_filter_decoder begin with these members. More...

Typedefs
typedef const lzma_filter_coder *(*	lzma_filter_find) (lzma_vli id)

Functions
lzma_ret	lzma_raw_coder_init (lzma_next_coder *next, const lzma_allocator *allocator, const lzma_filter *filters, lzma_filter_find coder_find, bool is_encoder)
uint64_t	lzma_raw_coder_memusage (lzma_filter_find coder_find, const lzma_filter *filters)

Detailed Description

Filter-specific stuff common for both encoder and decoder.

Definition in file filter_common.h.

Typedef Documentation

lzma_filter_find

typedef const lzma_filter_coder*(* lzma_filter_find) (lzma_vli id)

Definition at line 35 of file filter_common.h.

Function Documentation

lzma_raw_coder_init()

lzma_ret lzma_raw_coder_init	(	lzma_next_coder *	next,
		const lzma_allocator *	allocator,
		const lzma_filter *	filters,
		lzma_filter_find	coder_find,
		bool	is_encoder
	)

Definition at line 242 of file filter_common.c.

{
    // Do some basic validation and get the number of filters.
    size_t count;
    return_if_error(validate_chain(options, &count));
 
    // Set the filter functions and copy the options pointer.
    lzma_filter_info filters[LZMA_FILTERS_MAX + 1];
    if (is_encoder) {
        for (size_t i = 0; i < count; ++i) {
            // The order of the filters is reversed in the
            // encoder. It allows more efficient handling
            // of the uncompressed data.
            const size_t j = count - i - 1;
 
            const lzma_filter_coder *const fc
                    = coder_find(options[i].id);
            if (fc == NULL || fc->init == NULL)
                return LZMA_OPTIONS_ERROR;
 
            filters[j].id = options[i].id;
            filters[j].init = fc->init;
            filters[j].options = options[i].options;
        }
    } else {
        for (size_t i = 0; i < count; ++i) {
            const lzma_filter_coder *const fc
                    = coder_find(options[i].id);
            if (fc == NULL || fc->init == NULL)
                return LZMA_OPTIONS_ERROR;
 
            filters[i].id = options[i].id;
            filters[i].init = fc->init;
            filters[i].options = options[i].options;
        }
    }
 
    // Terminate the array.
    filters[count].id = LZMA_VLI_UNKNOWN;
    filters[count].init = NULL;
 
    // Initialize the filters.
    const lzma_ret ret = lzma_next_filter_init(next, allocator, filters);
    if (ret != LZMA_OK)
        lzma_next_end(next, allocator);
 
    return ret;
}

References allocator, count, filters, i, lzma_filter::id, lzma_filter_coder::init, LZMA_FILTERS_MAX, lzma_next_end(), lzma_next_filter_init(), LZMA_OK, LZMA_OPTIONS_ERROR, LZMA_VLI_UNKNOWN, NULL, options, lzma_filter::options, return_if_error, and validate_chain().

Referenced by lzma_raw_decoder_init(), and lzma_raw_encoder_init().

lzma_raw_coder_memusage()

uint64_t lzma_raw_coder_memusage	(	lzma_filter_find	coder_find,
		const lzma_filter *	filters
	)

Definition at line 295 of file filter_common.c.

{
    // The chain has to have at least one filter.
    {
        size_t tmp;
        if (validate_chain(filters, &tmp) != LZMA_OK)
            return UINT64_MAX;
    }
 
    uint64_t total = 0;
    size_t i = 0;
 
    do {
        const lzma_filter_coder *const fc
                 = coder_find(filters[i].id);
        if (fc == NULL)
            return UINT64_MAX; // Unsupported Filter ID
 
        if (fc->memusage == NULL) {
            // This filter doesn't have a function to calculate
            // the memory usage and validate the options. Such
            // filters need only little memory, so we use 1 KiB
            // as a good estimate. They also accept all possible
            // options, so there's no need to worry about lack
            // of validation.
            total += 1024;
        } else {
            // Call the filter-specific memory usage calculation
            // function.
            const uint64_t usage
                    = fc->memusage(filters[i].options);
            if (usage == UINT64_MAX)
                return UINT64_MAX; // Invalid options
 
            total += usage;
        }
    } while (filters[++i].id != LZMA_VLI_UNKNOWN);
 
    // Add some fixed amount of extra. It's to compensate memory usage
    // of Stream, Block etc. coders, malloc() overhead, stack etc.
    return total + LZMA_MEMUSAGE_BASE;
}

References filters, i, LZMA_MEMUSAGE_BASE, LZMA_OK, LZMA_VLI_UNKNOWN, lzma_filter_coder::memusage, NULL, options, autogen_x86imm::tmp, UINT64_MAX, usage(), and validate_chain().

Referenced by LZMA_API().