gopdecoder.cpp

JMVM MPEG MVC/3DAV 测试平台 国际通用标准

DPBUnit*
DecodedPicBuffer::getDPBUnit( Int iPoc )
{
  DPBUnit*              pcDPBUnit = 0;
  DPBUnitList::iterator iter      = m_cUsedDPBUnitList.begin();
  DPBUnitList::iterator end       = m_cUsedDPBUnitList.end  ();
  for( ; iter != end; iter++ )
  {
    if( (*iter)->getPoc() == iPoc && !(*iter)->isBaseRep() )
    {
      pcDPBUnit = *iter;
      break;
    }
  }
  return pcDPBUnit;
}

//TMM_EC {{
ErrVal              
DecodedPicBuffer::getPrdRefListsFromBase( DPBUnit*    pcCurrDPBUnit, SliceHeader* pSliceHeaderBase )
{
UInt uiPos=0;
  ROF( m_pcCurrDPBUnit == pcCurrDPBUnit );
  ROF( m_pcCurrDPBUnit->getCtrlData().getSliceHeader() );

  RefFrameList& rcList0 = m_pcCurrDPBUnit->getCtrlData().getPrdFrameList( LIST_0 );
  RefFrameList& rcList1 = m_pcCurrDPBUnit->getCtrlData().getPrdFrameList( LIST_1 );
    
  
  
  rcList0.reset();
  rcList1.reset();
  RefPicList<RefPic>& rcBaseList0 =pSliceHeaderBase->getRefPicList(LIST_0);
  RefPicList<RefPic>& rcBaseList1 =pSliceHeaderBase->getRefPicList(LIST_1);


  //----- generate reference list0 -----

  for( uiPos = 0; uiPos < rcBaseList0.size(); uiPos++ )
  {
	UInt uiPoc=rcBaseList0.get(uiPos).getFrame()->getPOC();
	DPBUnit*              pNext = 0;
    DPBUnitList::iterator iter  = m_cUsedDPBUnitList.begin();
    DPBUnitList::iterator end   = m_cUsedDPBUnitList.end  ();
    for( ; iter != end; iter++ )
    {
//			DPBUnit*              pTmp = 0;
      if((*iter)->getPoc()==uiPoc)
      {
        pNext = (*iter);
      }
    }
    rcList0.add( pNext->getFrame() );
  }

  //----- generate reference list1 -----

  for(      uiPos = 0; uiPos < rcBaseList1.size(); uiPos++ )
  {
	UInt uiPoc=rcBaseList1.get(uiPos).getFrame()->getPOC();
	DPBUnit*              pNext = 0;
    DPBUnitList::iterator iter  = m_cUsedDPBUnitList.begin();
    DPBUnitList::iterator end   = m_cUsedDPBUnitList.end  ();
    for( ; iter != end; iter++ )
    {
      if((*iter)->getPoc()==uiPoc)
      {
        pNext = (*iter);
      }
    }
    rcList1.add( pNext->getFrame() );
  }

  return Err::m_nOK;
}
//TMM_EC }}

ErrVal
DecodedPicBuffer::setPrdRefLists( DPBUnit* pcCurrDPBUnit )
{
  ROF( m_pcCurrDPBUnit == pcCurrDPBUnit );
  ROF( m_pcCurrDPBUnit->getCtrlData().getSliceHeader() );

  RefFrameList& rcList0 = m_pcCurrDPBUnit->getCtrlData().getPrdFrameList( LIST_0 );
  RefFrameList& rcList1 = m_pcCurrDPBUnit->getCtrlData().getPrdFrameList( LIST_1 );

  rcList0.reset();
  rcList1.reset();
  ROTRS( m_pcCurrDPBUnit->getCtrlData().getSliceHeader()->isIntra(),   Err::m_nOK );

  if( m_pcCurrDPBUnit->getCtrlData().getSliceHeader()->isInterP() )
  {
    RNOK( xInitPrdListPSlice( rcList0 ) );
    RNOK( xPrdListRemapping ( rcList0, LIST_0, m_pcCurrDPBUnit->getCtrlData().getSliceHeader() ) );
    RNOK( xDumpRefList( LIST_0, rcList0 ) );
  }
  else
  {
    RNOK( xInitPrdListsBSlice( rcList0, rcList1 ) );
    RNOK( xPrdListRemapping  ( rcList0, LIST_0, m_pcCurrDPBUnit->getCtrlData().getSliceHeader() ) );
    RNOK( xPrdListRemapping  ( rcList1, LIST_1, m_pcCurrDPBUnit->getCtrlData().getSliceHeader() ) );
    RNOK( xDumpRefList( LIST_0, rcList0 ) );
    RNOK( xDumpRefList( LIST_1, rcList1 ) );
  }

  return Err::m_nOK;
}

ErrVal
DecodedPicBuffer::store( DPBUnit*&        rpcDPBUnit,
                         PicBufferList&   rcOutputList,
                         PicBufferList&   rcUnusedList,
                         IntFrame*        pcFrameBaseRep,
                         UInt             uiQualityLevel, //JVT-T054
                         Bool             bRef) //JVT-T054
{
  RNOK( xStorePicture( rpcDPBUnit, rcOutputList, rcUnusedList,
                       rpcDPBUnit->getCtrlData().getSliceHeader()->isIdrNalUnit(),
                       uiQualityLevel, bRef) ); //JVT-T054

  if( rpcDPBUnit->isNeededForRef() )
  {
    m_uiLastRefFrameNum = rpcDPBUnit->getFrameNum();
  }
  ROFRS( pcFrameBaseRep, Err::m_nOK );

  //===== store base representation =====
  //--- get DPB unit ---
  if( m_cFreeDPBUnitList.empty() )
  {
    // not sure whether this always works ...
    RNOK( xOutput( rcOutputList, rcUnusedList ) );
  }
  DPBUnit*  pcBaseRep = m_cFreeDPBUnitList.popFront();
  //--- init unit and extend picture ---
  RNOK( pcBaseRep->initBase( *rpcDPBUnit, pcFrameBaseRep ) );
  RNOK( m_pcYuvBufferCtrl->initMb() );
  RNOK( pcBaseRep->getFrame()->extendFrame( NULL ) );
  if(!bRef) //JVT-T054
  {
  //--- store just before normal representation of the same picture
  DPBUnitList::iterator iter  = m_cUsedDPBUnitList.begin();
  DPBUnitList::iterator end   = m_cUsedDPBUnitList.end  ();
  for( ; iter != end; iter++ )
  {
    if( (*iter) == rpcDPBUnit )
    {
      break;
    }
  }
  ROT( iter == end );
  m_cUsedDPBUnitList.insert( iter, pcBaseRep );
  RNOK( xDumpDPB() );

  //===== reset DPB unit =====
  rpcDPBUnit = 0;
//JVT-T054{
  } 
  else
  {
    //replace previous version of current baseRep frame in usedDPBUnit by the new version
    DPBUnit*  pcElemToReplace  = 0;
    DPBUnitList::iterator iter =  m_cUsedDPBUnitList.begin();
    DPBUnitList::iterator end  =  m_cUsedDPBUnitList.end  ();
    for( ; iter != end; iter++ )
    {
      if( (*iter)->isBaseRep() && (*iter)->getPoc() == rpcDPBUnit->getPoc() 
        && (*iter)->getQualityLevel()+1 == rpcDPBUnit->getQualityLevel() )
      {
        pcElemToReplace  = (*iter);
        m_cUsedDPBUnitList.remove(pcElemToReplace);
        m_cFreeDPBUnitList.push_back(pcElemToReplace);
        break;
      }
    }
    iter =  m_cUsedDPBUnitList.begin();
    for( ; iter != end; iter++ )
    {
      if( !(*iter)->isBaseRep() && (*iter)->getPoc() == rpcDPBUnit->getPoc() 
        && (*iter)->getQualityLevel() == rpcDPBUnit->getQualityLevel() )
      {
        m_cUsedDPBUnitList.insert( iter, pcBaseRep );
        //m_cUsedDPBUnitList.push_back(pcBaseRep);   
        break;
      }
    }
    RNOK( xDumpDPB() );
    //===== reset DPB unit =====
    rpcDPBUnit = 0;
  }
//JVT-T054}
  return Err::m_nOK;
}



ErrVal
DecodedPicBuffer::update( DPBUnit*  pcDPBUnit )
{
  ROF( pcDPBUnit );

  //---- fill border ----
  RNOK( m_pcYuvBufferCtrl->initMb() );
  RNOK( pcDPBUnit->getFrame()->extendFrame( NULL ) );

  return Err::m_nOK;
}











//////////////////////////////////////////////////////////////////////////
// MCTF DECODER
//////////////////////////////////////////////////////////////////////////
MCTFDecoder::MCTFDecoder()
: m_pcH264AVCDecoder              ( 0 )
, m_pcSliceReader                 ( 0 )
, m_pcSliceDecoder                ( 0 )
, m_pcNalUnitParser               ( 0 )
, m_pcControlMng                  ( 0 )
, m_pcLoopFilter                  ( 0 )
, m_pcHeaderSymbolReadIf          ( 0 )
, m_pcParameterSetMng             ( 0 )
, m_pcPocCalculator               ( 0 )
, m_pcYuvFullPelBufferCtrl        ( 0 )
, m_pcDecodedPictureBuffer        ( 0 )
, m_pcMotionCompensation          ( 0 )
, m_pcQuarterPelFilter            ( 0 )
, m_bInitDone                     ( false )
, m_bCreateDone                   ( false )
, m_bWaitForIdr                   ( true )
, m_bReconstructAll               ( false )
, m_uiFrameWidthInMb              ( 0 )
, m_uiFrameHeightInMb             ( 0 )
, m_uiMbNumber                    ( 0 )
, m_pcResidual                    ( 0 )
, m_pcILPrediction                ( 0 )
, m_pcPredSignal                  ( 0 )
, m_pcBaseLayerResidual           ( 0 )
, m_pcBaseLayerFrame              ( 0 )
, m_pcBaseLayerCtrl               ( 0 )
, m_pcCurrDPBUnit                 ( 0 )
, m_pcBaseLayerCtrlEL             ( 0 )	// ICU/ETRI FGS_MOT_USE
, m_uiLayerId                     ( 0 )
, m_bActive                       ( false )
, m_uiQualityLevelForPrediction   ( 3 )
, m_pcResizeParameter             ( 0 ) //TMM_ESS
, m_iMbProcessed                           (-1) //--ICU/ETRI FMO Implementation
, m_bIsNewPic						(true)
, m_bAVCBased                     ( false ) //JVT-T054
{
  ::memset( m_apcFrameTemp, 0x00, sizeof( m_apcFrameTemp ) );
//TMM_EC {{
  m_pcVeryFirstSliceHeader = NULL;
	m_bBaseLayerLost	=	false;
//TMM_EC }}
//JVT-T054{
  UInt uiFGSLayer;
  for(uiFGSLayer = 0; uiFGSLayer < MAX_FGS_LAYERS; uiFGSLayer++)
  {
    m_pcResizeParameterCGSSNR[uiFGSLayer] = 0;
  }
//JVT-T054}
}



MCTFDecoder::~MCTFDecoder()
{
}



ErrVal
MCTFDecoder::create( MCTFDecoder*& rpcMCTFDecoder )
{
  rpcMCTFDecoder = new MCTFDecoder;
  ROT( NULL == rpcMCTFDecoder );
  return Err::m_nOK;
}



ErrVal
MCTFDecoder::destroy()
{
  ROT( m_bInitDone );

  delete this;
  return Err::m_nOK;
}



ErrVal
MCTFDecoder::init( H264AVCDecoder*      pcH264AVCDecoder,
                   SliceReader*         pcSliceReader,
                   SliceDecoder*        pcSliceDecoder,
                   RQFGSDecoder*        pcRQFGSDecoder,
                   NalUnitParser*       pcNalUnitParser,
                   ControlMngIf*        pcControlMng,
                   LoopFilter*          pcLoopFilter,
                   HeaderSymbolReadIf*  pcHeaderSymbolReadIf,
                   ParameterSetMng*     pcParameterSetMng,
                   PocCalculator*       pcPocCalculator,
                   YuvBufferCtrl*       pcYuvFullPelBufferCtrl,
                   DecodedPicBuffer*    pcDecodedPictureBuffer,
                   MotionCompensation*  pcMotionCompensation,
                   QuarterPelFilter*    pcQuarterPelFilter )
{
  ROT( NULL == pcH264AVCDecoder );
  ROT( NULL == pcSliceReader );
  ROT( NULL == pcSliceDecoder );
  ROT( NULL == pcNalUnitParser );
  ROT( NULL == pcControlMng );
  ROT( NULL == pcLoopFilter );
  ROT( NULL == pcHeaderSymbolReadIf );
  ROT( NULL == pcParameterSetMng );
  ROT( NULL == pcPocCalculator );
  ROT( NULL == pcQuarterPelFilter );
  ROT( NULL == pcYuvFullPelBufferCtrl );
  ROT( NULL == pcDecodedPictureBuffer );
  ROT( NULL == pcMotionCompensation );
  ROT( NULL == pcRQFGSDecoder );

  m_pcH264AVCDecoder              = pcH264AVCDecoder;
  m_pcSliceReader                 = pcSliceReader;
  m_pcSliceDecoder                = pcSliceDecoder ;
  m_pcNalUnitParser               = pcNalUnitParser;
  m_pcControlMng                  = pcControlMng;
  m_pcLoopFilter                  = pcLoopFilter;
  m_pcHeaderSymbolReadIf          = pcHeaderSymbolReadIf;
  m_pcParameterSetMng             = pcParameterSetMng;
  m_pcPocCalculator               = pcPocCalculator;
  m_pcYuvFullPelBufferCtrl        = pcYuvFullPelBufferCtrl;
  m_pcDecodedPictureBuffer        = pcDecodedPictureBuffer;
  m_pcMotionCompensation          = pcMotionCompensation;
  m_pcQuarterPelFilter            = pcQuarterPelFilter;
  m_pcRQFGSDecoder                = pcRQFGSDecoder;

  
  m_bInitDone                     = true;
  m_bCreateDone                   = false;
  m_bWaitForIdr                   = true;
  m_bActive                       = false;
  m_uiFrameWidthInMb              = 0;
  m_uiFrameHeightInMb             = 0;
  m_uiMbNumber                    = 0;

  m_pcResidual                    = 0;
  m_pcILPrediction                = 0;
  m_pcBaseLayerFrame              = 0;
  m_pcBaseLayerResidual           = 0;
  m_pcPredSignal                  = 0;
  m_pcBaseLayerCtrl               = 0;
  m_pcCurrDPBUnit                 = 0;
  m_pcBaseLayerCtrlEL             = 0;

  m_uiLayerId                     = 0;

  m_iMbProcessed                  = -1;

  m_bIsNewPic					  = true;
  m_bAVCBased                     = false; //JVT-T054
  return Err::m_nOK;
}



ErrVal
MCTFDecoder::uninit()
{
  m_pcSliceReader             = NULL;
  m_pcSliceDecoder            = NULL;
  m_pcNalUnitParser           = NULL;
  m_pcControlMng              = NULL;
  m_pcLoopFilter              = NULL;
  m_pcHeaderSymbolReadIf      = NULL;
  m_pcParameterSetMng         = NULL;
  m_pcPocCalculator           = NULL;
  m_pcYuvFullPelBufferCtrl    = NULL;
  m_pcMotionCompensation      = NULL;
  m_uiFrameWidthInMb          = 0;
  m_uiFrameHeightInMb         = 0;
// {{ TMM_EC
	delete m_pcVeryFirstSliceHeader;
  m_pcVeryFirstSliceHeader = NULL;
// }}TMM_EC
  RNOK( xDeleteData() );

  m_bInitDone                 = false;

  return Err::m_nOK;
}




ErrVal
MCTFDecoder::initSlice0( SliceHeader* rcSH )
{
  ROTRS( m_bActive, Err::m_nOK );

  //===== get and set relevant parameters =====
  m_uiLayerId         = rcSH->getLayerId();
  m_uiFrameWidthInMb  = rcSH->getSPS().getFrameWidthInMbs();
  m_uiFrameHeightInMb = rcSH->getSPS().getFrameHeightInMbs();
  m_uiMbNumber        = m_uiFrameWidthInMb * m_uiFrameHeightInMb;

  //===== re-allocate dynamic memory =====
  RNOK( xDeleteData() );
  RNOK( xCreateData( rcSH->getSPS() ) );

  //===== initialize DPB =====
  RNOK( m_pcDecodedPictureBuffer->initSPS( rcSH->getSPS() ) );

  //===== initialize some parameters =====
  m_bActive         = true;
  m_bInitDone       = true;

  return Err::m_nOK;