gopdecoder.cpp

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

          else
          {
            uiPicNumPred -=   uiAbsDiff;
          }
        }
        else // uiCommand == RPLR_POS
        {
          if( uiPicNumPred + uiAbsDiff > uiMaxPicNum - 1 )
          {
            uiPicNumPred += ( uiAbsDiff - uiMaxPicNum );
          }
          else
          {
            uiPicNumPred +=   uiAbsDiff;
          }
        }
        uiIdentifier = uiPicNumPred;
        
				PicType ePicType;
        xSetIdentifier( uiIdentifier, ePicType, eCurrentPicType );

        //----- get frame -----
        DPBUnitList::iterator iter = m_cUsedDPBUnitList.begin();
        DPBUnitList::iterator end  = m_cUsedDPBUnitList.end  ();
        for( ; iter != end; iter++ )
        {
          if( (*iter)->isNeededForRef() &&
              (*iter)->getFrameNum() == uiIdentifier &&
              (!pcFrame || (*iter)->isBaseRep() == bBaseRep ) )
          {
            pcFrame = (*iter)->getFrame()->getPic( ePicType );
          }
        }
        if( !pcFrame )
        {
          fprintf( stderr, "\nERROR: MISSING PICTURE !!!!\n\n");
          RERR();
        }
        //----- find picture in reference list -----
        UInt uiRemoveIndex = MSYS_UINT_MAX;
        for( UInt uiPos = uiIndex; uiPos < rcList.getActive(); uiPos++ ) // active is equal to size !!!
        {
          if( rcList.getEntry( uiPos ) == pcFrame )
          {
            uiRemoveIndex = uiPos;
            break;
          }
        }

        //----- reference list re-ordering -----
        RNOK( rcList.setElementAndRemove( uiIndex, uiRemoveIndex, pcFrame ) );
        uiIndex++;
      } // short-term RPLR
    } // while command
  }

  //===== set final size =====
  //EIDR JVT-Q065
 // ROT( pcSliceHeader->getNumRefIdxActive( eListIdx ) > rcList.getActive() );
	rcList.setActive( pcSliceHeader->getNumRefIdxActive( eListIdx ) );

  return Err::m_nOK;
}



ErrVal
DecodedPicBuffer::xDumpRefList( RefFrameList& rcList,
                                ListIdx       eListIdx)
{
#if 1 // NO_DEBUG
  return Err::m_nOK;
#endif

  printf("LIST_%d={", eListIdx );
  for( UInt uiIndex = 1; uiIndex <= rcList.getActive(); uiIndex++ )
  {
		const PicType ePicType = rcList[uiIndex]->getPicType();
		printf(" %s POC=%4d,", ePicType==FRAME ? "FRAME" : ( ePicType==TOP_FIELD ? "TOP_FIELD" : "BOT_FIELD" ), rcList[uiIndex]->getPoc() );
  }
  printf(" }\n");
  return Err::m_nOK;
}

ErrVal
DecodedPicBuffer::initPicCurrDPBUnit( PicBuffer*&    rpcPicBuffer,
                                      Bool           bRef) //JVT-T054
{
    ROF( m_bInitDone );
    if(!bRef) //JVT-T054
    {
      //===== insert pic buffer in list =====
      m_cPicBufferList.push_back( rpcPicBuffer );
      rpcPicBuffer = 0;
    }
  SliceHeader* pcOldSH = m_pcCurrDPBUnit->getCtrlData().getSliceHeader();
  delete pcOldSH;
  m_pcCurrDPBUnit->getCtrlData().clear();
  m_pcCurrDPBUnit->getCtrlData().getMbDataCtrl()->reset();
  m_pcCurrDPBUnit->getCtrlData().getMbDataCtrl()->clear();

  return Err::m_nOK;
}


ErrVal
DecodedPicBuffer::initCurrDPBUnit( DPBUnit*&      rpcCurrDPBUnit,
                                   SliceHeader*   pcSliceHeader,
                                   PicBufferList& rcOutputList,
                                   PicBufferList& rcUnusedList,
                                   Bool           bRef) //JVT-T054
{
  ROF( m_bInitDone );

  Bool bNewFrame = true;
  if( NULL != m_pcLastDPBUnit )
  {
     bNewFrame = ! pcSliceHeader->isFieldPair( m_pcLastDPBUnit->getFrameNum(), m_pcLastDPBUnit->getPicType(), m_pcLastDPBUnit->isNalRefIdc() );
  }
  if( ! bNewFrame )
  {
    // reuse the DPBUnit in case of second field
    m_cFreeDPBUnitList.push_back( m_pcCurrDPBUnit );
		DPBUnitList::iterator iter = m_cUsedDPBUnitList.find( m_pcLastDPBUnit );
    if( iter != m_cUsedDPBUnitList.end() )
		{
			m_cUsedDPBUnitList.erase( iter );
		}
    m_pcCurrDPBUnit = m_pcLastDPBUnit;
  }

  if(!bRef) //JVT-T054
  {
    //===== check missing pictures =====
	  RNOK( xCheckMissingPics( pcSliceHeader, rcOutputList, rcUnusedList ) );
  }

  //===== initialize current DPB unit =====
  RNOK( m_pcCurrDPBUnit->init( *pcSliceHeader ) );

  ROT( pcSliceHeader->getUseBasePredictionFlag() && !pcSliceHeader->getNalRefIdc() ); // just a check
  m_pcCurrDPBUnit->getCtrlData().setSliceHeader( pcSliceHeader );
  m_pcCurrDPBUnit->setPicType( pcSliceHeader->getPicType() );
  m_pcCurrDPBUnit->setNalRefIdc( pcSliceHeader->getNalRefIdc() );

  if(!bRef) //JVT-T054
// JVT-Q065 EIDR{
  if( m_pcCurrDPBUnit->getCtrlData().getSliceHeader()->isIdrNalUnit() )
  {
	  //===== IDR pictures =====
	  Int iDummy;
	  RNOK( xClearOutputAll( rcOutputList, rcUnusedList, iDummy, false  ) ); // clear and output all pictures
  }
// JVT-Q065 EIDR}

  //===== set DPB unit =====
  rpcCurrDPBUnit = m_pcCurrDPBUnit;
  m_pcLastDPBUnit = m_pcCurrDPBUnit;
  return Err::m_nOK;
}



ErrVal
DecodedPicBuffer::clear( PicBufferList& rcOutputList,
                         PicBufferList& rcUnusedList,
                         Int&           riMaxPoc )
{
  RNOK( xClearOutputAll( rcOutputList, rcUnusedList, riMaxPoc, true ) ); // clear and output all pictures
  ROF ( m_cPicBufferList.empty() );
  return Err::m_nOK;
}



DPBUnit*
DecodedPicBuffer::getLastUnit()
{
  ROTRS( m_cUsedDPBUnitList.empty(), 0 );
  return m_cUsedDPBUnitList.back();
}



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

//TMM_EC {{
ErrVal              
DecodedPicBuffer::getPrdRefListsFromBase( DPBUnit*    pcCurrDPBUnit, SliceHeader* pSliceHeaderBase , DPBUnit*    pcBaseDPBUnit)//TMM_EC
{
  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 );
  UInt uiPos;
  rcList0.reset();
  rcList1.reset();
//TMM_EC {{
  if ( pcBaseDPBUnit )
  {
  RefFrameList& rcBaseList0 = pcBaseDPBUnit->getCtrlData().getPrdFrameList( LIST_0 );
  RefFrameList& rcBaseList1 = pcBaseDPBUnit->getCtrlData().getPrdFrameList( LIST_1 );

  //----- generate reference list0 -----
  for( uiPos = 0; uiPos < rcBaseList0.getActive(); uiPos++ )
  {
	  UInt uiPoc=rcBaseList0.getEntry(uiPos)->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)->getFrame()->getPoc()==uiPoc)
        {
          pNext = (*iter);
        }
      }
      rcList0.add( pNext->getFrame() );
    }

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

    for(      uiPos = 0; uiPos < rcBaseList1.getActive(); uiPos++ )
    {
	  UInt uiPoc=rcBaseList1.getEntry(uiPos)->getPoc();
	  DPBUnit*              pNext = 0;
      DPBUnitList::iterator iter  = m_cUsedDPBUnitList.begin();
      DPBUnitList::iterator end   = m_cUsedDPBUnitList.end  ();
      for( ; iter != end; iter++ )
      {
        if((*iter)->getFrame()->getPoc()==uiPoc)
        {
          pNext = (*iter);
        }
      }
      rcList1.add( pNext->getFrame() );
    }
  }
  else
  {
//TMM_EC }}
   	const PicType ePicType = pSliceHeaderBase->getPicType();

    RefPicList<RefPic>& rcBaseList0 =pSliceHeaderBase->getRefPicList(ePicType, LIST_0);
    RefPicList<RefPic>& rcBaseList1 =pSliceHeaderBase->getRefPicList(ePicType, 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)->getFrame()->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)->getFrame()->getPoc()==uiPoc)
        {
          pNext = (*iter);
        }
      }
      rcList1.add( pNext->getFrame() );
    }//TMM_EC
  }

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


ErrVal
DecodedPicBuffer::setPrdRefLists( DPBUnit* pcCurrDPBUnit )
{
  ROF( m_pcCurrDPBUnit == pcCurrDPBUnit );
  ROF( m_pcCurrDPBUnit->getCtrlData().getSliceHeader() );
  SliceHeader* pcSliceHeader = m_pcCurrDPBUnit->getCtrlData().getSliceHeader();
	ROF( pcSliceHeader );
  const PicType   ePicType   = pcSliceHeader->getPicType  ();
	const SliceType eSliceType = pcSliceHeader->getSliceType();

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

	IntFrame* pcCurrentFrame = m_pcCurrDPBUnit->getFrame();
  
  ROTRS( pcSliceHeader->isIntra(),   Err::m_nOK );

  if( pcSliceHeader->isInterP() )
  {
    RNOK( xInitPrdListPSlice( rcList0, pcCurrentFrame, ePicType, eSliceType ) );
    RNOK( xPrdListRemapping ( rcList0, LIST_0, pcSliceHeader                ) );
    RNOK( xDumpRefList      ( rcList0, LIST_0                               ) );
  }
  else
  {
    RNOK( xInitPrdListsBSlice( rcList0, rcList1, pcCurrentFrame, ePicType, eSliceType ) );
    RNOK( xPrdListRemapping  ( rcList0, LIST_0, pcSliceHeader                         ) );
    RNOK( xPrdListRemapping  ( rcList1, LIST_1, pcSliceHeader                         ) );
    RNOK( xDumpRefList       ( rcList0, LIST_0                                        ) );
    RNOK( xDumpRefList       ( rcList1, LIST_1                                        ) );
  }

  return Err::m_nOK;
}

ErrVal
DecodedPicBuffer::store( DPBUnit*&        rpcDPBUnit,
                         PicBufferList&   rcOutputList,
                         PicBufferList&   rcUnusedList,
                         IntFrame*        pcFrameBaseRep,
                         Bool             bRef) //JVT-T054
{
    RNOK( xStorePicture( rpcDPBUnit, 
                       rcOutputList, 
                       rcUnusedList,
                       rpcDPBUnit->getCtrlData().getSliceHeader()->isIdrNalUnit(),
                       /*uiQualityLevel,*/                         //JVT-T054
                       rpcDPBUnit->getCtrlData().getSliceHeader()->getSPS().getFrameMbsOnlyFlag(), bRef) ); //TMM_INTERLACE
 
  
  if( rpcDPBUnit->isNeededForRef() )
  {
    m_uiLastRefFrameNum = rpcDPBUnit->getFrameNum();
  }

  ROFRS( pcFrameBaseRep, Err::m_nOK );
  ROTRS( bRef,           Err::m_nOK );

  // Do not store the base representation if not specified in the stream
  ROFRS( rpcDPBUnit->getCtrlData().getSliceHeader()->getStoreBaseRepresentationFlag(), 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 = NULL;
  DPBUnitList::iterator iter1 = m_cUsedDPBUnitList.begin();
  DPBUnitList::iterator end1  = m_cUsedDPBUnitList.end  ();
  for( ; iter1 != end1; iter1++ )
  {
    if( ((*iter1)->getFrameNum() == rpcDPBUnit->getFrameNum() ) &&
      (  (*iter1)->isBaseRep  ()))
    {
      pcBaseRep = (*iter1);
      m_cUsedDPBUnitList.erase( iter1 );
      break;
    }
  }

  if( NULL == pcBaseRep )
  {
    pcBaseRep = m_cFreeDPBUnitList.popFront();
  }

  //--- init unit and extend picture ---
	const PicType ePicType          = rpcDPBUnit->getCtrlData().getSliceHeader()->getPicType();
 	const Bool    bFrameMbsOnlyFlag = rpcDPBUnit->getCtrlData().getSliceHeader()->getSPS().getFrameMbsOnlyFlag();
  RNOK( pcBaseRep->initBase( *rpcDPBUnit, pcFrameBaseRep ) );
  RNOK( m_pcYuvBufferCtrl->initMb() );
  RNOK( pcBaseRep->getFrame()->extendFrame( NULL, ePicType, bFrameMbsOnlyFlag ) );
  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{
  } 

  return Err::m_nOK;
}



ErrVal
DecodedPicBuffer::update( DPBUnit*  pcDPBUnit )