Context navigation

← Previous revision
Next revision →
Blame
Revision log

TComDepthMapGenerator.cpp

Visit:

Last change on this file 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: 77.1 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	#if VSP_N
566	Void
567	TComDepthMapGenerator::clearDepthMap( TComPic* pcPic, Int iVal/=PDM_UNDEFINED_DEPTH/ )
568	{
569	xClearDepthMap( pcPic, iVal );
570	}
571	#endif
572	#endif
573
574	#if HHI_INTER_VIEW_MOTION_PRED
575	Void
576	TComDepthMapGenerator::covertOrgDepthMap( TComPic* pcPic )
577	{
578	AOF ( m_bCreated && m_bInit );
579	AOF ( pcPic );
580	ROFVS( pcPic->getOrgDepthMap() );
581	AOF ( pcPic->getViewId() );
582
583	UInt uiBaseId = pcPic->getViewId();
584	Int iWidth = pcPic->getOrgDepthMap()->getWidth ();
585	Int iHeight = pcPic->getOrgDepthMap()->getHeight ();
586	Int iStride = pcPic->getOrgDepthMap()->getStride ();
587	Pel* pSamples = pcPic->getOrgDepthMap()->getLumaAddr ( 0 );
588	for( Int iY = 0; iY < iHeight; iY++, pSamples += iStride )
589	{
590	for( Int iX = 0; iX < iWidth; iX++ )
591	{
592	pSamples[ iX ] = xGetVirtDepthFromOrigDepth( uiBaseId, pSamples[ iX ] );
593	}
594	}
595	}
596	#endif
597
598	Int
599	TComDepthMapGenerator::getDisparity( TComPic* pcPic, Int iPosX, Int iPosY, UInt uiRefViewId )
600	{
601	AOF( pcPic );
602	AOF( pcPic->getPredDepthMap() );
603	AOF( iPosX >= 0 && iPosX < pcPic->getPredDepthMap()->getWidth () );
604	AOF( iPosY >= 0 && iPosY < pcPic->getPredDepthMap()->getHeight() );
605	Pel* piPdmMap = pcPic->getPredDepthMap()->getLumaAddr( 0 );
606	Int iStride = pcPic->getPredDepthMap()->getStride ();
607	Int iPrdDepth = piPdmMap[ iPosX + iPosY * iStride ];
608	Int iDisparity = xGetDisparityFromVirtDepth( uiRefViewId, iPrdDepth );
609	return iDisparity;
610	}
611
612
613
614	#if HHI_INTER_VIEW_MOTION_PRED
615	#if QC_MULTI_DIS_CAN_A0097
616	Int
617	TComDepthMapGenerator::getPdmMergeCandidate( TComDataCU* pcCU, UInt uiPartIdx, Int* paiPdmRefIdx, TComMv* pacPdmMv, DisInfo* pDInfo
618	#if QC_MRG_CANS_B0048
619	, Int* iPdm
620	#endif
621	)
622	#else
623	Int
624	TComDepthMapGenerator::getPdmMergeCandidate( TComDataCU* pcCU, UInt uiPartIdx, Int* paiPdmRefIdx, TComMv* pacPdmMv )
625	#endif
626	{
627	#if MTK_INTERVIEW_MERGE_A0049
628	AOF ( m_bCreated && m_bInit );
629
630	#if !QC_MULTI_DIS_CAN_A0097
631	ROFRS( m_bPDMAvailable, 0 );
632	#endif
633
634	TComSlice* pcSlice = pcCU->getSlice ();
635	TComSPS* pcSPS = pcSlice->getSPS();
636	AOF ( pcSPS->getViewId() == m_uiCurrViewId );
637	Bool bPdmMerge = ( ( pcSPS->getMultiviewMvPredMode() & PDM_USE_FOR_MERGE ) == PDM_USE_FOR_MERGE );
638	ROTRS( !bPdmMerge, 0 );
639
640	#if QC_MRG_CANS_B0048
641	Bool abPdmAvailable[4] = {false, false, false, false};
642	#else
643	Bool abPdmAvailable[2] = {false,false};
644	#endif
645
646	Int iValid = 0;
647	Int iViewId = 0;
648	for( UInt uiBId = 0; uiBId < m_uiCurrViewId && iValid==0; uiBId++ )
649	{
650	UInt uiBaseId = m_auiBaseIdList[ uiBId ];
651	TComPic* pcBasePic = m_pcAUPicAccess->getPic( uiBaseId );
652	for( Int iRefListId = 0; iRefListId < 2 && iValid==0; iRefListId++ )
653	{
654	RefPicList eRefPicListTest = RefPicList( iRefListId );
655	Int iNumRefPics = pcSlice->getNumRefIdx( eRefPicListTest ) ;
656	for( Int iRefIndex = 0; iRefIndex < iNumRefPics; iRefIndex++ )
657	{
658	if(pcBasePic->getPOC() == pcSlice->getRefPic( eRefPicListTest, iRefIndex )->getPOC()
659	&& pcBasePic->getViewId() == pcSlice->getRefPic( eRefPicListTest, iRefIndex )->getViewId())
660	{
661	iValid=1;
662	iViewId = uiBaseId;
663	break;
664	}
665	}
666	}
667	}
668	if (iValid == 0)
669	return 0;
670
671	//--- get base CU/PU and check prediction mode ---
672	TComPic* pcBasePic = m_pcAUPicAccess->getPic( iViewId );
673	TComPicYuv* pcBaseRec = pcBasePic->getPicYuvRec ();
674
675	#if QC_MULTI_DIS_CAN_A0097
676	Int iCurrPosX, iCurrPosY;
677	UInt uiPartAddr;
678	Int iWidth;
679	Int iHeight;
680
681	pcCU->getPartIndexAndSize( uiPartIdx, uiPartAddr, iWidth, iHeight );
682	pcBaseRec->getTopLeftSamplePos( pcCU->getAddr(), pcCU->getZorderIdxInCU() + uiPartAddr, iCurrPosX, iCurrPosY );
683	iCurrPosX += ( ( iWidth - 1 ) >> 1 );
684	iCurrPosY += ( ( iHeight - 1 ) >> 1 );
685
686	Int iBasePosX = Clip3( 0, pcBaseRec->getWidth () - 1, iCurrPosX + ( (pDInfo->m_acMvCand[0].getHor() + 2 ) >> 2 ) );
687	Int iBasePosY = Clip3( 0, pcBaseRec->getHeight() - 1, iCurrPosY + ( (pDInfo->m_acMvCand[0].getVer() + 2 ) >> 2 ));
688	Int iBaseCUAddr;
689	Int iBaseAbsPartIdx;
690	pcBaseRec->getCUAddrAndPartIdx( iBasePosX , iBasePosY , iBaseCUAddr, iBaseAbsPartIdx );
691	#else
692	Int iPrdDepth, iCurrPosX, iCurrPosY;
693	Bool bAvailable = xGetPredDepth( pcCU, uiPartIdx, iPrdDepth, &iCurrPosX, &iCurrPosY );
694	AOF( bAvailable );
695	TComPicYuv* pcBasePdm = pcBasePic->getPredDepthMap();
696	Int iDisparity = xGetDisparityFromVirtDepth( iViewId, iPrdDepth );
697	Int iShiftX = m_uiSubSampExpX + 2;
698	Int iAddX = ( 1 << iShiftX ) >> 1;
699	Int iBasePosX = Clip3( 0, pcBasePdm->getWidth () - 1, iCurrPosX + ( ( iDisparity + iAddX ) >> iShiftX ) );
700	Int iBasePosY = Clip3( 0, pcBasePdm->getHeight() - 1, iCurrPosY );
701	Int iBaseCUAddr;
702	Int iBaseAbsPartIdx;
703	pcBaseRec->getCUAddrAndPartIdx( iBasePosX<< m_uiSubSampExpX , iBasePosY<< m_uiSubSampExpY , iBaseCUAddr, iBaseAbsPartIdx );
704	#endif
705
706	TComDataCU* pcBaseCU = pcBasePic->getCU( iBaseCUAddr );
707
708	if( pcBaseCU->getPredictionMode( iBaseAbsPartIdx ) == MODE_INTER \|\| pcBaseCU->getPredictionMode( iBaseAbsPartIdx ) == MODE_SKIP )
709	{
710	for( UInt uiBaseRefListId = 0; uiBaseRefListId < 2; uiBaseRefListId++ )
711	{
712	RefPicList eBaseRefPicList = RefPicList( uiBaseRefListId );
713	TComMvField cBaseMvField;
714	pcBaseCU->getMvField( pcBaseCU, iBaseAbsPartIdx, eBaseRefPicList, cBaseMvField );
715	Int iBaseRefIdx = cBaseMvField.getRefIdx();
716
717	if (iBaseRefIdx >= 0)
718	{
719	Int iBaseRefPOC = pcBaseCU->getSlice()->getRefPOC(eBaseRefPicList, iBaseRefIdx);
720	if (iBaseRefPOC != pcSlice->getPOC())
721	{
722	for (Int iPdmRefIdx = 0; iPdmRefIdx < pcSlice->getNumRefIdx( eBaseRefPicList ); iPdmRefIdx++)
723	{
724	if (iBaseRefPOC == pcSlice->getRefPOC(eBaseRefPicList, iPdmRefIdx))
725	{
726	abPdmAvailable[ uiBaseRefListId ] = true;
727	paiPdmRefIdx [ uiBaseRefListId ] = iPdmRefIdx;
728	TComMv cMv(cBaseMvField.getHor(), cBaseMvField.getVer());
729	#if LGE_DVMCP_A0126
730	cMv.m_bDvMcp = true;
731	cMv.m_iDvMcpDispX = pDInfo->m_acMvCand[0].getHor();
732	#endif
733	pcCU->clipMv( cMv );
734	pacPdmMv [ uiBaseRefListId ] = cMv;
735	break;
736	}
737	}
738	}
739	}
740	}
741	}
742	Int iPdmInterDir = ( abPdmAvailable[0] ? 1 : 0 ) + ( abPdmAvailable[1] ? 2 : 0 );
743	#if QC_MRG_CANS_B0048
744	iPdm[0] = iPdmInterDir;
745	#else
746	if (iPdmInterDir == 0)
747	{
748	#endif
749	for( Int iRefListId = 0; iRefListId < 2 ; iRefListId++ )
750	{
751	RefPicList eRefPicList = RefPicList( iRefListId );
752	Int iNumRefPics = pcSlice->getNumRefIdx( eRefPicList );
753	for( Int iPdmRefIdx = 0; iPdmRefIdx < iNumRefPics; iPdmRefIdx++ )
754	{
755	#if VSP_N
756	if( !pcCU->isVspRef( eRefPicList, iPdmRefIdx ) )
757	#endif
758	if( pcSlice->getRefPOC( eRefPicList, iPdmRefIdx ) == pcSlice->getPOC())
759	{
760	#if QC_MRG_CANS_B0048
761	abPdmAvailable[ iRefListId+2 ] = true;
762	paiPdmRefIdx [ iRefListId+2 ] = iPdmRefIdx;
763	#else
764	abPdmAvailable[ iRefListId ] = true;
765	paiPdmRefIdx [ iRefListId ] = iPdmRefIdx;
766	#endif
767	#if QC_MULTI_DIS_CAN_A0097
768	TComMv cMv = pDInfo->m_acMvCand[0];
769	cMv.setVer(0);
770	#else
771	TComMv cMv(iDisparity, 0);
772	#endif
773	pcCU->clipMv( cMv );
774	#if QC_MRG_CANS_B0048
775	pacPdmMv [ iRefListId + 2] = cMv;
776	#else
777	pacPdmMv [ iRefListId ] = cMv;
778	#endif
779	break;
780	}
781	}
782	}
783	#if QC_MRG_CANS_B0048
784	iPdmInterDir = ( abPdmAvailable[2] ? 1 : 0 ) + ( abPdmAvailable[3] ? 2 : 0 ) ;
785	iPdm[1] = iPdmInterDir;
786	#else
787	iPdmInterDir = ( abPdmAvailable[0] ? 1 : 0 ) + ( abPdmAvailable[1] ? 2 : 0 ) ;
788	}
789	#endif
790
791	return iPdmInterDir;
792
793	#else
794	Int iMaxNumInterPics = 1;
795	Int iMaxNumAllPics = 2;
796
797	// inter-only
798	Bool abPdmAvailable[2] = {false,false};
799	for( Int iRefListId = 0; iRefListId < 2; iRefListId++ )
800	{
801	RefPicList eRefPicList = RefPicList( iRefListId );
802	Int iNumRefPics = pcCU->getSlice()->getNumRefIdx( eRefPicList );
803	TComMv cMv;
804	for( Int iPdmRefIdx = 0, iInterPics = 0; iPdmRefIdx < iNumRefPics && iInterPics < iMaxNumInterPics; iPdmRefIdx++ )
805	{
806	if( pcCU->getSlice()->getRefPOC( eRefPicList, iPdmRefIdx ) != pcCU->getSlice()->getPOC() )
807	{
808	#if QC_MULTI_DIS_CAN_A0097
809	if( getDisCanPdmMvPred (pcCU, uiPartIdx, eRefPicList, iPdmRefIdx, cMv, pDInfo, true ) )
810	#else
811	if( getPdmMvPred( pcCU, uiPartIdx, eRefPicList, iPdmRefIdx, cMv, true ) )
812	#endif
813	{
814	pcCU->clipMv( cMv );
815	abPdmAvailable[ iRefListId ] = true;
816	paiPdmRefIdx [ iRefListId ] = iPdmRefIdx;
817	pacPdmMv [ iRefListId ] = cMv;
818	break;
819	}
820	iInterPics++;
821	}
822	}
823	}
824	Int iPdmInterDir = ( abPdmAvailable[0] ? 1 : 0 ) + ( abPdmAvailable[1] ? 2 : 0 );
825	if( 0==iPdmInterDir )
826	{ // check all, including inter view references
827	for( Int iRefListId = 0; iRefListId < 2; iRefListId++ )
828	{
829	RefPicList eRefPicList = RefPicList( iRefListId );
830	Int iNumRefPics = Min( iMaxNumAllPics, pcCU->getSlice()->getNumRefIdx( eRefPicList ) );
831	TComMv cMv;
832	for( Int iPdmRefIdx = 0; iPdmRefIdx < iNumRefPics; iPdmRefIdx++ )
833	{
834	#if QC_MULTI_DIS_CAN_A0097
835	if ( getDisCanPdmMvPred (pcCU, uiPartIdx, eRefPicList, iPdmRefIdx, cMv, pDInfo, true ) )
836	#else
837	if( getPdmMvPred( pcCU, uiPartIdx, eRefPicList, iPdmRefIdx, cMv, true ) )
838	#endif
839	{
840	pcCU->clipMv( cMv );
841	abPdmAvailable[ iRefListId ] = true;
842	paiPdmRefIdx [ iRefListId ] = iPdmRefIdx;
843	pacPdmMv [ iRefListId ] = cMv;
844	break;
845	}
846	}
847	}
848	iPdmInterDir = ( abPdmAvailable[0] ? 1 : 0 ) + ( abPdmAvailable[1] ? 2 : 0 );
849	}
850	return iPdmInterDir;
851	#endif
852	}
853
854	#if QC_MULTI_DIS_CAN_A0097
855	Bool
856	TComDepthMapGenerator::getDisCanPdmMvPred ( TComDataCU* pcCU, UInt uiPartIdx, RefPicList eRefPicList, Int iRefIdx, TComMv& rcMv, DisInfo* pDInfo, Bool bMerge )
857	{
858	#if LGE_DVMCP_A0126
859	rcMv.m_bDvMcp = false;
860	#endif
861	AOF ( m_bCreated && m_bInit );
862	AOF ( iRefIdx >= 0 );
863	AOF ( pcCU );
864	//ROFRS( m_bPDMAvailable, false );
865	TComSlice* pcSlice = pcCU->getSlice ();
866	TComSPS* pcSPS = pcSlice->getSPS();
867	AOF ( pcSPS->getViewId() == m_uiCurrViewId );
868	TComPic* pcRefPic = pcSlice->getRefPic( eRefPicList, iRefIdx );
869	UInt uiRefViewId = pcRefPic->getSPS()->getViewId();
870	Int iRefPoc = pcRefPic->getPOC();
871	Bool bInterview = ( uiRefViewId < m_uiCurrViewId );
872	#if VSP_N
873	Bool bVsp = pcCU->isVspRef( eRefPicList, iRefIdx );
874	AOT( bInterview && bVsp && iRefPoc != pcSlice->getPOC() );
875	AOT( !bInterview && !bVsp && iRefPoc == pcSlice->getPOC() );
876	#else
877	AOT( bInterview && iRefPoc != pcSlice->getPOC() );
878	AOT( !bInterview && iRefPoc == pcSlice->getPOC() );
879	#endif
880
881	#if FORCE_REF_VSP
882	if( bVsp ) return false;
883	#endif
884
885	Bool bPdmIView = ( ( pcSPS->getMultiviewMvPredMode() & PDM_USE_FOR_IVIEW ) == PDM_USE_FOR_IVIEW );
886	Bool bPdmInter = ( ( pcSPS->getMultiviewMvPredMode() & PDM_USE_FOR_INTER ) == PDM_USE_FOR_INTER );
887	Bool bPdmMerge = ( ( pcSPS->getMultiviewMvPredMode() & PDM_USE_FOR_MERGE ) == PDM_USE_FOR_MERGE );
888	ROTRS( ( bInterview && !bMerge ) && !bPdmIView, false );
889	ROTRS( (!bInterview && !bMerge ) && !bPdmInter, false );
890	ROTRS( bMerge && !bPdmMerge, false );
891	Int iCurrPosX, iCurrPosY;
892	TComMv cDisMv;
893
894	if( bInterview )
895	{
896	rcMv = pDInfo->m_acMvCand[0];
897	rcMv.setVer(0);
898	return true;
899	}
900	for( UInt uiBId = 0; uiBId < m_uiCurrViewId; uiBId++ )
901	{
902	UInt uiBaseId = uiBId; //m_auiBaseIdList[ uiBId ];
903
904	if (m_uiCurrViewId >1 && uiBaseId ==1 )
905	continue;
906
907	TComPic* pcBasePic = m_pcAUPicAccess->getPic( uiBaseId );
908	TComPicYuv* pcBaseRec = pcBasePic->getPicYuvRec ();
909	UInt uiPartAddr;
910	Int iWidth;
911	Int iHeight;
912
913	pcCU->getPartIndexAndSize( uiPartIdx, uiPartAddr, iWidth, iHeight );
914	pcBaseRec->getTopLeftSamplePos( pcCU->getAddr(), pcCU->getZorderIdxInCU() + uiPartAddr, iCurrPosX, iCurrPosY );
915	iCurrPosX += ( ( iWidth - 1 ) >> 1 );
916	iCurrPosY += ( ( iHeight - 1 ) >> 1 );
917	Int iBasePosX = Clip3( 0, pcBaseRec->getWidth () - 1, iCurrPosX + ( (pDInfo->m_acMvCand[0].getHor() + 2 ) >> 2 ) );
918	Int iBasePosY = Clip3( 0, pcBaseRec->getHeight() - 1, iCurrPosY + ( (pDInfo->m_acMvCand[0].getVer() + 2 ) >> 2 ));
919	Int iBaseCUAddr;
920	Int iBaseAbsPartIdx;
921	pcBaseRec->getCUAddrAndPartIdx( iBasePosX , iBasePosY , iBaseCUAddr, iBaseAbsPartIdx );
922	TComDataCU* pcBaseCU = pcBasePic->getCU( iBaseCUAddr );
923	if( pcBaseCU->getPredictionMode( iBaseAbsPartIdx ) != MODE_INTER && pcBaseCU->getPredictionMode( iBaseAbsPartIdx ) != MODE_SKIP )
924	{
925	continue;
926	}
927	for( UInt uiBaseRefListId = 0; uiBaseRefListId < 2; uiBaseRefListId++ )
928	{
929	RefPicList eBaseRefPicList = RefPicList( uiBaseRefListId );
930	TComMvField cBaseMvField;
931	pcBaseCU->getMvField( pcBaseCU, iBaseAbsPartIdx, eBaseRefPicList, cBaseMvField );
932	Int iBaseRefIdx = cBaseMvField.getRefIdx();
933	Int iBaseRefPoc = ( iBaseRefIdx >= 0 ? pcBaseCU->getSlice()->getRefPic( eBaseRefPicList, iBaseRefIdx )->getPOC() : -(1<<30) );
934	if( iBaseRefIdx >= 0 && iBaseRefPoc == iRefPoc )
935	{
936	rcMv.set( cBaseMvField.getHor(), cBaseMvField.getVer() );
937	#if LGE_DVMCP_A0126
938	// save disparity vector when a merge candidate for IVMP is set as DV-MCP
939	if( bMerge )
940	{
941	rcMv.m_bDvMcp = true;
942	rcMv.m_iDvMcpDispX = pDInfo->m_acMvCand[0].getHor();
943	}
944	else { // AMVP ?
945	rcMv.m_bDvMcp = false;
946	}
947	#endif
948	return true;
949	}
950	}
951	}
952	return false;
953	}
954	#else
955	Bool
956	TComDepthMapGenerator::getPdmMvPred( TComDataCU* pcCU, UInt uiPartIdx, RefPicList eRefPicList, Int iRefIdx, TComMv& rcMv, Bool bMerge )
957	{
958	AOF ( m_bCreated && m_bInit );
959	AOF ( iRefIdx >= 0 );
960	AOF ( pcCU );
961	ROFRS( m_bPDMAvailable, false );
962
963	TComSlice* pcSlice = pcCU->getSlice ();
964	TComPic* pcPic = pcCU->getPic ();
965	TComSPS* pcSPS = pcSlice->getSPS();
966	AOF ( pcPic->getPredDepthMap() );
967	AOF ( pcSPS->getViewId() == m_uiCurrViewId );
968
969	TComPic* pcRefPic = pcSlice->getRefPic( eRefPicList, iRefIdx );
970	UInt uiRefViewId = pcRefPic->getSPS()->getViewId();
971	Int iRefPoc = pcRefPic->getPOC();
972	Bool bInterview = ( uiRefViewId < m_uiCurrViewId );
973	#if VSP_N
974	Bool bVsp = pcCU->isVspRef( eRefPicList, iRefIdx );
975	AOT( bInterview && bVsp && iRefPoc != pcSlice->getPOC() );
976	AOT( !bInterview && !bVsp && iRefPoc == pcSlice->getPOC() );
977	#else
978	AOT( bInterview && iRefPoc != pcSlice->getPOC() );
979	AOT( !bInterview && iRefPoc == pcSlice->getPOC() );
980	#endif
981
982	#if FORCE_REF_VSP
983	if( bVsp ) return false;
984	#endif
985
986	Bool bPdmIView = ( ( pcSPS->getMultiviewMvPredMode() & PDM_USE_FOR_IVIEW ) == PDM_USE_FOR_IVIEW );
987	Bool bPdmInter = ( ( pcSPS->getMultiviewMvPredMode() & PDM_USE_FOR_INTER ) == PDM_USE_FOR_INTER );
988	Bool bPdmMerge = ( ( pcSPS->getMultiviewMvPredMode() & PDM_USE_FOR_MERGE ) == PDM_USE_FOR_MERGE );
989	ROTRS( ( bInterview && !bMerge ) && !bPdmIView, false );
990	ROTRS( (!bInterview && !bMerge ) && !bPdmInter, false );
991	ROTRS( bMerge && !bPdmMerge, false );
992
993	//===== get predicted depth for middle position of current PU =====
994	Int iPrdDepth, iCurrPosX, iCurrPosY;
995	Bool bAvailable = xGetPredDepth( pcCU, uiPartIdx, iPrdDepth, &iCurrPosX, &iCurrPosY );
996	AOF( bAvailable );
997
998	//===== inter-view motion vector prediction =====
999	if( bInterview )
1000	{
1001	Int iDisparity = xGetDisparityFromVirtDepth( uiRefViewId, iPrdDepth );
1002	rcMv.set ( iDisparity, 0 );
1003	return true;
1004	}
1005
1006	//===== inter motion vector prediction =====
1007	for( UInt uiBId = 0; uiBId < m_uiCurrViewId; uiBId++ )
1008	{
1009	//--- get base CU/PU and check prediction mode ---
1010	UInt uiBaseId = m_auiBaseIdList[ uiBId ];
1011	#if PDM_REMOVE_DEPENDENCE
1012	if( uiBaseId != 0)
1013	continue;
1014	#endif
1015	TComPic* pcBasePic = m_pcAUPicAccess->getPic( uiBaseId );
1016	TComPicYuv* pcBasePdm = pcBasePic->getPredDepthMap();
1017	TComPicYuv* pcBaseRec = pcBasePic->getPicYuvRec ();
1018	Int iDisparity = xGetDisparityFromVirtDepth( uiBaseId, iPrdDepth );
1019	Int iShiftX = m_uiSubSampExpX + 2;
1020	Int iAddX = ( 1 << iShiftX ) >> 1;
1021	Int iBasePosX = Clip3( 0, pcBasePdm->getWidth () - 1, iCurrPosX + ( ( iDisparity + iAddX ) >> iShiftX ) );
1022	Int iBasePosY = Clip3( 0, pcBasePdm->getHeight() - 1, iCurrPosY );
1023	Int iBaseCUAddr;
1024	Int iBaseAbsPartIdx;
1025	pcBaseRec->getCUAddrAndPartIdx( iBasePosX << m_uiSubSampExpX, iBasePosY << m_uiSubSampExpY, iBaseCUAddr, iBaseAbsPartIdx );
1026	TComDataCU* pcBaseCU = pcBasePic->getCU( iBaseCUAddr );
1027	if( pcBaseCU->getPredictionMode( iBaseAbsPartIdx ) != MODE_INTER && pcBaseCU->getPredictionMode( iBaseAbsPartIdx ) != MODE_SKIP )
1028	{
1029	continue;
1030	}
1031
1032	for( UInt uiBaseRefListId = 0; uiBaseRefListId < 2; uiBaseRefListId++ )
1033	{
1034	RefPicList eBaseRefPicList = RefPicList( uiBaseRefListId );
1035	TComMvField cBaseMvField;
1036	pcBaseCU->getMvField( pcBaseCU, iBaseAbsPartIdx, eBaseRefPicList, cBaseMvField );
1037	Int iBaseRefIdx = cBaseMvField.getRefIdx();
1038	Int iBaseRefPoc = ( iBaseRefIdx >= 0 ? pcBaseCU->getSlice()->getRefPic( eBaseRefPicList, iBaseRefIdx )->getPOC() : -(1<<30) );
1039	if( iBaseRefIdx >= 0 && iBaseRefPoc == iRefPoc )
1040	{
1041	rcMv.set( cBaseMvField.getHor(), cBaseMvField.getVer() );
1042	return true;
1043	}
1044	}
1045	}
1046	return false;
1047	}
1048	#endif
1049
1050
1051	Bool // first version
1052	TComDepthMapGenerator::getIViewOrgDepthMvPred( TComDataCU* pcCU, UInt uiPartIdx, RefPicList eRefPicList, Int iRefIdx, TComMv& rcMv )
1053	{
1054	AOF ( m_bCreated && m_bInit );
1055	AOF ( iRefIdx >= 0 );
1056	AOF ( pcCU );
1057
1058	TComSlice* pcSlice = pcCU->getSlice ();
1059	TComPic* pcPic = pcCU->getPic ();
1060	TComSPS* pcSPS = pcSlice->getSPS();
1061	AOF ( pcSPS->getViewId() == m_uiCurrViewId );
1062	ROFRS( pcPic->getOrgDepthMap(), false );
1063
1064	TComPic* pcRefPic = pcSlice->getRefPic( eRefPicList, iRefIdx );
1065	UInt uiRefViewId = pcRefPic->getSPS()->getViewId();
1066	Int iRefPoc = pcRefPic->getPOC();
1067	ROFRS( uiRefViewId < m_uiCurrViewId, false );
1068	AOF ( iRefPoc == pcSlice->getPOC() );
1069
1070	//===== get predicted depth for middle position of current PU (first version) =====
1071	UInt uiPartAddr;
1072	Int iWidth;
1073	Int iHeight;
1074	pcCU->getPartIndexAndSize( uiPartIdx, uiPartAddr, iWidth, iHeight );
1075	TComPicYuv* pcOrgDepthMap = pcPic->getOrgDepthMap();
1076	Pel* piOrgDepthMap = pcOrgDepthMap->getLumaAddr ( 0 );
1077	Int iCurrStride = pcOrgDepthMap->getStride ();
1078	Int iCurrPosX;
1079	Int iCurrPosY;
1080	pcOrgDepthMap->getTopLeftSamplePos( pcCU->getAddr(), pcCU->getZorderIdxInCU() + uiPartAddr, iCurrPosX, iCurrPosY );
1081	iCurrPosX += ( iWidth - 1 ) >> 1;
1082	iCurrPosY += ( iHeight - 1 ) >> 1;
1083	Int iPrdDepth = piOrgDepthMap[ iCurrPosX + iCurrPosY * iCurrStride ];
1084
1085	//===== get disparity vector =====
1086	Int iDisparity = xGetDisparityFromVirtDepth( uiRefViewId, iPrdDepth );
1087	rcMv.set ( iDisparity, 0 );
1088	return true;
1089	}
1090	#endif
1091
1092
1093
1094
1095
1096	#if !QC_MULTI_DIS_CAN_A0097
1097	/=======================================================
1098	===== =====
1099	===== p i c t u r e o p e r a t i o n s =====
1100	===== =====
1101	=======================================================/
1102
1103	Bool
1104	TComDepthMapGenerator::xConvertDepthMapCurr2Ref( TComPic* pcRef, TComPic* pcCur )
1105	{
1106	AOF( pcCur->getSPS()->getViewId() == m_uiCurrViewId );
1107	AOF( pcCur->getSPS()->getViewId() > pcRef->getSPS()->getViewId() );
1108	AOF( pcCur->getPredDepthMap() );
1109	AOF( pcRef->getPredDepthMap() );
1110	AOF( pcRef->getPredDepthMap()->getWidth () == pcCur->getPredDepthMap()->getWidth () );
1111	AOF( pcRef->getPredDepthMap()->getHeight() == pcCur->getPredDepthMap()->getHeight() );
1112	#if PDM_REMOVE_DEPENDENCE
1113	if( pcCur->getViewId() == 1)
1114	xClearDepthMap( pcRef );
1115	else if (pcCur->getViewId() == 2)
1116	xClearDepthMap( pcRef, PDM_UNDEFINED_DEPTH, 1 );
1117	#else
1118	xClearDepthMap( pcRef );
1119	#endif
1120	TComPicYuv* pcCurDepthMap = pcCur->getPredDepthMap ();
1121	TComPicYuv* pcRefDepthMap = pcRef->getPredDepthMap ();
1122	Int iWidth = pcCurDepthMap->getWidth ();
1123	Int iHeight = pcCurDepthMap->getHeight ();
1124	Int iCurStride = pcCurDepthMap->getStride ();
1125	Int iRefStride = pcRefDepthMap->getStride ();
1126	Pel* pCurSamples = pcCurDepthMap->getLumaAddr( 0 );
1127	Pel* pRefSamples = pcRefDepthMap->getLumaAddr( 0 );
1128	Int iRefViewIdx = pcRef->getViewId();
1129	#if PDM_REMOVE_DEPENDENCE
1130	if( pcCur->getViewId() == 2)
1131	{
1132	pcRefDepthMap = pcRef->getPredDepthMapTemp();
1133	pRefSamples = pcRefDepthMap->getLumaAddr( 0 );
1134	}
1135	#endif
1136	Int iShiftX = m_uiSubSampExpX + 2;
1137	Int iAddX = ( 1 << iShiftX ) >> 1;
1138	for( Int iY = 0; iY < iHeight; iY++, pCurSamples += iCurStride, pRefSamples += iRefStride )
1139	{
1140	for( Int iXCur = 0; iXCur < iWidth; iXCur++ )
1141	{
1142	Int iDepth = pCurSamples[ iXCur ];
1143	Int iDisp = xGetDisparityFromVirtDepth( iRefViewIdx, iDepth );
1144	Int iXRef = iXCur + ( ( iDisp + iAddX ) >> iShiftX );
1145	if( iXRef >= 0 && iXRef < iWidth && iDepth > pRefSamples[ iXRef ] )
1146	{
1147	pRefSamples[ iXRef ] = iDepth;
1148	}
1149	}
1150	}
1151	Bool bUndefined = xFillDepthMapHoles( pcRef );
1152	pcRefDepthMap->setBorderExtension( false );
1153	pcRefDepthMap->extendPicBorder ();
1154	return bUndefined;
1155	}
1156
1157
1158	Bool
1159	TComDepthMapGenerator::xConvertDepthMapRef2Curr( TComPic* pcCur, TComPic* pcRef )
1160	{
1161	AOF( pcCur->getSPS()->getViewId() == m_uiCurrViewId );
1162	AOF( pcCur->getSPS()->getViewId() > pcRef->getSPS()->getViewId() );
1163	AOF( pcCur->getPredDepthMap() );
1164	#if PDM_REMOVE_DEPENDENCE
1165	if(pcCur->getViewId() == 1)
1166	{
1167	AOF( pcRef->getPredDepthMap() );
1168	}else
1169	{
1170	AOF( pcRef->getPredDepthMapTemp() );
1171	}
1172	#else
1173	AOF( pcRef->getPredDepthMap() );
1174	#endif
1175	AOF( pcRef->getPredDepthMap()->getWidth () == pcCur->getPredDepthMap()->getWidth () );
1176	AOF( pcRef->getPredDepthMap()->getHeight() == pcCur->getPredDepthMap()->getHeight() );
1177
1178	xClearDepthMap( pcCur );
1179	TComPicYuv* pcRefDepthMap = pcRef->getPredDepthMap ();
1180	#if PDM_REMOVE_DEPENDENCE
1181	if(pcCur->getViewId() == 2)
1182	pcRefDepthMap = pcRef->getPredDepthMapTemp ();
1183	#endif
1184	TComPicYuv* pcCurDepthMap = pcCur->getPredDepthMap ();
1185	Int iWidth = pcRefDepthMap->getWidth ();
1186	Int iHeight = pcRefDepthMap->getHeight ();
1187	Int iRefStride = pcRefDepthMap->getStride ();
1188	Int iCurStride = pcCurDepthMap->getStride ();
1189	Pel* pRefSamples = pcRefDepthMap->getLumaAddr( 0 );
1190	Pel* pCurSamples = pcCurDepthMap->getLumaAddr( 0 );
1191	Int iRefViewIdx = pcRef->getViewId();
1192	Int iShiftX = m_uiSubSampExpX + 2;
1193	Int iAddX = ( 1 << iShiftX ) >> 1;
1194	for( Int iY = 0; iY < iHeight; iY++, pRefSamples += iRefStride, pCurSamples += iCurStride )
1195	{
1196	for( Int iXRef = 0; iXRef < iWidth; iXRef++ )
1197	{
1198	Int iDepth = pRefSamples[ iXRef ];
1199	Int iDisp = xGetDisparityFromVirtDepth( iRefViewIdx, iDepth );
1200	Int iXCur = iXRef - ( ( iDisp + iAddX ) >> iShiftX );
1201	if( iXCur >= 0 && iXCur < iWidth && iDepth > pCurSamples[ iXCur ] )
1202	{
1203	pCurSamples[ iXCur ] = iDepth;
1204	}
1205	}
1206	}
1207	Bool bUndefined = xFillDepthMapHoles( pcCur );
1208	pcCurDepthMap->setBorderExtension( false );
1209	pcCurDepthMap->extendPicBorder ();
1210	return bUndefined;
1211	}
1212
1213
1214	Bool
1215	TComDepthMapGenerator::xPredictDepthMap( TComPic* pcPic )
1216	{
1217	for( UInt uiCUAddr = 0; uiCUAddr < pcPic->getPicSym()->getNumberOfCUsInFrame(); uiCUAddr++ )
1218	{
1219	TComDataCU* pcCU = pcPic->getCU( uiCUAddr );
1220	xPredictCUDepthMap( pcCU, 0, 0 );
1221	}
1222	Bool bUndefined = xFillDepthMapHoles( pcPic );
1223	#if PDM_REMOVE_DEPENDENCE
1224	if(pcPic->getStoredPDMforV2() == 1){
1225	pcPic->getPredDepthMapTemp()->setBorderExtension( false );
1226	pcPic->getPredDepthMapTemp()->extendPicBorder ();
1227	}else{
1228	#endif
1229	pcPic->getPredDepthMap()->setBorderExtension( false );
1230	pcPic->getPredDepthMap()->extendPicBorder ();
1231	#if PDM_REMOVE_DEPENDENCE
1232	}
1233	#endif
1234	return bUndefined;
1235	}
1236
1237
1238	Bool
1239	TComDepthMapGenerator::xFillDepthMapHoles( TComPic* pcPic )
1240	{
1241	Bool bUndefined = false;
1242	TComPicYuv* pcDepthMap = pcPic->getPredDepthMap ();
1243	#if PDM_REMOVE_DEPENDENCE
1244	if(pcPic->getViewId()==0 && pcPic->getStoredPDMforV2()==1)
1245	pcDepthMap = pcPic->getPredDepthMapTemp ();
1246	#endif
1247	Int iWidth = pcDepthMap->getWidth ();
1248	Int iHeight = pcDepthMap->getHeight ();
1249	Int iStride = pcDepthMap->getStride ();
1250	Pel* pDMSamples = pcDepthMap->getLumaAddr ( 0 );
1251	// horizontal
1252	for( Int iY = 0; iY < iHeight && !bUndefined; iY++, pDMSamples += iStride )
1253	{
1254	for( Int iX = 0; iX < iWidth; iX++ )
1255	{
1256	if( pDMSamples[ iX ] == PDM_UNDEFINED_DEPTH )
1257	{
1258	Int iE;
1259	for( iE = iX + 1; iE < iWidth; iE++ )
1260	{
1261	if( pDMSamples[ iE ] != PDM_UNDEFINED_DEPTH )
1262	{
1263	break;
1264	}
1265	}
1266	if( iX > 0 \|\| iE < iWidth )
1267	{
1268	Int iDepth;
1269	if ( iX > 0 && iE < iWidth ) iDepth = ( pDMSamples[ iX-1 ] < pDMSamples[ iE ] ? pDMSamples[ iX-1 ] : pDMSamples[ iE ] );
1270	else if( iX > 0 ) iDepth = pDMSamples[ iX-1 ];
1271	else /( iE < iWidth )/ iDepth = pDMSamples[ iE ];
1272	for( Int iZ = iX; iZ < iE; iZ++ )
1273	{
1274	pDMSamples[ iZ ] = iDepth;
1275	}
1276	}
1277	else
1278	{
1279	bUndefined = true;
1280	break;
1281	}
1282	iX = iE - 1;
1283	}
1284	}
1285	}
1286
1287	if( bUndefined && m_uiCurrViewId )
1288	{
1289	pDMSamples = pcDepthMap->getLumaAddr( 0 );
1290	Int iMiddleOrgDpth = ( 1 << m_uiOrgDepthBitDepth ) >> 1;
1291	Int iMiddleDepth = xGetVirtDepthFromOrigDepth( m_uiCurrViewId, iMiddleOrgDpth );
1292	for( Int iY = 0; iY < iHeight; iY++, pDMSamples += iStride )
1293	{
1294	for( Int iX = 0; iX < iWidth; iX++ )
1295	{
1296	pDMSamples[ iX ] = iMiddleDepth;
1297	}
1298	}
1299	}
1300	return bUndefined;
1301	}
1302
1303
1304	Void
1305	TComDepthMapGenerator::xClearDepthMap( TComPic* pcPic, Int iVal
1306	#if PDM_REMOVE_DEPENDENCE
1307	,
1308	Int forFirstNonBaseView
1309	#endif
1310	)
1311	{
1312	TComPicYuv* pcDepthMap = pcPic->getPredDepthMap ();
1313	Int iWidth = pcDepthMap->getWidth ();
1314	Int iHeight = pcDepthMap->getHeight ();
1315	Int iStride = pcDepthMap->getStride ();
1316	Pel* pDMSamples = pcDepthMap->getLumaAddr ( 0 );
1317	#if PDM_REMOVE_DEPENDENCE
1318	if( forFirstNonBaseView == 1)
1319	{
1320	pcDepthMap = pcPic->getPredDepthMapTemp ();
1321	pDMSamples = pcDepthMap->getLumaAddr ( 0 );
1322	}
1323	#endif
1324	for( Int iY = 0; iY < iHeight; iY++, pDMSamples += iStride )
1325	{
1326	for( Int iX = 0; iX < iWidth; iX++ )
1327	{
1328	pDMSamples[ iX ] = iVal;
1329	}
1330	}
1331	pcDepthMap->setBorderExtension( false );
1332	pcDepthMap->extendPicBorder ();
1333	}
1334
1335	Void
1336	TComDepthMapGenerator::xSetChroma( TComPicYuv* pcPic, Int iVal )
1337	{
1338	Int iWidth = pcPic->getWidth () >> 1;
1339	Int iHeight = pcPic->getHeight () >> 1;
1340	Int iStride = pcPic->getCStride ();
1341	Pel* pCbSamples = pcPic->getCbAddr ( 0 );
1342	Pel* pCrSamples = pcPic->getCrAddr ( 0 );
1343	for( Int iY = 0; iY < iHeight; iY++, pCbSamples += iStride, pCrSamples += iStride )
1344	{
1345	for( Int iX = 0; iX < iWidth; iX++ )
1346	{
1347	pCbSamples[ iX ] = pCrSamples[ iX ] = iVal;
1348	}
1349	}
1350	}
1351
1352
1353
1354
1355
1356
1357
1358	/===============================================
1359	===== =====
1360	===== C U p r e d i c t i o n s =====
1361	===== =====
1362	===============================================/
1363
1364	Void
1365	TComDepthMapGenerator::xPredictCUDepthMap( TComDataCU* pcCU, UInt uiDepth, UInt uiAbsPartIdx )
1366	{
1367	UInt uiLPelX = pcCU->getCUPelX() + g_auiRasterToPelX[ g_auiZscanToRaster[ uiAbsPartIdx ] ];
1368	UInt uiTPelY = pcCU->getCUPelY() + g_auiRasterToPelY[ g_auiZscanToRaster[ uiAbsPartIdx ] ];
1369	UInt uiRPelX = uiLPelX + ( g_uiMaxCUWidth >> uiDepth ) - 1;
1370	UInt uiBPelY = uiTPelY + ( g_uiMaxCUHeight >> uiDepth ) - 1;
1371	Bool bBoundary = ( uiRPelX >= pcCU->getSlice()->getSPS()->getPicWidthInLumaSamples() \|\| uiBPelY >= pcCU->getSlice()->getSPS()->getPicHeightInLumaSamples() );
1372	Bool bSplit = ( ( uiDepth < pcCU->getDepth( uiAbsPartIdx ) && uiDepth < ( g_uiMaxCUDepth - g_uiAddCUDepth ) ) \|\| bBoundary );
1373	if( bSplit )
1374	{
1375	UInt uiQNumParts = ( pcCU->getPic()->getNumPartInCU() >> ( uiDepth << 1 ) ) >> 2;
1376	for ( UInt uiPartUnitIdx = 0; uiPartUnitIdx < 4; uiPartUnitIdx++, uiAbsPartIdx += uiQNumParts )
1377	{
1378	uiLPelX = pcCU->getCUPelX() + g_auiRasterToPelX[ g_auiZscanToRaster[ uiAbsPartIdx ] ];
1379	uiTPelY = pcCU->getCUPelY() + g_auiRasterToPelY[ g_auiZscanToRaster[ uiAbsPartIdx ] ];
1380	Bool bInside = ( uiLPelX < pcCU->getSlice()->getSPS()->getPicWidthInLumaSamples() && uiTPelY < pcCU->getSlice()->getSPS()->getPicHeightInLumaSamples() );
1381	if( bInside )
1382	{
1383	xPredictCUDepthMap( pcCU, uiDepth + 1, uiAbsPartIdx );
1384	}
1385	}
1386	return;
1387	}
1388
1389	//--- set sub-CU and sub-depth-map ---
1390	TComDataCU* pcSubCU = m_ppcCU [ uiDepth ];
1391	TComYuv* pcSubDM = m_ppcYuv[ uiDepth ];
1392	TComPicYuv* pcPicDM = pcCU->getPic()->getPredDepthMap();
1393	#if PDM_REMOVE_DEPENDENCE
1394	if( pcCU->getPic()->getStoredPDMforV2() == 1)
1395	pcPicDM = pcCU->getPic()->getPredDepthMapTemp();
1396	#endif
1397	UInt uiCUAddr = pcCU->getAddr();
1398	pcSubCU->copySubCU( pcCU, uiAbsPartIdx, uiDepth );
1399
1400	//--- update depth map ---
1401	switch( pcSubCU->getPredictionMode( 0 ) )
1402	{
1403	case MODE_INTRA:
1404	xIntraPredictCUDepthMap( pcSubCU, pcSubDM );
1405	break;
1406	case MODE_SKIP:
1407	case MODE_INTER:
1408	xInterPredictCUDepthMap( pcSubCU, pcSubDM );
1409	break;
1410	#if FORCE_REF_VSP==1
1411	case MODE_SYNTH:
1412	xIntraPredictCUDepthMap( pcSubCU, pcSubDM ); //What to do? Need Fix!
1413	break;
1414	#endif
1415	default:
1416	AOT( true );
1417	break;
1418	}
1419
1420	//--- copy sub-depth-map ---
1421	pcSubDM->copyToPicYuv( pcPicDM, uiCUAddr, uiAbsPartIdx );
1422	}
1423
1424
1425	Void
1426	TComDepthMapGenerator::xIntraPredictCUDepthMap( TComDataCU* pcCU, TComYuv* pcCUDepthMap )
1427	{
1428	UInt uiInitTrDepth = ( pcCU->getPartitionSize( 0 ) == SIZE_2Nx2N ? 0 : 1 );
1429	UInt uiNumPart = pcCU->getNumPartInter ();
1430	UInt uiNumQParts = pcCU->getTotalNumPart () >> 2;
1431	for( UInt uiPU = 0; uiPU < uiNumPart; uiPU++ )
1432	{
1433	xIntraPredictBlkDepthMap( pcCU, pcCUDepthMap, uiPU * uiNumQParts, uiInitTrDepth );
1434	}
1435	}
1436
1437
1438	Void
1439	TComDepthMapGenerator::xInterPredictCUDepthMap( TComDataCU* pcCU, TComYuv* pcCUDepthMap )
1440	{
1441	for( UInt uiPartIdx = 0; uiPartIdx < pcCU->getNumPartInter(); uiPartIdx++ )
1442	{
1443	xInterPredictPUDepthMap( pcCU, pcCUDepthMap, uiPartIdx );
1444	}
1445	}
1446
1447
1448
1449
1450
1451
1452
1453	/=====================================================================
1454	===== =====
1455	===== P U - a n d B l o c k p r e d i c t i o n s =====
1456	===== =====
1457	=====================================================================/
1458
1459	Void
1460	TComDepthMapGenerator::xIntraPredictBlkDepthMap( TComDataCU* pcCU, TComYuv* pcCUDepthMap, UInt uiAbsPartIdx, UInt uiTrDepth )
1461	{
1462	UInt uiFullDepth = pcCU->getDepth( 0 ) + uiTrDepth;
1463	UInt uiTrMode = pcCU->getTransformIdx( uiAbsPartIdx );
1464	if( uiTrMode == uiTrDepth )
1465	{
1466	UInt uiWidth = pcCU->getWidth ( 0 ) >> ( uiTrDepth + m_uiSubSampExpX );
1467	UInt uiHeight = pcCU->getHeight( 0 ) >> ( uiTrDepth + m_uiSubSampExpY );
1468	UInt uiStride = pcCUDepthMap->getStride ();
1469	UInt uiBlkX = g_auiRasterToPelX[ g_auiZscanToRaster[ uiAbsPartIdx ] ] >> m_uiSubSampExpX;
1470	UInt uiBlkY = g_auiRasterToPelY[ g_auiZscanToRaster[ uiAbsPartIdx ] ] >> m_uiSubSampExpY;
1471	Pel* pDepthMap = pcCUDepthMap->getLumaAddr() + uiBlkY * pcCUDepthMap->getStride() + uiBlkX;
1472	UInt uiLumaPredMode = pcCU->getLumaIntraDir ( uiAbsPartIdx );
1473	Bool bAboveAvail = false;
1474	Bool bLeftAvail = false;
1475	pcCU->getPattern()->initPattern ( pcCU, uiTrDepth, uiAbsPartIdx, true );
1476	pcCU->getPattern()->initAdiPattern( pcCU, uiAbsPartIdx, uiTrDepth,
1477	m_pcPrediction->getPredicBuf (),
1478	m_pcPrediction->getPredicBufWidth (),
1479	m_pcPrediction->getPredicBufHeight (),
1480	bAboveAvail, bLeftAvail, false, true, m_uiSubSampExpX, m_uiSubSampExpY );
1481	m_pcPrediction->predIntraDepthAng ( pcCU->getPattern(), uiLumaPredMode, pDepthMap, uiStride, uiWidth, uiHeight ); // could be replaced with directional intra prediction
1482	// using "predIntraLumaAng", but note:
1483	// - need to take care of neighbours with undefined depth
1484	// - special case for wedgelet mode (if available in normal views)
1485	// copy to picture array (for next intra prediction block)
1486	UInt uiZOrderIdx = pcCU->getZorderIdxInCU() + uiAbsPartIdx;
1487	Pel* pPicDepthMap = pcCU->getPic()->getPredDepthMap()->getLumaAddr( pcCU->getAddr(), uiZOrderIdx );
1488	#if PDM_REMOVE_DEPENDENCE
1489	if(pcCU->getPic()->getStoredPDMforV2()==1)
1490	pPicDepthMap = pcCU->getPic()->getPredDepthMapTemp()->getLumaAddr( pcCU->getAddr(), uiZOrderIdx );
1491	#endif
1492	Int iPicStride = pcCU->getPic()->getPredDepthMap()->getStride ();
1493	for( UInt uiY = 0; uiY < uiHeight; uiY++, pDepthMap += uiStride, pPicDepthMap += iPicStride )
1494	{
1495	for( UInt uiX = 0; uiX < uiWidth; uiX++ )
1496	{
1497	pPicDepthMap[ uiX ] = pDepthMap[ uiX ];
1498	}
1499	}
1500	}
1501	else
1502	{
1503	UInt uiNumQPart = pcCU->getPic()->getNumPartInCU() >> ( ( uiFullDepth + 1 ) << 1 );
1504	for( UInt uiPart = 0; uiPart < 4; uiPart++ )
1505	{
1506	xIntraPredictBlkDepthMap( pcCU, pcCUDepthMap, uiAbsPartIdx + uiPart * uiNumQPart, uiTrDepth + 1 );
1507	}
1508	}
1509	}
1510
1511
1512	Void
1513	TComDepthMapGenerator::xInterPredictPUDepthMap( TComDataCU* pcCU, TComYuv* pcCUDepthMap, UInt uiPartIdx )
1514	{
1515	if ( pcCU->getSlice()->getSPS()->getViewId() )
1516	{
1517	AOF( m_uiCurrViewId == pcCU->getSlice()->getSPS()->getViewId() );
1518	// check for interview prediction
1519	Int iWidth;
1520	Int iHeight;
1521	UInt uiAbsPartIdx;
1522	pcCU->getPartIndexAndSize( uiPartIdx, uiAbsPartIdx, iWidth, iHeight );
1523	TComCUMvField* aiCurrMvField[2] = { pcCU->getCUMvField( REF_PIC_LIST_0 ), pcCU->getCUMvField( REF_PIC_LIST_1 ) };
1524	Int aiCurrRefIdx [2] = { aiCurrMvField[0]->getRefIdx( uiAbsPartIdx ), aiCurrMvField[1]->getRefIdx( uiAbsPartIdx ) };
1525	Bool abCurrIntView[2] = { aiCurrRefIdx[0] >= 0 && pcCU->getSlice()->getRefPic( REF_PIC_LIST_0, aiCurrRefIdx[0] )->getSPS()->getViewId() != m_uiCurrViewId,
1526	aiCurrRefIdx[1] >= 0 && pcCU->getSlice()->getRefPic( REF_PIC_LIST_1, aiCurrRefIdx[1] )->getSPS()->getViewId() != m_uiCurrViewId };
1527	Bool bUsesInterViewPrd = ( abCurrIntView[0] \|\| abCurrIntView[1] );
1528	#if VSP_N
1529	if(( aiCurrRefIdx[0] >= 0 && pcCU->isVspRef( REF_PIC_LIST_0, aiCurrRefIdx[0] ) ) \|\|
1530	( aiCurrRefIdx[1] >= 0 && pcCU->isVspRef( REF_PIC_LIST_1, aiCurrRefIdx[1] ) )) {
1531	//if refpic is VSP, copy to Original cuurent PDM
1532	TComPicYuv* pcPdm = pcCU->getPic()->getPredDepthMap();
1533	UInt uiZOrderIdx = pcCU->getZorderIdxInCU() + uiAbsPartIdx;
1534	assert( pcPdm );
1535	pcCUDepthMap->copyFromPicYuv( pcPdm, pcCU->getAddr(), uiZOrderIdx );
1536	}
1537	#endif
1538	if( bUsesInterViewPrd )
1539	{
1540	xIViewPUDepthMapUpdate ( pcCU, pcCUDepthMap, uiPartIdx );
1541	}
1542	else
1543	{
1544	#if PDM_NO_INTER_UPDATE
1545	xInterPUDepthMapPrediction( pcCU, pcCUDepthMap, uiPartIdx );
1546	#else
1547	xInterPUDepthMapUpdate ( pcCU, pcCUDepthMap, uiPartIdx );
1548	#endif
1549	}
1550	}
1551	else
1552	{
1553	xInterPUDepthMapPrediction( pcCU, pcCUDepthMap, uiPartIdx );
1554	}
1555	}
1556
1557
1558	Void
1559	TComDepthMapGenerator::xIViewPUDepthMapUpdate( TComDataCU* pcCU, TComYuv* pcCUDepthMap, UInt uiPartIdx )
1560	{
1561	// get width, height, and part address
1562	Int iWidth;
1563	Int iHeight;
1564	UInt uiAbsPartIdx;
1565	pcCU->getPartIndexAndSize( uiPartIdx, uiAbsPartIdx, iWidth, iHeight );
1566	iWidth >>= m_uiSubSampExpX;
1567	iHeight >>= m_uiSubSampExpY;
1568
1569	// get depth values
1570	Int iDepthValue = PDM_UNDEFINED_DEPTH;
1571	Int aiPrdDepth[2] = { PDM_UNDEFINED_DEPTH, PDM_UNDEFINED_DEPTH };
1572	for( Int iRefListId = 0; iRefListId < 2; iRefListId++ )
1573	{
1574	RefPicList eRefPicList = RefPicList( iRefListId );
1575	TComCUMvField* pcCUMvField = pcCU->getCUMvField( eRefPicList );
1576	Int iRefIdx = pcCUMvField->getRefIdx( uiAbsPartIdx );
1577	UInt uiBaseId = ( iRefIdx >= 0 ? pcCU->getSlice()->getRefPic( eRefPicList, iRefIdx )->getSPS()->getViewId() : MAX_VIEW_NUM );
1578	Bool bInterview = ( iRefIdx >= 0 && uiBaseId < m_uiCurrViewId );
1579	if( bInterview )
1580	{
1581	Int iMvX = pcCUMvField->getMv( uiAbsPartIdx ).getHor();
1582	aiPrdDepth[ iRefListId ] = xGetVirtDepthFromDisparity( uiBaseId, iMvX );
1583	}
1584	}
1585	if( aiPrdDepth[ 0 ] != PDM_UNDEFINED_DEPTH && aiPrdDepth[ 1 ] != PDM_UNDEFINED_DEPTH )
1586	{
1587	iDepthValue = ( aiPrdDepth[ 0 ] + aiPrdDepth[ 1 ] + 1 ) >> 1;
1588	}
1589	else
1590	{
1591	iDepthValue = ( aiPrdDepth[ 0 ] != PDM_UNDEFINED_DEPTH ? aiPrdDepth[ 0 ] : aiPrdDepth[ 1 ] );
1592	AOT( iDepthValue == PDM_UNDEFINED_DEPTH );
1593	}
1594	iDepthValue = Max( 0, Min( PDM_MAX_ABS_VIRT_DEPTH, iDepthValue ) );
1595
1596	// set depth map for PU
1597	UInt uiBlkX = g_auiRasterToPelX[ g_auiZscanToRaster[ uiAbsPartIdx ] ] >> m_uiSubSampExpX;
1598	UInt uiBlkY = g_auiRasterToPelY[ g_auiZscanToRaster[ uiAbsPartIdx ] ] >> m_uiSubSampExpY;
1599	Pel* pDMSamples = pcCUDepthMap->getLumaAddr() + uiBlkY * pcCUDepthMap->getStride() + uiBlkX;
1600	Int iStride = pcCUDepthMap->getStride ();
1601	for( Int iY = 0; iY < iHeight; iY++, pDMSamples += iStride )
1602	{
1603	for( Int iX = 0; iX < iWidth; iX++)
1604	{
1605	pDMSamples[ iX ] = (Pel)iDepthValue;
1606	}
1607	}
1608	}
1609
1610
1611	Void
1612	TComDepthMapGenerator::xInterPUDepthMapUpdate( TComDataCU* pcCU, TComYuv* pcCUDepthMap, UInt uiPartIdx )
1613	{
1614	const Int iMaxAbsDeltaMvY = 8 << 2;
1615
1616	//===== determine block parameters for current access unit and current view =====
1617	Int iWidth;
1618	Int iHeight;
1619	UInt uiAbsPartIdx;
1620	pcCU->getPartIndexAndSize ( uiPartIdx, uiAbsPartIdx, iWidth, iHeight );
1621	UInt uiCurrViewId = pcCU->getSlice()->getSPS()->getViewId();
1622	Int iNum4x4BlksY = iHeight >> 2;
1623	Int iNum4x4BlksX = iWidth >> 2;
1624	iWidth >>= m_uiSubSampExpX;
1625	iHeight >>= m_uiSubSampExpY;
1626
1627	TComPicYuv* pcCurrDepthMap = pcCU->getPic()->getPredDepthMap();
1628	Pel* piCurrDepthMap = pcCurrDepthMap->getLumaAddr();
1629	Int iCurrStride = pcCurrDepthMap->getStride();
1630	TComCUMvField* aiCurrMvField[2] = { pcCU->getCUMvField( REF_PIC_LIST_0 ), pcCU->getCUMvField( REF_PIC_LIST_1 ) };
1631	Int aiCurrRefIdx [2] = { aiCurrMvField[0]->getRefIdx( uiAbsPartIdx ), aiCurrMvField[1]->getRefIdx( uiAbsPartIdx ) };
1632	Int iMinCurrListId = ( aiCurrRefIdx [0] < 0 ? 1 : 0 );
1633	Int iMaxCurrListId = ( aiCurrRefIdx [1] < 0 ? 0 : 1 );
1634	Int iCurrPUPosX;
1635	Int iCurrPUPosY;
1636	pcCurrDepthMap->getTopLeftSamplePos( pcCU->getAddr(), pcCU->getZorderIdxInCU() + uiAbsPartIdx, iCurrPUPosX, iCurrPUPosY );
1637	AOT( uiCurrViewId != m_uiCurrViewId );
1638	AOT( iMinCurrListId > iMaxCurrListId );
1639	AOT( aiCurrRefIdx[0] >= 0 && pcCU->getSlice()->getRefPic( REF_PIC_LIST_0, aiCurrRefIdx[0] )->getSPS()->getViewId() != uiCurrViewId );
1640	AOT( aiCurrRefIdx[1] >= 0 && pcCU->getSlice()->getRefPic( REF_PIC_LIST_1, aiCurrRefIdx[1] )->getSPS()->getViewId() != uiCurrViewId );
1641
1642	//===== determine parameters for current access unit and base view =====
1643	AOF( m_auiBaseIdList.size() );
1644	UInt uiBaseId = m_auiBaseIdList[ 0 ];
1645	TComPic* pcBasePic = m_pcAUPicAccess->getPic( uiBaseId );
1646	AOF( pcBasePic );
1647	TComPicYuv* pcBaseDepthMap = pcBasePic->getPredDepthMap();
1648	TComPicYuv* pcBaseRecPic = pcBasePic->getPicYuvRec ();
1649	Pel* piBaseDepthMap = pcBaseDepthMap->getLumaAddr();
1650	Int iBaseStride = pcBaseDepthMap->getStride();
1651	Int iShiftX = m_uiSubSampExpX + 2;
1652	Int iShiftY = m_uiSubSampExpY + 2;
1653	Int iAddX = ( 1 << iShiftX ) >> 1;
1654	Int iAddY = ( 1 << iShiftY ) >> 1;
1655
1656	//===== initialize 4x4 block arrays =====
1657	for( Int i4x4BlkY = 0; i4x4BlkY < iNum4x4BlksY; i4x4BlkY++ )
1658	{
1659	for( Int i4x4BlkX = 0; i4x4BlkX < iNum4x4BlksX; i4x4BlkX++ )
1660	{
1661	m_aabDepthSet[ i4x4BlkY ][ i4x4BlkX ] = false;
1662	m_aai4x4Depth[ i4x4BlkY ][ i4x4BlkX ] = PDM_UNDEFINED_DEPTH;
1663	}
1664	}
1665	Int iNum4x4Set = 0;
1666
1667	//===== determine depth based on 4x4 blocks =====
1668	for( Int i4x4BlkY = 0; i4x4BlkY < iNum4x4BlksY; i4x4BlkY++ )
1669	{
1670	for( Int i4x4BlkX = 0; i4x4BlkX < iNum4x4BlksX; i4x4BlkX++ )
1671	{
1672	// position parameters
1673	Int iCurrBlkPosX = iCurrPUPosX + ( ( i4x4BlkX << 2 ) >> m_uiSubSampExpX );
1674	Int iCurrBlkPosY = iCurrPUPosY + ( ( i4x4BlkY << 2 ) >> m_uiSubSampExpY );
1675	Int iCurrSamplePosX = iCurrBlkPosX + ( 1 >> m_uiSubSampExpX );
1676	Int iCurrSamplePosY = iCurrBlkPosY + ( 1 >> m_uiSubSampExpY );
1677	Int iCurrPredDepth = piCurrDepthMap[ iCurrSamplePosY * iCurrStride + iCurrSamplePosX ];
1678	Int iCurrPredDisp = xGetDisparityFromVirtDepth( uiBaseId, iCurrPredDepth );
1679	Int iBaseSamplePosX = iCurrSamplePosX + ( ( iCurrPredDisp + iAddX ) >> iShiftX );
1680	Int iBaseSamplePosY = iCurrSamplePosY;
1681	iBaseSamplePosX = Clip3( 0, pcBaseDepthMap->getWidth () - 1, iBaseSamplePosX );
1682	iBaseSamplePosY = Clip3( 0, pcBaseDepthMap->getHeight() - 1, iBaseSamplePosY );
1683
1684	// check for occlusion
1685	if( piBaseDepthMap[ iBaseSamplePosY * iBaseStride + iBaseSamplePosX ] != iCurrPredDepth )
1686	{
1687	continue;
1688	}
1689
1690	// determine base motion data and check prediction mode
1691	Int iBaseCUAddr;
1692	Int iBaseAbsPartIdx;
1693	pcBaseRecPic->getCUAddrAndPartIdx( iBaseSamplePosX << m_uiSubSampExpX, iBaseSamplePosY << m_uiSubSampExpY, iBaseCUAddr, iBaseAbsPartIdx );
1694	TComDataCU* pcBaseCU = pcBasePic->getCU( iBaseCUAddr );
1695	if( pcBaseCU->getPredictionMode( iBaseAbsPartIdx ) != MODE_INTER && pcBaseCU->getPredictionMode( iBaseAbsPartIdx ) != MODE_SKIP )
1696	{
1697	continue;
1698	}
1699
1700	// check whether base was inter-view predicted
1701	TComCUMvField* aiBaseMvField[2] = { pcBaseCU->getCUMvField( REF_PIC_LIST_0 ), pcBaseCU->getCUMvField( REF_PIC_LIST_1 ) };
1702	Int aiBaseRefIdx [2] = { aiBaseMvField[0]->getRefIdx( iBaseAbsPartIdx ), aiBaseMvField[1]->getRefIdx( iBaseAbsPartIdx ) };
1703	Bool abBaseIntView[2] = { aiBaseRefIdx[0] >= 0 && pcBaseCU->getSlice()->getRefPic( REF_PIC_LIST_0, aiBaseRefIdx[0] )->getSPS()->getViewId() != uiBaseId,
1704	aiBaseRefIdx[1] >= 0 && pcBaseCU->getSlice()->getRefPic( REF_PIC_LIST_1, aiBaseRefIdx[1] )->getSPS()->getViewId() != uiBaseId };
1705	if( abBaseIntView[0] \|\| abBaseIntView[1] )
1706	{ // current depth is reliable
1707	m_aai4x4Depth[i4x4BlkY][i4x4BlkX] = iCurrPredDepth;
1708	m_aabDepthSet[i4x4BlkY][i4x4BlkX] = true;
1709	iNum4x4Set++;
1710	continue;
1711	}
1712
1713	// determine depth candidates using an approximate 4-point relationship (if appropriate)
1714	std::vector<Int> aiDepthCand;
1715	Int iMinBaseListId = ( aiBaseRefIdx [0] < 0 ? 1 : 0 );
1716	Int iMaxBaseListId = ( aiBaseRefIdx [1] < 0 ? 0 : 1 );
1717	AOT( iMinBaseListId > iMaxBaseListId );
1718	for( Int iCurrRefListId = iMinCurrListId; iCurrRefListId <= iMaxCurrListId; iCurrRefListId++ )
1719	{
1720	RefPicList eCurrRefPicList = RefPicList( iCurrRefListId );
1721	Int iCurrRefPoc = pcCU->getSlice()->getRefPOC( eCurrRefPicList, aiCurrRefIdx[ iCurrRefListId ] );
1722	TComPic* pcCurrRefPic = pcCU->getSlice()->getRefPic( eCurrRefPicList, aiCurrRefIdx[ iCurrRefListId ] );
1723	TComPicYuv* pcCurrRefDMap = pcCurrRefPic->getPredDepthMap();
1724	Pel* piCurrRefDMap = pcCurrRefDMap->getLumaAddr();
1725	Int iCurrRefStride = pcCurrRefDMap->getStride();
1726	TComMv rcCurrMv = aiCurrMvField[ iCurrRefListId ]->getMv( uiAbsPartIdx );
1727	Int iCurrRefSamplePosX = iCurrSamplePosX + ( ( rcCurrMv.getHor() + iAddX ) >> iShiftX );
1728	Int iCurrRefSamplePosY = iCurrSamplePosY + ( ( rcCurrMv.getVer() + iAddY ) >> iShiftY );
1729	Int iCurrRefSamplePosXC = Clip3( 0, pcCurrRefDMap->getWidth () - 1, iCurrRefSamplePosX );
1730	Int iCurrRefSamplePosYC = Clip3( 0, pcCurrRefDMap->getHeight() - 1, iCurrRefSamplePosY );
1731	Int iCurrRefDepth = piCurrRefDMap[ iCurrRefSamplePosYC * iCurrRefStride + iCurrRefSamplePosXC ];
1732
1733	for( Int iBaseRefListId = iMinBaseListId; iBaseRefListId <= iMaxBaseListId; iBaseRefListId++ )
1734	{
1735	RefPicList eBaseRefPicList = RefPicList( iBaseRefListId );
1736	Int iBaseRefPoc = pcBaseCU->getSlice()->getRefPOC( eBaseRefPicList, aiBaseRefIdx[ iBaseRefListId ] );
1737
1738	if( iCurrRefPoc == iBaseRefPoc )
1739	{
1740	// location and depth for path currView/currAU -> currView/refAU -> baseView/refAU
1741	Int iCurrRefDisp = xGetDisparityFromVirtDepth( uiBaseId, iCurrRefDepth );
1742	Int iBaseRefSamplePosX = iCurrRefSamplePosX + ( ( iCurrRefDisp + iAddX ) >> iShiftX );
1743	Int iBaseRefSamplePosY = iCurrRefSamplePosY;
1744	TComPic* pcBaseRefPic = pcBaseCU->getSlice()->getRefPic( eBaseRefPicList, aiBaseRefIdx[ iBaseRefListId ] );
1745	TComPicYuv* pcBaseRefDMap = pcBaseRefPic->getPredDepthMap();
1746	Pel* piBaseRefDMap = pcBaseRefDMap->getLumaAddr();
1747	Int iBaseRefStride = pcBaseRefDMap->getStride();
1748	iBaseRefSamplePosX = Clip3( 0, pcBaseRefDMap->getWidth () - 1, iBaseRefSamplePosX );
1749	iBaseRefSamplePosY = Clip3( 0, pcBaseRefDMap->getHeight() - 1, iBaseRefSamplePosY );
1750	Int iBaseRefDepth = piBaseRefDMap[ iBaseRefSamplePosY * iBaseRefStride + iBaseRefSamplePosX ];
1751
1752	// location and depth for path currView/currAU ->baseView/currAU -> baseView/refAU
1753	TComMv rcBaseMv = aiBaseMvField[ iBaseRefListId ]->getMv( iBaseAbsPartIdx );
1754	Int iAbsDeltaMvY = ( rcBaseMv.getAbsVer() > rcCurrMv.getVer() ? rcBaseMv.getAbsVer() - rcCurrMv.getVer() : rcCurrMv.getVer() - rcBaseMv.getAbsVer() );
1755
1756	// check reliability (occlusion in reference access unit / vertical motion vector difference)
1757	if( iBaseRefDepth != iCurrRefDepth \|\| iAbsDeltaMvY > iMaxAbsDeltaMvY )
1758	{
1759	continue;
1760	}
1761
1762	// determine new depth
1763	Int iCurrCandDisp = iCurrRefDisp + rcCurrMv.getHor() - rcBaseMv.getHor();
1764	Int iCurrCandDepth = xGetVirtDepthFromDisparity( uiBaseId, iCurrCandDisp );
1765	aiDepthCand.push_back( iCurrCandDepth );
1766	} // iCurrRefPoc == iBaseRefPoc
1767	} // iBaseRefListId
1768	} // iCurrRefListId
1769
1770	// set depth for 4x4 block
1771	if( aiDepthCand.size() )
1772	{ // get depth with minimum change (probably most reliable)
1773	Int iMinAbsDepthChange = (1<<30);
1774	Int iDepthForMinChange = (1<<30);
1775	for( UInt uiCandId = 0; uiCandId < (UInt)aiDepthCand.size(); uiCandId++ )
1776	{
1777	Int iAbsDeltaDepth = ( aiDepthCand[uiCandId] > iCurrPredDepth ? aiDepthCand[uiCandId] > iCurrPredDepth : iCurrPredDepth - aiDepthCand[uiCandId] );
1778	if( iAbsDeltaDepth < iMinAbsDepthChange )
1779	{
1780	iMinAbsDepthChange = iAbsDeltaDepth;
1781	iDepthForMinChange = aiDepthCand[uiCandId];
1782	}
1783	}
1784	m_aai4x4Depth[i4x4BlkY][i4x4BlkX] = Min( Max( 0, iDepthForMinChange ), PDM_MAX_ABS_VIRT_DEPTH );
1785	m_aabDepthSet[i4x4BlkY][i4x4BlkX] = true;
1786	iNum4x4Set++;
1787	}
1788	} // i4x4BlkX
1789	} // i4x4BlkY
1790
1791	//===== fall back (take original depth for 4x4 blocks) ====
1792	if( iNum4x4Set < Max( 1, ( iNum4x4BlksY * iNum4x4BlksX ) >> 2 ) )
1793	{
1794	iNum4x4Set = 0;
1795	for( Int i4x4BlkY = 0; i4x4BlkY < iNum4x4BlksY; i4x4BlkY++ )
1796	{
1797	for( Int i4x4BlkX = 0; i4x4BlkX < iNum4x4BlksX; i4x4BlkX++ )
1798	{
1799	Int iCurrSamplePosX = iCurrPUPosX + ( ( ( i4x4BlkX << 2 ) + 1 ) >> m_uiSubSampExpX );
1800	Int iCurrSamplePosY = iCurrPUPosY + ( ( ( i4x4BlkY << 2 ) + 1 ) >> m_uiSubSampExpY );
1801	m_aai4x4Depth[i4x4BlkY][i4x4BlkX] = piCurrDepthMap[ iCurrSamplePosY * iCurrStride + iCurrSamplePosX ];
1802	m_aabDepthSet[i4x4BlkY][i4x4BlkX] = true;
1803	iNum4x4Set++;
1804	}
1805	}
1806	}
1807
1808	#if PDM_ONE_DEPTH_PER_PU
1809	//===== set average in 4x4 depth array =====
1810	Int iSum = 0;
1811	for( Int i4x4BlkY = 0; i4x4BlkY < iNum4x4BlksY; i4x4BlkY++ )
1812	{
1813	for( Int i4x4BlkX = 0; i4x4BlkX < iNum4x4BlksX; i4x4BlkX++ )
1814	{
1815	if( m_aabDepthSet[ i4x4BlkY ][ i4x4BlkX ] )
1816	{
1817	iSum += m_aai4x4Depth[ i4x4BlkY ][ i4x4BlkX ];
1818	}
1819	}
1820	}
1821	Int iDepth = ( iSum + ( iNum4x4Set >> 1 ) ) / iNum4x4Set;
1822	iNum4x4Set = iNum4x4BlksY * iNum4x4BlksX;
1823	for( Int i4x4BlkY = 0; i4x4BlkY < iNum4x4BlksY; i4x4BlkY++ )
1824	{
1825	for( Int i4x4BlkX = 0; i4x4BlkX < iNum4x4BlksX; i4x4BlkX++ )
1826	{
1827	m_aai4x4Depth[ i4x4BlkY ][ i4x4BlkX ] = iDepth;
1828	m_aabDepthSet[ i4x4BlkY ][ i4x4BlkX ] = true;
1829	}
1830	}
1831	#endif
1832
1833	//===== complete depth arrays =====
1834	while( iNum4x4BlksY * iNum4x4BlksX - iNum4x4Set )
1835	{
1836	for( Int i4x4BlkY = 0; i4x4BlkY < iNum4x4BlksY; i4x4BlkY++ )
1837	{
1838	for( Int i4x4BlkX = 0; i4x4BlkX < iNum4x4BlksX; i4x4BlkX++ )
1839	{
1840	if( !m_aabDepthSet[ i4x4BlkY ][ i4x4BlkX ] )
1841	{ // could also use minimum of neighbours (occlusions)
1842	Int iNumNeighbours = 0;
1843	Int iSumNeighbours = 0;
1844	if( i4x4BlkY > 0 && m_aabDepthSet[ i4x4BlkY-1 ][ i4x4BlkX ] ) { iSumNeighbours += m_aai4x4Depth[ i4x4BlkY-1 ][ i4x4BlkX ]; iNumNeighbours++; }
1845	if( i4x4BlkY < iNum4x4BlksY-1 && m_aabDepthSet[ i4x4BlkY+1 ][ i4x4BlkX ] ) { iSumNeighbours += m_aai4x4Depth[ i4x4BlkY+1 ][ i4x4BlkX ]; iNumNeighbours++; }
1846	if( i4x4BlkX > 0 && m_aabDepthSet[ i4x4BlkY ][ i4x4BlkX-1 ] ) { iSumNeighbours += m_aai4x4Depth[ i4x4BlkY ][ i4x4BlkX-1 ]; iNumNeighbours++; }
1847	if( i4x4BlkX < iNum4x4BlksX-1 && m_aabDepthSet[ i4x4BlkY ][ i4x4BlkX+1 ] ) { iSumNeighbours += m_aai4x4Depth[ i4x4BlkY ][ i4x4BlkX+1 ]; iNumNeighbours++; }
1848	if( iNumNeighbours )
1849	{
1850	m_aai4x4Depth[ i4x4BlkY ][ i4x4BlkX ] = ( iSumNeighbours + ( iNumNeighbours >> 1 ) ) / iNumNeighbours;
1851	m_aabDepthSet[ i4x4BlkY ][ i4x4BlkX ] = true;
1852	iNum4x4Set++;
1853	}
1854	}
1855	}
1856	}
1857	}
1858
1859	//===== set depth values =====
1860	UInt uiBlkX = g_auiRasterToPelX[ g_auiZscanToRaster[ uiAbsPartIdx ] ] >> m_uiSubSampExpX;
1861	UInt uiBlkY = g_auiRasterToPelY[ g_auiZscanToRaster[ uiAbsPartIdx ] ] >> m_uiSubSampExpY;
1862	Pel* piDepthMap = pcCUDepthMap->getLumaAddr() + uiBlkY * pcCUDepthMap->getStride() + uiBlkX;
1863	Int iCUStride = pcCUDepthMap->getStride ();
1864	for( Int iRow = 0; iRow < iHeight; iRow++, piDepthMap += iCUStride )
1865	{
1866	for( Int iCol = 0; iCol < iWidth; iCol++ )
1867	{
1868	piDepthMap[ iCol ] = m_aai4x4Depth[ (iRow << m_uiSubSampExpY) >> 2 ][ (iCol << m_uiSubSampExpX) >> 2 ];
1869	}
1870	}
1871	}
1872
1873
1874	Void
1875	TComDepthMapGenerator::xInterPUDepthMapPrediction( TComDataCU* pcCU, TComYuv* pcCUDepthMap, UInt uiPartIdx )
1876	{
1877	m_pcPrediction->motionCompensation( pcCU, pcCUDepthMap, REF_PIC_LIST_X, (Int)uiPartIdx, true, m_uiSubSampExpX, m_uiSubSampExpY );
1878	}
1879
1880
1881	Bool
1882	TComDepthMapGenerator::xGetPredDepth( TComDataCU* pcCU, UInt uiPartIdx, Int& riPrdDepth, Int* piPosX, Int* piPosY )
1883	{
1884	AOF ( m_bCreated && m_bInit );
1885	AOF ( pcCU );
1886	ROFRS( m_bPDMAvailable, false );
1887
1888	TComSlice* pcSlice = pcCU->getSlice ();
1889	TComPic* pcPic = pcCU->getPic ();
1890	TComSPS* pcSPS = pcSlice->getSPS();
1891	AOF ( pcPic->getPredDepthMap() );
1892	AOF ( pcSPS->getViewId() == m_uiCurrViewId );
1893
1894	//===== get predicted depth and disprity for middle position of current PU =====
1895	UInt uiPartAddr;
1896	Int iWidth;
1897	Int iHeight;
1898	pcCU->getPartIndexAndSize( uiPartIdx, uiPartAddr, iWidth, iHeight );
1899	TComPicYuv* pcPredDepthMap = pcPic->getPredDepthMap();
1900	Pel* piPredDepthMap = pcPredDepthMap->getLumaAddr ( 0 );
1901	Int iCurrStride = pcPredDepthMap->getStride ();
1902	Int iCurrPosX;
1903	Int iCurrPosY;
1904	pcPredDepthMap->getTopLeftSamplePos( pcCU->getAddr(), pcCU->getZorderIdxInCU() + uiPartAddr, iCurrPosX, iCurrPosY );
1905	#if SAIT_IMPROV_MOTION_PRED_M24829 // max disparity within PU
1906	Int DiWidth = iCurrPosX+(iWidth >> m_uiSubSampExpX);
1907	Int DiHeight = iCurrPosY+(iHeight >> m_uiSubSampExpY);
1908	Int maxDepth = MIN_INT;
1909
1910	for(Int y=iCurrPosY; y<DiHeight ;y++)
1911	{
1912	for(Int x=iCurrPosX; x<DiWidth; x++)
1913	{
1914	if(piPredDepthMap[ x + y * iCurrStride ] > maxDepth)
1915	{
1916	maxDepth = piPredDepthMap[ x + y * iCurrStride ];
1917	}
1918	}
1919	}
1920	iCurrPosX += ( ( iWidth >> m_uiSubSampExpX ) - 1 ) >> 1;
1921	iCurrPosY += ( ( iHeight >> m_uiSubSampExpY ) - 1 ) >> 1;
1922	riPrdDepth = maxDepth;
1923	#else
1924	iCurrPosX += ( ( iWidth >> m_uiSubSampExpX ) - 1 ) >> 1;
1925	iCurrPosY += ( ( iHeight >> m_uiSubSampExpY ) - 1 ) >> 1;
1926	riPrdDepth = piPredDepthMap[ iCurrPosX + iCurrPosY * iCurrStride ];
1927	#endif
1928	if( piPosX )
1929	{
1930	*piPosX = iCurrPosX;
1931	}
1932	if( piPosY )
1933	{
1934	*piPosY = iCurrPosY;
1935	}
1936	return true;
1937	}
1938	#endif
1939
1940	#endif // DEPTH_MAP_GENERATION
1941

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/TComDepthMapGenerator.cpp

Download in other formats: