[pcsx_rearmed.git] / deps / lzma-16.04 / C / XzDec.c

/* XzDec.c -- Xz Decode\r
2015-11-09 : Igor Pavlov : Public domain */\r
\r
#include "Precomp.h"\r
\r
/* #define XZ_DUMP */\r
\r
#ifdef XZ_DUMP\r
#include <stdio.h>\r
#endif\r
\r
#include <stdlib.h>\r
#include <string.h>\r
\r
#include "7zCrc.h"\r
#include "Alloc.h"\r
#include "Bra.h"\r
#include "CpuArch.h"\r
#include "Delta.h"\r
#include "Lzma2Dec.h"\r
\r
#ifdef USE_SUBBLOCK\r
#include "Bcj3Dec.c"\r
#include "SbDec.c"\r
#endif\r
\r
#include "Xz.h"\r
\r
#define XZ_CHECK_SIZE_MAX 64\r
\r
#define CODER_BUF_SIZE (1 << 17)\r
\r
unsigned Xz_ReadVarInt(const Byte *p, size_t maxSize, UInt64 *value)\r
{\r
  unsigned i, limit;\r
  *value = 0;\r
  limit = (maxSize > 9) ? 9 : (unsigned)maxSize;\r
\r
  for (i = 0; i < limit;)\r
  {\r
    Byte b = p[i];\r
    *value |= (UInt64)(b & 0x7F) << (7 * i++);\r
    if ((b & 0x80) == 0)\r
      return (b == 0 && i != 1) ? 0 : i;\r
  }\r
  return 0;\r
}\r
\r
/* ---------- BraState ---------- */\r
\r
#define BRA_BUF_SIZE (1 << 14)\r
\r
typedef struct\r
{\r
  size_t bufPos;\r
  size_t bufConv;\r
  size_t bufTotal;\r
\r
  UInt32 methodId;\r
  int encodeMode;\r
  UInt32 delta;\r
  UInt32 ip;\r
  UInt32 x86State;\r
  Byte deltaState[DELTA_STATE_SIZE];\r
\r
  Byte buf[BRA_BUF_SIZE];\r
} CBraState;\r
\r
static void BraState_Free(void *pp, ISzAlloc *alloc)\r
{\r
  alloc->Free(alloc, pp);\r
}\r
\r
static SRes BraState_SetProps(void *pp, const Byte *props, size_t propSize, ISzAlloc *alloc)\r
{\r
  CBraState *p = ((CBraState *)pp);\r
  UNUSED_VAR(alloc);\r
  p->ip = 0;\r
  if (p->methodId == XZ_ID_Delta)\r
  {\r
    if (propSize != 1)\r
      return SZ_ERROR_UNSUPPORTED;\r
    p->delta = (unsigned)props[0] + 1;\r
  }\r
  else\r
  {\r
    if (propSize == 4)\r
    {\r
      UInt32 v = GetUi32(props);\r
      switch (p->methodId)\r
      {\r
        case XZ_ID_PPC:\r
        case XZ_ID_ARM:\r
        case XZ_ID_SPARC:\r
          if ((v & 3) != 0)\r
            return SZ_ERROR_UNSUPPORTED;\r
          break;\r
        case XZ_ID_ARMT:\r
          if ((v & 1) != 0)\r
            return SZ_ERROR_UNSUPPORTED;\r
          break;\r
        case XZ_ID_IA64:\r
          if ((v & 0xF) != 0)\r
            return SZ_ERROR_UNSUPPORTED;\r
          break;\r
      }\r
      p->ip = v;\r
    }\r
    else if (propSize != 0)\r
      return SZ_ERROR_UNSUPPORTED;\r
  }\r
  return SZ_OK;\r
}\r
\r
static void BraState_Init(void *pp)\r
{\r
  CBraState *p = ((CBraState *)pp);\r
  p->bufPos = p->bufConv = p->bufTotal = 0;\r
  x86_Convert_Init(p->x86State);\r
  if (p->methodId == XZ_ID_Delta)\r
    Delta_Init(p->deltaState);\r
}\r
\r
#define CASE_BRA_CONV(isa) case XZ_ID_ ## isa: p->bufConv = isa ## _Convert(p->buf, p->bufTotal, p->ip, p->encodeMode); break;\r
\r
static SRes BraState_Code(void *pp, Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,\r
    int srcWasFinished, ECoderFinishMode finishMode, int *wasFinished)\r
{\r
  CBraState *p = ((CBraState *)pp);\r
  SizeT destLenOrig = *destLen;\r
  SizeT srcLenOrig = *srcLen;\r
  UNUSED_VAR(finishMode);\r
  *destLen = 0;\r
  *srcLen = 0;\r
  *wasFinished = 0;\r
  while (destLenOrig > 0)\r
  {\r
    if (p->bufPos != p->bufConv)\r
    {\r
      size_t curSize = p->bufConv - p->bufPos;\r
      if (curSize > destLenOrig)\r
        curSize = destLenOrig;\r
      memcpy(dest, p->buf + p->bufPos, curSize);\r
      p->bufPos += curSize;\r
      *destLen += curSize;\r
      dest += curSize;\r
      destLenOrig -= curSize;\r
      continue;\r
    }\r
    p->bufTotal -= p->bufPos;\r
    memmove(p->buf, p->buf + p->bufPos, p->bufTotal);\r
    p->bufPos = 0;\r
    p->bufConv = 0;\r
    {\r
      size_t curSize = BRA_BUF_SIZE - p->bufTotal;\r
      if (curSize > srcLenOrig)\r
        curSize = srcLenOrig;\r
      memcpy(p->buf + p->bufTotal, src, curSize);\r
      *srcLen += curSize;\r
      src += curSize;\r
      srcLenOrig -= curSize;\r
      p->bufTotal += curSize;\r
    }\r
    if (p->bufTotal == 0)\r
      break;\r
    switch (p->methodId)\r
    {\r
      case XZ_ID_Delta:\r
        if (p->encodeMode)\r
          Delta_Encode(p->deltaState, p->delta, p->buf, p->bufTotal);\r
        else\r
          Delta_Decode(p->deltaState, p->delta, p->buf, p->bufTotal);\r
        p->bufConv = p->bufTotal;\r
        break;\r
      case XZ_ID_X86:\r
        p->bufConv = x86_Convert(p->buf, p->bufTotal, p->ip, &p->x86State, p->encodeMode);\r
        break;\r
      CASE_BRA_CONV(PPC)\r
      CASE_BRA_CONV(IA64)\r
      CASE_BRA_CONV(ARM)\r
      CASE_BRA_CONV(ARMT)\r
      CASE_BRA_CONV(SPARC)\r
      default:\r
        return SZ_ERROR_UNSUPPORTED;\r
    }\r
    p->ip += (UInt32)p->bufConv;\r
\r
    if (p->bufConv == 0)\r
    {\r
      if (!srcWasFinished)\r
        break;\r
      p->bufConv = p->bufTotal;\r
    }\r
  }\r
  if (p->bufTotal == p->bufPos && srcLenOrig == 0 && srcWasFinished)\r
    *wasFinished = 1;\r
  return SZ_OK;\r
}\r
\r
SRes BraState_SetFromMethod(IStateCoder *p, UInt64 id, int encodeMode, ISzAlloc *alloc)\r
{\r
  CBraState *decoder;\r
  if (id != XZ_ID_Delta &&\r
      id != XZ_ID_X86 &&\r
      id != XZ_ID_PPC &&\r
      id != XZ_ID_IA64 &&\r
      id != XZ_ID_ARM &&\r
      id != XZ_ID_ARMT &&\r
      id != XZ_ID_SPARC)\r
    return SZ_ERROR_UNSUPPORTED;\r
  p->p = 0;\r
  decoder = (CBraState *)alloc->Alloc(alloc, sizeof(CBraState));\r
  if (decoder == 0)\r
    return SZ_ERROR_MEM;\r
  decoder->methodId = (UInt32)id;\r
  decoder->encodeMode = encodeMode;\r
  p->p = decoder;\r
  p->Free = BraState_Free;\r
  p->SetProps = BraState_SetProps;\r
  p->Init = BraState_Init;\r
  p->Code = BraState_Code;\r
  return SZ_OK;\r
}\r
\r
/* ---------- SbState ---------- */\r
\r
#ifdef USE_SUBBLOCK\r
\r
static void SbState_Free(void *pp, ISzAlloc *alloc)\r
{\r
  CSbDec *p = (CSbDec *)pp;\r
  SbDec_Free(p);\r
  alloc->Free(alloc, pp);\r
}\r
\r
static SRes SbState_SetProps(void *pp, const Byte *props, size_t propSize, ISzAlloc *alloc)\r
{\r
  UNUSED_VAR(pp);\r
  UNUSED_VAR(props);\r
  UNUSED_VAR(alloc);\r
  return (propSize == 0) ? SZ_OK : SZ_ERROR_UNSUPPORTED;\r
}\r
\r
static void SbState_Init(void *pp)\r
{\r
  SbDec_Init((CSbDec *)pp);\r
}\r
\r
static SRes SbState_Code(void *pp, Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,\r
    int srcWasFinished, ECoderFinishMode finishMode, int *wasFinished)\r
{\r
  CSbDec *p = (CSbDec *)pp;\r
  SRes res;\r
  UNUSED_VAR(srcWasFinished);\r
  p->dest = dest;\r
  p->destLen = *destLen;\r
  p->src = src;\r
  p->srcLen = *srcLen;\r
  p->finish = finishMode; /* change it */\r
  res = SbDec_Decode((CSbDec *)pp);\r
  *destLen -= p->destLen;\r
  *srcLen -= p->srcLen;\r
  *wasFinished = (*destLen == 0 && *srcLen == 0); /* change it */\r
  return res;\r
}\r
\r
SRes SbState_SetFromMethod(IStateCoder *p, ISzAlloc *alloc)\r
{\r
  CSbDec *decoder;\r
  p->p = 0;\r
  decoder = alloc->Alloc(alloc, sizeof(CSbDec));\r
  if (decoder == 0)\r
    return SZ_ERROR_MEM;\r
  p->p = decoder;\r
  p->Free = SbState_Free;\r
  p->SetProps = SbState_SetProps;\r
  p->Init = SbState_Init;\r
  p->Code = SbState_Code;\r
  SbDec_Construct(decoder);\r
  SbDec_SetAlloc(decoder, alloc);\r
  return SZ_OK;\r
}\r
#endif\r
\r
/* ---------- Lzma2State ---------- */\r
\r
static void Lzma2State_Free(void *pp, ISzAlloc *alloc)\r
{\r
  Lzma2Dec_Free((CLzma2Dec *)pp, alloc);\r
  alloc->Free(alloc, pp);\r
}\r
\r
static SRes Lzma2State_SetProps(void *pp, const Byte *props, size_t propSize, ISzAlloc *alloc)\r
{\r
  if (propSize != 1)\r
    return SZ_ERROR_UNSUPPORTED;\r
  return Lzma2Dec_Allocate((CLzma2Dec *)pp, props[0], alloc);\r
}\r
\r
static void Lzma2State_Init(void *pp)\r
{\r
  Lzma2Dec_Init((CLzma2Dec *)pp);\r
}\r
\r
static SRes Lzma2State_Code(void *pp, Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,\r
    int srcWasFinished, ECoderFinishMode finishMode, int *wasFinished)\r
{\r
  ELzmaStatus status;\r
  /* ELzmaFinishMode fm = (finishMode == LZMA_FINISH_ANY) ? LZMA_FINISH_ANY : LZMA_FINISH_END; */\r
  SRes res = Lzma2Dec_DecodeToBuf((CLzma2Dec *)pp, dest, destLen, src, srcLen, (ELzmaFinishMode)finishMode, &status);\r
  UNUSED_VAR(srcWasFinished);\r
  *wasFinished = (status == LZMA_STATUS_FINISHED_WITH_MARK);\r
  return res;\r
}\r
\r
static SRes Lzma2State_SetFromMethod(IStateCoder *p, ISzAlloc *alloc)\r
{\r
  CLzma2Dec *decoder = (CLzma2Dec *)alloc->Alloc(alloc, sizeof(CLzma2Dec));\r
  p->p = decoder;\r
  if (decoder == 0)\r
    return SZ_ERROR_MEM;\r
  p->Free = Lzma2State_Free;\r
  p->SetProps = Lzma2State_SetProps;\r
  p->Init = Lzma2State_Init;\r
  p->Code = Lzma2State_Code;\r
  Lzma2Dec_Construct(decoder);\r
  return SZ_OK;\r
}\r
\r
\r
void MixCoder_Construct(CMixCoder *p, ISzAlloc *alloc)\r
{\r
  unsigned i;\r
  p->alloc = alloc;\r
  p->buf = NULL;\r
  p->numCoders = 0;\r
  for (i = 0; i < MIXCODER_NUM_FILTERS_MAX; i++)\r
    p->coders[i].p = NULL;\r
}\r
\r
void MixCoder_Free(CMixCoder *p)\r
{\r
  unsigned i;\r
  for (i = 0; i < p->numCoders; i++)\r
  {\r
    IStateCoder *sc = &p->coders[i];\r
    if (p->alloc && sc->p)\r
      sc->Free(sc->p, p->alloc);\r
  }\r
  p->numCoders = 0;\r
  if (p->buf)\r
  {\r
    p->alloc->Free(p->alloc, p->buf);\r
    p->buf = NULL; /* 9.31: the BUG was fixed */\r
  }\r
}\r
\r
void MixCoder_Init(CMixCoder *p)\r
{\r
  unsigned i;\r
  for (i = 0; i < MIXCODER_NUM_FILTERS_MAX - 1; i++)\r
  {\r
    p->size[i] = 0;\r
    p->pos[i] = 0;\r
    p->finished[i] = 0;\r
  }\r
  for (i = 0; i < p->numCoders; i++)\r
  {\r
    IStateCoder *coder = &p->coders[i];\r
    coder->Init(coder->p);\r
  }\r
}\r
\r
SRes MixCoder_SetFromMethod(CMixCoder *p, unsigned coderIndex, UInt64 methodId)\r
{\r
  IStateCoder *sc = &p->coders[coderIndex];\r
  p->ids[coderIndex] = methodId;\r
  switch (methodId)\r
  {\r
    case XZ_ID_LZMA2: return Lzma2State_SetFromMethod(sc, p->alloc);\r
    #ifdef USE_SUBBLOCK\r
    case XZ_ID_Subblock: return SbState_SetFromMethod(sc, p->alloc);\r
    #endif\r
  }\r
  if (coderIndex == 0)\r
    return SZ_ERROR_UNSUPPORTED;\r
  return BraState_SetFromMethod(sc, methodId, 0, p->alloc);\r
}\r
\r
SRes MixCoder_Code(CMixCoder *p, Byte *dest, SizeT *destLen,\r
    const Byte *src, SizeT *srcLen, int srcWasFinished,\r
    ECoderFinishMode finishMode, ECoderStatus *status)\r
{\r
  SizeT destLenOrig = *destLen;\r
  SizeT srcLenOrig = *srcLen;\r
  Bool allFinished = True;\r
  *destLen = 0;\r
  *srcLen = 0;\r
  *status = CODER_STATUS_NOT_FINISHED;\r
\r
  if (!p->buf)\r
  {\r
    p->buf = (Byte *)p->alloc->Alloc(p->alloc, CODER_BUF_SIZE * (MIXCODER_NUM_FILTERS_MAX - 1));\r
    if (!p->buf)\r
      return SZ_ERROR_MEM;\r
  }\r
\r
  if (p->numCoders != 1)\r
    finishMode = CODER_FINISH_ANY;\r
\r
  for (;;)\r
  {\r
    Bool processed = False;\r
    unsigned i;\r
    /*\r
    if (p->numCoders == 1 && *destLen == destLenOrig && finishMode == LZMA_FINISH_ANY)\r
      break;\r
    */\r
\r
    for (i = 0; i < p->numCoders; i++)\r
    {\r
      SRes res;\r
      IStateCoder *coder = &p->coders[i];\r
      Byte *destCur;\r
      SizeT destLenCur, srcLenCur;\r
      const Byte *srcCur;\r
      int srcFinishedCur;\r
      int encodingWasFinished;\r
      \r
      if (i == 0)\r
      {\r
        srcCur = src;\r
        srcLenCur = srcLenOrig - *srcLen;\r
        srcFinishedCur = srcWasFinished;\r
      }\r
      else\r
      {\r
        srcCur = p->buf + (CODER_BUF_SIZE * (i - 1)) + p->pos[i - 1];\r
        srcLenCur = p->size[i - 1] - p->pos[i - 1];\r
        srcFinishedCur = p->finished[i - 1];\r
      }\r
      \r
      if (i == p->numCoders - 1)\r
      {\r
        destCur = dest;\r
        destLenCur = destLenOrig - *destLen;\r
      }\r
      else\r
      {\r
        if (p->pos[i] != p->size[i])\r
          continue;\r
        destCur = p->buf + (CODER_BUF_SIZE * i);\r
        destLenCur = CODER_BUF_SIZE;\r
      }\r
      \r
      res = coder->Code(coder->p, destCur, &destLenCur, srcCur, &srcLenCur, srcFinishedCur, finishMode, &encodingWasFinished);\r
\r
      if (!encodingWasFinished)\r
        allFinished = False;\r
\r
      if (i == 0)\r
      {\r
        *srcLen += srcLenCur;\r
        src += srcLenCur;\r
      }\r
      else\r
      {\r
        p->pos[i - 1] += srcLenCur;\r
      }\r
\r
      if (i == p->numCoders - 1)\r
      {\r
        *destLen += destLenCur;\r
        dest += destLenCur;\r
      }\r
      else\r
      {\r
        p->size[i] = destLenCur;\r
        p->pos[i] = 0;\r
        p->finished[i] = encodingWasFinished;\r
      }\r
      \r
      if (res != SZ_OK)\r
        return res;\r
\r
      if (destLenCur != 0 || srcLenCur != 0)\r
        processed = True;\r
    }\r
    if (!processed)\r
      break;\r
  }\r
  if (allFinished)\r
    *status = CODER_STATUS_FINISHED_WITH_MARK;\r
  return SZ_OK;\r
}\r
\r
SRes Xz_ParseHeader(CXzStreamFlags *p, const Byte *buf)\r
{\r
  *p = (CXzStreamFlags)GetBe16(buf + XZ_SIG_SIZE);\r
  if (CrcCalc(buf + XZ_SIG_SIZE, XZ_STREAM_FLAGS_SIZE) !=\r
      GetUi32(buf + XZ_SIG_SIZE + XZ_STREAM_FLAGS_SIZE))\r
    return SZ_ERROR_NO_ARCHIVE;\r
  return XzFlags_IsSupported(*p) ? SZ_OK : SZ_ERROR_UNSUPPORTED;\r
}\r
\r
static Bool Xz_CheckFooter(CXzStreamFlags flags, UInt64 indexSize, const Byte *buf)\r
{\r
  return\r
      indexSize == (((UInt64)GetUi32(buf + 4) + 1) << 2) &&\r
      (GetUi32(buf) == CrcCalc(buf + 4, 6) &&\r
      flags == GetBe16(buf + 8) &&\r
      memcmp(buf + 10, XZ_FOOTER_SIG, XZ_FOOTER_SIG_SIZE) == 0);\r
}\r
\r
#define READ_VARINT_AND_CHECK(buf, pos, size, res) \\r
  { unsigned s = Xz_ReadVarInt(buf + pos, size - pos, res); \\r
  if (s == 0) return SZ_ERROR_ARCHIVE; pos += s; }\r
\r
\r
SRes XzBlock_Parse(CXzBlock *p, const Byte *header)\r
{\r
  unsigned pos;\r
  unsigned numFilters, i;\r
  unsigned headerSize = (unsigned)header[0] << 2;\r
\r
  if (CrcCalc(header, headerSize) != GetUi32(header + headerSize))\r
    return SZ_ERROR_ARCHIVE;\r
\r
  pos = 1;\r
  if (pos == headerSize)\r
    return SZ_ERROR_ARCHIVE;\r
  p->flags = header[pos++];\r
\r
  if (XzBlock_HasPackSize(p))\r
  {\r
    READ_VARINT_AND_CHECK(header, pos, headerSize, &p->packSize);\r
    if (p->packSize == 0 || p->packSize + headerSize >= (UInt64)1 << 63)\r
      return SZ_ERROR_ARCHIVE;\r
  }\r
\r
  if (XzBlock_HasUnpackSize(p))\r
    READ_VARINT_AND_CHECK(header, pos, headerSize, &p->unpackSize);\r
\r
  numFilters = XzBlock_GetNumFilters(p);\r
  for (i = 0; i < numFilters; i++)\r
  {\r
    CXzFilter *filter = p->filters + i;\r
    UInt64 size;\r
    READ_VARINT_AND_CHECK(header, pos, headerSize, &filter->id);\r
    READ_VARINT_AND_CHECK(header, pos, headerSize, &size);\r
    if (size > headerSize - pos || size > XZ_FILTER_PROPS_SIZE_MAX)\r
      return SZ_ERROR_ARCHIVE;\r
    filter->propsSize = (UInt32)size;\r
    memcpy(filter->props, header + pos, (size_t)size);\r
    pos += (unsigned)size;\r
\r
    #ifdef XZ_DUMP\r
    printf("\nf[%u] = %2X: ", i, (unsigned)filter->id);\r
    {\r
      unsigned i;\r
      for (i = 0; i < size; i++)\r
        printf(" %2X", filter->props[i]);\r
    }\r
    #endif\r
  }\r
\r
  while (pos < headerSize)\r
    if (header[pos++] != 0)\r
      return SZ_ERROR_ARCHIVE;\r
  return SZ_OK;\r
}\r
\r
SRes XzDec_Init(CMixCoder *p, const CXzBlock *block)\r
{\r
  unsigned i;\r
  Bool needReInit = True;\r
  unsigned numFilters = XzBlock_GetNumFilters(block);\r
  \r
  if (numFilters == p->numCoders)\r
  {\r
    for (i = 0; i < numFilters; i++)\r
      if (p->ids[i] != block->filters[numFilters - 1 - i].id)\r
        break;\r
    needReInit = (i != numFilters);\r
  }\r
  \r
  if (needReInit)\r
  {\r
    MixCoder_Free(p);\r
    p->numCoders = numFilters;\r
    for (i = 0; i < numFilters; i++)\r
    {\r
      const CXzFilter *f = &block->filters[numFilters - 1 - i];\r
      RINOK(MixCoder_SetFromMethod(p, i, f->id));\r
    }\r
  }\r
  \r
  for (i = 0; i < numFilters; i++)\r
  {\r
    const CXzFilter *f = &block->filters[numFilters - 1 - i];\r
    IStateCoder *sc = &p->coders[i];\r
    RINOK(sc->SetProps(sc->p, f->props, f->propsSize, p->alloc));\r
  }\r
  \r
  MixCoder_Init(p);\r
  return SZ_OK;\r
}\r
\r
void XzUnpacker_Init(CXzUnpacker *p)\r
{\r
  p->state = XZ_STATE_STREAM_HEADER;\r
  p->pos = 0;\r
  p->numStartedStreams = 0;\r
  p->numFinishedStreams = 0;\r
  p->numTotalBlocks = 0;\r
  p->padSize = 0;\r
}\r
\r
void XzUnpacker_Construct(CXzUnpacker *p, ISzAlloc *alloc)\r
{\r
  MixCoder_Construct(&p->decoder, alloc);\r
  XzUnpacker_Init(p);\r
}\r
\r
void XzUnpacker_Free(CXzUnpacker *p)\r
{\r
  MixCoder_Free(&p->decoder);\r
}\r
\r
SRes XzUnpacker_Code(CXzUnpacker *p, Byte *dest, SizeT *destLen,\r
    const Byte *src, SizeT *srcLen, ECoderFinishMode finishMode, ECoderStatus *status)\r
{\r
  SizeT destLenOrig = *destLen;\r
  SizeT srcLenOrig = *srcLen;\r
  *destLen = 0;\r
  *srcLen = 0;\r
  *status = CODER_STATUS_NOT_SPECIFIED;\r
  for (;;)\r
  {\r
    SizeT srcRem = srcLenOrig - *srcLen;\r
\r
    if (p->state == XZ_STATE_BLOCK)\r
    {\r
      SizeT destLen2 = destLenOrig - *destLen;\r
      SizeT srcLen2 = srcLenOrig - *srcLen;\r
      SRes res;\r
      if (srcLen2 == 0 && destLen2 == 0)\r
      {\r
        *status = CODER_STATUS_NOT_FINISHED;\r
        return SZ_OK;\r
      }\r
      \r
      res = MixCoder_Code(&p->decoder, dest, &destLen2, src, &srcLen2, False, finishMode, status);\r
      XzCheck_Update(&p->check, dest, destLen2);\r
      \r
      (*srcLen) += srcLen2;\r
      src += srcLen2;\r
      p->packSize += srcLen2;\r
      \r
      (*destLen) += destLen2;\r
      dest += destLen2;\r
      p->unpackSize += destLen2;\r
      \r
      RINOK(res);\r
      \r
      if (*status == CODER_STATUS_FINISHED_WITH_MARK)\r
      {\r
        Byte temp[32];\r
        unsigned num = Xz_WriteVarInt(temp, p->packSize + p->blockHeaderSize + XzFlags_GetCheckSize(p->streamFlags));\r
        num += Xz_WriteVarInt(temp + num, p->unpackSize);\r
        Sha256_Update(&p->sha, temp, num);\r
        p->indexSize += num;\r
        p->numBlocks++;\r
        \r
        p->state = XZ_STATE_BLOCK_FOOTER;\r
        p->pos = 0;\r
        p->alignPos = 0;\r
      }\r
      else if (srcLen2 == 0 && destLen2 == 0)\r
        return SZ_OK;\r
      \r
      continue;\r
    }\r
\r
    if (srcRem == 0)\r
    {\r
      *status = CODER_STATUS_NEEDS_MORE_INPUT;\r
      return SZ_OK;\r
    }\r
\r
    switch (p->state)\r
    {\r
      case XZ_STATE_STREAM_HEADER:\r
      {\r
        if (p->pos < XZ_STREAM_HEADER_SIZE)\r
        {\r
          if (p->pos < XZ_SIG_SIZE && *src != XZ_SIG[p->pos])\r
            return SZ_ERROR_NO_ARCHIVE;\r
          p->buf[p->pos++] = *src++;\r
          (*srcLen)++;\r
        }\r
        else\r
        {\r
          RINOK(Xz_ParseHeader(&p->streamFlags, p->buf));\r
          p->numStartedStreams++;\r
          p->state = XZ_STATE_BLOCK_HEADER;\r
          Sha256_Init(&p->sha);\r
          p->indexSize = 0;\r
          p->numBlocks = 0;\r
          p->pos = 0;\r
        }\r
        break;\r
      }\r
\r
      case XZ_STATE_BLOCK_HEADER:\r
      {\r
        if (p->pos == 0)\r
        {\r
          p->buf[p->pos++] = *src++;\r
          (*srcLen)++;\r
          if (p->buf[0] == 0)\r
          {\r
            p->indexPreSize = 1 + Xz_WriteVarInt(p->buf + 1, p->numBlocks);\r
            p->indexPos = p->indexPreSize;\r
            p->indexSize += p->indexPreSize;\r
            Sha256_Final(&p->sha, p->shaDigest);\r
            Sha256_Init(&p->sha);\r
            p->crc = CrcUpdate(CRC_INIT_VAL, p->buf, p->indexPreSize);\r
            p->state = XZ_STATE_STREAM_INDEX;\r
          }\r
          p->blockHeaderSize = ((UInt32)p->buf[0] << 2) + 4;\r
        }\r
        else if (p->pos != p->blockHeaderSize)\r
        {\r
          UInt32 cur = p->blockHeaderSize - p->pos;\r
          if (cur > srcRem)\r
            cur = (UInt32)srcRem;\r
          memcpy(p->buf + p->pos, src, cur);\r
          p->pos += cur;\r
          (*srcLen) += cur;\r
          src += cur;\r
        }\r
        else\r
        {\r
          RINOK(XzBlock_Parse(&p->block, p->buf));\r
          p->numTotalBlocks++;\r
          p->state = XZ_STATE_BLOCK;\r
          p->packSize = 0;\r
          p->unpackSize = 0;\r
          XzCheck_Init(&p->check, XzFlags_GetCheckType(p->streamFlags));\r
          RINOK(XzDec_Init(&p->decoder, &p->block));\r
        }\r
        break;\r
      }\r
\r
      case XZ_STATE_BLOCK_FOOTER:\r
      {\r
        if (((p->packSize + p->alignPos) & 3) != 0)\r
        {\r
          (*srcLen)++;\r
          p->alignPos++;\r
          if (*src++ != 0)\r
            return SZ_ERROR_CRC;\r
        }\r
        else\r
        {\r
          UInt32 checkSize = XzFlags_GetCheckSize(p->streamFlags);\r
          UInt32 cur = checkSize - p->pos;\r
          if (cur != 0)\r
          {\r
            if (cur > srcRem)\r
              cur = (UInt32)srcRem;\r
            memcpy(p->buf + p->pos, src, cur);\r
            p->pos += cur;\r
            (*srcLen) += cur;\r
            src += cur;\r
          }\r
          else\r
          {\r
            Byte digest[XZ_CHECK_SIZE_MAX];\r
            p->state = XZ_STATE_BLOCK_HEADER;\r
            p->pos = 0;\r
            if (XzCheck_Final(&p->check, digest) && memcmp(digest, p->buf, checkSize) != 0)\r
              return SZ_ERROR_CRC;\r
          }\r
        }\r
        break;\r
      }\r
\r
      case XZ_STATE_STREAM_INDEX:\r
      {\r
        if (p->pos < p->indexPreSize)\r
        {\r
          (*srcLen)++;\r
          if (*src++ != p->buf[p->pos++])\r
            return SZ_ERROR_CRC;\r
        }\r
        else\r
        {\r
          if (p->indexPos < p->indexSize)\r
          {\r
            UInt64 cur = p->indexSize - p->indexPos;\r
            if (srcRem > cur)\r
              srcRem = (SizeT)cur;\r
            p->crc = CrcUpdate(p->crc, src, srcRem);\r
            Sha256_Update(&p->sha, src, srcRem);\r
            (*srcLen) += srcRem;\r
            src += srcRem;\r
            p->indexPos += srcRem;\r
          }\r
          else if ((p->indexPos & 3) != 0)\r
          {\r
            Byte b = *src++;\r
            p->crc = CRC_UPDATE_BYTE(p->crc, b);\r
            (*srcLen)++;\r
            p->indexPos++;\r
            p->indexSize++;\r
            if (b != 0)\r
              return SZ_ERROR_CRC;\r
          }\r
          else\r
          {\r
            Byte digest[SHA256_DIGEST_SIZE];\r
            p->state = XZ_STATE_STREAM_INDEX_CRC;\r
            p->indexSize += 4;\r
            p->pos = 0;\r
            Sha256_Final(&p->sha, digest);\r
            if (memcmp(digest, p->shaDigest, SHA256_DIGEST_SIZE) != 0)\r
              return SZ_ERROR_CRC;\r
          }\r
        }\r
        break;\r
      }\r
\r
      case XZ_STATE_STREAM_INDEX_CRC:\r
      {\r
        if (p->pos < 4)\r
        {\r
          (*srcLen)++;\r
          p->buf[p->pos++] = *src++;\r
        }\r
        else\r
        {\r
          p->state = XZ_STATE_STREAM_FOOTER;\r
          p->pos = 0;\r
          if (CRC_GET_DIGEST(p->crc) != GetUi32(p->buf))\r
            return SZ_ERROR_CRC;\r
        }\r
        break;\r
      }\r
\r
      case XZ_STATE_STREAM_FOOTER:\r
      {\r
        UInt32 cur = XZ_STREAM_FOOTER_SIZE - p->pos;\r
        if (cur > srcRem)\r
          cur = (UInt32)srcRem;\r
        memcpy(p->buf + p->pos, src, cur);\r
        p->pos += cur;\r
        (*srcLen) += cur;\r
        src += cur;\r
        if (p->pos == XZ_STREAM_FOOTER_SIZE)\r
        {\r
          p->state = XZ_STATE_STREAM_PADDING;\r
          p->numFinishedStreams++;\r
          p->padSize = 0;\r
          if (!Xz_CheckFooter(p->streamFlags, p->indexSize, p->buf))\r
            return SZ_ERROR_CRC;\r
        }\r
        break;\r
      }\r
\r
      case XZ_STATE_STREAM_PADDING:\r
      {\r
        if (*src != 0)\r
        {\r
          if (((UInt32)p->padSize & 3) != 0)\r
            return SZ_ERROR_NO_ARCHIVE;\r
          p->pos = 0;\r
          p->state = XZ_STATE_STREAM_HEADER;\r
        }\r
        else\r
        {\r
          (*srcLen)++;\r
          src++;\r
          p->padSize++;\r
        }\r
        break;\r
      }\r
      \r
      case XZ_STATE_BLOCK: break; /* to disable GCC warning */\r
    }\r
  }\r
  /*\r
  if (p->state == XZ_STATE_FINISHED)\r
    *status = CODER_STATUS_FINISHED_WITH_MARK;\r
  return SZ_OK;\r
  */\r
}\r
\r
Bool XzUnpacker_IsStreamWasFinished(CXzUnpacker *p)\r
{\r
  return (p->state == XZ_STATE_STREAM_PADDING) && (((UInt32)p->padSize & 3) == 0);\r
}\r
\r
UInt64 XzUnpacker_GetExtraSize(CXzUnpacker *p)\r
{\r
  UInt64 num = 0;\r
  if (p->state == XZ_STATE_STREAM_PADDING)\r
    num += p->padSize;\r
  else if (p->state == XZ_STATE_STREAM_HEADER)\r
    num += p->padSize + p->pos;\r
  return num;\r
}\r