Context navigation

TComDataCU.h @ 213

Visit:

Last change on this file since 213 was 213, checked in by mitsubishi-htm, 12 years ago

A final release, as planned

Migrate to HTM 5.1
For VC project files, only VC9 file is updated
To be used as an additional anchor for CE1.h for 3rd JCTVC meeting at Geneva

Property svn:eol-style set to native

File size: 54.7 KB

Line
1	/* The copyright in this software is being made available under the BSD
2	* License, included below. This software may be subject to other third party
3	* and contributor rights, including patent rights, and no such rights are
4	* granted under this license.
5	*
6	* Copyright (c) 2010-2012, ITU/ISO/IEC
7	* All rights reserved.
8	*
9	* Redistribution and use in source and binary forms, with or without
10	* modification, are permitted provided that the following conditions are met:
11	*
12	* * Redistributions of source code must retain the above copyright notice,
13	* this list of conditions and the following disclaimer.
14	* * Redistributions in binary form must reproduce the above copyright notice,
15	* this list of conditions and the following disclaimer in the documentation
16	* and/or other materials provided with the distribution.
17	* * Neither the name of the ITU/ISO/IEC nor the names of its contributors may
18	* be used to endorse or promote products derived from this software without
19	* specific prior written permission.
20	*
21	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
22	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24	* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
25	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
31	* THE POSSIBILITY OF SUCH DAMAGE.
32	*/
33
34	/** \file TComDataCU.h
35	\brief CU data structure (header)
36	\todo not all entities are documented
37	*/
38
39	#ifndef _TCOMDATACU_
40	#define _TCOMDATACU_
41
42	#include <assert.h>
43
44	// Include files
45	#include "CommonDef.h"
46	#include "TComMotionInfo.h"
47	#include "TComSlice.h"
48	#include "TComRdCost.h"
49	#include "TComPattern.h"
50
51	#if HHI_INTER_VIEW_RESIDUAL_PRED
52	#include "TComYuv.h"
53	#endif
54
55	#include <algorithm>
56	#include <vector>
57
58	//! \ingroup TLibCommon
59	//! \{
60
61	// ====================================================================================================================
62	// Non-deblocking in-loop filter processing block data structure
63	// ====================================================================================================================
64
65	/// Non-deblocking filter processing block border tag
66	enum NDBFBlockBorderTag
67	{
68	SGU_L = 0,
69	SGU_R,
70	SGU_T,
71	SGU_B,
72	SGU_TL,
73	SGU_TR,
74	SGU_BL,
75	SGU_BR,
76	NUM_SGU_BORDER
77	};
78
79	/// Non-deblocking filter processing block information
80	struct NDBFBlockInfo
81	{
82	Int tileID; //!< tile ID
83	Int sliceID; //!< slice ID
84	UInt startSU; //!< starting SU z-scan address in LCU
85	UInt endSU; //!< ending SU z-scan address in LCU
86	UInt widthSU; //!< number of SUs in width
87	UInt heightSU; //!< number of SUs in height
88	UInt posX; //!< top-left X coordinate in picture
89	UInt posY; //!< top-left Y coordinate in picture
90	UInt width; //!< number of pixels in width
91	UInt height; //!< number of pixels in height
92	Bool isBorderAvailable[NUM_SGU_BORDER]; //!< the border availabilities
93	#if LCU_SYNTAX_ALF
94	Bool allBordersAvailable;
95	#endif
96
97	NDBFBlockInfo():tileID(0), sliceID(0), startSU(0), endSU(0) {} //!< constructor
98	const NDBFBlockInfo& operator= (const NDBFBlockInfo& src); //!< "=" operator
99	};
100
101
102	// ====================================================================================================================
103	// Class definition
104	// ====================================================================================================================
105
106	/// CU data structure class
107	class TComDataCU
108	{
109	private:
110
111	// -------------------------------------------------------------------------------------------------------------------
112	// class pointers
113	// -------------------------------------------------------------------------------------------------------------------
114
115	TComPic* m_pcPic; ///< picture class pointer
116	TComSlice* m_pcSlice; ///< slice header pointer
117	TComPattern* m_pcPattern; ///< neighbour access class pointer
118
119	// -------------------------------------------------------------------------------------------------------------------
120	// CU description
121	// -------------------------------------------------------------------------------------------------------------------
122
123	UInt m_uiCUAddr; ///< CU address in a slice
124	UInt m_uiAbsIdxInLCU; ///< absolute address in a CU. It's Z scan order
125	UInt m_uiCUPelX; ///< CU position in a pixel (X)
126	UInt m_uiCUPelY; ///< CU position in a pixel (Y)
127	UInt m_uiNumPartition; ///< total number of minimum partitions in a CU
128	UChar* m_puhWidth; ///< array of widths
129	UChar* m_puhHeight; ///< array of heights
130	UChar* m_puhDepth; ///< array of depths
131	Int m_unitSize; ///< size of a "minimum partition"
132	#if HHI_MPI
133	Int* m_piTextureModeDepth; ///< at which depth are prediction data inherited from texture picture ( -1 : none )
134	#endif
135
136	// -------------------------------------------------------------------------------------------------------------------
137	// CU data
138	// -------------------------------------------------------------------------------------------------------------------
139
140	Char* m_pePartSize; ///< array of partition sizes
141	#if HHI_INTERVIEW_SKIP
142	Bool* m_pbRenderable; ///< array of merge flags
143	#endif
144	Char* m_pePredMode; ///< array of prediction modes
145	#if H0736_AVC_STYLE_QP_RANGE
146	Char* m_phQP; ///< array of QP values
147	#else
148	UChar* m_phQP; ///< array of QP values
149	#endif
150	UChar* m_puhTrIdx; ///< array of transform indices
151	UChar* m_nsqtPartIdx; ///< array of absPartIdx mapping table, map zigzag to NSQT
152	UChar* m_puhCbf[3]; ///< array of coded block flags (CBF)
153	TComCUMvField m_acCUMvField[2]; ///< array of motion vectors
154	TCoeff* m_pcTrCoeffY; ///< transformed coefficient buffer (Y)
155	TCoeff* m_pcTrCoeffCb; ///< transformed coefficient buffer (Cb)
156	TCoeff* m_pcTrCoeffCr; ///< transformed coefficient buffer (Cr)
157	#if ADAPTIVE_QP_SELECTION
158	Int* m_pcArlCoeffY; ///< ARL coefficient buffer (Y)
159	Int* m_pcArlCoeffCb; ///< ARL coefficient buffer (Cb)
160	Int* m_pcArlCoeffCr; ///< ARL coefficient buffer (Cr)
161	Bool m_ArlCoeffIsAliasedAllocation; ///< ARL coefficient buffer is an alias of the global buffer and must not be free()'d
162
163	static Int* m_pcGlbArlCoeffY; ///< ARL coefficient buffer (Y)
164	static Int* m_pcGlbArlCoeffCb; ///< ARL coefficient buffer (Cb)
165	static Int* m_pcGlbArlCoeffCr; ///< ARL coefficient buffer (Cr)
166
167	#endif
168
169	Pel* m_pcIPCMSampleY; ///< PCM sample buffer (Y)
170	Pel* m_pcIPCMSampleCb; ///< PCM sample buffer (Cb)
171	Pel* m_pcIPCMSampleCr; ///< PCM sample buffer (Cr)
172
173	Int* m_piSliceSUMap; ///< pointer of slice ID map
174	std::vector<NDBFBlockInfo> m_vNDFBlock;
175
176	// -------------------------------------------------------------------------------------------------------------------
177	// neighbour access variables
178	// -------------------------------------------------------------------------------------------------------------------
179
180	TComDataCU* m_pcCUAboveLeft; ///< pointer of above-left CU
181	TComDataCU* m_pcCUAboveRight; ///< pointer of above-right CU
182	TComDataCU* m_pcCUAbove; ///< pointer of above CU
183	TComDataCU* m_pcCULeft; ///< pointer of left CU
184	TComDataCU* m_apcCUColocated[2]; ///< pointer of temporally colocated CU's for both directions
185	TComMvField m_cMvFieldA; ///< motion vector of position A
186	TComMvField m_cMvFieldB; ///< motion vector of position B
187	TComMvField m_cMvFieldC; ///< motion vector of position C
188	TComMv m_cMvPred; ///< motion vector predictor
189
190	// -------------------------------------------------------------------------------------------------------------------
191	// coding tool information
192	// -------------------------------------------------------------------------------------------------------------------
193
194	Bool* m_pbMergeFlag; ///< array of merge flags
195	#if LGE_ILLUCOMP_B0045
196	Bool* m_pbICFlag; ///< array of IC flags
197	#endif
198	UChar* m_puhMergeIndex; ///< array of merge candidate indices
199	#if AMP_MRG
200	Bool m_bIsMergeAMP;
201	#endif
202	UChar* m_puhLumaIntraDir; ///< array of intra directions (luma)
203	UChar* m_puhChromaIntraDir; ///< array of intra directions (chroma)
204	UChar* m_puhInterDir; ///< array of inter directions
205	Char* m_apiMVPIdx[2]; ///< array of motion vector predictor candidates
206	Char* m_apiMVPNum[2]; ///< array of number of possible motion vectors predictors
207	Bool* m_puiAlfCtrlFlag; ///< array of ALF flags
208	Bool* m_puiTmpAlfCtrlFlag; ///< temporal array of ALF flags
209
210	Bool* m_pbIPCMFlag; ///< array of intra_pcm flags
211
212	#if BURST_IPCM
213	Int m_numSucIPCM; ///< the number of succesive IPCM blocks associated with the current log2CUSize
214	Bool m_lastCUSucIPCMFlag; ///< True indicates that the last CU is IPCM and shares the same root as the current CU.
215	#endif
216	#if HHI_INTER_VIEW_RESIDUAL_PRED
217	Bool* m_pbResPredAvailable; ///< array of residual prediction available flags
218	Bool* m_pbResPredFlag; ///< array of residual prediction flags
219	#endif
220
221	#if LGE_EDGE_INTRA_A0070
222	UChar* m_pucEdgeCode; ///< array of edge code
223	UChar* m_pucEdgeNumber; ///< total number of edge
224	UChar* m_pucEdgeStartPos; ///< starting point position
225	Bool* m_pbEdgeLeftFirst; ///< true if edge should be checked in left boundary first
226	Bool* m_pbEdgePartition; ///< true if it belongs to region 1, otherwise, region 0
227	#if LGE_EDGE_INTRA_DELTA_DC
228	Int* m_piEdgeDeltaDC0;
229	Int* m_piEdgeDeltaDC1;
230	#endif
231	#endif
232
233	// -------------------------------------------------------------------------------------------------------------------
234	// misc. variables
235	// -------------------------------------------------------------------------------------------------------------------
236
237	Bool m_bDecSubCu; ///< indicates decoder-mode
238	Double m_dTotalCost; ///< sum of partition RD costs
239	#if FIX_RDO_NEGDIST
240	Dist m_uiTotalDistortion; ///< sum of partition distortion
241	#else
242	UInt m_uiTotalDistortion; ///< sum of partition distortion
243	#endif
244	UInt m_uiTotalBits; ///< sum of partition bits
245	UInt m_uiTotalBins; ///< sum of partition bins
246	UInt* m_uiSliceStartCU; ///< Start CU address of current slice
247	UInt* m_uiEntropySliceStartCU; ///< Start CU address of current slice
248
249	// -------------------------------------------------------------------------------------------------------------------
250	// depth model mode data
251	// -------------------------------------------------------------------------------------------------------------------
252	#if HHI_DMM_WEDGE_INTRA
253	UInt* m_puiWedgeFullTabIdx;
254	Int* m_piWedgeFullDeltaDC1;
255	Int* m_piWedgeFullDeltaDC2;
256
257	UInt* m_puiWedgePredDirTabIdx;
258	Int* m_piWedgePredDirDeltaDC1;
259	Int* m_piWedgePredDirDeltaDC2;
260	Int* m_piWedgePredDirDeltaEnd;
261	#endif
262	#if HHI_DMM_PRED_TEX
263	UInt* m_puiWedgePredTexTabIdx;
264	Int* m_piWedgePredTexDeltaDC1;
265	Int* m_piWedgePredTexDeltaDC2;
266
267	Int* m_piContourPredTexDeltaDC1;
268	Int* m_piContourPredTexDeltaDC2;
269	#endif
270
271	#if RWTH_SDC_DLT_B0036
272	Bool* m_pbSDCFlag;
273	Pel* m_apSegmentDCOffset[2];
274	#endif
275
276	protected:
277
278	/// add possible motion vector predictor candidates
279	Bool xAddMVPCand ( AMVPInfo* pInfo, RefPicList eRefPicList, Int iRefIdx, UInt uiPartUnitIdx, MVP_DIR eDir );
280	Bool xAddMVPCandOrder ( AMVPInfo* pInfo, RefPicList eRefPicList, Int iRefIdx, UInt uiPartUnitIdx, MVP_DIR eDir );
281	#if FORCE_REF_VSP==2
282	inline bool xAddVspSkip(UChar ucVspMergePos, Bool bVspMvZeroDone, UInt uiDepth, Bool* abCandIsInter, Int& iCount,
283	UChar* puhInterDirNeighbours, TComMvField* pcMvFieldNeighbours, Int mrgCandIdx);
284	#endif
285
286	Void deriveRightBottomIdx ( PartSize eCUMode, UInt uiPartIdx, UInt& ruiPartIdxRB );
287	Bool xGetColMVP( RefPicList eRefPicList, Int uiCUAddr, Int uiPartUnitIdx, TComMv& rcMv, Int& riRefIdx );
288	#if QC_MULTI_DIS_CAN_A0097
289	Bool xGetColDisMV( RefPicList eRefPicList, Int refidx, Int uiCUAddr, Int uiPartUnitIdx, TComMv& rcMv, Int & iTargetViewIdx, Int & iStartViewIdx );
290	#endif
291
292	#if !AMVP_PRUNING_SIMPLIFICATION
293	/// remove redundant candidates
294	Void xUniqueMVPCand ( AMVPInfo* pInfo );
295	#endif
296
297	Void xCheckCornerCand( TComDataCU* pcCorner, UInt uiCornerIdx, UInt uiIter, Bool& rbValidCand );
298	/// compute required bits to encode MVD (used in AMVP)
299	UInt xGetMvdBits ( TComMv cMvd );
300	UInt xGetComponentBits ( Int iVal );
301
302	/// compute scaling factor from POC difference
303	Int xGetDistScaleFactor ( Int iCurrPOC, Int iCurrRefPOC, Int iColPOC, Int iColRefPOC );
304
305	Void xDeriveCenterIdx( PartSize eCUMode, UInt uiPartIdx, UInt& ruiPartIdxCenter );
306	Bool xGetCenterCol( UInt uiPartIdx, RefPicList eRefPicList, int iRefIdx, TComMv *pcMv );
307
308	Void xCheckDuplicateCand(TComMvField* pcMvFieldNeighbours, UChar* puhInterDirNeighbours, bool* pbCandIsInter, UInt& ruiArrayAddr);
309
310	#if !BURST_IPCM
311	Int getLastValidPartIdx ( Int iAbsPartIdx );
312	#endif
313
314	public:
315	TComDataCU();
316	virtual ~TComDataCU();
317
318	// -------------------------------------------------------------------------------------------------------------------
319	// create / destroy / initialize / copy
320	// -------------------------------------------------------------------------------------------------------------------
321
322	Void create ( UInt uiNumPartition, UInt uiWidth, UInt uiHeight, Bool bDecSubCu, Int unitSize
323	#if ADAPTIVE_QP_SELECTION
324	, Bool bGlobalRMARLBuffer = false
325	#endif
326	);
327	Void destroy ();
328
329	Void initCU ( TComPic* pcPic, UInt uiCUAddr );
330	#if H0736_AVC_STYLE_QP_RANGE
331	Void initEstData ( UInt uiDepth, Int qp );
332	Void initSubCU ( TComDataCU* pcCU, UInt uiPartUnitIdx, UInt uiDepth, Int qp );
333	#else
334	Void initEstData ( UInt uiDepth, UInt uiQP );
335	Void initSubCU ( TComDataCU* pcCU, UInt uiPartUnitIdx, UInt uiDepth, UInt uiQP );
336	#endif
337	Void setOutsideCUPart ( UInt uiAbsPartIdx, UInt uiDepth );
338
339	Void copySubCU ( TComDataCU* pcCU, UInt uiPartUnitIdx, UInt uiDepth );
340	Void copyInterPredInfoFrom ( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefPicList );
341	Void copyPartFrom ( TComDataCU* pcCU, UInt uiPartUnitIdx, UInt uiDepth );
342
343	Void copyToPic ( UChar uiDepth );
344	Void copyToPic ( UChar uiDepth, UInt uiPartIdx, UInt uiPartDepth );
345
346	// -------------------------------------------------------------------------------------------------------------------
347	// member functions for CU description
348	// -------------------------------------------------------------------------------------------------------------------
349
350	TComPic* getPic () { return m_pcPic; }
351	TComSlice* getSlice () { return m_pcSlice; }
352	UInt& getAddr () { return m_uiCUAddr; }
353	UInt& getZorderIdxInCU () { return m_uiAbsIdxInLCU; }
354	UInt getSCUAddr ();
355	UInt getCUPelX () { return m_uiCUPelX; }
356	UInt getCUPelY () { return m_uiCUPelY; }
357	TComPattern* getPattern () { return m_pcPattern; }
358
359	UChar* getDepth () { return m_puhDepth; }
360	UChar getDepth ( UInt uiIdx ) { return m_puhDepth[uiIdx]; }
361	Void setDepth ( UInt uiIdx, UChar uh ) { m_puhDepth[uiIdx] = uh; }
362
363	Void setDepthSubParts ( UInt uiDepth, UInt uiAbsPartIdx );
364	Void getPosInPic ( UInt uiAbsPartIndex, Int& riPosX, Int& riPosY );
365	#if HHI_MPI
366	Int* getTextureModeDepth () { return m_piTextureModeDepth; }
367	Int getTextureModeDepth ( UInt uiIdx ) { return m_piTextureModeDepth[uiIdx]; }
368	Void setTextureModeDepth ( UInt uiIdx, Int iTextureModeDepth ){ m_piTextureModeDepth[uiIdx] = iTextureModeDepth; }
369	Void setTextureModeDepthSubParts( Int iTextureModeDepth, UInt uiAbsPartIdx, UInt uiDepth );
370	Void copyTextureMotionDataFrom( TComDataCU* pcCU, UInt uiDepth, UInt uiAbsPartIdxSrc, UInt uiAbsPartIdxDst = 0 );
371	#endif
372
373	// -------------------------------------------------------------------------------------------------------------------
374	// member functions for CU data
375	// -------------------------------------------------------------------------------------------------------------------
376
377	Char* getPartitionSize () { return m_pePartSize; }
378	PartSize getPartitionSize ( UInt uiIdx ) { return static_cast<PartSize>( m_pePartSize[uiIdx] ); }
379	Void setPartitionSize ( UInt uiIdx, PartSize uh){ m_pePartSize[uiIdx] = uh; }
380	Void setPartSizeSubParts ( PartSize eMode, UInt uiAbsPartIdx, UInt uiDepth );
381
382	#if HHI_INTERVIEW_SKIP
383	Bool* getRenderable () { return m_pbRenderable; }
384	Bool getRenderable ( UInt uiIdx ) { return m_pbRenderable[uiIdx]; }
385	Void setRenderable ( UInt uiIdx, Bool b ) { m_pbRenderable[uiIdx] = b; }
386	Void setRenderableSubParts ( Bool bRenderable, UInt uiAbsPartIdx, UInt uiDepth );
387	#endif
388
389	Char* getPredictionMode () { return m_pePredMode; }
390	PredMode getPredictionMode ( UInt uiIdx ) { return static_cast<PredMode>( m_pePredMode[uiIdx] ); }
391	Void setPredictionMode ( UInt uiIdx, PredMode uh){ m_pePredMode[uiIdx] = uh; }
392	Void setPredModeSubParts ( PredMode eMode, UInt uiAbsPartIdx, UInt uiDepth );
393
394	UChar* getWidth () { return m_puhWidth; }
395	UChar getWidth ( UInt uiIdx ) { return m_puhWidth[uiIdx]; }
396	Void setWidth ( UInt uiIdx, UChar uh ) { m_puhWidth[uiIdx] = uh; }
397
398	UChar* getHeight () { return m_puhHeight; }
399	UChar getHeight ( UInt uiIdx ) { return m_puhHeight[uiIdx]; }
400	Void setHeight ( UInt uiIdx, UChar uh ) { m_puhHeight[uiIdx] = uh; }
401
402	Void setSizeSubParts ( UInt uiWidth, UInt uiHeight, UInt uiAbsPartIdx, UInt uiDepth );
403
404	#if H0736_AVC_STYLE_QP_RANGE
405	Char* getQP () { return m_phQP; }
406	Char getQP ( UInt uiIdx ) { return m_phQP[uiIdx]; }
407	Void setQP ( UInt uiIdx, Char value ){ m_phQP[uiIdx] = value; }
408	Void setQPSubParts ( Int qp, UInt uiAbsPartIdx, UInt uiDepth );
409	#if BURST_IPCM
410	Int getLastValidPartIdx ( Int iAbsPartIdx );
411	#endif
412	Char getLastCodedQP ( UInt uiAbsPartIdx );
413	#else
414	UChar* getQP () { return m_phQP; }
415	UChar getQP ( UInt uiIdx ) { return m_phQP[uiIdx]; }
416	Void setQP ( UInt uiIdx, UChar uh ) { m_phQP[uiIdx] = uh; }
417	Void setQPSubParts ( UInt uiQP, UInt uiAbsPartIdx, UInt uiDepth );
418	#if BURST_IPCM
419	Int getLastValidPartIdx ( Int iAbsPartIdx );
420	#endif
421	UChar getLastCodedQP ( UInt uiAbsPartIdx );
422	#endif
423
424	#if LOSSLESS_CODING
425	Bool isLosslessCoded(UInt absPartIdx);
426	#endif
427	UChar* getNSQTPartIdx () { return m_nsqtPartIdx; }
428	UChar getNSQTPartIdx ( UInt idx ) { return m_nsqtPartIdx[idx]; }
429	Void setNSQTIdxSubParts ( UInt absPartIdx, UInt depth );
430	Void setNSQTIdxSubParts ( UInt log2TrafoSize, UInt absPartIdx, UInt absTUPartIdx, UInt trMode );
431
432	UChar* getTransformIdx () { return m_puhTrIdx; }
433	UChar getTransformIdx ( UInt uiIdx ) { return m_puhTrIdx[uiIdx]; }
434	Void setTrIdxSubParts ( UInt uiTrIdx, UInt uiAbsPartIdx, UInt uiDepth );
435
436	UInt getQuadtreeTULog2MinSizeInCU( UInt absPartIdx );
437
438	TComCUMvField* getCUMvField ( RefPicList e ) { return &m_acCUMvField[e]; }
439
440	TCoeff*& getCoeffY () { return m_pcTrCoeffY; }
441	TCoeff*& getCoeffCb () { return m_pcTrCoeffCb; }
442	TCoeff*& getCoeffCr () { return m_pcTrCoeffCr; }
443	#if ADAPTIVE_QP_SELECTION
444	Int*& getArlCoeffY () { return m_pcArlCoeffY; }
445	Int*& getArlCoeffCb () { return m_pcArlCoeffCb; }
446	Int*& getArlCoeffCr () { return m_pcArlCoeffCr; }
447	#endif
448
449	Pel*& getPCMSampleY () { return m_pcIPCMSampleY; }
450	Pel*& getPCMSampleCb () { return m_pcIPCMSampleCb; }
451	Pel*& getPCMSampleCr () { return m_pcIPCMSampleCr; }
452
453	UChar getCbf ( UInt uiIdx, TextType eType ) { return m_puhCbf[g_aucConvertTxtTypeToIdx[eType]][uiIdx]; }
454	UChar* getCbf ( TextType eType ) { return m_puhCbf[g_aucConvertTxtTypeToIdx[eType]]; }
455	UChar getCbf ( UInt uiIdx, TextType eType, UInt uiTrDepth ) { return ( ( getCbf( uiIdx, eType ) >> uiTrDepth ) & 0x1 ); }
456	Void setCbf ( UInt uiIdx, TextType eType, UChar uh ) { m_puhCbf[g_aucConvertTxtTypeToIdx[eType]][uiIdx] = uh; }
457	Void clearCbf ( UInt uiIdx, TextType eType, UInt uiNumParts );
458	UChar getQtRootCbf ( UInt uiIdx ) { return getCbf( uiIdx, TEXT_LUMA, 0 ) \|\| getCbf( uiIdx, TEXT_CHROMA_U, 0 ) \|\| getCbf( uiIdx, TEXT_CHROMA_V, 0 ); }
459
460	Void setCbfSubParts ( UInt uiCbfY, UInt uiCbfU, UInt uiCbfV, UInt uiAbsPartIdx, UInt uiDepth );
461	Void setCbfSubParts ( UInt uiCbf, TextType eTType, UInt uiAbsPartIdx, UInt uiDepth );
462	Void setCbfSubParts ( UInt uiCbf, TextType eTType, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth );
463
464	// -------------------------------------------------------------------------------------------------------------------
465	// member functions for coding tool information
466	// -------------------------------------------------------------------------------------------------------------------
467
468	Bool* getMergeFlag () { return m_pbMergeFlag; }
469	Bool getMergeFlag ( UInt uiIdx ) { return m_pbMergeFlag[uiIdx]; }
470	Void setMergeFlag ( UInt uiIdx, Bool b ) { m_pbMergeFlag[uiIdx] = b; }
471	Void setMergeFlagSubParts ( Bool bMergeFlag, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth );
472
473	UChar* getMergeIndex () { return m_puhMergeIndex; }
474	UChar getMergeIndex ( UInt uiIdx ) { return m_puhMergeIndex[uiIdx]; }
475	Void setMergeIndex ( UInt uiIdx, UInt uiMergeIndex ) { m_puhMergeIndex[uiIdx] = uiMergeIndex; }
476	Void setMergeIndexSubParts ( UInt uiMergeIndex, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth );
477	template <typename T>
478	Void setSubPart ( T bParameter, T* pbBaseLCU, UInt uiCUAddr, UInt uiCUDepth, UInt uiPUIdx );
479
480	#if LGE_ILLUCOMP_B0045
481	Bool* getICFlag () { return m_pbICFlag; }
482	Bool getICFlag ( UInt uiIdx ) { return m_pbICFlag[uiIdx]; }
483	Void setICFlag ( UInt uiIdx, Bool uh ) { m_pbICFlag[uiIdx] = uh; }
484	Void setICFlagSubParts ( Bool bICFlag, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth );
485	Bool isICFlagRequired (UInt uiAbsPartIdx);
486	#endif
487
488	#if AMP_MRG
489	Void setMergeAMP( Bool b ) { m_bIsMergeAMP = b; }
490	Bool getMergeAMP( ) { return m_bIsMergeAMP; }
491	#endif
492
493	UChar* getLumaIntraDir () { return m_puhLumaIntraDir; }
494	UChar getLumaIntraDir ( UInt uiIdx ) { return m_puhLumaIntraDir[uiIdx]; }
495	Void setLumaIntraDir ( UInt uiIdx, UChar uh ) { m_puhLumaIntraDir[uiIdx] = uh; }
496	Void setLumaIntraDirSubParts( UInt uiDir, UInt uiAbsPartIdx, UInt uiDepth );
497
498	UChar* getChromaIntraDir () { return m_puhChromaIntraDir; }
499	UChar getChromaIntraDir ( UInt uiIdx ) { return m_puhChromaIntraDir[uiIdx]; }
500	Void setChromaIntraDir ( UInt uiIdx, UChar uh ) { m_puhChromaIntraDir[uiIdx] = uh; }
501	Void setChromIntraDirSubParts( UInt uiDir, UInt uiAbsPartIdx, UInt uiDepth );
502
503	UChar* getInterDir () { return m_puhInterDir; }
504	UChar getInterDir ( UInt uiIdx ) { return m_puhInterDir[uiIdx]; }
505	Void setInterDir ( UInt uiIdx, UChar uh ) { m_puhInterDir[uiIdx] = uh; }
506	Void setInterDirSubParts ( UInt uiDir, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth );
507
508	Bool* getAlfCtrlFlag () { return m_puiAlfCtrlFlag; }
509	Bool getAlfCtrlFlag ( UInt uiIdx ) { return m_puiAlfCtrlFlag[uiIdx]; }
510	Void setAlfCtrlFlag ( UInt uiIdx, Bool uiFlag){ m_puiAlfCtrlFlag[uiIdx] = uiFlag; }
511	Void setAlfCtrlFlagSubParts( Bool uiFlag, UInt uiAbsPartIdx, UInt uiDepth );
512
513	Void createTmpAlfCtrlFlag ();
514	Void destroyTmpAlfCtrlFlag ();
515	Void copyAlfCtrlFlagToTmp ();
516	Void copyAlfCtrlFlagFromTmp();
517
518	Bool* getIPCMFlag () { return m_pbIPCMFlag; }
519	Bool getIPCMFlag (UInt uiIdx ) { return m_pbIPCMFlag[uiIdx]; }
520	Void setIPCMFlag (UInt uiIdx, Bool b ) { m_pbIPCMFlag[uiIdx] = b; }
521	Void setIPCMFlagSubParts (Bool bIpcmFlag, UInt uiAbsPartIdx, UInt uiDepth);
522
523	#if BURST_IPCM
524	Int getNumSucIPCM () { return m_numSucIPCM; }
525	Void setNumSucIPCM ( Int num ) { m_numSucIPCM = num; }
526	Bool getLastCUSucIPCMFlag () { return m_lastCUSucIPCMFlag; }
527	Void setLastCUSucIPCMFlag ( Bool flg ) { m_lastCUSucIPCMFlag = flg; }
528	#endif
529
530	/// get slice ID for SU
531	Int getSUSliceID (UInt uiIdx) {return m_piSliceSUMap[uiIdx]; }
532
533	/// get the pointer of slice ID map
534	Int* getSliceSUMap () {return m_piSliceSUMap; }
535
536	/// set the pointer of slice ID map
537	Void setSliceSUMap (Int *pi) {m_piSliceSUMap = pi; }
538
539	std::vector<NDBFBlockInfo>* getNDBFilterBlocks() {return &m_vNDFBlock;}
540	Void setNDBFilterBlockBorderAvailability(UInt numLCUInPicWidth, UInt numLCUInPicHeight, UInt numSUInLCUWidth, UInt numSUInLCUHeight, UInt picWidth, UInt picHeight
541	,Bool bIndependentSliceBoundaryEnabled
542	,Bool bTopTileBoundary, Bool bDownTileBoundary, Bool bLeftTileBoundary, Bool bRightTileBoundary
543	,Bool bIndependentTileBoundaryEnabled );
544
545	#if HHI_INTER_VIEW_MOTION_PRED
546	#if !QC_MULTI_DIS_CAN_A0097
547	Int getPdmMergeCandidate( UInt uiPartIdx, Int* paiPdmRefIdx, TComMv* pacPdmMv );
548	Bool getPdmMvPred( UInt uiPartIdx, RefPicList eRefPicList, Int iRefIdx, TComMv& rcMv, Bool bMerge = false );
549	#else
550	Bool getPdmMvPredDisCan( UInt uiPartIdx, RefPicList eRefPicList, Int iRefIdx, TComMv& rcMv, DisInfo* pDInfo, Bool bMerge = false );
551	Int getPdmMergeCandidateDisCan( UInt uiPartIdx, Int* paiPdmRefIdx, TComMv* pacPdmMv, DisInfo* pDInfo
552	#if QC_MRG_CANS_B0048
553	, Int* iPdm
554	#endif
555	);
556	Void getDisMvpCand ( UInt uiPartIdx, UInt uiPartAddr, DisInfo* pDInfo );
557	#if LGE_DVMCP_A0126
558	#if QC_SIMPLE_NBDV_B0047
559	Void getDisMvpCand2( UInt uiPartIdx, UInt uiPartAddr, DisInfo* pDInfo
560	#if LGE_IVMP_PARALLEL_MERGE_B0136
561	, Bool bParMerg = false
562	#endif
563	);
564	#else
565	Void getDisMvpCand2( UInt uiPartIdx, UInt uiPartAddr, DisInfo* pDInfo, Bool bMerge=false, RefPicList eRefPicList=REF_PIC_LIST_X, Int iRefIdx=-1
566	#if LGE_IVMP_PARALLEL_MERGE_B0136
567	, Bool bParMerg = false
568	#endif
569	);
570	#endif
571	#endif
572
573	#endif
574	Bool getIViewOrgDepthMvPred( UInt uiPartIdx, RefPicList eRefPicList, Int iRefIdx, TComMv& rcMv );
575	#endif
576	#if HHI_INTER_VIEW_RESIDUAL_PRED
577	Bool* getResPredAvail () { return m_pbResPredAvailable; }
578	Bool getResPredAvail ( UInt uiIdx ) { return m_pbResPredAvailable[uiIdx]; }
579	Void setResPredAvail ( UInt uiIdx, Bool b ) { m_pbResPredAvailable[uiIdx] = b; }
580	Void setResPredAvailSubParts ( Bool b, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth );
581
582	Bool* getResPredFlag () { return m_pbResPredFlag; }
583	Bool getResPredFlag ( UInt uiIdx ) { return m_pbResPredFlag[uiIdx]; }
584	Void setResPredFlag ( UInt uiIdx, Bool b ) { m_pbResPredFlag[uiIdx] = b; }
585	Void setResPredFlagSubParts ( Bool b, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth );
586
587	Void setResPredIndicator ( Bool bAv, Bool bRP ) { m_pbResPredAvailable[0] = bAv; m_pbResPredFlag[0] = bRP; }
588	#endif
589	#if HHI_INTER_VIEW_RESIDUAL_PRED
590	Bool getResidualSamples( UInt uiPartIdx,
591	#if QC_SIMPLIFIEDIVRP_M24938
592	Bool bRecon ,
593	#endif
594	TComYuv* pcYuv = 0 );
595	#endif
596	// -------------------------------------------------------------------------------------------------------------------
597	// member functions for accessing partition information
598	// -------------------------------------------------------------------------------------------------------------------
599	#if LG_RESTRICTEDRESPRED_M24766
600	Void getPartIndexAndSize( UInt uiPartIdx, UInt& ruiPartAddr, Int& riWidth, Int& riHeight, UInt uiAbsPartIdx = 0, Bool bLCU = false);
601	#else
602	Void getPartIndexAndSize ( UInt uiPartIdx, UInt& ruiPartAddr, Int& riWidth, Int& riHeight );
603	#endif
604	#if LG_RESTRICTEDRESPRED_M24766
605	Int getResiPredMode(UInt uiPartAddr);
606	Void getPUResiPredShift (Int *iPUPredResiShift, UInt uiAbsPartIndex);
607	#endif
608	UChar getNumPartInter ();
609	Bool isFirstAbsZorderIdxInDepth (UInt uiAbsPartIdx, UInt uiDepth);
610
611	// -------------------------------------------------------------------------------------------------------------------
612	// member functions for motion vector
613	// -------------------------------------------------------------------------------------------------------------------
614
615	Void getMvField ( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefPicList, TComMvField& rcMvField );
616
617	AMVP_MODE getAMVPMode ( UInt uiIdx );
618	#if SHARP_INTERVIEW_DECOUPLE_B0111
619	Void fillMvpCandBase ( UInt uiPartIdx, UInt uiPartAddr, RefPicList eRefPicList, Int iRefIdx, AMVPInfo* pInfo );
620	Void fillMvpCand ( UInt uiPartIdx, UInt uiPartAddr, RefPicList eRefPicList, Int iRefIdx, AMVPInfo* pInfo , Int iMVPIdx=-1);
621	#else
622	Void fillMvpCand ( UInt uiPartIdx, UInt uiPartAddr, RefPicList eRefPicList, Int iRefIdx, AMVPInfo* pInfo );
623	#endif
624	#if PARALLEL_MERGE
625	Bool isDiffMER ( Int xN, Int yN, Int xP, Int yP);
626	Void getPartPosition ( UInt partIdx, Int& xP, Int& yP, Int& nPSW, Int& nPSH);
627	#endif
628	Void setMVPIdx ( RefPicList eRefPicList, UInt uiIdx, Int iMVPIdx) { m_apiMVPIdx[eRefPicList][uiIdx] = iMVPIdx; }
629	Int getMVPIdx ( RefPicList eRefPicList, UInt uiIdx) { return m_apiMVPIdx[eRefPicList][uiIdx]; }
630	Char* getMVPIdx ( RefPicList eRefPicList ) { return m_apiMVPIdx[eRefPicList]; }
631
632	Void setMVPNum ( RefPicList eRefPicList, UInt uiIdx, Int iMVPNum ) { m_apiMVPNum[eRefPicList][uiIdx] = iMVPNum; }
633	Int getMVPNum ( RefPicList eRefPicList, UInt uiIdx ) { return m_apiMVPNum[eRefPicList][uiIdx]; }
634	Char* getMVPNum ( RefPicList eRefPicList ) { return m_apiMVPNum[eRefPicList]; }
635
636	Void setMVPIdxSubParts ( Int iMVPIdx, RefPicList eRefPicList, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth );
637	Void setMVPNumSubParts ( Int iMVPNum, RefPicList eRefPicList, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth );
638
639	Void clipMv ( TComMv& rcMv );
640	Void getMvPredLeft ( TComMv& rcMvPred ) { rcMvPred = m_cMvFieldA.getMv(); }
641	Void getMvPredAbove ( TComMv& rcMvPred ) { rcMvPred = m_cMvFieldB.getMv(); }
642	Void getMvPredAboveRight ( TComMv& rcMvPred ) { rcMvPred = m_cMvFieldC.getMv(); }
643
644	Void compressMV ();
645
646	// -------------------------------------------------------------------------------------------------------------------
647	// utility functions for neighbouring information
648	// -------------------------------------------------------------------------------------------------------------------
649
650	TComDataCU* getCULeft () { return m_pcCULeft; }
651	TComDataCU* getCUAbove () { return m_pcCUAbove; }
652	TComDataCU* getCUAboveLeft () { return m_pcCUAboveLeft; }
653	TComDataCU* getCUAboveRight () { return m_pcCUAboveRight; }
654	TComDataCU* getCUColocated ( RefPicList eRefPicList ) { return m_apcCUColocated[eRefPicList]; }
655
656
657	TComDataCU* getPULeft ( UInt& uiLPartUnitIdx , UInt uiCurrPartUnitIdx, Bool bEnforceSliceRestriction=true, Bool bEnforceEntropySliceRestriction=true
658	, Bool bEnforceTileRestriction=true
659	);
660
661	TComDataCU* getPUAbove ( UInt& uiAPartUnitIdx , UInt uiCurrPartUnitIdx, Bool bEnforceSliceRestriction=true, Bool bEnforceEntropySliceRestriction=true, Bool MotionDataCompresssion = false
662	, Bool planarAtLCUBoundary = false
663	, Bool bEnforceTileRestriction=true
664	);
665
666	TComDataCU* getPUAboveLeft ( UInt& uiALPartUnitIdx, UInt uiCurrPartUnitIdx, Bool bEnforceSliceRestriction=true, Bool bEnforceEntropySliceRestriction=true, Bool MotionDataCompresssion = false );
667	TComDataCU* getPUAboveRight ( UInt& uiARPartUnitIdx, UInt uiCurrPartUnitIdx, Bool bEnforceSliceRestriction=true, Bool bEnforceEntropySliceRestriction=true, Bool MotionDataCompresssion = false );
668	TComDataCU* getPUBelowLeft ( UInt& uiBLPartUnitIdx, UInt uiCurrPartUnitIdx, Bool bEnforceSliceRestriction=true, Bool bEnforceEntropySliceRestriction=true );
669
670	TComDataCU* getQpMinCuLeft ( UInt& uiLPartUnitIdx , UInt uiCurrAbsIdxInLCU, Bool bEnforceSliceRestriction=true, Bool bEnforceEntropySliceRestriction=true );
671	#if H0204_QP_PREDICTION
672	TComDataCU* getQpMinCuAbove ( UInt& aPartUnitIdx , UInt currAbsIdxInLCU, Bool enforceSliceRestriction=true, Bool enforceEntropySliceRestriction=true );
673	#endif
674	#if H0736_AVC_STYLE_QP_RANGE
675	Char getRefQP ( UInt uiCurrAbsIdxInLCU );
676	#else
677	UChar getRefQP ( UInt uiCurrAbsIdxInLCU );
678	#endif
679
680	TComDataCU* getPUAboveRightAdi ( UInt& uiARPartUnitIdx, UInt uiPuWidth, UInt uiCurrPartUnitIdx, UInt uiPartUnitOffset = 1, Bool bEnforceSliceRestriction=true, Bool bEnforceEntropySliceRestriction=true );
681	TComDataCU* getPUBelowLeftAdi ( UInt& uiBLPartUnitIdx, UInt uiPuHeight, UInt uiCurrPartUnitIdx, UInt uiPartUnitOffset = 1, Bool bEnforceSliceRestriction=true, Bool bEnforceEntropySliceRestriction=true );
682
683	Void deriveLeftRightTopIdx ( PartSize eCUMode, UInt uiPartIdx, UInt& ruiPartIdxLT, UInt& ruiPartIdxRT );
684	Void deriveLeftBottomIdx ( PartSize eCUMode, UInt uiPartIdx, UInt& ruiPartIdxLB );
685
686	Void deriveLeftRightTopIdxAdi ( UInt& ruiPartIdxLT, UInt& ruiPartIdxRT, UInt uiPartOffset, UInt uiPartDepth );
687	Void deriveLeftBottomIdxAdi ( UInt& ruiPartIdxLB, UInt uiPartOffset, UInt uiPartDepth );
688
689	Bool hasEqualMotion ( UInt uiAbsPartIdx, TComDataCU* pcCandCU, UInt uiCandAbsPartIdx );
690	#if SIMP_MRG_PRUN
691	Void getInterMergeCandidates ( UInt uiAbsPartIdx, UInt uiPUIdx, UInt uiDepth, TComMvField* pcMFieldNeighbours, UChar* puhInterDirNeighbours, Int& numValidMergeCand, Int mrgCandIdx = -1 );
692	#else
693	Void getInterMergeCandidates ( UInt uiAbsPartIdx, UInt uiPUIdx, UInt uiDepth, TComMvField* pcMFieldNeighbours, UChar* puhInterDirNeighbours, Int& numValidMergeCand );
694	#endif
695	Void deriveLeftRightTopIdxGeneral ( PartSize eCUMode, UInt uiAbsPartIdx, UInt uiPartIdx, UInt& ruiPartIdxLT, UInt& ruiPartIdxRT );
696	Void deriveLeftBottomIdxGeneral ( PartSize eCUMode, UInt uiAbsPartIdx, UInt uiPartIdx, UInt& ruiPartIdxLB );
697
698
699	// -------------------------------------------------------------------------------------------------------------------
700	// member functions for modes
701	// -------------------------------------------------------------------------------------------------------------------
702
703	Bool isIntra ( UInt uiPartIdx ) { return m_pePredMode[ uiPartIdx ] == MODE_INTRA; }
704	Bool isSkipped ( UInt uiPartIdx ); ///< SKIP (no residual)
705	#if FORCE_REF_VSP==1
706	Int isVspMode ( UInt uiPartIdx ) { return m_pePredMode[ uiPartIdx ] == MODE_SYNTH; }
707	#elif FORCE_REF_VSP==2
708	Int isVspMode ( UInt uiPartIdx );
709	Int isVspMode ( UInt uiPartIdx, TComMv cCompMv );
710	Bool isVspRef ( RefPicList e, Int iRefIdx );
711	#endif
712
713	// -------------------------------------------------------------------------------------------------------------------
714	// member functions for symbol prediction (most probable / mode conversion)
715	// -------------------------------------------------------------------------------------------------------------------
716
717	UInt getIntraSizeIdx ( UInt uiAbsPartIdx );
718	Void convertTransIdx ( UInt uiAbsPartIdx, UInt uiTrIdx, UInt& ruiLumaTrMode, UInt& ruiChromaTrMode );
719
720	Void getAllowedChromaDir ( UInt uiAbsPartIdx, UInt* uiModeList );
721	Int getIntraDirLumaPredictor ( UInt uiAbsPartIdx, Int* uiIntraDirPred, Int* piMode = NULL );
722
723	// -------------------------------------------------------------------------------------------------------------------
724	// member functions for SBAC context
725	// -------------------------------------------------------------------------------------------------------------------
726
727	UInt getCtxSplitFlag ( UInt uiAbsPartIdx, UInt uiDepth );
728	UInt getCtxQtCbf ( UInt uiAbsPartIdx, TextType eType, UInt uiTrDepth );
729
730	UInt getCtxSkipFlag ( UInt uiAbsPartIdx );
731	#if LGE_ILLUCOMP_B0045
732	UInt getCtxICFlag ( UInt uiAbsPartIdx );
733	#endif
734	UInt getCtxInterDir ( UInt uiAbsPartIdx );
735
736	#if HHI_INTER_VIEW_RESIDUAL_PRED
737	UInt getCtxResPredFlag ( UInt uiAbsPartIdx );
738	#endif
739
740	UInt getSliceStartCU ( UInt pos ) { return m_uiSliceStartCU[pos-m_uiAbsIdxInLCU]; }
741	UInt getEntropySliceStartCU ( UInt pos ) { return m_uiEntropySliceStartCU[pos-m_uiAbsIdxInLCU]; }
742	UInt& getTotalBins () { return m_uiTotalBins; }
743
744	#if LGE_EDGE_INTRA_A0070
745	UInt getCtxEdgeIntra ( UInt uiAbsPartIdx );
746	#endif
747
748	// -------------------------------------------------------------------------------------------------------------------
749	// member functions for RD cost storage
750	// -------------------------------------------------------------------------------------------------------------------
751
752	Double& getTotalCost() { return m_dTotalCost; }
753	#if FIX_RDO_NEGDIST
754	Dist& getTotalDistortion() { return m_uiTotalDistortion; }
755	#else
756	UInt& getTotalDistortion() { return m_uiTotalDistortion; }
757	#endif
758	UInt& getTotalBits() { return m_uiTotalBits; }
759	UInt& getTotalNumPart() { return m_uiNumPartition; }
760
761	UInt getCoefScanIdx(UInt uiAbsPartIdx, UInt uiWidth, Bool bIsLuma, Bool bIsIntra);
762
763	Bool useNonSquareTrans( UInt uiTrMode, Int absPartIdx );
764	Void getNSQTSize(Int trMode, Int absPartIdx, Int &trWidth, Int &trHeight);
765	Bool useNonSquarePU ( UInt absPartIdx);
766	UInt getInterTUSplitDirection ( Int width, Int height, Int trLastWidth, Int trLastHeight );
767	UInt getNSAbsPartIdx ( UInt log2TrafoSize, UInt absPartIdx, UInt absTUPartIdx, UInt innerQuadIdx, UInt trMode );
768	UInt getNSAddrChroma ( UInt uiLog2TrSizeC, UInt uiTrModeC, UInt uiQuadrant, UInt absTUPartIdx );
769
770	// -------------------------------------------------------------------------------------------------------------------
771	// member functions for depth model modes
772	// -------------------------------------------------------------------------------------------------------------------
773	#if HHI_DMM_WEDGE_INTRA
774	UInt* getWedgeFullTabIdx () { return m_puiWedgeFullTabIdx; }
775	UInt getWedgeFullTabIdx ( UInt uiIdx ) { return m_puiWedgeFullTabIdx[uiIdx]; }
776	Void setWedgeFullTabIdx ( UInt uiIdx, UInt uh ) { m_puiWedgeFullTabIdx[uiIdx] = uh; }
777	Void setWedgeFullTabIdxSubParts ( UInt uiTIdx, UInt uiAbsPartIdx, UInt uiDepth );
778	Int* getWedgeFullDeltaDC1 () { return m_piWedgeFullDeltaDC1; }
779	Int getWedgeFullDeltaDC1 ( UInt uiIdx ) { return m_piWedgeFullDeltaDC1[uiIdx]; }
780	Void setWedgeFullDeltaDC1 ( UInt uiIdx, Int i ) { m_piWedgeFullDeltaDC1[uiIdx] = i; }
781	Void setWedgeFullDeltaDC1SubParts ( Int iDC1, UInt uiAbsPartIdx, UInt uiDepth );
782	Int* getWedgeFullDeltaDC2 () { return m_piWedgeFullDeltaDC2; }
783	Int getWedgeFullDeltaDC2 ( UInt uiIdx ) { return m_piWedgeFullDeltaDC2[uiIdx]; }
784	Void setWedgeFullDeltaDC2 ( UInt uiIdx, Int i ) { m_piWedgeFullDeltaDC2[uiIdx] = i; }
785	Void setWedgeFullDeltaDC2SubParts ( Int iDC2, UInt uiAbsPartIdx, UInt uiDepth );
786
787	UInt* getWedgePredDirTabIdx () { return m_puiWedgePredDirTabIdx; }
788	UInt getWedgePredDirTabIdx ( UInt uiIdx ) { return m_puiWedgePredDirTabIdx[uiIdx]; }
789	Void setWedgePredDirTabIdx ( UInt uiIdx, UInt uh ) { m_puiWedgePredDirTabIdx[uiIdx] = uh; }
790	Void setWedgePredDirTabIdxSubParts ( UInt uiTIdx, UInt uiAbsPartIdx, UInt uiDepth );
791	Int* getWedgePredDirDeltaDC1 () { return m_piWedgePredDirDeltaDC1; }
792	Int getWedgePredDirDeltaDC1 ( UInt uiIdx ) { return m_piWedgePredDirDeltaDC1[uiIdx]; }
793	Void setWedgePredDirDeltaDC1 ( UInt uiIdx, Int i ) { m_piWedgePredDirDeltaDC1[uiIdx] = i; }
794	Void setWedgePredDirDeltaDC1SubParts ( Int iDC1, UInt uiAbsPartIdx, UInt uiDepth );
795	Int* getWedgePredDirDeltaDC2 () { return m_piWedgePredDirDeltaDC2; }
796	Int getWedgePredDirDeltaDC2 ( UInt uiIdx ) { return m_piWedgePredDirDeltaDC2[uiIdx]; }
797	Void setWedgePredDirDeltaDC2 ( UInt uiIdx, Int i ) { m_piWedgePredDirDeltaDC2[uiIdx] = i; }
798	Void setWedgePredDirDeltaDC2SubParts ( Int iDC2, UInt uiAbsPartIdx, UInt uiDepth );
799	Int* getWedgePredDirDeltaEnd () { return m_piWedgePredDirDeltaEnd; }
800	Int getWedgePredDirDeltaEnd ( UInt uiIdx ) { return m_piWedgePredDirDeltaEnd[uiIdx]; }
801	Void setWedgePredDirDeltaEnd ( UInt uiIdx, Int iD ) { m_piWedgePredDirDeltaEnd[uiIdx] = iD; }
802	Void setWedgePredDirDeltaEndSubParts ( Int iDelta, UInt uiAbsPartIdx, UInt uiDepth );
803	#endif
804	#if HHI_DMM_PRED_TEX
805	UInt* getWedgePredTexTabIdx () { return m_puiWedgePredTexTabIdx; }
806	UInt getWedgePredTexTabIdx ( UInt uiIdx ) { return m_puiWedgePredTexTabIdx[uiIdx]; }
807	Void setWedgePredTexTabIdx ( UInt uiIdx, UInt uh ) { m_puiWedgePredTexTabIdx[uiIdx] = uh; }
808	Void setWedgePredTexTabIdxSubParts ( UInt uiTIdx, UInt uiAbsPartIdx, UInt uiDepth );
809	Int* getWedgePredTexDeltaDC1 () { return m_piWedgePredTexDeltaDC1; }
810	Int getWedgePredTexDeltaDC1 ( UInt uiIdx ) { return m_piWedgePredTexDeltaDC1[uiIdx]; }
811	Void setWedgePredTexDeltaDC1 ( UInt uiIdx, Int i ) { m_piWedgePredTexDeltaDC1[uiIdx] = i; }
812	Void setWedgePredTexDeltaDC1SubParts ( Int iDC1, UInt uiAbsPartIdx, UInt uiDepth );
813	Int* getWedgePredTexDeltaDC2 () { return m_piWedgePredTexDeltaDC2; }
814	Int getWedgePredTexDeltaDC2 ( UInt uiIdx ) { return m_piWedgePredTexDeltaDC2[uiIdx]; }
815	Void setWedgePredTexDeltaDC2 ( UInt uiIdx, Int i ) { m_piWedgePredTexDeltaDC2[uiIdx] = i; }
816	Void setWedgePredTexDeltaDC2SubParts ( Int iDC2, UInt uiAbsPartIdx, UInt uiDepth );
817
818	Int* getContourPredTexDeltaDC1 () { return m_piContourPredTexDeltaDC1; }
819	Int getContourPredTexDeltaDC1 ( UInt uiIdx ) { return m_piContourPredTexDeltaDC1[uiIdx]; }
820	Void setContourPredTexDeltaDC1 ( UInt uiIdx, Int i ) { m_piContourPredTexDeltaDC1[uiIdx] = i; }
821	Void setContourPredTexDeltaDC1SubParts ( Int iDC1, UInt uiAbsPartIdx, UInt uiDepth );
822	Int* getContourPredTexDeltaDC2 () { return m_piContourPredTexDeltaDC2; }
823	Int getContourPredTexDeltaDC2 ( UInt uiIdx ) { return m_piContourPredTexDeltaDC2[uiIdx]; }
824	Void setContourPredTexDeltaDC2 ( UInt uiIdx, Int i ) { m_piContourPredTexDeltaDC2[uiIdx] = i; }
825	Void setContourPredTexDeltaDC2SubParts ( Int iDC2, UInt uiAbsPartIdx, UInt uiDepth );
826	#endif
827
828	#if LGE_EDGE_INTRA_A0070
829	UChar* getEdgeCode( UInt uiIdx ) { return &m_pucEdgeCode[uiIdx * LGE_EDGE_INTRA_MAX_EDGE_NUM_PER_4x4]; }
830	UChar* getEdgeNumber( ) { return m_pucEdgeNumber; }
831	UChar getEdgeNumber( UInt uiIdx ) { return m_pucEdgeNumber[uiIdx]; }
832	Void setEdgeNumber( UInt uiIdx, UChar val ) { m_pucEdgeNumber[uiIdx] = val; }
833	UChar* getEdgeStartPos( ) { return m_pucEdgeStartPos; }
834	UChar getEdgeStartPos( UInt uiIdx ) { return m_pucEdgeStartPos[uiIdx]; }
835	Void setEdgeStartPos( UInt uiIdx, UChar val ) { m_pucEdgeStartPos[uiIdx] = val; }
836	Bool* getEdgeLeftFirst( ) { return m_pbEdgeLeftFirst; }
837	Bool getEdgeLeftFirst( UInt uiIdx ) { return m_pbEdgeLeftFirst[uiIdx]; }
838	Void setEdgeLeftFirst( UInt uiIdx, Bool val ) { m_pbEdgeLeftFirst[uiIdx] = val; }
839	Bool* getEdgePartition( UInt uiIdx ) { return &m_pbEdgePartition[uiIdx * 16]; }
840	Void reconPartition( UInt uiAbsPartIdx, UInt uiDepth, Bool bLeft, UChar ucStartPos, UChar ucNumEdge, UChar* pucEdgeCode, Bool* pbRegion );
841
842	#if LGE_EDGE_INTRA_DELTA_DC
843	Int* getEdgeDeltaDC0( ) { return m_piEdgeDeltaDC0; }
844	Int* getEdgeDeltaDC1( ) { return m_piEdgeDeltaDC1; }
845	Int getEdgeDeltaDC0( UInt uiIdx ) { return m_piEdgeDeltaDC0[uiIdx]; }
846	Int getEdgeDeltaDC1( UInt uiIdx ) { return m_piEdgeDeltaDC1[uiIdx]; }
847	Void setEdgeDeltaDC0( UInt uiIdx, Int val ) { m_piEdgeDeltaDC0[uiIdx] = val; }
848	Void setEdgeDeltaDC1( UInt uiIdx, Int val ) { m_piEdgeDeltaDC1[uiIdx] = val; }
849	#endif
850	#endif
851
852	#if RWTH_SDC_DLT_B0036
853	Bool* getSDCFlag () { return m_pbSDCFlag; }
854	Bool getSDCFlag ( UInt uiIdx ) { return m_pbSDCFlag[uiIdx]; }
855	Void setSDCFlagSubParts ( Bool bSDCFlag, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth );
856
857	UInt getCtxSDCFlag ( UInt uiAbsPartIdx );
858
859	Bool getSDCAvailable ( UInt uiAbsPartIdx );
860
861	Pel* getSDCSegmentDCOffset( UInt uiSeg ) { return m_apSegmentDCOffset[uiSeg]; }
862	Pel getSDCSegmentDCOffset( UInt uiSeg, UInt uiPartIdx ) { return m_apSegmentDCOffset[uiSeg][uiPartIdx]; }
863	Void setSDCSegmentDCOffset( Pel pOffset, UInt uiSeg, UInt uiPartIdx) { m_apSegmentDCOffset[uiSeg][uiPartIdx] = pOffset; }
864	#endif
865	};
866
867	namespace RasterAddress
868	{
869	/** Check whether 2 addresses point to the same column
870	* \param addrA First address in raster scan order
871	* \param addrB Second address in raters scan order
872	* \param numUnitsPerRow Number of units in a row
873	* \return Result of test
874	*/
875	static inline Bool isEqualCol( Int addrA, Int addrB, Int numUnitsPerRow )
876	{
877	// addrA % numUnitsPerRow == addrB % numUnitsPerRow
878	return (( addrA ^ addrB ) & ( numUnitsPerRow - 1 ) ) == 0;
879	}
880
881	/** Check whether 2 addresses point to the same row
882	* \param addrA First address in raster scan order
883	* \param addrB Second address in raters scan order
884	* \param numUnitsPerRow Number of units in a row
885	* \return Result of test
886	*/
887	static inline Bool isEqualRow( Int addrA, Int addrB, Int numUnitsPerRow )
888	{
889	// addrA / numUnitsPerRow == addrB / numUnitsPerRow
890	return (( addrA ^ addrB ) &~ ( numUnitsPerRow - 1 ) ) == 0;
891	}
892
893	/** Check whether 2 addresses point to the same row or column
894	* \param addrA First address in raster scan order
895	* \param addrB Second address in raters scan order
896	* \param numUnitsPerRow Number of units in a row
897	* \return Result of test
898	*/
899	static inline Bool isEqualRowOrCol( Int addrA, Int addrB, Int numUnitsPerRow )
900	{
901	return isEqualCol( addrA, addrB, numUnitsPerRow ) \| isEqualRow( addrA, addrB, numUnitsPerRow );
902	}
903
904	/** Check whether one address points to the first column
905	* \param addr Address in raster scan order
906	* \param numUnitsPerRow Number of units in a row
907	* \return Result of test
908	*/
909	static inline Bool isZeroCol( Int addr, Int numUnitsPerRow )
910	{
911	// addr % numUnitsPerRow == 0
912	return ( addr & ( numUnitsPerRow - 1 ) ) == 0;
913	}
914
915	/** Check whether one address points to the first row
916	* \param addr Address in raster scan order
917	* \param numUnitsPerRow Number of units in a row
918	* \return Result of test
919	*/
920	static inline Bool isZeroRow( Int addr, Int numUnitsPerRow )
921	{
922	// addr / numUnitsPerRow == 0
923	return ( addr &~ ( numUnitsPerRow - 1 ) ) == 0;
924	}
925
926	/** Check whether one address points to a column whose index is smaller than a given value
927	* \param addr Address in raster scan order
928	* \param val Given column index value
929	* \param numUnitsPerRow Number of units in a row
930	* \return Result of test
931	*/
932	static inline Bool lessThanCol( Int addr, Int val, Int numUnitsPerRow )
933	{
934	// addr % numUnitsPerRow < val
935	return ( addr & ( numUnitsPerRow - 1 ) ) < val;
936	}
937
938	/** Check whether one address points to a row whose index is smaller than a given value
939	* \param addr Address in raster scan order
940	* \param val Given row index value
941	* \param numUnitsPerRow Number of units in a row
942	* \return Result of test
943	*/
944	static inline Bool lessThanRow( Int addr, Int val, Int numUnitsPerRow )
945	{
946	// addr / numUnitsPerRow < val
947	return addr < val * numUnitsPerRow;
948	}
949	};
950
951	//! \}
952
953	#endif

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

JCT-3V 3D-HEVC

Context navigation

source: 3DVCSoftware/branches/HTM-4.0.1-VSP-dev0/source/Lib/TLibCommon/TComDataCU.h @ 213

Download in other formats: