vopmbdec.c

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

            if (nBldOpt == USE_MAE && pmbmd->m_bFieldMV) 
            {
              Get_PVOP_YILMVs (m_ppxlcPredMBY, m_pvopcRefQ0->pixelsY (),
                pmv, pmbmd, 
                iMBX, iMBY, 
                x, y,
                pmbmd->m_bSkip,
                FALSE,
                &m_rctRefVOPY0);
              
              if (!(pmbmd->m_bSkip && !pmbmd->m_bMCSEL))  // GMC
              {
                CoordI iXRefUV, iYRefUV, iXRefUV1, iYRefUV1;
                // GMC
                if (!pmbmd->m_bMCSEL)
                  // ~GMC
                  mvLookupUV (pmbmd, pmv, &iXRefUV, &iYRefUV, &iXRefUV1, &iYRefUV1);
                
                Get_PVOP_UVILMVs(m_ppxlcPredMBU, m_ppxlcPredMBV, m_pvopcRefQ0, iMBX, iMBY, x, y,
                  iXRefUV, iYRefUV, pmbmd->m_bForwardTop,
                  &m_rctRefVOPY0, MAEMB_CONFIG_MV_UV, DUMP_CHROMA_IC_BLKS); // added by Y.Suzuki for the extended bounding box support
                Get_PVOP_UVILMVs(m_ppxlcPredMBU + BLOCK_SIZE, m_ppxlcPredMBV + BLOCK_SIZE,
                  m_pvopcRefQ0, iMBX, iMBY, x, y, iXRefUV1, iYRefUV1, pmbmd->m_bForwardBottom,
                  &m_rctRefVOPY0, MAEMB_CONFIG_MV_UV1, NO_DUMP_CHROMA_IC_BLKS); // added by Y.Suzuki for the extended bounding box support
              }
              // HV For Travis
#ifndef COPY_FRAME_FROM_CMODEL
              if (nFlipToRef == FLIP_TO_REF && !nDoPadding)
              {
                // Copy the reference frame into the m_IFFlipQ0_Y/U/V buffers
                CopyRefFrameWhenFlipping (m_IFFlipQ0_Y, m_pvopcRefQ0->pixelsY (),
                  iPicWidth, iPicHeight, 
                  iPicWidth, iPicWidth + EXPANDY_REF_FRAMEx2);
                
                CopyRefFrameWhenFlipping (m_IFFlipQ0_U, m_pvopcRefQ0->pixelsU (),
                  iPicWidth/2, iPicHeight/2, 
                  iPicWidth/2, iPicWidth/2 + EXPANDUV_REF_FRAMEx2);
                
                CopyRefFrameWhenFlipping (m_IFFlipQ0_V, m_pvopcRefQ0->pixelsV (),
                  iPicWidth/2, iPicHeight/2, 
                  iPicWidth/2, iPicWidth/2 + EXPANDUV_REF_FRAMEx2);
                
                // Generate the OOF bytes in the m_IFFlipQ0_Y/U/V buffers
                repeatPadYOrA (m_IFFlipQ0_Y, (CVOPU8YUVBA *)m_OOFFlipQ0_Y);
                repeatPadUV   ((CVOPU8YUVBA *)m_OOFFlipQ0_Y);
                nDoPadding = 1;
              }
#endif
              // ~HV For Travis
            }
          }
        }
#endif
        // ~HV

#ifdef DUAL_MODE
				if (m_uiSprite == 0 || m_uiSprite == 2)  // GMC
#endif
				{
					if (pmbmd->m_dctMd == INTRA || pmbmd->m_dctMd == INTRAQ) 
					{
						nTrueInterP = INTER_CODED_AS_INTRA;
						DECODETEXTUREINTRAMB (pmbmd, iMBX, iMBY);
					}

					else if (!pmbmd->m_bSkip)
                    {
							DECODETEXTUREINTERMB (pmbmd);
					}
				}

#ifdef DUAL_MODE
				// only non-transparent MB and COD == 0 will be decoded
				else if (m_uiSprite == 1 && TmpSMode != STOP)
					// sprite update piece use P_VOP syntax with no MV
				{
					SETTOZERO(pmv);  
					pmbmd->m_bhas4MVForward = FALSE ;  
					pmbmd -> m_dctMd = INTER ;

					if (!pmbmd->m_bSkip)
                    {
						DECODETEXTUREINTERMB (pmbmd);
                    }
				}
#endif

				if (iMBX != iNumMBX - 1) 
				{				
					CMBMode* pmbmdRight = pmbmd + 1;
					SKIPANYSTUFFING();

                    MP4V_CHECKRESYNCMARKER(&bResyncMark);
                    if (bResyncMark)
					{
						decodeVideoPacketHeader(&iCurrentQP);
						iVideoPacketNumber++;
						bRestartDelayedQP = TRUE;
					}

					pmbmdRight->m_iVideoPacketNumber = iVideoPacketNumber;
					if (iMBY == 0 || bFirstGobRow==TRUE) // [FDS]
					{
						bLeftBndry = !(pmbmd -> m_iVideoPacketNumber == pmbmdRight -> m_iVideoPacketNumber);
						bRightBndry = TRUE;
						bTopBndry = TRUE;
					}
					else	
					{
						bLeftBndry =  !(pmbmd -> m_iVideoPacketNumber == pmbmdRight -> m_iVideoPacketNumber);
						if ((iMBX + 1) == iNumMBX - 1)
							bRightBndry = TRUE;
						else
							bRightBndry = !((pmbmdRight - iNumMBX + 1) -> m_iVideoPacketNumber == pmbmdRight->m_iVideoPacketNumber);
						bTopBndry = !((pmbmdRight - iNumMBX) -> m_iVideoPacketNumber == pmbmdRight->m_iVideoPacketNumber);
					}

#ifdef DUAL_MODE
					if (m_uiSprite == 0 || m_uiSprite == 2) // GMC
#endif
					{
						decodeMBTextureHeadOfPVOP (pmbmdRight, &iCurrentQP, &bRestartDelayedQP);

						// GMC
						if(!pmbmdRight -> m_bMCSEL)
							// ~GMC
							decodeMV (pmbmdRight, pmv + PVOP_MV_PER_REF_PER_MB, bLeftBndry, bRightBndry, bTopBndry, FALSE, iMBX+1, iMBY);
						// GMC
						else
						{
							Int iPmvx, iPmvy, iHalfx, iHalfy, i;
							CMotionVector* pmvcurr;
                            globalmv (&iPmvx, &iPmvy, &iHalfx, &iHalfy, x+16,y,g_pVOP->mvInfoForward.uiRange,TmpQPel);
							pmvcurr = pmv + PVOP_MV_PER_REF_PER_MB;
                            CMOTIONVECTOR_INIT3(pmvcurr, iPmvx, iPmvy);
							pmvcurr -> iHalfX = iHalfx;
							pmvcurr -> iHalfY = iHalfy;
                            COMPUTETRUEMV(pmv);
                            COMPUTEMV(pmvcurr);
							for (i = 1; i < PVOP_MV_PER_REF_PER_MB; i++)
								pmvcurr[i] = *pmvcurr;
						}
						// ~GMC
					}
				}

				if (pmbmd->m_dctMd == INTER || pmbmd->m_dctMd == INTERQ) 
				{
#ifdef DUAL_MODE
					if (m_uiSprite == 0 || m_uiSprite == 2) // GMC
#endif
					{
#ifdef ENABLE_INTERLACING
						if (nFlipToRef == FLIP_TO_REF)
						{
							m_iFrameWidthY += EXPANDY_REF_FRAMEx2;

							motionCompMB (pmv, pmbmd, iMBX, iMBY, x, y, pmbmd->m_bSkip);

							m_iFrameWidthY -= EXPANDY_REF_FRAMEx2;
						}
#endif

						if (!pmbmd->m_bSkip)
                        {
                            motionCompMB (pmv, pmbmd);

#ifdef ENABLE_INTERLACING
                            if(pmbmd->m_bFieldMV)
                            {
                                motionCompFieldUV(m_ppxlcPredMBU, m_ppxlcPredMBV, m_pvopcRefQ0, x, y,
                                    iXRefUV, iYRefUV, pmbmd->m_bForwardTop,
                                    &m_rctRefVOPY0, MAEMB_CONFIG_MV_UV, DUMP_CHROMA_IC_BLKS); // added by Y.Suzuki for the extended bounding box support
                                motionCompFieldUV(m_ppxlcPredMBU + BLOCK_SIZE, m_ppxlcPredMBV + BLOCK_SIZE,
                                    m_pvopcRefQ0, x, y, iXRefUV1, iYRefUV1, pmbmd->m_bForwardBottom,
                                    &m_rctRefVOPY0, MAEMB_CONFIG_MV_UV1, NO_DUMP_CHROMA_IC_BLKS); // added by Y.Suzuki for the extended bounding box support
                            }
#endif
						}
						else 
						{
							// The reference code is processing "SKIPPED" MBs here
							if (g_pVOL->bAdvPredDisable)
                            {
                                g_pHeader2->mbmode = MBMODE_FWD_ALL_420;
                                g_pHeader3->mbtype = MBT_16x16;
                            }
#ifdef DUAL_MODE
                            // reference code doesn't seem to enter this path!!
							else
                            { 
                                MP4V_FATAL_ERROR("Didn't Reference code doesn't expect to go here\n");
                                copyFromPredForYAndRefForCToCurrQ (x, y, ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, NULL);
                            }
#endif
						}
					} // end else from "if ( m_vopmd.SpriteXmitMode != STOP)" 
				}

#ifndef NEW_MAE_DRIVER
                if (!MP4V_nBytesUsed) 
                {
                    // Fill in all the frame related registers
                    // Assign the FWD TOP pointers
                    pMAERegs->fwd_y_top_ptr     = (uint32)m_pMAERef0Y;
                    pMAERegs->fwd_cb_top_ptr    = (uint32)m_pMAERef0Y + m_iSizeYPlane;
                    pMAERegs->fwd_cr_top_ptr    = (uint32)m_pMAERef0Y + m_iSizeYPlane + m_iSizeUVPlane;

                    // FWD BOT pointers are 1 row below the FWD TOP pointers
                    pMAERegs->fwd_y_bot_ptr     = (uint32)m_pMAERef0Y + g_pVO->m_iFrameWidthY;
                    pMAERegs->fwd_cb_bot_ptr    = (uint32)m_pMAERef0Y + m_iSizeYPlane + g_pVO->m_iFrameWidthUV;
                    pMAERegs->fwd_cr_bot_ptr    = (uint32)m_pMAERef0Y + m_iSizeYPlane + m_iSizeUVPlane + g_pVO->m_iFrameWidthUV;

                    MP4V_FILLMAEREGISTERS(PFRAME, g_pVOP->bInterlace);
                }
#endif

                // Rounding control
                g_pHeader3->rnd = g_pVOP->iRoundingControl;

                // Y Precision
                if (TmpQPel)
                    g_pHeader3->mcprecy = MAE_QUARTER_PEL;

#ifdef ENABLE_INTERLACING
                // Field DCT
                if (pmbmd->m_bFieldDCT)
                    g_pHeader3->dctt = 1;

                // Interlacing
                if (pmbmd->m_bFieldMV)
                {
                    g_pHeader3->fp = MAE_FIELD_PREDICTION;

                    if (!pmbmd->m_bForwardTop)
                        g_pHeader3->ft = 1;

                    if (!pmbmd->m_bForwardBottom)
                        g_pHeader3->fb = 1;

                    if (!pmbmd->m_bBackwardTop)
                        g_pHeader3->bt = 1;

                    if (!pmbmd->m_bBackwardBottom)
                        g_pHeader3->bb = 1;
                }
#endif
                // Call MAE only if this is TRUE since we will have to do IQUANT
                // & IDCT at the minimum even if MotionComp is not needed!!
                // *************************************************************
                if (nTrueInterP == INTER_CODED_AS_INTER)
                    QueueMB ();

#ifdef ENABLE_INTERLACING
				// Put back to MAE mode if we had flipped
				if (nFlipToRef == FLIP_TO_REF)
				{
// HV For Travis
					// Update the FlipArray
					nFlipArray[g_MAEWrapper->Get_MAEConfig_nMB ("CVideoObjectDecoder::decodePVOP", __LINE__, __FILE__)] 
								= FLIP_TO_REF;

// ~HV For Travis
					nBldOpt = USE_MAE;
					nFlipToRef	= NO_FLIP;
				}
#endif

				pmbmd++;
				pmv += PVOP_MV_PER_REF_PER_MB;

#ifdef MP4V_DEBUG
                g_nGlobMB++;
#endif

#ifdef ENABLE_INTERLACING
                // Check if the previous MB got flipped, If so, don't call WrapGetNextContext
                if( nFlipArray[g_MAEWrapper->Get_MAEConfig_nMB ("CVideoObjectDecoder::decodePVOP", __LINE__, __FILE__)-1] == NO_FLIP)
#endif
                    MP4V_WRAPGETNEXTCONTEXT ();
			}
			
			ppmbmTemp = g_pVO->m_rgpmbmAbove;
			g_pVO->m_rgpmbmAbove = g_pVO->m_rgpmbmCurr;
			g_pVO->m_rgpmbmCurr  = ppmbmTemp;
			bFirstGobRow=FALSE; // KPN
		}
	} // Terminate while loop
	
#ifdef ENABLE_INTERLACING
    // Due to CModel bug wherein it cannot retain already filled in MB data (due to 
    // the flipping logic), we need to do the copy before calling the CModel
    if (nDoPadding)
        CopyCurFrmsForCModel ((PixelC *)m_pvopcRefQ1->pixelsY () + m_iStartInRefToCurrRctY,
                              (PixelC *)m_pvopcRefQ1->pixelsU () + m_iStartInRefToCurrRctUV,
                              (PixelC *)m_pvopcRefQ1->pixelsV () + m_iStartInRefToCurrRctUV,
                              iPicWidth, iPicHeight);
#endif

SUBMIT_P_CONTEXT:
#ifdef ENABLE_PRINTS
    printf("TNUM = %d PTS = %d\n", pMAEContext->tnum, pMAEContext->pts);
#endif

    // Now that we have queued all the MBs for this frame, let us ask MAE to process the same
    WrapSubmitMBs();
	SKIPANYSTUFFING();
}

#ifdef UNDER_CE 
Void decodeBVOP ()	
#else
INLINE Void decodeBVOP ()	
#endif
{
	Int iMBX, iMBY;
  Int iMBXstop = g_pVO->m_iNumMBX, iMBYstop = g_pVO->m_iNumMBY;
	CMBMode* pmbmdRef = g_pVO->m_rgmbmdRef;
  CMBMode *pmbmd = g_pVO->m_rgmbmd;
  CMotionVector *pmv = g_pVO->m_rgmv;
	CMotionVector* pmvRef = g_pVO->m_rgmvRef;
	CMotionVector* pmvBackward = g_pVO->m_rgmvBackward;
	Int iCurrentQP;
	//	Added for error resilient mode by Toshiba(1998-1-16:B-VOP+Error)
	Int	iVideoPacketNumber = 0;
  int nMBMode = 0, nMBType = 0;
#ifdef ENABLE_INTERLACING
  int n4MV;
#endif
  CVector *FwdPred0, *BwdPred0;
  VOLtype TmpVOLType;
  Int TmpRefSelCode;

  g_NumMVs = 0;

#ifndef NEW_MAE_DRIVER
    pMAERegs->cur_y_frame_ptr   = get_cur_buffer(); 
    pMAERegs->cur_cb_frame_ptr  = pMAERegs->cur_y_frame_ptr + m_iSizeYPlane; 
    pMAERegs->cur_cr_frame_ptr  = pMAERegs->cur_cb_frame_ptr + m_iSizeUVPlane; 
#endif

	MP4V_nBytesUsed = 0;

	iCurrentQP  = g_pVOP->intStepB;

	g_pVO->m_iVPMBnum = 0;

	if(g_pVO->m_bCodedFutureRef==FALSE)
	{
		pmbmdRef = NULL;
		pmvRef = NULL;
	}

    // Store some locals here
    TmpVOLType = g_pVOL->volType;
    TmpRefSelCode = g_pVOP->iRefSelectCode;

    FwdPred0 = &(g_pVO->m_vctForwardMvPredBVOP[0]);
    BwdPred0 = &(g_pVO->m_vctBackwardMvPredBVOP[0]);

#ifdef ENABLE_INTERLACING
    CVector *FwdPred1, *BwdPred1;
    FwdPred1 = &(g_pVO->m_vctForwardMvPredBVOP[1]);
    BwdPred1 = &(g_pVO->m_vctBackwardMvPredBVOP[1]);
#endif

    // Call MAE-Wrapper to get a pointer to 1 Frame worth of memory
    pMAEContext = WrapGetContext (MP4V_nBytesUsed);
    
    // Now, get the temporal number
    MP4V_COMPUTETEMPORALNUMBER(&pMAEContext->tnum, BFRAME);

    // Set the anchor flag & frametype
    pMAEContext->anchor_flag = 0; 

#ifdef NEW_MAE_DRIVER
    MP4V_FILLFRAMEPARAMETERS(BFRAME);
#else
    pMAEContext->frametype = BFRAME;
#endif

	//	End Toshiba(1998-1-16:B-VOP+Error)
	for (iMBY = 0; iMBY < iMBYstop; iMBY++) 
	{
        FwdPred0->x = FwdPred0->y = BwdPred0->x = BwdPred0->y = 0;

#ifdef ENABLE_INTERLACING
		FwdPred1->x = FwdPred1->y = BwdPred1->x = BwdPred1->y = 0;
#endif

		for (iMBX = 0; iMBX < iMBXstop; iMBX++) 
		{
            // Reset the number of coded blocks
            nCodedBlocks = 0;

            // Set default to Intra MB
            g_NumMVs	= TOTAL_INTRA_MVS;

            MP4V_CLEARHEADERWORDS (); 

            // MB position
            g_pHeader3->xpos = iMBX * 2;
            g_pHeader3->ypos = iMBY * 2;

			if(!(TmpVOLType == ENHN_LAYER && TmpRefSelCode == 0))
				pmbmd->m_bColocatedMBSkip = (pmbmdRef==NULL ? FALSE : pmbmdRef->m_bSkip);
			else
				pmbmd->m_bColocatedMBSkip = FALSE;

			// GMC
			if(!(TmpVOLType == ENHN_LAYER && TmpRefSelCode == 0))
				pmbmd->m_bColocatedMBMCSEL = (pmbmdRef==NULL ? FALSE : pmbmdRef->m_bMCSEL); // GMC_V2
			else
				pmbmd->m_bColocatedMBMCSEL = FALSE;

			// ~GMC
			if ((pmbmd->m_bColocatedMBSkip  && !(pmbmd->m_bColocatedMBMCSEL)) && // GMC
				(TmpVOLType == BASE_LAYER))
			{
                g_pHeader2->mbmode = MBMODE_FWD_ALL_420;
                g_pHeader3->mbtype = MBT_16x16;