filter_common.c

Go to the documentation of this file.

//
//
//  Author:     Lasse Collin
//
//  This file has been put into the public domain.
//  You can do whatever you want with this file.
//
 
#include "filter_common.h"
 
 
static const struct {
    lzma_vli id;
 
    size_t options_size;
 
    bool non_last_ok;
 
    bool last_ok;
 
    bool changes_size;
 
} features[] = {
#if defined (HAVE_ENCODER_LZMA1) || defined(HAVE_DECODER_LZMA1)
    {
        .id = LZMA_FILTER_LZMA1,
        .options_size = sizeof(lzma_options_lzma),
        .non_last_ok = false,
        .last_ok = true,
        .changes_size = true,
    },
#endif
#if defined(HAVE_ENCODER_LZMA2) || defined(HAVE_DECODER_LZMA2)
    {
        .id = LZMA_FILTER_LZMA2,
        .options_size = sizeof(lzma_options_lzma),
        .non_last_ok = false,
        .last_ok = true,
        .changes_size = true,
    },
#endif
#if defined(HAVE_ENCODER_X86) || defined(HAVE_DECODER_X86)
    {
        .id = LZMA_FILTER_X86,
        .options_size = sizeof(lzma_options_bcj),
        .non_last_ok = true,
        .last_ok = false,
        .changes_size = false,
    },
#endif
#if defined(HAVE_ENCODER_POWERPC) || defined(HAVE_DECODER_POWERPC)
    {
        .id = LZMA_FILTER_POWERPC,
        .options_size = sizeof(lzma_options_bcj),
        .non_last_ok = true,
        .last_ok = false,
        .changes_size = false,
    },
#endif
#if defined(HAVE_ENCODER_IA64) || defined(HAVE_DECODER_IA64)
    {
        .id = LZMA_FILTER_IA64,
        .options_size = sizeof(lzma_options_bcj),
        .non_last_ok = true,
        .last_ok = false,
        .changes_size = false,
    },
#endif
#if defined(HAVE_ENCODER_ARM) || defined(HAVE_DECODER_ARM)
    {
        .id = LZMA_FILTER_ARM,
        .options_size = sizeof(lzma_options_bcj),
        .non_last_ok = true,
        .last_ok = false,
        .changes_size = false,
    },
#endif
#if defined(HAVE_ENCODER_ARMTHUMB) || defined(HAVE_DECODER_ARMTHUMB)
    {
        .id = LZMA_FILTER_ARMTHUMB,
        .options_size = sizeof(lzma_options_bcj),
        .non_last_ok = true,
        .last_ok = false,
        .changes_size = false,
    },
#endif
#if defined(HAVE_ENCODER_SPARC) || defined(HAVE_DECODER_SPARC)
    {
        .id = LZMA_FILTER_SPARC,
        .options_size = sizeof(lzma_options_bcj),
        .non_last_ok = true,
        .last_ok = false,
        .changes_size = false,
    },
#endif
#if defined(HAVE_ENCODER_DELTA) || defined(HAVE_DECODER_DELTA)
    {
        .id = LZMA_FILTER_DELTA,
        .options_size = sizeof(lzma_options_delta),
        .non_last_ok = true,
        .last_ok = false,
        .changes_size = false,
    },
#endif
    {
        .id = LZMA_VLI_UNKNOWN
    }
};
 
 
extern LZMA_API(lzma_ret)
lzma_filters_copy(const lzma_filter *src, lzma_filter *dest,
        const lzma_allocator *allocator)
{
    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;
}
 
 
static lzma_ret
validate_chain(const lzma_filter *filters, size_t *count)
{
    // 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;
}
 
 
extern 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)
{
    // 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;
}
 
 
extern uint64_t
lzma_raw_coder_memusage(lzma_filter_find coder_find,
        const lzma_filter *filters)
{
    // 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;
}