Context navigation

TDecSbac.cpp @ 1216

Visit:

Last change on this file since 1216 was 1209, checked in by hhi, 10 years ago

Alignment and reactivation of DMM and depth encoder optimizations:

new macro NH_3D_DMM for DMM functionality, including several clean-ups.
new macro NH_3D_SDC for SDC functionality, currently only used for covering common SDC and DMM parts.
new macro NH_3D_ENC_DEPTH for encoder optimizations related to depth.
temporary macro TEMP_SDC_CLEANUP for covering several proposed cleanups related to SDC and DMM.

Property svn:eol-style set to native

File size: 88.8 KB

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

Note: See TracBrowser for help on using the repository browser.

JCT-3V 3D-HEVC

Context navigation

source: 3DVCSoftware/branches/HTM-14.1-update-dev1-HHI/source/Lib/TLibDecoder/TDecSbac.cpp @ 1216

Download in other formats: