1 /** 2 * \file lzma/lzma12.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 alignment 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; 421