dctblk.cc

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

      if (! (val & 0x7f)) {
	DUMPBITS (bit_buf, bits, 8);
	val = UBITS (bit_buf, 8) + 2 * val;
      }
      val = DequantizeInter(val + SBITS (val, 1),quantizer_scale,quant_matrix[i]);

      Saturate (val);
      coeff[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 |= bs.GetNextWord() << (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);
}


static void get_intra_block_B14(class FastBitBuf& bs,short* coeff,const int* scan,
				int quantizer_scale,
				const int* quant_matrix)
{
  int i;
  int j;
  int val;
  int mismatch;
  DCTtabb * tab;
  uint32 bit_buf;
  int bits;

  i = 0;
  mismatch = ~coeff[0];

  bs.MakeLocalCopy(bit_buf,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 = DequantizeIntra(tab->level , quantizer_scale , quant_matrix[i]);

      // if (bitstream_get (1)) val = -val;
      val = (val ^ SBITS (bit_buf, 1)) - SBITS (bit_buf, 1);

      Saturate (val);
      coeff[j] = val;
      mismatch ^= 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 = DequantizeIntra(SBITS (bit_buf, 12) , quantizer_scale , quant_matrix[i]);

      Saturate(val);
      coeff[j] = val;
      mismatch ^= val;

      DUMPBITS (bit_buf, bits, 12);
      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 |= bs.GetNextWord () << (bits + 16);
      i += tab->run;
      if (i < 64)
	goto normal_code;
    }
    break;  // illegal, but check needed to avoid buffer overflow
  }
  coeff[63] ^= mismatch & 1;
  DUMPBITS (bit_buf, bits, 2);        // dump end of block code
  bs.RestoreFromLocal(bit_buf,bits);
}


static void get_intra_block_B15(class FastBitBuf& bs,short* coeff,const int* scan,
				int quantizer_scale,
				const int* quant_matrix)
{
  int i;
  int j;
  int val;
  int mismatch;
  DCTtabb * tab;
  uint32 bit_buf;
  int bits;

  i = 0;
  mismatch = ~coeff[0];

  bs.MakeLocalCopy(bit_buf,bits);

  NEEDBITS (bit_buf, bits);

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

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

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

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

	// if (bitstream_get (1)) val = -val;
	val = (val ^ SBITS (bit_buf, 1)) - SBITS (bit_buf, 1);

	Saturate(val);
	coeff[j] = val;
	mismatch ^= val;

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

	continue;

      } else {

	// end of block. I commented out this code because if we
	// dont exit here we will still exit at the later test :)

	//if (i >= 128) break;  // end of block

	// escape code

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

	j = scan[i];

	DUMPBITS (bit_buf, bits, 12);
	NEEDBITS (bit_buf, bits);
	val = DequantizeIntra(SBITS (bit_buf, 12) , quantizer_scale , quant_matrix[i]);

	Saturate(val);
	coeff[j] = val;
	mismatch ^= val;

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

	continue;

      }
    } else if (bit_buf >= 0x02000000) {
      tab = DCT_B15_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 |= bs.GetNextWord() << (bits + 16);
      i += tab->run;
      if (i < 64)
	goto normal_code;
    }
    break;  // illegal, but check needed to avoid buffer overflow
  }
  coeff[63] ^= mismatch & 1;
  DUMPBITS (bit_buf, bits, 4);        // dump end of block code
  bs.RestoreFromLocal(bit_buf,bits);
}


static void get_non_intra_block(class FastBitBuf& bs,short* coeff,const int* scan,
				int quantizer_scale,
				const int* quant_matrix)
{
  int i;
  int j;
  int val;
  int mismatch;
  DCTtabb * tab;
  uint32 bit_buf;
  int bits;

  i = -1;
  mismatch = 1;

  bs.MakeLocalCopy(bit_buf,bits);

  NEEDBITS (bit_buf, bits);
  if (bit_buf >= 0x28000000) {
    tab = DCT_B14DC_5 - 5 + UBITS (bit_buf, 5);
    goto entry_1;
  } else
    goto entry_2;

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

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

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

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

      // if (bitstream_get (1)) val = -val;
      val = (val ^ SBITS (bit_buf, 1)) - SBITS (bit_buf, 1);

      Saturate(val);
      coeff[j] = val;
      mismatch ^= val;

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

      continue;

    }

  entry_2:
    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 = DequantizeInter(SBITS (bit_buf, 12) + SBITS (bit_buf, 1) , quantizer_scale, quant_matrix[i]);

      Saturate(val);
      coeff[j] = val;
      mismatch ^= val;

      DUMPBITS (bit_buf, bits, 12);
      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 |= bs.GetNextWord () << (bits + 16);
      i += tab->run;
      if (i < 64)
	goto normal_code;
    }
    break;  // illegal, but check needed to avoid buffer overflow
  }
  coeff[63] ^= mismatch & 1;
  DUMPBITS (bit_buf, bits, 2);        // dump end of block code
  bs.RestoreFromLocal(bit_buf,bits);
}