createrh264avcdecoder.cpp

JVT-Z203_jsvm.rar

, m_pcCabacReader           ( 0 )
, m_pcSampleWeighting       ( 0 )
#ifdef SHARP_AVC_REWRITE_OUTPUT
, m_pcRewriteEncoder        ( 0 )
#endif
{
  ::memset( m_apcDecodedPicBuffer,     0x00, MAX_LAYERS * sizeof( Void* ) );
  ::memset( m_apcLayerDecoder,         0x00, MAX_LAYERS * sizeof( Void* ) );
  ::memset( m_apcPocCalculator,        0x00, MAX_LAYERS * sizeof( Void* ) );
  ::memset( m_apcYuvFullPelBufferCtrl, 0x00, MAX_LAYERS * sizeof( Void* ) );
}

CreaterH264AVCDecoder::~CreaterH264AVCDecoder()
{
}

ErrVal
CreaterH264AVCDecoder::create( CreaterH264AVCDecoder*& rpcCreaterH264AVCDecoder )
{
  rpcCreaterH264AVCDecoder = new CreaterH264AVCDecoder;
  ROT( NULL == rpcCreaterH264AVCDecoder );
  RNOK( rpcCreaterH264AVCDecoder->xCreateDecoder() )
  return Err::m_nOK;
}

ErrVal
CreaterH264AVCDecoder::xCreateDecoder()
{
  RNOK( ParameterSetMng         ::create( m_pcParameterSetMngAUInit ) );
  RNOK( ParameterSetMng         ::create( m_pcParameterSetMngDecode ) );
  RNOK( BitReadBuffer           ::create( m_pcBitReadBuffer ) );
  RNOK( NalUnitParser           ::create( m_pcNalUnitParser) );
  RNOK( SliceReader             ::create( m_pcSliceReader ) );
  RNOK( SliceDecoder            ::create( m_pcSliceDecoder ) );
  RNOK( UvlcReader              ::create( m_pcUvlcReader ) );
  RNOK( CabacReader             ::create( m_pcCabacReader ) );
  RNOK( MbParser                ::create( m_pcMbParser ) );
  RNOK( MbDecoder               ::create( m_pcMbDecoder ) );
  RNOK( LoopFilter              ::create( m_pcLoopFilter ) );
  RNOK( IntraPrediction         ::create( m_pcIntraPrediction ) );
  RNOK( MotionCompensation      ::create( m_pcMotionCompensation ) );
  RNOK( H264AVCDecoder          ::create( m_pcH264AVCDecoder ) );
  RNOK( ControlMngH264AVCDecoder::create( m_pcControlMng ) );
  RNOK( ReconstructionBypass    ::create( m_pcReconstructionBypass ) );
  RNOK( SampleWeighting         ::create( m_pcSampleWeighting ) );
  RNOK( QuarterPelFilter        ::create( m_pcQuarterPelFilter ) );
  RNOK( Transform               ::create( m_pcTransform ) );
#ifdef SHARP_AVC_REWRITE_OUTPUT
  RNOK( RewriteEncoder          ::create( m_pcRewriteEncoder ) );
#endif

  for( UInt uiLayer = 0; uiLayer < MAX_LAYERS; uiLayer++ )
  {
    RNOK( DecodedPicBuffer      ::create( m_apcDecodedPicBuffer     [uiLayer] ) );
    RNOK( LayerDecoder          ::create( m_apcLayerDecoder         [uiLayer] ) );
    RNOK( PocCalculator         ::create( m_apcPocCalculator        [uiLayer] ) );
    RNOK( YuvBufferCtrl         ::create( m_apcYuvFullPelBufferCtrl [uiLayer] ) );
  }

  return Err::m_nOK;
}


ErrVal
CreaterH264AVCDecoder::destroy()
{
  RNOK( m_pcSliceDecoder          ->destroy() );
  RNOK( m_pcSliceReader           ->destroy() );
  RNOK( m_pcBitReadBuffer         ->destroy() );
  RNOK( m_pcUvlcReader            ->destroy() );
  RNOK( m_pcMbParser              ->destroy() );
  RNOK( m_pcLoopFilter            ->destroy() );
  RNOK( m_pcMbDecoder             ->destroy() );
  RNOK( m_pcTransform             ->destroy() );
  RNOK( m_pcIntraPrediction       ->destroy() );
  RNOK( m_pcMotionCompensation    ->destroy() );
  RNOK( m_pcQuarterPelFilter      ->destroy() );
  RNOK( m_pcCabacReader           ->destroy() );
  RNOK( m_pcNalUnitParser         ->destroy() );
  RNOK( m_pcParameterSetMngAUInit ->destroy() );
  RNOK( m_pcParameterSetMngDecode ->destroy() );
  RNOK( m_pcSampleWeighting       ->destroy() );
  RNOK( m_pcH264AVCDecoder        ->destroy() );
  RNOK( m_pcControlMng            ->destroy() );
  RNOK( m_pcReconstructionBypass  ->destroy() );
#ifdef SHARP_AVC_REWRITE_OUTPUT
  RNOK( m_pcRewriteEncoder        ->destroy() );
#endif

  for( UInt uiLayer = 0; uiLayer < MAX_LAYERS; uiLayer++ )
  {
    RNOK( m_apcDecodedPicBuffer    [uiLayer]->destroy() );
    RNOK( m_apcLayerDecoder        [uiLayer]->destroy() );
    RNOK( m_apcPocCalculator       [uiLayer]->destroy() );
    RNOK( m_apcYuvFullPelBufferCtrl[uiLayer]->destroy() );
  }
  delete this;
  return Err::m_nOK;
}

ErrVal
CreaterH264AVCDecoder::init( Bool bOpenTrace )
{
  if( bOpenTrace )
  {
    INIT_DTRACE;
    OPEN_DTRACE;
  }

  RNOK( m_pcBitReadBuffer         ->init() );
  RNOK( m_pcNalUnitParser         ->init( m_pcBitReadBuffer, m_pcUvlcReader ) );
  RNOK( m_pcUvlcReader            ->init( m_pcBitReadBuffer ) );
  RNOK( m_pcCabacReader           ->init( m_pcBitReadBuffer ) );
  RNOK( m_pcQuarterPelFilter      ->init() );
  RNOK( m_pcParameterSetMngAUInit ->init() );
  RNOK( m_pcParameterSetMngDecode ->init() );
  RNOK( m_pcSampleWeighting       ->init() );
  RNOK( m_pcSliceDecoder          ->init( m_pcMbDecoder, m_pcControlMng ) );
  RNOK( m_pcSliceReader           ->init( m_pcMbParser ) );
  RNOK( m_pcMbParser              ->init() );
  RNOK( m_pcLoopFilter            ->init( m_pcControlMng, m_pcReconstructionBypass, false ) );
  RNOK( m_pcIntraPrediction       ->init() );
  RNOK( m_pcMotionCompensation    ->init( m_pcQuarterPelFilter, m_pcTransform, m_pcSampleWeighting ) );
  RNOK( m_pcMbDecoder             ->init( m_pcTransform, m_pcIntraPrediction, m_pcMotionCompensation ) );
  RNOK( m_pcH264AVCDecoder        ->init( m_pcNalUnitParser,
                                          m_pcUvlcReader,
                                          m_pcParameterSetMngAUInit,
                                          m_pcParameterSetMngDecode,
                                          m_apcLayerDecoder ) );
  RNOK( m_pcReconstructionBypass  ->init() );
#ifdef SHARP_AVC_REWRITE_OUTPUT
  RNOK( m_pcRewriteEncoder        ->init() );
#endif

  for( UInt uiLayer = 0; uiLayer < MAX_LAYERS; uiLayer++ )
  {
    RNOK( m_apcDecodedPicBuffer[uiLayer]->init ( m_apcYuvFullPelBufferCtrl [uiLayer],
                                                 uiLayer ) );
#ifdef SHARP_AVC_REWRITE_OUTPUT
    RNOK( m_apcLayerDecoder    [uiLayer]->init ( uiLayer,
                                                 m_pcH264AVCDecoder,
                                                 m_pcNalUnitParser,
                                                 m_pcSliceReader,
                                                 m_pcSliceDecoder,
                                                 m_pcControlMng,
                                                 m_pcLoopFilter,
                                                 m_pcUvlcReader,
                                                 m_pcParameterSetMngDecode,
                                                 m_apcPocCalculator        [uiLayer],
                                                 m_apcYuvFullPelBufferCtrl [uiLayer],
                                                 m_apcDecodedPicBuffer     [uiLayer],
                                                 m_pcMotionCompensation,
												                         m_pcReconstructionBypass,
                                                 m_pcRewriteEncoder ) );
#else
    RNOK( m_apcLayerDecoder    [uiLayer]->init ( uiLayer,
                                                 m_pcH264AVCDecoder,
                                                 m_pcNalUnitParser,
                                                 m_pcSliceReader,
                                                 m_pcSliceDecoder,
                                                 m_pcControlMng,
                                                 m_pcLoopFilter,
                                                 m_pcUvlcReader,
                                                 m_pcParameterSetMngDecode,
                                                 m_apcPocCalculator        [uiLayer],
                                                 m_apcYuvFullPelBufferCtrl [uiLayer],
                                                 m_apcDecodedPicBuffer     [uiLayer],
                                                 m_pcMotionCompensation,
												                         m_pcReconstructionBypass ) );
#endif
  }

  RNOK( m_pcControlMng            ->init( m_pcUvlcReader, 
                                          m_pcMbParser, 
                                          m_pcMotionCompensation, 
                                          m_apcYuvFullPelBufferCtrl, 
                                          m_pcCabacReader, 
                                          m_pcSampleWeighting, 
                                          m_apcLayerDecoder ) );

  return Err::m_nOK;
}

ErrVal
CreaterH264AVCDecoder::uninit( Bool bCloseTrace )
{
  RNOK( m_pcSampleWeighting       ->uninit() );
  RNOK( m_pcQuarterPelFilter      ->uninit() );
  RNOK( m_pcParameterSetMngAUInit ->uninit() );
  RNOK( m_pcParameterSetMngDecode ->uninit() );
  RNOK( m_pcSliceDecoder          ->uninit() );
  RNOK( m_pcSliceReader           ->uninit() );
  RNOK( m_pcNalUnitParser         ->uninit() );
  RNOK( m_pcBitReadBuffer         ->uninit() );
  RNOK( m_pcUvlcReader            ->uninit() );
  RNOK( m_pcMbParser              ->uninit() );
  RNOK( m_pcLoopFilter            ->uninit() );
  RNOK( m_pcMbDecoder             ->uninit() );
  RNOK( m_pcIntraPrediction       ->uninit() );
  RNOK( m_pcMotionCompensation    ->uninit() );
  RNOK( m_pcCabacReader           ->uninit() );
  RNOK( m_pcH264AVCDecoder        ->uninit() );
  RNOK( m_pcControlMng            ->uninit() );
  RNOK( m_pcReconstructionBypass  ->uninit() );
#ifdef SHARP_AVC_REWRITE_OUTPUT
  RNOK( m_pcRewriteEncoder        ->uninit() );
#endif

  for( UInt uiLayer = 0; uiLayer < MAX_LAYERS; uiLayer++ )
  {
    RNOK( m_apcDecodedPicBuffer    [uiLayer] ->uninit() );
    RNOK( m_apcLayerDecoder        [uiLayer] ->uninit() );
    RNOK( m_apcYuvFullPelBufferCtrl[uiLayer] ->uninit() );
  }

  if( bCloseTrace )
  {
    CLOSE_DTRACE;
  }

  return Err::m_nOK;
}

ErrVal
CreaterH264AVCDecoder::initNALUnit( BinData*& rpcBinData, AccessUnit& rcAccessUnit )
{
  RNOK( m_pcH264AVCDecoder->initNALUnit( rpcBinData, rcAccessUnit ) );
  return Err::m_nOK;
}

ErrVal
CreaterH264AVCDecoder::processNALUnit( PicBuffer*         pcPicBuffer,
                                       PicBufferList&     rcPicBufferOutputList,
                                       PicBufferList&     rcPicBufferUnusedList,
                                       BinDataList&       rcBinDataList,
                                       NALUnit&           rcNALUnit )
{
  RNOK( m_pcH264AVCDecoder->processNALUnit( pcPicBuffer, rcPicBufferOutputList, rcPicBufferUnusedList, rcBinDataList, rcNALUnit ) );
  return Err::m_nOK;
}








H264AVCPacketAnalyzer::H264AVCPacketAnalyzer()
: m_pcBitReadBuffer       ( 0 )
, m_pcUvlcReader          ( 0 )
, m_pcNalUnitParser       ( 0 )
, m_uiStdAVCOffset        ( 0 )
, m_pcNonRequiredSEI      ( 0 )
, m_uiNonRequiredSeiFlag  ( 0 )
, m_uiPrevPicLayer        ( 0 )
, m_uiCurrPicLayer        ( 0 )
{
  for( Int iLayer = 0; iLayer < MAX_SCALABLE_LAYERS; iLayer++ )
  {
    m_silceIDOfSubPicLayer[iLayer] = -1;
  }
}


H264AVCPacketAnalyzer::~H264AVCPacketAnalyzer()
{
}


ErrVal
H264AVCPacketAnalyzer::create( H264AVCPacketAnalyzer*& rpcH264AVCPacketAnalyzer )
{
  rpcH264AVCPacketAnalyzer = new H264AVCPacketAnalyzer;
  ROT ( NULL == rpcH264AVCPacketAnalyzer );
  RNOK( rpcH264AVCPacketAnalyzer->xCreate() );
  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, m_pcUvlcReader ) );
  m_uiPrevPicLayer = 0;
  return Err::m_nOK;
}


ErrVal
H264AVCPacketAnalyzer::uninit()
{
  RNOK( m_pcBitReadBuffer ->uninit() );
  RNOK( m_pcUvlcReader    ->uninit() );
  RNOK( m_pcNalUnitParser ->uninit() );
  return Err::m_nOK;
}