| #include "rar.hpp" |
| |
| void Unpack::CopyString20(uint Length,uint Distance) |
| { |
| LastDist=OldDist[OldDistPtr++ & 3]=Distance; |
| LastLength=Length; |
| DestUnpSize-=Length; |
| CopyString(Length,Distance); |
| } |
| |
| |
| void Unpack::Unpack20(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 uint DDecode[]={0,1,2,3,4,6,8,12,16,24,32,48,64,96,128,192,256,384,512,768,1024,1536,2048,3072,4096,6144,8192,12288,16384,24576,32768U,49152U,65536,98304,131072,196608,262144,327680,393216,458752,524288,589824,655360,720896,786432,851968,917504,983040}; |
| static unsigned char DBits[]= {0,0,0,0,1,1,2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16}; |
| static unsigned char SDDecode[]={0,4,8,16,32,64,128,192}; |
| static unsigned char SDBits[]= {2,2,3, 4, 5, 6, 6, 6}; |
| uint Bits; |
| |
| if (Suspended) |
| UnpPtr=WrPtr; |
| else |
| { |
| UnpInitData(Solid); |
| if (!UnpReadBuf()) |
| return; |
| if ((!Solid || !TablesRead2) && !ReadTables20()) |
| return; |
| --DestUnpSize; |
| } |
| |
| while (DestUnpSize>=0) |
| { |
| UnpPtr&=MaxWinMask; |
| |
| if (Inp.InAddr>ReadTop-30) |
| if (!UnpReadBuf()) |
| break; |
| if (((WrPtr-UnpPtr) & MaxWinMask)<270 && WrPtr!=UnpPtr) |
| { |
| UnpWriteBuf20(); |
| if (Suspended) |
| return; |
| } |
| if (UnpAudioBlock) |
| { |
| uint AudioNumber=DecodeNumber(Inp,&MD[UnpCurChannel]); |
| |
| if (AudioNumber==256) |
| { |
| if (!ReadTables20()) |
| break; |
| continue; |
| } |
| Window[UnpPtr++]=DecodeAudio((int)AudioNumber); |
| if (++UnpCurChannel==UnpChannels) |
| UnpCurChannel=0; |
| --DestUnpSize; |
| continue; |
| } |
| |
| uint Number=DecodeNumber(Inp,&BlockTables.LD); |
| if (Number<256) |
| { |
| Window[UnpPtr++]=(byte)Number; |
| --DestUnpSize; |
| continue; |
| } |
| if (Number>269) |
| { |
| uint Length=LDecode[Number-=270]+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) |
| { |
| Distance+=Inp.getbits()>>(16-Bits); |
| Inp.addbits(Bits); |
| } |
| |
| if (Distance>=0x2000) |
| { |
| Length++; |
| if (Distance>=0x40000L) |
| Length++; |
| } |
| |
| CopyString20(Length,Distance); |
| continue; |
| } |
| if (Number==269) |
| { |
| if (!ReadTables20()) |
| break; |
| continue; |
| } |
| if (Number==256) |
| { |
| CopyString20(LastLength,LastDist); |
| continue; |
| } |
| if (Number<261) |
| { |
| uint Distance=OldDist[(OldDistPtr-(Number-256)) & 3]; |
| uint LengthNumber=DecodeNumber(Inp,&BlockTables.RD); |
| uint Length=LDecode[LengthNumber]+2; |
| if ((Bits=LBits[LengthNumber])>0) |
| { |
| Length+=Inp.getbits()>>(16-Bits); |
| Inp.addbits(Bits); |
| } |
| if (Distance>=0x101) |
| { |
| Length++; |
| if (Distance>=0x2000) |
| { |
| Length++; |
| if (Distance>=0x40000) |
| Length++; |
| } |
| } |
| CopyString20(Length,Distance); |
| continue; |
| } |
| if (Number<270) |
| { |
| uint Distance=SDDecode[Number-=261]+1; |
| if ((Bits=SDBits[Number])>0) |
| { |
| Distance+=Inp.getbits()>>(16-Bits); |
| Inp.addbits(Bits); |
| } |
| CopyString20(2,Distance); |
| continue; |
| } |
| } |
| ReadLastTables(); |
| UnpWriteBuf20(); |
| } |
| |
| |
| void Unpack::UnpWriteBuf20() |
| { |
| if (UnpPtr!=WrPtr) |
| UnpSomeRead=true; |
| if (UnpPtr<WrPtr) |
| { |
| UnpIO->UnpWrite(&Window[WrPtr],-(int)WrPtr & MaxWinMask); |
| UnpIO->UnpWrite(Window,UnpPtr); |
| UnpAllBuf=true; |
| } |
| else |
| UnpIO->UnpWrite(&Window[WrPtr],UnpPtr-WrPtr); |
| WrPtr=UnpPtr; |
| } |
| |
| |
| bool Unpack::ReadTables20() |
| { |
| byte BitLength[BC20]; |
| byte Table[MC20*4]; |
| if (Inp.InAddr>ReadTop-25) |
| if (!UnpReadBuf()) |
| return false; |
| uint BitField=Inp.getbits(); |
| UnpAudioBlock=(BitField & 0x8000)!=0; |
| |
| if (!(BitField & 0x4000)) |
| memset(UnpOldTable20,0,sizeof(UnpOldTable20)); |
| Inp.addbits(2); |
| |
| uint TableSize; |
| if (UnpAudioBlock) |
| { |
| UnpChannels=((BitField>>12) & 3)+1; |
| if (UnpCurChannel>=UnpChannels) |
| UnpCurChannel=0; |
| Inp.addbits(2); |
| TableSize=MC20*UnpChannels; |
| } |
| else |
| TableSize=NC20+DC20+RC20; |
| |
| for (uint I=0;I<BC20;I++) |
| { |
| BitLength[I]=(byte)(Inp.getbits() >> 12); |
| Inp.addbits(4); |
| } |
| MakeDecodeTables(BitLength,&BlockTables.BD,BC20); |
| for (uint I=0;I<TableSize;) |
| { |
| if (Inp.InAddr>ReadTop-5) |
| if (!UnpReadBuf()) |
| return false; |
| uint Number=DecodeNumber(Inp,&BlockTables.BD); |
| if (Number<16) |
| { |
| Table[I]=(Number+UnpOldTable20[I]) & 0xf; |
| I++; |
| } |
| else |
| if (Number==16) |
| { |
| uint N=(Inp.getbits() >> 14)+3; |
| Inp.addbits(2); |
| 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==17) |
| { |
| N=(Inp.getbits() >> 13)+3; |
| Inp.addbits(3); |
| } |
| else |
| { |
| N=(Inp.getbits() >> 9)+11; |
| Inp.addbits(7); |
| } |
| while (N-- > 0 && I<TableSize) |
| Table[I++]=0; |
| } |
| } |
| TablesRead2=true; |
| if (Inp.InAddr>ReadTop) |
| return true; |
| if (UnpAudioBlock) |
| for (uint I=0;I<UnpChannels;I++) |
| MakeDecodeTables(&Table[I*MC20],&MD[I],MC20); |
| else |
| { |
| MakeDecodeTables(&Table[0],&BlockTables.LD,NC20); |
| MakeDecodeTables(&Table[NC20],&BlockTables.DD,DC20); |
| MakeDecodeTables(&Table[NC20+DC20],&BlockTables.RD,RC20); |
| } |
| memcpy(UnpOldTable20,Table,TableSize); |
| return true; |
| } |
| |
| |
| void Unpack::ReadLastTables() |
| { |
| if (ReadTop>=Inp.InAddr+5) |
| { |
| if (UnpAudioBlock) |
| { |
| if (DecodeNumber(Inp,&MD[UnpCurChannel])==256) |
| ReadTables20(); |
| } |
| else |
| if (DecodeNumber(Inp,&BlockTables.LD)==269) |
| ReadTables20(); |
| } |
| } |
| |
| |
| void Unpack::UnpInitData20(int Solid) |
| { |
| if (!Solid) |
| { |
| TablesRead2=false; |
| UnpAudioBlock=false; |
| UnpChannelDelta=0; |
| UnpCurChannel=0; |
| UnpChannels=1; |
| |
| memset(AudV,0,sizeof(AudV)); |
| memset(UnpOldTable20,0,sizeof(UnpOldTable20)); |
| memset(MD,0,sizeof(MD)); |
| } |
| } |
| |
| |
| byte Unpack::DecodeAudio(int Delta) |
| { |
| struct AudioVariables *V=&AudV[UnpCurChannel]; |
| V->ByteCount++; |
| V->D4=V->D3; |
| V->D3=V->D2; |
| V->D2=V->LastDelta-V->D1; |
| V->D1=V->LastDelta; |
| int PCh=8*V->LastChar+V->K1*V->D1+V->K2*V->D2+V->K3*V->D3+V->K4*V->D4+V->K5*UnpChannelDelta; |
| PCh=(PCh>>3) & 0xFF; |
| |
| uint Ch=PCh-Delta; |
| |
| int D=(signed char)Delta; |
| // Left shift of negative value is undefined behavior in C++, |
| // so we cast it to unsigned to follow the standard. |
| D=(uint)D<<3; |
| |
| V->Dif[0]+=abs(D); |
| V->Dif[1]+=abs(D-V->D1); |
| V->Dif[2]+=abs(D+V->D1); |
| V->Dif[3]+=abs(D-V->D2); |
| V->Dif[4]+=abs(D+V->D2); |
| V->Dif[5]+=abs(D-V->D3); |
| V->Dif[6]+=abs(D+V->D3); |
| V->Dif[7]+=abs(D-V->D4); |
| V->Dif[8]+=abs(D+V->D4); |
| V->Dif[9]+=abs(D-UnpChannelDelta); |
| V->Dif[10]+=abs(D+UnpChannelDelta); |
| |
| UnpChannelDelta=V->LastDelta=(signed char)(Ch-V->LastChar); |
| V->LastChar=Ch; |
| |
| if ((V->ByteCount & 0x1F)==0) |
| { |
| uint MinDif=V->Dif[0],NumMinDif=0; |
| V->Dif[0]=0; |
| for (uint I=1;I<ASIZE(V->Dif);I++) |
| { |
| if (V->Dif[I]<MinDif) |
| { |
| MinDif=V->Dif[I]; |
| NumMinDif=I; |
| } |
| V->Dif[I]=0; |
| } |
| switch(NumMinDif) |
| { |
| case 1: |
| if (V->K1>=-16) |
| V->K1--; |
| break; |
| case 2: |
| if (V->K1<16) |
| V->K1++; |
| break; |
| case 3: |
| if (V->K2>=-16) |
| V->K2--; |
| break; |
| case 4: |
| if (V->K2<16) |
| V->K2++; |
| break; |
| case 5: |
| if (V->K3>=-16) |
| V->K3--; |
| break; |
| case 6: |
| if (V->K3<16) |
| V->K3++; |
| break; |
| case 7: |
| if (V->K4>=-16) |
| V->K4--; |
| break; |
| case 8: |
| if (V->K4<16) |
| V->K4++; |
| break; |
| case 9: |
| if (V->K5>=-16) |
| V->K5--; |
| break; |
| case 10: |
| if (V->K5<16) |
| V->K5++; |
| break; |
| } |
| } |
| return (byte)Ch; |
| } |
