]>
Commit | Line | Data |
---|---|---|
fc9c1727 LCM |
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 | --------------------- | |
f12e4549 WD |
120 | C - C source code |
121 | CPP - CPP source code | |
122 | CS - C# source code | |
123 | Java - Java source code | |
fc9c1727 LCM |
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 | ||
f12e4549 WD |
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) | |
fc9c1727 | 150 | |
f12e4549 | 151 | Branch - Filters for x86, IA-64, ARM, ARM-Thumb, PowerPC and SPARC code |
fc9c1727 LCM |
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 | |
f12e4549 | 161 | 7zip - files related to 7-Zip Project |
fc9c1727 LCM |
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 | ||
f12e4549 | 169 | Copy - Copy coder |
fc9c1727 | 170 | RangeCoder - Range Coder (special code of compression/decompression) |
f12e4549 | 171 | LZMA - LZMA compression/decompression on C++ |
fc9c1727 LCM |
172 | LZMA_Alone - file->file LZMA compression/decompression |
173 | ||
f12e4549 | 174 | Branch - Filters for x86, IA-64, ARM, ARM-Thumb, PowerPC and SPARC code |
fc9c1727 LCM |
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 | ||
f12e4549 WD |
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. | |
fc9c1727 | 186 | |
f12e4549 | 187 | UI - User Interface files |
fc9c1727 | 188 | |
f12e4549 | 189 | Client7z - Test application for 7za.dll, 7zr.dll, 7zxr.dll |
fc9c1727 LCM |
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 | |
f12e4549 | 200 | LZMA - LZMA compression/decompression |
fc9c1727 LCM |
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 | |
f12e4549 WD |
207 | LZ - files related to LZ (Lempel-Ziv) compression algorithm |
208 | LZMA - LZMA compression/decompression | |
fc9c1727 LCM |
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 | ||
f12e4549 | 254 | Usage: LZMA <e|d> inputFile outputFile [<switches>...] |
fc9c1727 LCM |
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 | |
f12e4549 | 275 | default: 1 (normal) |
fc9c1727 LCM |
276 | |
277 | d{N}: Sets Dictionary size - [0, 30], default: 23 (8MB) | |
f12e4549 WD |
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). | |
fc9c1727 LCM |
282 | |
283 | -fb{N}: set number of fast bytes - [5, 273], default: 128 | |
f12e4549 WD |
284 | Usually big number gives a little bit better compression ratio |
285 | and slower compression process. | |
fc9c1727 LCM |
286 | |
287 | -lc{N}: set number of literal context bits - [0, 8], default: 3 | |
f12e4549 | 288 | Sometimes lc=4 gives gain for big files. |
fc9c1727 LCM |
289 | |
290 | -lp{N}: set number of literal pos bits - [0, 4], default: 0 | |
f12e4549 WD |
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. | |
fc9c1727 LCM |
295 | |
296 | -pb{N}: set number of pos bits - [0, 4], default: 2 | |
f12e4549 WD |
297 | pb switch is intended for periodical data |
298 | when period is equal 2^N. | |
fc9c1727 LCM |
299 | |
300 | -mf{MF_ID}: set Match Finder. Default: bt4. | |
f12e4549 WD |
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). | |
fc9c1727 | 304 | |
f12e4549 WD |
305 | Memory requirements depend from dictionary size |
306 | (parameter "d" in table below). | |
fc9c1727 | 307 | |
f12e4549 | 308 | MF_ID Memory Description |
fc9c1727 | 309 | |
f12e4549 WD |
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. | |
fc9c1727 LCM |
314 | |
315 | -eos: write End Of Stream marker. By default LZMA doesn't write | |
f12e4549 WD |
316 | eos marker, since LZMA decoder knows uncompressed size |
317 | stored in .lzma file header. | |
fc9c1727 | 318 | |
f12e4549 WD |
319 | -si: Read data from stdin (it will write End Of Stream marker). |
320 | -so: Write data to stdout | |
fc9c1727 LCM |
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 | |
f12e4549 WD |
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 | |
fc9c1727 LCM |
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. | |
f12e4549 WD |
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 | |
fc9c1727 LCM |
635 | |
636 | _LZMA_PROB32 - It can increase speed on some 32-bit CPUs, | |
f12e4549 | 637 | but memory usage will be doubled in that case |
fc9c1727 LCM |
638 | |
639 | _LZMA_UINT32_IS_ULONG - Define it if int is 16-bit on your compiler | |
f12e4549 | 640 | and long is 32-bit. |
fc9c1727 LCM |
641 | |
642 | _LZMA_SYSTEM_SIZE_T - Define it if you want to use system's size_t. | |
f12e4549 | 643 | You can use it to enable 64-bit sizes supporting |
fc9c1727 LCM |
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 |