| /* Lzma2Dec.c -- LZMA2 Decoder |
| 2015-11-09 : Igor Pavlov : Public domain */ |
| |
| /* #define SHOW_DEBUG_INFO */ |
| |
| #include "Precomp.h" |
| |
| #ifdef SHOW_DEBUG_INFO |
| #include <stdio.h> |
| #endif |
| |
| #include <string.h> |
| |
| #include "Lzma2Dec.h" |
| |
| /* |
| 00000000 - EOS |
| 00000001 U U - Uncompressed Reset Dic |
| 00000010 U U - Uncompressed No Reset |
| 100uuuuu U U P P - LZMA no reset |
| 101uuuuu U U P P - LZMA reset state |
| 110uuuuu U U P P S - LZMA reset state + new prop |
| 111uuuuu U U P P S - LZMA reset state + new prop + reset dic |
| |
| u, U - Unpack Size |
| P - Pack Size |
| S - Props |
| */ |
| |
| #define LZMA2_CONTROL_LZMA (1 << 7) |
| #define LZMA2_CONTROL_COPY_NO_RESET 2 |
| #define LZMA2_CONTROL_COPY_RESET_DIC 1 |
| #define LZMA2_CONTROL_EOF 0 |
| |
| #define LZMA2_IS_UNCOMPRESSED_STATE(p) (((p)->control & LZMA2_CONTROL_LZMA) == 0) |
| |
| #define LZMA2_GET_LZMA_MODE(p) (((p)->control >> 5) & 3) |
| #define LZMA2_IS_THERE_PROP(mode) ((mode) >= 2) |
| |
| #define LZMA2_LCLP_MAX 4 |
| #define LZMA2_DIC_SIZE_FROM_PROP(p) (((UInt32)2 | ((p) & 1)) << ((p) / 2 + 11)) |
| |
| #ifdef SHOW_DEBUG_INFO |
| #define PRF(x) x |
| #else |
| #define PRF(x) |
| #endif |
| |
| typedef enum |
| { |
| LZMA2_STATE_CONTROL, |
| LZMA2_STATE_UNPACK0, |
| LZMA2_STATE_UNPACK1, |
| LZMA2_STATE_PACK0, |
| LZMA2_STATE_PACK1, |
| LZMA2_STATE_PROP, |
| LZMA2_STATE_DATA, |
| LZMA2_STATE_DATA_CONT, |
| LZMA2_STATE_FINISHED, |
| LZMA2_STATE_ERROR |
| } ELzma2State; |
| |
| static SRes Lzma2Dec_GetOldProps(Byte prop, Byte *props) |
| { |
| UInt32 dicSize; |
| if (prop > 40) |
| return SZ_ERROR_UNSUPPORTED; |
| dicSize = (prop == 40) ? 0xFFFFFFFF : LZMA2_DIC_SIZE_FROM_PROP(prop); |
| props[0] = (Byte)LZMA2_LCLP_MAX; |
| props[1] = (Byte)(dicSize); |
| props[2] = (Byte)(dicSize >> 8); |
| props[3] = (Byte)(dicSize >> 16); |
| props[4] = (Byte)(dicSize >> 24); |
| return SZ_OK; |
| } |
| |
| SRes Lzma2Dec_AllocateProbs(CLzma2Dec *p, Byte prop, ISzAlloc *alloc) |
| { |
| Byte props[LZMA_PROPS_SIZE]; |
| RINOK(Lzma2Dec_GetOldProps(prop, props)); |
| return LzmaDec_AllocateProbs(&p->decoder, props, LZMA_PROPS_SIZE, alloc); |
| } |
| |
| SRes Lzma2Dec_Allocate(CLzma2Dec *p, Byte prop, ISzAlloc *alloc) |
| { |
| Byte props[LZMA_PROPS_SIZE]; |
| RINOK(Lzma2Dec_GetOldProps(prop, props)); |
| return LzmaDec_Allocate(&p->decoder, props, LZMA_PROPS_SIZE, alloc); |
| } |
| |
| void Lzma2Dec_Init(CLzma2Dec *p) |
| { |
| p->state = LZMA2_STATE_CONTROL; |
| p->needInitDic = True; |
| p->needInitState = True; |
| p->needInitProp = True; |
| LzmaDec_Init(&p->decoder); |
| } |
| |
| static ELzma2State Lzma2Dec_UpdateState(CLzma2Dec *p, Byte b) |
| { |
| switch (p->state) |
| { |
| case LZMA2_STATE_CONTROL: |
| p->control = b; |
| PRF(printf("\n %4X ", (unsigned)p->decoder.dicPos)); |
| PRF(printf(" %2X", (unsigned)b)); |
| if (p->control == 0) |
| return LZMA2_STATE_FINISHED; |
| if (LZMA2_IS_UNCOMPRESSED_STATE(p)) |
| { |
| if ((p->control & 0x7F) > 2) |
| return LZMA2_STATE_ERROR; |
| p->unpackSize = 0; |
| } |
| else |
| p->unpackSize = (UInt32)(p->control & 0x1F) << 16; |
| return LZMA2_STATE_UNPACK0; |
| |
| case LZMA2_STATE_UNPACK0: |
| p->unpackSize |= (UInt32)b << 8; |
| return LZMA2_STATE_UNPACK1; |
| |
| case LZMA2_STATE_UNPACK1: |
| p->unpackSize |= (UInt32)b; |
| p->unpackSize++; |
| PRF(printf(" %8u", (unsigned)p->unpackSize)); |
| return (LZMA2_IS_UNCOMPRESSED_STATE(p)) ? LZMA2_STATE_DATA : LZMA2_STATE_PACK0; |
| |
| case LZMA2_STATE_PACK0: |
| p->packSize = (UInt32)b << 8; |
| return LZMA2_STATE_PACK1; |
| |
| case LZMA2_STATE_PACK1: |
| p->packSize |= (UInt32)b; |
| p->packSize++; |
| PRF(printf(" %8u", (unsigned)p->packSize)); |
| return LZMA2_IS_THERE_PROP(LZMA2_GET_LZMA_MODE(p)) ? LZMA2_STATE_PROP: |
| (p->needInitProp ? LZMA2_STATE_ERROR : LZMA2_STATE_DATA); |
| |
| case LZMA2_STATE_PROP: |
| { |
| unsigned lc, lp; |
| if (b >= (9 * 5 * 5)) |
| return LZMA2_STATE_ERROR; |
| lc = b % 9; |
| b /= 9; |
| p->decoder.prop.pb = b / 5; |
| lp = b % 5; |
| if (lc + lp > LZMA2_LCLP_MAX) |
| return LZMA2_STATE_ERROR; |
| p->decoder.prop.lc = lc; |
| p->decoder.prop.lp = lp; |
| p->needInitProp = False; |
| return LZMA2_STATE_DATA; |
| } |
| } |
| return LZMA2_STATE_ERROR; |
| } |
| |
| static void LzmaDec_UpdateWithUncompressed(CLzmaDec *p, const Byte *src, SizeT size) |
| { |
| memcpy(p->dic + p->dicPos, src, size); |
| p->dicPos += size; |
| if (p->checkDicSize == 0 && p->prop.dicSize - p->processedPos <= size) |
| p->checkDicSize = p->prop.dicSize; |
| p->processedPos += (UInt32)size; |
| } |
| |
| void LzmaDec_InitDicAndState(CLzmaDec *p, Bool initDic, Bool initState); |
| |
| SRes Lzma2Dec_DecodeToDic(CLzma2Dec *p, SizeT dicLimit, |
| const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status) |
| { |
| SizeT inSize = *srcLen; |
| *srcLen = 0; |
| *status = LZMA_STATUS_NOT_SPECIFIED; |
| |
| while (p->state != LZMA2_STATE_FINISHED) |
| { |
| SizeT dicPos = p->decoder.dicPos; |
| |
| if (p->state == LZMA2_STATE_ERROR) |
| return SZ_ERROR_DATA; |
| |
| if (dicPos == dicLimit && finishMode == LZMA_FINISH_ANY) |
| { |
| *status = LZMA_STATUS_NOT_FINISHED; |
| return SZ_OK; |
| } |
| |
| if (p->state != LZMA2_STATE_DATA && p->state != LZMA2_STATE_DATA_CONT) |
| { |
| if (*srcLen == inSize) |
| { |
| *status = LZMA_STATUS_NEEDS_MORE_INPUT; |
| return SZ_OK; |
| } |
| (*srcLen)++; |
| p->state = Lzma2Dec_UpdateState(p, *src++); |
| |
| if (dicPos == dicLimit && p->state != LZMA2_STATE_FINISHED) |
| { |
| p->state = LZMA2_STATE_ERROR; |
| return SZ_ERROR_DATA; |
| } |
| continue; |
| } |
| |
| { |
| SizeT destSizeCur = dicLimit - dicPos; |
| SizeT srcSizeCur = inSize - *srcLen; |
| ELzmaFinishMode curFinishMode = LZMA_FINISH_ANY; |
| |
| if (p->unpackSize <= destSizeCur) |
| { |
| destSizeCur = (SizeT)p->unpackSize; |
| curFinishMode = LZMA_FINISH_END; |
| } |
| |
| if (LZMA2_IS_UNCOMPRESSED_STATE(p)) |
| { |
| if (*srcLen == inSize) |
| { |
| *status = LZMA_STATUS_NEEDS_MORE_INPUT; |
| return SZ_OK; |
| } |
| |
| if (p->state == LZMA2_STATE_DATA) |
| { |
| Bool initDic = (p->control == LZMA2_CONTROL_COPY_RESET_DIC); |
| if (initDic) |
| p->needInitProp = p->needInitState = True; |
| else if (p->needInitDic) |
| { |
| p->state = LZMA2_STATE_ERROR; |
| return SZ_ERROR_DATA; |
| } |
| p->needInitDic = False; |
| LzmaDec_InitDicAndState(&p->decoder, initDic, False); |
| } |
| |
| if (srcSizeCur > destSizeCur) |
| srcSizeCur = destSizeCur; |
| |
| if (srcSizeCur == 0) |
| { |
| p->state = LZMA2_STATE_ERROR; |
| return SZ_ERROR_DATA; |
| } |
| |
| LzmaDec_UpdateWithUncompressed(&p->decoder, src, srcSizeCur); |
| |
| src += srcSizeCur; |
| *srcLen += srcSizeCur; |
| p->unpackSize -= (UInt32)srcSizeCur; |
| p->state = (p->unpackSize == 0) ? LZMA2_STATE_CONTROL : LZMA2_STATE_DATA_CONT; |
| } |
| else |
| { |
| SizeT outSizeProcessed; |
| SRes res; |
| |
| if (p->state == LZMA2_STATE_DATA) |
| { |
| unsigned mode = LZMA2_GET_LZMA_MODE(p); |
| Bool initDic = (mode == 3); |
| Bool initState = (mode != 0); |
| if ((!initDic && p->needInitDic) || (!initState && p->needInitState)) |
| { |
| p->state = LZMA2_STATE_ERROR; |
| return SZ_ERROR_DATA; |
| } |
| |
| LzmaDec_InitDicAndState(&p->decoder, initDic, initState); |
| p->needInitDic = False; |
| p->needInitState = False; |
| p->state = LZMA2_STATE_DATA_CONT; |
| } |
| |
| if (srcSizeCur > p->packSize) |
| srcSizeCur = (SizeT)p->packSize; |
| |
| res = LzmaDec_DecodeToDic(&p->decoder, dicPos + destSizeCur, src, &srcSizeCur, curFinishMode, status); |
| |
| src += srcSizeCur; |
| *srcLen += srcSizeCur; |
| p->packSize -= (UInt32)srcSizeCur; |
| |
| outSizeProcessed = p->decoder.dicPos - dicPos; |
| p->unpackSize -= (UInt32)outSizeProcessed; |
| |
| RINOK(res); |
| if (*status == LZMA_STATUS_NEEDS_MORE_INPUT) |
| return res; |
| |
| if (srcSizeCur == 0 && outSizeProcessed == 0) |
| { |
| if (*status != LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK |
| || p->unpackSize != 0 |
| || p->packSize != 0) |
| { |
| p->state = LZMA2_STATE_ERROR; |
| return SZ_ERROR_DATA; |
| } |
| p->state = LZMA2_STATE_CONTROL; |
| } |
| |
| if (*status == LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK) |
| *status = LZMA_STATUS_NOT_FINISHED; |
| } |
| } |
| } |
| |
| *status = LZMA_STATUS_FINISHED_WITH_MARK; |
| return SZ_OK; |
| } |
| |
| SRes Lzma2Dec_DecodeToBuf(CLzma2Dec *p, Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status) |
| { |
| SizeT outSize = *destLen, inSize = *srcLen; |
| *srcLen = *destLen = 0; |
| for (;;) |
| { |
| SizeT srcSizeCur = inSize, outSizeCur, dicPos; |
| ELzmaFinishMode curFinishMode; |
| SRes res; |
| if (p->decoder.dicPos == p->decoder.dicBufSize) |
| p->decoder.dicPos = 0; |
| dicPos = p->decoder.dicPos; |
| if (outSize > p->decoder.dicBufSize - dicPos) |
| { |
| outSizeCur = p->decoder.dicBufSize; |
| curFinishMode = LZMA_FINISH_ANY; |
| } |
| else |
| { |
| outSizeCur = dicPos + outSize; |
| curFinishMode = finishMode; |
| } |
| |
| res = Lzma2Dec_DecodeToDic(p, outSizeCur, src, &srcSizeCur, curFinishMode, status); |
| src += srcSizeCur; |
| inSize -= srcSizeCur; |
| *srcLen += srcSizeCur; |
| outSizeCur = p->decoder.dicPos - dicPos; |
| memcpy(dest, p->decoder.dic + dicPos, outSizeCur); |
| dest += outSizeCur; |
| outSize -= outSizeCur; |
| *destLen += outSizeCur; |
| if (res != 0) |
| return res; |
| if (outSizeCur == 0 || outSize == 0) |
| return SZ_OK; |
| } |
| } |
| |
| SRes Lzma2Decode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen, |
| Byte prop, ELzmaFinishMode finishMode, ELzmaStatus *status, ISzAlloc *alloc) |
| { |
| CLzma2Dec p; |
| SRes res; |
| SizeT outSize = *destLen, inSize = *srcLen; |
| *destLen = *srcLen = 0; |
| *status = LZMA_STATUS_NOT_SPECIFIED; |
| Lzma2Dec_Construct(&p); |
| RINOK(Lzma2Dec_AllocateProbs(&p, prop, alloc)); |
| p.decoder.dic = dest; |
| p.decoder.dicBufSize = outSize; |
| Lzma2Dec_Init(&p); |
| *srcLen = inSize; |
| res = Lzma2Dec_DecodeToDic(&p, outSize, src, srcLen, finishMode, status); |
| *destLen = p.decoder.dicPos; |
| if (res == SZ_OK && *status == LZMA_STATUS_NEEDS_MORE_INPUT) |
| res = SZ_ERROR_INPUT_EOF; |
| Lzma2Dec_FreeProbs(&p, alloc); |
| return res; |
| } |