hedgewars: comparison misc/libphysfs/lzma/lzma.txt

equal deleted inserted replaced

-:ea891871f481
+:bb5522e88ab2
+LZMA SDK 4.57
+-------------
+LZMA SDK   Copyright (C) 1999-2007 Igor Pavlov
+LZMA SDK provides the documentation, samples, header files, libraries,
+and tools you need to develop applications that use LZMA compression.
+LZMA is default and general compression method of 7z format
+in 7-Zip compression program (www.7-zip.org). LZMA provides high
+compression ratio and very fast decompression.
+LZMA is an improved version of famous LZ77 compression algorithm.
+It was improved in way of maximum increasing of compression ratio,
+keeping high decompression speed and low memory requirements for
+decompressing.
+LICENSE
+-------
+LZMA SDK is available under any of the following licenses:
+1) GNU Lesser General Public License (GNU LGPL)
+2) Common Public License (CPL)
+3) Simplified license for unmodified code (read SPECIAL EXCEPTION)
+4) Proprietary license
+It means that you can select one of these four options and follow rules of that license.
+1,2) GNU LGPL and CPL licenses are pretty similar and both these
+licenses are classified as
+- "Free software licenses" at http://www.gnu.org/
+- "OSI-approved" at http://www.opensource.org/
+3) SPECIAL EXCEPTION
+Igor Pavlov, as the author of this code, expressly permits you
+to statically or dynamically link your code (or bind by name)
+to the files from LZMA SDK without subjecting your linked
+code to the terms of the CPL or GNU LGPL.
+Any modifications or additions to files from LZMA SDK, however,
+are subject to the GNU LGPL or CPL terms.
+SPECIAL EXCEPTION allows you to use LZMA SDK in applications with closed code,
+while you keep LZMA SDK code unmodified.
+SPECIAL EXCEPTION #2: Igor Pavlov, as the author of this code, expressly permits
+you to use this code under the same terms and conditions contained in the License
+Agreement you have for any previous version of LZMA SDK developed by Igor Pavlov.
+SPECIAL EXCEPTION #2 allows owners of proprietary licenses to use latest version
+of LZMA SDK as update for previous versions.
+SPECIAL EXCEPTION #3: Igor Pavlov, as the author of this code, expressly permits
+you to use code of the following files:
+BranchTypes.h, LzmaTypes.h, LzmaTest.c, LzmaStateTest.c, LzmaAlone.cpp,
+LzmaAlone.cs, LzmaAlone.java
+as public domain code.
+4) Proprietary license
+LZMA SDK also can be available under a proprietary license which
+can include:
+1) Right to modify code without subjecting modified code to the
+terms of the CPL or GNU LGPL
+2) Technical support for code
+To request such proprietary license or any additional consultations,
+send email message from that page:
+http://www.7-zip.org/support.html
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+You should have received a copy of the Common Public License
+along with this library.
+LZMA SDK Contents
+-----------------
+LZMA SDK includes:
+- C++ source code of LZMA compressing and decompressing
+- ANSI-C compatible source code for LZMA decompressing
+- C# source code for LZMA compressing and decompressing
+- Java source code for LZMA compressing and decompressing
+- Compiled file->file LZMA compressing/decompressing program for Windows system
+ANSI-C LZMA decompression code was ported from original C++ sources to C.
+Also it was simplified and optimized for code size.
+But it is fully compatible with LZMA from 7-Zip.
+UNIX/Linux version
+------------------
+To compile C++ version of file->file LZMA, go to directory
+C/7zip/Compress/LZMA_Alone
+and type "make" or "make clean all" to recompile all.
+In some UNIX/Linux versions you must compile LZMA with static libraries.
+To compile with static libraries, change string in makefile
+LIB = -lm
+to string
+LIB = -lm -static
+Files
+---------------------
+C        - C source code
+CPP      - CPP source code
+CS       - C# source code
+Java     - Java source code
+lzma.txt - LZMA SDK description (this file)
+7zFormat.txt - 7z Format description
+7zC.txt  - 7z ANSI-C Decoder description (this file)
+methods.txt  - Compression method IDs for .7z
+LGPL.txt - GNU Lesser General Public License
+CPL.html - Common Public License
+lzma.exe - Compiled file->file LZMA encoder/decoder for Windows
+history.txt - history of the LZMA SDK
+Source code structure
+---------------------
+C  - C files
+Compress - files related to compression/decompression
+Lz     - files related to LZ (Lempel-Ziv) compression algorithm
+Lzma   - ANSI-C compatible LZMA decompressor
+LzmaDecode.h  - interface for LZMA decoding on ANSI-C
+LzmaDecode.c      - LZMA decoding on ANSI-C (new fastest version)
+LzmaDecodeSize.c  - LZMA decoding on ANSI-C (old size-optimized version)
+LzmaTest.c        - test application that decodes LZMA encoded file
+LzmaTypes.h       - basic types for LZMA Decoder
+LzmaStateDecode.h - interface for LZMA decoding (State version)
+LzmaStateDecode.c - LZMA decoding on ANSI-C (State version)
+LzmaStateTest.c   - test application (State version)
+Branch       - Filters for x86, IA-64, ARM, ARM-Thumb, PowerPC and SPARC code
+Archive - files related to archiving
+7z_C     - 7z ANSI-C Decoder
+CPP -- CPP files
+Common  - common files for C++ projects
+Windows - common files for Windows related code
+7zip    - files related to 7-Zip Project
+Common   - common files for 7-Zip
+Compress - files related to compression/decompression
+LZ     - files related to LZ (Lempel-Ziv) compression algorithm
+Copy         - Copy coder
+RangeCoder   - Range Coder (special code of compression/decompression)
+LZMA         - LZMA compression/decompression on C++
+LZMA_Alone   - file->file LZMA compression/decompression
+Branch       - Filters for x86, IA-64, ARM, ARM-Thumb, PowerPC and SPARC code
+Archive - files related to archiving
+Common   - common files for archive handling
+7z       - 7z C++ Encoder/Decoder
+Bundles    - Modules that are bundles of other modules
+Alone7z           - 7zr.exe: Standalone version of 7z.exe that supports only 7z/LZMA/BCJ/BCJ2
+Format7zR         - 7zr.dll: Reduced version of 7za.dll: extracting/compressing to 7z/LZMA/BCJ/BCJ2
+Format7zExtractR  - 7zxr.dll: Reduced version of 7zxa.dll: extracting from 7z/LZMA/BCJ/BCJ2.
+UI        - User Interface files
+Client7z - Test application for 7za.dll,  7zr.dll, 7zxr.dll
+Common   - Common UI files
+Console  - Code for console archiver
+CS - C# files
+7zip
+Common   - some common files for 7-Zip
+Compress - files related to compression/decompression
+LZ     - files related to LZ (Lempel-Ziv) compression algorithm
+LZMA         - LZMA compression/decompression
+LzmaAlone    - file->file LZMA compression/decompression
+RangeCoder   - Range Coder (special code of compression/decompression)
+Java  - Java files
+SevenZip
+Compression    - files related to compression/decompression
+LZ           - files related to LZ (Lempel-Ziv) compression algorithm
+LZMA         - LZMA compression/decompression
+RangeCoder   - Range Coder (special code of compression/decompression)
+C/C++ source code of LZMA SDK is part of 7-Zip project.
+You can find ANSI-C LZMA decompressing code at folder
+C/7zip/Compress/Lzma
+7-Zip doesn't use that ANSI-C LZMA code and that code was developed
+specially for this SDK. And files from C/7zip/Compress/Lzma do not need
+files from other directories of SDK for compiling.
+7-Zip source code can be downloaded from 7-Zip's SourceForge page:
+http://sourceforge.net/projects/sevenzip/
+LZMA features
+-------------
+- Variable dictionary size (up to 1 GB)
+- Estimated compressing speed: about 1 MB/s on 1 GHz CPU
+- Estimated decompressing speed:
+- 8-12 MB/s on 1 GHz Intel Pentium 3 or AMD Athlon
+- 500-1000 KB/s on 100 MHz ARM, MIPS, PowerPC or other simple RISC
+- Small memory requirements for decompressing (8-32 KB + DictionarySize)
+- Small code size for decompressing: 2-8 KB (depending from
+speed optimizations)
+LZMA decoder uses only integer operations and can be
+implemented in any modern 32-bit CPU (or on 16-bit CPU with some conditions).
+Some critical operations that affect to speed of LZMA decompression:
+1) 32*16 bit integer multiply
+2) Misspredicted branches (penalty mostly depends from pipeline length)
+3) 32-bit shift and arithmetic operations
+Speed of LZMA decompressing mostly depends from CPU speed.
+Memory speed has no big meaning. But if your CPU has small data cache,
+overall weight of memory speed will slightly increase.
+How To Use
+----------
+Using LZMA encoder/decoder executable
+--------------------------------------
+Usage:  LZMA <e|d> inputFile outputFile [<switches>...]
+e: encode file
+d: decode file
+b: Benchmark. There are two tests: compressing and decompressing
+with LZMA method. Benchmark shows rating in MIPS (million
+instructions per second). Rating value is calculated from
+measured speed and it is normalized with AMD Athlon 64 X2 CPU
+results. Also Benchmark checks possible hardware errors (RAM
+errors in most cases). Benchmark uses these settings:
+(-a1, -d21, -fb32, -mfbt4). You can change only -d. Also you
+can change number of iterations. Example for 30 iterations:
+LZMA b 30
+Default number of iterations is 10.
+<Switches>
+-a{N}:  set compression mode 0 = fast, 1 = normal
+default: 1 (normal)
+d{N}:   Sets Dictionary size - [0, 30], default: 23 (8MB)
+The maximum value for dictionary size is 1 GB = 2^30 bytes.
+Dictionary size is calculated as DictionarySize = 2^N bytes.
+For decompressing file compressed by LZMA method with dictionary
+size D = 2^N you need about D bytes of memory (RAM).
+-fb{N}: set number of fast bytes - [5, 273], default: 128
+Usually big number gives a little bit better compression ratio
+and slower compression process.
+-lc{N}: set number of literal context bits - [0, 8], default: 3
+Sometimes lc=4 gives gain for big files.
+-lp{N}: set number of literal pos bits - [0, 4], default: 0
+lp switch is intended for periodical data when period is
+equal 2^N. For example, for 32-bit (4 bytes)
+periodical data you can use lp=2. Often it's better to set lc0,
+if you change lp switch.
+-pb{N}: set number of pos bits - [0, 4], default: 2
+pb switch is intended for periodical data
+when period is equal 2^N.
+-mf{MF_ID}: set Match Finder. Default: bt4.
+Algorithms from hc* group doesn't provide good compression
+ratio, but they often works pretty fast in combination with
+fast mode (-a0).
+Memory requirements depend from dictionary size
+(parameter "d" in table below).
+MF_ID     Memory                   Description
+bt2    d *  9.5 + 4MB  Binary Tree with 2 bytes hashing.
+bt3    d * 11.5 + 4MB  Binary Tree with 3 bytes hashing.
+bt4    d * 11.5 + 4MB  Binary Tree with 4 bytes hashing.
+hc4    d *  7.5 + 4MB  Hash Chain with 4 bytes hashing.
+-eos:   write End Of Stream marker. By default LZMA doesn't write
+eos marker, since LZMA decoder knows uncompressed size
+stored in .lzma file header.
+-si:    Read data from stdin (it will write End Of Stream marker).
+-so:    Write data to stdout
+Examples:
+1) LZMA e file.bin file.lzma -d16 -lc0
+compresses file.bin to file.lzma with 64 KB dictionary (2^16=64K)
+and 0 literal context bits. -lc0 allows to reduce memory requirements
+for decompression.
+2) LZMA e file.bin file.lzma -lc0 -lp2
+compresses file.bin to file.lzma with settings suitable
+for 32-bit periodical data (for example, ARM or MIPS code).
+3) LZMA d file.lzma file.bin
+decompresses file.lzma to file.bin.
+Compression ratio hints
+-----------------------
+Recommendations
+---------------
+To increase compression ratio for LZMA compressing it's desirable
+to have aligned data (if it's possible) and also it's desirable to locate
+data in such order, where code is grouped in one place and data is
+grouped in other place (it's better than such mixing: code, data, code,
+data, ...).
+Using Filters
+-------------
+You can increase compression ratio for some data types, using
+special filters before compressing. For example, it's possible to
+increase compression ratio on 5-10% for code for those CPU ISAs:
+x86, IA-64, ARM, ARM-Thumb, PowerPC, SPARC.
+You can find C/C++ source code of such filters in folder "7zip/Compress/Branch"
+You can check compression ratio gain of these filters with such
+7-Zip commands (example for ARM code):
+No filter:
+7z a a1.7z a.bin -m0=lzma
+With filter for little-endian ARM code:
+7z a a2.7z a.bin -m0=bc_arm -m1=lzma
+With filter for big-endian ARM code (using additional Swap4 filter):
+7z a a3.7z a.bin -m0=swap4 -m1=bc_arm -m2=lzma
+It works in such manner:
+Compressing    = Filter_encoding + LZMA_encoding
+Decompressing  = LZMA_decoding + Filter_decoding
+Compressing and decompressing speed of such filters is very high,
+so it will not increase decompressing time too much.
+Moreover, it reduces decompression time for LZMA_decoding,
+since compression ratio with filtering is higher.
+These filters convert CALL (calling procedure) instructions
+from relative offsets to absolute addresses, so such data becomes more
+compressible. Source code of these CALL filters is pretty simple
+(about 20 lines of C++), so you can convert it from C++ version yourself.
+For some ISAs (for example, for MIPS) it's impossible to get gain from such filter.
+LZMA compressed file format
+---------------------------
+Offset Size Description
+0     1   Special LZMA properties for compressed data
+1     4   Dictionary size (little endian)
+5     8   Uncompressed size (little endian). -1 means unknown size
+13         Compressed data
+ANSI-C LZMA Decoder
+~~~~~~~~~~~~~~~~~~~
+To compile ANSI-C LZMA Decoder you can use one of the following files sets:
+1) LzmaDecode.h + LzmaDecode.c + LzmaTest.c  (fastest version)
+2) LzmaDecode.h + LzmaDecodeSize.c + LzmaTest.c  (old size-optimized version)
+3) LzmaStateDecode.h + LzmaStateDecode.c + LzmaStateTest.c  (zlib-like interface)
+Memory requirements for LZMA decoding
+-------------------------------------
+LZMA decoder doesn't allocate memory itself, so you must
+allocate memory and send it to LZMA.
+Stack usage of LZMA decoding function for local variables is not
+larger than 200 bytes.
+How To decompress data
+----------------------
+LZMA Decoder (ANSI-C version) now supports 5 interfaces:
+1) Single-call Decompressing
+2) Single-call Decompressing with input stream callback
+3) Multi-call Decompressing with output buffer
+4) Multi-call Decompressing with input callback and output buffer
+5) Multi-call State Decompressing (zlib-like interface)
+Variant-5 is similar to Variant-4, but Variant-5 doesn't use callback functions.
+Decompressing steps
+-------------------
+1) read LZMA properties (5 bytes):
+unsigned char properties[LZMA_PROPERTIES_SIZE];
+2) read uncompressed size (8 bytes, little-endian)
+3) Decode properties:
+CLzmaDecoderState state;  /* it's 24-140 bytes structure, if int is 32-bit */
+if (LzmaDecodeProperties(&state.Properties, properties, LZMA_PROPERTIES_SIZE) != LZMA_RESULT_OK)
+return PrintError(rs, "Incorrect stream properties");
+4) Allocate memory block for internal Structures:
+state.Probs = (CProb *)malloc(LzmaGetNumProbs(&state.Properties) * sizeof(CProb));
+if (state.Probs == 0)
+return PrintError(rs, kCantAllocateMessage);
+LZMA decoder uses array of CProb variables as internal structure.
+By default, CProb is unsigned_short. But you can define _LZMA_PROB32 to make
+it unsigned_int. It can increase speed on some 32-bit CPUs, but memory
+usage will be doubled in that case.
+5) Main Decompressing
+You must use one of the following interfaces:
+5.1 Single-call Decompressing
+-----------------------------
+When to use: RAM->RAM decompressing
+Compile files: LzmaDecode.h, LzmaDecode.c
+Compile defines: no defines
+Memory Requirements:
+- Input buffer: compressed size
+- Output buffer: uncompressed size
+- LZMA Internal Structures (~16 KB for default settings)
+Interface:
+int res = LzmaDecode(&state,
+inStream, compressedSize, &inProcessed,
+outStream, outSize, &outProcessed);
+5.2 Single-call Decompressing with input stream callback
+--------------------------------------------------------
+When to use: File->RAM or Flash->RAM decompressing.
+Compile files: LzmaDecode.h, LzmaDecode.c
+Compile defines: _LZMA_IN_CB
+Memory Requirements:
+- Buffer for input stream: any size (for example, 16 KB)
+- Output buffer: uncompressed size
+- LZMA Internal Structures (~16 KB for default settings)
+Interface:
+typedef struct _CBuffer
+{
+ILzmaInCallback InCallback;
+FILE *File;
+unsigned char Buffer[kInBufferSize];
+} CBuffer;
+int LzmaReadCompressed(void *object, const unsigned char **buffer, SizeT *size)
+{
+CBuffer *bo = (CBuffer *)object;
+*buffer = bo->Buffer;
+*size = MyReadFile(bo->File, bo->Buffer, kInBufferSize);
+return LZMA_RESULT_OK;
+}
+CBuffer g_InBuffer;
+g_InBuffer.File = inFile;
+g_InBuffer.InCallback.Read = LzmaReadCompressed;
+int res = LzmaDecode(&state,
+&g_InBuffer.InCallback,
+outStream, outSize, &outProcessed);
+5.3 Multi-call decompressing with output buffer
+-----------------------------------------------
+When to use: RAM->File decompressing
+Compile files: LzmaDecode.h, LzmaDecode.c
+Compile defines: _LZMA_OUT_READ
+Memory Requirements:
+- Input buffer: compressed size
+- Buffer for output stream: any size (for example, 16 KB)
+- LZMA Internal Structures (~16 KB for default settings)
+- LZMA dictionary (dictionary size is encoded in stream properties)
+Interface:
+state.Dictionary = (unsigned char *)malloc(state.Properties.DictionarySize);
+LzmaDecoderInit(&state);
+do
+{
+LzmaDecode(&state,
+inBuffer, inAvail, &inProcessed,
+g_OutBuffer, outAvail, &outProcessed);
+inAvail -= inProcessed;
+inBuffer += inProcessed;
+}
+while you need more bytes
+see LzmaTest.c for more details.
+5.4 Multi-call decompressing with input callback and output buffer
+------------------------------------------------------------------
+When to use: File->File decompressing
+Compile files: LzmaDecode.h, LzmaDecode.c
+Compile defines: _LZMA_IN_CB, _LZMA_OUT_READ
+Memory Requirements:
+- Buffer for input stream: any size (for example, 16 KB)
+- Buffer for output stream: any size (for example, 16 KB)
+- LZMA Internal Structures (~16 KB for default settings)
+- LZMA dictionary (dictionary size is encoded in stream properties)
+Interface:
+state.Dictionary = (unsigned char *)malloc(state.Properties.DictionarySize);
+LzmaDecoderInit(&state);
+do
+{
+LzmaDecode(&state,
+&bo.InCallback,
+g_OutBuffer, outAvail, &outProcessed);
+}
+while you need more bytes
+see LzmaTest.c for more details:
+5.5 Multi-call State Decompressing (zlib-like interface)
+------------------------------------------------------------------
+When to use: file->file decompressing
+Compile files: LzmaStateDecode.h, LzmaStateDecode.c
+Compile defines:
+Memory Requirements:
+- Buffer for input stream: any size (for example, 16 KB)
+- Buffer for output stream: any size (for example, 16 KB)
+- LZMA Internal Structures (~16 KB for default settings)
+- LZMA dictionary (dictionary size is encoded in stream properties)
+Interface:
+state.Dictionary = (unsigned char *)malloc(state.Properties.DictionarySize);
+LzmaDecoderInit(&state);
+do
+{
+res = LzmaDecode(&state,
+inBuffer, inAvail, &inProcessed,
+g_OutBuffer, outAvail, &outProcessed,
+finishDecoding);
+inAvail -= inProcessed;
+inBuffer += inProcessed;
+}
+while you need more bytes
+see LzmaStateTest.c for more details:
+6) Free all allocated blocks
+Note
+----
+LzmaDecodeSize.c is size-optimized version of LzmaDecode.c.
+But compiled code of LzmaDecodeSize.c can be larger than
+compiled code of LzmaDecode.c. So it's better to use
+LzmaDecode.c in most cases.
+EXIT codes
+-----------
+LZMA decoder can return one of the following codes:
+#define LZMA_RESULT_OK 0
+#define LZMA_RESULT_DATA_ERROR 1
+If you use callback function for input data and you return some
+error code, LZMA Decoder also returns that code.
+LZMA Defines
+------------
+_LZMA_IN_CB    - Use callback for input data
+_LZMA_OUT_READ - Use read function for output data
+_LZMA_LOC_OPT  - Enable local speed optimizations inside code.
+_LZMA_LOC_OPT is only for LzmaDecodeSize.c (size-optimized version).
+_LZMA_LOC_OPT doesn't affect LzmaDecode.c (speed-optimized version)
+and LzmaStateDecode.c
+_LZMA_PROB32   - It can increase speed on some 32-bit CPUs,
+but memory usage will be doubled in that case
+_LZMA_UINT32_IS_ULONG  - Define it if int is 16-bit on your compiler
+and long is 32-bit.
+_LZMA_SYSTEM_SIZE_T  - Define it if you want to use system's size_t.
+You can use it to enable 64-bit sizes supporting
+C++ LZMA Encoder/Decoder
+~~~~~~~~~~~~~~~~~~~~~~~~
+C++ LZMA code use COM-like interfaces. So if you want to use it,
+you can study basics of COM/OLE.
+By default, LZMA Encoder contains all Match Finders.
+But for compressing it's enough to have just one of them.
+So for reducing size of compressing code you can define:
+#define COMPRESS_MF_BT
+#define COMPRESS_MF_BT4
+and it will use only bt4 match finder.
+---
+http://www.7-zip.org
+http://www.7-zip.org/support.html