react-native-update 10.34.3 → 10.34.4

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

@@ -1,8 +1,8 @@
 /*  LzmaEnc.h -- LZMA Encoder
-: Igor Pavlov : Public domain */
+2017-07-27 : Igor Pavlov : Public domain */
 
-#ifndef ZIP7_INC_LZMA_ENC_H
-#define ZIP7_INC_LZMA_ENC_H
+#ifndef __LZMA_ENC_H
+#define __LZMA_ENC_H
 
 #include "7zTypes.h"
 
@@ -10,7 +10,7 @@ EXTERN_C_BEGIN
 
 #define LZMA_PROPS_SIZE 5
 
-typedef struct
+typedef struct _CLzmaEncProps
 {
   int level;       /* 0 <= level <= 9 */
   UInt32 dictSize; /* (1 << 12) <= dictSize <= (1 << 27) for 32-bit version
@@ -23,19 +23,12 @@ typedef struct
   int fb;          /* 5 <= fb <= 273, default = 32 */
   int btMode;      /* 0 - hashChain Mode, 1 - binTree mode - normal, default = 1 */
   int numHashBytes; /* 2, 3 or 4, default = 4 */
-  unsigned numHashOutBits;  /* default = ? */
   UInt32 mc;       /* 1 <= mc <= (1 << 30), default = 32 */
   unsigned writeEndMark;  /* 0 - do not write EOPM, 1 - write EOPM, default = 0 */
   int numThreads;  /* 1 or 2, default = 2 */
 
-  // int _pad;
-  Int32 affinityGroup;
-
   UInt64 reduceSize; /* estimated size of data that will be compressed. default = (UInt64)(Int64)-1.
                         Encoder uses this value to reduce dictionary size */
-
-  UInt64 affinity;
-  UInt64 affinityInGroup;
 } CLzmaEncProps;
 
 void LzmaEncProps_Init(CLzmaEncProps *p);
@@ -56,9 +49,7 @@ SRes:
   SZ_ERROR_THREAD - error in multithreading functions (only for Mt version)
 */
 
-typedef struct CLzmaEnc CLzmaEnc;
-typedef CLzmaEnc * CLzmaEncHandle;
-// Z7_DECLARE_HANDLE(CLzmaEncHandle)
+typedef void * CLzmaEncHandle;
 
 CLzmaEncHandle LzmaEnc_Create(ISzAllocPtr alloc);
 void LzmaEnc_Destroy(CLzmaEncHandle p, ISzAllocPtr alloc, ISzAllocPtr allocBig);
@@ -68,17 +59,17 @@ void LzmaEnc_SetDataSize(CLzmaEncHandle p, UInt64 expectedDataSiize);
 SRes LzmaEnc_WriteProperties(CLzmaEncHandle p, Byte *properties, SizeT *size);
 unsigned LzmaEnc_IsWriteEndMark(CLzmaEncHandle p);
 
-SRes LzmaEnc_Encode(CLzmaEncHandle p, ISeqOutStreamPtr outStream, ISeqInStreamPtr inStream,
-    ICompressProgressPtr progress, ISzAllocPtr alloc, ISzAllocPtr allocBig);
+SRes LzmaEnc_Encode(CLzmaEncHandle p, ISeqOutStream *outStream, ISeqInStream *inStream,
+    ICompressProgress *progress, ISzAllocPtr alloc, ISzAllocPtr allocBig);
 SRes LzmaEnc_MemEncode(CLzmaEncHandle p, Byte *dest, SizeT *destLen, const Byte *src, SizeT srcLen,
-    int writeEndMark, ICompressProgressPtr progress, ISzAllocPtr alloc, ISzAllocPtr allocBig);
+    int writeEndMark, ICompressProgress *progress, ISzAllocPtr alloc, ISzAllocPtr allocBig);
 
 
 /* ---------- One Call Interface ---------- */
 
 SRes LzmaEncode(Byte *dest, SizeT *destLen, const Byte *src, SizeT srcLen,
     const CLzmaEncProps *props, Byte *propsEncoded, SizeT *propsSize, int writeEndMark,
-    ICompressProgressPtr progress, ISzAllocPtr alloc, ISzAllocPtr allocBig);
+    ICompressProgress *progress, ISzAllocPtr alloc, ISzAllocPtr allocBig);
 
 EXTERN_C_END
 

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

@@ -1,14 +1,12 @@
 /* LzmaLib.c -- LZMA library wrapper
-2023-04-02 : Igor Pavlov : Public domain */
-
-#include "Precomp.h"
+2015-06-13 : Igor Pavlov : Public domain */
 
 #include "Alloc.h"
 #include "LzmaDec.h"
 #include "LzmaEnc.h"
 #include "LzmaLib.h"
 
-Z7_STDAPI LzmaCompress(unsigned char *dest, size_t *destLen, const unsigned char *src, size_t srcLen,
+MY_STDAPI LzmaCompress(unsigned char *dest, size_t *destLen, const unsigned char *src, size_t srcLen,
   unsigned char *outProps, size_t *outPropsSize,
   int level, /* 0 <= level <= 9, default = 5 */
   unsigned dictSize, /* use (1 << N) or (3 << N). 4 KB < dictSize <= 128 MB */
@@ -34,7 +32,7 @@ Z7_STDAPI LzmaCompress(unsigned char *dest, size_t *destLen, const unsigned char
 }
 
 
-Z7_STDAPI LzmaUncompress(unsigned char *dest, size_t *destLen, const unsigned char *src, size_t *srcLen,
+MY_STDAPI LzmaUncompress(unsigned char *dest, size_t *destLen, const unsigned char *src, size_t *srcLen,
   const unsigned char *props, size_t propsSize)
 {
   ELzmaStatus status;

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

@@ -1,14 +1,14 @@
 /* LzmaLib.h -- LZMA library interface
-2023-04-02 : Igor Pavlov : Public domain */
+2013-01-18 : Igor Pavlov : Public domain */
 
-#ifndef ZIP7_INC_LZMA_LIB_H
-#define ZIP7_INC_LZMA_LIB_H
+#ifndef __LZMA_LIB_H
+#define __LZMA_LIB_H
 
 #include "7zTypes.h"
 
 EXTERN_C_BEGIN
 
-#define Z7_STDAPI int Z7_STDCALL
+#define MY_STDAPI int MY_STD_CALL
 
 #define LZMA_PROPS_SIZE 5
 
@@ -40,16 +40,14 @@ outPropsSize -
 level - compression level: 0 <= level <= 9;
 
   level dictSize algo  fb
-    0:    64 KB   0    32
-    1:   256 KB   0    32
-    2:     1 MB   0    32
-    3:     4 MB   0    32
-    4:    16 MB   0    32
+    0:    16 KB   0    32
+    1:    64 KB   0    32
+    2:   256 KB   0    32
+    3:     1 MB   0    32
+    4:     4 MB   0    32
     5:    16 MB   1    32
     6:    32 MB   1    32
-    7:    32 MB   1    64
-    8:    64 MB   1    64
-    9:    64 MB   1    64
+    7+:   64 MB   1    64
  
   The default value for "level" is 5.
 
@@ -85,11 +83,6 @@ fb - Word size (the number of fast bytes).
 numThreads - The number of thereads. 1 or 2. The default value is 2.
      Fast mode (algo = 0) can use only 1 thread.
 
-In:
-  dest     - output data buffer
-  destLen  - output data buffer size
-  src      - input data
-  srcLen   - input data size
 Out:
   destLen  - processed output size
 Returns:
@@ -100,7 +93,7 @@ Returns:
   SZ_ERROR_THREAD     - errors in multithreading functions (only for Mt version)
 */
 
-Z7_STDAPI LzmaCompress(unsigned char *dest, size_t *destLen, const unsigned char *src, size_t srcLen,
+MY_STDAPI LzmaCompress(unsigned char *dest, size_t *destLen, const unsigned char *src, size_t srcLen,
   unsigned char *outProps, size_t *outPropsSize, /* *outPropsSize must be = 5 */
   int level,      /* 0 <= level <= 9, default = 5 */
   unsigned dictSize,  /* default = (1 << 24) */
@@ -115,8 +108,8 @@ Z7_STDAPI LzmaCompress(unsigned char *dest, size_t *destLen, const unsigned char
 LzmaUncompress
 --------------
 In:
-  dest     - output data buffer
-  destLen  - output data buffer size
+  dest     - output data
+  destLen  - output data size
   src      - input data
   srcLen   - input data size
 Out:
@@ -130,7 +123,7 @@ Returns:
   SZ_ERROR_INPUT_EOF   - it needs more bytes in input buffer (src)
 */
 
-Z7_STDAPI LzmaUncompress(unsigned char *dest, size_t *destLen, const unsigned char *src, SizeT *srcLen,
+MY_STDAPI LzmaUncompress(unsigned char *dest, size_t *destLen, const unsigned char *src, SizeT *srcLen,
   const unsigned char *props, size_t propsSize);
 
 EXTERN_C_END

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

@@ -1,28 +1,28 @@
 /* MtCoder.c -- Multi-thread Coder
-: Igor Pavlov : Public domain */
+2018-07-04 : Igor Pavlov : Public domain */
 
 #include "Precomp.h"
 
 #include "MtCoder.h"
 
-#ifndef Z7_ST
+#ifndef _7ZIP_ST
 
-static SRes MtProgressThunk_Progress(ICompressProgressPtr pp, UInt64 inSize, UInt64 outSize)
+SRes MtProgressThunk_Progress(const ICompressProgress *pp, UInt64 inSize, UInt64 outSize)
 {
-  Z7_CONTAINER_FROM_VTBL_TO_DECL_VAR_pp_vt_p(CMtProgressThunk)
+  CMtProgressThunk *thunk = CONTAINER_FROM_VTBL(pp, CMtProgressThunk, vt);
   UInt64 inSize2 = 0;
   UInt64 outSize2 = 0;
   if (inSize != (UInt64)(Int64)-1)
   {
-    inSize2 = inSize - p->inSize;
-    p->inSize = inSize;
+    inSize2 = inSize - thunk->inSize;
+    thunk->inSize = inSize;
   }
   if (outSize != (UInt64)(Int64)-1)
   {
-    outSize2 = outSize - p->outSize;
-    p->outSize = outSize;
+    outSize2 = outSize - thunk->outSize;
+    thunk->outSize = outSize;
   }
-  return MtProgress_ProgressAdd(p->mtProgress, inSize2, outSize2);
+  return MtProgress_ProgressAdd(thunk->mtProgress, inSize2, outSize2);
 }
 
 
@@ -36,31 +36,25 @@ void MtProgressThunk_CreateVTable(CMtProgressThunk *p)
 #define RINOK_THREAD(x) { if ((x) != 0) return SZ_ERROR_THREAD; }
 
 
-static THREAD_FUNC_DECL ThreadFunc(void *pp);
+static WRes ArEvent_OptCreate_And_Reset(CEvent *p)
+{
+  if (Event_IsCreated(p))
+    return Event_Reset(p);
+  return AutoResetEvent_CreateNotSignaled(p);
+}
 
 
-static SRes MtCoderThread_CreateAndStart(CMtCoderThread *t
-#ifdef _WIN32
-    , CMtCoder * const mtc
-#endif
-    )
+static THREAD_FUNC_RET_TYPE THREAD_FUNC_CALL_TYPE ThreadFunc(void *pp);
+
+
+static SRes MtCoderThread_CreateAndStart(CMtCoderThread *t)
 {
-  WRes wres = AutoResetEvent_OptCreate_And_Reset(&t->startEvent);
-  // printf("\n====== MtCoderThread_CreateAndStart : \n");
+  WRes wres = ArEvent_OptCreate_And_Reset(&t->startEvent);
   if (wres == 0)
   {
     t->stop = False;
     if (!Thread_WasCreated(&t->thread))
-    {
-#ifdef _WIN32
-      if (mtc->numThreadGroups)
-        wres = Thread_Create_With_Group(&t->thread, ThreadFunc, t,
-            ThreadNextGroup_GetNext(&mtc->nextGroup), // group
-            0); // affinityMask
-      else
-#endif
-        wres = Thread_Create(&t->thread, ThreadFunc, t);
-    }
+      wres = Thread_Create(&t->thread, ThreadFunc, t);
     if (wres == 0)
       wres = Event_Set(&t->startEvent);
   }
@@ -70,14 +64,14 @@ static SRes MtCoderThread_CreateAndStart(CMtCoderThread *t
 }
 
 
-Z7_FORCE_INLINE
 static void MtCoderThread_Destruct(CMtCoderThread *t)
 {
   if (Thread_WasCreated(&t->thread))
   {
     t->stop = 1;
     Event_Set(&t->startEvent);
-    Thread_Wait_Close(&t->thread);
+    Thread_Wait(&t->thread);
+    Thread_Close(&t->thread);
   }
 
   Event_Close(&t->startEvent);
@@ -91,6 +85,24 @@ static void MtCoderThread_Destruct(CMtCoderThread *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;
+}
+
 
 /*
   ThreadFunc2() returns:
@@ -100,7 +112,7 @@ static void MtCoderThread_Destruct(CMtCoderThread *t)
 
 static SRes ThreadFunc2(CMtCoderThread *t)
 {
-  CMtCoder * const mtc = t->mtCoder;
+  CMtCoder *mtc = t->mtCoder;
 
   for (;;)
   {
@@ -141,7 +153,7 @@ static SRes ThreadFunc2(CMtCoderThread *t)
         }
         if (res == SZ_OK)
         {
-          res = SeqInStream_ReadMax(mtc->inStream, t->inBuf, &size);
+          res = FullRead(mtc->inStream, t->inBuf, &size);
           readProcessed = mtc->readProcessed + size;
           mtc->readProcessed = readProcessed;
         }
@@ -200,11 +212,7 @@ static SRes ThreadFunc2(CMtCoderThread *t)
       if (mtc->numStartedThreads < mtc->numStartedThreadsLimit
           && mtc->expectedDataSize != readProcessed)
       {
-        res = MtCoderThread_CreateAndStart(&mtc->threads[mtc->numStartedThreads]
-#ifdef _WIN32
-            , mtc
-#endif
-            );
+        res = MtCoderThread_CreateAndStart(&mtc->threads[mtc->numStartedThreads]);
         if (res == SZ_OK)
           mtc->numStartedThreads++;
         else
@@ -240,13 +248,13 @@ static SRes ThreadFunc2(CMtCoderThread *t)
     }
 
     {
-      CMtCoderBlock * const block = &mtc->blocks[bi];
+      CMtCoderBlock *block = &mtc->blocks[bi];
       block->res = res;
       block->bufIndex = bufIndex;
       block->finished = finished;
     }
     
-    #ifdef MTCODER_USE_WRITE_THREAD
+    #ifdef MTCODER__USE_WRITE_THREAD
       RINOK_THREAD(Event_Set(&mtc->writeEvents[bi]))
     #else
     {
@@ -328,29 +336,29 @@ static SRes ThreadFunc2(CMtCoderThread *t)
 }
 
 
-static THREAD_FUNC_DECL ThreadFunc(void *pp)
+static THREAD_FUNC_RET_TYPE THREAD_FUNC_CALL_TYPE ThreadFunc(void *pp)
 {
-  CMtCoderThread * const t = (CMtCoderThread *)pp;
+  CMtCoderThread *t = (CMtCoderThread *)pp;
   for (;;)
   {
     if (Event_Wait(&t->startEvent) != 0)
-      return (THREAD_FUNC_RET_TYPE)SZ_ERROR_THREAD;
+      return SZ_ERROR_THREAD;
     if (t->stop)
       return 0;
     {
-      const SRes res = ThreadFunc2(t);
+      SRes res = ThreadFunc2(t);
       CMtCoder *mtc = t->mtCoder;
       if (res != SZ_OK)
       {
         MtProgress_SetError(&mtc->mtProgress, res);
       }
       
-      #ifndef MTCODER_USE_WRITE_THREAD
+      #ifndef MTCODER__USE_WRITE_THREAD
       {
-        const unsigned numFinished = (unsigned)InterlockedIncrement(&mtc->numFinishedThreads);
+        unsigned numFinished = (unsigned)InterlockedIncrement(&mtc->numFinishedThreads);
         if (numFinished == mtc->numStartedThreads)
           if (Event_Set(&mtc->finishedEvent) != 0)
-            return (THREAD_FUNC_RET_TYPE)SZ_ERROR_THREAD;
+            return SZ_ERROR_THREAD;
       }
       #endif
     }
@@ -365,7 +373,6 @@ void MtCoder_Construct(CMtCoder *p)
   
   p->blockSize = 0;
   p->numThreadsMax = 0;
-  p->numThreadGroups = 0;
   p->expectedDataSize = (UInt64)(Int64)-1;
 
   p->inStream = NULL;
@@ -383,7 +390,7 @@ void MtCoder_Construct(CMtCoder *p)
   Event_Construct(&p->readEvent);
   Semaphore_Construct(&p->blocksSemaphore);
 
-  for (i = 0; i < MTCODER_THREADS_MAX; i++)
+  for (i = 0; i < MTCODER__THREADS_MAX; i++)
   {
     CMtCoderThread *t = &p->threads[i];
     t->mtCoder = p;
@@ -391,11 +398,11 @@ void MtCoder_Construct(CMtCoder *p)
     t->inBuf = NULL;
     t->stop = False;
     Event_Construct(&t->startEvent);
-    Thread_CONSTRUCT(&t->thread)
+    Thread_Construct(&t->thread);
   }
 
-  #ifdef MTCODER_USE_WRITE_THREAD
-    for (i = 0; i < MTCODER_BLOCKS_MAX; i++)
+  #ifdef MTCODER__USE_WRITE_THREAD
+    for (i = 0; i < MTCODER__BLOCKS_MAX; i++)
       Event_Construct(&p->writeEvents[i]);
   #else
     Event_Construct(&p->finishedEvent);
@@ -418,14 +425,14 @@ static void MtCoder_Free(CMtCoder *p)
     Event_Set(&p->readEvent);
   */
 
-  for (i = 0; i < MTCODER_THREADS_MAX; i++)
+  for (i = 0; i < MTCODER__THREADS_MAX; i++)
     MtCoderThread_Destruct(&p->threads[i]);
 
   Event_Close(&p->readEvent);
   Semaphore_Close(&p->blocksSemaphore);
 
-  #ifdef MTCODER_USE_WRITE_THREAD
-    for (i = 0; i < MTCODER_BLOCKS_MAX; i++)
+  #ifdef MTCODER__USE_WRITE_THREAD
+    for (i = 0; i < MTCODER__BLOCKS_MAX; i++)
       Event_Close(&p->writeEvents[i]);
   #else
     Event_Close(&p->finishedEvent);
@@ -449,22 +456,20 @@ SRes MtCoder_Code(CMtCoder *p)
   unsigned i;
   SRes res = SZ_OK;
 
-  // printf("\n====== MtCoder_Code : \n");
-
-  if (numThreads > MTCODER_THREADS_MAX)
-      numThreads = MTCODER_THREADS_MAX;
-  numBlocksMax = MTCODER_GET_NUM_BLOCKS_FROM_THREADS(numThreads);
+  if (numThreads > MTCODER__THREADS_MAX)
+    numThreads = MTCODER__THREADS_MAX;
+  numBlocksMax = MTCODER__GET_NUM_BLOCKS_FROM_THREADS(numThreads);
   
   if (p->blockSize < ((UInt32)1 << 26)) numBlocksMax++;
   if (p->blockSize < ((UInt32)1 << 24)) numBlocksMax++;
   if (p->blockSize < ((UInt32)1 << 22)) numBlocksMax++;
 
-  if (numBlocksMax > MTCODER_BLOCKS_MAX)
-      numBlocksMax = MTCODER_BLOCKS_MAX;
+  if (numBlocksMax > MTCODER__BLOCKS_MAX)
+    numBlocksMax = MTCODER__BLOCKS_MAX;
 
   if (p->blockSize != p->allocatedBufsSize)
   {
-    for (i = 0; i < MTCODER_THREADS_MAX; i++)
+    for (i = 0; i < MTCODER__THREADS_MAX; i++)
     {
       CMtCoderThread *t = &p->threads[i];
       if (t->inBuf)
@@ -480,23 +485,28 @@ SRes MtCoder_Code(CMtCoder *p)
 
   MtProgress_Init(&p->mtProgress, p->progress);
 
-  #ifdef MTCODER_USE_WRITE_THREAD
+  #ifdef MTCODER__USE_WRITE_THREAD
     for (i = 0; i < numBlocksMax; i++)
     {
-      RINOK_THREAD(AutoResetEvent_OptCreate_And_Reset(&p->writeEvents[i]))
+      RINOK_THREAD(ArEvent_OptCreate_And_Reset(&p->writeEvents[i]));
     }
   #else
-    RINOK_THREAD(AutoResetEvent_OptCreate_And_Reset(&p->finishedEvent))
+    RINOK_THREAD(ArEvent_OptCreate_And_Reset(&p->finishedEvent));
   #endif
 
   {
-    RINOK_THREAD(AutoResetEvent_OptCreate_And_Reset(&p->readEvent))
-    RINOK_THREAD(Semaphore_OptCreateInit(&p->blocksSemaphore, (UInt32)numBlocksMax, (UInt32)numBlocksMax))
+    RINOK_THREAD(ArEvent_OptCreate_And_Reset(&p->readEvent));
+
+    if (Semaphore_IsCreated(&p->blocksSemaphore))
+    {
+      RINOK_THREAD(Semaphore_Close(&p->blocksSemaphore));
+    }
+    RINOK_THREAD(Semaphore_Create(&p->blocksSemaphore, numBlocksMax, numBlocksMax));
   }
 
-  for (i = 0; i < MTCODER_BLOCKS_MAX - 1; i++)
+  for (i = 0; i < MTCODER__BLOCKS_MAX - 1; i++)
     p->freeBlockList[i] = i + 1;
-  p->freeBlockList[MTCODER_BLOCKS_MAX - 1] = (unsigned)(int)-1;
+  p->freeBlockList[MTCODER__BLOCKS_MAX - 1] = (unsigned)(int)-1;
   p->freeBlockHead = 0;
 
   p->readProcessed = 0;
@@ -504,37 +514,26 @@ SRes MtCoder_Code(CMtCoder *p)
   p->numBlocksMax = numBlocksMax;
   p->stopReading = False;
 
-  #ifndef MTCODER_USE_WRITE_THREAD
+  #ifndef MTCODER__USE_WRITE_THREAD
     p->writeIndex = 0;
     p->writeRes = SZ_OK;
-    for (i = 0; i < MTCODER_BLOCKS_MAX; i++)
+    for (i = 0; i < MTCODER__BLOCKS_MAX; i++)
       p->ReadyBlocks[i] = False;
     p->numFinishedThreads = 0;
   #endif
 
   p->numStartedThreadsLimit = numThreads;
   p->numStartedThreads = 0;
-  ThreadNextGroup_Init(&p->nextGroup, p->numThreadGroups, 0); // startGroup
 
   // for (i = 0; i < numThreads; i++)
   {
-    // here we create new thread for first block.
-    // And each new thread will create another new thread after block reading
-    // until numStartedThreadsLimit is reached.
     CMtCoderThread *nextThread = &p->threads[p->numStartedThreads++];
-    {
-      const SRes res2 = MtCoderThread_CreateAndStart(nextThread
-#ifdef _WIN32
-            , p
-#endif
-            );
-      RINOK(res2)
-    }
+    RINOK(MtCoderThread_CreateAndStart(nextThread));
   }
 
   RINOK_THREAD(Event_Set(&p->readEvent))
 
-  #ifdef MTCODER_USE_WRITE_THREAD
+  #ifdef MTCODER__USE_WRITE_THREAD
   {
     unsigned bi = 0;
 
@@ -546,9 +545,9 @@ SRes MtCoder_Code(CMtCoder *p)
       RINOK_THREAD(Event_Wait(&p->writeEvents[bi]))
 
       {
-        const CMtCoderBlock * const block = &p->blocks[bi];
-        const unsigned bufIndex = block->bufIndex;
-        const BoolInt finished = block->finished;
+        const CMtCoderBlock *block = &p->blocks[bi];
+        unsigned bufIndex = block->bufIndex;
+        BoolInt finished = block->finished;
         if (res == SZ_OK && block->res != SZ_OK)
           res = block->res;
 
@@ -578,7 +577,7 @@ SRes MtCoder_Code(CMtCoder *p)
   }
   #else
   {
-    const WRes wres = Event_Wait(&p->finishedEvent);
+    WRes wres = Event_Wait(&p->finishedEvent);
     res = MY_SRes_HRESULT_FROM_WRes(wres);
   }
   #endif
@@ -589,7 +588,7 @@ SRes MtCoder_Code(CMtCoder *p)
   if (res == SZ_OK)
     res = p->mtProgress.res;
 
-  #ifndef MTCODER_USE_WRITE_THREAD
+  #ifndef MTCODER__USE_WRITE_THREAD
     if (res == SZ_OK)
       res = p->writeRes;
   #endif
@@ -600,5 +599,3 @@ SRes MtCoder_Code(CMtCoder *p)
 }
 
 #endif
-
-#undef RINOK_THREAD