frame.cpp

JVT-Z203_jsvm.rar

  {
    if( NULL != m_pcFrameTopField )
		{
			RNOK( m_pcFrameTopField->uninit() );
		}
		if( NULL == m_pcFrameTopField )
    {
			YuvBufferCtrl& rcYuvFullPelBufferCtrl = getFullPelYuvBuffer()->getBufferCtrl();
			YuvBufferCtrl& rcYuvHalfPelBufferCtrl = getHalfPelYuvBuffer()->getBufferCtrl();

			RNOK( Frame::create( m_pcFrameTopField, rcYuvFullPelBufferCtrl, rcYuvHalfPelBufferCtrl, TOP_FIELD, this ) );
		}

    // creates private full pel buffer
    XPel* pData = getFullPelYuvBuffer()->getBuffer();
    RNOK( m_pcFrameTopField->getFullPelYuvBuffer()->init( pData ) );
    RNOK( m_pcFrameTopField->getFullPelYuvBuffer()->fillMargin() );

    m_pcFrameTopField->setPoc( m_iTopFieldPoc );
    m_pcFrameTopField->setFrameNum( m_iFrameNum );
  }
  else if( ePicType == BOT_FIELD )
  {
		if( NULL != m_pcFrameBotField )
		{
			RNOK( m_pcFrameBotField->uninit() );
		}
		if( NULL == m_pcFrameBotField )
    {
			YuvBufferCtrl& rcYuvFullPelBufferCtrl = getFullPelYuvBuffer()->getBufferCtrl();
			YuvBufferCtrl& rcYuvHalfPelBufferCtrl = getHalfPelYuvBuffer()->getBufferCtrl();

			RNOK( Frame::create( m_pcFrameBotField, rcYuvFullPelBufferCtrl, rcYuvHalfPelBufferCtrl, BOT_FIELD, this ) );
		}

    // creates private full pel buffer
    XPel* pData = getFullPelYuvBuffer()->getBuffer();
    RNOK( m_pcFrameBotField->getFullPelYuvBuffer()->init( pData ) );
    RNOK( m_pcFrameBotField->getFullPelYuvBuffer()->fillMargin() );

    m_pcFrameBotField->setPoc( m_iBotFieldPoc );
    m_pcFrameBotField->setFrameNum( m_iFrameNum );
  }

  return Err::m_nOK;
}

ErrVal Frame::addFrameFieldBuffer()
{
  ASSERT( m_ePicType==FRAME );

  RNOK( addFieldBuffer( TOP_FIELD ) );
  RNOK( addFieldBuffer( BOT_FIELD ) );

  return Err::m_nOK;
}

ErrVal Frame::extendFrame( QuarterPelFilter* pcQuarterPelFilter, PicType ePicType, Bool bFrameMbsOnlyFlag )
{
	ASSERT( m_ePicType==FRAME );

	const Bool bNoHalfPel = ( NULL == pcQuarterPelFilter );

	if( NULL != m_pcFrameTopField || NULL != m_pcFrameBotField )
  {
    RNOK( removeFrameFieldBuffer() );
  }

	// perform border padding on the full pel buffer
  RNOK( getFullPelYuvBuffer()->fillMargin( ) );
  m_bExtended     = true;
  
	if( ! bFrameMbsOnlyFlag )
	{
		if( ePicType==FRAME )
		{
			if( NULL == m_pcFrameTopField || NULL == m_pcFrameBotField )
			{
				ROT( NULL != m_pcFrameTopField );
				ROT( NULL != m_pcFrameTopField );
				YuvBufferCtrl& rcYuvFullPelBufferCtrl = getFullPelYuvBuffer()->getBufferCtrl();
				YuvBufferCtrl& rcYuvHalfPelBufferCtrl = getHalfPelYuvBuffer()->getBufferCtrl();

				RNOK( Frame::create( m_pcFrameTopField, rcYuvFullPelBufferCtrl, rcYuvHalfPelBufferCtrl, TOP_FIELD, this ) );
				RNOK( Frame::create( m_pcFrameBotField, rcYuvFullPelBufferCtrl, rcYuvHalfPelBufferCtrl, BOT_FIELD, this ) );

				// creates private full pel buffer
				XPel* pData = NULL;
				RNOK( m_pcFrameTopField->getFullPelYuvBuffer()->init( pData ) );
//TMM {
        m_pcFrameTopField->setPoc     ( m_iTopFieldPoc );
        m_pcFrameTopField->setFrameNum( m_iFrameNum );
//TMM }
				RNOK( m_pcFrameBotField->getFullPelYuvBuffer()->init( pData ) );
//TMM {
        m_pcFrameBotField->setPoc     ( m_iBotFieldPoc );
        m_pcFrameBotField->setFrameNum( m_iFrameNum );
//TMM }       
			}
		}
		else
		{
			RNOK( addFrameFieldBuffer() );
		}

  // perform border padding on the full pel buffer
		RNOK( m_pcFrameTopField->getFullPelYuvBuffer()->loadBufferAndFillMargin( getFullPelYuvBuffer() ) );
		RNOK( m_pcFrameBotField->getFullPelYuvBuffer()->loadBufferAndFillMargin( getFullPelYuvBuffer() ) );
		m_pcFrameTopField->setExtended();
		m_pcFrameBotField->setExtended();

		if( ! bNoHalfPel )
		{
			XPel* pHPData = NULL;
			RNOK( m_pcFrameTopField->initHalfPel( pHPData ) );
			RNOK( m_pcFrameBotField->initHalfPel( pHPData ) );
		}
	}

  // if cond is true no sub pel buffer is used
  ROTRS( bNoHalfPel, Err::m_nOK );

  // create half pel samples
  RNOK( pcQuarterPelFilter->filterFrame(                         getFullPelYuvBuffer(),                       getHalfPelYuvBuffer() ) );

	if( ! bFrameMbsOnlyFlag )
	{
		RNOK( pcQuarterPelFilter->filterFrame( m_pcFrameTopField->getFullPelYuvBuffer(), m_pcFrameTopField->getHalfPelYuvBuffer() ) );
		RNOK( pcQuarterPelFilter->filterFrame( m_pcFrameBotField->getFullPelYuvBuffer(), m_pcFrameBotField->getHalfPelYuvBuffer() ) );
	}

  return Err::m_nOK;
}

ErrVal 
Frame::intraUpsampling( Frame*                pcBaseFrame, 
                        Frame*                pcTempBaseFrame,
                        Frame*                pcTempFrame,
                        DownConvert&          rcDownConvert,
                        ResizeParameters*     pcParameters,
                        MbDataCtrl*           pcMbDataCtrlBase, 
                        MbDataCtrl*           pcMbDataCtrlPredFrm, 
                        MbDataCtrl*           pcMbDataCtrlPredFld, 
                        ReconstructionBypass* pcReconstructionBypass,
                        Bool                  bConstrainedIntraUpsamplingFlag,
                        Bool*                 pabBaseModeAllowedFlagArrayFrm, 
                        Bool*                 pabBaseModeAllowedFlagArrayFld )
{
  AOF ( m_ePicType == FRAME );
  rcDownConvert.intraUpsampling( this, pcBaseFrame, pcTempFrame, pcTempBaseFrame, pcParameters, 
                                 pcMbDataCtrlBase, pcMbDataCtrlPredFrm, pcMbDataCtrlPredFld,
                                 pcReconstructionBypass, pabBaseModeAllowedFlagArrayFrm, pabBaseModeAllowedFlagArrayFld, bConstrainedIntraUpsamplingFlag );
  return Err::m_nOK;
}

ErrVal
Frame::residualUpsampling( Frame*             pcBaseFrame, 
                           DownConvert&       rcDownConvert,
                           ResizeParameters*  pcParameters,
                           MbDataCtrl*        pcMbDataCtrlBase )
{
  AOF ( m_ePicType == FRAME );
  rcDownConvert.residualUpsampling( this, pcBaseFrame, pcParameters, pcMbDataCtrlBase );
  return Err::m_nOK;
}


Void Frame::initChannelDistortion()
{
	if(!m_piChannelDistortion)
	{
		UInt  uiMbY  = getFullPelYuvBuffer()->getLHeight()/4;
		UInt  uiMbX  = getFullPelYuvBuffer()->getLWidth()/4;
		UInt  uiSize = uiMbX*uiMbY;
		m_piChannelDistortion= new UInt[uiSize];
	}
}

Void Frame::copyChannelDistortion(Frame*p1)
{
	UInt  uiMbY  = getFullPelYuvBuffer()->getLHeight()/16;
	UInt  uiMbX  = getFullPelYuvBuffer()->getLWidth()/16;
	for(UInt y=0;y<uiMbY*4;y++)
	{
		for(UInt x=0;x<uiMbX*4;x++)
		{ 
			m_piChannelDistortion[y*(uiMbX*4)+x]=p1->m_piChannelDistortion[y*(uiMbX*4)+x];
		}
	}
}

Void Frame::zeroChannelDistortion()
{
	UInt  uiMbY  = getFullPelYuvBuffer()->getLHeight()/16;
	UInt  uiMbX  = getFullPelYuvBuffer()->getLWidth()/16;
	for(UInt y=0;y<uiMbY*4;y++)
	{
		for(UInt x=0;x<uiMbX*4;x++)
		{ 
			m_piChannelDistortion[y*(uiMbX*4)+x]=0;
		}
	}
}

const PictureParameters& 
Frame::getPicParameters() const
{
  return getPicParameters( m_ePicType );
}

const PictureParameters&
Frame::getPicParameters( PicType ePicType ) const
{
  if( ePicType == BOT_FIELD )
  {
    return m_cPicParametersBot;
  }
  return m_cPicParameters;
}

ErrVal
Frame::setPicParameters( const ResizeParameters& rcRP, const SliceHeader* pcSH )
{
  PictureParameters cPP;
  cPP.m_iScaledRefFrmWidth    = rcRP.m_iScaledRefFrmWidth;
  cPP.m_iScaledRefFrmHeight   = rcRP.m_iScaledRefFrmHeight;
  cPP.m_iLeftFrmOffset        = rcRP.m_iLeftFrmOffset;
  cPP.m_iTopFrmOffset         = rcRP.m_iTopFrmOffset;
  cPP.m_iRefLayerChromaPhaseX = rcRP.m_iRefLayerChromaPhaseX;
  cPP.m_iRefLayerChromaPhaseY = rcRP.m_iRefLayerChromaPhaseY;

  PicType ePicType = FRAME;
  if( pcSH && pcSH->getFieldPicFlag() )
  {
    ePicType = ( pcSH->getBottomFieldFlag() ? BOT_FIELD : TOP_FIELD );
  }

  RNOK( setPicParameters( cPP, ePicType ) );
  return Err::m_nOK;
}

ErrVal 
Frame::setPicParameters( const PictureParameters& rcPP, PicType ePicType )
{
  //===== set in current pictures =====
  if( ePicType == FRAME || ePicType == TOP_FIELD )
  {
    m_cPicParameters    = rcPP;
  }
  if( ePicType == FRAME || ePicType == BOT_FIELD )
  {
    m_cPicParametersBot = rcPP;
  }
  RNOK( xUpdatePicParameters() );
  return Err::m_nOK;
}

ErrVal
Frame::copyPicParameters( const Frame& rcFrame, PicType ePicType )
{
  //===== set in current pictures =====
  if( ePicType == FRAME || ePicType == TOP_FIELD )
  {
    m_cPicParameters    = rcFrame.m_cPicParameters;
  }
  if( ePicType == FRAME || ePicType == BOT_FIELD )
  {
    m_cPicParametersBot = rcFrame.m_cPicParametersBot;
  }
  RNOK( xUpdatePicParameters() );
  return Err::m_nOK;
}

ErrVal
Frame::xUpdatePicParameters()
{
  //===== set in associated frame or top and bot field =====
  if( m_ePicType == FRAME )
  {
    if( m_pcFrameTopField )
    {
      m_pcFrameTopField->m_cPicParameters     = m_cPicParameters;
      m_pcFrameTopField->m_cPicParametersBot  = m_cPicParametersBot;
    }
    if( m_pcFrameBotField )
    {
      m_pcFrameBotField->m_cPicParameters     = m_cPicParameters;
      m_pcFrameBotField->m_cPicParametersBot  = m_cPicParametersBot;
    }
  }
  else if( m_ePicType == TOP_FIELD )
  {
    ROF( m_pcFrame );
    m_pcFrame->m_cPicParameters     = m_cPicParameters;
    m_pcFrame->m_cPicParametersBot  = m_cPicParametersBot;
    if( m_pcFrame->m_pcFrameBotField )
    {
      m_pcFrameBotField->m_cPicParameters     = m_cPicParameters;
      m_pcFrameBotField->m_cPicParametersBot  = m_cPicParametersBot;
    }
  }
  else if( m_ePicType == TOP_FIELD )
  {
    ROF( m_pcFrame );
    m_pcFrame->m_cPicParameters     = m_cPicParameters;
    m_pcFrame->m_cPicParametersBot  = m_cPicParametersBot;
    if( m_pcFrame->m_pcFrameTopField )
    {
      m_pcFrameTopField->m_cPicParameters     = m_cPicParameters;
      m_pcFrameTopField->m_cPicParametersBot  = m_cPicParametersBot;
    }
  }
  return Err::m_nOK;
}


H264AVC_NAMESPACE_END