react-native-update 10.34.3 → 10.34.4

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

@@ -1,30 +1,30 @@
 /* MtCoder.h -- Multi-thread Coder
-: Igor Pavlov : Public domain */
+2018-07-04 : Igor Pavlov : Public domain */
 
-#ifndef ZIP7_INC_MT_CODER_H
-#define ZIP7_INC_MT_CODER_H
+#ifndef __MT_CODER_H
+#define __MT_CODER_H
 
 #include "MtDec.h"
 
 EXTERN_C_BEGIN
 
 /*
-  if (    defined MTCODER_USE_WRITE_THREAD) : main thread writes all data blocks to output stream
-  if (not defined MTCODER_USE_WRITE_THREAD) : any coder thread can write data blocks to output stream
+  if (    defined MTCODER__USE_WRITE_THREAD) : main thread writes all data blocks to output stream
+  if (not defined MTCODER__USE_WRITE_THREAD) : any coder thread can write data blocks to output stream
 */
-/* #define MTCODER_USE_WRITE_THREAD */
+/* #define MTCODER__USE_WRITE_THREAD */
 
-#ifndef Z7_ST
-  #define MTCODER_GET_NUM_BLOCKS_FROM_THREADS(numThreads) ((numThreads) + (numThreads) / 8 + 1)
-  #define MTCODER_THREADS_MAX 256
-  #define MTCODER_BLOCKS_MAX (MTCODER_GET_NUM_BLOCKS_FROM_THREADS(MTCODER_THREADS_MAX) + 3)
+#ifndef _7ZIP_ST
+  #define MTCODER__GET_NUM_BLOCKS_FROM_THREADS(numThreads) ((numThreads) + (numThreads) / 8 + 1)
+  #define MTCODER__THREADS_MAX 64
+  #define MTCODER__BLOCKS_MAX (MTCODER__GET_NUM_BLOCKS_FROM_THREADS(MTCODER__THREADS_MAX) + 3)
 #else
-  #define MTCODER_THREADS_MAX 1
-  #define MTCODER_BLOCKS_MAX 1
+  #define MTCODER__THREADS_MAX 1
+  #define MTCODER__BLOCKS_MAX 1
 #endif
 
 
-#ifndef Z7_ST
+#ifndef _7ZIP_ST
 
 
 typedef struct
@@ -37,15 +37,15 @@ typedef struct
 
 void MtProgressThunk_CreateVTable(CMtProgressThunk *p);
     
-#define MtProgressThunk_INIT(p) { (p)->inSize = 0; (p)->outSize = 0; }
+#define MtProgressThunk_Init(p) { (p)->inSize = 0; (p)->outSize = 0; }
 
 
-struct CMtCoder_;
+struct _CMtCoder;
 
 
 typedef struct
 {
-  struct CMtCoder_ *mtCoder;
+  struct _CMtCoder *mtCoder;
   unsigned index;
   int stop;
   Byte *inBuf;
@@ -71,20 +71,19 @@ typedef struct
 } CMtCoderBlock;
 
 
-typedef struct CMtCoder_
+typedef struct _CMtCoder
 {
   /* input variables */
   
   size_t blockSize;        /* size of input block */
   unsigned numThreadsMax;
-  unsigned numThreadGroups;
   UInt64 expectedDataSize;
 
-  ISeqInStreamPtr inStream;
+  ISeqInStream *inStream;
   const Byte *inData;
   size_t inDataSize;
 
-  ICompressProgressPtr progress;
+  ICompressProgress *progress;
   ISzAllocPtr allocBig;
 
   IMtCoderCallback2 *mtCallback;
@@ -101,13 +100,13 @@ typedef struct CMtCoder_
   BoolInt stopReading;
   SRes readRes;
 
-  #ifdef MTCODER_USE_WRITE_THREAD
-    CAutoResetEvent writeEvents[MTCODER_BLOCKS_MAX];
+  #ifdef MTCODER__USE_WRITE_THREAD
+    CAutoResetEvent writeEvents[MTCODER__BLOCKS_MAX];
   #else
     CAutoResetEvent finishedEvent;
     SRes writeRes;
     unsigned writeIndex;
-    Byte ReadyBlocks[MTCODER_BLOCKS_MAX];
+    Byte ReadyBlocks[MTCODER__BLOCKS_MAX];
     LONG numFinishedThreads;
   #endif
 
@@ -121,13 +120,11 @@ typedef struct CMtCoder_
   CCriticalSection cs;
 
   unsigned freeBlockHead;
-  unsigned freeBlockList[MTCODER_BLOCKS_MAX];
+  unsigned freeBlockList[MTCODER__BLOCKS_MAX];
 
   CMtProgress mtProgress;
-  CMtCoderBlock blocks[MTCODER_BLOCKS_MAX];
-  CMtCoderThread threads[MTCODER_THREADS_MAX];
-
-  CThreadNextGroup nextGroup;
+  CMtCoderBlock blocks[MTCODER__BLOCKS_MAX];
+  CMtCoderThread threads[MTCODER__THREADS_MAX];
 } CMtCoder;
 
 

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

@@ -1,21 +1,16 @@
 /* MtDec.c -- Multi-thread Decoder
-2024-02-20 : Igor Pavlov : Public domain */
+2019-02-02 : Igor Pavlov : Public domain */
 
 #include "Precomp.h"
 
 // #define SHOW_DEBUG_INFO
 
 // #include <stdio.h>
-#include <string.h>
 
 #ifdef SHOW_DEBUG_INFO
 #include <stdio.h>
 #endif
 
-#include "MtDec.h"
-
-#ifndef Z7_ST
-
 #ifdef SHOW_DEBUG_INFO
 #define PRF(x) x
 #else
@@ -24,7 +19,11 @@
 
 #define PRF_STR_INT(s, d) PRF(printf("\n" s " %d\n", (unsigned)d))
 
-void MtProgress_Init(CMtProgress *p, ICompressProgressPtr progress)
+#include "MtDec.h"
+
+#ifndef _7ZIP_ST
+
+void MtProgress_Init(CMtProgress *p, ICompressProgress *progress)
 {
   p->progress = progress;
   p->res = SZ_OK;
@@ -78,31 +77,39 @@ void MtProgress_SetError(CMtProgress *p, SRes res)
 }
 
 
-#define RINOK_THREAD(x) RINOK_WRes(x)
+#define RINOK_THREAD(x) RINOK(x)
+
+
+static WRes ArEvent_OptCreate_And_Reset(CEvent *p)
+{
+  if (Event_IsCreated(p))
+    return Event_Reset(p);
+  return AutoResetEvent_CreateNotSignaled(p);
+}
 
 
-struct CMtDecBufLink_
+struct __CMtDecBufLink
 {
-  struct CMtDecBufLink_ *next;
+  struct __CMtDecBufLink *next;
   void *pad[3];
 };
 
-typedef struct CMtDecBufLink_ CMtDecBufLink;
+typedef struct __CMtDecBufLink CMtDecBufLink;
 
 #define MTDEC__LINK_DATA_OFFSET sizeof(CMtDecBufLink)
 #define MTDEC__DATA_PTR_FROM_LINK(link) ((Byte *)(link) + MTDEC__LINK_DATA_OFFSET)
 
 
 
-static THREAD_FUNC_DECL MtDec_ThreadFunc(void *pp);
+static THREAD_FUNC_RET_TYPE THREAD_FUNC_CALL_TYPE ThreadFunc(void *pp);
 
 
 static WRes MtDecThread_CreateEvents(CMtDecThread *t)
 {
-  WRes wres = AutoResetEvent_OptCreate_And_Reset(&t->canWrite);
+  WRes wres = ArEvent_OptCreate_And_Reset(&t->canWrite);
   if (wres == 0)
   {
-    wres = AutoResetEvent_OptCreate_And_Reset(&t->canRead);
+    wres = ArEvent_OptCreate_And_Reset(&t->canRead);
     if (wres == 0)
       return SZ_OK;
   }
@@ -118,7 +125,7 @@ static SRes MtDecThread_CreateAndStart(CMtDecThread *t)
   {
     if (Thread_WasCreated(&t->thread))
       return SZ_OK;
-    wres = Thread_Create(&t->thread, MtDec_ThreadFunc, t);
+    wres = Thread_Create(&t->thread, ThreadFunc, t);
     if (wres == 0)
       return SZ_OK;
   }
@@ -149,7 +156,8 @@ static void MtDecThread_CloseThread(CMtDecThread *t)
   {
     Event_Set(&t->canWrite); /* we can disable it. There are no threads waiting canWrite in normal cases */
     Event_Set(&t->canRead);
-    Thread_Wait_Close(&t->thread);
+    Thread_Wait(&t->thread);
+    Thread_Close(&t->thread);
   }
 
   Event_Close(&t->canRead);
@@ -159,7 +167,7 @@ static void MtDecThread_CloseThread(CMtDecThread *t)
 static void MtDec_CloseThreads(CMtDec *p)
 {
   unsigned i;
-  for (i = 0; i < MTDEC_THREADS_MAX; i++)
+  for (i = 0; i < MTDEC__THREADS_MAX; i++)
     MtDecThread_CloseThread(&p->threads[i]);
 }
 
@@ -171,6 +179,25 @@ static void MtDecThread_Destruct(CMtDecThread *t)
 
 
 
+static SRes FullRead(ISeqInStream *stream, Byte *data, size_t *processedSize)
+{
+  size_t size = *processedSize;
+  *processedSize = 0;
+  while (size != 0)
+  {
+    size_t cur = size;
+    SRes res = ISeqInStream_Read(stream, data, &cur);
+    *processedSize += cur;
+    data += cur;
+    size -= cur;
+    RINOK(res);
+    if (cur == 0)
+      return SZ_OK;
+  }
+  return SZ_OK;
+}
+
+
 static SRes MtDec_GetError_Spec(CMtDec *p, UInt64 interruptIndex, BoolInt *wasInterrupted)
 {
   SRes res;
@@ -226,7 +253,7 @@ Byte *MtDec_GetCrossBuff(CMtDec *p)
 
 
 /*
-  MtDec_ThreadFunc2() returns:
+  ThreadFunc2() returns:
   0      - in all normal cases (even for stream error or memory allocation error)
   (!= 0) - WRes error return by system threading function
 */
@@ -234,11 +261,11 @@ Byte *MtDec_GetCrossBuff(CMtDec *p)
 // #define MTDEC_ProgessStep (1 << 22)
 #define MTDEC_ProgessStep (1 << 0)
 
-static WRes MtDec_ThreadFunc2(CMtDecThread *t)
+static WRes ThreadFunc2(CMtDecThread *t)
 {
   CMtDec *p = t->mtDec;
 
-  PRF_STR_INT("MtDec_ThreadFunc2", t->index)
+  PRF_STR_INT("ThreadFunc2", t->index);
 
   // SetThreadAffinityMask(GetCurrentThread(), 1 << t->index);
 
@@ -262,19 +289,18 @@ static WRes MtDec_ThreadFunc2(CMtDecThread *t)
     
     Byte *afterEndData = NULL;
     size_t afterEndData_Size = 0;
-    BoolInt afterEndData_IsCross = False;
 
     BoolInt canCreateNewThread = False;
     // CMtDecCallbackInfo parse;
     CMtDecThread *nextThread;
 
-    PRF_STR_INT("=============== Event_Wait(&t->canRead)", t->index)
+    PRF_STR_INT("Event_Wait(&t->canRead)", t->index);
 
-    RINOK_THREAD(Event_Wait(&t->canRead))
+    RINOK_THREAD(Event_Wait(&t->canRead));
     if (p->exitThread)
       return 0;
 
-    PRF_STR_INT("after Event_Wait(&t->canRead)", t->index)
+    PRF_STR_INT("after Event_Wait(&t->canRead)", t->index);
 
     // if (t->index == 3) return 19; // for test
 
@@ -346,7 +372,7 @@ static WRes MtDec_ThreadFunc2(CMtDecThread *t)
             {
               size = p->inBufSize;
               
-              res = SeqInStream_ReadMax(p->inStream, data, &size);
+              res = FullRead(p->inStream, data, &size);
               
               // size = 10; // test
 
@@ -392,12 +418,10 @@ static WRes MtDec_ThreadFunc2(CMtDecThread *t)
               parse.srcFinished = finish;
               parse.canCreateNewThread = True;
 
-              PRF(printf("\nParse size = %d\n", (unsigned)size));
+              // PRF(printf("\nParse size = %d\n", (unsigned)size))
 
               p->mtCallback->Parse(p->mtCallbackObject, t->index, &parse);
 
-              PRF(printf("   Parse processed = %d, state = %d \n", (unsigned)parse.srcSize, (unsigned)parse.state));
-
               needWrite = True;
               canCreateNewThread = parse.canCreateNewThread;
 
@@ -454,12 +478,16 @@ static WRes MtDec_ThreadFunc2(CMtDecThread *t)
 
                 if (parse.state == MTDEC_PARSE_END)
                 {
-                  afterEndData = parseData + parse.srcSize;
-                  afterEndData_Size = size - parse.srcSize;
+                  p->crossStart = 0;
+                  p->crossEnd = 0;
+
                   if (crossSize != 0)
-                    afterEndData_IsCross = True;
+                    memcpy(data + parse.srcSize, parseData + parse.srcSize, size - parse.srcSize); // we need all data
+                  afterEndData_Size = size - parse.srcSize;
+                  afterEndData = parseData + parse.srcSize;
+
                   // we reduce data size to required bytes (parsed only)
-                  inDataSize -= afterEndData_Size;
+                  inDataSize -= (size - parse.srcSize);
                   if (!prev)
                     inDataSize_Start = parse.srcSize;
                   break;
@@ -588,7 +616,7 @@ static WRes MtDec_ThreadFunc2(CMtDecThread *t)
     // if ( !finish ) we must call Event_Set(&nextThread->canWrite) in any case
     // if (  finish ) we switch to single-thread mode and there are 2 ways at the end of current iteration (current block):
     //   - if (needContinue) after Write(&needContinue), we restore decoding with new iteration
-    //   - otherwise we stop decoding and exit from MtDec_ThreadFunc2()
+    //   - otherwise we stop decoding and exit from ThreadFunc2()
 
     // Don't change (finish) variable in the further code
 
@@ -661,7 +689,7 @@ static WRes MtDec_ThreadFunc2(CMtDecThread *t)
 
     // ---------- WRITE ----------
    
-    RINOK_THREAD(Event_Wait(&t->canWrite))
+    RINOK_THREAD(Event_Wait(&t->canWrite));
 
   {
     BoolInt isErrorMode = False;
@@ -724,15 +752,13 @@ static WRes MtDec_ThreadFunc2(CMtDecThread *t)
     {
       // p->inProcessed += inCodePos;
 
-      PRF(printf("\n--Write afterSize = %d\n", (unsigned)afterEndData_Size));
-
       res = p->mtCallback->Write(p->mtCallbackObject, t->index,
           res == SZ_OK && needWriteToStream && !wasInterrupted, // needWrite
-          afterEndData, afterEndData_Size, afterEndData_IsCross,
+          afterEndData, afterEndData_Size,
           &needContinue,
           &canRecode);
-
-      // res = SZ_ERROR_FAIL; // for test
+      
+      // res= E_INVALIDARG; // for test
 
       PRF(printf("\nAfter Write needContinue = %d\n", (unsigned)needContinue));
       PRF(printf("\nprocessed = %d\n", (unsigned)p->inProcessed));
@@ -774,14 +800,14 @@ static WRes MtDec_ThreadFunc2(CMtDecThread *t)
 
     if (!finish)
     {
-      RINOK_THREAD(Event_Set(&nextThread->canWrite))
+      RINOK_THREAD(Event_Set(&nextThread->canWrite));
     }
     else
     {
       if (needContinue)
       {
         // we restore decoding with new iteration
-        RINOK_THREAD(Event_Set(&p->threads[0].canWrite))
+        RINOK_THREAD(Event_Set(&p->threads[0].canWrite));
       }
       else
       {
@@ -790,7 +816,7 @@ static WRes MtDec_ThreadFunc2(CMtDecThread *t)
           return SZ_OK;
         p->exitThread = True;
       }
-      RINOK_THREAD(Event_Set(&p->threads[0].canRead))
+      RINOK_THREAD(Event_Set(&p->threads[0].canRead));
     }
   }
   }
@@ -809,17 +835,7 @@ static WRes MtDec_ThreadFunc2(CMtDecThread *t)
 #endif
 
 
-typedef
-  #ifdef _WIN32
-    UINT_PTR
-  #elif 1
-    uintptr_t
-  #else
-    ptrdiff_t
-  #endif
-    MY_uintptr_t;
-
-static THREAD_FUNC_DECL MtDec_ThreadFunc1(void *pp)
+static THREAD_FUNC_RET_TYPE THREAD_FUNC_CALL_TYPE ThreadFunc1(void *pp)
 {
   WRes res;
 
@@ -828,10 +844,10 @@ static THREAD_FUNC_DECL MtDec_ThreadFunc1(void *pp)
 
   // fprintf(stdout, "\n%d = %p\n", t->index, &t);
 
-  res = MtDec_ThreadFunc2(t);
+  res = ThreadFunc2(t);
   p = t->mtDec;
   if (res == 0)
-    return (THREAD_FUNC_RET_TYPE)(MY_uintptr_t)p->exitThreadWRes;
+    return p->exitThreadWRes;
   {
     // it's unexpected situation for some threading function error
     if (p->exitThreadWRes == 0)
@@ -842,17 +858,18 @@ static THREAD_FUNC_DECL MtDec_ThreadFunc1(void *pp)
     Event_Set(&p->threads[0].canWrite);
     MtProgress_SetError(&p->mtProgress, MY_SRes_HRESULT_FROM_WRes(res));
   }
-  return (THREAD_FUNC_RET_TYPE)(MY_uintptr_t)res;
+  return res;
 }
 
-static Z7_NO_INLINE THREAD_FUNC_DECL MtDec_ThreadFunc(void *pp)
+static MY_NO_INLINE THREAD_FUNC_RET_TYPE THREAD_FUNC_CALL_TYPE ThreadFunc(void *pp)
 {
-  #ifdef USE_ALLOCA
   CMtDecThread *t = (CMtDecThread *)pp;
+
   // fprintf(stderr, "\n%d = %p - before", t->index, &t);
+  #ifdef USE_ALLOCA
   t->allocaPtr = alloca(t->index * 128);
   #endif
-  return MtDec_ThreadFunc1(pp);
+  return ThreadFunc1(pp);
 }
 
 
@@ -866,7 +883,7 @@ int MtDec_PrepareRead(CMtDec *p)
     
   {
     unsigned i;
-    for (i = 0; i < MTDEC_THREADS_MAX; i++)
+    for (i = 0; i < MTDEC__THREADS_MAX; i++)
       if (i > p->numStartedThreads
           || p->numFilledThreads <=
             (i >= p->filledThreadStart ?
@@ -970,7 +987,7 @@ void MtDec_Construct(CMtDec *p)
 
   p->allocatedBufsSize = 0;
 
-  for (i = 0; i < MTDEC_THREADS_MAX; i++)
+  for (i = 0; i < MTDEC__THREADS_MAX; i++)
   {
     CMtDecThread *t = &p->threads[i];
     t->mtDec = p;
@@ -978,7 +995,7 @@ void MtDec_Construct(CMtDec *p)
     t->inBuf = NULL;
     Event_Construct(&t->canRead);
     Event_Construct(&t->canWrite);
-    Thread_CONSTRUCT(&t->thread)
+    Thread_Construct(&t->thread);
   }
 
   // Event_Construct(&p->finishedEvent);
@@ -993,7 +1010,7 @@ static void MtDec_Free(CMtDec *p)
 
   p->exitThread = True;
 
-  for (i = 0; i < MTDEC_THREADS_MAX; i++)
+  for (i = 0; i < MTDEC__THREADS_MAX; i++)
     MtDecThread_Destruct(&p->threads[i]);
 
   // Event_Close(&p->finishedEvent);
@@ -1044,15 +1061,15 @@ SRes MtDec_Code(CMtDec *p)
 
   {
     unsigned numThreads = p->numThreadsMax;
-    if (numThreads > MTDEC_THREADS_MAX)
-      numThreads = MTDEC_THREADS_MAX;
+    if (numThreads > MTDEC__THREADS_MAX)
+      numThreads = MTDEC__THREADS_MAX;
     p->numStartedThreads_Limit = numThreads;
     p->numStartedThreads = 0;
   }
 
   if (p->inBufSize != p->allocatedBufsSize)
   {
-    for (i = 0; i < MTDEC_THREADS_MAX; i++)
+    for (i = 0; i < MTDEC__THREADS_MAX; i++)
     {
       CMtDecThread *t = &p->threads[i];
       if (t->inBuf)
@@ -1069,20 +1086,19 @@ SRes MtDec_Code(CMtDec *p)
 
   MtProgress_Init(&p->mtProgress, p->progress);
 
-  // RINOK_THREAD(AutoResetEvent_OptCreate_And_Reset(&p->finishedEvent))
+  // RINOK_THREAD(ArEvent_OptCreate_And_Reset(&p->finishedEvent));
   p->exitThread = False;
   p->exitThreadWRes = 0;
 
   {
     WRes wres;
-    SRes sres;
+    WRes sres;
     CMtDecThread *nextThread = &p->threads[p->numStartedThreads++];
     // wres = MtDecThread_CreateAndStart(nextThread);
     wres = MtDecThread_CreateEvents(nextThread);
     if (wres == 0) { wres = Event_Set(&nextThread->canWrite);
     if (wres == 0) { wres = Event_Set(&nextThread->canRead);
-    if (wres == 0) { THREAD_FUNC_RET_TYPE res = MtDec_ThreadFunc(nextThread);
-    wres = (WRes)(MY_uintptr_t)res;
+    if (wres == 0) { wres = ThreadFunc(nextThread);
     if (wres != 0)
     {
       p->needContinue = False;
@@ -1114,11 +1130,9 @@ SRes MtDec_Code(CMtDec *p)
       return SZ_OK;
 
     // if (sres != SZ_OK)
-    return sres;
-    // return SZ_ERROR_FAIL;
+      return sres;
+    // return E_FAIL;
   }
 }
 
 #endif
-
-#undef PRF

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

@@ -1,46 +1,46 @@
 /* MtDec.h -- Multi-thread Decoder
-2023-04-02 : Igor Pavlov : Public domain */
+2018-07-04 : Igor Pavlov : Public domain */
 
-#ifndef ZIP7_INC_MT_DEC_H
-#define ZIP7_INC_MT_DEC_H
+#ifndef __MT_DEC_H
+#define __MT_DEC_H
 
 #include "7zTypes.h"
 
-#ifndef Z7_ST
+#ifndef _7ZIP_ST
 #include "Threads.h"
 #endif
 
 EXTERN_C_BEGIN
 
-#ifndef Z7_ST
+#ifndef _7ZIP_ST
 
-#ifndef Z7_ST
-  #define MTDEC_THREADS_MAX 32
+#ifndef _7ZIP_ST
+  #define MTDEC__THREADS_MAX 32
 #else
-  #define MTDEC_THREADS_MAX 1
+  #define MTDEC__THREADS_MAX 1
 #endif
 
 
 typedef struct
 {
-  ICompressProgressPtr progress;
+  ICompressProgress *progress;
   SRes res;
   UInt64 totalInSize;
   UInt64 totalOutSize;
   CCriticalSection cs;
 } CMtProgress;
 
-void MtProgress_Init(CMtProgress *p, ICompressProgressPtr progress);
+void MtProgress_Init(CMtProgress *p, ICompressProgress *progress);
 SRes MtProgress_Progress_ST(CMtProgress *p);
 SRes MtProgress_ProgressAdd(CMtProgress *p, UInt64 inSize, UInt64 outSize);
 SRes MtProgress_GetError(CMtProgress *p);
 void MtProgress_SetError(CMtProgress *p, SRes res);
 
-typedef struct CMtDec_ CMtDec;
+struct _CMtDec;
 
 typedef struct
 {
-  struct CMtDec_ *mtDec;
+  struct _CMtDec *mtDec;
   unsigned index;
   void *inBuf;
 
@@ -108,16 +108,15 @@ typedef struct
   */
   SRes (*Write)(void *p, unsigned coderIndex,
       BoolInt needWriteToStream,
-      const Byte *src, size_t srcSize, BoolInt isCross,
+      const Byte *src, size_t srcSize,
       // int srcFinished,
       BoolInt *needContinue,
       BoolInt *canRecode);
+} IMtDecCallback;
 
-} IMtDecCallback2;
 
 
-
-typedef struct CMtDec_
+typedef struct _CMtDec
 {
   /* input variables */
   
@@ -126,14 +125,14 @@ typedef struct CMtDec_
   // size_t inBlockMax;
   unsigned numThreadsMax_2;
 
-  ISeqInStreamPtr inStream;
+  ISeqInStream *inStream;
   // const Byte *inData;
   // size_t inDataSize;
 
-  ICompressProgressPtr progress;
+  ICompressProgress *progress;
   ISzAllocPtr alloc;
 
-  IMtDecCallback2 *mtCallback;
+  IMtDecCallback *mtCallback;
   void *mtCallbackObject;
 
   
@@ -171,11 +170,11 @@ typedef struct CMtDec_
   unsigned filledThreadStart;
   unsigned numFilledThreads;
 
-  #ifndef Z7_ST
+  #ifndef _7ZIP_ST
   BoolInt needInterrupt;
   UInt64 interruptIndex;
   CMtProgress mtProgress;
-  CMtDecThread threads[MTDEC_THREADS_MAX];
+  CMtDecThread threads[MTDEC__THREADS_MAX];
   #endif
 } CMtDec;