lib_generic/lzma/lzma.txt

   1 LZMA SDK 4.57
   2 -------------
   3
   4 LZMA SDK   Copyright (C) 1999-2007 Igor Pavlov
   5
   6 LZMA SDK provides the documentation, samples, header files, libraries,
   7 and tools you need to develop applications that use LZMA compression.
   8
   9 LZMA is default and general compression method of 7z format
  10 in 7-Zip compression program (www.7-zip.org). LZMA provides high
  11 compression ratio and very fast decompression.
  12
  13 LZMA is an improved version of famous LZ77 compression algorithm.
  14 It was improved in way of maximum increasing of compression ratio,
  15 keeping high decompression speed and low memory requirements for
  16 decompressing.
  17
  18
  19
  20 LICENSE
  21 -------
  22
  23 LZMA SDK is available under any of the following licenses:
  24
  25 1) GNU Lesser General Public License (GNU LGPL)
  26 2) Common Public License (CPL)
  27 3) Simplified license for unmodified code (read SPECIAL EXCEPTION)
  28 4) Proprietary license
  29
  30 It means that you can select one of these four options and follow rules of that license.
  31
  32
  33 1,2) GNU LGPL and CPL licenses are pretty similar and both these
  34 licenses are classified as
  35  - "Free software licenses" at http://www.gnu.org/
  36  - "OSI-approved" at http://www.opensource.org/
  37
  38
  39 3) SPECIAL EXCEPTION
  40
  41 Igor Pavlov, as the author of this code, expressly permits you
  42 to statically or dynamically link your code (or bind by name)
  43 to the files from LZMA SDK without subjecting your linked
  44 code to the terms of the CPL or GNU LGPL.
  45 Any modifications or additions to files from LZMA SDK, however,
  46 are subject to the GNU LGPL or CPL terms.
  47
  48 SPECIAL EXCEPTION allows you to use LZMA SDK in applications with closed code,
  49 while you keep LZMA SDK code unmodified.
  50
  51
  52 SPECIAL EXCEPTION #2: Igor Pavlov, as the author of this code, expressly permits
  53 you to use this code under the same terms and conditions contained in the License
  54 Agreement you have for any previous version of LZMA SDK developed by Igor Pavlov.
  55
  56 SPECIAL EXCEPTION #2 allows owners of proprietary licenses to use latest version
  57 of LZMA SDK as update for previous versions.
  58
  59
  60 SPECIAL EXCEPTION #3: Igor Pavlov, as the author of this code, expressly permits
  61 you to use code of the following files:
  62 BranchTypes.h, LzmaTypes.h, LzmaTest.c, LzmaStateTest.c, LzmaAlone.cpp,
  63 LzmaAlone.cs, LzmaAlone.java
  64 as public domain code.
  65
  66
  67 4) Proprietary license
  68
  69 LZMA SDK also can be available under a proprietary license which
  70 can include:
  71
  72 1) Right to modify code without subjecting modified code to the
  73 terms of the CPL or GNU LGPL
  74 2) Technical support for code
  75
  76 To request such proprietary license or any additional consultations,
  77 send email message from that page:
  78 http://www.7-zip.org/support.html
  79
  80
  81 You should have received a copy of the GNU Lesser General Public
  82 License along with this library; if not, write to the Free Software
  83 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  84
  85 You should have received a copy of the Common Public License
  86 along with this library.
  87
  88
  89 LZMA SDK Contents
  90 -----------------
  91
  92 LZMA SDK includes:
  93
  94   - C++ source code of LZMA compressing and decompressing
  95   - ANSI-C compatible source code for LZMA decompressing
  96   - C# source code for LZMA compressing and decompressing
  97   - Java source code for LZMA compressing and decompressing
  98   - Compiled file->file LZMA compressing/decompressing program for Windows system
  99
 100 ANSI-C LZMA decompression code was ported from original C++ sources to C.
 101 Also it was simplified and optimized for code size.
 102 But it is fully compatible with LZMA from 7-Zip.
 103
 104
 105 UNIX/Linux version
 106 ------------------
 107 To compile C++ version of file->file LZMA, go to directory
 108 C/7zip/Compress/LZMA_Alone
 109 and type "make" or "make clean all" to recompile all.
 110
 111 In some UNIX/Linux versions you must compile LZMA with static libraries.
 112 To compile with static libraries, change string in makefile
 113 LIB = -lm
 114 to string
 115 LIB = -lm -static
 116
 117
 118 Files
 119 ---------------------
 120 C        - C source code
 121 CPP      - CPP source code
 122 CS       - C# source code
 123 Java     - Java source code
 124 lzma.txt - LZMA SDK description (this file)
 125 7zFormat.txt - 7z Format description
 126 7zC.txt  - 7z ANSI-C Decoder description (this file)
 127 methods.txt  - Compression method IDs for .7z
 128 LGPL.txt - GNU Lesser General Public License
 129 CPL.html - Common Public License
 130 lzma.exe - Compiled file->file LZMA encoder/decoder for Windows
 131 history.txt - history of the LZMA SDK
 132
 133
 134 Source code structure
 135 ---------------------
 136
 137 C  - C files
 138     Compress - files related to compression/decompression
 139       Lz     - files related to LZ (Lempel-Ziv) compression algorithm
 140       Lzma   - ANSI-C compatible LZMA decompressor
 141
 142         LzmaDecode.h  - interface for LZMA decoding on ANSI-C
 143         LzmaDecode.c      - LZMA decoding on ANSI-C (new fastest version)
 144         LzmaDecodeSize.c  - LZMA decoding on ANSI-C (old size-optimized version)
 145         LzmaTest.c        - test application that decodes LZMA encoded file
 146         LzmaTypes.h       - basic types for LZMA Decoder
 147         LzmaStateDecode.h - interface for LZMA decoding (State version)
 148         LzmaStateDecode.c - LZMA decoding on ANSI-C (State version)
 149         LzmaStateTest.c   - test application (State version)
 150
 151       Branch       - Filters for x86, IA-64, ARM, ARM-Thumb, PowerPC and SPARC code
 152
 153     Archive - files related to archiving
 154       7z_C     - 7z ANSI-C Decoder
 155
 156
 157 CPP -- CPP files
 158
 159   Common  - common files for C++ projects
 160   Windows - common files for Windows related code
 161   7zip    - files related to 7-Zip Project
 162
 163     Common   - common files for 7-Zip
 164
 165     Compress - files related to compression/decompression
 166
 167       LZ     - files related to LZ (Lempel-Ziv) compression algorithm
 168
 169       Copy         - Copy coder
 170       RangeCoder   - Range Coder (special code of compression/decompression)
 171       LZMA         - LZMA compression/decompression on C++
 172       LZMA_Alone   - file->file LZMA compression/decompression
 173
 174       Branch       - Filters for x86, IA-64, ARM, ARM-Thumb, PowerPC and SPARC code
 175
 176     Archive - files related to archiving
 177
 178       Common   - common files for archive handling
 179       7z       - 7z C++ Encoder/Decoder
 180
 181     Bundles    - Modules that are bundles of other modules
 182
 183       Alone7z           - 7zr.exe: Standalone version of 7z.exe that supports only 7z/LZMA/BCJ/BCJ2
 184       Format7zR         - 7zr.dll: Reduced version of 7za.dll: extracting/compressing to 7z/LZMA/BCJ/BCJ2
 185       Format7zExtractR  - 7zxr.dll: Reduced version of 7zxa.dll: extracting from 7z/LZMA/BCJ/BCJ2.
 186
 187     UI        - User Interface files
 188
 189       Client7z - Test application for 7za.dll,  7zr.dll, 7zxr.dll
 190       Common   - Common UI files
 191       Console  - Code for console archiver
 192
 193
 194
 195 CS - C# files
 196   7zip
 197     Common   - some common files for 7-Zip
 198     Compress - files related to compression/decompression
 199       LZ     - files related to LZ (Lempel-Ziv) compression algorithm
 200       LZMA         - LZMA compression/decompression
 201       LzmaAlone    - file->file LZMA compression/decompression
 202       RangeCoder   - Range Coder (special code of compression/decompression)
 203
 204 Java  - Java files
 205   SevenZip
 206     Compression    - files related to compression/decompression
 207       LZ           - files related to LZ (Lempel-Ziv) compression algorithm
 208       LZMA         - LZMA compression/decompression
 209       RangeCoder   - Range Coder (special code of compression/decompression)
 210
 211 C/C++ source code of LZMA SDK is part of 7-Zip project.
 212
 213 You can find ANSI-C LZMA decompressing code at folder
 214   C/7zip/Compress/Lzma
 215 7-Zip doesn't use that ANSI-C LZMA code and that code was developed
 216 specially for this SDK. And files from C/7zip/Compress/Lzma do not need
 217 files from other directories of SDK for compiling.
 218
 219 7-Zip source code can be downloaded from 7-Zip's SourceForge page:
 220
 221   http://sourceforge.net/projects/sevenzip/
 222
 223
 224 LZMA features
 225 -------------
 226   - Variable dictionary size (up to 1 GB)
 227   - Estimated compressing speed: about 1 MB/s on 1 GHz CPU
 228   - Estimated decompressing speed:
 229       - 8-12 MB/s on 1 GHz Intel Pentium 3 or AMD Athlon
 230       - 500-1000 KB/s on 100 MHz ARM, MIPS, PowerPC or other simple RISC
 231   - Small memory requirements for decompressing (8-32 KB + DictionarySize)
 232   - Small code size for decompressing: 2-8 KB (depending from
 233     speed optimizations)
 234
 235 LZMA decoder uses only integer operations and can be
 236 implemented in any modern 32-bit CPU (or on 16-bit CPU with some conditions).
 237
 238 Some critical operations that affect to speed of LZMA decompression:
 239   1) 32*16 bit integer multiply
 240   2) Misspredicted branches (penalty mostly depends from pipeline length)
 241   3) 32-bit shift and arithmetic operations
 242
 243 Speed of LZMA decompressing mostly depends from CPU speed.
 244 Memory speed has no big meaning. But if your CPU has small data cache,
 245 overall weight of memory speed will slightly increase.
 246
 247
 248 How To Use
 249 ----------
 250
 251 Using LZMA encoder/decoder executable
 252 --------------------------------------
 253
 254 Usage:  LZMA <e|d> inputFile outputFile [<switches>...]
 255
 256   e: encode file
 257
 258   d: decode file
 259
 260   b: Benchmark. There are two tests: compressing and decompressing
 261      with LZMA method. Benchmark shows rating in MIPS (million
 262      instructions per second). Rating value is calculated from
 263      measured speed and it is normalized with AMD Athlon 64 X2 CPU
 264      results. Also Benchmark checks possible hardware errors (RAM
 265      errors in most cases). Benchmark uses these settings:
 266      (-a1, -d21, -fb32, -mfbt4). You can change only -d. Also you
 267      can change number of iterations. Example for 30 iterations:
 268        LZMA b 30
 269      Default number of iterations is 10.
 270
 271 <Switches>
 272
 273
 274   -a{N}:  set compression mode 0 = fast, 1 = normal
 275           default: 1 (normal)
 276
 277   d{N}:   Sets Dictionary size - [0, 30], default: 23 (8MB)
 278           The maximum value for dictionary size is 1 GB = 2^30 bytes.
 279           Dictionary size is calculated as DictionarySize = 2^N bytes.
 280           For decompressing file compressed by LZMA method with dictionary
 281           size D = 2^N you need about D bytes of memory (RAM).
 282
 283   -fb{N}: set number of fast bytes - [5, 273], default: 128
 284           Usually big number gives a little bit better compression ratio
 285           and slower compression process.
 286
 287   -lc{N}: set number of literal context bits - [0, 8], default: 3
 288           Sometimes lc=4 gives gain for big files.
 289
 290   -lp{N}: set number of literal pos bits - [0, 4], default: 0
 291           lp switch is intended for periodical data when period is
 292           equal 2^N. For example, for 32-bit (4 bytes)
 293           periodical data you can use lp=2. Often it's better to set lc0,
 294           if you change lp switch.
 295
 296   -pb{N}: set number of pos bits - [0, 4], default: 2
 297           pb switch is intended for periodical data
 298           when period is equal 2^N.
 299
 300   -mf{MF_ID}: set Match Finder. Default: bt4.
 301               Algorithms from hc* group doesn't provide good compression
 302               ratio, but they often works pretty fast in combination with
 303               fast mode (-a0).
 304
 305               Memory requirements depend from dictionary size
 306               (parameter "d" in table below).
 307
 308                MF_ID     Memory                   Description
 309
 310                 bt2    d *  9.5 + 4MB  Binary Tree with 2 bytes hashing.
 311                 bt3    d * 11.5 + 4MB  Binary Tree with 3 bytes hashing.
 312                 bt4    d * 11.5 + 4MB  Binary Tree with 4 bytes hashing.
 313                 hc4    d *  7.5 + 4MB  Hash Chain with 4 bytes hashing.
 314
 315   -eos:   write End Of Stream marker. By default LZMA doesn't write
 316           eos marker, since LZMA decoder knows uncompressed size
 317           stored in .lzma file header.
 318
 319   -si:    Read data from stdin (it will write End Of Stream marker).
 320   -so:    Write data to stdout
 321
 322
 323 Examples:
 324
 325 1) LZMA e file.bin file.lzma -d16 -lc0
 326
 327 compresses file.bin to file.lzma with 64 KB dictionary (2^16=64K)
 328 and 0 literal context bits. -lc0 allows to reduce memory requirements
 329 for decompression.
 330
 331
 332 2) LZMA e file.bin file.lzma -lc0 -lp2
 333
 334 compresses file.bin to file.lzma with settings suitable
 335 for 32-bit periodical data (for example, ARM or MIPS code).
 336
 337 3) LZMA d file.lzma file.bin
 338
 339 decompresses file.lzma to file.bin.
 340
 341
 342 Compression ratio hints
 343 -----------------------
 344
 345 Recommendations
 346 ---------------
 347
 348 To increase compression ratio for LZMA compressing it's desirable
 349 to have aligned data (if it's possible) and also it's desirable to locate
 350 data in such order, where code is grouped in one place and data is
 351 grouped in other place (it's better than such mixing: code, data, code,
 352 data, ...).
 353
 354
 355 Using Filters
 356 -------------
 357 You can increase compression ratio for some data types, using
 358 special filters before compressing. For example, it's possible to
 359 increase compression ratio on 5-10% for code for those CPU ISAs:
 360 x86, IA-64, ARM, ARM-Thumb, PowerPC, SPARC.
 361
 362 You can find C/C++ source code of such filters in folder "7zip/Compress/Branch"
 363
 364 You can check compression ratio gain of these filters with such
 365 7-Zip commands (example for ARM code):
 366 No filter:
 367   7z a a1.7z a.bin -m0=lzma
 368
 369 With filter for little-endian ARM code:
 370   7z a a2.7z a.bin -m0=bc_arm -m1=lzma
 371
 372 With filter for big-endian ARM code (using additional Swap4 filter):
 373   7z a a3.7z a.bin -m0=swap4 -m1=bc_arm -m2=lzma
 374
 375 It works in such manner:
 376 Compressing    = Filter_encoding + LZMA_encoding
 377 Decompressing  = LZMA_decoding + Filter_decoding
 378
 379 Compressing and decompressing speed of such filters is very high,
 380 so it will not increase decompressing time too much.
 381 Moreover, it reduces decompression time for LZMA_decoding,
 382 since compression ratio with filtering is higher.
 383
 384 These filters convert CALL (calling procedure) instructions
 385 from relative offsets to absolute addresses, so such data becomes more
 386 compressible. Source code of these CALL filters is pretty simple
 387 (about 20 lines of C++), so you can convert it from C++ version yourself.
 388
 389 For some ISAs (for example, for MIPS) it's impossible to get gain from such filter.
 390
 391
 392 LZMA compressed file format
 393 ---------------------------
 394 Offset Size Description
 395   0     1   Special LZMA properties for compressed data
 396   1     4   Dictionary size (little endian)
 397   5     8   Uncompressed size (little endian). -1 means unknown size
 398  13         Compressed data
 399
 400
 401 ANSI-C LZMA Decoder
 402 ~~~~~~~~~~~~~~~~~~~
 403
 404 To compile ANSI-C LZMA Decoder you can use one of the following files sets:
 405 1) LzmaDecode.h + LzmaDecode.c + LzmaTest.c  (fastest version)
 406 2) LzmaDecode.h + LzmaDecodeSize.c + LzmaTest.c  (old size-optimized version)
 407 3) LzmaStateDecode.h + LzmaStateDecode.c + LzmaStateTest.c  (zlib-like interface)
 408
 409
 410 Memory requirements for LZMA decoding
 411 -------------------------------------
 412
 413 LZMA decoder doesn't allocate memory itself, so you must
 414 allocate memory and send it to LZMA.
 415
 416 Stack usage of LZMA decoding function for local variables is not
 417 larger than 200 bytes.
 418
 419 How To decompress data
 420 ----------------------
 421
 422 LZMA Decoder (ANSI-C version) now supports 5 interfaces:
 423 1) Single-call Decompressing
 424 2) Single-call Decompressing with input stream callback
 425 3) Multi-call Decompressing with output buffer
 426 4) Multi-call Decompressing with input callback and output buffer
 427 5) Multi-call State Decompressing (zlib-like interface)
 428
 429 Variant-5 is similar to Variant-4, but Variant-5 doesn't use callback functions.
 430
 431 Decompressing steps
 432 -------------------
 433
 434 1) read LZMA properties (5 bytes):
 435    unsigned char properties[LZMA_PROPERTIES_SIZE];
 436
 437 2) read uncompressed size (8 bytes, little-endian)
 438
 439 3) Decode properties:
 440
 441   CLzmaDecoderState state;  /* it's 24-140 bytes structure, if int is 32-bit */
 442
 443   if (LzmaDecodeProperties(&state.Properties, properties, LZMA_PROPERTIES_SIZE) != LZMA_RESULT_OK)
 444     return PrintError(rs, "Incorrect stream properties");
 445
 446 4) Allocate memory block for internal Structures:
 447
 448   state.Probs = (CProb *)malloc(LzmaGetNumProbs(&state.Properties) * sizeof(CProb));
 449   if (state.Probs == 0)
 450     return PrintError(rs, kCantAllocateMessage);
 451
 452   LZMA decoder uses array of CProb variables as internal structure.
 453   By default, CProb is unsigned_short. But you can define _LZMA_PROB32 to make
 454   it unsigned_int. It can increase speed on some 32-bit CPUs, but memory
 455   usage will be doubled in that case.
 456
 457
 458 5) Main Decompressing
 459
 460 You must use one of the following interfaces:
 461
 462 5.1 Single-call Decompressing
 463 -----------------------------
 464 When to use: RAM->RAM decompressing
 465 Compile files: LzmaDecode.h, LzmaDecode.c
 466 Compile defines: no defines
 467 Memory Requirements:
 468   - Input buffer: compressed size
 469   - Output buffer: uncompressed size
 470   - LZMA Internal Structures (~16 KB for default settings)
 471
 472 Interface:
 473   int res = LzmaDecode(&state,
 474       inStream, compressedSize, &inProcessed,
 475       outStream, outSize, &outProcessed);
 476
 477
 478 5.2 Single-call Decompressing with input stream callback
 479 --------------------------------------------------------
 480 When to use: File->RAM or Flash->RAM decompressing.
 481 Compile files: LzmaDecode.h, LzmaDecode.c
 482 Compile defines: _LZMA_IN_CB
 483 Memory Requirements:
 484   - Buffer for input stream: any size (for example, 16 KB)
 485   - Output buffer: uncompressed size
 486   - LZMA Internal Structures (~16 KB for default settings)
 487
 488 Interface:
 489   typedef struct _CBuffer
 490   {
 491     ILzmaInCallback InCallback;
 492     FILE *File;
 493     unsigned char Buffer[kInBufferSize];
 494   } CBuffer;
 495
 496   int LzmaReadCompressed(void *object, const unsigned char **buffer, SizeT *size)
 497   {
 498     CBuffer *bo = (CBuffer *)object;
 499     *buffer = bo->Buffer;
 500     *size = MyReadFile(bo->File, bo->Buffer, kInBufferSize);
 501     return LZMA_RESULT_OK;
 502   }
 503
 504   CBuffer g_InBuffer;
 505
 506   g_InBuffer.File = inFile;
 507   g_InBuffer.InCallback.Read = LzmaReadCompressed;
 508   int res = LzmaDecode(&state,
 509       &g_InBuffer.InCallback,
 510       outStream, outSize, &outProcessed);
 511
 512
 513 5.3 Multi-call decompressing with output buffer
 514 -----------------------------------------------
 515 When to use: RAM->File decompressing
 516 Compile files: LzmaDecode.h, LzmaDecode.c
 517 Compile defines: _LZMA_OUT_READ
 518 Memory Requirements:
 519  - Input buffer: compressed size
 520  - Buffer for output stream: any size (for example, 16 KB)
 521  - LZMA Internal Structures (~16 KB for default settings)
 522  - LZMA dictionary (dictionary size is encoded in stream properties)
 523
 524 Interface:
 525
 526   state.Dictionary = (unsigned char *)malloc(state.Properties.DictionarySize);
 527
 528   LzmaDecoderInit(&state);
 529   do
 530   {
 531     LzmaDecode(&state,
 532       inBuffer, inAvail, &inProcessed,
 533       g_OutBuffer, outAvail, &outProcessed);
 534     inAvail -= inProcessed;
 535     inBuffer += inProcessed;
 536   }
 537   while you need more bytes
 538
 539   see LzmaTest.c for more details.
 540
 541
 542 5.4 Multi-call decompressing with input callback and output buffer
 543 ------------------------------------------------------------------
 544 When to use: File->File decompressing
 545 Compile files: LzmaDecode.h, LzmaDecode.c
 546 Compile defines: _LZMA_IN_CB, _LZMA_OUT_READ
 547 Memory Requirements:
 548  - Buffer for input stream: any size (for example, 16 KB)
 549  - Buffer for output stream: any size (for example, 16 KB)
 550  - LZMA Internal Structures (~16 KB for default settings)
 551  - LZMA dictionary (dictionary size is encoded in stream properties)
 552
 553 Interface:
 554
 555   state.Dictionary = (unsigned char *)malloc(state.Properties.DictionarySize);
 556
 557   LzmaDecoderInit(&state);
 558   do
 559   {
 560     LzmaDecode(&state,
 561       &bo.InCallback,
 562       g_OutBuffer, outAvail, &outProcessed);
 563   }
 564   while you need more bytes
 565
 566   see LzmaTest.c for more details:
 567
 568
 569 5.5 Multi-call State Decompressing (zlib-like interface)
 570 ------------------------------------------------------------------
 571 When to use: file->file decompressing
 572 Compile files: LzmaStateDecode.h, LzmaStateDecode.c
 573 Compile defines:
 574 Memory Requirements:
 575  - Buffer for input stream: any size (for example, 16 KB)
 576  - Buffer for output stream: any size (for example, 16 KB)
 577  - LZMA Internal Structures (~16 KB for default settings)
 578  - LZMA dictionary (dictionary size is encoded in stream properties)
 579
 580 Interface:
 581
 582   state.Dictionary = (unsigned char *)malloc(state.Properties.DictionarySize);
 583
 584
 585   LzmaDecoderInit(&state);
 586   do
 587   {
 588     res = LzmaDecode(&state,
 589       inBuffer, inAvail, &inProcessed,
 590       g_OutBuffer, outAvail, &outProcessed,
 591       finishDecoding);
 592     inAvail -= inProcessed;
 593     inBuffer += inProcessed;
 594   }
 595   while you need more bytes
 596
 597   see LzmaStateTest.c for more details:
 598
 599
 600 6) Free all allocated blocks
 601
 602
 603 Note
 604 ----
 605 LzmaDecodeSize.c is size-optimized version of LzmaDecode.c.
 606 But compiled code of LzmaDecodeSize.c can be larger than
 607 compiled code of LzmaDecode.c. So it's better to use
 608 LzmaDecode.c in most cases.
 609
 610
 611 EXIT codes
 612 -----------
 613
 614 LZMA decoder can return one of the following codes:
 615
 616 #define LZMA_RESULT_OK 0
 617 #define LZMA_RESULT_DATA_ERROR 1
 618
 619 If you use callback function for input data and you return some
 620 error code, LZMA Decoder also returns that code.
 621
 622
 623
 624 LZMA Defines
 625 ------------
 626
 627 _LZMA_IN_CB    - Use callback for input data
 628
 629 _LZMA_OUT_READ - Use read function for output data
 630
 631 _LZMA_LOC_OPT  - Enable local speed optimizations inside code.
 632                  _LZMA_LOC_OPT is only for LzmaDecodeSize.c (size-optimized version).
 633                  _LZMA_LOC_OPT doesn't affect LzmaDecode.c (speed-optimized version)
 634                  and LzmaStateDecode.c
 635
 636 _LZMA_PROB32   - It can increase speed on some 32-bit CPUs,
 637                  but memory usage will be doubled in that case
 638
 639 _LZMA_UINT32_IS_ULONG  - Define it if int is 16-bit on your compiler
 640                          and long is 32-bit.
 641
 642 _LZMA_SYSTEM_SIZE_T  - Define it if you want to use system's size_t.
 643                        You can use it to enable 64-bit sizes supporting
 644
 645
 646
 647 C++ LZMA Encoder/Decoder
 648 ~~~~~~~~~~~~~~~~~~~~~~~~
 649 C++ LZMA code use COM-like interfaces. So if you want to use it,
 650 you can study basics of COM/OLE.
 651
 652 By default, LZMA Encoder contains all Match Finders.
 653 But for compressing it's enough to have just one of them.
 654 So for reducing size of compressing code you can define:
 655   #define COMPRESS_MF_BT
 656   #define COMPRESS_MF_BT4
 657 and it will use only bt4 match finder.
 658
 659
 660 ---
 661
 662 http://www.7-zip.org
 663 http://www.7-zip.org/support.html