/* XzEnc.c -- Xz Encode | |
2009-06-04 : Igor Pavlov : Public domain */ | |
#include <stdlib.h> | |
#include <string.h> | |
#include "7zCrc.h" | |
#include "Alloc.h" | |
#include "Bra.h" | |
#include "CpuArch.h" | |
#ifdef USE_SUBBLOCK | |
#include "SbEnc.h" | |
#endif | |
#include "XzEnc.h" | |
static void *SzBigAlloc(void *p, size_t size) { p = p; return BigAlloc(size); } | |
static void SzBigFree(void *p, void *address) { p = p; BigFree(address); } | |
static ISzAlloc g_BigAlloc = { SzBigAlloc, SzBigFree }; | |
static void *SzAlloc(void *p, size_t size) { p = p; return MyAlloc(size); } | |
static void SzFree(void *p, void *address) { p = p; MyFree(address); } | |
static ISzAlloc g_Alloc = { SzAlloc, SzFree }; | |
#define XzBlock_ClearFlags(p) (p)->flags = 0; | |
#define XzBlock_SetNumFilters(p, n) (p)->flags |= ((n) - 1); | |
#define XzBlock_SetHasPackSize(p) (p)->flags |= XZ_BF_PACK_SIZE; | |
#define XzBlock_SetHasUnpackSize(p) (p)->flags |= XZ_BF_UNPACK_SIZE; | |
static SRes WriteBytes(ISeqOutStream *s, const void *buf, UInt32 size) | |
{ | |
return (s->Write(s, buf, size) == size) ? SZ_OK : SZ_ERROR_WRITE; | |
} | |
static SRes WriteBytesAndCrc(ISeqOutStream *s, const void *buf, UInt32 size, UInt32 *crc) | |
{ | |
*crc = CrcUpdate(*crc, buf, size); | |
return WriteBytes(s, buf, size); | |
} | |
SRes Xz_WriteHeader(CXzStreamFlags f, ISeqOutStream *s) | |
{ | |
UInt32 crc; | |
Byte header[XZ_STREAM_HEADER_SIZE]; | |
memcpy(header, XZ_SIG, XZ_SIG_SIZE); | |
header[XZ_SIG_SIZE] = (Byte)(f >> 8); | |
header[XZ_SIG_SIZE + 1] = (Byte)(f & 0xFF); | |
crc = CrcCalc(header + XZ_SIG_SIZE, XZ_STREAM_FLAGS_SIZE); | |
SetUi32(header + XZ_SIG_SIZE + XZ_STREAM_FLAGS_SIZE, crc); | |
return WriteBytes(s, header, XZ_STREAM_HEADER_SIZE); | |
} | |
SRes XzBlock_WriteHeader(const CXzBlock *p, ISeqOutStream *s) | |
{ | |
Byte header[XZ_BLOCK_HEADER_SIZE_MAX]; | |
unsigned pos = 1; | |
int numFilters, i; | |
header[pos++] = p->flags; | |
if (XzBlock_HasPackSize(p)) pos += Xz_WriteVarInt(header + pos, p->packSize); | |
if (XzBlock_HasUnpackSize(p)) pos += Xz_WriteVarInt(header + pos, p->unpackSize); | |
numFilters = XzBlock_GetNumFilters(p); | |
for (i = 0; i < numFilters; i++) | |
{ | |
const CXzFilter *f = &p->filters[i]; | |
pos += Xz_WriteVarInt(header + pos, f->id); | |
pos += Xz_WriteVarInt(header + pos, f->propsSize); | |
memcpy(header + pos, f->props, f->propsSize); | |
pos += f->propsSize; | |
} | |
while((pos & 3) != 0) | |
header[pos++] = 0; | |
header[0] = (Byte)(pos >> 2); | |
SetUi32(header + pos, CrcCalc(header, pos)); | |
return WriteBytes(s, header, pos + 4); | |
} | |
SRes Xz_WriteFooter(CXzStream *p, ISeqOutStream *s) | |
{ | |
Byte buf[32]; | |
UInt64 globalPos; | |
{ | |
UInt32 crc = CRC_INIT_VAL; | |
unsigned pos = 1 + Xz_WriteVarInt(buf + 1, p->numBlocks); | |
size_t i; | |
globalPos = pos; | |
buf[0] = 0; | |
RINOK(WriteBytesAndCrc(s, buf, pos, &crc)); | |
for (i = 0; i < p->numBlocks; i++) | |
{ | |
const CXzBlockSizes *block = &p->blocks[i]; | |
pos = Xz_WriteVarInt(buf, block->totalSize); | |
pos += Xz_WriteVarInt(buf + pos, block->unpackSize); | |
globalPos += pos; | |
RINOK(WriteBytesAndCrc(s, buf, pos, &crc)); | |
} | |
pos = ((unsigned)globalPos & 3); | |
if (pos != 0) | |
{ | |
buf[0] = buf[1] = buf[2] = 0; | |
RINOK(WriteBytesAndCrc(s, buf, 4 - pos, &crc)); | |
globalPos += 4 - pos; | |
} | |
{ | |
SetUi32(buf, CRC_GET_DIGEST(crc)); | |
RINOK(WriteBytes(s, buf, 4)); | |
globalPos += 4; | |
} | |
} | |
{ | |
UInt32 indexSize = (UInt32)((globalPos >> 2) - 1); | |
SetUi32(buf + 4, indexSize); | |
buf[8] = (Byte)(p->flags >> 8); | |
buf[9] = (Byte)(p->flags & 0xFF); | |
SetUi32(buf, CrcCalc(buf + 4, 6)); | |
memcpy(buf + 10, XZ_FOOTER_SIG, XZ_FOOTER_SIG_SIZE); | |
return WriteBytes(s, buf, 12); | |
} | |
} | |
SRes Xz_AddIndexRecord(CXzStream *p, UInt64 unpackSize, UInt64 totalSize, ISzAlloc *alloc) | |
{ | |
if (p->blocks == 0 || p->numBlocksAllocated == p->numBlocks) | |
{ | |
size_t num = (p->numBlocks + 1) * 2; | |
size_t newSize = sizeof(CXzBlockSizes) * num; | |
CXzBlockSizes *blocks; | |
if (newSize / sizeof(CXzBlockSizes) != num) | |
return SZ_ERROR_MEM; | |
blocks = alloc->Alloc(alloc, newSize); | |
if (blocks == 0) | |
return SZ_ERROR_MEM; | |
if (p->numBlocks != 0) | |
{ | |
memcpy(blocks, p->blocks, p->numBlocks * sizeof(CXzBlockSizes)); | |
Xz_Free(p, alloc); | |
} | |
p->blocks = blocks; | |
p->numBlocksAllocated = num; | |
} | |
{ | |
CXzBlockSizes *block = &p->blocks[p->numBlocks++]; | |
block->totalSize = totalSize; | |
block->unpackSize = unpackSize; | |
} | |
return SZ_OK; | |
} | |
/* ---------- CSeqCheckInStream ---------- */ | |
typedef struct | |
{ | |
ISeqInStream p; | |
ISeqInStream *realStream; | |
UInt64 processed; | |
CXzCheck check; | |
} CSeqCheckInStream; | |
void SeqCheckInStream_Init(CSeqCheckInStream *p, int mode) | |
{ | |
p->processed = 0; | |
XzCheck_Init(&p->check, mode); | |
} | |
void SeqCheckInStream_GetDigest(CSeqCheckInStream *p, Byte *digest) | |
{ | |
XzCheck_Final(&p->check, digest); | |
} | |
static SRes SeqCheckInStream_Read(void *pp, void *data, size_t *size) | |
{ | |
CSeqCheckInStream *p = (CSeqCheckInStream *)pp; | |
SRes res = p->realStream->Read(p->realStream, data, size); | |
XzCheck_Update(&p->check, data, *size); | |
p->processed += *size; | |
return res; | |
} | |
/* ---------- CSeqSizeOutStream ---------- */ | |
typedef struct | |
{ | |
ISeqOutStream p; | |
ISeqOutStream *realStream; | |
UInt64 processed; | |
} CSeqSizeOutStream; | |
static size_t MyWrite(void *pp, const void *data, size_t size) | |
{ | |
CSeqSizeOutStream *p = (CSeqSizeOutStream *)pp; | |
size = p->realStream->Write(p->realStream, data, size); | |
p->processed += size; | |
return size; | |
} | |
/* ---------- CSeqInFilter ---------- */ | |
/* | |
typedef struct _IFilter | |
{ | |
void *p; | |
void (*Free)(void *p, ISzAlloc *alloc); | |
SRes (*SetProps)(void *p, const Byte *props, size_t propSize, ISzAlloc *alloc); | |
void (*Init)(void *p); | |
size_t (*Filter)(void *p, Byte *data, SizeT destLen); | |
} IFilter; | |
#define FILT_BUF_SIZE (1 << 19) | |
typedef struct | |
{ | |
ISeqInStream p; | |
ISeqInStream *realStream; | |
UInt32 x86State; | |
UInt32 ip; | |
UInt64 processed; | |
CXzCheck check; | |
Byte buf[FILT_BUF_SIZE]; | |
UInt32 bufferPos; | |
UInt32 convertedPosBegin; | |
UInt32 convertedPosEnd; | |
IFilter *filter; | |
} CSeqInFilter; | |
static SRes SeqInFilter_Read(void *pp, void *data, size_t *size) | |
{ | |
CSeqInFilter *p = (CSeqInFilter *)pp; | |
size_t remSize = *size; | |
*size = 0; | |
while (remSize > 0) | |
{ | |
int i; | |
if (p->convertedPosBegin != p->convertedPosEnd) | |
{ | |
UInt32 sizeTemp = p->convertedPosEnd - p->convertedPosBegin; | |
if (remSize < sizeTemp) | |
sizeTemp = (UInt32)remSize; | |
memmove(data, p->buf + p->convertedPosBegin, sizeTemp); | |
p->convertedPosBegin += sizeTemp; | |
data = (void *)((Byte *)data + sizeTemp); | |
remSize -= sizeTemp; | |
*size += sizeTemp; | |
break; | |
} | |
for (i = 0; p->convertedPosEnd + i < p->bufferPos; i++) | |
p->buf[i] = p->buf[i + p->convertedPosEnd]; | |
p->bufferPos = i; | |
p->convertedPosBegin = p->convertedPosEnd = 0; | |
{ | |
size_t processedSizeTemp = FILT_BUF_SIZE - p->bufferPos; | |
RINOK(p->realStream->Read(p->realStream, p->buf + p->bufferPos, &processedSizeTemp)); | |
p->bufferPos = p->bufferPos + (UInt32)processedSizeTemp; | |
} | |
p->convertedPosEnd = (UInt32)p->filter->Filter(p->filter->p, p->buf, p->bufferPos); | |
if (p->convertedPosEnd == 0) | |
{ | |
if (p->bufferPos == 0) | |
break; | |
else | |
{ | |
p->convertedPosEnd = p->bufferPos; | |
continue; | |
} | |
} | |
if (p->convertedPosEnd > p->bufferPos) | |
{ | |
for (; p->bufferPos < p->convertedPosEnd; p->bufferPos++) | |
p->buf[p->bufferPos] = 0; | |
p->convertedPosEnd = (UInt32)p->filter->Filter(p->filter->p, p->buf, p->bufferPos); | |
} | |
} | |
return SZ_OK; | |
} | |
*/ | |
/* | |
typedef struct | |
{ | |
ISeqInStream p; | |
ISeqInStream *realStream; | |
CMixCoder mixCoder; | |
Byte buf[FILT_BUF_SIZE]; | |
UInt32 bufPos; | |
UInt32 bufSize; | |
} CMixCoderSeqInStream; | |
static SRes CMixCoderSeqInStream_Read(void *pp, void *data, size_t *size) | |
{ | |
CMixCoderSeqInStream *p = (CMixCoderSeqInStream *)pp; | |
SRes res = SZ_OK; | |
size_t remSize = *size; | |
*size = 0; | |
while (remSize > 0) | |
{ | |
if (p->bufPos == p->bufSize) | |
{ | |
size_t curSize; | |
p->bufPos = p->bufSize = 0; | |
if (*size != 0) | |
break; | |
curSize = FILT_BUF_SIZE; | |
RINOK(p->realStream->Read(p->realStream, p->buf, &curSize)); | |
p->bufSize = (UInt32)curSize; | |
} | |
{ | |
SizeT destLen = remSize; | |
SizeT srcLen = p->bufSize - p->bufPos; | |
res = MixCoder_Code(&p->mixCoder, data, &destLen, p->buf + p->bufPos, &srcLen, 0); | |
data = (void *)((Byte *)data + destLen); | |
remSize -= destLen; | |
*size += destLen; | |
p->bufPos += srcLen; | |
} | |
} | |
return res; | |
} | |
*/ | |
#ifdef USE_SUBBLOCK | |
typedef struct | |
{ | |
ISeqInStream p; | |
CSubblockEnc sb; | |
UInt64 processed; | |
} CSbEncInStream; | |
void SbEncInStream_Init(CSbEncInStream *p) | |
{ | |
p->processed = 0; | |
SubblockEnc_Init(&p->sb); | |
} | |
static SRes SbEncInStream_Read(void *pp, void *data, size_t *size) | |
{ | |
CSbEncInStream *p = (CSbEncInStream *)pp; | |
SRes res = SubblockEnc_Read(&p->sb, data, size); | |
p->processed += *size; | |
return res; | |
} | |
#endif | |
typedef struct | |
{ | |
/* CMixCoderSeqInStream inStream; */ | |
CLzma2EncHandle lzma2; | |
#ifdef USE_SUBBLOCK | |
CSbEncInStream sb; | |
#endif | |
ISzAlloc *alloc; | |
ISzAlloc *bigAlloc; | |
} CLzma2WithFilters; | |
static void Lzma2WithFilters_Construct(CLzma2WithFilters *p, ISzAlloc *alloc, ISzAlloc *bigAlloc) | |
{ | |
p->alloc = alloc; | |
p->bigAlloc = bigAlloc; | |
p->lzma2 = NULL; | |
#ifdef USE_SUBBLOCK | |
p->sb.p.Read = SbEncInStream_Read; | |
SubblockEnc_Construct(&p->sb.sb, p->alloc); | |
#endif | |
} | |
static SRes Lzma2WithFilters_Create(CLzma2WithFilters *p) | |
{ | |
p->lzma2 = Lzma2Enc_Create(p->alloc, p->bigAlloc); | |
if (p->lzma2 == 0) | |
return SZ_ERROR_MEM; | |
return SZ_OK; | |
} | |
static void Lzma2WithFilters_Free(CLzma2WithFilters *p) | |
{ | |
#ifdef USE_SUBBLOCK | |
SubblockEnc_Free(&p->sb.sb); | |
#endif | |
if (p->lzma2) | |
{ | |
Lzma2Enc_Destroy(p->lzma2); | |
p->lzma2 = NULL; | |
} | |
} | |
static SRes Xz_Compress(CXzStream *xz, | |
CLzma2WithFilters *lzmaf, | |
ISeqOutStream *outStream, | |
ISeqInStream *inStream, | |
const CLzma2EncProps *lzma2Props, | |
Bool useSubblock, | |
ICompressProgress *progress) | |
{ | |
xz->flags = XZ_CHECK_CRC32; | |
RINOK(Lzma2Enc_SetProps(lzmaf->lzma2, lzma2Props)); | |
RINOK(Xz_WriteHeader(xz->flags, outStream)); | |
{ | |
CSeqCheckInStream checkInStream; | |
CSeqSizeOutStream seqSizeOutStream; | |
CXzBlock block; | |
int filterIndex = 0; | |
XzBlock_ClearFlags(&block); | |
XzBlock_SetNumFilters(&block, 1 + (useSubblock ? 1 : 0)); | |
if (useSubblock) | |
{ | |
CXzFilter *f = &block.filters[filterIndex++]; | |
f->id = XZ_ID_Subblock; | |
f->propsSize = 0; | |
} | |
{ | |
CXzFilter *f = &block.filters[filterIndex++]; | |
f->id = XZ_ID_LZMA2; | |
f->propsSize = 1; | |
f->props[0] = Lzma2Enc_WriteProperties(lzmaf->lzma2); | |
} | |
seqSizeOutStream.p.Write = MyWrite; | |
seqSizeOutStream.realStream = outStream; | |
seqSizeOutStream.processed = 0; | |
RINOK(XzBlock_WriteHeader(&block, &seqSizeOutStream.p)); | |
checkInStream.p.Read = SeqCheckInStream_Read; | |
checkInStream.realStream = inStream; | |
SeqCheckInStream_Init(&checkInStream, XzFlags_GetCheckType(xz->flags)); | |
#ifdef USE_SUBBLOCK | |
if (useSubblock) | |
{ | |
lzmaf->sb.sb.inStream = &checkInStream.p; | |
SubblockEnc_Init(&lzmaf->sb.sb); | |
} | |
#endif | |
{ | |
UInt64 packPos = seqSizeOutStream.processed; | |
SRes res = Lzma2Enc_Encode(lzmaf->lzma2, &seqSizeOutStream.p, | |
#ifdef USE_SUBBLOCK | |
useSubblock ? &lzmaf->sb.p: | |
#endif | |
&checkInStream.p, | |
progress); | |
RINOK(res); | |
block.unpackSize = checkInStream.processed; | |
block.packSize = seqSizeOutStream.processed - packPos; | |
} | |
{ | |
unsigned padSize = 0; | |
Byte buf[128]; | |
while((((unsigned)block.packSize + padSize) & 3) != 0) | |
buf[padSize++] = 0; | |
SeqCheckInStream_GetDigest(&checkInStream, buf + padSize); | |
RINOK(WriteBytes(&seqSizeOutStream.p, buf, padSize + XzFlags_GetCheckSize(xz->flags))); | |
RINOK(Xz_AddIndexRecord(xz, block.unpackSize, seqSizeOutStream.processed - padSize, &g_Alloc)); | |
} | |
} | |
return Xz_WriteFooter(xz, outStream); | |
} | |
SRes Xz_Encode(ISeqOutStream *outStream, ISeqInStream *inStream, | |
const CLzma2EncProps *lzma2Props, Bool useSubblock, | |
ICompressProgress *progress) | |
{ | |
SRes res; | |
CXzStream xz; | |
CLzma2WithFilters lzmaf; | |
Xz_Construct(&xz); | |
Lzma2WithFilters_Construct(&lzmaf, &g_Alloc, &g_BigAlloc); | |
res = Lzma2WithFilters_Create(&lzmaf); | |
if (res == SZ_OK) | |
res = Xz_Compress(&xz, &lzmaf, outStream, inStream, | |
lzma2Props, useSubblock, progress); | |
Lzma2WithFilters_Free(&lzmaf); | |
Xz_Free(&xz, &g_Alloc); | |
return res; | |
} | |
SRes Xz_EncodeEmpty(ISeqOutStream *outStream) | |
{ | |
SRes res; | |
CXzStream xz; | |
Xz_Construct(&xz); | |
res = Xz_WriteHeader(xz.flags, outStream); | |
if (res == SZ_OK) | |
res = Xz_WriteFooter(&xz, outStream); | |
Xz_Free(&xz, &g_Alloc); | |
return res; | |
} |