fork/slippc
git clone https://git.julia.blue/fork/slippc
39f196d
bench
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*/ 58typedef enum { 59LZMA_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 70LZMA_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 81LZMA_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 90LZMA_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 101LZMA_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*/ 128extern LZMA_API (lzma_bool )lzma_mf_is_supported (lzma_match_finder match_finder ) 129lzma_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*/ 138typedef enum { 139LZMA_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 147LZMA_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*/ 170extern LZMA_API (lzma_bool )lzma_mode_is_supported (lzma_mode mode ) 171lzma_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*/ 185typedef 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*/ 217uint32_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*/ 240const 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*/ 254uint32_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*/ 281uint32_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*/ 293uint32_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*/ 316uint32_t pb ; 317# define LZMA_PB_MIN 0 318# define LZMA_PB_MAX 4 319# define LZMA_PB_DEFAULT 2 320 321/** Compression mode */ 322lzma_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*/ 342uint32_t nice_len ; 343 344/** Match finder ID */ 345lzma_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*/ 375uint32_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*/ 384uint32_t reserved_int1 ; 385uint32_t reserved_int2 ; 386uint32_t reserved_int3 ; 387uint32_t reserved_int4 ; 388uint32_t reserved_int5 ; 389uint32_t reserved_int6 ; 390uint32_t reserved_int7 ; 391uint32_t reserved_int8 ; 392lzma_reserved_enum reserved_enum1 ; 393lzma_reserved_enum reserved_enum2 ; 394lzma_reserved_enum reserved_enum3 ; 395lzma_reserved_enum reserved_enum4 ; 396void * reserved_ptr1 ; 397void * 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*/ 419extern LZMA_API (lzma_bool )lzma_lzma_preset ( 420lzma_options_lzma * options ,uint32_t preset )lzma_nothrow ;