createrh264avcdecoder.cpp

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

        {
			uiOperationPointId = pcSEI->getOperationPointId();
		}
		else
		{
		  uiNumActiveViewsMinus1 = pcSEI->getNumActiveViewsMinus1();
          uiViewId = new UInt[uiNumActiveViewsMinus1+1];
          for( UInt uiIndex = 0; uiIndex <= uiNumActiveViewsMinus1; uiIndex++ )
          {
            uiViewId[uiIndex] = pcSEI->getViewId(uiIndex);
          }

          delete uiViewId;
        }
              bApplyToNext = true;
        break;
      }
//SEI }
	  case SEI::MULTIVIEW_SCENE_INFO_SEI: // SEI JVT-W060
      {
        UInt uiMaxDisparity;
		
		SEI::MultiviewSceneInfoSei* pcSEI = (SEI::MultiviewSceneInfoSei*)pcSEIMessage;
		uiMaxDisparity = pcSEI->getMaxDisparity();
        bApplyToNext = true;
        break;
      }
	  case SEI::MULTIVIEW_ACQUISITION_INFO_SEI: // SEI JVT-W060
      {
        
        SEI::MultiviewAcquisitionInfoSei* pcSEI = (SEI::MultiviewAcquisitionInfoSei*)pcSEIMessage;
        bApplyToNext = true;
        break;
      }
      default:
        {
          delete pcSEIMessage;
        }
      }
    }
    m_pcNalUnitParser->closeNalUnit();
  }

  if( eNalUnitType != NAL_UNIT_SEI )
  {
    ULong*  pulData = (ULong*)( pcBinData->data() + 1 );
    UInt    uiSize  =     8 * ( pcBinData->size() - 1 ) - 1;
    RNOK( m_pcBitReadBuffer->initPacket( pulData, uiSize ) );

    uiSize = pcBinData->byteSize();
    BinData cBinData( new UChar[uiSize], uiSize );
    memcpy( cBinData.data(), pcBinData->data(), uiSize );
    BinDataAccessor cBinDataAccessor;
    cBinData.setMemAccessor( cBinDataAccessor );
    m_pcNalUnitParser->setCheckAllNALUs(true); //JVT-P031
	  UInt uiNumBytesRemoved; //FIX_FRAG_CAVLC

  	RNOK( m_pcNalUnitParser->initNalUnit( &cBinDataAccessor, NULL, uiNumBytesRemoved ) ); //FIX_FRAG_CAVLC

    m_pcNalUnitParser->setCheckAllNALUs(false);//JVT-P031
  
    // get the SPSid
    if(eNalUnitType == NAL_UNIT_SPS )
    {
      SequenceParameterSet* pcSPS = NULL;
      RNOK( SequenceParameterSet::create  ( pcSPS   ) );
	  
      RNOK( pcSPS->read( m_pcUvlcReader, eNalUnitType ) );
      // Copy simple priority ID mapping from SPS
       uiSPSid = pcSPS->getSeqParameterSetId();
	  
      pcSPS->destroy();
    }
    // get the PPSid and the referenced SPSid
    else if( eNalUnitType == NAL_UNIT_PPS )
    {
      PictureParameterSet* pcPPS = NULL;
      RNOK( PictureParameterSet::create  ( pcPPS   ) );
      RNOK( pcPPS->read( m_pcUvlcReader, eNalUnitType ) );
      uiPPSid = pcPPS->getPicParameterSetId();
      uiSPSid = pcPPS->getSeqParameterSetId();

	  // FMO ROI ICU/ETRI
	  m_uiNumSliceGroupsMinus1 = pcPPS->getNumSliceGroupsMinus1();
   
	  for(UInt i=0; i<=m_uiNumSliceGroupsMinus1; i++)
	  {
		 uiaAddrFirstMBofROIs[uiPPSid ][i] = pcPPS->getTopLeft (i);
		 uiaAddrLastMBofROIs[uiPPSid ][i]  = pcPPS->getBottomRight (i);
	  }

      pcPPS->destroy();
      rcPacketDescription.SPSidRefByPPS[uiPPSid] = uiSPSid;
    }
    // get the PPSid and SPSid referenced by the slice header
    else if(  eNalUnitType == NAL_UNIT_CODED_SLICE              ||
              eNalUnitType == NAL_UNIT_CODED_SLICE_IDR          ||
              eNalUnitType == NAL_UNIT_CODED_SLICE_SCALABLE     ||
              eNalUnitType == NAL_UNIT_CODED_SLICE_IDR_SCALABLE   )
    {
//BUG FIX Kai Zhang{
	if(!(uiLayer == 0 && uiFGSLayer == 0 && m_bAVCCompatible&&
			(eNalUnitType == NAL_UNIT_CODED_SLICE_SCALABLE||eNalUnitType == NAL_UNIT_CODED_SLICE_IDR_SCALABLE))){
      UInt uiTemp;
	    Bool bTemp;
      //JVT-P031

    RNOK( m_pcUvlcReader->getUvlc( uiTemp,  "SH: first_mb_in_slice" ) );

	// FMO ROI ICU/ETRI
	rcPacketDescription.uiFirstMb = uiTemp;


    RNOK( m_pcUvlcReader->getUvlc( uiTemp,  "SH: slice_type" ) );
//JVT-T054{
		rcPacketDescription.bEnableQLTruncation = false;
//JVT-T054}
    if(uiTemp == F_SLICE)
    {
//JVT-T054{
      rcPacketDescription.bEnableQLTruncation = true;
//JVT-T054}
       RNOK( m_pcUvlcReader->getFlag( bFragmentedFlag,  "SH: fragmented_flag" ) );
       if(bFragmentedFlag)
       {
            RNOK( m_pcUvlcReader->getUvlc(uiFragmentOrder,  "SH: fragment_order" ) );
            if(uiFragmentOrder!=0)
            {
                RNOK( m_pcUvlcReader->getFlag( bLastFragmentFlag,  "SH: last_fragment_flag" ) );
            }
       }
		  if(uiFragmentOrder == 0 )
		  {
			  RNOK( m_pcUvlcReader    ->getUvlc( uiTemp,  "SH: num_mbs_in_slice" ) );
			  RNOK( m_pcUvlcReader    ->getFlag( bTemp,  "SH: fgs_comp_sep" ) );
		  }
    }
  
    if(uiFragmentOrder == 0)
    {
        RNOK( m_pcUvlcReader->getUvlc( uiPPSid, "SH: pic_parameter_set_id" ) );
        uiSPSid = rcPacketDescription.SPSidRefByPPS[uiPPSid];
    }     
		
    //~JVT-P031
		m_uiCurrPicLayer = (uiLayer << 4) + uiFGSLayer;
	  if(m_uiCurrPicLayer <= m_uiPrevPicLayer && m_uiNonRequiredSeiFlag != 1)
	  {
		  m_pcNonRequiredSEI->destroy();
		  m_pcNonRequiredSEI = NULL;
	  }          
	  m_uiNonRequiredSeiFlag = 0;
	  m_uiPrevPicLayer = m_uiCurrPicLayer;
		}
//BUG_FIX Kai Zhang}
    }
    m_pcNalUnitParser->closeNalUnit();
  }

  rcPacketDescription.NalUnitType   = eNalUnitType;
  rcPacketDescription.SPSid         = uiSPSid;
  rcPacketDescription.PPSid         = uiPPSid;

  rcPacketDescription.Scalable      = bScalable;
  rcPacketDescription.ParameterSet  = bParameterSet;
  rcPacketDescription.Layer         = uiLayer;
  rcPacketDescription.FGSLayer      = uiFGSLayer;
  rcPacketDescription.Level         = uiLevel;
  rcPacketDescription.ApplyToNext   = bApplyToNext;
  rcPacketDescription.uiPId         = uiSimplePriorityId;
  rcPacketDescription.bDiscardable  = bDiscardableFlag;//JVT-P031
  rcPacketDescription.bFragmentedFlag   = bFragmentedFlag;//JVT-P031
  rcPacketDescription.NalRefIdc     = eNalRefIdc;
//SEI {
  rcPacketDescription.bAnchorPicFlag = bAnchorPicFlag;
  rcPacketDescription.bSvcMvcFlag   = bSvcMvcFlag;
  rcPacketDescription.ViewId		= uiViewId;
//SEI }
  return Err::m_nOK;
}



ErrVal
H264AVCPacketAnalyzer::create( H264AVCPacketAnalyzer*& rpcH264AVCPacketAnalyzer )
{
  rpcH264AVCPacketAnalyzer = new H264AVCPacketAnalyzer;
  ROT( NULL == rpcH264AVCPacketAnalyzer );
  RNOK( rpcH264AVCPacketAnalyzer->xCreate() )
  return Err::m_nOK;
}
ErrVal     
H264AVCPacketAnalyzer::isMVCProfile ( BinData*				pcBinData, Bool& b )// fix Nov. 30
{
  UChar       ucByte        = (pcBinData->data())[0];
  NalUnitType eNalUnitType  = NalUnitType ( ucByte  & 0x1F );
  if ( eNalUnitType != NAL_UNIT_SPS )
  return Err::m_nERR; 

  ULong*  pulData = (ULong*)( pcBinData->data() + 1 );
  UInt    uiSize  =     8 * ( pcBinData->size() - 1 ) - 1;
  RNOK( m_pcBitReadBuffer->initPacket( pulData, uiSize ) );

  uiSize = pcBinData->byteSize();
  BinData cBinData( new UChar[uiSize], uiSize );
  memcpy( cBinData.data(), pcBinData->data(), uiSize );
  BinDataAccessor cBinDataAccessor;
  cBinData.setMemAccessor( cBinDataAccessor );
  m_pcNalUnitParser->setCheckAllNALUs(true); //JVT-P031
	UInt uiNumBytesRemoved; //FIX_FRAG_CAVLC

  RNOK( m_pcNalUnitParser->initNalUnit( &cBinDataAccessor, NULL, uiNumBytesRemoved ) ); //FIX_FRAG_CAVLC

  m_pcNalUnitParser->setCheckAllNALUs(false);//JVT-P031

  SequenceParameterSet* pcSPS = NULL;
  RNOK( SequenceParameterSet::create  ( pcSPS   ) );

	RNOK( pcSPS->read( m_pcUvlcReader, eNalUnitType ) );

  b= (MULTI_VIEW_PROFILE == pcSPS->getProfileIdc());
  
  pcSPS->destroy();
  
  return Err::m_nOK;
}

ErrVal
H264AVCPacketAnalyzer::processSEIAndMVC( BinData*				pcBinData,
								   SEI::ViewScalabilityInfoSei*&		pcSEIMessage )
{
  UChar       ucByte        = (pcBinData->data())[0];
  NalUnitType eNalUnitType  = NalUnitType ( ucByte  & 0x1F );
  Bool        bApplyToNext  = false;

  if( eNalUnitType == NAL_UNIT_SEI )
  {
    ULong*  pulData = (ULong*)( pcBinData->data() + 1 );
    UInt    uiSize  =     8 * ( pcBinData->size() - 1 ) - 1;
    RNOK( m_pcBitReadBuffer->initPacket( pulData, uiSize ) );

    uiSize = pcBinData->byteSize();
    BinData cBinData( new UChar[uiSize], uiSize );
    memcpy( cBinData.data(), pcBinData->data(), uiSize );
    BinDataAccessor cBinDataAccessor;
    cBinData.setMemAccessor( cBinDataAccessor );

    UInt uiNumBytesRemoved; //FIX_FRAG_CAVLC
    RNOK( m_pcNalUnitParser->initNalUnit( &cBinDataAccessor, NULL, uiNumBytesRemoved ) ); //FIX_FRAG_CAVLC
    SEI::MessageList cMessageList;
    RNOK( SEI::read( m_pcUvlcReader, cMessageList ) );

    SEI::MessageList::iterator iter = cMessageList.begin();
    while( ! cMessageList.empty() )
    {
      SEI::SEIMessage* pcSEIMessage1 = cMessageList.popBack();

      switch( pcSEIMessage1->getMessageType() )
      {
	  case SEI::VIEW_SCALABILITY_INFO_SEI:
      {
		pcSEIMessage = (SEI::ViewScalabilityInfoSei* )pcSEIMessage1;

        bApplyToNext = true;
        break;
      }
      default:
        {
          delete pcSEIMessage1;
        }
      }
    }
    m_pcNalUnitParser->closeNalUnit();
  }
  else if( eNalUnitType == NAL_UNIT_SPS && pcSEIMessage )
  {
    ULong*  pulData = (ULong*)( pcBinData->data() + 1 );
    UInt    uiSize  =     8 * ( pcBinData->size() - 1 ) - 1;
    RNOK( m_pcBitReadBuffer->initPacket( pulData, uiSize ) );

    uiSize = pcBinData->byteSize();
    BinData cBinData( new UChar[uiSize], uiSize );
    memcpy( cBinData.data(), pcBinData->data(), uiSize );
    BinDataAccessor cBinDataAccessor;
    cBinData.setMemAccessor( cBinDataAccessor );
    m_pcNalUnitParser->setCheckAllNALUs(true); //JVT-P031
	  UInt uiNumBytesRemoved; //FIX_FRAG_CAVLC

  	RNOK( m_pcNalUnitParser->initNalUnit( &cBinDataAccessor, NULL, uiNumBytesRemoved ) ); //FIX_FRAG_CAVLC

    m_pcNalUnitParser->setCheckAllNALUs(false);//JVT-P031
  
    SequenceParameterSet* pcSPS = NULL;
    RNOK( SequenceParameterSet::create  ( pcSPS   ) );
	pcSPS->SpsMVC = new SpsMvcExtension;	
 
	RNOK( pcSPS->read( m_pcUvlcReader, eNalUnitType ) );
	//modify the view scalability information sei message
	UInt uiNumAllViews = pcSPS->SpsMVC->getNumViewMinus1() + 1;
	UInt* ViewOp;
	ViewOp = new UInt [uiNumAllViews];
	UInt uiNumOp = pcSEIMessage->getNumOperationPointsMinus1();
	UInt i;
	for( i = 0; i <= uiNumOp; i++ )
	{
	  UInt uiNumViews = pcSEIMessage->getNumActiveViewsMinus1( i );
	  for( UInt j = 0; j <= uiNumViews; j++ )
	  {
		UInt uiViewId = pcSEIMessage->getViewId(i, j); 
		ViewOp[uiViewId] = i;
	  }
	}

	for( i = 0; i <= uiNumOp; i++ )
	{
	  UInt uiNumViews = pcSEIMessage->getNumActiveViewsMinus1( i );
	  for( UInt j = 0; j <= uiNumViews; j++ )
	  {
		UInt uiViewId = pcSEIMessage->getViewId(i, j); 

		UInt uiNumRef = pcSPS->SpsMVC->getNumRefsForListX( uiViewId, LIST_0, true ) 
						+ pcSPS->SpsMVC->getNumRefsForListX( uiViewId, LIST_1, true );
		UInt uiNumRef1 = pcSPS->SpsMVC->getNumRefsForListX( uiViewId, LIST_0, false ) 
						+ pcSPS->SpsMVC->getNumRefsForListX( uiViewId, LIST_1, false );
		if( uiNumRef1 > uiNumRef )
		  uiNumRef = uiNumRef1;

		if( uiNumRef == 0 )
			continue;

		if( !pcSEIMessage->getOpDependencyInfoPresentFlag(i) && !pcSEIMessage->getOpDependencyInfoSrcOpIdDelta(i))
		{
		  pcSEIMessage->setNumDirectlyDependentOps(i, uiNumRef );
		  pcSEIMessage->setOpDependencyInfoPresentFlag(i, true);
		}
	    else if( pcSEIMessage->getNumDirectlyDependentOps(i) < uiNumRef )
			pcSEIMessage->setNumDirectlyDependentOps(i, uiNumRef );

		for( UInt ui = 0; ui < uiNumRef; ui++ )
		{
		  UInt uiRef;
		  if( ui< pcSPS->SpsMVC->getNumRefsForListX( uiViewId, LIST_0, true ) )
		    uiRef = pcSPS->SpsMVC->getAnchorRefForListX( uiViewId, ui, LIST_0 ); 
		  else
		    uiRef = pcSPS->SpsMVC->getAnchorRefForListX( uiViewId, ui-pcSPS->SpsMVC->getNumRefsForListX(uiViewId,LIST_0,true), LIST_1 );
		  if( i > ViewOp[uiRef] )
		    pcSEIMessage->setDirectlyDependentOpIdDeltaMinus1( i, ui, i - ViewOp[uiRef] - 1 );
		}
	  }
	}

	ViewOp = NULL;
	pcSPS->destroy();
  }

  return Err::m_nOK;
}


ErrVal
H264AVCPacketAnalyzer::xCreate()
{
  RNOK( BitReadBuffer::create( m_pcBitReadBuffer ) );
  RNOK( UvlcReader   ::create( m_pcUvlcReader    ) );
  RNOK( NalUnitParser::create( m_pcNalUnitParser  ) );

  return Err::m_nOK;
}



ErrVal
H264AVCPacketAnalyzer::destroy()
{
  RNOK( m_pcBitReadBuffer ->destroy() );
  RNOK( m_pcUvlcReader    ->destroy() );
  RNOK( m_pcNalUnitParser ->destroy() );
  
  delete this;

  return Err::m_nOK;
}



ErrVal
H264AVCPacketAnalyzer::init()
{
  RNOK( m_pcBitReadBuffer ->init() );
  RNOK( m_pcUvlcReader    ->init( m_pcBitReadBuffer ) );
  RNOK( m_pcNalUnitParser ->init( m_pcBitReadBuffer ) );

  ::memset( m_auiDecompositionStages, 0x00, MAX_LAYERS*sizeof(UInt) );

  return Err::m_nOK;
}



ErrVal
H264AVCPacketAnalyzer::uninit()
{
  RNOK( m_pcBitReadBuffer ->uninit() );
  RNOK( m_pcUvlcReader    ->uninit() );

  return Err::m_nOK;
}


// JVT-Q054 Red. Picture {
Bool
CreaterH264AVCDecoder::isRedundantPic()
{
  return m_pcH264AVCDecoder->isRedundantPic();
}


ErrVal
CreaterH264AVCDecoder::checkRedundantPic()
{
  return m_pcH264AVCDecoder->checkRedundantPic();
}


// JVT-Q054 Red. Picture }

H264AVC_NAMESPACE_END