source: 3DVCSoftware/branches/HTM-8.2-dev3-Qualcomm/source/Lib/TLibDecoder/TDecSbac.cpp

Last change on this file was 667, checked in by zhang, 11 years ago

JCT3V-F0132; JCT3V-F0171
  • Property svn:eol-style set to native
File size: 71.1 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-2013, 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
40//! \ingroup TLibDecoder
41//! \{
42
43//////////////////////////////////////////////////////////////////////
44// Construction/Destruction
45//////////////////////////////////////////////////////////////////////
46
47TDecSbac::TDecSbac() 
48// new structure here
49: m_pcBitstream               ( 0 )
50, m_pcTDecBinIf               ( NULL )
51, m_numContextModels          ( 0 )
52, m_cCUSplitFlagSCModel       ( 1,             1,               NUM_SPLIT_FLAG_CTX            , m_contextModels + m_numContextModels, m_numContextModels )
53, m_cCUSkipFlagSCModel        ( 1,             1,               NUM_SKIP_FLAG_CTX             , m_contextModels + m_numContextModels, m_numContextModels)
54, m_cCUMergeFlagExtSCModel    ( 1,             1,               NUM_MERGE_FLAG_EXT_CTX        , m_contextModels + m_numContextModels, m_numContextModels)
55, m_cCUMergeIdxExtSCModel     ( 1,             1,               NUM_MERGE_IDX_EXT_CTX         , m_contextModels + m_numContextModels, m_numContextModels)
56#if H_3D_ARP
57, m_cCUPUARPWSCModel          ( 1,             1,               NUM_ARPW_CTX                  , m_contextModels + m_numContextModels, m_numContextModels)
58#endif
59#if H_3D_IC
60, m_cCUICFlagSCModel          ( 1,             1,               NUM_IC_FLAG_CTX               , m_contextModels + m_numContextModels, m_numContextModels)
61#endif
62, m_cCUPartSizeSCModel        ( 1,             1,               NUM_PART_SIZE_CTX             , m_contextModels + m_numContextModels, m_numContextModels)
63, m_cCUPredModeSCModel        ( 1,             1,               NUM_PRED_MODE_CTX             , m_contextModels + m_numContextModels, m_numContextModels)
64, m_cCUIntraPredSCModel       ( 1,             1,               NUM_ADI_CTX                   , m_contextModels + m_numContextModels, m_numContextModels)
65, m_cCUChromaPredSCModel      ( 1,             1,               NUM_CHROMA_PRED_CTX           , m_contextModels + m_numContextModels, m_numContextModels)
66, m_cCUDeltaQpSCModel         ( 1,             1,               NUM_DELTA_QP_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
67, m_cCUInterDirSCModel        ( 1,             1,               NUM_INTER_DIR_CTX             , m_contextModels + m_numContextModels, m_numContextModels)
68, m_cCURefPicSCModel          ( 1,             1,               NUM_REF_NO_CTX                , m_contextModels + m_numContextModels, m_numContextModels)
69, m_cCUMvdSCModel             ( 1,             1,               NUM_MV_RES_CTX                , m_contextModels + m_numContextModels, m_numContextModels)
70, m_cCUQtCbfSCModel           ( 1,             2,               NUM_QT_CBF_CTX                , m_contextModels + m_numContextModels, m_numContextModels)
71, m_cCUTransSubdivFlagSCModel ( 1,             1,               NUM_TRANS_SUBDIV_FLAG_CTX     , m_contextModels + m_numContextModels, m_numContextModels)
72, m_cCUQtRootCbfSCModel       ( 1,             1,               NUM_QT_ROOT_CBF_CTX           , m_contextModels + m_numContextModels, m_numContextModels)
73, m_cCUSigCoeffGroupSCModel   ( 1,             2,               NUM_SIG_CG_FLAG_CTX           , m_contextModels + m_numContextModels, m_numContextModels)
74, m_cCUSigSCModel             ( 1,             1,               NUM_SIG_FLAG_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
75, m_cCuCtxLastX               ( 1,             2,               NUM_CTX_LAST_FLAG_XY          , m_contextModels + m_numContextModels, m_numContextModels)
76, m_cCuCtxLastY               ( 1,             2,               NUM_CTX_LAST_FLAG_XY          , m_contextModels + m_numContextModels, m_numContextModels)
77, m_cCUOneSCModel             ( 1,             1,               NUM_ONE_FLAG_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
78, m_cCUAbsSCModel             ( 1,             1,               NUM_ABS_FLAG_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
79, m_cMVPIdxSCModel            ( 1,             1,               NUM_MVP_IDX_CTX               , m_contextModels + m_numContextModels, m_numContextModels)
80, m_cCUAMPSCModel             ( 1,             1,               NUM_CU_AMP_CTX                , m_contextModels + m_numContextModels, m_numContextModels)
81, m_cSaoMergeSCModel      ( 1,             1,               NUM_SAO_MERGE_FLAG_CTX   , m_contextModels + m_numContextModels, m_numContextModels)
82, m_cSaoTypeIdxSCModel        ( 1,             1,               NUM_SAO_TYPE_IDX_CTX          , m_contextModels + m_numContextModels, m_numContextModels)
83, m_cTransformSkipSCModel     ( 1,             2,               NUM_TRANSFORMSKIP_FLAG_CTX    , m_contextModels + m_numContextModels, m_numContextModels)
84, m_CUTransquantBypassFlagSCModel( 1,          1,               NUM_CU_TRANSQUANT_BYPASS_FLAG_CTX, m_contextModels + m_numContextModels, m_numContextModels)
85#if H_3D_DIM
86, m_cDepthIntraModeSCModel    ( 1,             1,               NUM_DEPTH_INTRA_MODE_CTX      , m_contextModels + m_numContextModels, m_numContextModels)
87, m_cDdcFlagSCModel           ( 1,             1,               NUM_DDC_FLAG_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
88, m_cDdcDataSCModel           ( 1,             1,               NUM_DDC_DATA_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
89#if H_3D_DIM_DMM
90, m_cDmm1DataSCModel          ( 1,             1,               NUM_DMM1_DATA_CTX             , m_contextModels + m_numContextModels, m_numContextModels)
91, m_cDmm3DataSCModel          ( 1,             1,               NUM_DMM3_DATA_CTX             , m_contextModels + m_numContextModels, m_numContextModels)
92#endif
93#if H_3D_DIM_RBC
94, m_cRbcDataSCModel           ( 1,             1,               NUM_RBC_DATA_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
95#endif
96#if H_3D_DIM_SDC
97, m_cSDCResidualFlagSCModel     ( 1,             1,             SDC_NUM_RESIDUAL_FLAG_CTX     , m_contextModels + m_numContextModels, m_numContextModels)
98, m_cSDCResidualSCModel         ( 1,             1,             SDC_NUM_RESIDUAL_CTX          , m_contextModels + m_numContextModels, m_numContextModels)
99#endif
100#endif
101#if H_3D_INTER_SDC
102, m_cInterSDCFlagSCModel             ( 1,             1,  NUM_INTER_SDC_FLAG_CTX           , m_contextModels + m_numContextModels, m_numContextModels)
103, m_cInterSDCResidualSCModel         ( 1,             1,  NUM_INTER_SDC_RESIDUAL_CTX       , m_contextModels + m_numContextModels, m_numContextModels)
104, m_cInterSDCResidualSignFlagSCModel ( 1,             1,  NUM_INTER_SDC_SIGN_FLAG_CTX      , m_contextModels + m_numContextModels, m_numContextModels)
105#endif
106{
107  assert( m_numContextModels <= MAX_NUM_CTX_MOD );
108}
109
110TDecSbac::~TDecSbac()
111{
112}
113
114// ====================================================================================================================
115// Public member functions
116// ====================================================================================================================
117
118Void TDecSbac::resetEntropy(TComSlice* pSlice)
119{
120  SliceType sliceType  = pSlice->getSliceType();
121  Int       qp         = pSlice->getSliceQp();
122
123  if (pSlice->getPPS()->getCabacInitPresentFlag() && pSlice->getCabacInitFlag())
124  {
125    switch (sliceType)
126    {
127    case P_SLICE:           // change initialization table to B_SLICE initialization
128      sliceType = B_SLICE; 
129      break;
130    case B_SLICE:           // change initialization table to P_SLICE initialization
131      sliceType = P_SLICE; 
132      break;
133    default     :           // should not occur
134      assert(0);
135    }
136  }
137
138  m_cCUSplitFlagSCModel.initBuffer       ( sliceType, qp, (UChar*)INIT_SPLIT_FLAG );
139  m_cCUSkipFlagSCModel.initBuffer        ( sliceType, qp, (UChar*)INIT_SKIP_FLAG );
140  m_cCUMergeFlagExtSCModel.initBuffer    ( sliceType, qp, (UChar*)INIT_MERGE_FLAG_EXT );
141  m_cCUMergeIdxExtSCModel.initBuffer     ( sliceType, qp, (UChar*)INIT_MERGE_IDX_EXT );
142#if H_3D_ARP
143  m_cCUPUARPWSCModel.initBuffer          ( sliceType, qp, (UChar*)INIT_ARPW );
144#endif
145#if H_3D_IC
146  m_cCUICFlagSCModel.initBuffer          ( sliceType, qp, (UChar*)INIT_IC_FLAG );
147#endif
148  m_cCUPartSizeSCModel.initBuffer        ( sliceType, qp, (UChar*)INIT_PART_SIZE );
149  m_cCUAMPSCModel.initBuffer             ( sliceType, qp, (UChar*)INIT_CU_AMP_POS );
150  m_cCUPredModeSCModel.initBuffer        ( sliceType, qp, (UChar*)INIT_PRED_MODE );
151  m_cCUIntraPredSCModel.initBuffer       ( sliceType, qp, (UChar*)INIT_INTRA_PRED_MODE );
152  m_cCUChromaPredSCModel.initBuffer      ( sliceType, qp, (UChar*)INIT_CHROMA_PRED_MODE );
153  m_cCUInterDirSCModel.initBuffer        ( sliceType, qp, (UChar*)INIT_INTER_DIR );
154  m_cCUMvdSCModel.initBuffer             ( sliceType, qp, (UChar*)INIT_MVD );
155  m_cCURefPicSCModel.initBuffer          ( sliceType, qp, (UChar*)INIT_REF_PIC );
156  m_cCUDeltaQpSCModel.initBuffer         ( sliceType, qp, (UChar*)INIT_DQP );
157  m_cCUQtCbfSCModel.initBuffer           ( sliceType, qp, (UChar*)INIT_QT_CBF );
158  m_cCUQtRootCbfSCModel.initBuffer       ( sliceType, qp, (UChar*)INIT_QT_ROOT_CBF );
159  m_cCUSigCoeffGroupSCModel.initBuffer   ( sliceType, qp, (UChar*)INIT_SIG_CG_FLAG );
160  m_cCUSigSCModel.initBuffer             ( sliceType, qp, (UChar*)INIT_SIG_FLAG );
161  m_cCuCtxLastX.initBuffer               ( sliceType, qp, (UChar*)INIT_LAST );
162  m_cCuCtxLastY.initBuffer               ( sliceType, qp, (UChar*)INIT_LAST );
163  m_cCUOneSCModel.initBuffer             ( sliceType, qp, (UChar*)INIT_ONE_FLAG );
164  m_cCUAbsSCModel.initBuffer             ( sliceType, qp, (UChar*)INIT_ABS_FLAG );
165  m_cMVPIdxSCModel.initBuffer            ( sliceType, qp, (UChar*)INIT_MVP_IDX );
166  m_cSaoMergeSCModel.initBuffer      ( sliceType, qp, (UChar*)INIT_SAO_MERGE_FLAG );
167  m_cSaoTypeIdxSCModel.initBuffer        ( sliceType, qp, (UChar*)INIT_SAO_TYPE_IDX );
168
169  m_cCUTransSubdivFlagSCModel.initBuffer ( sliceType, qp, (UChar*)INIT_TRANS_SUBDIV_FLAG );
170  m_cTransformSkipSCModel.initBuffer     ( sliceType, qp, (UChar*)INIT_TRANSFORMSKIP_FLAG );
171  m_CUTransquantBypassFlagSCModel.initBuffer( sliceType, qp, (UChar*)INIT_CU_TRANSQUANT_BYPASS_FLAG );
172#if H_3D_DIM
173  m_cDepthIntraModeSCModel.initBuffer    ( sliceType, qp, (UChar*)INIT_DEPTH_INTRA_MODE );
174  m_cDdcFlagSCModel.initBuffer           ( sliceType, qp, (UChar*)INIT_DDC_FLAG );
175  m_cDdcDataSCModel.initBuffer           ( sliceType, qp, (UChar*)INIT_DDC_DATA );
176#if H_3D_DIM_DMM
177  m_cDmm1DataSCModel.initBuffer          ( sliceType, qp, (UChar*)INIT_DMM1_DATA );
178  m_cDmm3DataSCModel.initBuffer          ( sliceType, qp, (UChar*)INIT_DMM3_DATA );
179#endif
180#if H_3D_DIM_RBC
181  m_cRbcDataSCModel.initBuffer           ( sliceType, qp, (UChar*)INIT_RBC_DATA );
182#endif
183#if H_3D_DIM_SDC
184  m_cSDCResidualFlagSCModel.initBuffer    ( sliceType, qp, (UChar*)INIT_SDC_RESIDUAL_FLAG );
185  m_cSDCResidualSCModel.initBuffer        ( sliceType, qp, (UChar*)INIT_SDC_RESIDUAL );
186#endif
187#endif
188#if H_3D_INTER_SDC
189  m_cInterSDCFlagSCModel.initBuffer       ( sliceType, qp, (UChar*)INIT_INTER_SDC_FLAG );
190  m_cInterSDCResidualSCModel.initBuffer   ( sliceType, qp, (UChar*)INIT_INTER_SDC_RESIDUAL );
191  m_cInterSDCResidualSignFlagSCModel.initBuffer ( sliceType, qp, (UChar*)INIT_INTER_SDC_SIGN_FLAG );
192#endif
193  m_uiLastDQpNonZero  = 0;
194 
195  // new structure
196  m_uiLastQp          = qp;
197 
198  m_pcTDecBinIf->start();
199}
200
201/** The function does the following: Read out terminate bit. Flush CABAC. Byte-align for next tile.
202 *  Intialize CABAC states. Start CABAC.
203 */
204Void TDecSbac::updateContextTables( SliceType eSliceType, Int iQp )
205{
206  UInt uiBit;
207  m_pcTDecBinIf->decodeBinTrm(uiBit);
208  assert(uiBit); // end_of_sub_stream_one_bit must be equal to 1
209  m_pcTDecBinIf->finish(); 
210  m_pcBitstream->readOutTrailingBits();
211  m_cCUSplitFlagSCModel.initBuffer       ( eSliceType, iQp, (UChar*)INIT_SPLIT_FLAG );
212  m_cCUSkipFlagSCModel.initBuffer        ( eSliceType, iQp, (UChar*)INIT_SKIP_FLAG );
213  m_cCUMergeFlagExtSCModel.initBuffer    ( eSliceType, iQp, (UChar*)INIT_MERGE_FLAG_EXT );
214  m_cCUMergeIdxExtSCModel.initBuffer     ( eSliceType, iQp, (UChar*)INIT_MERGE_IDX_EXT );
215#if H_3D_ARP
216  m_cCUPUARPWSCModel.initBuffer          ( eSliceType, iQp, (UChar*)INIT_ARPW );
217#endif
218#if H_3D_IC
219  m_cCUICFlagSCModel.initBuffer          ( eSliceType, iQp, (UChar*)INIT_IC_FLAG );
220#endif
221  m_cCUPartSizeSCModel.initBuffer        ( eSliceType, iQp, (UChar*)INIT_PART_SIZE );
222  m_cCUAMPSCModel.initBuffer             ( eSliceType, iQp, (UChar*)INIT_CU_AMP_POS );
223  m_cCUPredModeSCModel.initBuffer        ( eSliceType, iQp, (UChar*)INIT_PRED_MODE );
224  m_cCUIntraPredSCModel.initBuffer       ( eSliceType, iQp, (UChar*)INIT_INTRA_PRED_MODE );
225  m_cCUChromaPredSCModel.initBuffer      ( eSliceType, iQp, (UChar*)INIT_CHROMA_PRED_MODE );
226  m_cCUInterDirSCModel.initBuffer        ( eSliceType, iQp, (UChar*)INIT_INTER_DIR );
227  m_cCUMvdSCModel.initBuffer             ( eSliceType, iQp, (UChar*)INIT_MVD );
228  m_cCURefPicSCModel.initBuffer          ( eSliceType, iQp, (UChar*)INIT_REF_PIC );
229  m_cCUDeltaQpSCModel.initBuffer         ( eSliceType, iQp, (UChar*)INIT_DQP );
230  m_cCUQtCbfSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_QT_CBF );
231  m_cCUQtRootCbfSCModel.initBuffer       ( eSliceType, iQp, (UChar*)INIT_QT_ROOT_CBF );
232  m_cCUSigCoeffGroupSCModel.initBuffer   ( eSliceType, iQp, (UChar*)INIT_SIG_CG_FLAG );
233  m_cCUSigSCModel.initBuffer             ( eSliceType, iQp, (UChar*)INIT_SIG_FLAG );
234  m_cCuCtxLastX.initBuffer               ( eSliceType, iQp, (UChar*)INIT_LAST );
235  m_cCuCtxLastY.initBuffer               ( eSliceType, iQp, (UChar*)INIT_LAST );
236  m_cCUOneSCModel.initBuffer             ( eSliceType, iQp, (UChar*)INIT_ONE_FLAG );
237  m_cCUAbsSCModel.initBuffer             ( eSliceType, iQp, (UChar*)INIT_ABS_FLAG );
238  m_cMVPIdxSCModel.initBuffer            ( eSliceType, iQp, (UChar*)INIT_MVP_IDX );
239  m_cSaoMergeSCModel.initBuffer      ( eSliceType, iQp, (UChar*)INIT_SAO_MERGE_FLAG );
240  m_cSaoTypeIdxSCModel.initBuffer        ( eSliceType, iQp, (UChar*)INIT_SAO_TYPE_IDX );
241  m_cCUTransSubdivFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_TRANS_SUBDIV_FLAG );
242  m_cTransformSkipSCModel.initBuffer     ( eSliceType, iQp, (UChar*)INIT_TRANSFORMSKIP_FLAG );
243  m_CUTransquantBypassFlagSCModel.initBuffer( eSliceType, iQp, (UChar*)INIT_CU_TRANSQUANT_BYPASS_FLAG );
244
245#if H_3D_DIM
246  m_cDepthIntraModeSCModel.initBuffer    ( eSliceType, iQp, (UChar*)INIT_DEPTH_INTRA_MODE );
247  m_cDdcFlagSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_DDC_FLAG );
248  m_cDdcDataSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_DDC_DATA );
249#if H_3D_DIM_DMM
250  m_cDmm1DataSCModel.initBuffer          ( eSliceType, iQp, (UChar*)INIT_DMM1_DATA );
251  m_cDmm3DataSCModel.initBuffer          ( eSliceType, iQp, (UChar*)INIT_DMM3_DATA );
252#endif
253#if H_3D_DIM_RBC
254  m_cRbcDataSCModel.initBuffer           ( eSliceType, iQp, (UChar*)INIT_RBC_DATA );
255#endif
256#if H_3D_DIM_SDC
257  m_cSDCResidualFlagSCModel.initBuffer    ( eSliceType, iQp, (UChar*)INIT_SDC_RESIDUAL_FLAG );
258  m_cSDCResidualSCModel.initBuffer        ( eSliceType, iQp, (UChar*)INIT_SDC_RESIDUAL );
259#endif
260#endif
261#if H_3D_INTER_SDC
262  m_cInterSDCFlagSCModel.initBuffer       ( eSliceType, iQp, (UChar*)INIT_INTER_SDC_FLAG );
263  m_cInterSDCResidualSCModel.initBuffer   ( eSliceType, iQp, (UChar*)INIT_INTER_SDC_RESIDUAL );
264  m_cInterSDCResidualSignFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_INTER_SDC_SIGN_FLAG );
265#endif
266  m_pcTDecBinIf->start();
267}
268
269Void TDecSbac::parseTerminatingBit( UInt& ruiBit )
270{
271  m_pcTDecBinIf->decodeBinTrm( ruiBit );
272  if ( ruiBit )
273  {
274    m_pcTDecBinIf->finish();
275  }
276}
277
278
279Void TDecSbac::xReadUnaryMaxSymbol( UInt& ruiSymbol, ContextModel* pcSCModel, Int iOffset, UInt uiMaxSymbol )
280{
281  if (uiMaxSymbol == 0)
282  {
283    ruiSymbol = 0;
284    return;
285  }
286 
287  m_pcTDecBinIf->decodeBin( ruiSymbol, pcSCModel[0] );
288 
289  if( ruiSymbol == 0 || uiMaxSymbol == 1 )
290  {
291    return;
292  }
293 
294  UInt uiSymbol = 0;
295  UInt uiCont;
296 
297  do
298  {
299    m_pcTDecBinIf->decodeBin( uiCont, pcSCModel[ iOffset ] );
300    uiSymbol++;
301  }
302  while( uiCont && ( uiSymbol < uiMaxSymbol - 1 ) );
303 
304  if( uiCont && ( uiSymbol == uiMaxSymbol - 1 ) )
305  {
306    uiSymbol++;
307  }
308 
309  ruiSymbol = uiSymbol;
310}
311
312Void TDecSbac::xReadEpExGolomb( UInt& ruiSymbol, UInt uiCount )
313{
314  UInt uiSymbol = 0;
315  UInt uiBit = 1;
316 
317  while( uiBit )
318  {
319    m_pcTDecBinIf->decodeBinEP( uiBit );
320    uiSymbol += uiBit << uiCount++;
321  }
322 
323  if ( --uiCount )
324  {
325    UInt bins;
326    m_pcTDecBinIf->decodeBinsEP( bins, uiCount );
327    uiSymbol += bins;
328  }
329 
330  ruiSymbol = uiSymbol;
331}
332
333Void TDecSbac::xReadUnarySymbol( UInt& ruiSymbol, ContextModel* pcSCModel, Int iOffset )
334{
335  m_pcTDecBinIf->decodeBin( ruiSymbol, pcSCModel[0] );
336 
337  if( !ruiSymbol )
338  {
339    return;
340  }
341 
342  UInt uiSymbol = 0;
343  UInt uiCont;
344 
345  do
346  {
347    m_pcTDecBinIf->decodeBin( uiCont, pcSCModel[ iOffset ] );
348    uiSymbol++;
349  }
350  while( uiCont );
351 
352  ruiSymbol = uiSymbol;
353}
354
355
356/** Parsing of coeff_abs_level_remaing
357 * \param ruiSymbol reference to coeff_abs_level_remaing
358 * \param ruiParam reference to parameter
359 * \returns Void
360 */
361Void TDecSbac::xReadCoefRemainExGolomb ( UInt &rSymbol, UInt &rParam )
362{
363
364  UInt prefix   = 0;
365  UInt codeWord = 0;
366  do
367  {
368    prefix++;
369    m_pcTDecBinIf->decodeBinEP( codeWord );
370  }
371  while( codeWord);
372  codeWord  = 1 - codeWord;
373  prefix -= codeWord;
374  codeWord=0;
375  if (prefix < COEF_REMAIN_BIN_REDUCTION )
376  {
377    m_pcTDecBinIf->decodeBinsEP(codeWord,rParam);
378    rSymbol = (prefix<<rParam) + codeWord;
379  }
380  else
381  {
382    m_pcTDecBinIf->decodeBinsEP(codeWord,prefix-COEF_REMAIN_BIN_REDUCTION+rParam);
383    rSymbol = (((1<<(prefix-COEF_REMAIN_BIN_REDUCTION))+COEF_REMAIN_BIN_REDUCTION-1)<<rParam)+codeWord;
384  }
385}
386
387#if H_3D_DIM
388Void TDecSbac::xReadExGolombLevel( UInt& ruiSymbol, ContextModel& rcSCModel  )
389{
390  UInt uiSymbol;
391  UInt uiCount = 0;
392  do
393  {
394    m_pcTDecBinIf->decodeBin( uiSymbol, rcSCModel );
395    uiCount++;
396  }
397  while( uiSymbol && ( uiCount != 13 ) );
398
399  ruiSymbol = uiCount - 1;
400
401  if( uiSymbol )
402  {
403    xReadEpExGolomb( uiSymbol, 0 );
404    ruiSymbol += uiSymbol + 1;
405  }
406
407  return;
408}
409
410#if QC_DIM_DELTADC_UNIFY_F0132
411Void TDecSbac::xParseDimDeltaDC( Pel& rValDeltaDC, UInt uiNumSeg )
412{
413  UInt absValDeltaDC = 0;
414  xReadExGolombLevel( absValDeltaDC, m_cDdcDataSCModel.get(0, 0, 0) );
415  rValDeltaDC = (Pel)absValDeltaDC + ( uiNumSeg > 1 ? 0 : 1 );
416
417  if( rValDeltaDC != 0 )
418  {
419    UInt uiSign;
420    m_pcTDecBinIf->decodeBinEP( uiSign );
421    if ( uiSign )
422    {
423      rValDeltaDC = -rValDeltaDC;
424    }
425  }
426}
427#else
428Void TDecSbac::xParseDimDeltaDC( Pel& rValDeltaDC, UInt dimType )
429{
430  UInt absValDeltaDC = 0;
431  xReadExGolombLevel( absValDeltaDC, m_cDdcDataSCModel.get(0, 0, (RBC_IDX == dimType) ? 1 : 0) );
432  rValDeltaDC = (Pel)absValDeltaDC;
433
434  if( rValDeltaDC != 0 )
435  {
436    UInt uiSign;
437    m_pcTDecBinIf->decodeBinEP( uiSign );
438    if ( uiSign )
439    {
440      rValDeltaDC = -rValDeltaDC;
441    }
442  }
443}
444#endif
445
446#if H_3D_DIM_DMM
447Void TDecSbac::xParseDmm1WedgeIdx( UInt& ruiTabIdx, Int iNumBit )
448{
449  UInt uiSymbol, uiIdx = 0;
450  for( Int i = 0; i < iNumBit; i++ )
451  {
452    m_pcTDecBinIf->decodeBin( uiSymbol, m_cDmm1DataSCModel.get(0, 0, 0) );
453    uiIdx += uiSymbol << i;
454  }
455  ruiTabIdx = uiIdx;
456}
457
458Void TDecSbac::xParseDmm3WedgeIdx( UInt& ruiIntraIdx, Int iNumBit )
459{
460  UInt uiSymbol, uiIdx = 0;
461  for( Int i = 0; i < iNumBit; i++ )
462  {
463    m_pcTDecBinIf->decodeBin( uiSymbol, m_cDmm3DataSCModel.get(0, 0, 0) );
464    uiIdx += uiSymbol << i;
465  }
466  ruiIntraIdx = uiIdx;
467}
468#endif
469#if H_3D_DIM_RBC
470Void TDecSbac::xParseRbcEdge( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
471{
472  UInt uiSymbol = 0;
473
474  // 1. Top(0) or Left(1)
475  UChar ucLeft;
476  m_pcTDecBinIf->decodeBinEP( uiSymbol );
477  ucLeft = uiSymbol;
478
479  // 2. Start position (lowest bit first)
480  UChar ucStart = 0;
481  for( UInt ui = 0; ui < 6 - uiDepth; ui++ )
482  {
483    m_pcTDecBinIf->decodeBinEP( uiSymbol );
484    ucStart |= (uiSymbol << ui);
485  }
486
487  // 3. Number of edges
488  UChar ucMax = 0;
489  for( UInt ui = 0; ui < 7 - uiDepth; ui++ )
490  {
491    m_pcTDecBinIf->decodeBinEP( uiSymbol );
492    ucMax |= (uiSymbol << ui);
493  }
494  ucMax++; // +1
495
496  // 4. Edges
497  UChar* pucSymbolList = (UChar*) xMalloc( UChar, 256 * RBC_MAX_EDGE_NUM_PER_4x4 );
498  for( Int iPtr = 0; iPtr < ucMax; iPtr++ )
499  {
500    UChar ucEdge = 0;
501    UInt  uiReorderEdge = 0;
502    for( UInt ui = 0; ui < 6; ui++ )
503    {
504      m_pcTDecBinIf->decodeBin( uiSymbol, m_cRbcDataSCModel.get( 0, 0, 0 ) );
505      ucEdge <<= 1;
506      ucEdge |= uiSymbol;
507      if( uiSymbol == 0 )
508        break;
509    }
510
511    switch( ucEdge )
512    {
513    case 0 :  // "0"       
514      uiReorderEdge = 0;
515      break;
516    case 2 :  // "10"
517      uiReorderEdge = 1;
518      break;
519    case 6 :  // "110"
520      uiReorderEdge = 2;
521      break;
522    case 14 : // "1110"
523      uiReorderEdge = 3;
524      break;
525    case 30 : // "11110"
526      uiReorderEdge = 4;
527      break;
528    case 62 : // "111110"
529      uiReorderEdge = 5;
530      break;
531    case 63 : // "111111"
532      uiReorderEdge = 6;
533      break;
534    default :
535      printf("parseIntraEdgeChain: error (unknown code %d)\n",ucEdge);
536      assert(false);
537      break;
538    }
539    pucSymbolList[iPtr] = uiReorderEdge;
540  }
541  /////////////////////
542  // Edge Reconstruction
543  Bool* pbRegion = pcCU->getEdgePartition( uiAbsPartIdx );
544  pcCU->reconPartition( uiAbsPartIdx, uiDepth, ucLeft == 1, ucStart, ucMax, pucSymbolList, pbRegion );
545  xFree( pucSymbolList );
546}
547#endif
548#if H_3D_DIM_SDC
549Void TDecSbac::xParseSDCResidualData ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, UInt uiSegment )
550{
551  assert( pcCU->getSlice()->getIsDepth() );
552  assert( pcCU->getPartitionSize(uiAbsPartIdx) == SIZE_2Nx2N );
553  assert( pcCU->getSDCFlag(uiAbsPartIdx) );
554  assert( uiSegment < 2 );
555 
556  UInt uiResidual = 0;
557  UInt uiBit      = 0;
558  UInt uiAbsIdx   = 0;
559  UInt uiSign     = 0;
560  Int  iIdx       = 0;
561 
562#if H_3D_DIM_DLT
563  UInt uiMaxResidualBits = pcCU->getSlice()->getVPS()->getBitsPerDepthValue( pcCU->getSlice()->getLayerIdInVps() );
564#else
565  UInt uiMaxResidualBits = g_bitDepthY;
566#endif
567  assert( uiMaxResidualBits <= g_bitDepthY );
568 
569  m_pcTDecBinIf->decodeBin(uiResidual, m_cSDCResidualFlagSCModel.get( 0, 0, 0 ) );
570 
571#if H_MV_ENC_DEC_TRAC
572  DTRACE_CU("sdc_residual_flag[i]", uiResidual)
573#endif
574 
575  if (uiResidual)
576  {
577    // decode residual sign bit
578    m_pcTDecBinIf->decodeBinEP(uiSign);
579#if H_MV_ENC_DEC_TRAC
580    DTRACE_CU("sdc_residual_sign_flag[i]", uiSign)
581#endif
582   
583    // decode residual magnitude
584    // prefix part
585    UInt uiCount = 0;
586#if H_3D_DIM_DLT
587    UInt uiNumDepthValues = pcCU->getSlice()->getVPS()->getNumDepthValues( pcCU->getSlice()->getLayerIdInVps() );
588#else
589    UInt uiNumDepthValues = ((1 << g_bitDepthY)-1);
590#endif
591    UInt uiPrefixThreshold = ((uiNumDepthValues * 3) >> 2);
592    for ( UInt ui = 0; ui < uiPrefixThreshold; ui++)
593    {
594      m_pcTDecBinIf->decodeBin( uiBit, m_cSDCResidualSCModel.get(0, 0, 0) );
595      if ( uiBit == 0 )
596        break;
597      else
598        uiCount++;
599    }
600    // suffix part
601    if ( uiCount == uiPrefixThreshold )
602    {
603      for ( UInt ui = 0; ui < numBitsForValue(uiNumDepthValues - uiPrefixThreshold); ui++ )
604      {
605        m_pcTDecBinIf->decodeBinEP( uiBit );
606        uiAbsIdx |= uiBit << ui;
607      }
608      uiAbsIdx += uiCount;
609    }
610    else
611    {
612      uiAbsIdx = uiCount;
613    }
614 
615#if H_MV_ENC_DEC_TRAC
616    DTRACE_CU("sdc_residual_abs_minus1[i]", uiAbsIdx)
617#endif
618   
619    uiAbsIdx += 1;
620    iIdx =(Int)(uiSign ? -1 : 1)*uiAbsIdx;
621  }
622 
623  pcCU->setSDCSegmentDCOffset(iIdx, uiSegment, uiAbsPartIdx);
624}
625#endif
626#endif
627
628/** Parse I_PCM information.
629 * \param pcCU
630 * \param uiAbsPartIdx
631 * \param uiDepth
632 * \returns Void
633 *
634 * If I_PCM flag indicates that the CU is I_PCM, parse its PCM alignment bits and codes.
635 */
636Void TDecSbac::parseIPCMInfo ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
637{
638  UInt uiSymbol;
639
640    m_pcTDecBinIf->decodeBinTrm(uiSymbol);
641
642#if H_MV_ENC_DEC_TRAC
643      DTRACE_CU("pcm_flag", uiSymbol)
644#endif
645    if (uiSymbol)
646    {
647    Bool bIpcmFlag = true;
648
649    pcCU->setPartSizeSubParts  ( SIZE_2Nx2N, uiAbsPartIdx, uiDepth );
650    pcCU->setSizeSubParts      ( g_uiMaxCUWidth>>uiDepth, g_uiMaxCUHeight>>uiDepth, uiAbsPartIdx, uiDepth );
651    pcCU->setTrIdxSubParts     ( 0, uiAbsPartIdx, uiDepth );
652    pcCU->setIPCMFlagSubParts  ( bIpcmFlag, uiAbsPartIdx, uiDepth );
653
654    UInt uiMinCoeffSize = pcCU->getPic()->getMinCUWidth()*pcCU->getPic()->getMinCUHeight();
655    UInt uiLumaOffset   = uiMinCoeffSize*uiAbsPartIdx;
656    UInt uiChromaOffset = uiLumaOffset>>2;
657
658    Pel* piPCMSample;
659    UInt uiWidth;
660    UInt uiHeight;
661    UInt uiSampleBits;
662    UInt uiX, uiY;
663
664    piPCMSample = pcCU->getPCMSampleY() + uiLumaOffset;
665    uiWidth = pcCU->getWidth(uiAbsPartIdx);
666    uiHeight = pcCU->getHeight(uiAbsPartIdx);
667    uiSampleBits = pcCU->getSlice()->getSPS()->getPCMBitDepthLuma();
668
669    for(uiY = 0; uiY < uiHeight; uiY++)
670    {
671      for(uiX = 0; uiX < uiWidth; uiX++)
672      {
673        UInt uiSample;
674        m_pcTDecBinIf->xReadPCMCode(uiSampleBits, uiSample);
675        piPCMSample[uiX] = uiSample;
676      }
677      piPCMSample += uiWidth;
678    }
679
680    piPCMSample = pcCU->getPCMSampleCb() + uiChromaOffset;
681    uiWidth = pcCU->getWidth(uiAbsPartIdx)/2;
682    uiHeight = pcCU->getHeight(uiAbsPartIdx)/2;
683    uiSampleBits = pcCU->getSlice()->getSPS()->getPCMBitDepthChroma();
684
685    for(uiY = 0; uiY < uiHeight; uiY++)
686    {
687      for(uiX = 0; uiX < uiWidth; uiX++)
688      {
689        UInt uiSample;
690        m_pcTDecBinIf->xReadPCMCode(uiSampleBits, uiSample);
691        piPCMSample[uiX] = uiSample;
692      }
693      piPCMSample += uiWidth;
694    }
695
696    piPCMSample = pcCU->getPCMSampleCr() + uiChromaOffset;
697    uiWidth = pcCU->getWidth(uiAbsPartIdx)/2;
698    uiHeight = pcCU->getHeight(uiAbsPartIdx)/2;
699    uiSampleBits = pcCU->getSlice()->getSPS()->getPCMBitDepthChroma();
700
701    for(uiY = 0; uiY < uiHeight; uiY++)
702    {
703      for(uiX = 0; uiX < uiWidth; uiX++)
704      {
705        UInt uiSample;
706        m_pcTDecBinIf->xReadPCMCode(uiSampleBits, uiSample);
707        piPCMSample[uiX] = uiSample;
708      }
709      piPCMSample += uiWidth;
710    }
711
712    m_pcTDecBinIf->start();
713  }
714}
715
716Void TDecSbac::parseCUTransquantBypassFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
717{
718  UInt uiSymbol;
719  m_pcTDecBinIf->decodeBin( uiSymbol, m_CUTransquantBypassFlagSCModel.get( 0, 0, 0 ) );
720#if H_MV_ENC_DEC_TRAC
721  DTRACE_CU("cu_transquant_bypass_flag", uiSymbol); 
722#endif
723  pcCU->setCUTransquantBypassSubParts(uiSymbol ? true : false, uiAbsPartIdx, uiDepth);
724}
725
726/** parse skip flag
727 * \param pcCU
728 * \param uiAbsPartIdx
729 * \param uiDepth
730 * \returns Void
731 */
732Void TDecSbac::parseSkipFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
733{
734  if( pcCU->getSlice()->isIntra() )
735  {
736    return;
737  }
738 
739  UInt uiSymbol = 0;
740  UInt uiCtxSkip = pcCU->getCtxSkipFlag( uiAbsPartIdx );
741  m_pcTDecBinIf->decodeBin( uiSymbol, m_cCUSkipFlagSCModel.get( 0, 0, uiCtxSkip ) );
742#if !H_MV_ENC_DEC_TRAC
743  DTRACE_CABAC_VL( g_nSymbolCounter++ );
744  DTRACE_CABAC_T( "\tSkipFlag" );
745  DTRACE_CABAC_T( "\tuiCtxSkip: ");
746  DTRACE_CABAC_V( uiCtxSkip );
747  DTRACE_CABAC_T( "\tuiSymbol: ");
748  DTRACE_CABAC_V( uiSymbol );
749  DTRACE_CABAC_T( "\n");
750#endif
751 
752  if( uiSymbol )
753  {
754    pcCU->setSkipFlagSubParts( true,        uiAbsPartIdx, uiDepth );
755    pcCU->setPredModeSubParts( MODE_INTER,  uiAbsPartIdx, uiDepth );
756    pcCU->setPartSizeSubParts( SIZE_2Nx2N, uiAbsPartIdx, uiDepth );
757    pcCU->setSizeSubParts( g_uiMaxCUWidth>>uiDepth, g_uiMaxCUHeight>>uiDepth, uiAbsPartIdx, uiDepth );
758    pcCU->setMergeFlagSubParts( true , uiAbsPartIdx, 0, uiDepth );
759  }
760#if H_MV_ENC_DEC_TRAC
761  DTRACE_CU("cu_skip_flag", uiSymbol); 
762#endif
763}
764
765/** parse merge flag
766 * \param pcCU
767 * \param uiAbsPartIdx
768 * \param uiDepth
769 * \param uiPUIdx
770 * \returns Void
771 */
772Void TDecSbac::parseMergeFlag ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, UInt uiPUIdx )
773{
774  UInt uiSymbol;
775  m_pcTDecBinIf->decodeBin( uiSymbol, *m_cCUMergeFlagExtSCModel.get( 0 ) );
776#if H_MV_ENC_DEC_TRAC
777  DTRACE_PU("merge_flag", uiSymbol)
778#endif
779  pcCU->setMergeFlagSubParts( uiSymbol ? true : false, uiAbsPartIdx, uiPUIdx, uiDepth );
780
781#if !H_MV_ENC_DEC_TRAC
782  DTRACE_CABAC_VL( g_nSymbolCounter++ );
783  DTRACE_CABAC_T( "\tMergeFlag: " );
784  DTRACE_CABAC_V( uiSymbol );
785  DTRACE_CABAC_T( "\tAddress: " );
786  DTRACE_CABAC_V( pcCU->getAddr() );
787  DTRACE_CABAC_T( "\tuiAbsPartIdx: " );
788  DTRACE_CABAC_V( uiAbsPartIdx );
789  DTRACE_CABAC_T( "\n" );
790#endif
791}
792
793Void TDecSbac::parseMergeIndex ( TComDataCU* pcCU, UInt& ruiMergeIndex )
794{
795  UInt uiUnaryIdx = 0;
796  UInt uiNumCand = pcCU->getSlice()->getMaxNumMergeCand();
797  if ( uiNumCand > 1 )
798  {
799    for( ; uiUnaryIdx < uiNumCand - 1; ++uiUnaryIdx )
800    {
801      UInt uiSymbol = 0;
802      if ( uiUnaryIdx==0 )
803      {
804        m_pcTDecBinIf->decodeBin( uiSymbol, m_cCUMergeIdxExtSCModel.get( 0, 0, 0 ) );
805      }
806      else
807      {
808        m_pcTDecBinIf->decodeBinEP( uiSymbol );
809      }
810      if( uiSymbol == 0 )
811      {
812        break;
813      }
814    }
815#if H_MV_ENC_DEC_TRAC
816    DTRACE_PU("merge_idx", uiUnaryIdx)
817#endif
818  }
819  ruiMergeIndex = uiUnaryIdx;
820
821#if !H_MV_ENC_DEC_TRAC
822  DTRACE_CABAC_VL( g_nSymbolCounter++ )
823  DTRACE_CABAC_T( "\tparseMergeIndex()" )
824  DTRACE_CABAC_T( "\tuiMRGIdx= " )
825  DTRACE_CABAC_V( ruiMergeIndex )
826  DTRACE_CABAC_T( "\n" )
827#endif
828}
829
830Void TDecSbac::parseMVPIdx      ( Int& riMVPIdx )
831{
832  UInt uiSymbol;
833  xReadUnaryMaxSymbol(uiSymbol, m_cMVPIdxSCModel.get(0), 1, AMVP_MAX_NUM_CANDS-1);
834  riMVPIdx = uiSymbol;
835}
836
837Void TDecSbac::parseSplitFlag     ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
838{
839  if( uiDepth == g_uiMaxCUDepth - g_uiAddCUDepth )
840  {
841    pcCU->setDepthSubParts( uiDepth, uiAbsPartIdx );
842    return;
843  }
844
845  UInt uiSymbol;
846#if H_3D_QTLPC
847  Bool bParseSplitFlag    = true;
848
849  TComSPS *sps            = pcCU->getPic()->getSlice(0)->getSPS();
850  TComPic *pcTexture      = pcCU->getSlice()->getTexturePic();
851  Bool bDepthMapDetect    = (pcTexture != NULL);
852  Bool bIntraSliceDetect  = (pcCU->getSlice()->getSliceType() == I_SLICE);
853
854  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);
855
856  if(bDepthMapDetect && !bIntraSliceDetect && !rapPic && sps->getUseQTL() && sps->getUsePC())
857  {
858    TComDataCU *pcTextureCU = pcTexture->getCU(pcCU->getAddr());
859    assert(pcTextureCU->getDepth(uiAbsPartIdx) >= uiDepth);
860    bParseSplitFlag         = (pcTextureCU->getDepth(uiAbsPartIdx) > uiDepth);
861  }
862
863  if(bParseSplitFlag)
864  {
865#endif
866    m_pcTDecBinIf->decodeBin( uiSymbol, m_cCUSplitFlagSCModel.get( 0, 0, pcCU->getCtxSplitFlag( uiAbsPartIdx, uiDepth ) ) );
867#if H_MV_ENC_DEC_TRAC
868    DTRACE_CU("split_cu_flag", uiSymbol); 
869#else
870    DTRACE_CABAC_VL( g_nSymbolCounter++ )
871    DTRACE_CABAC_T( "\tSplitFlag\n" )
872#endif
873#if H_3D_QTLPC
874  }
875  else
876  {
877    uiSymbol = 0;
878  }
879#endif
880  pcCU->setDepthSubParts( uiDepth + uiSymbol, uiAbsPartIdx );
881 
882  return;
883}
884
885/** parse partition size
886 * \param pcCU
887 * \param uiAbsPartIdx
888 * \param uiDepth
889 * \returns Void
890 */
891Void TDecSbac::parsePartSize( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
892{
893  UInt uiSymbol, uiMode = 0;
894  PartSize eMode;
895
896#if H_3D_QTLPC
897  Bool bParsePartSize    = true;
898  TComSPS *sps           = pcCU->getPic()->getSlice(0)->getSPS();
899  TComPic *pcTexture     = pcCU->getSlice()->getTexturePic();
900  Bool bDepthMapDetect   = (pcTexture != NULL);
901  Bool bIntraSliceDetect = (pcCU->getSlice()->getSliceType() == I_SLICE);
902
903  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);
904
905  if(bDepthMapDetect && !bIntraSliceDetect && !rapPic && sps->getUseQTL() && sps->getUsePC())
906  {
907    TComDataCU *pcTextureCU = pcTexture->getCU(pcCU->getAddr());
908    assert(pcTextureCU->getDepth(uiAbsPartIdx) >= uiDepth);
909    if (pcTextureCU->getDepth(uiAbsPartIdx) == uiDepth && pcTextureCU->getPartitionSize( uiAbsPartIdx ) != SIZE_NxN)
910    {
911      bParsePartSize = false;
912      eMode          = SIZE_2Nx2N;
913    }
914  }
915#endif
916
917 
918  if ( pcCU->isIntra( uiAbsPartIdx ) )
919  {
920#if H_3D_QTLPC
921    if(bParsePartSize)
922    {
923#endif
924     uiSymbol = 1;
925      if( uiDepth == g_uiMaxCUDepth - g_uiAddCUDepth )
926      {
927        m_pcTDecBinIf->decodeBin( uiSymbol, m_cCUPartSizeSCModel.get( 0, 0, 0) );
928#if H_MV_ENC_DEC_TRAC         
929        DTRACE_CU("part_mode", uiSymbol)
930#endif       
931      }
932      eMode = uiSymbol ? SIZE_2Nx2N : SIZE_NxN;
933#if H_3D_QTLPC
934    }
935#endif
936    UInt uiTrLevel = 0;   
937    UInt uiWidthInBit  = g_aucConvertToBit[pcCU->getWidth(uiAbsPartIdx)]+2;
938    UInt uiTrSizeInBit = g_aucConvertToBit[pcCU->getSlice()->getSPS()->getMaxTrSize()]+2;
939    uiTrLevel          = uiWidthInBit >= uiTrSizeInBit ? uiWidthInBit - uiTrSizeInBit : 0;
940    if( eMode == SIZE_NxN )
941    {
942      pcCU->setTrIdxSubParts( 1+uiTrLevel, uiAbsPartIdx, uiDepth );
943    }
944    else
945    {
946      pcCU->setTrIdxSubParts( uiTrLevel, uiAbsPartIdx, uiDepth );
947    }
948  }
949  else
950  {
951#if H_3D_QTLPC
952    if(bParsePartSize)
953    {
954#endif
955      UInt uiMaxNumBits = 2;
956      if( uiDepth == g_uiMaxCUDepth - g_uiAddCUDepth && !( (g_uiMaxCUWidth>>uiDepth) == 8 && (g_uiMaxCUHeight>>uiDepth) == 8 ) )
957      {
958        uiMaxNumBits ++;
959      }
960      for ( UInt ui = 0; ui < uiMaxNumBits; ui++ )
961      {
962        m_pcTDecBinIf->decodeBin( uiSymbol, m_cCUPartSizeSCModel.get( 0, 0, ui) );
963        if ( uiSymbol )
964        {
965          break;
966        }
967        uiMode++;
968      }
969      eMode = (PartSize) uiMode;
970      if ( pcCU->getSlice()->getSPS()->getAMPAcc( uiDepth ) )
971      {
972        if (eMode == SIZE_2NxN)
973        {
974          m_pcTDecBinIf->decodeBin(uiSymbol, m_cCUAMPSCModel.get( 0, 0, 0 ));
975          if (uiSymbol == 0)
976          {
977            m_pcTDecBinIf->decodeBinEP(uiSymbol);
978            eMode = (uiSymbol == 0? SIZE_2NxnU : SIZE_2NxnD);
979          }
980        }
981        else if (eMode == SIZE_Nx2N)
982        {
983          m_pcTDecBinIf->decodeBin(uiSymbol, m_cCUAMPSCModel.get( 0, 0, 0 ));
984          if (uiSymbol == 0)
985          {
986            m_pcTDecBinIf->decodeBinEP(uiSymbol);
987            eMode = (uiSymbol == 0? SIZE_nLx2N : SIZE_nRx2N);
988          }
989        }
990      }
991#if H_MV_ENC_DEC_TRAC         
992      DTRACE_CU("part_mode", eMode )
993#endif
994#if H_3D_QTLPC
995    }
996#endif
997  }
998  pcCU->setPartSizeSubParts( eMode, uiAbsPartIdx, uiDepth );
999  pcCU->setSizeSubParts( g_uiMaxCUWidth>>uiDepth, g_uiMaxCUHeight>>uiDepth, uiAbsPartIdx, uiDepth );
1000}
1001
1002/** parse prediction mode
1003 * \param pcCU
1004 * \param uiAbsPartIdx
1005 * \param uiDepth
1006 * \returns Void
1007 */
1008Void TDecSbac::parsePredMode( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
1009{
1010  if( pcCU->getSlice()->isIntra() )
1011  {
1012    pcCU->setPredModeSubParts( MODE_INTRA, uiAbsPartIdx, uiDepth );
1013    return;
1014  }
1015 
1016  UInt uiSymbol;
1017  Int  iPredMode = MODE_INTER;
1018  m_pcTDecBinIf->decodeBin( uiSymbol, m_cCUPredModeSCModel.get( 0, 0, 0 ) );
1019  iPredMode += uiSymbol;
1020#if H_MV_ENC_DEC_TRAC         
1021  DTRACE_CU("pred_mode_flag", uiSymbol)
1022#endif       
1023  pcCU->setPredModeSubParts( (PredMode)iPredMode, uiAbsPartIdx, uiDepth );
1024}
1025
1026Void TDecSbac::parseIntraDirLumaAng  ( TComDataCU* pcCU, UInt absPartIdx, UInt depth )
1027{
1028  PartSize mode = pcCU->getPartitionSize( absPartIdx );
1029  UInt partNum = mode==SIZE_NxN?4:1;
1030  UInt partOffset = ( pcCU->getPic()->getNumPartInCU() >> ( pcCU->getDepth(absPartIdx) << 1 ) ) >> 2;
1031  UInt mpmPred[4],symbol;
1032  Int j,intraPredMode;   
1033  if (mode==SIZE_NxN)
1034  {
1035    depth++;
1036  }
1037  for (j=0;j<partNum;j++)
1038  {
1039#if H_3D_DIM
1040    if( pcCU->getSlice()->getVpsDepthModesFlag() )
1041    {
1042      parseIntraDepth( pcCU, absPartIdx+partOffset*j, depth );
1043    }
1044    if( pcCU->getLumaIntraDir( absPartIdx+partOffset*j ) < NUM_INTRA_MODE )
1045#if H_3D_DIM_SDC
1046      if( !pcCU->getSDCFlag( absPartIdx+partOffset*j ) )
1047#endif
1048    {
1049#endif
1050    m_pcTDecBinIf->decodeBin( symbol, m_cCUIntraPredSCModel.get( 0, 0, 0) );
1051    mpmPred[j] = symbol;
1052#if H_MV_ENC_DEC_TRAC         
1053    DTRACE_CU("prev_intra_luma_pred_flag", symbol)
1054#endif
1055#if H_3D_DIM
1056    }
1057#endif
1058  }
1059  for (j=0;j<partNum;j++)
1060  {
1061#if H_3D_DIM
1062    if( pcCU->getLumaIntraDir( absPartIdx+partOffset*j ) < NUM_INTRA_MODE )
1063#if H_3D_DIM_SDC
1064      if( !pcCU->getSDCFlag( absPartIdx+partOffset*j ) )
1065#endif
1066    {
1067#endif
1068    Int preds[3] = {-1, -1, -1};
1069    Int predNum = pcCU->getIntraDirLumaPredictor(absPartIdx+partOffset*j, preds); 
1070    if (mpmPred[j])
1071    {
1072      m_pcTDecBinIf->decodeBinEP( symbol );
1073      if (symbol)
1074      {
1075        m_pcTDecBinIf->decodeBinEP( symbol );
1076        symbol++;
1077      }
1078#if H_MV_ENC_DEC_TRAC         
1079      DTRACE_CU("mpm_idx", symbol)
1080#endif
1081      intraPredMode = preds[symbol];
1082    }
1083    else
1084    {
1085      m_pcTDecBinIf->decodeBinsEP( symbol, 5 );
1086      intraPredMode = symbol;
1087#if H_MV_ENC_DEC_TRAC         
1088      DTRACE_CU("rem_intra_luma_pred_mode", symbol)
1089#endif       
1090      //postponed sorting of MPMs (only in remaining branch)
1091      if (preds[0] > preds[1])
1092      { 
1093        std::swap(preds[0], preds[1]); 
1094      }
1095      if (preds[0] > preds[2])
1096      {
1097        std::swap(preds[0], preds[2]);
1098      }
1099      if (preds[1] > preds[2])
1100      {
1101        std::swap(preds[1], preds[2]);
1102      }
1103      for ( Int i = 0; i < predNum; i++ )
1104      {
1105        intraPredMode += ( intraPredMode >= preds[i] );
1106      }
1107    }
1108    pcCU->setLumaIntraDirSubParts( (UChar)intraPredMode, absPartIdx+partOffset*j, depth );
1109#if H_3D_DIM
1110    }
1111#endif
1112  }
1113}
1114
1115Void TDecSbac::parseIntraDirChroma( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
1116{
1117  UInt uiSymbol;
1118
1119  m_pcTDecBinIf->decodeBin( uiSymbol, m_cCUChromaPredSCModel.get( 0, 0, 0 ) );
1120
1121  if( uiSymbol == 0 )
1122  {
1123#if H_MV_ENC_DEC_TRAC         
1124    DTRACE_CU("intra_chroma_pred_mode", uiSymbol )
1125#endif       
1126    uiSymbol = DM_CHROMA_IDX;
1127  } 
1128  else 
1129  {
1130    {
1131      UInt uiIPredMode;
1132      m_pcTDecBinIf->decodeBinsEP( uiIPredMode, 2 );
1133#if H_MV_ENC_DEC_TRAC         
1134      DTRACE_CU("intra_chroma_pred_mode", uiIPredMode )
1135#endif       
1136      UInt uiAllowedChromaDir[ NUM_CHROMA_MODE ];
1137      pcCU->getAllowedChromaDir( uiAbsPartIdx, uiAllowedChromaDir );
1138      uiSymbol = uiAllowedChromaDir[ uiIPredMode ];
1139    }
1140  }
1141  pcCU->setChromIntraDirSubParts( uiSymbol, uiAbsPartIdx, uiDepth );
1142  return;
1143}
1144
1145#if H_3D_DIM
1146Void TDecSbac::parseIntraDepth( TComDataCU* pcCU, UInt absPartIdx, UInt depth )
1147{
1148  parseIntraDepthMode( pcCU, absPartIdx, depth );
1149
1150  UInt dir     = pcCU->getLumaIntraDir( absPartIdx );
1151  UInt dimType = getDimType( dir );
1152
1153  switch( dimType )
1154  {
1155#if H_3D_DIM_DMM
1156  case( DMM1_IDX ):
1157    {
1158      UInt uiTabIdx = 0;
1159      xParseDmm1WedgeIdx( uiTabIdx, g_dmm1TabIdxBits[pcCU->getIntraSizeIdx(absPartIdx)] );
1160      pcCU->setDmmWedgeTabIdxSubParts( uiTabIdx, dimType, absPartIdx, depth );
1161    } break;
1162  case( DMM3_IDX ):
1163    {
1164      UInt uiIntraIdx = 0;
1165      xParseDmm3WedgeIdx( uiIntraIdx, g_dmm3IntraTabIdxBits[pcCU->getIntraSizeIdx(absPartIdx)] );
1166      pcCU->setDmm3IntraTabIdxSubParts( uiIntraIdx, absPartIdx, depth );
1167    } break;
1168  case( DMM4_IDX ): break;
1169#endif
1170#if H_3D_DIM_RBC
1171  case( RBC_IDX ): 
1172    {
1173      xParseRbcEdge( pcCU, absPartIdx, depth );
1174    } break;
1175#endif
1176  default: break;
1177  }
1178
1179#if H_3D_DIM_SDC && !QC_DIM_DELTADC_UNIFY_F0132
1180  if( pcCU->getSDCFlag(absPartIdx) )
1181  {
1182    assert(pcCU->getPartitionSize(absPartIdx)==SIZE_2Nx2N);
1183    pcCU->setTrIdxSubParts(0, absPartIdx, depth);
1184    pcCU->setCbfSubParts(1, 1, 1, absPartIdx, depth);
1185
1186    UInt uiNumSegments = ( dir == DC_IDX || dir == PLANAR_IDX )? 1 : 2;
1187    for (UInt uiSeg=0; uiSeg<uiNumSegments; uiSeg++)
1188    {
1189      xParseSDCResidualData(pcCU, absPartIdx, depth, uiSeg);
1190    }
1191  }
1192  else
1193  {
1194#endif
1195#if QC_DIM_DELTADC_UNIFY_F0132
1196    if( dimType < DIM_NUM_TYPE || pcCU->getSDCFlag( absPartIdx ) )
1197#else
1198    if( dimType < DIM_NUM_TYPE )
1199#endif
1200    {
1201      UInt symbol;
1202#if QC_DIM_DELTADC_UNIFY_F0132
1203      UInt uiNumSegments = ( dir == PLANAR_IDX ) ? 1 : 2;
1204
1205      if( pcCU->getSDCFlag( absPartIdx ) )
1206      {
1207        assert(pcCU->getPartitionSize(absPartIdx)==SIZE_2Nx2N);
1208        pcCU->setTrIdxSubParts(0, absPartIdx, depth);
1209        pcCU->setCbfSubParts(1, 1, 1, absPartIdx, depth);
1210      }
1211
1212      m_pcTDecBinIf->decodeBin( symbol, m_cDdcFlagSCModel.get(0, 0, uiNumSegments-1) );
1213
1214      if( symbol )
1215      {
1216        if( !pcCU->getSDCFlag( absPartIdx ) )
1217        {
1218          dir += symbol;
1219        }
1220      }
1221      for( UInt segment = 0; segment < uiNumSegments; segment++ )
1222      {
1223        Pel valDeltaDC = 0;
1224        if( symbol )
1225        {
1226          xParseDimDeltaDC( valDeltaDC, uiNumSegments );
1227        }
1228
1229        if( pcCU->getSDCFlag( absPartIdx ) )
1230        {
1231          pcCU->setSDCSegmentDCOffset( valDeltaDC, segment, absPartIdx );
1232        }
1233        else
1234        {
1235          pcCU->setDimDeltaDC( dimType, segment, absPartIdx, valDeltaDC );
1236        }
1237      }
1238#else
1239      m_pcTDecBinIf->decodeBin( symbol, m_cDdcFlagSCModel.get(0, 0, (RBC_IDX == dimType) ? 1 : 0) );
1240      if( symbol )
1241      {
1242        dir += symbol;
1243        for( UInt segment = 0; segment < 2; segment++ )
1244        {
1245          Pel valDeltaDC = 0;
1246          xParseDimDeltaDC( valDeltaDC, dimType );
1247          pcCU->setDimDeltaDC( dimType, segment, absPartIdx, valDeltaDC );
1248        }
1249      }
1250#endif
1251    }
1252#if H_3D_DIM_SDC && !QC_DIM_DELTADC_UNIFY_F0132
1253  }
1254#endif
1255
1256  pcCU->setLumaIntraDirSubParts( (UChar)dir, absPartIdx, depth );
1257}
1258
1259Void TDecSbac::parseIntraDepthMode( TComDataCU* pcCU, UInt absPartIdx, UInt depth )
1260{
1261  UInt puIdx = (pcCU->getWidth(absPartIdx) == 64) ? 2 : ( (pcCU->getPartitionSize(absPartIdx) == SIZE_NxN && pcCU->getWidth(absPartIdx) == 8) ? 0 : 1 );
1262  UInt dir = 0;
1263  Bool sdcFlag = 0;
1264  UInt symbol = 1;
1265  UInt modeCode = 0 ;
1266  UInt binNum = 0;
1267  UInt ctxDepthMode = 0;
1268
1269  if( puIdx == 2 )
1270  {
1271    {
1272      ctxDepthMode = puIdx*3 + binNum;
1273      m_pcTDecBinIf->decodeBin( symbol, m_cDepthIntraModeSCModel.get(0,0,ctxDepthMode) );
1274      modeCode = (modeCode<<1) + symbol;
1275      binNum++;
1276    }
1277         if( modeCode == 0 ) { dir = PLANAR_IDX; sdcFlag = 1;}
1278    else if( modeCode == 1 ) { dir = 0;          sdcFlag = 0;}
1279  }
1280  else if( puIdx == 0 )
1281  {
1282    while( binNum < 3 && symbol )
1283    {
1284      ctxDepthMode = puIdx*3 + ((binNum >= 2) ? 2 : binNum);
1285      m_pcTDecBinIf->decodeBin( symbol, m_cDepthIntraModeSCModel.get(0,0,ctxDepthMode) );
1286      modeCode = (modeCode<<1) + symbol;
1287      binNum++;
1288    }
1289         if( modeCode == 0 ) { dir = 0;                       sdcFlag = 0;}
1290    else if( modeCode == 2 ) { dir = (2*DMM1_IDX+DIM_OFFSET); sdcFlag = 0;}
1291    else if( modeCode == 6 ) { dir = (2*DMM3_IDX+DIM_OFFSET); sdcFlag = 0;}
1292    else if( modeCode == 7 ) { dir = (2* RBC_IDX+DIM_OFFSET); sdcFlag = 0;}
1293  }
1294  else
1295  {
1296    UInt maxBinNum = 0;
1297    m_pcTDecBinIf->decodeBinEP(symbol);
1298    if( symbol == 1 )
1299    {
1300      maxBinNum = 3;
1301    }
1302    else
1303    {
1304      maxBinNum = 2;
1305      symbol = 1;
1306    }
1307    while( binNum<maxBinNum && symbol )
1308    {
1309      ctxDepthMode = puIdx*3 + ( binNum >= 2 ? 2 : binNum );
1310      m_pcTDecBinIf->decodeBin(symbol,m_cDepthIntraModeSCModel.get(0,0,ctxDepthMode));
1311      modeCode = (modeCode<<1)+symbol;
1312      binNum++;
1313    }
1314    if( maxBinNum == 3 )
1315    {
1316      if ( modeCode == 0 )       { dir =  PLANAR_IDX;             sdcFlag = 1;}
1317      else if ( modeCode == 2 )  { dir = (2* RBC_IDX+DIM_OFFSET); sdcFlag = 0;}
1318      else if ( modeCode == 6 )  { dir = (2*DMM3_IDX+DIM_OFFSET); sdcFlag = 0;}
1319      else if ( modeCode == 7 )  { dir = (2*DMM1_IDX+DIM_OFFSET); sdcFlag = 0;}
1320    }
1321    else
1322    {
1323      if ( modeCode == 0 )       { dir = 5;                       sdcFlag = 0;}
1324      else if ( modeCode == 2 )  { dir = (2*DMM1_IDX+DIM_OFFSET); sdcFlag = 1;}
1325      else if ( modeCode == 3 )  { dir = (2*DMM4_IDX+DIM_OFFSET); sdcFlag = 0;}
1326    }
1327  }
1328  pcCU->setLumaIntraDirSubParts( (UChar)dir, absPartIdx, depth );
1329#if H_3D_DIM_SDC
1330  pcCU->setSDCFlagSubParts( sdcFlag, absPartIdx, depth ); 
1331#endif
1332}
1333#endif
1334
1335Void TDecSbac::parseInterDir( TComDataCU* pcCU, UInt& ruiInterDir, UInt uiAbsPartIdx )
1336{
1337  UInt uiSymbol;
1338  const UInt uiCtx = pcCU->getCtxInterDir( uiAbsPartIdx );
1339  ContextModel *pCtx = m_cCUInterDirSCModel.get( 0 );
1340  uiSymbol = 0;
1341  if (pcCU->getPartitionSize(uiAbsPartIdx) == SIZE_2Nx2N || pcCU->getHeight(uiAbsPartIdx) != 8 )
1342  {
1343    m_pcTDecBinIf->decodeBin( uiSymbol, *( pCtx + uiCtx ) );
1344  }
1345
1346  if( uiSymbol )
1347  {
1348    uiSymbol = 2;
1349  }
1350  else
1351  {
1352    m_pcTDecBinIf->decodeBin( uiSymbol, *( pCtx + 4 ) );
1353    assert(uiSymbol == 0 || uiSymbol == 1);
1354  }
1355
1356  uiSymbol++;
1357  ruiInterDir = uiSymbol;
1358#if H_MV_ENC_DEC_TRAC
1359    DTRACE_PU("inter_pred_idc", ruiInterDir - 1 )   
1360#endif
1361
1362  return;
1363}
1364
1365Void TDecSbac::parseRefFrmIdx( TComDataCU* pcCU, Int& riRefFrmIdx, RefPicList eRefList )
1366{
1367  UInt uiSymbol;
1368  {
1369    ContextModel *pCtx = m_cCURefPicSCModel.get( 0 );
1370    m_pcTDecBinIf->decodeBin( uiSymbol, *pCtx );
1371
1372    if( uiSymbol )
1373    {
1374      UInt uiRefNum = pcCU->getSlice()->getNumRefIdx( eRefList ) - 2;
1375      pCtx++;
1376      UInt ui;
1377      for( ui = 0; ui < uiRefNum; ++ui )
1378      {
1379        if( ui == 0 )
1380        {
1381          m_pcTDecBinIf->decodeBin( uiSymbol, *pCtx );
1382        }
1383        else
1384        {
1385          m_pcTDecBinIf->decodeBinEP( uiSymbol );
1386        }
1387        if( uiSymbol == 0 )
1388        {
1389          break;
1390        }
1391      }
1392      uiSymbol = ui + 1;
1393    }
1394    riRefFrmIdx = uiSymbol;
1395  }
1396
1397#if H_MV_ENC_DEC_TRAC
1398#if ENC_DEC_TRACE
1399  if ( eRefList == REF_PIC_LIST_0 )
1400  {
1401    DTRACE_PU("ref_idx_l0", uiSymbol)
1402  }
1403  else
1404  {
1405    DTRACE_PU("ref_idx_l1", uiSymbol)
1406  }
1407#endif
1408#endif
1409  return;
1410}
1411
1412Void TDecSbac::parseMvd( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth, RefPicList eRefList )
1413{
1414  UInt uiSymbol;
1415  UInt uiHorAbs;
1416  UInt uiVerAbs;
1417  UInt uiHorSign = 0;
1418  UInt uiVerSign = 0;
1419  ContextModel *pCtx = m_cCUMvdSCModel.get( 0 );
1420
1421  if(pcCU->getSlice()->getMvdL1ZeroFlag() && eRefList == REF_PIC_LIST_1 && pcCU->getInterDir(uiAbsPartIdx)==3)
1422  {
1423    uiHorAbs=0;
1424    uiVerAbs=0;
1425  }
1426  else
1427  {
1428    m_pcTDecBinIf->decodeBin( uiHorAbs, *pCtx );
1429    m_pcTDecBinIf->decodeBin( uiVerAbs, *pCtx );
1430
1431    const Bool bHorAbsGr0 = uiHorAbs != 0;
1432    const Bool bVerAbsGr0 = uiVerAbs != 0;
1433    pCtx++;
1434
1435    if( bHorAbsGr0 )
1436    {
1437      m_pcTDecBinIf->decodeBin( uiSymbol, *pCtx );
1438      uiHorAbs += uiSymbol;
1439    }
1440
1441    if( bVerAbsGr0 )
1442    {
1443      m_pcTDecBinIf->decodeBin( uiSymbol, *pCtx );
1444      uiVerAbs += uiSymbol;
1445    }
1446
1447    if( bHorAbsGr0 )
1448    {
1449      if( 2 == uiHorAbs )
1450      {
1451        xReadEpExGolomb( uiSymbol, 1 );
1452        uiHorAbs += uiSymbol;
1453      }
1454
1455      m_pcTDecBinIf->decodeBinEP( uiHorSign );
1456    }
1457
1458    if( bVerAbsGr0 )
1459    {
1460      if( 2 == uiVerAbs )
1461      {
1462        xReadEpExGolomb( uiSymbol, 1 );
1463        uiVerAbs += uiSymbol;
1464      }
1465
1466      m_pcTDecBinIf->decodeBinEP( uiVerSign );
1467    }
1468
1469  }
1470
1471  const TComMv cMv( uiHorSign ? -Int( uiHorAbs ): uiHorAbs, uiVerSign ? -Int( uiVerAbs ) : uiVerAbs );
1472  pcCU->getCUMvField( eRefList )->setAllMvd( cMv, pcCU->getPartitionSize( uiAbsPartIdx ), uiAbsPartIdx, uiDepth, uiPartIdx );
1473  return;
1474}
1475
1476
1477Void TDecSbac::parseTransformSubdivFlag( UInt& ruiSubdivFlag, UInt uiLog2TransformBlockSize )
1478{
1479  m_pcTDecBinIf->decodeBin( ruiSubdivFlag, m_cCUTransSubdivFlagSCModel.get( 0, 0, uiLog2TransformBlockSize ) );
1480#if !H_MV_ENC_DEC_TRAC
1481  DTRACE_CABAC_VL( g_nSymbolCounter++ )
1482  DTRACE_CABAC_T( "\tparseTransformSubdivFlag()" )
1483  DTRACE_CABAC_T( "\tsymbol=" )
1484  DTRACE_CABAC_V( ruiSubdivFlag )
1485  DTRACE_CABAC_T( "\tctx=" )
1486  DTRACE_CABAC_V( uiLog2TransformBlockSize )
1487  DTRACE_CABAC_T( "\n" )
1488#endif
1489}
1490
1491Void TDecSbac::parseQtRootCbf( UInt uiAbsPartIdx, UInt& uiQtRootCbf )
1492{
1493  UInt uiSymbol;
1494  const UInt uiCtx = 0;
1495  m_pcTDecBinIf->decodeBin( uiSymbol , m_cCUQtRootCbfSCModel.get( 0, 0, uiCtx ) );
1496#if !H_MV_ENC_DEC_TRAC
1497  DTRACE_CABAC_VL( g_nSymbolCounter++ )
1498  DTRACE_CABAC_T( "\tparseQtRootCbf()" )
1499  DTRACE_CABAC_T( "\tsymbol=" )
1500  DTRACE_CABAC_V( uiSymbol )
1501  DTRACE_CABAC_T( "\tctx=" )
1502  DTRACE_CABAC_V( uiCtx )
1503  DTRACE_CABAC_T( "\tuiAbsPartIdx=" )
1504  DTRACE_CABAC_V( uiAbsPartIdx )
1505  DTRACE_CABAC_T( "\n" )
1506#else
1507  DTRACE_CU( "rqt_root_cbf", uiSymbol )
1508#endif
1509 
1510  uiQtRootCbf = uiSymbol;
1511}
1512
1513Void TDecSbac::parseDeltaQP( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
1514{
1515  Int qp;
1516  UInt uiDQp;
1517  Int  iDQp;
1518 
1519  UInt uiSymbol;
1520
1521  xReadUnaryMaxSymbol (uiDQp,  &m_cCUDeltaQpSCModel.get( 0, 0, 0 ), 1, CU_DQP_TU_CMAX);
1522
1523  if( uiDQp >= CU_DQP_TU_CMAX)
1524  {
1525    xReadEpExGolomb( uiSymbol, CU_DQP_EG_k );
1526    uiDQp+=uiSymbol;
1527  }
1528
1529  if ( uiDQp > 0 )
1530  {
1531    UInt uiSign;
1532    Int qpBdOffsetY = pcCU->getSlice()->getSPS()->getQpBDOffsetY();
1533    m_pcTDecBinIf->decodeBinEP(uiSign);
1534    iDQp = uiDQp;
1535    if(uiSign)
1536    {
1537      iDQp = -iDQp;
1538    }
1539    qp = (((Int) pcCU->getRefQP( uiAbsPartIdx ) + iDQp + 52 + 2*qpBdOffsetY )%(52+qpBdOffsetY)) - qpBdOffsetY;
1540  }
1541  else 
1542  {
1543    qp = pcCU->getRefQP(uiAbsPartIdx);
1544  }
1545  pcCU->setQPSubParts(qp, uiAbsPartIdx, uiDepth); 
1546  pcCU->setCodedQP(qp);
1547}
1548
1549Void TDecSbac::parseQtCbf( TComDataCU* pcCU, UInt uiAbsPartIdx, TextType eType, UInt uiTrDepth, UInt uiDepth )
1550{
1551  UInt uiSymbol;
1552  const UInt uiCtx = pcCU->getCtxQtCbf( eType, uiTrDepth );
1553  m_pcTDecBinIf->decodeBin( uiSymbol , m_cCUQtCbfSCModel.get( 0, eType ? TEXT_CHROMA: eType, uiCtx ) );
1554#if !H_MV_ENC_DEC_TRAC 
1555  DTRACE_CABAC_VL( g_nSymbolCounter++ )
1556  DTRACE_CABAC_T( "\tparseQtCbf()" )
1557  DTRACE_CABAC_T( "\tsymbol=" )
1558  DTRACE_CABAC_V( uiSymbol )
1559  DTRACE_CABAC_T( "\tctx=" )
1560  DTRACE_CABAC_V( uiCtx )
1561  DTRACE_CABAC_T( "\tetype=" )
1562  DTRACE_CABAC_V( eType )
1563  DTRACE_CABAC_T( "\tuiAbsPartIdx=" )
1564  DTRACE_CABAC_V( uiAbsPartIdx )
1565  DTRACE_CABAC_T( "\n" )
1566#endif
1567 
1568  pcCU->setCbfSubParts( uiSymbol << uiTrDepth, eType, uiAbsPartIdx, uiDepth );
1569}
1570
1571void TDecSbac::parseTransformSkipFlags (TComDataCU* pcCU, UInt uiAbsPartIdx, UInt width, UInt height, UInt uiDepth, TextType eTType)
1572{
1573  if (pcCU->getCUTransquantBypass(uiAbsPartIdx))
1574  {
1575    return;
1576  }
1577  if(width != 4 || height != 4)
1578  {
1579    return;
1580  }
1581 
1582  UInt useTransformSkip;
1583  m_pcTDecBinIf->decodeBin( useTransformSkip , m_cTransformSkipSCModel.get( 0, eTType? TEXT_CHROMA: TEXT_LUMA, 0 ) );
1584  if(eTType!= TEXT_LUMA)
1585  {
1586    const UInt uiLog2TrafoSize = g_aucConvertToBit[pcCU->getSlice()->getSPS()->getMaxCUWidth()] + 2 - uiDepth;
1587    if(uiLog2TrafoSize == 2) 
1588    { 
1589      uiDepth --;
1590    }
1591  }
1592#if !H_MV_ENC_DEC_TRAC
1593  DTRACE_CABAC_VL( g_nSymbolCounter++ )
1594  DTRACE_CABAC_T("\tparseTransformSkip()");
1595  DTRACE_CABAC_T( "\tsymbol=" )
1596  DTRACE_CABAC_V( useTransformSkip )
1597  DTRACE_CABAC_T( "\tAddr=" )
1598  DTRACE_CABAC_V( pcCU->getAddr() )
1599  DTRACE_CABAC_T( "\tetype=" )
1600  DTRACE_CABAC_V( eTType )
1601  DTRACE_CABAC_T( "\tuiAbsPartIdx=" )
1602  DTRACE_CABAC_V( uiAbsPartIdx )
1603  DTRACE_CABAC_T( "\n" )
1604#endif
1605
1606  pcCU->setTransformSkipSubParts( useTransformSkip, eTType, uiAbsPartIdx, uiDepth);
1607}
1608
1609/** Parse (X,Y) position of the last significant coefficient
1610 * \param uiPosLastX reference to X component of last coefficient
1611 * \param uiPosLastY reference to Y component of last coefficient
1612 * \param width  Block width
1613 * \param height Block height
1614 * \param eTType plane type / luminance or chrominance
1615 * \param uiScanIdx scan type (zig-zag, hor, ver)
1616 *
1617 * This method decodes the X and Y component within a block of the last significant coefficient.
1618 */
1619Void TDecSbac::parseLastSignificantXY( UInt& uiPosLastX, UInt& uiPosLastY, Int width, Int height, TextType eTType, UInt uiScanIdx )
1620{
1621  UInt uiLast;
1622  ContextModel *pCtxX = m_cCuCtxLastX.get( 0, eTType );
1623  ContextModel *pCtxY = m_cCuCtxLastY.get( 0, eTType );
1624
1625  Int blkSizeOffsetX, blkSizeOffsetY, shiftX, shiftY;
1626  blkSizeOffsetX = eTType ? 0: (g_aucConvertToBit[ width ] *3 + ((g_aucConvertToBit[ width ] +1)>>2));
1627  blkSizeOffsetY = eTType ? 0: (g_aucConvertToBit[ height ]*3 + ((g_aucConvertToBit[ height ]+1)>>2));
1628  shiftX= eTType ? g_aucConvertToBit[ width  ] :((g_aucConvertToBit[ width  ]+3)>>2);
1629  shiftY= eTType ? g_aucConvertToBit[ height ] :((g_aucConvertToBit[ height ]+3)>>2);
1630  // posX
1631  for( uiPosLastX = 0; uiPosLastX < g_uiGroupIdx[ width - 1 ]; uiPosLastX++ )
1632  {
1633    m_pcTDecBinIf->decodeBin( uiLast, *( pCtxX + blkSizeOffsetX + (uiPosLastX >>shiftX) ) );
1634    if( !uiLast )
1635    {
1636      break;
1637    }
1638  }
1639
1640  // posY
1641  for( uiPosLastY = 0; uiPosLastY < g_uiGroupIdx[ height - 1 ]; uiPosLastY++ )
1642  {
1643    m_pcTDecBinIf->decodeBin( uiLast, *( pCtxY + blkSizeOffsetY + (uiPosLastY >>shiftY)) );
1644    if( !uiLast )
1645    {
1646      break;
1647    }
1648  }
1649  if ( uiPosLastX > 3 )
1650  {
1651    UInt uiTemp  = 0;
1652    UInt uiCount = ( uiPosLastX - 2 ) >> 1;
1653    for ( Int i = uiCount - 1; i >= 0; i-- )
1654    {
1655      m_pcTDecBinIf->decodeBinEP( uiLast );
1656      uiTemp += uiLast << i;
1657    }
1658    uiPosLastX = g_uiMinInGroup[ uiPosLastX ] + uiTemp;
1659  }
1660  if ( uiPosLastY > 3 )
1661  {
1662    UInt uiTemp  = 0;
1663    UInt uiCount = ( uiPosLastY - 2 ) >> 1;
1664    for ( Int i = uiCount - 1; i >= 0; i-- )
1665    {
1666      m_pcTDecBinIf->decodeBinEP( uiLast );
1667      uiTemp += uiLast << i;
1668    }
1669    uiPosLastY = g_uiMinInGroup[ uiPosLastY ] + uiTemp;
1670  }
1671 
1672  if( uiScanIdx == SCAN_VER )
1673  {
1674    swap( uiPosLastX, uiPosLastY );
1675  }
1676}
1677
1678Void TDecSbac::parseCoeffNxN( TComDataCU* pcCU, TCoeff* pcCoef, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, UInt uiDepth, TextType eTType )
1679{
1680#if !H_MV_ENC_DEC_TRAC
1681  DTRACE_CABAC_VL( g_nSymbolCounter++ )
1682  DTRACE_CABAC_T( "\tparseCoeffNxN()\teType=" )
1683  DTRACE_CABAC_V( eTType )
1684  DTRACE_CABAC_T( "\twidth=" )
1685  DTRACE_CABAC_V( uiWidth )
1686  DTRACE_CABAC_T( "\theight=" )
1687  DTRACE_CABAC_V( uiHeight )
1688  DTRACE_CABAC_T( "\tdepth=" )
1689  DTRACE_CABAC_V( uiDepth )
1690  DTRACE_CABAC_T( "\tabspartidx=" )
1691  DTRACE_CABAC_V( uiAbsPartIdx )
1692  DTRACE_CABAC_T( "\ttoCU-X=" )
1693  DTRACE_CABAC_V( pcCU->getCUPelX() )
1694  DTRACE_CABAC_T( "\ttoCU-Y=" )
1695  DTRACE_CABAC_V( pcCU->getCUPelY() )
1696  DTRACE_CABAC_T( "\tCU-addr=" )
1697  DTRACE_CABAC_V(  pcCU->getAddr() )
1698  DTRACE_CABAC_T( "\tinCU-X=" )
1699  DTRACE_CABAC_V( g_auiRasterToPelX[ g_auiZscanToRaster[uiAbsPartIdx] ] )
1700  DTRACE_CABAC_T( "\tinCU-Y=" )
1701  DTRACE_CABAC_V( g_auiRasterToPelY[ g_auiZscanToRaster[uiAbsPartIdx] ] )
1702  DTRACE_CABAC_T( "\tpredmode=" )
1703  DTRACE_CABAC_V(  pcCU->getPredictionMode( uiAbsPartIdx ) )
1704  DTRACE_CABAC_T( "\n" )
1705#endif
1706 
1707  if( uiWidth > pcCU->getSlice()->getSPS()->getMaxTrSize() )
1708  {
1709    uiWidth  = pcCU->getSlice()->getSPS()->getMaxTrSize();
1710    uiHeight = pcCU->getSlice()->getSPS()->getMaxTrSize();
1711  }
1712  if(pcCU->getSlice()->getPPS()->getUseTransformSkip())
1713  {
1714    parseTransformSkipFlags( pcCU, uiAbsPartIdx, uiWidth, uiHeight, uiDepth, eTType);
1715  }
1716
1717  eTType = eTType == TEXT_LUMA ? TEXT_LUMA : ( eTType == TEXT_NONE ? TEXT_NONE : TEXT_CHROMA );
1718 
1719  //----- parse significance map -----
1720  const UInt  uiLog2BlockSize   = g_aucConvertToBit[ uiWidth ] + 2;
1721  const UInt  uiMaxNumCoeff     = uiWidth * uiHeight;
1722  const UInt  uiMaxNumCoeffM1   = uiMaxNumCoeff - 1;
1723  UInt uiScanIdx = pcCU->getCoefScanIdx(uiAbsPartIdx, uiWidth, eTType==TEXT_LUMA, pcCU->isIntra(uiAbsPartIdx));
1724 
1725  //===== decode last significant =====
1726  UInt uiPosLastX, uiPosLastY;
1727  parseLastSignificantXY( uiPosLastX, uiPosLastY, uiWidth, uiHeight, eTType, uiScanIdx );
1728  UInt uiBlkPosLast      = uiPosLastX + (uiPosLastY<<uiLog2BlockSize);
1729  pcCoef[ uiBlkPosLast ] = 1;
1730
1731  //===== decode significance flags =====
1732  UInt uiScanPosLast;
1733  const UInt *scan   = g_auiSigLastScan[ uiScanIdx ][ uiLog2BlockSize-1 ];
1734  for( uiScanPosLast = 0; uiScanPosLast < uiMaxNumCoeffM1; uiScanPosLast++ )
1735  {
1736    UInt uiBlkPos = scan[ uiScanPosLast ];
1737    if( uiBlkPosLast == uiBlkPos )
1738    {
1739      break;
1740    }
1741  }
1742
1743  ContextModel * const baseCoeffGroupCtx = m_cCUSigCoeffGroupSCModel.get( 0, eTType );
1744  ContextModel * const baseCtx = (eTType==TEXT_LUMA) ? m_cCUSigSCModel.get( 0, 0 ) : m_cCUSigSCModel.get( 0, 0 ) + NUM_SIG_FLAG_CTX_LUMA;
1745
1746  const Int  iLastScanSet      = uiScanPosLast >> LOG2_SCAN_SET_SIZE;
1747  UInt c1 = 1;
1748  UInt uiGoRiceParam           = 0;
1749
1750  Bool beValid; 
1751  if (pcCU->getCUTransquantBypass(uiAbsPartIdx))
1752  {
1753    beValid = false;
1754  }
1755  else 
1756  {
1757    beValid = pcCU->getSlice()->getPPS()->getSignHideFlag() > 0;
1758  }
1759  UInt absSum = 0;
1760
1761  UInt uiSigCoeffGroupFlag[ MLS_GRP_NUM ];
1762  ::memset( uiSigCoeffGroupFlag, 0, sizeof(UInt) * MLS_GRP_NUM );
1763  const UInt uiNumBlkSide = uiWidth >> (MLS_CG_SIZE >> 1);
1764  const UInt * scanCG;
1765  {
1766    scanCG = g_auiSigLastScan[ uiScanIdx ][ uiLog2BlockSize > 3 ? uiLog2BlockSize-2-1 : 0  ];   
1767    if( uiLog2BlockSize == 3 )
1768    {
1769      scanCG = g_sigLastScan8x8[ uiScanIdx ];
1770    }
1771    else if( uiLog2BlockSize == 5 )
1772    {
1773      scanCG = g_sigLastScanCG32x32;
1774    }
1775  }
1776  Int  iScanPosSig             = (Int) uiScanPosLast;
1777  for( Int iSubSet = iLastScanSet; iSubSet >= 0; iSubSet-- )
1778  {
1779    Int  iSubPos     = iSubSet << LOG2_SCAN_SET_SIZE;
1780    uiGoRiceParam    = 0;
1781    Int numNonZero = 0;
1782   
1783    Int lastNZPosInCG = -1, firstNZPosInCG = SCAN_SET_SIZE;
1784
1785    Int pos[SCAN_SET_SIZE];
1786    if( iScanPosSig == (Int) uiScanPosLast )
1787    {
1788      lastNZPosInCG  = iScanPosSig;
1789      firstNZPosInCG = iScanPosSig;
1790      iScanPosSig--;
1791      pos[ numNonZero ] = uiBlkPosLast;
1792      numNonZero = 1;
1793    }
1794
1795    // decode significant_coeffgroup_flag
1796    Int iCGBlkPos = scanCG[ iSubSet ];
1797    Int iCGPosY   = iCGBlkPos / uiNumBlkSide;
1798    Int iCGPosX   = iCGBlkPos - (iCGPosY * uiNumBlkSide);
1799    if( iSubSet == iLastScanSet || iSubSet == 0)
1800    {
1801      uiSigCoeffGroupFlag[ iCGBlkPos ] = 1;
1802    }
1803    else
1804    {
1805      UInt uiSigCoeffGroup;
1806      UInt uiCtxSig  = TComTrQuant::getSigCoeffGroupCtxInc( uiSigCoeffGroupFlag, iCGPosX, iCGPosY, uiWidth, uiHeight );
1807      m_pcTDecBinIf->decodeBin( uiSigCoeffGroup, baseCoeffGroupCtx[ uiCtxSig ] );
1808      uiSigCoeffGroupFlag[ iCGBlkPos ] = uiSigCoeffGroup;
1809    }
1810
1811    // decode significant_coeff_flag
1812    Int patternSigCtx = TComTrQuant::calcPatternSigCtx( uiSigCoeffGroupFlag, iCGPosX, iCGPosY, uiWidth, uiHeight );
1813    UInt uiBlkPos, uiPosY, uiPosX, uiSig, uiCtxSig;
1814    for( ; iScanPosSig >= iSubPos; iScanPosSig-- )
1815    {
1816      uiBlkPos  = scan[ iScanPosSig ];
1817      uiPosY    = uiBlkPos >> uiLog2BlockSize;
1818      uiPosX    = uiBlkPos - ( uiPosY << uiLog2BlockSize );
1819      uiSig     = 0;
1820     
1821      if( uiSigCoeffGroupFlag[ iCGBlkPos ] )
1822      {
1823        if( iScanPosSig > iSubPos || iSubSet == 0  || numNonZero )
1824        {
1825          uiCtxSig  = TComTrQuant::getSigCtxInc( patternSigCtx, uiScanIdx, uiPosX, uiPosY, uiLog2BlockSize, eTType );
1826          m_pcTDecBinIf->decodeBin( uiSig, baseCtx[ uiCtxSig ] );
1827        }
1828        else
1829        {
1830          uiSig = 1;
1831        }
1832      }
1833      pcCoef[ uiBlkPos ] = uiSig;
1834      if( uiSig )
1835      {
1836        pos[ numNonZero ] = uiBlkPos;
1837        numNonZero ++;
1838        if( lastNZPosInCG == -1 )
1839        {
1840          lastNZPosInCG = iScanPosSig;
1841        }
1842        firstNZPosInCG = iScanPosSig;
1843      }
1844    }
1845   
1846    if( numNonZero )
1847    {
1848      Bool signHidden = ( lastNZPosInCG - firstNZPosInCG >= SBH_THRESHOLD );
1849      absSum = 0;
1850      UInt uiCtxSet    = (iSubSet > 0 && eTType==TEXT_LUMA) ? 2 : 0;
1851      UInt uiBin;
1852      if( c1 == 0 )
1853      {
1854        uiCtxSet++;
1855      }
1856      c1 = 1;
1857      ContextModel *baseCtxMod = ( eTType==TEXT_LUMA ) ? m_cCUOneSCModel.get( 0, 0 ) + 4 * uiCtxSet : m_cCUOneSCModel.get( 0, 0 ) + NUM_ONE_FLAG_CTX_LUMA + 4 * uiCtxSet;
1858      Int absCoeff[SCAN_SET_SIZE];
1859
1860      for ( Int i = 0; i < numNonZero; i++) absCoeff[i] = 1;   
1861      Int numC1Flag = min(numNonZero, C1FLAG_NUMBER);
1862      Int firstC2FlagIdx = -1;
1863
1864      for( Int idx = 0; idx < numC1Flag; idx++ )
1865      {
1866        m_pcTDecBinIf->decodeBin( uiBin, baseCtxMod[c1] );
1867        if( uiBin == 1 )
1868        {
1869          c1 = 0;
1870          if (firstC2FlagIdx == -1)
1871          {
1872            firstC2FlagIdx = idx;
1873          }
1874        }
1875        else if( (c1 < 3) && (c1 > 0) )
1876        {
1877          c1++;
1878        }
1879        absCoeff[ idx ] = uiBin + 1;
1880      }
1881     
1882      if (c1 == 0)
1883      {
1884        baseCtxMod = ( eTType==TEXT_LUMA ) ? m_cCUAbsSCModel.get( 0, 0 ) + uiCtxSet : m_cCUAbsSCModel.get( 0, 0 ) + NUM_ABS_FLAG_CTX_LUMA + uiCtxSet;
1885        if ( firstC2FlagIdx != -1)
1886        {
1887          m_pcTDecBinIf->decodeBin( uiBin, baseCtxMod[0] ); 
1888          absCoeff[ firstC2FlagIdx ] = uiBin + 2;
1889        }
1890      }
1891
1892      UInt coeffSigns;
1893      if ( signHidden && beValid )
1894      {
1895        m_pcTDecBinIf->decodeBinsEP( coeffSigns, numNonZero-1 );
1896        coeffSigns <<= 32 - (numNonZero-1);
1897      }
1898      else
1899      {
1900        m_pcTDecBinIf->decodeBinsEP( coeffSigns, numNonZero );
1901        coeffSigns <<= 32 - numNonZero;
1902      }
1903     
1904      Int iFirstCoeff2 = 1;   
1905      if (c1 == 0 || numNonZero > C1FLAG_NUMBER)
1906      {
1907        for( Int idx = 0; idx < numNonZero; idx++ )
1908        {
1909          UInt baseLevel  = (idx < C1FLAG_NUMBER)? (2 + iFirstCoeff2) : 1;
1910
1911          if( absCoeff[ idx ] == baseLevel)
1912          {
1913            UInt uiLevel;
1914            xReadCoefRemainExGolomb( uiLevel, uiGoRiceParam );
1915            absCoeff[ idx ] = uiLevel + baseLevel;
1916            if(absCoeff[idx]>3*(1<<uiGoRiceParam))
1917            {
1918              uiGoRiceParam = min<UInt>(uiGoRiceParam+ 1, 4);
1919            }
1920          }
1921
1922          if(absCoeff[ idx ] >= 2) 
1923          {
1924            iFirstCoeff2 = 0;
1925          }
1926        }
1927      }
1928
1929      for( Int idx = 0; idx < numNonZero; idx++ )
1930      {
1931        Int blkPos = pos[ idx ];
1932        // Signs applied later.
1933        pcCoef[ blkPos ] = absCoeff[ idx ];
1934        absSum += absCoeff[ idx ];
1935
1936        if ( idx == numNonZero-1 && signHidden && beValid )
1937        {
1938          // Infer sign of 1st element.
1939          if (absSum&0x1)
1940          {
1941            pcCoef[ blkPos ] = -pcCoef[ blkPos ];
1942          }
1943        }
1944        else
1945        {
1946          Int sign = static_cast<Int>( coeffSigns ) >> 31;
1947          pcCoef[ blkPos ] = ( pcCoef[ blkPos ] ^ sign ) - sign;
1948          coeffSigns <<= 1;
1949        }
1950      }
1951    }
1952  }
1953 
1954  return;
1955}
1956
1957
1958Void TDecSbac::parseSaoMaxUvlc ( UInt& val, UInt maxSymbol )
1959{
1960  if (maxSymbol == 0)
1961  {
1962    val = 0;
1963    return;
1964  }
1965
1966  UInt code;
1967  Int  i;
1968  m_pcTDecBinIf->decodeBinEP( code );
1969  if ( code == 0 )
1970  {
1971    val = 0;
1972    return;
1973  }
1974
1975  i=1;
1976  while (1)
1977  {
1978    m_pcTDecBinIf->decodeBinEP( code );
1979    if ( code == 0 )
1980    {
1981      break;
1982    }
1983    i++;
1984    if (i == maxSymbol) 
1985    {
1986      break;
1987    }
1988  }
1989
1990  val = i;
1991}
1992Void TDecSbac::parseSaoUflc (UInt uiLength, UInt&  riVal)
1993{
1994  m_pcTDecBinIf->decodeBinsEP ( riVal, uiLength );
1995}
1996Void TDecSbac::parseSaoMerge (UInt&  ruiVal)
1997{
1998  UInt uiCode;
1999  m_pcTDecBinIf->decodeBin( uiCode, m_cSaoMergeSCModel.get( 0, 0, 0 ) );
2000  ruiVal = (Int)uiCode;
2001}
2002Void TDecSbac::parseSaoTypeIdx (UInt&  ruiVal)
2003{
2004  UInt uiCode;
2005  m_pcTDecBinIf->decodeBin( uiCode, m_cSaoTypeIdxSCModel.get( 0, 0, 0 ) );
2006  if (uiCode == 0) 
2007  {
2008    ruiVal = 0;
2009  }
2010  else
2011  {
2012    m_pcTDecBinIf->decodeBinEP( uiCode ); 
2013    if (uiCode == 0)
2014    {
2015      ruiVal = 5;
2016    }
2017    else
2018    {
2019      ruiVal = 1;
2020    }
2021  }
2022}
2023
2024inline Void copySaoOneLcuParam(SaoLcuParam* psDst,  SaoLcuParam* psSrc)
2025{
2026  Int i;
2027  psDst->partIdx = psSrc->partIdx;
2028  psDst->typeIdx    = psSrc->typeIdx;
2029  if (psDst->typeIdx != -1)
2030  {
2031    psDst->subTypeIdx = psSrc->subTypeIdx ;
2032    psDst->length  = psSrc->length;
2033    for (i=0;i<psDst->length;i++)
2034    {
2035      psDst->offset[i] = psSrc->offset[i];
2036    }
2037  }
2038  else
2039  {
2040    psDst->length  = 0;
2041    for (i=0;i<SAO_BO_LEN;i++)
2042    {
2043      psDst->offset[i] = 0;
2044    }
2045  }
2046}
2047
2048Void TDecSbac::parseSaoOffset(SaoLcuParam* psSaoLcuParam, UInt compIdx)
2049{
2050  UInt uiSymbol;
2051  static Int iTypeLength[MAX_NUM_SAO_TYPE] =
2052  {
2053    SAO_EO_LEN,
2054    SAO_EO_LEN,
2055    SAO_EO_LEN,
2056    SAO_EO_LEN,
2057    SAO_BO_LEN
2058  }; 
2059
2060  if (compIdx==2)
2061  {
2062    uiSymbol = (UInt)( psSaoLcuParam->typeIdx + 1);
2063  }
2064  else
2065  {
2066    parseSaoTypeIdx(uiSymbol);
2067  }
2068  psSaoLcuParam->typeIdx = (Int)uiSymbol - 1;
2069  if (uiSymbol)
2070  {
2071    psSaoLcuParam->length = iTypeLength[psSaoLcuParam->typeIdx];
2072
2073    Int bitDepth = compIdx ? g_bitDepthC : g_bitDepthY;
2074    Int offsetTh = 1 << min(bitDepth - 5,5);
2075
2076    if( psSaoLcuParam->typeIdx == SAO_BO )
2077    {
2078      for(Int i=0; i< psSaoLcuParam->length; i++)
2079      {
2080        parseSaoMaxUvlc(uiSymbol, offsetTh -1 );
2081        psSaoLcuParam->offset[i] = uiSymbol;
2082      }   
2083      for(Int i=0; i< psSaoLcuParam->length; i++)
2084      {
2085        if (psSaoLcuParam->offset[i] != 0) 
2086        {
2087          m_pcTDecBinIf->decodeBinEP ( uiSymbol);
2088          if (uiSymbol)
2089          {
2090            psSaoLcuParam->offset[i] = -psSaoLcuParam->offset[i] ;
2091          }
2092        }
2093      }
2094      parseSaoUflc(5, uiSymbol );
2095      psSaoLcuParam->subTypeIdx = uiSymbol;
2096    }
2097    else if( psSaoLcuParam->typeIdx < 4 )
2098    {
2099      parseSaoMaxUvlc(uiSymbol, offsetTh -1 ); psSaoLcuParam->offset[0] = uiSymbol;
2100      parseSaoMaxUvlc(uiSymbol, offsetTh -1 ); psSaoLcuParam->offset[1] = uiSymbol;
2101      parseSaoMaxUvlc(uiSymbol, offsetTh -1 ); psSaoLcuParam->offset[2] = -(Int)uiSymbol;
2102      parseSaoMaxUvlc(uiSymbol, offsetTh -1 ); psSaoLcuParam->offset[3] = -(Int)uiSymbol;
2103     if (compIdx != 2)
2104     {
2105       parseSaoUflc(2, uiSymbol );
2106       psSaoLcuParam->subTypeIdx = uiSymbol;
2107       psSaoLcuParam->typeIdx += psSaoLcuParam->subTypeIdx;
2108     }
2109   }
2110  }
2111  else
2112  {
2113    psSaoLcuParam->length = 0;
2114  }
2115}
2116
2117Void TDecSbac::parseSaoOneLcuInterleaving(Int rx, Int ry, SAOParam* pSaoParam, TComDataCU* pcCU, Int iCUAddrInSlice, Int iCUAddrUpInSlice, Int allowMergeLeft, Int allowMergeUp)
2118{
2119  Int iAddr = pcCU->getAddr();
2120  UInt uiSymbol;
2121  for (Int iCompIdx=0; iCompIdx<3; iCompIdx++)
2122  {
2123    pSaoParam->saoLcuParam[iCompIdx][iAddr].mergeUpFlag    = 0;
2124    pSaoParam->saoLcuParam[iCompIdx][iAddr].mergeLeftFlag  = 0;
2125    pSaoParam->saoLcuParam[iCompIdx][iAddr].subTypeIdx     = 0;
2126    pSaoParam->saoLcuParam[iCompIdx][iAddr].typeIdx        = -1;
2127    pSaoParam->saoLcuParam[iCompIdx][iAddr].offset[0]     = 0;
2128    pSaoParam->saoLcuParam[iCompIdx][iAddr].offset[1]     = 0;
2129    pSaoParam->saoLcuParam[iCompIdx][iAddr].offset[2]     = 0;
2130    pSaoParam->saoLcuParam[iCompIdx][iAddr].offset[3]     = 0;
2131
2132  }
2133 if (pSaoParam->bSaoFlag[0] || pSaoParam->bSaoFlag[1] )
2134  {
2135    if (rx>0 && iCUAddrInSlice!=0 && allowMergeLeft)
2136    {
2137      parseSaoMerge(uiSymbol); 
2138      pSaoParam->saoLcuParam[0][iAddr].mergeLeftFlag = (Bool)uiSymbol; 
2139    }
2140    if (pSaoParam->saoLcuParam[0][iAddr].mergeLeftFlag==0)
2141    {
2142      if ((ry > 0) && (iCUAddrUpInSlice>=0) && allowMergeUp)
2143      {
2144        parseSaoMerge(uiSymbol);
2145        pSaoParam->saoLcuParam[0][iAddr].mergeUpFlag = (Bool)uiSymbol;
2146      }
2147    }
2148  }
2149
2150  for (Int iCompIdx=0; iCompIdx<3; iCompIdx++)
2151  {
2152    if ((iCompIdx == 0  && pSaoParam->bSaoFlag[0]) || (iCompIdx > 0  && pSaoParam->bSaoFlag[1]) )
2153    {
2154      if (rx>0 && iCUAddrInSlice!=0 && allowMergeLeft)
2155      {
2156        pSaoParam->saoLcuParam[iCompIdx][iAddr].mergeLeftFlag = pSaoParam->saoLcuParam[0][iAddr].mergeLeftFlag;
2157      }
2158      else
2159      {
2160        pSaoParam->saoLcuParam[iCompIdx][iAddr].mergeLeftFlag = 0;
2161      }
2162
2163      if (pSaoParam->saoLcuParam[iCompIdx][iAddr].mergeLeftFlag==0)
2164      {
2165        if ((ry > 0) && (iCUAddrUpInSlice>=0) && allowMergeUp)
2166        {
2167          pSaoParam->saoLcuParam[iCompIdx][iAddr].mergeUpFlag = pSaoParam->saoLcuParam[0][iAddr].mergeUpFlag;
2168        }
2169        else
2170        {
2171          pSaoParam->saoLcuParam[iCompIdx][iAddr].mergeUpFlag = 0;
2172        }
2173        if (!pSaoParam->saoLcuParam[iCompIdx][iAddr].mergeUpFlag)
2174        {
2175          pSaoParam->saoLcuParam[2][iAddr].typeIdx = pSaoParam->saoLcuParam[1][iAddr].typeIdx;
2176          parseSaoOffset(&(pSaoParam->saoLcuParam[iCompIdx][iAddr]), iCompIdx);
2177        }
2178        else
2179        {
2180          copySaoOneLcuParam(&pSaoParam->saoLcuParam[iCompIdx][iAddr], &pSaoParam->saoLcuParam[iCompIdx][iAddr-pSaoParam->numCuInWidth]);
2181        }
2182      }
2183      else
2184      {
2185        copySaoOneLcuParam(&pSaoParam->saoLcuParam[iCompIdx][iAddr],  &pSaoParam->saoLcuParam[iCompIdx][iAddr-1]);
2186      }
2187    }
2188    else
2189    {
2190      pSaoParam->saoLcuParam[iCompIdx][iAddr].typeIdx = -1;
2191      pSaoParam->saoLcuParam[iCompIdx][iAddr].subTypeIdx = 0;
2192    }
2193  }
2194}
2195
2196/**
2197 - Initialize our contexts from the nominated source.
2198 .
2199 \param pSrc Contexts to be copied.
2200 */
2201Void TDecSbac::xCopyContextsFrom( TDecSbac* pSrc )
2202{
2203  memcpy(m_contextModels, pSrc->m_contextModels, m_numContextModels*sizeof(m_contextModels[0]));
2204}
2205
2206Void TDecSbac::xCopyFrom( TDecSbac* pSrc )
2207{
2208  m_pcTDecBinIf->copyState( pSrc->m_pcTDecBinIf );
2209
2210  m_uiLastQp           = pSrc->m_uiLastQp;
2211  xCopyContextsFrom( pSrc );
2212
2213}
2214
2215Void TDecSbac::load ( TDecSbac* pScr )
2216{
2217  xCopyFrom(pScr);
2218}
2219
2220Void TDecSbac::loadContexts ( TDecSbac* pScr )
2221{
2222  xCopyContextsFrom(pScr);
2223}
2224
2225#if H_3D_ARP
2226Void TDecSbac::parseARPW( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
2227{
2228  UInt uiMaxW = pcCU->getSlice()->getARPStepNum() - 1;
2229  UInt uiW = 0;
2230  UInt uiOffset = pcCU->getCTXARPWFlag(uiAbsPartIdx);
2231  UInt uiCode = 0;
2232
2233  assert ( uiMaxW > 0 );
2234
2235  m_pcTDecBinIf->decodeBin( uiCode , m_cCUPUARPWSCModel.get( 0, 0, 0 + uiOffset ) );
2236
2237  uiW = uiCode;
2238  if( 1 == uiW )   
2239  {
2240    m_pcTDecBinIf->decodeBin( uiCode , m_cCUPUARPWSCModel.get( 0, 0, 3 ) );
2241    uiW += ( 1 == uiCode ? 1 : 0 );
2242  }
2243#if H_MV_ENC_DEC_TRAC
2244  DTRACE_CU("iv_res_pred_weight_idx", uiW )
2245#endif
2246  pcCU->setARPWSubParts( ( UChar )( uiW ) , uiAbsPartIdx, uiDepth ); 
2247}
2248#endif
2249
2250#if H_3D_IC
2251/** parse illumination compensation flag
2252 * \param pcCU
2253 * \param uiAbsPartIdx
2254 * \param uiDepth
2255 * \returns Void
2256 */
2257Void TDecSbac::parseICFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
2258{ 
2259  UInt uiSymbol = 0;
2260  UInt uiCtxIC = pcCU->getCtxICFlag( uiAbsPartIdx );
2261  m_pcTDecBinIf->decodeBin( uiSymbol, m_cCUICFlagSCModel.get( 0, 0, uiCtxIC ) );
2262#if !H_MV_ENC_DEC_TRAC
2263  DTRACE_CABAC_VL( g_nSymbolCounter++ );
2264  DTRACE_CABAC_T( "\tICFlag" );
2265  DTRACE_CABAC_T( "\tuiCtxIC: ");
2266  DTRACE_CABAC_V( uiCtxIC );
2267  DTRACE_CABAC_T( "\tuiSymbol: ");
2268  DTRACE_CABAC_V( uiSymbol );
2269  DTRACE_CABAC_T( "\n");
2270#else
2271  DTRACE_CU("ic_flag", uiSymbol)
2272#endif
2273 
2274  pcCU->setICFlagSubParts( uiSymbol ? true : false , uiAbsPartIdx, 0, uiDepth );
2275}
2276#endif
2277
2278#if H_3D_INTER_SDC
2279Void TDecSbac::parseInterSDCFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
2280{
2281  UInt uiSymbol = 0;
2282  UInt uiCtxInterSDCFlag = pcCU->getCtxInterSDCFlag( uiAbsPartIdx );
2283
2284  m_pcTDecBinIf->decodeBin( uiSymbol, m_cInterSDCFlagSCModel.get( 0, 0, uiCtxInterSDCFlag ) );
2285
2286  if( uiSymbol )
2287  {
2288    pcCU->setInterSDCFlagSubParts( true, uiAbsPartIdx, 0, uiDepth );
2289    pcCU->setTrIdxSubParts( 0, uiAbsPartIdx, uiDepth );
2290    pcCU->setCbfSubParts( 1, 1, 1, uiAbsPartIdx, uiDepth );
2291  }
2292  else
2293  {
2294    pcCU->setInterSDCFlagSubParts( false, uiAbsPartIdx, 0, uiDepth);
2295  }
2296}
2297
2298Void TDecSbac::parseInterSDCResidualData ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, UInt uiSegment )
2299{
2300  UInt uiAbsIdx   = 0;
2301  UInt uiSign     = 0;
2302  Int  iIdx       = 0;
2303
2304  xReadExGolombLevel( uiAbsIdx, m_cInterSDCResidualSCModel.get( 0, 0, 0 ) );
2305
2306  uiAbsIdx++;
2307  m_pcTDecBinIf->decodeBin( uiSign, m_cInterSDCResidualSignFlagSCModel.get( 0, 0, 0 ) );
2308  iIdx = (Int)( uiSign ? -1 : 1 ) * uiAbsIdx;
2309
2310  pcCU->setInterSDCSegmentDCOffset( iIdx, uiSegment, uiAbsPartIdx );
2311}
2312#endif
2313
2314//! \}
Note: See TracBrowser for help on using the repository browser.