Context navigation

source: 3DVCSoftware/branches/HTM-6.2-dev3-RWTH-Fix/source/Lib/TLibEncoder/TEncSbac.cpp @ 414

Visit:

Last change on this file since 414 was 414, checked in by rwth, 13 years ago
renamed LGE_CONCATENATE to LGE_CONCATENATE_D0141
Property svn:eol-style set to `native`
File size: 91.6 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-2012, 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
41	#include <map>
42	#include <algorithm>
43
44	#if RWTH_SDC_DLT_B0036
45	#define GetNumDepthValues() (pcCU->getSlice()->getSPS()->getNumDepthValues())
46	#define GetBitsPerDepthValue() (pcCU->getSlice()->getSPS()->getBitsPerDepthValue())
47	#if LGE_CONCATENATE_D0141
48	#define PrefixThreshold ( ((GetNumDepthValues() * 3) >> 2) )
49	#define BitsPerSuffix ( (UInt)ceil( Log2(GetNumDepthValues() - PrefixThreshold) ) )
50	#endif
51	#endif
52
53	//! \ingroup TLibEncoder
54	//! \{
55
56	// ====================================================================================================================
57	// Constructor / destructor / create / destroy
58	// ====================================================================================================================
59
60	TEncSbac::TEncSbac()
61	// new structure here
62	: m_pcBitIf ( NULL )
63	, m_pcSlice ( NULL )
64	, m_pcBinIf ( NULL )
65	, m_bAlfCtrl ( false )
66	, m_uiCoeffCost ( 0 )
67	, m_uiMaxAlfCtrlDepth ( 0 )
68	, m_numContextModels ( 0 )
69	, m_cCUSplitFlagSCModel ( 1, 1, NUM_SPLIT_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels )
70	, m_cCUSkipFlagSCModel ( 1, 1, NUM_SKIP_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels)
71	#if LGE_ILLUCOMP_B0045
72	, m_cCUICFlagSCModel ( 1, 1, NUM_IC_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels)
73	#endif
74	, m_cCUMergeFlagExtSCModel ( 1, 1, NUM_MERGE_FLAG_EXT_CTX , m_contextModels + m_numContextModels, m_numContextModels)
75	, m_cCUMergeIdxExtSCModel ( 1, 1, NUM_MERGE_IDX_EXT_CTX , m_contextModels + m_numContextModels, m_numContextModels)
76	#if H3D_IVRP
77	, m_cResPredFlagSCModel ( 1, 1, NUM_RES_PRED_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels)
78	#endif
79	, m_cCUPartSizeSCModel ( 1, 1, NUM_PART_SIZE_CTX , m_contextModels + m_numContextModels, m_numContextModels)
80	, m_cCUPredModeSCModel ( 1, 1, NUM_PRED_MODE_CTX , m_contextModels + m_numContextModels, m_numContextModels)
81	, m_cCUAlfCtrlFlagSCModel ( 1, 1, NUM_ALF_CTRL_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels)
82	, m_cCUIntraPredSCModel ( 1, 1, NUM_ADI_CTX , m_contextModels + m_numContextModels, m_numContextModels)
83	, m_cCUChromaPredSCModel ( 1, 1, NUM_CHROMA_PRED_CTX , m_contextModels + m_numContextModels, m_numContextModels)
84	, m_cCUDeltaQpSCModel ( 1, 1, NUM_DELTA_QP_CTX , m_contextModels + m_numContextModels, m_numContextModels)
85	, m_cCUInterDirSCModel ( 1, 1, NUM_INTER_DIR_CTX , m_contextModels + m_numContextModels, m_numContextModels)
86	, m_cCURefPicSCModel ( 1, 1, NUM_REF_NO_CTX , m_contextModels + m_numContextModels, m_numContextModels)
87	, m_cCUMvdSCModel ( 1, 1, NUM_MV_RES_CTX , m_contextModels + m_numContextModels, m_numContextModels)
88	, m_cCUQtCbfSCModel ( 1, 2, NUM_QT_CBF_CTX , m_contextModels + m_numContextModels, m_numContextModels)
89	, m_cCUTransSubdivFlagSCModel ( 1, 1, NUM_TRANS_SUBDIV_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels)
90	, m_cCUQtRootCbfSCModel ( 1, 1, NUM_QT_ROOT_CBF_CTX , m_contextModels + m_numContextModels, m_numContextModels)
91	, m_cCUSigCoeffGroupSCModel ( 1, 2, NUM_SIG_CG_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels)
92	, m_cCUSigSCModel ( 1, 1, NUM_SIG_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels)
93	, m_cCuCtxLastX ( 1, 2, NUM_CTX_LAST_FLAG_XY , m_contextModels + m_numContextModels, m_numContextModels)
94	, m_cCuCtxLastY ( 1, 2, NUM_CTX_LAST_FLAG_XY , m_contextModels + m_numContextModels, m_numContextModels)
95	, m_cCUOneSCModel ( 1, 1, NUM_ONE_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels)
96	, m_cCUAbsSCModel ( 1, 1, NUM_ABS_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels)
97	, m_cMVPIdxSCModel ( 1, 1, NUM_MVP_IDX_CTX , m_contextModels + m_numContextModels, m_numContextModels)
98	, m_cALFFlagSCModel ( 1, 1, NUM_ALF_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels)
99	, m_cALFUvlcSCModel ( 1, 1, NUM_ALF_UVLC_CTX , m_contextModels + m_numContextModels, m_numContextModels)
100	, m_cALFSvlcSCModel ( 1, 1, NUM_ALF_SVLC_CTX , m_contextModels + m_numContextModels, m_numContextModels)
101	, m_cCUAMPSCModel ( 1, 1, NUM_CU_AMP_CTX , m_contextModels + m_numContextModels, m_numContextModels)
102	, m_cSaoFlagSCModel ( 1, 1, NUM_SAO_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels)
103	, m_cSaoUvlcSCModel ( 1, 1, NUM_SAO_UVLC_CTX , m_contextModels + m_numContextModels, m_numContextModels)
104	, m_cSaoSvlcSCModel ( 1, 1, NUM_SAO_SVLC_CTX , m_contextModels + m_numContextModels, m_numContextModels)
105	, m_cSaoMergeLeftSCModel ( 1, 1, NUM_SAO_MERGE_LEFT_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels)
106	, m_cSaoMergeUpSCModel ( 1, 1, NUM_SAO_MERGE_UP_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels)
107	, m_cSaoTypeIdxSCModel ( 1, 1, NUM_SAO_TYPE_IDX_CTX , m_contextModels + m_numContextModels, m_numContextModels)
108	#if HHI_DMM_WEDGE_INTRA \|\| HHI_DMM_PRED_TEX
109	#if !PKU_QC_DEPTH_INTRA_UNI_D0195
110	, m_cDmmFlagSCModel ( 1, 1, NUM_DMM_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels)
111	, m_cDmmModeSCModel ( 1, 1, NUM_DMM_MODE_CTX , m_contextModels + m_numContextModels, m_numContextModels)
112	#endif
113	, m_cDmmDataSCModel ( 1, 1, NUM_DMM_DATA_CTX , m_contextModels + m_numContextModels, m_numContextModels)
114	#endif
115	#if LGE_EDGE_INTRA_A0070
116	, m_cEdgeIntraSCModel ( 1, 1, NUM_EDGE_INTRA_CTX , m_contextModels + m_numContextModels, m_numContextModels)
117	#if LGE_EDGE_INTRA_DELTA_DC
118	, m_cEdgeIntraDeltaDCSCModel ( 1, 1, NUM_EDGE_INTRA_DELTA_DC_CTX , m_contextModels + m_numContextModels, m_numContextModels)
119	#endif
120	#endif
121	#if RWTH_SDC_DLT_B0036
122	#if !PKU_QC_DEPTH_INTRA_UNI_D0195
123	, m_cSDCFlagSCModel ( 1, 1, SDC_NUM_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels)
124	#else
125	, m_cDepthModeModel ( 1, 1, DEPTH_MODE_NUM_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels)
126	, m_cDmmDeltaFlagModel ( 1, 1, DMM_DELTA_NUM_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels)
127	#endif
128	#if RWTH_SDC_CTX_SIMPL_D0032
129	, m_cSDCResidualFlagSCModel ( 1, 1, SDC_NUM_RESIDUAL_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels)
130	, m_cSDCResidualSCModel ( 1, 1, SDC_NUM_RESIDUAL_CTX , m_contextModels + m_numContextModels, m_numContextModels)
131	, m_cSDCPredModeSCModel ( 1, 3, SDC_NUM_PRED_MODE_CTX , m_contextModels + m_numContextModels, m_numContextModels)
132	#else
133	, m_cSDCResidualFlagSCModel ( 1, 2, SDC_NUM_RESIDUAL_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels)
134	, m_cSDCResidualSignFlagSCModel ( 1, 2, SDC_NUM_SIGN_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels)
135	, m_cSDCResidualSCModel ( 1, 2, SDC_NUM_RESIDUAL_CTX , m_contextModels + m_numContextModels, m_numContextModels)
136	, m_cSDCPredModeSCModel ( 1, 3, SDC_NUM_PRED_MODE_CTX , m_contextModels + m_numContextModels, m_numContextModels)
137	#endif
138	#endif
139	{
140	assert( m_numContextModels <= MAX_NUM_CTX_MOD );
141	m_iSliceGranularity = 0;
142	}
143
144	TEncSbac::~TEncSbac()
145	{
146	}
147
148	// ====================================================================================================================
149	// Public member functions
150	// ====================================================================================================================
151
152	Void TEncSbac::resetEntropy ()
153	{
154	Int iQp = m_pcSlice->getSliceQp();
155	SliceType eSliceType = m_pcSlice->getSliceType();
156
157	#if CABAC_INIT_FLAG
158	Int encCABACTableIdx = m_pcSlice->getPPS()->getEncCABACTableIdx();
159	if (!m_pcSlice->isIntra() && (encCABACTableIdx==B_SLICE \|\| encCABACTableIdx==P_SLICE) && m_pcSlice->getPPS()->getCabacInitPresentFlag())
160	{
161	eSliceType = (SliceType) encCABACTableIdx;
162	}
163	#endif
164
165	m_cCUSplitFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_SPLIT_FLAG );
166
167	m_cCUSkipFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_SKIP_FLAG );
168	#if LGE_ILLUCOMP_B0045
169	m_cCUICFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_IC_FLAG );
170	#endif
171	m_cCUAlfCtrlFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_ALF_CTRL_FLAG );
172	m_cCUMergeFlagExtSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_MERGE_FLAG_EXT);
173	m_cCUMergeIdxExtSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_MERGE_IDX_EXT);
174	#if H3D_IVRP
175	m_cResPredFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_RES_PRED_FLAG );
176	#endif
177	m_cCUPartSizeSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_PART_SIZE );
178	m_cCUAMPSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_CU_AMP_POS );
179	m_cCUPredModeSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_PRED_MODE );
180	m_cCUIntraPredSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_INTRA_PRED_MODE );
181	m_cCUChromaPredSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_CHROMA_PRED_MODE );
182	m_cCUInterDirSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_INTER_DIR );
183	m_cCUMvdSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_MVD );
184	m_cCURefPicSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_REF_PIC );
185	m_cCUDeltaQpSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_DQP );
186	m_cCUQtCbfSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_QT_CBF );
187	m_cCUQtRootCbfSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_QT_ROOT_CBF );
188	m_cCUSigCoeffGroupSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_SIG_CG_FLAG );
189	m_cCUSigSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_SIG_FLAG );
190	m_cCuCtxLastX.initBuffer ( eSliceType, iQp, (UChar*)INIT_LAST );
191	m_cCuCtxLastY.initBuffer ( eSliceType, iQp, (UChar*)INIT_LAST );
192	m_cCUOneSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_ONE_FLAG );
193	m_cCUAbsSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_ABS_FLAG );
194	m_cMVPIdxSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_MVP_IDX );
195	m_cALFFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_ALF_FLAG );
196	m_cALFUvlcSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_ALF_UVLC );
197	m_cALFSvlcSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_ALF_SVLC );
198	m_cCUTransSubdivFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_TRANS_SUBDIV_FLAG );
199	m_cSaoFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_SAO_FLAG );
200	m_cSaoUvlcSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_SAO_UVLC );
201	m_cSaoSvlcSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_SAO_SVLC );
202	m_cSaoMergeLeftSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_SAO_MERGE_LEFT_FLAG );
203	m_cSaoMergeUpSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_SAO_MERGE_UP_FLAG );
204	m_cSaoTypeIdxSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_SAO_TYPE_IDX );
205	#if HHI_DMM_WEDGE_INTRA \|\| HHI_DMM_PRED_TEX
206	#if !PKU_QC_DEPTH_INTRA_UNI_D0195
207	m_cDmmFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_DMM_FLAG );
208	m_cDmmModeSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_DMM_MODE );
209	#endif
210	m_cDmmDataSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_DMM_DATA );
211	#endif
212	#if LGE_EDGE_INTRA_A0070
213	m_cEdgeIntraSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_EDGE_INTRA );
214	#if LGE_EDGE_INTRA_DELTA_DC
215	m_cEdgeIntraDeltaDCSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_EDGE_INTRA_DELTA_DC );
216	#endif
217	#endif
218	#if RWTH_SDC_DLT_B0036
219	#if !PKU_QC_DEPTH_INTRA_UNI_D0195
220	m_cSDCFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_SDC_FLAG );
221	#else
222	m_cDepthModeModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_DEPTHMODE_FLAG );
223	m_cDmmDeltaFlagModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_DMMDELTA_FLAG );
224	#endif
225	m_cSDCResidualFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_SDC_RESIDUAL_FLAG );
226	m_cSDCResidualSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_SDC_RESIDUAL );
227	#if !RWTH_SDC_CTX_SIMPL_D0032
228	m_cSDCResidualSignFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_SDC_SIGN_FLAG );
229	#endif
230	m_cSDCPredModeSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_SDC_PRED_MODE );
231	#endif
232
233	// new structure
234	m_uiLastQp = iQp;
235
236	m_pcBinIf->start();
237
238	return;
239	}
240
241	#if CABAC_INIT_FLAG
242	/** The function does the following:
243	* If current slice type is P/B then it determines the distance of initialisation type 1 and 2 from the current CABAC states and
244	* stores the index of the closest table. This index is used for the next P/B slice when cabac_init_present_flag is true.
245	*/
246	Void TEncSbac::determineCabacInitIdx()
247	{
248	Int qp = m_pcSlice->getSliceQp();
249
250	if (!m_pcSlice->isIntra())
251	{
252	SliceType aSliceTypeChoices[] = {B_SLICE, P_SLICE};
253
254	UInt bestCost = MAX_UINT;
255	SliceType bestSliceType = aSliceTypeChoices[0];
256	for (UInt idx=0; idx<2; idx++)
257	{
258	UInt curCost = 0;
259	SliceType curSliceType = aSliceTypeChoices[idx];
260
261	curCost = m_cCUSplitFlagSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_SPLIT_FLAG );
262	curCost += m_cCUSkipFlagSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_SKIP_FLAG );
263	#if LGE_ILLUCOMP_B0045
264	curCost += m_cCUICFlagSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_IC_FLAG );
265	#endif
266	curCost += m_cCUAlfCtrlFlagSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_ALF_CTRL_FLAG );
267	curCost += m_cCUMergeFlagExtSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_MERGE_FLAG_EXT);
268	curCost += m_cCUMergeIdxExtSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_MERGE_IDX_EXT);
269	#if H3D_IVRP
270	curCost += m_cResPredFlagSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_RES_PRED_FLAG);
271	#endif
272	curCost += m_cCUPartSizeSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_PART_SIZE );
273	curCost += m_cCUAMPSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_CU_AMP_POS );
274	curCost += m_cCUPredModeSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_PRED_MODE );
275	curCost += m_cCUIntraPredSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_INTRA_PRED_MODE );
276	curCost += m_cCUChromaPredSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_CHROMA_PRED_MODE );
277	curCost += m_cCUInterDirSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_INTER_DIR );
278	curCost += m_cCUMvdSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_MVD );
279	curCost += m_cCURefPicSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_REF_PIC );
280	curCost += m_cCUDeltaQpSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_DQP );
281	curCost += m_cCUQtCbfSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_QT_CBF );
282	curCost += m_cCUQtRootCbfSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_QT_ROOT_CBF );
283	curCost += m_cCUSigCoeffGroupSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_SIG_CG_FLAG );
284	curCost += m_cCUSigSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_SIG_FLAG );
285	curCost += m_cCuCtxLastX.calcCost ( curSliceType, qp, (UChar*)INIT_LAST );
286	curCost += m_cCuCtxLastY.calcCost ( curSliceType, qp, (UChar*)INIT_LAST );
287	curCost += m_cCUOneSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_ONE_FLAG );
288	curCost += m_cCUAbsSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_ABS_FLAG );
289	curCost += m_cMVPIdxSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_MVP_IDX );
290	curCost += m_cALFFlagSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_ALF_FLAG );
291	curCost += m_cALFUvlcSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_ALF_UVLC );
292	curCost += m_cALFSvlcSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_ALF_SVLC );
293	curCost += m_cCUTransSubdivFlagSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_TRANS_SUBDIV_FLAG );
294	curCost += m_cSaoFlagSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_SAO_FLAG );
295	curCost += m_cSaoUvlcSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_SAO_UVLC );
296	curCost += m_cSaoSvlcSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_SAO_SVLC );
297	curCost += m_cSaoMergeLeftSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_SAO_MERGE_LEFT_FLAG );
298	curCost += m_cSaoMergeUpSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_SAO_MERGE_UP_FLAG );
299	curCost += m_cSaoTypeIdxSCModel.calcCost ( curSliceType, qp, (UChar*)INIT_SAO_TYPE_IDX );
300
301	if (curCost < bestCost)
302	{
303	bestSliceType = curSliceType;
304	bestCost = curCost;
305	}
306	}
307	m_pcSlice->getPPS()->setEncCABACTableIdx( bestSliceType );
308	}
309	else
310	{
311	m_pcSlice->getPPS()->setEncCABACTableIdx( I_SLICE );
312	}
313
314	#if CABAC_INIT_FLAG && FIX_POZNAN_CABAC_INIT_FLAG
315	m_pcSlice->getPPS()->setEncPrevPOC( m_pcSlice->getPOC() );
316	#endif
317	}
318	#endif
319
320
321	/** The function does the followng: Write out terminate bit. Flush CABAC. Intialize CABAC states. Start CABAC.
322	*/
323	Void TEncSbac::updateContextTables( SliceType eSliceType, Int iQp, Bool bExecuteFinish )
324	{
325	m_pcBinIf->encodeBinTrm(1);
326	if (bExecuteFinish) m_pcBinIf->finish();
327	m_cCUSplitFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_SPLIT_FLAG );
328
329	m_cCUSkipFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_SKIP_FLAG );
330	#if LGE_ILLUCOMP_B0045
331	m_cCUICFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_IC_FLAG );
332	#endif
333	m_cCUAlfCtrlFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_ALF_CTRL_FLAG );
334	m_cCUMergeFlagExtSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_MERGE_FLAG_EXT);
335	m_cCUMergeIdxExtSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_MERGE_IDX_EXT);
336	#if H3D_IVRP
337	m_cResPredFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_RES_PRED_FLAG );
338	#endif
339	m_cCUPartSizeSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_PART_SIZE );
340	m_cCUAMPSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_CU_AMP_POS );
341	m_cCUPredModeSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_PRED_MODE );
342	m_cCUIntraPredSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_INTRA_PRED_MODE );
343	m_cCUChromaPredSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_CHROMA_PRED_MODE );
344	m_cCUInterDirSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_INTER_DIR );
345	m_cCUMvdSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_MVD );
346	m_cCURefPicSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_REF_PIC );
347	m_cCUDeltaQpSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_DQP );
348	m_cCUQtCbfSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_QT_CBF );
349	m_cCUQtRootCbfSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_QT_ROOT_CBF );
350	m_cCUSigCoeffGroupSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_SIG_CG_FLAG );
351	m_cCUSigSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_SIG_FLAG );
352	m_cCuCtxLastX.initBuffer ( eSliceType, iQp, (UChar*)INIT_LAST );
353	m_cCuCtxLastY.initBuffer ( eSliceType, iQp, (UChar*)INIT_LAST );
354	m_cCUOneSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_ONE_FLAG );
355	m_cCUAbsSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_ABS_FLAG );
356	m_cMVPIdxSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_MVP_IDX );
357	m_cALFFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_ALF_FLAG );
358	m_cALFUvlcSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_ALF_UVLC );
359	m_cALFSvlcSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_ALF_SVLC );
360	m_cCUTransSubdivFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_TRANS_SUBDIV_FLAG );
361	m_cSaoFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_SAO_FLAG );
362	m_cSaoUvlcSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_SAO_UVLC );
363	m_cSaoSvlcSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_SAO_SVLC );
364	m_cSaoMergeLeftSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_SAO_MERGE_LEFT_FLAG );
365	m_cSaoMergeUpSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_SAO_MERGE_UP_FLAG );
366	m_cSaoTypeIdxSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_SAO_TYPE_IDX );
367	#if HHI_DMM_WEDGE_INTRA \|\| HHI_DMM_PRED_TEX
368	#if !PKU_QC_DEPTH_INTRA_UNI_D0195
369	m_cDmmFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_DMM_FLAG );
370	m_cDmmModeSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_DMM_MODE );
371	#endif
372	m_cDmmDataSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_DMM_DATA );
373	#endif
374	#if RWTH_SDC_DLT_B0036
375	#if !PKU_QC_DEPTH_INTRA_UNI_D0195
376	m_cSDCFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_SDC_FLAG );
377	#else
378	m_cDepthModeModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_DEPTHMODE_FLAG );
379	m_cDmmDeltaFlagModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_DMMDELTA_FLAG );
380	#endif
381	m_cSDCResidualFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_SDC_RESIDUAL_FLAG );
382	m_cSDCResidualSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_SDC_RESIDUAL );
383	#if !RWTH_SDC_CTX_SIMPL_D0032
384	m_cSDCResidualSignFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_SDC_SIGN_FLAG );
385	#endif
386	m_cSDCPredModeSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_SDC_PRED_MODE );
387	#endif
388
389	m_pcBinIf->start();
390	}
391
392	Void TEncSbac::writeTileMarker( UInt uiTileIdx, UInt uiBitsUsed )
393	{
394	for (Int iShift=uiBitsUsed-1; iShift>=0; iShift--)
395	{
396	m_pcBinIf->encodeBinEP ( (uiTileIdx & (1 << iShift)) >> iShift );
397	}
398	}
399
400	void TEncSbac::codeSEI(const SEI&)
401	{
402	assert(0);
403	}
404
405	#if VIDYO_VPS_INTEGRATION\|QC_MVHEVC_B0046
406	Void TEncSbac::codeVPS( TComVPS* pcVPS )
407	{
408	assert (0);
409	return;
410	}
411	#endif
412
413	#if HHI_MPI \|\| H3D_QTL
414	Void TEncSbac::codeSPS( TComSPS* pcSPS, Bool bIsDepth )
415	#else
416	Void TEncSbac::codeSPS( TComSPS* pcSPS )
417	#endif
418	{
419	assert (0);
420	return;
421	}
422
423	Void TEncSbac::codePPS( TComPPS* pcPPS )
424	{
425	assert (0);
426	return;
427	}
428
429	Void TEncSbac::codeSliceHeader( TComSlice* pcSlice )
430	{
431	assert (0);
432	return;
433	}
434
435	Void TEncSbac::codeTilesWPPEntryPoint( TComSlice* pSlice )
436	{
437	assert (0);
438	return;
439	}
440
441	Void TEncSbac::codeTerminatingBit( UInt uilsLast )
442	{
443	m_pcBinIf->encodeBinTrm( uilsLast );
444	}
445
446	Void TEncSbac::codeSliceFinish()
447	{
448	m_pcBinIf->finish();
449	}
450
451	Void TEncSbac::codeFlush()
452	{
453	m_pcBinIf->flush();
454	}
455
456	Void TEncSbac::encodeStart()
457	{
458	m_pcBinIf->start();
459	}
460
461	Void TEncSbac::xWriteUnarySymbol( UInt uiSymbol, ContextModel* pcSCModel, Int iOffset )
462	{
463	m_pcBinIf->encodeBin( uiSymbol ? 1 : 0, pcSCModel[0] );
464
465	if( 0 == uiSymbol)
466	{
467	return;
468	}
469
470	while( uiSymbol-- )
471	{
472	m_pcBinIf->encodeBin( uiSymbol ? 1 : 0, pcSCModel[ iOffset ] );
473	}
474
475	return;
476	}
477
478	Void TEncSbac::xWriteUnaryMaxSymbol( UInt uiSymbol, ContextModel* pcSCModel, Int iOffset, UInt uiMaxSymbol )
479	{
480	if (uiMaxSymbol == 0)
481	{
482	return;
483	}
484
485	m_pcBinIf->encodeBin( uiSymbol ? 1 : 0, pcSCModel[ 0 ] );
486
487	if ( uiSymbol == 0 )
488	{
489	return;
490	}
491
492	Bool bCodeLast = ( uiMaxSymbol > uiSymbol );
493
494	while( --uiSymbol )
495	{
496	m_pcBinIf->encodeBin( 1, pcSCModel[ iOffset ] );
497	}
498	if( bCodeLast )
499	{
500	m_pcBinIf->encodeBin( 0, pcSCModel[ iOffset ] );
501	}
502
503	return;
504	}
505
506	Void TEncSbac::xWriteEpExGolomb( UInt uiSymbol, UInt uiCount )
507	{
508	UInt bins = 0;
509	Int numBins = 0;
510
511	while( uiSymbol >= (UInt)(1<<uiCount) )
512	{
513	bins = 2 * bins + 1;
514	numBins++;
515	uiSymbol -= 1 << uiCount;
516	uiCount ++;
517	}
518	bins = 2 * bins + 0;
519	numBins++;
520
521	bins = (bins << uiCount) \| uiSymbol;
522	numBins += uiCount;
523
524	assert( numBins <= 32 );
525	m_pcBinIf->encodeBinsEP( bins, numBins );
526	}
527
528	/** Coding of coeff_abs_level_minus3
529	* \param uiSymbol value of coeff_abs_level_minus3
530	* \param ruiGoRiceParam reference to Rice parameter
531	* \returns Void
532	*/
533	Void TEncSbac::xWriteGoRiceExGolomb( UInt uiSymbol, UInt &ruiGoRiceParam )
534	{
535	UInt uiMaxVlc = g_auiGoRiceRange[ ruiGoRiceParam ];
536	Bool bExGolomb = ( uiSymbol > uiMaxVlc );
537	UInt uiCodeWord = min<UInt>( uiSymbol, ( uiMaxVlc + 1 ) );
538	UInt uiQuotient = uiCodeWord >> ruiGoRiceParam;
539	UInt uiMaxPreLen = g_auiGoRicePrefixLen[ ruiGoRiceParam ];
540
541	UInt binValues;
542	Int numBins;
543
544	if ( uiQuotient >= uiMaxPreLen )
545	{
546	numBins = uiMaxPreLen;
547	binValues = ( 1 << numBins ) - 1;
548	}
549	else
550	{
551	numBins = uiQuotient + 1;
552	binValues = ( 1 << numBins ) - 2;
553	}
554
555	m_pcBinIf->encodeBinsEP( ( binValues << ruiGoRiceParam ) + uiCodeWord - ( uiQuotient << ruiGoRiceParam ), numBins + ruiGoRiceParam );
556
557	ruiGoRiceParam = g_aauiGoRiceUpdate[ ruiGoRiceParam ][ min<UInt>( uiSymbol, 23 ) ];
558
559	if( bExGolomb )
560	{
561	uiSymbol -= uiMaxVlc + 1;
562	xWriteEpExGolomb( uiSymbol, 0 );
563	}
564	}
565
566	// SBAC RD
567	Void TEncSbac::load ( TEncSbac* pSrc)
568	{
569	this->xCopyFrom(pSrc);
570	}
571
572	Void TEncSbac::loadIntraDirModeLuma( TEncSbac* pSrc)
573	{
574	m_pcBinIf->copyState( pSrc->m_pcBinIf );
575
576	this->m_cCUIntraPredSCModel .copyFrom( &pSrc->m_cCUIntraPredSCModel );
577	}
578
579	#if PKU_QC_DEPTH_INTRA_UNI_D0195
580	Void TEncSbac::loadDepthMode( TEncSbac* pSrc)
581	{
582	m_pcBinIf->copyState( pSrc->m_pcBinIf );
583
584	this->m_cDepthModeModel .copyFrom( &pSrc->m_cDepthModeModel );
585	this->m_cDmmDeltaFlagModel .copyFrom( &pSrc->m_cDmmDeltaFlagModel );
586	}
587	#endif
588	Void TEncSbac::store( TEncSbac* pDest)
589	{
590	pDest->xCopyFrom( this );
591	}
592
593
594	Void TEncSbac::xCopyFrom( TEncSbac* pSrc )
595	{
596	m_pcBinIf->copyState( pSrc->m_pcBinIf );
597
598	this->m_uiCoeffCost = pSrc->m_uiCoeffCost;
599	this->m_uiLastQp = pSrc->m_uiLastQp;
600
601	memcpy( m_contextModels, pSrc->m_contextModels, m_numContextModels * sizeof( ContextModel ) );
602	}
603
604	#if H3D_IVMP
605	Void TEncSbac::codeMVPIdx ( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList, Int iNum )
606	#else
607	Void TEncSbac::codeMVPIdx ( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList )
608	#endif
609	{
610	Int iSymbol = pcCU->getMVPIdx(eRefList, uiAbsPartIdx);
611	#if H3D_IVMP
612	#else
613	Int iNum = AMVP_MAX_NUM_CANDS;
614	#endif
615
616	xWriteUnaryMaxSymbol(iSymbol, m_cMVPIdxSCModel.get(0), 1, iNum-1);
617	}
618
619	Void TEncSbac::codePartSize( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
620	{
621	PartSize eSize = pcCU->getPartitionSize( uiAbsPartIdx );
622
623	#if H3D_QTL
624	TComSPS *sps = pcCU->getPic()->getSlice(0)->getSPS();
625	TComPic *pcTexture = pcCU->getSlice()->getTexturePic();
626	Bool bDepthMapDetect = (pcTexture != NULL);
627	Bool bIntraSliceDetect = (pcCU->getSlice()->getSliceType() == I_SLICE);
628
629	Bool rapPic = (pcCU->getSlice()->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR \|\| pcCU->getSlice()->getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA);
630	if(bDepthMapDetect && !bIntraSliceDetect && !rapPic && sps->getUseQTLPC() && pcCU->getPic()->getReduceBitsFlag())
631	{
632	TComDataCU *pcTextureCU = pcTexture->getCU(pcCU->getAddr());
633	UInt uiCUIdx = (pcCU->getZorderIdxInCU() == 0) ? uiAbsPartIdx : pcCU->getZorderIdxInCU();
634	assert(pcTextureCU->getDepth(uiCUIdx) >= uiDepth);
635	if (pcTextureCU->getDepth(uiCUIdx) == uiDepth && pcTextureCU->getPartitionSize( uiCUIdx ) != SIZE_NxN)
636	{
637	assert( eSize == SIZE_2Nx2N );
638	return;
639	}
640	}
641	#endif
642
643	if ( pcCU->isIntra( uiAbsPartIdx ) )
644	{
645	if( uiDepth == g_uiMaxCUDepth - g_uiAddCUDepth )
646	{
647	m_pcBinIf->encodeBin( eSize == SIZE_2Nx2N? 1 : 0, m_cCUPartSizeSCModel.get( 0, 0, 0 ) );
648	}
649	return;
650	}
651
652	switch(eSize)
653	{
654	case SIZE_2Nx2N:
655	{
656	m_pcBinIf->encodeBin( 1, m_cCUPartSizeSCModel.get( 0, 0, 0) );
657	break;
658	}
659	case SIZE_2NxN:
660	case SIZE_2NxnU:
661	case SIZE_2NxnD:
662	{
663	m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 0) );
664	m_pcBinIf->encodeBin( 1, m_cCUPartSizeSCModel.get( 0, 0, 1) );
665	if ( pcCU->getSlice()->getSPS()->getAMPAcc( uiDepth ) )
666	{
667	if (eSize == SIZE_2NxN)
668	{
669	m_pcBinIf->encodeBin(1, m_cCUAMPSCModel.get( 0, 0, 0 ));
670	}
671	else
672	{
673	m_pcBinIf->encodeBin(0, m_cCUAMPSCModel.get( 0, 0, 0 ));
674	m_pcBinIf->encodeBinEP((eSize == SIZE_2NxnU? 0: 1));
675	}
676	}
677	break;
678	}
679	case SIZE_Nx2N:
680	case SIZE_nLx2N:
681	case SIZE_nRx2N:
682	{
683	m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 0) );
684	m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 1) );
685	if( uiDepth == g_uiMaxCUDepth - g_uiAddCUDepth && !( pcCU->getSlice()->getSPS()->getDisInter4x4() && pcCU->getWidth(uiAbsPartIdx) == 8 && pcCU->getHeight(uiAbsPartIdx) == 8 ) )
686	{
687	m_pcBinIf->encodeBin( 1, m_cCUPartSizeSCModel.get( 0, 0, 2) );
688	}
689	if ( pcCU->getSlice()->getSPS()->getAMPAcc( uiDepth ) )
690	{
691	if (eSize == SIZE_Nx2N)
692	{
693	m_pcBinIf->encodeBin(1, m_cCUAMPSCModel.get( 0, 0, 0 ));
694	}
695	else
696	{
697	m_pcBinIf->encodeBin(0, m_cCUAMPSCModel.get( 0, 0, 0 ));
698	m_pcBinIf->encodeBinEP((eSize == SIZE_nLx2N? 0: 1));
699	}
700	}
701	break;
702	}
703	case SIZE_NxN:
704	{
705	if( uiDepth == g_uiMaxCUDepth - g_uiAddCUDepth && !( pcCU->getSlice()->getSPS()->getDisInter4x4() && pcCU->getWidth(uiAbsPartIdx) == 8 && pcCU->getHeight(uiAbsPartIdx) == 8 ) )
706	{
707	m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 0) );
708	m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 1) );
709	m_pcBinIf->encodeBin( 0, m_cCUPartSizeSCModel.get( 0, 0, 2) );
710	}
711	break;
712	}
713	default:
714	{
715	assert(0);
716	}
717	}
718	}
719
720	/** code prediction mode
721	* \param pcCU
722	* \param uiAbsPartIdx
723	* \returns Void
724	*/
725	Void TEncSbac::codePredMode( TComDataCU* pcCU, UInt uiAbsPartIdx )
726	{
727	#if RWTH_SDC_DLT_B0036
728	if ( pcCU->getSlice()->isIntra() )
729	{
730	assert( pcCU->isIntra(uiAbsPartIdx) );
731	return;
732	}
733	#endif
734
735	// get context function is here
736	Int iPredMode = pcCU->getPredictionMode( uiAbsPartIdx );
737	m_pcBinIf->encodeBin( iPredMode == MODE_INTER ? 0 : 1, m_cCUPredModeSCModel.get( 0, 0, 0 ) );
738	}
739
740	Void TEncSbac::codeAlfCtrlFlag( TComDataCU* pcCU, UInt uiAbsPartIdx )
741	{
742	if (!m_bAlfCtrl)
743	return;
744
745	if( pcCU->getDepth(uiAbsPartIdx) > m_uiMaxAlfCtrlDepth && !pcCU->isFirstAbsZorderIdxInDepth(uiAbsPartIdx, m_uiMaxAlfCtrlDepth))
746	{
747	return;
748	}
749
750	const UInt uiSymbol = pcCU->getAlfCtrlFlag( uiAbsPartIdx ) ? 1 : 0;
751	m_pcBinIf->encodeBin( uiSymbol, *m_cCUAlfCtrlFlagSCModel.get( 0 ) );
752	}
753
754	Void TEncSbac::codeAlfCtrlDepth()
755	{
756	if (!m_bAlfCtrl)
757	return;
758
759	UInt uiDepth = m_uiMaxAlfCtrlDepth;
760	xWriteUnaryMaxSymbol(uiDepth, m_cALFUvlcSCModel.get(0), 1, g_uiMaxCUDepth-1);
761	}
762
763	/** code skip flag
764	* \param pcCU
765	* \param uiAbsPartIdx
766	* \returns Void
767	*/
768	Void TEncSbac::codeSkipFlag( TComDataCU* pcCU, UInt uiAbsPartIdx )
769	{
770	// get context function is here
771	UInt uiSymbol = pcCU->isSkipped( uiAbsPartIdx ) ? 1 : 0;
772	UInt uiCtxSkip = pcCU->getCtxSkipFlag( uiAbsPartIdx ) ;
773	m_pcBinIf->encodeBin( uiSymbol, m_cCUSkipFlagSCModel.get( 0, 0, uiCtxSkip ) );
774	DTRACE_CABAC_VL( g_nSymbolCounter++ );
775	DTRACE_CABAC_T( "\tSkipFlag" );
776	DTRACE_CABAC_T( "\tuiCtxSkip: ");
777	DTRACE_CABAC_V( uiCtxSkip );
778	DTRACE_CABAC_T( "\tuiSymbol: ");
779	DTRACE_CABAC_V( uiSymbol );
780	DTRACE_CABAC_T( "\n");
781	}
782
783	#if LGE_ILLUCOMP_B0045
784	/** code Illumination Compensation flag
785	* \param pcCU
786	* \param uiAbsPartIdx
787	* \returns Void
788	*/
789	Void TEncSbac::codeICFlag( TComDataCU* pcCU, UInt uiAbsPartIdx )
790	{
791	// get context function is here
792	UInt uiSymbol = pcCU->getICFlag( uiAbsPartIdx ) ? 1 : 0;
793	UInt uiCtxIC = pcCU->getCtxICFlag( uiAbsPartIdx ) ;
794	m_pcBinIf->encodeBin( uiSymbol, m_cCUICFlagSCModel.get( 0, 0, uiCtxIC ) );
795	DTRACE_CABAC_VL( g_nSymbolCounter++ );
796	DTRACE_CABAC_T( "\tICFlag" );
797	DTRACE_CABAC_T( "\tuiCtxIC: ");
798	DTRACE_CABAC_V( uiCtxIC );
799	DTRACE_CABAC_T( "\tuiSymbol: ");
800	DTRACE_CABAC_V( uiSymbol );
801	DTRACE_CABAC_T( "\n");
802	}
803	#endif
804
805	/** code merge flag
806	* \param pcCU
807	* \param uiAbsPartIdx
808	* \returns Void
809	*/
810	Void TEncSbac::codeMergeFlag( TComDataCU* pcCU, UInt uiAbsPartIdx )
811	{
812	const UInt uiSymbol = pcCU->getMergeFlag( uiAbsPartIdx ) ? 1 : 0;
813	m_pcBinIf->encodeBin( uiSymbol, *m_cCUMergeFlagExtSCModel.get( 0 ) );
814
815	DTRACE_CABAC_VL( g_nSymbolCounter++ );
816	DTRACE_CABAC_T( "\tMergeFlag: " );
817	DTRACE_CABAC_V( uiSymbol );
818	DTRACE_CABAC_T( "\tAddress: " );
819	DTRACE_CABAC_V( pcCU->getAddr() );
820	DTRACE_CABAC_T( "\tuiAbsPartIdx: " );
821	DTRACE_CABAC_V( uiAbsPartIdx );
822	DTRACE_CABAC_T( "\n" );
823	}
824
825	/** code merge index
826	* \param pcCU
827	* \param uiAbsPartIdx
828	* \returns Void
829	*/
830	Void TEncSbac::codeMergeIndex( TComDataCU* pcCU, UInt uiAbsPartIdx )
831	{
832	UInt uiNumCand = MRG_MAX_NUM_CANDS;
833	UInt uiUnaryIdx = pcCU->getMergeIndex( uiAbsPartIdx );
834	uiNumCand = pcCU->getSlice()->getMaxNumMergeCand();
835	#if HHI_MPI
836	const Bool bMVIAvailable = pcCU->getSlice()->getSPS()->getUseMVI() && pcCU->getSlice()->getSliceType() != I_SLICE;
837	if( bMVIAvailable )
838	{
839	const Bool bUseMVI = pcCU->getTextureModeDepth( uiAbsPartIdx ) != -1;
840	if( bUseMVI )
841	{
842	uiUnaryIdx = (UInt)HHI_MPI_MERGE_POS;
843	}
844	else if( (Int)uiUnaryIdx >= (Int)HHI_MPI_MERGE_POS )
845	{
846	uiUnaryIdx++;
847	}
848	}
849	#endif
850	if ( uiNumCand > 1 )
851	{
852	for( UInt ui = 0; ui < uiNumCand - 1; ++ui )
853	{
854	const UInt uiSymbol = ui == uiUnaryIdx ? 0 : 1;
855	if ( ui==0 )
856	{
857	m_pcBinIf->encodeBin( uiSymbol, m_cCUMergeIdxExtSCModel.get( 0, 0, 0 ) );
858	}
859	else
860	{
861	m_pcBinIf->encodeBinEP( uiSymbol );
862	}
863	if( uiSymbol == 0 )
864	{
865	break;
866	}
867	}
868	}
869	DTRACE_CABAC_VL( g_nSymbolCounter++ );
870	DTRACE_CABAC_T( "\tparseMergeIndex()" );
871	DTRACE_CABAC_T( "\tuiMRGIdx= " );
872	DTRACE_CABAC_V( pcCU->getMergeIndex( uiAbsPartIdx ) );
873	DTRACE_CABAC_T( "\n" );
874	}
875
876	#if H3D_IVRP
877	Void
878	TEncSbac::codeResPredFlag( TComDataCU* pcCU, UInt uiAbsPartIdx )
879	{
880	UInt uiCtx = pcCU->getCtxResPredFlag( uiAbsPartIdx );
881	UInt uiSymbol = ( pcCU->getResPredFlag( uiAbsPartIdx ) ? 1 : 0 );
882	m_pcBinIf->encodeBin( uiSymbol, m_cResPredFlagSCModel.get( 0, 0, uiCtx ) );
883	}
884	#endif
885
886	Void TEncSbac::codeSplitFlag ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
887	{
888	if( uiDepth == g_uiMaxCUDepth - g_uiAddCUDepth )
889	return;
890
891	UInt uiCtx = pcCU->getCtxSplitFlag( uiAbsPartIdx, uiDepth );
892	UInt uiCurrSplitFlag = ( pcCU->getDepth( uiAbsPartIdx ) > uiDepth ) ? 1 : 0;
893
894	assert( uiCtx < 3 );
895
896	#if H3D_QTL
897	Bool bCodeSplitFlag = true;
898
899	TComSPS *sps = pcCU->getPic()->getSlice(0)->getSPS();
900	TComPic *pcTexture = pcCU->getSlice()->getTexturePic();
901	Bool bDepthMapDetect = (pcTexture != NULL);
902	Bool bIntraSliceDetect = (pcCU->getSlice()->getSliceType() == I_SLICE);
903
904	Bool rapPic = (pcCU->getSlice()->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR \|\| pcCU->getSlice()->getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA);
905	if(bDepthMapDetect && !bIntraSliceDetect && !rapPic && sps->getUseQTLPC() && pcCU->getPic()->getReduceBitsFlag())
906	{
907	TComDataCU *pcTextureCU = pcTexture->getCU(pcCU->getAddr());
908	UInt uiCUIdx = (pcCU->getZorderIdxInCU() == 0) ? uiAbsPartIdx : pcCU->getZorderIdxInCU();
909	assert(pcTextureCU->getDepth(uiCUIdx) >= uiDepth);
910	bCodeSplitFlag = (pcTextureCU->getDepth(uiCUIdx) > uiDepth);
911	}
912
913	if(!bCodeSplitFlag)
914	{
915	assert(uiCurrSplitFlag == 0);
916	return;
917	}
918	#endif
919
920	m_pcBinIf->encodeBin( uiCurrSplitFlag, m_cCUSplitFlagSCModel.get( 0, 0, uiCtx ) );
921	DTRACE_CABAC_VL( g_nSymbolCounter++ )
922	DTRACE_CABAC_T( "\tSplitFlag\n" )
923	return;
924	}
925
926	Void TEncSbac::codeTransformSubdivFlag( UInt uiSymbol, UInt uiCtx )
927	{
928	m_pcBinIf->encodeBin( uiSymbol, m_cCUTransSubdivFlagSCModel.get( 0, 0, uiCtx ) );
929	DTRACE_CABAC_VL( g_nSymbolCounter++ )
930	DTRACE_CABAC_T( "\tparseTransformSubdivFlag()" )
931	DTRACE_CABAC_T( "\tsymbol=" )
932	DTRACE_CABAC_V( uiSymbol )
933	DTRACE_CABAC_T( "\tctx=" )
934	DTRACE_CABAC_V( uiCtx )
935	DTRACE_CABAC_T( "\n" )
936	}
937
938	#if LGE_EDGE_INTRA_A0070
939	Void TEncSbac::xCodeEdgeIntraInfo( TComDataCU* pcCU, UInt uiPartIdx )
940	{
941	UInt uiDepth = pcCU->getDepth( uiPartIdx ) + (pcCU->getPartitionSize( uiPartIdx ) == SIZE_NxN ? 1 : 0);
942	UInt uiCtxEdgeIntra = pcCU->getCtxEdgeIntra( uiPartIdx );
943	UChar* pucSymbolList = pcCU->getEdgeCode( uiPartIdx );
944	UChar ucEdgeNumber = pcCU->getEdgeNumber( uiPartIdx );
945	Bool bLeft = pcCU->getEdgeLeftFirst( uiPartIdx );
946	UChar ucStart = pcCU->getEdgeStartPos( uiPartIdx );
947	UInt uiSymbol;
948
949	// 1. Top(0) or Left(1)
950	uiSymbol = (bLeft == false) ? 0 : 1;
951	m_pcBinIf->encodeBinEP( uiSymbol );
952
953	// 2. Start position (lowest bit first)
954	uiSymbol = ucStart;
955	for( UInt ui = 6; ui > uiDepth; ui-- ) // 64(0)->6, 32(1)->5, 16(2)->4, 8(3)->3, 4(4)->2
956	{
957	m_pcBinIf->encodeBinEP( uiSymbol & 0x1 );
958	uiSymbol >>= 1;
959	}
960
961	// 3. Number of edges
962	uiSymbol = ucEdgeNumber > 0 ? ucEdgeNumber - 1 : 0;
963	for( UInt ui = 7; ui > uiDepth; ui-- ) // 64(0)->7, 32(1)->6, 16(2)->5, 8(3)->4, 4(4)->3
964	{
965	m_pcBinIf->encodeBinEP( uiSymbol & 0x1 );
966	uiSymbol >>= 1;
967	}
968
969	if(uiSymbol != 0)
970	{
971	printf(" ucEdgeNumber %d at depth %d\n",ucEdgeNumber, uiDepth);
972	assert(false);
973	}
974
975	// 4. Edges
976	for( Int iPtr2 = 0; iPtr2 < ucEdgeNumber; iPtr2++ )
977	{
978	UInt uiReorderSymbol = pucSymbolList[iPtr2];
979
980	//printf ("Ptr = %d, Symbol = %d\n", iPtr2, uiSymbol);
981
982	// Left-friendly direction (Top start)
983	// 0 ( 0deg) => 0
984	// 1 ( 45deg) => 10
985	// 2 ( -45deg) => 110
986	// 3 ( 90deg) => 1110
987	// 4 ( -90deg) => 11110
988	// 5 ( 135deg) => 111110
989	// 6 (-135deg) => 111111
990	// Right-friendly direction (Left start)
991	// 0 ( 0deg) => 0
992	// 2 ( -45deg) => 10
993	// 1 ( 45deg) => 110
994	// 4 ( -90deg) => 1110
995	// 3 ( 90deg) => 11110
996	// 6 (-135deg) => 111110
997	// 5 ( 135deg) => 111111
998
999	// refer to a paper "An efficient chain code with Huffman coding"
1000
1001	for( UInt ui = 0; ui < uiReorderSymbol; ui++ )
1002	{
1003	m_pcBinIf->encodeBin( 1, m_cEdgeIntraSCModel.get( 0, 0, uiCtxEdgeIntra ) );
1004	}
1005
1006	if( uiReorderSymbol != 6 )
1007	m_pcBinIf->encodeBin( 0, m_cEdgeIntraSCModel.get( 0, 0, uiCtxEdgeIntra ) );
1008	}
1009	}
1010	#endif
1011	#if PKU_QC_DEPTH_INTRA_UNI_D0195
1012	Void TEncSbac::codeDepthIntraMode( TComDataCU* pcCU, UInt uiAbsPartIdx )
1013	{
1014	UInt uiCodeWordTable[3][9] = {{0, 0, 0, 2, 0,6, 0, 0, 7},{0, 2, 3, 4, 5, 6, 14, 31, 30},{0, 2, 0, 0, 0, 0, 3, 0, 0}};
1015	UInt uiCodeWordLenTable[3][9] = {{0, 1, 0, 2, 0,3, 0, 0, 3},{2, 3, 3, 3, 3, 3, 4, 5, 5},{1, 2, 0, 0, 0, 0, 2, 0, 0}};
1016	UInt uiDir = pcCU->getLumaIntraDir(uiAbsPartIdx);
1017	Bool bSdcFlag = pcCU->getSDCFlag(uiAbsPartIdx);
1018	UInt uiPuIdx = ( pcCU->getWidth(uiAbsPartIdx) == 64 )? 2 : ( ( pcCU->getPartitionSize(uiAbsPartIdx) == SIZE_NxN && pcCU->getWidth(uiAbsPartIdx) == 8 ) ? 0 : 1 );
1019	UInt uiCodeIdx = 0;
1020	if ( bSdcFlag )
1021	{
1022	switch(uiDir)
1023	{
1024	case PLANAR_IDX: uiCodeIdx = 0; break;
1025	case DC_IDX: uiCodeIdx = 6; break;
1026	default: uiCodeIdx = 2;
1027	}
1028	}
1029	else if ( uiDir>=EDGE_INTRA_IDX )
1030	{
1031	uiCodeIdx = 8;
1032	}
1033	else if ( uiDir<NUM_INTRA_MODE )
1034	{
1035	uiCodeIdx = 1;
1036	}
1037	else
1038	{
1039	if (uiDir== DMM_WEDGE_FULL_IDX \|\| uiDir==DMM_WEDGE_FULL_D_IDX ) {uiCodeIdx = 3;}
1040	if (uiDir== DMM_CONTOUR_PREDTEX_IDX\|\| uiDir==DMM_CONTOUR_PREDTEX_D_IDX) {uiCodeIdx = 4;}
1041	if (uiDir== DMM_WEDGE_PREDTEX_IDX \|\| uiDir==DMM_WEDGE_PREDTEX_D_IDX ) {uiCodeIdx = 5;}
1042	if (uiDir== DMM_WEDGE_PREDDIR_IDX \|\| uiDir==DMM_WEDGE_PREDDIR_D_IDX ) {uiCodeIdx = 7;}
1043	}
1044	//mode coding
1045	for (UInt i=0; i<uiCodeWordLenTable[uiPuIdx][uiCodeIdx]; i++)
1046	{
1047	UInt uiBit = uiCodeWordTable[uiPuIdx][uiCodeIdx] & ( 1<<(uiCodeWordLenTable[uiPuIdx][uiCodeIdx]-i-1) );
1048	UInt uiCtxDepthMode = uiPuIdx*3 + ( i >= 2? 2 : i );
1049	m_pcBinIf->encodeBin( uiBit!=0 , m_cDepthModeModel.get(0, 0, uiCtxDepthMode) );
1050	}
1051	}
1052	Void TEncSbac::codeDepthModelingTable( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bSdcRD)
1053	{
1054	UInt uiDir = pcCU->getLumaIntraDir( uiAbsPartIdx );
1055	Bool bSdcFlag = pcCU->getSDCFlag(uiAbsPartIdx);
1056	Bool bDmmFlag = (uiDir >= NUM_INTRA_MODE && uiDir < EDGE_INTRA_IDX &&(!bSdcFlag))? 1:0;
1057
1058	codeDepthIntraMode(pcCU,uiAbsPartIdx);
1059
1060	if (uiDir >= NUM_INTRA_MODE && uiDir < EDGE_INTRA_IDX )//DMM modes or SDC DMM1
1061	{
1062	assert(pcCU->getWidth(uiAbsPartIdx)<64);
1063	assert(pcCU->getWidth(uiAbsPartIdx)<64);
1064	if( uiDir == DMM_WEDGE_FULL_IDX \|\| uiDir == DMM_WEDGE_FULL_D_IDX) { xCodeWedgeFullInfo ( pcCU, uiAbsPartIdx ); }
1065	else if( uiDir == DMM_WEDGE_PREDTEX_IDX \|\| uiDir == DMM_WEDGE_PREDTEX_D_IDX ) { xCodeWedgePredTexInfo ( pcCU, uiAbsPartIdx ); }
1066	else if( uiDir == DMM_WEDGE_PREDDIR_IDX \|\| uiDir == DMM_WEDGE_PREDDIR_D_IDX) { xCodeWedgePredDirInfo ( pcCU, uiAbsPartIdx ); }
1067	}
1068	else if(uiDir >= EDGE_INTRA_IDX)//CCM mode
1069	{
1070	assert(pcCU->getWidth(uiAbsPartIdx)<64);
1071	xCodeEdgeIntraInfo( pcCU, uiAbsPartIdx );
1072	}
1073
1074	if (bDmmFlag)
1075	{
1076	m_pcBinIf->encodeBin( (uiDir&1) , m_cDmmDeltaFlagModel.get(0, 0, 0) );
1077	if (uiDir&1)
1078	{
1079	Int iDeltaDC1 = 0,iDeltaDC2 = 0;
1080	if ( uiDir == DMM_WEDGE_FULL_D_IDX )
1081	{
1082	iDeltaDC1 = pcCU->getWedgeFullDeltaDC1( uiAbsPartIdx );
1083	iDeltaDC2 = pcCU->getWedgeFullDeltaDC2( uiAbsPartIdx );
1084	}
1085	else if ( uiDir == DMM_WEDGE_PREDTEX_D_IDX )
1086	{
1087	iDeltaDC1 = pcCU->getWedgePredTexDeltaDC1( uiAbsPartIdx );
1088	iDeltaDC2 = pcCU->getWedgePredTexDeltaDC2( uiAbsPartIdx );
1089	}
1090	else if ( uiDir == DMM_WEDGE_PREDDIR_D_IDX )
1091	{
1092	iDeltaDC1 = pcCU->getWedgePredDirDeltaDC1( uiAbsPartIdx );
1093	iDeltaDC2 = pcCU->getWedgePredDirDeltaDC2( uiAbsPartIdx );
1094	}
1095	else if ( uiDir == DMM_CONTOUR_PREDTEX_D_IDX )
1096	{
1097	iDeltaDC1 = pcCU->getContourPredTexDeltaDC1( uiAbsPartIdx );
1098	iDeltaDC2 = pcCU->getContourPredTexDeltaDC2( uiAbsPartIdx );
1099
1100	}
1101
1102	for ( Int i = 0; i < 2; i++ )
1103	{
1104	Int iDeltaDC = (i==0)? iDeltaDC1 : iDeltaDC2;
1105	xWriteExGolombLevel( UInt( abs( iDeltaDC ) ), m_cDmmDataSCModel.get(0, 0, 1) );
1106	if ( iDeltaDC != 0 )
1107	{
1108	UInt uiSign = iDeltaDC > 0 ? 0 : 1;
1109	m_pcBinIf->encodeBinEP( uiSign );
1110	}
1111	}
1112	}
1113	}
1114	else if (uiDir>=EDGE_INTRA_IDX)
1115	{
1116	m_pcBinIf->encodeBin( (uiDir == EDGE_INTRA_DELTA_IDX), m_cEdgeIntraDeltaDCSCModel.get(0, 0, 0) );
1117	if( uiDir == EDGE_INTRA_DELTA_IDX )
1118	{
1119	Int iDeltaDC0 = pcCU->getEdgeDeltaDC0( uiAbsPartIdx );
1120	Int iDeltaDC1 = pcCU->getEdgeDeltaDC1( uiAbsPartIdx );
1121
1122	for ( Int i = 0; i < 2; i++ )
1123	{
1124	Int iDeltaDC = (i==0)? iDeltaDC0 : iDeltaDC1;
1125	xWriteExGolombLevel( UInt( abs( iDeltaDC ) ), m_cEdgeIntraDeltaDCSCModel.get(0, 0, 1) );
1126	if ( iDeltaDC != 0 )
1127	{
1128	UInt uiSign = iDeltaDC > 0 ? 0 : 1;
1129	m_pcBinIf->encodeBinEP( uiSign );
1130	}
1131	}
1132	}
1133	}
1134	if (pcCU->getSDCFlag(uiAbsPartIdx))//SDC mode
1135	{
1136	assert(pcCU->getPartitionSize(uiAbsPartIdx)==SIZE_2Nx2N);
1137	UInt uiNumSegments = ( uiDir == DC_IDX \|\| uiDir == PLANAR_IDX )? 1 : 2;
1138	if(!bSdcRD)
1139	{
1140	for (int uiSeg=0; uiSeg<uiNumSegments; uiSeg++)
1141	{
1142	codeSDCResidualData(pcCU, uiAbsPartIdx, uiSeg);
1143	}
1144	}
1145	}
1146	}
1147	#endif
1148	Void TEncSbac::codeIntraDirLumaAng( TComDataCU* pcCU, UInt uiAbsPartIdx
1149	#if PKU_QC_DEPTH_INTRA_UNI_D0195
1150	, Bool bSdcRD
1151	#endif
1152	)
1153	{
1154	UInt uiDir = pcCU->getLumaIntraDir( uiAbsPartIdx );
1155
1156	#if !PKU_QC_DEPTH_INTRA_UNI_D0195
1157	#if HHI_DMM_WEDGE_INTRA \|\| HHI_DMM_PRED_TEX
1158	if( pcCU->getSlice()->getSPS()->getUseDMM() && pcCU->getWidth( uiAbsPartIdx ) <= DMM_WEDGEMODEL_MAX_SIZE )
1159	{
1160	#if LGE_EDGE_INTRA_A0070
1161	m_pcBinIf->encodeBin( uiDir >= NUM_INTRA_MODE && uiDir < EDGE_INTRA_IDX, m_cDmmFlagSCModel.get(0, 0, 0) );
1162	#else
1163	m_pcBinIf->encodeBin( uiDir >= NUM_INTRA_MODE, m_cDmmFlagSCModel.get(0, 0, 0) );
1164	#endif
1165	}
1166	#if LGE_EDGE_INTRA_A0070
1167	if( uiDir >= NUM_INTRA_MODE && uiDir < EDGE_INTRA_IDX )
1168	#else
1169	if( uiDir >= NUM_INTRA_MODE )
1170	#endif
1171	{
1172	assert( pcCU->getWidth( uiAbsPartIdx ) <= DMM_WEDGEMODEL_MAX_SIZE );
1173	UInt uiDMMode = uiDir - NUM_INTRA_MODE;
1174
1175	#if HHI_DMM_WEDGE_INTRA && HHI_DMM_PRED_TEX
1176	m_pcBinIf->encodeBin( (uiDMMode & 0x01), m_cDmmModeSCModel.get(0, 0, 0) );
1177	m_pcBinIf->encodeBin( (uiDMMode & 0x02) >> 1, m_cDmmModeSCModel.get(0, 0, 0) );
1178
1179	if( pcCU->getPartitionSize( uiAbsPartIdx ) != SIZE_NxN && pcCU->getWidth( uiAbsPartIdx ) > 4 )
1180	{
1181	m_pcBinIf->encodeBin( (uiDMMode & 0x04) >> 2, m_cDmmModeSCModel.get(0, 0, 0) );
1182	}
1183	#else
1184	m_pcBinIf->encodeBin( (uiDMMode & 0x01), m_cDmmModeSCModel.get(0, 0, 0) );
1185
1186	if( pcCU->getPartitionSize( uiAbsPartIdx ) != SIZE_NxN && pcCU->getWidth( uiAbsPartIdx ) > 4 )
1187	{
1188	m_pcBinIf->encodeBin( (uiDMMode & 0x02) >> 1, m_cDmmModeSCModel.get(0, 0, 0) );
1189	}
1190	#endif
1191	#if HHI_DMM_WEDGE_INTRA
1192	if( uiDir == DMM_WEDGE_FULL_IDX ) { xCodeWedgeFullInfo ( pcCU, uiAbsPartIdx ); }
1193	if( uiDir == DMM_WEDGE_FULL_D_IDX ) { xCodeWedgeFullDeltaInfo ( pcCU, uiAbsPartIdx ); }
1194	if( uiDir == DMM_WEDGE_PREDDIR_IDX ) { xCodeWedgePredDirInfo ( pcCU, uiAbsPartIdx ); }
1195	if( uiDir == DMM_WEDGE_PREDDIR_D_IDX ) { xCodeWedgePredDirDeltaInfo ( pcCU, uiAbsPartIdx ); }
1196	#endif
1197	#if HHI_DMM_PRED_TEX
1198
1199	#if FLEX_CODING_ORDER_M23723
1200	if ( !pcCU->getSlice()->getSPS()->getUseDMM34() )
1201	{
1202	assert( uiDir != DMM_WEDGE_PREDTEX_D_IDX );
1203	assert( uiDir != DMM_CONTOUR_PREDTEX_D_IDX );
1204	}
1205	#endif
1206
1207	if( uiDir == DMM_WEDGE_PREDTEX_D_IDX ) { xCodeWedgePredTexDeltaInfo ( pcCU, uiAbsPartIdx ); }
1208	#if LGE_DMM3_SIMP_C0044
1209	if( uiDir == DMM_WEDGE_PREDTEX_IDX ) { xCodeWedgePredTexInfo ( pcCU, uiAbsPartIdx ); }
1210	#endif
1211	if( uiDir == DMM_CONTOUR_PREDTEX_D_IDX ) { xCodeContourPredTexDeltaInfo( pcCU, uiAbsPartIdx ); }
1212	#endif
1213	}
1214	else
1215	#if LGE_EDGE_INTRA_A0070
1216	if ( uiDir >= EDGE_INTRA_IDX)
1217	{
1218	m_pcBinIf->encodeBin( 0, m_cCUIntraPredSCModel.get( 0, 0, 0 ) );
1219	m_pcBinIf->encodeBinsEP( 63, 6 );
1220	xCodeEdgeIntraInfo( pcCU, uiAbsPartIdx );
1221	#if LGE_EDGE_INTRA_DELTA_DC
1222	m_pcBinIf->encodeBin( (uiDir == EDGE_INTRA_DELTA_IDX), m_cEdgeIntraDeltaDCSCModel.get(0, 0, 0) );
1223	if( uiDir == EDGE_INTRA_DELTA_IDX )
1224	{
1225	Int iDeltaDC0 = pcCU->getEdgeDeltaDC0( uiAbsPartIdx );
1226	Int iDeltaDC1 = pcCU->getEdgeDeltaDC1( uiAbsPartIdx );
1227
1228	xWriteExGolombLevel( UInt( abs( iDeltaDC0 ) ), m_cEdgeIntraDeltaDCSCModel.get(0, 0, 1) );
1229	if ( iDeltaDC0 != 0 )
1230	{
1231	UInt uiSign = iDeltaDC0 > 0 ? 0 : 1;
1232	m_pcBinIf->encodeBinEP( uiSign );
1233	}
1234	xWriteExGolombLevel( UInt( abs( iDeltaDC1 ) ), m_cEdgeIntraDeltaDCSCModel.get(0, 0, 1) );
1235	if ( iDeltaDC1 != 0 )
1236	{
1237	UInt uiSign = iDeltaDC1 > 0 ? 0 : 1;
1238	m_pcBinIf->encodeBinEP( uiSign );
1239	}
1240	}
1241	#endif
1242	}
1243	else
1244	#endif // LGE_EDGE_INTRA
1245	{
1246	#endif
1247	#if LGE_EDGE_INTRA_A0070
1248	Bool bCodeEdgeIntra = false;
1249	if( pcCU->getSlice()->getSPS()->isDepth() )
1250	{
1251	UInt uiPUWidth = pcCU->getWidth( uiAbsPartIdx ) >> (pcCU->getPartitionSize( uiAbsPartIdx ) == SIZE_NxN ? 1 : 0);
1252	if( uiPUWidth <= LGE_EDGE_INTRA_MAX_SIZE && uiPUWidth >= LGE_EDGE_INTRA_MIN_SIZE )
1253	bCodeEdgeIntra = true;
1254	}
1255	#endif
1256	#else
1257	if (pcCU->getSlice()->getSPS()->isDepth())
1258	{
1259	codeDepthModelingTable(pcCU, uiAbsPartIdx, bSdcRD);
1260	}
1261	if (pcCU->getLumaIntraDir(uiAbsPartIdx)<NUM_INTRA_MODE && !pcCU->getSDCFlag(uiAbsPartIdx))
1262	{
1263	#endif
1264	Int uiPreds[3] = {-1, -1, -1};
1265	Int uiPredNum = pcCU->getIntraDirLumaPredictor(uiAbsPartIdx, uiPreds);
1266
1267	Int uiPredIdx = -1;
1268
1269	for(UInt i = 0; i < uiPredNum; i++)
1270	{
1271	if(uiDir == uiPreds[i])
1272	{
1273	uiPredIdx = i;
1274	}
1275	}
1276
1277	if(uiPredIdx != -1)
1278	{
1279	m_pcBinIf->encodeBin( 1, m_cCUIntraPredSCModel.get( 0, 0, 0 ) );
1280	m_pcBinIf->encodeBinEP( uiPredIdx ? 1 : 0 );
1281	if (uiPredIdx)
1282	{
1283	m_pcBinIf->encodeBinEP( uiPredIdx-1 );
1284	}
1285	}
1286	else
1287	{
1288	m_pcBinIf->encodeBin( 0, m_cCUIntraPredSCModel.get( 0, 0, 0 ) );
1289
1290	if (uiPreds[0] > uiPreds[1])
1291	{
1292	std::swap(uiPreds[0], uiPreds[1]);
1293	}
1294	if (uiPreds[0] > uiPreds[2])
1295	{
1296	std::swap(uiPreds[0], uiPreds[2]);
1297	}
1298	if (uiPreds[1] > uiPreds[2])
1299	{
1300	std::swap(uiPreds[1], uiPreds[2]);
1301	}
1302
1303	for(Int i = (uiPredNum - 1); i >= 0; i--)
1304	{
1305	uiDir = uiDir > uiPreds[i] ? uiDir - 1 : uiDir;
1306	}
1307
1308	m_pcBinIf->encodeBinsEP( uiDir, 5 );
1309	#if !PKU_QC_DEPTH_INTRA_UNI_D0195
1310	#if LGE_EDGE_INTRA_A0070
1311	if (bCodeEdgeIntra)
1312	if (uiDir == 31) m_pcBinIf->encodeBinsEP(0,1);
1313	#endif
1314	#endif
1315	}
1316	#if PKU_QC_DEPTH_INTRA_UNI_D0195
1317	}
1318	#else
1319	#if HHI_DMM_WEDGE_INTRA \|\| HHI_DMM_PRED_TEX
1320	}
1321	#endif
1322	#endif
1323
1324	return;
1325	}
1326
1327	Void TEncSbac::codeIntraDirChroma( TComDataCU* pcCU, UInt uiAbsPartIdx )
1328	{
1329	UInt uiIntraDirChroma = pcCU->getChromaIntraDir( uiAbsPartIdx );
1330
1331	if( uiIntraDirChroma == DM_CHROMA_IDX )
1332	{
1333	m_pcBinIf->encodeBin( 0, m_cCUChromaPredSCModel.get( 0, 0, 0 ) );
1334	}
1335	else if( uiIntraDirChroma == LM_CHROMA_IDX )
1336	{
1337	m_pcBinIf->encodeBin( 1, m_cCUChromaPredSCModel.get( 0, 0, 0 ) );
1338	m_pcBinIf->encodeBin( 0, m_cCUChromaPredSCModel.get( 0, 0, 1 ) );
1339	}
1340	else
1341	{
1342	UInt uiAllowedChromaDir[ NUM_CHROMA_MODE ];
1343	pcCU->getAllowedChromaDir( uiAbsPartIdx, uiAllowedChromaDir );
1344
1345	for( Int i = 0; i < NUM_CHROMA_MODE - 2; i++ )
1346	{
1347	if( uiIntraDirChroma == uiAllowedChromaDir[i] )
1348	{
1349	uiIntraDirChroma = i;
1350	break;
1351	}
1352	}
1353	m_pcBinIf->encodeBin( 1, m_cCUChromaPredSCModel.get( 0, 0, 0 ) );
1354
1355	if (pcCU->getSlice()->getSPS()->getUseLMChroma())
1356	{
1357	m_pcBinIf->encodeBin( 1, m_cCUChromaPredSCModel.get( 0, 0, 1 ));
1358	}
1359	m_pcBinIf->encodeBinsEP( uiIntraDirChroma, 2 );
1360	}
1361	return;
1362	}
1363
1364	Void TEncSbac::codeInterDir( TComDataCU* pcCU, UInt uiAbsPartIdx )
1365	{
1366	const UInt uiInterDir = pcCU->getInterDir( uiAbsPartIdx ) - 1;
1367	const UInt uiCtx = pcCU->getCtxInterDir( uiAbsPartIdx );
1368	ContextModel *pCtx = m_cCUInterDirSCModel.get( 0 );
1369	m_pcBinIf->encodeBin( uiInterDir == 2 ? 1 : 0, *( pCtx + uiCtx ) );
1370
1371	return;
1372	}
1373
1374	Void TEncSbac::codeRefFrmIdx( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList )
1375	{
1376	if ( pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_C) > 0 && pcCU->getInterDir( uiAbsPartIdx ) != 3)
1377	{
1378	Int iRefFrame = pcCU->getSlice()->getRefIdxOfLC(eRefList, pcCU->getCUMvField( eRefList )->getRefIdx( uiAbsPartIdx ));
1379
1380	ContextModel *pCtx = m_cCURefPicSCModel.get( 0 );
1381	m_pcBinIf->encodeBin( ( iRefFrame == 0 ? 0 : 1 ), *pCtx );
1382
1383	if( iRefFrame > 0 )
1384	{
1385	xWriteUnaryMaxSymbol( iRefFrame - 1, pCtx + 1, 1, pcCU->getSlice()->getNumRefIdx( REF_PIC_LIST_C )-2 );
1386	}
1387	#if MERL_VSP_C0152
1388	else if (iRefFrame < 0) // NOT_VALID
1389	{
1390	assert(0);
1391	}
1392	#endif
1393	}
1394	else
1395	{
1396	Int iRefFrame = pcCU->getCUMvField( eRefList )->getRefIdx( uiAbsPartIdx );
1397	ContextModel *pCtx = m_cCURefPicSCModel.get( 0 );
1398	m_pcBinIf->encodeBin( ( iRefFrame == 0 ? 0 : 1 ), *pCtx );
1399
1400	if( iRefFrame > 0 )
1401	{
1402	xWriteUnaryMaxSymbol( iRefFrame - 1, pCtx + 1, 1, pcCU->getSlice()->getNumRefIdx( eRefList )-2 );
1403	}
1404	#if MERL_VSP_C0152
1405	else if (iRefFrame < 0) // NOT_VALID
1406	{
1407	assert(0);
1408	}
1409	#endif
1410	}
1411	return;
1412	}
1413
1414	Void TEncSbac::codeMvd( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList )
1415	{
1416	if(pcCU->getSlice()->getMvdL1ZeroFlag() && eRefList == REF_PIC_LIST_1 && pcCU->getInterDir(uiAbsPartIdx)==3)
1417	{
1418	return;
1419	}
1420
1421	const TComCUMvField* pcCUMvField = pcCU->getCUMvField( eRefList );
1422	const Int iHor = pcCUMvField->getMvd( uiAbsPartIdx ).getHor();
1423	const Int iVer = pcCUMvField->getMvd( uiAbsPartIdx ).getVer();
1424	ContextModel* pCtx = m_cCUMvdSCModel.get( 0 );
1425
1426	m_pcBinIf->encodeBin( iHor != 0 ? 1 : 0, *pCtx );
1427	m_pcBinIf->encodeBin( iVer != 0 ? 1 : 0, *pCtx );
1428
1429	const Bool bHorAbsGr0 = iHor != 0;
1430	const Bool bVerAbsGr0 = iVer != 0;
1431	const UInt uiHorAbs = 0 > iHor ? -iHor : iHor;
1432	const UInt uiVerAbs = 0 > iVer ? -iVer : iVer;
1433	pCtx++;
1434
1435	if( bHorAbsGr0 )
1436	{
1437	m_pcBinIf->encodeBin( uiHorAbs > 1 ? 1 : 0, *pCtx );
1438	}
1439
1440	if( bVerAbsGr0 )
1441	{
1442	m_pcBinIf->encodeBin( uiVerAbs > 1 ? 1 : 0, *pCtx );
1443	}
1444
1445	if( bHorAbsGr0 )
1446	{
1447	if( uiHorAbs > 1 )
1448	{
1449	xWriteEpExGolomb( uiHorAbs-2, 1 );
1450	}
1451
1452	m_pcBinIf->encodeBinEP( 0 > iHor ? 1 : 0 );
1453	}
1454
1455	if( bVerAbsGr0 )
1456	{
1457	if( uiVerAbs > 1 )
1458	{
1459	xWriteEpExGolomb( uiVerAbs-2, 1 );
1460	}
1461
1462	m_pcBinIf->encodeBinEP( 0 > iVer ? 1 : 0 );
1463	}
1464
1465	return;
1466	}
1467
1468	Void TEncSbac::codeDeltaQP( TComDataCU* pcCU, UInt uiAbsPartIdx )
1469	{
1470	Int iDQp = pcCU->getQP( uiAbsPartIdx ) - pcCU->getRefQP( uiAbsPartIdx );
1471
1472	Int qpBdOffsetY = pcCU->getSlice()->getSPS()->getQpBDOffsetY();
1473	iDQp = (iDQp + 78 + qpBdOffsetY + (qpBdOffsetY/2)) % (52 + qpBdOffsetY) - 26 - (qpBdOffsetY/2);
1474
1475	if ( iDQp == 0 )
1476	{
1477	m_pcBinIf->encodeBin( 0, m_cCUDeltaQpSCModel.get( 0, 0, 0 ) );
1478	}
1479	else
1480	{
1481	m_pcBinIf->encodeBin( 1, m_cCUDeltaQpSCModel.get( 0, 0, 0 ) );
1482
1483	UInt uiSign = (iDQp > 0 ? 0 : 1);
1484
1485	m_pcBinIf->encodeBinEP(uiSign);
1486
1487	assert(iDQp >= -(26+(qpBdOffsetY/2)));
1488	assert(iDQp <= (25+(qpBdOffsetY/2)));
1489
1490	UInt uiMaxAbsDQpMinus1 = 24 + (qpBdOffsetY/2) + (uiSign);
1491	UInt uiAbsDQpMinus1 = (UInt)((iDQp > 0)? iDQp : (-iDQp)) - 1;
1492	xWriteUnaryMaxSymbol( uiAbsDQpMinus1, &m_cCUDeltaQpSCModel.get( 0, 0, 1 ), 1, uiMaxAbsDQpMinus1);
1493	}
1494
1495	return;
1496	}
1497
1498	Void TEncSbac::codeQtCbf( TComDataCU* pcCU, UInt uiAbsPartIdx, TextType eType, UInt uiTrDepth )
1499	{
1500	UInt uiCbf = pcCU->getCbf ( uiAbsPartIdx, eType, uiTrDepth );
1501	UInt uiCtx = pcCU->getCtxQtCbf( uiAbsPartIdx, eType, uiTrDepth );
1502	m_pcBinIf->encodeBin( uiCbf , m_cCUQtCbfSCModel.get( 0, eType ? TEXT_CHROMA : eType, uiCtx ) );
1503	DTRACE_CABAC_VL( g_nSymbolCounter++ )
1504	DTRACE_CABAC_T( "\tparseQtCbf()" )
1505	DTRACE_CABAC_T( "\tsymbol=" )
1506	DTRACE_CABAC_V( uiCbf )
1507	DTRACE_CABAC_T( "\tctx=" )
1508	DTRACE_CABAC_V( uiCtx )
1509	DTRACE_CABAC_T( "\tetype=" )
1510	DTRACE_CABAC_V( eType )
1511	DTRACE_CABAC_T( "\tuiAbsPartIdx=" )
1512	DTRACE_CABAC_V( uiAbsPartIdx )
1513	DTRACE_CABAC_T( "\n" )
1514	}
1515
1516	/** Code I_PCM information.
1517	* \param pcCU pointer to CU
1518	* \param uiAbsPartIdx CU index
1519	* \param numIPCM the number of succesive IPCM blocks with the same size
1520	* \param firstIPCMFlag
1521	* \returns Void
1522	*/
1523	Void TEncSbac::codeIPCMInfo( TComDataCU* pcCU, UInt uiAbsPartIdx, Int numIPCM, Bool firstIPCMFlag)
1524	{
1525	UInt uiIPCM = (pcCU->getIPCMFlag(uiAbsPartIdx) == true)? 1 : 0;
1526
1527	Bool writePCMSampleFlag = pcCU->getIPCMFlag(uiAbsPartIdx);
1528
1529	if( uiIPCM == 0 \|\| firstIPCMFlag)
1530	{
1531	m_pcBinIf->encodeBinTrm (uiIPCM);
1532
1533	if ( firstIPCMFlag )
1534	{
1535	m_pcBinIf->encodeNumSubseqIPCM( numIPCM - 1 );
1536	m_pcBinIf->encodePCMAlignBits();
1537	}
1538	}
1539
1540	if (writePCMSampleFlag)
1541	{
1542	UInt uiMinCoeffSize = pcCU->getPic()->getMinCUWidth()*pcCU->getPic()->getMinCUHeight();
1543	UInt uiLumaOffset = uiMinCoeffSize*uiAbsPartIdx;
1544	UInt uiChromaOffset = uiLumaOffset>>2;
1545	Pel* piPCMSample;
1546	UInt uiWidth;
1547	UInt uiHeight;
1548	UInt uiSampleBits;
1549	UInt uiX, uiY;
1550
1551	piPCMSample = pcCU->getPCMSampleY() + uiLumaOffset;
1552	uiWidth = pcCU->getWidth(uiAbsPartIdx);
1553	uiHeight = pcCU->getHeight(uiAbsPartIdx);
1554	uiSampleBits = pcCU->getSlice()->getSPS()->getPCMBitDepthLuma();
1555
1556	for(uiY = 0; uiY < uiHeight; uiY++)
1557	{
1558	for(uiX = 0; uiX < uiWidth; uiX++)
1559	{
1560	UInt uiSample = piPCMSample[uiX];
1561
1562	m_pcBinIf->xWritePCMCode(uiSample, uiSampleBits);
1563	}
1564	piPCMSample += uiWidth;
1565	}
1566
1567	piPCMSample = pcCU->getPCMSampleCb() + uiChromaOffset;
1568	uiWidth = pcCU->getWidth(uiAbsPartIdx)/2;
1569	uiHeight = pcCU->getHeight(uiAbsPartIdx)/2;
1570	uiSampleBits = pcCU->getSlice()->getSPS()->getPCMBitDepthChroma();
1571
1572	for(uiY = 0; uiY < uiHeight; uiY++)
1573	{
1574	for(uiX = 0; uiX < uiWidth; uiX++)
1575	{
1576	UInt uiSample = piPCMSample[uiX];
1577
1578	m_pcBinIf->xWritePCMCode(uiSample, uiSampleBits);
1579	}
1580	piPCMSample += uiWidth;
1581	}
1582
1583	piPCMSample = pcCU->getPCMSampleCr() + uiChromaOffset;
1584	uiWidth = pcCU->getWidth(uiAbsPartIdx)/2;
1585	uiHeight = pcCU->getHeight(uiAbsPartIdx)/2;
1586	uiSampleBits = pcCU->getSlice()->getSPS()->getPCMBitDepthChroma();
1587
1588	for(uiY = 0; uiY < uiHeight; uiY++)
1589	{
1590	for(uiX = 0; uiX < uiWidth; uiX++)
1591	{
1592	UInt uiSample = piPCMSample[uiX];
1593
1594	m_pcBinIf->xWritePCMCode(uiSample, uiSampleBits);
1595	}
1596	piPCMSample += uiWidth;
1597	}
1598	numIPCM--;
1599	if(numIPCM == 0)
1600	{
1601	m_pcBinIf->resetBac();
1602	}
1603	}
1604	}
1605
1606	Void TEncSbac::codeQtRootCbf( TComDataCU* pcCU, UInt uiAbsPartIdx )
1607	{
1608	UInt uiCbf = pcCU->getQtRootCbf( uiAbsPartIdx );
1609	UInt uiCtx = 0;
1610	m_pcBinIf->encodeBin( uiCbf , m_cCUQtRootCbfSCModel.get( 0, 0, uiCtx ) );
1611	DTRACE_CABAC_VL( g_nSymbolCounter++ )
1612	DTRACE_CABAC_T( "\tparseQtRootCbf()" )
1613	DTRACE_CABAC_T( "\tsymbol=" )
1614	DTRACE_CABAC_V( uiCbf )
1615	DTRACE_CABAC_T( "\tctx=" )
1616	DTRACE_CABAC_V( uiCtx )
1617	DTRACE_CABAC_T( "\tuiAbsPartIdx=" )
1618	DTRACE_CABAC_V( uiAbsPartIdx )
1619	DTRACE_CABAC_T( "\n" )
1620	}
1621
1622	/** Encode (X,Y) position of the last significant coefficient
1623	* \param uiPosX X component of last coefficient
1624	* \param uiPosY Y component of last coefficient
1625	* \param width Block width
1626	* \param height Block height
1627	* \param eTType plane type / luminance or chrominance
1628	* \param uiScanIdx scan type (zig-zag, hor, ver)
1629	* This method encodes the X and Y component within a block of the last significant coefficient.
1630	*/
1631	Void TEncSbac::codeLastSignificantXY( UInt uiPosX, UInt uiPosY, Int width, Int height, TextType eTType, UInt uiScanIdx )
1632	{
1633	// swap
1634	if( uiScanIdx == SCAN_VER )
1635	{
1636	swap( uiPosX, uiPosY );
1637	}
1638
1639	UInt uiCtxLast;
1640	ContextModel *pCtxX = m_cCuCtxLastX.get( 0, eTType );
1641	ContextModel *pCtxY = m_cCuCtxLastY.get( 0, eTType );
1642	UInt uiGroupIdxX = g_uiGroupIdx[ uiPosX ];
1643	UInt uiGroupIdxY = g_uiGroupIdx[ uiPosY ];
1644
1645	// posX
1646	Int widthCtx = eTType? 4: width;
1647	const UInt puiCtxIdxX = g_uiLastCtx + ( g_aucConvertToBit[ widthCtx ] ( g_aucConvertToBit[ widthCtx ] + 3 ) );
1648	for( uiCtxLast = 0; uiCtxLast < uiGroupIdxX; uiCtxLast++ )
1649	{
1650	if (eTType)
1651	{
1652	m_pcBinIf->encodeBin( 1, *( pCtxX + (uiCtxLast>>g_aucConvertToBit[ width ]) ) );
1653	}
1654	else
1655	{
1656	m_pcBinIf->encodeBin( 1, *( pCtxX + puiCtxIdxX[ uiCtxLast ] ) );
1657	}
1658	}
1659	if( uiGroupIdxX < g_uiGroupIdx[ width - 1 ])
1660	{
1661	if ( eTType )
1662	{
1663	m_pcBinIf->encodeBin( 0, *( pCtxX + (uiCtxLast>>g_aucConvertToBit[ width ]) ) );
1664	}
1665	else
1666	{
1667	m_pcBinIf->encodeBin( 0, *( pCtxX + puiCtxIdxX[ uiCtxLast ] ) );
1668	}
1669	}
1670
1671	// posY
1672	Int heightCtx = eTType? 4: height;
1673	const UInt puiCtxIdxY = g_uiLastCtx + ( g_aucConvertToBit[ heightCtx ] ( g_aucConvertToBit[ heightCtx ] + 3 ) );
1674	for( uiCtxLast = 0; uiCtxLast < uiGroupIdxY; uiCtxLast++ )
1675	{
1676	if (eTType)
1677	{
1678	m_pcBinIf->encodeBin( 1, *( pCtxY + (uiCtxLast>>g_aucConvertToBit[ height ])));
1679	}
1680	else
1681	{
1682	m_pcBinIf->encodeBin( 1, *( pCtxY + puiCtxIdxY[ uiCtxLast ] ) );
1683	}
1684	}
1685	if( uiGroupIdxY < g_uiGroupIdx[ height - 1 ])
1686	{
1687	if (eTType)
1688	{
1689	m_pcBinIf->encodeBin( 0, *( pCtxY + (uiCtxLast>>g_aucConvertToBit[ height ]) ) );
1690	}
1691	else
1692	{
1693	m_pcBinIf->encodeBin( 0, *( pCtxY + puiCtxIdxY[ uiCtxLast ] ) );
1694	}
1695	}
1696	if ( uiGroupIdxX > 3 )
1697	{
1698	UInt uiCount = ( uiGroupIdxX - 2 ) >> 1;
1699	uiPosX = uiPosX - g_uiMinInGroup[ uiGroupIdxX ];
1700	for (Int i = uiCount - 1 ; i >= 0; i-- )
1701	{
1702	m_pcBinIf->encodeBinEP( ( uiPosX >> i ) & 1 );
1703	}
1704	}
1705	if ( uiGroupIdxY > 3 )
1706	{
1707	UInt uiCount = ( uiGroupIdxY - 2 ) >> 1;
1708	uiPosY = uiPosY - g_uiMinInGroup[ uiGroupIdxY ];
1709	for ( Int i = uiCount - 1 ; i >= 0; i-- )
1710	{
1711	m_pcBinIf->encodeBinEP( ( uiPosY >> i ) & 1 );
1712	}
1713	}
1714	}
1715
1716	Void TEncSbac::codeCoeffNxN( TComDataCU* pcCU, TCoeff* pcCoef, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, UInt uiDepth, TextType eTType )
1717	{
1718	DTRACE_CABAC_VL( g_nSymbolCounter++ )
1719	DTRACE_CABAC_T( "\tparseCoeffNxN()\teType=" )
1720	DTRACE_CABAC_V( eTType )
1721	DTRACE_CABAC_T( "\twidth=" )
1722	DTRACE_CABAC_V( uiWidth )
1723	DTRACE_CABAC_T( "\theight=" )
1724	DTRACE_CABAC_V( uiHeight )
1725	DTRACE_CABAC_T( "\tdepth=" )
1726	DTRACE_CABAC_V( uiDepth )
1727	DTRACE_CABAC_T( "\tabspartidx=" )
1728	DTRACE_CABAC_V( uiAbsPartIdx )
1729	DTRACE_CABAC_T( "\ttoCU-X=" )
1730	DTRACE_CABAC_V( pcCU->getCUPelX() )
1731	DTRACE_CABAC_T( "\ttoCU-Y=" )
1732	DTRACE_CABAC_V( pcCU->getCUPelY() )
1733	DTRACE_CABAC_T( "\tCU-addr=" )
1734	DTRACE_CABAC_V( pcCU->getAddr() )
1735	DTRACE_CABAC_T( "\tinCU-X=" )
1736	DTRACE_CABAC_V( g_auiRasterToPelX[ g_auiZscanToRaster[uiAbsPartIdx] ] )
1737	DTRACE_CABAC_T( "\tinCU-Y=" )
1738	DTRACE_CABAC_V( g_auiRasterToPelY[ g_auiZscanToRaster[uiAbsPartIdx] ] )
1739	DTRACE_CABAC_T( "\tpredmode=" )
1740	DTRACE_CABAC_V( pcCU->getPredictionMode( uiAbsPartIdx ) )
1741	DTRACE_CABAC_T( "\n" )
1742
1743	if( uiWidth > m_pcSlice->getSPS()->getMaxTrSize() )
1744	{
1745	uiWidth = m_pcSlice->getSPS()->getMaxTrSize();
1746	uiHeight = m_pcSlice->getSPS()->getMaxTrSize();
1747	}
1748
1749	UInt uiNumSig = 0;
1750
1751	// compute number of significant coefficients
1752	uiNumSig = TEncEntropy::countNonZeroCoeffs(pcCoef, uiWidth * uiHeight);
1753
1754	if ( uiNumSig == 0 )
1755	return;
1756
1757	eTType = eTType == TEXT_LUMA ? TEXT_LUMA : ( eTType == TEXT_NONE ? TEXT_NONE : TEXT_CHROMA );
1758
1759	//----- encode significance map -----
1760	const UInt uiLog2BlockSize = g_aucConvertToBit[ uiWidth ] + 2;
1761	UInt uiScanIdx = pcCU->getCoefScanIdx(uiAbsPartIdx, uiWidth, eTType==TEXT_LUMA, pcCU->isIntra(uiAbsPartIdx));
1762	if (uiScanIdx == SCAN_ZIGZAG)
1763	{
1764	// Map zigzag to diagonal scan
1765	uiScanIdx = SCAN_DIAG;
1766	}
1767	Int blockType = uiLog2BlockSize;
1768	if (uiWidth != uiHeight)
1769	{
1770	uiScanIdx = SCAN_DIAG;
1771	blockType = 4;
1772	}
1773
1774	const UInt * scan;
1775	if (uiWidth == uiHeight)
1776	{
1777	scan = g_auiSigLastScan[ uiScanIdx ][ uiLog2BlockSize - 1 ];
1778	}
1779	else
1780	{
1781	scan = g_sigScanNSQT[ uiLog2BlockSize - 2 ];
1782	}
1783
1784	UInt const tsig = pcCU->getSlice()->getPPS()->getTSIG();
1785	#if LOSSLESS_CODING
1786	Bool beValid;
1787	if (pcCU->isLosslessCoded(uiAbsPartIdx))
1788	{
1789	beValid = false;
1790	}
1791	else
1792	{
1793	beValid = pcCU->getSlice()->getPPS()->getSignHideFlag() > 0;
1794	}
1795	#else
1796	Bool beValid = pcCU->getSlice()->getPPS()->getSignHideFlag() > 0;
1797	#endif
1798
1799	// Find position of last coefficient
1800	Int scanPosLast = -1;
1801	Int posLast;
1802
1803	const UInt * scanCG;
1804	if (uiWidth == uiHeight)
1805	{
1806	scanCG = g_auiSigLastScan[ uiScanIdx ][ uiLog2BlockSize > 3 ? uiLog2BlockSize-2-1 : 0 ];
1807	if( uiLog2BlockSize == 3 )
1808	{
1809	scanCG = g_sigLastScan8x8[ uiScanIdx ];
1810	}
1811	else if( uiLog2BlockSize == 5 )
1812	{
1813	scanCG = g_sigLastScanCG32x32;
1814	}
1815	}
1816	else
1817	{
1818	scanCG = g_sigCGScanNSQT[ uiLog2BlockSize - 2 ];
1819	}
1820	UInt uiSigCoeffGroupFlag[ MLS_GRP_NUM ];
1821	static const UInt uiShift = MLS_CG_SIZE >> 1;
1822	const UInt uiNumBlkSide = uiWidth >> uiShift;
1823
1824	::memset( uiSigCoeffGroupFlag, 0, sizeof(UInt) * MLS_GRP_NUM );
1825
1826	do
1827	{
1828	posLast = scan[ ++scanPosLast ];
1829
1830	// get L1 sig map
1831	UInt uiPosY = posLast >> uiLog2BlockSize;
1832	UInt uiPosX = posLast - ( uiPosY << uiLog2BlockSize );
1833	UInt uiBlkIdx = uiNumBlkSide * (uiPosY >> uiShift) + (uiPosX >> uiShift);
1834	if( uiWidth == 8 && uiHeight == 8 && (uiScanIdx == SCAN_HOR \|\| uiScanIdx == SCAN_VER) )
1835	{
1836	if( uiScanIdx == SCAN_HOR )
1837	{
1838	uiBlkIdx = uiPosY >> 1;
1839	}
1840	else if( uiScanIdx == SCAN_VER )
1841	{
1842	uiBlkIdx = uiPosX >> 1;
1843	}
1844	}
1845	if( pcCoef[ posLast ] )
1846	{
1847	uiSigCoeffGroupFlag[ uiBlkIdx ] = 1;
1848	}
1849
1850	uiNumSig -= ( pcCoef[ posLast ] != 0 );
1851	}
1852	while ( uiNumSig > 0 );
1853
1854	// Code position of last coefficient
1855	Int posLastY = posLast >> uiLog2BlockSize;
1856	Int posLastX = posLast - ( posLastY << uiLog2BlockSize );
1857	codeLastSignificantXY(posLastX, posLastY, uiWidth, uiHeight, eTType, uiScanIdx);
1858
1859	//===== code significance flag =====
1860	ContextModel * const baseCoeffGroupCtx = m_cCUSigCoeffGroupSCModel.get( 0, eTType );
1861	ContextModel * const baseCtx = (eTType==TEXT_LUMA) ? m_cCUSigSCModel.get( 0, 0 ) : m_cCUSigSCModel.get( 0, 0 ) + NUM_SIG_FLAG_CTX_LUMA;
1862
1863
1864	const Int iLastScanSet = scanPosLast >> LOG2_SCAN_SET_SIZE;
1865	UInt uiNumOne = 0;
1866	UInt uiGoRiceParam = 0;
1867	Int iScanPosSig = scanPosLast;
1868
1869	for( Int iSubSet = iLastScanSet; iSubSet >= 0; iSubSet-- )
1870	{
1871	Int numNonZero = 0;
1872	Int iSubPos = iSubSet << LOG2_SCAN_SET_SIZE;
1873	uiGoRiceParam = 0;
1874	Int absCoeff[16];
1875	UInt coeffSigns = 0;
1876
1877	Int lastNZPosInCG = -1, firstNZPosInCG = SCAN_SET_SIZE;
1878
1879	if( iScanPosSig == scanPosLast )
1880	{
1881	absCoeff[ 0 ] = abs( pcCoef[ posLast ] );
1882	coeffSigns = ( pcCoef[ posLast ] < 0 );
1883	numNonZero = 1;
1884	lastNZPosInCG = iScanPosSig;
1885	firstNZPosInCG = iScanPosSig;
1886	iScanPosSig--;
1887	}
1888
1889	// encode significant_coeffgroup_flag
1890	Int iCGBlkPos = scanCG[ iSubSet ];
1891	Int iCGPosY = iCGBlkPos / uiNumBlkSide;
1892	Int iCGPosX = iCGBlkPos - (iCGPosY * uiNumBlkSide);
1893	if( uiWidth == 8 && uiHeight == 8 && (uiScanIdx == SCAN_HOR \|\| uiScanIdx == SCAN_VER) )
1894	{
1895	iCGPosY = (uiScanIdx == SCAN_HOR ? iCGBlkPos : 0);
1896	iCGPosX = (uiScanIdx == SCAN_VER ? iCGBlkPos : 0);
1897	}
1898	if( iSubSet == iLastScanSet \|\| iSubSet == 0)
1899	{
1900	uiSigCoeffGroupFlag[ iCGBlkPos ] = 1;
1901	}
1902	else
1903	{
1904	UInt uiSigCoeffGroup = (uiSigCoeffGroupFlag[ iCGBlkPos ] != 0);
1905	UInt uiCtxSig = TComTrQuant::getSigCoeffGroupCtxInc( uiSigCoeffGroupFlag, iCGPosX, iCGPosY, uiScanIdx, uiWidth, uiHeight );
1906	m_pcBinIf->encodeBin( uiSigCoeffGroup, baseCoeffGroupCtx[ uiCtxSig ] );
1907	}
1908
1909	// encode significant_coeff_flag
1910	if( uiSigCoeffGroupFlag[ iCGBlkPos ] )
1911	{
1912	UInt uiBlkPos, uiPosY, uiPosX, uiSig, uiCtxSig;
1913	for( ; iScanPosSig >= iSubPos; iScanPosSig-- )
1914	{
1915	uiBlkPos = scan[ iScanPosSig ];
1916	uiPosY = uiBlkPos >> uiLog2BlockSize;
1917	uiPosX = uiBlkPos - ( uiPosY << uiLog2BlockSize );
1918	uiSig = (pcCoef[ uiBlkPos ] != 0);
1919	if( iScanPosSig > iSubPos \|\| iSubSet == 0 \|\| numNonZero )
1920	{
1921	uiCtxSig = TComTrQuant::getSigCtxInc( pcCoef, uiPosX, uiPosY, blockType, uiWidth, uiHeight, eTType );
1922	m_pcBinIf->encodeBin( uiSig, baseCtx[ uiCtxSig ] );
1923	}
1924	if( uiSig )
1925	{
1926	absCoeff[ numNonZero ] = abs( pcCoef[ uiBlkPos ] );
1927	coeffSigns = 2 * coeffSigns + ( pcCoef[ uiBlkPos ] < 0 );
1928	numNonZero++;
1929	if( lastNZPosInCG == -1 )
1930	{
1931	lastNZPosInCG = iScanPosSig;
1932	}
1933	firstNZPosInCG = iScanPosSig;
1934	}
1935	}
1936	}
1937	else
1938	{
1939	iScanPosSig = iSubPos - 1;
1940	}
1941
1942	if( numNonZero > 0 )
1943	{
1944	Bool signHidden = ( lastNZPosInCG - firstNZPosInCG >= (Int)tsig );
1945
1946	UInt c1 = 1;
1947	UInt uiCtxSet = (iSubSet > 0 && eTType==TEXT_LUMA) ? 2 : 0;
1948
1949	if( uiNumOne > 0 )
1950	{
1951	uiCtxSet++;
1952	}
1953
1954	uiNumOne >>= 1;
1955	ContextModel baseCtxMod = ( eTType==TEXT_LUMA ) ? m_cCUOneSCModel.get( 0, 0 ) + 4 uiCtxSet : m_cCUOneSCModel.get( 0, 0 ) + NUM_ONE_FLAG_CTX_LUMA + 4 * uiCtxSet;
1956
1957	Int numC1Flag = min(numNonZero, C1FLAG_NUMBER);
1958	Int firstC2FlagIdx = -1;
1959	for( Int idx = 0; idx < numC1Flag; idx++ )
1960	{
1961	UInt uiSymbol = absCoeff[ idx ] > 1;
1962	m_pcBinIf->encodeBin( uiSymbol, baseCtxMod[c1] );
1963	if( uiSymbol )
1964	{
1965	c1 = 0;
1966
1967	if (firstC2FlagIdx == -1)
1968	{
1969	firstC2FlagIdx = idx;
1970	}
1971	}
1972	else if( (c1 < 3) && (c1 > 0) )
1973	{
1974	c1++;
1975	}
1976	}
1977
1978	if (c1 == 0)
1979	{
1980
1981	baseCtxMod = ( eTType==TEXT_LUMA ) ? m_cCUAbsSCModel.get( 0, 0 ) + uiCtxSet : m_cCUAbsSCModel.get( 0, 0 ) + NUM_ABS_FLAG_CTX_LUMA + uiCtxSet;
1982	if ( firstC2FlagIdx != -1)
1983	{
1984	UInt symbol = absCoeff[ firstC2FlagIdx ] > 2;
1985	m_pcBinIf->encodeBin( symbol, baseCtxMod[0] );
1986	}
1987	}
1988
1989	if( beValid && signHidden )
1990	{
1991	m_pcBinIf->encodeBinsEP( (coeffSigns >> 1), numNonZero-1 );
1992	}
1993	else
1994	{
1995	m_pcBinIf->encodeBinsEP( coeffSigns, numNonZero );
1996	}
1997
1998	Int iFirstCoeff2 = 1;
1999	if (c1 == 0 \|\| numNonZero > C1FLAG_NUMBER)
2000	{
2001	for ( Int idx = 0; idx < numNonZero; idx++ )
2002	{
2003	UInt baseLevel = (idx < C1FLAG_NUMBER)? (2 + iFirstCoeff2 ) : 1;
2004
2005	if( absCoeff[ idx ] >= baseLevel)
2006	{
2007	xWriteGoRiceExGolomb( absCoeff[ idx ] - baseLevel, uiGoRiceParam );
2008	}
2009	if(absCoeff[ idx ] >= 2)
2010	{
2011	iFirstCoeff2 = 0;
2012	uiNumOne++;
2013	}
2014	}
2015	}
2016	}
2017	else
2018	{
2019	uiNumOne >>= 1;
2020	}
2021	}
2022
2023	return;
2024	}
2025
2026	Void TEncSbac::codeAlfFlag ( UInt uiCode )
2027	{
2028	UInt uiSymbol = ( ( uiCode == 0 ) ? 0 : 1 );
2029	m_pcBinIf->encodeBin( uiSymbol, m_cALFFlagSCModel.get( 0, 0, 0 ) );
2030	}
2031
2032	Void TEncSbac::codeAlfCtrlFlag( UInt uiSymbol )
2033	{
2034	m_pcBinIf->encodeBin( uiSymbol, m_cCUAlfCtrlFlagSCModel.get( 0, 0, 0) );
2035	}
2036
2037	Void TEncSbac::codeAlfUvlc ( UInt uiCode )
2038	{
2039	Int i;
2040
2041	if ( uiCode == 0 )
2042	{
2043	m_pcBinIf->encodeBin( 0, m_cALFUvlcSCModel.get( 0, 0, 0 ) );
2044	}
2045	else
2046	{
2047	m_pcBinIf->encodeBin( 1, m_cALFUvlcSCModel.get( 0, 0, 0 ) );
2048	for ( i=0; i<uiCode-1; i++ )
2049	{
2050	m_pcBinIf->encodeBin( 1, m_cALFUvlcSCModel.get( 0, 0, 1 ) );
2051	}
2052	m_pcBinIf->encodeBin( 0, m_cALFUvlcSCModel.get( 0, 0, 1 ) );
2053	}
2054	}
2055
2056	Void TEncSbac::codeAlfSvlc ( Int iCode )
2057	{
2058	Int i;
2059
2060	if ( iCode == 0 )
2061	{
2062	m_pcBinIf->encodeBin( 0, m_cALFSvlcSCModel.get( 0, 0, 0 ) );
2063	}
2064	else
2065	{
2066	m_pcBinIf->encodeBin( 1, m_cALFSvlcSCModel.get( 0, 0, 0 ) );
2067
2068	// write sign
2069	if ( iCode > 0 )
2070	{
2071	m_pcBinIf->encodeBin( 0, m_cALFSvlcSCModel.get( 0, 0, 1 ) );
2072	}
2073	else
2074	{
2075	m_pcBinIf->encodeBin( 1, m_cALFSvlcSCModel.get( 0, 0, 1 ) );
2076	iCode = -iCode;
2077	}
2078
2079	// write magnitude
2080	for ( i=0; i<iCode-1; i++ )
2081	{
2082	m_pcBinIf->encodeBin( 1, m_cALFSvlcSCModel.get( 0, 0, 2 ) );
2083	}
2084	m_pcBinIf->encodeBin( 0, m_cALFSvlcSCModel.get( 0, 0, 2 ) );
2085	}
2086	}
2087
2088	Void TEncSbac::codeSaoFlag ( UInt uiCode )
2089	{
2090	UInt uiSymbol = ( ( uiCode == 0 ) ? 0 : 1 );
2091	m_pcBinIf->encodeBin( uiSymbol, m_cSaoFlagSCModel.get( 0, 0, 0 ) );
2092	}
2093
2094	Void TEncSbac::codeSaoUvlc ( UInt uiCode )
2095	{
2096	Int i;
2097
2098	if ( uiCode == 0 )
2099	{
2100	m_pcBinIf->encodeBin( 0, m_cSaoUvlcSCModel.get( 0, 0, 0 ) );
2101	}
2102	else
2103	{
2104	m_pcBinIf->encodeBin( 1, m_cSaoUvlcSCModel.get( 0, 0, 0 ) );
2105	for ( i=0; i<uiCode-1; i++ )
2106	{
2107	m_pcBinIf->encodeBin( 1, m_cSaoUvlcSCModel.get( 0, 0, 1 ) );
2108	}
2109	m_pcBinIf->encodeBin( 0, m_cSaoUvlcSCModel.get( 0, 0, 1 ) );
2110	}
2111	}
2112
2113	Void TEncSbac::codeSaoSvlc ( Int iCode )
2114	{
2115	Int i;
2116
2117	if ( iCode == 0 )
2118	{
2119	m_pcBinIf->encodeBin( 0, m_cSaoSvlcSCModel.get( 0, 0, 0 ) );
2120	}
2121	else
2122	{
2123	m_pcBinIf->encodeBin( 1, m_cSaoSvlcSCModel.get( 0, 0, 0 ) );
2124
2125	// write sign
2126	if ( iCode > 0 )
2127	{
2128	m_pcBinIf->encodeBin( 0, m_cSaoSvlcSCModel.get( 0, 0, 1 ) );
2129	}
2130	else
2131	{
2132	m_pcBinIf->encodeBin( 1, m_cSaoSvlcSCModel.get( 0, 0, 1 ) );
2133	iCode = -iCode;
2134	}
2135
2136	// write magnitude
2137	for ( i=0; i<iCode-1; i++ )
2138	{
2139	m_pcBinIf->encodeBin( 1, m_cSaoSvlcSCModel.get( 0, 0, 2 ) );
2140	}
2141	m_pcBinIf->encodeBin( 0, m_cSaoSvlcSCModel.get( 0, 0, 2 ) );
2142	}
2143	}
2144	/** Code SAO band position
2145	* \param uiCode
2146	*/
2147	Void TEncSbac::codeSaoUflc ( UInt uiCode )
2148	{
2149	for (Int i=0;i<5;i++)
2150	{
2151	m_pcBinIf->encodeBinEP ( (uiCode>>i) &0x01 );
2152	}
2153	}
2154	/** Code SAO merge left flag
2155	* \param uiCode
2156	* \param uiCompIdx
2157	*/
2158	Void TEncSbac::codeSaoMergeLeft ( UInt uiCode, UInt uiCompIdx )
2159	{
2160	if (uiCode == 0)
2161	{
2162	m_pcBinIf->encodeBin(0, m_cSaoMergeLeftSCModel.get( 0, 0, uiCompIdx ));
2163	}
2164	else
2165	{
2166	m_pcBinIf->encodeBin(1, m_cSaoMergeLeftSCModel.get( 0, 0, uiCompIdx ));
2167	}
2168	}
2169	/** Code SAO merge up flag
2170	* \param uiCode
2171	*/
2172	Void TEncSbac::codeSaoMergeUp ( UInt uiCode)
2173	{
2174	if (uiCode == 0)
2175	{
2176	m_pcBinIf->encodeBin(0, m_cSaoMergeUpSCModel.get( 0, 0, 0 ));
2177	}
2178	else
2179	{
2180	m_pcBinIf->encodeBin(1, m_cSaoMergeUpSCModel.get( 0, 0, 0 ));
2181	}
2182	}
2183	/** Code SAO type index
2184	* \param uiCode
2185	*/
2186	Void TEncSbac::codeSaoTypeIdx ( UInt uiCode)
2187	{
2188	Int i;
2189	if ( uiCode == 0 )
2190	{
2191	m_pcBinIf->encodeBin( 0, m_cSaoTypeIdxSCModel.get( 0, 0, 0 ) );
2192	}
2193	else
2194	{
2195	m_pcBinIf->encodeBin( 1, m_cSaoTypeIdxSCModel.get( 0, 0, 0 ) );
2196	for ( i=0; i<uiCode-1; i++ )
2197	{
2198	m_pcBinIf->encodeBin( 1, m_cSaoTypeIdxSCModel.get( 0, 0, 1 ) );
2199	}
2200	m_pcBinIf->encodeBin( 0, m_cSaoTypeIdxSCModel.get( 0, 0, 1 ) );
2201	}
2202	}
2203	/*!
2204	****************************************************************************
2205	* \brief
2206	* estimate bit cost for CBP, significant map and significant coefficients
2207	****************************************************************************
2208	*/
2209	Void TEncSbac::estBit( estBitsSbacStruct* pcEstBitsSbac, Int width, Int height, TextType eTType )
2210	{
2211	estCBFBit( pcEstBitsSbac, 0, eTType );
2212
2213	estSignificantCoeffGroupMapBit( pcEstBitsSbac, 0, eTType );
2214
2215	// encode significance map
2216	estSignificantMapBit( pcEstBitsSbac, width, height, eTType );
2217
2218	// encode significant coefficients
2219	estSignificantCoefficientsBit( pcEstBitsSbac, 0, eTType );
2220	}
2221
2222	/*!
2223	****************************************************************************
2224	* \brief
2225	* estimate bit cost for each CBP bit
2226	****************************************************************************
2227	*/
2228	Void TEncSbac::estCBFBit( estBitsSbacStruct* pcEstBitsSbac, UInt uiCTXIdx, TextType eTType )
2229	{
2230	ContextModel *pCtx = m_cCUQtCbfSCModel.get( 0 );
2231
2232	for( UInt uiCtxInc = 0; uiCtxInc < 3*NUM_QT_CBF_CTX; uiCtxInc++ )
2233	{
2234	pcEstBitsSbac->blockCbpBits[ uiCtxInc ][ 0 ] = pCtx[ uiCtxInc ].getEntropyBits( 0 );
2235	pcEstBitsSbac->blockCbpBits[ uiCtxInc ][ 1 ] = pCtx[ uiCtxInc ].getEntropyBits( 1 );
2236	}
2237
2238	pCtx = m_cCUQtRootCbfSCModel.get( 0 );
2239
2240	for( UInt uiCtxInc = 0; uiCtxInc < 4; uiCtxInc++ )
2241	{
2242	pcEstBitsSbac->blockRootCbpBits[ uiCtxInc ][ 0 ] = pCtx[ uiCtxInc ].getEntropyBits( 0 );
2243	pcEstBitsSbac->blockRootCbpBits[ uiCtxInc ][ 1 ] = pCtx[ uiCtxInc ].getEntropyBits( 1 );
2244	}
2245	}
2246
2247
2248	/*!
2249	****************************************************************************
2250	* \brief
2251	* estimate SAMBAC bit cost for significant coefficient group map
2252	****************************************************************************
2253	*/
2254	Void TEncSbac::estSignificantCoeffGroupMapBit( estBitsSbacStruct* pcEstBitsSbac, UInt uiCTXIdx, TextType eTType )
2255	{
2256	Int firstCtx = 0, numCtx = NUM_SIG_CG_FLAG_CTX;
2257
2258	for ( Int ctxIdx = firstCtx; ctxIdx < firstCtx + numCtx; ctxIdx++ )
2259	{
2260	for( UInt uiBin = 0; uiBin < 2; uiBin++ )
2261	{
2262	pcEstBitsSbac->significantCoeffGroupBits[ ctxIdx ][ uiBin ] = m_cCUSigCoeffGroupSCModel.get( 0, eTType, ctxIdx ).getEntropyBits( uiBin );
2263	}
2264	}
2265	}
2266
2267
2268	/*!
2269	****************************************************************************
2270	* \brief
2271	* estimate SAMBAC bit cost for significant coefficient map
2272	****************************************************************************
2273	*/
2274	Void TEncSbac::estSignificantMapBit( estBitsSbacStruct* pcEstBitsSbac, Int width, Int height, TextType eTType )
2275	{
2276	Int firstCtx = 0, numCtx = (eTType == TEXT_LUMA) ? 9 : 6;
2277	if (std::max(width, height) >= 16)
2278	{
2279	firstCtx = (eTType == TEXT_LUMA) ? 20 : 17;
2280	numCtx = (eTType == TEXT_LUMA) ? 7 : 4;
2281	}
2282	else if (width == 8)
2283	{
2284	firstCtx = (eTType == TEXT_LUMA) ? 9 : 6;
2285	numCtx = 11;
2286	}
2287
2288	if (eTType == TEXT_LUMA )
2289	{
2290	for ( Int ctxIdx = firstCtx; ctxIdx < firstCtx + numCtx; ctxIdx++ )
2291	{
2292	for( UInt uiBin = 0; uiBin < 2; uiBin++ )
2293	{
2294	pcEstBitsSbac->significantBits[ ctxIdx ][ uiBin ] = m_cCUSigSCModel.get( 0, 0, ctxIdx ).getEntropyBits( uiBin );
2295	}
2296	}
2297	}
2298	else
2299	{
2300	for ( Int ctxIdx = firstCtx; ctxIdx < firstCtx + numCtx; ctxIdx++ )
2301	{
2302	for( UInt uiBin = 0; uiBin < 2; uiBin++ )
2303	{
2304	pcEstBitsSbac->significantBits[ ctxIdx ][ uiBin ] = m_cCUSigSCModel.get( 0, 0, NUM_SIG_FLAG_CTX_LUMA + ctxIdx ).getEntropyBits( uiBin );
2305	}
2306	}
2307	}
2308	Int iBitsX = 0, iBitsY = 0;
2309	const UInt *puiCtxIdx;
2310	Int ctx;
2311	Int widthCtx = eTType? 4 : width;
2312	puiCtxIdx = g_uiLastCtx + (g_aucConvertToBit[ widthCtx ]*(g_aucConvertToBit[ widthCtx ]+3));
2313	ContextModel *pCtxX = m_cCuCtxLastX.get( 0, eTType );
2314	for (ctx = 0; ctx < g_uiGroupIdx[ width - 1 ]; ctx++)
2315	{
2316	Int ctxOffset = puiCtxIdx[ ctx ];
2317	if (eTType)
2318	{
2319	Int ctxOffsetC = ctx>>g_aucConvertToBit[ width ];
2320	pcEstBitsSbac->lastXBits[ ctx ] = iBitsX + pCtxX[ ctxOffsetC ].getEntropyBits( 0 );
2321	iBitsX += pCtxX[ ctxOffsetC].getEntropyBits( 1 );
2322	}
2323	else
2324	{
2325	pcEstBitsSbac->lastXBits[ ctx ] = iBitsX + pCtxX[ ctxOffset ].getEntropyBits( 0 );
2326	iBitsX += pCtxX[ ctxOffset ].getEntropyBits( 1 );
2327	}
2328	}
2329	pcEstBitsSbac->lastXBits[ctx] = iBitsX;
2330
2331	Int heightCtx = eTType? 4 : height;
2332	puiCtxIdx = g_uiLastCtx + (g_aucConvertToBit[ heightCtx ]*(g_aucConvertToBit[ heightCtx ]+3));
2333	ContextModel *pCtxY = m_cCuCtxLastY.get( 0, eTType );
2334	for (ctx = 0; ctx < g_uiGroupIdx[ height - 1 ]; ctx++)
2335	{
2336	Int ctxOffset = puiCtxIdx[ ctx ];
2337	if (eTType)
2338	{
2339	Int ctxOffsetC = ctx>>g_aucConvertToBit[ height ];
2340	pcEstBitsSbac->lastYBits[ ctx ] = iBitsY + pCtxY[ ctxOffsetC ].getEntropyBits( 0 );
2341	iBitsY += pCtxY[ctxOffsetC].getEntropyBits( 1 );
2342	}
2343	else
2344	{
2345	pcEstBitsSbac->lastYBits[ ctx ] = iBitsY + pCtxY[ ctxOffset ].getEntropyBits( 0 );
2346	iBitsY += pCtxY[ ctxOffset ].getEntropyBits( 1 );
2347	}
2348	}
2349	pcEstBitsSbac->lastYBits[ctx] = iBitsY;
2350	}
2351
2352	/*!
2353	****************************************************************************
2354	* \brief
2355	* estimate bit cost of significant coefficient
2356	****************************************************************************
2357	*/
2358	Void TEncSbac::estSignificantCoefficientsBit( estBitsSbacStruct* pcEstBitsSbac, UInt uiCTXIdx, TextType eTType )
2359	{
2360	if (eTType==TEXT_LUMA)
2361	{
2362	ContextModel *ctxOne = m_cCUOneSCModel.get(0, 0);
2363	ContextModel *ctxAbs = m_cCUAbsSCModel.get(0, 0);
2364
2365	for (Int ctxIdx = 0; ctxIdx < NUM_ONE_FLAG_CTX_LUMA; ctxIdx++)
2366	{
2367	pcEstBitsSbac->m_greaterOneBits[ ctxIdx ][ 0 ] = ctxOne[ ctxIdx ].getEntropyBits( 0 );
2368	pcEstBitsSbac->m_greaterOneBits[ ctxIdx ][ 1 ] = ctxOne[ ctxIdx ].getEntropyBits( 1 );
2369	}
2370
2371	for (Int ctxIdx = 0; ctxIdx < NUM_ABS_FLAG_CTX_LUMA; ctxIdx++)
2372	{
2373	pcEstBitsSbac->m_levelAbsBits[ ctxIdx ][ 0 ] = ctxAbs[ ctxIdx ].getEntropyBits( 0 );
2374	pcEstBitsSbac->m_levelAbsBits[ ctxIdx ][ 1 ] = ctxAbs[ ctxIdx ].getEntropyBits( 1 );
2375	}
2376	}
2377	else
2378	{
2379	ContextModel *ctxOne = m_cCUOneSCModel.get(0, 0) + NUM_ONE_FLAG_CTX_LUMA;
2380	ContextModel *ctxAbs = m_cCUAbsSCModel.get(0, 0) + NUM_ABS_FLAG_CTX_LUMA;
2381
2382	for (Int ctxIdx = 0; ctxIdx < NUM_ONE_FLAG_CTX_CHROMA; ctxIdx++)
2383	{
2384	pcEstBitsSbac->m_greaterOneBits[ ctxIdx ][ 0 ] = ctxOne[ ctxIdx ].getEntropyBits( 0 );
2385	pcEstBitsSbac->m_greaterOneBits[ ctxIdx ][ 1 ] = ctxOne[ ctxIdx ].getEntropyBits( 1 );
2386	}
2387
2388	for (Int ctxIdx = 0; ctxIdx < NUM_ABS_FLAG_CTX_CHROMA; ctxIdx++)
2389	{
2390	pcEstBitsSbac->m_levelAbsBits[ ctxIdx ][ 0 ] = ctxAbs[ ctxIdx ].getEntropyBits( 0 );
2391	pcEstBitsSbac->m_levelAbsBits[ ctxIdx ][ 1 ] = ctxAbs[ ctxIdx ].getEntropyBits( 1 );
2392	}
2393	}
2394	}
2395
2396	/**
2397	- Initialize our context information from the nominated source.
2398	.
2399	\param pSrc From where to copy context information.
2400	*/
2401	Void TEncSbac::xCopyContextsFrom( TEncSbac* pSrc )
2402	{
2403	memcpy(m_contextModels, pSrc->m_contextModels, m_numContextModels*sizeof(m_contextModels[0]));
2404	}
2405
2406	Void TEncSbac::loadContexts ( TEncSbac* pScr)
2407	{
2408	this->xCopyContextsFrom(pScr);
2409	}
2410
2411	#if HHI_DMM_WEDGE_INTRA \|\| HHI_DMM_PRED_TEX \|\| (LGE_EDGE_INTRA_A0070 && LGE_EDGE_INTRA_DELTA_DC)
2412	Void TEncSbac::xWriteExGolombLevel( UInt uiSymbol, ContextModel& rcSCModel )
2413	{
2414	if( uiSymbol )
2415	{
2416	m_pcBinIf->encodeBin( 1, rcSCModel );
2417	UInt uiCount = 0;
2418	Bool bNoExGo = (uiSymbol < 13);
2419
2420	while( --uiSymbol && ++uiCount < 13 )
2421	{
2422	m_pcBinIf->encodeBin( 1, rcSCModel );
2423	}
2424	if( bNoExGo )
2425	{
2426	m_pcBinIf->encodeBin( 0, rcSCModel );
2427	}
2428	else
2429	{
2430	xWriteEpExGolomb( uiSymbol, 0 );
2431	}
2432	}
2433	else
2434	{
2435	m_pcBinIf->encodeBin( 0, rcSCModel );
2436	}
2437
2438	return;
2439	}
2440	#endif
2441	#if HHI_DMM_WEDGE_INTRA
2442	Void TEncSbac::xCodeWedgeFullInfo( TComDataCU* pcCU, UInt uiAbsPartIdx )
2443	{
2444	Int iIntraIdx = pcCU->getIntraSizeIdx(uiAbsPartIdx);
2445	Int iBits = g_aucWedgeFullBitsListIdx[iIntraIdx];
2446
2447	UInt uiTabIdx = pcCU->getWedgeFullTabIdx( uiAbsPartIdx );
2448
2449	for ( Int i = 0; i < iBits; i++ )
2450	{
2451	m_pcBinIf->encodeBin( ( uiTabIdx >> i ) & 1, m_cDmmDataSCModel.get(0, 0, 0) );
2452	}
2453	}
2454
2455	Void TEncSbac::xCodeWedgeFullDeltaInfo( TComDataCU* pcCU, UInt uiAbsPartIdx )
2456	{
2457	Int iIntraIdx = pcCU->getIntraSizeIdx(uiAbsPartIdx);
2458	Int iBits = g_aucWedgeFullBitsListIdx[iIntraIdx];
2459
2460	UInt uiTabIdx = pcCU->getWedgeFullTabIdx( uiAbsPartIdx );
2461
2462	for ( Int i = 0; i < iBits; i++ )
2463	{
2464	m_pcBinIf->encodeBin( ( uiTabIdx >> i ) & 1, m_cDmmDataSCModel.get(0, 0, 0) );
2465	}
2466
2467	Int iDeltaDC1 = pcCU->getWedgeFullDeltaDC1( uiAbsPartIdx );
2468	Int iDeltaDC2 = pcCU->getWedgeFullDeltaDC2( uiAbsPartIdx );
2469
2470	xWriteExGolombLevel( UInt( abs( iDeltaDC1 ) ), m_cDmmDataSCModel.get(0, 0, 1) );
2471	if ( iDeltaDC1 != 0 )
2472	{
2473	UInt uiSign = iDeltaDC1 > 0 ? 0 : 1;
2474	m_pcBinIf->encodeBinEP( uiSign );
2475	}
2476	xWriteExGolombLevel( UInt( abs( iDeltaDC2 ) ), m_cDmmDataSCModel.get(0, 0, 1) );
2477	if ( iDeltaDC2 != 0 )
2478	{
2479	UInt uiSign = iDeltaDC2 > 0 ? 0 : 1;
2480	m_pcBinIf->encodeBinEP( uiSign );
2481	}
2482	}
2483
2484	Void TEncSbac::xCodeWedgePredDirInfo( TComDataCU* pcCU, UInt uiAbsPartIdx )
2485	{
2486	if( DMM_WEDGE_PREDDIR_DELTAEND_MAX > 0 )
2487	{
2488	Int iDeltaEnd = pcCU->getWedgePredDirDeltaEnd( uiAbsPartIdx );
2489	m_pcBinIf->encodeBin( (iDeltaEnd!=0), m_cDmmDataSCModel.get(0, 0, 2) );
2490
2491	if( iDeltaEnd != 0 )
2492	{
2493	UInt uiAbsValMinus1 = abs(iDeltaEnd)-1;
2494	m_pcBinIf->encodeBin( (uiAbsValMinus1 & 0x01), m_cDmmDataSCModel.get(0, 0, 2) );
2495	m_pcBinIf->encodeBin( (uiAbsValMinus1 & 0x02) >> 1, m_cDmmDataSCModel.get(0, 0, 2) );
2496
2497	UInt uiSign = iDeltaEnd > 0 ? 0 : 1;
2498	m_pcBinIf->encodeBinEP( uiSign );
2499	}
2500	}
2501	}
2502
2503	Void TEncSbac::xCodeWedgePredDirDeltaInfo( TComDataCU* pcCU, UInt uiAbsPartIdx )
2504	{
2505	if( DMM_WEDGE_PREDDIR_DELTAEND_MAX > 0 )
2506	{
2507	Int iDeltaEnd = pcCU->getWedgePredDirDeltaEnd( uiAbsPartIdx );
2508	m_pcBinIf->encodeBin( (iDeltaEnd!=0), m_cDmmDataSCModel.get(0, 0, 2) );
2509
2510	if( iDeltaEnd != 0 )
2511	{
2512	UInt uiAbsValMinus1 = abs(iDeltaEnd)-1;
2513	m_pcBinIf->encodeBin( (uiAbsValMinus1 & 0x01), m_cDmmDataSCModel.get(0, 0, 2) );
2514	m_pcBinIf->encodeBin( (uiAbsValMinus1 & 0x02) >> 1, m_cDmmDataSCModel.get(0, 0, 2) );
2515
2516	UInt uiSign = iDeltaEnd > 0 ? 0 : 1;
2517	m_pcBinIf->encodeBinEP( uiSign );
2518	}
2519	}
2520
2521	Int iDeltaDC1 = pcCU->getWedgePredDirDeltaDC1( uiAbsPartIdx );
2522	Int iDeltaDC2 = pcCU->getWedgePredDirDeltaDC2( uiAbsPartIdx );
2523
2524	xWriteExGolombLevel( UInt( abs( iDeltaDC1 ) ), m_cDmmDataSCModel.get(0, 0, 1) );
2525	if ( iDeltaDC1 != 0 )
2526	{
2527	UInt uiSign = iDeltaDC1 > 0 ? 0 : 1;
2528	m_pcBinIf->encodeBinEP( uiSign );
2529	}
2530	xWriteExGolombLevel( UInt( abs( iDeltaDC2 ) ), m_cDmmDataSCModel.get(0, 0, 1) );
2531	if ( iDeltaDC2 != 0 )
2532	{
2533	UInt uiSign = iDeltaDC2 > 0 ? 0 : 1;
2534	m_pcBinIf->encodeBinEP( uiSign );
2535	}
2536	}
2537	#endif
2538	#if HHI_DMM_PRED_TEX
2539	#if LGE_DMM3_SIMP_C0044
2540	Void TEncSbac::xCodeWedgePredTexInfo( TComDataCU* pcCU, UInt uiAbsPartIdx )
2541	{
2542	Int iIntraIdx = pcCU->getIntraSizeIdx(uiAbsPartIdx);
2543	Int iBits = g_aucWedgeTexPredBitsListIdx[iIntraIdx];
2544
2545	UInt uiTabIdx = pcCU->getWedgePredTexIntraTabIdx( uiAbsPartIdx );
2546
2547	for ( Int i = 0; i < iBits; i++ )
2548	{
2549	m_pcBinIf->encodeBin( ( uiTabIdx >> i ) & 1, m_cDmmDataSCModel.get(0, 0, 3) );
2550	}
2551	}
2552	#endif
2553
2554	Void TEncSbac::xCodeWedgePredTexDeltaInfo( TComDataCU* pcCU, UInt uiAbsPartIdx )
2555	{
2556	#if LGE_DMM3_SIMP_C0044
2557	xCodeWedgePredTexInfo( pcCU, uiAbsPartIdx );
2558	#endif
2559	Int iDeltaDC1 = pcCU->getWedgePredTexDeltaDC1( uiAbsPartIdx );
2560	Int iDeltaDC2 = pcCU->getWedgePredTexDeltaDC2( uiAbsPartIdx );
2561
2562	xWriteExGolombLevel( UInt( abs( iDeltaDC1 ) ), m_cDmmDataSCModel.get(0, 0, 1) );
2563	if ( iDeltaDC1 != 0 )
2564	{
2565	UInt uiSign = iDeltaDC1 > 0 ? 0 : 1;
2566	m_pcBinIf->encodeBinEP( uiSign );
2567	}
2568	xWriteExGolombLevel( UInt( abs( iDeltaDC2 ) ), m_cDmmDataSCModel.get(0, 0, 1) );
2569	if ( iDeltaDC2 != 0 )
2570	{
2571	UInt uiSign = iDeltaDC2 > 0 ? 0 : 1;
2572	m_pcBinIf->encodeBinEP( uiSign );
2573	}
2574	}
2575
2576	Void TEncSbac::xCodeContourPredTexDeltaInfo( TComDataCU* pcCU, UInt uiAbsPartIdx )
2577	{
2578	Int iDeltaDC1 = pcCU->getContourPredTexDeltaDC1( uiAbsPartIdx );
2579	Int iDeltaDC2 = pcCU->getContourPredTexDeltaDC2( uiAbsPartIdx );
2580
2581	xWriteExGolombLevel( UInt( abs( iDeltaDC1 ) ), m_cDmmDataSCModel.get(0, 0, 1) );
2582	if ( iDeltaDC1 != 0 )
2583	{
2584	UInt uiSign = iDeltaDC1 > 0 ? 0 : 1;
2585	m_pcBinIf->encodeBinEP( uiSign );
2586	}
2587	xWriteExGolombLevel( UInt( abs( iDeltaDC2 ) ), m_cDmmDataSCModel.get(0, 0, 1) );
2588	if ( iDeltaDC2 != 0 )
2589	{
2590	UInt uiSign = iDeltaDC2 > 0 ? 0 : 1;
2591	m_pcBinIf->encodeBinEP( uiSign );
2592	}
2593	}
2594	#endif
2595
2596	#if RWTH_SDC_DLT_B0036
2597	#if !PKU_QC_DEPTH_INTRA_UNI_D0195
2598	Void TEncSbac::codeSDCPredMode( TComDataCU* pcCU, UInt uiAbsPartIdx )
2599	{
2600	assert( pcCU->getSlice()->getSPS()->isDepth() );
2601	assert( pcCU->getPartitionSize(uiAbsPartIdx) == SIZE_2Nx2N );
2602	assert( pcCU->getSDCFlag(uiAbsPartIdx) );
2603
2604	UInt uiPredMode = pcCU->getLumaIntraDir(uiAbsPartIdx);
2605	UInt uiCtx = 0;
2606
2607	UInt uiMPModeIdx = 0;
2608
2609	for(Int i=0; i<RWTH_SDC_NUM_PRED_MODES-1; i++)
2610	{
2611	UInt uiBit = (uiPredMode == g_auiSDCPredModes[uiMPModeIdx]) ? 1 : 0;
2612	#if INTEL_SDC64_D0193
2613	if( !(pcCU->getWidth(uiAbsPartIdx) == 64 && i == 1))
2614	#endif
2615	m_pcBinIf->encodeBin( uiBit, m_cSDCPredModeSCModel.get( 0, i, uiCtx ) );
2616
2617	// if mode is most probable mode, we are done here
2618	if ( uiBit == 1 )
2619	break;
2620
2621	// else: get next most probable pred mode
2622	uiMPModeIdx = (uiMPModeIdx+1)%RWTH_SDC_NUM_PRED_MODES;
2623	}
2624
2625	#if HHI_DMM_WEDGE_INTRA
2626	if( uiPredMode == DMM_WEDGE_FULL_IDX ) { xCodeWedgeFullInfo ( pcCU, uiAbsPartIdx ); }
2627	if( uiPredMode == DMM_WEDGE_PREDDIR_IDX ) { xCodeWedgePredDirInfo ( pcCU, uiAbsPartIdx ); }
2628	#endif
2629
2630	AOF(uiPredMode == g_auiSDCPredModes[uiMPModeIdx]);
2631	}
2632
2633	Void TEncSbac::codeSDCFlag( TComDataCU* pcCU, UInt uiAbsPartIdx )
2634	{
2635	// get context function is here
2636	UInt uiSymbol = pcCU->getSDCFlag( uiAbsPartIdx ) ? 1 : 0;
2637	UInt uiCtxSDCFlag = pcCU->getCtxSDCFlag( uiAbsPartIdx );
2638	m_pcBinIf->encodeBin( uiSymbol, m_cSDCFlagSCModel.get( 0, 0, uiCtxSDCFlag ) );
2639
2640	}
2641	#endif
2642
2643	Void TEncSbac::codeSDCResidualData ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiSegment )
2644	{
2645	assert( pcCU->getSlice()->getSPS()->isDepth() );
2646	assert( pcCU->getPartitionSize(uiAbsPartIdx) == SIZE_2Nx2N );
2647	assert( pcCU->getSDCFlag(uiAbsPartIdx) );
2648	assert( uiSegment < 2 );
2649
2650	Pel segmentDCOffset = pcCU->getSDCSegmentDCOffset(uiSegment, uiAbsPartIdx);
2651
2652	UInt uiResidual = segmentDCOffset == 0 ? 0 : 1;
2653	UInt uiSign = segmentDCOffset < 0 ? 1 : 0;
2654	UInt uiAbsIdx = abs(segmentDCOffset);
2655	#if !LGE_CONCATENATE_D0141
2656	UInt uiBit = 0;
2657	#endif
2658
2659	UInt uiMaxResidualBits = GetBitsPerDepthValue();
2660	assert( uiMaxResidualBits <= g_uiBitDepth );
2661
2662	// residual flag
2663	#if RWTH_SDC_CTX_SIMPL_D0032
2664	m_pcBinIf->encodeBin( uiResidual, m_cSDCResidualFlagSCModel.get( 0, 0, 0 ) );
2665	#else
2666	m_pcBinIf->encodeBin( uiResidual, m_cSDCResidualFlagSCModel.get( 0, uiSegment, 0 ) ); //TODO depthmap: more sophisticated context selection
2667	#endif
2668
2669	if (uiResidual)
2670	{
2671	// encode sign bit of residual
2672	#if RWTH_SDC_CTX_SIMPL_D0032
2673	m_pcBinIf->encodeBinEP( uiSign );
2674	#else
2675	m_pcBinIf->encodeBin( uiSign, m_cSDCResidualSignFlagSCModel.get( 0, uiSegment, 0 ) ); //TODO depthmap: more sophisticated context selection
2676	#endif
2677
2678	assert(uiAbsIdx < GetNumDepthValues());
2679
2680	// encode residual magnitude
2681	uiAbsIdx -= 1;
2682	#if LGE_CONCATENATE_D0141
2683	//prefix part
2684	if ( uiAbsIdx == 0 )
2685	m_pcBinIf->encodeBin( 0, m_cSDCResidualSCModel.get(0, 0, 0) );
2686	else
2687	{
2688	UInt l = uiAbsIdx;
2689	UInt k = 0;
2690	while ( l > 0 && k < PrefixThreshold )
2691	{
2692	m_pcBinIf->encodeBin( 1, m_cSDCResidualSCModel.get(0, 0, 0) );
2693	l--;
2694	k++;
2695	}
2696	if ( uiAbsIdx < PrefixThreshold )
2697	m_pcBinIf->encodeBin( 0, m_cSDCResidualSCModel.get(0, 0, 0) );
2698	//suffix part
2699	else
2700	{
2701	uiAbsIdx -= PrefixThreshold;
2702	UInt uiSuffixLength = BitsPerSuffix;
2703	UInt uiBitInfo = 0;
2704	for ( Int i = 0; i < uiSuffixLength; i++)
2705	{
2706	uiBitInfo = ( uiAbsIdx & ( 1 << i ) ) >> i;
2707	m_pcBinIf->encodeBinEP( uiBitInfo);
2708	}
2709	}
2710	}
2711	#else
2712	for (Int i=0; i<uiMaxResidualBits; i++)
2713	{
2714	uiBit = (uiAbsIdx & (1<<i))>>i;
2715
2716	#if RWTH_SDC_CTX_SIMPL_D0032
2717	m_pcBinIf->encodeBin( uiBit, m_cSDCResidualSCModel.get( 0, 0, i ) );
2718	#else
2719	m_pcBinIf->encodeBin( uiBit, m_cSDCResidualSCModel.get( 0, uiSegment, i ) ); //TODO depthmap: more sophisticated context selection
2720	#endif
2721	}
2722	#endif
2723
2724	}
2725	}
2726	#endif
2727	//! \}

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

Download in other formats: