Changeset 1360 in 3DVCSoftware


Ignore:
Timestamp:
28 Oct 2015, 17:46:00 (10 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          getIPCMFlag           (UInt uiIdx )             { return m_pbIPCMFlag[uiIdx];        }
     474  Bool          getIPCMFlag                   ( UInt uiIdx ) const                                         { return m_pbIPCMFlag[uiIdx];                }
    472475  Void          setIPCMFlag           (UInt uiIdx, Bool b )     { m_pbIPCMFlag[uiIdx] = b;           }
    473476  Void          setIPCMFlagSubParts   (Bool bIpcmFlag, UInt uiAbsPartIdx, UInt uiDepth);
    … …  
    482485#if NH_3D_NBDV
    483486  Void          xDeriveRightBottomNbIdx(Int &uiLCUIdxRBNb, Int &uiPartIdxRBNb );
    484   Bool          xCheckSpatialNBDV (TComDataCU* pcTmpCU, UInt uiIdx, DisInfo* pNbDvInfo, Bool bSearchForMvpDv, IDVInfo* paMvpDvInfo,
     487  Bool          xCheckSpatialNBDV (const TComDataCU* pcTmpCU, UInt uiIdx, DisInfo* pNbDvInfo, Bool bSearchForMvpDv, IDVInfo* paMvpDvInfo,
    485488                                   UInt uiMvpDvPos
    486489#if NH_3D_NBDV_REF
    … …  
    525528#endif
    526529#if NH_3D_ARP
    527   UChar*        getARPW            ()                        { return m_puhARPW;               }
    528   UChar         getARPW            ( UInt uiIdx )            { return m_puhARPW[uiIdx];        }
     530  UChar*        getARPW            ()              const          { return m_puhARPW;               }
     531  UChar         getARPW            ( UInt uiIdx )  const          { return m_puhARPW[uiIdx];        }
    529532  Void          setARPW            ( UInt uiIdx, UChar w )   { m_puhARPW[uiIdx] = w;           }
    530533  Void          setARPWSubParts    ( UChar w, UInt uiAbsPartIdx, UInt uiDepth );
    … …  
    536539  Void          setICFlagSubParts  ( Bool bICFlag,  UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth );
    537540  Bool          isICFlagRequired   ( UInt uiAbsPartIdx );
    538   Void          getPartIndexAndSize( UInt uiPartIdx, UInt& ruiPartAddr, Int& riWidth, Int& riHeight, UInt uiAbsPartIdx = 0, Bool bLCU = false);
     541  Void          getPartIndexAndSize( UInt uiPartIdx, UInt& ruiPartAddr, Int& riWidth, Int& riHeight, UInt uiAbsPartIdx = 0, Bool bLCU = false) const;
    539542#elif NH_3D_VSP
    540   Void          getPartIndexAndSize( UInt uiPartIdx, UInt& ruiPartAddr, Int& riWidth, Int& riHeight, UInt uiAbsPartIdx = 0, Bool bLCU = false);
     543  Void          getPartIndexAndSize( UInt uiPartIdx, UInt& ruiPartAddr, Int& riWidth, Int& riHeight, UInt uiAbsPartIdx = 0, Bool bLCU = false) const;
    541544#else
    542545  // -------------------------------------------------------------------------------------------------------------------
    … …  
    544547  // -------------------------------------------------------------------------------------------------------------------
    545548
    546   Void          getPartIndexAndSize   ( UInt uiPartIdx, UInt& ruiPartAddr, Int& riWidth, Int& riHeight ); // This is for use by a leaf/sub CU object only, with no additional AbsPartIdx
    547 #endif
    548   UChar         getNumPartitions      ( const UInt uiAbsPartIdx = 0 );
    549   Bool          isFirstAbsZorderIdxInDepth (UInt uiAbsPartIdx, UInt uiDepth);
     549  Void          getPartIndexAndSize           ( UInt uiPartIdx, UInt& ruiPartAddr, Int& riWidth, Int& riHeight ) const; // This is for use by a leaf/sub CU object only, with no additional AbsPartIdx
     550#endif
     551  UChar         getNumPartitions              ( const UInt uiAbsPartIdx = 0 ) const;
     552  Bool          isFirstAbsZorderIdxInDepth    ( UInt uiAbsPartIdx, UInt uiDepth ) const;
    550553
    551554#if NH_3D_DMM
    … …  
    575578  // -------------------------------------------------------------------------------------------------------------------
    576579
    577   Void          getMvField            ( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefPicList, TComMvField& rcMvField );
    578 
    579   Void          fillMvpCand           ( UInt uiPartIdx, UInt uiPartAddr, RefPicList eRefPicList, Int iRefIdx, AMVPInfo* pInfo );
    580   Bool          isDiffMER             ( Int xN, Int yN, Int xP, Int yP);
    581   Void          getPartPosition       ( UInt partIdx, Int& xP, Int& yP, Int& nPSW, Int& nPSH);
     580  static Void   getMvField                    ( const TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefPicList, TComMvField& rcMvField );
     581
     582  Void          fillMvpCand                   ( const UInt uiPartIdx, const UInt uiPartAddr, const RefPicList eRefPicList, const Int iRefIdx, AMVPInfo* pInfo ) const;
     583  Bool          isDiffMER                     ( Int xN, Int yN, Int xP, Int yP ) const;
     584  Void          getPartPosition               ( UInt partIdx, Int& xP, Int& yP, Int& nPSW, Int& nPSH ) const;
    582585
    583586  Void          setMVPIdx             ( RefPicList eRefPicList, UInt uiIdx, Int iMVPIdx)  { m_apiMVPIdx[eRefPicList][uiIdx] = iMVPIdx;  }
    584   Int           getMVPIdx             ( RefPicList eRefPicList, UInt uiIdx)               { return m_apiMVPIdx[eRefPicList][uiIdx];     }
    585   Char*         getMVPIdx             ( RefPicList eRefPicList )                          { return m_apiMVPIdx[eRefPicList];            }
     587  Int           getMVPIdx                     ( RefPicList eRefPicList, UInt uiIdx) const                  { return m_apiMVPIdx[eRefPicList][uiIdx];    }
     588  SChar*        getMVPIdx                     ( RefPicList eRefPicList )                                   { return m_apiMVPIdx[eRefPicList];           }
    586589
    587590  Void          setMVPNum             ( RefPicList eRefPicList, UInt uiIdx, Int iMVPNum ) { m_apiMVPNum[eRefPicList][uiIdx] = iMVPNum;  }
    588   Int           getMVPNum             ( RefPicList eRefPicList, UInt uiIdx )              { return m_apiMVPNum[eRefPicList][uiIdx];     }
    589   Char*         getMVPNum             ( RefPicList eRefPicList )                          { return m_apiMVPNum[eRefPicList];            }
     591  Int           getMVPNum                     ( RefPicList eRefPicList, UInt uiIdx ) const                 { return m_apiMVPNum[eRefPicList][uiIdx];    }
     592  SChar*        getMVPNum                     ( RefPicList eRefPicList )                                   { return m_apiMVPNum[eRefPicList];           }
    590593
    591594  Void          setMVPIdxSubParts     ( Int iMVPIdx, RefPicList eRefPicList, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth );
    592595  Void          setMVPNumSubParts     ( Int iMVPNum, RefPicList eRefPicList, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth );
    593596
    594   Void          clipMv                ( TComMv&     rcMv     );
     597  Void          clipMv                        ( TComMv&     rcMv     ) const;
     598
    595599#if NH_MV
    596600  Void          checkMvVertRest (TComMv&  rcMv,  RefPicList eRefPicList, int iRefIdx );
    597601#endif
    598   Void          getMvPredLeft         ( TComMv&     rcMvPred )   { rcMvPred = m_cMvFieldA.getMv(); }
    599   Void          getMvPredAbove        ( TComMv&     rcMvPred )   { rcMvPred = m_cMvFieldB.getMv(); }
    600   Void          getMvPredAboveRight   ( TComMv&     rcMvPred )   { rcMvPred = m_cMvFieldC.getMv(); }
     602  Void          getMvPredLeft                 ( TComMv&     rcMvPred ) const                               { rcMvPred = m_cMvFieldA.getMv();            }
     603  Void          getMvPredAbove                ( TComMv&     rcMvPred ) const                               { rcMvPred = m_cMvFieldB.getMv();            }
     604  Void          getMvPredAboveRight           ( TComMv&     rcMvPred ) const                               { rcMvPred = m_cMvFieldC.getMv();            }
    601605#if NH_3D
    602606  Void          compressMV            ( Int scale );
    … …  
    618622  Bool          CUIsFromSameSliceAndTile    ( const TComDataCU *pCU /* Can be NULL */) const;
    619623  Bool          CUIsFromSameSliceTileAndWavefrontRow( const TComDataCU *pCU /* Can be NULL */) const;
    620   Bool          isLastSubCUOfCtu(const UInt absPartIdx);
    621 
    622 
    623   TComDataCU*   getPULeft                   ( UInt& uiLPartUnitIdx,
     624  Bool          isLastSubCUOfCtu              ( const UInt absPartIdx ) const;
     625
     626
     627  const TComDataCU*   getPULeft               ( UInt& uiLPartUnitIdx,
    624628                                              UInt uiCurrPartUnitIdx,
    625629                                              Bool bEnforceSliceRestriction=true,
    626                                               Bool bEnforceTileRestriction=true );
    627   TComDataCU*   getPUAbove                  ( UInt&  uiAPartUnitIdx,
     630                                                Bool  bEnforceTileRestriction=true ) const;
     631
     632  const TComDataCU*   getPUAbove              ( UInt& uiAPartUnitIdx,
    628633                                              UInt uiCurrPartUnitIdx,
    629634                                              Bool bEnforceSliceRestriction=true,
    630635                                              Bool planarAtCTUBoundary = false,
    631                                               Bool bEnforceTileRestriction=true );
    632   TComDataCU*   getPUAboveLeft              ( UInt&  uiALPartUnitIdx, UInt uiCurrPartUnitIdx, Bool bEnforceSliceRestriction=true );
    633 
    634   TComDataCU*   getQpMinCuLeft              ( UInt&  uiLPartUnitIdx , UInt uiCurrAbsIdxInCtu );
    635   TComDataCU*   getQpMinCuAbove             ( UInt&  uiAPartUnitIdx , UInt uiCurrAbsIdxInCtu );
    636   Char          getRefQP                    ( UInt   uiCurrAbsIdxInCtu                       );
     636                                                Bool  bEnforceTileRestriction=true ) const;
     637
     638  const TComDataCU*   getPUAboveLeft          ( UInt&  uiALPartUnitIdx, UInt uiCurrPartUnitIdx, Bool bEnforceSliceRestriction=true ) const;
     639
     640  const TComDataCU*   getQpMinCuLeft          ( UInt&  uiLPartUnitIdx,  UInt uiCurrAbsIdxInCtu ) const;
     641  const TComDataCU*   getQpMinCuAbove         ( UInt&  uiAPartUnitIdx,  UInt uiCurrAbsIdxInCtu ) const;
    637642
    638643  /// returns CU and part index of the PU above the top row of the current uiCurrPartUnitIdx of the CU, at a horizontal offset (to the right) of uiPartUnitOffset (in parts)
    639   TComDataCU*   getPUAboveRight             ( UInt&  uiARPartUnitIdx, UInt uiCurrPartUnitIdx, UInt uiPartUnitOffset = 1, Bool bEnforceSliceRestriction=true );
     644  const TComDataCU*   getPUAboveRight         ( UInt&  uiARPartUnitIdx, UInt uiCurrPartUnitIdx, UInt uiPartUnitOffset = 1, Bool bEnforceSliceRestriction=true ) const;
    640645  /// returns CU and part index of the PU left of the lefthand column of the current uiCurrPartUnitIdx of the CU, at a vertical offset (below) of uiPartUnitOffset (in parts)
    641   TComDataCU*   getPUBelowLeft              ( UInt&  uiBLPartUnitIdx, UInt uiCurrPartUnitIdx, UInt uiPartUnitOffset = 1, Bool bEnforceSliceRestriction=true );
    642 
    643   Void          deriveLeftRightTopIdx       ( UInt uiPartIdx, UInt& ruiPartIdxLT, UInt& ruiPartIdxRT );
    644   Void          deriveLeftBottomIdx         ( UInt uiPartIdx, UInt& ruiPartIdxLB );
    645 
    646   Bool          hasEqualMotion              ( UInt uiAbsPartIdx, TComDataCU* pcCandCU, UInt uiCandAbsPartIdx );
     646  const TComDataCU*   getPUBelowLeft          ( UInt&  uiBLPartUnitIdx, UInt uiCurrPartUnitIdx, UInt uiPartUnitOffset = 1, Bool bEnforceSliceRestriction=true ) const;
     647
     648  SChar         getRefQP                      ( UInt uiCurrAbsIdxInCtu ) const;
     649
     650  Void          deriveLeftRightTopIdx         ( UInt uiPartIdx, UInt& ruiPartIdxLT, UInt& ruiPartIdxRT ) const;
     651  Void          deriveLeftBottomIdx           ( UInt uiPartIdx, UInt& ruiPartIdxLB ) const;
     652
    647653#if NH_3D
    648654  Bool          hasEqualMotion              ( Int dirA, const TComMvField* mvFieldA,  Int dirB, const TComMvField* mvFieldB  );
    649655#endif
     656  Bool          hasEqualMotion                ( UInt uiAbsPartIdx, const TComDataCU* pcCandCU, UInt uiCandAbsPartIdx ) const;
     657
    650658#if NH_3D_MLC
    651659  Bool          getAvailableFlagA1() { return m_bAvailableFlagA1;   }
    … …  
    670678  , Int& numValidMergeCand, Int mrgCandIdx = -1 );
    671679#endif
     680#if NH_3D
    672681  Void          getInterMergeCandidates       ( UInt uiAbsPartIdx, UInt uiPUIdx, TComMvField* pcMFieldNeighbours, UChar* puhInterDirNeighbours, Int& numValidMergeCand, Int mrgCandIdx = -1 );
     682#else
     683  Void          getInterMergeCandidates       ( UInt uiAbsPartIdx, UInt uiPUIdx, TComMvField* pcMFieldNeighbours, UChar* puhInterDirNeighbours, Int& numValidMergeCand, Int mrgCandIdx = -1 ) const;
     684#endif
    673685
    674686#if NH_3D_VSP
    675687#if NH_3D_SPIVMP
    676   Bool*         getSPIVMPFlag        ()                        { return m_pbSPIVMPFlag;          }
    677   Bool          getSPIVMPFlag        ( UInt uiIdx )            { return m_pbSPIVMPFlag[uiIdx];   }
     688  Bool*         getSPIVMPFlag        ()                        const { return m_pbSPIVMPFlag;          }
     689  Bool          getSPIVMPFlag        ( UInt uiIdx )            const { return m_pbSPIVMPFlag[uiIdx];   }
    678690  Void          setSPIVMPFlag        ( UInt uiIdx, Bool n )     { m_pbSPIVMPFlag[uiIdx] = n;      }
    679691  Void          setSPIVMPFlagSubParts( Bool bSPIVMPFlag, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth );
    680692#endif
    681693
    682   Char*         getVSPFlag        ()                        { return m_piVSPFlag;          }
    683   Char          getVSPFlag        ( UInt uiIdx )            { return m_piVSPFlag[uiIdx];   }
     694  SChar*        getVSPFlag        ()                        const { return m_piVSPFlag;          }
     695  SChar         getVSPFlag        ( UInt uiIdx )            const { return m_piVSPFlag[uiIdx];   }
    684696  Void          setVSPFlag        ( UInt uiIdx, Int n )     { m_piVSPFlag[uiIdx] = n;      }
    685   Void          setVSPFlagSubParts( Char iVSPFlag, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth );
     697  Void          setVSPFlagSubParts( SChar iVSPFlag, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth );
    686698  Void          setMvFieldPUForVSP    ( TComDataCU* cu, UInt partAddr, Int width, Int height, RefPicList refPicList, Int refIdx, Int &vspSize );
    687699#endif
    688   Void          deriveLeftRightTopIdxGeneral  ( UInt uiAbsPartIdx, UInt uiPartIdx, UInt& ruiPartIdxLT, UInt& ruiPartIdxRT );
    689   Void          deriveLeftBottomIdxGeneral    ( UInt uiAbsPartIdx, UInt uiPartIdx, UInt& ruiPartIdxLB );
    690 
     700  Void          deriveLeftRightTopIdxGeneral  ( UInt uiAbsPartIdx, UInt uiPartIdx, UInt& ruiPartIdxLT, UInt& ruiPartIdxRT ) const;
     701  Void          deriveLeftBottomIdxGeneral    ( UInt uiAbsPartIdx, UInt uiPartIdx, UInt& ruiPartIdxLB ) const;
    691702  // -------------------------------------------------------------------------------------------------------------------
    692703  // member functions for modes
    … …  
    695706  Bool          isIntra            ( UInt uiPartIdx )  const { return m_pePredMode[ uiPartIdx ] == MODE_INTRA;                                              }
    696707  Bool          isInter            ( UInt uiPartIdx )  const { return m_pePredMode[ uiPartIdx ] == MODE_INTER;                                              }
    697   Bool          isSkipped          ( UInt uiPartIdx );                                                    ///< returns true, if the partiton is skipped
    698   Bool          isBipredRestriction( UInt puIdx );
     708  Bool          isSkipped                     ( UInt uiPartIdx ) const; ///< returns true, if the partiton is skipped
     709  Bool          isBipredRestriction           ( UInt puIdx     ) const;
    699710
    700711  // -------------------------------------------------------------------------------------------------------------------
    … …  
    702713  // -------------------------------------------------------------------------------------------------------------------
    703714
    704   UInt          getIntraSizeIdx                 ( UInt uiAbsPartIdx                                       );
    705 
    706   Void          getAllowedChromaDir             ( UInt uiAbsPartIdx, UInt* uiModeList );
    707   Void          getIntraDirPredictor            ( UInt uiAbsPartIdx, Int uiIntraDirPred[NUM_MOST_PROBABLE_MODES], const ComponentID compID, Int* piMode = NULL );
     715  UInt          getIntraSizeIdx               ( UInt uiAbsPartIdx ) const;
     716
     717  Void          getAllowedChromaDir           ( UInt uiAbsPartIdx, UInt* uiModeList ) const;
     718  Void          getIntraDirPredictor          ( UInt uiAbsPartIdx, Int uiIntraDirPred[NUM_MOST_PROBABLE_MODES], const ComponentID compID, Int* piMode = NULL ) const;
    708719
    709720  // -------------------------------------------------------------------------------------------------------------------
    … …  
    711722  // -------------------------------------------------------------------------------------------------------------------
    712723
    713   UInt          getCtxSplitFlag                 ( UInt   uiAbsPartIdx, UInt uiDepth                   );
    714   UInt          getCtxQtCbf                     ( TComTU &rTu, const ChannelType chType );
    715 
    716   UInt          getCtxSkipFlag                  ( UInt   uiAbsPartIdx                                 );
    717   UInt          getCtxInterDir                  ( UInt   uiAbsPartIdx                                 );
     724  UInt          getCtxSplitFlag               ( UInt   uiAbsPartIdx, UInt uiDepth     ) const;
     725  UInt          getCtxQtCbf                   ( TComTU &rTu, const ChannelType chType ) const;
     726
     727  UInt          getCtxSkipFlag                ( UInt   uiAbsPartIdx ) const;
     728  UInt          getCtxInterDir                ( UInt   uiAbsPartIdx ) const;
    718729#if NH_3D_ARP
    719730  UInt          getCTXARPWFlag                  ( UInt   uiAbsPartIdx                                 );

  • branches/HTM-15.2-dev/source/Lib/TLibCommon/TComLoopFilter.cpp

    r1313 r1360  
    365365  UInt uiY           = pcCU->getCUPelY() + g_auiRasterToPelY[ g_auiZscanToRaster[ uiAbsZorderIdx ] ];
    366366
    367   TComDataCU* pcTempCU;
    368367  UInt        uiTempPartIdx;
    369368
    … …  
    380379  if ( m_stLFCUParam.bLeftEdge )
    381380  {
    382     pcTempCU = pcCU->getPULeft( uiTempPartIdx, uiAbsZorderIdx, !pcCU->getSlice()->getLFCrossSliceBoundaryFlag(), !m_bLFCrossTileBoundary);
     381    const TComDataCU* pcTempCU = pcCU->getPULeft( uiTempPartIdx, uiAbsZorderIdx, !pcCU->getSlice()->getLFCrossSliceBoundaryFlag(), !m_bLFCrossTileBoundary);
    383382
    384383    if ( pcTempCU != NULL )
    … …  
    402401  if ( m_stLFCUParam.bTopEdge )
    403402  {
    404     pcTempCU = pcCU->getPUAbove( uiTempPartIdx, uiAbsZorderIdx, !pcCU->getSlice()->getLFCrossSliceBoundaryFlag(), false, !m_bLFCrossTileBoundary);
     403    const TComDataCU* pcTempCU = pcCU->getPUAbove( uiTempPartIdx, uiAbsZorderIdx, !pcCU->getSlice()->getLFCrossSliceBoundaryFlag(), false, !m_bLFCrossTileBoundary);
    405404
    406405    if ( pcTempCU != NULL )
    … …  
    425424
    426425  UInt uiPartP;
    427   TComDataCU* pcCUP;
     426  const TComDataCU* pcCUP;
    428427  UInt uiBs = 0;
    429428
    … …  
    459458      {
    460459        Int iRefIdx;
    461         TComPic *piRefP0, *piRefP1, *piRefQ0, *piRefQ1;
    462460        iRefIdx = pcCUP->getCUMvField(REF_PIC_LIST_0)->getRefIdx(uiPartP);
    463         piRefP0 = (iRefIdx < 0) ? NULL : pcCUP->getSlice()->getRefPic(REF_PIC_LIST_0, iRefIdx);
     461        const TComPic *piRefP0 = (iRefIdx < 0) ? NULL : pcCUP->getSlice()->getRefPic(REF_PIC_LIST_0, iRefIdx);
    464462        iRefIdx = pcCUP->getCUMvField(REF_PIC_LIST_1)->getRefIdx(uiPartP);
    465         piRefP1 = (iRefIdx < 0) ? NULL : pcCUP->getSlice()->getRefPic(REF_PIC_LIST_1, iRefIdx);
     463        const TComPic *piRefP1 = (iRefIdx < 0) ? NULL : pcCUP->getSlice()->getRefPic(REF_PIC_LIST_1, iRefIdx);
    466464        iRefIdx = pcCUQ->getCUMvField(REF_PIC_LIST_0)->getRefIdx(uiPartQ);
    467         piRefQ0 = (iRefIdx < 0) ? NULL : pcSlice->getRefPic(REF_PIC_LIST_0, iRefIdx);
     465        const TComPic *piRefQ0 = (iRefIdx < 0) ? NULL : pcSlice->getRefPic(REF_PIC_LIST_0, iRefIdx);
    468466        iRefIdx = pcCUQ->getCUMvField(REF_PIC_LIST_1)->getRefIdx(uiPartQ);
    469         piRefQ1 = (iRefIdx < 0) ? NULL : pcSlice->getRefPic(REF_PIC_LIST_1, iRefIdx);
     467        const TComPic *piRefQ1 = (iRefIdx < 0) ? NULL : pcSlice->getRefPic(REF_PIC_LIST_1, iRefIdx);
    470468
    471469        TComMv pcMvP0 = pcCUP->getCUMvField(REF_PIC_LIST_0)->getMv(uiPartP);
    … …  
    530528      {
    531529        Int iRefIdx;
    532         TComPic *piRefP0, *piRefQ0;
    533530        iRefIdx = pcCUP->getCUMvField(REF_PIC_LIST_0)->getRefIdx(uiPartP);
    534         piRefP0 = (iRefIdx < 0) ? NULL : pcCUP->getSlice()->getRefPic(REF_PIC_LIST_0, iRefIdx);
     531        const TComPic *piRefP0 = (iRefIdx < 0) ? NULL : pcCUP->getSlice()->getRefPic(REF_PIC_LIST_0, iRefIdx);
    535532        iRefIdx = pcCUQ->getCUMvField(REF_PIC_LIST_0)->getRefIdx(uiPartQ);
    536         piRefQ0 = (iRefIdx < 0) ? NULL : pcSlice->getRefPic(REF_PIC_LIST_0, iRefIdx);
     533        const TComPic *piRefQ0 = (iRefIdx < 0) ? NULL : pcSlice->getRefPic(REF_PIC_LIST_0, iRefIdx);
    537534        TComMv pcMvP0 = pcCUP->getCUMvField(REF_PIC_LIST_0)->getMv(uiPartP);
    538535        TComMv pcMvQ0 = pcCUQ->getCUMvField(REF_PIC_LIST_0)->getMv(uiPartQ);
    … …  
    583580  UInt  uiPartPIdx = 0;
    584581  UInt  uiPartQIdx = 0;
    585   TComDataCU* pcCUP = pcCU;
     582  const TComDataCU* pcCUP = pcCU;
    586583  TComDataCU* pcCUQ = pcCU;
    587584  Int  betaOffsetDiv2 = pcCUQ->getSlice()->getDeblockingFilterBetaOffsetDiv2();
    … …  
    758755      UInt  uiPartQIdx = uiBsAbsIdx;
    759756      // Derive neighboring PU index
    760       TComDataCU* pcCUP;
     757      const TComDataCU* pcCUP;
    761758      UInt  uiPartPIdx;
    762759

  • branches/HTM-15.2-dev/source/Lib/TLibCommon/TComMotionInfo.cpp

    r1321 r1360  
    6666  m_pcMv     = new TComMv[ uiNumPartition ];
    6767  m_pcMvd    = new TComMv[ uiNumPartition ];
    68   m_piRefIdx = new Char [ uiNumPartition ];
     68  m_piRefIdx = new SChar [ uiNumPartition ];
    6969
    7070  m_uiNumPartition = uiNumPartition;
    … …  
    321321Void TComCUMvField::setAllRefIdx ( Int iRefIdx, PartSize eCUMode, Int iPartAddr, UInt uiDepth, Int iPartIdx )
    322322{
    323   setAll(m_piRefIdx, static_cast<Char>(iRefIdx), eCUMode, iPartAddr, uiDepth, iPartIdx);
     323  setAll(m_piRefIdx, static_cast<SChar>(iRefIdx), eCUMode, iPartAddr, uiDepth, iPartIdx);
    324324}
    325325
    … …  
    358358 * \param scale      Factor by which to subsample motion information
    359359 */
    360 Void TComCUMvField::compress(Char* pePredMode, Int scale)
     360Void TComCUMvField::compress(SChar* pePredMode, Int scale)
    361361{
    362362  Int N = scale * scale;
    … …  
    381381
    382382#if NH_MV
    383 Void TComCUMvField::print(Char* pePredMode)
     383Void TComCUMvField::print(SChar* pePredMode)
    384384{
    385385  for ( Int uiPartIdx = 0; uiPartIdx < m_uiNumPartition; uiPartIdx += 1 )

  • branches/HTM-15.2-dev/source/Lib/TLibCommon/TComMotionInfo.h

    r1321 r1360  
    5757typedef struct _AMVPInfo
    5858{
    59   TComMv m_acMvCand[ AMVP_MAX_NUM_CANDS_MEM ];  ///< array of motion vector predictor candidates
     59  TComMv m_acMvCand[ AMVP_MAX_NUM_CANDS ];  ///< array of motion vector predictor candidates
    6060  Int    iN;                                ///< number of motion vector predictor candidates
    6161} AMVPInfo;
    … …  
    122122  TComMv*   m_pcMv;
    123123  TComMv*   m_pcMvd;
    124   Char*     m_piRefIdx;
     124  SChar*    m_piRefIdx;
    125125  UInt      m_uiNumPartition;
    126126  AMVPInfo  m_cAMVPInfo;
    … …  
    188188  }
    189189 
    190   Void compress(Char* pePredMode, Int scale);
     190  Void compress(SChar* pePredMode, Int scale);
    191191#if NH_MV
    192   Void print   (Char* pePredMode);
     192  Void print   (SChar* pePredMode);
    193193#endif
    194194};

  • branches/HTM-15.2-dev/source/Lib/TLibCommon/TComMv.h

    r1313 r1360  
    145145  }
    146146
     147#if NH_3D || !ME_ENABLE_ROUNDING_OF_MVS
    147148  const TComMv& operator>>= (const Int i)
    148149  {
    … …  
    151152    return  *this;
    152153  }
     154#endif
     155
     156#if ME_ENABLE_ROUNDING_OF_MVS
     157  //! shift right with rounding
     158  Void divideByPowerOf2 (const Int i)
     159  {
     160    Int offset = (i == 0) ? 0 : 1 << (i - 1);
     161    m_iHor += offset;
     162    m_iVer += offset;
     163
     164    m_iHor >>= i;
     165    m_iVer >>= i;
     166  }
     167#endif
    153168
    154169  const TComMv& operator<<= (const Int i)

  • branches/HTM-15.2-dev/source/Lib/TLibCommon/TComPattern.cpp

    r1313 r1360  
    6666
    6767/// constrained intra prediction
    68 Bool  isAboveLeftAvailable  ( TComDataCU* pcCU, UInt uiPartIdxLT );
    69 Int   isAboveAvailable      ( TComDataCU* pcCU, UInt uiPartIdxLT, UInt uiPartIdxRT, Bool* bValidFlags );
    70 Int   isLeftAvailable       ( TComDataCU* pcCU, UInt uiPartIdxLT, UInt uiPartIdxLB, Bool* bValidFlags );
    71 Int   isAboveRightAvailable ( TComDataCU* pcCU, UInt uiPartIdxLT, UInt uiPartIdxRT, Bool* bValidFlags );
    72 Int   isBelowLeftAvailable  ( TComDataCU* pcCU, UInt uiPartIdxLT, UInt uiPartIdxLB, Bool* bValidFlags );
     68Bool  isAboveLeftAvailable  ( const TComDataCU* pcCU, UInt uiPartIdxLT );
     69Int   isAboveAvailable      ( const TComDataCU* pcCU, UInt uiPartIdxLT, UInt uiPartIdxRT, Bool* bValidFlags );
     70Int   isLeftAvailable       ( const TComDataCU* pcCU, UInt uiPartIdxLT, UInt uiPartIdxLB, Bool* bValidFlags );
     71Int   isAboveRightAvailable ( const TComDataCU* pcCU, UInt uiPartIdxLT, UInt uiPartIdxRT, Bool* bValidFlags );
     72Int   isBelowLeftAvailable  ( const TComDataCU* pcCU, UInt uiPartIdxLT, UInt uiPartIdxLB, Bool* bValidFlags );
    7373
    7474
    … …  
    566566}
    567567
    568 Bool isAboveLeftAvailable( TComDataCU* pcCU, UInt uiPartIdxLT )
     568Bool isAboveLeftAvailable( const TComDataCU* pcCU, UInt uiPartIdxLT )
    569569{
    570570  Bool bAboveLeftFlag;
    571571  UInt uiPartAboveLeft;
    572   TComDataCU* pcCUAboveLeft = pcCU->getPUAboveLeft( uiPartAboveLeft, uiPartIdxLT );
     572  const TComDataCU* pcCUAboveLeft = pcCU->getPUAboveLeft( uiPartAboveLeft, uiPartIdxLT );
    573573  if(pcCU->getSlice()->getPPS()->getConstrainedIntraPred())
    574574  {
    … …  
    582582}
    583583
    584 Int isAboveAvailable( TComDataCU* pcCU, UInt uiPartIdxLT, UInt uiPartIdxRT, Bool *bValidFlags )
     584Int isAboveAvailable( const TComDataCU* pcCU, UInt uiPartIdxLT, UInt uiPartIdxRT, Bool *bValidFlags )
    585585{
    586586  const UInt uiRasterPartBegin = g_auiZscanToRaster[uiPartIdxLT];
    … …  
    593593  {
    594594    UInt uiPartAbove;
    595     TComDataCU* pcCUAbove = pcCU->getPUAbove( uiPartAbove, g_auiRasterToZscan[uiRasterPart] );
     595    const TComDataCU* pcCUAbove = pcCU->getPUAbove( uiPartAbove, g_auiRasterToZscan[uiRasterPart] );
    596596    if(pcCU->getSlice()->getPPS()->getConstrainedIntraPred())
    597597    {
    … …  
    623623}
    624624
    625 Int isLeftAvailable( TComDataCU* pcCU, UInt uiPartIdxLT, UInt uiPartIdxLB, Bool *bValidFlags )
     625Int isLeftAvailable( const TComDataCU* pcCU, UInt uiPartIdxLT, UInt uiPartIdxLB, Bool *bValidFlags )
    626626{
    627627  const UInt uiRasterPartBegin = g_auiZscanToRaster[uiPartIdxLT];
    … …  
    634634  {
    635635    UInt uiPartLeft;
    636     TComDataCU* pcCULeft = pcCU->getPULeft( uiPartLeft, g_auiRasterToZscan[uiRasterPart] );
     636    const TComDataCU* pcCULeft = pcCU->getPULeft( uiPartLeft, g_auiRasterToZscan[uiRasterPart] );
    637637    if(pcCU->getSlice()->getPPS()->getConstrainedIntraPred())
    638638    {
    … …  
    665665}
    666666
    667 Int isAboveRightAvailable( TComDataCU* pcCU, UInt uiPartIdxLT, UInt uiPartIdxRT, Bool *bValidFlags )
     667Int isAboveRightAvailable( const TComDataCU* pcCU, UInt uiPartIdxLT, UInt uiPartIdxRT, Bool *bValidFlags )
    668668{
    669669  const UInt uiNumUnitsInPU = g_auiZscanToRaster[uiPartIdxRT] - g_auiZscanToRaster[uiPartIdxLT] + 1;
    … …  
    674674  {
    675675    UInt uiPartAboveRight;
    676     TComDataCU* pcCUAboveRight = pcCU->getPUAboveRight( uiPartAboveRight, uiPartIdxRT, uiOffset );
     676    const TComDataCU* pcCUAboveRight = pcCU->getPUAboveRight( uiPartAboveRight, uiPartIdxRT, uiOffset );
    677677    if(pcCU->getSlice()->getPPS()->getConstrainedIntraPred())
    678678    {
    … …  
    705705}
    706706
    707 Int isBelowLeftAvailable( TComDataCU* pcCU, UInt uiPartIdxLT, UInt uiPartIdxLB, Bool *bValidFlags )
     707Int isBelowLeftAvailable( const TComDataCU* pcCU, UInt uiPartIdxLT, UInt uiPartIdxLB, Bool *bValidFlags )
    708708{
    709709  const UInt uiNumUnitsInPU = (g_auiZscanToRaster[uiPartIdxLB] - g_auiZscanToRaster[uiPartIdxLT]) / pcCU->getPic()->getNumPartInCtuWidth() + 1;
    … …  
    714714  {
    715715    UInt uiPartBelowLeft;
    716     TComDataCU* pcCUBelowLeft = pcCU->getPUBelowLeft( uiPartBelowLeft, uiPartIdxLB, uiOffset );
     716    const TComDataCU* pcCUBelowLeft = pcCU->getPUBelowLeft( uiPartBelowLeft, uiPartIdxLB, uiOffset );
    717717    if(pcCU->getSlice()->getPPS()->getConstrainedIntraPred())
    718718    {

  • branches/HTM-15.2-dev/source/Lib/TLibCommon/TComPattern.h

    r1313 r1360  
    6969    return  m_piROIOrigin;
    7070  }
     71  __inline const Pel*  getROIOrigin() const
     72  {
     73    return  m_piROIOrigin;
     74  }
    7175
    7276  /// set parameters from Pel buffer for accessing neighbouring pixels
    … …  
    9397  // ROI & pattern information, (ROI = &pattern[AboveOffset][LeftOffset])
    9498  Pel*  getROIY()                 { return m_cPatternY.getROIOrigin();    }
    95   Int   getROIYWidth()            { return m_cPatternY.m_iROIWidth;       }
    96   Int   getROIYHeight()           { return m_cPatternY.m_iROIHeight;      }
    97   Int   getPatternLStride()       { return m_cPatternY.m_iPatternStride;  }
    98   Int   getBitDepthY()            { return m_cPatternY.m_bitDepth; }
     99  const Pel*  getROIY() const     { return m_cPatternY.getROIOrigin();    }
     100  Int   getROIYWidth() const      { return m_cPatternY.m_iROIWidth;       }
     101  Int   getROIYHeight() const     { return m_cPatternY.m_iROIHeight;      }
     102  Int   getPatternLStride() const { return m_cPatternY.m_iPatternStride;  }
     103  Int   getBitDepthY() const      { return m_cPatternY.m_bitDepth;        }
    99104
    100105#if NH_3D_IC
    101   Bool  getICFlag()               { return m_bICFlag; }
     106  Bool  getICFlag()               const { return m_bICFlag; }
    102107  Void  setICFlag( Bool bICFlag ) { m_bICFlag = bICFlag; }
    103108#endif
    104109#if NH_3D_SDC_INTER
    105   Bool  getSDCMRSADFlag()         { return m_bSDCMRSADFlag; }
     110  Bool  getSDCMRSADFlag()         const { return m_bSDCMRSADFlag; }
    106111  Void  setSDCMRSADFlag( Bool bSDCMRSADFlag )    { m_bSDCMRSADFlag = bSDCMRSADFlag; }
    107112#endif

  • branches/HTM-15.2-dev/source/Lib/TLibCommon/TComPic.h

    r1321 r1360  
    189189
    190190  TComPicSym*   getPicSym()           { return  &m_picSym;    }
     191  const TComPicSym* getPicSym() const { return  &m_picSym;    }
    191192  TComSlice*    getSlice(Int i)       { return  m_picSym.getSlice(i);  }
    192193  Int           getPOC() const        { return  m_picSym.getSlice(m_uiCurrSliceIdx)->getPOC();  }
    … …  
    247248#if NH_MV
    248249   Void          setLayerId            ( Int layerId )    { m_layerId      = layerId; }
    249    Int           getLayerId            ()                 { return m_layerId;    }
     250   Int           getLayerId            () const           { return m_layerId;    }
    250251   
    251252   Void          setViewId             ( Int viewId )     { m_viewId = viewId;   }
    252    Int           getViewId             ()                 { return m_viewId;     }
     253   Int           getViewId             () const           { return m_viewId;     }
    253254
    254255   Void          setPicOutputFlag(Bool b)                 { m_bPicOutputFlag = b;      }
    255    Bool          getPicOutputFlag()                       { return m_bPicOutputFlag ;  }
     256   Bool          getPicOutputFlag() const                 { return m_bPicOutputFlag ;  }
    256257
    257258   Bool          getPocResetPeriodId();
    … …  
    312313#if NH_3D
    313314   Void          setViewIndex          ( Int viewIndex )  { m_viewIndex = viewIndex;   }
    314    Int           getViewIndex          ()                 { return m_viewIndex;     }
     315   Int           getViewIndex          () const           { return m_viewIndex;     }
    315316
    316317   Void          setIsDepth            ( Bool isDepth )   { m_isDepth = isDepth; }

  • branches/HTM-15.2-dev/source/Lib/TLibCommon/TComPicSym.cpp

    r1313 r1360  
    140140  clearSliceBuffer();
    141141
     142  if (m_pictureCtuArray)
     143  {
    142144  for (Int i = 0; i < m_numCtusInFrame; i++)
    143145  {
     146      if (m_pictureCtuArray[i])
     147      {
    144148    m_pictureCtuArray[i]->destroy();
    145149    delete m_pictureCtuArray[i];
    146150    m_pictureCtuArray[i] = NULL;
    147151  }
     152    }
    148153  delete [] m_pictureCtuArray;
    149154  m_pictureCtuArray = NULL;
     155  }
    150156
    151157  delete [] m_ctuTsToRsAddrMap;

  • branches/HTM-15.2-dev/source/Lib/TLibCommon/TComPicYuv.cpp

    r1313 r1360  
    7979
    8080
    81 Void TComPicYuv::create ( const Int iPicWidth,                ///< picture width
    82                           const Int iPicHeight,               ///< picture height
     81Void TComPicYuv::createWithoutCUInfo ( const Int picWidth,                 ///< picture width
     82                                       const Int picHeight,                ///< picture height
     83                                       const ChromaFormat chromaFormatIDC, ///< chroma format
     84                                       const Bool bUseMargin,              ///< if true, then a margin of uiMaxCUWidth+16 and uiMaxCUHeight+16 is created around the image.
     85                                       const UInt maxCUWidth,              ///< used for margin only
     86                                       const UInt maxCUHeight)             ///< used for margin only
     87
     88{
     89  m_picWidth          = picWidth;
     90  m_picHeight         = picHeight;
     91
     92#if NH_3D_IV_MERGE
     93// Check if m_iBaseUnitWidth and m_iBaseUnitHeight need to be derived here
     94#endif
     95
     96  m_chromaFormatIDC   = chromaFormatIDC;
     97  m_marginX          = (bUseMargin?maxCUWidth:0) + 16;   // for 16-byte alignment
     98  m_marginY          = (bUseMargin?maxCUHeight:0) + 16;  // margin for 8-tap filter and infinite padding
     99  m_bIsBorderExtended = false;
     100
     101  // assign the picture arrays and set up the ptr to the top left of the original picture
     102  for(UInt comp=0; comp<getNumberValidComponents(); comp++)
     103  {
     104    const ComponentID ch=ComponentID(comp);
     105    m_apiPicBuf[comp] = (Pel*)xMalloc( Pel, getStride(ch) * getTotalHeight(ch));
     106    m_piPicOrg[comp]  = m_apiPicBuf[comp] + (m_marginY >> getComponentScaleY(ch)) * getStride(ch) + (m_marginX >> getComponentScaleX(ch));
     107  }
     108  // initialize pointers for unused components to NULL
     109  for(UInt comp=getNumberValidComponents();comp<MAX_NUM_COMPONENT; comp++)
     110    {
     111    }
     112
     113  for(Int chan=0; chan<MAX_NUM_CHANNEL_TYPE; chan++)
     114    {
     115    m_ctuOffsetInBuffer[chan]   = NULL;
     116    m_subCuOffsetInBuffer[chan] = NULL;
     117    }
     118  }
     119
     120
     121
     122Void TComPicYuv::create ( const Int picWidth,                 ///< picture width
     123                          const Int picHeight,                ///< picture height
    83124                          const ChromaFormat chromaFormatIDC, ///< chroma format
    84                           const UInt uiMaxCUWidth,            ///< used for generating offsets to CUs. Can use iPicWidth if no offsets are required
    85                           const UInt uiMaxCUHeight,           ///< used for generating offsets to CUs. Can use iPicHeight if no offsets are required
    86                           const UInt uiMaxCUDepth,            ///< used for generating offsets to CUs. Can use 0 if no offsets are required
     125                          const UInt maxCUWidth,              ///< used for generating offsets to CUs.
     126                          const UInt maxCUHeight,             ///< used for generating offsets to CUs.
     127                          const UInt maxCUDepth,              ///< used for generating offsets to CUs.
    87128                          const Bool bUseMargin)              ///< if true, then a margin of uiMaxCUWidth+16 and uiMaxCUHeight+16 is created around the image.
    88129
    89130{
    90   m_iPicWidth         = iPicWidth;
    91   m_iPicHeight        = iPicHeight;
     131  createWithoutCUInfo(picWidth, picHeight, chromaFormatIDC, bUseMargin, maxCUWidth, maxCUHeight);
    92132
    93133#if NH_3D_IV_MERGE
    94   m_iCuWidth        = uiMaxCUWidth;
    95   m_iCuHeight       = uiMaxCUHeight;
    96 
    97   m_iNumCuInWidth   = m_iPicWidth / m_iCuWidth;
    98   m_iNumCuInWidth  += ( m_iPicWidth % m_iCuWidth ) ? 1 : 0;
    99 
    100   m_iBaseUnitWidth  = uiMaxCUWidth  >> uiMaxCUDepth;
    101   m_iBaseUnitHeight = uiMaxCUHeight >> uiMaxCUDepth;
    102 #endif
    103 
    104   m_chromaFormatIDC   = chromaFormatIDC;
    105   m_iMarginX          = (bUseMargin?uiMaxCUWidth:0) + 16;   // for 16-byte alignment
    106   m_iMarginY          = (bUseMargin?uiMaxCUHeight:0) + 16;  // margin for 8-tap filter and infinite padding
    107   m_bIsBorderExtended = false;
    108 
    109   // assign the picture arrays and set up the ptr to the top left of the original picture
    110   {
    111     Int chan=0;
    112     for(; chan<getNumberValidComponents(); chan++)
    113     {
    114       const ComponentID ch=ComponentID(chan);
    115       m_apiPicBuf[chan] = (Pel*)xMalloc( Pel, getStride(ch)       * getTotalHeight(ch));
    116       m_piPicOrg[chan]  = m_apiPicBuf[chan] + (m_iMarginY >> getComponentScaleY(ch))   * getStride(ch)       + (m_iMarginX >> getComponentScaleX(ch));
    117     }
    118     for(;chan<MAX_NUM_COMPONENT; chan++)
    119     {
    120       m_apiPicBuf[chan] = NULL;
    121       m_piPicOrg[chan]  = NULL;
    122     }
    123   }
    124 
    125 
    126   const Int numCuInWidth  = m_iPicWidth  / uiMaxCUWidth  + (m_iPicWidth  % uiMaxCUWidth  != 0);
    127   const Int numCuInHeight = m_iPicHeight / uiMaxCUHeight + (m_iPicHeight % uiMaxCUHeight != 0);
    128   for(Int chan=0; chan<2; chan++)
    129   {
    130     const ComponentID ch=ComponentID(chan);
    131     const Int ctuHeight=uiMaxCUHeight>>getComponentScaleY(ch);
    132     const Int ctuWidth=uiMaxCUWidth>>getComponentScaleX(ch);
     134  m_iBaseUnitWidth  = maxCUWidth  >> maxCUDepth;
     135  m_iBaseUnitHeight = maxCUHeight >> maxCUDepth;
     136#endif
     137
     138
     139  const Int numCuInWidth  = m_picWidth  / maxCUWidth  + (m_picWidth  % maxCUWidth  != 0);
     140  const Int numCuInHeight = m_picHeight / maxCUHeight + (m_picHeight % maxCUHeight != 0);
     141  for(Int chan=0; chan<MAX_NUM_CHANNEL_TYPE; chan++)
     142  {
     143    const ChannelType ch= ChannelType(chan);
     144    const Int ctuHeight = maxCUHeight>>getChannelTypeScaleY(ch);
     145    const Int ctuWidth  = maxCUWidth>>getChannelTypeScaleX(ch);
    133146    const Int stride = getStride(ch);
    134147
    … …  
    143156    }
    144157
    145     m_subCuOffsetInBuffer[chan] = new Int[(size_t)1 << (2 * uiMaxCUDepth)];
    146 
    147     const Int numSubBlockPartitions=(1<<uiMaxCUDepth);
    148     const Int minSubBlockHeight    =(ctuHeight >> uiMaxCUDepth);
    149     const Int minSubBlockWidth     =(ctuWidth  >> uiMaxCUDepth);
     158    m_subCuOffsetInBuffer[chan] = new Int[(size_t)1 << (2 * maxCUDepth)];
     159
     160    const Int numSubBlockPartitions=(1<<maxCUDepth);
     161    const Int minSubBlockHeight    =(ctuHeight >> maxCUDepth);
     162    const Int minSubBlockWidth     =(ctuWidth  >> maxCUDepth);
    150163
    151164    for (Int buRow = 0; buRow < numSubBlockPartitions; buRow++)
    … …  
    153166      for (Int buCol = 0; buCol < numSubBlockPartitions; buCol++)
    154167      {
    155         m_subCuOffsetInBuffer[chan][(buRow << uiMaxCUDepth) + buCol] = stride  * buRow * minSubBlockHeight + buCol * minSubBlockWidth;
    156       }
    157     }
    158   }
    159   return;
     168        m_subCuOffsetInBuffer[chan][(buRow << maxCUDepth) + buCol] = stride  * buRow * minSubBlockHeight + buCol * minSubBlockWidth;
     169      }
     170    }
     171  }
    160172}
    161173
    … …  
    164176Void TComPicYuv::destroy()
    165177{
    166   for(Int chan=0; chan<MAX_NUM_COMPONENT; chan++)
    167   {
    168     m_piPicOrg[chan] = NULL;
    169 
    170     if( m_apiPicBuf[chan] )
    171     {
    172       xFree( m_apiPicBuf[chan] );
    173       m_apiPicBuf[chan] = NULL;
     178  for(Int comp=0; comp<MAX_NUM_COMPONENT; comp++)
     179  {
     180    m_piPicOrg[comp] = NULL;
     181
     182    if( m_apiPicBuf[comp] )
     183    {
     184      xFree( m_apiPicBuf[comp] );
     185      m_apiPicBuf[comp] = NULL;
    174186    }
    175187  }
    … …  
    194206Void  TComPicYuv::copyToPic (TComPicYuv*  pcPicYuvDst) const
    195207{
    196   assert( m_iPicWidth  == pcPicYuvDst->getWidth(COMPONENT_Y)  );
    197   assert( m_iPicHeight == pcPicYuvDst->getHeight(COMPONENT_Y) );
    198208  assert( m_chromaFormatIDC == pcPicYuvDst->getChromaFormat() );
    199209
    200   for(Int chan=0; chan<getNumberValidComponents(); chan++)
    201   {
    202     const ComponentID ch=ComponentID(chan);
    203     ::memcpy ( pcPicYuvDst->getBuf(ch), m_apiPicBuf[ch], sizeof (Pel) * getStride(ch) * getTotalHeight(ch));
    204   }
    205   return;
     210  for(Int comp=0; comp<getNumberValidComponents(); comp++)
     211  {
     212    const ComponentID compId=ComponentID(comp);
     213    const Int width     = getWidth(compId);
     214    const Int height    = getHeight(compId);
     215    const Int strideSrc = getStride(compId);
     216    assert(pcPicYuvDst->getWidth(compId) == width);
     217    assert(pcPicYuvDst->getHeight(compId) == height);
     218    if (strideSrc==pcPicYuvDst->getStride(compId))
     219  {
     220      ::memcpy ( pcPicYuvDst->getBuf(compId), getBuf(compId), sizeof(Pel)*strideSrc*getTotalHeight(compId));
     221    }
     222    else
     223    {
     224      const Pel *pSrc       = getAddr(compId);
     225            Pel *pDest      = pcPicYuvDst->getAddr(compId);
     226      const UInt strideDest = pcPicYuvDst->getStride(compId);
     227
     228      for(Int y=0; y<height; y++, pSrc+=strideSrc, pDest+=strideDest)
     229      {
     230        ::memcpy(pDest, pSrc, width*sizeof(Pel));
     231      }
     232    }
     233  }
    206234}
    207235
    … …  
    214242  }
    215243
    216   for(Int chan=0; chan<getNumberValidComponents(); chan++)
    217   {
    218     const ComponentID ch=ComponentID(chan);
    219     Pel *piTxt=getAddr(ch); // piTxt = point to (0,0) of image within bigger picture.
    220     const Int iStride=getStride(ch);
    221     const Int iWidth=getWidth(ch);
    222     const Int iHeight=getHeight(ch);
    223     const Int iMarginX=getMarginX(ch);
    224     const Int iMarginY=getMarginY(ch);
     244  for(Int comp=0; comp<getNumberValidComponents(); comp++)
     245  {
     246    const ComponentID compId=ComponentID(comp);
     247    Pel *piTxt=getAddr(compId); // piTxt = point to (0,0) of image within bigger picture.
     248    const Int stride=getStride(compId);
     249    const Int width=getWidth(compId);
     250    const Int height=getHeight(compId);
     251    const Int marginX=getMarginX(compId);
     252    const Int marginY=getMarginY(compId);
    225253
    226254    Pel*  pi = piTxt;
    227255    // do left and right margins
    228     for (Int y = 0; y < iHeight; y++)
    229     {
    230       for (Int x = 0; x < iMarginX; x++ )
    231       {
    232         pi[ -iMarginX + x ] = pi[0];
    233         pi[    iWidth + x ] = pi[iWidth-1];
    234       }
    235       pi += iStride;
     256    for (Int y = 0; y < height; y++)
     257    {
     258      for (Int x = 0; x < marginX; x++ )
     259      {
     260        pi[ -marginX + x ] = pi[0];
     261        pi[    width + x ] = pi[width-1];
     262      }
     263      pi += stride;
    236264    }
    237265
    238266    // pi is now the (0,height) (bottom left of image within bigger picture
    239     pi -= (iStride + iMarginX);
     267    pi -= (stride + marginX);
    240268    // pi is now the (-marginX, height-1)
    241     for (Int y = 0; y < iMarginY; y++ )
    242     {
    243       ::memcpy( pi + (y+1)*iStride, pi, sizeof(Pel)*(iWidth + (iMarginX<<1)) );
     269    for (Int y = 0; y < marginY; y++ )
     270    {
     271      ::memcpy( pi + (y+1)*stride, pi, sizeof(Pel)*(width + (marginX<<1)) );
    244272    }
    245273
    246274    // pi is still (-marginX, height-1)
    247     pi -= ((iHeight-1) * iStride);
     275    pi -= ((height-1) * stride);
    248276    // pi is now (-marginX, 0)
    249     for (Int y = 0; y < iMarginY; y++ )
    250     {
    251       ::memcpy( pi - (y+1)*iStride, pi, sizeof(Pel)*(iWidth + (iMarginX<<1)) );
     277    for (Int y = 0; y < marginY; y++ )
     278    {
     279      ::memcpy( pi - (y+1)*stride, pi, sizeof(Pel)*(width + (marginX<<1)) );
    252280    }
    253281  }
    … …  
    259287
    260288// NOTE: This function is never called, but may be useful for developers.
    261 Void TComPicYuv::dump (const Char* pFileName, const BitDepths &bitDepths, Bool bAdd) const
    262 {
    263   FILE* pFile;
    264   if (!bAdd)
    265   {
    266     pFile = fopen (pFileName, "wb");
    267   }
    268   else
    269   {
    270     pFile = fopen (pFileName, "ab");
    271   }
    272 
    273 
    274   for(Int chan = 0; chan < getNumberValidComponents(); chan++)
    275   {
    276     const ComponentID  ch     = ComponentID(chan);
    277     const Int          shift  = bitDepths.recon[toChannelType(ch)] - 8;
    278     const Int          offset = (shift>0)?(1<<(shift-1)):0;
    279     const Pel         *pi     = getAddr(ch);
    280     const Int          stride = getStride(ch);
    281     const Int          height = getHeight(ch);
    282     const Int          width  = getWidth(ch);
    283 
     289Void TComPicYuv::dump (const std::string &fileName, const BitDepths &bitDepths, const Bool bAppend, const Bool bForceTo8Bit) const
     290{
     291  FILE *pFile = fopen (fileName.c_str(), bAppend?"ab":"wb");
     292
     293  Bool is16bit=false;
     294  for(Int comp = 0; comp < getNumberValidComponents() && !bForceTo8Bit; comp++)
     295  {
     296    if (bitDepths.recon[toChannelType(ComponentID(comp))]>8)
     297  {
     298      is16bit=true;
     299    }
     300  }
     301
     302  for(Int comp = 0; comp < getNumberValidComponents(); comp++)
     303  {
     304    const ComponentID  compId = ComponentID(comp);
     305    const Pel         *pi     = getAddr(compId);
     306    const Int          stride = getStride(compId);
     307    const Int          height = getHeight(compId);
     308    const Int          width  = getWidth(compId);
     309
     310    if (is16bit)
     311    {
    284312    for (Int y = 0; y < height; y++ )
    285313    {
    286314      for (Int x = 0; x < width; x++ )
    287315      {
    288         UChar uc = (UChar)Clip3<Pel>(0, 255, (pi[x]+offset)>>shift);
     316          UChar uc = (UChar)((pi[x]>>0) & 0xff);
    289317        fwrite( &uc, sizeof(UChar), 1, pFile );
     318          uc = (UChar)((pi[x]>>8) & 0xff);
     319          fwrite( &uc, sizeof(UChar), 1, pFile );
    290320      }
    291321      pi += stride;
     322    }
     323  }
     324    else
     325    {
     326      const Int shift  = bitDepths.recon[toChannelType(compId)] - 8;
     327      const Int offset = (shift>0)?(1<<(shift-1)):0;
     328      for (Int y = 0; y < height; y++ )
     329      {
     330        for (Int x = 0; x < width; x++ )
     331        {
     332          UChar uc = (UChar)Clip3<Pel>(0, 255, (pi[x]+offset)>>shift);
     333          fwrite( &uc, sizeof(UChar), 1, pFile );
     334        }
     335        pi += stride;
     336      }
    292337    }
    293338  }

  • branches/HTM-15.2-dev/source/Lib/TLibCommon/TComPicYuv.h

    r1321 r1360  
    6969  // ------------------------------------------------------------------------------------------------
    7070
    71   Int   m_iPicWidth;                                ///< Width of picture in pixels
    72   Int   m_iPicHeight;                               ///< Height of picture in pixels
     71  Int   m_picWidth;                                 ///< Width of picture in pixels
     72  Int   m_picHeight;                                ///< Height of picture in pixels
    7373  ChromaFormat m_chromaFormatIDC;                   ///< Chroma Format
    7474
    … …  
    7676  Int*  m_subCuOffsetInBuffer[MAX_NUM_CHANNEL_TYPE];///< Gives an offset in the buffer for a given sub-CU (and channel), relative to start of CTU
    7777
    78   Int   m_iMarginX;                                 ///< margin of Luma channel (chroma's may be smaller, depending on ratio)
    79   Int   m_iMarginY;                                 ///< margin of Luma channel (chroma's may be smaller, depending on ratio)
     78  Int   m_marginX;                                  ///< margin of Luma channel (chroma's may be smaller, depending on ratio)
     79  Int   m_marginY;                                  ///< margin of Luma channel (chroma's may be smaller, depending on ratio)
    8080
    8181  Bool  m_bIsBorderExtended;
    … …  
    100100  // ------------------------------------------------------------------------------------------------
    101101
    102   Void          create            (const Int iPicWidth,
    103                                    const Int iPicHeight,
     102  Void          create            (const Int picWidth,
     103                                   const Int picHeight,
    104104                                   const ChromaFormat chromaFormatIDC,
    105                                    const UInt uiMaxCUWidth,  ///< used for generating offsets to CUs. Can use iPicWidth if no offsets are required
    106                                    const UInt uiMaxCUHeight, ///< used for generating offsets to CUs. Can use iPicHeight if no offsets are required
    107                                    const UInt uiMaxCUDepth,  ///< used for generating offsets to CUs. Can use 0 if no offsets are required
     105                                   const UInt maxCUWidth,  ///< used for generating offsets to CUs.
     106                                   const UInt maxCUHeight, ///< used for generating offsets to CUs.
     107                                   const UInt maxCUDepth,  ///< used for generating offsets to CUs.
    108108                                   const Bool bUseMargin);   ///< if true, then a margin of uiMaxCUWidth+16 and uiMaxCUHeight+16 is created around the image.
     109
     110  Void          createWithoutCUInfo(const Int picWidth,
     111                                    const Int picHeight,
     112                                    const ChromaFormat chromaFormatIDC,
     113                                    const Bool bUseMargin=false, ///< if true, then a margin of uiMaxCUWidth+16 and uiMaxCUHeight+16 is created around the image.
     114                                    const UInt maxCUWidth=0,   ///< used for margin only
     115                                    const UInt maxCUHeight=0); ///< used for margin only
    109116
    110117  Void          destroy           ();
    … …  
    118125  // ------------------------------------------------------------------------------------------------
    119126
    120   Int           getWidth          (const ComponentID id) const { return  m_iPicWidth >> getComponentScaleX(id);   }
    121   Int           getHeight         (const ComponentID id) const { return  m_iPicHeight >> getComponentScaleY(id);  }
     127  Int           getWidth          (const ComponentID id) const { return  m_picWidth >> getComponentScaleX(id);   }
     128  Int           getHeight         (const ComponentID id) const { return  m_picHeight >> getComponentScaleY(id);  }
    122129  ChromaFormat  getChromaFormat   ()                     const { return m_chromaFormatIDC; }
    123130  UInt          getNumberValidComponents() const { return ::getNumberValidComponents(m_chromaFormatIDC); }
    124131
    125   Int           getStride         (const ComponentID id) const { return ((m_iPicWidth     ) + (m_iMarginX  <<1)) >> getComponentScaleX(id); }
    126   Int           getTotalHeight    (const ComponentID id) const { return ((m_iPicHeight    ) + (m_iMarginY  <<1)) >> getComponentScaleY(id); }
    127 
    128   Int           getMarginX        (const ComponentID id) const { return m_iMarginX >> getComponentScaleX(id);  }
    129   Int           getMarginY        (const ComponentID id) const { return m_iMarginY >> getComponentScaleY(id);  }
     132  Int           getStride         (const ComponentID id) const { return ((m_picWidth     ) + (m_marginX  <<1)) >> getComponentScaleX(id); }
     133private:
     134  Int           getStride         (const ChannelType id) const { return ((m_picWidth     ) + (m_marginX  <<1)) >> getChannelTypeScaleX(id); }
     135public:
     136  Int           getTotalHeight    (const ComponentID id) const { return ((m_picHeight    ) + (m_marginY  <<1)) >> getComponentScaleY(id); }
     137
     138  Int           getMarginX        (const ComponentID id) const { return m_marginX >> getComponentScaleX(id);  }
     139  Int           getMarginY        (const ComponentID id) const { return m_marginY >> getComponentScaleY(id);  }
    130140
    131141  // ------------------------------------------------------------------------------------------------
    … …  
    135145  //  Access starting position of picture buffer with margin
    136146  Pel*          getBuf            (const ComponentID ch)       { return  m_apiPicBuf[ch];   }
     147  const Pel*    getBuf            (const ComponentID ch) const { return  m_apiPicBuf[ch];   }
    137148
    138149  //  Access starting position of original picture
    … …  
    151162  UInt          getComponentScaleY(const ComponentID id) const { return ::getComponentScaleY(id, m_chromaFormatIDC); }
    152163
     164  UInt          getChannelTypeScaleX(const ChannelType id) const { return ::getChannelTypeScaleX(id, m_chromaFormatIDC); }
     165  UInt          getChannelTypeScaleY(const ChannelType id) const { return ::getChannelTypeScaleY(id, m_chromaFormatIDC); }
     166
    153167  // ------------------------------------------------------------------------------------------------
    154168  //  Miscellaneous
    … …  
    162176
    163177  //  Dump picture
    164   Void          dump              (const Char* pFileName, const BitDepths &bitDepths, Bool bAdd = false) const ;
     178  Void          dump              (const std::string &fileName, const BitDepths &bitDepths, const Bool bAppend=false, const Bool bForceTo8Bit=false) const ;
    165179
    166180  // Set border extension flag

  • branches/HTM-15.2-dev/source/Lib/TLibCommon/TComPicYuvMD5.cpp

    r1313 r1360  
    209209std::string hashToString(const TComPictureHash &digest, Int numChar)
    210210{
    211   static const Char* hex = "0123456789abcdef";
     211  static const TChar* hex = "0123456789abcdef";
    212212  std::string result;
    213213

  • branches/HTM-15.2-dev/source/Lib/TLibCommon/TComPrediction.cpp

    r1321 r1360  
    11391139  Int         iHeight;
    11401140  UInt        uiPartAddr;
     1141  const TComSlice *pSlice    = pcCU->getSlice();
     1142  const SliceType  sliceType = pSlice->getSliceType();
     1143  const TComPPS   &pps       = *(pSlice->getPPS());
    11411144
    11421145  if ( iPartIdx >= 0 )
    … …  
    11471150    {
    11481151#endif
    1149       if ( eRefPicList != REF_PIC_LIST_X )
    1150       {
    1151         if( pcCU->getSlice()->getPPS()->getUseWP())
    1152         {
    1153           xPredInterUni (pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred, true );
    1154         }
    1155         else
    1156         {
    1157           xPredInterUni (pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred );
    1158         }
    1159         if ( pcCU->getSlice()->getPPS()->getUseWP() )
    1160         {
    1161           xWeightedPredictionUni( pcCU, pcYuvPred, uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred );
    1162         }
     1152     if ( eRefPicList != REF_PIC_LIST_X )
     1153     {
     1154      if( (sliceType == P_SLICE && pps.getUseWP()) || (sliceType == B_SLICE && pps.getWPBiPred()))
     1155      {
     1156        xPredInterUni (pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred, true );
     1157        xWeightedPredictionUni( pcCU, pcYuvPred, uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred );
    11631158      }
    11641159      else
    11651160      {
     1161        xPredInterUni (pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred );
     1162      }
     1163     }
     1164     else
     1165     {
    11661166#if NH_3D_SPIVMP
    11671167        if ( pcCU->getSPIVMPFlag(uiPartAddr)!=0) 
    … …  
    12351235    if ( eRefPicList != REF_PIC_LIST_X )
    12361236    {
    1237       if( pcCU->getSlice()->getPPS()->getUseWP())
     1237      if( (sliceType == P_SLICE && pps.getUseWP()) || (sliceType == B_SLICE && pps.getWPBiPred()))
    12381238      {
    12391239        xPredInterUni (pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred, true );
     1240        xWeightedPredictionUni( pcCU, pcYuvPred, uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred );
    12401241      }
    12411242      else
    12421243      {
    12431244        xPredInterUni (pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred );
    1244       }
    1245       if ( pcCU->getSlice()->getPPS()->getUseWP() )
    1246       {
    1247         xWeightedPredictionUni( pcCU, pcYuvPred, uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred );
    12481245      }
    12491246    }
    … …  
    14491446      Int iCurrPOC    = pcCU->getSlice()->getPOC();
    14501447      Int iColRefPOC  = pcCU->getSlice()->getRefPOC( eRefPicList, iRefIdx );
    1451     Int iCurrRefPOC = pcCU->getSlice()->getRefPOC( eRefPicList, arpRefIdx );
    1452       Int iScale = pcCU-> xGetDistScaleFactor(iCurrPOC, iCurrRefPOC, iCurrPOC, iColRefPOC);
     1448      Int iCurrRefPOC = pcCU->getSlice()->getRefPOC( eRefPicList, arpRefIdx );
     1449      Int iScale      = pcCU->xGetDistScaleFactor(iCurrPOC, iCurrRefPOC, iCurrPOC, iColRefPOC);
    14531450      if ( iScale != 4096 )
    14541451      {
    14551452        cMv = cMv.scaleMv( iScale );
    14561453      }
    1457     iRefIdx = arpRefIdx;
    1458   }
     1454      iRefIdx = arpRefIdx;
     1455    }
    14591456
    14601457  pcCU->clipMv(cMv);

  • branches/HTM-15.2-dev/source/Lib/TLibCommon/TComRdCost.cpp

    r1321 r1360  
    6464// Calculate RD functions
    6565#if NH_3D_VSO
    66 Double TComRdCost::calcRdCost( UInt uiBits, Dist uiDistortion, Bool bFlag, DFunc eDFunc )
     66Double TComRdCost::calcRdCost( Double numBits, Dist intDistortion, DFunc eDFunc )
     67{
     68  Double distortion = (Double) intDistortion;
    6769#else
    68 Double TComRdCost::calcRdCost( UInt uiBits, Distortion uiDistortion, Bool bFlag, DFunc eDFunc )
    69 #endif
    70 {
    71   Double dRdCost = 0.0;
    72   Double dLambda = 0.0;
     70Double TComRdCost::calcRdCost( Double numBits, Double distortion, DFunc eDFunc )
     71{
     72#endif
     73 
     74  Double lambda = 1.0;
    7375
    7476  switch ( eDFunc )
    … …  
    7880      break;
    7981    case DF_SAD:
    80 #if RExt__HIGH_BIT_DEPTH_SUPPORT
     82      lambda = m_dLambdaMotionSAD[0]; // 0 is valid, because for lossless blocks, the cost equation is modified to compensate.
     83      break;
     84    case DF_DEFAULT:
     85      lambda = m_dLambda;
     86      break;
     87    case DF_SSE_FRAME:
     88      lambda = m_dFrameLambda;
     89      break;
     90    default:
     91      assert (0);
     92      break;
     93  }
     94
     95#if NH_MV
     96  // D_PRINT_INDENT( g_traceRDCost,  "Dist: " + n2s(distortion) + " Bits: " + n2s(numBits) + " RD Cost: " + n2s(dRdCost));
     97   D_PRINT_INDENT( g_traceRDCost,  "Dist: " + n2s(distortion) + " Bits: " + n2s(numBits) );
     98#endif
     99
     100  if (eDFunc == DF_SAD)
     101  {
     102    if (m_costMode != COST_STANDARD_LOSSY)
     103    {
     104      return ((distortion * 65536.0) / lambda) + numBits; // all lossless costs would have uiDistortion=0, and therefore this cost function can be used.
     105    }
     106    else
     107    {
     108      return distortion + (((numBits * lambda) ) / 65536.0);
     109    }
     110  }
     111  else
     112  {
     113    if (m_costMode != COST_STANDARD_LOSSY)
     114    {
     115      return (distortion / lambda) + numBits; // all lossless costs would have uiDistortion=0, and therefore this cost function can be used.
     116    }
     117    else
     118    {
     119      return distortion + (numBits * lambda);
     120    }
     121  }
     122}
     123
     124#if NH_3D_VSO
     125Double TComRdCost::calcRdCost64( UInt64 uiBits, Dist64 uiDistortion, Bool bFlag, DFunc eDFunc )
     126#else
     127Double TComRdCost::calcRdCost64( UInt64 uiBits, UInt64 uiDistortion, Bool bFlag, DFunc eDFunc )
     128#endif
     129{
     130  Double dRdCost = 0.0;
     131  Double dLambda = 0.0;
     132
     133  switch ( eDFunc )
     134  {
     135    case DF_SSE:
     136      assert(0);
     137      break;
     138    case DF_SAD:
    81139      dLambda = m_dLambdaMotionSAD[0]; // 0 is valid, because for lossless blocks, the cost equation is modified to compensate.
    82 #else
    83       dLambda = (Double)m_uiLambdaMotionSAD[0]; // 0 is valid, because for lossless blocks, the cost equation is modified to compensate.
    84 #endif
    85140      break;
    86141    case DF_DEFAULT:
    … …  
    104159    else
    105160    {
    106       dRdCost = (((Double)uiDistortion) + ((Double)uiBits * dLambda));
     161      dRdCost = (((Double)(Int64)uiDistortion) + ((Double)(Int64)uiBits * dLambda));
    107162    }
    108163  }
    … …  
    133188  }
    134189
    135 #if NH_MV
    136   D_PRINT_INDENT( g_traceRDCost,  "Dist: " + n2s(uiDistortion) + " Bits: " + n2s(uiBits) + " RD Cost: " + n2s(dRdCost));
    137 #endif
    138   return dRdCost;
    139 }
    140 
    141 #if NH_3D_VSO
    142 Double TComRdCost::calcRdCost64( UInt64 uiBits, Dist64 uiDistortion, Bool bFlag, DFunc eDFunc )
    143 #else
    144 Double TComRdCost::calcRdCost64( UInt64 uiBits, UInt64 uiDistortion, Bool bFlag, DFunc eDFunc )
    145 #endif
    146 {
    147   Double dRdCost = 0.0;
    148   Double dLambda = 0.0;
    149 
    150   switch ( eDFunc )
    151   {
    152     case DF_SSE:
    153       assert(0);
    154       break;
    155     case DF_SAD:
    156 #if RExt__HIGH_BIT_DEPTH_SUPPORT
    157       dLambda = m_dLambdaMotionSAD[0]; // 0 is valid, because for lossless blocks, the cost equation is modified to compensate.
    158 #else
    159       dLambda = (Double)m_uiLambdaMotionSAD[0]; // 0 is valid, because for lossless blocks, the cost equation is modified to compensate.
    160 #endif
    161       break;
    162     case DF_DEFAULT:
    163       dLambda =         m_dLambda;
    164       break;
    165     case DF_SSE_FRAME:
    166       dLambda =         m_dFrameLambda;
    167       break;
    168     default:
    169       assert (0);
    170       break;
    171   }
    172 
    173   if (bFlag) //NOTE: this "bFlag" is never true
    174   {
    175     // Intra8x8, Intra4x4 Block only...
    176     if (m_costMode != COST_STANDARD_LOSSY)
    177     {
    178       dRdCost = (Double(uiDistortion) / dLambda) + Double(uiBits); // all lossless costs would have uiDistortion=0, and therefore this cost function can be used.
    179     }
    180     else
    181     {
    182       dRdCost = (((Double)(Int64)uiDistortion) + ((Double)(Int64)uiBits * dLambda));
    183     }
    184   }
    185   else
    186   {
    187     if (eDFunc == DF_SAD)
    188     {
    189       if (m_costMode != COST_STANDARD_LOSSY)
    190       {
    191         dRdCost = ((Double(uiDistortion) * 65536) / dLambda) + Double(uiBits); // all lossless costs would have uiDistortion=0, and therefore this cost function can be used.
    192       }
    193       else
    194       {
    195         dRdCost = floor(Double(uiDistortion) + (floor((Double(uiBits) * dLambda) + 0.5) / 65536.0));
    196       }
    197     }
    198     else
    199     {
    200       if (m_costMode != COST_STANDARD_LOSSY)
    201       {
    202         dRdCost = (Double(uiDistortion) / dLambda) + Double(uiBits); // all lossless costs would have uiDistortion=0, and therefore this cost function can be used.
    203       }
    204       else
    205       {
    206         dRdCost = floor(Double(uiDistortion) + (Double(uiBits) * dLambda) + 0.5);
    207       }
    208     }
    209   }
    210 
    211190  return dRdCost;
    212191}
    … …  
    216195  m_dLambda           = dLambda;
    217196  m_sqrtLambda        = sqrt(m_dLambda);
    218 #if RExt__HIGH_BIT_DEPTH_SUPPORT
    219197  m_dLambdaMotionSAD[0] = 65536.0 * m_sqrtLambda;
    220198  m_dLambdaMotionSSE[0] = 65536.0 * m_dLambda;
    … …  
    226204  m_dLambdaMotionSAD[1] = 65536.0 * sqrt(dLambda);
    227205  m_dLambdaMotionSSE[1] = 65536.0 * dLambda;
    228 #else
    229   m_uiLambdaMotionSAD[0] = (UInt)floor(65536.0 * m_sqrtLambda);
    230   m_uiLambdaMotionSSE[0] = (UInt)floor(65536.0 * m_dLambda   );
    231 #if FULL_NBIT
    232   dLambda = 0.57 * pow(2.0, ((LOSSLESS_AND_MIXED_LOSSLESS_RD_COST_TEST_QP_PRIME - 12) / 3.0));
    233 #else
    234   dLambda = 0.57 * pow(2.0, ((LOSSLESS_AND_MIXED_LOSSLESS_RD_COST_TEST_QP_PRIME - 12 - 6 * (bitDepths.recon[CHANNEL_TYPE_LUMA] - 8)) / 3.0));
    235 #endif
    236   m_uiLambdaMotionSAD[1] = (UInt)floor(65536.0 * sqrt(dLambda));
    237   m_uiLambdaMotionSSE[1] = (UInt)floor(65536.0 * dLambda   );
    238 #endif
    239206}
    240207
    … …  
    298265  m_costMode                   = COST_STANDARD_LOSSY;
    299266
    300 #if RExt__HIGH_BIT_DEPTH_SUPPORT
    301   m_dCost                      = 0;
    302 #else
    303   m_uiCost                     = 0;
    304 #endif
     267  m_motionLambda               = 0;
    305268  m_iCostScale                 = 0;
    306269
    … …  
    370333  // initialize
    371334  rcDistParam.iSubShift  = 0;
     335  rcDistParam.m_maximumDistortionForEarlyExit = std::numeric_limits<Distortion>::max();
    372336}
    373337
    374338// Setting the Distortion Parameter for Inter (ME)
    375 Void TComRdCost::setDistParam( TComPattern* pcPatternKey, Pel* piRefY, Int iRefStride, DistParam& rcDistParam )
     339Void TComRdCost::setDistParam( const TComPattern* const pcPatternKey, const Pel* piRefY, Int iRefStride, DistParam& rcDistParam )
    376340{
    377341  // set Original & Curr Pointer / Stride
    … …  
    386350  rcDistParam.iRows    = pcPatternKey->getROIYHeight();
    387351  rcDistParam.DistFunc = m_afpDistortFunc[DF_SAD + g_aucConvertToBit[ rcDistParam.iCols ] + 1 ];
     352  rcDistParam.m_maximumDistortionForEarlyExit = std::numeric_limits<Distortion>::max();
    388353
    389354  if (rcDistParam.iCols == 12)
    … …  
    411376
    412377// Setting the Distortion Parameter for Inter (subpel ME with step)
    413 Void TComRdCost::setDistParam( TComPattern* pcPatternKey, Pel* piRefY, Int iRefStride, Int iStep, DistParam& rcDistParam, Bool bHADME )
     378Void TComRdCost::setDistParam( const TComPattern* const pcPatternKey, const Pel* piRefY, Int iRefStride, Int iStep, DistParam& rcDistParam, Bool bHADME )
    414379{
    415380  // set Original & Curr Pointer / Stride
    … …  
    427392  rcDistParam.iRows    = pcPatternKey->getROIYHeight();
    428393
     394  rcDistParam.m_maximumDistortionForEarlyExit = std::numeric_limits<Distortion>::max();
     395
    429396  // set distortion function
    430397  if ( !bHADME )
    … …  
    459426}
    460427
    461 Void TComRdCost::setDistParam( DistParam& rcDP, Int bitDepth, Pel* p1, Int iStride1, Pel* p2, Int iStride2, Int iWidth, Int iHeight, Bool bHadamard )
     428Void TComRdCost::setDistParam( DistParam& rcDP, Int bitDepth, const Pel* p1, Int iStride1, const Pel* p2, Int iStride2, Int iWidth, Int iHeight, Bool bHadamard )
    462429{
    463430  rcDP.pOrg       = p1;
    … …  
    471438  rcDP.bitDepth   = bitDepth;
    472439  rcDP.DistFunc   = m_afpDistortFunc[ ( bHadamard ? DF_HADS : DF_SADS ) + g_aucConvertToBit[ iWidth ] + 1 ];
     440  rcDP.m_maximumDistortionForEarlyExit = std::numeric_limits<Distortion>::max();
    473441#if NH_3D_DBBP
    474442  if( m_bUseMask )
    … …  
    479447}
    480448
    481 Distortion TComRdCost::calcHAD( Int bitDepth, Pel* pi0, Int iStride0, Pel* pi1, Int iStride1, Int iWidth, Int iHeight )
     449Distortion TComRdCost::calcHAD( Int bitDepth, const Pel* pi0, Int iStride0, const Pel* pi1, Int iStride1, Int iWidth, Int iHeight )
    482450{
    483451  Distortion uiSum = 0;
    … …  
    550518
    551519
    552 Distortion TComRdCost::getDistPart( Int bitDepth, Pel* piCur, Int iCurStride, Pel* piOrg, Int iOrgStride, UInt uiBlkWidth, UInt uiBlkHeight, const ComponentID compID, DFunc eDFunc )
     520Distortion TComRdCost::getDistPart( Int bitDepth, const Pel* piCur, Int iCurStride,  const Pel* piOrg, Int iOrgStride, UInt uiBlkWidth, UInt uiBlkHeight, const ComponentID compID, DFunc eDFunc )
    553521{
    554522  DistParam cDtParam;
    … …  
    663631UInt TComRdCost::xGetMaskedSSE( DistParam* pcDtParam )
    664632{
    665   Pel* piOrg   = pcDtParam->pOrg;
    666   Pel* piCur   = pcDtParam->pCur;
     633  const Pel* piOrg   = pcDtParam->pOrg;
     634  const Pel* piCur   = pcDtParam->pCur;
    667635  Int  iRows   = pcDtParam->iRows;
    668636  Int  iCols   = pcDtParam->iCols;
    … …  
    701669#endif
    702670 
    703   Pel* piOrg   = pcDtParam->pOrg;
    704   Pel* piCur   = pcDtParam->pCur;
     671  const Pel* piOrg   = pcDtParam->pOrg;
     672  const Pel* piCur   = pcDtParam->pCur;
    705673  Int  iRows   = pcDtParam->iRows;
    706674  Int  iCols   = pcDtParam->iCols;
    … …  
    729697UInt TComRdCost::xGetMaskedVSD( DistParam* pcDtParam )
    730698{
    731   Pel* piOrg    = pcDtParam->pOrg;
    732   Pel* piCur    = pcDtParam->pCur;
    733   Pel* piVirRec = pcDtParam->pVirRec;
    734   Pel* piVirOrg = pcDtParam->pVirOrg;
     699  const Pel* piOrg    = pcDtParam->pOrg;
     700  const Pel* piCur    = pcDtParam->pCur;
     701  const Pel* piVirRec = pcDtParam->pVirRec;
     702  const Pel* piVirOrg = pcDtParam->pVirOrg;
    735703  Int  iRows    = pcDtParam->iRows;
    736704  Int  iCols    = pcDtParam->iCols;
    … …  
    786754  const Pel* piOrg   = pcDtParam->pOrg;
    787755  const Pel* piCur   = pcDtParam->pCur;
    788   Int  iRows   = pcDtParam->iRows;
    789   Int  iCols   = pcDtParam->iCols;
    790   Int  iStrideCur = pcDtParam->iStrideCur;
    791   Int  iStrideOrg = pcDtParam->iStrideOrg;
     756  const Int  iCols           = pcDtParam->iCols;
     757  const Int  iStrideCur      = pcDtParam->iStrideCur;
     758  const Int  iStrideOrg      = pcDtParam->iStrideOrg;
     759  const UInt distortionShift = DISTORTION_PRECISION_ADJUSTMENT(pcDtParam->bitDepth - 8);
    792760
    793761  Distortion uiSum = 0;
    794762
    795   for( ; iRows != 0; iRows-- )
     763  for(Int iRows = pcDtParam->iRows ; iRows != 0; iRows-- )
    796764  {
    797765    for (Int n = 0; n < iCols; n++ )
    … …  
    799767      uiSum += abs( piOrg[n] - piCur[n] );
    800768    }
    801     piOrg += iStrideOrg;
    802     piCur += iStrideCur;
    803   }
    804 
    805   return ( uiSum >> DISTORTION_PRECISION_ADJUSTMENT(pcDtParam->bitDepth-8) );
     769    if (pcDtParam->m_maximumDistortionForEarlyExit < ( uiSum >> distortionShift ))
     770    {
     771      return ( uiSum >> distortionShift );
     772    }
     773    piOrg += iStrideOrg;
     774    piCur += iStrideCur;
     775  }
     776
     777  return ( uiSum >> distortionShift );
    806778}
    807779
    … …  
    14031375    return TComRdCostWeightPrediction::xGetSADw( pcDtParam );
    14041376  }
    1405   Pel* piOrg   = pcDtParam->pOrg;
    1406   Pel* piCur   = pcDtParam->pCur;
     1377  const Pel* piOrg   = pcDtParam->pOrg;
     1378  const Pel* piCur   = pcDtParam->pCur;
    14071379  Int  iRows   = pcDtParam->iRows;
    14081380  Int  iCols   = pcDtParam->iCols;
    … …  
    14511423    return TComRdCostWeightPrediction::xGetSADw( pcDtParam );
    14521424  }
    1453   Pel* piOrg   = pcDtParam->pOrg;
    1454   Pel* piCur   = pcDtParam->pCur;
     1425  const Pel* piOrg   = pcDtParam->pOrg;
     1426  const Pel* piCur   = pcDtParam->pCur;
    14551427  Int  iRows   = pcDtParam->iRows;
    14561428  Int  iSubShift  = pcDtParam->iSubShift;
    … …  
    15081480    return TComRdCostWeightPrediction::xGetSADw( pcDtParam );
    15091481  }
    1510   Pel* piOrg      = pcDtParam->pOrg;
    1511   Pel* piCur      = pcDtParam->pCur;
     1482  const Pel* piOrg      = pcDtParam->pOrg;
     1483  const Pel* piCur      = pcDtParam->pCur;
    15121484  Int  iRows      = pcDtParam->iRows;
    15131485  Int  iSubShift  = pcDtParam->iSubShift;
    … …  
    15771549    return TComRdCostWeightPrediction::xGetSADw( pcDtParam );
    15781550  }
    1579   Pel* piOrg   = pcDtParam->pOrg;
    1580   Pel* piCur   = pcDtParam->pCur;
     1551  const Pel* piOrg   = pcDtParam->pOrg;
     1552  const Pel* piCur   = pcDtParam->pCur;
    15811553  Int  iRows   = pcDtParam->iRows;
    15821554  Int  iSubShift  = pcDtParam->iSubShift;
    … …  
    16701642    return TComRdCostWeightPrediction::xGetSADw( pcDtParam );
    16711643  }
    1672   Pel* piOrg   = pcDtParam->pOrg;
    1673   Pel* piCur   = pcDtParam->pCur;
     1644  const Pel* piOrg   = pcDtParam->pOrg;
     1645  const Pel* piCur   = pcDtParam->pCur;
    16741646  Int  iRows   = pcDtParam->iRows;
    16751647  Int  iSubShift  = pcDtParam->iSubShift;
    … …  
    17481720UInt TComRdCost::xGetSAD16Nic( DistParam* pcDtParam )
    17491721{
    1750   Pel* piOrg   = pcDtParam->pOrg;
    1751   Pel* piCur   = pcDtParam->pCur;
     1722  const Pel* piOrg   = pcDtParam->pOrg;
     1723  const Pel* piCur   = pcDtParam->pCur;
    17521724  Int  iRows   = pcDtParam->iRows;
    17531725  Int  iCols   = pcDtParam->iCols;
    … …  
    18451817    return TComRdCostWeightPrediction::xGetSADw( pcDtParam );
    18461818  }
    1847   Pel* piOrg   = pcDtParam->pOrg;
    1848   Pel* piCur   = pcDtParam->pCur;
     1819  const Pel* piOrg   = pcDtParam->pOrg;
     1820  const Pel* piCur   = pcDtParam->pCur;
    18491821  Int  iRows   = pcDtParam->iRows;
    18501822  Int  iSubShift  = pcDtParam->iSubShift;
    … …  
    19871959    return TComRdCostWeightPrediction::xGetSADw( pcDtParam );
    19881960  }
    1989   Pel* piOrg   = pcDtParam->pOrg;
    1990   Pel* piCur   = pcDtParam->pCur;
     1961  const Pel* piOrg   = pcDtParam->pOrg;
     1962  const Pel* piCur   = pcDtParam->pCur;
    19911963  Int  iRows   = pcDtParam->iRows;
    19921964  Int  iSubShift  = pcDtParam->iSubShift;
    … …  
    21042076    return TComRdCostWeightPrediction::xGetSADw( pcDtParam );
    21052077  }
    2106   Pel* piOrg   = pcDtParam->pOrg;
    2107   Pel* piCur   = pcDtParam->pCur;
     2078  const Pel* piOrg   = pcDtParam->pOrg;
     2079  const Pel* piCur   = pcDtParam->pCur;
    21082080  Int  iRows   = pcDtParam->iRows;
    21092081  Int  iSubShift  = pcDtParam->iSubShift;
    … …  
    23432315  }
    23442316
    2345   Pel* piOrg   = pcDtParam->pOrg;
    2346   Pel* piCur   = pcDtParam->pCur;
     2317  const Pel* piOrg   = pcDtParam->pOrg;
     2318  const Pel* piCur   = pcDtParam->pCur;
    23472319  Int  iRows   = pcDtParam->iRows;
    23482320  Int  iSubShift  = pcDtParam->iSubShift;
    … …  
    28792851#if NH_3D_VSO
    28802852//SAIT_VSO_EST_A0033
    2881 UInt TComRdCost::getVSDEstimate( Int dDM, Pel* pOrg, Int iOrgStride,  Pel* pVirRec, Pel* pVirOrg, Int iVirStride, Int x, Int y )
     2853UInt TComRdCost::getVSDEstimate( Int dDM, const Pel* pOrg, Int iOrgStride, const Pel* pVirRec, const Pel* pVirOrg, Int iVirStride, Int x, Int y )
    28822854{
    28832855  // change to use bit depth from DistParam struct
    … …  
    28942866UInt TComRdCost::xGetVSD( DistParam* pcDtParam )
    28952867{
    2896   Pel* piOrg    = pcDtParam->pOrg;
    2897   Pel* piCur    = pcDtParam->pCur;
    2898   Pel* piVirRec = pcDtParam->pVirRec;
    2899   Pel* piVirOrg = pcDtParam->pVirOrg;
     2868  const Pel* piOrg    = pcDtParam->pOrg;
     2869  const Pel* piCur    = pcDtParam->pCur;
     2870  const Pel* piVirRec = pcDtParam->pVirRec;
     2871  const Pel* piVirOrg = pcDtParam->pVirOrg;
    29002872  Int  iRows    = pcDtParam->iRows;
    29012873  Int  iCols    = pcDtParam->iCols;
    … …  
    29252897UInt TComRdCost::xGetVSD4( DistParam* pcDtParam )
    29262898{
    2927   Pel* piOrg   = pcDtParam->pOrg;
    2928   Pel* piCur   = pcDtParam->pCur;
    2929   Pel* piVirRec = pcDtParam->pVirRec;
    2930   Pel* piVirOrg = pcDtParam->pVirOrg;
     2899  const Pel* piOrg   = pcDtParam->pOrg;
     2900  const Pel* piCur   = pcDtParam->pCur;
     2901  const Pel* piVirRec = pcDtParam->pVirRec;
     2902  const Pel* piVirOrg = pcDtParam->pVirOrg;
    29312903  Int  iRows   = pcDtParam->iRows;
    29322904  Int  iStrideOrg = pcDtParam->iStrideOrg;
    … …  
    29552927UInt TComRdCost::xGetVSD8( DistParam* pcDtParam )
    29562928{
    2957   Pel* piOrg   = pcDtParam->pOrg;
    2958   Pel* piCur   = pcDtParam->pCur;
    2959   Pel* piVirRec = pcDtParam->pVirRec;
    2960   Pel* piVirOrg = pcDtParam->pVirOrg;
     2929  const Pel* piOrg   = pcDtParam->pOrg;
     2930  const Pel* piCur   = pcDtParam->pCur;
     2931  const Pel* piVirRec = pcDtParam->pVirRec;
     2932  const Pel* piVirOrg = pcDtParam->pVirOrg;
    29612933  Int  iRows   = pcDtParam->iRows;
    29622934  Int  iStrideOrg = pcDtParam->iStrideOrg;
    … …  
    29852957UInt TComRdCost::xGetVSD16( DistParam* pcDtParam )
    29862958{
    2987   Pel* piOrg   = pcDtParam->pOrg;
    2988   Pel* piCur   = pcDtParam->pCur;
    2989   Pel* piVirRec = pcDtParam->pVirRec;
    2990   Pel* piVirOrg = pcDtParam->pVirOrg;
     2959  const Pel* piOrg   = pcDtParam->pOrg;
     2960  const Pel* piCur   = pcDtParam->pCur;
     2961  const Pel* piVirRec = pcDtParam->pVirRec;
     2962  const Pel* piVirOrg = pcDtParam->pVirOrg;
    29912963  Int  iRows   = pcDtParam->iRows;
    29922964  Int  iStrideOrg = pcDtParam->iStrideOrg;
    … …  
    30152987UInt TComRdCost::xGetVSD16N( DistParam* pcDtParam )
    30162988{
    3017   Pel* piOrg   = pcDtParam->pOrg;
    3018   Pel* piCur   = pcDtParam->pCur;
    3019   Pel* piVirRec = pcDtParam->pVirRec;
    3020   Pel* piVirOrg = pcDtParam->pVirOrg;
     2989  const Pel* piOrg   = pcDtParam->pOrg;
     2990  const Pel* piCur   = pcDtParam->pCur;
     2991  const Pel* piVirRec = pcDtParam->pVirRec;
     2992  const Pel* piVirOrg = pcDtParam->pVirOrg;
    30212993  Int  iRows   = pcDtParam->iRows;
    30222994  Int  iCols   = pcDtParam->iCols;
    … …  
    30493021UInt TComRdCost::xGetVSD32( DistParam* pcDtParam )
    30503022{
    3051   Pel* piOrg   = pcDtParam->pOrg;
    3052   Pel* piCur   = pcDtParam->pCur;
    3053   Pel* piVirRec = pcDtParam->pVirRec;
    3054   Pel* piVirOrg = pcDtParam->pVirOrg;
     3023  const Pel* piOrg   = pcDtParam->pOrg;
     3024  const Pel* piCur   = pcDtParam->pCur;
     3025  const Pel* piVirRec = pcDtParam->pVirRec;
     3026  const Pel* piVirOrg = pcDtParam->pVirOrg;
    30553027  Int  iRows   = pcDtParam->iRows;
    30563028  Int  iStrideOrg = pcDtParam->iStrideOrg;
    … …  
    30793051UInt TComRdCost::xGetVSD64( DistParam* pcDtParam )
    30803052{
    3081   Pel* piOrg      = pcDtParam->pOrg;
    3082   Pel* piCur      = pcDtParam->pCur;
    3083   Pel* piVirRec   = pcDtParam->pVirRec;
    3084   Pel* piVirOrg   = pcDtParam->pVirOrg;
     3053  const Pel* piOrg      = pcDtParam->pOrg;
     3054  const Pel* piCur      = pcDtParam->pCur;
     3055  const Pel* piVirRec   = pcDtParam->pVirRec;
     3056  const Pel* piVirOrg   = pcDtParam->pVirOrg;
    30853057  Int  iRows      = pcDtParam->iRows;
    30863058  Int  iStrideOrg = pcDtParam->iStrideOrg;
    … …  
    31133085// --------------------------------------------------------------------------------------------------------------------
    31143086
    3115 Distortion TComRdCost::xCalcHADs2x2( Pel *piOrg, Pel *piCur, Int iStrideOrg, Int iStrideCur, Int iStep )
     3087Distortion TComRdCost::xCalcHADs2x2( const Pel *piOrg, const Pel *piCur, Int iStrideOrg, Int iStrideCur, Int iStep )
    31163088{
    31173089  Distortion satd = 0;
    … …  
    31353107}
    31363108
    3137 Distortion TComRdCost::xCalcHADs4x4( Pel *piOrg, Pel *piCur, Int iStrideOrg, Int iStrideCur, Int iStep )
     3109Distortion TComRdCost::xCalcHADs4x4( const Pel *piOrg, const Pel *piCur, Int iStrideOrg, Int iStrideCur, Int iStep )
    31383110{
    31393111  Int k;
    … …  
    32313203}
    32323204
    3233 Distortion TComRdCost::xCalcHADs8x8( Pel *piOrg, Pel *piCur, Int iStrideOrg, Int iStrideCur, Int iStep )
     3205Distortion TComRdCost::xCalcHADs8x8( const Pel *piOrg, const Pel *piCur, Int iStrideOrg, Int iStrideCur, Int iStep )
    32343206{
    32353207  Int k, i, j, jj;
    … …  
    33483320#endif
    33493321
    3350   Pel* piOrg   = pcDtParam->pOrg;
    3351   Pel* piCur   = pcDtParam->pCur;
    3352   Int  iRows   = pcDtParam->iRows;
    3353   Int  iCols   = pcDtParam->iCols;
    3354   Int  iStrideCur = pcDtParam->iStrideCur;
    3355   Int  iStrideOrg = pcDtParam->iStrideOrg;
    3356   Int  iStep  = pcDtParam->iStep;
     3322  const Pel* piOrg      = pcDtParam->pOrg;
     3323  const Pel* piCur      = pcDtParam->pCur;
     3324  const Int  iRows      = pcDtParam->iRows;
     3325  const Int  iCols      = pcDtParam->iCols;
     3326  const Int  iStrideCur = pcDtParam->iStrideCur;
     3327  const Int  iStrideOrg = pcDtParam->iStrideOrg;
     3328  const Int  iStep      = pcDtParam->iStep;
    33573329
    33583330  Int  x, y;
    … …  
    34183390    return TComRdCostWeightPrediction::xGetHADsw( pcDtParam );
    34193391  }
    3420   Pel* piOrg   = pcDtParam->pOrg;
    3421   Pel* piCur   = pcDtParam->pCur;
     3392  const Pel* piOrg   = pcDtParam->pOrg;
     3393  const Pel* piCur   = pcDtParam->pCur;
     3394 
    34223395  Int  iRows   = pcDtParam->iRows;
    34233396  Int  iCols   = pcDtParam->iCols;
    … …  
    34493422  iDeltaC = (iOrigAvg - iCurAvg)/iRows/iCols;
    34503423
     3424  const Int orgMaxSize = MAX_CU_SIZE*MAX_CU_SIZE;
     3425  assert( iRows * iCols <= orgMaxSize );
     3426 
     3427  Pel orgMinusDeltaDc[ orgMaxSize ];
     3428  Pel* tempOrgMinusDeltaDc = orgMinusDeltaDc;
     3429 
    34513430  for ( y=0; y<iRows; y++ )
    34523431  {
    34533432    for ( x=0; x<iCols; x++ )
    34543433    {       
    3455       piOrg[x] -= iDeltaC;
    3456     }
    3457     piOrg += iStrideOrg;
    3458   }
     3434      tempOrgMinusDeltaDc[x] = (piOrg[x] - iDeltaC);
     3435    }
     3436    piOrg               += iStrideOrg;
     3437    tempOrgMinusDeltaDc += iStrideOrg;
     3438  }
     3439
     3440  tempOrgMinusDeltaDc = orgMinusDeltaDc;
    34593441
    34603442  piOrg   = pcDtParam->pOrg;
    … …  
    34723454      for ( x=0; x<iCols; x+= 8 )
    34733455      {
    3474         uiSum += xCalcHADs8x8( &piOrg[x], &piCur[x*iStep], iStrideOrg, iStrideCur, iStep );
     3456        uiSum += xCalcHADs8x8( &tempOrgMinusDeltaDc[x], &piCur[x*iStep], iStrideOrg, iStrideCur, iStep );
    34753457      }
    3476       piOrg += iOffsetOrg;
    3477       piCur += iOffsetCur;
     3458      tempOrgMinusDeltaDc += iOffsetOrg;
     3459      piCur               += iOffsetCur;
    34783460    }
    34793461  }
    … …  
    34873469      for ( x=0; x<iCols; x+= 16 )
    34883470      {
    3489         uiSum += xCalcHADs16x4( &piOrg[x], &piCur[x*iStep], iStrideOrg, iStrideCur, iStep );
     3471        uiSum += xCalcHADs16x4( &tempOrgMinusDeltaDc[x], &piCur[x*iStep], iStrideOrg, iStrideCur, iStep );
    34903472      }
    3491       piOrg += iOffsetOrg;
    3492       piCur += iOffsetCur;
     3473      tempOrgMinusDeltaDc += iOffsetOrg;
     3474      piCur               += iOffsetCur;
    34933475    }
    34943476  }
    … …  
    35013483      for ( x=0; x<iCols; x+= 4 )
    35023484      {
    3503         uiSum += xCalcHADs4x16( &piOrg[x], &piCur[x*iStep], iStrideOrg, iStrideCur, iStep );
     3485        uiSum += xCalcHADs4x16( &tempOrgMinusDeltaDc[x], &piCur[x*iStep], iStrideOrg, iStrideCur, iStep );
    35043486      }
    3505       piOrg += iOffsetOrg;
    3506       piCur += iOffsetCur;
     3487      tempOrgMinusDeltaDc += iOffsetOrg;
     3488      piCur               += iOffsetCur;
    35073489    }
    35083490  }
    … …  
    35173499      for ( x=0; x<iCols; x+= 4 )
    35183500      {
    3519         uiSum += xCalcHADs4x4( &piOrg[x], &piCur[x*iStep], iStrideOrg, iStrideCur, iStep );
     3501        uiSum += xCalcHADs4x4( &tempOrgMinusDeltaDc[x], &piCur[x*iStep], iStrideOrg, iStrideCur, iStep );
    35203502      }
    3521       piOrg += iOffsetOrg;
    3522       piCur += iOffsetCur;
     3503      tempOrgMinusDeltaDc += iOffsetOrg;
     3504      piCur               += iOffsetCur;
    35233505    }
    35243506  }
    … …  
    35313513      for ( x=0; x<iCols; x+=2 )
    35323514      {
    3533         uiSum += xCalcHADs2x2( &piOrg[x], &piCur[x*iStep], iStrideOrg, iStrideCur, iStep );
     3515        uiSum += xCalcHADs2x2( &tempOrgMinusDeltaDc[x], &piCur[x*iStep], iStrideOrg, iStrideCur, iStep );
    35343516      }
    3535       piOrg += iOffsetOrg;
    3536       piCur += iOffsetCur;
     3517      tempOrgMinusDeltaDc += iOffsetOrg;
     3518      piCur               += iOffsetCur;
    35373519    }
    35383520  }
    … …  
    35403522  {
    35413523    assert(false);
    3542   }
    3543 
    3544   piOrg   = pcDtParam->pOrg;
    3545 
    3546   for ( y=0; y<iRows; y++ )
    3547   {
    3548     for ( x=0; x<iCols; x++ )
    3549     {       
    3550       piOrg[x] += iDeltaC;
    3551     }
    3552     piOrg += iStrideOrg;
    35533524  }
    35543525

  • branches/HTM-15.2-dev/source/Lib/TLibCommon/TComRdCost.h

    r1313 r1360  
    8181{
    8282public:
    83   Pel*  pOrg;
    84   Pel*  pCur;
     83  const Pel*            pOrg;
     84  const Pel*            pCur;
    8585  Int   iStrideOrg;
    8686  Int   iStrideCur;
    … …  
    104104
    105105  Bool            bApplyWeight;     // whether weighted prediction is used or not
    106   WPScalingParam  *wpCur;           // weighted prediction scaling parameters for current ref
     106  Bool                  bIsBiPred;
     107
     108  const WPScalingParam *wpCur;           // weighted prediction scaling parameters for current ref
    107109  ComponentID     compIdx;
     110  Distortion            m_maximumDistortionForEarlyExit; /// During cost calculations, if distortion exceeds this value, cost calculations may early-terminate.
    108111
    109112  // (vertical) subsampling shift (for reducing complexity)
    … …  
    112115
    113116  DistParam()
    114   {
    115     pOrg = NULL;
    116     pCur = NULL;
    117     iStrideOrg = 0;
    118     iStrideCur = 0;
    119     iRows = 0;
    120     iCols = 0;
    121     iStep = 1;
    122     DistFunc = NULL;
    123     iSubShift = 0;
    124     bitDepth = 0;
    125 #if NH_3D_VSO
    126     // SAIT_VSO_EST_A0033
    127     pVirRec = NULL;
    128     pVirOrg = NULL;
    129     iStrideVir = 0;
    130 #endif
    131 #if NH_3D_SDC_INTER
    132     bUseSDCMRSAD = false;
    133 #endif
    134   }
     117   : pOrg(NULL),
     118     pCur(NULL),
     119     iStrideOrg(0),
     120     iStrideCur(0),
     121     iRows(0),
     122     iCols(0),
     123     iStep(1),
     124     DistFunc(NULL),
     125     bitDepth(0),
     126     bApplyWeight(false),
     127     bIsBiPred(false),
     128     wpCur(NULL),
     129     compIdx(MAX_NUM_COMPONENT),
     130     m_maximumDistortionForEarlyExit(std::numeric_limits<Distortion>::max()),
     131     iSubShift(0)
     132  { }
    135133};
    136134
    … …  
    146144  Double                  m_dLambda;
    147145  Double                  m_sqrtLambda;
    148 #if RExt__HIGH_BIT_DEPTH_SUPPORT
    149146  Double                  m_dLambdaMotionSAD[2 /* 0=standard, 1=for transquant bypass when mixed-lossless cost evaluation enabled*/];
    150147  Double                  m_dLambdaMotionSSE[2 /* 0=standard, 1=for transquant bypass when mixed-lossless cost evaluation enabled*/];
    151 #else
    152   UInt                    m_uiLambdaMotionSAD[2 /* 0=standard, 1=for transquant bypass when mixed-lossless cost evaluation enabled*/];
    153   UInt                    m_uiLambdaMotionSSE[2 /* 0=standard, 1=for transquant bypass when mixed-lossless cost evaluation enabled*/];
    154 #endif
    155148  Double                  m_dFrameLambda;
    156149#if NH_3D_VSO
    … …  
    161154  // for motion cost
    162155  TComMv                  m_mvPredictor;
    163 #if RExt__HIGH_BIT_DEPTH_SUPPORT
    164   Double                  m_dCost;
    165 #else
    166   UInt                    m_uiCost;
    167 #endif
     156  Double                  m_motionLambda;
    168157  Int                     m_iCostScale;
    169158#if NH_3D_DBBP
    … …  
    175164  virtual ~TComRdCost();
    176165#if NH_3D_VSO
    177   Double  calcRdCost  ( UInt   uiBits, Dist  uiDistortion, Bool bFlag = false, DFunc eDFunc = DF_DEFAULT );
    178   Double  calcRdCost64( UInt64 uiBits, Dist64 uiDistortion, Bool bFlag = false, DFunc eDFunc = DF_DEFAULT );
     166  Double  calcRdCost64( UInt64 uiBits , Dist64 uiDistortion, Bool bFlag = false, DFunc eDFunc = DF_DEFAULT );
     167  Double  calcRdCost( Double numBits, Dist intDistortion, DFunc eDFunc = DF_DEFAULT );
    179168#else
    180   Double  calcRdCost  ( UInt   uiBits, Distortion uiDistortion, Bool bFlag = false, DFunc eDFunc = DF_DEFAULT );
    181   Double  calcRdCost64( UInt64 uiBits, UInt64 uiDistortion, Bool bFlag = false, DFunc eDFunc = DF_DEFAULT );
    182 #endif
     169  Double calcRdCost( Double numBits, Double distortion, DFunc eDFunc = DF_DEFAULT );
     170#endif
     171
    183172
    184173  Void    setDistortionWeight  ( const ComponentID compID, const Double distortionWeight ) { m_distortionWeight[compID] = distortionWeight; }
    … …  
    202191
    203192  Void    setDistParam( UInt uiBlkWidth, UInt uiBlkHeight, DFunc eDFunc, DistParam& rcDistParam );
    204   Void    setDistParam( TComPattern* pcPatternKey, Pel* piRefY, Int iRefStride,            DistParam& rcDistParam );
    205   Void    setDistParam( TComPattern* pcPatternKey, Pel* piRefY, Int iRefStride, Int iStep, DistParam& rcDistParam, Bool bHADME=false );
    206   Void    setDistParam( DistParam& rcDP, Int bitDepth, Pel* p1, Int iStride1, Pel* p2, Int iStride2, Int iWidth, Int iHeight, Bool bHadamard = false );
     193  Void    setDistParam( const TComPattern* const pcPatternKey, const Pel* piRefY, Int iRefStride,            DistParam& rcDistParam );
     194  Void    setDistParam( const TComPattern* const pcPatternKey, const Pel* piRefY, Int iRefStride, Int iStep, DistParam& rcDistParam, Bool bHADME=false );
     195  Void    setDistParam( DistParam& rcDP, Int bitDepth, const Pel* p1, Int iStride1, const Pel* p2, Int iStride2, Int iWidth, Int iHeight, Bool bHadamard = false );
    207196
    208197#if NH_3D_DBBP
    … …  
    210199#endif
    211200
    212   Distortion calcHAD(Int bitDepth, Pel* pi0, Int iStride0, Pel* pi1, Int iStride1, Int iWidth, Int iHeight );
     201  Distortion calcHAD(Int bitDepth, const Pel* pi0, Int iStride0, const Pel* pi1, Int iStride1, Int iWidth, Int iHeight );
    213202
    214203#if NH_3D_ENC_DEPTH
    … …  
    218207  // for motion cost
    219208  static UInt    xGetExpGolombNumberOfBits( Int iVal );
    220 #if RExt__HIGH_BIT_DEPTH_SUPPORT
    221   Void    getMotionCost( Bool bSad, Int iAdd, Bool bIsTransquantBypass ) { m_dCost = (bSad ? m_dLambdaMotionSAD[(bIsTransquantBypass && m_costMode==COST_MIXED_LOSSLESS_LOSSY_CODING) ?1:0] + iAdd : m_dLambdaMotionSSE[(bIsTransquantBypass && m_costMode==COST_MIXED_LOSSLESS_LOSSY_CODING)?1:0] + iAdd); }
    222 #else
    223   Void    getMotionCost( Bool bSad, Int iAdd, Bool bIsTransquantBypass ) { m_uiCost = (bSad ? m_uiLambdaMotionSAD[(bIsTransquantBypass && m_costMode==COST_MIXED_LOSSLESS_LOSSY_CODING) ?1:0] + iAdd : m_uiLambdaMotionSSE[(bIsTransquantBypass && m_costMode==COST_MIXED_LOSSLESS_LOSSY_CODING)?1:0] + iAdd); }
    224 #endif
     209  Void    selectMotionLambda( Bool bSad, Int iAdd, Bool bIsTransquantBypass ) { m_motionLambda = (bSad ? m_dLambdaMotionSAD[(bIsTransquantBypass && m_costMode==COST_MIXED_LOSSLESS_LOSSY_CODING) ?1:0] + iAdd : m_dLambdaMotionSSE[(bIsTransquantBypass && m_costMode==COST_MIXED_LOSSLESS_LOSSY_CODING)?1:0] + iAdd); }
    225210  Void    setPredictor( TComMv& rcMv )
    226211  {
    … …  
    228213  }
    229214  Void    setCostScale( Int iCostScale )    { m_iCostScale = iCostScale; }
    230   __inline Distortion getCost( Int x, Int y )
     215  Distortion getCost( UInt b )                 { return Distortion(( m_motionLambda * b ) / 65536.0); }
     216  Distortion getCostOfVectorWithPredictor( const Int x, const Int y )
    231217  {
    232 #if RExt__HIGH_BIT_DEPTH_SUPPORT
    233     return Distortion((m_dCost * getBits(x, y)) / 65536.0);
    234 #else
    235     return m_uiCost * getBits(x, y) >> 16;
    236 #endif
     218    return Distortion((m_motionLambda * getBitsOfVectorWithPredictor(x, y)) / 65536.0);
    237219  }
    238 #if RExt__HIGH_BIT_DEPTH_SUPPORT
    239   Distortion getCost( UInt b )                 { return Distortion(( m_dCost * b ) / 65536.0); }
    240 #else
    241   Distortion getCost( UInt b )                 { return ( m_uiCost * b ) >> 16; }
    242 #endif
    243   UInt    getBits( Int x, Int y )
     220  UInt getBitsOfVectorWithPredictor( const Int x, const Int y )
    244221  {
    245222    return xGetExpGolombNumberOfBits((x << m_iCostScale) - m_mvPredictor.getHor())
    … …  
    299276
    300277  static Distortion xGetHADs          ( DistParam* pcDtParam );
    301   static Distortion xCalcHADs2x2      ( Pel *piOrg, Pel *piCurr, Int iStrideOrg, Int iStrideCur, Int iStep );
    302   static Distortion xCalcHADs4x4      ( Pel *piOrg, Pel *piCurr, Int iStrideOrg, Int iStrideCur, Int iStep );
    303   static Distortion xCalcHADs8x8      ( Pel *piOrg, Pel *piCurr, Int iStrideOrg, Int iStrideCur, Int iStep );
     278  static Distortion xCalcHADs2x2      ( const Pel *piOrg, const Pel *piCurr, Int iStrideOrg, Int iStrideCur, Int iStep );
     279  static Distortion xCalcHADs4x4      ( const Pel *piOrg, const Pel *piCurr, Int iStrideOrg, Int iStrideCur, Int iStep );
     280  static Distortion xCalcHADs8x8      ( const Pel *piOrg, const Pel *piCurr, Int iStrideOrg, Int iStrideCur, Int iStep );
    304281#if NH_3D_DBBP
    305282  static UInt xGetMaskedSSE     ( DistParam* pcDtParam );
    … …  
    311288public:
    312289
    313   Distortion   getDistPart(Int bitDepth, Pel* piCur, Int iCurStride, Pel* piOrg, Int iOrgStride, UInt uiBlkWidth, UInt uiBlkHeight, const ComponentID compID, DFunc eDFunc = DF_SSE );
     290  Distortion   getDistPart(Int bitDepth, const Pel* piCur, Int iCurStride, const Pel* piOrg, Int iOrgStride, UInt uiBlkWidth, UInt uiBlkHeight, const ComponentID compID, DFunc eDFunc = DF_SSE );
    314291
    315292#if KWU_RC_MADPRED_E0227
    … …  
    320297  // SAIT_VSO_EST_A0033
    321298  UInt        getDistPartVSD( TComDataCU* pcCu, UInt uiPartOffset, Int bitDepth, Pel* piCur, Int iCurStride,  Pel* piOrg, Int iOrgStride, UInt uiBlkWidth, UInt uiBlkHeight, Bool bHad, DFunc eDFunc = DF_VSD);
    322   static UInt getVSDEstimate( Int dDM, Pel* pOrg, Int iOrgStride,  Pel* pVirRec, Pel* pVirOrg, Int iVirStride, Int x, Int y );
     299  static UInt getVSDEstimate( Int dDM, const Pel* pOrg, Int iOrgStride,  const Pel* pVirRec, const Pel* pVirOrg, Int iVirStride, Int x, Int y );
    323300
    324301private:

  • branches/HTM-15.2-dev/source/Lib/TLibCommon/TComRdCostWeightPrediction.cpp

    r1313 r1360  
    7070  const Int             shift      = wpCur.shift;
    7171  const Int             round      = wpCur.round;
     72  const Int        distortionShift = DISTORTION_PRECISION_ADJUSTMENT(pcDtParam->bitDepth-8);
    7273
    7374  Distortion uiSum = 0;
    7475
     76#if !U0040_MODIFIED_WEIGHTEDPREDICTION_WITH_BIPRED_AND_CLIPPING
    7577  for(Int iRows = pcDtParam->iRows; iRows != 0; iRows-- )
    7678  {
    … …  
    8082
    8183      uiSum += abs( piOrg[n] - pred );
     84    }
     85    if (pcDtParam->m_maximumDistortionForEarlyExit <  ( uiSum >> distortionShift))
     86    {
     87      return uiSum >> distortionShift;
    8288    }
    8389    piOrg += iStrideOrg;
    … …  
    8692
    8793  pcDtParam->compIdx = MAX_NUM_COMPONENT;  // reset for DEBUG (assert test)
    88 
    89   return uiSum >> DISTORTION_PRECISION_ADJUSTMENT(pcDtParam->bitDepth-8);
     94#else
     95  // Default weight
     96  if (w0 == 1 << shift)
     97  {
     98    // no offset
     99    if (offset == 0)
     100    {
     101      for(Int iRows = pcDtParam->iRows; iRows != 0; iRows-- )
     102      {
     103        for (Int n = 0; n < iCols; n++ )
     104        {
     105          uiSum += abs( piOrg[n] - piCur[n] );
     106        }
     107        if (pcDtParam->m_maximumDistortionForEarlyExit <  ( uiSum >> distortionShift))
     108        {
     109          return uiSum >> distortionShift;
     110        }
     111        piOrg += iStrideOrg;
     112        piCur += iStrideCur;
     113      }
     114    }
     115    else
     116    {
     117      // Lets not clip for the bipredictive case since clipping should be done after
     118      // combining both elements. Unfortunately the code uses the suboptimal "subtraction"
     119      // method, which is faster but introduces the clipping issue (therefore Bipred is suboptimal).
     120      if (pcDtParam->bIsBiPred)
     121      {
     122        for(Int iRows = pcDtParam->iRows; iRows != 0; iRows-- )
     123        {
     124          for (Int n = 0; n < iCols; n++ )
     125          {
     126            uiSum += abs( piOrg[n] - (piCur[n] + offset) );
     127          }
     128          if (pcDtParam->m_maximumDistortionForEarlyExit <  ( uiSum >> distortionShift))
     129          {
     130            return uiSum >> distortionShift;
     131          }
     132
     133          piOrg += iStrideOrg;
     134          piCur += iStrideCur;
     135        }
     136      }
     137      else
     138      {
     139        const Pel iMaxValue = (Pel) ((1 << pcDtParam->bitDepth) - 1);
     140        for(Int iRows = pcDtParam->iRows; iRows != 0; iRows-- )
     141        {
     142          for (Int n = 0; n < iCols; n++ )
     143          {
     144            const Pel pred = Clip3((Pel) 0, iMaxValue, (Pel) (piCur[n] + offset)) ;
     145
     146            uiSum += abs( piOrg[n] - pred );
     147          }
     148          if (pcDtParam->m_maximumDistortionForEarlyExit <  ( uiSum >> distortionShift))
     149          {
     150            return uiSum >> distortionShift;
     151          }
     152          piOrg += iStrideOrg;
     153          piCur += iStrideCur;
     154        }
     155      }
     156    }
     157  }
     158  else
     159  {
     160    // Lets not clip for the bipredictive case since clipping should be done after
     161    // combining both elements. Unfortunately the code uses the suboptimal "subtraction"
     162    // method, which is faster but introduces the clipping issue (therefore Bipred is suboptimal).
     163    if (pcDtParam->bIsBiPred)
     164    {
     165      for(Int iRows = pcDtParam->iRows; iRows != 0; iRows-- )
     166      {
     167        for (Int n = 0; n < iCols; n++ )
     168        {
     169          const Pel pred = ( (w0*piCur[n] + round) >> shift ) + offset ;
     170          uiSum += abs( piOrg[n] - pred );
     171        }
     172        if (pcDtParam->m_maximumDistortionForEarlyExit <  ( uiSum >> distortionShift))
     173        {
     174          return uiSum >> distortionShift;
     175        }
     176
     177        piOrg += iStrideOrg;
     178        piCur += iStrideCur;
     179      }
     180    }
     181    else
     182    {
     183      const Pel iMaxValue = (Pel) ((1 << pcDtParam->bitDepth) - 1);
     184
     185      if (offset == 0)
     186      {
     187        for(Int iRows = pcDtParam->iRows; iRows != 0; iRows-- )
     188        {
     189          for (Int n = 0; n < iCols; n++ )
     190          {
     191            const Pel pred = Clip3((Pel) 0, iMaxValue, (Pel) (( (w0*piCur[n] + round) >> shift ))) ;
     192
     193            uiSum += abs( piOrg[n] - pred );
     194          }
     195          if (pcDtParam->m_maximumDistortionForEarlyExit <  ( uiSum >> distortionShift))
     196          {
     197            return uiSum >> distortionShift;
     198          }
     199          piOrg += iStrideOrg;
     200          piCur += iStrideCur;
     201        }
     202      }
     203      else
     204      {
     205        for(Int iRows = pcDtParam->iRows; iRows != 0; iRows-- )
     206        {
     207          for (Int n = 0; n < iCols; n++ )
     208          {
     209            const Pel pred = Clip3((Pel) 0, iMaxValue, (Pel) (( (w0*piCur[n] + round) >> shift ) + offset)) ;
     210
     211            uiSum += abs( piOrg[n] - pred );
     212          }
     213          if (pcDtParam->m_maximumDistortionForEarlyExit <  ( uiSum >> distortionShift))
     214          {
     215            return uiSum >> distortionShift;
     216          }
     217          piOrg += iStrideOrg;
     218          piCur += iStrideCur;
     219        }
     220      }
     221    }
     222  }
     223  //pcDtParam->compIdx = MAX_NUM_COMPONENT;  // reset for DEBUG (assert test)
     224#endif
     225
     226  return uiSum >> distortionShift;
    90227}
    91228
    … …  
    119256  Distortion sum = 0;
    120257
     258#if !U0040_MODIFIED_WEIGHTEDPREDICTION_WITH_BIPRED_AND_CLIPPING
    121259  for(Int iRows = pcDtParam->iRows ; iRows != 0; iRows-- )
    122260  {
    … …  
    132270
    133271  pcDtParam->compIdx = MAX_NUM_COMPONENT; // reset for DEBUG (assert test)
     272#else
     273  if (pcDtParam->bIsBiPred)
     274  {
     275    for(Int iRows = pcDtParam->iRows ; iRows != 0; iRows-- )
     276    {
     277      for (Int n = 0; n < iCols; n++ )
     278      {
     279        const Pel pred     = ( (w0*piCur[n] + round) >> shift ) + offset ;
     280        const Pel residual = piOrg[n] - pred;
     281        sum += ( Distortion(residual) * Distortion(residual) ) >> distortionShift;
     282      }
     283      piOrg += iStrideOrg;
     284      piCur += iStrideCur;
     285    }
     286  }
     287  else
     288  {
     289    const Pel iMaxValue = (Pel) ((1 << pcDtParam->bitDepth) - 1);
     290
     291    for(Int iRows = pcDtParam->iRows ; iRows != 0; iRows-- )
     292    {
     293      for (Int n = 0; n < iCols; n++ )
     294      {
     295        const Pel pred     = Clip3((Pel) 0, iMaxValue, (Pel) (( (w0*piCur[n] + round) >> shift ) + offset)) ;
     296        const Pel residual = piOrg[n] - pred;
     297        sum += ( Distortion(residual) * Distortion(residual) ) >> distortionShift;
     298      }
     299      piOrg += iStrideOrg;
     300      piCur += iStrideCur;
     301    }
     302  }
     303
     304  //pcDtParam->compIdx = MAX_NUM_COMPONENT; // reset for DEBUG (assert test)
     305#endif
    134306
    135307  return sum;
    … …  
    416588  const ComponentID compIdx    = pcDtParam->compIdx;
    417589  assert(compIdx<MAX_NUM_COMPONENT);
    418   const WPScalingParam  wpCur    = pcDtParam->wpCur[compIdx];
     590  const WPScalingParam &wpCur  = pcDtParam->wpCur[compIdx];
    419591
    420592  Distortion uiSum = 0;

  • branches/HTM-15.2-dev/source/Lib/TLibCommon/TComRom.cpp

    r1321 r1360  
    4747//! \ingroup TLibCommon
    4848//! \{
    49 const Char* nalUnitTypeToString(NalUnitType type)
     49const TChar* nalUnitTypeToString(NalUnitType type)
    5050{
    5151  switch (type)
    … …  
    532532// Misc.
    533533// ====================================================================================================================
    534 Char  g_aucConvertToBit  [ MAX_CU_SIZE+1 ];
     534SChar  g_aucConvertToBit  [ MAX_CU_SIZE+1 ];
    535535#if ENC_DEC_TRACE
    536536FILE*  g_hTrace = NULL; // Set to NULL to open up a file. Set to stdout to use the current output
    537537const Bool g_bEncDecTraceEnable  = true;
    538538const Bool g_bEncDecTraceDisable = false;
    539 Bool   g_HLSTraceEnable = false;
     539Bool   g_HLSTraceEnable = true;
    540540Bool   g_bJustDoIt = false;
    541541UInt64 g_nSymbolCounter = 0;
    … …  
    582582const UInt g_uiMinInGroup[ LAST_SIGNIFICANT_GROUPS ] = {0,1,2,3,4,6,8,12,16,24};
    583583const UInt g_uiGroupIdx[ MAX_TU_SIZE ]   = {0,1,2,3,4,4,5,5,6,6,6,6,7,7,7,7,8,8,8,8,8,8,8,8,9,9,9,9,9,9,9,9};
    584 const Char *MatrixType[SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM] =
     584const TChar *MatrixType[SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM] =
    585585{
    586586  {
    … …  
    617617  },
    618618};
    619 const Char *MatrixType_DC[SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM] =
     619const TChar *MatrixType_DC[SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM] =
    620620{
    621621  {
    … …  
    673673#if H_MV_ENC_DEC_TRAC
    674674#if ENC_DEC_TRACE
    675 Void tracePSHeader( const Char* psName, Int layerId )
     675Void tracePSHeader( const TChar* psName, Int layerId )
    676676{ 
    677677  if ( !g_disableHLSTrace  )
    … …  
    727727  } 
    728728}
    729 Void writeToTraceFile( const Char* symbolName, Int val, Bool doIt )
     729Void writeToTraceFile( const TChar* symbolName, Int val, Bool doIt )
    730730{
    731731  if ( ( ( g_nSymbolCounter >= COUNTER_START && g_nSymbolCounter <= COUNTER_END )|| g_bJustDoIt ) && doIt  )
    … …  
    749749  return g_nSymbolCounter;
    750750}
    751 Void writeToTraceFile( const Char* symbolName, Bool doIt )
     751Void writeToTraceFile( const TChar* symbolName, Bool doIt )
    752752{
    753753  if ( ( ( g_nSymbolCounter >= COUNTER_START && g_nSymbolCounter <= COUNTER_END )|| g_bJustDoIt ) && doIt  )

  • branches/HTM-15.2-dev/source/Lib/TLibCommon/TComRom.h

    r1321 r1360  
    149149// Misc.
    150150// ====================================================================================================================
    151 extern       Char   g_aucConvertToBit  [ MAX_CU_SIZE+1 ];   // from width to log2(width)-2
     151extern       SChar   g_aucConvertToBit  [ MAX_CU_SIZE+1 ];   // from width to log2(width)-2
    152152#if NH_MV
    153153// Change later
    … …  
    206206#define D_PRINT_INC_INDENT( b, str ) prinStrIncIndent( b, str );
    207207#define D_PRINT_INDENT( b, str )     printStrIndent   ( b, str);
    208  Void           tracePSHeader   ( const Char* psName, Int layerId );
    209  Void           writeToTraceFile( const Char* symbolName, Int val, Bool doIt );
    210  Void           writeToTraceFile( const Char* symbolName, Bool doIt );
     208 Void           tracePSHeader   ( const TChar* psName, Int layerId );
     209 Void           writeToTraceFile( const TChar* symbolName, Int val, Bool doIt );
     210 Void           writeToTraceFile( const TChar* symbolName, Bool doIt );
    211211 UInt64         incSymbolCounter();         
    212212 Void           stopAtPos       ( Int poc, Int layerId, Int cuPelX, Int cuPelY, Int cuWidth, Int cuHeight );           
    … …  
    243243#endif
    244244#endif
    245 const Char* nalUnitTypeToString(NalUnitType type);
    246 extern const Char *MatrixType[SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM];
    247 extern const Char *MatrixType_DC[SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM];
     245const TChar* nalUnitTypeToString(NalUnitType type);
     246
     247extern const TChar *MatrixType[SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM];
     248extern const TChar *MatrixType_DC[SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM];
    248249extern const Int g_quantTSDefault4x4[4*4];
    249250extern const Int g_quantIntraDefault8x8[8*8];

  • branches/HTM-15.2-dev/source/Lib/TLibCommon/TComSampleAdaptiveOffset.cpp

    r1313 r1360  
    324324      m_signLineBuf1 = NULL;
    325325    }
    326     m_signLineBuf1 = new Char[m_lineBufWidth+1];
     326    m_signLineBuf1 = new SChar[m_lineBufWidth+1];
    327327
    328328    if (m_signLineBuf2)
    … …  
    331331      m_signLineBuf2 = NULL;
    332332    }
    333     m_signLineBuf2 = new Char[m_lineBufWidth+1];
     333    m_signLineBuf2 = new SChar[m_lineBufWidth+1];
    334334  }
    335335
    … …  
    338338  Int x,y, startX, startY, endX, endY, edgeType;
    339339  Int firstLineStartX, firstLineEndX, lastLineStartX, lastLineEndX;
    340   Char signLeft, signRight, signDown;
     340  SChar signLeft, signRight, signDown;
    341341
    342342  Pel* srcLine = srcBlk;
    … …  
    352352      for (y=0; y< height; y++)
    353353      {
    354         signLeft = (Char)sgn(srcLine[startX] - srcLine[startX-1]);
     354        signLeft = (SChar)sgn(srcLine[startX] - srcLine[startX-1]);
    355355        for (x=startX; x< endX; x++)
    356356        {
    357           signRight = (Char)sgn(srcLine[x] - srcLine[x+1]);
     357          signRight = (SChar)sgn(srcLine[x] - srcLine[x+1]);
    358358          edgeType =  signRight + signLeft;
    359359          signLeft  = -signRight;
    … …  
    370370    {
    371371      offset += 2;
    372       Char *signUpLine = m_signLineBuf1;
     372      SChar *signUpLine = m_signLineBuf1;
    373373
    374374      startY = isAboveAvail ? 0 : 1;
    … …  
    383383      for (x=0; x< width; x++)
    384384      {
    385         signUpLine[x] = (Char)sgn(srcLine[x] - srcLineAbove[x]);
     385        signUpLine[x] = (SChar)sgn(srcLine[x] - srcLineAbove[x]);
    386386      }
    387387
    … …  
    393393        for (x=0; x< width; x++)
    394394        {
    395           signDown  = (Char)sgn(srcLine[x] - srcLineBelow[x]);
     395          signDown  = (SChar)sgn(srcLine[x] - srcLineBelow[x]);
    396396          edgeType = signDown + signUpLine[x];
    397397          signUpLine[x]= -signDown;
    … …  
    408408    {
    409409      offset += 2;
    410       Char *signUpLine, *signDownLine, *signTmpLine;
     410      SChar *signUpLine, *signDownLine, *signTmpLine;
    411411
    412412      signUpLine  = m_signLineBuf1;
    … …  
    420420      for (x=startX; x< endX+1; x++)
    421421      {
    422         signUpLine[x] = (Char)sgn(srcLineBelow[x] - srcLine[x- 1]);
     422        signUpLine[x] = (SChar)sgn(srcLineBelow[x] - srcLine[x- 1]);
    423423      }
    424424
    … …  
    444444        for (x=startX; x<endX; x++)
    445445        {
    446           signDown =  (Char)sgn(srcLine[x] - srcLineBelow[x+ 1]);
     446          signDown =  (SChar)sgn(srcLine[x] - srcLineBelow[x+ 1]);
    447447          edgeType =  signDown + signUpLine[x];
    448448          resLine[x] = Clip3<Int>(0, maxSampleValueIncl, srcLine[x] + offset[edgeType]);
    … …  
    450450          signDownLine[x+1] = -signDown;
    451451        }
    452         signDownLine[startX] = (Char)sgn(srcLineBelow[startX] - srcLine[startX-1]);
     452        signDownLine[startX] = (SChar)sgn(srcLineBelow[startX] - srcLine[startX-1]);
    453453
    454454        signTmpLine  = signUpLine;
    … …  
    475475    {
    476476      offset += 2;
    477       Char *signUpLine = m_signLineBuf1+1;
     477      SChar *signUpLine = m_signLineBuf1+1;
    478478
    479479      startX = isLeftAvail ? 0 : 1;
    … …  
    484484      for (x=startX-1; x< endX; x++)
    485485      {
    486         signUpLine[x] = (Char)sgn(srcLineBelow[x] - srcLine[x+1]);
     486        signUpLine[x] = (SChar)sgn(srcLineBelow[x] - srcLine[x+1]);
    487487      }
    488488
    … …  
    507507        for(x= startX; x< endX; x++)
    508508        {
    509           signDown =  (Char)sgn(srcLine[x] - srcLineBelow[x-1]);
     509          signDown =  (SChar)sgn(srcLine[x] - srcLineBelow[x-1]);
    510510          edgeType =  signDown + signUpLine[x];
    511511          resLine[x] = Clip3<Int>(0, maxSampleValueIncl, srcLine[x] + offset[edgeType]);
    512512          signUpLine[x-1] = -signDown;
    513513        }
    514         signUpLine[endX-1] = (Char)sgn(srcLineBelow[endX-1] - srcLine[endX]);
     514        signUpLine[endX-1] = (SChar)sgn(srcLineBelow[endX-1] - srcLine[endX]);
    515515        srcLine  += srcStride;
    516516        resLine += resStride;

  • branches/HTM-15.2-dev/source/Lib/TLibCommon/TComSampleAdaptiveOffset.h

    r1313 r1360  
    9696
    9797  Int m_lineBufWidth;
    98   Char* m_signLineBuf1;
    99   Char* m_signLineBuf2;
     98  SChar* m_signLineBuf1;
     99  SChar* m_signLineBuf2;
    100100  ChromaFormat m_chromaFormatIDC;
    101101private:

  • branches/HTM-15.2-dev/source/Lib/TLibCommon/TComSlice.cpp

    r1321 r1360  
    452452Void TComSlice::setRefPicList( TComList<TComPic*>& rcListPic, Bool checkNumPocTotalCurr )
    453453{
    454   if (!checkNumPocTotalCurr)
    455   {
    456454    if (m_eSliceType == I_SLICE)
    457455    {
    … …  
    459457      ::memset( m_aiNumRefIdx,   0, sizeof ( m_aiNumRefIdx ));
    460458
     459    if (!checkNumPocTotalCurr)
     460    {
    461461      return;
    462462    }
    463 
    464     m_aiNumRefIdx[REF_PIC_LIST_0] = getNumRefIdx(REF_PIC_LIST_0);
    465     m_aiNumRefIdx[REF_PIC_LIST_1] = getNumRefIdx(REF_PIC_LIST_1);
    466463  }
    467464
    … …  
    536533    if (m_eSliceType == I_SLICE)
    537534    {
    538       ::memset( m_apcRefPicList, 0, sizeof (m_apcRefPicList));
    539       ::memset( m_aiNumRefIdx,   0, sizeof ( m_aiNumRefIdx ));
    540 
    541535      return;
    542536    }
    … …  
    545539    // general tier and level limit:
    546540    assert(numPicTotalCurr <= 8);
    547 
    548     m_aiNumRefIdx[0] = getNumRefIdx(REF_PIC_LIST_0);
    549     m_aiNumRefIdx[1] = getNumRefIdx(REF_PIC_LIST_1);
    550541  }
    551542
    … …  
    27672758    m_uiSpsMaxLatencyIncreasePlus1[i] = 0;
    27682759#else
    2769     m_uiMaxLatencyIncrease[i] = 0;
     2760    m_uiMaxLatencyIncreasePlus1[i] = 0;
    27702761#endif
    27712762    m_uiMaxDecPicBuffering[i] = 1;
    … …  
    45454536}
    45464537
    4547 Bool TComScalingList::xParseScalingList(Char* pchFile)
     4538Bool TComScalingList::xParseScalingList(const std::string &fileName)
    45484539{
    45494540  static const Int LINE_SIZE=1024;
    45504541  FILE *fp = NULL;
    4551   Char line[LINE_SIZE];
    4552 
    4553   if (pchFile == NULL)
     4542  TChar line[LINE_SIZE];
     4543
     4544  if (fileName.empty())
    45544545  {
    45554546    fprintf(stderr, "Error: no scaling list file specified. Help on scaling lists being output\n");
    … …  
    45604551    return true;
    45614552  }
    4562   else if ((fp = fopen(pchFile,"r")) == (FILE*)NULL)
    4563   {
    4564     fprintf(stderr, "Error: cannot open scaling list file %s for reading\n",pchFile);
     4553  else if ((fp = fopen(fileName.c_str(),"r")) == (FILE*)NULL)
     4554  {
     4555    fprintf(stderr, "Error: cannot open scaling list file %s for reading\n", fileName.c_str());
    45654556    return true;
    45664557  }
    … …  
    45904581          while ((!feof(fp)) && (!bFound))
    45914582          {
    4592             Char *ret = fgets(line, LINE_SIZE, fp);
    4593             Char *findNamePosition= ret==NULL ? NULL : strstr(line, MatrixType[sizeIdc][listIdc]);
     4583            TChar *ret = fgets(line, LINE_SIZE, fp);
     4584            TChar *findNamePosition= ret==NULL ? NULL : strstr(line, MatrixType[sizeIdc][listIdc]);
    45944585            // This could be a match against the DC string as well, so verify it isn't
    45954586            if (findNamePosition!= NULL && (MatrixType_DC[sizeIdc][listIdc]==NULL || strstr(line, MatrixType_DC[sizeIdc][listIdc])==NULL))
    … …  
    46004591          if (!bFound)
    46014592          {
    4602             fprintf(stderr, "Error: cannot find Matrix %s from scaling list file %s\n", MatrixType[sizeIdc][listIdc], pchFile);
     4593            fprintf(stderr, "Error: cannot find Matrix %s from scaling list file %s\n", MatrixType[sizeIdc][listIdc], fileName.c_str());
    46034594            return true;
    46044595          }
    … …  
    46094600          if (fscanf(fp, "%d,", &data)!=1)
    46104601          {
    4611             fprintf(stderr, "Error: cannot read value #%d for Matrix %s from scaling list file %s at file position %ld\n", i, MatrixType[sizeIdc][listIdc], pchFile, ftell(fp));
     4602            fprintf(stderr, "Error: cannot read value #%d for Matrix %s from scaling list file %s at file position %ld\n", i, MatrixType[sizeIdc][listIdc], fileName.c_str(), ftell(fp));
    46124603            return true;
    46134604          }
    46144605          if (data<0 || data>255)
    46154606          {
    4616             fprintf(stderr, "Error: QMatrix entry #%d of value %d for Matrix %s from scaling list file %s at file position %ld is out of range (0 to 255)\n", i, data, MatrixType[sizeIdc][listIdc], pchFile, ftell(fp));
     4607            fprintf(stderr, "Error: QMatrix entry #%d of value %d for Matrix %s from scaling list file %s at file position %ld is out of range (0 to 255)\n", i, data, MatrixType[sizeIdc][listIdc], fileName.c_str(), ftell(fp));
    46174608            return true;
    46184609          }
    … …  
    46304621            while ((!feof(fp)) && (!bFound))
    46314622            {
    4632               Char *ret = fgets(line, LINE_SIZE, fp);
    4633               Char *findNamePosition= ret==NULL ? NULL : strstr(line, MatrixType_DC[sizeIdc][listIdc]);
     4623              TChar *ret = fgets(line, LINE_SIZE, fp);
     4624              TChar *findNamePosition= ret==NULL ? NULL : strstr(line, MatrixType_DC[sizeIdc][listIdc]);
    46344625              if (findNamePosition!= NULL)
    46354626              {
    … …  
    46404631            if (!bFound)
    46414632            {
    4642               fprintf(stderr, "Error: cannot find DC Matrix %s from scaling list file %s\n", MatrixType_DC[sizeIdc][listIdc], pchFile);
     4633              fprintf(stderr, "Error: cannot find DC Matrix %s from scaling list file %s\n", MatrixType_DC[sizeIdc][listIdc], fileName.c_str());
    46434634              return true;
    46444635            }
    … …  
    46474638          if (fscanf(fp, "%d,", &data)!=1)
    46484639          {
    4649             fprintf(stderr, "Error: cannot read DC %s from scaling list file %s at file position %ld\n", MatrixType_DC[sizeIdc][listIdc], pchFile, ftell(fp));
     4640            fprintf(stderr, "Error: cannot read DC %s from scaling list file %s at file position %ld\n", MatrixType_DC[sizeIdc][listIdc], fileName.c_str(), ftell(fp));
    46504641            return true;
    46514642          }
    46524643          if (data<0 || data>255)
    46534644          {
    4654             fprintf(stderr, "Error: DC value %d for Matrix %s from scaling list file %s at file position %ld is out of range (0 to 255)\n", data, MatrixType[sizeIdc][listIdc], pchFile, ftell(fp));
     4645            fprintf(stderr, "Error: DC value %d for Matrix %s from scaling list file %s at file position %ld is out of range (0 to 255)\n", data, MatrixType[sizeIdc][listIdc], fileName.c_str(), ftell(fp));
    46554646            return true;
    46564647          }

  • branches/HTM-15.2-dev/source/Lib/TLibCommon/TComSlice.h

    r1321 r1360  
    292292  Void       checkDcOfMatrix();
    293293  Void       processRefMatrix(UInt sizeId, UInt listId , UInt refListId );
    294   Bool       xParseScalingList(Char* pchFile);
     294  Bool       xParseScalingList(const std::string &fileName);
    295295#if NH_MV
    296296  Void       inferFrom                      ( const TComScalingList& srcScLi );
    … …  
    14261426#endif
    14271427
    1428   template <typename T, typename S, typename U> Void xPrintArray( const Char* name, Int numElemDim1, U idx, S numElemDim2, T vec, Bool printNumber, Bool printIdx = true ) const
     1428  template <typename T, typename S, typename U> Void xPrintArray( const TChar* name, Int numElemDim1, U idx, S numElemDim2, T vec, Bool printNumber, Bool printIdx = true ) const
    14291429  {
    14301430    std::cout << std::endl;
    … …  
    19551955#if NH_MV
    19561956  UInt             m_uiSpsMaxLatencyIncreasePlus1[MAX_TLAYER]; 
    1957   // Calling a member m_uiMaxLatencyIncrease although it is m_uiMaxLatencyIncreasePlus1 is really bad style. 
    19581957#else
    1959   UInt             m_uiMaxLatencyIncrease[MAX_TLAYER];  // Really max latency increase plus 1 (value 0 expresses no limit)
     1958  UInt             m_uiMaxLatencyIncreasePlus1[MAX_TLAYER];
    19601959#endif
    19611960
    … …  
    21352134  Bool                   getScalingListPresentFlag() const                                               { return m_scalingListPresentFlag;                                     }
    21362135  Void                   setScalingListPresentFlag( Bool b )                                             { m_scalingListPresentFlag  = b;                                       }
    2137   Void                   setScalingList( TComScalingList *scalingList);
    21382136  TComScalingList&       getScalingList()                                                                { return m_scalingList;                                                }
    21392137  const TComScalingList& getScalingList() const                                                          { return m_scalingList;                                                }
    … …  
    21462144  Int                    getSpsMaxLatencyPictures( Int i )  const                                       { return ( getSpsMaxNumReorderPics(i) + getSpsMaxLatencyIncreasePlus1(i)-1); }
    21472145#else
    2148   UInt                   getMaxLatencyIncrease(UInt tlayer) const                                        { return m_uiMaxLatencyIncrease[tlayer];                               }
    2149   Void                   setMaxLatencyIncrease( UInt ui , UInt tlayer)                                   { m_uiMaxLatencyIncrease[tlayer] = ui;                                 }
     2146  UInt                   getMaxLatencyIncreasePlus1(UInt tlayer) const                                   { return m_uiMaxLatencyIncreasePlus1[tlayer];                          }
     2147  Void                   setMaxLatencyIncreasePlus1( UInt ui , UInt tlayer)                              { m_uiMaxLatencyIncreasePlus1[tlayer] = ui;                            }
    21502148#endif
    21512149
    … …  
    21662164  const TComSPSRExt&     getSpsRangeExtension() const                                                    { return m_spsRangeExtension;                                          }
    21672165  TComSPSRExt&           getSpsRangeExtension()                                                          { return m_spsRangeExtension;                                          }
    2168 
    2169   // Sequence parameter set range extension syntax
    2170   // WAS: getUseResidualRotation and setUseResidualRotation
    2171   // Now getSpsRangeExtension().getTransformSkipRotationEnabledFlag and getSpsRangeExtension().setTransformSkipRotationEnabledFlag
    2172 
    2173   // WAS: getUseSingleSignificanceMapContext and setUseSingleSignificanceMapContext
    2174   // Now: getSpsRangeExtension().getTransformSkipContextEnabledFlag and getSpsRangeExtension().setTransformSkipContextEnabledFlag
    2175 
    2176   // WAS: getUseResidualDPCM and setUseResidualDPCM
    2177   // Now: getSpsRangeExtension().getRdpcmEnabledFlag and getSpsRangeExtension().setRdpcmEnabledFlag and
    2178 
    2179   // WAS: getUseExtendedPrecision and setUseExtendedPrecision
    2180   // Now: getSpsRangeExtension().getExtendedPrecisionProcessingFlag and getSpsRangeExtension().setExtendedPrecisionProcessingFlag
    2181 
    2182   // WAS: getDisableIntraReferenceSmoothing and setDisableIntraReferenceSmoothing
    2183   // Now: getSpsRangeExtension().getIntraSmoothingDisabledFlag and getSpsRangeExtension().setIntraSmoothingDisabledFlag
    2184 
    2185   // WAS: getUseHighPrecisionPredictionWeighting and setUseHighPrecisionPredictionWeighting
    2186   // Now: getSpsRangeExtension().getHighPrecisionOffsetsEnabledFlag and getSpsRangeExtension().setHighPrecisionOffsetsEnabledFlag
    2187 
    2188   // WAS: getUseGolombRiceParameterAdaptation and setUseGolombRiceParameterAdaptation
    2189   // Now: getSpsRangeExtension().getPersistentRiceAdaptationEnabledFlag and getSpsRangeExtension().setPersistentRiceAdaptationEnabledFlag
    2190 
    2191   // WAS: getAlignCABACBeforeBypass and setAlignCABACBeforeBypass
    2192   // Now: getSpsRangeExtension().getCabacBypassAlignmentEnabledFlag and getSpsRangeExtension().setCabacBypassAlignmentEnabledFlag
    2193 
    21942166
    21952167#if NH_MV
    … …  
    22992271  Void    setListEntryL0( Int i, Int  val )                      { m_RefPicSetIdxL0[i] = val;                                          }
    23002272  Void    setListEntryL1( Int i, Int  val )                      { m_RefPicSetIdxL1[i] = val;                                          }
    2301 
    2302 
    2303 #endif
     2273#endif
     2274
    23042275};
     2276
    23052277
    23062278/// PPS RExt class
    … …  
    25572529  TComPPSRExt&           getPpsRangeExtension()                                           { return m_ppsRangeExtension;                   }
    25582530
    2559   // WAS: getTransformSkipLog2MaxSize and setTransformSkipLog2MaxSize
    2560   // Now: getPpsRangeExtension().getLog2MaxTransformSkipBlockSize and getPpsRangeExtension().setLog2MaxTransformSkipBlockSize
    2561 
    2562   // WAS: getUseCrossComponentPrediction and setUseCrossComponentPrediction
    2563   // Now: getPpsRangeExtension().getCrossComponentPredictionEnabledFlag and getPpsRangeExtension().setCrossComponentPredictionEnabledFlag
    2564 
    2565   // WAS: clearChromaQpAdjTable
    2566   // Now: getPpsRangeExtension().clearChromaQpOffsetList
    2567 
    2568   // WAS: getMaxCuChromaQpAdjDepth and setMaxCuChromaQpAdjDepth
    2569   // Now: getPpsRangeExtension().getDiffCuChromaQpOffsetDepth and getPpsRangeExtension().setDiffCuChromaQpOffsetDepth
    2570 
    2571   // WAS: getChromaQpAdjTableSize
    2572   // Now: getPpsRangeExtension().getChromaQpOffsetListLen
    2573 
    2574   // WAS: getChromaQpAdjTableAt and setChromaQpAdjTableAt
    2575   // Now: getPpsRangeExtension().getChromaQpOffsetListEntry and getPpsRangeExtension().setChromaQpOffsetListEntry
    2576 
    2577   // WAS: getSaoOffsetBitShift and setSaoOffsetBitShift
    2578   // Now: getPpsRangeExtension().getLog2SaoOffsetScale and getPpsRangeExtension().setLog2SaoOffsetScale
    2579 
    25802531#if NH_MV
    25812532  Void    setLayerId( Int  val )                                                     { m_layerId = val;                                           }
    … …  
    28762827  Int                         getPOC() const                                         { return m_iPOC;                                                }
    28772828  Int                         getSliceQp() const                                     { return m_iSliceQp;                                            }
     2829  Bool                        getUseWeightedPrediction() const                       { return( (m_eSliceType==P_SLICE && testWeightPred()) || (m_eSliceType==B_SLICE && testWeightBiPred()) ); }
    28782830  Bool                        getDependentSliceSegmentFlag() const                   { return m_dependentSliceSegmentFlag;                           }
    28792831  Void                        setDependentSliceSegmentFlag(Bool val)                 { m_dependentSliceSegmentFlag = val;                            }
    … …  
    28922844  TComPic*                    getPic()                                               { return m_pcPic;                                               }
    28932845  TComPic*                    getRefPic( RefPicList e, Int iRefIdx)                  { return m_apcRefPicList[e][iRefIdx];                           }
    2894   Int                         getRefPOC( RefPicList e, Int iRefIdx)                  { return m_aiRefPOCList[e][iRefIdx];                            }
     2846  const TComPic*              getRefPic( RefPicList e, Int iRefIdx) const            { return m_apcRefPicList[e][iRefIdx];                           }
     2847  Int                         getRefPOC( RefPicList e, Int iRefIdx) const            { return m_aiRefPOCList[e][iRefIdx];                            }
    28952848#if NH_3D
    28962849  Bool                        getInCmpPredAvailFlag( )                 const         { return m_inCmpPredAvailFlag;                                  }
    … …  
    31803133
    31813134  Void                        setEnableTMVPFlag( Bool   b )                          { m_enableTMVPFlag = b;                                         }
    3182   Bool                        getEnableTMVPFlag()                                    { return m_enableTMVPFlag;                                      }
     3135  Bool                        getEnableTMVPFlag() const                              { return m_enableTMVPFlag;                                      }
    31833136
    31843137  Void                        setEncCABACTableIdx( SliceType idx )                   { m_encCABACTableIdx = idx;                                     }

  • branches/HTM-15.2-dev/source/Lib/TLibCommon/TComWeightPrediction.cpp

    r1313 r1360  
    5555}
    5656
     57static inline Pel noWeightUnidir( Pel P0, Int round, Int shift, Int offset, Int clipBD)
     58{
     59  return ClipBD( ( ((P0 + IF_INTERNAL_OFFS) + round) >> shift ) + offset, clipBD );
     60}
     61
     62static inline Pel noWeightOffsetUnidir( Pel P0, Int round, Int shift, Int clipBD)
     63{
     64  return ClipBD( ( ((P0 + IF_INTERNAL_OFFS) + round) >> shift ), clipBD );
     65}
     66
     67
    5768// ====================================================================================================================
    5869// Class definition
    … …  
    154165    const Int  shiftNum    = std::max<Int>(2, (IF_INTERNAL_PREC - clipBD));
    155166    const Int  shift       = wp0[compID].shift + shiftNum;
    156     const Int  round       = (shift > 0) ? (1<<(shift-1)) : 0;
    157167    const UInt iSrc0Stride = pcYuvSrc0->getStride(compID);
    158168    const UInt iDstStride  = pcYuvDst->getStride(compID);
    … …  
    162172    const Int  iWidth      = uiWidth>>csx;
    163173
     174    if (w0 != 1 << wp0[compID].shift)
     175    {
     176      const Int  round       = (shift > 0) ? (1<<(shift-1)) : 0;
    164177    for (Int y = iHeight-1; y >= 0; y-- )
    165178    {
    … …  
    178191      pSrc0 += iSrc0Stride;
    179192      pDst  += iDstStride;
     193    }
     194  }
     195    else
     196    {
     197      const Int  round       = (shiftNum > 0) ? (1<<(shiftNum-1)) : 0;
     198      if (offset == 0)
     199      {
     200        for (Int y = iHeight-1; y >= 0; y-- )
     201        {
     202          Int x = iWidth-1;
     203          for ( ; x >= 3; )
     204          {
     205            pDst[x] = noWeightOffsetUnidir(pSrc0[x], round, shiftNum, clipBD); x--;
     206            pDst[x] = noWeightOffsetUnidir(pSrc0[x], round, shiftNum, clipBD); x--;
     207            pDst[x] = noWeightOffsetUnidir(pSrc0[x], round, shiftNum, clipBD); x--;
     208            pDst[x] = noWeightOffsetUnidir(pSrc0[x], round, shiftNum, clipBD); x--;
     209          }
     210          for( ; x >= 0; x--)
     211          {
     212            pDst[x] = noWeightOffsetUnidir(pSrc0[x], round, shiftNum, clipBD);
     213          }
     214          pSrc0 += iSrc0Stride;
     215          pDst  += iDstStride;
     216        }
     217      }
     218      else
     219      {
     220        for (Int y = iHeight-1; y >= 0; y-- )
     221        {
     222          Int x = iWidth-1;
     223          for ( ; x >= 3; )
     224          {
     225            pDst[x] = noWeightUnidir(pSrc0[x], round, shiftNum, offset, clipBD); x--;
     226            pDst[x] = noWeightUnidir(pSrc0[x], round, shiftNum, offset, clipBD); x--;
     227            pDst[x] = noWeightUnidir(pSrc0[x], round, shiftNum, offset, clipBD); x--;
     228            pDst[x] = noWeightUnidir(pSrc0[x], round, shiftNum, offset, clipBD); x--;
     229          }
     230          for( ; x >= 0; x--)
     231          {
     232            pDst[x] = noWeightUnidir(pSrc0[x], round, shiftNum, offset, clipBD);
     233          }
     234          pSrc0 += iSrc0Stride;
     235          pDst  += iDstStride;
     236        }
     237      }
    180238    }
    181239  }
    … …  
    197255        TComSlice *const pcSlice  = pcCU->getSlice();
    198256  const Bool             wpBiPred = pcCU->getSlice()->getPPS()->getWPBiPred();
    199   const Bool             bBiDir   = (iRefIdx0>=0 && iRefIdx1>=0);
    200   const Bool             bUniDir  = !bBiDir;
    201 
    202   if ( bUniDir || wpBiPred )
     257  const Bool             bBiPred  = (iRefIdx0>=0 && iRefIdx1>=0);
     258  const Bool             bUniPred = !bBiPred;
     259
     260  if ( bUniPred || wpBiPred )
    203261  { // explicit --------------------
    204262    if ( iRefIdx0 >= 0 )
    … …  
    228286  const Bool bUseHighPrecisionPredictionWeighting = pcSlice->getSPS()->getSpsRangeExtension().getHighPrecisionOffsetsEnabledFlag();
    229287
    230   if ( bBiDir )
    231   { // Bi-Dir case
     288  if ( bBiPred )
     289  { // Bi-predictive case
    232290    for ( Int yuv=0 ; yuv<numValidComponent ; yuv++ )
    233291    {
    … …  
    248306  }
    249307  else
    250   {  // Unidir
     308  {  // UniPred
    251309    WPScalingParam *const pwp = (iRefIdx0>=0) ? wp0 : wp1 ;
    252310

  • branches/HTM-15.2-dev/source/Lib/TLibCommon/TypeDef.h

    r1356 r1360  
    3232 */
    3333/** \file     TypeDef.h
    34     \brief    Define basic types, new types and enumerations
     34    \brief    Define macros, basic types, new types and enumerations
    3535*/
    3636#ifndef __TYPEDEF__
    … …  
    373373#define DECODER_CHECK_SUBSTREAM_AND_SLICE_TRAILING_BYTES  1 ///< TODO: integrate this macro into a broader conformance checking system.
    374374#define T0196_SELECTIVE_RDOQ                              1 ///< selective RDOQ
     375#define U0040_MODIFIED_WEIGHTEDPREDICTION_WITH_BIPRED_AND_CLIPPING 1
     376
    375377// ====================================================================================================================
    376378// Tool Switches
    … …  
    389391#define MATRIX_MULT                                       0 ///< Brute force matrix multiplication instead of partial butterfly
    390392#define O0043_BEST_EFFORT_DECODING                        0 ///< 0 (default) = disable code related to best effort decoding, 1 = enable code relating to best effort decoding [ decode-side only ].
     393
     394#define ME_ENABLE_ROUNDING_OF_MVS                         1 ///< 0 (default) = disables rounding of motion vectors when right shifted,  1 = enables rounding
     395
    391396#define RDOQ_CHROMA_LAMBDA                                1 ///< F386: weighting of chroma for RDOQ
    392397// This can be enabled by the makefile
    … …  
    394399#define RExt__HIGH_BIT_DEPTH_SUPPORT                                           0 ///< 0 (default) use data type definitions for 8-10 bit video, 1 = use larger data types to allow for up to 16-bit video (originally developed as part of N0188)
    395400#endif
     401
     402#define U0132_TARGET_BITS_SATURATION                      1 ///< Rate control with target bits saturation method
     403
    396404// ====================================================================================================================
    397405// Derived macros
    … …  
    443451typedef       void                Void;
    444452typedef       bool                Bool;
    445 #ifdef __arm__
    446 typedef       signed char         Char;
    447 #else
    448 typedef       char                Char;
    449 #endif
    450 typedef       unsigned char       UChar;
     453
     454typedef       char                TChar; // Used for text/characters
     455typedef       signed char         SChar; // Signed 8-bit values
     456typedef       unsigned char       UChar; // Unsigned 8-bit values
    451457typedef       short               Short;
    452458typedef       unsigned short      UShort;
    … …  
    577583  NUMBER_INPUT_COLOUR_SPACE_CONVERSIONS = 4
    578584};
     585
     586enum MATRIX_COEFFICIENTS // Table E.5 (Matrix coefficients)
     587{
     588  MATRIX_COEFFICIENTS_RGB                           = 0,
     589  MATRIX_COEFFICIENTS_BT709                         = 1,
     590  MATRIX_COEFFICIENTS_UNSPECIFIED                   = 2,
     591  MATRIX_COEFFICIENTS_RESERVED_BY_ITUISOIEC         = 3,
     592  MATRIX_COEFFICIENTS_USFCCT47                      = 4,
     593  MATRIX_COEFFICIENTS_BT601_625                     = 5,
     594  MATRIX_COEFFICIENTS_BT601_525                     = 6,
     595  MATRIX_COEFFICIENTS_SMPTE240                      = 7,
     596  MATRIX_COEFFICIENTS_YCGCO                         = 8,
     597  MATRIX_COEFFICIENTS_BT2020_NON_CONSTANT_LUMINANCE = 9,
     598  MATRIX_COEFFICIENTS_BT2020_CONSTANT_LUMINANCE     = 10,
     599};
     600
    579601enum DeblockEdgeDir
    580602{
    … …  
    713735enum MESearchMethod
    714736{
    715   FULL_SEARCH                = 0,     ///< Full search
    716   DIAMOND                    = 1,     ///< Fast search
    717   SELECTIVE                  = 2      ///< Selective search
     737  MESEARCH_FULL              = 0,
     738  MESEARCH_DIAMOND           = 1,
     739  MESEARCH_SELECTIVE         = 2,
     740  MESEARCH_DIAMOND_ENHANCED  = 3,
     741  MESEARCH_NUMBER_OF_METHODS = 4
    718742};
    719743/// coefficient scanning type used in ACS
    … …  
    760784  FIXED_NUMBER_OF_BYTES  = 2,          ///< Limit maximum number of bytes in a slice / slice segment
    761785  FIXED_NUMBER_OF_TILES  = 3,          ///< slices / slice segments span an integer number of tiles
    762 };
     786  NUMBER_OF_SLICE_CONSTRAINT_MODES = 4
     787};
     788
     789// For use with decoded picture hash SEI messages, generated by encoder.
     790enum HashType
     791{
     792  HASHTYPE_MD5             = 0,
     793  HASHTYPE_CRC             = 1,
     794  HASHTYPE_CHECKSUM        = 2,
     795  HASHTYPE_NONE            = 3,
     796  NUMBER_OF_HASHTYPES      = 4
     797};
     798
    763799enum SAOMode //mode
    764800{
    … …  
    861897  COST_MIXED_LOSSLESS_LOSSY_CODING = 3
    862898};
     899
     900enum WeightedPredictionMethod
     901{
     902  WP_PER_PICTURE_WITH_SIMPLE_DC_COMBINED_COMPONENT                          =0,
     903  WP_PER_PICTURE_WITH_SIMPLE_DC_PER_COMPONENT                               =1,
     904  WP_PER_PICTURE_WITH_HISTOGRAM_AND_PER_COMPONENT                           =2,
     905  WP_PER_PICTURE_WITH_HISTOGRAM_AND_PER_COMPONENT_AND_CLIPPING              =3,
     906  WP_PER_PICTURE_WITH_HISTOGRAM_AND_PER_COMPONENT_AND_CLIPPING_AND_EXTENSION=4
     907};
     908
     909enum FastInterSearchMode
     910{
     911  FASTINTERSEARCH_DISABLED = 0,
     912  FASTINTERSEARCH_MODE1    = 1, // TODO: assign better names to these.
     913  FASTINTERSEARCH_MODE2    = 2,
     914  FASTINTERSEARCH_MODE3    = 3
     915};
     916
    863917enum SPSExtensionFlagIndex
    864918{

  • branches/HTM-15.2-dev/source/Lib/TLibDecoder/SEIread.cpp

    r1356 r1360  
    6363#endif
    6464
    65 Void SEIReader::sei_read_code(std::ostream *pOS, UInt uiLength, UInt& ruiCode, const Char *pSymbolName)
     65Void SEIReader::sei_read_code(std::ostream *pOS, UInt uiLength, UInt& ruiCode, const TChar *pSymbolName)
    6666{
    6767  READ_CODE(uiLength, ruiCode, pSymbolName);
    … …  
    7272}
    7373
    74 Void SEIReader::sei_read_uvlc(std::ostream *pOS, UInt& ruiCode, const Char *pSymbolName)
     74Void SEIReader::sei_read_uvlc(std::ostream *pOS, UInt& ruiCode, const TChar *pSymbolName)
    7575{
    7676  READ_UVLC(ruiCode, pSymbolName);
    … …  
    8181}
    8282
    83 Void SEIReader::sei_read_svlc(std::ostream *pOS, Int& ruiCode, const Char *pSymbolName)
     83Void SEIReader::sei_read_svlc(std::ostream *pOS, Int& ruiCode, const TChar *pSymbolName)
    8484{
    8585  READ_SVLC(ruiCode, pSymbolName);
    … …  
    9090}
    9191
    92 Void SEIReader::sei_read_flag(std::ostream *pOS, UInt& ruiCode, const Char *pSymbolName)
     92Void SEIReader::sei_read_flag(std::ostream *pOS, UInt& ruiCode, const TChar *pSymbolName)
    9393{
    9494  READ_FLAG(ruiCode, pSymbolName);
    … …  
    9999}
    100100
    101 Void SEIReader::sei_read_string(std::ostream *pOS, UInt uiBufSize, UChar* pucCode, UInt& ruiLength, const Char *pSymbolName)
     101#if NH_MV_SEI
     102Void SEIReader::sei_read_string(std::ostream *pOS, UInt uiBufSize, UChar* pucCode, UInt& ruiLength, const TChar *pSymbolName)
    102103{
    103104  READ_STRING(uiBufSize, pucCode, ruiLength, pSymbolName);
    … …  
    107108  }
    108109}
    109 
    110 #if NH_MV_SEI
    111110inline Void SEIReader::output_sei_message_header(SEI &sei, std::ostream *pDecodedMessageOutputStream, UInt payloadSize)
    112111#else
    … …  
    295294      xParseSEITimeCode((SEITimeCode&) *sei, payloadSize, pDecodedMessageOutputStream);
    296295      break;
    297     case SEI::CHROMA_SAMPLING_FILTER_HINT:
    298       sei = new SEIChromaSamplingFilterHint;
    299       xParseSEIChromaSamplingFilterHint((SEIChromaSamplingFilterHint&) *sei, payloadSize/*, sps*/, pDecodedMessageOutputStream);
     296    case SEI::CHROMA_RESAMPLING_FILTER_HINT:
     297      sei = new SEIChromaResamplingFilterHint;
     298      xParseSEIChromaResamplingFilterHint((SEIChromaResamplingFilterHint&) *sei, payloadSize, pDecodedMessageOutputStream);
    300299      //}
    301300      break;
    … …  
    303302      sei = new SEIKneeFunctionInfo;
    304303      xParseSEIKneeFunctionInfo((SEIKneeFunctionInfo&) *sei, payloadSize, pDecodedMessageOutputStream);
     304      break;
     305    case SEI::COLOUR_REMAPPING_INFO:
     306      sei = new SEIColourRemappingInfo;
     307      xParseSEIColourRemappingInfo((SEIColourRemappingInfo&) *sei, payloadSize, pDecodedMessageOutputStream);
    305308      break;
    306309    case SEI::MASTERING_DISPLAY_COLOUR_VOLUME:
    … …  
    531534  UInt val;
    532535  sei_read_code( pDecodedMessageOutputStream, 8, val, "hash_type");
    533   sei.method = static_cast<SEIDecodedPictureHash::Method>(val); bytesRead++;
    534 
    535   const Char *traceString="\0";
     536  sei.method = static_cast<HashType>(val); bytesRead++;
     537
     538  const TChar *traceString="\0";
    536539  switch (sei.method)
    537540  {
    538     case SEIDecodedPictureHash::MD5: traceString="picture_md5"; break;
    539     case SEIDecodedPictureHash::CRC: traceString="picture_crc"; break;
    540     case SEIDecodedPictureHash::CHECKSUM: traceString="picture_checksum"; break;
     541    case HASHTYPE_MD5: traceString="picture_md5"; break;
     542    case HASHTYPE_CRC: traceString="picture_crc"; break;
     543    case HASHTYPE_CHECKSUM: traceString="picture_checksum"; break;
    541544    default: assert(false); break;
    542545  }
    … …  
    11231126}
    11241127
    1125 Void SEIReader::xParseSEIChromaSamplingFilterHint(SEIChromaSamplingFilterHint& sei, UInt payloadSize/*, TComSPS* sps*/, std::ostream *pDecodedMessageOutputStream)
     1128Void SEIReader::xParseSEIChromaResamplingFilterHint(SEIChromaResamplingFilterHint& sei, UInt payloadSize, std::ostream *pDecodedMessageOutputStream)
    11261129{
    11271130  UInt uiCode;
    … …  
    11301133  sei_read_code( pDecodedMessageOutputStream, 8, uiCode, "ver_chroma_filter_idc"); sei.m_verChromaFilterIdc = uiCode;
    11311134  sei_read_code( pDecodedMessageOutputStream, 8, uiCode, "hor_chroma_filter_idc"); sei.m_horChromaFilterIdc = uiCode;
    1132   sei_read_flag( pDecodedMessageOutputStream, uiCode, "ver_filtering_process_flag"); sei.m_verFilteringProcessFlag = uiCode;
     1135  sei_read_flag( pDecodedMessageOutputStream, uiCode, "ver_filtering_field_processing_flag"); sei.m_verFilteringFieldProcessingFlag = uiCode;
    11331136  if(sei.m_verChromaFilterIdc == 1 || sei.m_horChromaFilterIdc == 1)
    11341137  {
    … …  
    11361139    if(sei.m_verChromaFilterIdc == 1)
    11371140    {
    1138       sei_read_uvlc( pDecodedMessageOutputStream, uiCode, "num_vertical_filters"); sei.m_numVerticalFilters = uiCode;
    1139       if(sei.m_numVerticalFilters > 0)
    1140       {
    1141         sei.m_verTapLengthMinus1 = (Int*)malloc(sei.m_numVerticalFilters * sizeof(Int));
    1142         sei.m_verFilterCoeff = (Int**)malloc(sei.m_numVerticalFilters * sizeof(Int*));
    1143         for(Int i = 0; i < sei.m_numVerticalFilters; i ++)
    1144         {
    1145           sei_read_uvlc( pDecodedMessageOutputStream, uiCode, "ver_tap_length_minus_1"); sei.m_verTapLengthMinus1[i] = uiCode;
    1146           sei.m_verFilterCoeff[i] = (Int*)malloc(sei.m_verTapLengthMinus1[i] * sizeof(Int));
    1147           for(Int j = 0; j < sei.m_verTapLengthMinus1[i]; j ++)
     1141      UInt numVerticalFilters;
     1142      sei_read_uvlc( pDecodedMessageOutputStream, numVerticalFilters, "num_vertical_filters"); sei.m_verFilterCoeff.resize(numVerticalFilters);
     1143      if(numVerticalFilters > 0)
     1144      {
     1145        for(Int i = 0; i < numVerticalFilters; i++)
     1146        {
     1147          UInt verTapLengthMinus1;
     1148          sei_read_uvlc( pDecodedMessageOutputStream, verTapLengthMinus1, "ver_tap_length_minus_1"); sei.m_verFilterCoeff[i].resize(verTapLengthMinus1+1);
     1149          for(Int j = 0; j < (verTapLengthMinus1 + 1); j++)
    11481150          {
    11491151            sei_read_svlc( pDecodedMessageOutputStream, sei.m_verFilterCoeff[i][j], "ver_filter_coeff");
    … …  
    11541156    if(sei.m_horChromaFilterIdc == 1)
    11551157    {
    1156       sei_read_uvlc( pDecodedMessageOutputStream, uiCode, "num_horizontal_filters"); sei.m_numHorizontalFilters = uiCode;
    1157       if(sei.m_numHorizontalFilters  > 0)
    1158       {
    1159         sei.m_horTapLengthMinus1 = (Int*)malloc(sei.m_numHorizontalFilters * sizeof(Int));
    1160         sei.m_horFilterCoeff = (Int**)malloc(sei.m_numHorizontalFilters * sizeof(Int*));
    1161         for(Int i = 0; i < sei.m_numHorizontalFilters; i ++)
    1162         {
    1163           sei_read_uvlc( pDecodedMessageOutputStream, uiCode, "hor_tap_length_minus_1"); sei.m_horTapLengthMinus1[i] = uiCode;
    1164           sei.m_horFilterCoeff[i] = (Int*)malloc(sei.m_horTapLengthMinus1[i] * sizeof(Int));
    1165           for(Int j = 0; j < sei.m_horTapLengthMinus1[i]; j ++)
     1158      UInt numHorizontalFilters;
     1159      sei_read_uvlc( pDecodedMessageOutputStream, numHorizontalFilters, "num_horizontal_filters"); sei.m_horFilterCoeff.resize(numHorizontalFilters);
     1160      if(numHorizontalFilters  > 0)
     1161      {
     1162        for(Int i = 0; i < numHorizontalFilters; i++)
     1163        {
     1164          UInt horTapLengthMinus1;
     1165          sei_read_uvlc( pDecodedMessageOutputStream, horTapLengthMinus1, "hor_tap_length_minus_1"); sei.m_horFilterCoeff[i].resize(horTapLengthMinus1+1);
     1166          for(Int j = 0; j < (horTapLengthMinus1 + 1); j++)
    11661167          {
    11671168            sei_read_svlc( pDecodedMessageOutputStream, sei.m_horFilterCoeff[i][j], "hor_filter_coeff");
    … …  
    11991200  }
    12001201}
     1202
     1203Void SEIReader::xParseSEIColourRemappingInfo(SEIColourRemappingInfo& sei, UInt payloadSize, std::ostream *pDecodedMessageOutputStream)
     1204{
     1205  UInt  uiVal;
     1206  Int   iVal;
     1207  output_sei_message_header(sei, pDecodedMessageOutputStream, payloadSize);
     1208
     1209  sei_read_uvlc( pDecodedMessageOutputStream, uiVal, "colour_remap_id" );          sei.m_colourRemapId = uiVal;
     1210  sei_read_flag( pDecodedMessageOutputStream, uiVal, "colour_remap_cancel_flag" ); sei.m_colourRemapCancelFlag = uiVal;
     1211  if( !sei.m_colourRemapCancelFlag )
     1212  {
     1213    sei_read_flag( pDecodedMessageOutputStream, uiVal, "colour_remap_persistence_flag" );                sei.m_colourRemapPersistenceFlag = uiVal;
     1214    sei_read_flag( pDecodedMessageOutputStream, uiVal, "colour_remap_video_signal_info_present_flag" );  sei.m_colourRemapVideoSignalInfoPresentFlag = uiVal;
     1215    if ( sei.m_colourRemapVideoSignalInfoPresentFlag )
     1216    {
     1217      sei_read_flag( pDecodedMessageOutputStream, uiVal,    "colour_remap_full_range_flag" );            sei.m_colourRemapFullRangeFlag = uiVal;
     1218      sei_read_code( pDecodedMessageOutputStream, 8, uiVal, "colour_remap_primaries" );                  sei.m_colourRemapPrimaries = uiVal;
     1219      sei_read_code( pDecodedMessageOutputStream, 8, uiVal, "colour_remap_transfer_function" );          sei.m_colourRemapTransferFunction = uiVal;
     1220      sei_read_code( pDecodedMessageOutputStream, 8, uiVal, "colour_remap_matrix_coefficients" );        sei.m_colourRemapMatrixCoefficients = uiVal;
     1221    }
     1222    sei_read_code( pDecodedMessageOutputStream, 8, uiVal, "colour_remap_input_bit_depth" );              sei.m_colourRemapInputBitDepth = uiVal;
     1223    sei_read_code( pDecodedMessageOutputStream, 8, uiVal, "colour_remap_bit_depth" );                    sei.m_colourRemapBitDepth = uiVal;
     1224 
     1225    for( Int c=0 ; c<3 ; c++ )
     1226    {
     1227      sei_read_code( pDecodedMessageOutputStream, 8, uiVal, "pre_lut_num_val_minus1[c]" ); sei.m_preLutNumValMinus1[c] = (uiVal==0) ? 1 : uiVal;
     1228      sei.m_preLut[c].resize(sei.m_preLutNumValMinus1[c]+1);
     1229      if( uiVal> 0 )
     1230      {
     1231        for ( Int i=0 ; i<=sei.m_preLutNumValMinus1[c] ; i++ )
     1232        {
     1233          sei_read_code( pDecodedMessageOutputStream, (( sei.m_colourRemapInputBitDepth   + 7 ) >> 3 ) << 3, uiVal, "pre_lut_coded_value[c][i]" );  sei.m_preLut[c][i].codedValue  = uiVal;
     1234          sei_read_code( pDecodedMessageOutputStream, (( sei.m_colourRemapBitDepth + 7 ) >> 3 ) << 3, uiVal, "pre_lut_target_value[c][i]" ); sei.m_preLut[c][i].targetValue = uiVal;
     1235        }
     1236      }
     1237      else // pre_lut_num_val_minus1[c] == 0
     1238      {
     1239        sei.m_preLut[c][0].codedValue  = 0;
     1240        sei.m_preLut[c][0].targetValue = 0;
     1241        sei.m_preLut[c][1].codedValue  = (1 << sei.m_colourRemapInputBitDepth) - 1 ;
     1242        sei.m_preLut[c][1].targetValue = (1 << sei.m_colourRemapBitDepth) - 1 ;
     1243      }
     1244    }
     1245
     1246    sei_read_flag( pDecodedMessageOutputStream, uiVal,      "colour_remap_matrix_present_flag" ); sei.m_colourRemapMatrixPresentFlag = uiVal;
     1247    if( sei.m_colourRemapMatrixPresentFlag )
     1248    {
     1249      sei_read_code( pDecodedMessageOutputStream, 4, uiVal, "log2_matrix_denom" ); sei.m_log2MatrixDenom = uiVal;
     1250      for ( Int c=0 ; c<3 ; c++ )
     1251      {
     1252        for ( Int i=0 ; i<3 ; i++ )
     1253        {
     1254          sei_read_svlc( pDecodedMessageOutputStream, iVal, "colour_remap_coeffs[c][i]" ); sei.m_colourRemapCoeffs[c][i] = iVal;
     1255        }
     1256      }
     1257    }
     1258    else // setting default matrix (I3)
     1259    {
     1260      sei.m_log2MatrixDenom = 10;
     1261      for ( Int c=0 ; c<3 ; c++ )
     1262      {
     1263        for ( Int i=0 ; i<3 ; i++ )
     1264        {
     1265          sei.m_colourRemapCoeffs[c][i] = (c==i) << sei.m_log2MatrixDenom;
     1266        }
     1267      }
     1268    }
     1269    for( Int c=0 ; c<3 ; c++ )
     1270    {
     1271      sei_read_code( pDecodedMessageOutputStream, 8, uiVal, "post_lut_num_val_minus1[c]" ); sei.m_postLutNumValMinus1[c] = (uiVal==0) ? 1 : uiVal;
     1272      sei.m_postLut[c].resize(sei.m_postLutNumValMinus1[c]+1);
     1273      if( uiVal > 0 )
     1274      {
     1275        for ( Int i=0 ; i<=sei.m_postLutNumValMinus1[c] ; i++ )
     1276        {
     1277          sei_read_code( pDecodedMessageOutputStream, (( sei.m_colourRemapBitDepth + 7 ) >> 3 ) << 3, uiVal, "post_lut_coded_value[c][i]" );  sei.m_postLut[c][i].codedValue = uiVal;
     1278          sei_read_code( pDecodedMessageOutputStream, (( sei.m_colourRemapBitDepth + 7 ) >> 3 ) << 3, uiVal, "post_lut_target_value[c][i]" ); sei.m_postLut[c][i].targetValue = uiVal;
     1279        }
     1280      }
     1281      else
     1282      {
     1283        sei.m_postLut[c][0].codedValue  = 0;
     1284        sei.m_postLut[c][0].targetValue = 0;
     1285        sei.m_postLut[c][1].targetValue = (1 << sei.m_colourRemapBitDepth) - 1;
     1286        sei.m_postLut[c][1].codedValue  = (1 << sei.m_colourRemapBitDepth) - 1;
     1287      }
     1288    }
     1289  }
     1290}
     1291
    12011292
    12021293Void SEIReader::xParseSEIMasteringDisplayColourVolume(SEIMasteringDisplayColourVolume& sei, UInt payloadSize, std::ostream *pDecodedMessageOutputStream)

  • branches/HTM-15.2-dev/source/Lib/TLibDecoder/SEIread.h

    r1356 r1360  
    9393  Void xParseSEITempMotionConstraintsTileSets (SEITempMotionConstrainedTileSets& sei, UInt payloadSize,                     std::ostream *pDecodedMessageOutputStream);
    9494  Void xParseSEITimeCode                      (SEITimeCode& sei,                      UInt payloadSize,                     std::ostream *pDecodedMessageOutputStream);
    95   Void xParseSEIChromaSamplingFilterHint      (SEIChromaSamplingFilterHint& sei,      UInt payloadSize/*,TComSPS* */,       std::ostream *pDecodedMessageOutputStream);
     95  Void xParseSEIChromaResamplingFilterHint    (SEIChromaResamplingFilterHint& sei,    UInt payloadSize,                     std::ostream *pDecodedMessageOutputStream);
    9696  Void xParseSEIKneeFunctionInfo              (SEIKneeFunctionInfo& sei,              UInt payloadSize,                     std::ostream *pDecodedMessageOutputStream);
    9797  Void xParseSEIMasteringDisplayColourVolume  (SEIMasteringDisplayColourVolume& sei,  UInt payloadSize,                     std::ostream *pDecodedMessageOutputStream);
     98  Void xParseSEIColourRemappingInfo           (SEIColourRemappingInfo& sei,           UInt payloadSize,                     std::ostream *pDecodedMessageOutputStream);
    9899#if NH_MV
    99100#if !NH_MV_SEI
    … …  
    133134#endif
    134135
    135   Void sei_read_code(std::ostream *pOS, UInt uiLength, UInt& ruiCode, const Char *pSymbolName);
    136   Void sei_read_uvlc(std::ostream *pOS,                UInt& ruiCode, const Char *pSymbolName);
    137   Void sei_read_svlc(std::ostream *pOS,                Int&  ruiCode, const Char *pSymbolName);
    138   Void sei_read_flag(std::ostream *pOS,                UInt& ruiCode, const Char *pSymbolName);
    139   Void sei_read_string(std::ostream *pOS, UInt uiBufSize, UChar* pucCode, UInt& ruiLength, const Char *pSymbolName);
     136  Void sei_read_code(std::ostream *pOS, UInt uiLength, UInt& ruiCode, const TChar *pSymbolName);
     137  Void sei_read_uvlc(std::ostream *pOS,                UInt& ruiCode, const TChar *pSymbolName);
     138  Void sei_read_svlc(std::ostream *pOS,                Int&  ruiCode, const TChar *pSymbolName);
     139  Void sei_read_flag(std::ostream *pOS,                UInt& ruiCode, const TChar *pSymbolName);
     140  Void sei_read_string(std::ostream *pOS, UInt uiBufSize, UChar* pucCode, UInt& ruiLength, const TChar *pSymbolName);
    140141#if NH_MV_SEI
    141142  inline Void output_sei_message_header(SEI &sei, std::ostream *pDecodedMessageOutputStream, UInt payloadSize);

  • branches/HTM-15.2-dev/source/Lib/TLibDecoder/SyntaxElementParser.cpp

    r1356 r1360  
    4949#if ENC_DEC_TRACE
    5050
    51 Void  SyntaxElementParser::xReadCodeTr           (UInt length, UInt& rValue, const Char *pSymbolName)
     51Void  SyntaxElementParser::xReadCodeTr           (UInt length, UInt& rValue, const TChar *pSymbolName)
    5252{
    5353#if RExt__DECODER_DEBUG_BIT_STATISTICS
    … …  
    8080}
    8181
    82 Void  SyntaxElementParser::xReadUvlcTr           (UInt& rValue, const Char *pSymbolName)
     82Void  SyntaxElementParser::xReadUvlcTr           (UInt& rValue, const TChar *pSymbolName)
    8383{
    8484#if RExt__DECODER_DEBUG_BIT_STATISTICS
    … …  
    104104}
    105105
    106 Void  SyntaxElementParser::xReadSvlcTr           (Int& rValue, const Char *pSymbolName)
     106Void  SyntaxElementParser::xReadSvlcTr           (Int& rValue, const TChar *pSymbolName)
    107107{
    108108#if RExt__DECODER_DEBUG_BIT_STATISTICS
    … …  
    128128}
    129129
    130 Void  SyntaxElementParser::xReadFlagTr           (UInt& rValue, const Char *pSymbolName)
     130Void  SyntaxElementParser::xReadFlagTr           (UInt& rValue, const TChar *pSymbolName)
    131131{
    132132#if RExt__DECODER_DEBUG_BIT_STATISTICS
    … …  
    152152}
    153153
    154 Void  SyntaxElementParser::xReadStringTr        (UInt buSize, UChar *pValue, UInt& rLength, const Char *pSymbolName)
     154#if NH_MV
     155Void  SyntaxElementParser::xReadStringTr        (UInt buSize, UChar *pValue, UInt& rLength, const TChar *pSymbolName)
    155156{
    156157#if RExt__DECODER_DEBUG_BIT_STATISTICS
    … …  
    163164  fflush ( g_hTrace );
    164165}
    165 
     166#endif
    166167Void  xTraceAccessUnitDelimiter ()
    167168{
    … …  
    181182// ====================================================================================================================
    182183#if RExt__DECODER_DEBUG_BIT_STATISTICS
    183 Void SyntaxElementParser::xReadCode (UInt uiLength, UInt& ruiCode, const Char *pSymbolName)
     184Void SyntaxElementParser::xReadCode (UInt uiLength, UInt& ruiCode, const TChar *pSymbolName)
    184185#else
    185186Void SyntaxElementParser::xReadCode (UInt uiLength, UInt& ruiCode)
    … …  
    194195
    195196#if RExt__DECODER_DEBUG_BIT_STATISTICS
    196 Void SyntaxElementParser::xReadUvlc( UInt& ruiVal, const Char *pSymbolName)
     197Void SyntaxElementParser::xReadUvlc( UInt& ruiVal, const TChar *pSymbolName)
    197198#else
    198199Void SyntaxElementParser::xReadUvlc( UInt& ruiVal)
    … …  
    232233
    233234#if RExt__DECODER_DEBUG_BIT_STATISTICS
    234 Void SyntaxElementParser::xReadSvlc( Int& riVal, const Char *pSymbolName)
     235Void SyntaxElementParser::xReadSvlc( Int& riVal, const TChar *pSymbolName)
    235236#else
    236237Void SyntaxElementParser::xReadSvlc( Int& riVal)
    … …  
    270271
    271272#if RExt__DECODER_DEBUG_BIT_STATISTICS
    272 Void SyntaxElementParser::xReadFlag (UInt& ruiCode, const Char *pSymbolName)
     273Void SyntaxElementParser::xReadFlag (UInt& ruiCode, const TChar *pSymbolName)
    273274#else
    274275Void SyntaxElementParser::xReadFlag (UInt& ruiCode)
    … …  
    281282}
    282283
    283 #if RExt__DECODER_DEBUG_BIT_STATISTICS
    284 Void  SyntaxElementParser::xReadString  (UInt bufSize, UChar *pVal, UInt& rLength, const Char *pSymbolName)
     284#if NH_MV
     285#if RExt__DECODER_DEBUG_BIT_STATISTICS
     286Void  SyntaxElementParser::xReadString  (UInt bufSize, UChar *pVal, UInt& rLength, const TChar *pSymbolName)
    285287#else
    286288Void  SyntaxElementParser::xReadString  (UInt bufSize, UChar *pVal, UInt& rLength)
    … …  
    302304  assert( pVal[rLength] == 0 ); 
    303305}
     306#endif
    304307
    305308Void SyntaxElementParser::xReadRbspTrailingBits()

  • branches/HTM-15.2-dev/source/Lib/TLibDecoder/SyntaxElementParser.h

    r1356 r1360  
    9191
    9292#if RExt__DECODER_DEBUG_BIT_STATISTICS
    93   Void  xReadCode    ( UInt   length, UInt& val, const Char *pSymbolName );
    94   Void  xReadUvlc    ( UInt&  val, const Char *pSymbolName );
    95   Void  xReadSvlc    ( Int&   val, const Char *pSymbolName );
    96   Void  xReadFlag    ( UInt&  val, const Char *pSymbolName );
    97   Void  xReadString  ( UInt bufSize, UChar *val, UInt& length, const Char *pSymbolName);
     93  Void  xReadCode    ( UInt   length, UInt& val, const TChar *pSymbolName );
     94  Void  xReadUvlc    ( UInt&  val, const TChar *pSymbolName );
     95  Void  xReadSvlc    ( Int&   val, const TChar *pSymbolName );
     96  Void  xReadFlag    ( UInt&  val, const TChar *pSymbolName );
     97#if NH_MV
     98  Void  xReadString  ( UInt bufSize, UChar *val, UInt& length, const TChar *pSymbolName);
     99#endif
    98100#else
    99101  Void  xReadCode    ( UInt   length, UInt& val );
    … …  
    101103  Void  xReadSvlc    ( Int&   val );
    102104  Void  xReadFlag    ( UInt&  val );
     105#if NH_MV
    103106  Void  xReadString  ( UInt bufSize, UChar *val, UInt& length);
    104107#endif
     108#endif
    105109#if ENC_DEC_TRACE
    106   Void  xReadCodeTr  (UInt  length, UInt& rValue, const Char *pSymbolName);
    107   Void  xReadUvlcTr  (              UInt& rValue, const Char *pSymbolName);
    108   Void  xReadSvlcTr  (               Int& rValue, const Char *pSymbolName);
    109   Void  xReadFlagTr  (              UInt& rValue, const Char *pSymbolName);
    110   Void  xReadStringTr(UInt bufSize, UChar *pValue, UInt& rLength, const Char *pSymbolName);
     110  Void  xReadCodeTr  (UInt  length, UInt& rValue, const TChar *pSymbolName);
     111  Void  xReadUvlcTr  (              UInt& rValue, const TChar *pSymbolName);
     112  Void  xReadSvlcTr  (               Int& rValue, const TChar *pSymbolName);
     113  Void  xReadFlagTr  (              UInt& rValue, const TChar *pSymbolName);
     114#if NH_MV
     115  Void  xReadStringTr(UInt bufSize, UChar *pValue, UInt& rLength, const TChar *pSymbolName);
     116#endif
    111117#endif
    112118public:

  • branches/HTM-15.2-dev/source/Lib/TLibDecoder/TDecBinCoderCABAC.cpp

    r1313 r1360  
    169169  if (g_debugCounter >= debugCabacBinTargetLine)
    170170  {
    171     Char breakPointThis;
     171    UChar breakPointThis;
    172172    breakPointThis = 7;
    173173  }

  • branches/HTM-15.2-dev/source/Lib/TLibDecoder/TDecCAVLC.cpp

    r1321 r1360  
    454454#else
    455455#if ENC_DEC_TRACE || RExt__DECODER_DEBUG_BIT_STATISTICS
    456     static const char *syntaxStrings[]={ "pps_range_extension_flag",
     456    static const TChar *syntaxStrings[]={ "pps_range_extension_flag",
    457457                                         "pps_multilayer_extension_flag",
    458458                                         "pps_extension_6bits[0]",
    … …  
    10171017    pcSPS->setSpsMaxLatencyIncreasePlus1( uiCode, i );
    10181018#else
    1019     pcSPS->setMaxLatencyIncrease( uiCode, i );
     1019    pcSPS->setMaxLatencyIncreasePlus1( uiCode, i );
    10201020#endif
    10211021
    … …  
    10291029        pcSPS->setSpsMaxLatencyIncreasePlus1(pcSPS->getSpsMaxLatencyIncreasePlus1(0), i);
    10301030#else
    1031         pcSPS->setMaxLatencyIncrease(pcSPS->getMaxLatencyIncrease(0), i);
     1031        pcSPS->setMaxLatencyIncreasePlus1(pcSPS->getMaxLatencyIncreasePlus1(0), i);
    10321032#endif
    10331033      }
    … …  
    12061206
    12071207#if ENC_DEC_TRACE || RExt__DECODER_DEBUG_BIT_STATISTICS
    1208     static const char *syntaxStrings[]={ "sps_range_extension_flag",
     1208    static const TChar *syntaxStrings[]={ "sps_range_extension_flag",
    12091209                                         "sps_multilayer_extension_flag",
    12101210                                         "sps_extension_6bits[0]",

  • branches/HTM-15.2-dev/source/Lib/TLibDecoder/TDecEntropy.cpp

    r1321 r1360  
    505505#endif
    506506
    507       UInt uiMergeIndex = pcCU->getMergeIndex(uiSubPartIdx);
     507      const UInt uiMergeIndex = pcCU->getMergeIndex(uiSubPartIdx);
    508508      if ( pcCU->getSlice()->getPPS()->getLog2ParallelMergeLevelMinus2() && ePartSize != SIZE_2Nx2N && pcSubCU->getWidth( 0 ) <= 8 )
    509509      {
    … …  
    547547      else
    548548      {
    549         uiMergeIndex = pcCU->getMergeIndex(uiSubPartIdx);
    550549
    551550#if NH_3D_MLC

  • branches/HTM-15.2-dev/source/Lib/TLibDecoder/TDecGop.cpp

    r1313 r1360  
    177177  pcPic->compressMotion();
    178178#endif
    179   Char c = (pcSlice->isIntra() ? 'I' : pcSlice->isInterP() ? 'P' : 'B');
     179  TChar c = (pcSlice->isIntra() ? 'I' : pcSlice->isInterP() ? 'P' : 'B');
    180180  if (!pcSlice->isReferenced())
    181181  {
    … …  
    255255  TComPictureHash recon_digest;
    256256  Int numChar=0;
    257   const Char* hashType = "\0";
     257  const TChar* hashType = "\0";
    258258
    259259  if (pictureHashSEI)
    … …  
    261261    switch (pictureHashSEI->method)
    262262    {
    263       case SEIDecodedPictureHash::MD5:
     263      case HASHTYPE_MD5:
    264264        {
    265265          hashType = "MD5";
    … …  
    267267          break;
    268268        }
    269       case SEIDecodedPictureHash::CRC:
     269      case HASHTYPE_CRC:
    270270        {
    271271          hashType = "CRC";
    … …  
    273273          break;
    274274        }
    275       case SEIDecodedPictureHash::CHECKSUM:
     275      case HASHTYPE_CHECKSUM:
    276276        {
    277277          hashType = "Checksum";
    … …  
    288288
    289289  /* compare digest against received version */
    290   const Char* ok = "(unk)";
     290  const TChar* ok = "(unk)";
    291291  Bool mismatch = false;
    292292

  • branches/HTM-15.2-dev/source/Lib/TLibDecoder/TDecSbac.cpp

    r1313 r1360  
    11941194  if (!pcCU->isIntra(uiAbsPartIdx) || (pcCU->getIntraDir( CHANNEL_TYPE_CHROMA, uiAbsPartIdx ) == DM_CHROMA_IDX))
    11951195  {
    1196     Char alpha = 0;
     1196    SChar alpha = 0;
    11971197    UInt symbol = 0;
    11981198

  • branches/HTM-15.2-dev/source/Lib/TLibEncoder/AnnexBwrite.h

    r1313 r1360  
    6060    UInt size = 0; /* size of annexB unit in bytes */
    6161
    62     static const Char start_code_prefix[] = {0,0,0,1};
     62    static const UChar start_code_prefix[] = {0,0,0,1};
    6363    if (it == au.begin() || nalu.m_nalUnitType == NAL_UNIT_VPS || nalu.m_nalUnitType == NAL_UNIT_SPS || nalu.m_nalUnitType == NAL_UNIT_PPS)
    6464    {
    … …  
    7171       *    7.4.1.2.3.
    7272       */
    73       out.write(start_code_prefix, 4);
     73      out.write(reinterpret_cast<const TChar*>(start_code_prefix), 4);
    7474      size += 4;
    7575    }
    7676    else
    7777    {
    78       out.write(start_code_prefix+1, 3);
     78      out.write(reinterpret_cast<const TChar*>(start_code_prefix+1), 3);
    7979      size += 3;
    8080    }

  • branches/HTM-15.2-dev/source/Lib/TLibEncoder/NALwrite.cpp

    r1313 r1360  
    4545//! \{
    4646
    47 static const Char emulation_prevention_three_byte[] = {3};
     47static const UChar emulation_prevention_three_byte[] = {3};
    4848
    4949Void writeNalUnitHeader(ostream& out, OutputNALUnit& nalu)       // nal_unit_header()
    … …  
    6060  bsNALUHeader.write(nalu.m_temporalId+1, 3); // nuh_temporal_id_plus1
    6161
    62   out.write(bsNALUHeader.getByteStream(), bsNALUHeader.getByteStreamLength());
     62  out.write(reinterpret_cast<const TChar*>(bsNALUHeader.getByteStream()), bsNALUHeader.getByteStreamLength());
    6363}
    6464/**
    … …  
    124124    outputBuffer[outputAmount++]=emulation_prevention_three_byte[0];
    125125  }
    126   out.write((Char*)&(*outputBuffer.begin()), outputAmount);
     126  out.write(reinterpret_cast<const TChar*>(&(*outputBuffer.begin())), outputAmount);
    127127}
    128128

  • branches/HTM-15.2-dev/source/Lib/TLibEncoder/SEIEncoder.cpp

    r1356 r1360  
    294294  assert (pcPic!=NULL);
    295295
    296   if(m_pcCfg->getDecodedPictureHashSEIEnabled() == 1)
    297   {
    298     decodedPictureHashSEI->method = SEIDecodedPictureHash::MD5;
     296  decodedPictureHashSEI->method = m_pcCfg->getDecodedPictureHashSEIType();
     297  switch (m_pcCfg->getDecodedPictureHashSEIType())
     298  {
     299    case HASHTYPE_MD5:
     300  {
    299301    UInt numChar=calcMD5(*pcPic->getPicYuvRec(), decodedPictureHashSEI->m_pictureHash, bitDepths);
    300302    rHashString = hashToString(decodedPictureHashSEI->m_pictureHash, numChar);
    301303  }
    302   else if(m_pcCfg->getDecodedPictureHashSEIEnabled() == 2)
    303   {
    304     decodedPictureHashSEI->method = SEIDecodedPictureHash::CRC;
     304      break;
     305    case HASHTYPE_CRC:
     306  {
    305307    UInt numChar=calcCRC(*pcPic->getPicYuvRec(), decodedPictureHashSEI->m_pictureHash, bitDepths);
    306308    rHashString = hashToString(decodedPictureHashSEI->m_pictureHash, numChar);
    307309  }
    308   else if(m_pcCfg->getDecodedPictureHashSEIEnabled() == 3)
    309   {
    310     decodedPictureHashSEI->method = SEIDecodedPictureHash::CHECKSUM;
     310      break;
     311    case HASHTYPE_CHECKSUM:
     312    default:
     313  {
    311314    UInt numChar=calcChecksum(*pcPic->getPicYuvRec(), decodedPictureHashSEI->m_pictureHash, bitDepths);
    312315    rHashString = hashToString(decodedPictureHashSEI->m_pictureHash, numChar);
     316  }
     317      break;
    313318  }
    314319}
    … …  
    397402  }
    398403}
    399 
    400 Void SEIEncoder::initSEIChromaSamplingFilterHint(SEIChromaSamplingFilterHint *seiChromaSamplingFilterHint, Int iHorFilterIndex, Int iVerFilterIndex)
    401 {
    402   assert (m_isInitialized);
    403   assert (seiChromaSamplingFilterHint!=NULL);
    404 
    405   seiChromaSamplingFilterHint->m_verChromaFilterIdc = iVerFilterIndex;
    406   seiChromaSamplingFilterHint->m_horChromaFilterIdc = iHorFilterIndex;
    407   seiChromaSamplingFilterHint->m_verFilteringProcessFlag = 1;
    408   seiChromaSamplingFilterHint->m_targetFormatIdc = 3;
    409   seiChromaSamplingFilterHint->m_perfectReconstructionFlag = false;
    410   if(seiChromaSamplingFilterHint->m_verChromaFilterIdc == 1)
    411   {
    412     seiChromaSamplingFilterHint->m_numVerticalFilters = 1;
    413     seiChromaSamplingFilterHint->m_verTapLengthMinus1 = (Int*)malloc(seiChromaSamplingFilterHint->m_numVerticalFilters * sizeof(Int));
    414     seiChromaSamplingFilterHint->m_verFilterCoeff =    (Int**)malloc(seiChromaSamplingFilterHint->m_numVerticalFilters * sizeof(Int*));
    415     for(Int i = 0; i < seiChromaSamplingFilterHint->m_numVerticalFilters; i ++)
    416     {
    417       seiChromaSamplingFilterHint->m_verTapLengthMinus1[i] = 0;
    418       seiChromaSamplingFilterHint->m_verFilterCoeff[i] = (Int*)malloc(seiChromaSamplingFilterHint->m_verTapLengthMinus1[i] * sizeof(Int));
    419       for(Int j = 0; j < seiChromaSamplingFilterHint->m_verTapLengthMinus1[i]; j ++)
    420       {
    421         seiChromaSamplingFilterHint->m_verFilterCoeff[i][j] = 0;
    422       }
    423     }
     404template <typename T>
     405static Void readTokenValue(T            &returnedValue, /// value returned
     406                           Bool         &failed,        /// used and updated
     407                           std::istream &is,            /// stream to read token from
     408                           const TChar  *pToken)        /// token string
     409{
     410  returnedValue=T();
     411  if (failed)
     412  {
     413    return;
     414  }
     415
     416  Int c;
     417  // Ignore any whitespace
     418  while ((c=is.get())!=EOF && isspace(c));
     419  // test for comment mark
     420  while (c=='#')
     421  {
     422    // Ignore to the end of the line
     423    while ((c=is.get())!=EOF && (c!=10 && c!=13));
     424    // Ignore any white space at the start of the next line
     425    while ((c=is.get())!=EOF && isspace(c));
     426  }
     427  // test first character of token
     428  failed=(c!=pToken[0]);
     429  // test remaining characters of token
     430  Int pos;
     431  for(pos=1;!failed && pToken[pos]!=0 && is.get()==pToken[pos]; pos++);
     432  failed|=(pToken[pos]!=0);
     433  // Ignore any whitespace before the ':'
     434  while (!failed && (c=is.get())!=EOF && isspace(c));
     435  failed|=(c!=':');
     436  // Now read the value associated with the token:
     437  if (!failed)
     438  {
     439    is >> returnedValue;
     440    failed=!is.good();
     441    if (!failed)
     442    {
     443      c=is.get();
     444      failed=(c!=EOF && !isspace(c));
     445    }
     446  }
     447  if (failed)
     448  {
     449    std::cerr << "Unable to read token '" << pToken << "'\n";
     450  }
     451}
     452
     453template <typename T>
     454static Void readTokenValueAndValidate(T            &returnedValue, /// value returned
     455                                      Bool         &failed,        /// used and updated
     456                                      std::istream &is,            /// stream to read token from
     457                                      const TChar  *pToken,        /// token string
     458                                      const T      &minInclusive,  /// minimum value allowed, inclusive
     459                                      const T      &maxInclusive)  /// maximum value allowed, inclusive
     460{
     461  readTokenValue(returnedValue, failed, is, pToken);
     462  if (!failed)
     463  {
     464    if (returnedValue<minInclusive || returnedValue>maxInclusive)
     465    {
     466      failed=true;
     467      std::cerr << "Value for token " << pToken << " must be in the range " << minInclusive << " to " << maxInclusive << " (inclusive); value read: " << returnedValue << std::endl;
     468    }
     469  }
     470}
     471
     472// Bool version does not have maximum and minimum values.
     473static Void readTokenValueAndValidate(Bool         &returnedValue, /// value returned
     474                                      Bool         &failed,        /// used and updated
     475                                      std::istream &is,            /// stream to read token from
     476                                      const TChar  *pToken)        /// token string
     477{
     478  readTokenValue(returnedValue, failed, is, pToken);
     479}
     480
     481Bool SEIEncoder::initSEIColourRemappingInfo(SEIColourRemappingInfo* seiColourRemappingInfo, Int currPOC) // returns true on success, false on failure.
     482{
     483  assert (m_isInitialized);
     484  assert (seiColourRemappingInfo!=NULL);
     485
     486  // reading external Colour Remapping Information SEI message parameters from file
     487  if( !m_pcCfg->getColourRemapInfoSEIFileRoot().empty())
     488  {
     489    Bool failed=false;
     490
     491    // building the CRI file name with poc num in prefix "_poc.txt"
     492    std::string colourRemapSEIFileWithPoc(m_pcCfg->getColourRemapInfoSEIFileRoot());
     493    {
     494      std::stringstream suffix;
     495      suffix << "_" << currPOC << ".txt";
     496      colourRemapSEIFileWithPoc+=suffix.str();
     497    }
     498
     499    std::ifstream fic(colourRemapSEIFileWithPoc.c_str());
     500    if (!fic.good() || !fic.is_open())
     501    {
     502      std::cerr <<  "No Colour Remapping Information SEI parameters file " << colourRemapSEIFileWithPoc << " for POC " << currPOC << std::endl;
     503      return false;
     504    }
     505
     506    // TODO: identify and remove duplication with decoder parsing through abstraction.
     507
     508    readTokenValueAndValidate(seiColourRemappingInfo->m_colourRemapId,         failed, fic, "colour_remap_id",        UInt(0), UInt(0x7fffffff) );
     509    readTokenValueAndValidate(seiColourRemappingInfo->m_colourRemapCancelFlag, failed, fic, "colour_remap_cancel_flag" );
     510    if( !seiColourRemappingInfo->m_colourRemapCancelFlag )
     511    {
     512      readTokenValueAndValidate(seiColourRemappingInfo->m_colourRemapPersistenceFlag,            failed, fic, "colour_remap_persistence_flag" );
     513      readTokenValueAndValidate(seiColourRemappingInfo->m_colourRemapVideoSignalInfoPresentFlag, failed, fic, "colour_remap_video_signal_info_present_flag");
     514      if( seiColourRemappingInfo->m_colourRemapVideoSignalInfoPresentFlag )
     515      {
     516        readTokenValueAndValidate(seiColourRemappingInfo->m_colourRemapFullRangeFlag,      failed, fic, "colour_remap_full_range_flag" );
     517        readTokenValueAndValidate(seiColourRemappingInfo->m_colourRemapPrimaries,          failed, fic, "colour_remap_primaries",           Int(0), Int(255) );
     518        readTokenValueAndValidate(seiColourRemappingInfo->m_colourRemapTransferFunction,   failed, fic, "colour_remap_transfer_function",   Int(0), Int(255) );
     519        readTokenValueAndValidate(seiColourRemappingInfo->m_colourRemapMatrixCoefficients, failed, fic, "colour_remap_matrix_coefficients", Int(0), Int(255) );
     520      }
     521      readTokenValueAndValidate(seiColourRemappingInfo->m_colourRemapInputBitDepth, failed, fic, "colour_remap_input_bit_depth",            Int(8), Int(16) );
     522      readTokenValueAndValidate(seiColourRemappingInfo->m_colourRemapBitDepth,      failed, fic, "colour_remap_bit_depth",                  Int(8), Int(16) );
     523
     524      const Int maximumInputValue    = (1 << (((seiColourRemappingInfo->m_colourRemapInputBitDepth + 7) >> 3) << 3)) - 1;
     525      const Int maximumRemappedValue = (1 << (((seiColourRemappingInfo->m_colourRemapBitDepth      + 7) >> 3) << 3)) - 1;
     526
     527      for( Int c=0 ; c<3 ; c++ )
     528      {
     529        readTokenValueAndValidate(seiColourRemappingInfo->m_preLutNumValMinus1[c],         failed, fic, "pre_lut_num_val_minus1[c]",        Int(0), Int(32) );
     530        if( seiColourRemappingInfo->m_preLutNumValMinus1[c]>0 )
     531        {
     532          seiColourRemappingInfo->m_preLut[c].resize(seiColourRemappingInfo->m_preLutNumValMinus1[c]+1);
     533          for( Int i=0 ; i<=seiColourRemappingInfo->m_preLutNumValMinus1[c] ; i++ )
     534          {
     535            readTokenValueAndValidate(seiColourRemappingInfo->m_preLut[c][i].codedValue,   failed, fic, "pre_lut_coded_value[c][i]",  Int(0), maximumInputValue    );
     536            readTokenValueAndValidate(seiColourRemappingInfo->m_preLut[c][i].targetValue,  failed, fic, "pre_lut_target_value[c][i]", Int(0), maximumRemappedValue );
     537          }
     538        }
     539      }
     540      readTokenValueAndValidate(seiColourRemappingInfo->m_colourRemapMatrixPresentFlag, failed, fic, "colour_remap_matrix_present_flag" );
     541      if( seiColourRemappingInfo->m_colourRemapMatrixPresentFlag )
     542      {
     543        readTokenValueAndValidate(seiColourRemappingInfo->m_log2MatrixDenom, failed, fic, "log2_matrix_denom", Int(0), Int(15) );
     544        for( Int c=0 ; c<3 ; c++ )
     545        {
     546          for( Int i=0 ; i<3 ; i++ )
     547          {
     548            readTokenValueAndValidate(seiColourRemappingInfo->m_colourRemapCoeffs[c][i], failed, fic, "colour_remap_coeffs[c][i]", -32768, 32767 );
     549          }
     550        }
     551      }
     552      for( Int c=0 ; c<3 ; c++ )
     553      {
     554        readTokenValueAndValidate(seiColourRemappingInfo->m_postLutNumValMinus1[c], failed, fic, "post_lut_num_val_minus1[c]", Int(0), Int(32) );
     555        if( seiColourRemappingInfo->m_postLutNumValMinus1[c]>0 )
     556        {
     557          seiColourRemappingInfo->m_postLut[c].resize(seiColourRemappingInfo->m_postLutNumValMinus1[c]+1);
     558          for( Int i=0 ; i<=seiColourRemappingInfo->m_postLutNumValMinus1[c] ; i++ )
     559          {
     560            readTokenValueAndValidate(seiColourRemappingInfo->m_postLut[c][i].codedValue,  failed, fic, "post_lut_coded_value[c][i]",  Int(0), maximumRemappedValue );
     561            readTokenValueAndValidate(seiColourRemappingInfo->m_postLut[c][i].targetValue, failed, fic, "post_lut_target_value[c][i]", Int(0), maximumRemappedValue );
     562          }
     563        }
     564      }
     565    }
     566
     567    if( failed )
     568    {
     569      std::cerr << "Error while reading Colour Remapping Information SEI parameters file '" << colourRemapSEIFileWithPoc << "'" << std::endl;
     570      exit(EXIT_FAILURE);
     571    }
     572  }
     573  return true;
     574}
     575
     576
     577Void SEIEncoder::initSEIChromaResamplingFilterHint(SEIChromaResamplingFilterHint *seiChromaResamplingFilterHint, Int iHorFilterIndex, Int iVerFilterIndex)
     578{
     579  assert (m_isInitialized);
     580  assert (seiChromaResamplingFilterHint!=NULL);
     581
     582  seiChromaResamplingFilterHint->m_verChromaFilterIdc = iVerFilterIndex;
     583  seiChromaResamplingFilterHint->m_horChromaFilterIdc = iHorFilterIndex;
     584  seiChromaResamplingFilterHint->m_verFilteringFieldProcessingFlag = 1;
     585  seiChromaResamplingFilterHint->m_targetFormatIdc = 3;
     586  seiChromaResamplingFilterHint->m_perfectReconstructionFlag = false;
     587
     588  // this creates some example filter values, if explicit filter definition is selected
     589  if (seiChromaResamplingFilterHint->m_verChromaFilterIdc == 1)
     590    {
     591    const Int numVerticalFilters = 3;
     592    const Int verTapLengthMinus1[] = {5,3,3};
     593
     594    seiChromaResamplingFilterHint->m_verFilterCoeff.resize(numVerticalFilters);
     595    for(Int i = 0; i < numVerticalFilters; i ++)
     596      {
     597      seiChromaResamplingFilterHint->m_verFilterCoeff[i].resize(verTapLengthMinus1[i]+1);
     598    }
     599    // Note: C++11 -> seiChromaResamplingFilterHint->m_verFilterCoeff[0] = {-3,13,31,23,3,-3};
     600    seiChromaResamplingFilterHint->m_verFilterCoeff[0][0] = -3;
     601    seiChromaResamplingFilterHint->m_verFilterCoeff[0][1] = 13;
     602    seiChromaResamplingFilterHint->m_verFilterCoeff[0][2] = 31;
     603    seiChromaResamplingFilterHint->m_verFilterCoeff[0][3] = 23;
     604    seiChromaResamplingFilterHint->m_verFilterCoeff[0][4] = 3;
     605    seiChromaResamplingFilterHint->m_verFilterCoeff[0][5] = -3;
     606
     607    seiChromaResamplingFilterHint->m_verFilterCoeff[1][0] = -1;
     608    seiChromaResamplingFilterHint->m_verFilterCoeff[1][1] = 25;
     609    seiChromaResamplingFilterHint->m_verFilterCoeff[1][2] = 247;
     610    seiChromaResamplingFilterHint->m_verFilterCoeff[1][3] = -15;
     611
     612    seiChromaResamplingFilterHint->m_verFilterCoeff[2][0] = -20;
     613    seiChromaResamplingFilterHint->m_verFilterCoeff[2][1] = 186;
     614    seiChromaResamplingFilterHint->m_verFilterCoeff[2][2] = 100;
     615    seiChromaResamplingFilterHint->m_verFilterCoeff[2][3] = -10;
    424616  }
    425617  else
    426618  {
    427     seiChromaSamplingFilterHint->m_numVerticalFilters = 0;
    428     seiChromaSamplingFilterHint->m_verTapLengthMinus1 = NULL;
    429     seiChromaSamplingFilterHint->m_verFilterCoeff = NULL;
    430   }
    431   if(seiChromaSamplingFilterHint->m_horChromaFilterIdc == 1)
    432   {
    433     seiChromaSamplingFilterHint->m_numHorizontalFilters = 1;
    434     seiChromaSamplingFilterHint->m_horTapLengthMinus1 = (Int*)malloc(seiChromaSamplingFilterHint->m_numHorizontalFilters * sizeof(Int));
    435     seiChromaSamplingFilterHint->m_horFilterCoeff = (Int**)malloc(seiChromaSamplingFilterHint->m_numHorizontalFilters * sizeof(Int*));
    436     for(Int i = 0; i < seiChromaSamplingFilterHint->m_numHorizontalFilters; i ++)
    437     {
    438       seiChromaSamplingFilterHint->m_horTapLengthMinus1[i] = 0;
    439       seiChromaSamplingFilterHint->m_horFilterCoeff[i] = (Int*)malloc(seiChromaSamplingFilterHint->m_horTapLengthMinus1[i] * sizeof(Int));
    440       for(Int j = 0; j < seiChromaSamplingFilterHint->m_horTapLengthMinus1[i]; j ++)
    441       {
    442         seiChromaSamplingFilterHint->m_horFilterCoeff[i][j] = 0;
    443       }
    444     }
     619    seiChromaResamplingFilterHint->m_verFilterCoeff.resize(0);
     620  }
     621
     622  if (seiChromaResamplingFilterHint->m_horChromaFilterIdc == 1)
     623    {
     624    Int const numHorizontalFilters = 1;
     625    const Int horTapLengthMinus1[] = {3};
     626
     627    seiChromaResamplingFilterHint->m_horFilterCoeff.resize(numHorizontalFilters);
     628    for(Int i = 0; i < numHorizontalFilters; i ++)
     629      {
     630      seiChromaResamplingFilterHint->m_horFilterCoeff[i].resize(horTapLengthMinus1[i]+1);
     631    }
     632    seiChromaResamplingFilterHint->m_horFilterCoeff[0][0] = 1;
     633    seiChromaResamplingFilterHint->m_horFilterCoeff[0][1] = 6;
     634    seiChromaResamplingFilterHint->m_horFilterCoeff[0][2] = 1;
    445635  }
    446636  else
    447637  {
    448     seiChromaSamplingFilterHint->m_numHorizontalFilters = 0;
    449     seiChromaSamplingFilterHint->m_horTapLengthMinus1 = NULL;
    450     seiChromaSamplingFilterHint->m_horFilterCoeff = NULL;
     638    seiChromaResamplingFilterHint->m_horFilterCoeff.resize(0);
    451639  }
    452640}

  • branches/HTM-15.2-dev/source/Lib/TLibEncoder/SEIEncoder.h

    r1356 r1360  
    7979  Void initSEITempMotionConstrainedTileSets (SEITempMotionConstrainedTileSets *sei, const TComPPS *pps);
    8080  Void initSEIKneeFunctionInfo(SEIKneeFunctionInfo *sei);
    81   Void initSEIChromaSamplingFilterHint(SEIChromaSamplingFilterHint *sei, Int iHorFilterIndex, Int iVerFilterIndex);
     81  Void initSEIChromaResamplingFilterHint(SEIChromaResamplingFilterHint *sei, Int iHorFilterIndex, Int iVerFilterIndex);
    8282  Void initSEITimeCode(SEITimeCode *sei);
     83  Bool initSEIColourRemappingInfo(SEIColourRemappingInfo *sei, Int currPOC); // returns true on success, false on failure.
    8384
    8485  // trailing SEIs

  • branches/HTM-15.2-dev/source/Lib/TLibEncoder/SEIwrite.cpp

    r1356 r1360  
    106106    xWriteSEIScalableNesting(bs, *static_cast<const SEIScalableNesting*>(&sei), sps);
    107107    break;
    108   case SEI::CHROMA_SAMPLING_FILTER_HINT:
    109     xWriteSEIChromaSamplingFilterHint(*static_cast<const SEIChromaSamplingFilterHint*>(&sei)/*, sps*/);
     108  case SEI::CHROMA_RESAMPLING_FILTER_HINT:
     109    xWriteSEIChromaResamplingFilterHint(*static_cast<const SEIChromaResamplingFilterHint*>(&sei));
    110110    break;
    111111  case SEI::TEMP_MOTION_CONSTRAINED_TILE_SETS:
    … …  
    117117  case SEI::KNEE_FUNCTION_INFO:
    118118    xWriteSEIKneeFunctionInfo(*static_cast<const SEIKneeFunctionInfo*>(&sei));
     119    break;
     120  case SEI::COLOUR_REMAPPING_INFO:
     121    xWriteSEIColourRemappingInfo(*static_cast<const SEIColourRemappingInfo*>(&sei));
    119122    break;
    120123  case SEI::MASTERING_DISPLAY_COLOUR_VOLUME:
    … …  
    189192
    190193  default:
    191     assert(!"Unhandled SEI message");
     194    assert(!"Trying to write unhandled SEI message");
    192195    break;
    193196  }
    … …  
    277280Void SEIWriter::xWriteSEIDecodedPictureHash(const SEIDecodedPictureHash& sei)
    278281{
    279   const Char *traceString="\0";
     282  const TChar *traceString="\0";
    280283  switch (sei.method)
    281284  {
    282     case SEIDecodedPictureHash::MD5: traceString="picture_md5"; break;
    283     case SEIDecodedPictureHash::CRC: traceString="picture_crc"; break;
    284     case SEIDecodedPictureHash::CHECKSUM: traceString="picture_checksum"; break;
     285    case HASHTYPE_MD5: traceString="picture_md5"; break;
     286    case HASHTYPE_CRC: traceString="picture_crc"; break;
     287    case HASHTYPE_CHECKSUM: traceString="picture_checksum"; break;
    285288    default: assert(false); break;
    286289  }
    … …  
    726729}
    727730
    728 Void SEIWriter::xWriteSEIChromaSamplingFilterHint(const SEIChromaSamplingFilterHint &sei/*, TComSPS* sps*/)
     731Void SEIWriter::xWriteSEIChromaResamplingFilterHint(const SEIChromaResamplingFilterHint &sei)
    729732{
    730733  WRITE_CODE(sei.m_verChromaFilterIdc, 8, "ver_chroma_filter_idc");
    731734  WRITE_CODE(sei.m_horChromaFilterIdc, 8, "hor_chroma_filter_idc");
    732   WRITE_FLAG(sei.m_verFilteringProcessFlag, "ver_filtering_process_flag");
     735  WRITE_FLAG(sei.m_verFilteringFieldProcessingFlag, "ver_filtering_field_processing_flag");
    733736  if(sei.m_verChromaFilterIdc == 1 || sei.m_horChromaFilterIdc == 1)
    734737  {
    735     writeUserDefinedCoefficients(sei);
    736   }
    737 }
    738 
    739 // write hardcoded chroma filter coefficients in the SEI messages
    740 Void SEIWriter::writeUserDefinedCoefficients(const SEIChromaSamplingFilterHint &sei)
    741 {
    742   Int const iNumVerticalFilters = 3;
    743   Int verticalTapLength_minus1[iNumVerticalFilters] = {5,3,3};
    744   Int* userVerticalCoefficients[iNumVerticalFilters];
    745   for(Int i = 0; i < iNumVerticalFilters; i ++)
    746   {
    747     userVerticalCoefficients[i] = (Int*)malloc( (verticalTapLength_minus1[i]+1) * sizeof(Int));
    748   }
    749   userVerticalCoefficients[0][0] = -3;
    750   userVerticalCoefficients[0][1] = 13;
    751   userVerticalCoefficients[0][2] = 31;
    752   userVerticalCoefficients[0][3] = 23;
    753   userVerticalCoefficients[0][4] = 3;
    754   userVerticalCoefficients[0][5] = -3;
    755 
    756   userVerticalCoefficients[1][0] = -1;
    757   userVerticalCoefficients[1][1] = 25;
    758   userVerticalCoefficients[1][2] = 247;
    759   userVerticalCoefficients[1][3] = -15;
    760 
    761   userVerticalCoefficients[2][0] = -20;
    762   userVerticalCoefficients[2][1] = 186;
    763   userVerticalCoefficients[2][2] = 100;
    764   userVerticalCoefficients[2][3] = -10;
    765 
    766   Int const iNumHorizontalFilters = 1;
    767   Int horizontalTapLength_minus1[iNumHorizontalFilters] = {3};
    768   Int* userHorizontalCoefficients[iNumHorizontalFilters];
    769   for(Int i = 0; i < iNumHorizontalFilters; i ++)
    770   {
    771     userHorizontalCoefficients[i] = (Int*)malloc( (horizontalTapLength_minus1[i]+1) * sizeof(Int));
    772   }
    773   userHorizontalCoefficients[0][0] = 1;
    774   userHorizontalCoefficients[0][1] = 6;
    775   userHorizontalCoefficients[0][2] = 1;
    776 
    777   WRITE_UVLC(3, "target_format_idc");
    778   if(sei.m_verChromaFilterIdc == 1)
    779   {
    780     WRITE_UVLC(iNumVerticalFilters, "num_vertical_filters");
    781     if(iNumVerticalFilters > 0)
    782     {
    783       for(Int i = 0; i < iNumVerticalFilters; i ++)
    784       {
    785         WRITE_UVLC(verticalTapLength_minus1[i], "ver_tap_length_minus_1");
    786         for(Int j = 0; j < verticalTapLength_minus1[i]; j ++)
    787         {
    788           WRITE_SVLC(userVerticalCoefficients[i][j], "ver_filter_coeff");
    789         }
    790       }
    791     }
    792   }
    793   if(sei.m_horChromaFilterIdc == 1)
    794   {
    795     WRITE_UVLC(iNumHorizontalFilters, "num_horizontal_filters");
    796     if(iNumHorizontalFilters > 0)
    797     {
    798       for(Int i = 0; i < iNumHorizontalFilters; i ++)
    799       {
    800         WRITE_UVLC(horizontalTapLength_minus1[i], "hor_tap_length_minus_1");
    801         for(Int j = 0; j < horizontalTapLength_minus1[i]; j ++)
    802         {
    803           WRITE_SVLC(userHorizontalCoefficients[i][j], "hor_filter_coeff");
    804         }
    805       }
    806     }
    807   }
    808 }
    809 
     738    WRITE_UVLC(sei.m_targetFormatIdc, "target_format_idc");
     739    if(sei.m_verChromaFilterIdc == 1)
     740    {
     741      const Int numVerticalFilter = (Int)sei.m_verFilterCoeff.size();
     742      WRITE_UVLC(numVerticalFilter, "num_vertical_filters");
     743      if(numVerticalFilter > 0)
     744      {
     745        for(Int i = 0; i < numVerticalFilter; i ++)
     746        {
     747          const Int verTapLengthMinus1 = (Int) sei.m_verFilterCoeff[i].size() - 1;
     748          WRITE_UVLC(verTapLengthMinus1, "ver_tap_length_minus_1");
     749          for(Int j = 0; j < (verTapLengthMinus1 + 1); j ++)
     750          {
     751            WRITE_SVLC(sei.m_verFilterCoeff[i][j], "ver_filter_coeff");
     752          }
     753        }
     754      }
     755    }
     756    if(sei.m_horChromaFilterIdc == 1)
     757    {
     758      const Int numHorizontalFilter = (Int) sei.m_horFilterCoeff.size();
     759      WRITE_UVLC(numHorizontalFilter, "num_horizontal_filters");
     760      if(numHorizontalFilter > 0)
     761      {
     762        for(Int i = 0; i < numHorizontalFilter; i ++)
     763        {
     764          const Int horTapLengthMinus1 = (Int) sei.m_horFilterCoeff[i].size() - 1;
     765          WRITE_UVLC(horTapLengthMinus1, "hor_tap_length_minus_1");
     766          for(Int j = 0; j < (horTapLengthMinus1 + 1); j ++)
     767          {
     768            WRITE_SVLC(sei.m_horFilterCoeff[i][j], "hor_filter_coeff");
     769          }
     770        }
     771      }
     772    }
     773  }
     774}
    810775#if NH_MV
    811776#if !NH_MV_SEI
    … …  
    849814}
    850815
     816Void SEIWriter::xWriteSEIColourRemappingInfo(const SEIColourRemappingInfo& sei)
     817{
     818  WRITE_UVLC( sei.m_colourRemapId,                             "colour_remap_id" );
     819  WRITE_FLAG( sei.m_colourRemapCancelFlag,                     "colour_remap_cancel_flag" );
     820  if( !sei.m_colourRemapCancelFlag )
     821  {
     822    WRITE_FLAG( sei.m_colourRemapPersistenceFlag,              "colour_remap_persistence_flag" );
     823    WRITE_FLAG( sei.m_colourRemapVideoSignalInfoPresentFlag,   "colour_remap_video_signal_info_present_flag" );
     824    if ( sei.m_colourRemapVideoSignalInfoPresentFlag )
     825    {
     826      WRITE_FLAG( sei.m_colourRemapFullRangeFlag,              "colour_remap_full_range_flag" );
     827      WRITE_CODE( sei.m_colourRemapPrimaries,               8, "colour_remap_primaries" );
     828      WRITE_CODE( sei.m_colourRemapTransferFunction,        8, "colour_remap_transfer_function" );
     829      WRITE_CODE( sei.m_colourRemapMatrixCoefficients,      8, "colour_remap_matrix_coefficients" );
     830    }
     831    WRITE_CODE( sei.m_colourRemapInputBitDepth,             8, "colour_remap_input_bit_depth" );
     832    WRITE_CODE( sei.m_colourRemapBitDepth,                  8, "colour_remap_bit_depth" );
     833    for( Int c=0 ; c<3 ; c++ )
     834    {
     835      WRITE_CODE( sei.m_preLutNumValMinus1[c],              8, "pre_lut_num_val_minus1[c]" );
     836      if( sei.m_preLutNumValMinus1[c]>0 )
     837      {
     838        for( Int i=0 ; i<=sei.m_preLutNumValMinus1[c] ; i++ )
     839        {
     840          WRITE_CODE( sei.m_preLut[c][i].codedValue,  (( sei.m_colourRemapInputBitDepth + 7 ) >> 3 ) << 3, "pre_lut_coded_value[c][i]" );
     841          WRITE_CODE( sei.m_preLut[c][i].targetValue, (( sei.m_colourRemapBitDepth      + 7 ) >> 3 ) << 3, "pre_lut_target_value[c][i]" );
     842        }
     843      }
     844    }
     845    WRITE_FLAG( sei.m_colourRemapMatrixPresentFlag,            "colour_remap_matrix_present_flag" );
     846    if( sei.m_colourRemapMatrixPresentFlag )
     847    {
     848      WRITE_CODE( sei.m_log2MatrixDenom,                    4, "log2_matrix_denom" );
     849      for( Int c=0 ; c<3 ; c++ )
     850      {
     851        for( Int i=0 ; i<3 ; i++ )
     852        {
     853          WRITE_SVLC( sei.m_colourRemapCoeffs[c][i],           "colour_remap_coeffs[c][i]" );
     854        }
     855      }
     856    }
     857
     858    for( Int c=0 ; c<3 ; c++ )
     859    {
     860      WRITE_CODE( sei.m_postLutNumValMinus1[c],             8, "m_postLutNumValMinus1[c]" );
     861      if( sei.m_postLutNumValMinus1[c]>0 )
     862      {
     863        for( Int i=0 ; i<=sei.m_postLutNumValMinus1[c] ; i++ )
     864        {
     865          WRITE_CODE( sei.m_postLut[c][i].codedValue, (( sei.m_colourRemapBitDepth + 7 ) >> 3 ) << 3, "post_lut_coded_value[c][i]" );
     866          WRITE_CODE( sei.m_postLut[c][i].targetValue, (( sei.m_colourRemapBitDepth + 7 ) >> 3 ) << 3, "post_lut_target_value[c][i]" );
     867        }
     868      }
     869    }
     870  }
     871}
    851872
    852873Void SEIWriter::xWriteSEIMasteringDisplayColourVolume(const SEIMasteringDisplayColourVolume& sei)
    … …  
    863884  WRITE_CODE( sei.values.whitePoint[0],    16,  "white_point_x" );
    864885  WRITE_CODE( sei.values.whitePoint[1],    16,  "white_point_y" );
    865 
     886   
    866887  WRITE_CODE( sei.values.maxLuminance,     32,  "max_display_mastering_luminance" );
    867888  WRITE_CODE( sei.values.minLuminance,     32,  "min_display_mastering_luminance" );
    … …  
    881902}
    882903
     904
    883905#if NH_MV_LAYERS_NOT_PRESENT_SEI
    884906Void SEIWriter::xWriteSEILayersNotPresent(const SEILayersNotPresent& sei)
    … …  
    892914#endif
    893915
    894 
    895 
     916#if NH_MV
    896917Void SEIWriter::xWriteSEIInterLayerConstrainedTileSets( const SEIInterLayerConstrainedTileSets& sei)
    897918{
    … …  
    927948  }
    928949};
     950#endif
    929951
    930952#if NH_MV_SEI_TBD
    … …  
    10671089  }
    10681090};
     1091
    10691092
    10701093Void SEIWriter::xWriteSEITemporalMvPredictionConstraints( const SEITemporalMvPredictionConstraints& sei)

  • branches/HTM-15.2-dev/source/Lib/TLibEncoder/SEIwrite.h

    r1356 r1360  
    5353
    5454protected:
    55   Void xWriteSEIpayloadData(TComBitIf& bs, const SEI& sei, const TComSPS *sps);
    5655  Void xWriteSEIuserDataUnregistered(const SEIuserDataUnregistered &sei);
    5756  Void xWriteSEIActiveParameterSets(const SEIActiveParameterSets& sei);
    … …  
    6059  Void xWriteSEIBufferingPeriod(const SEIBufferingPeriod& sei, const TComSPS *sps);
    6160  Void xWriteSEIPictureTiming(const SEIPictureTiming& sei, const TComSPS *sps);
    62   TComSPS *m_pSPS;
    6361  Void xWriteSEIRecoveryPoint(const SEIRecoveryPoint& sei);
    6462  Void xWriteSEIFramePacking(const SEIFramePacking& sei);
    … …  
    7876  Void xWriteSEITempMotionConstrainedTileSets(const SEITempMotionConstrainedTileSets& sei);
    7977  Void xWriteSEITimeCode(const SEITimeCode& sei);
    80   Void xWriteSEIChromaSamplingFilterHint(const SEIChromaSamplingFilterHint& sei/*, TComSPS *sps*/);
    81   Void writeUserDefinedCoefficients(const SEIChromaSamplingFilterHint& sei);
     78  Void xWriteSEIChromaResamplingFilterHint(const SEIChromaResamplingFilterHint& sei);
    8279  Void xWriteSEIKneeFunctionInfo(const SEIKneeFunctionInfo &sei);
     80  Void xWriteSEIColourRemappingInfo(const SEIColourRemappingInfo& sei);
    8381  Void xWriteSEIMasteringDisplayColourVolume( const SEIMasteringDisplayColourVolume& sei);
    8482
    … …  
    110108  Void xWriteSEIAlternativeDepthInfo          ( const SEIAlternativeDepthInfo& sei);
    111109#endif
     110  Void xWriteSEIpayloadData(TComBitIf& bs, const SEI& sei, const TComSPS *sps);
    112111  Void xWriteByteAlign();
    113112};

  • branches/HTM-15.2-dev/source/Lib/TLibEncoder/SyntaxElementWriter.cpp

    r1356 r1360  
    4444#if ENC_DEC_TRACE
    4545
    46 Void  SyntaxElementWriter::xWriteCodeTr (UInt value, UInt  length, const Char *pSymbolName)
     46Void  SyntaxElementWriter::xWriteCodeTr (UInt value, UInt  length, const TChar *pSymbolName)
    4747{
    4848  xWriteCode (value,length);
    … …  
    7070}
    7171
    72 Void  SyntaxElementWriter::xWriteUvlcTr (UInt value, const Char *pSymbolName)
     72Void  SyntaxElementWriter::xWriteUvlcTr (UInt value, const TChar *pSymbolName)
    7373{
    7474  xWriteUvlc (value);
    … …  
    8989}
    9090
    91 Void  SyntaxElementWriter::xWriteSvlcTr (Int value, const Char *pSymbolName)
     91Void  SyntaxElementWriter::xWriteSvlcTr (Int value, const TChar *pSymbolName)
    9292{
    9393  xWriteSvlc(value);
    … …  
    108108}
    109109
    110 Void  SyntaxElementWriter::xWriteFlagTr(UInt value, const Char *pSymbolName)
     110Void  SyntaxElementWriter::xWriteFlagTr(UInt value, const TChar *pSymbolName)
    111111{
    112112  xWriteFlag(value);
    … …  
    127127}
    128128
     129#if H_MV_ENC_DEC_TRAC
    129130Void  SyntaxElementWriter::xWriteStringTr( UChar* value, UInt length, const Char *pSymbolName)
    130131{
    … …  
    136137  }
    137138}
    138 
     139#endif
    139140#endif
    140141
    … …  
    176177}
    177178
     179#if H_MV_ENC_DEC_TRAC
    178180Void  SyntaxElementWriter::xWriteString( UChar* sCode, UInt uiLength)
    179181{
    … …  
    185187  m_pcBitIf->write( 0, 8 ); //zero-termination byte
    186188}
    187 
     189#endif
    188190Void SyntaxElementWriter::xWriteRbspTrailingBits()
    189191{

  • branches/HTM-15.2-dev/source/Lib/TLibEncoder/SyntaxElementWriter.h

    r1356 r1360  
    5656#define WRITE_SVLC( value,         name)    xWriteSvlcTr ( value,         name )
    5757#define WRITE_FLAG( value,         name)    xWriteFlagTr ( value,         name )
     58#if NH_MV
    5859#define WRITE_STRING( value, length, name)   xWriteStringTr( value, length, name )
     60#endif
    5961
    6062#else
    … …  
    6466#define WRITE_SVLC( value,         name)     xWriteSvlc ( value )
    6567#define WRITE_FLAG( value,         name)     xWriteFlag ( value )
     68#if NH_MV
    6669#define WRITE_STRING( value, length, name)   xWriteString( value, length )
    67 
     70#endif
    6871#endif
    6972
    … …  
    8487  Void  xWriteSvlc            ( Int  iCode   );
    8588  Void  xWriteFlag            ( UInt uiCode );
     89#if NH_MV
    8690  Void  xWriteString          ( UChar* sCode, UInt uiLength);
     91#endif
    8792#if ENC_DEC_TRACE
    88   Void  xWriteCodeTr          ( UInt value, UInt  length, const Char *pSymbolName);
    89   Void  xWriteUvlcTr          ( UInt value,               const Char *pSymbolName);
    90   Void  xWriteSvlcTr          ( Int  value,               const Char *pSymbolName);
    91   Void  xWriteFlagTr          ( UInt value,               const Char *pSymbolName);
     93  Void  xWriteCodeTr          ( UInt value, UInt  length, const TChar *pSymbolName);
     94  Void  xWriteUvlcTr          ( UInt value,               const TChar *pSymbolName);
     95  Void  xWriteSvlcTr          ( Int  value,               const TChar *pSymbolName);
     96  Void  xWriteFlagTr          ( UInt value,               const TChar *pSymbolName);
     97#if NH_MV
    9298  Void  xWriteStringTr        ( UChar* value, UInt length, const Char *pSymbolName);
     99#endif
    93100#endif
    94101  Void xWriteRbspTrailingBits();

  • branches/HTM-15.2-dev/source/Lib/TLibEncoder/TEncAnalyze.h

    r1313 r1360  
    137137
    138138
    139   Void    printOut ( Char cDelim, const ChromaFormat chFmt, const Bool printMSEBasedSNR, const Bool printSequenceMSE, const BitDepths &bitDepths )
     139  Void    printOut ( TChar cDelim, const ChromaFormat chFmt, const Bool printMSEBasedSNR, const Bool printSequenceMSE, const BitDepths &bitDepths )
    140140  {
    141141    Double dFps     =   m_dFrmRate; //--CFG_KDY

  • branches/HTM-15.2-dev/source/Lib/TLibEncoder/TEncBinCoderCABAC.cpp

    r1321 r1360  
    246246  if (g_debugCounter >= debugCabacBinTargetLine)
    247247  {
    248     Char breakPointThis;
     248    UChar breakPointThis;
    249249    breakPointThis = 7;
    250250  }

  • branches/HTM-15.2-dev/source/Lib/TLibEncoder/TEncBinCoderCABACCounter.cpp

    r1321 r1360  
    9797  if (g_debugCounter >= debugEncoderSearchBinTargetLine)
    9898  {
    99     Char breakPointThis;
     99    UChar breakPointThis;
    100100    breakPointThis = 7;
    101101  }

  • branches/HTM-15.2-dev/source/Lib/TLibEncoder/TEncCavlc.cpp

    r1321 r1360  
    6969  fprintf( g_hTrace, "=========== Slice ===========\n");
    7070}
    71 #endif
    72 #endif
     71
     72Void  xTraceAccessUnitDelimiter ()
     73{
     74  fprintf( g_hTrace, "=========== Access Unit Delimiter ===========\n");
     75}
     76
     77#endif
     78#endif
     79
     80Void AUDWriter::codeAUD(TComBitIf& bs, const Int pictureType)
     81{
     82#if ENC_DEC_TRACE
     83  xTraceAccessUnitDelimiter();
     84#endif
     85
     86  assert (pictureType < 3);
     87  setBitstream(&bs);
     88  WRITE_CODE(pictureType, 3, "pic_type");
     89  xWriteRbspTrailingBits();
     90}
     91
    7392// ====================================================================================================================
    7493// Constructor / destructor / create / destroy
    … …  
    266285  {
    267286#if ENC_DEC_TRACE || RExt__DECODER_DEBUG_BIT_STATISTICS
    268     static const char *syntaxStrings[]={ "pps_range_extension_flag",
     287    static const TChar *syntaxStrings[]={ "pps_range_extension_flag",
    269288                                         "pps_multilayer_extension_flag",
    270289                                         "pps_extension_6bits[0]",
    … …  
    748767    WRITE_UVLC( pcSPS->getSpsMaxLatencyIncreasePlus1(i),   "sps_max_latency_increase_plus1[i]" );
    749768#else
    750     WRITE_UVLC( pcSPS->getMaxLatencyIncrease(i),           "sps_max_latency_increase_plus1[i]" );
     769    WRITE_UVLC( pcSPS->getMaxLatencyIncreasePlus1(i),      "sps_max_latency_increase_plus1[i]" );
    751770#endif
    752771    if (!subLayerOrderingInfoPresentFlag)
    … …  
    858877  {
    859878#if ENC_DEC_TRACE || RExt__DECODER_DEBUG_BIT_STATISTICS
    860     static const char *syntaxStrings[]={ "sps_range_extension_flag",
     879    static const TChar *syntaxStrings[]={ "sps_range_extension_flag",
    861880      "sps_multilayer_extension_flag",
    862881      "sps_extension_6bits[0]",

  • branches/HTM-15.2-dev/source/Lib/TLibEncoder/TEncCavlc.h

    r1321 r1360  
    5858// ====================================================================================================================
    5959
     60class AUDWriter : public SyntaxElementWriter
     61{
     62public:
     63  AUDWriter() {};
     64  virtual ~AUDWriter() {};
     65
     66  Void  codeAUD(TComBitIf& bs, const Int pictureType);
     67};
     68
    6069/// CAVLC encoder class
    6170class TEncCavlc : public SyntaxElementWriter, public TEncEntropyIf

  • branches/HTM-15.2-dev/source/Lib/TLibEncoder/TEncCfg.h

    r1356 r1360  
    6565  Bool m_refPic;
    6666  Int m_numRefPicsActive;
    67   Char m_sliceType;
     67  SChar m_sliceType;
    6868  Int m_numRefPics;
    6969  Int m_referencePics[MAX_NUM_REF_PICS];
    … …  
    137137  Int       m_framesToBeEncoded;
    138138  Double    m_adLambdaModifier[ MAX_TLAYER ];
     139  std::vector<Double> m_adIntraLambdaModifier;
     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) ))
    139141
    140142  Bool      m_printMSEBasedSequencePSNR;
    … …  
    174176  Int       m_aiPad[2];
    175177
     178  Bool      m_AccessUnitDelimiter;               ///< add Access Unit Delimiter NAL units
    176179
    177180  Int       m_iMaxRefPicNum;                     ///< this is used to mimic the sliding mechanism used by the decoder
    … …  
    206209  //====== Motion search ========
    207210  Bool      m_bDisableIntraPUsInInterSlices;
    208   Int       m_iFastSearch;                      //  0:Full search  1:Diamond  2:PMVFAST
     211  MESearchMethod m_motionEstimationSearchMethod;
    209212  Int       m_iSearchRange;                     //  0:Full frame
    210213  Int       m_bipredSearchRange;
    211214  Bool      m_bClipForBiPredMeEnabled;
    212215  Bool      m_bFastMEAssumingSmootherMVEnabled;
     216  Int       m_minSearchWindow;
     217  Bool      m_bRestrictMESampling;
    213218
    214219#if NH_MV
    … …  
    243248#endif
    244249  UInt      m_rdPenalty;
    245   Bool      m_bUseFastEnc;
     250  FastInterSearchMode m_fastInterSearchMode;
    246251  Bool      m_bUseEarlyCU;
    247252  Bool      m_useFastDecisionForMerge;
    … …  
    289294  std::vector<Int> m_tileRowHeight;
    290295
    291   Int       m_iWaveFrontSynchro;
    292 
    293   Int       m_decodedPictureHashSEIEnabled;              ///< Checksum(3)/CRC(2)/MD5(1)/disable(0) acting on decoded picture hash SEI message
    294   Int       m_bufferingPeriodSEIEnabled;
    295   Int       m_pictureTimingSEIEnabled;
    296   Int       m_recoveryPointSEIEnabled;
     296  Bool      m_entropyCodingSyncEnabledFlag;
     297
     298  HashType  m_decodedPictureHashSEIType;
     299  Bool      m_bufferingPeriodSEIEnabled;
     300  Bool      m_pictureTimingSEIEnabled;
     301  Bool      m_recoveryPointSEIEnabled;
    297302  Bool      m_toneMappingInfoSEIEnabled;
    298303  Int       m_toneMapId;
    … …  
    322327  Int*      m_codedPivotValue;
    323328  Int*      m_targetPivotValue;
    324   Int       m_framePackingSEIEnabled;
     329  Bool      m_framePackingSEIEnabled;
    325330  Int       m_framePackingSEIType;
    326331  Int       m_framePackingSEIId;
    327332  Int       m_framePackingSEIQuincunx;
    328333  Int       m_framePackingSEIInterpretation;
    329   Int       m_segmentedRectFramePackingSEIEnabled;
     334  Bool      m_segmentedRectFramePackingSEIEnabled;
    330335  Bool      m_segmentedRectFramePackingSEICancel;
    331336  Int       m_segmentedRectFramePackingSEIType;
    332337  Bool      m_segmentedRectFramePackingSEIPersistence;
    333338  Int       m_displayOrientationSEIAngle;
    334   Int       m_temporalLevel0IndexSEIEnabled;
    335   Int       m_gradualDecodingRefreshInfoEnabled;
     339  Bool      m_temporalLevel0IndexSEIEnabled;
     340  Bool      m_gradualDecodingRefreshInfoEnabled;
    336341  Int       m_noDisplaySEITLayer;
    337   Int       m_decodingUnitInfoSEIEnabled;
    338   Int       m_SOPDescriptionSEIEnabled;
    339   Int       m_scalableNestingSEIEnabled;
     342  Bool      m_decodingUnitInfoSEIEnabled;
     343  Bool      m_SOPDescriptionSEIEnabled;
     344  Bool      m_scalableNestingSEIEnabled;
    340345  Bool      m_tmctsSEIEnabled;
    341346  Bool      m_timeCodeSEIEnabled;
    … …  
    353358  Int*      m_kneeSEIInputKneePoint;
    354359  Int*      m_kneeSEIOutputKneePoint;
     360  std::string m_colourRemapSEIFileRoot;          ///< SEI Colour Remapping File (initialized from external file)
    355361  TComSEIMasteringDisplay m_masteringDisplay;
    356362#if NH_MV_SEI
    … …  
    360366  Bool      m_useWeightedPred;       //< Use of Weighting Prediction (P_SLICE)
    361367  Bool      m_useWeightedBiPred;    //< Use of Bi-directional Weighting Prediction (B_SLICE)
     368  WeightedPredictionMethod m_weightedPredictionMethod;
    362369  UInt      m_log2ParallelMergeLevelMinus2;       ///< Parallel merge estimation region
    363370  UInt      m_maxNumMergeCand;                    ///< Maximum number of merge candidates
    364371  ScalingListMode m_useScalingListId;            ///< Using quantization matrix i.e. 0=off, 1=default, 2=file.
    365   Char*     m_scalingListFile;          ///< quantization matrix file name
     372  std::string m_scalingListFileName;              ///< quantization matrix file name
    366373  Int       m_TMVPModeId;
    367374  Bool      m_signHideFlag;
    … …  
    373380  Int       m_RCInitialQP;
    374381  Bool      m_RCForceIntraQP;
     382#if U0132_TARGET_BITS_SATURATION
     383  Bool      m_RCCpbSaturationEnabled;                   
     384  UInt      m_RCCpbSize;
     385  Double    m_RCInitialCpbFullness;
     386#endif
    375387
    376388#if KWU_RC_MADPRED_E0227
    … …  
    398410  Bool      m_vuiParametersPresentFlag;                       ///< enable generation of VUI parameters
    399411  Bool      m_aspectRatioInfoPresentFlag;                     ///< Signals whether aspect_ratio_idc is present
    400   Bool      m_chromaSamplingFilterHintEnabled;                ///< Signals whether chroma sampling filter hint data is present
    401   Int       m_chromaSamplingHorFilterIdc;                     ///< Specifies the Index of filter to use
    402   Int       m_chromaSamplingVerFilterIdc;                     ///< Specifies the Index of filter to use
     412  Bool      m_chromaResamplingFilterHintEnabled;              ///< Signals whether chroma sampling filter hint data is present
     413  Int       m_chromaResamplingHorFilterIdc;                   ///< Specifies the Index of filter to use
     414  Int       m_chromaResamplingVerFilterIdc;                   ///< Specifies the Index of filter to use
    403415  Int       m_aspectRatioIdc;                                 ///< aspect_ratio_idc
    404416  Int       m_sarWidth;                                       ///< horizontal size of the sample aspect ratio
    … …  
    606618  //====== Motion search ========
    607619  Void      setDisableIntraPUsInInterSlices ( Bool  b )      { m_bDisableIntraPUsInInterSlices = b; }
    608   Void      setFastSearch                   ( Int   i )      { m_iFastSearch = i; }
     620  Void      setMotionEstimationSearchMethod ( MESearchMethod e ) { m_motionEstimationSearchMethod = e; }
    609621  Void      setSearchRange                  ( Int   i )      { m_iSearchRange = i; }
    610622  Void      setBipredSearchRange            ( Int   i )      { m_bipredSearchRange = i; }
    611623  Void      setClipForBiPredMeEnabled       ( Bool  b )      { m_bClipForBiPredMeEnabled = b; }
    612624  Void      setFastMEAssumingSmootherMVEnabled ( Bool b )    { m_bFastMEAssumingSmootherMVEnabled = b; }
     625  Void      setMinSearchWindow              ( Int   i )      { m_minSearchWindow = i; }
     626  Void      setRestrictMESampling           ( Bool  b )      { m_bRestrictMESampling = b; }
     627
    613628#if NH_MV
    614629  Void      setUseDisparitySearchRangeRestriction ( Bool   b )      { m_bUseDisparitySearchRangeRestriction = b; }
    … …  
    649664  Int       getSourceHeight                 ()      { return  m_iSourceHeight; }
    650665  Int       getFramesToBeEncoded            ()      { return  m_framesToBeEncoded; }
     666 
     667  //====== Lambda Modifiers ========
    651668  Void setLambdaModifier                    ( UInt uiIndex, Double dValue ) { m_adLambdaModifier[ uiIndex ] = dValue; }
    652669  Double getLambdaModifier                  ( UInt uiIndex ) const { return m_adLambdaModifier[ uiIndex ]; }
     670  Void      setIntraLambdaModifier          ( const std::vector<Double> &dValue )               { m_adIntraLambdaModifier = dValue;       }
     671  const std::vector<Double>& getIntraLambdaModifier()                        const { return m_adIntraLambdaModifier;         }
     672  Void      setIntraQpFactor                ( Double dValue )               { m_dIntraQpFactor = dValue;              }
     673  Double    getIntraQpFactor                ()                        const { return m_dIntraQpFactor;                }
    653674
    654675  //==== Coding Structure ========
    … …  
    662683  Int       getPad                          ( Int i )      { assert (i < 2 );                      return  m_aiPad[i]; }
    663684
     685  Bool      getAccessUnitDelimiter() const  { return m_AccessUnitDelimiter; }
     686  Void      setAccessUnitDelimiter(Bool val){ m_AccessUnitDelimiter = val; }
     687
    664688  //======== Transform =============
    665689  UInt      getQuadtreeTULog2MaxSize        ()      const { return m_uiQuadtreeTULog2MaxSize; }
    … …  
    677701  //==== Motion search ========
    678702  Bool      getDisableIntraPUsInInterSlices () const { return m_bDisableIntraPUsInInterSlices; }
    679   Int       getFastSearch                   () const { return m_iFastSearch; }
     703  MESearchMethod getMotionEstimationSearchMethod ( ) const { return m_motionEstimationSearchMethod; }
    680704  Int       getSearchRange                  () const { return m_iSearchRange; }
    681705  Bool      getClipForBiPredMeEnabled       () const { return m_bClipForBiPredMeEnabled; }
    682706  Bool      getFastMEAssumingSmootherMVEnabled ( ) const { return m_bFastMEAssumingSmootherMVEnabled; }
     707  Int       getMinSearchWindow                 () const { return m_minSearchWindow; }
     708  Bool      getRestrictMESampling              () const { return m_bRestrictMESampling; }
     709
    683710#if NH_MV
    684711  Bool      getUseDisparitySearchRangeRestriction ()      { return  m_bUseDisparitySearchRangeRestriction; }
    … …  
    701728  Void      setUseSelectiveRDOQ             ( Bool b )      { m_useSelectiveRDOQ = b; }
    702729#endif
    703   Void      setRDpenalty                 ( UInt  b )     { m_rdPenalty  = b; }
    704   Void      setUseFastEnc                   ( Bool  b )     { m_bUseFastEnc = b; }
     730  Void      setRDpenalty                    ( UInt  u )     { m_rdPenalty  = u; }
     731  Void      setFastInterSearchMode          ( FastInterSearchMode m ) { m_fastInterSearchMode = m; }
    705732  Void      setUseEarlyCU                   ( Bool  b )     { m_bUseEarlyCU = b; }
    706733  Void      setUseFastDecisionForMerge      ( Bool  b )     { m_useFastDecisionForMerge = b; }
    … …  
    729756#endif
    730757  Int       getRDpenalty                    ()      { return m_rdPenalty;  }
    731   Bool      getUseFastEnc                   ()      { return m_bUseFastEnc; }
     758  FastInterSearchMode getFastInterSearchMode() const{ return m_fastInterSearchMode; }
    732759  Bool      getUseEarlyCU                   ()      { return m_bUseEarlyCU; }
    733760  Bool      getUseFastDecisionForMerge      ()      { return m_useFastDecisionForMerge; }
    … …  
    812839  UInt  getRowHeight                   ( UInt rowIdx )               { return m_tileRowHeight[rowIdx]; }
    813840  Void  xCheckGSParameters();
    814   Void  setWaveFrontSynchro(Int iWaveFrontSynchro)                   { m_iWaveFrontSynchro = iWaveFrontSynchro; }
    815   Int   getWaveFrontsynchro()                                        { return m_iWaveFrontSynchro; }
    816   Void  setDecodedPictureHashSEIEnabled(Int b)                       { m_decodedPictureHashSEIEnabled = b; }
    817   Int   getDecodedPictureHashSEIEnabled()                            { return m_decodedPictureHashSEIEnabled; }
    818   Void  setBufferingPeriodSEIEnabled(Int b)                          { m_bufferingPeriodSEIEnabled = b; }
    819   Int   getBufferingPeriodSEIEnabled()                               { return m_bufferingPeriodSEIEnabled; }
    820   Void  setPictureTimingSEIEnabled(Int b)                            { m_pictureTimingSEIEnabled = b; }
    821   Int   getPictureTimingSEIEnabled()                                 { return m_pictureTimingSEIEnabled; }
    822   Void  setRecoveryPointSEIEnabled(Int b)                            { m_recoveryPointSEIEnabled = b; }
    823   Int   getRecoveryPointSEIEnabled()                                 { return m_recoveryPointSEIEnabled; }
     841  Void  setEntropyCodingSyncEnabledFlag(Bool b)                      { m_entropyCodingSyncEnabledFlag = b; }
     842  Bool  getEntropyCodingSyncEnabledFlag() const                      { return m_entropyCodingSyncEnabledFlag; }
     843  Void  setDecodedPictureHashSEIType(HashType m)                     { m_decodedPictureHashSEIType = m; }
     844  HashType getDecodedPictureHashSEIType() const                      { return m_decodedPictureHashSEIType; }
     845  Void  setBufferingPeriodSEIEnabled(Bool b)                         { m_bufferingPeriodSEIEnabled = b; }
     846  Bool  getBufferingPeriodSEIEnabled() const                         { return m_bufferingPeriodSEIEnabled; }
     847  Void  setPictureTimingSEIEnabled(Bool b)                           { m_pictureTimingSEIEnabled = b; }
     848  Bool  getPictureTimingSEIEnabled() const                           { return m_pictureTimingSEIEnabled; }
     849  Void  setRecoveryPointSEIEnabled(Bool b)                           { m_recoveryPointSEIEnabled = b; }
     850  Bool  getRecoveryPointSEIEnabled() const                           { return m_recoveryPointSEIEnabled; }
    824851  Void  setToneMappingInfoSEIEnabled(Bool b)                         { m_toneMappingInfoSEIEnabled = b;  }
    825852  Bool  getToneMappingInfoSEIEnabled()                               { return m_toneMappingInfoSEIEnabled;  }
    … …  
    876903  Void  setTMISEIExtendedWhiteLevelLumaCodeValue(Int b)              { m_extendedWhiteLevelLumaCodeValue =b;  }
    877904  Int   getTMISEIExtendedWhiteLevelLumaCodeValue()                   { return m_extendedWhiteLevelLumaCodeValue;  }
    878   Void  setFramePackingArrangementSEIEnabled(Int b)                  { m_framePackingSEIEnabled = b; }
    879   Int   getFramePackingArrangementSEIEnabled()                       { return m_framePackingSEIEnabled; }
     905  Void  setFramePackingArrangementSEIEnabled(Bool b)                 { m_framePackingSEIEnabled = b; }
     906  Bool  getFramePackingArrangementSEIEnabled() const                 { return m_framePackingSEIEnabled; }
    880907  Void  setFramePackingArrangementSEIType(Int b)                     { m_framePackingSEIType = b; }
    881908  Int   getFramePackingArrangementSEIType()                          { return m_framePackingSEIType; }
    … …  
    886913  Void  setFramePackingArrangementSEIInterpretation(Int b)           { m_framePackingSEIInterpretation = b; }
    887914  Int   getFramePackingArrangementSEIInterpretation()                { return m_framePackingSEIInterpretation; }
    888   Void  setSegmentedRectFramePackingArrangementSEIEnabled(Int b)     { m_segmentedRectFramePackingSEIEnabled = b; }
    889   Int   getSegmentedRectFramePackingArrangementSEIEnabled()          { return m_segmentedRectFramePackingSEIEnabled; }
     915  Void  setSegmentedRectFramePackingArrangementSEIEnabled(Bool b)    { m_segmentedRectFramePackingSEIEnabled = b; }
     916  Bool  getSegmentedRectFramePackingArrangementSEIEnabled() const    { return m_segmentedRectFramePackingSEIEnabled; }
    890917  Void  setSegmentedRectFramePackingArrangementSEICancel(Int b)      { m_segmentedRectFramePackingSEICancel = b; }
    891918  Int   getSegmentedRectFramePackingArrangementSEICancel()           { return m_segmentedRectFramePackingSEICancel; }
    … …  
    896923  Void  setDisplayOrientationSEIAngle(Int b)                         { m_displayOrientationSEIAngle = b; }
    897924  Int   getDisplayOrientationSEIAngle()                              { return m_displayOrientationSEIAngle; }
    898   Void  setTemporalLevel0IndexSEIEnabled(Int b)                      { m_temporalLevel0IndexSEIEnabled = b; }
    899   Int   getTemporalLevel0IndexSEIEnabled()                           { return m_temporalLevel0IndexSEIEnabled; }
    900   Void  setGradualDecodingRefreshInfoEnabled(Int b)                  { m_gradualDecodingRefreshInfoEnabled = b;    }
    901   Int   getGradualDecodingRefreshInfoEnabled()                       { return m_gradualDecodingRefreshInfoEnabled; }
     925  Void  setTemporalLevel0IndexSEIEnabled(Bool b)                     { m_temporalLevel0IndexSEIEnabled = b; }
     926  Bool  getTemporalLevel0IndexSEIEnabled() const                     { return m_temporalLevel0IndexSEIEnabled; }
     927  Void  setGradualDecodingRefreshInfoEnabled(Bool b)                 { m_gradualDecodingRefreshInfoEnabled = b;    }
     928  Bool  getGradualDecodingRefreshInfoEnabled() const                 { return m_gradualDecodingRefreshInfoEnabled; }
    902929  Void  setNoDisplaySEITLayer(Int b)                                 { m_noDisplaySEITLayer = b;    }
    903930  Int   getNoDisplaySEITLayer()                                      { return m_noDisplaySEITLayer; }
    904   Void  setDecodingUnitInfoSEIEnabled(Int b)                         { m_decodingUnitInfoSEIEnabled = b;    }
    905   Int   getDecodingUnitInfoSEIEnabled()                              { return m_decodingUnitInfoSEIEnabled; }
    906   Void  setSOPDescriptionSEIEnabled(Int b)                           { m_SOPDescriptionSEIEnabled = b; }
    907   Int   getSOPDescriptionSEIEnabled()                                { return m_SOPDescriptionSEIEnabled; }
    908   Void  setScalableNestingSEIEnabled(Int b)                          { m_scalableNestingSEIEnabled = b; }
    909   Int   getScalableNestingSEIEnabled()                               { return m_scalableNestingSEIEnabled; }
     931  Void  setDecodingUnitInfoSEIEnabled(Bool b)                        { m_decodingUnitInfoSEIEnabled = b;    }
     932  Bool  getDecodingUnitInfoSEIEnabled() const                        { return m_decodingUnitInfoSEIEnabled; }
     933  Void  setSOPDescriptionSEIEnabled(Bool b)                          { m_SOPDescriptionSEIEnabled = b; }
     934  Bool  getSOPDescriptionSEIEnabled() const                          { return m_SOPDescriptionSEIEnabled; }
     935  Void  setScalableNestingSEIEnabled(Bool b)                         { m_scalableNestingSEIEnabled = b; }
     936  Bool  getScalableNestingSEIEnabled() const                         { return m_scalableNestingSEIEnabled; }
    910937  Void  setTMCTSSEIEnabled(Bool b)                                   { m_tmctsSEIEnabled = b; }
    911938  Bool  getTMCTSSEIEnabled()                                         { return m_tmctsSEIEnabled; }
    … …  
    939966  Void  setKneeSEIOutputKneePoint(Int *p)                            { m_kneeSEIOutputKneePoint = p; }
    940967  Int*  getKneeSEIOutputKneePoint()                                  { return m_kneeSEIOutputKneePoint; }
     968  Void  setColourRemapInfoSEIFileRoot( const std::string &s )        { m_colourRemapSEIFileRoot = s; }
     969  const std::string &getColourRemapInfoSEIFileRoot() const           { return m_colourRemapSEIFileRoot; }
     970
    941971  Void  setMasteringDisplaySEI(const TComSEIMasteringDisplay &src)   { m_masteringDisplay = src; }
    942972  const TComSEIMasteringDisplay &getMasteringDisplaySEI() const      { return m_masteringDisplay; }
    … …  
    9841014  Void         setUseScalingListId    ( ScalingListMode u )          { m_useScalingListId       = u;   }
    9851015  ScalingListMode getUseScalingListId    ()                          { return m_useScalingListId;      }
    986   Void         setScalingListFile     ( Char*  pch )                 { m_scalingListFile     = pch; }
    987   Char*        getScalingListFile     ()                             { return m_scalingListFile;    }
     1016  Void         setScalingListFileName       ( const std::string &s ) { m_scalingListFileName = s;      }
     1017  const std::string& getScalingListFileName () const                 { return m_scalingListFileName;   }
    9881018  Void         setTMVPModeId ( Int  u )                              { m_TMVPModeId = u;    }
    9891019  Int          getTMVPModeId ()                                      { return m_TMVPModeId; }
     1020  WeightedPredictionMethod getWeightedPredictionMethod() const       { return m_weightedPredictionMethod; }
     1021  Void         setWeightedPredictionMethod( WeightedPredictionMethod m ) { m_weightedPredictionMethod = m; }
    9901022  Void         setSignHideFlag( Bool signHideFlag )                  { m_signHideFlag = signHideFlag; }
    9911023  Bool         getSignHideFlag()                                     { return m_signHideFlag; }
    … …  
    10041036  Bool         getForceIntraQP        ()                             { return m_RCForceIntraQP;        }
    10051037  Void         setForceIntraQP        ( Bool b )                     { m_RCForceIntraQP = b;           }
     1038
     1039#if U0132_TARGET_BITS_SATURATION
     1040  Bool         getCpbSaturationEnabled()                             { return m_RCCpbSaturationEnabled;}
     1041  Void         setCpbSaturationEnabled( Bool b )                     { m_RCCpbSaturationEnabled = b;   }
     1042  UInt         getCpbSize             ()                             { return m_RCCpbSize;}
     1043  Void         setCpbSize             ( UInt ui )                    { m_RCCpbSize = ui;   }
     1044  Double       getInitialCpbFullness  ()                             { return m_RCInitialCpbFullness;  }
     1045  Void         setInitialCpbFullness  (Double f)                     { m_RCInitialCpbFullness = f;     }
     1046#endif
    10061047
    10071048#if KWU_RC_MADPRED_E0227
    … …  
    11321173  Bool         getLowerBitRateConstraintFlag() const                 { return m_lowerBitRateConstraintFlag; }
    11331174  Void         setLowerBitRateConstraintFlag(Bool b)                 { m_lowerBitRateConstraintFlag=b; }
    1134   Bool      getChromaSamplingFilterHintEnabled()                     { return m_chromaSamplingFilterHintEnabled;}
    1135   Void      setChromaSamplingFilterHintEnabled(Bool i)               { m_chromaSamplingFilterHintEnabled = i;}
    1136   Int       getChromaSamplingHorFilterIdc()                          { return m_chromaSamplingHorFilterIdc;}
    1137   Void      setChromaSamplingHorFilterIdc(Int i)                     { m_chromaSamplingHorFilterIdc = i;}
    1138   Int       getChromaSamplingVerFilterIdc()                          { return m_chromaSamplingVerFilterIdc;}
    1139   Void      setChromaSamplingVerFilterIdc(Int i)                     { m_chromaSamplingVerFilterIdc = i;}
     1175  Bool         getChromaResamplingFilterHintEnabled()                { return m_chromaResamplingFilterHintEnabled;}
     1176  Void         setChromaResamplingFilterHintEnabled(Bool i)          { m_chromaResamplingFilterHintEnabled = i;}
     1177  Int          getChromaResamplingHorFilterIdc()                     { return m_chromaResamplingHorFilterIdc;}
     1178  Void         setChromaResamplingHorFilterIdc(Int i)                { m_chromaResamplingHorFilterIdc = i;}
     1179  Int          getChromaResamplingVerFilterIdc()                     { return m_chromaResamplingVerFilterIdc;}
     1180  Void         setChromaResamplingVerFilterIdc(Int i)                { m_chromaResamplingVerFilterIdc = i;}
    11401181
    11411182  Void      setSummaryOutFilename(const std::string &s)              { m_summaryOutFilename = s; }

  • branches/HTM-15.2-dev/source/Lib/TLibEncoder/TEncCu.cpp

    r1321 r1360  
    22162216          *earlyDetectionSkipMode = true;
    22172217        }
    2218         else if(m_pcEncCfg->getFastSearch() != SELECTIVE)
     2218        else if(m_pcEncCfg->getMotionEstimationSearchMethod() != MESEARCH_SELECTIVE)
    22192219        {
    22202220          Int absoulte_MV=0;

  • branches/HTM-15.2-dev/source/Lib/TLibEncoder/TEncGOP.cpp

    r1356 r1360  
    219219}
    220220
     221Void TEncGOP::xWriteAccessUnitDelimiter (AccessUnit &accessUnit, TComSlice *slice)
     222{
     223  AUDWriter audWriter;
     224  OutputNALUnit nalu(NAL_UNIT_ACCESS_UNIT_DELIMITER);
     225
     226  Int picType = slice->isIntra() ? 0 : (slice->isInterP() ? 1 : 2);
     227
     228  audWriter.codeAUD(nalu.m_Bitstream, picType);
     229  accessUnit.push_front(new NALUnitEBSP(nalu));
     230}
     231
    221232// write SEI list into one NAL unit and add it to the Access unit at auPos
    222233Void TEncGOP::xWriteSEI (NalUnitType naluType, SEIMessages& seiMessages, AccessUnit &accessUnit, AccessUnit::iterator &auPos, Int temporalId, const TComSPS *sps)
    … …  
    485496  }
    486497
     498  if(m_pcCfg->getChromaResamplingFilterHintEnabled())
     499  {
     500    SEIChromaResamplingFilterHint *seiChromaResamplingFilterHint = new SEIChromaResamplingFilterHint;
     501    m_seiEncoder.initSEIChromaResamplingFilterHint(seiChromaResamplingFilterHint, m_pcCfg->getChromaResamplingHorFilterIdc(), m_pcCfg->getChromaResamplingVerFilterIdc());
     502    seiMessages.push_back(seiChromaResamplingFilterHint);
     503  }
     504
     505
    487506#if NH_MV
    488507#if !NH_MV_SEI
    … …  
    545564  }
    546565
    547   if(slice->getSPS()->getVuiParametersPresentFlag() && m_pcCfg->getChromaSamplingFilterHintEnabled() && ( slice->getSliceType() == I_SLICE ))
    548   {
    549     SEIChromaSamplingFilterHint *seiChromaSamplingFilterHint = new SEIChromaSamplingFilterHint;
    550     m_seiEncoder.initSEIChromaSamplingFilterHint(seiChromaSamplingFilterHint, m_pcCfg->getChromaSamplingHorFilterIdc(), m_pcCfg->getChromaSamplingVerFilterIdc());
    551     seiMessages.push_back(seiChromaSamplingFilterHint);
    552   }
    553 
    554566  if( m_pcEncTop->getNoDisplaySEITLayer() && ( slice->getTLayer() >= m_pcEncTop->getNoDisplaySEITLayer() ) )
    555567  {
    … …  
    557569    seiNoDisplay->m_noDisplay = true;
    558570    seiMessages.push_back(seiNoDisplay);
     571  }
     572
     573  // insert one Colour Remapping Info SEI for the picture (if the file exists)
     574  if (!m_pcCfg->getColourRemapInfoSEIFileRoot().empty())
     575  {
     576    SEIColourRemappingInfo *seiColourRemappingInfo = new SEIColourRemappingInfo();
     577    const Bool success = m_seiEncoder.initSEIColourRemappingInfo(seiColourRemappingInfo, slice->getPOC() );
     578
     579    if(success)
     580    {
     581      seiMessages.push_back(seiColourRemappingInfo);
     582    }
     583    else
     584    {
     585      delete seiColourRemappingInfo;
     586    }
    559587  }
    560588}
    … …  
    577605Void TEncGOP::xCreatePictureTimingSEI  (Int IRAPGOPid, SEIMessages& seiMessages, SEIMessages& nestedSeiMessages, SEIMessages& duInfoSeiMessages, TComSlice *slice, Bool isField, std::deque<DUData> &duData)
    578606{
    579   Int picSptDpbOutputDuDelay = 0;
    580607#if !NH_MV
    581608  SEIPictureTiming *pictureTimingSEI = new SEIPictureTiming();
    … …  
    590617    (  hrd->getNalHrdParametersPresentFlag() || hrd->getVclHrdParametersPresentFlag() ) )
    591618  {
    592 #if NH_MV
    593     // Preliminary fix to avoid memory leak.
     619    Int picSptDpbOutputDuDelay = 0;
    594620    SEIPictureTiming *pictureTimingSEI = new SEIPictureTiming();
    595 #endif
    596621
    597622    // DU parameters
    … …  
    712737      }
    713738    }
     739
     740    if( !m_pcCfg->getPictureTimingSEIEnabled() && pictureTimingSEI )
     741    {
     742      delete pictureTimingSEI;
     743    }
    714744  }
    715745}
    … …  
    745775
    746776  // The last DU may have a trailing SEI
    747   if (m_pcCfg->getDecodedPictureHashSEIEnabled())
     777  if (m_pcCfg->getDecodedPictureHashSEIType()!=HASHTYPE_NONE)
    748778  {
    749779    duData.back().accumBitsDU += ( 20 << 3 ); // probably around 20 bytes - should be further adjusted, e.g. by type
    … …  
    867897      if (cabacZeroWordPaddingEnabled)
    868898      {
    869         std::vector<Char> zeroBytesPadding(numberOfAdditionalCabacZeroBytes, Char(0));
     899        std::vector<UChar> zeroBytesPadding(numberOfAdditionalCabacZeroBytes, UChar(0));
    870900        for(std::size_t i=0; i<numberOfAdditionalCabacZeroWords; i++)
    871901        {
    872902          zeroBytesPadding[i*3+2]=3;  // 00 00 03
    873903        }
    874         nalUnitData.write(&(zeroBytesPadding[0]), numberOfAdditionalCabacZeroBytes);
     904        nalUnitData.write(reinterpret_cast<const TChar*>(&(zeroBytesPadding[0])), numberOfAdditionalCabacZeroBytes);
    875905        printf("Adding %d bytes of padding\n", UInt(numberOfAdditionalCabacZeroWords*3));
    876906      }
    … …  
    10581088  {
    10591089    return 1;
     1090  }
     1091}
     1092
     1093
     1094static Void
     1095printHash(const HashType hashType, const std::string &digestStr)
     1096{
     1097  const TChar *decodedPictureHashModeName;
     1098  switch (hashType)
     1099  {
     1100    case HASHTYPE_MD5:
     1101      decodedPictureHashModeName = "MD5";
     1102      break;
     1103    case HASHTYPE_CRC:
     1104      decodedPictureHashModeName = "CRC";
     1105      break;
     1106    case HASHTYPE_CHECKSUM:
     1107      decodedPictureHashModeName = "Checksum";
     1108      break;
     1109    default:
     1110      decodedPictureHashModeName = NULL;
     1111      break;
     1112  }
     1113  if (decodedPictureHashModeName != NULL)
     1114  {
     1115    if (digestStr.empty())
     1116    {
     1117      printf(" [%s:%s]", decodedPictureHashModeName, "?");
     1118    }
     1119    else
     1120    {
     1121      printf(" [%s:%s]", decodedPictureHashModeName, digestStr.c_str());
     1122    }
    10601123  }
    10611124}
    … …  
    16061669#endif
    16071670
    1608     /////////////////////////////////////////////////////////////////////////////////////////////////// Compress a slice
    1609     //  Slice compression
    1610     if (m_pcCfg->getUseASR())
     1671    if (m_pcCfg->getUseASR() && pcSlice->getSliceType()!=I_SLICE)
    16111672    {
    16121673      m_pcSliceEncoder->setSearchRange(pcSlice);
    … …  
    16541715      }
    16551716      m_pcRateCtrl->initRCPic( frameLevel );
     1717      estimatedBits = m_pcRateCtrl->getRCPic()->getTargetBits();
    16561718
    16571719#if KWU_RC_MADPRED_E0227
    … …  
    16621724#endif
    16631725
    1664       estimatedBits = m_pcRateCtrl->getRCPic()->getTargetBits();
     1726#if U0132_TARGET_BITS_SATURATION
     1727      if (m_pcRateCtrl->getCpbSaturationEnabled() && frameLevel != 0)
     1728      {
     1729        Int estimatedCpbFullness = m_pcRateCtrl->getCpbState() + m_pcRateCtrl->getBufferingRate();
     1730
     1731        // prevent overflow
     1732        if (estimatedCpbFullness - estimatedBits > (Int)(m_pcRateCtrl->getCpbSize()*0.9f))
     1733        {
     1734          estimatedBits = estimatedCpbFullness - (Int)(m_pcRateCtrl->getCpbSize()*0.9f);
     1735        }
     1736
     1737        estimatedCpbFullness -= m_pcRateCtrl->getBufferingRate();
     1738        // prevent underflow
     1739        if (estimatedCpbFullness - estimatedBits < (Int)(m_pcRateCtrl->getCpbSize()*0.1f))
     1740        {
     1741          estimatedBits = max(200, estimatedCpbFullness - (Int)(m_pcRateCtrl->getCpbSize()*0.1f));
     1742        }
     1743
     1744        m_pcRateCtrl->getRCPic()->setTargetBits(estimatedBits);
     1745      }
     1746#endif
    16651747
    16661748      Int sliceQP = m_pcCfg->getInitialQP();
    … …  
    16831765          Int bits = m_pcRateCtrl->getRCSeq()->getLeftAverageBits();
    16841766          bits = m_pcRateCtrl->getRCPic()->getRefineBitsForIntra( bits );
     1767
     1768#if U0132_TARGET_BITS_SATURATION
     1769          if (m_pcRateCtrl->getCpbSaturationEnabled() )
     1770          {
     1771            Int estimatedCpbFullness = m_pcRateCtrl->getCpbState() + m_pcRateCtrl->getBufferingRate();
     1772
     1773            // prevent overflow
     1774            if (estimatedCpbFullness - bits > (Int)(m_pcRateCtrl->getCpbSize()*0.9f))
     1775            {
     1776              bits = estimatedCpbFullness - (Int)(m_pcRateCtrl->getCpbSize()*0.9f);
     1777            }
     1778
     1779            estimatedCpbFullness -= m_pcRateCtrl->getBufferingRate();
     1780            // prevent underflow
     1781            if (estimatedCpbFullness - bits < (Int)(m_pcRateCtrl->getCpbSize()*0.1f))
     1782            {
     1783              bits = estimatedCpbFullness - (Int)(m_pcRateCtrl->getCpbSize()*0.1f);
     1784            }
     1785          }
     1786#endif
     1787
    16851788          if ( bits < 200 )
    16861789          {
    … …  
    18351938      m_bSeqFirst = false;
    18361939    }
     1940    if (m_pcCfg->getAccessUnitDelimiter())
     1941    {
     1942      xWriteAccessUnitDelimiter(accessUnit, pcSlice);
     1943    }
    18371944
    18381945    // reset presence of BP SEI indication
    … …  
    20022109
    20032110    std::string digestStr;
    2004     if (m_pcCfg->getDecodedPictureHashSEIEnabled())
     2111    if (m_pcCfg->getDecodedPictureHashSEIType()!=HASHTYPE_NONE)
    20052112    {
    20062113      SEIDecodedPictureHash *decodedPictureHashSei = new SEIDecodedPictureHash();
    … …  
    20142121    xCalculateAddPSNRs( isField, isTff, iGOPid, pcPic, accessUnit, rcListPic, dEncTime, snr_conversion, printFrameMSE );
    20152122
    2016     if (!digestStr.empty())
    2017     {
    2018       if(m_pcCfg->getDecodedPictureHashSEIEnabled() == 1)
    2019       {
    2020         printf(" [MD5:%s]", digestStr.c_str());
    2021       }
    2022       else if(m_pcCfg->getDecodedPictureHashSEIEnabled() == 2)
    2023       {
    2024         printf(" [CRC:%s]", digestStr.c_str());
    2025       }
    2026       else if(m_pcCfg->getDecodedPictureHashSEIEnabled() == 3)
    2027       {
    2028         printf(" [Checksum:%s]", digestStr.c_str());
    2029       }
    2030     }
     2123    printHash(m_pcCfg->getDecodedPictureHashSEIType(), digestStr);
    20312124
    20322125    if ( m_pcCfg->getUseRateCtrl() )
    … …  
    20512144        m_pcRateCtrl->getRCGOP()->updateAfterPicture( estimatedBits );
    20522145      }
     2146#if U0132_TARGET_BITS_SATURATION
     2147      if (m_pcRateCtrl->getCpbSaturationEnabled())
     2148      {
     2149        m_pcRateCtrl->updateCpbState(actualTotalBits);
     2150        printf(" [CPB %6d bits]", m_pcRateCtrl->getCpbState());
     2151      }
     2152#endif
    20532153    }
    20542154
    … …  
    23522452  if (conversion!=IPCOLOURSPACE_UNCHANGED)
    23532453  {
    2354     cscd.create(pcPicD->getWidth(COMPONENT_Y), pcPicD->getHeight(COMPONENT_Y), pcPicD->getChromaFormat(), pcPicD->getWidth(COMPONENT_Y), pcPicD->getHeight(COMPONENT_Y), 0, false);
     2454    cscd.createWithoutCUInfo(pcPicD->getWidth(COMPONENT_Y), pcPicD->getHeight(COMPONENT_Y), pcPicD->getChromaFormat() );
    23552455    TVideoIOYuv::ColourSpaceConvert(*pcPicD, cscd, conversion, false);
    23562456  }
    … …  
    24522552  }
    24532553
    2454   Char c = (pcSlice->isIntra() ? 'I' : pcSlice->isInterP() ? 'P' : 'B');
     2554  TChar c = (pcSlice->isIntra() ? 'I' : pcSlice->isInterP() ? 'P' : 'B');
    24552555  if (!pcSlice->isReferenced())
    24562556  {
    … …  
    25062606  printf(" [ET %5.0f ]", dEncTime );
    25072607
     2608  // printf(" [WP %d]", pcSlice->getUseWeightedPrediction());
     2609
    25082610  for (Int iRefList = 0; iRefList < 2; iRefList++)
    25092611  {
    … …  
    25552657    {
    25562658      TComPicYuv &reconField=*(apcPicRecFields[fieldNum]);
    2557       cscd[fieldNum].create(reconField.getWidth(COMPONENT_Y), reconField.getHeight(COMPONENT_Y), reconField.getChromaFormat(), reconField.getWidth(COMPONENT_Y), reconField.getHeight(COMPONENT_Y), 0, false);
     2659      cscd[fieldNum].createWithoutCUInfo(reconField.getWidth(COMPONENT_Y), reconField.getHeight(COMPONENT_Y), reconField.getChromaFormat() );
    25582660      TVideoIOYuv::ColourSpaceConvert(reconField, cscd[fieldNum], conversion, false);
    25592661      apcPicRecFields[fieldNum]=cscd+fieldNum;

  • branches/HTM-15.2-dev/source/Lib/TLibEncoder/TEncGOP.h

    r1313 r1360  
    220220  Double xCalculateRVM();
    221221
     222  Void xWriteAccessUnitDelimiter (AccessUnit &accessUnit, TComSlice *slice);
     223
    222224  Void xCreateIRAPLeadingSEIMessages (SEIMessages& seiMessages, const TComSPS *sps, const TComPPS *pps);
    223225  Void xCreatePerPictureSEIMessages (Int picInGOP, SEIMessages& seiMessages, SEIMessages& nestedSeiMessages, TComSlice *slice);

  • branches/HTM-15.2-dev/source/Lib/TLibEncoder/TEncPreanalyzer.cpp

    r1313 r1360  
    8787        UInt64 uiSum[4] = {0, 0, 0, 0};
    8888        UInt64 uiSumSq[4] = {0, 0, 0, 0};
    89         UInt uiNumPixInAQPart = 0;
    9089        UInt by = 0;
    9190        for ( ; by < uiCurrAQPartHeight>>1; by++ )
    9291        {
    9392          UInt bx = 0;
    94           for ( ; bx < uiCurrAQPartWidth>>1; bx++, uiNumPixInAQPart++ )
     93          for ( ; bx < uiCurrAQPartWidth>>1; bx++ )
    9594          {
    9695            uiSum  [0] += pBlkY[bx];
    9796            uiSumSq[0] += pBlkY[bx] * pBlkY[bx];
    9897          }
    99           for ( ; bx < uiCurrAQPartWidth; bx++, uiNumPixInAQPart++ )
     98          for ( ; bx < uiCurrAQPartWidth; bx++ )
    10099          {
    101100            uiSum  [1] += pBlkY[bx];
    … …  
    107106        {
    108107          UInt bx = 0;
    109           for ( ; bx < uiCurrAQPartWidth>>1; bx++, uiNumPixInAQPart++ )
     108          for ( ; bx < uiCurrAQPartWidth>>1; bx++ )
    110109          {
    111110            uiSum  [2] += pBlkY[bx];
    112111            uiSumSq[2] += pBlkY[bx] * pBlkY[bx];
    113112          }
    114           for ( ; bx < uiCurrAQPartWidth; bx++, uiNumPixInAQPart++ )
     113          for ( ; bx < uiCurrAQPartWidth; bx++ )
    115114          {
    116115            uiSum  [3] += pBlkY[bx];
    … …  
    120119        }
    121120
     121        assert ((uiCurrAQPartWidth&1)==0);
     122        assert ((uiCurrAQPartHeight&1)==0);
     123        const UInt pixelWidthOfQuadrants  = uiCurrAQPartWidth >>1;
     124        const UInt pixelHeightOfQuadrants = uiCurrAQPartHeight>>1;
     125        const UInt numPixInAQPart         = pixelWidthOfQuadrants * pixelHeightOfQuadrants;
     126
    122127        Double dMinVar = DBL_MAX;
     128        if (numPixInAQPart!=0)
     129        {
    123130        for ( Int i=0; i<4; i++)
    124131        {
    125           const Double dAverage = Double(uiSum[i]) / uiNumPixInAQPart;
    126           const Double dVariance = Double(uiSumSq[i]) / uiNumPixInAQPart - dAverage * dAverage;
     132            const Double dAverage = Double(uiSum[i]) / numPixInAQPart;
     133            const Double dVariance = Double(uiSumSq[i]) / numPixInAQPart - dAverage * dAverage;
    127134          dMinVar = min(dMinVar, dVariance);
     135        }
     136        }
     137        else
     138        {
     139          dMinVar = 0.0;
    128140        }
    129141        const Double dActivity = 1.0 + dMinVar;

  • branches/HTM-15.2-dev/source/Lib/TLibEncoder/TEncRateCtrl.cpp

    r1313 r1360  
    16391639    m_encRCSeq->initLCUPara();
    16401640  }
     1641#if U0132_TARGET_BITS_SATURATION
     1642  m_CpbSaturationEnabled = false;
     1643  m_cpbSize              = targetBitrate;
     1644  m_cpbState             = (UInt)(m_cpbSize*0.5f);
     1645  m_bufferingRate        = (Int)(targetBitrate / frameRate);
     1646#endif
    16411647
    16421648#if KWU_RC_MADPRED_E0227
    … …  
    16641670}
    16651671
     1672#if U0132_TARGET_BITS_SATURATION
     1673Int  TEncRateCtrl::updateCpbState(Int actualBits)
     1674{
     1675  Int cpbState = 1;
     1676
     1677  m_cpbState -= actualBits;
     1678  if (m_cpbState < 0)
     1679  {
     1680    cpbState = -1;
     1681  }
     1682
     1683  m_cpbState += m_bufferingRate;
     1684  if (m_cpbState > m_cpbSize)
     1685  {
     1686    cpbState = 0;
     1687  }
     1688
     1689  return cpbState;
     1690}
     1691
     1692Void TEncRateCtrl::initHrdParam(const TComHRD* pcHrd, Int iFrameRate, Double fInitialCpbFullness)
     1693{
     1694  m_CpbSaturationEnabled = true;
     1695  m_cpbSize = (pcHrd->getCpbSizeValueMinus1(0, 0, 0) + 1) << (4 + pcHrd->getCpbSizeScale());
     1696  m_cpbState = (UInt)(m_cpbSize*fInitialCpbFullness);
     1697  m_bufferingRate = (UInt)(((pcHrd->getBitRateValueMinus1(0, 0, 0) + 1) << (6 + pcHrd->getBitRateScale())) / iFrameRate);
     1698  printf("\nHRD - [Initial CPB state %6d] [CPB Size %6d] [Buffering Rate %6d]\n", m_cpbState, m_cpbSize, m_bufferingRate);
     1699}
     1700#endif
     1701
    16661702Void TEncRateCtrl::destroyRCGOP()
    16671703{

  • branches/HTM-15.2-dev/source/Lib/TLibEncoder/TEncRateCtrl.h

    r1313 r1360  
    285285  TRCLCU& getLCU( Int LCUIdx )                            { return m_LCUs[LCUIdx]; }
    286286  Int  getPicActualHeaderBits()                           { return m_picActualHeaderBits; }
     287#if U0132_TARGET_BITS_SATURATION
     288  Void setBitLeft(Int bits)                               { m_bitsLeft = bits; }
     289#endif
    287290  Void setTargetBits( Int bits )                          { m_targetBits = bits; m_bitsLeft = bits;}
    288291  Void setTotalIntraCost(Double cost)                     { m_totalCostIntra = cost; }
    … …  
    369372  Void setLayerID(Int layerid)     { m_LayerID = layerid; }
    370373#endif
     374#if U0132_TARGET_BITS_SATURATION
     375  Bool       getCpbSaturationEnabled()  { return m_CpbSaturationEnabled;  }
     376  UInt       getCpbState()              { return m_cpbState;       }
     377  UInt       getCpbSize()               { return m_cpbSize;        }
     378  UInt       getBufferingRate()         { return m_bufferingRate;  }
     379  Int        updateCpbState(Int actualBits);
     380  Void       initHrdParam(const TComHRD* pcHrd, Int iFrameRate, Double fInitialCpbFullness);
     381#endif
     382
    371383private:
    372384  TEncRCSeq* m_encRCSeq;
    … …  
    375387  list<TEncRCPic*> m_listRCPictures;
    376388  Int        m_RCQP;
     389#if U0132_TARGET_BITS_SATURATION
     390  Bool       m_CpbSaturationEnabled;    // Enable target bits saturation to avoid CPB overflow and underflow
     391  Int        m_cpbState;                // CPB State
     392  UInt       m_cpbSize;                 // CPB size
     393  UInt       m_bufferingRate;           // Buffering rate
     394#endif
     395
    377396#if KWU_RC_MADPRED_E0227
    378397  Int m_LayerID;

  • branches/HTM-15.2-dev/source/Lib/TLibEncoder/TEncSampleAdaptiveOffset.cpp

    r1321 r1360  
    908908      m_signLineBuf1 = NULL;
    909909    }
    910     m_signLineBuf1 = new Char[m_lineBufWidth+1];
     910    m_signLineBuf1 = new SChar[m_lineBufWidth+1];
    911911
    912912    if (m_signLineBuf2)
    … …  
    915915      m_signLineBuf2 = NULL;
    916916    }
    917     m_signLineBuf2 = new Char[m_lineBufWidth+1];
     917    m_signLineBuf2 = new SChar[m_lineBufWidth+1];
    918918  }
    919919
    920920  Int x,y, startX, startY, endX, endY, edgeType, firstLineStartX, firstLineEndX;
    921   Char signLeft, signRight, signDown;
     921  SChar signLeft, signRight, signDown;
    922922  Int64 *diff, *count;
    923923  Pel *srcLine, *orgLine;
    … …  
    949949        for (y=0; y<endY; y++)
    950950        {
    951           signLeft = (Char)sgn(srcLine[startX] - srcLine[startX-1]);
     951          signLeft = (SChar)sgn(srcLine[startX] - srcLine[startX-1]);
    952952          for (x=startX; x<endX; x++)
    953953          {
    954             signRight =  (Char)sgn(srcLine[x] - srcLine[x+1]);
     954            signRight =  (SChar)sgn(srcLine[x] - srcLine[x+1]);
    955955            edgeType  =  signRight + signLeft;
    956956            signLeft  = -signRight;
    … …  
    971971            for(y=0; y<skipLinesB[typeIdx]; y++)
    972972            {
    973               signLeft = (Char)sgn(srcLine[startX] - srcLine[startX-1]);
     973              signLeft = (SChar)sgn(srcLine[startX] - srcLine[startX-1]);
    974974              for (x=startX; x<endX; x++)
    975975              {
    976                 signRight =  (Char)sgn(srcLine[x] - srcLine[x+1]);
     976                signRight =  (SChar)sgn(srcLine[x] - srcLine[x+1]);
    977977                edgeType  =  signRight + signLeft;
    978978                signLeft  = -signRight;
    … …  
    992992        diff +=2;
    993993        count+=2;
    994         Char *signUpLine = m_signLineBuf1;
     994        SChar *signUpLine = m_signLineBuf1;
    995995
    996996        startX = (!isCalculatePreDeblockSamples) ? 0
    … …  
    10111011        for (x=startX; x<endX; x++)
    10121012        {
    1013           signUpLine[x] = (Char)sgn(srcLine[x] - srcLineAbove[x]);
     1013          signUpLine[x] = (SChar)sgn(srcLine[x] - srcLineAbove[x]);
    10141014        }
    10151015
    … …  
    10211021          for (x=startX; x<endX; x++)
    10221022          {
    1023             signDown  = (Char)sgn(srcLine[x] - srcLineBelow[x]);
     1023            signDown  = (SChar)sgn(srcLine[x] - srcLineBelow[x]);
    10241024            edgeType  = signDown + signUpLine[x];
    10251025            signUpLine[x]= -signDown;
    … …  
    10611061        diff +=2;
    10621062        count+=2;
    1063         Char *signUpLine, *signDownLine, *signTmpLine;
     1063        SChar *signUpLine, *signDownLine, *signTmpLine;
    10641064
    10651065        signUpLine  = m_signLineBuf1;
    … …  
    10791079        for (x=startX; x<endX+1; x++)
    10801080        {
    1081           signUpLine[x] = (Char)sgn(srcLineBelow[x] - srcLine[x-1]);
     1081          signUpLine[x] = (SChar)sgn(srcLineBelow[x] - srcLine[x-1]);
    10821082        }
    10831083
    … …  
    11031103          for (x=startX; x<endX; x++)
    11041104          {
    1105             signDown = (Char)sgn(srcLine[x] - srcLineBelow[x+1]);
     1105            signDown = (SChar)sgn(srcLine[x] - srcLineBelow[x+1]);
    11061106            edgeType = signDown + signUpLine[x];
    11071107            diff [edgeType] += (orgLine[x] - srcLine[x]);
    … …  
    11101110            signDownLine[x+1] = -signDown;
    11111111          }
    1112           signDownLine[startX] = (Char)sgn(srcLineBelow[startX] - srcLine[startX-1]);
     1112          signDownLine[startX] = (SChar)sgn(srcLineBelow[startX] - srcLine[startX-1]);
    11131113
    11141114          signTmpLine  = signUpLine;
    … …  
    11481148        diff +=2;
    11491149        count+=2;
    1150         Char *signUpLine = m_signLineBuf1+1;
     1150        SChar *signUpLine = m_signLineBuf1+1;
    11511151
    11521152        startX = (!isCalculatePreDeblockSamples) ? (isLeftAvail  ? 0 : 1)
    … …  
    11621162        for (x=startX-1; x<endX; x++)
    11631163        {
    1164           signUpLine[x] = (Char)sgn(srcLineBelow[x] - srcLine[x+1]);
     1164          signUpLine[x] = (SChar)sgn(srcLineBelow[x] - srcLine[x+1]);
    11651165        }
    11661166
    … …  
    11911191          for(x=startX; x<endX; x++)
    11921192          {
    1193             signDown = (Char)sgn(srcLine[x] - srcLineBelow[x-1]);
     1193            signDown = (SChar)sgn(srcLine[x] - srcLineBelow[x-1]);
    11941194            edgeType = signDown + signUpLine[x];
    11951195
    … …  
    11991199            signUpLine[x-1] = -signDown;
    12001200          }
    1201           signUpLine[endX-1] = (Char)sgn(srcLineBelow[endX-1] - srcLine[endX]);
     1201          signUpLine[endX-1] = (SChar)sgn(srcLineBelow[endX-1] - srcLine[endX]);
    12021202          srcLine  += srcStride;
    12031203          orgLine  += orgStride;

  • branches/HTM-15.2-dev/source/Lib/TLibEncoder/TEncSearch.cpp

    r1321 r1360  
    7474};
    7575
    76 static const UInt s_auiDFilter[9] =
    77 {
    78   0, 1, 0,
    79   2, 3, 2,
    80   0, 1, 0
    81 };
    82 
    8376static Void offsetSubTUCBFs(TComTU &rTu, const ComponentID compID)
    8477{
    … …  
    120113, m_iSearchRange (0)
    121114, m_bipredSearchRange (0)
    122 , m_iFastSearch (0)
    123115, m_pppcRDSbacCoder (NULL)
    124116, m_pcRDGoOnSbacCoder (NULL)
    125117, m_pTempPel (NULL)
    126 , m_puiDFilter (NULL)
    127118, m_isInitialized (false)
    128119{
    … …  
    130121  {
    131122    m_ppcQTTempCoeff[ch]                           = NULL;
    132     m_pcQTTempCoeff[ch]                            = NULL;
    133123#if ADAPTIVE_QP_SELECTION
    134124    m_ppcQTTempArlCoeff[ch]                        = NULL;
    135     m_pcQTTempArlCoeff[ch]                         = NULL;
    136125#endif
    137126    m_puhQTTempCbf[ch]                             = NULL;
    … …  
    181170      }
    182171      delete[] m_ppcQTTempCoeff[ch];
    183       delete[] m_pcQTTempCoeff[ch];
    184172      delete[] m_puhQTTempCbf[ch];
    185173#if ADAPTIVE_QP_SELECTION
    186174      delete[] m_ppcQTTempArlCoeff[ch];
    187       delete[] m_pcQTTempArlCoeff[ch];
    188175#endif
    189176    }
    … …  
    229216                      Int           iSearchRange,
    230217                      Int           bipredSearchRange,
    231                       Int           iFastSearch,
     218                      MESearchMethod motionEstimationSearchMethod,
    232219                      const UInt    maxCUWidth,
    233220                      const UInt    maxCUHeight,
    … …  
    244231  m_iSearchRange         = iSearchRange;
    245232  m_bipredSearchRange    = bipredSearchRange;
    246   m_iFastSearch          = iFastSearch;
     233  m_motionEstimationSearchMethod = motionEstimationSearchMethod;
    247234  m_pcEntropyCoder       = pcEntropyCoder;
    248235  m_pcRdCost             = pcRdCost;
    … …  
    258245    }
    259246  }
    260 
    261   m_puiDFilter = s_auiDFilter + 4;
    262247
    263248  // initialize motion cost
    … …  
    289274    const UInt csy=::getComponentScaleY(ComponentID(ch), cform);
    290275    m_ppcQTTempCoeff[ch] = new TCoeff* [uiNumLayersToAllocate];
    291     m_pcQTTempCoeff[ch]   = new TCoeff [(maxCUWidth*maxCUHeight)>>(csx+csy)   ];
    292276#if ADAPTIVE_QP_SELECTION
    293277    m_ppcQTTempArlCoeff[ch]  = new TCoeff*[uiNumLayersToAllocate];
    294     m_pcQTTempArlCoeff[ch]   = new TCoeff [(maxCUWidth*maxCUHeight)>>(csx+csy)   ];
    295278#endif
    296279    m_puhQTTempCbf[ch] = new UChar  [uiNumPartitions];
    … …  
    304287    }
    305288
    306     m_phQTTempCrossComponentPredictionAlpha[ch]    = new Char  [uiNumPartitions];
     289    m_phQTTempCrossComponentPredictionAlpha[ch]    = new SChar  [uiNumPartitions];
    307290    m_pSharedPredTransformSkip[ch]                 = new Pel   [MAX_CU_SIZE*MAX_CU_SIZE];
    308291    m_pcQTTempTUCoeff[ch]                          = new TCoeff[MAX_CU_SIZE*MAX_CU_SIZE];
    … …  
    323306}
    324307
    325 #define TZ_SEARCH_CONFIGURATION                                                                                 \
    326 const Int  iRaster                  = 5;  /* TZ soll von aussen ?ergeben werden */                            \
    327 const Bool bTestOtherPredictedMV    = 0;                                                                      \
    328 const Bool bTestZeroVector          = 1;                                                                      \
    329 const Bool bTestZeroVectorStart     = 0;                                                                      \
    330 const Bool bTestZeroVectorStop      = 0;                                                                      \
    331 const Bool bFirstSearchDiamond      = 1;  /* 1 = xTZ8PointDiamondSearch   0 = xTZ8PointSquareSearch */        \
    332 const Bool bFirstSearchStop         = m_pcEncCfg->getFastMEAssumingSmootherMVEnabled();                       \
    333 const UInt uiFirstSearchRounds      = 3;  /* first search stop X rounds after best match (must be >=1) */     \
    334 const Bool bEnableRasterSearch      = 1;                                                                      \
    335 const Bool bAlwaysRasterSearch      = 0;  /* ===== 1: BETTER but factor 2 slower ===== */                     \
    336 const Bool bRasterRefinementEnable  = 0;  /* enable either raster refinement or star refinement */            \
    337 const Bool bRasterRefinementDiamond = 0;  /* 1 = xTZ8PointDiamondSearch   0 = xTZ8PointSquareSearch */        \
    338 const Bool bStarRefinementEnable    = 1;  /* enable either star refinement or raster refinement */            \
    339 const Bool bStarRefinementDiamond   = 1;  /* 1 = xTZ8PointDiamondSearch   0 = xTZ8PointSquareSearch */        \
    340 const Bool bStarRefinementStop      = 0;                                                                      \
    341 const UInt uiStarRefinementRounds   = 2;  /* star refinement stop X rounds after best match (must be >=1) */  \
    342 
    343 
    344 #define SEL_SEARCH_CONFIGURATION                                                                                 \
    345   const Bool bTestOtherPredictedMV    = 1;                                                                       \
    346   const Bool bTestZeroVector          = 1;                                                                       \
    347   const Bool bEnableRasterSearch      = 1;                                                                       \
    348   const Bool bAlwaysRasterSearch      = 0;  /* ===== 1: BETTER but factor 15x slower ===== */                    \
    349   const Bool bStarRefinementEnable    = 1;  /* enable either star refinement or raster refinement */             \
    350   const Bool bStarRefinementDiamond   = 1;  /* 1 = xTZ8PointDiamondSearch   0 = xTZ8PointSquareSearch */         \
    351   const Bool bStarRefinementStop      = 0;                                                                       \
    352   const UInt uiStarRefinementRounds   = 2;  /* star refinement stop X rounds after best match (must be >=1) */   \
    353   const UInt uiSearchRange            = m_iSearchRange;                                                          \
    354   const Int  uiSearchRangeInitial     = m_iSearchRange >> 2;                                                     \
    355   const Int  uiSearchStep             = 4;                                                                       \
    356   const Int  iMVDistThresh            = 8;                                                                       \
    357 
    358 
    359 
    360 __inline Void TEncSearch::xTZSearchHelp( TComPattern* pcPatternKey, IntTZSearchStruct& rcStruct, const Int iSearchX, const Int iSearchY, const UChar ucPointNr, const UInt uiDistance )
     308
     309
     310
     311__inline Void TEncSearch::xTZSearchHelp( const TComPattern* const pcPatternKey, IntTZSearchStruct& rcStruct, const Int iSearchX, const Int iSearchY, const UChar ucPointNr, const UInt uiDistance )
    361312{
    362313  Distortion  uiSad = 0;
    363314
    364   Pel*  piRefSrch;
    365 
    366   piRefSrch = rcStruct.piRefY + iSearchY * rcStruct.iYStride + iSearchX;
     315  const Pel* const  piRefSrch = rcStruct.piRefY + iSearchY * rcStruct.iYStride + iSearchX;
     316
    367317#if NH_3D_IC
    368318  m_cDistParam.bUseIC = pcPatternKey->getICFlag();
    … …  
    374324  m_pcRdCost->setDistParam( pcPatternKey, piRefSrch, rcStruct.iYStride,  m_cDistParam );
    375325
    376   if(m_pcEncCfg->getFastSearch() != SELECTIVE)
    377   {
    378     // fast encoder decision: use subsampled SAD when rows > 8 for integer ME
    379     if ( m_pcEncCfg->getUseFastEnc() )
    380     {
    381       if ( m_cDistParam.iRows > 8 )
    382       {
    383         m_cDistParam.iSubShift = 1;
    384       }
    385     }
    386   }
    387 
    388326  setDistParamComp(COMPONENT_Y);
    389327
    390328  // distortion
    391329  m_cDistParam.bitDepth = pcPatternKey->getBitDepthY();
    392   if(m_pcEncCfg->getFastSearch() == SELECTIVE)
     330  m_cDistParam.m_maximumDistortionForEarlyExit = rcStruct.uiBestSad;
     331
     332  if((m_pcEncCfg->getRestrictMESampling() == false) && m_pcEncCfg->getMotionEstimationSearchMethod() == MESEARCH_SELECTIVE)
    393333  {
    394334    Int isubShift = 0;
    395335    // motion cost
    396     Distortion uiBitCost = m_pcRdCost->getCost( iSearchX, iSearchY );
    397 
     336    Distortion uiBitCost = m_pcRdCost->getCostOfVectorWithPredictor( iSearchX, iSearchY );
     337
     338    // Skip search if bit cost is already larger than best SAD
     339    if (uiBitCost < rcStruct.uiBestSad)
     340    {
    398341    if ( m_cDistParam.iRows > 32 )
    399342    {
    … …  
    443386          rcStruct.uiBestRound    = 0;
    444387          rcStruct.ucPointNr      = ucPointNr;
     388            m_cDistParam.m_maximumDistortionForEarlyExit = uiSad;
     389          }
    445390        }
    446391      }
    … …  
    449394  else
    450395  {
     396    // fast encoder decision: use subsampled SAD when rows > 8 for integer ME
     397    if ( m_pcEncCfg->getFastInterSearchMode()==FASTINTERSEARCH_MODE1 || m_pcEncCfg->getFastInterSearchMode()==FASTINTERSEARCH_MODE3 )
     398    {
     399      if ( m_cDistParam.iRows > 8 )
     400      {
     401        m_cDistParam.iSubShift = 1;
     402      }
     403    }
     404
    451405    uiSad = m_cDistParam.DistFunc( &m_cDistParam );
    452406
     407    // only add motion cost if uiSad is smaller than best. Otherwise pointless
     408    // to add motion cost.
     409    if( uiSad < rcStruct.uiBestSad )
     410    {
    453411    // motion cost
    454     uiSad += m_pcRdCost->getCost( iSearchX, iSearchY );
     412      uiSad += m_pcRdCost->getCostOfVectorWithPredictor( iSearchX, iSearchY );
    455413
    456414    if( uiSad < rcStruct.uiBestSad )
    … …  
    462420      rcStruct.uiBestRound    = 0;
    463421      rcStruct.ucPointNr      = ucPointNr;
     422        m_cDistParam.m_maximumDistortionForEarlyExit = uiSad;
     423      }
    464424    }
    465425  }
    … …  
    469429
    470430
    471 __inline Void TEncSearch::xTZ2PointSearch( TComPattern* pcPatternKey, IntTZSearchStruct& rcStruct, TComMv* pcMvSrchRngLT, TComMv* pcMvSrchRngRB )
     431__inline Void TEncSearch::xTZ2PointSearch( const TComPattern* const pcPatternKey, IntTZSearchStruct& rcStruct, const TComMv* const pcMvSrchRngLT, const TComMv* const pcMvSrchRngRB )
    472432{
    473433  Int   iSrchRngHorLeft   = pcMvSrchRngLT->getHor();
    … …  
    602562
    603563
    604 __inline Void TEncSearch::xTZ8PointSquareSearch( TComPattern* pcPatternKey, IntTZSearchStruct& rcStruct, TComMv* pcMvSrchRngLT, TComMv* pcMvSrchRngRB, const Int iStartX, const Int iStartY, const Int iDist )
     564__inline Void TEncSearch::xTZ8PointSquareSearch( const TComPattern* const pcPatternKey, IntTZSearchStruct& rcStruct, const TComMv* const pcMvSrchRngLT, const TComMv* const pcMvSrchRngRB, const Int iStartX, const Int iStartY, const Int iDist )
    605565{
    606   Int   iSrchRngHorLeft   = pcMvSrchRngLT->getHor();
    607   Int   iSrchRngHorRight  = pcMvSrchRngRB->getHor();
    608   Int   iSrchRngVerTop    = pcMvSrchRngLT->getVer();
    609   Int   iSrchRngVerBottom = pcMvSrchRngRB->getVer();
     566  const Int   iSrchRngHorLeft   = pcMvSrchRngLT->getHor();
     567  const Int   iSrchRngHorRight  = pcMvSrchRngRB->getHor();
     568  const Int   iSrchRngVerTop    = pcMvSrchRngLT->getVer();
     569  const Int   iSrchRngVerBottom = pcMvSrchRngRB->getVer();
    610570
    611571  // 8 point search,                   //   1 2 3
    … …  
    660620
    661621
    662 __inline Void TEncSearch::xTZ8PointDiamondSearch( TComPattern* pcPatternKey, IntTZSearchStruct& rcStruct, TComMv* pcMvSrchRngLT, TComMv* pcMvSrchRngRB, const Int iStartX, const Int iStartY, const Int iDist )
     622__inline Void TEncSearch::xTZ8PointDiamondSearch( const TComPattern*const  pcPatternKey,
     623                                                  IntTZSearchStruct& rcStruct,
     624                                                  const TComMv*const  pcMvSrchRngLT,
     625                                                  const TComMv*const  pcMvSrchRngRB,
     626                                                  const Int iStartX,
     627                                                  const Int iStartY,
     628                                                  const Int iDist,
     629                                                  const Bool bCheckCornersAtDist1 )
    663630{
    664   Int   iSrchRngHorLeft   = pcMvSrchRngLT->getHor();
    665   Int   iSrchRngHorRight  = pcMvSrchRngRB->getHor();
    666   Int   iSrchRngVerTop    = pcMvSrchRngLT->getVer();
    667   Int   iSrchRngVerBottom = pcMvSrchRngRB->getVer();
     631  const Int   iSrchRngHorLeft   = pcMvSrchRngLT->getHor();
     632  const Int   iSrchRngHorRight  = pcMvSrchRngRB->getHor();
     633  const Int   iSrchRngVerTop    = pcMvSrchRngLT->getVer();
     634  const Int   iSrchRngVerBottom = pcMvSrchRngRB->getVer();
    668635
    669636  // 8 point search,                   //   1 2 3
    … …  
    677644  rcStruct.uiBestRound += 1;
    678645
    679   if ( iDist == 1 ) // iDist == 1
     646  if ( iDist == 1 )
    680647  {
    681648    if ( iTop >= iSrchRngVerTop ) // check top
    682649    {
     650      if (bCheckCornersAtDist1)
     651      {
     652        if ( iLeft >= iSrchRngHorLeft) // check top-left
     653        {
     654          xTZSearchHelp( pcPatternKey, rcStruct, iLeft, iTop, 1, iDist );
     655        }
     656        xTZSearchHelp( pcPatternKey, rcStruct, iStartX, iTop, 2, iDist );
     657        if ( iRight <= iSrchRngHorRight ) // check middle right
     658        {
     659          xTZSearchHelp( pcPatternKey, rcStruct, iRight, iTop, 3, iDist );
     660        }
     661      }
     662      else
     663      {
    683664      xTZSearchHelp( pcPatternKey, rcStruct, iStartX, iTop, 2, iDist );
    684665    }
     666    }
    685667    if ( iLeft >= iSrchRngHorLeft ) // check middle left
    686668    {
    … …  
    693675    if ( iBottom <= iSrchRngVerBottom ) // check bottom
    694676    {
     677      if (bCheckCornersAtDist1)
     678      {
     679        if ( iLeft >= iSrchRngHorLeft) // check top-left
     680        {
     681          xTZSearchHelp( pcPatternKey, rcStruct, iLeft, iBottom, 6, iDist );
     682        }
     683        xTZSearchHelp( pcPatternKey, rcStruct, iStartX, iBottom, 7, iDist );
     684        if ( iRight <= iSrchRngHorRight ) // check middle right
     685        {
     686          xTZSearchHelp( pcPatternKey, rcStruct, iRight, iBottom, 8, iDist );
     687        }
     688      }
     689      else
     690      {
    695691      xTZSearchHelp( pcPatternKey, rcStruct, iStartX, iBottom, 7, iDist );
    696692    }
    697693  }
    698   else // if (iDist != 1)
     694  }
     695  else
    699696  {
    700697    if ( iDist <= 8 )
    … …  
    770767        for ( Int index = 1; index < 4; index++ )
    771768        {
    772           Int iPosYT = iTop    + ((iDist>>2) * index);
    773           Int iPosYB = iBottom - ((iDist>>2) * index);
    774           Int iPosXL = iStartX - ((iDist>>2) * index);
    775           Int iPosXR = iStartX + ((iDist>>2) * index);
     769          const Int iPosYT = iTop    + ((iDist>>2) * index);
     770          const Int iPosYB = iBottom - ((iDist>>2) * index);
     771          const Int iPosXL = iStartX - ((iDist>>2) * index);
     772          const Int iPosXR = iStartX + ((iDist>>2) * index);
    776773          xTZSearchHelp( pcPatternKey, rcStruct, iPosXL, iPosYT, 0, iDist );
    777774          xTZSearchHelp( pcPatternKey, rcStruct, iPosXR, iPosYT, 0, iDist );
    … …  
    800797        for ( Int index = 1; index < 4; index++ )
    801798        {
    802           Int iPosYT = iTop    + ((iDist>>2) * index);
    803           Int iPosYB = iBottom - ((iDist>>2) * index);
    804           Int iPosXL = iStartX - ((iDist>>2) * index);
    805           Int iPosXR = iStartX + ((iDist>>2) * index);
     799          const Int iPosYT = iTop    + ((iDist>>2) * index);
     800          const Int iPosYB = iBottom - ((iDist>>2) * index);
     801          const Int iPosXL = iStartX - ((iDist>>2) * index);
     802          const Int iPosXR = iStartX + ((iDist>>2) * index);
    806803
    807804          if ( iPosYT >= iSrchRngVerTop ) // check top
    … …  
    833830}
    834831
    835 
    836 
    837 
    838 
    839 //<--
    840 
    841832Distortion TEncSearch::xPatternRefinement( TComPattern* pcPatternKey,
    842833                                           TComMv baseRefMv,
    … …  
    886877    m_cDistParam.bitDepth = pcPatternKey->getBitDepthY();
    887878    uiDist = m_cDistParam.DistFunc( &m_cDistParam );
    888     uiDist += m_pcRdCost->getCost( cMvTest.getHor(), cMvTest.getVer() );
     879    uiDist += m_pcRdCost->getCostOfVectorWithPredictor( cMvTest.getHor(), cMvTest.getVer() );
    889880
    890881    if ( uiDist < uiDistBest )
    … …  
    892883      uiDistBest  = uiDist;
    893884      uiDirecBest = i;
     885      m_cDistParam.m_maximumDistortionForEarlyExit = uiDist;
    894886    }
    895887  }
    … …  
    24102402}
    24112403
    2412 Char
     2404SChar
    24132405TEncSearch::xCalcCrossComponentPredictionAlpha(       TComTU &rTu,
    24142406                                                const ComponentID compID,
    … …  
    24272419  const Int diffBitDepth = pCU->getSlice()->getSPS()->getDifferentialLumaChromaBitDepth();
    24282420
    2429   Char alpha = 0;
     2421  SChar alpha = 0;
    24302422  Int SSxy  = 0;
    24312423  Int SSxx  = 0;
    … …  
    24472439  {
    24482440    Double dAlpha = SSxy / Double( SSxx );
    2449     alpha = Char(Clip3<Int>(-16, 16, (Int)(dAlpha * 16)));
    2450 
    2451     static const Char alphaQuant[17] = {0, 1, 1, 2, 2, 2, 4, 4, 4, 4, 4, 4, 8, 8, 8, 8, 8};
     2441    alpha = SChar(Clip3<Int>(-16, 16, (Int)(dAlpha * 16)));
     2442
     2443    static const SChar alphaQuant[17] = {0, 1, 1, 2, 2, 2, 4, 4, 4, 4, 4, 4, 8, 8, 8, 8, 8};
    24522444
    24532445    alpha = (alpha < 0) ? -alphaQuant[Int(-alpha)] : alphaQuant[Int(alpha)];
    … …  
    25402532        Double     singleCostTmp             = 0;
    25412533        UInt       singleCbfCTmp             = 0;
    2542         Char       bestCrossCPredictionAlpha = 0;
     2534        SChar      bestCrossCPredictionAlpha = 0;
    25432535        Int        bestTransformSkipMode     = 0;
    25442536
    … …  
    36893681              ::memcpy( m_puhQTTempCbf[compID], pcCU->getCbf( compID )+uiPartOffset, uiQPartNum * sizeof( UChar ) );
    36903682              ::memcpy( m_puhQTTempTransformSkipFlag[compID], pcCU->getTransformSkip( compID )+uiPartOffset, uiQPartNum * sizeof( UChar ) );
    3691               ::memcpy( m_phQTTempCrossComponentPredictionAlpha[compID], pcCU->getCrossComponentPredictionAlpha(compID)+uiPartOffset, uiQPartNum * sizeof( Char ) );
     3683              ::memcpy( m_phQTTempCrossComponentPredictionAlpha[compID], pcCU->getCrossComponentPredictionAlpha(compID)+uiPartOffset, uiQPartNum * sizeof( SChar ) );
    36923684            }
    36933685          }
    … …  
    37023694          ::memcpy( pcCU->getCbf( compID )+uiPartOffset, m_puhQTTempCbf[compID], uiQPartNum * sizeof( UChar ) );
    37033695          ::memcpy( pcCU->getTransformSkip( compID )+uiPartOffset, m_puhQTTempTransformSkipFlag[compID], uiQPartNum * sizeof( UChar ) );
    3704           ::memcpy( pcCU->getCrossComponentPredictionAlpha(compID)+uiPartOffset, m_phQTTempCrossComponentPredictionAlpha[compID], uiQPartNum * sizeof( Char ) );
     3696          ::memcpy( pcCU->getCrossComponentPredictionAlpha(compID)+uiPartOffset, m_phQTTempCrossComponentPredictionAlpha[compID], uiQPartNum * sizeof( SChar ) );
    37053697        }
    37063698      }
    … …  
    38123804{
    38133805  UInt        uiDepth      = pcCU->getDepth(0);
    3814   const UInt  uiDistortion = 0;
     3806  const Distortion  uiDistortion = 0;
    38153807  UInt        uiBits;
    38163808
    … …  
    43254317            /*correct the bit-rate part of the current ref*/
    43264318            m_pcRdCost->setPredictor  ( cMvPred[iRefList][iRefIdxTemp] );
    4327             uiBitsTemp += m_pcRdCost->getBits( cMvTemp[1][iRefIdxTemp].getHor(), cMvTemp[1][iRefIdxTemp].getVer() );
     4319            uiBitsTemp += m_pcRdCost->getBitsOfVectorWithPredictor( cMvTemp[1][iRefIdxTemp].getHor(), cMvTemp[1][iRefIdxTemp].getVer() );
    43284320            /*calculate the correct cost*/
    43294321            uiCostTemp += m_pcRdCost->getCost( uiBitsTemp );
    … …  
    43744366    }
    43754367
    4376     //  Bi-directional prediction
     4368    //  Bi-predictive Motion estimation
    43774369    if ( (pcCU->getSlice()->isInterB()) && (pcCU->isBipredRestriction(iPartIdx) == false) )
    43784370    {
    … …  
    44294421
    44304422      // fast encoder setting: only one iteration
    4431       if ( m_pcEncCfg->getUseFastEnc() || pcCU->getSlice()->getMvdL1ZeroFlag())
     4423      if ( m_pcEncCfg->getFastInterSearchMode()==FASTINTERSEARCH_MODE1 || m_pcEncCfg->getFastInterSearchMode()==FASTINTERSEARCH_MODE2 || pcCU->getSlice()->getMvdL1ZeroFlag() )
    44324424      {
    44334425        iNumIter = 1;
    … …  
    44384430        Int         iRefList    = iIter % 2;
    44394431
    4440         if ( m_pcEncCfg->getUseFastEnc() )
     4432        if ( m_pcEncCfg->getFastInterSearchMode()==FASTINTERSEARCH_MODE1 || m_pcEncCfg->getFastInterSearchMode()==FASTINTERSEARCH_MODE2 )
    44414433        {
    44424434          if( uiCost[0] <= uiCost[1] )
    … …  
    46294621      TComMvField cMEMvField[2];
    46304622
    4631       m_pcRdCost->getMotionCost( true, 0, pcCU->getCUTransquantBypass(uiPartAddr) );
     4623      m_pcRdCost->selectMotionLambda( true, 0, pcCU->getCUTransquantBypass(uiPartAddr) );
    46324624
    46334625#if AMP_MRG
    … …  
    46524644      // save ME result.
    46534645      uiMEInterDir = pcCU->getInterDir( uiPartAddr );
    4654       pcCU->getMvField( pcCU, uiPartAddr, REF_PIC_LIST_0, cMEMvField[0] );
    4655       pcCU->getMvField( pcCU, uiPartAddr, REF_PIC_LIST_1, cMEMvField[1] );
     4646      TComDataCU::getMvField( pcCU, uiPartAddr, REF_PIC_LIST_0, cMEMvField[0] );
     4647      TComDataCU::getMvField( pcCU, uiPartAddr, REF_PIC_LIST_1, cMEMvField[1] );
    46564648
    46574649      // find Merge result
    … …  
    50405032  }
    50415033
    5042   m_pcRdCost->getMotionCost( true, 0, pcCU->getCUTransquantBypass(0) );
     5034  m_pcRdCost->selectMotionLambda( true, 0, pcCU->getCUTransquantBypass(0) );
    50435035  m_pcRdCost->setCostScale ( 0    );
    50445036
    … …  
    50465038
    50475039  m_pcRdCost->setPredictor( rcMvPred );
    5048   Int iOrgMvBits  = m_pcRdCost->getBits(cMv.getHor(), cMv.getVer());
     5040  Int iOrgMvBits  = m_pcRdCost->getBitsOfVectorWithPredictor(cMv.getHor(), cMv.getVer());
    50495041  iOrgMvBits += m_auiMVPIdxCost[riMVPIdx][AMVP_MAX_NUM_CANDS];
    50505042  Int iBestMvBits = iOrgMvBits;
    … …  
    50595051    m_pcRdCost->setPredictor( pcAMVPInfo->m_acMvCand[iMVPIdx] );
    50605052
    5061     Int iMvBits = m_pcRdCost->getBits(cMv.getHor(), cMv.getVer());
     5053    Int iMvBits = m_pcRdCost->getBitsOfVectorWithPredictor(cMv.getHor(), cMv.getVer());
    50625054    iMvBits += m_auiMVPIdxCost[iMVPIdx][AMVP_MAX_NUM_CANDS];
    50635055
    … …  
    51345126
    51355127  uiCost = m_pcRdCost->getDistPart( pcCU->getSlice()->getSPS()->getBitDepth(CHANNEL_TYPE_LUMA), pcTemplateCand->getAddr(COMPONENT_Y, uiPartAddr), pcTemplateCand->getStride(COMPONENT_Y), pcOrgYuv->getAddr(COMPONENT_Y, uiPartAddr), pcOrgYuv->getStride(COMPONENT_Y), iSizeX, iSizeY, COMPONENT_Y, DF_SAD );
    5136   uiCost = (UInt) m_pcRdCost->calcRdCost( m_auiMVPIdxCost[iMVPIdx][iMVPNum], uiCost, false, DF_SAD );
     5128  uiCost = (UInt) m_pcRdCost->calcRdCost( m_auiMVPIdxCost[iMVPIdx][iMVPNum], uiCost, DF_SAD );
    51375129  return uiCost;
    51385130}
    … …  
    51765168#endif
    51775169
    5178   if ( bBi )
     5170  if ( bBi ) // Bipredictive ME
    51795171  {
    51805172    TComYuv*  pcYuvOther = &m_acYuvPred[1-(Int)eRefPicList];
    … …  
    51875179    fWeight = 0.5;
    51885180  }
     5181  m_cDistParam.bIsBiPred = bBi;
    51895182
    51905183  //  Search key pattern initialization
    … …  
    52125205  }
    52135206
    5214   m_pcRdCost->getMotionCost( true, 0, pcCU->getCUTransquantBypass(uiPartAddr) );
     5207  m_pcRdCost->selectMotionLambda( true, 0, pcCU->getCUTransquantBypass(uiPartAddr) );
    52155208
    52165209  m_pcRdCost->setPredictor  ( *pcMvPred );
    … …  
    52315224  setWpScalingDistParam( pcCU, iRefIdxPred, eRefPicList );
    52325225  //  Do integer search
    5233   if ( !m_iFastSearch || bBi )
     5226  if ( (m_motionEstimationSearchMethod==MESEARCH_FULL) || bBi )
    52345227  {
    52355228    xPatternSearch      ( pcPatternKey, piRefY, iRefStride, &cMvSrchRngLT, &cMvSrchRngRB, rcMv, ruiCost );
    … …  
    52505243  }
    52515244
    5252   m_pcRdCost->getMotionCost( true, 0, pcCU->getCUTransquantBypass(uiPartAddr) );
     5245  m_pcRdCost->selectMotionLambda( true, 0, pcCU->getCUTransquantBypass(uiPartAddr) );
    52535246#if NH_3D_INTEGER_MV_DEPTH
    52545247  if( ! pcCU->getSlice()->getIsDepth() )
    … …  
    52685261#endif
    52695262
    5270   UInt uiMvBits = m_pcRdCost->getBits( rcMv.getHor(), rcMv.getVer() );
     5263  UInt uiMvBits = m_pcRdCost->getBitsOfVectorWithPredictor( rcMv.getHor(), rcMv.getVer() );
    52715264#if NH_3D_INTEGER_MV_DEPTH
    52725265  if( pcCU->getSlice()->getIsDepth() )
    … …  
    52855278
    52865279
    5287 Void TEncSearch::xSetSearchRange ( TComDataCU* pcCU, TComMv& cMvPred, Int iSrchRng, TComMv& rcMvSrchRngLT, TComMv& rcMvSrchRngRB )
     5280Void TEncSearch::xSetSearchRange ( const TComDataCU* const pcCU, const TComMv& cMvPred, const Int iSrchRng,
     5281                                   TComMv& rcMvSrchRngLT, TComMv& rcMvSrchRngRB )
    52885282{
    52895283  Int  iMvShift = 2;
    … …  
    53175311  pcCU->clipMv        ( rcMvSrchRngRB );
    53185312
     5313#if ME_ENABLE_ROUNDING_OF_MVS
     5314  rcMvSrchRngLT.divideByPowerOf2(iMvShift);
     5315  rcMvSrchRngRB.divideByPowerOf2(iMvShift);
     5316#else
    53195317  rcMvSrchRngLT >>= iMvShift;
    53205318  rcMvSrchRngRB >>= iMvShift;
     5319#endif
    53215320}
    53225321
    53235322
    5324 
    5325 
    5326 Void TEncSearch::xPatternSearch( TComPattern* pcPatternKey, Pel* piRefY, Int iRefStride, TComMv* pcMvSrchRngLT, TComMv* pcMvSrchRngRB, TComMv& rcMv, Distortion& ruiSAD )
     5323Void TEncSearch::xPatternSearch( const TComPattern* const pcPatternKey,
     5324                                 const Pel*               piRefY,
     5325                                 const Int                iRefStride,
     5326                                 const TComMv* const      pcMvSrchRngLT,
     5327                                 const TComMv* const      pcMvSrchRngRB,
     5328                                 TComMv&      rcMv,
     5329                                 Distortion&  ruiSAD )
    53275330{
    53285331  Int   iSrchRngHorLeft   = pcMvSrchRngLT->getHor();
    … …  
    53365339  Int         iBestY = 0;
    53375340
    5338   Pel*  piRefSrch;
    5339 
    53405341  //-- jclee for using the SAD function pointer
    53415342  m_pcRdCost->setDistParam( pcPatternKey, piRefY, iRefStride,  m_cDistParam );
    53425343
    53435344  // fast encoder decision: use subsampled SAD for integer ME
    5344   if ( m_pcEncCfg->getUseFastEnc() )
     5345  if ( m_pcEncCfg->getFastInterSearchMode()==FASTINTERSEARCH_MODE1 || m_pcEncCfg->getFastInterSearchMode()==FASTINTERSEARCH_MODE3 )
    53455346  {
    53465347    if ( m_cDistParam.iRows > 8 )
    … …  
    53565357    {
    53575358      //  find min. distortion position
    5358       piRefSrch = piRefY + x;
    5359       m_cDistParam.pCur = piRefSrch;
     5359      m_cDistParam.pCur = piRefY + x;
    53605360
    53615361      setDistParamComp(COMPONENT_Y);
    … …  
    53735373
    53745374      // motion cost
    5375       uiSad += m_pcRdCost->getCost( x, y );
     5375      uiSad += m_pcRdCost->getCostOfVectorWithPredictor( x, y );
    53765376
    53775377      if ( uiSad < uiSadBest )
    … …  
    53805380        iBestX    = x;
    53815381        iBestY    = y;
     5382        m_cDistParam.m_maximumDistortionForEarlyExit = uiSad;
    53825383      }
    53835384    }
    … …  
    53875388  rcMv.set( iBestX, iBestY );
    53885389
    5389   ruiSAD = uiSadBest - m_pcRdCost->getCost( iBestX, iBestY );
     5390  ruiSAD = uiSadBest - m_pcRdCost->getCostOfVectorWithPredictor( iBestX, iBestY );
    53905391  return;
    53915392}
    … …  
    53935394
    53945395
    5395 Void TEncSearch::xPatternSearchFast( TComDataCU*   pcCU,
    5396                                      TComPattern* pcPatternKey,
    5397                                      Pel*          piRefY,
    5398                                      Int           iRefStride,
    5399                                      TComMv*       pcMvSrchRngLT,
    5400                                      TComMv*       pcMvSrchRngRB,
     5396Void TEncSearch::xPatternSearchFast( const TComDataCU* const  pcCU,
     5397                                     const TComPattern* const pcPatternKey,
     5398                                     const Pel* const         piRefY,
     5399                                     const Int                iRefStride,
     5400                                     const TComMv* const      pcMvSrchRngLT,
     5401                                     const TComMv* const      pcMvSrchRngRB,
    54015402                                     TComMv       &rcMv,
    54025403                                     Distortion   &ruiSAD,
    5403                                      const TComMv* pIntegerMv2Nx2NPred )
     5404                                     const TComMv* const      pIntegerMv2Nx2NPred )
    54045405{
    54055406  assert (MD_LEFT < NUM_MV_PREDICTORS);
    … …  
    54105411  pcCU->getMvPredAboveRight ( m_acMvPredictors[MD_ABOVE_RIGHT] );
    54115412
    5412   switch ( m_iFastSearch )
    5413   {
    5414     case 1:
    5415       xTZSearch( pcCU, pcPatternKey, piRefY, iRefStride, pcMvSrchRngLT, pcMvSrchRngRB, rcMv, ruiSAD, pIntegerMv2Nx2NPred );
     5413  switch ( m_motionEstimationSearchMethod )
     5414  {
     5415    case MESEARCH_DIAMOND:
     5416      xTZSearch( pcCU, pcPatternKey, piRefY, iRefStride, pcMvSrchRngLT, pcMvSrchRngRB, rcMv, ruiSAD, pIntegerMv2Nx2NPred, false );
    54165417      break;
    54175418
    5418     case 2:
     5419    case MESEARCH_SELECTIVE:
    54195420      xTZSearchSelective( pcCU, pcPatternKey, piRefY, iRefStride, pcMvSrchRngLT, pcMvSrchRngRB, rcMv, ruiSAD, pIntegerMv2Nx2NPred );
    54205421      break;
     5422
     5423    case MESEARCH_DIAMOND_ENHANCED:
     5424      xTZSearch( pcCU, pcPatternKey, piRefY, iRefStride, pcMvSrchRngLT, pcMvSrchRngRB, rcMv, ruiSAD, pIntegerMv2Nx2NPred, true );
     5425      break;
     5426
     5427    case MESEARCH_FULL: // shouldn't get here.
    54215428    default:
    54225429      break;
    … …  
    54275434
    54285435
    5429 Void TEncSearch::xTZSearch( TComDataCU* pcCU,
    5430                             TComPattern* pcPatternKey,
    5431                             Pel*         piRefY,
    5432                             Int          iRefStride,
    5433                             TComMv*      pcMvSrchRngLT,
    5434                             TComMv*      pcMvSrchRngRB,
     5436Void TEncSearch::xTZSearch( const TComDataCU* const pcCU,
     5437                            const TComPattern* const pcPatternKey,
     5438                            const Pel* const         piRefY,
     5439                            const Int                iRefStride,
     5440                            const TComMv* const      pcMvSrchRngLT,
     5441                            const TComMv* const      pcMvSrchRngRB,
    54355442                            TComMv      &rcMv,
    54365443                            Distortion  &ruiSAD,
    5437                             const TComMv* pIntegerMv2Nx2NPred )
     5444                            const TComMv* const      pIntegerMv2Nx2NPred,
     5445                            const Bool               bExtendedSettings)
    54385446{
    5439   Int   iSrchRngHorLeft   = pcMvSrchRngLT->getHor();
    5440   Int   iSrchRngHorRight  = pcMvSrchRngRB->getHor();
    5441   Int   iSrchRngVerTop    = pcMvSrchRngLT->getVer();
    5442   Int   iSrchRngVerBottom = pcMvSrchRngRB->getVer();
    5443 
    5444   TZ_SEARCH_CONFIGURATION
     5447  const Bool bUseAdaptiveRaster                      = bExtendedSettings;
     5448  const Int  iRaster                                 = 5;
     5449  const Bool bTestOtherPredictedMV                   = bExtendedSettings;
     5450  const Bool bTestZeroVector                         = true;
     5451  const Bool bTestZeroVectorStart                    = bExtendedSettings;
     5452  const Bool bTestZeroVectorStop                     = false;
     5453  const Bool bFirstSearchDiamond                     = true;  // 1 = xTZ8PointDiamondSearch   0 = xTZ8PointSquareSearch
     5454  const Bool bFirstCornersForDiamondDist1            = bExtendedSettings;
     5455  const Bool bFirstSearchStop                        = m_pcEncCfg->getFastMEAssumingSmootherMVEnabled();
     5456  const UInt uiFirstSearchRounds                     = 3;     // first search stop X rounds after best match (must be >=1)
     5457  const Bool bEnableRasterSearch                     = true;
     5458  const Bool bAlwaysRasterSearch                     = bExtendedSettings;  // true: BETTER but factor 2 slower
     5459  const Bool bRasterRefinementEnable                 = false; // enable either raster refinement or star refinement
     5460  const Bool bRasterRefinementDiamond                = false; // 1 = xTZ8PointDiamondSearch   0 = xTZ8PointSquareSearch
     5461  const Bool bRasterRefinementCornersForDiamondDist1 = bExtendedSettings;
     5462  const Bool bStarRefinementEnable                   = true;  // enable either star refinement or raster refinement
     5463  const Bool bStarRefinementDiamond                  = true;  // 1 = xTZ8PointDiamondSearch   0 = xTZ8PointSquareSearch
     5464  const Bool bStarRefinementCornersForDiamondDist1   = bExtendedSettings;
     5465  const Bool bStarRefinementStop                     = false;
     5466  const UInt uiStarRefinementRounds                  = 2;  // star refinement stop X rounds after best match (must be >=1)
     5467  const Bool bNewZeroNeighbourhoodTest               = bExtendedSettings;
    54455468
    54465469  UInt uiSearchRange = m_iSearchRange;
    … …  
    54495472  if( ! pcCU->getSlice()->getIsDepth() )
    54505473#endif
     5474#if ME_ENABLE_ROUNDING_OF_MVS
     5475  rcMv.divideByPowerOf2(2);
     5476#else
    54515477  rcMv >>= 2;
     5478#endif
     5479
    54525480  // init TZSearchStruct
    54535481  IntTZSearchStruct cStruct;
    … …  
    54705498      {     
    54715499#endif
    5472         cMv >>= 2;
     5500#if ME_ENABLE_ROUNDING_OF_MVS
     5501      cMv.divideByPowerOf2(2);
     5502#else
     5503      cMv >>= 2;
     5504#endif
     5505
    54735506#if NH_3D_INTEGER_MV_DEPTH
    54745507      }
    54755508#endif
    5476 
     5509      if (cMv != rcMv && (cMv.getHor() != cStruct.iBestX && cMv.getVer() != cStruct.iBestY))
     5510      {
     5511        // only test cMV if not obviously previously tested.
    54775512      xTZSearchHelp( pcPatternKey, cStruct, cMv.getHor(), cMv.getVer(), 0, 0 );
    54785513    }
     5514  }
    54795515  }
    54805516
    … …  
    54825518  if ( bTestZeroVector )
    54835519  {
     5520    if ((rcMv.getHor() != 0 || rcMv.getVer() != 0) &&
     5521        (0 != cStruct.iBestX || 0 != cStruct.iBestY))
     5522    {
     5523      // only test 0-vector if not obviously previously tested.
    54845524    xTZSearchHelp( pcPatternKey, cStruct, 0, 0, 0, 0 );
    54855525  }
     5526  }
     5527
     5528  Int   iSrchRngHorLeft   = pcMvSrchRngLT->getHor();
     5529  Int   iSrchRngHorRight  = pcMvSrchRngRB->getHor();
     5530  Int   iSrchRngVerTop    = pcMvSrchRngLT->getVer();
     5531  Int   iSrchRngVerBottom = pcMvSrchRngRB->getVer();
    54865532
    54875533  if (pIntegerMv2Nx2NPred != 0)
    … …  
    54905536    integerMv2Nx2NPred <<= 2;
    54915537    pcCU->clipMv( integerMv2Nx2NPred );
     5538#if ME_ENABLE_ROUNDING_OF_MVS
     5539    integerMv2Nx2NPred.divideByPowerOf2(2);
     5540#else
    54925541    integerMv2Nx2NPred >>= 2;
     5542#endif
     5543    if ((rcMv != integerMv2Nx2NPred) &&
     5544        (integerMv2Nx2NPred.getHor() != cStruct.iBestX || integerMv2Nx2NPred.getVer() != cStruct.iBestY))
     5545    {
     5546      // only test integerMv2Nx2NPred if not obviously previously tested.
    54935547    xTZSearchHelp(pcPatternKey, cStruct, integerMv2Nx2NPred.getHor(), integerMv2Nx2NPred.getVer(), 0, 0);
     5548    }
    54945549
    54955550    // reset search range
    … …  
    55115566  Int  iStartY = cStruct.iBestY;
    55125567
    5513   // first search
     5568  const Bool bBestCandidateZero = (cStruct.iBestX == 0) && (cStruct.iBestY == 0);
     5569
     5570  // first search around best position up to now.
     5571  // The following works as a "subsampled/log" window search around the best candidate
    55145572  for ( iDist = 1; iDist <= (Int)uiSearchRange; iDist*=2 )
    55155573  {
    55165574    if ( bFirstSearchDiamond == 1 )
    55175575    {
    5518       xTZ8PointDiamondSearch ( pcPatternKey, cStruct, pcMvSrchRngLT, pcMvSrchRngRB, iStartX, iStartY, iDist );
     5576      xTZ8PointDiamondSearch ( pcPatternKey, cStruct, pcMvSrchRngLT, pcMvSrchRngRB, iStartX, iStartY, iDist, bFirstCornersForDiamondDist1 );
    55195577    }
    55205578    else
    … …  
    55295587  }
    55305588
     5589  if (!bNewZeroNeighbourhoodTest)
     5590  {
    55315591  // test whether zero Mv is a better start point than Median predictor
    55325592  if ( bTestZeroVectorStart && ((cStruct.iBestX != 0) || (cStruct.iBestY != 0)) )
    … …  
    55385598      for ( iDist = 1; iDist <= (Int)uiSearchRange; iDist*=2 )
    55395599      {
    5540         xTZ8PointDiamondSearch( pcPatternKey, cStruct, pcMvSrchRngLT, pcMvSrchRngRB, 0, 0, iDist );
     5600          xTZ8PointDiamondSearch( pcPatternKey, cStruct, pcMvSrchRngLT, pcMvSrchRngRB, 0, 0, iDist, false );
    55415601        if ( bTestZeroVectorStop && (cStruct.uiBestRound > 0) ) // stop criterion
     5602        {
     5603          break;
     5604        }
     5605      }
     5606    }
     5607  }
     5608  }
     5609  else
     5610  {
     5611    // Test also zero neighbourhood but with half the range
     5612    // It was reported that the original (above) search scheme using bTestZeroVectorStart did not
     5613    // make sense since one would have already checked the zero candidate earlier
     5614    // and thus the conditions for that test would have not been satisfied
     5615    if (bTestZeroVectorStart == true && bBestCandidateZero != true)
     5616    {
     5617      for ( iDist = 1; iDist <= ((Int)uiSearchRange >> 1); iDist*=2 )
     5618      {
     5619        xTZ8PointDiamondSearch( pcPatternKey, cStruct, pcMvSrchRngLT, pcMvSrchRngRB, 0, 0, iDist, false );
     5620        if ( bTestZeroVectorStop && (cStruct.uiBestRound > 2) ) // stop criterion
    55425621        {
    55435622          break;
    … …  
    55555634
    55565635  // raster search if distance is too big
     5636  if (bUseAdaptiveRaster)
     5637  {
     5638    int iWindowSize = iRaster;
     5639    Int   iSrchRngRasterLeft   = iSrchRngHorLeft;
     5640    Int   iSrchRngRasterRight  = iSrchRngHorRight;
     5641    Int   iSrchRngRasterTop    = iSrchRngVerTop;
     5642    Int   iSrchRngRasterBottom = iSrchRngVerBottom;
     5643
     5644    if (!(bEnableRasterSearch && ( ((Int)(cStruct.uiBestDistance) > iRaster))))
     5645    {
     5646      iWindowSize ++;
     5647      iSrchRngRasterLeft /= 2;
     5648      iSrchRngRasterRight /= 2;
     5649      iSrchRngRasterTop /= 2;
     5650      iSrchRngRasterBottom /= 2;
     5651    }
     5652    cStruct.uiBestDistance = iWindowSize;
     5653    for ( iStartY = iSrchRngRasterTop; iStartY <= iSrchRngRasterBottom; iStartY += iWindowSize )
     5654    {
     5655      for ( iStartX = iSrchRngRasterLeft; iStartX <= iSrchRngRasterRight; iStartX += iWindowSize )
     5656      {
     5657        xTZSearchHelp( pcPatternKey, cStruct, iStartX, iStartY, 0, iWindowSize );
     5658      }
     5659    }
     5660  }
     5661  else
     5662  {
    55575663  if ( bEnableRasterSearch && ( ((Int)(cStruct.uiBestDistance) > iRaster) || bAlwaysRasterSearch ) )
    55585664  {
    … …  
    55655671      }
    55665672    }
     5673  }
    55675674  }
    55685675
    … …  
    55795686        if ( bRasterRefinementDiamond == 1 )
    55805687        {
    5581           xTZ8PointDiamondSearch ( pcPatternKey, cStruct, pcMvSrchRngLT, pcMvSrchRngRB, iStartX, iStartY, iDist );
     5688          xTZ8PointDiamondSearch ( pcPatternKey, cStruct, pcMvSrchRngLT, pcMvSrchRngRB, iStartX, iStartY, iDist, bRasterRefinementCornersForDiamondDist1 );
    55825689        }
    55835690        else
    … …  
    55995706  }
    56005707
    5601   // start refinement
     5708  // star refinement
    56025709  if ( bStarRefinementEnable && cStruct.uiBestDistance > 0 )
    56035710  {
    … …  
    56125719        if ( bStarRefinementDiamond == 1 )
    56135720        {
    5614           xTZ8PointDiamondSearch ( pcPatternKey, cStruct, pcMvSrchRngLT, pcMvSrchRngRB, iStartX, iStartY, iDist );
     5721          xTZ8PointDiamondSearch ( pcPatternKey, cStruct, pcMvSrchRngLT, pcMvSrchRngRB, iStartX, iStartY, iDist, bStarRefinementCornersForDiamondDist1 );
    56155722        }
    56165723        else
    … …  
    56385745  // write out best match
    56395746  rcMv.set( cStruct.iBestX, cStruct.iBestY );
    5640   ruiSAD = cStruct.uiBestSad - m_pcRdCost->getCost( cStruct.iBestX, cStruct.iBestY );
     5747  ruiSAD = cStruct.uiBestSad - m_pcRdCost->getCostOfVectorWithPredictor( cStruct.iBestX, cStruct.iBestY );
    56415748}
    56425749
    56435750
    5644 Void TEncSearch::xTZSearchSelective( TComDataCU*   pcCU,
    5645                                      TComPattern*  pcPatternKey,
    5646                                      Pel*          piRefY,
    5647                                      Int           iRefStride,
    5648                                      TComMv*       pcMvSrchRngLT,
    5649                                      TComMv*       pcMvSrchRngRB,
     5751Void TEncSearch::xTZSearchSelective( const TComDataCU* const   pcCU,
     5752                                     const TComPattern* const  pcPatternKey,
     5753                                     const Pel* const          piRefY,
     5754                                     const Int                 iRefStride,
     5755                                     const TComMv* const       pcMvSrchRngLT,
     5756                                     const TComMv* const       pcMvSrchRngRB,
    56505757                                     TComMv       &rcMv,
    56515758                                     Distortion   &ruiSAD,
    5652                                      const TComMv* pIntegerMv2Nx2NPred )
     5759                                     const TComMv* const       pIntegerMv2Nx2NPred )
    56535760{
    5654   SEL_SEARCH_CONFIGURATION
     5761  const Bool bTestOtherPredictedMV    = true;
     5762  const Bool bTestZeroVector          = true;
     5763  const Bool bEnableRasterSearch      = true;
     5764  const Bool bAlwaysRasterSearch      = false;  // 1: BETTER but factor 15x slower
     5765  const Bool bStarRefinementEnable    = true;   // enable either star refinement or raster refinement
     5766  const Bool bStarRefinementDiamond   = true;   // 1 = xTZ8PointDiamondSearch   0 = xTZ8PointSquareSearch
     5767  const Bool bStarRefinementStop      = false;
     5768  const UInt uiStarRefinementRounds   = 2;  // star refinement stop X rounds after best match (must be >=1)
     5769  const UInt uiSearchRange            = m_iSearchRange;
     5770  const Int  uiSearchRangeInitial     = m_iSearchRange >> 2;
     5771  const Int  uiSearchStep             = 4;
     5772  const Int  iMVDistThresh            = 8;
    56555773
    56565774  Int   iSrchRngHorLeft         = pcMvSrchRngLT->getHor();
    … …  
    56695787
    56705788  pcCU->clipMv( rcMv );
     5789#if ME_ENABLE_ROUNDING_OF_MVS
     5790  rcMv.divideByPowerOf2(2);
     5791#else
    56715792  rcMv >>= 2;
     5793#endif
    56725794  // init TZSearchStruct
    56735795  IntTZSearchStruct cStruct;
    … …  
    56895811      TComMv cMv = m_acMvPredictors[index];
    56905812      pcCU->clipMv( cMv );
     5813#if ME_ENABLE_ROUNDING_OF_MVS
     5814      cMv.divideByPowerOf2(2);
     5815#else
    56915816      cMv >>= 2;
     5817#endif
    56925818      xTZSearchHelp( pcPatternKey, cStruct, cMv.getHor(), cMv.getVer(), 0, 0 );
    56935819    }
    … …  
    57055831    integerMv2Nx2NPred <<= 2;
    57065832    pcCU->clipMv( integerMv2Nx2NPred );
     5833#if ME_ENABLE_ROUNDING_OF_MVS
     5834    integerMv2Nx2NPred.divideByPowerOf2(2);
     5835#else
    57075836    integerMv2Nx2NPred >>= 2;
     5837#endif
    57085838    xTZSearchHelp(pcPatternKey, cStruct, integerMv2Nx2NPred.getHor(), integerMv2Nx2NPred.getVer(), 0, 0);
    57095839
    … …  
    57345864    {
    57355865      xTZSearchHelp( pcPatternKey, cStruct, iStartX, iStartY, 0, 0 );
    5736       xTZ8PointDiamondSearch ( pcPatternKey, cStruct, pcMvSrchRngLT, pcMvSrchRngRB, iStartX, iStartY, 1 );
    5737       xTZ8PointDiamondSearch ( pcPatternKey, cStruct, pcMvSrchRngLT, pcMvSrchRngRB, iStartX, iStartY, 2 );
     5866      xTZ8PointDiamondSearch ( pcPatternKey, cStruct, pcMvSrchRngLT, pcMvSrchRngRB, iStartX, iStartY, 1, false );
     5867      xTZ8PointDiamondSearch ( pcPatternKey, cStruct, pcMvSrchRngLT, pcMvSrchRngRB, iStartX, iStartY, 2, false );
    57385868    }
    57395869  }
    … …  
    57665896        if ( bStarRefinementDiamond == 1 )
    57675897        {
    5768           xTZ8PointDiamondSearch ( pcPatternKey, cStruct, pcMvSrchRngLT, pcMvSrchRngRB, iStartX, iStartY, iDist );
     5898          xTZ8PointDiamondSearch ( pcPatternKey, cStruct, pcMvSrchRngLT, pcMvSrchRngRB, iStartX, iStartY, iDist, false );
    57695899        }
    57705900        else
    … …  
    57925922  // write out best match
    57935923  rcMv.set( cStruct.iBestX, cStruct.iBestY );
    5794   ruiSAD = cStruct.uiBestSad - m_pcRdCost->getCost( cStruct.iBestX, cStruct.iBestY );
     5924  ruiSAD = cStruct.uiBestSad - m_pcRdCost->getCostOfVectorWithPredictor( cStruct.iBestX, cStruct.iBestY );
    57955925
    57965926}
    … …  
    60276157      const ComponentID component = ComponentID(comp);
    60286158      ::memset( pcCU->getCbf( component ) , 0, uiQPartNum * sizeof(UChar) );
    6029       ::memset( pcCU->getCrossComponentPredictionAlpha(component), 0, ( uiQPartNum * sizeof(Char) ) );
     6159      ::memset( pcCU->getCrossComponentPredictionAlpha(component), 0, ( uiQPartNum * sizeof(SChar) ) );
    60306160    }
    60316161    static const UInt useTS[MAX_NUM_COMPONENT]={0,0,0};
    … …  
    63156445  //  Stores the best explicit RDPCM mode for a TU encoded without split
    63166446  UInt       bestExplicitRdpcmModeUnSplit[MAX_NUM_COMPONENT][2/*0 = top (or whole TU for non-4:2:2) sub-TU, 1 = bottom sub-TU*/] = {{3,3}, {3,3}, {3,3}};
    6317   Char       bestCrossCPredictionAlpha   [MAX_NUM_COMPONENT][2/*0 = top (or whole TU for non-4:2:2) sub-TU, 1 = bottom sub-TU*/] = {{0,0},{0,0},{0,0}};
     6447  SChar      bestCrossCPredictionAlpha   [MAX_NUM_COMPONENT][2/*0 = top (or whole TU for non-4:2:2) sub-TU, 1 = bottom sub-TU*/] = {{0,0},{0,0},{0,0}};
    63186448
    63196449  m_pcRDGoOnSbacCoder->store( m_pppcRDSbacCoder[ uiDepth ][ CI_QT_TRAFO_ROOT ] );
    … …  
    63866516                                                         && (pcCU->getCbf(subTUAbsPartIdx, COMPONENT_Y, uiTrMode) != 0);
    63876517
    6388           Char preCalcAlpha = 0;
     6518          SChar preCalcAlpha = 0;
    63896519          const Pel *pLumaResi = m_pcQTTempTComYuv[uiQTTempAccessLayer].getAddrPix( COMPONENT_Y, rTu.getRect( COMPONENT_Y ).x0, rTu.getRect( COMPONENT_Y ).y0 );
    63906520

  • branches/HTM-15.2-dev/source/Lib/TLibEncoder/TEncSearch.h

    r1321 r1360  
    6868private:
    6969  TCoeff**        m_ppcQTTempCoeff[MAX_NUM_COMPONENT /* 0->Y, 1->Cb, 2->Cr*/];
    70   TCoeff*         m_pcQTTempCoeff[MAX_NUM_COMPONENT];
    7170#if ADAPTIVE_QP_SELECTION
    7271  TCoeff**        m_ppcQTTempArlCoeff[MAX_NUM_COMPONENT];
    73   TCoeff*         m_pcQTTempArlCoeff[MAX_NUM_COMPONENT];
    7472#endif
    7573  UChar*          m_puhQTTempTrIdx;
    … …  
    7977  TComYuv         m_tmpYuvPred; // To be used in xGetInterPredictionError() to avoid constant memory allocation/deallocation
    8078
    81   Char*           m_phQTTempCrossComponentPredictionAlpha[MAX_NUM_COMPONENT];
     79  SChar*          m_phQTTempCrossComponentPredictionAlpha[MAX_NUM_COMPONENT];
    8280  Pel*            m_pSharedPredTransformSkip[MAX_NUM_COMPONENT];
    8381  TCoeff*         m_pcQTTempTUCoeff[MAX_NUM_COMPONENT];
    … …  
    10098  Int             m_iSearchRange;
    10199  Int             m_bipredSearchRange; // Search range for bi-prediction
    102   Int             m_iFastSearch;
     100  MESearchMethod  m_motionEstimationSearchMethod;
    103101#if NH_MV
    104102  Bool            m_vertRestriction;
    105103#endif
    106104  Int             m_aaiAdaptSR[MAX_NUM_REF_LIST_ADAPT_SR][MAX_IDX_ADAPT_SR];
    107   TComMv          m_cSrchRngLT;
    108   TComMv          m_cSrchRngRB;
    109105  TComMv          m_acMvPredictors[NUM_MV_PREDICTORS]; // Left, Above, AboveRight. enum MVP_DIR first NUM_MV_PREDICTORS entries are suitable for accessing.
    110106
    … …  
    116112  // Misc.
    117113  Pel*            m_pTempPel;
    118   const UInt*     m_puiDFilter;
    119114
    120115#if NH_3D_VSO // M17
    … …  
    136131            Int           iSearchRange,
    137132            Int           bipredSearchRange,
    138             Int           iFastSearch,
     133            MESearchMethod motionEstimationSearchMethod,
    139134            const UInt    maxCUWidth,
    140135            const UInt    maxCUHeight,
    … …  
    157152  typedef struct
    158153  {
    159     Pel*        piRefY;
     154    const Pel*  piRefY;
    160155    Int         iYStride;
    161156    Int         iBestX;
    … …  
    168163
    169164  // sub-functions for ME
    170   __inline Void xTZSearchHelp         ( TComPattern* pcPatternKey, IntTZSearchStruct& rcStruct, const Int iSearchX, const Int iSearchY, const UChar ucPointNr, const UInt uiDistance );
    171   __inline Void xTZ2PointSearch       ( TComPattern* pcPatternKey, IntTZSearchStruct& rcStrukt, TComMv* pcMvSrchRngLT, TComMv* pcMvSrchRngRB );
    172   __inline Void xTZ8PointSquareSearch ( TComPattern* pcPatternKey, IntTZSearchStruct& rcStrukt, TComMv* pcMvSrchRngLT, TComMv* pcMvSrchRngRB, const Int iStartX, const Int iStartY, const Int iDist );
    173   __inline Void xTZ8PointDiamondSearch( TComPattern* pcPatternKey, IntTZSearchStruct& rcStrukt, TComMv* pcMvSrchRngLT, TComMv* pcMvSrchRngRB, const Int iStartX, const Int iStartY, const Int iDist );
     165  __inline Void xTZSearchHelp         ( const TComPattern* const pcPatternKey, IntTZSearchStruct& rcStruct, const Int iSearchX, const Int iSearchY, const UChar ucPointNr, const UInt uiDistance );
     166  __inline Void xTZ2PointSearch       ( const TComPattern* const pcPatternKey, IntTZSearchStruct& rcStruct, const TComMv* const pcMvSrchRngLT, const TComMv* const pcMvSrchRngRB );
     167  __inline Void xTZ8PointSquareSearch ( const TComPattern* const pcPatternKey, IntTZSearchStruct& rcStruct, const TComMv* const pcMvSrchRngLT, const TComMv* const pcMvSrchRngRB, const Int iStartX, const Int iStartY, const Int iDist );
     168  __inline Void xTZ8PointDiamondSearch( const TComPattern* const pcPatternKey, IntTZSearchStruct& rcStruct, const TComMv* const pcMvSrchRngLT, const TComMv* const pcMvSrchRngRB, const Int iStartX, const Int iStartY, const Int iDist, const Bool bCheckCornersAtDist1 );
    174169
    175170  Void xGetInterPredictionError( TComDataCU* pcCU, TComYuv* pcYuvOrg, Int iPartIdx, Distortion& ruiSAD, Bool Hadamard );
    … …  
    322317                                               const Int     strideBest );
    323318
    324   Char xCalcCrossComponentPredictionAlpha    (       TComTU &rTu,
     319  SChar xCalcCrossComponentPredictionAlpha   (       TComTU &rTu,
    325320                                               const ComponentID compID,
    326321                                               const Pel*        piResiL,
    … …  
    446441                                    Bool         bBi = false  );
    447442
    448   Void xTZSearch                  ( TComDataCU*  pcCU,
    449                                     TComPattern* pcPatternKey,
    450                                     Pel*         piRefY,
    451                                     Int          iRefStride,
    452                                     TComMv*      pcMvSrchRngLT,
    453                                     TComMv*      pcMvSrchRngRB,
     443  Void xTZSearch                  ( const TComDataCU* const  pcCU,
     444                                    const TComPattern* const pcPatternKey,
     445                                    const Pel* const         piRefY,
     446                                    const Int                iRefStride,
     447                                    const TComMv* const      pcMvSrchRngLT,
     448                                    const TComMv* const      pcMvSrchRngRB,
    454449                                    TComMv&      rcMv,
    455450                                    Distortion&  ruiSAD,
    456                                     const TComMv *pIntegerMv2Nx2NPred
     451                                    const TComMv* const      pIntegerMv2Nx2NPred,
     452                                    const Bool               bExtendedSettings
    457453                                    );
    458454
    459   Void xTZSearchSelective         ( TComDataCU*  pcCU,
    460                                     TComPattern* pcPatternKey,
    461                                     Pel*         piRefY,
    462                                     Int          iRefStride,
    463                                     TComMv*      pcMvSrchRngLT,
    464                                     TComMv*      pcMvSrchRngRB,
     455  Void xTZSearchSelective         ( const TComDataCU* const  pcCU,
     456                                    const TComPattern* const pcPatternKey,
     457                                    const Pel* const         piRefY,
     458                                    const Int                iRefStride,
     459                                    const TComMv* const      pcMvSrchRngLT,
     460                                    const TComMv* const      pcMvSrchRngRB,
    465461                                    TComMv&      rcMv,
    466462                                    Distortion&  ruiSAD,
    467                                     const TComMv *pIntegerMv2Nx2NPred
     463                                    const TComMv* const      pIntegerMv2Nx2NPred
    468464                                    );
    469465
    470   Void xSetSearchRange            ( TComDataCU* pcCU,
    471                                     TComMv&      cMvPred,
    472                                     Int          iSrchRng,
     466  Void xSetSearchRange            ( const TComDataCU* const pcCU,
     467                                    const TComMv&      cMvPred,
     468                                    const Int          iSrchRng,
    473469                                    TComMv&      rcMvSrchRngLT,
    474470                                    TComMv&      rcMvSrchRngRB );
    475471
    476   Void xPatternSearchFast         ( TComDataCU*  pcCU,
    477                                     TComPattern* pcPatternKey,
    478                                     Pel*         piRefY,
    479                                     Int          iRefStride,
    480                                     TComMv*      pcMvSrchRngLT,
    481                                     TComMv*      pcMvSrchRngRB,
     472  Void xPatternSearchFast         ( const TComDataCU* const  pcCU,
     473                                    const TComPattern* const pcPatternKey,
     474                                    const Pel* const         piRefY,
     475                                    const Int                iRefStride,
     476                                    const TComMv* const      pcMvSrchRngLT,
     477                                    const TComMv* const      pcMvSrchRngRB,
    482478                                    TComMv&      rcMv,
    483479                                    Distortion&  ruiSAD,
    484                                     const TComMv* pIntegerMv2Nx2NPred
     480                                    const TComMv* const      pIntegerMv2Nx2NPred
    485481                                  );
    486482
    487   Void xPatternSearch             ( TComPattern* pcPatternKey,
    488                                     Pel*         piRefY,
    489                                     Int          iRefStride,
    490                                     TComMv*      pcMvSrchRngLT,
    491                                     TComMv*      pcMvSrchRngRB,
     483  Void xPatternSearch             ( const TComPattern* const pcPatternKey,
     484                                    const Pel*               piRefY,
     485                                    const Int                iRefStride,
     486                                    const TComMv* const      pcMvSrchRngLT,
     487                                    const TComMv* const      pcMvSrchRngRB,
    492488                                    TComMv&      rcMv,
    493489                                    Distortion&  ruiSAD );

  • branches/HTM-15.2-dev/source/Lib/TLibEncoder/TEncSlice.cpp

    r1313 r1360  
    203203Void TEncSlice::initEncSlice( TComPic* pcPic, Int pocLast, Int pocCurr, Int iGOPid, TComSlice*& rpcSlice, TComVPS* pVPS, Int layerId, bool isField )
    204204#else
    205 Void TEncSlice::initEncSlice( TComPic* pcPic, Int pocLast, Int pocCurr, Int iGOPid, TComSlice*& rpcSlice, Bool isField )
     205Void TEncSlice::initEncSlice( TComPic* pcPic, const Int pocLast, const Int pocCurr, const Int iGOPid, TComSlice*& rpcSlice, const Bool isField )
    206206#endif
    207207{
    … …  
    397397#endif
    398398    {
    399       dQPFactor=0.57*dLambda_scale;
     399      if (m_pcCfg->getIntraQpFactor()>=0.0 && m_pcCfg->getGOPEntry(iGOPid).m_sliceType != I_SLICE)
     400      {
     401        dQPFactor=m_pcCfg->getIntraQpFactor();
     402      }
     403      else
     404      {
     405        Double dLambda_scale = 1.0 - Clip3( 0.0, 0.5, 0.05*(Double)(isField ? NumberBFrames/2 : NumberBFrames) );
     406       
     407        dQPFactor=0.57*dLambda_scale;
     408      }
    400409    }
    401410    dLambda = dQPFactor*pow( 2.0, qp_temp/3.0 );
    … …  
    428437  iQP     = m_piRdPicQp    [0];
    429438
    430   if( rpcSlice->getSliceType( ) != I_SLICE )
    431   {
     439
    432440#if NH_MV
    433     dLambda *= m_pcCfg->getLambdaModifier( m_pcCfg->getGOPEntry((eSliceTypeBaseView == I_SLICE) ? MAX_GOP : iGOPid).m_temporalId );
    434 #else
    435     dLambda *= m_pcCfg->getLambdaModifier( m_pcCfg->getGOPEntry(iGOPid).m_temporalId );
    436 #endif
    437   }
    438 
     441  const Int temporalId=m_pcCfg->getGOPEntry((eSliceTypeBaseView == I_SLICE) ? MAX_GOP : iGOPid).m_temporalId;
     442#else
     443  const Int temporalId=m_pcCfg->getGOPEntry(iGOPid).m_temporalId;
     444#endif
     445  const std::vector<Double> &intraLambdaModifiers=m_pcCfg->getIntraLambdaModifier();
     446
     447  Double lambdaModifier;
     448  if( rpcSlice->getSliceType( ) != I_SLICE || intraLambdaModifiers.empty())
     449  {
     450    lambdaModifier = m_pcCfg->getLambdaModifier( temporalId );
     451  }
     452  else
     453  {
     454    lambdaModifier = intraLambdaModifiers[ (temporalId < intraLambdaModifiers.size()) ? temporalId : (intraLambdaModifiers.size()-1) ];
     455  }
     456
     457  dLambda *= lambdaModifier;
    439458  setUpLambda(rpcSlice, dLambda, iQP);
    440459
    … …  
    547566  rpcSlice->setDepth            ( depth );
    548567
    549 #if NH_MV
    550   pcPic->setTLayer( m_pcCfg->getGOPEntry( (eSliceTypeBaseView == I_SLICE) ? MAX_GOP : iGOPid ).m_temporalId );
    551 #else
    552   pcPic->setTLayer( m_pcCfg->getGOPEntry(iGOPid).m_temporalId );
    553 #endif
     568  pcPic->setTLayer( temporalId );
    554569  if(eSliceType==I_SLICE)
    555570  {
    … …  
    589604// ====================================================================================================================
    590605
     606//! set adaptive search range based on poc difference
    591607Void TEncSlice::setSearchRange( TComSlice* pcSlice )
    592608{
    … …  
    598614  Int iNumPredDir = pcSlice->isInterP() ? 1 : 2;
    599615
    600   for (Int iDir = 0; iDir <= iNumPredDir; iDir++)
    601   {
    602     //RefPicList e = (RefPicList)iDir;
     616  for (Int iDir = 0; iDir < iNumPredDir; iDir++)
     617  {
    603618    RefPicList  e = ( iDir ? REF_PIC_LIST_1 : REF_PIC_LIST_0 );
    604619    for (Int iRefIdx = 0; iRefIdx < pcSlice->getNumRefIdx(e); iRefIdx++)
    605620    {
    606621      iRefPOC = pcSlice->getRefPic(e, iRefIdx)->getPOC();
    607       Int iNewSR = Clip3(8, iMaxSR, (iMaxSR*ADAPT_SR_SCALE*abs(iCurrPOC - iRefPOC)+iOffset)/iGOPSize);
    608       m_pcPredSearch->setAdaptiveSearchRange(iDir, iRefIdx, iNewSR);
     622      Int newSearchRange = Clip3(m_pcCfg->getMinSearchWindow(), iMaxSR, (iMaxSR*ADAPT_SR_SCALE*abs(iCurrPOC - iRefPOC)+iOffset)/iGOPSize);
     623      m_pcPredSearch->setAdaptiveSearchRange(iDir, iRefIdx, newSearchRange);
    609624    }
    610625  }
    … …  
    696711
    697712    // compute RD cost and choose the best
    698     Double dPicRdCost = m_pcRdCost->calcRdCost64( m_uiPicTotalBits, uiPicDist, true, DF_SSE_FRAME); // NOTE: Is the 'true' parameter really necessary?
     713#if NH_3D
     714    Double dPicRdCost = m_pcRdCost->calcRdCost( (Double)m_uiPicTotalBits, uiPicDist, DF_SSE_FRAME);
     715#else
     716    Double dPicRdCost = m_pcRdCost->calcRdCost( (Double)m_uiPicTotalBits, (Double)uiPicDist, DF_SSE_FRAME);
     717#endif
    699718#if H_3D
    700719    // Above calculation need to be fixed for VSO, including frameLambda value.
    … …  
    805824    }
    806825
    807     xEstimateWPParamSlice( pcSlice );
     826    xEstimateWPParamSlice( pcSlice, m_pcCfg->getWeightedPredictionMethod() );
    808827    pcSlice->initWpScaling(pcSlice->getSPS());
    809828
    … …  
    849868    {
    850869      // This will only occur if dependent slice-segments (m_entropyCodingSyncContextState=true) are being used.
    851       if( pCurrentTile->getTileWidthInCtus() >= 2 || !m_pcCfg->getWaveFrontsynchro() )
     870      if( pCurrentTile->getTileWidthInCtus() >= 2 || !m_pcCfg->getEntropyCodingSyncEnabledFlag() )
    852871      {
    853872        m_pppcRDSbacCoder[0][CI_CURR_BEST]->loadContexts( &m_lastSliceSegmentEndContextState );
    … …  
    892911      m_pppcRDSbacCoder[0][CI_CURR_BEST]->resetEntropy(pcSlice);
    893912    }
    894     else if ( ctuXPosInCtus == tileXPosInCtus && m_pcCfg->getWaveFrontsynchro())
     913    else if ( ctuXPosInCtus == tileXPosInCtus && m_pcCfg->getEntropyCodingSyncEnabledFlag())
    895914    {
    896915      // reset and then update contexts to the state at the end of the top-right CTU (if within current slice and tile).
    … …  
    10311050
    10321051    // Store probabilities of second CTU in line into buffer - used only if wavefront-parallel-processing is enabled.
    1033     if ( ctuXPosInCtus == tileXPosInCtus+1 && m_pcCfg->getWaveFrontsynchro())
     1052    if ( ctuXPosInCtus == tileXPosInCtus+1 && m_pcCfg->getEntropyCodingSyncEnabledFlag())
    10341053    {
    10351054      m_entropyCodingSyncContextState.loadContexts(m_pppcRDSbacCoder[0][CI_CURR_BEST]);

  • branches/HTM-15.2-dev/source/Lib/TLibEncoder/TEncSlice.h

    r1313 r1360  
    120120                                Int iGOPid, TComSlice*& rpcSlice, TComVPS* pVPS, Int layerId, bool isField  );
    121121#else
    122   Void    initEncSlice        ( TComPic*  pcPic, Int pocLast, Int pocCurr,
    123                                 Int iGOPid,   TComSlice*& rpcSlice, Bool isField );
     122  Void    initEncSlice        ( TComPic*  pcPic, const Int pocLast, const Int pocCurr,
     123                                const Int iGOPid,   TComSlice*& rpcSlice, const Bool isField );
    124124#endif
    125125  Void    resetQP             ( TComPic* pic, Int sliceQP, Double lambda );

  • branches/HTM-15.2-dev/source/Lib/TLibEncoder/TEncTop.cpp

    r1321 r1360  
    4444#endif
    4545#if NH_MV
    46 #include "../../App/TAppEncoder/TAppEncTop.h"
     46//#include "../../App/TAppEncoder/TAppEncTop.h"
    4747#endif
    4848
    … …  
    216216  xInitVPS();
    217217
     218#if U0132_TARGET_BITS_SATURATION
     219  if (m_RCCpbSaturationEnabled)
     220  {
     221    m_cRateCtrl.initHrdParam(m_cSPS.getVuiParameters()->getHrdParameters(), m_iFrameRate, m_RCInitialCpbFullness);
     222  }
     223#endif
    218224  m_cRdCost.setCostMode(m_costMode);
    219225
    … …  
    264270
    265271  // initialize encoder search class
    266   m_cSearch.init( this, &m_cTrQuant, m_iSearchRange, m_bipredSearchRange, m_iFastSearch, m_maxCUWidth, m_maxCUHeight, m_maxTotalCUDepth, &m_cEntropyCoder, &m_cRdCost, getRDSbacCoder(), getRDGoOnSbacCoder() );
     272  m_cSearch.init( this, &m_cTrQuant, m_iSearchRange, m_bipredSearchRange, m_motionEstimationSearchMethod, m_maxCUWidth, m_maxCUHeight, m_maxTotalCUDepth, &m_cEntropyCoder, &m_cRdCost, getRDSbacCoder(), getRDGoOnSbacCoder() );
    267273
    268274  m_iMaxRefPicNum = 0;
    … …  
    299305  {
    300306    m_cSPS.getScalingList().setDefaultScalingList ();
    301     if(m_cSPS.getScalingList().xParseScalingList(getScalingListFile()))
     307    if(m_cSPS.getScalingList().xParseScalingList(getScalingListFileName()))
    302308    {
    303309      Bool bParsedScalingList=false; // Use of boolean so that assertion outputs useful string
    … …  
    842848    m_cSPS.setUsedByCurrPicLtSPSFlag(k, 0);
    843849  }
     850
     851#if U0132_TARGET_BITS_SATURATION
     852  if( getPictureTimingSEIEnabled() || getDecodingUnitInfoSEIEnabled() || getCpbSaturationEnabled() )
     853#else
    844854  if( getPictureTimingSEIEnabled() || getDecodingUnitInfoSEIEnabled() )
     855#endif
    845856  {
    846857    xInitHrdParameters();
    … …  
    866877  m_cSPS.setSpsRangeExtensionsFlag( m_cSPS.getSpsRangeExtension().settingsDifferFromDefaults() );
    867878#endif
    868 
    869 }
    870 
     879}
     880#if U0132_TARGET_BITS_SATURATION
     881// calculate scale value of bitrate and initial delay
     882Int calcScale(Int x)
     883{
     884  UInt iMask = 0xffffffff;
     885  Int ScaleValue = 32;
     886
     887  while ((x&iMask) != 0)
     888  {
     889    ScaleValue--;
     890    iMask = (iMask >> 1);
     891}
     892
     893  return ScaleValue;
     894}
     895#endif
    871896Void TEncTop::xInitHrdParameters()
    872897{
    … …  
    874899  Int  bitRate         = getTargetBitrate();
    875900  Bool isRandomAccess  = getIntraPeriod() > 0;
    876 
     901# if U0132_TARGET_BITS_SATURATION
     902  Int cpbSize          = getCpbSize();
     903
     904  if( !getVuiParametersPresentFlag() && !getCpbSaturationEnabled() )
     905#else
    877906  if( !getVuiParametersPresentFlag() )
     907#endif
    878908  {
    879909    return;
    … …  
    925955  }
    926956
     957#if U0132_TARGET_BITS_SATURATION
     958  if (calcScale(bitRate) <= 6)
     959  {
     960    hrd->setBitRateScale(0);
     961  }
     962  else
     963  {
     964    hrd->setBitRateScale(calcScale(bitRate) - 6);
     965  }
     966
     967  if (calcScale(cpbSize) <= 4)
     968  {
     969    hrd->setCpbSizeScale(0);
     970  }
     971  else
     972  {
     973    hrd->setCpbSizeScale(calcScale(cpbSize) - 4);
     974  }
     975#else
    927976  hrd->setBitRateScale( 4 );                                       // in units of 2^( 6 + 4 ) = 1,024 bps
    928977  hrd->setCpbSizeScale( 6 );                                       // in units of 2^( 4 + 6 ) = 1,024 bit
     978#endif
     979
    929980  hrd->setDuCpbSizeScale( 6 );                                     // in units of 2^( 4 + 6 ) = 1,024 bit
    930981
    … …  
    9581009    bitrateValue = bitRate / (1 << (6 + hrd->getBitRateScale()) );      // bitRate is in bits, so it needs to be scaled down
    9591010    // CpbSize[ i ] = ( cpb_size_value_minus1[ i ] + 1 ) * 2^( 4 + cpb_size_scale )
     1011#if U0132_TARGET_BITS_SATURATION
     1012    cpbSizeValue = cpbSize / (1 << (4 + hrd->getCpbSizeScale()) );      // using bitRate results in 1 second CPB size
     1013#else
    9601014    cpbSizeValue = bitRate / (1 << (4 + hrd->getCpbSizeScale()) );      // using bitRate results in 1 second CPB size
     1015#endif
     1016
    9611017
    9621018    // DU CPB size could be smaller (i.e. bitrateValue / number of DUs), but we don't know
    … …  
    10661122  m_cPPS.setQpOffset(COMPONENT_Cr, m_chromaCrQpOffset );
    10671123
    1068   m_cPPS.setEntropyCodingSyncEnabledFlag( m_iWaveFrontSynchro > 0 );
     1124  m_cPPS.setEntropyCodingSyncEnabledFlag( m_entropyCodingSyncEnabledFlag );
    10691125  m_cPPS.setTilesEnabledFlag( (m_iNumColumnsMinus1 > 0 || m_iNumRowsMinus1 > 0) );
    10701126  m_cPPS.setUseWP( m_useWeightedPred );

  • branches/HTM-15.2-dev/source/Lib/TLibEncoder/WeightPredAnalysis.cpp

    r1313 r1360  
    4141#include "../TLibCommon/TComPicYuv.h"
    4242#include "WeightPredAnalysis.h"
    43 
    44 #define ABS(a)    ((a) < 0 ? - (a) : (a))
    45 #define DTHRESH (0.99)
     43#include <limits>
     44
     45static const Double WEIGHT_PRED_SAD_RELATIVE_TO_NON_WEIGHT_PRED_SAD=0.99; // NOTE: U0040 used 0.95
     46
     47//! calculate SAD values for both WP version and non-WP version.
     48static
     49Int64 xCalcSADvalueWP(const Int   bitDepth,
     50                      const Pel  *pOrgPel,
     51                      const Pel  *pRefPel,
     52                      const Int   width,
     53                      const Int   height,
     54                      const Int   orgStride,
     55                      const Int   refStride,
     56                      const Int   log2Denom,
     57                      const Int   weight,
     58                      const Int   offset,
     59                      const Bool  useHighPrecision);
     60
     61//! calculate SAD values for both WP version and non-WP version.
     62static
     63Int64 xCalcSADvalueWPOptionalClip(const Int   bitDepth,
     64                                  const Pel  *pOrgPel,
     65                                  const Pel  *pRefPel,
     66                                  const Int   width,
     67                                  const Int   height,
     68                                  const Int   orgStride,
     69                                  const Int   refStride,
     70                                  const Int   log2Denom,
     71                                  const Int   weight,
     72                                  const Int   offset,
     73                                  const Bool  useHighPrecision,
     74                                  const Bool  clipped);
     75
     76// -----------------------------------------------------------------------------
     77// Helper functions
     78
     79
     80//! calculate Histogram for array of pixels
     81static
     82Void xCalcHistogram(const Pel  *pPel,
     83                    std::vector<Int> &histogram,
     84                    const Int   width,
     85                    const Int   height,
     86                    const Int   stride,
     87                    const Int   maxPel)
     88{
     89  histogram.clear();
     90  histogram.resize(maxPel);
     91  for( Int y = 0; y < height; y++ )
     92  {
     93    for( Int x = 0; x < width; x++ )
     94    {
     95      const Pel v=pPel[x];
     96      histogram[v<0?0:(v>=maxPel)?maxPel-1:v]++;
     97    }
     98    pPel += stride;
     99  }
     100}
     101
     102static
     103Distortion xCalcHistDistortion (const std::vector<Int> &histogram0,
     104                                const std::vector<Int> &histogram1)
     105{
     106  Distortion distortion = 0;
     107  assert(histogram0.size()==histogram1.size());
     108  const Int numElements=Int(histogram0.size());
     109
     110  // Scan histograms to compute histogram distortion
     111  for (Int i = 0; i <= numElements; i++)
     112  {
     113    distortion += (Distortion)(abs(histogram0[i] - histogram1[i]));
     114  }
     115
     116  return distortion;
     117}
     118
     119static
     120void xScaleHistogram(const std::vector<Int> &histogramInput,
     121                           std::vector<Int> &histogramOutput, // cannot be the same as the input
     122                     const Int               bitDepth,
     123                     const Int               log2Denom,
     124                     const Int               weight,
     125                     const Int               offset,
     126                     const Bool              bHighPrecision)
     127{
     128  assert(&histogramInput != &histogramOutput);
     129  const Int numElements=Int(histogramInput.size());
     130  histogramOutput.clear();
     131  histogramOutput.resize(numElements);
     132
     133  const Int64 iRealLog2Denom = bHighPrecision ? 0 : (bitDepth - 8);
     134  const Int64 iRealOffset    = ((Int64)offset)<<iRealLog2Denom;
     135
     136  const Int divOffset = log2Denom == 0 ? 0 : 1 << (log2Denom - 1);
     137  // Scan histogram and apply illumination parameters appropriately
     138  // Then compute updated histogram.
     139  // Note that this technique only works with single list weights/offsets.
     140
     141  for (Int i = 0; i < numElements; i++)
     142  {
     143    const Int j = Clip3(0, numElements - 1, (Int)(((weight * i + divOffset) >> log2Denom) + iRealOffset));
     144    histogramOutput[j] += histogramInput[i];
     145  }
     146}
     147
     148static
     149Distortion xSearchHistogram(const std::vector<Int> &histogramSource,
     150                            const std::vector<Int> &histogramRef,
     151                                  std::vector<Int> &outputHistogram,
     152                            const Int               bitDepth,
     153                            const Int               log2Denom,
     154                                  Int              &weightToUpdate,
     155                                  Int              &offsetToUpdate,
     156                            const Bool              bHighPrecision,
     157                            const ComponentID       compID)
     158{
     159  const Int initialWeight   = weightToUpdate;
     160  const Int initialOffset   = offsetToUpdate;
     161  const Int weightRange     = 10;
     162  const Int offsetRange     = 10;
     163  const Int maxOffset       = 1 << ((bHighPrecision == true) ? (bitDepth - 1) : 7);
     164  const Int range           = bHighPrecision ? (1<<bitDepth) / 2 : 128;
     165  const Int defaultWeight   = (1<<log2Denom);
     166  const Int minSearchWeight = std::max<Int>(initialWeight - weightRange, defaultWeight - range);
     167  const Int maxSearchWeight = std::min<Int>(initialWeight + weightRange+1, defaultWeight + range);
     168
     169  Distortion minDistortion   = std::numeric_limits<Distortion>::max();
     170  Int        bestWeight      = initialWeight;
     171  Int        bestOffset      = initialOffset;
     172
     173  for (Int searchWeight = minSearchWeight; searchWeight < maxSearchWeight; searchWeight++)
     174  {
     175    if (compID == COMPONENT_Y)
     176    {
     177      for (Int searchOffset = std::max<Int>(initialOffset - offsetRange, -maxOffset);
     178               searchOffset <= initialOffset + offsetRange && searchOffset<=(maxOffset-1);
     179               searchOffset++)
     180      {
     181        xScaleHistogram(histogramRef, outputHistogram, bitDepth, log2Denom, searchWeight, searchOffset, bHighPrecision);
     182        const Distortion distortion = xCalcHistDistortion(histogramSource, outputHistogram);
     183
     184        if (distortion < minDistortion)
     185        {
     186          minDistortion = distortion;
     187          bestWeight    = searchWeight;
     188          bestOffset    = searchOffset;
     189        }
     190      }
     191    }
     192    else
     193    {
     194      const Int pred        = ( maxOffset - ( ( maxOffset*searchWeight)>>(log2Denom) ) );
     195
     196      for (Int searchOffset = initialOffset - offsetRange; searchOffset <= initialOffset + offsetRange; searchOffset++)
     197      {
     198        const Int deltaOffset   = Clip3( -4*maxOffset, 4*maxOffset-1, (searchOffset - pred) ); // signed 10bit (if !bHighPrecision)
     199        const Int clippedOffset = Clip3( -1*maxOffset, 1*maxOffset-1, (deltaOffset  + pred) ); // signed 8bit  (if !bHighPrecision)
     200        xScaleHistogram(histogramRef, outputHistogram, bitDepth, log2Denom, searchWeight, clippedOffset, bHighPrecision);
     201        const Distortion distortion = xCalcHistDistortion(histogramSource, outputHistogram);
     202
     203        if (distortion < minDistortion)
     204        {
     205          minDistortion = distortion;
     206          bestWeight    = searchWeight;
     207          bestOffset    = clippedOffset;
     208        }
     209      }
     210    }
     211  }
     212
     213  weightToUpdate = bestWeight;
     214  offsetToUpdate = bestOffset;
     215
     216  // regenerate best histogram
     217  xScaleHistogram(histogramRef, outputHistogram, bitDepth, log2Denom, bestWeight, bestOffset, bHighPrecision);
     218
     219  return minDistortion;
     220}
     221
     222
     223// -----------------------------------------------------------------------------
     224// Member functions
    46225
    47226WeightPredAnalysis::WeightPredAnalysis()
    … …  
    49228  for ( UInt lst =0 ; lst<NUM_REF_PIC_LIST_01 ; lst++ )
    50229  {
    51     for ( Int iRefIdx=0 ; iRefIdx<MAX_NUM_REF ; iRefIdx++ )
     230    for ( Int refIdx=0 ; refIdx<MAX_NUM_REF ; refIdx++ )
    52231    {
    53232      for ( Int comp=0 ; comp<MAX_NUM_COMPONENT ;comp++ )
    54233      {
    55         WPScalingParam  *pwp   = &(m_wp[lst][iRefIdx][comp]);
     234        WPScalingParam  *pwp   = &(m_wp[lst][refIdx][comp]);
    56235        pwp->bPresentFlag      = false;
    57236        pwp->uiLog2WeightDenom = 0;
    … …  
    78257    // calculate DC/AC value for channel
    79258
    80     const Int iStride = pPic->getStride(compID);
    81     const Int iWidth  = pPic->getWidth(compID);
    82     const Int iHeight = pPic->getHeight(compID);
    83 
    84     const Int iSample = iWidth*iHeight;
    85 
    86     Int64 iOrgDC = 0;
     259    const Int stride = pPic->getStride(compID);
     260    const Int width  = pPic->getWidth(compID);
     261    const Int height = pPic->getHeight(compID);
     262
     263    const Int sample = width*height;
     264
     265    Int64 orgDC = 0;
    87266    {
    88267      const Pel *pPel = pPic->getAddr(compID);
    89268
    90       for(Int y = 0; y < iHeight; y++, pPel+=iStride )
    91       {
    92         for(Int x = 0; x < iWidth; x++ )
    93         {
    94           iOrgDC += (Int)( pPel[x] );
    95         }
    96       }
    97     }
    98 
    99     const Int64 iOrgNormDC = ((iOrgDC+(iSample>>1)) / iSample);
    100 
    101     Int64 iOrgAC = 0;
     269      for(Int y = 0; y < height; y++, pPel+=stride )
     270      {
     271        for(Int x = 0; x < width; x++ )
     272        {
     273          orgDC += (Int)( pPel[x] );
     274        }
     275      }
     276    }
     277
     278    const Int64 orgNormDC = ((orgDC+(sample>>1)) / sample);
     279
     280    Int64 orgAC = 0;
    102281    {
    103282      const Pel *pPel = pPic->getAddr(compID);
    104283
    105       for(Int y = 0; y < iHeight; y++, pPel += iStride )
    106       {
    107         for(Int x = 0; x < iWidth; x++ )
    108         {
    109           iOrgAC += abs( (Int)pPel[x] - (Int)iOrgNormDC );
     284      for(Int y = 0; y < height; y++, pPel += stride )
     285      {
     286        for(Int x = 0; x < width; x++ )
     287        {
     288          orgAC += abs( (Int)pPel[x] - (Int)orgNormDC );
    110289        }
    111290      }
    … …  
    113292
    114293    const Int fixedBitShift = (slice->getSPS()->getSpsRangeExtension().getHighPrecisionOffsetsEnabledFlag())?RExt__PREDICTION_WEIGHTING_ANALYSIS_DC_PRECISION:0;
    115     weightACDCParam[compID].iDC = (((iOrgDC<<fixedBitShift)+(iSample>>1)) / iSample);
    116     weightACDCParam[compID].iAC = iOrgAC;
     294    weightACDCParam[compID].iDC = (((orgDC<<fixedBitShift)+(sample>>1)) / sample);
     295    weightACDCParam[compID].iAC = orgAC;
    117296  }
    118297
    … …  
    126305  const TComPicYuv *pPic = slice->getPic()->getPicYuvOrg();
    127306
    128   Int iPresentCnt = 0;
     307  Int presentCnt = 0;
    129308  for ( UInt lst=0 ; lst<NUM_REF_PIC_LIST_01 ; lst++ )
    130309  {
    131     for ( Int iRefIdx=0 ; iRefIdx<MAX_NUM_REF ; iRefIdx++ )
     310    for ( Int refIdx=0 ; refIdx<MAX_NUM_REF ; refIdx++ )
    132311    {
    133312      for(Int componentIndex = 0; componentIndex < pPic->getNumberValidComponents(); componentIndex++)
    134313      {
    135         WPScalingParam  *pwp = &(m_wp[lst][iRefIdx][componentIndex]);
    136         iPresentCnt += (Int)pwp->bPresentFlag;
    137       }
    138     }
    139   }
    140 
    141   if(iPresentCnt==0)
     314        WPScalingParam  *pwp = &(m_wp[lst][refIdx][componentIndex]);
     315        presentCnt += (Int)pwp->bPresentFlag;
     316      }
     317    }
     318  }
     319
     320  if(presentCnt==0)
    142321  {
    143322    slice->setTestWeightPred(false);
    … …  
    146325    for ( UInt lst=0 ; lst<NUM_REF_PIC_LIST_01 ; lst++ )
    147326    {
    148       for ( Int iRefIdx=0 ; iRefIdx<MAX_NUM_REF ; iRefIdx++ )
     327      for ( Int refIdx=0 ; refIdx<MAX_NUM_REF ; refIdx++ )
    149328      {
    150329        for(Int componentIndex = 0; componentIndex < pPic->getNumberValidComponents(); componentIndex++)
    151330        {
    152           WPScalingParam  *pwp = &(m_wp[lst][iRefIdx][componentIndex]);
     331          WPScalingParam  *pwp = &(m_wp[lst][refIdx][componentIndex]);
    153332
    154333          pwp->bPresentFlag      = false;
    … …  
    163342  else
    164343  {
    165     slice->setTestWeightPred(slice->getPPS()->getUseWP());
     344    slice->setTestWeightPred  (slice->getPPS()->getUseWP());
    166345    slice->setTestWeightBiPred(slice->getPPS()->getWPBiPred());
    167346  }
    … …  
    170349
    171350//! estimate wp tables for explicit wp
    172 Void WeightPredAnalysis::xEstimateWPParamSlice(TComSlice *const slice)
     351Void WeightPredAnalysis::xEstimateWPParamSlice(TComSlice *const slice, const WeightedPredictionMethod method)
    173352{
    174353  Int  iDenom         = 6;
    … …  
    191370  // selecting whether WP is used, or not (fast search)
    192371  // NOTE: This is not operating on a slice, but the entire picture.
    193   xSelectWP(slice, iDenom);
     372  switch (method)
     373  {
     374    case WP_PER_PICTURE_WITH_SIMPLE_DC_COMBINED_COMPONENT:
     375      xSelectWP(slice, iDenom);
     376      break;
     377    case WP_PER_PICTURE_WITH_SIMPLE_DC_PER_COMPONENT:
     378      xSelectWPHistExtClip(slice, iDenom, false, false, false);
     379      break;
     380    case WP_PER_PICTURE_WITH_HISTOGRAM_AND_PER_COMPONENT:
     381      xSelectWPHistExtClip(slice, iDenom, false, false, true);
     382      break;
     383    case WP_PER_PICTURE_WITH_HISTOGRAM_AND_PER_COMPONENT_AND_CLIPPING:
     384      xSelectWPHistExtClip(slice, iDenom, false, true, true);
     385      break;
     386    case WP_PER_PICTURE_WITH_HISTOGRAM_AND_PER_COMPONENT_AND_CLIPPING_AND_EXTENSION:
     387      xSelectWPHistExtClip(slice, iDenom, true, true, true);
     388      break;
     389    default:
     390      assert(0);
     391      exit(1);
     392  }
    194393
    195394  slice->setWpScaling( m_wp );
    … …  
    251450        // Weighting factor limitation
    252451        const Int defaultWeight = (1<<log2Denom);
    253         const Int deltaWeight   = (defaultWeight - weight);
     452        const Int deltaWeight   = (weight - defaultWeight);
    254453
    255454        if(deltaWeight >= range || deltaWeight < -range)
    … …  
    269468
    270469
     470/** select whether weighted pred enables or not.
     471 * \param TComSlice *slice
     472 * \param log2Denom
     473 * \returns Bool
     474 */
     475Bool WeightPredAnalysis::xSelectWPHistExtClip(TComSlice *const slice, const Int log2Denom, const Bool bDoEnhancement, const Bool bClipInitialSADWP, const Bool bUseHistogram)
     476{
     477  const TComPicYuv *const pPic             = slice->getPic()->getPicYuvOrg();
     478  const Int               defaultWeight    = 1<<log2Denom;
     479  const Int               numPredDir       = slice->isInterP() ? 1 : 2;
     480  const Bool              useHighPrecision = slice->getSPS()->getSpsRangeExtension().getHighPrecisionOffsetsEnabledFlag();
     481
     482  assert (numPredDir <= Int(NUM_REF_PIC_LIST_01));
     483
     484  for ( Int refList = 0; refList < numPredDir; refList++ )
     485  {
     486    const RefPicList eRefPicList = ( refList ? REF_PIC_LIST_1 : REF_PIC_LIST_0 );
     487
     488    for ( Int refIdxTemp = 0; refIdxTemp < slice->getNumRefIdx(eRefPicList); refIdxTemp++ )
     489    {
     490      Bool  useChromaWeight = false;
     491
     492      for(Int comp=0; comp<pPic->getNumberValidComponents(); comp++)
     493      {
     494        const ComponentID  compID     = ComponentID(comp);
     495        const Pel         *pOrg       = pPic->getAddr(compID);
     496        const Pel         *pRef       = slice->getRefPic(eRefPicList, refIdxTemp)->getPicYuvRec()->getAddr(compID);
     497        const Int          orgStride  = pPic->getStride(compID);
     498        const Int          refStride  = slice->getRefPic(eRefPicList, refIdxTemp)->getPicYuvRec()->getStride(compID);
     499        const Int          width      = pPic->getWidth(compID);
     500        const Int          height     = pPic->getHeight(compID);
     501        const Int          bitDepth   = slice->getSPS()->getBitDepth(toChannelType(compID));
     502              WPScalingParam &wp      = m_wp[refList][refIdxTemp][compID];
     503              Int          weight     = wp.iWeight;
     504              Int          offset     = wp.iOffset;
     505              Int          weightDef  = defaultWeight;
     506              Int          offsetDef  = 0;
     507
     508        // calculate SAD costs with/without wp for luma
     509        const Int64 SADnoWP = xCalcSADvalueWPOptionalClip(bitDepth, pOrg, pRef, width, height, orgStride, refStride, log2Denom, defaultWeight, 0, useHighPrecision, bClipInitialSADWP);
     510        if (SADnoWP > 0)
     511        {
     512          const Int64 SADWP   = xCalcSADvalueWPOptionalClip(bitDepth, pOrg, pRef, width, height, orgStride, refStride, log2Denom, weight,   offset, useHighPrecision, bClipInitialSADWP);
     513          const Double dRatioSAD = (Double)SADWP / (Double)SADnoWP;
     514          Double dRatioSr0SAD = std::numeric_limits<Double>::max();
     515          Double dRatioSrSAD  = std::numeric_limits<Double>::max();
     516
     517          if (bUseHistogram)
     518          {
     519            std::vector<Int> histogramOrg;// = pPic->getHistogram(compID);
     520            std::vector<Int> histogramRef;// = slice->getRefPic(eRefPicList, refIdxTemp)->getPicYuvRec()->getHistogram(compID);
     521            std::vector<Int> searchedHistogram;
     522
     523            // Compute histograms
     524            xCalcHistogram(pOrg, histogramOrg, width, height, orgStride, 1 << bitDepth);
     525            xCalcHistogram(pRef, histogramRef, width, height, refStride, 1 << bitDepth);
     526
     527            // Do a histogram search around DC WP parameters; resulting distortion and 'searchedHistogram' is discarded
     528            xSearchHistogram(histogramOrg, histogramRef, searchedHistogram, bitDepth, log2Denom, weight, offset, useHighPrecision, compID);
     529            // calculate updated WP SAD
     530            const Int64 SADSrWP = xCalcSADvalueWP(bitDepth, pOrg, pRef, width, height, orgStride, refStride, log2Denom, weight, offset, useHighPrecision);
     531            dRatioSrSAD  = (Double)SADSrWP  / (Double)SADnoWP;
     532
     533            if (bDoEnhancement)
     534            {
     535              // Do the same around the default ones; resulting distortion and 'searchedHistogram' is discarded
     536              xSearchHistogram(histogramOrg, histogramRef, searchedHistogram, bitDepth, log2Denom, weightDef, offsetDef, useHighPrecision, compID);
     537              // calculate updated WP SAD
     538              const Int64 SADSr0WP = xCalcSADvalueWP(bitDepth, pOrg, pRef, width, height, orgStride, refStride, log2Denom, weightDef, offsetDef, useHighPrecision);
     539              dRatioSr0SAD = (Double)SADSr0WP / (Double)SADnoWP;
     540            }
     541          }
     542
     543          if(min(dRatioSr0SAD, min(dRatioSAD, dRatioSrSAD)) >= WEIGHT_PRED_SAD_RELATIVE_TO_NON_WEIGHT_PRED_SAD)
     544          {
     545            wp.bPresentFlag      = false;
     546            wp.iOffset           = 0;
     547            wp.iWeight           = defaultWeight;
     548            wp.uiLog2WeightDenom = log2Denom;
     549          }
     550          else
     551          {
     552            if (compID != COMPONENT_Y)
     553            {
     554              useChromaWeight = true;
     555            }
     556
     557            if (dRatioSr0SAD < dRatioSrSAD && dRatioSr0SAD < dRatioSAD)
     558            {
     559              wp.bPresentFlag      = true;
     560              wp.iOffset           = offsetDef;
     561              wp.iWeight           = weightDef;
     562              wp.uiLog2WeightDenom = log2Denom;
     563            }
     564            else if (dRatioSrSAD < dRatioSAD)
     565            {
     566              wp.bPresentFlag      = true;
     567              wp.iOffset           = offset;
     568              wp.iWeight           = weight;
     569              wp.uiLog2WeightDenom = log2Denom;
     570            }
     571          }
     572        }
     573        else // (SADnoWP <= 0)
     574        {
     575          wp.bPresentFlag      = false;
     576          wp.iOffset           = 0;
     577          wp.iWeight           = defaultWeight;
     578          wp.uiLog2WeightDenom = log2Denom;
     579        }
     580      }
     581
     582      for(Int comp=1; comp<pPic->getNumberValidComponents(); comp++)
     583      {
     584        m_wp[refList][refIdxTemp][comp].bPresentFlag = useChromaWeight;
     585      }
     586    }
     587  }
     588
     589  return true;
     590}
     591
    271592//! select whether weighted pred enables or not.
    272593Bool WeightPredAnalysis::xSelectWP(TComSlice *const slice, const Int log2Denom)
    273594{
    274595        TComPicYuv *const pPic                                = slice->getPic()->getPicYuvOrg();
    275   const Int               iDefaultWeight                      = ((Int)1<<log2Denom);
    276   const Int               iNumPredDir                         = slice->isInterP() ? 1 : 2;
     596  const Int               defaultWeight                       = 1<<log2Denom;
     597  const Int               numPredDir                          = slice->isInterP() ? 1 : 2;
    277598  const Bool              useHighPrecisionPredictionWeighting = slice->getSPS()->getSpsRangeExtension().getHighPrecisionOffsetsEnabledFlag();
    278599
    279   assert (iNumPredDir <= Int(NUM_REF_PIC_LIST_01));
    280 
    281   for ( Int iRefList = 0; iRefList < iNumPredDir; iRefList++ )
    282   {
    283     const RefPicList eRefPicList = ( iRefList ? REF_PIC_LIST_1 : REF_PIC_LIST_0 );
    284 
    285     for ( Int iRefIdxTemp = 0; iRefIdxTemp < slice->getNumRefIdx(eRefPicList); iRefIdxTemp++ )
    286     {
    287       Int64 iSADWP = 0, iSADnoWP = 0;
     600  assert (numPredDir <= Int(NUM_REF_PIC_LIST_01));
     601
     602  for ( Int refList = 0; refList < numPredDir; refList++ )
     603  {
     604    const RefPicList eRefPicList = ( refList ? REF_PIC_LIST_1 : REF_PIC_LIST_0 );
     605
     606    for ( Int refIdxTemp = 0; refIdxTemp < slice->getNumRefIdx(eRefPicList); refIdxTemp++ )
     607    {
     608      Int64 SADWP = 0, SADnoWP = 0;
    288609
    289610      for(Int comp=0; comp<pPic->getNumberValidComponents(); comp++)
    … …  
    291612        const ComponentID  compID     = ComponentID(comp);
    292613              Pel         *pOrg       = pPic->getAddr(compID);
    293               Pel         *pRef       = slice->getRefPic(eRefPicList, iRefIdxTemp)->getPicYuvRec()->getAddr(compID);
    294         const Int          iOrgStride = pPic->getStride(compID);
    295         const Int          iRefStride = slice->getRefPic(eRefPicList, iRefIdxTemp)->getPicYuvRec()->getStride(compID);
    296         const Int          iWidth     = pPic->getWidth(compID);
    297         const Int          iHeight    = pPic->getHeight(compID);
     614              Pel         *pRef       = slice->getRefPic(eRefPicList, refIdxTemp)->getPicYuvRec()->getAddr(compID);
     615        const Int          orgStride = pPic->getStride(compID);
     616        const Int          refStride = slice->getRefPic(eRefPicList, refIdxTemp)->getPicYuvRec()->getStride(compID);
     617        const Int          width     = pPic->getWidth(compID);
     618        const Int          height    = pPic->getHeight(compID);
    298619        const Int          bitDepth   = slice->getSPS()->getBitDepth(toChannelType(compID));
    299620
    300621        // calculate SAD costs with/without wp for luma
    301         iSADWP   += xCalcSADvalueWP(bitDepth, pOrg, pRef, iWidth, iHeight, iOrgStride, iRefStride, log2Denom, m_wp[iRefList][iRefIdxTemp][compID].iWeight, m_wp[iRefList][iRefIdxTemp][compID].iOffset, useHighPrecisionPredictionWeighting);
    302         iSADnoWP += xCalcSADvalueWP(bitDepth, pOrg, pRef, iWidth, iHeight, iOrgStride, iRefStride, log2Denom, iDefaultWeight, 0, useHighPrecisionPredictionWeighting);
    303       }
    304 
    305       const Double dRatio = ((Double)iSADWP / (Double)iSADnoWP);
    306       if(dRatio >= (Double)DTHRESH)
     622        SADWP   += xCalcSADvalueWP(bitDepth, pOrg, pRef, width, height, orgStride, refStride, log2Denom, m_wp[refList][refIdxTemp][compID].iWeight, m_wp[refList][refIdxTemp][compID].iOffset, useHighPrecisionPredictionWeighting);
     623        SADnoWP += xCalcSADvalueWP(bitDepth, pOrg, pRef, width, height, orgStride, refStride, log2Denom, defaultWeight, 0, useHighPrecisionPredictionWeighting);
     624      }
     625
     626      const Double dRatio = SADnoWP > 0 ? (((Double)SADWP / (Double)SADnoWP)) : std::numeric_limits<Double>::max();
     627      if(dRatio >= WEIGHT_PRED_SAD_RELATIVE_TO_NON_WEIGHT_PRED_SAD)
    307628      {
    308629        for(Int comp=0; comp<pPic->getNumberValidComponents(); comp++)
    309630        {
    310           m_wp[iRefList][iRefIdxTemp][comp].bPresentFlag      = false;
    311           m_wp[iRefList][iRefIdxTemp][comp].iOffset           = 0;
    312           m_wp[iRefList][iRefIdxTemp][comp].iWeight           = iDefaultWeight;
    313           m_wp[iRefList][iRefIdxTemp][comp].uiLog2WeightDenom = log2Denom;
     631          WPScalingParam &wp=m_wp[refList][refIdxTemp][comp];
     632          wp.bPresentFlag      = false;
     633          wp.iOffset           = 0;
     634          wp.iWeight           = defaultWeight;
     635          wp.uiLog2WeightDenom = log2Denom;
    314636        }
    315637      }
    … …  
    320642}
    321643
    322 
    323 //! calculate SAD values for both WP version and non-WP version.
    324 Int64 WeightPredAnalysis::xCalcSADvalueWP(const Int   bitDepth,
    325                                           const Pel  *pOrgPel,
    326                                           const Pel  *pRefPel,
    327                                           const Int   iWidth,
    328                                           const Int   iHeight,
    329                                           const Int   iOrgStride,
    330                                           const Int   iRefStride,
    331                                           const Int   iLog2Denom,
    332                                           const Int   iWeight,
    333                                           const Int   iOffset,
    334                                           const Bool  useHighPrecisionPredictionWeighting)
    335 {
    336   const Int64 iSize          = iWidth*iHeight;
    337   const Int64 iRealLog2Denom = useHighPrecisionPredictionWeighting ? iLog2Denom : (iLog2Denom + (bitDepth - 8));
    338 
    339   Int64 iSAD = 0;
    340   for( Int y = 0; y < iHeight; y++ )
    341   {
    342     for( Int x = 0; x < iWidth; x++ )
    343     {
    344       iSAD += ABS(( ((Int64)pOrgPel[x]<<(Int64)iLog2Denom) - ( (Int64)pRefPel[x] * (Int64)iWeight + ((Int64)iOffset<<iRealLog2Denom) ) ) );
    345     }
    346     pOrgPel += iOrgStride;
    347     pRefPel += iRefStride;
    348   }
    349 
    350   return (iSAD/iSize);
    351 }
     644// Alternatively, a SSE-based measure could be used instead.
     645// The respective function has been removed as it currently redundant.
     646static
     647Int64 xCalcSADvalueWP(const Int   bitDepth,
     648                      const Pel  *pOrgPel,
     649                      const Pel  *pRefPel,
     650                      const Int   width,
     651                      const Int   height,
     652                      const Int   orgStride,
     653                      const Int   refStride,
     654                      const Int   log2Denom,
     655                      const Int   weight,
     656                      const Int   offset,
     657                      const Bool  useHighPrecision)
     658{
     659  //const Int64 iSize          = iWidth*iHeight;
     660  const Int64 realLog2Denom = useHighPrecision ? log2Denom : (log2Denom + (bitDepth - 8));
     661  const Int64 realOffset    = ((Int64)offset)<<realLog2Denom;
     662
     663  Int64 SAD = 0;
     664  for( Int y = 0; y < height; y++ )
     665  {
     666    for( Int x = 0; x < width; x++ )
     667    {
     668      SAD += abs(( ((Int64)pOrgPel[x] << (Int64) log2Denom) - ( (Int64) pRefPel[x] * (Int64) weight + (realOffset) ) ) );
     669    }
     670    pOrgPel += orgStride;
     671    pRefPel += refStride;
     672  }
     673
     674  //return (iSAD/iSize);
     675  return SAD;
     676}
     677
     678static
     679Int64 xCalcSADvalueWPOptionalClip(const Int   bitDepth,
     680                                  const Pel  *pOrgPel,
     681                                  const Pel  *pRefPel,
     682                                  const Int   width,
     683                                  const Int   height,
     684                                  const Int   orgStride,
     685                                  const Int   refStride,
     686                                  const Int   log2Denom,
     687                                  const Int   weight,
     688                                  const Int   offset,
     689                                  const Bool  useHighPrecision,
     690                                  const Bool  clipped)
     691{
     692  Int64 SAD = 0;
     693  if (clipped)
     694  {
     695    const Int64 realLog2Denom = useHighPrecision ? 0 : (bitDepth - 8);
     696    const Int64 realOffset    = (Int64)offset<<realLog2Denom;
     697    const Int64 roundOffset = (log2Denom == 0) ? 0 : 1 << (log2Denom - 1);
     698    const Int64 minValue = 0;
     699    const Int64 maxValue = (1 << bitDepth) - 1;
     700
     701    for( Int y = 0; y < height; y++ )
     702    {
     703      for( Int x = 0; x < width; x++ )
     704      {
     705        Int64 scaledValue = Clip3(minValue, maxValue,  ((((Int64) pRefPel[x] * (Int64) weight + roundOffset) ) >>  (Int64) log2Denom) + realOffset);
     706        SAD += abs((Int64)pOrgPel[x] -  scaledValue);
     707      }
     708      pOrgPel += orgStride;
     709      pRefPel += refStride;
     710    }
     711  }
     712  else
     713  {
     714    //const Int64 iSize          = iWidth*iHeight;
     715    const Int64 realLog2Denom = useHighPrecision ? log2Denom : (log2Denom + (bitDepth - 8));
     716    const Int64 realOffset    = ((Int64)offset)<<realLog2Denom;
     717
     718    for( Int y = 0; y < height; y++ )
     719    {
     720      for( Int x = 0; x < width; x++ )
     721      {
     722        SAD += abs(( ((Int64)pOrgPel[x] << (Int64) log2Denom) - ( (Int64) pRefPel[x] * (Int64) weight + (realOffset) ) ) );
     723      }
     724      pOrgPel += orgStride;
     725      pRefPel += refStride;
     726    }
     727  }
     728  return SAD;
     729}

  • branches/HTM-15.2-dev/source/Lib/TLibEncoder/WeightPredAnalysis.h

    r1313 r1360  
    5252
    5353  Bool  xSelectWP            (TComSlice *const slice, const Int log2Denom);
     54  Bool  xSelectWPHistExtClip (TComSlice *const slice, const Int log2Denom, const Bool bDoEnhancement, const Bool bClipInitialSADWP, const Bool bUseHistogram);
    5455  Bool  xUpdatingWPParameters(TComSlice *const slice, const Int log2Denom);
    55 
    56   Int64 xCalcSADvalueWP      (const Int   bitDepth,
    57                               const Pel  *pOrgPel,
    58                               const Pel  *pRefPel,
    59                               const Int   iWidth,
    60                               const Int   iHeight,
    61                               const Int   iOrgStride,
    62                               const Int   iRefStride,
    63                               const Int   iLog2Denom,
    64                               const Int   iWeight,
    65                               const Int   iOffset,
    66                               const Bool  useHighPrecisionPredictionWeighting);
    6756
    6857public:
    … …  
    7261  // WP analysis :
    7362  Void  xCalcACDCParamSlice  (TComSlice *const slice);
    74   Void  xEstimateWPParamSlice(TComSlice *const slice);
     63  Void  xEstimateWPParamSlice(TComSlice *const slice, const WeightedPredictionMethod method);
    7564  Void  xCheckWPEnable       (TComSlice *const slice);
    7665};

  • branches/HTM-15.2-dev/source/Lib/TLibRenderer/TRenModSetupStrParser.cpp

    r1313 r1360  
    153153
    154154Void
    155 TRenModSetupStrParser::setString( Int iNumOfBaseViews, Char* pchSetStr )
     155TRenModSetupStrParser::setString( Int iNumOfBaseViews, TChar* pchSetStr )
    156156{
    157157  for (Int iContent = 0; iContent < 2; iContent++)
    … …  
    178178TRenModSetupStrParser::xParseString()
    179179{
    180   Char cChar;
     180  TChar cChar;
    181181  xGetNextChar(cChar);
    182182  while(  cChar != '\0' )
    … …  
    220220  m_bCurrentViewSet = false;
    221221
    222   Char cChar;
     222  TChar cChar;
    223223  xGetNextCharGoOn( cChar );
    224224  xError( cChar != '[' );
    … …  
    249249
    250250Void
    251 TRenModSetupStrParser::xReadViews( Char cType )
    252 {
    253   Char cChar;
     251TRenModSetupStrParser::xReadViews( TChar cType )
     252{
     253  TChar cChar;
    254254  xGetNextCharGoOn( cChar );
    255255  xError( cChar != '(' );
    … …  
    272272
    273273Void
    274 TRenModSetupStrParser::xReadViewInfo( Char cType )
     274TRenModSetupStrParser::xReadViewInfo( TChar cType )
    275275{
    276276  std::vector<Int> aiViewNums;
    … …  
    280280  {
    281281  case 'B':
    282     Char cVideoType;
    283     Char cDepthType;
     282    TChar cVideoType;
     283    TChar cDepthType;
    284284
    285285    xGetNextCharGoOn   ( cVideoType );
    … …  
    317317  case 'L':
    318318  case 'R':
    319     Char cRefType;
     319    TChar cRefType;
    320320    xGetNextCharGoOn   ( cRefType   );
    321321    xGetViewNumberRange( aiViewNums );
    … …  
    328328
    329329Void
    330 TRenModSetupStrParser::xAddBaseView( Int iViewIdx, Char cVideoType, Char cDepthType )
     330TRenModSetupStrParser::xAddBaseView( Int iViewIdx, TChar cVideoType, TChar cDepthType )
    331331{
    332332  AOF( m_bCurrentViewSet );
    … …  
    334334  if ( cDepthType == 'x' ) cDepthType = 'o';
    335335  if ( cVideoType == 'x' ) cVideoType = 'o';
    336 
    337 
    338 
     336 
    339337  xError( cDepthType != 'o' && cDepthType != 'c' && cVideoType != 'r' );
    340338  xError( cVideoType != 'o' && cVideoType != 'c' && cVideoType != 'r' );
    … …  
    346344
    347345Void
    348 TRenModSetupStrParser::xAddSynthView( Int iViewNum, Char cType, Char cRefType )
     346TRenModSetupStrParser::xAddSynthView( Int iViewNum, TChar cType, TChar cRefType )
    349347{
    350348  AOF( m_bCurrentViewSet );
    … …  
    399397  size_t iStartPos;
    400398  size_t iEndPos;
    401   Char cChar;
     399  TChar cChar;
    402400  xGetNextCharGoOn(cChar );
    403401  if (cChar == '{')
    … …  
    424422
    425423  size_t iNumElem = iEndPos - iStartPos + 1;
    426   Char* pcTempBuffer = new Char[  iNumElem + 1];
     424  TChar* pcTempBuffer = new TChar[  iNumElem + 1];
    427425  strncpy( pcTempBuffer, m_pchSetStr + iStartPos, iNumElem );
    428426  pcTempBuffer[iNumElem] = '\0';
    … …  
    433431
    434432Void
    435 TRenModSetupStrParser::xGetNextCharGoOn( Char& rcNextChar )
     433TRenModSetupStrParser::xGetNextCharGoOn( TChar& rcNextChar )
    436434{
    437435  while ( m_pchSetStr[m_iPosInStr] == ' ' || m_pchSetStr[m_iPosInStr] == ',' )
    … …  
    445443
    446444Void
    447 TRenModSetupStrParser::xGetNextChar( Char& rcNextChar )
     445TRenModSetupStrParser::xGetNextChar( TChar& rcNextChar )
    448446{
    449447  size_t iPos = m_iPosInStr;

  • branches/HTM-15.2-dev/source/Lib/TLibRenderer/TRenModSetupStrParser.h

    r1356 r1360  
    9292  TRenModSetupStrParser();
    9393
    94   Void setString( Int iNumOfBaseViews, Char* pchSetStr );
     94  Void setString( Int iNumOfBaseViews, TChar* pchSetStr );
    9595
    9696private:
    … …  
    112112  Int                              m_iNumberOfModels;
    113113
    114   Char*                            m_pchSetStr;
     114  TChar*                            m_pchSetStr;
    115115  size_t                           m_iPosInStr;
    116116
    … …  
    118118  Void xParseString();
    119119  Void xParseSourceView();
    120   Void xReadViews         ( Char cType );
    121   Void xReadViewInfo      ( Char cType );
    122   Void xAddBaseView       ( Int iViewIdx, Char cVideoType, Char cDepthType );
    123   Void xAddSynthView      ( Int iViewNum, Char cType, Char cRefType );
     120  Void xReadViews         ( TChar cType );
     121  Void xReadViewInfo      ( TChar cType );
     122  Void xAddBaseView       ( Int iViewIdx, TChar cVideoType, TChar cDepthType );
     123  Void xAddSynthView      ( Int iViewNum, TChar cType, TChar cRefType );
    124124  Void xError             ( Bool bIsError );
    125125  Void xGetViewNumberRange( std::vector<Int>& raiViewNumbers );
    126   Void xGetNextCharGoOn   ( Char& rcNextChar );
    127   Void xGetNextChar       ( Char& rcNextChar );
     126  Void xGetNextCharGoOn   ( TChar& rcNextChar );
     127  Void xGetNextChar       ( TChar& rcNextChar );
    128128};
    129129

  • branches/HTM-15.2-dev/source/Lib/TLibVideoIO/TVideoIOYuv.cpp

    r1313 r1360  
    9595}
    9696
     97static Void
     98copyPlane(const TComPicYuv &src, const ComponentID srcPlane, TComPicYuv &dest, const ComponentID destPlane);
    9799
    98100// ====================================================================================================================
    … …  
    116118 * \param internalBitDepth bit-depth array to scale image data to/from when reading/writing.
    117119 */
    118 Void TVideoIOYuv::open( Char* pchFile, Bool bWriteMode, const Int fileBitDepth[MAX_NUM_CHANNEL_TYPE], const Int MSBExtendedBitDepth[MAX_NUM_CHANNEL_TYPE], const Int internalBitDepth[MAX_NUM_CHANNEL_TYPE] )
     120Void TVideoIOYuv::open( const std::string &fileName, Bool bWriteMode, const Int fileBitDepth[MAX_NUM_CHANNEL_TYPE], const Int MSBExtendedBitDepth[MAX_NUM_CHANNEL_TYPE], const Int internalBitDepth[MAX_NUM_CHANNEL_TYPE] )
    119121{
    120122  //NOTE: files cannot have bit depth greater than 16
    … …  
    141143  if ( bWriteMode )
    142144  {
    143     m_cHandle.open( pchFile, ios::binary | ios::out );
     145    m_cHandle.open( fileName.c_str(), ios::binary | ios::out );
    144146
    145147    if( m_cHandle.fail() )
    … …  
    151153  else
    152154  {
    153     m_cHandle.open( pchFile, ios::binary | ios::in );
     155    m_cHandle.open( fileName.c_str(), ios::binary | ios::in );
    154156
    155157    if( m_cHandle.fail() )
    … …  
    217219
    218220  /* fall back to consuming the input */
    219   Char buf[512];
     221  TChar buf[512];
    220222  const streamoff offset_mod_bufsize = offset % sizeof(buf);
    221223  for (streamoff i = 0; i < offset - offset_mod_bufsize; i += sizeof(buf))
    … …  
    274276  const UInt stride_file      = (width444 * (is16bit ? 2 : 1)) >> csx_file;
    275277
    276   UChar  *buf   = new UChar[stride_file];
     278  std::vector<UChar> bufVec(stride_file);
     279  UChar *buf=&(bufVec[0]);
    277280
    278281  if (compID!=COMPONENT_Y && (fileFormat==CHROMA_400 || destFormat==CHROMA_400))
    … …  
    297300      if (fd.eof() || fd.fail() )
    298301      {
    299         delete[] buf;
    300302        return false;
    301303      }
    … …  
    311313      {
    312314        // read a new line
    313         fd.read(reinterpret_cast<Char*>(buf), stride_file);
     315        fd.read(reinterpret_cast<TChar*>(buf), stride_file);
    314316        if (fd.eof() || fd.fail() )
    315317        {
    316           delete[] buf;
    317318          return false;
    318319        }
    … …  
    381382    }
    382383  }
    383   delete[] buf;
    384384  return true;
    385385}
    … …  
    419419  const UInt height_file      = height444>>csy_file;
    420420
    421   UChar  *buf   = new UChar[stride_file];
     421  std::vector<UChar> bufVec(stride_file);
     422  UChar *buf=&(bufVec[0]);
    422423
    423424  if (compID!=COMPONENT_Y && (fileFormat==CHROMA_400 || srcFormat==CHROMA_400))
    … …  
    447448        }
    448449
    449         fd.write(reinterpret_cast<Char*>(buf), stride_file);
     450        fd.write(reinterpret_cast<const TChar*>(buf), stride_file);
    450451        if (fd.eof() || fd.fail() )
    451452        {
    452           delete[] buf;
    453453          return false;
    454454        }
    … …  
    506506        }
    507507
    508         fd.write(reinterpret_cast<Char*>(buf), stride_file);
     508        fd.write(reinterpret_cast<const TChar*>(buf), stride_file);
    509509        if (fd.eof() || fd.fail() )
    510510        {
    511           delete[] buf;
    512511          return false;
    513512        }
    … …  
    521520    }
    522521  }
    523   delete[] buf;
    524522  return true;
    525523}
    … …  
    544542  const UInt height_file      = height444>>csy_file;
    545543
    546   UChar  *buf   = new UChar[stride_file * 2];
     544  std::vector<UChar> bufVec(stride_file * 2);
     545  UChar *buf=&(bufVec[0]);
    547546
    548547  if (compID!=COMPONENT_Y && (fileFormat==CHROMA_400 || srcFormat==CHROMA_400))
    … …  
    577576        }
    578577
    579         fd.write(reinterpret_cast<Char*>(buf), (stride_file * 2));
     578        fd.write(reinterpret_cast<const TChar*>(buf), (stride_file * 2));
    580579        if (fd.eof() || fd.fail() )
    581580        {
    582           delete[] buf;
    583581          return false;
    584582        }
    … …  
    642640        }
    643641
    644         fd.write(reinterpret_cast<Char*>(buf), (stride_file * 2));
     642        fd.write(reinterpret_cast<const TChar*>(buf), (stride_file * 2));
    645643        if (fd.eof() || fd.fail() )
    646644        {
    647           delete[] buf;
    648645          return false;
    649646        }
    … …  
    658655    }
    659656  }
    660   delete[] buf;
    661657  return true;
    662658}
    … …  
    760756  if (ipCSC!=IPCOLOURSPACE_UNCHANGED)
    761757  {
    762     cPicYuvCSCd.create(pPicYuvUser->getWidth(COMPONENT_Y), pPicYuvUser->getHeight(COMPONENT_Y), pPicYuvUser->getChromaFormat(), pPicYuvUser->getWidth(COMPONENT_Y), pPicYuvUser->getHeight(COMPONENT_Y), 0, false);
     758    cPicYuvCSCd.createWithoutCUInfo(pPicYuvUser->getWidth(COMPONENT_Y), pPicYuvUser->getHeight(COMPONENT_Y), pPicYuvUser->getChromaFormat() );
    763759    ColourSpaceConvert(*pPicYuvUser, cPicYuvCSCd, ipCSC, false);
    764760  }
    … …  
    766762
    767763  // compute actual YUV frame size excluding padding size
    768   const Int   iStride444 = pPicYuv->getStride(COMPONENT_Y);
    769   const UInt width444  = pPicYuv->getWidth(COMPONENT_Y) - confLeft - confRight;
    770   const UInt height444 = pPicYuv->getHeight(COMPONENT_Y) -  confTop  - confBottom;
    771764  Bool is16bit = false;
    772765  Bool nonZeroBitDepthShift=false;
    773 
    774   if ((width444 == 0) || (height444 == 0))
    775   {
    776     printf ("\nWarning: writing %d x %d luma sample output picture!", width444, height444);
    777   }
    778766
    779767  for(UInt ch=0; ch<MAX_NUM_CHANNEL_TYPE; ch++)
    … …  
    799787  {
    800788    dstPicYuv = new TComPicYuv;
    801     dstPicYuv->create( pPicYuv->getWidth(COMPONENT_Y), pPicYuv->getHeight(COMPONENT_Y), pPicYuv->getChromaFormat(), pPicYuv->getWidth(COMPONENT_Y), pPicYuv->getHeight(COMPONENT_Y), 0, false );
    802     pPicYuv->copyToPic(dstPicYuv);
     789    dstPicYuv->createWithoutCUInfo( pPicYuv->getWidth(COMPONENT_Y), pPicYuv->getHeight(COMPONENT_Y), pPicYuv->getChromaFormat() );
    803790
    804791    for(UInt comp=0; comp<dstPicYuv->getNumberValidComponents(); comp++)
    … …  
    810797      const Pel maxval = b709Compliance? ((0xff << (m_MSBExtendedBitDepth[ch] - 8)) -1) : (1 << m_MSBExtendedBitDepth[ch]) - 1;
    811798
     799      copyPlane(*pPicYuv, compID, *dstPicYuv, compID);
    812800      scalePlane(dstPicYuv->getAddr(compID), dstPicYuv->getStride(compID), dstPicYuv->getWidth(compID), dstPicYuv->getHeight(compID), -m_bitdepthShift[ch], minval, maxval);
    813801    }
    … …  
    817805    dstPicYuv = pPicYuv;
    818806  }
    819 #if NH_3D
    820   for(UInt comp=0; retval && comp< ::getNumberValidComponents(format); comp++)
    821 #else
     807
     808  const Int  stride444 = dstPicYuv->getStride(COMPONENT_Y);
     809  const UInt width444  = dstPicYuv->getWidth(COMPONENT_Y) - confLeft - confRight;
     810  const UInt height444 = dstPicYuv->getHeight(COMPONENT_Y) -  confTop  - confBottom;
     811
     812  if ((width444 == 0) || (height444 == 0))
     813  {
     814    printf ("\nWarning: writing %d x %d luma sample output picture!", width444, height444);
     815  }
     816
    822817  for(UInt comp=0; retval && comp<dstPicYuv->getNumberValidComponents(); comp++)
    823 #endif
    824818  {
    825819    const ComponentID compID = ComponentID(comp);
    826820    const ChannelType ch=toChannelType(compID);
    827     const UInt csx = pPicYuv->getComponentScaleX(compID);
    828     const UInt csy = pPicYuv->getComponentScaleY(compID);
    829     const Int planeOffset =  (confLeft>>csx) + (confTop>>csy) * pPicYuv->getStride(compID);
    830     if (! writePlane(m_cHandle, dstPicYuv->getAddr(compID) + planeOffset, is16bit, iStride444, width444, height444, compID, dstPicYuv->getChromaFormat(), format, m_fileBitdepth[ch]))
     821    const UInt csx = dstPicYuv->getComponentScaleX(compID);
     822    const UInt csy = dstPicYuv->getComponentScaleY(compID);
     823    const Int planeOffset =  (confLeft>>csx) + (confTop>>csy) * dstPicYuv->getStride(compID);
     824    if (! writePlane(m_cHandle, dstPicYuv->getAddr(compID) + planeOffset, is16bit, stride444, width444, height444, compID, dstPicYuv->getChromaFormat(), format, m_fileBitdepth[ch]))
    831825    {
    832826      retval=false;
    … …  
    852846  if (ipCSC!=IPCOLOURSPACE_UNCHANGED)
    853847  {
    854     cPicYuvTopCSCd   .create(pPicYuvUserTop   ->getWidth(COMPONENT_Y), pPicYuvUserTop   ->getHeight(COMPONENT_Y), pPicYuvUserTop   ->getChromaFormat(), pPicYuvUserTop   ->getWidth(COMPONENT_Y), pPicYuvUserTop   ->getHeight(COMPONENT_Y), 0, false);
    855     cPicYuvBottomCSCd.create(pPicYuvUserBottom->getWidth(COMPONENT_Y), pPicYuvUserBottom->getHeight(COMPONENT_Y), pPicYuvUserBottom->getChromaFormat(), pPicYuvUserBottom->getWidth(COMPONENT_Y), pPicYuvUserBottom->getHeight(COMPONENT_Y), 0, false);
     848    cPicYuvTopCSCd   .createWithoutCUInfo(pPicYuvUserTop   ->getWidth(COMPONENT_Y), pPicYuvUserTop   ->getHeight(COMPONENT_Y), pPicYuvUserTop   ->getChromaFormat() );
     849    cPicYuvBottomCSCd.createWithoutCUInfo(pPicYuvUserBottom->getWidth(COMPONENT_Y), pPicYuvUserBottom->getHeight(COMPONENT_Y), pPicYuvUserBottom->getChromaFormat() );
    856850    ColourSpaceConvert(*pPicYuvUserTop,    cPicYuvTopCSCd,    ipCSC, false);
    857851    ColourSpaceConvert(*pPicYuvUserBottom, cPicYuvBottomCSCd, ipCSC, false);
    … …  
    892886    {
    893887      dstPicYuv = new TComPicYuv;
    894       dstPicYuv->create( pPicYuv->getWidth(COMPONENT_Y), pPicYuv->getHeight(COMPONENT_Y), pPicYuv->getChromaFormat(), pPicYuv->getWidth(COMPONENT_Y), pPicYuv->getHeight(COMPONENT_Y), 0, false );
    895       pPicYuv->copyToPic(dstPicYuv);
     888      dstPicYuv->createWithoutCUInfo( pPicYuv->getWidth(COMPONENT_Y), pPicYuv->getHeight(COMPONENT_Y), pPicYuv->getChromaFormat() );
    896889
    897890      for(UInt comp=0; comp<dstPicYuv->getNumberValidComponents(); comp++)
    … …  
    903896        const Pel maxval = b709Compliance? ((0xff << (m_MSBExtendedBitDepth[ch] - 8)) -1) : (1 << m_MSBExtendedBitDepth[ch]) - 1;
    904897
     898        copyPlane(*pPicYuv, compID, *dstPicYuv, compID);
    905899        scalePlane(dstPicYuv->getAddr(compID), dstPicYuv->getStride(compID), dstPicYuv->getWidth(compID), dstPicYuv->getHeight(compID), -m_bitdepthShift[ch], minval, maxval);
    906900      }
    … …  
    916910  assert(dstPicYuvTop->getNumberValidComponents() == dstPicYuvBottom->getNumberValidComponents());
    917911  assert(dstPicYuvTop->getChromaFormat()          == dstPicYuvBottom->getChromaFormat()         );
    918   assert(dstPicYuvTop->getWidth(COMPONENT_Y)      == dstPicYuvBottom->getWidth(COMPONENT_Y)    );
    919   assert(dstPicYuvTop->getHeight(COMPONENT_Y)     == dstPicYuvBottom->getHeight(COMPONENT_Y)    );
    920   assert(dstPicYuvTop->getStride(COMPONENT_Y)     == dstPicYuvBottom->getStride(COMPONENT_Y)    );
    921912
    922913  for(UInt comp=0; retval && comp<dstPicYuvTop->getNumberValidComponents(); comp++)
    … …  
    925916    const ChannelType ch=toChannelType(compID);
    926917
     918    assert(dstPicYuvTop->getWidth          (compID) == dstPicYuvBottom->getWidth          (compID));
     919    assert(dstPicYuvTop->getHeight         (compID) == dstPicYuvBottom->getHeight         (compID));
    927920    assert(dstPicYuvTop->getComponentScaleX(compID) == dstPicYuvBottom->getComponentScaleX(compID));
    928921    assert(dstPicYuvTop->getComponentScaleY(compID) == dstPicYuvBottom->getComponentScaleY(compID));

  • branches/HTM-15.2-dev/source/Lib/TLibVideoIO/TVideoIOYuv.h

    r1313 r1360  
    6464  virtual ~TVideoIOYuv()  {}
    6565
    66   Void  open  ( Char* pchFile, Bool bWriteMode, const Int fileBitDepth[MAX_NUM_CHANNEL_TYPE], const Int MSBExtendedBitDepth[MAX_NUM_CHANNEL_TYPE], const Int internalBitDepth[MAX_NUM_CHANNEL_TYPE] ); ///< open or create file
     66  Void  open  ( const std::string &fileName, Bool bWriteMode, const Int fileBitDepth[MAX_NUM_CHANNEL_TYPE], const Int MSBExtendedBitDepth[MAX_NUM_CHANNEL_TYPE], const Int internalBitDepth[MAX_NUM_CHANNEL_TYPE] ); ///< open or create file
    6767  Void  close ();                                           ///< close file
    6868
Note: See TracChangeset for help on using the changeset viewer.