mcpad.cpp

小波图像变换

        ppxlcMBA++;
      }
    }
}

Void CVideoObject::mcPadCurrMBFromLeft (PixelC* ppxlcMBY,
                                        PixelC* ppxlcMBU,
                                        PixelC* ppxlcMBV,
                                        PixelC** pppxlcMBA)
{
	UInt iy;
	for (iy = 0; iy < BLOCK_SIZE; iy++) {
		pxlcmemset (ppxlcMBY, *(ppxlcMBY - 1), MB_SIZE);
		pxlcmemset (ppxlcMBU, *(ppxlcMBU - 1), BLOCK_SIZE);
		pxlcmemset (ppxlcMBV, *(ppxlcMBV - 1), BLOCK_SIZE);
		ppxlcMBY += m_iFrameWidthY;
		ppxlcMBU += m_iFrameWidthUV;
		ppxlcMBV += m_iFrameWidthUV;
	
		pxlcmemset (ppxlcMBY, *(ppxlcMBY - 1), MB_SIZE);
		ppxlcMBY += m_iFrameWidthY;
	}
  if(m_volmd.fAUsage == EIGHT_BIT)
    for(Int iAuxComp=0;iAuxComp<m_volmd.iAuxCompCount;iAuxComp++) { // MAC (SB) 29-Nov-99
      PixelC* ppxlcMBA = pppxlcMBA[iAuxComp];
      for (iy = 0; iy < BLOCK_SIZE; iy++) {
        pxlcmemset (ppxlcMBA, *(ppxlcMBA - 1), MB_SIZE);
        ppxlcMBA += m_iFrameWidthY;
        pxlcmemset (ppxlcMBA, *(ppxlcMBA - 1), MB_SIZE);
        ppxlcMBA += m_iFrameWidthY;
      }
    }
}

Void CVideoObject::mcPadCurrMBFromTop (PixelC* ppxlcMBY, PixelC* ppxlcMBU, PixelC* ppxlcMBV, PixelC** pppxlcMBA)
{
	UInt ix, iy;
	for (ix = 0; ix < MB_SIZE; ix++) {
		PixelC* ppxlcYCol = ppxlcMBY;
		PixelC pxlcY = *(ppxlcMBY - m_iFrameWidthY);
		for (iy = 0; iy < MB_SIZE; iy++) {
			*ppxlcYCol = pxlcY;
			ppxlcYCol += m_iFrameWidthY;
		}
		ppxlcMBY++;
	}

	for (ix = 0; ix < BLOCK_SIZE; ix++) {
		PixelC* ppxlcUCol = ppxlcMBU;
		PixelC* ppxlcVCol = ppxlcMBV;
		PixelC pxlcU = *(ppxlcMBU - m_iFrameWidthUV);
		PixelC pxlcV = *(ppxlcMBV - m_iFrameWidthUV);
		for (iy = 0; iy < BLOCK_SIZE; iy++) {
			*ppxlcUCol = pxlcU;
			*ppxlcVCol = pxlcV;
			ppxlcUCol += m_iFrameWidthUV;
			ppxlcVCol += m_iFrameWidthUV;
		}
		ppxlcMBU++;
		ppxlcMBV++;
	}
	if(m_volmd.fAUsage == EIGHT_BIT)
    for(Int iAuxComp=0;iAuxComp<m_volmd.iAuxCompCount;iAuxComp++) { // MAC (SB) 29-Nov-99
      PixelC* ppxlcMBA = pppxlcMBA[iAuxComp];
      for (ix = 0; ix < MB_SIZE; ix++) {
        PixelC* ppxlcACol = ppxlcMBA;
        PixelC pxlcA = *(ppxlcMBA - m_iFrameWidthY);
        for (iy = 0; iy < MB_SIZE; iy++) {
          *ppxlcACol = pxlcA;
          ppxlcACol += m_iFrameWidthY;
        }
        ppxlcMBA++;
      }
    }
}

Void CVideoObject::mcSetTopMBGray (PixelC* ppxlcMBY, PixelC* ppxlcMBU, PixelC* ppxlcMBV, PixelC** pppxlcMBA)
{
	PixelC pxlcGrayVal = 128;
	if(m_volmd.bNot8Bit)
		pxlcGrayVal = 1<<(m_volmd.nBits-1);

	UInt iy;
	for (iy = 0; iy < BLOCK_SIZE; iy++) {
		ppxlcMBY -= m_iFrameWidthY;
		ppxlcMBU -= m_iFrameWidthUV;
		ppxlcMBV -= m_iFrameWidthUV;
		pxlcmemset (ppxlcMBY, pxlcGrayVal, MB_SIZE);
		pxlcmemset (ppxlcMBU, pxlcGrayVal, BLOCK_SIZE);
		pxlcmemset (ppxlcMBV, pxlcGrayVal, BLOCK_SIZE);

		ppxlcMBY -= m_iFrameWidthY;
		pxlcmemset (ppxlcMBY, pxlcGrayVal, MB_SIZE);
	}
	if(m_volmd.fAUsage == EIGHT_BIT)
    for(Int iAuxComp=0;iAuxComp<m_volmd.iAuxCompCount;iAuxComp++) { // MAC (SB) 29-Nov-99
      PixelC* ppxlcMBA = pppxlcMBA[iAuxComp];
      for (iy = 0; iy < BLOCK_SIZE; iy++) {
        ppxlcMBA -= m_iFrameWidthY;
        pxlcmemset (ppxlcMBA, pxlcGrayVal, MB_SIZE);
        ppxlcMBA -= m_iFrameWidthY;
        pxlcmemset (ppxlcMBA, pxlcGrayVal, MB_SIZE);
      }
    }
}

Void CVideoObject::mcSetLeftMBGray (PixelC* ppxlcMBY, PixelC* ppxlcMBU, PixelC* ppxlcMBV, PixelC** pppxlcMBA)
{
  PixelC** pppxlcMBA_tmp = new PixelC* [m_volmd.iAuxCompCount];
  for(Int iAuxComp=0;iAuxComp<m_volmd.iAuxCompCount;iAuxComp++) // MAC (SB) 29-Nov-99
    pppxlcMBA_tmp[iAuxComp] = pppxlcMBA[iAuxComp]-MB_SIZE;

	mcSetCurrMBGray(
		ppxlcMBY-MB_SIZE,
		ppxlcMBU-BLOCK_SIZE,
		ppxlcMBV-BLOCK_SIZE,
		(m_volmd.fAUsage == EIGHT_BIT) ? pppxlcMBA_tmp : (PixelC **)NULL
	);
  delete [] pppxlcMBA_tmp;
}

Void CVideoObject::mcSetCurrMBGray (PixelC* ppxlcMBY, PixelC* ppxlcMBU, PixelC* ppxlcMBV, PixelC** pppxlcMBA)
{
	PixelC pxlcGrayVal = 128;
	if(m_volmd.bNot8Bit)
		pxlcGrayVal = 1<<(m_volmd.nBits-1);
	UInt iy;
	for (iy = 0; iy < BLOCK_SIZE; iy++) {
		pxlcmemset (ppxlcMBY, pxlcGrayVal, MB_SIZE);
		pxlcmemset (ppxlcMBU, pxlcGrayVal, BLOCK_SIZE);
		pxlcmemset (ppxlcMBV, pxlcGrayVal, BLOCK_SIZE);
		ppxlcMBY += m_iFrameWidthY;
		ppxlcMBU += m_iFrameWidthUV;
		ppxlcMBV += m_iFrameWidthUV;

		pxlcmemset (ppxlcMBY, pxlcGrayVal, MB_SIZE);
		ppxlcMBY += m_iFrameWidthY;
	}
	if(m_volmd.fAUsage == EIGHT_BIT)
    for(Int iAuxComp=0;iAuxComp<m_volmd.iAuxCompCount;iAuxComp++) { // MAC (SB) 29-Nov-99
      PixelC* ppxlcMBA = pppxlcMBA[iAuxComp];
      for (iy = 0; iy < BLOCK_SIZE; iy++) {
        pxlcmemset (ppxlcMBA, pxlcGrayVal, MB_SIZE);
        ppxlcMBA += m_iFrameWidthY;
        pxlcmemset (ppxlcMBA, pxlcGrayVal, MB_SIZE);
        ppxlcMBA += m_iFrameWidthY;
      }
    }
}

// Added for field based MC padding by Hyundai(1998-5-9)

Void CVideoObject::fieldBasedMCPadding (CMBMode* pmbmd, CVOPU8YUVBA* pvopcCurrQ)
{
  Int     iMBX, iMBY;
  
  PixelC* ppxlcCurrY  = (PixelC*) pvopcCurrQ->pixelsY () + m_iStartInRefToCurrRctY;
  PixelC* ppxlcCurrU  = (PixelC*) pvopcCurrQ->pixelsU () + m_iStartInRefToCurrRctUV;
  PixelC* ppxlcCurrV  = (PixelC*) pvopcCurrQ->pixelsV () + m_iStartInRefToCurrRctUV;
  PixelC* ppxlcCurrBY = (PixelC*) pvopcCurrQ->pixelsBY () + m_iStartInRefToCurrRctY;
  PixelC* ppxlcCurrBUV = (PixelC*) pvopcCurrQ->pixelsBUV () + m_iStartInRefToCurrRctUV;
  // 12.22.98 begin of changes
	PixelC** pppxlcCurrMBA = NULL;
  if (m_volmd.fAUsage == EIGHT_BIT) {
    pppxlcCurrMBA = new PixelC* [m_volmd.iAuxCompCount];
  } 
  // 12.22.98 end of changes
  for (iMBY = 0; iMBY < m_iNumMBY; iMBY++) {
    PixelC* ppxlcCurrMBY  = ppxlcCurrY;
    PixelC* ppxlcCurrMBU  = ppxlcCurrU;
    PixelC* ppxlcCurrMBV  = ppxlcCurrV;
    PixelC* ppxlcCurrMBBY = ppxlcCurrBY;
    PixelC* ppxlcCurrMBBUV = ppxlcCurrBUV;
//    PixelC* ppxlcCurrMBA;
    // 12.22.98 begin of changes
//    if (m_volmd.fAUsage == EIGHT_BIT)
//      ppxlcCurrMBA  = ppxlcCurrA; 
    // 12.22.98 end of changes
    for (iMBX = 0; iMBX < m_iNumMBX; iMBX++) {
      memset(pmbmd->m_rgbFieldPadded, 0, 5*sizeof(Bool));
      fieldBasedDownSampleBY (ppxlcCurrMBBY, ppxlcCurrMBBUV);
      decideFieldTransparencyStatus (pmbmd, ppxlcCurrMBBY, ppxlcCurrMBBUV);
      for(Int iAuxComp=0;iAuxComp<m_volmd.iAuxCompCount;iAuxComp++) { // MAC (SB) 29-Nov-99
        pppxlcCurrMBA[iAuxComp] = (PixelC*) pvopcCurrQ->pixelsA (iAuxComp) + m_iStartInRefToCurrRctY;
        pppxlcCurrMBA[iAuxComp] += MB_SIZE * iMBX + m_iFrameWidthYxMBSize * iMBY;
      }
      mcPadCurrAndNeighborsMBFields (iMBX, iMBY, pmbmd, ppxlcCurrMBY, ppxlcCurrMBU, ppxlcCurrMBV, ppxlcCurrMBBY, ppxlcCurrMBBUV,pppxlcCurrMBA);
      ppxlcCurrMBY += MB_SIZE;
      ppxlcCurrMBU += BLOCK_SIZE;
      ppxlcCurrMBV += BLOCK_SIZE;
      ppxlcCurrMBBY += MB_SIZE;
      ppxlcCurrMBBUV += BLOCK_SIZE;
      // 12.22.98 begin of changes
//      if (m_volmd.fAUsage == EIGHT_BIT)
//        ppxlcCurrMBA  += MB_SIZE; 
      // 12.22.98 end of changes
      pmbmd++;
    }
    ppxlcCurrY += m_iFrameWidthYxMBSize;
    ppxlcCurrU += m_iFrameWidthUVxBlkSize;
    ppxlcCurrV += m_iFrameWidthUVxBlkSize;
    ppxlcCurrBY += m_iFrameWidthYxMBSize;
    ppxlcCurrBUV += m_iFrameWidthUVxBlkSize;
    // 12.22.98 begin of changes
//    if (m_volmd.fAUsage == EIGHT_BIT)
//      ppxlcCurrA  += m_iFrameWidthYxMBSize; 
    // 12.22.98 end of changes
  }
  if (m_volmd.fAUsage == EIGHT_BIT) {
    delete [] pppxlcCurrMBA;
  } 
}

Void CVideoObject::mcPadCurrAndNeighborsMBFields (
        Int     iMBX,
        Int     iMBY,
        CMBMode *pmbmd,
        PixelC* ppxlcRefMBY,
        PixelC* ppxlcRefMBU,
        PixelC* ppxlcRefMBV,
        PixelC* ppxlcRefMBBY,
        PixelC* ppxlcRefMBBUV,
		    PixelC** pppxlcRefMBA
)
{
  // 2.9.99 begin of changes.  X. Chen, 
		if (m_volmd.fAUsage == EIGHT_BIT) {
      for(Int iAuxComp=0;iAuxComp<m_volmd.iAuxCompCount;iAuxComp++)  // MAC (SB) 29-Nov-99
        mcPadFieldsCurr (iMBX, iMBY, pmbmd, MB_FIELDY, ppxlcRefMBY, pppxlcRefMBA[iAuxComp], ppxlcRefMBBY, MB_SIZE, m_iFrameWidthY);
    } else
      // 2.9.99 end of changes
      mcPadFieldsCurr (iMBX, iMBY, pmbmd, MB_FIELDY, ppxlcRefMBY, NULL, ppxlcRefMBBY, MB_SIZE, m_iFrameWidthY);
    mcPadFieldsCurr (iMBX, iMBY, pmbmd, MB_FIELDC, ppxlcRefMBU, ppxlcRefMBV, ppxlcRefMBBUV, BLOCK_SIZE, m_iFrameWidthUV);
}

Void CVideoObject::mcPadFieldsCurr (
        Int     iMBX,
        Int     iMBY,
        CMBMode *pmbmd,
        Int     mode,
        PixelC  *ppxlcCurrMB1,
        PixelC  *ppxlcCurrMB2,
        PixelC  *ppxlcCurrMBB,
        Int     uiBlkXSize,
        Int     uiStride
)
{
        PixelC  *ppxlcCurrTopField1 = ppxlcCurrMB1,
                *ppxlcCurrBotField1 = ppxlcCurrMB1 + uiStride,
                *ppxlcCurrTopField2 = ((ppxlcCurrMB2) ? ppxlcCurrMB2 : NULL),
                *ppxlcCurrBotField2 = ((ppxlcCurrMB2) ? ppxlcCurrMB2 + uiStride : NULL),
                *ppxlcCurrTopFieldB = ppxlcCurrMBB,
                *ppxlcCurrBotFieldB = ppxlcCurrMBB + uiStride;
 
        if (pmbmd->m_rgFieldTranspStatus [mode] != ALL) {       // Top Field MC Padding
                if (pmbmd->m_rgFieldTranspStatus [mode] == PARTIAL) {
                        mcPadOneField (ppxlcCurrTopField1, ppxlcCurrTopFieldB, uiBlkXSize, uiStride);
                        if (ppxlcCurrTopField2)
                                mcPadOneField (ppxlcCurrTopField2, ppxlcCurrTopFieldB, uiBlkXSize, uiStride);
                }
                padNeighborTranspMBFields (iMBX, iMBY, pmbmd, mode, ppxlcCurrTopField1, ppxlcCurrTopField2, uiBlkXSize, uiStride);
        } else  padCurrAndTopTranspMBFieldsFromNeighbor (iMBX, iMBY, pmbmd, mode, ppxlcCurrTopField1, ppxlcCurrTopField2, uiBlkXSize, uiStride);
        if (pmbmd->m_rgFieldTranspStatus [mode+1] != ALL) {     // Bottom Field MC Padding
                if (pmbmd->m_rgFieldTranspStatus [mode+1] == PARTIAL) {
                        mcPadOneField (ppxlcCurrBotField1, ppxlcCurrBotFieldB, uiBlkXSize, uiStride);
                        if (ppxlcCurrBotField2)
                                mcPadOneField (ppxlcCurrBotField2, ppxlcCurrBotFieldB, uiBlkXSize, uiStride);
                }
                padNeighborTranspMBFields (iMBX, iMBY, pmbmd, mode+1, ppxlcCurrBotField1, ppxlcCurrBotField2, uiBlkXSize, uiStride);
        } else  padCurrAndTopTranspMBFieldsFromNeighbor (iMBX, iMBY, pmbmd, mode+1, ppxlcCurrBotField1, ppxlcCurrBotField2, uiBlkXSize, uiStride);
}

Void CVideoObject::mcPadOneField (
        PixelC          *ppxlcTextureBase,
        const PixelC    *ppxlcAlphaBase,
        Int             uiBlkXSize,
        Int             uiStride
)
{
        Int     iUnit = sizeof(PixelC);
        Int     uiBlkYSize = uiBlkXSize/2;
        Int     iFieldSkip = 2*uiStride;
        CoordI  iX,iY,iJ,iLeftX = 0;
        Bool    bEmptyRow = FALSE;
        Bool    bInVop;
        Int     iLeftColour;
         
 
        PixelC  *ppxlcTexture = ppxlcTextureBase;
        for (iY=0;iY<(CoordI)uiBlkYSize;iY++, ppxlcTexture+=iFieldSkip) {
                bInVop = TRUE;
                iLeftColour = invalidColour;
                m_pbEmptyRowArray[iY]=0;
                const PixelC *ppxlcAlpha = ppxlcAlphaBase;
                for(iX=0;iX<(CoordI)uiBlkXSize;iX++,ppxlcAlpha++) {
                        if(bInVop==TRUE && *ppxlcAlpha==transpValue) {
                                bInVop=FALSE;