|
XZ Utils
5.2.2
|
Public Types | |
| enum | { SEQ_PROPERTIES, SEQ_DICTIONARY_SIZE, SEQ_UNCOMPRESSED_SIZE, SEQ_CODER_INIT, SEQ_CODE } |
| enum | { SEQ_HEADER, SEQ_CODE } |
| enum | { SEQ_INIT, SEQ_CODE, SEQ_FINISH } |
| enum | { SEQ_CODE, SEQ_PADDING, SEQ_CHECK } |
| enum | { SEQ_CODE, SEQ_PADDING, SEQ_CHECK } |
| enum | { SEQ_INDICATOR, SEQ_COUNT, SEQ_MEMUSAGE, SEQ_UNPADDED, SEQ_UNCOMPRESSED, SEQ_PADDING_INIT, SEQ_PADDING, SEQ_CRC32 } |
| enum | { SEQ_INDICATOR, SEQ_COUNT, SEQ_UNPADDED, SEQ_UNCOMPRESSED, SEQ_NEXT, SEQ_PADDING, SEQ_CRC32 } |
| enum | { SEQ_STREAM_HEADER, SEQ_BLOCK_HEADER, SEQ_BLOCK, SEQ_INDEX, SEQ_STREAM_FOOTER, SEQ_STREAM_PADDING } |
| enum | { SEQ_STREAM_HEADER, SEQ_BLOCK_INIT, SEQ_BLOCK_HEADER, SEQ_BLOCK_ENCODE, SEQ_INDEX_ENCODE, SEQ_STREAM_FOOTER } |
| enum | { SEQ_STREAM_HEADER, SEQ_BLOCK, SEQ_INDEX, SEQ_STREAM_FOOTER } |
| enum | sequence { SEQ_CONTROL, SEQ_UNCOMPRESSED_1, SEQ_UNCOMPRESSED_2, SEQ_COMPRESSED_0, SEQ_COMPRESSED_1, SEQ_PROPERTIES, SEQ_LZMA, SEQ_COPY } |
| enum | { SEQ_INIT, SEQ_LZMA_ENCODE, SEQ_LZMA_COPY, SEQ_UNCOMPRESSED_HEADER, SEQ_UNCOMPRESSED_COPY } |
| enum | { SEQ_NORMALIZE, SEQ_IS_MATCH, seq_8 =(SEQ_LITERAL), seq_8 =(SEQ_LITERAL), SEQ_LITERAL_WRITE, SEQ_IS_REP, seq_len =(SEQ_MATCH_LEN), seq_6 =(SEQ_DIST_SLOT), SEQ_DIST_MODEL, SEQ_DIRECT, seq_4 =(SEQ_ALIGN), SEQ_EOPM, SEQ_IS_REP0, SEQ_SHORTREP, SEQ_IS_REP0_LONG, SEQ_IS_REP1, SEQ_IS_REP2, seq_len =(SEQ_MATCH_LEN), SEQ_COPY } |
| Position where to continue the decoder loop. More... | |
Data Fields | |
| lzma_next_coder | next |
| Stream decoder or LZMA_Alone decoder. More... | |
| enum lzma_coder_s:: { ... } | sequence |
| bool | picky |
| size_t | pos |
| Position in the header fields. More... | |
| lzma_vli | uncompressed_size |
| Uncompressed size decoded from the header. More... | |
| uint64_t | memlimit |
| Memory usage limit. More... | |
| uint64_t | memusage |
| Amount of memory actually needed (only an estimate) More... | |
| lzma_options_lzma | options |
| enum lzma_coder_s:: { ... } | sequence |
| size_t | header_pos |
| Read position in header[]. More... | |
| uint8_t | header [ALONE_HEADER_SIZE] |
| Buffer to hold Stream Header and Stream Footer. More... | |
| uint32_t | flags |
| enum lzma_coder_s:: { ... } | sequence |
| enum lzma_coder_s:: { ... } | sequence |
| lzma_block * | block |
| lzma_vli | compressed_size |
| Compressed Size calculated while decoding. More... | |
| lzma_vli | compressed_limit |
| size_t | check_pos |
| Position when reading the Check field. More... | |
| lzma_check_state | check |
| Check of the uncompressed data. More... | |
| bool | ignore_check |
| True if the integrity check won't be calculated and verified. More... | |
| enum lzma_coder_s:: { ... } | sequence |
| enum lzma_coder_s:: { ... } | sequence |
| lzma_index * | index |
| Target Index. More... | |
| lzma_index ** | index_ptr |
| lzma_vli | count |
| Number of Records left to decode. More... | |
| lzma_vli | unpadded_size |
| The most recent Unpadded Size field. More... | |
| uint32_t | crc32 |
| CRC32 of the List of Records field. More... | |
| enum lzma_coder_s:: { ... } | sequence |
| const lzma_index * | index |
| Index being encoded. More... | |
| lzma_index_iter | iter |
| Iterator for the Index being encoded. More... | |
| enum lzma_coder_s:: { ... } | sequence |
| lzma_next_coder | block_decoder |
| 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 |
| 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 | concatenated |
| bool | first_stream |
| uint8_t | buffer [LZMA_BLOCK_HEADER_SIZE_MAX] |
| Temporary buffer. More... | |
| enum lzma_coder_s:: { ... } | sequence |
| bool | block_encoder_is_initialized |
| lzma_next_coder | block_encoder |
| Block. More... | |
| lzma_filter | filters [LZMA_FILTERS_MAX+1] |
| The filter chain currently in use. More... | |
| lzma_next_coder | index_encoder |
| Index encoder. More... | |
| size_t | buffer_pos |
| Read position in buffer[]. More... | |
| size_t | buffer_size |
| Total number of bytes in buffer[]. More... | |
| enum lzma_coder_s:: { ... } | sequence |
| size_t | block_size |
| lzma_outq | outq |
| Output buffer queue for compressed data. More... | |
| uint32_t | timeout |
| lzma_ret | thread_error |
| Error code from a worker thread. More... | |
| worker_thread * | threads |
| Array of allocated thread-specific structures. More... | |
| uint32_t | threads_max |
| uint32_t | threads_initialized |
| worker_thread * | threads_free |
| worker_thread * | thr |
| uint64_t | progress_in |
| uint64_t | progress_out |
| mythread_mutex | mutex |
| mythread_cond | cond |
| size_t | distance |
| Delta distance. More... | |
| uint8_t | pos |
| Position in history[]. More... | |
| uint8_t | history [LZMA_DELTA_DIST_MAX] |
| Buffer to hold history of the original data. More... | |
| lzma_dict | dict |
| Dictionary (history buffer) More... | |
| lzma_lz_decoder | lz |
| The actual LZ-based decoder e.g. LZMA. More... | |
| bool | next_finished |
| True if the next filter in the chain has returned LZMA_STREAM_END. More... | |
| bool | this_finished |
| struct { | |
| size_t pos | |
| size_t size | |
| uint8_t buffer [LZMA_BUFFER_SIZE] | |
| } | temp |
| lzma_lz_encoder | lz |
| LZ-based encoder e.g. LZMA. More... | |
| lzma_mf | mf |
| History buffer and match finder. More... | |
| enum lzma_coder_s::sequence | sequence |
| enum sequence | next_sequence |
| Sequence after the size fields have been decoded. More... | |
| lzma_lz_decoder | lzma |
| LZMA decoder. More... | |
| size_t | uncompressed_size |
| Uncompressed size of LZMA chunk. More... | |
| size_t | compressed_size |
| bool | need_properties |
| bool | need_dictionary_reset |
| enum lzma_coder_s:: { ... } | sequence |
| lzma_coder * | lzma |
| LZMA encoder. More... | |
| lzma_options_lzma | opt_cur |
| LZMA options currently in use. More... | |
| bool | need_state_reset |
| size_t | buf_pos |
| Read position in buf[]. More... | |
| uint8_t | buf [LZMA2_HEADER_MAX+LZMA2_CHUNK_MAX] |
| Buffer to hold the chunk header and LZMA compressed data. More... | |
| probability | literal [LITERAL_CODERS_MAX][LITERAL_CODER_SIZE] |
| Literals; see comments in lzma_common.h. More... | |
| probability | is_match [STATES][POS_STATES_MAX] |
| If 1, it's a match. Otherwise it's a single 8-bit literal. More... | |
| probability | is_rep [STATES] |
| If 1, it's a repeated match. The distance is one of rep0 .. rep3. More... | |
| probability | is_rep0 [STATES] |
| probability | is_rep1 [STATES] |
| probability | is_rep2 [STATES] |
| If 0, distance of a repeated match is rep2. Otherwise it is rep3. More... | |
| probability | is_rep0_long [STATES][POS_STATES_MAX] |
| probability | dist_slot [DIST_STATES][DIST_SLOTS] |
| probability | pos_special [FULL_DISTANCES - DIST_MODEL_END] |
| probability | pos_align [ALIGN_SIZE] |
| lzma_length_decoder | match_len_decoder |
| Length of a normal match. More... | |
| lzma_length_decoder | rep_len_decoder |
| Length of a repeated match. More... | |
| lzma_range_decoder | rc |
| lzma_lzma_state | state |
| State. More... | |
| uint32_t | rep0 |
| Distance of the latest match. More... | |
| uint32_t | rep1 |
| Distance of second latest match. More... | |
| uint32_t | rep2 |
| Distance of third latest match. More... | |
| uint32_t | rep3 |
| Distance of fourth latest match. More... | |
| uint32_t | pos_mask |
| (1 << pos_bits) - 1 More... | |
| uint32_t | literal_context_bits |
| uint32_t | literal_pos_mask |
| enum lzma_coder_s:: { ... } | sequence |
| Position where to continue the decoder loop. More... | |
| probability * | probs |
| Base of the current probability tree. More... | |
| uint32_t | symbol |
| uint32_t | limit |
| uint32_t | offset |
| uint32_t | len |
| lzma_range_encoder | rc |
| Range encoder. More... | |
| uint32_t | reps [REPS] |
| The four most recent match distances. More... | |
| lzma_match | matches [MATCH_LEN_MAX+1] |
| Array of match candidates. More... | |
| uint32_t | matches_count |
| Number of match candidates in matches[]. More... | |
| uint32_t | longest_match_length |
| bool | fast_mode |
| True if using getoptimumfast. More... | |
| bool | is_initialized |
| bool | is_flushed |
| probability | dist_special [FULL_DISTANCES - DIST_MODEL_END] |
| probability | dist_align [ALIGN_SIZE] |
| lzma_length_encoder | match_len_encoder |
| lzma_length_encoder | rep_len_encoder |
| uint32_t | dist_slot_prices [DIST_STATES][DIST_SLOTS] |
| uint32_t | dist_prices [DIST_STATES][FULL_DISTANCES] |
| uint32_t | dist_table_size |
| uint32_t | match_price_count |
| uint32_t | align_prices [ALIGN_SIZE] |
| uint32_t | align_price_count |
| uint32_t | opts_end_index |
| uint32_t | opts_current_index |
| lzma_optimal | opts [OPTS] |
| bool | end_was_reached |
| True if the next coder in the chain has returned LZMA_STREAM_END. More... | |
| bool | is_encoder |
| size_t(* | filter )(lzma_simple *simple, uint32_t now_pos, bool is_encoder, uint8_t *buffer, size_t size) |
| lzma_simple * | simple |
| uint32_t | now_pos |
| size_t | allocated |
| Size of the memory allocated for the buffer. More... | |
| size_t | filtered |
| anonymous enum |
Position where to continue the decoder loop.
| lzma_next_coder lzma_coder_s::next |
Stream decoder or LZMA_Alone decoder.
Next filter in the chain.
Next coder in the chain.
The filters in the chain; initialized with lzma_raw_decoder_init().
Next filter in the chain, if any. Note that LZMA and LZMA2 are only allowed as the last filter, but the long-range filter in future can be in the middle of the chain.
| bool lzma_coder_s::picky |
If true, reject files that are unlikely to be .lzma files. If false, more non-.lzma files get accepted and will give LZMA_DATA_ERROR either immediately or after a few output bytes.
| size_t lzma_coder_s::pos |
Position in the header fields.
Write position in buffer[] and position in Stream Padding.
Position in integers.
Position in the Check field.
Flushing position in the temporary buffer. buffer[pos] is the next byte to be copied to out[].
Referenced by copy_and_encode(), and encode_in_place().
| lzma_vli lzma_coder_s::uncompressed_size |
Uncompressed size decoded from the header.
Uncompressed size of a chunk.
The most recent Uncompressed Size field.
Uncompressed Size calculated while encoding.
Uncompressed Size calculated while decoding.
Uncompressed size as bytes, or LZMA_VLI_UNKNOWN if end of payload marker is expected.
| uint64_t lzma_coder_s::memlimit |
Memory usage limit.
| uint64_t lzma_coder_s::memusage |
Amount of memory actually needed (only an estimate)
| lzma_options_lzma lzma_coder_s::options |
Options decoded from the header needed to initialize the LZMA decoder
| size_t lzma_coder_s::header_pos |
Read position in header[].
| uint8_t lzma_coder_s::header |
Buffer to hold Stream Header and Stream Footer.
| lzma_block * lzma_coder_s::block |
Decoding options; we also write Compressed Size and Uncompressed Size back to this structure when the decoding has been finished.
Encoding options; we also write Unpadded Size, Compressed Size, and Uncompressed Size back to this structure when the encoding has been finished.
| size_t lzma_coder_s::compressed_size |
Compressed Size calculated while decoding.
Compressed Size calculated while encoding.
Compressed size of a chunk (excluding headers); this is also used to indicate the end of buf[] in SEQ_LZMA_COPY.
| lzma_vli lzma_coder_s::compressed_limit |
Maximum allowed Compressed Size; this takes into account the size of the Block Header and Check fields when Compressed Size is unknown.
| size_t lzma_coder_s::check_pos |
Position when reading the Check field.
| lzma_check_state lzma_coder_s::check |
Check of the uncompressed data.
| bool lzma_coder_s::ignore_check |
True if the integrity check won't be calculated and verified.
If true, we will tell the Block decoder to skip calculating and verifying the integrity check.
| lzma_index * lzma_coder_s::index |
Target Index.
Index to hold sizes of the Blocks.
| lzma_index** lzma_coder_s::index_ptr |
Pointer give by the application, which is set after successful decoding.
| lzma_vli lzma_coder_s::count |
Number of Records left to decode.
| lzma_vli lzma_coder_s::unpadded_size |
The most recent Unpadded Size field.
| uint32_t lzma_coder_s::crc32 |
CRC32 of the List of Records field.
| const lzma_index* lzma_coder_s::index |
Index being encoded.
| lzma_index_iter lzma_coder_s::iter |
Iterator for the Index being encoded.
| lzma_next_coder lzma_coder_s::block_decoder |
Block or Metadata decoder. This takes little memory and the same data structure can be used to decode every Block Header, so it's a good idea to have a separate lzma_next_coder structure for it.
| lzma_block lzma_coder_s::block_options |
Options for the Block encoder.
Block options decoded by the Block Header decoder and used by the Block decoder.
| lzma_stream_flags lzma_coder_s::stream_flags |
Stream Flags from Stream Header.
Stream Flags for encoding the Stream Header and Stream Footer.
| lzma_index_hash* lzma_coder_s::index_hash |
Index is hashed so that it can be compared to the sizes of Blocks with O(1) memory usage.
| bool lzma_coder_s::tell_no_check |
If true, LZMA_NO_CHECK is returned if the Stream has no integrity check.
| bool lzma_coder_s::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_coder_s::tell_any_check |
If true, LZMA_GET_CHECK is returned after decoding Stream Header.
| bool lzma_coder_s::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, and we aren't in the middle of a Stream, and possible Stream Padding is a multiple of four bytes.
| bool lzma_coder_s::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.
| uint8_t lzma_coder_s::buffer |
Temporary buffer.
Buffer to hold Stream Header, Block Header, and Stream Footer. Block Header has biggest maximum size.
| bool lzma_coder_s::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_coder_s::block_encoder |
Block.
| lzma_filter lzma_coder_s::filters |
The filter chain currently in use.
| lzma_next_coder lzma_coder_s::index_encoder |
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.
| size_t lzma_coder_s::buffer_pos |
Read position in buffer[].
| size_t lzma_coder_s::buffer_size |
Total number of bytes in buffer[].
| size_t lzma_coder_s::block_size |
Start a new Block every block_size bytes of input unless LZMA_FULL_FLUSH or LZMA_FULL_BARRIER is used earlier.
Referenced by initialize_new_thread().
| lzma_outq lzma_coder_s::outq |
Output buffer queue for compressed data.
Referenced by wait_for_work().
| uint32_t lzma_coder_s::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_coder_s::thread_error |
Error code from a worker thread.
Referenced by wait_for_work().
| worker_thread* lzma_coder_s::threads |
Array of allocated thread-specific structures.
Referenced by initialize_new_thread(), threads_end(), and threads_stop().
| uint32_t lzma_coder_s::threads_max |
Number of structures in "threads" above. This is also the number of threads that will be created at maximum.
| uint32_t lzma_coder_s::threads_initialized |
Number of thread structures that have been initialized, and thus the number of worker threads actually created so far.
Referenced by initialize_new_thread(), threads_end(), and threads_stop().
| worker_thread* lzma_coder_s::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().
| worker_thread* lzma_coder_s::thr |
The most recent worker thread to which the main thread writes the new input from the application.
| uint64_t lzma_coder_s::progress_in |
Amount of uncompressed data in Blocks that have already been finished.
| uint64_t lzma_coder_s::progress_out |
Amount of compressed data in Stream Header + Blocks that have already been finished.
| size_t lzma_coder_s::distance |
Delta distance.
Referenced by copy_and_encode(), and encode_in_place().
| uint8_t lzma_coder_s::pos |
Position in history[].
| uint8_t lzma_coder_s::history[LZMA_DELTA_DIST_MAX] |
Buffer to hold history of the original data.
Referenced by copy_and_encode(), and encode_in_place().
| lzma_dict lzma_coder_s::dict |
Dictionary (history buffer)
| lzma_lz_decoder lzma_coder_s::lz |
The actual LZ-based decoder e.g. LZMA.
| bool lzma_coder_s::next_finished |
True if the next filter in the chain has returned LZMA_STREAM_END.
| bool lzma_coder_s::this_finished |
True if the LZ decoder (e.g. LZMA) has detected end of payload marker. This may become true before next_finished becomes true.
| size_t lzma_coder_s::size |
Total number of bytes (both filtered and unfiltered) currently in the temporary buffer.
| struct { ... } lzma_coder_s::temp |
Temporary buffer needed when the LZ-based filter is not the last filter in the chain. The output of the next filter is first decoded into buffer[], which is then used as input for the actual LZ-based decoder.
| lzma_lz_encoder lzma_coder_s::lz |
LZ-based encoder e.g. LZMA.
| lzma_mf lzma_coder_s::mf |
History buffer and match finder.
| enum sequence lzma_coder_s::next_sequence |
Sequence after the size fields have been decoded.
| lzma_lz_decoder lzma_coder_s::lzma |
LZMA decoder.
| size_t lzma_coder_s::uncompressed_size |
Uncompressed size of LZMA chunk.
Uncompressed size of a chunk.
| size_t lzma_coder_s::compressed_size |
Compressed size of the chunk (naturally equals to uncompressed size of uncompressed chunk)
Compressed size of a chunk (excluding headers); this is also used to indicate the end of buf[] in SEQ_LZMA_COPY.
| bool lzma_coder_s::need_properties |
True if properties are needed. This is false before the first LZMA chunk.
| bool lzma_coder_s::need_dictionary_reset |
True if dictionary reset is needed. This is false before the first chunk (LZMA or uncompressed).
| lzma_coder* lzma_coder_s::lzma |
LZMA encoder.
| lzma_options_lzma lzma_coder_s::opt_cur |
LZMA options currently in use.
| size_t lzma_coder_s::buf_pos |
Read position in buf[].
| uint8_t lzma_coder_s::buf[LZMA2_HEADER_MAX+LZMA2_CHUNK_MAX] |
Buffer to hold the chunk header and LZMA compressed data.
| probability lzma_coder_s::literal |
Literals; see comments in lzma_common.h.
| probability lzma_coder_s::is_match |
If 1, it's a match. Otherwise it's a single 8-bit literal.
| probability lzma_coder_s::is_rep |
If 1, it's a repeated match. The distance is one of rep0 .. rep3.
| probability lzma_coder_s::is_rep0 |
If 0, distance of a repeated match is rep0. Otherwise check is_rep1.
| probability lzma_coder_s::is_rep1 |
If 0, distance of a repeated match is rep1. Otherwise check is_rep2.
| probability lzma_coder_s::is_rep2 |
If 0, distance of a repeated match is rep2. Otherwise it is rep3.
| probability lzma_coder_s::is_rep0_long |
If 1, the repeated match has length of one byte. Otherwise the length is decoded from rep_len_decoder.
| probability lzma_coder_s::dist_slot |
Probability tree for the highest two bits of the match distance. There is a separate probability tree for match lengths of 2 (i.e. MATCH_LEN_MIN), 3, 4, and [5, 273].
| probability lzma_coder_s::pos_special[FULL_DISTANCES - DIST_MODEL_END] |
Probability trees for additional bits for match distance when the distance is in the range [4, 127].
| probability lzma_coder_s::pos_align[ALIGN_SIZE] |
Probability tree for the lowest four bits of a match distance that is equal to or greater than 128.
| lzma_length_decoder lzma_coder_s::match_len_decoder |
Length of a normal match.
| lzma_length_decoder lzma_coder_s::rep_len_decoder |
Length of a repeated match.
| lzma_lzma_state lzma_coder_s::state |
State.
| uint32_t lzma_coder_s::rep0 |
Distance of the latest match.
| uint32_t lzma_coder_s::rep1 |
Distance of second latest match.
| uint32_t lzma_coder_s::rep2 |
Distance of third latest match.
| uint32_t lzma_coder_s::rep3 |
Distance of fourth latest match.
| uint32_t lzma_coder_s::pos_mask |
(1 << pos_bits) - 1
| enum { ... } lzma_coder_s::sequence |
Position where to continue the decoder loop.
| probability* lzma_coder_s::probs |
Base of the current probability tree.
| uint32_t lzma_coder_s::symbol |
Symbol being decoded. This is also used as an index variable in bittree decoders: probs[symbol]
| uint32_t lzma_coder_s::limit |
Used as a loop termination condition on bittree decoders and direct bits decoder.
| uint32_t lzma_coder_s::offset |
Matched literal decoder: 0x100 or 0 to help avoiding branches. Bittree reverse decoders: Offset of the next bit: 1 << offset
| uint32_t lzma_coder_s::len |
If decoding a literal: match byte. If decoding a match: length of the match.
| lzma_range_encoder lzma_coder_s::rc |
Range encoder.
| uint32_t lzma_coder_s::reps[REPS] |
The four most recent match distances.
| lzma_match lzma_coder_s::matches[MATCH_LEN_MAX+1] |
Array of match candidates.
| uint32_t lzma_coder_s::matches_count |
Number of match candidates in matches[].
| uint32_t lzma_coder_s::longest_match_length |
Variable to hold the length of the longest match between calls to lzma_lzma_optimum_*().
| bool lzma_coder_s::fast_mode |
True if using getoptimumfast.
| bool lzma_coder_s::is_initialized |
True if the encoder has been initialized by encoding the first byte as a literal.
| bool lzma_coder_s::is_flushed |
True if the range encoder has been flushed, but not all bytes have been written to the output buffer yet.
| bool lzma_coder_s::end_was_reached |
True if the next coder in the chain has returned LZMA_STREAM_END.
| bool lzma_coder_s::is_encoder |
True if filter() should encode the data; false to decode. Currently all simple filters use the same function for encoding and decoding, because the difference between encoders and decoders is very small.
| size_t(* lzma_coder_s::filter) (lzma_simple *simple, uint32_t now_pos, bool is_encoder, uint8_t *buffer, size_t size) |
Pointer to filter-specific function, which does the actual filtering.
| lzma_simple* lzma_coder_s::simple |
Pointer to filter-specific data, or NULL if filter doesn't need any extra data.
| uint32_t lzma_coder_s::now_pos |
The lowest 32 bits of the current position in the data. Most filters need this to do conversions between absolute and relative addresses.
| size_t lzma_coder_s::allocated |
Size of the memory allocated for the buffer.
| size_t lzma_coder_s::filtered |
buffer[filtered] is the first unfiltered byte. When pos is smaller than filtered, there is unflushed filtered data in the buffer.
1.8.13