source: 3DVCSoftware/branches/HTM-14.1-update-dev0/source/Lib/TLibDecoder/TDecSbac.cpp @ 1200

Last change on this file since 1200 was 1200, checked in by tech, 9 years ago

Update to HM-16.5.
Starting point for further re-activation of 3D-tools.

Includes:

active:

  • MV-HEVC
  • 3D-HLS (apart from DLT)
  • VSO

inactive:

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