react-native-update 10.34.3 → 10.34.4

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

@@ -1,5 +1,5 @@
 /* XzEnc.c -- Xz Encode
-: Igor Pavlov : Public domain */
+2019-02-02 : Igor Pavlov : Public domain */
 
 #include "Precomp.h"
 
@@ -18,43 +18,42 @@
 
 #include "XzEnc.h"
 
-// #define Z7_ST
+// #define _7ZIP_ST
 
-#ifndef Z7_ST
+#ifndef _7ZIP_ST
 #include "MtCoder.h"
 #else
-#define MTCODER_THREADS_MAX 1
-#define MTCODER_BLOCKS_MAX 1
+#define MTCODER__THREADS_MAX 1
+#define MTCODER__BLOCKS_MAX 1
 #endif
 
 #define XZ_GET_PAD_SIZE(dataSize) ((4 - ((unsigned)(dataSize) & 3)) & 3)
 
-#define XZ_CHECK_SIZE_MAX 64
-/* max pack size for LZMA2 block + pad4 + check_size: */
-#define XZ_GET_MAX_BLOCK_PACK_SIZE(unpackSize) ((unpackSize) + ((unpackSize) >> 10) + 16 + XZ_CHECK_SIZE_MAX)
+/* max pack size for LZMA2 block + check-64bytrs: */
+#define XZ_GET_MAX_BLOCK_PACK_SIZE(unpackSize) ((unpackSize) + ((unpackSize) >> 10) + 16 + 64)
 
 #define XZ_GET_ESTIMATED_BLOCK_TOTAL_PACK_SIZE(unpackSize) (XZ_BLOCK_HEADER_SIZE_MAX + XZ_GET_MAX_BLOCK_PACK_SIZE(unpackSize))
 
 
-// #define XzBlock_ClearFlags(p)       (p)->flags = 0;
-#define XzBlock_ClearFlags_SetNumFilters(p, n) (p)->flags = (Byte)((n) - 1);
+#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(ISeqOutStreamPtr s, const void *buf, size_t size)
+static SRes WriteBytes(ISeqOutStream *s, const void *buf, size_t size)
 {
   return (ISeqOutStream_Write(s, buf, size) == size) ? SZ_OK : SZ_ERROR_WRITE;
 }
 
-static SRes WriteBytes_UpdateCrc(ISeqOutStreamPtr s, const void *buf, size_t size, UInt32 *crc)
+static SRes WriteBytesUpdateCrc(ISeqOutStream *s, const void *buf, size_t size, UInt32 *crc)
 {
   *crc = CrcUpdate(*crc, buf, size);
   return WriteBytes(s, buf, size);
 }
 
 
-static SRes Xz_WriteHeader(CXzStreamFlags f, ISeqOutStreamPtr s)
+static SRes Xz_WriteHeader(CXzStreamFlags f, ISeqOutStream *s)
 {
   UInt32 crc;
   Byte header[XZ_STREAM_HEADER_SIZE];
@@ -62,12 +61,12 @@ static SRes Xz_WriteHeader(CXzStreamFlags f, ISeqOutStreamPtr s)
   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)
+  SetUi32(header + XZ_SIG_SIZE + XZ_STREAM_FLAGS_SIZE, crc);
   return WriteBytes(s, header, XZ_STREAM_HEADER_SIZE);
 }
 
 
-static SRes XzBlock_WriteHeader(const CXzBlock *p, ISeqOutStreamPtr s)
+static SRes XzBlock_WriteHeader(const CXzBlock *p, ISeqOutStream *s)
 {
   Byte header[XZ_BLOCK_HEADER_SIZE_MAX];
 
@@ -92,7 +91,7 @@ static SRes XzBlock_WriteHeader(const CXzBlock *p, ISeqOutStreamPtr s)
     header[pos++] = 0;
 
   header[0] = (Byte)(pos >> 2);
-  SetUi32(header + pos, CrcCalc(header, pos))
+  SetUi32(header + pos, CrcCalc(header, pos));
   return WriteBytes(s, header, pos + 4);
 }
 
@@ -183,7 +182,7 @@ static SRes XzEncIndex_AddIndexRecord(CXzEncIndex *p, UInt64 unpackSize, UInt64
     size_t newSize = p->allocated * 2 + 16 * 2;
     if (newSize < p->size + pos)
       return SZ_ERROR_MEM;
-    RINOK(XzEncIndex_ReAlloc(p, newSize, alloc))
+    RINOK(XzEncIndex_ReAlloc(p, newSize, alloc));
   }
   memcpy(p->blocks + p->size, buf, pos);
   p->size += pos;
@@ -192,7 +191,7 @@ static SRes XzEncIndex_AddIndexRecord(CXzEncIndex *p, UInt64 unpackSize, UInt64
 }
 
 
-static SRes XzEncIndex_WriteFooter(const CXzEncIndex *p, CXzStreamFlags flags, ISeqOutStreamPtr s)
+static SRes XzEncIndex_WriteFooter(const CXzEncIndex *p, CXzStreamFlags flags, ISeqOutStream *s)
 {
   Byte buf[32];
   UInt64 globalPos;
@@ -201,8 +200,8 @@ static SRes XzEncIndex_WriteFooter(const CXzEncIndex *p, CXzStreamFlags flags, I
   
   globalPos = pos;
   buf[0] = 0;
-  RINOK(WriteBytes_UpdateCrc(s, buf, pos, &crc))
-  RINOK(WriteBytes_UpdateCrc(s, p->blocks, p->size, &crc))
+  RINOK(WriteBytesUpdateCrc(s, buf, pos, &crc));
+  RINOK(WriteBytesUpdateCrc(s, p->blocks, p->size, &crc));
   globalPos += p->size;
   
   pos = XZ_GET_PAD_SIZE(globalPos);
@@ -212,12 +211,12 @@ static SRes XzEncIndex_WriteFooter(const CXzEncIndex *p, CXzStreamFlags flags, I
   globalPos += pos;
   
   crc = CrcUpdate(crc, buf + 4 - pos, pos);
-  SetUi32(buf + 4, CRC_GET_DIGEST(crc))
+  SetUi32(buf + 4, CRC_GET_DIGEST(crc));
   
-  SetUi32(buf + 8 + 4, (UInt32)(globalPos >> 2))
+  SetUi32(buf + 8 + 4, (UInt32)(globalPos >> 2));
   buf[8 + 8] = (Byte)(flags >> 8);
   buf[8 + 9] = (Byte)(flags & 0xFF);
-  SetUi32(buf + 8, CrcCalc(buf + 8 + 4, 6))
+  SetUi32(buf + 8, CrcCalc(buf + 8 + 4, 6));
   buf[8 + 10] = XZ_FOOTER_SIG_0;
   buf[8 + 11] = XZ_FOOTER_SIG_1;
   
@@ -231,7 +230,7 @@ static SRes XzEncIndex_WriteFooter(const CXzEncIndex *p, CXzStreamFlags flags, I
 typedef struct
 {
   ISeqInStream vt;
-  ISeqInStreamPtr realStream;
+  ISeqInStream *realStream;
   const Byte *data;
   UInt64 limit;
   UInt64 processed;
@@ -252,9 +251,9 @@ static void SeqCheckInStream_GetDigest(CSeqCheckInStream *p, Byte *digest)
   XzCheck_Final(&p->check, digest);
 }
 
-static SRes SeqCheckInStream_Read(ISeqInStreamPtr pp, void *data, size_t *size)
+static SRes SeqCheckInStream_Read(const ISeqInStream *pp, void *data, size_t *size)
 {
-  Z7_CONTAINER_FROM_VTBL_TO_DECL_VAR_pp_vt_p(CSeqCheckInStream)
+  CSeqCheckInStream *p = CONTAINER_FROM_VTBL(pp, CSeqCheckInStream, vt);
   size_t size2 = *size;
   SRes res = SZ_OK;
   
@@ -286,15 +285,15 @@ static SRes SeqCheckInStream_Read(ISeqInStreamPtr pp, void *data, size_t *size)
 typedef struct
 {
   ISeqOutStream vt;
-  ISeqOutStreamPtr realStream;
+  ISeqOutStream *realStream;
   Byte *outBuf;
   size_t outBufLimit;
   UInt64 processed;
 } CSeqSizeOutStream;
 
-static size_t SeqSizeOutStream_Write(ISeqOutStreamPtr pp, const void *data, size_t size)
+static size_t SeqSizeOutStream_Write(const ISeqOutStream *pp, const void *data, size_t size)
 {
-  Z7_CONTAINER_FROM_VTBL_TO_DECL_VAR_pp_vt_p(CSeqSizeOutStream)
+  CSeqSizeOutStream *p = CONTAINER_FROM_VTBL(pp, CSeqSizeOutStream, vt);
   if (p->realStream)
     size = ISeqOutStream_Write(p->realStream, data, size);
   else
@@ -314,8 +313,8 @@ static size_t SeqSizeOutStream_Write(ISeqOutStreamPtr pp, const void *data, size
 
 typedef struct
 {
-  ISeqInStream vt;
-  ISeqInStreamPtr realStream;
+  ISeqInStream p;
+  ISeqInStream *realStream;
   IStateCoder StateCoder;
   Byte *buf;
   size_t curPos;
@@ -324,40 +323,7 @@ typedef struct
 } CSeqInFilter;
 
 
-static const z7_Func_BranchConv g_Funcs_BranchConv_RISC_Enc[] =
-{
-  Z7_BRANCH_CONV_ENC_2 (BranchConv_PPC),
-  Z7_BRANCH_CONV_ENC_2 (BranchConv_IA64),
-  Z7_BRANCH_CONV_ENC_2 (BranchConv_ARM),
-  Z7_BRANCH_CONV_ENC_2 (BranchConv_ARMT),
-  Z7_BRANCH_CONV_ENC_2 (BranchConv_SPARC),
-  Z7_BRANCH_CONV_ENC_2 (BranchConv_ARM64),
-  Z7_BRANCH_CONV_ENC_2 (BranchConv_RISCV)
-};
-
-static SizeT XzBcFilterStateBase_Filter_Enc(CXzBcFilterStateBase *p, Byte *data, SizeT size)
-{
-  switch (p->methodId)
-  {
-    case XZ_ID_Delta:
-      Delta_Encode(p->delta_State, p->delta, data, size);
-      break;
-    case XZ_ID_X86:
-      size = (SizeT)(z7_BranchConvSt_X86_Enc(data, size, p->ip, &p->X86_State) - data);
-      break;
-    default:
-      if (p->methodId >= XZ_ID_PPC)
-      {
-        const UInt32 i = p->methodId - XZ_ID_PPC;
-        if (i < Z7_ARRAY_SIZE(g_Funcs_BranchConv_RISC_Enc))
-          size = (SizeT)(g_Funcs_BranchConv_RISC_Enc[i](data, size, p->ip) - data);
-      }
-      break;
-  }
-  p->ip += (UInt32)size;
-  return size;
-}
-
+SRes BraState_SetFromMethod(IStateCoder *p, UInt64 id, int encodeMode, ISzAllocPtr alloc);
 
 static SRes SeqInFilter_Init(CSeqInFilter *p, const CXzFilter *props, ISzAllocPtr alloc)
 {
@@ -369,17 +335,17 @@ static SRes SeqInFilter_Init(CSeqInFilter *p, const CXzFilter *props, ISzAllocPt
   }
   p->curPos = p->endPos = 0;
   p->srcWasFinished = 0;
-  RINOK(Xz_StateCoder_Bc_SetFromMethod_Func(&p->StateCoder, props->id, XzBcFilterStateBase_Filter_Enc, alloc))
-  RINOK(p->StateCoder.SetProps(p->StateCoder.p, props->props, props->propsSize, alloc))
+  RINOK(BraState_SetFromMethod(&p->StateCoder, props->id, 1, alloc));
+  RINOK(p->StateCoder.SetProps(p->StateCoder.p, props->props, props->propsSize, alloc));
   p->StateCoder.Init(p->StateCoder.p);
   return SZ_OK;
 }
 
 
-static SRes SeqInFilter_Read(ISeqInStreamPtr pp, void *data, size_t *size)
+static SRes SeqInFilter_Read(const ISeqInStream *pp, void *data, size_t *size)
 {
-  Z7_CONTAINER_FROM_VTBL_TO_DECL_VAR_pp_vt_p(CSeqInFilter)
-  const size_t sizeOriginal = *size;
+  CSeqInFilter *p = CONTAINER_FROM_VTBL(pp, CSeqInFilter, p);
+  size_t sizeOriginal = *size;
   if (sizeOriginal == 0)
     return SZ_OK;
   *size = 0;
@@ -390,7 +356,7 @@ static SRes SeqInFilter_Read(ISeqInStreamPtr pp, void *data, size_t *size)
     {
       p->curPos = 0;
       p->endPos = FILTER_BUF_SIZE;
-      RINOK(ISeqInStream_Read(p->realStream, p->buf, &p->endPos))
+      RINOK(ISeqInStream_Read(p->realStream, p->buf, &p->endPos));
       if (p->endPos == 0)
         p->srcWasFinished = 1;
     }
@@ -411,15 +377,13 @@ static SRes SeqInFilter_Read(ISeqInStreamPtr pp, void *data, size_t *size)
   }
 }
 
-Z7_FORCE_INLINE
 static void SeqInFilter_Construct(CSeqInFilter *p)
 {
   p->buf = NULL;
   p->StateCoder.p = NULL;
-  p->vt.Read = SeqInFilter_Read;
+  p->p.Read = SeqInFilter_Read;
 }
 
-Z7_FORCE_INLINE
 static void SeqInFilter_Free(CSeqInFilter *p, ISzAllocPtr alloc)
 {
   if (p->StateCoder.p)
@@ -442,13 +406,13 @@ static void SeqInFilter_Free(CSeqInFilter *p, ISzAllocPtr alloc)
 typedef struct
 {
   ISeqInStream vt;
-  ISeqInStreamPtr inStream;
+  ISeqInStream *inStream;
   CSbEnc enc;
 } CSbEncInStream;
 
-static SRes SbEncInStream_Read(ISeqInStreamPtr pp, void *data, size_t *size)
+static SRes SbEncInStream_Read(const ISeqInStream *pp, void *data, size_t *size)
 {
-  CSbEncInStream *p = Z7_CONTAINER_FROM_VTBL(pp, CSbEncInStream, vt);
+  CSbEncInStream *p = CONTAINER_FROM_VTBL(pp, CSbEncInStream, vt);
   size_t sizeOriginal = *size;
   if (sizeOriginal == 0)
     return SZ_OK;
@@ -458,7 +422,7 @@ static SRes SbEncInStream_Read(ISeqInStreamPtr pp, void *data, size_t *size)
     if (p->enc.needRead && !p->enc.readWasFinished)
     {
       size_t processed = p->enc.needReadSizeMax;
-      RINOK(p->inStream->Read(p->inStream, p->enc.buf + p->enc.readPos, &processed))
+      RINOK(p->inStream->Read(p->inStream, p->enc.buf + p->enc.readPos, &processed));
       p->enc.readPos += processed;
       if (processed == 0)
       {
@@ -469,7 +433,7 @@ static SRes SbEncInStream_Read(ISeqInStreamPtr pp, void *data, size_t *size)
     }
   
     *size = sizeOriginal;
-    RINOK(SbEnc_Read(&p->enc, data, size))
+    RINOK(SbEnc_Read(&p->enc, data, size));
     if (*size != 0 || !p->enc.needRead)
       return SZ_OK;
   }
@@ -509,8 +473,7 @@ void XzFilterProps_Init(CXzFilterProps *p)
 void XzProps_Init(CXzProps *p)
 {
   p->checkId = XZ_CHECK_CRC32;
-  p->numThreadGroups = 0;
-  p->blockSize = XZ_PROPS_BLOCK_SIZE_AUTO;
+  p->blockSize = XZ_PROPS__BLOCK_SIZE__AUTO;
   p->numBlockThreads_Reduced = -1;
   p->numBlockThreads_Max = -1;
   p->numTotalThreads = -1;
@@ -539,8 +502,8 @@ static void XzEncProps_Normalize_Fixed(CXzProps *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)
   {
@@ -556,8 +519,8 @@ static void XzEncProps_Normalize_Fixed(CXzProps *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)
   {
@@ -589,7 +552,7 @@ static void XzEncProps_Normalize_Fixed(CXzProps *p)
         numBlocks++;
       if (numBlocks < (unsigned)t2)
       {
-        t2r = (int)numBlocks;
+        t2r = (unsigned)numBlocks;
         if (t2r == 0)
           t2r = 1;
         t3 = t1 * t2r;
@@ -608,7 +571,7 @@ static void XzProps_Normalize(CXzProps *p)
   /* we normalize xzProps properties, but we normalize only some of CXzProps::lzma2Props properties.
      Lzma2Enc_SetProps() will normalize lzma2Props later. */
   
-  if (p->blockSize == XZ_PROPS_BLOCK_SIZE_SOLID)
+  if (p->blockSize == XZ_PROPS__BLOCK_SIZE__SOLID)
   {
     p->lzma2Props.lzmaProps.reduceSize = p->reduceSize;
     p->numBlockThreads_Reduced = 1;
@@ -620,15 +583,15 @@ static void XzProps_Normalize(CXzProps *p)
   else
   {
     CLzma2EncProps *lzma2 = &p->lzma2Props;
-    if (p->blockSize == LZMA2_ENC_PROPS_BLOCK_SIZE_AUTO)
+    if (p->blockSize == LZMA2_ENC_PROPS__BLOCK_SIZE__AUTO)
     {
       // xz-auto
       p->lzma2Props.lzmaProps.reduceSize = p->reduceSize;
 
-      if (lzma2->blockSize == LZMA2_ENC_PROPS_BLOCK_SIZE_SOLID)
+      if (lzma2->blockSize == LZMA2_ENC_PROPS__BLOCK_SIZE__SOLID)
       {
         // if (xz-auto && lzma2-solid) - we use solid for both
-        p->blockSize = XZ_PROPS_BLOCK_SIZE_SOLID;
+        p->blockSize = XZ_PROPS__BLOCK_SIZE__SOLID;
         p->numBlockThreads_Reduced = 1;
         p->numBlockThreads_Max = 1;
         if (p->lzma2Props.numTotalThreads <= 0)
@@ -647,9 +610,9 @@ static void XzProps_Normalize(CXzProps *p)
         p->blockSize = tp.blockSize; // fixed or solid
         p->numBlockThreads_Reduced = tp.numBlockThreads_Reduced;
         p->numBlockThreads_Max = tp.numBlockThreads_Max;
-        if (lzma2->blockSize == LZMA2_ENC_PROPS_BLOCK_SIZE_AUTO)
-          lzma2->blockSize = tp.blockSize; // fixed or solid, LZMA2_ENC_PROPS_BLOCK_SIZE_SOLID
-        if (lzma2->lzmaProps.reduceSize > tp.blockSize && tp.blockSize != LZMA2_ENC_PROPS_BLOCK_SIZE_SOLID)
+        if (lzma2->blockSize == LZMA2_ENC_PROPS__BLOCK_SIZE__AUTO)
+          lzma2->blockSize = tp.blockSize; // fixed or solid, LZMA2_ENC_PROPS__BLOCK_SIZE__SOLID
+        if (lzma2->lzmaProps.reduceSize > tp.blockSize && tp.blockSize != LZMA2_ENC_PROPS__BLOCK_SIZE__SOLID)
           lzma2->lzmaProps.reduceSize = tp.blockSize;
         lzma2->numBlockThreads_Reduced = 1;
         lzma2->numBlockThreads_Max = 1;
@@ -668,9 +631,9 @@ static void XzProps_Normalize(CXzProps *p)
           r = p->blockSize;
         lzma2->lzmaProps.reduceSize = r;
       }
-      if (lzma2->blockSize == LZMA2_ENC_PROPS_BLOCK_SIZE_AUTO)
-        lzma2->blockSize = LZMA2_ENC_PROPS_BLOCK_SIZE_SOLID;
-      else if (lzma2->blockSize > p->blockSize && lzma2->blockSize != LZMA2_ENC_PROPS_BLOCK_SIZE_SOLID)
+      if (lzma2->blockSize == LZMA2_ENC_PROPS__BLOCK_SIZE__AUTO)
+        lzma2->blockSize = LZMA2_ENC_PROPS__BLOCK_SIZE__SOLID;
+      else if (lzma2->blockSize > p->blockSize && lzma2->blockSize != LZMA2_ENC_PROPS__BLOCK_SIZE__SOLID)
         lzma2->blockSize = p->blockSize;
       
       XzEncProps_Normalize_Fixed(p);
@@ -692,7 +655,6 @@ typedef struct
 } CLzma2WithFilters;
 
 
-Z7_FORCE_INLINE
 static void Lzma2WithFilters_Construct(CLzma2WithFilters *p)
 {
   p->lzma2 = NULL;
@@ -716,7 +678,6 @@ static SRes Lzma2WithFilters_Create(CLzma2WithFilters *p, ISzAllocPtr alloc, ISz
 }
 
 
-Z7_FORCE_INLINE
 static void Lzma2WithFilters_Free(CLzma2WithFilters *p, ISzAllocPtr alloc)
 {
   #ifdef USE_SUBBLOCK
@@ -743,17 +704,17 @@ typedef struct
 static SRes Xz_CompressBlock(
     CLzma2WithFilters *lzmaf,
     
-    ISeqOutStreamPtr outStream,
+    ISeqOutStream *outStream,
     Byte *outBufHeader,
     Byte *outBufData, size_t outBufDataLimit,
 
-    ISeqInStreamPtr inStream,
+    ISeqInStream *inStream,
     // UInt64 expectedSize,
     const Byte *inBuf, // used if (!inStream)
     size_t inBufSize,  // used if (!inStream), it's block size, props->blockSize is ignored
 
     const CXzProps *props,
-    ICompressProgressPtr progress,
+    ICompressProgress *progress,
     int *inStreamFinished,  /* only for inStream version */
     CXzEncBlockInfo *blockSizes,
     ISzAllocPtr alloc,
@@ -770,12 +731,12 @@ static SRes Xz_CompressBlock(
   
   *inStreamFinished = False;
   
-  RINOK(Lzma2WithFilters_Create(lzmaf, alloc, allocBig))
+  RINOK(Lzma2WithFilters_Create(lzmaf, alloc, allocBig));
   
-  RINOK(Lzma2Enc_SetProps(lzmaf->lzma2, &props->lzma2Props))
+  RINOK(Lzma2Enc_SetProps(lzmaf->lzma2, &props->lzma2Props));
   
-  // XzBlock_ClearFlags(&block)
-  XzBlock_ClearFlags_SetNumFilters(&block, 1 + (fp ? 1 : 0))
+  XzBlock_ClearFlags(&block);
+  XzBlock_SetNumFilters(&block, 1 + (fp ? 1 : 0));
   
   if (fp)
   {
@@ -790,8 +751,7 @@ static SRes Xz_CompressBlock(
     }
     else if (fp->ipDefined)
     {
-      Byte *ptr = filter->props;
-      SetUi32(ptr, fp->ip)
+      SetUi32(filter->props, fp->ip);
       filter->propsSize = 4;
     }
   }
@@ -816,13 +776,13 @@ static SRes Xz_CompressBlock(
     if (props->blockSize != (UInt64)(Int64)-1)
       if (expectedSize > props->blockSize)
         block.unpackSize = props->blockSize;
-    XzBlock_SetHasUnpackSize(&block)
+    XzBlock_SetHasUnpackSize(&block);
   }
   */
 
   if (outStream)
   {
-    RINOK(XzBlock_WriteHeader(&block, &seqSizeOutStream.vt))
+    RINOK(XzBlock_WriteHeader(&block, &seqSizeOutStream.vt));
   }
   
   checkInStream.vt.Read = SeqCheckInStream_Read;
@@ -840,13 +800,13 @@ static SRes Xz_CompressBlock(
     if (fp->id == XZ_ID_Subblock)
     {
       lzmaf->sb.inStream = &checkInStream.vt;
-      RINOK(SbEncInStream_Init(&lzmaf->sb))
+      RINOK(SbEncInStream_Init(&lzmaf->sb));
     }
     else
     #endif
     {
       lzmaf->filter.realStream = &checkInStream.vt;
-      RINOK(SeqInFilter_Init(&lzmaf->filter, filter, alloc))
+      RINOK(SeqInFilter_Init(&lzmaf->filter, filter, alloc));
     }
   }
 
@@ -880,7 +840,7 @@ static SRes Xz_CompressBlock(
             #ifdef USE_SUBBLOCK
             (fp->id == XZ_ID_Subblock) ? &lzmaf->sb.vt:
             #endif
-            &lzmaf->filter.vt) :
+            &lzmaf->filter.p) :
             &checkInStream.vt) : NULL,
       
         useStream ? NULL : inBuf,
@@ -891,13 +851,13 @@ static SRes Xz_CompressBlock(
     if (outBuf)
       seqSizeOutStream.processed += outSize;
     
-    RINOK(res)
+    RINOK(res);
     blockSizes->unpackSize = checkInStream.processed;
   }
   {
-    Byte buf[4 + XZ_CHECK_SIZE_MAX];
-    const unsigned padSize = XZ_GET_PAD_SIZE(seqSizeOutStream.processed);
-    const UInt64 packSize = seqSizeOutStream.processed;
+    Byte buf[4 + 64];
+    unsigned padSize = XZ_GET_PAD_SIZE(seqSizeOutStream.processed);
+    UInt64 packSize = seqSizeOutStream.processed;
     
     buf[0] = 0;
     buf[1] = 0;
@@ -905,8 +865,7 @@ static SRes Xz_CompressBlock(
     buf[3] = 0;
     
     SeqCheckInStream_GetDigest(&checkInStream, buf + 4);
-    RINOK(WriteBytes(&seqSizeOutStream.vt, buf + (4 - padSize),
-        padSize + XzFlags_GetCheckSize((CXzStreamFlags)props->checkId)))
+    RINOK(WriteBytes(&seqSizeOutStream.vt, buf + (4 - padSize), padSize + XzFlags_GetCheckSize((CXzStreamFlags)props->checkId)));
     
     blockSizes->totalSize = seqSizeOutStream.processed - padSize;
     
@@ -917,12 +876,12 @@ static SRes Xz_CompressBlock(
       seqSizeOutStream.processed = 0;
       
       block.unpackSize = blockSizes->unpackSize;
-      XzBlock_SetHasUnpackSize(&block)
+      XzBlock_SetHasUnpackSize(&block);
       
       block.packSize = packSize;
-      XzBlock_SetHasPackSize(&block)
+      XzBlock_SetHasPackSize(&block);
       
-      RINOK(XzBlock_WriteHeader(&block, &seqSizeOutStream.vt))
+      RINOK(XzBlock_WriteHeader(&block, &seqSizeOutStream.vt));
       
       blockSizes->headerSize = (size_t)seqSizeOutStream.processed;
       blockSizes->totalSize += seqSizeOutStream.processed;
@@ -946,15 +905,15 @@ static SRes Xz_CompressBlock(
 typedef struct
 {
   ICompressProgress vt;
-  ICompressProgressPtr progress;
+  ICompressProgress *progress;
   UInt64 inOffset;
   UInt64 outOffset;
 } CCompressProgress_XzEncOffset;
 
 
-static SRes CompressProgress_XzEncOffset_Progress(ICompressProgressPtr pp, UInt64 inSize, UInt64 outSize)
+static SRes CompressProgress_XzEncOffset_Progress(const ICompressProgress *pp, UInt64 inSize, UInt64 outSize)
 {
-  const CCompressProgress_XzEncOffset *p = Z7_CONTAINER_FROM_VTBL_CONST(pp, CCompressProgress_XzEncOffset, vt);
+  const CCompressProgress_XzEncOffset *p = CONTAINER_FROM_VTBL(pp, CCompressProgress_XzEncOffset, vt);
   inSize += p->inOffset;
   outSize += p->outOffset;
   return ICompressProgress_Progress(p->progress, inSize, outSize);
@@ -963,7 +922,7 @@ static SRes CompressProgress_XzEncOffset_Progress(ICompressProgressPtr pp, UInt6
 
 
 
-struct CXzEnc
+typedef struct
 {
   ISzAllocPtr alloc;
   ISzAllocPtr allocBig;
@@ -973,19 +932,20 @@ struct CXzEnc
 
   CXzEncIndex xzIndex;
 
-  CLzma2WithFilters lzmaf_Items[MTCODER_THREADS_MAX];
+  CLzma2WithFilters lzmaf_Items[MTCODER__THREADS_MAX];
   
   size_t outBufSize;       /* size of allocated outBufs[i] */
-  Byte *outBufs[MTCODER_BLOCKS_MAX];
+  Byte *outBufs[MTCODER__BLOCKS_MAX];
 
-  #ifndef Z7_ST
+  #ifndef _7ZIP_ST
   unsigned checkType;
-  ISeqOutStreamPtr outStream;
+  ISeqOutStream *outStream;
   BoolInt mtCoder_WasConstructed;
   CMtCoder mtCoder;
-  CXzEncBlockInfo EncBlocks[MTCODER_BLOCKS_MAX];
+  CXzEncBlockInfo EncBlocks[MTCODER__BLOCKS_MAX];
   #endif
-};
+
+} CXzEnc;
 
 
 static void XzEnc_Construct(CXzEnc *p)
@@ -994,13 +954,13 @@ static void XzEnc_Construct(CXzEnc *p)
 
   XzEncIndex_Construct(&p->xzIndex);
 
-  for (i = 0; i < MTCODER_THREADS_MAX; i++)
+  for (i = 0; i < MTCODER__THREADS_MAX; i++)
     Lzma2WithFilters_Construct(&p->lzmaf_Items[i]);
 
-  #ifndef Z7_ST
+  #ifndef _7ZIP_ST
   p->mtCoder_WasConstructed = False;
   {
-    for (i = 0; i < MTCODER_BLOCKS_MAX; i++)
+    for (i = 0; i < MTCODER__BLOCKS_MAX; i++)
       p->outBufs[i] = NULL;
     p->outBufSize = 0;
   }
@@ -1011,7 +971,7 @@ static void XzEnc_Construct(CXzEnc *p)
 static void XzEnc_FreeOutBufs(CXzEnc *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]);
@@ -1027,10 +987,10 @@ static void XzEnc_Free(CXzEnc *p, ISzAllocPtr alloc)
 
   XzEncIndex_Free(&p->xzIndex, alloc);
 
-  for (i = 0; i < MTCODER_THREADS_MAX; i++)
+  for (i = 0; i < MTCODER__THREADS_MAX; i++)
     Lzma2WithFilters_Free(&p->lzmaf_Items[i], alloc);
   
-  #ifndef Z7_ST
+  #ifndef _7ZIP_ST
   if (p->mtCoder_WasConstructed)
   {
     MtCoder_Destruct(&p->mtCoder);
@@ -1052,38 +1012,37 @@ CXzEncHandle XzEnc_Create(ISzAllocPtr alloc, ISzAllocPtr allocBig)
   p->expectedDataSize = (UInt64)(Int64)-1;
   p->alloc = alloc;
   p->allocBig = allocBig;
-  return (CXzEncHandle)p;
+  return p;
 }
 
-// #define GET_CXzEnc_p  CXzEnc *p = (CXzEnc *)(void *)pp;
 
-void XzEnc_Destroy(CXzEncHandle p)
+void XzEnc_Destroy(CXzEncHandle pp)
 {
-  // GET_CXzEnc_p
+  CXzEnc *p = (CXzEnc *)pp;
   XzEnc_Free(p, p->alloc);
   ISzAlloc_Free(p->alloc, p);
 }
 
 
-SRes XzEnc_SetProps(CXzEncHandle p, const CXzProps *props)
+SRes XzEnc_SetProps(CXzEncHandle pp, const CXzProps *props)
 {
-  // GET_CXzEnc_p
+  CXzEnc *p = (CXzEnc *)pp;
   p->xzProps = *props;
   XzProps_Normalize(&p->xzProps);
   return SZ_OK;
 }
 
 
-void XzEnc_SetDataSize(CXzEncHandle p, UInt64 expectedDataSiize)
+void XzEnc_SetDataSize(CXzEncHandle pp, UInt64 expectedDataSiize)
 {
-  // GET_CXzEnc_p
+  CXzEnc *p = (CXzEnc *)pp;
   p->expectedDataSize = expectedDataSiize;
 }
 
 
 
 
-#ifndef Z7_ST
+#ifndef _7ZIP_ST
 
 static SRes XzEnc_MtCallback_Code(void *pp, unsigned coderIndex, unsigned outBufIndex,
     const Byte *src, size_t srcSize, int finished)
@@ -1091,19 +1050,18 @@ static SRes XzEnc_MtCallback_Code(void *pp, unsigned coderIndex, unsigned outBuf
   CXzEnc *me = (CXzEnc *)pp;
   SRes res;
   CMtProgressThunk progressThunk;
-  Byte *dest;
+
+  Byte *dest = me->outBufs[outBufIndex];
+
   UNUSED_VAR(finished)
+
   {
     CXzEncBlockInfo *bInfo = &me->EncBlocks[outBufIndex];
     bInfo->totalSize = 0;
     bInfo->unpackSize = 0;
     bInfo->headerSize = 0;
-    // v23.02: we don't compress empty blocks
-    // also we must ignore that empty block in XzEnc_MtCallback_Write()
-    if (srcSize == 0)
-      return SZ_OK;
   }
-  dest = me->outBufs[outBufIndex];
+
   if (!dest)
   {
     dest = (Byte *)ISzAlloc_Alloc(me->alloc, me->outBufSize);
@@ -1114,7 +1072,7 @@ static SRes XzEnc_MtCallback_Code(void *pp, unsigned coderIndex, unsigned outBuf
   
   MtProgressThunk_CreateVTable(&progressThunk);
   progressThunk.mtProgress = &me->mtCoder.mtProgress;
-  MtProgressThunk_INIT(&progressThunk)
+  MtProgressThunk_Init(&progressThunk);
 
   {
     CXzEncBlockInfo blockSizes;
@@ -1149,45 +1107,36 @@ static SRes XzEnc_MtCallback_Code(void *pp, unsigned coderIndex, unsigned outBuf
 static SRes XzEnc_MtCallback_Write(void *pp, unsigned outBufIndex)
 {
   CXzEnc *me = (CXzEnc *)pp;
+
   const CXzEncBlockInfo *bInfo = &me->EncBlocks[outBufIndex];
-  // v23.02: we don't write empty blocks
-  // note: if (bInfo->unpackSize == 0) then there is no compressed data of block
-  if (bInfo->unpackSize == 0)
-    return SZ_OK;
+  const Byte *data = me->outBufs[outBufIndex];
+
+  RINOK(WriteBytes(me->outStream, data, bInfo->headerSize));
+
   {
-    const Byte *data = me->outBufs[outBufIndex];
-    RINOK(WriteBytes(me->outStream, data, bInfo->headerSize))
-    {
-      const UInt64 totalPackFull = bInfo->totalSize + XZ_GET_PAD_SIZE(bInfo->totalSize);
-      RINOK(WriteBytes(me->outStream, data + XZ_BLOCK_HEADER_SIZE_MAX, (size_t)totalPackFull - bInfo->headerSize))
-    }
-    return XzEncIndex_AddIndexRecord(&me->xzIndex, bInfo->unpackSize, bInfo->totalSize, me->alloc);
+    UInt64 totalPackFull = bInfo->totalSize + XZ_GET_PAD_SIZE(bInfo->totalSize);
+    RINOK(WriteBytes(me->outStream, data + XZ_BLOCK_HEADER_SIZE_MAX, (size_t)totalPackFull - bInfo->headerSize));
   }
+
+  return XzEncIndex_AddIndexRecord(&me->xzIndex, bInfo->unpackSize, bInfo->totalSize, me->alloc);
 }
 
 #endif
 
 
 
-SRes XzEnc_Encode(CXzEncHandle p, ISeqOutStreamPtr outStream, ISeqInStreamPtr inStream, ICompressProgressPtr progress)
+SRes XzEnc_Encode(CXzEncHandle pp, ISeqOutStream *outStream, ISeqInStream *inStream, ICompressProgress *progress)
 {
-    return XzEnc_Encode_Part(p,outStream,inStream,progress,1,1);
-}
-
-SRes XzEnc_Encode_Part(CXzEncHandle p, ISeqOutStreamPtr outStream, ISeqInStreamPtr inStream,
-                       ICompressProgressPtr progress,int isWriteHead,int isWriteFooter)
-{
-  // GET_CXzEnc_p
+  CXzEnc *p = (CXzEnc *)pp;
 
   const CXzProps *props = &p->xzProps;
 
- if (isWriteHead){
   XzEncIndex_Init(&p->xzIndex);
   {
     UInt64 numBlocks = 1;
     UInt64 blockSize = props->blockSize;
     
-    if (blockSize != XZ_PROPS_BLOCK_SIZE_SOLID
+    if (blockSize != XZ_PROPS__BLOCK_SIZE__SOLID
         && props->reduceSize != (UInt64)(Int64)-1)
     {
       numBlocks = props->reduceSize / blockSize;
@@ -1197,13 +1146,13 @@ SRes XzEnc_Encode_Part(CXzEncHandle p, ISeqOutStreamPtr outStream, ISeqInStreamP
     else
       blockSize = (UInt64)1 << 62;
     
-    RINOK(XzEncIndex_PreAlloc(&p->xzIndex, numBlocks, blockSize, XZ_GET_ESTIMATED_BLOCK_TOTAL_PACK_SIZE(blockSize), p->alloc))
+    RINOK(XzEncIndex_PreAlloc(&p->xzIndex, numBlocks, blockSize, XZ_GET_ESTIMATED_BLOCK_TOTAL_PACK_SIZE(blockSize), p->alloc));
   }
 
-  RINOK(Xz_WriteHeader((CXzStreamFlags)props->checkId, outStream))
- }//isWriteHead
+  RINOK(Xz_WriteHeader((CXzStreamFlags)props->checkId, outStream));
+
 
-  #ifndef Z7_ST
+  #ifndef _7ZIP_ST
   if (props->numBlockThreads_Reduced > 1)
   {
     IMtCoderCallback2 vt;
@@ -1230,8 +1179,8 @@ SRes XzEnc_Encode_Part(CXzEncHandle p, ISeqOutStreamPtr outStream, ISeqInStreamP
     p->mtCoder.mtCallback = &vt;
     p->mtCoder.mtCallbackObject = p;
 
-    if (   props->blockSize == XZ_PROPS_BLOCK_SIZE_SOLID
-        || props->blockSize == XZ_PROPS_BLOCK_SIZE_AUTO)
+    if (   props->blockSize == XZ_PROPS__BLOCK_SIZE__SOLID
+        || props->blockSize == XZ_PROPS__BLOCK_SIZE__AUTO)
       return SZ_ERROR_FAIL;
 
     p->mtCoder.blockSize = (size_t)props->blockSize;
@@ -1247,11 +1196,10 @@ SRes XzEnc_Encode_Part(CXzEncHandle p, ISeqOutStreamPtr outStream, ISeqInStreamP
       p->outBufSize = destBlockSize;
     }
 
-    p->mtCoder.numThreadsMax = (unsigned)props->numBlockThreads_Max;
-    p->mtCoder.numThreadGroups = props->numThreadGroups;
+    p->mtCoder.numThreadsMax = props->numBlockThreads_Max;
     p->mtCoder.expectedDataSize = p->expectedDataSize;
     
-    RINOK(MtCoder_Code(&p->mtCoder))
+    RINOK(MtCoder_Code(&p->mtCoder));
   }
   else
   #endif
@@ -1268,7 +1216,7 @@ SRes XzEnc_Encode_Part(CXzEncHandle p, ISeqOutStreamPtr outStream, ISeqInStreamP
     
     writeStartSizes = 0;
     
-    if (props->blockSize != XZ_PROPS_BLOCK_SIZE_SOLID)
+    if (props->blockSize != XZ_PROPS__BLOCK_SIZE__SOLID)
     {
       writeStartSizes = (props->forceWriteSizesInHeader > 0);
       
@@ -1325,18 +1273,18 @@ SRes XzEnc_Encode_Part(CXzEncHandle p, ISeqOutStreamPtr outStream, ISeqInStreamP
           &inStreamFinished,
           &blockSizes,
           p->alloc,
-          p->allocBig))
+          p->allocBig));
 
       {
         UInt64 totalPackFull = blockSizes.totalSize + XZ_GET_PAD_SIZE(blockSizes.totalSize);
       
         if (writeStartSizes)
         {
-          RINOK(WriteBytes(outStream, p->outBufs[0], blockSizes.headerSize))
-          RINOK(WriteBytes(outStream, bufData, (size_t)totalPackFull - blockSizes.headerSize))
+          RINOK(WriteBytes(outStream, p->outBufs[0], blockSizes.headerSize));
+          RINOK(WriteBytes(outStream, bufData, (size_t)totalPackFull - blockSizes.headerSize));
         }
         
-        RINOK(XzEncIndex_AddIndexRecord(&p->xzIndex, blockSizes.unpackSize, blockSizes.totalSize, p->alloc))
+        RINOK(XzEncIndex_AddIndexRecord(&p->xzIndex, blockSizes.unpackSize, blockSizes.totalSize, p->alloc));
         
         progress2.inOffset += blockSizes.unpackSize;
         progress2.outOffset += totalPackFull;
@@ -1347,17 +1295,14 @@ SRes XzEnc_Encode_Part(CXzEncHandle p, ISeqOutStreamPtr outStream, ISeqInStreamP
     }
   }
 
- if (isWriteFooter)
   return XzEncIndex_WriteFooter(&p->xzIndex, (CXzStreamFlags)props->checkId, outStream);
- else
-  return SZ_OK;
 }
 
 
 #include "Alloc.h"
 
-SRes Xz_Encode(ISeqOutStreamPtr outStream, ISeqInStreamPtr inStream,
-    const CXzProps *props, ICompressProgressPtr progress)
+SRes Xz_Encode(ISeqOutStream *outStream, ISeqInStream *inStream,
+    const CXzProps *props, ICompressProgress *progress)
 {
   SRes res;
   CXzEncHandle xz = XzEnc_Create(&g_Alloc, &g_BigAlloc);
@@ -1371,7 +1316,7 @@ SRes Xz_Encode(ISeqOutStreamPtr outStream, ISeqInStreamPtr inStream,
 }
 
 
-SRes Xz_EncodeEmpty(ISeqOutStreamPtr outStream)
+SRes Xz_EncodeEmpty(ISeqOutStream *outStream)
 {
   SRes res;
   CXzEncIndex xzIndex;