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

#include "filter_common.h"

Functions
	LZMA_API (lzma_ret)

static lzma_ret	validate_chain (const lzma_filter filters, size_t count)

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

uint64_t	lzma_raw_coder_memusage (lzma_filter_find coder_find, const lzma_filter *filters)

Variables
struct {
lzma_vli id
	Filter ID. More...

size_t options_size
	Size of the filter-specific options structure. More...

bool non_last_ok

bool last_ok

bool changes_size

}	features []

Detailed Description

Filter-specific stuff common for both encoder and decoder.

Definition in file filter_common.c.

Function Documentation

◆ LZMA_API()

LZMA_API ( lzma_ret )

Definition at line 124 of file filter_common.c.

 {
     if (src == NULL || dest == NULL)
         return LZMA_PROG_ERROR;
  
     lzma_ret ret;
     size_t i;
     for (i = 0; src[i].id != LZMA_VLI_UNKNOWN; ++i) {
         // There must be a maximum of four filters plus
         // the array terminator.
         if (i == LZMA_FILTERS_MAX) {
             ret = LZMA_OPTIONS_ERROR;
             goto error;
         }
  
         dest[i].id = src[i].id;
  
         if (src[i].options == NULL) {
             dest[i].options = NULL;
         } else {
             // See if the filter is supported only when the
             // options is not NULL. This might be convenient
             // sometimes if the app is actually copying only
             // a partial filter chain with a place holder ID.
             //
             // When options is not NULL, the Filter ID must be
             // supported by us, because otherwise we don't know
             // how big the options are.
             size_t j;
             for (j = 0; src[i].id != features[j].id; ++j) {
                 if (features[j].id == LZMA_VLI_UNKNOWN) {
                     ret = LZMA_OPTIONS_ERROR;
                     goto error;
                 }
             }
  
             // Allocate and copy the options.
             dest[i].options = lzma_alloc(features[j].options_size,
                     allocator);
             if (dest[i].options == NULL) {
                 ret = LZMA_MEM_ERROR;
                 goto error;
             }
  
             memcpy(dest[i].options, src[i].options,
                     features[j].options_size);
         }
     }
  
     // Terminate the filter array.
     assert(i <= LZMA_FILTERS_MAX + 1);
     dest[i].id = LZMA_VLI_UNKNOWN;
     dest[i].options = NULL;
  
     return LZMA_OK;
  
 error:
     // Free the options which we have already allocated.
     while (i-- > 0) {
         lzma_free(dest[i].options, allocator);
         dest[i].options = NULL;
     }
  
     return ret;
 }

References allocator, assert(), dest, error(), features, i, lzma_alloc(), LZMA_FILTERS_MAX, lzma_free(), LZMA_MEM_ERROR, LZMA_OK, LZMA_OPTIONS_ERROR, LZMA_PROG_ERROR, LZMA_VLI_UNKNOWN, memcpy(), NULL, options, options_size, and src.

◆ lzma_raw_coder_init()

lzma_ret lzma_raw_coder_init	(	lzma_next_coder *	next,
		const lzma_allocator *	allocator,
		const lzma_filter *	options,
		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().

◆ validate_chain()

static lzma_ret validate_chain	(	const lzma_filter *	filters,
		size_t *	count
	)

static

Definition at line 194 of file filter_common.c.

 {
     // There must be at least one filter.
     if (filters == NULL || filters[0].id == LZMA_VLI_UNKNOWN)
         return LZMA_PROG_ERROR;
  
     // Number of non-last filters that may change the size of the data
     // significantly (that is, more than 1-2 % or so).
     size_t changes_size_count = 0;
  
     // True if it is OK to add a new filter after the current filter.
     bool non_last_ok = true;
  
     // True if the last filter in the given chain is actually usable as
     // the last filter. Only filters that support embedding End of Payload
     // Marker can be used as the last filter in the chain.
     bool last_ok = false;
  
     size_t i = 0;
     do {
         size_t j;
         for (j = 0; filters[i].id != features[j].id; ++j)
             if (features[j].id == LZMA_VLI_UNKNOWN)
                 return LZMA_OPTIONS_ERROR;
  
         // If the previous filter in the chain cannot be a non-last
         // filter, the chain is invalid.
         if (!non_last_ok)
             return LZMA_OPTIONS_ERROR;
  
         non_last_ok = features[j].non_last_ok;
         last_ok = features[j].last_ok;
         changes_size_count += features[j].changes_size;
  
     } while (filters[++i].id != LZMA_VLI_UNKNOWN);
  
     // There must be 1-4 filters. The last filter must be usable as
     // the last filter in the chain. A maximum of three filters are
     // allowed to change the size of the data.
     if (i > LZMA_FILTERS_MAX || !last_ok || changes_size_count > 3)
         return LZMA_OPTIONS_ERROR;
  
     *count = i;
     return LZMA_OK;
 }