XZ Utils 5.3.4alpha
Public Types | Data Fields
lzma_stream_coder Struct Reference

Public Types

enum  {
  SEQ_STREAM_HEADER , SEQ_BLOCK_HEADER , SEQ_BLOCK_INIT , SEQ_BLOCK_RUN ,
  SEQ_INDEX , SEQ_STREAM_FOOTER , SEQ_STREAM_PADDING
}
 
enum  {
  SEQ_STREAM_HEADER , SEQ_BLOCK_HEADER , SEQ_BLOCK_INIT , SEQ_BLOCK_THR_INIT ,
  SEQ_BLOCK_THR_RUN , SEQ_BLOCK_DIRECT_INIT , SEQ_BLOCK_DIRECT_RUN , SEQ_INDEX_WAIT_OUTPUT ,
  SEQ_INDEX_DECODE , SEQ_STREAM_FOOTER , SEQ_STREAM_PADDING , SEQ_ERROR
}
 
enum  {
  SEQ_STREAM_HEADER , SEQ_BLOCK_INIT , SEQ_BLOCK_HEADER , SEQ_BLOCK_ENCODE ,
  SEQ_INDEX_ENCODE , SEQ_STREAM_FOOTER
}
 

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_hashindex_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_threadthreads
 
struct worker_threadthreads_free
 
struct worker_threadthr
 
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_indexindex
 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...
 

Field Documentation

◆ block_decoder

lzma_next_coder lzma_stream_coder::block_decoder

Block decoder.

◆ block_options

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().

◆ stream_flags

lzma_stream_flags lzma_stream_coder::stream_flags

Stream Flags from Stream Header.

Referenced by comp_blk_size().

◆ index_hash

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.

◆ memlimit

uint64_t lzma_stream_coder::memlimit

Memory usage limit.

◆ memusage

uint64_t lzma_stream_coder::memusage

Amount of memory actually needed (only an estimate)

◆ tell_no_check

bool lzma_stream_coder::tell_no_check

If true, LZMA_NO_CHECK is returned if the Stream has no integrity check.

◆ tell_unsupported_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.

◆ tell_any_check

bool lzma_stream_coder::tell_any_check

If true, LZMA_GET_CHECK is returned after decoding Stream Header.

◆ ignore_check

bool lzma_stream_coder::ignore_check

If true, we will tell the Block decoder to skip calculating and verifying the integrity check.

◆ concatenated

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.

◆ first_stream

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.

◆ pos

size_t lzma_stream_coder::pos

Write position in buffer[] and position in Stream Padding.

◆ buffer

uint8_t lzma_stream_coder::buffer

Buffer to hold Stream Header, Block Header, and Stream Footer. Block Header has biggest maximum size.

◆ filters

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.

◆ timeout

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().

◆ thread_error

lzma_ret lzma_stream_coder::thread_error

Error code from a worker thread.

Note
Use mutex.

Referenced by wait_for_work().

◆ pending_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.

◆ threads_max

uint32_t lzma_stream_coder::threads_max

Number of threads that will be created at maximum.

◆ threads_initialized

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().

◆ threads

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().

◆ threads_free

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.

Note
Use mutex.

Referenced by wait_for_work(), and worker_stop().

◆ thr

struct worker_thread* lzma_stream_coder::thr

The most recent worker thread to which the main thread writes the new input from the application.

◆ outq

lzma_outq lzma_stream_coder::outq

Output buffer queue for decompressed data from the worker threads

Note
Use mutex with operations that need it.

Referenced by wait_for_work().

◆ memlimit_threading

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.

◆ memlimit_stop

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.

◆ mem_direct_mode

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.

◆ mem_in_use

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.

Note
Use mutex.

Referenced by worker_stop().

◆ mem_cached

uint64_t lzma_stream_coder::mem_cached

Amount of memory used by the idle (cached) threads.

Note
Use mutex.

Referenced by worker_stop().

◆ mem_next_filters

uint64_t lzma_stream_coder::mem_next_filters

Amount of memory needed for the filter chain of the next Block.

◆ mem_next_in

uint64_t lzma_stream_coder::mem_next_in

Amount of memory needed for the thread-specific input buffer for the next Block.

◆ mem_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.

◆ progress_in

uint64_t lzma_stream_coder::progress_in

Amount of compressed data in Stream Header + Blocks that have already been finished.

Note
Use mutex.

◆ progress_out

uint64_t lzma_stream_coder::progress_out

Amount of uncompressed data in Blocks that have already been finished.

Note
Use mutex.

◆ fail_fast

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.

◆ out_was_filled

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.

◆ block_encoder_is_initialized

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().

◆ block_encoder

lzma_next_coder lzma_stream_coder::block_encoder

Block.

◆ index_encoder

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.

◆ index

lzma_index* lzma_stream_coder::index

Index to hold sizes of the Blocks.

◆ buffer_pos

size_t lzma_stream_coder::buffer_pos

Read position in buffer[].

◆ buffer_size

size_t lzma_stream_coder::buffer_size

Total number of bytes in buffer[].


The documentation for this struct was generated from the following files: