qualitylevelassigner.cpp

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

}


ErrVal
QualityLevelAssigner::xClearPicBufferLists()
{
  ROF( m_cActivePicBufferList.empty() );
  
  PicBufferList::iterator iter;
  for( iter = m_cUnusedPicBufferList.begin(); iter != m_cUnusedPicBufferList.end(); iter++ )
  {
    delete (*iter)->getBuffer();
    delete (*iter);
  }
  m_cUnusedPicBufferList.clear();
  
  for( iter = m_cActivePicBufferList.begin(); iter != m_cActivePicBufferList.end(); iter++ )
  {
    delete (*iter)->getBuffer();
    delete (*iter);
  }
  m_cActivePicBufferList.clear();

  return Err::m_nOK;
}


ErrVal
QualityLevelAssigner::xInitStreamParameters()
{
  printf( "analyse stream content ..." );

  Bool              bFirstPacket  = true;
  BinData*          pcBinData     = 0;
  SEI::SEIMessage*  pcScalableSEI = 0;
  PacketDescription cPacketDescription;

  m_uiNumLayers = 0;
  ::memset( m_auiNumFGSLayers,  0x00, MAX_LAYERS*sizeof(UInt) );
  ::memset( m_auiNumFrames,     0x00, MAX_LAYERS*sizeof(UInt) );
  ::memset( m_auiGOPSize,       0x00, MAX_LAYERS*sizeof(UInt) );
  ::memset( m_auiNumTempLevel,  0x00, MAX_LAYERS*sizeof(UInt) );
  ::memset( m_auiFrameWidth,    0x00, MAX_LAYERS*sizeof(UInt) );
  ::memset( m_auiFrameHeight,   0x00, MAX_LAYERS*sizeof(UInt) );
  ::memset( m_auiSPSRequired,   0x00, 32        *sizeof(UInt) );
  ::memset( m_auiPPSRequired,   0x00, 256       *sizeof(UInt) );

  //===== init =====
  RNOK( m_pcH264AVCPacketAnalyzer->init() );
  ReadBitstreamFile* pcReadBitStream = 0;
  RNOK( ReadBitstreamFile::create( pcReadBitStream ) );
  RNOK( pcReadBitStream->init( m_pcParameter->getInputBitStreamName() ) );


  //===== loop over packets =====
  while( true )
  {
    //----- read packet -----
    Bool bEOS = false;
    RNOK( pcReadBitStream->extractPacket( pcBinData, bEOS ) );
    if( bEOS )
    {
      //manu.mathew@samsung : memory leak fix
      RNOK( pcReadBitStream->releasePacket( pcBinData ) );
      pcBinData = NULL;
      //--
      break;
    }

    //----- get packet description -----
    RNOK( m_pcH264AVCPacketAnalyzer->process( pcBinData, cPacketDescription, pcScalableSEI ) );
    ROT( bFirstPacket && !pcScalableSEI );
    if( pcScalableSEI )
    {
      Bool              bUncompleteInfo     = false;
      SEI::ScalableSei* pcScalSEI           = (SEI::ScalableSei*)pcScalableSEI;
      UInt              uiNumLayersInSEI    = pcScalSEI->getNumLayersMinus1() + 1;
      Bool              abUsed[MAX_LAYERS]  = { false, false, false, false, false, false, false, false };

      for( UInt ui = 0; ui < uiNumLayersInSEI; ui++ )
      {
        if(// ! pcScalSEI->getDecodingDependencyInfoPresentFlag ( ui ) ||  //JVT-S036 lsj
            ! pcScalSEI->getFrmSizeInfoPresentFlag            ( ui )   )
        {
          bUncompleteInfo = true;
          break;
        }

        UInt uiLayerId = pcScalSEI->getDependencyId( ui );
        if( abUsed[uiLayerId] )
        { // update information
          m_auiNumTempLevel [uiLayerId] = max( m_auiNumTempLevel[uiLayerId], pcScalSEI->getTemporalLevel( ui ) );
          m_auiGOPSize      [uiLayerId] = ( 1 << m_auiNumTempLevel[uiLayerId] );
        }
        else
        { // init information
          abUsed            [uiLayerId] = true;
          m_auiNumTempLevel [uiLayerId] = pcScalSEI->getTemporalLevel( ui );
          m_auiGOPSize      [uiLayerId] = ( 1 << m_auiNumTempLevel[uiLayerId] );
          m_auiFrameWidth   [uiLayerId] = ( pcScalSEI->getFrmWidthInMbsMinus1 ( ui ) + 1 ) << 4;
          m_auiFrameHeight  [uiLayerId] = ( pcScalSEI->getFrmHeightInMbsMinus1( ui ) + 1 ) << 4;
        }
      }

      ROT( bUncompleteInfo );

      delete pcScalableSEI;
      pcScalableSEI = 0;
      bFirstPacket  = false;
    }

    //----- analyse packets -----
    if( cPacketDescription.FGSLayer )
    {
      if( cPacketDescription.Layer+1 > m_uiNumLayers)
      {
        m_uiNumLayers = cPacketDescription.Layer+1;
      }
      if( cPacketDescription.FGSLayer > m_auiNumFGSLayers[cPacketDescription.Layer] )
      {
        m_auiNumFGSLayers[cPacketDescription.Layer] = cPacketDescription.FGSLayer;
      }
      m_auiSPSRequired[cPacketDescription.SPSid] |= (1 << cPacketDescription.Layer);
      m_auiPPSRequired[cPacketDescription.PPSid] |= (1 << cPacketDescription.Layer);
    }
    else if( ! cPacketDescription.ParameterSet && cPacketDescription.NalUnitType != NAL_UNIT_SEI &&
             ! cPacketDescription.FGSLayer )
    {
      m_auiNumFrames[cPacketDescription.Layer]++;
      
      m_auiSPSRequired[cPacketDescription.SPSid] |= (1 << cPacketDescription.Layer);
      m_auiPPSRequired[cPacketDescription.PPSid] |= (1 << cPacketDescription.Layer);
    }

    //----- delete bin data -----
    RNOK( pcReadBitStream->releasePacket( pcBinData ) );
  }

  
  //===== uninit =====
  RNOK( m_pcH264AVCPacketAnalyzer->uninit() );
  RNOK( pcReadBitStream->uninit() );
  RNOK( pcReadBitStream->destroy() );

  printf("\n");
  return Err::m_nOK;
}



ErrVal
QualityLevelAssigner::xInitRateAndDistortion(Bool bMultiLayer)
{
  RNOK( xInitRateValues() );

  //----- create temporarily distortion arrays -----
  UInt  uiLayer, uiFGS, uiTLevel, uiFrame;
  UInt* aaaauiDistortionDep[MAX_LAYERS][MAX_QUALITY_LEVELS][MAX_DSTAGES+1];
  UInt* aaaauiDistortionInd[MAX_LAYERS][MAX_QUALITY_LEVELS][MAX_DSTAGES+1];
  for( uiLayer  = 0;  uiLayer   <  m_uiNumLayers;              uiLayer  ++ )
  {
    //JVT-S043
    UInt uiTopLayer = (bMultiLayer? m_uiNumLayers-1 : uiLayer);

    for( uiFGS    = 0;  uiFGS     <= m_auiNumFGSLayers[uiLayer]; uiFGS    ++ )
    for( uiTLevel = 0;  uiTLevel  <= m_auiNumTempLevel[uiLayer]; uiTLevel ++ )
    {
      ROFRS( ( aaaauiDistortionDep[uiLayer][uiFGS][uiTLevel] = new UInt [m_auiNumFrames[uiTopLayer]] ), Err::m_nOK );
      ROFRS( ( aaaauiDistortionInd[uiLayer][uiFGS][uiTLevel] = new UInt [m_auiNumFrames[uiTopLayer]] ), Err::m_nOK );
    }
  }
  for( uiLayer  = 0;  uiLayer   <  m_uiNumLayers;              uiLayer  ++ )
  for( uiFrame  = 0;  uiFrame   <  m_auiNumFrames[uiLayer];    uiFrame  ++ )
  {
    m_aaadDeltaDist[uiLayer][0][uiFrame] = 100.0; // dummy value
  }


  Bool bDep = m_pcParameter->useDependentDistCalc   ();
  Bool bInd = m_pcParameter->useIndependentDistCalc ();
  ROF( bDep || bInd );


  //----- determine picture distortions -----
  for( uiLayer = 0; uiLayer < m_uiNumLayers; uiLayer++ )
  {
    //JVT-S043
    UInt uiTopLayer = (bMultiLayer? m_uiNumLayers-1 : uiLayer);

    //----- get base layer distortion -----
    RNOK( xInitDistortion( aaaauiDistortionDep[uiLayer][0][0], uiTopLayer, uiLayer, 0 ) );

    ::memcpy(              aaaauiDistortionInd[uiLayer][0][0], aaaauiDistortionDep[uiLayer][0][0], m_auiNumFrames[uiTopLayer]*sizeof(UInt) );
    for( uiTLevel = 1; uiTLevel <= m_auiNumTempLevel[uiLayer]; uiTLevel++ )
    {
      ::memcpy(     aaaauiDistortionDep[uiLayer][0][uiTLevel], aaaauiDistortionDep[uiLayer][0][0], m_auiNumFrames[uiTopLayer]*sizeof(UInt) );
      ::memcpy(     aaaauiDistortionInd[uiLayer][0][uiTLevel], aaaauiDistortionInd[uiLayer][0][0], m_auiNumFrames[uiTopLayer]*sizeof(UInt) );
    }
    //----- get enhancement distortions -----
    for( uiFGS    = 1; uiFGS    <= m_auiNumFGSLayers[uiLayer]; uiFGS   ++ )
    for( uiTLevel = 0; uiTLevel <= m_auiNumTempLevel[uiLayer]; uiTLevel++ )
    {
      if( bDep )
      {
        RNOK( xInitDistortion( aaaauiDistortionDep[uiLayer][uiFGS][uiTLevel], uiTopLayer, uiLayer, uiFGS, uiTLevel, false ) );
      }
      if( bInd )
      {
        RNOK( xInitDistortion( aaaauiDistortionInd[uiLayer][uiFGS][uiTLevel], uiTopLayer, uiLayer, uiFGS, uiTLevel, true  ) );
      }
    }
    RNOK( xClearPicBufferLists() ); // spatial resolution can be changed
  }


  //----- init delta distortion -----
  printf( "determine delta distortions ..." );
  for( uiLayer = 0; uiLayer < m_uiNumLayers; uiLayer++ )
  {
    //JVT-S043
    UInt uiTopLayer = (bMultiLayer? m_uiNumLayers-1 : uiLayer);

    //----- create arrays for pic number to frame number mapping -----
    UInt* puiPic2FNum = new UInt[ m_auiNumFrames[uiLayer] ];
    ROF(  puiPic2FNum);
    Bool  bLastGOP    = false;
    UInt  uiFrameNum  = 0;
    UInt  uiGOPPos    = 0;
    for( puiPic2FNum[0] = uiFrameNum++; ! bLastGOP; uiGOPPos += m_auiGOPSize[uiLayer] )
    {
      for( uiTLevel = 0; uiTLevel <= m_auiNumTempLevel[uiLayer]; uiTLevel++ )
      {
        UInt uiStep = ( 1 << ( m_auiNumTempLevel[uiLayer] - uiTLevel ) );
        for( UInt uiDeltaPos = uiStep; uiDeltaPos <= m_auiGOPSize[uiLayer]; uiDeltaPos += (uiStep<<1) )
        {
          if( uiGOPPos + uiDeltaPos < m_auiNumFrames[uiLayer] )
          {
            puiPic2FNum[uiGOPPos+uiDeltaPos] = uiFrameNum++;
          }
          else
          {
            bLastGOP = true;
          }
        }
      }
    }
  
   
    //----- determine delta distortions -----
    for( uiFGS = 1; uiFGS <= m_auiNumFGSLayers[uiLayer]; uiFGS++ )
    {
      //----- key pictures (that's a bit tricky) -----
      {
        UInt  uiMaxTLevel     = m_auiNumTempLevel[uiLayer];
        Bool  bLastKeyPicture = false;
        for( UInt uiKeyPicCount = 0; ! bLastKeyPicture; uiKeyPicCount++ )
        {
          Double dDistortionBaseDep  = 0;
          Double dDistortionBaseInd  = 0;
          Double dDistortionEnhDep   = 0;
          Double dDistortionEnhInd   = 0;
          bLastKeyPicture         = ( ( ( m_auiNumFrames[uiLayer] - 1 ) / m_auiGOPSize[uiLayer] ) == uiKeyPicCount );
          
          UInt   uiPicNum         = uiKeyPicCount * m_auiGOPSize[uiLayer];
          UInt   uiTopLayerPicNum = uiKeyPicCount * m_auiGOPSize[uiTopLayer];
          // UInt   uiStepSize2      = m_auiGOPSize[uiLayer] >> 1;  // unused variable mwi060625
          UInt   uiTopLayerStepSize2 = m_auiGOPSize[uiTopLayer] >> 1;
          
          //---- preceding level 1 picture -----
          if( uiKeyPicCount )
          {
            dDistortionBaseDep += log10( (Double)aaaauiDistortionDep[uiLayer][uiFGS-1][uiMaxTLevel][uiTopLayerPicNum-uiTopLayerStepSize2] ) / 2;
            dDistortionEnhDep  += log10( (Double)aaaauiDistortionDep[uiLayer][uiFGS  ][0          ][uiTopLayerPicNum-uiTopLayerStepSize2] ) / 2;

            dDistortionBaseInd += log10( (Double)aaaauiDistortionInd[uiLayer][uiFGS-1][0          ][uiTopLayerPicNum-uiTopLayerStepSize2] ) / 2;
            dDistortionEnhInd  += log10( (Double)aaaauiDistortionInd[uiLayer][uiFGS  ][0          ][uiTopLayerPicNum-uiTopLayerStepSize2] ) / 2;
          }
          //---- normal pictures -----
          UInt uiStartPicNum  = ( uiKeyPicCount   ?  uiTopLayerPicNum - uiTopLayerStepSize2 + 1 : 0 );
          UInt uiEndPicNum    = ( bLastKeyPicture ? m_auiNumFrames[uiTopLayer] - 1 : uiTopLayerPicNum + uiTopLayerStepSize2 - 1 );
          for( UInt uiCheckPicNum = uiStartPicNum; uiCheckPicNum <= uiEndPicNum; uiCheckPicNum++ )
          {
            dDistortionBaseDep += log10( (Double)aaaauiDistortionDep[uiLayer][uiFGS-1][uiMaxTLevel][uiCheckPicNum] );
            dDistortionEnhDep  += log10( (Double)aaaauiDistortionDep[uiLayer][uiFGS  ][0          ][uiCheckPicNum] );

            dDistortionBaseInd += log10( (Double)aaaauiDistortionInd[uiLayer][uiFGS-1][0          ][uiCheckPicNum] );
            dDistortionEnhInd  += log10( (Double)aaaauiDistortionInd[uiLayer][uiFGS  ][0          ][uiCheckPicNum] );
          }
          //---- following level 1 picture -----
          if( ! bLastKeyPicture )
          {
            dDistortionBaseDep += log10( (Double)aaaauiDistortionDep[uiLayer][uiFGS-1][uiMaxTLevel][uiTopLayerPicNum+uiTopLayerStepSize2] ) / 2;
            dDistortionEnhDep  += log10( (Double)aaaauiDistortionDep[uiLayer][uiFGS  ][0          ][uiTopLayerPicNum+uiTopLayerStepSize2] ) / 2;

            dDistortionBaseInd += log10( (Double)aaaauiDistortionInd[uiLayer][uiFGS-1][0          ][uiTopLayerPicNum+uiTopLayerStepSize2] ) / 2;
            dDistortionEnhInd  += log10( (Double)aaaauiDistortionInd[uiLayer][uiFGS  ][0          ][uiTopLayerPicNum+uiTopLayerStepSize2] ) / 2;
          }

          m_aaadDeltaDist[uiLayer][uiFGS][puiPic2FNum[uiPicNum]] = 0;
          m_aaadDeltaDist[uiLayer][uiFGS][puiPic2FNum[uiPicNum]]+= ( bDep ? dDistortionBaseDep - dDistortionEnhDep : 0 );
          m_aaadDeltaDist[uiLayer][uiFGS][puiPic2FNum[uiPicNum]]+= ( bInd ? dDistortionBaseInd - dDistortionEnhInd : 0 );
        }
      }

      //----- non-key pictures -----
      UInt uiTemporalScaleFactor = m_auiGOPSize[uiTopLayer] / m_auiGOPSize[uiLayer];

      for( uiTLevel = 1; uiTLevel <= m_auiNumTempLevel[uiLayer]; uiTLevel++ )
      {
        UInt uiStepSize2   = ( 1 << ( m_auiNumTempLevel[uiLayer] - uiTLevel ) );
        UInt uiTopLayerStepSize2   = ( 1 << ( m_auiNumTempLevel[uiTopLayer] - uiTLevel ) );

        for( UInt uiPicNum = uiStepSize2; uiPicNum < m_auiNumFrames[uiLayer]; uiPicNum += (uiStepSize2<<1) )
        {
          UInt uiTopLayerPicNum = uiPicNum * uiTemporalScaleFactor;

          Double dDistortionBaseDep  = 0;
          Double dDistortionBaseInd  = 0;
          Double dDistortionEnhDep   = 0;
          Double dDistortionEnhInd   = 0;
          UInt    uiStartPicNum   = uiTopLayerPicNum - uiTopLayerStepSize2 + 1;
          UInt    uiEndPicNum     = min( uiTopLayerPicNum + uiTopLayerStepSize2, m_auiNumFrames[uiTopLayer] ) - 1;
          for( UInt uiCheckPicNum = uiStartPicNum; uiCheckPicNum <= uiEndPicNum; uiCheckPicNum++ )
          {
            dDistortionBaseDep += log10( (Double)aaaauiDistortionDep[uiLayer][uiFGS  ][uiTLevel-1][uiCheckPicNum] );
            dDistortionEnhDep  += log10( (Double)aaaauiDistortionDep[uiLayer][uiFGS  ][uiTLevel  ][uiCheckPicNum] );

            dDistortionBaseInd += log10( (Double)aaaauiDistortionInd[uiLayer][uiFGS-1][uiTLevel  ][uiCheckPicNum] );
            dDistortionEnhInd  += log10( (Double)aaaauiDistortionInd[uiLayer][uiFGS  ][uiTLevel  ][uiCheckPicNum] );
          }
          m_aaadDeltaDist[uiLayer][uiFGS][puiPic2FNum[uiPicNum]] = 0;
          m_aaadDeltaDist[uiLayer][uiFGS][puiPic2FNum[uiPicNum]]+= ( bDep ? dDistortionBaseDep - dDistortionEnhDep : 0 );
          m_aaadDeltaDist[uiLayer][uiFGS][puiPic2FNum[uiPicNum]]+= ( bInd ? dDistortionBaseInd - dDistortionEnhInd : 0 );
        }