createrh264avcdecoder.cpp

JVT-Z203_jsvm.rar

ErrVal
H264AVCPacketAnalyzer::process( BinData*            pcBinData,
                                PacketDescription&  rcPacketDescription,
                                SEI::SEIMessage*&   pcScalableSEIMessage )
{
  ROF( pcBinData );

  //===== copy bin data and init NAL unit =====
  UChar*  pucBuffer = new UChar [ pcBinData->size() ];
  ROF( pucBuffer );
  ::memcpy( pucBuffer, pcBinData->data(), pcBinData->size() );
  BinData         cBinData( pucBuffer, pcBinData->size() );
  BinDataAccessor cBinDataAccessor;
  cBinData.setMemAccessor( cBinDataAccessor );
  RNOK( m_pcNalUnitParser->initNalUnit( cBinDataAccessor ) );


  pcScalableSEIMessage            = 0;
  NalRefIdc   eNalRefIdc          = m_pcNalUnitParser->getNalRefIdc           ();
  NalUnitType eNalUnitType        = m_pcNalUnitParser->getNalUnitType         ();
  UInt        uiLayer             = m_pcNalUnitParser->getDependencyId        ();
  UInt        uiLevel             = m_pcNalUnitParser->getTemporalId          ();
  UInt        uiFGSLayer          = m_pcNalUnitParser->getQualityId           ();
  UInt        uiSimplePriorityId  = m_pcNalUnitParser->getPriorityId          ();
  Bool        bDiscardableFlag    = m_pcNalUnitParser->getDiscardableFlag     ();
  Bool        bApplyToNext        = false;
  Bool        bParameterSet       = ( eNalUnitType == NAL_UNIT_SPS || eNalUnitType == NAL_UNIT_SUBSET_SPS || eNalUnitType == NAL_UNIT_PPS );
  Bool        bScalable           = ( eNalUnitType == NAL_UNIT_CODED_SLICE_SCALABLE );
  UInt        uiSPSid             = 0;
  UInt        uiPPSid             = 0;
  
  if( eNalUnitType == NAL_UNIT_CODED_SLICE || eNalUnitType == NAL_UNIT_CODED_SLICE_IDR )
  {
    uiLevel = ( eNalRefIdc > 0 ? 0 : 1 + m_uiStdAVCOffset );
  }
  
  rcPacketDescription.uiNumLevelsQL       = 0;
  rcPacketDescription.bDiscardableHRDSEI  = false;
  for( UInt ui = 0; ui < MAX_NUM_RD_LEVELS; ui++ )
  {
    rcPacketDescription.auiPriorityLevelPR[ui] = 0;
  }

  if( eNalUnitType == NAL_UNIT_SEI )
  {
    SEI::MessageList cMessageList;
    ParameterSetMng* pcParameterSetMng = NULL;
    RNOK( SEI::read( m_pcUvlcReader, cMessageList, pcParameterSetMng ) );

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

      switch( pcSEIMessage->getMessageType() )
      {
      case SEI::SUB_SEQ_INFO:
        {
          SEI::SubSeqInfo* pcSubSeqInfo = (SEI::SubSeqInfo*) pcSEIMessage;
          uiLevel       = pcSubSeqInfo->getSubSeqLayerNum();
          uiLayer       = 0;
          bApplyToNext  = true;
          delete pcSEIMessage;
          break;
        }
      case SEI::SCALABLE_SEI:
        {
          uiLevel = 0;
          uiLayer = 0;
          pcScalableSEIMessage = pcSEIMessage;
          {
            //====set parameters used for further parsing =====
            SEI::ScalableSei* pcSEI    = (SEI::ScalableSei*)pcSEIMessage;
            UInt uiNumScalableLayers  = pcSEI->getNumLayersMinus1() + 1;
            for(UInt uiIndex = 0; uiIndex < uiNumScalableLayers; uiIndex++ )
            {
              if( pcSEI->getDependencyId( uiIndex ) == 0 )
              {
                m_uiStdAVCOffset = pcSEI->getTemporalId( uiIndex );
                pcSEI->setStdAVCOffset( m_uiStdAVCOffset-1 );
              }
              else
              {
                break;
              }
            }
          }

          SEI::ScalableSei* pcSEI    = (SEI::ScalableSei*)pcSEIMessage;
          m_uiNum_layers = pcSEI->getNumLayersMinus1() + 1;
          for(UInt i=0; i < m_uiNum_layers; i++)
          {
            m_ID_ROI[i] = pcSEI->getRoiId(i);
            m_ID_Dependency[i] = pcSEI->getDependencyId(i);
          }
          break;
        }

      case SEI::MOTION_SEI:
        {
          SEI::MotionSEI* pcSEI               = (SEI::MotionSEI*)pcSEIMessage;
          m_silceIDOfSubPicLayer[m_layer_id]  = pcSEI->m_slice_group_id[0];
          break;
        }

      case SEI::SCALABLE_SEI_LAYERS_NOT_PRESENT:
      case SEI::SCALABLE_SEI_DEPENDENCY_CHANGE:
        {
          pcScalableSEIMessage = pcSEIMessage;
          break;
        }

      case SEI::SUB_PIC_SEI:
        {
          SEI::SubPicSei* pcSEI    = (SEI::SubPicSei*)pcSEIMessage;
          m_layer_id          = pcSEI->getDependencyId();
          bApplyToNext  = true;
          break;
        }

      case SEI::PRIORITYLEVEL_SEI:
        {
          UInt uiNum = 0;
          UInt uiPriorityLevel = 0;
          SEI::PriorityLevelSEI* pcSEI           = (SEI::PriorityLevelSEI*)pcSEIMessage;
          uiNum = pcSEI->getNumPriorityIds();
          rcPacketDescription.uiNumLevelsQL = uiNum;
          for(UInt ui = 0; ui < uiNum; ui++)
          {
            uiPriorityLevel = pcSEI->getAltPriorityId(ui);
            rcPacketDescription.auiPriorityLevelPR[ui] = uiPriorityLevel;
          }
          uiLayer = pcSEI->getPrDependencyId();
          bApplyToNext = true;
          break;
        }

      case SEI::NON_REQUIRED_SEI:
        {
          m_pcNonRequiredSEI = (SEI::NonRequiredSei*) pcSEIMessage;
          m_uiNonRequiredSeiFlag = 1;
          break;
        }

      case SEI::SCALABLE_NESTING_SEI:
        {
          Bool bAllPicturesInAuFlag;
          UInt uiNumPictures;
          UInt *puiDependencyId, *puiQualityLevel;
          UInt uiTemporalId;
          SEI::ScalableNestingSei* pcSEI = (SEI::ScalableNestingSei*)pcSEIMessage;
          bAllPicturesInAuFlag = pcSEI->getAllPicturesInAuFlag();
          if( bAllPicturesInAuFlag == 0 )
          {
            uiNumPictures = pcSEI->getNumPictures();
            ROT( uiNumPictures == 0 );
            puiDependencyId = new UInt[uiNumPictures];
            puiQualityLevel = new UInt[uiNumPictures];
            for( UInt uiIndex = 0; uiIndex < uiNumPictures; uiIndex++ )
            {
              puiDependencyId[uiIndex] = pcSEI->getDependencyId(uiIndex);
              puiQualityLevel[uiIndex] = pcSEI->getQualityId(uiIndex);
            }
            uiTemporalId = pcSEI->getTemporalId();
            delete puiDependencyId;
            delete puiQualityLevel;
          }
          bApplyToNext = true;
          rcPacketDescription.bDiscardableHRDSEI = true;
          break;
        }

      case SEI::BUFFERING_PERIOD:
        {
          rcPacketDescription.bDiscardableHRDSEI = true;
          rcPacketDescription.bDiscardable = true;
          break;
        }

      case SEI::PIC_TIMING:
        {
          rcPacketDescription.bDiscardableHRDSEI = true;
          rcPacketDescription.bDiscardable = true;
          break;
        }

      case SEI::INTEGRITY_CHECK_SEI:
        {
          break;
        }

      case SEI::REDUNDANT_PIC_SEI:
        {
          SEI::RedundantPicSei* pcSEI = (SEI::RedundantPicSei*) pcSEIMessage;
          UInt uiNumDIdMinus1;
          UInt uiNumDId;
          UInt *puiNumQIdMinus1, *puiDependencyId;
          UInt **ppuiQualityId, **ppuiNumRedundantPicsMinus1;
          UInt ***pppuiRedundantPicCntMinus1;

          uiNumDIdMinus1 = pcSEI->getNumDIdMinus1( );
          uiNumDId = uiNumDIdMinus1 + 1;
          puiNumQIdMinus1                = new UInt[uiNumDId];
          puiDependencyId                = new UInt[uiNumDId]; 
          ppuiQualityId                  = new UInt*[uiNumDId];
          ppuiNumRedundantPicsMinus1     = new UInt*[uiNumDId];
          pppuiRedundantPicCntMinus1     = new UInt**[uiNumDId];
          for(UInt ui = 0; ui <= uiNumDIdMinus1; ui++)
          {
            puiDependencyId[ui] = pcSEI->getDependencyId ( ui );
            puiNumQIdMinus1[ui] = pcSEI->getNumQIdMinus1 ( ui );
            ppuiQualityId[ui]                = new UInt[puiNumQIdMinus1[ui]+1];
            ppuiNumRedundantPicsMinus1[ui]   = new UInt[puiNumQIdMinus1[ui]+1];
            pppuiRedundantPicCntMinus1[ui]    = new UInt*[puiNumQIdMinus1[ui]+1];
            for(UInt uj = 0; uj <= puiNumQIdMinus1[ui]; uj++)
            {
              ppuiQualityId[ui][uj]  = pcSEI->getQualityId ( ui, uj );
              ppuiNumRedundantPicsMinus1[ui][uj]  = pcSEI->getNumRedundantPicsMinus1 ( ui, uj );
              pppuiRedundantPicCntMinus1[ui][uj] = new UInt[ppuiNumRedundantPicsMinus1[ui][uj] +1];
              for(UInt uk = 0; uk <= ppuiNumRedundantPicsMinus1[ui][uj]; uk++)
              {
                pppuiRedundantPicCntMinus1[ui][uj][uk] = pcSEI->getRedundantPicCntMinus1 ( ui, uj, uk );
              }
            }                                                           			                                               		                                
          }

          delete puiNumQIdMinus1;
          delete puiDependencyId;
          delete ppuiQualityId;
          delete ppuiNumRedundantPicsMinus1;
          delete pppuiRedundantPicCntMinus1;

          break;
        }

      case SEI::TL_SWITCHING_POINT_SEI:
        {
          break;
        }

      case SEI::TL0_DEP_REP_IDX_SEI:
        {
          break;
        }

      default:
        {
          delete pcSEIMessage;
        }
      }
    }
  }
  else if( eNalUnitType == NAL_UNIT_SPS || eNalUnitType == NAL_UNIT_SUBSET_SPS )
  {
    SequenceParameterSet* pcSPS = NULL;
    RNOK( SequenceParameterSet::create  ( pcSPS   ) );
    RNOK( pcSPS->read( m_pcUvlcReader, eNalUnitType ) );
    uiSPSid = pcSPS->getSeqParameterSetId();
    pcSPS->destroy();
  }
  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();

    m_uiNumSliceGroupsMinus1 = pcPPS->getNumSliceGroupsMinus1();
    for(UInt i=0; i<= m_uiNumSliceGroupsMinus1; i++)
    {
      uiaAddrFirstMBofROIs[uiPPSid ][i] = pcPPS->getTopLeft (i);
    }

    pcPPS->destroy();
    rcPacketDescription.SPSidRefByPPS[uiPPSid] = uiSPSid;
  }
  else if( eNalUnitType == NAL_UNIT_CODED_SLICE           ||
           eNalUnitType == NAL_UNIT_CODED_SLICE_IDR       ||
           eNalUnitType == NAL_UNIT_CODED_SLICE_SCALABLE    )
  {
    if( ! ( uiLayer == 0 && uiFGSLayer == 0 && eNalUnitType == NAL_UNIT_CODED_SLICE_SCALABLE ) )
    {
      UInt uiTemp;
      RNOK( m_pcUvlcReader->getUvlc( uiTemp,  "SH: first_mb_in_slice" ) );
      rcPacketDescription.uiFirstMb = uiTemp;

      RNOK( m_pcUvlcReader->getUvlc( uiTemp,  "SH: slice_type" ) );
      RNOK( m_pcUvlcReader->getUvlc( uiPPSid, "SH: pic_parameter_set_id" ) );
      uiSPSid = rcPacketDescription.SPSidRefByPPS[uiPPSid];

      m_uiCurrPicLayer = (uiLayer << 4) + uiFGSLayer;
      if((m_uiCurrPicLayer < m_uiPrevPicLayer || (m_uiCurrPicLayer == m_uiPrevPicLayer && m_uiCurrPicLayer == 0))&& m_uiNonRequiredSeiFlag != 1) //prefix unit
      {
        m_pcNonRequiredSEI->destroy();
        m_pcNonRequiredSEI = NULL;
      }
      m_uiNonRequiredSeiFlag = 0;
      m_uiPrevPicLayer = m_uiCurrPicLayer;
    }
  }
  
  m_pcNalUnitParser->closeNalUnit( false );

  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;
  return Err::m_nOK;
}


H264AVC_NAMESPACE_END