mc_interlaced.c

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

	     }
	   }
     for (iy=0; iy <= blkSizeY; iy++) {
		 for (ix=0; ix <= blkSizeX-1; ix++) {
		   tmpblk0[iy+3][ix] = ( refblk[iy+3][ix+3] + tmpblk1[iy][ix] + 1 - iRoundingControl)/2;
		 }
	   }
     break;
	   
     case 2 : // Half Pel Position
       for (iy=0; iy <= blkSizeY; iy++) {
	     for (ix=0; ix <= blkSizeX-1; ix++) {
           u = 0;
		   for (k=0; k<=3; k++) {
			 u += c[k] * ( refblk[iy+3][ix+3-k] + refblk[iy+3][ix+4+k] );
		   }
		   u = (u+128-iRoundingControl)/256;
		   u = max(0,min(maxVal,u));
// GMC_V3
		   tmpblk0[iy+3][ix] = (U8)u; 
//		   tmpblk1[iy][ix] = (U8)u; 
// ~GMC_V3
	     }
	   }
	 break;
	   
     case 3 : // Quarter Pel Position
       for (iy=0; iy <= blkSizeY; iy++) {
	     for (ix=0; ix <= blkSizeX-1; ix++) {
           u = 0;
		   for (k=0; k<=3; k++) {
			 u += c[k] * ( refblk[iy+3][ix+3-k] + refblk[iy+3][ix+4+k] );
		   }
		   u = (u+128-iRoundingControl)/256;
		   u = max(0,min(maxVal,u));
		   tmpblk1[iy][ix] = (U8)u; 
	     }
	   }
       for (iy=0; iy <= blkSizeY; iy++) {
		 for (ix=0; ix <= blkSizeX-1; ix++) {
		   tmpblk0[iy+3][ix] = ( refblk[iy+3][ix+4] + tmpblk1[iy][ix] + 1 - iRoundingControl)/2;
		 }
	   }
     break;
	 
   }

   // Copy tmpblk0 -> refblk

   for (iy=0; iy <= blkSizeY; iy++) {
	 for (ix=0; ix <= blkSizeX-1; ix++) {
	   refblk[iy+3][ix] = tmpblk0[iy+3][ix];
	 }
   }
   
   // Vertical Mirroring

   for (iy=0; iy <= 2; iy++) {
	 for (ix=0; ix <= blkSizeX-1; ix++) {
	   refblk[iy][ix] = refblk[5-iy][ix];
	   refblk[blkSizeY+iy+4][ix] = refblk[blkSizeY-iy+3][ix];
	 }
   }
   
   switch (y_frac) {

     case 0 : // Full Pel Position
       for (iy=0; iy <= blkSizeY-1; iy++) {
	     for (ix=0; ix <= blkSizeX-1; ix++) {
		   tmpblk0[iy][ix] = refblk[iy+3][ix];
	     }
	   }
	 break;
	 
     case 1 : // Quarter Pel Position
       for (iy=0; iy <= blkSizeY-1; iy++) {
	     for (ix=0; ix <= blkSizeX-1; ix++) {		   
           u = 0;
		   for (k=0; k<=3; k++) {
			 u += c[k] * ( refblk[iy+3-k][ix] + refblk[iy+4+k][ix] );
		   }
		   u = (u+128-iRoundingControl)/256;
		   u = max(0,min(maxVal,u));
		   tmpblk1[iy][ix] = (U8)u; 
	     }
	   }
       for (iy=0; iy <= blkSizeY-1; iy++) {
		 for (ix=0; ix <= blkSizeX-1; ix++) {
		   tmpblk0[iy][ix] = ( refblk[iy+3][ix] + tmpblk1[iy][ix] + 1 - iRoundingControl)/2;
		 }
	   }
     break;
	   
     case 2 : // Half Pel Position
       for (iy=0; iy <= blkSizeY-1; iy++) {
	     for (ix=0; ix <= blkSizeX-1; ix++) {
           u = 0;
		   for (k=0; k<=3; k++) {
			 u += c[k] * ( refblk[iy+3-k][ix] + refblk[iy+4+k][ix] );
		   }
		   u = (u+128-iRoundingControl)/256;
		   u = max(0,min(maxVal,u));
// GMC_V3
		   tmpblk0[iy][ix] = (U8)u; 
//		   tmpblk1[iy][ix] = (U8)u; 
// ~GMC_V3
	     }
	   }
	 break;
	   
     case 3 : // Quarter Pel Position
       for (iy=0; iy <= blkSizeY-1; iy++) {
	     for (ix=0; ix <= blkSizeX-1; ix++) {
           u = 0;
		   for (k=0; k<=3; k++) {
			 u += c[k] * ( refblk[iy+3-k][ix] + refblk[iy+4+k][ix] );
		   }
		   u = (u+128-iRoundingControl)/256;
		   u = max(0,min(maxVal,u));
		   tmpblk1[iy][ix] = (U8)u; 
	     }
	   }
       for (iy=0; iy <= blkSizeY-1; iy++) {
		 for (ix=0; ix <= blkSizeX-1; ix++) {
		   tmpblk0[iy][ix] = ( refblk[iy+4][ix] + tmpblk1[iy][ix] + 1 - iRoundingControl)/2;
		 }
	   }
     break;
	 
   }

   // Copy tmpblk0 -> ppxlcblk

   if (blkSize == 0) {
     for (iy=0; iy <= blkSizeY-1; iy++) {
       for (ix=0; ix <= blkSizeX-1; ix++) {
	     *(ppxlcblk+ix+iy*2*blkSizeX) = tmpblk0[iy][ix];
	   }
     }
   }
   else {
     for (iy=0; iy <= blkSizeY-1; iy++) {
       for (ix=0; ix <= blkSizeX-1; ix++) {
	     *(ppxlcblk+ix+iy*blkSizeX) = tmpblk0[iy][ix];
	   }
     }
   }
}
// ~QuarterSample

Void CVideoObject::motionCompQuarterSample (
	PixelC* ppxlcPred, // can be either Y or A
	const PixelC* ppxlcRefLeftTop, // point to left-top of the frame
	Int iSize, // either MB or BLOCK size
	CoordI xRef, CoordI yRef, // x + mvX in quarter pel unit
	Int iRoundingControl, // rounding control
	CRct *prctMVLimit, // extended bounding box
	int nMBType,
	int nBlockNum,
	const CMotionVector* pmv,
	int nSkip)
{
	CoordI ix, iy;
    U8 *ppxlcblk;

    printf("==>motionCompQuarterSample\n");

	LIMITMVRANGETOEXTENDEDBBQUARTERPEL(&xRef,&yRef,prctMVLimit,iSize);
    
    Int blkSizeX, blkSizeY;
    if (iSize == 0) { // INTERLACED
      blkSizeX = 16;
      blkSizeY = 8;
      
      ppxlcblk = (U8*) calloc(blkSizeX*blkSizeX,sizeof(U8));
      blkInterpolateY (ppxlcRefLeftTop,iSize,xRef,yRef,ppxlcblk,iRoundingControl);
      
      for (iy = 0; iy < blkSizeX; iy++) { 
        if (!(iy&1)) 
          for (ix = 0; ix < blkSizeX; ix++) { 
            ppxlcPred [ix] = *(ppxlcblk+ix+iy*blkSizeX);
          }
        ppxlcPred += blkSizeX;
      }
    } //~INTERLACED
    else { 
      blkSizeX = iSize;
      blkSizeY = iSize;
      
      ppxlcblk = (U8*) calloc(blkSizeX*blkSizeX,sizeof(U8));
      blkInterpolateY (ppxlcRefLeftTop,iSize,xRef,yRef,ppxlcblk,iRoundingControl);
 
      for (iy = 0; iy < blkSizeX; iy++) { 
        for (ix = 0; ix < blkSizeX; ix++) { 
          ppxlcPred [ix] = *(ppxlcblk+ix+iy*blkSizeX);
        }
        ppxlcPred += MB_SIZE;
      }
    }

  free(ppxlcblk);
}

Void CVideoObject::motionCompDirectMode(CoordI x, CoordI y, CMBMode *pmbmd, CMotionVector *pmvRef, 
                                        CRct *prctMVLimitFwd, CRct *prctMVLimitBak,Int plane)
{
	Int* rgiMvRound;
	UInt uiDivisor = 0;
	Int xRefUVF,yRefUVF,xRefUVB,yRefUVB;
	CoordI iMVX, iMVY;

	Int iMBX,iMBY;
	const CMBMode *pmbmdRef; 

	if(m_volmd.fAUsage != RECTANGLE)
	{
		iMBX=(x-m_rctCurrVOPY.left)/MB_SIZE;
		iMBY=(y-m_rctCurrVOPY.top)/MB_SIZE;
		pmbmdRef= m_rgmbmdRef + (iMBX+iMBY*m_iNumMBXRef);
	}
	else
	{
		iMBX=x/MB_SIZE;
		iMBY=y/MB_SIZE;
		pmbmdRef= m_rgmbmdRef + iMBX+iMBY*m_iNumMBXRef;
	}

	if (pmbmdRef->m_rgTranspStatus[0]==ALL) 
	{
		static CMotionVector mvZero[5];
		pmvRef = mvZero;
	}

	if ((iMBX<m_iNumMBXRef && iMBX>=0 && iMBY<m_iNumMBYRef && iMBY>=0)&& // new change 10/21/98
		(pmbmdRef->m_bFieldMV&&pmbmdRef->m_rgTranspStatus[0]!=ALL)) 
	{
      static I8 iTROffsetTop[] = {  0, 0,  1, 1, 0, 0, -1, -1 };
      static I8 iTROffsetBot[] = { -1, 0, -1, 0, 1, 0,  1,  0 };
      CoordI iXFwdTop, iXFwdBot, iXBakTop, iXBakBot;
      CoordI iYFwdTop, iYFwdBot, iYBakTop, iYBakBot;
      CoordI iXFTQSUV, iXFBQSUV, iXBTQSUV, iXBBQSUV;
      CoordI iYFTQSUV, iYFBQSUV, iYBTQSUV, iYBBQSUV;
      const CMotionVector *pmvRefTop, *pmvRefBot;
      Int iTopRefFldOffset = 0, iBotRefFldOffset = 0;
      Int iCode = (Int)(vopmd().bTopFieldFirst) << 2;
      
      pmbmd->m_bFieldMV = 1;  // set field direct mode for grey scale, Krit 02-17-99

      assert((pmbmdRef->m_dctMd != INTRA) && (pmbmdRef->m_dctMd != INTRAQ));
      if (pmbmdRef->m_bForwardTop) {
        iCode |= 2;
        iTopRefFldOffset = 1;
        pmvRefTop = pmvRef + 6;
      } else
        pmvRefTop = pmvRef + 5;
      if (pmbmdRef->m_bForwardBottom) {
        iCode |= 1;
        iBotRefFldOffset = 1;
        pmvRefBot = pmvRef + 8;
      } else
        pmvRefBot = pmvRef + 7;
      Int iTempRefDTop = 2*(m_tFutureRef - m_tPastRef) + iTROffsetTop[iCode];
      Int iTempRefDBot = 2*(m_tFutureRef - m_tPastRef) + iTROffsetBot[iCode];
      Int iTempRefBTop = 2*(m_t          - m_tPastRef) + iTROffsetTop[iCode];
      Int iTempRefBBot = 2*(m_t          - m_tPastRef) + iTROffsetBot[iCode];
      
      assert(iTempRefDTop > 0); assert(iTempRefDBot > 0); assert(iTempRefBTop > 0); assert(iTempRefBBot > 0);
      
      // Find MVs for the top field
      iXFwdTop = (pmvRefTop->m_vctTrueHalfPel.x * iTempRefBTop) / iTempRefDTop + pmbmd->m_vctDirectDeltaMV.x;
      iYFwdTop = (pmvRefTop->m_vctTrueHalfPel.y * iTempRefBTop) / iTempRefDTop + pmbmd->m_vctDirectDeltaMV.y;
      iXBakTop = pmbmd->m_vctDirectDeltaMV.x ? (iXFwdTop - pmvRefTop->m_vctTrueHalfPel.x) :
        ((pmvRefTop->m_vctTrueHalfPel.x * (iTempRefBTop - iTempRefDTop)) / iTempRefDTop);
      iYBakTop = pmbmd->m_vctDirectDeltaMV.y ? (iYFwdTop - pmvRefTop->m_vctTrueHalfPel.y) :
        ((pmvRefTop->m_vctTrueHalfPel.y * (iTempRefBTop - iTempRefDTop)) / iTempRefDTop);
      
      // Find MVs for the bottom field
      iXFwdBot = (pmvRefBot->m_vctTrueHalfPel.x * iTempRefBBot) / iTempRefDBot + pmbmd->m_vctDirectDeltaMV.x;
      iYFwdBot = (pmvRefBot->m_vctTrueHalfPel.y * iTempRefBBot) / iTempRefDBot + pmbmd->m_vctDirectDeltaMV.y;
      iXBakBot = pmbmd->m_vctDirectDeltaMV.x ? (iXFwdBot - pmvRefBot->m_vctTrueHalfPel.x) :
        ((pmvRefBot->m_vctTrueHalfPel.x * (iTempRefBBot - iTempRefDBot)) / iTempRefDBot);
      iYBakBot = pmbmd->m_vctDirectDeltaMV.y ? (iYFwdBot - pmvRefBot->m_vctTrueHalfPel.y) :
        ((pmvRefBot->m_vctTrueHalfPel.y * (iTempRefBBot - iTempRefDBot)) / iTempRefDBot);
    
      // Motion compensate the top field forward
      if (m_volmd.bQuarterSample) {
        iXFTQSUV = iXFwdTop/2; 
        iYFTQSUV = iYFwdTop/2;
        iXBTQSUV = iXBakTop/2; 
        iYBTQSUV = iYBakTop/2;

        iXFBQSUV = iXFwdBot/2;
        iYFBQSUV = iYFwdBot/2;
        iXBBQSUV = iXBakBot/2; 
        iYBBQSUV = iYBakBot/2;

        iYFwdTop = iYFwdTop & ~1;
        iYBakTop = iYBakTop & ~1;
        iYFwdBot = iYFwdBot & ~1;
        iYBakBot = iYBakBot & ~1;
    
        iXFwdTop += 4*x; iYFwdTop += 4*y;
      if (plane==0) {  // texture MC
          motionCompQuarterSample(m_ppxlcPredMBY, 
                                  m_pvopcRefQ0->pixelsY() + iTopRefFldOffset * m_iFrameWidthY, 0, 
                                  iXFwdTop, iYFwdTop, m_vopmd.iRoundingControl, prctMVLimitFwd);
          
          motionCompFieldUV(m_ppxlcPredMBU, m_ppxlcPredMBV, m_pvopcRefQ0, x, y,
                            (iXFTQSUV & 3) ? ((iXFTQSUV >> 1) | 1) : (iXFTQSUV >> 1),
                            (iYFTQSUV & 6) ? ((iYFTQSUV >> 1) | 2) : (iYFTQSUV >> 1), 
                            iTopRefFldOffset,
                            prctMVLimitFwd); // added by Y.Suzuki for the extended bounding box support
        }
        else {  // plane=1, grey scale MC
          for(Int iAuxComp=0;iAuxComp<m_volmd.iAuxCompCount;iAuxComp++) { // MAC (SB) 26-Nov-99
            motionCompQuarterSample(m_ppxlcPredMBA[iAuxComp], 
              m_pvopcRefQ0->pixelsA(iAuxComp) + iTopRefFldOffset * m_iFrameWidthY, 0, 
              iXFwdTop, iYFwdTop, m_vopmd.iRoundingControl, prctMVLimitFwd);
          }
        }
      }
      else {
          iXFwdTop += 2*x; iYFwdTop += 2*y;
        if (plane==0) { // texture MC

			// GW: MAE doesn't support texture coding
#if TRUE
			throw CUnsupportedTextureCodingException();
#else
          motionCompYField(m_ppxlcPredMBY,
                           m_pvopcRefQ0->pixelsY() + iTopRefFldOffset * m_iFrameWidthY, iXFwdTop, iYFwdTop,
                           prctMVLimitFwd); // added by Y.Suzuki for the extended bounding box support
          iXFwdTop -= 2*x; iYFwdTop -= 2*y;
          motionCompFieldUV(m_ppxlcPredMBU, m_ppxlcPredMBV, m_pvopcRefQ0, x, y,
                            (iXFwdTop & 3) ? ((iXFwdTop >> 1) | 1) : (iXFwdTop >> 1),
                            (iYFwdTop & 6) ? ((iYFwdTop >> 1) | 2) : (iYFwdTop >> 1), iTopRefFldOffset,
                            prctMVLimitFwd); // added by Y.Suzuki for the extended bounding box support
#endif
        }
        else { // plane=1, grey scale MC