frame.h

SVC最新更新代码

  }
  
    //JVT-X046 {
  ErrVal predictionSlices       (Frame* pcSrcFrame,Frame* pcMCPFrame, UInt uiMbY, UInt uiMbX)
  {	 
	  RNOK( getFullPelYuvBuffer()->predictionSlices( pcSrcFrame->getFullPelYuvBuffer(), pcMCPFrame->getFullPelYuvBuffer(), uiMbY, uiMbX ) );
	  return Err::m_nOK;
  }
  ErrVal inversepredictionSlices       (Frame* pcSrcFrame,Frame* pcMCPFrame, UInt uiMbY, UInt uiMbX)
  {	 
	  RNOK( getFullPelYuvBuffer()->inversepredictionSlices( pcSrcFrame->getFullPelYuvBuffer(), pcMCPFrame->getFullPelYuvBuffer(), uiMbY, uiMbX ) );
	  return Err::m_nOK;
  }
  ErrVal copyMb       (Frame* pcSrcFrame, UInt uiMbY ,UInt uiMbX)
  {	 
	  RNOK( getFullPelYuvBuffer()->copyMb( pcSrcFrame->getFullPelYuvBuffer(), uiMbY, uiMbX ) );
	  return Err::m_nOK;
  }
	void   setMBZero( UInt uiMBY, UInt uiMBX ) { getFullPelYuvBuffer()->setMBZero(uiMBY,uiMBX); }
	ErrVal copySlice (Frame* pcSrcFrame, PicType ePicType, UInt uiFirstMB, UInt uiLastMB)
  {
	  ASSERT( m_ePicType==FRAME );
	  if( ePicType==FRAME )
	  {
		  RNOK( getFullPelYuvBuffer()->copySlice( pcSrcFrame->getFullPelYuvBuffer(),uiFirstMB,uiLastMB) );
	  }
	  return Err::m_nOK;
  }
	//JVT-X046 }

  ErrVal  subtract    ( Frame* pcSrcFrame0, Frame* pcSrcFrame1 )
  {
    ASSERT( m_ePicType==FRAME );
    RNOK( getFullPelYuvBuffer()->subtract( pcSrcFrame0->getFullPelYuvBuffer(), pcSrcFrame1->getFullPelYuvBuffer() ) );
    return Err::m_nOK;
  }
  
  ErrVal add              ( Frame* pcSrcFrame,  PicType ePicType )
  {
    ASSERT( m_ePicType==FRAME );

    if( ePicType==FRAME )
  {
    RNOK( getFullPelYuvBuffer()->add ( pcSrcFrame->getFullPelYuvBuffer()) );
    }
    else
    {
			RNOK(             addFieldBuffer( ePicType ) );
			RNOK( pcSrcFrame->addFieldBuffer( ePicType ) );
      RNOK( getPic( ePicType )->getFullPelYuvBuffer()->add( pcSrcFrame->getPic( ePicType )->getFullPelYuvBuffer() ) );
    }
    return Err::m_nOK;
  }
  
  ErrVal  setZero     ()
  {
    ASSERT( m_ePicType==FRAME );
    getFullPelYuvBuffer()->setZero();
    return Err::m_nOK;
  }

  ErrVal  setNonZeroFlags( UShort* pusNonZeroFlags, UInt uiStride )
  {
    ASSERT( m_ePicType==FRAME );
    return getFullPelYuvBuffer()->setNonZeroFlags( pusNonZeroFlags, uiStride );
  }

  ErrVal getSSD( Double& dSSDY, Double& dSSDU, Double& dSSDV, PicBuffer* pcOrgPicBuffer )
  {
    ASSERT( m_ePicType==FRAME );
    RNOK( m_cFullPelYuvBuffer.getSSD( dSSDY, dSSDU, dSSDV, pcOrgPicBuffer ) );
    return Err::m_nOK;
  }

  ErrVal dump( FILE* pFile, Int uiBandType, MbDataCtrl* pcMbDataCtrl )
  {
    if( uiBandType != 0 )
    {
      RNOK( getFullPelYuvBuffer()->dumpHPS( pFile, pcMbDataCtrl ) );
    }
    else
    {
      RNOK( getFullPelYuvBuffer()->dumpLPS( pFile ) );
    }
		fflush( pFile );
    return Err::m_nOK;
  }

  ErrVal  intraUpsampling   ( Frame*                pcBaseFrame, 
                              Frame*                pcTempBaseFrame,
                              Frame*                pcTempFrame,
                              DownConvert&          rcDownConvert,
                              ResizeParameters*     pcParameters,
                              MbDataCtrl*           pcMbDataCtrlBase, 
                              MbDataCtrl*           pcMbDataCtrlPredFrm, 
                              MbDataCtrl*           pcMbDataCtrlPredFld, 
                              ReconstructionBypass* pcReconstructionBypass,
                              Bool                  bConstrainedIntraUpsamplingFlag,
                              Bool*                 pabBaseModeAllowedFlagArrayFrm = 0, 
                              Bool*                 pabBaseModeAllowedFlagArrayFld = 0 );
  ErrVal residualUpsampling ( Frame*                pcBaseFrame,
                              DownConvert&          rcDownConvert,
                              ResizeParameters*     pcParameters,
                              MbDataCtrl*           pcMbDataCtrlBase );

  YuvPicBuffer*  getFullPelYuvBuffer     ()        { return &m_cFullPelYuvBuffer; }
  YuvPicBuffer*  getHalfPelYuvBuffer     ()        { return &m_cHalfPelYuvBuffer; }

	Bool  isPocAvailable()           const { return m_bPocIsSet; }
	Int   getPoc        ()           const { return m_iPoc; }
  Int   getTopFieldPoc()           const { return m_iTopFieldPoc; }
  Int   getBotFieldPoc()           const { return m_iBotFieldPoc; }

  Void  clearPoc      ()
  {
    if( m_pcFrameTopField )
    {
      m_pcFrameTopField->clearPoc();
    }
    if( m_pcFrameBotField )
    {
      m_pcFrameBotField->clearPoc();
    }
    m_iTopFieldPoc  = MSYS_INT_MIN;
    m_iBotFieldPoc  = MSYS_INT_MIN;
    m_iPoc          = MSYS_INT_MIN;
    m_bPocIsSet     = false;
  }

	Void  setPoc        ( Int iPoc )       { m_iPoc = iPoc; m_bPocIsSet = true; }
	Void  setPoc        ( const SliceHeader& rcSH )
	{ 
		ASSERT( m_ePicType==FRAME );
		const PicType ePicType = rcSH.getPicType();

    if( ePicType & TOP_FIELD )
    {
      m_iTopFieldPoc = rcSH.getTopFieldPoc();
      if( m_pcFrameTopField && m_pcFrameBotField )
      {
        m_pcFrameTopField->setPoc( m_iTopFieldPoc );
        setPoc( m_pcFrameBotField->isPocAvailable() ? max( m_pcFrameBotField->getPoc(), m_iTopFieldPoc ) : m_iTopFieldPoc );
      }
    }
    if( ePicType & BOT_FIELD )
    {
      m_iBotFieldPoc = rcSH.getBotFieldPoc();
      if( m_pcFrameTopField && m_pcFrameBotField )
      {
        m_pcFrameBotField->setPoc( m_iBotFieldPoc );
        setPoc( m_pcFrameTopField->isPocAvailable() ? min( m_pcFrameTopField->getPoc(), m_iBotFieldPoc ) : m_iBotFieldPoc );
      }
    }
    if( ! m_pcFrameTopField || ! m_pcFrameBotField )
    {
      setPoc( max( m_iTopFieldPoc, m_iBotFieldPoc ) );
    }
  }

  Bool  isHalfPel()   { return m_bHalfPel; }

  const Frame*  getPic( PicType ePicType ) const;
  Frame*        getPic( PicType ePicType );

	PicType getPicType ()            const { return m_ePicType; }
	Void setPicType    ( PicType ePicType ){ m_ePicType = ePicType; }

  Bool  isExtended () { return m_bExtended; }
  Void  clearExtended() { m_bExtended = false; }
  Void  setExtended  ()                  { m_bExtended = true; }

  // JVT-R057 LA-RDO{
  Void   initChannelDistortion();
  Void   uninitChannelDistortion()  { 
	  if(m_piChannelDistortion) 
		  delete[] m_piChannelDistortion; 
  }
  UInt*   getChannelDistortion()   { return  m_piChannelDistortion;}
  Void   copyChannelDistortion(Frame*p1);
  Void   zeroChannelDistortion();
  Void   setChannelDistortion(Frame*p1) { if(p1) m_piChannelDistortion=p1->m_piChannelDistortion; else m_piChannelDistortion=NULL;}
  // JVT-R057 LA-RDO}  
  
  Void  setUnvalid()  { m_bUnvalid = true;  }
  Void  setValid  ()  { m_bUnvalid = false; }
  Bool  isUnvalid ()  { return m_bUnvalid;  }

protected:
  ErrVal  xUpdatePicParameters();

protected:
  YuvPicBuffer      m_cFullPelYuvBuffer;
  YuvPicBuffer      m_cHalfPelYuvBuffer;
  PictureParameters m_cPicParameters;     // for frame or top field
  PictureParameters m_cPicParametersBot;  // for bottom field
  
  Bool            m_bHalfPel;
  Bool            m_bExtended;
	Bool            m_bPocIsSet;
  Int             m_iTopFieldPoc;
  Int             m_iBotFieldPoc;
  Int             m_iPoc;
	PicType         m_ePicType;
  Frame*          m_pcFrameTopField;
  Frame*          m_pcFrameBotField;
  Frame*          m_pcFrame;

  DPBUnit*        m_pcDPBUnit;
  // JVT-R057 LA-RDO{
  UInt*            m_piChannelDistortion;
  // JVT-R057 LA-RDO}

  Bool      m_bLongTerm;
  Bool      m_bUnvalid;
};

H264AVCCOMMONLIB_API extern __inline ErrVal gSetFrameFieldLists ( RefFrameList& rcTopFieldList, RefFrameList& rcBotFieldList, RefFrameList& rcRefFrameList )
{
  ROTRS( NULL == &rcRefFrameList, Err::m_nOK );
 
  rcTopFieldList.reset();
  rcBotFieldList.reset();

  const Int iMaxEntries = min( rcRefFrameList.getSize(), rcRefFrameList.getActive() );
  for( Int iFrmIdx = 0; iFrmIdx < iMaxEntries; iFrmIdx++ )
  {
    Frame* pcTopField = rcRefFrameList.getEntry( iFrmIdx )->getPic( TOP_FIELD );
    Frame* pcBotField = rcRefFrameList.getEntry( iFrmIdx )->getPic( BOT_FIELD );
    rcTopFieldList.add( pcTopField );
    rcTopFieldList.add( pcBotField );
    rcBotFieldList.add( pcBotField );
    rcBotFieldList.add( pcTopField );
  }

  return Err::m_nOK;
}



H264AVCCOMMONLIB_API extern __inline ErrVal gSetFrameFieldArrays( Frame* apcFrame[4], Frame* pcFrame )
{
  if( pcFrame == NULL )
  {
    apcFrame[0] = NULL;
    apcFrame[1] = NULL;
    apcFrame[2] = NULL;
    apcFrame[3] = NULL;
  }
  else
  {
		RNOK( pcFrame->addFrameFieldBuffer() );
    apcFrame[0] = pcFrame->getPic( TOP_FIELD );
    apcFrame[1] = pcFrame->getPic( BOT_FIELD );
    apcFrame[2] = pcFrame->getPic( FRAME     );
    apcFrame[3] = pcFrame->getPic( FRAME     );
  }
  return Err::m_nOK;
}

H264AVC_NAMESPACE_END


#endif // !defined(AFX_INTFRAME_H__98AFB9AC_5EE3_45A9_B09B_859511AC9090__INCLUDED_)