7z ANSI-C Decoder 4.58
----------------------

7z ANSI-C Decoder 4.58 Copyright (C) 1999-2008 Igor Pavlov

7z ANSI-C provides 7z/LZMA decoding.
7z ANSI-C version is simplified version ported from C++ code.

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.


LICENSE
-------

Read lzma.txt for information about license.


Files
---------------------

7zDecode.*   - Low level 7z decoding
7zExtract.*  - High level 7z decoding
7zHeader.*   - .7z format constants
7zIn.*       - .7z archive opening
7zItem.*     - .7z structures
7zMain.c     - Test application


How To Use
----------

You must download 7-Zip program from www.7-zip.org.

You can create .7z archive with 7z.exe or 7za.exe:

  7za.exe a archive.7z *.htm -r -mx -m0fb=255

If you have big number of files in archive, and you need fast extracting, 
you can use partly-solid archives:
  
  7za.exe a archive.7z *.htm -ms=512K -r -mx -m0fb=255 -m0d=512K

In that example 7-Zip will use 512KB solid blocks. So it needs to decompress only 
512KB for extracting one file from such archive.


Limitations of current version of 7z ANSI-C Decoder
---------------------------------------------------

 - It reads only "FileName", "Size", "LastWriteTime" and "CRC" information for each file in archive.
 - It supports only LZMA and Copy (no compression) methods with BCJ or BCJ2 filters.
 - It converts original UTF-16 Unicode file names to UTF-8 Unicode file names.
 
These limitations will be fixed in future versions.


Using 7z ANSI-C Decoder Test application:
-----------------------------------------

Usage: 7zDec <command> <archive_name>

<Command>:
  e: Extract files from archive
  l: List contents of archive
  t: Test integrity of archive

Example: 

  7zDec l archive.7z

lists contents of archive.7z

  7zDec e archive.7z

extracts files from archive.7z to current folder.


How to use .7z Decoder
----------------------

Memory allocation
~~~~~~~~~~~~~~~~~

7z Decoder uses two memory pools:
1) Temporary pool
2) Main pool
Such scheme can allow you to avoid fragmentation of allocated blocks.


Steps for using 7z decoder
--------------------------

Use code at 7zMain.c as example.

1) Declare variables:
  inStream                 /* implements ISzInStream interface */
  CSzArEx db;              /* 7z archive database structure */
  ISzAlloc allocImp;       /* memory functions for main pool */
  ISzAlloc allocTempImp;   /* memory functions for temporary pool */

2) call CrcGenerateTable(); function to initialize CRC structures.

3) call SzArEx_Init(&db); function to initialize db structures.

4) call SzArEx_Open(&db, inStream, &allocMain, &allocTemp) to open archive

This function opens archive "inStream" and reads headers to "db".
All items in "db" will be allocated with "allocMain" functions.
SzArEx_Open function allocates and frees temporary structures by "allocTemp" functions.

5) List items or Extract items

  Listing code:
  ~~~~~~~~~~~~~
    {
      UInt32 i;
      for (i = 0; i < db.db.NumFiles; i++)
      {
        CFileItem *f = db.db.Files + i;
        printf("%10d  %s\n", (int)f->Size, f->Name);
      }
    }

  Extracting code:
  ~~~~~~~~~~~~~~~~

  SZ_RESULT SzAr_Extract(
    CArchiveDatabaseEx *db,
    ISzInStream *inStream, 
    UInt32 fileIndex,         /* index of file */
    UInt32 *blockIndex,       /* index of solid block */
    Byte **outBuffer,         /* pointer to pointer to output buffer (allocated with allocMain) */
    size_t *outBufferSize,    /* buffer size for output buffer */
    size_t *offset,           /* offset of stream for required file in *outBuffer */
    size_t *outSizeProcessed, /* size of file in *outBuffer */
    ISzAlloc *allocMain,
    ISzAlloc *allocTemp);

  If you need to decompress more than one file, you can send these values from previous call:
    blockIndex, 
    outBuffer, 
    outBufferSize,
  You can consider "outBuffer" as cache of solid block. If your archive is solid, 
  it will increase decompression speed.

  After decompressing you must free "outBuffer":
  allocImp.Free(outBuffer);

6) call SzArEx_Free(&db, allocImp.Free) to free allocated items in "db".




Memory requirements for .7z decoding 
------------------------------------

Memory usage for Archive opening:
  - Temporary pool:
     - Memory for uncompressed .7z headers
     - some other temporary blocks
  - Main pool:
     - Memory for database: 
       Estimated size of one file structures in solid archive:
         - Size (4 or 8 Bytes)
         - CRC32 (4 bytes)
         - LastWriteTime (8 bytes)
         - Some file information (4 bytes)
         - File Name (variable length) + pointer + allocation structures

Memory usage for archive Decompressing:
  - Temporary pool:
     - Memory for LZMA decompressing structures
  - Main pool:
     - Memory for decompressed solid block
     - Memory for temprorary buffers, if BCJ2 fileter is used. Usually these 
       temprorary buffers can be about 15% of solid block size. 
  

7z Decoder doesn't allocate memory for compressed blocks. 
Instead of this, you must allocate buffer with desired 
size before calling 7z Decoder. Use 7zMain.c as example.


Defines
-------

_SZ_ALLOC_DEBUG   - define it if you want to debug alloc/free operations to stderr.


---

http://www.7-zip.org
http://www.7-zip.org/support.html
