blkdec.no-opt

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

}


Void decodeIntraTCOEF (Int* rgiCoefQ, Int iCoefStart, Int* rgiZigzag)
{
	Bool bIsLastRun = FALSE;
	Int  iRun = 0, iLevel = 0, iCoef = iCoefStart, i, iSignBit;
	Long lIndex;

#ifdef USE_BSFAST
    _BSFAST_DECL;
    UInt bitsread;
    _BSFAST_INIT();
#endif


    // Use our custom memset routine
    i = rgiCoefQ [0];
    ZERO_256B (rgiCoefQ);
    rgiCoefQ [0] = i;

	while (!bIsLastRun)
    {
		if (!main_short_video_header)
        {
#ifdef MP4V_NEW_VLD
            lIndex = decodeSymbol_Test(TABLE_ID_DCTINTRA, MAX_SYMBOLS_FOR_DCTINTRA, MAX_SYMBOL_LENGTH_IN_DCTINTRA);
#else
#ifdef MPV4_VLD_WITH_PEEK
            lIndex = decodeSymbol_WithPeek(m_pentrdecDCTIntra, MAX_SYMBOL_LENGTH_IN_DCTINTRA);
#else
#ifdef USE_BSFAST
            lIndex = decodeSymbol_WithFastBS(m_pentrdecDCTIntra,_BSFastCurrentBits(), &bitsread);  // MPEG-4
#else
			lIndex = decodeSymbol(m_pentrdecDCTIntra);  // MPEG-4
#endif   // USE_BSFAST
#endif
#endif
        }

        // Added for short headers by KPN (1998-02-07, DS)
        else
        {
#ifdef MP4V_NEW_VLD
            lIndex = decodeSymbol_Test(TABLE_ID_DCT, MAX_SYMBOLS_FOR_DCT, MAX_SYMBOL_LENGTH_IN_DCT);
#else
#ifdef MPV4_VLD_WITH_PEEK
            lIndex = decodeSymbol_WithPeek(m_pentrdecDCT, MAX_SYMBOL_LENGTH_IN_DCT);
#else
#ifdef USE_BSFAST
            lIndex = decodeSymbol_WithFastBS(m_pentrdecDCT, _BSFastCurrentBits(), &bitsread);   // H.263
#else
            lIndex = decodeSymbol(m_pentrdecDCT);   // H.263
#endif   // USE_BSFAST
#endif   // MPV4_VLD_WITH_PEEK
#endif   //MP4V_NEW_VLD
        }

#ifdef USE_BSFAST
    _BSFastSkipBits(bitsread);
    _BSFastCheckedPreload();
#endif

        // Added for short headers by KPN - END
				
		if (lIndex != TCOEF_ESCAPE)
        {
#ifdef USE_BSFAST
            iSignBit = _BSFastGetBits(1);
#else
            MP4V_GETSINGLEBIT (); // sign bit
            iSignBit = nSingBitRet;
#endif

            // MPEG-4
			if (!main_short_video_header)
				decodeIntraVLCtableIndex (lIndex, &iLevel, &iRun, &bIsLastRun, iSignBit);

            // short header
            else // Added by KPN [FDS]
            {
                Bool tempBool = (Bool) bIsLastRun;
                decodeInterVLCtableIndex (lIndex, &iLevel, &iRun, &tempBool, iSignBit); 

                bIsLastRun = (Int) tempBool;
            }
		}
		else
        {
#ifdef MP4V_NEW_VLD
			decodeEscape_Test (&iLevel, &iRun, &bIsLastRun, g_rgiLMAXintra, g_rgiRMAXintra, TRUE);
#else
#ifdef USE_BSFAST
        decodeEscape_WithFastBS(&iLevel, &iRun, &bIsLastRun, g_rgiLMAXintra, g_rgiRMAXintra, m_pentrdecDCTIntra, TRUE,_BSFastCurrentBits(),&bitsread);
        _BSFastSkipBits(bitsread);
        _BSFastCheckedPreload();
#else
			decodeEscape (&iLevel, &iRun, &bIsLastRun, g_rgiLMAXintra, g_rgiRMAXintra, m_pentrdecDCTIntra, TRUE);
#endif // USE_BSFAST
#endif
        }

        iCoef+=iRun;
		rgiCoefQ [rgiZigzag [iCoef]] = iLevel;			
		iCoef++;
	}  

#ifdef USE_BSFAST
    _BSFAST_DONE();
#endif 
}



Void decodeInterTCOEF (Int* rgiCoefQ, Int iCoefStart, Int* rgiZigzag)
{
	Bool bIsLastRun = FALSE;
	Int  iRun = 0, iLevel = 0,  iCoef = iCoefStart, i, iSignBit;
	Long lIndex;

#ifdef USE_BSFAST
    _BSFAST_DECL;
    UInt bitsread;
    _BSFAST_INIT();
#endif


    // iCoefStart is 0, so let's memset the entire array and then skip the two for loops below.
    ZERO_256B (rgiCoefQ);

	while (!bIsLastRun)
    {
#ifdef MP4V_NEW_VLD
        lIndex = decodeSymbol_Test(TABLE_ID_DCT, MAX_SYMBOLS_FOR_DCT, MAX_SYMBOL_LENGTH_IN_DCT);
#else
#ifdef MPV4_VLD_WITH_PEEK
        lIndex = decodeSymbol_WithPeek(m_pentrdecDCT, MAX_SYMBOL_LENGTH_IN_DCT);
#else
#ifdef USE_BSFAST
        lIndex = decodeSymbol_WithFastBS(m_pentrdecDCT,_BSFastCurrentBits(),&bitsread);
        _BSFastSkipBits(bitsread);
        _BSFastCheckedPreload();
#else
		lIndex = decodeSymbol(m_pentrdecDCT);
#endif // USE_BSFAST
#endif
#endif

		if (lIndex != TCOEF_ESCAPE)	// if Huffman
        {
#ifdef USE_BSFAST
            iSignBit = _BSFastGetBits(1);
#else
            MP4V_GETSINGLEBIT (); // sign bit
            iSignBit = nSingBitRet;
#endif
			decodeInterVLCtableIndex (lIndex, &iLevel, &iRun, &bIsLastRun, iSignBit);
			assert (iRun < BLOCK_SQUARE_SIZE);
		}

		else
        {
#ifdef MP4V_NEW_VLD
			decodeEscape_Test (&iLevel, &iRun, &bIsLastRun, g_rgiLMAXinter, g_rgiRMAXinter, FALSE);
#else
#ifdef USE_BSFAST
            decodeEscape_WithFastBS (&iLevel, &iRun, &bIsLastRun, g_rgiLMAXinter, g_rgiRMAXinter, m_pentrdecDCT, FALSE, _BSFastCurrentBits(),&bitsread);
            _BSFastSkipBits(bitsread);
            _BSFastCheckedPreload();
#else
            decodeEscape (&iLevel, &iRun, &bIsLastRun, g_rgiLMAXinter, g_rgiRMAXinter, m_pentrdecDCT, FALSE);
#endif // USE_BSFAST
#endif
        }

        iCoef+=iRun;
		rgiCoefQ [rgiZigzag [iCoef]] = iLevel;			
		iCoef++;
	}  
#ifdef USE_BSFAST
    _BSFAST_DONE();
#endif
}

Void decodeIntraVLCtableIndex  (Int iIndex, Int *iLevel, Int *iRun, Int *bIsLastRun, Int iSignBit)
{
	static Int iLevelMask = 0x0000001F;
	static Int iRunMask = 0x000003E0;
	static Int iLastRunMask = 0x00000400;

	*iLevel = iLevelMask & grgiIntraYAVCLHashingTable [iIndex];
	*iRun = (iRunMask & grgiIntraYAVCLHashingTable [iIndex]) >> 5;
	*bIsLastRun = (iLastRunMask  & grgiIntraYAVCLHashingTable [iIndex]) >> 10;

	if (iSignBit)
		*iLevel = -(*iLevel);

	assert (*iRun < BLOCK_SQUARE_SIZE);
}

// return islastrun, run and level
Void decodeInterVLCtableIndex (Int iIndex, Int *iLevel, Int *iRun, Bool *bIsLastRun, Int iSignBit)
{	
	Int iIndexLeft = (Int) iIndex;

	assert (iIndex >= 0 && iIndex < 102);

	*bIsLastRun = FALSE;

	if (iIndex >= 58)
   	{
		iIndexLeft -= 58;
		*bIsLastRun = TRUE;
	}

	*iRun = 0;
	while (iIndexLeft >= 0)
  	{
		if (!*bIsLastRun)
			iIndexLeft -= grgIfNotLastNumOfLevelAtRun [*iRun];
		else
			iIndexLeft -= grgIfLastNumOfLevelAtRun [*iRun];
		(*iRun)++;
	}

	assert (*iRun > 0);

	(*iRun)--;
	if (!*bIsLastRun)
		*iLevel = iIndexLeft + grgIfNotLastNumOfLevelAtRun [*iRun] + 1;
	else
		*iLevel = iIndexLeft + grgIfLastNumOfLevelAtRun [*iRun] + 1;	

	assert (*iRun >= 0);

    if (iSignBit)
		*iLevel = -(*iLevel);
}

Int decodeIntraDCmpeg (Bool bIsYBlk)
{
	Long lSzDiffIntraDC;
	Int iDiffIntraDC = 0;
    U8 chDiffIntraDC;	
    UInt uiDiffIntraDC;

#ifdef USE_BSFAST
    _BSFAST_DECL;
    UInt bitsread;
    _BSFAST_INIT();
#endif

#ifdef MP4V_NEW_VLD
    if (bIsYBlk)
        lSzDiffIntraDC = decodeSymbol_Test(TABLE_ID_INTRADCY, MAX_SYMBOLS_FOR_INTRADCY, MAX_SYMBOL_LENGTH_IN_INTRADCY);
    else 
        lSzDiffIntraDC = decodeSymbol_Test(TABLE_ID_INTRADCC, MAX_SYMBOLS_FOR_INTRADCC, MAX_SYMBOL_LENGTH_IN_INTRADCC);
#else
    if (bIsYBlk)
#ifdef MPV4_VLD_WITH_PEEK
        lSzDiffIntraDC = decodeSymbol_WithPeek(m_pentrdecIntraDCy, MAX_SYMBOL_LENGTH_IN_INTRADCY);
#else
#ifdef USE_BSFAST
        lSzDiffIntraDC = decodeSymbol_WithFastBS(m_pentrdecIntraDCy,_BSFastCurrentBits(), &bitsread);
#else
        lSzDiffIntraDC = decodeSymbol(m_pentrdecIntraDCy);
#endif  // USE_BSFAST
#endif
    else 
#ifdef MPV4_VLD_WITH_PEEK
        lSzDiffIntraDC = decodeSymbol_WithPeek(m_pentrdecIntraDCc, MAX_SYMBOL_LENGTH_IN_INTRADCC);
#else
#ifdef USE_BSFAST
        lSzDiffIntraDC = decodeSymbol_WithFastBS(m_pentrdecIntraDCc,_BSFastCurrentBits(), &bitsread);
#else
        lSzDiffIntraDC = decodeSymbol(m_pentrdecIntraDCc);
#endif // USE_BSFAST
#endif
#endif

#ifdef USE_BSFAST
    _BSFastSkipBits(bitsread);
    _BSFastCheckedPreload();
#endif

	if (lSzDiffIntraDC !=0 )
   	{
	    if (lSzDiffIntraDC<=8) // NBIT
        {
#ifdef USE_BSFAST
            chDiffIntraDC = (U8)_BSFastGetBits (lSzDiffIntraDC);	
#else
            chDiffIntraDC = (U8) getBits (lSzDiffIntraDC);	
#endif

    		if (!((1 << (lSzDiffIntraDC - 1)) & chDiffIntraDC))
    			iDiffIntraDC = -1 * ((0x00FF >> (8 - lSzDiffIntraDC)) & (~chDiffIntraDC));
    		else
    			iDiffIntraDC = (Int) chDiffIntraDC;
	    } 

        else // NBIT - marker bit inserted after 8 bits
        {
#ifdef USE_BSFAST
            uiDiffIntraDC = (U8)_BSFastGetBits (lSzDiffIntraDC);	
#else
			uiDiffIntraDC = (UInt) getBits (lSzDiffIntraDC);
#endif

			if (!((1 << (lSzDiffIntraDC - 1)) & uiDiffIntraDC))
				iDiffIntraDC = -1 * ((0xFFFF >> (16 - lSzDiffIntraDC)) & (~uiDiffIntraDC));
			else
				iDiffIntraDC = (Int) uiDiffIntraDC;

#ifdef USE_BSFAST
            _BSFastGetBits(1);
#else
            MP4V_GETSINGLEBIT ();
#endif
	    }
	}
#ifdef USE_BSFAST
    _BSFAST_DONE();
#endif

	return iDiffIntraDC;
}

inline Void inverseDCACPred (CMBMode* pmbmd, Int iBlkIdx, Int* rgiCoefQ, Int iQP, Int iDcScaler, BlockMemory blkmPred, Int iQpPred)
{
	UInt nBits = g_pVOL->nBits; // NBIT
	Int iDefVal = 1<<(nBits+2); // NBIT
    Int i, j;

	// do DC prediction
	if (!main_short_video_header)
	{		// Added by KPN for short video headers
		if (blkmPred == NULL)
			rgiCoefQ [0] += DIVROUNDNEAREST(iDefVal, iDcScaler);

		else
        {
			rgiCoefQ [0] += DIVROUNDNEAREST(blkmPred [0], iDcScaler);

			// clip range after inverse pred
            rgiCoefQ [0] = rgiCoefQ[0] < -2048 ? -2048 : (rgiCoefQ[0] > 2047 ? 2047 : rgiCoefQ[0]);

			if (iBlkIdx<(A_BLOCK1 - 1) && pmbmd->m_bACPrediction)
          	{
				// do AC prediction
				if (pmbmd->m_preddir [iBlkIdx] == HORIZONTAL)
               	{
                    int x = 2 * BLOCK_SIZE - 1;
					for (i = 8, j = 8; j < x; i += 8, j++)
					{
						rgiCoefQ [i] += (blkmPred == NULL) ? 0 : (iQP == iQpPred) ? blkmPred [j] : DIVROUNDNEAREST(blkmPred [j] * iQpPred, iQP);

						// clip range after inverse pred
						rgiCoefQ [i] = rgiCoefQ[i] < -2048 ? -2048 : (rgiCoefQ[i] > 2047 ? 2047 : rgiCoefQ[i]);
					}
				}

				else if  (pmbmd->m_preddir [iBlkIdx] == VERTICAL)
               	{
					//horizontal zigzag scan
					for (i = 1; i < BLOCK_SIZE; i++)
					{
						rgiCoefQ [i] += (blkmPred == NULL) ? 0 : (iQP == iQpPred) ? blkmPred [i] : DIVROUNDNEAREST(blkmPred [i] * iQpPred, iQP);

						// clip range after inverse pred
						rgiCoefQ [i] = rgiCoefQ[i] < -2048 ? -2048 : (rgiCoefQ[i] > 2047 ? 2047 : rgiCoefQ[i]);
					}
				}
				else
					assert (FALSE);
			}
		}
	}// End short video headers
}