api/lzma/lzma.h

/**
 * \file        lzma/lzma.h
 * \brief       LZMA1 and LZMA2 filters
 */

/*
 * Author: Lasse Collin
 *
 * This file has been put into the public domain.
 * You can do whatever you want with this file.
 *
 * See ../lzma.h for information about liblzma as a whole.
 */

#ifndef LZMA_H_INTERNAL
#       error Never include this file directly. Use <lzma.h> instead.
#endif


/**
 * \brief       LZMA1 Filter ID
 *
 * LZMA1 is the very same thing as what was called just LZMA in LZMA Utils,
 * 7-Zip, and LZMA SDK. It's called LZMA1 here to prevent developers from
 * accidentally using LZMA when they actually want LZMA2.
 *
 * LZMA1 shouldn't be used for new applications unless you _really_ know
 * what you are doing. LZMA2 is almost always a better choice.
 */
#define LZMA_FILTER_LZMA1       LZMA_VLI_C(0x4000000000000001)

/**
 * \brief       LZMA2 Filter ID
 *
 * Usually you want this instead of LZMA1. Compared to LZMA1, LZMA2 adds
 * support for LZMA_SYNC_FLUSH, uncompressed chunks (smaller expansion
 * when trying to compress uncompressible data), possibility to change
 * lc/lp/pb in the middle of encoding, and some other internal improvements.
 */
#define LZMA_FILTER_LZMA2       LZMA_VLI_C(0x21)


/**
 * \brief       Match finders
 *
 * Match finder has major effect on both speed and compression ratio.
 * Usually hash chains are faster than binary trees.
 *
 * If you will use LZMA_SYNC_FLUSH often, the hash chains may be a better
 * choice, because binary trees get much higher compression ratio penalty
 * with LZMA_SYNC_FLUSH.
 *
 * The memory usage formulas are only rough estimates, which are closest to
 * reality when dict_size is a power of two. The formulas are  more complex
 * in reality, and can also change a little between liblzma versions. Use
 * lzma_raw_encoder_memusage() to get more accurate estimate of memory usage.
 */
typedef enum {
        LZMA_MF_HC3     = 0x03,
                /**<
                 * \brief       Hash Chain with 2- and 3-byte hashing
                 *
                 * Minimum nice_len: 3
                 *
                 * Memory usage:
                 *  - dict_size <= 16 MiB: dict_size * 7.5
                 *  - dict_size > 16 MiB: dict_size * 5.5 + 64 MiB
                 */

        LZMA_MF_HC4     = 0x04,
                /**<
                 * \brief       Hash Chain with 2-, 3-, and 4-byte hashing
                 *
                 * Minimum nice_len: 4
                 *
                 * Memory usage:
                 *  - dict_size <= 32 MiB: dict_size * 7.5
                 *  - dict_size > 32 MiB: dict_size * 6.5
                 */

        LZMA_MF_BT2     = 0x12,
                /**<
                 * \brief       Binary Tree with 2-byte hashing
                 *
                 * Minimum nice_len: 2
                 *
                 * Memory usage: dict_size * 9.5
                 */

        LZMA_MF_BT3     = 0x13,
                /**<
                 * \brief       Binary Tree with 2- and 3-byte hashing
                 *
                 * Minimum nice_len: 3
                 *
                 * Memory usage:
                 *  - dict_size <= 16 MiB: dict_size * 11.5
                 *  - dict_size > 16 MiB: dict_size * 9.5 + 64 MiB
                 */

        LZMA_MF_BT4     = 0x14
                /**<
                 * \brief       Binary Tree with 2-, 3-, and 4-byte hashing
                 *
                 * Minimum nice_len: 4
                 *
                 * Memory usage:
                 *  - dict_size <= 32 MiB: dict_size * 11.5
                 *  - dict_size > 32 MiB: dict_size * 10.5
                 */
} lzma_match_finder;


/**
 * \brief       Test if given match finder is supported
 *
 * Return true if the given match finder is supported by this liblzma build.
 * Otherwise false is returned. It is safe to call this with a value that
 * isn't listed in lzma_match_finder enumeration; the return value will be
 * false.
 *
 * There is no way to list which match finders are available in this
 * particular liblzma version and build. It would be useless, because
 * a new match finder, which the application developer wasn't aware,
 * could require giving additional options to the encoder that the older
 * match finders don't need.
 */
extern LZMA_API(lzma_bool) lzma_mf_is_supported(lzma_match_finder match_finder)
                lzma_nothrow lzma_attr_const;


/**
 * \brief       Compression modes
 *
 * This selects the function used to analyze the data produced by the match
 * finder.
 */
typedef enum {
        LZMA_MODE_FAST = 1,
                /**<
                 * \brief       Fast compression
                 *
                 * Fast mode is usually at its best when combined with
                 * a hash chain match finder.
                 */

        LZMA_MODE_NORMAL = 2
                /**<
                 * \brief       Normal compression
                 *
                 * This is usually notably slower than fast mode. Use this
                 * together with binary tree match finders to expose the
                 * full potential of the LZMA1 or LZMA2 encoder.
                 */
} lzma_mode;


/**
 * \brief       Test if given compression mode is supported
 *
 * Return true if the given compression mode is supported by this liblzma
 * build. Otherwise false is returned. It is safe to call this with a value
 * that isn't listed in lzma_mode enumeration; the return value will be false.
 *
 * There is no way to list which modes are available in this particular
 * liblzma version and build. It would be useless, because a new compression
 * mode, which the application developer wasn't aware, could require giving
 * additional options to the encoder that the older modes don't need.
 */
extern LZMA_API(lzma_bool) lzma_mode_is_supported(lzma_mode mode)
                lzma_nothrow lzma_attr_const;


/**
 * \brief       Options specific to the LZMA1 and LZMA2 filters
 *
 * Since LZMA1 and LZMA2 share most of the code, it's simplest to share
 * the options structure too. For encoding, all but the reserved variables
 * need to be initialized unless specifically mentioned otherwise.
 * lzma_lzma_preset() can be used to get a good starting point.
 *
 * For raw decoding, both LZMA1 and LZMA2 need dict_size, preset_dict, and
 * preset_dict_size (if preset_dict != NULL). LZMA1 needs also lc, lp, and pb.
 */
typedef struct {
        /**
         * \brief       Dictionary size in bytes
         *
         * Dictionary size indicates how many bytes of the recently processed
         * uncompressed data is kept in memory. One method to reduce size of
         * the uncompressed data is to store distance-length pairs, which
         * indicate what data to repeat from the dictionary buffer. Thus,
         * the bigger the dictionary, the better the compression ratio
         * usually is.
         *
         * Maximum size of the dictionary depends on multiple things:
         *  - Memory usage limit
         *  - Available address space (not a problem on 64-bit systems)
         *  - Selected match finder (encoder only)
         *
         * Currently the maximum dictionary size for encoding is 1.5 GiB
         * (i.e. (UINT32_C(1) << 30) + (UINT32_C(1) << 29)) even on 64-bit
         * systems for certain match finder implementation reasons. In the
         * future, there may be match finders that support bigger
         * dictionaries.
         *
         * Decoder already supports dictionaries up to 4 GiB - 1 B (i.e.
         * UINT32_MAX), so increasing the maximum dictionary size of the
         * encoder won't cause problems for old decoders.
         *
         * Because extremely small dictionaries sizes would have unneeded
         * overhead in the decoder, the minimum dictionary size is 4096 bytes.
         *
         * \note        When decoding, too big dictionary does no other harm
         *              than wasting memory.
         */
        uint32_t dict_size;
#       define LZMA_DICT_SIZE_MIN       UINT32_C(4096)
#       define LZMA_DICT_SIZE_DEFAULT   (UINT32_C(1) << 23)

        /**
         * \brief       Pointer to an initial dictionary
         *
         * It is possible to initialize the LZ77 history window using
         * a preset dictionary. It is useful when compressing many
         * similar, relatively small chunks of data independently from
         * each other. The preset dictionary should contain typical
         * strings that occur in the files being compressed. The most
         * probable strings should be near the end of the preset dictionary.
         *
         * This feature should be used only in special situations. For
         * now, it works correctly only with raw encoding and decoding.
         * Currently none of the container formats supported by
         * liblzma allow preset dictionary when decoding, thus if
         * you create a .xz or .lzma file with preset dictionary, it
         * cannot be decoded with the regular decoder functions. In the
         * future, the .xz format will likely get support for preset
         * dictionary though.
         */
        const uint8_t *preset_dict;

        /**
         * \brief       Size of the preset dictionary
         *
         * Specifies the size of the preset dictionary. If the size is
         * bigger than dict_size, only the last dict_size bytes are
         * processed.
         *
         * This variable is read only when preset_dict is not NULL.
         * If preset_dict is not NULL but preset_dict_size is zero,
         * no preset dictionary is used (identical to only setting
         * preset_dict to NULL).
         */
        uint32_t preset_dict_size;

        /**
         * \brief       Number of literal context bits
         *
         * How many of the highest bits of the previous uncompressed
         * eight-bit byte (also known as `literal') are taken into
         * account when predicting the bits of the next literal.
         *
         * E.g. in typical English text, an upper-case letter is
         * often followed by a lower-case letter, and a lower-case
         * letter is usually followed by another lower-case letter.
         * In the US-ASCII character set, the highest three bits are 010
         * for upper-case letters and 011 for lower-case letters.
         * When lc is at least 3, the literal coding can take advantage of
         * this property in the uncompressed data.
         *
         * There is a limit that applies to literal context bits and literal
         * position bits together: lc + lp <= 4. Without this limit the
         * decoding could become very slow, which could have security related
         * results in some cases like email servers doing virus scanning.
         * This limit also simplifies the internal implementation in liblzma.
         *
         * There may be LZMA1 streams that have lc + lp > 4 (maximum possible
         * lc would be 8). It is not possible to decode such streams with
         * liblzma.
         */
        uint32_t lc;
#       define LZMA_LCLP_MIN    0
#       define LZMA_LCLP_MAX    4
#       define LZMA_LC_DEFAULT  3

        /**
         * \brief       Number of literal position bits
         *
         * lp affects what kind of alignment in the uncompressed data is
         * assumed when encoding literals. A literal is a single 8-bit byte.
         * See pb below for more information about alignment.
         */
        uint32_t lp;
#       define LZMA_LP_DEFAULT  0

        /**
         * \brief       Number of position bits
         *
         * pb affects what kind of alignment in the uncompressed data is
         * assumed in general. The default means four-byte alignment
         * (2^ pb =2^2=4), which is often a good choice when there's
         * no better guess.
         *
         * When the aligment is known, setting pb accordingly may reduce
         * the file size a little. E.g. with text files having one-byte
         * alignment (US-ASCII, ISO-8859-*, UTF-8), setting pb=0 can
         * improve compression slightly. For UTF-16 text, pb=1 is a good
         * choice. If the alignment is an odd number like 3 bytes, pb=0
         * might be the best choice.
         *
         * Even though the assumed alignment can be adjusted with pb and
         * lp, LZMA1 and LZMA2 still slightly favor 16-byte alignment.
         * It might be worth taking into account when designing file formats
         * that are likely to be often compressed with LZMA1 or LZMA2.
         */
        uint32_t pb;
#       define LZMA_PB_MIN      0
#       define LZMA_PB_MAX      4
#       define LZMA_PB_DEFAULT  2

        /** Compression mode */
        lzma_mode mode;

        /**
         * \brief       Nice length of a match
         *
         * This determines how many bytes the encoder compares from the match
         * candidates when looking for the best match. Once a match of at
         * least nice_len bytes long is found, the encoder stops looking for
         * better candidates and encodes the match. (Naturally, if the found
         * match is actually longer than nice_len, the actual length is
         * encoded; it's not truncated to nice_len.)
         *
         * Bigger values usually increase the compression ratio and
         * compression time. For most files, 32 to 128 is a good value,
         * which gives very good compression ratio at good speed.
         *
         * The exact minimum value depends on the match finder. The maximum
         * is 273, which is the maximum length of a match that LZMA1 and
         * LZMA2 can encode.
         */
        uint32_t nice_len;

        /** Match finder ID */
        lzma_match_finder mf;

        /**
         * \brief       Maximum search depth in the match finder
         *
         * For every input byte, match finder searches through the hash chain
         * or binary tree in a loop, each iteration going one step deeper in
         * the chain or tree. The searching stops if
         *  - a match of at least nice_len bytes long is found;
         *  - all match candidates from the hash chain or binary tree have
         *    been checked; or
         *  - maximum search depth is reached.
         *
         * Maximum search depth is needed to prevent the match finder from
         * wasting too much time in case there are lots of short match
         * candidates. On the other hand, stopping the search before all
         * candidates have been checked can reduce compression ratio.
         *
         * Setting depth to zero tells liblzma to use an automatic default
         * value, that depends on the selected match finder and nice_len.
         * The default is in the range [4, 200] or so (it may vary between
         * liblzma versions).
         *
         * Using a bigger depth value than the default can increase
         * compression ratio in some cases. There is no strict maximum value,
         * but high values (thousands or millions) should be used with care:
         * the encoder could remain fast enough with typical input, but
         * malicious input could cause the match finder to slow down
         * dramatically, possibly creating a denial of service attack.
         */
        uint32_t depth;

        /*
         * Reserved space to allow possible future extensions without
         * breaking the ABI. You should not touch these, because the names
         * of these variables may change. These are and will never be used
         * with the currently supported options, so it is safe to leave these
         * uninitialized.
         */
        uint32_t reserved_int1;
        uint32_t reserved_int2;
        uint32_t reserved_int3;
        uint32_t reserved_int4;
        uint32_t reserved_int5;
        uint32_t reserved_int6;
        uint32_t reserved_int7;
        uint32_t reserved_int8;
        lzma_reserved_enum reserved_enum1;
        lzma_reserved_enum reserved_enum2;
        lzma_reserved_enum reserved_enum3;
        lzma_reserved_enum reserved_enum4;
        void *reserved_ptr1;
        void *reserved_ptr2;

} lzma_options_lzma;


/**
 * \brief       Set a compression preset to lzma_options_lzma structure
 *
 * 0 is the fastest and 9 is the slowest. These match the switches -0 .. -9
 * of the xz command line tool. In addition, it is possible to bitwise-or
 * flags to the preset. Currently only LZMA_PRESET_EXTREME is supported.
 * The flags are defined in container.h, because the flags are used also
 * with lzma_easy_encoder().
 *
 * The preset values are subject to changes between liblzma versions.
 *
 * This function is available only if LZMA1 or LZMA2 encoder has been enabled
 * when building liblzma.
 *
 * \return      On success, false is returned. If the preset is not
 *              supported, true is returned.
 */
extern LZMA_API(lzma_bool) lzma_lzma_preset(
                lzma_options_lzma *options, uint32_t preset) lzma_nothrow;
Revision:	6433
Committed:	Mon Dec 2 02:59:32 2013 UTC (10 years, 4 months ago) by laffer1
Content type:	text/plain
File size:	14741 byte(s)
Log Message:	remove cvs2svn:cvs-rev property
#	Content
1	/**
2	* \file lzma/lzma.h
3	* \brief LZMA1 and LZMA2 filters
4	*/
5
6	/*
7	* Author: Lasse Collin
8	*
9	* This file has been put into the public domain.
10	* You can do whatever you want with this file.
11	*
12	* See ../lzma.h for information about liblzma as a whole.
13	*/
14
15	#ifndef LZMA_H_INTERNAL
16	# error Never include this file directly. Use <lzma.h> instead.
17	#endif
18
19
20	/**
21	* \brief LZMA1 Filter ID
22	*
23	* LZMA1 is the very same thing as what was called just LZMA in LZMA Utils,
24	* 7-Zip, and LZMA SDK. It's called LZMA1 here to prevent developers from
25	* accidentally using LZMA when they actually want LZMA2.
26	*
27	* LZMA1 shouldn't be used for new applications unless you _really_ know
28	* what you are doing. LZMA2 is almost always a better choice.
29	*/
30	#define LZMA_FILTER_LZMA1 LZMA_VLI_C(0x4000000000000001)
31
32	/**
33	* \brief LZMA2 Filter ID
34	*
35	* Usually you want this instead of LZMA1. Compared to LZMA1, LZMA2 adds
36	* support for LZMA_SYNC_FLUSH, uncompressed chunks (smaller expansion
37	* when trying to compress uncompressible data), possibility to change
38	* lc/lp/pb in the middle of encoding, and some other internal improvements.
39	*/
40	#define LZMA_FILTER_LZMA2 LZMA_VLI_C(0x21)
41
42
43	/**
44	* \brief Match finders
45	*
46	* Match finder has major effect on both speed and compression ratio.
47	* Usually hash chains are faster than binary trees.
48	*
49	* If you will use LZMA_SYNC_FLUSH often, the hash chains may be a better
50	* choice, because binary trees get much higher compression ratio penalty
51	* with LZMA_SYNC_FLUSH.
52	*
53	* The memory usage formulas are only rough estimates, which are closest to
54	* reality when dict_size is a power of two. The formulas are more complex
55	* in reality, and can also change a little between liblzma versions. Use
56	* lzma_raw_encoder_memusage() to get more accurate estimate of memory usage.
57	*/
58	typedef enum {
59	LZMA_MF_HC3 = 0x03,
60	/**<
61	* \brief Hash Chain with 2- and 3-byte hashing
62	*
63	* Minimum nice_len: 3
64	*
65	* Memory usage:
66	* - dict_size <= 16 MiB: dict_size * 7.5
67	* - dict_size > 16 MiB: dict_size * 5.5 + 64 MiB
68	*/
69
70	LZMA_MF_HC4 = 0x04,
71	/**<
72	* \brief Hash Chain with 2-, 3-, and 4-byte hashing
73	*
74	* Minimum nice_len: 4
75	*
76	* Memory usage:
77	* - dict_size <= 32 MiB: dict_size * 7.5
78	* - dict_size > 32 MiB: dict_size * 6.5
79	*/
80
81	LZMA_MF_BT2 = 0x12,
82	/**<
83	* \brief Binary Tree with 2-byte hashing
84	*
85	* Minimum nice_len: 2
86	*
87	* Memory usage: dict_size * 9.5
88	*/
89
90	LZMA_MF_BT3 = 0x13,
91	/**<
92	* \brief Binary Tree with 2- and 3-byte hashing
93	*
94	* Minimum nice_len: 3
95	*
96	* Memory usage:
97	* - dict_size <= 16 MiB: dict_size * 11.5
98	* - dict_size > 16 MiB: dict_size * 9.5 + 64 MiB
99	*/
100
101	LZMA_MF_BT4 = 0x14
102	/**<
103	* \brief Binary Tree with 2-, 3-, and 4-byte hashing
104	*
105	* Minimum nice_len: 4
106	*
107	* Memory usage:
108	* - dict_size <= 32 MiB: dict_size * 11.5
109	* - dict_size > 32 MiB: dict_size * 10.5
110	*/
111	} lzma_match_finder;
112
113
114	/**
115	* \brief Test if given match finder is supported
116	*
117	* Return true if the given match finder is supported by this liblzma build.
118	* Otherwise false is returned. It is safe to call this with a value that
119	* isn't listed in lzma_match_finder enumeration; the return value will be
120	* false.
121	*
122	* There is no way to list which match finders are available in this
123	* particular liblzma version and build. It would be useless, because
124	* a new match finder, which the application developer wasn't aware,
125	* could require giving additional options to the encoder that the older
126	* match finders don't need.
127	*/
128	extern LZMA_API(lzma_bool) lzma_mf_is_supported(lzma_match_finder match_finder)
129	lzma_nothrow lzma_attr_const;
130
131
132	/**
133	* \brief Compression modes
134	*
135	* This selects the function used to analyze the data produced by the match
136	* finder.
137	*/
138	typedef enum {
139	LZMA_MODE_FAST = 1,
140	/**<
141	* \brief Fast compression
142	*
143	* Fast mode is usually at its best when combined with
144	* a hash chain match finder.
145	*/
146
147	LZMA_MODE_NORMAL = 2
148	/**<
149	* \brief Normal compression
150	*
151	* This is usually notably slower than fast mode. Use this
152	* together with binary tree match finders to expose the
153	* full potential of the LZMA1 or LZMA2 encoder.
154	*/
155	} lzma_mode;
156
157
158	/**
159	* \brief Test if given compression mode is supported
160	*
161	* Return true if the given compression mode is supported by this liblzma
162	* build. Otherwise false is returned. It is safe to call this with a value
163	* that isn't listed in lzma_mode enumeration; the return value will be false.
164	*
165	* There is no way to list which modes are available in this particular
166	* liblzma version and build. It would be useless, because a new compression
167	* mode, which the application developer wasn't aware, could require giving
168	* additional options to the encoder that the older modes don't need.
169	*/
170	extern LZMA_API(lzma_bool) lzma_mode_is_supported(lzma_mode mode)
171	lzma_nothrow lzma_attr_const;
172
173
174	/**
175	* \brief Options specific to the LZMA1 and LZMA2 filters
176	*
177	* Since LZMA1 and LZMA2 share most of the code, it's simplest to share
178	* the options structure too. For encoding, all but the reserved variables
179	* need to be initialized unless specifically mentioned otherwise.
180	* lzma_lzma_preset() can be used to get a good starting point.
181	*
182	* For raw decoding, both LZMA1 and LZMA2 need dict_size, preset_dict, and
183	* preset_dict_size (if preset_dict != NULL). LZMA1 needs also lc, lp, and pb.
184	*/
185	typedef struct {
186	/**
187	* \brief Dictionary size in bytes
188	*
189	* Dictionary size indicates how many bytes of the recently processed
190	* uncompressed data is kept in memory. One method to reduce size of
191	* the uncompressed data is to store distance-length pairs, which
192	* indicate what data to repeat from the dictionary buffer. Thus,
193	* the bigger the dictionary, the better the compression ratio
194	* usually is.
195	*
196	* Maximum size of the dictionary depends on multiple things:
197	* - Memory usage limit
198	* - Available address space (not a problem on 64-bit systems)
199	* - Selected match finder (encoder only)
200	*
201	* Currently the maximum dictionary size for encoding is 1.5 GiB
202	* (i.e. (UINT32_C(1) << 30) + (UINT32_C(1) << 29)) even on 64-bit
203	* systems for certain match finder implementation reasons. In the
204	* future, there may be match finders that support bigger
205	* dictionaries.
206	*
207	* Decoder already supports dictionaries up to 4 GiB - 1 B (i.e.
208	* UINT32_MAX), so increasing the maximum dictionary size of the
209	* encoder won't cause problems for old decoders.
210	*
211	* Because extremely small dictionaries sizes would have unneeded
212	* overhead in the decoder, the minimum dictionary size is 4096 bytes.
213	*
214	* \note When decoding, too big dictionary does no other harm
215	* than wasting memory.
216	*/
217	uint32_t dict_size;
218	# define LZMA_DICT_SIZE_MIN UINT32_C(4096)
219	# define LZMA_DICT_SIZE_DEFAULT (UINT32_C(1) << 23)
220
221	/**
222	* \brief Pointer to an initial dictionary
223	*
224	* It is possible to initialize the LZ77 history window using
225	* a preset dictionary. It is useful when compressing many
226	* similar, relatively small chunks of data independently from
227	* each other. The preset dictionary should contain typical
228	* strings that occur in the files being compressed. The most
229	* probable strings should be near the end of the preset dictionary.
230	*
231	* This feature should be used only in special situations. For
232	* now, it works correctly only with raw encoding and decoding.
233	* Currently none of the container formats supported by
234	* liblzma allow preset dictionary when decoding, thus if
235	* you create a .xz or .lzma file with preset dictionary, it
236	* cannot be decoded with the regular decoder functions. In the
237	* future, the .xz format will likely get support for preset
238	* dictionary though.
239	*/
240	const uint8_t *preset_dict;
241
242	/**
243	* \brief Size of the preset dictionary
244	*
245	* Specifies the size of the preset dictionary. If the size is
246	* bigger than dict_size, only the last dict_size bytes are
247	* processed.
248	*
249	* This variable is read only when preset_dict is not NULL.
250	* If preset_dict is not NULL but preset_dict_size is zero,
251	* no preset dictionary is used (identical to only setting
252	* preset_dict to NULL).
253	*/
254	uint32_t preset_dict_size;
255
256	/**
257	* \brief Number of literal context bits
258	*
259	* How many of the highest bits of the previous uncompressed
260	* eight-bit byte (also known as `literal') are taken into
261	* account when predicting the bits of the next literal.
262	*
263	* E.g. in typical English text, an upper-case letter is
264	* often followed by a lower-case letter, and a lower-case
265	* letter is usually followed by another lower-case letter.
266	* In the US-ASCII character set, the highest three bits are 010
267	* for upper-case letters and 011 for lower-case letters.
268	* When lc is at least 3, the literal coding can take advantage of
269	* this property in the uncompressed data.
270	*
271	* There is a limit that applies to literal context bits and literal
272	* position bits together: lc + lp <= 4. Without this limit the
273	* decoding could become very slow, which could have security related
274	* results in some cases like email servers doing virus scanning.
275	* This limit also simplifies the internal implementation in liblzma.
276	*
277	* There may be LZMA1 streams that have lc + lp > 4 (maximum possible
278	* lc would be 8). It is not possible to decode such streams with
279	* liblzma.
280	*/
281	uint32_t lc;
282	# define LZMA_LCLP_MIN 0
283	# define LZMA_LCLP_MAX 4
284	# define LZMA_LC_DEFAULT 3
285
286	/**
287	* \brief Number of literal position bits
288	*
289	* lp affects what kind of alignment in the uncompressed data is
290	* assumed when encoding literals. A literal is a single 8-bit byte.
291	* See pb below for more information about alignment.
292	*/
293	uint32_t lp;
294	# define LZMA_LP_DEFAULT 0
295
296	/**
297	* \brief Number of position bits
298	*
299	* pb affects what kind of alignment in the uncompressed data is
300	* assumed in general. The default means four-byte alignment
301	* (2^ pb =2^2=4), which is often a good choice when there's
302	* no better guess.
303	*
304	* When the aligment is known, setting pb accordingly may reduce
305	* the file size a little. E.g. with text files having one-byte
306	* alignment (US-ASCII, ISO-8859-*, UTF-8), setting pb=0 can
307	* improve compression slightly. For UTF-16 text, pb=1 is a good
308	* choice. If the alignment is an odd number like 3 bytes, pb=0
309	* might be the best choice.
310	*
311	* Even though the assumed alignment can be adjusted with pb and
312	* lp, LZMA1 and LZMA2 still slightly favor 16-byte alignment.
313	* It might be worth taking into account when designing file formats
314	* that are likely to be often compressed with LZMA1 or LZMA2.
315	*/
316	uint32_t pb;
317	# define LZMA_PB_MIN 0
318	# define LZMA_PB_MAX 4
319	# define LZMA_PB_DEFAULT 2
320
321	/** Compression mode */
322	lzma_mode mode;
323
324	/**
325	* \brief Nice length of a match
326	*
327	* This determines how many bytes the encoder compares from the match
328	* candidates when looking for the best match. Once a match of at
329	* least nice_len bytes long is found, the encoder stops looking for
330	* better candidates and encodes the match. (Naturally, if the found
331	* match is actually longer than nice_len, the actual length is
332	* encoded; it's not truncated to nice_len.)
333	*
334	* Bigger values usually increase the compression ratio and
335	* compression time. For most files, 32 to 128 is a good value,
336	* which gives very good compression ratio at good speed.
337	*
338	* The exact minimum value depends on the match finder. The maximum
339	* is 273, which is the maximum length of a match that LZMA1 and
340	* LZMA2 can encode.
341	*/
342	uint32_t nice_len;
343
344	/** Match finder ID */
345	lzma_match_finder mf;
346
347	/**
348	* \brief Maximum search depth in the match finder
349	*
350	* For every input byte, match finder searches through the hash chain
351	* or binary tree in a loop, each iteration going one step deeper in
352	* the chain or tree. The searching stops if
353	* - a match of at least nice_len bytes long is found;
354	* - all match candidates from the hash chain or binary tree have
355	* been checked; or
356	* - maximum search depth is reached.
357	*
358	* Maximum search depth is needed to prevent the match finder from
359	* wasting too much time in case there are lots of short match
360	* candidates. On the other hand, stopping the search before all
361	* candidates have been checked can reduce compression ratio.
362	*
363	* Setting depth to zero tells liblzma to use an automatic default
364	* value, that depends on the selected match finder and nice_len.
365	* The default is in the range [4, 200] or so (it may vary between
366	* liblzma versions).
367	*
368	* Using a bigger depth value than the default can increase
369	* compression ratio in some cases. There is no strict maximum value,
370	* but high values (thousands or millions) should be used with care:
371	* the encoder could remain fast enough with typical input, but
372	* malicious input could cause the match finder to slow down
373	* dramatically, possibly creating a denial of service attack.
374	*/
375	uint32_t depth;
376
377	/*
378	* Reserved space to allow possible future extensions without
379	* breaking the ABI. You should not touch these, because the names
380	* of these variables may change. These are and will never be used
381	* with the currently supported options, so it is safe to leave these
382	* uninitialized.
383	*/
384	uint32_t reserved_int1;
385	uint32_t reserved_int2;
386	uint32_t reserved_int3;
387	uint32_t reserved_int4;
388	uint32_t reserved_int5;
389	uint32_t reserved_int6;
390	uint32_t reserved_int7;
391	uint32_t reserved_int8;
392	lzma_reserved_enum reserved_enum1;
393	lzma_reserved_enum reserved_enum2;
394	lzma_reserved_enum reserved_enum3;
395	lzma_reserved_enum reserved_enum4;
396	void *reserved_ptr1;
397	void *reserved_ptr2;
398
399	} lzma_options_lzma;
400
401
402	/**
403	* \brief Set a compression preset to lzma_options_lzma structure
404	*
405	* 0 is the fastest and 9 is the slowest. These match the switches -0 .. -9
406	* of the xz command line tool. In addition, it is possible to bitwise-or
407	* flags to the preset. Currently only LZMA_PRESET_EXTREME is supported.
408	* The flags are defined in container.h, because the flags are used also
409	* with lzma_easy_encoder().
410	*
411	* The preset values are subject to changes between liblzma versions.
412	*
413	* This function is available only if LZMA1 or LZMA2 encoder has been enabled
414	* when building liblzma.
415	*
416	* \return On success, false is returned. If the preset is not
417	* supported, true is returned.
418	*/
419	extern LZMA_API(lzma_bool) lzma_lzma_preset(
420	lzma_options_lzma *options, uint32_t preset) lzma_nothrow;