Changeset 296 in 3DVCSoftware for trunk/source/Lib/TLibDecoder


Ignore:
Timestamp:
20 Feb 2013, 22:07:43 (11 years ago)
Author:
tech
Message:

Reintegrated branch 5.1-dev0 rev. 295.

Location:
trunk/source/Lib/TLibDecoder
Files:
17 edited

Legend:

Unmodified
Added
Removed
  • trunk/source/Lib/TLibDecoder/NALread.cpp

    r210 r296  
    124124  assert(forbidden_zero_bit == 0);
    125125
    126 #if NAL_REF_FLAG
    127126  nalu.m_nalRefFlag  = (bs.read(1) != 0 );
    128127  nalu.m_nalUnitType = (NalUnitType) bs.read(6);
    129 #else
    130   nalu.m_nalRefIDC   = (NalRefIdc) bs.read(2);
    131   nalu.m_nalUnitType = (NalUnitType) bs.read(5);
    132 #endif
    133128
    134129#if QC_MVHEVC_B0046
     
    137132  nalu.m_temporalId = bs.read(3) - 1;
    138133#else
    139 #if H0388
    140134  nalu.m_temporalId = bs.read(3);
    141135 //  unsigned reserved_one_5bits = bs.read(5);
     
    147141  nalu.m_isDepth  = bs.read(1);
    148142#endif
    149 #if H0566_TLA
    150143  if ( nalu.m_temporalId )
    151144  {
     
    157150  }
    158151#endif
    159 #else
    160   switch (nalu.m_nalUnitType)
    161   {
    162   case NAL_UNIT_CODED_SLICE:
    163   case NAL_UNIT_CODED_SLICE_IDR:
    164 #if H0566_TLA
    165 #if !QC_REM_IDV_B0046
    166   case NAL_UNIT_CODED_SLICE_IDV:
    167 #endif
    168   case NAL_UNIT_CODED_SLICE_CRA:
    169   case NAL_UNIT_CODED_SLICE_TLA:
    170 #else
    171   case NAL_UNIT_CODED_SLICE_CDR:
    172 #endif
    173     {
    174       nalu.m_temporalId = bs.read(3);
    175 #if VIDYO_VPS_INTEGRATION
    176       nalu.m_layerId    = bs.read(5) - 1;
    177 #else
    178       nalu.m_OutputFlag = bs.read(1);
    179   //    unsigned reserved_one_4bits = bs.read(4);
    180   //    assert(reserved_one_4bits == 1);
    181       nalu.m_viewId   = bs.read(3)-1;
    182       nalu.m_isDepth  = bs.read(1);
    183 #endif
    184 
    185 #if H0566_TLA
    186       if (nalu.m_temporalId == 0)
    187       {
    188 #if QC_REM_IDV_B0046
    189         assert(nalu.m_nalUnitType == NAL_UNIT_CODED_SLICE || nalu.m_nalUnitType == NAL_UNIT_CODED_SLICE_CRA || nalu.m_nalUnitType == NAL_UNIT_CODED_SLICE_IDR);
    190 #else
    191         assert(nalu.m_nalUnitType == NAL_UNIT_CODED_SLICE || nalu.m_nalUnitType == NAL_UNIT_CODED_SLICE_CRA || nalu.m_nalUnitType == NAL_UNIT_CODED_SLICE_IDR || nalu.m_nalUnitType == NAL_UNIT_CODED_SLICE_IDV );
    192 #endif
    193       }
    194       else
    195       {
    196         assert(nalu.m_nalUnitType == NAL_UNIT_CODED_SLICE || nalu.m_nalUnitType == NAL_UNIT_CODED_SLICE_TLA);
    197       }
    198 #endif
    199     }
    200     break;
    201   default:
    202     nalu.m_temporalId = 0;
    203     nalu.m_OutputFlag = true;
    204     break;
    205   }
    206 #endif
    207 #endif
    208152}
    209153//! \}
  • trunk/source/Lib/TLibDecoder/TDecBinCoder.h

    r56 r296  
    5454  virtual Void  start             ()                                          = 0;
    5555  virtual Void  finish            ()                                          = 0;
    56 #if OL_FLUSH
    5756  virtual Void  flush            ()                                           = 0;
    58 #endif
    5957
    6058  virtual Void  decodeBin         ( UInt& ruiBin, ContextModel& rcCtxModel )  = 0;
     
    6462 
    6563  virtual Void  resetBac          ()                                          = 0;
    66 #if BURST_IPCM
    6764  virtual Void  decodeNumSubseqIPCM( Int& numSubseqIPCM )                  = 0;
    68 #endif
    6965  virtual Void  decodePCMAlignBits()                                          = 0;
    7066  virtual Void  xReadPCMCode      ( UInt uiLength, UInt& ruiCode)              = 0;
  • trunk/source/Lib/TLibDecoder/TDecBinCoderCABAC.cpp

    r56 r296  
    6565TDecBinCABAC::start()
    6666{
    67 #if !OL_FLUSH || OL_FLUSH_ALIGN
     67#if OL_FLUSH_ALIGN
    6868  assert( m_pcTComBitstream->getNumBitsUntilByteAligned() == 0 );
    6969#endif
     
    7272  m_bitsNeeded = -8;
    7373  m_uiValue    = m_pcTComBitstream->readByte() << 8;
    74 #if OL_FLUSH && !OL_FLUSH_ALIGN
     74#if !OL_FLUSH_ALIGN
    7575  m_uiLastByte = m_pcTComBitstream->readByte();
    7676  m_uiValue   |= m_uiLastByte;
     
    8585}
    8686
    87 #if OL_FLUSH
    8887Void
    8988TDecBinCABAC::flush()
     
    108107#endif // OL_FLUSH_ALIGN
    109108}
    110 #endif // OL_FLUSH
    111109
    112110/**
     
    122120  m_uiValue   = pcTDecBinCABAC->m_uiValue;
    123121  m_bitsNeeded= pcTDecBinCABAC->m_bitsNeeded;
    124 #if OL_FLUSH && !OL_FLUSH_ALIGN
     122#if !OL_FLUSH_ALIGN
    125123  m_uiLastByte= pcTDecBinCABAC->m_uiLastByte;
    126124#endif
     
    152150    {
    153151      m_bitsNeeded = -8;
    154 #if OL_FLUSH && !OL_FLUSH_ALIGN
     152#if !OL_FLUSH_ALIGN
    155153      m_uiLastByte = m_pcTComBitstream->readByte();
    156154      m_uiValue += m_uiLastByte;   
     
    173171    if ( m_bitsNeeded >= 0 )
    174172    {
    175 #if OL_FLUSH && !OL_FLUSH_ALIGN
     173#if !OL_FLUSH_ALIGN
    176174      m_uiLastByte = m_pcTComBitstream->readByte();
    177175      m_uiValue += m_uiLastByte << m_bitsNeeded;
     
    192190  {
    193191    m_bitsNeeded = -8;
    194 #if OL_FLUSH && !OL_FLUSH_ALIGN
     192#if !OL_FLUSH_ALIGN
    195193    m_uiLastByte = m_pcTComBitstream->readByte();
    196194    m_uiValue += m_uiLastByte;
     
    215213  while ( numBins > 8 )
    216214  {
    217 #if OL_FLUSH && !OL_FLUSH_ALIGN
     215#if !OL_FLUSH_ALIGN
    218216    m_uiLastByte = m_pcTComBitstream->readByte();
    219217    m_uiValue = ( m_uiValue << 8 ) + ( m_uiLastByte << ( 8 + m_bitsNeeded ) );
     
    241239  if ( m_bitsNeeded >= 0 )
    242240  {
    243 #if OL_FLUSH && !OL_FLUSH_ALIGN
     241#if !OL_FLUSH_ALIGN
    244242    m_uiLastByte = m_pcTComBitstream->readByte();
    245243    m_uiValue += m_uiLastByte << m_bitsNeeded;
     
    285283      {
    286284        m_bitsNeeded = -8;
    287 #if OL_FLUSH && !OL_FLUSH_ALIGN
     285#if !OL_FLUSH_ALIGN
    288286        m_uiLastByte = m_pcTComBitstream->readByte();
    289287        m_uiValue += m_uiLastByte;   
     
    306304}
    307305
    308 #if BURST_IPCM
    309306/** Decode subsequent_pcm_num.
    310307 * \param numSubseqIPCM
     
    323320    {
    324321      m_bitsNeeded = -8;
    325 #if OL_FLUSH && !OL_FLUSH_ALIGN
     322#if !OL_FLUSH_ALIGN
    326323      m_uiLastByte = m_pcTComBitstream->readByte();
    327324      m_uiValue += m_uiLastByte;
     
    342339  numSubseqIPCM --;
    343340}
    344 #endif
    345341
    346342/** Decode PCM alignment zero bits.
  • trunk/source/Lib/TLibDecoder/TDecBinCoderCABAC.h

    r56 r296  
    5656  Void  start             ();
    5757  Void  finish            ();
    58 #if OL_FLUSH
    5958  Void  flush             ();
    60 #endif
    6159 
    6260  Void  decodeBin         ( UInt& ruiBin, ContextModel& rcCtxModel );
     
    6664 
    6765  Void  resetBac          ();
    68 #if BURST_IPCM
    6966  Void  decodeNumSubseqIPCM( Int& numSubseqIPCM ) ;
    70 #endif
    7167  Void  decodePCMAlignBits();
    7268  Void  xReadPCMCode      ( UInt uiLength, UInt& ruiCode );
     
    8278  UInt                m_uiRange;
    8379  UInt                m_uiValue;
    84 #if OL_FLUSH && !OL_FLUSH_ALIGN
     80#if !OL_FLUSH_ALIGN
    8581  UInt                m_uiLastByte;
    8682#endif
  • trunk/source/Lib/TLibDecoder/TDecCAVLC.cpp

    r210 r296  
    169169  assert(m_pcBitstream->getNumBitsLeft() == 8); /* rsbp_trailing_bits */
    170170}
    171 #if RPS_IN_SPS
    172171void TDecCavlc::parseShortTermRefPicSet( TComSPS* sps, TComReferencePictureSet* rps, Int idx )
    173 #else
    174 void TDecCavlc::parseShortTermRefPicSet( TComPPS* pcPPS, TComReferencePictureSet* rps, Int idx )
    175 #endif
    176172{
    177173  UInt code;
     
    184180    Int rIdx =  idx - 1 - code;
    185181    assert (rIdx <= idx && rIdx >= 0);
    186 #if RPS_IN_SPS
    187182    TComReferencePictureSet*   rpsRef = sps->getRPSList()->getReferencePictureSet(rIdx);
    188 #else
    189     TComReferencePictureSet*   rpsRef = pcPPS->getRPSList()->getReferencePictureSet(rIdx);
    190 #endif
    191183    Int k = 0, k0 = 0, k1 = 0;
    192184    READ_CODE(1, bit, "delta_rps_sign"); // delta_RPS_sign
     
    265257  READ_FLAG(uiCode, "aps_scaling_list_data_present_flag"); aps->setScalingListEnabled( (uiCode==1)?true:false );
    266258  READ_FLAG(uiCode, "aps_deblocking_filter_flag");         aps->setLoopFilterOffsetInAPS( (uiCode==1)?true:false );
    267 #if !SAO_UNIT_INTERLEAVING
    268   READ_FLAG(uiCode, "aps_sample_adaptive_offset_flag");    aps->setSaoEnabled( (uiCode==1)?true:false );
    269 #endif
    270 #if !LCU_SYNTAX_ALF
    271   READ_FLAG(uiCode, "aps_adaptive_loop_filter_flag");      aps->setAlfEnabled( (uiCode==1)?true:false );
    272 #endif
    273259  if(aps->getScalingListEnabled())
    274260  {
    275261    parseScalingList( aps->getScalingList() );
    276262  }
    277 #if DBL_CONTROL
    278263  if(aps->getLoopFilterOffsetInAPS())
    279264  {
    280265    xParseDblParam( aps );   
    281266  }
    282 #endif
    283 #if SAO_UNIT_INTERLEAVING
    284267  READ_FLAG(uiCode, "aps_sao_interleaving_flag");      aps->setSaoInterleavingFlag( (uiCode==1)?true:false );
    285268  if(!aps->getSaoInterleavingFlag())
    286269  {
    287270    READ_FLAG(uiCode, "aps_sample_adaptive_offset_flag");      aps->setSaoEnabled( (uiCode==1)?true:false );
    288 #endif
    289271  if(aps->getSaoEnabled())
    290272  {
     
    292274    xParseSaoParam( aps->getSaoParam() );
    293275  }
    294 #if SAO_UNIT_INTERLEAVING
    295   }
    296 #endif
    297 #if LCU_SYNTAX_ALF
     276  }
    298277  READ_FLAG(uiCode, "aps_adaptive_loop_filter_flag");      aps->setAlfEnabled( (uiCode==1)?true:false );
    299 #endif
    300278  if(aps->getAlfEnabled())
    301279  {
    302 #if !LCU_SYNTAX_ALF
    303     aps->getAlfParam()->alf_flag = 1;
    304 #endif
    305280    xParseAlfParam( aps->getAlfParam());
    306281  }
     
    316291}
    317292
    318 #if DBL_CONTROL
    319293Void  TDecCavlc::xParseDblParam       ( TComAPS* aps )
    320294{
     
    333307  }
    334308}
    335 #endif
    336309/** parse SAO parameters
    337310 * \param pSaoParam
     
    341314  UInt uiSymbol;
    342315
    343 #if SAO_UNIT_INTERLEAVING
    344316  int i,j, compIdx;
    345317  int numCuInWidth;
     
    393365    }
    394366  }
    395 #else
    396   if (pSaoParam->bSaoFlag[0])
    397   {
    398     xParseSaoSplitParam (pSaoParam, 0, 0);
    399     xParseSaoOffsetParam(pSaoParam, 0, 0);
    400     READ_FLAG (uiSymbol, "sao_flag_cb");
    401     pSaoParam->bSaoFlag[1] = uiSymbol? true:false;
    402     if (pSaoParam->bSaoFlag[1])
    403     {
    404       xParseSaoSplitParam (pSaoParam, 0, 1);
    405       xParseSaoOffsetParam(pSaoParam, 0, 1);
    406     }
    407 
    408     READ_FLAG (uiSymbol, "sao_flag_cr");
    409     pSaoParam->bSaoFlag[2] = uiSymbol? true:false;
    410     if (pSaoParam->bSaoFlag[2])
    411     {
    412       xParseSaoSplitParam (pSaoParam, 0, 2);
    413       xParseSaoOffsetParam(pSaoParam, 0, 2);
    414     }
    415   }
    416 #endif
    417 }
    418 #if SAO_UNIT_INTERLEAVING
     367}
    419368/** copy SAO parameter
    420369 * \param dst 
     
    584533}
    585534
    586 #else
    587 /** Decode quadtree split flag
    588  * \param  pSaoParam, iPartIdx
    589  */
    590 Void TDecCavlc::xParseSaoSplitParam(SAOParam* pSaoParam, Int iPartIdx, Int iYCbCr)
    591 {
    592   UInt uiSymbol;
    593   SAOQTPart*  pSaoPart = NULL;
    594   pSaoPart= &(pSaoParam->psSaoPart[iYCbCr][iPartIdx]);
    595 
    596   if(pSaoPart->PartLevel < pSaoParam->iMaxSplitLevel)
    597   {
    598     READ_FLAG (uiSymbol, "sao_split_flag");
    599     pSaoPart->bSplit = uiSymbol? true:false;
    600     if(pSaoPart->bSplit)
    601     {
    602       for (Int i=0;i<NUM_DOWN_PART;i++)
    603       {
    604         xParseSaoSplitParam(pSaoParam, pSaoPart->DownPartsIdx[i], iYCbCr);
    605       }
    606     }
    607   }
    608   else
    609   {
    610     pSaoPart->bSplit = false;
    611   }
    612 }
    613 
    614 /** Decode SAO for one partition
    615  * \param  pSaoParam, iPartIdx
    616  */
    617 Void TDecCavlc::xParseSaoOffsetParam(SAOParam* pSaoParam, Int iPartIdx, Int iYCbCr)
    618 {
    619   UInt uiSymbol;
    620   Int iSymbol; 
    621   SAOQTPart*  pSaoPart = NULL;
    622   pSaoPart = &(pSaoParam->psSaoPart[iYCbCr][iPartIdx]);
    623 
    624   static Int iTypeLength[MAX_NUM_SAO_TYPE] = {
    625     SAO_EO_LEN,
    626     SAO_EO_LEN,
    627     SAO_EO_LEN,
    628     SAO_EO_LEN,
    629     SAO_BO_LEN,
    630     SAO_BO_LEN
    631   }; 
    632   if(!pSaoPart->bSplit)
    633   {
    634     READ_UVLC (uiSymbol, "sao_type_idx");
    635     if (uiSymbol)
    636     {
    637       pSaoPart->iBestType = uiSymbol-1;
    638       pSaoPart->bEnableFlag = true;
    639     }
    640     else
    641     {
    642       pSaoPart->iBestType = -1;
    643       pSaoPart->bEnableFlag = false;
    644     }
    645 
    646     if (pSaoPart->bEnableFlag)
    647     {
    648       pSaoPart->iLength = iTypeLength[pSaoPart->iBestType];
    649       for(Int i=0; i< pSaoPart->iLength; i++)
    650       {
    651         READ_SVLC (iSymbol, "sao_offset");
    652         pSaoPart->iOffset[i] = iSymbol;
    653       }
    654     }
    655     return;
    656   }
    657 
    658   //split
    659   if (pSaoPart->PartLevel < pSaoParam->iMaxSplitLevel)
    660   {
    661     for(Int i=0;i<NUM_DOWN_PART;i++)
    662     {
    663       xParseSaoOffsetParam(pSaoParam, pSaoPart->DownPartsIdx[i], iYCbCr);
    664     }
    665   }
    666 }
    667 #endif
    668 
    669 #if LCU_SYNTAX_ALF
     535
    670536Void TDecCavlc::xParseAlfParam(AlfParamSet* pAlfParamSet, Bool bSentInAPS, Int firstLCUAddr, Bool acrossSlice, Int numLCUInWidth, Int numLCUInHeight)
    671537{
     
    931797}
    932798
    933 #endif
    934799
    935800Void TDecCavlc::xParseAlfParam(ALFParam* pAlfParam)
     
    937802  UInt uiSymbol;
    938803  Int iSymbol;
    939 #if ALF_SINGLE_FILTER_SHAPE
    940804  Int sqrFiltLengthTab[NUM_ALF_FILTER_SHAPE] = {ALF_FILTER_LEN};
    941 #else
    942   Int sqrFiltLengthTab[2] = { 9, 9};
    943 #endif
    944 
    945 #if LCU_SYNTAX_ALF
     805
    946806  switch(pAlfParam->componentID)
    947807  {
     
    961821  case ALF_Y:
    962822    {
    963 #endif
    964823  pAlfParam->filters_per_group = 0;
    965824  memset (pAlfParam->filterPattern, 0 , sizeof(Int)*NO_VAR_BINS);
    966 #if !LCU_SYNTAX_ALF
    967   READ_FLAG (uiSymbol, "alf_region_adaptation_flag");
    968   pAlfParam->alf_pcr_region_flag = uiSymbol; 
    969 #endif
    970 #if ALF_SINGLE_FILTER_SHAPE 
    971825  pAlfParam->filter_shape = 0;
    972 #else
    973   READ_UVLC (uiSymbol, "alf_length_luma_minus_5_div2");
    974   pAlfParam->filter_shape = uiSymbol;
    975 #endif
    976826  pAlfParam->num_coeff = sqrFiltLengthTab[pAlfParam->filter_shape];
    977827
     
    989839  {
    990840    pAlfParam->filters_per_group = 1;
    991 #if LCU_SYNTAX_ALF
    992 #if ALF_16_BA_GROUPS
    993841    Int numMergeFlags = 16;
    994 #else
    995     Int numMergeFlags = 15;
    996 #endif
    997 #else
    998 #if ALF_16_BA_GROUPS
    999     Int numMergeFlags = 16;
    1000 #else
    1001     Int numMergeFlags = pAlfParam->alf_pcr_region_flag ? 16 : 15;
    1002 #endif
    1003 #endif
    1004842    for (Int i=1; i<numMergeFlags; i++)
    1005843    {
     
    1021859  }
    1022860
    1023 #if ALF_SINGLE_FILTER_SHAPE
    1024861  Int minScanVal = MIN_SCAN_POS_CROSS;
    1025 #else
    1026   Int minScanVal = (pAlfParam->filter_shape == ALF_STAR5x5) ? 0: MIN_SCAN_POS_CROSS;
    1027 #endif
    1028862
    1029863  // Determine maxScanVal
     
    1036870
    1037871  // Golomb parameters
    1038 #if LCU_SYNTAX_ALF
    1039872  if( pAlfParam->filters_per_group > 1 )
    1040873  {
    1041 #endif
    1042874  READ_UVLC (uiSymbol, "alf_min_kstart_minus1");
    1043875  pAlfParam->minKStart = 1 + uiSymbol;
     
    1051883    kMin = pAlfParam->kMinTab[scanPos];
    1052884  }
    1053 #if LCU_SYNTAX_ALF
    1054   }
    1055 #endif
     885  }
    1056886
    1057887  Int scanPos;
     
    1061891    {
    1062892      scanPos = pDepthInt[i] - 1;
    1063 #if LCU_SYNTAX_ALF
    1064893      Int k = (pAlfParam->filters_per_group == 1) ? kTableTabShapes[ALF_CROSS9x7_SQUARE3x3][i] : pAlfParam->kMinTab[scanPos];
    1065894      pAlfParam->coeffmulti[idx][i] = xGolombDecode(k);
    1066 #else
    1067       pAlfParam->coeffmulti[idx][i] = xGolombDecode(pAlfParam->kMinTab[scanPos]);
    1068 #endif
    1069     }
    1070   }
    1071 #if LCU_SYNTAX_ALF
     895    }
     896  }
    1072897    }
    1073898    break;
     
    1079904    }
    1080905  }
    1081 #else
    1082   // filter parameters for chroma
    1083   READ_UVLC (uiSymbol, "alf_chroma_idc");
    1084   pAlfParam->chroma_idc = uiSymbol;
    1085 
    1086   if(pAlfParam->chroma_idc)
    1087   {
    1088 
    1089 #if ALF_SINGLE_FILTER_SHAPE
    1090     pAlfParam->filter_shape_chroma  = 0;
    1091 #else
    1092     READ_UVLC (uiSymbol, "alf_length_chroma_minus_5_div2");
    1093 
    1094     pAlfParam->filter_shape_chroma = uiSymbol;
    1095 #endif
    1096     pAlfParam->num_coeff_chroma = sqrFiltLengthTab[pAlfParam->filter_shape_chroma];
    1097     // filter coefficients for chroma
    1098     for(Int pos=0; pos<pAlfParam->num_coeff_chroma; pos++)
    1099     {
    1100       READ_SVLC (iSymbol, "alf_coeff_chroma");
    1101       pAlfParam->coeff_chroma[pos] = iSymbol;
    1102     }
    1103   }
    1104 #endif
    1105906}
    1106907
     
    1137938}
    1138939
    1139 #if TILES_OR_ENTROPY_SYNC_IDC
    1140940Void TDecCavlc::parsePPS(TComPPS* pcPPS, ParameterSetManagerDecoder *parameterSet)
    1141 #else
    1142 Void TDecCavlc::parsePPS(TComPPS* pcPPS)
    1143 #endif
    1144941{
    1145942#if ENC_DEC_TRACE 
     
    1150947  Int   iCode;
    1151948
    1152 #if !RPS_IN_SPS
    1153   TComRPSList* rpsList = pcPPS->getRPSList();
    1154 #endif
    1155949  READ_UVLC( uiCode, "pic_parameter_set_id");                      pcPPS->setPPSId (uiCode);
    1156950  READ_UVLC( uiCode, "seq_parameter_set_id");                      pcPPS->setSPSId (uiCode);
    1157951
    1158 #if MULTIBITS_DATA_HIDING
    1159952  READ_FLAG ( uiCode, "sign_data_hiding_flag" ); pcPPS->setSignHideFlag( uiCode );
    1160953  if( pcPPS->getSignHideFlag() )
     
    1162955    READ_CODE( 4, uiCode, "sign_hiding_threshold"); pcPPS->setTSIG(uiCode);
    1163956  }
    1164 #endif
    1165957
    1166958#if CABAC_INIT_FLAG
    1167959  READ_FLAG( uiCode,   "cabac_init_present_flag" );            pcPPS->setCabacInitPresentFlag( uiCode ? true : false );
    1168 #endif
    1169 #if !RPS_IN_SPS
    1170   // RPS is put before entropy_coding_mode_flag
    1171   // since entropy_coding_mode_flag will probably be removed from the WD
    1172   TComReferencePictureSet*      pcRPS;
    1173 
    1174   READ_UVLC( uiCode, "num_short_term_ref_pic_sets" );
    1175   rpsList->create(uiCode);
    1176 
    1177   for(Int i=0; i< rpsList->getNumberOfReferencePictureSets(); i++)
    1178   {
    1179     pcRPS = rpsList->getReferencePictureSet(i);
    1180     parseShortTermRefPicSet(pcPPS,pcRPS,i);
    1181   }
    1182   READ_FLAG( uiCode, "long_term_ref_pics_present_flag" );          pcPPS->setLongTermRefsPresent(uiCode);
    1183960#endif
    1184961  // entropy_coding_mode_flag
     
    1187964  if (pcPPS->getEntropyCodingMode())
    1188965  {
    1189 #if !WPP_SIMPLIFICATION
    1190     READ_UVLC( uiCode, "entropy_coding_synchro" );                 pcPPS->setEntropyCodingSynchro( uiCode );
    1191     READ_FLAG( uiCode, "cabac_istate_reset" );                     pcPPS->setCabacIstateReset( uiCode ? true : false );
    1192 #endif
    1193 #if !TILES_OR_ENTROPY_SYNC_IDC
    1194 #if !WPP_SIMPLIFICATION
    1195     if ( pcPPS->getEntropyCodingSynchro() )
    1196 #endif
    1197     {
    1198       READ_UVLC( uiCode, "num_substreams_minus1" );                pcPPS->setNumSubstreams(uiCode+1);
    1199     }
    1200 #endif
    1201   }
    1202 #if !H0566_TLA
    1203   READ_UVLC( uiCode, "num_temporal_layer_switching_point_flags" ); pcPPS->setNumTLayerSwitchingFlags( uiCode );
    1204   for ( UInt i = 0; i < pcPPS->getNumTLayerSwitchingFlags(); i++ )
    1205   {
    1206     READ_FLAG( uiCode, "temporal_layer_switching_point_flag" );    pcPPS->setTLayerSwitchingFlag( i, uiCode > 0 ? true : false );
    1207   }
    1208 #endif
     966  }
    1209967 
    1210968  // num_ref_idx_l0_default_active_minus1
     
    1241999//printf("TDecCavlc::parsePPS():\tm_bUseWeightPred=%d\tm_uiBiPredIdc=%d\n", pcPPS->getUseWP(), pcPPS->getWPBiPredIdc());
    12421000
    1243 #if H0388
    12441001  READ_FLAG( uiCode, "output_flag_present_flag" );
    12451002  pcPPS->setOutputFlagPresentFlag( uiCode==1 );
    1246 #endif
    1247 
    1248 #if TILES_OR_ENTROPY_SYNC_IDC
     1003
    12491004  if(parameterSet->getPrefetchedSPS(pcPPS->getSPSId())->getTilesOrEntropyCodingSyncIdc()==1)
    12501005  {
    1251 #endif
    12521006    READ_FLAG ( uiCode, "tile_info_present_flag" );
    12531007    pcPPS->setColumnRowInfoPresent(uiCode);
     
    12901044      Int iNumColTilesMinus1 = (pcPPS->getColumnRowInfoPresent() == 1)?(pcPPS->getNumColumnsMinus1()):(pcPPS->getSPS()->getNumColumnsMinus1());
    12911045      Int iNumRowTilesMinus1 = (pcPPS->getColumnRowInfoPresent() == 1)?(pcPPS->getNumColumnsMinus1()):(pcPPS->getSPS()->getNumRowsMinus1());
    1292 #if !REMOVE_TILE_DEPENDENCE
    1293       pcPPS->setTileBoundaryIndependenceIdr( 1 ); //default
    1294 #endif
    12951046      pcPPS->setLFCrossTileBoundaryFlag(true); //default
    12961047
    12971048      if(iNumColTilesMinus1 !=0 || iNumRowTilesMinus1 !=0)
    12981049      {
    1299 #if !REMOVE_TILE_DEPENDENCE
    1300         READ_FLAG ( uiCode, "tile_boundary_independence_flag" ); 
    1301         pcPPS->setTileBoundaryIndependenceIdr( uiCode );
    1302 
    1303         if(pcPPS->getTileBoundaryIndependenceIdr() == 1)
    1304         {
    1305 #endif
    13061050          READ_FLAG ( uiCode, "loop_filter_across_tile_flag" ); 
    13071051          pcPPS->setLFCrossTileBoundaryFlag( (uiCode == 1)?true:false );
    1308 #if !REMOVE_TILE_DEPENDENCE
    1309         }
    1310 #endif
    1311       }
    1312     }
    1313 #if TILES_OR_ENTROPY_SYNC_IDC
     1052      }
     1053    }
    13141054  }
    13151055  else if(parameterSet->getPrefetchedSPS(pcPPS->getSPSId())->getTilesOrEntropyCodingSyncIdc()==2)
     
    13171057    READ_UVLC( uiCode, "num_substreams_minus1" );                pcPPS->setNumSubstreams(uiCode+1);
    13181058  }
    1319 #endif
    1320 
    1321 #if DBL_CONTROL
     1059
    13221060  READ_FLAG( uiCode, "deblocking_filter_control_present_flag" );
    13231061  pcPPS->setDeblockingFilterControlPresent( uiCode ? true : false);
    1324 #endif
    1325 #if PARALLEL_MERGE
    13261062  READ_UVLC( uiCode, "log2_parallel_merge_level_minus2");
    13271063  assert(uiCode == LOG2_PARALLEL_MERGE_LEVEL_MINUS2);
    13281064  pcPPS->setLog2ParallelMergeLevelMinus2 (uiCode);
    1329 #endif
    13301065
    13311066  READ_FLAG( uiCode, "pps_extension_flag");
     
    14581193      }
    14591194    }
     1195#if INTER_VIEW_VECTOR_SCALING_C0115
     1196    READ_FLAG( uiCode,  "inter_view_vector_scaling_flag" );    pcVPS->setIVScalingFlag( uiCode ? true:false);
     1197#endif
    14601198  }
    14611199 
     
    14681206#endif
    14691207#endif
    1470 #if HHI_MPI
     1208#if HHI_MPI || OL_QTLIMIT_PREDCODING_B0068
    14711209Void TDecCavlc::parseSPS(TComSPS* pcSPS, Bool bIsDepth)
    14721210#else
     
    14931231  READ_UVLC (    uiCode, "pic_width_in_luma_samples" );          pcSPS->setPicWidthInLumaSamples ( uiCode    );
    14941232  READ_UVLC (    uiCode, "pic_height_in_luma_samples" );         pcSPS->setPicHeightInLumaSamples( uiCode    );
    1495 #if PIC_CROPPING
    14961233  READ_FLAG(     uiCode, "pic_cropping_flag");                   pcSPS->setPicCroppingFlag ( uiCode ? true : false );
    14971234  if (uiCode != 0)
     
    15021239    READ_UVLC(   uiCode, "pic_crop_bottom_offset" );             pcSPS->setPicCropBottomOffset( uiCode );
    15031240  }
    1504 #endif
    15051241
    15061242#if FULL_NBIT
     
    15221258#endif
    15231259
    1524 #if H0736_AVC_STYLE_QP_RANGE
    15251260  pcSPS->setQpBDOffsetY( (Int) (6*uiCode) );
    1526 #endif
    15271261
    15281262  g_uiBASE_MAX  = ((1<<(g_uiBitDepth))-1);
     
    15341268#endif
    15351269  READ_UVLC( uiCode,    "bit_depth_chroma_minus8" );
    1536 #if H0736_AVC_STYLE_QP_RANGE
    15371270  pcSPS->setQpBDOffsetC( (Int) (6*uiCode) );
    1538 #endif
    15391271
    15401272  READ_FLAG( uiCode, "pcm_enabled_flag" ); pcSPS->setUsePCM( uiCode ? true : false );
     
    15511283
    15521284  READ_UVLC( uiCode,    "log2_max_pic_order_cnt_lsb_minus4" );   pcSPS->setBitsForPOC( 4 + uiCode );
    1553 #if H0567_DPB_PARAMETERS_PER_TEMPORAL_LAYER
    15541285  for(UInt i=0; i <= pcSPS->getMaxTLayers()-1; i++)
    15551286  {
     
    15611292    pcSPS->setMaxLatencyIncrease( uiCode, i );
    15621293  }
    1563 #else
    1564   READ_UVLC( uiCode,    "max_num_ref_pics" );                    pcSPS->setMaxNumberOfReferencePictures(uiCode);
    1565   READ_UVLC( uiCode,    "num_reorder_frames" );                  pcSPS->setNumReorderFrames(uiCode);
    1566   READ_UVLC ( uiCode, "max_dec_frame_buffering");
    1567   pcSPS->setMaxDecFrameBuffering( uiCode );
    1568   READ_UVLC ( uiCode, "max_latency_increase");
    1569   pcSPS->setMaxLatencyIncrease( uiCode );
    1570 #endif
    1571 
    1572 #if H0412_REF_PIC_LIST_RESTRICTION
     1294
    15731295  READ_FLAG( uiCode, "restricted_ref_pic_lists_flag" );
    15741296  pcSPS->setRestrictedRefPicListsFlag( uiCode );
     
    15821304    pcSPS->setListsModificationPresentFlag(true);
    15831305  }
    1584 #endif
    15851306  READ_UVLC( uiCode, "log2_min_coding_block_size_minus3" );
    15861307  UInt log2MinCUSize = uiCode + 3;
     
    16251346  READ_FLAG( uiCode, "sample_adaptive_offset_enabled_flag" );       pcSPS->setUseSAO ( uiCode ? true : false ); 
    16261347  READ_FLAG( uiCode, "adaptive_loop_filter_enabled_flag" );         pcSPS->setUseALF ( uiCode ? true : false );
    1627 #if LCU_SYNTAX_ALF
    16281348  if(pcSPS->getUseALF())
    16291349  {
    16301350    READ_FLAG( uiCode, "alf_coef_in_slice_flag" );      pcSPS->setUseALFCoefInSlice ( uiCode ? true : false );
    16311351  }
    1632 #endif
    16331352  if( pcSPS->getUsePCM() )
    16341353  {
     
    16391358
    16401359
    1641 #if RPS_IN_SPS
    16421360  TComRPSList* rpsList = pcSPS->getRPSList();
    16431361  TComReferencePictureSet* rps;
     
    16521370  }
    16531371  READ_FLAG( uiCode, "long_term_ref_pics_present_flag" );          pcSPS->setLongTermRefsPresent(uiCode);
    1654 #endif
    1655 #if !PIC_CROPPING
    1656   //!!!KS: Syntax not in WD !!!
    1657 
    1658   xReadUvlc ( uiCode ); pcSPS->setPadX        ( uiCode    );
    1659   xReadUvlc ( uiCode ); pcSPS->setPadY        ( uiCode    );
    1660 #endif
    16611372 
    16621373  // AMVP mode for each depth (AM_NONE or AM_EXPL)
     
    16671378  }
    16681379
    1669 #if TILES_WPP_ENTRY_POINT_SIGNALLING
    16701380  READ_CODE(2, uiCode, "tiles_or_entropy_coding_sync_idc");         pcSPS->setTilesOrEntropyCodingSyncIdc(uiCode);
    1671 #endif
    1672 
    1673 #if TILES_OR_ENTROPY_SYNC_IDC
     1381
    16741382  if(pcSPS->getTilesOrEntropyCodingSyncIdc() == 1)
    16751383  {
    1676 #endif
    16771384    READ_UVLC ( uiCode, "num_tile_columns_minus1" );
    16781385    pcSPS->setNumColumnsMinus1( uiCode ); 
     
    17011408      free(rowHeight); 
    17021409    }
    1703 #if !REMOVE_TILE_DEPENDENCE
    1704     pcSPS->setTileBoundaryIndependenceIdr( 1 ); //default
    1705 #endif
    17061410    pcSPS->setLFCrossTileBoundaryFlag(true); //default
    17071411
    17081412    if( pcSPS->getNumColumnsMinus1() !=0 || pcSPS->getNumRowsMinus1() != 0)
    17091413    {
    1710 #if !REMOVE_TILE_DEPENDENCE
    1711       READ_FLAG ( uiCode, "tile_boundary_independence_flag" ); 
    1712       pcSPS->setTileBoundaryIndependenceIdr( uiCode );
    1713       if(pcSPS->getTileBoundaryIndependenceIdr() == 1)
    1714       {
    1715 #endif
    17161414        READ_FLAG ( uiCode, "loop_filter_across_tile_flag" ); 
    17171415        pcSPS->setLFCrossTileBoundaryFlag( (uiCode==1)?true:false);
    1718 #if !REMOVE_TILE_DEPENDENCE
    1719       }
    1720 #endif
    1721     }
    1722 #if TILES_OR_ENTROPY_SYNC_IDC
    1723   }
    1724 #endif
     1416    }
     1417  }
    17251418  READ_FLAG( uiCode, "sps_extension_flag");
    17261419#if !QC_MVHEVC_B0046
     
    17991492      pcSPS->setPredDepthMapGeneration( 0, false );
    18001493#endif
    1801 #if HHI_INTER_VIEW_RESIDUAL_PRED
     1494#if H3D_IVRP
    18021495    pcSPS->setMultiviewResPredMode  ( 0 );
    18031496#endif
     
    18141507        pcSPS->setPredDepthMapGeneration( uiCode, true );
    18151508#endif
    1816 #if HHI_INTER_VIEW_RESIDUAL_PRED
     1509#if H3D_IVRP
    18171510      pcSPS->setMultiviewResPredMode  ( 0 );
    18181511#endif
     
    18411534#if DEPTH_MAP_GENERATION
    18421535        UInt uiPredDepthMapGeneration = 0, uiPdmPrecision = 0;
    1843 #if HHI_INTER_VIEW_MOTION_PRED
     1536#if H3D_IVMP
    18441537        UInt uiMultiviewMvPredMode = 0;
    18451538#endif
    1846 #if HHI_INTER_VIEW_RESIDUAL_PRED
     1539#if H3D_IVRP
    18471540      UInt uiMultiviewResPredMode = 0;
    18481541#endif
     
    18561549            READ_SVLC( iCode, "Pdm_offset" );   m_aaiTempPdmOffset       [ uiViewId ][ uiBaseId ] = iCode;
    18571550          }
    1858 #if HHI_INTER_VIEW_MOTION_PRED
     1551#if H3D_IVMP
    18591552          READ_UVLC( uiMultiviewMvPredMode, "multi_view_mv_pred_mode" );
    18601553#endif
    1861 #if HHI_INTER_VIEW_RESIDUAL_PRED
     1554#if H3D_IVRP
    18621555          READ_FLAG( uiMultiviewResPredMode, "multi_view_residual_pred_mode" );
    18631556#endif
    18641557        }
    1865 #if HHI_INTER_VIEW_MOTION_PRED
     1558#if H3D_IVMP
    18661559        pcSPS->setPredDepthMapGeneration( uiViewId, false, uiPredDepthMapGeneration, uiMultiviewMvPredMode, uiPdmPrecision, m_aaiTempPdmScaleNomDelta, m_aaiTempPdmOffset );
    18671560#else
     
    18691562#endif
    18701563#endif
    1871 #if HHI_INTER_VIEW_RESIDUAL_PRED
     1564#if H3D_IVRP
    18721565      pcSPS->setMultiviewResPredMode  ( uiMultiviewResPredMode );
    18731566#endif
     
    18911584}
    18921585
    1893 #if LCU_SYNTAX_ALF
     1586#if MTK_DEPTH_MERGE_TEXTURE_CANDIDATE_C0137
     1587Void TDecCavlc::parseSliceHeader (TComSlice*& rpcSlice, ParameterSetManagerDecoder *parameterSetManager, AlfCUCtrlInfo &alfCUCtrl, AlfParamSet& alfParamSet, bool isDepth)
     1588#else
    18941589Void TDecCavlc::parseSliceHeader (TComSlice*& rpcSlice, ParameterSetManagerDecoder *parameterSetManager, AlfCUCtrlInfo &alfCUCtrl, AlfParamSet& alfParamSet)
    1895 #else
    1896 Void TDecCavlc::parseSliceHeader (TComSlice*& rpcSlice, ParameterSetManagerDecoder *parameterSetManager, AlfCUCtrlInfo &alfCUCtrl)
    18971590#endif
    18981591{
     
    19271620  {
    19281621    UInt uiCodeTmp = 0;
    1929     if ( rpcSlice->getSPS()->getViewId() && !rpcSlice->getSPS()->isDepth() )
     1622    if ( rpcSlice->getSPS()->getViewId()
     1623#if !LGE_ILLUCOMP_DEPTH_C0046
     1624        && !rpcSlice->getSPS()->isDepth()
     1625#endif
     1626        )
    19301627    {
    19311628      READ_FLAG (uiCodeTmp, "applying IC flag");
     
    19771674    rpcSlice->setSPS(sps);
    19781675    rpcSlice->setPPS(pps);
    1979 #if H0388
    19801676    if( pps->getOutputFlagPresentFlag() )
    19811677    {
     
    19871683      rpcSlice->setPicOutputFlag( true );
    19881684    }
    1989 #endif
    19901685#if QC_REM_IDV_B0046
    19911686#if !QC_MVHEVC_B0046
     
    20541749        {
    20551750          rps = rpcSlice->getLocalRPS();
    2056 #if RPS_IN_SPS
    20571751          parseShortTermRefPicSet(sps,rps, sps->getRPSList()->getNumberOfReferencePictureSets());
    2058 #else
    2059           parseShortTermRefPicSet(pps,rps, pps->getRPSList()->getNumberOfReferencePictureSets());
    2060 #endif
    20611752          rpcSlice->setRPS(rps);
    20621753        }
    20631754        else // use reference to short-term reference picture set in PPS
    20641755        {
    2065 #if RPS_IN_SPS
    20661756          READ_UVLC( uiCode, "short_term_ref_pic_set_idx"); rpcSlice->setRPS(sps->getRPSList()->getReferencePictureSet(uiCode));
    2067 #else
    2068           READ_UVLC( uiCode, "short_term_ref_pic_set_idx"); rpcSlice->setRPS(pps->getRPSList()->getReferencePictureSet(uiCode));
    2069 #endif
    20701757          rps = rpcSlice->getRPS();
    20711758        }
    2072 #if RPS_IN_SPS
    20731759        if(sps->getLongTermRefsPresent())
    2074 #else
    2075         if(pps->getLongTermRefsPresent())
    2076 #endif
    20771760        {
    20781761          Int offset = rps->getNumberOfNegativePictures()+rps->getNumberOfPositivePictures();
    20791762          READ_UVLC( uiCode, "num_long_term_pics");             rps->setNumberOfLongtermPictures(uiCode);
    20801763          Int prev = 0;
    2081 #if LTRP_MULT
    20821764          Int prevMsb=0;
    20831765          Int prevDeltaPocLt=0;
    2084 #endif
    20851766          for(Int j=rps->getNumberOfLongtermPictures()+offset-1 ; j > offset-1; j--)
    20861767          {
     
    20881769            prev += uiCode;
    20891770
    2090 #if LTRP_MULT
    20911771            READ_FLAG(uiCode,"delta_poc_msb_present_flag");
    20921772            Int decDeltaPOCMsbPresent=uiCode;
     
    21091789            else
    21101790            {
    2111 #endif
    21121791              rps->setPOC(j,rpcSlice->getPOC()-prev);         
    21131792              rps->setDeltaPOC(j,-(Int)prev);
    2114 #if LTRP_MULT
    21151793            }
    21161794            prevDeltaPocLt=prev;
    2117 #endif
    21181795            READ_FLAG( uiCode, "used_by_curr_pic_lt_flag");     rps->setUsed(j,uiCode);
    21191796          }
     
    21341811      if (sps->getUseSAO())
    21351812      {
    2136 #if SAO_UNIT_INTERLEAVING
    21371813        READ_FLAG(uiCode, "slice_sao_interleaving_flag");        rpcSlice->setSaoInterleavingFlag(uiCode);
    2138 #endif
    21391814        READ_FLAG(uiCode, "slice_sample_adaptive_offset_flag");  rpcSlice->setSaoEnabledFlag((Bool)uiCode);
    2140 #if SAO_UNIT_INTERLEAVING
    21411815        if (rpcSlice->getSaoEnabledFlag() && rpcSlice->getSaoInterleavingFlag())
    21421816        {
     
    21491823          rpcSlice->setSaoEnabledFlagCr(0);
    21501824        }
    2151 #endif
    21521825      }
    21531826      READ_UVLC (    uiCode, "aps_id" );  rpcSlice->setAPSId(uiCode);
     
    21771850    if( !rpcSlice->isIntra() )
    21781851    {
    2179 #if H0412_REF_PIC_LIST_RESTRICTION
    21801852#if QC_MVHEVC_B0046
    21811853    if( !rpcSlice->getViewId() || !rpcSlice->getSPS()->getListsModificationPresentFlag() )
     
    21881860      else
    21891861      {
    2190 #endif
    21911862        READ_FLAG( uiCode, "ref_pic_list_modification_flag_l0" ); refPicListModification->setRefPicListModificationFlagL0( uiCode ? 1 : 0 );
    2192 #if H0412_REF_PIC_LIST_RESTRICTION
    2193       }
    2194 #endif
     1863      }
    21951864     
    21961865      if(refPicListModification->getRefPicListModificationFlagL0())
     
    21981867        uiCode = 0;
    21991868        Int i = 0;
    2200 #if H0137_0138_LIST_MODIFICATION
    22011869        Int NumPocTotalCurr = rpcSlice->getNumPocTotalCurrMvc();
    22021870        if ( NumPocTotalCurr > 1 )
     
    22211889          }
    22221890        }
    2223 #else
    2224         Int list_modification_idc = 0;
    2225         while(list_modification_idc != 3) 
    2226         {
    2227           READ_UVLC( uiCode, "list_modification_idc" ); refPicListModification->setListIdcL0(i, uiCode );
    2228           list_modification_idc = uiCode;
    2229           if(uiCode != 3)
    2230           {
    2231             READ_UVLC( uiCode, "ref_pic_set_idx" ); refPicListModification->setRefPicSetIdxL0(i, uiCode );
    2232           }
    2233           i++;
    2234         }
    2235         refPicListModification->setNumberOfRefPicListModificationsL0(i-1);
    2236 #endif
    2237       }
    2238 #if !H0137_0138_LIST_MODIFICATION
    2239       else
    2240       {
    2241         refPicListModification->setNumberOfRefPicListModificationsL0(0);
    2242       }
    2243 #endif
     1891      }
    22441892    }
    22451893    else
    22461894    {
    22471895      refPicListModification->setRefPicListModificationFlagL0(0);
    2248 #if !H0137_0138_LIST_MODIFICATION
    2249       refPicListModification->setNumberOfRefPicListModificationsL0(0);
    2250 #endif
    22511896    }
    22521897    if(rpcSlice->isInterB())
    22531898    {
    2254 #if H0412_REF_PIC_LIST_RESTRICTION
    22551899#if QC_MVHEVC_B0046
    22561900    if( !rpcSlice->getViewId() || !rpcSlice->getSPS()->getListsModificationPresentFlag() )
     
    22631907      else
    22641908      {
    2265 #endif
    22661909        READ_FLAG( uiCode, "ref_pic_list_modification_flag_l1" ); refPicListModification->setRefPicListModificationFlagL1( uiCode ? 1 : 0 );
    2267 #if H0412_REF_PIC_LIST_RESTRICTION
    2268       }
    2269 #endif
     1910      }
    22701911      if(refPicListModification->getRefPicListModificationFlagL1())
    22711912      {
    22721913        uiCode = 0;
    22731914        Int i = 0;
    2274 #if H0137_0138_LIST_MODIFICATION
    22751915        Int NumPocTotalCurr = rpcSlice->getNumPocTotalCurrMvc();
    22761916        if ( NumPocTotalCurr > 1 )
     
    22951935          }
    22961936        }
    2297 #else
    2298         Int list_modification_idc = 0;
    2299         while(list_modification_idc != 3) 
    2300         {
    2301           READ_UVLC( uiCode, "list_modification_idc" ); refPicListModification->setListIdcL1(i, uiCode );
    2302           list_modification_idc = uiCode;
    2303           if(uiCode != 3)
    2304           {
    2305             READ_UVLC( uiCode, "ref_pic_set_idx" ); refPicListModification->setRefPicSetIdxL1(i, uiCode );
    2306           }
    2307           i++;
    2308         }
    2309         refPicListModification->setNumberOfRefPicListModificationsL1(i-1);
    2310 #endif
    2311       }
    2312 #if !H0137_0138_LIST_MODIFICATION
    2313       else
    2314       {
    2315         refPicListModification->setNumberOfRefPicListModificationsL1(0);
    2316       }
    2317 #endif
     1937      }
    23181938    } 
    23191939    else
    23201940    {
    23211941      refPicListModification->setRefPicListModificationFlagL1(0);
    2322 #if !H0137_0138_LIST_MODIFICATION
    2323       refPicListModification->setNumberOfRefPicListModificationsL1(0);
    2324 #endif
    23251942    }
    23261943  }
     
    23401957      READ_UVLC( uiCode, "num_ref_idx_lc_active_minus1" );      rpcSlice->setNumRefIdx( REF_PIC_LIST_C, uiCode + 1 );
    23411958     
    2342 #if H0412_REF_PIC_LIST_RESTRICTION
    23431959#if QC_MVHEVC_B0046
    23441960    if( rpcSlice->getViewId() && rpcSlice->getSPS()->getListsModificationPresentFlag() )
     
    23471963#endif
    23481964      {
    2349 #endif
    23501965        READ_FLAG( uiCode, "ref_pic_list_modification_flag_lc" ); rpcSlice->setRefPicListModificationFlagLC( uiCode ? 1 : 0 );
    23511966        if(uiCode)
     
    23551970            READ_FLAG( uiCode, "pic_from_list_0_flag" );
    23561971            rpcSlice->setListIdFromIdxOfLC(i, uiCode);
    2357 #if H0137_0138_LIST_MODIFICATION
    23581972          if (((rpcSlice->getListIdFromIdxOfLC(i) == REF_PIC_LIST_0) && (rpcSlice->getNumRefIdx( REF_PIC_LIST_0 ) == 1)) || ((rpcSlice->getListIdFromIdxOfLC(i) == REF_PIC_LIST_1) && (rpcSlice->getNumRefIdx( REF_PIC_LIST_1 ) == 1)) )
    23591973          {
     
    23641978            READ_UVLC( uiCode, "ref_idx_list_curr" );
    23651979          }
    2366 #else
    2367             READ_UVLC( uiCode, "ref_idx_list_curr" );
    2368 #endif
    23691980            rpcSlice->setRefIdxFromIdxOfLC(i, uiCode);
    23701981            rpcSlice->setRefIdxOfLC((RefPicList)rpcSlice->getListIdFromIdxOfLC(i), rpcSlice->getRefIdxFromIdxOfLC(i), i);
    23711982          }
    23721983        }
    2373 #if H0412_REF_PIC_LIST_RESTRICTION
    23741984      }
    23751985      else
     
    23771987        rpcSlice->setRefPicListModificationFlagLC(false);
    23781988      }
    2379 #endif
    23801989    }
    23811990    else
     
    23901999  }
    23912000 
    2392 #if H0111_MVD_L1_ZERO
    23932001  if (rpcSlice->isInterB())
    23942002  {
    23952003    READ_FLAG( uiCode, "mvd_l1_zero_flag" );       rpcSlice->setMvdL1ZeroFlag( (uiCode ? true : false) );
    23962004  }
    2397 #endif
    23982005
    23992006#if CABAC_INIT_FLAG
     
    24212028    rpcSlice->setSliceQp (26 + pps->getPicInitQPMinus26() + iCode);
    24222029
    2423 #if H0736_AVC_STYLE_QP_RANGE
    24242030    assert( rpcSlice->getSliceQp() >= -sps->getQpBDOffsetY() );
    24252031    assert( rpcSlice->getSliceQp() <=  51 );
    2426 #endif
    2427 
    2428 #if DBL_CONTROL
     2032
    24292033    if (rpcSlice->getPPS()->getDeblockingFilterControlPresent())
    24302034    {
     
    24362040        rpcSlice->setInheritDblParamFromAPS(0);
    24372041      }
    2438 #else
    2439     READ_FLAG ( uiCode, "inherit_dbl_param_from_APS_flag" ); rpcSlice->setInheritDblParamFromAPS(uiCode ? 1 : 0);
    2440 #endif
    24412042      if(!rpcSlice->getInheritDblParamFromAPS())
    24422043      {
     
    24482049        }
    24492050      }
    2450 #if DBL_CONTROL
    24512051   }
    2452 #endif
    24532052    if ( rpcSlice->getSliceType() == B_SLICE )
    24542053    {
     
    24902089  }
    24912090
    2492 #if ( HHI_MPI || HHI_INTER_VIEW_MOTION_PRED )
    2493   #if ( HHI_MPI && HHI_INTER_VIEW_MOTION_PRED )
     2091#if ( HHI_MPI || H3D_IVMP )
     2092  #if ( HHI_MPI && H3D_IVMP )
    24942093  const int iExtraMergeCandidates = ( sps->getUseMVI() || sps->getMultiviewMvPredMode() ) ? 1 : 0;
    24952094  #elif HHI_MPI
    24962095  const int iExtraMergeCandidates = sps->getUseMVI() ? 1 : 0;
     2096  #elif MTK_DEPTH_MERGE_TEXTURE_CANDIDATE_C0137
     2097  const int iExtraMergeCandidates = (  (isDepth || sps->getMultiviewMvPredMode()) ) ? 1 : 0;   
    24972098  #else
    24982099  const int iExtraMergeCandidates = sps->getMultiviewMvPredMode() ? 1 : 0;
     
    25182119
    25192120      Int uiNumCUsInFrame = uiNumLCUsInWidth* uiNumLCUsInHeight;
    2520 #if LCU_SYNTAX_ALF
    25212121      if(sps->getUseALFCoefInSlice())
    25222122      {
     
    25312131      if(!sps->getUseALFCoefInSlice())
    25322132      {
    2533 #endif
    25342133      xParseAlfCuControlParam(alfCUCtrl, uiNumCUsInFrame);
    2535 #if LCU_SYNTAX_ALF
    2536       }
    2537 #endif
     2134      }
    25382135
    25392136    }
     
    25442141  if (!bEntropySlice)
    25452142  {
    2546 #if !REMOVE_TILE_DEPENDENCE
    2547     if (sps->getTileBoundaryIndependenceIdr())
    2548     {   
    2549 #endif
    25502143    xReadCode(1, uiCode); // read flag indicating if tile markers transmitted
    25512144    rpcSlice->setTileMarkerFlag( uiCode );
    2552 #if !REMOVE_TILE_DEPENDENCE
    2553     }
    2554 #endif
    2555   }
    2556 
    2557 #if TILES_WPP_ENTRY_POINT_SIGNALLING
     2145  }
     2146
    25582147  Int tilesOrEntropyCodingSyncIdc = rpcSlice->getSPS()->getTilesOrEntropyCodingSyncIdc();
    25592148  UInt *entryPointOffset          = NULL;
     
    26162205    delete [] entryPointOffset;
    26172206  }
    2618 #else
    2619 #if WPP_SIMPLIFICATION
    2620   if (pps->getNumSubstreams() > 1)
    2621 #else
    2622   if (pps->getEntropyCodingSynchro())
    2623 #endif
    2624   {
    2625     UInt uiNumSubstreams = pps->getNumSubstreams();
    2626     rpcSlice->allocSubstreamSizes(uiNumSubstreams);
    2627     UInt *puiSubstreamSizes = rpcSlice->getSubstreamSizes();
    2628 
    2629     for (UInt ui = 0; ui+1 < uiNumSubstreams; ui++)
    2630     {
    2631       xReadCode(2, uiCode);
    2632      
    2633       switch ( uiCode )
    2634       {
    2635       case 0:
    2636         xReadCode(8,  uiCode);
    2637         break;
    2638       case 1:
    2639         xReadCode(16, uiCode);
    2640         break;
    2641       case 2:
    2642         xReadCode(24, uiCode);
    2643         break;
    2644       case 3:
    2645         xReadCode(32, uiCode);
    2646         break;
    2647       default:
    2648         printf("Error in parseSliceHeader\n");
    2649         exit(-1);
    2650         break;
    2651       }
    2652       puiSubstreamSizes[ui] = uiCode;
    2653     }
    2654   }
    2655 #endif
    26562207
    26572208  if (!bEntropySlice)
    26582209  {
    26592210    // Reading location information
    2660 #if !REMOVE_TILE_DEPENDENCE
    2661     if (sps->getTileBoundaryIndependenceIdr())
    2662     {   
    2663 #endif
    2664 #if !TILES_WPP_ENTRY_POINT_SIGNALLING
    2665       xReadCode(1, uiCode); // read flag indicating if location information signaled in slice header
    2666       Bool bTileLocationInformationInSliceHeaderFlag = (uiCode)? true : false;
    2667 
    2668       if (bTileLocationInformationInSliceHeaderFlag)
    2669       {
    2670         // location count
    2671         xReadCode(5, uiCode); // number of tiles for which location information signaled
    2672         rpcSlice->setTileLocationCount ( uiCode + 1 );
    2673 
    2674         xReadCode(5, uiCode); // number of bits used by diff
    2675         Int iBitsUsedByDiff = uiCode + 1;
    2676 
    2677         // read out tile start location
    2678         Int iLastSize = 0;
    2679         for (UInt uiIdx=0; uiIdx<rpcSlice->getTileLocationCount(); uiIdx++)
    2680         {
    2681           Int iAbsDiff, iCurSize, iCurDiff;
    2682           if (uiIdx==0)
    2683           {
    2684             xReadCode(iBitsUsedByDiff-1, uiCode); iAbsDiff  = uiCode;
    2685             rpcSlice->setTileLocation( uiIdx, iAbsDiff );
    2686             iCurDiff  = iAbsDiff;
    2687             iLastSize = iAbsDiff;
    2688           }
    2689           else
    2690           {
    2691             xReadCode(1, uiCode); // read sign
    2692             Int iSign = (uiCode) ? -1 : +1;
    2693 
    2694             xReadCode(iBitsUsedByDiff-1, uiCode); iAbsDiff  = uiCode;
    2695             iCurDiff  = (iSign) * iAbsDiff;
    2696             iCurSize  = iLastSize + iCurDiff;
    2697             iLastSize = iCurSize;
    2698             rpcSlice->setTileLocation( uiIdx, rpcSlice->getTileLocation( uiIdx-1 ) + iCurSize ); // calculate byte location
    2699           }
    2700         }
    2701       }
    2702 #endif
    27032211
    27042212      // read out trailing bits
    27052213    m_pcBitstream->readOutTrailingBits();
    2706 #if !REMOVE_TILE_DEPENDENCE
    2707     }
    2708 #endif
    27092214  }
    27102215  return;
     
    27672272#endif
    27682273
    2769 #if HHI_INTER_VIEW_MOTION_PRED
     2274#if H3D_IVMP
    27702275Void TDecCavlc::parseMVPIdx( Int& riMVPIdx, Int iAMVPCands )
    27712276#else
     
    28012306Void TDecCavlc::parseIPCMInfo( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
    28022307{
    2803 #if BURST_IPCM
    28042308  assert(0);
    2805 #else
    2806   UInt uiSymbol;
    2807 
    2808   xReadFlag( uiSymbol );
    2809 
    2810   if ( uiSymbol )
    2811   {
    2812     Bool bIpcmFlag   = true;
    2813 
    2814     xReadPCMAlignZero();
    2815 
    2816     pcCU->setPartSizeSubParts  ( SIZE_2Nx2N, uiAbsPartIdx, uiDepth );
    2817     pcCU->setSizeSubParts      ( g_uiMaxCUWidth>>uiDepth, g_uiMaxCUHeight>>uiDepth, uiAbsPartIdx, uiDepth );
    2818     pcCU->setIPCMFlagSubParts  ( bIpcmFlag, uiAbsPartIdx, uiDepth );
    2819 
    2820     UInt uiMinCoeffSize = pcCU->getPic()->getMinCUWidth()*pcCU->getPic()->getMinCUHeight();
    2821     UInt uiLumaOffset   = uiMinCoeffSize*uiAbsPartIdx;
    2822     UInt uiChromaOffset = uiLumaOffset>>2;
    2823 
    2824     Pel* piPCMSample;
    2825     UInt uiWidth;
    2826     UInt uiHeight;
    2827     UInt uiSampleBits;
    2828     UInt uiX, uiY;
    2829 
    2830     piPCMSample = pcCU->getPCMSampleY() + uiLumaOffset;
    2831     uiWidth = pcCU->getWidth(uiAbsPartIdx);
    2832     uiHeight = pcCU->getHeight(uiAbsPartIdx);
    2833     uiSampleBits = pcCU->getSlice()->getSPS()->getPCMBitDepthLuma();
    2834 
    2835     for(uiY = 0; uiY < uiHeight; uiY++)
    2836     {
    2837       for(uiX = 0; uiX < uiWidth; uiX++)
    2838       {
    2839         UInt uiSample;
    2840         xReadCode(uiSampleBits, uiSample);
    2841 
    2842         piPCMSample[uiX] = uiSample;
    2843       }
    2844       piPCMSample += uiWidth;
    2845     }
    2846 
    2847     piPCMSample = pcCU->getPCMSampleCb() + uiChromaOffset;
    2848     uiWidth = pcCU->getWidth(uiAbsPartIdx)/2;
    2849     uiHeight = pcCU->getHeight(uiAbsPartIdx)/2;
    2850     uiSampleBits = pcCU->getSlice()->getSPS()->getPCMBitDepthChroma();
    2851 
    2852     for(uiY = 0; uiY < uiHeight; uiY++)
    2853     {
    2854       for(uiX = 0; uiX < uiWidth; uiX++)
    2855       {
    2856         UInt uiSample;
    2857         xReadCode(uiSampleBits, uiSample);
    2858         piPCMSample[uiX] = uiSample;
    2859       }
    2860       piPCMSample += uiWidth;
    2861     }
    2862 
    2863     piPCMSample = pcCU->getPCMSampleCr() + uiChromaOffset;
    2864     uiWidth = pcCU->getWidth(uiAbsPartIdx)/2;
    2865     uiHeight = pcCU->getHeight(uiAbsPartIdx)/2;
    2866     uiSampleBits = pcCU->getSlice()->getSPS()->getPCMBitDepthChroma();
    2867 
    2868     for(uiY = 0; uiY < uiHeight; uiY++)
    2869     {
    2870       for(uiX = 0; uiX < uiWidth; uiX++)
    2871       {
    2872         UInt uiSample;
    2873         xReadCode(uiSampleBits, uiSample);
    2874         piPCMSample[uiX] = uiSample;
    2875       }
    2876       piPCMSample += uiWidth;
    2877     }
    2878   }
    2879 #endif
    28802309}
    28812310
     
    29072336Void TDecCavlc::parseDeltaQP( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
    29082337{
    2909 #if H0736_AVC_STYLE_QP_RANGE
    29102338  Int qp;
    2911 #else
    2912   UInt uiQp;
    2913 #endif
    29142339  Int  iDQp;
    29152340 
    29162341  xReadSvlc( iDQp );
    29172342
    2918 #if H0736_AVC_STYLE_QP_RANGE
    29192343  Int qpBdOffsetY = pcCU->getSlice()->getSPS()->getQpBDOffsetY();
    29202344  qp = (((Int) pcCU->getRefQP( uiAbsPartIdx ) + iDQp + 52 + 2*qpBdOffsetY )%(52+ qpBdOffsetY)) -  qpBdOffsetY;
    2921 #else
    2922   uiQp = pcCU->getRefQP( uiAbsPartIdx ) + iDQp;
    2923 #endif
    29242345
    29252346  UInt uiAbsQpCUPartIdx = (uiAbsPartIdx>>(8-(pcCU->getSlice()->getPPS()->getMaxCuDQPDepth()<<1)))<<(8-(pcCU->getSlice()->getPPS()->getMaxCuDQPDepth()<<1)) ;
    29262347  UInt uiQpCUDepth =   min(uiDepth,pcCU->getSlice()->getPPS()->getMaxCuDQPDepth()) ;
    29272348
    2928 #if H0736_AVC_STYLE_QP_RANGE
    29292349  pcCU->setQPSubParts( qp, uiAbsQpCUPartIdx, uiQpCUDepth );
    2930 #else
    2931   pcCU->setQPSubParts( uiQp, uiAbsQpCUPartIdx, uiQpCUDepth );
    2932 #endif
    29332350}
    29342351
     
    29642381}
    29652382
    2966 #if HHI_INTER_VIEW_RESIDUAL_PRED
     2383#if H3D_IVRP
    29672384Void
    29682385TDecCavlc::parseResPredFlag( TComDataCU* pcCU, Bool& rbResPredFlag, UInt uiAbsPartIdx, UInt uiDepth )
     
    33942811          READ_UVLC( code, "scaling_list_pred_matrix_id_delta");
    33952812          scalingList->setRefMatrixId (sizeId,listId,(UInt)((Int)(listId)-(code+1)));
    3396 #if SCALING_LIST
    33972813          if( sizeId > SCALING_LIST_8x8 )
    33982814          {
    33992815            scalingList->setScalingListDC(sizeId,listId,scalingList->getScalingListDC(sizeId, scalingList->getRefMatrixId (sizeId,listId)));
    34002816          }
    3401 #endif
    34022817          scalingList->processRefMatrix( sizeId, listId, scalingList->getRefMatrixId (sizeId,listId));
    34032818         
     
    34202835Void TDecCavlc::xDecodeScalingList(TComScalingList *scalingList, UInt sizeId, UInt listId)
    34212836{
    3422 #if SCALING_LIST
    34232837  Int i,coefNum = min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId]);
    34242838  Int data;
     
    34602874    }
    34612875  }
    3462 #else
    3463   Int i,coefNum = g_scalingListSize[sizeId];
    3464   Int data;
    3465   Int nextCoef = SCALING_LIST_START_VALUE;
    3466   UInt* scan  = g_auiFrameScanXY [ sizeId + 1 ];
    3467   Int *dst = scalingList->getScalingListAddress(sizeId, listId);
    3468 
    3469   for(i = 0; i < coefNum; i++)
    3470   {
    3471     READ_SVLC( data, "scaling_list_delta_coef");
    3472     nextCoef = (nextCoef + data + 256 ) % 256;
    3473     dst[scan[i]] = nextCoef;
    3474   }
    3475 #endif
    34762876}
    34772877
  • trunk/source/Lib/TLibDecoder/TDecCAVLC.h

    r210 r296  
    8282  UInt  xGetBit             ();
    8383 
    84 #if RPS_IN_SPS
    8584  void  parseShortTermRefPicSet            (TComSPS* pcSPS, TComReferencePictureSet* pcRPS, Int idx);
    86 #else
    87   void  parseShortTermRefPicSet            (TComPPS* pcPPS, TComReferencePictureSet* pcRPS, Int idx);
    88 #endif
    8985private:
    9086  TComInputBitstream*   m_pcBitstream;
     
    118114  Void  parseVPS            ( TComVPS* pcVPS );
    119115#endif
    120 #if HHI_MPI
     116#if HHI_MPI || OL_QTLIMIT_PREDCODING_B0068
    121117  Void  parseSPS            ( TComSPS* pcSPS, Bool bIsDepth );
    122118#else
    123119  Void  parseSPS            ( TComSPS* pcSPS );
    124120#endif
    125 #if TILES_OR_ENTROPY_SYNC_IDC
    126121  Void  parsePPS            ( TComPPS* pcPPS, ParameterSetManagerDecoder *parameterSet);
    127 #else
    128   Void  parsePPS            ( TComPPS* pcPPS);
    129 #endif
    130122  Void  parseSEI(SEImessages&);
    131123  Void  parseAPS            ( TComAPS* pAPS );
    132 #if LCU_SYNTAX_ALF
     124#if MTK_DEPTH_MERGE_TEXTURE_CANDIDATE_C0137
     125  Void  parseSliceHeader    ( TComSlice*& rpcSlice, ParameterSetManagerDecoder *parameterSetManager, AlfCUCtrlInfo &alfCUCtrl, AlfParamSet& alfParamSet, bool isDepth);
     126#else
    133127  Void  parseSliceHeader    ( TComSlice*& rpcSlice, ParameterSetManagerDecoder *parameterSetManager, AlfCUCtrlInfo &alfCUCtrl, AlfParamSet& alfParamSet);
    134 #else
    135   Void  parseSliceHeader    ( TComSlice*& rpcSlice, ParameterSetManagerDecoder *parameterSetManager, AlfCUCtrlInfo &alfCUCtrl );
    136128#endif
    137129  Void  parseTerminatingBit ( UInt& ruiBit );
    138130 
    139 #if HHI_INTER_VIEW_MOTION_PRED
     131#if H3D_IVMP
    140132  Void  parseMVPIdx         ( Int& riMVPIdx, Int iAMVPCands );
    141133#else
     
    149141  Void parseMergeFlag       ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, UInt uiPUIdx );
    150142  Void parseMergeIndex      ( TComDataCU* pcCU, UInt& ruiMergeIndex, UInt uiAbsPartIdx, UInt uiDepth );
    151 #if HHI_INTER_VIEW_RESIDUAL_PRED
     143#if H3D_IVRP
    152144  Void parseResPredFlag     ( TComDataCU* pcCU, Bool& rbResPredFlag, UInt uiAbsPartIdx, UInt uiDepth );
    153145#endif
     
    171163  Void readTileMarker     ( UInt& uiTileIdx, UInt uiBitsUsed );
    172164  Void updateContextTables  ( SliceType eSliceType, Int iQp ) { return; }
    173 #if OL_FLUSH
    174165  Void decodeFlush() {};
    175 #endif
    176166
    177167  Void xParsePredWeightTable ( TComSlice* pcSlice );
     
    186176#endif
    187177protected:
    188 #if DBL_CONTROL
    189178  Void  xParseDblParam       ( TComAPS* aps );
    190 #endif
    191179  Void  xParseSaoParam       ( SAOParam* pSaoParam );
    192 #if SAO_UNIT_INTERLEAVING
    193180  Void  xParseSaoOffset      (SaoLcuParam* saoLcuParam);
    194181  Void  xParseSaoUnit        (Int rx, Int ry, Int compIdx, SAOParam* saoParam, Bool& repeatedRow );
    195 #else
    196   Void  xParseSaoSplitParam  ( SAOParam* pSaoParam, Int iPartIdx, Int iYCbCr );
    197   Void  xParseSaoOffsetParam ( SAOParam* pSaoParam, Int iPartIdx, Int iYCbCr );
    198 #endif
    199 #if LCU_SYNTAX_ALF
    200182  Void  xParseAlfParam(AlfParamSet* pAlfParamSet, Bool bSentInAPS = true, Int firstLCUAddr = 0, Bool acrossSlice = true, Int numLCUInWidth= -1, Int numLCUInHeight= -1);
    201183  Void  parseAlfParamSet(AlfParamSet* pAlfParamSet, Int firstLCUAddr, Bool alfAcrossSlice);
    202184  Void  parseAlfFixedLengthRun(UInt& idx, UInt rx, UInt numLCUInWidth);
    203185  Void  parseAlfStoredFilterIdx(UInt& idx, UInt numFilterSetsInBuffer);
    204 #endif
    205186  Void  xParseAlfParam       ( ALFParam* pAlfParam );
    206187  Void  xParseAlfCuControlParam(AlfCUCtrlInfo& cAlfParam, Int iNumCUsInPic);
  • trunk/source/Lib/TLibDecoder/TDecCu.cpp

    r189 r296  
    5454  m_ppcYuvResi = NULL;
    5555  m_ppcYuvReco = NULL;
    56 #if HHI_INTER_VIEW_RESIDUAL_PRED
     56#if H3D_IVRP
    5757  m_ppcYuvResPred = NULL;
    5858#endif
     
    8282  m_ppcYuvResi = new TComYuv*[m_uiMaxDepth-1];
    8383  m_ppcYuvReco = new TComYuv*[m_uiMaxDepth-1];
    84 #if HHI_INTER_VIEW_RESIDUAL_PRED
     84#if H3D_IVRP
    8585  m_ppcYuvResPred = new TComYuv*   [m_uiMaxDepth-1];
    8686#endif
     
    9696    m_ppcYuvResi[ui] = new TComYuv;    m_ppcYuvResi[ui]->create( uiWidth, uiHeight );
    9797    m_ppcYuvReco[ui] = new TComYuv;    m_ppcYuvReco[ui]->create( uiWidth, uiHeight );
    98 #if HHI_INTER_VIEW_RESIDUAL_PRED
     98#if H3D_IVRP
    9999    m_ppcYuvResPred[ui] = new TComYuv;    m_ppcYuvResPred[ui]->create( uiWidth, uiHeight );
    100100#endif
     
    120120    m_ppcYuvResi[ui]->destroy(); delete m_ppcYuvResi[ui]; m_ppcYuvResi[ui] = NULL;
    121121    m_ppcYuvReco[ui]->destroy(); delete m_ppcYuvReco[ui]; m_ppcYuvReco[ui] = NULL;
    122 #if HHI_INTER_VIEW_RESIDUAL_PRED
     122#if H3D_IVRP
    123123    m_ppcYuvResPred[ui]->destroy(); delete m_ppcYuvResPred[ui]; m_ppcYuvResPred[ui] = NULL;
    124124#endif
     
    128128  delete [] m_ppcYuvResi; m_ppcYuvResi = NULL;
    129129  delete [] m_ppcYuvReco; m_ppcYuvReco = NULL;
    130 #if HHI_INTER_VIEW_RESIDUAL_PRED
     130#if H3D_IVRP
    131131  delete [] m_ppcYuvResPred; m_ppcYuvResPred = NULL;
    132132#endif
     
    148148  }
    149149
    150 #if BURST_IPCM
    151150  pcCU->setNumSucIPCM(0);
    152 #endif
    153151
    154152  // start from the top level CU
     
    240238  if((!bStartInCU) && ( uiRPelX < pcSlice->getSPS()->getPicWidthInLumaSamples() ) && ( uiBPelY < pcSlice->getSPS()->getPicHeightInLumaSamples() ) )
    241239  {
    242 #if BURST_IPCM
    243240    if(pcCU->getNumSucIPCM() == 0)
    244241    {
     
    252249      pcCU->setDepthSubParts( uiDepth, uiAbsPartIdx );
    253250    }
    254 #else
    255 #if HHI_MPI
    256     if( pcCU->getTextureModeDepth( uiAbsPartIdx ) == -1 || uiDepth < pcCU->getTextureModeDepth( uiAbsPartIdx ) )
    257 #endif
    258     m_pcEntropyDecoder->decodeSplitFlag( pcCU, uiAbsPartIdx, uiDepth );
    259 #endif
    260251  }
    261252  else
     
    323314
    324315  // decode CU mode and the partition size
    325 #if BURST_IPCM
    326316  if( !pcCU->getSlice()->isIntra() && pcCU->getNumSucIPCM() == 0 )
    327 #else
    328   if( !pcCU->getSlice()->isIntra() )
    329 #endif
    330317#if HHI_MPI
    331318  if( pcCU->getTextureModeDepth( uiAbsPartIdx ) == -1 )
     
    339326    m_ppcCU[uiDepth]->copyInterPredInfoFrom( pcCU, uiAbsPartIdx, REF_PIC_LIST_0 );
    340327    m_ppcCU[uiDepth]->copyInterPredInfoFrom( pcCU, uiAbsPartIdx, REF_PIC_LIST_1 );
    341 #if HHI_INTER_VIEW_MOTION_PRED
     328#if H3D_IVMP
    342329    TComMvField cMvFieldNeighbours[MRG_MAX_NUM_CANDS_MEM << 1]; // double length for mv of both lists
    343330    UChar uhInterDirNeighbours[MRG_MAX_NUM_CANDS_MEM];
     
    361348
    362349      UInt uiCurrPartNumb = pcCU->getPic()->getNumPartInCU() >> (uiDepth << 1);
     350
    363351      for( UInt ui = 0; ui < uiCurrPartNumb; ui++ )
    364352      {
    365353        const UChar uhNewDepth = max<UInt>( uiDepth, pcTextureCU->getDepth( uiAbsPartIdx + ui ) );
     354#if MERL_VSP_C0152
     355        Int vspIdx = pcTextureCU->getVSPIndex( uiAbsPartIdx + ui);
     356        pcCU->setVSPIndex( uiAbsPartIdx + ui, vspIdx);
     357#endif
    366358        pcCU->setPredictionMode( uiAbsPartIdx + ui, MODE_SKIP );
    367359        pcCU->setPartitionSize( uiAbsPartIdx + ui, SIZE_2Nx2N );
     
    370362        pcCU->setHeight( uiAbsPartIdx + ui, g_uiMaxCUHeight>>uhNewDepth );
    371363      }
     364#if LGE_ILLUCOMP_DEPTH_C0046
     365      m_pcEntropyDecoder->decodeICFlag( pcCU, uiAbsPartIdx, uiDepth );
     366#endif
    372367    }
    373368    else
    374369    {
    375370#endif
    376 #if SIMP_MRG_PRUN     
    377371    UInt uiMergeIndex = pcCU->getMergeIndex(uiAbsPartIdx);
     372#if MERL_VSP_C0152
     373    Int iVSPIndexTrue[3] = {-1, -1, -1};
     374    m_ppcCU[uiDepth]->getInterMergeCandidates( 0, 0, uiDepth, cMvFieldNeighbours, uhInterDirNeighbours, numValidMergeCand, iVSPIndexTrue, uiMergeIndex );
     375    {
     376      Int iVSPIdx = 0;
     377      Int numVspIdx;
     378      numVspIdx = 3;
     379      for (Int i = 0; i < numVspIdx; i++)
     380      {
     381        if (iVSPIndexTrue[i] == uiMergeIndex)
     382          {
     383            iVSPIdx = i+1;
     384            break;
     385          }
     386      }
     387      pcCU->setVSPIndexSubParts( iVSPIdx, uiAbsPartIdx, 0, uiDepth );  //Initialize the VSP, may change later in get InterMergeCandidates()
     388    }
     389#else
    378390    m_ppcCU[uiDepth]->getInterMergeCandidates( 0, 0, uiDepth, cMvFieldNeighbours, uhInterDirNeighbours, numValidMergeCand, uiMergeIndex );
    379 #else
    380     m_ppcCU[uiDepth]->getInterMergeCandidates( 0, 0, uiDepth, cMvFieldNeighbours, uhInterDirNeighbours, numValidMergeCand );
    381     UInt uiMergeIndex = pcCU->getMergeIndex(uiAbsPartIdx);
    382391#endif
    383392    pcCU->setInterDirSubParts( uhInterDirNeighbours[uiMergeIndex], uiAbsPartIdx, 0, uiDepth );
     
    400409    }
    401410#endif
    402 #if HHI_INTER_VIEW_RESIDUAL_PRED
     411#if H3D_IVRP && !MTK_MDIVRP_C0138
    403412    m_pcEntropyDecoder->decodeResPredFlag( pcCU, uiAbsPartIdx, uiDepth, m_ppcCU[uiDepth], 0 );
    404413#endif
     
    411420  {
    412421#endif
    413 #if BURST_IPCM
    414422  if( pcCU->getNumSucIPCM() == 0 )
    415423  {
     
    424432    pcCU->setTrIdxSubParts( 0, uiAbsPartIdx, uiDepth );
    425433  }
    426 #else
    427   m_pcEntropyDecoder->decodePredMode( pcCU, uiAbsPartIdx, uiDepth );
    428   m_pcEntropyDecoder->decodePartSize( pcCU, uiAbsPartIdx, uiDepth );
    429 #endif
    430434
    431435  if (pcCU->isIntra( uiAbsPartIdx ) && pcCU->getPartitionSize( uiAbsPartIdx ) == SIZE_2Nx2N )
     
    449453 
    450454#if LGE_ILLUCOMP_B0045
     455#if LGE_ILLUCOMP_DEPTH_C0046 && HHI_MPI
     456  if( pcCU->getTextureModeDepth( uiAbsPartIdx ) != uiDepth )
     457  {
     458#endif
    451459  m_pcEntropyDecoder->decodeICFlag( pcCU, uiAbsPartIdx, uiDepth );
    452460#endif
    453461
    454 #if HHI_INTER_VIEW_RESIDUAL_PRED
     462#if H3D_IVRP && !MTK_MDIVRP_C0138
    455463  if( !pcCU->isIntra( uiAbsPartIdx ) )
    456464  {
    457465    m_pcEntropyDecoder->decodeResPredFlag    ( pcCU, uiAbsPartIdx, uiDepth, m_ppcCU[uiDepth], 0 );
     466  }
     467#endif
     468#if LGE_ILLUCOMP_DEPTH_C0046 && HHI_MPI
    458469  }
    459470#endif
     
    467478
    468479      UInt uiCurrPartNumb = pcCU->getPic()->getNumPartInCU() >> (uiDepth << 1);
     480
    469481      for( UInt ui = 0; ui < uiCurrPartNumb; ui++ )
    470482      {
    471483        const UChar uhNewDepth = max<UInt>( uiDepth, pcTextureCU->getDepth( uiAbsPartIdx + ui ) );
     484#if MERL_VSP_C0152
     485        Int vspIdx = pcTextureCU->getVSPIndex( uiAbsPartIdx + ui);
     486        pcCU->setVSPIndex( uiAbsPartIdx + ui, vspIdx);
     487#endif
    472488        pcCU->setPredictionMode( uiAbsPartIdx + ui, MODE_INTER );
    473489        pcCU->setPartitionSize( uiAbsPartIdx + ui, SIZE_2Nx2N );
     
    476492        pcCU->setHeight( uiAbsPartIdx + ui, g_uiMaxCUHeight>>uhNewDepth );
    477493      }
    478 
     494#if LGE_ILLUCOMP_DEPTH_C0046
     495      m_pcEntropyDecoder->decodeICFlag( pcCU, uiAbsPartIdx, uiDepth );
     496#endif
    479497      if( ( ( uiDepth < pcCU->getDepth( uiAbsPartIdx ) ) && ( uiDepth < g_uiMaxCUDepth - g_uiAddCUDepth ) ) || bBoundary )
    480498      {
     
    551569  }
    552570
    553 #if BURST_IPCM
    554571  if( pcCU->getNumSucIPCM() > 0 )
    555572  {
     
    557574    return;
    558575  }
    559 #endif
    560576
    561577  ruiIsLast = xDecodeSliceEnd( pcCU, uiAbsPartIdx, uiDepth);
     
    658674 
    659675  // inter prediction
     676#if MERL_VSP_C0152
     677  m_pcPrediction->motionCompensation( pcCU, m_ppcYuvReco[uiDepth], uiAbsPartIdx );
     678#else
    660679  m_pcPrediction->motionCompensation( pcCU, m_ppcYuvReco[uiDepth] );
    661  
     680#endif
     681#if MTK_MDIVRP_C0138
     682  if (pcCU->getMergeFlag(0) && pcCU->getMergeIndex(0)==0 && pcCU->getResPredAvail(0))
     683  {
     684    m_pcPrediction->residualPrediction(pcCU, m_ppcYuvReco[uiDepth], m_ppcYuvResPred[uiDepth]);
     685  }
     686#endif
     687
    662688#if HHI_MPI
    663689  if( pcCU->getTextureModeDepth( 0 ) != -1 )
     
    665691#endif
    666692
    667 #if HHI_INTER_VIEW_RESIDUAL_PRED
     693#if H3D_IVRP && !MTK_MDIVRP_C0138
    668694  if( pcCU->getResPredFlag( 0 ) )
    669695  {
     
    695721  else
    696722  {
    697 #if HHI_INTER_VIEW_RESIDUAL_PRED
     723#if H3D_IVRP
     724#if MTK_MDIVRP_C0138
     725    if (pcCU->getMergeFlag(0) && pcCU->getMergeIndex(0)==0 && pcCU->getResPredAvail(0))
     726#else
    698727    if( pcCU->getResPredFlag( 0 ) )
     728#endif
    699729    {
    700730      m_ppcYuvReco[uiDepth]->clip( pcCU->getWidth( 0 ), pcCU->getHeight( 0 ) );
     
    765795 
    766796  //===== inverse transform =====
    767 #if H0736_AVC_STYLE_QP_RANGE
    768797  m_pcTrQuant->setQPforQuant  ( pcCU->getQP(0), !pcCU->getSlice()->getDepth(), pcCU->getSlice()->getSliceType(), TEXT_LUMA, pcCU->getSlice()->getSPS()->getQpBDOffsetY(), 0 );
    769 #else
    770   m_pcTrQuant->setQPforQuant  ( pcCU->getQP(0), !pcCU->getSlice()->getDepth(), pcCU->getSlice()->getSliceType(), TEXT_LUMA, 0 );
    771 #endif
    772798
    773799  Int scalingListType = (pcCU->isIntra(uiAbsPartIdx) ? 0 : 3) + g_eTTable[(Int)TEXT_LUMA];
     
    885911  if(eText == TEXT_CHROMA_U)
    886912  {
    887 #if H0736_AVC_STYLE_QP_RANGE
    888913    m_pcTrQuant->setQPforQuant  ( pcCU->getQP(0), !pcCU->getSlice()->getDepth(), pcCU->getSlice()->getSliceType(), eText, pcCU->getSlice()->getSPS()->getQpBDOffsetC(), pcCU->getSlice()->getPPS()->getChromaQpOffset() );
    889 #else
    890     m_pcTrQuant->setQPforQuant  ( pcCU->getQP(0), !pcCU->getSlice()->getDepth(), pcCU->getSlice()->getSliceType(), eText, pcCU->getSlice()->getPPS()->getChromaQpOffset() );
    891 #endif
    892914  }
    893915  else
    894916  {
    895 #if H0736_AVC_STYLE_QP_RANGE
    896917    m_pcTrQuant->setQPforQuant  ( pcCU->getQP(0), !pcCU->getSlice()->getDepth(), pcCU->getSlice()->getSliceType(), eText, pcCU->getSlice()->getSPS()->getQpBDOffsetC(), pcCU->getSlice()->getPPS()->getChromaQpOffset2nd() );
    897 #else
    898     m_pcTrQuant->setQPforQuant  ( pcCU->getQP(0), !pcCU->getSlice()->getDepth(), pcCU->getSlice()->getSliceType(), eText, pcCU->getSlice()->getPPS()->getChromaQpOffset2nd() );
    899 #endif
    900918  }
    901919
     
    11971215  pResi = m_ppcYuvResi[uiDepth]->getLumaAddr();
    11981216
    1199 #if H0736_AVC_STYLE_QP_RANGE
    12001217  m_pcTrQuant->setQPforQuant( pcCU->getQP( uiAbsPartIdx ), !pcCU->getSlice()->getDepth(), pcCU->getSlice()->getSliceType(), TEXT_LUMA, pcCU->getSlice()->getSPS()->getQpBDOffsetY(), 0 );
    1201 #else
    1202   m_pcTrQuant->setQPforQuant( pcCU->getQP( uiAbsPartIdx ), !pcCU->getSlice()->getDepth(), pcCU->getSlice()->getSliceType(), TEXT_LUMA, 0 );
    1203 #endif
    12041218
    12051219  m_pcTrQuant->invRecurTransformNxN ( pcCU, 0, TEXT_LUMA, pResi, 0, m_ppcYuvResi[uiDepth]->getStride(), uiWidth, uiHeight, uiLumaTrMode, 0, piCoeff );
    12061220 
    12071221  // Cb and Cr
    1208 #if H0736_AVC_STYLE_QP_RANGE
    12091222  m_pcTrQuant->setQPforQuant( pcCU->getQP( uiAbsPartIdx ), !pcCU->getSlice()->getDepth(), pcCU->getSlice()->getSliceType(), TEXT_CHROMA, pcCU->getSlice()->getSPS()->getQpBDOffsetC(), pcCU->getSlice()->getPPS()->getChromaQpOffset() );
    1210 #else
    1211   m_pcTrQuant->setQPforQuant( pcCU->getQP( uiAbsPartIdx ), !pcCU->getSlice()->getDepth(), pcCU->getSlice()->getSliceType(), TEXT_CHROMA, pcCU->getSlice()->getPPS()->getChromaQpOffset() );
    1212 #endif
    12131223
    12141224  uiWidth  >>= 1;
     
    12171227  m_pcTrQuant->invRecurTransformNxN ( pcCU, 0, TEXT_CHROMA_U, pResi, 0, m_ppcYuvResi[uiDepth]->getCStride(), uiWidth, uiHeight, uiChromaTrMode, 0, piCoeff );
    12181228
    1219 #if H0736_AVC_STYLE_QP_RANGE
    12201229  m_pcTrQuant->setQPforQuant( pcCU->getQP( uiAbsPartIdx ), !pcCU->getSlice()->getDepth(), pcCU->getSlice()->getSliceType(), TEXT_CHROMA, pcCU->getSlice()->getSPS()->getQpBDOffsetC(), pcCU->getSlice()->getPPS()->getChromaQpOffset2nd() );
    1221 #else
    1222   m_pcTrQuant->setQPforQuant( pcCU->getQP( uiAbsPartIdx ), !pcCU->getSlice()->getDepth(), pcCU->getSlice()->getSliceType(), TEXT_CHROMA, pcCU->getSlice()->getPPS()->getChromaQpOffset2nd() );
    1223 #endif
    12241230
    12251231  piCoeff = pcCU->getCoeffCr(); pResi = m_ppcYuvResi[uiDepth]->getCrAddr();
     
    13751381  Int iSumPix[2];
    13761382  memset(iSumPix, 0, sizeof(Int)*2);
    1377  
     1383#if HS_REFERENCE_SUBSAMPLE_C0154
     1384  Int subSamplePix;
     1385  if ( uiSize == 64 || uiSize == 32 )
     1386  {
     1387    subSamplePix = 2;
     1388  }
     1389  else
     1390  {
     1391    subSamplePix = 1;
     1392  }
     1393  for (Int y=0; y<uiSize; y+=subSamplePix)
     1394  {
     1395    for (Int x=0; x<uiSize; x+=subSamplePix)
     1396    {
     1397      UChar ucSegment = pMask?(UChar)pMask[x]:0;
     1398      assert( ucSegment < uiNumSegments );
     1399 
     1400      iSumDepth[ucSegment] += pOrig[x];
     1401      iSumPix[ucSegment]   += 1;
     1402    }
     1403    pOrig  += uiStride*subSamplePix;
     1404    pMask  += uiMaskStride*subSamplePix;
     1405  }
     1406#else
    13781407  for (Int y=0; y<uiSize; y++)
    13791408  {
     
    13901419    pMask  += uiMaskStride;
    13911420  }
    1392  
     1421#endif
    13931422  // compute mean for each segment
    13941423  for( UChar ucSeg = 0; ucSeg < uiNumSegments; ucSeg++ )
  • trunk/source/Lib/TLibDecoder/TDecCu.h

    r189 r296  
    6161  TComYuv**           m_ppcYuvResi;       ///< array of residual buffer
    6262  TComYuv**           m_ppcYuvReco;       ///< array of prediction & reconstruction buffer
    63 #if HHI_INTER_VIEW_RESIDUAL_PRED
     63#if H3D_IVRP
    6464  TComYuv**           m_ppcYuvResPred;    ///< residual prediction buffer
    6565#endif
    6666  TComDataCU**        m_ppcCU;            ///< CU data array
    67  
     67
    6868  // access channel
    6969  TComTrQuant*        m_pcTrQuant;
     
    8585  /// destroy internal buffers
    8686  Void  destroy                 ();
    87  
     87
    8888  /// decode CU information
    8989  Void  decodeCU                ( TComDataCU* pcCU, UInt& ruiIsLast );
  • trunk/source/Lib/TLibDecoder/TDecEntropy.cpp

    r189 r296  
    7272  pcCU->setICFlagSubParts( false , uiAbsPartIdx, 0, uiDepth );
    7373
    74   if (pcCU->isIntra(uiAbsPartIdx) || (pcCU->getSlice()->getViewId() == 0) || pcCU->getSlice()->getSPS()->isDepth())
     74  if (pcCU->isIntra(uiAbsPartIdx) || (pcCU->getSlice()->getViewId() == 0)
     75#if !LGE_ILLUCOMP_DEPTH_C0046
     76      || pcCU->getSlice()->getSPS()->isDepth()
     77#endif
     78      )
    7579  {
    7680    return;
     
    8084    return;
    8185
     86#if LGE_ILLUCOMP_DEPTH_C0046
     87  if(pcCU->isICFlagRequired(uiAbsPartIdx, uiDepth)) //This modification is not needed after integrating JCT3V-C0137
     88#else
    8289  if(pcCU->isICFlagRequired(uiAbsPartIdx))
     90#endif
    8391    m_pcEntropyDecoderIf->parseICFlag( pcCU, uiAbsPartIdx, uiDepth );
    8492}
     
    100108}
    101109
    102 #if HHI_INTER_VIEW_RESIDUAL_PRED
     110#if H3D_IVRP && !MTK_MDIVRP_C0138
    103111Void
    104112TDecEntropy::decodeResPredFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, TComDataCU* pcSubCU, UInt uiPUIdx )
     
    115123  if( bResPredAllowed )
    116124  {
    117     bResPredAvailable       = pcSubCU->getResidualSamples( uiPUIdx
    118 #if QC_SIMPLIFIEDIVRP_M24938
    119       , false
    120 #endif
    121       );
     125    bResPredAvailable       = pcSubCU->getResidualSamples( uiPUIdx , false  );
    122126  }
    123127
     
    272276
    273277#if CU_BASED_MRG_CAND_LIST
    274 #if HHI_INTER_VIEW_MOTION_PRED
     278#if H3D_IVMP
    275279  TComMvField cMvFieldNeighbours[MRG_MAX_NUM_CANDS_MEM << 1]; // double length for mv of both lists
    276280  UChar uhInterDirNeighbours[MRG_MAX_NUM_CANDS_MEM];
     
    293297  {
    294298#if !CU_BASED_MRG_CAND_LIST
    295 #if HHI_INTER_VIEW_MOTION_PRED
     299#if H3D_IVMP
    296300    TComMvField cMvFieldNeighbours[MRG_MAX_NUM_CANDS_MEM << 1]; // double length for mv of both lists
    297301    UChar uhInterDirNeighbours[MRG_MAX_NUM_CANDS_MEM];
     
    326330      else
    327331      {
    328 #if SIMP_MRG_PRUN
    329332        uiMergeIndex = pcCU->getMergeIndex(uiSubPartIdx);
    330333        pcSubCU->getInterMergeCandidates( uiSubPartIdx-uiAbsPartIdx, uiPartIdx, uiDepth, cMvFieldNeighbours, uhInterDirNeighbours, numValidMergeCand, uiMergeIndex );
    331 #else     
    332         pcSubCU->getInterMergeCandidates( uiSubPartIdx-uiAbsPartIdx, uiPartIdx, uiDepth, cMvFieldNeighbours, uhInterDirNeighbours, numValidMergeCand );
    333         uiMergeIndex = pcCU->getMergeIndex(uiSubPartIdx);
    334 #endif
    335334      }
    336335#else
    337 #if SIMP_MRG_PRUN       
    338336      UInt uiMergeIndex = pcCU->getMergeIndex(uiSubPartIdx);
     337#if MERL_VSP_C0152
     338      Int iVSPIndexTrue[3] = {-1, -1, -1};
     339      pcSubCU->getInterMergeCandidates( uiSubPartIdx-uiAbsPartIdx, uiPartIdx, uiDepth, cMvFieldNeighbours, uhInterDirNeighbours, numValidMergeCand, iVSPIndexTrue, uiMergeIndex );
     340
     341#if HHI_MPI
     342      if(pcCU->getTextureModeDepth( uiSubPartIdx ) == uiDepth)//MPI is used
     343      {
     344        TComDataCU *pcTextureCU = pcCU->getSlice()->getTexturePic()->getCU( pcCU->getAddr() );
     345        UInt uiCurrPartNumb = pcCU->getPic()->getNumPartInCU() >> (uiDepth << 1);
     346        for( UInt ui = 0; ui < uiCurrPartNumb; ui++ )
     347        {
     348          Int vspIdx = pcTextureCU->getVSPIndex( uiAbsPartIdx + ui);
     349          pcCU->setVSPIndex( uiAbsPartIdx + ui, vspIdx);
     350        }
     351      }
     352      else // MPI not used
     353#endif
     354      {
     355        Int iVSPIdx = 0;
     356        Int numVspIdx;
     357        numVspIdx = 3;
     358        for (Int i = 0; i < numVspIdx; i++)
     359        {
     360          if (iVSPIndexTrue[i] == uiMergeIndex)
     361            {
     362              iVSPIdx = i+1;
     363              break;
     364            }
     365        }
     366        pcCU->setVSPIndexSubParts( iVSPIdx, uiSubPartIdx, uiPartIdx, uiDepth );  //Initialize the VSP, may change later in get InterMergeCandidates()
     367      }
     368
     369#else
    339370      pcSubCU->getInterMergeCandidates( uiSubPartIdx-uiAbsPartIdx, uiPartIdx, uiDepth, cMvFieldNeighbours, uhInterDirNeighbours, numValidMergeCand, uiMergeIndex );
    340 #else     
    341       pcSubCU->getInterMergeCandidates( uiSubPartIdx-uiAbsPartIdx, uiPartIdx, uiDepth, cMvFieldNeighbours, uhInterDirNeighbours, numValidMergeCand );
    342       UInt uiMergeIndex = pcCU->getMergeIndex(uiSubPartIdx);
    343371#endif
    344372#endif
     
    485513  if ( (pcSubCU->getInterDir(uiPartAddr) & ( 1 << eRefList )) && (pcSubCU->getAMVPMode(uiPartAddr) == AM_EXPL) )
    486514  {
    487 #if HHI_INTER_VIEW_MOTION_PRED
     515#if H3D_IVMP
    488516    const Int iNumAMVPCands = AMVP_MAX_NUM_CANDS + ( pcSubCU->getSlice()->getSPS()->getMultiviewMvPredMode() ? 1 : 0 );
    489517    m_pcEntropyDecoderIf->parseMVPIdx( iMVPIdx, iNumAMVPCands );
     
    492520#endif
    493521  }
    494 #if SHARP_INTERVIEW_DECOUPLE_B0111
     522#if H3D_IVMP
    495523  pcSubCU->fillMvpCand(uiPartIdx, uiPartAddr, eRefList, iRefIdx, pAMVPInfo, iMVPIdx);
    496524#else
     
    509537}
    510538
    511 #if UNIFIED_TRANSFORM_TREE
    512539Void TDecEntropy::xDecodeTransform( TComDataCU* pcCU, UInt offsetLuma, UInt offsetChroma, UInt uiAbsPartIdx, UInt absTUPartIdx, UInt uiDepth, UInt width, UInt height, UInt uiTrIdx, UInt uiInnerQuadIdx, UInt& uiYCbfFront3, UInt& uiUCbfFront3, UInt& uiVCbfFront3, Bool& bCodeDQP )
    513 #else
    514 Void TDecEntropy::xDecodeTransformSubdiv( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt absTUPartIdx, UInt uiDepth, UInt uiInnerQuadIdx, UInt& uiYCbfFront3, UInt& uiUCbfFront3, UInt& uiVCbfFront3 )
    515 #endif
    516540{
    517541  UInt uiSubdiv;
    518542  const UInt uiLog2TrafoSize = g_aucConvertToBit[pcCU->getSlice()->getSPS()->getMaxCUWidth()]+2 - uiDepth;
    519543
    520 #if UNIFIED_TRANSFORM_TREE
    521544  if(uiTrIdx==0)
    522545  {
     
    532555    }
    533556  }
    534 #endif // UNIFIED_TRANSFORM_TREE
    535557  if( pcCU->getPredictionMode(uiAbsPartIdx) == MODE_INTRA && pcCU->getPartitionSize(uiAbsPartIdx) == SIZE_NxN && uiDepth == pcCU->getDepth(uiAbsPartIdx) )
    536558  {
    537559    uiSubdiv = 1;
    538560  }
    539 #if G519_TU_AMP_NSQT_HARMONIZATION
    540561  else if( (pcCU->getSlice()->getSPS()->getQuadtreeTUMaxDepthInter() == 1) && (pcCU->getPredictionMode(uiAbsPartIdx) == MODE_INTER) && ( pcCU->getPartitionSize(uiAbsPartIdx) != SIZE_2Nx2N ) && (uiDepth == pcCU->getDepth(uiAbsPartIdx)) )
    541 #else
    542   else if( (pcCU->getSlice()->getSPS()->getQuadtreeTUMaxDepthInter() == 1) && (pcCU->getPredictionMode(uiAbsPartIdx) == MODE_INTER) && ( pcCU->getPartitionSize(uiAbsPartIdx) == SIZE_2NxN || pcCU->getPartitionSize(uiAbsPartIdx) == SIZE_Nx2N) && (uiDepth == pcCU->getDepth(uiAbsPartIdx)) )
    543 #endif
    544562  {
    545563    uiSubdiv = (uiLog2TrafoSize > pcCU->getQuadtreeTULog2MinSizeInCU(uiAbsPartIdx));
     
    618636  if( uiSubdiv )
    619637  {
    620 #if UNIFIED_TRANSFORM_TREE
    621638    UInt size;
    622639    width  >>= 1;
     
    624641    size = width*height;
    625642    uiTrIdx++;
    626 #endif
    627643    ++uiDepth;
    628644    const UInt uiQPartNum = pcCU->getPic()->getNumPartInCU() >> (uiDepth << 1);
     
    640656    for( Int i = 0; i < 4; i++ )
    641657    {
    642 #if UNIFIED_TRANSFORM_TREE
    643658      UInt nsAddr = 0;
    644659      nsAddr = pcCU->getNSAbsPartIdx( uiLog2TrafoSize-1, uiAbsPartIdx, absTUPartIdx, i, uiTrDepth+1 );
    645660      xDecodeTransform( pcCU, offsetLuma, offsetChroma, uiAbsPartIdx, nsAddr, uiDepth, width, height, uiTrIdx, i, uiCurrentCbfY, uiCurrentCbfU, uiCurrentCbfV, bCodeDQP );
    646 #else
    647       UInt nsAddr = 0;
    648       nsAddr = pcCU->getNSAbsPartIdx( uiLog2TrafoSize-1, uiAbsPartIdx, absTUPartIdx, i, uiTrDepth+1 );
    649       xDecodeTransformSubdiv( pcCU, uiAbsPartIdx, nsAddr, uiDepth, i, uiCurrentCbfY, uiCurrentCbfU, uiCurrentCbfV );
    650 #endif
    651661      uiYCbf |= pcCU->getCbf( uiAbsPartIdx, TEXT_LUMA, uiLumaTrMode );
    652662      uiUCbf |= pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_U, uiChromaTrMode );
    653663      uiVCbf |= pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_V, uiChromaTrMode );
    654664      uiAbsPartIdx += uiQPartNum;
    655 #if UNIFIED_TRANSFORM_TREE
    656665      offsetLuma += size;  offsetChroma += (size>>2);
    657 #endif
    658666    }
    659667   
     
    713721      }
    714722    }
    715 #if UNIFIED_TRANSFORM_TREE
    716723    // transform_unit begin
    717724    UInt cbfY = pcCU->getCbf( uiAbsPartIdx, TEXT_LUMA    , uiTrIdx );
     
    779786    }
    780787    // transform_unit end
    781 #endif // UNIFIED_TRANSFORM_TREE
    782   }
    783 }
    784 
    785 #if !UNIFIED_TRANSFORM_TREE
    786 Void TDecEntropy::decodeTransformIdx( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
    787 {
    788   DTRACE_CABAC_VL( g_nSymbolCounter++ )
    789   DTRACE_CABAC_T( "\tdecodeTransformIdx()\tCUDepth=" )
    790   DTRACE_CABAC_V( uiDepth )
    791   DTRACE_CABAC_T( "\n" )
    792   UInt temp = 0;
    793   UInt temp1 = 0;
    794   UInt temp2 = 0;
    795   xDecodeTransformSubdiv( pcCU, uiAbsPartIdx, uiAbsPartIdx, uiDepth, 0, temp, temp1, temp2 );
    796 }
    797 #endif // UNIFIED_TRANSFORM_TREE
    798 
    799 #if UNIFIED_TRANSFORM_TREE
     788  }
     789}
     790
     791
    800792Void TDecEntropy::decodeQP          ( TComDataCU* pcCU, UInt uiAbsPartIdx )
    801793{
     
    805797  }
    806798}
    807 #else
    808 Void TDecEntropy::decodeQP          ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
    809 {
    810   if ( pcCU->getSlice()->getPPS()->getUseDQP() )
    811   {
    812     m_pcEntropyDecoderIf->parseDeltaQP( pcCU, uiAbsPartIdx, uiDepth );
    813   }
    814 }
    815 #endif
    816 
    817 #if !UNIFIED_TRANSFORM_TREE
    818 Void TDecEntropy::xDecodeCoeff( TComDataCU* pcCU, UInt uiLumaOffset, UInt uiChromaOffset, UInt uiAbsPartIdx, UInt uiDepth, UInt uiWidth, UInt uiHeight, UInt uiTrIdx, UInt uiCurrTrIdx, Bool& bCodeDQP )
    819 {
    820   UInt uiLog2TrSize = g_aucConvertToBit[ pcCU->getSlice()->getSPS()->getMaxCUWidth() >> uiDepth ] + 2;
    821   UInt uiCbfY = pcCU->getCbf( uiAbsPartIdx, TEXT_LUMA, uiTrIdx );
    822   UInt uiCbfU = pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_U, uiTrIdx );
    823   UInt uiCbfV = pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_V, uiTrIdx );
    824   if( uiLog2TrSize == 2 )
    825   {
    826     UInt uiQPDiv = pcCU->getPic()->getNumPartInCU() >> ( ( uiDepth - 1 ) << 1 );
    827     if( ( uiAbsPartIdx % uiQPDiv ) == 0 )
    828     {
    829       m_uiBakAbsPartIdx   = uiAbsPartIdx;
    830       m_uiBakChromaOffset = uiChromaOffset;
    831     }
    832     else if( ( uiAbsPartIdx % uiQPDiv ) == (uiQPDiv - 1) )
    833     {
    834       uiCbfU = pcCU->getCbf( m_uiBakAbsPartIdx, TEXT_CHROMA_U, uiTrIdx );
    835       uiCbfV = pcCU->getCbf( m_uiBakAbsPartIdx, TEXT_CHROMA_V, uiTrIdx );
    836     }
    837   }
    838 
    839   if ( uiCbfY || uiCbfU || uiCbfV )
    840   {
    841     // dQP: only for LCU
    842     if ( pcCU->getSlice()->getPPS()->getUseDQP() )
    843     {
    844       if ( bCodeDQP )
    845       {
    846         decodeQP( pcCU, uiAbsPartIdx, uiDepth);
    847         bCodeDQP = false;
    848       }
    849     }   
    850     UInt uiLumaTrMode, uiChromaTrMode;
    851     pcCU->convertTransIdx( uiAbsPartIdx, pcCU->getTransformIdx( uiAbsPartIdx ), uiLumaTrMode, uiChromaTrMode );
    852     const UInt uiStopTrMode = uiLumaTrMode;
    853    
    854     if( uiTrIdx == uiStopTrMode )
    855     {
    856       if( pcCU->getCbf( uiAbsPartIdx, TEXT_LUMA, uiTrIdx ) )
    857       {
    858         Int trWidth = uiWidth;
    859         Int trHeight = uiHeight;
    860         pcCU->getNSQTSize( uiTrIdx, uiAbsPartIdx, trWidth, trHeight );
    861         m_pcEntropyDecoderIf->parseCoeffNxN( pcCU, (pcCU->getCoeffY()+uiLumaOffset), uiAbsPartIdx, trWidth, trHeight, uiDepth, TEXT_LUMA );
    862       }
    863      
    864       uiWidth  >>= 1;
    865       uiHeight >>= 1;
    866 
    867       if( uiLog2TrSize == 2 )
    868       {
    869         UInt uiQPDiv = pcCU->getPic()->getNumPartInCU() >> ( ( uiDepth - 1 ) << 1 );
    870         if( ( uiAbsPartIdx % uiQPDiv ) == (uiQPDiv - 1) )
    871         {
    872           uiWidth  <<= 1;
    873           uiHeight <<= 1;
    874           Int trWidth = uiWidth;
    875           Int trHeight = uiHeight;
    876           pcCU->getNSQTSize( uiTrIdx-1, uiAbsPartIdx, trWidth, trHeight );
    877           if( pcCU->getCbf( m_uiBakAbsPartIdx, TEXT_CHROMA_U, uiTrIdx ) )
    878           {
    879             m_pcEntropyDecoderIf->parseCoeffNxN( pcCU, (pcCU->getCoeffCb()+m_uiBakChromaOffset), m_uiBakAbsPartIdx, trWidth, trHeight, uiDepth, TEXT_CHROMA_U );
    880           }
    881           if( pcCU->getCbf( m_uiBakAbsPartIdx, TEXT_CHROMA_V, uiTrIdx ) )
    882           {
    883             m_pcEntropyDecoderIf->parseCoeffNxN( pcCU, (pcCU->getCoeffCr()+m_uiBakChromaOffset), m_uiBakAbsPartIdx, trWidth, trHeight, uiDepth, TEXT_CHROMA_V );
    884           }
    885         }
    886       }
    887       else
    888       {
    889         Int trWidth = uiWidth;
    890         Int trHeight = uiHeight;
    891         pcCU->getNSQTSize( uiTrIdx, uiAbsPartIdx, trWidth, trHeight );
    892         if( pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_U, uiTrIdx ) )
    893         {
    894           m_pcEntropyDecoderIf->parseCoeffNxN( pcCU, (pcCU->getCoeffCb()+uiChromaOffset), uiAbsPartIdx, trWidth, trHeight, uiDepth, TEXT_CHROMA_U );
    895         }
    896         if( pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_V, uiTrIdx ) )
    897         {
    898           m_pcEntropyDecoderIf->parseCoeffNxN( pcCU, (pcCU->getCoeffCr()+uiChromaOffset), uiAbsPartIdx, trWidth, trHeight, uiDepth, TEXT_CHROMA_V );
    899         }
    900       }
    901     }
    902     else
    903     {
    904       {
    905         DTRACE_CABAC_VL( g_nSymbolCounter++ );
    906         DTRACE_CABAC_T( "\tgoing down\tdepth=" );
    907         DTRACE_CABAC_V( uiDepth );
    908         DTRACE_CABAC_T( "\ttridx=" );
    909         DTRACE_CABAC_V( uiTrIdx );
    910         DTRACE_CABAC_T( "\n" );
    911       }
    912       if( uiCurrTrIdx <= uiTrIdx )
    913       {
    914         assert(1);
    915       }
    916       UInt uiSize;
    917       uiWidth  >>= 1;
    918       uiHeight >>= 1;
    919       uiSize = uiWidth*uiHeight;
    920       uiDepth++;
    921       uiTrIdx++;
    922      
    923       UInt uiQPartNum = pcCU->getPic()->getNumPartInCU() >> (uiDepth << 1);
    924       UInt uiIdx      = uiAbsPartIdx;
    925      
    926       xDecodeCoeff( pcCU, uiLumaOffset, uiChromaOffset, uiIdx, uiDepth, uiWidth, uiHeight, uiTrIdx, uiCurrTrIdx, bCodeDQP );
    927       uiLumaOffset += uiSize;  uiChromaOffset += (uiSize>>2);  uiIdx += uiQPartNum;
    928      
    929       xDecodeCoeff( pcCU, uiLumaOffset, uiChromaOffset, uiIdx, uiDepth, uiWidth, uiHeight, uiTrIdx, uiCurrTrIdx, bCodeDQP );
    930       uiLumaOffset += uiSize;  uiChromaOffset += (uiSize>>2);  uiIdx += uiQPartNum;
    931      
    932       xDecodeCoeff( pcCU, uiLumaOffset, uiChromaOffset, uiIdx, uiDepth, uiWidth, uiHeight, uiTrIdx, uiCurrTrIdx, bCodeDQP );
    933       uiLumaOffset += uiSize;  uiChromaOffset += (uiSize>>2);  uiIdx += uiQPartNum;
    934      
    935       xDecodeCoeff( pcCU, uiLumaOffset, uiChromaOffset, uiIdx, uiDepth, uiWidth, uiHeight, uiTrIdx, uiCurrTrIdx, bCodeDQP );
    936       {
    937         DTRACE_CABAC_VL( g_nSymbolCounter++ );
    938         DTRACE_CABAC_T( "\tgoing up\n" );
    939       }
    940     }
    941   }
    942 }
    943 #endif // !UNIFIED_TRANSFORM_TREE
     799
    944800
    945801/** decode coefficients
     
    956812  UInt uiLumaOffset   = uiMinCoeffSize*uiAbsPartIdx;
    957813  UInt uiChromaOffset = uiLumaOffset>>2;
    958 #if UNIFIED_TRANSFORM_TREE
    959814  UInt temp  = 0;
    960815  UInt temp1 = 0;
    961816  UInt temp2 = 0;
    962 #else
    963   UInt uiLumaTrMode, uiChromaTrMode;
    964 #endif
    965817 
    966818#if RWTH_SDC_DLT_B0036
     
    980832  if( pcCU->isIntra(uiAbsPartIdx) )
    981833  {
    982 #if !UNIFIED_TRANSFORM_TREE
    983     decodeTransformIdx( pcCU, uiAbsPartIdx, pcCU->getDepth(uiAbsPartIdx) );
    984    
    985     pcCU->convertTransIdx( uiAbsPartIdx, pcCU->getTransformIdx(uiAbsPartIdx), uiLumaTrMode, uiChromaTrMode );
    986    
    987 #endif // !UNIFIED_TRANSFORM_TREE
    988834  }
    989835  else
     
    1007853    }
    1008854   
    1009 #if !UNIFIED_TRANSFORM_TREE
    1010     decodeTransformIdx( pcCU, uiAbsPartIdx, pcCU->getDepth(uiAbsPartIdx) );
    1011    
    1012     pcCU->convertTransIdx( uiAbsPartIdx, pcCU->getTransformIdx(uiAbsPartIdx), uiLumaTrMode, uiChromaTrMode );
    1013 #endif // !UNIFIED_TRANSFORM_TREE
    1014855  }
    1015856
     
    1030871#endif
    1031872
    1032 #if UNIFIED_TRANSFORM_TREE
    1033873  xDecodeTransform( pcCU, uiLumaOffset, uiChromaOffset, uiAbsPartIdx, uiAbsPartIdx, uiDepth, uiWidth, uiHeight, 0, 0, temp, temp1, temp2, bCodeDQP );
    1034 #else // UNIFIED_TRANSFORM_TREE
    1035   xDecodeCoeff( pcCU, uiLumaOffset, uiChromaOffset, uiAbsPartIdx, uiDepth, uiWidth, uiHeight, 0, uiLumaTrMode, bCodeDQP );
    1036 #endif // UNIFIED_TRANSFORM_TREE
    1037874
    1038875#if FIX_MPI_B0065
  • trunk/source/Lib/TLibDecoder/TDecEntropy.h

    r210 r296  
    6767  virtual Void  setBitstream          ( TComInputBitstream* p )  = 0;
    6868
    69 #if OL_FLUSH
    7069  virtual Void  decodeFlush()                                                                      = 0;
    71 #endif
    7270
    7371#if VIDYO_VPS_INTEGRATION|QC_MVHEVC_B0046
    7472  virtual Void  parseVPS                  ( TComVPS* pcVPS )                       = 0;
    7573#endif
    76 #if HHI_MPI
     74#if HHI_MPI || OL_QTLIMIT_PREDCODING_B0068
    7775  virtual Void  parseSPS                  ( TComSPS* pcSPS, Bool bIsDepth )                       = 0;
    7876#else
    7977  virtual Void  parseSPS                  ( TComSPS* pcSPS )                                      = 0;
    8078#endif
    81 #if TILES_OR_ENTROPY_SYNC_IDC 
    8279  virtual Void  parsePPS                  ( TComPPS* pcPPS, ParameterSetManagerDecoder *parameterSet )                                      = 0;
    83 #else
    84   virtual Void  parsePPS                  ( TComPPS* pcPPS )                                      = 0;
    85 #endif
    8680  virtual Void  parseAPS                  ( TComAPS* pAPS  )                                      = 0;
    8781  virtual void parseSEI(SEImessages&) = 0;
    8882
    89 #if LCU_SYNTAX_ALF
     83#if MTK_DEPTH_MERGE_TEXTURE_CANDIDATE_C0137
     84  virtual Void parseSliceHeader          ( TComSlice*& rpcSlice, ParameterSetManagerDecoder *parameterSetManager, AlfCUCtrlInfo &alfCUCtrl, AlfParamSet& alfParamSet, bool isDepth)       = 0;
     85#else
    9086  virtual Void parseSliceHeader          ( TComSlice*& rpcSlice, ParameterSetManagerDecoder *parameterSetManager, AlfCUCtrlInfo &alfCUCtrl, AlfParamSet& alfParamSet)       = 0;
    91 #else
    92   virtual Void parseSliceHeader          ( TComSlice*& rpcSlice, ParameterSetManagerDecoder *parameterSetManager, AlfCUCtrlInfo &alfCUCtrl )                                = 0;
    9387#endif
    9488
    9589  virtual Void  parseTerminatingBit       ( UInt& ruilsLast )                                     = 0;
    9690 
    97 #if HHI_INTER_VIEW_MOTION_PRED
     91#if H3D_IVMP
    9892  virtual Void parseMVPIdx        ( Int& riMVPIdx, Int iNumAMVPCands ) = 0;
    9993#else
     
    109103  virtual Void parseMergeFlag     ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, UInt uiPUIdx ) = 0;
    110104  virtual Void parseMergeIndex    ( TComDataCU* pcCU, UInt& ruiMergeIndex, UInt uiAbsPartIdx, UInt uiDepth ) = 0;
    111 #if HHI_INTER_VIEW_RESIDUAL_PRED
     105#if H3D_IVRP
    112106  virtual Void parseResPredFlag   ( TComDataCU* pcCU, Bool& rbResPredFlag, UInt uiAbsPartIdx, UInt uiDepth ) = 0;
    113107#endif
     
    159153  UInt    m_uiBakAbsPartIdx;
    160154  UInt    m_uiBakChromaOffset;
    161 #if UNIFIED_TRANSFORM_TREE
    162155  UInt    m_bakAbsPartIdxCU;
    163 #endif
    164156 
    165157public:
     
    179171#endif
    180172 
    181 #if HHI_MPI
     173#if HHI_MPI || OL_QTLIMIT_PREDCODING_B0068
    182174  Void    decodeSPS                   ( TComSPS* pcSPS, Bool bIsDepth ) { m_pcEntropyDecoderIf->parseSPS(pcSPS, bIsDepth); }
    183175#else
    184176  Void    decodeSPS                   ( TComSPS* pcSPS     )    { m_pcEntropyDecoderIf->parseSPS(pcSPS);                    }
    185177#endif
    186 #if TILES_OR_ENTROPY_SYNC_IDC
    187178  Void    decodePPS                   ( TComPPS* pcPPS, ParameterSetManagerDecoder *parameterSet    )    { m_pcEntropyDecoderIf->parsePPS(pcPPS, parameterSet);                    }
    188 #else
    189   Void    decodePPS                   ( TComPPS* pcPPS     )    { m_pcEntropyDecoderIf->parsePPS(pcPPS);                    }
    190 #endif
    191179  Void    decodeAPS                   ( TComAPS* pAPS      )    { m_pcEntropyDecoderIf->parseAPS(pAPS);}
    192180  void decodeSEI(SEImessages& seis) { m_pcEntropyDecoderIf->parseSEI(seis); }
    193181
    194 #if LCU_SYNTAX_ALF
     182#if MTK_DEPTH_MERGE_TEXTURE_CANDIDATE_C0137
     183  Void    decodeSliceHeader           ( TComSlice*& rpcSlice, ParameterSetManagerDecoder *parameterSetManager, AlfCUCtrlInfo &alfCUCtrl, AlfParamSet& alfParamSet, bool isDepth)  { m_pcEntropyDecoderIf->parseSliceHeader(rpcSlice, parameterSetManager, alfCUCtrl, alfParamSet, isDepth);         }
     184#else
    195185  Void    decodeSliceHeader           ( TComSlice*& rpcSlice, ParameterSetManagerDecoder *parameterSetManager, AlfCUCtrlInfo &alfCUCtrl, AlfParamSet& alfParamSet)  { m_pcEntropyDecoderIf->parseSliceHeader(rpcSlice, parameterSetManager, alfCUCtrl, alfParamSet);         }
    196 #else
    197   Void    decodeSliceHeader           ( TComSlice*& rpcSlice, ParameterSetManagerDecoder *parameterSetManager, AlfCUCtrlInfo &alfCUCtrl )  { m_pcEntropyDecoderIf->parseSliceHeader(rpcSlice, parameterSetManager, alfCUCtrl);         }
    198186#endif
    199187
     
    210198  Void decodeMergeFlag         ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, UInt uiPUIdx );
    211199  Void decodeMergeIndex        ( TComDataCU* pcSubCU, UInt uiPartIdx, UInt uiPartAddr, PartSize eCUMode, UChar* puhInterDirNeighbours, TComMvField* pcMvFieldNeighbours, UInt uiDepth );
    212 #if HHI_INTER_VIEW_RESIDUAL_PRED
     200#if H3D_IVRP && !MTK_MDIVRP_C0138
    213201  Void decodeResPredFlag       ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, TComDataCU* pcSubCU, UInt uiPUIdx );
    214202#endif
     
    223211  Void decodeIntraDirModeChroma( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth );
    224212 
    225 #if !UNIFIED_TRANSFORM_TREE
    226   Void decodeTransformIdx      ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth );
    227 #endif
    228 #if UNIFIED_TRANSFORM_TREE
    229213  Void decodeQP                ( TComDataCU* pcCU, UInt uiAbsPartIdx );
    230 #else
    231   Void decodeQP                ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth );
    232 #endif
    233214 
    234215  Void readTileMarker         ( UInt& uiTileIdx, UInt uiBitsUsed )  {  m_pcEntropyDecoderIf->readTileMarker( uiTileIdx, uiBitsUsed ); }
     
    237218 
    238219private:
    239 #if UNIFIED_TRANSFORM_TREE
    240220  Void xDecodeTransform        ( TComDataCU* pcCU, UInt offsetLuma, UInt offsetChroma, UInt uiAbsPartIdx, UInt absTUPartIdx, UInt uiDepth, UInt width, UInt height, UInt uiTrIdx, UInt uiInnerQuadIdx, UInt& uiYCbfFront3, UInt& uiUCbfFront3, UInt& uiVCbfFront3, Bool& bCodeDQP );
    241 #else
    242   Void xDecodeTransformSubdiv  ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt absTUPartIdx, UInt uiDepth, UInt uiInnerQuadIdx, UInt& uiYCbfFront3, UInt& uiUCbfFront3, UInt& uiVCbfFront3 );
    243  
    244   Void xDecodeCoeff            ( TComDataCU* pcCU, UInt uiLumaOffset, UInt uiChromaOffset, UInt uiAbsPartIdx, UInt uiDepth, UInt uiWidth, UInt uiHeight, UInt uiTrIdx, UInt uiCurrTrIdx, Bool& bCodeDQP );
    245 #endif //UNIFIED_TRANSFORM_TREE
    246221
    247222public:
     
    253228  Void setSliceGranularity (Int iSliceGranularity) {m_pcEntropyDecoderIf->setSliceGranularity(iSliceGranularity);}
    254229
    255 #if SAO_UNIT_INTERLEAVING
    256230  Void decodeSaoParam         (SAOParam* saoParam);
    257231  void decodeSaoLcu(Int rx, Int ry, Int compIdx, SAOParam* saoParam, Bool &repeatedRow );
    258232  Void decodeSaoOneLcu(SaoLcuParam* saoLcuParam);
    259 #endif
    260 
    261 #if OL_FLUSH
     233
    262234  Void decodeFlush() { m_pcEntropyDecoderIf->decodeFlush(); }
    263 #endif
    264235 
    265236#if RWTH_SDC_DLT_B0036
  • trunk/source/Lib/TLibDecoder/TDecGop.cpp

    r189 r296  
    7979Void TDecGop::destroy()
    8080{
    81 #if LCU_SYNTAX_ALF
    8281  m_alfParamSetPilot.releaseALFParam();
    83 #endif
    8482}
    8583
     
    9593                   ,TComDepthMapGenerator*  pcDepthMapGenerator
    9694#endif
    97 #if HHI_INTER_VIEW_RESIDUAL_PRED
     95#if H3D_IVRP
    9896                  ,TComResidualGenerator*  pcResidualGenerator
    9997#endif
     
    111109  m_pcDepthMapGenerator   = pcDepthMapGenerator;
    112110#endif
    113 #if HHI_INTER_VIEW_RESIDUAL_PRED
     111#if H3D_IVRP
    114112  m_pcResidualGenerator   = pcResidualGenerator;
    115113#endif
     
    120118// Private member functions
    121119// ====================================================================================================================
    122 #if LCU_SYNTAX_ALF
    123120Void TDecGop::patchAlfLCUParams(ALFParam*** alfLCUParam, AlfParamSet* alfParamSet, Int firstLCUAddr)
    124121{
     
    195192}
    196193
    197 #endif
    198194// ====================================================================================================================
    199195// Public member functions
     
    279275        if(pcSlice->getAlfEnabledFlag())
    280276        {
    281 #if LCU_SYNTAX_ALF
    282277          if(pcSlice->getSPS()->getUseALFCoefInSlice())
    283278          {
     
    289284          if( !pcSlice->getSPS()->getUseALFCoefInSlice())
    290285          {
    291 #endif
    292286          m_vAlfCUCtrlSlices.push_back(m_cAlfCUCtrlOneSlice);
    293 #if LCU_SYNTAX_ALF
    294287          }
    295 #endif
    296288        }
    297289      }
     
    303295    {
    304296      m_pcDepthMapGenerator->initViewComponent( rpcPic );
    305 #if !QC_MULTI_DIS_CAN_A0097
     297#if !H3D_NBDV
    306298      m_pcDepthMapGenerator->predictDepthMap  ( rpcPic );
    307299#endif
    308 #if HHI_INTER_VIEW_RESIDUAL_PRED
     300#if H3D_IVRP
    309301      m_pcResidualGenerator->initViewComponent( rpcPic );
    310302#endif
     
    312304#endif
    313305
    314 #if QC_SIMPLE_NBDV_B0047
     306#if H3D_NBDV
    315307    if(pcSlice->getViewId() && pcSlice->getSPS()->getMultiviewMvPredMode())
    316308    {
     
    323315    m_pcSliceDecoder->decompressSlice( pcBitstream, ppcSubstreams, rpcPic, m_pcSbacDecoder, m_pcSbacDecoders);
    324316    m_pcEntropyDecoder->setBitstream(  ppcSubstreams[uiNumSubstreams-1] );
    325 #if WPP_SIMPLIFICATION
    326317    if ( uiNumSubstreams > 1 )
    327 #else
    328     if ( pcSlice->getPPS()->getEntropyCodingSynchro() )
    329 #endif
    330318    {
    331319      // deallocate all created substreams, including internal buffers.
     
    343331  else
    344332  {
    345 #if HHI_INTER_VIEW_RESIDUAL_PRED
     333#if H3D_IVRP
    346334    // set residual picture
    347335    m_pcResidualGenerator->setRecResidualPic( rpcPic );
    348336#endif
    349337#if DEPTH_MAP_GENERATION
    350 #if !QC_MULTI_DIS_CAN_A0097
     338#if !H3D_NBDV
    351339    // update virtual depth map
    352340    m_pcDepthMapGenerator->updateDepthMap( rpcPic );
     
    356344    Bool bLFCrossTileBoundary = (pcSlice->getPPS()->getTileBehaviorControlPresentFlag() == 1)?
    357345                                (pcSlice->getPPS()->getLFCrossTileBoundaryFlag()):(pcSlice->getPPS()->getSPS()->getLFCrossTileBoundaryFlag());
    358 #if DBL_CONTROL
    359346    if (pcSlice->getPPS()->getDeblockingFilterControlPresent())
    360347    {
    361 #endif
    362348      if(pcSlice->getSPS()->getUseDF())
    363349      {
     
    372358        }
    373359      }
    374 #if DBL_CONTROL
    375360    }
    376361    m_pcLoopFilter->setCfg(pcSlice->getPPS()->getDeblockingFilterControlPresent(), pcSlice->getLoopFilterDisable(), pcSlice->getLoopFilterBetaOffset(), pcSlice->getLoopFilterTcOffset(), bLFCrossTileBoundary);
    377 #else
    378     m_pcLoopFilter->setCfg(pcSlice->getLoopFilterDisable(), pcSlice->getLoopFilterBetaOffset(), pcSlice->getLoopFilterTcOffset(), bLFCrossTileBoundary);
    379 #endif
    380362    m_pcLoopFilter->loopFilterPic( rpcPic );
    381363
     
    392374      if(pcSlice->getSaoEnabledFlag())
    393375      {
    394 #if SAO_UNIT_INTERLEAVING
    395376        if (pcSlice->getSaoInterleavingFlag())
    396377        {
     
    402383        }
    403384        m_pcSAO->setSaoInterleavingFlag(pcSlice->getAPS()->getSaoInterleavingFlag());
    404 #endif
    405385        m_pcSAO->createPicSaoInfo(rpcPic, m_uiILSliceCount);
    406386        m_pcSAO->SAOProcess(rpcPic, pcSlice->getAPS()->getSaoParam()); 
     
    413393    if( pcSlice->getSPS()->getUseALF() )
    414394    {
    415 #if LCU_SYNTAX_ALF
    416395      if( (pcSlice->getSPS()->getUseALFCoefInSlice())?(true):(pcSlice->getAlfEnabledFlag()))
    417 #else
    418       if(pcSlice->getAlfEnabledFlag())
    419 #endif
    420       {
    421 
    422 #if LCU_SYNTAX_ALF
     396      {
     397
    423398        if(!pcSlice->getSPS()->getUseALFCoefInSlice())
    424399        {
     
    427402        m_pcAdaptiveLoopFilter->createPicAlfInfo(rpcPic, m_uiILSliceCount, pcSlice->getSliceQp());
    428403        m_pcAdaptiveLoopFilter->ALFProcess(rpcPic, m_vAlfCUCtrlSlices, pcSlice->getSPS()->getUseALFCoefInSlice());
    429 #else
    430         m_pcAdaptiveLoopFilter->createPicAlfInfo(rpcPic, m_uiILSliceCount);
    431       m_pcAdaptiveLoopFilter->ALFProcess(rpcPic, pcSlice->getAPS()->getAlfParam(), m_vAlfCUCtrlSlices);
    432 #endif
    433404      m_pcAdaptiveLoopFilter->PCMLFDisableProcess(rpcPic);
    434405      m_pcAdaptiveLoopFilter->destroyPicAlfInfo();
    435406      }
    436 #if LCU_SYNTAX_ALF
    437407      m_pcAdaptiveLoopFilter->resetLCUAlfInfo(); //reset all LCU ALFParam->alf_flag = 0
    438 #endif   
    439408    }
    440409   
     
    511480    m_vAlfCUCtrlSlices.clear();
    512481  }
     482  fflush(stdout);
    513483}
    514484
  • trunk/source/Lib/TLibDecoder/TDecGop.h

    r56 r296  
    9090  TComDepthMapGenerator*  m_pcDepthMapGenerator;
    9191#endif
    92 #if HHI_INTER_VIEW_RESIDUAL_PRED
     92#if H3D_IVRP
    9393  TComResidualGenerator*  m_pcResidualGenerator;
    9494#endif
     
    101101  bool m_pictureDigestEnabled; ///< if true, handle picture_digest SEI messages
    102102  AlfCUCtrlInfo       m_cAlfCUCtrlOneSlice;
    103 #if LCU_SYNTAX_ALF
    104103  AlfParamSet           m_alfParamSetPilot;
    105 #endif
    106104
    107105public:
     
    120118                 ,TComDepthMapGenerator*  pcDepthMapGenerator
    121119#endif
    122 #if HHI_INTER_VIEW_RESIDUAL_PRED
     120#if H3D_IVRP
    123121                ,TComResidualGenerator*  pcResidualGenerator
    124122#endif
     
    131129  void setPictureDigestEnabled(bool enabled) { m_pictureDigestEnabled = enabled; }
    132130  AlfCUCtrlInfo& getAlfCuCtrlParam() { return m_cAlfCUCtrlOneSlice; }
    133 #if LCU_SYNTAX_ALF
    134131  AlfParamSet& getAlfParamSet() {return m_alfParamSetPilot;}
    135 #endif
    136132
    137133private:
    138 #if LCU_SYNTAX_ALF
    139134  Void patchAlfLCUParams(ALFParam*** alfLCUParam, AlfParamSet* alfParamSet, Int firstLCUAddr = 0);
    140 #endif
    141135
    142136
  • trunk/source/Lib/TLibDecoder/TDecSbac.cpp

    r189 r296  
    6262, m_cCUMergeFlagExtSCModel    ( 1,             1,               NUM_MERGE_FLAG_EXT_CTX        , m_contextModels + m_numContextModels, m_numContextModels)
    6363, m_cCUMergeIdxExtSCModel     ( 1,             1,               NUM_MERGE_IDX_EXT_CTX         , m_contextModels + m_numContextModels, m_numContextModels)
    64 #if HHI_INTER_VIEW_RESIDUAL_PRED
     64#if H3D_IVRP
    6565, m_cResPredFlagSCModel       ( 1,             1,               NUM_RES_PRED_FLAG_CTX         , m_contextModels + m_numContextModels, m_numContextModels)
    6666#endif
     
    8787, m_cALFUvlcSCModel           ( 1,             1,               NUM_ALF_UVLC_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
    8888, m_cALFSvlcSCModel           ( 1,             1,               NUM_ALF_SVLC_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
    89 #if AMP_CTX
    9089, m_cCUAMPSCModel             ( 1,             1,               NUM_CU_AMP_CTX                , m_contextModels + m_numContextModels, m_numContextModels)
    91 #else
    92 , m_cCUXPosiSCModel           ( 1,             1,               NUM_CU_X_POS_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
    93 , m_cCUYPosiSCModel           ( 1,             1,               NUM_CU_Y_POS_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
    94 #endif
    9590, m_cSaoFlagSCModel           ( 1,             1,               NUM_SAO_FLAG_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
    9691, m_cSaoUvlcSCModel           ( 1,             1,               NUM_SAO_UVLC_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
    9792, m_cSaoSvlcSCModel           ( 1,             1,               NUM_SAO_SVLC_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
    98 #if SAO_UNIT_INTERLEAVING
    9993, m_cSaoMergeLeftSCModel      ( 1,             1,               NUM_SAO_MERGE_LEFT_FLAG_CTX   , m_contextModels + m_numContextModels, m_numContextModels)
    10094, m_cSaoMergeUpSCModel        ( 1,             1,               NUM_SAO_MERGE_UP_FLAG_CTX     , m_contextModels + m_numContextModels, m_numContextModels)
    10195, m_cSaoTypeIdxSCModel        ( 1,             1,               NUM_SAO_TYPE_IDX_CTX          , m_contextModels + m_numContextModels, m_numContextModels)
    102 #endif
    10396#if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
    10497, m_cDmmFlagSCModel           ( 1,             1,               NUM_DMM_FLAG_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
     
    166159  m_cCUMergeFlagExtSCModel.initBuffer    ( sliceType, qp, (UChar*)INIT_MERGE_FLAG_EXT );
    167160  m_cCUMergeIdxExtSCModel.initBuffer     ( sliceType, qp, (UChar*)INIT_MERGE_IDX_EXT );
    168 #if HHI_INTER_VIEW_RESIDUAL_PRED
     161#if H3D_IVRP
    169162  m_cResPredFlagSCModel.initBuffer       ( sliceType, qp, (UChar*)INIT_RES_PRED_FLAG );
    170163#endif
    171164  m_cCUAlfCtrlFlagSCModel.initBuffer     ( sliceType, qp, (UChar*)INIT_ALF_CTRL_FLAG );
    172165  m_cCUPartSizeSCModel.initBuffer        ( sliceType, qp, (UChar*)INIT_PART_SIZE );
    173 #if AMP_CTX
    174166  m_cCUAMPSCModel.initBuffer             ( sliceType, qp, (UChar*)INIT_CU_AMP_POS );
    175 #else
    176   m_cCUXPosiSCModel.initBuffer           ( sliceType, qp, (UChar*)INIT_CU_X_POS );
    177   m_cCUYPosiSCModel.initBuffer           ( sliceType, qp, (UChar*)INIT_CU_Y_POS );
    178 #endif
    179167  m_cCUPredModeSCModel.initBuffer        ( sliceType, qp, (UChar*)INIT_PRED_MODE );
    180168  m_cCUIntraPredSCModel.initBuffer       ( sliceType, qp, (UChar*)INIT_INTRA_PRED_MODE );
     
    199187  m_cSaoUvlcSCModel.initBuffer           ( sliceType, qp, (UChar*)INIT_SAO_UVLC );
    200188  m_cSaoSvlcSCModel.initBuffer           ( sliceType, qp, (UChar*)INIT_SAO_SVLC );
    201 #if SAO_UNIT_INTERLEAVING
    202189  m_cSaoMergeLeftSCModel.initBuffer      ( sliceType, qp, (UChar*)INIT_SAO_MERGE_LEFT_FLAG );
    203190  m_cSaoMergeUpSCModel.initBuffer        ( sliceType, qp, (UChar*)INIT_SAO_MERGE_UP_FLAG );
    204191  m_cSaoTypeIdxSCModel.initBuffer        ( sliceType, qp, (UChar*)INIT_SAO_TYPE_IDX );
    205 #endif
    206192
    207193  m_cCUTransSubdivFlagSCModel.initBuffer ( sliceType, qp, (UChar*)INIT_TRANS_SUBDIV_FLAG );
     
    260246  m_cCUMergeFlagExtSCModel.initBuffer    ( eSliceType, iQp, (UChar*)INIT_MERGE_FLAG_EXT );
    261247  m_cCUMergeIdxExtSCModel.initBuffer     ( eSliceType, iQp, (UChar*)INIT_MERGE_IDX_EXT );
    262 #if HHI_INTER_VIEW_RESIDUAL_PRED
     248#if H3D_IVRP
    263249  m_cResPredFlagSCModel.initBuffer       ( eSliceType, iQp, (UChar*)INIT_RES_PRED_FLAG );
    264250#endif
    265251  m_cCUAlfCtrlFlagSCModel.initBuffer     ( eSliceType, iQp, (UChar*)INIT_ALF_CTRL_FLAG );
    266252  m_cCUPartSizeSCModel.initBuffer        ( eSliceType, iQp, (UChar*)INIT_PART_SIZE );
    267 #if AMP_CTX
    268253  m_cCUAMPSCModel.initBuffer             ( eSliceType, iQp, (UChar*)INIT_CU_AMP_POS );
    269 #else
    270   m_cCUXPosiSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_CU_X_POS );
    271   m_cCUYPosiSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_CU_Y_POS );
    272 #endif
    273254  m_cCUPredModeSCModel.initBuffer        ( eSliceType, iQp, (UChar*)INIT_PRED_MODE );
    274255  m_cCUIntraPredSCModel.initBuffer       ( eSliceType, iQp, (UChar*)INIT_INTRA_PRED_MODE );
     
    293274  m_cSaoUvlcSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_SAO_UVLC );
    294275  m_cSaoSvlcSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_SAO_SVLC );
    295 #if SAO_UNIT_INTERLEAVING
    296276  m_cSaoMergeLeftSCModel.initBuffer      ( eSliceType, iQp, (UChar*)INIT_SAO_MERGE_LEFT_FLAG );
    297277  m_cSaoMergeUpSCModel.initBuffer        ( eSliceType, iQp, (UChar*)INIT_SAO_MERGE_UP_FLAG );
    298278  m_cSaoTypeIdxSCModel.initBuffer        ( eSliceType, iQp, (UChar*)INIT_SAO_TYPE_IDX );
    299 #endif
    300279  m_cCUTransSubdivFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_TRANS_SUBDIV_FLAG );
    301280#if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
     
    449428  }
    450429
    451 #if EIGHT_BITS_RICE_CODE
    452430  ruiGoRiceParam = g_aauiGoRiceUpdate[ ruiGoRiceParam ][ min<UInt>( ruiSymbol, 23 ) ];
    453 #else
    454   ruiGoRiceParam = g_aauiGoRiceUpdate[ ruiGoRiceParam ][ min<UInt>( ruiSymbol, 15 ) ];
    455 #endif
    456431
    457432  return;
     
    470445{
    471446  UInt uiSymbol;
    472 #if BURST_IPCM
    473447  Int numSubseqIPCM = 0;
    474448  Bool readPCMSampleFlag = false;
     
    490464    }
    491465  }
    492 #else
    493   m_pcTDecBinIf->decodeBinTrm(uiSymbol);
    494 #endif
    495 
    496 #if BURST_IPCM
     466
    497467  if (readPCMSampleFlag == true)
    498 #else
    499   if (uiSymbol)
    500 #endif
    501468  {
    502469    Bool bIpcmFlag = true;
    503470
    504 #if !BURST_IPCM
    505     m_pcTDecBinIf->decodePCMAlignBits();
    506 #endif
    507471
    508472    pcCU->setPartSizeSubParts  ( SIZE_2Nx2N, uiAbsPartIdx, uiDepth );
     
    568532    }
    569533
    570 #if BURST_IPCM
    571534    pcCU->setNumSucIPCM( pcCU->getNumSucIPCM() - 1);
    572535    if(pcCU->getNumSucIPCM() == 0)
     
    574537      m_pcTDecBinIf->resetBac();
    575538    }
    576 #else
    577     m_pcTDecBinIf->resetBac();
    578 #endif
    579539  }
    580540}
     
    664624{
    665625  UInt uiNumCand = MRG_MAX_NUM_CANDS;
    666 #if !MRG_IDX_CTX_RED 
    667   UInt auiCtx[4] = { 0, 1, 2, 3 };
    668 #endif
    669626  UInt uiUnaryIdx = 0;
    670627  uiNumCand = pcCU->getSlice()->getMaxNumMergeCand();
     
    678635    {
    679636      UInt uiSymbol = 0;
    680 #if MRG_IDX_CTX_RED
    681637      if ( uiUnaryIdx==0 )
    682638      {
     
    687643        m_pcTDecBinIf->decodeBinEP( uiSymbol );
    688644      }
    689 #else
    690       m_pcTDecBinIf->decodeBin( uiSymbol, m_cCUMergeIdxExtSCModel.get( 0, 0, auiCtx[uiUnaryIdx] ) );
    691 #endif
    692645      if( uiSymbol == 0 )
    693646      {
     
    717670}
    718671
    719 #if HHI_INTER_VIEW_RESIDUAL_PRED
     672#if H3D_IVRP
    720673Void
    721674TDecSbac::parseResPredFlag( TComDataCU* pcCU, Bool& rbResPredFlag, UInt uiAbsPartIdx, UInt uiDepth )
     
    728681#endif
    729682
    730 #if HHI_INTER_VIEW_MOTION_PRED
     683#if H3D_IVMP
    731684Void TDecSbac::parseMVPIdx      ( Int& riMVPIdx, Int iNumAMVPCands )
    732685{
     
    762715  Bool bIntraSliceDetect  = (pcCU->getSlice()->getSliceType() == I_SLICE);
    763716
     717#if HHI_QTLPC_RAU_OFF_C0160
     718  Bool rapPic     = (pcCU->getSlice()->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR || pcCU->getSlice()->getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA);
     719  if(bDepthMapDetect && !bIntraSliceDetect && !rapPic && sps->getUseQTLPC())
     720#else
    764721  if(bDepthMapDetect && !bIntraSliceDetect && sps->getUseQTLPC())
     722#endif
    765723  {
    766724    TComDataCU *pcTextureCU = pcTexture->getCU(pcCU->getAddr());
     
    804762  Bool bIntraSliceDetect = (pcCU->getSlice()->getSliceType() == I_SLICE);
    805763
     764#if HHI_QTLPC_RAU_OFF_C0160
     765  Bool rapPic     = (pcCU->getSlice()->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR || pcCU->getSlice()->getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA);
     766  if(bDepthMapDetect && !bIntraSliceDetect && !rapPic && sps->getUseQTLPC())
     767#else
    806768  if(bDepthMapDetect && !bIntraSliceDetect && sps->getUseQTLPC())
     769#endif
    807770  {
    808771    TComDataCU *pcTextureCU = pcTexture->getCU(pcCU->getAddr());
     
    869832        if (eMode == SIZE_2NxN)
    870833        {
    871 #if AMP_CTX
    872834            m_pcTDecBinIf->decodeBin(uiSymbol, m_cCUAMPSCModel.get( 0, 0, 0 ));
    873 #else
    874           m_pcTDecBinIf->decodeBin(uiSymbol, m_cCUYPosiSCModel.get( 0, 0, 0 ));
    875 #endif
    876835          if (uiSymbol == 0)
    877836          {
    878 #if AMP_CTX
    879837            m_pcTDecBinIf->decodeBinEP(uiSymbol);
    880 #else
    881             m_pcTDecBinIf->decodeBin(uiSymbol, m_cCUYPosiSCModel.get( 0, 0, 1 ));
    882 #endif
    883838            eMode = (uiSymbol == 0? SIZE_2NxnU : SIZE_2NxnD);
    884839          }
     
    886841        else if (eMode == SIZE_Nx2N)
    887842        {
    888 #if AMP_CTX
    889843          m_pcTDecBinIf->decodeBin(uiSymbol, m_cCUAMPSCModel.get( 0, 0, 0 ));
    890 #else
    891           m_pcTDecBinIf->decodeBin(uiSymbol, m_cCUXPosiSCModel.get( 0, 0, 0 ));
    892 #endif
    893844          if (uiSymbol == 0)
    894845          {
    895 #if AMP_CTX
    896846            m_pcTDecBinIf->decodeBinEP(uiSymbol);
    897 #else
    898             m_pcTDecBinIf->decodeBin(uiSymbol, m_cCUXPosiSCModel.get( 0, 0, 1 ));
    899 #endif
    900847            eMode = (uiSymbol == 0? SIZE_nLx2N : SIZE_nRx2N);
    901848          }
     
    970917#if HHI_DMM_PRED_TEX
    971918    if( intraPredMode == DMM_WEDGE_PREDTEX_D_IDX )     { xParseWedgePredTexDeltaInfo  ( pcCU, uiAbsPartIdx, uiDepth ); }
     919#if LGE_DMM3_SIMP_C0044
     920    if( intraPredMode == DMM_WEDGE_PREDTEX_IDX )       { xParseWedgePredTexInfo       ( pcCU, uiAbsPartIdx, uiDepth ); }
     921#endif
    972922    if( intraPredMode == DMM_CONTOUR_PREDTEX_D_IDX )   { xParseContourPredTexDeltaInfo( pcCU, uiAbsPartIdx, uiDepth ); }
    973923#endif
     
    975925  else
    976926  {
    977 #endif
    978 #if !LOGI_INTRA_NAME_3MPM
    979     Int iIntraIdx = pcCU->getIntraSizeIdx(uiAbsPartIdx);
    980927#endif
    981928
     
    990937#endif
    991938
    992 #if LOGI_INTRA_NAME_3MPM
    993939    Int uiPreds[3] = {-1, -1, -1};
    994 #else
    995     Int uiPreds[2] = {-1, -1};
    996 #endif
    997940    Int uiPredNum = pcCU->getIntraDirLumaPredictor(uiAbsPartIdx, uiPreds); 
    998941#if LGE_EDGE_INTRA_A0070
     
    1005948    {
    1006949      m_pcTDecBinIf->decodeBinEP( uiSymbol );
    1007 #if LOGI_INTRA_NAME_3MPM
    1008950      if (uiSymbol)
    1009951      {
     
    1011953        uiSymbol++;
    1012954      }
    1013 #endif
    1014955      intraPredMode = uiPreds[uiSymbol];
    1015956    }
     
    1018959      intraPredMode = 0;
    1019960
    1020 #if LOGI_INTRA_NAME_3MPM
    1021961
    1022962      m_pcTDecBinIf->decodeBinsEP( uiSymbol, 5 );
     
    1047987        std::swap(uiPreds[1], uiPreds[2]);
    1048988      }
    1049 #else
    1050       m_pcTDecBinIf->decodeBinsEP( uiSymbol, g_aucIntraModeBitsAng[iIntraIdx] - 1 );
    1051       intraPredMode = uiSymbol;
    1052 
    1053       if ( intraPredMode == 31 )
    1054       {
    1055         m_pcTDecBinIf->decodeBinEP( uiSymbol );
    1056         intraPredMode += uiSymbol;     
    1057       }
    1058 #endif
    1059989#if LGE_EDGE_INTRA_A0070
    1060990      if ( intraPredMode != EDGE_INTRA_IDX)
     
    11451075    {
    11461076      UInt uiIPredMode;
    1147 #if CHROMA_MODE_CODING
    11481077      m_pcTDecBinIf->decodeBinsEP( uiIPredMode, 2 );
    1149 #else
    1150       xReadUnaryMaxSymbol( uiIPredMode, m_cCUChromaPredSCModel.get( 0, 0 ) + 1, 0, 3 );
    1151 #endif
    11521078      UInt uiAllowedChromaDir[ NUM_CHROMA_MODE ];
    11531079      pcCU->getAllowedChromaDir( uiAbsPartIdx, uiAllowedChromaDir );
     
    12171143  ContextModel *pCtx = m_cCUMvdSCModel.get( 0 );
    12181144
    1219 #if H0111_MVD_L1_ZERO
    12201145  if(pcCU->getSlice()->getMvdL1ZeroFlag() && eRefList == REF_PIC_LIST_1 && pcCU->getInterDir(uiAbsPartIdx)==3)
    12211146  {
     
    12251150  else
    12261151  {
    1227 #endif
    12281152
    12291153    m_pcTDecBinIf->decodeBin( uiHorAbs, *pCtx );
     
    12681192    }
    12691193
    1270 #if H0111_MVD_L1_ZERO
    1271   }
    1272 #endif
     1194  }
    12731195
    12741196  const TComMv cMv( uiHorSign ? -Int( uiHorAbs ): uiHorAbs, uiVerSign ? -Int( uiVerAbs ) : uiVerAbs );
     
    13101232Void TDecSbac::parseDeltaQP( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
    13111233{
    1312 #if H0736_AVC_STYLE_QP_RANGE
    13131234  Int qp;
    1314 #endif
    13151235  UInt uiDQp;
    13161236  Int  iDQp;
     
    13201240  if ( uiDQp == 0 )
    13211241  {
    1322 #if H0736_AVC_STYLE_QP_RANGE
    13231242    qp = pcCU->getRefQP(uiAbsPartIdx);
    1324 #else
    1325     uiDQp = pcCU->getRefQP(uiAbsPartIdx);
    1326 #endif
    13271243  }
    13281244  else
    13291245  {
    13301246    UInt uiSign;
    1331 #if H0736_AVC_STYLE_QP_RANGE
    13321247    Int qpBdOffsetY = pcCU->getSlice()->getSPS()->getQpBDOffsetY();
    1333 #else
    1334     UInt uiQpBdOffsetY = 6*(g_uiBitIncrement + g_uiBitDepth - 8);
    1335 #endif
    13361248    m_pcTDecBinIf->decodeBinEP(uiSign);
    13371249
    1338 #if H0736_AVC_STYLE_QP_RANGE
    13391250    UInt uiMaxAbsDQpMinus1 = 24 + (qpBdOffsetY/2) + (uiSign);
    1340 #else
    1341     UInt uiMaxAbsDQpMinus1 = 24 + (uiQpBdOffsetY/2) + (uiSign);
    1342 #endif
    13431251    UInt uiAbsDQpMinus1;
    13441252    xReadUnaryMaxSymbol (uiAbsDQpMinus1,  &m_cCUDeltaQpSCModel.get( 0, 0, 1 ), 1, uiMaxAbsDQpMinus1);
     
    13511259    }
    13521260
    1353 #if H0736_AVC_STYLE_QP_RANGE
    13541261    qp = (((Int) pcCU->getRefQP( uiAbsPartIdx ) + iDQp + 52 + 2*qpBdOffsetY )%(52+qpBdOffsetY)) - qpBdOffsetY;
    1355 #else
    1356 #if LOSSLESS_CODING
    1357     uiDQp = (pcCU->getRefQP(uiAbsPartIdx) + iDQp + 52) % 52;
    1358 #else
    1359     uiDQp = pcCU->getRefQP(uiAbsPartIdx) + iDQp;
    1360 #endif
    1361 #endif
    13621262  }
    13631263 
    13641264  UInt uiAbsQpCUPartIdx = (uiAbsPartIdx>>(8-(pcCU->getSlice()->getPPS()->getMaxCuDQPDepth()<<1)))<<(8-(pcCU->getSlice()->getPPS()->getMaxCuDQPDepth()<<1)) ;
    13651265  UInt uiQpCUDepth =   min(uiDepth,pcCU->getSlice()->getPPS()->getMaxCuDQPDepth()) ;
    1366 #if H0736_AVC_STYLE_QP_RANGE
    13671266  pcCU->setQPSubParts( qp, uiAbsQpCUPartIdx, uiQpCUDepth );
    1368 #else
    1369   pcCU->setQPSubParts( uiDQp, uiAbsQpCUPartIdx, uiQpCUDepth );
    1370 #endif
    13711267}
    13721268
     
    14091305
    14101306  // posX
    1411 #if LAST_CTX_REDUCTION
    14121307  Int widthCtx = eTType ? 4 : width;
    14131308  const UInt *puiCtxIdxX = g_uiLastCtx + ( g_aucConvertToBit[ widthCtx ] * ( g_aucConvertToBit[ widthCtx ] + 3 ) );
    1414 #else
    1415   const UInt *puiCtxIdxX = g_uiLastCtx + ( g_aucConvertToBit[ width ] * ( g_aucConvertToBit[ width ] + 3 ) );
    1416 #endif
    14171309  for( uiPosLastX = 0; uiPosLastX < g_uiGroupIdx[ width - 1 ]; uiPosLastX++ )
    14181310  {
    1419 #if LAST_CTX_REDUCTION
    14201311    if ( eTType  )
    14211312    {
     
    14241315    else
    14251316    {
    1426 #endif
    14271317      m_pcTDecBinIf->decodeBin( uiLast, *( pCtxX + puiCtxIdxX[ uiPosLastX ] ) );
    1428 #if LAST_CTX_REDUCTION
    1429     }
    1430 #endif
     1318    }
    14311319    if( !uiLast )
    14321320    {
     
    14361324
    14371325  // posY
    1438 #if LAST_CTX_REDUCTION
    14391326  Int heightCtx = eTType? 4 : height;
    14401327  const UInt *puiCtxIdxY = g_uiLastCtx + ( g_aucConvertToBit[ heightCtx ] * ( g_aucConvertToBit[ heightCtx ] + 3 ) );
    1441 #else
    1442   const UInt *puiCtxIdxY = g_uiLastCtx + ( g_aucConvertToBit[ height ] * ( g_aucConvertToBit[ height ] + 3 ) );
    1443 #endif
    14441328  for( uiPosLastY = 0; uiPosLastY < g_uiGroupIdx[ height - 1 ]; uiPosLastY++ )
    14451329  {
    1446 #if LAST_CTX_REDUCTION
    14471330    if (eTType)
    14481331    {
     
    14511334    else
    14521335    {
    1453 #endif
    14541336      m_pcTDecBinIf->decodeBin( uiLast, *( pCtxY + puiCtxIdxY[ uiPosLastY ] ) );
    1455 #if LAST_CTX_REDUCTION
    1456     }
    1457 #endif
     1337    }
    14581338    if( !uiLast )
    14591339    {
     
    15751455  UInt uiGoRiceParam           = 0;
    15761456
    1577 #if MULTIBITS_DATA_HIDING
    15781457  UInt const tsig = pcCU->getSlice()->getPPS()->getTSIG();
    15791458#if LOSSLESS_CODING
     
    15911470#endif
    15921471  UInt absSum = 0;
    1593 #endif  // MULTIBITS_DATA_HIDING
    15941472
    15951473  UInt uiSigCoeffGroupFlag[ MLS_GRP_NUM ];
     
    16001478  {
    16011479    scanCG = g_auiSigLastScan[ uiScanIdx ][ uiLog2BlockSize > 3 ? uiLog2BlockSize-2-1 : 0  ];   
    1602 #if MULTILEVEL_SIGMAP_EXT
    16031480    if( uiLog2BlockSize == 3 )
    16041481    {
     
    16091486      scanCG = g_sigLastScanCG32x32;
    16101487    }
    1611 #endif
    16121488  }
    16131489  else
     
    16221498    Int numNonZero = 0;
    16231499   
    1624 #if MULTIBITS_DATA_HIDING
    16251500    Int lastNZPosInCG = -1, firstNZPosInCG = SCAN_SET_SIZE;
    1626 #endif
    16271501
    16281502    Int pos[SCAN_SET_SIZE];
    16291503    if( iScanPosSig == (Int) uiScanPosLast )
    16301504    {
    1631 #if MULTIBITS_DATA_HIDING
    16321505      lastNZPosInCG  = iScanPosSig;
    16331506      firstNZPosInCG = iScanPosSig;
    1634 #endif
    16351507      iScanPosSig--;
    16361508      pos[ numNonZero ] = uiBlkPosLast;
     
    16381510    }
    16391511
    1640 #if !MULTILEVEL_SIGMAP_EXT
    1641     if( blockType > 3 )
    1642     {
    1643 #endif
    16441512      // decode significant_coeffgroup_flag
    16451513      Int iCGBlkPos = scanCG[ iSubSet ];
    16461514      Int iCGPosY   = iCGBlkPos / uiNumBlkSide;
    16471515      Int iCGPosX   = iCGBlkPos - (iCGPosY * uiNumBlkSide);
    1648 #if MULTILEVEL_SIGMAP_EXT
    16491516      if( uiWidth == 8 && uiHeight == 8 && (uiScanIdx == SCAN_HOR || uiScanIdx == SCAN_VER) )
    16501517      {
     
    16521519        iCGPosX = (uiScanIdx == SCAN_VER ? iCGBlkPos : 0);
    16531520      }
    1654 #endif
    1655 #if !REMOVE_INFER_SIGGRP
    1656       Bool bInferredCGFlag = false;
    1657 #endif
    1658 #if REMOVE_INFER_SIGGRP
    16591521      if( iSubSet == iLastScanSet || iSubSet == 0)
    1660 #else
    1661       if( iSubSet == iLastScanSet )
    1662 #endif
    16631522      {
    16641523        uiSigCoeffGroupFlag[ iCGBlkPos ] = 1;
     
    16661525      else
    16671526      {
    1668 #if !REMOVE_INFER_SIGGRP
    1669 #if MULTILEVEL_SIGMAP_EXT
    1670         if( !TComTrQuant::bothCGNeighboursOne( uiSigCoeffGroupFlag, iCGPosX, iCGPosY, uiScanIdx, uiWidth, uiHeight) && ( iSubSet ) )
    1671 #else
    1672         if( !TComTrQuant::bothCGNeighboursOne( uiSigCoeffGroupFlag, iCGPosX, iCGPosY, uiWidth, uiHeight) && ( iSubSet ) )
    1673 #endif
    1674         {
    1675 #endif
    16761527          UInt uiSigCoeffGroup;
    1677 #if MULTILEVEL_SIGMAP_EXT
    16781528          UInt uiCtxSig  = TComTrQuant::getSigCoeffGroupCtxInc( uiSigCoeffGroupFlag, iCGPosX, iCGPosY, uiScanIdx, uiWidth, uiHeight );
    1679 #else
    1680           UInt uiCtxSig  = TComTrQuant::getSigCoeffGroupCtxInc( uiSigCoeffGroupFlag, iCGPosX, iCGPosY, uiWidth, uiHeight );
    1681 #endif
    16821529          m_pcTDecBinIf->decodeBin( uiSigCoeffGroup, baseCoeffGroupCtx[ uiCtxSig ] );
    16831530          uiSigCoeffGroupFlag[ iCGBlkPos ] = uiSigCoeffGroup;
    1684 #if !REMOVE_INFER_SIGGRP
    1685         }
    1686         else
    1687         {
    1688           uiSigCoeffGroupFlag[ iCGBlkPos ] = 1;
    1689           bInferredCGFlag = true;
    1690         }
    1691 #endif
    16921531      }
    16931532
     
    17031542        if( uiSigCoeffGroupFlag[ iCGBlkPos ] )
    17041543        {
    1705 #if REMOVE_INFER_SIGGRP
    17061544          if( iScanPosSig > iSubPos || iSubSet == 0  || numNonZero )
    1707 #else
    1708           if( iScanPosSig > iSubPos || bInferredCGFlag || numNonZero )
    1709 #endif
    17101545          {
    17111546            uiCtxSig  = TComTrQuant::getSigCtxInc( pcCoef, uiPosX, uiPosY, blockType, uiWidth, uiHeight, eTType );
     
    17221557          pos[ numNonZero ] = uiBlkPos;
    17231558          numNonZero ++;
    1724 #if MULTIBITS_DATA_HIDING
    17251559          if( lastNZPosInCG == -1 )
    17261560          {
     
    17281562          }
    17291563          firstNZPosInCG = iScanPosSig;
    1730 #endif
    17311564        }
    17321565      }
    1733 #if !MULTILEVEL_SIGMAP_EXT
    1734     }
    1735     else
    1736     {
    1737       for( ; iScanPosSig >= iSubPos; iScanPosSig-- )
    1738       {
    1739         UInt uiBlkPos   = scan[ iScanPosSig ];
    1740         UInt  uiPosY    = uiBlkPos >> uiLog2BlockSize;
    1741         UInt  uiPosX    = uiBlkPos - ( uiPosY << uiLog2BlockSize );
    1742         UInt  uiSig     = 0;
    1743         UInt  uiCtxSig  = TComTrQuant::getSigCtxInc( pcCoef, uiPosX, uiPosY, blockType, uiWidth, uiHeight, eTType );
    1744         m_pcTDecBinIf->decodeBin( uiSig, baseCtx[ uiCtxSig ] );
    1745         pcCoef[ uiBlkPos ] = uiSig;
    1746         if( uiSig )
    1747         {
    1748           pos[ numNonZero ] = uiBlkPos;
    1749           numNonZero ++;
    1750 #if MULTIBITS_DATA_HIDING
    1751           if( lastNZPosInCG == -1 )
    1752           {
    1753             lastNZPosInCG = iScanPosSig;
    1754           }
    1755           firstNZPosInCG = iScanPosSig;
    1756 #endif
    1757         }
    1758       }
    1759     }
    1760 #endif
    17611566
    17621567   
    17631568    if( numNonZero )
    17641569    {
    1765 #if MULTIBITS_DATA_HIDING
    17661570      Bool signHidden = ( lastNZPosInCG - firstNZPosInCG >= (Int)tsig );
    17671571      absSum = 0;
    1768 #endif  // MULTIBITS_DATA_HIDING
    17691572
    17701573      UInt c1 = 1;
    1771 #if !RESTRICT_GR1GR2FLAG_NUMBER
    1772       UInt c2 = 0;
    1773 #endif
    1774 #if LEVEL_CTX_LUMA_RED
    17751574      UInt uiCtxSet    = (iSubSet > 0 && eTType==TEXT_LUMA) ? 2 : 0;
    1776 #else
    1777       UInt uiCtxSet    = (iSubSet > 0 && eTType==TEXT_LUMA) ? 3 : 0;
    1778 #endif
    17791575      UInt uiBin;
    17801576     
     
    17821578      {
    17831579        uiCtxSet++;
    1784 #if !LEVEL_CTX_LUMA_RED
    1785         if(eTType==TEXT_LUMA && uiNumOne > 3)
    1786         {
    1787           uiCtxSet++;
    1788         }
    1789 #endif
    17901580      }
    17911581     
     
    17941584      Int absCoeff[SCAN_SET_SIZE];
    17951585
    1796 #if RESTRICT_GR1GR2FLAG_NUMBER
    17971586      for ( Int i = 0; i < numNonZero; i++) absCoeff[i] = 1;   
    17981587      Int numC1Flag = min(numNonZero, C1FLAG_NUMBER);
     
    18001589
    18011590      for( Int idx = 0; idx < numC1Flag; idx++ )
    1802 #else
    1803       for( Int idx = 0; idx < numNonZero; idx++ )
    1804 #endif
    18051591      {
    18061592        m_pcTDecBinIf->decodeBin( uiBin, baseCtxMod[c1] );
     
    18081594        {
    18091595          c1 = 0;
    1810 #if RESTRICT_GR1GR2FLAG_NUMBER
    18111596          if (firstC2FlagIdx == -1)
    18121597          {
    18131598            firstC2FlagIdx = idx;
    18141599          }
    1815 #endif
    18161600        }
    18171601        else if( (c1 < 3) && (c1 > 0) )
     
    18241608      if (c1 == 0)
    18251609      {
    1826 #if RESTRICT_GR1GR2FLAG_NUMBER
    18271610        baseCtxMod = ( eTType==TEXT_LUMA ) ? m_cCUAbsSCModel.get( 0, 0 ) + uiCtxSet : m_cCUAbsSCModel.get( 0, 0 ) + NUM_ABS_FLAG_CTX_LUMA + uiCtxSet;
    18281611        if ( firstC2FlagIdx != -1)
     
    18311614          absCoeff[ firstC2FlagIdx ] = uiBin + 2;
    18321615        }
    1833 #else   
    1834         baseCtxMod = ( eTType==TEXT_LUMA ) ? m_cCUAbsSCModel.get( 0, 0 ) + 3 * uiCtxSet : m_cCUAbsSCModel.get( 0, 0 ) + NUM_ABS_FLAG_CTX_LUMA + 3 * uiCtxSet;
     1616      }
     1617
     1618      UInt coeffSigns;
     1619      if ( signHidden && beValid )
     1620      {
     1621        m_pcTDecBinIf->decodeBinsEP( coeffSigns, numNonZero-1 );
     1622        coeffSigns <<= 32 - (numNonZero-1);
     1623      }
     1624      else
     1625      {
     1626        m_pcTDecBinIf->decodeBinsEP( coeffSigns, numNonZero );
     1627        coeffSigns <<= 32 - numNonZero;
     1628      }
     1629     
     1630      Int iFirstCoeff2 = 1;   
     1631      if (c1 == 0 || numNonZero > C1FLAG_NUMBER)
     1632      {
    18351633        for( Int idx = 0; idx < numNonZero; idx++ )
    18361634        {
    1837           if( absCoeff[ idx ] == 2 )
    1838           {
    1839             m_pcTDecBinIf->decodeBin( uiBin, baseCtxMod[c2] );
    1840             absCoeff[ idx ] = uiBin + 2;
    1841             c2 += (c2 < 2);
    1842             uiNumOne++;
    1843           }
    1844         }
    1845 #endif
    1846       }
    1847 
    1848 #if MULTIBITS_DATA_HIDING
    1849       UInt coeffSigns;
    1850       if ( signHidden && beValid )
    1851       {
    1852         m_pcTDecBinIf->decodeBinsEP( coeffSigns, numNonZero-1 );
    1853         coeffSigns <<= 32 - (numNonZero-1);
    1854       }
    1855       else
    1856       {
    1857         m_pcTDecBinIf->decodeBinsEP( coeffSigns, numNonZero );
    1858         coeffSigns <<= 32 - numNonZero;
    1859       }
    1860 #else
    1861       UInt coeffSigns;
    1862       m_pcTDecBinIf->decodeBinsEP( coeffSigns, numNonZero );
    1863       coeffSigns <<= 32 - numNonZero;
    1864 #endif
    1865      
    1866 #if RESTRICT_GR1GR2FLAG_NUMBER
    1867       Int iFirstCoeff2 = 1;   
    1868       if (c1 == 0 || numNonZero > C1FLAG_NUMBER)
    1869 #else
    1870       if (c1 == 0)
    1871 #endif
    1872       {
    1873         for( Int idx = 0; idx < numNonZero; idx++ )
    1874         {
    1875 #if RESTRICT_GR1GR2FLAG_NUMBER   
    18761635          UInt baseLevel  = (idx < C1FLAG_NUMBER)? (2 + iFirstCoeff2) : 1;
    18771636
     
    18881647            uiNumOne++;
    18891648          }
    1890 #else
    1891           if( absCoeff[ idx ] == 3 )
    1892           {
    1893             UInt uiLevel;
    1894             xReadGoRiceExGolomb( uiLevel, uiGoRiceParam );
    1895             absCoeff[ idx ] = uiLevel + 3;
    1896           }
    1897 #endif
    18981649        }
    18991650      }
     
    19021653      {
    19031654        Int blkPos = pos[ idx ];
    1904 #if MULTIBITS_DATA_HIDING
    19051655        // Signs applied later.
    19061656        pcCoef[ blkPos ] = absCoeff[ idx ];
     
    19191669          coeffSigns <<= 1;
    19201670        }
    1921 #else
    1922         Int sign = static_cast<Int>( coeffSigns ) >> 31;
    1923         pcCoef[ blkPos ] = ( absCoeff[ idx ] ^ sign ) - sign;
    1924         coeffSigns <<= 1;
    1925 #endif
    19261671      }
    19271672    }
     
    19361681
    19371682
    1938 #if SAO_UNIT_INTERLEAVING
    19391683Void TDecSbac::parseSaoUvlc (UInt& ruiVal)
    19401684{
     
    21731917  }
    21741918}
    2175 #endif
    21761919
    21771920/**
     
    22041947}
    22051948
    2206 #if OL_FLUSH
    22071949Void TDecSbac::decodeFlush ( )
    22081950{
     
    22121954
    22131955}
    2214 #endif
    22151956
    22161957#if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX || (LGE_EDGE_INTRA_A0070 && LGE_EDGE_INTRA_DELTA_DC)
     
    24122153#endif
    24132154#if HHI_DMM_PRED_TEX
     2155#if LGE_DMM3_SIMP_C0044
     2156Void TDecSbac::xParseWedgePredTexInfo( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
     2157{
     2158  Int iIntraIdx = pcCU->getIntraSizeIdx(uiAbsPartIdx);
     2159  Int iBits = g_aucWedgeTexPredBitsListIdx[iIntraIdx];
     2160
     2161  UInt uiSymbol, uiTabIdx = 0;
     2162  for ( Int i = 0; i < iBits; i++ )
     2163  {
     2164    m_pcTDecBinIf->decodeBin( uiSymbol, m_cDmmDataSCModel.get(0, 0, 3) );
     2165    uiTabIdx += ( uiSymbol && i == 0 ) ? 1 : 0;
     2166    uiTabIdx += ( uiSymbol && i == 1 ) ? 2 : 0;
     2167    uiTabIdx += ( uiSymbol && i == 2 ) ? 4 : 0;
     2168    uiTabIdx += ( uiSymbol && i == 3 ) ? 8 : 0;
     2169    uiTabIdx += ( uiSymbol && i == 4 ) ? 16 : 0;
     2170    uiTabIdx += ( uiSymbol && i == 5 ) ? 32 : 0;
     2171    uiTabIdx += ( uiSymbol && i == 6 ) ? 64 : 0;
     2172    uiTabIdx += ( uiSymbol && i == 7 ) ? 128 : 0;
     2173    uiTabIdx += ( uiSymbol && i == 8 ) ? 256 : 0;
     2174    uiTabIdx += ( uiSymbol && i == 9 ) ? 512 : 0;
     2175    uiTabIdx += ( uiSymbol && i == 10 ) ? 1024 : 0;
     2176  }
     2177
     2178  pcCU->setWedgePredTexIntraTabIdxSubParts( uiTabIdx, uiAbsPartIdx, uiDepth );
     2179}
     2180#endif
     2181
    24142182Void TDecSbac::xParseWedgePredTexDeltaInfo( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
    24152183{
     2184#if LGE_DMM3_SIMP_C0044
     2185  xParseWedgePredTexInfo( pcCU, uiAbsPartIdx, uiDepth );
     2186#endif
    24162187  UInt uiDC1, uiDC2;
    24172188  xReadExGolombLevel( uiDC1, m_cDmmDataSCModel.get(0, 0, 1) );
  • trunk/source/Lib/TLibDecoder/TDecSbac.h

    r210 r296  
    7474  Void xCopyFrom           ( TDecSbac* pSrc );
    7575  Void xCopyContextsFrom       ( TDecSbac* pSrc );
    76 #if OL_FLUSH
    7776  Void decodeFlush();
    78 #endif
    7977
    8078#if CABAC_INIT_FLAG
     
    9088  Void  parseVPS                  ( TComVPS* pcVPS )  {}
    9189#endif
    92 #if HHI_MPI
     90#if HHI_MPI || OL_QTLIMIT_PREDCODING_B0068
    9391  Void  parseSPS                  ( TComSPS* pcSPS, Bool bIsDepth ) {}
    9492#else
    9593  Void  parseSPS                  ( TComSPS* pcSPS         ) {}
    9694#endif
    97 #if TILES_OR_ENTROPY_SYNC_IDC 
    9895  Void  parsePPS                  ( TComPPS* pcPPS, ParameterSetManagerDecoder *parameterSet         ) {}
    99 #else
    100   Void  parsePPS                  ( TComPPS* pcPPS         ) {}
    101 #endif
    10296  Void  parseAPS                  ( TComAPS* pAPS          ) {}
    10397  void parseSEI(SEImessages&) {}
    10498
    105 #if LCU_SYNTAX_ALF
     99#if MTK_DEPTH_MERGE_TEXTURE_CANDIDATE_C0137
     100  Void  parseSliceHeader          ( TComSlice*& rpcSlice, ParameterSetManagerDecoder *parameterSetManager, AlfCUCtrlInfo &alfCUCtrl, AlfParamSet& alfParamSet, bool isDepth) {}
     101#else
    106102  Void  parseSliceHeader          ( TComSlice*& rpcSlice, ParameterSetManagerDecoder *parameterSetManager, AlfCUCtrlInfo &alfCUCtrl, AlfParamSet& alfParamSet) {}
    107 #else
    108   Void  parseSliceHeader          ( TComSlice*& rpcSlice, ParameterSetManagerDecoder *parameterSetManager, AlfCUCtrlInfo &alfCUCtrl ) {}
    109103#endif
    110104
    111105  Void  parseTerminatingBit       ( UInt& ruiBit );
    112 #if HHI_INTER_VIEW_MOTION_PRED
     106#if H3D_IVMP
    113107  Void  parseMVPIdx               ( Int& riMVPIdx, Int iNumAMVPCands );
    114108#else
     
    116110#endif
    117111 
    118 #if SAO_UNIT_INTERLEAVING
    119112  Void  parseSaoUvlc              ( UInt& ruiVal           );
    120113  Void  parseSaoSvlc              ( Int&  riVal            );
     
    125118  Void  parseSaoOneLcuInterleaving(Int rx, Int ry, SAOParam* pSaoParam, TComDataCU* pcCU, Int iCUAddrInSlice, Int iCUAddrUpInSlice, Bool bLFCrossSliceBoundaryFlag);
    126119  Void  parseSaoOffset            (SaoLcuParam* psSaoLcuParam);
    127 #endif
    128120 
    129121#if RWTH_SDC_DLT_B0036
     
    148140#endif
    149141#if HHI_DMM_PRED_TEX
     142#if LGE_DMM3_SIMP_C0044
     143  Void xParseWedgePredTexInfo       ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth );
     144#endif
    150145  Void xParseWedgePredTexDeltaInfo  ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth );
    151146  Void xParseContourPredTexDeltaInfo( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth );
     
    178173  Void parseMergeFlag     ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, UInt uiPUIdx );
    179174  Void parseMergeIndex    ( TComDataCU* pcCU, UInt& ruiMergeIndex, UInt uiAbsPartIdx, UInt uiDepth );
    180 #if HHI_INTER_VIEW_RESIDUAL_PRED
     175#if H3D_IVRP
    181176  Void parseResPredFlag   ( TComDataCU* pcCU, Bool& rbResPredFlag, UInt uiAbsPartIdx, UInt uiDepth );
    182177#endif
     
    221216  ContextModel3DBuffer m_cCUMergeFlagExtSCModel;
    222217  ContextModel3DBuffer m_cCUMergeIdxExtSCModel;
    223 #if HHI_INTER_VIEW_RESIDUAL_PRED
     218#if H3D_IVRP
    224219  ContextModel3DBuffer m_cResPredFlagSCModel;
    225220#endif
     
    249244  ContextModel3DBuffer m_cALFUvlcSCModel;
    250245  ContextModel3DBuffer m_cALFSvlcSCModel;
    251 #if AMP_CTX
    252246  ContextModel3DBuffer m_cCUAMPSCModel;
    253 #else
    254   ContextModel3DBuffer m_cCUXPosiSCModel;
    255   ContextModel3DBuffer m_cCUYPosiSCModel;
    256 #endif
    257247  ContextModel3DBuffer m_cSaoFlagSCModel;
    258248  ContextModel3DBuffer m_cSaoUvlcSCModel;
    259249  ContextModel3DBuffer m_cSaoSvlcSCModel;
    260 #if SAO_UNIT_INTERLEAVING
    261250  ContextModel3DBuffer m_cSaoMergeLeftSCModel;
    262251  ContextModel3DBuffer m_cSaoMergeUpSCModel;
    263252  ContextModel3DBuffer m_cSaoTypeIdxSCModel;
    264 #endif
    265253
    266254#if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
  • trunk/source/Lib/TLibDecoder/TDecSlice.cpp

    r210 r296  
    148148  UInt uiCol=0, uiLin=0, uiSubStrm=0;
    149149
    150 #if !REMOVE_TILE_DEPENDENCE
    151   Int iBreakDep;
    152 #endif
    153150  UInt uiTileCol;
    154151  UInt uiTileStartLCU;
     
    163160    pcCU = rpcPic->getCU( iCUAddr );
    164161    pcCU->initCU( rpcPic, iCUAddr );
    165 #if !REMOVE_TILE_DEPENDENCE
    166     iBreakDep = rpcPic->getPicSym()->getTileBoundaryIndependenceIdr();
    167 #endif
    168162    uiTileCol = rpcPic->getPicSym()->getTileIdxMap(iCUAddr) % (rpcPic->getPicSym()->getNumColumnsMinus1()+1); // what column of tiles are we in?
    169163    uiTileStartLCU = rpcPic->getPicSym()->getTComTile(rpcPic->getPicSym()->getTileIdxMap(iCUAddr))->getFirstCUAddr();
     
    175169    uiLin     = iCUAddr / uiWidthInLCUs;
    176170    // inherit from TR if necessary, select substream to use.
    177 #if WPP_SIMPLIFICATION
    178171    if( iSymbolMode && pcSlice->getPPS()->getNumSubstreams() > 1 )
    179 #else
    180     if( iSymbolMode && pcSlice->getPPS()->getEntropyCodingSynchro() )
    181 #endif
    182     {
    183 #if !REMOVE_TILE_DEPENDENCE
    184 #if WPP_SIMPLIFICATION
    185       if (iBreakDep && pcSlice->getPPS()->getNumSubstreams() > 1)
    186 #else
    187       if (iBreakDep && pcSlice->getPPS()->getEntropyCodingSynchro())
    188 #endif
    189 #else
    190 #if WPP_SIMPLIFICATION
     172    {
    191173      if (pcSlice->getPPS()->getNumSubstreams() > 1)
    192 #else
    193       if (pcSlice->getPPS()->getEntropyCodingSynchro())
    194 #endif
    195 #endif
    196174      {
    197175        // independent tiles => substreams are "per tile".  iNumSubstreams has already been multiplied.
     
    207185      m_pcEntropyDecoder->setBitstream( ppcSubstreams[uiSubStrm] );
    208186      // Synchronize cabac probabilities with upper-right LCU if it's available and we're at the start of a line.
    209 #if WPP_SIMPLIFICATION
    210187      if (pcSlice->getPPS()->getNumSubstreams() > 1 && uiCol == uiTileLCUX)
    211 #else
    212       if (pcSlice->getPPS()->getEntropyCodingSynchro() && uiCol == uiTileLCUX)
    213 #endif
    214188      {
    215189        // We'll sync if the TR is available.
     
    217191        UInt uiWidthInCU = rpcPic->getFrameWidthInCU();
    218192        TComDataCU *pcCUTR = NULL;
    219 #if WPP_SIMPLIFICATION
    220193        if ( pcCUUp && ((iCUAddr%uiWidthInCU+1) < uiWidthInCU)  )
    221194        {
    222195          pcCUTR = rpcPic->getCU( iCUAddr - uiWidthInCU + 1 );
    223196        }
    224 #else
    225         if ( pcCUUp && ((iCUAddr%uiWidthInCU+pcSlice->getPPS()->getEntropyCodingSynchro()) < uiWidthInCU)  )
    226         {
    227           pcCUTR = rpcPic->getCU( iCUAddr - uiWidthInCU + pcSlice->getPPS()->getEntropyCodingSynchro() );
    228         }
    229 #endif
    230197        UInt uiMaxParts = 1<<(pcSlice->getSPS()->getMaxCUDepth()<<1);
    231198
     
    233200             ((pcCUTR==NULL) || (pcCUTR->getSlice()==NULL) ||
    234201             ((pcCUTR->getSCUAddr()+uiMaxParts-1) < pcSlice->getSliceCurStartCUAddr()) ||
    235 #if !REMOVE_TILE_DEPENDENCE
    236              (rpcPic->getPicSym()->getTileBoundaryIndependenceIdr() && (rpcPic->getPicSym()->getTileIdxMap( pcCUTR->getAddr() ) != rpcPic->getPicSym()->getTileIdxMap(iCUAddr)))
    237 #else
    238202             ((rpcPic->getPicSym()->getTileIdxMap( pcCUTR->getAddr() ) != rpcPic->getPicSym()->getTileIdxMap(iCUAddr)))
    239 #endif
    240203             ))||
    241204             (true/*bEnforceEntropySliceRestriction*/ &&
    242205             ((pcCUTR==NULL) || (pcCUTR->getSlice()==NULL) ||
    243206             ((pcCUTR->getSCUAddr()+uiMaxParts-1) < pcSlice->getEntropySliceCurStartCUAddr()) ||
    244 #if !REMOVE_TILE_DEPENDENCE
    245              (rpcPic->getPicSym()->getTileBoundaryIndependenceIdr() && (rpcPic->getPicSym()->getTileIdxMap( pcCUTR->getAddr() ) != rpcPic->getPicSym()->getTileIdxMap(iCUAddr)))
    246 #else
    247207             ((rpcPic->getPicSym()->getTileIdxMap( pcCUTR->getAddr() ) != rpcPic->getPicSym()->getTileIdxMap(iCUAddr)))
    248 #endif
    249208             ))
    250209           )
     
    260219      pcSbacDecoder->load(&pcSbacDecoders[uiSubStrm]);  //this load is used to simplify the code (avoid to change all the call to pcSbacDecoders)
    261220    }
    262 #if WPP_SIMPLIFICATION
    263221    else if ( iSymbolMode && pcSlice->getPPS()->getNumSubstreams() <= 1 )
    264 #else
    265     else if ( iSymbolMode && !pcSlice->getPPS()->getEntropyCodingSynchro() )
    266 #endif
    267222    {
    268223      // Set variables to appropriate values to avoid later code change.
     
    273228         (iCUAddr!=0) && (iCUAddr!=rpcPic->getPicSym()->getPicSCUAddr(rpcPic->getSlice(rpcPic->getCurrSliceIdx())->getSliceCurStartCUAddr())/rpcPic->getNumPartInCU())) // !1st in frame && !1st in slice
    274229    {
    275 #if WPP_SIMPLIFICATION
    276230      if (pcSlice->getPPS()->getNumSubstreams() > 1)
    277 #else
    278       if (pcSlice->getPPS()->getEntropyCodingSynchro())
    279 #endif
    280231      {
    281232        // We're crossing into another tile, tiles are independent.
     
    330281    }
    331282
    332 #if !REMOVE_TILE_DEPENDENCE
    333     if ( (rpcPic->getPicSym()->getTileBoundaryIndependenceIdr()==0) && (rpcPic->getPicSym()->getNumColumnsMinus1()!=0) )
    334     {   
    335       // Synchronize cabac probabilities with LCU among Tiles
    336       if( (uiTileLCUX != 0) &&
    337           (iCUAddr == rpcPic->getPicSym()->getTComTile(rpcPic->getPicSym()->getTileIdxMap(iCUAddr))->getFirstCUAddr()) )
    338       {       
    339         TComDataCU *pcCULeft = pcCU->getCULeft();
    340         UInt uiMaxParts = 1<<(pcSlice->getSPS()->getMaxCUDepth()<<1);
    341 
    342         if ( (true/*bEnforceSliceRestriction*/ &&
    343               ((pcCULeft==NULL) || (pcCULeft->getSlice()==NULL) ||
    344                ((pcCULeft->getSCUAddr()+uiMaxParts-1) < pcSlice->getSliceCurStartCUAddr())
    345               )
    346              )||
    347              (true/*bEnforceEntropySliceRestriction*/ &&
    348               ((pcCULeft==NULL) || (pcCULeft->getSlice()==NULL) ||
    349                ((pcCULeft->getSCUAddr()+uiMaxParts-1) < pcSlice->getEntropySliceCurStartCUAddr())
    350               )
    351              )
    352            )
    353         {
    354           // Left not available.
    355         }
    356         else
    357         {
    358           // Left is available, we use it.
    359           pcSbacDecoders[uiSubStrm].loadContexts( &m_pcBufferLowLatSbacDecoders[uiTileCol-1] );
    360           pcSbacDecoder->loadContexts(&pcSbacDecoders[uiSubStrm]);  //this load is used to simplify the code (avoid to change all the call to pcSbacDecoders)
    361         }
    362       }
    363     }
    364 #endif
    365283
    366284
     
    368286    g_bJustDoIt = g_bEncDecTraceEnable;
    369287#endif
    370 #if SAO_UNIT_INTERLEAVING
    371288    if ( pcSlice->getSPS()->getUseSAO() && pcSlice->getSaoInterleavingFlag() && pcSlice->getSaoEnabledFlag() )
    372289    {
     
    384301      pcSbacDecoder->parseSaoOneLcuInterleaving(rx, ry, pcSlice->getAPS()->getSaoParam(),pcCU, cuAddrInSlice, cuAddrUpInSlice, pcSlice->getSPS()->getLFCrossSliceBoundaryFlag() );
    385302    }
    386 #endif
    387303
    388304    m_pcCuDecoder->decodeCU     ( pcCU, uiIsLast );
     
    394310    if( iSymbolMode )
    395311    {
    396 #if OL_FLUSH
    397312      /*If at the end of a LCU line but not at the end of a substream, perform CABAC flush*/
    398 #if WPP_SIMPLIFICATION
    399313      if (!uiIsLast && pcSlice->getPPS()->getNumSubstreams() > 1)
    400 #else
    401       if (!uiIsLast && pcSlice->getPPS()->getCabacIstateReset())
    402 #endif
    403       {
    404 #if !REMOVE_TILE_DEPENDENCE
    405         if ((iBreakDep && (uiCol == uiTileLCUX+uiTileWidth-1) && (uiLin+iNumSubstreamsPerTile < uiTileLCUY+uiTileHeight))
    406             || (!iBreakDep && (uiCol == uiWidthInLCUs-1) && (uiLin+iNumSubstreams < pcCU->getPic()->getFrameHeightInCU())))
    407 #else
     314      {
    408315        if ((uiCol == uiTileLCUX+uiTileWidth-1) && (uiLin+iNumSubstreamsPerTile < uiTileLCUY+uiTileHeight))
    409 #endif
    410316        {
    411317          m_pcEntropyDecoder->decodeFlush();
    412318        }
    413319      }
    414 #endif
    415320      pcSbacDecoders[uiSubStrm].load(pcSbacDecoder);
    416321
    417322      //Store probabilities of second LCU in line into buffer
    418 #if WPP_SIMPLIFICATION
    419323      if (pcSlice->getPPS()->getNumSubstreams() > 1 && (uiCol == uiTileLCUX+1))
    420 #else
    421       if (pcSlice->getPPS()->getEntropyCodingSynchro() && (uiCol == uiTileLCUX+pcSlice->getPPS()->getEntropyCodingSynchro()))
    422 #endif
    423324      {
    424325        m_pcBufferSbacDecoders[uiTileCol].loadContexts( &pcSbacDecoders[uiSubStrm] );
     
    426327
    427328    }
    428 #if !REMOVE_TILE_DEPENDENCE
    429     if ( (rpcPic->getPicSym()->getTileBoundaryIndependenceIdr()==0) && (rpcPic->getPicSym()->getNumColumnsMinus1()!=0) )
    430     {
    431       pcSbacDecoders[uiSubStrm].load(pcSbacDecoder);
    432        //Store probabilties for next tile
    433       if( (uiLin == (rpcPic->getPicSym()->getTComTile(rpcPic->getPicSym()->getTileIdxMap(iCUAddr))->getFirstCUAddr() / uiWidthInLCUs )) &&
    434           (uiCol == rpcPic->getPicSym()->getTComTile(rpcPic->getPicSym()->getTileIdxMap(iCUAddr))->getRightEdgePosInCU()) )
    435       {
    436         m_pcBufferLowLatSbacDecoders[uiTileCol].loadContexts( &pcSbacDecoders[uiSubStrm] );
    437       }
    438     }
    439 #endif
    440329  }
    441330
  • trunk/source/Lib/TLibDecoder/TDecTop.cpp

    r210 r296  
    5959    m_aaiCodedScale       [ uiId ] = new Int [ MAX_VIEW_NUM ];
    6060  }
     61
     62#if MERL_VSP_C0152
     63  xCreateLUTs( (UInt)MAX_VIEW_NUM, (UInt)MAX_VIEW_NUM, m_adBaseViewShiftLUT, m_aiBaseViewShiftLUT );
     64  m_iLog2Precision   = LOG2_DISP_PREC_LUT;
     65  m_uiBitDepthForLUT = 8; // fixed
     66#endif
    6167}
    6268
     
    7278  delete [] m_aiViewOrderIndex;
    7379  delete [] m_aiViewReceived;
     80
     81#if MERL_VSP_C0152
     82  xDeleteArray( m_adBaseViewShiftLUT, MAX_VIEW_NUM, MAX_VIEW_NUM, 2 );
     83  xDeleteArray( m_aiBaseViewShiftLUT, MAX_VIEW_NUM, MAX_VIEW_NUM, 2 );
     84#endif
    7485}
    7586
     
    8596  m_uiMaxViewId             = 0;
    8697}
     98
     99#if MERL_VSP_C0152
     100Void
     101CamParsCollector::xCreateLUTs( UInt uiNumberSourceViews, UInt uiNumberTargetViews, Double****& radLUT, Int****& raiLUT)
     102{
     103  //AOF( m_uiBitDepthForLUT == 8 );
     104  //AOF(radLUT == NULL && raiLUT == NULL );
     105
     106  uiNumberSourceViews = Max( 1, uiNumberSourceViews );
     107  uiNumberTargetViews = Max( 1, uiNumberTargetViews );
     108
     109  radLUT         = new Double***[ uiNumberSourceViews ];
     110  raiLUT         = new Int   ***[ uiNumberSourceViews ];
     111
     112  for( UInt uiSourceView = 0; uiSourceView < uiNumberSourceViews; uiSourceView++ )
     113  {
     114    radLUT        [ uiSourceView ] = new Double**[ uiNumberTargetViews ];
     115    raiLUT        [ uiSourceView ] = new Int   **[ uiNumberTargetViews ];
     116
     117    for( UInt uiTargetView = 0; uiTargetView < uiNumberTargetViews; uiTargetView++ )
     118    {
     119      radLUT        [ uiSourceView ][ uiTargetView ]      = new Double*[ 2 ];
     120      radLUT        [ uiSourceView ][ uiTargetView ][ 0 ] = new Double [ 257 ];
     121      radLUT        [ uiSourceView ][ uiTargetView ][ 1 ] = new Double [ 257 ];
     122
     123      raiLUT        [ uiSourceView ][ uiTargetView ]      = new Int*   [ 2 ];
     124      raiLUT        [ uiSourceView ][ uiTargetView ][ 0 ] = new Int    [ 257 ];
     125      raiLUT        [ uiSourceView ][ uiTargetView ][ 1 ] = new Int    [ 257 ];
     126    }
     127  }
     128}
     129
     130Void
     131  CamParsCollector::xInitLUTs( UInt uiSourceView, UInt uiTargetView, Int iScale, Int iOffset, Double****& radLUT, Int****& raiLUT)
     132{
     133  Int     iLog2DivLuma   = m_uiBitDepthForLUT + m_uiCamParsCodedPrecision + 1 - m_iLog2Precision;   AOF( iLog2DivLuma > 0 );
     134  Int     iLog2DivChroma = iLog2DivLuma + 1;
     135
     136  iOffset <<= m_uiBitDepthForLUT;
     137
     138  Double dScale  = (Double) iScale  / (( Double ) ( 1 << iLog2DivLuma ));
     139  Double dOffset = (Double) iOffset / (( Double ) ( 1 << iLog2DivLuma ));
     140
     141  // offsets including rounding offsets
     142  Int64 iOffsetLuma   = iOffset + ( ( 1 << iLog2DivLuma   ) >> 1 );
     143  Int64 iOffsetChroma = iOffset + ( ( 1 << iLog2DivChroma ) >> 1 );
     144
     145
     146  for( UInt uiDepthValue = 0; uiDepthValue < 256; uiDepthValue++ )
     147  {
     148
     149    // real-valued look-up tables
     150    Double  dShiftLuma      = ( (Double)uiDepthValue * dScale + dOffset ) * Double( 1 << m_iLog2Precision );
     151    Double  dShiftChroma    = dShiftLuma / 2;
     152    radLUT[ uiSourceView ][ uiTargetView ][ 0 ][ uiDepthValue ] = dShiftLuma;
     153    radLUT[ uiSourceView ][ uiTargetView ][ 1 ][ uiDepthValue ] = dShiftChroma;
     154
     155    // integer-valued look-up tables
     156    Int64   iTempScale      = (Int64)uiDepthValue * iScale;
     157    Int64   iShiftLuma      = ( iTempScale + iOffsetLuma   ) >> iLog2DivLuma;
     158    Int64   iShiftChroma    = ( iTempScale + iOffsetChroma ) >> iLog2DivChroma;
     159    raiLUT[ uiSourceView ][ uiTargetView ][ 0 ][ uiDepthValue ] = (Int)iShiftLuma;
     160    raiLUT[ uiSourceView ][ uiTargetView ][ 1 ][ uiDepthValue ] = (Int)iShiftChroma;
     161
     162    // maximum deviation
     163    //dMaxDispDev     = Max( dMaxDispDev,    fabs( Double( (Int) iTestScale   ) - dShiftLuma * Double( 1 << iLog2DivLuma ) ) / Double( 1 << iLog2DivLuma ) );
     164    //dMaxRndDispDvL  = Max( dMaxRndDispDvL, fabs( Double( (Int) iShiftLuma   ) - dShiftLuma   ) );
     165    //dMaxRndDispDvC  = Max( dMaxRndDispDvC, fabs( Double( (Int) iShiftChroma ) - dShiftChroma ) );
     166  }
     167
     168  radLUT[ uiSourceView ][ uiTargetView ][ 0 ][ 256 ] = radLUT[ uiSourceView ][ uiTargetView ][ 0 ][ 255 ];
     169  radLUT[ uiSourceView ][ uiTargetView ][ 1 ][ 256 ] = radLUT[ uiSourceView ][ uiTargetView ][ 1 ][ 255 ];
     170  raiLUT[ uiSourceView ][ uiTargetView ][ 0 ][ 256 ] = raiLUT[ uiSourceView ][ uiTargetView ][ 0 ][ 255 ];
     171  raiLUT[ uiSourceView ][ uiTargetView ][ 1 ][ 256 ] = raiLUT[ uiSourceView ][ uiTargetView ][ 1 ][ 255 ];
     172}
     173#endif // end MERL_VSP_C0152
    87174
    88175Void
     
    167254        m_aaiCodedScale [ uiViewId ][ uiBaseId ]  = pcSlice->getInvCodedScale () [ uiBaseId ];
    168255        m_aaiCodedOffset[ uiViewId ][ uiBaseId ]  = pcSlice->getInvCodedOffset() [ uiBaseId ];
     256#if MERL_VSP_C0152
     257        xInitLUTs( uiBaseId, uiViewId, m_aaiCodedScale[ uiBaseId ][ uiViewId ], m_aaiCodedOffset[ uiBaseId ][ uiViewId ], m_adBaseViewShiftLUT, m_aiBaseViewShiftLUT);
     258        xInitLUTs( uiViewId, uiBaseId, m_aaiCodedScale[ uiViewId ][ uiBaseId ], m_aaiCodedOffset[ uiViewId ][ uiBaseId ], m_adBaseViewShiftLUT, m_aiBaseViewShiftLUT);
     259#endif
    169260      }
    170261      else
     
    174265        m_aaiCodedScale [ uiViewId ][ uiBaseId ]  = pcSlice->getSPS()->getInvCodedScale () [ uiBaseId ];
    175266        m_aaiCodedOffset[ uiViewId ][ uiBaseId ]  = pcSlice->getSPS()->getInvCodedOffset() [ uiBaseId ];
     267#if MERL_VSP_C0152
     268        xInitLUTs( uiBaseId, uiViewId, m_aaiCodedScale[ uiBaseId ][ uiViewId ], m_aaiCodedOffset[ uiBaseId ][ uiViewId ], m_adBaseViewShiftLUT, m_aiBaseViewShiftLUT );
     269        xInitLUTs( uiViewId, uiBaseId, m_aaiCodedScale[ uiViewId ][ uiBaseId ], m_aaiCodedOffset[ uiViewId ][ uiBaseId ], m_adBaseViewShiftLUT, m_aiBaseViewShiftLUT );
     270#endif
    176271      }
    177272    }
     
    188283        m_aaiCodedScale [ uiViewId ][ uiBaseId ]  = pcSlice->getInvCodedScale () [ uiBaseId ];
    189284        m_aaiCodedOffset[ uiViewId ][ uiBaseId ]  = pcSlice->getInvCodedOffset() [ uiBaseId ];
     285#if MERL_VSP_C0152
     286        xInitLUTs( uiBaseId, uiViewId, m_aaiCodedScale[ uiBaseId ][ uiViewId ], m_aaiCodedOffset[ uiBaseId ][ uiViewId ], m_adBaseViewShiftLUT, m_aiBaseViewShiftLUT );
     287        xInitLUTs( uiViewId, uiBaseId, m_aaiCodedScale[ uiViewId ][ uiBaseId ], m_aaiCodedOffset[ uiViewId ][ uiBaseId ], m_adBaseViewShiftLUT, m_aiBaseViewShiftLUT );
     288#endif
    190289      }
    191290    }
     
    254353  m_iMaxRefPicNum = 0;
    255354  m_uiValidPS = 0;
    256 #if SONY_COLPIC_AVAILABILITY
    257   m_iViewOrderIdx = 0;
    258 #endif
    259355#if ENC_DEC_TRACE
    260   g_hTrace = fopen( "TraceDec.txt", "wb" );
     356  if(!g_hTrace) g_hTrace = fopen( "TraceDec.txt", "wb" );
    261357  g_bJustDoIt = g_bEncDecTraceDisable;
    262358  g_nSymbolCounter = 0;
     
    277373{
    278374#if ENC_DEC_TRACE
    279   fclose( g_hTrace );
     375  if(g_hTrace) fclose( g_hTrace );
     376  g_hTrace=NULL;
    280377#endif
    281378}
     
    301398  m_cDepthMapGenerator.destroy();
    302399#endif
    303 #if HHI_INTER_VIEW_RESIDUAL_PRED
     400#if H3D_IVRP
    304401  m_cResidualGenerator.destroy();
    305402#endif
     403
    306404}
    307405
     
    317415                    , &m_cDepthMapGenerator
    318416#endif
    319 #if HHI_INTER_VIEW_RESIDUAL_PRED
     417#if H3D_IVRP
    320418                    , &m_cResidualGenerator
    321419#endif
     
    331429#endif
    332430#endif
    333 #if HHI_INTER_VIEW_RESIDUAL_PRED
     431#if H3D_IVRP
    334432  m_cResidualGenerator.init( &m_cTrQuant, &m_cDepthMapGenerator );
    335433#endif
     
    367465}
    368466
    369 #if HHI_INTER_VIEW_RESIDUAL_PRED
     467#if H3D_IVRP
    370468Void
    371469TDecTop::deleteExtraPicBuffers( Int iPoc )
     
    427525  xUpdateGopSize(pcSlice);
    428526 
    429 #if H0567_DPB_PARAMETERS_PER_TEMPORAL_LAYER
    430527  m_iMaxRefPicNum = pcSlice->getSPS()->getMaxDecPicBuffering(pcSlice->getTLayer())+pcSlice->getSPS()->getNumReorderPics(pcSlice->getTLayer()) + 1; // +1 to have space for the picture currently being decoded
    431 #else
    432   m_iMaxRefPicNum = pcSlice->getSPS()->getMaxNumberOfReferencePictures()+pcSlice->getSPS()->getNumReorderFrames() + 1; // +1 to have space for the picture currently being decoded
    433 #endif
    434528
    435529#if DEPTH_MAP_GENERATION
     
    618712  }
    619713
    620 #if !LCU_SYNTAX_ALF
    621   // create ALF temporary buffer
    622   m_cAdaptiveLoopFilter.create( sps->getPicWidthInLumaSamples(), sps->getPicHeightInLumaSamples(), g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth );
    623 #endif
    624714  m_cSAO.create( sps->getPicWidthInLumaSamples(), sps->getPicHeightInLumaSamples(), g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth );
    625715  m_cLoopFilter.        create( g_uiMaxCUDepth );
    626716}
    627717
    628 #if SKIPFRAME_BUGFIX
    629718Bool TDecTop::xDecodeSlice(InputNALUnit &nalu, Int &iSkipFrame, Int iPOCLastDisplay )
    630 #else
    631 Bool TDecTop::xDecodeSlice(InputNALUnit &nalu, Int iSkipFrame, Int iPOCLastDisplay )
    632 #endif
    633719{
    634720  TComPic*&   pcPic         = m_pcPic;
     
    687773  }
    688774
    689 #if SONY_COLPIC_AVAILABILITY
    690   m_apcSlicePilot->setViewOrderIdx( m_apcSlicePilot->getSPS()->getViewOrderIdx());
    691 #endif
    692 
    693 #if NAL_REF_FLAG
    694775  m_apcSlicePilot->setReferenced(nalu.m_nalRefFlag);
     776  m_apcSlicePilot->setTLayerInfo(nalu.m_temporalId);
     777
     778  // ALF CU parameters should be part of the slice header -> needs to be fixed
     779#if MTK_DEPTH_MERGE_TEXTURE_CANDIDATE_C0137
     780  m_cEntropyDecoder.decodeSliceHeader (m_apcSlicePilot, &m_parameterSetManagerDecoder, m_cGopDecoder.getAlfCuCtrlParam(), m_cGopDecoder.getAlfParamSet(),m_apcSlicePilot->getVPS()->getDepthFlag(nalu.m_layerId));
    695781#else
    696   m_apcSlicePilot->setReferenced(nalu.m_nalRefIDC != NAL_REF_IDC_PRIORITY_LOWEST);
    697 #endif
    698   m_apcSlicePilot->setTLayerInfo(nalu.m_temporalId);
    699 
    700   // ALF CU parameters should be part of the slice header -> needs to be fixed
    701 #if LCU_SYNTAX_ALF
    702782  m_cEntropyDecoder.decodeSliceHeader (m_apcSlicePilot, &m_parameterSetManagerDecoder, m_cGopDecoder.getAlfCuCtrlParam(), m_cGopDecoder.getAlfParamSet());
    703 #else
    704   m_cEntropyDecoder.decodeSliceHeader (m_apcSlicePilot, &m_parameterSetManagerDecoder, m_cGopDecoder.getAlfCuCtrlParam() );
    705783#endif
    706784  // byte align
     
    718796  if (m_apcSlicePilot->isNextSlice() && m_apcSlicePilot->getPOC()!=m_prevPOC && !m_bFirstSliceInSequence)
    719797  {
    720 #if START_DECODING_AT_CRA
    721798    if (m_prevPOC >= m_pocRandomAccess)
    722799    {
     
    725802    }
    726803    m_prevPOC = m_apcSlicePilot->getPOC();
    727 #else
    728     m_prevPOC = m_apcSlicePilot->getPOC();
    729     return true;
    730 #endif
    731804  }
    732805  // actual decoding starts here
     
    748821  }
    749822  //detect lost reference picture and insert copy of earlier frame.
    750 #if START_DECODING_AT_CRA
    751823  while(m_apcSlicePilot->checkThatAllRefPicsAreAvailable(m_cListPic, m_apcSlicePilot->getRPS(), true, m_pocRandomAccess) > 0)
    752 #else
    753   while(m_apcSlicePilot->checkThatAllRefPicsAreAvailable(m_cListPic, m_apcSlicePilot->getRPS(), true) > 0)
    754 #endif
    755824  {
    756825    xCreateLostPicture(m_apcSlicePilot->checkThatAllRefPicsAreAvailable(m_cListPic, m_apcSlicePilot->getRPS(), false)-1);
     
    764833    xGetNewPicBuffer (m_apcSlicePilot, pcPic);
    765834
    766 #if SONY_COLPIC_AVAILABILITY
    767     pcPic->setViewOrderIdx( m_apcSlicePilot->getSPS()->getViewOrderIdx() );
    768 #endif
    769 
     835#if INTER_VIEW_VECTOR_SCALING_C0115
     836    pcPic->setViewOrderIdx( m_apcSlicePilot->getVPS()->getViewOrderIdx(nalu.m_layerId) );    // will be changed to view_id
     837#endif
    770838    /* transfer any SEI messages that have been received to the picture */
    771839    pcPic->setSEIs(m_SEIs);
     
    787855    }
    788856#endif
    789 #if HHI_INTER_VIEW_RESIDUAL_PRED
     857#if H3D_IVRP
    790858    m_cResidualGenerator.create( true, m_apcSlicePilot->getSPS()->getPicWidthInLumaSamples(), m_apcSlicePilot->getSPS()->getPicHeightInLumaSamples(), g_uiMaxCUDepth, g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiBitDepth + g_uiBitIncrement );
    791859#endif
     
    800868  UInt i, j, p;
    801869
    802 #if !REMOVE_TILE_DEPENDENCE
    803   //set the TileBoundaryIndependenceIdr
    804   if(pcSlice->getPPS()->getTileBehaviorControlPresentFlag() == 1)
    805   {
    806     pcPic->getPicSym()->setTileBoundaryIndependenceIdr( pcSlice->getPPS()->getTileBoundaryIndependenceIdr() );
    807   }
    808   else
    809   {
    810     pcPic->getPicSym()->setTileBoundaryIndependenceIdr( pcSlice->getPPS()->getSPS()->getTileBoundaryIndependenceIdr() );
    811   }
    812 #endif
    813870
    814871  if( pcSlice->getPPS()->getColumnRowInfoPresent() == 1 )
     
    9921049#endif
    9931050
    994 #if SONY_COLPIC_AVAILABILITY
     1051#if INTER_VIEW_VECTOR_SCALING_C0115
    9951052#if VIDYO_VPS_INTEGRATION
    996     pcSlice->setViewOrderIdx( pcSlice->getVPS()->getViewOrderIdx(nalu.m_layerId) );
     1053    pcSlice->setViewOrderIdx( pcSlice->getVPS()->getViewOrderIdx(nalu.m_layerId) );        // will be changed to view_id
    9971054#else
    9981055    pcSlice->setViewOrderIdx( pcPic->getViewOrderIdx() );
    9991056#endif
     1057#endif
     1058
     1059#if INTER_VIEW_VECTOR_SCALING_C0115
     1060    pcSlice->setIVScalingFlag( pcSlice->getVPS()->getIVScalingFlag());
    10001061#endif
    10011062
     
    11111172#endif
    11121173
     1174#if MERL_VSP_C0152 // set BW LUT
     1175  if( m_pcCamParsCollector ) // Initialize the LUT elements
     1176  {
     1177    m_pcCamParsCollector->setSlice( pcSlice );
     1178  }
     1179  if( pcSlice->getViewId() !=0 )
     1180  {
     1181    TComPic* pcBaseTxtPic = m_tAppDecTop->getPicFromView(  0, pcSlice->getPOC(), false );  // get base view reconstructed texture
     1182    TComPic* pcBaseDepthPic = m_tAppDecTop->getPicFromView(  0, pcSlice->getPOC(), true ); // get base view reconstructed depth
     1183     pcSlice->setRefPicBaseTxt(pcBaseTxtPic);
     1184     pcSlice->setRefPicBaseDepth(pcBaseDepthPic);
     1185  }
     1186  getTAppDecTop()->setBWVSPLUT( pcSlice, pcSlice->getViewId(),  pcSlice->getPOC() ); // get the LUT for backward warping
     1187#endif
     1188
    11131189  //  Decode a picture
    11141190  m_cGopDecoder.decompressGop(nalu.m_Bitstream, pcPic, false);
     
    11491225{
    11501226  TComSPS* sps = new TComSPS();
    1151 #if RPS_IN_SPS
    11521227  TComRPSList* rps = new TComRPSList();
    11531228  sps->setRPSList(rps);
    1154 #endif
    1155 #if HHI_MPI
     1229#if HHI_MPI || OL_QTLIMIT_PREDCODING_B0068
    11561230  m_cEntropyDecoder.decodeSPS( sps, m_isDepth );
    11571231#else
     
    11591233#endif
    11601234  m_parameterSetManagerDecoder.storePrefetchedSPS(sps);
    1161 #if LCU_SYNTAX_ALF
    11621235  m_cAdaptiveLoopFilter.create( sps->getPicWidthInLumaSamples(), sps->getPicHeightInLumaSamples(), g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth );
    1163 #endif
    11641236}
    11651237
    11661238Void TDecTop::xDecodePPS()
    11671239{
    1168 #if !RPS_IN_SPS
    1169   TComRPSList* rps = new TComRPSList();
    1170 #endif
    11711240  TComPPS* pps = new TComPPS();
    1172 #if !RPS_IN_SPS
    1173   pps->setRPSList(rps);
    1174 #endif
    1175 #if TILES_OR_ENTROPY_SYNC_IDC
    11761241  m_cEntropyDecoder.decodePPS( pps, &m_parameterSetManagerDecoder );
    1177 #else
    1178   m_cEntropyDecoder.decodePPS( pps );
    1179 #endif
    11801242  m_parameterSetManagerDecoder.storePrefetchedPPS( pps );
    11811243
     
    12301292    case NAL_UNIT_CODED_SLICE:
    12311293    case NAL_UNIT_CODED_SLICE_IDR:
    1232 #if H0566_TLA
    12331294#if !QC_REM_IDV_B0046
    12341295    case NAL_UNIT_CODED_SLICE_IDV:
     
    12361297    case NAL_UNIT_CODED_SLICE_CRA:
    12371298    case NAL_UNIT_CODED_SLICE_TLA:
    1238 #else
    1239     case NAL_UNIT_CODED_SLICE_CDR:
    1240 #endif
    12411299      return xDecodeSlice(nalu, iSkipFrame, iPOCLastDisplay);
    12421300      break;
     
    12591317  sps = pSPSV0;
    12601318  m_parameterSetManagerDecoder.storePrefetchedSPS(sps);
    1261 #if LCU_SYNTAX_ALF
    12621319  m_cAdaptiveLoopFilter.create( sps->getPicWidthInLumaSamples(), sps->getPicHeightInLumaSamples(), g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth );
    1263 #endif
    12641320}
    12651321
     
    12961352  else if (m_pocRandomAccess == MAX_INT) // start of random access point, m_pocRandomAccess has not been set yet.
    12971353  {
    1298 #if H0566_TLA
    12991354    if( m_apcSlicePilot->getNalUnitTypeBaseViewMvc() == NAL_UNIT_CODED_SLICE_CRA )
    1300 #else
    1301     if( m_apcSlicePilot->getNalUnitTypeBaseViewMvc() == NAL_UNIT_CODED_SLICE_CDR )
    1302 #endif
    13031355    {
    13041356      m_pocRandomAccess = m_apcSlicePilot->getPOC(); // set the POC random access since we need to skip the reordered pictures in CRA.
     
    13101362    else
    13111363    {
    1312 #if START_DECODING_AT_CRA
    13131364      static bool warningMessage = false;
    13141365      if(!warningMessage)
     
    13181369      }
    13191370      return true;
    1320 #else
    1321       printf("\nUnsafe random access point. Decoder may crash.");
    1322       m_pocRandomAccess = 0;
    1323 #endif
    13241371    }
    13251372  }
     
    13421389  m_cSAO.allocSaoParam(pAPS->getSaoParam());
    13431390  pAPS->createAlfParam();
    1344 #if !LCU_SYNTAX_ALF
    1345   m_cAdaptiveLoopFilter.allocALFParam(pAPS->getAlfParam());
    1346 #endif
    13471391}
    13481392
  • trunk/source/Lib/TLibDecoder/TDecTop.h

    r210 r296  
    7777  Bool  isInitialized() const { return m_bInitialized; }
    7878
     79#if MERL_VSP_C0152
     80  Int**** getBaseViewShiftLUTI()  { return m_aiBaseViewShiftLUT;   }
     81#endif
    7982private:
    8083  Bool  xIsComplete ();
     
    97100  Int     m_iLastPOC;
    98101  UInt    m_uiMaxViewId;
     102
     103#if MERL_VSP_C0152
     104  UInt    m_uiBitDepthForLUT;
     105  UInt    m_iLog2Precision;
     106  UInt    m_uiInputBitDepth;
     107  // look-up tables
     108  Double****   m_adBaseViewShiftLUT;       ///< Disparity LUT
     109  Int****      m_aiBaseViewShiftLUT;       ///< Disparity LUT
     110  Void xCreateLUTs( UInt uiNumberSourceViews, UInt uiNumberTargetViews, Double****& radLUT, Int****& raiLUT);
     111  Void xInitLUTs( UInt uiSourceView, UInt uiTargetView, Int iScale, Int iOffset, Double****& radLUT, Int****& raiLUT);
     112  template<class T> Void  xDeleteArray  ( T*& rpt, UInt uiSize1, UInt uiSize2, UInt uiSize3 );
     113  template<class T> Void  xDeleteArray  ( T*& rpt, UInt uiSize1, UInt uiSize2 );
     114  template<class T> Void  xDeleteArray  ( T*& rpt, UInt uiSize );
     115#endif
     116
    99117};
     118
     119#if MERL_VSP_C0152
     120template <class T>
     121Void CamParsCollector::xDeleteArray( T*& rpt, UInt uiSize1, UInt uiSize2, UInt uiSize3 )
     122{
     123  if( rpt )
     124  {
     125    for( UInt uiK = 0; uiK < uiSize1; uiK++ )
     126    {
     127      for( UInt uiL = 0; uiL < uiSize2; uiL++ )
     128      {
     129        for( UInt uiM = 0; uiM < uiSize3; uiM++ )
     130        {
     131          delete[] rpt[ uiK ][ uiL ][ uiM ];
     132        }
     133        delete[] rpt[ uiK ][ uiL ];
     134      }
     135      delete[] rpt[ uiK ];
     136    }
     137    delete[] rpt;
     138  }
     139  rpt = NULL;
     140};
     141
     142
     143template <class T>
     144Void CamParsCollector::xDeleteArray( T*& rpt, UInt uiSize1, UInt uiSize2 )
     145{
     146  if( rpt )
     147  {
     148    for( UInt uiK = 0; uiK < uiSize1; uiK++ )
     149    {
     150      for( UInt uiL = 0; uiL < uiSize2; uiL++ )
     151      {
     152        delete[] rpt[ uiK ][ uiL ];
     153      }
     154      delete[] rpt[ uiK ];
     155    }
     156    delete[] rpt;
     157  }
     158  rpt = NULL;
     159};
     160
     161
     162template <class T>
     163Void CamParsCollector::xDeleteArray( T*& rpt, UInt uiSize )
     164{
     165  if( rpt )
     166  {
     167    for( UInt uiK = 0; uiK < uiSize; uiK++ )
     168    {
     169      delete[] rpt[ uiK ];
     170    }
     171    delete[] rpt;
     172  }
     173  rpt = NULL;
     174};
     175
     176#endif
    100177
    101178/// decoder class
     
    118195 
    119196  SEImessages *m_SEIs; ///< "all" SEI messages.  If not NULL, we own the object.
    120 
    121 #if SONY_COLPIC_AVAILABILITY
    122   Int                     m_iViewOrderIdx;
    123 #endif
    124197
    125198  // functional classes
     
    140213  TComDepthMapGenerator   m_cDepthMapGenerator;
    141214#endif
    142 #if HHI_INTER_VIEW_RESIDUAL_PRED
     215#if H3D_IVRP
    143216  TComResidualGenerator   m_cResidualGenerator;
    144217#endif
     
    176249  Void      xCopyVPS( TComVPS* pVPSV0);
    177250#endif
    178 #if HHI_INTER_VIEW_RESIDUAL_PRED
     251#if H3D_IVRP
    179252  Void      deleteExtraPicBuffers   ( Int iPoc );
    180253#endif
     
    186259  Int  getViewId()                { return m_viewId  ;}
    187260  Void setIsDepth( Bool isDepth ) { m_isDepth = isDepth; }
    188 
    189 #if SONY_COLPIC_AVAILABILITY
    190   Void setViewOrderIdx(Int i)     { m_iViewOrderIdx = i ;}
    191   Int  getViewOrderIdx()          { return m_iViewOrderIdx ; }
    192 #endif
    193261
    194262#if DEPTH_MAP_GENERATION
     
    206274  ParameterSetManagerDecoder* xGetParaSetDec ()        {return  &m_parameterSetManagerDecoder;}
    207275#endif
     276
    208277protected:
    209278  Void  xGetNewPicBuffer  (TComSlice* pcSlice, TComPic*& rpcPic);
     
    213282  Void      decodeAPS( TComAPS* cAPS) { m_cEntropyDecoder.decodeAPS(cAPS); };
    214283  Void      xActivateParameterSets();
    215 #if SKIPFRAME_BUGFIX
    216284  Bool      xDecodeSlice(InputNALUnit &nalu, Int &iSkipFrame, Int iPOCLastDisplay);
    217 #else
    218   Bool      xDecodeSlice(InputNALUnit &nalu, Int iSkipFrame, Int iPOCLastDisplay);
    219 #endif
    220285#if VIDYO_VPS_INTEGRATION|QC_MVHEVC_B0046
    221286  Void      xDecodeVPS();
Note: See TracChangeset for help on using the changeset viewer.