mirror of
https://github.com/ZDoom/qzdoom-gpl.git
synced 2024-11-24 04:41:53 +00:00
378 lines
10 KiB
C
378 lines
10 KiB
C
/* 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;
|
|
}
|