diff options
Diffstat (limited to 'contrib/xz/src/liblzma')
30 files changed, 69 insertions, 2131 deletions
diff --git a/contrib/xz/src/liblzma/api/lzma.h b/contrib/xz/src/liblzma/api/lzma.h index 5be9b4e..fb593a3 100644 --- a/contrib/xz/src/liblzma/api/lzma.h +++ b/contrib/xz/src/liblzma/api/lzma.h @@ -234,10 +234,6 @@ # define lzma_attribute(attr) __attribute__(attr) # endif -# ifndef lzma_restrict -# define lzma_restrict __restrict__ -# endif - /* warn_unused_result was added in GCC 3.4. */ # ifndef lzma_attr_warn_unused_result # if __GNUC__ == 3 && __GNUC_MINOR__ < 4 @@ -249,14 +245,6 @@ # ifndef lzma_attribute # define lzma_attribute(attr) # endif - -# ifndef lzma_restrict -# if __STDC_VERSION__ >= 199901L -# define lzma_restrict restrict -# else -# define lzma_restrict -# endif -# endif #endif @@ -296,7 +284,6 @@ extern "C" { /* Filters */ #include "lzma/filter.h" -#include "lzma/subblock.h" #include "lzma/bcj.h" #include "lzma/delta.h" #include "lzma/lzma.h" diff --git a/contrib/xz/src/liblzma/api/lzma/index.h b/contrib/xz/src/liblzma/api/lzma/index.h index 8d7a799..5ea12e3 100644 --- a/contrib/xz/src/liblzma/api/lzma/index.h +++ b/contrib/xz/src/liblzma/api/lzma/index.h @@ -368,7 +368,7 @@ extern LZMA_API(lzma_ret) lzma_index_stream_flags( /** * \brief Get the types of integrity Checks * - * If lzma_index_stream_padding() is used to set the Stream Flags for + * If lzma_index_stream_flags() is used to set the Stream Flags for * every Stream, lzma_index_checks() can be used to get a bitmask to * indicate which Check types have been used. It can be useful e.g. if * showing the Check types to the user. @@ -562,9 +562,8 @@ extern LZMA_API(lzma_bool) lzma_index_iter_locate( * - LZMA_MEM_ERROR * - LZMA_PROG_ERROR */ -extern LZMA_API(lzma_ret) lzma_index_cat(lzma_index *lzma_restrict dest, - lzma_index *lzma_restrict src, - lzma_allocator *allocator) +extern LZMA_API(lzma_ret) lzma_index_cat( + lzma_index *dest, lzma_index *src, lzma_allocator *allocator) lzma_nothrow lzma_attr_warn_unused_result; diff --git a/contrib/xz/src/liblzma/api/lzma/lzma.h b/contrib/xz/src/liblzma/api/lzma/lzma.h index c17736d..9d31a5c 100644 --- a/contrib/xz/src/liblzma/api/lzma/lzma.h +++ b/contrib/xz/src/liblzma/api/lzma/lzma.h @@ -49,7 +49,7 @@ * The memory usage formulas are only rough estimates, which are closest to * reality when dict_size is a power of two. The formulas are more complex * in reality, and can also change a little between liblzma versions. Use - * lzma_memusage_encoder() to get more accurate estimate of memory usage. + * lzma_raw_encoder_memusage() to get more accurate estimate of memory usage. */ typedef enum { LZMA_MF_HC3 = 0x03, @@ -69,7 +69,9 @@ typedef enum { * * Minimum nice_len: 4 * - * Memory usage: dict_size * 7.5 + * Memory usage: + * - dict_size <= 32 MiB: dict_size * 7.5 + * - dict_size > 32 MiB: dict_size * 6.5 */ LZMA_MF_BT2 = 0x12, @@ -98,7 +100,9 @@ typedef enum { * * Minimum nice_len: 4 * - * Memory usage: dict_size * 11.5 + * Memory usage: + * - dict_size <= 32 MiB: dict_size * 11.5 + * - dict_size > 32 MiB: dict_size * 10.5 */ } lzma_match_finder; diff --git a/contrib/xz/src/liblzma/api/lzma/subblock.h b/contrib/xz/src/liblzma/api/lzma/subblock.h deleted file mode 100644 index 4ffb049..0000000 --- a/contrib/xz/src/liblzma/api/lzma/subblock.h +++ /dev/null @@ -1,200 +0,0 @@ -/** - * \file lzma/subblock.h - * \brief Subblock filter - */ - -/* - * Author: Lasse Collin - * - * This file has been put into the public domain. - * You can do whatever you want with this file. - * - * See ../lzma.h for information about liblzma as a whole. - */ - -#ifndef LZMA_H_INTERNAL -# error Never include this file directly. Use <lzma.h> instead. -#endif - - -/** - * \brief Filter ID - * - * Filter ID of the Subblock filter. This is used as lzma_filter.id. - */ -#define LZMA_FILTER_SUBBLOCK LZMA_VLI_C(0x01) - - -/** - * \brief Subfilter mode - * - * See lzma_options_subblock.subfilter_mode for details. - */ -typedef enum { - LZMA_SUBFILTER_NONE, - /**< - * No Subfilter is in use. - */ - - LZMA_SUBFILTER_SET, - /**< - * New Subfilter has been requested to be initialized. - */ - - LZMA_SUBFILTER_RUN, - /**< - * Subfilter is active. - */ - - LZMA_SUBFILTER_FINISH - /**< - * Subfilter has been requested to be finished. - */ -} lzma_subfilter_mode; - - -/** - * \brief Options for the Subblock filter - * - * Specifying options for the Subblock filter is optional: if the pointer - * options is NULL, no subfilters are allowed and the default value is used - * for subblock_data_size. - */ -typedef struct { - /* Options for encoder and decoder */ - - /** - * \brief Allowing subfilters - * - * If this true, subfilters are allowed. - * - * In the encoder, if this is set to false, subfilter_mode and - * subfilter_options are completely ignored. - */ - lzma_bool allow_subfilters; - - /* Options for encoder only */ - - /** - * \brief Alignment - * - * The Subblock filter encapsulates the input data into Subblocks. - * Each Subblock has a header which takes a few bytes of space. - * When the output of the Subblock encoder is fed to another filter - * that takes advantage of the alignment of the input data (e.g. LZMA), - * the Subblock filter can add padding to keep the actual data parts - * in the Subblocks aligned correctly. - * - * The alignment should be a positive integer. Subblock filter will - * add enough padding between Subblocks so that this is true for - * every payload byte: - * input_offset % alignment == output_offset % alignment - * - * The Subblock filter assumes that the first output byte will be - * written to a position in the output stream that is properly - * aligned. This requirement is automatically met when the start - * offset of the Stream or Block is correctly told to Block or - * Stream encoder. - */ - uint32_t alignment; -# define LZMA_SUBBLOCK_ALIGNMENT_MIN 1 -# define LZMA_SUBBLOCK_ALIGNMENT_MAX 32 -# define LZMA_SUBBLOCK_ALIGNMENT_DEFAULT 4 - - /** - * \brief Size of the Subblock Data part of each Subblock - * - * This value is re-read every time a new Subblock is started. - * - * Bigger values - * - save a few bytes of space; - * - increase latency in the encoder (but no effect for decoding); - * - decrease memory locality (increased cache pollution) in the - * encoder (no effect in decoding). - */ - uint32_t subblock_data_size; -# define LZMA_SUBBLOCK_DATA_SIZE_MIN 1 -# define LZMA_SUBBLOCK_DATA_SIZE_MAX (UINT32_C(1) << 28) -# define LZMA_SUBBLOCK_DATA_SIZE_DEFAULT 4096 - - /** - * \brief Run-length encoder remote control - * - * The Subblock filter has an internal run-length encoder (RLE). It - * can be useful when the data includes byte sequences that repeat - * very many times. The RLE can be used also when a Subfilter is - * in use; the RLE will be applied to the output of the Subfilter. - * - * Note that in contrast to traditional RLE, this RLE is intended to - * be used only when there's a lot of data to be repeated. If the - * input data has e.g. 500 bytes of NULs now and then, this RLE - * is probably useless, because plain LZMA should provide better - * results. - * - * Due to above reasons, it was decided to keep the implementation - * of the RLE very simple. When the rle variable is non-zero, it - * subblock_data_size must be a multiple of rle. Once the Subblock - * encoder has got subblock_data_size bytes of input, it will check - * if the whole buffer of the last subblock_data_size can be - * represented with repeats of chunks having size of rle bytes. - * - * If there are consecutive identical buffers of subblock_data_size - * bytes, they will be encoded using a single repeat entry if - * possible. - * - * If need arises, more advanced RLE can be implemented later - * without breaking API or ABI. - */ - uint32_t rle; -# define LZMA_SUBBLOCK_RLE_OFF 0 -# define LZMA_SUBBLOCK_RLE_MIN 1 -# define LZMA_SUBBLOCK_RLE_MAX 256 - - /** - * \brief Subfilter remote control - * - * When the Subblock filter is initialized, this variable must be - * LZMA_SUBFILTER_NONE or LZMA_SUBFILTER_SET. - * - * When subfilter_mode is LZMA_SUBFILTER_NONE, the application may - * put Subfilter options to subfilter_options structure, and then - * set subfilter_mode to LZMA_SUBFILTER_SET. No new input data will - * be read until the Subfilter has been enabled. Once the Subfilter - * has been enabled, liblzma will set subfilter_mode to - * LZMA_SUBFILTER_RUN. - * - * When subfilter_mode is LZMA_SUBFILTER_RUN, the application may - * set subfilter_mode to LZMA_SUBFILTER_FINISH. All the input - * currently available will be encoded before unsetting the - * Subfilter. Application must not change the amount of available - * input until the Subfilter has finished. Once the Subfilter has - * finished, liblzma will set subfilter_mode to LZMA_SUBFILTER_NONE. - * - * If the intent is to have Subfilter enabled to the very end of - * the data, it is not needed to separately disable Subfilter with - * LZMA_SUBFILTER_FINISH. Using LZMA_FINISH as the second argument - * of lzma_code() will make the Subblock encoder to disable the - * Subfilter once all the data has been ran through the Subfilter. - * - * After the first call with LZMA_SYNC_FLUSH or LZMA_FINISH, the - * application must not change subfilter_mode until LZMA_STREAM_END. - * Setting LZMA_SUBFILTER_SET/LZMA_SUBFILTER_FINISH and - * LZMA_SYNC_FLUSH/LZMA_FINISH _at the same time_ is fine. - * - * \note This variable is ignored if allow_subfilters is false. - */ - lzma_subfilter_mode subfilter_mode; - - /** - * \brief Subfilter and its options - * - * When no Subfilter is used, the data is copied as is into Subblocks. - * Setting a Subfilter allows encoding some parts of the data with - * an additional filter. It is possible to many different Subfilters - * in the same Block, although only one can be used at once. - * - * \note This variable is ignored if allow_subfilters is false. - */ - lzma_filter subfilter_options; - -} lzma_options_subblock; diff --git a/contrib/xz/src/liblzma/api/lzma/vli.h b/contrib/xz/src/liblzma/api/lzma/vli.h index 8d4277f..57e3d38 100644 --- a/contrib/xz/src/liblzma/api/lzma/vli.h +++ b/contrib/xz/src/liblzma/api/lzma/vli.h @@ -113,9 +113,8 @@ typedef uint64_t lzma_vli; * - LZMA_BUF_ERROR: No output space was provided. * - LZMA_PROG_ERROR: Arguments are not sane. */ -extern LZMA_API(lzma_ret) lzma_vli_encode(lzma_vli vli, - size_t *vli_pos, uint8_t *lzma_restrict out, - size_t *lzma_restrict out_pos, size_t out_size) lzma_nothrow; +extern LZMA_API(lzma_ret) lzma_vli_encode(lzma_vli vli, size_t *vli_pos, + uint8_t *out, size_t *out_pos, size_t out_size) lzma_nothrow; /** @@ -153,9 +152,9 @@ extern LZMA_API(lzma_ret) lzma_vli_encode(lzma_vli vli, * - LZMA_BUF_ERROR: No input was provided. * - LZMA_PROG_ERROR: Arguments are not sane. */ -extern LZMA_API(lzma_ret) lzma_vli_decode(lzma_vli *lzma_restrict vli, - size_t *vli_pos, const uint8_t *lzma_restrict in, - size_t *lzma_restrict in_pos, size_t in_size) lzma_nothrow; +extern LZMA_API(lzma_ret) lzma_vli_decode(lzma_vli *vli, size_t *vli_pos, + const uint8_t *in, size_t *in_pos, size_t in_size) + lzma_nothrow; /** diff --git a/contrib/xz/src/liblzma/common/block_buffer_encoder.c b/contrib/xz/src/liblzma/common/block_buffer_encoder.c index 4d90fee..a8f71c2 100644 --- a/contrib/xz/src/liblzma/common/block_buffer_encoder.c +++ b/contrib/xz/src/liblzma/common/block_buffer_encoder.c @@ -139,7 +139,7 @@ block_encode_uncompressed(lzma_block *block, const uint8_t *in, size_t in_size, // Size of the uncompressed chunk const size_t copy_size - = MIN(in_size - in_pos, LZMA2_CHUNK_MAX); + = my_min(in_size - in_pos, LZMA2_CHUNK_MAX); out[(*out_pos)++] = (copy_size - 1) >> 8; out[(*out_pos)++] = (copy_size - 1) & 0xFF; diff --git a/contrib/xz/src/liblzma/common/block_util.c b/contrib/xz/src/liblzma/common/block_util.c index cb9cde2..62c9345 100644 --- a/contrib/xz/src/liblzma/common/block_util.c +++ b/contrib/xz/src/liblzma/common/block_util.c @@ -15,7 +15,7 @@ extern LZMA_API(lzma_ret) -lzma_block_compressed_size(lzma_block *block, lzma_vli total_size) +lzma_block_compressed_size(lzma_block *block, lzma_vli unpadded_size) { // Validate everything but Uncompressed Size and filters. if (lzma_block_unpadded_size(block) == 0) @@ -25,13 +25,13 @@ lzma_block_compressed_size(lzma_block *block, lzma_vli total_size) + lzma_check_size(block->check); // Validate that Compressed Size will be greater than zero. - if (container_size <= total_size) + if (unpadded_size <= container_size) return LZMA_DATA_ERROR; // Calculate what Compressed Size is supposed to be. // If Compressed Size was present in Block Header, // compare that the new value matches it. - const lzma_vli compressed_size = total_size - container_size; + const lzma_vli compressed_size = unpadded_size - container_size; if (block->compressed_size != LZMA_VLI_UNKNOWN && block->compressed_size != compressed_size) return LZMA_DATA_ERROR; diff --git a/contrib/xz/src/liblzma/common/chunk_size.c b/contrib/xz/src/liblzma/common/chunk_size.c deleted file mode 100644 index 363f07e..0000000 --- a/contrib/xz/src/liblzma/common/chunk_size.c +++ /dev/null @@ -1,67 +0,0 @@ -/////////////////////////////////////////////////////////////////////////////// -// -/// \file chunk_size.c -/// \brief Finds out the minimal reasonable chunk size for a filter chain -// -// Author: Lasse Collin -// -// This file has been put into the public domain. -// You can do whatever you want with this file. -// -/////////////////////////////////////////////////////////////////////////////// - -#include "common.h" - - -/** - * \brief Finds out the minimal reasonable chunk size for a filter chain - * - * This function helps determining the Uncompressed Sizes of the Blocks when - * doing multi-threaded encoding. - * - * When compressing a large file on a system having multiple CPUs or CPU - * cores, the file can be split into smaller chunks, that are compressed - * independently into separate Blocks in the same .lzma Stream. - * - * \return Minimum reasonable Uncompressed Size of a Block. The - * recommended minimum Uncompressed Size is between this value - * and the value times two. - - Zero if the Uncompressed Sizes of Blocks don't matter - */ -extern LZMA_API(size_t) -lzma_chunk_size(const lzma_options_filter *filters) -{ - while (filters->id != LZMA_VLI_UNKNOWN) { - switch (filters->id) { - // TODO LZMA_FILTER_SPARSE - - case LZMA_FILTER_COPY: - case LZMA_FILTER_SUBBLOCK: - case LZMA_FILTER_X86: - case LZMA_FILTER_POWERPC: - case LZMA_FILTER_IA64: - case LZMA_FILTER_ARM: - case LZMA_FILTER_ARMTHUMB: - case LZMA_FILTER_SPARC: - // These are very fast, thus there is no point in - // splitting the data into smaller blocks. - break; - - case LZMA_FILTER_LZMA1: - // The block sizes of the possible next filters in - // the chain are irrelevant after the LZMA filter. - return ((lzma_options_lzma *)(filters->options)) - ->dictionary_size; - - default: - // Unknown filters - return 0; - } - - ++filters; - } - - // Indicate that splitting would be useless. - return SIZE_MAX; -} diff --git a/contrib/xz/src/liblzma/common/common.c b/contrib/xz/src/liblzma/common/common.c index 2f185e4..07b1d47 100644 --- a/contrib/xz/src/liblzma/common/common.c +++ b/contrib/xz/src/liblzma/common/common.c @@ -76,7 +76,7 @@ lzma_bufcpy(const uint8_t *restrict in, size_t *restrict in_pos, { const size_t in_avail = in_size - *in_pos; const size_t out_avail = out_size - *out_pos; - const size_t copy_size = MIN(in_avail, out_avail); + const size_t copy_size = my_min(in_avail, out_avail); memcpy(out + *out_pos, in + *in_pos, copy_size); diff --git a/contrib/xz/src/liblzma/common/common.h b/contrib/xz/src/liblzma/common/common.h index 7b7fbb1..3a85168 100644 --- a/contrib/xz/src/liblzma/common/common.h +++ b/contrib/xz/src/liblzma/common/common.h @@ -60,12 +60,6 @@ #define LZMA_FILTER_RESERVED_START (LZMA_VLI_C(1) << 62) -/// Internal helper filter used by Subblock decoder. It is mapped to an -/// otherwise invalid Filter ID, which is impossible to get from any input -/// file (even if malicious file). -#define LZMA_FILTER_SUBBLOCK_HELPER LZMA_VLI_C(0x7000000000000001) - - /// Supported flags that can be passed to lzma_stream_decoder() /// or lzma_auto_decoder(). #define LZMA_SUPPORTED_FLAGS \ diff --git a/contrib/xz/src/liblzma/common/filter_common.c b/contrib/xz/src/liblzma/common/filter_common.c index 2322d7d..b157c62 100644 --- a/contrib/xz/src/liblzma/common/filter_common.c +++ b/contrib/xz/src/liblzma/common/filter_common.c @@ -52,15 +52,6 @@ static const struct { .changes_size = true, }, #endif -#if defined(HAVE_ENCODER_SUBBLOCK) || defined(HAVE_DECODER_SUBBLOCK) - { - .id = LZMA_FILTER_SUBBLOCK, - .options_size = sizeof(lzma_options_subblock), - .non_last_ok = true, - .last_ok = true, - .changes_size = true, - }, -#endif #ifdef HAVE_DECODER_X86 { .id = LZMA_FILTER_X86, diff --git a/contrib/xz/src/liblzma/common/filter_decoder.c b/contrib/xz/src/liblzma/common/filter_decoder.c index 95f77b7..1ebbe2a 100644 --- a/contrib/xz/src/liblzma/common/filter_decoder.c +++ b/contrib/xz/src/liblzma/common/filter_decoder.c @@ -14,8 +14,6 @@ #include "filter_common.h" #include "lzma_decoder.h" #include "lzma2_decoder.h" -#include "subblock_decoder.h" -#include "subblock_decoder_helper.h" #include "simple_decoder.h" #include "delta_decoder.h" @@ -60,20 +58,6 @@ static const lzma_filter_decoder decoders[] = { .props_decode = &lzma_lzma2_props_decode, }, #endif -#ifdef HAVE_DECODER_SUBBLOCK - { - .id = LZMA_FILTER_SUBBLOCK, - .init = &lzma_subblock_decoder_init, -// .memusage = &lzma_subblock_decoder_memusage, - .props_decode = NULL, - }, - { - .id = LZMA_FILTER_SUBBLOCK_HELPER, - .init = &lzma_subblock_decoder_helper_init, - .memusage = NULL, - .props_decode = NULL, - }, -#endif #ifdef HAVE_DECODER_X86 { .id = LZMA_FILTER_X86, diff --git a/contrib/xz/src/liblzma/common/filter_encoder.c b/contrib/xz/src/liblzma/common/filter_encoder.c index ab3d3af..436d2cc 100644 --- a/contrib/xz/src/liblzma/common/filter_encoder.c +++ b/contrib/xz/src/liblzma/common/filter_encoder.c @@ -14,7 +14,6 @@ #include "filter_common.h" #include "lzma_encoder.h" #include "lzma2_encoder.h" -#include "subblock_encoder.h" #include "simple_encoder.h" #include "delta_encoder.h" @@ -77,17 +76,6 @@ static const lzma_filter_encoder encoders[] = { .props_encode = &lzma_lzma2_props_encode, }, #endif -#ifdef HAVE_ENCODER_SUBBLOCK - { - .id = LZMA_FILTER_SUBBLOCK, - .init = &lzma_subblock_encoder_init, -// .memusage = &lzma_subblock_encoder_memusage, - .chunk_size = NULL, - .props_size_get = NULL, - .props_size_fixed = 0, - .props_encode = NULL, - }, -#endif #ifdef HAVE_ENCODER_X86 { .id = LZMA_FILTER_X86, diff --git a/contrib/xz/src/liblzma/common/stream_buffer_encoder.c b/contrib/xz/src/liblzma/common/stream_buffer_encoder.c index bbafaa6..f727d85 100644 --- a/contrib/xz/src/liblzma/common/stream_buffer_encoder.c +++ b/contrib/xz/src/liblzma/common/stream_buffer_encoder.c @@ -33,7 +33,7 @@ lzma_stream_buffer_bound(size_t uncompressed_size) // Catch the possible integer overflow and also prevent the size of // the Stream exceeding LZMA_VLI_MAX (theoretically possible on // 64-bit systems). - if (MIN(SIZE_MAX, LZMA_VLI_MAX) - block_bound < HEADERS_BOUND) + if (my_min(SIZE_MAX, LZMA_VLI_MAX) - block_bound < HEADERS_BOUND) return 0; return block_bound + HEADERS_BOUND; diff --git a/contrib/xz/src/liblzma/delta/delta_encoder.c b/contrib/xz/src/liblzma/delta/delta_encoder.c index 80d0d17..ea1cc2c 100644 --- a/contrib/xz/src/liblzma/delta/delta_encoder.c +++ b/contrib/xz/src/liblzma/delta/delta_encoder.c @@ -59,7 +59,7 @@ delta_encode(lzma_coder *coder, lzma_allocator *allocator, if (coder->next.code == NULL) { const size_t in_avail = in_size - *in_pos; const size_t out_avail = out_size - *out_pos; - const size_t size = MIN(in_avail, out_avail); + const size_t size = my_min(in_avail, out_avail); copy_and_encode(coder, in + *in_pos, out + *out_pos, size); diff --git a/contrib/xz/src/liblzma/lz/lz_decoder.c b/contrib/xz/src/liblzma/lz/lz_decoder.c index 350b1f8..2c57355 100644 --- a/contrib/xz/src/liblzma/lz/lz_decoder.c +++ b/contrib/xz/src/liblzma/lz/lz_decoder.c @@ -81,8 +81,9 @@ decode_buffer(lzma_coder *coder, // 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 + MIN(out_size - *out_pos, - coder->dict.size - coder->dict.pos); + 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( @@ -264,7 +265,7 @@ lzma_lz_decoder_init(lzma_next_coder *next, lzma_allocator *allocator, && 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 = MIN(lz_options.preset_dict_size, + 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(next->coder->dict.buf, lz_options.preset_dict + offset, diff --git a/contrib/xz/src/liblzma/lz/lz_decoder.h b/contrib/xz/src/liblzma/lz/lz_decoder.h index bf1609d..7266e80 100644 --- a/contrib/xz/src/liblzma/lz/lz_decoder.h +++ b/contrib/xz/src/liblzma/lz/lz_decoder.h @@ -129,7 +129,7 @@ dict_repeat(lzma_dict *dict, uint32_t distance, uint32_t *len) { // Don't write past the end of the dictionary. const size_t dict_avail = dict->limit - dict->pos; - uint32_t left = MIN(dict_avail, *len); + uint32_t left = my_min(dict_avail, *len); *len -= left; // Repeat a block of data from the history. Because memcpy() is faster diff --git a/contrib/xz/src/liblzma/lz/lz_encoder.c b/contrib/xz/src/liblzma/lz/lz_encoder.c index 757e537..273f577 100644 --- a/contrib/xz/src/liblzma/lz/lz_encoder.c +++ b/contrib/xz/src/liblzma/lz/lz_encoder.c @@ -341,7 +341,7 @@ lz_encoder_prepare(lzma_mf *mf, lzma_allocator *allocator, // Deallocate the old hash array if it exists and has different size // than what is needed now. - if (mf->hash != NULL && old_count != new_count) { + if (old_count != new_count) { lzma_free(mf->hash, allocator); mf->hash = NULL; } @@ -349,9 +349,10 @@ lz_encoder_prepare(lzma_mf *mf, lzma_allocator *allocator, // Maximum number of match finder cycles mf->depth = lz_options->depth; if (mf->depth == 0) { - mf->depth = 16 + (mf->nice_len / 2); - if (!is_bt) - mf->depth /= 2; + if (is_bt) + mf->depth = 16 + mf->nice_len / 2; + else + mf->depth = 4 + mf->nice_len / 4; } return false; @@ -423,7 +424,7 @@ lz_encoder_init(lzma_mf *mf, lzma_allocator *allocator, && lz_options->preset_dict_size > 0) { // If the preset dictionary is bigger than the actual // dictionary, use only the tail. - mf->write_pos = MIN(lz_options->preset_dict_size, mf->size); + mf->write_pos = my_min(lz_options->preset_dict_size, mf->size); memcpy(mf->buffer, lz_options->preset_dict + lz_options->preset_dict_size - mf->write_pos, mf->write_pos); @@ -444,6 +445,8 @@ lzma_lz_encoder_memusage(const lzma_lz_options *lz_options) lzma_mf mf = { .buffer = NULL, .hash = NULL, + .hash_size_sum = 0, + .sons_count = 0, }; // Setup the size information into mf. @@ -519,6 +522,8 @@ lzma_lz_encoder_init(lzma_next_coder *next, lzma_allocator *allocator, next->coder->mf.buffer = NULL; next->coder->mf.hash = NULL; + next->coder->mf.hash_size_sum = 0; + next->coder->mf.sons_count = 0; next->coder->next = LZMA_NEXT_CODER_INIT; } diff --git a/contrib/xz/src/liblzma/lz/lz_encoder.h b/contrib/xz/src/liblzma/lz/lz_encoder.h index f6352a4..741c453 100644 --- a/contrib/xz/src/liblzma/lz/lz_encoder.h +++ b/contrib/xz/src/liblzma/lz/lz_encoder.h @@ -281,7 +281,7 @@ mf_read(lzma_mf *mf, uint8_t *out, size_t *out_pos, size_t out_size, size_t *left) { const size_t out_avail = out_size - *out_pos; - const size_t copy_size = MIN(out_avail, *left); + const size_t copy_size = my_min(out_avail, *left); assert(mf->read_ahead == 0); assert(mf->read_pos >= *left); diff --git a/contrib/xz/src/liblzma/lz/lz_encoder_mf.c b/contrib/xz/src/liblzma/lz/lz_encoder_mf.c index b31b085..f82a1c1 100644 --- a/contrib/xz/src/liblzma/lz/lz_encoder_mf.c +++ b/contrib/xz/src/liblzma/lz/lz_encoder_mf.c @@ -481,7 +481,7 @@ bt_find_func( << 1); const uint8_t *const pb = cur - delta; - uint32_t len = MIN(len0, len1); + uint32_t len = my_min(len0, len1); if (pb[len] == cur[len]) { while (++len != len_limit) @@ -546,7 +546,7 @@ bt_skip_func( + (delta > cyclic_pos ? cyclic_size : 0)) << 1); const uint8_t *pb = cur - delta; - uint32_t len = MIN(len0, len1); + uint32_t len = my_min(len0, len1); if (pb[len] == cur[len]) { while (++len != len_limit) diff --git a/contrib/xz/src/liblzma/lzma/lzma2_encoder.c b/contrib/xz/src/liblzma/lzma/lzma2_encoder.c index 1e0569a..b48e0d6 100644 --- a/contrib/xz/src/liblzma/lzma/lzma2_encoder.c +++ b/contrib/xz/src/liblzma/lzma/lzma2_encoder.c @@ -372,7 +372,7 @@ extern lzma_ret lzma_lzma2_props_encode(const void *options, uint8_t *out) { const lzma_options_lzma *const opt = options; - uint32_t d = MAX(opt->dict_size, LZMA_DICT_SIZE_MIN); + uint32_t d = my_max(opt->dict_size, LZMA_DICT_SIZE_MIN); // Round up to to the next 2^n - 1 or 2^n + 2^(n - 1) - 1 depending // on which one is the next: diff --git a/contrib/xz/src/liblzma/lzma/lzma_encoder_optimum_fast.c b/contrib/xz/src/liblzma/lzma/lzma_encoder_optimum_fast.c index 4ca55b6..f835f69 100644 --- a/contrib/xz/src/liblzma/lzma/lzma_encoder_optimum_fast.c +++ b/contrib/xz/src/liblzma/lzma/lzma_encoder_optimum_fast.c @@ -33,7 +33,7 @@ lzma_lzma_optimum_fast(lzma_coder *restrict coder, lzma_mf *restrict mf, } const uint8_t *buf = mf_ptr(mf) - 1; - const uint32_t buf_avail = MIN(mf_avail(mf) + 1, MATCH_LEN_MAX); + const uint32_t buf_avail = my_min(mf_avail(mf) + 1, MATCH_LEN_MAX); if (buf_avail < 2) { // There's not enough input left to encode a match. diff --git a/contrib/xz/src/liblzma/lzma/lzma_encoder_optimum_normal.c b/contrib/xz/src/liblzma/lzma/lzma_encoder_optimum_normal.c index 9284c8a..7e85649 100644 --- a/contrib/xz/src/liblzma/lzma/lzma_encoder_optimum_normal.c +++ b/contrib/xz/src/liblzma/lzma/lzma_encoder_optimum_normal.c @@ -287,7 +287,7 @@ helper1(lzma_coder *restrict coder, lzma_mf *restrict mf, matches_count = coder->matches_count; } - const uint32_t buf_avail = MIN(mf_avail(mf) + 1, MATCH_LEN_MAX); + const uint32_t buf_avail = my_min(mf_avail(mf) + 1, MATCH_LEN_MAX); if (buf_avail < 2) { *back_res = UINT32_MAX; *len_res = 1; @@ -371,7 +371,7 @@ helper1(lzma_coder *restrict coder, lzma_mf *restrict mf, } } - const uint32_t len_end = MAX(len_main, rep_lens[rep_max_index]); + const uint32_t len_end = my_max(len_main, rep_lens[rep_max_index]); if (len_end < 2) { *back_res = coder->opts[1].back_prev; @@ -565,12 +565,12 @@ helper2(lzma_coder *coder, uint32_t *reps, const uint8_t *buf, if (buf_avail_full < 2) return len_end; - const uint32_t buf_avail = MIN(buf_avail_full, nice_len); + const uint32_t buf_avail = my_min(buf_avail_full, nice_len); if (!next_is_literal && match_byte != current_byte) { // speed optimization // try literal + rep0 const uint8_t *const buf_back = buf - reps[0] - 1; - const uint32_t limit = MIN(buf_avail_full, nice_len + 1); + const uint32_t limit = my_min(buf_avail_full, nice_len + 1); uint32_t len_test = 1; while (len_test < limit && buf[len_test] == buf_back[len_test]) @@ -648,7 +648,7 @@ helper2(lzma_coder *coder, uint32_t *reps, const uint8_t *buf, uint32_t len_test_2 = len_test + 1; - const uint32_t limit = MIN(buf_avail_full, + const uint32_t limit = my_min(buf_avail_full, len_test_2 + nice_len); for (; len_test_2 < limit && buf[len_test_2] == buf_back[len_test_2]; @@ -743,7 +743,7 @@ helper2(lzma_coder *coder, uint32_t *reps, const uint8_t *buf, // Try Match + Literal + Rep0 const uint8_t *const buf_back = buf - cur_back - 1; uint32_t len_test_2 = len_test + 1; - const uint32_t limit = MIN(buf_avail_full, + const uint32_t limit = my_min(buf_avail_full, len_test_2 + nice_len); for (; len_test_2 < limit && @@ -860,7 +860,7 @@ lzma_lzma_optimum_normal(lzma_coder *restrict coder, lzma_mf *restrict mf, len_end = helper2(coder, reps, mf_ptr(mf) - 1, len_end, position + cur, cur, mf->nice_len, - MIN(mf_avail(mf) + 1, OPTS - 1 - cur)); + my_min(mf_avail(mf) + 1, OPTS - 1 - cur)); } backward(coder, len_res, back_res, cur); diff --git a/contrib/xz/src/liblzma/lzma/lzma_encoder_presets.c b/contrib/xz/src/liblzma/lzma/lzma_encoder_presets.c index c4c9c14..21e427a 100644 --- a/contrib/xz/src/liblzma/lzma/lzma_encoder_presets.c +++ b/contrib/xz/src/liblzma/lzma/lzma_encoder_presets.c @@ -23,9 +23,6 @@ lzma_lzma_preset(lzma_options_lzma *options, uint32_t preset) if (level > 9 || (flags & ~supported_flags)) return true; - const uint32_t dict_shift = level <= 1 ? 16 : level + 17; - options->dict_size = UINT32_C(1) << dict_shift; - options->preset_dict = NULL; options->preset_dict_size = 0; @@ -33,19 +30,31 @@ lzma_lzma_preset(lzma_options_lzma *options, uint32_t preset) options->lp = LZMA_LP_DEFAULT; options->pb = LZMA_PB_DEFAULT; - options->mode = level <= 2 ? LZMA_MODE_FAST : LZMA_MODE_NORMAL; + options->dict_size = UINT32_C(1) << (uint8_t []){ + 18, 20, 21, 22, 22, 23, 23, 24, 25, 26 }[level]; - options->nice_len = level == 0 ? 8 : level <= 5 ? 32 : 64; - options->mf = level <= 1 ? LZMA_MF_HC3 : level <= 2 ? LZMA_MF_HC4 - : LZMA_MF_BT4; - options->depth = 0; + if (level <= 3) { + options->mode = LZMA_MODE_FAST; + options->mf = level == 0 ? LZMA_MF_HC3 : LZMA_MF_HC4; + options->nice_len = level <= 1 ? 128 : 273; + options->depth = (uint8_t []){ 4, 8, 24, 48 }[level]; + } else { + options->mode = LZMA_MODE_NORMAL; + options->mf = LZMA_MF_BT4; + options->nice_len = level == 4 ? 16 : level == 5 ? 32 : 64; + options->depth = 0; + } if (flags & LZMA_PRESET_EXTREME) { - options->lc = 4; // FIXME? options->mode = LZMA_MODE_NORMAL; options->mf = LZMA_MF_BT4; - options->nice_len = 273; - options->depth = 512; + if (level == 3 || level == 5) { + options->nice_len = 192; + options->depth = 0; + } else { + options->nice_len = 273; + options->depth = 512; + } } return false; diff --git a/contrib/xz/src/liblzma/subblock/subblock_decoder.c b/contrib/xz/src/liblzma/subblock/subblock_decoder.c deleted file mode 100644 index e055cee..0000000 --- a/contrib/xz/src/liblzma/subblock/subblock_decoder.c +++ /dev/null @@ -1,630 +0,0 @@ -/////////////////////////////////////////////////////////////////////////////// -// -/// \file subblock_decoder.c -/// \brief Decoder of the Subblock filter -// -// Author: Lasse Collin -// -// This file has been put into the public domain. -// You can do whatever you want with this file. -// -/////////////////////////////////////////////////////////////////////////////// - -#include "subblock_decoder.h" -#include "subblock_decoder_helper.h" -#include "filter_decoder.h" - - -/// Maximum number of consecutive Subblocks with Subblock Type Padding -#define PADDING_MAX 31 - - -struct lzma_coder_s { - lzma_next_coder next; - - enum { - // These require that there is at least one input - // byte available. - SEQ_FLAGS, - SEQ_FILTER_FLAGS, - SEQ_FILTER_END, - SEQ_REPEAT_COUNT_1, - SEQ_REPEAT_COUNT_2, - SEQ_REPEAT_COUNT_3, - SEQ_REPEAT_SIZE, - SEQ_REPEAT_READ_DATA, - SEQ_SIZE_1, - SEQ_SIZE_2, - SEQ_SIZE_3, // This must be right before SEQ_DATA. - - // These don't require any input to be available. - SEQ_DATA, - SEQ_REPEAT_FAST, - SEQ_REPEAT_NORMAL, - } sequence; - - /// Number of bytes left in the current Subblock Data field. - size_t size; - - /// Number of consecutive Subblocks with Subblock Type Padding - uint32_t padding; - - /// True when .next.code() has returned LZMA_STREAM_END. - bool next_finished; - - /// True when the Subblock decoder has detected End of Payload Marker. - /// This may become true before next_finished becomes true. - bool this_finished; - - /// True if Subfilters are allowed. - bool allow_subfilters; - - /// Indicates if at least one byte of decoded output has been - /// produced after enabling Subfilter. - bool got_output_with_subfilter; - - /// Possible subfilter - lzma_next_coder subfilter; - - /// Filter Flags decoder is needed to parse the ID and Properties - /// of the subfilter. - lzma_next_coder filter_flags_decoder; - - /// The filter_flags_decoder stores its results here. - lzma_filter filter_flags; - - /// Options for the Subblock decoder helper. This is used to tell - /// the helper when it should return LZMA_STREAM_END to the subfilter. - lzma_options_subblock_helper helper; - - struct { - /// How many times buffer should be repeated - size_t count; - - /// Size of the buffer - size_t size; - - /// Position in the buffer - size_t pos; - - /// Buffer to hold the data to be repeated - uint8_t buffer[LZMA_SUBBLOCK_RLE_MAX]; - } repeat; - - /// Temporary buffer needed when the Subblock filter is not the last - /// filter in the chain. The output of the next filter is first - /// decoded into buffer[], which is then used as input for the actual - /// Subblock decoder. - struct { - size_t pos; - size_t size; - uint8_t buffer[LZMA_BUFFER_SIZE]; - } temp; -}; - - -/// Values of valid Subblock Flags -enum { - FLAG_PADDING, - FLAG_EOPM, - FLAG_DATA, - FLAG_REPEAT, - FLAG_SET_SUBFILTER, - FLAG_END_SUBFILTER, -}; - - -/// Calls the subfilter and updates coder->uncompressed_size. -static lzma_ret -subfilter_decode(lzma_coder *coder, lzma_allocator *allocator, - const uint8_t *in, size_t *in_pos, - size_t in_size, uint8_t *restrict out, - size_t *restrict out_pos, size_t out_size, lzma_action action) -{ - assert(coder->subfilter.code != NULL); - - // Call the subfilter. - const lzma_ret ret = coder->subfilter.code( - coder->subfilter.coder, allocator, - in, in_pos, in_size, out, out_pos, out_size, action); - - return ret; -} - - -static lzma_ret -decode_buffer(lzma_coder *coder, lzma_allocator *allocator, - const uint8_t *in, size_t *in_pos, - size_t in_size, uint8_t *restrict out, - size_t *restrict out_pos, size_t out_size, lzma_action action) -{ - while (*out_pos < out_size && (*in_pos < in_size - || coder->sequence >= SEQ_DATA)) - switch (coder->sequence) { - case SEQ_FLAGS: { - // Do the correct action depending on the Subblock Type. - switch (in[*in_pos] >> 4) { - case FLAG_PADDING: - // Only check that reserved bits are zero. - if (++coder->padding > PADDING_MAX - || in[*in_pos] & 0x0F) - return LZMA_DATA_ERROR; - ++*in_pos; - break; - - case FLAG_EOPM: - // There must be no Padding before EOPM. - if (coder->padding != 0) - return LZMA_DATA_ERROR; - - // Check that reserved bits are zero. - if (in[*in_pos] & 0x0F) - return LZMA_DATA_ERROR; - - // There must be no Subfilter enabled. - if (coder->subfilter.code != NULL) - return LZMA_DATA_ERROR; - - ++*in_pos; - return LZMA_STREAM_END; - - case FLAG_DATA: - // First four bits of the Subblock Data size. - coder->size = in[*in_pos] & 0x0F; - ++*in_pos; - coder->got_output_with_subfilter = true; - coder->sequence = SEQ_SIZE_1; - break; - - case FLAG_REPEAT: - // First four bits of the Repeat Count. We use - // coder->size as a temporary place for it. - coder->size = in[*in_pos] & 0x0F; - ++*in_pos; - coder->got_output_with_subfilter = true; - coder->sequence = SEQ_REPEAT_COUNT_1; - break; - - case FLAG_SET_SUBFILTER: { - if (coder->padding != 0 || (in[*in_pos] & 0x0F) - || coder->subfilter.code != NULL - || !coder->allow_subfilters) - return LZMA_DATA_ERROR; - - assert(coder->filter_flags.options == NULL); - abort(); -// return_if_error(lzma_filter_flags_decoder_init( -// &coder->filter_flags_decoder, -// allocator, &coder->filter_flags)); - - coder->got_output_with_subfilter = false; - - ++*in_pos; - coder->sequence = SEQ_FILTER_FLAGS; - break; - } - - case FLAG_END_SUBFILTER: { - if (coder->padding != 0 || (in[*in_pos] & 0x0F) - || coder->subfilter.code == NULL - || !coder->got_output_with_subfilter) - return LZMA_DATA_ERROR; - - // Tell the helper filter to indicate End of Input - // to our subfilter. - coder->helper.end_was_reached = true; - - size_t dummy = 0; - const lzma_ret ret = subfilter_decode(coder, allocator, - NULL, &dummy, 0, out, out_pos,out_size, - action); - - // If we didn't reach the end of the subfilter's output - // yet, return to the application. On the next call we - // will get to this same switch-case again, because we - // haven't updated *in_pos yet. - if (ret != LZMA_STREAM_END) - return ret; - - // Free Subfilter's memory. This is a bit debatable, - // since we could avoid some malloc()/free() calls - // if the same Subfilter gets used soon again. But - // if Subfilter isn't used again, we could leave - // a memory-hogging filter dangling until someone - // frees Subblock filter itself. - lzma_next_end(&coder->subfilter, allocator); - - // Free memory used for subfilter options. This is - // safe, because we don't support any Subfilter that - // would allow pointers in the options structure. - lzma_free(coder->filter_flags.options, allocator); - coder->filter_flags.options = NULL; - - ++*in_pos; - - break; - } - - default: - return LZMA_DATA_ERROR; - } - - break; - } - - case SEQ_FILTER_FLAGS: { - const lzma_ret ret = coder->filter_flags_decoder.code( - coder->filter_flags_decoder.coder, allocator, - in, in_pos, in_size, NULL, NULL, 0, LZMA_RUN); - if (ret != LZMA_STREAM_END) - return ret == LZMA_OPTIONS_ERROR - ? LZMA_DATA_ERROR : ret; - - // Don't free the filter_flags_decoder. It doesn't take much - // memory and we may need it again. - - // Initialize the Subfilter. Subblock and Copy filters are - // not allowed. - if (coder->filter_flags.id == LZMA_FILTER_SUBBLOCK) - return LZMA_DATA_ERROR; - - coder->helper.end_was_reached = false; - - lzma_filter filters[3] = { - { - .id = coder->filter_flags.id, - .options = coder->filter_flags.options, - }, { - .id = LZMA_FILTER_SUBBLOCK_HELPER, - .options = &coder->helper, - }, { - .id = LZMA_VLI_UNKNOWN, - .options = NULL, - } - }; - - // Optimization: We know that LZMA uses End of Payload Marker - // (not End of Input), so we can omit the helper filter. - if (filters[0].id == LZMA_FILTER_LZMA1) - filters[1].id = LZMA_VLI_UNKNOWN; - - return_if_error(lzma_raw_decoder_init( - &coder->subfilter, allocator, filters)); - - coder->sequence = SEQ_FLAGS; - break; - } - - case SEQ_FILTER_END: - // We are in the beginning of a Subblock. The next Subblock - // whose type is not Padding, must indicate end of Subfilter. - if (in[*in_pos] == (FLAG_PADDING << 4)) { - ++*in_pos; - break; - } - - if (in[*in_pos] != (FLAG_END_SUBFILTER << 4)) - return LZMA_DATA_ERROR; - - coder->sequence = SEQ_FLAGS; - break; - - case SEQ_REPEAT_COUNT_1: - case SEQ_SIZE_1: - // We use the same code to parse - // - the Size (28 bits) in Subblocks of type Data; and - // - the Repeat count (28 bits) in Subblocks of type - // Repeating Data. - coder->size |= (size_t)(in[*in_pos]) << 4; - ++*in_pos; - ++coder->sequence; - break; - - case SEQ_REPEAT_COUNT_2: - case SEQ_SIZE_2: - coder->size |= (size_t)(in[*in_pos]) << 12; - ++*in_pos; - ++coder->sequence; - break; - - case SEQ_REPEAT_COUNT_3: - case SEQ_SIZE_3: - coder->size |= (size_t)(in[*in_pos]) << 20; - ++*in_pos; - - // The real value is the stored value plus one. - ++coder->size; - - // This moves to SEQ_REPEAT_SIZE or SEQ_DATA. That's why - // SEQ_DATA must be right after SEQ_SIZE_3 in coder->sequence. - ++coder->sequence; - break; - - case SEQ_REPEAT_SIZE: - // Move the Repeat Count to the correct variable and parse - // the Size of the Data to be repeated. - coder->repeat.count = coder->size; - coder->repeat.size = (size_t)(in[*in_pos]) + 1; - coder->repeat.pos = 0; - - // The size of the Data field must be bigger than the number - // of Padding bytes before this Subblock. - if (coder->repeat.size <= coder->padding) - return LZMA_DATA_ERROR; - - ++*in_pos; - coder->padding = 0; - coder->sequence = SEQ_REPEAT_READ_DATA; - break; - - case SEQ_REPEAT_READ_DATA: { - // Fill coder->repeat.buffer[]. - const size_t in_avail = in_size - *in_pos; - const size_t out_avail - = coder->repeat.size - coder->repeat.pos; - const size_t copy_size = MIN(in_avail, out_avail); - - memcpy(coder->repeat.buffer + coder->repeat.pos, - in + *in_pos, copy_size); - *in_pos += copy_size; - coder->repeat.pos += copy_size; - - if (coder->repeat.pos == coder->repeat.size) { - coder->repeat.pos = 0; - - if (coder->repeat.size == 1 - && coder->subfilter.code == NULL) - coder->sequence = SEQ_REPEAT_FAST; - else - coder->sequence = SEQ_REPEAT_NORMAL; - } - - break; - } - - case SEQ_DATA: { - // The size of the Data field must be bigger than the number - // of Padding bytes before this Subblock. - assert(coder->size > 0); - if (coder->size <= coder->padding) - return LZMA_DATA_ERROR; - - coder->padding = 0; - - // Limit the amount of input to match the available - // Subblock Data size. - size_t in_limit; - if (in_size - *in_pos > coder->size) - in_limit = *in_pos + coder->size; - else - in_limit = in_size; - - if (coder->subfilter.code == NULL) { - const size_t copy_size = lzma_bufcpy( - in, in_pos, in_limit, - out, out_pos, out_size); - - coder->size -= copy_size; - } else { - const size_t in_start = *in_pos; - const lzma_ret ret = subfilter_decode( - coder, allocator, - in, in_pos, in_limit, - out, out_pos, out_size, - action); - - // Update the number of unprocessed bytes left in - // this Subblock. This assert() is true because - // in_limit prevents *in_pos getting too big. - assert(*in_pos - in_start <= coder->size); - coder->size -= *in_pos - in_start; - - if (ret == LZMA_STREAM_END) { - // End of Subfilter can occur only at - // a Subblock boundary. - if (coder->size != 0) - return LZMA_DATA_ERROR; - - // We need a Subblock with Unset - // Subfilter before more data. - coder->sequence = SEQ_FILTER_END; - break; - } - - if (ret != LZMA_OK) - return ret; - } - - // If we couldn't process the whole Subblock Data yet, return. - if (coder->size > 0) - return LZMA_OK; - - coder->sequence = SEQ_FLAGS; - break; - } - - case SEQ_REPEAT_FAST: { - // Optimization for cases when there is only one byte to - // repeat and no Subfilter. - const size_t out_avail = out_size - *out_pos; - const size_t copy_size = MIN(coder->repeat.count, out_avail); - - memset(out + *out_pos, coder->repeat.buffer[0], copy_size); - - *out_pos += copy_size; - coder->repeat.count -= copy_size; - - if (coder->repeat.count != 0) - return LZMA_OK; - - coder->sequence = SEQ_FLAGS; - break; - } - - case SEQ_REPEAT_NORMAL: - do { - // Cycle the repeat buffer if needed. - if (coder->repeat.pos == coder->repeat.size) { - if (--coder->repeat.count == 0) { - coder->sequence = SEQ_FLAGS; - break; - } - - coder->repeat.pos = 0; - } - - if (coder->subfilter.code == NULL) { - lzma_bufcpy(coder->repeat.buffer, - &coder->repeat.pos, - coder->repeat.size, - out, out_pos, out_size); - } else { - const lzma_ret ret = subfilter_decode( - coder, allocator, - coder->repeat.buffer, - &coder->repeat.pos, - coder->repeat.size, - out, out_pos, out_size, - action); - - if (ret == LZMA_STREAM_END) { - // End of Subfilter can occur only at - // a Subblock boundary. - if (coder->repeat.pos - != coder->repeat.size - || --coder->repeat - .count != 0) - return LZMA_DATA_ERROR; - - // We need a Subblock with Unset - // Subfilter before more data. - coder->sequence = SEQ_FILTER_END; - break; - - } else if (ret != LZMA_OK) { - return ret; - } - } - } while (*out_pos < out_size); - - break; - - default: - return LZMA_PROG_ERROR; - } - - return LZMA_OK; -} - - -static lzma_ret -subblock_decode(lzma_coder *coder, 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) -{ - if (coder->next.code == NULL) - return decode_buffer(coder, allocator, in, in_pos, in_size, - out, out_pos, out_size, action); - - while (*out_pos < out_size) { - 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 (coder->temp.size == 0 || ret != LZMA_OK) - return ret; - } - - if (coder->this_finished) { - if (coder->temp.pos != coder->temp.size) - return LZMA_DATA_ERROR; - - if (coder->next_finished) - return LZMA_STREAM_END; - - return LZMA_OK; - } - - const lzma_ret ret = decode_buffer(coder, allocator, - coder->temp.buffer, &coder->temp.pos, - coder->temp.size, - out, out_pos, out_size, action); - - if (ret == LZMA_STREAM_END) - // The next coder in the chain hasn't finished - // yet. If the input data is valid, there - // must be no more output coming, but the - // next coder may still need a litle more - // input to detect End of Payload Marker. - 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; -} - - -static void -subblock_decoder_end(lzma_coder *coder, lzma_allocator *allocator) -{ - lzma_next_end(&coder->next, allocator); - lzma_next_end(&coder->subfilter, allocator); - lzma_next_end(&coder->filter_flags_decoder, allocator); - lzma_free(coder->filter_flags.options, allocator); - lzma_free(coder, allocator); - return; -} - - -extern lzma_ret -lzma_subblock_decoder_init(lzma_next_coder *next, lzma_allocator *allocator, - const lzma_filter_info *filters) -{ - if (next->coder == NULL) { - next->coder = lzma_alloc(sizeof(lzma_coder), allocator); - if (next->coder == NULL) - return LZMA_MEM_ERROR; - - next->code = &subblock_decode; - next->end = &subblock_decoder_end; - - next->coder->next = LZMA_NEXT_CODER_INIT; - next->coder->subfilter = LZMA_NEXT_CODER_INIT; - next->coder->filter_flags_decoder = LZMA_NEXT_CODER_INIT; - - } else { - lzma_next_end(&next->coder->subfilter, allocator); - lzma_free(next->coder->filter_flags.options, allocator); - } - - next->coder->filter_flags.options = NULL; - - next->coder->sequence = SEQ_FLAGS; - next->coder->padding = 0; - next->coder->next_finished = false; - next->coder->this_finished = false; - next->coder->temp.pos = 0; - next->coder->temp.size = 0; - - if (filters[0].options != NULL) - next->coder->allow_subfilters = ((lzma_options_subblock *)( - filters[0].options))->allow_subfilters; - else - next->coder->allow_subfilters = false; - - return lzma_next_filter_init( - &next->coder->next, allocator, filters + 1); -} diff --git a/contrib/xz/src/liblzma/subblock/subblock_decoder.h b/contrib/xz/src/liblzma/subblock/subblock_decoder.h deleted file mode 100644 index d1030b2..0000000 --- a/contrib/xz/src/liblzma/subblock/subblock_decoder.h +++ /dev/null @@ -1,22 +0,0 @@ -/////////////////////////////////////////////////////////////////////////////// -// -/// \file subblock_decoder.h -/// \brief Decoder of the Subblock filter -// -// Author: Lasse Collin -// -// This file has been put into the public domain. -// You can do whatever you want with this file. -// -/////////////////////////////////////////////////////////////////////////////// - -#ifndef LZMA_SUBBLOCK_DECODER_H -#define LZMA_SUBBLOCK_DECODER_H - -#include "common.h" - - -extern lzma_ret lzma_subblock_decoder_init(lzma_next_coder *next, - lzma_allocator *allocator, const lzma_filter_info *filters); - -#endif diff --git a/contrib/xz/src/liblzma/subblock/subblock_decoder_helper.c b/contrib/xz/src/liblzma/subblock/subblock_decoder_helper.c deleted file mode 100644 index 2a864ed..0000000 --- a/contrib/xz/src/liblzma/subblock/subblock_decoder_helper.c +++ /dev/null @@ -1,70 +0,0 @@ -/////////////////////////////////////////////////////////////////////////////// -// -/// \file subblock_decoder_helper.c -/// \brief Helper filter for the Subblock decoder -/// -/// This filter is used to indicate End of Input for subfilters needing it. -// -// Author: Lasse Collin -// -// This file has been put into the public domain. -// You can do whatever you want with this file. -// -/////////////////////////////////////////////////////////////////////////////// - -#include "subblock_decoder_helper.h" - - -struct lzma_coder_s { - const lzma_options_subblock_helper *options; -}; - - -static lzma_ret -helper_decode(lzma_coder *coder, - lzma_allocator *allocator lzma_attribute((unused)), - 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 lzma_attribute((unused))) -{ - // If end_was_reached is true, we cannot have any input. - assert(!coder->options->end_was_reached || *in_pos == in_size); - - // We can safely copy as much as possible, because we are never - // given more data than a single Subblock Data field. - lzma_bufcpy(in, in_pos, in_size, out, out_pos, out_size); - - // Return LZMA_STREAM_END when instructed so by the Subblock decoder. - return coder->options->end_was_reached ? LZMA_STREAM_END : LZMA_OK; -} - - -static void -helper_end(lzma_coder *coder, lzma_allocator *allocator) -{ - lzma_free(coder, allocator); - return; -} - - -extern lzma_ret -lzma_subblock_decoder_helper_init(lzma_next_coder *next, - lzma_allocator *allocator, const lzma_filter_info *filters) -{ - // This is always the last filter in the chain. - assert(filters[1].init == NULL); - - if (next->coder == NULL) { - next->coder = lzma_alloc(sizeof(lzma_coder), allocator); - if (next->coder == NULL) - return LZMA_MEM_ERROR; - - next->code = &helper_decode; - next->end = &helper_end; - } - - next->coder->options = filters[0].options; - - return LZMA_OK; -} diff --git a/contrib/xz/src/liblzma/subblock/subblock_decoder_helper.h b/contrib/xz/src/liblzma/subblock/subblock_decoder_helper.h deleted file mode 100644 index 18dcbb3..0000000 --- a/contrib/xz/src/liblzma/subblock/subblock_decoder_helper.h +++ /dev/null @@ -1,29 +0,0 @@ -/////////////////////////////////////////////////////////////////////////////// -// -/// \file subblock_decoder_helper.h -/// \brief Helper filter for the Subblock decoder -/// -/// This filter is used to indicate End of Input for subfilters needing it. -// -// Author: Lasse Collin -// -// This file has been put into the public domain. -// You can do whatever you want with this file. -// -/////////////////////////////////////////////////////////////////////////////// - -#ifndef LZMA_SUBBLOCK_DECODER_HELPER_H -#define LZMA_SUBBLOCK_DECODER_HELPER_H - -#include "common.h" - - -typedef struct { - bool end_was_reached; -} lzma_options_subblock_helper; - - -extern lzma_ret lzma_subblock_decoder_helper_init(lzma_next_coder *next, - lzma_allocator *allocator, const lzma_filter_info *filters); - -#endif diff --git a/contrib/xz/src/liblzma/subblock/subblock_encoder.c b/contrib/xz/src/liblzma/subblock/subblock_encoder.c deleted file mode 100644 index 4f71f99..0000000 --- a/contrib/xz/src/liblzma/subblock/subblock_encoder.c +++ /dev/null @@ -1,984 +0,0 @@ -/////////////////////////////////////////////////////////////////////////////// -// -/// \file subblock_encoder.c -/// \brief Encoder of the Subblock filter -// -// Author: Lasse Collin -// -// This file has been put into the public domain. -// You can do whatever you want with this file. -// -/////////////////////////////////////////////////////////////////////////////// - -#include "subblock_encoder.h" -#include "filter_encoder.h" - - -/// Maximum number of repeats that a single Repeating Data can indicate. -/// This is directly from the file format specification. -#define REPEAT_COUNT_MAX (1U << 28) - -/// Number of bytes the data chunk (not including the header part) must be -/// before we care about alignment. This is somewhat arbitrary. It just -/// doesn't make sense to waste bytes for alignment when the data chunk -/// is very small. -#define MIN_CHUNK_SIZE_FOR_ALIGN 4 - -/// Number of bytes of the header part of Subblock Type `Data'. This is -/// used as the `skew' argument for subblock_align(). -#define ALIGN_SKEW_DATA 4 - -/// Like above but for Repeating Data. -#define ALIGN_SKEW_REPEATING_DATA 5 - -/// Writes one byte to output buffer and updates the alignment counter. -#define write_byte(b) \ -do { \ - assert(*out_pos < out_size); \ - out[*out_pos] = b; \ - ++*out_pos; \ - ++coder->alignment.out_pos; \ -} while (0) - - -struct lzma_coder_s { - lzma_next_coder next; - bool next_finished; - - enum { - SEQ_FILL, - SEQ_FLUSH, - SEQ_RLE_COUNT_0, - SEQ_RLE_COUNT_1, - SEQ_RLE_COUNT_2, - SEQ_RLE_COUNT_3, - SEQ_RLE_SIZE, - SEQ_RLE_DATA, - SEQ_DATA_SIZE_0, - SEQ_DATA_SIZE_1, - SEQ_DATA_SIZE_2, - SEQ_DATA_SIZE_3, - SEQ_DATA, - SEQ_SUBFILTER_INIT, - SEQ_SUBFILTER_FLAGS, - } sequence; - - /// Pointer to the options given by the application. This is used - /// for two-way communication with the application. - lzma_options_subblock *options; - - /// Position in various arrays. - size_t pos; - - /// Holds subblock.size - 1 or rle.size - 1 when encoding size - /// of Data or Repeat Count. - uint32_t tmp; - - struct { - /// This is a copy of options->alignment, or - /// LZMA_SUBBLOCK_ALIGNMENT_DEFAULT if options is NULL. - uint32_t multiple; - - /// Number of input bytes which we have processed and started - /// writing out. 32-bit integer is enough since we care only - /// about the lowest bits when fixing alignment. - uint32_t in_pos; - - /// Number of bytes written out. - uint32_t out_pos; - } alignment; - - struct { - /// Pointer to allocated buffer holding the Data field - /// of Subblock Type "Data". - uint8_t *data; - - /// Number of bytes in the buffer. - size_t size; - - /// Allocated size of the buffer. - size_t limit; - - /// Number of input bytes that we have already read but - /// not yet started writing out. This can be different - /// to `size' when using Subfilter. That's why we track - /// in_pending separately for RLE (see below). - uint32_t in_pending; - } subblock; - - struct { - /// Buffer to hold the data that may be coded with - /// Subblock Type `Repeating Data'. - uint8_t buffer[LZMA_SUBBLOCK_RLE_MAX]; - - /// Number of bytes in buffer[]. - size_t size; - - /// Number of times the first `size' bytes of buffer[] - /// will be repeated. - uint64_t count; - - /// Like subblock.in_pending above, but for RLE. - uint32_t in_pending; - } rle; - - struct { - enum { - SUB_NONE, - SUB_SET, - SUB_RUN, - SUB_FLUSH, - SUB_FINISH, - SUB_END_MARKER, - } mode; - - /// This is a copy of options->allow_subfilters. We use - /// this to verify that the application doesn't change - /// the value of allow_subfilters. - bool allow; - - /// When this is true, application is not allowed to modify - /// options->subblock_mode. We may still modify it here. - bool mode_locked; - - /// True if we have encoded at least one byte of data with - /// the Subfilter. - bool got_input; - - /// Track the amount of input available once - /// LZMA_SUBFILTER_FINISH has been enabled. - /// This is needed for sanity checking (kind - /// of duplicating what common/code.c does). - size_t in_avail; - - /// Buffer for the Filter Flags field written after - /// the `Set Subfilter' indicator. - uint8_t *flags; - - /// Size of Filter Flags field. - uint32_t flags_size; - - /// Pointers to Subfilter. - lzma_next_coder subcoder; - - } subfilter; - - /// Temporary buffer used when we are not the last filter in the chain. - struct { - size_t pos; - size_t size; - uint8_t buffer[LZMA_BUFFER_SIZE]; - } temp; -}; - - -/// \brief Aligns the output buffer -/// -/// Aligns the output buffer so that after skew bytes the output position is -/// a multiple of coder->alignment.multiple. -static bool -subblock_align(lzma_coder *coder, uint8_t *restrict out, - size_t *restrict out_pos, size_t out_size, - size_t chunk_size, uint32_t skew) -{ - assert(*out_pos < out_size); - - // Fix the alignment only if it makes sense at least a little. - if (chunk_size >= MIN_CHUNK_SIZE_FOR_ALIGN) { - const uint32_t target = coder->alignment.in_pos - % coder->alignment.multiple; - - while ((coder->alignment.out_pos + skew) - % coder->alignment.multiple != target) { - // Zero indicates padding. - write_byte(0x00); - - // Check if output buffer got full and indicate it to - // the caller. - if (*out_pos == out_size) - return true; - } - } - - // Output buffer is not full. - return false; -} - - -/// \brief Checks if buffer contains repeated data -/// -/// \param needle Buffer containing a single repeat chunk -/// \param needle_size Size of needle in bytes -/// \param buf Buffer to search for repeated needles -/// \param buf_chunks Buffer size is buf_chunks * needle_size. -/// -/// \return True if the whole buf is filled with repeated needles. -/// -static bool -is_repeating(const uint8_t *restrict needle, size_t needle_size, - const uint8_t *restrict buf, size_t buf_chunks) -{ - while (buf_chunks-- != 0) { - if (memcmp(buf, needle, needle_size) != 0) - return false; - - buf += needle_size; - } - - return true; -} - - -/// \brief Optimizes the repeating style and updates coder->sequence -static void -subblock_rle_flush(lzma_coder *coder) -{ - // The Subblock decoder can use memset() when the size of the data - // being repeated is one byte, so we check if the RLE buffer is - // filled with a single repeating byte. - if (coder->rle.size > 1) { - const uint8_t b = coder->rle.buffer[0]; - size_t i = 0; - while (true) { - if (coder->rle.buffer[i] != b) - break; - - if (++i == coder->rle.size) { - // TODO Integer overflow check maybe, - // although this needs at least 2**63 bytes - // of input until it gets triggered... - coder->rle.count *= coder->rle.size; - coder->rle.size = 1; - break; - } - } - } - - if (coder->rle.count == 1) { - // The buffer should be repeated only once. It is - // waste of space to use Repeating Data. Instead, - // write a regular Data Subblock. See SEQ_RLE_COUNT_0 - // in subblock_buffer() for more info. - coder->tmp = coder->rle.size - 1; - } else if (coder->rle.count > REPEAT_COUNT_MAX) { - // There's so much to repeat that it doesn't fit into - // 28-bit integer. We will write two or more Subblocks - // of type Repeating Data. - coder->tmp = REPEAT_COUNT_MAX - 1; - } else { - coder->tmp = coder->rle.count - 1; - } - - coder->sequence = SEQ_RLE_COUNT_0; - - return; -} - - -/// \brief Resizes coder->subblock.data for a new size limit -static lzma_ret -subblock_data_size(lzma_coder *coder, lzma_allocator *allocator, - size_t new_limit) -{ - // Verify that the new limit is valid. - if (new_limit < LZMA_SUBBLOCK_DATA_SIZE_MIN - || new_limit > LZMA_SUBBLOCK_DATA_SIZE_MAX) - return LZMA_OPTIONS_ERROR; - - // Ff the new limit is different than the previous one, we need - // to reallocate the data buffer. - if (new_limit != coder->subblock.limit) { - lzma_free(coder->subblock.data, allocator); - coder->subblock.data = lzma_alloc(new_limit, allocator); - if (coder->subblock.data == NULL) - return LZMA_MEM_ERROR; - } - - coder->subblock.limit = new_limit; - - return LZMA_OK; -} - - -static lzma_ret -subblock_buffer(lzma_coder *coder, 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) -{ - // Changing allow_subfilter is not allowed. - if (coder->options != NULL && coder->subfilter.allow - != coder->options->allow_subfilters) - return LZMA_PROG_ERROR; - - // Check if we need to do something special with the Subfilter. - if (coder->subfilter.allow) { - assert(coder->options != NULL); - - // See if subfilter_mode has been changed. - switch (coder->options->subfilter_mode) { - case LZMA_SUBFILTER_NONE: - if (coder->subfilter.mode != SUB_NONE) - return LZMA_PROG_ERROR; - break; - - case LZMA_SUBFILTER_SET: - if (coder->subfilter.mode_locked - || coder->subfilter.mode != SUB_NONE) - return LZMA_PROG_ERROR; - - coder->subfilter.mode = SUB_SET; - coder->subfilter.got_input = false; - - if (coder->sequence == SEQ_FILL) - coder->sequence = SEQ_FLUSH; - - break; - - case LZMA_SUBFILTER_RUN: - if (coder->subfilter.mode != SUB_RUN) - return LZMA_PROG_ERROR; - - break; - - case LZMA_SUBFILTER_FINISH: { - const size_t in_avail = in_size - *in_pos; - - if (coder->subfilter.mode == SUB_RUN) { - if (coder->subfilter.mode_locked) - return LZMA_PROG_ERROR; - - coder->subfilter.mode = SUB_FINISH; - coder->subfilter.in_avail = in_avail; - - } else if (coder->subfilter.mode != SUB_FINISH - || coder->subfilter.in_avail - != in_avail) { - return LZMA_PROG_ERROR; - } - - break; - } - - default: - return LZMA_OPTIONS_ERROR; - } - - // If we are sync-flushing or finishing, the application may - // no longer change subfilter_mode. Note that this check is - // done after checking the new subfilter_mode above; this - // way the application may e.g. set LZMA_SUBFILTER_SET and - // LZMA_SYNC_FLUSH at the same time, but it cannot modify - // subfilter_mode on the later lzma_code() calls before - // we have returned LZMA_STREAM_END. - if (action != LZMA_RUN) - coder->subfilter.mode_locked = true; - } - - // Main loop - while (*out_pos < out_size) - switch (coder->sequence) { - case SEQ_FILL: - // Grab the new Subblock Data Size and reallocate the buffer. - if (coder->subblock.size == 0 && coder->options != NULL - && coder->options->subblock_data_size - != coder->subblock.limit) - return_if_error(subblock_data_size(coder, - allocator, coder->options - ->subblock_data_size)); - - if (coder->subfilter.mode == SUB_NONE) { - assert(coder->subfilter.subcoder.code == NULL); - - // No Subfilter is enabled, just copy the data as is. - coder->subblock.in_pending += lzma_bufcpy( - in, in_pos, in_size, - coder->subblock.data, - &coder->subblock.size, - coder->subblock.limit); - - // If we ran out of input before the whole buffer - // was filled, return to application. - if (coder->subblock.size < coder->subblock.limit - && action == LZMA_RUN) - return LZMA_OK; - - } else { - assert(coder->options->subfilter_mode - != LZMA_SUBFILTER_SET); - - // Using LZMA_FINISH automatically toggles - // LZMA_SUBFILTER_FINISH. - // - // NOTE: It is possible that application had set - // LZMA_SUBFILTER_SET and LZMA_FINISH at the same - // time. In that case it is possible that we will - // cycle to LZMA_SUBFILTER_RUN, LZMA_SUBFILTER_FINISH, - // and back to LZMA_SUBFILTER_NONE in a single - // Subblock encoder function call. - if (action == LZMA_FINISH) { - coder->options->subfilter_mode - = LZMA_SUBFILTER_FINISH; - coder->subfilter.mode = SUB_FINISH; - } - - const size_t in_start = *in_pos; - - const lzma_ret ret = coder->subfilter.subcoder.code( - coder->subfilter.subcoder.coder, - allocator, in, in_pos, in_size, - coder->subblock.data, - &coder->subblock.size, - coder->subblock.limit, - coder->subfilter.mode == SUB_FINISH - ? LZMA_FINISH : action); - - const size_t in_used = *in_pos - in_start; - coder->subblock.in_pending += in_used; - if (in_used > 0) - coder->subfilter.got_input = true; - - coder->subfilter.in_avail = in_size - *in_pos; - - if (ret == LZMA_STREAM_END) { - // All currently available input must have - // been processed. - assert(*in_pos == in_size); - - // Flush now. Even if coder->subblock.size - // happened to be zero, we still need to go - // to SEQ_FLUSH to possibly finish RLE or - // write the Subfilter Unset indicator. - coder->sequence = SEQ_FLUSH; - - if (coder->subfilter.mode == SUB_RUN) { - // Flushing with Subfilter enabled. - assert(action == LZMA_SYNC_FLUSH); - coder->subfilter.mode = SUB_FLUSH; - break; - } - - // Subfilter finished its job. - assert(coder->subfilter.mode == SUB_FINISH - || action == LZMA_FINISH); - - // At least one byte of input must have been - // encoded with the Subfilter. This is - // required by the file format specification. - if (!coder->subfilter.got_input) - return LZMA_PROG_ERROR; - - // We don't strictly need to do this, but - // doing it sounds like a good idea, because - // otherwise the Subfilter's memory could be - // left allocated for long time, and would - // just waste memory. - lzma_next_end(&coder->subfilter.subcoder, - allocator); - - // We need to flush the currently buffered - // data and write Unset Subfilter marker. - // Note that we cannot set - // coder->options->subfilter_mode to - // LZMA_SUBFILTER_NONE yet, because we - // haven't written the Unset Subfilter - // marker yet. - coder->subfilter.mode = SUB_END_MARKER; - coder->sequence = SEQ_FLUSH; - break; - } - - // Return if we couldn't fill the buffer or - // if an error occurred. - if (coder->subblock.size < coder->subblock.limit - || ret != LZMA_OK) - return ret; - } - - coder->sequence = SEQ_FLUSH; - - // SEQ_FILL doesn't produce any output so falling through - // to SEQ_FLUSH is safe. - assert(*out_pos < out_size); - - // Fall through - - case SEQ_FLUSH: - if (coder->options != NULL) { - // Update the alignment variable. - coder->alignment.multiple = coder->options->alignment; - if (coder->alignment.multiple - < LZMA_SUBBLOCK_ALIGNMENT_MIN - || coder->alignment.multiple - > LZMA_SUBBLOCK_ALIGNMENT_MAX) - return LZMA_OPTIONS_ERROR; - - // Run-length encoder - // - // First check if there is some data pending and we - // have an obvious need to flush it immediately. - if (coder->rle.count > 0 - && (coder->rle.size - != coder->options->rle - || coder->subblock.size - % coder->rle.size)) { - subblock_rle_flush(coder); - break; - } - - // Grab the (possibly new) RLE chunk size and - // validate it. - coder->rle.size = coder->options->rle; - if (coder->rle.size > LZMA_SUBBLOCK_RLE_MAX) - return LZMA_OPTIONS_ERROR; - - if (coder->subblock.size != 0 - && coder->rle.size - != LZMA_SUBBLOCK_RLE_OFF - && coder->subblock.size - % coder->rle.size == 0) { - - // Initialize coder->rle.buffer if we don't - // have RLE already running. - if (coder->rle.count == 0) - memcpy(coder->rle.buffer, - coder->subblock.data, - coder->rle.size); - - // Test if coder->subblock.data is repeating. - // If coder->rle.count would overflow, we - // force flushing. Forced flushing shouldn't - // really happen in real-world situations. - const size_t count = coder->subblock.size - / coder->rle.size; - if (UINT64_MAX - count > coder->rle.count - && is_repeating( - coder->rle.buffer, - coder->rle.size, - coder->subblock.data, - count)) { - coder->rle.count += count; - coder->rle.in_pending += coder - ->subblock.in_pending; - coder->subblock.in_pending = 0; - coder->subblock.size = 0; - - } else if (coder->rle.count > 0) { - // It's not repeating or at least not - // with the same byte sequence as the - // earlier Subblock Data buffers. We - // have some data pending in the RLE - // buffer already, so do a flush. - // Once flushed, we will check again - // if the Subblock Data happens to - // contain a different repeating - // sequence. - subblock_rle_flush(coder); - break; - } - } - } - - // If we now have some data left in coder->subblock, the RLE - // buffer is empty and we must write a regular Subblock Data. - if (coder->subblock.size > 0) { - assert(coder->rle.count == 0); - coder->tmp = coder->subblock.size - 1; - coder->sequence = SEQ_DATA_SIZE_0; - break; - } - - // Check if we should enable Subfilter. - if (coder->subfilter.mode == SUB_SET) { - if (coder->rle.count > 0) - subblock_rle_flush(coder); - else - coder->sequence = SEQ_SUBFILTER_INIT; - break; - } - - // Check if we have just finished Subfiltering. - if (coder->subfilter.mode == SUB_END_MARKER) { - if (coder->rle.count > 0) { - subblock_rle_flush(coder); - break; - } - - coder->options->subfilter_mode = LZMA_SUBFILTER_NONE; - coder->subfilter.mode = SUB_NONE; - - write_byte(0x50); - if (*out_pos == out_size) - return LZMA_OK; - } - - // Check if we have already written everything. - if (action != LZMA_RUN && *in_pos == in_size - && (coder->subfilter.mode == SUB_NONE - || coder->subfilter.mode == SUB_FLUSH)) { - if (coder->rle.count > 0) { - subblock_rle_flush(coder); - break; - } - - if (action == LZMA_SYNC_FLUSH) { - if (coder->subfilter.mode == SUB_FLUSH) - coder->subfilter.mode = SUB_RUN; - - coder->subfilter.mode_locked = false; - coder->sequence = SEQ_FILL; - - } else { - assert(action == LZMA_FINISH); - - // Write EOPM. - // NOTE: No need to use write_byte() here - // since we are finishing. - out[*out_pos] = 0x10; - ++*out_pos; - } - - return LZMA_STREAM_END; - } - - // Otherwise we have more work to do. - coder->sequence = SEQ_FILL; - break; - - case SEQ_RLE_COUNT_0: - assert(coder->rle.count > 0); - - if (coder->rle.count == 1) { - // The buffer should be repeated only once. Fix - // the alignment and write the first byte of - // Subblock Type `Data'. - if (subblock_align(coder, out, out_pos, out_size, - coder->rle.size, ALIGN_SKEW_DATA)) - return LZMA_OK; - - write_byte(0x20 | (coder->tmp & 0x0F)); - - } else { - // We have something to actually repeat, which should - // mean that it takes less space with run-length - // encoding. - if (subblock_align(coder, out, out_pos, out_size, - coder->rle.size, - ALIGN_SKEW_REPEATING_DATA)) - return LZMA_OK; - - write_byte(0x30 | (coder->tmp & 0x0F)); - } - - // NOTE: If we have to write more than one Repeating Data - // due to rle.count > REPEAT_COUNT_MAX, the subsequent - // Repeating Data Subblocks may get wrong alignment, because - // we add rle.in_pending to alignment.in_pos at once instead - // of adding only as much as this particular Repeating Data - // consumed input data. Correct alignment is always restored - // after all the required Repeating Data Subblocks have been - // written. This problem occurs in such a weird cases that - // it's not worth fixing. - coder->alignment.out_pos += coder->rle.size; - coder->alignment.in_pos += coder->rle.in_pending; - coder->rle.in_pending = 0; - - coder->sequence = SEQ_RLE_COUNT_1; - break; - - case SEQ_RLE_COUNT_1: - write_byte(coder->tmp >> 4); - coder->sequence = SEQ_RLE_COUNT_2; - break; - - case SEQ_RLE_COUNT_2: - write_byte(coder->tmp >> 12); - coder->sequence = SEQ_RLE_COUNT_3; - break; - - case SEQ_RLE_COUNT_3: - write_byte(coder->tmp >> 20); - - // Again, see if we are writing regular Data or Repeating Data. - // In the former case, we skip SEQ_RLE_SIZE. - if (coder->rle.count == 1) - coder->sequence = SEQ_RLE_DATA; - else - coder->sequence = SEQ_RLE_SIZE; - - if (coder->rle.count > REPEAT_COUNT_MAX) - coder->rle.count -= REPEAT_COUNT_MAX; - else - coder->rle.count = 0; - - break; - - case SEQ_RLE_SIZE: - assert(coder->rle.size >= LZMA_SUBBLOCK_RLE_MIN); - assert(coder->rle.size <= LZMA_SUBBLOCK_RLE_MAX); - write_byte(coder->rle.size - 1); - coder->sequence = SEQ_RLE_DATA; - break; - - case SEQ_RLE_DATA: - lzma_bufcpy(coder->rle.buffer, &coder->pos, coder->rle.size, - out, out_pos, out_size); - if (coder->pos < coder->rle.size) - return LZMA_OK; - - coder->pos = 0; - coder->sequence = SEQ_FLUSH; - break; - - case SEQ_DATA_SIZE_0: - // We need four bytes for the Size field. - if (subblock_align(coder, out, out_pos, out_size, - coder->subblock.size, ALIGN_SKEW_DATA)) - return LZMA_OK; - - coder->alignment.out_pos += coder->subblock.size; - coder->alignment.in_pos += coder->subblock.in_pending; - coder->subblock.in_pending = 0; - - write_byte(0x20 | (coder->tmp & 0x0F)); - coder->sequence = SEQ_DATA_SIZE_1; - break; - - case SEQ_DATA_SIZE_1: - write_byte(coder->tmp >> 4); - coder->sequence = SEQ_DATA_SIZE_2; - break; - - case SEQ_DATA_SIZE_2: - write_byte(coder->tmp >> 12); - coder->sequence = SEQ_DATA_SIZE_3; - break; - - case SEQ_DATA_SIZE_3: - write_byte(coder->tmp >> 20); - coder->sequence = SEQ_DATA; - break; - - case SEQ_DATA: - lzma_bufcpy(coder->subblock.data, &coder->pos, - coder->subblock.size, out, out_pos, out_size); - if (coder->pos < coder->subblock.size) - return LZMA_OK; - - coder->subblock.size = 0; - coder->pos = 0; - coder->sequence = SEQ_FLUSH; - break; - - case SEQ_SUBFILTER_INIT: { - assert(coder->subblock.size == 0); - assert(coder->subblock.in_pending == 0); - assert(coder->rle.count == 0); - assert(coder->rle.in_pending == 0); - assert(coder->subfilter.mode == SUB_SET); - assert(coder->options != NULL); - - // There must be a filter specified. - if (coder->options->subfilter_options.id == LZMA_VLI_UNKNOWN) - return LZMA_OPTIONS_ERROR; - - // Initialize a raw encoder to work as a Subfilter. - lzma_filter options[2]; - options[0] = coder->options->subfilter_options; - options[1].id = LZMA_VLI_UNKNOWN; - - return_if_error(lzma_raw_encoder_init( - &coder->subfilter.subcoder, allocator, - options)); - - // Encode the Filter Flags field into a buffer. This should - // never fail since we have already successfully initialized - // the Subfilter itself. Check it still, and return - // LZMA_PROG_ERROR instead of whatever the ret would say. - lzma_ret ret = lzma_filter_flags_size( - &coder->subfilter.flags_size, options); - assert(ret == LZMA_OK); - if (ret != LZMA_OK) - return LZMA_PROG_ERROR; - - coder->subfilter.flags = lzma_alloc( - coder->subfilter.flags_size, allocator); - if (coder->subfilter.flags == NULL) - return LZMA_MEM_ERROR; - - // Now we have a big-enough buffer. Encode the Filter Flags. - // Like above, this should never fail. - size_t dummy = 0; - ret = lzma_filter_flags_encode(options, coder->subfilter.flags, - &dummy, coder->subfilter.flags_size); - assert(ret == LZMA_OK); - assert(dummy == coder->subfilter.flags_size); - if (ret != LZMA_OK || dummy != coder->subfilter.flags_size) - return LZMA_PROG_ERROR; - - // Write a Subblock indicating a new Subfilter. - write_byte(0x40); - - coder->options->subfilter_mode = LZMA_SUBFILTER_RUN; - coder->subfilter.mode = SUB_RUN; - coder->alignment.out_pos += coder->subfilter.flags_size; - coder->sequence = SEQ_SUBFILTER_FLAGS; - - // It is safe to fall through because SEQ_SUBFILTER_FLAGS - // uses lzma_bufcpy() which doesn't write unless there is - // output space. - } - - // Fall through - - case SEQ_SUBFILTER_FLAGS: - // Copy the Filter Flags to the output stream. - lzma_bufcpy(coder->subfilter.flags, &coder->pos, - coder->subfilter.flags_size, - out, out_pos, out_size); - if (coder->pos < coder->subfilter.flags_size) - return LZMA_OK; - - lzma_free(coder->subfilter.flags, allocator); - coder->subfilter.flags = NULL; - - coder->pos = 0; - coder->sequence = SEQ_FILL; - break; - - default: - return LZMA_PROG_ERROR; - } - - return LZMA_OK; -} - - -static lzma_ret -subblock_encode(lzma_coder *coder, 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) -{ - if (coder->next.code == NULL) - return subblock_buffer(coder, allocator, in, in_pos, in_size, - out, out_pos, out_size, action); - - while (*out_pos < out_size - && (*in_pos < in_size || action != LZMA_RUN)) { - 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) { - assert(action != LZMA_RUN); - coder->next_finished = true; - } else if (coder->temp.size == 0 || ret != LZMA_OK) { - return ret; - } - } - - const lzma_ret ret = subblock_buffer(coder, allocator, - coder->temp.buffer, &coder->temp.pos, - coder->temp.size, out, out_pos, out_size, - coder->next_finished ? LZMA_FINISH : LZMA_RUN); - if (ret == LZMA_STREAM_END) { - assert(action != LZMA_RUN); - assert(coder->next_finished); - return LZMA_STREAM_END; - } - - if (ret != LZMA_OK) - return ret; - } - - return LZMA_OK; -} - - -static void -subblock_encoder_end(lzma_coder *coder, lzma_allocator *allocator) -{ - lzma_next_end(&coder->next, allocator); - lzma_next_end(&coder->subfilter.subcoder, allocator); - lzma_free(coder->subblock.data, allocator); - lzma_free(coder->subfilter.flags, allocator); - lzma_free(coder, allocator); - return; -} - - -extern lzma_ret -lzma_subblock_encoder_init(lzma_next_coder *next, lzma_allocator *allocator, - const lzma_filter_info *filters) -{ - if (next->coder == NULL) { - next->coder = lzma_alloc(sizeof(lzma_coder), allocator); - if (next->coder == NULL) - return LZMA_MEM_ERROR; - - next->code = &subblock_encode; - next->end = &subblock_encoder_end; - - next->coder->next = LZMA_NEXT_CODER_INIT; - next->coder->subblock.data = NULL; - next->coder->subblock.limit = 0; - next->coder->subfilter.subcoder = LZMA_NEXT_CODER_INIT; - } else { - lzma_next_end(&next->coder->subfilter.subcoder, - allocator); - lzma_free(next->coder->subfilter.flags, allocator); - } - - next->coder->subfilter.flags = NULL; - - next->coder->next_finished = false; - next->coder->sequence = SEQ_FILL; - next->coder->options = filters[0].options; - next->coder->pos = 0; - - next->coder->alignment.in_pos = 0; - next->coder->alignment.out_pos = 0; - next->coder->subblock.size = 0; - next->coder->subblock.in_pending = 0; - next->coder->rle.count = 0; - next->coder->rle.in_pending = 0; - next->coder->subfilter.mode = SUB_NONE; - next->coder->subfilter.mode_locked = false; - - next->coder->temp.pos = 0; - next->coder->temp.size = 0; - - // Grab some values from the options structure if it is available. - size_t subblock_size_limit; - if (next->coder->options != NULL) { - if (next->coder->options->alignment - < LZMA_SUBBLOCK_ALIGNMENT_MIN - || next->coder->options->alignment - > LZMA_SUBBLOCK_ALIGNMENT_MAX) { - subblock_encoder_end(next->coder, allocator); - return LZMA_OPTIONS_ERROR; - } - next->coder->alignment.multiple - = next->coder->options->alignment; - next->coder->subfilter.allow - = next->coder->options->allow_subfilters; - subblock_size_limit = next->coder->options->subblock_data_size; - } else { - next->coder->alignment.multiple - = LZMA_SUBBLOCK_ALIGNMENT_DEFAULT; - next->coder->subfilter.allow = false; - subblock_size_limit = LZMA_SUBBLOCK_DATA_SIZE_DEFAULT; - } - - return_if_error(subblock_data_size(next->coder, allocator, - subblock_size_limit)); - - return lzma_next_filter_init( - &next->coder->next, allocator, filters + 1); -} diff --git a/contrib/xz/src/liblzma/subblock/subblock_encoder.h b/contrib/xz/src/liblzma/subblock/subblock_encoder.h deleted file mode 100644 index ddbfe64..0000000 --- a/contrib/xz/src/liblzma/subblock/subblock_encoder.h +++ /dev/null @@ -1,21 +0,0 @@ -/////////////////////////////////////////////////////////////////////////////// -// -/// \file subblock_encoder.h -/// \brief Encoder of the Subblock filter -// -// Author: Lasse Collin -// -// This file has been put into the public domain. -// You can do whatever you want with this file. -// -/////////////////////////////////////////////////////////////////////////////// - -#ifndef LZMA_SUBBLOCK_ENCODER_H -#define LZMA_SUBBLOCK_ENCODER_H - -#include "common.h" - -extern lzma_ret lzma_subblock_encoder_init(lzma_next_coder *next, - lzma_allocator *allocator, const lzma_filter_info *filters); - -#endif |
