2013-03-29 00:51:45 +01:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdint.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include "../common.h"
|
|
|
|
#include "C/LzmaDec.h"
|
|
|
|
#include "C/LzmaEnc.h"
|
|
|
|
|
|
|
|
#define L (uint64_t)
|
|
|
|
|
|
|
|
static inline uint64_t get_64(const void *p)
|
|
|
|
{
|
|
|
|
const unsigned char *data = (const unsigned char *)p;
|
|
|
|
return (L data[0]) | (L data[1] << 8) | (L data[2] << 16) |
|
|
|
|
(L data[3] << 24) | (L data [4] << 32) | (L data[5] << 40) |
|
|
|
|
(L data[6] << 48) | (L data[7] << 56);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void put_64(void *p, uint64_t value)
|
|
|
|
{
|
|
|
|
unsigned char *data = (unsigned char *)p;
|
|
|
|
data[0] = value & 0xff;
|
|
|
|
data[1] = (value >> 8) & 0xff;
|
|
|
|
data[2] = (value >> 16) & 0xff;
|
|
|
|
data[3] = (value >> 24) & 0xff;
|
|
|
|
data[4] = (value >> 32) & 0xff;
|
|
|
|
data[5] = (value >> 40) & 0xff;
|
|
|
|
data[6] = (value >> 48) & 0xff;
|
|
|
|
data[7] = (value >> 56) & 0xff;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Memory Allocation API */
|
|
|
|
|
2015-03-04 00:55:03 +01:00
|
|
|
static void *SzAlloc(unused void *u, size_t size)
|
2013-03-29 00:51:45 +01:00
|
|
|
{
|
|
|
|
return malloc(size);
|
|
|
|
}
|
|
|
|
|
2015-03-04 00:55:03 +01:00
|
|
|
static void SzFree(unused void *u, void *address)
|
2013-03-29 00:51:45 +01:00
|
|
|
{
|
|
|
|
free(address);
|
|
|
|
}
|
|
|
|
|
2014-01-28 03:57:54 +01:00
|
|
|
static struct ISzAlloc LZMAalloc = { SzAlloc, SzFree };
|
2013-03-29 00:51:45 +01:00
|
|
|
|
|
|
|
/* Streaming API */
|
|
|
|
|
2014-01-28 03:57:54 +01:00
|
|
|
struct vector_t {
|
2013-03-29 00:51:45 +01:00
|
|
|
char *p;
|
|
|
|
size_t pos;
|
|
|
|
size_t size;
|
2014-01-28 03:57:54 +01:00
|
|
|
};
|
2013-03-29 00:51:45 +01:00
|
|
|
|
2014-01-28 03:57:54 +01:00
|
|
|
static struct vector_t instream, outstream;
|
2013-03-29 00:51:45 +01:00
|
|
|
|
2015-03-04 00:55:03 +01:00
|
|
|
static SRes Read(unused void *u, void *buf, size_t *size)
|
2013-03-29 00:51:45 +01:00
|
|
|
{
|
|
|
|
if ((instream.size - instream.pos) < *size)
|
|
|
|
*size = instream.size - instream.pos;
|
|
|
|
memcpy(buf, instream.p + instream.pos, *size);
|
|
|
|
instream.pos += *size;
|
|
|
|
return SZ_OK;
|
|
|
|
}
|
|
|
|
|
2015-03-04 00:55:03 +01:00
|
|
|
static size_t Write(unused void *u, const void *buf, size_t size)
|
2013-03-29 00:51:45 +01:00
|
|
|
{
|
|
|
|
if(outstream.size - outstream.pos < size)
|
|
|
|
size = outstream.size - outstream.pos;
|
|
|
|
memcpy(outstream.p + outstream.pos, buf, size);
|
|
|
|
outstream.pos += size;
|
|
|
|
return size;
|
|
|
|
}
|
|
|
|
|
2014-01-28 03:57:54 +01:00
|
|
|
static struct ISeqInStream is = { Read };
|
|
|
|
static struct ISeqOutStream os = { Write };
|
2013-03-29 00:51:45 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Compress a buffer with lzma
|
|
|
|
* Don't copy the result back if it is too large.
|
|
|
|
* @param in a pointer to the buffer
|
|
|
|
* @param in_len the length in bytes
|
|
|
|
* @param out a pointer to a buffer of at least size in_len
|
|
|
|
* @param out_len a pointer to the compressed length of in
|
|
|
|
*/
|
|
|
|
|
2014-02-21 08:38:49 +01:00
|
|
|
int do_lzma_compress(char *in, int in_len, char *out, int *out_len)
|
2013-03-29 00:51:45 +01:00
|
|
|
{
|
|
|
|
if (in_len == 0) {
|
|
|
|
ERROR("LZMA: Input length is zero.\n");
|
2014-02-21 08:38:49 +01:00
|
|
|
return -1;
|
2013-03-29 00:51:45 +01:00
|
|
|
}
|
|
|
|
|
2014-01-28 03:57:54 +01:00
|
|
|
struct CLzmaEncProps props;
|
2013-03-29 00:51:45 +01:00
|
|
|
LzmaEncProps_Init(&props);
|
|
|
|
props.dictSize = in_len;
|
|
|
|
props.pb = 0; /* PosStateBits, default: 2, range: 0..4 */
|
|
|
|
props.lp = 0; /* LiteralPosStateBits, default: 0, range: 0..4 */
|
|
|
|
props.lc = 1; /* LiteralContextBits, default: 3, range: 0..8 */
|
|
|
|
props.fb = 273; /* NumFastBytes */
|
|
|
|
props.mc = 0; /* MatchFinderCycles, default: 0 */
|
|
|
|
props.algo = 1; /* AlgorithmNo, apparently, 0 and 1 are valid values. 0 = fast mode */
|
|
|
|
props.numThreads = 1;
|
|
|
|
|
|
|
|
switch (props.algo) {
|
|
|
|
case 0: // quick: HC4
|
|
|
|
props.btMode = 0;
|
|
|
|
props.level = 1;
|
|
|
|
break;
|
|
|
|
case 1: // full: BT4
|
|
|
|
default:
|
|
|
|
props.level = 9;
|
|
|
|
props.btMode = 1;
|
|
|
|
props.numHashBytes = 4;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
CLzmaEncHandle p = LzmaEnc_Create(&LZMAalloc);
|
|
|
|
|
|
|
|
int res = LzmaEnc_SetProps(p, &props);
|
|
|
|
if (res != SZ_OK) {
|
|
|
|
ERROR("LZMA: LzmaEnc_SetProps failed.\n");
|
2014-02-21 08:38:49 +01:00
|
|
|
return -1;
|
2013-03-29 00:51:45 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
unsigned char propsEncoded[LZMA_PROPS_SIZE + 8];
|
|
|
|
size_t propsSize = sizeof propsEncoded;
|
|
|
|
res = LzmaEnc_WriteProperties(p, propsEncoded, &propsSize);
|
|
|
|
if (res != SZ_OK) {
|
|
|
|
ERROR("LZMA: LzmaEnc_WriteProperties failed.\n");
|
2014-02-21 08:38:49 +01:00
|
|
|
return -1;
|
2013-03-29 00:51:45 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
instream.p = in;
|
2013-04-08 20:20:55 +02:00
|
|
|
instream.pos = 0;
|
2013-03-29 00:51:45 +01:00
|
|
|
instream.size = in_len;
|
|
|
|
|
|
|
|
outstream.p = out;
|
2013-04-08 20:20:55 +02:00
|
|
|
outstream.pos = 0;
|
2013-03-29 00:51:45 +01:00
|
|
|
outstream.size = in_len;
|
|
|
|
|
|
|
|
put_64(propsEncoded + LZMA_PROPS_SIZE, in_len);
|
|
|
|
Write(&os, propsEncoded, LZMA_PROPS_SIZE+8);
|
|
|
|
|
|
|
|
res = LzmaEnc_Encode(p, &os, &is, 0, &LZMAalloc, &LZMAalloc);
|
|
|
|
if (res != SZ_OK) {
|
|
|
|
ERROR("LZMA: LzmaEnc_Encode failed %d.\n", res);
|
2014-02-21 08:38:49 +01:00
|
|
|
return -1;
|
2013-03-29 00:51:45 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
*out_len = outstream.pos;
|
2014-02-21 08:38:49 +01:00
|
|
|
return 0;
|
2013-03-29 00:51:45 +01:00
|
|
|
}
|
|
|
|
|
2014-02-21 08:38:49 +01:00
|
|
|
int do_lzma_uncompress(char *dst, int dst_len, char *src, int src_len)
|
2013-03-29 00:51:45 +01:00
|
|
|
{
|
|
|
|
if (src_len <= LZMA_PROPS_SIZE + 8) {
|
|
|
|
ERROR("LZMA: Input length is too small.\n");
|
2014-02-21 08:38:49 +01:00
|
|
|
return -1;
|
2013-03-29 00:51:45 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
uint64_t out_sizemax = get_64(&src[LZMA_PROPS_SIZE]);
|
|
|
|
|
|
|
|
if (out_sizemax > (size_t) dst_len) {
|
|
|
|
ERROR("Not copying %d bytes to %d-byte buffer!\n",
|
|
|
|
(unsigned int)out_sizemax, dst_len);
|
2014-02-21 08:38:49 +01:00
|
|
|
return -1;
|
2013-03-29 00:51:45 +01:00
|
|
|
}
|
|
|
|
|
2014-01-28 03:57:54 +01:00
|
|
|
enum ELzmaStatus status;
|
2013-03-29 00:51:45 +01:00
|
|
|
|
|
|
|
size_t destlen = out_sizemax;
|
|
|
|
size_t srclen = src_len - (LZMA_PROPS_SIZE + 8);
|
|
|
|
|
2014-01-27 05:55:01 +01:00
|
|
|
int res = LzmaDecode((uint8_t *) dst, &destlen,
|
|
|
|
(uint8_t *) &src[LZMA_PROPS_SIZE + 8], &srclen,
|
|
|
|
(uint8_t *) &src[0], LZMA_PROPS_SIZE,
|
2013-03-29 00:51:45 +01:00
|
|
|
LZMA_FINISH_END,
|
|
|
|
&status,
|
|
|
|
&LZMAalloc);
|
|
|
|
|
|
|
|
if (res != SZ_OK) {
|
|
|
|
ERROR("Error while decompressing.\n");
|
2014-02-21 08:38:49 +01:00
|
|
|
return -1;
|
2013-03-29 00:51:45 +01:00
|
|
|
}
|
2014-02-21 08:38:49 +01:00
|
|
|
|
|
|
|
return 0;
|
2013-03-29 00:51:45 +01:00
|
|
|
}
|