Context navigation

source: 3DVCSoftware/trunk/source/Lib/TLibDecoder/TDecSbac.cpp @ 590

Visit:

Last change on this file since 590 was 443, checked in by tech, 12 years ago
Reintegrated branch 6.2-dev0 rev. 442. Changed version number. Added coding results.
Property svn:eol-style set to `native`
File size: 95.1 KB

Rev	Line
[5]	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
[56]	4	* granted under this license.
[5]	5	*
[56]	6	* Copyright (c) 2010-2012, ITU/ISO/IEC
[5]	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.
[56]	17	* * Neither the name of the ITU/ISO/IEC nor the names of its contributors may
[5]	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	*/
[2]	33
	34	/** \file TDecSbac.cpp
	35	\brief Context-adaptive entropy decoder class
	36	*/
	37
	38	#include "TDecSbac.h"
	39
[56]	40	//! \ingroup TLibDecoder
	41	//! \{
	42
[2]	43	//////////////////////////////////////////////////////////////////////
	44	// Construction/Destruction
	45	//////////////////////////////////////////////////////////////////////
	46
	47	TDecSbac::TDecSbac()
	48	// new structure here
	49	: m_pcBitstream ( 0 )
	50	, m_pcTDecBinIf ( NULL )
[56]	51	, m_numContextModels ( 0 )
	52	, m_cCUSplitFlagSCModel ( 1, 1, NUM_SPLIT_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels )
	53	, m_cCUSkipFlagSCModel ( 1, 1, NUM_SKIP_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels)
[189]	54	#if LGE_ILLUCOMP_B0045
	55	, m_cCUICFlagSCModel ( 1, 1, NUM_IC_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels)
	56	#endif
[56]	57	, m_cCUMergeFlagExtSCModel ( 1, 1, NUM_MERGE_FLAG_EXT_CTX , m_contextModels + m_numContextModels, m_numContextModels)
	58	, m_cCUMergeIdxExtSCModel ( 1, 1, NUM_MERGE_IDX_EXT_CTX , m_contextModels + m_numContextModels, m_numContextModels)
[296]	59	#if H3D_IVRP
[56]	60	, m_cResPredFlagSCModel ( 1, 1, NUM_RES_PRED_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels)
[2]	61	#endif
[443]	62	#if QC_ARP_D0177
	63	, m_cCUPUARPW ( 1, 1, NUM_ARPW_CTX , m_contextModels + m_numContextModels, m_numContextModels)
	64	#endif
[56]	65	, m_cCUPartSizeSCModel ( 1, 1, NUM_PART_SIZE_CTX , m_contextModels + m_numContextModels, m_numContextModels)
	66	, m_cCUPredModeSCModel ( 1, 1, NUM_PRED_MODE_CTX , m_contextModels + m_numContextModels, m_numContextModels)
	67	, m_cCUAlfCtrlFlagSCModel ( 1, 1, NUM_ALF_CTRL_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels)
	68	, m_cCUIntraPredSCModel ( 1, 1, NUM_ADI_CTX , m_contextModels + m_numContextModels, m_numContextModels)
	69	, m_cCUChromaPredSCModel ( 1, 1, NUM_CHROMA_PRED_CTX , m_contextModels + m_numContextModels, m_numContextModels)
	70	, m_cCUDeltaQpSCModel ( 1, 1, NUM_DELTA_QP_CTX , m_contextModels + m_numContextModels, m_numContextModels)
	71	, m_cCUInterDirSCModel ( 1, 1, NUM_INTER_DIR_CTX , m_contextModels + m_numContextModels, m_numContextModels)
	72	, m_cCURefPicSCModel ( 1, 1, NUM_REF_NO_CTX , m_contextModels + m_numContextModels, m_numContextModels)
	73	, m_cCUMvdSCModel ( 1, 1, NUM_MV_RES_CTX , m_contextModels + m_numContextModels, m_numContextModels)
	74	, m_cCUQtCbfSCModel ( 1, 2, NUM_QT_CBF_CTX , m_contextModels + m_numContextModels, m_numContextModels)
	75	, m_cCUTransSubdivFlagSCModel ( 1, 1, NUM_TRANS_SUBDIV_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels)
	76	, m_cCUQtRootCbfSCModel ( 1, 1, NUM_QT_ROOT_CBF_CTX , m_contextModels + m_numContextModels, m_numContextModels)
	77	, m_cCUSigCoeffGroupSCModel ( 1, 2, NUM_SIG_CG_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels)
	78	, m_cCUSigSCModel ( 1, 1, NUM_SIG_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels)
	79	, m_cCuCtxLastX ( 1, 2, NUM_CTX_LAST_FLAG_XY , m_contextModels + m_numContextModels, m_numContextModels)
	80	, m_cCuCtxLastY ( 1, 2, NUM_CTX_LAST_FLAG_XY , m_contextModels + m_numContextModels, m_numContextModels)
	81	, m_cCUOneSCModel ( 1, 1, NUM_ONE_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels)
	82	, m_cCUAbsSCModel ( 1, 1, NUM_ABS_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels)
	83	, m_cMVPIdxSCModel ( 1, 1, NUM_MVP_IDX_CTX , m_contextModels + m_numContextModels, m_numContextModels)
	84	, m_cALFFlagSCModel ( 1, 1, NUM_ALF_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels)
	85	, m_cALFUvlcSCModel ( 1, 1, NUM_ALF_UVLC_CTX , m_contextModels + m_numContextModels, m_numContextModels)
	86	, m_cALFSvlcSCModel ( 1, 1, NUM_ALF_SVLC_CTX , m_contextModels + m_numContextModels, m_numContextModels)
	87	, m_cCUAMPSCModel ( 1, 1, NUM_CU_AMP_CTX , m_contextModels + m_numContextModels, m_numContextModels)
[443]	88	#if LGE_SAO_MIGRATION_D0091
	89	, m_cSaoMergeSCModel ( 1, 1, NUM_SAO_MERGE_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels)
	90	, m_cSaoTypeIdxSCModel ( 1, 1, NUM_SAO_TYPE_IDX_CTX , m_contextModels + m_numContextModels, m_numContextModels)
	91	#else
[56]	92	, m_cSaoFlagSCModel ( 1, 1, NUM_SAO_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels)
	93	, m_cSaoUvlcSCModel ( 1, 1, NUM_SAO_UVLC_CTX , m_contextModels + m_numContextModels, m_numContextModels)
	94	, m_cSaoSvlcSCModel ( 1, 1, NUM_SAO_SVLC_CTX , m_contextModels + m_numContextModels, m_numContextModels)
	95	, m_cSaoMergeLeftSCModel ( 1, 1, NUM_SAO_MERGE_LEFT_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels)
	96	, m_cSaoMergeUpSCModel ( 1, 1, NUM_SAO_MERGE_UP_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels)
	97	, m_cSaoTypeIdxSCModel ( 1, 1, NUM_SAO_TYPE_IDX_CTX , m_contextModels + m_numContextModels, m_numContextModels)
[443]	98	#endif
[5]	99	#if HHI_DMM_WEDGE_INTRA \|\| HHI_DMM_PRED_TEX
[443]	100	#if !PKU_QC_DEPTH_INTRA_UNI_D0195
[56]	101	, m_cDmmFlagSCModel ( 1, 1, NUM_DMM_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels)
	102	, m_cDmmModeSCModel ( 1, 1, NUM_DMM_MODE_CTX , m_contextModels + m_numContextModels, m_numContextModels)
[443]	103	#endif
[56]	104	, m_cDmmDataSCModel ( 1, 1, NUM_DMM_DATA_CTX , m_contextModels + m_numContextModels, m_numContextModels)
[2]	105	#endif
[189]	106	#if LGE_EDGE_INTRA_A0070
[100]	107	, m_cEdgeIntraSCModel ( 1, 1, NUM_EDGE_INTRA_CTX , m_contextModels + m_numContextModels, m_numContextModels)
	108	#if LGE_EDGE_INTRA_DELTA_DC
	109	, m_cEdgeIntraDeltaDCSCModel ( 1, 1, NUM_EDGE_INTRA_DELTA_DC_CTX , m_contextModels + m_numContextModels, m_numContextModels)
	110	#endif
	111	#endif
[189]	112	#if RWTH_SDC_DLT_B0036
[443]	113	#if !PKU_QC_DEPTH_INTRA_UNI_D0195
[189]	114	, m_cSDCFlagSCModel ( 1, 1, SDC_NUM_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels)
[443]	115	#else
	116	, m_cDepthModeModel ( 1, 1, DEPTH_MODE_NUM_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels)
	117	, m_cDmmDeltaFlagModel ( 1, 1, DMM_DELTA_NUM_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels)
	118	#endif
	119	#if RWTH_SDC_CTX_SIMPL_D0032
	120	, m_cSDCResidualFlagSCModel ( 1, 1, SDC_NUM_RESIDUAL_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels)
	121	, m_cSDCResidualSCModel ( 1, 1, SDC_NUM_RESIDUAL_CTX , m_contextModels + m_numContextModels, m_numContextModels)
	122	, m_cSDCPredModeSCModel ( 1, 3, SDC_NUM_PRED_MODE_CTX , m_contextModels + m_numContextModels, m_numContextModels)
	123	#else
[189]	124	, m_cSDCResidualFlagSCModel ( 1, 2, SDC_NUM_RESIDUAL_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels)
	125	, m_cSDCResidualSignFlagSCModel ( 1, 2, SDC_NUM_SIGN_FLAG_CTX , m_contextModels + m_numContextModels, m_numContextModels)
	126	, m_cSDCResidualSCModel ( 1, 2, SDC_NUM_RESIDUAL_CTX , m_contextModels + m_numContextModels, m_numContextModels)
	127	, m_cSDCPredModeSCModel ( 1, 3, SDC_NUM_PRED_MODE_CTX , m_contextModels + m_numContextModels, m_numContextModels)
	128	#endif
[443]	129	#endif
[2]	130	{
[56]	131	assert( m_numContextModels <= MAX_NUM_CTX_MOD );
	132	m_iSliceGranularity = 0;
[2]	133	}
	134
	135	TDecSbac::~TDecSbac()
	136	{
	137	}
	138
	139	// ====================================================================================================================
	140	// Public member functions
	141	// ====================================================================================================================
	142
[56]	143	#if CABAC_INIT_FLAG
	144	Void TDecSbac::resetEntropy(TComSlice* pSlice)
[2]	145	{
[56]	146	SliceType sliceType = pSlice->getSliceType();
	147	Int qp = pSlice->getSliceQp();
	148
	149	if (pSlice->getPPS()->getCabacInitPresentFlag() && pSlice->getCabacInitFlag())
	150	{
	151	switch (sliceType)
	152	{
	153	case P_SLICE: // change initialization table to B_SLICE initialization
	154	sliceType = B_SLICE;
	155	break;
	156	case B_SLICE: // change initialization table to P_SLICE initialization
	157	sliceType = P_SLICE;
	158	break;
	159	default : // should not occur
	160	assert(0);
	161	}
	162	}
	163
	164	#else
	165	Void TDecSbac::resetEntropywithQPandInitIDC (Int qp, Int iID)
	166	{
	167	SliceType sliceType = (SliceType)iID;
	168	#endif
	169
	170	m_cCUSplitFlagSCModel.initBuffer ( sliceType, qp, (UChar*)INIT_SPLIT_FLAG );
	171	m_cCUSkipFlagSCModel.initBuffer ( sliceType, qp, (UChar*)INIT_SKIP_FLAG );
[189]	172	#if LGE_ILLUCOMP_B0045
	173	m_cCUICFlagSCModel.initBuffer ( sliceType, qp, (UChar*)INIT_IC_FLAG );
	174	#endif
[56]	175	m_cCUMergeFlagExtSCModel.initBuffer ( sliceType, qp, (UChar*)INIT_MERGE_FLAG_EXT );
	176	m_cCUMergeIdxExtSCModel.initBuffer ( sliceType, qp, (UChar*)INIT_MERGE_IDX_EXT );
[296]	177	#if H3D_IVRP
[56]	178	m_cResPredFlagSCModel.initBuffer ( sliceType, qp, (UChar*)INIT_RES_PRED_FLAG );
[2]	179	#endif
[443]	180	#if QC_ARP_D0177
	181	m_cCUPUARPW.initBuffer ( sliceType, qp, (UChar*)INIT_ARPW );
	182	#endif
[56]	183	m_cCUAlfCtrlFlagSCModel.initBuffer ( sliceType, qp, (UChar*)INIT_ALF_CTRL_FLAG );
	184	m_cCUPartSizeSCModel.initBuffer ( sliceType, qp, (UChar*)INIT_PART_SIZE );
	185	m_cCUAMPSCModel.initBuffer ( sliceType, qp, (UChar*)INIT_CU_AMP_POS );
	186	m_cCUPredModeSCModel.initBuffer ( sliceType, qp, (UChar*)INIT_PRED_MODE );
	187	m_cCUIntraPredSCModel.initBuffer ( sliceType, qp, (UChar*)INIT_INTRA_PRED_MODE );
	188	m_cCUChromaPredSCModel.initBuffer ( sliceType, qp, (UChar*)INIT_CHROMA_PRED_MODE );
	189	m_cCUInterDirSCModel.initBuffer ( sliceType, qp, (UChar*)INIT_INTER_DIR );
	190	m_cCUMvdSCModel.initBuffer ( sliceType, qp, (UChar*)INIT_MVD );
	191	m_cCURefPicSCModel.initBuffer ( sliceType, qp, (UChar*)INIT_REF_PIC );
	192	m_cCUDeltaQpSCModel.initBuffer ( sliceType, qp, (UChar*)INIT_DQP );
	193	m_cCUQtCbfSCModel.initBuffer ( sliceType, qp, (UChar*)INIT_QT_CBF );
	194	m_cCUQtRootCbfSCModel.initBuffer ( sliceType, qp, (UChar*)INIT_QT_ROOT_CBF );
	195	m_cCUSigCoeffGroupSCModel.initBuffer ( sliceType, qp, (UChar*)INIT_SIG_CG_FLAG );
	196	m_cCUSigSCModel.initBuffer ( sliceType, qp, (UChar*)INIT_SIG_FLAG );
	197	m_cCuCtxLastX.initBuffer ( sliceType, qp, (UChar*)INIT_LAST );
	198	m_cCuCtxLastY.initBuffer ( sliceType, qp, (UChar*)INIT_LAST );
	199	m_cCUOneSCModel.initBuffer ( sliceType, qp, (UChar*)INIT_ONE_FLAG );
	200	m_cCUAbsSCModel.initBuffer ( sliceType, qp, (UChar*)INIT_ABS_FLAG );
	201	m_cMVPIdxSCModel.initBuffer ( sliceType, qp, (UChar*)INIT_MVP_IDX );
	202	m_cALFFlagSCModel.initBuffer ( sliceType, qp, (UChar*)INIT_ALF_FLAG );
	203	m_cALFUvlcSCModel.initBuffer ( sliceType, qp, (UChar*)INIT_ALF_UVLC );
	204	m_cALFSvlcSCModel.initBuffer ( sliceType, qp, (UChar*)INIT_ALF_SVLC );
[443]	205	#if LGE_SAO_MIGRATION_D0091
	206	m_cSaoMergeSCModel.initBuffer ( sliceType, qp, (UChar*)INIT_SAO_MERGE_FLAG );
	207	m_cSaoTypeIdxSCModel.initBuffer ( sliceType, qp, (UChar*)INIT_SAO_TYPE_IDX );
	208	#else
[56]	209	m_cSaoFlagSCModel.initBuffer ( sliceType, qp, (UChar*)INIT_SAO_FLAG );
	210	m_cSaoUvlcSCModel.initBuffer ( sliceType, qp, (UChar*)INIT_SAO_UVLC );
	211	m_cSaoSvlcSCModel.initBuffer ( sliceType, qp, (UChar*)INIT_SAO_SVLC );
	212	m_cSaoMergeLeftSCModel.initBuffer ( sliceType, qp, (UChar*)INIT_SAO_MERGE_LEFT_FLAG );
	213	m_cSaoMergeUpSCModel.initBuffer ( sliceType, qp, (UChar*)INIT_SAO_MERGE_UP_FLAG );
	214	m_cSaoTypeIdxSCModel.initBuffer ( sliceType, qp, (UChar*)INIT_SAO_TYPE_IDX );
[443]	215	#endif
[56]	216
	217	m_cCUTransSubdivFlagSCModel.initBuffer ( sliceType, qp, (UChar*)INIT_TRANS_SUBDIV_FLAG );
[189]	218	#if LGE_EDGE_INTRA_A0070
[100]	219	m_cEdgeIntraSCModel.initBuffer ( sliceType, qp, (UChar*)INIT_EDGE_INTRA );
	220	#if LGE_EDGE_INTRA_DELTA_DC
	221	m_cEdgeIntraDeltaDCSCModel.initBuffer ( sliceType, qp, (UChar*)INIT_EDGE_INTRA_DELTA_DC );
	222	#endif
	223	#endif
[56]	224	m_uiLastDQpNonZero = 0;
[5]	225	#if HHI_DMM_WEDGE_INTRA \|\| HHI_DMM_PRED_TEX
[443]	226	#if !PKU_QC_DEPTH_INTRA_UNI_D0195
[56]	227	m_cDmmFlagSCModel.initBuffer ( sliceType, qp, (UChar*)INIT_DMM_FLAG );
	228	m_cDmmModeSCModel.initBuffer ( sliceType, qp, (UChar*)INIT_DMM_MODE );
[443]	229	#endif
[56]	230	m_cDmmDataSCModel.initBuffer ( sliceType, qp, (UChar*)INIT_DMM_DATA );
[2]	231	#endif
[189]	232	#if RWTH_SDC_DLT_B0036
[443]	233	#if !PKU_QC_DEPTH_INTRA_UNI_D0195
[189]	234	m_cSDCFlagSCModel.initBuffer ( sliceType, qp, (UChar*)INIT_SDC_FLAG );
[443]	235	#else
	236	m_cDepthModeModel.initBuffer ( sliceType, qp, (UChar*)INIT_DEPTHMODE_FLAG );
	237	m_cDmmDeltaFlagModel.initBuffer ( sliceType, qp, (UChar*)INIT_DMMDELTA_FLAG );
	238	#endif
[189]	239	m_cSDCResidualFlagSCModel.initBuffer ( sliceType, qp, (UChar*)INIT_SDC_RESIDUAL_FLAG );
	240	m_cSDCResidualSCModel.initBuffer ( sliceType, qp, (UChar*)INIT_SDC_RESIDUAL );
[443]	241	#if !RWTH_SDC_CTX_SIMPL_D0032
[189]	242	m_cSDCResidualSignFlagSCModel.initBuffer ( sliceType, qp, (UChar*)INIT_SDC_SIGN_FLAG );
[443]	243	#endif
[189]	244	m_cSDCPredModeSCModel.initBuffer ( sliceType, qp, (UChar*)INIT_SDC_PRED_MODE );
	245	#endif
[2]	246
	247	// new structure
[56]	248	m_uiLastQp = qp;
[2]	249
	250	m_pcTDecBinIf->start();
	251	}
	252
[56]	253	/** The function does the following: Read out terminate bit. Flush CABAC. Byte-align for next tile.
	254	* Intialize CABAC states. Start CABAC.
	255	*/
	256	Void TDecSbac::updateContextTables( SliceType eSliceType, Int iQp )
	257	{
	258	UInt uiBit;
	259	m_pcTDecBinIf->decodeBinTrm(uiBit);
	260	m_pcTDecBinIf->finish();
	261	#if !OL_FLUSH_ALIGN
	262	// Account for misaligned CABAC.
	263	Int iCABACReadAhead = m_pcTDecBinIf->getBitsReadAhead();
	264	iCABACReadAhead--;
	265	Int iStreamBits = 8-m_pcBitstream->getNumBitsUntilByteAligned();
	266	if (iCABACReadAhead >= iStreamBits)
	267	{
	268	// Misaligned CABAC has read into the 1st byte of the next tile.
	269	// Back up a byte prior to alignment.
	270	m_pcBitstream->backupByte();
	271	}
	272	#endif
	273	m_pcBitstream->readOutTrailingBits();
	274	m_cCUSplitFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_SPLIT_FLAG );
	275	m_cCUSkipFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_SKIP_FLAG );
[189]	276	#if LGE_ILLUCOMP_B0045
	277	m_cCUICFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_IC_FLAG );
	278	#endif
[56]	279	m_cCUMergeFlagExtSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_MERGE_FLAG_EXT );
	280	m_cCUMergeIdxExtSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_MERGE_IDX_EXT );
[296]	281	#if H3D_IVRP
[56]	282	m_cResPredFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_RES_PRED_FLAG );
	283	#endif
[443]	284	#if QC_ARP_D0177
	285	m_cCUPUARPW.initBuffer ( eSliceType, iQp, (UChar*)INIT_ARPW );
	286	#endif
[56]	287	m_cCUAlfCtrlFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_ALF_CTRL_FLAG );
	288	m_cCUPartSizeSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_PART_SIZE );
	289	m_cCUAMPSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_CU_AMP_POS );
	290	m_cCUPredModeSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_PRED_MODE );
	291	m_cCUIntraPredSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_INTRA_PRED_MODE );
	292	m_cCUChromaPredSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_CHROMA_PRED_MODE );
	293	m_cCUInterDirSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_INTER_DIR );
	294	m_cCUMvdSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_MVD );
	295	m_cCURefPicSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_REF_PIC );
	296	m_cCUDeltaQpSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_DQP );
	297	m_cCUQtCbfSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_QT_CBF );
	298	m_cCUQtRootCbfSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_QT_ROOT_CBF );
	299	m_cCUSigCoeffGroupSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_SIG_CG_FLAG );
	300	m_cCUSigSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_SIG_FLAG );
	301	m_cCuCtxLastX.initBuffer ( eSliceType, iQp, (UChar*)INIT_LAST );
	302	m_cCuCtxLastY.initBuffer ( eSliceType, iQp, (UChar*)INIT_LAST );
	303	m_cCUOneSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_ONE_FLAG );
	304	m_cCUAbsSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_ABS_FLAG );
	305	m_cMVPIdxSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_MVP_IDX );
	306	m_cALFFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_ALF_FLAG );
	307	m_cALFUvlcSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_ALF_UVLC );
	308	m_cALFSvlcSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_ALF_SVLC );
[443]	309	#if LGE_SAO_MIGRATION_D0091
	310	m_cSaoMergeSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_SAO_MERGE_FLAG );
	311	m_cSaoTypeIdxSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_SAO_TYPE_IDX );
	312	#else
[56]	313	m_cSaoFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_SAO_FLAG );
	314	m_cSaoUvlcSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_SAO_UVLC );
	315	m_cSaoSvlcSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_SAO_SVLC );
	316	m_cSaoMergeLeftSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_SAO_MERGE_LEFT_FLAG );
	317	m_cSaoMergeUpSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_SAO_MERGE_UP_FLAG );
	318	m_cSaoTypeIdxSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_SAO_TYPE_IDX );
[443]	319	#endif
[56]	320	m_cCUTransSubdivFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_TRANS_SUBDIV_FLAG );
	321	#if HHI_DMM_WEDGE_INTRA \|\| HHI_DMM_PRED_TEX
[443]	322	#if !PKU_QC_DEPTH_INTRA_UNI_D0195
[56]	323	m_cDmmFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_DMM_FLAG );
	324	m_cDmmModeSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_DMM_MODE );
[443]	325	#endif
[56]	326	m_cDmmDataSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_DMM_DATA );
	327	#endif
[189]	328	#if RWTH_SDC_DLT_B0036
[443]	329	#if !PKU_QC_DEPTH_INTRA_UNI_D0195
[189]	330	m_cSDCFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_SDC_FLAG );
[443]	331	#else
	332	m_cDepthModeModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_DEPTHMODE_FLAG );
	333	m_cDmmDeltaFlagModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_DMMDELTA_FLAG );
	334	#endif
[189]	335	m_cSDCResidualFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_SDC_RESIDUAL_FLAG );
	336	m_cSDCResidualSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_SDC_RESIDUAL );
[443]	337	#if !RWTH_SDC_CTX_SIMPL_D0032
[189]	338	m_cSDCResidualSignFlagSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_SDC_SIGN_FLAG );
[443]	339	#endif
[189]	340	m_cSDCPredModeSCModel.initBuffer ( eSliceType, iQp, (UChar*)INIT_SDC_PRED_MODE );
	341	#endif
[56]	342
	343	m_pcTDecBinIf->start();
	344	}
	345
	346	Void TDecSbac::readTileMarker( UInt& uiTileIdx, UInt uiBitsUsed )
	347	{
	348	UInt uiSymbol;
	349	uiTileIdx = 0;
	350	for (Int iShift=uiBitsUsed-1; iShift>=0; iShift--)
	351	{
	352	m_pcTDecBinIf->decodeBinEP ( uiSymbol );
	353	if (uiSymbol)
	354	{
	355	uiTileIdx \|= (1<<iShift);
	356	}
	357	}
	358	}
	359
[2]	360	Void TDecSbac::parseTerminatingBit( UInt& ruiBit )
	361	{
	362	m_pcTDecBinIf->decodeBinTrm( ruiBit );
	363	}
	364
	365
	366	Void TDecSbac::xReadUnaryMaxSymbol( UInt& ruiSymbol, ContextModel* pcSCModel, Int iOffset, UInt uiMaxSymbol )
	367	{
	368	if (uiMaxSymbol == 0)
	369	{
	370	ruiSymbol = 0;
	371	return;
	372	}
	373
	374	m_pcTDecBinIf->decodeBin( ruiSymbol, pcSCModel[0] );
	375
	376	if( ruiSymbol == 0 \|\| uiMaxSymbol == 1 )
	377	{
	378	return;
	379	}
	380
	381	UInt uiSymbol = 0;
	382	UInt uiCont;
	383
	384	do
	385	{
	386	m_pcTDecBinIf->decodeBin( uiCont, pcSCModel[ iOffset ] );
	387	uiSymbol++;
	388	}
	389	while( uiCont && ( uiSymbol < uiMaxSymbol - 1 ) );
	390
	391	if( uiCont && ( uiSymbol == uiMaxSymbol - 1 ) )
	392	{
	393	uiSymbol++;
	394	}
	395
	396	ruiSymbol = uiSymbol;
	397	}
	398
	399	Void TDecSbac::xReadEpExGolomb( UInt& ruiSymbol, UInt uiCount )
	400	{
	401	UInt uiSymbol = 0;
	402	UInt uiBit = 1;
	403
	404	while( uiBit )
	405	{
	406	m_pcTDecBinIf->decodeBinEP( uiBit );
	407	uiSymbol += uiBit << uiCount++;
	408	}
	409
[56]	410	if ( --uiCount )
[2]	411	{
[56]	412	UInt bins;
	413	m_pcTDecBinIf->decodeBinsEP( bins, uiCount );
	414	uiSymbol += bins;
[2]	415	}
	416
	417	ruiSymbol = uiSymbol;
	418	}
	419
	420	Void TDecSbac::xReadUnarySymbol( UInt& ruiSymbol, ContextModel* pcSCModel, Int iOffset )
	421	{
	422	m_pcTDecBinIf->decodeBin( ruiSymbol, pcSCModel[0] );
	423
	424	if( !ruiSymbol )
	425	{
	426	return;
	427	}
	428
	429	UInt uiSymbol = 0;
	430	UInt uiCont;
	431
	432	do
	433	{
	434	m_pcTDecBinIf->decodeBin( uiCont, pcSCModel[ iOffset ] );
	435	uiSymbol++;
	436	}
	437	while( uiCont );
	438
	439	ruiSymbol = uiSymbol;
	440	}
	441
	442	/** Parsing of coeff_abs_level_minus3
	443	* \param ruiSymbol reference to coeff_abs_level_minus3
	444	* \param ruiGoRiceParam reference to Rice parameter
	445	* \returns Void
	446	*/
	447	Void TDecSbac::xReadGoRiceExGolomb( UInt &ruiSymbol, UInt &ruiGoRiceParam )
	448	{
	449	Bool bExGolomb = false;
	450	UInt uiCodeWord = 0;
	451	UInt uiQuotient = 0;
	452	UInt uiRemainder = 0;
	453	UInt uiMaxVlc = g_auiGoRiceRange[ ruiGoRiceParam ];
	454	UInt uiMaxPreLen = g_auiGoRicePrefixLen[ ruiGoRiceParam ];
	455
	456	do
	457	{
	458	uiQuotient++;
	459	m_pcTDecBinIf->decodeBinEP( uiCodeWord );
	460	}
	461	while( uiCodeWord && uiQuotient < uiMaxPreLen );
	462
	463	uiCodeWord = 1 - uiCodeWord;
	464	uiQuotient -= uiCodeWord;
	465
[56]	466	if ( ruiGoRiceParam > 0 )
[2]	467	{
[56]	468	m_pcTDecBinIf->decodeBinsEP( uiRemainder, ruiGoRiceParam );
[2]	469	}
	470
	471	ruiSymbol = uiRemainder + ( uiQuotient << ruiGoRiceParam );
	472	bExGolomb = ruiSymbol == ( uiMaxVlc + 1 );
	473
	474	if( bExGolomb )
	475	{
	476	xReadEpExGolomb( uiCodeWord, 0 );
	477	ruiSymbol += uiCodeWord;
	478	}
	479
[56]	480	ruiGoRiceParam = g_aauiGoRiceUpdate[ ruiGoRiceParam ][ min<UInt>( ruiSymbol, 23 ) ];
[2]	481
	482	return;
	483	}
[56]	484
	485
	486	/** Parse I_PCM information.
	487	* \param pcCU
	488	* \param uiAbsPartIdx
	489	* \param uiDepth
	490	* \returns Void
	491	*
	492	* If I_PCM flag indicates that the CU is I_PCM, parse its PCM alignment bits and codes.
	493	*/
	494	Void TDecSbac::parseIPCMInfo ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
[2]	495	{
	496	UInt uiSymbol;
[56]	497	Int numSubseqIPCM = 0;
	498	Bool readPCMSampleFlag = false;
	499
	500	if(pcCU->getNumSucIPCM() > 0)
[2]	501	{
[56]	502	readPCMSampleFlag = true;
[2]	503	}
[56]	504	else
	505	{
	506	m_pcTDecBinIf->decodeBinTrm(uiSymbol);
[2]	507
[56]	508	if (uiSymbol)
	509	{
	510	readPCMSampleFlag = true;
	511	m_pcTDecBinIf->decodeNumSubseqIPCM(numSubseqIPCM);
	512	pcCU->setNumSucIPCM(numSubseqIPCM + 1);
	513	m_pcTDecBinIf->decodePCMAlignBits();
	514	}
[2]	515	}
	516
[56]	517	if (readPCMSampleFlag == true)
[2]	518	{
[56]	519	Bool bIpcmFlag = true;
	520
[2]	521
[56]	522	pcCU->setPartSizeSubParts ( SIZE_2Nx2N, uiAbsPartIdx, uiDepth );
	523	pcCU->setSizeSubParts ( g_uiMaxCUWidth>>uiDepth, g_uiMaxCUHeight>>uiDepth, uiAbsPartIdx, uiDepth );
	524	pcCU->setIPCMFlagSubParts ( bIpcmFlag, uiAbsPartIdx, uiDepth );
[2]	525
[56]	526	UInt uiMinCoeffSize = pcCU->getPic()->getMinCUWidth()*pcCU->getPic()->getMinCUHeight();
	527	UInt uiLumaOffset = uiMinCoeffSize*uiAbsPartIdx;
	528	UInt uiChromaOffset = uiLumaOffset>>2;
	529
	530	Pel* piPCMSample;
	531	UInt uiWidth;
	532	UInt uiHeight;
	533	UInt uiSampleBits;
	534	UInt uiX, uiY;
	535
	536	piPCMSample = pcCU->getPCMSampleY() + uiLumaOffset;
	537	uiWidth = pcCU->getWidth(uiAbsPartIdx);
	538	uiHeight = pcCU->getHeight(uiAbsPartIdx);
	539	uiSampleBits = pcCU->getSlice()->getSPS()->getPCMBitDepthLuma();
	540
	541	for(uiY = 0; uiY < uiHeight; uiY++)
	542	{
	543	for(uiX = 0; uiX < uiWidth; uiX++)
	544	{
	545	UInt uiSample;
	546	m_pcTDecBinIf->xReadPCMCode(uiSampleBits, uiSample);
	547	piPCMSample[uiX] = uiSample;
	548	}
	549	piPCMSample += uiWidth;
	550	}
	551
	552	piPCMSample = pcCU->getPCMSampleCb() + uiChromaOffset;
	553	uiWidth = pcCU->getWidth(uiAbsPartIdx)/2;
	554	uiHeight = pcCU->getHeight(uiAbsPartIdx)/2;
	555	uiSampleBits = pcCU->getSlice()->getSPS()->getPCMBitDepthChroma();
	556
	557	for(uiY = 0; uiY < uiHeight; uiY++)
	558	{
	559	for(uiX = 0; uiX < uiWidth; uiX++)
	560	{
	561	UInt uiSample;
	562	m_pcTDecBinIf->xReadPCMCode(uiSampleBits, uiSample);
	563	piPCMSample[uiX] = uiSample;
	564	}
	565	piPCMSample += uiWidth;
	566	}
	567
	568	piPCMSample = pcCU->getPCMSampleCr() + uiChromaOffset;
	569	uiWidth = pcCU->getWidth(uiAbsPartIdx)/2;
	570	uiHeight = pcCU->getHeight(uiAbsPartIdx)/2;
	571	uiSampleBits = pcCU->getSlice()->getSPS()->getPCMBitDepthChroma();
	572
	573	for(uiY = 0; uiY < uiHeight; uiY++)
	574	{
	575	for(uiX = 0; uiX < uiWidth; uiX++)
	576	{
	577	UInt uiSample;
	578	m_pcTDecBinIf->xReadPCMCode(uiSampleBits, uiSample);
	579	piPCMSample[uiX] = uiSample;
	580	}
	581	piPCMSample += uiWidth;
	582	}
	583
	584	pcCU->setNumSucIPCM( pcCU->getNumSucIPCM() - 1);
	585	if(pcCU->getNumSucIPCM() == 0)
	586	{
	587	m_pcTDecBinIf->resetBac();
	588	}
[2]	589	}
	590	}
	591
	592	/** parse skip flag
	593	* \param pcCU
	594	* \param uiAbsPartIdx
	595	* \param uiDepth
	596	* \returns Void
	597	*/
	598	Void TDecSbac::parseSkipFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
	599	{
	600	if( pcCU->getSlice()->isIntra() )
	601	{
	602	return;
	603	}
	604
	605	UInt uiSymbol = 0;
	606	UInt uiCtxSkip = pcCU->getCtxSkipFlag( uiAbsPartIdx );
	607	m_pcTDecBinIf->decodeBin( uiSymbol, m_cCUSkipFlagSCModel.get( 0, 0, uiCtxSkip ) );
[56]	608	DTRACE_CABAC_VL( g_nSymbolCounter++ );
[2]	609	DTRACE_CABAC_T( "\tSkipFlag" );
	610	DTRACE_CABAC_T( "\tuiCtxSkip: ");
	611	DTRACE_CABAC_V( uiCtxSkip );
	612	DTRACE_CABAC_T( "\tuiSymbol: ");
	613	DTRACE_CABAC_V( uiSymbol );
	614	DTRACE_CABAC_T( "\n");
	615
	616	if( uiSymbol )
	617	{
	618	pcCU->setPredModeSubParts( MODE_SKIP, uiAbsPartIdx, uiDepth );
	619	pcCU->setPartSizeSubParts( SIZE_2Nx2N, uiAbsPartIdx, uiDepth );
	620	pcCU->setSizeSubParts( g_uiMaxCUWidth>>uiDepth, g_uiMaxCUHeight>>uiDepth, uiAbsPartIdx, uiDepth );
	621	pcCU->setMergeFlagSubParts( true , uiAbsPartIdx, 0, uiDepth );
	622	}
	623	}
	624
[189]	625	#if LGE_ILLUCOMP_B0045
	626	/** parse illumination compensation flag
	627	* \param pcCU
	628	* \param uiAbsPartIdx
	629	* \param uiDepth
	630	* \returns Void
	631	*/
	632	Void TDecSbac::parseICFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
	633	{
	634	UInt uiSymbol = 0;
	635	UInt uiCtxIC = pcCU->getCtxICFlag( uiAbsPartIdx );
	636	m_pcTDecBinIf->decodeBin( uiSymbol, m_cCUICFlagSCModel.get( 0, 0, uiCtxIC ) );
	637	DTRACE_CABAC_VL( g_nSymbolCounter++ );
	638	DTRACE_CABAC_T( "\tICFlag" );
	639	DTRACE_CABAC_T( "\tuiCtxIC: ");
	640	DTRACE_CABAC_V( uiCtxIC );
	641	DTRACE_CABAC_T( "\tuiSymbol: ");
	642	DTRACE_CABAC_V( uiSymbol );
	643	DTRACE_CABAC_T( "\n");
	644
	645	pcCU->setICFlagSubParts( uiSymbol ? true : false , uiAbsPartIdx, 0, uiDepth );
	646	}
	647	#endif
	648
	649
[2]	650	/** parse merge flag
	651	* \param pcCU
	652	* \param uiAbsPartIdx
	653	* \param uiDepth
	654	* \param uiPUIdx
	655	* \returns Void
	656	*/
	657	Void TDecSbac::parseMergeFlag ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, UInt uiPUIdx )
	658	{
	659	UInt uiSymbol;
[56]	660	m_pcTDecBinIf->decodeBin( uiSymbol, *m_cCUMergeFlagExtSCModel.get( 0 ) );
[2]	661	pcCU->setMergeFlagSubParts( uiSymbol ? true : false, uiAbsPartIdx, uiPUIdx, uiDepth );
	662
[56]	663	DTRACE_CABAC_VL( g_nSymbolCounter++ );
[2]	664	DTRACE_CABAC_T( "\tMergeFlag: " );
	665	DTRACE_CABAC_V( uiSymbol );
	666	DTRACE_CABAC_T( "\tAddress: " );
	667	DTRACE_CABAC_V( pcCU->getAddr() );
	668	DTRACE_CABAC_T( "\tuiAbsPartIdx: " );
	669	DTRACE_CABAC_V( uiAbsPartIdx );
	670	DTRACE_CABAC_T( "\n" );
	671	}
	672
[56]	673	Void TDecSbac::parseMergeIndex ( TComDataCU* pcCU, UInt& ruiMergeIndex, UInt uiAbsPartIdx, UInt uiDepth )
[2]	674	{
[56]	675	UInt uiNumCand = MRG_MAX_NUM_CANDS;
	676	UInt uiUnaryIdx = 0;
	677	uiNumCand = pcCU->getSlice()->getMaxNumMergeCand();
[5]	678	#if HHI_MPI
[2]	679	const Bool bMVIAvailable = pcCU->getSlice()->getSPS()->getUseMVI() && pcCU->getSlice()->getSliceType() != I_SLICE;
[56]	680	const UInt uiMviMergePos = bMVIAvailable ? HHI_MPI_MERGE_POS : uiNumCand;
[2]	681	#endif
[56]	682	if ( uiNumCand > 1 )
[2]	683	{
[56]	684	for( ; uiUnaryIdx < uiNumCand - 1; ++uiUnaryIdx )
[2]	685	{
[56]	686	UInt uiSymbol = 0;
	687	if ( uiUnaryIdx==0 )
[2]	688	{
[56]	689	m_pcTDecBinIf->decodeBin( uiSymbol, m_cCUMergeIdxExtSCModel.get( 0, 0, 0 ) );
[2]	690	}
[56]	691	else
	692	{
	693	m_pcTDecBinIf->decodeBinEP( uiSymbol );
	694	}
	695	if( uiSymbol == 0 )
[2]	696	{
[56]	697	break;
[2]	698	}
	699	}
	700	}
	701	ruiMergeIndex = uiUnaryIdx;
	702
[56]	703	DTRACE_CABAC_VL( g_nSymbolCounter++ )
	704	DTRACE_CABAC_T( "\tparseMergeIndex()" )
	705	DTRACE_CABAC_T( "\tuiMRGIdx= " )
	706	DTRACE_CABAC_V( ruiMergeIndex )
	707	DTRACE_CABAC_T( "\n" )
[5]	708	#if HHI_MPI
[2]	709	if( ruiMergeIndex > uiMviMergePos )
	710	{
[56]	711	assert( bMVIAvailable );
[2]	712	ruiMergeIndex--;
	713	}
	714	else if( ruiMergeIndex == uiMviMergePos )
	715	{
[56]	716	assert( bMVIAvailable );
[2]	717	pcCU->setTextureModeDepthSubParts( uiDepth, uiAbsPartIdx, uiDepth );
	718	}
	719	#endif
	720	}
	721
[296]	722	#if H3D_IVRP
[56]	723	Void
[2]	724	TDecSbac::parseResPredFlag( TComDataCU* pcCU, Bool& rbResPredFlag, UInt uiAbsPartIdx, UInt uiDepth )
	725	{
[56]	726	UInt uiCtx = pcCU->getCtxResPredFlag( uiAbsPartIdx );
[2]	727	UInt uiSymbol = 0;
	728	m_pcTDecBinIf->decodeBin( uiSymbol, m_cResPredFlagSCModel.get( 0, 0, uiCtx ) );
	729	rbResPredFlag = ( uiSymbol != 0 );
	730	}
[56]	731	#endif
[2]	732
[296]	733	#if H3D_IVMP
[56]	734	Void TDecSbac::parseMVPIdx ( Int& riMVPIdx, Int iNumAMVPCands )
[2]	735	{
	736	UInt uiSymbol;
[56]	737	xReadUnaryMaxSymbol(uiSymbol, m_cMVPIdxSCModel.get(0), 1, iNumAMVPCands-1);
[2]	738	riMVPIdx = uiSymbol;
	739	}
[56]	740	#else
	741	Void TDecSbac::parseMVPIdx ( Int& riMVPIdx )
	742	{
	743	UInt uiSymbol;
	744	xReadUnaryMaxSymbol(uiSymbol, m_cMVPIdxSCModel.get(0), 1, AMVP_MAX_NUM_CANDS-1);
	745	riMVPIdx = uiSymbol;
	746	}
	747	#endif
[2]	748
	749	Void TDecSbac::parseSplitFlag ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
	750	{
	751	if( uiDepth == g_uiMaxCUDepth - g_uiAddCUDepth )
	752	{
	753	pcCU->setDepthSubParts( uiDepth, uiAbsPartIdx );
	754	return;
	755	}
	756
	757	UInt uiSymbol;
[189]	758
[332]	759	#if H3D_QTL
[189]	760	Bool bParseSplitFlag = true;
	761
	762	TComSPS *sps = pcCU->getPic()->getSlice(0)->getSPS();
	763	TComPic *pcTexture = pcCU->getSlice()->getTexturePic();
	764	Bool bDepthMapDetect = (pcTexture != NULL);
	765	Bool bIntraSliceDetect = (pcCU->getSlice()->getSliceType() == I_SLICE);
	766
[296]	767	Bool rapPic = (pcCU->getSlice()->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR \|\| pcCU->getSlice()->getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA);
	768	if(bDepthMapDetect && !bIntraSliceDetect && !rapPic && sps->getUseQTLPC())
[189]	769	{
	770	TComDataCU *pcTextureCU = pcTexture->getCU(pcCU->getAddr());
	771	assert(pcTextureCU->getDepth(uiAbsPartIdx) >= uiDepth);
	772	bParseSplitFlag = (pcTextureCU->getDepth(uiAbsPartIdx) > uiDepth);
	773	}
	774
	775	if(bParseSplitFlag)
	776	{
	777	#endif
	778	m_pcTDecBinIf->decodeBin( uiSymbol, m_cCUSplitFlagSCModel.get( 0, 0, pcCU->getCtxSplitFlag( uiAbsPartIdx, uiDepth ) ) );
	779	DTRACE_CABAC_VL( g_nSymbolCounter++ )
	780	DTRACE_CABAC_T( "\tSplitFlag\n" )
[332]	781	#if H3D_QTL
[189]	782	}
	783	else
	784	uiSymbol = 0;
	785	#endif
	786
[2]	787	pcCU->setDepthSubParts( uiDepth + uiSymbol, uiAbsPartIdx );
	788
	789	return;
	790	}
	791
	792	/** parse partition size
	793	* \param pcCU
	794	* \param uiAbsPartIdx
	795	* \param uiDepth
	796	* \returns Void
	797	*/
	798	Void TDecSbac::parsePartSize( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
	799	{
	800	UInt uiSymbol, uiMode = 0;
	801	PartSize eMode;
[189]	802
[332]	803	#if H3D_QTL
[189]	804	Bool bParsePartSize = true;
	805	TComSPS *sps = pcCU->getPic()->getSlice(0)->getSPS();
	806	TComPic *pcTexture = pcCU->getSlice()->getTexturePic();
	807	Bool bDepthMapDetect = (pcTexture != NULL);
	808	Bool bIntraSliceDetect = (pcCU->getSlice()->getSliceType() == I_SLICE);
	809
[296]	810	Bool rapPic = (pcCU->getSlice()->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR \|\| pcCU->getSlice()->getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA);
	811	if(bDepthMapDetect && !bIntraSliceDetect && !rapPic && sps->getUseQTLPC())
[189]	812	{
	813	TComDataCU *pcTextureCU = pcTexture->getCU(pcCU->getAddr());
	814	assert(pcTextureCU->getDepth(uiAbsPartIdx) >= uiDepth);
	815	if (pcTextureCU->getDepth(uiAbsPartIdx) == uiDepth && pcTextureCU->getPartitionSize( uiAbsPartIdx ) != SIZE_NxN)
	816	{
	817	bParsePartSize = false;
	818	eMode = SIZE_2Nx2N;
	819	}
	820	}
	821	#endif
[2]	822
	823	if ( pcCU->isIntra( uiAbsPartIdx ) )
	824	{
[332]	825	#if H3D_QTL
[189]	826	if(bParsePartSize)
[2]	827	{
[189]	828	#endif
	829	uiSymbol = 1;
	830	if( uiDepth == g_uiMaxCUDepth - g_uiAddCUDepth )
	831	{
	832	m_pcTDecBinIf->decodeBin( uiSymbol, m_cCUPartSizeSCModel.get( 0, 0, 0) );
	833	}
	834	eMode = uiSymbol ? SIZE_2Nx2N : SIZE_NxN;
[332]	835	#if H3D_QTL
[2]	836	}
[189]	837	#endif
[56]	838	UInt uiTrLevel = 0;
	839	UInt uiWidthInBit = g_aucConvertToBit[pcCU->getWidth(uiAbsPartIdx)]+2;
	840	UInt uiTrSizeInBit = g_aucConvertToBit[pcCU->getSlice()->getSPS()->getMaxTrSize()]+2;
	841	uiTrLevel = uiWidthInBit >= uiTrSizeInBit ? uiWidthInBit - uiTrSizeInBit : 0;
	842	if( eMode == SIZE_NxN )
	843	{
	844	pcCU->setTrIdxSubParts( 1+uiTrLevel, uiAbsPartIdx, uiDepth );
	845	}
	846	else
	847	{
	848	pcCU->setTrIdxSubParts( uiTrLevel, uiAbsPartIdx, uiDepth );
	849	}
[2]	850	}
	851	else
	852	{
[332]	853	#if H3D_QTL
[189]	854	if(bParsePartSize)
[2]	855	{
[189]	856	#endif
	857	UInt uiMaxNumBits = 2;
	858	if( uiDepth == g_uiMaxCUDepth - g_uiAddCUDepth && !( pcCU->getSlice()->getSPS()->getDisInter4x4() && (g_uiMaxCUWidth>>uiDepth) == 8 && (g_uiMaxCUHeight>>uiDepth) == 8 ) )
[2]	859	{
[189]	860	uiMaxNumBits ++;
[2]	861	}
[189]	862	for ( UInt ui = 0; ui < uiMaxNumBits; ui++ )
[56]	863	{
[189]	864	m_pcTDecBinIf->decodeBin( uiSymbol, m_cCUPartSizeSCModel.get( 0, 0, ui) );
	865	if ( uiSymbol )
	866	{
	867	break;
	868	}
	869	uiMode++;
	870	}
	871	eMode = (PartSize) uiMode;
	872	if ( pcCU->getSlice()->getSPS()->getAMPAcc( uiDepth ) )
	873	{
	874	if (eMode == SIZE_2NxN)
	875	{
	876	m_pcTDecBinIf->decodeBin(uiSymbol, m_cCUAMPSCModel.get( 0, 0, 0 ));
	877	if (uiSymbol == 0)
	878	{
	879	m_pcTDecBinIf->decodeBinEP(uiSymbol);
	880	eMode = (uiSymbol == 0? SIZE_2NxnU : SIZE_2NxnD);
	881	}
[56]	882	}
[189]	883	else if (eMode == SIZE_Nx2N)
	884	{
	885	m_pcTDecBinIf->decodeBin(uiSymbol, m_cCUAMPSCModel.get( 0, 0, 0 ));
	886	if (uiSymbol == 0)
	887	{
	888	m_pcTDecBinIf->decodeBinEP(uiSymbol);
	889	eMode = (uiSymbol == 0? SIZE_nLx2N : SIZE_nRx2N);
	890	}
[2]	891	}
	892	}
[332]	893	#if H3D_QTL
[2]	894	}
[189]	895	#endif
[2]	896	}
	897	pcCU->setPartSizeSubParts( eMode, uiAbsPartIdx, uiDepth );
	898	pcCU->setSizeSubParts( g_uiMaxCUWidth>>uiDepth, g_uiMaxCUHeight>>uiDepth, uiAbsPartIdx, uiDepth );
	899	}
	900
	901	/** parse prediction mode
	902	* \param pcCU
	903	* \param uiAbsPartIdx
	904	* \param uiDepth
	905	* \returns Void
	906	*/
	907	Void TDecSbac::parsePredMode( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
	908	{
	909	if( pcCU->getSlice()->isIntra() )
	910	{
	911	pcCU->setPredModeSubParts( MODE_INTRA, uiAbsPartIdx, uiDepth );
	912	return;
	913	}
	914
	915	UInt uiSymbol;
	916	Int iPredMode = MODE_INTER;
[56]	917	m_pcTDecBinIf->decodeBin( uiSymbol, m_cCUPredModeSCModel.get( 0, 0, 0 ) );
[2]	918	iPredMode += uiSymbol;
	919	pcCU->setPredModeSubParts( (PredMode)iPredMode, uiAbsPartIdx, uiDepth );
	920	}
[443]	921	#if PKU_QC_DEPTH_INTRA_UNI_D0195
	922	Void TDecSbac::parseDepthIntraMode ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
	923	{
	924	UInt uiPuIdx = ( pcCU->getWidth(uiAbsPartIdx) == 64 )? 2 : ( ( pcCU->getPartitionSize(uiAbsPartIdx) == SIZE_NxN && pcCU->getWidth(uiAbsPartIdx) == 8 )? 0 : 1);
	925	UInt uiDir = 0;
	926	Bool bSDCFlag = 0;
	927	UInt uiSymbol = 1;
	928	UInt uiCode = 0 ;
	929	UInt uiBinNum = 0;
	930	UInt uiCtxDepthMode = 0;
	931	if ( uiPuIdx ==2 )
	932	{
	933	while(uiBinNum<2 && uiSymbol)
	934	{
	935	uiCtxDepthMode = uiPuIdx*3 + uiBinNum;
	936	m_pcTDecBinIf->decodeBin(uiSymbol,m_cDepthModeModel.get(0,0,uiCtxDepthMode));
	937	uiCode = (uiCode<<1)+uiSymbol;
	938	uiBinNum++;
	939	}
	940	if (uiCode == 0) { uiDir = PLANAR_IDX; bSDCFlag = 1;}
	941	else if (uiCode == 2) { uiDir = 0; bSDCFlag = 0;}
	942	else if (uiCode == 3) { uiDir = DC_IDX; bSDCFlag = 1;}
	943	}
	944	else if ( uiPuIdx ==0 )
	945	{
	946	while(uiBinNum<3 && uiSymbol)
	947	{
	948	uiCtxDepthMode = uiPuIdx*3 + ( uiBinNum >= 2? 2 : uiBinNum );
	949	m_pcTDecBinIf->decodeBin(uiSymbol,m_cDepthModeModel.get(0,0,uiCtxDepthMode));
	950	uiCode = (uiCode<<1)+uiSymbol;
	951	uiBinNum++;
	952	}
	953	if (uiCode == 0) { uiDir = 0; bSDCFlag = 0;}
	954	else if (uiCode == 2) { uiDir = DMM_WEDGE_FULL_IDX; bSDCFlag = 0;}
	955	else if (uiCode == 6) { uiDir = DMM_WEDGE_PREDTEX_IDX; bSDCFlag = 0;}
	956	else if (uiCode == 7) { uiDir = EDGE_INTRA_IDX; bSDCFlag = 0;}
	957	}
	958	else
	959	{
	960	uiCtxDepthMode = uiPuIdx*3 ;
	961	m_pcTDecBinIf->decodeBin(uiSymbol,m_cDepthModeModel.get(0,0,uiCtxDepthMode));
	962	uiCode = (uiCode<<1)+uiSymbol;
	963	if (!uiSymbol)
	964	{
	965	uiCtxDepthMode = uiPuIdx*3 + 1;
	966	m_pcTDecBinIf->decodeBin(uiSymbol,m_cDepthModeModel.get(0,0,uiCtxDepthMode));
	967	uiCode = (uiCode<<1)+uiSymbol;
	968	if (uiSymbol)
	969	{
	970	uiCtxDepthMode = uiPuIdx*3 + 2;
	971	m_pcTDecBinIf->decodeBin(uiSymbol,m_cDepthModeModel.get(0,0,uiCtxDepthMode));
	972	uiCode = (uiCode<<1)+uiSymbol;
	973	}
	974	}
	975	else
	976	{
	977	uiCtxDepthMode = uiPuIdx*3 + 1;
	978	m_pcTDecBinIf->decodeBin(uiSymbol,m_cDepthModeModel.get(0,0,uiCtxDepthMode));
	979	uiCode = (uiCode<<1)+uiSymbol;
	980	if (!uiSymbol)
	981	{
	982	uiCtxDepthMode = uiPuIdx*3 + 2;
	983	m_pcTDecBinIf->decodeBin(uiSymbol,m_cDepthModeModel.get(0,0,uiCtxDepthMode));
	984	uiCode = (uiCode<<1)+uiSymbol;
	985	}
	986	else
	987	{
	988	uiBinNum = 0;
	989	while( uiSymbol && uiBinNum<3 )
	990	{
	991	uiCtxDepthMode = uiPuIdx*3 + 2;
	992	m_pcTDecBinIf->decodeBin(uiSymbol,m_cDepthModeModel.get(0,0,uiCtxDepthMode));
	993	uiCode = (uiCode<<1)+uiSymbol;
	994	uiBinNum++;
	995	}
	996	}
	997	}
	998	if (uiCode == 0) { uiDir = PLANAR_IDX; bSDCFlag = 1;}
	999	else if (uiCode == 2) { uiDir = 5; bSDCFlag = 0;}
	1000	else if (uiCode == 3) { uiDir = DMM_WEDGE_FULL_IDX; bSDCFlag = 1;}
	1001	else if (uiCode == 4) { uiDir = DMM_WEDGE_FULL_IDX; bSDCFlag = 0;}
	1002	else if (uiCode == 5) { uiDir = DMM_CONTOUR_PREDTEX_IDX; bSDCFlag = 0;}
	1003	else if (uiCode == 6) { uiDir = DMM_WEDGE_PREDTEX_IDX; bSDCFlag = 0;}
	1004	else if (uiCode == 14) { uiDir = DC_IDX; bSDCFlag = 1;}
	1005	else if (uiCode == 31) { uiDir = DMM_WEDGE_PREDDIR_IDX; bSDCFlag = 0;}
	1006	else if (uiCode == 30) { uiDir = EDGE_INTRA_IDX; bSDCFlag = 0;}
	1007	}
	1008	pcCU->setLumaIntraDirSubParts( (UChar)uiDir, uiAbsPartIdx, uiDepth );
	1009	pcCU->setSDCFlagSubParts(bSDCFlag, uiAbsPartIdx, 0, uiDepth);
	1010	}
	1011	Void TDecSbac::parseDepthModelingTable ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
	1012	{
	1013	parseDepthIntraMode(pcCU,uiAbsPartIdx,uiDepth);
[56]	1014
[443]	1015	UInt uiDir = pcCU->getLumaIntraDir(uiAbsPartIdx);
	1016	Bool bSdcFlag = pcCU->getSDCAvailable(uiAbsPartIdx) && pcCU->getSDCFlag(uiAbsPartIdx);
	1017	Bool bDmmFlag = (uiDir >= NUM_INTRA_MODE && uiDir < EDGE_INTRA_IDX &&(!bSdcFlag))? 1:0;
	1018	if (uiDir >= NUM_INTRA_MODE && uiDir < EDGE_INTRA_IDX)//DMM modes and SDC DMM1
	1019	{
	1020	if( uiDir == DMM_WEDGE_FULL_IDX ) { xParseWedgeFullInfo ( pcCU, uiAbsPartIdx, uiDepth ); }
	1021	else if( uiDir == DMM_WEDGE_PREDTEX_IDX ) { xParseWedgePredTexInfo ( pcCU, uiAbsPartIdx, uiDepth ); }
	1022	else if( uiDir == DMM_WEDGE_PREDDIR_IDX ) { xParseWedgePredDirInfo ( pcCU, uiAbsPartIdx, uiDepth ); }
	1023	}
	1024	else if(uiDir >= EDGE_INTRA_IDX)//CCM mode
	1025	{
	1026	xParseEdgeIntraInfo( pcCU, uiAbsPartIdx, uiDepth );
	1027	}
	1028
	1029	UInt uiSymbol;
	1030	if (bDmmFlag)
	1031	{
	1032	if (bDmmFlag)
	1033	{
	1034	m_pcTDecBinIf->decodeBin( uiSymbol , m_cDmmDeltaFlagModel.get(0, 0, 0) );
	1035	uiDir += uiSymbol;
	1036	}
	1037	if (uiSymbol)
	1038	{
	1039	UInt uiDC;
	1040	Int iDC = 0,iDC1 = 0,iDC2 = 0;
	1041	for ( Int i = 0; i <2; i++ )
	1042	{
	1043	xReadExGolombLevel( uiDC, m_cDmmDataSCModel.get(0, 0, 1) );
	1044	iDC = uiDC;
	1045	if ( uiDC )
	1046	{
	1047	UInt uiSign;
	1048	m_pcTDecBinIf->decodeBinEP( uiSign );
	1049	if ( uiSign )
	1050	{
	1051	iDC = -iDC;
	1052	}
	1053	}
	1054	if ( i == 0 ) { iDC1 = iDC; }
	1055	else { iDC2 = iDC; }
	1056	}
	1057
	1058	if( uiDir == DMM_WEDGE_FULL_D_IDX )
	1059	{
	1060	pcCU->setWedgeFullDeltaDC1SubParts( iDC1, uiAbsPartIdx, uiDepth );
	1061	pcCU->setWedgeFullDeltaDC2SubParts( iDC2, uiAbsPartIdx, uiDepth );
	1062	}
	1063	else if( uiDir == DMM_WEDGE_PREDDIR_D_IDX )
	1064	{
	1065	pcCU->setWedgePredDirDeltaDC1SubParts( iDC1, uiAbsPartIdx, uiDepth );
	1066	pcCU->setWedgePredDirDeltaDC2SubParts( iDC2, uiAbsPartIdx, uiDepth );
	1067	}
	1068	else if( uiDir == DMM_WEDGE_PREDTEX_D_IDX)
	1069	{
	1070	pcCU->setWedgePredTexDeltaDC1SubParts( iDC1, uiAbsPartIdx, uiDepth );
	1071	pcCU->setWedgePredTexDeltaDC2SubParts( iDC2, uiAbsPartIdx, uiDepth );
	1072	}
	1073	else if (uiDir== DMM_CONTOUR_PREDTEX_D_IDX )
	1074	{
	1075	pcCU->setContourPredTexDeltaDC1SubParts( iDC1, uiAbsPartIdx, uiDepth );
	1076	pcCU->setContourPredTexDeltaDC2SubParts( iDC2, uiAbsPartIdx, uiDepth );
	1077	}
	1078	}
	1079	}
	1080	else if (uiDir >= EDGE_INTRA_IDX)
	1081	{
	1082	m_pcTDecBinIf->decodeBin( uiSymbol, m_cEdgeIntraDeltaDCSCModel.get(0, 0, 0) );
	1083	if( uiSymbol )
	1084	{
	1085	uiDir = EDGE_INTRA_DELTA_IDX;
	1086	Int iDeltaDC = 0,iDeltaDC0 = 0,iDeltaDC1 = 0;
	1087	for (Int i = 0; i<2; i++)
	1088	{
	1089	xReadExGolombLevel( (UInt &) iDeltaDC, m_cEdgeIntraDeltaDCSCModel.get(0, 0, 1) );
	1090	if( iDeltaDC != 0 )
	1091	{
	1092	UInt uiSign;
	1093	m_pcTDecBinIf->decodeBinEP( uiSign );
	1094	if ( uiSign )
	1095	{
	1096	iDeltaDC = -iDeltaDC;
	1097	}
	1098	}
	1099	if ( i == 0 ) { iDeltaDC0 = iDeltaDC; }
	1100	else { iDeltaDC1 = iDeltaDC; }
	1101	}
	1102
	1103	pcCU->setEdgeDeltaDC0( uiAbsPartIdx, iDeltaDC0 );
	1104	pcCU->setEdgeDeltaDC1( uiAbsPartIdx, iDeltaDC1 );
	1105	}
	1106	}
	1107	else if(bSdcFlag)//SDC mode
	1108	{
	1109	assert(pcCU->getPartitionSize(uiAbsPartIdx)!=SIZE_NxN);
	1110	pcCU->setTrIdxSubParts(0, uiAbsPartIdx, uiDepth);
	1111	pcCU->setCbfSubParts(1, 1, 1, uiAbsPartIdx, uiDepth);
	1112
	1113	UInt uiNumSegments = ( uiDir == DC_IDX \|\| uiDir == PLANAR_IDX )? 1 : 2;
	1114	for (int uiSeg=0; uiSeg<uiNumSegments; uiSeg++)
	1115	{
	1116	parseSDCResidualData(pcCU, uiAbsPartIdx, uiDepth, uiSeg);
	1117	}
	1118	}
	1119
	1120	pcCU->setLumaIntraDirSubParts( (UChar)uiDir, uiAbsPartIdx, uiDepth );
	1121	}
	1122	#endif
[56]	1123	Void TDecSbac::parseIntraDirLumaAng ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
[2]	1124	{
[56]	1125	UInt uiSymbol;
	1126	Int intraPredMode;
[443]	1127	#if PKU_QC_DEPTH_INTRA_UNI_D0195
	1128	if (pcCU->getSlice()->getSPS()->isDepth())
	1129	{
	1130	parseDepthModelingTable(pcCU, uiAbsPartIdx, uiDepth);
	1131	}
	1132	if (pcCU->getLumaIntraDir(uiAbsPartIdx)<NUM_INTRA_MODE && !pcCU->getSDCFlag(uiAbsPartIdx))
	1133	{
	1134	#else
[5]	1135	#if HHI_DMM_WEDGE_INTRA \|\| HHI_DMM_PRED_TEX
[2]	1136	UInt uiFlag = 0;
[56]	1137	if( pcCU->getSlice()->getSPS()->getUseDMM() && (g_uiMaxCUWidth>>uiDepth) <= DMM_WEDGEMODEL_MAX_SIZE )
[2]	1138	{
[56]	1139	m_pcTDecBinIf->decodeBin( uiFlag, m_cDmmFlagSCModel.get(0, 0, 0) );
[2]	1140	}
[56]	1141	if( uiFlag )
[2]	1142	{
	1143	UInt uiDMMode;
[100]	1144
[5]	1145	#if HHI_DMM_WEDGE_INTRA && HHI_DMM_PRED_TEX
[56]	1146	m_pcTDecBinIf->decodeBin( uiSymbol, m_cDmmModeSCModel.get(0, 0, 0) ); uiDMMode = uiSymbol;
	1147	m_pcTDecBinIf->decodeBin( uiSymbol, m_cDmmModeSCModel.get(0, 0, 0) ); uiDMMode \|= uiSymbol << 1;
[2]	1148	if ( pcCU->getPartitionSize( uiAbsPartIdx ) != SIZE_NxN && g_uiMaxCUWidth>>uiDepth > 4 )
	1149	{
[56]	1150	m_pcTDecBinIf->decodeBin( uiSymbol, m_cDmmModeSCModel.get(0, 0, 0) ); uiDMMode \|= uiSymbol << 2;
[2]	1151	}
	1152	#else
[56]	1153	m_pcTDecBinIf->decodeBin( uiSymbol, m_cDmmModeSCModel.get(0, 0, 0) ); uiDMMode = uiSymbol;
	1154	if ( pcCU->getPartitionSize( uiAbsPartIdx ) != SIZE_NxN && g_uiMaxCUWidth>>uiDepth > 4 )
	1155	{
	1156	m_pcTDecBinIf->decodeBin( uiSymbol, m_cDmmModeSCModel.get(0, 0, 0) ); uiDMMode \|= uiSymbol << 1;
[2]	1157	}
	1158	#endif
[56]	1159	intraPredMode = uiDMMode + NUM_INTRA_MODE;
[2]	1160
[5]	1161	#if HHI_DMM_WEDGE_INTRA
[56]	1162	if( intraPredMode == DMM_WEDGE_FULL_IDX ) { xParseWedgeFullInfo ( pcCU, uiAbsPartIdx, uiDepth ); }
	1163	if( intraPredMode == DMM_WEDGE_FULL_D_IDX ) { xParseWedgeFullDeltaInfo ( pcCU, uiAbsPartIdx, uiDepth ); }
	1164	if( intraPredMode == DMM_WEDGE_PREDDIR_IDX ) { xParseWedgePredDirInfo ( pcCU, uiAbsPartIdx, uiDepth ); }
	1165	if( intraPredMode == DMM_WEDGE_PREDDIR_D_IDX ) { xParseWedgePredDirDeltaInfo ( pcCU, uiAbsPartIdx, uiDepth ); }
[5]	1166	#endif
	1167	#if HHI_DMM_PRED_TEX
[56]	1168	if( intraPredMode == DMM_WEDGE_PREDTEX_D_IDX ) { xParseWedgePredTexDeltaInfo ( pcCU, uiAbsPartIdx, uiDepth ); }
[296]	1169	#if LGE_DMM3_SIMP_C0044
	1170	if( intraPredMode == DMM_WEDGE_PREDTEX_IDX ) { xParseWedgePredTexInfo ( pcCU, uiAbsPartIdx, uiDepth ); }
	1171	#endif
[56]	1172	if( intraPredMode == DMM_CONTOUR_PREDTEX_D_IDX ) { xParseContourPredTexDeltaInfo( pcCU, uiAbsPartIdx, uiDepth ); }
[5]	1173	#endif
[2]	1174	}
	1175	else
	1176	{
	1177	#endif
[100]	1178
[189]	1179	#if LGE_EDGE_INTRA_A0070
[100]	1180	Bool bCodeEdgeIntra = false;
	1181	if( pcCU->getSlice()->getSPS()->isDepth() )
	1182	{
	1183	UInt uiPUWidth = pcCU->getWidth( uiAbsPartIdx ) >> (pcCU->getPartitionSize( uiAbsPartIdx ) == SIZE_NxN ? 1 : 0);
	1184	if( uiPUWidth <= LGE_EDGE_INTRA_MAX_SIZE && uiPUWidth >= LGE_EDGE_INTRA_MIN_SIZE )
	1185	bCodeEdgeIntra = true;
	1186	}
	1187	#endif
[443]	1188	#endif
[100]	1189	Int uiPreds[3] = {-1, -1, -1};
	1190	Int uiPredNum = pcCU->getIntraDirLumaPredictor(uiAbsPartIdx, uiPreds);
[443]	1191	#if !PKU_QC_DEPTH_INTRA_UNI_D0195
[189]	1192	#if LGE_EDGE_INTRA_A0070
[100]	1193	UInt uiCheckBit = 0;
	1194	#endif
[443]	1195	#endif
[100]	1196
	1197	m_pcTDecBinIf->decodeBin( uiSymbol, m_cCUIntraPredSCModel.get( 0, 0, 0) );
	1198
	1199	if ( uiSymbol )
[56]	1200	{
	1201	m_pcTDecBinIf->decodeBinEP( uiSymbol );
[100]	1202	if (uiSymbol)
	1203	{
	1204	m_pcTDecBinIf->decodeBinEP( uiSymbol );
	1205	uiSymbol++;
	1206	}
	1207	intraPredMode = uiPreds[uiSymbol];
[56]	1208	}
[100]	1209	else
[2]	1210	{
[100]	1211	intraPredMode = 0;
	1212
	1213
	1214	m_pcTDecBinIf->decodeBinsEP( uiSymbol, 5 );
[443]	1215	#if !PKU_QC_DEPTH_INTRA_UNI_D0195
[189]	1216	#if LGE_EDGE_INTRA_A0070
[100]	1217	if (bCodeEdgeIntra)
	1218	{
	1219	if (uiSymbol==31)
	1220	{
	1221	m_pcTDecBinIf->decodeBinsEP(uiCheckBit,1);
	1222	if (uiCheckBit)
	1223	uiSymbol = EDGE_INTRA_IDX;
	1224	}
	1225	}
	1226	#endif
[443]	1227	#endif
[100]	1228	intraPredMode = uiSymbol;
	1229
	1230	//postponed sorting of MPMs (only in remaining branch)
	1231	if (uiPreds[0] > uiPreds[1])
	1232	{
	1233	std::swap(uiPreds[0], uiPreds[1]);
	1234	}
	1235	if (uiPreds[0] > uiPreds[2])
	1236	{
	1237	std::swap(uiPreds[0], uiPreds[2]);
	1238	}
	1239	if (uiPreds[1] > uiPreds[2])
	1240	{
	1241	std::swap(uiPreds[1], uiPreds[2]);
	1242	}
[443]	1243	#if !PKU_QC_DEPTH_INTRA_UNI_D0195
[189]	1244	#if LGE_EDGE_INTRA_A0070
[100]	1245	if ( intraPredMode != EDGE_INTRA_IDX)
	1246	{
	1247	#endif
[443]	1248	#endif
[100]	1249	for ( Int i = 0; i < uiPredNum; i++ )
	1250	{
	1251	intraPredMode += ( intraPredMode >= uiPreds[i] );
	1252	}
[443]	1253	#if !PKU_QC_DEPTH_INTRA_UNI_D0195
[189]	1254	#if LGE_EDGE_INTRA_A0070
[100]	1255	}
	1256	#endif
[443]	1257	#endif
[2]	1258	}
[100]	1259
[443]	1260	#if !PKU_QC_DEPTH_INTRA_UNI_D0195
[189]	1261	#if LGE_EDGE_INTRA_A0070
[100]	1262	if( intraPredMode == EDGE_INTRA_IDX )
[2]	1263	{
[100]	1264	xParseEdgeIntraInfo( pcCU, uiAbsPartIdx, uiDepth );
	1265	#if LGE_EDGE_INTRA_DELTA_DC
	1266	m_pcTDecBinIf->decodeBin( uiSymbol, m_cEdgeIntraDeltaDCSCModel.get(0, 0, 0) );
	1267	if( uiSymbol )
	1268	{
	1269	intraPredMode = EDGE_INTRA_DELTA_IDX;
	1270	Int iDeltaDC0;
	1271	Int iDeltaDC1;
	1272
	1273	xReadExGolombLevel( (UInt &) iDeltaDC0, m_cEdgeIntraDeltaDCSCModel.get(0, 0, 1) );
	1274	if( iDeltaDC0 != 0 )
	1275	{
	1276	UInt uiSign;
	1277	m_pcTDecBinIf->decodeBinEP( uiSign );
	1278	if ( uiSign )
	1279	{
	1280	iDeltaDC0 = -iDeltaDC0;
	1281	}
	1282	}
	1283	xReadExGolombLevel( (UInt &) iDeltaDC1, m_cEdgeIntraDeltaDCSCModel.get(0, 0, 1) );
	1284	if( iDeltaDC1 != 0 )
	1285	{
	1286	UInt uiSign;
	1287	m_pcTDecBinIf->decodeBinEP( uiSign );
	1288	if ( uiSign )
	1289	{
	1290	iDeltaDC1 = -iDeltaDC1;
	1291	}
	1292	}
	1293
	1294	pcCU->setEdgeDeltaDC0( uiAbsPartIdx, iDeltaDC0 );
	1295	pcCU->setEdgeDeltaDC1( uiAbsPartIdx, iDeltaDC1 );
	1296	}
	1297	#endif
[2]	1298	}
[56]	1299	#endif
[100]	1300
[56]	1301	#if HHI_DMM_WEDGE_INTRA \|\| HHI_DMM_PRED_TEX
	1302	}
[2]	1303	#endif
[56]	1304	pcCU->setLumaIntraDirSubParts( (UChar)intraPredMode, uiAbsPartIdx, uiDepth );
[443]	1305	#else
	1306	pcCU->setLumaIntraDirSubParts( (UChar)intraPredMode, uiAbsPartIdx, uiDepth );
[56]	1307	}
[443]	1308	#endif
	1309	}
[2]	1310
	1311	Void TDecSbac::parseIntraDirChroma( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
	1312	{
	1313	UInt uiSymbol;
	1314
[56]	1315	m_pcTDecBinIf->decodeBin( uiSymbol, m_cCUChromaPredSCModel.get( 0, 0, 0 ) );
	1316
	1317	if( uiSymbol == 0 )
[2]	1318	{
[56]	1319	uiSymbol = DM_CHROMA_IDX;
[2]	1320	}
	1321	else
	1322	{
[56]	1323	if( pcCU->getSlice()->getSPS()->getUseLMChroma() )
[2]	1324	{
[56]	1325	m_pcTDecBinIf->decodeBin( uiSymbol, m_cCUChromaPredSCModel.get( 0, 0, 1 ) );
[2]	1326	}
[56]	1327	else
	1328	{
	1329	uiSymbol = 1;
	1330	}
[2]	1331
[56]	1332	if( uiSymbol == 0 )
[2]	1333	{
[56]	1334	uiSymbol = LM_CHROMA_IDX;
	1335	}
	1336	else
	1337	{
	1338	UInt uiIPredMode;
	1339	m_pcTDecBinIf->decodeBinsEP( uiIPredMode, 2 );
	1340	UInt uiAllowedChromaDir[ NUM_CHROMA_MODE ];
	1341	pcCU->getAllowedChromaDir( uiAbsPartIdx, uiAllowedChromaDir );
	1342	uiSymbol = uiAllowedChromaDir[ uiIPredMode ];
[2]	1343	}
	1344	}
	1345	pcCU->setChromIntraDirSubParts( uiSymbol, uiAbsPartIdx, uiDepth );
	1346	return;
	1347	}
	1348
	1349	Void TDecSbac::parseInterDir( TComDataCU* pcCU, UInt& ruiInterDir, UInt uiAbsPartIdx, UInt uiDepth )
	1350	{
	1351	UInt uiSymbol;
[56]	1352	const UInt uiCtx = pcCU->getCtxInterDir( uiAbsPartIdx );
	1353	ContextModel *pCtx = m_cCUInterDirSCModel.get( 0 );
	1354	m_pcTDecBinIf->decodeBin( uiSymbol, *( pCtx + uiCtx ) );
	1355
	1356	if( uiSymbol )
[2]	1357	{
	1358	uiSymbol = 2;
	1359	}
[56]	1360
[2]	1361	uiSymbol++;
	1362	ruiInterDir = uiSymbol;
	1363	return;
	1364	}
	1365
	1366	Void TDecSbac::parseRefFrmIdx( TComDataCU* pcCU, Int& riRefFrmIdx, UInt uiAbsPartIdx, UInt uiDepth, RefPicList eRefList )
	1367	{
	1368	UInt uiSymbol;
	1369
	1370	if(pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_C ) > 0 && eRefList==REF_PIC_LIST_C)
	1371	{
[56]	1372	ContextModel *pCtx = m_cCURefPicSCModel.get( 0 );
	1373	m_pcTDecBinIf->decodeBin( uiSymbol, *pCtx );
[2]	1374
[56]	1375	if( uiSymbol )
[2]	1376	{
[56]	1377	xReadUnaryMaxSymbol( uiSymbol, pCtx + 1, 1, pcCU->getSlice()->getNumRefIdx( REF_PIC_LIST_C )-2 );
[2]	1378	uiSymbol++;
	1379	}
	1380	riRefFrmIdx = uiSymbol;
	1381	}
	1382	else
	1383	{
[56]	1384	ContextModel *pCtx = m_cCURefPicSCModel.get( 0 );
	1385	m_pcTDecBinIf->decodeBin( uiSymbol, *pCtx );
[2]	1386
[56]	1387	if( uiSymbol )
	1388	{
	1389	xReadUnaryMaxSymbol( uiSymbol, pCtx + 1, 1, pcCU->getSlice()->getNumRefIdx( eRefList )-2 );
	1390	uiSymbol++;
	1391	}
	1392	riRefFrmIdx = uiSymbol;
[2]	1393	}
	1394
	1395	return;
	1396	}
	1397
[56]	1398	Void TDecSbac::parseMvd( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth, RefPicList eRefList )
[2]	1399	{
	1400	UInt uiSymbol;
[56]	1401	UInt uiHorAbs;
	1402	UInt uiVerAbs;
	1403	UInt uiHorSign = 0;
	1404	UInt uiVerSign = 0;
	1405	ContextModel *pCtx = m_cCUMvdSCModel.get( 0 );
[2]	1406
[56]	1407	if(pcCU->getSlice()->getMvdL1ZeroFlag() && eRefList == REF_PIC_LIST_1 && pcCU->getInterDir(uiAbsPartIdx)==3)
	1408	{
	1409	uiHorAbs=0;
	1410	uiVerAbs=0;
	1411	}
	1412	else
	1413	{
[2]	1414
[56]	1415	m_pcTDecBinIf->decodeBin( uiHorAbs, *pCtx );
	1416	m_pcTDecBinIf->decodeBin( uiVerAbs, *pCtx );
[2]	1417
[56]	1418	const Bool bHorAbsGr0 = uiHorAbs != 0;
	1419	const Bool bVerAbsGr0 = uiVerAbs != 0;
	1420	pCtx++;
	1421
	1422	if( bHorAbsGr0 )
	1423	{
	1424	m_pcTDecBinIf->decodeBin( uiSymbol, *pCtx );
	1425	uiHorAbs += uiSymbol;
	1426	}
	1427
	1428	if( bVerAbsGr0 )
	1429	{
	1430	m_pcTDecBinIf->decodeBin( uiSymbol, *pCtx );
	1431	uiVerAbs += uiSymbol;
	1432	}
	1433
	1434	if( bHorAbsGr0 )
	1435	{
	1436	if( 2 == uiHorAbs )
	1437	{
	1438	xReadEpExGolomb( uiSymbol, 1 );
	1439	uiHorAbs += uiSymbol;
	1440	}
	1441
	1442	m_pcTDecBinIf->decodeBinEP( uiHorSign );
	1443	}
	1444
	1445	if( bVerAbsGr0 )
	1446	{
	1447	if( 2 == uiVerAbs )
	1448	{
	1449	xReadEpExGolomb( uiSymbol, 1 );
	1450	uiVerAbs += uiSymbol;
	1451	}
	1452
	1453	m_pcTDecBinIf->decodeBinEP( uiVerSign );
	1454	}
	1455
	1456	}
[2]	1457
[56]	1458	const TComMv cMv( uiHorSign ? -Int( uiHorAbs ): uiHorAbs, uiVerSign ? -Int( uiVerAbs ) : uiVerAbs );
	1459	pcCU->getCUMvField( eRefList )->setAllMvd( cMv, pcCU->getPartitionSize( uiAbsPartIdx ), uiAbsPartIdx, uiDepth, uiPartIdx );
[2]	1460	return;
	1461	}
	1462
	1463
	1464	Void TDecSbac::parseTransformSubdivFlag( UInt& ruiSubdivFlag, UInt uiLog2TransformBlockSize )
	1465	{
	1466	m_pcTDecBinIf->decodeBin( ruiSubdivFlag, m_cCUTransSubdivFlagSCModel.get( 0, 0, uiLog2TransformBlockSize ) );
[56]	1467	DTRACE_CABAC_VL( g_nSymbolCounter++ )
[2]	1468	DTRACE_CABAC_T( "\tparseTransformSubdivFlag()" )
	1469	DTRACE_CABAC_T( "\tsymbol=" )
	1470	DTRACE_CABAC_V( ruiSubdivFlag )
	1471	DTRACE_CABAC_T( "\tctx=" )
	1472	DTRACE_CABAC_V( uiLog2TransformBlockSize )
	1473	DTRACE_CABAC_T( "\n" )
	1474	}
	1475
	1476	Void TDecSbac::parseQtRootCbf( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, UInt& uiQtRootCbf )
	1477	{
	1478	UInt uiSymbol;
[56]	1479	const UInt uiCtx = 0;
[2]	1480	m_pcTDecBinIf->decodeBin( uiSymbol , m_cCUQtRootCbfSCModel.get( 0, 0, uiCtx ) );
[56]	1481	DTRACE_CABAC_VL( g_nSymbolCounter++ )
[2]	1482	DTRACE_CABAC_T( "\tparseQtRootCbf()" )
	1483	DTRACE_CABAC_T( "\tsymbol=" )
	1484	DTRACE_CABAC_V( uiSymbol )
	1485	DTRACE_CABAC_T( "\tctx=" )
	1486	DTRACE_CABAC_V( uiCtx )
	1487	DTRACE_CABAC_T( "\tuiAbsPartIdx=" )
	1488	DTRACE_CABAC_V( uiAbsPartIdx )
	1489	DTRACE_CABAC_T( "\n" )
	1490
	1491	uiQtRootCbf = uiSymbol;
	1492	}
	1493
	1494	Void TDecSbac::parseDeltaQP( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
	1495	{
[56]	1496	Int qp;
[2]	1497	UInt uiDQp;
	1498	Int iDQp;
	1499
	1500	m_pcTDecBinIf->decodeBin( uiDQp, m_cCUDeltaQpSCModel.get( 0, 0, 0 ) );
	1501
	1502	if ( uiDQp == 0 )
	1503	{
[56]	1504	qp = pcCU->getRefQP(uiAbsPartIdx);
[2]	1505	}
	1506	else
	1507	{
[56]	1508	UInt uiSign;
	1509	Int qpBdOffsetY = pcCU->getSlice()->getSPS()->getQpBDOffsetY();
	1510	m_pcTDecBinIf->decodeBinEP(uiSign);
	1511
	1512	UInt uiMaxAbsDQpMinus1 = 24 + (qpBdOffsetY/2) + (uiSign);
	1513	UInt uiAbsDQpMinus1;
	1514	xReadUnaryMaxSymbol (uiAbsDQpMinus1, &m_cCUDeltaQpSCModel.get( 0, 0, 1 ), 1, uiMaxAbsDQpMinus1);
	1515
	1516	iDQp = uiAbsDQpMinus1 + 1;
	1517
	1518	if(uiSign)
[2]	1519	{
	1520	iDQp = -iDQp;
	1521	}
[56]	1522
	1523	qp = (((Int) pcCU->getRefQP( uiAbsPartIdx ) + iDQp + 52 + 2*qpBdOffsetY )%(52+qpBdOffsetY)) - qpBdOffsetY;
[2]	1524	}
	1525
[56]	1526	UInt uiAbsQpCUPartIdx = (uiAbsPartIdx>>(8-(pcCU->getSlice()->getPPS()->getMaxCuDQPDepth()<<1)))<<(8-(pcCU->getSlice()->getPPS()->getMaxCuDQPDepth()<<1)) ;
	1527	UInt uiQpCUDepth = min(uiDepth,pcCU->getSlice()->getPPS()->getMaxCuDQPDepth()) ;
	1528	pcCU->setQPSubParts( qp, uiAbsQpCUPartIdx, uiQpCUDepth );
[2]	1529	}
	1530
	1531	Void TDecSbac::parseQtCbf( TComDataCU* pcCU, UInt uiAbsPartIdx, TextType eType, UInt uiTrDepth, UInt uiDepth )
	1532	{
	1533	UInt uiSymbol;
	1534	const UInt uiCtx = pcCU->getCtxQtCbf( uiAbsPartIdx, eType, uiTrDepth );
[56]	1535	m_pcTDecBinIf->decodeBin( uiSymbol , m_cCUQtCbfSCModel.get( 0, eType ? TEXT_CHROMA: eType, uiCtx ) );
[2]	1536
[56]	1537	DTRACE_CABAC_VL( g_nSymbolCounter++ )
[2]	1538	DTRACE_CABAC_T( "\tparseQtCbf()" )
	1539	DTRACE_CABAC_T( "\tsymbol=" )
	1540	DTRACE_CABAC_V( uiSymbol )
	1541	DTRACE_CABAC_T( "\tctx=" )
	1542	DTRACE_CABAC_V( uiCtx )
	1543	DTRACE_CABAC_T( "\tetype=" )
	1544	DTRACE_CABAC_V( eType )
	1545	DTRACE_CABAC_T( "\tuiAbsPartIdx=" )
	1546	DTRACE_CABAC_V( uiAbsPartIdx )
	1547	DTRACE_CABAC_T( "\n" )
	1548
	1549	pcCU->setCbfSubParts( uiSymbol << uiTrDepth, eType, uiAbsPartIdx, uiDepth );
	1550	}
	1551
	1552	/** Parse (X,Y) position of the last significant coefficient
	1553	* \param uiPosLastX reference to X component of last coefficient
	1554	* \param uiPosLastY reference to Y component of last coefficient
[56]	1555	* \param width Block width
	1556	* \param height Block height
[2]	1557	* \param eTType plane type / luminance or chrominance
	1558	* \param uiScanIdx scan type (zig-zag, hor, ver)
[56]	1559	*
[2]	1560	* This method decodes the X and Y component within a block of the last significant coefficient.
	1561	*/
[56]	1562	Void TDecSbac::parseLastSignificantXY( UInt& uiPosLastX, UInt& uiPosLastY, Int width, Int height, TextType eTType, UInt uiScanIdx )
[2]	1563	{
	1564	UInt uiLast;
[56]	1565	ContextModel *pCtxX = m_cCuCtxLastX.get( 0, eTType );
	1566	ContextModel *pCtxY = m_cCuCtxLastY.get( 0, eTType );
[2]	1567
[56]	1568	// posX
	1569	Int widthCtx = eTType ? 4 : width;
	1570	const UInt puiCtxIdxX = g_uiLastCtx + ( g_aucConvertToBit[ widthCtx ] ( g_aucConvertToBit[ widthCtx ] + 3 ) );
	1571	for( uiPosLastX = 0; uiPosLastX < g_uiGroupIdx[ width - 1 ]; uiPosLastX++ )
[2]	1572	{
[56]	1573	if ( eTType )
[2]	1574	{
[56]	1575	m_pcTDecBinIf->decodeBin( uiLast, *( pCtxX + (uiPosLastX>>g_aucConvertToBit[ width ]) ) );
	1576	}
	1577	else
	1578	{
	1579	m_pcTDecBinIf->decodeBin( uiLast, *( pCtxX + puiCtxIdxX[ uiPosLastX ] ) );
	1580	}
	1581	if( !uiLast )
	1582	{
[2]	1583	break;
	1584	}
	1585	}
	1586
[56]	1587	// posY
	1588	Int heightCtx = eTType? 4 : height;
	1589	const UInt puiCtxIdxY = g_uiLastCtx + ( g_aucConvertToBit[ heightCtx ] ( g_aucConvertToBit[ heightCtx ] + 3 ) );
	1590	for( uiPosLastY = 0; uiPosLastY < g_uiGroupIdx[ height - 1 ]; uiPosLastY++ )
[2]	1591	{
[56]	1592	if (eTType)
[2]	1593	{
[56]	1594	m_pcTDecBinIf->decodeBin( uiLast, *( pCtxY + (uiPosLastY>>g_aucConvertToBit[ height ]) ) );
	1595	}
	1596	else
	1597	{
	1598	m_pcTDecBinIf->decodeBin( uiLast, *( pCtxY + puiCtxIdxY[ uiPosLastY ] ) );
	1599	}
	1600	if( !uiLast )
	1601	{
[2]	1602	break;
	1603	}
	1604	}
[56]	1605	if ( uiPosLastX > 3 )
	1606	{
	1607	UInt uiTemp = 0;
	1608	UInt uiCount = ( uiPosLastX - 2 ) >> 1;
	1609	for ( Int i = uiCount - 1; i >= 0; i-- )
	1610	{
	1611	m_pcTDecBinIf->decodeBinEP( uiLast );
	1612	uiTemp += uiLast << i;
	1613	}
	1614	uiPosLastX = g_uiMinInGroup[ uiPosLastX ] + uiTemp;
	1615	}
	1616	if ( uiPosLastY > 3 )
	1617	{
	1618	UInt uiTemp = 0;
	1619	UInt uiCount = ( uiPosLastY - 2 ) >> 1;
	1620	for ( Int i = uiCount - 1; i >= 0; i-- )
	1621	{
	1622	m_pcTDecBinIf->decodeBinEP( uiLast );
	1623	uiTemp += uiLast << i;
	1624	}
	1625	uiPosLastY = g_uiMinInGroup[ uiPosLastY ] + uiTemp;
	1626	}
	1627
[2]	1628	if( uiScanIdx == SCAN_VER )
	1629	{
	1630	swap( uiPosLastX, uiPosLastY );
	1631	}
	1632	}
	1633
	1634	Void TDecSbac::parseCoeffNxN( TComDataCU* pcCU, TCoeff* pcCoef, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, UInt uiDepth, TextType eTType )
	1635	{
[56]	1636	DTRACE_CABAC_VL( g_nSymbolCounter++ )
[2]	1637	DTRACE_CABAC_T( "\tparseCoeffNxN()\teType=" )
	1638	DTRACE_CABAC_V( eTType )
	1639	DTRACE_CABAC_T( "\twidth=" )
	1640	DTRACE_CABAC_V( uiWidth )
	1641	DTRACE_CABAC_T( "\theight=" )
	1642	DTRACE_CABAC_V( uiHeight )
	1643	DTRACE_CABAC_T( "\tdepth=" )
	1644	DTRACE_CABAC_V( uiDepth )
	1645	DTRACE_CABAC_T( "\tabspartidx=" )
	1646	DTRACE_CABAC_V( uiAbsPartIdx )
	1647	DTRACE_CABAC_T( "\ttoCU-X=" )
	1648	DTRACE_CABAC_V( pcCU->getCUPelX() )
	1649	DTRACE_CABAC_T( "\ttoCU-Y=" )
	1650	DTRACE_CABAC_V( pcCU->getCUPelY() )
	1651	DTRACE_CABAC_T( "\tCU-addr=" )
	1652	DTRACE_CABAC_V( pcCU->getAddr() )
	1653	DTRACE_CABAC_T( "\tinCU-X=" )
	1654	DTRACE_CABAC_V( g_auiRasterToPelX[ g_auiZscanToRaster[uiAbsPartIdx] ] )
	1655	DTRACE_CABAC_T( "\tinCU-Y=" )
	1656	DTRACE_CABAC_V( g_auiRasterToPelY[ g_auiZscanToRaster[uiAbsPartIdx] ] )
	1657	DTRACE_CABAC_T( "\tpredmode=" )
	1658	DTRACE_CABAC_V( pcCU->getPredictionMode( uiAbsPartIdx ) )
	1659	DTRACE_CABAC_T( "\n" )
	1660
	1661	if( uiWidth > pcCU->getSlice()->getSPS()->getMaxTrSize() )
	1662	{
	1663	uiWidth = pcCU->getSlice()->getSPS()->getMaxTrSize();
	1664	uiHeight = pcCU->getSlice()->getSPS()->getMaxTrSize();
	1665	}
	1666
	1667	eTType = eTType == TEXT_LUMA ? TEXT_LUMA : ( eTType == TEXT_NONE ? TEXT_NONE : TEXT_CHROMA );
	1668
	1669	//----- parse significance map -----
	1670	const UInt uiLog2BlockSize = g_aucConvertToBit[ uiWidth ] + 2;
[56]	1671	const UInt uiMaxNumCoeff = uiWidth * uiHeight;
[2]	1672	const UInt uiMaxNumCoeffM1 = uiMaxNumCoeff - 1;
[56]	1673	UInt uiScanIdx = pcCU->getCoefScanIdx(uiAbsPartIdx, uiWidth, eTType==TEXT_LUMA, pcCU->isIntra(uiAbsPartIdx));
	1674	int blockType = uiLog2BlockSize;
	1675	if (uiWidth != uiHeight)
	1676	{
	1677	uiScanIdx = SCAN_DIAG;
	1678	blockType = 4;
	1679	}
[2]	1680
[56]	1681	//===== decode last significant =====
	1682	UInt uiPosLastX, uiPosLastY;
	1683	parseLastSignificantXY( uiPosLastX, uiPosLastY, uiWidth, uiHeight, eTType, uiScanIdx );
	1684	UInt uiBlkPosLast = uiPosLastX + (uiPosLastY<<uiLog2BlockSize);
	1685	pcCoef[ uiBlkPosLast ] = 1;
[2]	1686
[56]	1687	//===== decode significance flags =====
	1688	UInt uiScanPosLast = uiBlkPosLast;
	1689	if (uiScanIdx == SCAN_ZIGZAG)
	1690	{
	1691	// Map zigzag to diagonal scan
	1692	uiScanIdx = SCAN_DIAG;
	1693	}
	1694	const UInt * scan;
	1695	if (uiWidth == uiHeight)
	1696	{
	1697	scan = g_auiSigLastScan[ uiScanIdx ][ uiLog2BlockSize-1 ];
	1698	}
	1699	else
	1700	{
	1701	scan = g_sigScanNSQT[ uiLog2BlockSize - 2 ];
	1702	}
	1703	for( uiScanPosLast = 0; uiScanPosLast < uiMaxNumCoeffM1; uiScanPosLast++ )
	1704	{
	1705	UInt uiBlkPos = scan[ uiScanPosLast ];
	1706	if( uiBlkPosLast == uiBlkPos )
[2]	1707	{
[56]	1708	break;
[2]	1709	}
[56]	1710	}
[2]	1711
[56]	1712	ContextModel * const baseCoeffGroupCtx = m_cCUSigCoeffGroupSCModel.get( 0, eTType );
	1713	ContextModel * const baseCtx = (eTType==TEXT_LUMA) ? m_cCUSigSCModel.get( 0, 0 ) : m_cCUSigSCModel.get( 0, 0 ) + NUM_SIG_FLAG_CTX_LUMA;
	1714
	1715	const Int iLastScanSet = uiScanPosLast >> LOG2_SCAN_SET_SIZE;
	1716	UInt uiNumOne = 0;
	1717	UInt uiGoRiceParam = 0;
	1718
	1719	UInt const tsig = pcCU->getSlice()->getPPS()->getTSIG();
	1720	#if LOSSLESS_CODING
	1721	Bool beValid;
	1722	if (pcCU->isLosslessCoded(uiAbsPartIdx))
[2]	1723	{
[56]	1724	beValid = false;
	1725	}
	1726	else
	1727	{
	1728	beValid = pcCU->getSlice()->getPPS()->getSignHideFlag() > 0;
	1729	}
[2]	1730	#else
[56]	1731	Bool beValid = pcCU->getSlice()->getPPS()->getSignHideFlag() > 0;
[2]	1732	#endif
[56]	1733	UInt absSum = 0;
	1734
	1735	UInt uiSigCoeffGroupFlag[ MLS_GRP_NUM ];
	1736	::memset( uiSigCoeffGroupFlag, 0, sizeof(UInt) * MLS_GRP_NUM );
	1737	const UInt uiNumBlkSide = uiWidth >> (MLS_CG_SIZE >> 1);
	1738	const UInt * scanCG;
	1739	if (uiWidth == uiHeight)
	1740	{
	1741	scanCG = g_auiSigLastScan[ uiScanIdx ][ uiLog2BlockSize > 3 ? uiLog2BlockSize-2-1 : 0 ];
	1742	if( uiLog2BlockSize == 3 )
[2]	1743	{
[56]	1744	scanCG = g_sigLastScan8x8[ uiScanIdx ];
[2]	1745	}
[56]	1746	else if( uiLog2BlockSize == 5 )
	1747	{
	1748	scanCG = g_sigLastScanCG32x32;
	1749	}
[2]	1750	}
[56]	1751	else
[2]	1752	{
[56]	1753	scanCG = g_sigCGScanNSQT[ uiLog2BlockSize - 2 ];
[2]	1754	}
[56]	1755	Int iScanPosSig = (Int) uiScanPosLast;
	1756	for( Int iSubSet = iLastScanSet; iSubSet >= 0; iSubSet-- )
	1757	{
	1758	Int iSubPos = iSubSet << LOG2_SCAN_SET_SIZE;
	1759	uiGoRiceParam = 0;
	1760	Int numNonZero = 0;
	1761
	1762	Int lastNZPosInCG = -1, firstNZPosInCG = SCAN_SET_SIZE;
	1763
	1764	Int pos[SCAN_SET_SIZE];
	1765	if( iScanPosSig == (Int) uiScanPosLast )
	1766	{
	1767	lastNZPosInCG = iScanPosSig;
	1768	firstNZPosInCG = iScanPosSig;
	1769	iScanPosSig--;
	1770	pos[ numNonZero ] = uiBlkPosLast;
	1771	numNonZero = 1;
	1772	}
[2]	1773
[56]	1774	// decode significant_coeffgroup_flag
	1775	Int iCGBlkPos = scanCG[ iSubSet ];
	1776	Int iCGPosY = iCGBlkPos / uiNumBlkSide;
	1777	Int iCGPosX = iCGBlkPos - (iCGPosY * uiNumBlkSide);
	1778	if( uiWidth == 8 && uiHeight == 8 && (uiScanIdx == SCAN_HOR \|\| uiScanIdx == SCAN_VER) )
[2]	1779	{
[56]	1780	iCGPosY = (uiScanIdx == SCAN_HOR ? iCGBlkPos : 0);
	1781	iCGPosX = (uiScanIdx == SCAN_VER ? iCGBlkPos : 0);
[2]	1782	}
[56]	1783	if( iSubSet == iLastScanSet \|\| iSubSet == 0)
[2]	1784	{
[56]	1785	uiSigCoeffGroupFlag[ iCGBlkPos ] = 1;
	1786	}
	1787	else
	1788	{
	1789	UInt uiSigCoeffGroup;
	1790	UInt uiCtxSig = TComTrQuant::getSigCoeffGroupCtxInc( uiSigCoeffGroupFlag, iCGPosX, iCGPosY, uiScanIdx, uiWidth, uiHeight );
	1791	m_pcTDecBinIf->decodeBin( uiSigCoeffGroup, baseCoeffGroupCtx[ uiCtxSig ] );
	1792	uiSigCoeffGroupFlag[ iCGBlkPos ] = uiSigCoeffGroup;
	1793	}
	1794
	1795	// decode significant_coeff_flag
	1796	UInt uiBlkPos, uiPosY, uiPosX, uiSig, uiCtxSig;
	1797	for( ; iScanPosSig >= iSubPos; iScanPosSig-- )
	1798	{
	1799	uiBlkPos = scan[ iScanPosSig ];
	1800	uiPosY = uiBlkPos >> uiLog2BlockSize;
	1801	uiPosX = uiBlkPos - ( uiPosY << uiLog2BlockSize );
	1802	uiSig = 0;
[2]	1803
[56]	1804	if( uiSigCoeffGroupFlag[ iCGBlkPos ] )
[2]	1805	{
[56]	1806	if( iScanPosSig > iSubPos \|\| iSubSet == 0 \|\| numNonZero )
[2]	1807	{
[56]	1808	uiCtxSig = TComTrQuant::getSigCtxInc( pcCoef, uiPosX, uiPosY, blockType, uiWidth, uiHeight, eTType );
	1809	m_pcTDecBinIf->decodeBin( uiSig, baseCtx[ uiCtxSig ] );
[2]	1810	}
[56]	1811	else
	1812	{
	1813	uiSig = 1;
	1814	}
[2]	1815	}
[56]	1816	pcCoef[ uiBlkPos ] = uiSig;
	1817	if( uiSig )
[2]	1818	{
[56]	1819	pos[ numNonZero ] = uiBlkPos;
	1820	numNonZero ++;
	1821	if( lastNZPosInCG == -1 )
[2]	1822	{
[56]	1823	lastNZPosInCG = iScanPosSig;
	1824	}
	1825	firstNZPosInCG = iScanPosSig;
[2]	1826	}
[56]	1827	}
	1828
[2]	1829
[56]	1830	if( numNonZero )
[2]	1831	{
[56]	1832	Bool signHidden = ( lastNZPosInCG - firstNZPosInCG >= (Int)tsig );
	1833	absSum = 0;
	1834
	1835	UInt c1 = 1;
	1836	UInt uiCtxSet = (iSubSet > 0 && eTType==TEXT_LUMA) ? 2 : 0;
	1837	UInt uiBin;
[2]	1838
[56]	1839	if( uiNumOne > 0 )
[2]	1840	{
[56]	1841	uiCtxSet++;
	1842	}
	1843
	1844	uiNumOne >>= 1;
	1845	ContextModel baseCtxMod = ( eTType==TEXT_LUMA ) ? m_cCUOneSCModel.get( 0, 0 ) + 4 uiCtxSet : m_cCUOneSCModel.get( 0, 0 ) + NUM_ONE_FLAG_CTX_LUMA + 4 * uiCtxSet;
	1846	Int absCoeff[SCAN_SET_SIZE];
	1847
	1848	for ( Int i = 0; i < numNonZero; i++) absCoeff[i] = 1;
	1849	Int numC1Flag = min(numNonZero, C1FLAG_NUMBER);
	1850	Int firstC2FlagIdx = -1;
	1851
	1852	for( Int idx = 0; idx < numC1Flag; idx++ )
	1853	{
	1854	m_pcTDecBinIf->decodeBin( uiBin, baseCtxMod[c1] );
	1855	if( uiBin == 1 )
[2]	1856	{
[56]	1857	c1 = 0;
	1858	if (firstC2FlagIdx == -1)
	1859	{
	1860	firstC2FlagIdx = idx;
	1861	}
	1862	}
	1863	else if( (c1 < 3) && (c1 > 0) )
	1864	{
[2]	1865	c1++;
	1866	}
[56]	1867	absCoeff[ idx ] = uiBin + 1;
	1868	}
	1869
	1870	if (c1 == 0)
	1871	{
	1872	baseCtxMod = ( eTType==TEXT_LUMA ) ? m_cCUAbsSCModel.get( 0, 0 ) + uiCtxSet : m_cCUAbsSCModel.get( 0, 0 ) + NUM_ABS_FLAG_CTX_LUMA + uiCtxSet;
	1873	if ( firstC2FlagIdx != -1)
[2]	1874	{
[56]	1875	m_pcTDecBinIf->decodeBin( uiBin, baseCtxMod[0] );
	1876	absCoeff[ firstC2FlagIdx ] = uiBin + 2;
[2]	1877	}
	1878	}
[56]	1879
	1880	UInt coeffSigns;
	1881	if ( signHidden && beValid )
	1882	{
	1883	m_pcTDecBinIf->decodeBinsEP( coeffSigns, numNonZero-1 );
	1884	coeffSigns <<= 32 - (numNonZero-1);
	1885	}
	1886	else
	1887	{
	1888	m_pcTDecBinIf->decodeBinsEP( coeffSigns, numNonZero );
	1889	coeffSigns <<= 32 - numNonZero;
	1890	}
[2]	1891
[56]	1892	Int iFirstCoeff2 = 1;
	1893	if (c1 == 0 \|\| numNonZero > C1FLAG_NUMBER)
[2]	1894	{
[56]	1895	for( Int idx = 0; idx < numNonZero; idx++ )
[2]	1896	{
[56]	1897	UInt baseLevel = (idx < C1FLAG_NUMBER)? (2 + iFirstCoeff2) : 1;
[2]	1898
[56]	1899	if( absCoeff[ idx ] == baseLevel)
[2]	1900	{
[56]	1901	UInt uiLevel;
[2]	1902	xReadGoRiceExGolomb( uiLevel, uiGoRiceParam );
[56]	1903	absCoeff[ idx ] = uiLevel + baseLevel;
[2]	1904	}
[56]	1905
	1906	if(absCoeff[ idx ] >= 2)
[2]	1907	{
[56]	1908	iFirstCoeff2 = 0;
	1909	uiNumOne++;
[2]	1910	}
	1911	}
	1912	}
[56]	1913
	1914	for( Int idx = 0; idx < numNonZero; idx++ )
[2]	1915	{
[56]	1916	Int blkPos = pos[ idx ];
	1917	// Signs applied later.
	1918	pcCoef[ blkPos ] = absCoeff[ idx ];
	1919	absSum += absCoeff[ idx ];
	1920
	1921	if ( idx == numNonZero-1 && signHidden && beValid )
	1922	{
	1923	// Infer sign of 1st element.
	1924	if (absSum&0x1)
	1925	pcCoef[ blkPos ] = -pcCoef[ blkPos ];
	1926	}
	1927	else
	1928	{
	1929	Int sign = static_cast<Int>( coeffSigns ) >> 31;
	1930	pcCoef[ blkPos ] = ( pcCoef[ blkPos ] ^ sign ) - sign;
	1931	coeffSigns <<= 1;
	1932	}
[2]	1933	}
	1934	}
[56]	1935	else
	1936	{
	1937	uiNumOne >>= 1;
	1938	}
[2]	1939	}
	1940
	1941	return;
	1942	}
	1943
[443]	1944	#if LGE_SAO_MIGRATION_D0091
	1945	Void TDecSbac::parseSaoMaxUvlc ( UInt& val, UInt maxSymbol )
	1946	{
	1947	if (maxSymbol == 0)
	1948	{
	1949	val = 0;
	1950	return;
	1951	}
[2]	1952
[443]	1953	UInt code;
	1954	Int i;
	1955	m_pcTDecBinIf->decodeBinEP( code );
	1956	if ( code == 0 )
	1957	{
	1958	val = 0;
	1959	return;
	1960	}
	1961
	1962	i=1;
	1963	while (1)
	1964	{
	1965	m_pcTDecBinIf->decodeBinEP( code );
	1966	if ( code == 0 )
	1967	{
	1968	break;
	1969	}
	1970	i++;
	1971	if (i == maxSymbol)
	1972	{
	1973	break;
	1974	}
	1975	}
	1976
	1977	val = i;
	1978	}
	1979
	1980	Void TDecSbac::parseSaoUflc (UInt uiLength, UInt& riVal)
	1981	{
	1982	m_pcTDecBinIf->decodeBinsEP ( riVal, uiLength );
	1983	}
	1984
	1985	Void TDecSbac::parseSaoMerge (UInt& ruiVal)
	1986	{
	1987	UInt uiCode;
	1988	m_pcTDecBinIf->decodeBin( uiCode, m_cSaoMergeSCModel.get( 0, 0, 0 ) );
	1989	ruiVal = (Int)uiCode;
	1990	}
	1991
	1992	Void TDecSbac::parseSaoTypeIdx (UInt& ruiVal)
	1993	{
	1994	UInt uiCode;
	1995	m_pcTDecBinIf->decodeBin( uiCode, m_cSaoTypeIdxSCModel.get( 0, 0, 0 ) );
	1996	if (uiCode == 0)
	1997	{
	1998	ruiVal = 0;
	1999	}
	2000	else
	2001	{
	2002	m_pcTDecBinIf->decodeBinEP( uiCode );
	2003	if (uiCode == 0)
	2004	{
	2005	ruiVal = 5;
	2006	}
	2007	else
	2008	{
	2009	ruiVal = 1;
	2010	}
	2011	}
	2012	}
	2013
	2014	inline Void copySaoOneLcuParam(SaoLcuParam* psDst, SaoLcuParam* psSrc)
	2015	{
	2016	Int i;
	2017	psDst->partIdx = psSrc->partIdx;
	2018	psDst->typeIdx = psSrc->typeIdx;
	2019	if (psDst->typeIdx != -1)
	2020	{
	2021	psDst->subTypeIdx = psSrc->subTypeIdx ;
	2022	psDst->length = psSrc->length;
	2023	for (i=0;i<psDst->length;i++)
	2024	{
	2025	psDst->offset[i] = psSrc->offset[i];
	2026	}
	2027	}
	2028	else
	2029	{
	2030	psDst->length = 0;
	2031	for (i=0;i<SAO_BO_LEN;i++)
	2032	{
	2033	psDst->offset[i] = 0;
	2034	}
	2035	}
	2036	}
	2037
	2038	Void TDecSbac::parseSaoOffset(SaoLcuParam* psSaoLcuParam, UInt compIdx)
	2039	{
	2040	UInt uiSymbol;
	2041	static Int iTypeLength[MAX_NUM_SAO_TYPE] =
	2042	{
	2043	SAO_EO_LEN,
	2044	SAO_EO_LEN,
	2045	SAO_EO_LEN,
	2046	SAO_EO_LEN,
	2047	SAO_BO_LEN
	2048	};
	2049
	2050	if (compIdx==2)
	2051	{
	2052	uiSymbol = (UInt)( psSaoLcuParam->typeIdx + 1);
	2053	}
	2054	else
	2055	{
	2056	parseSaoTypeIdx(uiSymbol);
	2057	}
	2058	psSaoLcuParam->typeIdx = (Int)uiSymbol - 1;
	2059
	2060	if (uiSymbol)
	2061	{
	2062	psSaoLcuParam->length = iTypeLength[psSaoLcuParam->typeIdx];
	2063	#if FULL_NBIT
	2064	Int offsetTh = 1 << ( min((Int)(g_uiBitDepth + (g_uiBitDepth-8)-5),5) );
	2065	#else
	2066	Int offsetTh = 1 << ( min((Int)(g_uiBitDepth + g_uiBitIncrement-5),5) );
	2067	#endif
	2068
	2069	if( psSaoLcuParam->typeIdx == SAO_BO )
	2070	{
	2071	for(Int i=0; i< psSaoLcuParam->length; i++)
	2072	{
	2073	parseSaoMaxUvlc(uiSymbol, offsetTh -1 );
	2074	psSaoLcuParam->offset[i] = uiSymbol;
	2075	}
	2076	for(Int i=0; i< psSaoLcuParam->length; i++)
	2077	{
	2078	if (psSaoLcuParam->offset[i] != 0)
	2079	{
	2080	m_pcTDecBinIf->decodeBinEP ( uiSymbol);
	2081	if (uiSymbol)
	2082	{
	2083	psSaoLcuParam->offset[i] = -psSaoLcuParam->offset[i] ;
	2084	}
	2085	}
	2086	}
	2087	parseSaoUflc(5, uiSymbol );
	2088	psSaoLcuParam->subTypeIdx = uiSymbol;
	2089	}
	2090	else if( psSaoLcuParam->typeIdx < 4 )
	2091	{
	2092	parseSaoMaxUvlc(uiSymbol, offsetTh -1 ); psSaoLcuParam->offset[0] = uiSymbol;
	2093	parseSaoMaxUvlc(uiSymbol, offsetTh -1 ); psSaoLcuParam->offset[1] = uiSymbol;
	2094	parseSaoMaxUvlc(uiSymbol, offsetTh -1 ); psSaoLcuParam->offset[2] = -(Int)uiSymbol;
	2095	parseSaoMaxUvlc(uiSymbol, offsetTh -1 ); psSaoLcuParam->offset[3] = -(Int)uiSymbol;
	2096	if (compIdx != 2)
	2097	{
	2098	parseSaoUflc(2, uiSymbol );
	2099	psSaoLcuParam->subTypeIdx = uiSymbol;
	2100	psSaoLcuParam->typeIdx += psSaoLcuParam->subTypeIdx;
	2101	}
	2102	}
	2103	}
	2104	else
	2105	{
	2106	psSaoLcuParam->length = 0;
	2107	}
	2108	}
	2109
	2110	Void TDecSbac::parseSaoOneLcuInterleaving(Int rx, Int ry, SAOParam* pSaoParam, TComDataCU* pcCU, Int iCUAddrInSlice, Int iCUAddrUpInSlice, Int allowMergeLeft, Int allowMergeUp)
	2111	{
	2112	Int iAddr = pcCU->getAddr();
	2113	UInt uiSymbol;
	2114
	2115	for (Int iCompIdx=0; iCompIdx<3; iCompIdx++)
	2116	{
	2117	pSaoParam->saoLcuParam[iCompIdx][iAddr].mergeUpFlag = 0;
	2118	pSaoParam->saoLcuParam[iCompIdx][iAddr].mergeLeftFlag = 0;
	2119	pSaoParam->saoLcuParam[iCompIdx][iAddr].subTypeIdx = 0;
	2120	pSaoParam->saoLcuParam[iCompIdx][iAddr].typeIdx =-1;
	2121	pSaoParam->saoLcuParam[iCompIdx][iAddr].offset[0] = 0;
	2122	pSaoParam->saoLcuParam[iCompIdx][iAddr].offset[1] = 0;
	2123	pSaoParam->saoLcuParam[iCompIdx][iAddr].offset[2] = 0;
	2124	pSaoParam->saoLcuParam[iCompIdx][iAddr].offset[3] = 0;
	2125	}
	2126	if (pSaoParam->bSaoFlag[0] \|\| pSaoParam->bSaoFlag[1] )
	2127	{
	2128	if (rx>0 && iCUAddrInSlice!=0 && allowMergeLeft)
	2129	{
	2130	parseSaoMerge(uiSymbol);
	2131	pSaoParam->saoLcuParam[0][iAddr].mergeLeftFlag = (Bool)uiSymbol;
	2132	}
	2133	if (pSaoParam->saoLcuParam[0][iAddr].mergeLeftFlag==0)
	2134	{
	2135	if ((ry > 0) && (iCUAddrUpInSlice>=0) && allowMergeUp)
	2136	{
	2137	parseSaoMerge(uiSymbol);
	2138	pSaoParam->saoLcuParam[0][iAddr].mergeUpFlag = (Bool)uiSymbol;
	2139	}
	2140	}
	2141	}
	2142
	2143	for (Int iCompIdx=0; iCompIdx<3; iCompIdx++)
	2144	{
	2145	if ((iCompIdx == 0 && pSaoParam->bSaoFlag[0]) \|\| (iCompIdx > 0 && pSaoParam->bSaoFlag[1]) )
	2146	{
	2147	if (rx>0 && iCUAddrInSlice!=0 && allowMergeLeft)
	2148	{
	2149	pSaoParam->saoLcuParam[iCompIdx][iAddr].mergeLeftFlag = pSaoParam->saoLcuParam[0][iAddr].mergeLeftFlag;
	2150	}
	2151	else
	2152	{
	2153	pSaoParam->saoLcuParam[iCompIdx][iAddr].mergeLeftFlag = 0;
	2154	}
	2155
	2156	if (pSaoParam->saoLcuParam[iCompIdx][iAddr].mergeLeftFlag==0)
	2157	{
	2158	if ((ry > 0) && (iCUAddrUpInSlice>=0) && allowMergeUp)
	2159	{
	2160	pSaoParam->saoLcuParam[iCompIdx][iAddr].mergeUpFlag = pSaoParam->saoLcuParam[0][iAddr].mergeUpFlag;
	2161	}
	2162	else
	2163	{
	2164	pSaoParam->saoLcuParam[iCompIdx][iAddr].mergeUpFlag = 0;
	2165	}
	2166
	2167	if (!pSaoParam->saoLcuParam[iCompIdx][iAddr].mergeUpFlag)
	2168	{
	2169	pSaoParam->saoLcuParam[2][iAddr].typeIdx = pSaoParam->saoLcuParam[1][iAddr].typeIdx;
	2170	parseSaoOffset(&(pSaoParam->saoLcuParam[iCompIdx][iAddr]), iCompIdx);
	2171	}
	2172	else
	2173	{
	2174	copySaoOneLcuParam(&pSaoParam->saoLcuParam[iCompIdx][iAddr], &pSaoParam->saoLcuParam[iCompIdx][iAddr-pSaoParam->numCuInWidth]);
	2175	}
	2176	}
	2177	else
	2178	{
	2179	copySaoOneLcuParam(&pSaoParam->saoLcuParam[iCompIdx][iAddr], &pSaoParam->saoLcuParam[iCompIdx][iAddr-1]);
	2180	}
	2181	}
	2182	else
	2183	{
	2184	pSaoParam->saoLcuParam[iCompIdx][iAddr].typeIdx = -1;
	2185	pSaoParam->saoLcuParam[iCompIdx][iAddr].subTypeIdx = 0;
	2186	}
	2187	}
	2188	}
	2189	#else
[56]	2190	Void TDecSbac::parseSaoUvlc (UInt& ruiVal)
[2]	2191	{
	2192	UInt uiCode;
	2193	Int i;
[56]	2194
	2195	m_pcTDecBinIf->decodeBin( uiCode, m_cSaoUvlcSCModel.get( 0, 0, 0 ) );
[2]	2196	if ( uiCode == 0 )
	2197	{
	2198	ruiVal = 0;
	2199	return;
	2200	}
[56]	2201
[2]	2202	i=1;
	2203	while (1)
	2204	{
[56]	2205	m_pcTDecBinIf->decodeBin( uiCode, m_cSaoUvlcSCModel.get( 0, 0, 1 ) );
[2]	2206	if ( uiCode == 0 ) break;
	2207	i++;
	2208	}
[56]	2209
[2]	2210	ruiVal = i;
	2211	}
	2212
[56]	2213	Void TDecSbac::parseSaoSvlc (Int& riVal)
[2]	2214	{
	2215	UInt uiCode;
	2216	Int iSign;
	2217	Int i;
[56]	2218
	2219	m_pcTDecBinIf->decodeBin( uiCode, m_cSaoSvlcSCModel.get( 0, 0, 0 ) );
	2220
[2]	2221	if ( uiCode == 0 )
	2222	{
	2223	riVal = 0;
	2224	return;
	2225	}
[56]	2226
[2]	2227	// read sign
[56]	2228	m_pcTDecBinIf->decodeBin( uiCode, m_cSaoSvlcSCModel.get( 0, 0, 1 ) );
	2229
	2230	if ( uiCode == 0 )
	2231	{
	2232	iSign = 1;
	2233	}
	2234	else
	2235	{
	2236	iSign = -1;
	2237	}
	2238
[2]	2239	// read magnitude
	2240	i=1;
	2241	while (1)
	2242	{
[56]	2243	m_pcTDecBinIf->decodeBin( uiCode, m_cSaoSvlcSCModel.get( 0, 0, 2 ) );
[2]	2244	if ( uiCode == 0 ) break;
	2245	i++;
	2246	}
[56]	2247
[2]	2248	riVal = i*iSign;
	2249	}
	2250
[56]	2251	Void TDecSbac::parseSaoUflc (UInt& riVal)
[2]	2252	{
	2253	UInt uiSymbol;
[56]	2254	riVal = 0;
	2255	for (Int i=0;i<5;i++)
	2256	{
	2257	m_pcTDecBinIf->decodeBinEP ( uiSymbol );
	2258	if (uiSymbol)
	2259	{
	2260	riVal \|= (1<<i);
	2261	}
	2262	}
[2]	2263	}
[56]	2264	Void TDecSbac::parseSaoMergeLeft (UInt& ruiVal, UInt uiCompIdx)
	2265	{
	2266	UInt uiCode;
	2267	m_pcTDecBinIf->decodeBin( uiCode, m_cSaoMergeLeftSCModel.get( 0, 0, uiCompIdx ) );
	2268	ruiVal = (Int)uiCode;
	2269	}
[2]	2270
[56]	2271	Void TDecSbac::parseSaoMergeUp (UInt& ruiVal)
[2]	2272	{
	2273	UInt uiCode;
[56]	2274	m_pcTDecBinIf->decodeBin( uiCode, m_cSaoMergeUpSCModel.get( 0, 0, 0 ) );
	2275	ruiVal = (Int)uiCode;
	2276	}
	2277	Void TDecSbac::parseSaoTypeIdx (UInt& ruiVal)
	2278	{
	2279	UInt uiCode;
[2]	2280	Int i;
[56]	2281	m_pcTDecBinIf->decodeBin( uiCode, m_cSaoTypeIdxSCModel.get( 0, 0, 0 ) );
[2]	2282	if ( uiCode == 0 )
	2283	{
	2284	ruiVal = 0;
	2285	return;
	2286	}
	2287	i=1;
	2288	while (1)
	2289	{
[56]	2290	m_pcTDecBinIf->decodeBin( uiCode, m_cSaoTypeIdxSCModel.get( 0, 0, 1 ) );
[2]	2291	if ( uiCode == 0 ) break;
	2292	i++;
	2293	}
	2294	ruiVal = i;
	2295	}
	2296
[56]	2297	inline Void copySaoOneLcuParam(SaoLcuParam* psDst, SaoLcuParam* psSrc)
[2]	2298	{
[56]	2299	Int i;
	2300	psDst->partIdx = psSrc->partIdx;
	2301	psDst->typeIdx = psSrc->typeIdx;
	2302	if (psDst->typeIdx != -1)
	2303	{
	2304	if (psDst->typeIdx == SAO_BO)
	2305	{
	2306	psDst->bandPosition = psSrc->bandPosition ;
	2307	}
	2308	else
	2309	{
	2310	psDst->bandPosition = 0;
	2311	}
	2312	psDst->length = psSrc->length;
	2313	for (i=0;i<psDst->length;i++)
	2314	{
	2315	psDst->offset[i] = psSrc->offset[i];
	2316	}
	2317	}
	2318	else
	2319	{
	2320	psDst->length = 0;
	2321	for (i=0;i<SAO_BO_LEN;i++)
	2322	{
	2323	psDst->offset[i] = 0;
	2324	}
	2325	}
	2326	}
	2327	Void TDecSbac::parseSaoOffset(SaoLcuParam* psSaoLcuParam)
	2328	{
	2329	UInt uiSymbol;
	2330	Int iSymbol;
	2331	static Int iTypeLength[MAX_NUM_SAO_TYPE] = {
	2332	SAO_EO_LEN,
	2333	SAO_EO_LEN,
	2334	SAO_EO_LEN,
	2335	SAO_EO_LEN,
	2336	SAO_BO_LEN
	2337	};
[2]	2338
[56]	2339	parseSaoTypeIdx(uiSymbol);
	2340	psSaoLcuParam->typeIdx = (Int)uiSymbol - 1;
	2341	if (uiSymbol)
	2342	{
	2343	psSaoLcuParam->length = iTypeLength[psSaoLcuParam->typeIdx];
	2344	if( psSaoLcuParam->typeIdx == SAO_BO )
	2345	{
	2346	// Parse Left Band Index
	2347	parseSaoUflc( uiSymbol );
	2348	psSaoLcuParam->bandPosition = uiSymbol;
	2349	for(Int i=0; i< psSaoLcuParam->length; i++)
	2350	{
	2351	parseSaoSvlc(iSymbol);
	2352	psSaoLcuParam->offset[i] = iSymbol;
	2353	}
	2354	}
	2355	else if( psSaoLcuParam->typeIdx < 4 )
	2356	{
	2357	parseSaoUvlc(uiSymbol); psSaoLcuParam->offset[0] = uiSymbol;
	2358	parseSaoUvlc(uiSymbol); psSaoLcuParam->offset[1] = uiSymbol;
	2359	parseSaoUvlc(uiSymbol); psSaoLcuParam->offset[2] = -(Int)uiSymbol;
	2360	parseSaoUvlc(uiSymbol); psSaoLcuParam->offset[3] = -(Int)uiSymbol;
	2361	}
	2362	}
	2363	else
	2364	{
	2365	psSaoLcuParam->length = 0;
	2366	}
	2367	}
[2]	2368
[56]	2369	Void TDecSbac::parseSaoOneLcuInterleaving(Int rx, Int ry, SAOParam* pSaoParam, TComDataCU* pcCU, Int iCUAddrInSlice, Int iCUAddrUpInSlice, Bool bLFCrossSliceBoundaryFlag)
	2370	{
	2371	Int iAddr = pcCU->getAddr();
	2372	UInt uiSymbol;
	2373	for (Int iCompIdx=0; iCompIdx<3; iCompIdx++)
[2]	2374	{
[56]	2375	pSaoParam->saoLcuParam[iCompIdx][iAddr].mergeUpFlag = 0;
	2376	pSaoParam->saoLcuParam[iCompIdx][iAddr].mergeLeftFlag = 0;
	2377	pSaoParam->saoLcuParam[iCompIdx][iAddr].bandPosition = 0;
	2378	pSaoParam->saoLcuParam[iCompIdx][iAddr].typeIdx = -1;
	2379	pSaoParam->saoLcuParam[iCompIdx][iAddr].offset[0] = 0;
	2380	pSaoParam->saoLcuParam[iCompIdx][iAddr].offset[1] = 0;
	2381	pSaoParam->saoLcuParam[iCompIdx][iAddr].offset[2] = 0;
	2382	pSaoParam->saoLcuParam[iCompIdx][iAddr].offset[3] = 0;
	2383
	2384	if (pSaoParam->bSaoFlag[iCompIdx])
	2385	{
	2386	if (rx>0 && iCUAddrInSlice!=0)
	2387	{
	2388	parseSaoMergeLeft(uiSymbol,iCompIdx); pSaoParam->saoLcuParam[iCompIdx][iAddr].mergeLeftFlag = (Int)uiSymbol;
	2389	}
	2390	else
	2391	{
	2392	pSaoParam->saoLcuParam[iCompIdx][iAddr].mergeLeftFlag = 0;
	2393	}
	2394
	2395	if (pSaoParam->saoLcuParam[iCompIdx][iAddr].mergeLeftFlag==0)
	2396	{
	2397	if ((ry > 0) && (iCUAddrUpInSlice>0\|\|bLFCrossSliceBoundaryFlag))
	2398	{
	2399	parseSaoMergeUp(uiSymbol); pSaoParam->saoLcuParam[iCompIdx][iAddr].mergeUpFlag = uiSymbol;
	2400	}
	2401	else
	2402	{
	2403	pSaoParam->saoLcuParam[iCompIdx][iAddr].mergeUpFlag = 0;
	2404	}
	2405	if (!pSaoParam->saoLcuParam[iCompIdx][iAddr].mergeUpFlag)
	2406	{
	2407	parseSaoOffset(&(pSaoParam->saoLcuParam[iCompIdx][iAddr]));
	2408	}
	2409	else
	2410	{
	2411	copySaoOneLcuParam(&pSaoParam->saoLcuParam[iCompIdx][iAddr], &pSaoParam->saoLcuParam[iCompIdx][iAddr-pSaoParam->numCuInWidth]);
	2412	}
	2413	}
	2414	else
	2415	{
	2416	copySaoOneLcuParam(&pSaoParam->saoLcuParam[iCompIdx][iAddr], &pSaoParam->saoLcuParam[iCompIdx][iAddr-1]);
	2417	}
	2418	}
	2419	else
	2420	{
	2421	pSaoParam->saoLcuParam[iCompIdx][iAddr].typeIdx = -1;
	2422	pSaoParam->saoLcuParam[iCompIdx][iAddr].bandPosition = 0;
	2423	}
[2]	2424	}
[56]	2425	}
[443]	2426	#endif
[56]	2427	/**
	2428	- Initialize our contexts from the nominated source.
	2429	.
	2430	\param pSrc Contexts to be copied.
	2431	*/
	2432	Void TDecSbac::xCopyContextsFrom( TDecSbac* pSrc )
	2433	{
	2434	memcpy(m_contextModels, pSrc->m_contextModels, m_numContextModels*sizeof(m_contextModels[0]));
	2435	}
[2]	2436
[56]	2437	Void TDecSbac::xCopyFrom( TDecSbac* pSrc )
	2438	{
	2439	m_pcTDecBinIf->copyState( pSrc->m_pcTDecBinIf );
[2]	2440
[56]	2441	m_uiLastQp = pSrc->m_uiLastQp;
	2442	xCopyContextsFrom( pSrc );
	2443
	2444	}
	2445
	2446	Void TDecSbac::load ( TDecSbac* pScr )
	2447	{
	2448	xCopyFrom(pScr);
	2449	}
	2450
	2451	Void TDecSbac::loadContexts ( TDecSbac* pScr )
	2452	{
	2453	xCopyContextsFrom(pScr);
	2454	}
	2455
	2456	Void TDecSbac::decodeFlush ( )
	2457	{
	2458	UInt uiBit;
	2459	m_pcTDecBinIf->decodeBinTrm(uiBit);
	2460	m_pcTDecBinIf->flush();
	2461
	2462	}
	2463
[189]	2464	#if HHI_DMM_WEDGE_INTRA \|\| HHI_DMM_PRED_TEX \|\| (LGE_EDGE_INTRA_A0070 && LGE_EDGE_INTRA_DELTA_DC)
[56]	2465	Void TDecSbac::xReadExGolombLevel( UInt& ruiSymbol, ContextModel& rcSCModel )
	2466	{
	2467	UInt uiSymbol;
	2468	UInt uiCount = 0;
	2469	do
[2]	2470	{
[56]	2471	m_pcTDecBinIf->decodeBin( uiSymbol, rcSCModel );
	2472	uiCount++;
[2]	2473	}
[56]	2474	while( uiSymbol && ( uiCount != 13 ) );
[2]	2475
[56]	2476	ruiSymbol = uiCount - 1;
	2477
	2478	if( uiSymbol )
	2479	{
	2480	xReadEpExGolomb( uiSymbol, 0 );
	2481	ruiSymbol += uiSymbol + 1;
	2482	}
	2483
	2484	return;
[2]	2485	}
	2486	#endif
[56]	2487	#if HHI_DMM_WEDGE_INTRA
	2488	Void TDecSbac::xParseWedgeFullInfo( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
	2489	{
	2490	Int iIntraIdx = pcCU->getIntraSizeIdx(uiAbsPartIdx);
	2491	Int iBits = g_aucWedgeFullBitsListIdx[iIntraIdx];
	2492
	2493	UInt uiSymbol, uiTabIdx = 0;
	2494	for ( Int i = 0; i < iBits; i++ )
	2495	{
	2496	m_pcTDecBinIf->decodeBin( uiSymbol, m_cDmmDataSCModel.get(0, 0, 0) );
	2497	uiTabIdx += ( uiSymbol && i == 0 ) ? 1 : 0;
	2498	uiTabIdx += ( uiSymbol && i == 1 ) ? 2 : 0;
	2499	uiTabIdx += ( uiSymbol && i == 2 ) ? 4 : 0;
	2500	uiTabIdx += ( uiSymbol && i == 3 ) ? 8 : 0;
	2501	uiTabIdx += ( uiSymbol && i == 4 ) ? 16 : 0;
	2502	uiTabIdx += ( uiSymbol && i == 5 ) ? 32 : 0;
	2503	uiTabIdx += ( uiSymbol && i == 6 ) ? 64 : 0;
	2504	uiTabIdx += ( uiSymbol && i == 7 ) ? 128 : 0;
	2505	uiTabIdx += ( uiSymbol && i == 8 ) ? 256 : 0;
	2506	uiTabIdx += ( uiSymbol && i == 9 ) ? 512 : 0;
	2507	uiTabIdx += ( uiSymbol && i == 10 ) ? 1024 : 0;
	2508	uiTabIdx += ( uiSymbol && i == 11 ) ? 2048 : 0;
	2509	uiTabIdx += ( uiSymbol && i == 12 ) ? 4096 : 0;
	2510	}
	2511
	2512	pcCU->setWedgeFullTabIdxSubParts( uiTabIdx, uiAbsPartIdx, uiDepth );
	2513	}
	2514
	2515	Void TDecSbac::xParseWedgeFullDeltaInfo( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
	2516	{
	2517	Int iIntraIdx = pcCU->getIntraSizeIdx(uiAbsPartIdx);
	2518	Int iBits = g_aucWedgeFullBitsListIdx[iIntraIdx];
	2519
	2520	UInt uiSymbol, uiTabIdx = 0;
	2521	for ( Int i = 0; i < iBits; i++ )
	2522	{
	2523	m_pcTDecBinIf->decodeBin( uiSymbol, m_cDmmDataSCModel.get(0, 0, 0) );
	2524	uiTabIdx += ( uiSymbol && i == 0 ) ? 1 : 0;
	2525	uiTabIdx += ( uiSymbol && i == 1 ) ? 2 : 0;
	2526	uiTabIdx += ( uiSymbol && i == 2 ) ? 4 : 0;
	2527	uiTabIdx += ( uiSymbol && i == 3 ) ? 8 : 0;
	2528	uiTabIdx += ( uiSymbol && i == 4 ) ? 16 : 0;
	2529	uiTabIdx += ( uiSymbol && i == 5 ) ? 32 : 0;
	2530	uiTabIdx += ( uiSymbol && i == 6 ) ? 64 : 0;
	2531	uiTabIdx += ( uiSymbol && i == 7 ) ? 128 : 0;
	2532	uiTabIdx += ( uiSymbol && i == 8 ) ? 256 : 0;
	2533	uiTabIdx += ( uiSymbol && i == 9 ) ? 512 : 0;
	2534	uiTabIdx += ( uiSymbol && i == 10 ) ? 1024 : 0;
	2535	uiTabIdx += ( uiSymbol && i == 11 ) ? 2048 : 0;
	2536	uiTabIdx += ( uiSymbol && i == 12 ) ? 4096 : 0;
	2537	}
	2538
	2539	pcCU->setWedgeFullTabIdxSubParts( uiTabIdx, uiAbsPartIdx, uiDepth );
	2540
	2541	UInt uiDC1, uiDC2;
	2542	xReadExGolombLevel( uiDC1, m_cDmmDataSCModel.get(0, 0, 1) );
	2543	Int iDC1 = uiDC1;
	2544	if ( uiDC1 )
	2545	{
	2546	UInt uiSign;
	2547	m_pcTDecBinIf->decodeBinEP( uiSign );
	2548	if ( uiSign )
	2549	{
	2550	iDC1 = -iDC1;
	2551	}
	2552	}
	2553	xReadExGolombLevel( uiDC2, m_cDmmDataSCModel.get(0, 0, 1) );
	2554	Int iDC2 = uiDC2;
	2555	if ( uiDC2 )
	2556	{
	2557	UInt uiSign;
	2558	m_pcTDecBinIf->decodeBinEP( uiSign );
	2559	if ( uiSign )
	2560	{
	2561	iDC2 = -iDC2;
	2562	}
	2563	}
	2564
	2565	pcCU->setWedgeFullDeltaDC1SubParts( iDC1, uiAbsPartIdx, uiDepth );
	2566	pcCU->setWedgeFullDeltaDC2SubParts( iDC2, uiAbsPartIdx, uiDepth );
	2567	}
	2568
	2569	Void TDecSbac::xParseWedgePredDirInfo( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
	2570	{
	2571	if( DMM_WEDGE_PREDDIR_DELTAEND_MAX > 0 )
	2572	{
	2573	UInt uiDeltaEnd = 0;
	2574	m_pcTDecBinIf->decodeBin( uiDeltaEnd, m_cDmmDataSCModel.get(0, 0, 2) );
	2575
	2576	Int iDeltaEnd;
	2577	if( uiDeltaEnd != 0 )
	2578	{
	2579	UInt uiAbsValMinus1;
	2580	UInt uiSymbol;
	2581	m_pcTDecBinIf->decodeBin( uiSymbol, m_cDmmDataSCModel.get(0, 0, 2) ); uiAbsValMinus1 = uiSymbol;
	2582	m_pcTDecBinIf->decodeBin( uiSymbol, m_cDmmDataSCModel.get(0, 0, 2) ); uiAbsValMinus1 \|= uiSymbol << 1;
	2583	uiDeltaEnd = uiAbsValMinus1 + 1;
	2584
	2585	iDeltaEnd = uiDeltaEnd;
	2586	UInt uiSign;
	2587	m_pcTDecBinIf->decodeBinEP( uiSign );
	2588	if( uiSign )
	2589	{
	2590	iDeltaEnd = -iDeltaEnd;
	2591	}
	2592	}
	2593	else
	2594	{
	2595	iDeltaEnd = 0;
	2596	}
	2597	pcCU->setWedgePredDirDeltaEndSubParts( iDeltaEnd, uiAbsPartIdx, uiDepth );
	2598	}
	2599	}
	2600
	2601	Void TDecSbac::xParseWedgePredDirDeltaInfo( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
	2602	{
	2603	if( DMM_WEDGE_PREDDIR_DELTAEND_MAX > 0 )
	2604	{
	2605	UInt uiDeltaEnd = 0;
	2606	m_pcTDecBinIf->decodeBin( uiDeltaEnd, m_cDmmDataSCModel.get(0, 0, 2) );
	2607
	2608	Int iDeltaEnd;
	2609	if( uiDeltaEnd != 0 )
	2610	{
	2611	UInt uiAbsValMinus1;
	2612	UInt uiSymbol;
	2613	m_pcTDecBinIf->decodeBin( uiSymbol, m_cDmmDataSCModel.get(0, 0, 2) ); uiAbsValMinus1 = uiSymbol;
	2614	m_pcTDecBinIf->decodeBin( uiSymbol, m_cDmmDataSCModel.get(0, 0, 2) ); uiAbsValMinus1 \|= uiSymbol << 1;
	2615	uiDeltaEnd = uiAbsValMinus1 + 1;
	2616
	2617	iDeltaEnd = uiDeltaEnd;
	2618	UInt uiSign;
	2619	m_pcTDecBinIf->decodeBinEP( uiSign );
	2620	if( uiSign )
	2621	{
	2622	iDeltaEnd = -iDeltaEnd;
	2623	}
	2624	}
	2625	else
	2626	{
	2627	iDeltaEnd = 0;
	2628	}
	2629
	2630	pcCU->setWedgePredDirDeltaEndSubParts( iDeltaEnd, uiAbsPartIdx, uiDepth );
	2631	}
	2632
	2633	UInt uiDC1, uiDC2;
	2634	xReadExGolombLevel( uiDC1, m_cDmmDataSCModel.get(0, 0, 1) );
	2635	Int iDC1 = uiDC1;
	2636	if ( uiDC1 )
	2637	{
	2638	UInt uiSign;
	2639	m_pcTDecBinIf->decodeBinEP( uiSign );
	2640	if ( uiSign )
	2641	{
	2642	iDC1 = -iDC1;
	2643	}
	2644	}
	2645	xReadExGolombLevel( uiDC2, m_cDmmDataSCModel.get(0, 0, 1) );
	2646	Int iDC2 = uiDC2;
	2647	if ( uiDC2 )
	2648	{
	2649	UInt uiSign;
	2650	m_pcTDecBinIf->decodeBinEP( uiSign );
	2651	if ( uiSign )
	2652	{
	2653	iDC2 = -iDC2;
	2654	}
	2655	}
	2656
	2657	pcCU->setWedgePredDirDeltaDC1SubParts( iDC1, uiAbsPartIdx, uiDepth );
	2658	pcCU->setWedgePredDirDeltaDC2SubParts( iDC2, uiAbsPartIdx, uiDepth );
	2659	}
	2660	#endif
	2661	#if HHI_DMM_PRED_TEX
[296]	2662	#if LGE_DMM3_SIMP_C0044
	2663	Void TDecSbac::xParseWedgePredTexInfo( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
	2664	{
	2665	Int iIntraIdx = pcCU->getIntraSizeIdx(uiAbsPartIdx);
	2666	Int iBits = g_aucWedgeTexPredBitsListIdx[iIntraIdx];
	2667
	2668	UInt uiSymbol, uiTabIdx = 0;
	2669	for ( Int i = 0; i < iBits; i++ )
	2670	{
	2671	m_pcTDecBinIf->decodeBin( uiSymbol, m_cDmmDataSCModel.get(0, 0, 3) );
	2672	uiTabIdx += ( uiSymbol && i == 0 ) ? 1 : 0;
	2673	uiTabIdx += ( uiSymbol && i == 1 ) ? 2 : 0;
	2674	uiTabIdx += ( uiSymbol && i == 2 ) ? 4 : 0;
	2675	uiTabIdx += ( uiSymbol && i == 3 ) ? 8 : 0;
	2676	uiTabIdx += ( uiSymbol && i == 4 ) ? 16 : 0;
	2677	uiTabIdx += ( uiSymbol && i == 5 ) ? 32 : 0;
	2678	uiTabIdx += ( uiSymbol && i == 6 ) ? 64 : 0;
	2679	uiTabIdx += ( uiSymbol && i == 7 ) ? 128 : 0;
	2680	uiTabIdx += ( uiSymbol && i == 8 ) ? 256 : 0;
	2681	uiTabIdx += ( uiSymbol && i == 9 ) ? 512 : 0;
	2682	uiTabIdx += ( uiSymbol && i == 10 ) ? 1024 : 0;
	2683	}
	2684
	2685	pcCU->setWedgePredTexIntraTabIdxSubParts( uiTabIdx, uiAbsPartIdx, uiDepth );
	2686	}
	2687	#endif
	2688
[56]	2689	Void TDecSbac::xParseWedgePredTexDeltaInfo( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
	2690	{
[296]	2691	#if LGE_DMM3_SIMP_C0044
	2692	xParseWedgePredTexInfo( pcCU, uiAbsPartIdx, uiDepth );
	2693	#endif
[56]	2694	UInt uiDC1, uiDC2;
	2695	xReadExGolombLevel( uiDC1, m_cDmmDataSCModel.get(0, 0, 1) );
	2696	Int iDC1 = uiDC1;
	2697	if ( uiDC1 )
	2698	{
	2699	UInt uiSign;
	2700	m_pcTDecBinIf->decodeBinEP( uiSign );
	2701	if ( uiSign )
	2702	{
	2703	iDC1 = -iDC1;
	2704	}
	2705	}
	2706	xReadExGolombLevel( uiDC2, m_cDmmDataSCModel.get(0, 0, 1) );
	2707	Int iDC2 = uiDC2;
	2708	if ( uiDC2 )
	2709	{
	2710	UInt uiSign;
	2711	m_pcTDecBinIf->decodeBinEP( uiSign );
	2712	if ( uiSign )
	2713	{
	2714	iDC2 = -iDC2;
	2715	}
	2716	}
	2717
	2718	pcCU->setWedgePredTexDeltaDC1SubParts( iDC1, uiAbsPartIdx, uiDepth );
	2719	pcCU->setWedgePredTexDeltaDC2SubParts( iDC2, uiAbsPartIdx, uiDepth );
	2720	}
	2721
	2722	Void TDecSbac::xParseContourPredTexDeltaInfo( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
	2723	{
	2724	UInt uiDC1, uiDC2;
	2725	xReadExGolombLevel( uiDC1, m_cDmmDataSCModel.get(0, 0, 1) );
	2726	Int iDC1 = uiDC1;
	2727	if ( uiDC1 )
	2728	{
	2729	UInt uiSign;
	2730	m_pcTDecBinIf->decodeBinEP( uiSign );
	2731	if ( uiSign )
	2732	{
	2733	iDC1 = -iDC1;
	2734	}
	2735	}
	2736	xReadExGolombLevel( uiDC2, m_cDmmDataSCModel.get(0, 0, 1) );
	2737	Int iDC2 = uiDC2;
	2738	if ( uiDC2 )
	2739	{
	2740	UInt uiSign;
	2741	m_pcTDecBinIf->decodeBinEP( uiSign );
	2742	if ( uiSign )
	2743	{
	2744	iDC2 = -iDC2;
	2745	}
	2746	}
	2747
	2748	pcCU->setContourPredTexDeltaDC1SubParts( iDC1, uiAbsPartIdx, uiDepth );
	2749	pcCU->setContourPredTexDeltaDC2SubParts( iDC2, uiAbsPartIdx, uiDepth );
	2750	}
	2751	#endif
[443]	2752	#if QC_ARP_D0177
	2753	Void TDecSbac::parseARPW( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
	2754	{
	2755	UInt nMaxW = pcCU->getSlice()->getARPStepNum() - 1;
	2756	#if !QC_ARP_WARNING_FIX
	2757	assert (nMaxW >= 0);
	2758	#endif
	2759	UInt nW = 0;
	2760	if( nMaxW > 0 )
	2761	{
	2762	UInt nOffset = pcCU->getCTXARPWFlag(uiAbsPartIdx);
	2763	#if !QC_ARP_WARNING_FIX
	2764	assert( 0 <= nOffset && nOffset <= 2 );
	2765	#endif
	2766	UInt uiCode = 0;
	2767	m_pcTDecBinIf->decodeBin( uiCode , m_cCUPUARPW.get( 0, 0, 0 + nOffset ) );
	2768	nW = uiCode;
	2769	if( nW == 1 )
	2770	{
	2771	m_pcTDecBinIf->decodeBin( uiCode , m_cCUPUARPW.get( 0, 0, 3 ) );
	2772	nW += ( uiCode == 1 );
	2773	}
	2774	}
	2775	pcCU->setARPWSubParts( ( UChar )( nW ) , uiAbsPartIdx, uiDepth );
	2776	}
	2777	#endif
[189]	2778	#if LGE_EDGE_INTRA_A0070
[100]	2779	Void TDecSbac::xParseEdgeIntraInfo( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
	2780	{
	2781	UInt uiSymbol = 0;
	2782
	2783	// 1. Top(0) or Left(1)
	2784	UChar ucLeft;
	2785	m_pcTDecBinIf->decodeBinEP( uiSymbol );
	2786	ucLeft = uiSymbol;
	2787
	2788	// 2. Start position (lowest bit first)
	2789	UChar ucStart = 0;
	2790	for( UInt ui = 0; ui < 6 - uiDepth; ui++ )
	2791	{
	2792	m_pcTDecBinIf->decodeBinEP( uiSymbol );
	2793	ucStart \|= (uiSymbol << ui);
	2794	}
	2795
	2796	// 3. Number of edges
	2797	UChar ucMax = 0;
	2798	for( UInt ui = 0; ui < 7 - uiDepth; ui++ )
	2799	{
	2800	m_pcTDecBinIf->decodeBinEP( uiSymbol );
	2801	ucMax \|= (uiSymbol << ui);
	2802	}
	2803	ucMax++; // +1
	2804
	2805	// 4. Edges
	2806	UChar* pucSymbolList = (UChar) xMalloc( UChar, 256 LGE_EDGE_INTRA_MAX_EDGE_NUM_PER_4x4 );
	2807	UInt uiCtxEdgeIntra = pcCU->getCtxEdgeIntra( uiAbsPartIdx );
	2808	for( Int iPtr = 0; iPtr < ucMax; iPtr++ )
	2809	{
	2810	UChar ucEdge = 0;
	2811	UInt uiReorderEdge = 0;
	2812	// Left-friendly direction
	2813	// 0 ( 0deg) => 0
	2814	// 1 ( 45deg) => 10
	2815	// 2 ( -45deg) => 110
	2816	// 3 ( 90deg) => 1110
	2817	// 4 ( -90deg) => 11110
	2818	// 5 ( 135deg) => 111110
	2819	// 6 (-135deg) => 111111
	2820	// Right-friendly direction
	2821	// 0 ( 0deg) => 0
	2822	// 1 ( -45deg) => 10
	2823	// 2 ( 45deg) => 110
	2824	// 3 ( -90deg) => 1110
	2825	// 4 ( 90deg) => 11110
	2826	// 5 (-135deg) => 111110
	2827	// 6 ( 135deg) => 111111
	2828	// refer to a paper "An efficient chain code with Huffman coding"
	2829	for( UInt ui = 0; ui < 6; ui++ )
	2830	{
	2831	m_pcTDecBinIf->decodeBin( uiSymbol, m_cEdgeIntraSCModel.get( 0, 0, uiCtxEdgeIntra ) );
	2832	ucEdge <<= 1;
	2833	ucEdge \|= uiSymbol;
	2834	if( uiSymbol == 0 )
	2835	break;
	2836	}
	2837
	2838	switch( ucEdge )
	2839	{
	2840	case 0 : // "0"
	2841	uiReorderEdge = 0;
	2842	break;
	2843	case 2 : // "10"
	2844	uiReorderEdge = 1;
	2845	break;
	2846	case 6 : // "110"
	2847	uiReorderEdge = 2;
	2848	break;
	2849	case 14 : // "1110"
	2850	uiReorderEdge = 3;
	2851	break;
	2852	case 30 : // "11110"
	2853	uiReorderEdge = 4;
	2854	break;
	2855	case 62 : // "111110"
	2856	uiReorderEdge = 5;
	2857	break;
	2858	case 63 : // "111111"
	2859	uiReorderEdge = 6;
	2860	break;
	2861	default :
	2862	printf("parseIntraEdgeChain: error (unknown code %d)\n",ucEdge);
	2863	assert(false);
	2864	break;
	2865	}
	2866	pucSymbolList[iPtr] = uiReorderEdge;
	2867	}
	2868	/////////////////////
	2869	// Edge Reconstruction
	2870	Bool* pbRegion = pcCU->getEdgePartition( uiAbsPartIdx );
	2871	pcCU->reconPartition( uiAbsPartIdx, uiDepth, ucLeft == 1, ucStart, ucMax, pucSymbolList, pbRegion );
	2872	xFree( pucSymbolList );
	2873	}
	2874	#endif
[189]	2875
	2876	#if RWTH_SDC_DLT_B0036
[443]	2877	#if !PKU_QC_DEPTH_INTRA_UNI_D0195
[189]	2878	Void TDecSbac::parseSDCFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
	2879	{
	2880	assert( pcCU->getSlice()->getSPS()->isDepth() );
	2881
	2882	UInt uiSymbol = 0;
	2883	UInt uiCtxSDCFlag = pcCU->getCtxSDCFlag( uiAbsPartIdx );
	2884	m_pcTDecBinIf->decodeBin( uiSymbol, m_cSDCFlagSCModel.get( 0, 0, uiCtxSDCFlag ) );
	2885
	2886	if( uiSymbol == 1 )
	2887	{
	2888	pcCU->setPartSizeSubParts(SIZE_2Nx2N, uiAbsPartIdx, uiDepth);
	2889
	2890	pcCU->setSDCFlagSubParts( true, uiAbsPartIdx, 0, uiDepth);
	2891	pcCU->setTrIdxSubParts(0, uiAbsPartIdx, uiDepth);
	2892	pcCU->setCbfSubParts(1, 1, 1, uiAbsPartIdx, uiDepth);
	2893	}
	2894	}
[100]	2895
[189]	2896	Void TDecSbac::parseSDCPredMode( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
	2897	{
	2898	assert( pcCU->getSlice()->getSPS()->isDepth() );
	2899	assert( pcCU->getPartitionSize(uiAbsPartIdx) == SIZE_2Nx2N );
	2900
	2901	assert( pcCU->getSDCFlag(uiAbsPartIdx) );
	2902
	2903	UInt uiCtx = 0;
	2904
	2905	UInt uiMPModeIdx = 0;
	2906
	2907	for(Int i=0; i<RWTH_SDC_NUM_PRED_MODES-1; i++)
	2908	{
	2909	UInt uiIsMostProb = 0;
[443]	2910	#if INTEL_SDC64_D0193
	2911	if( !(pcCU->getWidth(uiAbsPartIdx) == 64 && i == 1))
	2912	#endif
[189]	2913	m_pcTDecBinIf->decodeBin( uiIsMostProb, m_cSDCPredModeSCModel.get( 0, i, uiCtx ) );
	2914
	2915	if ( uiIsMostProb == 1 )
	2916	break;
	2917
	2918	// else: get next most probable pred mode
	2919	uiMPModeIdx = (uiMPModeIdx+1)%RWTH_SDC_NUM_PRED_MODES;
	2920	}
	2921
	2922	Int intraPredMode = g_auiSDCPredModes[uiMPModeIdx];
	2923
	2924	#if HHI_DMM_WEDGE_INTRA
	2925	if( intraPredMode == DMM_WEDGE_FULL_IDX ) { xParseWedgeFullInfo ( pcCU, uiAbsPartIdx, uiDepth ); }
	2926	if( intraPredMode == DMM_WEDGE_PREDDIR_IDX ) { xParseWedgePredDirInfo ( pcCU, uiAbsPartIdx, uiDepth ); }
	2927	#endif
	2928
	2929	pcCU->setLumaIntraDirSubParts((UChar)intraPredMode, uiAbsPartIdx, uiDepth);
	2930	}
[443]	2931	#endif
[189]	2932
	2933	Void TDecSbac::parseSDCResidualData ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, UInt uiSegment )
	2934	{
	2935	assert( pcCU->getSlice()->getSPS()->isDepth() );
	2936	assert( pcCU->getSDCFlag(uiAbsPartIdx) );
	2937	assert( uiSegment < 2 );
	2938
	2939	UInt uiResidual = 0;
	2940	UInt uiBit = 0;
	2941	UInt uiAbsIdx = 0;
	2942	UInt uiSign = 0;
	2943	Int iIdx = 0;
	2944
[443]	2945	UInt uiMaxResidualBits = pcCU->getSlice()->getSPS()->getBitsPerDepthValue();
[189]	2946	assert( uiMaxResidualBits <= g_uiBitDepth );
	2947
[443]	2948	#if RWTH_SDC_CTX_SIMPL_D0032
	2949	m_pcTDecBinIf->decodeBin(uiResidual, m_cSDCResidualFlagSCModel.get( 0, 0, 0 ) );
	2950	#else
[189]	2951	m_pcTDecBinIf->decodeBin(uiResidual, m_cSDCResidualFlagSCModel.get( 0, uiSegment, 0 ) );
[443]	2952	#endif
[189]	2953
	2954	if (uiResidual)
	2955	{
	2956	// decode residual sign bit
[443]	2957	#if RWTH_SDC_CTX_SIMPL_D0032
	2958	m_pcTDecBinIf->decodeBinEP(uiSign);
	2959	#else
[189]	2960	m_pcTDecBinIf->decodeBin(uiSign, m_cSDCResidualSignFlagSCModel.get( 0, uiSegment, 0 ) );
[443]	2961	#endif
[189]	2962
	2963	// decode residual magnitude
[443]	2964	#if LGE_CONCATENATE_D0141
	2965	//prefix part
	2966	UInt uiCount = 0;
	2967	UInt uiNumDepthValues = pcCU->getSlice()->getSPS()->getNumDepthValues();
	2968	UInt uiPrefixThreshold = ((uiNumDepthValues * 3) >> 2);
	2969	for ( UInt ui = 0; ui < uiPrefixThreshold; ui++)
	2970	{
	2971	m_pcTDecBinIf->decodeBin( uiBit, m_cSDCResidualSCModel.get(0, 0, 0) );
	2972	if ( uiBit == 0 )
	2973	break;
	2974	else
	2975	uiCount++;
	2976	}
	2977	//suffix part
	2978	if ( uiCount == uiPrefixThreshold )
	2979	{
	2980	for ( UInt ui = 0; ui < ( (UInt)ceil( Log2(uiNumDepthValues - uiPrefixThreshold) ) ); ui++ )
	2981	{
	2982	m_pcTDecBinIf->decodeBinEP( uiBit );
	2983	uiAbsIdx \|= uiBit << ui;
	2984	}
	2985	uiAbsIdx += uiCount;
	2986	}
	2987	else
	2988	uiAbsIdx = uiCount;
	2989	#else
[189]	2990	for (Int i=0; i<uiMaxResidualBits; i++)
	2991	{
[443]	2992	#if RWTH_SDC_CTX_SIMPL_D0032
	2993	m_pcTDecBinIf->decodeBin(uiBit, m_cSDCResidualSCModel.get( 0, 0, i ) );
	2994	#else
[189]	2995	m_pcTDecBinIf->decodeBin(uiBit, m_cSDCResidualSCModel.get( 0, uiSegment, i ) );
[443]	2996	#endif
[189]	2997	uiAbsIdx \|= uiBit << i;
	2998	}
[443]	2999	#endif
[189]	3000
	3001	uiAbsIdx += 1;
	3002	iIdx =(Int)(uiSign ? -1 : 1)*uiAbsIdx;
	3003	}
	3004
	3005	pcCU->setSDCSegmentDCOffset(iIdx, uiSegment, uiAbsPartIdx);
	3006	}
	3007	#endif
	3008
[56]	3009	//! \}

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

Download in other formats: