gopdecoder.cpp

来自「SVC最新更新代码」· C++ 代码 · 共 1,768 行 · 第 1/5 页

{
  if( ( ePicType & TOP_FIELD ) == TOP_FIELD )
  {
    m_abNeededForReference[0] = false;
    m_abLongTerm          [0] = false;
  }
  if( ( ePicType & BOT_FIELD ) == BOT_FIELD )
  {
    m_abNeededForReference[1] = false;
    m_abLongTerm          [1] = false;
  }
  if( !m_abLongTerm[0] && !m_abLongTerm[1] )
  {
    m_iLongTermFrameIdx = -1;
  }
  if( bRemoveOutputFlag )
  {
    ROF( ePicType == FRAME );
    m_bWaitForOutput = false; 
  }
  return Err::m_nOK;
}

ErrVal
DPBUnit::markLongTerm( PicType ePicType, Int iLongTermFrameIdx )
{
  if( ( ePicType & TOP_FIELD ) == TOP_FIELD )
  {
    ROF( m_abNeededForReference[0] );
    ROT( m_abLongTerm          [0] );
    m_abLongTerm[0] = true;
  }
  if( ( ePicType & BOT_FIELD ) == BOT_FIELD )
  {
    ROF( m_abNeededForReference[1] );
    ROT( m_abLongTerm          [1] );
    m_abLongTerm[1] = true;
  }
  ROF( m_iLongTermFrameIdx == -1 || m_iLongTermFrameIdx == iLongTermFrameIdx );
  m_iLongTermFrameIdx = iLongTermFrameIdx;
  return Err::m_nOK;
}

ErrVal
DPBUnit::checkStatus( Int iMaxLongTermFrameIdx )
{
  ROF(  m_ePicStatus );
  ROT( !m_abLongTerm[0] && !m_abLongTerm[1] && m_iLongTermFrameIdx != -1 );
  ROT( !m_abNeededForReference[0] && m_abLongTerm[0] );
  ROT( !m_abNeededForReference[1] && m_abLongTerm[1] );
  ROT(  m_abNeededForReference[0] && ( m_ePicStatus & TOP_FIELD ) == 0 );
  ROT(  m_abNeededForReference[1] && ( m_ePicStatus & BOT_FIELD ) == 0 );
  ROT(  m_abNeededForReference[0] && m_abNeededForReference[1] && m_abLongTerm[0] != m_abLongTerm[1] );
  ROT(  m_iLongTermFrameIdx > iMaxLongTermFrameIdx );
  return Err::m_nOK;
}





//////////////////////////////////////////////////////////////////////////
// CURRENT DPB UNIT
//////////////////////////////////////////////////////////////////////////
CurrDPBUnit::CurrDPBUnit( YuvBufferCtrl& rcYuvBufferCtrl )
: DPBUnit             ( rcYuvBufferCtrl )
, m_bInUse            ( false )
, m_bRefBasePicInUse  ( false )
, m_bCompleted        ( false )
, m_uiQualityId       ( 0 )
, m_pcControlData     ( 0 )
, m_pcRefBasePicFrame ( 0 )
{
}

CurrDPBUnit::~CurrDPBUnit()
{
}

ErrVal
CurrDPBUnit::create( CurrDPBUnit*&                rpcCurrDPBUnit,
                     YuvBufferCtrl&               rcYuvBufferCtrl,
                     const SequenceParameterSet&  rcSPS,
                     Bool                         bCreateRefBasePicBuffer,
                     Bool                         bBaseLayer )
{
  ROF(( rpcCurrDPBUnit = new CurrDPBUnit( rcYuvBufferCtrl ) ));
  RNOK( rpcCurrDPBUnit->xCreateData     ( rcSPS, bCreateRefBasePicBuffer, bBaseLayer ) );
  return Err::m_nOK;
}

ErrVal
CurrDPBUnit::destroy()
{
  RNOK( xDeleteData() );
  delete this;
  return Err::m_nOK;
}

ErrVal
CurrDPBUnit::xCreateData( const SequenceParameterSet& rcSPS,
                          Bool                        bCreateRefBasePicBuffer, 
                          Bool                        bBaseLayer )
{
  ROT ( m_pcControlData );
  ROT ( m_pcRefBasePicFrame );
  //===== create data of base class =====
  RNOK( DPBUnit::xCreateData( rcSPS, bBaseLayer ) );
  m_pcFrame->setDPBUnit( 0 );
  //===== create and init control data =====
  {
    MbDataCtrl* pcMbDataCtrl = 0;
    ROF(( m_pcControlData = new ControlData () ));
    ROF(( pcMbDataCtrl    = new MbDataCtrl  () ));
    RNOK( pcMbDataCtrl    ->init            ( rcSPS ) );
    RNOK( m_pcControlData ->setMbDataCtrl   ( pcMbDataCtrl ) );
  }
  //===== create and init reference base picture frame =====
  if( bCreateRefBasePicBuffer )
  {
    ROF(( m_pcRefBasePicFrame = new Frame( m_rcYuvBufferCtrl, m_rcYuvBufferCtrl, FRAME, 0 ) ));
    RNOK( m_pcRefBasePicFrame->init() );
  }
  return Err::m_nOK;
}

ErrVal
CurrDPBUnit::xDeleteData()
{
  RNOK( DPBUnit::xDeleteData() );
  if( m_pcControlData )
  {
    if( m_pcControlData->getMbDataCtrl() )
    {
      RNOK(  m_pcControlData->getMbDataCtrl()->uninit() );
      delete m_pcControlData->getMbDataCtrl();
      m_pcControlData->setMbDataCtrl( 0 );
    }
    delete m_pcControlData;
    m_pcControlData = 0;
  }
  if( m_pcRefBasePicFrame )
  {
    RNOK( m_pcRefBasePicFrame->uninit () );
    RNOK( m_pcRefBasePicFrame->destroy() );
    m_pcRefBasePicFrame = 0;
  }
  return Err::m_nOK;
}

ErrVal
CurrDPBUnit::init( SliceHeader& rcSliceHeader )
{
  ROF( !m_bInUse && !m_bRefBasePicInUse && !m_bCompleted );
  ROT( rcSliceHeader.getStoreRefBasePicFlag() && ! rcSliceHeader.getNalRefIdc() );
  ROT( rcSliceHeader.getStoreRefBasePicFlag() && ! m_pcRefBasePicFrame );
  ROT( rcSliceHeader.getDependencyId() == 0   && ! m_pcMbDataCtrlBaseLayer );
  //===== init parameters =====
  m_bInUse              = true;
  m_bRefBasePicInUse    = rcSliceHeader.getStoreRefBasePicFlag();
  m_bCompleted          = false;
  m_uiQualityId         = rcSliceHeader.getQualityId          ();
  m_ePicStatus          = rcSliceHeader.getPicType            ();
  m_uiFrameNum          = rcSliceHeader.getFrameNum           ();
  m_iLongTermFrameIdx   = -1;
  m_bExisting           = true;
  m_bBaseRepresentation = false;
  m_bWaitForOutput      = rcSliceHeader.getOutputFlag         ();
  m_bRefPic             = rcSliceHeader.getNalRefIdc          () > 0;
  Int iFldMin           = ( m_ePicStatus == BOT_FIELD ? 1 : 0 );
  Int iFldMax           = ( m_ePicStatus == TOP_FIELD ? 1 : 2 );
  for( Int iF = iFldMin; iF < iFldMax; iF++ )
  {
    m_aiPoc               [iF]  = rcSliceHeader.getPoc              ( m_ePicStatus );
    m_abUseBasePred       [iF]  = rcSliceHeader.getUseRefBasePicFlag();
    m_abNeededForReference[iF]  = m_bRefPic;
    m_abLongTerm          [iF]  = false;
  }
  //===== init frame =====
  RNOK( m_pcFrame->addFrameFieldBuffer() );
  m_pcFrame->setPoc     ( rcSliceHeader );
  //===== init reference base picture frame =====
  if( m_pcRefBasePicFrame )
  {
    RNOK( m_pcRefBasePicFrame->addFrameFieldBuffer() );
    m_pcRefBasePicFrame->setPoc     ( rcSliceHeader );
  }
  //===== init control data =====
  m_pcControlData->clear();
  RNOK( m_pcControlData->setSliceHeader ( &rcSliceHeader )  );
  RNOK( m_pcControlData->getMbDataCtrl  ()->reset ()        );
  RNOK( m_pcControlData->getMbDataCtrl  ()->clear ()        );
  return Err::m_nOK;
}

ErrVal
CurrDPBUnit::reinit( SliceHeader& rcSliceHeader, Bool bNewLayerRepresentation )
{
  ROF( m_bInUse );
  ROF( m_bCompleted       ==  bNewLayerRepresentation );
  ROF( m_bRefBasePicInUse ==  rcSliceHeader.getStoreRefBasePicFlag() );
  ROF( m_uiQualityId      ==  rcSliceHeader.getQualityId          () - ( bNewLayerRepresentation ? 1 : 0 ) );
  ROF( m_ePicStatus       ==  rcSliceHeader.getPicType            () );
  ROF( m_uiFrameNum       ==  rcSliceHeader.getFrameNum           () );
  ROF( m_bWaitForOutput   ==  rcSliceHeader.getOutputFlag         () );
  ROF( m_bRefPic          == (rcSliceHeader.getNalRefIdc          () > 0) );
  Int iFldMin = ( m_ePicStatus == BOT_FIELD ? 1 : 0 );
  Int iFldMax = ( m_ePicStatus == TOP_FIELD ? 1 : 2 );
  for( Int iF = iFldMin; iF < iFldMax; iF++ )
  {
    ROF( m_aiPoc                [iF] == rcSliceHeader.getPoc              ( m_ePicStatus ) );
    ROF( m_abUseBasePred        [iF] == rcSliceHeader.getUseRefBasePicFlag() );
    ROF( m_abNeededForReference [iF] == m_bRefPic );
    ROF( m_abLongTerm           [iF] == false );
  }
  if( bNewLayerRepresentation )
  {
    RNOK( uninit() );
    RNOK( init  ( rcSliceHeader ) );
  }
  else
  {
    RNOK( m_pcControlData->setSliceHeader( &rcSliceHeader ) );
  }
  return Err::m_nOK;
}

ErrVal
CurrDPBUnit::resetMMCO5( SliceHeader& rcSliceHeader )
{
  ROT( m_bBaseRepresentation );
  ROF( m_bExisting );
  ROF( m_bRefPic );
  ROF( m_ePicStatus == rcSliceHeader.getPicType () );
  ROF( m_uiFrameNum == rcSliceHeader.getFrameNum() );
  m_uiFrameNum  = 0;
  m_aiPoc[0]    = ( m_ePicStatus == BOT_FIELD ? m_aiPoc[0] : rcSliceHeader.getTopFieldPoc() );
  m_aiPoc[1]    = ( m_ePicStatus == TOP_FIELD ? m_aiPoc[1] : rcSliceHeader.getBotFieldPoc() );
  return Err::m_nOK;
}

ErrVal
CurrDPBUnit::setComplete( CurrDPBUnit& rcILPredUnit, Bool bDependencyRepresentationFinished )
{
  ROF( m_bInUse && !m_bCompleted );
  //===== copy base layer macroblock data =====
  if( m_pcMbDataCtrlBaseLayer && !m_uiQualityId )
  {
    RNOK( m_pcMbDataCtrlBaseLayer->copyMotion( *m_pcControlData->getMbDataCtrl(), m_ePicStatus ) );
  }
  //===== set complete =====
  m_bCompleted = true;
  //===== set inter-layer prediction DPB unit =====
  if( bDependencyRepresentationFinished )
  {
    if( rcILPredUnit.isCompleted() )
    {
      RNOK( rcILPredUnit.uninit() );
    }
  }
  else
  {
    Frame*        pcFrame         = m_pcFrame;
    MbDataCtrl*   pcMbDataCtrl    = m_pcControlData->getMbDataCtrl  ();
    SliceHeader*  pcSliceHeader   = m_pcControlData->getSliceHeader ();
    m_pcFrame                     = rcILPredUnit.m_pcFrame;
    rcILPredUnit.m_pcFrame        = pcFrame;
    rcILPredUnit.m_bInUse         = true;
    rcILPredUnit.m_bCompleted     = true;
    rcILPredUnit.m_uiQualityId    = m_uiQualityId;
    RNOK( m_pcControlData->setMbDataCtrl( rcILPredUnit.m_pcControlData->getMbDataCtrl() ) );
    RNOK( rcILPredUnit.m_pcControlData->setMbDataCtrl ( pcMbDataCtrl  ) );
    RNOK( rcILPredUnit.m_pcControlData->setSliceHeader( pcSliceHeader ) );
  }
  return Err::m_nOK;
}

ErrVal
CurrDPBUnit::store( DPBUnit& rcDPBUnit, Bool bRefBasePic )
{
  //===== store picture =====
  if( rcDPBUnit.m_ePicStatus )
  {
    RNOK( xStore2ndField( rcDPBUnit, bRefBasePic ) );
  }
  else
  {
    RNOK( xStoreFrame   ( rcDPBUnit, bRefBasePic ) );
  }
  //===== fill image border =====
  {
    SliceHeader* pcSliceHeader = m_pcControlData->getSliceHeader();
    ROF ( pcSliceHeader );
    RNOK( rcDPBUnit.m_rcYuvBufferCtrl.initMb() );
    RNOK( rcDPBUnit.m_pcFrame->extendFrame( 0, rcDPBUnit.m_ePicStatus, pcSliceHeader->getSPS().getFrameMbsOnlyFlag() ) );
  }
  return Err::m_nOK;
}

ErrVal
CurrDPBUnit::xStoreFrame( DPBUnit& rcDPBUnit, Bool bRefBasePic )
{
  ROF( m_bInUse && m_bCompleted );
  //===== safety checks =====
  ROF( m_ePicStatus > 0 && m_ePicStatus <= FRAME );
  ROF( m_iLongTermFrameIdx >= 0 || ( m_ePicStatus == FRAME ? ( !m_abLongTerm[0] && !m_abLongTerm[1] ) : !m_abLongTerm[m_ePicStatus-1] ) );
  //===== set parameters =====
  rcDPBUnit.m_ePicStatus          = m_ePicStatus;
  rcDPBUnit.m_uiFrameNum          = m_uiFrameNum;
  rcDPBUnit.m_iLongTermFrameIdx   = m_iLongTermFrameIdx;
  rcDPBUnit.m_bExisting           = true;
  rcDPBUnit.m_bBaseRepresentation = bRefBasePic;
  rcDPBUnit.m_bWaitForOutput      = ( bRefBasePic ? false : m_bWaitForOutput );
  rcDPBUnit.m_bRefPic             = m_bRefPic;
  Int iMinFld                     = ( m_ePicStatus == BOT_FIELD ? 1 : 0 );
  Int iMaxFld                     = ( m_ePicStatus == TOP_FIELD ? 1 : 2 );
  for( Int iFld = iMinFld; iFld < iMaxFld; iFld++ )
  {
    rcDPBUnit.m_aiPoc               [iFld]  = m_aiPoc               [iFld];
    rcDPBUnit.m_abUseBasePred       [iFld]  = m_abUseBasePred       [iFld];
    rcDPBUnit.m_abNeededForReference[iFld]  = m_abNeededForReference[iFld];
    rcDPBUnit.m_abLongTerm          [iFld]  = m_abLongTerm          [iFld];
  }
  //===== switch frame =====
  {
    Frame*  pcTmpFrame  = rcDPBUnit.m_pcFrame;
    Frame*& rpcFrame    = ( bRefBasePic ? m_pcRefBasePicFrame : m_pcFrame );
    ROF( rpcFrame && pcTmpFrame );
    rcDPBUnit.m_pcFrame = rpcFrame;
    rpcFrame            = pcTmpFrame;
  }
  //===== switch base layer macroblock data control =====
  if( rcDPBUnit.m_pcMbDataCtrlBaseLayer )
  {
    ROF( m_pcMbDataCtrlBaseLayer );
    MbDataCtrl* pcTmpMbDataCtrl       = rcDPBUnit.m_pcMbDataCtrlBaseLayer;
    rcDPBUnit.m_pcMbDataCtrlBaseLayer = m_pcMbDataCtrlBaseLayer;
    m_pcMbDataCtrlBaseLayer           = pcTmpMbDataCtrl;
  }
  return Err::m_nOK;
}

ErrVal
CurrDPBUnit::xStore2ndField( DPBUnit& rcDPBUnit, Bool bRefBasePic )
{
  ROF( m_bInUse && m_bCompleted );
  //===== safety checks =====
  ROF( rcDPBUnit.m_bExisting );
  ROF( rcDPBUnit.m_ePicStatus == TOP_FIELD || rcDPBUnit.m_ePicStatus == BOT_FIELD );
  ROF( rcDPBUnit.m_ePicStatus + m_ePicStatus  == FRAME );
  ROF( rcDPBUnit.m_uiFrameNum                 == m_uiFrameNum );
  ROF( rcDPBUnit.m_iLongTermFrameIdx          == m_iLongTermFrameIdx || rcDPBUnit.m_abLongTerm[rcDPBUnit.m_ePicStatus-1] != m_abLongTerm[m_ePicStatus-1] );
  ROF( rcDPBUnit.m_bExisting                  == m_bExisting );
  ROF( rcDPBUnit.m_bBaseRepresentation        == bRefBasePic );