repo sync | baa3858 | 2013-07-26 17:53:31 -0700 | [diff] [blame] | 1 | LZMA SDK 9.20
|
| 2 | -------------
|
| 3 |
|
| 4 | LZMA SDK provides the documentation, samples, header files, libraries,
|
| 5 | and tools you need to develop applications that use LZMA compression.
|
| 6 |
|
| 7 | LZMA is default and general compression method of 7z format
|
| 8 | in 7-Zip compression program (www.7-zip.org). LZMA provides high
|
| 9 | compression ratio and very fast decompression.
|
| 10 |
|
| 11 | LZMA is an improved version of famous LZ77 compression algorithm.
|
| 12 | It was improved in way of maximum increasing of compression ratio,
|
| 13 | keeping high decompression speed and low memory requirements for
|
| 14 | decompressing.
|
| 15 |
|
| 16 |
|
| 17 |
|
| 18 | LICENSE
|
| 19 | -------
|
| 20 |
|
| 21 | LZMA SDK is written and placed in the public domain by Igor Pavlov.
|
| 22 |
|
| 23 | Some code in LZMA SDK is based on public domain code from another developers:
|
| 24 | 1) PPMd var.H (2001): Dmitry Shkarin
|
| 25 | 2) SHA-256: Wei Dai (Crypto++ library)
|
| 26 |
|
| 27 |
|
| 28 | LZMA SDK Contents
|
| 29 | -----------------
|
| 30 |
|
| 31 | LZMA SDK includes:
|
| 32 |
|
| 33 | - ANSI-C/C++/C#/Java source code for LZMA compressing and decompressing
|
| 34 | - Compiled file->file LZMA compressing/decompressing program for Windows system
|
| 35 |
|
| 36 |
|
| 37 | UNIX/Linux version
|
| 38 | ------------------
|
| 39 | To compile C++ version of file->file LZMA encoding, go to directory
|
| 40 | CPP/7zip/Bundles/LzmaCon
|
| 41 | and call make to recompile it:
|
| 42 | make -f makefile.gcc clean all
|
| 43 |
|
| 44 | In some UNIX/Linux versions you must compile LZMA with static libraries.
|
| 45 | To compile with static libraries, you can use
|
| 46 | LIB = -lm -static
|
| 47 |
|
| 48 |
|
| 49 | Files
|
| 50 | ---------------------
|
| 51 | lzma.txt - LZMA SDK description (this file)
|
| 52 | 7zFormat.txt - 7z Format description
|
| 53 | 7zC.txt - 7z ANSI-C Decoder description
|
| 54 | methods.txt - Compression method IDs for .7z
|
| 55 | lzma.exe - Compiled file->file LZMA encoder/decoder for Windows
|
| 56 | 7zr.exe - 7-Zip with 7z/lzma/xz support.
|
| 57 | history.txt - history of the LZMA SDK
|
| 58 |
|
| 59 |
|
| 60 | Source code structure
|
| 61 | ---------------------
|
| 62 |
|
| 63 | C/ - C files
|
| 64 | 7zCrc*.* - CRC code
|
| 65 | Alloc.* - Memory allocation functions
|
| 66 | Bra*.* - Filters for x86, IA-64, ARM, ARM-Thumb, PowerPC and SPARC code
|
| 67 | LzFind.* - Match finder for LZ (LZMA) encoders
|
| 68 | LzFindMt.* - Match finder for LZ (LZMA) encoders for multithreading encoding
|
| 69 | LzHash.h - Additional file for LZ match finder
|
| 70 | LzmaDec.* - LZMA decoding
|
| 71 | LzmaEnc.* - LZMA encoding
|
| 72 | LzmaLib.* - LZMA Library for DLL calling
|
| 73 | Types.h - Basic types for another .c files
|
| 74 | Threads.* - The code for multithreading.
|
| 75 |
|
| 76 | LzmaLib - LZMA Library (.DLL for Windows)
|
| 77 |
|
| 78 | LzmaUtil - LZMA Utility (file->file LZMA encoder/decoder).
|
| 79 |
|
| 80 | Archive - files related to archiving
|
| 81 | 7z - 7z ANSI-C Decoder
|
| 82 |
|
| 83 | CPP/ -- CPP files
|
| 84 |
|
| 85 | Common - common files for C++ projects
|
| 86 | Windows - common files for Windows related code
|
| 87 |
|
| 88 | 7zip - files related to 7-Zip Project
|
| 89 |
|
| 90 | Common - common files for 7-Zip
|
| 91 |
|
| 92 | Compress - files related to compression/decompression
|
| 93 |
|
| 94 | Archive - files related to archiving
|
| 95 |
|
| 96 | Common - common files for archive handling
|
| 97 | 7z - 7z C++ Encoder/Decoder
|
| 98 |
|
| 99 | Bundles - Modules that are bundles of other modules
|
| 100 |
|
| 101 | Alone7z - 7zr.exe: Standalone version of 7z.exe that supports only 7z/LZMA/BCJ/BCJ2
|
| 102 | LzmaCon - lzma.exe: LZMA compression/decompression
|
| 103 | Format7zR - 7zr.dll: Reduced version of 7za.dll: extracting/compressing to 7z/LZMA/BCJ/BCJ2
|
| 104 | Format7zExtractR - 7zxr.dll: Reduced version of 7zxa.dll: extracting from 7z/LZMA/BCJ/BCJ2.
|
| 105 |
|
| 106 | UI - User Interface files
|
| 107 |
|
| 108 | Client7z - Test application for 7za.dll, 7zr.dll, 7zxr.dll
|
| 109 | Common - Common UI files
|
| 110 | Console - Code for console archiver
|
| 111 |
|
| 112 |
|
| 113 |
|
| 114 | CS/ - C# files
|
| 115 | 7zip
|
| 116 | Common - some common files for 7-Zip
|
| 117 | Compress - files related to compression/decompression
|
| 118 | LZ - files related to LZ (Lempel-Ziv) compression algorithm
|
| 119 | LZMA - LZMA compression/decompression
|
| 120 | LzmaAlone - file->file LZMA compression/decompression
|
| 121 | RangeCoder - Range Coder (special code of compression/decompression)
|
| 122 |
|
| 123 | Java/ - Java files
|
| 124 | SevenZip
|
| 125 | Compression - files related to compression/decompression
|
| 126 | LZ - files related to LZ (Lempel-Ziv) compression algorithm
|
| 127 | LZMA - LZMA compression/decompression
|
| 128 | RangeCoder - Range Coder (special code of compression/decompression)
|
| 129 |
|
| 130 |
|
| 131 | C/C++ source code of LZMA SDK is part of 7-Zip project.
|
| 132 | 7-Zip source code can be downloaded from 7-Zip's SourceForge page:
|
| 133 |
|
| 134 | http://sourceforge.net/projects/sevenzip/
|
| 135 |
|
| 136 |
|
| 137 |
|
| 138 | LZMA features
|
| 139 | -------------
|
| 140 | - Variable dictionary size (up to 1 GB)
|
| 141 | - Estimated compressing speed: about 2 MB/s on 2 GHz CPU
|
| 142 | - Estimated decompressing speed:
|
| 143 | - 20-30 MB/s on 2 GHz Core 2 or AMD Athlon 64
|
| 144 | - 1-2 MB/s on 200 MHz ARM, MIPS, PowerPC or other simple RISC
|
| 145 | - Small memory requirements for decompressing (16 KB + DictionarySize)
|
| 146 | - Small code size for decompressing: 5-8 KB
|
| 147 |
|
| 148 | LZMA decoder uses only integer operations and can be
|
| 149 | implemented in any modern 32-bit CPU (or on 16-bit CPU with some conditions).
|
| 150 |
|
| 151 | Some critical operations that affect the speed of LZMA decompression:
|
| 152 | 1) 32*16 bit integer multiply
|
| 153 | 2) Misspredicted branches (penalty mostly depends from pipeline length)
|
| 154 | 3) 32-bit shift and arithmetic operations
|
| 155 |
|
| 156 | The speed of LZMA decompressing mostly depends from CPU speed.
|
| 157 | Memory speed has no big meaning. But if your CPU has small data cache,
|
| 158 | overall weight of memory speed will slightly increase.
|
| 159 |
|
| 160 |
|
| 161 | How To Use
|
| 162 | ----------
|
| 163 |
|
| 164 | Using LZMA encoder/decoder executable
|
| 165 | --------------------------------------
|
| 166 |
|
| 167 | Usage: LZMA <e|d> inputFile outputFile [<switches>...]
|
| 168 |
|
| 169 | e: encode file
|
| 170 |
|
| 171 | d: decode file
|
| 172 |
|
| 173 | b: Benchmark. There are two tests: compressing and decompressing
|
| 174 | with LZMA method. Benchmark shows rating in MIPS (million
|
| 175 | instructions per second). Rating value is calculated from
|
| 176 | measured speed and it is normalized with Intel's Core 2 results.
|
| 177 | Also Benchmark checks possible hardware errors (RAM
|
| 178 | errors in most cases). Benchmark uses these settings:
|
| 179 | (-a1, -d21, -fb32, -mfbt4). You can change only -d parameter.
|
| 180 | Also you can change the number of iterations. Example for 30 iterations:
|
| 181 | LZMA b 30
|
| 182 | Default number of iterations is 10.
|
| 183 |
|
| 184 | <Switches>
|
| 185 |
|
| 186 |
|
| 187 | -a{N}: set compression mode 0 = fast, 1 = normal
|
| 188 | default: 1 (normal)
|
| 189 |
|
| 190 | 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).
|
| 195 |
|
| 196 | -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.
|
| 199 |
|
| 200 | -lc{N}: set number of literal context bits - [0, 8], default: 3
|
| 201 | Sometimes lc=4 gives gain for big files.
|
| 202 |
|
| 203 | -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.
|
| 208 |
|
| 209 | -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.
|
| 212 |
|
| 213 | -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
|
| 216 | fast mode (-a0).
|
| 217 |
|
| 218 | Memory requirements depend from dictionary size
|
| 219 | (parameter "d" in table below).
|
| 220 |
|
| 221 | MF_ID Memory Description
|
| 222 |
|
| 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.
|
| 227 |
|
| 228 | -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.
|
| 231 |
|
| 232 | -si: Read data from stdin (it will write End Of Stream marker).
|
| 233 | -so: Write data to stdout
|
| 234 |
|
| 235 |
|
| 236 | Examples:
|
| 237 |
|
| 238 | 1) LZMA e file.bin file.lzma -d16 -lc0
|
| 239 |
|
| 240 | compresses file.bin to file.lzma with 64 KB dictionary (2^16=64K)
|
| 241 | and 0 literal context bits. -lc0 allows to reduce memory requirements
|
| 242 | for decompression.
|
| 243 |
|
| 244 |
|
| 245 | 2) LZMA e file.bin file.lzma -lc0 -lp2
|
| 246 |
|
| 247 | compresses file.bin to file.lzma with settings suitable
|
| 248 | for 32-bit periodical data (for example, ARM or MIPS code).
|
| 249 |
|
| 250 | 3) LZMA d file.lzma file.bin
|
| 251 |
|
| 252 | decompresses file.lzma to file.bin.
|
| 253 |
|
| 254 |
|
| 255 | Compression ratio hints
|
| 256 | -----------------------
|
| 257 |
|
| 258 | Recommendations
|
| 259 | ---------------
|
| 260 |
|
| 261 | To increase the compression ratio for LZMA compressing it's desirable
|
| 262 | to have aligned data (if it's possible) and also it's desirable to locate
|
| 263 | data in such order, where code is grouped in one place and data is
|
| 264 | grouped in other place (it's better than such mixing: code, data, code,
|
| 265 | data, ...).
|
| 266 |
|
| 267 |
|
| 268 | Filters
|
| 269 | -------
|
| 270 | You can increase the compression ratio for some data types, using
|
| 271 | special filters before compressing. For example, it's possible to
|
| 272 | increase the compression ratio on 5-10% for code for those CPU ISAs:
|
| 273 | x86, IA-64, ARM, ARM-Thumb, PowerPC, SPARC.
|
| 274 |
|
| 275 | You can find C source code of such filters in C/Bra*.* files
|
| 276 |
|
| 277 | You can check the compression ratio gain of these filters with such
|
| 278 | 7-Zip commands (example for ARM code):
|
| 279 | No filter:
|
| 280 | 7z a a1.7z a.bin -m0=lzma
|
| 281 |
|
| 282 | With filter for little-endian ARM code:
|
| 283 | 7z a a2.7z a.bin -m0=arm -m1=lzma
|
| 284 |
|
| 285 | It works in such manner:
|
| 286 | Compressing = Filter_encoding + LZMA_encoding
|
| 287 | Decompressing = LZMA_decoding + Filter_decoding
|
| 288 |
|
| 289 | Compressing and decompressing speed of such filters is very high,
|
| 290 | so it will not increase decompressing time too much.
|
| 291 | Moreover, it reduces decompression time for LZMA_decoding,
|
| 292 | since compression ratio with filtering is higher.
|
| 293 |
|
| 294 | These filters convert CALL (calling procedure) instructions
|
| 295 | from relative offsets to absolute addresses, so such data becomes more
|
| 296 | compressible.
|
| 297 |
|
| 298 | For some ISAs (for example, for MIPS) it's impossible to get gain from such filter.
|
| 299 |
|
| 300 |
|
| 301 | LZMA compressed file format
|
| 302 | ---------------------------
|
| 303 | 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
|
| 307 | 13 Compressed data
|
| 308 |
|
| 309 |
|
| 310 | ANSI-C LZMA Decoder
|
| 311 | ~~~~~~~~~~~~~~~~~~~
|
| 312 |
|
| 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.
|
| 316 |
|
| 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.
|
| 320 |
|
| 321 |
|
| 322 | Memory requirements for LZMA decoding
|
| 323 | -------------------------------------
|
| 324 |
|
| 325 | Stack usage of LZMA decoding function for local variables is not
|
| 326 | larger than 200-400 bytes.
|
| 327 |
|
| 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.
|
| 332 |
|
| 333 |
|
| 334 | How To decompress data
|
| 335 | ----------------------
|
| 336 |
|
| 337 | LZMA Decoder (ANSI-C version) now supports 2 interfaces:
|
| 338 | 1) Single-call Decompressing
|
| 339 | 2) Multi-call State Decompressing (zlib-like interface)
|
| 340 |
|
| 341 | You must use external allocator:
|
| 342 | Example:
|
| 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 };
|
| 346 |
|
| 347 | You can use p = p; operator to disable compiler warnings.
|
| 348 |
|
| 349 |
|
| 350 | Single-call Decompressing
|
| 351 | -------------------------
|
| 352 | When to use: RAM->RAM decompressing
|
| 353 | Compile files: LzmaDec.h + LzmaDec.c + Types.h
|
| 354 | Compile defines: no defines
|
| 355 | Memory Requirements:
|
| 356 | - Input buffer: compressed size
|
| 357 | - Output buffer: uncompressed size
|
| 358 | - LZMA Internal Structures: state_size (16 KB for default settings)
|
| 359 |
|
| 360 | Interface:
|
| 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);
|
| 364 | In:
|
| 365 | dest - output data
|
| 366 | destLen - output data size
|
| 367 | src - input data
|
| 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.
|
| 377 |
|
| 378 | Out:
|
| 379 | destLen - processed output size
|
| 380 | srcLen - processed input size
|
| 381 |
|
| 382 | Output:
|
| 383 | SZ_OK
|
| 384 | status:
|
| 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).
|
| 392 |
|
| 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.
|
| 395 |
|
| 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. */
|
| 401 |
|
| 402 |
|
| 403 | Multi-call State Decompressing (zlib-like interface)
|
| 404 | ----------------------------------------------------
|
| 405 |
|
| 406 | When to use: file->file decompressing
|
| 407 | Compile files: LzmaDec.h + LzmaDec.c + Types.h
|
| 408 |
|
| 409 | Memory Requirements:
|
| 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)
|
| 414 |
|
| 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)
|
| 418 |
|
| 419 | 2) Allocate CLzmaDec structures (state + dictionary) using LZMA properties
|
| 420 |
|
| 421 | CLzmaDec state;
|
| 422 | LzmaDec_Constr(&state);
|
| 423 | res = LzmaDec_Allocate(&state, header, LZMA_PROPS_SIZE, &g_Alloc);
|
| 424 | if (res != SZ_OK)
|
| 425 | return res;
|
| 426 |
|
| 427 | 3) Init LzmaDec structure before any new LZMA stream. And call LzmaDec_DecodeToBuf in loop
|
| 428 |
|
| 429 | LzmaDec_Init(&state);
|
| 430 | for (;;)
|
| 431 | {
|
| 432 | ...
|
| 433 | int res = LzmaDec_DecodeToBuf(CLzmaDec *p, Byte *dest, SizeT *destLen,
|
| 434 | const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode);
|
| 435 | ...
|
| 436 | }
|
| 437 |
|
| 438 |
|
| 439 | 4) Free all allocated structures
|
| 440 | LzmaDec_Free(&state, &g_Alloc);
|
| 441 |
|
| 442 | For full code example, look at C/LzmaUtil/LzmaUtil.c code.
|
| 443 |
|
| 444 |
|
| 445 | How To compress data
|
| 446 | --------------------
|
| 447 |
|
| 448 | Compile files: LzmaEnc.h + LzmaEnc.c + Types.h +
|
| 449 | LzFind.c + LzFind.h + LzFindMt.c + LzFindMt.h + LzHash.h
|
| 450 |
|
| 451 | Memory Requirements:
|
| 452 | - (dictSize * 11.5 + 6 MB) + state_size
|
| 453 |
|
| 454 | Lzma Encoder can use two memory allocators:
|
| 455 | 1) alloc - for small arrays.
|
| 456 | 2) allocBig - for big arrays.
|
| 457 |
|
| 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
|
| 460 | Large RAM Pages.
|
| 461 | It's OK to use same allocator for alloc and allocBig.
|
| 462 |
|
| 463 |
|
| 464 | Single-call Compression with callbacks
|
| 465 | --------------------------------------
|
| 466 |
|
| 467 | Check C/LzmaUtil/LzmaUtil.c as example,
|
| 468 |
|
| 469 | When to use: file->file decompressing
|
| 470 |
|
| 471 | 1) you must implement callback structures for interfaces:
|
| 472 | ISeqInStream
|
| 473 | ISeqOutStream
|
| 474 | ICompressProgress
|
| 475 | ISzAlloc
|
| 476 |
|
| 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 };
|
| 480 |
|
| 481 | CFileSeqInStream inStream;
|
| 482 | CFileSeqOutStream outStream;
|
| 483 |
|
| 484 | inStream.funcTable.Read = MyRead;
|
| 485 | inStream.file = inFile;
|
| 486 | outStream.funcTable.Write = MyWrite;
|
| 487 | outStream.file = outFile;
|
| 488 |
|
| 489 |
|
| 490 | 2) Create CLzmaEncHandle object;
|
| 491 |
|
| 492 | CLzmaEncHandle enc;
|
| 493 |
|
| 494 | enc = LzmaEnc_Create(&g_Alloc);
|
| 495 | if (enc == 0)
|
| 496 | return SZ_ERROR_MEM;
|
| 497 |
|
| 498 |
|
| 499 | 3) initialize CLzmaEncProps properties;
|
| 500 |
|
| 501 | LzmaEncProps_Init(&props);
|
| 502 |
|
| 503 | Then you can change some properties in that structure.
|
| 504 |
|
| 505 | 4) Send LZMA properties to LZMA Encoder
|
| 506 |
|
| 507 | res = LzmaEnc_SetProps(enc, &props);
|
| 508 |
|
| 509 | 5) Write encoded properties to header
|
| 510 |
|
| 511 | Byte header[LZMA_PROPS_SIZE + 8];
|
| 512 | size_t headerSize = LZMA_PROPS_SIZE;
|
| 513 | UInt64 fileSize;
|
| 514 | int i;
|
| 515 |
|
| 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)
|
| 521 |
|
| 522 | 6) Call encoding function:
|
| 523 | res = LzmaEnc_Encode(enc, &outStream.funcTable, &inStream.funcTable,
|
| 524 | NULL, &g_Alloc, &g_Alloc);
|
| 525 |
|
| 526 | 7) Destroy LZMA Encoder Object
|
| 527 | LzmaEnc_Destroy(enc, &g_Alloc, &g_Alloc);
|
| 528 |
|
| 529 |
|
| 530 | If callback function return some error code, LzmaEnc_Encode also returns that code
|
| 531 | or it can return the code like SZ_ERROR_READ, SZ_ERROR_WRITE or SZ_ERROR_PROGRESS.
|
| 532 |
|
| 533 |
|
| 534 | Single-call RAM->RAM Compression
|
| 535 | --------------------------------
|
| 536 |
|
| 537 | Single-call RAM->RAM Compression is similar to Compression with callbacks,
|
| 538 | but you provide pointers to buffers instead of pointers to stream callbacks:
|
| 539 |
|
| 540 | HRes LzmaEncode(Byte *dest, SizeT *destLen, const Byte *src, SizeT srcLen,
|
| 541 | CLzmaEncProps *props, Byte *propsEncoded, SizeT *propsSize, int writeEndMark,
|
| 542 | ICompressProgress *progress, ISzAlloc *alloc, ISzAlloc *allocBig);
|
| 543 |
|
| 544 | Return code:
|
| 545 | SZ_OK - OK
|
| 546 | SZ_ERROR_MEM - Memory allocation error
|
| 547 | SZ_ERROR_PARAM - Incorrect paramater
|
| 548 | SZ_ERROR_OUTPUT_EOF - output buffer overflow
|
| 549 | SZ_ERROR_THREAD - errors in multithreading functions (only for Mt version)
|
| 550 |
|
| 551 |
|
| 552 |
|
| 553 | Defines
|
| 554 | -------
|
| 555 |
|
| 556 | _LZMA_SIZE_OPT - Enable some optimizations in LZMA Decoder to get smaller executable code.
|
| 557 |
|
| 558 | _LZMA_PROB32 - It can increase the speed on some 32-bit CPUs, but memory usage for
|
| 559 | some structures will be doubled in that case.
|
| 560 |
|
| 561 | _LZMA_UINT32_IS_ULONG - Define it if int is 16-bit on your compiler and long is 32-bit.
|
| 562 |
|
| 563 | _LZMA_NO_SYSTEM_SIZE_T - Define it if you don't want to use size_t type.
|
| 564 |
|
| 565 |
|
| 566 | _7ZIP_PPMD_SUPPPORT - Define it if you don't want to support PPMD method in AMSI-C .7z decoder.
|
| 567 |
|
| 568 |
|
| 569 | C++ LZMA Encoder/Decoder
|
| 570 | ~~~~~~~~~~~~~~~~~~~~~~~~
|
| 571 | C++ LZMA code use COM-like interfaces. So if you want to use it,
|
| 572 | you can study basics of COM/OLE.
|
| 573 | C++ LZMA code is just wrapper over ANSI-C code.
|
| 574 |
|
| 575 |
|
| 576 | C++ Notes
|
| 577 | ~~~~~~~~~~~~~~~~~~~~~~~~
|
| 578 | If you use some C++ code folders in 7-Zip (for example, C++ code for .7z handling),
|
| 579 | you must check that you correctly work with "new" operator.
|
| 580 | 7-Zip can be compiled with MSVC 6.0 that doesn't throw "exception" from "new" operator.
|
| 581 | So 7-Zip uses "CPP\Common\NewHandler.cpp" that redefines "new" operator:
|
| 582 | operator new(size_t size)
|
| 583 | {
|
| 584 | void *p = ::malloc(size);
|
| 585 | if (p == 0)
|
| 586 | throw CNewException();
|
| 587 | return p;
|
| 588 | }
|
| 589 | If you use MSCV that throws exception for "new" operator, you can compile without
|
| 590 | "NewHandler.cpp". So standard exception will be used. Actually some code of
|
| 591 | 7-Zip catches any exception in internal code and converts it to HRESULT code.
|
| 592 | So you don't need to catch CNewException, if you call COM interfaces of 7-Zip.
|
| 593 |
|
| 594 | ---
|
| 595 |
|
| 596 | http://www.7-zip.org
|
| 597 | http://www.7-zip.org/sdk.html
|
| 598 | http://www.7-zip.org/support.html
|