#include "rar.hpp"

void Unpack::CopyString20(uint Length,uint Distance)

{

  LastDist=OldDist[OldDistPtr++]=Distance;

  OldDistPtr = OldDistPtr & 3; // Needed if RAR 1.5 file is called after RAR 2.0.

  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;

}