/* Lzma2Dec.c -- LZMA2 Decoder | |
2010-12-15 : 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 ", p->decoder.dicPos)); | |
PRF(printf(" %2X", 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(" %8d", 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(" %8d", 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: | |
{ | |
int 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++); | |
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) | |
return SZ_ERROR_DATA; | |
p->needInitDic = False; | |
LzmaDec_InitDicAndState(&p->decoder, initDic, False); | |
} | |
if (srcSizeCur > destSizeCur) | |
srcSizeCur = destSizeCur; | |
if (srcSizeCur == 0) | |
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) | |
{ | |
int mode = LZMA2_GET_LZMA_MODE(p); | |
Bool initDic = (mode == 3); | |
Bool initState = (mode > 0); | |
if ((!initDic && p->needInitDic) || (!initState && p->needInitState)) | |
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) | |
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; | |
} |