mbenc.cpp

《Visual C++小波变换技术与工程实践》靳济芳编著的光盘程序。

		}
	}
}

Void CVideoObjectEncoder::copyToCurrBuffJustShape(const PixelC* ppxlcCurrBY,
												  Int iWidthY)
{
	PixelC* ppxlcCurrMBBY = m_ppxlcCurrMBBY;
	Int ic;
	for (ic = 0; ic < BLOCK_SIZE; ic++) {
		memcpy (ppxlcCurrMBBY, ppxlcCurrBY, MB_SIZE*sizeof(PixelC));
		ppxlcCurrMBBY += MB_SIZE; ppxlcCurrBY += iWidthY;
		memcpy (ppxlcCurrMBBY, ppxlcCurrBY, MB_SIZE*sizeof(PixelC));
		ppxlcCurrMBBY += MB_SIZE; ppxlcCurrBY += iWidthY;
	}
}

Void CVideoObjectEncoder::copyToCurrBuff (
	const PixelC* ppxlcCurrY, const PixelC* ppxlcCurrU, const PixelC* ppxlcCurrV,
	Int iWidthY, Int iWidthUV
)
{
	PixelC* ppxlcCurrMBY = m_ppxlcCurrMBY;
	PixelC* ppxlcCurrMBU = m_ppxlcCurrMBU;
	PixelC* ppxlcCurrMBV = m_ppxlcCurrMBV;
	Int ic;
// RRV modification
	for (ic = 0; ic < (BLOCK_SIZE *m_iRRVScale); ic++) {
		memcpy (ppxlcCurrMBY, ppxlcCurrY,
				(MB_SIZE *sizeof(PixelC) *m_iRRVScale));
		memcpy (ppxlcCurrMBU, ppxlcCurrU,
				(BLOCK_SIZE *sizeof(PixelC) *m_iRRVScale));
		memcpy (ppxlcCurrMBV, ppxlcCurrV,
				(BLOCK_SIZE* sizeof(PixelC) *m_iRRVScale));
		ppxlcCurrMBY += (MB_SIZE *m_iRRVScale);		ppxlcCurrY += iWidthY;
		ppxlcCurrMBU += (BLOCK_SIZE *m_iRRVScale);	ppxlcCurrU += iWidthUV;
		ppxlcCurrMBV += (BLOCK_SIZE *m_iRRVScale);	ppxlcCurrV += iWidthUV;
		
		memcpy (ppxlcCurrMBY, ppxlcCurrY,
				(MB_SIZE *sizeof(PixelC) *m_iRRVScale));	// two rows for Y
		ppxlcCurrMBY += (MB_SIZE *m_iRRVScale); ppxlcCurrY += iWidthY;
//	for (ic = 0; ic < BLOCK_SIZE; ic++) {
//		memcpy (ppxlcCurrMBY, ppxlcCurrY, MB_SIZE*sizeof(PixelC));
//		memcpy (ppxlcCurrMBU, ppxlcCurrU, BLOCK_SIZE*sizeof(PixelC));
//		memcpy (ppxlcCurrMBV, ppxlcCurrV, BLOCK_SIZE*sizeof(PixelC));
//		ppxlcCurrMBY += MB_SIZE; ppxlcCurrY += iWidthY;
//		ppxlcCurrMBU += BLOCK_SIZE; ppxlcCurrU += iWidthUV;
//		ppxlcCurrMBV += BLOCK_SIZE;	ppxlcCurrV += iWidthUV;
//
//		memcpy (ppxlcCurrMBY, ppxlcCurrY, MB_SIZE*sizeof(PixelC)); // two rows for Y
//		ppxlcCurrMBY += MB_SIZE; ppxlcCurrY += iWidthY;
// ~RRV
	}
}

// compute error signal

Void CVideoObjectEncoder::computeTextureError ()
{
	CoordI ix;
// RRV insertion
	Int	iTmp	= (m_iRRVScale *m_iRRVScale);
// ~RRV
	// Y
// RRV modification
	for (ix = 0; ix < (MB_SQUARE_SIZE *iTmp); ix++)
//	for (ix = 0; ix < MB_SQUARE_SIZE; ix++)
// ~RRV
		m_ppxliErrorMBY [ix] = m_ppxlcCurrMBY [ix] - m_ppxlcPredMBY [ix];

	// UV
// RRV modification
	for (ix = 0; ix < (BLOCK_SQUARE_SIZE *iTmp); ix++) {
//	for (ix = 0; ix < BLOCK_SQUARE_SIZE; ix++) {
// ~RRV
		m_ppxliErrorMBU [ix] = m_ppxlcCurrMBU [ix] - m_ppxlcPredMBU [ix];
		m_ppxliErrorMBV [ix] = m_ppxlcCurrMBV [ix] - m_ppxlcPredMBV [ix];
	}

	// Alpha
  if(m_volmd.fAUsage==EIGHT_BIT) {
    for(Int iAuxComp=0;iAuxComp<m_volmd.iAuxCompCount;iAuxComp++) { // MAC (SB) 29-Nov-99
      
      for (ix = 0; ix < (MB_SQUARE_SIZE *iTmp); ix++)
        m_ppxliErrorMBA[iAuxComp][ix] = m_ppxlcCurrMBA[iAuxComp][ix] - m_ppxlcPredMBA[iAuxComp][ix];
    }
  }
}

Void CVideoObjectEncoder::computeTextureErrorWithShape ()
{
	CoordI ix;
	// Y
	for (ix = 0; ix < MB_SQUARE_SIZE; ix++) {
		if (m_ppxlcCurrMBBY [ix] == transpValue)
			m_ppxliErrorMBY [ix] = 0; // zero padding
		else
			m_ppxliErrorMBY [ix] = m_ppxlcCurrMBY [ix] - m_ppxlcPredMBY [ix];
	}

	// UV
	for (ix = 0; ix < BLOCK_SQUARE_SIZE; ix++) {
		if (m_ppxlcCurrMBBUV [ix] == transpValue)
			m_ppxliErrorMBU [ix] = m_ppxliErrorMBV [ix] = 0;
		else {
			m_ppxliErrorMBU [ix] = m_ppxlcCurrMBU [ix] - m_ppxlcPredMBU [ix];
			m_ppxliErrorMBV [ix] = m_ppxlcCurrMBV [ix] - m_ppxlcPredMBV [ix];
		}
	}

  if(m_volmd.fAUsage==EIGHT_BIT) {
    for(Int iAuxComp=0;iAuxComp<m_volmd.iAuxCompCount;iAuxComp++) { // MAC (SB) 29-Nov-99
      for (ix = 0; ix < MB_SQUARE_SIZE; ix++) {
        if (m_ppxlcCurrMBBY [ix] == transpValue)
          m_ppxliErrorMBA[iAuxComp] [ix] = 0; // zero padding
        else
          m_ppxliErrorMBA[iAuxComp] [ix] = m_ppxlcCurrMBA[iAuxComp] [ix] - m_ppxlcPredMBA[iAuxComp] [ix];
      }
    }
  }
}

Void CVideoObjectEncoder::computeAlphaError ()
{
	CoordI ix;

  for(Int iAuxComp=0;iAuxComp<m_volmd.iAuxCompCount;iAuxComp++) { // MAC (SB) 29-Nov-99
    for (ix = 0; ix < MB_SQUARE_SIZE; ix++) {
      if (m_ppxlcCurrMBBY [ix] == transpValue)
        m_ppxliErrorMBA[iAuxComp] [ix] = 0; // zero padding
      else
        m_ppxliErrorMBA[iAuxComp] [ix] = m_ppxlcCurrMBA[iAuxComp] [ix] - m_ppxlcPredMBA[iAuxComp] [ix];
    }
	}
}

// HHI Schueuer: added const PixelC *ppxlcCurrMBBY, const PixelC *ppxlcCurrMBBUV for sadct
Void CVideoObjectEncoder::quantizeTextureIntraMB (	
	Int imbX,
  Int imbY,
	CMBMode* pmbmd, 
	PixelC* ppxlcCurrQMBY,
  PixelC* ppxlcCurrQMBU,
  PixelC* ppxlcCurrQMBV,
	PixelC** pppxlcCurrQMBA,
	const PixelC *ppxlcCurrMBBY,
	const PixelC *ppxlcCurrMBBUV
)
{
	assert (pmbmd != NULL);
	assert (pmbmd -> m_dctMd == INTRA || pmbmd->m_dctMd == INTRAQ);
	assert (pmbmd -> m_rgTranspStatus [0] != ALL);

	Int iQP = pmbmd->m_stepSize;
#ifdef __TRACE_AND_STATS_
	m_statsMB.nQMB++;
	m_statsMB.nQp += iQP;
#endif // __TRACE_AND_STATS_

	Int iDcScalerY, iDcScalerC, iDcScalerA;
	if (iQP <= 4)
	{
		iDcScalerY = 8;
		iDcScalerC = 8;
	}
	else if (iQP >= 5 && iQP <= 8)
	{
		iDcScalerY = 2 * iQP;
		iDcScalerC = (iQP + 13) / 2;
	}
	else if (iQP >= 9 && iQP <= 24)
	{
		iDcScalerY = iQP + 8;
		iDcScalerC = (iQP + 13) / 2;
	}
	else
	{
		iDcScalerY = 2 * iQP - 16;
		iDcScalerC = iQP - 6;
	}

	Int iQPA;
  
  for(Int iAuxComp=0;iAuxComp<m_volmd.iAuxCompCount;iAuxComp++) // MAC (SB) 29-Nov-99
	  pmbmd->m_pCODAlpha[iAuxComp] = ALPHA_CODED;

	if(m_volmd.fAUsage == EIGHT_BIT)
	{
		if (pmbmd -> m_stepSizeAlpha < 1)
			pmbmd -> m_stepSizeAlpha = 1;
		iQPA = pmbmd->m_stepSizeAlpha;

		if (iQPA <= 4)
			iDcScalerA = 8;
		else if (iQPA >= 5 && iQPA <= 8)
			iDcScalerA = 2 * iQPA;
		else if (iQPA >= 9 && iQPA <= 24)
			iDcScalerA = iQPA + 8;
		else
			iDcScalerA = 2 * iQPA - 16;

		if(pmbmd->m_rgTranspStatus [0] == NONE)
		{
			// need to test gray alpha vals
			// CODA = 1 if all==255, can't use TranspStatus, has to be 255
			Int i;
			Int iThresh = 256 - iQPA;

      for(Int iAuxComp=0;iAuxComp<m_volmd.iAuxCompCount;iAuxComp++) { // MAC (SB) 29-Nov-99

        pmbmd->m_pCODAlpha[iAuxComp] = ALPHA_ALL255;
        for(i = 0; i<MB_SQUARE_SIZE; i++) {
          if(m_ppxlcCurrMBA[iAuxComp][i]<=iThresh)
          {
            pmbmd->m_pCODAlpha[iAuxComp] = ALPHA_CODED;
            break;
          }
        }
        if(pmbmd->m_pCODAlpha[iAuxComp] == ALPHA_ALL255)
        {
          pxlcmemset(m_ppxlcCurrMBA[iAuxComp], 255, MB_SQUARE_SIZE);
          PixelC *ppxlc = pppxlcCurrQMBA[iAuxComp];
          for(i = 0; i<MB_SIZE; i++, ppxlc += m_iFrameWidthY)
            pxlcmemset(ppxlc, 255, MB_SIZE);
        }        
      }
		}	
	}

	Int iCoefToStart;
	assert (pmbmd -> m_stepSizeDelayed > 0);
	if (pmbmd -> m_stepSizeDelayed >= grgiDCSwitchingThreshold [m_vopmd.iIntraDcSwitchThr])
	{
		pmbmd->m_bCodeDcAsAc = TRUE;
		//pmbmd->m_bCodeDcAsAcAlpha = TRUE; // decision should really be based on alpha quantiser
		iCoefToStart = 0;
	}
	else {
		pmbmd->m_bCodeDcAsAc = FALSE;
		//pmbmd->m_bCodeDcAsAcAlpha = FALSE;
		iCoefToStart = 1;
	}
	pmbmd->m_bCodeDcAsAcAlpha = FALSE;

	//for intra pred
	MacroBlockMemory* pmbmLeft = NULL;
	MacroBlockMemory* pmbmTop = NULL;
	MacroBlockMemory* pmbmLeftTop = NULL;
	CMBMode* pmbmdLeft = NULL;
	CMBMode* pmbmdTop = NULL;
	CMBMode* pmbmdLeftTop = NULL;											 
	Int iMBnum = imbY * m_iNumMBX + imbX;
	if (!bVPNoTop(iMBnum))	{
		pmbmTop  = m_rgpmbmAbove [imbX];
		pmbmdTop = pmbmd - m_iNumMBX;
	}
	if (!bVPNoLeft(iMBnum, imbX))	{
		pmbmLeft  = m_rgpmbmCurr [imbX - 1];
		pmbmdLeft = pmbmd -  1;
	}
	if (!bVPNoLeftTop(iMBnum, imbX))	{
		pmbmLeftTop  = m_rgpmbmAbove [imbX - 1];
		pmbmdLeftTop = pmbmd - m_iNumMBX - 1;
	}

// INTERLACE
	if((pmbmd->m_rgTranspStatus [0] == NONE)&&(m_vopmd.bInterlace == TRUE) ) {
		pmbmd->m_bFieldDCT = FrameFieldDCTDecideC(m_ppxlcCurrMBY);
		m_statsMB.nFieldDCTMB += (Int) pmbmd->m_bFieldDCT;
	}
	else
		pmbmd->m_bFieldDCT = 0;

	pmbmd->m_bSkip = FALSE;		// for direct mode reference 
// ~INTERLACE

	PixelC* rgchBlkDst = NULL;
	PixelC* rgchBlkSrc = NULL;
	Int iWidthDst, iWidthSrc;
	Int iDcScaler;
	Int* rgiCoefQ;
	Int iSumErr = 0; //sum of error to determine intra ac prediction
	Int iBlk;
//	Int iBlkEnd;
//	if(m_volmd.fAUsage == EIGHT_BIT)
//		iBlkEnd = A_BLOCK4;
//	else
//		iBlkEnd = V_BLOCK;

	// HHI Schueuer: for sadct, see also the cond. assignments inside the next switch stmt.
	const PixelC* rgchBlkShape = NULL;
	// end

	for (iBlk = (Int) Y_BLOCK1; iBlk <= (Int)pmbmd->blkEnd(); iBlk++) { // + 1 is because of the indexing
		if (iBlk < (Int) U_BLOCK || iBlk > (Int) V_BLOCK) {
			if(iBlk>=A_BLOCK1 && ((iBlk-7)%4)==0)
				iSumErr = 0; // start again for alpha planes
      if (iBlk>=A_BLOCK1 && pmbmd->m_rgTranspStatus [((iBlk-7)%4)+1] == ALL)
        continue;
			else if (iBlk<A_BLOCK1 && pmbmd -> m_rgTranspStatus [iBlk % 6] == ALL) // %6 hack!!
				continue;
      

      switch (iBlk) 
			{
			case (Y_BLOCK1): 
				rgchBlkDst = ppxlcCurrQMBY;
				rgchBlkSrc = m_ppxlcCurrMBY;
				rgchBlkShape = (ppxlcCurrMBBY && pmbmd -> m_rgTranspStatus[iBlk] == PARTIAL) ? ppxlcCurrMBBY : NULL;
				break;
			case (Y_BLOCK2): 
				rgchBlkDst = ppxlcCurrQMBY + BLOCK_SIZE;
				rgchBlkSrc = m_ppxlcCurrMBY + BLOCK_SIZE;
				rgchBlkShape = (ppxlcCurrMBBY && pmbmd -> m_rgTranspStatus[iBlk] == PARTIAL) ? ppxlcCurrMBBY + BLOCK_SIZE : NULL;
				break;
			case (Y_BLOCK3): 
// RRV modification
				rgchBlkDst = ppxlcCurrQMBY + (m_iFrameWidthYxBlkSize /m_iRRVScale);
//				rgchBlkDst = ppxlcCurrQMBY + m_iFrameWidthYxBlkSize;
// ~RRV
				rgchBlkSrc = m_ppxlcCurrMBY + MB_SIZE * BLOCK_SIZE;
				rgchBlkShape = (ppxlcCurrMBBY && pmbmd -> m_rgTranspStatus[iBlk] == PARTIAL) ? ppxlcCurrMBBY + BLOCK_SIZE*MB_SIZE : NULL;
				break;
			case (Y_BLOCK4): 
// RRV modification
				rgchBlkDst = ppxlcCurrQMBY + (m_iFrameWidthYxBlkSize /m_iRRVScale) + BLOCK_SIZE;
//				rgchBlkDst = ppxlcCurrQMBY + m_iFrameWidthYxBlkSize + BLOCK_SIZE;
// ~RRV
				rgchBlkSrc = m_ppxlcCurrMBY + MB_SIZE * BLOCK_SIZE + BLOCK_SIZE;
				rgchBlkShape = (ppxlcCurrMBBY && pmbmd -> m_rgTranspStatus[iBlk] == PARTIAL) ? ppxlcCurrMBBY + BLOCK_SIZE*MB_SIZE + BLOCK_SIZE : NULL;
				break;
      }

// MAC (SB) 29-Nov-99
      if (iBlk>=A_BLOCK1) { // alpha blocks
			  Int iABlk = ((iBlk-7)&0x3);
        iAuxComp = (iBlk-7)/4;
        iABlk++;

      	rgchBlkDst = pppxlcCurrQMBA[iAuxComp];
				rgchBlkSrc = m_ppxlcCurrMBA[iAuxComp];
    
        switch (iABlk) {
        case 1: rgchBlkShape = (ppxlcCurrMBBY && pmbmd -> m_rgTranspStatus[1] == PARTIAL) ? ppxlcCurrMBBY : NULL;
                break;
        case 2: rgchBlkDst += BLOCK_SIZE;
                rgchBlkSrc += BLOCK_SIZE;
                rgchBlkShape = (ppxlcCurrMBBY && pmbmd -> m_rgTranspStatus[2] == PARTIAL) ? ppxlcCurrMBBY + BLOCK_SIZE : NULL;        
                break;
        case 3: rgchBlkDst += m_iFrameWidthYxBlkSize;
                rgchBlkSrc += MB_SIZE * BLOCK_SIZE;
                rgchBlkShape = (ppxlcCurrMBBY && pmbmd -> m_rgTranspStatus[3] == PARTIAL) ? ppxlcCurrMBBY + BLOCK_SIZE*MB_SIZE : NULL;
                break;
        case 4: rgchBlkDst += m_iFrameWidthYxBlkSize + BLOCK_SIZE;
                rgchBlkSrc += MB_SIZE * BLOCK_SIZE + BLOCK_SIZE;
                rgchBlkShape = (ppxlcCurrMBBY && pmbmd -> m_rgTranspStatus[4] == PARTIAL) ? ppxlcCurrMBBY + BLOCK_SIZE*MB_SIZE + BLOCK_SIZE : NULL;
                break;
        }
      }
//~MAC

			iWidthDst = m_iFrameWidthY;
			iWidthSrc = MB_SIZE;
			if(iBlk<=V_BLOCK)
				iDcScaler = iDcScalerY; //m_rgiDcScalerY [iQP];
			else
				iDcScaler = iDcScalerA;
		}
		else {
			iWidthDst = m_iFrameWidthUV;
			iWidthSrc = BLOCK_SIZE;
			rgchBlkDst = (iBlk == U_BLOCK) ? ppxlcCurrQMBU: ppxlcCurrQMBV;
			rgchBlkSrc = (iBlk == U_BLOCK) ? m_ppxlcCurrMBU: m_ppxlcCurrMBV;