h264avcencoder.cpp

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

				uiTotalScalableLayer++;
			}
		}

	}

	UInt              uiBits = 0;
	SEI::MessageList  cSEIMessageList;
	cSEIMessageList.push_back                       ( pcScalableSEI );
	RNOK( m_pcNalUnitEncoder  ->initNalUnit         ( pcExtBinDataAccessor ) );
	RNOK( m_pcNalUnitEncoder  ->write               ( cSEIMessageList ) );
	RNOK( m_pcNalUnitEncoder  ->closeNalUnit        ( uiBits ) );
	RNOK( m_apcMCTFEncoder[0] ->addParameterSetBits ( uiBits+4*8 ) );

	return Err::m_nOK;

}



// JVT-S080 LMI {
ErrVal
H264AVCEncoder::xWriteScalableSEILayersNotPresent( ExtBinDataAccessor* pcExtBinDataAccessor, UInt uiNumLayers, UInt* uiLayerId)
{
	UInt i, uiBits = 0;
	SEI::MessageList  cSEIMessageList;
	SEI::ScalableSeiLayersNotPresent* pcScalableSeiLayersNotPresent;
	RNOK(SEI::ScalableSeiLayersNotPresent::create(pcScalableSeiLayersNotPresent) );
	pcScalableSeiLayersNotPresent->setNumLayers( uiNumLayers );
	for (i=0; i < uiNumLayers; i++)
	pcScalableSeiLayersNotPresent->setLayerId( i, uiLayerId[i] );
	cSEIMessageList.push_back                       ( pcScalableSeiLayersNotPresent );
	RNOK( m_pcNalUnitEncoder  ->initNalUnit         ( pcExtBinDataAccessor ) );
	RNOK( m_pcNalUnitEncoder  ->write               ( cSEIMessageList ) );
	RNOK( m_pcNalUnitEncoder  ->closeNalUnit        ( uiBits ) );
	RNOK( m_apcMCTFEncoder[0] ->addParameterSetBits ( uiBits+4*8 ) );

	return Err::m_nOK;
}

ErrVal
H264AVCEncoder::xWriteScalableSEIDependencyChange( ExtBinDataAccessor* pcExtBinDataAccessor, UInt uiNumLayers, UInt* uiLayerId, Bool* pbLayerDependencyInfoPresentFlag, 
												  UInt* uiNumDirectDependentLayers, UInt** puiDirectDependentLayerIdDeltaMinus1, UInt* puiLayerDependencyInfoSrcLayerIdDeltaMinus1)
{
	UInt uiBits = 0;
	SEI::MessageList  cSEIMessageList;
	SEI::ScalableSeiDependencyChange* pcScalableSeiDependencyChange;
	RNOK(SEI::ScalableSeiDependencyChange::create(pcScalableSeiDependencyChange) );
	pcScalableSeiDependencyChange->setNumLayersMinus1(uiNumLayers-1);
    UInt uiLayer, uiDirectLayer;

	for( uiLayer = 0; uiLayer < uiNumLayers; uiLayer++ )
	{
		pcScalableSeiDependencyChange->setLayerId( uiLayer, uiLayerId[uiLayer]);
		pcScalableSeiDependencyChange->setLayerDependencyInfoPresentFlag( uiLayer, pbLayerDependencyInfoPresentFlag[uiLayer] );
		if ( pcScalableSeiDependencyChange->getLayerDependencyInfoPresentFlag( uiLayer ) )
		{
          pcScalableSeiDependencyChange->setNumDirectDependentLayers( uiLayer, uiNumDirectDependentLayers[uiLayer] );
		  for ( uiDirectLayer = 0; uiDirectLayer < pcScalableSeiDependencyChange->getNumDirectDependentLayers( uiLayer ); uiDirectLayer++)
              pcScalableSeiDependencyChange->setDirectDependentLayerIdDeltaMinus1( uiLayer, uiDirectLayer,  puiDirectDependentLayerIdDeltaMinus1[uiLayer][uiDirectLayer] );
		}
		else
            pcScalableSeiDependencyChange->setLayerDependencyInfoSrcLayerIdDeltaMinus1( uiLayer, puiLayerDependencyInfoSrcLayerIdDeltaMinus1[uiLayer] );
	}


	cSEIMessageList.push_back                       ( pcScalableSeiDependencyChange );
	RNOK( m_pcNalUnitEncoder  ->initNalUnit         ( pcExtBinDataAccessor ) );
	RNOK( m_pcNalUnitEncoder  ->write               ( cSEIMessageList ) );
	RNOK( m_pcNalUnitEncoder  ->closeNalUnit        ( uiBits ) );
	RNOK( m_apcMCTFEncoder[0] ->addParameterSetBits ( uiBits+4*8 ) );

	return Err::m_nOK;
}
//  JVT-S080 LMI }

ErrVal
H264AVCEncoder::xWriteSubPicSEI ( ExtBinDataAccessor* pcExtBinDataAccessor )
{
	SEI::SubPicSei* pcSubPicSEI;
	RNOK( SEI::SubPicSei::create( pcSubPicSEI ) );

  //===== set message =====
	UInt uiScalableLayerId = 0;	//should be changed
	pcSubPicSEI->setLayerId( uiScalableLayerId );
  
	//===== write message =====
  UInt              uiBits = 0;
  SEI::MessageList  cSEIMessageList;
  cSEIMessageList.push_back                       ( pcSubPicSEI );
  RNOK( m_pcNalUnitEncoder  ->initNalUnit         ( pcExtBinDataAccessor ) );
  RNOK( m_pcNalUnitEncoder  ->write               ( cSEIMessageList ) );
  RNOK( m_pcNalUnitEncoder  ->closeNalUnit        ( uiBits ) );

	return Err::m_nOK;
}


ErrVal
H264AVCEncoder::xWriteSubPicSEI ( ExtBinDataAccessor* pcExtBinDataAccessor, UInt layer_id )
{
	SEI::SubPicSei* pcSubPicSEI;
	RNOK( SEI::SubPicSei::create( pcSubPicSEI ) );

  //===== set message =====
	pcSubPicSEI->setLayerId( layer_id );
  
	//===== write message =====
  UInt              uiBits = 0;
  SEI::MessageList  cSEIMessageList;
  cSEIMessageList.push_back                       ( pcSubPicSEI );
  RNOK( m_pcNalUnitEncoder  ->initNalUnit         ( pcExtBinDataAccessor ) );
  RNOK( m_pcNalUnitEncoder  ->write               ( cSEIMessageList ) );
  RNOK( m_pcNalUnitEncoder  ->closeNalUnit        ( uiBits ) );

	return Err::m_nOK;
}

// Scalable SEI for ROI ICU/ETRI
ErrVal
H264AVCEncoder::xWriteMotionSEI( ExtBinDataAccessor* pcExtBinDataAccessor, UInt sg_id ) 
{
  //===== create message =====
  SEI::MotionSEI* pcMotionSEI;
  RNOK( SEI::MotionSEI::create( pcMotionSEI) );

  pcMotionSEI->setSliceGroupId(sg_id);


  //===== write message =====
  UInt              uiBits = 0;
  SEI::MessageList  cSEIMessageList;
  cSEIMessageList.push_back                       ( pcMotionSEI);
  RNOK( m_pcNalUnitEncoder  ->initNalUnit         ( pcExtBinDataAccessor ) );
  RNOK( m_pcNalUnitEncoder  ->write               ( cSEIMessageList ) );
  RNOK( m_pcNalUnitEncoder  ->closeNalUnit        ( uiBits ) );

  return Err::m_nOK;
}

ErrVal
H264AVCEncoder::writeParameterSets( ExtBinDataAccessor* pcExtBinDataAccessor, Bool &rbMoreSets )
{
  if( m_bVeryFirstCall )
  {
    m_bVeryFirstCall = false;

    RNOK( xInitParameterSets() );
    if( m_bScalableSeiMessage )
      RNOK( xWriteScalableSEI( pcExtBinDataAccessor ) );

	LayerParameters& rcLayer = m_pcCodingParameter->getLayerParameters ( 0 );
	if (0 < rcLayer.getNumROI())
		m_bWrteROISEI = true;
	else
		m_bWrteROISEI = false;
    m_loop_roi_sei=0;

    return Err::m_nOK;
  }
  else
    m_bScalableSeiMessage = true;

  UInt uiNumLayer = m_pcCodingParameter->getNumberOfLayers();
	
  if(m_bWrteROISEI)
  {
	LayerParameters& rcLayer = m_pcCodingParameter->getLayerParameters ( m_loop_roi_sei/2 );
	{
	  if(((m_loop_roi_sei+1)/2) >= uiNumLayer )
	  {
		m_bWrteROISEI = false;
	  }

	  if(m_loop_roi_sei%2)
	  {			
		RNOK( xWriteMotionSEI( pcExtBinDataAccessor,rcLayer.getSGID()[0] ) );    m_loop_roi_sei++; return Err::m_nOK;
	  }
	  else
	  {
	    RNOK( xWriteSubPicSEI( pcExtBinDataAccessor, rcLayer.getSLID()[0] ) );    m_loop_roi_sei++; return Err::m_nOK;
	  }
    }		
  }
    
  UInt uiBits;

  if( ! m_cUnWrittenSPS.empty() )
  {
    RNOK( m_pcNalUnitEncoder->initNalUnit( pcExtBinDataAccessor ) );
    SequenceParameterSet& rcSPS = *m_cUnWrittenSPS.front();
    
    if( rcSPS.getMbAdaptiveFrameFieldFlag() )
		{
			rcSPS.setFrameMbsOnlyFlag( false );
		}
		
    RNOK( m_pcNalUnitEncoder->write( rcSPS ) );
    RNOK( m_pcNalUnitEncoder->closeNalUnit( uiBits ) );

    if( m_pcCodingParameter->getNumberOfLayers() )
    {
      UInt  uiLayer = rcSPS.getLayerId();
      UInt  uiSize  = pcExtBinDataAccessor->size();
      RNOK( m_apcMCTFEncoder[uiLayer]->addParameterSetBits( 8*(uiSize+4) ) );
    }
    
    m_cUnWrittenSPS.pop_front();
  }
  else
  {
    if( ! m_cUnWrittenPPS.empty() )
    {
      RNOK( m_pcNalUnitEncoder->initNalUnit( pcExtBinDataAccessor ) );
      PictureParameterSet& rcPPS = *m_cUnWrittenPPS.front();
      RNOK( m_pcNalUnitEncoder->write( rcPPS ) )
      RNOK( m_pcNalUnitEncoder->closeNalUnit( uiBits ) );

      if( m_pcCodingParameter->getNumberOfLayers() )
      {
        UInt  uiSPSId = rcPPS.getSeqParameterSetId();
        SequenceParameterSet* pcSPS;
        RNOK( m_pcParameterSetMng->get( pcSPS, uiSPSId ) );

        UInt  uiLayer = pcSPS->getLayerId();
        UInt  uiSize  = pcExtBinDataAccessor->size();
        RNOK( m_apcMCTFEncoder[uiLayer]->addParameterSetBits( 8*(uiSize+4) ) );
      }
      
      m_cUnWrittenPPS.pop_front();
    }
    else
    {
      AF();
      rbMoreSets = false;
      return Err::m_nERR;
    }
  }

  rbMoreSets = !(m_cUnWrittenSPS.empty() && m_cUnWrittenPPS.empty());
  return Err::m_nOK;
}



ErrVal
H264AVCEncoder::process( ExtBinDataAccessorList&  rcExtBinDataAccessorList,
                         PicBuffer*               apcOriginalPicBuffer    [MAX_LAYERS],
                         PicBuffer*               apcReconstructPicBuffer [MAX_LAYERS],
                         PicBufferList*           apcPicBufferOutputList,
                         PicBufferList*           apcPicBufferUnusedList )
{
  UInt  uiHighestLayer  = m_pcCodingParameter->getNumberOfLayers() - 1;
  UInt  uiTargetSize    = ( 1 << m_pcCodingParameter->getLayerParameters(uiHighestLayer).getDecompositionStages() ) + ( m_apcMCTFEncoder[uiHighestLayer]->firstGOPCoded() ? 0 : 1 );

  //===== fill lists =====
  for( UInt uiLayer = 0; uiLayer <= uiHighestLayer; uiLayer++ )
  {
    if( apcOriginalPicBuffer[ uiLayer ] )
    {
      ROF( apcReconstructPicBuffer[ uiLayer ] );
      m_acOrgPicBufferList  [ uiLayer ].push_back( apcOriginalPicBuffer   [ uiLayer ] );
      m_acRecPicBufferList  [ uiLayer ].push_back( apcReconstructPicBuffer[ uiLayer ] );
    }
    else if( apcReconstructPicBuffer[ uiLayer ] )
    {
      apcPicBufferUnusedList[ uiLayer ].push_back( apcReconstructPicBuffer[ uiLayer ] );
    }
  }

  //===== encoding of GOP =====
  ROT( m_acOrgPicBufferList[uiHighestLayer].size() >  uiTargetSize );
  if ( m_acOrgPicBufferList[uiHighestLayer].size() == uiTargetSize )
  {
    RNOK( xProcessGOP( apcPicBufferOutputList, apcPicBufferUnusedList ) );
  }

  //===== update data accessor list =====
  m_cAccessUnitList.emptyNALULists( rcExtBinDataAccessorList );

  return Err::m_nOK;
}


ErrVal
H264AVCEncoder::finish( ExtBinDataAccessorList&  rcExtBinDataAccessorList,
                        PicBufferList*           apcPicBufferOutputList,
                        PicBufferList*           apcPicBufferUnusedList,
                        UInt&                    ruiNumCodedFrames,
                        Double&                  rdHighestLayerOutputRate )
{
  //===== encode GOP =====
  RNOK( xProcessGOP( apcPicBufferOutputList, apcPicBufferUnusedList ) );

  //===== update data accessor list =====