source: 3DVCSoftware/branches/HTM-DEV-2.0-dev0/source/Lib/TLibDecoder/TDecSbac.cpp @ 598

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

Merged dev2: DEV-2.0-LG@595

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