mirror of
https://github.com/Xevion/easy7zip.git
synced 2025-12-07 03:15:00 -06:00
bfa1f28920
- changed to real Lizard code v1.0 (I used LZ5 v2.0) - add Lizard file handling, so '.liz' files can be used in windows - changed CompressDialog (Lizard has 4 entries in the methods now) - added Lizard icon
221 lines
10 KiB
C
221 lines
10 KiB
C
/*
|
|
[0_MMMM_LLL] - 16-bit offset, 4-bit match length (4-15+), 3-bit literal length (0-7+)
|
|
[1_MMMM_LLL] - last offset, 4-bit match length (0-15+), 3-bit literal length (0-7+)
|
|
flag 31 - 24-bit offset, match length (47+), no literal length
|
|
flag 0-30 - 24-bit offset, 31 match lengths (16-46), no literal length
|
|
*/
|
|
|
|
/*! Lizard_decompress_LIZv1() :
|
|
* This generic decompression function cover all use cases.
|
|
* It shall be instantiated several times, using different sets of directives
|
|
* Note that it is important this generic function is really inlined,
|
|
* in order to remove useless branches during compilation optimization.
|
|
*/
|
|
FORCE_INLINE int Lizard_decompress_LIZv1(
|
|
Lizard_dstream_t* ctx,
|
|
BYTE* const dest,
|
|
int outputSize, /* this value is the max size of Output Buffer. */
|
|
|
|
int partialDecoding, /* full, partial */
|
|
int targetOutputSize, /* only used if partialDecoding==partial */
|
|
int dict, /* noDict, withPrefix64k, usingExtDict */
|
|
const BYTE* const lowPrefix, /* == dest if dict == noDict */
|
|
const BYTE* const dictStart, /* only if dict==usingExtDict */
|
|
const size_t dictSize, /* note : = 0 if noDict */
|
|
int compressionLevel
|
|
)
|
|
{
|
|
/* Local Variables */
|
|
int inputSize = (int)(ctx->flagsEnd - ctx->flagsPtr);
|
|
const BYTE* const blockBase = ctx->flagsPtr;
|
|
const BYTE* const iend = ctx->literalsEnd;
|
|
|
|
BYTE* op = dest;
|
|
BYTE* const oend = op + outputSize;
|
|
BYTE* cpy = NULL;
|
|
BYTE* oexit = op + targetOutputSize;
|
|
const BYTE* const lowLimit = lowPrefix - dictSize;
|
|
const BYTE* const dictEnd = (const BYTE*)dictStart + dictSize;
|
|
|
|
const int checkOffset = (dictSize < (int)(LIZARD_DICT_SIZE));
|
|
|
|
intptr_t last_off = ctx->last_off;
|
|
intptr_t length = 0;
|
|
(void)compressionLevel;
|
|
|
|
/* Special cases */
|
|
if (unlikely(outputSize==0)) return ((inputSize==1) && (*ctx->flagsPtr==0)) ? 0 : -1; /* Empty output buffer */
|
|
|
|
/* Main Loop : decode sequences */
|
|
while (ctx->flagsPtr < ctx->flagsEnd) {
|
|
unsigned token;
|
|
const BYTE* match;
|
|
// intptr_t litLength;
|
|
|
|
if ((partialDecoding) && (op >= oexit)) return (int) (op-dest);
|
|
|
|
/* get literal length */
|
|
token = *ctx->flagsPtr++;
|
|
|
|
if (token >= 32)
|
|
{
|
|
if ((length=(token & MAX_SHORT_LITLEN)) == MAX_SHORT_LITLEN) {
|
|
if (unlikely(ctx->literalsPtr > iend - 1)) { LIZARD_LOG_DECOMPRESS_LIZv1("1"); goto _output_error; }
|
|
length = *ctx->literalsPtr;
|
|
if unlikely(length >= 254) {
|
|
if (length == 254) {
|
|
length = MEM_readLE16(ctx->literalsPtr+1);
|
|
ctx->literalsPtr += 2;
|
|
} else {
|
|
length = MEM_readLE24(ctx->literalsPtr+1);
|
|
ctx->literalsPtr += 3;
|
|
}
|
|
}
|
|
length += MAX_SHORT_LITLEN;
|
|
ctx->literalsPtr++;
|
|
if (unlikely((size_t)(op+length)<(size_t)(op))) { LIZARD_LOG_DECOMPRESS_LIZv1("2"); goto _output_error; } /* overflow detection */
|
|
if (unlikely((size_t)(ctx->literalsPtr+length)<(size_t)(ctx->literalsPtr))) { LIZARD_LOG_DECOMPRESS_LIZv1("3"); goto _output_error; } /* overflow detection */
|
|
}
|
|
|
|
/* copy literals */
|
|
cpy = op + length;
|
|
if (unlikely(cpy > oend - WILDCOPYLENGTH || ctx->literalsPtr > iend - WILDCOPYLENGTH)) { LIZARD_LOG_DECOMPRESS_LIZv1("offset outside buffers\n"); goto _output_error; } /* Error : offset outside buffers */
|
|
#if 1
|
|
Lizard_wildCopy16(op, ctx->literalsPtr, cpy);
|
|
op = cpy;
|
|
ctx->literalsPtr += length;
|
|
#else
|
|
Lizard_copy8(op, ctx->literalsPtr);
|
|
Lizard_copy8(op+8, ctx->literalsPtr+8);
|
|
if (length > 16)
|
|
Lizard_wildCopy16(op + 16, ctx->literalsPtr + 16, cpy);
|
|
op = cpy;
|
|
ctx->literalsPtr += length;
|
|
#endif
|
|
|
|
/* get offset */
|
|
if (unlikely(ctx->offset16Ptr > ctx->offset16End)) { LIZARD_LOG_DECOMPRESS_LIZv1("(ctx->offset16Ptr > ctx->offset16End\n"); goto _output_error; }
|
|
#if 1
|
|
{ /* branchless */
|
|
intptr_t new_off = MEM_readLE16(ctx->offset16Ptr);
|
|
uintptr_t not_repCode = (uintptr_t)(token >> ML_RUN_BITS) - 1;
|
|
last_off ^= not_repCode & (last_off ^ -new_off);
|
|
ctx->offset16Ptr = (BYTE*)((uintptr_t)ctx->offset16Ptr + (not_repCode & 2));
|
|
}
|
|
#else
|
|
if ((token >> ML_RUN_BITS_LIZv1) == 0)
|
|
{
|
|
last_off = -(intptr_t)MEM_readLE16(ctx->offset16Ptr);
|
|
ctx->offset16Ptr += 2;
|
|
}
|
|
#endif
|
|
|
|
/* get matchlength */
|
|
length = (token >> RUN_BITS_LIZv1) & MAX_SHORT_MATCHLEN;
|
|
if (length == MAX_SHORT_MATCHLEN) {
|
|
if (unlikely(ctx->literalsPtr > iend - 1)) { LIZARD_LOG_DECOMPRESS_LIZv1("6"); goto _output_error; }
|
|
length = *ctx->literalsPtr;
|
|
if unlikely(length >= 254) {
|
|
if (length == 254) {
|
|
length = MEM_readLE16(ctx->literalsPtr+1);
|
|
ctx->literalsPtr += 2;
|
|
} else {
|
|
length = MEM_readLE24(ctx->literalsPtr+1);
|
|
ctx->literalsPtr += 3;
|
|
}
|
|
}
|
|
length += MAX_SHORT_MATCHLEN;
|
|
ctx->literalsPtr++;
|
|
if (unlikely((size_t)(op+length)<(size_t)(op))) { LIZARD_LOG_DECOMPRESS_LIZv1("7"); goto _output_error; } /* overflow detection */
|
|
}
|
|
|
|
DECOMPLOG_CODEWORDS_LIZv1("T32+ literal=%u match=%u offset=%d ipos=%d opos=%d\n", (U32)litLength, (U32)length, (int)-last_off, (U32)(ctx->flagsPtr-blockBase), (U32)(op-dest));
|
|
}
|
|
else
|
|
if (token < LIZARD_LAST_LONG_OFF)
|
|
{
|
|
if (unlikely(ctx->offset24Ptr > ctx->offset24End - 3)) { LIZARD_LOG_DECOMPRESS_LIZv1("8"); goto _output_error; }
|
|
length = token + MM_LONGOFF;
|
|
last_off = -(intptr_t)MEM_readLE24(ctx->offset24Ptr);
|
|
ctx->offset24Ptr += 3;
|
|
DECOMPLOG_CODEWORDS_LIZv1("T0-30 literal=%u match=%u offset=%d\n", 0, (U32)length, (int)-last_off);
|
|
}
|
|
else
|
|
{
|
|
if (unlikely(ctx->literalsPtr > iend - 1)) { LIZARD_LOG_DECOMPRESS_LIZv1("9"); goto _output_error; }
|
|
length = *ctx->literalsPtr;
|
|
if unlikely(length >= 254) {
|
|
if (length == 254) {
|
|
length = MEM_readLE16(ctx->literalsPtr+1);
|
|
ctx->literalsPtr += 2;
|
|
} else {
|
|
length = MEM_readLE24(ctx->literalsPtr+1);
|
|
ctx->literalsPtr += 3;
|
|
}
|
|
}
|
|
ctx->literalsPtr++;
|
|
length += LIZARD_LAST_LONG_OFF + MM_LONGOFF;
|
|
|
|
if (unlikely(ctx->offset24Ptr > ctx->offset24End - 3)) { LIZARD_LOG_DECOMPRESS_LIZv1("10"); goto _output_error; }
|
|
last_off = -(intptr_t)MEM_readLE24(ctx->offset24Ptr);
|
|
ctx->offset24Ptr += 3;
|
|
}
|
|
|
|
|
|
match = op + last_off;
|
|
if ((checkOffset) && ((unlikely((uintptr_t)(-last_off) > (uintptr_t)op) || (match < lowLimit)))) { LIZARD_LOG_DECOMPRESS_LIZv1("lowPrefix[%p]-dictSize[%d]=lowLimit[%p] match[%p]=op[%p]-last_off[%d]\n", lowPrefix, (int)dictSize, lowLimit, match, op, (int)last_off); goto _output_error; } /* Error : offset outside buffers */
|
|
|
|
/* check external dictionary */
|
|
if ((dict==usingExtDict) && (match < lowPrefix)) {
|
|
if (unlikely(op + length > oend - WILDCOPYLENGTH)) { LIZARD_LOG_DECOMPRESS_LIZv1("12"); goto _output_error; } /* doesn't respect parsing restriction */
|
|
|
|
if (length <= (intptr_t)(lowPrefix - match)) {
|
|
/* match can be copied as a single segment from external dictionary */
|
|
memmove(op, dictEnd - (lowPrefix-match), length);
|
|
op += length;
|
|
} else {
|
|
/* match encompass external dictionary and current block */
|
|
size_t const copySize = (size_t)(lowPrefix-match);
|
|
size_t const restSize = length - copySize;
|
|
memcpy(op, dictEnd - copySize, copySize);
|
|
op += copySize;
|
|
if (restSize > (size_t)(op-lowPrefix)) { /* overlap copy */
|
|
BYTE* const endOfMatch = op + restSize;
|
|
const BYTE* copyFrom = lowPrefix;
|
|
while (op < endOfMatch) *op++ = *copyFrom++;
|
|
} else {
|
|
memcpy(op, lowPrefix, restSize);
|
|
op += restSize;
|
|
} }
|
|
continue;
|
|
}
|
|
|
|
/* copy match within block */
|
|
cpy = op + length;
|
|
if (unlikely(cpy > oend - WILDCOPYLENGTH)) { LIZARD_LOG_DECOMPRESS_LIZv1("13match=%p lowLimit=%p\n", match, lowLimit); goto _output_error; } /* Error : offset outside buffers */
|
|
Lizard_copy8(op, match);
|
|
Lizard_copy8(op+8, match+8);
|
|
if (length > 16)
|
|
Lizard_wildCopy16(op + 16, match + 16, cpy);
|
|
op = cpy;
|
|
}
|
|
|
|
/* last literals */
|
|
length = ctx->literalsEnd - ctx->literalsPtr;
|
|
cpy = op + length;
|
|
if ((ctx->literalsPtr+length != iend) || (cpy > oend)) { LIZARD_LOG_DECOMPRESS_LIZv1("14"); goto _output_error; } /* Error : input must be consumed */
|
|
memcpy(op, ctx->literalsPtr, length);
|
|
ctx->literalsPtr += length;
|
|
op += length;
|
|
|
|
/* end of decoding */
|
|
ctx->last_off = last_off;
|
|
return (int) (op-dest); /* Nb of output bytes decoded */
|
|
|
|
/* Overflow error detected */
|
|
_output_error:
|
|
LIZARD_LOG_DECOMPRESS_LIZv1("_output_error=%d ctx->flagsPtr=%p blockBase=%p\n", (int) (-(ctx->flagsPtr-blockBase))-1, ctx->flagsPtr, blockBase);
|
|
LIZARD_LOG_DECOMPRESS_LIZv1("cpy=%p oend=%p ctx->literalsPtr+length[%d]=%p iend=%p\n", cpy, oend, (int)length, ctx->literalsPtr+length, iend);
|
|
return (int) (-(ctx->flagsPtr-blockBase))-1;
|
|
}
|