vlc.cc

PIXIL is a small footprint operating environment, complete with PDA PIM applications, a browser and

  { 4, 2,  "11111101s" },
  { 5, 2,  "000000100s" },
  {14, 1,  "000000101s" },
  {15, 1,  "000000111s" },
  {16, 1,  "0000001101s" },
  { 0, 8,  "1111011s" },
  { 0, 9,  "1111100s" },
  { 0,10,  "00100011s" },
  { 0,11,  "00100010s" },
  { 1, 5,  "00100000s" },
  { 2, 4,  "0000001100s" },
  { 3, 3,  "000000011100s" },
  { 4, 3,  "000000010010s" },
  { 6, 2,  "000000011110s" },
  { 7, 2,  "000000010101s" },
  { 8, 2,  "000000010001s" },
  {17, 1,  "000000011111s" },
  {18, 1,  "000000011010s" },
  {19, 1,  "000000011001s" },
  {20, 1,  "000000010111s" },
  {21, 1,  "000000010110s" },
  { 0,12,  "11111010s" },
  { 0,13,  "11111011s" },
  { 0,14,  "11111110s" },
  { 0,15,  "11111111s" },
  { 1, 6,  "0000000010110s" },
  { 1, 7,  "0000000010101s" },
  { 2, 5,  "0000000010100s" },
  { 3, 4,  "0000000010011s" },
  { 5, 3,  "0000000010010s" },
  { 9, 2,  "0000000010001s" },
  {10, 2,  "0000000010000s" },
  {22, 1,  "0000000011111s" },
  {23, 1,  "0000000011110s" },
  {24, 1,  "0000000011101s" },
  {25, 1,  "0000000011100s" },
  {26, 1,  "0000000011011s" },
  { 0,16,  "00000000011111s" },
  { 0,17,  "00000000011110s" },
  { 0,18,  "00000000011101s" },
  { 0,19,  "00000000011100s" },
  { 0,20,  "00000000011011s" },
  { 0,21,  "00000000011010s" },
  { 0,22,  "00000000011001s" },
  { 0,23,  "00000000011000s" },
  { 0,24,  "00000000010111s" },
  { 0,25,  "00000000010110s" },
  { 0,26,  "00000000010101s" },
  { 0,27,  "00000000010100s" },
  { 0,28,  "00000000010011s" },
  { 0,29,  "00000000010010s" },
  { 0,30,  "00000000010001s" },
  { 0,31,  "00000000010000s" },
  { 0,32,  "000000000011000s" },
  { 0,33,  "000000000010111s" },
  { 0,34,  "000000000010110s" },
  { 0,35,  "000000000010101s" },
  { 0,36,  "000000000010100s" },
  { 0,37,  "000000000010011s" },
  { 0,38,  "000000000010010s" },
  { 0,39,  "000000000010001s" },
  { 0,40,  "000000000010000s" },
  { 1, 8,  "000000000011111s" },
  { 1, 9,  "000000000011110s" },
  { 1,10,  "000000000011101s" },
  { 1,11,  "000000000011100s" },
  { 1,12,  "000000000011011s" },
  { 1,13,  "000000000011010s" },
  { 1,14,  "000000000011001s" },
  { 1,15,  "0000000000010011s" },
  { 1,16,  "0000000000010010s" },
  { 1,17,  "0000000000010001s" },
  { 1,18,  "0000000000010000s" },
  { 6, 3,  "0000000000010100s" },
  {11, 2,  "0000000000011010s" },
  {12, 2,  "0000000000011001s" },
  {13, 2,  "0000000000011000s" },
  {14, 2,  "0000000000010111s" },
  {15, 2,  "0000000000010110s" },
  {16, 2,  "0000000000010101s" },
  {27, 1,  "0000000000011111s" },
  {28, 1,  "0000000000011110s" },
  {29, 1,  "0000000000011101s" },
  {30, 1,  "0000000000011100s" },
  {31, 1,  "0000000000011011s" },
  
  { 0,0,0 }
};


int Bin2Int(const char* s)
{
  int val=0;
  while (*s)
    {
      val<<=1;
      if (*s=='1') val++;
      s++;
    }

  return val;
}


class CoeffTabInitializer
{
public:
  CoeffTabInitializer()
  {
    for (int i=0;coeff[i].nbits;i++)
      {
	uint32 bits  = coeff[i].bits;
	int    nbits = coeff[i].nbits;

	bits <<= (17-nbits);

	Insert(coefftab_first, bits,nbits,     coeff[i].run,coeff[i].level);
	Insert(coefftab_nonfirst, bits,nbits,  coeff[i].run,coeff[i].level);

	bits |= 1<<(17-nbits);

	Insert(coefftab_first, bits,nbits,     coeff[i].run,-coeff[i].level);
	Insert(coefftab_nonfirst, bits,nbits,  coeff[i].run,-coeff[i].level);
      }

    Insert(coefftab_first,    0x2<<15,2, 0, 1);
    Insert(coefftab_first,    0x3<<15,2, 0,-1);

    Insert(coefftab_nonfirst, 0x2<<15,2, 0, 0);
    Insert(coefftab_nonfirst, 0x6<<14,3, 0, 1);
    Insert(coefftab_nonfirst, 0x7<<14,3, 0,-1);

    Insert(coefftab_first,    0x1<<11,6, 1,0);
    Insert(coefftab_nonfirst, 0x1<<11,6, 1,0);


    // B15


    for (int i=0;coeff_B15[i].bits;i++)
      {
	uint32 bits  = Bin2Int(coeff_B15[i].bits);
	int    nbits = strlen(coeff_B15[i].bits);

	bits <<= (17-nbits);
	Insert(coefftab_B15, bits,nbits,  coeff_B15[i].run, coeff_B15[i].level);
	bits |= 1<<(17-nbits);
	Insert(coefftab_B15, bits,nbits,  coeff_B15[i].run,-coeff_B15[i].level);
      }

    Insert(coefftab_B15, 0x6<<13,4, 0, 0);
    Insert(coefftab_B15, 0x1<<11,6, 1, 0);
  }

  void Insert(CoeffTab* coeff,uint32 bits,int nbits,uint8 run,int16 level)
  {
    for (int i=0 ; i < (1<<(17-nbits)) ; i++)
      {
	coeff[bits | i].run   = run;
	coeff[bits | i].level = level;
	coeff[bits | i].nbits = nbits;
      }
  }
} dummy2348756;

bool GetRunLen_old(FastBitBuf& bs,int& run,int& value ,bool B15,bool first,bool MPEG1);

/*maybeinline*/ bool GetRunLen(FastBitBuf& bs,int& run,int& value ,bool B15,bool first,bool MPEG1)
{
#if 0
  return GetRunLen_old(bs,run,value ,B15,first,MPEG1);
#endif

  uint32 code = bs.PeekBits(17);

  CoeffTab* entry;

  if (B15)
    entry = &coefftab_B15[code];
  else
    {
      if (first) entry = &coefftab_first[code];
      else       entry = &coefftab_nonfirst[code];
    }

  bs.SkipBits(entry->nbits);

  if (entry->level)
    {
      value = entry->level;
      run   = entry->run;

      return false;
    }

  if (entry->run == 0)
    {
      return true;
    }

  run = bs.GetBits(6);

  if (MPEG1)
    {
      value = bs.GetBits(8);
      if (value==0)
	value = bs.GetBits(8);
      else if (value==128)
	value = bs.GetBits(8) - 256;
      else if (value>128)
	value -= 256;
    }
  else
    {
      value = bs.GetBits(12);
      if (value==0)
	throw Excpt_Huffman(ErrSev_Warning,
			    "Invalid MPEG stream, not allowed MPEG-2 escape seq value 0 read.");

      if (value >= 0x800)
	value = -(2048-(value-0x800));
    }

  return false;
}

maybeinline bool GetRunLen_old(FastBitBuf& bs,int& run,int& value ,bool B15,bool first,bool MPEG1)
{
  uint16 code = bs.PeekBits(16);

  DCTtab* tab;

  if (!B15 && first && code&0x8000)
    {
      if (code&0x4000) value=-1;
      else             value= 1;
      run=0;

      bs.SkipBitsFast(2);
      return false;
    }

  if (code>=16384 && !B15)
    tab = &DCTtabnext[(code>>12)-4];
  else if (code>=1024)
    {
      if (B15)
        tab = &DCTtab0a[(code>>8)-4];
      else
        tab = &DCTtab0[(code>>8)-4];
    }
  else if (code>=512)
    {
      if (B15)
        tab = &DCTtab1a[(code>>6)-8];
      else
        tab = &DCTtab1[(code>>6)-8];
    }
  else if (code>=256)
    tab = &DCTtab2[(code>>4)-16];
  else if (code>=128)
    tab = &DCTtab3[(code>>3)-16];
  else if (code>=64)
    tab = &DCTtab4[(code>>2)-16];
  else if (code>=32)
    tab = &DCTtab5[(code>>1)-16];
  else if (code>=16)
    tab = &DCTtab6[code-16];
  else
    {
      MessageDisplay::Show(ErrSev_Warning,"invalid Huffman code for DCT run/level-pair");
      return false;
    }


  bs.SkipBitsFast(tab->len);

  if (tab->run==64)  // EOB
    {
      return true;
    }

  if (tab->run==65) /* escape */
    {
      if (MPEG1)
        {
          run = bs.GetBits(6);
      
          value = bs.GetBits(8);
          if (value==0)
            value = bs.GetBits(8);
          else if (value==128)
            value = bs.GetBits(8) - 256;
          else if (value>128)
            value -= 256;
        }
      else
        {
          run = bs.GetBits(6);
          value = bs.GetBits(12);
          if (value==0)
            throw Excpt_Huffman(ErrSev_Warning,
				"Invalid MPEG stream, not allowed MPEG-2 escape seq value 0 read.");

          if (value >= 0x800)
            value = -(2048-(value-0x800));
        }
    }
  else
    {
      run   = tab->run;
      value = tab->level;
      if (bs.GetBits(1))
        value = -value;
    }

  return false;
}


maybeinline bool GetRunLen_ENVELOPE(FastBitBuf& bs,int& run,int& value ,bool B15,bool first,bool MPEG1)
{
  uint32 nextbits = bs.PeekBits(20);

  for (int i=0;i<20;i++)
    {
      if (nextbits & ((1<<19)>>i)) cout << "1"; else cout << "0";
    }

  cout << " ";

  bool ret = GetRunLen_old(bs,run,value,B15,first,MPEG1);
  //bool ret = GetRunLen_new(bs,run,value,B15,first,MPEG1);
  
  cout << run << " " << value << " " << (ret ? "T" : "F") << endl;
  return ret;
}






//static void get_mpeg1_intra_block (picture_t * picture, slice_t * slice,
//                                   int16_t * dest)

#if 0
maybeinline bool GetRunLen_old(FastBitBuf& bs,int& run,int& value ,bool B15,bool first,bool MPEG1)
{
    int i;
    int j;
    int val;
    DCTtab * tab;
    uint32_t bit_buf;
    int bits;

    i = 0;

    bs.MakeLocalCopy(bit_buf,bits);
    //bit_buf = bitstream_buf;
    //bits = bitstream_bits;

    NEEDBITS (bit_buf, bits);

    while (1) {
        if (bit_buf >= 0x28000000) {

            tab = DCT_B14AC_5 - 5 + UBITS (bit_buf, 5);

            i += tab->run;
            if (i >= 64)
                break;  // end of block

        normal_code:
            j = scan[i];
            bit_buf <<= tab->len;
            bits += tab->len + 1;
            val = tab->level;
            val = (val ^ SBITS (bit_buf, 1)) - SBITS (bit_buf, 1);

            value = val;

            bit_buf <<= 1;
            NEEDBITS (bit_buf, bits);

            continue;

        } else if (bit_buf >= 0x04000000) {

            tab = DCT_B14_8 - 4 + UBITS (bit_buf, 8);

            i += tab->run;
            if (i < 64)
                goto normal_code;

            // escape code

            i += UBITS (bit_buf << 6, 6) - 64;
            if (i >= 64)
                break;  // illegal, but check needed to avoid buffer overflow

            j = scan[i];

            DUMPBITS (bit_buf, bits, 12);
            NEEDBITS (bit_buf, bits);
            val = SBITS (bit_buf, 8);
            if (! (val & 0x7f)) {
                DUMPBITS (bit_buf, bits, 8);
                val = UBITS (bit_buf, 8) + 2 * val;
            }
            val = (val * quantizer_scale * quant_matrix[j]) / 16;

            SATURATE (val);
            dest[j] = val;

            DUMPBITS (bit_buf, bits, 8);
            NEEDBITS (bit_buf, bits);

            continue;

        } else if (bit_buf >= 0x02000000) {
            tab = DCT_B14_10 - 8 + UBITS (bit_buf, 10);
            i += tab->run;
            if (i < 64)
                goto normal_code;
        } else if (bit_buf >= 0x00800000) {
            tab = DCT_13 - 16 + UBITS (bit_buf, 13);
            i += tab->run;
            if (i < 64)
                goto normal_code;
        } else if (bit_buf >= 0x00200000) {
            tab = DCT_15 - 16 + UBITS (bit_buf, 15);
            i += tab->run;
            if (i < 64)
                goto normal_code;
        } else {
            tab = DCT_16 + UBITS (bit_buf, 16);
            bit_buf <<= 16;
            bit_buf |= getword () << (bits + 16);
            i += tab->run;
            if (i < 64)
                goto normal_code;
        }
        break;  // illegal, but check needed to avoid buffer overflow
    }
    DUMPBITS (bit_buf, bits, 2);        // dump end of block code


    bs.RestoreFromLocal(bit_buf,bits);
    //bitstream_buf = bit_buf;
    //bitstream_bits = bits;
}
#endif


/************************************* initialization ********************************/

static void InitTAB(const DirectVLCTableEntry* src,DirectVLC* dest,int invalid_value)
{
  int maxbits=0;
  for (uint16 n=0; src[n].nBits>=0 ;n++)
    if (src[n].nBits>maxbits)
      maxbits=src[n].nBits;

  int size = (1<<maxbits);

  for (int i=0;i<size;i++)
    dest[i].value = invalid_value;

  for (uint16 n=0; src[n].nBits>=0 ;n++)
    if (src[n].nBits>0)
      {
        uint16 vlc_base = src[n].bits << (maxbits - src[n].nBits);
        
        for (int i=0;i<(1<<(maxbits - src[n].nBits));i++)
          {
            dest[vlc_base+i].value = n;
            dest[vlc_base+i].bits  = src[n].nBits;
          }
      }
}

static class DummyInit_23487635
{
public:
  DummyInit_23487635()
    {
      InitTAB(vlc_mbaddrinc_tab,vlc_mbaddr,-1);
      InitTAB(vlc_mbmode_P_tab,vlc_mbmode_P,0);
      InitTAB(vlc_mbmode_B_tab,vlc_mbmode_B,0);
      InitTAB(vlc_cbp_tab,vlc_cbp,-1);
      InitTAB(vlc_DClum_tab,vlc_DClum,-1);
      InitTAB(vlc_DCchrom_tab,vlc_DCchrom,-1);
      InitTAB(vlc_mcode_tab,vlc_mc,-1);
    }
} dummyinit_23845673;