Changeset 133 in SHVCSoftware for branches/SHM-2.0-dev/source/Lib/TLibEncoder


Ignore:
Timestamp:
28 Apr 2013, 08:49:16 (12 years ago)
Author:
seregin
Message:

update to HM10.1

Location:
branches/SHM-2.0-dev/source/Lib/TLibEncoder
Files:
16 edited

Legend:

Unmodified
Added
Removed

  • branches/SHM-2.0-dev/source/Lib/TLibEncoder/SEIwrite.cpp

    r125 r133  
    8484    fprintf( g_hTrace, "=========== Decoding Unit Information SEI message ===========\n");
    8585    break;
     86#if J0149_TONE_MAPPING_SEI
     87  case SEI::TONE_MAPPING_INFO:
     88    fprintf( g_hTrace, "=========== Tone Mapping Info SEI message ===========\n");
     89    break;
     90#endif
     91#if L0208_SOP_DESCRIPTION_SEI
     92  case SEI::SOP_DESCRIPTION:
     93    fprintf( g_hTrace, "=========== SOP Description SEI message ===========\n");
     94    break;
     95#endif
     96#if K0180_SCALABLE_NESTING_SEI
     97  case SEI::SCALABLE_NESTING:
     98    fprintf( g_hTrace, "=========== Scalable Nesting SEI message ===========\n");
     99    break;
     100#endif
    86101  default:
    87102    fprintf( g_hTrace, "=========== Unknown SEI message ===========\n");
    … …  
    91106#endif
    92107
     108#if K0180_SCALABLE_NESTING_SEI
     109void SEIWriter::xWriteSEIpayloadData(TComBitIf& bs, const SEI& sei, TComSPS *sps)
     110#else
    93111void SEIWriter::xWriteSEIpayloadData(const SEI& sei, TComSPS *sps)
     112#endif
    94113{
    95114  switch (sei.payloadType())
    … …  
    128147    xWriteSEIGradualDecodingRefreshInfo(*static_cast<const SEIGradualDecodingRefreshInfo*>(&sei));
    129148    break;
     149#if J0149_TONE_MAPPING_SEI
     150  case SEI::TONE_MAPPING_INFO:
     151    xWriteSEIToneMappingInfo(*static_cast<const SEIToneMappingInfo*>(&sei));
     152    break;
     153#endif
     154#if L0208_SOP_DESCRIPTION_SEI
     155  case SEI::SOP_DESCRIPTION:
     156    xWriteSEISOPDescription(*static_cast<const SEISOPDescription*>(&sei));
     157    break;
     158#endif
     159#if K0180_SCALABLE_NESTING_SEI
     160  case SEI::SCALABLE_NESTING:
     161    xWriteSEIScalableNesting(bs, *static_cast<const SEIScalableNesting*>(&sei), sps);
     162    break;
     163#endif
    130164  default:
    131165    assert(!"Unhandled SEI message");
    … …  
    145179  setBitstream(&bs_count);
    146180
     181
     182#if K0180_SCALABLE_NESTING_SEI
     183
     184#if ENC_DEC_TRACE
     185  Bool traceEnable = g_HLSTraceEnable;
     186  g_HLSTraceEnable = false;
     187#endif
     188  xWriteSEIpayloadData(bs_count, sei, sps);
     189#if ENC_DEC_TRACE
     190  g_HLSTraceEnable = traceEnable;
     191#endif
     192
     193#else
     194
    147195#if ENC_DEC_TRACE
    148196  g_HLSTraceEnable = false;
    … …  
    152200  g_HLSTraceEnable = true;
    153201#endif
     202
     203#endif
     204
    154205  UInt payload_data_num_bits = bs_count.getNumberOfWrittenBits();
    155206  assert(0 == payload_data_num_bits % 8);
    … …  
    158209
    159210#if ENC_DEC_TRACE
     211#if K0180_SCALABLE_NESTING_SEI
     212  if (g_HLSTraceEnable)
     213#endif
    160214  xTraceSEIHeader();
    161215#endif
    … …  
    177231  /* payloadData */
    178232#if ENC_DEC_TRACE
     233#if K0180_SCALABLE_NESTING_SEI
     234  if (g_HLSTraceEnable)
     235#endif
    179236  xTraceSEIMessageType(sei.payloadType());
    180237#endif
    181238
     239#if K0180_SCALABLE_NESTING_SEI
     240  xWriteSEIpayloadData(bs, sei, sps);
     241#else
    182242  xWriteSEIpayloadData(sei, sps);
     243#endif
    183244}
    184245
    … …  
    421482  xWriteByteAlign();
    422483}
     484
     485#if J0149_TONE_MAPPING_SEI
     486Void SEIWriter::xWriteSEIToneMappingInfo(const SEIToneMappingInfo& sei)
     487{
     488  Int i;
     489  WRITE_UVLC( sei.m_toneMapId,                    "tone_map_id" );
     490  WRITE_FLAG( sei.m_toneMapCancelFlag,            "tone_map_cancel_flag" );
     491  if( !sei.m_toneMapCancelFlag )
     492  {
     493    WRITE_FLAG( sei.m_toneMapPersistenceFlag,     "tone_map_persistence_flag" );
     494    WRITE_CODE( sei.m_codedDataBitDepth,    8,    "coded_data_bit_depth" );
     495    WRITE_CODE( sei.m_targetBitDepth,       8,    "target_bit_depth" );
     496    WRITE_UVLC( sei.m_modelId,                    "model_id" );
     497    switch(sei.m_modelId)
     498    {
     499    case 0:
     500      {
     501        WRITE_CODE( sei.m_minValue,  32,        "min_value" );
     502        WRITE_CODE( sei.m_maxValue, 32,         "max_value" );
     503        break;
     504      }
     505    case 1:
     506      {
     507        WRITE_CODE( sei.m_sigmoidMidpoint, 32,  "sigmoid_midpoint" );
     508        WRITE_CODE( sei.m_sigmoidWidth,    32,  "sigmoid_width"    );
     509        break;
     510      }
     511    case 2:
     512      {
     513        UInt num = 1u << sei.m_targetBitDepth;
     514        for(i = 0; i < num; i++)
     515        {
     516          WRITE_CODE( sei.m_startOfCodedInterval[i], (( sei.m_codedDataBitDepth + 7 ) >> 3 ) << 3,  "start_of_coded_interval" );
     517        }
     518        break;
     519      }
     520    case 3:
     521      {
     522        WRITE_CODE( sei.m_numPivots, 16,          "num_pivots" );
     523        for(i = 0; i < sei.m_numPivots; i++ )
     524        {
     525          WRITE_CODE( sei.m_codedPivotValue[i], (( sei.m_codedDataBitDepth + 7 ) >> 3 ) << 3,       "coded_pivot_value" );
     526          WRITE_CODE( sei.m_targetPivotValue[i], (( sei.m_targetBitDepth + 7 ) >> 3 ) << 3,         "target_pivot_value");
     527        }
     528        break;
     529      }
     530    case 4:
     531      {
     532        WRITE_CODE( sei.m_cameraIsoSpeedIdc,    8,    "camera_iso_speed_idc" );
     533        if( sei.m_cameraIsoSpeedIdc == 255) //Extended_ISO
     534        {
     535          WRITE_CODE( sei.m_cameraIsoSpeedValue,    32,    "camera_iso_speed_value" );
     536        }
     537        WRITE_FLAG( sei.m_exposureCompensationValueSignFlag,           "exposure_compensation_value_sign_flag" );
     538        WRITE_CODE( sei.m_exposureCompensationValueNumerator,     16,  "exposure_compensation_value_numerator" );
     539        WRITE_CODE( sei.m_exposureCompensationValueDenomIdc,      16,  "exposure_compensation_value_denom_idc" );
     540        WRITE_CODE( sei.m_refScreenLuminanceWhite,                32,  "ref_screen_luminance_white" );
     541        WRITE_CODE( sei.m_extendedRangeWhiteLevel,                32,  "extended_range_white_level" );
     542        WRITE_CODE( sei.m_nominalBlackLevelLumaCodeValue,         16,  "nominal_black_level_luma_code_value" );
     543        WRITE_CODE( sei.m_nominalWhiteLevelLumaCodeValue,         16,  "nominal_white_level_luma_code_value" );
     544        WRITE_CODE( sei.m_extendedWhiteLevelLumaCodeValue,        16,  "extended_white_level_luma_code_value" );
     545        break;
     546      }
     547    default:
     548      {
     549        assert(!"Undefined SEIToneMapModelId");
     550        break;
     551      }
     552    }//switch m_modelId
     553  }//if(!sei.m_toneMapCancelFlag)
     554
     555  xWriteByteAlign();
     556}
     557#endif
     558
    423559Void SEIWriter::xWriteSEIDisplayOrientation(const SEIDisplayOrientation &sei)
    424560{
    … …  
    455591}
    456592
     593#if L0208_SOP_DESCRIPTION_SEI
     594Void SEIWriter::xWriteSEISOPDescription(const SEISOPDescription& sei)
     595{
     596  WRITE_UVLC( sei.m_sopSeqParameterSetId,           "sop_seq_parameter_set_id"               );
     597  WRITE_UVLC( sei.m_numPicsInSopMinus1,             "num_pics_in_sop_minus1"               );
     598  for (UInt i = 0; i <= sei.m_numPicsInSopMinus1; i++)
     599  {
     600    WRITE_CODE( sei.m_sopDescVclNaluType[i], 6, "sop_desc_vcl_nalu_type" );
     601    WRITE_CODE( sei.m_sopDescTemporalId[i],  3, "sop_desc_temporal_id" );
     602    if (sei.m_sopDescVclNaluType[i] != NAL_UNIT_CODED_SLICE_IDR_W_RADL && sei.m_sopDescVclNaluType[i] != NAL_UNIT_CODED_SLICE_IDR_N_LP)
     603    {
     604      WRITE_UVLC( sei.m_sopDescStRpsIdx[i],           "sop_desc_st_rps_idx"               );
     605    }
     606    if (i > 0)
     607    {
     608      WRITE_SVLC( sei.m_sopDescPocDelta[i],           "sop_desc_poc_delta"               );
     609    }
     610  }
     611
     612  xWriteByteAlign();
     613}
     614#endif
     615
     616#if K0180_SCALABLE_NESTING_SEI
     617Void SEIWriter::xWriteSEIScalableNesting(TComBitIf& bs, const SEIScalableNesting& sei, TComSPS *sps)
     618{
     619  WRITE_FLAG( sei.m_bitStreamSubsetFlag,             "bitstream_subset_flag"         );
     620  WRITE_FLAG( sei.m_nestingOpFlag,                   "nesting_op_flag      "         );
     621  if (sei.m_nestingOpFlag)
     622  {
     623    WRITE_FLAG( sei.m_defaultOpFlag,                 "default_op_flag"               );
     624    WRITE_UVLC( sei.m_nestingNumOpsMinus1,           "nesting_num_ops"               );
     625    for (UInt i = (sei.m_defaultOpFlag ? 1 : 0); i <= sei.m_nestingNumOpsMinus1; i++)
     626    {
     627      WRITE_CODE( sei.m_nestingNoOpMaxTemporalIdPlus1, 3, "nesting_no_op_max_temporal_id" );
     628      WRITE_CODE( sei.m_nestingMaxTemporalIdPlus1[i], 3,  "nesting_max_temporal_id"       );
     629      WRITE_UVLC( sei.m_nestingOpIdx[i],                  "nesting_op_idx"                );
     630    }
     631  }
     632  else
     633  {
     634    WRITE_FLAG( sei.m_allLayersFlag,                      "all_layers_flag"               );
     635    if (!sei.m_allLayersFlag)
     636    {
     637      WRITE_CODE( sei.m_nestingNoOpMaxTemporalIdPlus1, 3, "nesting_no_op_max_temporal_id" );
     638      WRITE_UVLC( sei.m_nestingNumLayersMinus1,           "nesting_num_layers"            );
     639      for (UInt i = 0; i <= sei.m_nestingNumLayersMinus1; i++)
     640      {
     641        WRITE_CODE( sei.m_nestingLayerId[i], 6,           "nesting_layer_id"              );
     642      }
     643    }
     644  }
     645 
     646  // byte alignment
     647  while ( m_pcBitIf->getNumberOfWrittenBits() % 8 != 0 )
     648  {
     649    WRITE_FLAG( 0, "nesting_zero_bit" );
     650  }
     651
     652  // write nested SEI messages
     653  for (SEIMessages::const_iterator it = sei.m_nestedSEIs.begin(); it != sei.m_nestedSEIs.end(); it++)
     654  {
     655    writeSEImessage(bs, *(*it), sps);
     656  }
     657}
     658#endif
     659
    457660Void SEIWriter::xWriteByteAlign()
    458661{

  • branches/SHM-2.0-dev/source/Lib/TLibEncoder/SEIwrite.h

    r125 r133  
    5050
    5151protected:
     52#if K0180_SCALABLE_NESTING_SEI
     53  Void xWriteSEIpayloadData(TComBitIf& bs, const SEI& sei, TComSPS *sps);
     54#else
    5255  Void xWriteSEIpayloadData(const SEI& sei, TComSPS *sps);
     56#endif
    5357  Void xWriteSEIuserDataUnregistered(const SEIuserDataUnregistered &sei);
    5458  Void xWriteSEIActiveParameterSets(const SEIActiveParameterSets& sei);
    … …  
    6367  Void xWriteSEITemporalLevel0Index(const SEITemporalLevel0Index &sei);
    6468  Void xWriteSEIGradualDecodingRefreshInfo(const SEIGradualDecodingRefreshInfo &sei);
     69#if J0149_TONE_MAPPING_SEI
     70  Void xWriteSEIToneMappingInfo(const SEIToneMappingInfo& sei);
     71#endif
     72#if L0208_SOP_DESCRIPTION_SEI
     73  Void xWriteSEISOPDescription(const SEISOPDescription& sei);
     74#endif
     75#if K0180_SCALABLE_NESTING_SEI
     76  Void xWriteSEIScalableNesting(TComBitIf& bs, const SEIScalableNesting& sei, TComSPS *sps);
     77#endif
    6578  Void xWriteByteAlign();
    6679};

  • branches/SHM-2.0-dev/source/Lib/TLibEncoder/TEncCavlc.cpp

    r125 r133  
    285285  WRITE_FLAG(pcVUI->getNeutralChromaIndicationFlag(),           "neutral_chroma_indication_flag");
    286286  WRITE_FLAG(pcVUI->getFieldSeqFlag(),                          "field_seq_flag");
    287   assert(pcVUI->getFieldSeqFlag() == 0);                        // not currently supported
    288287  WRITE_FLAG(pcVUI->getFrameFieldInfoPresentFlag(),             "frame_field_info_present_flag");
    289288
    … …  
    474473  for(UInt i=0; i <= pcSPS->getMaxTLayers()-1; i++)
    475474  {
     475#if L0323_DPB
     476    WRITE_UVLC( pcSPS->getMaxDecPicBuffering(i) - 1,       "sps_max_dec_pic_buffering_minus1[i]" );
     477#else
    476478    WRITE_UVLC( pcSPS->getMaxDecPicBuffering(i),           "sps_max_dec_pic_buffering[i]" );
     479#endif
    477480    WRITE_UVLC( pcSPS->getNumReorderPics(i),               "sps_num_reorder_pics[i]" );
    478481    WRITE_UVLC( pcSPS->getMaxLatencyIncrease(i),           "sps_max_latency_increase[i]" );
    … …  
    484487  assert( pcSPS->getMaxCUWidth() == pcSPS->getMaxCUHeight() );
    485488 
    486   UInt MinCUSize = pcSPS->getMaxCUWidth() >> ( pcSPS->getMaxCUDepth()-g_uiAddCUDepth );
    487   UInt log2MinCUSize = 0;
    488   while(MinCUSize > 1)
    489   {
    490     MinCUSize >>= 1;
    491     log2MinCUSize++;
    492   }
    493 
    494   WRITE_UVLC( log2MinCUSize - 3,                                                     "log2_min_coding_block_size_minus3" );
    495   WRITE_UVLC( pcSPS->getMaxCUDepth()-g_uiAddCUDepth,                                 "log2_diff_max_min_coding_block_size" );
     489  WRITE_UVLC( pcSPS->getLog2MinCodingBlockSize() - 3,                                "log2_min_coding_block_size_minus3" );
     490  WRITE_UVLC( pcSPS->getLog2DiffMaxMinCodingBlockSize(),                             "log2_diff_max_min_coding_block_size" );
    496491  WRITE_UVLC( pcSPS->getQuadtreeTULog2MinSize() - 2,                                 "log2_min_transform_block_size_minus2" );
    497492  WRITE_UVLC( pcSPS->getQuadtreeTULog2MaxSize() - pcSPS->getQuadtreeTULog2MinSize(), "log2_diff_max_min_transform_block_size" );
    … …  
    583578  for(UInt i=0; i <= pcVPS->getMaxTLayers()-1; i++)
    584579  {
     580#if L0323_DPB
     581    WRITE_UVLC( pcVPS->getMaxDecPicBuffering(i) - 1,       "vps_max_dec_pic_buffering_minus1[i]" );
     582#else
    585583    WRITE_UVLC( pcVPS->getMaxDecPicBuffering(i),           "vps_max_dec_pic_buffering[i]" );
     584#endif
    586585    WRITE_UVLC( pcVPS->getNumReorderPics(i),               "vps_num_reorder_pics[i]" );
    587586    WRITE_UVLC( pcVPS->getMaxLatencyIncrease(i),           "vps_max_latency_increase[i]" );
    … …  
    810809      WRITE_CODE( picOrderCntLSB, pcSlice->getSPS()->getBitsForPOC(), "pic_order_cnt_lsb");
    811810      TComReferencePictureSet* rps = pcSlice->getRPS();
     811     
     812#if FIX1071
     813      // Deal with bitstream restriction stating that:
     814      // – If the current picture is a BLA or CRA picture, the value of NumPocTotalCurr shall be equal to 0.
     815      // Ideally this process should not be repeated for each slice in a picture
     816      TComReferencePictureSet altRps;
     817      Bool useAltRps = false;
     818      if (pcSlice->getRapPicFlag())
     819      {
     820        for (Int picIdx = 0; !useAltRps && picIdx < rps->getNumberOfPictures(); picIdx++)
     821        {
     822          useAltRps = rps->getUsed(picIdx);
     823        }
     824        if (useAltRps)
     825        {
     826          memcpy(&altRps, rps, sizeof(TComReferencePictureSet));
     827          rps = &altRps;
     828          for (Int picIdx = 0; picIdx < rps->getNumberOfPictures(); picIdx++)
     829          {
     830            rps->setUsed(picIdx, false);
     831          }
     832        }
     833      }
     834
     835      if(pcSlice->getRPSidx() < 0 || useAltRps)
     836#else
    812837      if(pcSlice->getRPSidx() < 0)
     838#endif
    813839      {
    814840        WRITE_FLAG( 0, "short_term_ref_pic_set_sps_flag");
    … …  
    13891415// ====================================================================================================================
    13901416
    1391 
    1392 /** Write PCM alignment bits.
    1393  * \returns Void
    1394  */
    1395 Void  TEncCavlc::xWritePCMAlignZero    ()
    1396 {
    1397   m_pcBitIf->writeAlignZero();
    1398 }
    1399 
    1400 Void TEncCavlc::xWriteUnaryMaxSymbol( UInt uiSymbol, UInt uiMaxSymbol )
    1401 {
    1402   if (uiMaxSymbol == 0)
    1403   {
    1404     return;
    1405   }
    1406   xWriteFlag( uiSymbol ? 1 : 0 );
    1407   if ( uiSymbol == 0 )
    1408   {
    1409     return;
    1410   }
    1411  
    1412   Bool bCodeLast = ( uiMaxSymbol > uiSymbol );
    1413  
    1414   while( --uiSymbol )
    1415   {
    1416     xWriteFlag( 1 );
    1417   }
    1418   if( bCodeLast )
    1419   {
    1420     xWriteFlag( 0 );
    1421   }
    1422   return;
    1423 }
    1424 
    1425 Void TEncCavlc::xWriteExGolombLevel( UInt uiSymbol )
    1426 {
    1427   if( uiSymbol )
    1428   {
    1429     xWriteFlag( 1 );
    1430     UInt uiCount = 0;
    1431     Bool bNoExGo = (uiSymbol < 13);
    1432    
    1433     while( --uiSymbol && ++uiCount < 13 )
    1434     {
    1435       xWriteFlag( 1 );
    1436     }
    1437     if( bNoExGo )
    1438     {
    1439       xWriteFlag( 0 );
    1440     }
    1441     else
    1442     {
    1443       xWriteEpExGolomb( uiSymbol, 0 );
    1444     }
    1445   }
    1446   else
    1447   {
    1448     xWriteFlag( 0 );
    1449   }
    1450   return;
    1451 }
    1452 
    1453 Void TEncCavlc::xWriteEpExGolomb( UInt uiSymbol, UInt uiCount )
    1454 {
    1455   while( uiSymbol >= (UInt)(1<<uiCount) )
    1456   {
    1457     xWriteFlag( 1 );
    1458     uiSymbol -= 1<<uiCount;
    1459     uiCount  ++;
    1460   }
    1461   xWriteFlag( 0 );
    1462   while( uiCount-- )
    1463   {
    1464     xWriteFlag( (uiSymbol>>uiCount) & 1 );
    1465   }
    1466   return;
    1467 }
    1468 
    14691417/** code explicit wp tables
    14701418 * \param TComSlice* pcSlice

  • branches/SHM-2.0-dev/source/Lib/TLibEncoder/TEncCavlc.h

    r125 r133  
    6868  TComSlice*    m_pcSlice;
    6969  UInt          m_uiCoeffCost;
    70 
    71   Void  xWritePCMAlignZero    ();
    72   Void  xWriteEpExGolomb      ( UInt uiSymbol, UInt uiCount );
    73   Void  xWriteExGolombLevel    ( UInt uiSymbol );
    74   Void  xWriteUnaryMaxSymbol  ( UInt uiSymbol, UInt uiMaxSymbol );
    7570
    7671  Void codeShortTermRefPicSet              ( TComSPS* pcSPS, TComReferencePictureSet* pcRPS, Bool calledFromSliceHeader, Int idx );

  • branches/SHM-2.0-dev/source/Lib/TLibEncoder/TEncCfg.h

    r125 r133  
    158158  Int       m_loopFilterTcOffsetDiv2;
    159159  Bool      m_DeblockingFilterControlPresent;
     160#if L0386_DB_METRIC
     161  Bool      m_DeblockingFilterMetric;
     162#endif
    160163  Bool      m_bUseSAO;
    161164  Int       m_maxNumOffsetsPerPic;
    … …  
    188191  Bool      m_bUseASR;
    189192  Bool      m_bUseHADME;
     193#if !L0034_COMBINED_LIST_CLEANUP
    190194  Bool      m_bUseLComb;
     195#endif
    191196  Bool      m_useRDOQ;
    192197  Bool      m_useRDOQTS;
    … …  
    234239  Int       m_pictureTimingSEIEnabled;
    235240  Int       m_recoveryPointSEIEnabled;
     241#if J0149_TONE_MAPPING_SEI
     242  Bool      m_toneMappingInfoSEIEnabled;
     243  Int       m_toneMapId;
     244  Bool      m_toneMapCancelFlag;
     245  Bool      m_toneMapPersistenceFlag;
     246  Int       m_codedDataBitDepth;
     247  Int       m_targetBitDepth;
     248  Int       m_modelId;
     249  Int       m_minValue;
     250  Int       m_maxValue;
     251  Int       m_sigmoidMidpoint;
     252  Int       m_sigmoidWidth;
     253  Int       m_numPivots;
     254  Int       m_cameraIsoSpeedIdc;
     255  Int       m_cameraIsoSpeedValue;
     256  Int       m_exposureCompensationValueSignFlag;
     257  Int       m_exposureCompensationValueNumerator;
     258  Int       m_exposureCompensationValueDenomIdc;
     259  Int       m_refScreenLuminanceWhite;
     260  Int       m_extendedRangeWhiteLevel;
     261  Int       m_nominalBlackLevelLumaCodeValue;
     262  Int       m_nominalWhiteLevelLumaCodeValue;
     263  Int       m_extendedWhiteLevelLumaCodeValue;
     264  Int*      m_startOfCodedInterval;
     265  Int*      m_codedPivotValue;
     266  Int*      m_targetPivotValue;
     267#endif
    236268  Int       m_framePackingSEIEnabled;
    237269  Int       m_framePackingSEIType;
    … …  
    243275  Int       m_gradualDecodingRefreshInfoEnabled;
    244276  Int       m_decodingUnitInfoSEIEnabled;
     277#if L0208_SOP_DESCRIPTION_SEI
     278  Int       m_SOPDescriptionSEIEnabled;
     279#endif
     280#if K0180_SCALABLE_NESTING_SEI
     281  Int       m_scalableNestingSEIEnabled;
     282#endif
    245283  //====== Weighted Prediction ========
    246284  Bool      m_useWeightedPred;       //< Use of Weighting Prediction (P_SLICE)
    … …  
    379417  Void      setLoopFilterTcOffset           ( Int   i )      { m_loopFilterTcOffsetDiv2    = i; }
    380418  Void      setDeblockingFilterControlPresent ( Bool b ) { m_DeblockingFilterControlPresent = b; }
     419#if L0386_DB_METRIC
     420  Void      setDeblockingFilterMetric       ( Bool  b )      { m_DeblockingFilterMetric = b; }
     421#endif
    381422
    382423  //====== Motion search ========
    … …  
    433474  Int       getLoopFilterTcOffset           ()      { return m_loopFilterTcOffsetDiv2; }
    434475  Bool      getDeblockingFilterControlPresent()  { return  m_DeblockingFilterControlPresent; }
     476#if L0386_DB_METRIC
     477  Bool      getDeblockingFilterMetric       ()      { return m_DeblockingFilterMetric; }
     478#endif
    435479
    436480  //==== Motion search ========
    … …  
    450494  Void      setUseASR                       ( Bool  b )     { m_bUseASR     = b; }
    451495  Void      setUseHADME                     ( Bool  b )     { m_bUseHADME   = b; }
     496#if !L0034_COMBINED_LIST_CLEANUP
    452497  Void      setUseLComb                     ( Bool  b )     { m_bUseLComb   = b; }
     498#endif
    453499  Void      setUseRDOQ                      ( Bool  b )     { m_useRDOQ    = b; }
    454500  Void      setUseRDOQTS                    ( Bool  b )     { m_useRDOQTS  = b; }
    … …  
    472518  Bool      getUseASR                       ()      { return m_bUseASR;     }
    473519  Bool      getUseHADME                     ()      { return m_bUseHADME;   }
     520#if !L0034_COMBINED_LIST_CLEANUP
    474521  Bool      getUseLComb                     ()      { return m_bUseLComb;   }
     522#endif
    475523  Bool      getUseRDOQ                      ()      { return m_useRDOQ;    }
    476524  Bool      getUseRDOQTS                    ()      { return m_useRDOQTS;  }
    … …  
    569617  Void  setRecoveryPointSEIEnabled(Int b)                { m_recoveryPointSEIEnabled = b; }
    570618  Int   getRecoveryPointSEIEnabled()                     { return m_recoveryPointSEIEnabled; }
     619#if J0149_TONE_MAPPING_SEI
     620  Void  setToneMappingInfoSEIEnabled(Bool b)                 {  m_toneMappingInfoSEIEnabled = b;  }
     621  Bool  getToneMappingInfoSEIEnabled()                       {  return m_toneMappingInfoSEIEnabled;  }
     622  Void  setTMISEIToneMapId(Int b)                            {  m_toneMapId = b;  }
     623  Int   getTMISEIToneMapId()                                 {  return m_toneMapId;  }
     624  Void  setTMISEIToneMapCancelFlag(Bool b)                   {  m_toneMapCancelFlag=b;  }
     625  Bool  getTMISEIToneMapCancelFlag()                         {  return m_toneMapCancelFlag;  }
     626  Void  setTMISEIToneMapPersistenceFlag(Bool b)              {  m_toneMapPersistenceFlag = b;  }
     627  Bool   getTMISEIToneMapPersistenceFlag()                   {  return m_toneMapPersistenceFlag;  }
     628  Void  setTMISEICodedDataBitDepth(Int b)                    {  m_codedDataBitDepth = b;  }
     629  Int   getTMISEICodedDataBitDepth()                         {  return m_codedDataBitDepth;  }
     630  Void  setTMISEITargetBitDepth(Int b)                       {  m_targetBitDepth = b;  }
     631  Int   getTMISEITargetBitDepth()                            {  return m_targetBitDepth;  }
     632  Void  setTMISEIModelID(Int b)                              {  m_modelId = b;  }
     633  Int   getTMISEIModelID()                                   {  return m_modelId;  }
     634  Void  setTMISEIMinValue(Int b)                             {  m_minValue = b;  }
     635  Int   getTMISEIMinValue()                                  {  return m_minValue;  }
     636  Void  setTMISEIMaxValue(Int b)                             {  m_maxValue = b;  }
     637  Int   getTMISEIMaxValue()                                  {  return m_maxValue;  }
     638  Void  setTMISEISigmoidMidpoint(Int b)                      {  m_sigmoidMidpoint = b;  }
     639  Int   getTMISEISigmoidMidpoint()                           {  return m_sigmoidMidpoint;  }
     640  Void  setTMISEISigmoidWidth(Int b)                         {  m_sigmoidWidth = b;  }
     641  Int   getTMISEISigmoidWidth()                              {  return m_sigmoidWidth;  }
     642  Void  setTMISEIStartOfCodedInterva( Int*  p )              {  m_startOfCodedInterval = p;  }
     643  Int*  getTMISEIStartOfCodedInterva()                       {  return m_startOfCodedInterval;  }
     644  Void  setTMISEINumPivots(Int b)                            {  m_numPivots = b;  }
     645  Int   getTMISEINumPivots()                                 {  return m_numPivots;  }
     646  Void  setTMISEICodedPivotValue( Int*  p )                  {  m_codedPivotValue = p;  }
     647  Int*  getTMISEICodedPivotValue()                           {  return m_codedPivotValue;  }
     648  Void  setTMISEITargetPivotValue( Int*  p )                 {  m_targetPivotValue = p;  }
     649  Int*  getTMISEITargetPivotValue()                          {  return m_targetPivotValue;  }
     650  Void  setTMISEICameraIsoSpeedIdc(Int b)                    {  m_cameraIsoSpeedIdc = b;  }
     651  Int   getTMISEICameraIsoSpeedIdc()                         {  return m_cameraIsoSpeedIdc;  }
     652  Void  setTMISEICameraIsoSpeedValue(Int b)                  {  m_cameraIsoSpeedValue = b;  }
     653  Int   getTMISEICameraIsoSpeedValue()                       {  return m_cameraIsoSpeedValue;  }
     654  Void  setTMISEIExposureCompensationValueSignFlag(Int b)    {  m_exposureCompensationValueSignFlag = b;  }
     655  Int   getTMISEIExposureCompensationValueSignFlag()         {  return m_exposureCompensationValueSignFlag;  }
     656  Void  setTMISEIExposureCompensationValueNumerator(Int b)   {  m_exposureCompensationValueNumerator = b;  }
     657  Int   getTMISEIExposureCompensationValueNumerator()        {  return m_exposureCompensationValueNumerator;  }
     658  Void  setTMISEIExposureCompensationValueDenomIdc(Int b)    {  m_exposureCompensationValueDenomIdc =b;  }
     659  Int   getTMISEIExposureCompensationValueDenomIdc()         {  return m_exposureCompensationValueDenomIdc;  }
     660  Void  setTMISEIRefScreenLuminanceWhite(Int b)              {  m_refScreenLuminanceWhite = b;  }
     661  Int   getTMISEIRefScreenLuminanceWhite()                   {  return m_refScreenLuminanceWhite;  }
     662  Void  setTMISEIExtendedRangeWhiteLevel(Int b)              {  m_extendedRangeWhiteLevel = b;  }
     663  Int   getTMISEIExtendedRangeWhiteLevel()                   {  return m_extendedRangeWhiteLevel;  }
     664  Void  setTMISEINominalBlackLevelLumaCodeValue(Int b)       {  m_nominalBlackLevelLumaCodeValue = b;  }
     665  Int   getTMISEINominalBlackLevelLumaCodeValue()            {  return m_nominalBlackLevelLumaCodeValue;  }
     666  Void  setTMISEINominalWhiteLevelLumaCodeValue(Int b)       {  m_nominalWhiteLevelLumaCodeValue = b;  }
     667  Int   getTMISEINominalWhiteLevelLumaCodeValue()            {  return m_nominalWhiteLevelLumaCodeValue;  }
     668  Void  setTMISEIExtendedWhiteLevelLumaCodeValue(Int b)      {  m_extendedWhiteLevelLumaCodeValue =b;  }
     669  Int   getTMISEIExtendedWhiteLevelLumaCodeValue()           {  return m_extendedWhiteLevelLumaCodeValue;  }
     670#endif
    571671  Void  setFramePackingArrangementSEIEnabled(Int b)      { m_framePackingSEIEnabled = b; }
    572672  Int   getFramePackingArrangementSEIEnabled()           { return m_framePackingSEIEnabled; }
    … …  
    587687  Void  setDecodingUnitInfoSEIEnabled(Int b)                { m_decodingUnitInfoSEIEnabled = b;    }
    588688  Int   getDecodingUnitInfoSEIEnabled()                     { return m_decodingUnitInfoSEIEnabled; }
     689#if L0208_SOP_DESCRIPTION_SEI
     690  Void  setSOPDescriptionSEIEnabled(Int b)                { m_SOPDescriptionSEIEnabled = b; }
     691  Int   getSOPDescriptionSEIEnabled()                     { return m_SOPDescriptionSEIEnabled; }
     692#endif
     693#if K0180_SCALABLE_NESTING_SEI
     694  Void  setScalableNestingSEIEnabled(Int b)                { m_scalableNestingSEIEnabled = b; }
     695  Int   getScalableNestingSEIEnabled()                     { return m_scalableNestingSEIEnabled; }
     696#endif
    589697  Void      setUseWP               ( Bool b )    { m_useWeightedPred   = b;    }
    590698  Void      setWPBiPred            ( Bool b )    { m_useWeightedBiPred = b;    }

  • branches/SHM-2.0-dev/source/Lib/TLibEncoder/TEncGOP.cpp

    r125 r133  
    9696#if L0045_NON_NESTED_SEI_RESTRICTIONS
    9797  xResetNonNestedSEIPresentFlags();
     98#if K0180_SCALABLE_NESTING_SEI
     99  xResetNestedSEIPresentFlags();
     100#endif
    98101#endif
    99102#if SVC_UPSAMPLING
    … …  
    134137  m_pcSliceEncoder       = pcTEncTop->getSliceEncoder();
    135138  m_pcListPic            = pcTEncTop->getListPic(); 
     139 
    136140  m_pcEntropyCoder       = pcTEncTop->getEntropyCoder();
    137141  m_pcCavlcCoder         = pcTEncTop->getCavlcCoder();
    … …  
    210214}
    211215
     216#if J0149_TONE_MAPPING_SEI
     217SEIToneMappingInfo*  TEncGOP::xCreateSEIToneMappingInfo()
     218{
     219  SEIToneMappingInfo *seiToneMappingInfo = new SEIToneMappingInfo();
     220  seiToneMappingInfo->m_toneMapId = m_pcCfg->getTMISEIToneMapId();
     221  seiToneMappingInfo->m_toneMapCancelFlag = m_pcCfg->getTMISEIToneMapCancelFlag();
     222  seiToneMappingInfo->m_toneMapPersistenceFlag = m_pcCfg->getTMISEIToneMapPersistenceFlag();
     223
     224  seiToneMappingInfo->m_codedDataBitDepth = m_pcCfg->getTMISEICodedDataBitDepth();
     225  assert(seiToneMappingInfo->m_codedDataBitDepth >= 8 && seiToneMappingInfo->m_codedDataBitDepth <= 14);
     226  seiToneMappingInfo->m_targetBitDepth = m_pcCfg->getTMISEITargetBitDepth();
     227  assert( (seiToneMappingInfo->m_targetBitDepth >= 1 && seiToneMappingInfo->m_targetBitDepth <= 17) || (seiToneMappingInfo->m_targetBitDepth  == 255) );
     228  seiToneMappingInfo->m_modelId = m_pcCfg->getTMISEIModelID();
     229  assert(seiToneMappingInfo->m_modelId >=0 &&seiToneMappingInfo->m_modelId<=4);
     230
     231  switch( seiToneMappingInfo->m_modelId)
     232  {
     233  case 0:
     234    {
     235      seiToneMappingInfo->m_minValue = m_pcCfg->getTMISEIMinValue();
     236      seiToneMappingInfo->m_maxValue = m_pcCfg->getTMISEIMaxValue();
     237      break;
     238    }
     239  case 1:
     240    {
     241      seiToneMappingInfo->m_sigmoidMidpoint = m_pcCfg->getTMISEISigmoidMidpoint();
     242      seiToneMappingInfo->m_sigmoidWidth = m_pcCfg->getTMISEISigmoidWidth();
     243      break;
     244    }
     245  case 2:
     246    {
     247      UInt num = 1u<<(seiToneMappingInfo->m_targetBitDepth);
     248      seiToneMappingInfo->m_startOfCodedInterval.resize(num);
     249      Int* ptmp = m_pcCfg->getTMISEIStartOfCodedInterva();
     250      if(ptmp)
     251      {
     252        for(int i=0; i<num;i++)
     253        {
     254          seiToneMappingInfo->m_startOfCodedInterval[i] = ptmp[i];
     255        }
     256      }
     257      break;
     258    }
     259  case 3:
     260    {
     261      seiToneMappingInfo->m_numPivots = m_pcCfg->getTMISEINumPivots();
     262      seiToneMappingInfo->m_codedPivotValue.resize(seiToneMappingInfo->m_numPivots);
     263      seiToneMappingInfo->m_targetPivotValue.resize(seiToneMappingInfo->m_numPivots);
     264      Int* ptmpcoded = m_pcCfg->getTMISEICodedPivotValue();
     265      Int* ptmptarget = m_pcCfg->getTMISEITargetPivotValue();
     266      if(ptmpcoded&&ptmptarget)
     267      {
     268        for(int i=0; i<(seiToneMappingInfo->m_numPivots);i++)
     269        {
     270          seiToneMappingInfo->m_codedPivotValue[i]=ptmpcoded[i];
     271          seiToneMappingInfo->m_targetPivotValue[i]=ptmptarget[i];
     272         }
     273       }
     274       break;
     275     }
     276  case 4:
     277     {
     278       seiToneMappingInfo->m_cameraIsoSpeedIdc = m_pcCfg->getTMISEICameraIsoSpeedIdc();
     279       seiToneMappingInfo->m_cameraIsoSpeedValue = m_pcCfg->getTMISEICameraIsoSpeedValue();
     280       assert( seiToneMappingInfo->m_cameraIsoSpeedValue !=0 );
     281       seiToneMappingInfo->m_exposureCompensationValueSignFlag = m_pcCfg->getTMISEIExposureCompensationValueSignFlag();
     282       seiToneMappingInfo->m_exposureCompensationValueNumerator = m_pcCfg->getTMISEIExposureCompensationValueNumerator();
     283       seiToneMappingInfo->m_exposureCompensationValueDenomIdc = m_pcCfg->getTMISEIExposureCompensationValueDenomIdc();
     284       seiToneMappingInfo->m_refScreenLuminanceWhite = m_pcCfg->getTMISEIRefScreenLuminanceWhite();
     285       seiToneMappingInfo->m_extendedRangeWhiteLevel = m_pcCfg->getTMISEIExtendedRangeWhiteLevel();
     286       assert( seiToneMappingInfo->m_extendedRangeWhiteLevel >= 100 );
     287       seiToneMappingInfo->m_nominalBlackLevelLumaCodeValue = m_pcCfg->getTMISEINominalBlackLevelLumaCodeValue();
     288       seiToneMappingInfo->m_nominalWhiteLevelLumaCodeValue = m_pcCfg->getTMISEINominalWhiteLevelLumaCodeValue();
     289       assert( seiToneMappingInfo->m_nominalWhiteLevelLumaCodeValue > seiToneMappingInfo->m_nominalBlackLevelLumaCodeValue );
     290       seiToneMappingInfo->m_extendedWhiteLevelLumaCodeValue = m_pcCfg->getTMISEIExtendedWhiteLevelLumaCodeValue();
     291       assert( seiToneMappingInfo->m_extendedWhiteLevelLumaCodeValue >= seiToneMappingInfo->m_nominalWhiteLevelLumaCodeValue );
     292       break;
     293    }
     294  default:
     295    {
     296      assert(!"Undefined SEIToneMapModelId");
     297      break;
     298    }
     299  }
     300  return seiToneMappingInfo;
     301}
     302#endif
    212303Void TEncGOP::xCreateLeadingSEIMessages (/*SEIMessages seiMessages,*/ AccessUnit &accessUnit, TComSPS *sps)
    213304{
    214   OutputNALUnit nalu(NAL_UNIT_SEI);
     305  OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI);
    215306
    216307  if(m_pcCfg->getActiveParameterSetsSEIEnabled())
    … …  
    233324    SEIFramePacking *sei = xCreateSEIFramePacking ();
    234325
    235     nalu = NALUnit(NAL_UNIT_SEI);
     326    nalu = NALUnit(NAL_UNIT_PREFIX_SEI);
    236327    m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
    237328    m_seiWriter.writeSEImessage(nalu.m_Bitstream, *sei, sps);
    … …  
    244335    SEIDisplayOrientation *sei = xCreateSEIDisplayOrientation();
    245336
    246     nalu = NALUnit(NAL_UNIT_SEI);
     337    nalu = NALUnit(NAL_UNIT_PREFIX_SEI);
    247338    m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
    248339    m_seiWriter.writeSEImessage(nalu.m_Bitstream, *sei, sps);
    … …  
    251342    delete sei;
    252343  }
     344#if J0149_TONE_MAPPING_SEI
     345  if(m_pcCfg->getToneMappingInfoSEIEnabled())
     346  {
     347    SEIToneMappingInfo *sei = xCreateSEIToneMappingInfo ();
     348     
     349    nalu = NALUnit(NAL_UNIT_PREFIX_SEI);
     350    m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
     351    m_seiWriter.writeSEImessage(nalu.m_Bitstream, *sei, sps);
     352    writeRBSPTrailingBits(nalu.m_Bitstream);
     353    accessUnit.push_back(new NALUnitEBSP(nalu));
     354    delete sei;
     355  }
     356#endif
    253357}
    254358
    … …  
    276380  m_iNumPicCoded = 0;
    277381  SEIPictureTiming pictureTimingSEI;
     382#if L0208_SOP_DESCRIPTION_SEI
     383  Bool writeSOP = m_pcCfg->getSOPDescriptionSEIEnabled();
     384#endif
     385#if K0180_SCALABLE_NESTING_SEI
     386  // Initialize Scalable Nesting SEI with single layer values
     387  SEIScalableNesting scalableNestingSEI;
     388  scalableNestingSEI.m_bitStreamSubsetFlag           = 1;      // If the nested SEI messages are picture buffereing SEI mesages, picure timing SEI messages or sub-picture timing SEI messages, bitstream_subset_flag shall be equal to 1
     389  scalableNestingSEI.m_nestingOpFlag                 = 0;
     390  scalableNestingSEI.m_nestingNumOpsMinus1           = 0;      //nesting_num_ops_minus1
     391  scalableNestingSEI.m_allLayersFlag                 = 0;
     392  scalableNestingSEI.m_nestingNoOpMaxTemporalIdPlus1 = 6 + 1;  //nesting_no_op_max_temporal_id_plus1
     393  scalableNestingSEI.m_nestingNumLayersMinus1        = 1 - 1;  //nesting_num_layers_minus1
     394  scalableNestingSEI.m_nestingLayerId[0]             = 0;
     395  scalableNestingSEI.m_callerOwnsSEIs                = true;
     396#endif
    278397#if L0044_DU_DPB_OUTPUT_DELAY_HRD
    279398  Int picSptDpbOutputDuDelay = 0;
    … …  
    348467    }
    349468
    350     if( getNalUnitType(pocCurr) == NAL_UNIT_CODED_SLICE_IDR || getNalUnitType(pocCurr) == NAL_UNIT_CODED_SLICE_IDR_N_LP )
     469    if( getNalUnitType(pocCurr, m_iLastIDR) == NAL_UNIT_CODED_SLICE_IDR_W_RADL || getNalUnitType(pocCurr, m_iLastIDR) == NAL_UNIT_CODED_SLICE_IDR_N_LP )
    351470    {
    352471      m_iLastIDR = pocCurr;
    … …  
    411530    }
    412531    // Set the nal unit type
    413     pcSlice->setNalUnitType(getNalUnitType(pocCurr));
     532    pcSlice->setNalUnitType(getNalUnitType(pocCurr, m_iLastIDR));
    414533#if IDR_ALIGNMENT
    415534    if (m_layerId > 0)
    … …  
    424543    {
    425544#if IDR_ALIGNMENT
    426       if( pcSlice->getBaseColPic()->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR )
    427       {
    428         pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_IDR);
     545      if( pcSlice->getBaseColPic()->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL || pcSlice->getBaseColPic()->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP )
     546      {
     547        pcSlice->setNalUnitType(pcSlice->getBaseColPic()->getSlice(0)->getNalUnitType());
    429548      }
    430549      else
    … …  
    434553    if( m_layerId > 0 && !m_pcEncTop->getElRapSliceTypeB() )
    435554    {
    436       if( (pcSlice->getNalUnitType() >= NAL_UNIT_CODED_SLICE_BLA) &&
     555      if( (pcSlice->getNalUnitType() >= NAL_UNIT_CODED_SLICE_BLA_W_LP) &&
    437556          (pcSlice->getNalUnitType() <= NAL_UNIT_CODED_SLICE_CRA) &&
    438557           pcSlice->getSliceType() == B_SLICE )
    … …  
    442561    }
    443562#endif
    444     if(pcSlice->getNalUnitType()==NAL_UNIT_CODED_SLICE_TRAIL_R)
    445     {
    446       if(pcSlice->getTemporalLayerNonReferenceFlag())
     563    if(pcSlice->getTemporalLayerNonReferenceFlag())
     564    {
     565      if(pcSlice->getNalUnitType()==NAL_UNIT_CODED_SLICE_TRAIL_R)
    447566      {
    448567        pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_TRAIL_N);
     568    }
     569      if(pcSlice->getNalUnitType()==NAL_UNIT_CODED_SLICE_RADL_R)
     570      {
     571        pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_RADL_N);
     572      }
     573      if(pcSlice->getNalUnitType()==NAL_UNIT_CODED_SLICE_RASL_R)
     574      {
     575        pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_RASL_N);
    449576      }
    450577    }
    … …  
    471598        else
    472599        {
    473           pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_TLA);
     600          pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_TLA_R);
    474601        }
    475602      }
    … …  
    527654    if(m_layerId > 0)
    528655    {
    529       if( pcSlice->getNalUnitType() >= NAL_UNIT_CODED_SLICE_BLA && pcSlice->getNalUnitType() <= NAL_UNIT_CODED_SLICE_CRA )
     656      if( pcSlice->getNalUnitType() >= NAL_UNIT_CODED_SLICE_BLA_W_LP && pcSlice->getNalUnitType() <= NAL_UNIT_CODED_SLICE_CRA )
    530657      {
    531658        pcSlice->setNumRefIdx(REF_PIC_LIST_0, pcSlice->getNumILRRefIdx());
    … …  
    644771      pcSlice->setSliceType ( P_SLICE );
    645772    }
    646 
     773#if !L0034_COMBINED_LIST_CLEANUP
    647774    if (pcSlice->getSliceType() != B_SLICE || !pcSlice->getSPS()->getUseLComb())
    648775    {
    … …  
    656783      pcSlice->setNumRefIdx(REF_PIC_LIST_C, pcSlice->getNumRefIdx(REF_PIC_LIST_0));
    657784    }
     785#endif
    658786
    659787    if (pcSlice->getSliceType() == B_SLICE)
    … …  
    683811      pcSlice->setCheckLDC(bLowDelay); 
    684812    }
     813    else
     814    {
     815      pcSlice->setCheckLDC(true); 
     816    }
    685817
    686818    uiColDir = 1-uiColDir;
    … …  
    689821    pcSlice->setRefPOCList();
    690822
     823#if L0034_COMBINED_LIST_CLEANUP
     824    pcSlice->setList1IdxToList0Idx();
     825#else
    691826    pcSlice->setNoBackPredFlag( false );
    692827    if ( pcSlice->getSliceType() == B_SLICE && !pcSlice->getRefPicListCombinationFlag())
    … …  
    712847    }
    713848    pcSlice->generateCombinedList();
     849#endif
    714850
    715851    if (m_pcEncTop->getTMVPModeId() == 2)
    … …  
    10271163    Bool bLFCrossTileBoundary = pcSlice->getPPS()->getLoopFilterAcrossTilesEnabledFlag();
    10281164    m_pcLoopFilter->setCfg(bLFCrossTileBoundary);
     1165#if L0386_DB_METRIC
     1166    if ( m_pcCfg->getDeblockingFilterMetric() )
     1167    {
     1168      dblMetric(pcPic, uiNumSlices);
     1169    }
     1170#endif
    10291171    m_pcLoopFilter->loopFilterPic( pcPic );
    10301172
    … …  
    11331275    }
    11341276
     1277#if L0208_SOP_DESCRIPTION_SEI
     1278    if (writeSOP) // write SOP description SEI (if enabled) at the beginning of GOP
     1279    {
     1280      Int SOPcurrPOC = pocCurr;
     1281
     1282      OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI);
     1283      m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
     1284      m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
     1285
     1286      SEISOPDescription SOPDescriptionSEI;
     1287      SOPDescriptionSEI.m_sopSeqParameterSetId = pcSlice->getSPS()->getSPSId();
     1288
     1289      UInt i = 0;
     1290      UInt prevEntryId = iGOPid;
     1291      for (j = iGOPid; j < m_iGopSize; j++)
     1292      {
     1293        Int deltaPOC = m_pcCfg->getGOPEntry(j).m_POC - m_pcCfg->getGOPEntry(prevEntryId).m_POC;
     1294        if ((SOPcurrPOC + deltaPOC) < m_pcCfg->getFramesToBeEncoded())
     1295        {
     1296          SOPcurrPOC += deltaPOC;
     1297          SOPDescriptionSEI.m_sopDescVclNaluType[i] = getNalUnitType(SOPcurrPOC, m_iLastIDR);
     1298          SOPDescriptionSEI.m_sopDescTemporalId[i] = m_pcCfg->getGOPEntry(j).m_temporalId;
     1299          SOPDescriptionSEI.m_sopDescStRpsIdx[i] = m_pcEncTop->getReferencePictureSetIdxForSOP(pcSlice, SOPcurrPOC, j);
     1300          SOPDescriptionSEI.m_sopDescPocDelta[i] = deltaPOC;
     1301
     1302          prevEntryId = j;
     1303          i++;
     1304        }
     1305      }
     1306
     1307      SOPDescriptionSEI.m_numPicsInSopMinus1 = i - 1;
     1308
     1309      m_seiWriter.writeSEImessage( nalu.m_Bitstream, SOPDescriptionSEI, pcSlice->getSPS());
     1310      writeRBSPTrailingBits(nalu.m_Bitstream);
     1311      accessUnit.push_back(new NALUnitEBSP(nalu));
     1312
     1313      writeSOP = false;
     1314    }
     1315#endif
     1316
    11351317    if( ( m_pcCfg->getPictureTimingSEIEnabled() || m_pcCfg->getDecodingUnitInfoSEIEnabled() ) &&
    11361318        ( pcSlice->getSPS()->getVuiParametersPresentFlag() ) &&
    … …  
    11781360       || ( pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getVclHrdParametersPresentFlag() ) ) )
    11791361    {
    1180       OutputNALUnit nalu(NAL_UNIT_SEI);
     1362      OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI);
    11811363      m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
    11821364      m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
    … …  
    12191401      writeRBSPTrailingBits(nalu.m_Bitstream);
    12201402#if L0045_NON_NESTED_SEI_RESTRICTIONS
     1403      {
    12211404      UInt seiPositionInAu = xGetFirstSeiLocation(accessUnit);
    12221405      UInt offsetPosition = m_activeParameterSetSEIPresentInAU;   // Insert BP SEI after APS SEI
    … …  
    12281411      accessUnit.insert(it, new NALUnitEBSP(nalu));
    12291412      m_bufferingPeriodSEIPresentInAU = true;
     1413      }
    12301414#else
    12311415      accessUnit.push_back(new NALUnitEBSP(nalu));
    12321416#endif
    12331417
     1418#if K0180_SCALABLE_NESTING_SEI
     1419      if (m_pcCfg->getScalableNestingSEIEnabled())
     1420      {
     1421        OutputNALUnit naluTmp(NAL_UNIT_PREFIX_SEI);
     1422        m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
     1423        m_pcEntropyCoder->setBitstream(&naluTmp.m_Bitstream);
     1424        scalableNestingSEI.m_nestedSEIs.clear();
     1425        scalableNestingSEI.m_nestedSEIs.push_back(&sei_buffering_period);
     1426        m_seiWriter.writeSEImessage( naluTmp.m_Bitstream, scalableNestingSEI, pcSlice->getSPS());
     1427        writeRBSPTrailingBits(naluTmp.m_Bitstream);
     1428#if L0045_NON_NESTED_SEI_RESTRICTIONS
     1429        UInt seiPositionInAu = xGetFirstSeiLocation(accessUnit);
     1430        UInt offsetPosition = m_activeParameterSetSEIPresentInAU + m_bufferingPeriodSEIPresentInAU + m_pictureTimingSEIPresentInAU;   // Insert BP SEI after non-nested APS, BP and PT SEIs
     1431        AccessUnit::iterator it;
     1432        for(j = 0, it = accessUnit.begin(); j < seiPositionInAu + offsetPosition; j++)
     1433        {
     1434          it++;
     1435        }
     1436        accessUnit.insert(it, new NALUnitEBSP(naluTmp));
     1437        m_nestedBufferingPeriodSEIPresentInAU = true;
     1438#else
     1439        accessUnit.push_back(new NALUnitEBSP(naluTmp));
     1440#endif
     1441      }
     1442#endif
     1443
    12341444      m_lastBPSEI = m_totalCoded;
    12351445      m_cpbRemovalDelay = 0;
    … …  
    12411451      {
    12421452        // Gradual decoding refresh SEI
    1243         OutputNALUnit nalu(NAL_UNIT_SEI);
     1453        OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI);
    12441454        m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
    12451455        m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
    … …  
    12531463      }
    12541464    // Recovery point SEI
    1255       OutputNALUnit nalu(NAL_UNIT_SEI);
     1465      OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI);
    12561466      m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
    12571467      m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
    … …  
    14441654
    14451655          pcSlice->setTileOffstForMultES( uiOneBitstreamPerSliceLength );
    1446           if (!sliceSegment)
    1447           {
    14481656            pcSlice->setTileLocationCount ( 0 );
    1449             m_pcSliceEncoder->encodeSlice(pcPic, pcBitstreamRedirect, pcSubstreamsOut); // redirect is only used for CAVLC tile position info.
    1450           }
    1451           else
    1452           {
    1453             m_pcSliceEncoder->encodeSlice(pcPic, &nalu.m_Bitstream, pcSubstreamsOut); // nalu.m_Bitstream is only used for CAVLC tile position info.
    1454           }
     1657          m_pcSliceEncoder->encodeSlice(pcPic, pcSubstreamsOut);
    14551658
    14561659          {
    … …  
    14841687              if (ui+1 < pcSlice->getPPS()->getNumSubstreams())
    14851688              {
    1486                 puiSubstreamSizes[ui] = pcSubstreamsOut[ui].getNumberOfWrittenBits();
     1689                puiSubstreamSizes[ui] = pcSubstreamsOut[ui].getNumberOfWrittenBits() + (pcSubstreamsOut[ui].countStartCodeEmulations()<<3);
    14871690              }
    14881691            }
    … …  
    15161719          // If current NALU is the last NALU of slice and a NALU was buffered, then (a) Write current NALU (b) Update an write buffered NALU at approproate location in NALU list.
    15171720          Bool bNALUAlignedWrittenToList    = false; // used to ensure current NALU is not written more than once to the NALU list.
    1518           xWriteTileLocationToSliceHeader(nalu, pcBitstreamRedirect, pcSlice);
     1721          xAttachSliceDataToNalUnit(nalu, pcBitstreamRedirect);
    15191722          accessUnit.push_back(new NALUnitEBSP(nalu));
    15201723#if RATE_CONTROL_LAMBDA_DOMAIN
    … …  
    15441747            {
    15451748              UInt numRBSPBytes_nal = UInt((*it)->m_nalUnitData.str().size());
    1546               if ((*it)->m_nalUnitType != NAL_UNIT_SEI && (*it)->m_nalUnitType != NAL_UNIT_SEI_SUFFIX)
     1749              if ((*it)->m_nalUnitType != NAL_UNIT_PREFIX_SEI && (*it)->m_nalUnitType != NAL_UNIT_SUFFIX_SEI)
    15471750              {
    15481751                numRBSPBytes += numRBSPBytes_nal;
    … …  
    16401843        }
    16411844#if SVC_EXTENSION
    1642         OutputNALUnit nalu(NAL_UNIT_SEI_SUFFIX, pcSlice->getTLayer(), m_layerId);
     1845        OutputNALUnit nalu(NAL_UNIT_SUFFIX_SEI, pcSlice->getTLayer(), m_layerId);
    16431846#else
    1644         OutputNALUnit nalu(NAL_UNIT_SEI_SUFFIX, pcSlice->getTLayer());
     1847        OutputNALUnit nalu(NAL_UNIT_SUFFIX_SEI, pcSlice->getTLayer());
    16451848#endif
    16461849
    … …  
    16671870        sei_temporal_level0_index.rapIdx = m_rapIdx;
    16681871
    1669         OutputNALUnit nalu(NAL_UNIT_SEI);
     1872        OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI);
    16701873
    16711874        /* write the SEI messages */
    … …  
    18072010        if( m_pcCfg->getPictureTimingSEIEnabled() )
    18082011        {
    1809           OutputNALUnit nalu(NAL_UNIT_SEI, pcSlice->getTLayer());
     2012          {
     2013            OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI, pcSlice->getTLayer());
    18102014          m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
    18112015          m_seiWriter.writeSEImessage(nalu.m_Bitstream, pictureTimingSEI, pcSlice->getSPS());
    … …  
    18272031#endif
    18282032        }
     2033#if K0180_SCALABLE_NESTING_SEI
     2034          if ( m_pcCfg->getScalableNestingSEIEnabled() ) // put picture timing SEI into scalable nesting SEI
     2035          {
     2036            OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI, pcSlice->getTLayer());
     2037            m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice);
     2038            scalableNestingSEI.m_nestedSEIs.clear();
     2039            scalableNestingSEI.m_nestedSEIs.push_back(&pictureTimingSEI);
     2040            m_seiWriter.writeSEImessage(nalu.m_Bitstream, scalableNestingSEI, pcSlice->getSPS());
     2041            writeRBSPTrailingBits(nalu.m_Bitstream);
     2042#if L0045_NON_NESTED_SEI_RESTRICTIONS
     2043            UInt seiPositionInAu = xGetFirstSeiLocation(accessUnit);
     2044            UInt offsetPosition = m_activeParameterSetSEIPresentInAU
     2045              + m_bufferingPeriodSEIPresentInAU + m_pictureTimingSEIPresentInAU + m_nestedBufferingPeriodSEIPresentInAU;    // Insert PT SEI after APS and BP SEI
     2046            AccessUnit::iterator it;
     2047            for(j = 0, it = accessUnit.begin(); j < seiPositionInAu + offsetPosition; j++)
     2048            {
     2049              it++;
     2050            }
     2051            accessUnit.insert(it, new NALUnitEBSP(nalu));
     2052            m_nestedPictureTimingSEIPresentInAU = true;
     2053#else
     2054            AccessUnit::iterator it = find_if(accessUnit.begin(), accessUnit.end(), mem_fun(&NALUnit::isSlice));
     2055            accessUnit.insert(it, new NALUnitEBSP(nalu));
     2056#endif
     2057          }
     2058#endif
     2059
     2060        }
    18292061        if( m_pcCfg->getDecodingUnitInfoSEIEnabled() && hrd->getSubPicCpbParamsPresentFlag() )
    18302062        {             
    … …  
    18322064          for( Int i = 0; i < ( pictureTimingSEI.m_numDecodingUnitsMinus1 + 1 ); i ++ )
    18332065          {
    1834             OutputNALUnit nalu(NAL_UNIT_SEI, pcSlice->getTLayer());
     2066            OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI, pcSlice->getTLayer());
    18352067
    18362068            SEIDecodingUnitInfo tempSEI;
    … …  
    18802112                  break;
    18812113                }
    1882                 if ((*it)->m_nalUnitType != NAL_UNIT_SEI && (*it)->m_nalUnitType != NAL_UNIT_SEI_SUFFIX)
     2114                if ((*it)->m_nalUnitType != NAL_UNIT_PREFIX_SEI && (*it)->m_nalUnitType != NAL_UNIT_SUFFIX_SEI)
    18832115                {
    18842116                  ctr++;
    … …  
    18912123#if L0045_NON_NESTED_SEI_RESTRICTIONS
    18922124      xResetNonNestedSEIPresentFlags();
     2125#if K0180_SCALABLE_NESTING_SEI
     2126      xResetNestedSEIPresentFlags();
     2127#endif
    18932128#endif
    18942129      pcPic->getPicYuvRec()->copyToPic(pcPicYuvRecOut);
    … …  
    21132348    case NAL_UNIT_CODED_SLICE_TRAIL_R: return "TRAIL_R";
    21142349    case NAL_UNIT_CODED_SLICE_TRAIL_N: return "TRAIL_N";
    2115     case NAL_UNIT_CODED_SLICE_TLA: return "TLA";
     2350    case NAL_UNIT_CODED_SLICE_TLA_R:      return "TLA_R";
    21162351    case NAL_UNIT_CODED_SLICE_TSA_N: return "TSA_N";
    21172352    case NAL_UNIT_CODED_SLICE_STSA_R: return "STSA_R";
    21182353    case NAL_UNIT_CODED_SLICE_STSA_N: return "STSA_N";
    2119     case NAL_UNIT_CODED_SLICE_BLA: return "BLA";
    2120     case NAL_UNIT_CODED_SLICE_BLANT: return "BLANT";
     2354    case NAL_UNIT_CODED_SLICE_BLA_W_LP:   return "BLA_W_LP";
     2355    case NAL_UNIT_CODED_SLICE_BLA_W_RADL: return "BLA_W_RADL";
    21212356    case NAL_UNIT_CODED_SLICE_BLA_N_LP: return "BLA_N_LP";
    2122     case NAL_UNIT_CODED_SLICE_IDR: return "IDR";
     2357    case NAL_UNIT_CODED_SLICE_IDR_W_RADL: return "IDR_W_RADL";
    21232358    case NAL_UNIT_CODED_SLICE_IDR_N_LP: return "IDR_N_LP";
    21242359    case NAL_UNIT_CODED_SLICE_CRA: return "CRA";
    2125     case NAL_UNIT_CODED_SLICE_DLP: return "DLP";
    2126     case NAL_UNIT_CODED_SLICE_TFD: return "TFD";
     2360    case NAL_UNIT_CODED_SLICE_RADL_R:     return "RADL_R";
     2361    case NAL_UNIT_CODED_SLICE_RASL_R:     return "RASL_R";
    21272362    case NAL_UNIT_VPS: return "VPS";
    21282363    case NAL_UNIT_SPS: return "SPS";
    … …  
    21322367    case NAL_UNIT_EOB: return "EOB";
    21332368    case NAL_UNIT_FILLER_DATA: return "FILLER";
    2134     case NAL_UNIT_SEI: return "SEI";
     2369    case NAL_UNIT_PREFIX_SEI:             return "SEI";
     2370    case NAL_UNIT_SUFFIX_SEI:             return "SEI";
    21352371    default: return "UNK";
    21362372  }
    … …  
    22232459    printf("*** %6s numBytesInNALunit: %u\n", nalUnitTypeToString((*it)->m_nalUnitType), numRBSPBytes_nal);
    22242460#endif
    2225     if ((*it)->m_nalUnitType != NAL_UNIT_SEI && (*it)->m_nalUnitType != NAL_UNIT_SEI_SUFFIX)
     2461    if ((*it)->m_nalUnitType != NAL_UNIT_PREFIX_SEI && (*it)->m_nalUnitType != NAL_UNIT_SUFFIX_SEI)
    22262462    {
    22272463      numRBSPBytes += numRBSPBytes_nal;
    … …  
    23252561 * This function checks the configuration and returns the appropriate nal_unit_type for the picture.
    23262562 */
    2327 NalUnitType TEncGOP::getNalUnitType(Int pocCurr)
     2563NalUnitType TEncGOP::getNalUnitType(Int pocCurr, Int lastIDR)
    23282564{
    23292565  if (pocCurr == 0)
    23302566  {
    2331     return NAL_UNIT_CODED_SLICE_IDR;
     2567    return NAL_UNIT_CODED_SLICE_IDR_W_RADL;
    23322568  }
    23332569  if (pocCurr % m_pcCfg->getIntraPeriod() == 0)
    … …  
    23392575    else if (m_pcCfg->getDecodingRefreshType() == 2)
    23402576    {
    2341       return NAL_UNIT_CODED_SLICE_IDR;
     2577      return NAL_UNIT_CODED_SLICE_IDR_W_RADL;
    23422578    }
    23432579  }
    … …  
    23512587      // controlling the reference pictures used for encoding that leading picture. Such a leading
    23522588      // picture need not be marked as a TFD picture.
    2353       return NAL_UNIT_CODED_SLICE_TFD;
     2589      return NAL_UNIT_CODED_SLICE_RASL_R;
     2590    }
     2591  }
     2592  if (lastIDR>0)
     2593  {
     2594    if (pocCurr < lastIDR)
     2595    {
     2596      return NAL_UNIT_CODED_SLICE_RADL_R;
    23542597    }
    23552598  }
    … …  
    24022645}
    24032646
    2404 /** Determine the difference between consecutive tile sizes (in bytes) and writes it to  bistream rNalu [slice header]
    2405  * \param rpcBitstreamRedirect contains the bitstream to be concatenated to rNalu. rpcBitstreamRedirect contains slice payload. rpcSlice contains tile location information.
    2406  * \returns Updates rNalu to contain concatenated bitstream. rpcBitstreamRedirect is cleared at the end of this function call.
     2647/** Attaches the input bitstream to the stream in the output NAL unit
     2648    Updates rNalu to contain concatenated bitstream. rpcBitstreamRedirect is cleared at the end of this function call.
     2649 *  \param codedSliceData contains the coded slice data (bitstream) to be concatenated to rNalu
     2650 *  \param rNalu          target NAL unit
    24072651 */
    2408 Void TEncGOP::xWriteTileLocationToSliceHeader (OutputNALUnit& rNalu, TComOutputBitstream*& rpcBitstreamRedirect, TComSlice*& rpcSlice)
     2652Void TEncGOP::xAttachSliceDataToNalUnit (OutputNALUnit& rNalu, TComOutputBitstream*& codedSliceData)
    24092653{
    24102654  // Byte-align
    … …  
    24122656
    24132657  // Perform bitstream concatenation
    2414   if (rpcBitstreamRedirect->getNumberOfWrittenBits() > 0)
    2415   {
    2416     UInt uiBitCount  = rpcBitstreamRedirect->getNumberOfWrittenBits();
    2417     if (rpcBitstreamRedirect->getByteStreamLength()>0)
    2418     {
    2419       UChar *pucStart  =  reinterpret_cast<UChar*>(rpcBitstreamRedirect->getByteStream());
    2420       UInt uiWriteByteCount = 0;
    2421       while (uiWriteByteCount < (uiBitCount >> 3) )
    2422       {
    2423         UInt uiBits = (*pucStart);
    2424         rNalu.m_Bitstream.write(uiBits, 8);
    2425         pucStart++;
    2426         uiWriteByteCount++;
    2427       }
    2428     }
    2429     UInt uiBitsHeld = (uiBitCount & 0x07);
    2430     for (UInt uiIdx=0; uiIdx < uiBitsHeld; uiIdx++)
    2431     {
    2432       rNalu.m_Bitstream.write((rpcBitstreamRedirect->getHeldBits() & (1 << (7-uiIdx))) >> (7-uiIdx), 1);
    2433     }         
     2658  if (codedSliceData->getNumberOfWrittenBits() > 0)
     2659    {
     2660    rNalu.m_Bitstream.addSubstream(codedSliceData);
    24342661  }
    24352662
    24362663  m_pcEntropyCoder->setBitstream(&rNalu.m_Bitstream);
    24372664
    2438   delete rpcBitstreamRedirect;
    2439   rpcBitstreamRedirect = new TComOutputBitstream;
     2665  codedSliceData->clear();
    24402666}
    24412667
    … …  
    25622788     }               
    25632789  }
    2564   assert(it != accessUnit.end());
     2790//  assert(it != accessUnit.end());  // Triggers with some legit configurations
    25652791  return seiStartPos;
    25662792}
    25672793#endif
     2794
     2795#if L0386_DB_METRIC
     2796Void TEncGOP::dblMetric( TComPic* pcPic, UInt uiNumSlices )
     2797{
     2798  TComPicYuv* pcPicYuvRec = pcPic->getPicYuvRec();
     2799  Pel* Rec    = pcPicYuvRec->getLumaAddr( 0 );
     2800  Pel* tempRec = Rec;
     2801  Int  stride = pcPicYuvRec->getStride();
     2802  UInt log2maxTB = pcPic->getSlice(0)->getSPS()->getQuadtreeTULog2MaxSize();
     2803  UInt maxTBsize = (1<<log2maxTB);
     2804  const UInt minBlockArtSize = 8;
     2805  const UInt picWidth = pcPicYuvRec->getWidth();
     2806  const UInt picHeight = pcPicYuvRec->getHeight();
     2807  const UInt noCol = (picWidth>>log2maxTB);
     2808  const UInt noRows = (picHeight>>log2maxTB);
     2809  UInt64 *colSAD = (UInt64*)malloc(noCol*sizeof(UInt64));
     2810  UInt64 *rowSAD = (UInt64*)malloc(noRows*sizeof(UInt64));
     2811  UInt colIdx = 0;
     2812  UInt rowIdx = 0;
     2813  Pel p0, p1, p2, q0, q1, q2;
     2814 
     2815  Int qp = pcPic->getSlice(0)->getSliceQp();
     2816  Int bitdepthScale = 1 << (g_bitDepthY-8);
     2817  Int beta = TComLoopFilter::getBeta( qp ) * bitdepthScale;
     2818  const Int thr2 = (beta>>2);
     2819  const Int thr1 = 2*bitdepthScale;
     2820  UInt a = 0;
     2821 
     2822  memset(colSAD, 0, noCol*sizeof(UInt64));
     2823  memset(rowSAD, 0, noRows*sizeof(UInt64));
     2824 
     2825  if (maxTBsize > minBlockArtSize)
     2826  {
     2827    // Analyze vertical artifact edges
     2828    for(Int c = maxTBsize; c < picWidth; c += maxTBsize)
     2829    {
     2830      for(Int r = 0; r < picHeight; r++)
     2831      {
     2832        p2 = Rec[c-3];
     2833        p1 = Rec[c-2];
     2834        p0 = Rec[c-1];
     2835        q0 = Rec[c];
     2836        q1 = Rec[c+1];
     2837        q2 = Rec[c+2];
     2838        a = ((abs(p2-(p1<<1)+p0)+abs(q0-(q1<<1)+q2))<<1);
     2839        if ( thr1 < a && a < thr2)
     2840        {
     2841          colSAD[colIdx] += abs(p0 - q0);
     2842        }
     2843        Rec += stride;
     2844      }
     2845      colIdx++;
     2846      Rec = tempRec;
     2847    }
     2848   
     2849    // Analyze horizontal artifact edges
     2850    for(Int r = maxTBsize; r < picHeight; r += maxTBsize)
     2851    {
     2852      for(Int c = 0; c < picWidth; c++)
     2853      {
     2854        p2 = Rec[c + (r-3)*stride];
     2855        p1 = Rec[c + (r-2)*stride];
     2856        p0 = Rec[c + (r-1)*stride];
     2857        q0 = Rec[c + r*stride];
     2858        q1 = Rec[c + (r+1)*stride];
     2859        q2 = Rec[c + (r+2)*stride];
     2860        a = ((abs(p2-(p1<<1)+p0)+abs(q0-(q1<<1)+q2))<<1);
     2861        if (thr1 < a && a < thr2)
     2862        {
     2863          rowSAD[rowIdx] += abs(p0 - q0);
     2864        }
     2865      }
     2866      rowIdx++;
     2867    }
     2868  }
     2869 
     2870  UInt64 colSADsum = 0;
     2871  UInt64 rowSADsum = 0;
     2872  for(Int c = 0; c < noCol-1; c++)
     2873  {
     2874    colSADsum += colSAD[c];
     2875  }
     2876  for(Int r = 0; r < noRows-1; r++)
     2877  {
     2878    rowSADsum += rowSAD[r];
     2879  }
     2880 
     2881  colSADsum <<= 10;
     2882  rowSADsum <<= 10;
     2883  colSADsum /= (noCol-1);
     2884  colSADsum /= picHeight;
     2885  rowSADsum /= (noRows-1);
     2886  rowSADsum /= picWidth;
     2887 
     2888  UInt64 avgSAD = ((colSADsum + rowSADsum)>>1);
     2889  avgSAD >>= (g_bitDepthY-8);
     2890 
     2891  if ( avgSAD > 2048 )
     2892  {
     2893    avgSAD >>= 9;
     2894    Int offset = Clip3(2,6,(Int)avgSAD);
     2895    for (Int i=0; i<uiNumSlices; i++)
     2896    {
     2897      pcPic->getSlice(i)->setDeblockingFilterOverrideFlag(true);
     2898      pcPic->getSlice(i)->setDeblockingFilterDisable(false);
     2899      pcPic->getSlice(i)->setDeblockingFilterBetaOffsetDiv2( offset );
     2900      pcPic->getSlice(i)->setDeblockingFilterTcOffsetDiv2( offset );
     2901    }
     2902  }
     2903  else
     2904  {
     2905    for (Int i=0; i<uiNumSlices; i++)
     2906    {
     2907      pcPic->getSlice(i)->setDeblockingFilterOverrideFlag(false);
     2908      pcPic->getSlice(i)->setDeblockingFilterDisable(        pcPic->getSlice(i)->getPPS()->getPicDisableDeblockingFilterFlag() );
     2909      pcPic->getSlice(i)->setDeblockingFilterBetaOffsetDiv2( pcPic->getSlice(i)->getPPS()->getDeblockingFilterBetaOffsetDiv2() );
     2910      pcPic->getSlice(i)->setDeblockingFilterTcOffsetDiv2(   pcPic->getSlice(i)->getPPS()->getDeblockingFilterTcOffsetDiv2()   );
     2911    }
     2912  }
     2913 
     2914  free(colSAD);
     2915  free(rowSAD);
     2916}
     2917#endif
    25682918//! \}

  • branches/SHM-2.0-dev/source/Lib/TLibEncoder/TEncGOP.h

    r125 r133  
    131131  Bool                    m_bufferingPeriodSEIPresentInAU;
    132132  Bool                    m_pictureTimingSEIPresentInAU;
     133#if K0180_SCALABLE_NESTING_SEI
     134  Bool                    m_nestedBufferingPeriodSEIPresentInAU;
     135  Bool                    m_nestedPictureTimingSEIPresentInAU;
     136#endif
    133137#endif
    134138public:
    … …  
    149153  Void  compressGOP ( Int iPOCLast, Int iNumPicRcvd, TComList<TComPic*>& rcListPic, TComList<TComPicYuv*>& rcListPicYuvRec, std::list<AccessUnit>& accessUnitsInGOP );
    150154#endif
    151   Void xWriteTileLocationToSliceHeader (OutputNALUnit& rNalu, TComOutputBitstream*& rpcBitstreamRedirect, TComSlice*& rpcSlice);
     155  Void  xAttachSliceDataToNalUnit (OutputNALUnit& rNalu, TComOutputBitstream*& rpcBitstreamRedirect);
    152156
    153157 
    … …  
    160164 
    161165  TEncSlice*  getSliceEncoder()   { return m_pcSliceEncoder; }
    162   NalUnitType getNalUnitType( Int pocCurr );
     166  NalUnitType getNalUnitType( Int pocCurr, Int lastIdr );
    163167  Void arrangeLongtermPicturesInRPS(TComSlice *, TComList<TComPic*>& );
    164168protected:
    … …  
    178182  SEIFramePacking*        xCreateSEIFramePacking();
    179183  SEIDisplayOrientation*  xCreateSEIDisplayOrientation();
     184
     185#if J0149_TONE_MAPPING_SEI
     186  SEIToneMappingInfo*     xCreateSEIToneMappingInfo();
     187#endif
    180188
    181189  Void xCreateLeadingSEIMessages (/*SEIMessages seiMessages,*/ AccessUnit &accessUnit, TComSPS *sps);
    … …  
    188196    m_pictureTimingSEIPresentInAU      = false;
    189197  }
     198#if K0180_SCALABLE_NESTING_SEI
     199  Void xResetNestedSEIPresentFlags()
     200  {
     201    m_nestedBufferingPeriodSEIPresentInAU    = false;
     202    m_nestedPictureTimingSEIPresentInAU      = false;
     203  }
     204#endif
     205#endif
     206#if L0386_DB_METRIC
     207  Void dblMetric( TComPic* pcPic, UInt uiNumSlices );
    190208#endif
    191209};// END CLASS DEFINITION TEncGOP

  • branches/SHM-2.0-dev/source/Lib/TLibEncoder/TEncSampleAdaptiveOffset.cpp

    r125 r133  
    16771677#endif
    16781678{
    1679 #if SAO_CHROMA_LAMBDA
    1680   m_dLambdaLuma    = dLambdaLuma;
    1681   m_dLambdaChroma  = dLambdaChroma;
    1682 #else
    1683   m_dLambdaLuma    = dLambda;
    1684   m_dLambdaChroma  = dLambda;
    1685 #endif
    1686 
    16871679  if(m_bUseNIF)
    16881680  {

  • branches/SHM-2.0-dev/source/Lib/TLibEncoder/TEncSampleAdaptiveOffset.h

    r125 r133  
    5757{
    5858private:
    59   Double            m_dLambdaLuma;
    60   Double            m_dLambdaChroma;
    61 
    6259  TEncEntropy*      m_pcEntropyCoder;
    6360  TEncSbac***       m_pppcRDSbacCoder;              ///< for CABAC

  • branches/SHM-2.0-dev/source/Lib/TLibEncoder/TEncSbac.h

    r125 r133  
    109109  Void  xWriteEpExGolomb     ( UInt uiSymbol, UInt uiCount );
    110110  Void  xWriteCoefRemainExGolomb ( UInt symbol, UInt &rParam );
    111   Void  xWriteTerminatingBit ( UInt uiBit );
    112111 
    113112  Void  xCopyFrom            ( TEncSbac* pSrc );

  • branches/SHM-2.0-dev/source/Lib/TLibEncoder/TEncSearch.cpp

    r125 r133  
    32493249    UInt          uiBitsTempL0[MAX_NUM_REF];
    32503250
     3251#if L0034_COMBINED_LIST_CLEANUP
     3252    TComMv        mvValidList1;
     3253    Int           refIdxValidList1 = 0;
     3254    UInt          bitsValidList1 = MAX_UINT;
     3255    UInt          costValidList1 = MAX_UINT;
     3256#endif
     3257
    32513258#if (ENCODER_FAST_MODE)
    32523259    Bool          testILR;
    … …  
    33263333        uiBitsTemp += m_auiMVPIdxCost[aaiMvpIdx[iRefList][iRefIdxTemp]][AMVP_MAX_NUM_CANDS];
    33273334#if ZERO_MVD_EST
     3335#if L0034_COMBINED_LIST_CLEANUP
     3336        if ( iRefList == 0 || pcCU->getSlice()->getList1IdxToList0Idx( iRefIdxTemp ) < 0 )
     3337#else
    33283338        if ((iRefList != 1 || !pcCU->getSlice()->getNoBackPredFlag()) &&
    33293339            (pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_C) <= 0 || pcCU->getSlice()->getRefIdxOfLC(eRefPicList, iRefIdxTemp)>=0))
     3340#endif
    33303341        {
    33313342          uiZeroMvdBitsTemp = uiBitsTemp;
    … …  
    33473358       
    33483359#if GPB_SIMPLE_UNI
     3360#if L0034_COMBINED_LIST_CLEANUP
     3361        if ( iRefList == 1 )    // list 1
     3362        {
     3363          if ( pcCU->getSlice()->getList1IdxToList0Idx( iRefIdxTemp ) >= 0 )
     3364          {
     3365            cMvTemp[1][iRefIdxTemp] = cMvTemp[0][pcCU->getSlice()->getList1IdxToList0Idx( iRefIdxTemp )];
     3366            uiCostTemp = uiCostTempL0[pcCU->getSlice()->getList1IdxToList0Idx( iRefIdxTemp )];
     3367            /*first subtract the bit-rate part of the cost of the other list*/
     3368            uiCostTemp -= m_pcRdCost->getCost( uiBitsTempL0[pcCU->getSlice()->getList1IdxToList0Idx( iRefIdxTemp )] );
     3369            /*correct the bit-rate part of the current ref*/
     3370            m_pcRdCost->setPredictor  ( cMvPred[iRefList][iRefIdxTemp] );
     3371            uiBitsTemp += m_pcRdCost->getBits( cMvTemp[1][iRefIdxTemp].getHor(), cMvTemp[1][iRefIdxTemp].getVer() );
     3372            /*calculate the correct cost*/
     3373            uiCostTemp += m_pcRdCost->getCost( uiBitsTemp );
     3374          }
     3375          else
     3376          {
     3377            xMotionEstimation ( pcCU, pcOrgYuv, iPartIdx, eRefPicList, &cMvPred[iRefList][iRefIdxTemp], iRefIdxTemp, cMvTemp[iRefList][iRefIdxTemp], uiBitsTemp, uiCostTemp );
     3378          }
     3379        }
     3380        else
     3381        {
     3382          xMotionEstimation ( pcCU, pcOrgYuv, iPartIdx, eRefPicList, &cMvPred[iRefList][iRefIdxTemp], iRefIdxTemp, cMvTemp[iRefList][iRefIdxTemp], uiBitsTemp, uiCostTemp );
     3383        }
     3384#else
    33493385        if ( pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_C) > 0)
    33503386        {
    … …  
    33883424          }       
    33893425        }
     3426#endif
    33903427#else
    33913428        xMotionEstimation ( pcCU, pcOrgYuv, iPartIdx, eRefPicList, &cMvPred[iRefList][iRefIdxTemp], iRefIdxTemp, cMvTemp[iRefList][iRefIdxTemp], uiBitsTemp, uiCostTemp );
    … …  
    33943431        xCheckBestMVP(pcCU, eRefPicList, cMvTemp[iRefList][iRefIdxTemp], cMvPred[iRefList][iRefIdxTemp], aaiMvpIdx[iRefList][iRefIdxTemp], uiBitsTemp, uiCostTemp);
    33953432
     3433#if L0034_COMBINED_LIST_CLEANUP
     3434        if ( iRefList == 0 )
     3435        {
     3436          uiCostTempL0[iRefIdxTemp] = uiCostTemp;
     3437          uiBitsTempL0[iRefIdxTemp] = uiBitsTemp;
     3438        }
     3439        if ( uiCostTemp < uiCost[iRefList] )
     3440        {
     3441          uiCost[iRefList] = uiCostTemp;
     3442          uiBits[iRefList] = uiBitsTemp; // storing for bi-prediction
     3443
     3444          // set motion
     3445          cMv[iRefList]     = cMvTemp[iRefList][iRefIdxTemp];
     3446          iRefIdx[iRefList] = iRefIdxTemp;
     3447        }
     3448
     3449        if ( iRefList == 1 && uiCostTemp < costValidList1 && pcCU->getSlice()->getList1IdxToList0Idx( iRefIdxTemp ) < 0 )
     3450        {
     3451          costValidList1 = uiCostTemp;
     3452          bitsValidList1 = uiBitsTemp;
     3453
     3454          // set motion
     3455          mvValidList1     = cMvTemp[iRefList][iRefIdxTemp];
     3456          refIdxValidList1 = iRefIdxTemp;
     3457        }
     3458#else
    33963459        if(pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_C) > 0 && !pcCU->getSlice()->getNoBackPredFlag())
    33973460        {
    … …  
    34493512            }
    34503513          }
     3514#endif
    34513515      }
    34523516    }
    … …  
    35163580       
    35173581        Int         iRefList    = iIter % 2;
     3582#if L0034_COMBINED_LIST_CLEANUP
     3583        if ( m_pcEncCfg->getUseFastEnc() )
     3584        {
     3585          if( uiCost[0] <= uiCost[1] )
     3586          {
     3587            iRefList = 1;
     3588          }
     3589          else
     3590          {
     3591            iRefList = 0;
     3592          }
     3593        }
     3594        else if ( iIter == 0 )
     3595        {
     3596          iRefList = 0;
     3597        }
     3598        if ( iIter == 0 && !pcCU->getSlice()->getMvdL1ZeroFlag())
     3599        {
     3600          pcCU->getCUMvField(RefPicList(1-iRefList))->setAllMv( cMv[1-iRefList], ePartSize, uiPartAddr, 0, iPartIdx );
     3601          pcCU->getCUMvField(RefPicList(1-iRefList))->setAllRefIdx( iRefIdx[1-iRefList], ePartSize, uiPartAddr, 0, iPartIdx );
     3602          TComYuv*  pcYuvPred = &m_acYuvPred[1-iRefList];
     3603          motionCompensation ( pcCU, pcYuvPred, RefPicList(1-iRefList), iPartIdx );
     3604        }
     3605#else
    35183606        if ( m_pcEncCfg->getUseFastEnc() && (pcCU->getSlice()->getNoBackPredFlag() || (pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_C) > 0 && pcCU->getSlice()->getRefIdxOfL0FromRefIdxOfL1(0)==0 )) )
    35193607        {
    35203608          iRefList = 1;
    35213609        }
     3610#endif
    35223611        RefPicList  eRefPicList = ( iRefList ? REF_PIC_LIST_1 : REF_PIC_LIST_0 );
    35233612
    … …  
    36803769    UInt uiMEBits = 0;
    36813770    // Set Motion Field_
     3771#if L0034_COMBINED_LIST_CLEANUP
     3772    cMv[1] = mvValidList1;
     3773    iRefIdx[1] = refIdxValidList1;
     3774    uiBits[1] = bitsValidList1;
     3775    uiCost[1] = costValidList1;
     3776#else
    36823777    if ( pcCU->getSlice()->getNoBackPredFlag() || (pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_C) > 0 && pcCU->getSlice()->getRefIdxOfL0FromRefIdxOfL1(0)==0 ) )
    36833778    {
    36843779      uiCost[1] = MAX_UINT;
    36853780    }
     3781#endif
    36863782#if AMP_MRG
    36873783    if (bTestNormalMC)
    … …  
    46634759    while( pcCU->getWidth(0) > (pcCU->getSlice()->getSPS()->getMaxTrSize()<<uiTrLevel) ) uiTrLevel++;
    46644760  }
    4665   UInt uiMaxTrMode = pcCU->getSlice()->getSPS()->getMaxTrDepth() + uiTrLevel;
     4761  UInt uiMaxTrMode = 1 + uiTrLevel;
    46664762 
    46674763  while((uiWidth>>uiMaxTrMode) < (g_uiMaxCUWidth>>g_uiMaxCUDepth)) uiMaxTrMode--;

  • branches/SHM-2.0-dev/source/Lib/TLibEncoder/TEncSlice.cpp

    r125 r133  
    400400  rpcSlice->setNumRefIdx(REF_PIC_LIST_1,m_pcCfg->getGOPEntry(iGOPid).m_numRefPicsActive);
    401401 
     402#if L0386_DB_METRIC
     403  if ( m_pcCfg->getDeblockingFilterMetric() )
     404  {
     405    rpcSlice->setDeblockingFilterOverrideFlag(true);
     406    rpcSlice->setDeblockingFilterDisable(false);
     407    rpcSlice->setDeblockingFilterBetaOffsetDiv2( 0 );
     408    rpcSlice->setDeblockingFilterTcOffsetDiv2( 0 );
     409  } else
     410#endif
    402411  if (rpcSlice->getPPS()->getDeblockingFilterControlPresentFlag())
    403412  {
    … …  
    11821191 \retval rpcBitstream  bitstream class
    11831192 */
    1184 Void TEncSlice::encodeSlice   ( TComPic*& rpcPic, TComOutputBitstream* pcBitstream, TComOutputBitstream* pcSubstreams )
     1193Void TEncSlice::encodeSlice   ( TComPic*& rpcPic, TComOutputBitstream* pcSubstreams )
    11851194{
    11861195  UInt       uiCUAddr;
    … …  
    13621371      }
    13631372      {
    1364           UInt uiCounter = 0;
    1365           vector<uint8_t>& rbsp   = pcSubstreams[uiSubStrm].getFIFO();
    1366           for (vector<uint8_t>::iterator it = rbsp.begin(); it != rbsp.end();)
    1367           {
    1368             /* 1) find the next emulated 00 00 {00,01,02,03}
    1369              * 2a) if not found, write all remaining bytes out, stop.
    1370              * 2b) otherwise, write all non-emulated bytes out
    1371              * 3) insert emulation_prevention_three_byte
    1372              */
    1373             vector<uint8_t>::iterator found = it;
    1374             do
    1375             {
    1376               /* NB, end()-1, prevents finding a trailing two byte sequence */
    1377               found = search_n(found, rbsp.end()-1, 2, 0);
    1378               found++;
    1379               /* if not found, found == end, otherwise found = second zero byte */
    1380               if (found == rbsp.end())
    1381               {
    1382                 break;
    1383               }
    1384               if (*(++found) <= 3)
    1385               {
    1386                 break;
    1387               }
    1388             } while (true);
    1389             it = found;
    1390             if (found != rbsp.end())
    1391             {
    1392               it++;
    1393               uiCounter++;
    1394             }
    1395           }
    1396        
     1373        UInt numStartCodeEmulations = pcSubstreams[uiSubStrm].countStartCodeEmulations();
    13971374        UInt uiAccumulatedSubstreamLength = 0;
    13981375        for (Int iSubstrmIdx=0; iSubstrmIdx < iNumSubstreams; iSubstrmIdx++)
    … …  
    14021379        // add bits coded in previous dependent slices + bits coded so far
    14031380        // add number of emulation prevention byte count in the tile
    1404         pcSlice->addTileLocation( ((pcSlice->getTileOffstForMultES() + uiAccumulatedSubstreamLength - uiBitsOriginallyInSubstreams) >> 3) + uiCounter );
     1381        pcSlice->addTileLocation( ((pcSlice->getTileOffstForMultES() + uiAccumulatedSubstreamLength - uiBitsOriginallyInSubstreams) >> 3) + numStartCodeEmulations );
    14051382      }
    14061383    }

  • branches/SHM-2.0-dev/source/Lib/TLibEncoder/TEncSlice.h

    r125 r133  
    126126  Void    precompressSlice    ( TComPic*& rpcPic                                );      ///< precompress slice for multi-loop opt.
    127127  Void    compressSlice       ( TComPic*& rpcPic                                );      ///< analysis stage of slice
    128   Void    encodeSlice         ( TComPic*& rpcPic, TComOutputBitstream* rpcBitstream, TComOutputBitstream* pcSubstreams  );
     128  Void    encodeSlice         ( TComPic*& rpcPic, TComOutputBitstream* pcSubstreams  );
    129129 
    130130  // misc. functions

  • branches/SHM-2.0-dev/source/Lib/TLibEncoder/TEncTop.cpp

    r125 r133  
    599599  m_cSPS.setMaxCUHeight   ( g_uiMaxCUHeight     );
    600600  m_cSPS.setMaxCUDepth    ( g_uiMaxCUDepth      );
    601   m_cSPS.setMinTrDepth    ( 0                   );
    602   m_cSPS.setMaxTrDepth    ( 1                   );
     601
     602  Int minCUSize = m_cSPS.getMaxCUWidth() >> ( m_cSPS.getMaxCUDepth()-g_uiAddCUDepth );
     603  Int log2MinCUSize = 0;
     604  while(minCUSize > 1)
     605  {
     606    minCUSize >>= 1;
     607    log2MinCUSize++;
     608  }
     609
     610  m_cSPS.setLog2MinCodingBlockSize(log2MinCUSize);
     611  m_cSPS.setLog2DiffMaxMinCodingBlockSize(m_cSPS.getMaxCUDepth()-g_uiAddCUDepth);
    603612#if SVC_EXTENSION
    604613  m_cSPS.setSPSId         ( m_iSPSIdCnt       );
    … …  
    618627
    619628  m_cSPS.setMaxTrSize   ( 1 << m_uiQuadtreeTULog2MaxSize );
    620  
     629#if !L0034_COMBINED_LIST_CLEANUP
    621630  m_cSPS.setUseLComb    ( m_bUseLComb           );
     631#endif
    622632 
    623633  Int i;
    … …  
    763773  m_cPPS.setOutputFlagPresentFlag( false );
    764774  m_cPPS.setSignHideFlag(getSignHideFlag());
     775#if L0386_DB_METRIC
     776  if ( getDeblockingFilterMetric() )
     777  {
     778    m_cPPS.setDeblockingFilterControlPresentFlag (true);
     779    m_cPPS.setDeblockingFilterOverrideEnabledFlag(true);
     780    m_cPPS.setPicDisableDeblockingFilterFlag(false);
     781    m_cPPS.setDeblockingFilterBetaOffsetDiv2(0);
     782    m_cPPS.setDeblockingFilterTcOffsetDiv2(0);
     783  }
     784  else
     785  {
    765786  m_cPPS.setDeblockingFilterControlPresentFlag (m_DeblockingFilterControlPresent );
     787  }
     788#else
     789  m_cPPS.setDeblockingFilterControlPresentFlag (m_DeblockingFilterControlPresent );
     790#endif
    766791  m_cPPS.setLog2ParallelMergeLevelMinus2   (m_log2ParallelMergeLevelMinus2 );
    767792  m_cPPS.setCabacInitPresentFlag(CABAC_INIT_PRESENT_FLAG);
    … …  
    10361061}
    10371062
     1063#if L0208_SOP_DESCRIPTION_SEI
     1064Int TEncTop::getReferencePictureSetIdxForSOP(TComSlice* slice, Int POCCurr, Int GOPid )
     1065{
     1066  int rpsIdx = GOPid;
     1067
     1068  for(Int extraNum=m_iGOPSize; extraNum<m_extraRPSs+m_iGOPSize; extraNum++)
     1069  {   
     1070    if(m_uiIntraPeriod > 0 && getDecodingRefreshType() > 0)
     1071    {
     1072      Int POCIndex = POCCurr%m_uiIntraPeriod;
     1073      if(POCIndex == 0)
     1074      {
     1075        POCIndex = m_uiIntraPeriod;
     1076      }
     1077      if(POCIndex == m_GOPList[extraNum].m_POC)
     1078      {
     1079        rpsIdx = extraNum;
     1080      }
     1081    }
     1082    else
     1083    {
     1084      if(POCCurr==m_GOPList[extraNum].m_POC)
     1085      {
     1086        rpsIdx = extraNum;
     1087      }
     1088    }
     1089  }
     1090
     1091  return rpsIdx;
     1092}
     1093#endif
     1094
    10381095Void  TEncTop::xInitPPSforTiles()
    10391096{

  • branches/SHM-2.0-dev/source/Lib/TLibEncoder/TEncTop.h

    r125 r133  
    192192  TComPPS*                getPPS                () { return  &m_cPPS;                 }
    193193  Void selectReferencePictureSet(TComSlice* slice, Int POCCurr, Int GOPid );
     194#if L0208_SOP_DESCRIPTION_SEI
     195  Int getReferencePictureSetIdxForSOP(TComSlice* slice, Int POCCurr, Int GOPid );
     196#endif
    194197  TComScalingList*        getScalingList        () { return  &m_scalingList;         }
    195198#if SVC_EXTENSION

  • branches/SHM-2.0-dev/source/Lib/TLibEncoder/WeightPredAnalysis.cpp

    r125 r133  
    235235        Int offset = (Int)( ((currDC<<log2Denom) - ((Int64)weight * refDC) + (Int64)realOffset) >> realLog2Denom );
    236236
    237         // Chroma offset range limination
     237        // Chroma offset range limitation
    238238        if(comp)
    239239        {
    240           Int shift = 1 << (g_bitDepthC - 1);
    241           Int pred = ( shift - ( ( shift*weight)>>(log2Denom) ) );
     240          Int pred = ( 128 - ( ( 128*weight)>>(log2Denom) ) );
    242241          Int deltaOffset = Clip3( -512, 511, (offset - pred) );    // signed 10bit
    243242          offset = Clip3( -128, 127, (deltaOffset + pred) );        // signed 8bit
     243        }
     244        // Luma offset range limitation
     245        else
     246        {
     247          offset = Clip3( -128, 127, offset);
    244248        }
    245249
Note: See TracChangeset for help on using the changeset viewer.