| /** |
| * \file lzma/block.h |
| * \brief .lzma Block handling |
| * |
| * \author Copyright (C) 1999-2006 Igor Pavlov |
| * \author Copyright (C) 2007 Lasse Collin |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| */ |
| |
| #ifndef LZMA_H_INTERNAL |
| # error Never include this file directly. Use <lzma.h> instead. |
| #endif |
| |
| |
| /** |
| * \brief Options for the Block Header encoder and decoder |
| * |
| * Different things use different parts of this structure. Some read |
| * some members, other functions write, and some do both. Only the |
| * members listed for reading need to be initialized when the specified |
| * functions are called. The members marked for writing will be assigned |
| * new values at some point either by calling the given function or by |
| * later calls to lzma_code(). |
| */ |
| typedef struct { |
| /** |
| * \brief Type of integrity Check |
| * |
| * The type of the integrity Check is not stored into the Block |
| * Header, thus its value must be provided also when decoding. |
| * |
| * Read by: |
| * - lzma_block_encoder() |
| * - lzma_block_decoder() |
| */ |
| lzma_check_type check; |
| |
| /** |
| * \brief Precense of CRC32 of the Block Header |
| * |
| * Set this to true if CRC32 of the Block Header should be |
| * calculated and stored in the Block Header. |
| * |
| * There is no way to autodetect if CRC32 is present in the Block |
| * Header, thus this information must be provided also when decoding. |
| * |
| * Read by: |
| * - lzma_block_header_size() |
| * - lzma_block_header_encoder() |
| * - lzma_block_header_decoder() |
| */ |
| lzma_bool has_crc32; |
| |
| /** |
| * \brief Usage of End of Payload Marker |
| * |
| * If this is true, End of Payload Marker is used even if |
| * Uncompressed Size is known. |
| * |
| * Read by: |
| * - lzma_block_header_encoder() |
| * - lzma_block_encoder() |
| * - lzma_block_decoder() |
| * |
| * Written by: |
| * - lzma_block_header_decoder() |
| */ |
| lzma_bool has_eopm; |
| |
| /** |
| * \brief True if the Block is a Metadata Block |
| * |
| * If this is true, the Metadata bit will be set in the Block Header. |
| * It is up to the application to store correctly formatted data |
| * into Metadata Block. |
| * |
| * Read by: |
| * - lzma_block_header_encoder() |
| * |
| * Written by: |
| * - lzma_block_header_decoder() |
| */ |
| lzma_bool is_metadata; |
| |
| /** |
| * \brief True if Uncompressed Size is in Block Footer |
| * |
| * Read by: |
| * - lzma_block_encoder() |
| * - lzma_block_decoder() |
| */ |
| lzma_bool has_uncompressed_size_in_footer; |
| |
| /** |
| * \brief True if Backward Size is in Block Footer |
| * |
| * Read by: |
| * - lzma_block_encoder() |
| * - lzma_block_decoder() |
| */ |
| lzma_bool has_backward_size; |
| |
| /** |
| * \brief True if Block coder should take care of Padding |
| * |
| * In liblzma, Stream decoder sets this to true when decoding |
| * Header Metadata Block or Data Blocks from Multi-Block Stream, |
| * and to false when decoding Single-Block Stream or Footer |
| * Metadata Block from a Multi-Block Stream. |
| * |
| * Read by: |
| * - lzma_block_encoder() |
| * - lzma_block_decoder() |
| */ |
| lzma_bool handle_padding; |
| |
| /** |
| * \brief Size of the Compressed Data in bytes |
| * |
| * Usually you don't know this value when encoding in streamed mode. |
| * In non-streamed mode you can reserve space for this field when |
| * encoding the Block Header the first time, and then re-encode the |
| * Block Header and copy it over the original one after the encoding |
| * of the Block has been finished. |
| * |
| * Read by: |
| * - lzma_block_header_size() |
| * - lzma_block_header_encoder() |
| * - lzma_block_encoder() |
| * - lzma_block_decoder() |
| * |
| * Written by: |
| * - lzma_block_header_decoder() |
| * - lzma_block_encoder() |
| * - lzma_block_decoder() |
| */ |
| lzma_vli compressed_size; |
| |
| /** |
| * \brief Uncompressed Size in bytes |
| * |
| * Encoder: If this value is not LZMA_VLI_VALUE_UNKNOWN, it is stored |
| * to the Uncompressed Size field in the Block Header. The real |
| * uncompressed size of the data being compressed must match |
| * the Uncompressed Size or LZMA_HEADER_ERROR is returned. |
| * |
| * If Uncompressed Size is unknown, End of Payload Marker must |
| * be used. If uncompressed_size == LZMA_VLI_VALUE_UNKNOWN and |
| * has_eopm == 0, LZMA_HEADER_ERROR will be returned. |
| * |
| * Decoder: If this value is not LZMA_VLI_VALUE_UNKNOWN, it is |
| * compared to the real Uncompressed Size. If they do not match, |
| * LZMA_HEADER_ERROR is returned. |
| * |
| * Read by: |
| * - lzma_block_header_size() |
| * - lzma_block_header_encoder() |
| * - lzma_block_encoder() |
| * - lzma_block_decoder() |
| * |
| * Written by: |
| * - lzma_block_header_decoder() |
| * - lzma_block_encoder() |
| * - lzma_block_decoder() |
| */ |
| lzma_vli uncompressed_size; |
| |
| /** |
| * \brief Number of bytes to reserve for Compressed Size |
| * |
| * This is useful if you want to be able to store the Compressed Size |
| * to the Block Header, but you don't know it when starting to encode. |
| * Setting this to non-zero value at maximum of LZMA_VLI_BYTES_MAX, |
| * the Block Header encoder will force the Compressed Size field to |
| * occupy specified number of bytes. You can later rewrite the Block |
| * Header to contain correct information by using otherwise identical |
| * lzma_options_block structure except the correct compressed_size. |
| * |
| * Read by: |
| * - lzma_block_header_size() |
| * - lzma_block_header_encoder() |
| * |
| * Written by: |
| * - lzma_block_header_decoder() |
| */ |
| uint32_t compressed_reserve; |
| |
| /** |
| * \brief Number of bytes to reserve for Uncompressed Size |
| * |
| * See the description of compressed_size above. |
| * |
| * Read by: |
| * - lzma_block_header_size() |
| * - lzma_block_header_encoder() |
| * |
| * Written by: |
| * - lzma_block_header_decoder() |
| */ |
| uint32_t uncompressed_reserve; |
| |
| /** |
| * \brief Total Size of the Block in bytes |
| * |
| * This is useful in the decoder, which can verify the Total Size |
| * if it is known from Index. |
| * |
| * Read by: |
| * - lzma_block_encoder() |
| * - lzma_block_decoder() |
| * |
| * Written by: |
| * - lzma_block_encoder() |
| * - lzma_block_decoder() |
| */ |
| lzma_vli total_size; |
| |
| /** |
| * \brief Upper limit of Total Size |
| * |
| * Read by: |
| * - lzma_block_encoder() |
| * - lzma_block_decoder() |
| */ |
| lzma_vli total_limit; |
| |
| /** |
| * \brief Upper limit of Uncompressed Size |
| * |
| * Read by: |
| * - lzma_block_encoder() |
| * - lzma_block_decoder() |
| */ |
| lzma_vli uncompressed_limit; |
| |
| /** |
| * \brief Array of filters |
| * |
| * There can be at maximum of seven filters. The end of the array |
| * is marked with .id = LZMA_VLI_VALUE_UNKNOWN. Minimum number of |
| * filters is zero; in that case, an implicit Copy filter is used. |
| * |
| * Read by: |
| * - lzma_block_header_size() |
| * - lzma_block_header_encoder() |
| * - lzma_block_encoder() |
| * - lzma_block_decoder() |
| * |
| * Written by: |
| * - lzma_block_header_decoder(): Note that this does NOT free() |
| * the old filter options structures. If decoding fails, the |
| * caller must take care of freeing the options structures |
| * that may have been allocated and decoded before the error |
| * occurred. |
| */ |
| lzma_options_filter filters[8]; |
| |
| /** |
| * \brief Size of the Padding field |
| * |
| * The Padding field exist to allow aligning the Compressed Data field |
| * optimally in the Block. See lzma_options_stream.alignment in |
| * stream.h for more information. |
| * |
| * If you want the Block Header encoder to automatically calculate |
| * optimal size for the Padding field by looking at the information |
| * in filters[], set this to LZMA_BLOCK_HEADER_PADDING_AUTO. In that |
| * case, you must also set the aligmnet variable to tell the the |
| * encoder the aligmnet of the beginning of the Block Header. |
| * |
| * The decoder never sets this to LZMA_BLOCK_HEADER_PADDING_AUTO. |
| * |
| * Read by: |
| * - lzma_block_header_size() |
| * - lzma_block_header_encoder(): Note that this doesn't |
| * accept LZMA_BLOCK_HEADER_PADDING_AUTO. |
| * |
| * Written by (these never set padding to |
| * LZMA_BLOCK_HEADER_PADDING_AUTO): |
| * - lzma_block_header_size() |
| * - lzma_block_header_decoder() |
| */ |
| int32_t padding; |
| # define LZMA_BLOCK_HEADER_PADDING_AUTO (-1) |
| # define LZMA_BLOCK_HEADER_PADDING_MIN 0 |
| # define LZMA_BLOCK_HEADER_PADDING_MAX 31 |
| |
| /** |
| * \brief Alignment of the beginning of the Block Header |
| * |
| * This variable is read only if padding has been set to |
| * LZMA_BLOCK_HEADER_PADDING_AUTO. |
| * |
| * Read by: |
| * - lzma_block_header_size() |
| * - lzma_block_header_encoder() |
| */ |
| uint32_t alignment; |
| |
| /** |
| * \brief Size of the Block Header |
| * |
| * Read by: |
| * - lzma_block_encoder() |
| * - lzma_block_decoder() |
| * |
| * Written by: |
| * - lzma_block_header_size() |
| * - lzma_block_header_decoder() |
| */ |
| uint32_t header_size; |
| |
| } lzma_options_block; |
| |
| |
| /** |
| * \brief Calculates the size of Header Padding and Block Header |
| * |
| * \return - LZMA_OK: Size calculated successfully and stored to |
| * options->header_size. |
| * - LZMA_HEADER_ERROR: Unsupported filters or filter options. |
| * - LZMA_PROG_ERROR: Invalid options |
| * |
| * \note This doesn't check that all the options are valid i.e. this |
| * may return LZMA_OK even if lzma_block_header_encode() or |
| * lzma_block_encoder() would fail. |
| */ |
| extern lzma_ret lzma_block_header_size(lzma_options_block *options); |
| |
| |
| /** |
| * \brief Encodes Block Header |
| * |
| * Encoding of the Block options is done with a single call instead of |
| * first initializing and then doing the actual work with lzma_code(). |
| * |
| * \param out Beginning of the output buffer. This must be |
| * at least options->header_size bytes. |
| * \param options Block options to be encoded. |
| * |
| * \return - LZMA_OK: Encoding was successful. options->header_size |
| * bytes were written to output buffer. |
| * - LZMA_HEADER_ERROR: Invalid or unsupported options. |
| * - LZMA_PROG_ERROR |
| */ |
| extern lzma_ret lzma_block_header_encode( |
| uint8_t *out, const lzma_options_block *options); |
| |
| |
| /** |
| * \brief Initializes Block Header decoder |
| * |
| * Because the results of this decoder are placed into *options, |
| * strm->next_in, strm->avail_in, and strm->total_in are not used. |
| * |
| * The only valid `action' with lzma_code() is LZMA_RUN. |
| * |
| * \return - LZMA_OK: Encoding was successful. options->header_size |
| * bytes were written to output buffer. |
| * - LZMA_HEADER_ERROR: Invalid or unsupported options. |
| * - LZMA_PROG_ERROR |
| */ |
| extern lzma_ret lzma_block_header_decoder( |
| lzma_stream *strm, lzma_options_block *options); |
| |
| |
| /** |
| * \brief Initializes .lzma Block encoder |
| * |
| * This function is required for multi-thread encoding. It may also be |
| * useful when implementing custom file formats. |
| * |
| * \return - LZMA_OK: All good, continue with lzma_code(). |
| * - LZMA_MEM_ERROR |
| * - LZMA_HEADER_ERROR |
| * - LZMA_DATA_ERROR: Limits (total_limit and uncompressed_limit) |
| * have been reached already. |
| * - LZMA_UNSUPPORTED_CHECK: options->check specfies a Check |
| * that is not supported by this buid of liblzma. Initializing |
| * the encoder failed. |
| * - LZMA_PROG_ERROR |
| * |
| * lzma_code() can return FIXME |
| */ |
| extern lzma_ret lzma_block_encoder( |
| lzma_stream *strm, lzma_options_block *options); |
| |
| |
| /** |
| * \brief Initializes decoder for .lzma Block |
| * |
| * \return - LZMA_OK: All good, continue with lzma_code(). |
| * - LZMA_UNSUPPORTED_CHECK: Initialization was successful, but |
| * the given Check type is not supported, thus Check will be |
| * ignored. |
| * - LZMA_PROG_ERROR |
| * - LZMA_MEM_ERROR |
| */ |
| extern lzma_ret lzma_block_decoder( |
| lzma_stream *strm, lzma_options_block *options); |