framemng.cpp

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

FrameMng::updateLastFrame( IntFrame* pcSrcFrame, 
                           const PicType ePicType,          //TMM_INTERLACE
                            const Bool    bFrameMbsOnlyFlag //TMM_INTERLACE
                                       )  // MGS fix by Heiko Schwarz
{
  Bool bFlagFGS=true;

  ROF   ( pcSrcFrame );
  ROF   ( m_pcCurrentFrameUnit );

  ROFRS ( m_pcCurrentFrameUnit->isUsed       (ePicType), Err::m_nOK );

  ROFRS ( m_pcCurrentFrameUnit->getMaxPoc    () == pcSrcFrame->getPoc(), Err::m_nOK );
  ROF   ( m_pcCurrentFrameUnit->getPicBuffer () );
  ROT   ( m_pcCurrentFrameUnit->getBaseRep   () );

  if( ! m_pcCurrentFrameUnit->getFGSPicBuffer() )
  {
    RNOK( m_pcCurrentFrameUnit->getFGSPic( FRAME )->init( 0, m_pcCurrentFrameUnit ) );
    m_pcCurrentFrameUnit->getFGSPic( FRAME )->setPoc( m_pcCurrentFrameUnit->getPic( FRAME )->getPoc() );
    if( ! bFrameMbsOnlyFlag )
    {
      Pel* pBuffer = m_pcCurrentFrameUnit->getFGSPic( FRAME )->getFullPelYuvBuffer()->getBuffer();
      RNOK( m_pcCurrentFrameUnit->getFGSPic( TOP_FIELD )->init( pBuffer, m_pcCurrentFrameUnit ) );
      RNOK( m_pcCurrentFrameUnit->getFGSPic( BOT_FIELD )->init( pBuffer, m_pcCurrentFrameUnit ) );
      m_pcCurrentFrameUnit->getFGSPic( TOP_FIELD )->setPoc( m_pcCurrentFrameUnit->getPic( TOP_FIELD )->getPoc() );
      m_pcCurrentFrameUnit->getFGSPic( BOT_FIELD )->setPoc( m_pcCurrentFrameUnit->getPic( BOT_FIELD )->getPoc() );
    }
    m_pcCurrentFrameUnit->setFGSPicBuffer( m_pcCurrentFrameUnit->getPicBuffer() );
    m_pcCurrentFrameUnit->getFGSPicBuffer()->setUsed();
  }

  Frame* pcDesFrame = const_cast<Frame*>( m_pcCurrentFrameUnit->getFGSPic( ePicType ) );
  RNOK( pcSrcFrame->getFullPelYuvBuffer()->copyTo( pcDesFrame->getFullPelYuvBuffer() ) );
  RNOK( pcDesFrame->extendFrame ( m_pcQuarterPelFilter, bFrameMbsOnlyFlag, bFlagFGS ) );

  return Err::m_nOK;
}



//JVT-T054_FIX{
ErrVal FrameMng::UpdateFrameunitFromShortTermList(FrameUnit* pcFrameUnit, Int iPoc)
{
  FUIter  iter;
  for( iter = m_cShortTermList.begin(); iter != m_cShortTermList.end(); iter++ )
  {
    if( (*iter)->getMaxPoc() == iPoc )
    {
      break;
    }
  }

  (*iter) = pcFrameUnit;
  return Err::m_nOK;
}
//JVT-T054}

//JVT-S036 lsj{
ErrVal FrameMng::RefreshOrderedPocList()
{
  //===== store reference in ordered Poc List =====
  FUIter  iter;
  for( iter = m_cOrderedPocList.begin(); iter != m_cOrderedPocList.end(); iter++ )
  {
    if( (*iter)->getMaxPoc() == m_pcCurrentFrameUnit->getMaxPoc() )
    {
      break;
    }
  }

  (*iter) = m_pcCurrentFrameUnit;

	return Err::m_nOK;
}
//JVT-S036 lsj}


ErrVal FrameMng::initSlice( SliceHeader *rcSH )
{
  m_uiMaxFrameNumCurr = ( 1 << ( rcSH->getSPS().getLog2MaxFrameNum() ) );
  m_uiMaxFrameNumPrev = ( 1 << ( rcSH->getSPS().getLog2MaxFrameNum() ) );
  m_uiNumRefFrames    = rcSH->getSPS().getNumRefFrames();
  m_iMaxEntriesinDPB  = min( 64, rcSH->getSPS().getMaxDPBSize() + 3 );

  if( ! m_iMaxEntriesinDPB )
  {
    printf("WARNING: Size of Decoded picture buffer is less than 1 frame!");
  }

  if( m_pcRefinementIntFrame )
  {
    RNOK( m_pcRefinementIntFrame->init() );
  }
  if( m_pcRefinementIntFrameSpatial )
  {
    RNOK( m_pcRefinementIntFrameSpatial->init() );
  }
  if( m_pcBaseRepFrame )
  {
    RNOK( m_pcBaseRepFrame->init() );
  }
  if( m_pcPredictionIntFrame )
  {
    RNOK( m_pcPredictionIntFrame->init() );
  }

  return Err::m_nOK;
}

ErrVal FrameMng::initSPS( const SequenceParameterSet& rcSPS )
{
  m_uiMaxFrameNumCurr = ( 1 << ( rcSPS.getLog2MaxFrameNum() ) );
  m_uiMaxFrameNumPrev = ( 1 << ( rcSPS.getLog2MaxFrameNum() ) );
  m_uiNumRefFrames    = rcSPS.getNumRefFrames();
  m_iMaxEntriesinDPB  = min( 64, rcSPS.getMaxDPBSize() + 3 );

  if( ! m_iMaxEntriesinDPB )
  {
    printf("WARNING: Size of Decoded picture buffer is less than 1 frame!");
  }

  if( m_pcRefinementIntFrame )
  {
    RNOK( m_pcRefinementIntFrame->init() );
  }
  if( m_pcRefinementIntFrameSpatial )
  {
    RNOK( m_pcRefinementIntFrameSpatial->init() );
  }
  if( m_pcBaseRepFrame )
  {
    RNOK( m_pcBaseRepFrame->init() );
  }
  if( m_pcPredictionIntFrame )
  {
    RNOK( m_pcPredictionIntFrame->init() );
  }

  return Err::m_nOK;
}


ErrVal FrameMng::initPic( SliceHeader& rcSH )
{
  rcSH.setFrameUnit( m_pcCurrentFrameUnit );

  const PicType ePicType = rcSH.getPicType();

  if( NOT_SPECIFIED == m_pcCurrentFrameUnit->getAvailableStatus() )
  {
    m_pcCurrentFrameUnit->setFrameNumber( rcSH.getFrameNum() );
  }
  //===== init POC =====
  if( ePicType & TOP_FIELD )
  {
    m_pcCurrentFrameUnit->setTopFieldPoc( rcSH.getTopFieldPoc() );
  }
  if( ePicType & BOT_FIELD )
  {
    m_pcCurrentFrameUnit->setBotFieldPoc( rcSH.getBotFieldPoc() );
  }

  return Err::m_nOK;
}


ErrVal FrameMng::initFrame( SliceHeader& rcSH, PicBuffer* pcPicBuffer )
{
  ROF( m_bInitDone );

  //===== check frame numbers for reference pictures =====
  if( ! rcSH.isIdrNalUnit() )
  {
    RNOK( xCheckMissingFrameNums( rcSH ) );
  }

  RNOK( m_cFrameUnitBuffer.getFrameUnit( m_pcCurrentFrameUnit ) );
  RNOK( m_pcCurrentFrameUnit->init( rcSH, pcPicBuffer ) );

  rcSH.setFrameUnit( m_pcCurrentFrameUnit );

  return Err::m_nOK;
}

ErrVal FrameMng::xStoreInOrderedPocList( FrameUnit* pcFrameUnit )
{
  //===== store reference in ordered Poc List =====
  const Int iMaxPoc = pcFrameUnit->getMaxPoc();
  FUIter  iter;
  for( iter = m_cOrderedPocList.begin(); iter != m_cOrderedPocList.end(); iter++ )
  {
    if( (*iter)->getMaxPoc() > iMaxPoc )
    {
      break;
    }
  }
  m_cOrderedPocList.insert( iter, pcFrameUnit );
 
  //m_iEntriesInDPB++;
  

  return Err::m_nOK;
}

ErrVal FrameMng::xStoreShortTerm( FrameUnit* pcFrameUnit,const Bool bStorePocList )
{
	ROTRS( m_cShortTermList.size() && (m_cShortTermList.front() == pcFrameUnit), Err::m_nOK );

	m_cShortTermList.push_front( pcFrameUnit );
  m_iEntriesInDPB++;

	// this might happen if the corresponding field is marked
	// as unused for reference
	FUIter iterNR = m_cNonRefList.find( (const FrameUnit*&)pcFrameUnit );
	if( iterNR != m_cNonRefList.end() && (pcFrameUnit == *iterNR) )
	{
    m_iEntriesInDPB--;	
    m_cNonRefList.erase( iterNR );

	}
	else
	{
    if(bStorePocList)
    {
      RNOK( xStoreInOrderedPocList( pcFrameUnit ) );
    }
  }

  AOT_DBG( m_cNonRefList.end() != m_cNonRefList.  find( (const FrameUnit*&)pcFrameUnit ) );

	return Err::m_nOK;
}


ErrVal FrameMng::xStoreNonRef( FrameUnit* pcFrameUnit )
{
  ROTRS( m_cNonRefList.size() && m_cNonRefList.back() == pcFrameUnit, Err::m_nOK );

  m_cNonRefList.push_back( pcFrameUnit );
  m_iEntriesInDPB++;

  RNOK( xStoreInOrderedPocList( pcFrameUnit ) );

  AOT_DBG( m_cShortTermList.end() != m_cShortTermList.find( (const FrameUnit*&)pcFrameUnit ) );

	return Err::m_nOK;
}

Void FrameMng::xSetIdentifier( UInt& uiNum, PicType& rePicType, const PicType eCurrentPicType )
{
  if( eCurrentPicType==FRAME )
  {
    rePicType = FRAME;
  }
  else
  {
    if( uiNum % 2 ) 
    {
      rePicType = eCurrentPicType;
    }
    else if( eCurrentPicType==TOP_FIELD )
    {
      rePicType = BOT_FIELD;
    }
    else
    {
      rePicType = TOP_FIELD;
    }
    uiNum /= 2;
  }
}

ErrVal FrameMng::xCheckMissingFrameNums( SliceHeader& rcSH )
{
  //===== check frame numbers for reference pictures =====
  if( ( ( m_uiPrecedingRefFrameNum + 1 ) % m_uiMaxFrameNumCurr) != rcSH.getFrameNum() )
  {
    UInt  uiNumMissingPictures = rcSH.getFrameNum() - m_uiPrecedingRefFrameNum - 1;
    if( rcSH.getFrameNum() <= m_uiPrecedingRefFrameNum )
    {
      uiNumMissingPictures += m_uiMaxFrameNumCurr;
    }
    if( rcSH.getSPS().getGapsInFrameNumValueAllowedFlag() )
    {
      for( UInt uiIndex = 1; uiIndex <= uiNumMissingPictures; uiIndex++ )
      {
        UInt        uiFrameNum  = ( m_uiPrecedingRefFrameNum + uiIndex ) % m_uiMaxFrameNumCurr;
        FrameUnit*  pcFrameUnit = 0;
        RNOK( m_cFrameUnitBuffer.getFrameUnit( pcFrameUnit ) );
		//JVT-S036 lsj{
		if( !m_pcCurrentFrameUnit->getBaseRep() )
		{
			FUList::iterator iter = m_cShortTermList.begin();
			FUList::iterator end  = m_cShortTermList.end();
			Bool bFlag = false;
			for( ; iter != m_cShortTermList.end(); iter++ )
			{
				if( (*iter)->getBaseRep() && (*iter)->getFrameNumber() == m_pcCurrentFrameUnit->getFrameNumber())
				{
				    bFlag = true;
					break;
				}
			}
			if( bFlag )
			{
					FrameUnit* pcFrameUnitTemp = (*iter);
					RNOK(pcFrameUnit->init( rcSH, *pcFrameUnitTemp ));
			}
			else
			{
				RNOK( pcFrameUnit->init( rcSH, *m_pcCurrentFrameUnit ) );
			}
			
		}
		else
		//JVT-S036 lsj}
		{
			RNOK( pcFrameUnit->init( rcSH, *m_pcCurrentFrameUnit ) ); // HS: decoder robustness
		}

        pcFrameUnit->setFrameNumber( uiFrameNum );
        m_cShortTermList.push_front( pcFrameUnit );
        m_iEntriesInDPB++;

		RNOK( xSlidingWindowUpdate() );

      }
    }
    else
    {
      printf("\n  LOST PICTURES: %d\n", uiNumMissingPictures );
      AF();
    }

    m_uiPrecedingRefFrameNum = ( m_uiPrecedingRefFrameNum + uiNumMissingPictures ) % m_uiMaxFrameNumCurr;
  }
  return Err::m_nOK;
}

ErrVal FrameMng::setPicBufferLists( PicBufferList& rcPicBufferOutputList, PicBufferList& rcPicBufferUnusedList )
{
  rcPicBufferUnusedList += m_cPicBufferUnusedList;
  m_cPicBufferUnusedList.clear();

  rcPicBufferOutputList += m_cPicBufferOutputList;
  m_cPicBufferOutputList.clear();

  return Err::m_nOK;
}


ErrVal FrameMng::storePicture( const SliceHeader& rcSH )
{
  //===== memory managment =====
  if( rcSH.isIdrNalUnit() )
  {
    RNOK( xClearListsIDR( rcSH ) );
  }
  RNOK( xManageMemory( rcSH ) );

  //===== store current picture =====
  RNOK( xStoreCurrentPicture( rcSH ) );

  //===== set pictures for output =====
  RNOK( xSetOutputList( m_pcCurrentFrameUnit ) );

  if( rcSH.getNalRefIdc() )
  {
    m_uiPrecedingRefFrameNum = m_pcCurrentFrameUnit->getFrameNumber();
  }

  return Err::m_nOK;
}

UInt FrameMng::xSortPocOrderedList( RefPicList<Frame*>& rcRefPicFrameList, Int iCurrPoc )
{
  UInt  uiFirstPosWithGreaterPoc;

  std::sort( rcRefPicFrameList.begin(), rcRefPicFrameList.end(), Frame::PocOrder() );
  for( uiFirstPosWithGreaterPoc = 0; uiFirstPosWithGreaterPoc < rcRefPicFrameList.size(); uiFirstPosWithGreaterPoc++ )
  {
    if( rcRefPicFrameList.get( uiFirstPosWithGreaterPoc )->getPoc() > iCurrPoc )
    {
      break;
    }
  }
  return uiFirstPosWithGreaterPoc;
}


ErrVal FrameMng::xSetInitialReferenceListPFrame( SliceHeader& rcSH )
{
	RefPicList<RefPic>& rcList = rcSH.getRefPicList( FRAME, LIST_0 );

  if( ! rcSH.getUseBasePredictionFlag() ) 
    m_cShortTermList.setRefPicListFGS( rcList );
  else
    m_cShortTermList.setRefPicList( rcList );
  return Err::m_nOK;
}