luajitos

LZMA.c (8803B)

---

 #include "compression.h"
 #include <stdlib.h>
 #include <string.h>
 #include <lauxlib.h>
 
 /*
  * LZMA Compression Implementation
  *
  * NOTE: This is a SIMPLIFIED implementation for educational purposes.
  * For production use, integrate one of these proven libraries:
  *
  * 1. LZMA SDK (Recommended) ⭐
  *    - Official implementation
  *    - Download: https://www.7-zip.org/sdk.html
  *    - Files needed: LzmaDec.c, LzmaEnc.c, LzFind.c
  *    - Public domain
  *
  * 2. XZ Utils
  *    - Modern LZMA implementation
  *    - Better API than LZMA SDK
  *    - Used by Linux kernel
  *
  * This simplified version implements:
  * - Basic LZMA header structure
  * - Uncompressed storage (as placeholder)
  * - For real compression, integrate LZMA SDK
  */
 
 /* LZMA constants */
 #define LZMA_PROPS_SIZE 5
 #define LZMA_HEADER_SIZE 13  // props(5) + uncompressed_size(8)
 #define LZMA_DICT_SIZE_DEFAULT (1 << 23)  // 8MB
 
 /* LZMA header structure */
 typedef struct {
     uint8_t props[LZMA_PROPS_SIZE];  // LZMA properties
     uint64_t uncompressed_size;       // Size of original data (or -1 if unknown)
 } lzma_header_t;
 
 /* Get dictionary size based on compression level (0-9) */
 static uint32_t lzma_get_dict_size(int level) {
     /* Dictionary size increases with level:
      * Level 0-1: 64KB
      * Level 2-3: 1MB
      * Level 4-5: 4MB
      * Level 6-7: 8MB
      * Level 8-9: 16MB
      */
     if (level < 0) level = 0;
     if (level > 9) level = 9;
 
     if (level <= 1) return 1 << 16;       /* 64KB */
     else if (level <= 3) return 1 << 20;  /* 1MB */
     else if (level <= 5) return 1 << 22;  /* 4MB */
     else if (level <= 7) return 1 << 23;  /* 8MB */
     else return 1 << 24;                   /* 16MB */
 }
 
 /* Get LZMA properties based on compression level */
 static void lzma_get_props(uint8_t* props, int level) {
     /* Properties: lc=3, lp=0, pb=2
      * props[0] = (pb * 5 + lp) * 9 + lc
      * props[1-4] = dict_size (little-endian)
      */
     props[0] = (2 * 5 + 0) * 9 + 3;  // lc=3, lp=0, pb=2
 
     uint32_t dict_size = lzma_get_dict_size(level);
     props[1] = dict_size & 0xFF;
     props[2] = (dict_size >> 8) & 0xFF;
     props[3] = (dict_size >> 16) & 0xFF;
     props[4] = (dict_size >> 24) & 0xFF;
 }
 
 /* Write 64-bit little-endian */
 static void write_le64(uint8_t* buf, uint64_t value) {
     for (int i = 0; i < 8; i++) {
         buf[i] = (value >> (i * 8)) & 0xFF;
     }
 }
 
 /* Read 64-bit little-endian */
 static uint64_t read_le64(const uint8_t* buf) {
     uint64_t value = 0;
     for (int i = 0; i < 8; i++) {
         value |= ((uint64_t)buf[i]) << (i * 8);
     }
     return value;
 }
 
 /* Compress using simplified LZMA (uncompressed for now) */
 compression_result_t* lzma_compress(const uint8_t* input, uint32_t input_size, int level) {
     compression_result_t* result = compression_result_create();
     if (!result) return NULL;
 
     /* For this simplified version, we'll store uncompressed data with LZMA header
      * Format: LZMA props(5) + uncompressed_size(8) + data
      */
 
     uint32_t output_size = LZMA_HEADER_SIZE + input_size;
     result->data = (uint8_t*)malloc(output_size);
     if (!result->data) {
         result->error = COMPRESS_MEM_ERROR;
         strcpy(result->error_msg, "Memory allocation failed");
         return result;
     }
 
     uint8_t* out = result->data;
     uint32_t out_pos = 0;
 
     /* Write LZMA properties based on compression level */
     lzma_get_props(out, level);
     out_pos += LZMA_PROPS_SIZE;
 
     /* Write uncompressed size */
     write_le64(out + out_pos, input_size);
     out_pos += 8;
 
     /* Copy data (uncompressed) */
     memcpy(out + out_pos, input, input_size);
     out_pos += input_size;
 
     result->size = out_pos;
     result->error = COMPRESS_OK;
 
     /* Note: This is a placeholder. For real LZMA compression, integrate LZMA SDK */
     return result;
 }
 
 /* Decompress LZMA data */
 compression_result_t* lzma_decompress(const uint8_t* input, uint32_t input_size) {
     compression_result_t* result = compression_result_create();
     if (!result) return NULL;
 
     if (input_size < LZMA_HEADER_SIZE) {
         result->error = COMPRESS_DATA_ERROR;
         strcpy(result->error_msg, "Input too small for LZMA header");
         return result;
     }
 
     /* Read LZMA header */
     lzma_header_t header;
     memcpy(header.props, input, LZMA_PROPS_SIZE);
     header.uncompressed_size = read_le64(input + LZMA_PROPS_SIZE);
 
     /* Validate properties */
     uint8_t d = header.props[0];
     if (d >= (9 * 5 * 5)) {
         result->error = COMPRESS_DATA_ERROR;
         strcpy(result->error_msg, "Invalid LZMA properties");
         return result;
     }
 
     /* Decode properties */
     uint8_t lc = d % 9;
     d /= 9;
     uint8_t pb = d / 5;
     uint8_t lp = d % 5;
 
     /* Validate ranges */
     if (lc > 8 || lp > 4 || pb > 4) {
         result->error = COMPRESS_DATA_ERROR;
         strcpy(result->error_msg, "LZMA properties out of range");
         return result;
     }
 
     /* Check if uncompressed size is valid */
     if (header.uncompressed_size == (uint64_t)-1) {
         result->error = COMPRESS_ERROR;
         strcpy(result->error_msg, "Unknown uncompressed size");
         return result;
     }
 
     /* For simplified version, just copy data (assumes uncompressed) */
     uint32_t data_size = input_size - LZMA_HEADER_SIZE;
 
     if (data_size != header.uncompressed_size) {
         /* This is compressed data - need LZMA SDK */
         result->error = COMPRESS_ERROR;
         strcpy(result->error_msg, "Real LZMA compression not supported. Integrate LZMA SDK.");
         return result;
     }
 
     /* Allocate output buffer */
     result->data = (uint8_t*)malloc(header.uncompressed_size);
     if (!result->data) {
         result->error = COMPRESS_MEM_ERROR;
         strcpy(result->error_msg, "Memory allocation failed");
         return result;
     }
 
     /* Copy uncompressed data */
     memcpy(result->data, input + LZMA_HEADER_SIZE, header.uncompressed_size);
     result->size = header.uncompressed_size;
     result->error = COMPRESS_OK;
 
     return result;
 }
 
 /* Lua binding: Compress with LZMA */
 int lua_lzma_compress(lua_State* L) {
     size_t input_size;
     const uint8_t* input = (const uint8_t*)luaL_checklstring(L, 1, &input_size);
     int level = luaL_optinteger(L, 2, COMPRESS_LEVEL_DEFAULT);
 
     compression_result_t* result = lzma_compress(input, input_size, level);
 
     if (result && result->error == COMPRESS_OK) {
         lua_pushlstring(L, (const char*)result->data, result->size);
         compression_result_destroy(result);
         return 1;
     } else {
         lua_pushnil(L);
         lua_pushstring(L, result ? result->error_msg : "Compression failed");
         if (result) compression_result_destroy(result);
         return 2;
     }
 }
 
 /* Lua binding: Decompress LZMA */
 int lua_lzma_decompress(lua_State* L) {
     size_t input_size;
     const uint8_t* input = (const uint8_t*)luaL_checklstring(L, 1, &input_size);
 
     compression_result_t* result = lzma_decompress(input, input_size);
 
     if (result && result->error == COMPRESS_OK) {
         lua_pushlstring(L, (const char*)result->data, result->size);
         compression_result_destroy(result);
         return 1;
     } else {
         lua_pushnil(L);
         lua_pushstring(L, result ? result->error_msg : "Decompression failed");
         if (result) compression_result_destroy(result);
         return 2;
     }
 }
 
 /*
  * INTEGRATION GUIDE:
  *
  * To add full LZMA support, integrate LZMA SDK:
  *
  * 1. Download LZMA SDK from https://www.7-zip.org/sdk.html
  * 2. Add files to project: compression/LzmaDec.c, compression/LzmaEnc.c, compression/LzFind.c
  * 3. Include headers: LzmaDec.h, LzmaEnc.h
  *
  * 4. Replace lzma_compress() with:
  *    CLzmaEncProps props;
  *    LzmaEncProps_Init(&props);
  *    props.level = level;
  *    props.dictSize = 1 << 23;  // 8MB
  *
  *    size_t propsSize = LZMA_PROPS_SIZE;
  *    size_t destLen = input_size + input_size / 3 + 128;
  *    uint8_t* dest = malloc(destLen);
  *
  *    int res = LzmaEncode(dest + LZMA_PROPS_SIZE, &destLen,
  *                         input, input_size,
  *                         &props, dest, &propsSize,
  *                         0, NULL, &g_Alloc, &g_Alloc);
  *
  * 5. Replace lzma_decompress() with:
  *    ELzmaStatus status;
  *    size_t destLen = uncompressed_size;
  *    size_t srcLen = input_size - LZMA_HEADER_SIZE;
  *    uint8_t* dest = malloc(destLen);
  *
  *    int res = LzmaDecode(dest, &destLen,
  *                         input + LZMA_HEADER_SIZE, &srcLen,
  *                         props, LZMA_PROPS_SIZE,
  *                         LZMA_FINISH_ANY, &status,
  *                         &g_Alloc);
  *
  * Benefits of LZMA:
  * - Excellent compression ratio (often better than gzip/bzip2)
  * - Good decompression speed
  * - Used by 7-Zip, XZ Utils
  * - Dictionary size up to 4GB
  */