react-native-update 8.5.5 → 8.5.6

package/harmony/src/main/cpp/lzma/C/Lzma2Enc.c

@@ -1,803 +0,0 @@
-/* Lzma2Enc.c -- LZMA2 Encoder
-2018-07-04 : 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, BoolInt 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);
-  BoolInt 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];
-  BoolInt 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);
-}