src/liblzma/common/filter_common.c - jrn/xz - Git at Google

 ///////////////////////////////////////////////////////////////////////////////
 //
 /// \file       filter_common.c
 /// \brief      Filter-specific stuff common for both encoder and decoder
 //
 //  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 {
 	/// Filter ID
 	lzma_vli id;

 	/// Size of the filter-specific options structure
 	size_t options_size;

 	/// True if it is OK to use this filter as non-last filter in
 	/// the chain.
 	bool non_last_ok;

 	/// True if it is OK to use this filter as the last filter in
 	/// the chain.
 	bool last_ok;

 	/// True if the filter may change the size of the data (that is, the
 	/// amount of encoded output can be different than the amount of
 	/// uncompressed input).
 	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;
 }
	///////////////////////////////////////////////////////////////////////////////
	//
	/// \file filter_common.c
	/// \brief Filter-specific stuff common for both encoder and decoder
	//
	// 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 {
	/// Filter ID
	lzma_vli id;

	/// Size of the filter-specific options structure
	size_t options_size;

	/// True if it is OK to use this filter as non-last filter in
	/// the chain.
	bool non_last_ok;

	/// True if it is OK to use this filter as the last filter in
	/// the chain.
	bool last_ok;

	/// True if the filter may change the size of the data (that is, the
	/// amount of encoded output can be different than the amount of
	/// uncompressed input).
	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;
	}