SDK overview

// Example: LZMA compression in C
#include "LzmaEnc.h"
#include "LzmaDec.h"

// Compress data
SizeT destLen = sourceLen + sourceLen / 3 + 128;
LzmaCompress(dest, &destLen, src, sourceLen, ...);

// Decompress data
LzmaDecode(dest, &destLen, src, &srcLen, ...);

// Example: Open and extract 7z archive
#include "7z.h"
#include "7zAlloc.h"

CSzArEx db;
ISzAlloc allocImp;
ISzAlloc allocTempImp;

// Initialize
SzArEx_Init(&db);

// Open archive
SzArEx_Open(&db, inStream, &allocImp, &allocTempImp);

// Extract files
for (i = 0; i < db.NumFiles; i++) {
    SzArEx_Extract(&db, inStream, i, ...);
}

// Cleanup
SzArEx_Free(&db, allocImp.Free);

// Load 7z.dll
HMODULE lib = LoadLibrary("7z.dll");
CreateObjectFunc createObject = 
    (CreateObjectFunc)GetProcAddress(lib, "CreateObject");

// Create archive handler
IInArchive* archive;
createObject(&CLSID_CFormatZip, &IID_IInArchive, (void**)&archive);

interface IInArchive {
    Open(IInStream *stream, ...);          // Open archive
    GetNumberOfItems(UInt32 *numItems);    // Get file count
    GetProperty(UInt32 index, ...);        // Get file info
    Extract(const UInt32* indices, ...);   // Extract files
    Close();                                // Close archive
};

interface IOutArchive {
    UpdateItems(ISequentialOutStream *stream, ...);
    GetFileTimeType(UInt32 *type);
};

// From 7z.h (lines 16-20)
typedef struct {
    void *(*Alloc)(ISzAllocPtr p, size_t size);
    void (*Free)(ISzAllocPtr p, void *address);
} ISzAlloc;

// Example allocator
static void *SzAlloc(ISzAllocPtr p, size_t size) { 
    return malloc(size); 
}

static void SzFree(ISzAllocPtr p, void *address) { 
    free(address); 
}

static const ISzAlloc g_Alloc = { SzAlloc, SzFree };

// From LzmaEnc.h
typedef struct {
    UInt32 level;          // 0-9
    UInt32 dictSize;       // Dictionary size
    UInt32 lc;             // Number of literal context bits (0-8)
    UInt32 lp;             // Number of literal pos bits (0-4)
    UInt32 pb;             // Number of pos bits (0-4)
    UInt32 fb;             // Fast bytes (5-273)
    UInt32 numThreads;     // 1-2
} CLzmaEncProps;

// Initialize encoder
LzmaEncProps_Init(&props);
props.level = 9;
props.dictSize = 1 << 24; // 16 MB

// Create encoder
CLzmaEncHandle enc = LzmaEnc_Create(&g_Alloc);
LzmaEnc_SetProps(enc, &props);
LzmaEnc_Encode(enc, outStream, inStream, ...);
LzmaEnc_Destroy(enc, &g_Alloc);

// From LzmaDec.h
typedef struct {
    unsigned lc, lp, pb;   // Properties
    UInt32 dicSize;         // Dictionary size
} CLzmaProps;

// Decode header
LzmaProps_Decode(&props, header, LZMA_PROPS_SIZE);

// Initialize decoder
CLzmaDec dec;
LzmaDec_Construct(&dec);
LzmaDec_Allocate(&dec, &props, &g_Alloc);
LzmaDec_Init(&dec);

// Decode data
SizeT destLen = ..., srcLen = ...;
LzmaDec_DecodeToBuf(&dec, dest, &destLen, src, &srcLen, ...);

// Cleanup
LzmaDec_Free(&dec, &g_Alloc);

typedef enum {
    SZ_OK = 0,
    SZ_ERROR_DATA = 1,
    SZ_ERROR_MEM = 2,
    SZ_ERROR_CRC = 3,
    SZ_ERROR_UNSUPPORTED = 4,
    SZ_ERROR_PARAM = 5,
    SZ_ERROR_INPUT_EOF = 6,
    SZ_ERROR_OUTPUT_EOF = 7,
    SZ_ERROR_READ = 8,
    SZ_ERROR_WRITE = 9,
    SZ_ERROR_PROGRESS = 10,
    SZ_ERROR_FAIL = 11,
    SZ_ERROR_THREAD = 12,
    SZ_ERROR_ARCHIVE = 16,
    SZ_ERROR_NO_ARCHIVE = 17
} SRes;

cd C\\Util\\Lzma
nmake /f makefile

cd C/Util/Lzma
make -f makefile.gcc

#include "LzmaLib.h"

unsigned char src[1000000];
unsigned char dest[1100000];
size_t destLen = sizeof(dest);
size_t srcLen = sizeof(src);

// Compress
int res = LzmaCompress(
    dest, &destLen,
    src, srcLen,
    dest + destLen, 5,  // props
    1 << 24,            // dictSize = 16MB
    3, 0, 2, 32, 2      // lc, lp, pb, fb, numThreads
);

if (res == SZ_OK) {
    printf("Compressed %zu -> %zu bytes\n", srcLen, destLen);
}

#include "7z.h"
#include "7zFile.h"
#include "7zAlloc.h"

CFileInStream archiveStream;
CLookToRead2 lookStream;
CSzArEx db;
ISzAlloc allocImp = {SzAlloc, SzFree};
ISzAlloc allocTempImp = {SzAllocTemp, SzFreeTemp};

// Open file
if (InFile_Open(&archiveStream.file, "archive.7z"))
    return 1;

// Initialize
FileInStream_CreateVTable(&archiveStream);
LookToRead2_CreateVTable(&lookStream, False);
lookStream.buf = NULL;
lookStream.bufSize = 0;
lookStream.realStream = &archiveStream.vt;
LookToRead2_Init(&lookStream);

CrcGenerateTable();
SzArEx_Init(&db);

// Open archive
SRes res = SzArEx_Open(&db, &lookStream.vt, &allocImp, &allocTempImp);

if (res == SZ_OK) {
    // Extract files
    for (UInt32 i = 0; i < db.NumFiles; i++) {
        // ... extract file i
    }
}

// Cleanup
SzArEx_Free(&db, &allocImp);
File_Close(&archiveStream.file);