490 lines
11 KiB
C++
490 lines
11 KiB
C++
#define STARTL1 2
|
|
static unsigned int DecL1[]={0x8000,0xa000,0xc000,0xd000,0xe000,0xea00,
|
|
0xee00,0xf000,0xf200,0xf200,0xffff};
|
|
static unsigned int PosL1[]={0,0,0,2,3,5,7,11,16,20,24,32,32};
|
|
|
|
#define STARTL2 3
|
|
static unsigned int DecL2[]={0xa000,0xc000,0xd000,0xe000,0xea00,0xee00,
|
|
0xf000,0xf200,0xf240,0xffff};
|
|
static unsigned int PosL2[]={0,0,0,0,5,7,9,13,18,22,26,34,36};
|
|
|
|
#define STARTHF0 4
|
|
static unsigned int DecHf0[]={0x8000,0xc000,0xe000,0xf200,0xf200,0xf200,
|
|
0xf200,0xf200,0xffff};
|
|
static unsigned int PosHf0[]={0,0,0,0,0,8,16,24,33,33,33,33,33};
|
|
|
|
|
|
#define STARTHF1 5
|
|
static unsigned int DecHf1[]={0x2000,0xc000,0xe000,0xf000,0xf200,0xf200,
|
|
0xf7e0,0xffff};
|
|
static unsigned int PosHf1[]={0,0,0,0,0,0,4,44,60,76,80,80,127};
|
|
|
|
|
|
#define STARTHF2 5
|
|
static unsigned int DecHf2[]={0x1000,0x2400,0x8000,0xc000,0xfa00,0xffff,
|
|
0xffff,0xffff};
|
|
static unsigned int PosHf2[]={0,0,0,0,0,0,2,7,53,117,233,0,0};
|
|
|
|
|
|
#define STARTHF3 6
|
|
static unsigned int DecHf3[]={0x800,0x2400,0xee00,0xfe80,0xffff,0xffff,
|
|
0xffff};
|
|
static unsigned int PosHf3[]={0,0,0,0,0,0,0,2,16,218,251,0,0};
|
|
|
|
|
|
#define STARTHF4 8
|
|
static unsigned int DecHf4[]={0xff00,0xffff,0xffff,0xffff,0xffff,0xffff};
|
|
static unsigned int PosHf4[]={0,0,0,0,0,0,0,0,0,255,0,0,0};
|
|
|
|
|
|
void Unpack::Unpack15(bool Solid)
|
|
{
|
|
UnpInitData(Solid);
|
|
UnpInitData15(Solid);
|
|
UnpReadBuf();
|
|
if (!Solid)
|
|
{
|
|
InitHuff();
|
|
UnpPtr=0;
|
|
}
|
|
else
|
|
UnpPtr=WrPtr;
|
|
--DestUnpSize;
|
|
if (DestUnpSize>=0)
|
|
{
|
|
GetFlagsBuf();
|
|
FlagsCnt=8;
|
|
}
|
|
|
|
while (DestUnpSize>=0)
|
|
{
|
|
UnpPtr&=MaxWinMask;
|
|
|
|
if (Inp.InAddr>ReadTop-30 && !UnpReadBuf())
|
|
break;
|
|
if (((WrPtr-UnpPtr) & MaxWinMask)<270 && WrPtr!=UnpPtr)
|
|
UnpWriteBuf20();
|
|
if (StMode)
|
|
{
|
|
HuffDecode();
|
|
continue;
|
|
}
|
|
|
|
if (--FlagsCnt < 0)
|
|
{
|
|
GetFlagsBuf();
|
|
FlagsCnt=7;
|
|
}
|
|
|
|
if (FlagBuf & 0x80)
|
|
{
|
|
FlagBuf<<=1;
|
|
if (Nlzb > Nhfb)
|
|
LongLZ();
|
|
else
|
|
HuffDecode();
|
|
}
|
|
else
|
|
{
|
|
FlagBuf<<=1;
|
|
if (--FlagsCnt < 0)
|
|
{
|
|
GetFlagsBuf();
|
|
FlagsCnt=7;
|
|
}
|
|
if (FlagBuf & 0x80)
|
|
{
|
|
FlagBuf<<=1;
|
|
if (Nlzb > Nhfb)
|
|
HuffDecode();
|
|
else
|
|
LongLZ();
|
|
}
|
|
else
|
|
{
|
|
FlagBuf<<=1;
|
|
ShortLZ();
|
|
}
|
|
}
|
|
}
|
|
UnpWriteBuf20();
|
|
}
|
|
|
|
|
|
#define GetShortLen1(pos) ((pos)==1 ? Buf60+3:ShortLen1[pos])
|
|
#define GetShortLen2(pos) ((pos)==3 ? Buf60+3:ShortLen2[pos])
|
|
|
|
void Unpack::ShortLZ()
|
|
{
|
|
static unsigned int ShortLen1[]={1,3,4,4,5,6,7,8,8,4,4,5,6,6,4,0};
|
|
static unsigned int ShortXor1[]={0,0xa0,0xd0,0xe0,0xf0,0xf8,0xfc,0xfe,
|
|
0xff,0xc0,0x80,0x90,0x98,0x9c,0xb0};
|
|
static unsigned int ShortLen2[]={2,3,3,3,4,4,5,6,6,4,4,5,6,6,4,0};
|
|
static unsigned int ShortXor2[]={0,0x40,0x60,0xa0,0xd0,0xe0,0xf0,0xf8,
|
|
0xfc,0xc0,0x80,0x90,0x98,0x9c,0xb0};
|
|
|
|
|
|
unsigned int Length,SaveLength;
|
|
unsigned int LastDistance;
|
|
unsigned int Distance;
|
|
int DistancePlace;
|
|
NumHuf=0;
|
|
|
|
unsigned int BitField=Inp.fgetbits();
|
|
if (LCount==2)
|
|
{
|
|
Inp.faddbits(1);
|
|
if (BitField >= 0x8000)
|
|
{
|
|
CopyString15((unsigned int)LastDist,LastLength);
|
|
return;
|
|
}
|
|
BitField <<= 1;
|
|
LCount=0;
|
|
}
|
|
|
|
BitField>>=8;
|
|
|
|
// not thread safe, replaced by GetShortLen1 and GetShortLen2 macro
|
|
// ShortLen1[1]=ShortLen2[3]=Buf60+3;
|
|
|
|
if (AvrLn1<37)
|
|
{
|
|
for (Length=0;;Length++)
|
|
if (((BitField^ShortXor1[Length]) & (~(0xff>>GetShortLen1(Length))))==0)
|
|
break;
|
|
Inp.faddbits(GetShortLen1(Length));
|
|
}
|
|
else
|
|
{
|
|
for (Length=0;;Length++)
|
|
if (((BitField^ShortXor2[Length]) & (~(0xff>>GetShortLen2(Length))))==0)
|
|
break;
|
|
Inp.faddbits(GetShortLen2(Length));
|
|
}
|
|
|
|
if (Length >= 9)
|
|
{
|
|
if (Length == 9)
|
|
{
|
|
LCount++;
|
|
CopyString15((unsigned int)LastDist,LastLength);
|
|
return;
|
|
}
|
|
if (Length == 14)
|
|
{
|
|
LCount=0;
|
|
Length=DecodeNum(Inp.fgetbits(),STARTL2,DecL2,PosL2)+5;
|
|
Distance=(Inp.fgetbits()>>1) | 0x8000;
|
|
Inp.faddbits(15);
|
|
LastLength=Length;
|
|
LastDist=Distance;
|
|
CopyString15(Distance,Length);
|
|
return;
|
|
}
|
|
|
|
LCount=0;
|
|
SaveLength=Length;
|
|
Distance=OldDist[(OldDistPtr-(Length-9)) & 3];
|
|
Length=DecodeNum(Inp.fgetbits(),STARTL1,DecL1,PosL1)+2;
|
|
if (Length==0x101 && SaveLength==10)
|
|
{
|
|
Buf60 ^= 1;
|
|
return;
|
|
}
|
|
if (Distance > 256)
|
|
Length++;
|
|
if (Distance >= MaxDist3)
|
|
Length++;
|
|
|
|
OldDist[OldDistPtr++]=Distance;
|
|
OldDistPtr = OldDistPtr & 3;
|
|
LastLength=Length;
|
|
LastDist=Distance;
|
|
CopyString15(Distance,Length);
|
|
return;
|
|
}
|
|
|
|
LCount=0;
|
|
AvrLn1 += Length;
|
|
AvrLn1 -= AvrLn1 >> 4;
|
|
|
|
DistancePlace=DecodeNum(Inp.fgetbits(),STARTHF2,DecHf2,PosHf2) & 0xff;
|
|
Distance=ChSetA[DistancePlace];
|
|
if (--DistancePlace != -1)
|
|
{
|
|
LastDistance=ChSetA[DistancePlace];
|
|
ChSetA[DistancePlace+1]=LastDistance;
|
|
ChSetA[DistancePlace]=Distance;
|
|
}
|
|
Length+=2;
|
|
OldDist[OldDistPtr++] = ++Distance;
|
|
OldDistPtr = OldDistPtr & 3;
|
|
LastLength=Length;
|
|
LastDist=Distance;
|
|
CopyString15(Distance,Length);
|
|
}
|
|
|
|
|
|
void Unpack::LongLZ()
|
|
{
|
|
unsigned int Length;
|
|
unsigned int Distance;
|
|
unsigned int DistancePlace,NewDistancePlace;
|
|
unsigned int OldAvr2,OldAvr3;
|
|
|
|
NumHuf=0;
|
|
Nlzb+=16;
|
|
if (Nlzb > 0xff)
|
|
{
|
|
Nlzb=0x90;
|
|
Nhfb >>= 1;
|
|
}
|
|
OldAvr2=AvrLn2;
|
|
|
|
unsigned int BitField=Inp.fgetbits();
|
|
if (AvrLn2 >= 122)
|
|
Length=DecodeNum(BitField,STARTL2,DecL2,PosL2);
|
|
else
|
|
if (AvrLn2 >= 64)
|
|
Length=DecodeNum(BitField,STARTL1,DecL1,PosL1);
|
|
else
|
|
if (BitField < 0x100)
|
|
{
|
|
Length=BitField;
|
|
Inp.faddbits(16);
|
|
}
|
|
else
|
|
{
|
|
for (Length=0;((BitField<<Length)&0x8000)==0;Length++)
|
|
;
|
|
Inp.faddbits(Length+1);
|
|
}
|
|
|
|
AvrLn2 += Length;
|
|
AvrLn2 -= AvrLn2 >> 5;
|
|
|
|
BitField=Inp.fgetbits();
|
|
if (AvrPlcB > 0x28ff)
|
|
DistancePlace=DecodeNum(BitField,STARTHF2,DecHf2,PosHf2);
|
|
else
|
|
if (AvrPlcB > 0x6ff)
|
|
DistancePlace=DecodeNum(BitField,STARTHF1,DecHf1,PosHf1);
|
|
else
|
|
DistancePlace=DecodeNum(BitField,STARTHF0,DecHf0,PosHf0);
|
|
|
|
AvrPlcB += DistancePlace;
|
|
AvrPlcB -= AvrPlcB >> 8;
|
|
while (1)
|
|
{
|
|
Distance = ChSetB[DistancePlace & 0xff];
|
|
NewDistancePlace = NToPlB[Distance++ & 0xff]++;
|
|
if (!(Distance & 0xff))
|
|
CorrHuff(ChSetB,NToPlB);
|
|
else
|
|
break;
|
|
}
|
|
|
|
ChSetB[DistancePlace & 0xff]=ChSetB[NewDistancePlace];
|
|
ChSetB[NewDistancePlace]=Distance;
|
|
|
|
Distance=((Distance & 0xff00) | (Inp.fgetbits() >> 8)) >> 1;
|
|
Inp.faddbits(7);
|
|
|
|
OldAvr3=AvrLn3;
|
|
if (Length!=1 && Length!=4)
|
|
if (Length==0 && Distance <= MaxDist3)
|
|
{
|
|
AvrLn3++;
|
|
AvrLn3 -= AvrLn3 >> 8;
|
|
}
|
|
else
|
|
if (AvrLn3 > 0)
|
|
AvrLn3--;
|
|
Length+=3;
|
|
if (Distance >= MaxDist3)
|
|
Length++;
|
|
if (Distance <= 256)
|
|
Length+=8;
|
|
if (OldAvr3 > 0xb0 || AvrPlc >= 0x2a00 && OldAvr2 < 0x40)
|
|
MaxDist3=0x7f00;
|
|
else
|
|
MaxDist3=0x2001;
|
|
OldDist[OldDistPtr++]=Distance;
|
|
OldDistPtr = OldDistPtr & 3;
|
|
LastLength=Length;
|
|
LastDist=Distance;
|
|
CopyString15(Distance,Length);
|
|
}
|
|
|
|
|
|
void Unpack::HuffDecode()
|
|
{
|
|
unsigned int CurByte,NewBytePlace;
|
|
unsigned int Length;
|
|
unsigned int Distance;
|
|
int BytePlace;
|
|
|
|
unsigned int BitField=Inp.fgetbits();
|
|
|
|
if (AvrPlc > 0x75ff)
|
|
BytePlace=DecodeNum(BitField,STARTHF4,DecHf4,PosHf4);
|
|
else
|
|
if (AvrPlc > 0x5dff)
|
|
BytePlace=DecodeNum(BitField,STARTHF3,DecHf3,PosHf3);
|
|
else
|
|
if (AvrPlc > 0x35ff)
|
|
BytePlace=DecodeNum(BitField,STARTHF2,DecHf2,PosHf2);
|
|
else
|
|
if (AvrPlc > 0x0dff)
|
|
BytePlace=DecodeNum(BitField,STARTHF1,DecHf1,PosHf1);
|
|
else
|
|
BytePlace=DecodeNum(BitField,STARTHF0,DecHf0,PosHf0);
|
|
BytePlace&=0xff;
|
|
if (StMode)
|
|
{
|
|
if (BytePlace==0 && BitField > 0xfff)
|
|
BytePlace=0x100;
|
|
if (--BytePlace==-1)
|
|
{
|
|
BitField=Inp.fgetbits();
|
|
Inp.faddbits(1);
|
|
if (BitField & 0x8000)
|
|
{
|
|
NumHuf=StMode=0;
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
Length = (BitField & 0x4000) ? 4 : 3;
|
|
Inp.faddbits(1);
|
|
Distance=DecodeNum(Inp.fgetbits(),STARTHF2,DecHf2,PosHf2);
|
|
Distance = (Distance << 5) | (Inp.fgetbits() >> 11);
|
|
Inp.faddbits(5);
|
|
CopyString15(Distance,Length);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
if (NumHuf++ >= 16 && FlagsCnt==0)
|
|
StMode=1;
|
|
AvrPlc += BytePlace;
|
|
AvrPlc -= AvrPlc >> 8;
|
|
Nhfb+=16;
|
|
if (Nhfb > 0xff)
|
|
{
|
|
Nhfb=0x90;
|
|
Nlzb >>= 1;
|
|
}
|
|
|
|
Window[UnpPtr++]=(byte)(ChSet[BytePlace]>>8);
|
|
--DestUnpSize;
|
|
|
|
while (1)
|
|
{
|
|
CurByte=ChSet[BytePlace];
|
|
NewBytePlace=NToPl[CurByte++ & 0xff]++;
|
|
if ((CurByte & 0xff) > 0xa1)
|
|
CorrHuff(ChSet,NToPl);
|
|
else
|
|
break;
|
|
}
|
|
|
|
ChSet[BytePlace]=ChSet[NewBytePlace];
|
|
ChSet[NewBytePlace]=CurByte;
|
|
}
|
|
|
|
|
|
void Unpack::GetFlagsBuf()
|
|
{
|
|
unsigned int Flags,NewFlagsPlace;
|
|
unsigned int FlagsPlace=DecodeNum(Inp.fgetbits(),STARTHF2,DecHf2,PosHf2);
|
|
|
|
// Our Huffman table stores 257 items and needs all them in other parts
|
|
// of code such as when StMode is on, so the first item is control item.
|
|
// While normally we do not use the last item to code the flags byte here,
|
|
// we need to check for value 256 when unpacking in case we unpack
|
|
// a corrupt archive.
|
|
if (FlagsPlace>=sizeof(ChSetC)/sizeof(ChSetC[0]))
|
|
return;
|
|
|
|
while (1)
|
|
{
|
|
Flags=ChSetC[FlagsPlace];
|
|
FlagBuf=Flags>>8;
|
|
NewFlagsPlace=NToPlC[Flags++ & 0xff]++;
|
|
if ((Flags & 0xff) != 0)
|
|
break;
|
|
CorrHuff(ChSetC,NToPlC);
|
|
}
|
|
|
|
ChSetC[FlagsPlace]=ChSetC[NewFlagsPlace];
|
|
ChSetC[NewFlagsPlace]=Flags;
|
|
}
|
|
|
|
|
|
void Unpack::UnpInitData15(int Solid)
|
|
{
|
|
if (!Solid)
|
|
{
|
|
AvrPlcB=AvrLn1=AvrLn2=AvrLn3=NumHuf=Buf60=0;
|
|
AvrPlc=0x3500;
|
|
MaxDist3=0x2001;
|
|
Nhfb=Nlzb=0x80;
|
|
}
|
|
FlagsCnt=0;
|
|
FlagBuf=0;
|
|
StMode=0;
|
|
LCount=0;
|
|
ReadTop=0;
|
|
}
|
|
|
|
|
|
void Unpack::InitHuff()
|
|
{
|
|
for (unsigned int I=0;I<256;I++)
|
|
{
|
|
ChSet[I]=ChSetB[I]=I<<8;
|
|
ChSetA[I]=I;
|
|
ChSetC[I]=((~I+1) & 0xff)<<8;
|
|
}
|
|
memset(NToPl,0,sizeof(NToPl));
|
|
memset(NToPlB,0,sizeof(NToPlB));
|
|
memset(NToPlC,0,sizeof(NToPlC));
|
|
CorrHuff(ChSetB,NToPlB);
|
|
}
|
|
|
|
|
|
void Unpack::CorrHuff(ushort *CharSet,byte *NumToPlace)
|
|
{
|
|
int I,J;
|
|
for (I=7;I>=0;I--)
|
|
for (J=0;J<32;J++,CharSet++)
|
|
*CharSet=(*CharSet & ~0xff) | I;
|
|
memset(NumToPlace,0,sizeof(NToPl));
|
|
for (I=6;I>=0;I--)
|
|
NumToPlace[I]=(7-I)*32;
|
|
}
|
|
|
|
|
|
void Unpack::CopyString15(uint Distance,uint Length)
|
|
{
|
|
DestUnpSize-=Length;
|
|
while (Length--)
|
|
{
|
|
Window[UnpPtr]=Window[(UnpPtr-Distance) & MaxWinMask];
|
|
UnpPtr=(UnpPtr+1) & MaxWinMask;
|
|
}
|
|
}
|
|
|
|
|
|
uint Unpack::DecodeNum(uint Num,uint StartPos,uint *DecTab,uint *PosTab)
|
|
{
|
|
int I;
|
|
for (Num&=0xfff0,I=0;DecTab[I]<=Num;I++)
|
|
StartPos++;
|
|
Inp.faddbits(StartPos);
|
|
return(((Num-(I ? DecTab[I-1]:0))>>(16-StartPos))+PosTab[StartPos]);
|
|
}
|