mirror of
https://github.com/chibicitiberiu/rainmeter-studio.git
synced 2024-02-24 04:33:31 +00:00
New installer: Comment out unnecessary parts of the lzma files to reduce size
This commit is contained in:
Birunthan Mohanathas
parent
e35a65eeaa
commit
5689604f36
@ -7,11 +7,15 @@
|
|||||||
|
|
||||||
#include "7z.h"
|
#include "7z.h"
|
||||||
|
|
||||||
|
#ifdef _7ZIP_BCJ2_SUPPPORT
|
||||||
#include "Bcj2.h"
|
#include "Bcj2.h"
|
||||||
#include "Bra.h"
|
#include "Bra.h"
|
||||||
|
#endif
|
||||||
#include "CpuArch.h"
|
#include "CpuArch.h"
|
||||||
#include "LzmaDec.h"
|
#include "LzmaDec.h"
|
||||||
|
#ifdef _7ZIP_LZMA2_SUPPPORT
|
||||||
#include "Lzma2Dec.h"
|
#include "Lzma2Dec.h"
|
||||||
|
#endif
|
||||||
#ifdef _7ZIP_PPMD_SUPPPORT
|
#ifdef _7ZIP_PPMD_SUPPPORT
|
||||||
#include "Ppmd7.h"
|
#include "Ppmd7.h"
|
||||||
#endif
|
#endif
|
||||||
@ -249,7 +253,9 @@ static Bool IS_MAIN_METHOD(UInt32 m)
|
|||||||
{
|
{
|
||||||
case k_Copy:
|
case k_Copy:
|
||||||
case k_LZMA:
|
case k_LZMA:
|
||||||
|
#ifdef _7ZIP_LZMA2_SUPPPORT
|
||||||
case k_LZMA2:
|
case k_LZMA2:
|
||||||
|
#endif
|
||||||
#ifdef _7ZIP_PPMD_SUPPPORT
|
#ifdef _7ZIP_PPMD_SUPPPORT
|
||||||
case k_PPMD:
|
case k_PPMD:
|
||||||
#endif
|
#endif
|
||||||
@ -416,6 +422,7 @@ static SRes SzFolder_Decode2(const CSzFolder *folder, const UInt64 *packSizes,
|
|||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
#ifdef _7ZIP_BCJ2_SUPPPORT
|
||||||
else if (coder->MethodID == k_BCJ2)
|
else if (coder->MethodID == k_BCJ2)
|
||||||
{
|
{
|
||||||
UInt64 offset = GetSum(packSizes, 1);
|
UInt64 offset = GetSum(packSizes, 1);
|
||||||
@ -441,12 +448,14 @@ static SRes SzFolder_Decode2(const CSzFolder *folder, const UInt64 *packSizes,
|
|||||||
outBuffer, outSize);
|
outBuffer, outSize);
|
||||||
RINOK(res)
|
RINOK(res)
|
||||||
}
|
}
|
||||||
|
#endif
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
if (ci != 1)
|
if (ci != 1)
|
||||||
return SZ_ERROR_UNSUPPORTED;
|
return SZ_ERROR_UNSUPPORTED;
|
||||||
switch(coder->MethodID)
|
switch(coder->MethodID)
|
||||||
{
|
{
|
||||||
|
#ifdef _7ZIP_BCJ2_SUPPPORT
|
||||||
case k_BCJ:
|
case k_BCJ:
|
||||||
{
|
{
|
||||||
UInt32 state;
|
UInt32 state;
|
||||||
@ -455,6 +464,7 @@ static SRes SzFolder_Decode2(const CSzFolder *folder, const UInt64 *packSizes,
|
|||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
CASE_BRA_CONV(ARM)
|
CASE_BRA_CONV(ARM)
|
||||||
|
#endif
|
||||||
default:
|
default:
|
||||||
return SZ_ERROR_UNSUPPORTED;
|
return SZ_ERROR_UNSUPPORTED;
|
||||||
}
|
}
|
||||||
|
|||||||
@ -9,6 +9,8 @@
|
|||||||
|
|
||||||
#include "Types.h"
|
#include "Types.h"
|
||||||
|
|
||||||
|
EXTERN_C_BEGIN
|
||||||
|
|
||||||
typedef struct
|
typedef struct
|
||||||
{
|
{
|
||||||
ILookInStream s;
|
ILookInStream s;
|
||||||
@ -19,4 +21,6 @@ typedef struct
|
|||||||
|
|
||||||
void MemInStream_Init(CMemInStream *p, const void *begin, size_t length);
|
void MemInStream_Init(CMemInStream *p, const void *begin, size_t length);
|
||||||
|
|
||||||
|
EXTERN_C_END
|
||||||
|
|
||||||
#endif
|
#endif
|
||||||
|
|||||||
@ -1,132 +0,0 @@
|
|||||||
/* Bcj2.c -- Converter for x86 code (BCJ2)
|
|
||||||
2008-10-04 : Igor Pavlov : Public domain */
|
|
||||||
|
|
||||||
#include "Bcj2.h"
|
|
||||||
|
|
||||||
#ifdef _LZMA_PROB32
|
|
||||||
#define CProb UInt32
|
|
||||||
#else
|
|
||||||
#define CProb UInt16
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#define IsJcc(b0, b1) ((b0) == 0x0F && ((b1) & 0xF0) == 0x80)
|
|
||||||
#define IsJ(b0, b1) ((b1 & 0xFE) == 0xE8 || IsJcc(b0, b1))
|
|
||||||
|
|
||||||
#define kNumTopBits 24
|
|
||||||
#define kTopValue ((UInt32)1 << kNumTopBits)
|
|
||||||
|
|
||||||
#define kNumBitModelTotalBits 11
|
|
||||||
#define kBitModelTotal (1 << kNumBitModelTotalBits)
|
|
||||||
#define kNumMoveBits 5
|
|
||||||
|
|
||||||
#define RC_READ_BYTE (*buffer++)
|
|
||||||
#define RC_TEST { if (buffer == bufferLim) return SZ_ERROR_DATA; }
|
|
||||||
#define RC_INIT2 code = 0; range = 0xFFFFFFFF; \
|
|
||||||
{ int i; for (i = 0; i < 5; i++) { RC_TEST; code = (code << 8) | RC_READ_BYTE; }}
|
|
||||||
|
|
||||||
#define NORMALIZE if (range < kTopValue) { RC_TEST; range <<= 8; code = (code << 8) | RC_READ_BYTE; }
|
|
||||||
|
|
||||||
#define IF_BIT_0(p) ttt = *(p); bound = (range >> kNumBitModelTotalBits) * ttt; if (code < bound)
|
|
||||||
#define UPDATE_0(p) range = bound; *(p) = (CProb)(ttt + ((kBitModelTotal - ttt) >> kNumMoveBits)); NORMALIZE;
|
|
||||||
#define UPDATE_1(p) range -= bound; code -= bound; *(p) = (CProb)(ttt - (ttt >> kNumMoveBits)); NORMALIZE;
|
|
||||||
|
|
||||||
int Bcj2_Decode(
|
|
||||||
const Byte *buf0, SizeT size0,
|
|
||||||
const Byte *buf1, SizeT size1,
|
|
||||||
const Byte *buf2, SizeT size2,
|
|
||||||
const Byte *buf3, SizeT size3,
|
|
||||||
Byte *outBuf, SizeT outSize)
|
|
||||||
{
|
|
||||||
CProb p[256 + 2];
|
|
||||||
SizeT inPos = 0, outPos = 0;
|
|
||||||
|
|
||||||
const Byte *buffer, *bufferLim;
|
|
||||||
UInt32 range, code;
|
|
||||||
Byte prevByte = 0;
|
|
||||||
|
|
||||||
unsigned int i;
|
|
||||||
for (i = 0; i < sizeof(p) / sizeof(p[0]); i++)
|
|
||||||
p[i] = kBitModelTotal >> 1;
|
|
||||||
|
|
||||||
buffer = buf3;
|
|
||||||
bufferLim = buffer + size3;
|
|
||||||
RC_INIT2
|
|
||||||
|
|
||||||
if (outSize == 0)
|
|
||||||
return SZ_OK;
|
|
||||||
|
|
||||||
for (;;)
|
|
||||||
{
|
|
||||||
Byte b;
|
|
||||||
CProb *prob;
|
|
||||||
UInt32 bound;
|
|
||||||
UInt32 ttt;
|
|
||||||
|
|
||||||
SizeT limit = size0 - inPos;
|
|
||||||
if (outSize - outPos < limit)
|
|
||||||
limit = outSize - outPos;
|
|
||||||
while (limit != 0)
|
|
||||||
{
|
|
||||||
Byte b = buf0[inPos];
|
|
||||||
outBuf[outPos++] = b;
|
|
||||||
if (IsJ(prevByte, b))
|
|
||||||
break;
|
|
||||||
inPos++;
|
|
||||||
prevByte = b;
|
|
||||||
limit--;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (limit == 0 || outPos == outSize)
|
|
||||||
break;
|
|
||||||
|
|
||||||
b = buf0[inPos++];
|
|
||||||
|
|
||||||
if (b == 0xE8)
|
|
||||||
prob = p + prevByte;
|
|
||||||
else if (b == 0xE9)
|
|
||||||
prob = p + 256;
|
|
||||||
else
|
|
||||||
prob = p + 257;
|
|
||||||
|
|
||||||
IF_BIT_0(prob)
|
|
||||||
{
|
|
||||||
UPDATE_0(prob)
|
|
||||||
prevByte = b;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
UInt32 dest;
|
|
||||||
const Byte *v;
|
|
||||||
UPDATE_1(prob)
|
|
||||||
if (b == 0xE8)
|
|
||||||
{
|
|
||||||
v = buf1;
|
|
||||||
if (size1 < 4)
|
|
||||||
return SZ_ERROR_DATA;
|
|
||||||
buf1 += 4;
|
|
||||||
size1 -= 4;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
v = buf2;
|
|
||||||
if (size2 < 4)
|
|
||||||
return SZ_ERROR_DATA;
|
|
||||||
buf2 += 4;
|
|
||||||
size2 -= 4;
|
|
||||||
}
|
|
||||||
dest = (((UInt32)v[0] << 24) | ((UInt32)v[1] << 16) |
|
|
||||||
((UInt32)v[2] << 8) | ((UInt32)v[3])) - ((UInt32)outPos + 4);
|
|
||||||
outBuf[outPos++] = (Byte)dest;
|
|
||||||
if (outPos == outSize)
|
|
||||||
break;
|
|
||||||
outBuf[outPos++] = (Byte)(dest >> 8);
|
|
||||||
if (outPos == outSize)
|
|
||||||
break;
|
|
||||||
outBuf[outPos++] = (Byte)(dest >> 16);
|
|
||||||
if (outPos == outSize)
|
|
||||||
break;
|
|
||||||
outBuf[outPos++] = prevByte = (Byte)(dest >> 24);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return (outPos == outSize) ? SZ_OK : SZ_ERROR_DATA;
|
|
||||||
}
|
|
||||||
@ -1,38 +0,0 @@
|
|||||||
/* Bcj2.h -- Converter for x86 code (BCJ2)
|
|
||||||
2009-02-07 : Igor Pavlov : Public domain */
|
|
||||||
|
|
||||||
#ifndef __BCJ2_H
|
|
||||||
#define __BCJ2_H
|
|
||||||
|
|
||||||
#include "Types.h"
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
extern "C" {
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/*
|
|
||||||
Conditions:
|
|
||||||
outSize <= FullOutputSize,
|
|
||||||
where FullOutputSize is full size of output stream of x86_2 filter.
|
|
||||||
|
|
||||||
If buf0 overlaps outBuf, there are two required conditions:
|
|
||||||
1) (buf0 >= outBuf)
|
|
||||||
2) (buf0 + size0 >= outBuf + FullOutputSize).
|
|
||||||
|
|
||||||
Returns:
|
|
||||||
SZ_OK
|
|
||||||
SZ_ERROR_DATA - Data error
|
|
||||||
*/
|
|
||||||
|
|
||||||
int Bcj2_Decode(
|
|
||||||
const Byte *buf0, SizeT size0,
|
|
||||||
const Byte *buf1, SizeT size1,
|
|
||||||
const Byte *buf2, SizeT size2,
|
|
||||||
const Byte *buf3, SizeT size3,
|
|
||||||
Byte *outBuf, SizeT outSize);
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif
|
|
||||||
@ -1,133 +0,0 @@
|
|||||||
/* Bra.c -- Converters for RISC code
|
|
||||||
2010-04-16 : Igor Pavlov : Public domain */
|
|
||||||
|
|
||||||
#include "Bra.h"
|
|
||||||
|
|
||||||
SizeT ARM_Convert(Byte *data, SizeT size, UInt32 ip, int encoding)
|
|
||||||
{
|
|
||||||
SizeT i;
|
|
||||||
if (size < 4)
|
|
||||||
return 0;
|
|
||||||
size -= 4;
|
|
||||||
ip += 8;
|
|
||||||
for (i = 0; i <= size; i += 4)
|
|
||||||
{
|
|
||||||
if (data[i + 3] == 0xEB)
|
|
||||||
{
|
|
||||||
UInt32 dest;
|
|
||||||
UInt32 src = ((UInt32)data[i + 2] << 16) | ((UInt32)data[i + 1] << 8) | (data[i + 0]);
|
|
||||||
src <<= 2;
|
|
||||||
if (encoding)
|
|
||||||
dest = ip + (UInt32)i + src;
|
|
||||||
else
|
|
||||||
dest = src - (ip + (UInt32)i);
|
|
||||||
dest >>= 2;
|
|
||||||
data[i + 2] = (Byte)(dest >> 16);
|
|
||||||
data[i + 1] = (Byte)(dest >> 8);
|
|
||||||
data[i + 0] = (Byte)dest;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return i;
|
|
||||||
}
|
|
||||||
|
|
||||||
SizeT ARMT_Convert(Byte *data, SizeT size, UInt32 ip, int encoding)
|
|
||||||
{
|
|
||||||
SizeT i;
|
|
||||||
if (size < 4)
|
|
||||||
return 0;
|
|
||||||
size -= 4;
|
|
||||||
ip += 4;
|
|
||||||
for (i = 0; i <= size; i += 2)
|
|
||||||
{
|
|
||||||
if ((data[i + 1] & 0xF8) == 0xF0 &&
|
|
||||||
(data[i + 3] & 0xF8) == 0xF8)
|
|
||||||
{
|
|
||||||
UInt32 dest;
|
|
||||||
UInt32 src =
|
|
||||||
(((UInt32)data[i + 1] & 0x7) << 19) |
|
|
||||||
((UInt32)data[i + 0] << 11) |
|
|
||||||
(((UInt32)data[i + 3] & 0x7) << 8) |
|
|
||||||
(data[i + 2]);
|
|
||||||
|
|
||||||
src <<= 1;
|
|
||||||
if (encoding)
|
|
||||||
dest = ip + (UInt32)i + src;
|
|
||||||
else
|
|
||||||
dest = src - (ip + (UInt32)i);
|
|
||||||
dest >>= 1;
|
|
||||||
|
|
||||||
data[i + 1] = (Byte)(0xF0 | ((dest >> 19) & 0x7));
|
|
||||||
data[i + 0] = (Byte)(dest >> 11);
|
|
||||||
data[i + 3] = (Byte)(0xF8 | ((dest >> 8) & 0x7));
|
|
||||||
data[i + 2] = (Byte)dest;
|
|
||||||
i += 2;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return i;
|
|
||||||
}
|
|
||||||
|
|
||||||
SizeT PPC_Convert(Byte *data, SizeT size, UInt32 ip, int encoding)
|
|
||||||
{
|
|
||||||
SizeT i;
|
|
||||||
if (size < 4)
|
|
||||||
return 0;
|
|
||||||
size -= 4;
|
|
||||||
for (i = 0; i <= size; i += 4)
|
|
||||||
{
|
|
||||||
if ((data[i] >> 2) == 0x12 && (data[i + 3] & 3) == 1)
|
|
||||||
{
|
|
||||||
UInt32 src = ((UInt32)(data[i + 0] & 3) << 24) |
|
|
||||||
((UInt32)data[i + 1] << 16) |
|
|
||||||
((UInt32)data[i + 2] << 8) |
|
|
||||||
((UInt32)data[i + 3] & (~3));
|
|
||||||
|
|
||||||
UInt32 dest;
|
|
||||||
if (encoding)
|
|
||||||
dest = ip + (UInt32)i + src;
|
|
||||||
else
|
|
||||||
dest = src - (ip + (UInt32)i);
|
|
||||||
data[i + 0] = (Byte)(0x48 | ((dest >> 24) & 0x3));
|
|
||||||
data[i + 1] = (Byte)(dest >> 16);
|
|
||||||
data[i + 2] = (Byte)(dest >> 8);
|
|
||||||
data[i + 3] &= 0x3;
|
|
||||||
data[i + 3] |= dest;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return i;
|
|
||||||
}
|
|
||||||
|
|
||||||
SizeT SPARC_Convert(Byte *data, SizeT size, UInt32 ip, int encoding)
|
|
||||||
{
|
|
||||||
UInt32 i;
|
|
||||||
if (size < 4)
|
|
||||||
return 0;
|
|
||||||
size -= 4;
|
|
||||||
for (i = 0; i <= size; i += 4)
|
|
||||||
{
|
|
||||||
if ((data[i] == 0x40 && (data[i + 1] & 0xC0) == 0x00) ||
|
|
||||||
(data[i] == 0x7F && (data[i + 1] & 0xC0) == 0xC0))
|
|
||||||
{
|
|
||||||
UInt32 src =
|
|
||||||
((UInt32)data[i + 0] << 24) |
|
|
||||||
((UInt32)data[i + 1] << 16) |
|
|
||||||
((UInt32)data[i + 2] << 8) |
|
|
||||||
((UInt32)data[i + 3]);
|
|
||||||
UInt32 dest;
|
|
||||||
|
|
||||||
src <<= 2;
|
|
||||||
if (encoding)
|
|
||||||
dest = ip + i + src;
|
|
||||||
else
|
|
||||||
dest = src - (ip + i);
|
|
||||||
dest >>= 2;
|
|
||||||
|
|
||||||
dest = (((0 - ((dest >> 22) & 1)) << 22) & 0x3FFFFFFF) | (dest & 0x3FFFFF) | 0x40000000;
|
|
||||||
|
|
||||||
data[i + 0] = (Byte)(dest >> 24);
|
|
||||||
data[i + 1] = (Byte)(dest >> 16);
|
|
||||||
data[i + 2] = (Byte)(dest >> 8);
|
|
||||||
data[i + 3] = (Byte)dest;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return i;
|
|
||||||
}
|
|
||||||
@ -1,68 +0,0 @@
|
|||||||
/* Bra.h -- Branch converters for executables
|
|
||||||
2009-02-07 : Igor Pavlov : Public domain */
|
|
||||||
|
|
||||||
#ifndef __BRA_H
|
|
||||||
#define __BRA_H
|
|
||||||
|
|
||||||
#include "Types.h"
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
extern "C" {
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/*
|
|
||||||
These functions convert relative addresses to absolute addresses
|
|
||||||
in CALL instructions to increase the compression ratio.
|
|
||||||
|
|
||||||
In:
|
|
||||||
data - data buffer
|
|
||||||
size - size of data
|
|
||||||
ip - current virtual Instruction Pinter (IP) value
|
|
||||||
state - state variable for x86 converter
|
|
||||||
encoding - 0 (for decoding), 1 (for encoding)
|
|
||||||
|
|
||||||
Out:
|
|
||||||
state - state variable for x86 converter
|
|
||||||
|
|
||||||
Returns:
|
|
||||||
The number of processed bytes. If you call these functions with multiple calls,
|
|
||||||
you must start next call with first byte after block of processed bytes.
|
|
||||||
|
|
||||||
Type Endian Alignment LookAhead
|
|
||||||
|
|
||||||
x86 little 1 4
|
|
||||||
ARMT little 2 2
|
|
||||||
ARM little 4 0
|
|
||||||
PPC big 4 0
|
|
||||||
SPARC big 4 0
|
|
||||||
IA64 little 16 0
|
|
||||||
|
|
||||||
size must be >= Alignment + LookAhead, if it's not last block.
|
|
||||||
If (size < Alignment + LookAhead), converter returns 0.
|
|
||||||
|
|
||||||
Example:
|
|
||||||
|
|
||||||
UInt32 ip = 0;
|
|
||||||
for ()
|
|
||||||
{
|
|
||||||
; size must be >= Alignment + LookAhead, if it's not last block
|
|
||||||
SizeT processed = Convert(data, size, ip, 1);
|
|
||||||
data += processed;
|
|
||||||
size -= processed;
|
|
||||||
ip += processed;
|
|
||||||
}
|
|
||||||
*/
|
|
||||||
|
|
||||||
#define x86_Convert_Init(state) { state = 0; }
|
|
||||||
SizeT x86_Convert(Byte *data, SizeT size, UInt32 ip, UInt32 *state, int encoding);
|
|
||||||
SizeT ARM_Convert(Byte *data, SizeT size, UInt32 ip, int encoding);
|
|
||||||
SizeT ARMT_Convert(Byte *data, SizeT size, UInt32 ip, int encoding);
|
|
||||||
SizeT PPC_Convert(Byte *data, SizeT size, UInt32 ip, int encoding);
|
|
||||||
SizeT SPARC_Convert(Byte *data, SizeT size, UInt32 ip, int encoding);
|
|
||||||
SizeT IA64_Convert(Byte *data, SizeT size, UInt32 ip, int encoding);
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif
|
|
||||||
@ -1,85 +0,0 @@
|
|||||||
/* Bra86.c -- Converter for x86 code (BCJ)
|
|
||||||
2008-10-04 : Igor Pavlov : Public domain */
|
|
||||||
|
|
||||||
#include "Bra.h"
|
|
||||||
|
|
||||||
#define Test86MSByte(b) ((b) == 0 || (b) == 0xFF)
|
|
||||||
|
|
||||||
const Byte kMaskToAllowedStatus[8] = {1, 1, 1, 0, 1, 0, 0, 0};
|
|
||||||
const Byte kMaskToBitNumber[8] = {0, 1, 2, 2, 3, 3, 3, 3};
|
|
||||||
|
|
||||||
SizeT x86_Convert(Byte *data, SizeT size, UInt32 ip, UInt32 *state, int encoding)
|
|
||||||
{
|
|
||||||
SizeT bufferPos = 0, prevPosT;
|
|
||||||
UInt32 prevMask = *state & 0x7;
|
|
||||||
if (size < 5)
|
|
||||||
return 0;
|
|
||||||
ip += 5;
|
|
||||||
prevPosT = (SizeT)0 - 1;
|
|
||||||
|
|
||||||
for (;;)
|
|
||||||
{
|
|
||||||
Byte *p = data + bufferPos;
|
|
||||||
Byte *limit = data + size - 4;
|
|
||||||
for (; p < limit; p++)
|
|
||||||
if ((*p & 0xFE) == 0xE8)
|
|
||||||
break;
|
|
||||||
bufferPos = (SizeT)(p - data);
|
|
||||||
if (p >= limit)
|
|
||||||
break;
|
|
||||||
prevPosT = bufferPos - prevPosT;
|
|
||||||
if (prevPosT > 3)
|
|
||||||
prevMask = 0;
|
|
||||||
else
|
|
||||||
{
|
|
||||||
prevMask = (prevMask << ((int)prevPosT - 1)) & 0x7;
|
|
||||||
if (prevMask != 0)
|
|
||||||
{
|
|
||||||
Byte b = p[4 - kMaskToBitNumber[prevMask]];
|
|
||||||
if (!kMaskToAllowedStatus[prevMask] || Test86MSByte(b))
|
|
||||||
{
|
|
||||||
prevPosT = bufferPos;
|
|
||||||
prevMask = ((prevMask << 1) & 0x7) | 1;
|
|
||||||
bufferPos++;
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
prevPosT = bufferPos;
|
|
||||||
|
|
||||||
if (Test86MSByte(p[4]))
|
|
||||||
{
|
|
||||||
UInt32 src = ((UInt32)p[4] << 24) | ((UInt32)p[3] << 16) | ((UInt32)p[2] << 8) | ((UInt32)p[1]);
|
|
||||||
UInt32 dest;
|
|
||||||
for (;;)
|
|
||||||
{
|
|
||||||
Byte b;
|
|
||||||
int index;
|
|
||||||
if (encoding)
|
|
||||||
dest = (ip + (UInt32)bufferPos) + src;
|
|
||||||
else
|
|
||||||
dest = src - (ip + (UInt32)bufferPos);
|
|
||||||
if (prevMask == 0)
|
|
||||||
break;
|
|
||||||
index = kMaskToBitNumber[prevMask] * 8;
|
|
||||||
b = (Byte)(dest >> (24 - index));
|
|
||||||
if (!Test86MSByte(b))
|
|
||||||
break;
|
|
||||||
src = dest ^ ((1 << (32 - index)) - 1);
|
|
||||||
}
|
|
||||||
p[4] = (Byte)(~(((dest >> 24) & 1) - 1));
|
|
||||||
p[3] = (Byte)(dest >> 16);
|
|
||||||
p[2] = (Byte)(dest >> 8);
|
|
||||||
p[1] = (Byte)dest;
|
|
||||||
bufferPos += 5;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
prevMask = ((prevMask << 1) & 0x7) | 1;
|
|
||||||
bufferPos++;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
prevPosT = bufferPos - prevPosT;
|
|
||||||
*state = ((prevPosT > 3) ? 0 : ((prevMask << ((int)prevPosT - 1)) & 0x7));
|
|
||||||
return bufferPos;
|
|
||||||
}
|
|
||||||
@ -1,356 +0,0 @@
|
|||||||
/* Lzma2Dec.c -- LZMA2 Decoder
|
|
||||||
2009-05-03 : Igor Pavlov : Public domain */
|
|
||||||
|
|
||||||
/* #define SHOW_DEBUG_INFO */
|
|
||||||
|
|
||||||
#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 decoder;
|
|
||||||
SRes res;
|
|
||||||
SizeT outSize = *destLen, inSize = *srcLen;
|
|
||||||
Byte props[LZMA_PROPS_SIZE];
|
|
||||||
|
|
||||||
Lzma2Dec_Construct(&decoder);
|
|
||||||
|
|
||||||
*destLen = *srcLen = 0;
|
|
||||||
*status = LZMA_STATUS_NOT_SPECIFIED;
|
|
||||||
decoder.decoder.dic = dest;
|
|
||||||
decoder.decoder.dicBufSize = outSize;
|
|
||||||
|
|
||||||
RINOK(Lzma2Dec_GetOldProps(prop, props));
|
|
||||||
RINOK(LzmaDec_AllocateProbs(&decoder.decoder, props, LZMA_PROPS_SIZE, alloc));
|
|
||||||
|
|
||||||
*srcLen = inSize;
|
|
||||||
res = Lzma2Dec_DecodeToDic(&decoder, outSize, src, srcLen, finishMode, status);
|
|
||||||
*destLen = decoder.decoder.dicPos;
|
|
||||||
if (res == SZ_OK && *status == LZMA_STATUS_NEEDS_MORE_INPUT)
|
|
||||||
res = SZ_ERROR_INPUT_EOF;
|
|
||||||
|
|
||||||
LzmaDec_FreeProbs(&decoder.decoder, alloc);
|
|
||||||
return res;
|
|
||||||
}
|
|
||||||
@ -1,84 +0,0 @@
|
|||||||
/* Lzma2Dec.h -- LZMA2 Decoder
|
|
||||||
2009-05-03 : Igor Pavlov : Public domain */
|
|
||||||
|
|
||||||
#ifndef __LZMA2_DEC_H
|
|
||||||
#define __LZMA2_DEC_H
|
|
||||||
|
|
||||||
#include "LzmaDec.h"
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
extern "C" {
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/* ---------- State Interface ---------- */
|
|
||||||
|
|
||||||
typedef struct
|
|
||||||
{
|
|
||||||
CLzmaDec decoder;
|
|
||||||
UInt32 packSize;
|
|
||||||
UInt32 unpackSize;
|
|
||||||
int state;
|
|
||||||
Byte control;
|
|
||||||
Bool needInitDic;
|
|
||||||
Bool needInitState;
|
|
||||||
Bool needInitProp;
|
|
||||||
} CLzma2Dec;
|
|
||||||
|
|
||||||
#define Lzma2Dec_Construct(p) LzmaDec_Construct(&(p)->decoder)
|
|
||||||
#define Lzma2Dec_FreeProbs(p, alloc) LzmaDec_FreeProbs(&(p)->decoder, alloc);
|
|
||||||
#define Lzma2Dec_Free(p, alloc) LzmaDec_Free(&(p)->decoder, alloc);
|
|
||||||
|
|
||||||
SRes Lzma2Dec_AllocateProbs(CLzma2Dec *p, Byte prop, ISzAlloc *alloc);
|
|
||||||
SRes Lzma2Dec_Allocate(CLzma2Dec *p, Byte prop, ISzAlloc *alloc);
|
|
||||||
void Lzma2Dec_Init(CLzma2Dec *p);
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
finishMode:
|
|
||||||
It has meaning only if the decoding reaches output limit (*destLen or dicLimit).
|
|
||||||
LZMA_FINISH_ANY - use smallest number of input bytes
|
|
||||||
LZMA_FINISH_END - read EndOfStream marker after decoding
|
|
||||||
|
|
||||||
Returns:
|
|
||||||
SZ_OK
|
|
||||||
status:
|
|
||||||
LZMA_STATUS_FINISHED_WITH_MARK
|
|
||||||
LZMA_STATUS_NOT_FINISHED
|
|
||||||
LZMA_STATUS_NEEDS_MORE_INPUT
|
|
||||||
SZ_ERROR_DATA - Data error
|
|
||||||
*/
|
|
||||||
|
|
||||||
SRes Lzma2Dec_DecodeToDic(CLzma2Dec *p, SizeT dicLimit,
|
|
||||||
const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status);
|
|
||||||
|
|
||||||
SRes Lzma2Dec_DecodeToBuf(CLzma2Dec *p, Byte *dest, SizeT *destLen,
|
|
||||||
const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status);
|
|
||||||
|
|
||||||
|
|
||||||
/* ---------- One Call Interface ---------- */
|
|
||||||
|
|
||||||
/*
|
|
||||||
finishMode:
|
|
||||||
It has meaning only if the decoding reaches output limit (*destLen).
|
|
||||||
LZMA_FINISH_ANY - use smallest number of input bytes
|
|
||||||
LZMA_FINISH_END - read EndOfStream marker after decoding
|
|
||||||
|
|
||||||
Returns:
|
|
||||||
SZ_OK
|
|
||||||
status:
|
|
||||||
LZMA_STATUS_FINISHED_WITH_MARK
|
|
||||||
LZMA_STATUS_NOT_FINISHED
|
|
||||||
SZ_ERROR_DATA - Data error
|
|
||||||
SZ_ERROR_MEM - Memory allocation error
|
|
||||||
SZ_ERROR_UNSUPPORTED - Unsupported properties
|
|
||||||
SZ_ERROR_INPUT_EOF - It needs more bytes in input buffer (src).
|
|
||||||
*/
|
|
||||||
|
|
||||||
SRes Lzma2Decode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,
|
|
||||||
Byte prop, ELzmaFinishMode finishMode, ELzmaStatus *status, ISzAlloc *alloc);
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif
|
|
||||||
@ -1,81 +0,0 @@
|
|||||||
/* Ppmd.h -- PPMD codec common code
|
|
||||||
2010-03-12 : Igor Pavlov : Public domain
|
|
||||||
This code is based on PPMd var.H (2001): Dmitry Shkarin : Public domain */
|
|
||||||
|
|
||||||
#ifndef __PPMD_H
|
|
||||||
#define __PPMD_H
|
|
||||||
|
|
||||||
#include "Types.h"
|
|
||||||
#include "CpuArch.h"
|
|
||||||
|
|
||||||
EXTERN_C_BEGIN
|
|
||||||
|
|
||||||
#ifdef MY_CPU_32BIT
|
|
||||||
#define PPMD_32BIT
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#define PPMD_INT_BITS 7
|
|
||||||
#define PPMD_PERIOD_BITS 7
|
|
||||||
#define PPMD_BIN_SCALE (1 << (PPMD_INT_BITS + PPMD_PERIOD_BITS))
|
|
||||||
|
|
||||||
#define PPMD_GET_MEAN_SPEC(summ, shift, round) (((summ) + (1 << ((shift) - (round)))) >> (shift))
|
|
||||||
#define PPMD_GET_MEAN(summ) PPMD_GET_MEAN_SPEC((summ), PPMD_PERIOD_BITS, 2)
|
|
||||||
#define PPMD_UPDATE_PROB_0(prob) ((prob) + (1 << PPMD_INT_BITS) - PPMD_GET_MEAN(prob))
|
|
||||||
#define PPMD_UPDATE_PROB_1(prob) ((prob) - PPMD_GET_MEAN(prob))
|
|
||||||
|
|
||||||
#define PPMD_N1 4
|
|
||||||
#define PPMD_N2 4
|
|
||||||
#define PPMD_N3 4
|
|
||||||
#define PPMD_N4 ((128 + 3 - 1 * PPMD_N1 - 2 * PPMD_N2 - 3 * PPMD_N3) / 4)
|
|
||||||
#define PPMD_NUM_INDEXES (PPMD_N1 + PPMD_N2 + PPMD_N3 + PPMD_N4)
|
|
||||||
|
|
||||||
/* SEE-contexts for PPM-contexts with masked symbols */
|
|
||||||
typedef struct
|
|
||||||
{
|
|
||||||
UInt16 Summ; /* Freq */
|
|
||||||
Byte Shift; /* Speed of Freq change; low Shift is for fast change */
|
|
||||||
Byte Count; /* Count to next change of Shift */
|
|
||||||
} CPpmd_See;
|
|
||||||
|
|
||||||
#define Ppmd_See_Update(p) if ((p)->Shift < PPMD_PERIOD_BITS && --(p)->Count == 0) \
|
|
||||||
{ (p)->Summ <<= 1; (p)->Count = (Byte)(3 << (p)->Shift++); }
|
|
||||||
|
|
||||||
typedef struct
|
|
||||||
{
|
|
||||||
Byte Symbol;
|
|
||||||
Byte Freq;
|
|
||||||
UInt16 SuccessorLow;
|
|
||||||
UInt16 SuccessorHigh;
|
|
||||||
} CPpmd_State;
|
|
||||||
|
|
||||||
typedef
|
|
||||||
#ifdef PPMD_32BIT
|
|
||||||
CPpmd_State *
|
|
||||||
#else
|
|
||||||
UInt32
|
|
||||||
#endif
|
|
||||||
CPpmd_State_Ref;
|
|
||||||
|
|
||||||
typedef
|
|
||||||
#ifdef PPMD_32BIT
|
|
||||||
void *
|
|
||||||
#else
|
|
||||||
UInt32
|
|
||||||
#endif
|
|
||||||
CPpmd_Void_Ref;
|
|
||||||
|
|
||||||
typedef
|
|
||||||
#ifdef PPMD_32BIT
|
|
||||||
Byte *
|
|
||||||
#else
|
|
||||||
UInt32
|
|
||||||
#endif
|
|
||||||
CPpmd_Byte_Ref;
|
|
||||||
|
|
||||||
#define PPMD_SetAllBitsIn256Bytes(p) \
|
|
||||||
{ unsigned i; for (i = 0; i < 256 / sizeof(p[0]); i += 8) { \
|
|
||||||
p[i+7] = p[i+6] = p[i+5] = p[i+4] = p[i+3] = p[i+2] = p[i+1] = p[i+0] = ~(size_t)0; }}
|
|
||||||
|
|
||||||
EXTERN_C_END
|
|
||||||
|
|
||||||
#endif
|
|
||||||
@ -1,708 +0,0 @@
|
|||||||
/* Ppmd7.c -- PPMdH codec
|
|
||||||
2010-03-12 : Igor Pavlov : Public domain
|
|
||||||
This code is based on PPMd var.H (2001): Dmitry Shkarin : Public domain */
|
|
||||||
|
|
||||||
#include <memory.h>
|
|
||||||
|
|
||||||
#include "Ppmd7.h"
|
|
||||||
|
|
||||||
const Byte PPMD7_kExpEscape[16] = { 25, 14, 9, 7, 5, 5, 4, 4, 4, 3, 3, 3, 2, 2, 2, 2 };
|
|
||||||
static const UInt16 kInitBinEsc[] = { 0x3CDD, 0x1F3F, 0x59BF, 0x48F3, 0x64A1, 0x5ABC, 0x6632, 0x6051};
|
|
||||||
|
|
||||||
#define MAX_FREQ 124
|
|
||||||
#define UNIT_SIZE 12
|
|
||||||
|
|
||||||
#define U2B(nu) ((UInt32)(nu) * UNIT_SIZE)
|
|
||||||
#define U2I(nu) (p->Units2Indx[(nu) - 1])
|
|
||||||
#define I2U(indx) (p->Indx2Units[indx])
|
|
||||||
|
|
||||||
#ifdef PPMD_32BIT
|
|
||||||
#define REF(ptr) (ptr)
|
|
||||||
#else
|
|
||||||
#define REF(ptr) ((UInt32)((Byte *)(ptr) - (p)->Base))
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#define STATS_REF(ptr) ((CPpmd_State_Ref)REF(ptr))
|
|
||||||
|
|
||||||
#define CTX(ref) ((CPpmd7_Context *)Ppmd7_GetContext(p, ref))
|
|
||||||
#define STATS(ctx) Ppmd7_GetStats(p, ctx)
|
|
||||||
#define ONE_STATE(ctx) Ppmd7Context_OneState(ctx)
|
|
||||||
#define SUFFIX(ctx) CTX((ctx)->Suffix)
|
|
||||||
|
|
||||||
typedef CPpmd7_Context * CTX_PTR;
|
|
||||||
|
|
||||||
struct CPpmd7_Node_;
|
|
||||||
|
|
||||||
typedef
|
|
||||||
#ifdef PPMD_32BIT
|
|
||||||
struct CPpmd7_Node_ *
|
|
||||||
#else
|
|
||||||
UInt32
|
|
||||||
#endif
|
|
||||||
CPpmd7_Node_Ref;
|
|
||||||
|
|
||||||
typedef struct CPpmd7_Node_
|
|
||||||
{
|
|
||||||
UInt16 Stamp; /* must be at offset 0 as CPpmd7_Context::NumStats. Stamp=0 means free */
|
|
||||||
UInt16 NU;
|
|
||||||
CPpmd7_Node_Ref Next; /* must be at offset >= 4 */
|
|
||||||
CPpmd7_Node_Ref Prev;
|
|
||||||
} CPpmd7_Node;
|
|
||||||
|
|
||||||
#ifdef PPMD_32BIT
|
|
||||||
#define NODE(ptr) (ptr)
|
|
||||||
#else
|
|
||||||
#define NODE(offs) ((CPpmd7_Node *)(p->Base + (offs)))
|
|
||||||
#endif
|
|
||||||
|
|
||||||
void Ppmd7_Construct(CPpmd7 *p)
|
|
||||||
{
|
|
||||||
unsigned i, k, m;
|
|
||||||
|
|
||||||
p->Base = 0;
|
|
||||||
|
|
||||||
for (i = 0, k = 0; i < PPMD_NUM_INDEXES; i++)
|
|
||||||
{
|
|
||||||
unsigned step = (i >= 12 ? 4 : (i >> 2) + 1);
|
|
||||||
do { p->Units2Indx[k++] = (Byte)i; } while(--step);
|
|
||||||
p->Indx2Units[i] = (Byte)k;
|
|
||||||
}
|
|
||||||
|
|
||||||
p->NS2BSIndx[0] = (0 << 1);
|
|
||||||
p->NS2BSIndx[1] = (1 << 1);
|
|
||||||
memset(p->NS2BSIndx + 2, (2 << 1), 9);
|
|
||||||
memset(p->NS2BSIndx + 11, (3 << 1), 256 - 11);
|
|
||||||
|
|
||||||
for (i = 0; i < 3; i++)
|
|
||||||
p->NS2Indx[i] = (Byte)i;
|
|
||||||
for (m = i, k = 1; i < 256; i++)
|
|
||||||
{
|
|
||||||
p->NS2Indx[i] = (Byte)m;
|
|
||||||
if (--k == 0)
|
|
||||||
k = (++m) - 2;
|
|
||||||
}
|
|
||||||
|
|
||||||
memset(p->HB2Flag, 0, 0x40);
|
|
||||||
memset(p->HB2Flag + 0x40, 8, 0x100 - 0x40);
|
|
||||||
}
|
|
||||||
|
|
||||||
void Ppmd7_Free(CPpmd7 *p, ISzAlloc *alloc)
|
|
||||||
{
|
|
||||||
alloc->Free(alloc, p->Base);
|
|
||||||
p->Size = 0;
|
|
||||||
p->Base = 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
Bool Ppmd7_Alloc(CPpmd7 *p, UInt32 size, ISzAlloc *alloc)
|
|
||||||
{
|
|
||||||
if (p->Base == 0 || p->Size != size)
|
|
||||||
{
|
|
||||||
Ppmd7_Free(p, alloc);
|
|
||||||
p->AlignOffset =
|
|
||||||
#ifdef PPMD_32BIT
|
|
||||||
(4 - size) & 3;
|
|
||||||
#else
|
|
||||||
4 - (size & 3);
|
|
||||||
#endif
|
|
||||||
if ((p->Base = (Byte *)alloc->Alloc(alloc, p->AlignOffset + size
|
|
||||||
#ifndef PPMD_32BIT
|
|
||||||
+ UNIT_SIZE
|
|
||||||
#endif
|
|
||||||
)) == 0)
|
|
||||||
return False;
|
|
||||||
p->Size = size;
|
|
||||||
}
|
|
||||||
return True;
|
|
||||||
}
|
|
||||||
|
|
||||||
static void InsertNode(CPpmd7 *p, void *node, unsigned indx)
|
|
||||||
{
|
|
||||||
*((CPpmd_Void_Ref *)node) = p->FreeList[indx];
|
|
||||||
p->FreeList[indx] = REF(node);
|
|
||||||
}
|
|
||||||
|
|
||||||
static void *RemoveNode(CPpmd7 *p, unsigned indx)
|
|
||||||
{
|
|
||||||
CPpmd_Void_Ref *node = (CPpmd_Void_Ref *)Ppmd7_GetPtr(p, p->FreeList[indx]);
|
|
||||||
p->FreeList[indx] = *node;
|
|
||||||
return node;
|
|
||||||
}
|
|
||||||
|
|
||||||
static void SplitBlock(CPpmd7 *p, void *ptr, unsigned oldIndx, unsigned newIndx)
|
|
||||||
{
|
|
||||||
unsigned i, nu = I2U(oldIndx) - I2U(newIndx);
|
|
||||||
ptr = (Byte *)ptr + U2B(I2U(newIndx));
|
|
||||||
if (I2U(i = U2I(nu)) != nu)
|
|
||||||
{
|
|
||||||
unsigned k = I2U(--i);
|
|
||||||
InsertNode(p, ((Byte *)ptr) + U2B(k), nu - k - 1);
|
|
||||||
}
|
|
||||||
InsertNode(p, ptr, i);
|
|
||||||
}
|
|
||||||
|
|
||||||
static void GlueFreeBlocks(CPpmd7 *p)
|
|
||||||
{
|
|
||||||
#ifdef PPMD_32BIT
|
|
||||||
CPpmd7_Node headItem;
|
|
||||||
CPpmd7_Node_Ref head = &headItem;
|
|
||||||
#else
|
|
||||||
CPpmd7_Node_Ref head = p->AlignOffset + p->Size;
|
|
||||||
#endif
|
|
||||||
|
|
||||||
CPpmd7_Node_Ref n = head;
|
|
||||||
unsigned i;
|
|
||||||
|
|
||||||
p->GlueCount = 255;
|
|
||||||
|
|
||||||
/* create doubly-linked list of free blocks */
|
|
||||||
for (i = 0; i < PPMD_NUM_INDEXES; i++)
|
|
||||||
{
|
|
||||||
UInt16 nu = I2U(i);
|
|
||||||
CPpmd7_Node_Ref next = (CPpmd7_Node_Ref)p->FreeList[i];
|
|
||||||
p->FreeList[i] = 0;
|
|
||||||
while (next != 0)
|
|
||||||
{
|
|
||||||
CPpmd7_Node *node = NODE(next);
|
|
||||||
node->Next = n;
|
|
||||||
n = NODE(n)->Prev = next;
|
|
||||||
next = *(const CPpmd7_Node_Ref *)node;
|
|
||||||
node->Stamp = 0;
|
|
||||||
node->NU = (UInt16)nu;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
NODE(head)->Stamp = 1;
|
|
||||||
NODE(head)->Next = n;
|
|
||||||
NODE(n)->Prev = head;
|
|
||||||
if (p->LoUnit != p->HiUnit)
|
|
||||||
((CPpmd7_Node *)p->LoUnit)->Stamp = 1;
|
|
||||||
|
|
||||||
/* Glue free blocks */
|
|
||||||
while (n != head)
|
|
||||||
{
|
|
||||||
CPpmd7_Node *node = NODE(n);
|
|
||||||
UInt32 nu = (UInt32)node->NU;
|
|
||||||
for (;;)
|
|
||||||
{
|
|
||||||
CPpmd7_Node *node2 = NODE(n) + nu;
|
|
||||||
nu += node2->NU;
|
|
||||||
if (node2->Stamp != 0 || nu >= 0x10000)
|
|
||||||
break;
|
|
||||||
NODE(node2->Prev)->Next = node2->Next;
|
|
||||||
NODE(node2->Next)->Prev = node2->Prev;
|
|
||||||
node->NU = (UInt16)nu;
|
|
||||||
}
|
|
||||||
n = node->Next;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* Fill lists of free blocks */
|
|
||||||
for (n = NODE(head)->Next; n != head;)
|
|
||||||
{
|
|
||||||
CPpmd7_Node *node = NODE(n);
|
|
||||||
unsigned nu;
|
|
||||||
CPpmd7_Node_Ref next = node->Next;
|
|
||||||
for (nu = node->NU; nu > 128; nu -= 128, node += 128)
|
|
||||||
InsertNode(p, node, PPMD_NUM_INDEXES - 1);
|
|
||||||
if (I2U(i = U2I(nu)) != nu)
|
|
||||||
{
|
|
||||||
unsigned k = I2U(--i);
|
|
||||||
InsertNode(p, node + k, nu - k - 1);
|
|
||||||
}
|
|
||||||
InsertNode(p, node, i);
|
|
||||||
n = next;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
static void *AllocUnitsRare(CPpmd7 *p, unsigned indx)
|
|
||||||
{
|
|
||||||
unsigned i;
|
|
||||||
void *retVal;
|
|
||||||
if (p->GlueCount == 0)
|
|
||||||
{
|
|
||||||
GlueFreeBlocks(p);
|
|
||||||
if (p->FreeList[indx] != 0)
|
|
||||||
return RemoveNode(p, indx);
|
|
||||||
}
|
|
||||||
i = indx;
|
|
||||||
do
|
|
||||||
{
|
|
||||||
if (++i == PPMD_NUM_INDEXES)
|
|
||||||
{
|
|
||||||
UInt32 numBytes = U2B(I2U(indx));
|
|
||||||
p->GlueCount--;
|
|
||||||
return ((UInt32)(p->UnitsStart - p->Text) > numBytes) ? (p->UnitsStart -= numBytes) : (NULL);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
while (p->FreeList[i] == 0);
|
|
||||||
retVal = RemoveNode(p, i);
|
|
||||||
SplitBlock(p, retVal, i, indx);
|
|
||||||
return retVal;
|
|
||||||
}
|
|
||||||
|
|
||||||
static void *AllocUnits(CPpmd7 *p, unsigned indx)
|
|
||||||
{
|
|
||||||
UInt32 numBytes;
|
|
||||||
if (p->FreeList[indx] != 0)
|
|
||||||
return RemoveNode(p, indx);
|
|
||||||
numBytes = U2B(I2U(indx));
|
|
||||||
if (numBytes <= (UInt32)(p->HiUnit - p->LoUnit))
|
|
||||||
{
|
|
||||||
void *retVal = p->LoUnit;
|
|
||||||
p->LoUnit += numBytes;
|
|
||||||
return retVal;
|
|
||||||
}
|
|
||||||
return AllocUnitsRare(p, indx);
|
|
||||||
}
|
|
||||||
|
|
||||||
#define MyMem12Cpy(dest, src, num) \
|
|
||||||
{ UInt32 *d = (UInt32 *)dest; const UInt32 *s = (const UInt32 *)src; UInt32 n = num; \
|
|
||||||
do { d[0] = s[0]; d[1] = s[1]; d[2] = s[2]; s += 3; d += 3; } while(--n); }
|
|
||||||
|
|
||||||
static void *ShrinkUnits(CPpmd7 *p, void *oldPtr, unsigned oldNU, unsigned newNU)
|
|
||||||
{
|
|
||||||
unsigned i0 = U2I(oldNU);
|
|
||||||
unsigned i1 = U2I(newNU);
|
|
||||||
if (i0 == i1)
|
|
||||||
return oldPtr;
|
|
||||||
if (p->FreeList[i1] != 0)
|
|
||||||
{
|
|
||||||
void *ptr = RemoveNode(p, i1);
|
|
||||||
MyMem12Cpy(ptr, oldPtr, newNU);
|
|
||||||
InsertNode(p, oldPtr, i0);
|
|
||||||
return ptr;
|
|
||||||
}
|
|
||||||
SplitBlock(p, oldPtr, i0, i1);
|
|
||||||
return oldPtr;
|
|
||||||
}
|
|
||||||
|
|
||||||
#define SUCCESSOR(p) ((CPpmd_Void_Ref)((p)->SuccessorLow | ((UInt32)(p)->SuccessorHigh << 16)))
|
|
||||||
|
|
||||||
static void SetSuccessor(CPpmd_State *p, CPpmd_Void_Ref v)
|
|
||||||
{
|
|
||||||
(p)->SuccessorLow = (UInt16)((UInt32)(v) & 0xFFFF);
|
|
||||||
(p)->SuccessorHigh = (UInt16)(((UInt32)(v) >> 16) & 0xFFFF);
|
|
||||||
}
|
|
||||||
|
|
||||||
static void RestartModel(CPpmd7 *p)
|
|
||||||
{
|
|
||||||
unsigned i, k, m;
|
|
||||||
|
|
||||||
memset(p->FreeList, 0, sizeof(p->FreeList));
|
|
||||||
p->Text = p->Base + p->AlignOffset;
|
|
||||||
p->HiUnit = p->Text + p->Size;
|
|
||||||
p->LoUnit = p->UnitsStart = p->HiUnit - p->Size / 8 / UNIT_SIZE * 7 * UNIT_SIZE;
|
|
||||||
p->GlueCount = 0;
|
|
||||||
|
|
||||||
p->OrderFall = p->MaxOrder;
|
|
||||||
p->RunLength = p->InitRL = -(Int32)((p->MaxOrder < 12) ? p->MaxOrder : 12) - 1;
|
|
||||||
p->PrevSuccess = 0;
|
|
||||||
|
|
||||||
p->MinContext = p->MaxContext = (CTX_PTR)(p->HiUnit -= UNIT_SIZE); /* AllocContext(p); */
|
|
||||||
p->MinContext->Suffix = 0;
|
|
||||||
p->MinContext->NumStats = 256;
|
|
||||||
p->MinContext->SummFreq = 256 + 1;
|
|
||||||
p->FoundState = (CPpmd_State *)p->LoUnit; /* AllocUnits(p, PPMD_NUM_INDEXES - 1); */
|
|
||||||
p->LoUnit += U2B(256 / 2);
|
|
||||||
p->MinContext->Stats = REF(p->FoundState);
|
|
||||||
for (i = 0; i < 256; i++)
|
|
||||||
{
|
|
||||||
CPpmd_State *s = &p->FoundState[i];
|
|
||||||
s->Symbol = (Byte)i;
|
|
||||||
s->Freq = 1;
|
|
||||||
SetSuccessor(s, 0);
|
|
||||||
}
|
|
||||||
|
|
||||||
for (i = 0; i < 128; i++)
|
|
||||||
for (k = 0; k < 8; k++)
|
|
||||||
{
|
|
||||||
UInt16 *dest = p->BinSumm[i] + k;
|
|
||||||
UInt16 val = (UInt16)(PPMD_BIN_SCALE - kInitBinEsc[k] / (i + 2));
|
|
||||||
for (m = 0; m < 64; m += 8)
|
|
||||||
dest[m] = val;
|
|
||||||
}
|
|
||||||
|
|
||||||
for (i = 0; i < 25; i++)
|
|
||||||
for (k = 0; k < 16; k++)
|
|
||||||
{
|
|
||||||
CPpmd_See *s = &p->See[i][k];
|
|
||||||
s->Summ = (UInt16)((5 * i + 10) << (s->Shift = PPMD_PERIOD_BITS - 4));
|
|
||||||
s->Count = 4;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void Ppmd7_Init(CPpmd7 *p, unsigned maxOrder)
|
|
||||||
{
|
|
||||||
p->MaxOrder = maxOrder;
|
|
||||||
RestartModel(p);
|
|
||||||
p->DummySee.Shift = PPMD_PERIOD_BITS;
|
|
||||||
p->DummySee.Summ = 0; /* unused */
|
|
||||||
p->DummySee.Count = 64; /* unused */
|
|
||||||
}
|
|
||||||
|
|
||||||
static CTX_PTR CreateSuccessors(CPpmd7 *p, Bool skip)
|
|
||||||
{
|
|
||||||
CPpmd_State upState;
|
|
||||||
CTX_PTR c = p->MinContext;
|
|
||||||
CPpmd_Byte_Ref upBranch = (CPpmd_Byte_Ref)SUCCESSOR(p->FoundState);
|
|
||||||
CPpmd_State *ps[PPMD7_MAX_ORDER];
|
|
||||||
unsigned numPs = 0;
|
|
||||||
|
|
||||||
if (!skip)
|
|
||||||
ps[numPs++] = p->FoundState;
|
|
||||||
|
|
||||||
while (c->Suffix)
|
|
||||||
{
|
|
||||||
CPpmd_Void_Ref successor;
|
|
||||||
CPpmd_State *s;
|
|
||||||
c = SUFFIX(c);
|
|
||||||
if (c->NumStats != 1)
|
|
||||||
{
|
|
||||||
for (s = STATS(c); s->Symbol != p->FoundState->Symbol; s++);
|
|
||||||
}
|
|
||||||
else
|
|
||||||
s = ONE_STATE(c);
|
|
||||||
successor = SUCCESSOR(s);
|
|
||||||
if (successor != upBranch)
|
|
||||||
{
|
|
||||||
c = CTX(successor);
|
|
||||||
if (numPs == 0)
|
|
||||||
return c;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
ps[numPs++] = s;
|
|
||||||
}
|
|
||||||
|
|
||||||
upState.Symbol = *(const Byte *)Ppmd7_GetPtr(p, upBranch);
|
|
||||||
SetSuccessor(&upState, upBranch + 1);
|
|
||||||
|
|
||||||
if (c->NumStats == 1)
|
|
||||||
upState.Freq = ONE_STATE(c)->Freq;
|
|
||||||
else
|
|
||||||
{
|
|
||||||
UInt32 cf, s0;
|
|
||||||
CPpmd_State *s;
|
|
||||||
for (s = STATS(c); s->Symbol != upState.Symbol; s++);
|
|
||||||
cf = s->Freq - 1;
|
|
||||||
s0 = c->SummFreq - c->NumStats - cf;
|
|
||||||
upState.Freq = (Byte)(1 + ((2 * cf <= s0) ? (5 * cf > s0) : ((2 * cf + 3 * s0 - 1) / (2 * s0))));
|
|
||||||
}
|
|
||||||
|
|
||||||
do
|
|
||||||
{
|
|
||||||
/* Create Child */
|
|
||||||
CTX_PTR c1; /* = AllocContext(p); */
|
|
||||||
if (p->HiUnit != p->LoUnit)
|
|
||||||
c1 = (CTX_PTR)(p->HiUnit -= UNIT_SIZE);
|
|
||||||
else if (p->FreeList[0] != 0)
|
|
||||||
c1 = (CTX_PTR)RemoveNode(p, 0);
|
|
||||||
else
|
|
||||||
{
|
|
||||||
c1 = (CTX_PTR)AllocUnitsRare(p, 0);
|
|
||||||
if (!c1)
|
|
||||||
return NULL;
|
|
||||||
}
|
|
||||||
c1->NumStats = 1;
|
|
||||||
*ONE_STATE(c1) = upState;
|
|
||||||
c1->Suffix = REF(c);
|
|
||||||
SetSuccessor(ps[--numPs], REF(c1));
|
|
||||||
c = c1;
|
|
||||||
}
|
|
||||||
while (numPs != 0);
|
|
||||||
|
|
||||||
return c;
|
|
||||||
}
|
|
||||||
|
|
||||||
static void SwapStates(CPpmd_State *t1, CPpmd_State *t2)
|
|
||||||
{
|
|
||||||
CPpmd_State tmp = *t1;
|
|
||||||
*t1 = *t2;
|
|
||||||
*t2 = tmp;
|
|
||||||
}
|
|
||||||
|
|
||||||
static void UpdateModel(CPpmd7 *p)
|
|
||||||
{
|
|
||||||
CPpmd_Void_Ref successor, fSuccessor = SUCCESSOR(p->FoundState);
|
|
||||||
CTX_PTR c;
|
|
||||||
unsigned s0, ns;
|
|
||||||
|
|
||||||
if (p->FoundState->Freq < MAX_FREQ / 4 && p->MinContext->Suffix != 0)
|
|
||||||
{
|
|
||||||
c = SUFFIX(p->MinContext);
|
|
||||||
|
|
||||||
if (c->NumStats == 1)
|
|
||||||
{
|
|
||||||
CPpmd_State *s = ONE_STATE(c);
|
|
||||||
if (s->Freq < 32)
|
|
||||||
s->Freq++;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
CPpmd_State *s = STATS(c);
|
|
||||||
if (s->Symbol != p->FoundState->Symbol)
|
|
||||||
{
|
|
||||||
do { s++; } while (s->Symbol != p->FoundState->Symbol);
|
|
||||||
if (s[0].Freq >= s[-1].Freq)
|
|
||||||
{
|
|
||||||
SwapStates(&s[0], &s[-1]);
|
|
||||||
s--;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if (s->Freq < MAX_FREQ - 9)
|
|
||||||
{
|
|
||||||
s->Freq += 2;
|
|
||||||
c->SummFreq += 2;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
if (p->OrderFall == 0)
|
|
||||||
{
|
|
||||||
p->MinContext = p->MaxContext = CreateSuccessors(p, True);
|
|
||||||
if (p->MinContext == 0)
|
|
||||||
{
|
|
||||||
RestartModel(p);
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
SetSuccessor(p->FoundState, REF(p->MinContext));
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
*p->Text++ = p->FoundState->Symbol;
|
|
||||||
successor = REF(p->Text);
|
|
||||||
if (p->Text >= p->UnitsStart)
|
|
||||||
{
|
|
||||||
RestartModel(p);
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (fSuccessor)
|
|
||||||
{
|
|
||||||
if (fSuccessor <= successor)
|
|
||||||
{
|
|
||||||
CTX_PTR cs = CreateSuccessors(p, False);
|
|
||||||
if (cs == NULL)
|
|
||||||
{
|
|
||||||
RestartModel(p);
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
fSuccessor = REF(cs);
|
|
||||||
}
|
|
||||||
if (--p->OrderFall == 0)
|
|
||||||
{
|
|
||||||
successor = fSuccessor;
|
|
||||||
p->Text -= (p->MaxContext != p->MinContext);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
SetSuccessor(p->FoundState, successor);
|
|
||||||
fSuccessor = REF(p->MinContext);
|
|
||||||
}
|
|
||||||
|
|
||||||
s0 = p->MinContext->SummFreq - (ns = p->MinContext->NumStats) - (p->FoundState->Freq - 1);
|
|
||||||
|
|
||||||
for (c = p->MaxContext; c != p->MinContext; c = SUFFIX(c))
|
|
||||||
{
|
|
||||||
unsigned ns1;
|
|
||||||
UInt32 cf, sf;
|
|
||||||
if ((ns1 = c->NumStats) != 1)
|
|
||||||
{
|
|
||||||
if ((ns1 & 1) == 0)
|
|
||||||
{
|
|
||||||
/* Expand for one UNIT */
|
|
||||||
unsigned oldNU = ns1 >> 1;
|
|
||||||
unsigned i = U2I(oldNU);
|
|
||||||
if (i != U2I(oldNU + 1))
|
|
||||||
{
|
|
||||||
void *ptr = AllocUnits(p, i + 1);
|
|
||||||
void *oldPtr;
|
|
||||||
if (!ptr)
|
|
||||||
{
|
|
||||||
RestartModel(p);
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
oldPtr = STATS(c);
|
|
||||||
MyMem12Cpy(ptr, oldPtr, oldNU);
|
|
||||||
InsertNode(p, oldPtr, i);
|
|
||||||
c->Stats = STATS_REF(ptr);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
c->SummFreq = (UInt16)(c->SummFreq + (2 * ns1 < ns) + 2 * ((4 * ns1 <= ns) & (c->SummFreq <= 8 * ns1)));
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
CPpmd_State *s = (CPpmd_State*)AllocUnits(p, 0);
|
|
||||||
if (!s)
|
|
||||||
{
|
|
||||||
RestartModel(p);
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
*s = *ONE_STATE(c);
|
|
||||||
c->Stats = REF(s);
|
|
||||||
if (s->Freq < MAX_FREQ / 4 - 1)
|
|
||||||
s->Freq <<= 1;
|
|
||||||
else
|
|
||||||
s->Freq = MAX_FREQ - 4;
|
|
||||||
c->SummFreq = (UInt16)(s->Freq + p->InitEsc + (ns > 3));
|
|
||||||
}
|
|
||||||
cf = 2 * (UInt32)p->FoundState->Freq * (c->SummFreq + 6);
|
|
||||||
sf = (UInt32)s0 + c->SummFreq;
|
|
||||||
if (cf < 6 * sf)
|
|
||||||
{
|
|
||||||
cf = 1 + (cf > sf) + (cf >= 4 * sf);
|
|
||||||
c->SummFreq += 3;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
cf = 4 + (cf >= 9 * sf) + (cf >= 12 * sf) + (cf >= 15 * sf);
|
|
||||||
c->SummFreq = (UInt16)(c->SummFreq + cf);
|
|
||||||
}
|
|
||||||
{
|
|
||||||
CPpmd_State *s = STATS(c) + ns1;
|
|
||||||
SetSuccessor(s, successor);
|
|
||||||
s->Symbol = p->FoundState->Symbol;
|
|
||||||
s->Freq = (Byte)cf;
|
|
||||||
c->NumStats = (UInt16)(ns1 + 1);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
p->MaxContext = p->MinContext = CTX(fSuccessor);
|
|
||||||
}
|
|
||||||
|
|
||||||
static void Rescale(CPpmd7 *p)
|
|
||||||
{
|
|
||||||
unsigned i, adder, sumFreq, escFreq;
|
|
||||||
CPpmd_State *stats = STATS(p->MinContext);
|
|
||||||
CPpmd_State *s = p->FoundState;
|
|
||||||
{
|
|
||||||
CPpmd_State tmp = *s;
|
|
||||||
for (; s != stats; s--)
|
|
||||||
s[0] = s[-1];
|
|
||||||
*s = tmp;
|
|
||||||
}
|
|
||||||
escFreq = p->MinContext->SummFreq - s->Freq;
|
|
||||||
s->Freq += 4;
|
|
||||||
adder = (p->OrderFall != 0);
|
|
||||||
s->Freq = (Byte)((s->Freq + adder) >> 1);
|
|
||||||
sumFreq = s->Freq;
|
|
||||||
|
|
||||||
i = p->MinContext->NumStats - 1;
|
|
||||||
do
|
|
||||||
{
|
|
||||||
escFreq -= (++s)->Freq;
|
|
||||||
s->Freq = (Byte)((s->Freq + adder) >> 1);
|
|
||||||
sumFreq += s->Freq;
|
|
||||||
if (s[0].Freq > s[-1].Freq)
|
|
||||||
{
|
|
||||||
CPpmd_State *s1 = s;
|
|
||||||
CPpmd_State tmp = *s1;
|
|
||||||
do
|
|
||||||
s1[0] = s1[-1];
|
|
||||||
while (--s1 != stats && tmp.Freq > s1[-1].Freq);
|
|
||||||
*s1 = tmp;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
while (--i);
|
|
||||||
|
|
||||||
if (s->Freq == 0)
|
|
||||||
{
|
|
||||||
unsigned numStats = p->MinContext->NumStats;
|
|
||||||
unsigned n0, n1;
|
|
||||||
do { i++; } while ((--s)->Freq == 0);
|
|
||||||
escFreq += i;
|
|
||||||
p->MinContext->NumStats = (UInt16)(p->MinContext->NumStats - i);
|
|
||||||
if (p->MinContext->NumStats == 1)
|
|
||||||
{
|
|
||||||
CPpmd_State tmp = *stats;
|
|
||||||
do
|
|
||||||
{
|
|
||||||
tmp.Freq = (Byte)(tmp.Freq - (tmp.Freq >> 1));
|
|
||||||
escFreq >>= 1;
|
|
||||||
}
|
|
||||||
while (escFreq > 1);
|
|
||||||
InsertNode(p, stats, U2I(((numStats + 1) >> 1)));
|
|
||||||
*(p->FoundState = ONE_STATE(p->MinContext)) = tmp;
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
n0 = (numStats + 1) >> 1;
|
|
||||||
n1 = (p->MinContext->NumStats + 1) >> 1;
|
|
||||||
if (n0 != n1)
|
|
||||||
p->MinContext->Stats = STATS_REF(ShrinkUnits(p, stats, n0, n1));
|
|
||||||
}
|
|
||||||
p->MinContext->SummFreq = (UInt16)(sumFreq + escFreq - (escFreq >> 1));
|
|
||||||
p->FoundState = STATS(p->MinContext);
|
|
||||||
}
|
|
||||||
|
|
||||||
CPpmd_See *Ppmd7_MakeEscFreq(CPpmd7 *p, unsigned numMasked, UInt32 *escFreq)
|
|
||||||
{
|
|
||||||
CPpmd_See *see;
|
|
||||||
unsigned nonMasked = p->MinContext->NumStats - numMasked;
|
|
||||||
if (p->MinContext->NumStats != 256)
|
|
||||||
{
|
|
||||||
see = p->See[p->NS2Indx[nonMasked - 1]] +
|
|
||||||
(nonMasked < (unsigned)SUFFIX(p->MinContext)->NumStats - p->MinContext->NumStats) +
|
|
||||||
2 * (p->MinContext->SummFreq < 11 * p->MinContext->NumStats) +
|
|
||||||
4 * (numMasked > nonMasked) +
|
|
||||||
p->HiBitsFlag;
|
|
||||||
{
|
|
||||||
unsigned r = (see->Summ >> see->Shift);
|
|
||||||
see->Summ = (UInt16)(see->Summ - r);
|
|
||||||
*escFreq = r + (r == 0);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
see = &p->DummySee;
|
|
||||||
*escFreq = 1;
|
|
||||||
}
|
|
||||||
return see;
|
|
||||||
}
|
|
||||||
|
|
||||||
static void NextContext(CPpmd7 *p)
|
|
||||||
{
|
|
||||||
CTX_PTR c = CTX(SUCCESSOR(p->FoundState));
|
|
||||||
if (p->OrderFall == 0 && (Byte *)c > p->Text)
|
|
||||||
p->MinContext = p->MaxContext = c;
|
|
||||||
else
|
|
||||||
UpdateModel(p);
|
|
||||||
}
|
|
||||||
|
|
||||||
void Ppmd7_Update1(CPpmd7 *p)
|
|
||||||
{
|
|
||||||
CPpmd_State *s = p->FoundState;
|
|
||||||
s->Freq += 4;
|
|
||||||
p->MinContext->SummFreq += 4;
|
|
||||||
if (s[0].Freq > s[-1].Freq)
|
|
||||||
{
|
|
||||||
SwapStates(&s[0], &s[-1]);
|
|
||||||
p->FoundState = --s;
|
|
||||||
if (s->Freq > MAX_FREQ)
|
|
||||||
Rescale(p);
|
|
||||||
}
|
|
||||||
NextContext(p);
|
|
||||||
}
|
|
||||||
|
|
||||||
void Ppmd7_Update1_0(CPpmd7 *p)
|
|
||||||
{
|
|
||||||
p->PrevSuccess = (2 * p->FoundState->Freq > p->MinContext->SummFreq);
|
|
||||||
p->RunLength += p->PrevSuccess;
|
|
||||||
p->MinContext->SummFreq += 4;
|
|
||||||
if ((p->FoundState->Freq += 4) > MAX_FREQ)
|
|
||||||
Rescale(p);
|
|
||||||
NextContext(p);
|
|
||||||
}
|
|
||||||
|
|
||||||
void Ppmd7_UpdateBin(CPpmd7 *p)
|
|
||||||
{
|
|
||||||
p->FoundState->Freq = (Byte)(p->FoundState->Freq + (p->FoundState->Freq < 128 ? 1: 0));
|
|
||||||
p->PrevSuccess = 1;
|
|
||||||
p->RunLength++;
|
|
||||||
NextContext(p);
|
|
||||||
}
|
|
||||||
|
|
||||||
void Ppmd7_Update2(CPpmd7 *p)
|
|
||||||
{
|
|
||||||
p->MinContext->SummFreq += 4;
|
|
||||||
if ((p->FoundState->Freq += 4) > MAX_FREQ)
|
|
||||||
Rescale(p);
|
|
||||||
p->RunLength = p->InitRL;
|
|
||||||
UpdateModel(p);
|
|
||||||
}
|
|
||||||
@ -1,140 +0,0 @@
|
|||||||
/* Ppmd7.h -- PPMdH compression codec
|
|
||||||
2010-03-12 : Igor Pavlov : Public domain
|
|
||||||
This code is based on PPMd var.H (2001): Dmitry Shkarin : Public domain */
|
|
||||||
|
|
||||||
/* This code supports virtual RangeDecoder and includes the implementation
|
|
||||||
of RangeCoder from 7z, instead of RangeCoder from original PPMd var.H.
|
|
||||||
If you need the compatibility with original PPMd var.H, you can use external RangeDecoder */
|
|
||||||
|
|
||||||
#ifndef __PPMD7_H
|
|
||||||
#define __PPMD7_H
|
|
||||||
|
|
||||||
#include "Ppmd.h"
|
|
||||||
|
|
||||||
EXTERN_C_BEGIN
|
|
||||||
|
|
||||||
#define PPMD7_MIN_ORDER 2
|
|
||||||
#define PPMD7_MAX_ORDER 64
|
|
||||||
|
|
||||||
#define PPMD7_MIN_MEM_SIZE (1 << 11)
|
|
||||||
#define PPMD7_MAX_MEM_SIZE (0xFFFFFFFF - 12 * 3)
|
|
||||||
|
|
||||||
struct CPpmd7_Context_;
|
|
||||||
|
|
||||||
typedef
|
|
||||||
#ifdef PPMD_32BIT
|
|
||||||
struct CPpmd7_Context_ *
|
|
||||||
#else
|
|
||||||
UInt32
|
|
||||||
#endif
|
|
||||||
CPpmd7_Context_Ref;
|
|
||||||
|
|
||||||
typedef struct CPpmd7_Context_
|
|
||||||
{
|
|
||||||
UInt16 NumStats;
|
|
||||||
UInt16 SummFreq;
|
|
||||||
CPpmd_State_Ref Stats;
|
|
||||||
CPpmd7_Context_Ref Suffix;
|
|
||||||
} CPpmd7_Context;
|
|
||||||
|
|
||||||
#define Ppmd7Context_OneState(p) ((CPpmd_State *)&(p)->SummFreq)
|
|
||||||
|
|
||||||
typedef struct
|
|
||||||
{
|
|
||||||
CPpmd7_Context *MinContext, *MaxContext;
|
|
||||||
CPpmd_State *FoundState;
|
|
||||||
unsigned OrderFall, InitEsc, PrevSuccess, MaxOrder, HiBitsFlag;
|
|
||||||
Int32 RunLength, InitRL; /* must be 32-bit at least */
|
|
||||||
|
|
||||||
UInt32 Size;
|
|
||||||
UInt32 GlueCount;
|
|
||||||
Byte *Base, *LoUnit, *HiUnit, *Text, *UnitsStart;
|
|
||||||
UInt32 AlignOffset;
|
|
||||||
|
|
||||||
Byte Indx2Units[PPMD_NUM_INDEXES];
|
|
||||||
Byte Units2Indx[128];
|
|
||||||
CPpmd_Void_Ref FreeList[PPMD_NUM_INDEXES];
|
|
||||||
Byte NS2Indx[256], NS2BSIndx[256], HB2Flag[256];
|
|
||||||
CPpmd_See DummySee, See[25][16];
|
|
||||||
UInt16 BinSumm[128][64];
|
|
||||||
} CPpmd7;
|
|
||||||
|
|
||||||
void Ppmd7_Construct(CPpmd7 *p);
|
|
||||||
Bool Ppmd7_Alloc(CPpmd7 *p, UInt32 size, ISzAlloc *alloc);
|
|
||||||
void Ppmd7_Free(CPpmd7 *p, ISzAlloc *alloc);
|
|
||||||
void Ppmd7_Init(CPpmd7 *p, unsigned maxOrder);
|
|
||||||
#define Ppmd7_WasAllocated(p) ((p)->Base != NULL)
|
|
||||||
|
|
||||||
|
|
||||||
/* ---------- Internal Functions ---------- */
|
|
||||||
|
|
||||||
extern const Byte PPMD7_kExpEscape[16];
|
|
||||||
|
|
||||||
#ifdef PPMD_32BIT
|
|
||||||
#define Ppmd7_GetPtr(p, ptr) (ptr)
|
|
||||||
#define Ppmd7_GetContext(p, ptr) (ptr)
|
|
||||||
#define Ppmd7_GetStats(p, ctx) ((ctx)->Stats)
|
|
||||||
#else
|
|
||||||
#define Ppmd7_GetPtr(p, offs) ((void *)((p)->Base + (offs)))
|
|
||||||
#define Ppmd7_GetContext(p, offs) ((CPpmd7_Context *)Ppmd7_GetPtr((p), (offs)))
|
|
||||||
#define Ppmd7_GetStats(p, ctx) ((CPpmd_State *)Ppmd7_GetPtr((p), ((ctx)->Stats)))
|
|
||||||
#endif
|
|
||||||
|
|
||||||
void Ppmd7_Update1(CPpmd7 *p);
|
|
||||||
void Ppmd7_Update1_0(CPpmd7 *p);
|
|
||||||
void Ppmd7_Update2(CPpmd7 *p);
|
|
||||||
void Ppmd7_UpdateBin(CPpmd7 *p);
|
|
||||||
|
|
||||||
#define Ppmd7_GetBinSumm(p) \
|
|
||||||
&p->BinSumm[Ppmd7Context_OneState(p->MinContext)->Freq - 1][p->PrevSuccess + \
|
|
||||||
p->NS2BSIndx[Ppmd7_GetContext(p, p->MinContext->Suffix)->NumStats - 1] + \
|
|
||||||
(p->HiBitsFlag = p->HB2Flag[p->FoundState->Symbol]) + \
|
|
||||||
2 * p->HB2Flag[Ppmd7Context_OneState(p->MinContext)->Symbol] + \
|
|
||||||
((p->RunLength >> 26) & 0x20)]
|
|
||||||
|
|
||||||
CPpmd_See *Ppmd7_MakeEscFreq(CPpmd7 *p, unsigned numMasked, UInt32 *scale);
|
|
||||||
|
|
||||||
|
|
||||||
/* ---------- Decode ---------- */
|
|
||||||
|
|
||||||
typedef struct
|
|
||||||
{
|
|
||||||
UInt32 (*GetThreshold)(void *p, UInt32 total);
|
|
||||||
void (*Decode)(void *p, UInt32 start, UInt32 size);
|
|
||||||
UInt32 (*DecodeBit)(void *p, UInt32 size0);
|
|
||||||
} IPpmd7_RangeDec;
|
|
||||||
|
|
||||||
typedef struct
|
|
||||||
{
|
|
||||||
IPpmd7_RangeDec p;
|
|
||||||
UInt32 Range;
|
|
||||||
UInt32 Code;
|
|
||||||
IByteIn *Stream;
|
|
||||||
} CPpmd7z_RangeDec;
|
|
||||||
|
|
||||||
void Ppmd7z_RangeDec_CreateVTable(CPpmd7z_RangeDec *p);
|
|
||||||
Bool Ppmd7z_RangeDec_Init(CPpmd7z_RangeDec *p);
|
|
||||||
#define Ppmd7z_RangeDec_IsFinishedOK(p) ((p)->Code == 0)
|
|
||||||
|
|
||||||
int Ppmd7_DecodeSymbol(CPpmd7 *p, IPpmd7_RangeDec *rc);
|
|
||||||
|
|
||||||
|
|
||||||
/* ---------- Encode ---------- */
|
|
||||||
|
|
||||||
typedef struct
|
|
||||||
{
|
|
||||||
UInt64 Low;
|
|
||||||
UInt32 Range;
|
|
||||||
Byte Cache;
|
|
||||||
UInt64 CacheSize;
|
|
||||||
IByteOut *Stream;
|
|
||||||
} CPpmd7z_RangeEnc;
|
|
||||||
|
|
||||||
void Ppmd7z_RangeEnc_Init(CPpmd7z_RangeEnc *p);
|
|
||||||
void Ppmd7z_RangeEnc_FlushData(CPpmd7z_RangeEnc *p);
|
|
||||||
|
|
||||||
void Ppmd7_EncodeSymbol(CPpmd7 *p, CPpmd7z_RangeEnc *rc, int symbol);
|
|
||||||
|
|
||||||
EXTERN_C_END
|
|
||||||
|
|
||||||
#endif
|
|
||||||
@ -1,187 +0,0 @@
|
|||||||
/* Ppmd7Dec.c -- PPMdH Decoder
|
|
||||||
2010-03-12 : Igor Pavlov : Public domain
|
|
||||||
This code is based on PPMd var.H (2001): Dmitry Shkarin : Public domain */
|
|
||||||
|
|
||||||
#include "Ppmd7.h"
|
|
||||||
|
|
||||||
#define kTopValue (1 << 24)
|
|
||||||
|
|
||||||
Bool Ppmd7z_RangeDec_Init(CPpmd7z_RangeDec *p)
|
|
||||||
{
|
|
||||||
unsigned i;
|
|
||||||
p->Code = 0;
|
|
||||||
p->Range = 0xFFFFFFFF;
|
|
||||||
if (p->Stream->Read((void *)p->Stream) != 0)
|
|
||||||
return False;
|
|
||||||
for (i = 0; i < 4; i++)
|
|
||||||
p->Code = (p->Code << 8) | p->Stream->Read((void *)p->Stream);
|
|
||||||
return (p->Code < 0xFFFFFFFF);
|
|
||||||
}
|
|
||||||
|
|
||||||
static UInt32 Range_GetThreshold(void *pp, UInt32 total)
|
|
||||||
{
|
|
||||||
CPpmd7z_RangeDec *p = (CPpmd7z_RangeDec *)pp;
|
|
||||||
return (p->Code) / (p->Range /= total);
|
|
||||||
}
|
|
||||||
|
|
||||||
static void Range_Normalize(CPpmd7z_RangeDec *p)
|
|
||||||
{
|
|
||||||
if (p->Range < kTopValue)
|
|
||||||
{
|
|
||||||
p->Code = (p->Code << 8) | p->Stream->Read((void *)p->Stream);
|
|
||||||
p->Range <<= 8;
|
|
||||||
if (p->Range < kTopValue)
|
|
||||||
{
|
|
||||||
p->Code = (p->Code << 8) | p->Stream->Read((void *)p->Stream);
|
|
||||||
p->Range <<= 8;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
static void Range_Decode(void *pp, UInt32 start, UInt32 size)
|
|
||||||
{
|
|
||||||
CPpmd7z_RangeDec *p = (CPpmd7z_RangeDec *)pp;
|
|
||||||
p->Code -= start * p->Range;
|
|
||||||
p->Range *= size;
|
|
||||||
Range_Normalize(p);
|
|
||||||
}
|
|
||||||
|
|
||||||
static UInt32 Range_DecodeBit(void *pp, UInt32 size0)
|
|
||||||
{
|
|
||||||
CPpmd7z_RangeDec *p = (CPpmd7z_RangeDec *)pp;
|
|
||||||
UInt32 newBound = (p->Range >> 14) * size0;
|
|
||||||
UInt32 symbol;
|
|
||||||
if (p->Code < newBound)
|
|
||||||
{
|
|
||||||
symbol = 0;
|
|
||||||
p->Range = newBound;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
symbol = 1;
|
|
||||||
p->Code -= newBound;
|
|
||||||
p->Range -= newBound;
|
|
||||||
}
|
|
||||||
Range_Normalize(p);
|
|
||||||
return symbol;
|
|
||||||
}
|
|
||||||
|
|
||||||
void Ppmd7z_RangeDec_CreateVTable(CPpmd7z_RangeDec *p)
|
|
||||||
{
|
|
||||||
p->p.GetThreshold = Range_GetThreshold;
|
|
||||||
p->p.Decode = Range_Decode;
|
|
||||||
p->p.DecodeBit = Range_DecodeBit;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
#define MASK(sym) ((signed char *)charMask)[sym]
|
|
||||||
|
|
||||||
int Ppmd7_DecodeSymbol(CPpmd7 *p, IPpmd7_RangeDec *rc)
|
|
||||||
{
|
|
||||||
size_t charMask[256 / sizeof(size_t)];
|
|
||||||
if (p->MinContext->NumStats != 1)
|
|
||||||
{
|
|
||||||
CPpmd_State *s = Ppmd7_GetStats(p, p->MinContext);
|
|
||||||
unsigned i;
|
|
||||||
UInt32 count, hiCnt;
|
|
||||||
if ((count = rc->GetThreshold(rc, p->MinContext->SummFreq)) < (hiCnt = s->Freq))
|
|
||||||
{
|
|
||||||
Byte symbol;
|
|
||||||
rc->Decode(rc, 0, s->Freq);
|
|
||||||
p->FoundState = s;
|
|
||||||
symbol = s->Symbol;
|
|
||||||
Ppmd7_Update1_0(p);
|
|
||||||
return symbol;
|
|
||||||
}
|
|
||||||
p->PrevSuccess = 0;
|
|
||||||
i = p->MinContext->NumStats - 1;
|
|
||||||
do
|
|
||||||
{
|
|
||||||
if ((hiCnt += (++s)->Freq) > count)
|
|
||||||
{
|
|
||||||
Byte symbol;
|
|
||||||
rc->Decode(rc, hiCnt - s->Freq, s->Freq);
|
|
||||||
p->FoundState = s;
|
|
||||||
symbol = s->Symbol;
|
|
||||||
Ppmd7_Update1(p);
|
|
||||||
return symbol;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
while (--i);
|
|
||||||
if (count >= p->MinContext->SummFreq)
|
|
||||||
return -2;
|
|
||||||
p->HiBitsFlag = p->HB2Flag[p->FoundState->Symbol];
|
|
||||||
rc->Decode(rc, hiCnt, p->MinContext->SummFreq - hiCnt);
|
|
||||||
PPMD_SetAllBitsIn256Bytes(charMask);
|
|
||||||
MASK(s->Symbol) = 0;
|
|
||||||
i = p->MinContext->NumStats - 1;
|
|
||||||
do { MASK((--s)->Symbol) = 0; } while (--i);
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
UInt16 *prob = Ppmd7_GetBinSumm(p);
|
|
||||||
if (rc->DecodeBit(rc, *prob) == 0)
|
|
||||||
{
|
|
||||||
Byte symbol;
|
|
||||||
*prob = (UInt16)PPMD_UPDATE_PROB_0(*prob);
|
|
||||||
symbol = (p->FoundState = Ppmd7Context_OneState(p->MinContext))->Symbol;
|
|
||||||
Ppmd7_UpdateBin(p);
|
|
||||||
return symbol;
|
|
||||||
}
|
|
||||||
*prob = (UInt16)PPMD_UPDATE_PROB_1(*prob);
|
|
||||||
p->InitEsc = PPMD7_kExpEscape[*prob >> 10];
|
|
||||||
PPMD_SetAllBitsIn256Bytes(charMask);
|
|
||||||
MASK(Ppmd7Context_OneState(p->MinContext)->Symbol) = 0;
|
|
||||||
p->PrevSuccess = 0;
|
|
||||||
}
|
|
||||||
for (;;)
|
|
||||||
{
|
|
||||||
CPpmd_State *ps[256], *s;
|
|
||||||
UInt32 freqSum, count, hiCnt;
|
|
||||||
CPpmd_See *see;
|
|
||||||
unsigned i, num, numMasked = p->MinContext->NumStats;
|
|
||||||
do
|
|
||||||
{
|
|
||||||
p->OrderFall++;
|
|
||||||
if (!p->MinContext->Suffix)
|
|
||||||
return -1;
|
|
||||||
p->MinContext = Ppmd7_GetContext(p, p->MinContext->Suffix);
|
|
||||||
}
|
|
||||||
while (p->MinContext->NumStats == numMasked);
|
|
||||||
hiCnt = 0;
|
|
||||||
s = Ppmd7_GetStats(p, p->MinContext);
|
|
||||||
i = 0;
|
|
||||||
num = p->MinContext->NumStats - numMasked;
|
|
||||||
do
|
|
||||||
{
|
|
||||||
int k = (int)(MASK(s->Symbol));
|
|
||||||
hiCnt += (s->Freq & k);
|
|
||||||
ps[i] = s++;
|
|
||||||
i -= k;
|
|
||||||
}
|
|
||||||
while (i != num);
|
|
||||||
|
|
||||||
see = Ppmd7_MakeEscFreq(p, numMasked, &freqSum);
|
|
||||||
freqSum += hiCnt;
|
|
||||||
count = rc->GetThreshold(rc, freqSum);
|
|
||||||
|
|
||||||
if (count < hiCnt)
|
|
||||||
{
|
|
||||||
Byte symbol;
|
|
||||||
CPpmd_State **pps = ps;
|
|
||||||
for (hiCnt = 0; (hiCnt += (*pps)->Freq) <= count; pps++);
|
|
||||||
s = *pps;
|
|
||||||
rc->Decode(rc, hiCnt - s->Freq, s->Freq);
|
|
||||||
Ppmd_See_Update(see);
|
|
||||||
p->FoundState = s;
|
|
||||||
symbol = s->Symbol;
|
|
||||||
Ppmd7_Update2(p);
|
|
||||||
return symbol;
|
|
||||||
}
|
|
||||||
if (count >= freqSum)
|
|
||||||
return -2;
|
|
||||||
rc->Decode(rc, hiCnt, freqSum - hiCnt);
|
|
||||||
see->Summ = (UInt16)(see->Summ + freqSum);
|
|
||||||
do { MASK(ps[--i]->Symbol) = 0; } while (i != 0);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
Loading…
Reference in New Issue
Block a user