react-native-update 10.34.3 → 10.34.5

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

@@ -1,18 +1,18 @@
 /* Lzma2Enc.c -- LZMA2 Encoder
-: Igor Pavlov : Public domain */
+2018-07-04 : Igor Pavlov : Public domain */
 
 #include "Precomp.h"
 
 #include <string.h>
 
-/* #define Z7_ST */
+/* #define _7ZIP_ST */
 
 #include "Lzma2Enc.h"
 
-#ifndef Z7_ST
+#ifndef _7ZIP_ST
 #include "MtCoder.h"
 #else
-#define MTCODER_THREADS_MAX 1
+#define MTCODER__THREADS_MAX 1
 #endif
 
 #define LZMA2_CONTROL_LZMA (1 << 7)
@@ -40,7 +40,7 @@
 typedef struct
 {
   ISeqInStream vt;
-  ISeqInStreamPtr realStream;
+  ISeqInStream *realStream;
   UInt64 limit;
   UInt64 processed;
   int finished;
@@ -53,15 +53,15 @@ static void LimitedSeqInStream_Init(CLimitedSeqInStream *p)
   p->finished = 0;
 }
 
-static SRes LimitedSeqInStream_Read(ISeqInStreamPtr pp, void *data, size_t *size)
+static SRes LimitedSeqInStream_Read(const ISeqInStream *pp, void *data, size_t *size)
 {
-  Z7_CONTAINER_FROM_VTBL_TO_DECL_VAR_pp_vt_p(CLimitedSeqInStream)
+  CLimitedSeqInStream *p = CONTAINER_FROM_VTBL(pp, CLimitedSeqInStream, vt);
   size_t size2 = *size;
   SRes res = SZ_OK;
   
   if (p->limit != (UInt64)(Int64)-1)
   {
-    const UInt64 rem = p->limit - p->processed;
+    UInt64 rem = p->limit - p->processed;
     if (size2 > rem)
       size2 = (size_t)rem;
   }
@@ -95,8 +95,8 @@ static SRes Lzma2EncInt_InitStream(CLzma2EncInt *p, const CLzma2EncProps *props)
   {
     SizeT propsSize = LZMA_PROPS_SIZE;
     Byte propsEncoded[LZMA_PROPS_SIZE];
-    RINOK(LzmaEnc_SetProps(p->enc, &props->lzmaProps))
-    RINOK(LzmaEnc_WriteProperties(p->enc, propsEncoded, &propsSize))
+    RINOK(LzmaEnc_SetProps(p->enc, &props->lzmaProps));
+    RINOK(LzmaEnc_WriteProperties(p->enc, propsEncoded, &propsSize));
     p->propsByte = propsEncoded[0];
     p->propsAreSet = True;
   }
@@ -111,23 +111,23 @@ static void Lzma2EncInt_InitBlock(CLzma2EncInt *p)
 }
 
 
-SRes LzmaEnc_PrepareForLzma2(CLzmaEncHandle p, ISeqInStreamPtr inStream, UInt32 keepWindowSize,
+SRes LzmaEnc_PrepareForLzma2(CLzmaEncHandle pp, ISeqInStream *inStream, UInt32 keepWindowSize,
     ISzAllocPtr alloc, ISzAllocPtr allocBig);
-SRes LzmaEnc_MemPrepare(CLzmaEncHandle p, const Byte *src, SizeT srcLen,
+SRes LzmaEnc_MemPrepare(CLzmaEncHandle pp, const Byte *src, SizeT srcLen,
     UInt32 keepWindowSize, ISzAllocPtr alloc, ISzAllocPtr allocBig);
-SRes LzmaEnc_CodeOneMemBlock(CLzmaEncHandle p, BoolInt reInit,
+SRes LzmaEnc_CodeOneMemBlock(CLzmaEncHandle pp, BoolInt reInit,
     Byte *dest, size_t *destLen, UInt32 desiredPackSize, UInt32 *unpackSize);
-const Byte *LzmaEnc_GetCurBuf(CLzmaEncHandle p);
-void LzmaEnc_Finish(CLzmaEncHandle p);
-void LzmaEnc_SaveState(CLzmaEncHandle p);
-void LzmaEnc_RestoreState(CLzmaEncHandle p);
+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 p);
+UInt32 LzmaEnc_GetNumAvailableBytes(CLzmaEncHandle pp);
 */
 
 static SRes Lzma2EncInt_EncodeSubblock(CLzma2EncInt *p, Byte *outBuf,
-    size_t *packSizeRes, ISeqOutStreamPtr outStream)
+    size_t *packSizeRes, ISeqOutStream *outStream)
 {
   size_t packSizeLimit = *packSizeRes;
   size_t packSize = packSizeLimit;
@@ -167,7 +167,7 @@ static SRes Lzma2EncInt_EncodeSubblock(CLzma2EncInt *p, Byte *outBuf,
 
     while (unpackSize > 0)
     {
-      const UInt32 u = (unpackSize < LZMA2_COPY_CHUNK_SIZE) ? unpackSize : LZMA2_COPY_CHUNK_SIZE;
+      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);
@@ -196,9 +196,9 @@ static SRes Lzma2EncInt_EncodeSubblock(CLzma2EncInt *p, Byte *outBuf,
 
   {
     size_t destPos = 0;
-    const UInt32 u = unpackSize - 1;
-    const UInt32 pm = (UInt32)(packSize - 1);
-    const unsigned mode = (p->srcPos == 0) ? 3 : (p->needInitState ? (p->needInitProp ? 2 : 1) : 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("               "));
 
@@ -231,11 +231,10 @@ static SRes Lzma2EncInt_EncodeSubblock(CLzma2EncInt *p, Byte *outBuf,
 void Lzma2EncProps_Init(CLzma2EncProps *p)
 {
   LzmaEncProps_Init(&p->lzmaProps);
-  p->blockSize = LZMA2_ENC_PROPS_BLOCK_SIZE_AUTO;
+  p->blockSize = LZMA2_ENC_PROPS__BLOCK_SIZE__AUTO;
   p->numBlockThreads_Reduced = -1;
   p->numBlockThreads_Max = -1;
   p->numTotalThreads = -1;
-  p->numThreadGroups = 0;
 }
 
 void Lzma2EncProps_Normalize(CLzma2EncProps *p)
@@ -252,8 +251,8 @@ void Lzma2EncProps_Normalize(CLzma2EncProps *p)
   t2 = p->numBlockThreads_Max;
   t3 = p->numTotalThreads;
 
-  if (t2 > MTCODER_THREADS_MAX)
-    t2 = MTCODER_THREADS_MAX;
+  if (t2 > MTCODER__THREADS_MAX)
+    t2 = MTCODER__THREADS_MAX;
 
   if (t3 <= 0)
   {
@@ -269,8 +268,8 @@ void Lzma2EncProps_Normalize(CLzma2EncProps *p)
       t1 = 1;
       t2 = t3;
     }
-    if (t2 > MTCODER_THREADS_MAX)
-      t2 = MTCODER_THREADS_MAX;
+    if (t2 > MTCODER__THREADS_MAX)
+      t2 = MTCODER__THREADS_MAX;
   }
   else if (t1 <= 0)
   {
@@ -287,8 +286,8 @@ void Lzma2EncProps_Normalize(CLzma2EncProps *p)
 
   fileSize = p->lzmaProps.reduceSize;
 
-  if (   p->blockSize != LZMA2_ENC_PROPS_BLOCK_SIZE_SOLID
-      && p->blockSize != LZMA2_ENC_PROPS_BLOCK_SIZE_AUTO
+  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;
 
@@ -298,19 +297,19 @@ void Lzma2EncProps_Normalize(CLzma2EncProps *p)
 
   t1 = p->lzmaProps.numThreads;
 
-  if (p->blockSize == LZMA2_ENC_PROPS_BLOCK_SIZE_SOLID)
+  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)
+  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;
+    p->blockSize = LZMA2_ENC_PROPS__BLOCK_SIZE__SOLID;
   }
   else
   {
-    if (p->blockSize == LZMA2_ENC_PROPS_BLOCK_SIZE_AUTO)
+    if (p->blockSize == LZMA2_ENC_PROPS__BLOCK_SIZE__AUTO)
     {
       const UInt32 kMinSize = (UInt32)1 << 20;
       const UInt32 kMaxSize = (UInt32)1 << 28;
@@ -331,7 +330,7 @@ void Lzma2EncProps_Normalize(CLzma2EncProps *p)
         numBlocks++;
       if (numBlocks < (unsigned)t2)
       {
-        t2r = (int)numBlocks;
+        t2r = (unsigned)numBlocks;
         if (t2r == 0)
           t2r = 1;
         t3 = t1 * t2r;
@@ -345,7 +344,7 @@ void Lzma2EncProps_Normalize(CLzma2EncProps *p)
 }
 
 
-static SRes Progress(ICompressProgressPtr p, UInt64 inSize, UInt64 outSize)
+static SRes Progress(ICompressProgress *p, UInt64 inSize, UInt64 outSize)
 {
   return (p && ICompressProgress_Progress(p, inSize, outSize) != SZ_OK) ? SZ_ERROR_PROGRESS : SZ_OK;
 }
@@ -353,7 +352,7 @@ static SRes Progress(ICompressProgressPtr p, UInt64 inSize, UInt64 outSize)
 
 /* ---------- Lzma2 ---------- */
 
-struct CLzma2Enc
+typedef struct
 {
   Byte propEncoded;
   CLzma2EncProps props;
@@ -364,22 +363,23 @@ struct CLzma2Enc
   ISzAllocPtr alloc;
   ISzAllocPtr allocBig;
 
-  CLzma2EncInt coders[MTCODER_THREADS_MAX];
+  CLzma2EncInt coders[MTCODER__THREADS_MAX];
 
-  #ifndef Z7_ST
+  #ifndef _7ZIP_ST
   
-  ISeqOutStreamPtr outStream;
+  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];
+  size_t outBufsDataSizes[MTCODER__BLOCKS_MAX];
   BoolInt mtCoder_WasConstructed;
   CMtCoder mtCoder;
-  Byte *outBufs[MTCODER_BLOCKS_MAX];
+  Byte *outBufs[MTCODER__BLOCKS_MAX];
 
   #endif
-};
+
+} CLzma2Enc;
 
 
 
@@ -396,30 +396,30 @@ CLzma2EncHandle Lzma2Enc_Create(ISzAllocPtr alloc, ISzAllocPtr allocBig)
   p->allocBig = allocBig;
   {
     unsigned i;
-    for (i = 0; i < MTCODER_THREADS_MAX; i++)
+    for (i = 0; i < MTCODER__THREADS_MAX; i++)
       p->coders[i].enc = NULL;
   }
   
-  #ifndef Z7_ST
+  #ifndef _7ZIP_ST
   p->mtCoder_WasConstructed = False;
   {
     unsigned i;
-    for (i = 0; i < MTCODER_BLOCKS_MAX; i++)
+    for (i = 0; i < MTCODER__BLOCKS_MAX; i++)
       p->outBufs[i] = NULL;
     p->outBufSize = 0;
   }
   #endif
 
-  return (CLzma2EncHandle)p;
+  return p;
 }
 
 
-#ifndef Z7_ST
+#ifndef _7ZIP_ST
 
 static void Lzma2Enc_FreeOutBufs(CLzma2Enc *p)
 {
   unsigned i;
-  for (i = 0; i < MTCODER_BLOCKS_MAX; i++)
+  for (i = 0; i < MTCODER__BLOCKS_MAX; i++)
     if (p->outBufs[i])
     {
       ISzAlloc_Free(p->alloc, p->outBufs[i]);
@@ -430,13 +430,12 @@ static void Lzma2Enc_FreeOutBufs(CLzma2Enc *p)
 
 #endif
 
-// #define GET_CLzma2Enc_p  CLzma2Enc *p = (CLzma2Enc *)(void *)p;
 
-void Lzma2Enc_Destroy(CLzma2EncHandle p)
+void Lzma2Enc_Destroy(CLzma2EncHandle pp)
 {
-  // GET_CLzma2Enc_p
+  CLzma2Enc *p = (CLzma2Enc *)pp;
   unsigned i;
-  for (i = 0; i < MTCODER_THREADS_MAX; i++)
+  for (i = 0; i < MTCODER__THREADS_MAX; i++)
   {
     CLzma2EncInt *t = &p->coders[i];
     if (t->enc)
@@ -447,7 +446,7 @@ void Lzma2Enc_Destroy(CLzma2EncHandle p)
   }
 
 
-  #ifndef Z7_ST
+  #ifndef _7ZIP_ST
   if (p->mtCoder_WasConstructed)
   {
     MtCoder_Destruct(&p->mtCoder);
@@ -459,13 +458,13 @@ void Lzma2Enc_Destroy(CLzma2EncHandle p)
   ISzAlloc_Free(p->alloc, p->tempBufLzma);
   p->tempBufLzma = NULL;
 
-  ISzAlloc_Free(p->alloc, p);
+  ISzAlloc_Free(p->alloc, pp);
 }
 
 
-SRes Lzma2Enc_SetProps(CLzma2EncHandle p, const CLzma2EncProps *props)
+SRes Lzma2Enc_SetProps(CLzma2EncHandle pp, const CLzma2EncProps *props)
 {
-  // GET_CLzma2Enc_p
+  CLzma2Enc *p = (CLzma2Enc *)pp;
   CLzmaEncProps lzmaProps = props->lzmaProps;
   LzmaEncProps_Normalize(&lzmaProps);
   if (lzmaProps.lc + lzmaProps.lp > LZMA2_LCLP_MAX)
@@ -476,16 +475,16 @@ SRes Lzma2Enc_SetProps(CLzma2EncHandle p, const CLzma2EncProps *props)
 }
 
 
-void Lzma2Enc_SetDataSize(CLzma2EncHandle p, UInt64 expectedDataSiize)
+void Lzma2Enc_SetDataSize(CLzmaEncHandle pp, UInt64 expectedDataSiize)
 {
-  // GET_CLzma2Enc_p
+  CLzma2Enc *p = (CLzma2Enc *)pp;
   p->expectedDataSize = expectedDataSiize;
 }
 
 
-Byte Lzma2Enc_WriteProperties(CLzma2EncHandle p)
+Byte Lzma2Enc_WriteProperties(CLzma2EncHandle pp)
 {
-  // GET_CLzma2Enc_p
+  CLzma2Enc *p = (CLzma2Enc *)pp;
   unsigned i;
   UInt32 dicSize = LzmaEncProps_GetDictSize(&p->props.lzmaProps);
   for (i = 0; i < 40; i++)
@@ -498,12 +497,12 @@ Byte Lzma2Enc_WriteProperties(CLzma2EncHandle p)
 static SRes Lzma2Enc_EncodeMt1(
     CLzma2Enc *me,
     CLzma2EncInt *p,
-    ISeqOutStreamPtr outStream,
+    ISeqOutStream *outStream,
     Byte *outBuf, size_t *outBufSize,
-    ISeqInStreamPtr inStream,
+    ISeqInStream *inStream,
     const Byte *inData, size_t inDataSize,
     int finished,
-    ICompressProgressPtr progress)
+    ICompressProgress *progress)
 {
   UInt64 unpackTotal = 0;
   UInt64 packTotal = 0;
@@ -541,12 +540,12 @@ static SRes Lzma2Enc_EncodeMt1(
     }
   }
 
-  RINOK(Lzma2EncInt_InitStream(p, &me->props))
+  RINOK(Lzma2EncInt_InitStream(p, &me->props));
 
   for (;;)
   {
     SRes res = SZ_OK;
-    SizeT inSizeCur = 0;
+    size_t inSizeCur = 0;
 
     Lzma2EncInt_InitBlock(p);
     
@@ -560,7 +559,7 @@ static SRes Lzma2Enc_EncodeMt1(
       if (me->expectedDataSize != (UInt64)(Int64)-1
           && me->expectedDataSize >= unpackTotal)
         expected = me->expectedDataSize - unpackTotal;
-      if (me->props.blockSize != LZMA2_ENC_PROPS_BLOCK_SIZE_SOLID
+      if (me->props.blockSize != LZMA2_ENC_PROPS__BLOCK_SIZE__SOLID
           && expected > me->props.blockSize)
         expected = (size_t)me->props.blockSize;
 
@@ -570,14 +569,14 @@ static SRes Lzma2Enc_EncodeMt1(
           &limitedInStream.vt,
           LZMA2_KEEP_WINDOW_SIZE,
           me->alloc,
-          me->allocBig))
+          me->allocBig));
     }
     else
     {
-      inSizeCur = (SizeT)(inDataSize - (size_t)unpackTotal);
-      if (me->props.blockSize != LZMA2_ENC_PROPS_BLOCK_SIZE_SOLID
+      inSizeCur = inDataSize - (size_t)unpackTotal;
+      if (me->props.blockSize != LZMA2_ENC_PROPS__BLOCK_SIZE__SOLID
           && inSizeCur > me->props.blockSize)
-        inSizeCur = (SizeT)(size_t)me->props.blockSize;
+        inSizeCur = (size_t)me->props.blockSize;
     
       // LzmaEnc_SetDataSize(p->enc, inSizeCur);
       
@@ -585,7 +584,7 @@ static SRes Lzma2Enc_EncodeMt1(
           inData + (size_t)unpackTotal, inSizeCur,
           LZMA2_KEEP_WINDOW_SIZE,
           me->alloc,
-          me->allocBig))
+          me->allocBig));
     }
 
     for (;;)
@@ -622,7 +621,7 @@ static SRes Lzma2Enc_EncodeMt1(
     
     unpackTotal += p->srcPos;
     
-    RINOK(res)
+    RINOK(res);
 
     if (p->srcPos != (inStream ? limitedInStream.processed : inSizeCur))
       return SZ_ERROR_FAIL;
@@ -633,15 +632,15 @@ static SRes Lzma2Enc_EncodeMt1(
       {
         if (outBuf)
         {
-          const size_t destPos = *outBufSize;
+          size_t destPos = *outBufSize;
           if (destPos >= outLim)
             return SZ_ERROR_OUTPUT_EOF;
-          outBuf[destPos] = LZMA2_CONTROL_EOF; // 0
+          outBuf[destPos] = 0;
           *outBufSize = destPos + 1;
         }
         else
         {
-          const Byte b = LZMA2_CONTROL_EOF; // 0;
+          Byte b = 0;
           if (ISeqOutStream_Write(outStream, &b, 1) != 1)
             return SZ_ERROR_WRITE;
         }
@@ -653,12 +652,12 @@ static SRes Lzma2Enc_EncodeMt1(
 
 
 
-#ifndef Z7_ST
+#ifndef _7ZIP_ST
 
-static SRes Lzma2Enc_MtCallback_Code(void *p, unsigned coderIndex, unsigned outBufIndex,
+static SRes Lzma2Enc_MtCallback_Code(void *pp, unsigned coderIndex, unsigned outBufIndex,
     const Byte *src, size_t srcSize, int finished)
 {
-  CLzma2Enc *me = (CLzma2Enc *)p;
+  CLzma2Enc *me = (CLzma2Enc *)pp;
   size_t destSize = me->outBufSize;
   SRes res;
   CMtProgressThunk progressThunk;
@@ -693,9 +692,9 @@ static SRes Lzma2Enc_MtCallback_Code(void *p, unsigned coderIndex, unsigned outB
 }
 
 
-static SRes Lzma2Enc_MtCallback_Write(void *p, unsigned outBufIndex)
+static SRes Lzma2Enc_MtCallback_Write(void *pp, unsigned outBufIndex)
 {
-  CLzma2Enc *me = (CLzma2Enc *)p;
+  CLzma2Enc *me = (CLzma2Enc *)pp;
   size_t size = me->outBufsDataSizes[outBufIndex];
   const Byte *data = me->outBufs[outBufIndex];
   
@@ -714,14 +713,14 @@ static SRes Lzma2Enc_MtCallback_Write(void *p, unsigned outBufIndex)
 
 
 
-SRes Lzma2Enc_Encode2(CLzma2EncHandle p,
-    ISeqOutStreamPtr outStream,
+SRes Lzma2Enc_Encode2(CLzma2EncHandle pp,
+    ISeqOutStream *outStream,
     Byte *outBuf, size_t *outBufSize,
-    ISeqInStreamPtr inStream,
+    ISeqInStream *inStream,
     const Byte *inData, size_t inDataSize,
-    ICompressProgressPtr progress)
+    ICompressProgress *progress)
 {
-  // GET_CLzma2Enc_p
+  CLzma2Enc *p = (CLzma2Enc *)pp;
 
   if (inStream && inData)
     return SZ_ERROR_PARAM;
@@ -731,11 +730,11 @@ SRes Lzma2Enc_Encode2(CLzma2EncHandle p,
 
   {
     unsigned i;
-    for (i = 0; i < MTCODER_THREADS_MAX; i++)
+    for (i = 0; i < MTCODER__THREADS_MAX; i++)
       p->coders[i].propsAreSet = False;
   }
 
-  #ifndef Z7_ST
+  #ifndef _7ZIP_ST
   
   if (p->props.numBlockThreads_Reduced > 1)
   {
@@ -773,7 +772,7 @@ SRes Lzma2Enc_Encode2(CLzma2EncHandle p,
       return SZ_ERROR_PARAM; /* SZ_ERROR_MEM */
 
     {
-      const size_t destBlockSize = p->mtCoder.blockSize + (p->mtCoder.blockSize >> 10) + 16;
+      size_t destBlockSize = p->mtCoder.blockSize + (p->mtCoder.blockSize >> 10) + 16;
       if (destBlockSize < p->mtCoder.blockSize)
         return SZ_ERROR_PARAM;
       if (p->outBufSize != destBlockSize)
@@ -781,14 +780,13 @@ SRes Lzma2Enc_Encode2(CLzma2EncHandle p,
       p->outBufSize = destBlockSize;
     }
 
-    p->mtCoder.numThreadsMax = (unsigned)p->props.numBlockThreads_Max;
-    p->mtCoder.numThreadGroups = p->props.numThreadGroups;
+    p->mtCoder.numThreadsMax = p->props.numBlockThreads_Max;
     p->mtCoder.expectedDataSize = p->expectedDataSize;
     
     {
-      const SRes res = MtCoder_Code(&p->mtCoder);
+      SRes res = MtCoder_Code(&p->mtCoder);
       if (!outStream)
-        *outBufSize = (size_t)(p->outBuf - outBuf);
+        *outBufSize = p->outBuf - outBuf;
       return res;
     }
   }
@@ -803,5 +801,3 @@ SRes Lzma2Enc_Encode2(CLzma2EncHandle p,
       True, /* finished */
       progress);
 }
-
-#undef PRF

package/harmony/pushy/src/main/cpp/lzma/C/Lzma2Enc.h

@@ -1,15 +1,15 @@
 /* Lzma2Enc.h -- LZMA2 Encoder
-2023-04-13 : Igor Pavlov : Public domain */
+2017-07-27 : Igor Pavlov : Public domain */
 
-#ifndef ZIP7_INC_LZMA2_ENC_H
-#define ZIP7_INC_LZMA2_ENC_H
+#ifndef __LZMA2_ENC_H
+#define __LZMA2_ENC_H
 
 #include "LzmaEnc.h"
 
 EXTERN_C_BEGIN
 
-#define LZMA2_ENC_PROPS_BLOCK_SIZE_AUTO   0
-#define LZMA2_ENC_PROPS_BLOCK_SIZE_SOLID  ((UInt64)(Int64)-1)
+#define LZMA2_ENC_PROPS__BLOCK_SIZE__AUTO 0
+#define LZMA2_ENC_PROPS__BLOCK_SIZE__SOLID ((UInt64)(Int64)-1)
 
 typedef struct
 {
@@ -18,7 +18,6 @@ typedef struct
   int numBlockThreads_Reduced;
   int numBlockThreads_Max;
   int numTotalThreads;
-  unsigned numThreadGroups; // 0 : no groups
 } CLzma2EncProps;
 
 void Lzma2EncProps_Init(CLzma2EncProps *p);
@@ -37,9 +36,7 @@ SRes:
   SZ_ERROR_THREAD - error in multithreading functions (only for Mt version)
 */
 
-typedef struct CLzma2Enc CLzma2Enc;
-typedef CLzma2Enc * CLzma2EncHandle;
-// Z7_DECLARE_HANDLE(CLzma2EncHandle)
+typedef void * CLzma2EncHandle;
 
 CLzma2EncHandle Lzma2Enc_Create(ISzAllocPtr alloc, ISzAllocPtr allocBig);
 void Lzma2Enc_Destroy(CLzma2EncHandle p);
@@ -47,11 +44,11 @@ SRes Lzma2Enc_SetProps(CLzma2EncHandle p, const CLzma2EncProps *props);
 void Lzma2Enc_SetDataSize(CLzma2EncHandle p, UInt64 expectedDataSiize);
 Byte Lzma2Enc_WriteProperties(CLzma2EncHandle p);
 SRes Lzma2Enc_Encode2(CLzma2EncHandle p,
-    ISeqOutStreamPtr outStream,
+    ISeqOutStream *outStream,
     Byte *outBuf, size_t *outBufSize,
-    ISeqInStreamPtr inStream,
+    ISeqInStream *inStream,
     const Byte *inData, size_t inDataSize,
-    ICompressProgressPtr progress);
+    ICompressProgress *progress);
 
 EXTERN_C_END
 

package/harmony/pushy/src/main/cpp/lzma/C/Lzma86.h

@@ -1,8 +1,8 @@
 /* Lzma86.h -- LZMA + x86 (BCJ) Filter
-2023-03-03 : Igor Pavlov : Public domain */
+2013-01-18 : Igor Pavlov : Public domain */
 
-#ifndef ZIP7_INC_LZMA86_H
-#define ZIP7_INC_LZMA86_H
+#ifndef __LZMA86_H
+#define __LZMA86_H
 
 #include "7zTypes.h"
 

package/harmony/pushy/src/main/cpp/lzma/C/Lzma86Dec.c

@@ -1,5 +1,5 @@
 /* Lzma86Dec.c -- LZMA + x86 (BCJ) Filter Decoder
-2023-03-03 : Igor Pavlov : Public domain */
+2016-05-16 : Igor Pavlov : Public domain */
 
 #include "Precomp.h"
 
@@ -46,8 +46,9 @@ SRes Lzma86_Decode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen)
     return res;
   if (useFilter == 1)
   {
-    UInt32 x86State = Z7_BRANCH_CONV_ST_X86_STATE_INIT_VAL;
-    z7_BranchConvSt_X86_Dec(dest, *destLen, 0, &x86State);
+    UInt32 x86State;
+    x86_Convert_Init(x86State);
+    x86_Convert(dest, *destLen, 0, &x86State, 0);
   }
   return SZ_OK;
 }

package/harmony/pushy/src/main/cpp/lzma/C/Lzma86Enc.c

@@ -1,5 +1,5 @@
 /* Lzma86Enc.c -- LZMA + x86 (BCJ) Filter Encoder
-2023-03-03 : Igor Pavlov : Public domain */
+2018-07-04 : Igor Pavlov : Public domain */
 
 #include "Precomp.h"
 
@@ -11,6 +11,8 @@
 #include "Bra.h"
 #include "LzmaEnc.h"
 
+#define SZE_OUT_OVERFLOW SZE_DATA_ERROR
+
 int Lzma86_Encode(Byte *dest, size_t *destLen, const Byte *src, size_t srcLen,
     int level, UInt32 dictSize, int filterMode)
 {
@@ -46,8 +48,9 @@ int Lzma86_Encode(Byte *dest, size_t *destLen, const Byte *src, size_t srcLen,
       memcpy(filteredStream, src, srcLen);
     }
     {
-      UInt32 x86State = Z7_BRANCH_CONV_ST_X86_STATE_INIT_VAL;
-      z7_BranchConvSt_X86_Enc(filteredStream, srcLen, 0, &x86State);
+      UInt32 x86State;
+      x86_Convert_Init(x86State);
+      x86_Convert(filteredStream, srcLen, 0, &x86State, 1);
     }
   }