29
- ANSI-C/C++/C#/Java source code for LZMA compressing and decompressing
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
30
98
- Compiled file->file LZMA compressing/decompressing program for Windows system
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.
33
105
UNIX/Linux version
34
106
------------------
35
To compile C++ version of file->file LZMA encoding, go to directory
36
C++/7zip/Compress/LZMA_Alone
37
and call make to recompile it:
38
make -f makefile.gcc clean all
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.
40
111
In some UNIX/Linux versions you must compile LZMA with static libraries.
41
To compile with static libraries, you can use
112
To compile with static libraries, change string in makefile
46
119
---------------------
47
lzma.txt - LZMA SDK description (this file)
121
CPP - CPP source code
123
Java - Java source code
124
lzma.txt - LZMA SDK description (this file)
48
125
7zFormat.txt - 7z Format description
49
7zC.txt - 7z ANSI-C Decoder description
126
7zC.txt - 7z ANSI-C Decoder description (this file)
50
127
methods.txt - Compression method IDs for .7z
51
lzma.exe - Compiled file->file LZMA encoder/decoder for Windows
52
history.txt - history of the LZMA SDK
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
55
134
Source code structure
56
135
---------------------
60
Alloc.* - Memory allocation functions
61
Bra*.* - Filters for x86, IA-64, ARM, ARM-Thumb, PowerPC and SPARC code
62
LzFind.* - Match finder for LZ (LZMA) encoders
63
LzFindMt.* - Match finder for LZ (LZMA) encoders for multithreading encoding
64
LzHash.h - Additional file for LZ match finder
65
LzmaDec.* - LZMA decoding
66
LzmaEnc.* - LZMA encoding
67
LzmaLib.* - LZMA Library for DLL calling
68
Types.h - Basic types for another .c files
69
Threads.* - The code for multithreading.
71
LzmaLib - LZMA Library (.DLL for Windows)
73
LzmaUtil - LZMA Utility (file->file LZMA encoder/decoder).
138
Compress - files related to compression/decompression
139
Lz - files related to LZ (Lempel-Ziv) compression algorithm
140
Lzma - ANSI-C compatible LZMA decompressor
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)
151
Branch - Filters for x86, IA-64, ARM, ARM-Thumb, PowerPC and SPARC code
75
153
Archive - files related to archiving
76
7z - 7z ANSI-C Decoder
154
7z_C - 7z ANSI-C Decoder
80
159
Common - common files for C++ projects
81
160
Windows - common files for Windows related code
83
7zip - files related to 7-Zip Project
161
7zip - files related to 7-Zip Project
85
163
Common - common files for 7-Zip
87
165
Compress - files related to compression/decompression
167
LZ - files related to LZ (Lempel-Ziv) compression algorithm
90
170
RangeCoder - Range Coder (special code of compression/decompression)
91
LZMA - LZMA compression/decompression on C++
171
LZMA - LZMA compression/decompression on C++
92
172
LZMA_Alone - file->file LZMA compression/decompression
93
Branch - Filters for x86, IA-64, ARM, ARM-Thumb, PowerPC and SPARC code
174
Branch - Filters for x86, IA-64, ARM, ARM-Thumb, PowerPC and SPARC code
95
176
Archive - files related to archiving
187
274
-a{N}: set compression mode 0 = fast, 1 = normal
190
277
d{N}: Sets Dictionary size - [0, 30], default: 23 (8MB)
191
The maximum value for dictionary size is 1 GB = 2^30 bytes.
192
Dictionary size is calculated as DictionarySize = 2^N bytes.
193
For decompressing file compressed by LZMA method with dictionary
194
size D = 2^N you need about D bytes of memory (RAM).
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).
196
283
-fb{N}: set number of fast bytes - [5, 273], default: 128
197
Usually big number gives a little bit better compression ratio
198
and slower compression process.
284
Usually big number gives a little bit better compression ratio
285
and slower compression process.
200
287
-lc{N}: set number of literal context bits - [0, 8], default: 3
201
Sometimes lc=4 gives gain for big files.
288
Sometimes lc=4 gives gain for big files.
203
290
-lp{N}: set number of literal pos bits - [0, 4], default: 0
204
lp switch is intended for periodical data when period is
205
equal 2^N. For example, for 32-bit (4 bytes)
206
periodical data you can use lp=2. Often it's better to set lc0,
207
if you change lp switch.
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.
209
296
-pb{N}: set number of pos bits - [0, 4], default: 2
210
pb switch is intended for periodical data
211
when period is equal 2^N.
297
pb switch is intended for periodical data
298
when period is equal 2^N.
213
300
-mf{MF_ID}: set Match Finder. Default: bt4.
214
Algorithms from hc* group doesn't provide good compression
215
ratio, but they often works pretty fast in combination with
218
Memory requirements depend from dictionary size
219
(parameter "d" in table below).
221
MF_ID Memory Description
223
bt2 d * 9.5 + 4MB Binary Tree with 2 bytes hashing.
224
bt3 d * 11.5 + 4MB Binary Tree with 3 bytes hashing.
225
bt4 d * 11.5 + 4MB Binary Tree with 4 bytes hashing.
226
hc4 d * 7.5 + 4MB Hash Chain with 4 bytes hashing.
301
Algorithms from hc* group doesn't provide good compression
302
ratio, but they often works pretty fast in combination with
305
Memory requirements depend from dictionary size
306
(parameter "d" in table below).
308
MF_ID Memory Description
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.
228
315
-eos: write End Of Stream marker. By default LZMA doesn't write
229
eos marker, since LZMA decoder knows uncompressed size
230
stored in .lzma file header.
316
eos marker, since LZMA decoder knows uncompressed size
317
stored in .lzma file header.
232
-si: Read data from stdin (it will write End Of Stream marker).
233
-so: Write data to stdout
319
-si: Read data from stdin (it will write End Of Stream marker).
320
-so: Write data to stdout
301
392
LZMA compressed file format
302
393
---------------------------
303
394
Offset Size Description
304
0 1 Special LZMA properties (lc,lp, pb in encoded form)
305
1 4 Dictionary size (little endian)
306
5 8 Uncompressed size (little endian). -1 means unknown size
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
310
401
ANSI-C LZMA Decoder
311
402
~~~~~~~~~~~~~~~~~~~
313
Please note that interfaces for ANSI-C code were changed in LZMA SDK 4.58.
314
If you want to use old interfaces you can download previous version of LZMA SDK
315
from sourceforge.net site.
317
To use ANSI-C LZMA Decoder you need the following files:
318
1) LzmaDec.h + LzmaDec.c + Types.h
319
LzmaUtil/LzmaUtil.c is example application that uses these files.
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)
322
410
Memory requirements for LZMA decoding
323
411
-------------------------------------
413
LZMA decoder doesn't allocate memory itself, so you must
414
allocate memory and send it to LZMA.
325
416
Stack usage of LZMA decoding function for local variables is not
326
larger than 200-400 bytes.
328
LZMA Decoder uses dictionary buffer and internal state structure.
329
Internal state structure consumes
330
state_size = (4 + (1.5 << (lc + lp))) KB
331
by default (lc=3, lp=0), state_size = 16 KB.
417
larger than 200 bytes.
334
419
How To decompress data
335
420
----------------------
337
LZMA Decoder (ANSI-C version) now supports 2 interfaces:
422
LZMA Decoder (ANSI-C version) now supports 5 interfaces:
338
423
1) Single-call Decompressing
339
2) Multi-call State Decompressing (zlib-like interface)
341
You must use external allocator:
343
void *SzAlloc(void *p, size_t size) { p = p; return malloc(size); }
344
void SzFree(void *p, void *address) { p = p; free(address); }
345
ISzAlloc alloc = { SzAlloc, SzFree };
347
You can use p = p; operator to disable compiler warnings.
350
Single-call Decompressing
351
-------------------------
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)
429
Variant-5 is similar to Variant-4, but Variant-5 doesn't use callback functions.
434
1) read LZMA properties (5 bytes):
435
unsigned char properties[LZMA_PROPERTIES_SIZE];
437
2) read uncompressed size (8 bytes, little-endian)
439
3) Decode properties:
441
CLzmaDecoderState state; /* it's 24-140 bytes structure, if int is 32-bit */
443
if (LzmaDecodeProperties(&state.Properties, properties, LZMA_PROPERTIES_SIZE) != LZMA_RESULT_OK)
444
return PrintError(rs, "Incorrect stream properties");
446
4) Allocate memory block for internal Structures:
448
state.Probs = (CProb *)malloc(LzmaGetNumProbs(&state.Properties) * sizeof(CProb));
449
if (state.Probs == 0)
450
return PrintError(rs, kCantAllocateMessage);
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.
458
5) Main Decompressing
460
You must use one of the following interfaces:
462
5.1 Single-call Decompressing
463
-----------------------------
352
464
When to use: RAM->RAM decompressing
353
Compile files: LzmaDec.h + LzmaDec.c + Types.h
465
Compile files: LzmaDecode.h, LzmaDecode.c
354
466
Compile defines: no defines
355
467
Memory Requirements:
356
468
- Input buffer: compressed size
357
469
- Output buffer: uncompressed size
358
- LZMA Internal Structures: state_size (16 KB for default settings)
361
int LzmaDecode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,
362
const Byte *propData, unsigned propSize, ELzmaFinishMode finishMode,
363
ELzmaStatus *status, ISzAlloc *alloc);
366
destLen - output data size
368
srcLen - input data size
369
propData - LZMA properties (5 bytes)
370
propSize - size of propData buffer (5 bytes)
371
finishMode - It has meaning only if the decoding reaches output limit (*destLen).
372
LZMA_FINISH_ANY - Decode just destLen bytes.
373
LZMA_FINISH_END - Stream must be finished after (*destLen).
374
You can use LZMA_FINISH_END, when you know that
375
current output buffer covers last bytes of stream.
376
alloc - Memory allocator.
379
destLen - processed output size
380
srcLen - processed input size
385
LZMA_STATUS_FINISHED_WITH_MARK
386
LZMA_STATUS_NOT_FINISHED
387
LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK
388
SZ_ERROR_DATA - Data error
389
SZ_ERROR_MEM - Memory allocation error
390
SZ_ERROR_UNSUPPORTED - Unsupported properties
391
SZ_ERROR_INPUT_EOF - It needs more bytes in input buffer (src).
393
If LZMA decoder sees end_marker before reaching output limit, it returns OK result,
394
and output value of destLen will be less than output buffer size limit.
396
You can use multiple checks to test data integrity after full decompression:
397
1) Check Result and "status" variable.
398
2) Check that output(destLen) = uncompressedSize, if you know real uncompressedSize.
399
3) Check that output(srcLen) = compressedSize, if you know real compressedSize.
400
You must use correct finish mode in that case. */
403
Multi-call State Decompressing (zlib-like interface)
404
----------------------------------------------------
406
When to use: file->file decompressing
407
Compile files: LzmaDec.h + LzmaDec.c + Types.h
410
- Buffer for input stream: any size (for example, 16 KB)
411
- Buffer for output stream: any size (for example, 16 KB)
412
- LZMA Internal Structures: state_size (16 KB for default settings)
413
- LZMA dictionary (dictionary size is encoded in LZMA properties header)
415
1) read LZMA properties (5 bytes) and uncompressed size (8 bytes, little-endian) to header:
416
unsigned char header[LZMA_PROPS_SIZE + 8];
417
ReadFile(inFile, header, sizeof(header)
419
2) Allocate CLzmaDec structures (state + dictionary) using LZMA properties
422
LzmaDec_Constr(&state);
423
res = LzmaDec_Allocate(&state, header, LZMA_PROPS_SIZE, &g_Alloc);
427
3) Init LzmaDec structure before any new LZMA stream. And call LzmaDec_DecodeToBuf in loop
429
LzmaDec_Init(&state);
433
int res = LzmaDec_DecodeToBuf(CLzmaDec *p, Byte *dest, SizeT *destLen,
434
const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode);
439
4) Free all allocated structures
440
LzmaDec_Free(&state, &g_Alloc);
442
For full code example, look at C/LzmaUtil/LzmaUtil.c code.
448
Compile files: LzmaEnc.h + LzmaEnc.c + Types.h +
449
LzFind.c + LzFind.h + LzFindMt.c + LzFindMt.h + LzHash.h
452
- (dictSize * 11.5 + 6 MB) + state_size
454
Lzma Encoder can use two memory allocators:
455
1) alloc - for small arrays.
456
2) allocBig - for big arrays.
458
For example, you can use Large RAM Pages (2 MB) in allocBig allocator for
459
better compression speed. Note that Windows has bad implementation for
461
It's OK to use same allocator for alloc and allocBig.
464
Single-call Compression with callbacks
465
--------------------------------------
467
Check C/LzmaUtil/LzmaUtil.c as example,
469
When to use: file->file decompressing
471
1) you must implement callback structures for interfaces:
477
static void *SzAlloc(void *p, size_t size) { p = p; return MyAlloc(size); }
478
static void SzFree(void *p, void *address) { p = p; MyFree(address); }
479
static ISzAlloc g_Alloc = { SzAlloc, SzFree };
481
CFileSeqInStream inStream;
482
CFileSeqOutStream outStream;
484
inStream.funcTable.Read = MyRead;
485
inStream.file = inFile;
486
outStream.funcTable.Write = MyWrite;
487
outStream.file = outFile;
490
2) Create CLzmaEncHandle object;
494
enc = LzmaEnc_Create(&g_Alloc);
499
3) initialize CLzmaEncProps properties;
501
LzmaEncProps_Init(&props);
503
Then you can change some properties in that structure.
505
4) Send LZMA properties to LZMA Encoder
507
res = LzmaEnc_SetProps(enc, &props);
509
5) Write encoded properties to header
511
Byte header[LZMA_PROPS_SIZE + 8];
512
size_t headerSize = LZMA_PROPS_SIZE;
516
res = LzmaEnc_WriteProperties(enc, header, &headerSize);
517
fileSize = MyGetFileLength(inFile);
518
for (i = 0; i < 8; i++)
519
header[headerSize++] = (Byte)(fileSize >> (8 * i));
520
MyWriteFileAndCheck(outFile, header, headerSize)
522
6) Call encoding function:
523
res = LzmaEnc_Encode(enc, &outStream.funcTable, &inStream.funcTable,
524
NULL, &g_Alloc, &g_Alloc);
526
7) Destroy LZMA Encoder Object
527
LzmaEnc_Destroy(enc, &g_Alloc, &g_Alloc);
530
If callback function return some error code, LzmaEnc_Encode also returns that code.
533
Single-call RAM->RAM Compression
534
--------------------------------
536
Single-call RAM->RAM Compression is similar to Compression with callbacks,
537
but you provide pointers to buffers instead of pointers to stream callbacks:
539
HRes LzmaEncode(Byte *dest, SizeT *destLen, const Byte *src, SizeT srcLen,
540
CLzmaEncProps *props, Byte *propsEncoded, SizeT *propsSize, int writeEndMark,
541
ICompressProgress *progress, ISzAlloc *alloc, ISzAlloc *allocBig);
545
SZ_ERROR_MEM - Memory allocation error
546
SZ_ERROR_PARAM - Incorrect paramater
547
SZ_ERROR_OUTPUT_EOF - output buffer overflow
548
SZ_ERROR_THREAD - errors in multithreading functions (only for Mt version)
470
- LZMA Internal Structures (~16 KB for default settings)
473
int res = LzmaDecode(&state,
474
inStream, compressedSize, &inProcessed,
475
outStream, outSize, &outProcessed);
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
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)
489
typedef struct _CBuffer
491
ILzmaInCallback InCallback;
493
unsigned char Buffer[kInBufferSize];
496
int LzmaReadCompressed(void *object, const unsigned char **buffer, SizeT *size)
498
CBuffer *bo = (CBuffer *)object;
499
*buffer = bo->Buffer;
500
*size = MyReadFile(bo->File, bo->Buffer, kInBufferSize);
501
return LZMA_RESULT_OK;
506
g_InBuffer.File = inFile;
507
g_InBuffer.InCallback.Read = LzmaReadCompressed;
508
int res = LzmaDecode(&state,
509
&g_InBuffer.InCallback,
510
outStream, outSize, &outProcessed);
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
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)
526
state.Dictionary = (unsigned char *)malloc(state.Properties.DictionarySize);
528
LzmaDecoderInit(&state);
532
inBuffer, inAvail, &inProcessed,
533
g_OutBuffer, outAvail, &outProcessed);
534
inAvail -= inProcessed;
535
inBuffer += inProcessed;
537
while you need more bytes
539
see LzmaTest.c for more details.
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
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)
555
state.Dictionary = (unsigned char *)malloc(state.Properties.DictionarySize);
557
LzmaDecoderInit(&state);
562
g_OutBuffer, outAvail, &outProcessed);
564
while you need more bytes
566
see LzmaTest.c for more details:
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
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)
582
state.Dictionary = (unsigned char *)malloc(state.Properties.DictionarySize);
585
LzmaDecoderInit(&state);
588
res = LzmaDecode(&state,
589
inBuffer, inAvail, &inProcessed,
590
g_OutBuffer, outAvail, &outProcessed,
592
inAvail -= inProcessed;
593
inBuffer += inProcessed;
595
while you need more bytes
597
see LzmaStateTest.c for more details:
600
6) Free all allocated blocks
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.
614
LZMA decoder can return one of the following codes:
616
#define LZMA_RESULT_OK 0
617
#define LZMA_RESULT_DATA_ERROR 1
619
If you use callback function for input data and you return some
620
error code, LZMA Decoder also returns that code.
555
_LZMA_SIZE_OPT - Enable some optimizations in LZMA Decoder to get smaller executable code.
557
_LZMA_PROB32 - It can increase the speed on some 32-bit CPUs, but memory usage for
558
some structures will be doubled in that case.
560
_LZMA_UINT32_IS_ULONG - Define it if int is 16-bit on your compiler and long is 32-bit.
562
_LZMA_NO_SYSTEM_SIZE_T - Define it if you don't want to use size_t type.
627
_LZMA_IN_CB - Use callback for input data
629
_LZMA_OUT_READ - Use read function for output data
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
636
_LZMA_PROB32 - It can increase speed on some 32-bit CPUs,
637
but memory usage will be doubled in that case
639
_LZMA_UINT32_IS_ULONG - Define it if int is 16-bit on your compiler
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
565
647
C++ LZMA Encoder/Decoder
566
648
~~~~~~~~~~~~~~~~~~~~~~~~
567
649
C++ LZMA code use COM-like interfaces. So if you want to use it,
568
650
you can study basics of COM/OLE.
569
C++ LZMA code is just wrapper over ANSI-C code.
573
~~~~~~~~~~~~~~~~~~~~~~~~
574
If you use some C++ code folders in 7-Zip (for example, C++ code for .7z handling),
575
you must check that you correctly work with "new" operator.
576
7-Zip can be compiled with MSVC 6.0 that doesn't throw "exception" from "new" operator.
577
So 7-Zip uses "CPP\Common\NewHandler.cpp" that redefines "new" operator:
578
operator new(size_t size)
580
void *p = ::malloc(size);
582
throw CNewException();
585
If you use MSCV that throws exception for "new" operator, you can compile without
586
"NewHandler.cpp". So standard exception will be used. Actually some code of
587
7-Zip catches any exception in internal code and converts it to HRESULT code.
588
So you don't need to catch CNewException, if you call COM interfaces of 7-Zip.
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.
592
662
http://www.7-zip.org
593
http://www.7-zip.org/sdk.html
594
663
http://www.7-zip.org/support.html
added
removed
lib_generic/lzma/lzma.txt
