Source code
Revision control
Copy as Markdown
Other Tools
/* Lzma2Enc.c -- LZMA2 Encoder↩
2018-04-27 : Igor Pavlov : Public domain */↩
↩
#include "Precomp.h"↩
↩
#include <string.h>↩
↩
/* #define _7ZIP_ST */↩
↩
#include "Lzma2Enc.h"↩
↩
#ifndef _7ZIP_ST↩
#include "MtCoder.h"↩
#else↩
#define MTCODER__THREADS_MAX 1↩
#endif↩
↩
#define LZMA2_CONTROL_LZMA (1 << 7)↩
#define LZMA2_CONTROL_COPY_NO_RESET 2↩
#define LZMA2_CONTROL_COPY_RESET_DIC 1↩
#define LZMA2_CONTROL_EOF 0↩
↩
#define LZMA2_LCLP_MAX 4↩
↩
#define LZMA2_DIC_SIZE_FROM_PROP(p) (((UInt32)2 | ((p) & 1)) << ((p) / 2 + 11))↩
↩
#define LZMA2_PACK_SIZE_MAX (1 << 16)↩
#define LZMA2_COPY_CHUNK_SIZE LZMA2_PACK_SIZE_MAX↩
#define LZMA2_UNPACK_SIZE_MAX (1 << 21)↩
#define LZMA2_KEEP_WINDOW_SIZE LZMA2_UNPACK_SIZE_MAX↩
↩
#define LZMA2_CHUNK_SIZE_COMPRESSED_MAX ((1 << 16) + 16)↩
↩
↩
#define PRF(x) /* x */↩
↩
↩
/* ---------- CLimitedSeqInStream ---------- */↩
↩
typedef struct↩
{↩
ISeqInStream vt;↩
ISeqInStream *realStream;↩
UInt64 limit;↩
UInt64 processed;↩
int finished;↩
} CLimitedSeqInStream;↩
↩
static void LimitedSeqInStream_Init(CLimitedSeqInStream *p)↩
{↩
p->limit = (UInt64)(Int64)-1;↩
p->processed = 0;↩
p->finished = 0;↩
}↩
↩
static SRes LimitedSeqInStream_Read(const ISeqInStream *pp, void *data, size_t *size)↩
{↩
CLimitedSeqInStream *p = CONTAINER_FROM_VTBL(pp, CLimitedSeqInStream, vt);↩
size_t size2 = *size;↩
SRes res = SZ_OK;↩
↩
if (p->limit != (UInt64)(Int64)-1)↩
{↩
UInt64 rem = p->limit - p->processed;↩
if (size2 > rem)↩
size2 = (size_t)rem;↩
}↩
if (size2 != 0)↩
{↩
res = ISeqInStream_Read(p->realStream, data, &size2);↩
p->finished = (size2 == 0 ? 1 : 0);↩
p->processed += size2;↩
}↩
*size = size2;↩
return res;↩
}↩
↩
↩
/* ---------- CLzma2EncInt ---------- */↩
↩
typedef struct↩
{↩
CLzmaEncHandle enc;↩
Byte propsAreSet;↩
Byte propsByte;↩
Byte needInitState;↩
Byte needInitProp;↩
UInt64 srcPos;↩
} CLzma2EncInt;↩
↩
↩
static SRes Lzma2EncInt_InitStream(CLzma2EncInt *p, const CLzma2EncProps *props)↩
{↩
if (!p->propsAreSet)↩
{↩
SizeT propsSize = LZMA_PROPS_SIZE;↩
Byte propsEncoded[LZMA_PROPS_SIZE];↩
RINOK(LzmaEnc_SetProps(p->enc, &props->lzmaProps));↩
RINOK(LzmaEnc_WriteProperties(p->enc, propsEncoded, &propsSize));↩
p->propsByte = propsEncoded[0];↩
p->propsAreSet = True;↩
}↩
return SZ_OK;↩
}↩
↩
static void Lzma2EncInt_InitBlock(CLzma2EncInt *p)↩
{↩
p->srcPos = 0;↩
p->needInitState = True;↩
p->needInitProp = True;↩
}↩
↩
↩
SRes LzmaEnc_PrepareForLzma2(CLzmaEncHandle pp, ISeqInStream *inStream, UInt32 keepWindowSize,↩
ISzAllocPtr alloc, ISzAllocPtr allocBig);↩
SRes LzmaEnc_MemPrepare(CLzmaEncHandle pp, const Byte *src, SizeT srcLen,↩
UInt32 keepWindowSize, ISzAllocPtr alloc, ISzAllocPtr allocBig);↩
SRes LzmaEnc_CodeOneMemBlock(CLzmaEncHandle pp, Bool reInit,↩
Byte *dest, size_t *destLen, UInt32 desiredPackSize, UInt32 *unpackSize);↩
const Byte *LzmaEnc_GetCurBuf(CLzmaEncHandle pp);↩
void LzmaEnc_Finish(CLzmaEncHandle pp);↩
void LzmaEnc_SaveState(CLzmaEncHandle pp);↩
void LzmaEnc_RestoreState(CLzmaEncHandle pp);↩
↩
/*↩
UInt32 LzmaEnc_GetNumAvailableBytes(CLzmaEncHandle pp);↩
*/↩
↩
static SRes Lzma2EncInt_EncodeSubblock(CLzma2EncInt *p, Byte *outBuf,↩
size_t *packSizeRes, ISeqOutStream *outStream)↩
{↩
size_t packSizeLimit = *packSizeRes;↩
size_t packSize = packSizeLimit;↩
UInt32 unpackSize = LZMA2_UNPACK_SIZE_MAX;↩
unsigned lzHeaderSize = 5 + (p->needInitProp ? 1 : 0);↩
Bool useCopyBlock;↩
SRes res;↩
↩
*packSizeRes = 0;↩
if (packSize < lzHeaderSize)↩
return SZ_ERROR_OUTPUT_EOF;↩
packSize -= lzHeaderSize;↩
↩
LzmaEnc_SaveState(p->enc);↩
res = LzmaEnc_CodeOneMemBlock(p->enc, p->needInitState,↩
outBuf + lzHeaderSize, &packSize, LZMA2_PACK_SIZE_MAX, &unpackSize);↩
↩
PRF(printf("\npackSize = %7d unpackSize = %7d ", packSize, unpackSize));↩
↩
if (unpackSize == 0)↩
return res;↩
↩
if (res == SZ_OK)↩
useCopyBlock = (packSize + 2 >= unpackSize || packSize > (1 << 16));↩
else↩
{↩
if (res != SZ_ERROR_OUTPUT_EOF)↩
return res;↩
res = SZ_OK;↩
useCopyBlock = True;↩
}↩
↩
if (useCopyBlock)↩
{↩
size_t destPos = 0;↩
PRF(printf("################# COPY "));↩
↩
while (unpackSize > 0)↩
{↩
UInt32 u = (unpackSize < LZMA2_COPY_CHUNK_SIZE) ? unpackSize : LZMA2_COPY_CHUNK_SIZE;↩
if (packSizeLimit - destPos < u + 3)↩
return SZ_ERROR_OUTPUT_EOF;↩
outBuf[destPos++] = (Byte)(p->srcPos == 0 ? LZMA2_CONTROL_COPY_RESET_DIC : LZMA2_CONTROL_COPY_NO_RESET);↩
outBuf[destPos++] = (Byte)((u - 1) >> 8);↩
outBuf[destPos++] = (Byte)(u - 1);↩
memcpy(outBuf + destPos, LzmaEnc_GetCurBuf(p->enc) - unpackSize, u);↩
unpackSize -= u;↩
destPos += u;↩
p->srcPos += u;↩
↩
if (outStream)↩
{↩
*packSizeRes += destPos;↩
if (ISeqOutStream_Write(outStream, outBuf, destPos) != destPos)↩
return SZ_ERROR_WRITE;↩
destPos = 0;↩
}↩
else↩
*packSizeRes = destPos;↩
/* needInitState = True; */↩
}↩
↩
LzmaEnc_RestoreState(p->enc);↩
return SZ_OK;↩
}↩
↩
{↩
size_t destPos = 0;↩
UInt32 u = unpackSize - 1;↩
UInt32 pm = (UInt32)(packSize - 1);↩
unsigned mode = (p->srcPos == 0) ? 3 : (p->needInitState ? (p->needInitProp ? 2 : 1) : 0);↩
↩
PRF(printf(" "));↩
↩
outBuf[destPos++] = (Byte)(LZMA2_CONTROL_LZMA | (mode << 5) | ((u >> 16) & 0x1F));↩
outBuf[destPos++] = (Byte)(u >> 8);↩
outBuf[destPos++] = (Byte)u;↩
outBuf[destPos++] = (Byte)(pm >> 8);↩
outBuf[destPos++] = (Byte)pm;↩
↩
if (p->needInitProp)↩
outBuf[destPos++] = p->propsByte;↩
↩
p->needInitProp = False;↩
p->needInitState = False;↩
destPos += packSize;↩
p->srcPos += unpackSize;↩
↩
if (outStream)↩
if (ISeqOutStream_Write(outStream, outBuf, destPos) != destPos)↩
return SZ_ERROR_WRITE;↩
↩
*packSizeRes = destPos;↩
return SZ_OK;↩
}↩
}↩
↩
↩
/* ---------- Lzma2 Props ---------- */↩
↩
void Lzma2EncProps_Init(CLzma2EncProps *p)↩
{↩
LzmaEncProps_Init(&p->lzmaProps);↩
p->blockSize = LZMA2_ENC_PROPS__BLOCK_SIZE__AUTO;↩
p->numBlockThreads_Reduced = -1;↩
p->numBlockThreads_Max = -1;↩
p->numTotalThreads = -1;↩
}↩
↩
void Lzma2EncProps_Normalize(CLzma2EncProps *p)↩
{↩
UInt64 fileSize;↩
int t1, t1n, t2, t2r, t3;↩
{↩
CLzmaEncProps lzmaProps = p->lzmaProps;↩
LzmaEncProps_Normalize(&lzmaProps);↩
t1n = lzmaProps.numThreads;↩
}↩
↩
t1 = p->lzmaProps.numThreads;↩
t2 = p->numBlockThreads_Max;↩
t3 = p->numTotalThreads;↩
↩
if (t2 > MTCODER__THREADS_MAX)↩
t2 = MTCODER__THREADS_MAX;↩
↩
if (t3 <= 0)↩
{↩
if (t2 <= 0)↩
t2 = 1;↩
t3 = t1n * t2;↩
}↩
else if (t2 <= 0)↩
{↩
t2 = t3 / t1n;↩
if (t2 == 0)↩
{↩
t1 = 1;↩
t2 = t3;↩
}↩
if (t2 > MTCODER__THREADS_MAX)↩
t2 = MTCODER__THREADS_MAX;↩
}↩
else if (t1 <= 0)↩
{↩
t1 = t3 / t2;↩
if (t1 == 0)↩
t1 = 1;↩
}↩
else↩
t3 = t1n * t2;↩
↩
p->lzmaProps.numThreads = t1;↩
↩
t2r = t2;↩
↩
fileSize = p->lzmaProps.reduceSize;↩
↩
if ( p->blockSize != LZMA2_ENC_PROPS__BLOCK_SIZE__SOLID↩
&& p->blockSize != LZMA2_ENC_PROPS__BLOCK_SIZE__AUTO↩
&& (p->blockSize < fileSize || fileSize == (UInt64)(Int64)-1))↩
p->lzmaProps.reduceSize = p->blockSize;↩
↩
LzmaEncProps_Normalize(&p->lzmaProps);↩
↩
p->lzmaProps.reduceSize = fileSize;↩
↩
t1 = p->lzmaProps.numThreads;↩
↩
if (p->blockSize == LZMA2_ENC_PROPS__BLOCK_SIZE__SOLID)↩
{↩
t2r = t2 = 1;↩
t3 = t1;↩
}↩
else if (p->blockSize == LZMA2_ENC_PROPS__BLOCK_SIZE__AUTO && t2 <= 1)↩
{↩
/* if there is no block multi-threading, we use SOLID block */↩
p->blockSize = LZMA2_ENC_PROPS__BLOCK_SIZE__SOLID;↩
}↩
else↩
{↩
if (p->blockSize == LZMA2_ENC_PROPS__BLOCK_SIZE__AUTO)↩
{↩
const UInt32 kMinSize = (UInt32)1 << 20;↩
const UInt32 kMaxSize = (UInt32)1 << 28;↩
const UInt32 dictSize = p->lzmaProps.dictSize;↩
UInt64 blockSize = (UInt64)dictSize << 2;↩
if (blockSize < kMinSize) blockSize = kMinSize;↩
if (blockSize > kMaxSize) blockSize = kMaxSize;↩
if (blockSize < dictSize) blockSize = dictSize;↩
blockSize += (kMinSize - 1);↩
blockSize &= ~(UInt64)(kMinSize - 1);↩
p->blockSize = blockSize;↩
}↩
↩
if (t2 > 1 && fileSize != (UInt64)(Int64)-1)↩
{↩
UInt64 numBlocks = fileSize / p->blockSize;↩
if (numBlocks * p->blockSize != fileSize)↩
numBlocks++;↩
if (numBlocks < (unsigned)t2)↩
{↩
t2r = (unsigned)numBlocks;↩
if (t2r == 0)↩
t2r = 1;↩
t3 = t1 * t2r;↩
}↩
}↩
}↩
↩
p->numBlockThreads_Max = t2;↩
p->numBlockThreads_Reduced = t2r;↩
p->numTotalThreads = t3;↩
}↩
↩
↩
static SRes Progress(ICompressProgress *p, UInt64 inSize, UInt64 outSize)↩
{↩
return (p && ICompressProgress_Progress(p, inSize, outSize) != SZ_OK) ? SZ_ERROR_PROGRESS : SZ_OK;↩
}↩
↩
↩
/* ---------- Lzma2 ---------- */↩
↩
typedef struct↩
{↩
Byte propEncoded;↩
CLzma2EncProps props;↩
UInt64 expectedDataSize;↩
↩
Byte *tempBufLzma;↩
↩
ISzAllocPtr alloc;↩
ISzAllocPtr allocBig;↩
↩
CLzma2EncInt coders[MTCODER__THREADS_MAX];↩
↩
#ifndef _7ZIP_ST↩
↩
ISeqOutStream *outStream;↩
Byte *outBuf;↩
size_t outBuf_Rem; /* remainder in outBuf */↩
↩
size_t outBufSize; /* size of allocated outBufs[i] */↩
size_t outBufsDataSizes[MTCODER__BLOCKS_MAX];↩
Bool mtCoder_WasConstructed;↩
CMtCoder mtCoder;↩
Byte *outBufs[MTCODER__BLOCKS_MAX];↩
↩
#endif↩
↩
} CLzma2Enc;↩
↩
↩
↩
CLzma2EncHandle Lzma2Enc_Create(ISzAllocPtr alloc, ISzAllocPtr allocBig)↩
{↩
CLzma2Enc *p = (CLzma2Enc *)ISzAlloc_Alloc(alloc, sizeof(CLzma2Enc));↩
if (!p)↩
return NULL;↩
Lzma2EncProps_Init(&p->props);↩
Lzma2EncProps_Normalize(&p->props);↩
p->expectedDataSize = (UInt64)(Int64)-1;↩
p->tempBufLzma = NULL;↩
p->alloc = alloc;↩
p->allocBig = allocBig;↩
{↩
unsigned i;↩
for (i = 0; i < MTCODER__THREADS_MAX; i++)↩
p->coders[i].enc = NULL;↩
}↩
↩
#ifndef _7ZIP_ST↩
p->mtCoder_WasConstructed = False;↩
{↩
unsigned i;↩
for (i = 0; i < MTCODER__BLOCKS_MAX; i++)↩
p->outBufs[i] = NULL;↩
p->outBufSize = 0;↩
}↩
#endif↩
↩
return p;↩
}↩
↩
↩
#ifndef _7ZIP_ST↩
↩
static void Lzma2Enc_FreeOutBufs(CLzma2Enc *p)↩
{↩
unsigned i;↩
for (i = 0; i < MTCODER__BLOCKS_MAX; i++)↩
if (p->outBufs[i])↩
{↩
ISzAlloc_Free(p->alloc, p->outBufs[i]);↩
p->outBufs[i] = NULL;↩
}↩
p->outBufSize = 0;↩
}↩
↩
#endif↩
↩
↩
void Lzma2Enc_Destroy(CLzma2EncHandle pp)↩
{↩
CLzma2Enc *p = (CLzma2Enc *)pp;↩
unsigned i;↩
for (i = 0; i < MTCODER__THREADS_MAX; i++)↩
{↩
CLzma2EncInt *t = &p->coders[i];↩
if (t->enc)↩
{↩
LzmaEnc_Destroy(t->enc, p->alloc, p->allocBig);↩
t->enc = NULL;↩
}↩
}↩
↩
↩
#ifndef _7ZIP_ST↩
if (p->mtCoder_WasConstructed)↩
{↩
MtCoder_Destruct(&p->mtCoder);↩
p->mtCoder_WasConstructed = False;↩
}↩
Lzma2Enc_FreeOutBufs(p);↩
#endif↩
↩
ISzAlloc_Free(p->alloc, p->tempBufLzma);↩
p->tempBufLzma = NULL;↩
↩
ISzAlloc_Free(p->alloc, pp);↩
}↩
↩
↩
SRes Lzma2Enc_SetProps(CLzma2EncHandle pp, const CLzma2EncProps *props)↩
{↩
CLzma2Enc *p = (CLzma2Enc *)pp;↩
CLzmaEncProps lzmaProps = props->lzmaProps;↩
LzmaEncProps_Normalize(&lzmaProps);↩
if (lzmaProps.lc + lzmaProps.lp > LZMA2_LCLP_MAX)↩
return SZ_ERROR_PARAM;↩
p->props = *props;↩
Lzma2EncProps_Normalize(&p->props);↩
return SZ_OK;↩
}↩
↩
↩
void Lzma2Enc_SetDataSize(CLzmaEncHandle pp, UInt64 expectedDataSiize)↩
{↩
CLzma2Enc *p = (CLzma2Enc *)pp;↩
p->expectedDataSize = expectedDataSiize;↩
}↩
↩
↩
Byte Lzma2Enc_WriteProperties(CLzma2EncHandle pp)↩
{↩
CLzma2Enc *p = (CLzma2Enc *)pp;↩
unsigned i;↩
UInt32 dicSize = LzmaEncProps_GetDictSize(&p->props.lzmaProps);↩
for (i = 0; i < 40; i++)↩
if (dicSize <= LZMA2_DIC_SIZE_FROM_PROP(i))↩
break;↩
return (Byte)i;↩
}↩
↩
↩
static SRes Lzma2Enc_EncodeMt1(↩
CLzma2Enc *me,↩
CLzma2EncInt *p,↩
ISeqOutStream *outStream,↩
Byte *outBuf, size_t *outBufSize,↩
ISeqInStream *inStream,↩
const Byte *inData, size_t inDataSize,↩
int finished,↩
ICompressProgress *progress)↩
{↩
UInt64 unpackTotal = 0;↩
UInt64 packTotal = 0;↩
size_t outLim = 0;↩
CLimitedSeqInStream limitedInStream;↩
↩
if (outBuf)↩
{↩
outLim = *outBufSize;↩
*outBufSize = 0;↩
}↩
↩
if (!p->enc)↩
{↩
p->propsAreSet = False;↩
p->enc = LzmaEnc_Create(me->alloc);↩
if (!p->enc)↩
return SZ_ERROR_MEM;↩
}↩
↩
limitedInStream.realStream = inStream;↩
if (inStream)↩
{↩
limitedInStream.vt.Read = LimitedSeqInStream_Read;↩
}↩
↩
if (!outBuf)↩
{↩
// outStream version works only in one thread. So we use CLzma2Enc::tempBufLzma↩
if (!me->tempBufLzma)↩
{↩
me->tempBufLzma = (Byte *)ISzAlloc_Alloc(me->alloc, LZMA2_CHUNK_SIZE_COMPRESSED_MAX);↩
if (!me->tempBufLzma)↩
return SZ_ERROR_MEM;↩
}↩
}↩
↩
RINOK(Lzma2EncInt_InitStream(p, &me->props));↩
↩
for (;;)↩
{↩
SRes res = SZ_OK;↩
size_t inSizeCur = 0;↩
↩
Lzma2EncInt_InitBlock(p);↩
↩
LimitedSeqInStream_Init(&limitedInStream);↩
limitedInStream.limit = me->props.blockSize;↩
↩
if (inStream)↩
{↩
UInt64 expected = (UInt64)(Int64)-1;↩
// inStream version works only in one thread. So we use CLzma2Enc::expectedDataSize↩
if (me->expectedDataSize != (UInt64)(Int64)-1↩
&& me->expectedDataSize >= unpackTotal)↩
expected = me->expectedDataSize - unpackTotal;↩
if (me->props.blockSize != LZMA2_ENC_PROPS__BLOCK_SIZE__SOLID↩
&& expected > me->props.blockSize)↩
expected = (size_t)me->props.blockSize;↩
↩
LzmaEnc_SetDataSize(p->enc, expected);↩
↩
RINOK(LzmaEnc_PrepareForLzma2(p->enc,↩
&limitedInStream.vt,↩
LZMA2_KEEP_WINDOW_SIZE,↩
me->alloc,↩
me->allocBig));↩
}↩
else↩
{↩
inSizeCur = inDataSize - (size_t)unpackTotal;↩
if (me->props.blockSize != LZMA2_ENC_PROPS__BLOCK_SIZE__SOLID↩
&& inSizeCur > me->props.blockSize)↩
inSizeCur = (size_t)me->props.blockSize;↩
↩
// LzmaEnc_SetDataSize(p->enc, inSizeCur);↩
↩
RINOK(LzmaEnc_MemPrepare(p->enc,↩
inData + (size_t)unpackTotal, inSizeCur,↩
LZMA2_KEEP_WINDOW_SIZE,↩
me->alloc,↩
me->allocBig));↩
}↩
↩
for (;;)↩
{↩
size_t packSize = LZMA2_CHUNK_SIZE_COMPRESSED_MAX;↩
if (outBuf)↩
packSize = outLim - (size_t)packTotal;↩
↩
res = Lzma2EncInt_EncodeSubblock(p,↩
outBuf ? outBuf + (size_t)packTotal : me->tempBufLzma, &packSize,↩
outBuf ? NULL : outStream);↩
↩
if (res != SZ_OK)↩
break;↩
↩
packTotal += packSize;↩
if (outBuf)↩
*outBufSize = (size_t)packTotal;↩
↩
res = Progress(progress, unpackTotal + p->srcPos, packTotal);↩
if (res != SZ_OK)↩
break;↩
↩
/*↩
if (LzmaEnc_GetNumAvailableBytes(p->enc) == 0)↩
break;↩
*/↩
↩
if (packSize == 0)↩
break;↩
}↩
↩
LzmaEnc_Finish(p->enc);↩
↩
unpackTotal += p->srcPos;↩
↩
RINOK(res);↩
↩
if (p->srcPos != (inStream ? limitedInStream.processed : inSizeCur))↩
return SZ_ERROR_FAIL;↩
↩
if (inStream ? limitedInStream.finished : (unpackTotal == inDataSize))↩
{↩
if (finished)↩
{↩
if (outBuf)↩
{↩
size_t destPos = *outBufSize;↩
if (destPos >= outLim)↩
return SZ_ERROR_OUTPUT_EOF;↩
outBuf[destPos] = 0;↩
*outBufSize = destPos + 1;↩
}↩
else↩
{↩
Byte b = 0;↩
if (ISeqOutStream_Write(outStream, &b, 1) != 1)↩
return SZ_ERROR_WRITE;↩
}↩
}↩
return SZ_OK;↩
}↩
}↩
}↩
↩
↩
↩
#ifndef _7ZIP_ST↩
↩
static SRes Lzma2Enc_MtCallback_Code(void *pp, unsigned coderIndex, unsigned outBufIndex,↩
const Byte *src, size_t srcSize, int finished)↩
{↩
CLzma2Enc *me = (CLzma2Enc *)pp;↩
size_t destSize = me->outBufSize;↩
SRes res;↩
CMtProgressThunk progressThunk;↩
↩
Byte *dest = me->outBufs[outBufIndex];↩
↩
me->outBufsDataSizes[outBufIndex] = 0;↩
↩
if (!dest)↩
{↩
dest = (Byte *)ISzAlloc_Alloc(me->alloc, me->outBufSize);↩
if (!dest)↩
return SZ_ERROR_MEM;↩
me->outBufs[outBufIndex] = dest;↩
}↩
↩
MtProgressThunk_CreateVTable(&progressThunk);↩
progressThunk.mtProgress = &me->mtCoder.mtProgress;↩
progressThunk.inSize = 0;↩
progressThunk.outSize = 0;↩
↩
res = Lzma2Enc_EncodeMt1(me,↩
&me->coders[coderIndex],↩
NULL, dest, &destSize,↩
NULL, src, srcSize,↩
finished,↩
&progressThunk.vt);↩
↩
me->outBufsDataSizes[outBufIndex] = destSize;↩
↩
return res;↩
}↩
↩
↩
static SRes Lzma2Enc_MtCallback_Write(void *pp, unsigned outBufIndex)↩
{↩
CLzma2Enc *me = (CLzma2Enc *)pp;↩
size_t size = me->outBufsDataSizes[outBufIndex];↩
const Byte *data = me->outBufs[outBufIndex];↩
↩
if (me->outStream)↩
return ISeqOutStream_Write(me->outStream, data, size) == size ? SZ_OK : SZ_ERROR_WRITE;↩
↩
if (size > me->outBuf_Rem)↩
return SZ_ERROR_OUTPUT_EOF;↩
memcpy(me->outBuf, data, size);↩
me->outBuf_Rem -= size;↩
me->outBuf += size;↩
return SZ_OK;↩
}↩
↩
#endif↩
↩
↩
↩
SRes Lzma2Enc_Encode2(CLzma2EncHandle pp,↩
ISeqOutStream *outStream,↩
Byte *outBuf, size_t *outBufSize,↩
ISeqInStream *inStream,↩
const Byte *inData, size_t inDataSize,↩
ICompressProgress *progress)↩
{↩
CLzma2Enc *p = (CLzma2Enc *)pp;↩
↩
if (inStream && inData)↩
return SZ_ERROR_PARAM;↩
↩
if (outStream && outBuf)↩
return SZ_ERROR_PARAM;↩
↩
{↩
unsigned i;↩
for (i = 0; i < MTCODER__THREADS_MAX; i++)↩
p->coders[i].propsAreSet = False;↩
}↩
↩
#ifndef _7ZIP_ST↩
↩
if (p->props.numBlockThreads_Reduced > 1)↩
{↩
IMtCoderCallback2 vt;↩
↩
if (!p->mtCoder_WasConstructed)↩
{↩
p->mtCoder_WasConstructed = True;↩
MtCoder_Construct(&p->mtCoder);↩
}↩
↩
vt.Code = Lzma2Enc_MtCallback_Code;↩
vt.Write = Lzma2Enc_MtCallback_Write;↩
↩
p->outStream = outStream;↩
p->outBuf = NULL;↩
p->outBuf_Rem = 0;↩
if (!outStream)↩
{↩
p->outBuf = outBuf;↩
p->outBuf_Rem = *outBufSize;↩
*outBufSize = 0;↩
}↩
↩
p->mtCoder.allocBig = p->allocBig;↩
p->mtCoder.progress = progress;↩
p->mtCoder.inStream = inStream;↩
p->mtCoder.inData = inData;↩
p->mtCoder.inDataSize = inDataSize;↩
p->mtCoder.mtCallback = &vt;↩
p->mtCoder.mtCallbackObject = p;↩
↩
p->mtCoder.blockSize = (size_t)p->props.blockSize;↩
if (p->mtCoder.blockSize != p->props.blockSize)↩
return SZ_ERROR_PARAM; /* SZ_ERROR_MEM */↩
↩
{↩
size_t destBlockSize = p->mtCoder.blockSize + (p->mtCoder.blockSize >> 10) + 16;↩
if (destBlockSize < p->mtCoder.blockSize)↩
return SZ_ERROR_PARAM;↩
if (p->outBufSize != destBlockSize)↩
Lzma2Enc_FreeOutBufs(p);↩
p->outBufSize = destBlockSize;↩
}↩
↩
p->mtCoder.numThreadsMax = p->props.numBlockThreads_Max;↩
p->mtCoder.expectedDataSize = p->expectedDataSize;↩
↩
{↩
SRes res = MtCoder_Code(&p->mtCoder);↩
if (!outStream)↩
*outBufSize = p->outBuf - outBuf;↩
return res;↩
}↩
}↩
↩
#endif↩
↩
↩
return Lzma2Enc_EncodeMt1(p,↩
&p->coders[0],↩
outStream, outBuf, outBufSize,↩
inStream, inData, inDataSize,↩
True, /* finished */↩
progress);↩
}↩