Changeset 1360 in 3DVCSoftware


Ignore:
Timestamp:
28 Oct 2015, 17:46:00 (9 years ago)
Author:
tech
Message:

Update to HM-16.7.

Location:
branches/HTM-15.2-dev
Files:
45 added
4 deleted
88 edited

Legend:

Unmodified
Added
Removed
  • branches/HTM-15.2-dev/source/App/TAppDecoder/TAppDecCfg.cpp

    r1356 r1360  
    6262    \param argv array of arguments
    6363 */
    64 Bool TAppDecCfg::parseCfg( Int argc, Char* argv[] )
     64Bool TAppDecCfg::parseCfg( Int argc, TChar* argv[] )
    6565{
    6666  Bool do_help = false;
    67   string cfg_BitstreamFile;
    68   string cfg_ReconFile;
    6967  string cfg_TargetDecLayerIdSetFile;
    7068#if NH_3D
     
    7977
    8078  ("help",                      do_help,                               false,      "this help text")
    81   ("BitstreamFile,b",           cfg_BitstreamFile,                     string(""), "bitstream input file name")
    82   ("ReconFile,o",               cfg_ReconFile,                         string(""), "reconstructed YUV output file name\n"
     79  ("BitstreamFile,b",           m_bitstreamFileName,                   string(""), "bitstream input file name")
     80  ("ReconFile,o",               m_reconFileName,                       string(""), "reconstructed YUV output file name\n"
    8381                                                                                   "YUV writing is skipped if omitted")
    8482#if NH_3D
     
    106104  ("PrintNalus,n",              m_printReceivedNalus,                 false,        "Print information on received NAL units")
    107105#endif
     106  ("SEIColourRemappingInfoFilename",  m_colourRemapSEIFileName,        string(""), "Colour Remapping YUV output file name. If empty, no remapping is applied (ignore SEI message)\n")
     107
    108108#if O0043_BEST_EFFORT_DECODING
    109109  ("ForceDecodeBitDepth",       m_forceDecodeBitDepth,                 0U,         "Force the decoder to operate at a particular bit-depth (best effort decoding)")
     
    119119  po::setDefaults(opts);
    120120  po::ErrorReporter err;
    121   const list<const Char*>& argv_unhandled = po::scanArgv(opts, argc, (const Char**) argv, err);
    122 
    123   for (list<const Char*>::const_iterator it = argv_unhandled.begin(); it != argv_unhandled.end(); it++)
     121  const list<const TChar*>& argv_unhandled = po::scanArgv(opts, argc, (const TChar**) argv, err);
     122
     123  for (list<const TChar*>::const_iterator it = argv_unhandled.begin(); it != argv_unhandled.end(); it++)
    124124  {
    125125    fprintf(stderr, "Unhandled argument ignored: `%s'\n", *it);
     
    148148  }
    149149
    150   /* convert std::string to c string for compatability */
    151   m_pchBitstreamFile = cfg_BitstreamFile.empty() ? NULL : strdup(cfg_BitstreamFile.c_str());
    152   m_pchReconFile = cfg_ReconFile.empty() ? NULL : strdup(cfg_ReconFile.c_str());
    153 
    154 #if NH_3D
    155   m_pchScaleOffsetFile = cfg_ScaleOffsetFile.empty() ? NULL : strdup(cfg_ScaleOffsetFile.c_str());
    156 #endif
    157 
    158   if (!m_pchBitstreamFile)
     150  if (m_bitstreamFileName.empty())
    159151  {
    160152    fprintf(stderr, "No input file specified, aborting\n");
     
    217209
    218210#if NH_MV
    219 Void TAppDecCfg::xAppendToFileNameEnd( Char* pchInputFileName, const Char* pchStringToAppend, Char*& rpchOutputFileName)
     211Void TAppDecCfg::xAppendToFileNameEnd( const TChar* pchInputFileName, const TChar* pchStringToAppend, TChar*& rpchOutputFileName)
    220212{
    221213  size_t iInLength     = strlen(pchInputFileName);
    222214  size_t iAppendLength = strlen(pchStringToAppend);
    223215
    224   rpchOutputFileName = (Char*) malloc(iInLength+iAppendLength+1);                       
    225   Char* pCDot = strrchr(pchInputFileName,'.');         
     216  rpchOutputFileName = (TChar*) malloc(iInLength+iAppendLength+1);                       
     217  const TChar* pCDot = strrchr(pchInputFileName,'.');         
    226218  pCDot = pCDot ? pCDot : pchInputFileName + iInLength;       
    227219  size_t iCharsToDot = pCDot - pchInputFileName ;
  • branches/HTM-15.2-dev/source/App/TAppDecoder/TAppDecCfg.h

    r1356 r1360  
    6060{
    6161protected:
    62   Char*         m_pchBitstreamFile;                     ///< input bitstream file name
    63   Char*         m_pchReconFile;                         ///< output reconstruction file name
     62  std::string   m_bitstreamFileName;                    ///< input bitstream file name
     63  std::string   m_reconFileName;                        ///< output reconstruction file name
    6464  Int           m_iSkipFrame;                           ///< counter for frames prior to the random access point to skip
    6565  Int           m_outputBitDepth[MAX_NUM_CHANNEL_TYPE]; ///< bit depth used for writing output
     
    6969  Int           m_decodedPictureHashSEIEnabled;       ///< Checksum(3)/CRC(2)/MD5(1)/disable(0) acting on decoded picture hash SEI message
    7070  Bool          m_decodedNoDisplaySEIEnabled;         ///< Enable(true)/disable(false) writing only pictures that get displayed based on the no display SEI message
     71  std::string   m_colourRemapSEIFileName;             ///< output Colour Remapping file name
    7172  std::vector<Int> m_targetDecLayerIdSet;             ///< set of LayerIds to be included in the sub-bitstream extraction process.
    7273
     
    7879  Bool          m_bClipOutputVideoToRec709Range;      ///< If true, clip the output video to the Rec 709 range on saving.
    7980#if NH_MV
    80   std::vector<Char*> m_pchReconFiles;                   ///< array of output reconstruction file name create from output reconstruction file name
     81  std::vector<TChar*> m_pchReconFiles;                ///< array of output reconstruction file name create from output reconstruction file name
    8182
    82   Int           m_targetOptLayerSetIdx;                 ///< target output layer set index
     83  Int           m_targetOptLayerSetIdx;               ///< target output layer set index
    8384  Int           m_targetDecLayerSetIdx;
    8485  Int           m_baseLayerOutputFlag;
    8586  Int           m_baseLayerPicOutputFlag;
    8687  Int           m_auOutputFlag;
    87   Int           m_maxLayerId;                           ///< maximum nuh_layer_id decoded
     88  Int           m_maxLayerId;                         ///< maximum nuh_layer_id decoded
    8889  std::ifstream m_bitstreamFile;
    8990  Int           m_highestTid;
    9091  Bool          m_targetDecLayerIdSetFileEmpty;       ///< indication if target layers are given by file
    9192
    92   Bool          m_printVpsInfo;                      ///< Output VPS information
     93  Bool          m_printVpsInfo;                       ///< Output VPS information
    9394  Bool          m_printPicOutput;                     ///< Print information on picture output
    9495  Bool          m_printReceivedNalus;                 ///< Print information on received NAL units
    9596#if NH_3D
    96   Char*         m_pchScaleOffsetFile;                   ///< output coded scale and offset parameters
     97  TChar*        m_pchScaleOffsetFile;                   ///< output coded scale and offset parameters
    9798  Bool          m_depth420OutputFlag;                   ///< output depth layers in 4:2:0
    9899#endif
    99100
    100   Void xAppendToFileNameEnd( Char* pchInputFileName, const Char* pchStringToAppend, Char*& rpchOutputFileName); ///< create filenames
     101  Void xAppendToFileNameEnd( const TChar* pchInputFileName, const TChar* pchStringToAppend, TChar*& rpchOutputFileName); ///< create filenames
    101102#endif
    102103
    103104public:
    104105  TAppDecCfg()
    105   : m_pchBitstreamFile(NULL)
    106   , m_pchReconFile(NULL)
     106  : m_bitstreamFileName()
     107  , m_reconFileName()
    107108  , m_iSkipFrame(0)
     109  // m_outputBitDepth array initialised below
    108110  , m_outputColourSpaceConvert(IPCOLOURSPACE_UNCHANGED)
    109111  , m_iMaxTemporalLayer(-1)
    110112  , m_decodedPictureHashSEIEnabled(0)
    111113  , m_decodedNoDisplaySEIEnabled(false)
     114  , m_colourRemapSEIFileName()
     115  , m_targetDecLayerIdSet()
    112116  , m_respectDefDispWindow(0)
    113117#if O0043_BEST_EFFORT_DECODING
    114118  , m_forceDecodeBitDepth(0)
    115119#endif
     120  , m_outputDecodedSEIMessagesFilename()
     121  , m_bClipOutputVideoToRec709Range(false)
    116122#if NH_MV
    117123  , m_highestTid(-1)
     
    131137  virtual ~TAppDecCfg() {}
    132138
    133   Bool  parseCfg        ( Int argc, Char* argv[] );   ///< initialize option class from configuration
     139  Bool  parseCfg        ( Int argc, TChar* argv[] );   ///< initialize option class from configuration
    134140};
    135141
  • branches/HTM-15.2-dev/source/App/TAppDecoder/TAppDecTop.cpp

    r1321 r1360  
    6262: m_numDecoders( 0 )
    6363#endif
     64 ,m_pcSeiColourRemappingInfoPrevious(NULL)
    6465{
    6566#if NH_MV
     
    118119  xDestroyDecLib();
    119120#endif
    120 
    121   if (m_pchBitstreamFile)
    122   {
    123     free (m_pchBitstreamFile);
    124     m_pchBitstreamFile = NULL;
    125   }
     121  m_bitstreamFileName.clear();
    126122#if NH_MV
    127123  for (Int decIdx = 0; decIdx < m_numDecoders; decIdx++)
     
    134130  }
    135131#endif
    136   if (m_pchReconFile)
    137   {
    138     free (m_pchReconFile);
    139     m_pchReconFile = NULL;
    140   }
     132  m_reconFileName.clear();
    141133#if NH_3D
    142134  if (m_pchScaleOffsetFile)
     
    226218  TComList<TComPic*>* pcListPic = NULL;
    227219
    228   ifstream bitstreamFile(m_pchBitstreamFile, ifstream::in | ifstream::binary);
     220  ifstream bitstreamFile(m_bitstreamFileName.c_str(), ifstream::in | ifstream::binary);
    229221  if (!bitstreamFile)
    230222  {
    231     fprintf(stderr, "\nfailed to open bitstream file `%s' for reading\n", m_pchBitstreamFile);
     223    fprintf(stderr, "\nfailed to open bitstream file `%s' for reading\n", m_bitstreamFileName.c_str());
    232224    exit(EXIT_FAILURE);
    233225  }
     
    250242
    251243  m_iPOCLastDisplay += m_iSkipFrame;      // set the last displayed POC correctly for skip forward.
     244
     245  // clear contents of colour-remap-information-SEI output file
     246  if (!m_colourRemapSEIFileName.empty())
     247  {
     248    std::ofstream ofile(m_colourRemapSEIFileName.c_str());
     249    if (!ofile.good() || !ofile.is_open())
     250    {
     251      fprintf(stderr, "\nUnable to open file '%s' for writing colour-remap-information-SEI video\n", m_colourRemapSEIFileName.c_str());
     252      exit(EXIT_FAILURE);
     253    }
     254  }
    252255
    253256  // main decoder loop
     
    336339    if( pcListPic )
    337340    {
    338       if ( m_pchReconFile && !openedReconFile )
     341      if ( (!m_reconFileName.empty()) && (!openedReconFile) )
    339342      {
    340343        const BitDepths &bitDepths=pcListPic->front()->getPicSym()->getSPS().getBitDepths(); // use bit depths of first reconstructed picture.
     
    346349          }
    347350        }
    348         m_cTVideoIOYuvReconFile.open( m_pchReconFile, true, m_outputBitDepth, m_outputBitDepth, bitDepths.recon ); // write mode
     351
     352        m_cTVideoIOYuvReconFile.open( m_reconFileName, true, m_outputBitDepth, m_outputBitDepth, bitDepths.recon ); // write mode
    349353        openedReconFile = true;
    350354      }
     
    436440  }
    437441#else
    438   if ( m_pchReconFile )
     442  if ( !m_reconFileName.empty() )
    439443  {
    440444    m_cTVideoIOYuvReconFile. close();
     
    444448  m_cTDecTop.destroy();
    445449#endif
     450  if (m_pcSeiColourRemappingInfoPrevious != NULL)
     451  {
     452    delete m_pcSeiColourRemappingInfoPrevious;
     453    m_pcSeiColourRemappingInfoPrevious = NULL;
     454  }
    446455#if NH_3D
    447456  m_cCamParsCollector.uninit();
     
    474483  }
    475484#endif
     485  if (m_pcSeiColourRemappingInfoPrevious != NULL)
     486  {
     487    delete m_pcSeiColourRemappingInfoPrevious;
     488    m_pcSeiColourRemappingInfoPrevious = NULL;
     489  }
    476490}
    477491
     
    549563        // write to file
    550564        numPicsNotYetDisplayed = numPicsNotYetDisplayed-2;
    551         if ( m_pchReconFile )
     565        if ( !m_reconFileName.empty() )
    552566        {
    553567          const Window &conf = pcPicTop->getConformanceWindow();
     
    617631          dpbFullness--;
    618632        }
    619         if ( m_pchReconFile )
     633        if ( !m_reconFileName.empty() )
    620634        {
    621635          const Window &conf    = pcPic->getConformanceWindow();
     
    631645        }
    632646
     647        if (!m_colourRemapSEIFileName.empty())
     648        {
     649          xOutputColourRemapPic(pcPic);
     650        }
     651
    633652        // update POC of display order
    634653        m_iPOCLastDisplay = pcPic->getPOC();
     
    678697        // write to file
    679698
    680         if ( m_pchReconFile )
     699        if ( !m_reconFileName.empty() )
    681700        {
    682701          const Window &conf = pcPicTop->getConformanceWindow();
     
    736755      {
    737756        // write to file
    738         if ( m_pchReconFile )
     757        if ( !m_reconFileName.empty() )
    739758        {
    740759          const Window &conf    = pcPic->getConformanceWindow();
     
    747766                                         conf.getWindowBottomOffset() + defDisp.getWindowBottomOffset(),
    748767                                         NUM_CHROMA_FORMAT, m_bClipOutputVideoToRec709Range );
     768        }
     769
     770        if (!m_colourRemapSEIFileName.empty())
     771        {
     772          xOutputColourRemapPic(pcPic);
    749773        }
    750774
     
    26712695
    26722696    // create recon file related stuff
    2673     Char* pchTempFilename = NULL;
    2674     if ( m_pchReconFile )
    2675     {
    2676       Char buffer[4];
     2697    TChar* pchTempFilename = NULL;
     2698    if ( !m_reconFileName.empty() )
     2699    {
     2700      TChar buffer[4];
    26772701      sprintf(buffer,"_%i", layerId );
    2678       assert ( m_pchReconFile );
    2679       xAppendToFileNameEnd( m_pchReconFile , buffer, pchTempFilename );
     2702      assert ( !m_reconFileName.empty() );
     2703      xAppendToFileNameEnd( m_reconFileName.c_str() , buffer, pchTempFilename );
    26802704      assert( m_pchReconFiles.size() == m_numDecoders );
    26812705    }
     
    28702894Void TAppDecTop::xInitFileIO()
    28712895{
    2872   m_bitstreamFile.open(m_pchBitstreamFile, ifstream::in | ifstream::binary);
     2896  m_bitstreamFile.open(m_bitstreamFileName.c_str(), ifstream::in | ifstream::binary);
    28732897
    28742898  if ( !m_bitstreamFile)
    28752899  {
    2876     fprintf(stderr, "\nUnable to open bitstream file `%s' for reading\n", m_pchBitstreamFile);
     2900    fprintf(stderr, "\nUnable to open bitstream file `%s' for reading\n", m_bitstreamFileName.c_str());
    28772901    exit(EXIT_FAILURE);
    28782902  }
     
    29052929  Int decIdx = xGetDecoderIdx( curPic->getLayerId() );
    29062930
    2907   if ( m_pchReconFile && !m_reconOpen[decIdx] )
     2931  if ( !m_reconFileName.empty() && !m_reconOpen[decIdx] )
    29082932  {
    29092933    const BitDepths &bitDepths= curPic->getPicSym()->getSPS().getBitDepths(); // use bit depths of first reconstructed picture.
     
    30073031
    30083032#endif
     3033
     3034Void TAppDecTop::xOutputColourRemapPic(TComPic* pcPic)
     3035{
     3036  const TComSPS &sps=pcPic->getPicSym()->getSPS();
     3037  SEIMessages colourRemappingInfo = getSeisByType(pcPic->getSEIs(), SEI::COLOUR_REMAPPING_INFO );
     3038  SEIColourRemappingInfo *seiColourRemappingInfo = ( colourRemappingInfo.size() > 0 ) ? (SEIColourRemappingInfo*) *(colourRemappingInfo.begin()) : NULL;
     3039
     3040  if (colourRemappingInfo.size() > 1)
     3041  {
     3042    printf ("Warning: Got multiple Colour Remapping Information SEI messages. Using first.");
     3043  }
     3044  if (seiColourRemappingInfo)
     3045  {
     3046    applyColourRemapping(*pcPic->getPicYuvRec(), *seiColourRemappingInfo, sps);
     3047
     3048    // save the last CRI SEI received
     3049    if (m_pcSeiColourRemappingInfoPrevious == NULL)
     3050    {
     3051      m_pcSeiColourRemappingInfoPrevious = new SEIColourRemappingInfo();
     3052    }
     3053    m_pcSeiColourRemappingInfoPrevious->copyFrom(*seiColourRemappingInfo);
     3054  }
     3055  else  // using the last CRI SEI received
     3056  {
     3057    // TODO: prevent persistence of CRI SEI across C(L)VS.
     3058    if (m_pcSeiColourRemappingInfoPrevious != NULL)
     3059    {
     3060      if (m_pcSeiColourRemappingInfoPrevious->m_colourRemapPersistenceFlag == false)
     3061      {
     3062        printf("Warning No SEI-CRI message is present for the current picture, persistence of the CRI is not managed\n");
     3063      }
     3064      applyColourRemapping(*pcPic->getPicYuvRec(), *m_pcSeiColourRemappingInfoPrevious, sps);
     3065    }
     3066  }
     3067}
     3068
     3069// compute lut from SEI
     3070// use at lutPoints points aligned on a power of 2 value
     3071// SEI Lut must be in ascending values of coded Values
     3072static std::vector<Int>
     3073initColourRemappingInfoLut(const Int                                          bitDepth_in,     // bit-depth of the input values of the LUT
     3074                           const Int                                          nbDecimalValues, // Position of the fixed point
     3075                           const std::vector<SEIColourRemappingInfo::CRIlut> &lut,
     3076                           const Int                                          maxValue, // maximum output value
     3077                           const Int                                          lutOffset)
     3078{
     3079  const Int lutPoints = (1 << bitDepth_in) + 1 ;
     3080  std::vector<Int> retLut(lutPoints);
     3081
     3082  // missing values: need to define default values before first definition (check codedValue[0] == 0)
     3083  Int iTargetPrev = (lut.size() && lut[0].codedValue == 0) ? lut[0].targetValue: 0;
     3084  Int startPivot = (lut.size())? ((lut[0].codedValue == 0)? 1: 0): 1;
     3085  Int iCodedPrev  = 0;
     3086  // set max value with the coded bit-depth
     3087  // + ((1 << nbDecimalValues) - 1) is for the added bits
     3088  const Int maxValueFixedPoint = (maxValue << nbDecimalValues) + ((1 << nbDecimalValues) - 1);
     3089
     3090  Int iValue = 0;
     3091
     3092  for ( Int iPivot=startPivot ; iPivot < (Int)lut.size(); iPivot++ )
     3093  {
     3094    Int iCodedNext  = lut[iPivot].codedValue;
     3095    Int iTargetNext = lut[iPivot].targetValue;
     3096
     3097    // ensure correct bit depth and avoid overflow in lut address
     3098    Int iCodedNext_bitDepth = std::min(iCodedNext, (1 << bitDepth_in));
     3099
     3100    const Int divValue =  (iCodedNext - iCodedPrev > 0)? (iCodedNext - iCodedPrev): 1;
     3101    const Int lutValInit = (lutOffset + iTargetPrev) << nbDecimalValues;
     3102    const Int roundValue = divValue / 2;
     3103    for ( ; iValue<iCodedNext_bitDepth; iValue++ )
     3104    {
     3105      Int value = iValue;
     3106      Int interpol = ((((value-iCodedPrev) * (iTargetNext - iTargetPrev)) << nbDecimalValues) + roundValue) / divValue;               
     3107      retLut[iValue]  = std::min(lutValInit + interpol , maxValueFixedPoint);
     3108    }
     3109    iCodedPrev  = iCodedNext;
     3110    iTargetPrev = iTargetNext;
     3111  }
     3112  // fill missing values if necessary
     3113  if(iCodedPrev < (1 << bitDepth_in)+1)
     3114  {
     3115    Int iCodedNext  = (1 << bitDepth_in);
     3116    Int iTargetNext = (1 << bitDepth_in) - 1;
     3117
     3118    const Int divValue =  (iCodedNext - iCodedPrev > 0)? (iCodedNext - iCodedPrev): 1;
     3119    const Int lutValInit = (lutOffset + iTargetPrev) << nbDecimalValues;
     3120    const Int roundValue = divValue / 2;
     3121
     3122    for ( ; iValue<=iCodedNext; iValue++ )
     3123    {
     3124      Int value = iValue;
     3125      Int interpol = ((((value-iCodedPrev) * (iTargetNext - iTargetPrev)) << nbDecimalValues) + roundValue) / divValue;
     3126      retLut[iValue]  = std::min(lutValInit + interpol , maxValueFixedPoint);
     3127    }
     3128  }
     3129  return retLut;
     3130}
     3131
     3132static Void
     3133initColourRemappingInfoLuts(std::vector<Int>      (&preLut)[3],
     3134                            std::vector<Int>      (&postLut)[3],
     3135                            SEIColourRemappingInfo &pCriSEI,
     3136                            const Int               maxBitDepth)
     3137{
     3138  Int internalBitDepth = pCriSEI.m_colourRemapBitDepth;
     3139  for ( Int c=0 ; c<3 ; c++ )
     3140  {
     3141    std::sort(pCriSEI.m_preLut[c].begin(), pCriSEI.m_preLut[c].end()); // ensure preLut is ordered in ascending values of codedValues   
     3142    preLut[c] = initColourRemappingInfoLut(pCriSEI.m_colourRemapInputBitDepth, maxBitDepth - pCriSEI.m_colourRemapInputBitDepth, pCriSEI.m_preLut[c], ((1 << internalBitDepth) - 1), 0); //Fill preLut
     3143
     3144    std::sort(pCriSEI.m_postLut[c].begin(), pCriSEI.m_postLut[c].end()); // ensure postLut is ordered in ascending values of codedValues       
     3145    postLut[c] = initColourRemappingInfoLut(pCriSEI.m_colourRemapBitDepth, maxBitDepth - pCriSEI.m_colourRemapBitDepth, pCriSEI.m_postLut[c], (1 << internalBitDepth) - 1, 0); //Fill postLut
     3146  }
     3147}
     3148
     3149// apply lut.
     3150// Input lut values are aligned on power of 2 boundaries
     3151static Int
     3152applyColourRemappingInfoLut1D(Int inVal, const std::vector<Int> &lut, const Int inValPrecisionBits)
     3153{
     3154  const Int roundValue = (inValPrecisionBits)? 1 << (inValPrecisionBits - 1): 0;
     3155  inVal = std::min(std::max(0, inVal), (Int)(((lut.size()-1) << inValPrecisionBits)));
     3156  Int index  = (Int) std::min((inVal >> inValPrecisionBits), (Int)(lut.size()-2));
     3157  Int outVal = (( inVal - (index<<inValPrecisionBits) ) * (lut[index+1] - lut[index]) + roundValue) >> inValPrecisionBits;
     3158  outVal +=  lut[index] ;
     3159
     3160  return outVal;
     3161
     3162
     3163static Int
     3164applyColourRemappingInfoMatrix(const Int (&colourRemapCoeffs)[3], const Int postOffsetShift, const Int p0, const Int p1, const Int p2, const Int offset)
     3165{
     3166  Int YUVMat = (colourRemapCoeffs[0]* p0 + colourRemapCoeffs[1]* p1 + colourRemapCoeffs[2]* p2  + offset) >> postOffsetShift;
     3167  return YUVMat;
     3168}
     3169
     3170static Void
     3171setColourRemappingInfoMatrixOffset(Int (&matrixOffset)[3], Int offset0, Int offset1, Int offset2)
     3172{
     3173  matrixOffset[0] = offset0;
     3174  matrixOffset[1] = offset1;
     3175  matrixOffset[2] = offset2;
     3176}
     3177
     3178static Void
     3179setColourRemappingInfoMatrixOffsets(      Int  (&matrixInputOffset)[3],
     3180                                          Int  (&matrixOutputOffset)[3],
     3181                                    const Int  bitDepth,
     3182                                    const Bool crInputFullRangeFlag,
     3183                                    const Int  crInputMatrixCoefficients,
     3184                                    const Bool crFullRangeFlag,
     3185                                    const Int  crMatrixCoefficients)
     3186{
     3187  // set static matrix offsets
     3188  Int crInputOffsetLuma = (crInputFullRangeFlag)? 0:-(16 << (bitDepth-8));
     3189  Int crOffsetLuma = (crFullRangeFlag)? 0:(16 << (bitDepth-8));
     3190  Int crInputOffsetChroma = 0;
     3191  Int crOffsetChroma = 0;
     3192
     3193  switch(crInputMatrixCoefficients)
     3194  {
     3195    case MATRIX_COEFFICIENTS_RGB:
     3196      crInputOffsetChroma = 0;
     3197      if(!crInputFullRangeFlag)
     3198      {
     3199        fprintf(stderr, "WARNING: crInputMatrixCoefficients set to MATRIX_COEFFICIENTS_RGB and crInputFullRangeFlag not set\n");
     3200        crInputOffsetLuma = 0;
     3201      }
     3202      break;
     3203    case MATRIX_COEFFICIENTS_UNSPECIFIED:
     3204    case MATRIX_COEFFICIENTS_BT709:
     3205    case MATRIX_COEFFICIENTS_BT2020_NON_CONSTANT_LUMINANCE:
     3206      crInputOffsetChroma = -(1 << (bitDepth-1));
     3207      break;
     3208    default:
     3209      fprintf(stderr, "WARNING: crInputMatrixCoefficients set to undefined value: %d\n", crInputMatrixCoefficients);
     3210  }
     3211
     3212  switch(crMatrixCoefficients)
     3213  {
     3214    case MATRIX_COEFFICIENTS_RGB:
     3215      crOffsetChroma = 0;
     3216      if(!crFullRangeFlag)
     3217      {
     3218        fprintf(stderr, "WARNING: crMatrixCoefficients set to MATRIX_COEFFICIENTS_RGB and crInputFullRangeFlag not set\n");
     3219        crOffsetLuma = 0;
     3220      }
     3221      break;
     3222    case MATRIX_COEFFICIENTS_UNSPECIFIED:
     3223    case MATRIX_COEFFICIENTS_BT709:
     3224    case MATRIX_COEFFICIENTS_BT2020_NON_CONSTANT_LUMINANCE:
     3225      crOffsetChroma = (1 << (bitDepth-1));
     3226      break;
     3227    default:
     3228      fprintf(stderr, "WARNING: crMatrixCoefficients set to undefined value: %d\n", crMatrixCoefficients);
     3229  }
     3230
     3231  setColourRemappingInfoMatrixOffset(matrixInputOffset, crInputOffsetLuma, crInputOffsetChroma, crInputOffsetChroma);
     3232  setColourRemappingInfoMatrixOffset(matrixOutputOffset, crOffsetLuma, crOffsetChroma, crOffsetChroma);
     3233}
     3234
     3235Void TAppDecTop::applyColourRemapping(const TComPicYuv& pic, SEIColourRemappingInfo& criSEI, const TComSPS &activeSPS)
     3236
     3237  const Int maxBitDepth = 16;
     3238
     3239  // create colour remapped picture
     3240  if( !criSEI.m_colourRemapCancelFlag && pic.getChromaFormat()!=CHROMA_400) // 4:0:0 not supported.
     3241  {
     3242    const Int          iHeight         = pic.getHeight(COMPONENT_Y);
     3243    const Int          iWidth          = pic.getWidth(COMPONENT_Y);
     3244    const ChromaFormat chromaFormatIDC = pic.getChromaFormat();
     3245
     3246    TComPicYuv picYuvColourRemapped;
     3247    picYuvColourRemapped.createWithoutCUInfo( iWidth, iHeight, chromaFormatIDC );
     3248
     3249    const Int  iStrideIn   = pic.getStride(COMPONENT_Y);
     3250    const Int  iCStrideIn  = pic.getStride(COMPONENT_Cb);
     3251    const Int  iStrideOut  = picYuvColourRemapped.getStride(COMPONENT_Y);
     3252    const Int  iCStrideOut = picYuvColourRemapped.getStride(COMPONENT_Cb);
     3253    const Bool b444        = ( pic.getChromaFormat() == CHROMA_444 );
     3254    const Bool b422        = ( pic.getChromaFormat() == CHROMA_422 );
     3255    const Bool b420        = ( pic.getChromaFormat() == CHROMA_420 );
     3256
     3257    std::vector<Int> preLut[3];
     3258    std::vector<Int> postLut[3];
     3259    Int matrixInputOffset[3];
     3260    Int matrixOutputOffset[3];
     3261    const Pel *YUVIn[MAX_NUM_COMPONENT];
     3262    Pel *YUVOut[MAX_NUM_COMPONENT];
     3263    YUVIn[COMPONENT_Y]  = pic.getAddr(COMPONENT_Y);
     3264    YUVIn[COMPONENT_Cb] = pic.getAddr(COMPONENT_Cb);
     3265    YUVIn[COMPONENT_Cr] = pic.getAddr(COMPONENT_Cr);
     3266    YUVOut[COMPONENT_Y]  = picYuvColourRemapped.getAddr(COMPONENT_Y);
     3267    YUVOut[COMPONENT_Cb] = picYuvColourRemapped.getAddr(COMPONENT_Cb);
     3268    YUVOut[COMPONENT_Cr] = picYuvColourRemapped.getAddr(COMPONENT_Cr);
     3269
     3270    const Int bitDepth = criSEI.m_colourRemapBitDepth;
     3271    BitDepths        bitDepthsCriFile;
     3272    bitDepthsCriFile.recon[CHANNEL_TYPE_LUMA]   = bitDepth;
     3273    bitDepthsCriFile.recon[CHANNEL_TYPE_CHROMA] = bitDepth; // Different bitdepth is not implemented
     3274
     3275    const Int postOffsetShift = criSEI.m_log2MatrixDenom;
     3276    const Int matrixRound = 1 << (postOffsetShift - 1);
     3277    const Int postLutInputPrecision = (maxBitDepth - criSEI.m_colourRemapBitDepth);
     3278
     3279    if ( ! criSEI.m_colourRemapVideoSignalInfoPresentFlag ) // setting default
     3280    {
     3281      setColourRemappingInfoMatrixOffsets(matrixInputOffset, matrixOutputOffset, maxBitDepth,
     3282          activeSPS.getVuiParameters()->getVideoFullRangeFlag(), activeSPS.getVuiParameters()->getMatrixCoefficients(),
     3283          activeSPS.getVuiParameters()->getVideoFullRangeFlag(), activeSPS.getVuiParameters()->getMatrixCoefficients());
     3284    }
     3285    else
     3286    {
     3287      setColourRemappingInfoMatrixOffsets(matrixInputOffset, matrixOutputOffset, maxBitDepth,
     3288          activeSPS.getVuiParameters()->getVideoFullRangeFlag(), activeSPS.getVuiParameters()->getMatrixCoefficients(),
     3289          criSEI.m_colourRemapFullRangeFlag, criSEI.m_colourRemapMatrixCoefficients);
     3290    }
     3291
     3292    // add matrix rounding to output matrix offsets
     3293    matrixOutputOffset[0] = (matrixOutputOffset[0] << postOffsetShift) + matrixRound;
     3294    matrixOutputOffset[1] = (matrixOutputOffset[1] << postOffsetShift) + matrixRound;
     3295    matrixOutputOffset[2] = (matrixOutputOffset[2] << postOffsetShift) + matrixRound;
     3296
     3297    // Merge   matrixInputOffset and matrixOutputOffset to matrixOutputOffset
     3298    matrixOutputOffset[0] += applyColourRemappingInfoMatrix(criSEI.m_colourRemapCoeffs[0], 0, matrixInputOffset[0], matrixInputOffset[1], matrixInputOffset[2], 0);
     3299    matrixOutputOffset[1] += applyColourRemappingInfoMatrix(criSEI.m_colourRemapCoeffs[1], 0, matrixInputOffset[0], matrixInputOffset[1], matrixInputOffset[2], 0);
     3300    matrixOutputOffset[2] += applyColourRemappingInfoMatrix(criSEI.m_colourRemapCoeffs[2], 0, matrixInputOffset[0], matrixInputOffset[1], matrixInputOffset[2], 0);
     3301
     3302    // rescaling output: include CRI/output frame difference
     3303    const Int scaleShiftOut_neg = abs(bitDepth - maxBitDepth);
     3304    const Int scaleOut_round = 1 << (scaleShiftOut_neg-1);
     3305
     3306    initColourRemappingInfoLuts(preLut, postLut, criSEI, maxBitDepth);
     3307
     3308    assert(pic.getChromaFormat() != CHROMA_400);
     3309    const Int hs = pic.getComponentScaleX(ComponentID(COMPONENT_Cb));
     3310    const Int maxOutputValue = (1 << bitDepth) - 1;
     3311
     3312    for( Int y = 0; y < iHeight; y++ )
     3313    {
     3314      for( Int x = 0; x < iWidth; x++ )
     3315      {
     3316        const Int xc = (x>>hs);
     3317        Bool computeChroma = b444 || ((b422 || !(y&1)) && !(x&1));
     3318
     3319        Int YUVPre_0 = applyColourRemappingInfoLut1D(YUVIn[COMPONENT_Y][x], preLut[0], 0);
     3320        Int YUVPre_1 = applyColourRemappingInfoLut1D(YUVIn[COMPONENT_Cb][xc], preLut[1], 0);
     3321        Int YUVPre_2 = applyColourRemappingInfoLut1D(YUVIn[COMPONENT_Cr][xc], preLut[2], 0);
     3322
     3323        Int YUVMat_0 = applyColourRemappingInfoMatrix(criSEI.m_colourRemapCoeffs[0], postOffsetShift, YUVPre_0, YUVPre_1, YUVPre_2, matrixOutputOffset[0]);
     3324        Int YUVLutB_0 = applyColourRemappingInfoLut1D(YUVMat_0, postLut[0], postLutInputPrecision);
     3325        YUVOut[COMPONENT_Y][x] = std::min(maxOutputValue, (YUVLutB_0 + scaleOut_round) >> scaleShiftOut_neg);
     3326
     3327        if( computeChroma )
     3328        {
     3329          Int YUVMat_1 = applyColourRemappingInfoMatrix(criSEI.m_colourRemapCoeffs[1], postOffsetShift, YUVPre_0, YUVPre_1, YUVPre_2, matrixOutputOffset[1]);
     3330          Int YUVLutB_1 = applyColourRemappingInfoLut1D(YUVMat_1, postLut[1], postLutInputPrecision);
     3331          YUVOut[COMPONENT_Cb][xc] = std::min(maxOutputValue, (YUVLutB_1 + scaleOut_round) >> scaleShiftOut_neg);
     3332
     3333          Int YUVMat_2 = applyColourRemappingInfoMatrix(criSEI.m_colourRemapCoeffs[2], postOffsetShift, YUVPre_0, YUVPre_1, YUVPre_2, matrixOutputOffset[2]);
     3334          Int YUVLutB_2 = applyColourRemappingInfoLut1D(YUVMat_2, postLut[2], postLutInputPrecision);
     3335          YUVOut[COMPONENT_Cr][xc] = std::min(maxOutputValue, (YUVLutB_2 + scaleOut_round) >> scaleShiftOut_neg);
     3336        }
     3337      }
     3338
     3339      YUVIn[COMPONENT_Y]  += iStrideIn;
     3340      YUVOut[COMPONENT_Y] += iStrideOut;
     3341      if( !(b420 && !(y&1)) )
     3342      {
     3343         YUVIn[COMPONENT_Cb]  += iCStrideIn;
     3344         YUVIn[COMPONENT_Cr]  += iCStrideIn;
     3345         YUVOut[COMPONENT_Cb] += iCStrideOut;
     3346         YUVOut[COMPONENT_Cr] += iCStrideOut;
     3347      }
     3348    }
     3349    //Write remapped picture in display order
     3350    picYuvColourRemapped.dump( m_colourRemapSEIFileName, bitDepthsCriFile, true );
     3351    picYuvColourRemapped.destroy();
     3352  }
     3353}
    30093354//! \}
  • branches/HTM-15.2-dev/source/App/TAppDecoder/TAppDecTop.h

    r1321 r1360  
    128128#endif
    129129  std::ofstream                   m_seiMessageFileStream;         ///< Used for outputing SEI messages. 
     130
     131  SEIColourRemappingInfo*         m_pcSeiColourRemappingInfoPrevious;
     132
    130133public:
    131134  TAppDecTop();
     
    206209  Void  xCropAndOutput                     ( TComPic* curPic ); 
    207210#endif
     211
     212private:
     213  Void applyColourRemapping(const TComPicYuv& pic, SEIColourRemappingInfo& pCriSEI, const TComSPS &activeSPS);
     214  Void xOutputColourRemapPic(TComPic* pcPic);
    208215};
    209216
  • branches/HTM-15.2-dev/source/App/TAppEncoder/TAppEncCfg.cpp

    r1356 r1360  
    109109
    110110TAppEncCfg::TAppEncCfg()
    111 #if NH_MV
    112 : m_pchBitstreamFile()
    113 #else
    114 : m_pchInputFile()
    115 , m_pchBitstreamFile()
    116 , m_pchReconFile()
    117 #endif
    118 , m_inputColourSpaceConvert(IPCOLOURSPACE_UNCHANGED)
     111: m_inputColourSpaceConvert(IPCOLOURSPACE_UNCHANGED)
    119112, m_snrInternalColourSpace(false)
    120113, m_outputInternalColourSpace(false)
    121 , m_pchdQPFile()
    122 , m_scalingListFile()
    123114{
    124115#if !NH_MV
     
    171162    m_targetPivotValue = NULL;
    172163  }
    173 #if !NH_MV
    174   free(m_pchInputFile);
    175 #endif
    176   free(m_pchBitstreamFile);
    177164#if NH_MV
    178165  for(Int i = 0; i< m_pchReconFileList.size(); i++ )
     
    181168      free (m_pchReconFileList[i]);
    182169  }
    183 #else
    184   free(m_pchReconFile);
    185 #endif
    186   free(m_pchdQPFile);
    187   free(m_scalingListFile);
    188 #if NH_MV
     170
    189171  for( Int i = 0; i < m_GOPListMvc.size(); i++ )
    190172  {
     
    196178  }
    197179#endif
     180
    198181#if NH_3D
    199182#if NH_3D_VSO
     
    302285}
    303286
    304 Bool confirmPara(Bool bflag, const Char* message);
     287Bool confirmPara(Bool bflag, const TChar* message);
    305288
    306289static inline ChromaFormat numberToChromaFormat(const Int val)
     
    318301static const struct MapStrToProfile
    319302{
    320   const Char* str;
     303  const TChar* str;
    321304  Profile::Name value;
    322305}
     
    340323static const struct MapStrToExtendedProfile
    341324{
    342   const Char* str;
     325  const TChar* str;
    343326  ExtendedProfileName value;
    344327}
     
    405388static const struct MapStrToTier
    406389{
    407   const Char* str;
     390  const TChar* str;
    408391  Level::Tier value;
    409392}
     
    416399static const struct MapStrToLevel
    417400{
    418   const Char* str;
     401  const TChar* str;
    419402  Level::Name value;
    420403}
     
    438421};
    439422
     423#if U0132_TARGET_BITS_SATURATION
     424UInt g_uiMaxCpbSize[2][21] =
     425{
     426  //         LEVEL1,        LEVEL2,LEVEL2_1,     LEVEL3, LEVEL3_1,      LEVEL4, LEVEL4_1,       LEVEL5,  LEVEL5_1,  LEVEL5_2,    LEVEL6,  LEVEL6_1,  LEVEL6_2
     427  { 0, 0, 0, 350000, 0, 0, 1500000, 3000000, 0, 6000000, 10000000, 0, 12000000, 20000000, 0,  25000000,  40000000,  60000000,  60000000, 120000000, 240000000 },
     428  { 0, 0, 0,      0, 0, 0,       0,       0, 0,       0,        0, 0, 30000000, 50000000, 0, 100000000, 160000000, 240000000, 240000000, 480000000, 800000000 }
     429};
     430#endif
     431
    440432static const struct MapStrToCostMode
    441433{
    442   const Char* str;
     434  const TChar* str;
    443435  CostMode    value;
    444436}
     
    453445static const struct MapStrToScalingListMode
    454446{
    455   const Char* str;
     447  const TChar* str;
    456448  ScalingListMode value;
    457449}
     
    533525{
    534526  const T              minValIncl;
    535   const T              maxValIncl; // Use 0 for unlimited
     527  const T              maxValIncl;
    536528  const std::size_t    minNumValuesIncl;
    537529  const std::size_t    maxNumValuesIncl; // Use 0 for unlimited
     
    545537  SMultiValueInput<T> &operator=(const std::vector<T> &userValues) { values=userValues; return *this; }
    546538  SMultiValueInput<T> &operator=(const SMultiValueInput<T> &userValues) { values=userValues.values; return *this; }
     539
     540  T readValue(const TChar *&pStr, Bool &bSuccess);
     541
     542  istream& readValues(std::istream &in);
    547543};
    548544
    549 static inline istream& operator >> (istream &in, SMultiValueInput<UInt> &values)
     545template <class T>
     546static inline istream& operator >> (std::istream &in, SMultiValueInput<T> &values)
    550547{
    551   values.values.clear();
     548  return values.readValues(in);
     549  }
     550
     551template<>
     552UInt SMultiValueInput<UInt>::readValue(const TChar *&pStr, Bool &bSuccess)
     553    {
     554  TChar *eptr;
     555      UInt val=strtoul(pStr, &eptr, 0);
     556  pStr=eptr;
     557  bSuccess=!(*eptr!=0 && !isspace(*eptr) && *eptr!=',') && !(val<minValIncl || val>maxValIncl);
     558  return val;
     559      }
     560
     561template<>
     562Int SMultiValueInput<Int>::readValue(const TChar *&pStr, Bool &bSuccess)
     563      {
     564  TChar *eptr;
     565  Int val=strtol(pStr, &eptr, 0);
     566      pStr=eptr;
     567  bSuccess=!(*eptr!=0 && !isspace(*eptr) && *eptr!=',') && !(val<minValIncl || val>maxValIncl);
     568  return val;
     569}
     570
     571template<>
     572Double SMultiValueInput<Double>::readValue(const TChar *&pStr, Bool &bSuccess)
     573  {
     574  TChar *eptr;
     575  Double val=strtod(pStr, &eptr);
     576  pStr=eptr;
     577  bSuccess=!(*eptr!=0 && !isspace(*eptr) && *eptr!=',') && !(val<minValIncl || val>maxValIncl);
     578  return val;
     579  }
     580
     581template<>
     582Bool SMultiValueInput<Bool>::readValue(const TChar *&pStr, Bool &bSuccess)
     583    {
     584  TChar *eptr;
     585      Int val=strtol(pStr, &eptr, 0);
     586      pStr=eptr;
     587  bSuccess=!(*eptr!=0 && !isspace(*eptr) && *eptr!=',') && !(val<Int(minValIncl) || val>Int(maxValIncl));
     588  return val!=0;
     589}
     590
     591template <class T>
     592istream& SMultiValueInput<T>::readValues(std::istream &in)
     593{
     594  values.clear();
    552595  string str;
    553596  while (!in.eof())
     
    557600  if (!str.empty())
    558601  {
    559     const Char *pStr=str.c_str();
     602    const TChar *pStr=str.c_str();
    560603    // soak up any whitespace
    561604    for(;isspace(*pStr);pStr++);
     
    563606    while (*pStr != 0)
    564607    {
    565       Char *eptr;
    566       UInt val=strtoul(pStr, &eptr, 0);
    567       if (*eptr!=0 && !isspace(*eptr) && *eptr!=',')
     608      Bool bSuccess=true;
     609      T val=readValue(pStr, bSuccess);
     610      if (!bSuccess)
    568611      {
    569612        in.setstate(ios::failbit);
    570613        break;
    571614      }
    572       if (val<values.minValIncl || val>values.maxValIncl)
     615
     616      if (maxNumValuesIncl != 0 && values.size() >= maxNumValuesIncl)
    573617      {
    574618        in.setstate(ios::failbit);
    575619        break;
    576620      }
    577 
    578       if (values.maxNumValuesIncl != 0 && values.values.size() >= values.maxNumValuesIncl)
    579       {
    580         in.setstate(ios::failbit);
    581         break;
    582       }
    583       values.values.push_back(val);
     621      values.push_back(val);
    584622      // soak up any whitespace and up to 1 comma.
    585       pStr=eptr;
    586623      for(;isspace(*pStr);pStr++);
    587624      if (*pStr == ',')
     
    592629    }
    593630  }
    594   if (values.values.size() < values.minNumValuesIncl)
    595   {
    596     in.setstate(ios::failbit);
    597   }
    598   return in;
    599 }
    600 
    601 static inline istream& operator >> (istream &in, SMultiValueInput<Int> &values)
    602 {
    603   values.values.clear();
    604   string str;
    605   while (!in.eof())
    606   {
    607     string tmp; in >> tmp; str+=" " + tmp;
    608   }
    609   if (!str.empty())
    610   {
    611     const Char *pStr=str.c_str();
    612     // soak up any whitespace
    613     for(;isspace(*pStr);pStr++);
    614 
    615     while (*pStr != 0)
    616     {
    617       Char *eptr;
    618       Int val=strtol(pStr, &eptr, 0);
    619       if (*eptr!=0 && !isspace(*eptr) && *eptr!=',')
    620       {
    621         in.setstate(ios::failbit);
    622         break;
    623       }
    624       if (val<values.minValIncl || val>values.maxValIncl)
    625       {
    626         in.setstate(ios::failbit);
    627         break;
    628       }
    629 
    630       if (values.maxNumValuesIncl != 0 && values.values.size() >= values.maxNumValuesIncl)
    631       {
    632         in.setstate(ios::failbit);
    633         break;
    634       }
    635       values.values.push_back(val);
    636       // soak up any whitespace and up to 1 comma.
    637       pStr=eptr;
    638       for(;isspace(*pStr);pStr++);
    639       if (*pStr == ',')
    640       {
    641         pStr++;
    642       }
    643       for(;isspace(*pStr);pStr++);
    644     }
    645   }
    646   if (values.values.size() < values.minNumValuesIncl)
    647   {
    648     in.setstate(ios::failbit);
    649   }
    650   return in;
    651 }
    652 
    653 static inline istream& operator >> (istream &in, SMultiValueInput<Bool> &values)
    654 {
    655   values.values.clear();
    656   string str;
    657   while (!in.eof())
    658   {
    659     string tmp; in >> tmp; str+=" " + tmp;
    660   }
    661   if (!str.empty())
    662   {
    663     const Char *pStr=str.c_str();
    664     // soak up any whitespace
    665     for(;isspace(*pStr);pStr++);
    666 
    667     while (*pStr != 0)
    668     {
    669       Char *eptr;
    670       Int val=strtol(pStr, &eptr, 0);
    671       if (*eptr!=0 && !isspace(*eptr) && *eptr!=',')
    672       {
    673         in.setstate(ios::failbit);
    674         break;
    675       }
    676       if (val<Int(values.minValIncl) || val>Int(values.maxValIncl))
    677       {
    678         in.setstate(ios::failbit);
    679         break;
    680       }
    681 
    682       if (values.maxNumValuesIncl != 0 && values.values.size() >= values.maxNumValuesIncl)
    683       {
    684         in.setstate(ios::failbit);
    685         break;
    686       }
    687       values.values.push_back(val!=0);
    688       // soak up any whitespace and up to 1 comma.
    689       pStr=eptr;
    690       for(;isspace(*pStr);pStr++);
    691       if (*pStr == ',')
    692       {
    693         pStr++;
    694       }
    695       for(;isspace(*pStr);pStr++);
    696     }
    697   }
    698   if (values.values.size() < values.minNumValuesIncl)
     631  if (values.size() < minNumValuesIncl)
    699632  {
    700633    in.setstate(ios::failbit);
     
    786719    \retval             true when success
    787720 */
    788 Bool TAppEncCfg::parseCfg( Int argc, Char* argv[] )
     721Bool TAppEncCfg::parseCfg( Int argc, TChar* argv[] )
    789722{
    790723  Bool do_help = false;
     
    815748  Int tmpInputChromaFormat;
    816749  Int tmpConstraintChromaFormat;
     750  Int tmpWeightedPredictionMethod;
     751  Int tmpFastInterSearchMode;
     752  Int tmpMotionEstimationSearchMethod;
     753  Int tmpSliceMode;
     754  Int tmpSliceSegmentMode;
     755  Int tmpDecodedPictureHashSEIMappedType;
    817756  string inputColourSpaceConvert;
    818757#if NH_MV
     
    829768  SMultiValueInput<Int>  cfg_codedPivotValue                 (std::numeric_limits<Int>::min(), std::numeric_limits<Int>::max(), 0, 1<<16);
    830769  SMultiValueInput<Int>  cfg_targetPivotValue                (std::numeric_limits<Int>::min(), std::numeric_limits<Int>::max(), 0, 1<<16);
     770
     771  SMultiValueInput<Double> cfg_adIntraLambdaModifier         (0, std::numeric_limits<Double>::max(), 0, MAX_TLAYER); ///< Lambda modifier for Intra pictures, one for each temporal layer. If size>temporalLayer, then use [temporalLayer], else if size>0, use [size()-1], else use m_adLambdaModifier.
     772
    831773
    832774  const UInt defaultInputKneeCodes[3]  = { 600, 800, 900 };
     
    866808  ("InputFile_%d,i_%d",       m_pchInputFileList,       (char *) 0 , MAX_NUM_LAYER_IDS , "original Yuv input file name %d")
    867809#else
    868   ("InputFile,i",                                     cfg_InputFile,                               string(""), "Original YUV input file name")
    869 #endif
    870   ("BitstreamFile,b",                                 cfg_BitstreamFile,                           string(""), "Bitstream output file name")
     810  ("InputFile,i",                                     m_inputFileName,                             string(""), "Original YUV input file name")
     811#endif
     812  ("BitstreamFile,b",                                 m_bitstreamFileName,                         string(""), "Bitstream output file name")
    871813#if NH_MV
    872814  ("ReconFile_%d,o_%d",       m_pchReconFileList,       (char *) 0 , MAX_NUM_LAYER_IDS , "reconstructed Yuv output file name %d")
    873815#else
    874   ("ReconFile,o",                                     cfg_ReconFile,                               string(""), "Reconstructed YUV output file name")
     816  ("ReconFile,o",                                     m_reconFileName,                             string(""), "Reconstructed YUV output file name")
    875817#endif
    876818#if NH_MV
     
    941883  ("ConfWinTop",                                      m_confWinTop,                                         0, "Top offset for window conformance mode 3")
    942884  ("ConfWinBottom",                                   m_confWinBottom,                                      0, "Bottom offset for window conformance mode 3")
     885  ("AccessUnitDelimiter",                             m_AccessUnitDelimiter,                            false, "Enable Access Unit Delimiter NALUs")
    943886  ("FrameRate,-fr",                                   m_iFrameRate,                                         0, "Frame rate")
    944887  ("FrameSkip,-fs",                                   m_FrameSkip,                                         0u, "Number of frames to skip at start of input YUV")
     
    1003946  // motion search options
    1004947  ("DisableIntraInInter",                             m_bDisableIntraPUsInInterSlices,                  false, "Flag to disable intra PUs in inter slices")
    1005   ("FastSearch",                                      m_iFastSearch,                                        1, "0:Full search  1:Diamond  2:PMVFAST")
     948  ("FastSearch",                                      tmpMotionEstimationSearchMethod,  Int(MESEARCH_DIAMOND), "0:Full search 1:Diamond 2:Selective 3:Enhanced Diamond")
    1006949  ("SearchRange,-sr",                                 m_iSearchRange,                                      96, "Motion search range")
    1007950#if NH_MV
     
    1010953#endif
    1011954  ("BipredSearchRange",                               m_bipredSearchRange,                                  4, "Motion search range for bipred refinement")
     955  ("MinSearchWindow",                                 m_minSearchWindow,                                    8, "Minimum motion search window size for the adaptive window ME")
     956  ("RestrictMESampling",                              m_bRestrictMESampling,                            false, "Restrict ME Sampling for selective inter motion search")
    1012957  ("ClipForBiPredMEEnabled",                          m_bClipForBiPredMeEnabled,                        false, "Enables clipping in the Bi-Pred ME. It is disabled to reduce encoder run-time")
    1013958  ("FastMEAssumingSmootherMVEnabled",                 m_bFastMEAssumingSmootherMVEnabled,                true, "Enables fast ME assuming a smoother MV.")
     
    1017962
    1018963  // Mode decision parameters
    1019   ("LambdaModifier0,-LM0",                            m_adLambdaModifier[ 0 ],                  ( Double )1.0, "Lambda modifier for temporal layer 0")
    1020   ("LambdaModifier1,-LM1",                            m_adLambdaModifier[ 1 ],                  ( Double )1.0, "Lambda modifier for temporal layer 1")
    1021   ("LambdaModifier2,-LM2",                            m_adLambdaModifier[ 2 ],                  ( Double )1.0, "Lambda modifier for temporal layer 2")
    1022   ("LambdaModifier3,-LM3",                            m_adLambdaModifier[ 3 ],                  ( Double )1.0, "Lambda modifier for temporal layer 3")
    1023   ("LambdaModifier4,-LM4",                            m_adLambdaModifier[ 4 ],                  ( Double )1.0, "Lambda modifier for temporal layer 4")
    1024   ("LambdaModifier5,-LM5",                            m_adLambdaModifier[ 5 ],                  ( Double )1.0, "Lambda modifier for temporal layer 5")
    1025   ("LambdaModifier6,-LM6",                            m_adLambdaModifier[ 6 ],                  ( Double )1.0, "Lambda modifier for temporal layer 6")
     964  ("LambdaModifier0,-LM0",                            m_adLambdaModifier[ 0 ],                  ( Double )1.0, "Lambda modifier for temporal layer 0. If LambdaModifierI is used, this will not affect intra pictures")
     965  ("LambdaModifier1,-LM1",                            m_adLambdaModifier[ 1 ],                  ( Double )1.0, "Lambda modifier for temporal layer 1. If LambdaModifierI is used, this will not affect intra pictures")
     966  ("LambdaModifier2,-LM2",                            m_adLambdaModifier[ 2 ],                  ( Double )1.0, "Lambda modifier for temporal layer 2. If LambdaModifierI is used, this will not affect intra pictures")
     967  ("LambdaModifier3,-LM3",                            m_adLambdaModifier[ 3 ],                  ( Double )1.0, "Lambda modifier for temporal layer 3. If LambdaModifierI is used, this will not affect intra pictures")
     968  ("LambdaModifier4,-LM4",                            m_adLambdaModifier[ 4 ],                  ( Double )1.0, "Lambda modifier for temporal layer 4. If LambdaModifierI is used, this will not affect intra pictures")
     969  ("LambdaModifier5,-LM5",                            m_adLambdaModifier[ 5 ],                  ( Double )1.0, "Lambda modifier for temporal layer 5. If LambdaModifierI is used, this will not affect intra pictures")
     970  ("LambdaModifier6,-LM6",                            m_adLambdaModifier[ 6 ],                  ( Double )1.0, "Lambda modifier for temporal layer 6. If LambdaModifierI is used, this will not affect intra pictures")
     971  ("LambdaModifierI,-LMI",                            cfg_adIntraLambdaModifier,    cfg_adIntraLambdaModifier, "Lambda modifiers for Intra pictures, comma separated, up to one the number of temporal layer. If entry for temporalLayer exists, then use it, else if some are specified, use the last, else use the standard LambdaModifiers.")
     972  ("IQPFactor,-IQF",                                  m_dIntraQpFactor,                                  -1.0, "Intra QP Factor for Lambda Computation. If negative, use the default equation: 0.57*(1.0 - Clip3( 0.0, 0.5, 0.05*(Double)(isField ? (GopSize-1)/2 : GopSize-1) ))")
    1026973
    1027974  /* Quantization parameters */
     
    1046993  ("AdaptiveQP,-aq",                                  m_bUseAdaptiveQP,                                 false, "QP adaptation based on a psycho-visual model")
    1047994  ("MaxQPAdaptationRange,-aqr",                       m_iQPAdaptationRange,                                 6, "QP adaptation range")
    1048   ("dQPFile,m",                                       cfg_dQPFile,                                 string(""), "dQP file name")
     995  ("dQPFile,m",                                       m_dQPFileName,                               string(""), "dQP file name")
    1049996  ("RDOQ",                                            m_useRDOQ,                                         true)
    1050997  ("RDOQTS",                                          m_useRDOQTS,                                       true)
     
    10901037  ("MaxNumOffsetsPerPic",                             m_maxNumOffsetsPerPic,                             2048, "Max number of SAO offset per picture (Default: 2048)")
    10911038  ("SAOLcuBoundary",                                  m_saoCtuBoundary,                                 false, "0: right/bottom CTU boundary areas skipped from SAO parameter estimation, 1: non-deblocked pixels are used for those areas")
    1092   ("SliceMode",                                       m_sliceMode,                                          0, "0: Disable all Recon slice limits, 1: Enforce max # of CTUs, 2: Enforce max # of bytes, 3:specify tiles per dependent slice")
     1039  ("SliceMode",                                       tmpSliceMode,                            Int(NO_SLICES), "0: Disable all Recon slice limits, 1: Enforce max # of CTUs, 2: Enforce max # of bytes, 3:specify tiles per dependent slice")
    10931040  ("SliceArgument",                                   m_sliceArgument,                                      0, "Depending on SliceMode being:"
    10941041                                                                                                               "\t1: max number of CTUs per slice"
    10951042                                                                                                               "\t2: max number of bytes per slice"
    10961043                                                                                                               "\t3: max number of tiles per slice")
    1097   ("SliceSegmentMode",                                m_sliceSegmentMode,                                   0, "0: Disable all slice segment limits, 1: Enforce max # of CTUs, 2: Enforce max # of bytes, 3:specify tiles per dependent slice")
     1044  ("SliceSegmentMode",                                tmpSliceSegmentMode,                     Int(NO_SLICES), "0: Disable all slice segment limits, 1: Enforce max # of CTUs, 2: Enforce max # of bytes, 3:specify tiles per dependent slice")
    10981045  ("SliceSegmentArgument",                            m_sliceSegmentArgument,                               0, "Depending on SliceSegmentMode being:"
    10991046                                                                                                               "\t1: max number of CTUs per slice segment"
     
    11121059  ("PCMInputBitDepthFlag",                            m_bPCMInputBitDepthFlag,                           true)
    11131060  ("PCMFilterDisableFlag",                            m_bPCMFilterDisableFlag,                          false)
    1114   ("IntraReferenceSmoothing",                         m_enableIntraReferenceSmoothing,                   true, "0: Disable use of intra reference smoothing. 1: Enable use of intra reference smoothing (not valid in V1 profiles)")
     1061  ("IntraReferenceSmoothing",                         m_enableIntraReferenceSmoothing,                   true, "0: Disable use of intra reference smoothing (not valid in V1 profiles). 1: Enable use of intra reference smoothing (same as V1)")
    11151062  ("WeightedPredP,-wpP",                              m_useWeightedPred,                                false, "Use weighted prediction in P slices")
    11161063  ("WeightedPredB,-wpB",                              m_useWeightedBiPred,                              false, "Use weighted (bidirectional) prediction in B slices")
     1064  ("WeightedPredMethod,-wpM",                         tmpWeightedPredictionMethod, Int(WP_PER_PICTURE_WITH_SIMPLE_DC_COMBINED_COMPONENT), "Weighted prediction method")
    11171065  ("Log2ParallelMergeLevel",                          m_log2ParallelMergeLevel,                            2u, "Parallel merge estimation region")
    11181066    //deprecated copies of renamed tile parameters
     
    11271075  ("TileRowHeightArray",                              cfg_RowHeight,                            cfg_RowHeight, "Array containing tile row height values in units of CTU")
    11281076  ("LFCrossTileBoundaryFlag",                         m_bLFCrossTileBoundaryFlag,                        true, "1: cross-tile-boundary loop filtering. 0:non-cross-tile-boundary loop filtering")
    1129   ("WaveFrontSynchro",                                m_iWaveFrontSynchro,                                  0, "0: no synchro; 1 synchro with top-right-right")
     1077  ("WaveFrontSynchro",                                m_entropyCodingSyncEnabledFlag,                   false, "0: entropy coding sync disabled; 1 entropy coding sync enabled")
    11301078  ("ScalingList",                                     m_useScalingListId,                    SCALING_LIST_OFF, "0/off: no scaling list, 1/default: default scaling lists, 2/file: scaling lists specified in ScalingListFile")
    1131   ("ScalingListFile",                                 cfg_ScalingListFile,                         string(""), "Scaling list file name. Use an empty string to produce help.")
     1079  ("ScalingListFile",                                 m_scalingListFileName,                       string(""), "Scaling list file name. Use an empty string to produce help.")
    11321080  ("SignHideFlag,-SBH",                               m_signHideFlag,                                    true)
    11331081  ("MaxNumMergeCand",                                 m_maxNumMergeCand,                                   5u, "Maximum number of merge candidates")
    11341082  /* Misc. */
    1135   ("SEIDecodedPictureHash",                           m_decodedPictureHashSEIEnabled,                       0, "Control generation of decode picture hash SEI messages\n"
     1083  ("SEIDecodedPictureHash",                           tmpDecodedPictureHashSEIMappedType,                   0, "Control generation of decode picture hash SEI messages\n"
    11361084                                                                                                               "\t3: checksum\n"
    11371085                                                                                                               "\t2: CRC\n"
     
    11391087                                                                                                               "\t0: disable")
    11401088  ("TMVPMode",                                        m_TMVPModeId,                                         1, "TMVP mode 0: TMVP disable for all slices. 1: TMVP enable for all slices (default) 2: TMVP enable for certain slices only")
    1141   ("FEN",                                             m_bUseFastEnc,                                    false, "fast encoder setting")
     1089  ("FEN",                                             tmpFastInterSearchMode,   Int(FASTINTERSEARCH_DISABLED), "fast encoder setting")
    11421090  ("ECU",                                             m_bUseEarlyCU,                                    false, "Early CU setting")
    11431091  ("FDM",                                             m_useFastDecisionForMerge,                         true, "Fast decision for Merge RD Cost")
     
    11511099  ( "InitialQP",                                      m_RCInitialQP,                                        0, "Rate control: initial QP" )
    11521100  ( "RCForceIntraQP",                                 m_RCForceIntraQP,                                 false, "Rate control: force intra QP to be equal to initial QP" )
     1101
     1102#if U0132_TARGET_BITS_SATURATION
     1103  ( "RCCpbSaturation",                                m_RCCpbSaturationEnabled,                         false, "Rate control: enable target bits saturation to avoid CPB overflow and underflow" )
     1104  ( "RCCpbSize",                                      m_RCCpbSize,                                         0u, "Rate control: CPB size" )
     1105  ( "RCInitialCpbFullness",                           m_RCInitialCpbFullness,                             0.9, "Rate control: initial CPB fullness" )
     1106#endif
    11531107
    11541108#if KWU_RC_VIEWRC_E0227
     
    12271181  ("Log2MaxMvLengthHorizontal",                       m_log2MaxMvLengthHorizontal,                         15, "Indicate the maximum absolute value of a decoded horizontal MV component in quarter-pel luma units")
    12281182  ("Log2MaxMvLengthVertical",                         m_log2MaxMvLengthVertical,                           15, "Indicate the maximum absolute value of a decoded vertical MV component in quarter-pel luma units")
    1229   ("SEIRecoveryPoint",                                m_recoveryPointSEIEnabled,                            0, "Control generation of recovery point SEI messages")
    1230   ("SEIBufferingPeriod",                              m_bufferingPeriodSEIEnabled,                          0, "Control generation of buffering period SEI messages")
    1231   ("SEIPictureTiming",                                m_pictureTimingSEIEnabled,                            0, "Control generation of picture timing SEI messages")
     1183  ("SEIColourRemappingInfoFileRoot,-cri",             m_colourRemapSEIFileRoot,                    string(""), "Colour Remapping Information SEI parameters root file name (wo num ext)")
     1184  ("SEIRecoveryPoint",                                m_recoveryPointSEIEnabled,                        false, "Control generation of recovery point SEI messages")
     1185  ("SEIBufferingPeriod",                              m_bufferingPeriodSEIEnabled,                      false, "Control generation of buffering period SEI messages")
     1186  ("SEIPictureTiming",                                m_pictureTimingSEIEnabled,                        false, "Control generation of picture timing SEI messages")
    12321187  ("SEIToneMappingInfo",                              m_toneMappingInfoSEIEnabled,                      false, "Control generation of Tone Mapping SEI messages")
    12331188  ("SEIToneMapId",                                    m_toneMapId,                                          0, "Specifies Id of Tone Mapping SEI message for a given session")
     
    12621217  ("SEIToneMapNominalWhiteLevelLumaCodeValue",        m_nominalWhiteLevelLumaCodeValue,                   235, "Specifies luma sample value of the nominal white level assigned decoded pictures")
    12631218  ("SEIToneMapExtendedWhiteLevelLumaCodeValue",       m_extendedWhiteLevelLumaCodeValue,                  300, "Specifies luma sample value of the extended dynamic range assigned decoded pictures")
    1264   ("SEIChromaSamplingFilterHint",                     m_chromaSamplingFilterSEIenabled,                 false, "Control generation of the chroma sampling filter hint SEI message")
    1265   ("SEIChromaSamplingHorizontalFilterType",           m_chromaSamplingHorFilterIdc,                         2, "Defines the Index of the chroma sampling horizontal filter\n"
     1219  ("SEIChromaResamplingFilterHint",                   m_chromaResamplingFilterSEIenabled,               false, "Control generation of the chroma sampling filter hint SEI message")
     1220  ("SEIChromaResamplingHorizontalFilterType",         m_chromaResamplingHorFilterIdc,                       2, "Defines the Index of the chroma sampling horizontal filter\n"
    12661221                                                                                                               "\t0: unspecified  - Chroma filter is unknown or is determined by the application"
    12671222                                                                                                               "\t1: User-defined - Filter coefficients are specified in the chroma sampling filter hint SEI message"
    12681223                                                                                                               "\t2: Standards-defined - ITU-T Rec. T.800 | ISO/IEC15444-1, 5/3 filter")
    1269   ("SEIChromaSamplingVerticalFilterType",             m_chromaSamplingVerFilterIdc,                         2, "Defines the Index of the chroma sampling vertical filter\n"
     1224  ("SEIChromaResamplingVerticalFilterType",           m_chromaResamplingVerFilterIdc,                         2, "Defines the Index of the chroma sampling vertical filter\n"
    12701225                                                                                                               "\t0: unspecified  - Chroma filter is unknown or is determined by the application"
    12711226                                                                                                               "\t1: User-defined - Filter coefficients are specified in the chroma sampling filter hint SEI message"
    12721227                                                                                                               "\t2: Standards-defined - ITU-T Rec. T.800 | ISO/IEC15444-1, 5/3 filter")
    1273   ("SEIFramePacking",                                 m_framePackingSEIEnabled,                             0, "Control generation of frame packing SEI messages")
     1228  ("SEIFramePacking",                                 m_framePackingSEIEnabled,                         false, "Control generation of frame packing SEI messages")
    12741229  ("SEIFramePackingType",                             m_framePackingSEIType,                                0, "Define frame packing arrangement\n"
    12751230                                                                                                               "\t3: side by side - frames are displayed horizontally\n"
     
    12821237                                                                                                               "\t1: stereo pair, frame0 represents left view\n"
    12831238                                                                                                               "\t2: stereo pair, frame0 represents right view")
    1284   ("SEISegmentedRectFramePacking",                    m_segmentedRectFramePackingSEIEnabled,                0, "Controls generation of segmented rectangular frame packing SEI messages")
     1239  ("SEISegmentedRectFramePacking",                    m_segmentedRectFramePackingSEIEnabled,            false, "Controls generation of segmented rectangular frame packing SEI messages")
    12851240  ("SEISegmentedRectFramePackingCancel",              m_segmentedRectFramePackingSEICancel,             false, "If equal to 1, cancels the persistence of any previous SRFPA SEI message")
    12861241  ("SEISegmentedRectFramePackingType",                m_segmentedRectFramePackingSEIType,                   0, "Specifies the arrangement of the frames in the reconstructed picture")
     
    12891244                                                                                                               "\tN: 0 < N < (2^16 - 1) enable display orientation SEI message with anticlockwise_rotation = N and display_orientation_repetition_period = 1\n"
    12901245                                                                                                               "\t0: disable")
    1291   ("SEITemporalLevel0Index",                          m_temporalLevel0IndexSEIEnabled,                      0, "Control generation of temporal level 0 index SEI messages")
    1292   ("SEIGradualDecodingRefreshInfo",                   m_gradualDecodingRefreshInfoEnabled,                  0, "Control generation of gradual decoding refresh information SEI message")
     1246  ("SEITemporalLevel0Index",                          m_temporalLevel0IndexSEIEnabled,                  false, "Control generation of temporal level 0 index SEI messages")
     1247  ("SEIGradualDecodingRefreshInfo",                   m_gradualDecodingRefreshInfoEnabled,              false, "Control generation of gradual decoding refresh information SEI message")
    12931248  ("SEINoDisplay",                                    m_noDisplaySEITLayer,                                 0, "Control generation of no display SEI message\n"
    12941249                                                                                                               "\tN: 0 < N enable no display SEI message for temporal layer N or higher\n"
    12951250                                                                                                               "\t0: disable")
    1296   ("SEIDecodingUnitInfo",                             m_decodingUnitInfoSEIEnabled,                         0, "Control generation of decoding unit information SEI message.")
    1297   ("SEISOPDescription",                               m_SOPDescriptionSEIEnabled,                           0, "Control generation of SOP description SEI messages")
    1298   ("SEIScalableNesting",                              m_scalableNestingSEIEnabled,                          0, "Control generation of scalable nesting SEI messages")
     1251  ("SEIDecodingUnitInfo",                             m_decodingUnitInfoSEIEnabled,                     false, "Control generation of decoding unit information SEI message.")
     1252  ("SEISOPDescription",                               m_SOPDescriptionSEIEnabled,                       false, "Control generation of SOP description SEI messages")
     1253  ("SEIScalableNesting",                              m_scalableNestingSEIEnabled,                      false, "Control generation of scalable nesting SEI messages")
    12991254  ("SEITempMotionConstrainedTileSets",                m_tmctsSEIEnabled,                                false, "Control generation of temporal motion constrained tile sets SEI message")
    13001255  ("SEITimeCodeEnabled",                              m_timeCodeSEIEnabled,                             false, "Control generation of time code information SEI message")
     
    13411296  ("SEISubBitstreamMaxBitRate",                       m_sbPropMaxBitRate,             IntAry1d (1,0)            ,"Specifies maximum bit rate of the i-th sub-bitstream")
    13421297#else
    1343   ("SeiCfgFileName_%d",                               m_seiCfgFileNames,             (Char *) 0 , MAX_NUM_SEIS , "SEI cfg file name %d")
     1298  ("SeiCfgFileName_%d",                               m_seiCfgFileNames,             (TChar *) 0 ,MAX_NUM_SEIS , "SEI cfg file name %d")
    13441299#endif
    13451300  ("OutputVpsInfo",                                   m_outputVpsInfo,                false                     ,"Output information about the layer dependencies and layer sets")
     
    13481303/* Camera parameters */ 
    13491304  ("Depth420OutputFlag",                              m_depth420OutputFlag,           true                     , "Output depth layers in 4:2:0 ")
    1350   ("CameraParameterFile,cpf",                         m_pchCameraParameterFile,    (Char *) 0,                    "Camera Parameter File Name")
    1351   ("BaseViewCameraNumbers",                           m_pchBaseViewCameraNumbers,  (Char *) 0,                    "Numbers of base views")
     1305  ("CameraParameterFile,cpf",                         m_pchCameraParameterFile,    (TChar *) 0                 , "Camera Parameter File Name")
     1306  ("BaseViewCameraNumbers",                           m_pchBaseViewCameraNumbers,  (TChar *) 0                 , "Numbers of base views")
    13521307  ("CodedCamParsPrecision",                           m_iCodedCamParPrecision,      STD_CAM_PARAMETERS_PRECISION, "precision for coding of camera parameters (in units of 2^(-x) luma samples)" )
    13531308
    13541309#if NH_3D_VSO
    13551310  /* View Synthesis Optimization */
    1356   ("VSOConfig",                                       m_pchVSOConfig            , (Char *) 0                    ,"VSO configuration")
     1311  ("VSOConfig",                                       m_pchVSOConfig            , (TChar *) 0                   ,"VSO configuration")
    13571312  ("VSO",                                             m_bUseVSO                 , false                         ,"Use VSO" )   
    13581313  ("VSOMode",                                         m_uiVSOMode               , (UInt)   4                    ,"VSO Mode")
     
    14471402  po::setDefaults(opts);
    14481403  po::ErrorReporter err;
    1449   const list<const Char*>& argv_unhandled = po::scanArgv(opts, argc, (const Char**) argv, err);
    1450 
    1451   for (list<const Char*>::const_iterator it = argv_unhandled.begin(); it != argv_unhandled.end(); it++)
     1404  const list<const TChar*>& argv_unhandled = po::scanArgv(opts, argc, (const TChar**) argv, err);
     1405
     1406  for (list<const TChar*>::const_iterator it = argv_unhandled.begin(); it != argv_unhandled.end(); it++)
    14521407  {
    14531408    fprintf(stderr, "Unhandled argument ignored: `%s'\n", *it);
     
    14731428   * Set any derived parameters
    14741429   */
    1475   /* convert std::string to c string for compatability */
    1476 #if !NH_MV
    1477   m_pchInputFile = cfg_InputFile.empty() ? NULL : strdup(cfg_InputFile.c_str());
    1478 #endif
    1479   m_pchBitstreamFile = cfg_BitstreamFile.empty() ? NULL : strdup(cfg_BitstreamFile.c_str());
    1480 #if !NH_MV
    1481   m_pchReconFile = cfg_ReconFile.empty() ? NULL : strdup(cfg_ReconFile.c_str());
    1482 #endif
    1483   m_pchdQPFile = cfg_dQPFile.empty() ? NULL : strdup(cfg_dQPFile.c_str());
    1484 
     1430  m_adIntraLambdaModifier = cfg_adIntraLambdaModifier.values;
    14851431  if(m_isField)
    14861432  {
     
    15451491  }
    15461492
    1547   m_scalingListFile = cfg_ScalingListFile.empty() ? NULL : strdup(cfg_ScalingListFile.c_str());
    1548 
    15491493  /* rules for input, output and internal bitdepths as per help text */
    15501494  if (m_MSBExtendedBitDepth[CHANNEL_TYPE_LUMA  ] == 0)
     
    15791523  m_InputChromaFormatIDC = numberToChromaFormat(tmpInputChromaFormat);
    15801524  m_chromaFormatIDC      = ((tmpChromaFormat == 0) ? (m_InputChromaFormatIDC) : (numberToChromaFormat(tmpChromaFormat)));
     1525
     1526
     1527  assert(tmpWeightedPredictionMethod>=0 && tmpWeightedPredictionMethod<=WP_PER_PICTURE_WITH_HISTOGRAM_AND_PER_COMPONENT_AND_CLIPPING_AND_EXTENSION);
     1528  if (!(tmpWeightedPredictionMethod>=0 && tmpWeightedPredictionMethod<=WP_PER_PICTURE_WITH_HISTOGRAM_AND_PER_COMPONENT_AND_CLIPPING_AND_EXTENSION))
     1529  {
     1530    exit(EXIT_FAILURE);
     1531  }
     1532  m_weightedPredictionMethod = WeightedPredictionMethod(tmpWeightedPredictionMethod);
     1533
     1534  assert(tmpFastInterSearchMode>=0 && tmpFastInterSearchMode<=FASTINTERSEARCH_MODE3);
     1535  if (tmpFastInterSearchMode<0 || tmpFastInterSearchMode>FASTINTERSEARCH_MODE3)
     1536  {
     1537    exit(EXIT_FAILURE);
     1538  }
     1539  m_fastInterSearchMode = FastInterSearchMode(tmpFastInterSearchMode);
     1540
     1541  assert(tmpMotionEstimationSearchMethod>=0 && tmpMotionEstimationSearchMethod<MESEARCH_NUMBER_OF_METHODS);
     1542  if (tmpMotionEstimationSearchMethod<0 || tmpMotionEstimationSearchMethod>=MESEARCH_NUMBER_OF_METHODS)
     1543  {
     1544    exit(EXIT_FAILURE);
     1545  }
     1546  m_motionEstimationSearchMethod=MESearchMethod(tmpMotionEstimationSearchMethod);
    15811547
    15821548#if NH_MV
     
    18021768  }
    18031769
     1770  if (tmpSliceMode<0 || tmpSliceMode>=Int(NUMBER_OF_SLICE_CONSTRAINT_MODES))
     1771  {
     1772    fprintf(stderr, "Error: bad slice mode\n");
     1773    exit(EXIT_FAILURE);
     1774  }
     1775  m_sliceMode = SliceConstraint(tmpSliceMode);
     1776  if (tmpSliceSegmentMode<0 || tmpSliceSegmentMode>=Int(NUMBER_OF_SLICE_CONSTRAINT_MODES))
     1777  {
     1778    fprintf(stderr, "Error: bad slice segment mode\n");
     1779    exit(EXIT_FAILURE);
     1780  }
     1781  m_sliceSegmentMode = SliceConstraint(tmpSliceSegmentMode);
     1782
     1783  if (tmpDecodedPictureHashSEIMappedType<0 || tmpDecodedPictureHashSEIMappedType>=Int(NUMBER_OF_HASHTYPES))
     1784  {
     1785    fprintf(stderr, "Error: bad checksum mode\n");
     1786    exit(EXIT_FAILURE);
     1787  }
     1788  // Need to map values to match those of the SEI message:
     1789  if (tmpDecodedPictureHashSEIMappedType==0)
     1790  {
     1791    m_decodedPictureHashSEIType=HASHTYPE_NONE;
     1792  }
     1793  else
     1794  {
     1795    m_decodedPictureHashSEIType=HashType(tmpDecodedPictureHashSEIMappedType-1);
     1796  }
     1797
    18041798  // allocate slice-based dQP values
    18051799#if NH_MV
     
    19231917
    19241918  // reading external dQP description from file
    1925   if ( m_pchdQPFile )
    1926   {
    1927     FILE* fpt=fopen( m_pchdQPFile, "r" );
     1919  if ( !m_dQPFileName.empty() )
     1920  {
     1921    FILE* fpt=fopen( m_dQPFileName.c_str(), "r" );
    19281922    if ( fpt )
    19291923    {
     
    21452139Void TAppEncCfg::xCheckParameter()
    21462140{
    2147   if (!m_decodedPictureHashSEIEnabled)
     2141  if (m_decodedPictureHashSEIType==HASHTYPE_NONE)
    21482142  {
    21492143    fprintf(stderr, "******************************************************************\n");
     
    21732167#define xConfirmPara(a,b) check_failed |= confirmPara(a,b)
    21742168
    2175   xConfirmPara(m_pchBitstreamFile==NULL, "A bitstream file name must be specified (BitstreamFile)");
     2169  xConfirmPara(m_bitstreamFileName.empty(), "A bitstream file name must be specified (BitstreamFile)");
    21762170  const UInt maxBitDepth=(m_chromaFormatIDC==CHROMA_400) ? m_internalBitDepth[CHANNEL_TYPE_LUMA] : std::max(m_internalBitDepth[CHANNEL_TYPE_LUMA], m_internalBitDepth[CHANNEL_TYPE_CHROMA]);
    21772171  xConfirmPara(m_bitDepthConstraint<maxBitDepth, "The internalBitDepth must not be greater than the bitDepthConstraint value");
     
    25442538  xConfirmPara( m_loopFilterBetaOffsetDiv2 < -6 || m_loopFilterBetaOffsetDiv2 > 6,        "Loop Filter Beta Offset div. 2 exceeds supported range (-6 to 6)");
    25452539  xConfirmPara( m_loopFilterTcOffsetDiv2 < -6 || m_loopFilterTcOffsetDiv2 > 6,            "Loop Filter Tc Offset div. 2 exceeds supported range (-6 to 6)");
    2546   xConfirmPara( m_iFastSearch < 0 || m_iFastSearch > 2,                                     "Fast Search Mode is not supported value (0:Full search  1:Diamond  2:PMVFAST)" );
    25472540  xConfirmPara( m_iSearchRange < 0 ,                                                        "Search Range must be more than 0" );
    2548   xConfirmPara( m_bipredSearchRange < 0 ,                                                   "Search Range must be more than 0" );
     2541  xConfirmPara( m_bipredSearchRange < 0 ,                                                   "Bi-prediction refinement search range must be more than 0" );
     2542  xConfirmPara( m_minSearchWindow < 0,                                                      "Minimum motion search window size for the adaptive window ME must be greater than or equal to 0" );
    25492543#if NH_MV
    25502544  xConfirmPara( m_iVerticalDisparitySearchRange <= 0 ,                                      "Vertical Disparity Search Range must be more than 0" );
     
    26242618  }
    26252619
    2626   xConfirmPara( m_sliceMode < 0 || m_sliceMode > 3, "SliceMode exceeds supported range (0 to 3)" );
    2627   if (m_sliceMode!=0)
     2620  if (m_sliceMode!=NO_SLICES)
    26282621  {
    26292622    xConfirmPara( m_sliceArgument < 1 ,         "SliceArgument should be larger than or equal to 1" );
    26302623  }
    2631   xConfirmPara( m_sliceSegmentMode < 0 || m_sliceSegmentMode > 3, "SliceSegmentMode exceeds supported range (0 to 3)" );
    2632   if (m_sliceSegmentMode!=0)
     2624  if (m_sliceSegmentMode!=NO_SLICES)
    26332625  {
    26342626    xConfirmPara( m_sliceSegmentArgument < 1 ,         "SliceSegmentArgument should be larger than or equal to 1" );
     
    26382630  if (m_profile!=Profile::HIGHTHROUGHPUTREXT)
    26392631  {
    2640     xConfirmPara( tileFlag && m_iWaveFrontSynchro,            "Tile and Wavefront can not be applied together, except in the High Throughput Intra 4:4:4 16 profile");
     2632    xConfirmPara( tileFlag && m_entropyCodingSyncEnabledFlag, "Tiles and entropy-coding-sync (Wavefronts) can not be applied together, except in the High Throughput Intra 4:4:4 16 profile");
    26412633  }
    26422634
     
    32373229      m_minSpatialSegmentationIdc = 4*PicSizeInSamplesY/maxSizeInSamplesY-4;
    32383230    }
    3239     else if(m_iWaveFrontSynchro)
     3231    else if(m_entropyCodingSyncEnabledFlag)
    32403232    {
    32413233      m_minSpatialSegmentationIdc = 4*PicSizeInSamplesY/((2*m_iSourceHeight+m_iSourceWidth)*m_uiMaxCUHeight)-4;
     
    32503242    }
    32513243  }
    3252 
    3253   xConfirmPara( m_iWaveFrontSynchro < 0, "WaveFrontSynchro cannot be negative" );
    3254 
    3255   xConfirmPara( m_decodedPictureHashSEIEnabled<0 || m_decodedPictureHashSEIEnabled>3, "this hash type is not correct!\n");
    32563244
    32573245  if (m_toneMappingInfoSEIEnabled)
     
    32823270  }
    32833271
     3272  if (m_chromaResamplingFilterSEIenabled)
     3273  {
     3274    xConfirmPara( (m_chromaFormatIDC == CHROMA_400 ), "chromaResamplingFilterSEI is not allowed to be present when ChromaFormatIDC is equal to zero (4:0:0)" );
     3275    xConfirmPara(m_vuiParametersPresentFlag && m_chromaLocInfoPresentFlag && (m_chromaSampleLocTypeTopField != m_chromaSampleLocTypeBottomField ), "When chromaResamplingFilterSEI is enabled, ChromaSampleLocTypeTopField has to be equal to ChromaSampleLocTypeBottomField" );
     3276  }
     3277
    32843278  if ( m_RCEnableRateControl )
    32853279  {
     
    32933287    }
    32943288    xConfirmPara( m_uiDeltaQpRD > 0, "Rate control cannot be used together with slice level multiple-QP optimization!\n" );
    3295   }
     3289#if U0132_TARGET_BITS_SATURATION
     3290#if NH_MV
     3291    if ((m_RCCpbSaturationEnabled) && (m_level[0]!=Level::NONE) && (m_profile!=Profile::NONE))
     3292    {
     3293      UInt uiLevelIdx = (m_level[0] / 10) + (UInt)((m_level[0] % 10) / 3);    // (m_level / 30)*3 + ((m_level % 10) / 3);
     3294      xConfirmPara(m_RCCpbSize > g_uiMaxCpbSize[m_levelTier[0]][uiLevelIdx], "RCCpbSize should be smaller than or equal to Max CPB size according to tier and level");
     3295      xConfirmPara(m_RCInitialCpbFullness > 1, "RCInitialCpbFullness should be smaller than or equal to 1");
     3296    }
     3297#else
     3298    if ((m_RCCpbSaturationEnabled) && (m_level!=Level::NONE) && (m_profile!=Profile::NONE))
     3299    {
     3300      UInt uiLevelIdx = (m_level / 10) + (UInt)((m_level % 10) / 3);    // (m_level / 30)*3 + ((m_level % 10) / 3);
     3301      xConfirmPara(m_RCCpbSize > g_uiMaxCpbSize[m_levelTier][uiLevelIdx], "RCCpbSize should be smaller than or equal to Max CPB size according to tier and level");
     3302      xConfirmPara(m_RCInitialCpbFullness > 1, "RCInitialCpbFullness should be smaller than or equal to 1");
     3303    }
     3304#endif
     3305#endif
     3306  }
     3307#if U0132_TARGET_BITS_SATURATION
     3308  else
     3309  {
     3310    xConfirmPara( m_RCCpbSaturationEnabled != 0, "Target bits saturation cannot be processed without Rate control" );
     3311  }
     3312#endif
     3313
    32963314#if NH_MV
    32973315  // VPS VUI
     
    33513369  if (m_segmentedRectFramePackingSEIEnabled)
    33523370  {
    3353     xConfirmPara(m_framePackingSEIEnabled > 0 , "SEISegmentedRectFramePacking must be 0 when SEIFramePacking is 1");
     3371    xConfirmPara(m_framePackingSEIEnabled , "SEISegmentedRectFramePacking must be 0 when SEIFramePacking is 1");
    33543372  }
    33553373
     
    33723390}
    33733391
    3374 const Char *profileToString(const Profile::Name profile)
     3392const TChar *profileToString(const Profile::Name profile)
    33753393{
    33763394  static const UInt numberOfProfiles = sizeof(strToProfile)/sizeof(*strToProfile);
     
    34003418  }
    34013419#else
    3402   printf("Input          File               : %s\n", m_pchInputFile          );
    3403 #endif
    3404   printf("Bitstream      File               : %s\n", m_pchBitstreamFile      );
     3420  printf("Input          File                    : %s\n", m_inputFileName.c_str()          );
     3421#endif
     3422  printf("Bitstream      File                    : %s\n", m_bitstreamFileName.c_str()      );
    34053423#if NH_MV
    34063424  for( Int layer = 0; layer < m_numberOfLayers; layer++)
     
    34093427  }
    34103428#else
    3411   printf("Reconstruction File               : %s\n", m_pchReconFile          );
     3429  printf("Reconstruction File                    : %s\n", m_reconFileName.c_str()          );
    34123430#endif
    34133431#if NH_MV
     
    35813599
    35823600  printf("RateControl                       : %d\n", m_RCEnableRateControl );
     3601  printf("WPMethod                               : %d\n", Int(m_weightedPredictionMethod));
    35833602
    35843603  if(m_RCEnableRateControl)
     
    35903609    printf("InitialQP                         : %d\n", m_RCInitialQP );
    35913610    printf("ForceIntraQP                      : %d\n", m_RCForceIntraQP );
     3611
     3612#if U0132_TARGET_BITS_SATURATION
     3613    printf("CpbSaturation                          : %d\n", m_RCCpbSaturationEnabled );
     3614    if (m_RCCpbSaturationEnabled)
     3615    {
     3616      printf("CpbSize                                : %d\n", m_RCCpbSize);
     3617      printf("InitalCpbFullness                      : %.2f\n", m_RCInitialCpbFullness);
     3618    }
     3619#endif
    35923620
    35933621#if KWU_RC_MADPRED_E0227
     
    36483676  printf("SQP:%d ", m_uiDeltaQpRD         );
    36493677  printf("ASR:%d ", m_bUseASR             );
    3650   printf("FEN:%d ", m_bUseFastEnc         );
     3678  printf("MinSearchWindow:%d ", m_minSearchWindow        );
     3679  printf("RestrictMESampling:%d ", m_bRestrictMESampling );
     3680  printf("FEN:%d ", Int(m_fastInterSearchMode)           );
    36513681  printf("ECU:%d ", m_bUseEarlyCU         );
    36523682  printf("FDM:%d ", m_useFastDecisionForMerge );
     
    36573687  printf("TransformSkipFast:%d ", m_useTransformSkipFast       );
    36583688  printf("TransformSkipLog2MaxSize:%d ", m_log2MaxTransformSkipBlockSize);
    3659   printf("Slice: M=%d ", m_sliceMode);
     3689  printf("Slice: M=%d ", Int(m_sliceMode));
    36603690  if (m_sliceMode!=NO_SLICES)
    36613691  {
     
    36853715  printf("WPB:%d ", (Int)m_useWeightedBiPred);
    36863716  printf("PME:%d ", m_log2ParallelMergeLevel);
    3687   const Int iWaveFrontSubstreams = m_iWaveFrontSynchro ? (m_iSourceHeight + m_uiMaxCUHeight - 1) / m_uiMaxCUHeight : 1;
    3688   printf(" WaveFrontSynchro:%d WaveFrontSubstreams:%d",
    3689           m_iWaveFrontSynchro, iWaveFrontSubstreams);
     3717  const Int iWaveFrontSubstreams = m_entropyCodingSyncEnabledFlag ? (m_iSourceHeight + m_uiMaxCUHeight - 1) / m_uiMaxCUHeight : 1;
     3718  printf(" WaveFrontSynchro:%d WaveFrontSubstreams:%d", m_entropyCodingSyncEnabledFlag?1:0, iWaveFrontSubstreams);
    36903719  printf(" ScalingList:%d ", m_useScalingListId );
    36913720  printf("TMVPMode:%d ", m_TMVPModeId     );
     
    37303759}
    37313760
    3732 Bool confirmPara(Bool bflag, const Char* message)
     3761Bool confirmPara(Bool bflag, const TChar* message)
    37333762{
    37343763  if (!bflag)
  • branches/HTM-15.2-dev/source/App/TAppEncoder/TAppEncCfg.h

    r1356 r1360  
    6262  // file I/O
    6363#if NH_MV
    64   std::vector<char*>     m_pchInputFileList;                  ///< source file names
    65 #else
    66   Char*     m_pchInputFile;                                   ///< source file name
    67 #endif
    68   Char*     m_pchBitstreamFile;                               ///< output bitstream file
     64  std::vector<TChar*>     m_pchInputFileList;                  ///< source file names
     65#else
     66  std::string m_inputFileName;                                ///< source file name
     67#endif
     68  std::string m_bitstreamFileName;                            ///< output bitstream file
    6969#if NH_MV
    7070  std::vector<char*>     m_pchReconFileList;                  ///< output reconstruction file names
     
    7272  Int                    m_iNumberOfViews;                    ///< number of Layers that are views
    7373#else
    74   Char*     m_pchReconFile;                                   ///< output reconstruction file
     74  std::string m_reconFileName;                                ///< output reconstruction file
    7575#endif
    7676  #if NH_MV
     
    112112  Bool m_bitRatePresentVpsFlag;
    113113  Bool m_picRatePresentVpsFlag;
    114   BoolAry2d              m_bitRatePresentFlag;
    115   BoolAry2d              m_picRatePresentFlag;
    116   IntAry2d               m_avgBitRate;
    117   IntAry2d               m_maxBitRate;
    118   IntAry2d               m_constantPicRateIdc;
    119   IntAry2d               m_avgPicRate;
    120   Bool                              m_tilesNotInUseFlag;
    121   BoolAry1d               m_tilesInUseFlag;
    122   BoolAry1d               m_loopFilterNotAcrossTilesFlag;
    123   Bool                              m_wppNotInUseFlag;
    124   BoolAry1d               m_wppInUseFlag;
    125 
    126   BoolAry2d              m_tileBoundariesAlignedFlag; 
    127   Bool m_ilpRestrictedRefLayersFlag;
    128   IntAry2d               m_minSpatialSegmentOffsetPlus1;
    129   BoolAry2d              m_ctuBasedOffsetEnabledFlag;
    130   IntAry2d               m_minHorizontalCtuOffsetPlus1;
    131   Bool m_singleLayerForNonIrapFlag;
    132   Bool m_higherLayerIrapSkipFlag;
    133 
    134 
     114  BoolAry2d m_bitRatePresentFlag;
     115  BoolAry2d m_picRatePresentFlag;
     116  IntAry2d  m_avgBitRate;
     117  IntAry2d  m_maxBitRate;
     118  IntAry2d  m_constantPicRateIdc;
     119  IntAry2d  m_avgPicRate;
     120  Bool      m_tilesNotInUseFlag;
     121  BoolAry1d m_tilesInUseFlag;
     122  BoolAry1d m_loopFilterNotAcrossTilesFlag;
     123  Bool      m_wppNotInUseFlag;
     124  BoolAry1d m_wppInUseFlag;
     125
     126  BoolAry2d m_tileBoundariesAlignedFlag; 
     127  Bool      m_ilpRestrictedRefLayersFlag;
     128  IntAry2d  m_minSpatialSegmentOffsetPlus1;
     129  BoolAry2d m_ctuBasedOffsetEnabledFlag;
     130  IntAry2d  m_minHorizontalCtuOffsetPlus1;
     131  Bool      m_singleLayerForNonIrapFlag;
     132  Bool      m_higherLayerIrapSkipFlag;
    135133#if NH_3D
    136134  Bool      m_abUseIC;
    137135  Bool      m_bUseLowLatencyICEnc;
    138136#endif
    139 
    140137#endif
    141138  Double    m_adLambdaModifier[ MAX_TLAYER ];                 ///< Lambda modifier array for each temporal layer
     139  std::vector<Double> m_adIntraLambdaModifier;                ///< Lambda modifier for Intra pictures, one for each temporal layer. If size>temporalLayer, then use [temporalLayer], else if size>0, use [size()-1], else use m_adLambdaModifier.
     140  Double    m_dIntraQpFactor;                                 ///< Intra Q Factor. If negative, use a default equation: 0.57*(1.0 - Clip3( 0.0, 0.5, 0.05*(Double)(isField ? (GopSize-1)/2 : GopSize-1) ))
     141
    142142  // source specification
    143143  Int       m_iFrameRate;                                     ///< source frame-rates (Hz)
     
    160160  Int       m_framesToBeEncoded;                              ///< number of encoded frames
    161161  Int       m_aiPad[2];                                       ///< number of padded pixels for width and height
     162  Bool      m_AccessUnitDelimiter;                            ///< add Access Unit Delimiter NAL units
    162163  InputColourSpaceConversion m_inputColourSpaceConvert;       ///< colour space conversion to apply to input video
    163164  Bool      m_snrInternalColourSpace;                       ///< if true, then no colour space conversion is applied for snr calculation, otherwise inverse of input is applied.
     
    237238  Int       m_iQP;                                            ///< QP value of key-picture (integer)
    238239#endif
    239   Char*     m_pchdQPFile;                                     ///< QP offset for each slice (initialized from external file)
     240  std::string m_dQPFileName;                                  ///< QP offset for each slice (initialized from external file)
    240241#if NH_MV
    241242  std::vector<Int*> m_aidQP;                                    ///< array of slice QP values for each layer
     
    338339  Int       m_rdPenalty;                                      ///< RD-penalty for 32x32 TU for intra in non-intra slices (0: no RD-penalty, 1: RD-penalty, 2: maximum RD-penalty)
    339340  Bool      m_bDisableIntraPUsInInterSlices;                  ///< Flag for disabling intra predicted PUs in inter slices.
    340   Int       m_iFastSearch;                                    ///< ME mode, 0 = full, 1 = diamond, 2 = PMVFAST
     341  MESearchMethod m_motionEstimationSearchMethod;
     342  Bool      m_bRestrictMESampling;                            ///< Restrict sampling for the Selective ME
    341343  Int       m_iSearchRange;                                   ///< ME search range
    342344  Int       m_bipredSearchRange;                              ///< ME search range for bipred refinement
     345  Int       m_minSearchWindow;                                ///< ME minimum search window size for the Adaptive Window ME
    343346  Bool      m_bClipForBiPredMeEnabled;                        ///< Enables clipping for Bi-Pred ME.
    344347  Bool      m_bFastMEAssumingSmootherMVEnabled;               ///< Enables fast ME assuming a smoother MV.
     
    347350  Int       m_iVerticalDisparitySearchRange;                  ///< ME vertical search range for inter-view prediction
    348351#endif
    349   Bool      m_bUseFastEnc;                                    ///< flag for using fast encoder setting
     352  FastInterSearchMode m_fastInterSearchMode;                  ///< Parameter that controls fast encoder settings
    350353  Bool      m_bUseEarlyCU;                                    ///< flag for using Early CU setting
    351354  Bool      m_useFastDecisionForMerge;                        ///< flag for using Fast Decision Merge RD-Cost
    352355  Bool      m_bUseCbfFastMode;                              ///< flag for using Cbf Fast PU Mode Decision
    353356  Bool      m_useEarlySkipDetection;                         ///< flag for using Early SKIP Detection
    354   Int       m_sliceMode;                                     ///< 0: no slice limits, 1 : max number of CTBs per slice, 2: max number of bytes per slice,
    355                                                              ///< 3: max number of tiles per slice
     357  SliceConstraint m_sliceMode;
    356358  Int       m_sliceArgument;                                 ///< argument according to selected slice mode
    357   Int       m_sliceSegmentMode;                              ///< 0: no slice segment limits, 1 : max number of CTBs per slice segment, 2: max number of bytes per slice segment,
    358                                                              ///< 3: max number of tiles per slice segment
     359  SliceConstraint m_sliceSegmentMode;
    359360  Int       m_sliceSegmentArgument;                          ///< argument according to selected slice segment mode
    360361
     
    366367  std::vector<Int> m_tileColumnWidth;
    367368  std::vector<Int> m_tileRowHeight;
    368   Int       m_iWaveFrontSynchro; //< 0: no WPP. >= 1: WPP is enabled, the "Top right" from which inheritance occurs is this LCU offset in the line above the current.
    369   Int       m_iWaveFrontFlush; //< enable(1)/disable(0) the CABAC flush at the end of each line of LCUs.
     369  Bool      m_entropyCodingSyncEnabledFlag;
    370370
    371371  Bool      m_bUseConstrainedIntraPred;                       ///< flag for using constrained intra prediction
     
    374374  Bool      m_bUseBLambdaForNonKeyLowDelayPictures;
    375375
    376   Int       m_decodedPictureHashSEIEnabled;                    ///< Checksum(3)/CRC(2)/MD5(1)/disable(0) acting on decoded picture hash SEI message
    377   Int       m_recoveryPointSEIEnabled;
    378   Int       m_bufferingPeriodSEIEnabled;
    379   Int       m_pictureTimingSEIEnabled;
     376  HashType  m_decodedPictureHashSEIType;                      ///< Checksum mode for decoded picture hash SEI message
     377  Bool      m_recoveryPointSEIEnabled;
     378  Bool      m_bufferingPeriodSEIEnabled;
     379  Bool      m_pictureTimingSEIEnabled;
    380380  Bool      m_toneMappingInfoSEIEnabled;
    381   Bool      m_chromaSamplingFilterSEIenabled;
    382   Int       m_chromaSamplingHorFilterIdc;
    383   Int       m_chromaSamplingVerFilterIdc;
     381  Bool      m_chromaResamplingFilterSEIenabled;
     382  Int       m_chromaResamplingHorFilterIdc;
     383  Int       m_chromaResamplingVerFilterIdc;
    384384  Int       m_toneMapId;
    385385  Bool      m_toneMapCancelFlag;
     
    408408  Int*      m_codedPivotValue;
    409409  Int*      m_targetPivotValue;
    410   Int       m_framePackingSEIEnabled;
     410  Bool      m_framePackingSEIEnabled;
    411411  Int       m_framePackingSEIType;
    412412  Int       m_framePackingSEIId;
    413413  Int       m_framePackingSEIQuincunx;
    414414  Int       m_framePackingSEIInterpretation;
    415   Int       m_segmentedRectFramePackingSEIEnabled;
     415  Bool      m_segmentedRectFramePackingSEIEnabled;
    416416  Bool      m_segmentedRectFramePackingSEICancel;
    417417  Int       m_segmentedRectFramePackingSEIType;
    418418  Bool      m_segmentedRectFramePackingSEIPersistence;
    419419  Int       m_displayOrientationSEIAngle;
    420   Int       m_temporalLevel0IndexSEIEnabled;
    421   Int       m_gradualDecodingRefreshInfoEnabled;
     420  Bool      m_temporalLevel0IndexSEIEnabled;
     421  Bool      m_gradualDecodingRefreshInfoEnabled;
    422422  Int       m_noDisplaySEITLayer;
    423   Int       m_decodingUnitInfoSEIEnabled;
    424   Int       m_SOPDescriptionSEIEnabled;
    425   Int       m_scalableNestingSEIEnabled;
     423  Bool      m_decodingUnitInfoSEIEnabled;
     424  Bool      m_SOPDescriptionSEIEnabled;
     425  Bool      m_scalableNestingSEIEnabled;
    426426  Bool      m_tmctsSEIEnabled;
    427427  Bool      m_timeCodeSEIEnabled;
     
    442442  Bool      m_useWeightedPred;                    ///< Use of weighted prediction in P slices
    443443  Bool      m_useWeightedBiPred;                  ///< Use of bi-directional weighted prediction in B slices
     444  WeightedPredictionMethod m_weightedPredictionMethod;
    444445
    445446  UInt      m_log2ParallelMergeLevel;                         ///< Parallel merge estimation region
     
    455456  Int       m_RCInitialQP;                        ///< inital QP for rate control
    456457  Bool      m_RCForceIntraQP;                     ///< force all intra picture to use initial QP or not
    457  
     458
     459#if U0132_TARGET_BITS_SATURATION
     460  Bool      m_RCCpbSaturationEnabled;             ///< enable target bits saturation to avoid CPB overflow and underflow
     461  UInt      m_RCCpbSize;                          ///< CPB size
     462  Double    m_RCInitialCpbFullness;               ///< initial CPB fullness
     463#endif
     464
    458465#if KWU_RC_VIEWRC_E0227
    459466  vector<Int>     m_viewTargetBits;
     
    464471#endif
    465472
    466 ScalingListMode m_useScalingListId;                         ///< using quantization matrix
    467   Char*     m_scalingListFile;                                ///< quantization matrix file name
     473  ScalingListMode m_useScalingListId;                         ///< using quantization matrix
     474  std::string m_scalingListFileName;                          ///< quantization matrix file name
    468475
    469476  Bool      m_TransquantBypassEnableFlag;                     ///< transquant_bypass_enable_flag setting in PPS.
     
    509516  Int       m_log2MaxMvLengthHorizontal;                      ///< Indicate the maximum absolute value of a decoded horizontal MV component in quarter-pel luma units
    510517  Int       m_log2MaxMvLengthVertical;                        ///< Indicate the maximum absolute value of a decoded vertical MV component in quarter-pel luma units
     518  std::string m_colourRemapSEIFileRoot;
     519
    511520  std::string m_summaryOutFilename;                           ///< filename to use for producing summary output file.
    512521  std::string m_summaryPicFilenameBase;                       ///< Base filename to use for producing summary picture output files. The actual filenames used will have I.txt, P.txt and B.txt appended.
     
    528537  Bool      m_depth420OutputFlag;                             ///< Output depth layers in 4:2:0 format
    529538  // Camera parameters
    530   Char*     m_pchCameraParameterFile;                         ///< camera parameter file
    531   Char*     m_pchBaseViewCameraNumbers;
     539  TChar*    m_pchCameraParameterFile;                         ///< camera parameter file
     540  TChar*    m_pchBaseViewCameraNumbers;
    532541  TAppComCamPara m_cCameraData;
    533542  Int       m_iCodedCamParPrecision;                          ///< precision for coding of camera parameters
    534543#if NH_3D_VSO
    535   Char*     m_pchVSOConfig;
     544  TChar*    m_pchVSOConfig;
    536545  Bool      m_bUseVSO;                                        ///< flag for using View Synthesis Optimization
    537546  Bool      m_bVSOLSTable;                                    ///< Depth QP dependent Lagrange parameter optimization (m23714)
     
    674683  Void  create    ();                                         ///< create option handling class
    675684  Void  destroy   ();                                         ///< destroy option handling class
    676   Bool  parseCfg  ( Int argc, Char* argv[] );                 ///< parse configuration file to fill member variables
     685  Bool  parseCfg  ( Int argc, TChar* argv[] );                ///< parse configuration file to fill member variables
    677686
    678687};// END CLASS DEFINITION TAppEncCfg
  • branches/HTM-15.2-dev/source/App/TAppEncoder/TAppEncTop.cpp

    r1356 r1360  
    378378    m_cTEncTop.setLambdaModifier                                  ( uiLoop, m_adLambdaModifier[ uiLoop ] );
    379379  }
     380  m_cTEncTop.setIntraLambdaModifier                               ( m_adIntraLambdaModifier );
     381  m_cTEncTop.setIntraQpFactor                                     ( m_dIntraQpFactor );
     382
    380383#if NH_MV
    381384  m_cTEncTop.setQP                                                ( m_iQP[layerIdInVps] );
     
    385388
    386389  m_cTEncTop.setPad                                               ( m_aiPad );
    387 
     390  m_cTEncTop.setAccessUnitDelimiter                               ( m_AccessUnitDelimiter );
    388391#if NH_MV
    389392  m_cTEncTop.setMaxTempLayer                                      ( m_maxTempLayerMvc[layerIdInVps] );
     
    408411  //====== Motion search ========
    409412  m_cTEncTop.setDisableIntraPUsInInterSlices                      ( m_bDisableIntraPUsInInterSlices );
    410   m_cTEncTop.setFastSearch                                        ( m_iFastSearch  );
     413  m_cTEncTop.setMotionEstimationSearchMethod                      ( m_motionEstimationSearchMethod  );
    411414  m_cTEncTop.setSearchRange                                       ( m_iSearchRange );
    412415  m_cTEncTop.setBipredSearchRange                                 ( m_bipredSearchRange );
    413416  m_cTEncTop.setClipForBiPredMeEnabled                            ( m_bClipForBiPredMeEnabled );
    414417  m_cTEncTop.setFastMEAssumingSmootherMVEnabled                   ( m_bFastMEAssumingSmootherMVEnabled );
     418  m_cTEncTop.setMinSearchWindow                                   ( m_minSearchWindow );
     419  m_cTEncTop.setRestrictMESampling                                ( m_bRestrictMESampling );
    415420
    416421#if NH_MV
     
    439444  m_cTEncTop.setExtendedPrecisionProcessingFlag                   ( m_extendedPrecisionProcessingFlag );
    440445  m_cTEncTop.setHighPrecisionOffsetsEnabledFlag                   ( m_highPrecisionOffsetsEnabledFlag );
     446
     447  m_cTEncTop.setWeightedPredictionMethod( m_weightedPredictionMethod );
     448
    441449  //====== Tool list ========
    442450  m_cTEncTop.setDeltaQpRD                                         ( m_uiDeltaQpRD  );
     
    463471  m_cTEncTop.setQuadtreeTUMaxDepthInter                           ( m_uiQuadtreeTUMaxDepthInter );
    464472  m_cTEncTop.setQuadtreeTUMaxDepthIntra                           ( m_uiQuadtreeTUMaxDepthIntra );
    465   m_cTEncTop.setUseFastEnc                                        ( m_bUseFastEnc );
     473  m_cTEncTop.setFastInterSearchMode                               ( m_fastInterSearchMode );
    466474  m_cTEncTop.setUseEarlyCU                                        ( m_bUseEarlyCU  );
    467475  m_cTEncTop.setUseFastDecisionForMerge                           ( m_useFastDecisionForMerge  );
     
    513521
    514522  //====== Slice ========
    515   m_cTEncTop.setSliceMode                                         ( (SliceConstraint) m_sliceMode );
     523  m_cTEncTop.setSliceMode                                         ( m_sliceMode );
    516524  m_cTEncTop.setSliceArgument                                     ( m_sliceArgument            );
    517525
    518526  //====== Dependent Slice ========
    519   m_cTEncTop.setSliceSegmentMode                                  (  (SliceConstraint) m_sliceSegmentMode );
     527  m_cTEncTop.setSliceSegmentMode                                  ( m_sliceSegmentMode );
    520528  m_cTEncTop.setSliceSegmentArgument                              ( m_sliceSegmentArgument     );
    521529
     
    540548
    541549  m_cTEncTop.setIntraSmoothingDisabledFlag                        (!m_enableIntraReferenceSmoothing );
    542   m_cTEncTop.setDecodedPictureHashSEIEnabled                      ( m_decodedPictureHashSEIEnabled );
     550  m_cTEncTop.setDecodedPictureHashSEIType                         ( m_decodedPictureHashSEIType );
    543551  m_cTEncTop.setRecoveryPointSEIEnabled                           ( m_recoveryPointSEIEnabled );
    544552  m_cTEncTop.setBufferingPeriodSEIEnabled                         ( m_bufferingPeriodSEIEnabled );
     
    571579  m_cTEncTop.setTMISEINominalWhiteLevelLumaCodeValue              ( m_nominalWhiteLevelLumaCodeValue );
    572580  m_cTEncTop.setTMISEIExtendedWhiteLevelLumaCodeValue             ( m_extendedWhiteLevelLumaCodeValue );
    573   m_cTEncTop.setChromaSamplingFilterHintEnabled                   ( m_chromaSamplingFilterSEIenabled );
    574   m_cTEncTop.setChromaSamplingHorFilterIdc                        ( m_chromaSamplingHorFilterIdc );
    575   m_cTEncTop.setChromaSamplingVerFilterIdc                        ( m_chromaSamplingVerFilterIdc );
     581  m_cTEncTop.setChromaResamplingFilterHintEnabled                 ( m_chromaResamplingFilterSEIenabled );
     582  m_cTEncTop.setChromaResamplingHorFilterIdc                      ( m_chromaResamplingHorFilterIdc );
     583  m_cTEncTop.setChromaResamplingVerFilterIdc                      ( m_chromaResamplingVerFilterIdc );
    576584  m_cTEncTop.setFramePackingArrangementSEIEnabled                 ( m_framePackingSEIEnabled );
    577585  m_cTEncTop.setFramePackingArrangementSEIType                    ( m_framePackingSEIType );
     
    623631  m_cTEncTop.setKneeSEIInputKneePoint                             ( m_kneeSEIInputKneePoint );
    624632  m_cTEncTop.setKneeSEIOutputKneePoint                            ( m_kneeSEIOutputKneePoint );
     633  m_cTEncTop.setColourRemapInfoSEIFileRoot                        ( m_colourRemapSEIFileRoot );
    625634  m_cTEncTop.setMasteringDisplaySEI                               ( m_masteringDisplay );
    626635
     
    644653  }
    645654  m_cTEncTop.setLFCrossTileBoundaryFlag                           ( m_bLFCrossTileBoundaryFlag );
    646   m_cTEncTop.setWaveFrontSynchro                                  ( m_iWaveFrontSynchro );
     655  m_cTEncTop.setEntropyCodingSyncEnabledFlag                      ( m_entropyCodingSyncEnabledFlag );
    647656  m_cTEncTop.setTMVPModeId                                        ( m_TMVPModeId );
    648657  m_cTEncTop.setUseScalingListId                                  ( m_useScalingListId  );
    649   m_cTEncTop.setScalingListFile                                   ( m_scalingListFile  );
     658  m_cTEncTop.setScalingListFileName                               ( m_scalingListFileName );
    650659  m_cTEncTop.setSignHideFlag                                      ( m_signHideFlag);
    651660#if KWU_RC_VIEWRC_E0227 || KWU_RC_MADPRED_E0227
     
    669678  m_cTEncTop.setInitialQP                                         ( m_RCInitialQP );
    670679  m_cTEncTop.setForceIntraQP                                      ( m_RCForceIntraQP );
     680#if U0132_TARGET_BITS_SATURATION
     681  m_cTEncTop.setCpbSaturationEnabled                              ( m_RCCpbSaturationEnabled );
     682  m_cTEncTop.setCpbSize                                           ( m_RCCpbSize );
     683  m_cTEncTop.setInitialCpbFullness                                ( m_RCInitialCpbFullness );
     684#endif
     685
    671686#if KWU_RC_MADPRED_E0227
    672687  if(m_cTEncTop.getUseRateCtrl() && !m_cTEncTop.getIsDepth())
     
    843858#else
    844859  // Video I/O
    845   m_cTVideoIOYuvInputFile.open( m_pchInputFile,     false, m_inputBitDepth, m_MSBExtendedBitDepth, m_internalBitDepth );  // read  mode
     860  m_cTVideoIOYuvInputFile.open( m_inputFileName,     false, m_inputBitDepth, m_MSBExtendedBitDepth, m_internalBitDepth );  // read  mode
    846861  m_cTVideoIOYuvInputFile.skipFrames(m_FrameSkip, m_iSourceWidth - m_aiPad[0], m_iSourceHeight - m_aiPad[1], m_InputChromaFormatIDC);
    847862
    848   if (m_pchReconFile)
    849   {
    850     m_cTVideoIOYuvReconFile.open(m_pchReconFile, true, m_outputBitDepth, m_outputBitDepth, m_internalBitDepth);  // write mode
     863  if (!m_reconFileName.empty())
     864  {
     865    m_cTVideoIOYuvReconFile.open(m_reconFileName, true, m_outputBitDepth, m_outputBitDepth, m_internalBitDepth);  // write mode
    851866  }
    852867
     
    917932Void TAppEncTop::encode()
    918933{
    919   fstream bitstreamFile(m_pchBitstreamFile, fstream::binary | fstream::out);
     934  fstream bitstreamFile(m_bitstreamFileName.c_str(), fstream::binary | fstream::out);
    920935  if (!bitstreamFile)
    921936  {
    922     fprintf(stderr, "\nfailed to open bitstream file `%s' for writing\n", m_pchBitstreamFile);
     937    fprintf(stderr, "\nfailed to open bitstream file `%s' for writing\n", m_bitstreamFileName.c_str());
    923938    exit(EXIT_FAILURE);
    924939  }
     
    12951310  }
    12961311#else
    1297       if (m_pchReconFile)
     1312      if (!m_reconFileName.empty())
    12981313      {
    12991314        m_cTVideoIOYuvReconFile.write( pcPicYuvRecTop, pcPicYuvRecBottom, ipCSC, m_confWinLeft, m_confWinRight, m_confWinTop, m_confWinBottom, NUM_CHROMA_FORMAT, m_isTopFieldFirst );
     
    13521367  }
    13531368#else
    1354       if (m_pchReconFile)
     1369      if (!m_reconFileName.empty())
    13551370      {
    13561371        m_cTVideoIOYuvReconFile.write( pcPicYuvRec, ipCSC, m_confWinLeft, m_confWinRight, m_confWinTop, m_confWinBottom,
  • branches/HTM-15.2-dev/source/App/TAppExtractor/TAppExtrCfg.cpp

    r1179 r1360  
    5858    \param argv array of arguments
    5959 */
    60 Bool TAppExtrCfg::parseCfg( Int argc, Char* argv[] )
     60Bool TAppExtrCfg::parseCfg( Int argc, TChar* argv[] )
    6161{
    6262  bool do_help = false;
  • branches/HTM-15.2-dev/source/App/TAppExtractor/TAppExtrCfg.h

    r1179 r1360  
    6565  virtual ~TAppExtrCfg() {}
    6666 
    67   Bool  parseCfg        ( Int argc, Char* argv[] );    ///< initialize option class from configuration
     67  Bool  parseCfg        ( Int argc, TChar* argv[] );    ///< initialize option class from configuration
    6868
    6969protected:
  • branches/HTM-15.2-dev/source/App/TAppRenderer/TAppRendererCfg.cpp

    r1313 r1360  
    111111\retval             true when success
    112112*/
    113 Bool TAppRendererCfg::parseCfg( Int argc, Char* argv[] )
     113Bool TAppRendererCfg::parseCfg( Int argc, TChar* argv[] )
    114114{
    115115  bool do_help = false;
     
    121121
    122122    /* File I/O */
    123     ("VideoInputFileBaseName,v",  m_pchVideoInputFileBaseName,  (Char*) 0, "Basename to generate video input file names")
    124     ("DepthInputFileBaseName,d",  m_pchDepthInputFileBaseName,  (Char*) 0, "Basename to generate depth input file names")
    125     ("SynthOutputFileBaseName,s", m_pchSynthOutputFileBaseName, (Char*) 0, "Basename to generate synthesized output file names")
     123    ("VideoInputFileBaseName,v",  m_pchVideoInputFileBaseName,  (TChar*) 0, "Basename to generate video input file names")
     124    ("DepthInputFileBaseName,d",  m_pchDepthInputFileBaseName,  (TChar*) 0, "Basename to generate depth input file names")
     125    ("SynthOutputFileBaseName,s", m_pchSynthOutputFileBaseName, (TChar*) 0, "Basename to generate synthesized output file names")
    126126    ("ContOutputFileNumbering", m_bContOutputFileNumbering  ,  false   , "Continuous Output File Numbering")
    127127    ("Sweep"                  , m_bSweep                    ,  false   , "Store all views in first Output File")
    128128
    129     ("VideoInputFile_%d,v_%d",  m_pchVideoInputFileList ,    (Char *) 0, MAX_INPUT_VIEW_NUM , "Original Yuv video input file name %d")
    130     ("DepthInputFile_%d,d_%d",  m_pchDepthInputFileList ,    (Char *) 0, MAX_INPUT_VIEW_NUM , "Original Yuv depth input file name %d")
    131     ("SynthOutputFile_%d,s_%d", m_pchSynthOutputFileList,    (Char *) 0, MAX_OUTPUT_VIEW_NUM, "Synthesized Yuv output file name %d")
     129    ("VideoInputFile_%d,v_%d",  m_pchVideoInputFileList ,    (TChar *) 0, MAX_INPUT_VIEW_NUM , "Original Yuv video input file name %d")
     130    ("DepthInputFile_%d,d_%d",  m_pchDepthInputFileList ,    (TChar *) 0, MAX_INPUT_VIEW_NUM , "Original Yuv depth input file name %d")
     131    ("SynthOutputFile_%d,s_%d", m_pchSynthOutputFileList,    (TChar *) 0, MAX_OUTPUT_VIEW_NUM, "Synthesized Yuv output file name %d")
    132132
    133133    ("InputBitDepth",           m_inputBitDepth[0],                     8, "Bit-depth of input file")
     
    146146
    147147    /* Camera Specification */
    148     ("CameraParameterFile,-cpf", m_pchCameraParameterFile,          (Char *) 0, "Camera Parameter File Name")
    149     ("BaseViewCameraNumbers"  , m_pchBaseViewCameraNumbers,        (Char *) 0, "Numbers of base views")
    150     ("SynthViewCameraNumbers" , m_pchSynthViewCameraNumbers,       (Char *) 0, "Numbers of views to synthesis")
    151     ("ViewConfig"             , m_pchViewConfig,                   (Char *) 0, "View Configuration"               )
     148    ("CameraParameterFile,-cpf", m_pchCameraParameterFile,         (TChar *) 0, "Camera Parameter File Name")
     149    ("BaseViewCameraNumbers"  , m_pchBaseViewCameraNumbers,        (TChar *) 0, "Numbers of base views")
     150    ("SynthViewCameraNumbers" , m_pchSynthViewCameraNumbers,       (TChar *) 0, "Numbers of views to synthesis")
     151    ("ViewConfig"             , m_pchViewConfig,                   (TChar *) 0, "View Configuration"               )
    152152
    153153    /* Renderer Modes */
     
    458458}
    459459
    460 Void TAppRendererCfg::xAddNumberToFileName( Char* pchSourceFileName, Char*& rpchTargetFileName, Int iNumberToAdd, UInt uiPrecBefore, UInt uiPrecAfter )
     460Void TAppRendererCfg::xAddNumberToFileName( TChar* pchSourceFileName, TChar*& rpchTargetFileName, Int iNumberToAdd, UInt uiPrecBefore, UInt uiPrecAfter )
    461461{
    462462
     
    468468  }
    469469
    470   Char pchNumberBuffer[2* LOG10_VIEW_NUM_PREC + 2];
    471   Char pchPrintBuffer[10];
     470  TChar pchNumberBuffer[2* LOG10_VIEW_NUM_PREC + 2];
     471  TChar pchPrintBuffer[10];
    472472
    473473  Double dNumberToAdd = ( (Double) iNumberToAdd ) / VIEW_NUM_PREC;
     
    488488  size_t iAddLength = strlen(pchNumberBuffer);
    489489
    490   rpchTargetFileName = (Char*) malloc(iInLength+iAddLength+1);
    491 
    492   Char* pchPlaceHolder = strrchr(pchSourceFileName,'$');
     490  rpchTargetFileName = (TChar*) malloc(iInLength+iAddLength+1);
     491
     492  TChar* pchPlaceHolder = strrchr(pchSourceFileName,'$');
    493493  assert( pchPlaceHolder );
    494494
  • branches/HTM-15.2-dev/source/App/TAppRenderer/TAppRendererCfg.h

    r1313 r1360  
    5959
    6060  //// file I/O ////
    61   Char*              m_pchVideoInputFileBaseName;      ///< input video  file base name, placeholder for numbering $$
    62   Char*              m_pchDepthInputFileBaseName;      ///< input depth  file base name, placeholder for numbering $$
    63   Char*              m_pchSynthOutputFileBaseName;     ///< output synth file base name, placeholder for numbering $$
     61  TChar*             m_pchVideoInputFileBaseName;      ///< input video  file base name, placeholder for numbering $$
     62  TChar*             m_pchDepthInputFileBaseName;      ///< input depth  file base name, placeholder for numbering $$
     63  TChar*             m_pchSynthOutputFileBaseName;     ///< output synth file base name, placeholder for numbering $$
    6464  Bool               m_bContOutputFileNumbering;       ///< use continous numbering instead of view numbering
    6565  Bool               m_bSweep;                         ///< 1: Store view range in file
     
    7373
    7474  // derived
    75   std::vector<Char*> m_pchVideoInputFileList;          ///< source file names
    76   std::vector<Char*> m_pchDepthInputFileList;          ///< source depth file names
    77   std::vector<Char*> m_pchSynthOutputFileList;         ///< output reconstruction file names
     75  std::vector<TChar*> m_pchVideoInputFileList;         ///< source file names
     76  std::vector<TChar*> m_pchDepthInputFileList;         ///< source depth file names
     77  std::vector<TChar*> m_pchSynthOutputFileList;        ///< output reconstruction file names
    7878
    7979  //// source specification ////
     
    8484
    8585  ////camera specification ////
    86   Char*               m_pchCameraParameterFile;         ///< camera parameter file
    87   Char*               m_pchSynthViewCameraNumbers;      ///< numbers of views to synthesize
    88   Char*               m_pchViewConfig;                  ///< String to setup renderer
    89   Char*               m_pchBaseViewCameraNumbers;       ///< numbers of base views
     86  TChar*             m_pchCameraParameterFile;         ///< camera parameter file
     87  TChar*             m_pchSynthViewCameraNumbers;      ///< numbers of views to synthesize
     88  TChar*             m_pchViewConfig;                  ///< String to setup renderer
     89  TChar*             m_pchBaseViewCameraNumbers;       ///< numbers of base views
    9090
    9191  // derived
     
    123123  Void xCreateFileNames();
    124124  Void xGetMaxPrecision( IntAry1d adIn, Int& iPrecBefore, Int& iPrecAfter );
    125   Void xAddNumberToFileName( Char* pchSourceFileName, Char*& rpchTargetFileName, Int iNumberToAdd, UInt uiPrecBefore, UInt uiPrecAfter );
     125  Void xAddNumberToFileName( TChar* pchSourceFileName, TChar*& rpchTargetFileName, Int iNumberToAdd, UInt uiPrecBefore, UInt uiPrecAfter );
    126126public:
    127127  TAppRendererCfg();
     
    131131  Void  create    ();                                         ///< create option handling class
    132132  Void  destroy   ();                                         ///< destroy option handling class
    133   Bool  parseCfg  ( Int argc, Char* argv[] );                 ///< parse configuration file to fill member variables
    134   Bool  xConfirmParameter(Bool bflag, const Char* message);
     133  Bool  parseCfg  ( Int argc, TChar* argv[] );                 ///< parse configuration file to fill member variables
     134  Bool  xConfirmParameter(Bool bflag, const TChar* message);
    135135
    136136
  • branches/HTM-15.2-dev/source/App/utils/convert_NtoMbit_YCbCr.cpp

    r1313 r1360  
    105105
    106106  TComPicYuv frame;
    107   frame.create( width, height, chromaFormatIDC, width, height, 0, false);
     107  frame.createWithoutCUInfo( width, height, chromaFormatIDC);
    108108
    109109  Int pad[2] = {0, 0};
    110110
    111111  TComPicYuv cPicYuvTrueOrg;
    112   cPicYuvTrueOrg.create( width, height, chromaFormatIDC, width, height, 0, false );
     112  cPicYuvTrueOrg.createWithoutCUInfo( width, height, chromaFormatIDC );
    113113
    114114  UInt num_frames_processed = 0;
  • branches/HTM-15.2-dev/source/Lib/TAppCommon/TAppComCamPara.cpp

    r1313 r1360  
    115115
    116116Void
    117 TAppComCamPara::convertNumberString( Char* pchViewNumberString, std::vector<Int>& raiViewNumbers, Double dViewNumPrec )
     117TAppComCamPara::convertNumberString( TChar* pchViewNumberString, std::vector<Int>& raiViewNumbers, Double dViewNumPrec )
    118118{
    119119  Bool bStringIsRange = false;
     
    131131  }
    132132
    133   Char* pcNextStart = pchViewNumberString;
    134   Char* pcEnd       = pcNextStart + iIdx;
    135   Char* pcOldStart  = 0;
     133  TChar* pcNextStart = pchViewNumberString;
     134  TChar* pcEnd       = pcNextStart + iIdx;
     135  TChar* pcOldStart  = 0;
    136136
    137137  while( pcNextStart < pcEnd )
     
    192192
    193193Void
    194 TAppComCamPara::xReadCameraParameterFile( Char* pchCfgFileName )
     194TAppComCamPara::xReadCameraParameterFile( TChar* pchCfgFileName )
    195195{
    196196  std::ifstream cCfgStream( pchCfgFileName, std::ifstream::in );
     
    220220    }
    221221
    222     Char* pcNextStart = (Char*) cLine.data();
    223     Char* pcEnd = pcNextStart + cLine.length();
     222    TChar* pcNextStart = (TChar*) cLine.data();
     223    TChar* pcEnd = pcNextStart + cLine.length();
    224224
    225225    std::vector<Double> caNewLine;
    226226    caNewLine.clear();
    227227
    228     Char* pcOldStart = 0;
     228    TChar* pcOldStart = 0;
    229229    while( pcNextStart < pcEnd )
    230230    {
     
    10941094}
    10951095
    1096 Void TAppComCamPara::xSetupBaseViews( Char* pchBaseViewNumbers, UInt uiNumBaseViews )
     1096Void TAppComCamPara::xSetupBaseViews( TChar* pchBaseViewNumbers, UInt uiNumBaseViews )
    10971097  {
    10981098    // init list
     
    11421142                      UInt   uiStartFrameId,
    11431143                      UInt   uiNumFrames,
    1144                       Char* pchCfgFileName,
    1145                       Char* pchBaseViewNumbers,
    1146                       Char* pchSynthViewNumbers,
     1144                      TChar* pchCfgFileName,
     1145                      TChar* pchBaseViewNumbers,
     1146                      TChar* pchSynthViewNumbers,
    11471147                      std::vector<Int>* paiSynthViewNumbers,
    11481148                      Int    iLog2Precision )
  • branches/HTM-15.2-dev/source/Lib/TAppCommon/TAppComCamPara.h

    r1313 r1360  
    113113
    114114  // functions for reading, initialization, sorting, getting data, etc.
    115   Void  xReadCameraParameterFile  ( Char* pchCfgFileName );
     115  Void  xReadCameraParameterFile  ( TChar* pchCfgFileName );
    116116  Bool  xGetCameraDataRow         ( Int iView, UInt uiFrame, UInt& ruiFoundLine );
    117117
     
    129129#endif
    130130  Void  xSetupBaseViewsFromCoded  ();
    131   Void  xSetupBaseViews           ( Char* pchBaseViewNumbers, UInt uiNumBaseViews );
     131  Void  xSetupBaseViews           ( TChar* pchBaseViewNumbers, UInt uiNumBaseViews );
    132132  Bool  xIsIn                     ( std::vector<Int>& rVec, Int iNumber);
    133133
     
    156156                UInt    uiStartFrameId,
    157157                UInt    uiNumFrames,
    158                 Char*   pchCfgFileName,
    159                 Char*   pchBaseViewNumbers,
    160                 Char*   pchSynthViewNumbers,
     158                TChar*   pchCfgFileName,
     159                TChar*   pchBaseViewNumbers,
     160                TChar*   pchSynthViewNumbers,
    161161                std::vector<Int>* paiSynthViewNumbers,
    162162                Int     iLog2Precision );
     
    165165                UInt    uiStartFrameId,
    166166                UInt    uiNumFrames,
    167                 Char*   pchCfgFileName,
    168                 Char*   pchSynthViewNumbers,
     167                TChar*   pchCfgFileName,
     168                TChar*   pchSynthViewNumbers,
    169169                std::vector<Int>* paiSynthViewNumbers,
    170170                Int     iLog2Precision
     
    183183  Int                 getRelDistLeft            ( Int iSynthViewIdx, Int   iLeftViewIdx, Int iRightViewIdx );
    184184  UInt                getCurFrameId             ()  { return m_iCurrentFrameId;   }
    185   static Void         convertNumberString       ( Char* pchViewNumberString, std::vector<Int>& raiViewNumbers, Double dViewNumPrec );
     185  static Void         convertNumberString       ( TChar* pchViewNumberString, std::vector<Int>& raiViewNumbers, Double dViewNumPrec );
    186186#if H_3D_REN_MAX_DEV_OUT
    187187  Double              getMaxShiftDeviation      () { return m_dMaxShiftDeviation; };
  • branches/HTM-15.2-dev/source/Lib/TLibCommon/CommonDef.h

    r1357 r1360  
    4242#include <iostream>
    4343#include <assert.h>
     44#include <limits>
    4445
    4546#if _MSC_VER > 1000
     
    7576#define HM_VERSION        "16.6"                ///<
    7677#else
    77 #define NV_VERSION        "16.6"                 ///< Current software version
     78#define NV_VERSION        "16.7"                 ///< Current software version
    7879#endif
    7980// ====================================================================================================================
     
    141142
    142143static const Int AMVP_MAX_NUM_CANDS =                               2; ///< AMVP: advanced motion vector prediction - max number of final candidates
    143 static const Int AMVP_MAX_NUM_CANDS_MEM =                           3; ///< AMVP: advanced motion vector prediction - max number of candidates
    144144static const Int AMVP_DECIMATION_FACTOR =                           4;
    145145static const Int MRG_MAX_NUM_CANDS =                                5; ///< MERGE
  • branches/HTM-15.2-dev/source/Lib/TLibCommon/Debug.cpp

    r1321 r1360  
    4949#if DEBUG_STRING
    5050// these strings are used to reorder the debug output so that the encoder and decoder match.
    51 const Char *debug_reorder_data_inter_token[MAX_NUM_COMPONENT+1]
     51const TChar *debug_reorder_data_inter_token[MAX_NUM_COMPONENT+1]
    5252 = {"Start of channel 0 inter debug\n", "Start of channel 1 inter debug\n", "Start of channel 2 inter debug\n", "End of inter residual debug\n"} ;
    53 const Char *partSizeToString[NUMBER_OF_PART_SIZES]={"2Nx2N(0)", "2NxN(1)", "Nx2N(2)", "NxN(3)", "2Nx(N/2+3N/2)(4)", "2Nx(3N/2+N/2)(5)", "(N/2+3N/2)x2N(6)", "(3N/2+N/2)x2N(7)"};
     53const TChar *partSizeToString[NUMBER_OF_PART_SIZES]={"2Nx2N(0)", "2NxN(1)", "Nx2N(2)", "NxN(3)", "2Nx(N/2+3N/2)(4)", "2Nx(3N/2+N/2)(5)", "(N/2+3N/2)x2N(6)", "(3N/2+N/2)x2N(7)"};
    5454#endif
    5555
     
    179179  PRINT_CONSTANT(O0043_BEST_EFFORT_DECODING,                                        settingNameWidth, settingValueWidth);
    180180
     181  PRINT_CONSTANT(ME_ENABLE_ROUNDING_OF_MVS,                                         settingNameWidth, settingValueWidth);
     182  PRINT_CONSTANT(U0040_MODIFIED_WEIGHTEDPREDICTION_WITH_BIPRED_AND_CLIPPING,        settingNameWidth, settingValueWidth);
     183
    181184  //------------------------------------------------
    182185
     
    418421
    419422
    420 Void printBlockToStream( std::ostream &ss, const Char *pLinePrefix, TComYuv &src, const UInt numSubBlocksAcross, const UInt numSubBlocksUp, const UInt defWidth )
     423Void printBlockToStream( std::ostream &ss, const TChar *pLinePrefix, TComYuv &src, const UInt numSubBlocksAcross, const UInt numSubBlocksUp, const UInt defWidth )
    421424{
    422425  const UInt numValidComp=src.getNumberValidComponents();
  • branches/HTM-15.2-dev/source/Lib/TLibCommon/Debug.h

    r1313 r1360  
    4747#include <TLibCommon/CommonDef.h>
    4848#if DEBUG_STRING
    49 extern const Char *debug_reorder_data_inter_token[MAX_NUM_COMPONENT+1];
    50 extern const Char *partSizeToString[NUMBER_OF_PART_SIZES];
     49extern const TChar *debug_reorder_data_inter_token[MAX_NUM_COMPONENT+1];
     50extern const TChar *partSizeToString[NUMBER_OF_PART_SIZES];
    5151#endif
    5252
     
    149149UInt getZScanIndex(const UInt x, const UInt y);
    150150
    151 //template specialisation for Char types to get it to render as a number
     151//template specialisation for SChar/UChar types to get it to render as a number
    152152template <typename ValueType> inline Void writeValueToStream       (const ValueType &value, std::ostream &stream, const UInt outputWidth) { stream << std::setw(outputWidth) <<      value;  }
    153 template <>                   inline Void writeValueToStream<Char >(const Char      &value, std::ostream &stream, const UInt outputWidth) { stream << std::setw(outputWidth) <<  Int(value); }
     153template <>                   inline Void writeValueToStream<SChar>(const SChar     &value, std::ostream &stream, const UInt outputWidth) { stream << std::setw(outputWidth) <<  Int(value); }
    154154template <>                   inline Void writeValueToStream<UChar>(const UChar     &value, std::ostream &stream, const UInt outputWidth) { stream << std::setw(outputWidth) << UInt(value); }
    155155
     
    231231
    232232template <typename T>
    233 Void printBlockToStream( std::ostream &ss, const Char *pLinePrefix, const T * blkSrc, const UInt width, const UInt height, const UInt stride, const UInt subBlockWidth=0, const UInt subBlockHeight=0, const UInt defWidth=3 )
     233Void printBlockToStream( std::ostream &ss, const TChar *pLinePrefix, const T * blkSrc, const UInt width, const UInt height, const UInt stride, const UInt subBlockWidth=0, const UInt subBlockHeight=0, const UInt defWidth=3 )
    234234{
    235235  for (UInt y=0; y<height; y++)
     
    255255
    256256class TComYuv;
    257 Void printBlockToStream( std::ostream &ss, const Char *pLinePrefix, TComYuv &src, const UInt numSubBlocksAcross=1, const UInt numSubBlocksUp=1, const UInt defWidth=3 );
     257Void printBlockToStream( std::ostream &ss, const TChar *pLinePrefix, TComYuv &src, const UInt numSubBlocksAcross=1, const UInt numSubBlocksUp=1, const UInt defWidth=3 );
    258258
    259259// ---------------------------------------------------------------------------------------------- //
  • branches/HTM-15.2-dev/source/Lib/TLibCommon/SEI.cpp

    r1356 r1360  
    118118
    119119// Static member
    120 const Char *SEI::getSEIMessageString(SEI::PayloadType payloadType)
     120const TChar *SEI::getSEIMessageString(SEI::PayloadType payloadType)
    121121{
    122122  switch (payloadType)
     
    151151    case SEI::SEGM_RECT_FRAME_PACKING:              return "Segmented rectangular frame packing arrangement";
    152152    case SEI::TEMP_MOTION_CONSTRAINED_TILE_SETS:    return "Temporal motion constrained tile sets";
    153     case SEI::CHROMA_SAMPLING_FILTER_HINT:          return "Chroma sampling filter hint";
     153    case SEI::CHROMA_RESAMPLING_FILTER_HINT:        return "Chroma sampling filter hint";
     154    case SEI::COLOUR_REMAPPING_INFO:                return "Colour remapping info";
     155
    154156#if NH_MV
    155     case SEI::COLOUR_REMAPPING_INFO:                     return "Colour remapping information";
    156157    case SEI::DEINTERLACED_FIELD_IDENTIFICATION:         return "Deinterlaced field identification";
    157158    case SEI::LAYERS_NOT_PRESENT:                        return "Layers not present";
     
    266267}
    267268
    268 Void SEI::setupFromCfgFile( const Char* cfgFile )
     269Void SEI::setupFromCfgFile( const TChar* cfgFile )
    269270{
    270271  assert( false );
     
    304305}
    305306
    306 Void SEI::xCheckCfgRange( Bool& wrongConfig, Int val, Int minVal, Int maxVal, const Char* seName )
     307Void SEI::xCheckCfgRange( Bool& wrongConfig, Int val, Int minVal, Int maxVal, const TChar* seName )
    307308{
    308309  if ( val < minVal || val > maxVal  )
     
    329330}
    330331
    331 Void SEI::xCheckCfg( Bool& wrongConfig, Bool cond, const Char* errStr )
     332Void SEI::xCheckCfg( Bool& wrongConfig, Bool cond, const TChar* errStr )
    332333{
    333334  if ( !cond  )
     
    341342
    342343#if NH_MV_LAYERS_NOT_PRESENT_SEI
    343 Void SEILayersNotPresent::setupFromCfgFile(const Char* cfgFile)
     344Void SEILayersNotPresent::setupFromCfgFile(const TChar* cfgFile)
    344345{
    345346  // Set default values
     
    401402
    402403
    403 Void SEIInterLayerConstrainedTileSets::setupFromCfgFile(const Char* cfgFile)
     404Void SEIInterLayerConstrainedTileSets::setupFromCfgFile(const TChar* cfgFile)
    404405{
    405406  // Set default values
     
    483484};
    484485
    485 Void SEIBspNesting::setupFromCfgFile(const Char* cfgFile)
     486Void SEIBspNesting::setupFromCfgFile(const TChar* cfgFile)
    486487{
    487488  // Set default values
     
    556557};
    557558
    558 Void SEIBspInitialArrivalTime::setupFromCfgFile(const Char* cfgFile)
     559Void SEIBspInitialArrivalTime::setupFromCfgFile(const TChar* cfgFile)
    559560{
    560561  // Set default values
     
    605606#endif
    606607
    607 Void SEISubBitstreamProperty::setupFromCfgFile(const Char* cfgFile)
     608Void SEISubBitstreamProperty::setupFromCfgFile(const TChar* cfgFile)
    608609{
    609610  // Set default values
     
    681682}
    682683
    683 Void SEIAlphaChannelInfo::setupFromCfgFile(const Char* cfgFile)
     684Void SEIAlphaChannelInfo::setupFromCfgFile(const TChar* cfgFile)
    684685{
    685686  // Set default values
     
    744745{ };
    745746
    746 Void SEIOverlayInfo::setupFromCfgFile(const Char* cfgFile)
     747Void SEIOverlayInfo::setupFromCfgFile(const TChar* cfgFile)
    747748{
    748749  // Set default values
     
    828829
    829830
    830 Void SEITemporalMvPredictionConstraints::setupFromCfgFile(const Char* cfgFile)
     831Void SEITemporalMvPredictionConstraints::setupFromCfgFile(const TChar* cfgFile)
    831832{
    832833  // Set default values
     
    870871
    871872#if NH_MV_SEI_TBD
    872 Void SEIFrameFieldInfo::setupFromCfgFile(const Char* cfgFile)
     873Void SEIFrameFieldInfo::setupFromCfgFile(const TChar* cfgFile)
    873874{
    874875  // Set default values
     
    922923#endif
    923924
    924 Void SEIThreeDimensionalReferenceDisplaysInfo::setupFromCfgFile(const Char* cfgFile)
     925Void SEIThreeDimensionalReferenceDisplaysInfo::setupFromCfgFile(const TChar* cfgFile)
    925926{
    926927  // Set default values
     
    10251026};
    10261027
    1027 Void SEIDepthRepresentationInfo::setupFromCfgFile(const Char* cfgFile)
     1028Void SEIDepthRepresentationInfo::setupFromCfgFile(const TChar* cfgFile)
    10281029{
    10291030  // Set default values
     
    11971198#endif
    11981199
    1199 Void SEIMultiviewSceneInfo::setupFromCfgFile(const Char* cfgFile)
     1200Void SEIMultiviewSceneInfo::setupFromCfgFile(const TChar* cfgFile)
    12001201{
    12011202  // Set default values
     
    12431244};
    12441245
    1245 Void SEIMultiviewAcquisitionInfo::setupFromCfgFile(const Char* cfgFile)
     1246Void SEIMultiviewAcquisitionInfo::setupFromCfgFile(const TChar* cfgFile)
    12461247{
    12471248  // Set default values
     
    14051406}
    14061407
    1407 Void SEIMultiviewViewPosition::setupFromCfgFile(const Char* cfgFile)
     1408Void SEIMultiviewViewPosition::setupFromCfgFile(const TChar* cfgFile)
    14081409{
    14091410  // Set default values
     
    14561457
    14571458#if NH_3D
    1458 Void SEIAlternativeDepthInfo::setupFromCfgFile(const Char* cfgFile)
     1459Void SEIAlternativeDepthInfo::setupFromCfgFile(const TChar* cfgFile)
    14591460{
    14601461  // Set default values
  • branches/HTM-15.2-dev/source/Lib/TLibCommon/SEI.h

    r1356 r1360  
    9494    SEGM_RECT_FRAME_PACKING              = 138,
    9595    TEMP_MOTION_CONSTRAINED_TILE_SETS    = 139,
    96     CHROMA_SAMPLING_FILTER_HINT          = 140,
    97     KNEE_FUNCTION_INFO                   = 141
     96    CHROMA_RESAMPLING_FILTER_HINT        = 140,
     97    KNEE_FUNCTION_INFO                   = 141,
     98    COLOUR_REMAPPING_INFO                = 142,
    9899#if NH_MV_SEI
    99     ,COLOUR_REMAPPING_INFO                    = 142,
    100100    DEINTERLACED_FIELD_IDENTIFICATION         = 143,
    101101    LAYERS_NOT_PRESENT                        = 160,
     
    120120  };
    121121
     122#if NH_MV
    122123  SEI();
     124#else
     125  SEI() {}
     126#endif
     127
    123128
    124129  virtual ~SEI() {}
     130
     131  static const TChar *getSEIMessageString(SEI::PayloadType payloadType);
     132
     133  virtual PayloadType payloadType() const = 0;
     134
     135#if NH_MV_SEI
    125136  virtual SEI*       getCopy( ) const;
    126   static const Char *getSEIMessageString(SEI::PayloadType payloadType );
    127   virtual PayloadType payloadType() const = 0;
    128 
    129 #if NH_MV_SEI
    130137  static SEI*        getNewSEIMessage         ( SEI::PayloadType payloadType );
    131138  Bool               insertSei                ( Int curLayerId, Int curPoc, Int curTid, Int curNaluType ) const;
     
    133140
    134141  virtual Void       setupFromSlice           ( const TComSlice* slice );
    135   virtual Void       setupFromCfgFile         ( const Char* cfgFile );
     142  virtual Void       setupFromCfgFile         ( const TChar*  cfgFile );
    136143  virtual Bool       checkCfg                 ( const TComSlice* slice   );
    137144
    138145  Void               xPrintCfgErrorIntro();
    139   Void               xCheckCfgRange           ( Bool& wrongConfig, Int val, Int minVal, Int maxVal, const Char* seName );
    140   Void               xCheckCfg                ( Bool& wrongConfig, Bool cond, const Char* errStr );
     146  Void               xCheckCfgRange           ( Bool& wrongConfig, Int val, Int minVal, Int maxVal, const TChar* seName );
     147  Void               xCheckCfg                ( Bool& wrongConfig, Bool cond, const TChar* errStr );
    141148  Void               xAddGeneralOpts          ( po::Options &opts, IntAry1d defAppLayerIds, IntAry1d defAppPocs, IntAry1d defAppTids, IntAry1d defAppVclNaluTypes,
    142149                                                Int defSeiNaluId, Int defPositionInSeiNalu, Bool defModifyByEncoder );
     
    186193  virtual ~SEIDecodedPictureHash() {}
    187194
    188   enum Method
    189   {
    190     MD5,
    191     CRC,
    192     CHECKSUM,
    193     RESERVED,
    194   } method;
     195  HashType method;
    195196
    196197  TComPictureHash m_pictureHash;
     
    482483};
    483484
    484 class SEIChromaSamplingFilterHint : public SEI
    485 {
    486 public:
    487   PayloadType payloadType() const {return CHROMA_SAMPLING_FILTER_HINT;}
    488   SEIChromaSamplingFilterHint() {}
    489   virtual ~SEIChromaSamplingFilterHint() {
    490     if(m_verChromaFilterIdc == 1)
     485class SEIColourRemappingInfo : public SEI
     486{
     487public:
     488
     489  struct CRIlut
     490  {
     491    Int codedValue;
     492    Int targetValue;
     493    bool operator < (const CRIlut& a) const
    491494    {
    492       for(Int i = 0; i < m_numVerticalFilters; i ++)
     495      return codedValue < a.codedValue;
     496    }
     497  };
     498
     499  PayloadType payloadType() const { return COLOUR_REMAPPING_INFO; }
     500  SEIColourRemappingInfo() {}
     501  ~SEIColourRemappingInfo() {}
     502
     503  Void copyFrom( const SEIColourRemappingInfo &seiCriInput)
    493504      {
    494         free(m_verFilterCoeff[i]);
    495       }
    496       free(m_verFilterCoeff);
    497       free(m_verTapLengthMinus1);
    498     }
    499     if(m_horChromaFilterIdc == 1)
    500     {
    501       for(Int i = 0; i < m_numHorizontalFilters; i ++)
    502       {
    503         free(m_horFilterCoeff[i]);
    504       }
    505       free(m_horFilterCoeff);
    506       free(m_horTapLengthMinus1);
    507     }
     505    (*this) = seiCriInput;
    508506  }
     507
     508  UInt                m_colourRemapId;
     509  Bool                m_colourRemapCancelFlag;
     510  Bool                m_colourRemapPersistenceFlag;
     511  Bool                m_colourRemapVideoSignalInfoPresentFlag;
     512  Bool                m_colourRemapFullRangeFlag;
     513  Int                 m_colourRemapPrimaries;
     514  Int                 m_colourRemapTransferFunction;
     515  Int                 m_colourRemapMatrixCoefficients;
     516  Int                 m_colourRemapInputBitDepth;
     517  Int                 m_colourRemapBitDepth;
     518  Int                 m_preLutNumValMinus1[3];
     519  std::vector<CRIlut> m_preLut[3];
     520  Bool                m_colourRemapMatrixPresentFlag;
     521  Int                 m_log2MatrixDenom;
     522  Int                 m_colourRemapCoeffs[3][3];
     523  Int                 m_postLutNumValMinus1[3];
     524  std::vector<CRIlut> m_postLut[3];
     525};
     526
     527class SEIChromaResamplingFilterHint : public SEI
     528{
     529public:
     530  PayloadType payloadType() const {return CHROMA_RESAMPLING_FILTER_HINT;}
     531  SEIChromaResamplingFilterHint() {}
     532  virtual ~SEIChromaResamplingFilterHint() {}
    509533
    510534  Int   m_verChromaFilterIdc;
    511535  Int   m_horChromaFilterIdc;
    512   Bool  m_verFilteringProcessFlag;
     536  Bool                           m_verFilteringFieldProcessingFlag;
    513537  Int   m_targetFormatIdc;
    514538  Bool  m_perfectReconstructionFlag;
    515   Int   m_numVerticalFilters;
    516   Int*  m_verTapLengthMinus1;
    517   Int** m_verFilterCoeff;
    518   Int   m_numHorizontalFilters;
    519   Int*  m_horTapLengthMinus1;
    520   Int** m_horFilterCoeff;
     539  std::vector<std::vector<Int> > m_verFilterCoeff;
     540  std::vector<std::vector<Int> > m_horFilterCoeff;
    521541};
    522542
     
    669689  SEI* getCopy( ) const { return new SEILayersNotPresent(*this); };
    670690
    671   Void setupFromCfgFile( const Char*      cfgFile );
     691  Void setupFromCfgFile( const TChar*     cfgFile );
    672692  Bool checkCfg        ( const TComSlice* slice   );
    673693
     
    691711  SEI* getCopy( ) const { return new SEIInterLayerConstrainedTileSets(*this); };
    692712
    693   Void setupFromCfgFile( const Char*      cfgFile );
     713  Void setupFromCfgFile( const TChar*     cfgFile );
    694714  Bool checkCfg        ( const TComSlice* slice   );
    695715
     
    733753  SEI* getCopy( ) const { return new SEIBspNesting(*this); };
    734754
    735   Void setupFromCfgFile( const Char*      cfgFile );
     755  Void setupFromCfgFile( const TChar*      cfgFile );
    736756  Void setupFromSlice  ( const TComSlice* slice   );
    737757  Bool checkCfg        ( const TComSlice* slice   );
     
    752772  SEI* getCopy( ) const { return new SEIBspInitialArrivalTime(*this); };
    753773
    754   Void setupFromCfgFile( const Char*      cfgFile );
     774  Void setupFromCfgFile( const TChar*      cfgFile );
    755775  Void setupFromSlice  ( const TComSlice* slice   );
    756776  Bool checkCfg        ( const TComSlice* slice   );
     
    769789  SEI* getCopy( ) const { return new SEISubBitstreamProperty(*this); };
    770790
    771   Void setupFromCfgFile( const Char*      cfgFile );
     791  Void setupFromCfgFile( const TChar*     cfgFile );
    772792  Bool checkCfg        ( const TComSlice* slice   );
    773793  Void resizeArrays    ( );
     
    790810  SEI* getCopy( ) const { return new SEIAlphaChannelInfo(*this); };
    791811
    792   Void setupFromCfgFile( const Char*      cfgFile );
     812  Void setupFromCfgFile( const TChar*     cfgFile );
    793813  Bool checkCfg        ( const TComSlice* slice   );
    794814
     
    811831  SEI* getCopy( ) const { return new SEIOverlayInfo(*this); };
    812832
    813   Void setupFromCfgFile( const Char*      cfgFile );
     833  Void setupFromCfgFile( const TChar*     cfgFile );
    814834  Bool checkCfg        ( const TComSlice* slice   );
    815835
     
    848868  SEI* getCopy( ) const { return new SEITemporalMvPredictionConstraints(*this); };
    849869
    850   Void setupFromCfgFile( const Char*      cfgFile );
     870  Void setupFromCfgFile( const TChar*     cfgFile );
    851871  Bool checkCfg        ( const TComSlice* slice   );
    852872
     
    864884  SEI* getCopy( ) const { return new SEIFrameFieldInfo(*this); };
    865885
    866   Void setupFromCfgFile( const Char*      cfgFile );
     886  Void setupFromCfgFile( const TChar*     cfgFile );
    867887  Void setupFromSlice  ( const TComSlice* slice   );
    868888  Bool checkCfg        ( const TComSlice* slice   );
     
    882902  SEI* getCopy( ) const { return new SEIThreeDimensionalReferenceDisplaysInfo(*this); };
    883903
    884   Void setupFromCfgFile( const Char*      cfgFile );
     904  Void setupFromCfgFile( const TChar*     cfgFile );
    885905  Bool checkCfg        ( const TComSlice* slice   );
    886906
     
    936956        SEI* getCopy( ) const { return new SEIDepthRepresentationInfo(*this); };
    937957
    938         Void setupFromCfgFile( const Char*      cfgFile );
     958        Void setupFromCfgFile( const TChar*     cfgFile );
    939959        Void setupFromSlice  ( const TComSlice* slice   );
    940960        Bool checkCfg        ( const TComSlice* slice   );
     
    10031023  SEI* getCopy( ) const { return new SEIMultiviewSceneInfo(*this); };
    10041024
    1005   Void setupFromCfgFile( const Char*      cfgFile );
     1025  Void setupFromCfgFile( const TChar*     cfgFile );
    10061026  Bool checkCfg        ( const TComSlice* slice   );
    10071027
     
    10191039  SEI* getCopy( ) const { return new SEIMultiviewAcquisitionInfo(*this); };
    10201040
    1021   Void setupFromCfgFile( const Char*      cfgFile );
     1041  Void setupFromCfgFile( const TChar*     cfgFile );
    10221042  Bool checkCfg        ( const TComSlice* slice   );
    10231043
     
    11311151  SEI* getCopy( ) const { return new SEIMultiviewViewPosition(*this); };
    11321152
    1133   Void setupFromCfgFile( const Char*      cfgFile );
     1153  Void setupFromCfgFile( const TChar*     cfgFile );
    11341154  Void setupFromSlice  ( const TComSlice* slice   );
    11351155  Bool checkCfg        ( const TComSlice* slice   );
     
    11481168  SEI* getCopy( ) const { return new SEIAlternativeDepthInfo(*this); };
    11491169
    1150   Void setupFromCfgFile( const Char*      cfgFile );
     1170  Void setupFromCfgFile( const TChar*     cfgFile );
    11511171  Bool checkCfg        ( const TComSlice* slice   );
    11521172
  • branches/HTM-15.2-dev/source/Lib/TLibCommon/TComBitStream.cpp

    r1321 r1360  
    9393}
    9494
    95 Char* TComOutputBitstream::getByteStream() const
    96 {
    97   return (Char*) &m_fifo.front();
     95UChar* TComOutputBitstream::getByteStream() const
     96{
     97  return (UChar*) &m_fifo.front();
    9898}
    9999
  • branches/HTM-15.2-dev/source/Lib/TLibCommon/TComBitStream.h

    r1313 r1360  
    115115   * bytestream are stored in ascending addresses.
    116116   */
    117   Char* getByteStream() const;
     117  UChar* getByteStream() const;
    118118
    119119  /**
  • branches/HTM-15.2-dev/source/Lib/TLibCommon/TComCodingStatistics.h

    r1321 r1360  
    120120};
    121121
    122 static inline const Char* getName(TComCodingStatisticsType name)
     122static inline const TChar* getName(TComCodingStatisticsType name)
    123123{
    124   static const Char *statNames[]=
     124  static const TChar *statNames[]=
    125125  {
    126126    "NAL_UNIT_TOTAL_BODY", // This is a special case and is not included in the total sums.
     
    189189#endif
    190190  };
    191   assert(STATS__NUM_STATS == sizeof(statNames)/sizeof(Char *) && name < STATS__NUM_STATS);
     191  assert(STATS__NUM_STATS == sizeof(statNames)/sizeof(TChar *) && name < STATS__NUM_STATS);
    192192  return statNames[name];
    193193}
     
    229229  }
    230230
    231   static const Char *GetSubClassString(const UInt subClass)
     231  static const TChar *GetSubClassString(const UInt subClass)
    232232  {
    233233    assert (subClass<CODING_STATS_NUM_SUBCLASSES);
    234     static const Char *strings[1+MAX_NUM_COMPONENT+MAX_NUM_CHANNEL_TYPE]={"-", "Y", "Cb", "Cr", "Luma", "Chroma"};
     234    static const TChar *strings[1+MAX_NUM_COMPONENT+MAX_NUM_CHANNEL_TYPE]={"-", "Y", "Cb", "Cr", "Luma", "Chroma"};
    235235    return strings[subClass/CODING_STATS_NUM_WIDTHS];
    236236  }
     
    289289    { }
    290290
    291     static Void OutputLine(const Char *pName, const Char sep, UInt width, const Char *pSubClassStr, const SStat &sCABAC, const SStat &sEP)
     291    static Void OutputLine(const TChar *pName, const TChar sep, UInt width, const TChar *pSubClassStr, const SStat &sCABAC, const SStat &sEP)
    292292    {
    293293      if (width==0)
     
    302302      }
    303303    }
    304     static Void OutputLine(const Char *pName, const Char sep, const Char *pWidthString, const Char *pSubClassStr, const SStat &sCABAC, const SStat &sEP)
     304    static Void OutputLine(const TChar *pName, const TChar sep, const TChar *pWidthString, const TChar *pSubClassStr, const SStat &sCABAC, const SStat &sEP)
    305305    {
    306306      printf("%c%-45s%c  %6s %6s %12lld %12lld %12lld %12lld %12lld %12lld %12lld (%12lld)%c\n",
     
    308308              sCABAC.count, sCABAC.sum, sCABAC.bits, sEP.count, sEP.sum, sEP.bits, sCABAC.bits+sEP.bits, (sCABAC.bits+sEP.bits)/8, sep=='~'?']':' ');
    309309    }
    310     static Void OutputLine(const Char *pName, const Char sep, const Char *pWidthString, const Char *pSubClassStr,  const SStat &sEP)
     310    static Void OutputLine(const TChar *pName, const TChar sep, const TChar *pWidthString, const TChar *pSubClassStr,  const SStat &sEP)
    311311    {
    312312      printf("%c%-45s%c  %6s %6s %12s %12s %12s %12lld %12lld %12lld %12lld (%12lld)%c\n",
     
    315315    }
    316316
    317     static Void OutputDashedLine(const Char *pText)
     317    static Void OutputDashedLine(const TChar *pText)
    318318    {
    319319      printf("--%s",pText);
     
    360360        SStat cabacSubTotal, epSubTotal;
    361361        Bool bHadClassifiedEntry=false;
    362         const Char *pName=getName(TComCodingStatisticsType(i));
     362        const TChar *pName=getName(TComCodingStatisticsType(i));
    363363
    364364        for(UInt c=0; c<CODING_STATS_NUM_SUBCLASSES; c++)
     
    488488    static SStat &GetStatisticEP(const std::string &str) { return GetSingletonInstance().data.mappings_ep[str]; }
    489489
    490     static SStat &GetStatisticEP(const Char *pKey) {return GetStatisticEP(std::string(pKey)); }
     490    static SStat &GetStatisticEP(const TChar *pKey) {return GetStatisticEP(std::string(pKey)); }
    491491
    492492    static Void IncrementStatisticEP(const TComCodingStatisticsClassType &stat, const Int numBits, const Int value)
     
    506506    }
    507507
    508     static Void IncrementStatisticEP(const Char *pKey, const Int numBits, const Int value)
     508    static Void IncrementStatisticEP(const TChar *pKey, const Int numBits, const Int value)
    509509    {
    510510      SStat &s=GetStatisticEP(pKey);
  • branches/HTM-15.2-dev/source/Lib/TLibCommon/TComDataCU.cpp

    r1356 r1360  
    160160  if ( !bDecSubCu )
    161161  {
    162     m_phQP               = (Char*     )xMalloc(Char,     uiNumPartition);
     162    m_phQP               = (SChar*    )xMalloc(SChar,    uiNumPartition);
    163163    m_puhDepth           = (UChar*    )xMalloc(UChar,    uiNumPartition);
    164164    m_puhWidth           = (UChar*    )xMalloc(UChar,    uiNumPartition);
     
    171171    m_ucDISType          = (UChar*)xMalloc(UChar, uiNumPartition);
    172172#endif
    173     m_pePartSize         = new Char[ uiNumPartition ];
     173    m_pePartSize         = new SChar[ uiNumPartition ];
    174174    memset( m_pePartSize, NUMBER_OF_PART_SIZES,uiNumPartition * sizeof( *m_pePartSize ) );
    175     m_pePredMode         = new Char[ uiNumPartition ];
     175    m_pePredMode         = new SChar[ uiNumPartition ];
    176176    m_CUTransquantBypass = new Bool[ uiNumPartition ];
    177177
     
    179179    m_puhMergeIndex      = (UChar* )xMalloc(UChar,  uiNumPartition);
    180180#if NH_3D_VSP
    181     m_piVSPFlag          = (Char*  )xMalloc(Char,  uiNumPartition);
     181    m_piVSPFlag          = (SChar* )xMalloc(SChar, uiNumPartition);
    182182#endif
    183183#if NH_3D_SPIVMP
     
    196196    {
    197197      const RefPicList rpl=RefPicList(i);
    198       m_apiMVPIdx[rpl]       = new Char[ uiNumPartition ];
    199       m_apiMVPNum[rpl]       = new Char[ uiNumPartition ];
    200       memset( m_apiMVPIdx[rpl], -1,uiNumPartition * sizeof( Char ) );
     198      m_apiMVPIdx[rpl]       = new SChar[ uiNumPartition ];
     199      m_apiMVPNum[rpl]       = new SChar[ uiNumPartition ];
     200      memset( m_apiMVPIdx[rpl], -1,uiNumPartition * sizeof( SChar ) );
    201201    }
    202202
     
    212212      const UInt totalSize   = (uiWidth * uiHeight) >> chromaShift;
    213213
    214       m_crossComponentPredictionAlpha[compID] = (Char*  )xMalloc(Char,   uiNumPartition);
     214      m_crossComponentPredictionAlpha[compID] = (SChar* )xMalloc(SChar,  uiNumPartition);
    215215      m_puhTransformSkip[compID]              = (UChar* )xMalloc(UChar,  uiNumPartition);
    216216      m_explicitRdpcmMode[compID]             = (UChar* )xMalloc(UChar,  uiNumPartition);
     
    524524}
    525525
    526 Bool TComDataCU::isLastSubCUOfCtu(const UInt absPartIdx)
     526Bool TComDataCU::isLastSubCUOfCtu(const UInt absPartIdx) const
    527527{
    528528  const TComSPS &sps=*(getSlice()->getSPS());
     
    844844  Int iSizeInUchar = sizeof( UChar  ) * m_uiNumPartition;
    845845  Int iSizeInBool  = sizeof( Bool   ) * m_uiNumPartition;
    846   Int sizeInChar = sizeof( Char  ) * m_uiNumPartition;
     846  Int sizeInChar = sizeof( SChar  ) * m_uiNumPartition;
    847847
    848848  memset( m_phQP,              qp,  sizeInChar );
     
    850850  memset( m_puhMergeIndex,      0, iSizeInUchar );
    851851#if NH_3D_VSP
    852   memset( m_piVSPFlag,          0, sizeof( Char ) * m_uiNumPartition );
     852  memset( m_piVSPFlag,          0, sizeof( SChar ) * m_uiNumPartition );
    853853#endif
    854854#if NH_3D_SPIVMP
     
    12191219  Int iSizeInBool   = sizeof( Bool  ) * uiNumPartition;
    12201220
    1221   Int sizeInChar  = sizeof( Char ) * uiNumPartition;
     1221  Int sizeInChar  = sizeof( SChar ) * uiNumPartition;
    12221222  memcpy( m_skipFlag   + uiOffset, pcCU->getSkipFlag(),       sizeof( *m_skipFlag )   * uiNumPartition );
    12231223#if NH_3D_DIS
     
    12331233  memcpy( m_puhMergeIndex       + uiOffset, pcCU->getMergeIndex(),        iSizeInUchar );
    12341234#if NH_3D_VSP
    1235   memcpy( m_piVSPFlag           + uiOffset, pcCU->getVSPFlag(),           sizeof( Char ) * uiNumPartition );
     1235  memcpy( m_piVSPFlag           + uiOffset, pcCU->getVSPFlag(),           sizeof( SChar ) * uiNumPartition );
    12361236  memcpy( m_pDvInfo             + uiOffset, pcCU->getDvInfo(),            sizeof( *m_pDvInfo ) * uiNumPartition );
    12371237#endif
     
    13351335  Int iSizeInUchar  = sizeof( UChar ) * m_uiNumPartition;
    13361336  Int iSizeInBool   = sizeof( Bool  ) * m_uiNumPartition;
    1337   Int sizeInChar  = sizeof( Char ) * m_uiNumPartition;
     1337  Int sizeInChar  = sizeof( SChar ) * m_uiNumPartition;
    13381338
    13391339  memcpy( pCtu->getSkipFlag() + m_absZIdxInCtu, m_skipFlag, sizeof( *m_skipFlag ) * m_uiNumPartition );
     
    13551355  memcpy( pCtu->getMergeIndex()        + m_absZIdxInCtu, m_puhMergeIndex,       iSizeInUchar );
    13561356#if NH_3D_VSP
    1357   memcpy( pCtu->getVSPFlag()           + m_absZIdxInCtu, m_piVSPFlag,           sizeof( Char ) * m_uiNumPartition );
     1357  memcpy( pCtu->getVSPFlag()           + m_absZIdxInCtu, m_piVSPFlag,           sizeof( SChar ) * m_uiNumPartition );
    13581358#endif
    13591359#if NH_3D_DBBP
     
    14471447// --------------------------------------------------------------------------------------------------------------------
    14481448
    1449 TComDataCU* TComDataCU::getPULeft( UInt& uiLPartUnitIdx,
     1449const TComDataCU* TComDataCU::getPULeft( UInt& uiLPartUnitIdx,
    14501450                                   UInt uiCurrPartUnitIdx,
    14511451                                   Bool bEnforceSliceRestriction,
    1452                                    Bool bEnforceTileRestriction )
     1452                                         Bool bEnforceTileRestriction ) const
    14531453{
    14541454  UInt uiAbsPartIdx       = g_auiZscanToRaster[uiCurrPartUnitIdx];
     
    14791479
    14801480
    1481 TComDataCU* TComDataCU::getPUAbove( UInt& uiAPartUnitIdx,
     1481const TComDataCU* TComDataCU::getPUAbove( UInt& uiAPartUnitIdx,
    14821482                                    UInt uiCurrPartUnitIdx,
    14831483                                    Bool bEnforceSliceRestriction,
    14841484                                    Bool planarAtCtuBoundary,
    1485                                     Bool bEnforceTileRestriction )
     1485                                          Bool bEnforceTileRestriction ) const
    14861486{
    14871487  UInt uiAbsPartIdx       = g_auiZscanToRaster[uiCurrPartUnitIdx];
     
    15171517}
    15181518
    1519 TComDataCU* TComDataCU::getPUAboveLeft( UInt& uiALPartUnitIdx, UInt uiCurrPartUnitIdx, Bool bEnforceSliceRestriction )
     1519const TComDataCU* TComDataCU::getPUAboveLeft( UInt& uiALPartUnitIdx, UInt uiCurrPartUnitIdx, Bool bEnforceSliceRestriction ) const
    15201520{
    15211521  UInt uiAbsPartIdx       = g_auiZscanToRaster[uiCurrPartUnitIdx];
     
    15641564}
    15651565
    1566 TComDataCU* TComDataCU::getPUBelowLeft(UInt& uiBLPartUnitIdx,  UInt uiCurrPartUnitIdx, UInt uiPartUnitOffset, Bool bEnforceSliceRestriction)
     1566const TComDataCU* TComDataCU::getPUBelowLeft(UInt& uiBLPartUnitIdx,  UInt uiCurrPartUnitIdx, UInt uiPartUnitOffset, Bool bEnforceSliceRestriction) const
    15671567{
    15681568  UInt uiAbsPartIdxLB     = g_auiZscanToRaster[uiCurrPartUnitIdx];
     
    16081608}
    16091609
    1610 TComDataCU* TComDataCU::getPUAboveRight(UInt&  uiARPartUnitIdx, UInt uiCurrPartUnitIdx, UInt uiPartUnitOffset, Bool bEnforceSliceRestriction)
     1610const TComDataCU* TComDataCU::getPUAboveRight(UInt&  uiARPartUnitIdx, UInt uiCurrPartUnitIdx, UInt uiPartUnitOffset, Bool bEnforceSliceRestriction) const
    16111611{
    16121612  UInt uiAbsPartIdxRT     = g_auiZscanToRaster[uiCurrPartUnitIdx];
     
    16681668*\returns TComDataCU*   point of TComDataCU of left QpMinCu
    16691669*/
    1670 TComDataCU* TComDataCU::getQpMinCuLeft( UInt& uiLPartUnitIdx, UInt uiCurrAbsIdxInCtu )
     1670const TComDataCU* TComDataCU::getQpMinCuLeft( UInt& uiLPartUnitIdx, UInt uiCurrAbsIdxInCtu ) const
    16711671{
    16721672  const UInt numPartInCtuWidth = m_pcPic->getNumPartInCtuWidth();
     
    16951695*\returns TComDataCU*   point of TComDataCU of above QpMinCu
    16961696*/
    1697 TComDataCU* TComDataCU::getQpMinCuAbove( UInt& uiAPartUnitIdx, UInt uiCurrAbsIdxInCtu )
     1697const TComDataCU* TComDataCU::getQpMinCuAbove( UInt& uiAPartUnitIdx, UInt uiCurrAbsIdxInCtu ) const
    16981698{
    16991699  const UInt numPartInCtuWidth = m_pcPic->getNumPartInCtuWidth();
     
    17211721/** Get reference QP from left QpMinCu or latest coded QP
    17221722*\param   uiCurrAbsIdxInCtu
    1723 *\returns Char   reference QP value
     1723*\returns SChar   reference QP value
    17241724*/
    1725 Char TComDataCU::getRefQP( UInt uiCurrAbsIdxInCtu )
     1725SChar TComDataCU::getRefQP( UInt uiCurrAbsIdxInCtu ) const
    17261726{
    17271727  UInt lPartIdx = MAX_UINT;
    17281728  UInt aPartIdx = MAX_UINT;
    1729   TComDataCU* cULeft  = getQpMinCuLeft ( lPartIdx, m_absZIdxInCtu + uiCurrAbsIdxInCtu );
    1730   TComDataCU* cUAbove = getQpMinCuAbove( aPartIdx, m_absZIdxInCtu + uiCurrAbsIdxInCtu );
     1729  const TComDataCU* cULeft  = getQpMinCuLeft ( lPartIdx, m_absZIdxInCtu + uiCurrAbsIdxInCtu );
     1730  const TComDataCU* cUAbove = getQpMinCuAbove( aPartIdx, m_absZIdxInCtu + uiCurrAbsIdxInCtu );
    17311731  return (((cULeft? cULeft->getQP( lPartIdx ): getLastCodedQP( uiCurrAbsIdxInCtu )) + (cUAbove? cUAbove->getQP( aPartIdx ): getLastCodedQP( uiCurrAbsIdxInCtu )) + 1) >> 1);
    17321732}
    17331733
    1734 Int TComDataCU::getLastValidPartIdx( Int iAbsPartIdx )
     1734Int TComDataCU::getLastValidPartIdx( Int iAbsPartIdx ) const
    17351735{
    17361736  Int iLastValidPartIdx = iAbsPartIdx-1;
     
    17441744}
    17451745
    1746 Char TComDataCU::getLastCodedQP( UInt uiAbsPartIdx )
     1746SChar TComDataCU::getLastCodedQP( UInt uiAbsPartIdx ) const
    17471747{
    17481748  UInt uiQUPartIdxMask = ~((1<<((getSlice()->getSPS()->getMaxTotalCUDepth() - getSlice()->getPPS()->getMaxCuDQPDepth())<<1))-1);
     
    17841784 * \returns true if the CU is coded in lossless coding mode; false if otherwise
    17851785 */
    1786 Bool TComDataCU::isLosslessCoded(UInt absPartIdx)
     1786Bool TComDataCU::isLosslessCoded(UInt absPartIdx) const
    17871787{
    17881788  return (getSlice()->getPPS()->getTransquantBypassEnableFlag() && getCUTransquantBypass (absPartIdx));
     
    17961796*\param   [out] uiModeList pointer to chroma intra modes array
    17971797*/
    1798 Void TComDataCU::getAllowedChromaDir( UInt uiAbsPartIdx, UInt uiModeList[NUM_CHROMA_MODE] )
     1798Void TComDataCU::getAllowedChromaDir( UInt uiAbsPartIdx, UInt uiModeList[NUM_CHROMA_MODE] ) const
    17991799{
    18001800  uiModeList[0] = PLANAR_IDX;
     
    18241824*\returns Number of MPM
    18251825*/
    1826 Void TComDataCU::getIntraDirPredictor( UInt uiAbsPartIdx, Int uiIntraDirPred[NUM_MOST_PROBABLE_MODES], const ComponentID compID, Int* piMode  )
    1827 {
    1828   TComDataCU* pcCULeft, *pcCUAbove;
     1826Void TComDataCU::getIntraDirPredictor( UInt uiAbsPartIdx, Int uiIntraDirPred[NUM_MOST_PROBABLE_MODES], const ComponentID compID, Int* piMode ) const
     1827{
    18291828  UInt        LeftPartIdx  = MAX_UINT;
    18301829  UInt        AbovePartIdx = MAX_UINT;
     
    18361835  const ChromaFormat chForm = getPic()->getChromaFormat();
    18371836  // Get intra direction of left PU
    1838   pcCULeft = getPULeft( LeftPartIdx, m_absZIdxInCtu + uiAbsPartIdx );
     1837  const TComDataCU *pcCULeft = getPULeft( LeftPartIdx, m_absZIdxInCtu + uiAbsPartIdx );
    18391838
    18401839  if (isChroma(compID))
     
    18481847
    18491848  // Get intra direction of above PU
    1850   pcCUAbove = getPUAbove( AbovePartIdx, m_absZIdxInCtu + uiAbsPartIdx, true, true );
     1849  const TComDataCU *pcCUAbove = getPUAbove( AbovePartIdx, m_absZIdxInCtu + uiAbsPartIdx, true, true );
    18511850
    18521851  if (isChroma(compID))
     
    19171916}
    19181917
    1919 UInt TComDataCU::getCtxSplitFlag( UInt uiAbsPartIdx, UInt uiDepth )
    1920 {
    1921   TComDataCU* pcTempCU;
     1918UInt TComDataCU::getCtxSplitFlag( UInt uiAbsPartIdx, UInt uiDepth ) const
     1919{
     1920  const TComDataCU* pcTempCU;
    19221921  UInt        uiTempPartIdx;
    19231922  UInt        uiCtx;
     
    19331932}
    19341933
    1935 UInt TComDataCU::getCtxQtCbf( TComTU &rTu, const ChannelType chType )
     1934UInt TComDataCU::getCtxQtCbf( TComTU &rTu, const ChannelType chType ) const
    19361935{
    19371936  const UInt transformDepth = rTu.GetTransformDepthRel();
     
    19481947}
    19491948
    1950 UInt TComDataCU::getQuadtreeTULog2MinSizeInCU( UInt absPartIdx )
     1949UInt TComDataCU::getQuadtreeTULog2MinSizeInCU( UInt absPartIdx ) const
    19511950{
    19521951  UInt log2CbSize = g_aucConvertToBit[getWidth( absPartIdx )] + 2;
     
    19751974}
    19761975
    1977 UInt TComDataCU::getCtxSkipFlag( UInt uiAbsPartIdx )
    1978 {
    1979   TComDataCU* pcTempCU;
     1976UInt TComDataCU::getCtxSkipFlag( UInt uiAbsPartIdx ) const
     1977{
     1978  const TComDataCU* pcTempCU;
    19801979  UInt        uiTempPartIdx;
    19811980  UInt        uiCtx = 0;
     
    19941993UInt TComDataCU::getCTXARPWFlag( UInt uiAbsPartIdx )
    19951994{
    1996   TComDataCU* pcTempCU;
     1995  const TComDataCU* pcTempCU;
    19971996  UInt        uiTempPartIdx;
    19981997  UInt        uiCtx = 0;
    1999  
     1998
    20001999  pcTempCU = getPULeft( uiTempPartIdx, m_absZIdxInCtu + uiAbsPartIdx );
    20012000  uiCtx    = ( pcTempCU ) ? ((pcTempCU->getARPW( uiTempPartIdx )==0)?0:1) : 0;
    2002     return uiCtx;
     2001  return uiCtx;
    20032002}
    20042003#endif
     
    20862085
    20872086
    2088 UInt TComDataCU::getCtxInterDir( UInt uiAbsPartIdx )
     2087UInt TComDataCU::getCtxInterDir( UInt uiAbsPartIdx ) const
    20892088{
    20902089  return getDepth( uiAbsPartIdx );
     
    20922091
    20932092
    2094 UChar TComDataCU::getQtRootCbf( UInt uiIdx )
     2093UChar TComDataCU::getQtRootCbf( UInt uiIdx ) const
    20952094{
    20962095  const UInt numberValidComponents = getPic()->getNumberValidComponents();
     
    21482147}
    21492148
    2150 Bool TComDataCU::isFirstAbsZorderIdxInDepth (UInt uiAbsPartIdx, UInt uiDepth)
     2149Bool TComDataCU::isFirstAbsZorderIdxInDepth (UInt uiAbsPartIdx, UInt uiDepth) const
    21512150{
    21522151  UInt uiPartNumb = m_pcPic->getNumPartitionsInCtu() >> (uiDepth << 1);
     
    23762375
    23772376#if NH_3D_VSP
    2378 Void TComDataCU::setVSPFlagSubParts( Char iVSPFlag, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth )
    2379 {
    2380   setSubPart<Char>( iVSPFlag, m_piVSPFlag, uiAbsPartIdx, uiDepth, uiPartIdx );
     2377Void TComDataCU::setVSPFlagSubParts( SChar iVSPFlag, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth )
     2378{
     2379  setSubPart<SChar>( iVSPFlag, m_piVSPFlag, uiAbsPartIdx, uiDepth, uiPartIdx );
    23812380}
    23822381template<typename T>
     
    25232522Void TComDataCU::setMVPIdxSubParts( Int iMVPIdx, RefPicList eRefPicList, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth )
    25242523{
    2525   setSubPart<Char>( iMVPIdx, m_apiMVPIdx[eRefPicList], uiAbsPartIdx, uiDepth, uiPartIdx );
     2524  setSubPart<SChar>( iMVPIdx, m_apiMVPIdx[eRefPicList], uiAbsPartIdx, uiDepth, uiPartIdx );
    25262525}
    25272526
    25282527Void TComDataCU::setMVPNumSubParts( Int iMVPNum, RefPicList eRefPicList, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth )
    25292528{
    2530   setSubPart<Char>( iMVPNum, m_apiMVPNum[eRefPicList], uiAbsPartIdx, uiDepth, uiPartIdx );
     2529  setSubPart<SChar>( iMVPNum, m_apiMVPNum[eRefPicList], uiAbsPartIdx, uiDepth, uiPartIdx );
    25312530}
    25322531
     
    25612560}
    25622561
    2563 Void TComDataCU::setCrossComponentPredictionAlphaPartRange( Char alphaValue, ComponentID compID, UInt uiAbsPartIdx, UInt uiCoveredPartIdxes )
    2564 {
    2565   memset((m_crossComponentPredictionAlpha[compID] + uiAbsPartIdx), alphaValue, (sizeof(Char) * uiCoveredPartIdxes));
     2562Void TComDataCU::setCrossComponentPredictionAlphaPartRange( SChar alphaValue, ComponentID compID, UInt uiAbsPartIdx, UInt uiCoveredPartIdxes )
     2563{
     2564  memset((m_crossComponentPredictionAlpha[compID] + uiAbsPartIdx), alphaValue, (sizeof(SChar) * uiCoveredPartIdxes));
    25662565}
    25672566
     
    25792578}
    25802579
    2581 UChar TComDataCU::getNumPartitions(const UInt uiAbsPartIdx)
     2580UChar TComDataCU::getNumPartitions(const UInt uiAbsPartIdx) const
    25822581{
    25832582  UChar iNumPart = 0;
     
    26012600// This is for use by a leaf/sub CU object only, with no additional AbsPartIdx
    26022601#if NH_3D_IC || NH_3D_VSP
    2603 Void TComDataCU::getPartIndexAndSize( UInt uiPartIdx, UInt& ruiPartAddr, Int& riWidth, Int& riHeight, UInt uiAbsPartIdx, Bool bLCU)
     2602Void TComDataCU::getPartIndexAndSize( UInt uiPartIdx, UInt& ruiPartAddr, Int& riWidth, Int& riHeight, UInt uiAbsPartIdx, Bool bLCU) const
    26042603{
    26052604  UInt uiNumPartition  = bLCU ? (getWidth(uiAbsPartIdx)*getHeight(uiAbsPartIdx) >> 4) : m_uiNumPartition;
     
    26452644#else
    26462645
    2647 Void TComDataCU::getPartIndexAndSize( UInt uiPartIdx, UInt& ruiPartAddr, Int& riWidth, Int& riHeight )
     2646Void TComDataCU::getPartIndexAndSize( UInt uiPartIdx, UInt& ruiPartAddr, Int& riWidth, Int& riHeight )  const
    26482647{
    26492648  switch ( m_pePartSize[0] )
     
    26862685#endif
    26872686
    2688 
    2689 Void TComDataCU::getMvField ( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefPicList, TComMvField& rcMvField )
     2687// static member function
     2688Void TComDataCU::getMvField ( const TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefPicList, TComMvField& rcMvField )
    26902689{
    26912690  if ( pcCU == NULL )  // OUT OF BOUNDARY
     
    26962695  }
    26972696
    2698   TComCUMvField*  pcCUMvField = pcCU->getCUMvField( eRefPicList );
     2697  const TComCUMvField*  pcCUMvField = pcCU->getCUMvField( eRefPicList );
    26992698  rcMvField.setMvField( pcCUMvField->getMv( uiAbsPartIdx ), pcCUMvField->getRefIdx( uiAbsPartIdx ) );
    27002699}
    27012700
    2702 Void TComDataCU::deriveLeftRightTopIdxGeneral ( UInt uiAbsPartIdx, UInt uiPartIdx, UInt& ruiPartIdxLT, UInt& ruiPartIdxRT )
     2701Void TComDataCU::deriveLeftRightTopIdxGeneral ( UInt uiAbsPartIdx, UInt uiPartIdx, UInt& ruiPartIdxLT, UInt& ruiPartIdxRT ) const
    27032702{
    27042703  ruiPartIdxLT = m_absZIdxInCtu + uiAbsPartIdx;
     
    27492748}
    27502749
    2751 Void TComDataCU::deriveLeftBottomIdxGeneral( UInt uiAbsPartIdx, UInt uiPartIdx, UInt& ruiPartIdxLB )
     2750Void TComDataCU::deriveLeftBottomIdxGeneral( UInt uiAbsPartIdx, UInt uiPartIdx, UInt& ruiPartIdxLB ) const
    27522751{
    27532752  UInt uiPUHeight = 0;
     
    27962795}
    27972796
    2798 Void TComDataCU::deriveLeftRightTopIdx ( UInt uiPartIdx, UInt& ruiPartIdxLT, UInt& ruiPartIdxRT )
     2797Void TComDataCU::deriveLeftRightTopIdx ( UInt uiPartIdx, UInt& ruiPartIdxLT, UInt& ruiPartIdxRT ) const
    27992798{
    28002799  ruiPartIdxLT = m_absZIdxInCtu;
     
    28362835}
    28372836
    2838 Void TComDataCU::deriveLeftBottomIdx( UInt  uiPartIdx,      UInt&      ruiPartIdxLB )
     2837Void TComDataCU::deriveLeftBottomIdx( UInt  uiPartIdx,      UInt&      ruiPartIdxLB ) const
    28392838{
    28402839  ruiPartIdxLB      = g_auiRasterToZscan [g_auiZscanToRaster[ m_absZIdxInCtu ] + ( ((m_puhHeight[0] / m_pcPic->getMinCUHeight())>>1) - 1)*m_pcPic->getNumPartInCtuWidth()];
     
    28762875 * \param [out] ruiPartIdxRB  partition index of neighbouring bottom right block
    28772876 */
    2878 Void TComDataCU::deriveRightBottomIdx( UInt uiPartIdx, UInt &ruiPartIdxRB )
     2877Void TComDataCU::deriveRightBottomIdx( UInt uiPartIdx, UInt &ruiPartIdxRB ) const
    28792878{
    28802879  ruiPartIdxRB      = g_auiRasterToZscan [g_auiZscanToRaster[ m_absZIdxInCtu ] + ( ((m_puhHeight[0] / m_pcPic->getMinCUHeight())>>1) - 1)*m_pcPic->getNumPartInCtuWidth() +  m_puhWidth[0] / m_pcPic->getMinCUWidth() - 1];
     
    29122911}
    29132912
    2914 Bool TComDataCU::hasEqualMotion( UInt uiAbsPartIdx, TComDataCU* pcCandCU, UInt uiCandAbsPartIdx )
     2913Bool TComDataCU::hasEqualMotion( UInt uiAbsPartIdx, const TComDataCU* pcCandCU, UInt uiCandAbsPartIdx ) const
    29152914{
    29162915  if ( getInterDir( uiAbsPartIdx ) != pcCandCU->getInterDir( uiCandAbsPartIdx ) )
     
    33063305  //left
    33073306  UInt uiLeftPartIdx = 0;
    3308   TComDataCU* pcCULeft = 0;
     3307  const TComDataCU* pcCULeft = 0;
    33093308  pcCULeft = getPULeft( uiLeftPartIdx, uiPartIdxLB ); 
    33103309
     
    37833782
    37843783//! Construct a list of merging candidates
     3784#if NH_3D
    37853785Void TComDataCU::getInterMergeCandidates( UInt uiAbsPartIdx, UInt uiPUIdx, TComMvField* pcMvFieldNeighbours, UChar* puhInterDirNeighbours, Int& numValidMergeCand, Int mrgCandIdx )
     3786#else
     3787Void TComDataCU::getInterMergeCandidates( UInt uiAbsPartIdx, UInt uiPUIdx, TComMvField* pcMvFieldNeighbours, UChar* puhInterDirNeighbours, Int& numValidMergeCand, Int mrgCandIdx ) const
     3788#endif
    37863789{
    37873790  UInt uiAbsPartAddr = m_absZIdxInCtu + uiAbsPartIdx;
     
    38113814  //left
    38123815  UInt uiLeftPartIdx = 0;
    3813   TComDataCU* pcCULeft = 0;
    3814   pcCULeft = getPULeft( uiLeftPartIdx, uiPartIdxLB );
     3816  const TComDataCU *pcCULeft = getPULeft( uiLeftPartIdx, uiPartIdxLB );
    38153817
    38163818  Bool isAvailableA1 = pcCULeft &&
     
    38283830    puhInterDirNeighbours[iCount] = pcCULeft->getInterDir( uiLeftPartIdx );
    38293831    // get Mv from Left
    3830     pcCULeft->getMvField( pcCULeft, uiLeftPartIdx, REF_PIC_LIST_0, pcMvFieldNeighbours[iCount<<1] );
     3832    TComDataCU::getMvField( pcCULeft, uiLeftPartIdx, REF_PIC_LIST_0, pcMvFieldNeighbours[iCount<<1] );
    38313833    if ( getSlice()->isInterB() )
    38323834    {
    3833       pcCULeft->getMvField( pcCULeft, uiLeftPartIdx, REF_PIC_LIST_1, pcMvFieldNeighbours[(iCount<<1)+1] );
     3835      TComDataCU::getMvField( pcCULeft, uiLeftPartIdx, REF_PIC_LIST_1, pcMvFieldNeighbours[(iCount<<1)+1] );
    38343836    }
    38353837    if ( mrgCandIdx == iCount )
     
    38473849  // above
    38483850  UInt uiAbovePartIdx = 0;
    3849   TComDataCU* pcCUAbove = 0;
    3850   pcCUAbove = getPUAbove( uiAbovePartIdx, uiPartIdxRT );
     3851  const TComDataCU *pcCUAbove = getPUAbove( uiAbovePartIdx, uiPartIdxRT );
    38513852
    38523853  Bool isAvailableB1 = pcCUAbove &&
     
    38643865    puhInterDirNeighbours[iCount] = pcCUAbove->getInterDir( uiAbovePartIdx );
    38653866    // get Mv from Left
    3866     pcCUAbove->getMvField( pcCUAbove, uiAbovePartIdx, REF_PIC_LIST_0, pcMvFieldNeighbours[iCount<<1] );
     3867    TComDataCU::getMvField( pcCUAbove, uiAbovePartIdx, REF_PIC_LIST_0, pcMvFieldNeighbours[iCount<<1] );
    38673868    if ( getSlice()->isInterB() )
    38683869    {
    3869       pcCUAbove->getMvField( pcCUAbove, uiAbovePartIdx, REF_PIC_LIST_1, pcMvFieldNeighbours[(iCount<<1)+1] );
     3870      TComDataCU::getMvField( pcCUAbove, uiAbovePartIdx, REF_PIC_LIST_1, pcMvFieldNeighbours[(iCount<<1)+1] );
    38703871    }
    38713872    if ( mrgCandIdx == iCount )
     
    38833884  // above right
    38843885  UInt uiAboveRightPartIdx = 0;
    3885   TComDataCU* pcCUAboveRight = 0;
    3886   pcCUAboveRight = getPUAboveRight( uiAboveRightPartIdx, uiPartIdxRT );
     3886  const TComDataCU *pcCUAboveRight = getPUAboveRight( uiAboveRightPartIdx, uiPartIdxRT );
    38873887
    38883888  Bool isAvailableB0 = pcCUAboveRight &&
     
    38993899    puhInterDirNeighbours[iCount] = pcCUAboveRight->getInterDir( uiAboveRightPartIdx );
    39003900    // get Mv from Left
    3901     pcCUAboveRight->getMvField( pcCUAboveRight, uiAboveRightPartIdx, REF_PIC_LIST_0, pcMvFieldNeighbours[iCount<<1] );
     3901    TComDataCU::getMvField( pcCUAboveRight, uiAboveRightPartIdx, REF_PIC_LIST_0, pcMvFieldNeighbours[iCount<<1] );
    39023902    if ( getSlice()->isInterB() )
    39033903    {
    3904       pcCUAboveRight->getMvField( pcCUAboveRight, uiAboveRightPartIdx, REF_PIC_LIST_1, pcMvFieldNeighbours[(iCount<<1)+1] );
     3904      TComDataCU::getMvField( pcCUAboveRight, uiAboveRightPartIdx, REF_PIC_LIST_1, pcMvFieldNeighbours[(iCount<<1)+1] );
    39053905    }
    39063906    if ( mrgCandIdx == iCount )
     
    39183918  //left bottom
    39193919  UInt uiLeftBottomPartIdx = 0;
    3920   TComDataCU* pcCULeftBottom = 0;
    3921   pcCULeftBottom = this->getPUBelowLeft( uiLeftBottomPartIdx, uiPartIdxLB );
     3920  const TComDataCU *pcCULeftBottom = this->getPUBelowLeft( uiLeftBottomPartIdx, uiPartIdxLB );
    39223921
    39233922  Bool isAvailableA0 = pcCULeftBottom &&
     
    39343933    puhInterDirNeighbours[iCount] = pcCULeftBottom->getInterDir( uiLeftBottomPartIdx );
    39353934    // get Mv from Left
    3936     pcCULeftBottom->getMvField( pcCULeftBottom, uiLeftBottomPartIdx, REF_PIC_LIST_0, pcMvFieldNeighbours[iCount<<1] );
     3935    TComDataCU::getMvField( pcCULeftBottom, uiLeftBottomPartIdx, REF_PIC_LIST_0, pcMvFieldNeighbours[iCount<<1] );
    39373936    if ( getSlice()->isInterB() )
    39383937    {
    3939       pcCULeftBottom->getMvField( pcCULeftBottom, uiLeftBottomPartIdx, REF_PIC_LIST_1, pcMvFieldNeighbours[(iCount<<1)+1] );
     3938      TComDataCU::getMvField( pcCULeftBottom, uiLeftBottomPartIdx, REF_PIC_LIST_1, pcMvFieldNeighbours[(iCount<<1)+1] );
    39403939    }
    39413940    if ( mrgCandIdx == iCount )
     
    39553954  {
    39563955    UInt uiAboveLeftPartIdx = 0;
    3957     TComDataCU* pcCUAboveLeft = 0;
    3958     pcCUAboveLeft = getPUAboveLeft( uiAboveLeftPartIdx, uiAbsPartAddr );
     3956    const TComDataCU *pcCUAboveLeft = getPUAboveLeft( uiAboveLeftPartIdx, uiAbsPartAddr );
    39593957
    39603958    Bool isAvailableB2 = pcCUAboveLeft &&
     
    39723970      puhInterDirNeighbours[iCount] = pcCUAboveLeft->getInterDir( uiAboveLeftPartIdx );
    39733971      // get Mv from Left
    3974       pcCUAboveLeft->getMvField( pcCUAboveLeft, uiAboveLeftPartIdx, REF_PIC_LIST_0, pcMvFieldNeighbours[iCount<<1] );
     3972      TComDataCU::getMvField( pcCUAboveLeft, uiAboveLeftPartIdx, REF_PIC_LIST_0, pcMvFieldNeighbours[iCount<<1] );
    39753973      if ( getSlice()->isInterB() )
    39763974      {
    3977         pcCUAboveLeft->getMvField( pcCUAboveLeft, uiAboveLeftPartIdx, REF_PIC_LIST_1, pcMvFieldNeighbours[(iCount<<1)+1] );
     3975        TComDataCU::getMvField( pcCUAboveLeft, uiAboveLeftPartIdx, REF_PIC_LIST_1, pcMvFieldNeighbours[(iCount<<1)+1] );
    39783976      }
    39793977      if ( mrgCandIdx == iCount )
     
    41664164 * \param xP, yP   location of the upper-left corner pixel of the current PU
    41674165 */
    4168 Bool TComDataCU::isDiffMER(Int xN, Int yN, Int xP, Int yP)
     4166Bool TComDataCU::isDiffMER(Int xN, Int yN, Int xP, Int yP) const
    41694167{
    41704168
     
    41864184 * \param nPSW, nPSH    size of the current PU
    41874185 */
    4188 Void TComDataCU::getPartPosition( UInt partIdx, Int& xP, Int& yP, Int& nPSW, Int& nPSH)
     4186Void TComDataCU::getPartPosition( UInt partIdx, Int& xP, Int& yP, Int& nPSW, Int& nPSH) const
    41894187{
    41904188  UInt col = m_uiCUPelX;
     
    42474245}
    42484246
    4249 /** Constructs a list of candidates for AMVP
     4247/** Constructs a list of candidates for AMVP (See specification, section "Derivation process for motion vector predictor candidates")
    42504248 * \param uiPartIdx
    42514249 * \param uiPartAddr
     
    42544252 * \param pInfo
    42554253 */
    4256 Void TComDataCU::fillMvpCand ( UInt uiPartIdx, UInt uiPartAddr, RefPicList eRefPicList, Int iRefIdx, AMVPInfo* pInfo )
    4257 {
    4258   TComMv cMvPred;
    4259   Bool bAddedSmvp = false;
    4260 
     4254Void TComDataCU::fillMvpCand ( const UInt partIdx, const UInt partAddr, const RefPicList eRefPicList, const Int refIdx, AMVPInfo* pInfo ) const
     4255{
    42614256  pInfo->iN = 0;
    4262   if (iRefIdx < 0)
     4257  if (refIdx < 0)
    42634258  {
    42644259    return;
     
    42664261
    42674262  //-- Get Spatial MV
    4268   UInt uiPartIdxLT, uiPartIdxRT, uiPartIdxLB;
    4269   const UInt numPartInCtuWidth  = m_pcPic->getNumPartInCtuWidth();
    4270   const UInt numPartInCtuHeight = m_pcPic->getNumPartInCtuHeight();
    4271   Bool bAdded = false;
    4272 
    4273   deriveLeftRightTopIdx( uiPartIdx, uiPartIdxLT, uiPartIdxRT );
    4274   deriveLeftBottomIdx( uiPartIdx, uiPartIdxLB );
    4275 
    4276   TComDataCU* tmpCU = NULL;
    4277   UInt idx;
    4278   tmpCU = getPUBelowLeft(idx, uiPartIdxLB);
    4279   bAddedSmvp = (tmpCU != NULL) && (tmpCU->isInter(idx));
    4280 
    4281   if (!bAddedSmvp)
    4282   {
    4283     tmpCU = getPULeft(idx, uiPartIdxLB);
    4284     bAddedSmvp = (tmpCU != NULL) && (tmpCU->isInter(idx));
     4263  UInt partIdxLT, partIdxRT, partIdxLB;
     4264  deriveLeftRightTopIdx( partIdx, partIdxLT, partIdxRT );
     4265  deriveLeftBottomIdx( partIdx, partIdxLB );
     4266
     4267  Bool isScaledFlagLX = false; /// variable name from specification; true when the PUs below left or left are available (availableA0 || availableA1).
     4268  {
     4269    UInt idx;
     4270    const TComDataCU* tmpCU = getPUBelowLeft(idx, partIdxLB);
     4271    isScaledFlagLX = (tmpCU != NULL) && (tmpCU->isInter(idx));
     4272    if (!isScaledFlagLX)
     4273    {
     4274      tmpCU = getPULeft(idx, partIdxLB);
     4275      isScaledFlagLX = (tmpCU != NULL) && (tmpCU->isInter(idx));
     4276    }
    42854277  }
    42864278
    42874279  // Left predictor search
    4288   bAdded = xAddMVPCand( pInfo, eRefPicList, iRefIdx, uiPartIdxLB, MD_BELOW_LEFT);
    4289   if (!bAdded)
    4290   {
    4291     bAdded = xAddMVPCand( pInfo, eRefPicList, iRefIdx, uiPartIdxLB, MD_LEFT );
    4292   }
    4293 
    4294   if(!bAdded)
    4295   {
    4296     bAdded = xAddMVPCandOrder( pInfo, eRefPicList, iRefIdx, uiPartIdxLB, MD_BELOW_LEFT);
     4280  if (isScaledFlagLX)
     4281  {
     4282    Bool bAdded = xAddMVPCandUnscaled( *pInfo, eRefPicList, refIdx, partIdxLB, MD_BELOW_LEFT);
    42974283    if (!bAdded)
    42984284    {
    4299       xAddMVPCandOrder( pInfo, eRefPicList, iRefIdx, uiPartIdxLB, MD_LEFT );
     4285      bAdded = xAddMVPCandUnscaled( *pInfo, eRefPicList, refIdx, partIdxLB, MD_LEFT );
     4286      if(!bAdded)
     4287      {
     4288        bAdded = xAddMVPCandWithScaling( *pInfo, eRefPicList, refIdx, partIdxLB, MD_BELOW_LEFT);
     4289        if (!bAdded)
     4290        {
     4291          xAddMVPCandWithScaling( *pInfo, eRefPicList, refIdx, partIdxLB, MD_LEFT );
     4292        }
     4293      }
    43004294    }
    43014295  }
    43024296
    43034297  // Above predictor search
    4304   bAdded = xAddMVPCand( pInfo, eRefPicList, iRefIdx, uiPartIdxRT, MD_ABOVE_RIGHT);
    4305 
    4306   if (!bAdded)
    4307   {
    4308     bAdded = xAddMVPCand( pInfo, eRefPicList, iRefIdx, uiPartIdxRT, MD_ABOVE);
    4309   }
    4310 
    4311   if(!bAdded)
    4312   {
    4313     xAddMVPCand( pInfo, eRefPicList, iRefIdx, uiPartIdxLT, MD_ABOVE_LEFT);
    4314   }
    4315 
    4316   if(!bAddedSmvp)
    4317   {
    4318     bAdded = xAddMVPCandOrder( pInfo, eRefPicList, iRefIdx, uiPartIdxRT, MD_ABOVE_RIGHT);
     4298  {
     4299    Bool bAdded = xAddMVPCandUnscaled( *pInfo, eRefPicList, refIdx, partIdxRT, MD_ABOVE_RIGHT);
    43194300    if (!bAdded)
    43204301    {
    4321       bAdded = xAddMVPCandOrder( pInfo, eRefPicList, iRefIdx, uiPartIdxRT, MD_ABOVE);
    4322     }
    4323 
    4324     if(!bAdded)
    4325     {
    4326       xAddMVPCandOrder( pInfo, eRefPicList, iRefIdx, uiPartIdxLT, MD_ABOVE_LEFT);
     4302      bAdded = xAddMVPCandUnscaled( *pInfo, eRefPicList, refIdx, partIdxRT, MD_ABOVE);
     4303      if(!bAdded)
     4304      {
     4305        xAddMVPCandUnscaled( *pInfo, eRefPicList, refIdx, partIdxLT, MD_ABOVE_LEFT);
     4306      }
     4307    }
     4308  }
     4309
     4310  if(!isScaledFlagLX)
     4311  {
     4312    Bool bAdded = xAddMVPCandWithScaling( *pInfo, eRefPicList, refIdx, partIdxRT, MD_ABOVE_RIGHT);
     4313    if (!bAdded)
     4314    {
     4315      bAdded = xAddMVPCandWithScaling( *pInfo, eRefPicList, refIdx, partIdxRT, MD_ABOVE);
     4316      if(!bAdded)
     4317      {
     4318        xAddMVPCandWithScaling( *pInfo, eRefPicList, refIdx, partIdxLT, MD_ABOVE_LEFT);
     4319      }
    43274320    }
    43284321  }
     
    43364329  }
    43374330
    4338   if ( getSlice()->getEnableTMVPFlag() )
     4331  if (pInfo->iN < AMVP_MAX_NUM_CANDS && getSlice()->getEnableTMVPFlag() )
    43394332  {
    43404333    // Get Temporal Motion Predictor
    4341     Int iRefIdx_Col = iRefIdx;
     4334    const UInt numPartInCtuWidth  = m_pcPic->getNumPartInCtuWidth();
     4335    const UInt numPartInCtuHeight = m_pcPic->getNumPartInCtuHeight();
     4336#if NH_3D_TMVP
     4337    Int refIdx_Col = refIdx;
     4338#else
     4339    const Int refIdx_Col = refIdx;
     4340#endif
    43424341    TComMv cColMv;
    4343     UInt uiPartIdxRB;
    4344     UInt uiAbsPartIdx;
    4345     UInt uiAbsPartAddr;
    4346 
    4347     deriveRightBottomIdx( uiPartIdx, uiPartIdxRB );
    4348     uiAbsPartAddr = m_absZIdxInCtu + uiPartAddr;
     4342    UInt partIdxRB;
     4343    UInt absPartIdx;
     4344
     4345    deriveRightBottomIdx( partIdx, partIdxRB );
     4346    UInt absPartAddr = m_absZIdxInCtu + partAddr;
    43494347
    43504348    //----  co-located RightBottom Temporal Predictor (H) ---//
    4351     uiAbsPartIdx = g_auiZscanToRaster[uiPartIdxRB];
     4349    absPartIdx = g_auiZscanToRaster[partIdxRB];
    43524350    Int ctuRsAddr = -1;
    4353     if (  ( ( m_pcPic->getCtu(m_ctuRsAddr)->getCUPelX() + g_auiRasterToPelX[uiAbsPartIdx] + m_pcPic->getMinCUWidth () ) < m_pcSlice->getSPS()->getPicWidthInLumaSamples () )  // image boundary check
    4354        && ( ( m_pcPic->getCtu(m_ctuRsAddr)->getCUPelY() + g_auiRasterToPelY[uiAbsPartIdx] + m_pcPic->getMinCUHeight() ) < m_pcSlice->getSPS()->getPicHeightInLumaSamples() ) )
    4355     {
    4356       if ( ( uiAbsPartIdx % numPartInCtuWidth < numPartInCtuWidth - 1 ) &&  // is not at the last column of CTU
    4357            ( uiAbsPartIdx / numPartInCtuWidth < numPartInCtuHeight - 1 ) )  // is not at the last row    of CTU
    4358       {
    4359         uiAbsPartAddr = g_auiRasterToZscan[ uiAbsPartIdx + numPartInCtuWidth + 1 ];
     4351    if (  ( ( m_pcPic->getCtu(m_ctuRsAddr)->getCUPelX() + g_auiRasterToPelX[absPartIdx] + m_pcPic->getMinCUWidth () ) < m_pcSlice->getSPS()->getPicWidthInLumaSamples () )  // image boundary check
     4352      && ( ( m_pcPic->getCtu(m_ctuRsAddr)->getCUPelY() + g_auiRasterToPelY[absPartIdx] + m_pcPic->getMinCUHeight() ) < m_pcSlice->getSPS()->getPicHeightInLumaSamples() ) )
     4353    {
     4354      if ( ( absPartIdx % numPartInCtuWidth < numPartInCtuWidth - 1 ) &&  // is not at the last column of CTU
     4355        ( absPartIdx / numPartInCtuWidth < numPartInCtuHeight - 1 ) )  // is not at the last row    of CTU
     4356      {
     4357        absPartAddr = g_auiRasterToZscan[ absPartIdx + numPartInCtuWidth + 1 ];
    43604358        ctuRsAddr = getCtuRsAddr();
    43614359      }
    4362       else if ( uiAbsPartIdx % numPartInCtuWidth < numPartInCtuWidth - 1 )  // is not at the last column of CTU But is last row of CTU
    4363       {
    4364         uiAbsPartAddr = g_auiRasterToZscan[ (uiAbsPartIdx + numPartInCtuWidth + 1) % m_pcPic->getNumPartitionsInCtu() ];
    4365       }
    4366       else if ( uiAbsPartIdx / numPartInCtuWidth < numPartInCtuHeight - 1 ) // is not at the last row of CTU But is last column of CTU
    4367       {
    4368         uiAbsPartAddr = g_auiRasterToZscan[ uiAbsPartIdx + 1 ];
     4360      else if ( absPartIdx % numPartInCtuWidth < numPartInCtuWidth - 1 )  // is not at the last column of CTU But is last row of CTU
     4361      {
     4362        absPartAddr = g_auiRasterToZscan[ (absPartIdx + numPartInCtuWidth + 1) % m_pcPic->getNumPartitionsInCtu() ];
     4363      }
     4364      else if ( absPartIdx / numPartInCtuWidth < numPartInCtuHeight - 1 ) // is not at the last row of CTU But is last column of CTU
     4365      {
     4366        absPartAddr = g_auiRasterToZscan[ absPartIdx + 1 ];
    43694367        ctuRsAddr = getCtuRsAddr() + 1;
    43704368      }
    43714369      else //is the right bottom corner of CTU
    43724370      {
    4373         uiAbsPartAddr = 0;
    4374       }
    4375     }
    4376     if ( ctuRsAddr >= 0 && xGetColMVP( eRefPicList, ctuRsAddr, uiAbsPartAddr, cColMv, iRefIdx_Col
     4371        absPartAddr = 0;
     4372      }
     4373    }
     4374    if ( ctuRsAddr >= 0 && xGetColMVP( eRefPicList, ctuRsAddr, absPartAddr, cColMv, refIdx_Col
    43774375#if NH_3D_TMVP
    4378          , 0
    4379 #endif
    4380  ) )
     4376      , 0
     4377#endif
     4378      ) )
    43814379    {
    43824380      pInfo->m_acMvCand[pInfo->iN++] = cColMv;
     
    43854383    {
    43864384      UInt uiPartIdxCenter;
    4387       xDeriveCenterIdx( uiPartIdx, uiPartIdxCenter );
    4388       if (xGetColMVP( eRefPicList, getCtuRsAddr(), uiPartIdxCenter,  cColMv, iRefIdx_Col
     4385      xDeriveCenterIdx( partIdx, uiPartIdxCenter );
     4386      if (xGetColMVP( eRefPicList, getCtuRsAddr(), uiPartIdxCenter,  cColMv, refIdx_Col
    43894387#if NH_3D_TMVP
    4390          , 0
    4391 #endif
    4392 ))
     4388        , 0
     4389#endif
     4390        ))
    43934391      {
    43944392        pInfo->m_acMvCand[pInfo->iN++] = cColMv;
     
    43964394    }
    43974395    //----  co-located RightBottom Temporal Predictor  ---//
    4398   }
    4399 
    4400   if (pInfo->iN > AMVP_MAX_NUM_CANDS)
    4401   {
    4402     pInfo->iN = AMVP_MAX_NUM_CANDS;
    44034396  }
    44044397
     
    44124405
    44134406
    4414 Bool TComDataCU::isBipredRestriction(UInt puIdx)
     4407Bool TComDataCU::isBipredRestriction(UInt puIdx) const
    44154408{
    44164409  Int width = 0;
     
    44344427
    44354428
    4436 Void TComDataCU::clipMv    (TComMv&  rcMv)
     4429Void TComDataCU::clipMv    (TComMv&  rcMv) const
    44374430{
    44384431  const TComSPS &sps=*(m_pcSlice->getSPS());
     
    44704463#endif
    44714464
    4472 UInt TComDataCU::getIntraSizeIdx(UInt uiAbsPartIdx)
     4465UInt TComDataCU::getIntraSizeIdx(UInt uiAbsPartIdx) const
    44734466{
    44744467  UInt uiShift = ( m_pePartSize[uiAbsPartIdx]==SIZE_NxN ? 1 : 0 );
     
    45074500 * \returns true if the current the block is skipped
    45084501 */
    4509 Bool TComDataCU::isSkipped( UInt uiPartIdx )
     4502Bool TComDataCU::isSkipped( UInt uiPartIdx ) const
    45104503{
    45114504  return ( getSkipFlag( uiPartIdx ) );
     
    45164509// ====================================================================================================================
    45174510
    4518 Bool TComDataCU::xAddMVPCand( AMVPInfo* pInfo, RefPicList eRefPicList, Int iRefIdx, UInt uiPartUnitIdx, MVP_DIR eDir )
    4519 {
    4520   TComDataCU* pcTmpCU = NULL;
    4521   UInt uiIdx;
     4511Bool TComDataCU::xAddMVPCandUnscaled( AMVPInfo &info, const RefPicList eRefPicList, const Int iRefIdx, const UInt uiPartUnitIdx, const MVP_DIR eDir ) const
     4512{
     4513  const TComDataCU* neibCU = NULL;
     4514  UInt neibPUPartIdx;
    45224515  switch( eDir )
    45234516  {
    45244517    case MD_LEFT:
    45254518    {
    4526       pcTmpCU = getPULeft(uiIdx, uiPartUnitIdx);
     4519      neibCU = getPULeft(neibPUPartIdx, uiPartUnitIdx);
    45274520      break;
    45284521    }
    45294522    case MD_ABOVE:
    45304523    {
    4531       pcTmpCU = getPUAbove(uiIdx, uiPartUnitIdx);
     4524      neibCU = getPUAbove(neibPUPartIdx, uiPartUnitIdx);
    45324525      break;
    45334526    }
    45344527    case MD_ABOVE_RIGHT:
    45354528    {
    4536       pcTmpCU = getPUAboveRight(uiIdx, uiPartUnitIdx);
     4529      neibCU = getPUAboveRight(neibPUPartIdx, uiPartUnitIdx);
    45374530      break;
    45384531    }
    45394532    case MD_BELOW_LEFT:
    45404533    {
    4541       pcTmpCU = getPUBelowLeft(uiIdx, uiPartUnitIdx);
     4534      neibCU = getPUBelowLeft(neibPUPartIdx, uiPartUnitIdx);
    45424535      break;
    45434536    }
    45444537    case MD_ABOVE_LEFT:
    45454538    {
    4546       pcTmpCU = getPUAboveLeft(uiIdx, uiPartUnitIdx);
     4539      neibCU = getPUAboveLeft(neibPUPartIdx, uiPartUnitIdx);
    45474540      break;
    45484541    }
     
    45534546  }
    45544547
    4555   if ( pcTmpCU == NULL )
     4548  if ( neibCU == NULL )
    45564549  {
    45574550    return false;
    45584551  }
    45594552
    4560   if ( pcTmpCU->getCUMvField(eRefPicList)->getRefIdx(uiIdx) >= 0 && m_pcSlice->getRefPic( eRefPicList, iRefIdx)->getPOC() == pcTmpCU->getSlice()->getRefPOC( eRefPicList, pcTmpCU->getCUMvField(eRefPicList)->getRefIdx(uiIdx) ))
    4561   {
    4562     TComMv cMvPred = pcTmpCU->getCUMvField(eRefPicList)->getMv(uiIdx);
    4563 
    4564     pInfo->m_acMvCand[ pInfo->iN++] = cMvPred;
    4565     return true;
    4566   }
    4567 
    4568   RefPicList eRefPicList2nd = REF_PIC_LIST_0;
    4569   if(       eRefPicList == REF_PIC_LIST_0 )
    4570   {
    4571     eRefPicList2nd = REF_PIC_LIST_1;
    4572   }
    4573   else if ( eRefPicList == REF_PIC_LIST_1)
    4574   {
    4575     eRefPicList2nd = REF_PIC_LIST_0;
    4576   }
    4577 
    4578 
    4579   Int iCurrRefPOC = m_pcSlice->getRefPic( eRefPicList, iRefIdx)->getPOC();
    4580   Int iNeibRefPOC;
    4581 
    4582 
    4583   if( pcTmpCU->getCUMvField(eRefPicList2nd)->getRefIdx(uiIdx) >= 0 )
    4584   {
    4585     iNeibRefPOC = pcTmpCU->getSlice()->getRefPOC( eRefPicList2nd, pcTmpCU->getCUMvField(eRefPicList2nd)->getRefIdx(uiIdx) );
    4586     if( iNeibRefPOC == iCurrRefPOC ) // Same Reference Frame But Diff List//
    4587     {
    4588       TComMv cMvPred = pcTmpCU->getCUMvField(eRefPicList2nd)->getMv(uiIdx);
    4589       pInfo->m_acMvCand[ pInfo->iN++] = cMvPred;
     4553  const Int        currRefPOC     = m_pcSlice->getRefPic( eRefPicList, iRefIdx)->getPOC();
     4554  const RefPicList eRefPicList2nd = (eRefPicList == REF_PIC_LIST_0) ? REF_PIC_LIST_1 : REF_PIC_LIST_0;
     4555
     4556  for(Int predictorSource=0; predictorSource<2; predictorSource++) // examine the indicated reference picture list, then if not available, examine the other list.
     4557  {
     4558    const RefPicList eRefPicListIndex = (predictorSource==0) ? eRefPicList : eRefPicList2nd;
     4559    const Int        neibRefIdx       = neibCU->getCUMvField(eRefPicListIndex)->getRefIdx(neibPUPartIdx);
     4560
     4561    if ( neibRefIdx >= 0 && currRefPOC == neibCU->getSlice()->getRefPOC( eRefPicListIndex, neibRefIdx ))
     4562    {
     4563      info.m_acMvCand[info.iN++] = neibCU->getCUMvField(eRefPicListIndex)->getMv(neibPUPartIdx);
    45904564      return true;
    45914565    }
     
    46024576 * \returns Bool
    46034577 */
    4604 Bool TComDataCU::xAddMVPCandOrder( AMVPInfo* pInfo, RefPicList eRefPicList, Int iRefIdx, UInt uiPartUnitIdx, MVP_DIR eDir )
    4605 {
    4606   TComDataCU* pcTmpCU = NULL;
    4607   UInt uiIdx;
     4578Bool TComDataCU::xAddMVPCandWithScaling( AMVPInfo &info, const RefPicList eRefPicList, const Int iRefIdx, const UInt uiPartUnitIdx, const MVP_DIR eDir ) const
     4579{
     4580  const TComDataCU* neibCU = NULL;
     4581  UInt neibPUPartIdx;
    46084582  switch( eDir )
    46094583  {
    46104584  case MD_LEFT:
    46114585    {
    4612       pcTmpCU = getPULeft(uiIdx, uiPartUnitIdx);
     4586      neibCU = getPULeft(neibPUPartIdx, uiPartUnitIdx);
    46134587      break;
    46144588    }
    46154589  case MD_ABOVE:
    46164590    {
    4617       pcTmpCU = getPUAbove(uiIdx, uiPartUnitIdx);
     4591      neibCU = getPUAbove(neibPUPartIdx, uiPartUnitIdx);
    46184592      break;
    46194593    }
    46204594  case MD_ABOVE_RIGHT:
    46214595    {
    4622       pcTmpCU = getPUAboveRight(uiIdx, uiPartUnitIdx);
     4596      neibCU = getPUAboveRight(neibPUPartIdx, uiPartUnitIdx);
    46234597      break;
    46244598    }
    46254599  case MD_BELOW_LEFT:
    46264600    {
    4627       pcTmpCU = getPUBelowLeft(uiIdx, uiPartUnitIdx);
     4601      neibCU = getPUBelowLeft(neibPUPartIdx, uiPartUnitIdx);
    46284602      break;
    46294603    }
    46304604  case MD_ABOVE_LEFT:
    46314605    {
    4632       pcTmpCU = getPUAboveLeft(uiIdx, uiPartUnitIdx);
     4606      neibCU = getPUAboveLeft(neibPUPartIdx, uiPartUnitIdx);
    46334607      break;
    46344608    }
     
    46394613  }
    46404614
    4641   if ( pcTmpCU == NULL )
     4615  if ( neibCU == NULL )
    46424616  {
    46434617    return false;
    46444618  }
    46454619
    4646   RefPicList eRefPicList2nd = REF_PIC_LIST_0;
    4647   if(       eRefPicList == REF_PIC_LIST_0 )
    4648   {
    4649     eRefPicList2nd = REF_PIC_LIST_1;
    4650   }
    4651   else if ( eRefPicList == REF_PIC_LIST_1)
    4652   {
    4653     eRefPicList2nd = REF_PIC_LIST_0;
    4654   }
    4655 
    4656   Int iCurrPOC = m_pcSlice->getPOC();
    4657   Int iCurrRefPOC = m_pcSlice->getRefPic( eRefPicList, iRefIdx)->getPOC();
    4658   Int iNeibPOC = iCurrPOC;
    4659   Int iNeibRefPOC;
    4660   Bool bIsCurrRefLongTerm = m_pcSlice->getRefPic( eRefPicList, iRefIdx)->getIsLongTerm();
    4661   Bool bIsNeibRefLongTerm = false;
    4662 
    4663   //---------------  V1 (END) ------------------//
    4664   if( pcTmpCU->getCUMvField(eRefPicList)->getRefIdx(uiIdx) >= 0)
    4665   {
    4666     iNeibRefPOC = pcTmpCU->getSlice()->getRefPOC( eRefPicList, pcTmpCU->getCUMvField(eRefPicList)->getRefIdx(uiIdx) );
    4667     TComMv cMvPred = pcTmpCU->getCUMvField(eRefPicList)->getMv(uiIdx);
    4668     TComMv rcMv;
    4669 
    4670     bIsNeibRefLongTerm = pcTmpCU->getSlice()->getRefPic( eRefPicList, pcTmpCU->getCUMvField(eRefPicList)->getRefIdx(uiIdx) )->getIsLongTerm();
    4671     if ( bIsCurrRefLongTerm == bIsNeibRefLongTerm )
    4672     {
    4673       if ( bIsCurrRefLongTerm || bIsNeibRefLongTerm )
    4674       {
    4675         rcMv = cMvPred;
    4676       }
    4677       else
    4678       {
    4679         Int iScale = xGetDistScaleFactor( iCurrPOC, iCurrRefPOC, iNeibPOC, iNeibRefPOC );
    4680         if ( iScale == 4096 )
     4620  const RefPicList eRefPicList2nd = (eRefPicList == REF_PIC_LIST_0) ? REF_PIC_LIST_1 : REF_PIC_LIST_0;
     4621
     4622  const Int  currPOC            = m_pcSlice->getPOC();
     4623  const Int  currRefPOC         = m_pcSlice->getRefPic( eRefPicList, iRefIdx)->getPOC();
     4624  const Bool bIsCurrRefLongTerm = m_pcSlice->getRefPic( eRefPicList, iRefIdx)->getIsLongTerm();
     4625  const Int  neibPOC            = currPOC;
     4626
     4627  for(Int predictorSource=0; predictorSource<2; predictorSource++) // examine the indicated reference picture list, then if not available, examine the other list.
     4628  {
     4629    const RefPicList eRefPicListIndex = (predictorSource==0) ? eRefPicList : eRefPicList2nd;
     4630    const Int        neibRefIdx       = neibCU->getCUMvField(eRefPicListIndex)->getRefIdx(neibPUPartIdx);
     4631    if( neibRefIdx >= 0)
     4632    {
     4633      const Bool bIsNeibRefLongTerm = neibCU->getSlice()->getRefPic( eRefPicListIndex, neibRefIdx )->getIsLongTerm();
     4634
     4635      if ( bIsCurrRefLongTerm == bIsNeibRefLongTerm )
     4636      {
     4637        const TComMv &cMvPred = neibCU->getCUMvField(eRefPicListIndex)->getMv(neibPUPartIdx);
     4638        TComMv rcMv;
     4639        if ( bIsCurrRefLongTerm /* || bIsNeibRefLongTerm*/ )
    46814640        {
    46824641          rcMv = cMvPred;
     
    46844643        else
    46854644        {
    4686           rcMv = cMvPred.scaleMv( iScale );
     4645          const Int neibRefPOC = neibCU->getSlice()->getRefPOC( eRefPicListIndex, neibRefIdx );
     4646          const Int scale      = xGetDistScaleFactor( currPOC, currRefPOC, neibPOC, neibRefPOC );
     4647          if ( scale == 4096 )
     4648          {
     4649            rcMv = cMvPred;
     4650          }
     4651          else
     4652          {
     4653            rcMv = cMvPred.scaleMv( scale );
     4654          }
    46874655        }
    4688       }
    4689 
    4690       pInfo->m_acMvCand[ pInfo->iN++] = rcMv;
    4691       return true;
    4692     }
    4693   }
    4694   //---------------------- V2(END) --------------------//
    4695   if( pcTmpCU->getCUMvField(eRefPicList2nd)->getRefIdx(uiIdx) >= 0)
    4696   {
    4697     iNeibRefPOC = pcTmpCU->getSlice()->getRefPOC( eRefPicList2nd, pcTmpCU->getCUMvField(eRefPicList2nd)->getRefIdx(uiIdx) );
    4698     TComMv cMvPred = pcTmpCU->getCUMvField(eRefPicList2nd)->getMv(uiIdx);
    4699     TComMv rcMv;
    4700 
    4701     bIsNeibRefLongTerm = pcTmpCU->getSlice()->getRefPic( eRefPicList2nd, pcTmpCU->getCUMvField(eRefPicList2nd)->getRefIdx(uiIdx) )->getIsLongTerm();
    4702     if ( bIsCurrRefLongTerm == bIsNeibRefLongTerm )
    4703     {
    4704       if ( bIsCurrRefLongTerm || bIsNeibRefLongTerm )
    4705       {
    4706         rcMv = cMvPred;
    4707       }
    4708       else
    4709       {
    4710         Int iScale = xGetDistScaleFactor( iCurrPOC, iCurrRefPOC, iNeibPOC, iNeibRefPOC );
    4711         if ( iScale == 4096 )
    4712         {
    4713           rcMv = cMvPred;
    4714         }
    4715         else
    4716         {
    4717           rcMv = cMvPred.scaleMv( iScale );
    4718         }
    4719       }
    4720 
    4721       pInfo->m_acMvCand[ pInfo->iN++] = rcMv;
    4722       return true;
    4723     }
    4724   }
    4725   //---------------------- V3(END) --------------------//
     4656
     4657        info.m_acMvCand[info.iN++] = rcMv;
     4658        return true;
     4659      }
     4660    }
     4661  }
    47264662  return false;
    47274663}
    47284664
    4729 Bool TComDataCU::xGetColMVP( RefPicList eRefPicList, Int ctuRsAddr, Int uiPartUnitIdx, TComMv& rcMv, Int& riRefIdx
    47304665#if NH_3D_TMVP
    4731   , Bool bMRG
    4732 #endif
    4733 )
    4734 {
    4735   UInt uiAbsPartAddr = uiPartUnitIdx;
    4736 
    4737   RefPicList  eColRefPicList;
    4738   Int iColPOC, iColRefPOC, iCurrPOC, iCurrRefPOC, iScale;
    4739   TComMv cColMv;
     4666Bool TComDataCU::xGetColMVP( const RefPicList eRefPicList, const Int ctuRsAddr, const Int partUnitIdx, TComMv& rcMv, Int& refIdx, Bool bMRG  ) const
     4667#else
     4668Bool TComDataCU::xGetColMVP( const RefPicList eRefPicList, const Int ctuRsAddr, const Int partUnitIdx, TComMv& rcMv, const Int refIdx ) const
     4669#endif
     4670{
     4671  const UInt absPartAddr = partUnitIdx;
    47404672
    47414673  // use coldir.
    4742   TComPic *pColPic = getSlice()->getRefPic( RefPicList(getSlice()->isInterB() ? 1-getSlice()->getColFromL0Flag() : 0), getSlice()->getColRefIdx());
    4743   TComDataCU *pColCtu = pColPic->getCtu( ctuRsAddr );
    4744   if(pColCtu->getPic()==0||pColCtu->getPartitionSize(uiPartUnitIdx)==NUMBER_OF_PART_SIZES)
     4674  const TComPic    * const pColPic = getSlice()->getRefPic( RefPicList(getSlice()->isInterB() ? 1-getSlice()->getColFromL0Flag() : 0), getSlice()->getColRefIdx());
     4675  const TComDataCU * const pColCtu = pColPic->getCtu( ctuRsAddr );
     4676  if(pColCtu->getPic()==0 || pColCtu->getPartitionSize(partUnitIdx)==NUMBER_OF_PART_SIZES)
    47454677  {
    47464678    return false;
    47474679  }
    4748   iCurrPOC = m_pcSlice->getPOC();
    4749   iColPOC = pColCtu->getSlice()->getPOC();
    4750 
    4751   if (!pColCtu->isInter(uiAbsPartAddr))
     4680
     4681  if (!pColCtu->isInter(absPartAddr))
    47524682  {
    47534683    return false;
    47544684  }
    47554685
    4756   eColRefPicList = getSlice()->getCheckLDC() ? eRefPicList : RefPicList(getSlice()->getColFromL0Flag());
    4757 
    4758   Int iColRefIdx = pColCtu->getCUMvField(RefPicList(eColRefPicList))->getRefIdx(uiAbsPartAddr);
     4686  RefPicList eColRefPicList = getSlice()->getCheckLDC() ? eRefPicList : RefPicList(getSlice()->getColFromL0Flag());
     4687  Int iColRefIdx            = pColCtu->getCUMvField(RefPicList(eColRefPicList))->getRefIdx(absPartAddr);
    47594688
    47604689  if (iColRefIdx < 0 )
    47614690  {
    47624691    eColRefPicList = RefPicList(1 - eColRefPicList);
    4763     iColRefIdx = pColCtu->getCUMvField(RefPicList(eColRefPicList))->getRefIdx(uiAbsPartAddr);
     4692    iColRefIdx = pColCtu->getCUMvField(RefPicList(eColRefPicList))->getRefIdx(absPartAddr);
    47644693
    47654694    if (iColRefIdx < 0 )
     
    47694698  }
    47704699
    4771   // Scale the vector.
    4772   iColRefPOC = pColCtu->getSlice()->getRefPOC(eColRefPicList, iColRefIdx);
    4773   cColMv = pColCtu->getCUMvField(eColRefPicList)->getMv(uiAbsPartAddr);
    4774 
    4775   iCurrRefPOC = m_pcSlice->getRefPic(eRefPicList, riRefIdx)->getPOC();
    4776 
    4777   Bool bIsCurrRefLongTerm = m_pcSlice->getRefPic(eRefPicList, riRefIdx)->getIsLongTerm();
    4778   Bool bIsColRefLongTerm = pColCtu->getSlice()->getIsUsedAsLongTerm(eColRefPicList, iColRefIdx);
     4700#if NH_3D_TMVP
     4701  Bool bIsCurrRefLongTerm = m_pcSlice->getRefPic(eRefPicList, refIdx)->getIsLongTerm();
     4702#else
     4703  const Bool bIsCurrRefLongTerm = m_pcSlice->getRefPic(eRefPicList, refIdx)->getIsLongTerm();
     4704#endif
     4705  const Bool bIsColRefLongTerm  = pColCtu->getSlice()->getIsUsedAsLongTerm(eColRefPicList, iColRefIdx);
    47794706
    47804707  if ( bIsCurrRefLongTerm != bIsColRefLongTerm )
     
    47844711    if(bMRG && iAlterRefIdx > 0)
    47854712    {
    4786       riRefIdx = iAlterRefIdx;
    4787       bIsCurrRefLongTerm = m_pcSlice->getRefPic(eRefPicList, riRefIdx)->getIsLongTerm();
    4788       iCurrRefPOC = m_pcSlice->getRefPic(eRefPicList, riRefIdx)->getPOC();
     4713      refIdx = iAlterRefIdx;
     4714      bIsCurrRefLongTerm = m_pcSlice->getRefPic(eRefPicList, refIdx)->getIsLongTerm();
    47894715      assert(bIsCurrRefLongTerm == bIsColRefLongTerm);
    47904716    }
     
    47924718    {
    47934719#endif
    4794     return false;
     4720      return false;
    47954721#if NH_3D_TMVP
    47964722    }
    47974723#endif
    47984724  }
    4799 
     4725  // Scale the vector.
     4726  const TComMv &cColMv = pColCtu->getCUMvField(eColRefPicList)->getMv(absPartAddr);
     4727
     4728#if NH_3D_TMVP
    48004729  if ( bIsCurrRefLongTerm || bIsColRefLongTerm )
     4730#else
     4731  if ( bIsCurrRefLongTerm /*|| bIsColRefLongTerm*/ )
     4732#endif
    48014733  {
    48024734#if NH_3D_TMVP
    4803     Int iCurrViewId    = m_pcSlice->getViewId ();
    4804     Int iCurrRefViewId = m_pcSlice->getRefPic(eRefPicList, riRefIdx)->getViewId ();
    4805     Int iColViewId     = pColCtu->getSlice()->getViewId();
    4806     Int iColRefViewId  = pColCtu->getSlice()->getRefPic( eColRefPicList, pColCtu->getCUMvField(eColRefPicList)->getRefIdx(uiAbsPartAddr))->getViewId();
    4807     iScale = 4096;
     4735    const Int iCurrViewId    = m_pcSlice->getViewId ();
     4736    const Int iCurrRefViewId = m_pcSlice->getRefPic(eRefPicList, refIdx)->getViewId ();
     4737    const Int iColViewId     = pColCtu->getSlice()->getViewId();
     4738    const Int iColRefViewId  = pColCtu->getSlice()->getRefPic( eColRefPicList, pColCtu->getCUMvField(eColRefPicList)->getRefIdx(absPartAddr))->getViewId();
     4739    Int scale = 4096;
    48084740    if ( iCurrRefViewId != iCurrViewId && iColViewId != iColRefViewId )
    48094741    {
    4810       iScale = xGetDistScaleFactor( iCurrViewId, iCurrRefViewId, iColViewId, iColRefViewId );
    4811     }
    4812     if ( bMRG && iScale != 4096 && m_pcSlice->getIvMvScalingFlag( ) )
    4813     {
    4814       rcMv = cColMv.scaleMv( iScale );
     4742      scale = xGetDistScaleFactor( iCurrViewId, iCurrRefViewId, iColViewId, iColRefViewId );
     4743    }
     4744    if ( bMRG && scale != 4096 && m_pcSlice->getIvMvScalingFlag( ) )
     4745    {
     4746      rcMv = cColMv.scaleMv( scale );
    48154747    }
    48164748    else
    48174749    {
    48184750#endif
    4819     rcMv = cColMv;
     4751      rcMv = cColMv;
    48204752#if NH_3D_TMVP
    48214753    }
     
    48244756  else
    48254757  {
    4826     iScale = xGetDistScaleFactor(iCurrPOC, iCurrRefPOC, iColPOC, iColRefPOC);
    4827     if ( iScale == 4096 )
     4758    const Int currPOC    = m_pcSlice->getPOC();
     4759    const Int colPOC     = pColCtu->getSlice()->getPOC();
     4760    const Int colRefPOC  = pColCtu->getSlice()->getRefPOC(eColRefPicList, iColRefIdx);
     4761    const Int currRefPOC = m_pcSlice->getRefPic(eRefPicList, refIdx)->getPOC();
     4762    const Int scale      = xGetDistScaleFactor(currPOC, currRefPOC, colPOC, colRefPOC);
     4763    if ( scale == 4096 )
    48284764    {
    48294765      rcMv = cColMv;
     
    48314767    else
    48324768    {
    4833       rcMv = cColMv.scaleMv( iScale );
     4769      rcMv = cColMv.scaleMv( scale );
    48344770    }
    48354771  }
     
    48384774}
    48394775
     4776// Static member
    48404777Int TComDataCU::xGetDistScaleFactor(Int iCurrPOC, Int iCurrRefPOC, Int iColPOC, Int iColRefPOC)
    48414778{
     
    48574794}
    48584795
    4859 Void TComDataCU::xDeriveCenterIdx( UInt uiPartIdx, UInt& ruiPartIdxCenter )
     4796Void TComDataCU::xDeriveCenterIdx( UInt uiPartIdx, UInt& ruiPartIdxCenter ) const
    48604797{
    48614798  UInt uiPartAddr;
     
    50014938 
    50024939  UInt uiMidPart, uiPartNeighbor; 
    5003   TComDataCU* pcCUNeighbor;
     4940  const TComDataCU* pcCUNeighbor;
    50044941  Bool bDepAvail = false;
    50054942  Pel *pDepth  = this->getPic()->getPicYuvRec()->getAddr(COMPONENT_Y);
     
    51615098  UInt uiIdx = 0;
    51625099  Bool        bCheckMcpDv = false;   
    5163   TComDataCU* pcTmpCU     = NULL;
     5100  const TComDataCU* pcTmpCU     = NULL;
    51645101
    51655102  //// ******* Get disparity from left block ******* /////
     
    53075244
    53085245
    5309 Bool TComDataCU::xCheckSpatialNBDV( TComDataCU* pcTmpCU, UInt uiIdx, DisInfo* pNbDvInfo, Bool bSearchForMvpDv, IDVInfo* paIDVInfo, UInt uiMvpDvPos
     5246Bool TComDataCU::xCheckSpatialNBDV( const TComDataCU* pcTmpCU, UInt uiIdx, DisInfo* pNbDvInfo, Bool bSearchForMvpDv, IDVInfo* paIDVInfo, UInt uiMvpDvPos
    53105247#if NH_3D_NBDV_REF
    53115248, Bool bDepthRefine
  • branches/HTM-15.2-dev/source/Lib/TLibCommon/TComDataCU.h

    r1321 r1360  
    112112  UChar*         m_ucDISType;
    113113#endif
    114   Char*          m_pePartSize;         ///< array of partition sizes
    115   Char*          m_pePredMode;         ///< array of prediction modes
    116   Char*          m_crossComponentPredictionAlpha[MAX_NUM_COMPONENT]; ///< array of cross-component prediction alpha values
     114  SChar*          m_pePartSize;         ///< array of partition sizes
     115  SChar*        m_pePredMode;                           ///< array of prediction modes
     116  SChar*        m_crossComponentPredictionAlpha[MAX_NUM_COMPONENT]; ///< array of cross-component prediction alpha values
    117117  Bool*          m_CUTransquantBypass;   ///< array of cu_transquant_bypass flags
    118   Char*          m_phQP;               ///< array of QP values
     118  SChar*        m_phQP;                                 ///< array of QP values
    119119  UChar*         m_ChromaQpAdj;        ///< array of chroma QP adjustments (indexed). when value = 0, cu_chroma_qp_offset_flag=0; when value>0, indicates cu_chroma_qp_offset_flag=1 and cu_chroma_qp_offset_idx=value-1
    120120  UInt           m_codedChromaQpAdj;
     
    125125  TCoeff*        m_pcTrCoeff[MAX_NUM_COMPONENT];       ///< array of transform coefficient buffers (0->Y, 1->Cb, 2->Cr)
    126126#if ADAPTIVE_QP_SELECTION
    127   TCoeff*        m_pcArlCoeff[MAX_NUM_COMPONENT];  // ARL coefficient buffer (0->Y, 1->Cb, 2->Cr)
     127  TCoeff*       m_pcArlCoeff[MAX_NUM_COMPONENT];        ///< ARL coefficient buffer (0->Y, 1->Cb, 2->Cr)
    128128  Bool           m_ArlCoeffIsAliasedAllocation;  ///< ARL coefficient buffer is an alias of the global buffer and must not be free()'d
    129129#endif
     
    154154  Bool          m_bIsMergeAMP;
    155155#endif
    156   UChar*        m_puhIntraDir[MAX_NUM_CHANNEL_TYPE]; // 0-> Luma, 1-> Chroma
     156  UChar*        m_puhIntraDir[MAX_NUM_CHANNEL_TYPE];
    157157  UChar*        m_puhInterDir;        ///< array of inter directions
    158   Char*         m_apiMVPIdx[NUM_REF_PIC_LIST_01];       ///< array of motion vector predictor candidates
    159   Char*         m_apiMVPNum[NUM_REF_PIC_LIST_01];       ///< array of number of possible motion vectors predictors
     158  SChar*        m_apiMVPIdx[NUM_REF_PIC_LIST_01];       ///< array of motion vector predictor candidates
     159  SChar*        m_apiMVPNum[NUM_REF_PIC_LIST_01];       ///< array of number of possible motion vectors predictors
    160160  Bool*         m_pbIPCMFlag;         ///< array of intra_pcm flags
    161161#if NH_3D_NBDV
     
    163163#endif
    164164#if NH_3D_VSP
    165   Char*         m_piVSPFlag;          ///< array of VSP flags to indicate whehter a block uses VSP or not  ///< 0: non-VSP; 1: VSP
     165  SChar*        m_piVSPFlag;          ///< array of VSP flags to indicate whehter a block uses VSP or not  ///< 0: non-VSP; 1: VSP
    166166#endif
    167167#if NH_3D_SPIVMP
     
    208208  UInt          m_uiTotalBits;        ///< sum of partition bits
    209209  UInt          m_uiTotalBins;        ///< sum of partition bins
    210   Char          m_codedQP;
     210  SChar         m_codedQP;
    211211#if NH_3D_MLC
    212212  DisInfo         m_cDefaultDisInfo;    ///< Default disparity information for initializing
     
    219219protected:
    220220
    221   /// add possible motion vector predictor candidates
    222   Bool          xAddMVPCand           ( AMVPInfo* pInfo, RefPicList eRefPicList, Int iRefIdx, UInt uiPartUnitIdx, MVP_DIR eDir );
    223   Bool          xAddMVPCandOrder      ( AMVPInfo* pInfo, RefPicList eRefPicList, Int iRefIdx, UInt uiPartUnitIdx, MVP_DIR eDir );
     221  /// adds a single possible motion vector predictor candidate
     222  Bool          xAddMVPCandUnscaled           ( AMVPInfo &info, const RefPicList eRefPicList, const Int iRefIdx, const UInt uiPartUnitIdx, const MVP_DIR eDir ) const;
     223  Bool          xAddMVPCandWithScaling        ( AMVPInfo &info, const RefPicList eRefPicList, const Int iRefIdx, const UInt uiPartUnitIdx, const MVP_DIR eDir ) const;
     224
    224225#if NH_3D_VSP
    225226  Bool          xAddVspCand( Int mrgCandIdx, DisInfo* pDInfo, Int& iCount);
     
    229230#endif
    230231
    231   Void          deriveRightBottomIdx        ( UInt uiPartIdx, UInt& ruiPartIdxRB );
    232   Bool          xGetColMVP( RefPicList eRefPicList, Int ctuRsAddr, Int uiPartUnitIdx, TComMv& rcMv, Int& riRefIdx
     232  Void          deriveRightBottomIdx          ( UInt uiPartIdx, UInt& ruiPartIdxRB ) const;
     233
    233234#if NH_3D_TMVP
    234   ,  Bool bMRG = true
    235 #endif
    236  );
    237 
     235  Bool          xGetColMVP                    ( const RefPicList eRefPicList, const Int ctuRsAddr, const Int partUnitIdx, TComMv& rcMv, Int& refIdx, Bool bMRG = true  ) const;
     236#else
     237  Bool          xGetColMVP                    ( const RefPicList eRefPicList, const Int ctuRsAddr, const Int partUnitIdx, TComMv& rcMv, const Int refIdx ) const;
     238#endif
    238239
    239240  /// compute scaling factor from POC difference
     241
    240242#if !NH_3D_ARP
    241   Int           xGetDistScaleFactor   ( Int iCurrPOC, Int iCurrRefPOC, Int iColPOC, Int iColRefPOC );
    242 #endif
    243 
    244   Void xDeriveCenterIdx( UInt uiPartIdx, UInt& ruiPartIdxCenter );
     243  static Int    xGetDistScaleFactor           ( Int iCurrPOC, Int iCurrRefPOC, Int iColPOC, Int iColRefPOC );
     244#endif
     245  Void          xDeriveCenterIdx              ( UInt uiPartIdx, UInt& ruiPartIdxCenter ) const;
    245246
    246247#if NH_3D_VSP
     
    249250
    250251public:
     252
     253#if NH_3D_ARP
     254  static Int    xGetDistScaleFactor           ( Int iCurrPOC, Int iCurrRefPOC, Int iColPOC, Int iColRefPOC );
     255#endif
     256
    251257  TComDataCU();
    252258  virtual ~TComDataCU();
     
    255261  // create / destroy / initialize / copy
    256262  // -------------------------------------------------------------------------------------------------------------------
    257 #if NH_3D_ARP
    258   /// compute scaling factor from POC difference
    259   Int           xGetDistScaleFactor   ( Int iCurrPOC, Int iCurrRefPOC, Int iColPOC, Int iColRefPOC );
    260 #endif
    261263  Void          create                ( ChromaFormat chromaFormatIDC, UInt uiNumPartition, UInt uiWidth, UInt uiHeight, Bool bDecSubCu, Int unitSize
    262264#if ADAPTIVE_QP_SELECTION
     
    315317  // -------------------------------------------------------------------------------------------------------------------
    316318
    317   Char*         getPartitionSize      ()                        { return m_pePartSize;        }
    318   PartSize      getPartitionSize      ( UInt uiIdx )            { return static_cast<PartSize>( m_pePartSize[uiIdx] ); }
     319  SChar*        getPartitionSize              ( )                                                          { return m_pePartSize;                       }
     320  PartSize      getPartitionSize              ( UInt uiIdx ) const                                         { return static_cast<PartSize>( m_pePartSize[uiIdx] ); }
    319321  Void          setPartitionSize      ( UInt uiIdx, PartSize uh){ m_pePartSize[uiIdx] = uh;   }
    320322  Void          setPartSizeSubParts   ( PartSize eMode, UInt uiAbsPartIdx, UInt uiDepth );
     
    326328 
    327329  Bool*         getSkipFlag            ()                        { return m_skipFlag;          }
    328   Bool          getSkipFlag            (UInt idx)                { return m_skipFlag[idx];     }
     330  Bool          getSkipFlag                   ( UInt idx ) const                                           { return m_skipFlag[idx];                    }
    329331  Void          setSkipFlag           ( UInt idx, Bool skip)     { m_skipFlag[idx] = skip;   }
    330332  Void          setSkipFlagSubParts   ( Bool skip, UInt absPartIdx, UInt depth );
     
    340342  Void         setDISTypeSubParts    ( UChar ucDISType, UInt uiAbsPartIdx, UInt uiDepth );
    341343#endif
    342   Char*         getPredictionMode     ()                        { return m_pePredMode;        }
    343   PredMode      getPredictionMode     ( UInt uiIdx )            { return static_cast<PredMode>( m_pePredMode[uiIdx] ); }
     344  SChar*        getPredictionMode             ( )                                                          { return m_pePredMode;                       }
     345  PredMode      getPredictionMode             ( UInt uiIdx ) const                                         { return static_cast<PredMode>( m_pePredMode[uiIdx] ); }
    344346  Void          setPredictionMode     ( UInt uiIdx, PredMode uh){ m_pePredMode[uiIdx] = uh;   }
    345347  Void          setPredModeSubParts   ( PredMode eMode, UInt uiAbsPartIdx, UInt uiDepth );
    346348
    347349#if NH_3D_DBBP
    348   Bool*         getDBBPFlag           ()                        { return m_pbDBBPFlag;               }
    349   Bool          getDBBPFlag           ( UInt uiIdx )            { return m_pbDBBPFlag[uiIdx];        }
     350  Bool*         getDBBPFlag           ()                        const { return m_pbDBBPFlag;               }
     351  Bool          getDBBPFlag           ( UInt uiIdx )            const { return m_pbDBBPFlag[uiIdx];        }
    350352  Void          setDBBPFlag           ( UInt uiIdx, Bool b )    { m_pbDBBPFlag[uiIdx] = b;           }
    351353  Void          setDBBPFlagSubParts   ( Bool bDBBPFlag, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth );
     
    353355#endif
    354356
    355   Char*         getCrossComponentPredictionAlpha( ComponentID compID )             { return m_crossComponentPredictionAlpha[compID];         }
    356   Char          getCrossComponentPredictionAlpha( UInt uiIdx, ComponentID compID ) { return m_crossComponentPredictionAlpha[compID][uiIdx]; }
     357  SChar*        getCrossComponentPredictionAlpha( ComponentID compID )                                     { return m_crossComponentPredictionAlpha[compID];        }
     358  SChar         getCrossComponentPredictionAlpha( UInt uiIdx, ComponentID compID )                         { return m_crossComponentPredictionAlpha[compID][uiIdx]; }
    357359
    358360  Bool*         getCUTransquantBypass ()                        { return m_CUTransquantBypass;        }
    359   Bool          getCUTransquantBypass( UInt uiIdx )             { return m_CUTransquantBypass[uiIdx]; }
     361  Bool          getCUTransquantBypass         ( UInt uiIdx ) const                                         { return m_CUTransquantBypass[uiIdx];        }
    360362
    361363  UChar*        getWidth              ()                        { return m_puhWidth;          }
    362   UChar         getWidth              ( UInt uiIdx )            { return m_puhWidth[uiIdx];   }
     364  UChar         getWidth                      ( UInt uiIdx ) const                                         { return m_puhWidth[uiIdx];                  }
    363365  Void          setWidth              ( UInt uiIdx, UChar  uh ) { m_puhWidth[uiIdx] = uh;     }
    364366
    365367  UChar*        getHeight             ()                        { return m_puhHeight;         }
    366   UChar         getHeight             ( UInt uiIdx )            { return m_puhHeight[uiIdx];  }
     368  UChar         getHeight                     ( UInt uiIdx ) const                                         { return m_puhHeight[uiIdx];                 }
    367369  Void          setHeight             ( UInt uiIdx, UChar  uh ) { m_puhHeight[uiIdx] = uh;    }
    368370
    369371  Void          setSizeSubParts       ( UInt uiWidth, UInt uiHeight, UInt uiAbsPartIdx, UInt uiDepth );
    370372
    371   Char*         getQP                 ()                        { return m_phQP;              }
    372   Char          getQP                 ( UInt uiIdx ) const      { return m_phQP[uiIdx];       }
    373   Void          setQP                 ( UInt uiIdx, Char value ){ m_phQP[uiIdx] =  value;     }
     373  SChar*        getQP                         ( )                                                          { return m_phQP;                             }
     374  SChar         getQP                         ( UInt uiIdx ) const                                         { return m_phQP[uiIdx];                      }
     375  Void          setQP                         ( UInt uiIdx, SChar value )                                  { m_phQP[uiIdx] =  value;                    }
    374376  Void          setQPSubParts         ( Int qp,   UInt uiAbsPartIdx, UInt uiDepth );
    375   Int           getLastValidPartIdx   ( Int iAbsPartIdx );
    376   Char          getLastCodedQP        ( UInt uiAbsPartIdx );
     377  Int           getLastValidPartIdx           ( Int iAbsPartIdx ) const;
     378  SChar         getLastCodedQP                ( UInt uiAbsPartIdx ) const;
    377379  Void          setQPSubCUs           ( Int qp, UInt absPartIdx, UInt depth, Bool &foundNonZeroCbf );
    378   Void          setCodedQP            ( Char qp )               { m_codedQP = qp;             }
    379   Char          getCodedQP            ()                        { return m_codedQP;           }
     380  Void          setCodedQP                    ( SChar qp )                                                 { m_codedQP = qp;                            }
     381  SChar         getCodedQP                    ( ) const                                                    { return m_codedQP;                          }
    380382
    381383  UChar*        getChromaQpAdj        ()                        { return m_ChromaQpAdj;       } ///< array of chroma QP adjustments (indexed). when value = 0, cu_chroma_qp_offset_flag=0; when value>0, indicates cu_chroma_qp_offset_flag=1 and cu_chroma_qp_offset_idx=value-1
     
    383385  Void          setChromaQpAdj        (Int idx, UChar val)      { m_ChromaQpAdj[idx] = val;   } ///< When val = 0,   cu_chroma_qp_offset_flag=0; when val>0,   indicates cu_chroma_qp_offset_flag=1 and cu_chroma_qp_offset_idx=val-1
    384386  Void          setChromaQpAdjSubParts( UChar val, Int absPartIdx, Int depth );
    385   Void          setCodedChromaQpAdj   ( Char qp )               { m_codedChromaQpAdj = qp;    }
    386   Char          getCodedChromaQpAdj   ()                        { return m_codedChromaQpAdj;  }
    387 
    388   Bool          isLosslessCoded       ( UInt absPartIdx );
     387  Void          setCodedChromaQpAdj           ( SChar qp )                                                 { m_codedChromaQpAdj = qp;                   }
     388  SChar         getCodedChromaQpAdj           ( ) const                                                    { return m_codedChromaQpAdj;                 }
     389
     390  Bool          isLosslessCoded               ( UInt absPartIdx ) const;
    389391
    390392  UChar*        getTransformIdx       ()                        { return m_puhTrIdx;          }
    391   UChar         getTransformIdx       ( UInt uiIdx )            { return m_puhTrIdx[uiIdx];   }
     393  UChar         getTransformIdx               ( UInt uiIdx ) const                                         { return m_puhTrIdx[uiIdx];                  }
    392394  Void          setTrIdxSubParts      ( UInt uiTrIdx, UInt uiAbsPartIdx, UInt uiDepth );
    393395
    394396  UChar*        getTransformSkip      ( ComponentID compID )    { return m_puhTransformSkip[compID];}
    395   UChar         getTransformSkip      ( UInt uiIdx, ComponentID compID)    { return m_puhTransformSkip[compID][uiIdx];}
     397  UChar         getTransformSkip              ( UInt uiIdx, ComponentID compID ) const                     { return m_puhTransformSkip[compID][uiIdx];  }
    396398  Void          setTransformSkipSubParts  ( UInt useTransformSkip, ComponentID compID, UInt uiAbsPartIdx, UInt uiDepth);
    397399  Void          setTransformSkipSubParts  ( const UInt useTransformSkip[MAX_NUM_COMPONENT], UInt uiAbsPartIdx, UInt uiDepth );
    398400
    399401  UChar*        getExplicitRdpcmMode      ( ComponentID component ) { return m_explicitRdpcmMode[component]; }
    400   UChar         getExplicitRdpcmMode      ( ComponentID component, UInt partIdx ) {return m_explicitRdpcmMode[component][partIdx]; }
     402  UChar         getExplicitRdpcmMode          ( ComponentID component, UInt partIdx ) const                { return m_explicitRdpcmMode[component][partIdx]; }
    401403  Void          setExplicitRdpcmModePartRange ( UInt rdpcmMode, ComponentID compID, UInt uiAbsPartIdx, UInt uiCoveredPartIdxes );
    402404
    403   Bool          isRDPCMEnabled         ( UInt uiAbsPartIdx )  { return getSlice()->getSPS()->getSpsRangeExtension().getRdpcmEnabledFlag(isIntra(uiAbsPartIdx) ? RDPCM_SIGNAL_IMPLICIT : RDPCM_SIGNAL_EXPLICIT); }
    404 
    405   Void          setCrossComponentPredictionAlphaPartRange    ( Char alphaValue, ComponentID compID, UInt uiAbsPartIdx, UInt uiCoveredPartIdxes );
     405  Bool          isRDPCMEnabled                ( UInt uiAbsPartIdx ) const                                  { return getSlice()->getSPS()->getSpsRangeExtension().getRdpcmEnabledFlag(isIntra(uiAbsPartIdx) ? RDPCM_SIGNAL_IMPLICIT : RDPCM_SIGNAL_EXPLICIT); }
     406
     407  Void          setCrossComponentPredictionAlphaPartRange ( SChar alphaValue, ComponentID compID, UInt uiAbsPartIdx, UInt uiCoveredPartIdxes );
    406408  Void          setTransformSkipPartRange                    ( UInt useTransformSkip, ComponentID compID, UInt uiAbsPartIdx, UInt uiCoveredPartIdxes );
    407409
    408   UInt          getQuadtreeTULog2MinSizeInCU( UInt uiIdx );
     410  UInt          getQuadtreeTULog2MinSizeInCU  ( UInt uiIdx ) const;
    409411
    410412  TComCUMvField* getCUMvField         ( RefPicList e )          { return  &m_acCUMvField[e];  }
     413  const TComCUMvField* getCUMvField           ( RefPicList e ) const                                       { return &m_acCUMvField[e];                  }
    411414
    412415  TCoeff*       getCoeff              (ComponentID component)   { return m_pcTrCoeff[component]; }
     
    417420  Pel*          getPCMSample          ( ComponentID component ) { return m_pcIPCMSample[component]; }
    418421
    419   UChar         getCbf    ( UInt uiIdx, ComponentID eType )                  { return m_puhCbf[eType][uiIdx];  }
     422  UChar         getCbf                        ( UInt uiIdx, ComponentID eType ) const                      { return m_puhCbf[eType][uiIdx];             }
    420423  UChar*        getCbf    ( ComponentID eType )                              { return m_puhCbf[eType];         }
    421   UChar         getCbf    ( UInt uiIdx, ComponentID eType, UInt uiTrDepth )  { return ( ( getCbf( uiIdx, eType ) >> uiTrDepth ) & 0x1 ); }
     424  UChar         getCbf                        ( UInt uiIdx, ComponentID eType, UInt uiTrDepth ) const      { return ( ( getCbf( uiIdx, eType ) >> uiTrDepth ) & 0x1 ); }
    422425  Void          setCbf    ( UInt uiIdx, ComponentID eType, UChar uh )        { m_puhCbf[eType][uiIdx] = uh;    }
    423426  Void          clearCbf  ( UInt uiIdx, ComponentID eType, UInt uiNumParts );
    424   UChar         getQtRootCbf          ( UInt uiIdx );
     427  UChar         getQtRootCbf                  ( UInt uiIdx ) const;
    425428
    426429  Void          setCbfSubParts        ( const UInt uiCbf[MAX_NUM_COMPONENT],  UInt uiAbsPartIdx, UInt uiDepth           );
     
    436439
    437440  Bool*         getMergeFlag          ()                        { return m_pbMergeFlag;               }
    438   Bool          getMergeFlag          ( UInt uiIdx )            { return m_pbMergeFlag[uiIdx];        }
     441  Bool          getMergeFlag                  ( UInt uiIdx ) const                                         { return m_pbMergeFlag[uiIdx];               }
    439442  Void          setMergeFlag          ( UInt uiIdx, Bool b )    { m_pbMergeFlag[uiIdx] = b;           }
    440443  Void          setMergeFlagSubParts  ( Bool bMergeFlag, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth );
    441444
    442445  UChar*        getMergeIndex         ()                        { return m_puhMergeIndex;                         }
    443   UChar         getMergeIndex         ( UInt uiIdx )            { return m_puhMergeIndex[uiIdx];                  }
     446  UChar         getMergeIndex                 ( UInt uiIdx ) const                                         { return m_puhMergeIndex[uiIdx];             }
    444447  Void          setMergeIndex         ( UInt uiIdx, UInt uiMergeIndex ) { m_puhMergeIndex[uiIdx] = uiMergeIndex;  }
    445448  Void          setMergeIndexSubParts ( UInt uiMergeIndex, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth );
     
    453456#if AMP_MRG
    454457  Void          setMergeAMP( Bool b )      { m_bIsMergeAMP = b; }
    455   Bool          getMergeAMP( )             { return m_bIsMergeAMP; }
     458  Bool          getMergeAMP                   ( ) const                                                    { return m_bIsMergeAMP;                      }
    456459#endif
    457460
     
    465468
    466469  UChar*        getInterDir           ()                        { return m_puhInterDir;               }
    467   UChar         getInterDir           ( UInt uiIdx )            { return m_puhInterDir[uiIdx];        }
     470  UChar         getInterDir                   ( UInt uiIdx ) const                                         { return m_puhInterDir[uiIdx];               }
    468471  Void          setInterDir           ( UInt uiIdx, UChar  uh ) { m_puhInterDir[uiIdx] = uh;          }
    469472  Void          setInterDirSubParts   ( UInt uiDir,  UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth );
    470473  Bool*         getIPCMFlag           ()                        { return m_pbIPCMFlag;               }
    471   Bool          getIP