mirror of https://github.com/Cisco-Talos/clamav
aCaB
17 years ago
parent
03d44bbfdd
commit
ed91ea51a5
@ -1,72 +1,7 @@ |
||||
Original unmodified files from the LZMA SDK are included under libclamav/lzma. |
||||
The original lzma.txt license file, a small portion of which is reproduced below, |
||||
is available under libclamav/lzma/lzma.txt. |
||||
is available under libclamav/7z/lzma.txt. |
||||
|
||||
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 is written and placed in the public domain by Igor Pavlov. |
||||
|
||||
@ -0,0 +1,594 @@ |
||||
LZMA SDK 4.65 |
||||
------------- |
||||
|
||||
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 written and placed in the public domain by Igor Pavlov. |
||||
|
||||
|
||||
LZMA SDK Contents |
||||
----------------- |
||||
|
||||
LZMA SDK includes: |
||||
|
||||
- ANSI-C/C++/C#/Java source code for LZMA compressing and decompressing |
||||
- Compiled file->file LZMA compressing/decompressing program for Windows system |
||||
|
||||
|
||||
UNIX/Linux version |
||||
------------------ |
||||
To compile C++ version of file->file LZMA encoding, go to directory |
||||
C++/7zip/Compress/LZMA_Alone |
||||
and call make to recompile it: |
||||
make -f makefile.gcc clean all |
||||
|
||||
In some UNIX/Linux versions you must compile LZMA with static libraries. |
||||
To compile with static libraries, you can use |
||||
LIB = -lm -static |
||||
|
||||
|
||||
Files |
||||
--------------------- |
||||
lzma.txt - LZMA SDK description (this file) |
||||
7zFormat.txt - 7z Format description |
||||
7zC.txt - 7z ANSI-C Decoder description |
||||
methods.txt - Compression method IDs for .7z |
||||
lzma.exe - Compiled file->file LZMA encoder/decoder for Windows |
||||
history.txt - history of the LZMA SDK |
||||
|
||||
|
||||
Source code structure |
||||
--------------------- |
||||
|
||||
C/ - C files |
||||
7zCrc*.* - CRC code |
||||
Alloc.* - Memory allocation functions |
||||
Bra*.* - Filters for x86, IA-64, ARM, ARM-Thumb, PowerPC and SPARC code |
||||
LzFind.* - Match finder for LZ (LZMA) encoders |
||||
LzFindMt.* - Match finder for LZ (LZMA) encoders for multithreading encoding |
||||
LzHash.h - Additional file for LZ match finder |
||||
LzmaDec.* - LZMA decoding |
||||
LzmaEnc.* - LZMA encoding |
||||
LzmaLib.* - LZMA Library for DLL calling |
||||
Types.h - Basic types for another .c files |
||||
Threads.* - The code for multithreading. |
||||
|
||||
LzmaLib - LZMA Library (.DLL for Windows) |
||||
|
||||
LzmaUtil - LZMA Utility (file->file LZMA encoder/decoder). |
||||
|
||||
Archive - files related to archiving |
||||
7z - 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 |
||||
|
||||
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. |
||||
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 2 MB/s on 2 GHz CPU |
||||
- Estimated decompressing speed: |
||||
- 20-30 MB/s on 2 GHz Core 2 or AMD Athlon 64 |
||||
- 1-2 MB/s on 200 MHz ARM, MIPS, PowerPC or other simple RISC |
||||
- Small memory requirements for decompressing (16 KB + DictionarySize) |
||||
- Small code size for decompressing: 5-8 KB |
||||
|
||||
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 the 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 |
||||
|
||||
The 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 Intel's Core 2 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 parameter. |
||||
Also you can change the 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 the 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, ...). |
||||
|
||||
|
||||
Filters |
||||
------- |
||||
You can increase the compression ratio for some data types, using |
||||
special filters before compressing. For example, it's possible to |
||||
increase the compression ratio on 5-10% for code for those CPU ISAs: |
||||
x86, IA-64, ARM, ARM-Thumb, PowerPC, SPARC. |
||||
|
||||
You can find C source code of such filters in C/Bra*.* files |
||||
|
||||
You can check the 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=arm -m1=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. |
||||
|
||||
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 (lc,lp, pb in encoded form) |
||||
1 4 Dictionary size (little endian) |
||||
5 8 Uncompressed size (little endian). -1 means unknown size |
||||
13 Compressed data |
||||
|
||||
|
||||
ANSI-C LZMA Decoder |
||||
~~~~~~~~~~~~~~~~~~~ |
||||
|
||||
Please note that interfaces for ANSI-C code were changed in LZMA SDK 4.58. |
||||
If you want to use old interfaces you can download previous version of LZMA SDK |
||||
from sourceforge.net site. |
||||
|
||||
To use ANSI-C LZMA Decoder you need the following files: |
||||
1) LzmaDec.h + LzmaDec.c + Types.h |
||||
LzmaUtil/LzmaUtil.c is example application that uses these files. |
||||
|
||||
|
||||
Memory requirements for LZMA decoding |
||||
------------------------------------- |
||||
|
||||
Stack usage of LZMA decoding function for local variables is not |
||||
larger than 200-400 bytes. |
||||
|
||||
LZMA Decoder uses dictionary buffer and internal state structure. |
||||
Internal state structure consumes |
||||
state_size = (4 + (1.5 << (lc + lp))) KB |
||||
by default (lc=3, lp=0), state_size = 16 KB. |
||||
|
||||
|
||||
How To decompress data |
||||
---------------------- |
||||
|
||||
LZMA Decoder (ANSI-C version) now supports 2 interfaces: |
||||
1) Single-call Decompressing |
||||
2) Multi-call State Decompressing (zlib-like interface) |
||||
|
||||
You must use external allocator: |
||||
Example: |
||||
void *SzAlloc(void *p, size_t size) { p = p; return malloc(size); } |
||||
void SzFree(void *p, void *address) { p = p; free(address); } |
||||
ISzAlloc alloc = { SzAlloc, SzFree }; |
||||
|
||||
You can use p = p; operator to disable compiler warnings. |
||||
|
||||
|
||||
Single-call Decompressing |
||||
------------------------- |
||||
When to use: RAM->RAM decompressing |
||||
Compile files: LzmaDec.h + LzmaDec.c + Types.h |
||||
Compile defines: no defines |
||||
Memory Requirements: |
||||
- Input buffer: compressed size |
||||
- Output buffer: uncompressed size |
||||
- LZMA Internal Structures: state_size (16 KB for default settings) |
||||
|
||||
Interface: |
||||
int LzmaDecode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen, |
||||
const Byte *propData, unsigned propSize, ELzmaFinishMode finishMode, |
||||
ELzmaStatus *status, ISzAlloc *alloc); |
||||
In: |
||||
dest - output data |
||||
destLen - output data size |
||||
src - input data |
||||
srcLen - input data size |
||||
propData - LZMA properties (5 bytes) |
||||
propSize - size of propData buffer (5 bytes) |
||||
finishMode - It has meaning only if the decoding reaches output limit (*destLen). |
||||
LZMA_FINISH_ANY - Decode just destLen bytes. |
||||
LZMA_FINISH_END - Stream must be finished after (*destLen). |
||||
You can use LZMA_FINISH_END, when you know that |
||||
current output buffer covers last bytes of stream. |
||||
alloc - Memory allocator. |
||||
|
||||
Out: |
||||
destLen - processed output size |
||||
srcLen - processed input size |
||||
|
||||
Output: |
||||
SZ_OK |
||||
status: |
||||
LZMA_STATUS_FINISHED_WITH_MARK |
||||
LZMA_STATUS_NOT_FINISHED |
||||
LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK |
||||
SZ_ERROR_DATA - Data error |
||||
SZ_ERROR_MEM - Memory allocation error |
||||
SZ_ERROR_UNSUPPORTED - Unsupported properties |
||||
SZ_ERROR_INPUT_EOF - It needs more bytes in input buffer (src). |
||||
|
||||
If LZMA decoder sees end_marker before reaching output limit, it returns OK result, |
||||
and output value of destLen will be less than output buffer size limit. |
||||
|
||||
You can use multiple checks to test data integrity after full decompression: |
||||
1) Check Result and "status" variable. |
||||
2) Check that output(destLen) = uncompressedSize, if you know real uncompressedSize. |
||||
3) Check that output(srcLen) = compressedSize, if you know real compressedSize. |
||||
You must use correct finish mode in that case. */ |
||||
|
||||
|
||||
Multi-call State Decompressing (zlib-like interface) |
||||
---------------------------------------------------- |
||||
|
||||
When to use: file->file decompressing |
||||
Compile files: LzmaDec.h + LzmaDec.c + Types.h |
||||
|
||||
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: state_size (16 KB for default settings) |
||||
- LZMA dictionary (dictionary size is encoded in LZMA properties header) |
||||
|
||||
1) read LZMA properties (5 bytes) and uncompressed size (8 bytes, little-endian) to header: |
||||
unsigned char header[LZMA_PROPS_SIZE + 8]; |
||||
ReadFile(inFile, header, sizeof(header) |
||||
|
||||
2) Allocate CLzmaDec structures (state + dictionary) using LZMA properties |
||||
|
||||
CLzmaDec state; |
||||
LzmaDec_Constr(&state); |
||||
res = LzmaDec_Allocate(&state, header, LZMA_PROPS_SIZE, &g_Alloc); |
||||
if (res != SZ_OK) |
||||
return res; |
||||
|
||||
3) Init LzmaDec structure before any new LZMA stream. And call LzmaDec_DecodeToBuf in loop |
||||
|
||||
LzmaDec_Init(&state); |
||||
for (;;) |
||||
{ |
||||
... |
||||
int res = LzmaDec_DecodeToBuf(CLzmaDec *p, Byte *dest, SizeT *destLen, |
||||
const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode); |
||||
... |
||||
} |
||||
|
||||
|
||||
4) Free all allocated structures |
||||
LzmaDec_Free(&state, &g_Alloc); |
||||
|
||||
For full code example, look at C/LzmaUtil/LzmaUtil.c code. |
||||
|
||||
|
||||
How To compress data |
||||
-------------------- |
||||
|
||||
Compile files: LzmaEnc.h + LzmaEnc.c + Types.h + |
||||
LzFind.c + LzFind.h + LzFindMt.c + LzFindMt.h + LzHash.h |
||||
|
||||
Memory Requirements: |
||||
- (dictSize * 11.5 + 6 MB) + state_size |
||||
|
||||
Lzma Encoder can use two memory allocators: |
||||
1) alloc - for small arrays. |
||||
2) allocBig - for big arrays. |
||||
|
||||
For example, you can use Large RAM Pages (2 MB) in allocBig allocator for |
||||
better compression speed. Note that Windows has bad implementation for |
||||
Large RAM Pages. |
||||
It's OK to use same allocator for alloc and allocBig. |
||||
|
||||
|
||||
Single-call Compression with callbacks |
||||
-------------------------------------- |
||||
|
||||
Check C/LzmaUtil/LzmaUtil.c as example, |
||||
|
||||
When to use: file->file decompressing |
||||
|
||||
1) you must implement callback structures for interfaces: |
||||
ISeqInStream |
||||
ISeqOutStream |
||||
ICompressProgress |
||||
ISzAlloc |
||||
|
||||
static void *SzAlloc(void *p, size_t size) { p = p; return MyAlloc(size); } |
||||
static void SzFree(void *p, void *address) { p = p; MyFree(address); } |
||||
static ISzAlloc g_Alloc = { SzAlloc, SzFree }; |
||||
|
||||
CFileSeqInStream inStream; |
||||
CFileSeqOutStream outStream; |
||||
|
||||
inStream.funcTable.Read = MyRead; |
||||
inStream.file = inFile; |
||||
outStream.funcTable.Write = MyWrite; |
||||
outStream.file = outFile; |
||||
|
||||
|
||||
2) Create CLzmaEncHandle object; |
||||
|
||||
CLzmaEncHandle enc; |
||||
|
||||
enc = LzmaEnc_Create(&g_Alloc); |
||||
if (enc == 0) |
||||
return SZ_ERROR_MEM; |
||||
|
||||
|
||||
3) initialize CLzmaEncProps properties; |
||||
|
||||
LzmaEncProps_Init(&props); |
||||
|
||||
Then you can change some properties in that structure. |
||||
|
||||
4) Send LZMA properties to LZMA Encoder |
||||
|
||||
res = LzmaEnc_SetProps(enc, &props); |
||||
|
||||
5) Write encoded properties to header |
||||
|
||||
Byte header[LZMA_PROPS_SIZE + 8]; |
||||
size_t headerSize = LZMA_PROPS_SIZE; |
||||
UInt64 fileSize; |
||||
int i; |
||||
|
||||
res = LzmaEnc_WriteProperties(enc, header, &headerSize); |
||||
fileSize = MyGetFileLength(inFile); |
||||
for (i = 0; i < 8; i++) |
||||
header[headerSize++] = (Byte)(fileSize >> (8 * i)); |
||||
MyWriteFileAndCheck(outFile, header, headerSize) |
||||
|
||||
6) Call encoding function: |
||||
res = LzmaEnc_Encode(enc, &outStream.funcTable, &inStream.funcTable, |
||||
NULL, &g_Alloc, &g_Alloc); |
||||
|
||||
7) Destroy LZMA Encoder Object |
||||
LzmaEnc_Destroy(enc, &g_Alloc, &g_Alloc); |
||||
|
||||
|
||||
If callback function return some error code, LzmaEnc_Encode also returns that code. |
||||
|
||||
|
||||
Single-call RAM->RAM Compression |
||||
-------------------------------- |
||||
|
||||
Single-call RAM->RAM Compression is similar to Compression with callbacks, |
||||
but you provide pointers to buffers instead of pointers to stream callbacks: |
||||
|
||||
HRes LzmaEncode(Byte *dest, SizeT *destLen, const Byte *src, SizeT srcLen, |
||||
CLzmaEncProps *props, Byte *propsEncoded, SizeT *propsSize, int writeEndMark, |
||||
ICompressProgress *progress, ISzAlloc *alloc, ISzAlloc *allocBig); |
||||
|
||||
Return code: |
||||
SZ_OK - OK |
||||
SZ_ERROR_MEM - Memory allocation error |
||||
SZ_ERROR_PARAM - Incorrect paramater |
||||
SZ_ERROR_OUTPUT_EOF - output buffer overflow |
||||
SZ_ERROR_THREAD - errors in multithreading functions (only for Mt version) |
||||
|
||||
|
||||
|
||||
LZMA Defines |
||||
------------ |
||||
|
||||
_LZMA_SIZE_OPT - Enable some optimizations in LZMA Decoder to get smaller executable code. |
||||
|
||||
_LZMA_PROB32 - It can increase the speed on some 32-bit CPUs, but memory usage for |
||||
some structures 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_NO_SYSTEM_SIZE_T - Define it if you don't want to use size_t type. |
||||
|
||||
|
||||
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. |
||||
C++ LZMA code is just wrapper over ANSI-C code. |
||||
|
||||
|
||||
C++ Notes |
||||
~~~~~~~~~~~~~~~~~~~~~~~~ |
||||
If you use some C++ code folders in 7-Zip (for example, C++ code for .7z handling), |
||||
you must check that you correctly work with "new" operator. |
||||
7-Zip can be compiled with MSVC 6.0 that doesn't throw "exception" from "new" operator. |
||||
So 7-Zip uses "CPP\Common\NewHandler.cpp" that redefines "new" operator: |
||||
operator new(size_t size) |
||||
{ |
||||
void *p = ::malloc(size); |
||||
if (p == 0) |
||||
throw CNewException(); |
||||
return p; |
||||
} |
||||
If you use MSCV that throws exception for "new" operator, you can compile without |
||||
"NewHandler.cpp". So standard exception will be used. Actually some code of |
||||
7-Zip catches any exception in internal code and converts it to HRESULT code. |
||||
So you don't need to catch CNewException, if you call COM interfaces of 7-Zip. |
||||
|
||||
--- |
||||
|
||||
http://www.7-zip.org |
||||
http://www.7-zip.org/sdk.html |
||||
http://www.7-zip.org/support.html |
||||
Loading…
Reference in new issue