qualitylevelassigner.cpp

JVT-Z203_jsvm.rar

          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 );
        }
      }
    }

    //----- delete auxiliary array -----
    delete [] puiPic2FNum;
  }
  printf("\n");


  //----- delete temporarily distortion arrays -----
  for( uiLayer  = 0;  uiLayer   <  m_uiNumLayers;              uiLayer  ++ )
  for( uiFGS    = 0;  uiFGS     <= m_auiNumFGSLayers[uiLayer]; uiFGS    ++ )
  for( uiTLevel = 0;  uiTLevel  <= m_auiNumTempLevel[uiLayer]; uiTLevel ++ )
  {
    delete [] aaaauiDistortionDep[uiLayer][uiFGS][uiTLevel];
    delete [] aaaauiDistortionInd[uiLayer][uiFGS][uiTLevel];
  }

  return Err::m_nOK;
}



ErrVal
QualityLevelAssigner::xInitRateValues()
{
  printf( "determine packet sizes ..." );

  Int64             i64StartPos   = 0;
  BinData*          pcBinData     = 0;
  SEI::SEIMessage*  pcScalableSEI = 0;
  PacketDescription cPacketDescription;
  UInt              auiFrameNum[MAX_LAYERS] = { MSYS_UINT_MAX, MSYS_UINT_MAX, MSYS_UINT_MAX, MSYS_UINT_MAX, MSYS_UINT_MAX, MSYS_UINT_MAX, MSYS_UINT_MAX, MSYS_UINT_MAX };
  static Bool    bAVCComaptible = false;  //bug-fix suffix 
  UInt	uiLevel_prefix = 0;//prefix unit

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


  //===== init values ======
  for( UInt uiLayer = 0; uiLayer <  m_uiNumLayers;               uiLayer ++ )
  for( UInt uiFGS   = 0; uiFGS   <= m_auiNumFGSLayers[uiLayer];  uiFGS   ++ )
  for( UInt uiFrame = 0; uiFrame <  m_auiNumFrames   [uiLayer];  uiFrame ++ )
  {
    m_aaauiPacketSize[uiLayer][uiFGS][uiFrame] = 0;
  }

  //===== 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 ) );
    if(cPacketDescription.NalUnitType== NAL_UNIT_CODED_SLICE     ||
       cPacketDescription.NalUnitType== NAL_UNIT_CODED_SLICE_IDR   )
    { 
			cPacketDescription.Level = uiLevel_prefix;//prefix unit
    }
    delete pcScalableSEI; pcScalableSEI = 0;

    //----- get packet size -----
    Int64 i64EndPos     = pcReadBitStream->getFilePos();
    UInt  uiPacketSize  = (UInt)( i64EndPos - i64StartPos );
    i64StartPos         = i64EndPos;

    //----- analyse packets -----
    if( ! cPacketDescription.ParameterSet && cPacketDescription.NalUnitType != NAL_UNIT_SEI )
    {
    if(cPacketDescription.NalUnitType == NAL_UNIT_CODED_SLICE_IDR || cPacketDescription.NalUnitType == NAL_UNIT_CODED_SLICE)
    {
      bAVCComaptible = true;
    }
//prefix unit{{
	if(cPacketDescription.NalUnitType == 14)
	{
		RNOK( pcReadBitStream->releasePacket( pcBinData ) );
		uiLevel_prefix = cPacketDescription.Level;
		continue;
	}
//prefix unit}}

      if( cPacketDescription.FGSLayer == 0 && cPacketDescription.uiFirstMb == 0 )
      {
        auiFrameNum[cPacketDescription.Layer]++;
      }
      m_aaauiPacketSize[cPacketDescription.Layer][cPacketDescription.FGSLayer][auiFrameNum[cPacketDescription.Layer]] += uiPacketSize;
    }

    //----- 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::xGetNextValidPacket( BinData*&          rpcBinData,
                                           ReadBitstreamFile* pcReadBitStream,
                                           UInt               uiTopLayer,
                                           UInt               uiLayer,
                                           UInt               uiFGSLayer,
                                           UInt               uiLevel,
                                           Bool               bIndependent,
                                           Bool&              rbEOS,
                                           UInt*              auiFrameNum )
{
  Bool              bValid        = false;
  static Bool    bAVCComaptible = false;  //bug-fix suffix
  SEI::SEIMessage*  pcScalableSEI = 0;
  PacketDescription cPacketDescription;

  while( !bValid )
  {
    //===== get next packet =====
    RNOK( pcReadBitStream->extractPacket( rpcBinData, rbEOS ) );
    if( rbEOS )
    {
      break;
    }

    //===== analyze packet =====
    RNOK( m_pcH264AVCPacketAnalyzer->process( rpcBinData, cPacketDescription, pcScalableSEI ) );
    delete pcScalableSEI; pcScalableSEI = 0;


    //===== check whether packet is required =====
    if( cPacketDescription.NalUnitType == NAL_UNIT_SEI )
    {
      bValid      = true;
    }
		else if( cPacketDescription.NalUnitType == NAL_UNIT_SPS )
    {
      bValid      = false;
      for( UInt ui = 0; ui <= uiTopLayer; ui++ )
      {
        if( m_auiSPSRequired[cPacketDescription.SPSid] & (1<<ui) )
        {
          bValid  = true;
          break;
        }
      }
    }
    else if( cPacketDescription.NalUnitType == NAL_UNIT_SUBSET_SPS )
    {
      bValid      = false;
      for( UInt ui = 0; ui <= uiTopLayer; ui++ )
      {
        if( m_auiSubsetSPSRequired[cPacketDescription.SPSid] & (1<<ui) )
        {
          bValid  = true;
          break;
        }
      }
    }
    else if( cPacketDescription.NalUnitType == NAL_UNIT_PPS )
    {
      bValid      = false;
      for( UInt ui = 0; ui <= uiTopLayer; ui++ )
      {
        if( m_auiPPSRequired[cPacketDescription.PPSid] & (1<<ui) )
        {
          bValid  = true;
          break;
        }
      }
    }
    else // slice data
    {
    if(cPacketDescription.NalUnitType == NAL_UNIT_CODED_SLICE_IDR || cPacketDescription.NalUnitType == NAL_UNIT_CODED_SLICE)
    {
      bAVCComaptible = true;
    }
//prefix unit{{
	if(cPacketDescription.NalUnitType == 14)
	{
	//	uiLevel_prefix = cPacketDescription.Level;
		bValid  = true;
		continue;
	}
//prefix unit}}
      //===== update frame num =====
      if( ! cPacketDescription.FGSLayer && cPacketDescription.uiFirstMb == 0 )
      {
        auiFrameNum[cPacketDescription.Layer]++;
      }

      //===== check temporal level =====
      {
        UInt uiTL                 = 0;
        UInt uiFN                 = auiFrameNum[cPacketDescription.Layer];
        UInt uiNumFramesComplete  = ( ( m_auiNumFrames[cPacketDescription.Layer] - 1 ) / m_auiGOPSize[cPacketDescription.Layer] ) * m_auiGOPSize[cPacketDescription.Layer] + 1;
        UInt uiRemainingFrames    = m_auiNumFrames[cPacketDescription.Layer] - uiNumFramesComplete;
        UInt uiFNMod              = ( uiFN - 1 ) % m_auiGOPSize[cPacketDescription.Layer];
        if( uiFN )
        {
          if( uiFN < uiNumFramesComplete )
          {
            for( ; uiFNMod > 0; uiFNMod >>= 1, uiTL++ );
          }
          else
          {
            UInt auiTLevel[128];
            UInt uiEntry = 0;
            ::memset( auiTLevel, 0xFF, 128*sizeof(UInt) );
            for( UInt   uiTempLevel = 0;      uiTempLevel <= m_auiNumTempLevel[cPacketDescription.Layer]; uiTempLevel++ )
            {
              UInt      uiStep      = ( 1 << ( m_auiNumTempLevel[cPacketDescription.Layer] - uiTempLevel ) );
              for( UInt uiPos       = uiStep; uiPos      <= m_auiGOPSize[cPacketDescription.Layer];      uiPos += (uiStep<<1) )
              {
                if( uiPos - 1 < uiRemainingFrames )
                {
                  auiTLevel[uiEntry++] = uiTempLevel;
                }
              }
            }
            uiTL = auiTLevel[uiFNMod];
            ROT( uiTL == MSYS_UINT_MAX );
          }
        }
        ROT( cPacketDescription.Scalable && cPacketDescription.Level != uiTL );
        cPacketDescription.Level = uiTL;
      }

      //===== get valid status =====
      //JVT-S043
      //For cPacketDescription.Layer > uiLayer,  only Base Quality Level(Discrete layer) is selected!
      //For cPacketDescription.Layer <= uiLayer, the algorithm selects the required FGS layers and Temporal Levels.
      //--
      if( bIndependent )
      {
        bValid      = ( cPacketDescription.Layer    <= uiLayer
                      //JVT-S043
                      || ( cPacketDescription.Layer  <= uiTopLayer && cPacketDescription.FGSLayer == 0 )
                      );
        if( cPacketDescription.Layer == uiLayer )
        {
          bValid    = ( cPacketDescription.Level    == uiLevel &&
                        cPacketDescription.FGSLayer <= uiFGSLayer ) || ( cPacketDescription.FGSLayer == 0 );
        }
      }
      else
      {
        bValid      = ( cPacketDescription.Layer <= uiLayer
                      //JVT-S043
                      || ( cPacketDescription.Layer  <= uiTopLayer && cPacketDescription.FGSLayer == 0 )
                      );
        if( cPacketDescription.Layer == uiLayer )
        {
          bValid    = ( cPacketDescription.FGSLayer <= uiFGSLayer );
          if( cPacketDescription.FGSLayer == uiFGSLayer )
          {
            bValid  = ( cPacketDescription.Level <= uiLevel );
          }
        }
      }

    }

    if( !bValid )
    {
      RNOK( pcReadBitStream->releasePacket( rpcBinData ) );
    }
  }

  return Err::m_nOK;
}

ErrVal
QualityLevelAssigner::xGetDistortion( UInt&         ruiDistortion,
                                      const UChar*  pucReconstruction,
                                      const UChar*  pucReference,
                                      UInt          uiHeight,
                                      UInt          uiWidth,
                                      UInt          uiStride )
{
  ruiDistortion = 0;
  for( UInt y = 0; y < uiHeight; y++ )
  {
    for( UInt x = 0; x < uiWidth; x++ )
    {
      Int iDiff      = ( pucReconstruction[x] - pucReference[x] );
      ruiDistortion += (UInt)( iDiff * iDiff );
    }
    pucReconstruction += uiStride;
    pucReference      += uiStride;
  }
  return Err::m_nOK;
}





ErrVal
QualityLevelAssigner::xInitDistortion( UInt*  auiDistortion,
                                       UInt   uiTopLayer,
                                       UInt   uiLayer,
                                       UInt   uiFGSLayer,
                                       UInt   uiLevel,
                                       Bool   bIndependent )
{
  ROT( m_pcParameter->getOriginalFileName( uiTopLayer ).empty() );