source: 3DVCSoftware/trunk/source/Lib/TLibDecoder/TDecSbac.cpp @ 860

Last change on this file since 860 was 833, checked in by tech, 11 years ago

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