[pcsx_rearmed.git] / deps / libchdr / deps / lzma-22.01 / src / MtDec.c

/* MtDec.c -- Multi-thread Decoder\r
2021-12-21 : Igor Pavlov : Public domain */\r
\r
#include "Precomp.h"\r
\r
// #define SHOW_DEBUG_INFO\r
\r
// #include <stdio.h>\r
#include <string.h>\r
\r
#ifdef SHOW_DEBUG_INFO\r
#include <stdio.h>\r
#endif\r
\r
#include "MtDec.h"\r
\r
#ifndef _7ZIP_ST\r
\r
#ifdef SHOW_DEBUG_INFO\r
#define PRF(x) x\r
#else\r
#define PRF(x)\r
#endif\r
\r
#define PRF_STR_INT(s, d) PRF(printf("\n" s " %d\n", (unsigned)d))\r
\r
void MtProgress_Init(CMtProgress *p, ICompressProgress *progress)\r
{\r
  p->progress = progress;\r
  p->res = SZ_OK;\r
  p->totalInSize = 0;\r
  p->totalOutSize = 0;\r
}\r
\r
\r
SRes MtProgress_Progress_ST(CMtProgress *p)\r
{\r
  if (p->res == SZ_OK && p->progress)\r
    if (ICompressProgress_Progress(p->progress, p->totalInSize, p->totalOutSize) != SZ_OK)\r
      p->res = SZ_ERROR_PROGRESS;\r
  return p->res;\r
}\r
\r
\r
SRes MtProgress_ProgressAdd(CMtProgress *p, UInt64 inSize, UInt64 outSize)\r
{\r
  SRes res;\r
  CriticalSection_Enter(&p->cs);\r
  \r
  p->totalInSize += inSize;\r
  p->totalOutSize += outSize;\r
  if (p->res == SZ_OK && p->progress)\r
    if (ICompressProgress_Progress(p->progress, p->totalInSize, p->totalOutSize) != SZ_OK)\r
      p->res = SZ_ERROR_PROGRESS;\r
  res = p->res;\r
  \r
  CriticalSection_Leave(&p->cs);\r
  return res;\r
}\r
\r
\r
SRes MtProgress_GetError(CMtProgress *p)\r
{\r
  SRes res;\r
  CriticalSection_Enter(&p->cs);\r
  res = p->res;\r
  CriticalSection_Leave(&p->cs);\r
  return res;\r
}\r
\r
\r
void MtProgress_SetError(CMtProgress *p, SRes res)\r
{\r
  CriticalSection_Enter(&p->cs);\r
  if (p->res == SZ_OK)\r
    p->res = res;\r
  CriticalSection_Leave(&p->cs);\r
}\r
\r
\r
#define RINOK_THREAD(x) RINOK_WRes(x)\r
\r
\r
static WRes ArEvent_OptCreate_And_Reset(CEvent *p)\r
{\r
  if (Event_IsCreated(p))\r
    return Event_Reset(p);\r
  return AutoResetEvent_CreateNotSignaled(p);\r
}\r
\r
\r
struct __CMtDecBufLink\r
{\r
  struct __CMtDecBufLink *next;\r
  void *pad[3];\r
};\r
\r
typedef struct __CMtDecBufLink CMtDecBufLink;\r
\r
#define MTDEC__LINK_DATA_OFFSET sizeof(CMtDecBufLink)\r
#define MTDEC__DATA_PTR_FROM_LINK(link) ((Byte *)(link) + MTDEC__LINK_DATA_OFFSET)\r
\r
\r
\r
static THREAD_FUNC_DECL ThreadFunc(void *pp);\r
\r
\r
static WRes MtDecThread_CreateEvents(CMtDecThread *t)\r
{\r
  WRes wres = ArEvent_OptCreate_And_Reset(&t->canWrite);\r
  if (wres == 0)\r
  {\r
    wres = ArEvent_OptCreate_And_Reset(&t->canRead);\r
    if (wres == 0)\r
      return SZ_OK;\r
  }\r
  return wres;\r
}\r
\r
\r
static SRes MtDecThread_CreateAndStart(CMtDecThread *t)\r
{\r
  WRes wres = MtDecThread_CreateEvents(t);\r
  // wres = 17; // for test\r
  if (wres == 0)\r
  {\r
    if (Thread_WasCreated(&t->thread))\r
      return SZ_OK;\r
    wres = Thread_Create(&t->thread, ThreadFunc, t);\r
    if (wres == 0)\r
      return SZ_OK;\r
  }\r
  return MY_SRes_HRESULT_FROM_WRes(wres);\r
}\r
\r
\r
void MtDecThread_FreeInBufs(CMtDecThread *t)\r
{\r
  if (t->inBuf)\r
  {\r
    void *link = t->inBuf;\r
    t->inBuf = NULL;\r
    do\r
    {\r
      void *next = ((CMtDecBufLink *)link)->next;\r
      ISzAlloc_Free(t->mtDec->alloc, link);\r
      link = next;\r
    }\r
    while (link);\r
  }\r
}\r
\r
\r
static void MtDecThread_CloseThread(CMtDecThread *t)\r
{\r
  if (Thread_WasCreated(&t->thread))\r
  {\r
    Event_Set(&t->canWrite); /* we can disable it. There are no threads waiting canWrite in normal cases */\r
    Event_Set(&t->canRead);\r
    Thread_Wait_Close(&t->thread);\r
  }\r
\r
  Event_Close(&t->canRead);\r
  Event_Close(&t->canWrite);\r
}\r
\r
static void MtDec_CloseThreads(CMtDec *p)\r
{\r
  unsigned i;\r
  for (i = 0; i < MTDEC__THREADS_MAX; i++)\r
    MtDecThread_CloseThread(&p->threads[i]);\r
}\r
\r
static void MtDecThread_Destruct(CMtDecThread *t)\r
{\r
  MtDecThread_CloseThread(t);\r
  MtDecThread_FreeInBufs(t);\r
}\r
\r
\r
\r
static SRes FullRead(ISeqInStream *stream, Byte *data, size_t *processedSize)\r
{\r
  size_t size = *processedSize;\r
  *processedSize = 0;\r
  while (size != 0)\r
  {\r
    size_t cur = size;\r
    SRes res = ISeqInStream_Read(stream, data, &cur);\r
    *processedSize += cur;\r
    data += cur;\r
    size -= cur;\r
    RINOK(res);\r
    if (cur == 0)\r
      return SZ_OK;\r
  }\r
  return SZ_OK;\r
}\r
\r
\r
static SRes MtDec_GetError_Spec(CMtDec *p, UInt64 interruptIndex, BoolInt *wasInterrupted)\r
{\r
  SRes res;\r
  CriticalSection_Enter(&p->mtProgress.cs);\r
  *wasInterrupted = (p->needInterrupt && interruptIndex > p->interruptIndex);\r
  res = p->mtProgress.res;\r
  CriticalSection_Leave(&p->mtProgress.cs);\r
  return res;\r
}\r
\r
static SRes MtDec_Progress_GetError_Spec(CMtDec *p, UInt64 inSize, UInt64 outSize, UInt64 interruptIndex, BoolInt *wasInterrupted)\r
{\r
  SRes res;\r
  CriticalSection_Enter(&p->mtProgress.cs);\r
\r
  p->mtProgress.totalInSize += inSize;\r
  p->mtProgress.totalOutSize += outSize;\r
  if (p->mtProgress.res == SZ_OK && p->mtProgress.progress)\r
    if (ICompressProgress_Progress(p->mtProgress.progress, p->mtProgress.totalInSize, p->mtProgress.totalOutSize) != SZ_OK)\r
      p->mtProgress.res = SZ_ERROR_PROGRESS;\r
\r
  *wasInterrupted = (p->needInterrupt && interruptIndex > p->interruptIndex);\r
  res = p->mtProgress.res;\r
  \r
  CriticalSection_Leave(&p->mtProgress.cs);\r
\r
  return res;\r
}\r
\r
static void MtDec_Interrupt(CMtDec *p, UInt64 interruptIndex)\r
{\r
  CriticalSection_Enter(&p->mtProgress.cs);\r
  if (!p->needInterrupt || interruptIndex < p->interruptIndex)\r
  {\r
    p->interruptIndex = interruptIndex;\r
    p->needInterrupt = True;\r
  }\r
  CriticalSection_Leave(&p->mtProgress.cs);\r
}\r
\r
Byte *MtDec_GetCrossBuff(CMtDec *p)\r
{\r
  Byte *cr = p->crossBlock;\r
  if (!cr)\r
  {\r
    cr = (Byte *)ISzAlloc_Alloc(p->alloc, MTDEC__LINK_DATA_OFFSET + p->inBufSize);\r
    if (!cr)\r
      return NULL;\r
    p->crossBlock = cr;\r
  }\r
  return MTDEC__DATA_PTR_FROM_LINK(cr);\r
}\r
\r
\r
/*\r
  ThreadFunc2() returns:\r
  0      - in all normal cases (even for stream error or memory allocation error)\r
  (!= 0) - WRes error return by system threading function\r
*/\r
\r
// #define MTDEC_ProgessStep (1 << 22)\r
#define MTDEC_ProgessStep (1 << 0)\r
\r
static WRes ThreadFunc2(CMtDecThread *t)\r
{\r
  CMtDec *p = t->mtDec;\r
\r
  PRF_STR_INT("ThreadFunc2", t->index);\r
\r
  // SetThreadAffinityMask(GetCurrentThread(), 1 << t->index);\r
\r
  for (;;)\r
  {\r
    SRes res, codeRes;\r
    BoolInt wasInterrupted, isAllocError, overflow, finish;\r
    SRes threadingErrorSRes;\r
    BoolInt needCode, needWrite, needContinue;\r
    \r
    size_t inDataSize_Start;\r
    UInt64 inDataSize;\r
    // UInt64 inDataSize_Full;\r
    \r
    UInt64 blockIndex;\r
\r
    UInt64 inPrev = 0;\r
    UInt64 outPrev = 0;\r
    UInt64 inCodePos;\r
    UInt64 outCodePos;\r
    \r
    Byte *afterEndData = NULL;\r
    size_t afterEndData_Size = 0;\r
    BoolInt afterEndData_IsCross = False;\r
\r
    BoolInt canCreateNewThread = False;\r
    // CMtDecCallbackInfo parse;\r
    CMtDecThread *nextThread;\r
\r
    PRF_STR_INT("=============== Event_Wait(&t->canRead)", t->index);\r
\r
    RINOK_THREAD(Event_Wait(&t->canRead));\r
    if (p->exitThread)\r
      return 0;\r
\r
    PRF_STR_INT("after Event_Wait(&t->canRead)", t->index);\r
\r
    // if (t->index == 3) return 19; // for test\r
\r
    blockIndex = p->blockIndex++;\r
\r
    // PRF(printf("\ncanRead\n"))\r
\r
    res = MtDec_Progress_GetError_Spec(p, 0, 0, blockIndex, &wasInterrupted);\r
\r
    finish = p->readWasFinished;\r
    needCode = False;\r
    needWrite = False;\r
    isAllocError = False;\r
    overflow = False;\r
\r
    inDataSize_Start = 0;\r
    inDataSize = 0;\r
    // inDataSize_Full = 0;\r
\r
    if (res == SZ_OK && !wasInterrupted)\r
    {\r
      // if (p->inStream)\r
      {\r
        CMtDecBufLink *prev = NULL;\r
        CMtDecBufLink *link = (CMtDecBufLink *)t->inBuf;\r
        size_t crossSize = p->crossEnd - p->crossStart;\r
\r
        PRF(printf("\ncrossSize = %d\n", crossSize));\r
\r
        for (;;)\r
        {\r
          if (!link)\r
          {\r
            link = (CMtDecBufLink *)ISzAlloc_Alloc(p->alloc, MTDEC__LINK_DATA_OFFSET + p->inBufSize);\r
            if (!link)\r
            {\r
              finish = True;\r
              // p->allocError_for_Read_BlockIndex = blockIndex;\r
              isAllocError = True;\r
              break;\r
            }\r
            link->next = NULL;\r
            if (prev)\r
            {\r
              // static unsigned g_num = 0;\r
              // printf("\n%6d : %x", ++g_num, (unsigned)(size_t)((Byte *)link - (Byte *)prev));\r
              prev->next = link;\r
            }\r
            else\r
              t->inBuf = (void *)link;\r
          }\r
\r
          {\r
            Byte *data = MTDEC__DATA_PTR_FROM_LINK(link);\r
            Byte *parseData = data;\r
            size_t size;\r
\r
            if (crossSize != 0)\r
            {\r
              inDataSize = crossSize;\r
              // inDataSize_Full = inDataSize;\r
              inDataSize_Start = crossSize;\r
              size = crossSize;\r
              parseData = MTDEC__DATA_PTR_FROM_LINK(p->crossBlock) + p->crossStart;\r
              PRF(printf("\ncross : crossStart = %7d  crossEnd = %7d finish = %1d",\r
                  (int)p->crossStart, (int)p->crossEnd, (int)finish));\r
            }\r
            else\r
            {\r
              size = p->inBufSize;\r
              \r
              res = FullRead(p->inStream, data, &size);\r
              \r
              // size = 10; // test\r
\r
              inDataSize += size;\r
              // inDataSize_Full = inDataSize;\r
              if (!prev)\r
                inDataSize_Start = size;\r
\r
              p->readProcessed += size;\r
              finish = (size != p->inBufSize);\r
              if (finish)\r
                p->readWasFinished = True;\r
              \r
              // res = E_INVALIDARG; // test\r
\r
              if (res != SZ_OK)\r
              {\r
                // PRF(printf("\nRead error = %d\n", res))\r
                // we want to decode all data before error\r
                p->readRes = res;\r
                // p->readError_BlockIndex = blockIndex;\r
                p->readWasFinished = True;\r
                finish = True;\r
                res = SZ_OK;\r
                // break;\r
              }\r
\r
              if (inDataSize - inPrev >= MTDEC_ProgessStep)\r
              {\r
                res = MtDec_Progress_GetError_Spec(p, 0, 0, blockIndex, &wasInterrupted);\r
                if (res != SZ_OK || wasInterrupted)\r
                  break;\r
                inPrev = inDataSize;\r
              }\r
            }\r
\r
            {\r
              CMtDecCallbackInfo parse;\r
\r
              parse.startCall = (prev == NULL);\r
              parse.src = parseData;\r
              parse.srcSize = size;\r
              parse.srcFinished = finish;\r
              parse.canCreateNewThread = True;\r
\r
              PRF(printf("\nParse size = %d\n", (unsigned)size));\r
\r
              p->mtCallback->Parse(p->mtCallbackObject, t->index, &parse);\r
\r
              PRF(printf("   Parse processed = %d, state = %d \n", (unsigned)parse.srcSize, (unsigned)parse.state));\r
\r
              needWrite = True;\r
              canCreateNewThread = parse.canCreateNewThread;\r
\r
              // printf("\n\n%12I64u %12I64u", (UInt64)p->mtProgress.totalInSize, (UInt64)p->mtProgress.totalOutSize);\r
              \r
              if (\r
                  // parseRes != SZ_OK ||\r
                  // inDataSize - (size - parse.srcSize) > p->inBlockMax\r
                  // ||\r
                  parse.state == MTDEC_PARSE_OVERFLOW\r
                  // || wasInterrupted\r
                  )\r
              {\r
                // Overflow or Parse error - switch from MT decoding to ST decoding\r
                finish = True;\r
                overflow = True;\r
\r
                {\r
                  PRF(printf("\n Overflow"));\r
                  // PRF(printf("\nisBlockFinished = %d", (unsigned)parse.blockWasFinished));\r
                  PRF(printf("\n inDataSize = %d", (unsigned)inDataSize));\r
                }\r
                \r
                if (crossSize != 0)\r
                  memcpy(data, parseData, size);\r
                p->crossStart = 0;\r
                p->crossEnd = 0;\r
                break;\r
              }\r
\r
              if (crossSize != 0)\r
              {\r
                memcpy(data, parseData, parse.srcSize);\r
                p->crossStart += parse.srcSize;\r
              }\r
\r
              if (parse.state != MTDEC_PARSE_CONTINUE || finish)\r
              {\r
                // we don't need to parse in current thread anymore\r
\r
                if (parse.state == MTDEC_PARSE_END)\r
                  finish = True;\r
\r
                needCode = True;\r
                // p->crossFinished = finish;\r
\r
                if (parse.srcSize == size)\r
                {\r
                  // full parsed - no cross transfer\r
                  p->crossStart = 0;\r
                  p->crossEnd = 0;\r
                  break;\r
                }\r
\r
                if (parse.state == MTDEC_PARSE_END)\r
                {\r
                  afterEndData = parseData + parse.srcSize;\r
                  afterEndData_Size = size - parse.srcSize;\r
                  if (crossSize != 0)\r
                    afterEndData_IsCross = True;\r
                  // we reduce data size to required bytes (parsed only)\r
                  inDataSize -= afterEndData_Size;\r
                  if (!prev)\r
                    inDataSize_Start = parse.srcSize;\r
                  break;\r
                }\r
\r
                {\r
                  // partial parsed - need cross transfer\r
                  if (crossSize != 0)\r
                    inDataSize = parse.srcSize; // it's only parsed now\r
                  else\r
                  {\r
                    // partial parsed - is not in initial cross block - we need to copy new data to cross block\r
                    Byte *cr = MtDec_GetCrossBuff(p);\r
                    if (!cr)\r
                    {\r
                      {\r
                        PRF(printf("\ncross alloc error error\n"));\r
                        // res = SZ_ERROR_MEM;\r
                        finish = True;\r
                        // p->allocError_for_Read_BlockIndex = blockIndex;\r
                        isAllocError = True;\r
                        break;\r
                      }\r
                    }\r
\r
                    {\r
                      size_t crSize = size - parse.srcSize;\r
                      inDataSize -= crSize;\r
                      p->crossEnd = crSize;\r
                      p->crossStart = 0;\r
                      memcpy(cr, parseData + parse.srcSize, crSize);\r
                    }\r
                  }\r
\r
                  // inDataSize_Full = inDataSize;\r
                  if (!prev)\r
                    inDataSize_Start = parse.srcSize; // it's partial size (parsed only)\r
\r
                  finish = False;\r
                  break;\r
                }\r
              }\r
\r
              if (parse.srcSize != size)\r
              {\r
                res = SZ_ERROR_FAIL;\r
                PRF(printf("\nfinished error SZ_ERROR_FAIL = %d\n", res));\r
                break;\r
              }\r
            }\r
          }\r
          \r
          prev = link;\r
          link = link->next;\r
\r
          if (crossSize != 0)\r
          {\r
            crossSize = 0;\r
            p->crossStart = 0;\r
            p->crossEnd = 0;\r
          }\r
        }\r
      }\r
\r
      if (res == SZ_OK)\r
        res = MtDec_GetError_Spec(p, blockIndex, &wasInterrupted);\r
    }\r
\r
    codeRes = SZ_OK;\r
\r
    if (res == SZ_OK && needCode && !wasInterrupted)\r
    {\r
      codeRes = p->mtCallback->PreCode(p->mtCallbackObject, t->index);\r
      if (codeRes != SZ_OK)\r
      {\r
        needCode = False;\r
        finish = True;\r
        // SZ_ERROR_MEM is expected error here.\r
        //   if (codeRes == SZ_ERROR_MEM) - we will try single-thread decoding later.\r
        //   if (codeRes != SZ_ERROR_MEM) - we can stop decoding or try single-thread decoding.\r
      }\r
    }\r
    \r
    if (res != SZ_OK || wasInterrupted)\r
      finish = True;\r
    \r
    nextThread = NULL;\r
    threadingErrorSRes = SZ_OK;\r
\r
    if (!finish)\r
    {\r
      if (p->numStartedThreads < p->numStartedThreads_Limit && canCreateNewThread)\r
      {\r
        SRes res2 = MtDecThread_CreateAndStart(&p->threads[p->numStartedThreads]);\r
        if (res2 == SZ_OK)\r
        {\r
          // if (p->numStartedThreads % 1000 == 0) PRF(printf("\n numStartedThreads=%d\n", p->numStartedThreads));\r
          p->numStartedThreads++;\r
        }\r
        else\r
        {\r
          PRF(printf("\nERROR: numStartedThreads=%d\n", p->numStartedThreads));\r
          if (p->numStartedThreads == 1)\r
          {\r
            // if only one thread is possible, we leave muti-threading code\r
            finish = True;\r
            needCode = False;\r
            threadingErrorSRes = res2;\r
          }\r
          else\r
            p->numStartedThreads_Limit = p->numStartedThreads;\r
        }\r
      }\r
      \r
      if (!finish)\r
      {\r
        unsigned nextIndex = t->index + 1;\r
        nextThread = &p->threads[nextIndex >= p->numStartedThreads ? 0 : nextIndex];\r
        RINOK_THREAD(Event_Set(&nextThread->canRead))\r
        // We have started executing for new iteration (with next thread)\r
        // And that next thread now is responsible for possible exit from decoding (threading_code)\r
      }\r
    }\r
\r
    // each call of Event_Set(&nextThread->canRead) must be followed by call of Event_Set(&nextThread->canWrite)\r
    // if ( !finish ) we must call Event_Set(&nextThread->canWrite) in any case\r
    // if (  finish ) we switch to single-thread mode and there are 2 ways at the end of current iteration (current block):\r
    //   - if (needContinue) after Write(&needContinue), we restore decoding with new iteration\r
    //   - otherwise we stop decoding and exit from ThreadFunc2()\r
\r
    // Don't change (finish) variable in the further code\r
\r
\r
    // ---------- CODE ----------\r
\r
    inPrev = 0;\r
    outPrev = 0;\r
    inCodePos = 0;\r
    outCodePos = 0;\r
\r
    if (res == SZ_OK && needCode && codeRes == SZ_OK)\r
    {\r
      BoolInt isStartBlock = True;\r
      CMtDecBufLink *link = (CMtDecBufLink *)t->inBuf;\r
\r
      for (;;)\r
      {\r
        size_t inSize;\r
        int stop;\r
\r
        if (isStartBlock)\r
          inSize = inDataSize_Start;\r
        else\r
        {\r
          UInt64 rem = inDataSize - inCodePos;\r
          inSize = p->inBufSize;\r
          if (inSize > rem)\r
            inSize = (size_t)rem;\r
        }\r
\r
        inCodePos += inSize;\r
        stop = True;\r
\r
        codeRes = p->mtCallback->Code(p->mtCallbackObject, t->index,\r
            (const Byte *)MTDEC__DATA_PTR_FROM_LINK(link), inSize,\r
            (inCodePos == inDataSize), // srcFinished\r
            &inCodePos, &outCodePos, &stop);\r
        \r
        if (codeRes != SZ_OK)\r
        {\r
          PRF(printf("\nCode Interrupt error = %x\n", codeRes));\r
          // we interrupt only later blocks\r
          MtDec_Interrupt(p, blockIndex);\r
          break;\r
        }\r
\r
        if (stop || inCodePos == inDataSize)\r
          break;\r
  \r
        {\r
          const UInt64 inDelta = inCodePos - inPrev;\r
          const UInt64 outDelta = outCodePos - outPrev;\r
          if (inDelta >= MTDEC_ProgessStep || outDelta >= MTDEC_ProgessStep)\r
          {\r
            // Sleep(1);\r
            res = MtDec_Progress_GetError_Spec(p, inDelta, outDelta, blockIndex, &wasInterrupted);\r
            if (res != SZ_OK || wasInterrupted)\r
              break;\r
            inPrev = inCodePos;\r
            outPrev = outCodePos;\r
          }\r
        }\r
\r
        link = link->next;\r
        isStartBlock = False;\r
      }\r
    }\r
\r
\r
    // ---------- WRITE ----------\r
   \r
    RINOK_THREAD(Event_Wait(&t->canWrite));\r
\r
  {\r
    BoolInt isErrorMode = False;\r
    BoolInt canRecode = True;\r
    BoolInt needWriteToStream = needWrite;\r
\r
    if (p->exitThread) return 0; // it's never executed in normal cases\r
\r
    if (p->wasInterrupted)\r
      wasInterrupted = True;\r
    else\r
    {\r
      if (codeRes != SZ_OK) // || !needCode // check it !!!\r
      {\r
        p->wasInterrupted = True;\r
        p->codeRes = codeRes;\r
        if (codeRes == SZ_ERROR_MEM)\r
          isAllocError = True;\r
      }\r
      \r
      if (threadingErrorSRes)\r
      {\r
        p->wasInterrupted = True;\r
        p->threadingErrorSRes = threadingErrorSRes;\r
        needWriteToStream = False;\r
      }\r
      if (isAllocError)\r
      {\r
        p->wasInterrupted = True;\r
        p->isAllocError = True;\r
        needWriteToStream = False;\r
      }\r
      if (overflow)\r
      {\r
        p->wasInterrupted = True;\r
        p->overflow = True;\r
        needWriteToStream = False;\r
      }\r
    }\r
\r
    if (needCode)\r
    {\r
      if (wasInterrupted)\r
      {\r
        inCodePos = 0;\r
        outCodePos = 0;\r
      }\r
      {\r
        const UInt64 inDelta = inCodePos - inPrev;\r
        const UInt64 outDelta = outCodePos - outPrev;\r
        // if (inDelta != 0 || outDelta != 0)\r
        res = MtProgress_ProgressAdd(&p->mtProgress, inDelta, outDelta);\r
      }\r
    }\r
\r
    needContinue = (!finish);\r
\r
    // if (res == SZ_OK && needWrite && !wasInterrupted)\r
    if (needWrite)\r
    {\r
      // p->inProcessed += inCodePos;\r
\r
      PRF(printf("\n--Write afterSize = %d\n", (unsigned)afterEndData_Size));\r
\r
      res = p->mtCallback->Write(p->mtCallbackObject, t->index,\r
          res == SZ_OK && needWriteToStream && !wasInterrupted, // needWrite\r
          afterEndData, afterEndData_Size, afterEndData_IsCross,\r
          &needContinue,\r
          &canRecode);\r
\r
      // res = SZ_ERROR_FAIL; // for test\r
\r
      PRF(printf("\nAfter Write needContinue = %d\n", (unsigned)needContinue));\r
      PRF(printf("\nprocessed = %d\n", (unsigned)p->inProcessed));\r
\r
      if (res != SZ_OK)\r
      {\r
        PRF(printf("\nWrite error = %d\n", res));\r
        isErrorMode = True;\r
        p->wasInterrupted = True;\r
      }\r
      if (res != SZ_OK\r
          || (!needContinue && !finish))\r
      {\r
        PRF(printf("\nWrite Interrupt error = %x\n", res));\r
        MtDec_Interrupt(p, blockIndex);\r
      }\r
    }\r
\r
    if (canRecode)\r
    if (!needCode\r
        || res != SZ_OK\r
        || p->wasInterrupted\r
        || codeRes != SZ_OK\r
        || wasInterrupted\r
        || p->numFilledThreads != 0\r
        || isErrorMode)\r
    {\r
      if (p->numFilledThreads == 0)\r
        p->filledThreadStart = t->index;\r
      if (inDataSize != 0 || !finish)\r
      {\r
        t->inDataSize_Start = inDataSize_Start;\r
        t->inDataSize = inDataSize;\r
        p->numFilledThreads++;\r
      }\r
      PRF(printf("\np->numFilledThreads = %d\n", p->numFilledThreads));\r
      PRF(printf("p->filledThreadStart = %d\n", p->filledThreadStart));\r
    }\r
\r
    if (!finish)\r
    {\r
      RINOK_THREAD(Event_Set(&nextThread->canWrite));\r
    }\r
    else\r
    {\r
      if (needContinue)\r
      {\r
        // we restore decoding with new iteration\r
        RINOK_THREAD(Event_Set(&p->threads[0].canWrite));\r
      }\r
      else\r
      {\r
        // we exit from decoding\r
        if (t->index == 0)\r
          return SZ_OK;\r
        p->exitThread = True;\r
      }\r
      RINOK_THREAD(Event_Set(&p->threads[0].canRead));\r
    }\r
  }\r
  }\r
}\r
\r
#ifdef _WIN32\r
#define USE_ALLOCA\r
#endif\r
\r
#ifdef USE_ALLOCA\r
#ifdef _WIN32\r
#include <malloc.h>\r
#else\r
#include <stdlib.h>\r
#endif\r
#endif\r
\r
\r
static THREAD_FUNC_DECL ThreadFunc1(void *pp)\r
{\r
  WRes res;\r
\r
  CMtDecThread *t = (CMtDecThread *)pp;\r
  CMtDec *p;\r
\r
  // fprintf(stdout, "\n%d = %p\n", t->index, &t);\r
\r
  res = ThreadFunc2(t);\r
  p = t->mtDec;\r
  if (res == 0)\r
    return (THREAD_FUNC_RET_TYPE)(UINT_PTR)p->exitThreadWRes;\r
  {\r
    // it's unexpected situation for some threading function error\r
    if (p->exitThreadWRes == 0)\r
      p->exitThreadWRes = res;\r
    PRF(printf("\nthread exit error = %d\n", res));\r
    p->exitThread = True;\r
    Event_Set(&p->threads[0].canRead);\r
    Event_Set(&p->threads[0].canWrite);\r
    MtProgress_SetError(&p->mtProgress, MY_SRes_HRESULT_FROM_WRes(res));\r
  }\r
  return (THREAD_FUNC_RET_TYPE)(UINT_PTR)res;\r
}\r
\r
static MY_NO_INLINE THREAD_FUNC_DECL ThreadFunc(void *pp)\r
{\r
  #ifdef USE_ALLOCA\r
  CMtDecThread *t = (CMtDecThread *)pp;\r
  // fprintf(stderr, "\n%d = %p - before", t->index, &t);\r
  t->allocaPtr = alloca(t->index * 128);\r
  #endif\r
  return ThreadFunc1(pp);\r
}\r
\r
\r
int MtDec_PrepareRead(CMtDec *p)\r
{\r
  if (p->crossBlock && p->crossStart == p->crossEnd)\r
  {\r
    ISzAlloc_Free(p->alloc, p->crossBlock);\r
    p->crossBlock = NULL;\r
  }\r
    \r
  {\r
    unsigned i;\r
    for (i = 0; i < MTDEC__THREADS_MAX; i++)\r
      if (i > p->numStartedThreads\r
          || p->numFilledThreads <=\r
            (i >= p->filledThreadStart ?\r
              i - p->filledThreadStart :\r
              i + p->numStartedThreads - p->filledThreadStart))\r
        MtDecThread_FreeInBufs(&p->threads[i]);\r
  }\r
\r
  return (p->numFilledThreads != 0) || (p->crossStart != p->crossEnd);\r
}\r
\r
    \r
const Byte *MtDec_Read(CMtDec *p, size_t *inLim)\r
{\r
  while (p->numFilledThreads != 0)\r
  {\r
    CMtDecThread *t = &p->threads[p->filledThreadStart];\r
    \r
    if (*inLim != 0)\r
    {\r
      {\r
        void *link = t->inBuf;\r
        void *next = ((CMtDecBufLink *)link)->next;\r
        ISzAlloc_Free(p->alloc, link);\r
        t->inBuf = next;\r
      }\r
      \r
      if (t->inDataSize == 0)\r
      {\r
        MtDecThread_FreeInBufs(t);\r
        if (--p->numFilledThreads == 0)\r
          break;\r
        if (++p->filledThreadStart == p->numStartedThreads)\r
          p->filledThreadStart = 0;\r
        t = &p->threads[p->filledThreadStart];\r
      }\r
    }\r
    \r
    {\r
      size_t lim = t->inDataSize_Start;\r
      if (lim != 0)\r
        t->inDataSize_Start = 0;\r
      else\r
      {\r
        UInt64 rem = t->inDataSize;\r
        lim = p->inBufSize;\r
        if (lim > rem)\r
          lim = (size_t)rem;\r
      }\r
      t->inDataSize -= lim;\r
      *inLim = lim;\r
      return (const Byte *)MTDEC__DATA_PTR_FROM_LINK(t->inBuf);\r
    }\r
  }\r
\r
  {\r
    size_t crossSize = p->crossEnd - p->crossStart;\r
    if (crossSize != 0)\r
    {\r
      const Byte *data = MTDEC__DATA_PTR_FROM_LINK(p->crossBlock) + p->crossStart;\r
      *inLim = crossSize;\r
      p->crossStart = 0;\r
      p->crossEnd = 0;\r
      return data;\r
    }\r
    *inLim = 0;\r
    if (p->crossBlock)\r
    {\r
      ISzAlloc_Free(p->alloc, p->crossBlock);\r
      p->crossBlock = NULL;\r
    }\r
    return NULL;\r
  }\r
}\r
\r
\r
void MtDec_Construct(CMtDec *p)\r
{\r
  unsigned i;\r
  \r
  p->inBufSize = (size_t)1 << 18;\r
\r
  p->numThreadsMax = 0;\r
\r
  p->inStream = NULL;\r
  \r
  // p->inData = NULL;\r
  // p->inDataSize = 0;\r
\r
  p->crossBlock = NULL;\r
  p->crossStart = 0;\r
  p->crossEnd = 0;\r
\r
  p->numFilledThreads = 0;\r
\r
  p->progress = NULL;\r
  p->alloc = NULL;\r
\r
  p->mtCallback = NULL;\r
  p->mtCallbackObject = NULL;\r
\r
  p->allocatedBufsSize = 0;\r
\r
  for (i = 0; i < MTDEC__THREADS_MAX; i++)\r
  {\r
    CMtDecThread *t = &p->threads[i];\r
    t->mtDec = p;\r
    t->index = i;\r
    t->inBuf = NULL;\r
    Event_Construct(&t->canRead);\r
    Event_Construct(&t->canWrite);\r
    Thread_Construct(&t->thread);\r
  }\r
\r
  // Event_Construct(&p->finishedEvent);\r
\r
  CriticalSection_Init(&p->mtProgress.cs);\r
}\r
\r
\r
static void MtDec_Free(CMtDec *p)\r
{\r
  unsigned i;\r
\r
  p->exitThread = True;\r
\r
  for (i = 0; i < MTDEC__THREADS_MAX; i++)\r
    MtDecThread_Destruct(&p->threads[i]);\r
\r
  // Event_Close(&p->finishedEvent);\r
\r
  if (p->crossBlock)\r
  {\r
    ISzAlloc_Free(p->alloc, p->crossBlock);\r
    p->crossBlock = NULL;\r
  }\r
}\r
\r
\r
void MtDec_Destruct(CMtDec *p)\r
{\r
  MtDec_Free(p);\r
\r
  CriticalSection_Delete(&p->mtProgress.cs);\r
}\r
\r
\r
SRes MtDec_Code(CMtDec *p)\r
{\r
  unsigned i;\r
\r
  p->inProcessed = 0;\r
\r
  p->blockIndex = 1; // it must be larger than not_defined index (0)\r
  p->isAllocError = False;\r
  p->overflow = False;\r
  p->threadingErrorSRes = SZ_OK;\r
\r
  p->needContinue = True;\r
\r
  p->readWasFinished = False;\r
  p->needInterrupt = False;\r
  p->interruptIndex = (UInt64)(Int64)-1;\r
\r
  p->readProcessed = 0;\r
  p->readRes = SZ_OK;\r
  p->codeRes = SZ_OK;\r
  p->wasInterrupted = False;\r
\r
  p->crossStart = 0;\r
  p->crossEnd = 0;\r
\r
  p->filledThreadStart = 0;\r
  p->numFilledThreads = 0;\r
\r
  {\r
    unsigned numThreads = p->numThreadsMax;\r
    if (numThreads > MTDEC__THREADS_MAX)\r
      numThreads = MTDEC__THREADS_MAX;\r
    p->numStartedThreads_Limit = numThreads;\r
    p->numStartedThreads = 0;\r
  }\r
\r
  if (p->inBufSize != p->allocatedBufsSize)\r
  {\r
    for (i = 0; i < MTDEC__THREADS_MAX; i++)\r
    {\r
      CMtDecThread *t = &p->threads[i];\r
      if (t->inBuf)\r
        MtDecThread_FreeInBufs(t);\r
    }\r
    if (p->crossBlock)\r
    {\r
      ISzAlloc_Free(p->alloc, p->crossBlock);\r
      p->crossBlock = NULL;\r
    }\r
\r
    p->allocatedBufsSize = p->inBufSize;\r
  }\r
\r
  MtProgress_Init(&p->mtProgress, p->progress);\r
\r
  // RINOK_THREAD(ArEvent_OptCreate_And_Reset(&p->finishedEvent));\r
  p->exitThread = False;\r
  p->exitThreadWRes = 0;\r
\r
  {\r
    WRes wres;\r
    SRes sres;\r
    CMtDecThread *nextThread = &p->threads[p->numStartedThreads++];\r
    // wres = MtDecThread_CreateAndStart(nextThread);\r
    wres = MtDecThread_CreateEvents(nextThread);\r
    if (wres == 0) { wres = Event_Set(&nextThread->canWrite);\r
    if (wres == 0) { wres = Event_Set(&nextThread->canRead);\r
    if (wres == 0) { THREAD_FUNC_RET_TYPE res = ThreadFunc(nextThread);\r
    wres = (WRes)(UINT_PTR)res;\r
    if (wres != 0)\r
    {\r
      p->needContinue = False;\r
      MtDec_CloseThreads(p);\r
    }}}}\r
\r
    // wres = 17; // for test\r
    // wres = Event_Wait(&p->finishedEvent);\r
\r
    sres = MY_SRes_HRESULT_FROM_WRes(wres);\r
\r
    if (sres != 0)\r
      p->threadingErrorSRes = sres;\r
\r
    if (\r
        // wres == 0\r
        // wres != 0\r
        // || p->mtc.codeRes == SZ_ERROR_MEM\r
        p->isAllocError\r
        || p->threadingErrorSRes != SZ_OK\r
        || p->overflow)\r
    {\r
      // p->needContinue = True;\r
    }\r
    else\r
      p->needContinue = False;\r
    \r
    if (p->needContinue)\r
      return SZ_OK;\r
\r
    // if (sres != SZ_OK)\r
    return sres;\r
    // return SZ_ERROR_FAIL;\r
  }\r
}\r
\r
#endif\r