src/lzma/lzma.txt
changeset 972 254427fc42ab
parent 917 d299a58a274f
equal deleted inserted replaced
969:0bc902336e00 972:254427fc42ab
       
     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