XZ Utils
5.4.1
|
Data Fields | |
enum lzma_stream_coder:: { ... } | sequence |
lzma_next_coder | block_decoder |
Block decoder. More... | |
lzma_block | block_options |
Options for the Block encoder. More... | |
lzma_stream_flags | stream_flags |
Stream Flags from Stream Header. More... | |
lzma_index_hash * | index_hash |
uint64_t | memlimit |
Memory usage limit. More... | |
uint64_t | memusage |
Amount of memory actually needed (only an estimate) More... | |
bool | tell_no_check |
bool | tell_unsupported_check |
bool | tell_any_check |
If true, LZMA_GET_CHECK is returned after decoding Stream Header. More... | |
bool | ignore_check |
bool | concatenated |
bool | first_stream |
size_t | pos |
Write position in buffer[] and position in Stream Padding. More... | |
uint8_t | buffer [LZMA_BLOCK_HEADER_SIZE_MAX] |
enum lzma_stream_coder:: { ... } | sequence |
lzma_filter | filters [LZMA_FILTERS_MAX+1] |
The filter chain currently in use. More... | |
uint32_t | timeout |
lzma_ret | thread_error |
lzma_ret | pending_error |
uint32_t | threads_max |
Number of threads that will be created at maximum. More... | |
uint32_t | threads_initialized |
struct worker_thread * | threads |
struct worker_thread * | threads_free |
struct worker_thread * | thr |
lzma_outq | outq |
mythread_mutex | mutex |
mythread_cond | cond |
uint64_t | memlimit_threading |
uint64_t | memlimit_stop |
uint64_t | mem_direct_mode |
uint64_t | mem_in_use |
uint64_t | mem_cached |
uint64_t | mem_next_filters |
Amount of memory needed for the filter chain of the next Block. More... | |
uint64_t | mem_next_in |
uint64_t | mem_next_block |
uint64_t | progress_in |
uint64_t | progress_out |
bool | fail_fast |
bool | out_was_filled |
enum lzma_stream_coder:: { ... } | sequence |
bool | block_encoder_is_initialized |
lzma_next_coder | block_encoder |
Block. More... | |
lzma_next_coder | index_encoder |
lzma_index * | index |
Index to hold sizes of the Blocks. More... | |
size_t | buffer_pos |
Read position in buffer[]. More... | |
size_t | buffer_size |
Total number of bytes in buffer[]. More... | |
lzma_next_coder lzma_stream_coder::block_decoder |
Block decoder.
lzma_block lzma_stream_coder::block_options |
Options for the Block encoder.
Block options decoded by the Block Header decoder and used by the Block decoder.
Every Block Header will be decoded into this structure. This is also used to initialize a Block decoder when in direct mode. In threaded mode, a thread-specific copy will be made for decoder initialization because the Block decoder will modify the structure given to it.
Referenced by comp_blk_size().
lzma_stream_flags lzma_stream_coder::stream_flags |
Stream Flags from Stream Header.
Referenced by comp_blk_size().
lzma_index_hash * lzma_stream_coder::index_hash |
Index is hashed so that it can be compared to the sizes of Blocks with O(1) memory usage.
uint64_t lzma_stream_coder::memlimit |
Memory usage limit.
uint64_t lzma_stream_coder::memusage |
Amount of memory actually needed (only an estimate)
bool lzma_stream_coder::tell_no_check |
If true, LZMA_NO_CHECK is returned if the Stream has no integrity check.
bool lzma_stream_coder::tell_unsupported_check |
If true, LZMA_UNSUPPORTED_CHECK is returned if the Stream has an integrity check that isn't supported by this liblzma build.
bool lzma_stream_coder::tell_any_check |
If true, LZMA_GET_CHECK is returned after decoding Stream Header.
bool lzma_stream_coder::ignore_check |
If true, we will tell the Block decoder to skip calculating and verifying the integrity check.
bool lzma_stream_coder::concatenated |
If true, we will decode concatenated Streams that possibly have Stream Padding between or after them. LZMA_STREAM_END is returned once the application isn't giving us any new input (LZMA_FINISH), and we aren't in the middle of a Stream, and possible Stream Padding is a multiple of four bytes.
bool lzma_stream_coder::first_stream |
When decoding concatenated Streams, this is true as long as we are decoding the first Stream. This is needed to avoid misleading LZMA_FORMAT_ERROR in case the later Streams don't have valid magic bytes.
size_t lzma_stream_coder::pos |
Write position in buffer[] and position in Stream Padding.
uint8_t lzma_stream_coder::buffer |
Buffer to hold Stream Header, Block Header, and Stream Footer. Block Header has biggest maximum size.
lzma_filter lzma_stream_coder::filters |
The filter chain currently in use.
Buffer to hold a filter chain for Block Header decoding and initialization. These are freed after successful Block decoder initialization or at stream_decoder_mt_end(). The thread-specific copy of block_options won't hold a pointer to filters[] after initialization.
uint32_t lzma_stream_coder::timeout |
Maximum wait time if cannot use all the input and cannot fill the output buffer. This is in milliseconds.
Referenced by wait_for_work().
lzma_ret lzma_stream_coder::thread_error |
lzma_ret lzma_stream_coder::pending_error |
Error code to return after pending output has been copied out. If set in read_output_and_wait(), this is a mirror of thread_error. If set in stream_decode_mt() then it's, for example, error that occurred when decoding Block Header.
uint32_t lzma_stream_coder::threads_max |
Number of threads that will be created at maximum.
uint32_t lzma_stream_coder::threads_initialized |
Number of thread structures that have been initialized from "threads", and thus the number of worker threads actually created so far.
Referenced by threads_stop().
struct worker_thread* lzma_stream_coder::threads |
Array of allocated thread-specific structures. When no threads are in use (direct mode) this is NULL. In threaded mode this points to an array of threads_max number of worker_thread structs.
Referenced by threads_stop().
struct worker_thread* lzma_stream_coder::threads_free |
Stack of free threads. When a thread finishes, it puts itself back into this stack. This starts as empty because threads are created only when actually needed.
Referenced by wait_for_work(), and worker_stop().
struct worker_thread* lzma_stream_coder::thr |
The most recent worker thread to which the main thread writes the new input from the application.
lzma_outq lzma_stream_coder::outq |
Output buffer queue for decompressed data from the worker threads
Referenced by wait_for_work().
uint64_t lzma_stream_coder::memlimit_threading |
Memory usage that will not be exceeded in multi-threaded mode. Single-threaded mode can exceed this even by a large amount.
uint64_t lzma_stream_coder::memlimit_stop |
Memory usage limit that should never be exceeded. LZMA_MEMLIMIT_ERROR will be returned if decoding isn't possible even in single-threaded mode without exceeding this limit.
uint64_t lzma_stream_coder::mem_direct_mode |
Amount of memory in use by the direct mode decoder (coder->block_decoder). In threaded mode this is 0.
uint64_t lzma_stream_coder::mem_in_use |
Amount of memory needed by the running worker threads. This doesn't include the memory needed by the output buffer.
Referenced by worker_stop().
uint64_t lzma_stream_coder::mem_cached |
uint64_t lzma_stream_coder::mem_next_filters |
Amount of memory needed for the filter chain of the next Block.
uint64_t lzma_stream_coder::mem_next_in |
Amount of memory needed for the thread-specific input buffer for the next Block.
uint64_t lzma_stream_coder::mem_next_block |
Amount of memory actually needed to decode the next Block in threaded mode. This is mem_next_filters + mem_next_in + memory needed for lzma_outbuf.
uint64_t lzma_stream_coder::progress_in |
Amount of compressed data in Stream Header + Blocks that have already been finished.
uint64_t lzma_stream_coder::progress_out |
Amount of uncompressed data in Blocks that have already been finished.
bool lzma_stream_coder::fail_fast |
If true, we will return any errors immediately instead of first producing all output before the location of the error.
bool lzma_stream_coder::out_was_filled |
This is used to track if the previous call to stream_decode_mt() had output space (*out_pos < out_size) and managed to fill the output buffer (*out_pos == out_size). This may be set to true in read_output_and_wait(). This is read and then reset to false at the beginning of stream_decode_mt().
This is needed to support applications that call lzma_code() in such a way that more input is provided only when lzma_code() didn't fill the output buffer completely. Basically, this makes it easier to convert such applications from single-threaded decoder to multi-threaded decoder.
bool lzma_stream_coder::block_encoder_is_initialized |
True if Block encoder has been initialized by stream_encoder_init() or stream_encoder_update() and thus doesn't need to be initialized in stream_encode().
lzma_next_coder lzma_stream_coder::block_encoder |
Block.
lzma_next_coder lzma_stream_coder::index_encoder |
Index encoder. This is separate from Block encoder, because this doesn't take much memory, and when encoding multiple Streams with the same encoding options we avoid reallocating memory.
lzma_index* lzma_stream_coder::index |
Index to hold sizes of the Blocks.
size_t lzma_stream_coder::buffer_pos |
Read position in buffer[].
size_t lzma_stream_coder::buffer_size |
Total number of bytes in buffer[].