intyuvpicbuffer.cpp

jsvm开发代码包括抽样,编码,抽取,解码等一系列功能,可以做工具或研究用

Void IntYuvPicBuffer::xFillPlaneMargin( XPel *pucDest, Int iHeight, Int iWidth, Int iStride, Int iXMargin, Int iYMargin )
{
  XPel* puc;
  Int   n, m;

  // left and right borders at once
  puc = pucDest;
  for( n = 0; n < iHeight; n++)
  {
    // left border lum
    //::memset( puc - iXMargin, puc[0],         iXMargin*sizeof(XPel) );
    for( m = -iXMargin; m < 0; m++ )    puc[m] = puc[0];
    // right border lum
    //::memset( puc + iWidth,  puc[iWidth - 1], iXMargin*sizeof(XPel) );
    for( m = iWidth; m<iWidth+iXMargin; m++ ) puc[m] = puc[iWidth-1];
    puc += iStride;
  }

  // bot border lum
  puc = pucDest - iXMargin + iStride * iHeight;
  UInt uiSize = iWidth + 2*iXMargin;
  for( n = 0; n < iYMargin; n++)
  {
    ::memcpy( puc, puc - iStride, uiSize*sizeof(XPel) );
    puc += iStride;
  }

  // top border lum
  puc = pucDest - iXMargin;
  for( n = 0; n < iYMargin; n++)
  {
    ::memcpy( puc - iStride, puc, uiSize*sizeof(XPel) );
    puc -= iStride;
  }
}


Void IntYuvPicBuffer::setZero()
{
  Int     n;
  XPel*   p;
  m_rcYuvBufferCtrl.initMb();

  for(n=0,p=getMbLumAddr();n<getLHeight();n++){::memset(p,0x00,getLWidth()*sizeof(XPel) );p+=getLStride();} 
  for(n=0,p=getMbCbAddr ();n<getCHeight();n++){::memset(p,0x00,getCWidth()*sizeof(XPel) );p+=getCStride();} 
  for(n=0,p=getMbCrAddr ();n<getCHeight();n++){::memset(p,0x00,getCWidth()*sizeof(XPel) );p+=getCStride();} 
}








ErrVal IntYuvPicBuffer::update( IntYuvPicBuffer*  pcSrcYuvPicBuffer,
                                IntYuvPicBuffer*  pcMCPYuvPicBuffer0,
                                IntYuvPicBuffer*  pcMCPYuvPicBuffer1 )
{
  pcSrcYuvPicBuffer ->m_rcYuvBufferCtrl.initMb();
  pcMCPYuvPicBuffer0->m_rcYuvBufferCtrl.initMb();
  pcMCPYuvPicBuffer1->m_rcYuvBufferCtrl.initMb();
  m_rcYuvBufferCtrl.initMb();

  XPel* pSrcAnchor  = pcSrcYuvPicBuffer ->getMbLumAddr();
  XPel* pMCP0Anchor = pcMCPYuvPicBuffer0->getMbLumAddr();
  XPel* pMCP1Anchor = pcMCPYuvPicBuffer1->getMbLumAddr();
  XPel* pDesAnchor  = getMbLumAddr();
  Int   iSrcStride  = pcSrcYuvPicBuffer ->getLStride();
  Int   iMCP0Stride = pcMCPYuvPicBuffer0->getLStride();
  Int   iMCP1Stride = pcMCPYuvPicBuffer1->getLStride();
  Int   iDesStride  = getLStride();
  UInt  uiHeight    = getLHeight();
  UInt  uiWidth     = getLWidth ();
  UInt  y, x;

  //===== luminance =====
  for( y = 0; y < uiHeight; y++ )
  {
    XPel* pSrc  = pSrcAnchor  + y * iSrcStride;
    XPel* pMCP0 = pMCP0Anchor + y * iMCP0Stride;
    XPel* pMCP1 = pMCP1Anchor + y * iMCP1Stride;
    XPel* pDes  = pDesAnchor  + y * iDesStride;

    for( x = 0; x < uiWidth; x++ )
    {
      pDes[x] = gClip( pSrc[x] + ( ( pMCP0[x] + pMCP1[x] + 1 ) >> 2 ) );
    }
  }


  //===== chrominance U =====
  iSrcStride  >>= 1;
  iMCP0Stride >>= 1;
  iMCP1Stride >>= 1;
  iDesStride  >>= 1;
  uiHeight    >>= 1;
  uiWidth     >>= 1;
  pSrcAnchor    = pcSrcYuvPicBuffer ->getMbCbAddr();
  pMCP0Anchor   = pcMCPYuvPicBuffer0->getMbCbAddr();
  pMCP1Anchor   = pcMCPYuvPicBuffer1->getMbCbAddr();
  pDesAnchor    = getMbCbAddr();

  for( y = 0; y < uiHeight; y++ )
  {
    XPel* pSrc  = pSrcAnchor  + y * iSrcStride;
    XPel* pMCP0 = pMCP0Anchor + y * iMCP0Stride;
    XPel* pMCP1 = pMCP1Anchor + y * iMCP1Stride;
    XPel* pDes  = pDesAnchor  + y * iDesStride;

    for( x = 0; x < uiWidth; x++ )
    {
      pDes[x] = gClip( pSrc[x] + ( ( pMCP0[x] + pMCP1[x] + 1 ) >> 2 ) );
    }
  }

  //===== chrominance V =====
  pSrcAnchor    = pcSrcYuvPicBuffer ->getMbCrAddr();
  pMCP0Anchor   = pcMCPYuvPicBuffer0->getMbCrAddr();
  pMCP1Anchor   = pcMCPYuvPicBuffer1->getMbCrAddr();
  pDesAnchor    = getMbCrAddr();

  for( y = 0; y < uiHeight; y++ )
  {
    XPel* pSrc  = pSrcAnchor  + y * iSrcStride;
    XPel* pMCP0 = pMCP0Anchor + y * iMCP0Stride;
    XPel* pMCP1 = pMCP1Anchor + y * iMCP1Stride;
    XPel* pDes  = pDesAnchor  + y * iDesStride;

    for( x = 0; x < uiWidth; x++ )
    {
      pDes[x] = gClip( pSrc[x] + ( ( pMCP0[x] + pMCP1[x] + 1 ) >> 2 ) );
    }
  }

  return Err::m_nOK;
}






ErrVal IntYuvPicBuffer::inverseUpdate( IntYuvPicBuffer*  pcSrcYuvPicBuffer,
                                       IntYuvPicBuffer*  pcMCPYuvPicBuffer0,
                                       IntYuvPicBuffer*  pcMCPYuvPicBuffer1 )
{
  pcSrcYuvPicBuffer ->m_rcYuvBufferCtrl.initMb();
	if (pcMCPYuvPicBuffer0)
		pcMCPYuvPicBuffer0->m_rcYuvBufferCtrl.initMb();
	if (pcMCPYuvPicBuffer1)
		pcMCPYuvPicBuffer1->m_rcYuvBufferCtrl.initMb();
  m_rcYuvBufferCtrl.initMb();

	if (pcMCPYuvPicBuffer0 && pcMCPYuvPicBuffer1)
	{
		XPel* pSrcAnchor  = pcSrcYuvPicBuffer ->getMbLumAddr();
		XPel* pMCP0Anchor = pcMCPYuvPicBuffer0->getMbLumAddr();
		XPel* pMCP1Anchor = pcMCPYuvPicBuffer1->getMbLumAddr();
		XPel* pDesAnchor  = getMbLumAddr();
		Int   iSrcStride  = pcSrcYuvPicBuffer ->getLStride();
		Int   iMCP0Stride = pcMCPYuvPicBuffer0->getLStride();
		Int   iMCP1Stride = pcMCPYuvPicBuffer1->getLStride();
		Int   iDesStride  = getLStride();
		UInt  uiHeight    = getLHeight();
		UInt  uiWidth     = getLWidth ();
		UInt  y, x;

		//===== luminance =====
		for( y = 0; y < uiHeight; y++ )
		{
			XPel* pSrc  = pSrcAnchor  + y * iSrcStride;
			XPel* pMCP0 = pMCP0Anchor + y * iMCP0Stride;
			XPel* pMCP1 = pMCP1Anchor + y * iMCP1Stride;
			XPel* pDes  = pDesAnchor  + y * iDesStride;

			for( x = 0; x < uiWidth; x++ )
			{
				pDes[x] = gClip( pSrc[x] - ( ( pMCP0[x] + pMCP1[x] + 1 ) >> 2 ) );
			}
		}


		//===== chrominance U =====
		iSrcStride  >>= 1;
		iMCP0Stride >>= 1;
		iMCP1Stride >>= 1;
		iDesStride  >>= 1;
		uiHeight    >>= 1;
		uiWidth     >>= 1;
		pSrcAnchor    = pcSrcYuvPicBuffer ->getMbCbAddr();
		pMCP0Anchor   = pcMCPYuvPicBuffer0->getMbCbAddr();
		pMCP1Anchor   = pcMCPYuvPicBuffer1->getMbCbAddr();
		pDesAnchor    = getMbCbAddr();

		for( y = 0; y < uiHeight; y++ )
		{
			XPel* pSrc  = pSrcAnchor  + y * iSrcStride;
			XPel* pMCP0 = pMCP0Anchor + y * iMCP0Stride;
			XPel* pMCP1 = pMCP1Anchor + y * iMCP1Stride;
			XPel* pDes  = pDesAnchor  + y * iDesStride;

			for( x = 0; x < uiWidth; x++ )
			{
				pDes[x] = gClip( pSrc[x] - ( ( pMCP0[x] + pMCP1[x] + 1 ) >> 2 ) );
			}
		}

		//===== chrominance V =====
		pSrcAnchor    = pcSrcYuvPicBuffer ->getMbCrAddr();
		pMCP0Anchor   = pcMCPYuvPicBuffer0->getMbCrAddr();
		pMCP1Anchor   = pcMCPYuvPicBuffer1->getMbCrAddr();
		pDesAnchor    = getMbCrAddr();

		for( y = 0; y < uiHeight; y++ )
		{
			XPel* pSrc  = pSrcAnchor  + y * iSrcStride;
			XPel* pMCP0 = pMCP0Anchor + y * iMCP0Stride;
			XPel* pMCP1 = pMCP1Anchor + y * iMCP1Stride;
			XPel* pDes  = pDesAnchor  + y * iDesStride;

			for( x = 0; x < uiWidth; x++ )
			{
				pDes[x] = gClip( pSrc[x] - ( ( pMCP0[x] + pMCP1[x] + 1 ) >> 2 ) );
			}
		}
	}
	else
	{
		XPel* pSrcAnchor  = pcSrcYuvPicBuffer ->getMbLumAddr();
		XPel* pMCAnchor ;
		XPel* pDesAnchor  = getMbLumAddr();

		Int   iSrcStride  = pcSrcYuvPicBuffer ->getLStride();
		Int   iMCStride;

		Int   iDesStride  = getLStride();
		UInt  uiHeight    = getLHeight();
		UInt  uiWidth     = getLWidth ();
		UInt  y, x;

		if (pcMCPYuvPicBuffer0)
		{
			pMCAnchor = pcMCPYuvPicBuffer0->getMbLumAddr();
			iMCStride = pcMCPYuvPicBuffer0->getLStride();
		}
		else
		{
			pMCAnchor = pcMCPYuvPicBuffer1->getMbLumAddr();
			iMCStride = pcMCPYuvPicBuffer1->getLStride();
		}
		
		//===== luminance =====
		for( y = 0; y < uiHeight; y++ )
		{
			XPel* pSrc  = pSrcAnchor  + y * iSrcStride;
			XPel* pMC		= pMCAnchor		+ y * iMCStride;
			XPel* pDes  = pDesAnchor  + y * iDesStride;

			for( x = 0; x < uiWidth; x++ )
			{
				pDes[x] = gClip( pSrc[x] - ( ( pMC[x] + 1 ) >> 2 ) );
			}
		}


		//===== chrominance U =====
		iSrcStride  >>= 1;
		iMCStride >>= 1;
		iDesStride  >>= 1;
		uiHeight    >>= 1;
		uiWidth     >>= 1;
		pSrcAnchor    = pcSrcYuvPicBuffer ->getMbCbAddr();
		if (pcMCPYuvPicBuffer0)
		{
			pMCAnchor = pcMCPYuvPicBuffer0->getMbCbAddr();
		}
		else
		{
			pMCAnchor = pcMCPYuvPicBuffer1->getMbCbAddr();
		}
		pDesAnchor    = getMbCbAddr();

		for( y = 0; y < uiHeight; y++ )
		{
			XPel* pSrc  = pSrcAnchor  + y * iSrcStride;
			XPel* pMC		= pMCAnchor		+ y * iMCStride;
			XPel* pDes  = pDesAnchor  + y * iDesStride;

			for( x = 0; x < uiWidth; x++ )
			{
				pDes[x] = gClip( pSrc[x] - ( ( pMC[x] + 1 ) >> 2 ) );
			}
		}

		//===== chrominance V =====
		pSrcAnchor    = pcSrcYuvPicBuffer ->getMbCrAddr();
		if (pcMCPYuvPicBuffer0)
		{
			pMCAnchor = pcMCPYuvPicBuffer0->getMbCbAddr();
		}
		else
		{
			pMCAnchor = pcMCPYuvPicBuffer1->getMbCbAddr();
		}
		pDesAnchor    = getMbCrAddr();

		for( y = 0; y < uiHeight; y++ )
		{
			XPel* pSrc  = pSrcAnchor  + y * iSrcStride;
			XPel* pMC		= pMCAnchor		+ y * iMCStride;
			XPel* pDes  = pDesAnchor  + y * iDesStride;

			for( x = 0; x < uiWidth; x++ )
			{
				pDes[x] = gClip( pSrc[x] - ( ( pMC[x] + 1 ) >> 2 ) );
			}
		}
	}

  return Err::m_nOK;
}

//-- JVT-R091
ErrVal IntYuvPicBuffer::smoothMbInside()
{
  Int   y, x;
  Int   iStride;
  XPel* pDes;
	XPel	iA;
	XPel	pTmp[16];

	// ------------------------------------------------------------------------
	// Luma
	// ------------------------------------------------------------------------

	iStride = getLStride	();
	pDes		= getMbLumAddr();

	// Step #1: horizontal smoothing process
	for( y = 0; y < 16; y++ )
	{
		for( x = 1; x < 15; x++ )
		{
			iA = ( pDes[x-1]+pDes[x]*2+pDes[x+1]+2 ) >> 2;
			pTmp[x] = iA;
		}
		for( x = 1; x < 15; x++ ) pDes[x] = pTmp[x];
		pDes += iStride;
	}

	// Step #2: vertical smoothing process
	pDes = getMbLumAddr() + iStride;
	for( y = 1; y < 15; y++ )
	{
		for( x = 0; x < 16; x++ )
		{
			iA = ( pDes[x-iStride]+pDes[x]*2+pDes[x+iStride]+2 ) >> 2;
			pTmp[x] = iA;
		}
		for( x = 0; x < 16; x++ ) pDes[x] = pTmp[x];
		pDes += iStride;
	}

	// ------------------------------------------------------------------------
	// Chroma (Cb)
	// ------------------------------------------------------------------------

	iStride = getCStride  ();
	pDes		= getMbCbAddr	();

	// Step #1: horizontal smoothing process
	for( y = 0; y < 8; y++ )
	{
		for( x = 1; x < 7; x++ )
		{
			iA = ( pDes[x-1]+pDes[x]*2+pDes[x+1]+2 ) >> 2;
			pTmp[x] = iA;
		}
		for( x = 1; x < 7; x++ ) pDes[x] = pTmp[x];
		pDes += iStride;
	}

	// Step #2: vertical smoothing process
	pDes = getMbCbAddr() + iStride;
	for( y = 1; y < 7; y++ )
	{
		for( x = 0; x < 8; x++ )
		{
			iA = ( pDes[x-iStride]+pDes[x]*2+pDes[x+iStride]+2 ) >> 2;
			pTmp[x] = iA;
		}
		for( x = 0; x < 8; x++ ) pDes[x] = pTmp[x];
		pDes += iStride;
	}

	// ------------------------------------------------------------------------
	// Chroma (Cr)
	// ------------------------------------------------------------------------

	iStride = getCStride  ();
	pDes		= getMbCrAddr	();

	// Step #1: horizontal smoothing process
	for( y = 0; y < 8; y++ )
	{
		for( x = 1; x < 7; x++ )
		{
			iA = ( pDes[x-1]+pDes[x]*2+pDes[x+1]+2 ) >> 2;
			pTmp[x] = iA;
		}
		for( x = 1; x < 7; x++ ) pDes[x] = pTmp[x];
		pDes += iStride;
	}

	// Step #2: vertical smoothing process
	pDes = getMbCrAddr() + iStride;
	for( y = 1; y < 7; y++ )
	{
		for( x = 0; x < 8; x++ )
		{
			iA = ( pDes[x-iStride]+pDes[x]*2+pDes[x+iStride]+2 ) >> 2;
			pTmp[x] = iA;
		}
		for( x = 0; x < 8; x++ ) pDes[x] = pTmp[x];
		pDes += iStride;
	}

	return Err::m_nOK;
}

ErrVal IntYuvPicBuffer::smoothMbTop ()
{
  Int   x;
  Int   iStride;
  XPel* pDes;
	XPel  iA;
	XPel	pTmp[16];

	// disable smoothing across MB boundary due to FMO
	return Err::m_nOK;

	// ------------------------------------------------------------------------
	// Luma
	// ------------------------------------------------------------------------

	iStride = getLStride  ();
	pDes		= getMbLumAddr();
	for( x = 0; x < 16; x++ )
	{
		iA = ( pDes[x-iStride]+pDes[x+iStride]*2+pDes[x+iStride]+2 ) >> 2;
		pTmp[x] = iA;
	}
	for( x = 0; x < 16; x++ ) pDes[x] = pTmp[x];

	// ------------------------------------------------------------------------
	// Chroma (Cb)
	// ------------------------------------------------------------------------

	iStride = getCStride  ();
	pDes		= getMbCbAddr();
	for( x = 0; x < 8; x++ )
	{
		iA = ( pDes[x-iStride]+pDes[x+iStride]*2+pDes[x+iStride]+2 ) >> 2;
		pTmp[x] = iA;
	}
	for( x = 0; x < 8; x++ ) pDes[x] = pTmp[x];

	// ------------------------------------------------------------------------
	// Chroma (Cr)
	// ------------------------------------------------------------------------

	iStride = getCStride  ();
	pDes		= getMbCrAddr();
	for( x = 0; x < 8; x++ )
	{
		iA = ( pDes[x-iStride]+pDes[x+iStride]*2+pDes[x+iStride]+2 ) >> 2;
		pTmp[x] = iA;
	}
	for( x = 0; x < 8; x++ ) pDes[x] = pTmp[x];

	return Err::m_nOK;
}

ErrVal IntYuvPicBuffer::smoothMbLeft ()
{
  Int   y;
  Int   iStride;
  XPel* pDes;
	XPel  iA;
	XPel	pTmp[16];

	// disable smoothing across MB boundary due to FMO
	return Err::m_nOK;

	// ------------------------------------------------------------------------
	// Luma
	// ------------------------------------------------------------------------

	iStride = getLStride();
	pDes		= getMbLumAddr();
	for( y = 0; y < 16; y++ )
	{
		iA = ( pDes[-1]+pDes[0]*2+pDes[1]+2 ) >> 2;
		pTmp[y] = iA;
		pDes += iStride;
	}
	pDes		= getMbLumAddr();
	for( y = 0; y < 16; y++ )
	{
		pDes[0] = pTmp[y];
		pDes += iStride;
	}

	// ------------------------------------------------------------------------
	// Chroma (Cb)
	// ------------------------------------------------------------------------

	iStride = getCStride();
	pDes		= getMbCbAddr();
	for( y = 0; y < 8; y++ )
	{
		iA = ( pDes[-1]+pDes[0]*2+pDes[1]+2 ) >> 2;
		pTmp[y] = iA;
		pDes += iStride;
	}
	pDes		= getMbCbAddr();
	for( y = 0; y < 8; y++ )
	{
		pDes[0] = pTmp[y];
		pDes += iStride;
	}

	// ------------------------------------------------------------------------
	// Chroma (Cr)
	// ------------------------------------------------------------------------

	iStride = getCStride();
	pDes		= getMbCrAddr();
	for( y = 0; y < 8; y++ )
	{
		iA = ( pDes[-1]+pDes[0]*2+pDes[1]+2 ) >> 2;
		pTmp[y] = iA;
		pDes += iStride;
	}
	pDes		= getMbCrAddr();
	for( y = 0; y < 8; y++ )
	{
		pDes[0] = pTmp[y];
		pDes += iStride;
	}

	return Err::m_nOK;
}
//--

H264AVC_NAMESPACE_END