Context navigation

TEncSbac.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: 91.5 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 TEncSbac.cpp
35	\brief SBAC encoder class
36	*/
37
38	#include "TEncTop.h"
39	#include "TEncSbac.h"
40	#include "TLibCommon/TComTU.h"
41
42	#include <map>
43	#include <algorithm>
44
45	#if ENVIRONMENT_VARIABLE_DEBUG_AND_TEST
46	#include "../TLibCommon/Debug.h"
47	#endif
48
49
50	//! \ingroup TLibEncoder
51	//! \{
52
53	// ====================================================================================================================
54	// Constructor / destructor / create / destroy
55	// ====================================================================================================================
56
57	TEncSbac::TEncSbac()
58	// new structure here
59	: m_pcBitIf ( NULL )
60	, m_pcBinIf ( NULL )
61	, m_numContextModels ( 0 )
62	, m_cCUSplitFlagSCModel ( 1, 1, NUM_SPLIT_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels)
63	, m_cCUSkipFlagSCModel ( 1, 1, NUM_SKIP_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels)
64	#if H_3D
65	, m_cCUDISFlagSCModel ( 1, 1, NUM_DIS_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels)
66	, m_cCUDISTypeSCModel ( 1, 1, NUM_DIS_TYPE_CTX , m_contextModels + m_numContextModels, m_numContextModels)
67	#endif
68	, m_cCUMergeFlagExtSCModel ( 1, 1, NUM_MERGE_FLAG_EXT_CTX , m_contextModels + m_numContextModels, m_numContextModels)
69	, m_cCUMergeIdxExtSCModel ( 1, 1, NUM_MERGE_IDX_EXT_CTX , m_contextModels + m_numContextModels, m_numContextModels)
70	#if H_3D_ARP
71	, m_cCUPUARPWSCModel ( 1, 1, NUM_ARPW_CTX , m_contextModels + m_numContextModels, m_numContextModels)
72	#endif
73	#if H_3D_IC
74	, m_cCUICFlagSCModel ( 1, 1, NUM_IC_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels)
75	#endif
76	, m_cCUPartSizeSCModel ( 1, 1, NUM_PART_SIZE_CTX , m_contextModels + m_numContextModels, m_numContextModels)
77	, m_cCUPredModeSCModel ( 1, 1, NUM_PRED_MODE_CTX , m_contextModels + m_numContextModels, m_numContextModels)
78	, m_cCUIntraPredSCModel ( 1, 1, NUM_INTRA_PREDICT_CTX , m_contextModels + m_numContextModels, m_numContextModels)
79	, m_cCUChromaPredSCModel ( 1, 1, NUM_CHROMA_PRED_CTX , m_contextModels + m_numContextModels, m_numContextModels)
80	, m_cCUDeltaQpSCModel ( 1, 1, NUM_DELTA_QP_CTX , m_contextModels + m_numContextModels, m_numContextModels)
81	, m_cCUInterDirSCModel ( 1, 1, NUM_INTER_DIR_CTX , m_contextModels + m_numContextModels, m_numContextModels)
82	, m_cCURefPicSCModel ( 1, 1, NUM_REF_NO_CTX , m_contextModels + m_numContextModels, m_numContextModels)
83	, m_cCUMvdSCModel ( 1, 1, NUM_MV_RES_CTX , m_contextModels + m_numContextModels, m_numContextModels)
84	, m_cCUQtCbfSCModel ( 1, NUM_QT_CBF_CTX_SETS, NUM_QT_CBF_CTX_PER_SET , m_contextModels + m_numContextModels, m_numContextModels)
85	, m_cCUTransSubdivFlagSCModel ( 1, 1, NUM_TRANS_SUBDIV_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels)
86	, m_cCUQtRootCbfSCModel ( 1, 1, NUM_QT_ROOT_CBF_CTX , m_contextModels + m_numContextModels, m_numContextModels)
87	, m_cCUSigCoeffGroupSCModel ( 1, 2, NUM_SIG_CG_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels)
88	, m_cCUSigSCModel ( 1, 1, NUM_SIG_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels)
89	, m_cCuCtxLastX ( 1, NUM_CTX_LAST_FLAG_SETS, NUM_CTX_LAST_FLAG_XY , m_contextModels + m_numContextModels, m_numContextModels)
90	, m_cCuCtxLastY ( 1, NUM_CTX_LAST_FLAG_SETS, NUM_CTX_LAST_FLAG_XY , m_contextModels + m_numContextModels, m_numContextModels)
91	, m_cCUOneSCModel ( 1, 1, NUM_ONE_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels)
92	, m_cCUAbsSCModel ( 1, 1, NUM_ABS_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels)
93	, m_cMVPIdxSCModel ( 1, 1, NUM_MVP_IDX_CTX , m_contextModels + m_numContextModels, m_numContextModels)
94	, m_cSaoMergeSCModel ( 1, 1, NUM_SAO_MERGE_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels)
95	, m_cSaoTypeIdxSCModel ( 1, 1, NUM_SAO_TYPE_IDX_CTX , m_contextModels + m_numContextModels, m_numContextModels)
96	, m_cTransformSkipSCModel ( 1, MAX_NUM_CHANNEL_TYPE, NUM_TRANSFORMSKIP_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels)
97	, m_CUTransquantBypassFlagSCModel ( 1, 1, NUM_CU_TRANSQUANT_BYPASS_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels)
98	, m_explicitRdpcmFlagSCModel ( 1, MAX_NUM_CHANNEL_TYPE, NUM_EXPLICIT_RDPCM_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels)
99	, m_explicitRdpcmDirSCModel ( 1, MAX_NUM_CHANNEL_TYPE, NUM_EXPLICIT_RDPCM_DIR_CTX , m_contextModels + m_numContextModels, m_numContextModels)
100	, m_cCrossComponentPredictionSCModel ( 1, 1, NUM_CROSS_COMPONENT_PREDICTION_CTX , m_contextModels + m_numContextModels, m_numContextModels)
101	, m_ChromaQpAdjFlagSCModel ( 1, 1, NUM_CHROMA_QP_ADJ_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels)
102	, m_ChromaQpAdjIdcSCModel ( 1, 1, NUM_CHROMA_QP_ADJ_IDC_CTX , m_contextModels + m_numContextModels, m_numContextModels)
103
104	#if NH_3D_DMM
105	, m_cNotDmmFlagSCModel ( 1, 1, NUM_NOTDMM_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels)
106	, m_cDmmModeSCModel ( 1, 1, NUM_DMM_MODE_CTX , m_contextModels + m_numContextModels, m_numContextModels)
107	#endif
108	#if NH_3D_DMM \|\| NH_3D_SDC
109	, m_cDdcDataSCModel ( 1, 1, NUM_DDC_DATA_CTX , m_contextModels + m_numContextModels, m_numContextModels)
110	#endif
111	#if H_3D_DIM_SDC
112	, m_cSDCResidualFlagSCModel ( 1, 1, SDC_NUM_RESIDUAL_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels)
113	, m_cSDCResidualSCModel ( 1, 1, SDC_NUM_RESIDUAL_CTX , m_contextModels + m_numContextModels, m_numContextModels)
114	, m_cSDCFlagSCModel ( 1, 1, NUM_SDC_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels)
115	, m_cDdcFlagSCModel ( 1, 1, NUM_DDC_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels)
116	#endif
117	#if H_3D_DBBP
118	, m_cDBBPFlagSCModel ( 1, 1, DBBP_NUM_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels)
119	#endif
120	{
121	assert( m_numContextModels <= MAX_NUM_CTX_MOD );
122	}
123
124	TEncSbac::~TEncSbac()
125	{
126	}
127
128	// ====================================================================================================================
129	// Public member functions
130	// ====================================================================================================================
131
132	Void TEncSbac::resetEntropy (const TComSlice *pSlice)
133	{
134	Int iQp = pSlice->getSliceQp();
135	SliceType eSliceType = pSlice->getSliceType();
136
137	SliceType encCABACTableIdx = pSlice->getEncCABACTableIdx();
138	if (!pSlice->isIntra() && (encCABACTableIdx==B_SLICE \|\| encCABACTableIdx==P_SLICE) && pSlice->getPPS()->getCabacInitPresentFlag())
139	{
140	eSliceType = encCABACTableIdx;
141	}
142
143	m_cCUSplitFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_SPLIT_FLAG );
144	m_cCUSkipFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_SKIP_FLAG );
145	#if H_3D
146	m_cCUDISFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_DIS_FLAG );
147	m_cCUDISTypeSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_DIS_TYPE );
148	#endif
149	m_cCUMergeFlagExtSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_MERGE_FLAG_EXT);
150	m_cCUMergeIdxExtSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_MERGE_IDX_EXT);
151	#if H_3D_ARP
152	m_cCUPUARPWSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_ARPW );
153	#endif
154	#if H_3D_IC
155	m_cCUICFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_IC_FLAG );
156	#endif
157	m_cCUPartSizeSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_PART_SIZE );
158	m_cCUPredModeSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_PRED_MODE );
159	m_cCUIntraPredSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_INTRA_PRED_MODE );
160	m_cCUChromaPredSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_CHROMA_PRED_MODE );
161	m_cCUInterDirSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_INTER_DIR );
162	m_cCUMvdSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_MVD );
163	m_cCURefPicSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_REF_PIC );
164	m_cCUDeltaQpSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_DQP );
165	m_cCUQtCbfSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_QT_CBF );
166	m_cCUQtRootCbfSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_QT_ROOT_CBF );
167	m_cCUSigCoeffGroupSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_SIG_CG_FLAG );
168	m_cCUSigSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_SIG_FLAG );
169	m_cCuCtxLastX.initBuffer ( eSliceType, iQp, (UChar*)INIT_LAST );
170	m_cCuCtxLastY.initBuffer ( eSliceType, iQp, (UChar*)INIT_LAST );
171	m_cCUOneSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_ONE_FLAG );
172	m_cCUAbsSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_ABS_FLAG );
173	m_cMVPIdxSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_MVP_IDX );
174	m_cCUTransSubdivFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_TRANS_SUBDIV_FLAG );
175	m_cSaoMergeSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_SAO_MERGE_FLAG );
176	m_cSaoTypeIdxSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_SAO_TYPE_IDX );
177	m_cTransformSkipSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_TRANSFORMSKIP_FLAG );
178	m_CUTransquantBypassFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_CU_TRANSQUANT_BYPASS_FLAG );
179	m_explicitRdpcmFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_EXPLICIT_RDPCM_FLAG);
180	m_explicitRdpcmDirSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_EXPLICIT_RDPCM_DIR);
181	m_cCrossComponentPredictionSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_CROSS_COMPONENT_PREDICTION );
182	m_ChromaQpAdjFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_CHROMA_QP_ADJ_FLAG );
183	m_ChromaQpAdjIdcSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_CHROMA_QP_ADJ_IDC );
184
185	#if NH_3D_DMM
186	m_cNotDmmFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_NOTDMM_FLAG );
187	m_cDmmModeSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_DMM_MODE );
188	#endif
189	#if NH_3D_DMM \|\| NH_3D_SDC
190	m_cDdcDataSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_DDC_DATA );
191	#endif
192	#if H_3D_DIM_SDC
193	m_cSDCResidualFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_SDC_RESIDUAL_FLAG );
194	m_cSDCResidualSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_SDC_RESIDUAL );
195	m_cSDCFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_SDC_FLAG );
196	m_cDdcFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_DDC_FLAG );
197	#endif
198	#if H_3D_DBBP
199	m_cDBBPFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_DBBP_FLAG );
200	#endif
201
202	for (UInt statisticIndex = 0; statisticIndex < RExt__GOLOMB_RICE_ADAPTATION_STATISTICS_SETS ; statisticIndex++)
203	{
204	m_golombRiceAdaptationStatistics[statisticIndex] = 0;
205	}
206
207	m_pcBinIf->start();
208
209	return;
210	}
211
212	/** The function does the following:
213	* If current slice type is P/B then it determines the distance of initialisation type 1 and 2 from the current CABAC states and
214	* stores the index of the closest table. This index is used for the next P/B slice when cabac_init_present_flag is true.
215	*/
216	SliceType TEncSbac::determineCabacInitIdx(const TComSlice *pSlice)
217	{
218	Int qp = pSlice->getSliceQp();
219
220	if (!pSlice->isIntra())
221	{
222	SliceType aSliceTypeChoices[] = {B_SLICE, P_SLICE};
223
224	UInt bestCost = MAX_UINT;
225	SliceType bestSliceType = aSliceTypeChoices[0];
226	for (UInt idx=0; idx<2; idx++)
227	{
228	UInt curCost = 0;
229	SliceType curSliceType = aSliceTypeChoices[idx];
230
231	curCost = m_cCUSplitFlagSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_SPLIT_FLAG );
232	curCost += m_cCUSkipFlagSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_SKIP_FLAG );
233	#if H_3D
234	curCost += m_cCUDISFlagSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_DIS_FLAG );
235	curCost += m_cCUDISTypeSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_DIS_TYPE );
236	#endif
237	curCost += m_cCUMergeFlagExtSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_MERGE_FLAG_EXT);
238	curCost += m_cCUMergeIdxExtSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_MERGE_IDX_EXT);
239	#if H_3D_ARP
240	curCost += m_cCUPUARPWSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_ARPW );
241	#endif
242	#if H_3D_IC
243	curCost += m_cCUICFlagSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_IC_FLAG );
244	#endif
245	#if H_3D_DIM_SDC
246	curCost += m_cSDCFlagSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_SDC_FLAG );
247	#endif
248	#if H_3D_DBBP
249	curCost += m_cDBBPFlagSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_DBBP_FLAG );
250	#endif
251	curCost += m_cCUPartSizeSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_PART_SIZE );
252	curCost += m_cCUPredModeSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_PRED_MODE );
253	curCost += m_cCUIntraPredSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_INTRA_PRED_MODE );
254	curCost += m_cCUChromaPredSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_CHROMA_PRED_MODE );
255	curCost += m_cCUInterDirSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_INTER_DIR );
256	curCost += m_cCUMvdSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_MVD );
257	curCost += m_cCURefPicSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_REF_PIC );
258	curCost += m_cCUDeltaQpSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_DQP );
259	curCost += m_cCUQtCbfSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_QT_CBF );
260	curCost += m_cCUQtRootCbfSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_QT_ROOT_CBF );
261	curCost += m_cCUSigCoeffGroupSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_SIG_CG_FLAG );
262	curCost += m_cCUSigSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_SIG_FLAG );
263	curCost += m_cCuCtxLastX.calcCost ( curSliceType, qp, (UChar*)INIT_LAST );
264	curCost += m_cCuCtxLastY.calcCost ( curSliceType, qp, (UChar*)INIT_LAST );
265	curCost += m_cCUOneSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_ONE_FLAG );
266	curCost += m_cCUAbsSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_ABS_FLAG );
267	curCost += m_cMVPIdxSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_MVP_IDX );
268	curCost += m_cCUTransSubdivFlagSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_TRANS_SUBDIV_FLAG );
269	curCost += m_cSaoMergeSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_SAO_MERGE_FLAG );
270	curCost += m_cSaoTypeIdxSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_SAO_TYPE_IDX );
271	curCost += m_cTransformSkipSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_TRANSFORMSKIP_FLAG );
272	curCost += m_CUTransquantBypassFlagSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_CU_TRANSQUANT_BYPASS_FLAG );
273	curCost += m_explicitRdpcmFlagSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_EXPLICIT_RDPCM_FLAG);
274	curCost += m_explicitRdpcmDirSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_EXPLICIT_RDPCM_DIR);
275	curCost += m_cCrossComponentPredictionSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_CROSS_COMPONENT_PREDICTION );
276	curCost += m_ChromaQpAdjFlagSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_CHROMA_QP_ADJ_FLAG );
277	curCost += m_ChromaQpAdjIdcSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_CHROMA_QP_ADJ_IDC );
278	#if NH_3D_DMM
279	curCost += m_cNotDmmFlagSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_NOTDMM_FLAG );
280	curCost += m_cDmmModeSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_DMM_MODE );
281	#endif
282	#if NH_3D_DMM \|\| NH_3D_SDC
283	curCost += m_cDdcDataSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_DDC_DATA );
284	#endif
285
286	if (curCost < bestCost)
287	{
288	bestSliceType = curSliceType;
289	bestCost = curCost;
290	}
291	}
292	return bestSliceType;
293	}
294	else
295	{
296	return I_SLICE;
297	}
298	}
299
300	#if H_3D
301	m_cCUDISFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_DIS_FLAG );
302	m_cCUDISTypeSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_DIS_TYPE );
303	#endif
304	#if H_3D_ARP
305	m_cCUPUARPWSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_ARPW );
306	#endif
307	#if H_3D_IC
308	m_cCUICFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_IC_FLAG );
309	#endif
310	#if H_3D_DIM_SDC
311	m_cSDCResidualFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_SDC_RESIDUAL_FLAG );
312	m_cSDCResidualSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_SDC_RESIDUAL );
313	m_cSDCFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_SDC_FLAG );
314	m_cDdcFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_DDC_FLAG );
315	#endif
316	#if H_3D_DBBP
317	m_cDBBPFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_DBBP_FLAG );
318	#endif
319
320
321	Void TEncSbac::codeVPS( const TComVPS* /pcVPS/ )
322	{
323	assert (0);
324	return;
325	}
326
327	Void TEncSbac::codeSPS( const TComSPS* /pcSPS/ )
328	{
329	assert (0);
330	return;
331	}
332
333	Void TEncSbac::codePPS( const TComPPS* /pcPPS/ )
334	{
335	assert (0);
336	return;
337	}
338
339	Void TEncSbac::codeSliceHeader( TComSlice* /pcSlice/ )
340	{
341	assert (0);
342	return;
343	}
344
345	Void TEncSbac::codeTilesWPPEntryPoint( TComSlice* /pSlice/ )
346	{
347	assert (0);
348	return;
349	}
350
351	Void TEncSbac::codeTerminatingBit( UInt uilsLast )
352	{
353	m_pcBinIf->encodeBinTrm( uilsLast );
354	}
355
356	Void TEncSbac::codeSliceFinish()
357	{
358	m_pcBinIf->finish();
359	}
360
361	Void TEncSbac::xWriteUnarySymbol( UInt uiSymbol, ContextModel* pcSCModel, Int iOffset )
362	{
363	m_pcBinIf->encodeBin( uiSymbol ? 1 : 0, pcSCModel[0] );
364
365	if( 0 == uiSymbol)
366	{
367	return;
368	}
369
370	while( uiSymbol-- )
371	{
372	m_pcBinIf->encodeBin( uiSymbol ? 1 : 0, pcSCModel[ iOffset ] );
373	}
374
375	return;
376	}
377
378	Void TEncSbac::xWriteUnaryMaxSymbol( UInt uiSymbol, ContextModel* pcSCModel, Int iOffset, UInt uiMaxSymbol )
379	{
380	if (uiMaxSymbol == 0)
381	{
382	return;
383	}
384
385	m_pcBinIf->encodeBin( uiSymbol ? 1 : 0, pcSCModel[ 0 ] );
386
387	if ( uiSymbol == 0 )
388	{
389	return;
390	}
391
392	Bool bCodeLast = ( uiMaxSymbol > uiSymbol );
393
394	while( --uiSymbol )
395	{
396	m_pcBinIf->encodeBin( 1, pcSCModel[ iOffset ] );
397	}
398	if( bCodeLast )
399	{
400	m_pcBinIf->encodeBin( 0, pcSCModel[ iOffset ] );
401	}
402
403	return;
404	}
405
406	Void TEncSbac::xWriteEpExGolomb( UInt uiSymbol, UInt uiCount )
407	{
408	UInt bins = 0;
409	Int numBins = 0;
410
411	while( uiSymbol >= (UInt)(1<<uiCount) )
412	{
413	bins = 2 * bins + 1;
414	numBins++;
415	uiSymbol -= 1 << uiCount;
416	uiCount ++;
417	}
418	bins = 2 * bins + 0;
419	numBins++;
420
421	bins = (bins << uiCount) \| uiSymbol;
422	numBins += uiCount;
423
424	assert( numBins <= 32 );
425	m_pcBinIf->encodeBinsEP( bins, numBins );
426	}
427
428	#if H_3D
429	Void TEncSbac::codeDIS( TComDataCU* pcCU, UInt uiAbsPartIdx )
430	{
431	UInt uiSymbol = pcCU->getDISFlag(uiAbsPartIdx ) ? 1 : 0;
432	m_pcBinIf->encodeBin( uiSymbol, m_cCUDISFlagSCModel.get( 0, 0, 0 ) );
433	if(uiSymbol)
434	{
435	UInt uiUnaryIdx = (UInt) pcCU->getDISType(uiAbsPartIdx);
436	UInt uiNumCand = 4;
437
438	if ( uiNumCand > 1 )
439	{
440	for( UInt ui = 0; ui < uiNumCand - 1; ++ui )
441	{
442	const UInt uiSymbol2 = ui == uiUnaryIdx ? 0 : 1;
443	if ( ui == 0 )
444	{
445	m_pcBinIf->encodeBin( uiSymbol2, m_cCUDISTypeSCModel.get( 0, 0, 0 ) );
446	}
447	else
448	{
449	m_pcBinIf->encodeBinEP( uiSymbol2 );
450	}
451	if( uiSymbol2 == 0 )
452	{
453	break;
454	}
455	}
456	}
457	}
458	}
459	#endif
460
461
462	/** Coding of coeff_abs_level_minus3
463	* \param symbol value of coeff_abs_level_minus3
464	* \param rParam reference to Rice parameter
465	* \param useLimitedPrefixLength
466	* \param maxLog2TrDynamicRange
467	*/
468	Void TEncSbac::xWriteCoefRemainExGolomb ( UInt symbol, UInt &rParam, const Bool useLimitedPrefixLength, const Int maxLog2TrDynamicRange )
469	{
470	Int codeNumber = (Int)symbol;
471	UInt length;
472
473	if (codeNumber < (COEF_REMAIN_BIN_REDUCTION << rParam))
474	{
475	length = codeNumber>>rParam;
476	m_pcBinIf->encodeBinsEP( (1<<(length+1))-2 , length+1);
477	m_pcBinIf->encodeBinsEP((codeNumber%(1<<rParam)),rParam);
478	}
479	else if (useLimitedPrefixLength)
480	{
481	const UInt maximumPrefixLength = (32 - (COEF_REMAIN_BIN_REDUCTION + maxLog2TrDynamicRange));
482
483	UInt prefixLength = 0;
484	UInt suffixLength = MAX_UINT;
485	UInt codeValue = (symbol >> rParam) - COEF_REMAIN_BIN_REDUCTION;
486
487	if (codeValue >= ((1 << maximumPrefixLength) - 1))
488	{
489	prefixLength = maximumPrefixLength;
490	suffixLength = maxLog2TrDynamicRange - rParam;
491	}
492	else
493	{
494	while (codeValue > ((2 << prefixLength) - 2))
495	{
496	prefixLength++;
497	}
498
499	suffixLength = prefixLength + 1; //+1 for the separator bit
500	}
501
502	const UInt suffix = codeValue - ((1 << prefixLength) - 1);
503
504	const UInt totalPrefixLength = prefixLength + COEF_REMAIN_BIN_REDUCTION;
505	const UInt prefix = (1 << totalPrefixLength) - 1;
506	const UInt rParamBitMask = (1 << rParam) - 1;
507
508	m_pcBinIf->encodeBinsEP( prefix, totalPrefixLength ); //prefix
509	m_pcBinIf->encodeBinsEP(((suffix << rParam) \| (symbol & rParamBitMask)), (suffixLength + rParam)); //separator, suffix, and rParam bits
510	}
511	else
512	{
513	length = rParam;
514	codeNumber = codeNumber - ( COEF_REMAIN_BIN_REDUCTION << rParam);
515
516	while (codeNumber >= (1<<length))
517	{
518	codeNumber -= (1<<(length++));
519	}
520
521	m_pcBinIf->encodeBinsEP((1<<(COEF_REMAIN_BIN_REDUCTION+length+1-rParam))-2,COEF_REMAIN_BIN_REDUCTION+length+1-rParam);
522	m_pcBinIf->encodeBinsEP(codeNumber,length);
523	}
524	}
525	// SBAC RD
526	Void TEncSbac::load ( const TEncSbac* pSrc)
527	{
528	this->xCopyFrom(pSrc);
529	}
530
531	Void TEncSbac::loadIntraDirMode( const TEncSbac* pSrc, const ChannelType chType )
532	{
533	m_pcBinIf->copyState( pSrc->m_pcBinIf );
534	if (isLuma(chType))
535	{
536	this->m_cCUIntraPredSCModel .copyFrom( &pSrc->m_cCUIntraPredSCModel );
537	}
538	else
539	{
540	this->m_cCUChromaPredSCModel .copyFrom( &pSrc->m_cCUChromaPredSCModel );
541	}
542	}
543
544	#if NH_3D_DMM
545	Void TEncSbac::loadIntraDepthDmm( const TEncSbac* pSrc )
546	{
547	m_pcBinIf->copyState( pSrc->m_pcBinIf );
548	this->m_cNotDmmFlagSCModel.copyFrom( &pSrc->m_cNotDmmFlagSCModel );
549	this->m_cDmmModeSCModel .copyFrom( &pSrc->m_cDmmModeSCModel );
550	}
551	#endif
552
553
554	Void TEncSbac::store( TEncSbac* pDest) const
555	{
556	pDest->xCopyFrom( this );
557	}
558
559
560	Void TEncSbac::xCopyFrom( const TEncSbac* pSrc )
561	{
562	m_pcBinIf->copyState( pSrc->m_pcBinIf );
563	xCopyContextsFrom(pSrc);
564	}
565
566	Void TEncSbac::codeMVPIdx ( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList )
567	{
568	Int iSymbol = pcCU->getMVPIdx(eRefList, uiAbsPartIdx);
569	Int iNum = AMVP_MAX_NUM_CANDS;
570
571	xWriteUnaryMaxSymbol(iSymbol, m_cMVPIdxSCModel.get(0), 1, iNum-1);
572	#if H_MV_ENC_DEC_TRAC
573	#if ENC_DEC_TRACE
574	if ( eRefList == REF_PIC_LIST_0 )
575	{
576	DTRACE_PU("mvp_l0_flag", iSymbol)
577	}
578	else
579	{
580	DTRACE_PU("mvp_l1_flag", iSymbol)
581	}
582	#endif
583	#endif
584	}
585
586	Void TEncSbac::codePartSize( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
587	{
588	PartSize eSize = pcCU->getPartitionSize( uiAbsPartIdx );
589	#if H_3D_QTLPC
590	Bool bLimQtPredFlag = pcCU->getPic()->getSlice(0)->getQtPredFlag();
591	TComPic *pcTexture = pcCU->getSlice()->getTexturePic();
592	Bool bDepthMapDetect = (pcTexture != NULL);
593	Bool bIntraSliceDetect = (pcCU->getSlice()->getSliceType() == I_SLICE);
594
595	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);
596
597	Bool depthDependent = false;
598	UInt uiTexturePart = eSize;
599
600	#if H_3D_FCO
601	if(bDepthMapDetect && !bIntraSliceDetect && !rapPic && pcCU->getPic()->getReduceBitsFlag() && bLimQtPredFlag && pcTexture->getReconMark())
602	#else
603	if(bDepthMapDetect && !bIntraSliceDetect && !rapPic && pcCU->getPic()->getReduceBitsFlag() && bLimQtPredFlag )
604	#endif
605	{
606	TComDataCU *pcTextureCU = pcTexture->getCU(pcCU->getAddr());
607	UInt uiCUIdx = (pcCU->getZorderIdxInCU() == 0) ? uiAbsPartIdx : pcCU->getZorderIdxInCU();
608	assert(pcTextureCU->getDepth(uiCUIdx) >= uiDepth);
609	if(pcTextureCU->getDepth(uiCUIdx) == uiDepth )
610	{
611	depthDependent = true;
612	uiTexturePart = pcTextureCU->getPartitionSize( uiCUIdx );
613	}
614	if (pcTextureCU->getDepth(uiCUIdx) == uiDepth && pcTextureCU->getPartitionSize( uiCUIdx ) == SIZE_2Nx2N)
615	{
616	assert( eSize == SIZE_2Nx2N );
617	return;
618	}
619	}
620	#endif
621	const UInt log2DiffMaxMinCodingBlockSize = pcCU->getSlice()->getSPS()->getLog2DiffMaxMinCodingBlockSize();
622
623	if ( pcCU->isIntra( uiAbsPartIdx ) )
624	{
625	if( uiDepth == log2DiffMaxMinCodingBlockSize )
626	{
627	m_pcBinIf->encodeBin( eSize == SIZE_2Nx2N? 1 : 0, m_cCUPartSizeSCModel.get( 0, 0, 0 ) );
628	#if H_MV_ENC_DEC_TRAC
629	DTRACE_CU("part_mode", eSize == SIZE_2Nx2N? 1 : 0)
630	#endif
631
632	}
633	return;
634	}
635	#if H_MV_ENC_DEC_TRAC
636	DTRACE_CU("part_mode", eSize )
637	#endif
638	#if H_3D_QTLPC
639	if (depthDependent==false \|\| uiTexturePart == SIZE_NxN\|\| uiTexturePart == SIZE_2Nx2N)
640	{
641	#endif
642
643	switch(eSize)
644	{
645	case SIZE_2Nx2N:
646	{
647	m_pcBinIf->encodeBin( 1, m_cCUPartSizeSCModel.get( 0, 0, 0) );
648	break;
649	}
650	case SIZE_2NxN:
651	case SIZE_2NxnU:
652	case SIZE_2NxnD:
653	{
654	m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 0) );
655	m_pcBinIf->encodeBin( 1, m_cCUPartSizeSCModel.get( 0, 0, 1) );
656	if ( pcCU->getSlice()->getSPS()->getUseAMP() && uiDepth < log2DiffMaxMinCodingBlockSize )
657	{
658	if (eSize == SIZE_2NxN)
659	{
660	m_pcBinIf->encodeBin(1, m_cCUPartSizeSCModel.get( 0, 0, 3 ));
661	}
662	else
663	{
664	m_pcBinIf->encodeBin(0, m_cCUPartSizeSCModel.get( 0, 0, 3 ));
665	m_pcBinIf->encodeBinEP((eSize == SIZE_2NxnU? 0: 1));
666	}
667	}
668	break;
669	}
670	case SIZE_Nx2N:
671	case SIZE_nLx2N:
672	case SIZE_nRx2N:
673	{
674	m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 0) );
675	m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 1) );
676
677	if( uiDepth == log2DiffMaxMinCodingBlockSize && !( pcCU->getWidth(uiAbsPartIdx) == 8 && pcCU->getHeight(uiAbsPartIdx) == 8 ) )
678	{
679	m_pcBinIf->encodeBin( 1, m_cCUPartSizeSCModel.get( 0, 0, 2) );
680	}
681
682	if ( pcCU->getSlice()->getSPS()->getUseAMP() && uiDepth < log2DiffMaxMinCodingBlockSize )
683	{
684	if (eSize == SIZE_Nx2N)
685	{
686	m_pcBinIf->encodeBin(1, m_cCUPartSizeSCModel.get( 0, 0, 3 ));
687	}
688	else
689	{
690	m_pcBinIf->encodeBin(0, m_cCUPartSizeSCModel.get( 0, 0, 3 ));
691	m_pcBinIf->encodeBinEP((eSize == SIZE_nLx2N? 0: 1));
692	}
693	}
694	break;
695	}
696	case SIZE_NxN:
697	{
698	if( uiDepth == log2DiffMaxMinCodingBlockSize && !( pcCU->getWidth(uiAbsPartIdx) == 8 && pcCU->getHeight(uiAbsPartIdx) == 8 ) )
699	{
700	m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 0) );
701	m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 1) );
702	m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 2) );
703	}
704	break;
705	}
706	default:
707	{
708	assert(0);
709	break;
710	}
711	}
712	#if H_3D_QTLPC
713	}
714	else if(uiTexturePart == SIZE_2NxN \|\| uiTexturePart == SIZE_2NxnU \|\| uiTexturePart == SIZE_2NxnD)
715	{
716	//assert(eSize!=SIZE_NxN);
717	//assert(eSize!=SIZE_Nx2N);
718	//assert(eSize==SIZE_2Nx2N \|\| eSize==SIZE_2NxN \|\| eSize==SIZE_2NxnU \|\| eSize==SIZE_2NxnD);
719	switch(eSize)
720	{
721	case SIZE_2Nx2N:
722	{
723	m_pcBinIf->encodeBin( 1, m_cCUPartSizeSCModel.get( 0, 0, 0) );
724	break;
725	}
726	case SIZE_2NxN:
727	{
728	m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 0) );
729	if ( pcCU->getSlice()->getSPS()->getAMPAcc( uiDepth ) )
730	{
731	m_pcBinIf->encodeBin( 1, m_cCUPartSizeSCModel.get( 0, 0, 1) );
732	}
733	break;
734	}
735	case SIZE_2NxnU:
736	case SIZE_2NxnD:
737	{
738	m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 0) );
739	m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 1) );
740	m_pcBinIf->encodeBinEP((eSize == SIZE_2NxnU? 0: 1));
741	break;
742	}
743	default:
744	{
745	assert(0);
746	}
747	}
748	}
749	else if(uiTexturePart == SIZE_Nx2N\|\| uiTexturePart==SIZE_nLx2N \|\| uiTexturePart==SIZE_nRx2N)
750	{
751	//assert(eSize!=SIZE_NxN);
752	//assert(eSize!=SIZE_2NxN);
753	//assert(eSize==SIZE_2Nx2N \|\|eSize==SIZE_Nx2N \|\| eSize==SIZE_nLx2N \|\| eSize==SIZE_nRx2N);
754	switch(eSize)
755	{
756	case SIZE_2Nx2N:
757	{
758	m_pcBinIf->encodeBin( 1, m_cCUPartSizeSCModel.get( 0, 0, 0) );
759	break;
760	}
761	case SIZE_Nx2N:
762	{
763	m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 0) );
764	if ( pcCU->getSlice()->getSPS()->getAMPAcc( uiDepth ) )
765	{
766	m_pcBinIf->encodeBin( 1, m_cCUPartSizeSCModel.get( 0, 0, 1) );
767	}
768	break;
769	}
770	case SIZE_nLx2N:
771	case SIZE_nRx2N:
772	{
773	m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 0) );
774	m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 1) );
775	m_pcBinIf->encodeBinEP((eSize == SIZE_nLx2N? 0: 1));
776	break;
777	}
778	default:
779	{
780	assert(0);
781	}
782	}
783	}
784	else
785	{
786	printf("uiTexturePart=%d",uiTexturePart);
787	assert(0);
788	}
789	#endif
790
791	}
792
793
794	/** code prediction mode
795	* \param pcCU
796	* \param uiAbsPartIdx
797	* \returns Void
798	*/
799	Void TEncSbac::codePredMode( TComDataCU* pcCU, UInt uiAbsPartIdx )
800	{
801	#if H_3D_DIM_SDC
802	if ( pcCU->getSlice()->isIntra() )
803	{
804	assert( pcCU->isIntra(uiAbsPartIdx) );
805	return;
806	}
807	#endif
808
809	// get context function is here
810	m_pcBinIf->encodeBin( pcCU->isIntra( uiAbsPartIdx ) ? 1 : 0, m_cCUPredModeSCModel.get( 0, 0, 0 ) );
811	#if H_MV_ENC_DEC_TRAC
812	DTRACE_CU("pred_mode_flag", pcCU->isIntra( uiAbsPartIdx ) ? 1 : 0);
813	#endif
814
815	}
816
817	Void TEncSbac::codeCUTransquantBypassFlag( TComDataCU* pcCU, UInt uiAbsPartIdx )
818	{
819	UInt uiSymbol = pcCU->getCUTransquantBypass(uiAbsPartIdx);
820	m_pcBinIf->encodeBin( uiSymbol, m_CUTransquantBypassFlagSCModel.get( 0, 0, 0 ) );
821	#if H_MV_ENC_DEC_TRAC
822	DTRACE_CU("cu_transquant_bypass_flag", uiSymbol);
823	#endif
824
825	}
826
827	/** code skip flag
828	* \param pcCU
829	* \param uiAbsPartIdx
830	* \returns Void
831	*/
832	Void TEncSbac::codeSkipFlag( TComDataCU* pcCU, UInt uiAbsPartIdx )
833	{
834	// get context function is here
835	UInt uiSymbol = pcCU->isSkipped( uiAbsPartIdx ) ? 1 : 0;
836	UInt uiCtxSkip = pcCU->getCtxSkipFlag( uiAbsPartIdx ) ;
837	m_pcBinIf->encodeBin( uiSymbol, m_cCUSkipFlagSCModel.get( 0, 0, uiCtxSkip ) );
838	#if !H_MV_ENC_DEC_TRAC
839	DTRACE_CABAC_VL( g_nSymbolCounter++ );
840	DTRACE_CABAC_T( "\tSkipFlag" );
841	DTRACE_CABAC_T( "\tuiCtxSkip: ");
842	DTRACE_CABAC_V( uiCtxSkip );
843	DTRACE_CABAC_T( "\tuiSymbol: ");
844	DTRACE_CABAC_V( uiSymbol );
845	DTRACE_CABAC_T( "\n");
846	#else
847	DTRACE_CU("cu_skip_flag", uiSymbol);
848	#endif
849	}
850
851	/** code merge flag
852	* \param pcCU
853	* \param uiAbsPartIdx
854	* \returns Void
855	*/
856	Void TEncSbac::codeMergeFlag( TComDataCU* pcCU, UInt uiAbsPartIdx )
857	{
858	const UInt uiSymbol = pcCU->getMergeFlag( uiAbsPartIdx ) ? 1 : 0;
859	m_pcBinIf->encodeBin( uiSymbol, *m_cCUMergeFlagExtSCModel.get( 0 ) );
860
861	#if H_MV_ENC_DEC_TRAC
862	DTRACE_PU("merge_flag", uiSymbol);
863	#else
864	DTRACE_CABAC_VL( g_nSymbolCounter++ );
865	DTRACE_CABAC_T( "\tMergeFlag: " );
866	DTRACE_CABAC_V( uiSymbol );
867	DTRACE_CABAC_T( "\tAddress: " );
868	DTRACE_CABAC_V( pcCU->getCtuRsAddr() );
869	DTRACE_CABAC_T( "\tuiAbsPartIdx: " );
870	DTRACE_CABAC_V( uiAbsPartIdx );
871	DTRACE_CABAC_T( "\n" );
872	#endif
873	}
874
875	/** code merge index
876	* \param pcCU
877	* \param uiAbsPartIdx
878	* \returns Void
879	*/
880	Void TEncSbac::codeMergeIndex( TComDataCU* pcCU, UInt uiAbsPartIdx )
881	{
882	UInt uiUnaryIdx = pcCU->getMergeIndex( uiAbsPartIdx );
883	UInt uiNumCand = pcCU->getSlice()->getMaxNumMergeCand();
884	if ( uiNumCand > 1 )
885	{
886	for( UInt ui = 0; ui < uiNumCand - 1; ++ui )
887	{
888	const UInt uiSymbol = ui == uiUnaryIdx ? 0 : 1;
889	if ( ui==0 )
890	{
891	m_pcBinIf->encodeBin( uiSymbol, m_cCUMergeIdxExtSCModel.get( 0, 0, 0 ) );
892	}
893	else
894	{
895	m_pcBinIf->encodeBinEP( uiSymbol );
896	}
897	if( uiSymbol == 0 )
898	{
899	break;
900	}
901	}
902	#if H_MV_ENC_DEC_TRAC
903	DTRACE_PU("merge_idx", uiUnaryIdx);
904	#endif
905	}
906	#if !H_MV_ENC_DEC_TRAC
907	DTRACE_CABAC_VL( g_nSymbolCounter++ );
908	DTRACE_CABAC_T( "\tparseMergeIndex()" );
909	DTRACE_CABAC_T( "\tuiMRGIdx= " );
910	DTRACE_CABAC_V( pcCU->getMergeIndex( uiAbsPartIdx ) );
911	DTRACE_CABAC_T( "\n" );
912	#endif
913	}
914
915	#if H_3D_ARP
916	Void TEncSbac::codeARPW( TComDataCU* pcCU, UInt uiAbsPartIdx )
917	{
918	Int iW = (Int)pcCU->getARPW( uiAbsPartIdx );
919	Int iMaxW = pcCU->getSlice()->getARPStepNum() - 1;
920	assert( iMaxW > 0);
921
922	Int nOffset = pcCU->getCTXARPWFlag(uiAbsPartIdx);
923	Int nBinNum = iW + ( iW != iMaxW );
924	m_pcBinIf->encodeBin( iW ? 1 : 0 , m_cCUPUARPWSCModel.get( 0, 0, 0 + nOffset ) );
925	if( nBinNum > 1 )
926	{
927	m_pcBinIf->encodeBin( ( iW == iMaxW ) ? 1 : 0, m_cCUPUARPWSCModel.get( 0, 0, 2 ) );
928	}
929	#if H_MV_ENC_DEC_TRAC
930	DTRACE_CU("iv_res_pred_weight_idx", iW);
931	#endif
932	}
933	#endif
934
935	#if H_3D_IC
936	/** code Illumination Compensation flag
937	* \param pcCU
938	* \param uiAbsPartIdx
939	* \returns Void
940	*/
941	Void TEncSbac::codeICFlag( TComDataCU* pcCU, UInt uiAbsPartIdx )
942	{
943	// get context function is here
944	UInt uiSymbol = pcCU->getICFlag( uiAbsPartIdx ) ? 1 : 0;
945	m_pcBinIf->encodeBin( uiSymbol, m_cCUICFlagSCModel.get( 0, 0, 0 ) );
946	#if !H_MV_ENC_DEC_TRAC
947	DTRACE_CABAC_VL( g_nSymbolCounter++ );
948	DTRACE_CABAC_T( "\tICFlag" );
949	DTRACE_CABAC_T( "\tuiSymbol: ");
950	DTRACE_CABAC_V( uiSymbol );
951	DTRACE_CABAC_T( "\n");
952	#else
953	DTRACE_CU("ic_flag", uiSymbol );
954	#endif
955	}
956	#endif
957
958
959	Void TEncSbac::codeSplitFlag ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
960	{
961	if( uiDepth == pcCU->getSlice()->getSPS()->getLog2DiffMaxMinCodingBlockSize() )
962	{
963	return;
964	}
965
966	UInt uiCtx = pcCU->getCtxSplitFlag( uiAbsPartIdx, uiDepth );
967	UInt uiCurrSplitFlag = ( pcCU->getDepth( uiAbsPartIdx ) > uiDepth ) ? 1 : 0;
968
969	assert( uiCtx < 3 );
970	#if H_3D_QTLPC
971	Bool bCodeSplitFlag = true;
972
973
974	Bool bLimQtPredFlag = pcCU->getPic()->getSlice(0)->getQtPredFlag();
975	TComPic *pcTexture = pcCU->getSlice()->getTexturePic();
976	Bool bDepthMapDetect = (pcTexture != NULL);
977	Bool bIntraSliceDetect = (pcCU->getSlice()->getSliceType() == I_SLICE);
978
979	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);
980
981	#if H_3D_FCO
982	if(bDepthMapDetect && !bIntraSliceDetect && !rapPic && pcCU->getPic()->getReduceBitsFlag() && bLimQtPredFlag && pcTexture->getReconMark() )
983	#else
984	if(bDepthMapDetect && !bIntraSliceDetect && !rapPic && pcCU->getPic()->getReduceBitsFlag() && bLimQtPredFlag )
985	#endif
986	{
987	TComDataCU *pcTextureCU = pcTexture->getCU(pcCU->getAddr());
988	UInt uiCUIdx = (pcCU->getZorderIdxInCU() == 0) ? uiAbsPartIdx : pcCU->getZorderIdxInCU();
989	assert(pcTextureCU->getDepth(uiCUIdx) >= uiDepth);
990	bCodeSplitFlag = (pcTextureCU->getDepth(uiCUIdx) > uiDepth);
991	}
992
993	if(!bCodeSplitFlag)
994	{
995	assert(uiCurrSplitFlag == 0);
996	return;
997	}
998	#endif
999
1000	m_pcBinIf->encodeBin( uiCurrSplitFlag, m_cCUSplitFlagSCModel.get( 0, 0, uiCtx ) );
1001	#if !H_MV_ENC_DEC_TRAC
1002	DTRACE_CABAC_VL( g_nSymbolCounter++ )
1003	DTRACE_CABAC_T( "\tSplitFlag\n" )
1004	#else
1005	DTRACE_CU("split_cu_flag", uiCurrSplitFlag );
1006	#endif
1007	return;
1008	}
1009
1010	Void TEncSbac::codeTransformSubdivFlag( UInt uiSymbol, UInt uiCtx )
1011	{
1012	m_pcBinIf->encodeBin( uiSymbol, m_cCUTransSubdivFlagSCModel.get( 0, 0, uiCtx ) );
1013	#if !H_MV_ENC_DEC_TRAC
1014	DTRACE_CABAC_VL( g_nSymbolCounter++ )
1015	DTRACE_CABAC_T( "\tparseTransformSubdivFlag()" )
1016	DTRACE_CABAC_T( "\tsymbol=" )
1017	DTRACE_CABAC_V( uiSymbol )
1018	DTRACE_CABAC_T( "\tctx=" )
1019	DTRACE_CABAC_V( uiCtx )
1020	DTRACE_CABAC_T( "\n" )
1021	#else
1022	DTRACE_TU("split_transform_flag", uiSymbol )
1023	#endif
1024
1025	}
1026
1027
1028	Void TEncSbac::codeIntraDirLumaAng( TComDataCU* pcCU, UInt absPartIdx, Bool isMultiple)
1029	{
1030	UInt dir[4],j;
1031	Int preds[4][NUM_MOST_PROBABLE_MODES] = {{-1, -1, -1},{-1, -1, -1},{-1, -1, -1},{-1, -1, -1}};
1032	Int predIdx[4] ={ -1,-1,-1,-1};
1033	PartSize mode = pcCU->getPartitionSize( absPartIdx );
1034	UInt partNum = isMultiple?(mode==SIZE_NxN?4:1):1;
1035	UInt partOffset = ( pcCU->getPic()->getNumPartitionsInCtu() >> ( pcCU->getDepth(absPartIdx) << 1 ) ) >> 2;
1036	for (j=0;j<partNum;j++)
1037	{
1038	dir[j] = pcCU->getIntraDir( CHANNEL_TYPE_LUMA, absPartIdx+partOffset*j );
1039	#if NH_3D_DMM
1040	if( pcCU->getSlice()->getIntraSdcWedgeFlag() \|\| pcCU->getSlice()->getIntraContourFlag() )
1041	{
1042	xCodeIntraDepthMode( pcCU, absPartIdx+partOffset*j );
1043	xCodeDmmData ( pcCU, absPartIdx+partOffset*j );
1044	}
1045	if( pcCU->getIntraDir( CHANNEL_TYPE_LUMA, absPartIdx+partOffset*j ) < NUM_INTRA_MODE )
1046	{
1047	#endif
1048	pcCU->getIntraDirPredictor(absPartIdx+partOffset*j, preds[j], COMPONENT_Y);
1049	for(UInt i = 0; i < NUM_MOST_PROBABLE_MODES; i++)
1050	{
1051	if(dir[j] == preds[j][i])
1052	{
1053	predIdx[j] = i;
1054	}
1055	}
1056	m_pcBinIf->encodeBin((predIdx[j] != -1)? 1 : 0, m_cCUIntraPredSCModel.get( 0, 0, 0 ) );
1057	#if H_MV_ENC_DEC_TRAC
1058	DTRACE_CU("prev_intra_luma_pred_flag", (predIdx[j] != -1)? 1 : 0);
1059	#endif
1060	#if NH_3D_DMM
1061	}
1062	#endif
1063
1064	}
1065	for (j=0;j<partNum;j++)
1066	{
1067	#if NH_3D_DMM
1068	if( pcCU->getIntraDir( CHANNEL_TYPE_LUMA, absPartIdx+partOffset*j ) < NUM_INTRA_MODE )
1069	{
1070	#endif
1071	if(predIdx[j] != -1)
1072	{
1073	m_pcBinIf->encodeBinEP( predIdx[j] ? 1 : 0 );
1074	if (predIdx[j])
1075	{
1076	m_pcBinIf->encodeBinEP( predIdx[j]-1 );
1077	}
1078	#if H_MV_ENC_DEC_TRAC
1079	DTRACE_CU("mpm_idx", predIdx[j] );
1080	#endif
1081	}
1082	else
1083	{
1084	if (preds[j][0] > preds[j][1])
1085	{
1086	std::swap(preds[j][0], preds[j][1]);
1087	}
1088	if (preds[j][0] > preds[j][2])
1089	{
1090	std::swap(preds[j][0], preds[j][2]);
1091	}
1092	if (preds[j][1] > preds[j][2])
1093	{
1094	std::swap(preds[j][1], preds[j][2]);
1095	}
1096	for(Int i = (Int(NUM_MOST_PROBABLE_MODES) - 1); i >= 0; i--)
1097	{
1098	dir[j] = dir[j] > preds[j][i] ? dir[j] - 1 : dir[j];
1099	}
1100	m_pcBinIf->encodeBinsEP( dir[j], 5 );
1101	#if H_MV_ENC_DEC_TRAC
1102	DTRACE_CU("rem_intra_luma_pred_mode", dir[j] );
1103	#endif
1104	}
1105	#if NH_3D_DMM
1106	}
1107	#endif
1108	}
1109	return;
1110	}
1111
1112	Void TEncSbac::codeIntraDirChroma( TComDataCU* pcCU, UInt uiAbsPartIdx )
1113	{
1114	UInt uiIntraDirChroma = pcCU->getIntraDir( CHANNEL_TYPE_CHROMA, uiAbsPartIdx );
1115
1116	if( uiIntraDirChroma == DM_CHROMA_IDX )
1117	{
1118	m_pcBinIf->encodeBin( 0, m_cCUChromaPredSCModel.get( 0, 0, 0 ) );
1119	#if H_MV_ENC_DEC_TRAC
1120	DTRACE_CU("intra_chroma_pred_mode", 0 );
1121	#endif
1122	}
1123	else
1124	{
1125	m_pcBinIf->encodeBin( 1, m_cCUChromaPredSCModel.get( 0, 0, 0 ) );
1126
1127	UInt uiAllowedChromaDir[ NUM_CHROMA_MODE ];
1128	pcCU->getAllowedChromaDir( uiAbsPartIdx, uiAllowedChromaDir );
1129
1130	for( Int i = 0; i < NUM_CHROMA_MODE - 1; i++ )
1131	{
1132	if( uiIntraDirChroma == uiAllowedChromaDir[i] )
1133	{
1134	uiIntraDirChroma = i;
1135	break;
1136	}
1137	}
1138
1139	m_pcBinIf->encodeBinsEP( uiIntraDirChroma, 2 );
1140	#if H_MV_ENC_DEC_TRAC
1141	DTRACE_CU("intra_chroma_pred_mode", uiIntraDirChroma );
1142	#endif
1143
1144	}
1145
1146	return;
1147	}
1148
1149	Void TEncSbac::codeInterDir( TComDataCU* pcCU, UInt uiAbsPartIdx )
1150	{
1151	const UInt uiInterDir = pcCU->getInterDir( uiAbsPartIdx ) - 1;
1152	const UInt uiCtx = pcCU->getCtxInterDir( uiAbsPartIdx );
1153	ContextModel *pCtx = m_cCUInterDirSCModel.get( 0 );
1154
1155	if (pcCU->getPartitionSize(uiAbsPartIdx) == SIZE_2Nx2N \|\| pcCU->getHeight(uiAbsPartIdx) != 8 )
1156	{
1157	m_pcBinIf->encodeBin( uiInterDir == 2 ? 1 : 0, *( pCtx + uiCtx ) );
1158	}
1159
1160	if (uiInterDir < 2)
1161	{
1162	m_pcBinIf->encodeBin( uiInterDir, *( pCtx + 4 ) );
1163	}
1164	#if H_MV_ENC_DEC_TRAC
1165	DTRACE_PU("inter_pred_idc", uiInterDir );
1166	#endif
1167
1168	return;
1169	}
1170
1171	Void TEncSbac::codeRefFrmIdx( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList )
1172	{
1173	Int iRefFrame = pcCU->getCUMvField( eRefList )->getRefIdx( uiAbsPartIdx );
1174	ContextModel *pCtx = m_cCURefPicSCModel.get( 0 );
1175	m_pcBinIf->encodeBin( ( iRefFrame == 0 ? 0 : 1 ), *pCtx );
1176
1177	if( iRefFrame > 0 )
1178	{
1179	UInt uiRefNum = pcCU->getSlice()->getNumRefIdx( eRefList ) - 2;
1180	pCtx++;
1181	iRefFrame--;
1182	for( UInt ui = 0; ui < uiRefNum; ++ui )
1183	{
1184	const UInt uiSymbol = ui == iRefFrame ? 0 : 1;
1185	if( ui == 0 )
1186	{
1187	m_pcBinIf->encodeBin( uiSymbol, *pCtx );
1188	}
1189	else
1190	{
1191	m_pcBinIf->encodeBinEP( uiSymbol );
1192	}
1193	if( uiSymbol == 0 )
1194	{
1195	break;
1196	}
1197	}
1198	}
1199	#if H_MV_ENC_DEC_TRAC
1200	#if ENC_DEC_TRACE
1201	iRefFrame = pcCU->getCUMvField( eRefList )->getRefIdx( uiAbsPartIdx );
1202	if ( eRefList == REF_PIC_LIST_0 )
1203	{
1204	DTRACE_PU("ref_idx_l0", iRefFrame)
1205	}
1206	else
1207	{
1208	DTRACE_PU("ref_idx_l1", iRefFrame)
1209	}
1210	#endif
1211	#endif
1212	return;
1213	}
1214
1215	Void TEncSbac::codeMvd( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList )
1216	{
1217	if(pcCU->getSlice()->getMvdL1ZeroFlag() && eRefList == REF_PIC_LIST_1 && pcCU->getInterDir(uiAbsPartIdx)==3)
1218	{
1219	return;
1220	}
1221
1222	const TComCUMvField* pcCUMvField = pcCU->getCUMvField( eRefList );
1223	const Int iHor = pcCUMvField->getMvd( uiAbsPartIdx ).getHor();
1224	const Int iVer = pcCUMvField->getMvd( uiAbsPartIdx ).getVer();
1225	ContextModel* pCtx = m_cCUMvdSCModel.get( 0 );
1226
1227	m_pcBinIf->encodeBin( iHor != 0 ? 1 : 0, *pCtx );
1228	m_pcBinIf->encodeBin( iVer != 0 ? 1 : 0, *pCtx );
1229
1230	const Bool bHorAbsGr0 = iHor != 0;
1231	const Bool bVerAbsGr0 = iVer != 0;
1232	const UInt uiHorAbs = 0 > iHor ? -iHor : iHor;
1233	const UInt uiVerAbs = 0 > iVer ? -iVer : iVer;
1234	pCtx++;
1235
1236	if( bHorAbsGr0 )
1237	{
1238	m_pcBinIf->encodeBin( uiHorAbs > 1 ? 1 : 0, *pCtx );
1239	}
1240
1241	if( bVerAbsGr0 )
1242	{
1243	m_pcBinIf->encodeBin( uiVerAbs > 1 ? 1 : 0, *pCtx );
1244	}
1245
1246	if( bHorAbsGr0 )
1247	{
1248	if( uiHorAbs > 1 )
1249	{
1250	xWriteEpExGolomb( uiHorAbs-2, 1 );
1251	}
1252
1253	m_pcBinIf->encodeBinEP( 0 > iHor ? 1 : 0 );
1254	}
1255
1256	if( bVerAbsGr0 )
1257	{
1258	if( uiVerAbs > 1 )
1259	{
1260	xWriteEpExGolomb( uiVerAbs-2, 1 );
1261	}
1262
1263	m_pcBinIf->encodeBinEP( 0 > iVer ? 1 : 0 );
1264	}
1265
1266	return;
1267	}
1268
1269	Void TEncSbac::codeCrossComponentPrediction( TComTU &rTu, ComponentID compID )
1270	{
1271	TComDataCU *pcCU = rTu.getCU();
1272
1273	if( isLuma(compID) \|\| !pcCU->getSlice()->getPPS()->getPpsRangeExtension().getCrossComponentPredictionEnabledFlag() )
1274	{
1275	return;
1276	}
1277
1278	const UInt uiAbsPartIdx = rTu.GetAbsPartIdxTU();
1279
1280	if (!pcCU->isIntra(uiAbsPartIdx) \|\| (pcCU->getIntraDir( CHANNEL_TYPE_CHROMA, uiAbsPartIdx ) == DM_CHROMA_IDX))
1281	{
1282	DTRACE_CABAC_VL( g_nSymbolCounter++ )
1283	DTRACE_CABAC_T("\tparseCrossComponentPrediction()")
1284	DTRACE_CABAC_T( "\tAddr=" )
1285	DTRACE_CABAC_V( compID )
1286	DTRACE_CABAC_T( "\tuiAbsPartIdx=" )
1287	DTRACE_CABAC_V( uiAbsPartIdx )
1288
1289	Int alpha = pcCU->getCrossComponentPredictionAlpha( uiAbsPartIdx, compID );
1290	ContextModel *pCtx = m_cCrossComponentPredictionSCModel.get(0, 0) + ((compID == COMPONENT_Cr) ? (NUM_CROSS_COMPONENT_PREDICTION_CTX >> 1) : 0);
1291	m_pcBinIf->encodeBin(((alpha != 0) ? 1 : 0), pCtx[0]);
1292
1293	if (alpha != 0)
1294	{
1295	static const Int log2AbsAlphaMinus1Table[8] = { 0, 1, 1, 2, 2, 2, 3, 3 };
1296	assert(abs(alpha) <= 8);
1297
1298	if (abs(alpha)>1)
1299	{
1300	m_pcBinIf->encodeBin(1, pCtx[1]);
1301	xWriteUnaryMaxSymbol( log2AbsAlphaMinus1Table[abs(alpha) - 1] - 1, (pCtx + 2), 1, 2 );
1302	}
1303	else
1304	{
1305	m_pcBinIf->encodeBin(0, pCtx[1]);
1306	}
1307	m_pcBinIf->encodeBin( ((alpha < 0) ? 1 : 0), pCtx[4] );
1308	}
1309	DTRACE_CABAC_T( "\tAlpha=" )
1310	DTRACE_CABAC_V( pcCU->getCrossComponentPredictionAlpha( uiAbsPartIdx, compID ) )
1311	DTRACE_CABAC_T( "\n" )
1312	}
1313	}
1314
1315	Void TEncSbac::codeDeltaQP( TComDataCU* pcCU, UInt uiAbsPartIdx )
1316	{
1317	Int iDQp = pcCU->getQP( uiAbsPartIdx ) - pcCU->getRefQP( uiAbsPartIdx );
1318
1319	Int qpBdOffsetY = pcCU->getSlice()->getSPS()->getQpBDOffset(CHANNEL_TYPE_LUMA);
1320	iDQp = (iDQp + 78 + qpBdOffsetY + (qpBdOffsetY/2)) % (52 + qpBdOffsetY) - 26 - (qpBdOffsetY/2);
1321
1322	UInt uiAbsDQp = (UInt)((iDQp > 0)? iDQp : (-iDQp));
1323	UInt TUValue = min((Int)uiAbsDQp, CU_DQP_TU_CMAX);
1324	xWriteUnaryMaxSymbol( TUValue, &m_cCUDeltaQpSCModel.get( 0, 0, 0 ), 1, CU_DQP_TU_CMAX);
1325	if( uiAbsDQp >= CU_DQP_TU_CMAX )
1326	{
1327	xWriteEpExGolomb( uiAbsDQp - CU_DQP_TU_CMAX, CU_DQP_EG_k );
1328	}
1329
1330	if ( uiAbsDQp > 0)
1331	{
1332	UInt uiSign = (iDQp > 0 ? 0 : 1);
1333	m_pcBinIf->encodeBinEP(uiSign);
1334	}
1335
1336	return;
1337	}
1338
1339	/** code chroma qp adjustment, converting from the internal table representation
1340	* \returns Void
1341	*/
1342	Void TEncSbac::codeChromaQpAdjustment( TComDataCU* cu, UInt absPartIdx )
1343	{
1344	Int internalIdc = cu->getChromaQpAdj( absPartIdx );
1345	Int chromaQpOffsetListLen = cu->getSlice()->getPPS()->getPpsRangeExtension().getChromaQpOffsetListLen();
1346	/* internal_idc == 0 => flag = 0
1347	* internal_idc > 1 => code idc value (if table size warrents) */
1348	m_pcBinIf->encodeBin( internalIdc > 0, m_ChromaQpAdjFlagSCModel.get( 0, 0, 0 ) );
1349
1350	if (internalIdc > 0 && chromaQpOffsetListLen > 1)
1351	{
1352	xWriteUnaryMaxSymbol( internalIdc - 1, &m_ChromaQpAdjIdcSCModel.get( 0, 0, 0 ), 0, chromaQpOffsetListLen - 1 );
1353	}
1354	}
1355
1356	Void TEncSbac::codeQtCbf( TComTU &rTu, const ComponentID compID, const Bool lowestLevel )
1357	{
1358	TComDataCU* pcCU = rTu.getCU();
1359
1360	const UInt absPartIdx = rTu.GetAbsPartIdxTU(compID);
1361	const UInt TUDepth = rTu.GetTransformDepthRel();
1362	UInt uiCtx = pcCU->getCtxQtCbf( rTu, toChannelType(compID) );
1363	const UInt contextSet = toChannelType(compID);
1364
1365	const UInt width = rTu.getRect(compID).width;
1366	const UInt height = rTu.getRect(compID).height;
1367	const Bool canQuadSplit = (width >= (MIN_TU_SIZE * 2)) && (height >= (MIN_TU_SIZE * 2));
1368
1369	// Since the CBF for chroma is coded at the highest level possible, if sub-TUs are
1370	// to be coded for a 4x8 chroma TU, their CBFs must be coded at the highest 4x8 level
1371	// (i.e. where luma TUs are 8x8 rather than 4x4)
1372	// ___ ___
1373	// \| \| \| <- 4 x (8x8 luma + 4x8 4:2:2 chroma)
1374	// \|___\|___\| each quadrant has its own chroma CBF
1375	// \| \| \| _ _ _ _
1376	// \|___\|___\| \|
1377	// <--16---> V
1378	// _ _
1379	// \|_\|_\| <- 4 x 4x4 luma + 1 x 4x8 4:2:2 chroma
1380	// \|_\|_\| no chroma CBF is coded - instead the parent CBF is inherited
1381	// <-8-> if sub-TUs are present, their CBFs had to be coded at the parent level
1382
1383	const UInt lowestTUDepth = TUDepth + ((!lowestLevel && !canQuadSplit) ? 1 : 0); //unsplittable TUs inherit their parent's CBF
1384
1385	if ((width != height) && (lowestLevel \|\| !canQuadSplit)) //if sub-TUs are present
1386	{
1387	const UInt subTUDepth = lowestTUDepth + 1; //if this is the lowest level of the TU-tree, the sub-TUs are directly below. Otherwise, this must be the level above the lowest level (as specified above)
1388	const UInt partIdxesPerSubTU = rTu.GetAbsPartIdxNumParts(compID) >> 1;
1389
1390	for (UInt subTU = 0; subTU < 2; subTU++)
1391	{
1392	const UInt subTUAbsPartIdx = absPartIdx + (subTU * partIdxesPerSubTU);
1393	const UInt uiCbf = pcCU->getCbf(subTUAbsPartIdx, compID, subTUDepth);
1394
1395	m_pcBinIf->encodeBin(uiCbf, m_cCUQtCbfSCModel.get(0, contextSet, uiCtx));
1396	#if !H_MV_ENC_DEC_TRAC
1397	DTRACE_CABAC_VL( g_nSymbolCounter++ )
1398	DTRACE_CABAC_T( "\tparseQtCbf()" )
1399	DTRACE_CABAC_T( "\tsub-TU=" )
1400	DTRACE_CABAC_V( subTU )
1401	DTRACE_CABAC_T( "\tsymbol=" )
1402	DTRACE_CABAC_V( uiCbf )
1403	DTRACE_CABAC_T( "\tctx=" )
1404	DTRACE_CABAC_V( uiCtx )
1405	DTRACE_CABAC_T( "\tetype=" )
1406	DTRACE_CABAC_V( compID )
1407	DTRACE_CABAC_T( "\tuiAbsPartIdx=" )
1408	DTRACE_CABAC_V( subTUAbsPartIdx )
1409	DTRACE_CABAC_T( "\n" )
1410	#else
1411	if ( compID == COMPONENT_Cb )
1412	{
1413	DTRACE_TU("cbf_cb", uiCbf )
1414	}
1415	else if ( compID == COMPONENT_Cr )
1416	{
1417	DTRACE_TU("cbf_cr", uiCbf )
1418	}
1419	else
1420	{
1421	DTRACE_TU("cbf_luma", uiCbf )
1422	}
1423	#endif
1424	}
1425	}
1426	else
1427	{
1428	const UInt uiCbf = pcCU->getCbf( absPartIdx, compID, lowestTUDepth );
1429	m_pcBinIf->encodeBin( uiCbf , m_cCUQtCbfSCModel.get( 0, contextSet, uiCtx ) );
1430	#if !H_MV_ENC_DEC_TRAC
1431	DTRACE_CABAC_VL( g_nSymbolCounter++ )
1432	DTRACE_CABAC_T( "\tparseQtCbf()" )
1433	DTRACE_CABAC_T( "\tsymbol=" )
1434	DTRACE_CABAC_V( uiCbf )
1435	DTRACE_CABAC_T( "\tctx=" )
1436	DTRACE_CABAC_V( uiCtx )
1437	DTRACE_CABAC_T( "\tetype=" )
1438	DTRACE_CABAC_V( compID )
1439	DTRACE_CABAC_T( "\tuiAbsPartIdx=" )
1440	DTRACE_CABAC_V( rTu.GetAbsPartIdxTU(compID) )
1441	DTRACE_CABAC_T( "\n" )
1442	#else
1443	if ( compID == COMPONENT_Cb )
1444	{
1445	DTRACE_TU("cbf_cb", uiCbf )
1446	}
1447	else if ( compID == COMPONENT_Cr )
1448	{
1449	DTRACE_TU("cbf_cr", uiCbf )
1450	}
1451	else
1452	{
1453	DTRACE_TU("cbf_luma", uiCbf )
1454	}
1455	#endif
1456
1457	}
1458	}
1459
1460
1461	Void TEncSbac::codeTransformSkipFlags (TComTU &rTu, ComponentID component )
1462	{
1463	TComDataCU* pcCU=rTu.getCU();
1464	const UInt uiAbsPartIdx=rTu.GetAbsPartIdxTU();
1465
1466	if (pcCU->getCUTransquantBypass(uiAbsPartIdx))
1467	{
1468	return;
1469	}
1470
1471	if (!TUCompRectHasAssociatedTransformSkipFlag(rTu.getRect(component), pcCU->getSlice()->getPPS()->getPpsRangeExtension().getLog2MaxTransformSkipBlockSize()))
1472	{
1473	return;
1474	}
1475
1476	UInt useTransformSkip = pcCU->getTransformSkip( uiAbsPartIdx,component);
1477	m_pcBinIf->encodeBin( useTransformSkip, m_cTransformSkipSCModel.get( 0, toChannelType(component), 0 ) );
1478	#if !H_MV_ENC_DEC_TRAC
1479	DTRACE_CABAC_VL( g_nSymbolCounter++ )
1480	DTRACE_CABAC_T("\tparseTransformSkip()");
1481	DTRACE_CABAC_T( "\tsymbol=" )
1482	DTRACE_CABAC_V( useTransformSkip )
1483	DTRACE_CABAC_T( "\tAddr=" )
1484	DTRACE_CABAC_V( pcCU->getCtuRsAddr() )
1485	DTRACE_CABAC_T( "\tetype=" )
1486	DTRACE_CABAC_V( component )
1487	DTRACE_CABAC_T( "\tuiAbsPartIdx=" )
1488	DTRACE_CABAC_V( rTu.GetAbsPartIdxTU() )
1489	DTRACE_CABAC_T( "\n" )
1490	#endif
1491	}
1492
1493
1494	/** Code I_PCM information.
1495	* \param pcCU pointer to CU
1496	* \param uiAbsPartIdx CU index
1497	* \returns Void
1498	*/
1499	Void TEncSbac::codeIPCMInfo( TComDataCU* pcCU, UInt uiAbsPartIdx )
1500	{
1501	UInt uiIPCM = (pcCU->getIPCMFlag(uiAbsPartIdx) == true)? 1 : 0;
1502
1503	Bool writePCMSampleFlag = pcCU->getIPCMFlag(uiAbsPartIdx);
1504
1505	m_pcBinIf->encodeBinTrm (uiIPCM);
1506	#if H_MV_ENC_DEC_TRAC
1507	DTRACE_CU("pcm_flag", uiIPCM)
1508	#endif
1509	if (writePCMSampleFlag)
1510	{
1511	m_pcBinIf->encodePCMAlignBits();
1512
1513	const UInt minCoeffSizeY = pcCU->getPic()->getMinCUWidth() * pcCU->getPic()->getMinCUHeight();
1514	const UInt offsetY = minCoeffSizeY * uiAbsPartIdx;
1515	for (UInt ch=0; ch < pcCU->getPic()->getNumberValidComponents(); ch++)
1516	{
1517	const ComponentID compID = ComponentID(ch);
1518	const UInt offset = offsetY >> (pcCU->getPic()->getComponentScaleX(compID) + pcCU->getPic()->getComponentScaleY(compID));
1519	Pel * pPCMSample = pcCU->getPCMSample(compID) + offset;
1520	const UInt width = pcCU->getWidth (uiAbsPartIdx) >> pcCU->getPic()->getComponentScaleX(compID);
1521	const UInt height = pcCU->getHeight(uiAbsPartIdx) >> pcCU->getPic()->getComponentScaleY(compID);
1522	const UInt sampleBits = pcCU->getSlice()->getSPS()->getPCMBitDepth(toChannelType(compID));
1523	for (UInt y=0; y<height; y++)
1524	{
1525	for (UInt x=0; x<width; x++)
1526	{
1527	UInt sample = pPCMSample[x];
1528	m_pcBinIf->xWritePCMCode(sample, sampleBits);
1529	}
1530	pPCMSample += width;
1531	}
1532	}
1533	m_pcBinIf->resetBac();
1534	}
1535	}
1536
1537	Void TEncSbac::codeQtRootCbf( TComDataCU* pcCU, UInt uiAbsPartIdx )
1538	{
1539	UInt uiCbf = pcCU->getQtRootCbf( uiAbsPartIdx );
1540	UInt uiCtx = 0;
1541	m_pcBinIf->encodeBin( uiCbf , m_cCUQtRootCbfSCModel.get( 0, 0, uiCtx ) );
1542	#if !H_MV_ENC_DEC_TRAC
1543	DTRACE_CABAC_VL( g_nSymbolCounter++ )
1544	DTRACE_CABAC_T( "\tparseQtRootCbf()" )
1545	DTRACE_CABAC_T( "\tsymbol=" )
1546	DTRACE_CABAC_V( uiCbf )
1547	DTRACE_CABAC_T( "\tctx=" )
1548	DTRACE_CABAC_V( uiCtx )
1549	DTRACE_CABAC_T( "\tuiAbsPartIdx=" )
1550	DTRACE_CABAC_V( uiAbsPartIdx )
1551	DTRACE_CABAC_T( "\n" )
1552	#else
1553	DTRACE_CU( "rqt_root_cbf", uiCbf )
1554	#endif
1555	}
1556
1557	Void TEncSbac::codeQtCbfZero( TComTU & rTu, const ChannelType chType )
1558	{
1559	// this function is only used to estimate the bits when cbf is 0
1560	// and will never be called when writing the bistream. do not need to write log
1561	UInt uiCbf = 0;
1562	UInt uiCtx = rTu.getCU()->getCtxQtCbf( rTu, chType );
1563
1564	m_pcBinIf->encodeBin( uiCbf , m_cCUQtCbfSCModel.get( 0, chType, uiCtx ) );
1565	}
1566
1567	Void TEncSbac::codeQtRootCbfZero( )
1568	{
1569	// this function is only used to estimate the bits when cbf is 0
1570	// and will never be called when writing the bistream. do not need to write log
1571	UInt uiCbf = 0;
1572	UInt uiCtx = 0;
1573	m_pcBinIf->encodeBin( uiCbf , m_cCUQtRootCbfSCModel.get( 0, 0, uiCtx ) );
1574	}
1575
1576	/** Encode (X,Y) position of the last significant coefficient
1577	* \param uiPosX X component of last coefficient
1578	* \param uiPosY Y component of last coefficient
1579	* \param width Block width
1580	* \param height Block height
1581	* \param component chroma component ID
1582	* \param uiScanIdx scan type (zig-zag, hor, ver)
1583	* This method encodes the X and Y component within a block of the last significant coefficient.
1584	*/
1585	Void TEncSbac::codeLastSignificantXY( UInt uiPosX, UInt uiPosY, Int width, Int height, ComponentID component, UInt uiScanIdx )
1586	{
1587	// swap
1588	if( uiScanIdx == SCAN_VER )
1589	{
1590	swap( uiPosX, uiPosY );
1591	swap( width, height );
1592	}
1593
1594	UInt uiCtxLast;
1595	UInt uiGroupIdxX = g_uiGroupIdx[ uiPosX ];
1596	UInt uiGroupIdxY = g_uiGroupIdx[ uiPosY ];
1597
1598	ContextModel *pCtxX = m_cCuCtxLastX.get( 0, toChannelType(component) );
1599	ContextModel *pCtxY = m_cCuCtxLastY.get( 0, toChannelType(component) );
1600
1601	Int blkSizeOffsetX, blkSizeOffsetY, shiftX, shiftY;
1602	getLastSignificantContextParameters(component, width, height, blkSizeOffsetX, blkSizeOffsetY, shiftX, shiftY);
1603
1604	//------------------
1605
1606	// posX
1607
1608	for( uiCtxLast = 0; uiCtxLast < uiGroupIdxX; uiCtxLast++ )
1609	{
1610	m_pcBinIf->encodeBin( 1, *( pCtxX + blkSizeOffsetX + (uiCtxLast >>shiftX) ) );
1611	}
1612	if( uiGroupIdxX < g_uiGroupIdx[ width - 1 ])
1613	{
1614	m_pcBinIf->encodeBin( 0, *( pCtxX + blkSizeOffsetX + (uiCtxLast >>shiftX) ) );
1615	}
1616
1617	// posY
1618
1619	for( uiCtxLast = 0; uiCtxLast < uiGroupIdxY; uiCtxLast++ )
1620	{
1621	m_pcBinIf->encodeBin( 1, *( pCtxY + blkSizeOffsetY + (uiCtxLast >>shiftY) ) );
1622	}
1623	if( uiGroupIdxY < g_uiGroupIdx[ height - 1 ])
1624	{
1625	m_pcBinIf->encodeBin( 0, *( pCtxY + blkSizeOffsetY + (uiCtxLast >>shiftY) ) );
1626	}
1627
1628	// EP-coded part
1629
1630	if ( uiGroupIdxX > 3 )
1631	{
1632	UInt uiCount = ( uiGroupIdxX - 2 ) >> 1;
1633	uiPosX = uiPosX - g_uiMinInGroup[ uiGroupIdxX ];
1634	for (Int i = uiCount - 1 ; i >= 0; i-- )
1635	{
1636	m_pcBinIf->encodeBinEP( ( uiPosX >> i ) & 1 );
1637	}
1638	}
1639	if ( uiGroupIdxY > 3 )
1640	{
1641	UInt uiCount = ( uiGroupIdxY - 2 ) >> 1;
1642	uiPosY = uiPosY - g_uiMinInGroup[ uiGroupIdxY ];
1643	for ( Int i = uiCount - 1 ; i >= 0; i-- )
1644	{
1645	m_pcBinIf->encodeBinEP( ( uiPosY >> i ) & 1 );
1646	}
1647	}
1648	}
1649
1650
1651	Void TEncSbac::codeCoeffNxN( TComTU &rTu, TCoeff* pcCoef, const ComponentID compID )
1652	{
1653	TComDataCU* pcCU=rTu.getCU();
1654	const UInt uiAbsPartIdx=rTu.GetAbsPartIdxTU(compID);
1655	const TComRectangle &tuRect=rTu.getRect(compID);
1656	const UInt uiWidth=tuRect.width;
1657	const UInt uiHeight=tuRect.height;
1658	const TComSPS &sps=*(pcCU->getSlice()->getSPS());
1659	#if !H_MV_ENC_DEC_TRAC
1660
1661	DTRACE_CABAC_VL( g_nSymbolCounter++ )
1662	DTRACE_CABAC_T( "\tparseCoeffNxN()\teType=" )
1663	DTRACE_CABAC_V( compID )
1664	DTRACE_CABAC_T( "\twidth=" )
1665	DTRACE_CABAC_V( uiWidth )
1666	DTRACE_CABAC_T( "\theight=" )
1667	DTRACE_CABAC_V( uiHeight )
1668	DTRACE_CABAC_T( "\tdepth=" )
1669	// DTRACE_CABAC_V( rTu.GetTransformDepthTotalAdj(compID) )
1670	DTRACE_CABAC_V( rTu.GetTransformDepthTotal() )
1671	DTRACE_CABAC_T( "\tabspartidx=" )
1672	DTRACE_CABAC_V( uiAbsPartIdx )
1673	DTRACE_CABAC_T( "\ttoCU-X=" )
1674	DTRACE_CABAC_V( pcCU->getCUPelX() )
1675	DTRACE_CABAC_T( "\ttoCU-Y=" )
1676	DTRACE_CABAC_V( pcCU->getCUPelY() )
1677	DTRACE_CABAC_T( "\tCU-addr=" )
1678	DTRACE_CABAC_V( pcCU->getCtuRsAddr() )
1679	DTRACE_CABAC_T( "\tinCU-X=" )
1680	// DTRACE_CABAC_V( g_auiRasterToPelX[ g_auiZscanToRaster[uiAbsPartIdx] ] )
1681	DTRACE_CABAC_V( g_auiRasterToPelX[ g_auiZscanToRaster[rTu.GetAbsPartIdxTU(compID)] ] )
1682	DTRACE_CABAC_T( "\tinCU-Y=" )
1683	// DTRACE_CABAC_V( g_auiRasterToPelY[ g_auiZscanToRaster[uiAbsPartIdx] ] )
1684	DTRACE_CABAC_V( g_auiRasterToPelY[ g_auiZscanToRaster[rTu.GetAbsPartIdxTU(compID)] ] )
1685	DTRACE_CABAC_T( "\tpredmode=" )
1686	DTRACE_CABAC_V( pcCU->getPredictionMode( uiAbsPartIdx ) )
1687	DTRACE_CABAC_T( "\n" )
1688	#endif
1689
1690	//--------------------------------------------------------------------------------------------------
1691
1692	if( uiWidth > sps.getMaxTrSize() )
1693	{
1694	std::cerr << "ERROR: codeCoeffNxN was passed a TU with dimensions larger than the maximum allowed size" << std::endl;
1695	assert(false);
1696	exit(1);
1697	}
1698
1699	// compute number of significant coefficients
1700	UInt uiNumSig = TEncEntropy::countNonZeroCoeffs(pcCoef, uiWidth * uiHeight);
1701
1702	if ( uiNumSig == 0 )
1703	{
1704	std::cerr << "ERROR: codeCoeffNxN called for empty TU!" << std::endl;
1705	assert(false);
1706	exit(1);
1707	}
1708
1709	//--------------------------------------------------------------------------------------------------
1710
1711	//set parameters
1712
1713	const ChannelType chType = toChannelType(compID);
1714	const UInt uiLog2BlockWidth = g_aucConvertToBit[ uiWidth ] + 2;
1715	const UInt uiLog2BlockHeight = g_aucConvertToBit[ uiHeight ] + 2;
1716
1717	const ChannelType channelType = toChannelType(compID);
1718	const Bool extendedPrecision = sps.getSpsRangeExtension().getExtendedPrecisionProcessingFlag();
1719
1720	const Bool alignCABACBeforeBypass = sps.getSpsRangeExtension().getCabacBypassAlignmentEnabledFlag();
1721	const Int maxLog2TrDynamicRange = sps.getMaxLog2TrDynamicRange(channelType);
1722
1723	Bool beValid;
1724
1725	{
1726	Int uiIntraMode = -1;
1727	const Bool bIsLuma = isLuma(compID);
1728	Int isIntra = pcCU->isIntra(uiAbsPartIdx) ? 1 : 0;
1729	if ( isIntra )
1730	{
1731	uiIntraMode = pcCU->getIntraDir( toChannelType(compID), uiAbsPartIdx );
1732
1733	const UInt partsPerMinCU = 1<<(2*(sps.getMaxTotalCUDepth() - sps.getLog2DiffMaxMinCodingBlockSize()));
1734	uiIntraMode = (uiIntraMode==DM_CHROMA_IDX && !bIsLuma) ? pcCU->getIntraDir(CHANNEL_TYPE_LUMA, getChromasCorrespondingPULumaIdx(uiAbsPartIdx, rTu.GetChromaFormat(), partsPerMinCU)) : uiIntraMode;
1735	uiIntraMode = ((rTu.GetChromaFormat() == CHROMA_422) && !bIsLuma) ? g_chroma422IntraAngleMappingTable[uiIntraMode] : uiIntraMode;
1736	}
1737
1738	Int transformSkip = pcCU->getTransformSkip( uiAbsPartIdx,compID) ? 1 : 0;
1739	Bool rdpcm_lossy = ( transformSkip && isIntra && ( (uiIntraMode == HOR_IDX) \|\| (uiIntraMode == VER_IDX) ) ) && pcCU->isRDPCMEnabled(uiAbsPartIdx);
1740
1741	if ( (pcCU->getCUTransquantBypass(uiAbsPartIdx)) \|\| rdpcm_lossy )
1742	{
1743	beValid = false;
1744	if ( (!pcCU->isIntra(uiAbsPartIdx)) && pcCU->isRDPCMEnabled(uiAbsPartIdx))
1745	{
1746	codeExplicitRdpcmMode( rTu, compID);
1747	}
1748	}
1749	else
1750	{
1751	beValid = pcCU->getSlice()->getPPS()->getSignHideFlag();
1752	}
1753	}
1754
1755	//--------------------------------------------------------------------------------------------------
1756
1757	if(pcCU->getSlice()->getPPS()->getUseTransformSkip())
1758	{
1759	codeTransformSkipFlags(rTu, compID);
1760	if(pcCU->getTransformSkip(uiAbsPartIdx, compID) && !pcCU->isIntra(uiAbsPartIdx) && pcCU->isRDPCMEnabled(uiAbsPartIdx))
1761	{
1762	// This TU has coefficients and is transform skipped. Check whether is inter coded and if yes encode the explicit RDPCM mode
1763	codeExplicitRdpcmMode( rTu, compID);
1764
1765	if(pcCU->getExplicitRdpcmMode(compID, uiAbsPartIdx) != RDPCM_OFF)
1766	{
1767	// Sign data hiding is avoided for horizontal and vertical explicit RDPCM modes
1768	beValid = false;
1769	}
1770	}
1771	}
1772
1773	//--------------------------------------------------------------------------------------------------
1774
1775	const Bool bUseGolombRiceParameterAdaptation = sps.getSpsRangeExtension().getPersistentRiceAdaptationEnabledFlag();
1776	UInt &currentGolombRiceStatistic = m_golombRiceAdaptationStatistics[rTu.getGolombRiceStatisticsIndex(compID)];
1777
1778	//select scans
1779	TUEntropyCodingParameters codingParameters;
1780	getTUEntropyCodingParameters(codingParameters, rTu, compID);
1781
1782	//----- encode significance map -----
1783
1784	// Find position of last coefficient
1785	Int scanPosLast = -1;
1786	Int posLast;
1787
1788
1789	UInt uiSigCoeffGroupFlag[ MLS_GRP_NUM ];
1790
1791	memset( uiSigCoeffGroupFlag, 0, sizeof(UInt) * MLS_GRP_NUM );
1792	do
1793	{
1794	posLast = codingParameters.scan[ ++scanPosLast ];
1795
1796	if( pcCoef[ posLast ] != 0 )
1797	{
1798	// get L1 sig map
1799	UInt uiPosY = posLast >> uiLog2BlockWidth;
1800	UInt uiPosX = posLast - ( uiPosY << uiLog2BlockWidth );
1801
1802	UInt uiBlkIdx = (codingParameters.widthInGroups * (uiPosY >> MLS_CG_LOG2_HEIGHT)) + (uiPosX >> MLS_CG_LOG2_WIDTH);
1803	uiSigCoeffGroupFlag[ uiBlkIdx ] = 1;
1804
1805	uiNumSig--;
1806	}
1807	} while ( uiNumSig > 0 );
1808
1809	// Code position of last coefficient
1810	Int posLastY = posLast >> uiLog2BlockWidth;
1811	Int posLastX = posLast - ( posLastY << uiLog2BlockWidth );
1812	codeLastSignificantXY(posLastX, posLastY, uiWidth, uiHeight, compID, codingParameters.scanType);
1813
1814	//===== code significance flag =====
1815	ContextModel * const baseCoeffGroupCtx = m_cCUSigCoeffGroupSCModel.get( 0, chType );
1816	ContextModel * const baseCtx = m_cCUSigSCModel.get( 0, 0 ) + getSignificanceMapContextOffset(compID);
1817
1818	const Int iLastScanSet = scanPosLast >> MLS_CG_SIZE;
1819
1820	UInt c1 = 1;
1821	UInt uiGoRiceParam = 0;
1822	Int iScanPosSig = scanPosLast;
1823
1824	for( Int iSubSet = iLastScanSet; iSubSet >= 0; iSubSet-- )
1825	{
1826	Int numNonZero = 0;
1827	Int iSubPos = iSubSet << MLS_CG_SIZE;
1828	uiGoRiceParam = currentGolombRiceStatistic / RExt__GOLOMB_RICE_INCREMENT_DIVISOR;
1829	Bool updateGolombRiceStatistics = bUseGolombRiceParameterAdaptation; //leave the statistics at 0 when not using the adaptation system
1830	UInt coeffSigns = 0;
1831
1832	Int absCoeff[1 << MLS_CG_SIZE];
1833
1834	Int lastNZPosInCG = -1;
1835	Int firstNZPosInCG = 1 << MLS_CG_SIZE;
1836
1837	Bool escapeDataPresentInGroup = false;
1838
1839	if( iScanPosSig == scanPosLast )
1840	{
1841	absCoeff[ 0 ] = Int(abs( pcCoef[ posLast ] ));
1842	coeffSigns = ( pcCoef[ posLast ] < 0 );
1843	numNonZero = 1;
1844	lastNZPosInCG = iScanPosSig;
1845	firstNZPosInCG = iScanPosSig;
1846	iScanPosSig--;
1847	}
1848
1849	// encode significant_coeffgroup_flag
1850	Int iCGBlkPos = codingParameters.scanCG[ iSubSet ];
1851	Int iCGPosY = iCGBlkPos / codingParameters.widthInGroups;
1852	Int iCGPosX = iCGBlkPos - (iCGPosY * codingParameters.widthInGroups);
1853
1854	if( iSubSet == iLastScanSet \|\| iSubSet == 0)
1855	{
1856	uiSigCoeffGroupFlag[ iCGBlkPos ] = 1;
1857	}
1858	else
1859	{
1860	UInt uiSigCoeffGroup = (uiSigCoeffGroupFlag[ iCGBlkPos ] != 0);
1861	UInt uiCtxSig = TComTrQuant::getSigCoeffGroupCtxInc( uiSigCoeffGroupFlag, iCGPosX, iCGPosY, codingParameters.widthInGroups, codingParameters.heightInGroups );
1862	m_pcBinIf->encodeBin( uiSigCoeffGroup, baseCoeffGroupCtx[ uiCtxSig ] );
1863	}
1864
1865	// encode significant_coeff_flag
1866	if( uiSigCoeffGroupFlag[ iCGBlkPos ] )
1867	{
1868	const Int patternSigCtx = TComTrQuant::calcPatternSigCtx(uiSigCoeffGroupFlag, iCGPosX, iCGPosY, codingParameters.widthInGroups, codingParameters.heightInGroups);
1869
1870	UInt uiBlkPos, uiSig, uiCtxSig;
1871	for( ; iScanPosSig >= iSubPos; iScanPosSig-- )
1872	{
1873	uiBlkPos = codingParameters.scan[ iScanPosSig ];
1874	uiSig = (pcCoef[ uiBlkPos ] != 0);
1875	if( iScanPosSig > iSubPos \|\| iSubSet == 0 \|\| numNonZero )
1876	{
1877	uiCtxSig = TComTrQuant::getSigCtxInc( patternSigCtx, codingParameters, iScanPosSig, uiLog2BlockWidth, uiLog2BlockHeight, chType );
1878	m_pcBinIf->encodeBin( uiSig, baseCtx[ uiCtxSig ] );
1879	}
1880	if( uiSig )
1881	{
1882	absCoeff[ numNonZero ] = Int(abs( pcCoef[ uiBlkPos ] ));
1883	coeffSigns = 2 * coeffSigns + ( pcCoef[ uiBlkPos ] < 0 );
1884	numNonZero++;
1885	if( lastNZPosInCG == -1 )
1886	{
1887	lastNZPosInCG = iScanPosSig;
1888	}
1889	firstNZPosInCG = iScanPosSig;
1890	}
1891	}
1892	}
1893	else
1894	{
1895	iScanPosSig = iSubPos - 1;
1896	}
1897
1898	if( numNonZero > 0 )
1899	{
1900	Bool signHidden = ( lastNZPosInCG - firstNZPosInCG >= SBH_THRESHOLD );
1901
1902	const UInt uiCtxSet = getContextSetIndex(compID, iSubSet, (c1 == 0));
1903	c1 = 1;
1904
1905	ContextModel baseCtxMod = m_cCUOneSCModel.get( 0, 0 ) + (NUM_ONE_FLAG_CTX_PER_SET uiCtxSet);
1906
1907	Int numC1Flag = min(numNonZero, C1FLAG_NUMBER);
1908	Int firstC2FlagIdx = -1;
1909	for( Int idx = 0; idx < numC1Flag; idx++ )
1910	{
1911	UInt uiSymbol = absCoeff[ idx ] > 1;
1912	m_pcBinIf->encodeBin( uiSymbol, baseCtxMod[c1] );
1913	if( uiSymbol )
1914	{
1915	c1 = 0;
1916
1917	if (firstC2FlagIdx == -1)
1918	{
1919	firstC2FlagIdx = idx;
1920	}
1921	else //if a greater-than-one has been encountered already this group
1922	{
1923	escapeDataPresentInGroup = true;
1924	}
1925	}
1926	else if( (c1 < 3) && (c1 > 0) )
1927	{
1928	c1++;
1929	}
1930	}
1931
1932	if (c1 == 0)
1933	{
1934	baseCtxMod = m_cCUAbsSCModel.get( 0, 0 ) + (NUM_ABS_FLAG_CTX_PER_SET * uiCtxSet);
1935	if ( firstC2FlagIdx != -1)
1936	{
1937	UInt symbol = absCoeff[ firstC2FlagIdx ] > 2;
1938	m_pcBinIf->encodeBin( symbol, baseCtxMod[0] );
1939	if (symbol != 0)
1940	{
1941	escapeDataPresentInGroup = true;
1942	}
1943	}
1944	}
1945
1946	escapeDataPresentInGroup = escapeDataPresentInGroup \|\| (numNonZero > C1FLAG_NUMBER);
1947
1948	if (escapeDataPresentInGroup && alignCABACBeforeBypass)
1949	{
1950	m_pcBinIf->align();
1951	}
1952
1953	if( beValid && signHidden )
1954	{
1955	m_pcBinIf->encodeBinsEP( (coeffSigns >> 1), numNonZero-1 );
1956	}
1957	else
1958	{
1959	m_pcBinIf->encodeBinsEP( coeffSigns, numNonZero );
1960	}
1961
1962	Int iFirstCoeff2 = 1;
1963	if (escapeDataPresentInGroup)
1964	{
1965	for ( Int idx = 0; idx < numNonZero; idx++ )
1966	{
1967	UInt baseLevel = (idx < C1FLAG_NUMBER)? (2 + iFirstCoeff2 ) : 1;
1968
1969	if( absCoeff[ idx ] >= baseLevel)
1970	{
1971	const UInt escapeCodeValue = absCoeff[idx] - baseLevel;
1972
1973	xWriteCoefRemainExGolomb( escapeCodeValue, uiGoRiceParam, extendedPrecision, maxLog2TrDynamicRange );
1974
1975	if (absCoeff[idx] > (3 << uiGoRiceParam))
1976	{
1977	uiGoRiceParam = bUseGolombRiceParameterAdaptation ? (uiGoRiceParam + 1) : (std::min<UInt>((uiGoRiceParam + 1), 4));
1978	}
1979
1980	if (updateGolombRiceStatistics)
1981	{
1982	const UInt initialGolombRiceParameter = currentGolombRiceStatistic / RExt__GOLOMB_RICE_INCREMENT_DIVISOR;
1983
1984	if (escapeCodeValue >= (3 << initialGolombRiceParameter))
1985	{
1986	currentGolombRiceStatistic++;
1987	}
1988	else if (((escapeCodeValue * 2) < (1 << initialGolombRiceParameter)) && (currentGolombRiceStatistic > 0))
1989	{
1990	currentGolombRiceStatistic--;
1991	}
1992
1993	updateGolombRiceStatistics = false;
1994	}
1995	}
1996
1997	if(absCoeff[ idx ] >= 2)
1998	{
1999	iFirstCoeff2 = 0;
2000	}
2001	}
2002	}
2003	}
2004	}
2005	#if ENVIRONMENT_VARIABLE_DEBUG_AND_TEST
2006	printSBACCoeffData(posLastX, posLastY, uiWidth, uiHeight, compID, uiAbsPartIdx, codingParameters.scanType, pcCoef, pcCU->getSlice()->getFinalized());
2007	#endif
2008
2009	return;
2010	}
2011
2012	/** code SAO offset sign
2013	* \param code sign value
2014	*/
2015	Void TEncSbac::codeSAOSign( UInt code )
2016	{
2017	m_pcBinIf->encodeBinEP( code );
2018	}
2019
2020	Void TEncSbac::codeSaoMaxUvlc ( UInt code, UInt maxSymbol )
2021	{
2022	if (maxSymbol == 0)
2023	{
2024	return;
2025	}
2026
2027	Int i;
2028	Bool bCodeLast = ( maxSymbol > code );
2029
2030	if ( code == 0 )
2031	{
2032	m_pcBinIf->encodeBinEP( 0 );
2033	}
2034	else
2035	{
2036	m_pcBinIf->encodeBinEP( 1 );
2037	for ( i=0; i<code-1; i++ )
2038	{
2039	m_pcBinIf->encodeBinEP( 1 );
2040	}
2041	if( bCodeLast )
2042	{
2043	m_pcBinIf->encodeBinEP( 0 );
2044	}
2045	}
2046	}
2047
2048	/** Code SAO EO class or BO band position
2049	*/
2050	Void TEncSbac::codeSaoUflc ( UInt uiLength, UInt uiCode )
2051	{
2052	m_pcBinIf->encodeBinsEP ( uiCode, uiLength );
2053	}
2054
2055	/** Code SAO merge flags
2056	*/
2057	Void TEncSbac::codeSaoMerge ( UInt uiCode )
2058	{
2059	m_pcBinIf->encodeBin(((uiCode == 0) ? 0 : 1), m_cSaoMergeSCModel.get( 0, 0, 0 ));
2060	}
2061
2062	/** Code SAO type index
2063	*/
2064	Void TEncSbac::codeSaoTypeIdx ( UInt uiCode)
2065	{
2066	if (uiCode == 0)
2067	{
2068	m_pcBinIf->encodeBin( 0, m_cSaoTypeIdxSCModel.get( 0, 0, 0 ) );
2069	}
2070	else
2071	{
2072	m_pcBinIf->encodeBin( 1, m_cSaoTypeIdxSCModel.get( 0, 0, 0 ) );
2073	m_pcBinIf->encodeBinEP( uiCode == 1 ? 0 : 1 );
2074	}
2075	}
2076
2077	Void TEncSbac::codeSAOOffsetParam(ComponentID compIdx, SAOOffset& ctbParam, Bool sliceEnabled, const Int channelBitDepth)
2078	{
2079	UInt uiSymbol;
2080	if(!sliceEnabled)
2081	{
2082	assert(ctbParam.modeIdc == SAO_MODE_OFF);
2083	return;
2084	}
2085	const Bool bIsFirstCompOfChType = (getFirstComponentOfChannel(toChannelType(compIdx)) == compIdx);
2086
2087	//type
2088	if(bIsFirstCompOfChType)
2089	{
2090	//sao_type_idx_luma or sao_type_idx_chroma
2091	if(ctbParam.modeIdc == SAO_MODE_OFF)
2092	{
2093	uiSymbol =0;
2094	}
2095	else if(ctbParam.typeIdc == SAO_TYPE_BO) //BO
2096	{
2097	uiSymbol = 1;
2098	}
2099	else
2100	{
2101	assert(ctbParam.typeIdc < SAO_TYPE_START_BO); //EO
2102	uiSymbol = 2;
2103	}
2104	codeSaoTypeIdx(uiSymbol);
2105	}
2106
2107	if(ctbParam.modeIdc == SAO_MODE_NEW)
2108	{
2109	Int numClasses = (ctbParam.typeIdc == SAO_TYPE_BO)?4:NUM_SAO_EO_CLASSES;
2110	Int offset[4];
2111	Int k=0;
2112	for(Int i=0; i< numClasses; i++)
2113	{
2114	if(ctbParam.typeIdc != SAO_TYPE_BO && i == SAO_CLASS_EO_PLAIN)
2115	{
2116	continue;
2117	}
2118	Int classIdx = (ctbParam.typeIdc == SAO_TYPE_BO)?( (ctbParam.typeAuxInfo+i)% NUM_SAO_BO_CLASSES ):i;
2119	offset[k] = ctbParam.offset[classIdx];
2120	k++;
2121	}
2122
2123	const Int maxOffsetQVal = TComSampleAdaptiveOffset::getMaxOffsetQVal(channelBitDepth);
2124	for(Int i=0; i< 4; i++)
2125	{
2126	codeSaoMaxUvlc((offset[i]<0)?(-offset[i]):(offset[i]), maxOffsetQVal ); //sao_offset_abs
2127	}
2128
2129
2130	if(ctbParam.typeIdc == SAO_TYPE_BO)
2131	{
2132	for(Int i=0; i< 4; i++)
2133	{
2134	if(offset[i] != 0)
2135	{
2136	codeSAOSign((offset[i]< 0)?1:0);
2137	}
2138	}
2139
2140	codeSaoUflc(NUM_SAO_BO_CLASSES_LOG2, ctbParam.typeAuxInfo ); //sao_band_position
2141	}
2142	else //EO
2143	{
2144	if(bIsFirstCompOfChType)
2145	{
2146	assert(ctbParam.typeIdc - SAO_TYPE_START_EO >=0);
2147	codeSaoUflc(NUM_SAO_EO_TYPES_LOG2, ctbParam.typeIdc - SAO_TYPE_START_EO ); //sao_eo_class_luma or sao_eo_class_chroma
2148	}
2149	}
2150
2151	}
2152	}
2153
2154
2155	Void TEncSbac::codeSAOBlkParam(SAOBlkParam& saoBlkParam, const BitDepths &bitDepths
2156	, Bool* sliceEnabled
2157	, Bool leftMergeAvail
2158	, Bool aboveMergeAvail
2159	, Bool onlyEstMergeInfo // = false
2160	)
2161	{
2162
2163	Bool isLeftMerge = false;
2164	Bool isAboveMerge= false;
2165
2166	if(leftMergeAvail)
2167	{
2168	isLeftMerge = ((saoBlkParam[COMPONENT_Y].modeIdc == SAO_MODE_MERGE) && (saoBlkParam[COMPONENT_Y].typeIdc == SAO_MERGE_LEFT));
2169	codeSaoMerge( isLeftMerge?1:0 ); //sao_merge_left_flag
2170	}
2171
2172	if( aboveMergeAvail && !isLeftMerge)
2173	{
2174	isAboveMerge = ((saoBlkParam[COMPONENT_Y].modeIdc == SAO_MODE_MERGE) && (saoBlkParam[COMPONENT_Y].typeIdc == SAO_MERGE_ABOVE));
2175	codeSaoMerge( isAboveMerge?1:0 ); //sao_merge_left_flag
2176	}
2177
2178	if(onlyEstMergeInfo)
2179	{
2180	return; //only for RDO
2181	}
2182
2183	if(!isLeftMerge && !isAboveMerge) //not merge mode
2184	{
2185	for(Int compIdx=0; compIdx < MAX_NUM_COMPONENT; compIdx++)
2186	{
2187	codeSAOOffsetParam(ComponentID(compIdx), saoBlkParam[compIdx], sliceEnabled[compIdx], bitDepths.recon[toChannelType(ComponentID(compIdx))]);
2188	}
2189	}
2190	}
2191
2192	/*!
2193	****************************************************************************
2194	* \brief
2195	* estimate bit cost for CBP, significant map and significant coefficients
2196	****************************************************************************
2197	*/
2198	Void TEncSbac::estBit( estBitsSbacStruct* pcEstBitsSbac, Int width, Int height, ChannelType chType )
2199	{
2200	estCBFBit( pcEstBitsSbac );
2201
2202	estSignificantCoeffGroupMapBit( pcEstBitsSbac, chType );
2203
2204	// encode significance map
2205	estSignificantMapBit( pcEstBitsSbac, width, height, chType );
2206
2207	// encode last significant position
2208	estLastSignificantPositionBit( pcEstBitsSbac, width, height, chType );
2209
2210	// encode significant coefficients
2211	estSignificantCoefficientsBit( pcEstBitsSbac, chType );
2212
2213	memcpy(pcEstBitsSbac->golombRiceAdaptationStatistics, m_golombRiceAdaptationStatistics, (sizeof(UInt) * RExt__GOLOMB_RICE_ADAPTATION_STATISTICS_SETS));
2214	}
2215
2216	/*!
2217	****************************************************************************
2218	* \brief
2219	* estimate bit cost for each CBP bit
2220	****************************************************************************
2221	*/
2222	Void TEncSbac::estCBFBit( estBitsSbacStruct* pcEstBitsSbac )
2223	{
2224	ContextModel *pCtx = m_cCUQtCbfSCModel.get( 0 );
2225
2226	for( UInt uiCtxInc = 0; uiCtxInc < (NUM_QT_CBF_CTX_SETS * NUM_QT_CBF_CTX_PER_SET); uiCtxInc++ )
2227	{
2228	pcEstBitsSbac->blockCbpBits[ uiCtxInc ][ 0 ] = pCtx[ uiCtxInc ].getEntropyBits( 0 );
2229	pcEstBitsSbac->blockCbpBits[ uiCtxInc ][ 1 ] = pCtx[ uiCtxInc ].getEntropyBits( 1 );
2230	}
2231
2232	pCtx = m_cCUQtRootCbfSCModel.get( 0 );
2233
2234	for( UInt uiCtxInc = 0; uiCtxInc < 4; uiCtxInc++ )
2235	{
2236	pcEstBitsSbac->blockRootCbpBits[ uiCtxInc ][ 0 ] = pCtx[ uiCtxInc ].getEntropyBits( 0 );
2237	pcEstBitsSbac->blockRootCbpBits[ uiCtxInc ][ 1 ] = pCtx[ uiCtxInc ].getEntropyBits( 1 );
2238	}
2239	}
2240
2241
2242	/*!
2243	****************************************************************************
2244	* \brief
2245	* estimate SAMBAC bit cost for significant coefficient group map
2246	****************************************************************************
2247	*/
2248	Void TEncSbac::estSignificantCoeffGroupMapBit( estBitsSbacStruct* pcEstBitsSbac, ChannelType chType )
2249	{
2250	Int firstCtx = 0, numCtx = NUM_SIG_CG_FLAG_CTX;
2251
2252	for ( Int ctxIdx = firstCtx; ctxIdx < firstCtx + numCtx; ctxIdx++ )
2253	{
2254	for( UInt uiBin = 0; uiBin < 2; uiBin++ )
2255	{
2256	pcEstBitsSbac->significantCoeffGroupBits[ ctxIdx ][ uiBin ] = m_cCUSigCoeffGroupSCModel.get( 0, chType, ctxIdx ).getEntropyBits( uiBin );
2257	}
2258	}
2259	}
2260
2261
2262	/*!
2263	****************************************************************************
2264	* \brief
2265	* estimate SAMBAC bit cost for significant coefficient map
2266	****************************************************************************
2267	*/
2268	Void TEncSbac::estSignificantMapBit( estBitsSbacStruct* pcEstBitsSbac, Int width, Int height, ChannelType chType )
2269	{
2270	//--------------------------------------------------------------------------------------------------
2271
2272	//set up the number of channels and context variables
2273
2274	const UInt firstComponent = ((isLuma(chType)) ? (COMPONENT_Y) : (COMPONENT_Cb));
2275	const UInt lastComponent = ((isLuma(chType)) ? (COMPONENT_Y) : (COMPONENT_Cb));
2276
2277	//----------------------------------------------------------
2278
2279	Int firstCtx = MAX_INT;
2280	Int numCtx = MAX_INT;
2281
2282	if ((width == 4) && (height == 4))
2283	{
2284	firstCtx = significanceMapContextSetStart[chType][CONTEXT_TYPE_4x4];
2285	numCtx = significanceMapContextSetSize [chType][CONTEXT_TYPE_4x4];
2286	}
2287	else if ((width == 8) && (height == 8))
2288	{
2289	firstCtx = significanceMapContextSetStart[chType][CONTEXT_TYPE_8x8];
2290	numCtx = significanceMapContextSetSize [chType][CONTEXT_TYPE_8x8];
2291	}
2292	else
2293	{
2294	firstCtx = significanceMapContextSetStart[chType][CONTEXT_TYPE_NxN];
2295	numCtx = significanceMapContextSetSize [chType][CONTEXT_TYPE_NxN];
2296	}
2297
2298	//--------------------------------------------------------------------------------------------------
2299
2300	//fill the data for the significace map
2301
2302	for (UInt component = firstComponent; component <= lastComponent; component++)
2303	{
2304	const UInt contextOffset = getSignificanceMapContextOffset(ComponentID(component));
2305
2306	if (firstCtx > 0)
2307	{
2308	for( UInt bin = 0; bin < 2; bin++ ) //always get the DC
2309	{
2310	pcEstBitsSbac->significantBits[ contextOffset ][ bin ] = m_cCUSigSCModel.get( 0, 0, contextOffset ).getEntropyBits( bin );
2311	}
2312	}
2313
2314	// This could be made optional, but would require this function to have knowledge of whether the
2315	// TU is transform-skipped or transquant-bypassed and whether the SPS flag is set
2316	for( UInt bin = 0; bin < 2; bin++ )
2317	{
2318	const Int ctxIdx = significanceMapContextSetStart[chType][CONTEXT_TYPE_SINGLE];
2319	pcEstBitsSbac->significantBits[ contextOffset + ctxIdx ][ bin ] = m_cCUSigSCModel.get( 0, 0, (contextOffset + ctxIdx) ).getEntropyBits( bin );
2320	}
2321
2322	for ( Int ctxIdx = firstCtx; ctxIdx < firstCtx + numCtx; ctxIdx++ )
2323	{
2324	for( UInt uiBin = 0; uiBin < 2; uiBin++ )
2325	{
2326	pcEstBitsSbac->significantBits[ contextOffset + ctxIdx ][ uiBin ] = m_cCUSigSCModel.get( 0, 0, (contextOffset + ctxIdx) ).getEntropyBits( uiBin );
2327	}
2328	}
2329	}
2330
2331	//--------------------------------------------------------------------------------------------------
2332	}
2333
2334
2335	/*!
2336	****************************************************************************
2337	* \brief
2338	* estimate bit cost of significant coefficient
2339	****************************************************************************
2340	*/
2341
2342	Void TEncSbac::estLastSignificantPositionBit( estBitsSbacStruct* pcEstBitsSbac, Int width, Int height, ChannelType chType )
2343	{
2344	//--------------------------------------------------------------------------------------------------.
2345
2346	//set up the number of channels
2347
2348	const UInt firstComponent = ((isLuma(chType)) ? (COMPONENT_Y) : (COMPONENT_Cb));
2349	const UInt lastComponent = ((isLuma(chType)) ? (COMPONENT_Y) : (COMPONENT_Cb));
2350
2351	//--------------------------------------------------------------------------------------------------
2352
2353	//fill the data for the last-significant-coefficient position
2354
2355	for (UInt componentIndex = firstComponent; componentIndex <= lastComponent; componentIndex++)
2356	{
2357	const ComponentID component = ComponentID(componentIndex);
2358
2359	Int iBitsX = 0, iBitsY = 0;
2360
2361	Int blkSizeOffsetX, blkSizeOffsetY, shiftX, shiftY;
2362	getLastSignificantContextParameters(ComponentID(component), width, height, blkSizeOffsetX, blkSizeOffsetY, shiftX, shiftY);
2363
2364	Int ctx;
2365
2366	const ChannelType channelType = toChannelType(ComponentID(component));
2367
2368	ContextModel *const pCtxX = m_cCuCtxLastX.get( 0, channelType );
2369	ContextModel *const pCtxY = m_cCuCtxLastY.get( 0, channelType );
2370	Int *const lastXBitsArray = pcEstBitsSbac->lastXBits[channelType];
2371	Int *const lastYBitsArray = pcEstBitsSbac->lastYBits[channelType];
2372
2373	//------------------------------------------------
2374
2375	//X-coordinate
2376
2377	for (ctx = 0; ctx < g_uiGroupIdx[ width - 1 ]; ctx++)
2378	{
2379	Int ctxOffset = blkSizeOffsetX + (ctx >>shiftX);
2380	lastXBitsArray[ ctx ] = iBitsX + pCtxX[ ctxOffset ].getEntropyBits( 0 );
2381	iBitsX += pCtxX[ ctxOffset ].getEntropyBits( 1 );
2382	}
2383
2384	lastXBitsArray[ctx] = iBitsX;
2385
2386	//------------------------------------------------
2387
2388	//Y-coordinate
2389
2390	for (ctx = 0; ctx < g_uiGroupIdx[ height - 1 ]; ctx++)
2391	{
2392	Int ctxOffset = blkSizeOffsetY + (ctx >>shiftY);
2393	lastYBitsArray[ ctx ] = iBitsY + pCtxY[ ctxOffset ].getEntropyBits( 0 );
2394	iBitsY += pCtxY[ ctxOffset ].getEntropyBits( 1 );
2395	}
2396
2397	lastYBitsArray[ctx] = iBitsY;
2398
2399	} //end of component loop
2400
2401	//--------------------------------------------------------------------------------------------------
2402	}
2403
2404
2405	/*!
2406	****************************************************************************
2407	* \brief
2408	* estimate bit cost of significant coefficient
2409	****************************************************************************
2410	*/
2411	Void TEncSbac::estSignificantCoefficientsBit( estBitsSbacStruct* pcEstBitsSbac, ChannelType chType )
2412	{
2413	ContextModel *ctxOne = m_cCUOneSCModel.get(0, 0);
2414	ContextModel *ctxAbs = m_cCUAbsSCModel.get(0, 0);
2415
2416	const UInt oneStartIndex = ((isLuma(chType)) ? (0) : (NUM_ONE_FLAG_CTX_LUMA));
2417	const UInt oneStopIndex = ((isLuma(chType)) ? (NUM_ONE_FLAG_CTX_LUMA) : (NUM_ONE_FLAG_CTX));
2418	const UInt absStartIndex = ((isLuma(chType)) ? (0) : (NUM_ABS_FLAG_CTX_LUMA));
2419	const UInt absStopIndex = ((isLuma(chType)) ? (NUM_ABS_FLAG_CTX_LUMA) : (NUM_ABS_FLAG_CTX));
2420
2421	for (Int ctxIdx = oneStartIndex; ctxIdx < oneStopIndex; ctxIdx++)
2422	{
2423	pcEstBitsSbac->m_greaterOneBits[ ctxIdx ][ 0 ] = ctxOne[ ctxIdx ].getEntropyBits( 0 );
2424	pcEstBitsSbac->m_greaterOneBits[ ctxIdx ][ 1 ] = ctxOne[ ctxIdx ].getEntropyBits( 1 );
2425	}
2426
2427	for (Int ctxIdx = absStartIndex; ctxIdx < absStopIndex; ctxIdx++)
2428	{
2429	pcEstBitsSbac->m_levelAbsBits[ ctxIdx ][ 0 ] = ctxAbs[ ctxIdx ].getEntropyBits( 0 );
2430	pcEstBitsSbac->m_levelAbsBits[ ctxIdx ][ 1 ] = ctxAbs[ ctxIdx ].getEntropyBits( 1 );
2431	}
2432	}
2433
2434	/**
2435	- Initialize our context information from the nominated source.
2436	.
2437	\param pSrc From where to copy context information.
2438	*/
2439	Void TEncSbac::xCopyContextsFrom( const TEncSbac* pSrc )
2440	{
2441	memcpy(m_contextModels, pSrc->m_contextModels, m_numContextModels*sizeof(m_contextModels[0]));
2442	memcpy(m_golombRiceAdaptationStatistics, pSrc->m_golombRiceAdaptationStatistics, (sizeof(UInt) * RExt__GOLOMB_RICE_ADAPTATION_STATISTICS_SETS));
2443	}
2444
2445	Void TEncSbac::loadContexts ( const TEncSbac* pSrc)
2446	{
2447	xCopyContextsFrom(pSrc);
2448	}
2449
2450	/** Performs CABAC encoding of the explicit RDPCM mode
2451	* \param rTu current TU data structure
2452	* \param compID component identifier
2453	*/
2454	Void TEncSbac::codeExplicitRdpcmMode( TComTU &rTu, const ComponentID compID )
2455	{
2456	TComDataCU *cu = rTu.getCU();
2457	const TComRectangle &rect = rTu.getRect(compID);
2458	const UInt absPartIdx = rTu.GetAbsPartIdxTU(compID);
2459	const UInt tuHeight = g_aucConvertToBit[rect.height];
2460	const UInt tuWidth = g_aucConvertToBit[rect.width];
2461
2462	assert(tuHeight == tuWidth);
2463	assert(tuHeight < 4);
2464
2465	UInt explicitRdpcmMode = cu->getExplicitRdpcmMode(compID, absPartIdx);
2466
2467	if( explicitRdpcmMode == RDPCM_OFF )
2468	{
2469	m_pcBinIf->encodeBin (0, m_explicitRdpcmFlagSCModel.get (0, toChannelType(compID), 0));
2470	}
2471	else if( explicitRdpcmMode == RDPCM_HOR \|\| explicitRdpcmMode == RDPCM_VER )
2472	{
2473	m_pcBinIf->encodeBin (1, m_explicitRdpcmFlagSCModel.get (0, toChannelType(compID), 0));
2474	if(explicitRdpcmMode == RDPCM_HOR)
2475	{
2476	m_pcBinIf->encodeBin ( 0, m_explicitRdpcmDirSCModel.get(0, toChannelType(compID), 0));
2477	}
2478	else
2479	{
2480	m_pcBinIf->encodeBin ( 1, m_explicitRdpcmDirSCModel.get(0, toChannelType(compID), 0));
2481	}
2482	}
2483	else
2484	{
2485	assert(0);
2486	}
2487	}
2488
2489	#if NH_3D_DMM \|\| H_3D_DIM_SDC \|\| H_3D_INTER_SDC
2490	Void TEncSbac::codeDeltaDC( TComDataCU* pcCU, UInt absPartIdx )
2491	{
2492	#if H_3D_DIM_SDC \|\| H_3D_INTER_SDC
2493	if( !(pcCU->getSDCFlag( absPartIdx )) )
2494	#endif
2495	#if NH_3D_DMM
2496	if( !(pcCU->isIntra( absPartIdx ) && isDmmMode( pcCU->getIntraDir( CHANNEL_TYPE_LUMA, absPartIdx ) )) )
2497	#endif
2498	assert( 0 );
2499
2500	UInt uiNumSegments = 1;
2501	#if NH_3D_DMM
2502	uiNumSegments = isDmmMode( pcCU->getIntraDir( CHANNEL_TYPE_LUMA, absPartIdx ) ) ? 2 : 1;
2503	#endif
2504
2505	UInt hasDeltaDC = 1;
2506	#if H_3D_DIM_SDC
2507	if( pcCU->isIntra( absPartIdx ) && pcCU->getSDCFlag( absPartIdx ))
2508	{
2509	if( uiNumSegments == 1 )
2510	{
2511	hasDeltaDC = pcCU->getSDCSegmentDCOffset( 0, absPartIdx ) ? 1 : 0;
2512	}
2513	else
2514	{
2515	hasDeltaDC = ( pcCU->getSDCSegmentDCOffset( 0, absPartIdx ) \|\| pcCU->getSDCSegmentDCOffset( 1, absPartIdx ) ) ? 1 : 0;
2516	}
2517	m_pcBinIf->encodeBin( hasDeltaDC, m_cDdcFlagSCModel.get( 0, 0, 0 ) );
2518	}
2519	#endif
2520
2521	if( hasDeltaDC )
2522	{
2523	for( UInt segment = 0; segment < uiNumSegments; segment++ )
2524	{
2525	Pel deltaDC = 0;
2526	if( pcCU->isIntra( absPartIdx ) )
2527	{
2528	#if H_3D_DIM_SDC
2529	if( pcCU->getSDCFlag( absPartIdx ) )
2530	{
2531	deltaDC = pcCU->getSDCSegmentDCOffset( segment, absPartIdx );
2532	}
2533	else
2534	{
2535	#endif
2536	#if NH_3D_DMM
2537	deltaDC = pcCU->getDmmDeltaDC( getDmmType( pcCU->getIntraDir( CHANNEL_TYPE_LUMA, absPartIdx ) ), segment, absPartIdx );
2538	#endif
2539	#if H_3D_DIM_SDC
2540	}
2541	#endif
2542	}
2543	#if H_3D_INTER_SDC
2544	else
2545	{
2546	deltaDC = pcCU->getSDCSegmentDCOffset( segment, absPartIdx );
2547	}
2548	#endif
2549	xCodeDeltaDC( deltaDC, uiNumSegments );
2550	}
2551	}
2552	}
2553
2554	Void TEncSbac::xCodeDeltaDC( Pel valDeltaDC, UInt uiNumSeg )
2555	{
2556	xWriteExGolombLevelDdc( UInt( abs( valDeltaDC ) - ( uiNumSeg > 1 ? 0 : 1 ) ) );
2557	if( valDeltaDC != 0 )
2558	{
2559	UInt uiSign = valDeltaDC > 0 ? 0 : 1;
2560	m_pcBinIf->encodeBinEP( uiSign );
2561	}
2562	}
2563
2564	Void TEncSbac::xWriteExGolombLevelDdc( UInt uiSymbol )
2565	{
2566	if( uiSymbol )
2567	{
2568	m_pcBinIf->encodeBin( 1, m_cDdcDataSCModel.get(0, 0, 0) );
2569	UInt uiCount = 0;
2570	Bool bNoExGo = ( uiSymbol < 3 );
2571
2572	while( --uiSymbol && ++uiCount < 3 )
2573	{
2574	m_pcBinIf->encodeBin( 1, m_cDdcDataSCModel.get(0, 0, 0) );
2575	}
2576	if( bNoExGo )
2577	{
2578	m_pcBinIf->encodeBin( 0, m_cDdcDataSCModel.get(0, 0, 0) );
2579	}
2580	else
2581	{
2582	xWriteEpExGolomb( uiSymbol, 0 );
2583	}
2584	}
2585	else
2586	{
2587	m_pcBinIf->encodeBin( 0, m_cDdcDataSCModel.get(0, 0, 0) );
2588	}
2589
2590	return;
2591	}
2592	#endif
2593
2594	#if NH_3D_DMM
2595	Void TEncSbac::xCodeIntraDepthMode( TComDataCU* pcCU, UInt absPartIdx )
2596	{
2597	UInt dir = pcCU->getIntraDir( CHANNEL_TYPE_LUMA, absPartIdx );
2598
2599	if( ( pcCU->getSlice()->getSPS()->getMaxCUWidth() >> pcCU->getDepth( absPartIdx ) ) < 64 ) //DMM and HEVC intra modes are both allowed
2600	{
2601	m_pcBinIf->encodeBin( isDmmMode( dir ) ? 0 : 1, m_cNotDmmFlagSCModel.get( 0, 0, 0 ) );
2602	}
2603	if( isDmmMode( dir ) )
2604	{
2605	UInt uiCodeIdx = 0;
2606
2607	switch( getDmmType( dir ) )
2608	{
2609	case DMM1_IDX: uiCodeIdx = 0; break;
2610	case DMM4_IDX: uiCodeIdx = 1; break;
2611	default: break;
2612	}
2613	//mode coding
2614	if( pcCU->getSlice()->getIntraSdcWedgeFlag() && pcCU->getSlice()->getIntraContourFlag())
2615	{
2616	m_pcBinIf->encodeBin( uiCodeIdx == 0 ? 0 : 1, m_cDmmModeSCModel.get( 0, 0, 0 ) );
2617	}
2618	}
2619	}
2620
2621	Void TEncSbac::xCodeDmmData( TComDataCU* pcCU, UInt absPartIdx )
2622	{
2623	UInt dir = pcCU->getIntraDir( CHANNEL_TYPE_LUMA, absPartIdx );
2624	switch( getDmmType( dir ) )
2625	{
2626	case( DMM1_IDX ): { xCodeDmm1WedgeIdx( pcCU->getDmm1WedgeTabIdx( absPartIdx ), g_dmm1TabIdxBits[pcCU->getIntraSizeIdx(absPartIdx)] ); } break;
2627	case( DMM4_IDX ): break;
2628	default: break;
2629	}
2630	}
2631
2632	Void TEncSbac::xCodeDmm1WedgeIdx( UInt uiTabIdx, Int iNumBit )
2633	{
2634	for ( Int i = 0; i < iNumBit; i++ )
2635	{
2636	m_pcBinIf->encodeBinEP( ( uiTabIdx >> i ) & 1 );
2637	}
2638	}
2639	#endif
2640
2641	#if H_3D_INTER_SDC
2642	Void TEncSbac::codeSDCFlag( TComDataCU* pcCU, UInt uiAbsPartIdx )
2643	{
2644	UInt uiSymbol = pcCU->getSDCFlag( uiAbsPartIdx ) ? 1 : 0;
2645	UInt uiCtxSDCFlag = pcCU->getCtxSDCFlag( uiAbsPartIdx );
2646	DTRACE_CU("dc_only_flag", uiSymbol)
2647	m_pcBinIf->encodeBin( uiSymbol, m_cSDCFlagSCModel.get( 0, 0, uiCtxSDCFlag ) );
2648	}
2649
2650	#endif
2651
2652	#if H_3D_DBBP
2653	Void TEncSbac::codeDBBPFlag( TComDataCU* pcCU, UInt uiAbsPartIdx )
2654	{
2655	PartSize ePartSize = pcCU->getPartitionSize( uiAbsPartIdx );
2656	AOF( ePartSize == SIZE_2NxN \|\| ePartSize == SIZE_Nx2N );
2657	AOF( pcCU->getSlice()->getDepthBasedBlkPartFlag() );
2658	AOF( !pcCU->getSlice()->getIsDepth() );
2659
2660	UInt uiSymbol = pcCU->getDBBPFlag( uiAbsPartIdx ) ? 1 : 0;
2661	m_pcBinIf->encodeBin( uiSymbol, m_cDBBPFlagSCModel.get( 0, 0, 0 ) );
2662	DTRACE_CU("dbbp_flag", uiSymbol)
2663	}
2664	#endif
2665
2666	//! \}

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/TLibEncoder/TEncSbac.cpp @ 1216

Download in other formats: