h264avcdecoder.cpp

JVT-Z203_jsvm.rar

        RNOK( pcPPS->read( m_pcHeaderSymbolReadIf, m_pcNalUnitParser->getNalUnitType() ) );
        RNOK( m_pcParameterSetMngAUInit->store ( pcPPS ) );
        bCompletelyParsed = true;
        break;
      }
    case NAL_UNIT_PREFIX:
      {
        pcPrefixHeader = new PrefixHeader( *m_pcNalUnitParser );
        ROF ( pcPrefixHeader );
        RNOK( pcPrefixHeader->read( *m_pcHeaderSymbolReadIf ) );
        bCompletelyParsed = true;
        break;
      }
    case NAL_UNIT_CODED_SLICE:
    case NAL_UNIT_CODED_SLICE_IDR:
      {
        if( rcAccessUnit.getLastPrefixHeader() )
        {
          pcSliceHeader = new SliceHeader( *rcAccessUnit.getLastPrefixHeader() );
          ROF( pcSliceHeader );
          pcSliceHeader->NalUnitHeader::copy( *m_pcNalUnitParser, false );
        }
        else
        {
          pcSliceHeader = new SliceHeader( *m_pcNalUnitParser );
          ROF( pcSliceHeader );
        }
        RNOK ( pcSliceHeader->read( *m_pcParameterSetMngAUInit, *m_pcHeaderSymbolReadIf ) );
        break;
      }
    case NAL_UNIT_CODED_SLICE_SCALABLE:
      {
        pcSliceHeader = new SliceHeader( *m_pcNalUnitParser );
        ROF ( pcSliceHeader );
        RNOK( pcSliceHeader->read( *m_pcParameterSetMngAUInit, *m_pcHeaderSymbolReadIf ) );
        break;
      }
    default:
      {
        // no parsing required
        break;
      }
    }
    RNOK( m_pcNalUnitParser->closeNalUnit( bCompletelyParsed ) );
    DTRACE_ON;
  }

  //===== update access unit list =====
  switch( m_pcNalUnitParser->getNalUnitType() )
  {
  case NAL_UNIT_PREFIX:
    {
      RNOK( rcAccessUnit.update( pcBinDataCopy, *pcPrefixHeader ) );
      break;
    }
  case NAL_UNIT_CODED_SLICE:
  case NAL_UNIT_CODED_SLICE_IDR:
  case NAL_UNIT_CODED_SLICE_SCALABLE:
    {
      RNOK( rcAccessUnit.update( pcBinDataCopy, *pcSliceHeader ) );
      break;
    }
  case NAL_UNIT_CODED_SLICE_DATAPART_A:
  case NAL_UNIT_CODED_SLICE_DATAPART_B:
  case NAL_UNIT_CODED_SLICE_DATAPART_C:
    {
      RERR(); // not supported
      break;
    }
  default:
    {
      RNOK( rcAccessUnit.update( pcBinDataCopy ) );
      break;
    }
  }
  return Err::m_nOK;
}


ErrVal
H264AVCDecoder::processNALUnit( PicBuffer*        pcPicBuffer,
                                PicBufferList&    rcPicBufferOutputList,
                                PicBufferList&    rcPicBufferUnusedList,
                                BinDataList&      rcBinDataList,
                                NALUnit&          rcNALUnit )
{
  if( ! rcNALUnit.isVCLNALUnit() )
  {
    NonVCLNALUnit& rcNonVCLNALUnit = *(NonVCLNALUnit*)rcNALUnit.getInstance();
    RNOK( xProcessNonVCLNALUnit( rcNonVCLNALUnit ) );
    rcPicBufferUnusedList.push_back( pcPicBuffer );
    return Err::m_nOK;
  }

  PicBufferList     cDummyList;
  SliceDataNALUnit& rcSliceDataNALUnit  = *(SliceDataNALUnit*)rcNALUnit.getInstance();
  PicBufferList&    rcOutputList        = ( rcSliceDataNALUnit.isDependencyIdMax() ? rcPicBufferOutputList : cDummyList );
  RNOK  ( m_apcLayerDecoder[ rcSliceDataNALUnit.getDependencyId() ]->processSliceData( pcPicBuffer, rcOutputList, rcPicBufferUnusedList, rcBinDataList, rcSliceDataNALUnit ) );
  ROFRS ( rcSliceDataNALUnit.isLastAccessUnitInStream() && rcSliceDataNALUnit.isLastSliceInAccessUnit(), Err::m_nOK );

  for( UInt uiDependencyId = 0; uiDependencyId < rcSliceDataNALUnit.getDependencyId(); uiDependencyId++ )
  {
    RNOK( m_apcLayerDecoder[ uiDependencyId                       ]->finishProcess( cDummyList,            rcPicBufferUnusedList ) );
  }
  RNOK(   m_apcLayerDecoder[ rcSliceDataNALUnit.getDependencyId() ]->finishProcess( rcPicBufferOutputList, rcPicBufferUnusedList ) );

  return Err::m_nOK;
}


ErrVal
H264AVCDecoder::xProcessNonVCLNALUnit( NonVCLNALUnit& rcNonVCLNALUnit )
{
  //===== parse prefix header when available =====
  PrefixHeader* pcPrefixHeader = 0;
  if( rcNonVCLNALUnit.getBinDataPrefix() )
  {
    BinDataAccessor cBinDataAccessorPrefix;
    rcNonVCLNALUnit.getBinDataPrefix()->setMemAccessor( cBinDataAccessorPrefix );
    RNOK( m_pcNalUnitParser ->initNalUnit   ( cBinDataAccessorPrefix )  );
    ROF ( m_pcNalUnitParser ->getNalUnitType() == NAL_UNIT_PREFIX );
    pcPrefixHeader = new PrefixHeader( *m_pcNalUnitParser );
    ROF ( pcPrefixHeader );
    RNOK( pcPrefixHeader    ->read          ( *m_pcHeaderSymbolReadIf ) );
    RNOK( m_pcNalUnitParser ->closeNalUnit  () );
  }

  //===== parse NAL unit =====
  BinDataAccessor cBinDataAccessor;
  rcNonVCLNALUnit.getBinData()->setMemAccessor( cBinDataAccessor );
  RNOK  ( m_pcNalUnitParser   ->initNalUnit   ( cBinDataAccessor )  );
  switch( m_pcNalUnitParser   ->getNalUnitType() )
  {
  case NAL_UNIT_SPS:
    {
      SequenceParameterSet* pcSPS = NULL;
      RNOK( SequenceParameterSet::create( pcSPS ) );
      RNOK( pcSPS->read( m_pcHeaderSymbolReadIf, m_pcNalUnitParser->getNalUnitType() ) );
      RNOK( m_pcParameterSetMngDecode->store( pcSPS ) );
      printf("  NON-VCL: SEQUENCE PARAMETER SET (ID=%d)\n", pcSPS->getSeqParameterSetId() );
      break;
    }
  case NAL_UNIT_SUBSET_SPS:
    {
      SequenceParameterSet* pcSPS = NULL;
      RNOK( SequenceParameterSet::create( pcSPS ) );
      RNOK( pcSPS->read( m_pcHeaderSymbolReadIf, m_pcNalUnitParser->getNalUnitType() ) );
      RNOK( m_pcParameterSetMngDecode->store( pcSPS ) );
      printf("  NON-VCL: SUBSET SEQUENCE PARAMETER SET (ID=%d)\n", pcSPS->getSeqParameterSetId() );
      break;
    }
  case NAL_UNIT_PPS:
    {
      PictureParameterSet* pcPPS = NULL;
      RNOK( PictureParameterSet::create( pcPPS ) );
      RNOK( pcPPS->read( m_pcHeaderSymbolReadIf, m_pcNalUnitParser->getNalUnitType() ) );
      RNOK( m_pcParameterSetMngDecode->store ( pcPPS ) );
      printf("  NON-VCL: PICTURE PARAMETER SET (ID=%d)\n", pcPPS->getPicParameterSetId() );
      break;
    }
  case NAL_UNIT_SEI: // just read, but ignore
    {
      SEI::MessageList cSEIMessageList;
      RNOK( SEI::read( m_pcHeaderSymbolReadIf, cSEIMessageList, m_pcParameterSetMngDecode ) );
      printf("  NON-VCL: SEI NAL UNIT\n" );
      break;
    }
  case NAL_UNIT_ACCESS_UNIT_DELIMITER: // just read, but ignore
    {
      AUDelimiter cAUDelimiter( *m_pcNalUnitParser );
      RNOK( cAUDelimiter.read ( *m_pcHeaderSymbolReadIf ) );
      printf("  NON-VCL: ACCESS UNIT DELIMITER\n" );
      break;
    }
  case NAL_UNIT_END_OF_SEQUENCE: // just read, but ignore
    {
      EndOfSequence cEndOfSequence( *m_pcNalUnitParser );
      RNOK( cEndOfSequence.read   ( *m_pcHeaderSymbolReadIf ) );
      printf("  NON-VCL: END OF SEQUENCE\n" );
      break;
    }
  case NAL_UNIT_END_OF_STREAM: // just read, but ignore
    {
      EndOfStream cEndOfStream( *m_pcNalUnitParser );
      RNOK( cEndOfStream.read ( *m_pcHeaderSymbolReadIf ) );
      printf("  NON-VCL: END OF STREAM\n" );
      break;
    }
  case NAL_UNIT_FILLER_DATA: // just read, but ignore
    {
      const NalUnitHeader&  rcNalUnitHeader = ( pcPrefixHeader ? *pcPrefixHeader : *m_pcNalUnitParser );
      FillerData            cFillerData( rcNalUnitHeader );
      RNOK( cFillerData.read( *m_pcHeaderSymbolReadIf ) );
      cFillerData.NalUnitHeader::copy( *m_pcNalUnitParser, false );
      printf("  NON-VCL: FILLER DATA (D=%d,Q=%d)\n", cFillerData.getDependencyId(), cFillerData.getQualityId() );
      break;
    }
  default:
    {
      // ignore
      break;
    }
  }
  RNOK( m_pcNalUnitParser->closeNalUnit() );
  return Err::m_nOK;
}

ErrVal
H264AVCDecoder::getBaseLayerData( SliceHeader&      rcELSH,
                                  Frame*&           pcFrame,
                                  Frame*&           pcResidual,
                                  MbDataCtrl*&      pcMbDataCtrl,
                                  ResizeParameters& rcResizeParameters,
                                  UInt              uiBaseLayerId )
{
  RNOK( m_apcLayerDecoder[uiBaseLayerId]->getBaseLayerData( rcELSH, pcFrame, pcResidual, pcMbDataCtrl, rcResizeParameters ) );
  return Err::m_nOK;
}

ErrVal
H264AVCDecoder::getBaseSliceHeader( SliceHeader*& rpcSliceHeader, UInt uiRefLayerDependencyId )
{
  RNOK( m_apcLayerDecoder[ uiRefLayerDependencyId ]->getBaseSliceHeader( rpcSliceHeader ) );
  return Err::m_nOK;
}


H264AVC_NAMESPACE_END