source: 3DVCSoftware/branches/HTM-14.1-update-dev1-HHI/source/Lib/TLibDecoder/TDecSbac.cpp @ 1209

Last change on this file since 1209 was 1209, checked in by hhi, 9 years ago

Alignment and reactivation of DMM and depth encoder optimizations:

  • new macro NH_3D_DMM for DMM functionality, including several clean-ups.
  • new macro NH_3D_SDC for SDC functionality, currently only used for covering common SDC and DMM parts.
  • new macro NH_3D_ENC_DEPTH for encoder optimizations related to depth.
  • temporary macro TEMP_SDC_CLEANUP for covering several proposed cleanups related to SDC and DMM.
  • Property svn:eol-style set to native
File size: 88.8 KB
Line 
1/* The copyright in this software is being made available under the BSD
2 * License, included below. This software may be subject to other third party
3 * and contributor rights, including patent rights, and no such rights are
4 * granted under this license.
5 *
6 * Copyright (c) 2010-2015, ITU/ISO/IEC
7 * All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions are met:
11 *
12 *  * Redistributions of source code must retain the above copyright notice,
13 *    this list of conditions and the following disclaimer.
14 *  * Redistributions in binary form must reproduce the above copyright notice,
15 *    this list of conditions and the following disclaimer in the documentation
16 *    and/or other materials provided with the distribution.
17 *  * Neither the name of the ITU/ISO/IEC nor the names of its contributors may
18 *    be used to endorse or promote products derived from this software without
19 *    specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
31 * THE POSSIBILITY OF SUCH DAMAGE.
32 */
33
34/** \file     TDecSbac.cpp
35    \brief    Context-adaptive entropy decoder class
36*/
37
38#include "TDecSbac.h"
39#include "TLibCommon/TComTU.h"
40#include "TLibCommon/TComTrQuant.h"
41
42#if RExt__DECODER_DEBUG_BIT_STATISTICS
43#include "TLibCommon/TComCodingStatistics.h"
44//
45#define RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(a) , a
46#else
47#define RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(a)
48#endif
49
50//! \ingroup TLibDecoder
51//! \{
52
53#if ENVIRONMENT_VARIABLE_DEBUG_AND_TEST
54#include "../TLibCommon/Debug.h"
55#endif
56
57
58//////////////////////////////////////////////////////////////////////
59// Construction/Destruction
60//////////////////////////////////////////////////////////////////////
61
62TDecSbac::TDecSbac()
63// new structure here
64: m_pcBitstream                              ( 0 )
65, m_pcTDecBinIf                              ( NULL )
66, m_numContextModels                         ( 0 )
67, m_cCUSplitFlagSCModel                      ( 1,             1,                      NUM_SPLIT_FLAG_CTX                   , m_contextModels + m_numContextModels, m_numContextModels)
68, m_cCUSkipFlagSCModel                       ( 1,             1,                      NUM_SKIP_FLAG_CTX                    , m_contextModels + m_numContextModels, m_numContextModels)
69#if H_3D
70, m_cCUDISFlagSCModel         ( 1,             1,               NUM_DIS_FLAG_CTX             , m_contextModels + m_numContextModels, m_numContextModels)
71, m_cCUDISTypeSCModel         ( 1,             1,               NUM_DIS_TYPE_CTX             , m_contextModels + m_numContextModels, m_numContextModels)
72#endif
73, m_cCUMergeFlagExtSCModel                   ( 1,             1,                      NUM_MERGE_FLAG_EXT_CTX               , m_contextModels + m_numContextModels, m_numContextModels)
74, m_cCUMergeIdxExtSCModel                    ( 1,             1,                      NUM_MERGE_IDX_EXT_CTX                , m_contextModels + m_numContextModels, m_numContextModels)
75#if H_3D_ARP
76, m_cCUPUARPWSCModel          ( 1,             1,               NUM_ARPW_CTX                  , m_contextModels + m_numContextModels, m_numContextModels)
77#endif
78#if H_3D_IC
79, m_cCUICFlagSCModel          ( 1,             1,               NUM_IC_FLAG_CTX               , m_contextModels + m_numContextModels, m_numContextModels)
80#endif
81, m_cCUPartSizeSCModel                       ( 1,             1,                      NUM_PART_SIZE_CTX                    , m_contextModels + m_numContextModels, m_numContextModels)
82, m_cCUPredModeSCModel                       ( 1,             1,                      NUM_PRED_MODE_CTX                    , m_contextModels + m_numContextModels, m_numContextModels)
83, m_cCUIntraPredSCModel                      ( 1,             1,                      NUM_INTRA_PREDICT_CTX                , m_contextModels + m_numContextModels, m_numContextModels)
84, m_cCUChromaPredSCModel                     ( 1,             1,                      NUM_CHROMA_PRED_CTX                  , m_contextModels + m_numContextModels, m_numContextModels)
85, m_cCUDeltaQpSCModel                        ( 1,             1,                      NUM_DELTA_QP_CTX                     , m_contextModels + m_numContextModels, m_numContextModels)
86, m_cCUInterDirSCModel                       ( 1,             1,                      NUM_INTER_DIR_CTX                    , m_contextModels + m_numContextModels, m_numContextModels)
87, m_cCURefPicSCModel                         ( 1,             1,                      NUM_REF_NO_CTX                       , m_contextModels + m_numContextModels, m_numContextModels)
88, m_cCUMvdSCModel                            ( 1,             1,                      NUM_MV_RES_CTX                       , m_contextModels + m_numContextModels, m_numContextModels)
89, m_cCUQtCbfSCModel                          ( 1,             NUM_QT_CBF_CTX_SETS,    NUM_QT_CBF_CTX_PER_SET               , m_contextModels + m_numContextModels, m_numContextModels)
90, m_cCUTransSubdivFlagSCModel                ( 1,             1,                      NUM_TRANS_SUBDIV_FLAG_CTX            , m_contextModels + m_numContextModels, m_numContextModels)
91, m_cCUQtRootCbfSCModel                      ( 1,             1,                      NUM_QT_ROOT_CBF_CTX                  , m_contextModels + m_numContextModels, m_numContextModels)
92, m_cCUSigCoeffGroupSCModel                  ( 1,             2,                      NUM_SIG_CG_FLAG_CTX                  , m_contextModels + m_numContextModels, m_numContextModels)
93, m_cCUSigSCModel                            ( 1,             1,                      NUM_SIG_FLAG_CTX                     , m_contextModels + m_numContextModels, m_numContextModels)
94, m_cCuCtxLastX                              ( 1,             NUM_CTX_LAST_FLAG_SETS, NUM_CTX_LAST_FLAG_XY                 , m_contextModels + m_numContextModels, m_numContextModels)
95, m_cCuCtxLastY                              ( 1,             NUM_CTX_LAST_FLAG_SETS, NUM_CTX_LAST_FLAG_XY                 , m_contextModels + m_numContextModels, m_numContextModels)
96, m_cCUOneSCModel                            ( 1,             1,                      NUM_ONE_FLAG_CTX                     , m_contextModels + m_numContextModels, m_numContextModels)
97, m_cCUAbsSCModel                            ( 1,             1,                      NUM_ABS_FLAG_CTX                     , m_contextModels + m_numContextModels, m_numContextModels)
98, m_cMVPIdxSCModel                           ( 1,             1,                      NUM_MVP_IDX_CTX                      , m_contextModels + m_numContextModels, m_numContextModels)
99, m_cSaoMergeSCModel                         ( 1,             1,                      NUM_SAO_MERGE_FLAG_CTX               , m_contextModels + m_numContextModels, m_numContextModels)
100, m_cSaoTypeIdxSCModel                       ( 1,             1,                      NUM_SAO_TYPE_IDX_CTX                 , m_contextModels + m_numContextModels, m_numContextModels)
101, m_cTransformSkipSCModel                    ( 1,             MAX_NUM_CHANNEL_TYPE,   NUM_TRANSFORMSKIP_FLAG_CTX           , m_contextModels + m_numContextModels, m_numContextModels)
102, m_CUTransquantBypassFlagSCModel            ( 1,             1,                      NUM_CU_TRANSQUANT_BYPASS_FLAG_CTX    , m_contextModels + m_numContextModels, m_numContextModels)
103, m_explicitRdpcmFlagSCModel                 ( 1,             MAX_NUM_CHANNEL_TYPE,   NUM_EXPLICIT_RDPCM_FLAG_CTX          , m_contextModels + m_numContextModels, m_numContextModels)
104, m_explicitRdpcmDirSCModel                  ( 1,             MAX_NUM_CHANNEL_TYPE,   NUM_EXPLICIT_RDPCM_DIR_CTX           , m_contextModels + m_numContextModels, m_numContextModels)
105, m_cCrossComponentPredictionSCModel         ( 1,             1,                      NUM_CROSS_COMPONENT_PREDICTION_CTX   , m_contextModels + m_numContextModels, m_numContextModels)
106, m_ChromaQpAdjFlagSCModel                   ( 1,             1,                      NUM_CHROMA_QP_ADJ_FLAG_CTX           , m_contextModels + m_numContextModels, m_numContextModels)
107, m_ChromaQpAdjIdcSCModel                    ( 1,             1,                      NUM_CHROMA_QP_ADJ_IDC_CTX            , m_contextModels + m_numContextModels, m_numContextModels)
108
109#if NH_3D_DMM
110, m_cNotDmmFlagSCModel                       ( 1,             1,                      NUM_NOTDMM_FLAG_CTX                  , m_contextModels + m_numContextModels, m_numContextModels)
111, m_cDmmModeSCModel                          ( 1,             1,                      NUM_DMM_MODE_CTX                     , m_contextModels + m_numContextModels, m_numContextModels)
112#endif
113#if NH_3D_DMM || NH_3D_SDC
114, m_cDdcDataSCModel                          ( 1,             1,                      NUM_DDC_DATA_CTX                     , m_contextModels + m_numContextModels, m_numContextModels)
115#endif
116#if H_3D_DIM_SDC
117, m_cSDCResidualFlagSCModel                  ( 1,             1,                     SDC_NUM_RESIDUAL_FLAG_CTX             , m_contextModels + m_numContextModels, m_numContextModels)
118, m_cSDCResidualSCModel                      ( 1,             1,                     SDC_NUM_RESIDUAL_CTX                  , m_contextModels + m_numContextModels, m_numContextModels)
119, m_cSDCFlagSCModel                          ( 1,             1,                     NUM_SDC_FLAG_CTX                      , m_contextModels + m_numContextModels, m_numContextModels)
120, m_cDdcFlagSCModel                          ( 1,             1,                     NUM_DDC_FLAG_CTX                      , m_contextModels + m_numContextModels, m_numContextModels)
121#endif
122#if H_3D_DBBP
123, m_cDBBPFlagSCModel                         ( 1,             1,                     DBBP_NUM_FLAG_CTX                     , m_contextModels + m_numContextModels, m_numContextModels)
124#endif
125
126{
127  assert( m_numContextModels <= MAX_NUM_CTX_MOD );
128}
129
130TDecSbac::~TDecSbac()
131{
132}
133
134// ====================================================================================================================
135// Public member functions
136// ====================================================================================================================
137
138Void TDecSbac::resetEntropy(TComSlice* pSlice)
139{
140  SliceType sliceType  = pSlice->getSliceType();
141  Int       qp         = pSlice->getSliceQp();
142
143  if (pSlice->getPPS()->getCabacInitPresentFlag() && pSlice->getCabacInitFlag())
144  {
145    switch (sliceType)
146    {
147    case P_SLICE:           // change initialization table to B_SLICE initialization
148      sliceType = B_SLICE;
149      break;
150    case B_SLICE:           // change initialization table to P_SLICE initialization
151      sliceType = P_SLICE;
152      break;
153    default     :           // should not occur
154      assert(0);
155      break;
156    }
157  }
158
159  m_cCUSplitFlagSCModel.initBuffer                ( sliceType, qp, (UChar*)INIT_SPLIT_FLAG );
160  m_cCUSkipFlagSCModel.initBuffer                 ( sliceType, qp, (UChar*)INIT_SKIP_FLAG );
161#if H_3D
162  m_cCUDISFlagSCModel.initBuffer         ( sliceType, qp, (UChar*)INIT_DIS_FLAG );
163  m_cCUDISTypeSCModel.initBuffer         ( sliceType, qp, (UChar*)INIT_DIS_TYPE );
164#endif
165  m_cCUMergeFlagExtSCModel.initBuffer             ( sliceType, qp, (UChar*)INIT_MERGE_FLAG_EXT );
166  m_cCUMergeIdxExtSCModel.initBuffer              ( sliceType, qp, (UChar*)INIT_MERGE_IDX_EXT );
167#if H_3D_ARP
168  m_cCUPUARPWSCModel.initBuffer          ( sliceType, qp, (UChar*)INIT_ARPW );
169#endif
170#if H_3D_IC
171  m_cCUICFlagSCModel.initBuffer          ( sliceType, qp, (UChar*)INIT_IC_FLAG );
172#endif
173  m_cCUPartSizeSCModel.initBuffer                 ( sliceType, qp, (UChar*)INIT_PART_SIZE );
174  m_cCUPredModeSCModel.initBuffer                 ( sliceType, qp, (UChar*)INIT_PRED_MODE );
175  m_cCUIntraPredSCModel.initBuffer                ( sliceType, qp, (UChar*)INIT_INTRA_PRED_MODE );
176  m_cCUChromaPredSCModel.initBuffer               ( sliceType, qp, (UChar*)INIT_CHROMA_PRED_MODE );
177  m_cCUInterDirSCModel.initBuffer                 ( sliceType, qp, (UChar*)INIT_INTER_DIR );
178  m_cCUMvdSCModel.initBuffer                      ( sliceType, qp, (UChar*)INIT_MVD );
179  m_cCURefPicSCModel.initBuffer                   ( sliceType, qp, (UChar*)INIT_REF_PIC );
180  m_cCUDeltaQpSCModel.initBuffer                  ( sliceType, qp, (UChar*)INIT_DQP );
181  m_cCUQtCbfSCModel.initBuffer                    ( sliceType, qp, (UChar*)INIT_QT_CBF );
182  m_cCUQtRootCbfSCModel.initBuffer                ( sliceType, qp, (UChar*)INIT_QT_ROOT_CBF );
183  m_cCUSigCoeffGroupSCModel.initBuffer            ( sliceType, qp, (UChar*)INIT_SIG_CG_FLAG );
184  m_cCUSigSCModel.initBuffer                      ( sliceType, qp, (UChar*)INIT_SIG_FLAG );
185  m_cCuCtxLastX.initBuffer                        ( sliceType, qp, (UChar*)INIT_LAST );
186  m_cCuCtxLastY.initBuffer                        ( sliceType, qp, (UChar*)INIT_LAST );
187  m_cCUOneSCModel.initBuffer                      ( sliceType, qp, (UChar*)INIT_ONE_FLAG );
188  m_cCUAbsSCModel.initBuffer                      ( sliceType, qp, (UChar*)INIT_ABS_FLAG );
189  m_cMVPIdxSCModel.initBuffer                     ( sliceType, qp, (UChar*)INIT_MVP_IDX );
190  m_cSaoMergeSCModel.initBuffer                   ( sliceType, qp, (UChar*)INIT_SAO_MERGE_FLAG );
191  m_cSaoTypeIdxSCModel.initBuffer                 ( sliceType, qp, (UChar*)INIT_SAO_TYPE_IDX );
192  m_cCUTransSubdivFlagSCModel.initBuffer          ( sliceType, qp, (UChar*)INIT_TRANS_SUBDIV_FLAG );
193  m_cTransformSkipSCModel.initBuffer              ( sliceType, qp, (UChar*)INIT_TRANSFORMSKIP_FLAG );
194  m_CUTransquantBypassFlagSCModel.initBuffer      ( sliceType, qp, (UChar*)INIT_CU_TRANSQUANT_BYPASS_FLAG );
195  m_explicitRdpcmFlagSCModel.initBuffer           ( sliceType, qp, (UChar*)INIT_EXPLICIT_RDPCM_FLAG);
196  m_explicitRdpcmDirSCModel.initBuffer            ( sliceType, qp, (UChar*)INIT_EXPLICIT_RDPCM_DIR);
197  m_cCrossComponentPredictionSCModel.initBuffer   ( sliceType, qp, (UChar*)INIT_CROSS_COMPONENT_PREDICTION );
198  m_ChromaQpAdjFlagSCModel.initBuffer             ( sliceType, qp, (UChar*)INIT_CHROMA_QP_ADJ_FLAG );
199  m_ChromaQpAdjIdcSCModel.initBuffer              ( sliceType, qp, (UChar*)INIT_CHROMA_QP_ADJ_IDC );
200#if NH_3D_DMM
201  m_cNotDmmFlagSCModel.initBuffer                 ( sliceType, qp, (UChar*)INIT_NOTDMM_FLAG );
202  m_cDmmModeSCModel.initBuffer                    ( sliceType, qp, (UChar*)INIT_DMM_MODE );
203#endif
204#if NH_3D_DMM || NH_3D_SDC
205  m_cDdcDataSCModel.initBuffer                    ( sliceType, qp, (UChar*)INIT_DDC_DATA );
206#endif
207#if H_3D_DIM_SDC
208  m_cSDCResidualFlagSCModel.initBuffer            ( sliceType, qp, (UChar*)INIT_SDC_RESIDUAL_FLAG );
209  m_cSDCResidualSCModel.initBuffer                ( sliceType, qp, (UChar*)INIT_SDC_RESIDUAL );
210  m_cSDCFlagSCModel.initBuffer                    ( sliceType, qp, (UChar*)INIT_SDC_FLAG );
211  m_cDdcFlagSCModel.initBuffer                    ( sliceType, qp, (UChar*)INIT_DDC_FLAG );
212#endif
213#if H_3D_DBBP
214  m_cDBBPFlagSCModel.initBuffer                   ( sliceType, qp, (UChar*)INIT_DBBP_FLAG );
215#endif
216
217  for (UInt statisticIndex = 0; statisticIndex < RExt__GOLOMB_RICE_ADAPTATION_STATISTICS_SETS ; statisticIndex++)
218  {
219    m_golombRiceAdaptationStatistics[statisticIndex] = 0;
220  }
221
222  m_pcTDecBinIf->start();
223}
224
225Void TDecSbac::parseTerminatingBit( UInt& ruiBit )
226{
227  m_pcTDecBinIf->decodeBinTrm( ruiBit );
228  if ( ruiBit == 1 )
229  {
230    m_pcTDecBinIf->finish();
231
232#if RExt__DECODER_DEBUG_BIT_STATISTICS
233    TComCodingStatistics::IncrementStatisticEP(STATS__TRAILING_BITS, m_pcBitstream->readOutTrailingBits(),0);
234#else
235    m_pcBitstream->readOutTrailingBits();
236#endif
237  }
238}
239
240#if H_3D
241  m_cCUDISFlagSCModel.initBuffer         ( eSliceType, iQp, (UChar*)INIT_DIS_FLAG );
242  m_cCUDISTypeSCModel.initBuffer         ( eSliceType, iQp, (UChar*)INIT_DIS_TYPE );
243#endif
244#if H_3D_ARP
245  m_cCUPUARPWSCModel.initBuffer          ( eSliceType, iQp, (UChar*)INIT_ARPW );
246#endif
247#if H_3D_IC
248  m_cCUICFlagSCModel.initBuffer          ( eSliceType, iQp, (UChar*)INIT_IC_FLAG );
249#endif
250#if H_3D_DIM_SDC
251  m_cSDCResidualFlagSCModel.initBuffer    ( eSliceType, iQp, (UChar*)INIT_SDC_RESIDUAL_FLAG );
252  m_cSDCResidualSCModel.initBuffer        ( eSliceType, iQp, (UChar*)INIT_SDC_RESIDUAL );
253  m_cSDCFlagSCModel.initBuffer            ( eSliceType, iQp, (UChar*)INIT_SDC_FLAG );
254  m_cDdcFlagSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_DDC_FLAG );
255#endif
256#if H_3D_DBBP
257  m_cDBBPFlagSCModel.initBuffer              ( eSliceType, iQp, (UChar*)INIT_DBBP_FLAG );
258#endif
259
260
261Void TDecSbac::parseRemainingBytes( Bool noTrailingBytesExpected )
262{
263  if (noTrailingBytesExpected)
264  {
265    const UInt numberOfRemainingSubstreamBytes=m_pcBitstream->getNumBitsLeft();
266    assert (numberOfRemainingSubstreamBytes == 0);
267  }
268  else
269  {
270    while (m_pcBitstream->getNumBitsLeft())
271    {
272      UInt trailingNullByte=m_pcBitstream->readByte();
273      if (trailingNullByte!=0)
274      {
275        printf("Trailing byte should be 0, but has value %02x\n", trailingNullByte);
276        assert(trailingNullByte==0);
277      }
278    }
279  }
280}
281
282#if RExt__DECODER_DEBUG_BIT_STATISTICS
283Void TDecSbac::xReadUnaryMaxSymbol( UInt& ruiSymbol, ContextModel* pcSCModel, Int iOffset, UInt uiMaxSymbol, const class TComCodingStatisticsClassType &whichStat )
284#else
285Void TDecSbac::xReadUnaryMaxSymbol( UInt& ruiSymbol, ContextModel* pcSCModel, Int iOffset, UInt uiMaxSymbol )
286#endif
287{
288  if (uiMaxSymbol == 0)
289  {
290    ruiSymbol = 0;
291    return;
292  }
293
294  m_pcTDecBinIf->decodeBin( ruiSymbol, pcSCModel[0] RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(whichStat) );
295
296  if( ruiSymbol == 0 || uiMaxSymbol == 1 )
297  {
298    return;
299  }
300
301  UInt uiSymbol = 0;
302  UInt uiCont;
303
304  do
305  {
306    m_pcTDecBinIf->decodeBin( uiCont, pcSCModel[ iOffset ] RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(whichStat) );
307    uiSymbol++;
308  } while( uiCont && ( uiSymbol < uiMaxSymbol - 1 ) );
309
310  if( uiCont && ( uiSymbol == uiMaxSymbol - 1 ) )
311  {
312    uiSymbol++;
313  }
314
315  ruiSymbol = uiSymbol;
316}
317
318#if RExt__DECODER_DEBUG_BIT_STATISTICS
319Void TDecSbac::xReadEpExGolomb( UInt& ruiSymbol, UInt uiCount, const class TComCodingStatisticsClassType &whichStat )
320#else
321Void TDecSbac::xReadEpExGolomb( UInt& ruiSymbol, UInt uiCount )
322#endif
323{
324  UInt uiSymbol = 0;
325  UInt uiBit = 1;
326
327  while( uiBit )
328  {
329    m_pcTDecBinIf->decodeBinEP( uiBit RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(whichStat) );
330    uiSymbol += uiBit << uiCount++;
331  }
332
333  if ( --uiCount )
334  {
335    UInt bins;
336    m_pcTDecBinIf->decodeBinsEP( bins, uiCount RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(whichStat) );
337    uiSymbol += bins;
338  }
339
340  ruiSymbol = uiSymbol;
341}
342
343#if RExt__DECODER_DEBUG_BIT_STATISTICS
344Void TDecSbac::xReadUnarySymbol( UInt& ruiSymbol, ContextModel* pcSCModel, Int iOffset, const class TComCodingStatisticsClassType &whichStat )
345#else
346Void TDecSbac::xReadUnarySymbol( UInt& ruiSymbol, ContextModel* pcSCModel, Int iOffset )
347#endif
348{
349  m_pcTDecBinIf->decodeBin( ruiSymbol, pcSCModel[0] RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(whichStat));
350
351  if( !ruiSymbol )
352  {
353    return;
354  }
355
356  UInt uiSymbol = 0;
357  UInt uiCont;
358
359  do
360  {
361    m_pcTDecBinIf->decodeBin( uiCont, pcSCModel[ iOffset ] RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(whichStat));
362    uiSymbol++;
363  } while( uiCont );
364
365  ruiSymbol = uiSymbol;
366}
367
368
369/** Parsing of coeff_abs_level_remaing
370 * \param rSymbol                 reference to coeff_abs_level_remaing
371 * \param rParam                  reference to parameter
372 * \param useLimitedPrefixLength
373 * \param maxLog2TrDynamicRange
374 */
375#if RExt__DECODER_DEBUG_BIT_STATISTICS
376Void TDecSbac::xReadCoefRemainExGolomb ( UInt &rSymbol, UInt &rParam, const Bool useLimitedPrefixLength, const Int maxLog2TrDynamicRange, const class TComCodingStatisticsClassType &whichStat )
377#else
378Void TDecSbac::xReadCoefRemainExGolomb ( UInt &rSymbol, UInt &rParam, const Bool useLimitedPrefixLength, const Int maxLog2TrDynamicRange )
379#endif
380{
381  UInt prefix   = 0;
382  UInt codeWord = 0;
383
384  if (useLimitedPrefixLength)
385  {
386    const UInt longestPossiblePrefix = (32 - (COEF_REMAIN_BIN_REDUCTION + maxLog2TrDynamicRange)) + COEF_REMAIN_BIN_REDUCTION;
387
388    do
389    {
390      prefix++;
391      m_pcTDecBinIf->decodeBinEP( codeWord RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(whichStat) );
392    } while((codeWord != 0) && (prefix < longestPossiblePrefix));
393  }
394  else
395  {
396    do
397    {
398      prefix++;
399      m_pcTDecBinIf->decodeBinEP( codeWord RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(whichStat) );
400    } while( codeWord);
401  }
402
403  codeWord  = 1 - codeWord;
404  prefix -= codeWord;
405  codeWord=0;
406
407  if (prefix < COEF_REMAIN_BIN_REDUCTION )
408  {
409    m_pcTDecBinIf->decodeBinsEP(codeWord,rParam RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(whichStat));
410    rSymbol = (prefix<<rParam) + codeWord;
411  }
412  else if (useLimitedPrefixLength)
413  {
414    const UInt maximumPrefixLength = (32 - (COEF_REMAIN_BIN_REDUCTION + maxLog2TrDynamicRange));
415
416    const UInt prefixLength = prefix - COEF_REMAIN_BIN_REDUCTION;
417    const UInt suffixLength = (prefixLength == maximumPrefixLength) ? (maxLog2TrDynamicRange - rParam) : prefixLength;
418
419    m_pcTDecBinIf->decodeBinsEP(codeWord, (suffixLength + rParam) RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(whichStat));
420
421    rSymbol = codeWord + ((((1 << prefixLength) - 1) + COEF_REMAIN_BIN_REDUCTION) << rParam);
422  }
423  else
424  {
425    m_pcTDecBinIf->decodeBinsEP(codeWord,prefix-COEF_REMAIN_BIN_REDUCTION+rParam RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(whichStat));
426    rSymbol = (((1<<(prefix-COEF_REMAIN_BIN_REDUCTION))+COEF_REMAIN_BIN_REDUCTION-1)<<rParam)+codeWord;
427  }
428}
429
430/** Parse I_PCM information.
431 * \param pcCU
432 * \param uiAbsPartIdx
433 * \param uiDepth
434 * \returns Void
435 *
436 * If I_PCM flag indicates that the CU is I_PCM, parse its PCM alignment bits and codes.
437 */
438Void TDecSbac::parseIPCMInfo ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
439{
440  UInt uiSymbol;
441
442  m_pcTDecBinIf->decodeBinTrm(uiSymbol);
443
444#if H_MV_ENC_DEC_TRAC
445  DTRACE_CU("pcm_flag", uiSymbol)
446#endif
447
448
449  if (uiSymbol == 1)
450  {
451    Bool bIpcmFlag = true;
452    const TComSPS &sps=*(pcCU->getSlice()->getSPS());
453
454    pcCU->setPartSizeSubParts  ( SIZE_2Nx2N, uiAbsPartIdx, uiDepth );
455    pcCU->setSizeSubParts      ( sps.getMaxCUWidth()>>uiDepth, sps.getMaxCUHeight()>>uiDepth, uiAbsPartIdx, uiDepth );
456    pcCU->setTrIdxSubParts     ( 0, uiAbsPartIdx, uiDepth );
457    pcCU->setIPCMFlagSubParts  ( bIpcmFlag, uiAbsPartIdx, uiDepth );
458
459    const UInt minCoeffSizeY = pcCU->getPic()->getMinCUWidth() * pcCU->getPic()->getMinCUHeight();
460    const UInt offsetY       = minCoeffSizeY * uiAbsPartIdx;
461    for (UInt ch=0; ch < pcCU->getPic()->getNumberValidComponents(); ch++)
462    {
463      const ComponentID compID = ComponentID(ch);
464      const UInt offset = offsetY >> (pcCU->getPic()->getComponentScaleX(compID) + pcCU->getPic()->getComponentScaleY(compID));
465      Pel * pPCMSample  = pcCU->getPCMSample(compID) + offset;
466      const UInt width  = pcCU->getWidth (uiAbsPartIdx) >> pcCU->getPic()->getComponentScaleX(compID);
467      const UInt height = pcCU->getHeight(uiAbsPartIdx) >> pcCU->getPic()->getComponentScaleY(compID);
468      const UInt sampleBits = pcCU->getSlice()->getSPS()->getPCMBitDepth(toChannelType(compID));
469      for (UInt y=0; y<height; y++)
470      {
471        for (UInt x=0; x<width; x++)
472        {
473          UInt sample;
474          m_pcTDecBinIf->xReadPCMCode(sampleBits, sample);
475          pPCMSample[x] = sample;
476        }
477        pPCMSample += width;
478      }
479    }
480    m_pcTDecBinIf->start();
481  }
482}
483
484Void TDecSbac::parseCUTransquantBypassFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
485{
486  UInt uiSymbol;
487  m_pcTDecBinIf->decodeBin( uiSymbol, m_CUTransquantBypassFlagSCModel.get( 0, 0, 0 ) RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__TQ_BYPASS_FLAG) );
488#if H_MV_ENC_DEC_TRAC
489  DTRACE_CU("cu_transquant_bypass_flag", uiSymbol); 
490#endif
491
492  pcCU->setCUTransquantBypassSubParts(uiSymbol ? true : false, uiAbsPartIdx, uiDepth);
493}
494
495/** parse skip flag
496 * \param pcCU
497 * \param uiAbsPartIdx
498 * \param uiDepth
499 * \returns Void
500 */
501Void TDecSbac::parseSkipFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
502{
503  if( pcCU->getSlice()->isIntra() )
504  {
505    return;
506  }
507
508  UInt uiSymbol = 0;
509  UInt uiCtxSkip = pcCU->getCtxSkipFlag( uiAbsPartIdx );
510  m_pcTDecBinIf->decodeBin( uiSymbol, m_cCUSkipFlagSCModel.get( 0, 0, uiCtxSkip ) RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__SKIP_FLAG) );
511#if !H_MV_ENC_DEC_TRAC
512  DTRACE_CABAC_VL( g_nSymbolCounter++ );
513  DTRACE_CABAC_T( "\tSkipFlag" );
514  DTRACE_CABAC_T( "\tuiCtxSkip: ");
515  DTRACE_CABAC_V( uiCtxSkip );
516  DTRACE_CABAC_T( "\tuiSymbol: ");
517  DTRACE_CABAC_V( uiSymbol );
518  DTRACE_CABAC_T( "\n");
519#endif
520  if( uiSymbol )
521  {
522    pcCU->setSkipFlagSubParts( true,        uiAbsPartIdx, uiDepth );
523    pcCU->setPredModeSubParts( MODE_INTER,  uiAbsPartIdx, uiDepth );
524    pcCU->setPartSizeSubParts( SIZE_2Nx2N, uiAbsPartIdx, uiDepth );
525    pcCU->setSizeSubParts( pcCU->getSlice()->getSPS()->getMaxCUWidth()>>uiDepth, pcCU->getSlice()->getSPS()->getMaxCUHeight()>>uiDepth, uiAbsPartIdx, uiDepth );
526    pcCU->setMergeFlagSubParts( true , uiAbsPartIdx, 0, uiDepth );
527  }
528#if H_MV_ENC_DEC_TRAC
529  DTRACE_CU("cu_skip_flag", uiSymbol); 
530#endif
531
532}
533#if H_3D
534Void TDecSbac::parseDIS( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
535{
536  pcCU->setDISFlagSubParts( false,        uiAbsPartIdx, uiDepth );
537  UInt uiSymbol = 0;
538  m_pcTDecBinIf->decodeBin( uiSymbol, m_cCUDISFlagSCModel.get( 0, 0, 0 ) );
539  if( uiSymbol )
540  {
541    pcCU->setDISFlagSubParts( true,        uiAbsPartIdx, uiDepth );
542    pcCU->setSkipFlagSubParts( false,        uiAbsPartIdx, uiDepth );
543    pcCU->setSDCFlagSubParts( false,        uiAbsPartIdx, uiDepth );
544    pcCU->setPredModeSubParts( MODE_INTRA,  uiAbsPartIdx, uiDepth );
545    pcCU->setPartSizeSubParts( SIZE_2Nx2N, uiAbsPartIdx, uiDepth );
546    pcCU->setLumaIntraDirSubParts (DC_IDX, uiAbsPartIdx, uiDepth );
547    pcCU->setSizeSubParts( g_uiMaxCUWidth>>uiDepth, g_uiMaxCUHeight>>uiDepth, uiAbsPartIdx, uiDepth );
548    pcCU->setMergeFlagSubParts( false , uiAbsPartIdx, 0, uiDepth );
549    pcCU->setTrIdxSubParts(0, uiAbsPartIdx, uiDepth);
550    pcCU->setCbfSubParts(0, 1, 1, uiAbsPartIdx, uiDepth);
551
552    UInt uiUnaryIdx = 0;
553    UInt uiNumCand  = 4;
554
555    if ( uiNumCand > 1 )
556    {
557      for( ; uiUnaryIdx < uiNumCand - 1; ++uiUnaryIdx )
558      {
559        UInt uiSymbol2 = 0;
560        if ( uiUnaryIdx==0 )
561        {
562          m_pcTDecBinIf->decodeBin( uiSymbol2, m_cCUDISTypeSCModel.get( 0, 0, 0 ) );
563        }
564        else
565        {
566          m_pcTDecBinIf->decodeBinEP( uiSymbol2);
567        }
568        if( uiSymbol2 == 0 )
569        {
570          break;
571        }
572      }
573    }
574    pcCU->setDISTypeSubParts(uiUnaryIdx, uiAbsPartIdx, 0, uiDepth);
575  }
576}
577#endif
578
579
580/** parse merge flag
581 * \param pcCU
582 * \param uiAbsPartIdx
583 * \param uiDepth
584 * \param uiPUIdx
585 * \returns Void
586 */
587Void TDecSbac::parseMergeFlag ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, UInt uiPUIdx )
588{
589  UInt uiSymbol;
590  m_pcTDecBinIf->decodeBin( uiSymbol, *m_cCUMergeFlagExtSCModel.get( 0 ) RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__MERGE_FLAG) );
591#if H_MV_ENC_DEC_TRAC
592  DTRACE_PU("merge_flag", uiSymbol)
593#endif
594  pcCU->setMergeFlagSubParts( uiSymbol ? true : false, uiAbsPartIdx, uiPUIdx, uiDepth );
595#if !H_MV_ENC_DEC_TRAC
596  DTRACE_CABAC_VL( g_nSymbolCounter++ );
597  DTRACE_CABAC_T( "\tMergeFlag: " );
598  DTRACE_CABAC_V( uiSymbol );
599  DTRACE_CABAC_T( "\tAddress: " );
600  DTRACE_CABAC_V( pcCU->getCtuRsAddr() );
601  DTRACE_CABAC_T( "\tuiAbsPartIdx: " );
602  DTRACE_CABAC_V( uiAbsPartIdx );
603  DTRACE_CABAC_T( "\n" );
604#endif
605}
606
607Void TDecSbac::parseMergeIndex ( TComDataCU* pcCU, UInt& ruiMergeIndex )
608{
609  UInt uiUnaryIdx = 0;
610  UInt uiNumCand = pcCU->getSlice()->getMaxNumMergeCand();
611  if ( uiNumCand > 1 )
612  {
613    for( ; uiUnaryIdx < uiNumCand - 1; ++uiUnaryIdx )
614    {
615      UInt uiSymbol = 0;
616      if ( uiUnaryIdx==0 )
617      {
618        m_pcTDecBinIf->decodeBin( uiSymbol, m_cCUMergeIdxExtSCModel.get( 0, 0, 0 ) RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__MERGE_INDEX) );
619      }
620      else
621      {
622        m_pcTDecBinIf->decodeBinEP( uiSymbol RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__MERGE_INDEX) );
623      }
624      if( uiSymbol == 0 )
625      {
626        break;
627      }
628    }
629#if H_MV_ENC_DEC_TRAC
630    DTRACE_PU("merge_idx", uiUnaryIdx)
631#endif
632  }
633  ruiMergeIndex = uiUnaryIdx;
634
635#if !H_MV_ENC_DEC_TRAC
636  DTRACE_CABAC_VL( g_nSymbolCounter++ )
637  DTRACE_CABAC_T( "\tparseMergeIndex()" )
638  DTRACE_CABAC_T( "\tuiMRGIdx= " )
639  DTRACE_CABAC_V( ruiMergeIndex )
640  DTRACE_CABAC_T( "\n" )
641#endif
642}
643
644Void TDecSbac::parseMVPIdx      ( Int& riMVPIdx )
645{
646  UInt uiSymbol;
647  xReadUnaryMaxSymbol(uiSymbol, m_cMVPIdxSCModel.get(0), 1, AMVP_MAX_NUM_CANDS-1 RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__MVP_IDX) );
648  riMVPIdx = uiSymbol;
649}
650
651Void TDecSbac::parseSplitFlag     ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
652{
653  if( uiDepth == pcCU->getSlice()->getSPS()->getLog2DiffMaxMinCodingBlockSize() )
654  {
655    pcCU->setDepthSubParts( uiDepth, uiAbsPartIdx );
656    return;
657  }
658#if RExt__DECODER_DEBUG_BIT_STATISTICS
659  const TComCodingStatisticsClassType ctype(STATS__CABAC_BITS__SPLIT_FLAG, g_aucConvertToBit[pcCU->getSlice()->getSPS()->getMaxCUWidth()>>uiDepth]+2);
660#endif
661
662  UInt uiSymbol;
663#if H_3D_QTLPC
664  Bool bParseSplitFlag    = true;
665  Bool    bLimQtPredFlag = pcCU->getPic()->getSlice(0)->getQtPredFlag();
666  TComPic *pcTexture      = pcCU->getSlice()->getTexturePic();
667  Bool bDepthMapDetect    = (pcTexture != NULL);
668  Bool bIntraSliceDetect  = (pcCU->getSlice()->getSliceType() == I_SLICE);
669
670  Bool rapPic = (pcCU->getSlice()->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL || pcCU->getSlice()->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP || pcCU->getSlice()->getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA);
671
672#if H_3D_FCO
673  if(bDepthMapDetect && !bIntraSliceDetect && !rapPic && bLimQtPredFlag && pcTexture->getReconMark())
674#else
675  if(bDepthMapDetect && !bIntraSliceDetect && !rapPic && bLimQtPredFlag)
676#endif
677  {
678    TComDataCU *pcTextureCU = pcTexture->getCU(pcCU->getAddr());
679    assert(pcTextureCU->getDepth(uiAbsPartIdx) >= uiDepth);
680    bParseSplitFlag         = (pcTextureCU->getDepth(uiAbsPartIdx) > uiDepth);
681  }
682
683  if(bParseSplitFlag)
684  {
685#endif
686  m_pcTDecBinIf->decodeBin( uiSymbol, m_cCUSplitFlagSCModel.get( 0, 0, pcCU->getCtxSplitFlag( uiAbsPartIdx, uiDepth ) ) RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype) );
687#if H_MV_ENC_DEC_TRAC
688    DTRACE_CU("split_cu_flag", uiSymbol); 
689#else
690  DTRACE_CABAC_VL( g_nSymbolCounter++ )
691  DTRACE_CABAC_T( "\tSplitFlag\n" )
692#endif
693#if H_3D_QTLPC
694  }
695  else
696  {
697    uiSymbol = 0;
698  }
699#endif
700  pcCU->setDepthSubParts( uiDepth + uiSymbol, uiAbsPartIdx );
701
702  return;
703}
704
705/** parse partition size
706 * \param pcCU
707 * \param uiAbsPartIdx
708 * \param uiDepth
709 * \returns Void
710 */
711Void TDecSbac::parsePartSize( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
712{
713  UInt uiSymbol, uiMode = 0;
714  PartSize eMode;
715  const UChar cuWidth =UChar(pcCU->getSlice()->getSPS()->getMaxCUWidth()>>uiDepth);
716  const UChar cuHeight=UChar(pcCU->getSlice()->getSPS()->getMaxCUHeight()>>uiDepth);
717  const Int log2DiffMaxMinCodingBlockSize = pcCU->getSlice()->getSPS()->getLog2DiffMaxMinCodingBlockSize();
718
719#if RExt__DECODER_DEBUG_BIT_STATISTICS
720  const TComCodingStatisticsClassType ctype(STATS__CABAC_BITS__PART_SIZE, g_aucConvertToBit[cuWidth]+2);
721#endif
722
723  assert ( pcCU->getSlice()->getSPS()->getLog2DiffMaxMinCodingBlockSize() == log2DiffMaxMinCodingBlockSize);
724
725#if H_3D_QTLPC
726  Bool bParsePartSize    = true;
727
728  Bool    bLimQtPredFlag = pcCU->getPic()->getSlice(0)->getQtPredFlag();
729  TComPic *pcTexture     = pcCU->getSlice()->getTexturePic();
730  Bool bDepthMapDetect   = (pcTexture != NULL);
731  Bool bIntraSliceDetect = (pcCU->getSlice()->getSliceType() == I_SLICE);
732
733  Bool rapPic     = (pcCU->getSlice()->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL || pcCU->getSlice()->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP || pcCU->getSlice()->getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA);
734
735  Bool depthDependent = false;
736  UInt uiTexturePart = uiMode;
737
738#if H_3D_FCO
739  if(bDepthMapDetect && !bIntraSliceDetect && !rapPic && bLimQtPredFlag && pcTexture->getReconMark())
740#else
741  if(bDepthMapDetect && !bIntraSliceDetect && !rapPic && bLimQtPredFlag )
742#endif
743  {
744    TComDataCU *pcTextureCU = pcTexture->getCU(pcCU->getAddr());
745    assert(pcTextureCU->getDepth(uiAbsPartIdx) >= uiDepth);
746    if(pcTextureCU->getDepth(uiAbsPartIdx) == uiDepth )
747    {
748      depthDependent = true;
749      uiTexturePart = pcTextureCU->getPartitionSize( uiAbsPartIdx );
750    }
751    if (pcTextureCU->getDepth(uiAbsPartIdx) == uiDepth && pcTextureCU->getPartitionSize( uiAbsPartIdx ) == SIZE_2Nx2N)
752    {
753      bParsePartSize = false;
754      eMode          = SIZE_2Nx2N;
755    }
756  }
757#endif
758
759  if ( pcCU->isIntra( uiAbsPartIdx ) )
760  {
761#if H_3D_QTLPC
762    if(bParsePartSize)
763    {
764#endif
765    uiSymbol = 1;
766    if( uiDepth == log2DiffMaxMinCodingBlockSize )
767    {
768      m_pcTDecBinIf->decodeBin( uiSymbol, m_cCUPartSizeSCModel.get( 0, 0, 0) RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype) );
769#if H_MV_ENC_DEC_TRAC         
770        DTRACE_CU("part_mode", uiSymbol)
771#endif       
772    }
773    eMode = uiSymbol ? SIZE_2Nx2N : SIZE_NxN;
774#if H_3D_QTLPC
775    }
776#endif
777    UInt uiTrLevel = 0;
778    UInt uiWidthInBit  = g_aucConvertToBit[pcCU->getWidth(uiAbsPartIdx)]+2;
779    UInt uiTrSizeInBit = g_aucConvertToBit[pcCU->getSlice()->getSPS()->getMaxTrSize()]+2;
780    uiTrLevel          = uiWidthInBit >= uiTrSizeInBit ? uiWidthInBit - uiTrSizeInBit : 0;
781    if( eMode == SIZE_NxN )
782    {
783      pcCU->setTrIdxSubParts( 1+uiTrLevel, uiAbsPartIdx, uiDepth );
784    }
785    else
786    {
787      pcCU->setTrIdxSubParts( uiTrLevel, uiAbsPartIdx, uiDepth );
788    }
789  }
790  else
791  {
792#if H_3D_QTLPC
793    if(bParsePartSize)
794    {
795      if (depthDependent==false || uiTexturePart == SIZE_NxN|| uiTexturePart == SIZE_2Nx2N)
796      {
797#endif
798    UInt uiMaxNumBits = 2;
799
800    if( uiDepth == log2DiffMaxMinCodingBlockSize && !( cuWidth == 8 && cuHeight == 8 ) )
801    {
802      uiMaxNumBits ++;
803    }
804
805    for ( UInt ui = 0; ui < uiMaxNumBits; ui++ )
806    {
807      m_pcTDecBinIf->decodeBin( uiSymbol, m_cCUPartSizeSCModel.get( 0, 0, ui) RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype) );
808      if ( uiSymbol )
809      {
810        break;
811      }
812      uiMode++;
813    }
814    eMode = (PartSize) uiMode;
815    if ( pcCU->getSlice()->getSPS()->getUseAMP() && uiDepth < log2DiffMaxMinCodingBlockSize )
816    {
817      if (eMode == SIZE_2NxN)
818      {
819        m_pcTDecBinIf->decodeBin(uiSymbol, m_cCUPartSizeSCModel.get( 0, 0, 3 ) RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype));
820        if (uiSymbol == 0)
821        {
822          m_pcTDecBinIf->decodeBinEP(uiSymbol RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype) );
823          eMode = (uiSymbol == 0? SIZE_2NxnU : SIZE_2NxnD);
824        }
825      }
826      else if (eMode == SIZE_Nx2N)
827      {
828        m_pcTDecBinIf->decodeBin(uiSymbol, m_cCUPartSizeSCModel.get( 0, 0, 3 ) RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype) );
829        if (uiSymbol == 0)
830        {
831          m_pcTDecBinIf->decodeBinEP(uiSymbol RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype) );
832          eMode = (uiSymbol == 0? SIZE_nLx2N : SIZE_nRx2N);
833        }
834      }
835    }
836#if H_3D_QTLPC
837      }
838      else if(uiTexturePart == SIZE_2NxN || uiTexturePart == SIZE_2NxnU || uiTexturePart == SIZE_2NxnD)
839      {
840        UInt uiMaxNumBits = 1;
841        if ( pcCU->getSlice()->getSPS()->getAMPAcc( uiDepth ) )
842        {
843          uiMaxNumBits ++;
844        }
845        for ( UInt ui = 0; ui < uiMaxNumBits; ui++ )
846        {
847          m_pcTDecBinIf->decodeBin( uiSymbol, m_cCUPartSizeSCModel.get( 0, 0, ui) );
848          if ( uiSymbol )
849          {
850            break;
851          }
852          uiMode++;
853        }
854        eMode = (PartSize) uiMode;
855        if(uiMode && pcCU->getSlice()->getSPS()->getAMPAcc( uiDepth ) && uiSymbol==1 )
856        {
857          eMode = SIZE_2NxN;
858        }
859        else if (uiMode && pcCU->getSlice()->getSPS()->getAMPAcc( uiDepth )==0  && uiSymbol==0)
860        {
861          eMode = SIZE_2NxN;
862        }
863        else if (uiMode && pcCU->getSlice()->getSPS()->getAMPAcc( uiDepth ) && uiSymbol==0)
864        {
865          m_pcTDecBinIf->decodeBinEP(uiSymbol);
866          eMode = (uiSymbol == 0? SIZE_2NxnU : SIZE_2NxnD);
867        }
868      }
869      else if(uiTexturePart == SIZE_Nx2N|| uiTexturePart==SIZE_nLx2N || uiTexturePart==SIZE_nRx2N)
870      {
871        UInt uiMaxNumBits = 1;
872        if ( pcCU->getSlice()->getSPS()->getAMPAcc( uiDepth ) )
873        {
874          uiMaxNumBits ++;
875        }
876        for ( UInt ui = 0; ui < uiMaxNumBits; ui++ )
877        {
878          m_pcTDecBinIf->decodeBin( uiSymbol, m_cCUPartSizeSCModel.get( 0, 0, ui) );
879          if ( uiSymbol )
880          {
881            break;
882          }
883          uiMode++;
884        }
885        eMode = (PartSize) uiMode;
886        if(uiMode && pcCU->getSlice()->getSPS()->getAMPAcc( uiDepth ) && uiSymbol==1 )
887        {
888          eMode = SIZE_Nx2N;
889        }
890        else if (uiMode && pcCU->getSlice()->getSPS()->getAMPAcc( uiDepth )==0  && uiSymbol==0)
891        {
892          eMode = SIZE_Nx2N;
893        }
894        else if (uiMode && pcCU->getSlice()->getSPS()->getAMPAcc( uiDepth ) && uiSymbol==0)
895        {
896          m_pcTDecBinIf->decodeBinEP(uiSymbol);
897          eMode = (uiSymbol == 0? SIZE_nLx2N : SIZE_nRx2N);
898        }
899      }
900      else
901      {
902        assert(0);
903      }
904#endif
905#if H_MV_ENC_DEC_TRAC         
906      DTRACE_CU("part_mode", eMode )
907#endif
908#if H_3D_QTLPC
909    }
910#endif
911  }
912  pcCU->setPartSizeSubParts( eMode, uiAbsPartIdx, uiDepth );
913  pcCU->setSizeSubParts( cuWidth, cuHeight, uiAbsPartIdx, uiDepth );
914}
915
916
917/** parse prediction mode
918 * \param pcCU
919 * \param uiAbsPartIdx
920 * \param uiDepth
921 * \returns Void
922 */
923Void TDecSbac::parsePredMode( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
924{
925  if( pcCU->getSlice()->isIntra() )
926  {
927    pcCU->setPredModeSubParts( MODE_INTRA, uiAbsPartIdx, uiDepth );
928    return;
929  }
930
931  UInt uiSymbol;
932  Int  iPredMode = MODE_INTER;
933  m_pcTDecBinIf->decodeBin( uiSymbol, m_cCUPredModeSCModel.get( 0, 0, 0 ) RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__PRED_MODE) );
934  iPredMode += uiSymbol;
935#if H_MV_ENC_DEC_TRAC         
936  DTRACE_CU("pred_mode_flag", uiSymbol)
937#endif       
938  pcCU->setPredModeSubParts( (PredMode)iPredMode, uiAbsPartIdx, uiDepth );
939}
940
941
942Void TDecSbac::parseIntraDirLumaAng  ( TComDataCU* pcCU, UInt absPartIdx, UInt depth )
943{
944  PartSize mode = pcCU->getPartitionSize( absPartIdx );
945  UInt partNum = mode==SIZE_NxN?4:1;
946  UInt partOffset = ( pcCU->getPic()->getNumPartitionsInCtu() >> ( pcCU->getDepth(absPartIdx) << 1 ) ) >> 2;
947  UInt mpmPred[4],symbol;
948  Int j,intraPredMode;
949  if (mode==SIZE_NxN)
950  {
951    depth++;
952  }
953#if RExt__DECODER_DEBUG_BIT_STATISTICS
954  const TComCodingStatisticsClassType ctype(STATS__CABAC_BITS__INTRA_DIR_ANG, g_aucConvertToBit[pcCU->getSlice()->getSPS()->getMaxCUWidth()>>depth]+2, CHANNEL_TYPE_LUMA);
955#endif
956  for (j=0;j<partNum;j++)
957  {
958#if NH_3D_DMM
959    if( pcCU->getSlice()->getIntraSdcWedgeFlag() || pcCU->getSlice()->getIntraContourFlag() )
960    {
961      xParseIntraDepthMode( pcCU, absPartIdx+partOffset*j, depth );
962      xParseDmmData       ( pcCU, absPartIdx+partOffset*j, depth );
963    }
964    if( pcCU->getIntraDir( CHANNEL_TYPE_LUMA, absPartIdx+partOffset*j ) < NUM_INTRA_MODE )
965    {
966#endif
967    m_pcTDecBinIf->decodeBin( symbol, m_cCUIntraPredSCModel.get( 0, 0, 0) RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype) );
968    mpmPred[j] = symbol;
969#if H_MV_ENC_DEC_TRAC         
970      DTRACE_CU("prev_intra_luma_pred_flag", symbol)
971#endif
972#if NH_3D_DMM
973    }
974#endif
975  }
976  for (j=0;j<partNum;j++)
977  {
978#if NH_3D_DMM
979    if( pcCU->getIntraDir( CHANNEL_TYPE_LUMA, absPartIdx+partOffset*j ) < NUM_INTRA_MODE )
980    {
981#endif
982    Int preds[NUM_MOST_PROBABLE_MODES] = {-1, -1, -1};
983    pcCU->getIntraDirPredictor(absPartIdx+partOffset*j, preds, COMPONENT_Y);
984    if (mpmPred[j])
985    {
986      m_pcTDecBinIf->decodeBinEP( symbol RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype) );
987      if (symbol)
988      {
989        m_pcTDecBinIf->decodeBinEP( symbol RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype) );
990        symbol++;
991      }
992#if H_MV_ENC_DEC_TRAC         
993        DTRACE_CU("mpm_idx", symbol)
994#endif
995      intraPredMode = preds[symbol];
996    }
997    else
998    {
999      m_pcTDecBinIf->decodeBinsEP( symbol, 5 RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype) );
1000      intraPredMode = symbol;
1001#if H_MV_ENC_DEC_TRAC         
1002        DTRACE_CU("rem_intra_luma_pred_mode", symbol)
1003#endif       
1004
1005      //postponed sorting of MPMs (only in remaining branch)
1006      if (preds[0] > preds[1])
1007      {
1008        std::swap(preds[0], preds[1]);
1009      }
1010      if (preds[0] > preds[2])
1011      {
1012        std::swap(preds[0], preds[2]);
1013      }
1014      if (preds[1] > preds[2])
1015      {
1016        std::swap(preds[1], preds[2]);
1017      }
1018      for ( UInt i = 0; i < NUM_MOST_PROBABLE_MODES; i++ )
1019      {
1020        intraPredMode += ( intraPredMode >= preds[i] );
1021      }
1022    }
1023    pcCU->setIntraDirSubParts(CHANNEL_TYPE_LUMA, (UChar)intraPredMode, absPartIdx+partOffset*j, depth );
1024#if NH_3D_DMM
1025    }
1026#endif
1027  }
1028}
1029
1030
1031Void TDecSbac::parseIntraDirChroma( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
1032{
1033  UInt uiSymbol;
1034#if RExt__DECODER_DEBUG_BIT_STATISTICS
1035  const TComCodingStatisticsClassType ctype(STATS__CABAC_BITS__INTRA_DIR_ANG, g_aucConvertToBit[pcCU->getSlice()->getSPS()->getMaxCUWidth()>>uiDepth]+2, CHANNEL_TYPE_CHROMA);
1036#endif
1037
1038  m_pcTDecBinIf->decodeBin( uiSymbol, m_cCUChromaPredSCModel.get( 0, 0, 0 ) RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype) );
1039  if( uiSymbol == 0 )
1040  {
1041#if H_MV_ENC_DEC_TRAC         
1042    DTRACE_CU("intra_chroma_pred_mode", uiSymbol )
1043#endif       
1044    uiSymbol = DM_CHROMA_IDX;
1045  }
1046  else
1047  {
1048    UInt uiIPredMode;
1049    m_pcTDecBinIf->decodeBinsEP( uiIPredMode, 2 RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype) );
1050#if H_MV_ENC_DEC_TRAC         
1051      DTRACE_CU("intra_chroma_pred_mode", uiIPredMode )
1052#endif       
1053    UInt uiAllowedChromaDir[ NUM_CHROMA_MODE ];
1054    pcCU->getAllowedChromaDir( uiAbsPartIdx, uiAllowedChromaDir );
1055    uiSymbol = uiAllowedChromaDir[ uiIPredMode ];
1056  }
1057
1058  pcCU->setIntraDirSubParts( CHANNEL_TYPE_CHROMA, uiSymbol, uiAbsPartIdx, uiDepth );
1059}
1060
1061Void TDecSbac::parseInterDir( TComDataCU* pcCU, UInt& ruiInterDir, UInt uiAbsPartIdx )
1062{
1063  UInt uiSymbol;
1064  const UInt uiCtx = pcCU->getCtxInterDir( uiAbsPartIdx );
1065  ContextModel *pCtx = m_cCUInterDirSCModel.get( 0 );
1066
1067  uiSymbol = 0;
1068  if (pcCU->getPartitionSize(uiAbsPartIdx) == SIZE_2Nx2N || pcCU->getHeight(uiAbsPartIdx) != 8 )
1069  {
1070    m_pcTDecBinIf->decodeBin( uiSymbol, *( pCtx + uiCtx ) RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__INTER_DIR) );
1071  }
1072
1073  if( uiSymbol )
1074  {
1075    uiSymbol = 2;
1076  }
1077  else
1078  {
1079    m_pcTDecBinIf->decodeBin( uiSymbol, *( pCtx + 4 ) RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__INTER_DIR) );
1080    assert(uiSymbol == 0 || uiSymbol == 1);
1081  }
1082
1083  uiSymbol++;
1084  ruiInterDir = uiSymbol;
1085#if H_MV_ENC_DEC_TRAC
1086    DTRACE_PU("inter_pred_idc", ruiInterDir - 1 )   
1087#endif
1088
1089  return;
1090}
1091
1092Void TDecSbac::parseRefFrmIdx( TComDataCU* pcCU, Int& riRefFrmIdx, RefPicList eRefList )
1093{
1094  UInt uiSymbol;
1095
1096  ContextModel *pCtx = m_cCURefPicSCModel.get( 0 );
1097  m_pcTDecBinIf->decodeBin( uiSymbol, *pCtx RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__REF_FRM_IDX) );
1098
1099  if( uiSymbol )
1100  {
1101    UInt uiRefNum = pcCU->getSlice()->getNumRefIdx( eRefList ) - 2;
1102    pCtx++;
1103    UInt ui;
1104    for( ui = 0; ui < uiRefNum; ++ui )
1105    {
1106      if( ui == 0 )
1107      {
1108        m_pcTDecBinIf->decodeBin( uiSymbol, *pCtx RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__REF_FRM_IDX) );
1109      }
1110      else
1111      {
1112        m_pcTDecBinIf->decodeBinEP( uiSymbol RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__REF_FRM_IDX) );
1113      }
1114      if( uiSymbol == 0 )
1115      {
1116        break;
1117      }
1118    }
1119    uiSymbol = ui + 1;
1120  }
1121  riRefFrmIdx = uiSymbol;
1122#if H_MV_ENC_DEC_TRAC
1123#if ENC_DEC_TRACE
1124  if ( eRefList == REF_PIC_LIST_0 )
1125  {
1126    DTRACE_PU("ref_idx_l0", uiSymbol)
1127  }
1128  else
1129  {
1130    DTRACE_PU("ref_idx_l1", uiSymbol)
1131  }
1132#endif
1133#endif
1134
1135  return;
1136}
1137
1138Void TDecSbac::parseMvd( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth, RefPicList eRefList )
1139{
1140  UInt uiSymbol;
1141  UInt uiHorAbs;
1142  UInt uiVerAbs;
1143  UInt uiHorSign = 0;
1144  UInt uiVerSign = 0;
1145  ContextModel *pCtx = m_cCUMvdSCModel.get( 0 );
1146
1147  if(pcCU->getSlice()->getMvdL1ZeroFlag() && eRefList == REF_PIC_LIST_1 && pcCU->getInterDir(uiAbsPartIdx)==3)
1148  {
1149    uiHorAbs=0;
1150    uiVerAbs=0;
1151  }
1152  else
1153  {
1154    m_pcTDecBinIf->decodeBin( uiHorAbs, *pCtx RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__MVD) );
1155    m_pcTDecBinIf->decodeBin( uiVerAbs, *pCtx RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__MVD) );
1156
1157    const Bool bHorAbsGr0 = uiHorAbs != 0;
1158    const Bool bVerAbsGr0 = uiVerAbs != 0;
1159    pCtx++;
1160
1161    if( bHorAbsGr0 )
1162    {
1163      m_pcTDecBinIf->decodeBin( uiSymbol, *pCtx RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__MVD) );
1164      uiHorAbs += uiSymbol;
1165    }
1166
1167    if( bVerAbsGr0 )
1168    {
1169      m_pcTDecBinIf->decodeBin( uiSymbol, *pCtx RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__MVD) );
1170      uiVerAbs += uiSymbol;
1171    }
1172
1173    if( bHorAbsGr0 )
1174    {
1175      if( 2 == uiHorAbs )
1176      {
1177        xReadEpExGolomb( uiSymbol, 1 RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__MVD_EP) );
1178        uiHorAbs += uiSymbol;
1179      }
1180
1181      m_pcTDecBinIf->decodeBinEP( uiHorSign RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__MVD_EP) );
1182    }
1183
1184    if( bVerAbsGr0 )
1185    {
1186      if( 2 == uiVerAbs )
1187      {
1188        xReadEpExGolomb( uiSymbol, 1 RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__MVD_EP) );
1189        uiVerAbs += uiSymbol;
1190      }
1191
1192      m_pcTDecBinIf->decodeBinEP( uiVerSign RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__MVD_EP) );
1193    }
1194
1195  }
1196
1197  const TComMv cMv( uiHorSign ? -Int( uiHorAbs ): uiHorAbs, uiVerSign ? -Int( uiVerAbs ) : uiVerAbs );
1198  pcCU->getCUMvField( eRefList )->setAllMvd( cMv, pcCU->getPartitionSize( uiAbsPartIdx ), uiAbsPartIdx, uiDepth, uiPartIdx );
1199  return;
1200}
1201
1202Void TDecSbac::parseCrossComponentPrediction( TComTU &rTu, ComponentID compID )
1203{
1204  TComDataCU *pcCU = rTu.getCU();
1205
1206  if( isLuma(compID) || !pcCU->getSlice()->getPPS()->getPpsRangeExtension().getCrossComponentPredictionEnabledFlag() )
1207  {
1208    return;
1209  }
1210
1211  const UInt uiAbsPartIdx = rTu.GetAbsPartIdxTU();
1212
1213  if (!pcCU->isIntra(uiAbsPartIdx) || (pcCU->getIntraDir( CHANNEL_TYPE_CHROMA, uiAbsPartIdx ) == DM_CHROMA_IDX))
1214  {
1215    Char alpha  = 0;
1216    UInt symbol = 0;
1217
1218    DTRACE_CABAC_VL( g_nSymbolCounter++ )
1219    DTRACE_CABAC_T("\tparseCrossComponentPrediction()")
1220    DTRACE_CABAC_T( "\tAddr=" )
1221    DTRACE_CABAC_V( compID )
1222    DTRACE_CABAC_T( "\tuiAbsPartIdx=" )
1223    DTRACE_CABAC_V( uiAbsPartIdx )
1224#if RExt__DECODER_DEBUG_BIT_STATISTICS
1225    TComCodingStatisticsClassType ctype(STATS__CABAC_BITS__CROSS_COMPONENT_PREDICTION, (g_aucConvertToBit[rTu.getRect(compID).width] + 2), compID);
1226#endif
1227    ContextModel *pCtx = m_cCrossComponentPredictionSCModel.get(0, 0) + ((compID == COMPONENT_Cr) ? (NUM_CROSS_COMPONENT_PREDICTION_CTX >> 1) : 0);
1228    m_pcTDecBinIf->decodeBin( symbol, pCtx[0] RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype) );
1229
1230    if(symbol != 0)
1231    {
1232      // Cross-component prediction alpha is non-zero.
1233      UInt sign = 0;
1234      m_pcTDecBinIf->decodeBin( symbol, pCtx[1] RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype) );
1235
1236      if (symbol != 0)
1237      {
1238        // alpha is 2 (symbol=1), 4(symbol=2) or 8(symbol=3).
1239        // Read up to two more bits
1240        xReadUnaryMaxSymbol( symbol, (pCtx + 2), 1, 2 RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype) );
1241        symbol += 1;
1242      }
1243      m_pcTDecBinIf->decodeBin( sign, pCtx[4] RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype) );
1244
1245      alpha = (sign != 0) ? -(1 << symbol) : (1 << symbol);
1246    }
1247    DTRACE_CABAC_T( "\tAlpha=" )
1248    DTRACE_CABAC_V( alpha )
1249    DTRACE_CABAC_T( "\n" )
1250
1251    pcCU->setCrossComponentPredictionAlphaPartRange( alpha, compID, uiAbsPartIdx, rTu.GetAbsPartIdxNumParts( compID ) );
1252  }
1253}
1254
1255Void TDecSbac::parseTransformSubdivFlag( UInt& ruiSubdivFlag, UInt uiLog2TransformBlockSize )
1256{
1257  m_pcTDecBinIf->decodeBin( ruiSubdivFlag, m_cCUTransSubdivFlagSCModel.get( 0, 0, uiLog2TransformBlockSize )
1258      RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(TComCodingStatisticsClassType(STATS__CABAC_BITS__TRANSFORM_SUBDIV_FLAG, 5-uiLog2TransformBlockSize))
1259                          );
1260#if !H_MV_ENC_DEC_TRAC
1261  DTRACE_CABAC_VL( g_nSymbolCounter++ )
1262  DTRACE_CABAC_T( "\tparseTransformSubdivFlag()" )
1263  DTRACE_CABAC_T( "\tsymbol=" )
1264  DTRACE_CABAC_V( ruiSubdivFlag )
1265  DTRACE_CABAC_T( "\tctx=" )
1266  DTRACE_CABAC_V( uiLog2TransformBlockSize )
1267  DTRACE_CABAC_T( "\n" )
1268#else
1269  DTRACE_TU("split_transform_flag", ruiSubdivFlag )
1270#endif
1271
1272}
1273
1274Void TDecSbac::parseQtRootCbf( UInt uiAbsPartIdx, UInt& uiQtRootCbf )
1275{
1276  UInt uiSymbol;
1277  const UInt uiCtx = 0;
1278  m_pcTDecBinIf->decodeBin( uiSymbol , m_cCUQtRootCbfSCModel.get( 0, 0, uiCtx ) RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__QT_ROOT_CBF) );
1279#if !H_MV_ENC_DEC_TRAC
1280  DTRACE_CABAC_VL( g_nSymbolCounter++ )
1281  DTRACE_CABAC_T( "\tparseQtRootCbf()" )
1282  DTRACE_CABAC_T( "\tsymbol=" )
1283  DTRACE_CABAC_V( uiSymbol )
1284  DTRACE_CABAC_T( "\tctx=" )
1285  DTRACE_CABAC_V( uiCtx )
1286  DTRACE_CABAC_T( "\tuiAbsPartIdx=" )
1287  DTRACE_CABAC_V( uiAbsPartIdx )
1288  DTRACE_CABAC_T( "\n" )
1289#else
1290  DTRACE_CU( "rqt_root_cbf", uiSymbol )
1291#endif
1292
1293  uiQtRootCbf = uiSymbol;
1294}
1295
1296Void TDecSbac::parseDeltaQP( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
1297{
1298  Int qp;
1299  UInt uiDQp;
1300  Int  iDQp;
1301
1302  UInt uiSymbol;
1303
1304  xReadUnaryMaxSymbol (uiDQp,  &m_cCUDeltaQpSCModel.get( 0, 0, 0 ), 1, CU_DQP_TU_CMAX RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__DELTA_QP_EP) );
1305
1306  if( uiDQp >= CU_DQP_TU_CMAX)
1307  {
1308    xReadEpExGolomb( uiSymbol, CU_DQP_EG_k RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__DELTA_QP_EP));
1309    uiDQp+=uiSymbol;
1310  }
1311
1312  if ( uiDQp > 0 )
1313  {
1314    UInt uiSign;
1315    Int qpBdOffsetY = pcCU->getSlice()->getSPS()->getQpBDOffset(CHANNEL_TYPE_LUMA);
1316    m_pcTDecBinIf->decodeBinEP(uiSign RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__DELTA_QP_EP));
1317    iDQp = uiDQp;
1318    if(uiSign)
1319    {
1320      iDQp = -iDQp;
1321    }
1322    qp = (((Int) pcCU->getRefQP( uiAbsPartIdx ) + iDQp + 52 + 2*qpBdOffsetY )%(52+qpBdOffsetY)) - qpBdOffsetY;
1323  }
1324  else
1325  {
1326    qp = pcCU->getRefQP(uiAbsPartIdx);
1327  }
1328
1329  pcCU->setQPSubParts(qp, uiAbsPartIdx, uiDepth);
1330  pcCU->setCodedQP(qp);
1331}
1332
1333/** parse chroma qp adjustment, converting to the internal table representation.
1334 * \returns Void
1335 */
1336Void TDecSbac::parseChromaQpAdjustment( TComDataCU* cu, UInt absPartIdx, UInt depth )
1337{
1338  UInt symbol;
1339#if RExt__DECODER_DEBUG_BIT_STATISTICS
1340  const TComCodingStatisticsClassType ctype(STATS__CABAC_BITS__CHROMA_QP_ADJUSTMENT, g_aucConvertToBit[cu->getSlice()->getSPS()->getMaxCUWidth()>>depth]+2, CHANNEL_TYPE_CHROMA);
1341#endif
1342
1343  Int chromaQpOffsetListLen = cu->getSlice()->getPPS()->getPpsRangeExtension().getChromaQpOffsetListLen();
1344
1345  // cu_chroma_qp_offset_flag
1346  m_pcTDecBinIf->decodeBin( symbol, m_ChromaQpAdjFlagSCModel.get( 0, 0, 0 ) RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype) );
1347
1348  if (symbol && chromaQpOffsetListLen > 1)
1349  {
1350    // cu_chroma_qp_offset_idx
1351    xReadUnaryMaxSymbol( symbol,  &m_ChromaQpAdjIdcSCModel.get( 0, 0, 0 ), 0, chromaQpOffsetListLen - 1 RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype) );
1352    symbol++;
1353  }
1354  /* NB, symbol = 0 if outer flag is not set,
1355   *              1 if outer flag is set and there is no inner flag
1356   *              1+ otherwise */
1357  cu->setChromaQpAdjSubParts( symbol, absPartIdx, depth );
1358  cu->setCodedChromaQpAdj(symbol);
1359}
1360
1361Void TDecSbac::parseQtCbf( TComTU &rTu, const ComponentID compID, const Bool lowestLevel )
1362{
1363  TComDataCU* pcCU = rTu.getCU();
1364
1365  const UInt absPartIdx       = rTu.GetAbsPartIdxTU(compID);
1366  const UInt TUDepth          = rTu.GetTransformDepthRel();
1367  const UInt uiCtx            = pcCU->getCtxQtCbf( rTu, toChannelType(compID) );
1368  const UInt contextSet       = toChannelType(compID);
1369
1370  const UInt width            = rTu.getRect(compID).width;
1371  const UInt height           = rTu.getRect(compID).height;
1372  const Bool canQuadSplit     = (width >= (MIN_TU_SIZE * 2)) && (height >= (MIN_TU_SIZE * 2));
1373  const UInt coveredPartIdxes = rTu.GetAbsPartIdxNumParts(compID);
1374
1375  //             Since the CBF for chroma is coded at the highest level possible, if sub-TUs are
1376  //             to be coded for a 4x8 chroma TU, their CBFs must be coded at the highest 4x8 level
1377  //             (i.e. where luma TUs are 8x8 rather than 4x4)
1378  //    ___ ___
1379  //   |   |   | <- 4 x (8x8 luma + 4x8 4:2:2 chroma)
1380  //   |___|___|    each quadrant has its own chroma CBF
1381  //   |   |   | _ _ _ _
1382  //   |___|___|        |
1383  //   <--16--->        V
1384  //                   _ _
1385  //                  |_|_| <- 4 x 4x4 luma + 1 x 4x8 4:2:2 chroma
1386  //                  |_|_|    no chroma CBF is coded - instead the parent CBF is inherited
1387  //                  <-8->    if sub-TUs are present, their CBFs had to be coded at the parent level
1388
1389  const UInt lowestTUDepth = TUDepth + ((!lowestLevel && !canQuadSplit) ? 1 : 0); //unsplittable TUs inherit their parent's CBF
1390        UInt lowestTUCBF   = 0;
1391
1392  if ((width != height) && (lowestLevel || !canQuadSplit)) //if sub-TUs are present
1393  {
1394    const UInt subTUDepth        = lowestTUDepth + 1;
1395    const UInt partIdxesPerSubTU = rTu.GetAbsPartIdxNumParts(compID) >> 1;
1396
1397    UInt combinedSubTUCBF = 0;
1398
1399    for (UInt subTU = 0; subTU < 2; subTU++)
1400    {
1401      UInt uiCbf = MAX_UINT;
1402      m_pcTDecBinIf->decodeBin(uiCbf, m_cCUQtCbfSCModel.get(0, contextSet, uiCtx) RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(TComCodingStatisticsClassType(STATS__CABAC_BITS__QT_CBF, g_aucConvertToBit[rTu.getRect(compID).width]+2, compID)));
1403
1404      const UInt subTUAbsPartIdx = absPartIdx + (subTU * partIdxesPerSubTU);
1405      pcCU->setCbfPartRange((uiCbf << subTUDepth), compID, subTUAbsPartIdx, partIdxesPerSubTU);
1406      combinedSubTUCBF |= uiCbf;
1407#if !H_MV_ENC_DEC_TRAC 
1408      DTRACE_CABAC_VL( g_nSymbolCounter++ )
1409      DTRACE_CABAC_T( "\tparseQtCbf()" )
1410      DTRACE_CABAC_T( "\tsub-TU=" )
1411      DTRACE_CABAC_V( subTU )
1412      DTRACE_CABAC_T( "\tsymbol=" )
1413      DTRACE_CABAC_V( uiCbf )
1414      DTRACE_CABAC_T( "\tctx=" )
1415      DTRACE_CABAC_V( uiCtx )
1416      DTRACE_CABAC_T( "\tetype=" )
1417      DTRACE_CABAC_V( compID )
1418      DTRACE_CABAC_T( "\tuiAbsPartIdx=" )
1419      DTRACE_CABAC_V( subTUAbsPartIdx )
1420      DTRACE_CABAC_T( "\n" )
1421#else
1422  if ( compID == COMPONENT_Cb )
1423  {
1424    DTRACE_TU("cbf_cb", uiCbf )
1425  }
1426  else if ( compID == COMPONENT_Cr )
1427  {
1428    DTRACE_TU("cbf_cr", uiCbf )
1429  }
1430  else
1431  {
1432    DTRACE_TU("cbf_luma", uiCbf )
1433  }
1434#endif
1435
1436    }
1437
1438    //propagate the sub-TU CBF up to the lowest TU level
1439    if (combinedSubTUCBF != 0)
1440    {
1441      pcCU->bitwiseOrCbfPartRange((combinedSubTUCBF << lowestTUDepth), compID, absPartIdx, coveredPartIdxes);
1442      lowestTUCBF = combinedSubTUCBF;
1443    }
1444  }
1445  else
1446  {
1447    UInt uiCbf = MAX_UINT;
1448    m_pcTDecBinIf->decodeBin(uiCbf, m_cCUQtCbfSCModel.get(0, contextSet, uiCtx) RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(TComCodingStatisticsClassType(STATS__CABAC_BITS__QT_CBF, g_aucConvertToBit[rTu.getRect(compID).width]+2, compID)));
1449
1450    pcCU->setCbfSubParts((uiCbf << lowestTUDepth), compID, absPartIdx, rTu.GetTransformDepthTotalAdj(compID));
1451#if !H_MV_ENC_DEC_TRAC
1452    DTRACE_CABAC_VL( g_nSymbolCounter++ )
1453    DTRACE_CABAC_T( "\tparseQtCbf()" )
1454    DTRACE_CABAC_T( "\tsymbol=" )
1455    DTRACE_CABAC_V( uiCbf )
1456    DTRACE_CABAC_T( "\tctx=" )
1457    DTRACE_CABAC_V( uiCtx )
1458    DTRACE_CABAC_T( "\tetype=" )
1459    DTRACE_CABAC_V( compID )
1460    DTRACE_CABAC_T( "\tuiAbsPartIdx=" )
1461    DTRACE_CABAC_V( rTu.GetAbsPartIdxTU(compID) )
1462    DTRACE_CABAC_T( "\n" )
1463#else
1464    if ( compID == COMPONENT_Cb )
1465    {
1466      DTRACE_TU("cbf_cb", uiCbf )
1467    }
1468    else if ( compID == COMPONENT_Cr )
1469    {
1470      DTRACE_TU("cbf_cr", uiCbf )
1471    }
1472    else
1473    {
1474      DTRACE_TU("cbf_luma", uiCbf )
1475    }
1476#endif
1477    lowestTUCBF = uiCbf;
1478  }
1479
1480  //propagate the lowest level CBF up to the current level
1481  if (lowestTUCBF != 0)
1482  {
1483    for (UInt depth = TUDepth; depth < lowestTUDepth; depth++)
1484    {
1485      pcCU->bitwiseOrCbfPartRange((lowestTUCBF << depth), compID, absPartIdx, coveredPartIdxes);
1486    }
1487  }
1488}
1489
1490
1491Void TDecSbac::parseTransformSkipFlags (TComTU &rTu, ComponentID component)
1492{
1493  TComDataCU* pcCU=rTu.getCU();
1494  UInt uiAbsPartIdx=rTu.GetAbsPartIdxTU(component);
1495
1496  if (pcCU->getCUTransquantBypass(uiAbsPartIdx))
1497  {
1498    return;
1499  }
1500
1501  if (!TUCompRectHasAssociatedTransformSkipFlag(rTu.getRect(component), pcCU->getSlice()->getPPS()->getPpsRangeExtension().getLog2MaxTransformSkipBlockSize()))
1502  {
1503    return;
1504  }
1505
1506  UInt useTransformSkip;
1507
1508  m_pcTDecBinIf->decodeBin( useTransformSkip , m_cTransformSkipSCModel.get( 0, toChannelType(component), 0 )
1509      RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(TComCodingStatisticsClassType(STATS__CABAC_BITS__TRANSFORM_SKIP_FLAGS, component))
1510                          );
1511
1512#if !H_MV_ENC_DEC_TRAC
1513  DTRACE_CABAC_VL( g_nSymbolCounter++ )
1514  DTRACE_CABAC_T("\tparseTransformSkip()");
1515  DTRACE_CABAC_T( "\tsymbol=" )
1516  DTRACE_CABAC_V( useTransformSkip )
1517  DTRACE_CABAC_T( "\tAddr=" )
1518  DTRACE_CABAC_V( pcCU->getCtuRsAddr() )
1519  DTRACE_CABAC_T( "\tetype=" )
1520  DTRACE_CABAC_V( component )
1521  DTRACE_CABAC_T( "\tuiAbsPartIdx=" )
1522  DTRACE_CABAC_V( rTu.GetAbsPartIdxTU() )
1523  DTRACE_CABAC_T( "\n" )
1524#endif
1525
1526  pcCU->setTransformSkipPartRange( useTransformSkip, component, uiAbsPartIdx, rTu.GetAbsPartIdxNumParts(component));
1527}
1528
1529
1530/** Parse (X,Y) position of the last significant coefficient
1531 * \param uiPosLastX reference to X component of last coefficient
1532 * \param uiPosLastY reference to Y component of last coefficient
1533 * \param width  Block width
1534 * \param height Block height
1535 * \param component chroma compinent ID
1536 * \param uiScanIdx scan type (zig-zag, hor, ver)
1537 *
1538 * This method decodes the X and Y component within a block of the last significant coefficient.
1539 */
1540Void TDecSbac::parseLastSignificantXY( UInt& uiPosLastX, UInt& uiPosLastY, Int width, Int height, ComponentID component, UInt uiScanIdx )
1541{
1542  UInt uiLast;
1543
1544  ContextModel *pCtxX = m_cCuCtxLastX.get( 0, toChannelType(component) );
1545  ContextModel *pCtxY = m_cCuCtxLastY.get( 0, toChannelType(component) );
1546
1547#if RExt__DECODER_DEBUG_BIT_STATISTICS
1548  TComCodingStatisticsClassType ctype(STATS__CABAC_BITS__LAST_SIG_X_Y, g_aucConvertToBit[width]+2, component);
1549#endif
1550
1551
1552  if ( uiScanIdx == SCAN_VER )
1553  {
1554    swap( width, height );
1555  }
1556
1557  Int blkSizeOffsetX, blkSizeOffsetY, shiftX, shiftY;
1558  getLastSignificantContextParameters(component, width, height, blkSizeOffsetX, blkSizeOffsetY, shiftX, shiftY);
1559
1560  //------------------
1561
1562  // posX
1563
1564  for( uiPosLastX = 0; uiPosLastX < g_uiGroupIdx[ width - 1 ]; uiPosLastX++ )
1565  {
1566    m_pcTDecBinIf->decodeBin( uiLast, *( pCtxX + blkSizeOffsetX + (uiPosLastX >>shiftX) ) RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype) );
1567
1568    if( !uiLast )
1569    {
1570      break;
1571    }
1572  }
1573
1574  // posY
1575
1576  for( uiPosLastY = 0; uiPosLastY < g_uiGroupIdx[ height - 1 ]; uiPosLastY++ )
1577  {
1578    m_pcTDecBinIf->decodeBin( uiLast, *( pCtxY + blkSizeOffsetY + (uiPosLastY >>shiftY)) RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype) );
1579
1580    if( !uiLast )
1581    {
1582      break;
1583    }
1584  }
1585
1586  // EP-coded part
1587
1588  if ( uiPosLastX > 3 )
1589  {
1590    UInt uiTemp  = 0;
1591    UInt uiCount = ( uiPosLastX - 2 ) >> 1;
1592    for ( Int i = uiCount - 1; i >= 0; i-- )
1593    {
1594      m_pcTDecBinIf->decodeBinEP( uiLast RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype) );
1595      uiTemp += uiLast << i;
1596    }
1597    uiPosLastX = g_uiMinInGroup[ uiPosLastX ] + uiTemp;
1598  }
1599  if ( uiPosLastY > 3 )
1600  {
1601    UInt uiTemp  = 0;
1602    UInt uiCount = ( uiPosLastY - 2 ) >> 1;
1603    for ( Int i = uiCount - 1; i >= 0; i-- )
1604    {
1605      m_pcTDecBinIf->decodeBinEP( uiLast RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype) );
1606      uiTemp += uiLast << i;
1607    }
1608    uiPosLastY = g_uiMinInGroup[ uiPosLastY ] + uiTemp;
1609  }
1610
1611  if( uiScanIdx == SCAN_VER )
1612  {
1613    swap( uiPosLastX, uiPosLastY );
1614  }
1615}
1616
1617Void TDecSbac::parseCoeffNxN(  TComTU &rTu, ComponentID compID )
1618{
1619  TComDataCU* pcCU=rTu.getCU();
1620  const UInt uiAbsPartIdx=rTu.GetAbsPartIdxTU(compID);
1621  const TComRectangle &rRect=rTu.getRect(compID);
1622  const UInt uiWidth=rRect.width;
1623  const UInt uiHeight=rRect.height;
1624  TCoeff* pcCoef=(pcCU->getCoeff(compID)+rTu.getCoefficientOffset(compID));
1625  const TComSPS &sps=*(pcCU->getSlice()->getSPS());
1626#if !H_MV_ENC_DEC_TRAC
1627  DTRACE_CABAC_VL( g_nSymbolCounter++ )
1628  DTRACE_CABAC_T( "\tparseCoeffNxN()\teType=" )
1629  DTRACE_CABAC_V( compID )
1630  DTRACE_CABAC_T( "\twidth=" )
1631  DTRACE_CABAC_V( uiWidth )
1632  DTRACE_CABAC_T( "\theight=" )
1633  DTRACE_CABAC_V( uiHeight )
1634  DTRACE_CABAC_T( "\tdepth=" )
1635//  DTRACE_CABAC_V( rTu.GetTransformDepthTotalAdj(compID) )
1636  DTRACE_CABAC_V( rTu.GetTransformDepthTotal() )
1637  DTRACE_CABAC_T( "\tabspartidx=" )
1638//  DTRACE_CABAC_V( uiAbsPartIdx )
1639  DTRACE_CABAC_V( rTu.GetAbsPartIdxTU(compID) )
1640  DTRACE_CABAC_T( "\ttoCU-X=" )
1641  DTRACE_CABAC_V( pcCU->getCUPelX() )
1642  DTRACE_CABAC_T( "\ttoCU-Y=" )
1643  DTRACE_CABAC_V( pcCU->getCUPelY() )
1644  DTRACE_CABAC_T( "\tCU-addr=" )
1645  DTRACE_CABAC_V(  pcCU->getCtuRsAddr() )
1646  DTRACE_CABAC_T( "\tinCU-X=" )
1647//  DTRACE_CABAC_V( g_auiRasterToPelX[ g_auiZscanToRaster[uiAbsPartIdx] ] )
1648  DTRACE_CABAC_V( g_auiRasterToPelX[ g_auiZscanToRaster[rTu.GetAbsPartIdxTU(compID)] ] )
1649  DTRACE_CABAC_T( "\tinCU-Y=" )
1650// DTRACE_CABAC_V( g_auiRasterToPelY[ g_auiZscanToRaster[uiAbsPartIdx] ] )
1651  DTRACE_CABAC_V( g_auiRasterToPelY[ g_auiZscanToRaster[rTu.GetAbsPartIdxTU(compID)] ] )
1652  DTRACE_CABAC_T( "\tpredmode=" )
1653  DTRACE_CABAC_V(  pcCU->getPredictionMode( uiAbsPartIdx ) )
1654  DTRACE_CABAC_T( "\n" )
1655#endif
1656
1657  //--------------------------------------------------------------------------------------------------
1658
1659  if( uiWidth > sps.getMaxTrSize() )
1660  {
1661    std::cerr << "ERROR: parseCoeffNxN was passed a TU with dimensions larger than the maximum allowed size" << std::endl;
1662    assert(false);
1663    exit(1);
1664  }
1665
1666  //--------------------------------------------------------------------------------------------------
1667
1668  //set parameters
1669
1670  const ChannelType  chType            = toChannelType(compID);
1671  const UInt         uiLog2BlockWidth  = g_aucConvertToBit[ uiWidth  ] + 2;
1672  const UInt         uiLog2BlockHeight = g_aucConvertToBit[ uiHeight ] + 2;
1673  const UInt         uiMaxNumCoeff     = uiWidth * uiHeight;
1674  const UInt         uiMaxNumCoeffM1   = uiMaxNumCoeff - 1;
1675
1676  const ChannelType  channelType       = toChannelType(compID);
1677  const Bool         extendedPrecision = sps.getSpsRangeExtension().getExtendedPrecisionProcessingFlag();
1678
1679  const Bool         alignCABACBeforeBypass = sps.getSpsRangeExtension().getCabacBypassAlignmentEnabledFlag();
1680  const Int          maxLog2TrDynamicRange  = sps.getMaxLog2TrDynamicRange(channelType);
1681
1682#if RExt__DECODER_DEBUG_BIT_STATISTICS
1683  TComCodingStatisticsClassType ctype_group(STATS__CABAC_BITS__SIG_COEFF_GROUP_FLAG, uiLog2BlockWidth, compID);
1684  TComCodingStatisticsClassType ctype_map(STATS__CABAC_BITS__SIG_COEFF_MAP_FLAG, uiLog2BlockWidth, compID);
1685  TComCodingStatisticsClassType ctype_gt1(STATS__CABAC_BITS__GT1_FLAG, uiLog2BlockWidth, compID);
1686  TComCodingStatisticsClassType ctype_gt2(STATS__CABAC_BITS__GT2_FLAG, uiLog2BlockWidth, compID);
1687#endif
1688
1689  Bool beValid;
1690  if (pcCU->getCUTransquantBypass(uiAbsPartIdx))
1691  {
1692    beValid = false;
1693    if((!pcCU->isIntra(uiAbsPartIdx)) && pcCU->isRDPCMEnabled(uiAbsPartIdx))
1694    {
1695      parseExplicitRdpcmMode(rTu, compID);
1696    }
1697  }
1698  else
1699  {
1700    beValid = pcCU->getSlice()->getPPS()->getSignHideFlag();
1701  }
1702
1703  UInt absSum = 0;
1704
1705  //--------------------------------------------------------------------------------------------------
1706
1707  if(pcCU->getSlice()->getPPS()->getUseTransformSkip())
1708  {
1709    parseTransformSkipFlags(rTu, compID);
1710    //  This TU has coefficients and is transform skipped. Check whether is inter coded and if yes decode the explicit RDPCM mode
1711    if(pcCU->getTransformSkip(uiAbsPartIdx, compID) && (!pcCU->isIntra(uiAbsPartIdx)) && pcCU->isRDPCMEnabled(uiAbsPartIdx) )
1712    {
1713      parseExplicitRdpcmMode(rTu, compID);
1714      if(pcCU->getExplicitRdpcmMode(compID, uiAbsPartIdx) != RDPCM_OFF)
1715      {
1716        //  Sign data hiding is avoided for horizontal and vertical RDPCM modes
1717        beValid = false;
1718      }
1719    }
1720  }
1721
1722  Int uiIntraMode = -1;
1723  const Bool       bIsLuma = isLuma(compID);
1724  Int isIntra = pcCU->isIntra(uiAbsPartIdx) ? 1 : 0;
1725  if ( isIntra && pcCU->isRDPCMEnabled(uiAbsPartIdx) )
1726  {
1727    const UInt partsPerMinCU = 1<<(2*(sps.getMaxTotalCUDepth() - sps.getLog2DiffMaxMinCodingBlockSize()));
1728    uiIntraMode = pcCU->getIntraDir( toChannelType(compID), uiAbsPartIdx );
1729    uiIntraMode = (uiIntraMode==DM_CHROMA_IDX && !bIsLuma) ? pcCU->getIntraDir(CHANNEL_TYPE_LUMA, getChromasCorrespondingPULumaIdx(uiAbsPartIdx, rTu.GetChromaFormat(), partsPerMinCU)) : uiIntraMode;
1730    uiIntraMode = ((rTu.GetChromaFormat() == CHROMA_422) && !bIsLuma) ? g_chroma422IntraAngleMappingTable[uiIntraMode] : uiIntraMode;
1731
1732    Bool transformSkip = pcCU->getTransformSkip( uiAbsPartIdx,compID);
1733    Bool rdpcm_lossy = ( transformSkip /*&& isIntra*/ && ( (uiIntraMode == HOR_IDX) || (uiIntraMode == VER_IDX) ) );
1734    if ( rdpcm_lossy )
1735    {
1736      beValid = false;
1737    }
1738  }
1739
1740  //--------------------------------------------------------------------------------------------------
1741
1742  const Bool  bUseGolombRiceParameterAdaptation = sps.getSpsRangeExtension().getPersistentRiceAdaptationEnabledFlag();
1743        UInt &currentGolombRiceStatistic        = m_golombRiceAdaptationStatistics[rTu.getGolombRiceStatisticsIndex(compID)];
1744
1745  //select scans
1746  TUEntropyCodingParameters codingParameters;
1747  getTUEntropyCodingParameters(codingParameters, rTu, compID);
1748
1749  //===== decode last significant =====
1750  UInt uiPosLastX, uiPosLastY;
1751  parseLastSignificantXY( uiPosLastX, uiPosLastY, uiWidth, uiHeight, compID, codingParameters.scanType );
1752  UInt uiBlkPosLast      = uiPosLastX + (uiPosLastY<<uiLog2BlockWidth);
1753  pcCoef[ uiBlkPosLast ] = 1;
1754
1755  //===== decode significance flags =====
1756  UInt uiScanPosLast;
1757  for( uiScanPosLast = 0; uiScanPosLast < uiMaxNumCoeffM1; uiScanPosLast++ )
1758  {
1759    UInt uiBlkPos = codingParameters.scan[ uiScanPosLast ];
1760    if( uiBlkPosLast == uiBlkPos )
1761    {
1762      break;
1763    }
1764  }
1765
1766  ContextModel * const baseCoeffGroupCtx = m_cCUSigCoeffGroupSCModel.get( 0, isChroma(chType) );
1767  ContextModel * const baseCtx = m_cCUSigSCModel.get( 0, 0 ) + getSignificanceMapContextOffset(compID);
1768
1769  const Int  iLastScanSet  = uiScanPosLast >> MLS_CG_SIZE;
1770  UInt c1                  = 1;
1771  UInt uiGoRiceParam       = 0;
1772
1773
1774  UInt uiSigCoeffGroupFlag[ MLS_GRP_NUM ];
1775  memset( uiSigCoeffGroupFlag, 0, sizeof(UInt) * MLS_GRP_NUM );
1776
1777  Int  iScanPosSig             = (Int) uiScanPosLast;
1778  for( Int iSubSet = iLastScanSet; iSubSet >= 0; iSubSet-- )
1779  {
1780    Int  iSubPos   = iSubSet << MLS_CG_SIZE;
1781    uiGoRiceParam  = currentGolombRiceStatistic / RExt__GOLOMB_RICE_INCREMENT_DIVISOR;
1782    Bool updateGolombRiceStatistics = bUseGolombRiceParameterAdaptation; //leave the statistics at 0 when not using the adaptation system
1783    Int numNonZero = 0;
1784
1785    Int lastNZPosInCG  = -1;
1786    Int firstNZPosInCG = 1 << MLS_CG_SIZE;
1787
1788    Bool escapeDataPresentInGroup = false;
1789
1790    Int pos[1 << MLS_CG_SIZE];
1791
1792    if( iScanPosSig == (Int) uiScanPosLast )
1793    {
1794      lastNZPosInCG  = iScanPosSig;
1795      firstNZPosInCG = iScanPosSig;
1796      iScanPosSig--;
1797      pos[ numNonZero ] = uiBlkPosLast;
1798      numNonZero = 1;
1799    }
1800
1801    // decode significant_coeffgroup_flag
1802    Int iCGBlkPos = codingParameters.scanCG[ iSubSet ];
1803    Int iCGPosY   = iCGBlkPos / codingParameters.widthInGroups;
1804    Int iCGPosX   = iCGBlkPos - (iCGPosY * codingParameters.widthInGroups);
1805
1806    if( iSubSet == iLastScanSet || iSubSet == 0)
1807    {
1808      uiSigCoeffGroupFlag[ iCGBlkPos ] = 1;
1809    }
1810    else
1811    {
1812      UInt uiSigCoeffGroup;
1813      UInt uiCtxSig  = TComTrQuant::getSigCoeffGroupCtxInc( uiSigCoeffGroupFlag, iCGPosX, iCGPosY, codingParameters.widthInGroups, codingParameters.heightInGroups );
1814      m_pcTDecBinIf->decodeBin( uiSigCoeffGroup, baseCoeffGroupCtx[ uiCtxSig ] RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype_group) );
1815      uiSigCoeffGroupFlag[ iCGBlkPos ] = uiSigCoeffGroup;
1816    }
1817
1818    // decode significant_coeff_flag
1819    const Int patternSigCtx = TComTrQuant::calcPatternSigCtx(uiSigCoeffGroupFlag, iCGPosX, iCGPosY, codingParameters.widthInGroups, codingParameters.heightInGroups);
1820
1821    UInt uiBlkPos, uiSig, uiCtxSig;
1822    for( ; iScanPosSig >= iSubPos; iScanPosSig-- )
1823    {
1824      uiBlkPos  = codingParameters.scan[ iScanPosSig ];
1825      uiSig     = 0;
1826
1827      if( uiSigCoeffGroupFlag[ iCGBlkPos ] )
1828      {
1829        if( iScanPosSig > iSubPos || iSubSet == 0  || numNonZero )
1830        {
1831          uiCtxSig  = TComTrQuant::getSigCtxInc( patternSigCtx, codingParameters, iScanPosSig, uiLog2BlockWidth, uiLog2BlockHeight, chType );
1832          m_pcTDecBinIf->decodeBin( uiSig, baseCtx[ uiCtxSig ] RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype_map) );
1833        }
1834        else
1835        {
1836          uiSig = 1;
1837        }
1838      }
1839      pcCoef[ uiBlkPos ] = uiSig;
1840      if( uiSig )
1841      {
1842        pos[ numNonZero ] = uiBlkPos;
1843        numNonZero ++;
1844        if( lastNZPosInCG == -1 )
1845        {
1846          lastNZPosInCG = iScanPosSig;
1847        }
1848        firstNZPosInCG = iScanPosSig;
1849      }
1850    }
1851
1852    if( numNonZero > 0 )
1853    {
1854      Bool signHidden = ( lastNZPosInCG - firstNZPosInCG >= SBH_THRESHOLD );
1855
1856      absSum = 0;
1857
1858      const UInt uiCtxSet = getContextSetIndex(compID, iSubSet, (c1 == 0));
1859      c1 = 1;
1860      UInt uiBin;
1861
1862      ContextModel *baseCtxMod = m_cCUOneSCModel.get( 0, 0 ) + (NUM_ONE_FLAG_CTX_PER_SET * uiCtxSet);
1863
1864      Int absCoeff[1 << MLS_CG_SIZE];
1865
1866      for ( Int i = 0; i < numNonZero; i++)
1867      {
1868        absCoeff[i] = 1;
1869      }
1870      Int numC1Flag = min(numNonZero, C1FLAG_NUMBER);
1871      Int firstC2FlagIdx = -1;
1872
1873      for( Int idx = 0; idx < numC1Flag; idx++ )
1874      {
1875        m_pcTDecBinIf->decodeBin( uiBin, baseCtxMod[c1] RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype_gt1) );
1876        if( uiBin == 1 )
1877        {
1878          c1 = 0;
1879          if (firstC2FlagIdx == -1)
1880          {
1881            firstC2FlagIdx = idx;
1882          }
1883          else //if a greater-than-one has been encountered already this group
1884          {
1885            escapeDataPresentInGroup = true;
1886          }
1887        }
1888        else if( (c1 < 3) && (c1 > 0) )
1889        {
1890          c1++;
1891        }
1892        absCoeff[ idx ] = uiBin + 1;
1893      }
1894
1895      if (c1 == 0)
1896      {
1897        baseCtxMod = m_cCUAbsSCModel.get( 0, 0 ) + (NUM_ABS_FLAG_CTX_PER_SET * uiCtxSet);
1898        if ( firstC2FlagIdx != -1)
1899        {
1900          m_pcTDecBinIf->decodeBin( uiBin, baseCtxMod[0] RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype_gt2) );
1901          absCoeff[ firstC2FlagIdx ] = uiBin + 2;
1902          if (uiBin != 0)
1903          {
1904            escapeDataPresentInGroup = true;
1905          }
1906        }
1907      }
1908
1909      escapeDataPresentInGroup = escapeDataPresentInGroup || (numNonZero > C1FLAG_NUMBER);
1910
1911      const Bool alignGroup = escapeDataPresentInGroup && alignCABACBeforeBypass;
1912
1913#if RExt__DECODER_DEBUG_BIT_STATISTICS
1914      TComCodingStatisticsClassType ctype_signs((alignGroup ? STATS__CABAC_BITS__ALIGNED_SIGN_BIT    : STATS__CABAC_BITS__SIGN_BIT   ), uiLog2BlockWidth, compID);
1915      TComCodingStatisticsClassType ctype_escs ((alignGroup ? STATS__CABAC_BITS__ALIGNED_ESCAPE_BITS : STATS__CABAC_BITS__ESCAPE_BITS), uiLog2BlockWidth, compID);
1916#endif
1917
1918      if (alignGroup)
1919      {
1920        m_pcTDecBinIf->align();
1921      }
1922
1923      UInt coeffSigns;
1924      if ( signHidden && beValid )
1925      {
1926        m_pcTDecBinIf->decodeBinsEP( coeffSigns, numNonZero-1 RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype_signs) );
1927        coeffSigns <<= 32 - (numNonZero-1);
1928      }
1929      else
1930      {
1931        m_pcTDecBinIf->decodeBinsEP( coeffSigns, numNonZero RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype_signs) );
1932        coeffSigns <<= 32 - numNonZero;
1933      }
1934
1935      Int iFirstCoeff2 = 1;
1936      if (escapeDataPresentInGroup)
1937      {
1938        for( Int idx = 0; idx < numNonZero; idx++ )
1939        {
1940          UInt baseLevel  = (idx < C1FLAG_NUMBER)? (2 + iFirstCoeff2) : 1;
1941
1942          if( absCoeff[ idx ] == baseLevel)
1943          {
1944            UInt uiLevel;
1945            xReadCoefRemainExGolomb( uiLevel, uiGoRiceParam, extendedPrecision, maxLog2TrDynamicRange RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype_escs) );
1946
1947            absCoeff[ idx ] = uiLevel + baseLevel;
1948
1949            if (absCoeff[idx] > (3 << uiGoRiceParam))
1950            {
1951              uiGoRiceParam = bUseGolombRiceParameterAdaptation ? (uiGoRiceParam + 1) : (std::min<UInt>((uiGoRiceParam + 1), 4));
1952            }
1953
1954            if (updateGolombRiceStatistics)
1955            {
1956              const UInt initialGolombRiceParameter = currentGolombRiceStatistic / RExt__GOLOMB_RICE_INCREMENT_DIVISOR;
1957
1958              if (uiLevel >= (3 << initialGolombRiceParameter))
1959              {
1960                currentGolombRiceStatistic++;
1961              }
1962              else if (((uiLevel * 2) < (1 << initialGolombRiceParameter)) && (currentGolombRiceStatistic > 0))
1963              {
1964                currentGolombRiceStatistic--;
1965              }
1966
1967              updateGolombRiceStatistics = false;
1968            }
1969          }
1970
1971          if(absCoeff[ idx ] >= 2)
1972          {
1973            iFirstCoeff2 = 0;
1974          }
1975        }
1976      }
1977
1978      for( Int idx = 0; idx < numNonZero; idx++ )
1979      {
1980        Int blkPos = pos[ idx ];
1981        // Signs applied later.
1982        pcCoef[ blkPos ] = absCoeff[ idx ];
1983        absSum += absCoeff[ idx ];
1984
1985        if ( idx == numNonZero-1 && signHidden && beValid )
1986        {
1987          // Infer sign of 1st element.
1988          if (absSum&0x1)
1989          {
1990            pcCoef[ blkPos ] = -pcCoef[ blkPos ];
1991          }
1992        }
1993        else
1994        {
1995          Int sign = static_cast<Int>( coeffSigns ) >> 31;
1996          pcCoef[ blkPos ] = ( pcCoef[ blkPos ] ^ sign ) - sign;
1997          coeffSigns <<= 1;
1998        }
1999      }
2000    }
2001  }
2002
2003#if ENVIRONMENT_VARIABLE_DEBUG_AND_TEST
2004  printSBACCoeffData(uiPosLastX, uiPosLastY, uiWidth, uiHeight, compID, uiAbsPartIdx, codingParameters.scanType, pcCoef);
2005#endif
2006
2007  return;
2008}
2009
2010Void TDecSbac::parseSaoMaxUvlc ( UInt& val, UInt maxSymbol )
2011{
2012  if (maxSymbol == 0)
2013  {
2014    val = 0;
2015    return;
2016  }
2017
2018  UInt code;
2019  Int  i;
2020  m_pcTDecBinIf->decodeBinEP( code RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__SAO) );
2021  if ( code == 0 )
2022  {
2023    val = 0;
2024    return;
2025  }
2026
2027  i=1;
2028  while (1)
2029  {
2030    m_pcTDecBinIf->decodeBinEP( code RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__SAO) );
2031    if ( code == 0 )
2032    {
2033      break;
2034    }
2035    i++;
2036    if (i == maxSymbol)
2037    {
2038      break;
2039    }
2040  }
2041
2042  val = i;
2043}
2044
2045Void TDecSbac::parseSaoUflc (UInt uiLength, UInt&  riVal)
2046{
2047  m_pcTDecBinIf->decodeBinsEP ( riVal, uiLength RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__SAO) );
2048}
2049
2050Void TDecSbac::parseSaoMerge (UInt&  ruiVal)
2051{
2052  UInt uiCode;
2053  m_pcTDecBinIf->decodeBin( uiCode, m_cSaoMergeSCModel.get( 0, 0, 0 ) RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__SAO) );
2054  ruiVal = (Int)uiCode;
2055}
2056
2057Void TDecSbac::parseSaoTypeIdx (UInt&  ruiVal)
2058{
2059  UInt uiCode;
2060  m_pcTDecBinIf->decodeBin( uiCode, m_cSaoTypeIdxSCModel.get( 0, 0, 0 ) RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__SAO) );
2061  if (uiCode == 0)
2062  {
2063    ruiVal = 0;
2064  }
2065  else
2066  {
2067    m_pcTDecBinIf->decodeBinEP( uiCode RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__SAO) );
2068    if (uiCode == 0)
2069    {
2070      ruiVal = 1;
2071    }
2072    else
2073    {
2074      ruiVal = 2;
2075    }
2076  }
2077}
2078
2079Void TDecSbac::parseSaoSign(UInt& val)
2080{
2081  m_pcTDecBinIf->decodeBinEP ( val RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__SAO) );
2082}
2083
2084Void TDecSbac::parseSAOBlkParam (SAOBlkParam& saoBlkParam
2085                                , Bool* sliceEnabled
2086                                , Bool leftMergeAvail
2087                                , Bool aboveMergeAvail
2088                                , const BitDepths &bitDepths
2089                                )
2090{
2091  UInt uiSymbol;
2092
2093  Bool isLeftMerge = false;
2094  Bool isAboveMerge= false;
2095
2096  if(leftMergeAvail)
2097  {
2098    parseSaoMerge(uiSymbol); //sao_merge_left_flag
2099    isLeftMerge = (uiSymbol?true:false);
2100  }
2101
2102  if( aboveMergeAvail && !isLeftMerge)
2103  {
2104    parseSaoMerge(uiSymbol); //sao_merge_up_flag
2105    isAboveMerge = (uiSymbol?true:false);
2106  }
2107
2108  if(isLeftMerge || isAboveMerge) //merge mode
2109  {
2110    for (UInt componentIndex = 0; componentIndex < MAX_NUM_COMPONENT; componentIndex++)
2111    {
2112      saoBlkParam[componentIndex].modeIdc = (sliceEnabled[componentIndex]) ? SAO_MODE_MERGE : SAO_MODE_OFF;
2113      saoBlkParam[componentIndex].typeIdc = (isLeftMerge)?SAO_MERGE_LEFT:SAO_MERGE_ABOVE;
2114    }
2115  }
2116  else //new or off mode
2117  {
2118    for(Int compId=COMPONENT_Y; compId < MAX_NUM_COMPONENT; compId++)
2119    {
2120      const ComponentID compIdx=ComponentID(compId);
2121      const ComponentID firstCompOfChType = getFirstComponentOfChannel(toChannelType(compIdx));
2122      SAOOffset& ctbParam = saoBlkParam[compIdx];
2123#if O0043_BEST_EFFORT_DECODING
2124      const Int bitDepthOrig = bitDepths.stream[toChannelType(compIdx)];
2125      const Int forceBitDepthAdjust = bitDepthOrig - bitDepths.recon[toChannelType(compIdx)];
2126#else
2127      const Int bitDepthOrig = bitDepths.recon[toChannelType(compIdx)];
2128#endif
2129      const Int maxOffsetQVal=TComSampleAdaptiveOffset::getMaxOffsetQVal(bitDepthOrig);
2130      if(!sliceEnabled[compIdx])
2131      {
2132        //off
2133        ctbParam.modeIdc = SAO_MODE_OFF;
2134        continue;
2135      }
2136
2137      //type
2138      if(compIdx == firstCompOfChType)
2139      {
2140        parseSaoTypeIdx(uiSymbol); //sao_type_idx_luma or sao_type_idx_chroma
2141
2142        assert(uiSymbol ==0 || uiSymbol ==1 || uiSymbol ==2);
2143
2144        if(uiSymbol ==0) //OFF
2145        {
2146          ctbParam.modeIdc = SAO_MODE_OFF;
2147        }
2148        else if(uiSymbol == 1) //BO
2149        {
2150          ctbParam.modeIdc = SAO_MODE_NEW;
2151          ctbParam.typeIdc = SAO_TYPE_START_BO;
2152        }
2153        else //2, EO
2154        {
2155          ctbParam.modeIdc = SAO_MODE_NEW;
2156          ctbParam.typeIdc = SAO_TYPE_START_EO;
2157        }
2158
2159      }
2160      else //Cr, follow Cb SAO type
2161      {
2162        ctbParam.modeIdc = saoBlkParam[COMPONENT_Cb].modeIdc;
2163        ctbParam.typeIdc = saoBlkParam[COMPONENT_Cb].typeIdc;
2164      }
2165
2166      if(ctbParam.modeIdc == SAO_MODE_NEW)
2167      {
2168        Int offset[4];
2169        for(Int i=0; i< 4; i++)
2170        {
2171          parseSaoMaxUvlc(uiSymbol, maxOffsetQVal ); //sao_offset_abs
2172          offset[i] = (Int)uiSymbol;
2173        }
2174
2175        if(ctbParam.typeIdc == SAO_TYPE_START_BO)
2176        {
2177          for(Int i=0; i< 4; i++)
2178          {
2179            if(offset[i] != 0)
2180            {
2181              parseSaoSign(uiSymbol); //sao_offset_sign
2182              if(uiSymbol)
2183              {
2184#if O0043_BEST_EFFORT_DECODING
2185                offset[i] >>= forceBitDepthAdjust;
2186#endif
2187                offset[i] = -offset[i];
2188              }
2189            }
2190          }
2191          parseSaoUflc(NUM_SAO_BO_CLASSES_LOG2, uiSymbol ); //sao_band_position
2192          ctbParam.typeAuxInfo = uiSymbol;
2193
2194          for(Int i=0; i<4; i++)
2195          {
2196            ctbParam.offset[(ctbParam.typeAuxInfo+i)%MAX_NUM_SAO_CLASSES] = offset[i];
2197          }
2198
2199        }
2200        else //EO
2201        {
2202          ctbParam.typeAuxInfo = 0;
2203
2204          if(firstCompOfChType == compIdx)
2205          {
2206            parseSaoUflc(NUM_SAO_EO_TYPES_LOG2, uiSymbol ); //sao_eo_class_luma or sao_eo_class_chroma
2207            ctbParam.typeIdc += uiSymbol;
2208          }
2209          else
2210          {
2211            ctbParam.typeIdc = saoBlkParam[firstCompOfChType].typeIdc;
2212          }
2213          ctbParam.offset[SAO_CLASS_EO_FULL_VALLEY] = offset[0];
2214          ctbParam.offset[SAO_CLASS_EO_HALF_VALLEY] = offset[1];
2215          ctbParam.offset[SAO_CLASS_EO_PLAIN      ] = 0;
2216          ctbParam.offset[SAO_CLASS_EO_HALF_PEAK  ] = -offset[2];
2217          ctbParam.offset[SAO_CLASS_EO_FULL_PEAK  ] = -offset[3];
2218        }
2219      }
2220    }
2221  }
2222}
2223
2224/**
2225 - Initialize our contexts from the nominated source.
2226 .
2227 \param pSrc Contexts to be copied.
2228 */
2229Void TDecSbac::xCopyContextsFrom( const TDecSbac* pSrc )
2230{
2231  memcpy(m_contextModels, pSrc->m_contextModels, m_numContextModels*sizeof(m_contextModels[0]));
2232  memcpy(m_golombRiceAdaptationStatistics, pSrc->m_golombRiceAdaptationStatistics, (sizeof(UInt) * RExt__GOLOMB_RICE_ADAPTATION_STATISTICS_SETS));
2233}
2234
2235Void TDecSbac::xCopyFrom( const TDecSbac* pSrc )
2236{
2237  m_pcTDecBinIf->copyState( pSrc->m_pcTDecBinIf );
2238  xCopyContextsFrom( pSrc );
2239}
2240
2241Void TDecSbac::load ( const TDecSbac* pSrc )
2242{
2243  xCopyFrom(pSrc);
2244}
2245
2246Void TDecSbac::loadContexts ( const TDecSbac* pSrc )
2247{
2248  xCopyContextsFrom(pSrc);
2249}
2250
2251/** Performs CABAC decoding of the explicit RDPCM mode
2252 * \param rTu current TU data structure
2253 * \param compID component identifier
2254 */
2255Void TDecSbac::parseExplicitRdpcmMode( TComTU &rTu, ComponentID compID )
2256{
2257  TComDataCU* cu = rTu.getCU();
2258  const UInt absPartIdx=rTu.GetAbsPartIdxTU(compID);
2259  const TComRectangle &rect = rTu.getRect(compID);
2260  const UInt tuHeight = g_aucConvertToBit[rect.height];
2261  const UInt tuWidth  = g_aucConvertToBit[rect.width];
2262  UInt code = 0;
2263
2264  assert(tuHeight == tuWidth);
2265
2266#if RExt__DECODER_DEBUG_BIT_STATISTICS
2267  const TComCodingStatisticsClassType ctype(STATS__EXPLICIT_RDPCM_BITS, g_aucConvertToBit[cu->getSlice()->getSPS()->getMaxCUWidth()>>rTu.GetTransformDepthTotal()]+2);
2268#endif
2269
2270  m_pcTDecBinIf->decodeBin(code, m_explicitRdpcmFlagSCModel.get (0, toChannelType(compID), 0) RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype));
2271
2272  if(code == 0)
2273  {
2274    cu->setExplicitRdpcmModePartRange( RDPCM_OFF, compID, absPartIdx, rTu.GetAbsPartIdxNumParts(compID));
2275  }
2276  else
2277  {
2278    m_pcTDecBinIf->decodeBin(code, m_explicitRdpcmDirSCModel.get (0, toChannelType(compID), 0) RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(ctype));
2279    if(code == 0)
2280    {
2281      cu->setExplicitRdpcmModePartRange( RDPCM_HOR, compID, absPartIdx, rTu.GetAbsPartIdxNumParts(compID));
2282    }
2283    else
2284    {
2285      cu->setExplicitRdpcmModePartRange( RDPCM_VER, compID, absPartIdx, rTu.GetAbsPartIdxNumParts(compID));
2286    }
2287  }
2288}
2289
2290#if H_3D_ARP
2291Void TDecSbac::parseARPW( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
2292{
2293  UInt uiMaxW = pcCU->getSlice()->getARPStepNum() - 1;
2294  UInt uiW = 0;
2295  UInt uiOffset = pcCU->getCTXARPWFlag(uiAbsPartIdx);
2296  UInt uiCode = 0;
2297
2298  assert ( uiMaxW > 0 );
2299
2300  m_pcTDecBinIf->decodeBin( uiCode , m_cCUPUARPWSCModel.get( 0, 0, 0 + uiOffset ) );
2301
2302  uiW = uiCode;
2303  if( 1 == uiW )   
2304  {
2305    m_pcTDecBinIf->decodeBin( uiCode , m_cCUPUARPWSCModel.get( 0, 0, 2 ) );
2306    uiW += ( 1 == uiCode ? 1 : 0 );
2307  }
2308#if H_MV_ENC_DEC_TRAC
2309  DTRACE_CU("iv_res_pred_weight_idx", uiW )
2310#endif
2311  pcCU->setARPWSubParts( ( UChar )( uiW ) , uiAbsPartIdx, uiDepth ); 
2312}
2313#endif
2314
2315#if H_3D_IC
2316/** parse illumination compensation flag
2317 * \param pcCU
2318 * \param uiAbsPartIdx
2319 * \param uiDepth
2320 * \returns Void
2321 */
2322Void TDecSbac::parseICFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
2323{ 
2324  UInt uiSymbol = 0;
2325  m_pcTDecBinIf->decodeBin( uiSymbol, m_cCUICFlagSCModel.get( 0, 0, 0 ) );
2326#if !H_MV_ENC_DEC_TRAC
2327  DTRACE_CABAC_VL( g_nSymbolCounter++ );
2328  DTRACE_CABAC_T( "\tICFlag" );
2329  DTRACE_CABAC_T( "\tuiCtxIC: ");
2330  DTRACE_CABAC_V( uiCtxIC );
2331  DTRACE_CABAC_T( "\tuiSymbol: ");
2332  DTRACE_CABAC_V( uiSymbol );
2333  DTRACE_CABAC_T( "\n");
2334#else
2335  DTRACE_CU("ic_flag", uiSymbol)
2336#endif
2337 
2338  pcCU->setICFlagSubParts( uiSymbol ? true : false , uiAbsPartIdx, 0, uiDepth );
2339}
2340#endif
2341
2342#if NH_3D_DMM || H_3D_DIM_SDC || H_3D_INTER_SDC
2343Void TDecSbac::parseDeltaDC( TComDataCU* pcCU, UInt absPartIdx, UInt depth )
2344{
2345#if H_3D_DIM_SDC || H_3D_INTER_SDC
2346  if( !(pcCU->getSDCFlag( absPartIdx )) )
2347#endif
2348#if NH_3D_DMM
2349  if( !(pcCU->isIntra( absPartIdx ) && isDmmMode( pcCU->getIntraDir( CHANNEL_TYPE_LUMA, absPartIdx ) )) )
2350#endif
2351    assert( 0 );
2352
2353  UInt symbol = 1;
2354#if H_3D_DIM_SDC
2355  if( pcCU->isIntra( absPartIdx ) && pcCU->getSDCFlag( absPartIdx ))
2356  {
2357    m_pcTDecBinIf->decodeBin( symbol, m_cDdcFlagSCModel.get( 0, 0, 0 ) );
2358      assert( pcCU->getPartitionSize( absPartIdx ) == SIZE_2Nx2N );
2359      pcCU->setTrIdxSubParts( 0, absPartIdx, depth );
2360      pcCU->setCbfSubParts( 1, 1, 1, absPartIdx, depth );
2361    }
2362#endif
2363  UInt uiNumSegments = 1;
2364#if NH_3D_DMM
2365  uiNumSegments = isDmmMode( pcCU->getIntraDir( CHANNEL_TYPE_LUMA, absPartIdx ) ) ? 2 : 1;
2366#endif
2367
2368  for( UInt segment = 0; segment < uiNumSegments; segment++ )
2369  {
2370    Pel valDeltaDC = 0;
2371    if( symbol )
2372    {
2373      xParseDeltaDC( valDeltaDC, uiNumSegments );
2374    }
2375
2376    if( pcCU->isIntra( absPartIdx ) )
2377    {
2378#if H_3D_DIM_SDC
2379      if( pcCU->getSDCFlag( absPartIdx ) )
2380      {
2381        pcCU->setSDCSegmentDCOffset( valDeltaDC, segment, absPartIdx );
2382      }
2383      else
2384      {
2385#endif
2386#if NH_3D_DMM
2387        pcCU->setDmmDeltaDC( getDmmType( pcCU->getIntraDir( CHANNEL_TYPE_LUMA, absPartIdx ) ), segment, absPartIdx, valDeltaDC );
2388#endif
2389#if H_3D_DIM_SDC
2390      }
2391#endif
2392    }
2393#if H_3D_INTER_SDC
2394    else
2395    {
2396      pcCU->setSDCSegmentDCOffset( valDeltaDC, segment, absPartIdx );
2397    }
2398#endif
2399  }
2400}
2401
2402Void TDecSbac::xParseDeltaDC( Pel& rValDeltaDC, UInt uiNumSeg )
2403{
2404  UInt absValDeltaDC = 0;
2405  xReadExGolombLevelDdc( absValDeltaDC );
2406  rValDeltaDC = (Pel)absValDeltaDC + ( uiNumSeg > 1 ? 0 : 1 );
2407
2408  if( rValDeltaDC != 0 )
2409  {
2410    UInt uiSign;
2411    m_pcTDecBinIf->decodeBinEP( uiSign RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__DELTADC_SIGN_EP) );
2412    if ( uiSign )
2413    {
2414      rValDeltaDC = -rValDeltaDC;
2415    }
2416  }
2417}
2418
2419Void TDecSbac::xReadExGolombLevelDdc( UInt& ruiSymbol )
2420{
2421  UInt uiSymbol;
2422  UInt uiCount = 0;
2423  do
2424  {
2425    m_pcTDecBinIf->decodeBin( uiSymbol, m_cDdcDataSCModel.get(0, 0, 0) RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__DELTADC_PREFIX) );
2426    uiCount++;
2427  }
2428  while( uiSymbol && ( uiCount != 3 ) );
2429  ruiSymbol = uiCount - 1;
2430
2431  if( uiSymbol )
2432  {
2433    xReadEpExGolomb( uiSymbol, 0 RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__DELTADC_SUFFIX_EP) );
2434    ruiSymbol += uiSymbol + 1;
2435  }
2436
2437  return;
2438}
2439#endif
2440#if NH_3D_DMM
2441Void TDecSbac::xParseIntraDepthMode( TComDataCU* pcCU, UInt absPartIdx, UInt depth )
2442{
2443  pcCU->setIntraDirSubParts( CHANNEL_TYPE_LUMA, 0, absPartIdx, depth );
2444
2445  UInt uiSymbol;
2446  if( ( pcCU->getSlice()->getSPS()->getMaxCUWidth() >> pcCU->getDepth( absPartIdx ) ) < 64 ) //DMM and HEVC intra modes are both allowed
2447  {
2448    m_pcTDecBinIf->decodeBin( uiSymbol, m_cNotDmmFlagSCModel.get( 0, 0, 0 ) RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__NOTDMM_FLAG) );
2449  }
2450  else
2451  {
2452    uiSymbol = 1;
2453  }
2454
2455  //decode DMM mode index
2456  if( !uiSymbol )
2457  {
2458    if( pcCU->getSlice()->getIntraSdcWedgeFlag() && pcCU->getSlice()->getIntraContourFlag() )
2459    {
2460      m_pcTDecBinIf->decodeBin( uiSymbol, m_cDmmModeSCModel.get( 0, 0, 0 ) RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__DMMMODE) );
2461      if( !uiSymbol )
2462      {
2463        pcCU->setIntraDirSubParts( CHANNEL_TYPE_LUMA, DMM_OFFSET, absPartIdx, depth );
2464      }
2465      else
2466      {
2467        pcCU->setIntraDirSubParts( CHANNEL_TYPE_LUMA, ( 1+ DMM_OFFSET ), absPartIdx, depth );
2468      }
2469    }
2470    else if( pcCU->getSlice()->getIntraSdcWedgeFlag() )
2471    {
2472      pcCU->setIntraDirSubParts( CHANNEL_TYPE_LUMA, DMM_OFFSET, absPartIdx, depth );
2473    }
2474    else if( pcCU->getSlice()->getIntraContourFlag() )
2475    {
2476      pcCU->setIntraDirSubParts( CHANNEL_TYPE_LUMA, ( 1+ DMM_OFFSET ), absPartIdx, depth );
2477    }
2478  }
2479}
2480
2481Void TDecSbac::xParseDmmData( TComDataCU* pcCU, UInt absPartIdx, UInt depth )
2482{
2483  UInt dir = pcCU->getIntraDir( CHANNEL_TYPE_LUMA, absPartIdx );
2484  switch( getDmmType( dir ) )
2485  {
2486  case( DMM1_IDX ):
2487    {
2488      UInt uiTabIdx = 0;
2489      xParseDmm1WedgeIdx( uiTabIdx, g_dmm1TabIdxBits[pcCU->getIntraSizeIdx(absPartIdx)] );
2490      assert( uiTabIdx < getWedgeListScaled( pcCU->getWidth( absPartIdx ) )->size() );
2491      pcCU->setDmm1WedgeTabIdxSubParts( uiTabIdx, absPartIdx, depth );
2492    } break;
2493  case( DMM4_IDX ): break;
2494  default: break;
2495  }
2496}
2497
2498Void TDecSbac::xParseDmm1WedgeIdx( UInt& ruiTabIdx, Int iNumBit )
2499{
2500  UInt uiSymbol, uiIdx = 0;
2501  for( Int i = 0; i < iNumBit; i++ )
2502  {
2503    m_pcTDecBinIf->decodeBinEP( uiSymbol RExt__DECODER_DEBUG_BIT_STATISTICS_PASS_OPT_ARG(STATS__CABAC_BITS__DMM1_BITS_EP) );
2504    uiIdx += uiSymbol << i;
2505  }
2506  ruiTabIdx = uiIdx;
2507}
2508#endif
2509#if H_3D_INTER_SDC
2510Void TDecSbac::parseSDCFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
2511{
2512  UInt uiSymbol = 0;
2513  UInt uiCtxSDCFlag = pcCU->getCtxSDCFlag( uiAbsPartIdx );
2514
2515  m_pcTDecBinIf->decodeBin( uiSymbol, m_cSDCFlagSCModel.get( 0, 0, uiCtxSDCFlag ) );
2516  DTRACE_CU("dc_only_flag", uiSymbol)
2517  if( uiSymbol )
2518  {
2519    pcCU->setSDCFlagSubParts( true, uiAbsPartIdx, uiDepth );
2520    pcCU->setTrIdxSubParts( 0, uiAbsPartIdx, uiDepth );
2521    pcCU->setCbfSubParts( 1, 1, 1, uiAbsPartIdx, uiDepth );
2522  }
2523  else
2524  {
2525    pcCU->setSDCFlagSubParts( false, uiAbsPartIdx, uiDepth );
2526  }
2527}
2528
2529#endif
2530
2531#if H_3D_DBBP
2532Void TDecSbac::parseDBBPFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
2533{
2534  AOF( pcCU->getSlice()->getDepthBasedBlkPartFlag() );
2535  AOF( !pcCU->getSlice()->getIsDepth() );
2536 
2537  UInt uiSymbol = 0;
2538 
2539  m_pcTDecBinIf->decodeBin( uiSymbol, m_cDBBPFlagSCModel.get( 0, 0, 0 ) );
2540  DTRACE_CU("dbbp_flag", uiSymbol)
2541  PartSize ePartSize = pcCU->getPartitionSize( uiAbsPartIdx );
2542  AOF( ePartSize == SIZE_2NxN || ePartSize == SIZE_Nx2N );
2543  UInt uiPUOffset = ( g_auiPUOffset[UInt( ePartSize )] << ( ( pcCU->getSlice()->getSPS()->getMaxCUDepth() - uiDepth ) << 1 ) ) >> 4;
2544  pcCU->setDBBPFlagSubParts(uiSymbol, uiAbsPartIdx, 0, uiDepth);
2545  pcCU->setDBBPFlagSubParts(uiSymbol, uiAbsPartIdx+uiPUOffset, 1, uiDepth);
2546}
2547#endif
2548
2549
2550//! \}
Note: See TracBrowser for help on using the repository browser.