source: 3DVCSoftware/branches/HTM-DEV-2.0-dev3-SCU-Hisilicon/source/Lib/TLibDecoder/TDecSbac.cpp

Last change on this file was 561, checked in by zhejiang, 11 years ago

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