blkdec.no-opt

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

/*************************************************************************

This software module was originally developed by 

	Ming-Chieh Lee ([e-mail]), Microsoft Corporation
	Wei-ge Chen ([e-mail]), Microsoft Corporation
	Bruce Lin ([e-mail]), Microsoft Corporation
	Chuang Gu ([e-mail]), Microsoft Corporation
	(date: July, 1997)
and edited by
        Wei Wu ([e-mail]) Rockwell Science Center

and also edited by
	Yoshihiro Kikuchi (TOSHIBA CORPORATION)
	Takeshi Nagai (TOSHIBA CORPORATION)
	Toshiaki Watanabe (TOSHIBA CORPORATION)
	Noboru Yamaguchi (TOSHIBA CORPORATION)

and also edited by
	Dick van Smirren ([e-mail]), KPN Research
	Cor Quist ([e-mail]), KPN Research
	(date: July, 1998)

and also edited by
    Fujitsu Laboratories Ltd. (contact: Eishi Morimatsu)

in the course of development of the MPEG-4 Video (ISO/IEC 14496-2). 
This software module is an implementation of a part of one or more MPEG-4 Video tools 
as specified by the MPEG-4 Video. 
ISO/IEC gives users of the MPEG-4 Video free license to this software module or modifications 
thereof for use in hardware or software products claiming conformance to the MPEG-4 Video. 
Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. 
The original developer of this software module and his/her company, 
the subsequent editors and their companies, 
and ISO/IEC have no liability for use of this software module or modifications thereof in an implementation. 
Copyright is not released for non MPEG-4 Video conforming products. 
Microsoft retains full right to use the code for his/her own purpose, 
assign or donate the code to a third party and to inhibit third parties from using the code for non <MPEG standard> conforming products. 
This copyright notice must be included in all copies or derivative works. 

Copyright (c) 1996, 1997.

Module Name:

	blkdec.c

Abstract:

	Block decoding functions

Revision History
    Dec 20, 1977    Interlaced tools added by NextLevel Systems
	Sep.06	1999 : RRV added by Eishi Morimatsu (Fujitsu Laboratories Ltd.) 

*************************************************************************/

#include <stdlib.h>
#include <math.h>
#include "typeapi.h"
#include "codehead.h"
#include "mode.h"
#include "global.h"
#include "entropy/bitstrm.h"
#include "entropy/huffman.h"
#include "vopses.h"
#include "vopsedec.h"

//#define USE_BSFAST

#define DIVROUNDNEAREST(i, iDenom) (i>=0)?((i+(iDenom>>1))/iDenom):((i-(iDenom>>1))/iDenom)
#define MP4V_DECODESHORTHEADERINTRAMBDC(rgiCoefQ)\
\
	UInt uiIntraDC = getBits(8);\
\
	rgiCoefQ[0] =  (uiIntraDC == 255) ? 128 : uiIntraDC;
    

BlockMemory findPredictorBlock (Int iBlkOrig, IntraPredDirection predDir, MacroBlockMemory* pmbmLeft, MacroBlockMemory* pmbmTop,
                                MacroBlockMemory* pmbmLeftTop, MacroBlockMemory* pmbmCurr, CMBMode* pmbmdLeft, CMBMode* pmbmdTop,
                                CMBMode* pmbmdLeftTop, CMBMode* pmbmdCurr,Int *iQPpred)
{
    BlockMemory blkmRet = NULL;
// MAC
//    Int iBlk = iBlkOrig, iAuxComp = 0;

/*  if (iBlkOrig<7)
    iBlk = iBlkOrig;
  else
  {
    iAuxComp = (iBlkOrig-7)/4;
    iBlk = ((iBlkOrig-7)&3)+7;
  }*/
//~MAC
  
	if (predDir == HORIZONTAL)
   	{
		switch (iBlkOrig)
       	{
            case Y_BLOCK1:
            case Y_BLOCK3:
    			if (pmbmLeft != NULL && (pmbmdLeft->m_dctMd == INTRA || pmbmdLeft->m_dctMd == INTRAQ))
                {
    				blkmRet = pmbmLeft->rgblkm [iBlkOrig];
    				*iQPpred = pmbmdLeft->m_stepSize;
    			}
			break;

            case Y_BLOCK2:
		    case Y_BLOCK4:
    				blkmRet = pmbmCurr->rgblkm [iBlkOrig - 2];
    				*iQPpred = pmbmdCurr->m_stepSize;
			break;

/*
		    case A_BLOCK1:
    			if (pmbmLeft != NULL && (pmbmdLeft->m_dctMd == INTRA || pmbmdLeft->m_dctMd == INTRAQ))	
                {
    				blkmRet = pmbmLeft->rgblkm [A_BLOCK2 + iAuxComp*4 - 1]; 
    				*iQPpred = pmbmdLeft->m_stepSizeAlpha;	
    			}
			break;

		    case A_BLOCK2:
    				blkmRet = pmbmCurr->rgblkm [A_BLOCK1 + iAuxComp*4 - 1]; 
    				*iQPpred = pmbmdCurr->m_stepSizeAlpha;	
			break;

		    case A_BLOCK3:
    			if (pmbmLeft != NULL && (pmbmdLeft->m_dctMd == INTRA || pmbmdLeft->m_dctMd == INTRAQ))	
                {
    				blkmRet = pmbmLeft->rgblkm [A_BLOCK4 + iAuxComp*4 - 1];
    				*iQPpred = pmbmdLeft->m_stepSizeAlpha;	
    			}
			break;

		    case A_BLOCK4:
    				blkmRet = pmbmCurr->rgblkm [A_BLOCK3 + iAuxComp*4 - 1];        
    				*iQPpred = pmbmdCurr->m_stepSizeAlpha;	
			break;
*/
		    default:								//U, V block
    			if (pmbmLeft != NULL && (pmbmdLeft->m_dctMd == INTRA || pmbmdLeft->m_dctMd == INTRAQ))	
                {
    				blkmRet = pmbmLeft->rgblkm [iBlkOrig - 1];
    				*iQPpred = pmbmdLeft->m_stepSize;	
    			}
        }
	}

	else if  (predDir == VERTICAL)
   	{
		switch (iBlkOrig)	
        {
            case Y_BLOCK1:
            case Y_BLOCK2:
    			if (pmbmTop != NULL && (pmbmdTop->m_dctMd == INTRA || pmbmdTop->m_dctMd == INTRAQ))	
                {
    				blkmRet = pmbmTop->rgblkm [iBlkOrig + 1];
    				*iQPpred = pmbmdTop->m_stepSize;	
    			}
			break;

            case Y_BLOCK3:
		    case Y_BLOCK4:
    				blkmRet = pmbmCurr->rgblkm [iBlkOrig - 3];
    				*iQPpred = pmbmdCurr->m_stepSize;	
			break;

/*
		    case A_BLOCK1:
    			if (pmbmTop != NULL && (pmbmdTop->m_dctMd == INTRA || pmbmdTop->m_dctMd == INTRAQ))	
                {
    				blkmRet = pmbmTop->rgblkm [A_BLOCK3 + iAuxComp*4 - 1];
    				*iQPpred = pmbmdTop->m_stepSizeAlpha;	
    			}
			break;

		    case A_BLOCK2:
    			if (pmbmTop != NULL && (pmbmdTop->m_dctMd == INTRA || pmbmdTop->m_dctMd == INTRAQ))	
                {
    				blkmRet = pmbmTop->rgblkm [A_BLOCK4 + iAuxComp*4 - 1];
    				*iQPpred = pmbmdTop->m_stepSizeAlpha;	
    			}
			break;

		    case A_BLOCK3:
    				blkmRet = pmbmCurr->rgblkm [A_BLOCK1 + iAuxComp*4 - 1];
    				*iQPpred = pmbmdCurr->m_stepSizeAlpha;	
			break;

		    case A_BLOCK4:
    				blkmRet = pmbmCurr->rgblkm [A_BLOCK2 + iAuxComp*4 - 1];
    				*iQPpred = pmbmdCurr->m_stepSizeAlpha;	
			break;
*/
		    default:								//U, V block
    			if (pmbmTop != NULL && (pmbmdTop->m_dctMd == INTRA || pmbmdTop->m_dctMd == INTRAQ))	
                {
    				blkmRet = pmbmTop->rgblkm [iBlkOrig - 1];
    				*iQPpred = pmbmdTop->m_stepSize;	
    			}
		}
	}

	else if (predDir == DIAGONAL)	
    {
		switch (iBlkOrig)	
        {
            case Y_BLOCK1:
    			if (pmbmLeftTop != NULL && (pmbmdLeftTop->m_dctMd == INTRA || pmbmdLeftTop->m_dctMd == INTRAQ))	
                {
    				blkmRet = pmbmLeftTop->rgblkm [Y_BLOCK4 - 1];
    				*iQPpred = pmbmdLeftTop->m_stepSize;	
    			}
			break;

		    case Y_BLOCK2:
    			if (pmbmTop != NULL && (pmbmdTop->m_dctMd == INTRA || pmbmdTop->m_dctMd == INTRAQ))	
                {
    				blkmRet = pmbmTop->rgblkm [Y_BLOCK3 - 1];
    				*iQPpred = pmbmdTop->m_stepSize;	
    			}
			break;

		    case Y_BLOCK3:
    			if (pmbmLeft != NULL && (pmbmdLeft->m_dctMd == INTRA || pmbmdLeft->m_dctMd == INTRAQ))	
                {
    				blkmRet = pmbmLeft->rgblkm [Y_BLOCK2 - 1];
    				*iQPpred = pmbmdLeft->m_stepSize;	
    			}
			break;

		    case Y_BLOCK4:
    				blkmRet = pmbmCurr->rgblkm [Y_BLOCK1 - 1];
    				*iQPpred = pmbmdCurr->m_stepSize;	
			break;
/*
		    case A_BLOCK1:
    			if (pmbmLeftTop != NULL && (pmbmdLeftTop->m_dctMd == INTRA || pmbmdLeftTop->m_dctMd == INTRAQ))	
                {
    				blkmRet = pmbmLeftTop->rgblkm [A_BLOCK4 + iAuxComp*4 - 1];
    				*iQPpred = pmbmdLeftTop->m_stepSizeAlpha;	
    			}
			break;

		    case A_BLOCK2:
    			if (pmbmTop != NULL && (pmbmdTop->m_dctMd == INTRA || pmbmdTop->m_dctMd == INTRAQ))	
                {
    				blkmRet = pmbmTop->rgblkm [A_BLOCK3 + iAuxComp*4 - 1];
    				*iQPpred = pmbmdTop->m_stepSizeAlpha;	
    			}
			break;

		    case A_BLOCK3:
    			if (pmbmLeft != NULL && (pmbmdLeft->m_dctMd == INTRA || pmbmdLeft->m_dctMd == INTRAQ))	
                {
    				blkmRet = pmbmLeft->rgblkm [A_BLOCK2 + iAuxComp*4 - 1];
    				*iQPpred = pmbmdLeft->m_stepSizeAlpha;	
    			}
			break;

		    case A_BLOCK4:
    				blkmRet = pmbmCurr->rgblkm [A_BLOCK1 + iAuxComp*4 - 1];
    				*iQPpred = pmbmdCurr->m_stepSizeAlpha;	
			break;
*/
		    default:								//U, V block
    			if (pmbmLeftTop != NULL && (pmbmdLeftTop->m_dctMd == INTRA || pmbmdLeftTop->m_dctMd == INTRAQ))	
                {
    				blkmRet = pmbmLeftTop->rgblkm [iBlkOrig - 1];
    				*iQPpred = pmbmdLeftTop->m_stepSize;	
    			}
		}
	}

	else 
		assert (FALSE);

	return (blkmRet);
}

inline Void decodeTextureIntraBlock (Int iQP, Int iDcScaler, Int iBlk, MacroBlockMemory* pmbmCurr, CMBMode* pmbmd, BlockMemory blkmPred, Int iQpPred)
{
// HV - Perf Changes
	Int* rgiCoefQ = g_pVO->m_rgpiCoefQ [iBlk - 1];
	Int iCoefStart = 0, i, j;
    Int iCoef;

	if (!main_short_video_header)
	{  
		if (iBlk<=V_BLOCK && pmbmd->m_bCodeDcAsAc==FALSE) 
        {
			rgiCoefQ [0] = decodeIntraDCmpeg (iBlk <= Y_BLOCK4 || iBlk >=A_BLOCK1);
			iCoefStart++;
		}
	} 

    else  // short_header
    {
        MP4V_DECODESHORTHEADERINTRAMBDC(rgiCoefQ); // 8 bits FLC & fixed quantizer op 8.
        iCoefStart++;
    }

	if (GETCODEDBLOCKPATTERN (pmbmd, iBlk))	
    {
		Int* rgiZigzag = grgiStandardZigzag;

	    if (g_pVOP->bAlternateScan && iBlk<=V_BLOCK) // 12.22.98 Changes
            rgiZigzag = grgiVerticalZigzag;

        else if (iBlk<=V_BLOCK && pmbmd->m_bACPrediction)
			rgiZigzag = (pmbmd->m_preddir [iBlk - 1] == HORIZONTAL) ? grgiVerticalZigzag : grgiHorizontalZigzag;

        decodeIntraTCOEF (rgiCoefQ, iCoefStart, rgiZigzag);
	}
	else
	{
		// Use our custom memset routine
		i = rgiCoefQ [0];
		ZERO_256B (rgiCoefQ);
		rgiCoefQ [0] = i;
	}

	inverseDCACPred (pmbmd, iBlk - 1, rgiCoefQ, iQP, iDcScaler, blkmPred, iQpPred);

    // Parse thru the right block & update the dst pointer with the correct
    // block data pointer.Also, custom memset this to 0
    ClearBlockDataPointer(iBlk-1);

    // Since inverseQuantizeIntraDc () has only 1 line of code, its just replaced here to avoid the function call overhead
	if (!main_short_video_header) 
    {
        pmbmCurr->rgblkm [iBlk - 1] [0] = rgiCoefQ [0] * iDcScaler;	//save recon value of DC for intra pred
        if (iBlk < U_BLOCK)
            g_pHeader0->dcluma = iDcScaler;
        else
            g_pHeader0->dcchroma = iDcScaler;
        // inverseQuantizeIntraDc (rgiCoefQ, iDcScaler); 
    }

    else 
    {
        pmbmCurr->rgblkm [iBlk - 1] [0] = rgiCoefQ [0] * 8;	//save recon value of DC for intra pred
        g_pHeader0->dcluma = g_pHeader0->dcchroma = 8;
        // inverseQuantizeIntraDc(rgiCoefQ,8); 
    }

    // Save the DC block data (Inline Big-Endian conversion)
	g_pIQOutput [0 ^ 1] = rgiCoefQ [0];

    // Copy the INTRA Weighting Matrices only when we are processing the first block
    if (iBlk == Y_BLOCK1)
    {
        // Update IQMUL2
        g_pHeader0->iqmul2 = iQP;

        // Update IQDIV3
        if (g_pVOL->fQuantizer == Q_MPEG)
            g_pHeader1->iqdiv3 = 3;
    }

	if (g_pVOL->fQuantizer == Q_H263)
    {
        // Setting up block data here to avoid the function call overhead
		// inverseQuantizeDCTcoefH263 (rgiCoefQ, 1, iQP);
        for (i = 1; i < BLOCK_SQUARE_SIZE; i++)
        {
            iCoef = rgiCoefQ[i];
            if (iCoef)
            {
                g_pIQOutput [i ^ 1] = iCoef + iCoef + sign(iCoef);
            }
        }
    }
	else
    {
        // Setting up block data here to avoid the function call overhead
        // inverseQuantizeIntraDCTcoefMPEG (rgiCoefQ, 1, iQP, iBlk>=A_BLOCK1, iAuxComp);
        for (i = 1; i < BLOCK_SQUARE_SIZE; i++)
        {
    		if (rgiCoefQ [i])