controlmngh264avcdecoder.cpp

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

  uiMbY = uiMbIndex         / m_auiMbXinFrame[m_uiCurrLayer];
  uiMbX = uiMbIndex - uiMbY * m_auiMbXinFrame[m_uiCurrLayer];

  RNOK( m_apcYuvFullPelBufferCtrl[m_uiCurrLayer]->initMb( uiMbY, uiMbX ) );
  RNOK( m_pcMotionCompensation                  ->initMb( uiMbY, uiMbX ) ) ;

  return Err::m_nOK;
}


ErrVal ControlMngH264AVCDecoder::initMbForFiltering( MbDataAccess*& rpcMbDataAccess, UInt uiMbIndex )
{
  ROF( m_uiCurrLayer < MAX_LAYERS );
  
  UInt uiMbY, uiMbX;

  uiMbY = uiMbIndex         / m_auiMbXinFrame[m_uiCurrLayer];
  uiMbX = uiMbIndex - uiMbY * m_auiMbXinFrame[m_uiCurrLayer];

  RNOK( m_pcMbDataCtrl                          ->initMb( rpcMbDataAccess, uiMbY, uiMbX           ) );
  RNOK( m_apcYuvFullPelBufferCtrl[m_uiCurrLayer]->initMb(                  uiMbY, uiMbX ) );

  return Err::m_nOK;
}



ErrVal ControlMngH264AVCDecoder::initMbForFiltering( UInt uiMbIndex )
{
  ROF( m_uiCurrLayer < MAX_LAYERS );
  
  UInt uiMbY, uiMbX;

  uiMbY = uiMbIndex         / m_auiMbXinFrame[m_uiCurrLayer];
  uiMbX = uiMbIndex - uiMbY * m_auiMbXinFrame[m_uiCurrLayer];

  RNOK( m_apcYuvFullPelBufferCtrl[m_uiCurrLayer]->initMb( uiMbY, uiMbX ) );

  return Err::m_nOK;
}


ErrVal ControlMngH264AVCDecoder::initSlice0( SliceHeader *rcSH )
{
  UInt  uiLayer             = rcSH->getLayerId                    ();
  /*
//JVT-T054{
  if(rcSH->getBaseLayerId() != MSYS_UINT_MAX && rcSH->getQualityLevel() != 0)
  {
    if( !m_apcMCTFDecoder[uiLayer]->isActive())
    {
      m_apcMCTFDecoder[uiLayer]->initSlice0( rcSH );
    }
    //if(!m_apcMCTFDecoder[uiLayer]->getResizeParameters())
      RNOK( xInitESS( rcSH ) );
    return Err::m_nOK;
  }
//JVT-T054}
*/
  ROTRS( m_uiInitilized[uiLayer], Err::m_nOK );
  m_auiMbXinFrame[uiLayer]  = rcSH->getSPS().getFrameWidthInMbs   ();
  m_auiMbYinFrame[uiLayer]  = rcSH->getSPS().getFrameHeightInMbs  ();

  UInt uiSizeX = m_auiMbXinFrame  [uiLayer] << 4;
  UInt uiSizeY = m_auiMbYinFrame  [uiLayer] << 4;

  RNOK( m_apcYuvFullPelBufferCtrl [uiLayer]->initSlice( uiSizeY, uiSizeX, YUV_Y_MARGIN, YUV_X_MARGIN ) );

  if( uiLayer == 0 )
  {
    m_bLayer0IsAVC  = ( rcSH->getNalUnitType() == NAL_UNIT_CODED_SLICE || 
                        rcSH->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR);
    
    RNOK( m_pcFrameMng->initSlice               ( rcSH ) );
    m_pcH264AVCDecoder->setReconstructionLayerId( uiLayer );
    m_pcH264AVCDecoder->setBaseAVCCompatible    ( m_bLayer0IsAVC );
  }
  else
  {
    m_pcH264AVCDecoder->setReconstructionLayerId( uiLayer );
  }

  if( (rcSH->getNalUnitType() == NAL_UNIT_CODED_SLICE_SCALABLE ||  
      rcSH->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_SCALABLE) &&
			rcSH->getTrueSlice())//TMM_EC
  {
    /*
      if(!rcSH->getSvcMvcFlag() )
        m_apcMCTFDecoder[uiLayer]->initSlice0( rcSH );
        */
  }

  RNOK( xInitESS( rcSH ) );

  m_uiInitilized[uiLayer] = true;

  return Err::m_nOK;
}


// TMM_ESS {
ErrVal ControlMngH264AVCDecoder::initSPS( SequenceParameterSet& rcSequenceParameterSet, UInt  uiLayer )
{
  m_auiMbXinFrame[uiLayer]  = rcSequenceParameterSet.getFrameWidthInMbs   ();
  m_auiMbYinFrame[uiLayer]  = rcSequenceParameterSet.getFrameHeightInMbs  ();

  return Err::m_nOK;
}


ErrVal ControlMngH264AVCDecoder::xInitESS( SliceHeader* pcSliceHeader )
{
  UInt uiLayer = pcSliceHeader->getLayerId();
  UInt uiBaseLayer = pcSliceHeader->getBaseLayerId();
//JVT-T054{
  if( pcSliceHeader->getQualityLevel() == 0)
  {
    pcSliceHeader->getSPS().getResizeParameters(&m_ResizeParameter[uiLayer]);
  }
  else
  {
    pcSliceHeader->getSPS().getResizeParameters(&m_ResizeParameterCGSSNR[uiLayer][pcSliceHeader->getQualityLevel()]);
  }
//JVT-T054}
  if (uiBaseLayer != MSYS_UINT_MAX )
  {
//JVT-T054{
    ResizeParameters * curr;
    if(pcSliceHeader->getQualityLevel() == 0)
    {
      curr = &m_ResizeParameter[uiLayer];
    }
    else
    {
      curr = &m_ResizeParameterCGSSNR[uiLayer][pcSliceHeader->getQualityLevel()];
    }
//JVT-T054}
    curr->m_iInWidth  = m_auiMbXinFrame  [uiBaseLayer] << 4;
    curr->m_iInHeight = m_auiMbYinFrame  [uiBaseLayer] << 4;

    bool is_crop_aligned = (curr->m_iPosX%16 == 0) && (curr->m_iPosY%16 == 0);
    if      ((curr->m_iInWidth == curr->m_iOutWidth) && (curr->m_iInHeight == curr->m_iOutHeight) &&
             is_crop_aligned && (curr->m_iExtendedSpatialScalability < ESS_PICT) )
      curr->m_iSpatialScalabilityType = SST_RATIO_1;
    else if ((curr->m_iInWidth*2 == curr->m_iOutWidth) && (curr->m_iInHeight*2 == curr->m_iOutHeight) &&
             is_crop_aligned && (curr->m_iExtendedSpatialScalability < ESS_PICT) )
      curr->m_iSpatialScalabilityType = SST_RATIO_2;
    else 
      curr->m_iSpatialScalabilityType = SST_RATIO_X;

    if ( curr->m_iExtendedSpatialScalability == ESS_NONE && curr->m_iSpatialScalabilityType > SST_RATIO_2 )
    {
      printf("\nControlMngH264AVCDecoder::initEES() - use of Extended Spatial Scalability not signaled\n");
      return Err::m_nERR;
    }
    //end 
    /*
//JVT-T054{
    if(pcSliceHeader->getQualityLevel() == 0)
    {
      m_apcMCTFDecoder[uiLayer]->setResizeParameters(&m_ResizeParameter[uiLayer]);
    }
    else
    {
      m_apcMCTFDecoder[uiLayer]->setResizeParametersCGSSNR(pcSliceHeader->getQualityLevel(), &m_ResizeParameterCGSSNR[uiLayer][pcSliceHeader->getQualityLevel()]);
    }
//JVT-T054}
*/
    if (curr->m_iExtendedSpatialScalability == ESS_SEQ)
    {
      printf("Extended Spatial Scalability - crop win: origin=(%3d,%3d) - size=(%3d,%3d)\n\n",
             curr->m_iPosX,curr->m_iPosY,curr->m_iOutWidth,curr->m_iOutHeight);
    }
    else if (curr->m_iExtendedSpatialScalability == ESS_PICT)
    {
      printf("Extended Spatial Scalability - crop win by picture\n\n");
    }
    
  }
	return Err::m_nOK;
}
// TMM_ESS }



ErrVal ControlMngH264AVCDecoder::initSlice( SliceHeader& rcSH, ProcessingState eProcessingState )
{
  m_uiCurrLayer   = rcSH.getLayerId();
  m_pcMbDataCtrl  = rcSH.getFrameUnit()->getMbDataCtrl();

  RNOK( m_pcMbDataCtrl->initSlice( rcSH, eProcessingState, true, NULL ) );
  RNOK( m_pcSampleWeighting->initSlice( rcSH ) );

  if( PARSE_PROCESS == eProcessingState && rcSH.getTrueSlice())//TMM_EC
  {
    MbSymbolReadIf* pcMbSymbolReadIf;
    
    if( rcSH.getPPS().getEntropyCodingModeFlag() )
    {
      pcMbSymbolReadIf = m_pcCabacReader;
    }
    else
    {
      pcMbSymbolReadIf = m_pcUvlcReader;
    }

    RNOK( pcMbSymbolReadIf->startSlice( rcSH ) );
    RNOK( m_pcMbParser->initSlice( pcMbSymbolReadIf ) );

  }

  if( DECODE_PROCESS == eProcessingState)
  {
    RNOK( m_pcMotionCompensation->initSlice( rcSH ) );
  }

  return Err::m_nOK;
}



ErrVal ControlMngH264AVCDecoder::initSliceForReading( const SliceHeader& rcSH )
{
  m_uiCurrLayer   = rcSH.getLayerId();

  MbSymbolReadIf* pcMbSymbolReadIf;
  
  if( rcSH.getPPS().getEntropyCodingModeFlag() )
  {
    pcMbSymbolReadIf = m_pcCabacReader;
  }
  else
  {
    pcMbSymbolReadIf = m_pcUvlcReader;
  }

	if ( rcSH.getTrueSlice())
	{
		RNOK( pcMbSymbolReadIf->startSlice( rcSH ) );
	}
  RNOK( m_pcMbParser->initSlice( pcMbSymbolReadIf ) );

  return Err::m_nOK;
}


ErrVal ControlMngH264AVCDecoder::initSliceForDecoding( const SliceHeader& rcSH )
{
  m_uiCurrLayer   = rcSH.getLayerId();

  RNOK( m_pcMotionCompensation->initSlice( rcSH ) );
  RNOK( m_pcSampleWeighting->initSlice( rcSH ) );

  return Err::m_nOK;
}


ErrVal ControlMngH264AVCDecoder::initSliceForFiltering( const SliceHeader& rcSH )
{
  m_uiCurrLayer   = rcSH.getLayerId();

  return Err::m_nOK;
}


ErrVal ControlMngH264AVCDecoder::finishSlice( const SliceHeader& rcSH, Bool& rbPicDone, Bool& rbFrameDone )
{
  rbPicDone     = m_pcMbDataCtrl->isPicDone( rcSH );
  rbFrameDone   = m_pcMbDataCtrl->isFrameDone( rcSH );
  m_uiCurrLayer = MSYS_UINT_MAX;
  
  return Err::m_nOK;
}

H264AVC_NAMESPACE_END