other-licenses/7zstub/src/C/XzDec.c

   1 /* XzDec.c -- Xz Decode
   2 2018-04-24 : Igor Pavlov : Public domain */
   3
   4 #include "Precomp.h"
   5
   6 // #include <stdio.h>
   7
   8 // #define XZ_DUMP
   9
  10 /* #define XZ_DUMP */
  11
  12 #ifdef XZ_DUMP
  13 #include <stdio.h>
  14 #endif
  15
  16 // #define SHOW_DEBUG_INFO
  17
  18 #ifdef SHOW_DEBUG_INFO
  19 #include <stdio.h>
  20 #endif
  21
  22 #ifdef SHOW_DEBUG_INFO
  23 #define PRF(x) x
  24 #else
  25 #define PRF(x)
  26 #endif
  27
  28 #define PRF_STR(s) PRF(printf("\n" s "\n"))
  29 #define PRF_STR_INT(s, d) PRF(printf("\n" s " %d\n", (unsigned)d))
  30
  31 #include <stdlib.h>
  32 #include <string.h>
  33
  34 #include "7zCrc.h"
  35 #include "Alloc.h"
  36 #include "Bra.h"
  37 #include "CpuArch.h"
  38 #include "Delta.h"
  39 #include "Lzma2Dec.h"
  40
  41 // #define USE_SUBBLOCK
  42
  43 #ifdef USE_SUBBLOCK
  44 #include "Bcj3Dec.c"
  45 #include "SbDec.h"
  46 #endif
  47
  48 #include "Xz.h"
  49
  50 #define XZ_CHECK_SIZE_MAX 64
  51
  52 #define CODER_BUF_SIZE ((size_t)1 << 17)
  53
  54 unsigned Xz_ReadVarInt(const Byte *p, size_t maxSize, UInt64 *value)
  55 {
  56   unsigned i, limit;
  57   *value = 0;
  58   limit = (maxSize > 9) ? 9 : (unsigned)maxSize;
  59
  60   for (i = 0; i < limit;)
  61   {
  62     Byte b = p[i];
  63     *value |= (UInt64)(b & 0x7F) << (7 * i++);
  64     if ((b & 0x80) == 0)
  65       return (b == 0 && i != 1) ? 0 : i;
  66   }
  67   return 0;
  68 }
  69
  70 /* ---------- BraState ---------- */
  71
  72 #define BRA_BUF_SIZE (1 << 14)
  73
  74 typedef struct
  75 {
  76   size_t bufPos;
  77   size_t bufConv;
  78   size_t bufTotal;
  79
  80   int encodeMode;
  81
  82   UInt32 methodId;
  83   UInt32 delta;
  84   UInt32 ip;
  85   UInt32 x86State;
  86   Byte deltaState[DELTA_STATE_SIZE];
  87
  88   Byte buf[BRA_BUF_SIZE];
  89 } CBraState;
  90
  91 static void BraState_Free(void *pp, ISzAllocPtr alloc)
  92 {
  93   ISzAlloc_Free(alloc, pp);
  94 }
  95
  96 static SRes BraState_SetProps(void *pp, const Byte *props, size_t propSize, ISzAllocPtr alloc)
  97 {
  98   CBraState *p = ((CBraState *)pp);
  99   UNUSED_VAR(alloc);
 100   p->ip = 0;
 101   if (p->methodId == XZ_ID_Delta)
 102   {
 103     if (propSize != 1)
 104       return SZ_ERROR_UNSUPPORTED;
 105     p->delta = (unsigned)props[0] + 1;
 106   }
 107   else
 108   {
 109     if (propSize == 4)
 110     {
 111       UInt32 v = GetUi32(props);
 112       switch (p->methodId)
 113       {
 114         case XZ_ID_PPC:
 115         case XZ_ID_ARM:
 116         case XZ_ID_SPARC:
 117           if ((v & 3) != 0)
 118             return SZ_ERROR_UNSUPPORTED;
 119           break;
 120         case XZ_ID_ARMT:
 121           if ((v & 1) != 0)
 122             return SZ_ERROR_UNSUPPORTED;
 123           break;
 124         case XZ_ID_IA64:
 125           if ((v & 0xF) != 0)
 126             return SZ_ERROR_UNSUPPORTED;
 127           break;
 128       }
 129       p->ip = v;
 130     }
 131     else if (propSize != 0)
 132       return SZ_ERROR_UNSUPPORTED;
 133   }
 134   return SZ_OK;
 135 }
 136
 137 static void BraState_Init(void *pp)
 138 {
 139   CBraState *p = ((CBraState *)pp);
 140   p->bufPos = p->bufConv = p->bufTotal = 0;
 141   x86_Convert_Init(p->x86State);
 142   if (p->methodId == XZ_ID_Delta)
 143     Delta_Init(p->deltaState);
 144 }
 145
 146
 147 #define CASE_BRA_CONV(isa) case XZ_ID_ ## isa: size = isa ## _Convert(data, size, p->ip, p->encodeMode); break;
 148
 149 static SizeT BraState_Filter(void *pp, Byte *data, SizeT size)
 150 {
 151   CBraState *p = ((CBraState *)pp);
 152   switch (p->methodId)
 153   {
 154     case XZ_ID_Delta:
 155       if (p->encodeMode)
 156         Delta_Encode(p->deltaState, p->delta, data, size);
 157       else
 158         Delta_Decode(p->deltaState, p->delta, data, size);
 159       break;
 160     case XZ_ID_X86:
 161       size = x86_Convert(data, size, p->ip, &p->x86State, p->encodeMode);
 162       break;
 163     CASE_BRA_CONV(PPC)
 164     CASE_BRA_CONV(IA64)
 165     CASE_BRA_CONV(ARM)
 166     CASE_BRA_CONV(ARMT)
 167     CASE_BRA_CONV(SPARC)
 168   }
 169   p->ip += (UInt32)size;
 170   return size;
 171 }
 172
 173
 174 static SRes BraState_Code2(void *pp,
 175     Byte *dest, SizeT *destLen,
 176     const Byte *src, SizeT *srcLen, int srcWasFinished,
 177     ECoderFinishMode finishMode,
 178     // int *wasFinished
 179     ECoderStatus *status)
 180 {
 181   CBraState *p = ((CBraState *)pp);
 182   SizeT destRem = *destLen;
 183   SizeT srcRem = *srcLen;
 184   UNUSED_VAR(finishMode);
 185
 186   *destLen = 0;
 187   *srcLen = 0;
 188   // *wasFinished = False;
 189   *status = CODER_STATUS_NOT_FINISHED;
 190
 191   while (destRem > 0)
 192   {
 193     if (p->bufPos != p->bufConv)
 194     {
 195       size_t size = p->bufConv - p->bufPos;
 196       if (size > destRem)
 197         size = destRem;
 198       memcpy(dest, p->buf + p->bufPos, size);
 199       p->bufPos += size;
 200       *destLen += size;
 201       dest += size;
 202       destRem -= size;
 203       continue;
 204     }
 205
 206     p->bufTotal -= p->bufPos;
 207     memmove(p->buf, p->buf + p->bufPos, p->bufTotal);
 208     p->bufPos = 0;
 209     p->bufConv = 0;
 210     {
 211       size_t size = BRA_BUF_SIZE - p->bufTotal;
 212       if (size > srcRem)
 213         size = srcRem;
 214       memcpy(p->buf + p->bufTotal, src, size);
 215       *srcLen += size;
 216       src += size;
 217       srcRem -= size;
 218       p->bufTotal += size;
 219     }
 220     if (p->bufTotal == 0)
 221       break;
 222
 223     p->bufConv = BraState_Filter(pp, p->buf, p->bufTotal);
 224
 225     if (p->bufConv == 0)
 226     {
 227       if (!srcWasFinished)
 228         break;
 229       p->bufConv = p->bufTotal;
 230     }
 231   }
 232
 233   if (p->bufTotal == p->bufPos && srcRem == 0 && srcWasFinished)
 234   {
 235     *status = CODER_STATUS_FINISHED_WITH_MARK;
 236     // *wasFinished = 1;
 237   }
 238
 239   return SZ_OK;
 240 }
 241
 242
 243 SRes BraState_SetFromMethod(IStateCoder *p, UInt64 id, int encodeMode, ISzAllocPtr alloc)
 244 {
 245   CBraState *decoder;
 246   if (id < XZ_ID_Delta || id > XZ_ID_SPARC)
 247     return SZ_ERROR_UNSUPPORTED;
 248   decoder = p->p;
 249   if (!decoder)
 250   {
 251     decoder = (CBraState *)ISzAlloc_Alloc(alloc, sizeof(CBraState));
 252     if (!decoder)
 253       return SZ_ERROR_MEM;
 254     p->p = decoder;
 255     p->Free = BraState_Free;
 256     p->SetProps = BraState_SetProps;
 257     p->Init = BraState_Init;
 258     p->Code2 = BraState_Code2;
 259     p->Filter = BraState_Filter;
 260   }
 261   decoder->methodId = (UInt32)id;
 262   decoder->encodeMode = encodeMode;
 263   return SZ_OK;
 264 }
 265
 266
 267
 268 /* ---------- SbState ---------- */
 269
 270 #ifdef USE_SUBBLOCK
 271
 272 static void SbState_Free(void *pp, ISzAllocPtr alloc)
 273 {
 274   CSbDec *p = (CSbDec *)pp;
 275   SbDec_Free(p);
 276   ISzAlloc_Free(alloc, pp);
 277 }
 278
 279 static SRes SbState_SetProps(void *pp, const Byte *props, size_t propSize, ISzAllocPtr alloc)
 280 {
 281   UNUSED_VAR(pp);
 282   UNUSED_VAR(props);
 283   UNUSED_VAR(alloc);
 284   return (propSize == 0) ? SZ_OK : SZ_ERROR_UNSUPPORTED;
 285 }
 286
 287 static void SbState_Init(void *pp)
 288 {
 289   SbDec_Init((CSbDec *)pp);
 290 }
 291
 292 static SRes SbState_Code2(void *pp, Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,
 293     int srcWasFinished, ECoderFinishMode finishMode,
 294     // int *wasFinished
 295     ECoderStatus *status)
 296 {
 297   CSbDec *p = (CSbDec *)pp;
 298   SRes res;
 299   UNUSED_VAR(srcWasFinished);
 300   p->dest = dest;
 301   p->destLen = *destLen;
 302   p->src = src;
 303   p->srcLen = *srcLen;
 304   p->finish = finishMode; /* change it */
 305   res = SbDec_Decode((CSbDec *)pp);
 306   *destLen -= p->destLen;
 307   *srcLen -= p->srcLen;
 308   // *wasFinished = (*destLen == 0 && *srcLen == 0); /* change it */
 309   *status = (*destLen == 0 && *srcLen == 0) ?
 310       CODER_STATUS_FINISHED_WITH_MARK :
 311       CODER_STATUS_NOT_FINISHED;
 312   return res;
 313 }
 314
 315 static SRes SbState_SetFromMethod(IStateCoder *p, ISzAllocPtr alloc)
 316 {
 317   CSbDec *decoder = (CSbDec *)p->p;
 318   if (!decoder)
 319   {
 320     decoder = (CSbDec *)ISzAlloc_Alloc(alloc, sizeof(CSbDec));
 321     if (!decoder)
 322       return SZ_ERROR_MEM;
 323     p->p = decoder;
 324     p->Free = SbState_Free;
 325     p->SetProps = SbState_SetProps;
 326     p->Init = SbState_Init;
 327     p->Code2 = SbState_Code2;
 328     p->Filter = NULL;
 329   }
 330   SbDec_Construct(decoder);
 331   SbDec_SetAlloc(decoder, alloc);
 332   return SZ_OK;
 333 }
 334
 335 #endif
 336
 337
 338
 339 /* ---------- Lzma2 ---------- */
 340
 341 typedef struct
 342 {
 343   CLzma2Dec decoder;
 344   Bool outBufMode;
 345 } CLzma2Dec_Spec;
 346
 347
 348 static void Lzma2State_Free(void *pp, ISzAllocPtr alloc)
 349 {
 350   CLzma2Dec_Spec *p = (CLzma2Dec_Spec *)pp;
 351   if (p->outBufMode)
 352     Lzma2Dec_FreeProbs(&p->decoder, alloc);
 353   else
 354     Lzma2Dec_Free(&p->decoder, alloc);
 355   ISzAlloc_Free(alloc, pp);
 356 }
 357
 358 static SRes Lzma2State_SetProps(void *pp, const Byte *props, size_t propSize, ISzAllocPtr alloc)
 359 {
 360   if (propSize != 1)
 361     return SZ_ERROR_UNSUPPORTED;
 362   {
 363     CLzma2Dec_Spec *p = (CLzma2Dec_Spec *)pp;
 364     if (p->outBufMode)
 365       return Lzma2Dec_AllocateProbs(&p->decoder, props[0], alloc);
 366     else
 367       return Lzma2Dec_Allocate(&p->decoder, props[0], alloc);
 368   }
 369 }
 370
 371 static void Lzma2State_Init(void *pp)
 372 {
 373   Lzma2Dec_Init(&((CLzma2Dec_Spec *)pp)->decoder);
 374 }
 375
 376
 377 /*
 378   if (outBufMode), then (dest) is not used. Use NULL.
 379          Data is unpacked to (spec->decoder.decoder.dic) output buffer.
 380 */
 381
 382 static SRes Lzma2State_Code2(void *pp, Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,
 383     int srcWasFinished, ECoderFinishMode finishMode,
 384     // int *wasFinished,
 385     ECoderStatus *status)
 386 {
 387   CLzma2Dec_Spec *spec = (CLzma2Dec_Spec *)pp;
 388   ELzmaStatus status2;
 389   /* ELzmaFinishMode fm = (finishMode == LZMA_FINISH_ANY) ? LZMA_FINISH_ANY : LZMA_FINISH_END; */
 390   SRes res;
 391   UNUSED_VAR(srcWasFinished);
 392   if (spec->outBufMode)
 393   {
 394     SizeT dicPos = spec->decoder.decoder.dicPos;
 395     SizeT dicLimit = dicPos + *destLen;
 396     res = Lzma2Dec_DecodeToDic(&spec->decoder, dicLimit, src, srcLen, (ELzmaFinishMode)finishMode, &status2);
 397     *destLen = spec->decoder.decoder.dicPos - dicPos;
 398   }
 399   else
 400     res = Lzma2Dec_DecodeToBuf(&spec->decoder, dest, destLen, src, srcLen, (ELzmaFinishMode)finishMode, &status2);
 401   // *wasFinished = (status2 == LZMA_STATUS_FINISHED_WITH_MARK);
 402   // ECoderStatus values are identical to ELzmaStatus values of LZMA2 decoder
 403   *status = status2;
 404   return res;
 405 }
 406
 407
 408 static SRes Lzma2State_SetFromMethod(IStateCoder *p, Byte *outBuf, size_t outBufSize, ISzAllocPtr alloc)
 409 {
 410   CLzma2Dec_Spec *spec = (CLzma2Dec_Spec *)p->p;
 411   if (!spec)
 412   {
 413     spec = (CLzma2Dec_Spec *)ISzAlloc_Alloc(alloc, sizeof(CLzma2Dec_Spec));
 414     if (!spec)
 415       return SZ_ERROR_MEM;
 416     p->p = spec;
 417     p->Free = Lzma2State_Free;
 418     p->SetProps = Lzma2State_SetProps;
 419     p->Init = Lzma2State_Init;
 420     p->Code2 = Lzma2State_Code2;
 421     p->Filter = NULL;
 422     Lzma2Dec_Construct(&spec->decoder);
 423   }
 424   spec->outBufMode = False;
 425   if (outBuf)
 426   {
 427     spec->outBufMode = True;
 428     spec->decoder.decoder.dic = outBuf;
 429     spec->decoder.decoder.dicBufSize = outBufSize;
 430   }
 431   return SZ_OK;
 432 }
 433
 434
 435 static SRes Lzma2State_ResetOutBuf(IStateCoder *p, Byte *outBuf, size_t outBufSize)
 436 {
 437   CLzma2Dec_Spec *spec = (CLzma2Dec_Spec *)p->p;
 438   if ((spec->outBufMode && !outBuf) || (!spec->outBufMode && outBuf))
 439     return SZ_ERROR_FAIL;
 440   if (outBuf)
 441   {
 442     spec->decoder.decoder.dic = outBuf;
 443     spec->decoder.decoder.dicBufSize = outBufSize;
 444   }
 445   return SZ_OK;
 446 }
 447
 448
 449
 450 static void MixCoder_Construct(CMixCoder *p, ISzAllocPtr alloc)
 451 {
 452   unsigned i;
 453   p->alloc = alloc;
 454   p->buf = NULL;
 455   p->numCoders = 0;
 456
 457   p->outBufSize = 0;
 458   p->outBuf = NULL;
 459   // p->SingleBufMode = False;
 460
 461   for (i = 0; i < MIXCODER_NUM_FILTERS_MAX; i++)
 462     p->coders[i].p = NULL;
 463 }
 464
 465
 466 static void MixCoder_Free(CMixCoder *p)
 467 {
 468   unsigned i;
 469   p->numCoders = 0;
 470   for (i = 0; i < MIXCODER_NUM_FILTERS_MAX; i++)
 471   {
 472     IStateCoder *sc = &p->coders[i];
 473     if (sc->p)
 474     {
 475       sc->Free(sc->p, p->alloc);
 476       sc->p = NULL;
 477     }
 478   }
 479   if (p->buf)
 480   {
 481     ISzAlloc_Free(p->alloc, p->buf);
 482     p->buf = NULL; /* 9.31: the BUG was fixed */
 483   }
 484 }
 485
 486 static void MixCoder_Init(CMixCoder *p)
 487 {
 488   unsigned i;
 489   for (i = 0; i < MIXCODER_NUM_FILTERS_MAX - 1; i++)
 490   {
 491     p->size[i] = 0;
 492     p->pos[i] = 0;
 493     p->finished[i] = 0;
 494   }
 495   for (i = 0; i < p->numCoders; i++)
 496   {
 497     IStateCoder *coder = &p->coders[i];
 498     coder->Init(coder->p);
 499     p->results[i] = SZ_OK;
 500   }
 501   p->outWritten = 0;
 502   p->wasFinished = False;
 503   p->res = SZ_OK;
 504   p->status = CODER_STATUS_NOT_SPECIFIED;
 505 }
 506
 507
 508 static SRes MixCoder_SetFromMethod(CMixCoder *p, unsigned coderIndex, UInt64 methodId, Byte *outBuf, size_t outBufSize)
 509 {
 510   IStateCoder *sc = &p->coders[coderIndex];
 511   p->ids[coderIndex] = methodId;
 512   switch (methodId)
 513   {
 514     case XZ_ID_LZMA2: return Lzma2State_SetFromMethod(sc, outBuf, outBufSize, p->alloc);
 515     #ifdef USE_SUBBLOCK
 516     case XZ_ID_Subblock: return SbState_SetFromMethod(sc, p->alloc);
 517     #endif
 518   }
 519   if (coderIndex == 0)
 520     return SZ_ERROR_UNSUPPORTED;
 521   return BraState_SetFromMethod(sc, methodId, 0, p->alloc);
 522 }
 523
 524
 525 static SRes MixCoder_ResetFromMethod(CMixCoder *p, unsigned coderIndex, UInt64 methodId, Byte *outBuf, size_t outBufSize)
 526 {
 527   IStateCoder *sc = &p->coders[coderIndex];
 528   switch (methodId)
 529   {
 530     case XZ_ID_LZMA2: return Lzma2State_ResetOutBuf(sc, outBuf, outBufSize);
 531   }
 532   return SZ_ERROR_UNSUPPORTED;
 533 }
 534
 535
 536
 537 /*
 538  if (destFinish) - then unpack data block is finished at (*destLen) position,
 539                    and we can return data that were not processed by filter
 540
 541 output (status) can be :
 542   CODER_STATUS_NOT_FINISHED
 543   CODER_STATUS_FINISHED_WITH_MARK
 544   CODER_STATUS_NEEDS_MORE_INPUT - not implemented still
 545 */
 546
 547 static SRes MixCoder_Code(CMixCoder *p,
 548     Byte *dest, SizeT *destLen, int destFinish,
 549     const Byte *src, SizeT *srcLen, int srcWasFinished,
 550     ECoderFinishMode finishMode)
 551 {
 552   SizeT destLenOrig = *destLen;
 553   SizeT srcLenOrig = *srcLen;
 554
 555   *destLen = 0;
 556   *srcLen = 0;
 557
 558   if (p->wasFinished)
 559     return p->res;
 560
 561   p->status = CODER_STATUS_NOT_FINISHED;
 562
 563   // if (p->SingleBufMode)
 564   if (p->outBuf)
 565   {
 566     SRes res;
 567     SizeT destLen2, srcLen2;
 568     int wasFinished;
 569
 570     PRF_STR("------- MixCoder Single ----------");
 571
 572     srcLen2 = srcLenOrig;
 573     destLen2 = destLenOrig;
 574
 575     {
 576       IStateCoder *coder = &p->coders[0];
 577       res = coder->Code2(coder->p, NULL, &destLen2, src, &srcLen2, srcWasFinished, finishMode,
 578           // &wasFinished,
 579           &p->status);
 580       wasFinished = (p->status == CODER_STATUS_FINISHED_WITH_MARK);
 581     }
 582
 583     p->res = res;
 584
 585     /*
 586     if (wasFinished)
 587       p->status = CODER_STATUS_FINISHED_WITH_MARK;
 588     else
 589     {
 590       if (res == SZ_OK)
 591         if (destLen2 != destLenOrig)
 592           p->status = CODER_STATUS_NEEDS_MORE_INPUT;
 593     }
 594     */
 595
 596
 597     *srcLen = srcLen2;
 598     src += srcLen2;
 599     p->outWritten += destLen2;
 600
 601     if (res != SZ_OK || srcWasFinished || wasFinished)
 602       p->wasFinished = True;
 603
 604     if (p->numCoders == 1)
 605       *destLen = destLen2;
 606     else if (p->wasFinished)
 607     {
 608       unsigned i;
 609       size_t processed = p->outWritten;
 610
 611       for (i = 1; i < p->numCoders; i++)
 612       {
 613         IStateCoder *coder = &p->coders[i];
 614         processed = coder->Filter(coder->p, p->outBuf, processed);
 615         if (wasFinished || (destFinish && p->outWritten == destLenOrig))
 616           processed = p->outWritten;
 617         PRF_STR_INT("filter", i);
 618       }
 619       *destLen = processed;
 620     }
 621     return res;
 622   }
 623
 624   PRF_STR("standard mix");
 625
 626   if (p->numCoders != 1)
 627   {
 628     if (!p->buf)
 629     {
 630       p->buf = (Byte *)ISzAlloc_Alloc(p->alloc, CODER_BUF_SIZE * (MIXCODER_NUM_FILTERS_MAX - 1));
 631       if (!p->buf)
 632         return SZ_ERROR_MEM;
 633     }
 634
 635     finishMode = CODER_FINISH_ANY;
 636   }
 637
 638   for (;;)
 639   {
 640     Bool processed = False;
 641     Bool allFinished = True;
 642     SRes resMain = SZ_OK;
 643     unsigned i;
 644
 645     p->status = CODER_STATUS_NOT_FINISHED;
 646     /*
 647     if (p->numCoders == 1 && *destLen == destLenOrig && finishMode == LZMA_FINISH_ANY)
 648       break;
 649     */
 650
 651     for (i = 0; i < p->numCoders; i++)
 652     {
 653       SRes res;
 654       IStateCoder *coder = &p->coders[i];
 655       Byte *dest2;
 656       SizeT destLen2, srcLen2; // destLen2_Orig;
 657       const Byte *src2;
 658       int srcFinished2;
 659       int encodingWasFinished;
 660       ECoderStatus status2;
 661
 662       if (i == 0)
 663       {
 664         src2 = src;
 665         srcLen2 = srcLenOrig - *srcLen;
 666         srcFinished2 = srcWasFinished;
 667       }
 668       else
 669       {
 670         size_t k = i - 1;
 671         src2 = p->buf + (CODER_BUF_SIZE * k) + p->pos[k];
 672         srcLen2 = p->size[k] - p->pos[k];
 673         srcFinished2 = p->finished[k];
 674       }
 675
 676       if (i == p->numCoders - 1)
 677       {
 678         dest2 = dest;
 679         destLen2 = destLenOrig - *destLen;
 680       }
 681       else
 682       {
 683         if (p->pos[i] != p->size[i])
 684           continue;
 685         dest2 = p->buf + (CODER_BUF_SIZE * i);
 686         destLen2 = CODER_BUF_SIZE;
 687       }
 688
 689       // destLen2_Orig = destLen2;
 690
 691       if (p->results[i] != SZ_OK)
 692       {
 693         if (resMain == SZ_OK)
 694           resMain = p->results[i];
 695         continue;
 696       }
 697
 698       res = coder->Code2(coder->p,
 699           dest2, &destLen2,
 700           src2, &srcLen2, srcFinished2,
 701           finishMode,
 702           // &encodingWasFinished,
 703           &status2);
 704
 705       if (res != SZ_OK)
 706       {
 707         p->results[i] = res;
 708         if (resMain == SZ_OK)
 709           resMain = res;
 710       }
 711
 712       encodingWasFinished = (status2 == CODER_STATUS_FINISHED_WITH_MARK);
 713
 714       if (!encodingWasFinished)
 715       {
 716         allFinished = False;
 717         if (p->numCoders == 1 && res == SZ_OK)
 718           p->status = status2;
 719       }
 720
 721       if (i == 0)
 722       {
 723         *srcLen += srcLen2;
 724         src += srcLen2;
 725       }
 726       else
 727         p->pos[(size_t)i - 1] += srcLen2;
 728
 729       if (i == p->numCoders - 1)
 730       {
 731         *destLen += destLen2;
 732         dest += destLen2;
 733       }
 734       else
 735       {
 736         p->size[i] = destLen2;
 737         p->pos[i] = 0;
 738         p->finished[i] = encodingWasFinished;
 739       }
 740
 741       if (destLen2 != 0 || srcLen2 != 0)
 742         processed = True;
 743     }
 744
 745     if (!processed)
 746     {
 747       if (allFinished)
 748         p->status = CODER_STATUS_FINISHED_WITH_MARK;
 749       return resMain;
 750     }
 751   }
 752 }
 753
 754
 755 SRes Xz_ParseHeader(CXzStreamFlags *p, const Byte *buf)
 756 {
 757   *p = (CXzStreamFlags)GetBe16(buf + XZ_SIG_SIZE);
 758   if (CrcCalc(buf + XZ_SIG_SIZE, XZ_STREAM_FLAGS_SIZE) !=
 759       GetUi32(buf + XZ_SIG_SIZE + XZ_STREAM_FLAGS_SIZE))
 760     return SZ_ERROR_NO_ARCHIVE;
 761   return XzFlags_IsSupported(*p) ? SZ_OK : SZ_ERROR_UNSUPPORTED;
 762 }
 763
 764 static Bool Xz_CheckFooter(CXzStreamFlags flags, UInt64 indexSize, const Byte *buf)
 765 {
 766   return indexSize == (((UInt64)GetUi32(buf + 4) + 1) << 2)
 767       && GetUi32(buf) == CrcCalc(buf + 4, 6)
 768       && flags == GetBe16(buf + 8)
 769       && buf[10] == XZ_FOOTER_SIG_0
 770       && buf[11] == XZ_FOOTER_SIG_1;
 771 }
 772
 773 #define READ_VARINT_AND_CHECK(buf, pos, size, res) \
 774   { unsigned s = Xz_ReadVarInt(buf + pos, size - pos, res); \
 775   if (s == 0) return SZ_ERROR_ARCHIVE; pos += s; }
 776
 777
 778 static Bool XzBlock_AreSupportedFilters(const CXzBlock *p)
 779 {
 780   unsigned numFilters = XzBlock_GetNumFilters(p) - 1;
 781   unsigned i;
 782   {
 783     const CXzFilter *f = &p->filters[numFilters];
 784     if (f->id != XZ_ID_LZMA2 || f->propsSize != 1 || f->props[0] > 40)
 785       return False;
 786   }
 787
 788   for (i = 0; i < numFilters; i++)
 789   {
 790     const CXzFilter *f = &p->filters[i];
 791     if (f->id == XZ_ID_Delta)
 792     {
 793       if (f->propsSize != 1)
 794         return False;
 795     }
 796     else if (f->id < XZ_ID_Delta
 797         || f->id > XZ_ID_SPARC
 798         || (f->propsSize != 0 && f->propsSize != 4))
 799       return False;
 800   }
 801   return True;
 802 }
 803
 804
 805 SRes XzBlock_Parse(CXzBlock *p, const Byte *header)
 806 {
 807   unsigned pos;
 808   unsigned numFilters, i;
 809   unsigned headerSize = (unsigned)header[0] << 2;
 810
 811   /* (headerSize != 0) : another code checks */
 812
 813   if (CrcCalc(header, headerSize) != GetUi32(header + headerSize))
 814     return SZ_ERROR_ARCHIVE;
 815
 816   pos = 1;
 817   p->flags = header[pos++];
 818
 819   p->packSize = (UInt64)(Int64)-1;
 820   if (XzBlock_HasPackSize(p))
 821   {
 822     READ_VARINT_AND_CHECK(header, pos, headerSize, &p->packSize);
 823     if (p->packSize == 0 || p->packSize + headerSize >= (UInt64)1 << 63)
 824       return SZ_ERROR_ARCHIVE;
 825   }
 826
 827   p->unpackSize = (UInt64)(Int64)-1;
 828   if (XzBlock_HasUnpackSize(p))
 829     READ_VARINT_AND_CHECK(header, pos, headerSize, &p->unpackSize);
 830
 831   numFilters = XzBlock_GetNumFilters(p);
 832   for (i = 0; i < numFilters; i++)
 833   {
 834     CXzFilter *filter = p->filters + i;
 835     UInt64 size;
 836     READ_VARINT_AND_CHECK(header, pos, headerSize, &filter->id);
 837     READ_VARINT_AND_CHECK(header, pos, headerSize, &size);
 838     if (size > headerSize - pos || size > XZ_FILTER_PROPS_SIZE_MAX)
 839       return SZ_ERROR_ARCHIVE;
 840     filter->propsSize = (UInt32)size;
 841     memcpy(filter->props, header + pos, (size_t)size);
 842     pos += (unsigned)size;
 843
 844     #ifdef XZ_DUMP
 845     printf("\nf[%u] = %2X: ", i, (unsigned)filter->id);
 846     {
 847       unsigned i;
 848       for (i = 0; i < size; i++)
 849         printf(" %2X", filter->props[i]);
 850     }
 851     #endif
 852   }
 853
 854   if (XzBlock_HasUnsupportedFlags(p))
 855     return SZ_ERROR_UNSUPPORTED;
 856
 857   while (pos < headerSize)
 858     if (header[pos++] != 0)
 859       return SZ_ERROR_ARCHIVE;
 860   return SZ_OK;
 861 }
 862
 863
 864
 865
 866 static SRes XzDecMix_Init(CMixCoder *p, const CXzBlock *block, Byte *outBuf, size_t outBufSize)
 867 {
 868   unsigned i;
 869   Bool needReInit = True;
 870   unsigned numFilters = XzBlock_GetNumFilters(block);
 871
 872   if (numFilters == p->numCoders && ((p->outBuf && outBuf) || (!p->outBuf && !outBuf)))
 873   {
 874     needReInit = False;
 875     for (i = 0; i < numFilters; i++)
 876       if (p->ids[i] != block->filters[numFilters - 1 - i].id)
 877       {
 878         needReInit = True;
 879         break;
 880       }
 881   }
 882
 883   // p->SingleBufMode = (outBuf != NULL);
 884   p->outBuf = outBuf;
 885   p->outBufSize = outBufSize;
 886
 887   // p->SingleBufMode = False;
 888   // outBuf = NULL;
 889
 890   if (needReInit)
 891   {
 892     MixCoder_Free(p);
 893     for (i = 0; i < numFilters; i++)
 894     {
 895       RINOK(MixCoder_SetFromMethod(p, i, block->filters[numFilters - 1 - i].id, outBuf, outBufSize));
 896     }
 897     p->numCoders = numFilters;
 898   }
 899   else
 900   {
 901     RINOK(MixCoder_ResetFromMethod(p, 0, block->filters[numFilters - 1].id, outBuf, outBufSize));
 902   }
 903
 904   for (i = 0; i < numFilters; i++)
 905   {
 906     const CXzFilter *f = &block->filters[numFilters - 1 - i];
 907     IStateCoder *sc = &p->coders[i];
 908     RINOK(sc->SetProps(sc->p, f->props, f->propsSize, p->alloc));
 909   }
 910
 911   MixCoder_Init(p);
 912   return SZ_OK;
 913 }
 914
 915
 916
 917 void XzUnpacker_Init(CXzUnpacker *p)
 918 {
 919   p->state = XZ_STATE_STREAM_HEADER;
 920   p->pos = 0;
 921   p->numStartedStreams = 0;
 922   p->numFinishedStreams = 0;
 923   p->numTotalBlocks = 0;
 924   p->padSize = 0;
 925   p->decodeOnlyOneBlock = 0;
 926
 927   p->parseMode = False;
 928   p->decodeToStreamSignature = False;
 929
 930   // p->outBuf = NULL;
 931   // p->outBufSize = 0;
 932   p->outDataWritten = 0;
 933 }
 934
 935
 936 void XzUnpacker_SetOutBuf(CXzUnpacker *p, Byte *outBuf, size_t outBufSize)
 937 {
 938   p->outBuf = outBuf;
 939   p->outBufSize = outBufSize;
 940 }
 941
 942
 943 void XzUnpacker_Construct(CXzUnpacker *p, ISzAllocPtr alloc)
 944 {
 945   MixCoder_Construct(&p->decoder, alloc);
 946   p->outBuf = NULL;
 947   p->outBufSize = 0;
 948   XzUnpacker_Init(p);
 949 }
 950
 951
 952 void XzUnpacker_Free(CXzUnpacker *p)
 953 {
 954   MixCoder_Free(&p->decoder);
 955 }
 956
 957
 958 void XzUnpacker_PrepareToRandomBlockDecoding(CXzUnpacker *p)
 959 {
 960   p->indexSize = 0;
 961   p->numBlocks = 0;
 962   Sha256_Init(&p->sha);
 963   p->state = XZ_STATE_BLOCK_HEADER;
 964   p->pos = 0;
 965   p->decodeOnlyOneBlock = 1;
 966 }
 967
 968
 969 static void XzUnpacker_UpdateIndex(CXzUnpacker *p, UInt64 packSize, UInt64 unpackSize)
 970 {
 971   Byte temp[32];
 972   unsigned num = Xz_WriteVarInt(temp, packSize);
 973   num += Xz_WriteVarInt(temp + num, unpackSize);
 974   Sha256_Update(&p->sha, temp, num);
 975   p->indexSize += num;
 976   p->numBlocks++;
 977 }
 978
 979
 980
 981 SRes XzUnpacker_Code(CXzUnpacker *p, Byte *dest, SizeT *destLen,
 982     const Byte *src, SizeT *srcLen, int srcFinished,
 983     ECoderFinishMode finishMode, ECoderStatus *status)
 984 {
 985   SizeT destLenOrig = *destLen;
 986   SizeT srcLenOrig = *srcLen;
 987   *destLen = 0;
 988   *srcLen = 0;
 989   *status = CODER_STATUS_NOT_SPECIFIED;
 990
 991   for (;;)
 992   {
 993     SizeT srcRem;
 994
 995     if (p->state == XZ_STATE_BLOCK)
 996     {
 997       SizeT destLen2 = destLenOrig - *destLen;
 998       SizeT srcLen2 = srcLenOrig - *srcLen;
 999       SRes res;
1000
1001       ECoderFinishMode finishMode2 = finishMode;
1002       Bool srcFinished2 = srcFinished;
1003       Bool destFinish = False;
1004
1005       if (p->block.packSize != (UInt64)(Int64)-1)
1006       {
1007         UInt64 rem = p->block.packSize - p->packSize;
1008         if (srcLen2 >= rem)
1009         {
1010           srcFinished2 = True;
1011           srcLen2 = (SizeT)rem;
1012         }
1013         if (rem == 0 && p->block.unpackSize == p->unpackSize)
1014           return SZ_ERROR_DATA;
1015       }
1016
1017       if (p->block.unpackSize != (UInt64)(Int64)-1)
1018       {
1019         UInt64 rem = p->block.unpackSize - p->unpackSize;
1020         if (destLen2 >= rem)
1021         {
1022           destFinish = True;
1023           finishMode2 = CODER_FINISH_END;
1024           destLen2 = (SizeT)rem;
1025         }
1026       }
1027
1028       /*
1029       if (srcLen2 == 0 && destLen2 == 0)
1030       {
1031         *status = CODER_STATUS_NOT_FINISHED;
1032         return SZ_OK;
1033       }
1034       */
1035
1036       {
1037         res = MixCoder_Code(&p->decoder,
1038             (p->outBuf ? NULL : dest), &destLen2, destFinish,
1039             src, &srcLen2, srcFinished2,
1040             finishMode2);
1041
1042         *status = p->decoder.status;
1043         XzCheck_Update(&p->check, (p->outBuf ? p->outBuf + p->outDataWritten : dest), destLen2);
1044         if (!p->outBuf)
1045           dest += destLen2;
1046         p->outDataWritten += destLen2;
1047       }
1048
1049       (*srcLen) += srcLen2;
1050       src += srcLen2;
1051       p->packSize += srcLen2;
1052       (*destLen) += destLen2;
1053       p->unpackSize += destLen2;
1054
1055       RINOK(res);
1056
1057       if (*status != CODER_STATUS_FINISHED_WITH_MARK)
1058       {
1059         if (p->block.packSize == p->packSize
1060             && *status == CODER_STATUS_NEEDS_MORE_INPUT)
1061         {
1062           PRF_STR("CODER_STATUS_NEEDS_MORE_INPUT");
1063           *status = CODER_STATUS_NOT_SPECIFIED;
1064           return SZ_ERROR_DATA;
1065         }
1066
1067         return SZ_OK;
1068       }
1069       {
1070         XzUnpacker_UpdateIndex(p, XzUnpacker_GetPackSizeForIndex(p), p->unpackSize);
1071         p->state = XZ_STATE_BLOCK_FOOTER;
1072         p->pos = 0;
1073         p->alignPos = 0;
1074         *status = CODER_STATUS_NOT_SPECIFIED;
1075
1076         if ((p->block.packSize != (UInt64)(Int64)-1 && p->block.packSize != p->packSize)
1077            || (p->block.unpackSize != (UInt64)(Int64)-1 && p->block.unpackSize != p->unpackSize))
1078         {
1079           PRF_STR("ERROR: block.size mismatch");
1080           return SZ_ERROR_DATA;
1081         }
1082       }
1083       // continue;
1084     }
1085
1086     srcRem = srcLenOrig - *srcLen;
1087
1088     // XZ_STATE_BLOCK_FOOTER can transit to XZ_STATE_BLOCK_HEADER without input bytes
1089     if (srcRem == 0 && p->state != XZ_STATE_BLOCK_FOOTER)
1090     {
1091       *status = CODER_STATUS_NEEDS_MORE_INPUT;
1092       return SZ_OK;
1093     }
1094
1095     switch (p->state)
1096     {
1097       case XZ_STATE_STREAM_HEADER:
1098       {
1099         if (p->pos < XZ_STREAM_HEADER_SIZE)
1100         {
1101           if (p->pos < XZ_SIG_SIZE && *src != XZ_SIG[p->pos])
1102             return SZ_ERROR_NO_ARCHIVE;
1103           if (p->decodeToStreamSignature)
1104             return SZ_OK;
1105           p->buf[p->pos++] = *src++;
1106           (*srcLen)++;
1107         }
1108         else
1109         {
1110           RINOK(Xz_ParseHeader(&p->streamFlags, p->buf));
1111           p->numStartedStreams++;
1112           p->indexSize = 0;
1113           p->numBlocks = 0;
1114           Sha256_Init(&p->sha);
1115           p->state = XZ_STATE_BLOCK_HEADER;
1116           p->pos = 0;
1117         }
1118         break;
1119       }
1120
1121       case XZ_STATE_BLOCK_HEADER:
1122       {
1123         if (p->pos == 0)
1124         {
1125           p->buf[p->pos++] = *src++;
1126           (*srcLen)++;
1127           if (p->buf[0] == 0)
1128           {
1129             if (p->decodeOnlyOneBlock)
1130               return SZ_ERROR_DATA;
1131             p->indexPreSize = 1 + Xz_WriteVarInt(p->buf + 1, p->numBlocks);
1132             p->indexPos = p->indexPreSize;
1133             p->indexSize += p->indexPreSize;
1134             Sha256_Final(&p->sha, p->shaDigest);
1135             Sha256_Init(&p->sha);
1136             p->crc = CrcUpdate(CRC_INIT_VAL, p->buf, p->indexPreSize);
1137             p->state = XZ_STATE_STREAM_INDEX;
1138             break;
1139           }
1140           p->blockHeaderSize = ((UInt32)p->buf[0] << 2) + 4;
1141           break;
1142         }
1143
1144         if (p->pos != p->blockHeaderSize)
1145         {
1146           UInt32 cur = p->blockHeaderSize - p->pos;
1147           if (cur > srcRem)
1148             cur = (UInt32)srcRem;
1149           memcpy(p->buf + p->pos, src, cur);
1150           p->pos += cur;
1151           (*srcLen) += cur;
1152           src += cur;
1153         }
1154         else
1155         {
1156           RINOK(XzBlock_Parse(&p->block, p->buf));
1157           if (!XzBlock_AreSupportedFilters(&p->block))
1158             return SZ_ERROR_UNSUPPORTED;
1159           p->numTotalBlocks++;
1160           p->state = XZ_STATE_BLOCK;
1161           p->packSize = 0;
1162           p->unpackSize = 0;
1163           XzCheck_Init(&p->check, XzFlags_GetCheckType(p->streamFlags));
1164           if (p->parseMode)
1165           {
1166             p->headerParsedOk = True;
1167             return SZ_OK;
1168           }
1169           RINOK(XzDecMix_Init(&p->decoder, &p->block, p->outBuf, p->outBufSize));
1170         }
1171         break;
1172       }
1173
1174       case XZ_STATE_BLOCK_FOOTER:
1175       {
1176         if ((((unsigned)p->packSize + p->alignPos) & 3) != 0)
1177         {
1178           if (srcRem == 0)
1179           {
1180             *status = CODER_STATUS_NEEDS_MORE_INPUT;
1181             return SZ_OK;
1182           }
1183           (*srcLen)++;
1184           p->alignPos++;
1185           if (*src++ != 0)
1186             return SZ_ERROR_CRC;
1187         }
1188         else
1189         {
1190           UInt32 checkSize = XzFlags_GetCheckSize(p->streamFlags);
1191           UInt32 cur = checkSize - p->pos;
1192           if (cur != 0)
1193           {
1194             if (srcRem == 0)
1195             {
1196               *status = CODER_STATUS_NEEDS_MORE_INPUT;
1197               return SZ_OK;
1198             }
1199             if (cur > srcRem)
1200               cur = (UInt32)srcRem;
1201             memcpy(p->buf + p->pos, src, cur);
1202             p->pos += cur;
1203             (*srcLen) += cur;
1204             src += cur;
1205             if (checkSize != p->pos)
1206               break;
1207           }
1208           {
1209             Byte digest[XZ_CHECK_SIZE_MAX];
1210             p->state = XZ_STATE_BLOCK_HEADER;
1211             p->pos = 0;
1212             if (XzCheck_Final(&p->check, digest) && memcmp(digest, p->buf, checkSize) != 0)
1213               return SZ_ERROR_CRC;
1214             if (p->decodeOnlyOneBlock)
1215             {
1216               *status = CODER_STATUS_FINISHED_WITH_MARK;
1217               return SZ_OK;
1218             }
1219           }
1220         }
1221         break;
1222       }
1223
1224       case XZ_STATE_STREAM_INDEX:
1225       {
1226         if (p->pos < p->indexPreSize)
1227         {
1228           (*srcLen)++;
1229           if (*src++ != p->buf[p->pos++])
1230             return SZ_ERROR_CRC;
1231         }
1232         else
1233         {
1234           if (p->indexPos < p->indexSize)
1235           {
1236             UInt64 cur = p->indexSize - p->indexPos;
1237             if (srcRem > cur)
1238               srcRem = (SizeT)cur;
1239             p->crc = CrcUpdate(p->crc, src, srcRem);
1240             Sha256_Update(&p->sha, src, srcRem);
1241             (*srcLen) += srcRem;
1242             src += srcRem;
1243             p->indexPos += srcRem;
1244           }
1245           else if ((p->indexPos & 3) != 0)
1246           {
1247             Byte b = *src++;
1248             p->crc = CRC_UPDATE_BYTE(p->crc, b);
1249             (*srcLen)++;
1250             p->indexPos++;
1251             p->indexSize++;
1252             if (b != 0)
1253               return SZ_ERROR_CRC;
1254           }
1255           else
1256           {
1257             Byte digest[SHA256_DIGEST_SIZE];
1258             p->state = XZ_STATE_STREAM_INDEX_CRC;
1259             p->indexSize += 4;
1260             p->pos = 0;
1261             Sha256_Final(&p->sha, digest);
1262             if (memcmp(digest, p->shaDigest, SHA256_DIGEST_SIZE) != 0)
1263               return SZ_ERROR_CRC;
1264           }
1265         }
1266         break;
1267       }
1268
1269       case XZ_STATE_STREAM_INDEX_CRC:
1270       {
1271         if (p->pos < 4)
1272         {
1273           (*srcLen)++;
1274           p->buf[p->pos++] = *src++;
1275         }
1276         else
1277         {
1278           p->state = XZ_STATE_STREAM_FOOTER;
1279           p->pos = 0;
1280           if (CRC_GET_DIGEST(p->crc) != GetUi32(p->buf))
1281             return SZ_ERROR_CRC;
1282         }
1283         break;
1284       }
1285
1286       case XZ_STATE_STREAM_FOOTER:
1287       {
1288         UInt32 cur = XZ_STREAM_FOOTER_SIZE - p->pos;
1289         if (cur > srcRem)
1290           cur = (UInt32)srcRem;
1291         memcpy(p->buf + p->pos, src, cur);
1292         p->pos += cur;
1293         (*srcLen) += cur;
1294         src += cur;
1295         if (p->pos == XZ_STREAM_FOOTER_SIZE)
1296         {
1297           p->state = XZ_STATE_STREAM_PADDING;
1298           p->numFinishedStreams++;
1299           p->padSize = 0;
1300           if (!Xz_CheckFooter(p->streamFlags, p->indexSize, p->buf))
1301             return SZ_ERROR_CRC;
1302         }
1303         break;
1304       }
1305
1306       case XZ_STATE_STREAM_PADDING:
1307       {
1308         if (*src != 0)
1309         {
1310           if (((UInt32)p->padSize & 3) != 0)
1311             return SZ_ERROR_NO_ARCHIVE;
1312           p->pos = 0;
1313           p->state = XZ_STATE_STREAM_HEADER;
1314         }
1315         else
1316         {
1317           (*srcLen)++;
1318           src++;
1319           p->padSize++;
1320         }
1321         break;
1322       }
1323
1324       case XZ_STATE_BLOCK: break; /* to disable GCC warning */
1325     }
1326   }
1327   /*
1328   if (p->state == XZ_STATE_FINISHED)
1329     *status = CODER_STATUS_FINISHED_WITH_MARK;
1330   return SZ_OK;
1331   */
1332 }
1333
1334
1335 SRes XzUnpacker_CodeFull(CXzUnpacker *p, Byte *dest, SizeT *destLen,
1336     const Byte *src, SizeT *srcLen,
1337     ECoderFinishMode finishMode, ECoderStatus *status)
1338 {
1339   XzUnpacker_Init(p);
1340   XzUnpacker_SetOutBuf(p, dest, *destLen);
1341
1342   return XzUnpacker_Code(p,
1343       NULL, destLen,
1344       src, srcLen, True,
1345       finishMode, status);
1346 }
1347
1348
1349 Bool XzUnpacker_IsBlockFinished(const CXzUnpacker *p)
1350 {
1351   return (p->state == XZ_STATE_BLOCK_HEADER) && (p->pos == 0);
1352 }
1353
1354 Bool XzUnpacker_IsStreamWasFinished(const CXzUnpacker *p)
1355 {
1356   return (p->state == XZ_STATE_STREAM_PADDING) && (((UInt32)p->padSize & 3) == 0);
1357 }
1358
1359 UInt64 XzUnpacker_GetExtraSize(const CXzUnpacker *p)
1360 {
1361   UInt64 num = 0;
1362   if (p->state == XZ_STATE_STREAM_PADDING)
1363     num = p->padSize;
1364   else if (p->state == XZ_STATE_STREAM_HEADER)
1365     num = p->padSize + p->pos;
1366   return num;
1367 }
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389 #ifndef _7ZIP_ST
1390 #include "MtDec.h"
1391 #endif
1392
1393
1394 void XzDecMtProps_Init(CXzDecMtProps *p)
1395 {
1396   p->inBufSize_ST = 1 << 18;
1397   p->outStep_ST = 1 << 20;
1398   p->ignoreErrors = False;
1399
1400   #ifndef _7ZIP_ST
1401   p->numThreads = 1;
1402   p->inBufSize_MT = 1 << 18;
1403   p->memUseMax = sizeof(size_t) << 28;
1404   #endif
1405 }
1406
1407
1408
1409 #ifndef _7ZIP_ST
1410
1411 /* ---------- CXzDecMtThread ---------- */
1412
1413 typedef struct
1414 {
1415   Byte *outBuf;
1416   size_t outBufSize;
1417   size_t outPreSize;
1418   size_t inPreSize;
1419   size_t inPreHeaderSize;
1420   size_t blockPackSize_for_Index;  // including block header and checksum.
1421   size_t blockPackTotal;  // including stream header, block header and checksum.
1422   size_t inCodeSize;
1423   size_t outCodeSize;
1424   ECoderStatus status;
1425   SRes codeRes;
1426   Bool skipMode;
1427   // Bool finishedWithMark;
1428   EMtDecParseState parseState;
1429   Bool parsing_Truncated;
1430   Bool atBlockHeader;
1431   CXzStreamFlags streamFlags;
1432   // UInt64 numFinishedStreams
1433   UInt64 numStreams;
1434   UInt64 numTotalBlocks;
1435   UInt64 numBlocks;
1436
1437   Bool dec_created;
1438   CXzUnpacker dec;
1439
1440   Byte mtPad[1 << 7];
1441 } CXzDecMtThread;
1442
1443 #endif
1444
1445
1446 /* ---------- CXzDecMt ---------- */
1447
1448 typedef struct
1449 {
1450   CAlignOffsetAlloc alignOffsetAlloc;
1451   ISzAllocPtr allocMid;
1452
1453   CXzDecMtProps props;
1454   size_t unpackBlockMaxSize;
1455
1456   ISeqInStream *inStream;
1457   ISeqOutStream *outStream;
1458   ICompressProgress *progress;
1459   // CXzStatInfo *stat;
1460
1461   Bool finishMode;
1462   Bool outSize_Defined;
1463   UInt64 outSize;
1464
1465   UInt64 outProcessed;
1466   UInt64 inProcessed;
1467   UInt64 readProcessed;
1468   Bool readWasFinished;
1469   SRes readRes;
1470   SRes writeRes;
1471
1472   Byte *outBuf;
1473   size_t outBufSize;
1474   Byte *inBuf;
1475   size_t inBufSize;
1476   Bool dec_created;
1477   CXzUnpacker dec;
1478
1479   ECoderStatus status;
1480   SRes codeRes;
1481
1482   #ifndef _7ZIP_ST
1483   Bool mainDecoderWasCalled;
1484   // int statErrorDefined;
1485   int finishedDecoderIndex;
1486
1487   // global values that are used in Parse stage
1488   CXzStreamFlags streamFlags;
1489   // UInt64 numFinishedStreams
1490   UInt64 numStreams;
1491   UInt64 numTotalBlocks;
1492   UInt64 numBlocks;
1493
1494   // UInt64 numBadBlocks;
1495   SRes mainErrorCode;
1496
1497   Bool isBlockHeaderState_Parse;
1498   Bool isBlockHeaderState_Write;
1499   UInt64 outProcessed_Parse;
1500   Bool parsing_Truncated;
1501
1502   Bool mtc_WasConstructed;
1503   CMtDec mtc;
1504   CXzDecMtThread coders[MTDEC__THREADS_MAX];
1505   #endif
1506
1507 } CXzDecMt;
1508
1509
1510
1511 CXzDecMtHandle XzDecMt_Create(ISzAllocPtr alloc, ISzAllocPtr allocMid)
1512 {
1513   CXzDecMt *p = (CXzDecMt *)ISzAlloc_Alloc(alloc, sizeof(CXzDecMt));
1514   if (!p)
1515     return NULL;
1516
1517   AlignOffsetAlloc_CreateVTable(&p->alignOffsetAlloc);
1518   p->alignOffsetAlloc.baseAlloc = alloc;
1519   p->alignOffsetAlloc.numAlignBits = 7;
1520   p->alignOffsetAlloc.offset = 0;
1521
1522   p->allocMid = allocMid;
1523
1524   p->outBuf = NULL;
1525   p->outBufSize = 0;
1526   p->inBuf = NULL;
1527   p->inBufSize = 0;
1528   p->dec_created = False;
1529
1530   p->unpackBlockMaxSize = 0;
1531
1532   XzDecMtProps_Init(&p->props);
1533
1534   #ifndef _7ZIP_ST
1535   p->mtc_WasConstructed = False;
1536   {
1537     unsigned i;
1538     for (i = 0; i < MTDEC__THREADS_MAX; i++)
1539     {
1540       CXzDecMtThread *coder = &p->coders[i];
1541       coder->dec_created = False;
1542       coder->outBuf = NULL;
1543       coder->outBufSize = 0;
1544     }
1545   }
1546   #endif
1547
1548   return p;
1549 }
1550
1551
1552 #ifndef _7ZIP_ST
1553
1554 static void XzDecMt_FreeOutBufs(CXzDecMt *p)
1555 {
1556   unsigned i;
1557   for (i = 0; i < MTDEC__THREADS_MAX; i++)
1558   {
1559     CXzDecMtThread *coder = &p->coders[i];
1560     if (coder->outBuf)
1561     {
1562       ISzAlloc_Free(p->allocMid, coder->outBuf);
1563       coder->outBuf = NULL;
1564       coder->outBufSize = 0;
1565     }
1566   }
1567   p->unpackBlockMaxSize = 0;
1568 }
1569
1570 #endif
1571
1572
1573
1574 static void XzDecMt_FreeSt(CXzDecMt *p)
1575 {
1576   if (p->dec_created)
1577   {
1578     XzUnpacker_Free(&p->dec);
1579     p->dec_created = False;
1580   }
1581
1582   if (p->outBuf)
1583   {
1584     ISzAlloc_Free(p->allocMid, p->outBuf);
1585     p->outBuf = NULL;
1586   }
1587   p->outBufSize = 0;
1588
1589   if (p->inBuf)
1590   {
1591     ISzAlloc_Free(p->allocMid, p->inBuf);
1592     p->inBuf = NULL;
1593   }
1594   p->inBufSize = 0;
1595 }
1596
1597
1598 void XzDecMt_Destroy(CXzDecMtHandle pp)
1599 {
1600   CXzDecMt *p = (CXzDecMt *)pp;
1601
1602   XzDecMt_FreeSt(p);
1603
1604   #ifndef _7ZIP_ST
1605
1606   if (p->mtc_WasConstructed)
1607   {
1608     MtDec_Destruct(&p->mtc);
1609     p->mtc_WasConstructed = False;
1610   }
1611   {
1612     unsigned i;
1613     for (i = 0; i < MTDEC__THREADS_MAX; i++)
1614     {
1615       CXzDecMtThread *t = &p->coders[i];
1616       if (t->dec_created)
1617       {
1618         // we don't need to free dict here
1619         XzUnpacker_Free(&t->dec);
1620         t->dec_created = False;
1621       }
1622     }
1623   }
1624   XzDecMt_FreeOutBufs(p);
1625
1626   #endif
1627
1628   ISzAlloc_Free(p->alignOffsetAlloc.baseAlloc, pp);
1629 }
1630
1631
1632
1633 #ifndef _7ZIP_ST
1634
1635 static void XzDecMt_Callback_Parse(void *obj, unsigned coderIndex, CMtDecCallbackInfo *cc)
1636 {
1637   CXzDecMt *me = (CXzDecMt *)obj;
1638   CXzDecMtThread *coder = &me->coders[coderIndex];
1639   size_t srcSize = cc->srcSize;
1640
1641   cc->srcSize = 0;
1642   cc->outPos = 0;
1643   cc->state = MTDEC_PARSE_CONTINUE;
1644
1645   cc->canCreateNewThread = True;
1646
1647   if (cc->startCall)
1648   {
1649     coder->outPreSize = 0;
1650     coder->inPreSize = 0;
1651     coder->inPreHeaderSize = 0;
1652     coder->parseState = MTDEC_PARSE_CONTINUE;
1653     coder->parsing_Truncated = False;
1654     coder->skipMode = False;
1655     coder->codeRes = SZ_OK;
1656     coder->status = CODER_STATUS_NOT_SPECIFIED;
1657     coder->inCodeSize = 0;
1658     coder->outCodeSize = 0;
1659
1660     coder->numStreams = me->numStreams;
1661     coder->numTotalBlocks = me->numTotalBlocks;
1662     coder->numBlocks = me->numBlocks;
1663
1664     if (!coder->dec_created)
1665     {
1666       XzUnpacker_Construct(&coder->dec, &me->alignOffsetAlloc.vt);
1667       coder->dec_created = True;
1668     }
1669
1670     XzUnpacker_Init(&coder->dec);
1671
1672     if (me->isBlockHeaderState_Parse)
1673     {
1674       coder->dec.streamFlags = me->streamFlags;
1675       coder->atBlockHeader = True;
1676       XzUnpacker_PrepareToRandomBlockDecoding(&coder->dec);
1677     }
1678     else
1679     {
1680       coder->atBlockHeader = False;
1681       me->isBlockHeaderState_Parse = True;
1682     }
1683
1684     coder->dec.numStartedStreams = me->numStreams;
1685     coder->dec.numTotalBlocks = me->numTotalBlocks;
1686     coder->dec.numBlocks = me->numBlocks;
1687   }
1688
1689   while (!coder->skipMode)
1690   {
1691     ECoderStatus status;
1692     SRes res;
1693     size_t srcSize2 = srcSize;
1694     size_t destSize = (size_t)0 - 1;
1695
1696     coder->dec.parseMode = True;
1697     coder->dec.headerParsedOk = False;
1698
1699     PRF_STR_INT("Parse", srcSize2);
1700
1701     res = XzUnpacker_Code(&coder->dec,
1702         NULL, &destSize,
1703         cc->src, &srcSize2, cc->srcFinished,
1704         CODER_FINISH_END, &status);
1705
1706     // PRF(printf(" res = %d, srcSize2 = %d", res, (unsigned)srcSize2));
1707
1708     coder->codeRes = res;
1709     coder->status = status;
1710     cc->srcSize += srcSize2;
1711     srcSize -= srcSize2;
1712     coder->inPreHeaderSize += srcSize2;
1713     coder->inPreSize = coder->inPreHeaderSize;
1714
1715     if (res != SZ_OK)
1716     {
1717       cc->state =
1718       coder->parseState = MTDEC_PARSE_END;
1719       /*
1720       if (res == SZ_ERROR_MEM)
1721         return res;
1722       return SZ_OK;
1723       */
1724       return; // res;
1725     }
1726
1727     if (coder->dec.headerParsedOk)
1728     {
1729       const CXzBlock *block = &coder->dec.block;
1730       if (XzBlock_HasUnpackSize(block)
1731           // && block->unpackSize <= me->props.outBlockMax
1732           && XzBlock_HasPackSize(block))
1733       {
1734         {
1735           if (block->unpackSize * 2 * me->mtc.numStartedThreads > me->props.memUseMax)
1736           {
1737             cc->state = MTDEC_PARSE_OVERFLOW;
1738             return; // SZ_OK;
1739           }
1740         }
1741         {
1742         UInt64 packSize = block->packSize;
1743         UInt64 packSizeAligned = packSize + ((0 - (unsigned)packSize) & 3);
1744         UInt32 checkSize = XzFlags_GetCheckSize(coder->dec.streamFlags);
1745         UInt64 blockPackSum = coder->inPreSize + packSizeAligned + checkSize;
1746         // if (blockPackSum <= me->props.inBlockMax)
1747         // unpackBlockMaxSize
1748         {
1749           coder->blockPackSize_for_Index = (size_t)(coder->dec.blockHeaderSize + packSize + checkSize);
1750           coder->blockPackTotal = (size_t)blockPackSum;
1751           coder->outPreSize = (size_t)block->unpackSize;
1752           coder->streamFlags = coder->dec.streamFlags;
1753           me->streamFlags = coder->dec.streamFlags;
1754           coder->skipMode = True;
1755           break;
1756         }
1757         }
1758       }
1759     }
1760     else
1761     // if (coder->inPreSize <= me->props.inBlockMax)
1762     {
1763       if (!cc->srcFinished)
1764         return; // SZ_OK;
1765       cc->state =
1766       coder->parseState = MTDEC_PARSE_END;
1767       return; // SZ_OK;
1768     }
1769     cc->state = MTDEC_PARSE_OVERFLOW;
1770     return; // SZ_OK;
1771   }
1772
1773   // ---------- skipMode ----------
1774   {
1775     UInt64 rem = coder->blockPackTotal - coder->inPreSize;
1776     size_t cur = srcSize;
1777     if (cur > rem)
1778       cur = (size_t)rem;
1779     cc->srcSize += cur;
1780     coder->inPreSize += cur;
1781     srcSize -= cur;
1782
1783     if (coder->inPreSize == coder->blockPackTotal)
1784     {
1785       if (srcSize == 0)
1786       {
1787         if (!cc->srcFinished)
1788           return; // SZ_OK;
1789         cc->state = MTDEC_PARSE_END;
1790       }
1791       else if ((cc->src)[cc->srcSize] == 0) // we check control byte of next block
1792         cc->state = MTDEC_PARSE_END;
1793       else
1794       {
1795         cc->state = MTDEC_PARSE_NEW;
1796
1797         {
1798           size_t blockMax = me->unpackBlockMaxSize;
1799           if (blockMax < coder->outPreSize)
1800             blockMax = coder->outPreSize;
1801           {
1802             UInt64 required = (UInt64)blockMax * (me->mtc.numStartedThreads + 1) * 2;
1803             if (me->props.memUseMax < required)
1804               cc->canCreateNewThread = False;
1805           }
1806         }
1807
1808         if (me->outSize_Defined)
1809         {
1810           // next block can be zero size
1811           const UInt64 rem2 = me->outSize - me->outProcessed_Parse;
1812           if (rem2 < coder->outPreSize)
1813           {
1814             coder->parsing_Truncated = True;
1815             cc->state = MTDEC_PARSE_END;
1816           }
1817           me->outProcessed_Parse += coder->outPreSize;
1818         }
1819       }
1820     }
1821     else if (cc->srcFinished)
1822       cc->state = MTDEC_PARSE_END;
1823     else
1824       return; // SZ_OK;
1825
1826     coder->parseState = cc->state;
1827     cc->outPos = coder->outPreSize;
1828
1829     me->numStreams = coder->dec.numStartedStreams;
1830     me->numTotalBlocks = coder->dec.numTotalBlocks;
1831     me->numBlocks = coder->dec.numBlocks + 1;
1832     return; // SZ_OK;
1833   }
1834 }
1835
1836
1837 static SRes XzDecMt_Callback_PreCode(void *pp, unsigned coderIndex)
1838 {
1839   CXzDecMt *me = (CXzDecMt *)pp;
1840   CXzDecMtThread *coder = &me->coders[coderIndex];
1841   Byte *dest;
1842
1843   if (!coder->dec.headerParsedOk)
1844     return SZ_OK;
1845
1846   dest = coder->outBuf;
1847
1848   if (!dest || coder->outBufSize < coder->outPreSize)
1849   {
1850     if (dest)
1851     {
1852       ISzAlloc_Free(me->allocMid, dest);
1853       coder->outBuf = NULL;
1854       coder->outBufSize = 0;
1855     }
1856     {
1857       size_t outPreSize = coder->outPreSize;
1858       if (outPreSize == 0)
1859         outPreSize = 1;
1860       dest = (Byte *)ISzAlloc_Alloc(me->allocMid, outPreSize);
1861     }
1862     if (!dest)
1863       return SZ_ERROR_MEM;
1864     coder->outBuf = dest;
1865     coder->outBufSize = coder->outPreSize;
1866
1867     if (coder->outBufSize > me->unpackBlockMaxSize)
1868       me->unpackBlockMaxSize = coder->outBufSize;
1869   }
1870
1871   // return SZ_ERROR_MEM;
1872
1873   XzUnpacker_SetOutBuf(&coder->dec, coder->outBuf, coder->outBufSize);
1874
1875   {
1876     SRes res = XzDecMix_Init(&coder->dec.decoder, &coder->dec.block, coder->outBuf, coder->outBufSize);
1877     // res = SZ_ERROR_UNSUPPORTED; // to test
1878     coder->codeRes = res;
1879     if (res != SZ_OK)
1880     {
1881       // if (res == SZ_ERROR_MEM) return res;
1882       if (me->props.ignoreErrors && res != SZ_ERROR_MEM)
1883         return S_OK;
1884       return res;
1885     }
1886   }
1887
1888   return SZ_OK;
1889 }
1890
1891
1892 static SRes XzDecMt_Callback_Code(void *pp, unsigned coderIndex,
1893     const Byte *src, size_t srcSize, int srcFinished,
1894     // int finished, int blockFinished,
1895     UInt64 *inCodePos, UInt64 *outCodePos, int *stop)
1896 {
1897   CXzDecMt *me = (CXzDecMt *)pp;
1898   CXzDecMtThread *coder = &me->coders[coderIndex];
1899
1900   *inCodePos = coder->inCodeSize;
1901   *outCodePos = coder->outCodeSize;
1902   *stop = True;
1903
1904   if (coder->inCodeSize < coder->inPreHeaderSize)
1905   {
1906     UInt64 rem = coder->inPreHeaderSize - coder->inCodeSize;
1907     size_t step = srcSize;
1908     if (step > rem)
1909       step = (size_t)rem;
1910     src += step;
1911     srcSize -= step;
1912     coder->inCodeSize += step;
1913     if (coder->inCodeSize < coder->inPreHeaderSize)
1914     {
1915       *stop = False;
1916       return SZ_OK;
1917     }
1918   }
1919
1920   if (!coder->dec.headerParsedOk)
1921     return SZ_OK;
1922   if (!coder->outBuf)
1923     return SZ_OK;
1924
1925   if (coder->codeRes == SZ_OK)
1926   {
1927     ECoderStatus status;
1928     SRes res;
1929     size_t srcProcessed = srcSize;
1930     size_t outSizeCur = coder->outPreSize - coder->dec.outDataWritten;
1931
1932     // PRF(printf("\nCallback_Code: Code %d %d\n", (unsigned)srcSize, (unsigned)outSizeCur));
1933
1934     res = XzUnpacker_Code(&coder->dec,
1935         NULL, &outSizeCur,
1936         src, &srcProcessed, srcFinished,
1937         // coder->finishedWithMark ? CODER_FINISH_END : CODER_FINISH_ANY,
1938         CODER_FINISH_END,
1939         &status);
1940
1941     // PRF(printf(" res = %d, srcSize2 = %d, outSizeCur = %d", res, (unsigned)srcProcessed, (unsigned)outSizeCur));
1942
1943     coder->codeRes = res;
1944     coder->status = status;
1945     coder->inCodeSize += srcProcessed;
1946     coder->outCodeSize = coder->dec.outDataWritten;
1947     *inCodePos = coder->inCodeSize;
1948     *outCodePos = coder->outCodeSize;
1949
1950     if (res == SZ_OK)
1951     {
1952       if (srcProcessed == srcSize)
1953         *stop = False;
1954       return SZ_OK;
1955     }
1956   }
1957
1958   if (me->props.ignoreErrors && coder->codeRes != SZ_ERROR_MEM)
1959   {
1960     *inCodePos = coder->inPreSize;
1961     *outCodePos = coder->outPreSize;
1962     return S_OK;
1963   }
1964   return coder->codeRes;
1965 }
1966
1967
1968 #define XZDECMT_STREAM_WRITE_STEP (1 << 24)
1969
1970 static SRes XzDecMt_Callback_Write(void *pp, unsigned coderIndex,
1971     Bool needWriteToStream,
1972     const Byte *src, size_t srcSize,
1973     // int srcFinished,
1974     Bool *needContinue,
1975     Bool *canRecode)
1976 {
1977   CXzDecMt *me = (CXzDecMt *)pp;
1978   const CXzDecMtThread *coder = &me->coders[coderIndex];
1979
1980   // PRF(printf("\nWrite processed = %d srcSize = %d\n", (unsigned)me->mtc.inProcessed, (unsigned)srcSize));
1981
1982   *needContinue = False;
1983   *canRecode = True;
1984
1985   if (!needWriteToStream)
1986     return SZ_OK;
1987
1988   if (!coder->dec.headerParsedOk || !coder->outBuf)
1989   {
1990     if (me->finishedDecoderIndex < 0)
1991       me->finishedDecoderIndex = coderIndex;
1992     return SZ_OK;
1993   }
1994
1995   if (me->finishedDecoderIndex >= 0)
1996     return SZ_OK;
1997
1998   me->mtc.inProcessed += coder->inCodeSize;
1999
2000   *canRecode = False;
2001
2002   {
2003     SRes res;
2004     size_t size = coder->outCodeSize;
2005     Byte *data = coder->outBuf;
2006
2007     // we use in me->dec: sha, numBlocks, indexSize
2008
2009     if (!me->isBlockHeaderState_Write)
2010     {
2011       XzUnpacker_PrepareToRandomBlockDecoding(&me->dec);
2012       me->dec.decodeOnlyOneBlock = False;
2013       me->dec.numStartedStreams = coder->dec.numStartedStreams;
2014       me->dec.streamFlags = coder->streamFlags;
2015
2016       me->isBlockHeaderState_Write = True;
2017     }
2018
2019     me->dec.numTotalBlocks = coder->dec.numTotalBlocks;
2020     XzUnpacker_UpdateIndex(&me->dec, coder->blockPackSize_for_Index, coder->outPreSize);
2021
2022     if (coder->outPreSize != size)
2023     {
2024       if (me->props.ignoreErrors)
2025       {
2026         memset(data + size, 0, coder->outPreSize - size);
2027         size = coder->outPreSize;
2028       }
2029       // me->numBadBlocks++;
2030       if (me->mainErrorCode == SZ_OK)
2031       {
2032         if ((int)coder->status == LZMA_STATUS_NEEDS_MORE_INPUT)
2033           me->mainErrorCode = SZ_ERROR_INPUT_EOF;
2034         else
2035           me->mainErrorCode = SZ_ERROR_DATA;
2036       }
2037     }
2038
2039     if (me->writeRes != SZ_OK)
2040       return me->writeRes;
2041
2042     res = SZ_OK;
2043     {
2044       if (me->outSize_Defined)
2045       {
2046         const UInt64 rem = me->outSize - me->outProcessed;
2047         if (size > rem)
2048           size = (SizeT)rem;
2049       }
2050
2051       for (;;)
2052       {
2053         size_t cur = size;
2054         size_t written;
2055         if (cur > XZDECMT_STREAM_WRITE_STEP)
2056           cur = XZDECMT_STREAM_WRITE_STEP;
2057
2058         written = ISeqOutStream_Write(me->outStream, data, cur);
2059
2060         // PRF(printf("\nWritten ask = %d written = %d\n", (unsigned)cur, (unsigned)written));
2061
2062         me->outProcessed += written;
2063         if (written != cur)
2064         {
2065           me->writeRes = SZ_ERROR_WRITE;
2066           res = me->writeRes;
2067           break;
2068         }
2069         data += cur;
2070         size -= cur;
2071         // PRF_STR_INT("Written size =", size);
2072         if (size == 0)
2073           break;
2074         res = MtProgress_ProgressAdd(&me->mtc.mtProgress, 0, 0);
2075         if (res != SZ_OK)
2076           break;
2077       }
2078     }
2079
2080     if (coder->codeRes != SZ_OK)
2081       if (!me->props.ignoreErrors)
2082       {
2083         me->finishedDecoderIndex = coderIndex;
2084         return res;
2085       }
2086
2087     RINOK(res);
2088
2089     if (coder->inPreSize != coder->inCodeSize
2090         || coder->blockPackTotal != coder->inCodeSize)
2091     {
2092       me->finishedDecoderIndex = coderIndex;
2093       return SZ_OK;
2094     }
2095
2096     if (coder->parseState != MTDEC_PARSE_END)
2097     {
2098       *needContinue = True;
2099       return SZ_OK;
2100     }
2101   }
2102
2103   // (coder->state == MTDEC_PARSE_END) means that there are no other working threads
2104   // so we can use mtc variables without lock
2105
2106   PRF_STR_INT("Write MTDEC_PARSE_END", me->mtc.inProcessed);
2107
2108   me->mtc.mtProgress.totalInSize = me->mtc.inProcessed;
2109   {
2110     CXzUnpacker *dec = &me->dec;
2111
2112     PRF_STR_INT("PostSingle", srcSize);
2113
2114     {
2115       size_t srcProcessed = srcSize;
2116       ECoderStatus status;
2117       size_t outSizeCur = 0;
2118       SRes res;
2119
2120       // dec->decodeOnlyOneBlock = False;
2121       dec->decodeToStreamSignature = True;
2122
2123       me->mainDecoderWasCalled = True;
2124
2125       if (coder->parsing_Truncated)
2126       {
2127         me->parsing_Truncated = True;
2128         return SZ_OK;
2129       }
2130
2131       res = XzUnpacker_Code(dec,
2132           NULL, &outSizeCur,
2133           src, &srcProcessed,
2134           me->mtc.readWasFinished, // srcFinished
2135           CODER_FINISH_END, // CODER_FINISH_ANY,
2136           &status);
2137
2138       me->status = status;
2139       me->codeRes = res;
2140
2141       me->mtc.inProcessed += srcProcessed;
2142       me->mtc.mtProgress.totalInSize = me->mtc.inProcessed;
2143
2144       if (res != SZ_OK)
2145       {
2146         return S_OK;
2147         // return res;
2148       }
2149
2150       if (dec->state == XZ_STATE_STREAM_HEADER)
2151       {
2152         *needContinue = True;
2153         me->isBlockHeaderState_Parse = False;
2154         me->isBlockHeaderState_Write = False;
2155         {
2156           Byte *crossBuf = MtDec_GetCrossBuff(&me->mtc);
2157           if (!crossBuf)
2158             return SZ_ERROR_MEM;
2159           memcpy(crossBuf, src + srcProcessed, srcSize - srcProcessed);
2160         }
2161         me->mtc.crossStart = 0;
2162         me->mtc.crossEnd = srcSize - srcProcessed;
2163         return SZ_OK;
2164       }
2165
2166       if (status != CODER_STATUS_NEEDS_MORE_INPUT)
2167       {
2168         return E_FAIL;
2169       }
2170
2171       if (me->mtc.readWasFinished)
2172       {
2173         return SZ_OK;
2174       }
2175     }
2176
2177     {
2178       size_t inPos;
2179       size_t inLim;
2180       const Byte *inData;
2181       UInt64 inProgressPrev = me->mtc.inProcessed;
2182
2183       // XzDecMt_Prepare_InBuf_ST(p);
2184       Byte *crossBuf = MtDec_GetCrossBuff(&me->mtc);
2185       if (!crossBuf)
2186         return SZ_ERROR_MEM;
2187
2188       inPos = 0;
2189       inLim = 0;
2190       // outProcessed = 0;
2191
2192       inData = crossBuf;
2193
2194       for (;;)
2195       {
2196         SizeT inProcessed;
2197         SizeT outProcessed;
2198         ECoderStatus status;
2199         SRes res;
2200
2201         if (inPos == inLim)
2202         {
2203           if (!me->mtc.readWasFinished)
2204           {
2205             inPos = 0;
2206             inLim = me->mtc.inBufSize;
2207             me->mtc.readRes = ISeqInStream_Read(me->inStream, (void *)inData, &inLim);
2208             me->mtc.readProcessed += inLim;
2209             if (inLim == 0 || me->mtc.readRes != SZ_OK)
2210               me->mtc.readWasFinished = True;
2211           }
2212         }
2213
2214         inProcessed = inLim - inPos;
2215         outProcessed = 0;
2216
2217         res = XzUnpacker_Code(dec,
2218             NULL, &outProcessed,
2219             inData + inPos, &inProcessed,
2220             (inProcessed == 0), // srcFinished
2221             CODER_FINISH_END, &status);
2222
2223         me->codeRes = res;
2224         me->status = status;
2225         inPos += inProcessed;
2226         me->mtc.inProcessed += inProcessed;
2227         me->mtc.mtProgress.totalInSize = me->mtc.inProcessed;
2228
2229         if (res != SZ_OK)
2230         {
2231           return S_OK;
2232           // return res;
2233         }
2234
2235         if (dec->state == XZ_STATE_STREAM_HEADER)
2236         {
2237           *needContinue = True;
2238           me->mtc.crossStart = inPos;
2239           me->mtc.crossEnd = inLim;
2240           me->isBlockHeaderState_Parse = False;
2241           me->isBlockHeaderState_Write = False;
2242           return SZ_OK;
2243         }
2244
2245         if (status != CODER_STATUS_NEEDS_MORE_INPUT)
2246           return E_FAIL;
2247
2248         if (me->mtc.progress)
2249         {
2250           UInt64 inDelta = me->mtc.inProcessed - inProgressPrev;
2251           if (inDelta >= (1 << 22))
2252           {
2253             RINOK(MtProgress_Progress_ST(&me->mtc.mtProgress));
2254             inProgressPrev = me->mtc.inProcessed;
2255           }
2256         }
2257         if (me->mtc.readWasFinished)
2258           return SZ_OK;
2259       }
2260     }
2261   }
2262 }
2263
2264
2265 #endif
2266
2267
2268
2269 void XzStatInfo_Clear(CXzStatInfo *p)
2270 {
2271   p->InSize = 0;
2272   p->OutSize = 0;
2273
2274   p->NumStreams = 0;
2275   p->NumBlocks = 0;
2276
2277   p->UnpackSize_Defined = False;
2278
2279   p->NumStreams_Defined = False;
2280   p->NumBlocks_Defined = False;
2281
2282   // p->IsArc = False;
2283   // p->UnexpectedEnd = False;
2284   // p->Unsupported = False;
2285   // p->HeadersError = False;
2286   // p->DataError = False;
2287   // p->CrcError = False;
2288
2289   p->DataAfterEnd = False;
2290   p->DecodingTruncated = False;
2291
2292   p->DecodeRes = SZ_OK;
2293   p->ReadRes = SZ_OK;
2294   p->ProgressRes = SZ_OK;
2295
2296   p->CombinedRes = SZ_OK;
2297   p->CombinedRes_Type = SZ_OK;
2298 }
2299
2300
2301
2302
2303 static SRes XzDecMt_Decode_ST(CXzDecMt *p
2304     #ifndef _7ZIP_ST
2305     , Bool tMode
2306     #endif
2307     , CXzStatInfo *stat)
2308 {
2309   size_t outPos;
2310   size_t inPos, inLim;
2311   const Byte *inData;
2312   UInt64 inPrev, outPrev;
2313
2314   CXzUnpacker *dec;
2315
2316   #ifndef _7ZIP_ST
2317   if (tMode)
2318   {
2319     XzDecMt_FreeOutBufs(p);
2320     tMode = MtDec_PrepareRead(&p->mtc);
2321   }
2322   #endif
2323
2324   if (!p->outBuf || p->outBufSize != p->props.outStep_ST)
2325   {
2326     ISzAlloc_Free(p->allocMid, p->outBuf);
2327     p->outBufSize = 0;
2328     p->outBuf = (Byte *)ISzAlloc_Alloc(p->allocMid, p->props.outStep_ST);
2329     if (!p->outBuf)
2330       return SZ_ERROR_MEM;
2331     p->outBufSize = p->props.outStep_ST;
2332   }
2333
2334   if (!p->inBuf || p->inBufSize != p->props.inBufSize_ST)
2335   {
2336     ISzAlloc_Free(p->allocMid, p->inBuf);
2337     p->inBufSize = 0;
2338     p->inBuf = (Byte *)ISzAlloc_Alloc(p->allocMid, p->props.inBufSize_ST);
2339     if (!p->inBuf)
2340       return SZ_ERROR_MEM;
2341     p->inBufSize = p->props.inBufSize_ST;
2342   }
2343
2344   dec = &p->dec;
2345   dec->decodeToStreamSignature = False;
2346   // dec->decodeOnlyOneBlock = False;
2347
2348   XzUnpacker_SetOutBuf(dec, NULL, 0);
2349
2350   inPrev = p->inProcessed;
2351   outPrev = p->outProcessed;
2352
2353   inPos = 0;
2354   inLim = 0;
2355   inData = NULL;
2356   outPos = 0;
2357
2358   for (;;)
2359   {
2360     SizeT outSize;
2361     Bool finished;
2362     ECoderFinishMode finishMode;
2363     SizeT inProcessed;
2364     ECoderStatus status;
2365     SRes res;
2366
2367     SizeT outProcessed;
2368
2369
2370
2371     if (inPos == inLim)
2372     {
2373       #ifndef _7ZIP_ST
2374       if (tMode)
2375       {
2376         inData = MtDec_Read(&p->mtc, &inLim);
2377         inPos = 0;
2378         if (inData)
2379           continue;
2380         tMode = False;
2381         inLim = 0;
2382       }
2383       #endif
2384
2385       if (!p->readWasFinished)
2386       {
2387         inPos = 0;
2388         inLim = p->inBufSize;
2389         inData = p->inBuf;
2390         p->readRes = ISeqInStream_Read(p->inStream, (void *)inData, &inLim);
2391         p->readProcessed += inLim;
2392         if (inLim == 0 || p->readRes != SZ_OK)
2393           p->readWasFinished = True;
2394       }
2395     }
2396
2397     outSize = p->props.outStep_ST - outPos;
2398
2399     finishMode = CODER_FINISH_ANY;
2400     if (p->outSize_Defined)
2401     {
2402       const UInt64 rem = p->outSize - p->outProcessed;
2403       if (outSize >= rem)
2404       {
2405         outSize = (SizeT)rem;
2406         if (p->finishMode)
2407           finishMode = CODER_FINISH_END;
2408       }
2409     }
2410
2411     inProcessed = inLim - inPos;
2412     outProcessed = outSize;
2413
2414     res = XzUnpacker_Code(dec, p->outBuf + outPos, &outProcessed,
2415         inData + inPos, &inProcessed,
2416         (inPos == inLim), // srcFinished
2417         finishMode, &status);
2418
2419     p->codeRes = res;
2420     p->status = status;
2421
2422     inPos += inProcessed;
2423     outPos += outProcessed;
2424     p->inProcessed += inProcessed;
2425     p->outProcessed += outProcessed;
2426
2427     finished = ((inProcessed == 0 && outProcessed == 0) || res != SZ_OK);
2428
2429     if (finished || outProcessed >= outSize)
2430       if (outPos != 0)
2431       {
2432         size_t written = ISeqOutStream_Write(p->outStream, p->outBuf, outPos);
2433         p->outProcessed += written;
2434         if (written != outPos)
2435         {
2436           stat->CombinedRes_Type = SZ_ERROR_WRITE;
2437           return SZ_ERROR_WRITE;
2438         }
2439         outPos = 0;
2440       }
2441
2442     if (p->progress && res == SZ_OK)
2443     {
2444       UInt64 inDelta = p->inProcessed - inPrev;
2445       UInt64 outDelta = p->outProcessed - outPrev;
2446       if (inDelta >= (1 << 22) || outDelta >= (1 << 22))
2447       {
2448         res = ICompressProgress_Progress(p->progress, p->inProcessed, p->outProcessed);
2449         if (res != SZ_OK)
2450         {
2451           stat->CombinedRes_Type = SZ_ERROR_PROGRESS;
2452           stat->ProgressRes = res;
2453           return res;
2454         }
2455         inPrev = p->inProcessed;
2456         outPrev = p->outProcessed;
2457       }
2458     }
2459
2460     if (finished)
2461       return res;
2462   }
2463 }
2464
2465 static SRes XzStatInfo_SetStat(const CXzUnpacker *dec,
2466     int finishMode,
2467     UInt64 readProcessed, UInt64 inProcessed,
2468     SRes res, ECoderStatus status,
2469     Bool decodingTruncated,
2470     CXzStatInfo *stat)
2471 {
2472   UInt64 extraSize;
2473
2474   stat->DecodingTruncated = (Byte)(decodingTruncated ? 1 : 0);
2475   stat->InSize = inProcessed;
2476   stat->NumStreams = dec->numStartedStreams;
2477   stat->NumBlocks = dec->numTotalBlocks;
2478
2479   stat->UnpackSize_Defined = True;
2480   stat->NumStreams_Defined = True;
2481   stat->NumBlocks_Defined = True;
2482
2483   extraSize = XzUnpacker_GetExtraSize(dec);
2484
2485   if (res == SZ_OK)
2486   {
2487     if (status == CODER_STATUS_NEEDS_MORE_INPUT)
2488     {
2489       // CODER_STATUS_NEEDS_MORE_INPUT is expected status for correct xz streams
2490       extraSize = 0;
2491       if (!XzUnpacker_IsStreamWasFinished(dec))
2492         res = SZ_ERROR_INPUT_EOF;
2493     }
2494     else if (!decodingTruncated || finishMode) // (status == CODER_STATUS_NOT_FINISHED)
2495       res = SZ_ERROR_DATA;
2496   }
2497   else if (res == SZ_ERROR_NO_ARCHIVE)
2498   {
2499     /*
2500     SZ_ERROR_NO_ARCHIVE is possible for 2 states:
2501       XZ_STATE_STREAM_HEADER  - if bad signature or bad CRC
2502       XZ_STATE_STREAM_PADDING - if non-zero padding data
2503     extraSize / inProcessed don't include "bad" byte
2504     */
2505     if (inProcessed != extraSize) // if good streams before error
2506       if (extraSize != 0 || readProcessed != inProcessed)
2507       {
2508         stat->DataAfterEnd = True;
2509         // there is some good xz stream before. So we set SZ_OK
2510         res = SZ_OK;
2511       }
2512   }
2513
2514   stat->DecodeRes = res;
2515
2516   stat->InSize -= extraSize;
2517   return res;
2518 }
2519
2520
2521 SRes XzDecMt_Decode(CXzDecMtHandle pp,
2522     const CXzDecMtProps *props,
2523     const UInt64 *outDataSize, int finishMode,
2524     ISeqOutStream *outStream,
2525     // Byte *outBuf, size_t *outBufSize,
2526     ISeqInStream *inStream,
2527     // const Byte *inData, size_t inDataSize,
2528     CXzStatInfo *stat,
2529     int *isMT,
2530     ICompressProgress *progress)
2531 {
2532   CXzDecMt *p = (CXzDecMt *)pp;
2533   #ifndef _7ZIP_ST
2534   Bool tMode;
2535   #endif
2536
2537   XzStatInfo_Clear(stat);
2538
2539   p->props = *props;
2540
2541   p->inStream = inStream;
2542   p->outStream = outStream;
2543   p->progress = progress;
2544   // p->stat = stat;
2545
2546   p->outSize = 0;
2547   p->outSize_Defined = False;
2548   if (outDataSize)
2549   {
2550     p->outSize_Defined = True;
2551     p->outSize = *outDataSize;
2552   }
2553
2554   p->finishMode = finishMode;
2555
2556   // p->outSize = 457; p->outSize_Defined = True; p->finishMode = False; // for test
2557
2558   p->writeRes = SZ_OK;
2559   p->outProcessed = 0;
2560   p->inProcessed = 0;
2561   p->readProcessed = 0;
2562   p->readWasFinished = False;
2563
2564   p->codeRes = 0;
2565   p->status = CODER_STATUS_NOT_SPECIFIED;
2566
2567   if (!p->dec_created)
2568   {
2569     XzUnpacker_Construct(&p->dec, &p->alignOffsetAlloc.vt);
2570     p->dec_created = True;
2571   }
2572   XzUnpacker_Init(&p->dec);
2573
2574
2575   *isMT = False;
2576
2577     /*
2578     p->outBuf = NULL;
2579     p->outBufSize = 0;
2580     if (!outStream)
2581     {
2582       p->outBuf = outBuf;
2583       p->outBufSize = *outBufSize;
2584       *outBufSize = 0;
2585     }
2586     */
2587
2588
2589   #ifndef _7ZIP_ST
2590
2591   p->isBlockHeaderState_Parse = False;
2592   p->isBlockHeaderState_Write = False;
2593   // p->numBadBlocks = 0;
2594   p->mainErrorCode = SZ_OK;
2595   p->mainDecoderWasCalled = False;
2596
2597   tMode = False;
2598
2599   if (p->props.numThreads > 1)
2600   {
2601     IMtDecCallback vt;
2602
2603     XzDecMt_FreeSt(p);
2604
2605     p->outProcessed_Parse = 0;
2606     p->parsing_Truncated = False;
2607
2608     p->numStreams = 0;
2609     p->numTotalBlocks = 0;
2610     p->numBlocks = 0;
2611     p->finishedDecoderIndex = -1;
2612
2613     if (!p->mtc_WasConstructed)
2614     {
2615       p->mtc_WasConstructed = True;
2616       MtDec_Construct(&p->mtc);
2617     }
2618
2619     p->mtc.mtCallback = &vt;
2620     p->mtc.mtCallbackObject = p;
2621
2622     p->mtc.progress = progress;
2623     p->mtc.inStream = inStream;
2624     p->mtc.alloc = &p->alignOffsetAlloc.vt;
2625     // p->mtc.inData = inData;
2626     // p->mtc.inDataSize = inDataSize;
2627     p->mtc.inBufSize = p->props.inBufSize_MT;
2628     // p->mtc.inBlockMax = p->props.inBlockMax;
2629     p->mtc.numThreadsMax = p->props.numThreads;
2630
2631     *isMT = True;
2632
2633     vt.Parse = XzDecMt_Callback_Parse;
2634     vt.PreCode = XzDecMt_Callback_PreCode;
2635     vt.Code = XzDecMt_Callback_Code;
2636     vt.Write = XzDecMt_Callback_Write;
2637
2638     {
2639       Bool needContinue;
2640
2641       SRes res = MtDec_Code(&p->mtc);
2642
2643       stat->InSize = p->mtc.inProcessed;
2644
2645       p->inProcessed = p->mtc.inProcessed;
2646       p->readRes = p->mtc.readRes;
2647       p->readWasFinished = p->mtc.readWasFinished;
2648       p->readProcessed = p->mtc.readProcessed;
2649
2650       tMode = True;
2651       needContinue = False;
2652
2653       if (res == SZ_OK)
2654       {
2655         if (p->mtc.mtProgress.res != SZ_OK)
2656         {
2657           res = p->mtc.mtProgress.res;
2658           stat->ProgressRes = res;
2659           stat->CombinedRes_Type = SZ_ERROR_PROGRESS;
2660         }
2661         else
2662           needContinue = p->mtc.needContinue;
2663       }
2664
2665       if (!needContinue)
2666       {
2667         SRes codeRes;
2668         Bool truncated = False;
2669         ECoderStatus status;
2670         CXzUnpacker *dec;
2671
2672         stat->OutSize = p->outProcessed;
2673
2674         if (p->finishedDecoderIndex >= 0)
2675         {
2676           CXzDecMtThread *coder = &p->coders[(unsigned)p->finishedDecoderIndex];
2677           codeRes = coder->codeRes;
2678           dec = &coder->dec;
2679           status = coder->status;
2680         }
2681         else if (p->mainDecoderWasCalled)
2682         {
2683           codeRes = p->codeRes;
2684           dec = &p->dec;
2685           status = p->status;
2686           truncated = p->parsing_Truncated;
2687         }
2688         else
2689           return E_FAIL;
2690
2691         XzStatInfo_SetStat(dec, p->finishMode,
2692             p->mtc.readProcessed, p->mtc.inProcessed,
2693             codeRes, status,
2694             truncated,
2695             stat);
2696
2697         if (res == SZ_OK)
2698         {
2699           if (p->writeRes != SZ_OK)
2700           {
2701             res = p->writeRes;
2702             stat->CombinedRes_Type = SZ_ERROR_WRITE;
2703           }
2704           else if (p->mtc.readRes != SZ_OK && p->mtc.inProcessed == p->mtc.readProcessed)
2705           {
2706             res = p->mtc.readRes;
2707             stat->ReadRes = res;
2708             stat->CombinedRes_Type = SZ_ERROR_READ;
2709           }
2710           else if (p->mainErrorCode != SZ_OK)
2711           {
2712             res = p->mainErrorCode;
2713           }
2714         }
2715
2716         stat->CombinedRes = res;
2717         if (stat->CombinedRes_Type == SZ_OK)
2718           stat->CombinedRes_Type = res;
2719         return res;
2720       }
2721
2722       PRF_STR("----- decoding ST -----");
2723     }
2724   }
2725
2726   #endif
2727
2728
2729   *isMT = False;
2730
2731   {
2732     SRes res = XzDecMt_Decode_ST(p
2733         #ifndef _7ZIP_ST
2734         , tMode
2735         #endif
2736         , stat
2737         );
2738
2739     XzStatInfo_SetStat(&p->dec,
2740         p->finishMode,
2741         p->readProcessed, p->inProcessed,
2742         p->codeRes, p->status,
2743         False, // truncated
2744         stat);
2745
2746     if (res == SZ_OK)
2747     {
2748       /*
2749       if (p->writeRes != SZ_OK)
2750       {
2751         res = p->writeRes;
2752         stat->CombinedRes_Type = SZ_ERROR_WRITE;
2753       }
2754       else
2755       */
2756       if (p->readRes != SZ_OK && p->inProcessed == p->readProcessed)
2757       {
2758         res = p->readRes;
2759         stat->ReadRes = res;
2760         stat->CombinedRes_Type = SZ_ERROR_READ;
2761       }
2762       #ifndef _7ZIP_ST
2763       else if (p->mainErrorCode != SZ_OK)
2764         res = p->mainErrorCode;
2765       #endif
2766     }
2767
2768     stat->CombinedRes = res;
2769     if (stat->CombinedRes_Type == SZ_OK)
2770       stat->CombinedRes_Type = res;
2771     return res;
2772   }
2773 }