slice.c

au1200 linux2.6.11 硬件解码mae驱动和maiplayer播放器源码

} while (0);

#define ZERO_OUT(i) \
	for (; index < i; index++)\
	{\
		pBlockData[index] = 0;\
	}\
	index++;\

// $PP
// added one more param
// used to create block data coeff for MAE
static void get_intra_block_B14 (mpeg2_decoder_t * const decoder,
								 const uint16_t * const quant_matrix,
								 short int *pBlockData)
{
    int i = 0;
    int j;
    const uint8_t * scan;
    const DCTtab * tab;
    uint32_t bit_buf;
    int bits;
    const uint8_t * bit_ptr;
#ifdef NO_PERF
    int val;
    int16_t * const dest = decoder->DCTblock;
    int mismatch = ~dest[0];
#endif //#ifdef NO_PERF

    bit_buf = decoder->bitstream_buf;
    bits = decoder->bitstream_bits;
    bit_ptr = decoder->bitstream_ptr;

    NEEDBITS (bit_buf, bits, bit_ptr);
	
	/* select our scan matrix based on type */
#ifdef NO_PERF
	if (decoder->bUseMAE)
	{
		scan = (decoder->scan_type ? my_mpeg2_scan_alt : my_mpeg2_scan_norm);
	}
	else
		scan = decoder->scan;
#else
    scan = (decoder->scan_type ? my_mpeg2_scan_alt : my_mpeg2_scan_norm);
#endif //#ifdef NO_PERF

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

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

			i += tab->run;

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

normal_code:
			j = scan[i];
			bit_buf <<= tab->len;
			bits += tab->len + 1;
#ifdef NO_PERF
			val = (tab->level * quant_matrix[j]) >> 4;
			/* if (bitstream_get (1)) val = -val; */
			val = (val ^ SBITS (bit_buf, 1)) - SBITS (bit_buf, 1);
#endif //#ifdef NO_PERF

#ifndef NO_PERF
			// $PP
			// store block data for MAE
			/**************************/
			pBlockData[j ^ 1] = (tab->level ^ SBITS (bit_buf, 1)) - SBITS (bit_buf, 1);
#endif
				
#ifdef NO_PERF			
			SATURATE (val);
			dest[j] = val;
			mismatch ^= val;
#endif //#ifdef NO_PERF

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

			continue;

		}
		else if (bit_buf >= 0x04000000)
		{

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

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

			/* escape code */

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

			j = scan[i];

			DUMPBITS (bit_buf, bits, 12);
			NEEDBITS (bit_buf, bits, bit_ptr);
#ifdef NO_PERF
			val = (SBITS (bit_buf, 12) * quant_matrix[j]) / 16;
#endif //#ifdef NO_PERF

#ifndef NO_PERF
			// $PP
			// store block data for MAE
			pBlockData[j ^ 1] = SBITS (bit_buf, 12);
#endif


#ifdef NO_PERF
			SATURATE (val);
			dest[j] = val;		
			mismatch ^= val;
#endif //#ifdef NO_PERF

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

			continue;

		} else if (bit_buf >= 0x02000000)
		{
			tab = DCT_B14_10 + (UBITS (bit_buf, 10) - 8);
			i += tab->run;
			
			if (i < 64)
				goto normal_code;
		}
		else if (bit_buf >= 0x00800000)
		{
			tab = DCT_13 + (UBITS (bit_buf, 13) - 16);
			i += tab->run;
			
			if (i < 64)
				goto normal_code;
		}
		else if (bit_buf >= 0x00200000)
		{
			tab = DCT_15 + (UBITS (bit_buf, 15) - 16);
			i += tab->run;
			
			if (i < 64)
				goto normal_code;
		}
		else
		{
			tab = DCT_16 + UBITS (bit_buf, 16);
			bit_buf <<= 16;
			GETWORD (bit_buf, bits + 16, bit_ptr);
			i += tab->run;
		
			if (i < 64)
				goto normal_code;
		}

		break;	/* illegal, check needed to avoid buffer overflow */
    }

#ifdef NO_PERF
	dest[63] ^= mismatch & 16;
#endif //#ifdef NO_PERF

    DUMPBITS (bit_buf, bits, 2);	/* dump end of block code */
    decoder->bitstream_buf = bit_buf;
    decoder->bitstream_bits = bits;
    decoder->bitstream_ptr = bit_ptr;
}


static void get_intra_block_B15 (mpeg2_decoder_t *const decoder,
								 const uint16_t *const quant_matrix,
								 short int *pBlockData)
{
    int i = 0;
    int j;
    const uint8_t * scan;
    const DCTtab * tab;
    uint32_t bit_buf;
    int bits;
    const uint8_t * bit_ptr;
#ifdef NO_PERF
    int val;
    int16_t * const dest = decoder->DCTblock;
    int mismatch = ~dest[0];
#endif //#ifdef NO_PERF

    bit_buf = decoder->bitstream_buf;
    bits = decoder->bitstream_bits;
    bit_ptr = decoder->bitstream_ptr;

    NEEDBITS (bit_buf, bits, bit_ptr);

#ifdef NO_PERF
	/* select our scan matrix based on type */
	if (decoder->bUseMAE)
	{
		scan = (decoder->scan_type ? my_mpeg2_scan_alt : my_mpeg2_scan_norm);
	}
	else
		scan = decoder->scan;
#else
 		scan = (decoder->scan_type ? my_mpeg2_scan_alt : my_mpeg2_scan_norm);
#endif //#ifdef NO_PERF
  while (1)
	{
		if (bit_buf >= 0x04000000)
		{

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

			i += tab->run;

			if (i < 64)
			{

				normal_code:
				j = scan[i];
				bit_buf <<= tab->len;
				bits += tab->len + 1;
#ifdef NO_PERF
				val = (tab->level * quant_matrix[j]) >> 4;
				/* if (bitstream_get (1)) val = -val; */
				val = (val ^ SBITS (bit_buf, 1)) - SBITS (bit_buf, 1);
#endif //#ifdef NO_PERF

#ifndef NO_PERF
				// $PP
				// store block data for MAE
				/**************************/
			   pBlockData[j ^ 1] = (tab->level ^ SBITS (bit_buf, 1)) - SBITS (bit_buf, 1);//temp;
#endif

#ifdef NO_PERF
        SATURATE (val);
				dest[j] = val;
				mismatch ^= val;
#endif //#ifdef NO_PERF

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

				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, check against buffer overflow */

				j = scan[i];

				DUMPBITS (bit_buf, bits, 12);
				NEEDBITS (bit_buf, bits, bit_ptr);
#ifdef NO_PERF
				val = (SBITS (bit_buf, 12) * quant_matrix[j]) / 16;
#endif //#ifdef NO_PERF

#ifndef NO_PERF
				// $PP
				// store block data for MAE
				pBlockData[j ^ 1] = SBITS (bit_buf, 12);
#endif

#ifdef NO_PERF
				SATURATE (val);
				dest[j] = val;
				mismatch ^= val;
#endif //#ifdef NO_PERF

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

				continue;

			}
		}
		else if (bit_buf >= 0x02000000)
		{
			tab = DCT_B15_10 + (UBITS (bit_buf, 10) - 8);
			i += tab->run;
			
			if (i < 64)
				goto normal_code;
		}
		else if (bit_buf >= 0x00800000)
		{
			tab = DCT_13 + (UBITS (bit_buf, 13) - 16);
			i += tab->run;
			
			if (i < 64)
				goto normal_code;
		}
		else if (bit_buf >= 0x00200000)
		{
			tab = DCT_15 + (UBITS (bit_buf, 15) - 16);
			i += tab->run;
			
			if (i < 64)
				goto normal_code;
		}
		else
		{
			tab = DCT_16 + UBITS (bit_buf, 16);
			bit_buf <<= 16;
			GETWORD (bit_buf, bits + 16, bit_ptr);
			i += tab->run;
			
			if (i < 64)
				goto normal_code;
		}

		break;	/* illegal, check needed to avoid buffer overflow */
    }

#ifdef NO_PERF
	// $PP
    dest[63] ^= mismatch & 16;
#endif //#ifdef NO_PERF

    DUMPBITS (bit_buf, bits, 4);	/* dump end of block code */
    decoder->bitstream_buf = bit_buf;
    decoder->bitstream_bits = bits;
    decoder->bitstream_ptr = bit_ptr;
}

static int get_non_intra_block (mpeg2_decoder_t * const decoder,
								const uint16_t * const quant_matrix,
								short int *pBlockData)
{
    int i = -1;
    int j;
    const uint8_t * scan;
    const DCTtab * tab;
    uint32_t bit_buf;
    int bits;
    const uint8_t * bit_ptr;
#ifdef NO_PERF
    int mismatch = -1;
    int val;
    int16_t * const dest = decoder->DCTblock;
#endif //#ifdef NO_PERF

    bit_buf = decoder->bitstream_buf;
    bits = decoder->bitstream_bits;
    bit_ptr = decoder->bitstream_ptr;

    NEEDBITS (bit_buf, bits, bit_ptr);

#ifdef NO_PERF
	/* select our scan matrix based on type */
	if (decoder->bUseMAE)
	{
		scan = (decoder->scan_type ? my_mpeg2_scan_alt : my_mpeg2_scan_norm);
	}
	else
		scan = decoder->scan;
#else
    scan = (decoder->scan_type ? my_mpeg2_scan_alt : my_mpeg2_scan_norm);
#endif //#ifdef NO_PERF

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

    while (1)
	{
		if (bit_buf >= 0x28000000)
		{
			tab = DCT_B14AC_5 + (UBITS (bit_buf, 5) - 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;
#ifdef NO_PERF
            val = ((2 * tab->level + 1) * quant_matrix[j]) >> 5;
			/* if (bitstream_get (1)) val = -val; */
			val = (val ^ SBITS (bit_buf, 1)) - SBITS (bit_buf, 1);
#endif //#ifdef NO_PERF

#ifndef NO_PERF
			// $PP
			// store block data for MAE
			/**************************/
 			pBlockData[j ^ 1] = ( (2 * tab->level + 1) ^ SBITS (bit_buf, 1)) - SBITS (bit_buf, 1);//temp;
#endif 

#ifdef NO_PERF
			SATURATE (val);
			dest[j] = val;
			mismatch ^= val;
#endif //#ifdef NO_PERF

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

			continue;
		}

entry_2:
		if (bit_buf >= 0x04000000)
		{
			tab = DCT_B14_8 + (UBITS (bit_buf, 8) - 4);

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

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

			j = scan[i];

			DUMPBITS (bit_buf, bits, 12);
			NEEDBITS (bit_buf, bits, bit_ptr);
#ifdef NO_PERF
			val = 2 * (SBITS (bit_buf, 12) + SBITS (bit_buf, 1)) + 1;
			val = (val * quant_matrix[j]) / 32;
#endif //#ifdef NO_PERF

#ifndef NO_PERF
			// $PP
			// store block data for MAE
			pBlockData[j ^ 1] = 2 * (SBITS (bit_buf, 12) + SBITS (bit_buf, 1)) + 1;
#endif

#ifdef NO_PERF
			SATURATE (val);
			dest[j] = val;
			mismatch ^= val;
#endif //#ifdef NO_PERF

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

			continue;

		}