diff options
Diffstat (limited to '')
23 files changed, 294 insertions, 262 deletions
diff --git a/src/liblzma/api/lzma.h b/src/liblzma/api/lzma.h index 7790a089..d19687b7 100644 --- a/src/liblzma/api/lzma.h +++ b/src/liblzma/api/lzma.h @@ -127,12 +127,12 @@ #endif /* ifdef LZMA_MANUAL_HEADERS */ -/****************** - * GCC extensions * - ******************/ +/******************** + * GNU C extensions * + ********************/ /* - * GCC extensions are used conditionally in the public API. It doesn't + * GNU C extensions are used conditionally in the public API. It doesn't * break anything if these are sometimes enabled and sometimes not, only * affects warnings and optimizations. */ diff --git a/src/liblzma/api/lzma/block.h b/src/liblzma/api/lzma/block.h index 2702cd51..a747b145 100644 --- a/src/liblzma/api/lzma/block.h +++ b/src/liblzma/api/lzma/block.h @@ -33,6 +33,35 @@ */ typedef struct { /** + * \brief Block format version + * + * To prevent API and ABI breakages if new features are needed in + * Block, a version number is used to indicate which fields in this + * structure are in use. For now, version must always be zero. + * With non-zero version, most Block related functions will return + * LZMA_OPTIONS_ERROR. + * + * The decoding functions will always set this to the lowest value + * that supports all the features indicated by the Block Header field. + * The application must check that the version number set by the + * decoding functions is supported by the application. Otherwise it + * is possible that the application will decode the Block incorrectly. + * + * Read by: + * - lzma_block_header_size() + * - lzma_block_header_encode() + * - lzma_block_compressed_size() + * - lzma_block_unpadded_size() + * - lzma_block_total_size() + * - lzma_block_encoder() + * - lzma_block_decoder() + * + * Written by: + * - lzma_block_header_decode() + */ + uint32_t version; + + /** * \brief Size of the Block Header field * * This is always a multiple of four. @@ -168,6 +197,37 @@ typedef struct { */ lzma_filter *filters; + /* + * Reserved space to allow possible future extensions without + * breaking the ABI. You should not touch these, because the names + * of these variables may change. These are and will never be used + * with the currently supported options, so it is safe to leave these + * uninitialized. + */ + void *reserved_ptr1; + void *reserved_ptr2; + void *reserved_ptr3; + uint32_t reserved_int1; + uint32_t reserved_int2; + lzma_vli reserved_int3; + lzma_vli reserved_int4; + lzma_vli reserved_int5; + lzma_vli reserved_int6; + lzma_vli reserved_int7; + lzma_vli reserved_int8; + lzma_reserved_enum reserved_enum1; + lzma_reserved_enum reserved_enum2; + lzma_reserved_enum reserved_enum3; + lzma_reserved_enum reserved_enum4; + lzma_bool reserved_bool1; + lzma_bool reserved_bool2; + lzma_bool reserved_bool3; + lzma_bool reserved_bool4; + lzma_bool reserved_bool5; + lzma_bool reserved_bool6; + lzma_bool reserved_bool7; + lzma_bool reserved_bool8; + } lzma_block; @@ -196,7 +256,8 @@ typedef struct { * * \return - LZMA_OK: Size calculated successfully and stored to * block->header_size. - * - LZMA_OPTIONS_ERROR: Unsupported filters or filter options. + * - LZMA_OPTIONS_ERROR: Unsupported version, filters or + * filter options. * - LZMA_PROG_ERROR: Invalid values like compressed_size == 0. * * \note This doesn't check that all the options are valid i.e. this diff --git a/src/liblzma/api/lzma/container.h b/src/liblzma/api/lzma/container.h index 800f2129..ba2c4f8f 100644 --- a/src/liblzma/api/lzma/container.h +++ b/src/liblzma/api/lzma/container.h @@ -26,30 +26,42 @@ ************/ /** - * \brief Default compression level for easy encoder + * \brief Default compression preset * - * It's not straightforward to recommend a default level, because in some + * It's not straightforward to recommend a default preset, because in some * cases keeping the resource usage relatively low is more important that * getting the maximum compression ratio. */ -#define LZMA_EASY_LEVEL_DEFAULT 6 +#define LZMA_PRESET_DEFAULT UINT32_C(6) + + +/** + * \brief Mask for preset level + * + * This is useful only if you need to extract the level from the preset + * variable. That should be rare. + */ +#define LZMA_PRESET_LEVEL_MASK UINT32_C(0x1F) /* - * Flags for easy encoder + * Preset flags * * Currently only one flag is defined. */ /** - * Use significantly slower compression to get marginally better compression - * ratio. This doesn't affect the memory requirements of the encoder or - * decoder. This flag is useful when you don't mind wasting time to get as - * small result as possible. + * \brief Extreme compression preset + * + * This flag modifies the preset to make the encoding significantly slower + * while improving the compression ratio only marginally. This is useful + * when you don't mind wasting time to get as small result as possible. * - * FIXME: Not implemented yet. + * This flag doesn't affect the memory usage requirements of the decoder (at + * least not significantly). The memory usage of the encoder may be increased + * a little but only at the lowest preset levels (0-4 or so). */ -#define LZMA_EASY_EXTREME UINT32_C(0x01) +#define LZMA_PRESET_EXTREME (UINT32_C(1) << 31) /** @@ -57,12 +69,9 @@ * * This function is a wrapper for lzma_raw_encoder_memusage(). * - * \param level Compression level - * \param flags Easy encoder flags (usually zero). This parameter is - * needed, because in future some flags may affect the - * memory requirements. + * \param preset Compression preset (level and possible flags) */ -extern uint64_t lzma_easy_encoder_memusage(uint32_t level, uint32_t flags) +extern uint64_t lzma_easy_encoder_memusage(uint32_t preset) lzma_attr_pure; @@ -71,12 +80,9 @@ extern uint64_t lzma_easy_encoder_memusage(uint32_t level, uint32_t flags) * * This function is a wrapper for lzma_raw_decoder_memusage(). * - * \param level Compression level - * \param flags Easy encoder flags (usually zero). This parameter is - * needed, because in future some flags may affect the - * memory requirements. + * \param preset Compression preset (level and possible flags) */ -extern uint64_t lzma_easy_decoder_memusage(uint32_t level, uint32_t flags) +extern uint64_t lzma_easy_decoder_memusage(uint32_t preset) lzma_attr_pure; @@ -88,14 +94,12 @@ extern uint64_t lzma_easy_decoder_memusage(uint32_t level, uint32_t flags) * * \param strm Pointer to lzma_stream that is at least initialized * with LZMA_STREAM_INIT. - * \param level Compression level to use. This selects a set of - * compression settings from a list of compression - * presets. Currently levels from 1 to 9 are defined, - * which match the options -1 .. -9 of the xz command - * line tool. - * \param flags Flags that can finetune the compression preset. - * In most cases, no flags are wanted, and this - * parameter is zero. + * \param preset Compression preset to use. A preset consist of level + * number and zero or more flags. Usually flags aren't + * used, so preset is simply a number [0, 9] which match + * the options -0 .. -9 of the xz command line tool. + * Additional flags can be be set using bitwise-or with + * the preset level number, e.g. 6 | LZMA_PRESET_EXTREME. * \param check Integrity check type to use. See check.h for available * checks. If you are unsure, use LZMA_CHECK_CRC32. * @@ -115,8 +119,8 @@ extern uint64_t lzma_easy_decoder_memusage(uint32_t level, uint32_t flags) * LZMA_RUN, LZMA_SYNC_FLUSH, LZMA_FULL_FLUSH, and LZMA_FINISH. In future, * there may be compression levels or flags that don't support LZMA_SYNC_FLUSH. */ -extern lzma_ret lzma_easy_encoder(lzma_stream *strm, - uint32_t level, uint32_t flags, lzma_check check) +extern lzma_ret lzma_easy_encoder( + lzma_stream *strm, uint32_t preset, lzma_check check) lzma_attr_warn_unused_result; @@ -125,10 +129,8 @@ extern lzma_ret lzma_easy_encoder(lzma_stream *strm, * * \param strm Pointer to properly prepared lzma_stream * \param filters Array of filters. This must be terminated with - * filters[n].id = LZMA_VLI_UNKNOWN. There must - * be 1-4 filters, but there are restrictions on how - * multiple filters can be combined. FIXME Tell where - * to find more information. + * filters[n].id = LZMA_VLI_UNKNOWN. See filter.h for + * more information. * \param check Type of the integrity check to calculate from * uncompressed data. * @@ -153,15 +155,13 @@ extern lzma_ret lzma_stream_encoder(lzma_stream *strm, * legacy LZMA tools such as LZMA Utils 4.32.x. Moving to the .xz format * is strongly recommended. * - * FIXME: Dictionary size limit? - * * The valid action values for lzma_code() are LZMA_RUN and LZMA_FINISH. * No kind of flushing is supported, because the file format doesn't make * it possible. * * \return - LZMA_OK * - LZMA_MEM_ERROR - * - LZMA_OPTIONS_ERROR // FIXME + * - LZMA_OPTIONS_ERROR * - LZMA_PROG_ERROR */ extern lzma_ret lzma_alone_encoder( @@ -252,7 +252,7 @@ extern lzma_ret lzma_auto_decoder( /** - * \brief Initializes decoder for .lzma file + * \brief Initialize .lzma decoder (legacy file format) * * Valid `action' arguments to lzma_code() are LZMA_RUN and LZMA_FINISH. * There is no need to use LZMA_FINISH, but allowing it may simplify diff --git a/src/liblzma/api/lzma/lzma.h b/src/liblzma/api/lzma/lzma.h index e3db236b..834bf0b0 100644 --- a/src/liblzma/api/lzma/lzma.h +++ b/src/liblzma/api/lzma/lzma.h @@ -160,19 +160,20 @@ typedef enum { * mode, which the application developer wasn't aware, could require giving * additional options to the encoder that the older modes don't need. */ -extern lzma_bool lzma_mode_is_available(lzma_mode mode) lzma_attr_const; +extern lzma_bool lzma_mode_is_supported(lzma_mode mode) lzma_attr_const; /** * \brief Options specific to the LZMA1 and LZMA2 filters + * + * Since LZMA1 and LZMA2 share most of the code, it's simplest to share + * the options structure too. For encoding, all but the reserved variables + * need to be initialized unless specifically mentioned otherwise. + * + * For raw decoding, both LZMA1 and LZMA2 need dict_size, preset_dict, and + * preset_dict_size (if preset_dict != NULL). LZMA1 needs also lc, lp, and pb. */ typedef struct { - /********************************** - * LZMA encoding/decoding options * - **********************************/ - - /* These options are required in encoder and also with raw decoding. */ - /** * \brief Dictionary size in bytes * @@ -298,10 +299,6 @@ typedef struct { # define LZMA_PB_MAX 4 # define LZMA_PB_DEFAULT 2 - /****************************************** - * LZMA options needed only when encoding * - ******************************************/ - /** * \brief Indicate if the options structure is persistent * @@ -377,6 +374,8 @@ typedef struct { * with the currently supported options, so it is safe to leave these * uninitialized. */ + void *reserved_ptr1; + void *reserved_ptr2; uint32_t reserved_int1; uint32_t reserved_int2; uint32_t reserved_int3; @@ -385,20 +384,26 @@ typedef struct { uint32_t reserved_int6; uint32_t reserved_int7; uint32_t reserved_int8; - void *reserved_ptr1; - void *reserved_ptr2; + lzma_reserved_enum reserved_enum1; + lzma_reserved_enum reserved_enum2; + lzma_reserved_enum reserved_enum3; + lzma_reserved_enum reserved_enum4; } lzma_options_lzma; /** - * \brief Set a compression level preset to lzma_options_lzma structure + * \brief Set a compression preset to lzma_options_lzma structure * - * level = 1 is the fastest and level = 9 is the slowest. These presets match - * the switches -1 .. -9 of the command line tool. + * 0 is the fastest and 9 is the slowest. These match the switches -0 .. -9 + * of the xz command line tool. In addition, it is possible to bitwise-or + * flags to the preset. Currently only LZMA_PRESET_EXTREME is supported. + * The flags are defined in container.h, because the flags are used also + * with lzma_easy_encoder(). * * The preset values are subject to changes between liblzma versions. * - * This function is available only if LZMA encoder has been enabled. + * This function is available only if LZMA1 or LZMA2 encoder has been enabled + * when building liblzma. */ -extern lzma_bool lzma_lzma_preset(lzma_options_lzma *options, uint32_t level); +extern lzma_bool lzma_lzma_preset(lzma_options_lzma *options, uint32_t preset); diff --git a/src/liblzma/common/alone_decoder.c b/src/liblzma/common/alone_decoder.c index 6845537f..e850a926 100644 --- a/src/liblzma/common/alone_decoder.c +++ b/src/liblzma/common/alone_decoder.c @@ -75,24 +75,24 @@ alone_decode(lzma_coder *coder, |= (size_t)(in[*in_pos]) << (coder->pos * 8); if (++coder->pos == 4) { - if (coder->options.dict_size > (UINT32_C(1) << 30)) - return LZMA_FORMAT_ERROR; - - // A hack to ditch tons of false positives: We allow - // only dictionary sizes that are 2^n or 2^n + 2^(n-1). - // LZMA_Alone created only files with 2^n, but accepts - // any dictionary size. If someone complains, this - // will be reconsidered. - uint32_t d = coder->options.dict_size - 1; - d |= d >> 2; - d |= d >> 3; - d |= d >> 4; - d |= d >> 8; - d |= d >> 16; - ++d; - - if (d != coder->options.dict_size) - return LZMA_FORMAT_ERROR; + if (coder->options.dict_size != UINT32_MAX) { + // A hack to ditch tons of false positives: + // We allow only dictionary sizes that are + // 2^n or 2^n + 2^(n-1). LZMA_Alone created + // only files with 2^n, but accepts any + // dictionary size. If someone complains, this + // will be reconsidered. + uint32_t d = coder->options.dict_size - 1; + d |= d >> 2; + d |= d >> 3; + d |= d >> 4; + d |= d >> 8; + d |= d >> 16; + ++d; + + if (d != coder->options.dict_size) + return LZMA_FORMAT_ERROR; + } coder->pos = 0; coder->sequence = SEQ_UNCOMPRESSED_SIZE; diff --git a/src/liblzma/common/alone_encoder.c b/src/liblzma/common/alone_encoder.c index 41fb6162..b2dccf05 100644 --- a/src/liblzma/common/alone_encoder.c +++ b/src/liblzma/common/alone_encoder.c @@ -104,28 +104,24 @@ alone_encoder_init(lzma_next_coder *next, lzma_allocator *allocator, // Encode the header: // - Properties (1 byte) if (lzma_lzma_lclppb_encode(options, next->coder->header)) - return LZMA_PROG_ERROR; + return LZMA_OPTIONS_ERROR; - // - Dictionary size (4 bytes); limit to 1 GiB since that's what - // LZMA SDK currently does for encoding. - if (options->dict_size < LZMA_DICT_SIZE_MIN - || options->dict_size > (UINT32_C(1) << 30)) - return LZMA_PROG_ERROR; + // - Dictionary size (4 bytes) + if (options->dict_size < LZMA_DICT_SIZE_MIN) + return LZMA_OPTIONS_ERROR; // Round up to to the next 2^n or 2^n + 2^(n - 1) depending on which - // one is the next. While the header would allow any 32-bit integer, - // we do this to keep the decoder of liblzma accepting the resulting - // files. - // - // FIXME Maybe LZMA_Alone needs some lower limit for maximum - // dictionary size? Must check decoders from old LZMA SDK version. + // one is the next unless it is UINT32_MAX. While the header would + // allow any 32-bit integer, we do this to keep the decoder of liblzma + // accepting the resulting files. uint32_t d = options->dict_size - 1; d |= d >> 2; d |= d >> 3; d |= d >> 4; d |= d >> 8; d |= d >> 16; - ++d; + if (d != UINT32_MAX) + ++d; integer_write_32(next->coder->header + 1, d); diff --git a/src/liblzma/common/auto_decoder.c b/src/liblzma/common/auto_decoder.c index 2520dc17..7333da66 100644 --- a/src/liblzma/common/auto_decoder.c +++ b/src/liblzma/common/auto_decoder.c @@ -1,7 +1,7 @@ /////////////////////////////////////////////////////////////////////////////// // /// \file auto_decoder.c -/// \brief Autodetect between .lzma Stream and LZMA_Alone formats +/// \brief Autodetect between .xz Stream and .lzma (LZMA_Alone) formats // // Copyright (C) 2007 Lasse Collin // diff --git a/src/liblzma/common/block_decoder.c b/src/liblzma/common/block_decoder.c index 2bfe0b92..b130f567 100644 --- a/src/liblzma/common/block_decoder.c +++ b/src/liblzma/common/block_decoder.c @@ -1,7 +1,7 @@ /////////////////////////////////////////////////////////////////////////////// // /// \file block_decoder.c -/// \brief Decodes .lzma Blocks +/// \brief Decodes .xz Blocks // // Copyright (C) 2007 Lasse Collin // @@ -34,7 +34,7 @@ struct lzma_coder_s { /// Decoding options; we also write Compressed Size and Uncompressed /// Size back to this structure when the decoding has been finished. - lzma_block *options; + lzma_block *block; /// Compressed Size calculated while decoding lzma_vli compressed_size; @@ -101,10 +101,10 @@ block_decode(lzma_coder *coder, lzma_allocator *allocator, coder->compressed_limit) || update_size(&coder->uncompressed_size, out_used, - coder->options->uncompressed_size)) + coder->block->uncompressed_size)) return LZMA_DATA_ERROR; - lzma_check_update(&coder->check, coder->options->check, + lzma_check_update(&coder->check, coder->block->check, out + out_start, out_used); if (ret != LZMA_STREAM_END) @@ -113,15 +113,15 @@ block_decode(lzma_coder *coder, lzma_allocator *allocator, // Compressed and Uncompressed Sizes are now at their final // values. Verify that they match the values given to us. if (!is_size_valid(coder->compressed_size, - coder->options->compressed_size) + coder->block->compressed_size) || !is_size_valid(coder->uncompressed_size, - coder->options->uncompressed_size)) + coder->block->uncompressed_size)) return LZMA_DATA_ERROR; - // Copy the values into coder->options. The caller + // Copy the values into coder->block. The caller // may use this information to construct Index. - coder->options->compressed_size = coder->compressed_size; - coder->options->uncompressed_size = coder->uncompressed_size; + coder->block->compressed_size = coder->compressed_size; + coder->block->uncompressed_size = coder->uncompressed_size; coder->sequence = SEQ_PADDING; } @@ -133,7 +133,7 @@ block_decode(lzma_coder *coder, lzma_allocator *allocator, while (coder->compressed_size & 3) { // We use compressed_size here just get the Padding // right. The actual Compressed Size was stored to - // coder->options already, and won't be modified by + // coder->block already, and won't be modified by // us anymore. ++coder->compressed_size; @@ -144,17 +144,17 @@ block_decode(lzma_coder *coder, lzma_allocator *allocator, return LZMA_DATA_ERROR; } - if (coder->options->check == LZMA_CHECK_NONE) + if (coder->block->check == LZMA_CHECK_NONE) return LZMA_STREAM_END; - lzma_check_finish(&coder->check, coder->options->check); + lzma_check_finish(&coder->check, coder->block->check); coder->sequence = SEQ_CHECK; // Fall through case SEQ_CHECK: { const bool chksup = lzma_check_is_supported( - coder->options->check); + coder->block->check); while (*in_pos < in_size) { // coder->check.buffer[] may be uninitialized when @@ -168,7 +168,7 @@ block_decode(lzma_coder *coder, lzma_allocator *allocator, ++*in_pos; if (++coder->check_pos == lzma_check_size( - coder->options->check)) + coder->block->check)) return LZMA_STREAM_END; } @@ -191,15 +191,15 @@ block_decoder_end(lzma_coder *coder, lzma_allocator *allocator) extern lzma_ret lzma_block_decoder_init(lzma_next_coder *next, lzma_allocator *allocator, - lzma_block *options) + lzma_block *block) { lzma_next_coder_init(lzma_block_decoder_init, next, allocator); // Validate the options. lzma_block_unpadded_size() does that for us // except for Uncompressed Size and filters. Filters are validated // by the raw decoder. - if (lzma_block_unpadded_size(options) == 0 - || !lzma_vli_is_valid(options->uncompressed_size)) + if (lzma_block_unpadded_size(block) == 0 + || !lzma_vli_is_valid(block->uncompressed_size)) return LZMA_PROG_ERROR; // Allocate and initialize *next->coder if needed. @@ -215,7 +215,7 @@ lzma_block_decoder_init(lzma_next_coder *next, lzma_allocator *allocator, // Basic initializations next->coder->sequence = SEQ_CODE; - next->coder->options = options; + next->coder->block = block; next->coder->compressed_size = 0; next->coder->uncompressed_size = 0; @@ -223,28 +223,28 @@ lzma_block_decoder_init(lzma_next_coder *next, lzma_allocator *allocator, // value so that encoded size of the Block (including Block Padding) // is still a valid VLI and a multiple of four. next->coder->compressed_limit - = options->compressed_size == LZMA_VLI_UNKNOWN + = block->compressed_size == LZMA_VLI_UNKNOWN ? (LZMA_VLI_MAX & ~LZMA_VLI_C(3)) - - options->header_size - - lzma_check_size(options->check) - : options->compressed_size; + - block->header_size + - lzma_check_size(block->check) + : block->compressed_size; // Initialize the check. It's caller's problem if the Check ID is not // supported, and the Block decoder cannot verify the Check field. - // Caller can test lzma_checks[options->check]. + // Caller can test lzma_check_is_supported(block->check). next->coder->check_pos = 0; - lzma_check_init(&next->coder->check, options->check); + lzma_check_init(&next->coder->check, block->check); // Initialize the filter chain. return lzma_raw_decoder_init(&next->coder->next, allocator, - options->filters); + block->filters); } extern LZMA_API lzma_ret -lzma_block_decoder(lzma_stream *strm, lzma_block *options) +lzma_block_decoder(lzma_stream *strm, lzma_block *block) { - lzma_next_strm_init(lzma_block_decoder_init, strm, options); + lzma_next_strm_init(lzma_block_decoder_init, strm, block); strm->internal->supported_actions[LZMA_RUN] = true; strm->internal->supported_actions[LZMA_FINISH] = true; diff --git a/src/liblzma/common/block_decoder.h b/src/liblzma/common/block_decoder.h index 999aa748..e16bffdb 100644 --- a/src/liblzma/common/block_decoder.h +++ b/src/liblzma/common/block_decoder.h @@ -1,7 +1,7 @@ /////////////////////////////////////////////////////////////////////////////// // /// \file block_decoder.h -/// \brief Decodes .lzma Blocks +/// \brief Decodes .xz Blocks // // Copyright (C) 2007 Lasse Collin // @@ -24,6 +24,6 @@ extern lzma_ret lzma_block_decoder_init(lzma_next_coder *next, - lzma_allocator *allocator, lzma_block *options); + lzma_allocator *allocator, lzma_block *block); #endif diff --git a/src/liblzma/common/block_encoder.c b/src/liblzma/common/block_encoder.c index 6468cb44..994de59a 100644 --- a/src/liblzma/common/block_encoder.c +++ b/src/liblzma/common/block_encoder.c @@ -1,7 +1,7 @@ /////////////////////////////////////////////////////////////////////////////// // /// \file block_encoder.c -/// \brief Encodes .lzma Blocks +/// \brief Encodes .xz Blocks // // Copyright (C) 2007 Lasse Collin // @@ -44,7 +44,7 @@ struct lzma_coder_s { /// Encoding options; we also write Unpadded Size, Compressed Size, /// and Uncompressed Size back to this structure when the encoding /// has been finished. - lzma_block *options; + lzma_block *block; enum { SEQ_CODE, @@ -97,7 +97,7 @@ block_encode(lzma_coder *coder, lzma_allocator *allocator, // checked it at the beginning of this function. coder->uncompressed_size += in_used; - lzma_check_update(&coder->check, coder->options->check, + lzma_check_update(&coder->check, coder->block->check, in + in_start, in_used); if (ret != LZMA_STREAM_END || action == LZMA_SYNC_FLUSH) @@ -106,10 +106,10 @@ block_encode(lzma_coder *coder, lzma_allocator *allocator, assert(*in_pos == in_size); assert(action == LZMA_FINISH); - // Copy the values into coder->options. The caller + // Copy the values into coder->block. The caller // may use this information to construct Index. - coder->options->compressed_size = coder->compressed_size; - coder->options->uncompressed_size = coder->uncompressed_size; + coder->block->compressed_size = coder->compressed_size; + coder->block->uncompressed_size = coder->uncompressed_size; coder->sequence = SEQ_PADDING; } @@ -127,10 +127,10 @@ block_encode(lzma_coder *coder, lzma_allocator *allocator, ++coder->pos; } - if (coder->options->check == LZMA_CHECK_NONE) + if (coder->block->check == LZMA_CHECK_NONE) return LZMA_STREAM_END; - lzma_check_finish(&coder->check, coder->options->check); + lzma_check_finish(&coder->check, coder->block->check); coder->pos = 0; coder->sequence = SEQ_CHECK; @@ -139,7 +139,7 @@ block_encode(lzma_coder *coder, lzma_allocator *allocator, case SEQ_CHECK: { const uint32_t check_size - = lzma_check_size(coder->options->check); + = lzma_check_size(coder->block->check); while (*out_pos < out_size) { out[*out_pos] = coder->check.buffer.u8[coder->pos]; @@ -168,16 +168,19 @@ block_encoder_end(lzma_coder *coder, lzma_allocator *allocator) extern lzma_ret lzma_block_encoder_init(lzma_next_coder *next, lzma_allocator *allocator, - lzma_block *options) + lzma_block *block) { lzma_next_coder_init(lzma_block_encoder_init, next, allocator); + if (block->version != 0) + return LZMA_OPTIONS_ERROR; + // If the Check ID is not supported, we cannot calculate the check and // thus not create a proper Block. - if ((unsigned)(options->check) > LZMA_CHECK_ID_MAX) + if ((unsigned int)(block->check) > LZMA_CHECK_ID_MAX) return LZMA_PROG_ERROR; - if (!lzma_check_is_supported(options->check)) + if (!lzma_check_is_supported(block->check)) return LZMA_UNSUPPORTED_CHECK; // Allocate and initialize *next->coder if needed. @@ -193,24 +196,24 @@ lzma_block_encoder_init(lzma_next_coder *next, lzma_allocator *allocator, // Basic initializations next->coder->sequence = SEQ_CODE; - next->coder->options = options; + next->coder->block = block; next->coder->compressed_size = 0; next->coder->uncompressed_size = 0; next->coder->pos = 0; // Initialize the check - lzma_check_init(&next->coder->check, options->check); + lzma_check_init(&next->coder->check, block->check); // Initialize the requested filters. return lzma_raw_encoder_init(&next->coder->next, allocator, - options->filters); + block->filters); } extern LZMA_API lzma_ret -lzma_block_encoder(lzma_stream *strm, lzma_block *options) +lzma_block_encoder(lzma_stream *strm, lzma_block *block) { - lzma_next_strm_init(lzma_block_encoder_init, strm, options); + lzma_next_strm_init(lzma_block_encoder_init, strm, block); strm->internal->supported_actions[LZMA_RUN] = true; strm->internal->supported_actions[LZMA_FINISH] = true; diff --git a/src/liblzma/common/block_encoder.h b/src/liblzma/common/block_encoder.h index 7bc40139..d5b3ec0d 100644 --- a/src/liblzma/common/block_encoder.h +++ b/src/liblzma/common/block_encoder.h @@ -1,7 +1,7 @@ /////////////////////////////////////////////////////////////////////////////// // /// \file block_encoder.h -/// \brief Encodes .lzma Blocks +/// \brief Encodes .xz Blocks // // Copyright (C) 2007 Lasse Collin // @@ -24,6 +24,6 @@ extern lzma_ret lzma_block_encoder_init(lzma_next_coder *next, - lzma_allocator *allocator, lzma_block *options); + lzma_allocator *allocator, lzma_block *block); #endif diff --git a/src/liblzma/common/block_header_decoder.c b/src/liblzma/common/block_header_decoder.c index 8421ac37..82afb425 100644 --- a/src/liblzma/common/block_header_decoder.c +++ b/src/liblzma/common/block_header_decoder.c @@ -1,7 +1,7 @@ /////////////////////////////////////////////////////////////////////////////// // /// \file block_header_decoder.c -/// \brief Decodes Block Header from .lzma files +/// \brief Decodes Block Header from .xz files // // Copyright (C) 2007 Lasse Collin // @@ -22,15 +22,15 @@ static void -free_properties(lzma_block *options, lzma_allocator *allocator) +free_properties(lzma_block *block, lzma_allocator *allocator) { // Free allocated filter options. The last array member is not // touched after the initialization in the beginning of // lzma_block_header_decode(), so we don't need to touch that here. for (size_t i = 0; i < LZMA_FILTERS_MAX; ++i) { - lzma_free(options->filters[i].options, allocator); - options->filters[i].id = LZMA_VLI_UNKNOWN; - options->filters[i].options = NULL; + lzma_free(block->filters[i].options, allocator); + block->filters[i].id = LZMA_VLI_UNKNOWN; + block->filters[i].options = NULL; } return; @@ -38,7 +38,7 @@ free_properties(lzma_block *options, lzma_allocator *allocator) extern LZMA_API lzma_ret -lzma_block_header_decode(lzma_block *options, +lzma_block_header_decode(lzma_block *block, lzma_allocator *allocator, const uint8_t *in) { // NOTE: We consider the header to be corrupt not only when the @@ -49,18 +49,21 @@ lzma_block_header_decode(lzma_block *options, // Initialize the filter options array. This way the caller can // safely free() the options even if an error occurs in this function. for (size_t i = 0; i <= LZMA_FILTERS_MAX; ++i) { - options->filters[i].id = LZMA_VLI_UNKNOWN; - options->filters[i].options = NULL; + block->filters[i].id = LZMA_VLI_UNKNOWN; + block->filters[i].options = NULL; } + // Always zero for now. + block->version = 0; + // Validate Block Header Size and Check type. The caller must have // already set these, so it is a programming error if this test fails. - if (lzma_block_header_size_decode(in[0]) != options->header_size - || (unsigned int)(options->check) > LZMA_CHECK_ID_MAX) + if (lzma_block_header_size_decode(in[0]) != block->header_size + || (unsigned int)(block->check) > LZMA_CHECK_ID_MAX) return LZMA_PROG_ERROR; // Exclude the CRC32 field. - const size_t in_size = options->header_size - 4; + const size_t in_size = block->header_size - 4; // Verify CRC32 if (lzma_crc32(in, in_size, 0) != integer_read_32(in + in_size)) @@ -75,32 +78,32 @@ lzma_block_header_decode(lzma_block *options, // Compressed Size if (in[1] & 0x40) { - return_if_error(lzma_vli_decode(&options->compressed_size, + return_if_error(lzma_vli_decode(&block->compressed_size, NULL, in, &in_pos, in_size)); // Validate Compressed Size. This checks that it isn't zero // and that the total size of the Block is a valid VLI. - if (lzma_block_unpadded_size(options) == 0) + if (lzma_block_unpadded_size(block) == 0) return LZMA_DATA_ERROR; } else { - options->compressed_size = LZMA_VLI_UNKNOWN; + block->compressed_size = LZMA_VLI_UNKNOWN; } // Uncompressed Size if (in[1] & 0x80) - return_if_error(lzma_vli_decode(&options->uncompressed_size, + return_if_error(lzma_vli_decode(&block->uncompressed_size, NULL, in, &in_pos, in_size)); else - options->uncompressed_size = LZMA_VLI_UNKNOWN; + block->uncompressed_size = LZMA_VLI_UNKNOWN; // Filter Flags const size_t filter_count = (in[1] & 3) + 1; for (size_t i = 0; i < filter_count; ++i) { const lzma_ret ret = lzma_filter_flags_decode( - &options->filters[i], allocator, + &block->filters[i], allocator, in, &in_pos, in_size); if (ret != LZMA_OK) { - free_properties(options, allocator); + free_properties(block, allocator); return ret; } } @@ -108,7 +111,7 @@ lzma_block_header_decode(lzma_block *options, // Padding while (in_pos < in_size) { if (in[in_pos++] != 0x00) { - free_properties(options, allocator); + free_properties(block, allocator); // Possibly some new field present so use // LZMA_OPTIONS_ERROR instead of LZMA_DATA_ERROR. diff --git a/src/liblzma/common/block_header_encoder.c b/src/liblzma/common/block_header_encoder.c index b9980363..d4427c3d 100644 --- a/src/liblzma/common/block_header_encoder.c +++ b/src/liblzma/common/block_header_encoder.c @@ -1,7 +1,7 @@ /////////////////////////////////////////////////////////////////////////////// // /// \file block_header_encoder.c -/// \brief Encodes Block Header for .lzma files +/// \brief Encodes Block Header for .xz files // // Copyright (C) 2007 Lasse Collin // @@ -22,23 +22,26 @@ extern LZMA_API lzma_ret -lzma_block_header_size(lzma_block *options) +lzma_block_header_size(lzma_block *block) { + if (block->version != 0) + return LZMA_OPTIONS_ERROR; + // Block Header Size + Block Flags + CRC32. uint32_t size = 1 + 1 + 4; // Compressed Size - if (options->compressed_size != LZMA_VLI_UNKNOWN) { - const uint32_t add = lzma_vli_size(options->compressed_size); - if (add == 0 || options->compressed_size == 0) + if (block->compressed_size != LZMA_VLI_UNKNOWN) { + const uint32_t add = lzma_vli_size(block->compressed_size); + if (add == 0 || block->compressed_size == 0) return LZMA_PROG_ERROR; size += add; } // Uncompressed Size - if (options->uncompressed_size != LZMA_VLI_UNKNOWN) { - const uint32_t add = lzma_vli_size(options->uncompressed_size); + if (block->uncompressed_size != LZMA_VLI_UNKNOWN) { + const uint32_t add = lzma_vli_size(block->uncompressed_size); if (add == 0) return LZMA_PROG_ERROR; @@ -46,24 +49,23 @@ lzma_block_header_size(lzma_block *options) } // List of Filter Flags - if (options->filters == NULL - || options->filters[0].id == LZMA_VLI_UNKNOWN) + if (block->filters == NULL || block->filters[0].id == LZMA_VLI_UNKNOWN) return LZMA_PROG_ERROR; - for (size_t i = 0; options->filters[i].id != LZMA_VLI_UNKNOWN; ++i) { + for (size_t i = 0; block->filters[i].id != LZMA_VLI_UNKNOWN; ++i) { // Don't allow too many filters. if (i == LZMA_FILTERS_MAX) return LZMA_PROG_ERROR; uint32_t add; return_if_error(lzma_filter_flags_size(&add, - options->filters + i)); + block->filters + i)); size += add; } // Pad to a multiple of four bytes. - options->header_size = (size + 3) & ~UINT32_C(3); + block->header_size = (size + 3) & ~UINT32_C(3); // NOTE: We don't verify that the encoded size of the Block stays // within limits. This is because it is possible that we are called @@ -76,15 +78,15 @@ lzma_block_header_size(lzma_block *options) extern LZMA_API lzma_ret -lzma_block_header_encode(const lzma_block *options, uint8_t *out) +lzma_block_header_encode(const lzma_block *block, uint8_t *out) { // Valdidate everything but filters. - if (lzma_block_unpadded_size(options) == 0 - || !lzma_vli_is_valid(options->uncompressed_size)) + if (lzma_block_unpadded_size(block) == 0 + || !lzma_vli_is_valid(block->uncompressed_size)) return LZMA_PROG_ERROR; // Indicate the size of the buffer _excluding_ the CRC32 field. - const size_t out_size = options->header_size - 4; + const size_t out_size = block->header_size - 4; // Store the Block Header Size. out[0] = out_size / 4; @@ -94,26 +96,23 @@ lzma_block_header_encode(const lzma_block *options, uint8_t *out) size_t out_pos = 2; // Compressed Size - if (options->compressed_size != LZMA_VLI_UNKNOWN) { - return_if_error(lzma_vli_encode( - options->compressed_size, NULL, + if (block->compressed_size != LZMA_VLI_UNKNOWN) { + return_if_error(lzma_vli_encode(block->compressed_size, NULL, out, &out_pos, out_size)); out[1] |= 0x40; } // Uncompressed Size - if (options->uncompressed_size != LZMA_VLI_UNKNOWN) { - return_if_error(lzma_vli_encode( - options->uncompressed_size, NULL, + if (block->uncompressed_size != LZMA_VLI_UNKNOWN) { + return_if_error(lzma_vli_encode(block->uncompressed_size, NULL, out, &out_pos, out_size)); out[1] |= 0x80; } // Filter Flags - if (options->filters == NULL - || options->filters[0].id == LZMA_VLI_UNKNOWN) + if (block->filters == NULL || block->filters[0].id == LZMA_VLI_UNKNOWN) return LZMA_PROG_ERROR; size_t filter_count = 0; @@ -123,10 +122,10 @@ lzma_block_header_encode(const lzma_block *options, uint8_t *out) return LZMA_PROG_ERROR; return_if_error(lzma_filter_flags_encode( - options->filters + filter_count, + block->filters + filter_count, out, &out_pos, out_size)); - } while (options->filters[++filter_count].id != LZMA_VLI_UNKNOWN); + } while (block->filters[++filter_count].id != LZMA_VLI_UNKNOWN); out[1] |= filter_count - 1; diff --git a/src/liblzma/common/block_util.c b/src/liblzma/common/block_util.c index 2fa45841..1dccacf4 100644 --- a/src/liblzma/common/block_util.c +++ b/src/liblzma/common/block_util.c @@ -58,7 +58,8 @@ lzma_block_unpadded_size(const lzma_block *block) // NOTE: This function is used for validation too, so it is // essential that these checks are always done even if // Compressed Size is unknown. - if (block->header_size < LZMA_BLOCK_HEADER_SIZE_MIN + if (block->version != 0 + || block->header_size < LZMA_BLOCK_HEADER_SIZE_MIN || block->header_size > LZMA_BLOCK_HEADER_SIZE_MAX || (block->header_size & 3) || !lzma_vli_is_valid(block->compressed_size) diff --git a/src/liblzma/common/easy.c b/src/liblzma/common/easy.c index 769253f4..441e66c0 100644 --- a/src/liblzma/common/easy.c +++ b/src/liblzma/common/easy.c @@ -33,30 +33,16 @@ struct lzma_coder_s { static bool -easy_set_filters(lzma_coder *coder, uint32_t level, uint32_t flags) +easy_set_filters(lzma_coder *coder, uint32_t preset) { - // FIXME - (void)flags; + if (lzma_lzma_preset(&coder->opt_lzma, preset)) + return true; - bool error = false; + coder->filters[0].id = LZMA_FILTER_LZMA2; + coder->filters[0].options = &coder->opt_lzma; + coder->filters[1].id = LZMA_VLI_UNKNOWN; - if (level == 0) { - // TODO FIXME Use Subblock or LZMA2 with no compression. - error = true; - -#ifdef HAVE_ENCODER_LZMA2 - } else if (level <= 9) { - error = lzma_lzma_preset(&coder->opt_lzma, level); - coder->filters[0].id = LZMA_FILTER_LZMA2; - coder->filters[0].options = &coder->opt_lzma; - coder->filters[1].id = LZMA_VLI_UNKNOWN; -#endif - - } else { - error = true; - } - - return error; + return false; } @@ -83,7 +69,7 @@ easy_encoder_end(lzma_coder *coder, lzma_allocator *allocator) static lzma_ret easy_encoder_init(lzma_next_coder *next, lzma_allocator *allocator, - uint32_t level, uint32_t flags, lzma_check check) + uint32_t preset, lzma_check check) { lzma_next_coder_init(easy_encoder_init, next, allocator); @@ -98,7 +84,7 @@ easy_encoder_init(lzma_next_coder *next, lzma_allocator *allocator, next->coder->stream_encoder = LZMA_NEXT_CODER_INIT; } - if (easy_set_filters(next->coder, level, flags)) + if (easy_set_filters(next->coder, preset)) return LZMA_OPTIONS_ERROR; return lzma_stream_encoder_init(&next->coder->stream_encoder, @@ -107,10 +93,9 @@ easy_encoder_init(lzma_next_coder *next, lzma_allocator *allocator, extern LZMA_API lzma_ret -lzma_easy_encoder(lzma_stream *strm, - uint32_t level, uint32_t flags, lzma_check check) +lzma_easy_encoder(lzma_stream *strm, uint32_t preset, lzma_check check) { - lzma_next_strm_init(easy_encoder_init, strm, level, flags, check); + lzma_next_strm_init(easy_encoder_init, strm, preset, check); strm->internal->supported_actions[LZMA_RUN] = true; strm->internal->supported_actions[LZMA_SYNC_FLUSH] = true; @@ -122,10 +107,10 @@ lzma_easy_encoder(lzma_stream *strm, extern LZMA_API uint64_t -lzma_easy_encoder_memusage(uint32_t level, uint32_t flags) +lzma_easy_encoder_memusage(uint32_t preset) { lzma_coder coder; - if (easy_set_filters(&coder, level, flags)) + if (easy_set_filters(&coder, preset)) return UINT32_MAX; return lzma_memusage_encoder(coder.filters); @@ -133,10 +118,10 @@ lzma_easy_encoder_memusage(uint32_t level, uint32_t flags) extern LZMA_API uint64_t -lzma_easy_decoder_memusage(uint32_t level, uint32_t flags) +lzma_easy_decoder_memusage(uint32_t preset) { lzma_coder coder; - if (easy_set_filters(&coder, level, flags)) + if (easy_set_filters(&coder, preset)) return UINT32_MAX; return lzma_memusage_decoder(coder.filters); diff --git a/src/liblzma/common/stream_decoder.c b/src/liblzma/common/stream_decoder.c index 956a08f3..7ed5c3af 100644 --- a/src/liblzma/common/stream_decoder.c +++ b/src/liblzma/common/stream_decoder.c @@ -1,7 +1,7 @@ /////////////////////////////////////////////////////////////////////////////// // /// \file stream_decoder.c -/// \brief Decodes .lzma Streams +/// \brief Decodes .xz Streams // // Copyright (C) 2007 Lasse Collin // @@ -96,7 +96,6 @@ stream_decoder_reset(lzma_coder *coder, lzma_allocator *allocator) // Reset the rest of the variables. coder->sequence = SEQ_STREAM_HEADER; - coder->block_options.filters = NULL; coder->pos = 0; return LZMA_OK; diff --git a/src/liblzma/common/stream_decoder.h b/src/liblzma/common/stream_decoder.h index 59d58c6f..b12e21d6 100644 --- a/src/liblzma/common/stream_decoder.h +++ b/src/liblzma/common/stream_decoder.h @@ -1,7 +1,7 @@ /////////////////////////////////////////////////////////////////////////////// // /// \file stream_decoder.h -/// \brief Decodes .lzma Streams +/// \brief Decodes .xz Streams // // Copyright (C) 2008 Lasse Collin // diff --git a/src/liblzma/common/stream_encoder.c b/src/liblzma/common/stream_encoder.c index e52ad692..4400e26a 100644 --- a/src/liblzma/common/stream_encoder.c +++ b/src/liblzma/common/stream_encoder.c @@ -1,7 +1,7 @@ /////////////////////////////////////////////////////////////////////////////// // /// \file stream_encoder.c -/// \brief Encodes .lzma Streams +/// \brief Encodes .xz Streams // // Copyright (C) 2007-2008 Lasse Collin // @@ -238,6 +238,7 @@ lzma_stream_encoder_init(lzma_next_coder *next, lzma_allocator *allocator, // Basic initializations next->coder->sequence = SEQ_STREAM_HEADER; + next->coder->block_options.version = 0; next->coder->block_options.check = check; next->coder->block_options.filters = (lzma_filter *)(filters); diff --git a/src/liblzma/common/stream_encoder.h b/src/liblzma/common/stream_encoder.h index cec2e5b5..97ef83e9 100644 --- a/src/liblzma/common/stream_encoder.h +++ b/src/liblzma/common/stream_encoder.h @@ -1,7 +1,7 @@ /////////////////////////////////////////////////////////////////////////////// // /// \file stream_encoder.h -/// \brief Encodes .lzma Streams +/// \brief Encodes .xz Streams // // Copyright (C) 2008 Lasse Collin // diff --git a/src/liblzma/common/stream_flags_decoder.c b/src/liblzma/common/stream_flags_decoder.c index 48379e53..50463096 100644 --- a/src/liblzma/common/stream_flags_decoder.c +++ b/src/liblzma/common/stream_flags_decoder.c @@ -1,7 +1,7 @@ /////////////////////////////////////////////////////////////////////////////// // /// \file stream_flags_decoder.c -/// \brief Decodes Stream Header and Stream Footer from .lzma files +/// \brief Decodes Stream Header and Stream Footer from .xz files // // Copyright (C) 2007 Lasse Collin // diff --git a/src/liblzma/common/stream_flags_encoder.c b/src/liblzma/common/stream_flags_encoder.c index e73a5133..21c62ffd 100644 --- a/src/liblzma/common/stream_flags_encoder.c +++ b/src/liblzma/common/stream_flags_encoder.c @@ -1,7 +1,7 @@ /////////////////////////////////////////////////////////////////////////////// // /// \file stream_flags_encoder.c -/// \brief Encodes Stream Header and Stream Footer for .lzma files +/// \brief Encodes Stream Header and Stream Footer for .xz files // // Copyright (C) 2007 Lasse Collin // diff --git a/src/liblzma/lzma/lzma_encoder.c b/src/liblzma/lzma/lzma_encoder.c index 57ba87f3..70fd93eb 100644 --- a/src/liblzma/lzma/lzma_encoder.c +++ b/src/liblzma/lzma/lzma_encoder.c @@ -668,7 +668,7 @@ lzma_lzma_props_encode(const void *options, uint8_t *out) extern LZMA_API lzma_bool -lzma_mode_is_available(lzma_mode mode) +lzma_mode_is_supported(lzma_mode mode) { return mode == LZMA_MODE_FAST || mode == LZMA_MODE_NORMAL; } diff --git a/src/liblzma/lzma/lzma_encoder_presets.c b/src/liblzma/lzma/lzma_encoder_presets.c index b48e0698..31928d61 100644 --- a/src/liblzma/lzma/lzma_encoder_presets.c +++ b/src/liblzma/lzma/lzma_encoder_presets.c @@ -20,47 +20,18 @@ #include "common.h" -/* -#define pow2(e) (UINT32_C(1) << (e)) - - -static const lzma_options_lzma presets[9] = { -// dict lc lp pb mode fb mf mfc -{ pow2(16), NULL, 0, 3, 0, 2, false, LZMA_MODE_FAST, 64, LZMA_MF_HC3, 0, 0, 0, 0, 0, NULL, NULL }, -{ pow2(20), NULL, 0, 3, 0, 0, false, LZMA_MODE_FAST, 64, LZMA_MF_HC4, 0, 0, 0, 0, 0, NULL, NULL }, -{ pow2(19), NULL, 0, 3, 0, 0, false, LZMA_MODE_NORMAL, 64, LZMA_MF_BT4, 0, 0, 0, 0, 0, NULL, NULL }, -{ pow2(20), NULL, 0, 3, 0, 0, false, LZMA_MODE_NORMAL, 64, LZMA_MF_BT4, 0, 0, 0, 0, 0, NULL, NULL }, -{ pow2(21), NULL, 0, 3, 0, 0, false, LZMA_MODE_NORMAL, 128, LZMA_MF_BT4, 0, 0, 0, 0, 0, NULL, NULL }, -{ pow2(22), NULL, 0, 3, 0, 0, false, LZMA_MODE_NORMAL, 128, LZMA_MF_BT4, 0, 0, 0, 0, 0, NULL, NULL }, -{ pow2(23), NULL, 0, 3, 0, 0, false, LZMA_MODE_NORMAL, 128, LZMA_MF_BT4, 0, 0, 0, 0, 0, NULL, NULL }, -{ pow2(24), NULL, 0, 3, 0, 0, false, LZMA_MODE_NORMAL, 273, LZMA_MF_BT4, 0, 0, 0, 0, 0, NULL, NULL }, -{ pow2(25), NULL, 0, 3, 0, 0, false, LZMA_MODE_NORMAL, 273, LZMA_MF_BT4, 0, 0, 0, 0, 0, NULL, NULL }, -}; - - extern LZMA_API lzma_bool -lzma_lzma_preset(lzma_options_lzma *options, uint32_t level) +lzma_lzma_preset(lzma_options_lzma *options, uint32_t preset) { - if (level >= ARRAY_SIZE(presetes)) - return true; + const uint32_t level = preset & LZMA_PRESET_LEVEL_MASK; + const uint32_t flags = preset & ~LZMA_PRESET_LEVEL_MASK; + const uint32_t supported_flags = LZMA_PRESET_EXTREME; - *options = presets[level]; - return false; -} -*/ - - -extern LZMA_API lzma_bool -lzma_lzma_preset(lzma_options_lzma *options, uint32_t level) -{ - if (level == 0 || level > 9) + if (level > 9 || (flags & ~supported_flags)) return true; - --level; - memzero(options, sizeof(*options)); - - static const uint8_t shift[9] = { 16, 20, 19, 20, 21, 22, 23, 24, 25 }; - options->dict_size = UINT32_C(1) << shift[level]; + 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; @@ -72,10 +43,18 @@ lzma_lzma_preset(lzma_options_lzma *options, uint32_t level) options->persistent = false; options->mode = level <= 2 ? LZMA_MODE_FAST : LZMA_MODE_NORMAL; - options->nice_len = level <= 5 ? 32 : 64; + 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 (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; + } + return false; } |