Adding upstream version 86.0.1.upstream/86.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 803 insertions, 0 deletions

diff --git a/other-licenses/7zstub/src/C/Lzma2Enc.c b/other-licenses/7zstub/src/C/Lzma2Enc.c
new file mode 100644
index 0000000000..5098195c12
--- /dev/null
+++ b/other-licenses/7zstub/src/C/Lzma2Enc.c
@@ -0,0 +1,803 @@
+/* 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);

+}