mirror of https://git.tukaani.org/xz.git
267 lines
9.3 KiB
C
267 lines
9.3 KiB
C
/**
|
|
* \file lzma/container.h
|
|
* \brief File formats
|
|
*
|
|
* \author Copyright (C) 1999-2008 Igor Pavlov
|
|
* \author Copyright (C) 2007-2008 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
|
|
|
|
|
|
/************
|
|
* Encoding *
|
|
************/
|
|
|
|
/**
|
|
* \brief Compression level names for lzma_easy_* functions
|
|
*
|
|
* At the moment, all the compression levels support LZMA_SYNC_FLUSH.
|
|
* In future there may be levels that don't support LZMA_SYNC_FLUSH.
|
|
* However, the LZMA_SYNC_FLUSH support won't be removed from the
|
|
* existing compression levels.
|
|
*
|
|
* \note If liblzma is built without encoder support, or with some
|
|
* filters disabled, some of the compression levels may be
|
|
* unsupported. In that case, the initialization functions
|
|
* will return LZMA_OPTIONS_ERROR.
|
|
*/
|
|
typedef enum {
|
|
LZMA_EASY_COPY = 0,
|
|
/**<
|
|
* No compression; the data is just wrapped into .lzma
|
|
* container.
|
|
*/
|
|
|
|
LZMA_EASY_LZMA2_1 = 1,
|
|
/**<
|
|
* LZMA2 filter with fast compression (fast in terms of LZMA2).
|
|
* If you are interested in the exact options used, see
|
|
* lzma_preset_lzma[0]. Note that the exact options may
|
|
* change between liblzma versions.
|
|
*
|
|
* At the moment, the command line tool uses these settings
|
|
* when `lzma -1' is used. In future, the command line tool
|
|
* may default to some more complex way to determine the
|
|
* settings used e.g. the type of files being compressed.
|
|
*
|
|
* LZMA_EASY_LZMA_2 is equivalent to lzma_preset_lzma[1]
|
|
* and so on.
|
|
*/
|
|
|
|
LZMA_EASY_LZMA_2 = 2,
|
|
LZMA_EASY_LZMA_3 = 3,
|
|
LZMA_EASY_LZMA_4 = 4,
|
|
LZMA_EASY_LZMA_5 = 5,
|
|
LZMA_EASY_LZMA_6 = 6,
|
|
LZMA_EASY_LZMA_7 = 7,
|
|
LZMA_EASY_LZMA_8 = 8,
|
|
LZMA_EASY_LZMA_9 = 9,
|
|
} lzma_easy_level;
|
|
|
|
|
|
/**
|
|
* \brief Default compression level
|
|
*
|
|
* Data Blocks contain the actual compressed data. It's not straightforward
|
|
* to recommend a default level, because in some cases keeping the resource
|
|
* usage relatively low is more important that getting the maximum
|
|
* compression ratio.
|
|
*/
|
|
#define LZMA_EASY_DEFAULT LZMA_EASY_LZMA2_7
|
|
|
|
|
|
/**
|
|
* \brief Calculates rough memory requirements of a compression level
|
|
*
|
|
* This function is a wrapper for lzma_memory_usage(), which is declared
|
|
* in filter.h.
|
|
*
|
|
* \return Approximate memory usage of the encoder with the given
|
|
* compression level in mebibytes (value * 1024 * 1024 bytes).
|
|
* On error (e.g. compression level is not supported),
|
|
* UINT32_MAX is returned.
|
|
*/
|
|
extern uint64_t lzma_easy_memory_usage(lzma_easy_level level)
|
|
lzma_attr_pure;
|
|
|
|
|
|
/**
|
|
* \brief Initializes .lzma Stream encoder
|
|
*
|
|
* This function is intended for those who just want to use the basic features
|
|
* if liblzma (that is, most developers out there). Lots of assumptions are
|
|
* made, which are correct or at least good enough for most situations.
|
|
*
|
|
* \param strm Pointer to lzma_stream that is at least initialized
|
|
* with LZMA_STREAM_INIT.
|
|
* \param level Compression level to use. This selects a set of
|
|
* compression settings from a list of compression
|
|
* presets.
|
|
*
|
|
* \return - LZMA_OK: Initialization succeeded. Use lzma_code() to
|
|
* encode your data.
|
|
* - LZMA_MEM_ERROR: Memory allocation failed. All memory
|
|
* previously allocated for *strm is now freed.
|
|
* - LZMA_OPTIONS_ERROR: The given compression level is not
|
|
* supported by this build of liblzma.
|
|
*
|
|
* If initialization succeeds, use lzma_code() to do the actual encoding.
|
|
* Valid values for `action' (the second argument of lzma_code()) are
|
|
* LZMA_RUN, LZMA_SYNC_FLUSH, LZMA_FULL_FLUSH, and LZMA_FINISH. In future,
|
|
* there may be compression levels that don't support LZMA_SYNC_FLUSH.
|
|
*/
|
|
extern lzma_ret lzma_easy_encoder(lzma_stream *strm, lzma_easy_level level)
|
|
lzma_attr_warn_unused_result;
|
|
|
|
|
|
/**
|
|
* \brief Initializes .lzma Stream encoder
|
|
*
|
|
* \param strm Pointer to properly prepared lzma_stream
|
|
* \param filters Array of filters. This must be terminated with
|
|
* filters[n].id = LZMA_VLI_UNKNOWN. There must
|
|
* be 1-4 filters, but there are restrictions on how
|
|
* multiple filters can be combined. FIXME Tell where
|
|
* to find more information.
|
|
* \param check Type of the integrity check to calculate from
|
|
* uncompressed data.
|
|
*
|
|
* \return - LZMA_OK: Initialization was successful.
|
|
* - LZMA_MEM_ERROR
|
|
* - LZMA_OPTIONS_ERROR
|
|
* - LZMA_PROG_ERROR
|
|
*/
|
|
extern lzma_ret lzma_stream_encoder(lzma_stream *strm,
|
|
const lzma_filter *filters, lzma_check check)
|
|
lzma_attr_warn_unused_result;
|
|
|
|
|
|
/**
|
|
* \brief Initializes LZMA_Alone (deprecated file format) encoder
|
|
*
|
|
* LZMA_Alone files have the suffix .lzma like the .lzma Stream files.
|
|
* LZMA_Alone format supports only one filter, the LZMA filter. There is
|
|
* no support for integrity checks like CRC32.
|
|
*
|
|
* Use this format if and only if you need to create files readable by
|
|
* legacy LZMA tools such as LZMA Utils 4.32.x.
|
|
*
|
|
* LZMA_Alone encoder doesn't support LZMA_SYNC_FLUSH or LZMA_FULL_FLUSH.
|
|
*
|
|
* \return - LZMA_OK
|
|
* - LZMA_MEM_ERROR
|
|
* - LZMA_PROG_ERROR
|
|
*/
|
|
extern lzma_ret lzma_alone_encoder(
|
|
lzma_stream *strm, const lzma_options_lzma *options)
|
|
lzma_attr_warn_unused_result;
|
|
|
|
|
|
/************
|
|
* Decoding *
|
|
************/
|
|
|
|
/**
|
|
* This flag makes lzma_code() return LZMA_NO_CHECK if the input stream
|
|
* being decoded has no integrity check. Note that when used with
|
|
* lzma_auto_decoder(), all LZMA_Alone files will trigger LZMA_NO_CHECK
|
|
* if LZMA_TELL_NO_CHECK is used.
|
|
*/
|
|
#define LZMA_TELL_NO_CHECK UINT32_C(0x01)
|
|
|
|
|
|
/**
|
|
* This flag makes lzma_code() return LZMA_UNSUPPORTED_CHECK if the input
|
|
* stream has an integrity check, but the type of the integrity check is not
|
|
* supported by this liblzma version or build. Such files can still be
|
|
* decoded, but the integrity check cannot be verified.
|
|
*/
|
|
#define LZMA_TELL_UNSUPPORTED_CHECK UINT32_C(0x02)
|
|
|
|
|
|
/**
|
|
* This flag makes lzma_code() return LZMA_GET_CHECK as soon as the type
|
|
* of the integrity check is known. The type can then be got with
|
|
* lzma_get_check().
|
|
*/
|
|
#define LZMA_TELL_ANY_CHECK UINT32_C(0x04)
|
|
|
|
|
|
/**
|
|
* This flag enables decoding of concatenated files with file formats that
|
|
* allow concatenating compressed files as is. From the formats currently
|
|
* supported by liblzma, only the new .lzma format allows concatenated files.
|
|
* Concatenated files are not allowed with the LZMA_Alone format.
|
|
*
|
|
* This flag also affects the usage of the `action' argument for lzma_code().
|
|
* When LZMA_CONCATENATED is used, lzma_code() won't return LZMA_STREAM_END
|
|
* unless LZMA_FINISH is used as `action'. Thus, the application has to set
|
|
* LZMA_FINISH in the same way as it does when encoding.
|
|
*
|
|
* If LZMA_CONCATENATED is not used, the decoders still accept LZMA_FINISH
|
|
* as `action' for lzma_code(), but the usage of LZMA_FINISH isn't required.
|
|
*/
|
|
#define LZMA_CONCATENATED UINT32_C(0x08)
|
|
|
|
|
|
/**
|
|
* \brief Initializes decoder for .lzma Stream
|
|
*
|
|
* \param strm Pointer to properly prepared lzma_stream
|
|
* \param memlimit Rough memory usage limit as bytes
|
|
*
|
|
* \return - LZMA_OK: Initialization was successful.
|
|
* - LZMA_MEM_ERROR: Cannot allocate memory.
|
|
* - LZMA_OPTIONS_ERROR: Unsupported flags
|
|
*/
|
|
extern lzma_ret lzma_stream_decoder(
|
|
lzma_stream *strm, uint64_t memlimit, uint32_t flags)
|
|
lzma_attr_warn_unused_result;
|
|
|
|
|
|
/**
|
|
* \brief Decode .lzma Streams and LZMA_Alone files with autodetection
|
|
*
|
|
* Autodetects between the .lzma Stream and LZMA_Alone formats, and
|
|
* calls lzma_stream_decoder() or lzma_alone_decoder() once the type
|
|
* of the file has been detected.
|
|
*
|
|
* \param strm Pointer to propertily prepared lzma_stream
|
|
* \param memlimit Rough memory usage limit as bytes
|
|
* \param flags Bitwise-or of flags, or zero for no flags.
|
|
*
|
|
* \return - LZMA_OK: Initialization was successful.
|
|
* - LZMA_MEM_ERROR: Cannot allocate memory.
|
|
* - LZMA_OPTIONS_ERROR: Unsupported flags
|
|
*/
|
|
extern lzma_ret lzma_auto_decoder(
|
|
lzma_stream *strm, uint64_t memlimit, uint32_t flags)
|
|
lzma_attr_warn_unused_result;
|
|
|
|
|
|
/**
|
|
* \brief Initializes decoder for LZMA_Alone file
|
|
*
|
|
* Valid `action' arguments to lzma_code() are LZMA_RUN and LZMA_FINISH.
|
|
* There is no need to use LZMA_FINISH, but allowing it may simplify
|
|
* certain types of applications.
|
|
*
|
|
* \return - LZMA_OK
|
|
* - LZMA_MEM_ERROR
|
|
*/
|
|
extern lzma_ret lzma_alone_decoder(lzma_stream *strm, uint64_t memlimit)
|
|
lzma_attr_warn_unused_result;
|