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

  //===== 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 ) );
    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.FGSLayer == 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;
  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_PPS )
    {
      bValid      = false;
      for( UInt ui = 0; ui <= uiTopLayer; ui++ )
      {
        if( m_auiPPSRequired[cPacketDescription.PPSid] & (1<<ui) )
        {
          bValid  = true;
          break;
        }
      }
    }
    else // slice data
    {
      //===== update frame num =====
      if( ! cPacketDescription.FGSLayer )
      {
        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() );

  if( uiLevel == MSYS_UINT_MAX )
    printf( "determine distortion (layer %d - FGS %d - base layer  ) ...", uiLayer, uiFGSLayer );
  else
    printf( "determine distortion (layer %d - FGS %d - lev%2d - %s ) ...", uiLayer, uiFGSLayer, uiLevel, bIndependent?"ind":"dep" );

#if WIN32
  Char              tmp_file_name[]   = "decout.tmp";
#endif
  Bool              bEOS              = false;
  Bool              bToDecode         = false;
  UInt              uiFrame           = 0;
  UInt              uiNalUnitType     = 0;
  UInt              uiMbX             = 0;
  UInt              uiMbY             = 0;
  UInt              uiSize            = 0;

//  UInt              uiNonRequiredPic  = 0;  //NonRequired JVT-Q066

  UInt              uiLumOffset       = 0;
  UInt              uiCbOffset        = 0;
  UInt              uiCrOffset        = 0;
  Bool              bYuvDimSet        = false;
  PicBuffer*        pcPicBuffer       = 0;
  PicBuffer*        pcPicBufferOrig   = 0;
  WriteYuvIf*       pcWriteYuv        = 0;
  PicBufferList     cPicBufferOutputList;
  PicBufferList     cPicBufferUnusedList;
  PicBufferList     cPicBufferReleaseList;
  UInt              auiFrameNumAnalysis[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 };
  UInt              auiFrameNumDecoding[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 };

  //===== init =====
  RNOK( m_pcH264AVCPacketAnalyzer->init() );
  RNOK( m_pcH264AVCDecoder       ->init(true,NULL) );

  ReadBitstreamFile*  pcReadBitStream = 0;
  ReadYuvFile*        pcReadYuv       = 0;
  RNOK( ReadBitstreamFile ::create( pcReadBitStream ) );
  RNOK( ReadYuvFile       ::create( pcReadYuv       ) );
  RNOK( pcReadBitStream ->init( m_pcParameter->getInputBitStreamName() ) );
  RNOK( pcReadYuv       ->init( m_pcParameter->getOriginalFileName  ( uiTopLayer ), m_auiFrameHeight[uiTopLayer], m_auiFrameWidth[uiTopLayer] ) );

  if( m_bOutputReconstructions )
  {
    Char  acName[1024];
    sprintf( acName, "rec_Layer%d_FGS%d_Level%d_Mode%d", uiLayer, uiFGSLayer, uiLevel, (bIndependent?0:1) );
    RNOK( WriteYuvToFile::create( pcWriteYuv, std::string( acName ) ) );
  }


  //===== loop over packets =====
  while( ! bEOS )