|
liblzma (XZ Utils) 5.4.5
|
Data types and functions used in many places in liblzma API. More...
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 , LZMA_SEEK_NEEDED = 12 , LZMA_RET_INTERNAL1 = 101 , LZMA_RET_INTERNAL2 = 102 , LZMA_RET_INTERNAL3 = 103 , LZMA_RET_INTERNAL4 = 104 , LZMA_RET_INTERNAL5 = 105 , LZMA_RET_INTERNAL6 = 106 , LZMA_RET_INTERNAL7 = 107 , LZMA_RET_INTERNAL8 = 108 } |
| 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_ret | lzma_code (lzma_stream *strm, lzma_action action) lzma_nothrow lzma_attr_warn_unused_result |
| Encode or decode data. | |
| void | lzma_end (lzma_stream *strm) lzma_nothrow |
| Free memory allocated for the coder data structures. | |
| void | lzma_get_progress (lzma_stream *strm, uint64_t *progress_in, uint64_t *progress_out) lzma_nothrow |
| Get progress information. | |
| uint64_t | lzma_memusage (const lzma_stream *strm) lzma_nothrow lzma_attr_pure |
| Get the memory usage of decoder filter chain. | |
| uint64_t | lzma_memlimit_get (const lzma_stream *strm) lzma_nothrow lzma_attr_pure |
| Get the current memory usage limit. | |
| lzma_ret | lzma_memlimit_set (lzma_stream *strm, uint64_t memlimit) lzma_nothrow |
| Set the memory usage limit. | |
Data types and functions used in many places in liblzma API.
| #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
| typedef struct lzma_internal_s lzma_internal |
Internal data structure.
The contents of this structure is not visible outside the library.
| 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.
| 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.
| Enumerator | |
|---|---|
| LZMA_OK | Operation completed successfully. |
| LZMA_STREAM_END | End of stream was reached. In encoder, LZMA_SYNC_FLUSH, LZMA_FULL_FLUSH, or LZMA_FINISH was finished. In decoder, this indicates that all the data was successfully decoded. In all cases, when LZMA_STREAM_END is returned, the last output bytes should be picked from strm->next_out. |
| LZMA_NO_CHECK | Input stream has no integrity check. This return value can be returned only if the LZMA_TELL_NO_CHECK flag was used when initializing the decoder. LZMA_NO_CHECK is just a warning, and the decoding can be continued normally. It is possible to call lzma_get_check() immediately after lzma_code has returned LZMA_NO_CHECK. The result will naturally be LZMA_CHECK_NONE, but the possibility to call lzma_get_check() may be convenient in some applications. |
| LZMA_UNSUPPORTED_CHECK | Cannot calculate the integrity check. The usage of this return value is different in encoders and decoders. Encoders can return this value only from the initialization function. If initialization fails with this value, the encoding cannot be done, because there's no way to produce output with the correct integrity check. Decoders can return this value only from lzma_code() and only if the LZMA_TELL_UNSUPPORTED_CHECK flag was used when initializing the decoder. The decoding can still be continued normally even if the check type is unsupported, but naturally the check will not be validated, and possible errors may go undetected. With decoder, it is possible to call lzma_get_check() immediately after lzma_code() has returned LZMA_UNSUPPORTED_CHECK. This way it is possible to find out what the unsupported Check ID was. |
| LZMA_GET_CHECK | Integrity check type is now available. This value can be returned only by the lzma_code() function and only if the decoder was initialized with the LZMA_TELL_ANY_CHECK flag. LZMA_GET_CHECK tells the application that it may now call lzma_get_check() to find out the Check ID. This can be used, for example, to implement a decoder that accepts only files that have strong enough integrity check. |
| LZMA_MEM_ERROR | Cannot allocate memory. Memory allocation failed, or the size of the allocation would be greater than SIZE_MAX. Due to internal implementation reasons, the coding cannot be continued even if more memory were made available after LZMA_MEM_ERROR. |
| LZMA_MEMLIMIT_ERROR | Memory usage limit was reached. Decoder would need more memory than allowed by the specified memory usage limit. To continue decoding, the memory usage limit has to be increased with lzma_memlimit_set(). 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. |
| LZMA_FORMAT_ERROR | File format not recognized. The decoder did not recognize the input as supported file format. This error can occur, for example, when trying to decode .lzma format file with lzma_stream_decoder, because lzma_stream_decoder accepts only the .xz format. |
| LZMA_OPTIONS_ERROR | Invalid or unsupported options. Invalid or unsupported options, for example
Rebuilding liblzma with more features enabled, or upgrading to a newer version of liblzma may help. |
| LZMA_DATA_ERROR | Data is corrupt. The usage of this return value is different in encoders and decoders. In both encoder and decoder, the coding cannot continue after this error. Encoders return this if size limits of the target file format would be exceeded. These limits are huge, thus getting this error from an encoder is mostly theoretical. For example, the maximum compressed and uncompressed size of a .xz Stream is roughly 8 EiB (2^63 bytes). Decoders return this error if the input data is corrupt. This can mean, for example, invalid CRC32 in headers or invalid check of uncompressed data. |
| LZMA_BUF_ERROR | No progress is possible. This error code is returned when the coder cannot consume any new input and produce any new output. The most common reason for this error is that the input stream being decoded is truncated or corrupt. This error is not fatal. Coding can be continued normally by providing more input and/or more output space, if possible. Typically the first call to lzma_code() that can do no progress returns LZMA_OK instead of LZMA_BUF_ERROR. Only the second consecutive call doing no progress will return LZMA_BUF_ERROR. This is intentional. With zlib, Z_BUF_ERROR may be returned even if the application is doing nothing wrong, so apps will need to handle Z_BUF_ERROR specially. The above hack guarantees that liblzma never returns LZMA_BUF_ERROR to properly written applications unless the input file is truncated or corrupt. This should simplify the applications a little. |
| LZMA_PROG_ERROR | Programming error. This indicates that the arguments given to the function are invalid or the internal state of the decoder is corrupt.
If you think that your code is correct, this error code can be a sign of a bug in liblzma. See the documentation how to report bugs. |
| LZMA_SEEK_NEEDED | Request to change the input file position. Some coders can do random access in the input file. The initialization functions of these coders take the file size as an argument. No other coders can return LZMA_SEEK_NEEDED. When this value is returned, the application must seek to the file position given in lzma_stream.seek_pos. This value is guaranteed to never exceed the file size that was specified at the coder initialization. After seeking the application should read new input and pass it normally via lzma_stream.next_in and .avail_in. |
| 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 be 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. |
| lzma_ret lzma_code | ( | lzma_stream * | strm, |
| lzma_action | action | ||
| ) |
Encode or decode data.
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.
| strm | Pointer to lzma_stream that is at least initialized with LZMA_STREAM_INIT. |
| action | Action for this function to take. Must be a valid lzma_action enum value. |
| void lzma_end | ( | lzma_stream * | strm | ) |
Free memory allocated for the coder data structures.
After lzma_end(strm), strm->internal is guaranteed to be NULL. No other members of the lzma_stream structure are touched.
| strm | Pointer to lzma_stream that is at least initialized with LZMA_STREAM_INIT. |
| void lzma_get_progress | ( | lzma_stream * | strm, |
| uint64_t * | progress_in, | ||
| uint64_t * | progress_out | ||
| ) |
Get progress information.
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. |
| uint64_t lzma_memusage | ( | const lzma_stream * | strm | ) |
Get the memory usage of decoder filter chain.
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.
| strm | Pointer to lzma_stream that is at least initialized with LZMA_STREAM_INIT. |
If this function isn't supported by *strm or some other error occurs, zero is returned.
| uint64_t lzma_memlimit_get | ( | const lzma_stream * | strm | ) |
Get the current memory usage limit.
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. |
| lzma_ret lzma_memlimit_set | ( | lzma_stream * | strm, |
| uint64_t | memlimit | ||
| ) |
Set the memory usage limit.
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.
1.9.7