intframe.h

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

    if( ePicType==FRAME )
    {
    RNOK( getFullPelYuvBuffer()->copy( pcSrcFrame->getFullPelYuvBuffer()) );
    }
    else
    {
      RNOK(             addFieldBuffer( ePicType ) );
      RNOK( pcSrcFrame->addFieldBuffer( ePicType ) );
      RNOK( getPic( ePicType )->getFullPelYuvBuffer()->copy( pcSrcFrame->getPic( ePicType )->getFullPelYuvBuffer() ) );
    }
    return Err::m_nOK;
  }
  
  
  //	TMM_EC {{
	ErrVal  copy        ( Frame* pcSrcFrame, PicType ePicType )
  {
    AOF(ePicType == m_ePicType);
    RNOK( getFullPelYuvBuffer()->copy( pcSrcFrame->getFullPelYuvBuffer()) );
    return Err::m_nOK;
  }
 //TMM_EC }}  
  //JVT-U106 Behaviour at slice boundaries{
  ErrVal  copyMask        ( IntFrame* pcSrcFrame,Int**ppiMaskL,Int**ppiMaskC )
  {
	  m_bUnusedForRef = pcSrcFrame->getUnusedForRef();// JVT-Q065 EIDR

	  RNOK( getFullPelYuvBuffer()->copyMask( pcSrcFrame->getFullPelYuvBuffer(),ppiMaskL,ppiMaskC) );
	  return Err::m_nOK;
  }
  ErrVal  copyPortion        ( IntFrame* pcSrcFrame )
  {
	  RNOK( getFullPelYuvBuffer()->copyPortion( pcSrcFrame->getFullPelYuvBuffer()) );
	  return Err::m_nOK;
  }
  //JVT-U106 Behaviour at slice boundaries}
  ErrVal  subtract    ( IntFrame* pcSrcFrame0, IntFrame* pcSrcFrame1 )
  {
    ASSERT( m_ePicType==FRAME );
    RNOK( getFullPelYuvBuffer()->subtract( pcSrcFrame0->getFullPelYuvBuffer(), pcSrcFrame1->getFullPelYuvBuffer() ) );
    return Err::m_nOK;
  }
  
  ErrVal add              ( IntFrame* 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 upsample     ( DownConvert& rcDownConvert, ResizeParameters* pcParameters, Bool bClip )
  {
    ASSERT( m_ePicType==FRAME );
    RNOK( getFullPelYuvBuffer()->upsample( rcDownConvert, pcParameters, bClip ) );
    return Err::m_nOK;
  }

  ErrVal upsampleResidual ( DownConvert& rcDownConvert, ResizeParameters* pcParameters, MbDataCtrl* pcMbDataCtrl, Bool bClip )
  {
    ASSERT( m_ePicType==FRAME );
    RNOK( getFullPelYuvBuffer()->upsampleResidual( rcDownConvert, pcParameters, pcMbDataCtrl, bClip ) );
    return Err::m_nOK;
  }

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

	Bool  isPocAvailable()           const { return m_bPocIsSet; }
	Int   getPoc        ()           const { return m_iPoc; }

  Void  setTopFieldPoc( Int iPoc );
  Void  setBotFieldPoc( Int iPoc );
	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 )
		{
			setTopFieldPoc( rcSH.getTopFieldPoc() );
		}
		if( ePicType & BOT_FIELD )
		{
			setBotFieldPoc( rcSH.getBotFieldPoc() );
		}
	}

//JVT-S036 lsj{
  Int	getFrameNum()	  const		{ return m_iFrameNum; }
  Void  setFrameNum( Int iNum )		{ m_iFrameNum = iNum; }
//JVT-S036 lsj}

// JVT-Q065 EIDR{
  Bool	getUnusedForRef()			  { return m_bUnusedForRef; }
  Void	setUnusedForRef( Bool b )	  { m_bUnusedForRef = b; }
// JVT-Q065 EIDR}


  Bool  isHalfPel()   { return m_bHalfPel; }

	IntFrame* 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(IntFrame*p1);
  Void   zeroChannelDistortion();
  Void   setChannelDistortion(IntFrame*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:
  IntYuvPicBuffer m_cFullPelYuvBuffer;
  IntYuvPicBuffer m_cHalfPelYuvBuffer;
  
  Bool            m_bHalfPel;
  Bool            m_bExtended;
	Bool            m_bPocIsSet;
  Int             m_iPoc;
	PicType         m_ePicType;
  IntFrame*       m_pcIntFrameTopField;
  IntFrame*       m_pcIntFrameBotField;
  UInt            m_uiFrameIdInGop;

  DPBUnit*        m_pcDPBUnit;
  Bool			  m_bUnusedForRef; // JVT-Q065 EIDR
  // 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++ )
  {
		//IntFrame* pcFrame    = rcRefFrameList.getEntry( iFrmIdx );
    IntFrame* pcTopField = rcRefFrameList.getEntry( iFrmIdx )->getPic( TOP_FIELD );
    IntFrame* 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( IntFrame* apcFrame[4], IntFrame* 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_)