766 lines
19 KiB
C++
766 lines
19 KiB
C++
// We use it instead of direct PPM.DecodeChar call to be sure that
|
|
// we reset PPM structures in case of corrupt data. It is important,
|
|
// because these structures can be invalid after PPM.DecodeChar returned -1.
|
|
inline int Unpack::SafePPMDecodeChar()
|
|
{
|
|
int Ch=PPM.DecodeChar();
|
|
if (Ch==-1) // Corrupt PPM data found.
|
|
{
|
|
PPM.CleanUp(); // Reset possibly corrupt PPM data structures.
|
|
UnpBlockType=BLOCK_LZ; // Set faster and more fail proof LZ mode.
|
|
}
|
|
return(Ch);
|
|
}
|
|
|
|
|
|
void Unpack::Unpack29(bool Solid)
|
|
{
|
|
static unsigned char LDecode[]={0,1,2,3,4,5,6,7,8,10,12,14,16,20,24,28,32,40,48,56,64,80,96,112,128,160,192,224};
|
|
static unsigned char LBits[]= {0,0,0,0,0,0,0,0,1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5};
|
|
static int DDecode[DC];
|
|
static byte DBits[DC];
|
|
static int DBitLengthCounts[]= {4,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,14,0,12};
|
|
static unsigned char SDDecode[]={0,4,8,16,32,64,128,192};
|
|
static unsigned char SDBits[]= {2,2,3, 4, 5, 6, 6, 6};
|
|
unsigned int Bits;
|
|
|
|
if (DDecode[1]==0)
|
|
{
|
|
int Dist=0,BitLength=0,Slot=0;
|
|
for (int I=0;I<ASIZE(DBitLengthCounts);I++,BitLength++)
|
|
for (int J=0;J<DBitLengthCounts[I];J++,Slot++,Dist+=(1<<BitLength))
|
|
{
|
|
DDecode[Slot]=Dist;
|
|
DBits[Slot]=BitLength;
|
|
}
|
|
}
|
|
|
|
FileExtracted=true;
|
|
|
|
if (!Suspended)
|
|
{
|
|
UnpInitData(Solid);
|
|
if (!UnpReadBuf30())
|
|
return;
|
|
if ((!Solid || !TablesRead3) && !ReadTables30())
|
|
return;
|
|
}
|
|
|
|
while (true)
|
|
{
|
|
UnpPtr&=MaxWinMask;
|
|
|
|
if (Inp.InAddr>ReadBorder)
|
|
{
|
|
if (!UnpReadBuf30())
|
|
break;
|
|
}
|
|
if (((WrPtr-UnpPtr) & MaxWinMask)<260 && WrPtr!=UnpPtr)
|
|
{
|
|
UnpWriteBuf30();
|
|
if (WrittenFileSize>DestUnpSize)
|
|
return;
|
|
if (Suspended)
|
|
{
|
|
FileExtracted=false;
|
|
return;
|
|
}
|
|
}
|
|
if (UnpBlockType==BLOCK_PPM)
|
|
{
|
|
// Here speed is critical, so we do not use SafePPMDecodeChar,
|
|
// because sometimes even the inline function can introduce
|
|
// some additional penalty.
|
|
int Ch=PPM.DecodeChar();
|
|
if (Ch==-1) // Corrupt PPM data found.
|
|
{
|
|
PPM.CleanUp(); // Reset possibly corrupt PPM data structures.
|
|
UnpBlockType=BLOCK_LZ; // Set faster and more fail proof LZ mode.
|
|
break;
|
|
}
|
|
if (Ch==PPMEscChar)
|
|
{
|
|
int NextCh=SafePPMDecodeChar();
|
|
if (NextCh==0) // End of PPM encoding.
|
|
{
|
|
if (!ReadTables30())
|
|
break;
|
|
continue;
|
|
}
|
|
if (NextCh==-1) // Corrupt PPM data found.
|
|
break;
|
|
if (NextCh==2) // End of file in PPM mode.
|
|
break;
|
|
if (NextCh==3) // Read VM code.
|
|
{
|
|
if (!ReadVMCodePPM())
|
|
break;
|
|
continue;
|
|
}
|
|
if (NextCh==4) // LZ inside of PPM.
|
|
{
|
|
unsigned int Distance=0,Length;
|
|
bool Failed=false;
|
|
for (int I=0;I<4 && !Failed;I++)
|
|
{
|
|
int Ch=SafePPMDecodeChar();
|
|
if (Ch==-1)
|
|
Failed=true;
|
|
else
|
|
if (I==3)
|
|
Length=(byte)Ch;
|
|
else
|
|
Distance=(Distance<<8)+(byte)Ch;
|
|
}
|
|
if (Failed)
|
|
break;
|
|
|
|
CopyString(Length+32,Distance+2);
|
|
continue;
|
|
}
|
|
if (NextCh==5) // One byte distance match (RLE) inside of PPM.
|
|
{
|
|
int Length=SafePPMDecodeChar();
|
|
if (Length==-1)
|
|
break;
|
|
CopyString(Length+4,1);
|
|
continue;
|
|
}
|
|
// If we are here, NextCh must be 1, what means that current byte
|
|
// is equal to our 'escape' byte, so we just store it to Window.
|
|
}
|
|
Window[UnpPtr++]=Ch;
|
|
continue;
|
|
}
|
|
|
|
uint Number=DecodeNumber(Inp,&BlockTables.LD);
|
|
if (Number<256)
|
|
{
|
|
Window[UnpPtr++]=(byte)Number;
|
|
continue;
|
|
}
|
|
if (Number>=271)
|
|
{
|
|
uint Length=LDecode[Number-=271]+3;
|
|
if ((Bits=LBits[Number])>0)
|
|
{
|
|
Length+=Inp.getbits()>>(16-Bits);
|
|
Inp.addbits(Bits);
|
|
}
|
|
|
|
uint DistNumber=DecodeNumber(Inp,&BlockTables.DD);
|
|
uint Distance=DDecode[DistNumber]+1;
|
|
if ((Bits=DBits[DistNumber])>0)
|
|
{
|
|
if (DistNumber>9)
|
|
{
|
|
if (Bits>4)
|
|
{
|
|
Distance+=((Inp.getbits()>>(20-Bits))<<4);
|
|
Inp.addbits(Bits-4);
|
|
}
|
|
if (LowDistRepCount>0)
|
|
{
|
|
LowDistRepCount--;
|
|
Distance+=PrevLowDist;
|
|
}
|
|
else
|
|
{
|
|
uint LowDist=DecodeNumber(Inp,&BlockTables.LDD);
|
|
if (LowDist==16)
|
|
{
|
|
LowDistRepCount=LOW_DIST_REP_COUNT-1;
|
|
Distance+=PrevLowDist;
|
|
}
|
|
else
|
|
{
|
|
Distance+=LowDist;
|
|
PrevLowDist=LowDist;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Distance+=Inp.getbits()>>(16-Bits);
|
|
Inp.addbits(Bits);
|
|
}
|
|
}
|
|
|
|
if (Distance>=0x2000)
|
|
{
|
|
Length++;
|
|
if (Distance>=0x40000)
|
|
Length++;
|
|
}
|
|
|
|
InsertOldDist(Distance);
|
|
LastLength=Length;
|
|
CopyString(Length,Distance);
|
|
continue;
|
|
}
|
|
if (Number==256)
|
|
{
|
|
if (!ReadEndOfBlock())
|
|
break;
|
|
continue;
|
|
}
|
|
if (Number==257)
|
|
{
|
|
if (!ReadVMCode())
|
|
break;
|
|
continue;
|
|
}
|
|
if (Number==258)
|
|
{
|
|
if (LastLength!=0)
|
|
CopyString(LastLength,OldDist[0]);
|
|
continue;
|
|
}
|
|
if (Number<263)
|
|
{
|
|
uint DistNum=Number-259;
|
|
uint Distance=OldDist[DistNum];
|
|
for (uint I=DistNum;I>0;I--)
|
|
OldDist[I]=OldDist[I-1];
|
|
OldDist[0]=Distance;
|
|
|
|
uint LengthNumber=DecodeNumber(Inp,&BlockTables.RD);
|
|
int Length=LDecode[LengthNumber]+2;
|
|
if ((Bits=LBits[LengthNumber])>0)
|
|
{
|
|
Length+=Inp.getbits()>>(16-Bits);
|
|
Inp.addbits(Bits);
|
|
}
|
|
LastLength=Length;
|
|
CopyString(Length,Distance);
|
|
continue;
|
|
}
|
|
if (Number<272)
|
|
{
|
|
uint Distance=SDDecode[Number-=263]+1;
|
|
if ((Bits=SDBits[Number])>0)
|
|
{
|
|
Distance+=Inp.getbits()>>(16-Bits);
|
|
Inp.addbits(Bits);
|
|
}
|
|
InsertOldDist(Distance);
|
|
LastLength=2;
|
|
CopyString(2,Distance);
|
|
continue;
|
|
}
|
|
}
|
|
UnpWriteBuf30();
|
|
}
|
|
|
|
|
|
// Return 'false' to quit unpacking the current file or 'true' to continue.
|
|
bool Unpack::ReadEndOfBlock()
|
|
{
|
|
uint BitField=Inp.getbits();
|
|
bool NewTable,NewFile=false;
|
|
|
|
// "1" - no new file, new table just here.
|
|
// "00" - new file, no new table.
|
|
// "01" - new file, new table (in beginning of next file).
|
|
|
|
if ((BitField & 0x8000)!=0)
|
|
{
|
|
NewTable=true;
|
|
Inp.addbits(1);
|
|
}
|
|
else
|
|
{
|
|
NewFile=true;
|
|
NewTable=(BitField & 0x4000)!=0;
|
|
Inp.addbits(2);
|
|
}
|
|
TablesRead3=!NewTable;
|
|
|
|
// Quit immediately if "new file" flag is set. If "new table" flag
|
|
// is present, we'll read the table in beginning of next file
|
|
// based on 'TablesRead3' 'false' value.
|
|
if (NewFile)
|
|
return false;
|
|
return ReadTables30(); // Quit only if we failed to read tables.
|
|
}
|
|
|
|
|
|
bool Unpack::ReadVMCode()
|
|
{
|
|
// Entire VM code is guaranteed to fully present in block defined
|
|
// by current Huffman table. Compressor checks that VM code does not cross
|
|
// Huffman block boundaries.
|
|
uint FirstByte=Inp.getbits()>>8;
|
|
Inp.addbits(8);
|
|
uint Length=(FirstByte & 7)+1;
|
|
if (Length==7)
|
|
{
|
|
Length=(Inp.getbits()>>8)+7;
|
|
Inp.addbits(8);
|
|
}
|
|
else
|
|
if (Length==8)
|
|
{
|
|
Length=Inp.getbits();
|
|
Inp.addbits(16);
|
|
}
|
|
if (Length==0)
|
|
return false;
|
|
Array<byte> VMCode(Length);
|
|
for (uint I=0;I<Length;I++)
|
|
{
|
|
// Try to read the new buffer if only one byte is left.
|
|
// But if we read all bytes except the last, one byte is enough.
|
|
if (Inp.InAddr>=ReadTop-1 && !UnpReadBuf30() && I<Length-1)
|
|
return false;
|
|
VMCode[I]=Inp.getbits()>>8;
|
|
Inp.addbits(8);
|
|
}
|
|
return AddVMCode(FirstByte,&VMCode[0],Length);
|
|
}
|
|
|
|
|
|
bool Unpack::ReadVMCodePPM()
|
|
{
|
|
uint FirstByte=SafePPMDecodeChar();
|
|
if ((int)FirstByte==-1)
|
|
return false;
|
|
uint Length=(FirstByte & 7)+1;
|
|
if (Length==7)
|
|
{
|
|
int B1=SafePPMDecodeChar();
|
|
if (B1==-1)
|
|
return false;
|
|
Length=B1+7;
|
|
}
|
|
else
|
|
if (Length==8)
|
|
{
|
|
int B1=SafePPMDecodeChar();
|
|
if (B1==-1)
|
|
return false;
|
|
int B2=SafePPMDecodeChar();
|
|
if (B2==-1)
|
|
return false;
|
|
Length=B1*256+B2;
|
|
}
|
|
if (Length==0)
|
|
return false;
|
|
Array<byte> VMCode(Length);
|
|
for (uint I=0;I<Length;I++)
|
|
{
|
|
int Ch=SafePPMDecodeChar();
|
|
if (Ch==-1)
|
|
return false;
|
|
VMCode[I]=Ch;
|
|
}
|
|
return AddVMCode(FirstByte,&VMCode[0],Length);
|
|
}
|
|
|
|
|
|
bool Unpack::AddVMCode(uint FirstByte,byte *Code,uint CodeSize)
|
|
{
|
|
VMCodeInp.InitBitInput();
|
|
memcpy(VMCodeInp.InBuf,Code,Min(BitInput::MAX_SIZE,CodeSize));
|
|
VM.Init();
|
|
|
|
uint FiltPos;
|
|
if ((FirstByte & 0x80)!=0)
|
|
{
|
|
FiltPos=RarVM::ReadData(VMCodeInp);
|
|
if (FiltPos==0)
|
|
InitFilters30(false);
|
|
else
|
|
FiltPos--;
|
|
}
|
|
else
|
|
FiltPos=LastFilter; // Use the same filter as last time.
|
|
|
|
if (FiltPos>Filters30.Size() || FiltPos>OldFilterLengths.Size())
|
|
return false;
|
|
LastFilter=FiltPos;
|
|
bool NewFilter=(FiltPos==Filters30.Size());
|
|
|
|
UnpackFilter30 *StackFilter=new UnpackFilter30; // New filter for PrgStack.
|
|
|
|
UnpackFilter30 *Filter;
|
|
if (NewFilter) // New filter code, never used before since VM reset.
|
|
{
|
|
if (FiltPos>MAX3_UNPACK_FILTERS)
|
|
{
|
|
// Too many different filters, corrupt archive.
|
|
delete StackFilter;
|
|
return false;
|
|
}
|
|
|
|
Filters30.Add(1);
|
|
Filters30[Filters30.Size()-1]=Filter=new UnpackFilter30;
|
|
StackFilter->ParentFilter=(uint)(Filters30.Size()-1);
|
|
|
|
// Reserve one item to store the data block length of our new filter
|
|
// entry. We'll set it to real block length below, after reading it.
|
|
// But we need to initialize it now, because when processing corrupt
|
|
// data, we can access this item even before we set it to real value.
|
|
OldFilterLengths.Push(0);
|
|
}
|
|
else // Filter was used in the past.
|
|
{
|
|
Filter=Filters30[FiltPos];
|
|
StackFilter->ParentFilter=FiltPos;
|
|
}
|
|
|
|
uint EmptyCount=0;
|
|
for (uint I=0;I<PrgStack.Size();I++)
|
|
{
|
|
PrgStack[I-EmptyCount]=PrgStack[I];
|
|
if (PrgStack[I]==NULL)
|
|
EmptyCount++;
|
|
if (EmptyCount>0)
|
|
PrgStack[I]=NULL;
|
|
}
|
|
if (EmptyCount==0)
|
|
{
|
|
if (PrgStack.Size()>MAX3_UNPACK_FILTERS)
|
|
{
|
|
delete StackFilter;
|
|
return false;
|
|
}
|
|
PrgStack.Add(1);
|
|
EmptyCount=1;
|
|
}
|
|
size_t StackPos=PrgStack.Size()-EmptyCount;
|
|
PrgStack[StackPos]=StackFilter;
|
|
|
|
uint BlockStart=RarVM::ReadData(VMCodeInp);
|
|
if ((FirstByte & 0x40)!=0)
|
|
BlockStart+=258;
|
|
StackFilter->BlockStart=(uint)((BlockStart+UnpPtr)&MaxWinMask);
|
|
if ((FirstByte & 0x20)!=0)
|
|
{
|
|
StackFilter->BlockLength=RarVM::ReadData(VMCodeInp);
|
|
|
|
// Store the last data block length for current filter.
|
|
OldFilterLengths[FiltPos]=StackFilter->BlockLength;
|
|
}
|
|
else
|
|
{
|
|
// Set the data block size to same value as the previous block size
|
|
// for same filter. It is possible for corrupt data to access a new
|
|
// and not filled yet item of OldFilterLengths array here. This is why
|
|
// we set new OldFilterLengths items to zero above.
|
|
StackFilter->BlockLength=FiltPos<OldFilterLengths.Size() ? OldFilterLengths[FiltPos]:0;
|
|
}
|
|
|
|
StackFilter->NextWindow=WrPtr!=UnpPtr && ((WrPtr-UnpPtr)&MaxWinMask)<=BlockStart;
|
|
|
|
// DebugLog("\nNextWindow: UnpPtr=%08x WrPtr=%08x BlockStart=%08x",UnpPtr,WrPtr,BlockStart);
|
|
|
|
memset(StackFilter->Prg.InitR,0,sizeof(StackFilter->Prg.InitR));
|
|
StackFilter->Prg.InitR[4]=StackFilter->BlockLength;
|
|
|
|
if ((FirstByte & 0x10)!=0) // Set registers to optional parameters if any.
|
|
{
|
|
uint InitMask=VMCodeInp.fgetbits()>>9;
|
|
VMCodeInp.faddbits(7);
|
|
for (uint I=0;I<7;I++)
|
|
if (InitMask & (1<<I))
|
|
StackFilter->Prg.InitR[I]=RarVM::ReadData(VMCodeInp);
|
|
}
|
|
|
|
if (NewFilter)
|
|
{
|
|
uint VMCodeSize=RarVM::ReadData(VMCodeInp);
|
|
if (VMCodeSize>=0x10000 || VMCodeSize==0 || VMCodeInp.InAddr+VMCodeSize>CodeSize)
|
|
return false;
|
|
Array<byte> VMCode(VMCodeSize);
|
|
for (uint I=0;I<VMCodeSize;I++)
|
|
{
|
|
if (VMCodeInp.Overflow(3))
|
|
return false;
|
|
VMCode[I]=VMCodeInp.fgetbits()>>8;
|
|
VMCodeInp.faddbits(8);
|
|
}
|
|
VM.Prepare(&VMCode[0],VMCodeSize,&Filter->Prg);
|
|
}
|
|
StackFilter->Prg.Type=Filter->Prg.Type;
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool Unpack::UnpReadBuf30()
|
|
{
|
|
int DataSize=ReadTop-Inp.InAddr; // Data left to process.
|
|
if (DataSize<0)
|
|
return false;
|
|
if (Inp.InAddr>BitInput::MAX_SIZE/2)
|
|
{
|
|
// If we already processed more than half of buffer, let's move
|
|
// remaining data into beginning to free more space for new data
|
|
// and ensure that calling function does not cross the buffer border
|
|
// even if we did not read anything here. Also it ensures that read size
|
|
// is not less than CRYPT_BLOCK_SIZE, so we can align it without risk
|
|
// to make it zero.
|
|
if (DataSize>0)
|
|
memmove(Inp.InBuf,Inp.InBuf+Inp.InAddr,DataSize);
|
|
Inp.InAddr=0;
|
|
ReadTop=DataSize;
|
|
}
|
|
else
|
|
DataSize=ReadTop;
|
|
int ReadCode=UnpIO->UnpRead(Inp.InBuf+DataSize,BitInput::MAX_SIZE-DataSize);
|
|
if (ReadCode>0)
|
|
ReadTop+=ReadCode;
|
|
ReadBorder=ReadTop-30;
|
|
return ReadCode!=-1;
|
|
}
|
|
|
|
|
|
void Unpack::UnpWriteBuf30()
|
|
{
|
|
uint WrittenBorder=(uint)WrPtr;
|
|
uint WriteSize=(uint)((UnpPtr-WrittenBorder)&MaxWinMask);
|
|
for (size_t I=0;I<PrgStack.Size();I++)
|
|
{
|
|
// Here we apply filters to data which we need to write.
|
|
// We always copy data to virtual machine memory before processing.
|
|
// We cannot process them just in place in Window buffer, because
|
|
// these data can be used for future string matches, so we must
|
|
// preserve them in original form.
|
|
|
|
UnpackFilter30 *flt=PrgStack[I];
|
|
if (flt==NULL)
|
|
continue;
|
|
if (flt->NextWindow)
|
|
{
|
|
flt->NextWindow=false;
|
|
continue;
|
|
}
|
|
unsigned int BlockStart=flt->BlockStart;
|
|
unsigned int BlockLength=flt->BlockLength;
|
|
if (((BlockStart-WrittenBorder)&MaxWinMask)<WriteSize)
|
|
{
|
|
if (WrittenBorder!=BlockStart)
|
|
{
|
|
UnpWriteArea(WrittenBorder,BlockStart);
|
|
WrittenBorder=BlockStart;
|
|
WriteSize=(uint)((UnpPtr-WrittenBorder)&MaxWinMask);
|
|
}
|
|
if (BlockLength<=WriteSize)
|
|
{
|
|
uint BlockEnd=(BlockStart+BlockLength)&MaxWinMask;
|
|
if (BlockStart<BlockEnd || BlockEnd==0)
|
|
VM.SetMemory(0,Window+BlockStart,BlockLength);
|
|
else
|
|
{
|
|
uint FirstPartLength=uint(MaxWinSize-BlockStart);
|
|
VM.SetMemory(0,Window+BlockStart,FirstPartLength);
|
|
VM.SetMemory(FirstPartLength,Window,BlockEnd);
|
|
}
|
|
|
|
VM_PreparedProgram *ParentPrg=&Filters30[flt->ParentFilter]->Prg;
|
|
VM_PreparedProgram *Prg=&flt->Prg;
|
|
|
|
ExecuteCode(Prg);
|
|
|
|
byte *FilteredData=Prg->FilteredData;
|
|
unsigned int FilteredDataSize=Prg->FilteredDataSize;
|
|
|
|
delete PrgStack[I];
|
|
PrgStack[I]=NULL;
|
|
while (I+1<PrgStack.Size())
|
|
{
|
|
UnpackFilter30 *NextFilter=PrgStack[I+1];
|
|
// It is required to check NextWindow here.
|
|
if (NextFilter==NULL || NextFilter->BlockStart!=BlockStart ||
|
|
NextFilter->BlockLength!=FilteredDataSize || NextFilter->NextWindow)
|
|
break;
|
|
|
|
// Apply several filters to same data block.
|
|
|
|
VM.SetMemory(0,FilteredData,FilteredDataSize);
|
|
|
|
VM_PreparedProgram *ParentPrg=&Filters30[NextFilter->ParentFilter]->Prg;
|
|
VM_PreparedProgram *NextPrg=&NextFilter->Prg;
|
|
|
|
ExecuteCode(NextPrg);
|
|
|
|
FilteredData=NextPrg->FilteredData;
|
|
FilteredDataSize=NextPrg->FilteredDataSize;
|
|
I++;
|
|
delete PrgStack[I];
|
|
PrgStack[I]=NULL;
|
|
}
|
|
UnpIO->UnpWrite(FilteredData,FilteredDataSize);
|
|
UnpSomeRead=true;
|
|
WrittenFileSize+=FilteredDataSize;
|
|
WrittenBorder=BlockEnd;
|
|
WriteSize=uint((UnpPtr-WrittenBorder)&MaxWinMask);
|
|
}
|
|
else
|
|
{
|
|
// Current filter intersects the window write border, so we adjust
|
|
// the window border to process this filter next time, not now.
|
|
for (size_t J=I;J<PrgStack.Size();J++)
|
|
{
|
|
UnpackFilter30 *flt=PrgStack[J];
|
|
if (flt!=NULL && flt->NextWindow)
|
|
flt->NextWindow=false;
|
|
}
|
|
WrPtr=WrittenBorder;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
UnpWriteArea(WrittenBorder,UnpPtr);
|
|
WrPtr=UnpPtr;
|
|
}
|
|
|
|
|
|
void Unpack::ExecuteCode(VM_PreparedProgram *Prg)
|
|
{
|
|
Prg->InitR[6]=(uint)WrittenFileSize;
|
|
VM.Execute(Prg);
|
|
}
|
|
|
|
|
|
bool Unpack::ReadTables30()
|
|
{
|
|
byte BitLength[BC];
|
|
byte Table[HUFF_TABLE_SIZE30];
|
|
if (Inp.InAddr>ReadTop-25)
|
|
if (!UnpReadBuf30())
|
|
return(false);
|
|
Inp.faddbits((8-Inp.InBit)&7);
|
|
uint BitField=Inp.fgetbits();
|
|
if (BitField & 0x8000)
|
|
{
|
|
UnpBlockType=BLOCK_PPM;
|
|
return(PPM.DecodeInit(this,PPMEscChar));
|
|
}
|
|
UnpBlockType=BLOCK_LZ;
|
|
|
|
PrevLowDist=0;
|
|
LowDistRepCount=0;
|
|
|
|
if (!(BitField & 0x4000))
|
|
memset(UnpOldTable,0,sizeof(UnpOldTable));
|
|
Inp.faddbits(2);
|
|
|
|
for (uint I=0;I<BC;I++)
|
|
{
|
|
uint Length=(byte)(Inp.fgetbits() >> 12);
|
|
Inp.faddbits(4);
|
|
if (Length==15)
|
|
{
|
|
uint ZeroCount=(byte)(Inp.fgetbits() >> 12);
|
|
Inp.faddbits(4);
|
|
if (ZeroCount==0)
|
|
BitLength[I]=15;
|
|
else
|
|
{
|
|
ZeroCount+=2;
|
|
while (ZeroCount-- > 0 && I<ASIZE(BitLength))
|
|
BitLength[I++]=0;
|
|
I--;
|
|
}
|
|
}
|
|
else
|
|
BitLength[I]=Length;
|
|
}
|
|
MakeDecodeTables(BitLength,&BlockTables.BD,BC30);
|
|
|
|
const uint TableSize=HUFF_TABLE_SIZE30;
|
|
for (uint I=0;I<TableSize;)
|
|
{
|
|
if (Inp.InAddr>ReadTop-5)
|
|
if (!UnpReadBuf30())
|
|
return(false);
|
|
uint Number=DecodeNumber(Inp,&BlockTables.BD);
|
|
if (Number<16)
|
|
{
|
|
Table[I]=(Number+UnpOldTable[I]) & 0xf;
|
|
I++;
|
|
}
|
|
else
|
|
if (Number<18)
|
|
{
|
|
uint N;
|
|
if (Number==16)
|
|
{
|
|
N=(Inp.fgetbits() >> 13)+3;
|
|
Inp.faddbits(3);
|
|
}
|
|
else
|
|
{
|
|
N=(Inp.fgetbits() >> 9)+11;
|
|
Inp.faddbits(7);
|
|
}
|
|
if (I==0)
|
|
return false; // We cannot have "repeat previous" code at the first position.
|
|
else
|
|
while (N-- > 0 && I<TableSize)
|
|
{
|
|
Table[I]=Table[I-1];
|
|
I++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
uint N;
|
|
if (Number==18)
|
|
{
|
|
N=(Inp.fgetbits() >> 13)+3;
|
|
Inp.faddbits(3);
|
|
}
|
|
else
|
|
{
|
|
N=(Inp.fgetbits() >> 9)+11;
|
|
Inp.faddbits(7);
|
|
}
|
|
while (N-- > 0 && I<TableSize)
|
|
Table[I++]=0;
|
|
}
|
|
}
|
|
TablesRead3=true;
|
|
if (Inp.InAddr>ReadTop)
|
|
return false;
|
|
MakeDecodeTables(&Table[0],&BlockTables.LD,NC30);
|
|
MakeDecodeTables(&Table[NC30],&BlockTables.DD,DC30);
|
|
MakeDecodeTables(&Table[NC30+DC30],&BlockTables.LDD,LDC30);
|
|
MakeDecodeTables(&Table[NC30+DC30+LDC30],&BlockTables.RD,RC30);
|
|
memcpy(UnpOldTable,Table,sizeof(UnpOldTable));
|
|
return true;
|
|
}
|
|
|
|
|
|
void Unpack::UnpInitData30(bool Solid)
|
|
{
|
|
if (!Solid)
|
|
{
|
|
TablesRead3=false;
|
|
memset(UnpOldTable,0,sizeof(UnpOldTable));
|
|
PPMEscChar=2;
|
|
UnpBlockType=BLOCK_LZ;
|
|
}
|
|
InitFilters30(Solid);
|
|
}
|
|
|
|
|
|
void Unpack::InitFilters30(bool Solid)
|
|
{
|
|
if (!Solid)
|
|
{
|
|
OldFilterLengths.SoftReset();
|
|
LastFilter=0;
|
|
|
|
for (size_t I=0;I<Filters30.Size();I++)
|
|
delete Filters30[I];
|
|
Filters30.SoftReset();
|
|
}
|
|
for (size_t I=0;I<PrgStack.Size();I++)
|
|
delete PrgStack[I];
|
|
PrgStack.SoftReset();
|
|
}
|