 |
Parolin 0.7.9 6796
Console (soon DLLs) to do a tar like job
|
Loading...
Searching...
No Matches
|
Parolin 0.7.9 6796
Console (soon DLLs) to do a tar like job
|
Go to the source code of this file.
Data Structures | |
| struct | lzma_allocator |
| Custom functions for memory handling. More... | |
| struct | lzma_stream |
| Passing data to and from liblzma. More... | |
Macros | |
| #define | LZMA_STREAM_INIT |
| Initialization for lzma_stream. | |
Typedefs | |
| typedef unsigned char | lzma_bool |
| Boolean. | |
| typedef struct lzma_internal_s | lzma_internal |
| Internal data structure. | |
Enumerations | |
| enum | lzma_reserved_enum { LZMA_RESERVED_ENUM = 0 } |
| Type of reserved enumeration variable in structures. More... | |
| enum | lzma_ret { LZMA_OK = 0 , LZMA_STREAM_END = 1 , LZMA_NO_CHECK = 2 , LZMA_UNSUPPORTED_CHECK = 3 , LZMA_GET_CHECK = 4 , LZMA_MEM_ERROR = 5 , LZMA_MEMLIMIT_ERROR = 6 , LZMA_FORMAT_ERROR = 7 , LZMA_OPTIONS_ERROR = 8 , LZMA_DATA_ERROR = 9 , LZMA_BUF_ERROR = 10 , LZMA_PROG_ERROR = 11 } |
| Return values used by several functions in liblzma. More... | |
| enum | lzma_action { LZMA_RUN = 0 , LZMA_SYNC_FLUSH = 1 , LZMA_FULL_FLUSH = 2 , LZMA_FULL_BARRIER = 4 , LZMA_FINISH = 3 } |
| The ‘action’ argument for lzma_code() More... | |
Functions | |
| LZMA_API (lzma_ret) lzma_code(lzma_stream *strm | |
| Encode or decode data. | |
| LZMA_API (void) lzma_end(lzma_stream *strm) lzma_nothrow | |
| Free memory allocated for the coder data structures. | |
| LZMA_API (uint64_t) lzma_memusage(const lzma_stream *strm) lzma_nothrow lzma_attr_pure | |
| Get the memory usage of decoder filter chain. | |
Variables | |
| lzma_action action lzma_nothrow | lzma_attr_warn_unused_result |
| uint64_t * | progress_in |
| uint64_t uint64_t *progress_out | lzma_nothrow |
| #define LZMA_STREAM_INIT |
Initialization for lzma_stream.
When you declare an instance of lzma_stream, you can immediately initialize it so that initialization functions know that no memory has been allocated yet:
lzma_stream strm = LZMA_STREAM_INIT;
If you need to initialize a dynamically allocated lzma_stream, you can use memset(strm_pointer, 0, sizeof(lzma_stream)). Strictly speaking, this violates the C standard since NULL may have different internal representation than zero, but it should be portable enough in practice. Anyway, for maximum portability, you can use something like this:
lzma_stream tmp = LZMA_STREAM_INIT; *strm = tmp;
| typedef unsigned char lzma_bool |
Boolean.
This is here because C89 doesn't have stdbool.h. To set a value for variables having type lzma_bool, you can use
This is here because C89 doesn't have stdbool.h. To set a value for variables having type lzma_bool, you can use
| typedef struct lzma_internal_s lzma_internal |
Internal data structure.
The contents of this structure is not visible outside the library.
| enum lzma_action |
The ‘action’ argument for lzma_code()
After the first use of LZMA_SYNC_FLUSH, LZMA_FULL_FLUSH, LZMA_FULL_BARRIER, or LZMA_FINISH, the same ‘action’ must is used until lzma_code() returns LZMA_STREAM_END. Also, the amount of input (that is, strm->avail_in) must not be modified by the application until lzma_code() returns LZMA_STREAM_END. Changing the ‘action’ or modifying the amount of input will make lzma_code() return LZMA_PROG_ERROR.
| Enumerator | |
|---|---|
| LZMA_RUN | Continue coding. Encoder: Encode as much input as possible. Some internal buffering will probably be done (depends on the filter chain in use), which causes latency: the input used won't usually be decodeable from the output of the same lzma_code() call. Decoder: Decode as much input as possible and produce as much output as possible. |
| LZMA_SYNC_FLUSH | Make all the input available at output. Normally the encoder introduces some latency. LZMA_SYNC_FLUSH forces all the buffered data to be available at output without resetting the internal state of the encoder. This way it is possible to use compressed stream for example for communication over network. Only some filters support LZMA_SYNC_FLUSH. Trying to use LZMA_SYNC_FLUSH with filters that don't support it will make lzma_code() return LZMA_OPTIONS_ERROR. For example, LZMA1 doesn't support LZMA_SYNC_FLUSH but LZMA2 does. Using LZMA_SYNC_FLUSH very often can dramatically reduce the compression ratio. With some filters (for example, LZMA2), fine-tuning the compression options may help mitigate this problem significantly (for example, match finder with LZMA2). Decoders don't support LZMA_SYNC_FLUSH. |
| LZMA_FULL_FLUSH | Finish encoding of the current Block. All the input data going to the current Block must have been given to the encoder (the last bytes can still be pending in *next_in). Call lzma_code() with LZMA_FULL_FLUSH until it returns LZMA_STREAM_END. Then continue normally with LZMA_RUN or finish the Stream with LZMA_FINISH. This action is currently supported only by Stream encoder and easy encoder (which uses Stream encoder). If there is no unfinished Block, no empty Block is created. |
| LZMA_FULL_BARRIER | Finish encoding of the current Block. This is like LZMA_FULL_FLUSH except that this doesn't necessarily wait until all the input has been made available via the output buffer. That is, lzma_code() might return LZMA_STREAM_END as soon as all the input has been consumed (avail_in == 0). LZMA_FULL_BARRIER is useful with a threaded encoder if one wants to split the .xz Stream into Blocks at specific offsets but doesn't care if the output isn't flushed immediately. Using LZMA_FULL_BARRIER allows keeping the threads busy while LZMA_FULL_FLUSH would make lzma_code() wait until all the threads have finished until more data could be passed to the encoder. With a lzma_stream initialized with the single-threaded lzma_stream_encoder() or lzma_easy_encoder(), LZMA_FULL_BARRIER is an alias for LZMA_FULL_FLUSH. |
| LZMA_FINISH | Finish the coding operation. All the input data must have been given to the encoder (the last bytes can still be pending in next_in). Call lzma_code() with LZMA_FINISH until it returns LZMA_STREAM_END. Once LZMA_FINISH has been used, the amount of input must no longer be changed by the application. When decoding, using LZMA_FINISH is optional unless the LZMA_CONCATENATED flag was used when the decoder was initialized. When LZMA_CONCATENATED was not used, the only effect of LZMA_FINISH is that the amount of input must not be changed just like in the encoder. |
| enum lzma_reserved_enum |
Type of reserved enumeration variable in structures.
To avoid breaking library ABI when new features are added, several structures contain extra variables that may be used in future. Since sizeof(enum) can be different than sizeof(int), and sizeof(enum) may even vary depending on the range of enumeration constants, we specify a separate type to be used for reserved enumeration variables. All enumeration constants in liblzma API will be non-negative and less than 128, which should guarantee that the ABI won't break even when new constants are added to existing enumerations.
| Enumerator | |
|---|---|
| LZMA_RESERVED_ENUM | |
| enum lzma_ret |
Return values used by several functions in liblzma.
Check the descriptions of specific functions to find out which return values they can return. With some functions the return values may have more specific meanings than described here; those differences are described per-function basis.
|
extern |
Encode or decode data.
Initialize a .xz file information decoder.
List available filters and/or their options (for help message)
Convert a filter chain to a string.
MicroLZMA decoder.
Initialize .lz (lzip) decoder (a foreign file format)
Decode .xz, .lzma, and .lz (lzip) files with autodetection.
Initialize multithreaded .xz Stream decoder.
MicroLZMA encoder.
Decode a variable-length integer.
Compare two lzma_stream_flags structures.
Decode Stream Footer.
Decode Stream Header.
Encode Stream Footer.
Decode and validate the Index field.
Single-call .xz Index decoder.
Single-call .xz Index encoder.
Initialize .xz Index decoder.
Initialize .xz Index encoder.
Concatenate lzma_indexes.
Set the amount of Stream Padding.
Set the Stream Flags.
Decode Filter Flags from given buffer.
Encode Filter Flags into given buffer.
Calculate encoded size of a Filter Flags field.
Decode the Filter Properties field.
Encode the Filter Properties field.
Get the size of the Filter Properties field.
Single-call raw decoder.
Single-call raw encoder.
Update the filter chain in the encoder.
Initialize raw decoder.
Initialize raw encoder.
Single-call .xz Stream decoder.
Initialize .lzma decoder (legacy file format)
Decode .xz Streams and .lzma files with autodetection.
Initialize .xz Stream decoder.
Single-call .xz Stream encoder.
Initialize .lzma encoder (legacy file format)
Initialize multithreaded .xz Stream encoder.
Initialize .xz Stream encoder using a custom filter chain.
Single-call .xz Stream encoding using a preset number.
Single-call .xz Block decoder.
Single-call uncompressed .xz Block encoder.
Single-call .xz Block encoder.
Initialize .xz Block decoder.
Initialize .xz Block encoder.
Validate and set Compressed Size according to Unpadded Size.
Decode Block Header.
Encode Block Header.
Set the memory usage limit.
Once the lzma_stream has been successfully initialized (e.g. with lzma_stream_encoder()), the actual encoding or decoding is done using this function. The application has to update strm->next_in, strm->avail_in, strm->next_out, and strm->avail_out to pass input to and get output from liblzma.
See the description of the coder-specific initialization function to find out what ‘action’ values are supported by the coder.
This function is supported only when *strm has been initialized with a function that takes a memlimit argument.
liblzma 5.2.3 and earlier has a bug where memlimit value of 0 causes this function to do nothing (leaving the limit unchanged) and still return LZMA_OK. Later versions treat 0 as if 1 had been specified (so lzma_memlimit_get() will return 1 even if you specify 0 here).
The caller must have calculated the size of the Block Header already with lzma_block_header_size(). If a value larger than the one calculated by lzma_block_header_size() is used, the Block Header will be padded to the specified size.
| out | Beginning of the output buffer. This must be at least block->header_size bytes. |
| block | Block options to be encoded. |
block->version should (usually) be set to the highest value supported by the application. If the application sets block->version to a value higher than supported by the current liblzma version, this function will downgrade block->version to the highest value supported by it. Thus one should check the value of block->version after calling this function if block->version was set to a non-zero value and the application doesn't otherwise know that the liblzma version being used is new enough to support the specified block->version.
The size of the Block Header must have already been decoded with lzma_block_header_size_decode() macro and stored to block->header_size.
The integrity check type from Stream Header must have been stored to block->check.
block->filters must have been allocated, but they don't need to be initialized (possible existing filter options are not freed).
| block | Destination for Block options. |
| allocator | lzma_allocator for custom allocator functions. Set to NULL to use malloc() (and also free() if an error occurs). |
| in | Beginning of the input buffer. This must be at least block->header_size bytes. |
Block Header stores Compressed Size, but Index has Unpadded Size. If the application has already parsed the Index and is now decoding Blocks, it can calculate Compressed Size from Unpadded Size. This function does exactly that with error checking:
Valid actions for lzma_code() are LZMA_RUN, LZMA_SYNC_FLUSH (only if the filter chain supports it), and LZMA_FINISH.
Valid actions for lzma_code() are LZMA_RUN and LZMA_FINISH. Using LZMA_FINISH is not required. It is supported only for convenience.
In contrast to the multi-call encoder initialized with lzma_block_encoder(), this function encodes also the Block Header. This is required to make it possible to write appropriate Block Header also in case the data isn't compressible, and different filter chain has to be used to encode the data in uncompressed form using uncompressed chunks of the LZMA2 filter.
When the data isn't compressible, header_size, compressed_size, and uncompressed_size are set just like when the data was compressible, but it is possible that header_size is too small to hold the filter chain specified in block->filters, because that isn't necessarily the filter chain that was actually used to encode the data. lzma_block_unpadded_size() still works normally, because it doesn't read the filters array.
| block | Block options: block->version, block->check, and block->filters must have been initialized. |
| allocator | lzma_allocator for custom allocator functions. Set to NULL to use malloc() and free(). |
| in | Beginning of the input buffer |
| in_size | Size of the input buffer |
| out | Beginning of the output buffer |
| out_pos | The next byte will be written to out[*out_pos]. *out_pos is updated only if encoding succeeds. |
| out_size | Size of the out buffer; the first byte into which no data is written to is out[out_size]. |
This is like lzma_block_buffer_encode() except this doesn't try to compress the data and instead encodes the data using LZMA2 uncompressed chunks. The required output buffer size can be determined with lzma_block_buffer_bound().
Since the data won't be compressed, this function ignores block->filters. This function doesn't take lzma_allocator because this function doesn't allocate any memory from the heap.
This is single-call equivalent of lzma_block_decoder(), and requires that the caller has already decoded Block Header and checked its memory usage.
| block | Block options just like with lzma_block_decoder(). |
| allocator | lzma_allocator for custom allocator functions. Set to NULL to use malloc() and free(). |
| in | Beginning of the input buffer |
| in_pos | The next byte will be read from in[*in_pos]. *in_pos is updated only if decoding succeeds. |
| in_size | Size of the input buffer; the first byte that won't be read is in[in_size]. |
| out | Beginning of the output buffer |
| out_pos | The next byte will be written to out[*out_pos]. *out_pos is updated only if encoding succeeds. |
| out_size | Size of the out buffer; the first byte into which no data is written to is out[out_size]. |
The maximum required output buffer size can be calculated with lzma_stream_buffer_bound().
| preset | Compression preset to use. See the description in lzma_easy_encoder(). |
| check | Type of the integrity check to calculate from uncompressed data. |
| allocator | lzma_allocator for custom allocator functions. Set to NULL to use malloc() and free(). |
| in | Beginning of the input buffer |
| in_size | Size of the input buffer |
| out | Beginning of the output buffer |
| out_pos | The next byte will be written to out[*out_pos]. *out_pos is updated only if encoding succeeds. |
| out_size | Size of the out buffer; the first byte into which no data is written to is out[out_size]. |
| strm | Pointer to properly prepared lzma_stream |
| filters | Array of filters. This must be terminated with filters[n].id = LZMA_VLI_UNKNOWN. See filter.h for more information. |
| check | Type of the integrity check to calculate from uncompressed data. |
This provides the functionality of lzma_easy_encoder() and lzma_stream_encoder() as a single function for multithreaded use.
The supported actions for lzma_code() are LZMA_RUN, LZMA_FULL_FLUSH, LZMA_FULL_BARRIER, and LZMA_FINISH. Support for LZMA_SYNC_FLUSH might be added in the future.
| strm | Pointer to properly prepared lzma_stream |
| options | Pointer to multithreaded compression options |
The .lzma format is sometimes called the LZMA_Alone format, which is the reason for the name of this function. The .lzma format supports only the LZMA1 filter. There is no support for integrity checks like CRC32.
Use this function if and only if you need to create files readable by legacy LZMA tools such as LZMA Utils 4.32.x. Moving to the .xz format is strongly recommended.
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.
| filters | Array of filters. This must be terminated with filters[n].id = LZMA_VLI_UNKNOWN. See filter.h for more information. |
| check | Type of the integrity check to calculate from uncompressed data. |
| allocator | lzma_allocator for custom allocator functions. Set to NULL to use malloc() and free(). |
| in | Beginning of the input buffer |
| in_size | Size of the input buffer |
| out | Beginning of the output buffer |
| out_pos | The next byte will be written to out[*out_pos]. *out_pos is updated only if encoding succeeds. |
| out_size | Size of the out buffer; the first byte into which no data is written to is out[out_size]. |
| strm | Pointer to properly prepared lzma_stream |
| memlimit | Memory usage limit as bytes. Use UINT64_MAX to effectively disable the limiter. liblzma 5.2.3 and earlier don't allow 0 here and return LZMA_PROG_ERROR; later versions treat 0 as if 1 had been specified. |
| flags | Bitwise-or of zero or more of the decoder flags: LZMA_TELL_NO_CHECK, LZMA_TELL_UNSUPPORTED_CHECK, LZMA_TELL_ANY_CHECK, LZMA_CONCATENATED |
This decoder autodetects between the .xz and .lzma file formats, and calls lzma_stream_decoder() or lzma_alone_decoder() once the type of the input file has been detected.
| strm | Pointer to properly prepared lzma_stream |
| memlimit | Memory usage limit as bytes. Use UINT64_MAX to effectively disable the limiter. liblzma 5.2.3 and earlier don't allow 0 here and return LZMA_PROG_ERROR; later versions treat 0 as if 1 had been specified. |
| flags | Bitwise-or of flags, or zero for no flags. |
| strm | Pointer to properly prepared lzma_stream |
| memlimit | Memory usage limit as bytes. Use UINT64_MAX to effectively disable the limiter. liblzma 5.2.3 and earlier don't allow 0 here and return LZMA_PROG_ERROR; later versions treat 0 as if 1 had been specified. |
Valid ‘action’ arguments to lzma_code() are LZMA_RUN and LZMA_FINISH. There is no need to use LZMA_FINISH, but it's allowed because it may simplify certain types of applications.
| memlimit | Pointer to how much memory the decoder is allowed to allocate. The value pointed by this pointer is modified if and only if LZMA_MEMLIMIT_ERROR is returned. |
| flags | Bitwise-or of zero or more of the decoder flags: LZMA_TELL_NO_CHECK, LZMA_TELL_UNSUPPORTED_CHECK, LZMA_CONCATENATED. Note that LZMA_TELL_ANY_CHECK is not allowed and will return LZMA_PROG_ERROR. |
| allocator | lzma_allocator for custom allocator functions. Set to NULL to use malloc() and free(). |
| in | Beginning of the input buffer |
| in_pos | The next byte will be read from in[*in_pos]. *in_pos is updated only if decoding succeeds. |
| in_size | Size of the input buffer; the first byte that won't be read is in[in_size]. |
| out | Beginning of the output buffer |
| out_pos | The next byte will be written to out[*out_pos]. *out_pos is updated only if decoding succeeds. |
| out_size | Size of the out buffer; the first byte into which no data is written to is out[out_size]. |
This function may be useful when implementing custom file formats.
| strm | Pointer to properly prepared lzma_stream |
| filters | Array of lzma_filter structures. The end of the array must be marked with .id = LZMA_VLI_UNKNOWN. |
The ‘action’ with lzma_code() can be LZMA_RUN, LZMA_SYNC_FLUSH (if the filter chain supports it), or LZMA_FINISH.
The initialization of raw decoder goes similarly to raw encoder.
The ‘action’ with lzma_code() can be LZMA_RUN or LZMA_FINISH. Using LZMA_FINISH is not required, it is supported just for convenience.
This function is for advanced users only. This function has two slightly different purposes:
While rarely useful, this function may be called also when no data has been compressed yet. In that case, this function will behave as if LZMA_FULL_FLUSH (Stream encoder) or LZMA_SYNC_FLUSH (Raw or Block encoder) had been used right before calling this function.
| filters | Array of lzma_filter structures. The end of the array must be marked with .id = LZMA_VLI_UNKNOWN. |
| allocator | lzma_allocator for custom allocator functions. Set to NULL to use malloc() and free(). |
| in | Beginning of the input buffer |
| in_size | Size of the input buffer |
| out | Beginning of the output buffer |
| out_pos | The next byte will be written to out[*out_pos]. *out_pos is updated only if encoding succeeds. |
| out_size | Size of the out buffer; the first byte into which no data is written to is out[out_size]. |
| filters | Array of lzma_filter structures. The end of the array must be marked with .id = LZMA_VLI_UNKNOWN. |
| allocator | lzma_allocator for custom allocator functions. Set to NULL to use malloc() and free(). |
| in | Beginning of the input buffer |
| in_pos | The next byte will be read from in[*in_pos]. *in_pos is updated only if decoding succeeds. |
| in_size | Size of the input buffer; the first byte that won't be read is in[in_size]. |
| out | Beginning of the output buffer |
| out_pos | The next byte will be written to out[*out_pos]. *out_pos is updated only if encoding succeeds. |
| out_size | Size of the out buffer; the first byte into which no data is written to is out[out_size]. |
This function may be useful when implementing custom file formats using the raw encoder and decoder.
| size | Pointer to uint32_t to hold the size of the properties |
| filter | Filter ID and options (the size of the properties may vary depending on the options) |
| filter | Filter ID and options |
| props | Buffer to hold the encoded options. The size of buffer must have been already determined with lzma_properties_size(). |
| filter | filter->id must have been set to the correct Filter ID. filter->options doesn't need to be initialized (it's not freed by this function). The decoded options will be stored in filter->options; it's application's responsibility to free it when appropriate. filter->options is set to NULL if there are no properties or if an error occurs. |
| allocator | Custom memory allocator used to allocate the options. Set to NULL to use the default malloc(), and in case of an error, also free(). |
| props | Input buffer containing the properties. |
| props_size | Size of the properties. This must be the exact size; giving too much or too little input will return LZMA_OPTIONS_ERROR. |
Knowing the size of Filter Flags is useful to know when allocating memory to hold the encoded Filter Flags.
| size | Pointer to integer to hold the calculated size |
| filter | Filter ID and associated options whose encoded size is to be calculated |
In contrast to some functions, this doesn't allocate the needed buffer. This is due to how this function is used internally by liblzma.
| filter | Filter ID and options to be encoded |
| out | Beginning of the output buffer |
| out_pos | out[*out_pos] is the next write position. This is updated by the encoder. |
| out_size | out[out_size] is the first byte to not write. |
The decoded result is stored into *filter. The old value of filter->options is not free()d.
Set the Stream Flags of the last (and typically the only) Stream in lzma_index. This can be useful when reading information from the lzma_index, because to decode Blocks, knowing the integrity check type is needed.
The given Stream Flags are copied into internal preallocated structure in the lzma_index, thus the caller doesn't need to keep the *stream_flags available after calling this function.
Set the amount of Stream Padding of the last (and typically the only) Stream in the lzma_index. This is needed when planning to do random-access reading within multiple concatenated Streams.
By default, the amount of Stream Padding is assumed to be zero bytes.
Concatenating lzma_indexes is useful when doing random-access reading in multi-Stream .xz file, or when combining multiple Streams into single Stream.
| dest | lzma_index after which src is appended |
| src | lzma_index to be appended after dest. If this function succeeds, the memory allocated for src is freed or moved to be part of dest, and all iterators pointing to src will become invalid. |
| allocator | Custom memory allocator; can be NULL to use malloc() and free(). |
| strm | Pointer to properly prepared lzma_stream |
| i | Pointer to lzma_index which should be encoded. |
The valid ‘action’ values for lzma_code() are LZMA_RUN and LZMA_FINISH. It is enough to use only one of them (you can choose freely).
| strm | Pointer to properly prepared lzma_stream |
| i | The decoded Index will be made available via this pointer. Initially this function will set *i to NULL (the old value is ignored). If decoding succeeds (lzma_code() returns LZMA_STREAM_END), *i will be set to point to a new lzma_index, which the application has to later free with lzma_index_end(). |
| memlimit | How much memory the resulting lzma_index is allowed to require. liblzma 5.2.3 and earlier don't allow 0 here and return LZMA_PROG_ERROR; later versions treat 0 as if 1 had been specified. |
Valid ‘action’ arguments to lzma_code() are LZMA_RUN and LZMA_FINISH. There is no need to use LZMA_FINISH, but it's allowed because it may simplify certain types of applications.
liblzma 5.2.3 and older list also LZMA_MEMLIMIT_ERROR here but that error code has never been possible from this initialization function.
| i | lzma_index to be encoded |
| out | Beginning of the output buffer |
| out_pos | The next byte will be written to out[*out_pos]. *out_pos is updated only if encoding succeeds. |
| out_size | Size of the out buffer; the first byte into which no data is written to is out[out_size]. |
| i | If decoding succeeds, *i will point to a new lzma_index, which the application has to later free with lzma_index_end(). If an error occurs, *i will be NULL. The old value of *i is always ignored and thus doesn't need to be initialized by the caller. |
| memlimit | Pointer to how much memory the resulting lzma_index is allowed to require. The value pointed by this pointer is modified if and only if LZMA_MEMLIMIT_ERROR is returned. |
| allocator | Pointer to lzma_allocator, or NULL to use malloc() |
| in | Beginning of the input buffer |
| in_pos | The next byte will be read from in[*in_pos]. *in_pos is updated only if decoding succeeds. |
| in_size | Size of the input buffer; the first byte that won't be read is in[in_size]. |
After telling the sizes of all Blocks with lzma_index_hash_append(), the actual Index field is decoded with this function. Specifically, once decoding of the Index field has been started, no more Records can be added using lzma_index_hash_append().
This function doesn't use lzma_stream structure to pass the input data. Instead, the input buffer is specified using three arguments. This is because it matches better the internal APIs of liblzma.
| index_hash | Pointer to a lzma_index_hash structure |
| in | Pointer to the beginning of the input buffer |
| in_pos | in[*in_pos] is the next byte to process |
| in_size | in[in_size] is the first byte not to process |
| options | Stream Footer options to be encoded. |
| out | Beginning of the output buffer of LZMA_STREAM_HEADER_SIZE bytes. |
| options | Target for the decoded Stream Header options. |
| in | Beginning of the input buffer of LZMA_STREAM_HEADER_SIZE bytes. |
options->backward_size is always set to LZMA_VLI_UNKNOWN. This is to help comparing Stream Flags from Stream Header and Stream Footer with lzma_stream_flags_compare().
For example, Stream decoder in liblzma uses LZMA_DATA_ERROR if LZMA_FORMAT_ERROR is returned by lzma_stream_header_decode() when decoding non-first Stream.
| options | Target for the decoded Stream Header options. |
| in | Beginning of the input buffer of LZMA_STREAM_HEADER_SIZE bytes. |
backward_size values are compared only if both are not LZMA_VLI_UNKNOWN.
Like lzma_vli_encode(), this function has single-call and multi-call modes.
| vli | Pointer to decoded integer. The decoder will initialize it to zero when *vli_pos == 0, so application isn't required to initialize *vli. |
| vli_pos | How many bytes have already been decoded. When starting to decode a new integer in multi-call mode, *vli_pos must be initialized to zero. To use single-call decoding, set vli_pos to NULL. |
| in | Beginning of the input buffer |
| in_pos | The next byte will be read from in[*in_pos]. |
| in_size | Size of the input buffer; the first byte that won't be read is in[in_size]. |
Single-call (vli_pos == NULL):
Multi-call (vli_pos != NULL):
This function is supported only when *strm has been initialized with a function that takes a memlimit argument.
liblzma 5.2.3 and earlier has a bug where memlimit value of 0 causes this function to do nothing (leaving the limit unchanged) and still return LZMA_OK. Later versions treat 0 as if 1 had been specified (so lzma_memlimit_get() will return 1 even if you specify 0 here).
liblzma 5.2.6 and earlier had a bug in single-threaded .xz decoder (lzma_stream_decoder()) which made it impossible to continue decoding after LZMA_MEMLIMIT_ERROR even if the limit was increased using lzma_memlimit_set(). Other decoders worked correctly.
Valid actions for lzma_code() are LZMA_RUN and LZMA_FINISH. Using LZMA_FINISH is not required. It is supported only for convenience.
The MicroLZMA format is a raw LZMA stream whose first byte (always 0x00) has been replaced with bitwise-negation of the LZMA properties (lc/lp/pb). This encoding ensures that the first byte of MicroLZMA stream is never 0x00. There is no end of payload marker and thus the uncompressed size must be stored separately. For the best error detection the dictionary size should be stored separately as well but alternatively one may use the uncompressed size as the dictionary size when decoding.
With the MicroLZMA encoder, lzma_code() behaves slightly unusually. The action argument must be LZMA_FINISH and the return value will never be LZMA_OK. Thus the encoding is always done with a single lzma_code() after the initialization. The benefit of the combination of initialization function and lzma_code() is that memory allocations can be re-used for better performance.
lzma_code() will try to encode as much input as is possible to fit into the given output buffer. If not all input can be encoded, the stream will be finished without encoding all the input. The caller must check both input and output buffer usage after lzma_code() (total_in and total_out in lzma_stream can be convenient). Often lzma_code() can fill the output buffer completely if there is a lot of input, but sometimes a few bytes may remain unused because the next LZMA symbol would require more space.
lzma_stream.avail_out must be at least 6. Otherwise LZMA_PROG_ERROR will be returned.
The LZMA dictionary should be reasonably low to speed up the encoder re-initialization. A good value is bigger than the resulting uncompressed size of most of the output chunks. For example, if output size is 4 KiB, dictionary size of 32 KiB or 64 KiB is good. If the data compresses extremely well, even 128 KiB may be useful.
The MicroLZMA format and this encoder variant were made with the EROFS file system in mind. This format may be convenient in other embedded uses too where many small streams are needed. XZ Embedded includes a decoder for this format.
| strm | Pointer to properly prepared lzma_stream |
| memlimit | Memory usage limit as bytes. Use UINT64_MAX to effectively disable the limiter. liblzma 5.2.3 and earlier don't allow 0 here and return LZMA_PROG_ERROR; later versions treat 0 as if 1 had been specified. |
| flags | Bitwise-or of zero or more of the decoder flags: LZMA_TELL_NO_CHECK, LZMA_TELL_UNSUPPORTED_CHECK, LZMA_TELL_ANY_CHECK, LZMA_IGNORE_CHECK, LZMA_CONCATENATED, LZMA_FAIL_FAST |
| strm | Pointer to properly prepared lzma_stream |
| options | Pointer to multithreaded compression options |
The decoder can decode multiple Blocks in parallel. This requires that each Block Header contains the Compressed Size and Uncompressed size fields which are added by the multi-threaded encoder, see lzma_stream_encoder_mt().
A Stream with one Block will only utilize one thread. A Stream with multiple Blocks but without size information in Block Headers will be processed in single-threaded mode in the same way as done by lzma_stream_decoder(). Concatenated Streams are processed one Stream at a time; no inter-Stream parallelization is done.
This function behaves like lzma_stream_decoder() when options->threads == 1 and options->memlimit_threading <= 1.
This decoder autodetects between the .xz, .lzma, and .lz file formats, and calls lzma_stream_decoder(), lzma_alone_decoder(), or lzma_lzip_decoder() once the type of the input file has been detected.
Support for .lz was added in 5.4.0.
If the flag LZMA_CONCATENATED is used and the input is a .lzma file: For historical reasons concatenated .lzma files aren't supported. If there is trailing data after one .lzma stream, lzma_code() will return LZMA_DATA_ERROR. (lzma_alone_decoder() doesn't have such a check as it doesn't support any decoder flags. It will return LZMA_STREAM_END after one .lzma stream.)
| strm | Pointer to properly prepared lzma_stream |
| memlimit | Memory usage limit as bytes. Use UINT64_MAX to effectively disable the limiter. liblzma 5.2.3 and earlier don't allow 0 here and return LZMA_PROG_ERROR; later versions treat 0 as if 1 had been specified. |
| flags | Bitwise-or of zero or more of the decoder flags: LZMA_TELL_NO_CHECK, LZMA_TELL_UNSUPPORTED_CHECK, LZMA_TELL_ANY_CHECK, LZMA_IGNORE_CHECK, LZMA_CONCATENATED, LZMA_FAIL_FAST |
| strm | Pointer to properly prepared lzma_stream |
| memlimit | Memory usage limit as bytes. Use UINT64_MAX to effectively disable the limiter. |
| flags | Bitwise-or of flags, or zero for no flags. All decoder flags listed above are supported although only LZMA_CONCATENATED and (in very rare cases) LZMA_IGNORE_CHECK are actually useful. LZMA_TELL_NO_CHECK, LZMA_TELL_UNSUPPORTED_CHECK, and LZMA_FAIL_FAST do nothing. LZMA_TELL_ANY_CHECK is supported for consistency only as CRC32 is always used in the .lz format. |
This decoder supports the .lz format version 0 and the unextended .lz format version 1:
Just like with lzma_stream_decoder() for .xz files, LZMA_CONCATENATED should be used when decompressing normal standalone .lz files.
The .lz format allows putting non-.lz data at the end of a file after at least one valid .lz member. That is, one can append custom data at the end of a .lz file and the decoder is required to ignore it. In liblzma this is relevant only when LZMA_CONCATENATED is used. In that case lzma_code() will return LZMA_STREAM_END and leave lzma_stream.next_in pointing to the first byte of the non-.lz data. An exception to this is if the first 1-3 bytes of the non-.lz data are identical to the .lz magic bytes (0x4C, 0x5A, 0x49, 0x50; "LZIP" in US-ASCII). In such a case the 1-3 bytes will have been ignored by lzma_code(). If one wishes to locate the non-.lz data reliably, one must ensure that the first byte isn't 0x4C. Actually one should ensure that none of the first four bytes of trailing data are equal to the magic bytes because lzip >= 1.20 requires it by default.
| memlimit | Pointer to how much memory the decoder is allowed to allocate. The value pointed by this pointer is modified if and only if LZMA_MEMLIMIT_ERROR is returned. |
| flags | Bitwise-or of zero or more of the decoder flags: LZMA_TELL_NO_CHECK, LZMA_TELL_UNSUPPORTED_CHECK, LZMA_IGNORE_CHECK, LZMA_CONCATENATED, LZMA_FAIL_FAST. Note that LZMA_TELL_ANY_CHECK is not allowed and will return LZMA_PROG_ERROR. |
| allocator | lzma_allocator for custom allocator functions. Set to NULL to use malloc() and free(). |
| in | Beginning of the input buffer |
| in_pos | The next byte will be read from in[*in_pos]. *in_pos is updated only if decoding succeeds. |
| in_size | Size of the input buffer; the first byte that won't be read is in[in_size]. |
| out | Beginning of the output buffer |
| out_pos | The next byte will be written to out[*out_pos]. *out_pos is updated only if decoding succeeds. |
| out_size | Size of the out buffer; the first byte into which no data is written to is out[out_size]. |
See lzma_microlzma_decoder() for more information.
The lzma_code() usage with this decoder is completely normal. The special behavior of lzma_code() applies to lzma_microlzma_encoder() only.
| strm | Pointer to properly prepared lzma_stream |
| comp_size | Compressed size of the MicroLZMA stream. The caller must somehow know this exactly. |
| uncomp_size | Uncompressed size of the MicroLZMA stream. If the exact uncompressed size isn't known, this can be set to a value that is at most as big as the exact uncompressed size would be, but then the next argument uncomp_size_is_exact must be false. |
| uncomp_size_is_exact | If true, uncomp_size must be exactly correct. This will improve error detection at the end of the stream. If the exact uncompressed size isn't known, this must be false. uncomp_size must still be at most as big as the exact uncompressed size is. Setting this to false when the exact size is known will work but error detection at the end of the stream will be weaker. |
| dict_size | LZMA dictionary size that was used when compressing the data. It is OK to use a bigger value too but liblzma will then allocate more memory than would actually be required and error detection will be slightly worse. (Note that with the implementation in XZ Embedded it doesn't affect the memory usage if one specifies bigger dictionary than actually required.) |
This function may be called after lzma_code() has returned LZMA_STREAM_END when LZMA_FULL_BARRIER, LZMA_FULL_FLUSH, or LZMA_SYNC_FLUSH was used:
This function may also be called when no data has been compressed yet although this is rarely useful. In that case, this function will behave as if LZMA_FULL_FLUSH (Stream encoders) or LZMA_SYNC_FLUSH (Raw or Block encoder) had been used right before calling this function.
Use cases:
Note that even if the filter chain was specified using a preset, the resulting filter chain isn't reversed to a preset. So if you specify "6" to lzma_str_to_filters() then lzma_str_from_filters() will produce a string containing "lzma2".
| str | On success *str will be set to point to an allocated string describing the given filter chain. Old value is ignored. On error *str is always set to NULL. |
| filters | Array of 1-4 filters and a terminating element with .id = LZMA_VLI_UNKNOWN. |
| flags | Bitwise-or of zero or more of the flags LZMA_STR_ENCODER, LZMA_STR_DECODER, LZMA_STR_GETOPT_LONG, and LZMA_STR_NO_SPACES. |
| allocator | lzma_allocator for custom allocator functions. Set to NULL to use malloc() and free(). |
If a filter_id is given then only one line is created which contains the filter name. If LZMA_STR_ENCODER or LZMA_STR_DECODER is used then the options required for encoding or decoding are listed on the same line too.
If filter_id is LZMA_VLI_UNKNOWN then all supported .xz-compatible filters are listed:
| str | On success *str will be set to point to an allocated string listing the filters and options. Old value is ignored. On error *str is always set to NULL. |
| filter_id | Filter ID or LZMA_VLI_UNKNOWN. |
| flags | Bitwise-or of zero or more of the flags LZMA_STR_ALL_FILTERS, LZMA_STR_ENCODER, LZMA_STR_DECODER, and LZMA_STR_GETOPT_LONG. |
| allocator | lzma_allocator for custom allocator functions. Set to NULL to use malloc() and free(). |
| strm | Pointer to a properly prepared lzma_stream |
| dest_index | Pointer to a pointer where the decoder will put the decoded lzma_index. The old value of *dest_index is ignored (not freed). |
| memlimit | How much memory the resulting lzma_index is allowed to require. Use UINT64_MAX to effectively disable the limiter. |
| file_size | Size of the input .xz file |
This decoder decodes the Stream Header, Stream Footer, Index, and Stream Padding field(s) from the input .xz file and stores the resulting combined index in *dest_index. This information can be used to get the uncompressed file size with lzma_index_uncompressed_size(*dest_index) or, for example, to implement random access reading by locating the Blocks in the Streams.
To get the required information from the .xz file, lzma_code() may ask the application to seek in the input file by returning LZMA_SEEK_NEEDED and having the target file position specified in lzma_stream.seek_pos. The number of seeks required depends on the input file and how big buffers the application provides. When possible, the decoder will seek backward and forward in the given buffer to avoid useless seek requests. Thus, if the application provides the whole file at once, no external seeking will be required (that is, lzma_code() won't return LZMA_SEEK_NEEDED).
The value in lzma_stream.total_in can be used to estimate how much data liblzma had to read to get the file information. However, due to seeking and the way total_in is updated, the value of total_in will be somewhat inaccurate (a little too big). Thus, total_in is a good estimate but don't expect to see the same exact value for the same file if you change the input buffer size or switch to a different liblzma version.
Valid ‘action’ arguments to lzma_code() are LZMA_RUN and LZMA_FINISH. You only need to use LZMA_RUN; LZMA_FINISH is only supported because it might be convenient for some applications. If you use LZMA_FINISH and if lzma_code() asks the application to seek, remember to reset ‘action’ back to LZMA_RUN unless you hit the end of the file again.
Possible return values from lzma_code():
This function is supported only when *strm has been initialized with a function that takes a memlimit argument.
liblzma 5.2.3 and earlier has a bug where memlimit value of 0 causes this function to do nothing (leaving the limit unchanged) and still return LZMA_OK. Later versions treat 0 as if 1 had been specified (so lzma_memlimit_get() will return 1 even if you specify 0 here).
liblzma 5.2.6 and earlier had a bug in single-threaded .xz decoder (lzma_stream_decoder()) which made it impossible to continue decoding after LZMA_MEMLIMIT_ERROR even if the limit was increased using lzma_memlimit_set(). Other decoders worked correctly.
The caller must have calculated the size of the Block Header already with lzma_block_header_size(). If a value larger than the one calculated by lzma_block_header_size() is used, the Block Header will be padded to the specified size.
| block | Block options to be encoded. | |
| [out] | out | Beginning of the output buffer. This must be at least block->header_size bytes. |
block->version should (usually) be set to the highest value supported by the application. If the application sets block->version to a value higher than supported by the current liblzma version, this function will downgrade block->version to the highest value supported by it. Thus one should check the value of block->version after calling this function if block->version was set to a non-zero value and the application doesn't otherwise know that the liblzma version being used is new enough to support the specified block->version.
The size of the Block Header must have already been decoded with lzma_block_header_size_decode() macro and stored to block->header_size.
The integrity check type from Stream Header must have been stored to block->check.
block->filters must have been allocated, but they don't need to be initialized (possible existing filter options are not freed).
| [out] | block | Destination for Block options |
| allocator | lzma_allocator for custom allocator functions. Set to NULL to use malloc() (and also free() if an error occurs). | |
| in | Beginning of the input buffer. This must be at least block->header_size bytes. |
Block Header stores Compressed Size, but Index has Unpadded Size. If the application has already parsed the Index and is now decoding Blocks, it can calculate Compressed Size from Unpadded Size. This function does exactly that with error checking:
| block | Block options: block->header_size must already be set with lzma_block_header_size(). |
| unpadded_size | Unpadded Size from the Index field in bytes |
Valid actions for lzma_code() are LZMA_RUN, LZMA_SYNC_FLUSH (only if the filter chain supports it), and LZMA_FINISH.
The Block encoder encodes the Block Data, Block Padding, and Check value. It does NOT encode the Block Header which can be encoded with lzma_block_header_encode().
| strm | Pointer to lzma_stream that is at least initialized with LZMA_STREAM_INIT. |
| block | Block options: block->version, block->check, and block->filters must have been initialized. |
Valid actions for lzma_code() are LZMA_RUN and LZMA_FINISH. Using LZMA_FINISH is not required. It is supported only for convenience.
The Block decoder decodes the Block Data, Block Padding, and Check value. It does NOT decode the Block Header which can be decoded with lzma_block_header_decode().
| strm | Pointer to lzma_stream that is at least initialized with LZMA_STREAM_INIT. |
| block | Block options |
In contrast to the multi-call encoder initialized with lzma_block_encoder(), this function encodes also the Block Header. This is required to make it possible to write appropriate Block Header also in case the data isn't compressible, and different filter chain has to be used to encode the data in uncompressed form using uncompressed chunks of the LZMA2 filter.
When the data isn't compressible, header_size, compressed_size, and uncompressed_size are set just like when the data was compressible, but it is possible that header_size is too small to hold the filter chain specified in block->filters, because that isn't necessarily the filter chain that was actually used to encode the data. lzma_block_unpadded_size() still works normally, because it doesn't read the filters array.
| block | Block options: block->version, block->check, and block->filters must have been initialized. | |
| allocator | lzma_allocator for custom allocator functions. Set to NULL to use malloc() and free(). | |
| in | Beginning of the input buffer | |
| in_size | Size of the input buffer | |
| [out] | out | Beginning of the output buffer |
| [out] | out_pos | The next byte will be written to out[*out_pos]. *out_pos is updated only if encoding succeeds. |
| out_size | Size of the out buffer; the first byte into which no data is written to is out[out_size]. |
This is like lzma_block_buffer_encode() except this doesn't try to compress the data and instead encodes the data using LZMA2 uncompressed chunks. The required output buffer size can be determined with lzma_block_buffer_bound().
Since the data won't be compressed, this function ignores block->filters. This function doesn't take lzma_allocator because this function doesn't allocate any memory from the heap.
| block | Block options: block->version, block->check, and block->filters must have been initialized. | |
| in | Beginning of the input buffer | |
| in_size | Size of the input buffer | |
| [out] | out | Beginning of the output buffer |
| [out] | out_pos | The next byte will be written to out[*out_pos]. *out_pos is updated only if encoding succeeds. |
| out_size | Size of the out buffer; the first byte into which no data is written to is out[out_size]. |
This is single-call equivalent of lzma_block_decoder(), and requires that the caller has already decoded Block Header and checked its memory usage.
| block | Block options | |
| allocator | lzma_allocator for custom allocator functions. Set to NULL to use malloc() and free(). | |
| in | Beginning of the input buffer | |
| in_pos | The next byte will be read from in[*in_pos]. *in_pos is updated only if decoding succeeds. | |
| in_size | Size of the input buffer; the first byte that won't be read is in[in_size]. | |
| [out] | out | Beginning of the output buffer |
| [out] | out_pos | The next byte will be written to out[*out_pos]. *out_pos is updated only if encoding succeeds. |
| out_size | Size of the out buffer; the first byte into which no data is written to is out[out_size]. |
The maximum required output buffer size can be calculated with lzma_stream_buffer_bound().
| preset | Compression preset to use. See the description in lzma_easy_encoder(). | |
| check | Type of the integrity check to calculate from uncompressed data. | |
| allocator | lzma_allocator for custom allocator functions. Set to NULL to use malloc() and free(). | |
| in | Beginning of the input buffer | |
| in_size | Size of the input buffer | |
| [out] | out | Beginning of the output buffer |
| [out] | out_pos | The next byte will be written to out[*out_pos]. *out_pos is updated only if encoding succeeds. |
| out_size | Size of the out buffer; the first byte into which no data is written to is out[out_size]. |
| strm | Pointer to lzma_stream that is at least initialized with LZMA_STREAM_INIT. |
| filters | Array of filters terminated with .id == LZMA_VLI_UNKNOWN. See filters.h for more information. |
| check | Type of the integrity check to calculate from uncompressed data. |
This provides the functionality of lzma_easy_encoder() and lzma_stream_encoder() as a single function for multithreaded use.
The supported actions for lzma_code() are LZMA_RUN, LZMA_FULL_FLUSH, LZMA_FULL_BARRIER, and LZMA_FINISH. Support for LZMA_SYNC_FLUSH might be added in the future.
| strm | Pointer to lzma_stream that is at least initialized with LZMA_STREAM_INIT. |
| options | Pointer to multithreaded compression options |
The .lzma format is sometimes called the LZMA_Alone format, which is the reason for the name of this function. The .lzma format supports only the LZMA1 filter. There is no support for integrity checks like CRC32.
Use this function if and only if you need to create files readable by legacy LZMA tools such as LZMA Utils 4.32.x. Moving to the .xz format is strongly recommended.
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.
| strm | Pointer to lzma_stream that is at least initialized with LZMA_STREAM_INIT. |
| options | Pointer to encoder options |
| filters | Array of filters terminated with .id == LZMA_VLI_UNKNOWN. See filters.h for more information. | |
| check | Type of the integrity check to calculate from uncompressed data. | |
| allocator | lzma_allocator for custom allocator functions. Set to NULL to use malloc() and free(). | |
| in | Beginning of the input buffer | |
| in_size | Size of the input buffer | |
| [out] | out | Beginning of the output buffer |
| [out] | out_pos | The next byte will be written to out[*out_pos]. *out_pos is updated only if encoding succeeds. |
| out_size | Size of the out buffer; the first byte into which no data is written to is out[out_size]. |
The MicroLZMA format is a raw LZMA stream whose first byte (always 0x00) has been replaced with bitwise-negation of the LZMA properties (lc/lp/pb). This encoding ensures that the first byte of MicroLZMA stream is never 0x00. There is no end of payload marker and thus the uncompressed size must be stored separately. For the best error detection the dictionary size should be stored separately as well but alternatively one may use the uncompressed size as the dictionary size when decoding.
With the MicroLZMA encoder, lzma_code() behaves slightly unusually. The action argument must be LZMA_FINISH and the return value will never be LZMA_OK. Thus the encoding is always done with a single lzma_code() after the initialization. The benefit of the combination of initialization function and lzma_code() is that memory allocations can be re-used for better performance.
lzma_code() will try to encode as much input as is possible to fit into the given output buffer. If not all input can be encoded, the stream will be finished without encoding all the input. The caller must check both input and output buffer usage after lzma_code() (total_in and total_out in lzma_stream can be convenient). Often lzma_code() can fill the output buffer completely if there is a lot of input, but sometimes a few bytes may remain unused because the next LZMA symbol would require more space.
lzma_stream.avail_out must be at least 6. Otherwise LZMA_PROG_ERROR will be returned.
The LZMA dictionary should be reasonably low to speed up the encoder re-initialization. A good value is bigger than the resulting uncompressed size of most of the output chunks. For example, if output size is 4 KiB, dictionary size of 32 KiB or 64 KiB is good. If the data compresses extremely well, even 128 KiB may be useful.
The MicroLZMA format and this encoder variant were made with the EROFS file system in mind. This format may be convenient in other embedded uses too where many small streams are needed. XZ Embedded includes a decoder for this format.
| strm | Pointer to lzma_stream that is at least initialized with LZMA_STREAM_INIT. |
| options | Pointer to encoder options |
| strm | Pointer to lzma_stream that is at least initialized with LZMA_STREAM_INIT. |
| memlimit | Memory usage limit as bytes. Use UINT64_MAX to effectively disable the limiter. liblzma 5.2.3 and earlier don't allow 0 here and return LZMA_PROG_ERROR; later versions treat 0 as if 1 had been specified. |
| flags | Bitwise-or of zero or more of the decoder flags: LZMA_TELL_NO_CHECK, LZMA_TELL_UNSUPPORTED_CHECK, LZMA_TELL_ANY_CHECK, LZMA_IGNORE_CHECK, LZMA_CONCATENATED, LZMA_FAIL_FAST |
The decoder can decode multiple Blocks in parallel. This requires that each Block Header contains the Compressed Size and Uncompressed size fields which are added by the multi-threaded encoder, see lzma_stream_encoder_mt().
A Stream with one Block will only utilize one thread. A Stream with multiple Blocks but without size information in Block Headers will be processed in single-threaded mode in the same way as done by lzma_stream_decoder(). Concatenated Streams are processed one Stream at a time; no inter-Stream parallelization is done.
This function behaves like lzma_stream_decoder() when options->threads == 1 and options->memlimit_threading <= 1.
| strm | Pointer to lzma_stream that is at least initialized with LZMA_STREAM_INIT. |
| options | Pointer to multithreaded compression options |
This decoder autodetects between the .xz, .lzma, and .lz file formats, and calls lzma_stream_decoder(), lzma_alone_decoder(), or lzma_lzip_decoder() once the type of the input file has been detected.
Support for .lz was added in 5.4.0.
If the flag LZMA_CONCATENATED is used and the input is a .lzma file: For historical reasons concatenated .lzma files aren't supported. If there is trailing data after one .lzma stream, lzma_code() will return LZMA_DATA_ERROR. (lzma_alone_decoder() doesn't have such a check as it doesn't support any decoder flags. It will return LZMA_STREAM_END after one .lzma stream.)
| strm | Pointer to lzma_stream that is at least initialized with LZMA_STREAM_INIT. |
| memlimit | Memory usage limit as bytes. Use UINT64_MAX to effectively disable the limiter. liblzma 5.2.3 and earlier don't allow 0 here and return LZMA_PROG_ERROR; later versions treat 0 as if 1 had been specified. |
| flags | Bitwise-or of zero or more of the decoder flags: LZMA_TELL_NO_CHECK, LZMA_TELL_UNSUPPORTED_CHECK, LZMA_TELL_ANY_CHECK, LZMA_IGNORE_CHECK, LZMA_CONCATENATED, LZMA_FAIL_FAST |
Valid 'action' arguments to lzma_code() are LZMA_RUN and LZMA_FINISH. There is no need to use LZMA_FINISH, but it's allowed because it may simplify certain types of applications.
| strm | Pointer to lzma_stream that is at least initialized with LZMA_STREAM_INIT. |
| memlimit | Memory usage limit as bytes. Use UINT64_MAX to effectively disable the limiter. liblzma 5.2.3 and earlier don't allow 0 here and return LZMA_PROG_ERROR; later versions treat 0 as if 1 had been specified. |
This decoder supports the .lz format version 0 and the unextended .lz format version 1:
Just like with lzma_stream_decoder() for .xz files, LZMA_CONCATENATED should be used when decompressing normal standalone .lz files.
The .lz format allows putting non-.lz data at the end of a file after at least one valid .lz member. That is, one can append custom data at the end of a .lz file and the decoder is required to ignore it. In liblzma this is relevant only when LZMA_CONCATENATED is used. In that case lzma_code() will return LZMA_STREAM_END and leave lzma_stream.next_in pointing to the first byte of the non-.lz data. An exception to this is if the first 1-3 bytes of the non-.lz data are identical to the .lz magic bytes (0x4C, 0x5A, 0x49, 0x50; "LZIP" in US-ASCII). In such a case the 1-3 bytes will have been ignored by lzma_code(). If one wishes to locate the non-.lz data reliably, one must ensure that the first byte isn't 0x4C. Actually one should ensure that none of the first four bytes of trailing data are equal to the magic bytes because lzip >= 1.20 requires it by default.
| strm | Pointer to lzma_stream that is at least initialized with LZMA_STREAM_INIT. |
| memlimit | Memory usage limit as bytes. Use UINT64_MAX to effectively disable the limiter. |
| flags | Bitwise-or of flags, or zero for no flags. All decoder flags listed above are supported although only LZMA_CONCATENATED and (in very rare cases) LZMA_IGNORE_CHECK are actually useful. LZMA_TELL_NO_CHECK, LZMA_TELL_UNSUPPORTED_CHECK, and LZMA_FAIL_FAST do nothing. LZMA_TELL_ANY_CHECK is supported for consistency only as CRC32 is always used in the .lz format. |
| memlimit | Pointer to how much memory the decoder is allowed to allocate. The value pointed by this pointer is modified if and only if LZMA_MEMLIMIT_ERROR is returned. | |
| flags | Bitwise-or of zero or more of the decoder flags: LZMA_TELL_NO_CHECK, LZMA_TELL_UNSUPPORTED_CHECK, LZMA_IGNORE_CHECK, LZMA_CONCATENATED, LZMA_FAIL_FAST. Note that LZMA_TELL_ANY_CHECK is not allowed and will return LZMA_PROG_ERROR. | |
| allocator | lzma_allocator for custom allocator functions. Set to NULL to use malloc() and free(). | |
| in | Beginning of the input buffer | |
| in_pos | The next byte will be read from in[*in_pos]. *in_pos is updated only if decoding succeeds. | |
| in_size | Size of the input buffer; the first byte that won't be read is in[in_size]. | |
| [out] | out | Beginning of the output buffer |
| [out] | out_pos | The next byte will be written to out[*out_pos]. *out_pos is updated only if decoding succeeds. |
| out_size | Size of the out buffer; the first byte into which no data is written to is out[out_size]. |
See lzma_microlzma_encoder() for more information.
The lzma_code() usage with this decoder is completely normal. The special behavior of lzma_code() applies to lzma_microlzma_encoder() only.
| strm | Pointer to lzma_stream that is at least initialized with LZMA_STREAM_INIT. |
| comp_size | Compressed size of the MicroLZMA stream. The caller must somehow know this exactly. |
| uncomp_size | Uncompressed size of the MicroLZMA stream. If the exact uncompressed size isn't known, this can be set to a value that is at most as big as the exact uncompressed size would be, but then the next argument uncomp_size_is_exact must be false. |
| uncomp_size_is_exact | If true, uncomp_size must be exactly correct. This will improve error detection at the end of the stream. If the exact uncompressed size isn't known, this must be false. uncomp_size must still be at most as big as the exact uncompressed size is. Setting this to false when the exact size is known will work but error detection at the end of the stream will be weaker. |
| dict_size | LZMA dictionary size that was used when compressing the data. It is OK to use a bigger value too but liblzma will then allocate more memory than would actually be required and error detection will be slightly worse. (Note that with the implementation in XZ Embedded it doesn't affect the memory usage if one specifies bigger dictionary than actually required.) |
This function may be useful when implementing custom file formats.
The 'action' with lzma_code() can be LZMA_RUN, LZMA_SYNC_FLUSH (if the filter chain supports it), or LZMA_FINISH.
| strm | Pointer to lzma_stream that is at least initialized with LZMA_STREAM_INIT. |
| filters | Array of filters terminated with .id == LZMA_VLI_UNKNOWN. |
The initialization of raw decoder goes similarly to raw encoder.
The 'action' with lzma_code() can be LZMA_RUN or LZMA_FINISH. Using LZMA_FINISH is not required, it is supported just for convenience.
| strm | Pointer to lzma_stream that is at least initialized with LZMA_STREAM_INIT. |
| filters | Array of filters terminated with .id == LZMA_VLI_UNKNOWN. |
This function may be called after lzma_code() has returned LZMA_STREAM_END when LZMA_FULL_BARRIER, LZMA_FULL_FLUSH, or LZMA_SYNC_FLUSH was used:
This function may also be called when no data has been compressed yet although this is rarely useful. In that case, this function will behave as if LZMA_FULL_FLUSH (Stream encoders) or LZMA_SYNC_FLUSH (Raw or Block encoder) had been used right before calling this function.
| strm | Pointer to lzma_stream that is at least initialized with LZMA_STREAM_INIT. |
| filters | Array of filters terminated with .id == LZMA_VLI_UNKNOWN. |
| filters | Array of filters terminated with .id == LZMA_VLI_UNKNOWN. | |
| allocator | lzma_allocator for custom allocator functions. Set to NULL to use malloc() and free(). | |
| in | Beginning of the input buffer | |
| in_size | Size of the input buffer | |
| [out] | out | Beginning of the output buffer |
| [out] | out_pos | The next byte will be written to out[*out_pos]. *out_pos is updated only if encoding succeeds. |
| out_size | Size of the out buffer; the first byte into which no data is written to is out[out_size]. |
| filters | Array of filters terminated with .id == LZMA_VLI_UNKNOWN. | |
| allocator | lzma_allocator for custom allocator functions. Set to NULL to use malloc() and free(). | |
| in | Beginning of the input buffer | |
| in_pos | The next byte will be read from in[*in_pos]. *in_pos is updated only if decoding succeeds. | |
| in_size | Size of the input buffer; the first byte that won't be read is in[in_size]. | |
| [out] | out | Beginning of the output buffer |
| [out] | out_pos | The next byte will be written to out[*out_pos]. *out_pos is updated only if encoding succeeds. |
| out_size | Size of the out buffer; the first byte into which no data is written to is out[out_size]. |
This function may be useful when implementing custom file formats using the raw encoder and decoder.
| [out] | size | Pointer to uint32_t to hold the size of the properties |
| filter | Filter ID and options (the size of the properties may vary depending on the options) |
| filter | Filter ID and options | |
| [out] | props | Buffer to hold the encoded options. The size of the buffer must have been already determined with lzma_properties_size(). |
| filter | filter->id must have been set to the correct Filter ID. filter->options doesn't need to be initialized (it's not freed by this function). The decoded options will be stored in filter->options; it's application's responsibility to free it when appropriate. filter->options is set to NULL if there are no properties or if an error occurs. |
| allocator | lzma_allocator for custom allocator functions. Set to NULL to use malloc() and free(). and in case of an error, also free(). |
| props | Input buffer containing the properties. |
| props_size | Size of the properties. This must be the exact size; giving too much or too little input will return LZMA_OPTIONS_ERROR. |
Knowing the size of Filter Flags is useful to know when allocating memory to hold the encoded Filter Flags.
| [out] | size | Pointer to integer to hold the calculated size |
| filter | Filter ID and associated options whose encoded size is to be calculated |
In contrast to some functions, this doesn't allocate the needed buffer. This is due to how this function is used internally by liblzma.
| filter | Filter ID and options to be encoded | |
| [out] | out | Beginning of the output buffer |
| [out] | out_pos | out[*out_pos] is the next write position. This is updated by the encoder. |
| out_size | out[out_size] is the first byte to not write. |
The decoded result is stored into *filter. The old value of filter->options is not free()d. If anything other than LZMA_OK is returned, filter->options is set to NULL.
| [out] | filter | Destination filter. The decoded Filter ID will be stored in filter->id. If options are needed they will be allocated and the pointer will be stored in filter->options. |
| allocator | lzma_allocator for custom allocator functions. Set to NULL to use malloc() and free(). | |
| in | Beginning of the input buffer | |
| [out] | in_pos | The next byte will be read from in[*in_pos]. *in_pos is updated only if decoding succeeds. |
| in_size | Size of the input buffer; the first byte that won't be read is in[in_size]. |
Use cases:
Note that even if the filter chain was specified using a preset, the resulting filter chain isn't reversed to a preset. So if you specify "6" to lzma_str_to_filters() then lzma_str_from_filters() will produce a string containing "lzma2".
| [out] | str | On success *str will be set to point to an allocated string describing the given filter chain. Old value is ignored. On error *str is always set to NULL. |
| filters | Array of filters terminated with .id == LZMA_VLI_UNKNOWN. | |
| flags | Bitwise-or of zero or more of the flags LZMA_STR_ENCODER, LZMA_STR_DECODER, LZMA_STR_GETOPT_LONG, and LZMA_STR_NO_SPACES. | |
| allocator | lzma_allocator for custom allocator functions. Set to NULL to use malloc() and free(). |
If a filter_id is given then only one line is created which contains the filter name. If LZMA_STR_ENCODER or LZMA_STR_DECODER is used then the options read by the encoder or decoder are printed on the same line.
If filter_id is LZMA_VLI_UNKNOWN then all supported .xz-compatible filters are listed:
| str | On success *str will be set to point to an allocated string listing the filters and options. Old value is ignored. On error *str is always set to NULL. |
| filter_id | Filter ID or LZMA_VLI_UNKNOWN. |
| flags | Bitwise-or of zero or more of the flags LZMA_STR_ALL_FILTERS, LZMA_STR_ENCODER, LZMA_STR_DECODER, and LZMA_STR_GETOPT_LONG. |
| allocator | lzma_allocator for custom allocator functions. Set to NULL to use malloc() and free(). |
Set the Stream Flags of the last (and typically the only) Stream in lzma_index. This can be useful when reading information from the lzma_index, because to decode Blocks, knowing the integrity check type is needed.
| i | Pointer to lzma_index structure |
| stream_flags | Pointer to lzma_stream_flags structure. This is copied into the internal preallocated structure, so the caller doesn't need to keep the flags' data available after calling this function. |
Set the amount of Stream Padding of the last (and typically the only) Stream in the lzma_index. This is needed when planning to do random-access reading within multiple concatenated Streams.
By default, the amount of Stream Padding is assumed to be zero bytes.
Concatenating lzma_indexes is useful when doing random-access reading in multi-Stream .xz file, or when combining multiple Streams into single Stream.
| [out] | dest | lzma_index after which src is appended |
| src | lzma_index to be appended after dest. If this function succeeds, the memory allocated for src is freed or moved to be part of dest, and all iterators pointing to src will become invalid. | |
| allocator | lzma_allocator for custom allocator functions. Set to NULL to use malloc() and free(). |
| strm | Pointer to properly prepared lzma_stream |
| i | Pointer to lzma_index which should be encoded. |
The valid 'action' values for lzma_code() are LZMA_RUN and LZMA_FINISH. It is enough to use only one of them (you can choose freely).
| strm | Pointer to properly prepared lzma_stream | |
| [out] | i | The decoded Index will be made available via this pointer. Initially this function will set *i to NULL (the old value is ignored). If decoding succeeds (lzma_code() returns LZMA_STREAM_END), *i will be set to point to a new lzma_index, which the application has to later free with lzma_index_end(). |
| memlimit | How much memory the resulting lzma_index is allowed to require. liblzma 5.2.3 and earlier don't allow 0 here and return LZMA_PROG_ERROR; later versions treat 0 as if 1 had been specified. |
Valid 'action' arguments to lzma_code() are LZMA_RUN and LZMA_FINISH. There is no need to use LZMA_FINISH, but it's allowed because it may simplify certain types of applications.
| i | lzma_index to be encoded | |
| [out] | out | Beginning of the output buffer |
| [out] | out_pos | The next byte will be written to out[*out_pos]. *out_pos is updated only if encoding succeeds. |
| out_size | Size of the out buffer; the first byte into which no data is written to is out[out_size]. |
| [out] | i | If decoding succeeds, *i will point to a new lzma_index, which the application has to later free with lzma_index_end(). If an error occurs, *i will be NULL. The old value of *i is always ignored and thus doesn't need to be initialized by the caller. |
| [out] | memlimit | Pointer to how much memory the resulting lzma_index is allowed to require. The value pointed by this pointer is modified if and only if LZMA_MEMLIMIT_ERROR is returned. |
| allocator | lzma_allocator for custom allocator functions. Set to NULL to use malloc() and free(). | |
| in | Beginning of the input buffer | |
| in_pos | The next byte will be read from in[*in_pos]. *in_pos is updated only if decoding succeeds. | |
| in_size | Size of the input buffer; the first byte that won't be read is in[in_size]. |
This decoder decodes the Stream Header, Stream Footer, Index, and Stream Padding field(s) from the input .xz file and stores the resulting combined index in *dest_index. This information can be used to get the uncompressed file size with lzma_index_uncompressed_size(*dest_index) or, for example, to implement random access reading by locating the Blocks in the Streams.
To get the required information from the .xz file, lzma_code() may ask the application to seek in the input file by returning LZMA_SEEK_NEEDED and having the target file position specified in lzma_stream.seek_pos. The number of seeks required depends on the input file and how big buffers the application provides. When possible, the decoder will seek backward and forward in the given buffer to avoid useless seek requests. Thus, if the application provides the whole file at once, no external seeking will be required (that is, lzma_code() won't return LZMA_SEEK_NEEDED).
The value in lzma_stream.total_in can be used to estimate how much data liblzma had to read to get the file information. However, due to seeking and the way total_in is updated, the value of total_in will be somewhat inaccurate (a little too big). Thus, total_in is a good estimate but don't expect to see the same exact value for the same file if you change the input buffer size or switch to a different liblzma version.
Valid 'action' arguments to lzma_code() are LZMA_RUN and LZMA_FINISH. You only need to use LZMA_RUN; LZMA_FINISH is only supported because it might be convenient for some applications. If you use LZMA_FINISH and if lzma_code() asks the application to seek, remember to reset 'action' back to LZMA_RUN unless you hit the end of the file again.
Possible return values from lzma_code():
| strm | Pointer to a properly prepared lzma_stream | |
| [out] | dest_index | Pointer to a pointer where the decoder will put the decoded lzma_index. The old value of *dest_index is ignored (not freed). |
| memlimit | How much memory the resulting lzma_index is allowed to require. Use UINT64_MAX to effectively disable the limiter. | |
| file_size | Size of the input .xz file |
After telling the sizes of all Blocks with lzma_index_hash_append(), the actual Index field is decoded with this function. Specifically, once decoding of the Index field has been started, no more Records can be added using lzma_index_hash_append().
This function doesn't use lzma_stream structure to pass the input data. Instead, the input buffer is specified using three arguments. This is because it matches better the internal APIs of liblzma.
| index_hash | Pointer to a lzma_index_hash structure | |
| in | Pointer to the beginning of the input buffer | |
| [out] | in_pos | in[*in_pos] is the next byte to process |
| in_size | in[in_size] is the first byte not to process |
| options | Stream Footer options to be encoded. | |
| [out] | out | Beginning of the output buffer of LZMA_STREAM_HEADER_SIZE bytes. |
options->backward_size is always set to LZMA_VLI_UNKNOWN. This is to help comparing Stream Flags from Stream Header and Stream Footer with lzma_stream_flags_compare().
| [out] | options | Target for the decoded Stream Header options. |
| in | Beginning of the input buffer of LZMA_STREAM_HEADER_SIZE bytes. |
| [out] | options | Target for the decoded Stream Footer options. |
| in | Beginning of the input buffer of LZMA_STREAM_HEADER_SIZE bytes. |
backward_size values are compared only if both are not LZMA_VLI_UNKNOWN.
| a | Pointer to lzma_stream_flags structure |
| b | Pointer to lzma_stream_flags structure |
Like lzma_vli_encode(), this function has single-call and multi-call modes.
| [out] | vli | Pointer to decoded integer. The decoder will initialize it to zero when *vli_pos == 0, so application isn't required to initialize *vli. |
| [out] | vli_pos | How many bytes have already been decoded. When starting to decode a new integer in multi-call mode, *vli_pos must be initialized to zero. To use single-call decoding, set vli_pos to NULL. |
| in | Beginning of the input buffer | |
| [out] | in_pos | The next byte will be read from in[*in_pos]. |
| in_size | Size of the input buffer; the first byte that won't be read is in[in_size]. |
Single-call (vli_pos == NULL):
Multi-call (vli_pos != NULL):
|
extern |
Get the memory usage of decoder filter chain.
Calculate recommended Block size for multithreaded .xz encoder.
Get the uncompressed size of the file.
Get the total size of the file.
Get the total size of the Blocks.
Get the total size of the Stream.
Get the size of the Index field as bytes.
Get the number of Blocks.
Get the number of Streams.
Calculate the memory usage of an existing lzma_index.
Calculate approximate memory requirements for raw decoder.
Calculate approximate memory usage of multithreaded .xz encoder.
Calculate approximate decoder memory usage of a preset.
Calculate the total encoded size of a Block.
Get the current memory usage limit.
This function is currently supported only when *strm has been initialized with a function that takes a memlimit argument. With other functions, you should use e.g. lzma_raw_encoder_memusage() or lzma_raw_decoder_memusage() to estimate the memory requirements.
This function is useful e.g. after LZMA_MEMLIMIT_ERROR to find out how big the memory usage limit should have been to decode the input. Note that this may give misleading information if decoding .xz Streams that have multiple Blocks, because each Block can have different memory requirements.
If this function isn't supported by *strm or some other error occurs, zero is returned.
This function is supported only when *strm has been initialized with a function that takes a memlimit argument.
This is equivalent to lzma_block_unpadded_size() except that the returned value includes the size of the Block Padding field.
This function is a wrapper for lzma_raw_decoder_memusage().
| preset | Compression preset (level and possible flags) |
Since doing the encoding in threaded mode doesn't affect the memory requirements of single-threaded decompressor, you can use lzma_easy_decoder_memusage(options->preset) or lzma_raw_decoder_memusage(options->filters) to calculate the decompressor memory requirements.
| options | Compression options |
This function can be used to calculate the memory requirements for Block and Stream decoders too because Block and Stream decoders don't need significantly more memory than raw decoder.
| filters | Array of filters terminated with .id == LZMA_VLI_UNKNOWN. |
This is a shorthand for lzma_index_memusage(lzma_index_stream_count(i), lzma_index_block_count(i)).
This returns the total number of Blocks in lzma_index. To get number of Blocks in individual Streams, use lzma_index_iter.
This is needed to verify the Backward Size field in the Stream Footer.
If multiple lzma_indexes have been combined, this works as if the Blocks were in a single Stream. This is useful if you are going to combine Blocks from multiple Streams into a single new Stream.
This doesn't include the Stream Header, Stream Footer, Stream Padding, or Index fields.
When no lzma_indexes have been combined with lzma_index_cat() and there is no Stream Padding, this function is identical to lzma_index_stream_size(). If multiple lzma_indexes have been combined, this includes also the headers of each separate Stream and the possible Stream Padding fields.
This function is supported only when *strm has been initialized with a function that takes a memlimit argument.
| strm | Pointer to lzma_stream that is at least initialized with LZMA_STREAM_INIT. |
This is equivalent to lzma_block_unpadded_size() except that the returned value includes the size of the Block Padding field.
| block | Block options: block->header_size must already be set with lzma_block_header_size(). |
This function is a wrapper for lzma_raw_decoder_memusage().
| preset | Compression preset (level and possible flags) |
This calculates a recommended Block size for multithreaded encoding given a filter chain. This is used internally by lzma_stream_encoder_mt() to determine the Block size if the block_size member is not set to the special value of 0 in the lzma_mt options struct.
If one wishes to change the filters between Blocks, this function is helpful to set the block_size member of the lzma_mt struct before calling lzma_stream_encoder_mt(). Since the block_size member represents the maximum possible Block size for the multithreaded .xz encoder, one can use this function to find the maximum recommended Block size based on all planned filter chains. Otherwise, the multithreaded encoder will base its maximum Block size on the first filter chain used (if the block_size member is not set), which may unnecessarily limit the Block size for a later filter chain.
| filters | Array of filters terminated with .id == LZMA_VLI_UNKNOWN. |
This function can be used to calculate the memory requirements for Block and Stream decoders too because Block and Stream decoders don't need significantly more memory than raw decoder.
| filters | Array of filters terminated with .id == LZMA_VLI_UNKNOWN. |
This is a shorthand for lzma_index_memusage(lzma_index_stream_count(i), lzma_index_block_count(i)).
| i | Pointer to lzma_index structure |
| i | Pointer to lzma_index structure |
This returns the total number of Blocks in lzma_index. To get number of Blocks in individual Streams, use lzma_index_iter.
| i | Pointer to lzma_index structure |
This is needed to verify the Backward Size field in the Stream Footer.
| i | Pointer to lzma_index structure |
If multiple lzma_indexes have been combined, this works as if the Blocks were in a single Stream. This is useful if you are going to combine Blocks from multiple Streams into a single new Stream.
| i | Pointer to lzma_index structure |
This doesn't include the Stream Header, Stream Footer, Stream Padding, or Index fields.
| i | Pointer to lzma_index structure |
When no lzma_indexes have been combined with lzma_index_cat() and there is no Stream Padding, this function is identical to lzma_index_stream_size(). If multiple lzma_indexes have been combined, this includes also the headers of each separate Stream and the possible Stream Padding fields.
| i | Pointer to lzma_index structure |
| i | Pointer to lzma_index structure |
Get the memory usage of decoder filter chain.
Calculate CRC64 using the polynomial from the ECMA-182 standard.
This function is used similarly to lzma_crc32(). See its documentation.
Get the memory usage of decoder filter chain.
Calculate CRC64 using the polynomial from the ECMA-182 standard.
This function is used similarly to lzma_crc32().
| buf | Pointer to the input buffer |
| size | Size of the input buffer |
| crc | Previously returned CRC value. This is used to calculate the CRC of a big buffer in smaller chunks. Set to zero when starting a new calculation. |
|
extern |
Free memory allocated for the coder data structures.
Rewind the iterator.
Initialize an iterator.
Get progress information.
| strm | Pointer to lzma_stream that is at least initialized with LZMA_STREAM_INIT. |
After lzma_end(strm), strm->internal is guaranteed to be NULL. No other members of the lzma_stream structure are touched.
In single-threaded mode, applications can get progress information from strm->total_in and strm->total_out. In multi-threaded mode this is less useful because a significant amount of both input and output data gets buffered internally by liblzma. This makes total_in and total_out give misleading information and also makes the progress indicator updates non-smooth.
This function gives realistic progress information also in multi-threaded mode by taking into account the progress made by each thread. In single-threaded mode *progress_in and *progress_out are set to strm->total_in and strm->total_out, respectively.
| iter | Pointer to a lzma_index_iter structure |
| i | lzma_index to which the iterator will be associated |
This function associates the iterator with the given lzma_index, and calls lzma_index_iter_rewind() on the iterator.
This function doesn't allocate any memory, thus there is no lzma_index_iter_end(). The iterator is valid as long as the associated lzma_index is valid, that is, until lzma_index_end() or using it as source in lzma_index_cat(). Specifically, lzma_index doesn't become invalid if new Blocks are added to it with lzma_index_append() or if it is used as the destination in lzma_index_cat().
It is safe to make copies of an initialized lzma_index_iter, for example, to easily restart reading at some particular position.
Rewind the iterator so that next call to lzma_index_iter_next() will return the first Block or Stream.
In single-threaded mode, applications can get progress information from strm->total_in and strm->total_out. In multi-threaded mode this is less useful because a significant amount of both input and output data gets buffered internally by liblzma. This makes total_in and total_out give misleading information and also makes the progress indicator updates non-smooth.
This function gives realistic progress information also in multi-threaded mode by taking into account the progress made by each thread. In single-threaded mode *progress_in and *progress_out are set to strm->total_in and strm->total_out, respectively.
| strm | Pointer to lzma_stream that is at least initialized with LZMA_STREAM_INIT. | |
| [out] | progress_in | Pointer to the number of input bytes processed. |
| [out] | progress_out | Pointer to the number of output bytes processed. |
This function associates the iterator with the given lzma_index, and calls lzma_index_iter_rewind() on the iterator.
This function doesn't allocate any memory, thus there is no lzma_index_iter_end(). The iterator is valid as long as the associated lzma_index is valid, that is, until lzma_index_end() or using it as source in lzma_index_cat(). Specifically, lzma_index doesn't become invalid if new Blocks are added to it with lzma_index_append() or if it is used as the destination in lzma_index_cat().
It is safe to make copies of an initialized lzma_index_iter, for example, to easily restart reading at some particular position.
| iter | Pointer to a lzma_index_iter structure |
| i | lzma_index to which the iterator will be associated |
Rewind the iterator so that next call to lzma_index_iter_next() will return the first Block or Stream.
| iter | Pointer to a lzma_index_iter structure |
| lzma_action action lzma_nothrow lzma_attr_warn_unused_result |
| uint64_t memlimit lzma_nothrow |
| uint64_t* progress_in |
1.12.0