Context navigation

source: 3DVCSoftware/branches/HTM-5.1-dev0-MERL-Mediatek-Fix/source/Lib/TLibCommon/TComDepthMapGenerator.cpp @ 286

Visit:

Last change on this file since 286 was 280, checked in by tech, 12 years ago
Integration of branch dev 2.
Property svn:eol-style set to `native`
File size: 83.6 KB

Line
1	/* The copyright in this software is being made available under the BSD
2	* License, included below. This software may be subject to other third party
3	* and contributor rights, including patent rights, and no such rights are
4	* granted under this license.
5	*
6	* Copyright (c) 2010-2011, 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 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
35
36	/** \file TComDepthMapGenerator.cpp
37	\brief depth map generator class
38	*/
39
40
41
42	#include "CommonDef.h"
43	#include "TComDepthMapGenerator.h"
44
45
46	#if DEPTH_MAP_GENERATION
47
48
49	TComDepthMapGenerator::TComDepthMapGenerator()
50	{
51	m_bCreated = false;
52	m_bInit = false;
53	m_bDecoder = false;
54	m_pcPrediction = 0;
55	m_pcSPSAccess = 0;
56	m_pcAUPicAccess = 0;
57	m_uiMaxDepth = 0;
58	m_uiOrgDepthBitDepth = 0;
59	m_uiSubSampExpX = 0;
60	m_uiSubSampExpY = 0;
61	m_ppcYuv = 0;
62	m_ppcCU = 0;
63	}
64
65	TComDepthMapGenerator::~TComDepthMapGenerator()
66	{
67	destroy ();
68	uninit ();
69	}
70
71	Void
72	TComDepthMapGenerator::create( Bool bDecoder, UInt uiPicWidth, UInt uiPicHeight, UInt uiMaxCUDepth, UInt uiMaxCUWidth, UInt uiMaxCUHeight, UInt uiOrgBitDepth, UInt uiSubSampExpX, UInt uiSubSampExpY )
73	{
74	destroy();
75	m_bDecoder = bDecoder;
76	m_uiMaxDepth = uiMaxCUDepth;
77	m_uiOrgDepthBitDepth = uiOrgBitDepth;
78	m_uiSubSampExpX = uiSubSampExpX;
79	m_uiSubSampExpY = uiSubSampExpY;
80	#if !QC_MULTI_DIS_CAN_A0097
81	m_ppcYuv = new TComYuv* [ m_uiMaxDepth ];
82	m_ppcCU = new TComDataCU* [ m_uiMaxDepth ];
83	for( UInt uiDepth = 0; uiDepth < m_uiMaxDepth; uiDepth++ )
84	{
85	UInt uiNumPart = 1 << ( ( m_uiMaxDepth - uiDepth ) << 1 );
86	UInt uiWidth = uiMaxCUWidth >> uiDepth;
87	UInt uiHeight = uiMaxCUHeight >> uiDepth;
88
89	m_ppcYuv[ uiDepth ] = new TComYuv; m_ppcYuv[ uiDepth ]->create( uiWidth >> m_uiSubSampExpX, uiHeight >> m_uiSubSampExpY );
90	m_ppcCU [ uiDepth ] = new TComDataCU; m_ppcCU [ uiDepth ]->create( uiNumPart, uiWidth, uiHeight, true, uiMaxCUWidth >> (uiMaxCUDepth - 1) );
91	}
92	m_cTmpPic.create( uiPicWidth >> m_uiSubSampExpX, uiPicHeight >> m_uiSubSampExpY, uiMaxCUWidth >> m_uiSubSampExpX, uiMaxCUHeight >> m_uiSubSampExpY, uiMaxCUDepth );
93	xSetChroma( &m_cTmpPic, ( 1 << uiOrgBitDepth ) >> 1 );
94	#endif
95	m_bCreated = true;
96	}
97
98	Void
99	TComDepthMapGenerator::destroy()
100	{
101	if( m_bCreated )
102	{
103	m_bCreated = false;
104	#if !QC_MULTI_DIS_CAN_A0097
105	for( UInt uiDepth = 0; uiDepth < m_uiMaxDepth; uiDepth++ )
106	{
107	if( m_ppcYuv[ uiDepth ] )
108	{
109	m_ppcYuv[ uiDepth ]->destroy(); delete m_ppcYuv[ uiDepth ]; m_ppcYuv[ uiDepth ] = 0;
110	}
111	if( m_ppcCU [ uiDepth ] )
112	{
113	m_ppcCU [ uiDepth ]->destroy(); delete m_ppcCU [ uiDepth ]; m_ppcCU [ uiDepth ] = 0;
114	}
115	}
116	delete [] m_ppcYuv; m_ppcYuv = 0;
117	delete [] m_ppcCU; m_ppcCU = 0;
118	m_cTmpPic.destroy();
119	#endif
120	m_uiMaxDepth = 0;
121	m_uiOrgDepthBitDepth = 0;
122	m_uiSubSampExpX = 0;
123	m_uiSubSampExpY = 0;
124	m_bDecoder = false;
125	}
126	}
127
128	#if VIDYO_VPS_INTEGRATION
129	Void
130	TComDepthMapGenerator::init( TComPrediction* pcPrediction, TComVPSAccess* pcVPSAccess, TComSPSAccess* pcSPSAccess, TComAUPicAccess* pcAUPicAccess )
131	#else
132	Void
133	TComDepthMapGenerator::init( TComPrediction* pcPrediction, TComSPSAccess* pcSPSAccess, TComAUPicAccess* pcAUPicAccess )
134	#endif
135	{
136	AOF( pcPrediction );
137	AOF( pcSPSAccess );
138	AOF( pcAUPicAccess );
139	uninit();
140	m_pcPrediction = pcPrediction;
141	#if VIDYO_VPS_INTEGRATION
142	m_pcVPSAccess = pcVPSAccess;
143	#endif
144	m_pcSPSAccess = pcSPSAccess;
145	m_pcAUPicAccess = pcAUPicAccess;
146	m_bInit = true;
147	}
148
149	Void
150	TComDepthMapGenerator::uninit()
151	{
152	if( m_bInit )
153	{
154	m_bInit = false;
155	m_pcPrediction = 0;
156	m_pcSPSAccess = 0;
157	m_pcAUPicAccess = 0;
158	}
159	}
160
161	Void
162	TComDepthMapGenerator::initViewComponent( TComPic* pcPic )
163	{
164	AOF ( m_bCreated && m_bInit );
165	AOF ( pcPic );
166	AOT ( pcPic->getSPS()->getViewId() && !pcPic->getSPS()->isDepth() && pcPic->getPOC() && pcPic->getSPS()->getPredDepthMapGeneration() != m_pcSPSAccess->getPdm() );
167	m_bPDMAvailable = false;
168	m_uiCurrViewId = pcPic->getSPS()->getViewId();
169	#if PDM_REMOVE_DEPENDENCE
170	pcPic->setStoredPDMforV2(0);
171	#endif
172	// update SPS list and AU pic list and set depth map generator in SPS
173	#if VIDYO_VPS_INTEGRATION
174	m_pcVPSAccess ->addVPS( pcPic->getVPS() );
175	#endif
176	m_pcSPSAccess ->addSPS( pcPic->getSPS() );
177	m_pcAUPicAccess->addPic( pcPic );
178	pcPic->getSPS()->setDepthMapGenerator( this );
179
180	// check whether we have depth data or don't use pred depth prediction
181	ROFVS( pcPic->getSPS()->getViewId() );
182	ROTVS( pcPic->getSPS()->isDepth () );
183	ROFVS( m_pcSPSAccess->getPdm () );
184
185	// set basic SPS parameters
186	const Int iDisparityDir = 1; // 1 or -1, depending on the usage of disparity vectors
187	TComSPS* pcSPS = pcPic->getSPS ();
188	Int iVOI = pcSPS->getViewOrderIdx ();
189	UInt uiPdmPrec = pcSPS->getPdmPrecision ();
190	UInt uiCamPrec = pcSPS->getCamParPrecision ();
191	Bool bInSlice = pcSPS->hasCamParInSliceHeader ();
192	Int iScaleVOI01 = ( 1 << ( uiPdmPrec + PDM_INTER_CALC_SHIFT + PDM_VIRT_DEPTH_PRECISION - 2 ) );
193
194	// check availability of base views and set base id list
195	std::vector<Int> aiAbsDeltaVOI;
196	for( UInt uiBaseId = 0; uiBaseId < m_uiCurrViewId; uiBaseId++ )
197	{
198	TComSPS* pcBaseSPS = m_pcSPSAccess ->getSPS( uiBaseId );
199	TComPic* pcBasePic = m_pcAUPicAccess->getPic( uiBaseId );
200	AOF( pcBaseSPS != 0 && pcBasePic != 0 );
201	Int iDeltaVOI = iVOI - pcBaseSPS->getViewOrderIdx();
202	Int iAbsDeltaVOI = ( iDeltaVOI < 0 ? -iDeltaVOI : iDeltaVOI );
203	AOT( iAbsDeltaVOI == 0 );
204	aiAbsDeltaVOI.push_back( iAbsDeltaVOI );
205	}
206	m_auiBaseIdList.clear();
207	while( (UInt)m_auiBaseIdList.size() < m_uiCurrViewId )
208	{
209	Int iMinAbsDelta = MAX_INT;
210	UInt uiNextBaseId = MAX_VIEW_NUM;
211	for( UInt uiBaseId = 0; uiBaseId < m_uiCurrViewId; uiBaseId++ )
212	{
213	if( aiAbsDeltaVOI[ uiBaseId ] > 0 && aiAbsDeltaVOI[ uiBaseId ] <= iMinAbsDelta )
214	{
215	iMinAbsDelta = aiAbsDeltaVOI[ uiBaseId ];
216	uiNextBaseId = uiBaseId;
217	}
218	}
219	m_auiBaseIdList.push_back( uiNextBaseId );
220	aiAbsDeltaVOI[ uiNextBaseId ] = 0;
221	}
222
223	// check availability of prediction depth map
224	if( m_uiCurrViewId )
225	{
226	#if PDM_REMOVE_DEPENDENCE
227	UInt uiBaseVId = m_auiBaseIdList[0];
228	#else
229	Bool bCheckVId1 = ( m_uiCurrViewId > 1 && m_auiBaseIdList[0] == 0 );
230	UInt uiBaseVId = ( bCheckVId1 ? 1 : m_auiBaseIdList[0] );
231	#endif
232	TComPic* pcBasePic = m_pcAUPicAccess->getPic( uiBaseVId );
233	SliceType eSliceType = pcBasePic->getCurrSlice()->getSliceType();
234	Bool bNoRAPdm = ( pcPic->getSPS()->getPredDepthMapGeneration() == 1 );
235	m_bPDMAvailable = ( eSliceType != I_SLICE \|\| !bNoRAPdm );
236	}
237
238	// update disparity depth conversion parameters
239	for( UInt uiBaseId = 0; uiBaseId < m_uiCurrViewId; uiBaseId++ )
240	{
241	TComSPS* pcBaseSPS = m_pcSPSAccess->getSPS( uiBaseId );
242	Int iBaseVOI = pcBaseSPS->getViewOrderIdx();
243
244	// disparity -> virtual depth
245	Int iVNominator = ( 1 << PDM_LOG4_SCALE_DENOMINATOR ) + pcSPS->getPdmScaleNomDelta()[ uiBaseId ];
246	Int iVDiv = iVOI - iBaseVOI;
247	Int iVAdd = ( iVDiv > 0 ? iVDiv / 2 : -iVDiv / 2 );
248	Int iVScalePred = ( iScaleVOI01 + iVAdd ) / iVDiv;
249	Int iVShift = PDM_INTER_CALC_SHIFT;
250	Int iVScale = Int( ( (Int64)iVNominator * (Int64)iVScalePred + (Int64)( ( 1 << PDM_LOG4_SCALE_DENOMINATOR ) >> 1 ) ) >> PDM_LOG4_SCALE_DENOMINATOR );
251	Int iVOffset = pcSPS->getPdmOffset()[ uiBaseId ] << PDM_OFFSET_SHIFT;
252	m_aaiConvParsDisparity2VirtDepth[ uiBaseId ][ 0 ] = iDisparityDir * iVScale;
253	m_aaiConvParsDisparity2VirtDepth[ uiBaseId ][ 1 ] = iDisparityDir * iVOffset + ( ( 1 << iVShift ) >> 1 );
254	m_aaiConvParsDisparity2VirtDepth[ uiBaseId ][ 2 ] = iVShift;
255
256	// virtual depth -> disparity
257	Int iVInvAdd = ( iVScale > 0 ? iVScale / 2 : -iVScale / 2 );
258	Int iVInvScale = Int( ( ( Int64( 1 ) << ( iVShift << 1 ) ) + iVInvAdd ) / Int64( iVScale ) );
259	Int iVInvOffset = Int( ( ( Int64( -iVOffset ) << iVShift ) + iVInvAdd ) / Int64( iVScale ) );
260	m_aaiConvParsVirtDepth2Disparity[ uiBaseId ][ 0 ] = iDisparityDir * iVInvScale;
261	m_aaiConvParsVirtDepth2Disparity[ uiBaseId ][ 1 ] = iDisparityDir * iVInvOffset + ( ( 1 << iVShift ) >> 1 );
262	m_aaiConvParsVirtDepth2Disparity[ uiBaseId ][ 2 ] = iVShift;
263
264	// coded depth -> virtual depth
265	Int iCScale = ( bInSlice ? pcPic->getCurrSlice()->getCodedScale () : pcSPS->getCodedScale () )[ uiBaseId ];
266	Int iCOffset = ( bInSlice ? pcPic->getCurrSlice()->getCodedOffset() : pcSPS->getCodedOffset() )[ uiBaseId ] << m_uiOrgDepthBitDepth;
267	Int iCShift = m_uiOrgDepthBitDepth + uiCamPrec + 1 - 2;
268	Int iCVShift = PDM_INTER_CALC_SHIFT;
269	Int iTmpShift = iVShift + iCShift - iCVShift; AOF( iTmpShift >= 0 )
270	Int iCVScale = Int( ( Int64( iVScale ) * Int64( iCScale ) + Int64( ( 1 << iTmpShift ) >> 1 ) ) >> iTmpShift );
271	Int iCVOffset = Int( ( Int64( iVScale ) * Int64( iCOffset ) + Int64( ( 1 << iTmpShift ) >> 1 ) ) >> iTmpShift );
272	iTmpShift = iVShift - iCVShift; AOF( iTmpShift >= 0 )
273	iCVOffset += ( iVOffset + ( ( 1 << iTmpShift ) >> 1 ) ) >> iTmpShift;
274	m_aaiConvParsOrigDepth2VirtDepth[ uiBaseId ][ 0 ] = iCVScale;
275	m_aaiConvParsOrigDepth2VirtDepth[ uiBaseId ][ 1 ] = iCVOffset + ( ( 1 << iCVShift ) >> 1 );
276	m_aaiConvParsOrigDepth2VirtDepth[ uiBaseId ][ 2 ] = iCVShift;
277
278	// virtual depth -> coded depth
279	Int iCVAdd = ( iCVScale > 0 ? iCVScale / 2 : -iCVScale / 2 );
280	Int iCVInvScale = Int( ( ( Int64( 1 ) << ( iCVShift << 1 ) ) + iCVAdd ) / Int64( iCVScale ) );
281	Int iCVInvOffset= Int( ( ( Int64( -iCVOffset ) << iCVShift ) + iCVAdd ) / Int64( iCVScale ) );
282	m_aaiConvParsVirtDepth2OrigDepth[ uiBaseId ][ 0 ] = iCVInvScale;
283	m_aaiConvParsVirtDepth2OrigDepth[ uiBaseId ][ 1 ] = iCVInvOffset + ( ( 1 << iCVShift ) >> 1 );
284	m_aaiConvParsVirtDepth2OrigDepth[ uiBaseId ][ 2 ] = iCVShift;
285	}
286
287	if( m_uiCurrViewId > 0 )
288	{
289	UInt uiBaseId = 0;
290	UInt uiBaseVOI = 0; // per definition
291	Int iVNominator = ( 1 << PDM_LOG4_SCALE_DENOMINATOR ) + pcSPS->getPdmScaleNomDelta()[ uiBaseId ];
292	Int iVDiv = iVOI - uiBaseVOI;
293	Int iVAdd = ( iVDiv > 0 ? iVDiv / 2 : -iVDiv / 2 );
294	Int iVScalePred = ( iScaleVOI01 + iVAdd ) / iVDiv;
295	Int iVShift = PDM_INTER_CALC_SHIFT;
296	Int iVScale = Int( ( (Int64)iVNominator * (Int64)iVScalePred + (Int64)( ( 1 << PDM_LOG4_SCALE_DENOMINATOR ) >> 1 ) ) >> PDM_LOG4_SCALE_DENOMINATOR );
297	Int iVOffset = pcSPS->getPdmOffset()[ uiBaseId ] << PDM_OFFSET_SHIFT;
298
299	// coded depth -> virtual depth (current view)
300	Int iCScale = ( bInSlice ? pcPic->getCurrSlice()->getInvCodedScale () : pcSPS->getInvCodedScale () )[ uiBaseId ];
301	Int iCOffset = ( bInSlice ? pcPic->getCurrSlice()->getInvCodedOffset() : pcSPS->getInvCodedOffset() )[ uiBaseId ] << m_uiOrgDepthBitDepth;
302	Int iCShift = m_uiOrgDepthBitDepth + uiCamPrec + 1 - 2;
303	Int iCVShift = PDM_INTER_CALC_SHIFT;
304	Int iTmpShift = iVShift + iCShift - iCVShift; AOF( iTmpShift >= 0 )
305	Int iCVScale = Int( ( Int64( -iVScale ) * Int64( iCScale ) + Int64( ( 1 << iTmpShift ) >> 1 ) ) >> iTmpShift );
306	Int iCVOffset = Int( ( Int64( -iVScale ) * Int64( iCOffset ) + Int64( ( 1 << iTmpShift ) >> 1 ) ) >> iTmpShift );
307	iTmpShift = iVShift - iCVShift; AOF( iTmpShift >= 0 )
308	iCVOffset += ( iVOffset + ( ( 1 << iTmpShift ) >> 1 ) ) >> iTmpShift;
309	m_aaiConvParsOrigDepth2VirtDepth[ m_uiCurrViewId ][ 0 ] = iCVScale;
310	m_aaiConvParsOrigDepth2VirtDepth[ m_uiCurrViewId ][ 1 ] = iCVOffset + ( ( 1 << iCVShift ) >> 1 );
311	m_aaiConvParsOrigDepth2VirtDepth[ m_uiCurrViewId ][ 2 ] = iCVShift;
312
313	// virtual depth -> coded depth
314	Int iCVAdd = ( iCVScale > 0 ? iCVScale / 2 : -iCVScale / 2 );
315	Int iCVInvScale = Int( ( ( Int64( 1 ) << ( iCVShift << 1 ) ) + iCVAdd ) / Int64( iCVScale ) );
316	Int iCVInvOffset= Int( ( ( Int64( -iCVOffset ) << iCVShift ) + iCVAdd ) / Int64( iCVScale ) );
317	m_aaiConvParsVirtDepth2OrigDepth[ m_uiCurrViewId ][ 0 ] = iCVInvScale;
318	m_aaiConvParsVirtDepth2OrigDepth[ m_uiCurrViewId ][ 1 ] = iCVInvOffset + ( ( 1 << iCVShift ) >> 1 );
319	m_aaiConvParsVirtDepth2OrigDepth[ m_uiCurrViewId ][ 2 ] = iCVShift;
320	}
321	else if( pcPic->getPOC() == 0 )
322	{ // set dummy values
323	m_aaiConvParsOrigDepth2VirtDepth[ m_uiCurrViewId ][ 0 ] = 0;
324	m_aaiConvParsOrigDepth2VirtDepth[ m_uiCurrViewId ][ 1 ] = 0;
325	m_aaiConvParsOrigDepth2VirtDepth[ m_uiCurrViewId ][ 2 ] = 0;
326	m_aaiConvParsVirtDepth2OrigDepth[ m_uiCurrViewId ][ 0 ] = 0;
327	m_aaiConvParsVirtDepth2OrigDepth[ m_uiCurrViewId ][ 1 ] = 0;
328	m_aaiConvParsVirtDepth2OrigDepth[ m_uiCurrViewId ][ 2 ] = 0;
329	}
330
331
332	#if 0 // print out for debugging
333	if( m_uiCurrViewId )
334	{
335	printf( "\n\ninit slice of view %d (VOI=%2d):\n===============================\n", m_uiCurrViewId, iVOI );
336	{
337	printf( "\n disparity -> virtual depth:\n" );
338	for( UInt uiBaseId = 0; uiBaseId < m_uiCurrViewId; uiBaseId++ )
339	{
340	Int* pP = m_aaiConvParsDisparity2VirtDepth[ uiBaseId ];
341	Double dF = 1.0 / Double( 1 << pP[ 2 ] );
342	Double dA = dF * Double( pP[ 0 ] );
343	Double dB = dF * Double( pP[ 1 ] - ( ( 1 << pP[ 2 ] ) >> 1 ) );
344	printf( " BId=%d: a = %10.4lf b = %10.4lf\n", uiBaseId, dA, dB );
345	}
346	printf( "\n virtual depth -> disparity:\n" );
347	for( UInt uiBaseId = 0; uiBaseId < m_uiCurrViewId; uiBaseId++ )
348	{
349	Int* pP = m_aaiConvParsVirtDepth2Disparity[ uiBaseId ];
350	Double dF = 1.0 / Double( 1 << pP[ 2 ] );
351	Double dA = dF * Double( pP[ 0 ] );
352	Double dB = dF * Double( pP[ 1 ] - ( ( 1 << pP[ 2 ] ) >> 1 ) );
353	printf( " BId=%d: a = %10.4lf b = %10.4lf\n", uiBaseId, dA, dB );
354	}
355	printf( "\n original depth -> virtual depth:\n" );
356	for( UInt uiBaseId = 0; uiBaseId <= m_uiCurrViewId; uiBaseId++ )
357	{
358	Int* pP = m_aaiConvParsOrigDepth2VirtDepth[ uiBaseId ];
359	Double dF = 1.0 / Double( 1 << pP[ 2 ] );
360	Double dA = dF * Double( pP[ 0 ] );
361	Double dB = dF * Double( pP[ 1 ] - ( ( 1 << pP[ 2 ] ) >> 1 ) );
362	printf( " VId=%d: a = %10.4lf b = %10.4lf\n", uiBaseId, dA, dB );
363	}
364	printf( "\n virtual depth -> original depth:\n" );
365	for( UInt uiBaseId = 0; uiBaseId <= m_uiCurrViewId; uiBaseId++ )
366	{
367	Int* pP = m_aaiConvParsVirtDepth2OrigDepth[ uiBaseId ];
368	Double dF = 1.0 / Double( 1 << pP[ 2 ] );
369	Double dA = dF * Double( pP[ 0 ] );
370	Double dB = dF * Double( pP[ 1 ] - ( ( 1 << pP[ 2 ] ) >> 1 ) );
371	printf( " VId=%d: a = %10.4lf b = %10.4lf\n", uiBaseId, dA, dB );
372	}
373	printf( "\n" );
374	}
375	}
376	#endif
377	}
378
379	#if !QC_MULTI_DIS_CAN_A0097
380	Bool
381	TComDepthMapGenerator::predictDepthMap( TComPic* pcPic )
382	{
383	AOF ( m_bCreated && m_bInit );
384	AOF ( pcPic );
385	ROTRS( pcPic->getSPS()->isDepth(), true );
386	ROFRS( m_pcSPSAccess->getPdm(), true );
387	AOF ( pcPic->getPredDepthMap() );
388	AOF ( pcPic->getSPS()->getViewId() == m_uiCurrViewId );
389
390	#if PDM_OUTPUT_PRED_DEPTH_MAP
391	Char acFilenameBase[1024];
392	::sprintf( acFilenameBase, "PDM_%s_Prd", ( m_bDecoder ? "Dec" : "Enc" ) );
393	#endif
394
395	Bool bUndefined = true;
396	if( m_uiCurrViewId )
397	{
398	AOF( m_auiBaseIdList.size() );
399	UInt uiBaseId = m_auiBaseIdList[ 0 ];
400	TComPic* pcBasePic = m_pcAUPicAccess->getPic( uiBaseId );
401	AOF( pcBasePic );
402
403	if( m_uiCurrViewId == 1 )
404	{
405	if( pcBasePic->getPOC() == 0 )
406	{
407	pcBasePic->removePrdDepthMapBuffer();
408	pcBasePic->addPrdDepthMapBuffer( PDM_SUB_SAMP_EXP_X(m_pcSPSAccess->getPdm()), PDM_SUB_SAMP_EXP_Y(m_pcSPSAccess->getPdm()) );
409	xClearDepthMap( pcBasePic );
410	#if PDM_REMOVE_DEPENDENCE
411	xClearDepthMap( pcBasePic, PDM_UNDEFINED_DEPTH, 1 );
412	#endif
413	}
414	#if PDM_OUTPUT_PRED_DEPTH_MAP
415	dumpDepthMap( pcBasePic, acFilenameBase );
416	#endif
417	}
418
419	Bool bLoadDepth = ( m_pcSPSAccess->getPdm() == 2 );
420	if( m_pcSPSAccess->getPdm() > 2 )
421	{
422	bLoadDepth = ( pcBasePic->getCurrSlice()->getSliceType() == I_SLICE );
423	}
424
425	if( bLoadDepth)
426	{ // load coded depth of base view
427	TComPic* pcBaseDepth = m_pcAUPicAccess->getPic( uiBaseId, true );
428	AOF( pcBaseDepth );
429	AOF( pcBaseDepth->getPicYuvRec() );
430	AOF( pcBaseDepth->getPicYuvRec()->getWidth () == pcBasePic->getPredDepthMap()->getWidth () );
431	AOF( pcBaseDepth->getPicYuvRec()->getHeight() == pcBasePic->getPredDepthMap()->getHeight() );
432	Int iWidth = pcBasePic ->getPredDepthMap()->getWidth ();
433	Int iHeight = pcBasePic ->getPredDepthMap()->getHeight ();
434	Int iDesStride = pcBasePic ->getPredDepthMap()->getStride ();
435	Int iSrcStride = pcBaseDepth->getPicYuvRec ()->getStride ();
436	Pel* pDesSamples = pcBasePic ->getPredDepthMap()->getLumaAddr ( 0 );
437	Pel* pSrcSamples = pcBaseDepth->getPicYuvRec ()->getLumaAddr ( 0 );
438	for( Int iY = 0; iY < iHeight; iY++, pSrcSamples += iSrcStride, pDesSamples += iDesStride )
439	{
440	for( Int iX = 0; iX < iWidth; iX++ )
441	{
442	pDesSamples[ iX ] = xGetVirtDepthFromOrigDepth( uiBaseId, pSrcSamples[ iX ] );
443	}
444	}
445	}
446
447	// convert depth of base view to current view
448	bUndefined = xConvertDepthMapRef2Curr( pcPic, pcBasePic );
449
450	#if PDM_OUTPUT_PRED_DEPTH_MAP
451	dumpDepthMap( pcPic, acFilenameBase );
452	#endif
453	}
454	else
455	{
456	xClearDepthMap( pcPic );
457	#if PDM_REMOVE_DEPENDENCE
458	xClearDepthMap( pcPic, PDM_UNDEFINED_DEPTH, 1 );
459	#endif
460	}
461	return bUndefined;
462	}
463
464
465	Void
466	TComDepthMapGenerator::updateDepthMap( TComPic* pcPic )
467	{
468	AOF ( m_bCreated && m_bInit );
469	AOF ( pcPic );
470	ROTVS( pcPic->getSPS()->isDepth() );
471	ROFVS( m_pcSPSAccess->getPdm() == 1 \|\| m_pcSPSAccess->getPdm() == 3 );
472	AOF ( pcPic->getPredDepthMap() );
473	AOF ( pcPic->getSPS()->getViewId() == m_uiCurrViewId );
474
475	#if PDM_OUTPUT_PRED_DEPTH_MAP
476	Char acFilenameBase[1024];
477	::sprintf( acFilenameBase, "PDM_%s_Upd", ( m_bDecoder ? "Dec" : "Enc" ) );
478	#endif
479
480	// predict depth map using current coding symbols
481	#if PDM_REMOVE_DEPENDENCE
482	pcPic->setStoredPDMforV2(0);
483	xPredictDepthMap( pcPic );
484	if(m_uiCurrViewId==0)
485	{
486	pcPic->setStoredPDMforV2(1);
487	xPredictDepthMap( pcPic );
488	pcPic->setStoredPDMforV2(0);
489	}
490	#else
491	xPredictDepthMap( pcPic );
492	#if PDM_OUTPUT_PRED_DEPTH_MAP
493	if( m_uiCurrViewId )
494	{
495	dumpDepthMap( pcPic, acFilenameBase );
496	}
497	#endif
498	#endif
499
500	// generate base depth map
501	if( m_uiCurrViewId == 1 )
502	{
503	TComPic* pcBasePic = m_pcAUPicAccess->getPic( 0 );
504	AOF( pcBasePic );
505	xConvertDepthMapCurr2Ref( pcBasePic, pcPic );
506	#if PDM_OUTPUT_PRED_DEPTH_MAP
507	dumpDepthMap( pcBasePic, acFilenameBase );
508	#endif
509	}
510	#if PDM_REMOVE_DEPENDENCE
511	if( m_uiCurrViewId == 2 )
512	{
513	TComPic* pcBasePic = m_pcAUPicAccess->getPic( 0 );
514	AOF( pcBasePic );
515	xConvertDepthMapCurr2Ref( pcBasePic, pcPic );
516	#if PDM_OUTPUT_PRED_DEPTH_MAP
517	dumpDepthMap( pcBasePic, acFilenameBase );
518	#endif
519	}
520	#endif
521	}
522
523
524	Void
525	TComDepthMapGenerator::dumpDepthMap( TComPic* pcPic, char* pFilenameBase )
526	{
527	AOF( m_bCreated && m_bInit );
528	AOF( pcPic );
529	AOF( pFilenameBase );
530	AOF( m_uiOrgDepthBitDepth == 8 + g_uiBitIncrement );
531	AOF( pcPic->getSPS()->getViewId() <= m_uiCurrViewId );
532
533	// convert to output format
534	Int iMax = ( 1 << m_uiOrgDepthBitDepth ) - 1;
535	UInt uiViewId = pcPic->getSPS()->getViewId();
536	TComPicYuv* pcPicYuv = pcPic->getPredDepthMap();
537	Int iWidth = pcPicYuv->getWidth ();
538	Int iHeight = pcPicYuv->getHeight ();
539	Int iSrcStride = pcPicYuv->getStride ();
540	Int iDstStride = m_cTmpPic.getStride ();
541	#if PDM_REMOVE_DEPENDENCE
542	if(pcPic->getStoredPDMforV2())
543	pcPicYuv = pcPic->getPredDepthMapTemp();
544	#endif
545	Pel* pSrcSamples = pcPicYuv->getLumaAddr ( 0 );
546	Pel* pDstSamples = m_cTmpPic.getLumaAddr ( 0 );
547	Int iMidOrgDpth = ( 1 << m_uiOrgDepthBitDepth ) >> 1;
548	AOF( m_cTmpPic.getWidth () == iWidth );
549	AOF( m_cTmpPic.getHeight() == iHeight );
550	for( Int iY = 0; iY < iHeight; iY++, pSrcSamples += iSrcStride, pDstSamples += iDstStride )
551	{
552	for( Int iX = 0; iX < iWidth; iX++ )
553	{
554	Int iOrgDepth = ( pSrcSamples[ iX ] != PDM_UNDEFINED_DEPTH ? xGetOrigDepthFromVirtDepth( uiViewId, pSrcSamples[ iX ] ) : iMidOrgDpth );
555	pDstSamples[ iX ] = Max( 0, Min( iMax, iOrgDepth ) );
556	}
557	}
558
559	// output
560	Char acFilename[1024];
561	::sprintf ( acFilename, "%s_V%d.yuv", pFilenameBase, uiViewId );
562	m_cTmpPic.dump( acFilename, ( pcPic->getPOC() != 0 ) );
563	}
564
565	#endif
566
567	#if HHI_INTER_VIEW_MOTION_PRED
568	Void
569	TComDepthMapGenerator::covertOrgDepthMap( TComPic* pcPic )
570	{
571	AOF ( m_bCreated && m_bInit );
572	AOF ( pcPic );
573	ROFVS( pcPic->getOrgDepthMap() );
574	AOF ( pcPic->getViewId() );
575
576	UInt uiBaseId = pcPic->getViewId();
577	Int iWidth = pcPic->getOrgDepthMap()->getWidth ();
578	Int iHeight = pcPic->getOrgDepthMap()->getHeight ();
579	Int iStride = pcPic->getOrgDepthMap()->getStride ();
580	Pel* pSamples = pcPic->getOrgDepthMap()->getLumaAddr ( 0 );
581	for( Int iY = 0; iY < iHeight; iY++, pSamples += iStride )
582	{
583	for( Int iX = 0; iX < iWidth; iX++ )
584	{
585	pSamples[ iX ] = xGetVirtDepthFromOrigDepth( uiBaseId, pSamples[ iX ] );
586	}
587	}
588	}
589	#endif
590
591	Int
592	TComDepthMapGenerator::getDisparity( TComPic* pcPic, Int iPosX, Int iPosY, UInt uiRefViewId )
593	{
594	AOF( pcPic );
595	AOF( pcPic->getPredDepthMap() );
596	AOF( iPosX >= 0 && iPosX < pcPic->getPredDepthMap()->getWidth () );
597	AOF( iPosY >= 0 && iPosY < pcPic->getPredDepthMap()->getHeight() );
598	Pel* piPdmMap = pcPic->getPredDepthMap()->getLumaAddr( 0 );
599	Int iStride = pcPic->getPredDepthMap()->getStride ();
600	Int iPrdDepth = piPdmMap[ iPosX + iPosY * iStride ];
601	Int iDisparity = xGetDisparityFromVirtDepth( uiRefViewId, iPrdDepth );
602	return iDisparity;
603	}
604
605
606
607	#if HHI_INTER_VIEW_MOTION_PRED
608	#if QC_AMVP_MRG_UNIFY_IVCAN_C0051
609	Bool
610	TComDepthMapGenerator::getPdmCandidate(TComDataCU* pcCU, UInt uiPartIdx, RefPicList eRefPicList, Int iRefIdx, Int* paiPdmRefIdx, TComMv* pacPdmMv, DisInfo* pDInfo, Int* iPdm, Bool bMerge )
611	{
612	AOF ( m_bCreated && m_bInit );
613	TComSlice* pcSlice = pcCU->getSlice ();
614	TComSPS* pcSPS = pcSlice->getSPS();
615	AOF ( pcSPS->getViewId() == m_uiCurrViewId );
616
617	TComPic* pcRefPic = pcSlice->getRefPic( eRefPicList, iRefIdx );
618	UInt uiRefViewId = pcRefPic->getSPS()->getViewId();
619	Bool bInterview = ( uiRefViewId < m_uiCurrViewId );
620	Bool bPdmIView = ( ( pcSPS->getMultiviewMvPredMode() & PDM_USE_FOR_IVIEW ) == PDM_USE_FOR_IVIEW );
621	Bool bPdmInter = ( ( pcSPS->getMultiviewMvPredMode() & PDM_USE_FOR_INTER ) == PDM_USE_FOR_INTER );
622	Bool bPdmMerge = ( ( pcSPS->getMultiviewMvPredMode() & PDM_USE_FOR_MERGE ) == PDM_USE_FOR_MERGE );
623	if(!bMerge)
624	{
625	ROTRS( ( bInterview && !bMerge ) && !bPdmIView, false );
626	ROTRS( (!bInterview && !bMerge ) && !bPdmInter, false );
627	ROTRS( bMerge && !bPdmMerge, false );
628	}
629	else
630	ROTRS( !bPdmMerge, 0 );
631
632	#if QC_MRG_CANS_B0048
633	Bool abPdmAvailable[4] = {false, false, false, false};
634	#else
635	Bool abPdmAvailable[2] = {false,false};
636	#endif
637
638	Int iValid = 0;
639	Int iViewId = 0;
640	for( UInt uiBId = 0; uiBId < m_uiCurrViewId && iValid==0; uiBId++ )
641	{
642	#if MTK_C0138_FIXED
643	UInt uiBaseId = uiBId;
644	#else
645	UInt uiBaseId = m_auiBaseIdList[ uiBId ];
646	#endif
647	TComPic* pcBasePic = m_pcAUPicAccess->getPic( uiBaseId );
648	for( Int iRefListId = 0; iRefListId < 2 && iValid==0; iRefListId++ )
649	{
650	RefPicList eRefPicListTest = RefPicList( iRefListId );
651	Int iNumRefPics = pcSlice->getNumRefIdx( eRefPicListTest ) ;
652	for( Int iRefIndex = 0; iRefIndex < iNumRefPics; iRefIndex++ )
653	{
654	if(pcBasePic->getPOC() == pcSlice->getRefPic( eRefPicListTest, iRefIndex )->getPOC()
655	&& pcBasePic->getViewId() == pcSlice->getRefPic( eRefPicListTest, iRefIndex )->getViewId())
656	{
657	iValid=1;
658	iViewId = uiBaseId;
659	break;
660	}
661	}
662	}
663	}
664	if (iValid == 0)
665	return false;
666
667	//--- get base CU/PU and check prediction mode ---
668	TComPic* pcBasePic = m_pcAUPicAccess->getPic( iViewId );
669	TComPicYuv* pcBaseRec = pcBasePic->getPicYuvRec ();
670	if(bMerge \|\| !bInterview)
671	{
672	#if QC_MULTI_DIS_CAN_A0097
673	Int iCurrPosX, iCurrPosY;
674	UInt uiPartAddr;
675	Int iWidth;
676	Int iHeight;
677
678	pcCU->getPartIndexAndSize( uiPartIdx, uiPartAddr, iWidth, iHeight );
679	pcBaseRec->getTopLeftSamplePos( pcCU->getAddr(), pcCU->getZorderIdxInCU() + uiPartAddr, iCurrPosX, iCurrPosY );
680	iCurrPosX += ( ( iWidth - 1 ) >> 1 );
681	iCurrPosY += ( ( iHeight - 1 ) >> 1 );
682
683	Int iBasePosX = Clip3( 0, pcBaseRec->getWidth () - 1, iCurrPosX + ( (pDInfo->m_acMvCand[0].getHor() + 2 ) >> 2 ) );
684	Int iBasePosY = Clip3( 0, pcBaseRec->getHeight() - 1, iCurrPosY + ( (pDInfo->m_acMvCand[0].getVer() + 2 ) >> 2 ));
685	Int iBaseCUAddr;
686	Int iBaseAbsPartIdx;
687	pcBaseRec->getCUAddrAndPartIdx( iBasePosX , iBasePosY , iBaseCUAddr, iBaseAbsPartIdx );
688	#else
689	Int iPrdDepth, iCurrPosX, iCurrPosY;
690	Bool bAvailable = xGetPredDepth( pcCU, uiPartIdx, iPrdDepth, &iCurrPosX, &iCurrPosY );
691	AOF( bAvailable );
692	TComPicYuv* pcBasePdm = pcBasePic->getPredDepthMap();
693	Int iDisparity = xGetDisparityFromVirtDepth( iViewId, iPrdDepth );
694	Int iShiftX = m_uiSubSampExpX + 2;
695	Int iAddX = ( 1 << iShiftX ) >> 1;
696	Int iBasePosX = Clip3( 0, pcBasePdm->getWidth () - 1, iCurrPosX + ( ( iDisparity + iAddX ) >> iShiftX ) );
697	Int iBasePosY = Clip3( 0, pcBasePdm->getHeight() - 1, iCurrPosY );
698	Int iBaseCUAddr;
699	Int iBaseAbsPartIdx;
700	pcBaseRec->getCUAddrAndPartIdx( iBasePosX<< m_uiSubSampExpX , iBasePosY<< m_uiSubSampExpY , iBaseCUAddr, iBaseAbsPartIdx );
701	#endif
702	TComDataCU* pcBaseCU = pcBasePic->getCU( iBaseCUAddr );
703	if( pcBaseCU->getPredictionMode( iBaseAbsPartIdx ) == MODE_INTER \|\| pcBaseCU->getPredictionMode( iBaseAbsPartIdx ) == MODE_SKIP )
704	{
705	for( UInt uiCurrRefListId = 0; uiCurrRefListId < 2; uiCurrRefListId++ )
706	{
707	RefPicList eCurrRefPicList = RefPicList( uiCurrRefListId );
708	if(!bMerge && eCurrRefPicList != eRefPicList)
709	continue;
710	Bool bLoop_stop = false;
711	for(Int iLoop = 0; iLoop < 2 && !bLoop_stop; ++iLoop)
712	{
713	RefPicList eBaseRefPicList = (iLoop ==1)? RefPicList( 1 - uiCurrRefListId ) : RefPicList( uiCurrRefListId );
714	TComMvField cBaseMvField;
715	pcBaseCU->getMvField( pcBaseCU, iBaseAbsPartIdx, eBaseRefPicList, cBaseMvField );
716	Int iBaseRefIdx = cBaseMvField.getRefIdx();
717	if (iBaseRefIdx >= 0)
718	{
719	Int iBaseRefPOC = pcBaseCU->getSlice()->getRefPOC(eBaseRefPicList, iBaseRefIdx);
720	if (iBaseRefPOC != pcSlice->getPOC())
721	{
722	for (Int iPdmRefIdx = (bMerge?0: iRefIdx); iPdmRefIdx < (bMerge? pcSlice->getNumRefIdx( eCurrRefPicList ): (iRefIdx+1)); iPdmRefIdx++)
723	{
724	if (iBaseRefPOC == pcSlice->getRefPOC(eCurrRefPicList, iPdmRefIdx))
725	{
726	abPdmAvailable[ uiCurrRefListId ] = true;
727	TComMv cMv(cBaseMvField.getHor(), cBaseMvField.getVer());
728	#if LGE_DVMCP_A0126
729	if( bMerge )
730	{
731	cMv.m_bDvMcp = true;
732	cMv.m_iDvMcpDispX = pDInfo->m_acMvCand[0].getHor();
733	}
734	#endif
735	pcCU->clipMv( cMv );
736	if(bMerge)
737	{
738	paiPdmRefIdx [ uiCurrRefListId ] = iPdmRefIdx;
739	pacPdmMv [ uiCurrRefListId ] = cMv;
740	bLoop_stop = true;
741	break;
742	}else
743	{
744	pacPdmMv [0] = cMv;
745	return true;
746	}
747	}
748	}
749	}
750	}
751	}
752	}
753	}
754	if( bMerge )
755	iPdm[0] = ( abPdmAvailable[0] ? 1 : 0 ) + ( abPdmAvailable[1] ? 2 : 0 );
756	}
757	if(bMerge \|\| bInterview)
758	{
759	for( Int iRefListId = 0; iRefListId < 2 ; iRefListId++ )
760	{
761	RefPicList eRefPicListDMV = RefPicList( iRefListId );
762	Int iNumRefPics = pcSlice->getNumRefIdx( eRefPicListDMV );
763	for( Int iPdmRefIdx = (bMerge ? 0: iRefIdx); iPdmRefIdx < (bMerge ? iNumRefPics: (iRefIdx+1) ); iPdmRefIdx++ )
764	{
765	if( pcSlice->getRefPOC( eRefPicListDMV, iPdmRefIdx ) == pcSlice->getPOC())
766	{
767	#if QC_MRG_CANS_B0048
768	abPdmAvailable[ iRefListId+2 ] = true;
769	paiPdmRefIdx [ iRefListId+2 ] = iPdmRefIdx;
770	#else
771	abPdmAvailable[ iRefListId ] = true;
772	paiPdmRefIdx [ iRefListId ] = iPdmRefIdx;
773	#endif
774	#if QC_MULTI_DIS_CAN_A0097
775	TComMv cMv = pDInfo->m_acMvCand[0];
776	cMv.setVer(0);
777	#else
778	TComMv cMv(iDisparity, 0);
779	#endif
780	pcCU->clipMv( cMv );
781	#if QC_MRG_CANS_B0048
782	pacPdmMv [ iRefListId + 2] = cMv;
783	#else
784	pacPdmMv [ iRefListId ] = cMv;
785	#endif
786	if(bMerge)
787	break;
788	else
789	{
790	pacPdmMv [0] = cMv;
791	return true;
792	}
793	}
794	}
795	}
796	#if QC_MRG_CANS_B0048
797	iPdm[1] = ( abPdmAvailable[2] ? 1 : 0 ) + ( abPdmAvailable[3] ? 2 : 0 );
798	#else
799	iPdmInterDir = ( abPdmAvailable[0] ? 1 : 0 ) + ( abPdmAvailable[1] ? 2 : 0 ) ;
800	}
801	#endif
802	}
803	return false;
804	}
805	#else
806	#if QC_MULTI_DIS_CAN_A0097
807	Int
808	TComDepthMapGenerator::getPdmMergeCandidate( TComDataCU* pcCU, UInt uiPartIdx, Int* paiPdmRefIdx, TComMv* pacPdmMv, DisInfo* pDInfo
809	#if QC_MRG_CANS_B0048
810	, Int* iPdm
811	#endif
812	)
813	#else
814	Int
815	TComDepthMapGenerator::getPdmMergeCandidate( TComDataCU* pcCU, UInt uiPartIdx, Int* paiPdmRefIdx, TComMv* pacPdmMv )
816	#endif
817	{
818	#if MTK_INTERVIEW_MERGE_A0049
819	AOF ( m_bCreated && m_bInit );
820
821	#if !QC_MULTI_DIS_CAN_A0097
822	ROFRS( m_bPDMAvailable, 0 );
823	#endif
824
825	TComSlice* pcSlice = pcCU->getSlice ();
826	TComSPS* pcSPS = pcSlice->getSPS();
827	AOF ( pcSPS->getViewId() == m_uiCurrViewId );
828	Bool bPdmMerge = ( ( pcSPS->getMultiviewMvPredMode() & PDM_USE_FOR_MERGE ) == PDM_USE_FOR_MERGE );
829	ROTRS( !bPdmMerge, 0 );
830
831	#if QC_MRG_CANS_B0048
832	Bool abPdmAvailable[4] = {false, false, false, false};
833	#else
834	Bool abPdmAvailable[2] = {false,false};
835	#endif
836
837	Int iValid = 0;
838	Int iViewId = 0;
839	for( UInt uiBId = 0; uiBId < m_uiCurrViewId && iValid==0; uiBId++ )
840	{
841	UInt uiBaseId = m_auiBaseIdList[ uiBId ];
842	TComPic* pcBasePic = m_pcAUPicAccess->getPic( uiBaseId );
843	for( Int iRefListId = 0; iRefListId < 2 && iValid==0; iRefListId++ )
844	{
845	RefPicList eRefPicListTest = RefPicList( iRefListId );
846	Int iNumRefPics = pcSlice->getNumRefIdx( eRefPicListTest ) ;
847	for( Int iRefIndex = 0; iRefIndex < iNumRefPics; iRefIndex++ )
848	{
849	if(pcBasePic->getPOC() == pcSlice->getRefPic( eRefPicListTest, iRefIndex )->getPOC()
850	&& pcBasePic->getViewId() == pcSlice->getRefPic( eRefPicListTest, iRefIndex )->getViewId())
851	{
852	iValid=1;
853	iViewId = uiBaseId;
854	break;
855	}
856	}
857	}
858	}
859	if (iValid == 0)
860	return 0;
861
862	//--- get base CU/PU and check prediction mode ---
863	TComPic* pcBasePic = m_pcAUPicAccess->getPic( iViewId );
864	TComPicYuv* pcBaseRec = pcBasePic->getPicYuvRec ();
865
866	#if QC_MULTI_DIS_CAN_A0097
867	Int iCurrPosX, iCurrPosY;
868	UInt uiPartAddr;
869	Int iWidth;
870	Int iHeight;
871
872	pcCU->getPartIndexAndSize( uiPartIdx, uiPartAddr, iWidth, iHeight );
873	pcBaseRec->getTopLeftSamplePos( pcCU->getAddr(), pcCU->getZorderIdxInCU() + uiPartAddr, iCurrPosX, iCurrPosY );
874	iCurrPosX += ( ( iWidth - 1 ) >> 1 );
875	iCurrPosY += ( ( iHeight - 1 ) >> 1 );
876
877	Int iBasePosX = Clip3( 0, pcBaseRec->getWidth () - 1, iCurrPosX + ( (pDInfo->m_acMvCand[0].getHor() + 2 ) >> 2 ) );
878	Int iBasePosY = Clip3( 0, pcBaseRec->getHeight() - 1, iCurrPosY + ( (pDInfo->m_acMvCand[0].getVer() + 2 ) >> 2 ));
879	Int iBaseCUAddr;
880	Int iBaseAbsPartIdx;
881	pcBaseRec->getCUAddrAndPartIdx( iBasePosX , iBasePosY , iBaseCUAddr, iBaseAbsPartIdx );
882	#else
883	Int iPrdDepth, iCurrPosX, iCurrPosY;
884	Bool bAvailable = xGetPredDepth( pcCU, uiPartIdx, iPrdDepth, &iCurrPosX, &iCurrPosY );
885	AOF( bAvailable );
886	TComPicYuv* pcBasePdm = pcBasePic->getPredDepthMap();
887	Int iDisparity = xGetDisparityFromVirtDepth( iViewId, iPrdDepth );
888	Int iShiftX = m_uiSubSampExpX + 2;
889	Int iAddX = ( 1 << iShiftX ) >> 1;
890	Int iBasePosX = Clip3( 0, pcBasePdm->getWidth () - 1, iCurrPosX + ( ( iDisparity + iAddX ) >> iShiftX ) );
891	Int iBasePosY = Clip3( 0, pcBasePdm->getHeight() - 1, iCurrPosY );
892	Int iBaseCUAddr;
893	Int iBaseAbsPartIdx;
894	pcBaseRec->getCUAddrAndPartIdx( iBasePosX<< m_uiSubSampExpX , iBasePosY<< m_uiSubSampExpY , iBaseCUAddr, iBaseAbsPartIdx );
895	#endif
896
897	TComDataCU* pcBaseCU = pcBasePic->getCU( iBaseCUAddr );
898
899	if( pcBaseCU->getPredictionMode( iBaseAbsPartIdx ) == MODE_INTER \|\| pcBaseCU->getPredictionMode( iBaseAbsPartIdx ) == MODE_SKIP )
900	{
901	for( UInt uiBaseRefListId = 0; uiBaseRefListId < 2; uiBaseRefListId++ )
902	{
903	RefPicList eBaseRefPicList = RefPicList( uiBaseRefListId );
904	TComMvField cBaseMvField;
905	pcBaseCU->getMvField( pcBaseCU, iBaseAbsPartIdx, eBaseRefPicList, cBaseMvField );
906	Int iBaseRefIdx = cBaseMvField.getRefIdx();
907
908	if (iBaseRefIdx >= 0)
909	{
910	Int iBaseRefPOC = pcBaseCU->getSlice()->getRefPOC(eBaseRefPicList, iBaseRefIdx);
911	if (iBaseRefPOC != pcSlice->getPOC())
912	{
913	for (Int iPdmRefIdx = 0; iPdmRefIdx < pcSlice->getNumRefIdx( eBaseRefPicList ); iPdmRefIdx++)
914	{
915	if (iBaseRefPOC == pcSlice->getRefPOC(eBaseRefPicList, iPdmRefIdx))
916	{
917	abPdmAvailable[ uiBaseRefListId ] = true;
918	paiPdmRefIdx [ uiBaseRefListId ] = iPdmRefIdx;
919	TComMv cMv(cBaseMvField.getHor(), cBaseMvField.getVer());
920	#if LGE_DVMCP_A0126
921	cMv.m_bDvMcp = true;
922	cMv.m_iDvMcpDispX = pDInfo->m_acMvCand[0].getHor();
923	#if MTK_RELEASE_DV_CONSTRAINT_C0129
924	cMv.m_iDvMcpDispY = pDInfo->m_acMvCand[0].getVer();
925	#endif
926	#endif
927	pcCU->clipMv( cMv );
928	pacPdmMv [ uiBaseRefListId ] = cMv;
929	break;
930	}
931	}
932	}
933	}
934	}
935	}
936	Int iPdmInterDir = ( abPdmAvailable[0] ? 1 : 0 ) + ( abPdmAvailable[1] ? 2 : 0 );
937	#if QC_MRG_CANS_B0048
938	iPdm[0] = iPdmInterDir;
939	#else
940	if (iPdmInterDir == 0)
941	{
942	#endif
943	for( Int iRefListId = 0; iRefListId < 2 ; iRefListId++ )
944	{
945	RefPicList eRefPicList = RefPicList( iRefListId );
946	Int iNumRefPics = pcSlice->getNumRefIdx( eRefPicList );
947	for( Int iPdmRefIdx = 0; iPdmRefIdx < iNumRefPics; iPdmRefIdx++ )
948	{
949	if( pcSlice->getRefPOC( eRefPicList, iPdmRefIdx ) == pcSlice->getPOC())
950	{
951	#if QC_MRG_CANS_B0048
952	abPdmAvailable[ iRefListId+2 ] = true;
953	paiPdmRefIdx [ iRefListId+2 ] = iPdmRefIdx;
954	#else
955	abPdmAvailable[ iRefListId ] = true;
956	paiPdmRefIdx [ iRefListId ] = iPdmRefIdx;
957	#endif
958	#if QC_MULTI_DIS_CAN_A0097
959	TComMv cMv = pDInfo->m_acMvCand[0];
960	cMv.setVer(0);
961	#else
962	TComMv cMv(iDisparity, 0);
963	#endif
964	pcCU->clipMv( cMv );
965	#if QC_MRG_CANS_B0048
966	pacPdmMv [ iRefListId + 2] = cMv;
967	#else
968	pacPdmMv [ iRefListId ] = cMv;
969	#endif
970	break;
971	}
972	}
973	}
974	#if QC_MRG_CANS_B0048
975	iPdmInterDir = ( abPdmAvailable[2] ? 1 : 0 ) + ( abPdmAvailable[3] ? 2 : 0 ) ;
976	iPdm[1] = iPdmInterDir;
977	#else
978	iPdmInterDir = ( abPdmAvailable[0] ? 1 : 0 ) + ( abPdmAvailable[1] ? 2 : 0 ) ;
979	}
980	#endif
981
982	return iPdmInterDir;
983
984	#else
985	Int iMaxNumInterPics = 1;
986	Int iMaxNumAllPics = 2;
987
988	// inter-only
989	Bool abPdmAvailable[2] = {false,false};
990	for( Int iRefListId = 0; iRefListId < 2; iRefListId++ )
991	{
992	RefPicList eRefPicList = RefPicList( iRefListId );
993	Int iNumRefPics = pcCU->getSlice()->getNumRefIdx( eRefPicList );
994	TComMv cMv;
995	for( Int iPdmRefIdx = 0, iInterPics = 0; iPdmRefIdx < iNumRefPics && iInterPics < iMaxNumInterPics; iPdmRefIdx++ )
996	{
997	if( pcCU->getSlice()->getRefPOC( eRefPicList, iPdmRefIdx ) != pcCU->getSlice()->getPOC() )
998	{
999	#if QC_MULTI_DIS_CAN_A0097
1000	if( getDisCanPdmMvPred (pcCU, uiPartIdx, eRefPicList, iPdmRefIdx, cMv, pDInfo, true ) )
1001	#else
1002	if( getPdmMvPred( pcCU, uiPartIdx, eRefPicList, iPdmRefIdx, cMv, true ) )
1003	#endif
1004	{
1005	pcCU->clipMv( cMv );
1006	abPdmAvailable[ iRefListId ] = true;
1007	paiPdmRefIdx [ iRefListId ] = iPdmRefIdx;
1008	pacPdmMv [ iRefListId ] = cMv;
1009	break;
1010	}
1011	iInterPics++;
1012	}
1013	}
1014	}
1015	Int iPdmInterDir = ( abPdmAvailable[0] ? 1 : 0 ) + ( abPdmAvailable[1] ? 2 : 0 );
1016	if( 0==iPdmInterDir )
1017	{ // check all, including inter view references
1018	for( Int iRefListId = 0; iRefListId < 2; iRefListId++ )
1019	{
1020	RefPicList eRefPicList = RefPicList( iRefListId );
1021	Int iNumRefPics = Min( iMaxNumAllPics, pcCU->getSlice()->getNumRefIdx( eRefPicList ) );
1022	TComMv cMv;
1023	for( Int iPdmRefIdx = 0; iPdmRefIdx < iNumRefPics; iPdmRefIdx++ )
1024	{
1025	#if QC_MULTI_DIS_CAN_A0097
1026	if ( getDisCanPdmMvPred (pcCU, uiPartIdx, eRefPicList, iPdmRefIdx, cMv, pDInfo, true ) )
1027	#else
1028	if( getPdmMvPred( pcCU, uiPartIdx, eRefPicList, iPdmRefIdx, cMv, true ) )
1029	#endif
1030	{
1031	pcCU->clipMv( cMv );
1032	abPdmAvailable[ iRefListId ] = true;
1033	paiPdmRefIdx [ iRefListId ] = iPdmRefIdx;
1034	pacPdmMv [ iRefListId ] = cMv;
1035	break;
1036	}
1037	}
1038	}
1039	iPdmInterDir = ( abPdmAvailable[0] ? 1 : 0 ) + ( abPdmAvailable[1] ? 2 : 0 );
1040	}
1041	return iPdmInterDir;
1042	#endif
1043	}
1044
1045	#if QC_MULTI_DIS_CAN_A0097
1046	Bool
1047	TComDepthMapGenerator::getDisCanPdmMvPred ( TComDataCU* pcCU, UInt uiPartIdx, RefPicList eRefPicList, Int iRefIdx, TComMv& rcMv, DisInfo* pDInfo, Bool bMerge )
1048	{
1049	#if LGE_DVMCP_A0126
1050	rcMv.m_bDvMcp = false;
1051	#endif
1052	AOF ( m_bCreated && m_bInit );
1053	AOF ( iRefIdx >= 0 );
1054	AOF ( pcCU );
1055	//ROFRS( m_bPDMAvailable, false );
1056	TComSlice* pcSlice = pcCU->getSlice ();
1057	TComSPS* pcSPS = pcSlice->getSPS();
1058	AOF ( pcSPS->getViewId() == m_uiCurrViewId );
1059	TComPic* pcRefPic = pcSlice->getRefPic( eRefPicList, iRefIdx );
1060	UInt uiRefViewId = pcRefPic->getSPS()->getViewId();
1061	Int iRefPoc = pcRefPic->getPOC();
1062	Bool bInterview = ( uiRefViewId < m_uiCurrViewId );
1063	AOT( bInterview && iRefPoc != pcSlice->getPOC() );
1064	AOT( !bInterview && iRefPoc == pcSlice->getPOC() );
1065	Bool bPdmIView = ( ( pcSPS->getMultiviewMvPredMode() & PDM_USE_FOR_IVIEW ) == PDM_USE_FOR_IVIEW );
1066	Bool bPdmInter = ( ( pcSPS->getMultiviewMvPredMode() & PDM_USE_FOR_INTER ) == PDM_USE_FOR_INTER );
1067	Bool bPdmMerge = ( ( pcSPS->getMultiviewMvPredMode() & PDM_USE_FOR_MERGE ) == PDM_USE_FOR_MERGE );
1068	ROTRS( ( bInterview && !bMerge ) && !bPdmIView, false );
1069	ROTRS( (!bInterview && !bMerge ) && !bPdmInter, false );
1070	ROTRS( bMerge && !bPdmMerge, false );
1071	Int iCurrPosX, iCurrPosY;
1072	TComMv cDisMv;
1073
1074	if( bInterview )
1075	{
1076	rcMv = pDInfo->m_acMvCand[0];
1077	rcMv.setVer(0);
1078	return true;
1079	}
1080	for( UInt uiBId = 0; uiBId < m_uiCurrViewId; uiBId++ )
1081	{
1082	UInt uiBaseId = uiBId; //m_auiBaseIdList[ uiBId ];
1083
1084	if (m_uiCurrViewId >1 && uiBaseId ==1 )
1085	continue;
1086
1087	TComPic* pcBasePic = m_pcAUPicAccess->getPic( uiBaseId );
1088	TComPicYuv* pcBaseRec = pcBasePic->getPicYuvRec ();
1089	UInt uiPartAddr;
1090	Int iWidth;
1091	Int iHeight;
1092
1093	pcCU->getPartIndexAndSize( uiPartIdx, uiPartAddr, iWidth, iHeight );
1094	pcBaseRec->getTopLeftSamplePos( pcCU->getAddr(), pcCU->getZorderIdxInCU() + uiPartAddr, iCurrPosX, iCurrPosY );
1095	iCurrPosX += ( ( iWidth - 1 ) >> 1 );
1096	iCurrPosY += ( ( iHeight - 1 ) >> 1 );
1097	Int iBasePosX = Clip3( 0, pcBaseRec->getWidth () - 1, iCurrPosX + ( (pDInfo->m_acMvCand[0].getHor() + 2 ) >> 2 ) );
1098	Int iBasePosY = Clip3( 0, pcBaseRec->getHeight() - 1, iCurrPosY + ( (pDInfo->m_acMvCand[0].getVer() + 2 ) >> 2 ));
1099	Int iBaseCUAddr;
1100	Int iBaseAbsPartIdx;
1101	pcBaseRec->getCUAddrAndPartIdx( iBasePosX , iBasePosY , iBaseCUAddr, iBaseAbsPartIdx );
1102	TComDataCU* pcBaseCU = pcBasePic->getCU( iBaseCUAddr );
1103	if( pcBaseCU->getPredictionMode( iBaseAbsPartIdx ) != MODE_INTER && pcBaseCU->getPredictionMode( iBaseAbsPartIdx ) != MODE_SKIP )
1104	{
1105	continue;
1106	}
1107	for( UInt uiBaseRefListId = 0; uiBaseRefListId < 2; uiBaseRefListId++ )
1108	{
1109	RefPicList eBaseRefPicList = RefPicList( uiBaseRefListId );
1110	TComMvField cBaseMvField;
1111	pcBaseCU->getMvField( pcBaseCU, iBaseAbsPartIdx, eBaseRefPicList, cBaseMvField );
1112	Int iBaseRefIdx = cBaseMvField.getRefIdx();
1113	Int iBaseRefPoc = ( iBaseRefIdx >= 0 ? pcBaseCU->getSlice()->getRefPic( eBaseRefPicList, iBaseRefIdx )->getPOC() : -(1<<30) );
1114	if( iBaseRefIdx >= 0 && iBaseRefPoc == iRefPoc )
1115	{
1116	rcMv.set( cBaseMvField.getHor(), cBaseMvField.getVer() );
1117	#if LGE_DVMCP_A0126
1118	// save disparity vector when a merge candidate for IVMP is set as DV-MCP
1119	if( bMerge )
1120	{
1121	rcMv.m_bDvMcp = true;
1122	rcMv.m_iDvMcpDispX = pDInfo->m_acMvCand[0].getHor();
1123	#if MTK_RELEASE_DV_CONSTRAINT_C0129
1124	rcMv.m_iDvMcpDispY = pDInfo->m_acMvCand[0].getVer();
1125	#endif
1126	}
1127	else { // AMVP ?
1128	rcMv.m_bDvMcp = false;
1129	}
1130	#endif
1131	return true;
1132	}
1133	}
1134	}
1135	return false;
1136	}
1137	#else
1138	Bool
1139	TComDepthMapGenerator::getPdmMvPred( TComDataCU* pcCU, UInt uiPartIdx, RefPicList eRefPicList, Int iRefIdx, TComMv& rcMv, Bool bMerge )
1140	{
1141	AOF ( m_bCreated && m_bInit );
1142	AOF ( iRefIdx >= 0 );
1143	AOF ( pcCU );
1144	ROFRS( m_bPDMAvailable, false );
1145
1146	TComSlice* pcSlice = pcCU->getSlice ();
1147	TComPic* pcPic = pcCU->getPic ();
1148	TComSPS* pcSPS = pcSlice->getSPS();
1149	AOF ( pcPic->getPredDepthMap() );
1150	AOF ( pcSPS->getViewId() == m_uiCurrViewId );
1151
1152	TComPic* pcRefPic = pcSlice->getRefPic( eRefPicList, iRefIdx );
1153	UInt uiRefViewId = pcRefPic->getSPS()->getViewId();
1154	Int iRefPoc = pcRefPic->getPOC();
1155	Bool bInterview = ( uiRefViewId < m_uiCurrViewId );
1156	AOT( bInterview && iRefPoc != pcSlice->getPOC() );
1157	AOT( !bInterview && iRefPoc == pcSlice->getPOC() );
1158
1159	Bool bPdmIView = ( ( pcSPS->getMultiviewMvPredMode() & PDM_USE_FOR_IVIEW ) == PDM_USE_FOR_IVIEW );
1160	Bool bPdmInter = ( ( pcSPS->getMultiviewMvPredMode() & PDM_USE_FOR_INTER ) == PDM_USE_FOR_INTER );
1161	Bool bPdmMerge = ( ( pcSPS->getMultiviewMvPredMode() & PDM_USE_FOR_MERGE ) == PDM_USE_FOR_MERGE );
1162	ROTRS( ( bInterview && !bMerge ) && !bPdmIView, false );
1163	ROTRS( (!bInterview && !bMerge ) && !bPdmInter, false );
1164	ROTRS( bMerge && !bPdmMerge, false );
1165
1166	//===== get predicted depth for middle position of current PU =====
1167	Int iPrdDepth, iCurrPosX, iCurrPosY;
1168	Bool bAvailable = xGetPredDepth( pcCU, uiPartIdx, iPrdDepth, &iCurrPosX, &iCurrPosY );
1169	AOF( bAvailable );
1170
1171	//===== inter-view motion vector prediction =====
1172	if( bInterview )
1173	{
1174	Int iDisparity = xGetDisparityFromVirtDepth( uiRefViewId, iPrdDepth );
1175	rcMv.set ( iDisparity, 0 );
1176	return true;
1177	}
1178
1179	//===== inter motion vector prediction =====
1180	for( UInt uiBId = 0; uiBId < m_uiCurrViewId; uiBId++ )
1181	{
1182	//--- get base CU/PU and check prediction mode ---
1183	UInt uiBaseId = m_auiBaseIdList[ uiBId ];
1184	#if PDM_REMOVE_DEPENDENCE
1185	if( uiBaseId != 0)
1186	continue;
1187	#endif
1188	TComPic* pcBasePic = m_pcAUPicAccess->getPic( uiBaseId );
1189	TComPicYuv* pcBasePdm = pcBasePic->getPredDepthMap();
1190	TComPicYuv* pcBaseRec = pcBasePic->getPicYuvRec ();
1191	Int iDisparity = xGetDisparityFromVirtDepth( uiBaseId, iPrdDepth );
1192	Int iShiftX = m_uiSubSampExpX + 2;
1193	Int iAddX = ( 1 << iShiftX ) >> 1;
1194	Int iBasePosX = Clip3( 0, pcBasePdm->getWidth () - 1, iCurrPosX + ( ( iDisparity + iAddX ) >> iShiftX ) );
1195	Int iBasePosY = Clip3( 0, pcBasePdm->getHeight() - 1, iCurrPosY );
1196	Int iBaseCUAddr;
1197	Int iBaseAbsPartIdx;
1198	pcBaseRec->getCUAddrAndPartIdx( iBasePosX << m_uiSubSampExpX, iBasePosY << m_uiSubSampExpY, iBaseCUAddr, iBaseAbsPartIdx );
1199	TComDataCU* pcBaseCU = pcBasePic->getCU( iBaseCUAddr );
1200	if( pcBaseCU->getPredictionMode( iBaseAbsPartIdx ) != MODE_INTER && pcBaseCU->getPredictionMode( iBaseAbsPartIdx ) != MODE_SKIP )
1201	{
1202	continue;
1203	}
1204
1205	for( UInt uiBaseRefListId = 0; uiBaseRefListId < 2; uiBaseRefListId++ )
1206	{
1207	RefPicList eBaseRefPicList = RefPicList( uiBaseRefListId );
1208	TComMvField cBaseMvField;
1209	pcBaseCU->getMvField( pcBaseCU, iBaseAbsPartIdx, eBaseRefPicList, cBaseMvField );
1210	Int iBaseRefIdx = cBaseMvField.getRefIdx();
1211	Int iBaseRefPoc = ( iBaseRefIdx >= 0 ? pcBaseCU->getSlice()->getRefPic( eBaseRefPicList, iBaseRefIdx )->getPOC() : -(1<<30) );
1212	if( iBaseRefIdx >= 0 && iBaseRefPoc == iRefPoc )
1213	{
1214	rcMv.set( cBaseMvField.getHor(), cBaseMvField.getVer() );
1215	return true;
1216	}
1217	}
1218	}
1219	return false;
1220	}
1221	#endif
1222	#endif
1223
1224
1225	Bool // first version
1226	TComDepthMapGenerator::getIViewOrgDepthMvPred( TComDataCU* pcCU, UInt uiPartIdx, RefPicList eRefPicList, Int iRefIdx, TComMv& rcMv )
1227	{
1228	AOF ( m_bCreated && m_bInit );
1229	AOF ( iRefIdx >= 0 );
1230	AOF ( pcCU );
1231
1232	TComSlice* pcSlice = pcCU->getSlice ();
1233	TComPic* pcPic = pcCU->getPic ();
1234	TComSPS* pcSPS = pcSlice->getSPS();
1235	AOF ( pcSPS->getViewId() == m_uiCurrViewId );
1236	ROFRS( pcPic->getOrgDepthMap(), false );
1237
1238	TComPic* pcRefPic = pcSlice->getRefPic( eRefPicList, iRefIdx );
1239	UInt uiRefViewId = pcRefPic->getSPS()->getViewId();
1240	Int iRefPoc = pcRefPic->getPOC();
1241	ROFRS( uiRefViewId < m_uiCurrViewId, false );
1242	AOF ( iRefPoc == pcSlice->getPOC() );
1243
1244	//===== get predicted depth for middle position of current PU (first version) =====
1245	UInt uiPartAddr;
1246	Int iWidth;
1247	Int iHeight;
1248	pcCU->getPartIndexAndSize( uiPartIdx, uiPartAddr, iWidth, iHeight );
1249	TComPicYuv* pcOrgDepthMap = pcPic->getOrgDepthMap();
1250	Pel* piOrgDepthMap = pcOrgDepthMap->getLumaAddr ( 0 );
1251	Int iCurrStride = pcOrgDepthMap->getStride ();
1252	Int iCurrPosX;
1253	Int iCurrPosY;
1254	pcOrgDepthMap->getTopLeftSamplePos( pcCU->getAddr(), pcCU->getZorderIdxInCU() + uiPartAddr, iCurrPosX, iCurrPosY );
1255	iCurrPosX += ( iWidth - 1 ) >> 1;
1256	iCurrPosY += ( iHeight - 1 ) >> 1;
1257	Int iPrdDepth = piOrgDepthMap[ iCurrPosX + iCurrPosY * iCurrStride ];
1258
1259	//===== get disparity vector =====
1260	Int iDisparity = xGetDisparityFromVirtDepth( uiRefViewId, iPrdDepth );
1261	rcMv.set ( iDisparity, 0 );
1262	return true;
1263	}
1264	#endif
1265
1266
1267
1268
1269
1270	#if !QC_MULTI_DIS_CAN_A0097
1271	/=======================================================
1272	===== =====
1273	===== p i c t u r e o p e r a t i o n s =====
1274	===== =====
1275	=======================================================/
1276
1277	Bool
1278	TComDepthMapGenerator::xConvertDepthMapCurr2Ref( TComPic* pcRef, TComPic* pcCur )
1279	{
1280	AOF( pcCur->getSPS()->getViewId() == m_uiCurrViewId );
1281	AOF( pcCur->getSPS()->getViewId() > pcRef->getSPS()->getViewId() );
1282	AOF( pcCur->getPredDepthMap() );
1283	AOF( pcRef->getPredDepthMap() );
1284	AOF( pcRef->getPredDepthMap()->getWidth () == pcCur->getPredDepthMap()->getWidth () );
1285	AOF( pcRef->getPredDepthMap()->getHeight() == pcCur->getPredDepthMap()->getHeight() );
1286	#if PDM_REMOVE_DEPENDENCE
1287	if( pcCur->getViewId() == 1)
1288	xClearDepthMap( pcRef );
1289	else if (pcCur->getViewId() == 2)
1290	xClearDepthMap( pcRef, PDM_UNDEFINED_DEPTH, 1 );
1291	#else
1292	xClearDepthMap( pcRef );
1293	#endif
1294	TComPicYuv* pcCurDepthMap = pcCur->getPredDepthMap ();
1295	TComPicYuv* pcRefDepthMap = pcRef->getPredDepthMap ();
1296	Int iWidth = pcCurDepthMap->getWidth ();
1297	Int iHeight = pcCurDepthMap->getHeight ();
1298	Int iCurStride = pcCurDepthMap->getStride ();
1299	Int iRefStride = pcRefDepthMap->getStride ();
1300	Pel* pCurSamples = pcCurDepthMap->getLumaAddr( 0 );
1301	Pel* pRefSamples = pcRefDepthMap->getLumaAddr( 0 );
1302	Int iRefViewIdx = pcRef->getViewId();
1303	#if PDM_REMOVE_DEPENDENCE
1304	if( pcCur->getViewId() == 2)
1305	{
1306	pcRefDepthMap = pcRef->getPredDepthMapTemp();
1307	pRefSamples = pcRefDepthMap->getLumaAddr( 0 );
1308	}
1309	#endif
1310	Int iShiftX = m_uiSubSampExpX + 2;
1311	Int iAddX = ( 1 << iShiftX ) >> 1;
1312	for( Int iY = 0; iY < iHeight; iY++, pCurSamples += iCurStride, pRefSamples += iRefStride )
1313	{
1314	for( Int iXCur = 0; iXCur < iWidth; iXCur++ )
1315	{
1316	Int iDepth = pCurSamples[ iXCur ];
1317	Int iDisp = xGetDisparityFromVirtDepth( iRefViewIdx, iDepth );
1318	Int iXRef = iXCur + ( ( iDisp + iAddX ) >> iShiftX );
1319	if( iXRef >= 0 && iXRef < iWidth && iDepth > pRefSamples[ iXRef ] )
1320	{
1321	pRefSamples[ iXRef ] = iDepth;
1322	}
1323	}
1324	}
1325	Bool bUndefined = xFillDepthMapHoles( pcRef );
1326	pcRefDepthMap->setBorderExtension( false );
1327	pcRefDepthMap->extendPicBorder ();
1328	return bUndefined;
1329	}
1330
1331
1332	Bool
1333	TComDepthMapGenerator::xConvertDepthMapRef2Curr( TComPic* pcCur, TComPic* pcRef )
1334	{
1335	AOF( pcCur->getSPS()->getViewId() == m_uiCurrViewId );
1336	AOF( pcCur->getSPS()->getViewId() > pcRef->getSPS()->getViewId() );
1337	AOF( pcCur->getPredDepthMap() );
1338	#if PDM_REMOVE_DEPENDENCE
1339	if(pcCur->getViewId() == 1)
1340	{
1341	AOF( pcRef->getPredDepthMap() );
1342	}else
1343	{
1344	AOF( pcRef->getPredDepthMapTemp() );
1345	}
1346	#else
1347	AOF( pcRef->getPredDepthMap() );
1348	#endif
1349	AOF( pcRef->getPredDepthMap()->getWidth () == pcCur->getPredDepthMap()->getWidth () );
1350	AOF( pcRef->getPredDepthMap()->getHeight() == pcCur->getPredDepthMap()->getHeight() );
1351
1352	xClearDepthMap( pcCur );
1353	TComPicYuv* pcRefDepthMap = pcRef->getPredDepthMap ();
1354	#if PDM_REMOVE_DEPENDENCE
1355	if(pcCur->getViewId() == 2)
1356	pcRefDepthMap = pcRef->getPredDepthMapTemp ();
1357	#endif
1358	TComPicYuv* pcCurDepthMap = pcCur->getPredDepthMap ();
1359	Int iWidth = pcRefDepthMap->getWidth ();
1360	Int iHeight = pcRefDepthMap->getHeight ();
1361	Int iRefStride = pcRefDepthMap->getStride ();
1362	Int iCurStride = pcCurDepthMap->getStride ();
1363	Pel* pRefSamples = pcRefDepthMap->getLumaAddr( 0 );
1364	Pel* pCurSamples = pcCurDepthMap->getLumaAddr( 0 );
1365	Int iRefViewIdx = pcRef->getViewId();
1366	Int iShiftX = m_uiSubSampExpX + 2;
1367	Int iAddX = ( 1 << iShiftX ) >> 1;
1368	for( Int iY = 0; iY < iHeight; iY++, pRefSamples += iRefStride, pCurSamples += iCurStride )
1369	{
1370	for( Int iXRef = 0; iXRef < iWidth; iXRef++ )
1371	{
1372	Int iDepth = pRefSamples[ iXRef ];
1373	Int iDisp = xGetDisparityFromVirtDepth( iRefViewIdx, iDepth );
1374	Int iXCur = iXRef - ( ( iDisp + iAddX ) >> iShiftX );
1375	if( iXCur >= 0 && iXCur < iWidth && iDepth > pCurSamples[ iXCur ] )
1376	{
1377	pCurSamples[ iXCur ] = iDepth;
1378	}
1379	}
1380	}
1381	Bool bUndefined = xFillDepthMapHoles( pcCur );
1382	pcCurDepthMap->setBorderExtension( false );
1383	pcCurDepthMap->extendPicBorder ();
1384	return bUndefined;
1385	}
1386
1387
1388	Bool
1389	TComDepthMapGenerator::xPredictDepthMap( TComPic* pcPic )
1390	{
1391	for( UInt uiCUAddr = 0; uiCUAddr < pcPic->getPicSym()->getNumberOfCUsInFrame(); uiCUAddr++ )
1392	{
1393	TComDataCU* pcCU = pcPic->getCU( uiCUAddr );
1394	xPredictCUDepthMap( pcCU, 0, 0 );
1395	}
1396	Bool bUndefined = xFillDepthMapHoles( pcPic );
1397	#if PDM_REMOVE_DEPENDENCE
1398	if(pcPic->getStoredPDMforV2() == 1){
1399	pcPic->getPredDepthMapTemp()->setBorderExtension( false );
1400	pcPic->getPredDepthMapTemp()->extendPicBorder ();
1401	}else{
1402	#endif
1403	pcPic->getPredDepthMap()->setBorderExtension( false );
1404	pcPic->getPredDepthMap()->extendPicBorder ();
1405	#if PDM_REMOVE_DEPENDENCE
1406	}
1407	#endif
1408	return bUndefined;
1409	}
1410
1411
1412	Bool
1413	TComDepthMapGenerator::xFillDepthMapHoles( TComPic* pcPic )
1414	{
1415	Bool bUndefined = false;
1416	TComPicYuv* pcDepthMap = pcPic->getPredDepthMap ();
1417	#if PDM_REMOVE_DEPENDENCE
1418	if(pcPic->getViewId()==0 && pcPic->getStoredPDMforV2()==1)
1419	pcDepthMap = pcPic->getPredDepthMapTemp ();
1420	#endif
1421	Int iWidth = pcDepthMap->getWidth ();
1422	Int iHeight = pcDepthMap->getHeight ();
1423	Int iStride = pcDepthMap->getStride ();
1424	Pel* pDMSamples = pcDepthMap->getLumaAddr ( 0 );
1425	// horizontal
1426	for( Int iY = 0; iY < iHeight && !bUndefined; iY++, pDMSamples += iStride )
1427	{
1428	for( Int iX = 0; iX < iWidth; iX++ )
1429	{
1430	if( pDMSamples[ iX ] == PDM_UNDEFINED_DEPTH )
1431	{
1432	Int iE;
1433	for( iE = iX + 1; iE < iWidth; iE++ )
1434	{
1435	if( pDMSamples[ iE ] != PDM_UNDEFINED_DEPTH )
1436	{
1437	break;
1438	}
1439	}
1440	if( iX > 0 \|\| iE < iWidth )
1441	{
1442	Int iDepth;
1443	if ( iX > 0 && iE < iWidth ) iDepth = ( pDMSamples[ iX-1 ] < pDMSamples[ iE ] ? pDMSamples[ iX-1 ] : pDMSamples[ iE ] );
1444	else if( iX > 0 ) iDepth = pDMSamples[ iX-1 ];
1445	else /( iE < iWidth )/ iDepth = pDMSamples[ iE ];
1446	for( Int iZ = iX; iZ < iE; iZ++ )
1447	{
1448	pDMSamples[ iZ ] = iDepth;
1449	}
1450	}
1451	else
1452	{
1453	bUndefined = true;
1454	break;
1455	}
1456	iX = iE - 1;
1457	}
1458	}
1459	}
1460
1461	if( bUndefined && m_uiCurrViewId )
1462	{
1463	pDMSamples = pcDepthMap->getLumaAddr( 0 );
1464	Int iMiddleOrgDpth = ( 1 << m_uiOrgDepthBitDepth ) >> 1;
1465	Int iMiddleDepth = xGetVirtDepthFromOrigDepth( m_uiCurrViewId, iMiddleOrgDpth );
1466	for( Int iY = 0; iY < iHeight; iY++, pDMSamples += iStride )
1467	{
1468	for( Int iX = 0; iX < iWidth; iX++ )
1469	{
1470	pDMSamples[ iX ] = iMiddleDepth;
1471	}
1472	}
1473	}
1474	return bUndefined;
1475	}
1476
1477
1478	Void
1479	TComDepthMapGenerator::xClearDepthMap( TComPic* pcPic, Int iVal
1480	#if PDM_REMOVE_DEPENDENCE
1481	,
1482	Int forFirstNonBaseView
1483	#endif
1484	)
1485	{
1486	TComPicYuv* pcDepthMap = pcPic->getPredDepthMap ();
1487	Int iWidth = pcDepthMap->getWidth ();
1488	Int iHeight = pcDepthMap->getHeight ();
1489	Int iStride = pcDepthMap->getStride ();
1490	Pel* pDMSamples = pcDepthMap->getLumaAddr ( 0 );
1491	#if PDM_REMOVE_DEPENDENCE
1492	if( forFirstNonBaseView == 1)
1493	{
1494	pcDepthMap = pcPic->getPredDepthMapTemp ();
1495	pDMSamples = pcDepthMap->getLumaAddr ( 0 );
1496	}
1497	#endif
1498	for( Int iY = 0; iY < iHeight; iY++, pDMSamples += iStride )
1499	{
1500	for( Int iX = 0; iX < iWidth; iX++ )
1501	{
1502	pDMSamples[ iX ] = iVal;
1503	}
1504	}
1505	pcDepthMap->setBorderExtension( false );
1506	pcDepthMap->extendPicBorder ();
1507	}
1508
1509	Void
1510	TComDepthMapGenerator::xSetChroma( TComPicYuv* pcPic, Int iVal )
1511	{
1512	Int iWidth = pcPic->getWidth () >> 1;
1513	Int iHeight = pcPic->getHeight () >> 1;
1514	Int iStride = pcPic->getCStride ();
1515	Pel* pCbSamples = pcPic->getCbAddr ( 0 );
1516	Pel* pCrSamples = pcPic->getCrAddr ( 0 );
1517	for( Int iY = 0; iY < iHeight; iY++, pCbSamples += iStride, pCrSamples += iStride )
1518	{
1519	for( Int iX = 0; iX < iWidth; iX++ )
1520	{
1521	pCbSamples[ iX ] = pCrSamples[ iX ] = iVal;
1522	}
1523	}
1524	}
1525
1526
1527
1528
1529
1530
1531
1532	/===============================================
1533	===== =====
1534	===== C U p r e d i c t i o n s =====
1535	===== =====
1536	===============================================/
1537
1538	Void
1539	TComDepthMapGenerator::xPredictCUDepthMap( TComDataCU* pcCU, UInt uiDepth, UInt uiAbsPartIdx )
1540	{
1541	UInt uiLPelX = pcCU->getCUPelX() + g_auiRasterToPelX[ g_auiZscanToRaster[ uiAbsPartIdx ] ];
1542	UInt uiTPelY = pcCU->getCUPelY() + g_auiRasterToPelY[ g_auiZscanToRaster[ uiAbsPartIdx ] ];
1543	UInt uiRPelX = uiLPelX + ( g_uiMaxCUWidth >> uiDepth ) - 1;
1544	UInt uiBPelY = uiTPelY + ( g_uiMaxCUHeight >> uiDepth ) - 1;
1545	Bool bBoundary = ( uiRPelX >= pcCU->getSlice()->getSPS()->getPicWidthInLumaSamples() \|\| uiBPelY >= pcCU->getSlice()->getSPS()->getPicHeightInLumaSamples() );
1546	Bool bSplit = ( ( uiDepth < pcCU->getDepth( uiAbsPartIdx ) && uiDepth < ( g_uiMaxCUDepth - g_uiAddCUDepth ) ) \|\| bBoundary );
1547	if( bSplit )
1548	{
1549	UInt uiQNumParts = ( pcCU->getPic()->getNumPartInCU() >> ( uiDepth << 1 ) ) >> 2;
1550	for ( UInt uiPartUnitIdx = 0; uiPartUnitIdx < 4; uiPartUnitIdx++, uiAbsPartIdx += uiQNumParts )
1551	{
1552	uiLPelX = pcCU->getCUPelX() + g_auiRasterToPelX[ g_auiZscanToRaster[ uiAbsPartIdx ] ];
1553	uiTPelY = pcCU->getCUPelY() + g_auiRasterToPelY[ g_auiZscanToRaster[ uiAbsPartIdx ] ];
1554	Bool bInside = ( uiLPelX < pcCU->getSlice()->getSPS()->getPicWidthInLumaSamples() && uiTPelY < pcCU->getSlice()->getSPS()->getPicHeightInLumaSamples() );
1555	if( bInside )
1556	{
1557	xPredictCUDepthMap( pcCU, uiDepth + 1, uiAbsPartIdx );
1558	}
1559	}
1560	return;
1561	}
1562
1563	//--- set sub-CU and sub-depth-map ---
1564	TComDataCU* pcSubCU = m_ppcCU [ uiDepth ];
1565	TComYuv* pcSubDM = m_ppcYuv[ uiDepth ];
1566	TComPicYuv* pcPicDM = pcCU->getPic()->getPredDepthMap();
1567	#if PDM_REMOVE_DEPENDENCE
1568	if( pcCU->getPic()->getStoredPDMforV2() == 1)
1569	pcPicDM = pcCU->getPic()->getPredDepthMapTemp();
1570	#endif
1571	UInt uiCUAddr = pcCU->getAddr();
1572	pcSubCU->copySubCU( pcCU, uiAbsPartIdx, uiDepth );
1573
1574	//--- update depth map ---
1575	switch( pcSubCU->getPredictionMode( 0 ) )
1576	{
1577	case MODE_INTRA:
1578	xIntraPredictCUDepthMap( pcSubCU, pcSubDM );
1579	break;
1580	case MODE_SKIP:
1581	case MODE_INTER:
1582	xInterPredictCUDepthMap( pcSubCU, pcSubDM );
1583	break;
1584	default:
1585	AOT( true );
1586	break;
1587	}
1588
1589	//--- copy sub-depth-map ---
1590	pcSubDM->copyToPicYuv( pcPicDM, uiCUAddr, uiAbsPartIdx );
1591	}
1592
1593
1594	Void
1595	TComDepthMapGenerator::xIntraPredictCUDepthMap( TComDataCU* pcCU, TComYuv* pcCUDepthMap )
1596	{
1597	UInt uiInitTrDepth = ( pcCU->getPartitionSize( 0 ) == SIZE_2Nx2N ? 0 : 1 );
1598	UInt uiNumPart = pcCU->getNumPartInter ();
1599	UInt uiNumQParts = pcCU->getTotalNumPart () >> 2;
1600	for( UInt uiPU = 0; uiPU < uiNumPart; uiPU++ )
1601	{
1602	xIntraPredictBlkDepthMap( pcCU, pcCUDepthMap, uiPU * uiNumQParts, uiInitTrDepth );
1603	}
1604	}
1605
1606
1607	Void
1608	TComDepthMapGenerator::xInterPredictCUDepthMap( TComDataCU* pcCU, TComYuv* pcCUDepthMap )
1609	{
1610	for( UInt uiPartIdx = 0; uiPartIdx < pcCU->getNumPartInter(); uiPartIdx++ )
1611	{
1612	xInterPredictPUDepthMap( pcCU, pcCUDepthMap, uiPartIdx );
1613	}
1614	}
1615
1616
1617
1618
1619
1620
1621
1622	/=====================================================================
1623	===== =====
1624	===== P U - a n d B l o c k p r e d i c t i o n s =====
1625	===== =====
1626	=====================================================================/
1627
1628	Void
1629	TComDepthMapGenerator::xIntraPredictBlkDepthMap( TComDataCU* pcCU, TComYuv* pcCUDepthMap, UInt uiAbsPartIdx, UInt uiTrDepth )
1630	{
1631	UInt uiFullDepth = pcCU->getDepth( 0 ) + uiTrDepth;
1632	UInt uiTrMode = pcCU->getTransformIdx( uiAbsPartIdx );
1633	if( uiTrMode == uiTrDepth )
1634	{
1635	UInt uiWidth = pcCU->getWidth ( 0 ) >> ( uiTrDepth + m_uiSubSampExpX );
1636	UInt uiHeight = pcCU->getHeight( 0 ) >> ( uiTrDepth + m_uiSubSampExpY );
1637	UInt uiStride = pcCUDepthMap->getStride ();
1638	UInt uiBlkX = g_auiRasterToPelX[ g_auiZscanToRaster[ uiAbsPartIdx ] ] >> m_uiSubSampExpX;
1639	UInt uiBlkY = g_auiRasterToPelY[ g_auiZscanToRaster[ uiAbsPartIdx ] ] >> m_uiSubSampExpY;
1640	Pel* pDepthMap = pcCUDepthMap->getLumaAddr() + uiBlkY * pcCUDepthMap->getStride() + uiBlkX;
1641	UInt uiLumaPredMode = pcCU->getLumaIntraDir ( uiAbsPartIdx );
1642	Bool bAboveAvail = false;
1643	Bool bLeftAvail = false;
1644	pcCU->getPattern()->initPattern ( pcCU, uiTrDepth, uiAbsPartIdx, true );
1645	pcCU->getPattern()->initAdiPattern( pcCU, uiAbsPartIdx, uiTrDepth,
1646	m_pcPrediction->getPredicBuf (),
1647	m_pcPrediction->getPredicBufWidth (),
1648	m_pcPrediction->getPredicBufHeight (),
1649	bAboveAvail, bLeftAvail, false, true, m_uiSubSampExpX, m_uiSubSampExpY );
1650	m_pcPrediction->predIntraDepthAng ( pcCU->getPattern(), uiLumaPredMode, pDepthMap, uiStride, uiWidth, uiHeight ); // could be replaced with directional intra prediction
1651	// using "predIntraLumaAng", but note:
1652	// - need to take care of neighbours with undefined depth
1653	// - special case for wedgelet mode (if available in normal views)
1654	// copy to picture array (for next intra prediction block)
1655	UInt uiZOrderIdx = pcCU->getZorderIdxInCU() + uiAbsPartIdx;
1656	Pel* pPicDepthMap = pcCU->getPic()->getPredDepthMap()->getLumaAddr( pcCU->getAddr(), uiZOrderIdx );
1657	#if PDM_REMOVE_DEPENDENCE
1658	if(pcCU->getPic()->getStoredPDMforV2()==1)
1659	pPicDepthMap = pcCU->getPic()->getPredDepthMapTemp()->getLumaAddr( pcCU->getAddr(), uiZOrderIdx );
1660	#endif
1661	Int iPicStride = pcCU->getPic()->getPredDepthMap()->getStride ();
1662	for( UInt uiY = 0; uiY < uiHeight; uiY++, pDepthMap += uiStride, pPicDepthMap += iPicStride )
1663	{
1664	for( UInt uiX = 0; uiX < uiWidth; uiX++ )
1665	{
1666	pPicDepthMap[ uiX ] = pDepthMap[ uiX ];
1667	}
1668	}
1669	}
1670	else
1671	{
1672	UInt uiNumQPart = pcCU->getPic()->getNumPartInCU() >> ( ( uiFullDepth + 1 ) << 1 );
1673	for( UInt uiPart = 0; uiPart < 4; uiPart++ )
1674	{
1675	xIntraPredictBlkDepthMap( pcCU, pcCUDepthMap, uiAbsPartIdx + uiPart * uiNumQPart, uiTrDepth + 1 );
1676	}
1677	}
1678	}
1679
1680
1681	Void
1682	TComDepthMapGenerator::xInterPredictPUDepthMap( TComDataCU* pcCU, TComYuv* pcCUDepthMap, UInt uiPartIdx )
1683	{
1684	if ( pcCU->getSlice()->getSPS()->getViewId() )
1685	{
1686	AOF( m_uiCurrViewId == pcCU->getSlice()->getSPS()->getViewId() );
1687	// check for interview prediction
1688	Int iWidth;
1689	Int iHeight;
1690	UInt uiAbsPartIdx;
1691	pcCU->getPartIndexAndSize( uiPartIdx, uiAbsPartIdx, iWidth, iHeight );
1692	TComCUMvField* aiCurrMvField[2] = { pcCU->getCUMvField( REF_PIC_LIST_0 ), pcCU->getCUMvField( REF_PIC_LIST_1 ) };
1693	Int aiCurrRefIdx [2] = { aiCurrMvField[0]->getRefIdx( uiAbsPartIdx ), aiCurrMvField[1]->getRefIdx( uiAbsPartIdx ) };
1694	Bool abCurrIntView[2] = { aiCurrRefIdx[0] >= 0 && pcCU->getSlice()->getRefPic( REF_PIC_LIST_0, aiCurrRefIdx[0] )->getSPS()->getViewId() != m_uiCurrViewId,
1695	aiCurrRefIdx[1] >= 0 && pcCU->getSlice()->getRefPic( REF_PIC_LIST_1, aiCurrRefIdx[1] )->getSPS()->getViewId() != m_uiCurrViewId };
1696	Bool bUsesInterViewPrd = ( abCurrIntView[0] \|\| abCurrIntView[1] );
1697	if( bUsesInterViewPrd )
1698	{
1699	xIViewPUDepthMapUpdate ( pcCU, pcCUDepthMap, uiPartIdx );
1700	}
1701	else
1702	{
1703	#if PDM_NO_INTER_UPDATE
1704	xInterPUDepthMapPrediction( pcCU, pcCUDepthMap, uiPartIdx );
1705	#else
1706	xInterPUDepthMapUpdate ( pcCU, pcCUDepthMap, uiPartIdx );
1707	#endif
1708	}
1709	}
1710	else
1711	{
1712	xInterPUDepthMapPrediction( pcCU, pcCUDepthMap, uiPartIdx );
1713	}
1714	}
1715
1716
1717	Void
1718	TComDepthMapGenerator::xIViewPUDepthMapUpdate( TComDataCU* pcCU, TComYuv* pcCUDepthMap, UInt uiPartIdx )
1719	{
1720	// get width, height, and part address
1721	Int iWidth;
1722	Int iHeight;
1723	UInt uiAbsPartIdx;
1724	pcCU->getPartIndexAndSize( uiPartIdx, uiAbsPartIdx, iWidth, iHeight );
1725	iWidth >>= m_uiSubSampExpX;
1726	iHeight >>= m_uiSubSampExpY;
1727
1728	// get depth values
1729	Int iDepthValue = PDM_UNDEFINED_DEPTH;
1730	Int aiPrdDepth[2] = { PDM_UNDEFINED_DEPTH, PDM_UNDEFINED_DEPTH };
1731	for( Int iRefListId = 0; iRefListId < 2; iRefListId++ )
1732	{
1733	RefPicList eRefPicList = RefPicList( iRefListId );
1734	TComCUMvField* pcCUMvField = pcCU->getCUMvField( eRefPicList );
1735	Int iRefIdx = pcCUMvField->getRefIdx( uiAbsPartIdx );
1736	UInt uiBaseId = ( iRefIdx >= 0 ? pcCU->getSlice()->getRefPic( eRefPicList, iRefIdx )->getSPS()->getViewId() : MAX_VIEW_NUM );
1737	Bool bInterview = ( iRefIdx >= 0 && uiBaseId < m_uiCurrViewId );
1738	if( bInterview )
1739	{
1740	Int iMvX = pcCUMvField->getMv( uiAbsPartIdx ).getHor();
1741	aiPrdDepth[ iRefListId ] = xGetVirtDepthFromDisparity( uiBaseId, iMvX );
1742	}
1743	}
1744	if( aiPrdDepth[ 0 ] != PDM_UNDEFINED_DEPTH && aiPrdDepth[ 1 ] != PDM_UNDEFINED_DEPTH )
1745	{
1746	iDepthValue = ( aiPrdDepth[ 0 ] + aiPrdDepth[ 1 ] + 1 ) >> 1;
1747	}
1748	else
1749	{
1750	iDepthValue = ( aiPrdDepth[ 0 ] != PDM_UNDEFINED_DEPTH ? aiPrdDepth[ 0 ] : aiPrdDepth[ 1 ] );
1751	AOT( iDepthValue == PDM_UNDEFINED_DEPTH );
1752	}
1753	iDepthValue = Max( 0, Min( PDM_MAX_ABS_VIRT_DEPTH, iDepthValue ) );
1754
1755	// set depth map for PU
1756	UInt uiBlkX = g_auiRasterToPelX[ g_auiZscanToRaster[ uiAbsPartIdx ] ] >> m_uiSubSampExpX;
1757	UInt uiBlkY = g_auiRasterToPelY[ g_auiZscanToRaster[ uiAbsPartIdx ] ] >> m_uiSubSampExpY;
1758	Pel* pDMSamples = pcCUDepthMap->getLumaAddr() + uiBlkY * pcCUDepthMap->getStride() + uiBlkX;
1759	Int iStride = pcCUDepthMap->getStride ();
1760	for( Int iY = 0; iY < iHeight; iY++, pDMSamples += iStride )
1761	{
1762	for( Int iX = 0; iX < iWidth; iX++)
1763	{
1764	pDMSamples[ iX ] = (Pel)iDepthValue;
1765	}
1766	}
1767	}
1768
1769
1770	Void
1771	TComDepthMapGenerator::xInterPUDepthMapUpdate( TComDataCU* pcCU, TComYuv* pcCUDepthMap, UInt uiPartIdx )
1772	{
1773	const Int iMaxAbsDeltaMvY = 8 << 2;
1774
1775	//===== determine block parameters for current access unit and current view =====
1776	Int iWidth;
1777	Int iHeight;
1778	UInt uiAbsPartIdx;
1779	pcCU->getPartIndexAndSize ( uiPartIdx, uiAbsPartIdx, iWidth, iHeight );
1780	UInt uiCurrViewId = pcCU->getSlice()->getSPS()->getViewId();
1781	Int iNum4x4BlksY = iHeight >> 2;
1782	Int iNum4x4BlksX = iWidth >> 2;
1783	iWidth >>= m_uiSubSampExpX;
1784	iHeight >>= m_uiSubSampExpY;
1785
1786	TComPicYuv* pcCurrDepthMap = pcCU->getPic()->getPredDepthMap();
1787	Pel* piCurrDepthMap = pcCurrDepthMap->getLumaAddr();
1788	Int iCurrStride = pcCurrDepthMap->getStride();
1789	TComCUMvField* aiCurrMvField[2] = { pcCU->getCUMvField( REF_PIC_LIST_0 ), pcCU->getCUMvField( REF_PIC_LIST_1 ) };
1790	Int aiCurrRefIdx [2] = { aiCurrMvField[0]->getRefIdx( uiAbsPartIdx ), aiCurrMvField[1]->getRefIdx( uiAbsPartIdx ) };
1791	Int iMinCurrListId = ( aiCurrRefIdx [0] < 0 ? 1 : 0 );
1792	Int iMaxCurrListId = ( aiCurrRefIdx [1] < 0 ? 0 : 1 );
1793	Int iCurrPUPosX;
1794	Int iCurrPUPosY;
1795	pcCurrDepthMap->getTopLeftSamplePos( pcCU->getAddr(), pcCU->getZorderIdxInCU() + uiAbsPartIdx, iCurrPUPosX, iCurrPUPosY );
1796	AOT( uiCurrViewId != m_uiCurrViewId );
1797	AOT( iMinCurrListId > iMaxCurrListId );
1798	AOT( aiCurrRefIdx[0] >= 0 && pcCU->getSlice()->getRefPic( REF_PIC_LIST_0, aiCurrRefIdx[0] )->getSPS()->getViewId() != uiCurrViewId );
1799	AOT( aiCurrRefIdx[1] >= 0 && pcCU->getSlice()->getRefPic( REF_PIC_LIST_1, aiCurrRefIdx[1] )->getSPS()->getViewId() != uiCurrViewId );
1800
1801	//===== determine parameters for current access unit and base view =====
1802	AOF( m_auiBaseIdList.size() );
1803	UInt uiBaseId = m_auiBaseIdList[ 0 ];
1804	TComPic* pcBasePic = m_pcAUPicAccess->getPic( uiBaseId );
1805	AOF( pcBasePic );
1806	TComPicYuv* pcBaseDepthMap = pcBasePic->getPredDepthMap();
1807	TComPicYuv* pcBaseRecPic = pcBasePic->getPicYuvRec ();
1808	Pel* piBaseDepthMap = pcBaseDepthMap->getLumaAddr();
1809	Int iBaseStride = pcBaseDepthMap->getStride();
1810	Int iShiftX = m_uiSubSampExpX + 2;
1811	Int iShiftY = m_uiSubSampExpY + 2;
1812	Int iAddX = ( 1 << iShiftX ) >> 1;
1813	Int iAddY = ( 1 << iShiftY ) >> 1;
1814
1815	//===== initialize 4x4 block arrays =====
1816	for( Int i4x4BlkY = 0; i4x4BlkY < iNum4x4BlksY; i4x4BlkY++ )
1817	{
1818	for( Int i4x4BlkX = 0; i4x4BlkX < iNum4x4BlksX; i4x4BlkX++ )
1819	{
1820	m_aabDepthSet[ i4x4BlkY ][ i4x4BlkX ] = false;
1821	m_aai4x4Depth[ i4x4BlkY ][ i4x4BlkX ] = PDM_UNDEFINED_DEPTH;
1822	}
1823	}
1824	Int iNum4x4Set = 0;
1825
1826	//===== determine depth based on 4x4 blocks =====
1827	for( Int i4x4BlkY = 0; i4x4BlkY < iNum4x4BlksY; i4x4BlkY++ )
1828	{
1829	for( Int i4x4BlkX = 0; i4x4BlkX < iNum4x4BlksX; i4x4BlkX++ )
1830	{
1831	// position parameters
1832	Int iCurrBlkPosX = iCurrPUPosX + ( ( i4x4BlkX << 2 ) >> m_uiSubSampExpX );
1833	Int iCurrBlkPosY = iCurrPUPosY + ( ( i4x4BlkY << 2 ) >> m_uiSubSampExpY );
1834	Int iCurrSamplePosX = iCurrBlkPosX + ( 1 >> m_uiSubSampExpX );
1835	Int iCurrSamplePosY = iCurrBlkPosY + ( 1 >> m_uiSubSampExpY );
1836	Int iCurrPredDepth = piCurrDepthMap[ iCurrSamplePosY * iCurrStride + iCurrSamplePosX ];
1837	Int iCurrPredDisp = xGetDisparityFromVirtDepth( uiBaseId, iCurrPredDepth );
1838	Int iBaseSamplePosX = iCurrSamplePosX + ( ( iCurrPredDisp + iAddX ) >> iShiftX );
1839	Int iBaseSamplePosY = iCurrSamplePosY;
1840	iBaseSamplePosX = Clip3( 0, pcBaseDepthMap->getWidth () - 1, iBaseSamplePosX );
1841	iBaseSamplePosY = Clip3( 0, pcBaseDepthMap->getHeight() - 1, iBaseSamplePosY );
1842
1843	// check for occlusion
1844	if( piBaseDepthMap[ iBaseSamplePosY * iBaseStride + iBaseSamplePosX ] != iCurrPredDepth )
1845	{
1846	continue;
1847	}
1848
1849	// determine base motion data and check prediction mode
1850	Int iBaseCUAddr;
1851	Int iBaseAbsPartIdx;
1852	pcBaseRecPic->getCUAddrAndPartIdx( iBaseSamplePosX << m_uiSubSampExpX, iBaseSamplePosY << m_uiSubSampExpY, iBaseCUAddr, iBaseAbsPartIdx );
1853	TComDataCU* pcBaseCU = pcBasePic->getCU( iBaseCUAddr );
1854	if( pcBaseCU->getPredictionMode( iBaseAbsPartIdx ) != MODE_INTER && pcBaseCU->getPredictionMode( iBaseAbsPartIdx ) != MODE_SKIP )
1855	{
1856	continue;
1857	}
1858
1859	// check whether base was inter-view predicted
1860	TComCUMvField* aiBaseMvField[2] = { pcBaseCU->getCUMvField( REF_PIC_LIST_0 ), pcBaseCU->getCUMvField( REF_PIC_LIST_1 ) };
1861	Int aiBaseRefIdx [2] = { aiBaseMvField[0]->getRefIdx( iBaseAbsPartIdx ), aiBaseMvField[1]->getRefIdx( iBaseAbsPartIdx ) };
1862	Bool abBaseIntView[2] = { aiBaseRefIdx[0] >= 0 && pcBaseCU->getSlice()->getRefPic( REF_PIC_LIST_0, aiBaseRefIdx[0] )->getSPS()->getViewId() != uiBaseId,
1863	aiBaseRefIdx[1] >= 0 && pcBaseCU->getSlice()->getRefPic( REF_PIC_LIST_1, aiBaseRefIdx[1] )->getSPS()->getViewId() != uiBaseId };
1864	if( abBaseIntView[0] \|\| abBaseIntView[1] )
1865	{ // current depth is reliable
1866	m_aai4x4Depth[i4x4BlkY][i4x4BlkX] = iCurrPredDepth;
1867	m_aabDepthSet[i4x4BlkY][i4x4BlkX] = true;
1868	iNum4x4Set++;
1869	continue;
1870	}
1871
1872	// determine depth candidates using an approximate 4-point relationship (if appropriate)
1873	std::vector<Int> aiDepthCand;
1874	Int iMinBaseListId = ( aiBaseRefIdx [0] < 0 ? 1 : 0 );
1875	Int iMaxBaseListId = ( aiBaseRefIdx [1] < 0 ? 0 : 1 );
1876	AOT( iMinBaseListId > iMaxBaseListId );
1877	for( Int iCurrRefListId = iMinCurrListId; iCurrRefListId <= iMaxCurrListId; iCurrRefListId++ )
1878	{
1879	RefPicList eCurrRefPicList = RefPicList( iCurrRefListId );
1880	Int iCurrRefPoc = pcCU->getSlice()->getRefPOC( eCurrRefPicList, aiCurrRefIdx[ iCurrRefListId ] );
1881	TComPic* pcCurrRefPic = pcCU->getSlice()->getRefPic( eCurrRefPicList, aiCurrRefIdx[ iCurrRefListId ] );
1882	TComPicYuv* pcCurrRefDMap = pcCurrRefPic->getPredDepthMap();
1883	Pel* piCurrRefDMap = pcCurrRefDMap->getLumaAddr();
1884	Int iCurrRefStride = pcCurrRefDMap->getStride();
1885	TComMv rcCurrMv = aiCurrMvField[ iCurrRefListId ]->getMv( uiAbsPartIdx );
1886	Int iCurrRefSamplePosX = iCurrSamplePosX + ( ( rcCurrMv.getHor() + iAddX ) >> iShiftX );
1887	Int iCurrRefSamplePosY = iCurrSamplePosY + ( ( rcCurrMv.getVer() + iAddY ) >> iShiftY );
1888	Int iCurrRefSamplePosXC = Clip3( 0, pcCurrRefDMap->getWidth () - 1, iCurrRefSamplePosX );
1889	Int iCurrRefSamplePosYC = Clip3( 0, pcCurrRefDMap->getHeight() - 1, iCurrRefSamplePosY );
1890	Int iCurrRefDepth = piCurrRefDMap[ iCurrRefSamplePosYC * iCurrRefStride + iCurrRefSamplePosXC ];
1891
1892	for( Int iBaseRefListId = iMinBaseListId; iBaseRefListId <= iMaxBaseListId; iBaseRefListId++ )
1893	{
1894	RefPicList eBaseRefPicList = RefPicList( iBaseRefListId );
1895	Int iBaseRefPoc = pcBaseCU->getSlice()->getRefPOC( eBaseRefPicList, aiBaseRefIdx[ iBaseRefListId ] );
1896
1897	if( iCurrRefPoc == iBaseRefPoc )
1898	{
1899	// location and depth for path currView/currAU -> currView/refAU -> baseView/refAU
1900	Int iCurrRefDisp = xGetDisparityFromVirtDepth( uiBaseId, iCurrRefDepth );
1901	Int iBaseRefSamplePosX = iCurrRefSamplePosX + ( ( iCurrRefDisp + iAddX ) >> iShiftX );
1902	Int iBaseRefSamplePosY = iCurrRefSamplePosY;
1903	TComPic* pcBaseRefPic = pcBaseCU->getSlice()->getRefPic( eBaseRefPicList, aiBaseRefIdx[ iBaseRefListId ] );
1904	TComPicYuv* pcBaseRefDMap = pcBaseRefPic->getPredDepthMap();
1905	Pel* piBaseRefDMap = pcBaseRefDMap->getLumaAddr();
1906	Int iBaseRefStride = pcBaseRefDMap->getStride();
1907	iBaseRefSamplePosX = Clip3( 0, pcBaseRefDMap->getWidth () - 1, iBaseRefSamplePosX );
1908	iBaseRefSamplePosY = Clip3( 0, pcBaseRefDMap->getHeight() - 1, iBaseRefSamplePosY );
1909	Int iBaseRefDepth = piBaseRefDMap[ iBaseRefSamplePosY * iBaseRefStride + iBaseRefSamplePosX ];
1910
1911	// location and depth for path currView/currAU ->baseView/currAU -> baseView/refAU
1912	TComMv rcBaseMv = aiBaseMvField[ iBaseRefListId ]->getMv( iBaseAbsPartIdx );
1913	Int iAbsDeltaMvY = ( rcBaseMv.getAbsVer() > rcCurrMv.getVer() ? rcBaseMv.getAbsVer() - rcCurrMv.getVer() : rcCurrMv.getVer() - rcBaseMv.getAbsVer() );
1914
1915	// check reliability (occlusion in reference access unit / vertical motion vector difference)
1916	if( iBaseRefDepth != iCurrRefDepth \|\| iAbsDeltaMvY > iMaxAbsDeltaMvY )
1917	{
1918	continue;
1919	}
1920
1921	// determine new depth
1922	Int iCurrCandDisp = iCurrRefDisp + rcCurrMv.getHor() - rcBaseMv.getHor();
1923	Int iCurrCandDepth = xGetVirtDepthFromDisparity( uiBaseId, iCurrCandDisp );
1924	aiDepthCand.push_back( iCurrCandDepth );
1925	} // iCurrRefPoc == iBaseRefPoc
1926	} // iBaseRefListId
1927	} // iCurrRefListId
1928
1929	// set depth for 4x4 block
1930	if( aiDepthCand.size() )
1931	{ // get depth with minimum change (probably most reliable)
1932	Int iMinAbsDepthChange = (1<<30);
1933	Int iDepthForMinChange = (1<<30);
1934	for( UInt uiCandId = 0; uiCandId < (UInt)aiDepthCand.size(); uiCandId++ )
1935	{
1936	Int iAbsDeltaDepth = ( aiDepthCand[uiCandId] > iCurrPredDepth ? aiDepthCand[uiCandId] > iCurrPredDepth : iCurrPredDepth - aiDepthCand[uiCandId] );
1937	if( iAbsDeltaDepth < iMinAbsDepthChange )
1938	{
1939	iMinAbsDepthChange = iAbsDeltaDepth;
1940	iDepthForMinChange = aiDepthCand[uiCandId];
1941	}
1942	}
1943	m_aai4x4Depth[i4x4BlkY][i4x4BlkX] = Min( Max( 0, iDepthForMinChange ), PDM_MAX_ABS_VIRT_DEPTH );
1944	m_aabDepthSet[i4x4BlkY][i4x4BlkX] = true;
1945	iNum4x4Set++;
1946	}
1947	} // i4x4BlkX
1948	} // i4x4BlkY
1949
1950	//===== fall back (take original depth for 4x4 blocks) ====
1951	if( iNum4x4Set < Max( 1, ( iNum4x4BlksY * iNum4x4BlksX ) >> 2 ) )
1952	{
1953	iNum4x4Set = 0;
1954	for( Int i4x4BlkY = 0; i4x4BlkY < iNum4x4BlksY; i4x4BlkY++ )
1955	{
1956	for( Int i4x4BlkX = 0; i4x4BlkX < iNum4x4BlksX; i4x4BlkX++ )
1957	{
1958	Int iCurrSamplePosX = iCurrPUPosX + ( ( ( i4x4BlkX << 2 ) + 1 ) >> m_uiSubSampExpX );
1959	Int iCurrSamplePosY = iCurrPUPosY + ( ( ( i4x4BlkY << 2 ) + 1 ) >> m_uiSubSampExpY );
1960	m_aai4x4Depth[i4x4BlkY][i4x4BlkX] = piCurrDepthMap[ iCurrSamplePosY * iCurrStride + iCurrSamplePosX ];
1961	m_aabDepthSet[i4x4BlkY][i4x4BlkX] = true;
1962	iNum4x4Set++;
1963	}
1964	}
1965	}
1966
1967	#if PDM_ONE_DEPTH_PER_PU
1968	//===== set average in 4x4 depth array =====
1969	Int iSum = 0;
1970	for( Int i4x4BlkY = 0; i4x4BlkY < iNum4x4BlksY; i4x4BlkY++ )
1971	{
1972	for( Int i4x4BlkX = 0; i4x4BlkX < iNum4x4BlksX; i4x4BlkX++ )
1973	{
1974	if( m_aabDepthSet[ i4x4BlkY ][ i4x4BlkX ] )
1975	{
1976	iSum += m_aai4x4Depth[ i4x4BlkY ][ i4x4BlkX ];
1977	}
1978	}
1979	}
1980	Int iDepth = ( iSum + ( iNum4x4Set >> 1 ) ) / iNum4x4Set;
1981	iNum4x4Set = iNum4x4BlksY * iNum4x4BlksX;
1982	for( Int i4x4BlkY = 0; i4x4BlkY < iNum4x4BlksY; i4x4BlkY++ )
1983	{
1984	for( Int i4x4BlkX = 0; i4x4BlkX < iNum4x4BlksX; i4x4BlkX++ )
1985	{
1986	m_aai4x4Depth[ i4x4BlkY ][ i4x4BlkX ] = iDepth;
1987	m_aabDepthSet[ i4x4BlkY ][ i4x4BlkX ] = true;
1988	}
1989	}
1990	#endif
1991
1992	//===== complete depth arrays =====
1993	while( iNum4x4BlksY * iNum4x4BlksX - iNum4x4Set )
1994	{
1995	for( Int i4x4BlkY = 0; i4x4BlkY < iNum4x4BlksY; i4x4BlkY++ )
1996	{
1997	for( Int i4x4BlkX = 0; i4x4BlkX < iNum4x4BlksX; i4x4BlkX++ )
1998	{
1999	if( !m_aabDepthSet[ i4x4BlkY ][ i4x4BlkX ] )
2000	{ // could also use minimum of neighbours (occlusions)
2001	Int iNumNeighbours = 0;
2002	Int iSumNeighbours = 0;
2003	if( i4x4BlkY > 0 && m_aabDepthSet[ i4x4BlkY-1 ][ i4x4BlkX ] ) { iSumNeighbours += m_aai4x4Depth[ i4x4BlkY-1 ][ i4x4BlkX ]; iNumNeighbours++; }
2004	if( i4x4BlkY < iNum4x4BlksY-1 && m_aabDepthSet[ i4x4BlkY+1 ][ i4x4BlkX ] ) { iSumNeighbours += m_aai4x4Depth[ i4x4BlkY+1 ][ i4x4BlkX ]; iNumNeighbours++; }
2005	if( i4x4BlkX > 0 && m_aabDepthSet[ i4x4BlkY ][ i4x4BlkX-1 ] ) { iSumNeighbours += m_aai4x4Depth[ i4x4BlkY ][ i4x4BlkX-1 ]; iNumNeighbours++; }
2006	if( i4x4BlkX < iNum4x4BlksX-1 && m_aabDepthSet[ i4x4BlkY ][ i4x4BlkX+1 ] ) { iSumNeighbours += m_aai4x4Depth[ i4x4BlkY ][ i4x4BlkX+1 ]; iNumNeighbours++; }
2007	if( iNumNeighbours )
2008	{
2009	m_aai4x4Depth[ i4x4BlkY ][ i4x4BlkX ] = ( iSumNeighbours + ( iNumNeighbours >> 1 ) ) / iNumNeighbours;
2010	m_aabDepthSet[ i4x4BlkY ][ i4x4BlkX ] = true;
2011	iNum4x4Set++;
2012	}
2013	}
2014	}
2015	}
2016	}
2017
2018	//===== set depth values =====
2019	UInt uiBlkX = g_auiRasterToPelX[ g_auiZscanToRaster[ uiAbsPartIdx ] ] >> m_uiSubSampExpX;
2020	UInt uiBlkY = g_auiRasterToPelY[ g_auiZscanToRaster[ uiAbsPartIdx ] ] >> m_uiSubSampExpY;
2021	Pel* piDepthMap = pcCUDepthMap->getLumaAddr() + uiBlkY * pcCUDepthMap->getStride() + uiBlkX;
2022	Int iCUStride = pcCUDepthMap->getStride ();
2023	for( Int iRow = 0; iRow < iHeight; iRow++, piDepthMap += iCUStride )
2024	{
2025	for( Int iCol = 0; iCol < iWidth; iCol++ )
2026	{
2027	piDepthMap[ iCol ] = m_aai4x4Depth[ (iRow << m_uiSubSampExpY) >> 2 ][ (iCol << m_uiSubSampExpX) >> 2 ];
2028	}
2029	}
2030	}
2031
2032
2033	Void
2034	TComDepthMapGenerator::xInterPUDepthMapPrediction( TComDataCU* pcCU, TComYuv* pcCUDepthMap, UInt uiPartIdx )
2035	{
2036	m_pcPrediction->motionCompensation( pcCU, pcCUDepthMap, REF_PIC_LIST_X, (Int)uiPartIdx, true, m_uiSubSampExpX, m_uiSubSampExpY );
2037	}
2038
2039
2040	Bool
2041	TComDepthMapGenerator::xGetPredDepth( TComDataCU* pcCU, UInt uiPartIdx, Int& riPrdDepth, Int* piPosX, Int* piPosY )
2042	{
2043	AOF ( m_bCreated && m_bInit );
2044	AOF ( pcCU );
2045	ROFRS( m_bPDMAvailable, false );
2046
2047	TComSlice* pcSlice = pcCU->getSlice ();
2048	TComPic* pcPic = pcCU->getPic ();
2049	TComSPS* pcSPS = pcSlice->getSPS();
2050	AOF ( pcPic->getPredDepthMap() );
2051	AOF ( pcSPS->getViewId() == m_uiCurrViewId );
2052
2053	//===== get predicted depth and disprity for middle position of current PU =====
2054	UInt uiPartAddr;
2055	Int iWidth;
2056	Int iHeight;
2057	pcCU->getPartIndexAndSize( uiPartIdx, uiPartAddr, iWidth, iHeight );
2058	TComPicYuv* pcPredDepthMap = pcPic->getPredDepthMap();
2059	Pel* piPredDepthMap = pcPredDepthMap->getLumaAddr ( 0 );
2060	Int iCurrStride = pcPredDepthMap->getStride ();
2061	Int iCurrPosX;
2062	Int iCurrPosY;
2063	pcPredDepthMap->getTopLeftSamplePos( pcCU->getAddr(), pcCU->getZorderIdxInCU() + uiPartAddr, iCurrPosX, iCurrPosY );
2064	#if SAIT_IMPROV_MOTION_PRED_M24829 // max disparity within PU
2065	Int DiWidth = iCurrPosX+(iWidth >> m_uiSubSampExpX);
2066	Int DiHeight = iCurrPosY+(iHeight >> m_uiSubSampExpY);
2067	Int maxDepth = MIN_INT;
2068
2069	for(Int y=iCurrPosY; y<DiHeight ;y++)
2070	{
2071	for(Int x=iCurrPosX; x<DiWidth; x++)
2072	{
2073	if(piPredDepthMap[ x + y * iCurrStride ] > maxDepth)
2074	{
2075	maxDepth = piPredDepthMap[ x + y * iCurrStride ];
2076	}
2077	}
2078	}
2079	iCurrPosX += ( ( iWidth >> m_uiSubSampExpX ) - 1 ) >> 1;
2080	iCurrPosY += ( ( iHeight >> m_uiSubSampExpY ) - 1 ) >> 1;
2081	riPrdDepth = maxDepth;
2082	#else
2083	iCurrPosX += ( ( iWidth >> m_uiSubSampExpX ) - 1 ) >> 1;
2084	iCurrPosY += ( ( iHeight >> m_uiSubSampExpY ) - 1 ) >> 1;
2085	riPrdDepth = piPredDepthMap[ iCurrPosX + iCurrPosY * iCurrStride ];
2086	#endif
2087	if( piPosX )
2088	{
2089	*piPosX = iCurrPosX;
2090	}
2091	if( piPosY )
2092	{
2093	*piPosY = iCurrPosY;
2094	}
2095	return true;
2096	}
2097	#endif
2098
2099	#endif // DEPTH_MAP_GENERATION
2100

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

Download in other formats: