frame.h

JVT-Z203_jsvm.rar

	  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 );
	  //m_bUnusedForRef = pcSrcFrame->getUnusedForRef();// JVT-Q065 EIDR
	  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  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 ) );
    }
  }


//JVT-S036 lsj{
  Int	getFrameNum()	  const		{ return m_iFrameNum; }
  Void  setFrameNum( Int iNum )		
  {
    m_iFrameNum = iNum;
//TMM  {
    if( NULL != m_pcFrameTopField )
      m_pcFrameTopField->setFrameNum( iNum );
    if( NULL != m_pcFrameBotField )
      m_pcFrameBotField->setFrameNum( iNum );
//TMM }
  }
//JVT-S036 lsj}

// JVT-Q065 EIDR{
  Bool	getUnusedForRef()			  { return m_bUnusedForRef; }
  Void	setUnusedForRef( Bool b )	  { m_bUnusedForRef = b; }
// JVT-Q065 EIDR}
//EIDR 0619{
	UInt	getIdrPicId()				{return m_uiIdrPicId;}
	Void	setIdrPicId(UInt ui)				{ m_uiIdrPicId=ui;	}
//EIDR 0619}


  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; }

  UInt getFrameIdInGop()                        { return m_uiFrameIdInGop; }
  Void setFrameIdInGop( UInt uiFrameIdInGop )   { m_uiFrameIdInGop = uiFrameIdInGop; }

  // 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;
  UInt            m_uiFrameIdInGop;

  DPBUnit*        m_pcDPBUnit;
  Bool			  m_bUnusedForRef; // JVT-Q065 EIDR
	UInt				m_uiIdrPicId; //EIDR 0619
  // JVT-R057 LA-RDO{
  UInt*            m_piChannelDistortion;
  // JVT-R057 LA-RDO}

  Int			  m_iFrameNum; //JVT-S036 lsj
  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_)