Context navigation

source: 3DVCSoftware/branches/HTM-3.0-Qualcomm/source/Lib/TLibCommon/TComDepthMapGenerator.cpp @ 1314

Visit:

Last change on this file since 1314 was 56, checked in by hschwarz, 13 years ago
updated trunk (move to HM6.1)
Property svn:eol-style set to `native`
File size: 62.0 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	m_ppcYuv = new TComYuv* [ m_uiMaxDepth ];
81	m_ppcCU = new TComDataCU* [ m_uiMaxDepth ];
82	for( UInt uiDepth = 0; uiDepth < m_uiMaxDepth; uiDepth++ )
83	{
84	UInt uiNumPart = 1 << ( ( m_uiMaxDepth - uiDepth ) << 1 );
85	UInt uiWidth = uiMaxCUWidth >> uiDepth;
86	UInt uiHeight = uiMaxCUHeight >> uiDepth;
87
88	m_ppcYuv[ uiDepth ] = new TComYuv; m_ppcYuv[ uiDepth ]->create( uiWidth >> m_uiSubSampExpX, uiHeight >> m_uiSubSampExpY );
89	m_ppcCU [ uiDepth ] = new TComDataCU; m_ppcCU [ uiDepth ]->create( uiNumPart, uiWidth, uiHeight, true, uiMaxCUWidth >> (uiMaxCUDepth - 1) );
90	}
91	m_cTmpPic.create( uiPicWidth >> m_uiSubSampExpX, uiPicHeight >> m_uiSubSampExpY, uiMaxCUWidth >> m_uiSubSampExpX, uiMaxCUHeight >> m_uiSubSampExpY, uiMaxCUDepth );
92	xSetChroma( &m_cTmpPic, ( 1 << uiOrgBitDepth ) >> 1 );
93	m_bCreated = true;
94	}
95
96	Void
97	TComDepthMapGenerator::destroy()
98	{
99	if( m_bCreated )
100	{
101	m_bCreated = false;
102	for( UInt uiDepth = 0; uiDepth < m_uiMaxDepth; uiDepth++ )
103	{
104	if( m_ppcYuv[ uiDepth ] )
105	{
106	m_ppcYuv[ uiDepth ]->destroy(); delete m_ppcYuv[ uiDepth ]; m_ppcYuv[ uiDepth ] = 0;
107	}
108	if( m_ppcCU [ uiDepth ] )
109	{
110	m_ppcCU [ uiDepth ]->destroy(); delete m_ppcCU [ uiDepth ]; m_ppcCU [ uiDepth ] = 0;
111	}
112	}
113	delete [] m_ppcYuv; m_ppcYuv = 0;
114	delete [] m_ppcCU; m_ppcCU = 0;
115	m_cTmpPic.destroy();
116	m_uiMaxDepth = 0;
117	m_uiOrgDepthBitDepth = 0;
118	m_uiSubSampExpX = 0;
119	m_uiSubSampExpY = 0;
120	m_bDecoder = false;
121	}
122	}
123
124	Void
125	TComDepthMapGenerator::init( TComPrediction* pcPrediction, TComSPSAccess* pcSPSAccess, TComAUPicAccess* pcAUPicAccess )
126	{
127	AOF( pcPrediction );
128	AOF( pcSPSAccess );
129	AOF( pcAUPicAccess );
130	uninit();
131	m_pcPrediction = pcPrediction;
132	m_pcSPSAccess = pcSPSAccess;
133	m_pcAUPicAccess = pcAUPicAccess;
134	m_bInit = true;
135	}
136
137	Void
138	TComDepthMapGenerator::uninit()
139	{
140	if( m_bInit )
141	{
142	m_bInit = false;
143	m_pcPrediction = 0;
144	m_pcSPSAccess = 0;
145	m_pcAUPicAccess = 0;
146	}
147	}
148
149	Void
150	TComDepthMapGenerator::initViewComponent( TComPic* pcPic )
151	{
152	AOF ( m_bCreated && m_bInit );
153	AOF ( pcPic );
154	AOT ( pcPic->getSPS()->getViewId() && !pcPic->getSPS()->isDepth() && pcPic->getPOC() && pcPic->getSPS()->getPredDepthMapGeneration() != m_pcSPSAccess->getPdm() );
155	m_bPDMAvailable = false;
156	m_uiCurrViewId = pcPic->getSPS()->getViewId();
157
158	// update SPS list and AU pic list and set depth map generator in SPS
159	m_pcSPSAccess ->addSPS( pcPic->getSPS() );
160	m_pcAUPicAccess->addPic( pcPic );
161	pcPic->getSPS()->setDepthMapGenerator( this );
162
163	// check whether we have depth data or don't use pred depth prediction
164	ROFVS( pcPic->getSPS()->getViewId() );
165	ROTVS( pcPic->getSPS()->isDepth () );
166	ROFVS( m_pcSPSAccess->getPdm () );
167
168	// set basic SPS parameters
169	const Int iDisparityDir = 1; // 1 or -1, depending on the usage of disparity vectors
170	TComSPS* pcSPS = pcPic->getSPS ();
171	Int iVOI = pcSPS->getViewOrderIdx ();
172	UInt uiPdmPrec = pcSPS->getPdmPrecision ();
173	UInt uiCamPrec = pcSPS->getCamParPrecision ();
174	Bool bInSlice = pcSPS->hasCamParInSliceHeader ();
175	Int iScaleVOI01 = ( 1 << ( uiPdmPrec + PDM_INTER_CALC_SHIFT + PDM_VIRT_DEPTH_PRECISION - 2 ) );
176
177	// check availability of base views and set base id list
178	std::vector<Int> aiAbsDeltaVOI;
179	for( UInt uiBaseId = 0; uiBaseId < m_uiCurrViewId; uiBaseId++ )
180	{
181	TComSPS* pcBaseSPS = m_pcSPSAccess ->getSPS( uiBaseId );
182	TComPic* pcBasePic = m_pcAUPicAccess->getPic( uiBaseId );
183	AOF( pcBaseSPS != 0 && pcBasePic != 0 );
184	Int iDeltaVOI = iVOI - pcBaseSPS->getViewOrderIdx();
185	Int iAbsDeltaVOI = ( iDeltaVOI < 0 ? -iDeltaVOI : iDeltaVOI );
186	AOT( iAbsDeltaVOI == 0 );
187	aiAbsDeltaVOI.push_back( iAbsDeltaVOI );
188	}
189	m_auiBaseIdList.clear();
190	while( (UInt)m_auiBaseIdList.size() < m_uiCurrViewId )
191	{
192	Int iMinAbsDelta = MAX_INT;
193	UInt uiNextBaseId = MAX_VIEW_NUM;
194	for( UInt uiBaseId = 0; uiBaseId < m_uiCurrViewId; uiBaseId++ )
195	{
196	if( aiAbsDeltaVOI[ uiBaseId ] > 0 && aiAbsDeltaVOI[ uiBaseId ] <= iMinAbsDelta )
197	{
198	iMinAbsDelta = aiAbsDeltaVOI[ uiBaseId ];
199	uiNextBaseId = uiBaseId;
200	}
201	}
202	m_auiBaseIdList.push_back( uiNextBaseId );
203	aiAbsDeltaVOI[ uiNextBaseId ] = 0;
204	}
205
206	// check availability of prediction depth map
207	if( m_uiCurrViewId )
208	{
209	Bool bCheckVId1 = ( m_uiCurrViewId > 1 && m_auiBaseIdList[0] == 0 );
210	UInt uiBaseVId = ( bCheckVId1 ? 1 : m_auiBaseIdList[0] );
211	TComPic* pcBasePic = m_pcAUPicAccess->getPic( uiBaseVId );
212	SliceType eSliceType = pcBasePic->getCurrSlice()->getSliceType();
213	Bool bNoRAPdm = ( pcPic->getSPS()->getPredDepthMapGeneration() == 1 );
214	m_bPDMAvailable = ( eSliceType != I_SLICE \|\| !bNoRAPdm );
215	}
216
217	// update disparity depth conversion parameters
218	for( UInt uiBaseId = 0; uiBaseId < m_uiCurrViewId; uiBaseId++ )
219	{
220	TComSPS* pcBaseSPS = m_pcSPSAccess->getSPS( uiBaseId );
221	Int iBaseVOI = pcBaseSPS->getViewOrderIdx();
222
223	// disparity -> virtual depth
224	Int iVNominator = ( 1 << PDM_LOG4_SCALE_DENOMINATOR ) + pcSPS->getPdmScaleNomDelta()[ uiBaseId ];
225	Int iVDiv = iVOI - iBaseVOI;
226	Int iVAdd = ( iVDiv > 0 ? iVDiv / 2 : -iVDiv / 2 );
227	Int iVScalePred = ( iScaleVOI01 + iVAdd ) / iVDiv;
228	Int iVShift = PDM_INTER_CALC_SHIFT;
229	Int iVScale = Int( ( (Int64)iVNominator * (Int64)iVScalePred + (Int64)( ( 1 << PDM_LOG4_SCALE_DENOMINATOR ) >> 1 ) ) >> PDM_LOG4_SCALE_DENOMINATOR );
230	Int iVOffset = pcSPS->getPdmOffset()[ uiBaseId ] << PDM_OFFSET_SHIFT;
231	m_aaiConvParsDisparity2VirtDepth[ uiBaseId ][ 0 ] = iDisparityDir * iVScale;
232	m_aaiConvParsDisparity2VirtDepth[ uiBaseId ][ 1 ] = iDisparityDir * iVOffset + ( ( 1 << iVShift ) >> 1 );
233	m_aaiConvParsDisparity2VirtDepth[ uiBaseId ][ 2 ] = iVShift;
234
235	// virtual depth -> disparity
236	Int iVInvAdd = ( iVScale > 0 ? iVScale / 2 : -iVScale / 2 );
237	Int iVInvScale = Int( ( ( Int64( 1 ) << ( iVShift << 1 ) ) + iVInvAdd ) / Int64( iVScale ) );
238	Int iVInvOffset = Int( ( ( Int64( -iVOffset ) << iVShift ) + iVInvAdd ) / Int64( iVScale ) );
239	m_aaiConvParsVirtDepth2Disparity[ uiBaseId ][ 0 ] = iDisparityDir * iVInvScale;
240	m_aaiConvParsVirtDepth2Disparity[ uiBaseId ][ 1 ] = iDisparityDir * iVInvOffset + ( ( 1 << iVShift ) >> 1 );
241	m_aaiConvParsVirtDepth2Disparity[ uiBaseId ][ 2 ] = iVShift;
242
243	// coded depth -> virtual depth
244	Int iCScale = ( bInSlice ? pcPic->getCurrSlice()->getCodedScale () : pcSPS->getCodedScale () )[ uiBaseId ];
245	Int iCOffset = ( bInSlice ? pcPic->getCurrSlice()->getCodedOffset() : pcSPS->getCodedOffset() )[ uiBaseId ] << m_uiOrgDepthBitDepth;
246	Int iCShift = m_uiOrgDepthBitDepth + uiCamPrec + 1 - 2;
247	Int iCVShift = PDM_INTER_CALC_SHIFT;
248	Int iTmpShift = iVShift + iCShift - iCVShift; AOF( iTmpShift >= 0 )
249	Int iCVScale = Int( ( Int64( iVScale ) * Int64( iCScale ) + Int64( ( 1 << iTmpShift ) >> 1 ) ) >> iTmpShift );
250	Int iCVOffset = Int( ( Int64( iVScale ) * Int64( iCOffset ) + Int64( ( 1 << iTmpShift ) >> 1 ) ) >> iTmpShift );
251	iTmpShift = iVShift - iCVShift; AOF( iTmpShift >= 0 )
252	iCVOffset += ( iVOffset + ( ( 1 << iTmpShift ) >> 1 ) ) >> iTmpShift;
253	m_aaiConvParsOrigDepth2VirtDepth[ uiBaseId ][ 0 ] = iCVScale;
254	m_aaiConvParsOrigDepth2VirtDepth[ uiBaseId ][ 1 ] = iCVOffset + ( ( 1 << iCVShift ) >> 1 );
255	m_aaiConvParsOrigDepth2VirtDepth[ uiBaseId ][ 2 ] = iCVShift;
256
257	// virtual depth -> coded depth
258	Int iCVAdd = ( iCVScale > 0 ? iCVScale / 2 : -iCVScale / 2 );
259	Int iCVInvScale = Int( ( ( Int64( 1 ) << ( iCVShift << 1 ) ) + iCVAdd ) / Int64( iCVScale ) );
260	Int iCVInvOffset= Int( ( ( Int64( -iCVOffset ) << iCVShift ) + iCVAdd ) / Int64( iCVScale ) );
261	m_aaiConvParsVirtDepth2OrigDepth[ uiBaseId ][ 0 ] = iCVInvScale;
262	m_aaiConvParsVirtDepth2OrigDepth[ uiBaseId ][ 1 ] = iCVInvOffset + ( ( 1 << iCVShift ) >> 1 );
263	m_aaiConvParsVirtDepth2OrigDepth[ uiBaseId ][ 2 ] = iCVShift;
264	}
265
266	if( m_uiCurrViewId > 0 )
267	{
268	UInt uiBaseId = 0;
269	UInt uiBaseVOI = 0; // per definition
270	Int iVNominator = ( 1 << PDM_LOG4_SCALE_DENOMINATOR ) + pcSPS->getPdmScaleNomDelta()[ uiBaseId ];
271	Int iVDiv = iVOI - uiBaseVOI;
272	Int iVAdd = ( iVDiv > 0 ? iVDiv / 2 : -iVDiv / 2 );
273	Int iVScalePred = ( iScaleVOI01 + iVAdd ) / iVDiv;
274	Int iVShift = PDM_INTER_CALC_SHIFT;
275	Int iVScale = Int( ( (Int64)iVNominator * (Int64)iVScalePred + (Int64)( ( 1 << PDM_LOG4_SCALE_DENOMINATOR ) >> 1 ) ) >> PDM_LOG4_SCALE_DENOMINATOR );
276	Int iVOffset = pcSPS->getPdmOffset()[ uiBaseId ] << PDM_OFFSET_SHIFT;
277
278	// coded depth -> virtual depth (current view)
279	Int iCScale = ( bInSlice ? pcPic->getCurrSlice()->getInvCodedScale () : pcSPS->getInvCodedScale () )[ uiBaseId ];
280	Int iCOffset = ( bInSlice ? pcPic->getCurrSlice()->getInvCodedOffset() : pcSPS->getInvCodedOffset() )[ uiBaseId ] << m_uiOrgDepthBitDepth;
281	Int iCShift = m_uiOrgDepthBitDepth + uiCamPrec + 1 - 2;
282	Int iCVShift = PDM_INTER_CALC_SHIFT;
283	Int iTmpShift = iVShift + iCShift - iCVShift; AOF( iTmpShift >= 0 )
284	Int iCVScale = Int( ( Int64( -iVScale ) * Int64( iCScale ) + Int64( ( 1 << iTmpShift ) >> 1 ) ) >> iTmpShift );
285	Int iCVOffset = Int( ( Int64( -iVScale ) * Int64( iCOffset ) + Int64( ( 1 << iTmpShift ) >> 1 ) ) >> iTmpShift );
286	iTmpShift = iVShift - iCVShift; AOF( iTmpShift >= 0 )
287	iCVOffset += ( iVOffset + ( ( 1 << iTmpShift ) >> 1 ) ) >> iTmpShift;
288	m_aaiConvParsOrigDepth2VirtDepth[ m_uiCurrViewId ][ 0 ] = iCVScale;
289	m_aaiConvParsOrigDepth2VirtDepth[ m_uiCurrViewId ][ 1 ] = iCVOffset + ( ( 1 << iCVShift ) >> 1 );
290	m_aaiConvParsOrigDepth2VirtDepth[ m_uiCurrViewId ][ 2 ] = iCVShift;
291
292	// virtual depth -> coded depth
293	Int iCVAdd = ( iCVScale > 0 ? iCVScale / 2 : -iCVScale / 2 );
294	Int iCVInvScale = Int( ( ( Int64( 1 ) << ( iCVShift << 1 ) ) + iCVAdd ) / Int64( iCVScale ) );
295	Int iCVInvOffset= Int( ( ( Int64( -iCVOffset ) << iCVShift ) + iCVAdd ) / Int64( iCVScale ) );
296	m_aaiConvParsVirtDepth2OrigDepth[ m_uiCurrViewId ][ 0 ] = iCVInvScale;
297	m_aaiConvParsVirtDepth2OrigDepth[ m_uiCurrViewId ][ 1 ] = iCVInvOffset + ( ( 1 << iCVShift ) >> 1 );
298	m_aaiConvParsVirtDepth2OrigDepth[ m_uiCurrViewId ][ 2 ] = iCVShift;
299	}
300	else if( pcPic->getPOC() == 0 )
301	{ // set dummy values
302	m_aaiConvParsOrigDepth2VirtDepth[ m_uiCurrViewId ][ 0 ] = 0;
303	m_aaiConvParsOrigDepth2VirtDepth[ m_uiCurrViewId ][ 1 ] = 0;
304	m_aaiConvParsOrigDepth2VirtDepth[ m_uiCurrViewId ][ 2 ] = 0;
305	m_aaiConvParsVirtDepth2OrigDepth[ m_uiCurrViewId ][ 0 ] = 0;
306	m_aaiConvParsVirtDepth2OrigDepth[ m_uiCurrViewId ][ 1 ] = 0;
307	m_aaiConvParsVirtDepth2OrigDepth[ m_uiCurrViewId ][ 2 ] = 0;
308	}
309
310
311	#if 0 // print out for debugging
312	if( m_uiCurrViewId )
313	{
314	printf( "\n\ninit slice of view %d (VOI=%2d):\n===============================\n", m_uiCurrViewId, iVOI );
315	{
316	printf( "\n disparity -> virtual depth:\n" );
317	for( UInt uiBaseId = 0; uiBaseId < m_uiCurrViewId; uiBaseId++ )
318	{
319	Int* pP = m_aaiConvParsDisparity2VirtDepth[ uiBaseId ];
320	Double dF = 1.0 / Double( 1 << pP[ 2 ] );
321	Double dA = dF * Double( pP[ 0 ] );
322	Double dB = dF * Double( pP[ 1 ] - ( ( 1 << pP[ 2 ] ) >> 1 ) );
323	printf( " BId=%d: a = %10.4lf b = %10.4lf\n", uiBaseId, dA, dB );
324	}
325	printf( "\n virtual depth -> disparity:\n" );
326	for( UInt uiBaseId = 0; uiBaseId < m_uiCurrViewId; uiBaseId++ )
327	{
328	Int* pP = m_aaiConvParsVirtDepth2Disparity[ uiBaseId ];
329	Double dF = 1.0 / Double( 1 << pP[ 2 ] );
330	Double dA = dF * Double( pP[ 0 ] );
331	Double dB = dF * Double( pP[ 1 ] - ( ( 1 << pP[ 2 ] ) >> 1 ) );
332	printf( " BId=%d: a = %10.4lf b = %10.4lf\n", uiBaseId, dA, dB );
333	}
334	printf( "\n original depth -> virtual depth:\n" );
335	for( UInt uiBaseId = 0; uiBaseId <= m_uiCurrViewId; uiBaseId++ )
336	{
337	Int* pP = m_aaiConvParsOrigDepth2VirtDepth[ uiBaseId ];
338	Double dF = 1.0 / Double( 1 << pP[ 2 ] );
339	Double dA = dF * Double( pP[ 0 ] );
340	Double dB = dF * Double( pP[ 1 ] - ( ( 1 << pP[ 2 ] ) >> 1 ) );
341	printf( " VId=%d: a = %10.4lf b = %10.4lf\n", uiBaseId, dA, dB );
342	}
343	printf( "\n virtual depth -> original depth:\n" );
344	for( UInt uiBaseId = 0; uiBaseId <= m_uiCurrViewId; uiBaseId++ )
345	{
346	Int* pP = m_aaiConvParsVirtDepth2OrigDepth[ uiBaseId ];
347	Double dF = 1.0 / Double( 1 << pP[ 2 ] );
348	Double dA = dF * Double( pP[ 0 ] );
349	Double dB = dF * Double( pP[ 1 ] - ( ( 1 << pP[ 2 ] ) >> 1 ) );
350	printf( " VId=%d: a = %10.4lf b = %10.4lf\n", uiBaseId, dA, dB );
351	}
352	printf( "\n" );
353	}
354	}
355	#endif
356	}
357
358
359	Bool
360	TComDepthMapGenerator::predictDepthMap( TComPic* pcPic )
361	{
362	AOF ( m_bCreated && m_bInit );
363	AOF ( pcPic );
364	ROTRS( pcPic->getSPS()->isDepth(), true );
365	ROFRS( m_pcSPSAccess->getPdm(), true );
366	AOF ( pcPic->getPredDepthMap() );
367	AOF ( pcPic->getSPS()->getViewId() == m_uiCurrViewId );
368
369	#if PDM_OUTPUT_PRED_DEPTH_MAP
370	Char acFilenameBase[1024];
371	::sprintf( acFilenameBase, "PDM_%s_Prd", ( m_bDecoder ? "Dec" : "Enc" ) );
372	#endif
373
374	Bool bUndefined = true;
375	if( m_uiCurrViewId )
376	{
377	AOF( m_auiBaseIdList.size() );
378	UInt uiBaseId = m_auiBaseIdList[ 0 ];
379	TComPic* pcBasePic = m_pcAUPicAccess->getPic( uiBaseId );
380	AOF( pcBasePic );
381
382	if( m_uiCurrViewId == 1 )
383	{
384	if( pcBasePic->getPOC() == 0 )
385	{
386	pcBasePic->removePrdDepthMapBuffer();
387	pcBasePic->addPrdDepthMapBuffer( PDM_SUB_SAMP_EXP_X(m_pcSPSAccess->getPdm()), PDM_SUB_SAMP_EXP_Y(m_pcSPSAccess->getPdm()) );
388	xClearDepthMap( pcBasePic );
389	}
390	#if PDM_OUTPUT_PRED_DEPTH_MAP
391	dumpDepthMap( pcBasePic, acFilenameBase );
392	#endif
393	}
394
395	Bool bLoadDepth = ( m_pcSPSAccess->getPdm() == 2 );
396	if( m_pcSPSAccess->getPdm() > 2 )
397	{
398	bLoadDepth = ( pcBasePic->getCurrSlice()->getSliceType() == I_SLICE );
399	}
400
401	if( bLoadDepth)
402	{ // load coded depth of base view
403	TComPic* pcBaseDepth = m_pcAUPicAccess->getPic( uiBaseId, true );
404	AOF( pcBaseDepth );
405	AOF( pcBaseDepth->getPicYuvRec() );
406	AOF( pcBaseDepth->getPicYuvRec()->getWidth () == pcBasePic->getPredDepthMap()->getWidth () );
407	AOF( pcBaseDepth->getPicYuvRec()->getHeight() == pcBasePic->getPredDepthMap()->getHeight() );
408	Int iWidth = pcBasePic ->getPredDepthMap()->getWidth ();
409	Int iHeight = pcBasePic ->getPredDepthMap()->getHeight ();
410	Int iDesStride = pcBasePic ->getPredDepthMap()->getStride ();
411	Int iSrcStride = pcBaseDepth->getPicYuvRec ()->getStride ();
412	Pel* pDesSamples = pcBasePic ->getPredDepthMap()->getLumaAddr ( 0 );
413	Pel* pSrcSamples = pcBaseDepth->getPicYuvRec ()->getLumaAddr ( 0 );
414	for( Int iY = 0; iY < iHeight; iY++, pSrcSamples += iSrcStride, pDesSamples += iDesStride )
415	{
416	for( Int iX = 0; iX < iWidth; iX++ )
417	{
418	pDesSamples[ iX ] = xGetVirtDepthFromOrigDepth( uiBaseId, pSrcSamples[ iX ] );
419	}
420	}
421	}
422
423	// convert depth of base view to current view
424	bUndefined = xConvertDepthMapRef2Curr( pcPic, pcBasePic );
425
426	#if PDM_OUTPUT_PRED_DEPTH_MAP
427	dumpDepthMap( pcPic, acFilenameBase );
428	#endif
429	}
430	else
431	{
432	xClearDepthMap( pcPic );
433	}
434	return bUndefined;
435	}
436
437
438	Void
439	TComDepthMapGenerator::updateDepthMap( TComPic* pcPic )
440	{
441	AOF ( m_bCreated && m_bInit );
442	AOF ( pcPic );
443	ROTVS( pcPic->getSPS()->isDepth() );
444	ROFVS( m_pcSPSAccess->getPdm() == 1 \|\| m_pcSPSAccess->getPdm() == 3 );
445	AOF ( pcPic->getPredDepthMap() );
446	AOF ( pcPic->getSPS()->getViewId() == m_uiCurrViewId );
447
448	#if PDM_OUTPUT_PRED_DEPTH_MAP
449	Char acFilenameBase[1024];
450	::sprintf( acFilenameBase, "PDM_%s_Upd", ( m_bDecoder ? "Dec" : "Enc" ) );
451	#endif
452
453	// predict depth map using current coding symbols
454	xPredictDepthMap( pcPic );
455	#if PDM_OUTPUT_PRED_DEPTH_MAP
456	if( m_uiCurrViewId )
457	{
458	dumpDepthMap( pcPic, acFilenameBase );
459	}
460	#endif
461
462	// generate base depth map
463	if( m_uiCurrViewId == 1 )
464	{
465	TComPic* pcBasePic = m_pcAUPicAccess->getPic( 0 );
466	AOF( pcBasePic );
467	xConvertDepthMapCurr2Ref( pcBasePic, pcPic );
468	#if PDM_OUTPUT_PRED_DEPTH_MAP
469	dumpDepthMap( pcBasePic, acFilenameBase );
470	#endif
471	}
472	}
473
474
475	Void
476	TComDepthMapGenerator::dumpDepthMap( TComPic* pcPic, char* pFilenameBase )
477	{
478	AOF( m_bCreated && m_bInit );
479	AOF( pcPic );
480	AOF( pFilenameBase );
481	AOF( m_uiOrgDepthBitDepth == 8 + g_uiBitIncrement );
482	AOF( pcPic->getSPS()->getViewId() <= m_uiCurrViewId );
483
484	// convert to output format
485	Int iMax = ( 1 << m_uiOrgDepthBitDepth ) - 1;
486	UInt uiViewId = pcPic->getSPS()->getViewId();
487	TComPicYuv* pcPicYuv = pcPic->getPredDepthMap();
488	Int iWidth = pcPicYuv->getWidth ();
489	Int iHeight = pcPicYuv->getHeight ();
490	Int iSrcStride = pcPicYuv->getStride ();
491	Int iDstStride = m_cTmpPic.getStride ();
492	Pel* pSrcSamples = pcPicYuv->getLumaAddr ( 0 );
493	Pel* pDstSamples = m_cTmpPic.getLumaAddr ( 0 );
494	Int iMidOrgDpth = ( 1 << m_uiOrgDepthBitDepth ) >> 1;
495	AOF( m_cTmpPic.getWidth () == iWidth );
496	AOF( m_cTmpPic.getHeight() == iHeight );
497	for( Int iY = 0; iY < iHeight; iY++, pSrcSamples += iSrcStride, pDstSamples += iDstStride )
498	{
499	for( Int iX = 0; iX < iWidth; iX++ )
500	{
501	Int iOrgDepth = ( pSrcSamples[ iX ] != PDM_UNDEFINED_DEPTH ? xGetOrigDepthFromVirtDepth( uiViewId, pSrcSamples[ iX ] ) : iMidOrgDpth );
502	pDstSamples[ iX ] = Max( 0, Min( iMax, iOrgDepth ) );
503	}
504	}
505
506	// output
507	Char acFilename[1024];
508	::sprintf ( acFilename, "%s_V%d.yuv", pFilenameBase, uiViewId );
509	m_cTmpPic.dump( acFilename, ( pcPic->getPOC() != 0 ) );
510	}
511
512
513	#if HHI_INTER_VIEW_MOTION_PRED
514	Void
515	TComDepthMapGenerator::covertOrgDepthMap( TComPic* pcPic )
516	{
517	AOF ( m_bCreated && m_bInit );
518	AOF ( pcPic );
519	ROFVS( pcPic->getOrgDepthMap() );
520	AOF ( pcPic->getViewId() );
521
522	UInt uiBaseId = pcPic->getViewId();
523	Int iWidth = pcPic->getOrgDepthMap()->getWidth ();
524	Int iHeight = pcPic->getOrgDepthMap()->getHeight ();
525	Int iStride = pcPic->getOrgDepthMap()->getStride ();
526	Pel* pSamples = pcPic->getOrgDepthMap()->getLumaAddr ( 0 );
527	for( Int iY = 0; iY < iHeight; iY++, pSamples += iStride )
528	{
529	for( Int iX = 0; iX < iWidth; iX++ )
530	{
531	pSamples[ iX ] = xGetVirtDepthFromOrigDepth( uiBaseId, pSamples[ iX ] );
532	}
533	}
534	}
535	#endif
536
537	Int
538	TComDepthMapGenerator::getDisparity( TComPic* pcPic, Int iPosX, Int iPosY, UInt uiRefViewId )
539	{
540	AOF( pcPic );
541	AOF( pcPic->getPredDepthMap() );
542	AOF( iPosX >= 0 && iPosX < pcPic->getPredDepthMap()->getWidth () );
543	AOF( iPosY >= 0 && iPosY < pcPic->getPredDepthMap()->getHeight() );
544	Pel* piPdmMap = pcPic->getPredDepthMap()->getLumaAddr( 0 );
545	Int iStride = pcPic->getPredDepthMap()->getStride ();
546	Int iPrdDepth = piPdmMap[ iPosX + iPosY * iStride ];
547	Int iDisparity = xGetDisparityFromVirtDepth( uiRefViewId, iPrdDepth );
548	return iDisparity;
549	}
550
551
552
553	#if HHI_INTER_VIEW_MOTION_PRED
554	Int
555	TComDepthMapGenerator::getPdmMergeCandidate( TComDataCU* pcCU, UInt uiPartIdx, Int* paiPdmRefIdx, TComMv* pacPdmMv )
556	{
557	Int iMaxNumInterPics = 1;
558	Int iMaxNumAllPics = 2;
559
560	// inter-only
561	Bool abPdmAvailable[2] = {false,false};
562	for( Int iRefListId = 0; iRefListId < 2; iRefListId++ )
563	{
564	RefPicList eRefPicList = RefPicList( iRefListId );
565	Int iNumRefPics = pcCU->getSlice()->getNumRefIdx( eRefPicList );
566	TComMv cMv;
567	for( Int iPdmRefIdx = 0, iInterPics = 0; iPdmRefIdx < iNumRefPics && iInterPics < iMaxNumInterPics; iPdmRefIdx++ )
568	{
569	if( pcCU->getSlice()->getRefPOC( eRefPicList, iPdmRefIdx ) != pcCU->getSlice()->getPOC() )
570	{
571	if( getPdmMvPred( pcCU, uiPartIdx, eRefPicList, iPdmRefIdx, cMv, true ) )
572	{
573	pcCU->clipMv( cMv );
574	abPdmAvailable[ iRefListId ] = true;
575	paiPdmRefIdx [ iRefListId ] = iPdmRefIdx;
576	pacPdmMv [ iRefListId ] = cMv;
577	break;
578	}
579	iInterPics++;
580	}
581	}
582	}
583	Int iPdmInterDir = ( abPdmAvailable[0] ? 1 : 0 ) + ( abPdmAvailable[1] ? 2 : 0 );
584	if( 0==iPdmInterDir )
585	{ // check all, including inter view references
586	for( Int iRefListId = 0; iRefListId < 2; iRefListId++ )
587	{
588	RefPicList eRefPicList = RefPicList( iRefListId );
589	Int iNumRefPics = Min( iMaxNumAllPics, pcCU->getSlice()->getNumRefIdx( eRefPicList ) );
590	TComMv cMv;
591	for( Int iPdmRefIdx = 0; iPdmRefIdx < iNumRefPics; iPdmRefIdx++ )
592	{
593	if( getPdmMvPred( pcCU, uiPartIdx, eRefPicList, iPdmRefIdx, cMv, true ) )
594	{
595	pcCU->clipMv( cMv );
596	abPdmAvailable[ iRefListId ] = true;
597	paiPdmRefIdx [ iRefListId ] = iPdmRefIdx;
598	pacPdmMv [ iRefListId ] = cMv;
599	break;
600	}
601	}
602	}
603	iPdmInterDir = ( abPdmAvailable[0] ? 1 : 0 ) + ( abPdmAvailable[1] ? 2 : 0 );
604	}
605	return iPdmInterDir;
606	}
607
608
609	Bool
610	TComDepthMapGenerator::getPdmMvPred( TComDataCU* pcCU, UInt uiPartIdx, RefPicList eRefPicList, Int iRefIdx, TComMv& rcMv, Bool bMerge )
611	{
612	AOF ( m_bCreated && m_bInit );
613	AOF ( iRefIdx >= 0 );
614	AOF ( pcCU );
615	ROFRS( m_bPDMAvailable, false );
616
617	TComSlice* pcSlice = pcCU->getSlice ();
618	TComPic* pcPic = pcCU->getPic ();
619	TComSPS* pcSPS = pcSlice->getSPS();
620	AOF ( pcPic->getPredDepthMap() );
621	AOF ( pcSPS->getViewId() == m_uiCurrViewId );
622
623	TComPic* pcRefPic = pcSlice->getRefPic( eRefPicList, iRefIdx );
624	UInt uiRefViewId = pcRefPic->getSPS()->getViewId();
625	Int iRefPoc = pcRefPic->getPOC();
626	Bool bInterview = ( uiRefViewId < m_uiCurrViewId );
627	AOT( bInterview && iRefPoc != pcSlice->getPOC() );
628	AOT( !bInterview && iRefPoc == pcSlice->getPOC() );
629
630	Bool bPdmIView = ( ( pcSPS->getMultiviewMvPredMode() & PDM_USE_FOR_IVIEW ) == PDM_USE_FOR_IVIEW );
631	Bool bPdmInter = ( ( pcSPS->getMultiviewMvPredMode() & PDM_USE_FOR_INTER ) == PDM_USE_FOR_INTER );
632	Bool bPdmMerge = ( ( pcSPS->getMultiviewMvPredMode() & PDM_USE_FOR_MERGE ) == PDM_USE_FOR_MERGE );
633	ROTRS( ( bInterview && !bMerge ) && !bPdmIView, false );
634	ROTRS( (!bInterview && !bMerge ) && !bPdmInter, false );
635	ROTRS( bMerge && !bPdmMerge, false );
636
637	//===== get predicted depth for middle position of current PU =====
638	Int iPrdDepth, iCurrPosX, iCurrPosY;
639	Bool bAvailable = xGetPredDepth( pcCU, uiPartIdx, iPrdDepth, &iCurrPosX, &iCurrPosY );
640	AOF( bAvailable );
641
642	//===== inter-view motion vector prediction =====
643	if( bInterview )
644	{
645	Int iDisparity = xGetDisparityFromVirtDepth( uiRefViewId, iPrdDepth );
646	rcMv.set ( iDisparity, 0 );
647	return true;
648	}
649
650	//===== inter motion vector prediction =====
651	for( UInt uiBId = 0; uiBId < m_uiCurrViewId; uiBId++ )
652	{
653	//--- get base CU/PU and check prediction mode ---
654	UInt uiBaseId = m_auiBaseIdList[ uiBId ];
655	TComPic* pcBasePic = m_pcAUPicAccess->getPic( uiBaseId );
656	TComPicYuv* pcBasePdm = pcBasePic->getPredDepthMap();
657	TComPicYuv* pcBaseRec = pcBasePic->getPicYuvRec ();
658	Int iDisparity = xGetDisparityFromVirtDepth( uiBaseId, iPrdDepth );
659	Int iShiftX = m_uiSubSampExpX + 2;
660	Int iAddX = ( 1 << iShiftX ) >> 1;
661	Int iBasePosX = Clip3( 0, pcBasePdm->getWidth () - 1, iCurrPosX + ( ( iDisparity + iAddX ) >> iShiftX ) );
662	Int iBasePosY = Clip3( 0, pcBasePdm->getHeight() - 1, iCurrPosY );
663	Int iBaseCUAddr;
664	Int iBaseAbsPartIdx;
665	pcBaseRec->getCUAddrAndPartIdx( iBasePosX << m_uiSubSampExpX, iBasePosY << m_uiSubSampExpY, iBaseCUAddr, iBaseAbsPartIdx );
666	TComDataCU* pcBaseCU = pcBasePic->getCU( iBaseCUAddr );
667	if( pcBaseCU->getPredictionMode( iBaseAbsPartIdx ) != MODE_INTER && pcBaseCU->getPredictionMode( iBaseAbsPartIdx ) != MODE_SKIP )
668	{
669	continue;
670	}
671
672	for( UInt uiBaseRefListId = 0; uiBaseRefListId < 2; uiBaseRefListId++ )
673	{
674	RefPicList eBaseRefPicList = RefPicList( uiBaseRefListId );
675	TComMvField cBaseMvField;
676	pcBaseCU->getMvField( pcBaseCU, iBaseAbsPartIdx, eBaseRefPicList, cBaseMvField );
677	Int iBaseRefIdx = cBaseMvField.getRefIdx();
678	Int iBaseRefPoc = ( iBaseRefIdx >= 0 ? pcBaseCU->getSlice()->getRefPic( eBaseRefPicList, iBaseRefIdx )->getPOC() : -(1<<30) );
679	if( iBaseRefIdx >= 0 && iBaseRefPoc == iRefPoc )
680	{
681	rcMv.set( cBaseMvField.getHor(), cBaseMvField.getVer() );
682	return true;
683	}
684	}
685	}
686	return false;
687	}
688
689
690	Bool // first version
691	TComDepthMapGenerator::getIViewOrgDepthMvPred( TComDataCU* pcCU, UInt uiPartIdx, RefPicList eRefPicList, Int iRefIdx, TComMv& rcMv )
692	{
693	AOF ( m_bCreated && m_bInit );
694	AOF ( iRefIdx >= 0 );
695	AOF ( pcCU );
696
697	TComSlice* pcSlice = pcCU->getSlice ();
698	TComPic* pcPic = pcCU->getPic ();
699	TComSPS* pcSPS = pcSlice->getSPS();
700	AOF ( pcSPS->getViewId() == m_uiCurrViewId );
701	ROFRS( pcPic->getOrgDepthMap(), false );
702
703	TComPic* pcRefPic = pcSlice->getRefPic( eRefPicList, iRefIdx );
704	UInt uiRefViewId = pcRefPic->getSPS()->getViewId();
705	Int iRefPoc = pcRefPic->getPOC();
706	ROFRS( uiRefViewId < m_uiCurrViewId, false );
707	AOF ( iRefPoc == pcSlice->getPOC() );
708
709	//===== get predicted depth for middle position of current PU (first version) =====
710	UInt uiPartAddr;
711	Int iWidth;
712	Int iHeight;
713	pcCU->getPartIndexAndSize( uiPartIdx, uiPartAddr, iWidth, iHeight );
714	TComPicYuv* pcOrgDepthMap = pcPic->getOrgDepthMap();
715	Pel* piOrgDepthMap = pcOrgDepthMap->getLumaAddr ( 0 );
716	Int iCurrStride = pcOrgDepthMap->getStride ();
717	Int iCurrPosX;
718	Int iCurrPosY;
719	pcOrgDepthMap->getTopLeftSamplePos( pcCU->getAddr(), pcCU->getZorderIdxInCU() + uiPartAddr, iCurrPosX, iCurrPosY );
720	iCurrPosX += ( iWidth - 1 ) >> 1;
721	iCurrPosY += ( iHeight - 1 ) >> 1;
722	Int iPrdDepth = piOrgDepthMap[ iCurrPosX + iCurrPosY * iCurrStride ];
723
724	//===== get disparity vector =====
725	Int iDisparity = xGetDisparityFromVirtDepth( uiRefViewId, iPrdDepth );
726	rcMv.set ( iDisparity, 0 );
727	return true;
728	}
729	#endif
730
731
732
733
734
735
736	/=======================================================
737	===== =====
738	===== p i c t u r e o p e r a t i o n s =====
739	===== =====
740	=======================================================/
741
742	Bool
743	TComDepthMapGenerator::xConvertDepthMapCurr2Ref( TComPic* pcRef, TComPic* pcCur )
744	{
745	AOF( pcCur->getSPS()->getViewId() == m_uiCurrViewId );
746	AOF( pcCur->getSPS()->getViewId() > pcRef->getSPS()->getViewId() );
747	AOF( pcCur->getPredDepthMap() );
748	AOF( pcRef->getPredDepthMap() );
749	AOF( pcRef->getPredDepthMap()->getWidth () == pcCur->getPredDepthMap()->getWidth () );
750	AOF( pcRef->getPredDepthMap()->getHeight() == pcCur->getPredDepthMap()->getHeight() );
751
752	xClearDepthMap( pcRef );
753	TComPicYuv* pcCurDepthMap = pcCur->getPredDepthMap ();
754	TComPicYuv* pcRefDepthMap = pcRef->getPredDepthMap ();
755	Int iWidth = pcCurDepthMap->getWidth ();
756	Int iHeight = pcCurDepthMap->getHeight ();
757	Int iCurStride = pcCurDepthMap->getStride ();
758	Int iRefStride = pcRefDepthMap->getStride ();
759	Pel* pCurSamples = pcCurDepthMap->getLumaAddr( 0 );
760	Pel* pRefSamples = pcRefDepthMap->getLumaAddr( 0 );
761	Int iRefViewIdx = pcRef->getViewId();
762	Int iShiftX = m_uiSubSampExpX + 2;
763	Int iAddX = ( 1 << iShiftX ) >> 1;
764	for( Int iY = 0; iY < iHeight; iY++, pCurSamples += iCurStride, pRefSamples += iRefStride )
765	{
766	for( Int iXCur = 0; iXCur < iWidth; iXCur++ )
767	{
768	Int iDepth = pCurSamples[ iXCur ];
769	Int iDisp = xGetDisparityFromVirtDepth( iRefViewIdx, iDepth );
770	Int iXRef = iXCur + ( ( iDisp + iAddX ) >> iShiftX );
771	if( iXRef >= 0 && iXRef < iWidth && iDepth > pRefSamples[ iXRef ] )
772	{
773	pRefSamples[ iXRef ] = iDepth;
774	}
775	}
776	}
777	Bool bUndefined = xFillDepthMapHoles( pcRef );
778	pcRefDepthMap->setBorderExtension( false );
779	pcRefDepthMap->extendPicBorder ();
780	return bUndefined;
781	}
782
783
784	Bool
785	TComDepthMapGenerator::xConvertDepthMapRef2Curr( TComPic* pcCur, TComPic* pcRef )
786	{
787	AOF( pcCur->getSPS()->getViewId() == m_uiCurrViewId );
788	AOF( pcCur->getSPS()->getViewId() > pcRef->getSPS()->getViewId() );
789	AOF( pcCur->getPredDepthMap() );
790	AOF( pcRef->getPredDepthMap() );
791	AOF( pcRef->getPredDepthMap()->getWidth () == pcCur->getPredDepthMap()->getWidth () );
792	AOF( pcRef->getPredDepthMap()->getHeight() == pcCur->getPredDepthMap()->getHeight() );
793
794	xClearDepthMap( pcCur );
795	TComPicYuv* pcRefDepthMap = pcRef->getPredDepthMap ();
796	TComPicYuv* pcCurDepthMap = pcCur->getPredDepthMap ();
797	Int iWidth = pcRefDepthMap->getWidth ();
798	Int iHeight = pcRefDepthMap->getHeight ();
799	Int iRefStride = pcRefDepthMap->getStride ();
800	Int iCurStride = pcCurDepthMap->getStride ();
801	Pel* pRefSamples = pcRefDepthMap->getLumaAddr( 0 );
802	Pel* pCurSamples = pcCurDepthMap->getLumaAddr( 0 );
803	Int iRefViewIdx = pcRef->getViewId();
804	Int iShiftX = m_uiSubSampExpX + 2;
805	Int iAddX = ( 1 << iShiftX ) >> 1;
806	for( Int iY = 0; iY < iHeight; iY++, pRefSamples += iRefStride, pCurSamples += iCurStride )
807	{
808	for( Int iXRef = 0; iXRef < iWidth; iXRef++ )
809	{
810	Int iDepth = pRefSamples[ iXRef ];
811	Int iDisp = xGetDisparityFromVirtDepth( iRefViewIdx, iDepth );
812	Int iXCur = iXRef - ( ( iDisp + iAddX ) >> iShiftX );
813	if( iXCur >= 0 && iXCur < iWidth && iDepth > pCurSamples[ iXCur ] )
814	{
815	pCurSamples[ iXCur ] = iDepth;
816	}
817	}
818	}
819	Bool bUndefined = xFillDepthMapHoles( pcCur );
820	pcCurDepthMap->setBorderExtension( false );
821	pcCurDepthMap->extendPicBorder ();
822	return bUndefined;
823	}
824
825
826	Bool
827	TComDepthMapGenerator::xPredictDepthMap( TComPic* pcPic )
828	{
829	for( UInt uiCUAddr = 0; uiCUAddr < pcPic->getPicSym()->getNumberOfCUsInFrame(); uiCUAddr++ )
830	{
831	TComDataCU* pcCU = pcPic->getCU( uiCUAddr );
832	xPredictCUDepthMap( pcCU, 0, 0 );
833	}
834	Bool bUndefined = xFillDepthMapHoles( pcPic );
835	pcPic->getPredDepthMap()->setBorderExtension( false );
836	pcPic->getPredDepthMap()->extendPicBorder ();
837	return bUndefined;
838	}
839
840
841	Bool
842	TComDepthMapGenerator::xFillDepthMapHoles( TComPic* pcPic )
843	{
844	Bool bUndefined = false;
845	TComPicYuv* pcDepthMap = pcPic->getPredDepthMap ();
846	Int iWidth = pcDepthMap->getWidth ();
847	Int iHeight = pcDepthMap->getHeight ();
848	Int iStride = pcDepthMap->getStride ();
849	Pel* pDMSamples = pcDepthMap->getLumaAddr ( 0 );
850	// horizontal
851	for( Int iY = 0; iY < iHeight && !bUndefined; iY++, pDMSamples += iStride )
852	{
853	for( Int iX = 0; iX < iWidth; iX++ )
854	{
855	if( pDMSamples[ iX ] == PDM_UNDEFINED_DEPTH )
856	{
857	Int iE;
858	for( iE = iX + 1; iE < iWidth; iE++ )
859	{
860	if( pDMSamples[ iE ] != PDM_UNDEFINED_DEPTH )
861	{
862	break;
863	}
864	}
865	if( iX > 0 \|\| iE < iWidth )
866	{
867	Int iDepth;
868	if ( iX > 0 && iE < iWidth ) iDepth = ( pDMSamples[ iX-1 ] < pDMSamples[ iE ] ? pDMSamples[ iX-1 ] : pDMSamples[ iE ] );
869	else if( iX > 0 ) iDepth = pDMSamples[ iX-1 ];
870	else /( iE < iWidth )/ iDepth = pDMSamples[ iE ];
871	for( Int iZ = iX; iZ < iE; iZ++ )
872	{
873	pDMSamples[ iZ ] = iDepth;
874	}
875	}
876	else
877	{
878	bUndefined = true;
879	break;
880	}
881	iX = iE - 1;
882	}
883	}
884	}
885
886	if( bUndefined && m_uiCurrViewId )
887	{
888	pDMSamples = pcDepthMap->getLumaAddr( 0 );
889	Int iMiddleOrgDpth = ( 1 << m_uiOrgDepthBitDepth ) >> 1;
890	Int iMiddleDepth = xGetVirtDepthFromOrigDepth( m_uiCurrViewId, iMiddleOrgDpth );
891	for( Int iY = 0; iY < iHeight; iY++, pDMSamples += iStride )
892	{
893	for( Int iX = 0; iX < iWidth; iX++ )
894	{
895	pDMSamples[ iX ] = iMiddleDepth;
896	}
897	}
898	}
899	return bUndefined;
900	}
901
902
903	Void
904	TComDepthMapGenerator::xClearDepthMap( TComPic* pcPic, Int iVal )
905	{
906	TComPicYuv* pcDepthMap = pcPic->getPredDepthMap ();
907	Int iWidth = pcDepthMap->getWidth ();
908	Int iHeight = pcDepthMap->getHeight ();
909	Int iStride = pcDepthMap->getStride ();
910	Pel* pDMSamples = pcDepthMap->getLumaAddr ( 0 );
911	for( Int iY = 0; iY < iHeight; iY++, pDMSamples += iStride )
912	{
913	for( Int iX = 0; iX < iWidth; iX++ )
914	{
915	pDMSamples[ iX ] = iVal;
916	}
917	}
918	pcDepthMap->setBorderExtension( false );
919	pcDepthMap->extendPicBorder ();
920	}
921
922	Void
923	TComDepthMapGenerator::xSetChroma( TComPicYuv* pcPic, Int iVal )
924	{
925	Int iWidth = pcPic->getWidth () >> 1;
926	Int iHeight = pcPic->getHeight () >> 1;
927	Int iStride = pcPic->getCStride ();
928	Pel* pCbSamples = pcPic->getCbAddr ( 0 );
929	Pel* pCrSamples = pcPic->getCrAddr ( 0 );
930	for( Int iY = 0; iY < iHeight; iY++, pCbSamples += iStride, pCrSamples += iStride )
931	{
932	for( Int iX = 0; iX < iWidth; iX++ )
933	{
934	pCbSamples[ iX ] = pCrSamples[ iX ] = iVal;
935	}
936	}
937	}
938
939
940
941
942
943
944
945	/===============================================
946	===== =====
947	===== C U p r e d i c t i o n s =====
948	===== =====
949	===============================================/
950
951	Void
952	TComDepthMapGenerator::xPredictCUDepthMap( TComDataCU* pcCU, UInt uiDepth, UInt uiAbsPartIdx )
953	{
954	UInt uiLPelX = pcCU->getCUPelX() + g_auiRasterToPelX[ g_auiZscanToRaster[ uiAbsPartIdx ] ];
955	UInt uiTPelY = pcCU->getCUPelY() + g_auiRasterToPelY[ g_auiZscanToRaster[ uiAbsPartIdx ] ];
956	UInt uiRPelX = uiLPelX + ( g_uiMaxCUWidth >> uiDepth ) - 1;
957	UInt uiBPelY = uiTPelY + ( g_uiMaxCUHeight >> uiDepth ) - 1;
958	Bool bBoundary = ( uiRPelX >= pcCU->getSlice()->getSPS()->getPicWidthInLumaSamples() \|\| uiBPelY >= pcCU->getSlice()->getSPS()->getPicHeightInLumaSamples() );
959	Bool bSplit = ( ( uiDepth < pcCU->getDepth( uiAbsPartIdx ) && uiDepth < ( g_uiMaxCUDepth - g_uiAddCUDepth ) ) \|\| bBoundary );
960	if( bSplit )
961	{
962	UInt uiQNumParts = ( pcCU->getPic()->getNumPartInCU() >> ( uiDepth << 1 ) ) >> 2;
963	for ( UInt uiPartUnitIdx = 0; uiPartUnitIdx < 4; uiPartUnitIdx++, uiAbsPartIdx += uiQNumParts )
964	{
965	uiLPelX = pcCU->getCUPelX() + g_auiRasterToPelX[ g_auiZscanToRaster[ uiAbsPartIdx ] ];
966	uiTPelY = pcCU->getCUPelY() + g_auiRasterToPelY[ g_auiZscanToRaster[ uiAbsPartIdx ] ];
967	Bool bInside = ( uiLPelX < pcCU->getSlice()->getSPS()->getPicWidthInLumaSamples() && uiTPelY < pcCU->getSlice()->getSPS()->getPicHeightInLumaSamples() );
968	if( bInside )
969	{
970	xPredictCUDepthMap( pcCU, uiDepth + 1, uiAbsPartIdx );
971	}
972	}
973	return;
974	}
975
976	//--- set sub-CU and sub-depth-map ---
977	TComDataCU* pcSubCU = m_ppcCU [ uiDepth ];
978	TComYuv* pcSubDM = m_ppcYuv[ uiDepth ];
979	TComPicYuv* pcPicDM = pcCU->getPic()->getPredDepthMap();
980	UInt uiCUAddr = pcCU->getAddr();
981	pcSubCU->copySubCU( pcCU, uiAbsPartIdx, uiDepth );
982
983	//--- update depth map ---
984	switch( pcSubCU->getPredictionMode( 0 ) )
985	{
986	case MODE_INTRA:
987	xIntraPredictCUDepthMap( pcSubCU, pcSubDM );
988	break;
989	case MODE_SKIP:
990	case MODE_INTER:
991	xInterPredictCUDepthMap( pcSubCU, pcSubDM );
992	break;
993	default:
994	AOT( true );
995	break;
996	}
997
998	//--- copy sub-depth-map ---
999	pcSubDM->copyToPicYuv( pcPicDM, uiCUAddr, uiAbsPartIdx );
1000	}
1001
1002
1003	Void
1004	TComDepthMapGenerator::xIntraPredictCUDepthMap( TComDataCU* pcCU, TComYuv* pcCUDepthMap )
1005	{
1006	UInt uiInitTrDepth = ( pcCU->getPartitionSize( 0 ) == SIZE_2Nx2N ? 0 : 1 );
1007	UInt uiNumPart = pcCU->getNumPartInter ();
1008	UInt uiNumQParts = pcCU->getTotalNumPart () >> 2;
1009	for( UInt uiPU = 0; uiPU < uiNumPart; uiPU++ )
1010	{
1011	xIntraPredictBlkDepthMap( pcCU, pcCUDepthMap, uiPU * uiNumQParts, uiInitTrDepth );
1012	}
1013	}
1014
1015
1016	Void
1017	TComDepthMapGenerator::xInterPredictCUDepthMap( TComDataCU* pcCU, TComYuv* pcCUDepthMap )
1018	{
1019	for( UInt uiPartIdx = 0; uiPartIdx < pcCU->getNumPartInter(); uiPartIdx++ )
1020	{
1021	xInterPredictPUDepthMap( pcCU, pcCUDepthMap, uiPartIdx );
1022	}
1023	}
1024
1025
1026
1027
1028
1029
1030
1031	/=====================================================================
1032	===== =====
1033	===== P U - a n d B l o c k p r e d i c t i o n s =====
1034	===== =====
1035	=====================================================================/
1036
1037	Void
1038	TComDepthMapGenerator::xIntraPredictBlkDepthMap( TComDataCU* pcCU, TComYuv* pcCUDepthMap, UInt uiAbsPartIdx, UInt uiTrDepth )
1039	{
1040	UInt uiFullDepth = pcCU->getDepth( 0 ) + uiTrDepth;
1041	UInt uiTrMode = pcCU->getTransformIdx( uiAbsPartIdx );
1042	if( uiTrMode == uiTrDepth )
1043	{
1044	UInt uiWidth = pcCU->getWidth ( 0 ) >> ( uiTrDepth + m_uiSubSampExpX );
1045	UInt uiHeight = pcCU->getHeight( 0 ) >> ( uiTrDepth + m_uiSubSampExpY );
1046	UInt uiStride = pcCUDepthMap->getStride ();
1047	UInt uiBlkX = g_auiRasterToPelX[ g_auiZscanToRaster[ uiAbsPartIdx ] ] >> m_uiSubSampExpX;
1048	UInt uiBlkY = g_auiRasterToPelY[ g_auiZscanToRaster[ uiAbsPartIdx ] ] >> m_uiSubSampExpY;
1049	Pel* pDepthMap = pcCUDepthMap->getLumaAddr() + uiBlkY * pcCUDepthMap->getStride() + uiBlkX;
1050	UInt uiLumaPredMode = pcCU->getLumaIntraDir ( uiAbsPartIdx );
1051	Bool bAboveAvail = false;
1052	Bool bLeftAvail = false;
1053	pcCU->getPattern()->initPattern ( pcCU, uiTrDepth, uiAbsPartIdx, true );
1054	pcCU->getPattern()->initAdiPattern( pcCU, uiAbsPartIdx, uiTrDepth,
1055	m_pcPrediction->getPredicBuf (),
1056	m_pcPrediction->getPredicBufWidth (),
1057	m_pcPrediction->getPredicBufHeight (),
1058	bAboveAvail, bLeftAvail, false, true, m_uiSubSampExpX, m_uiSubSampExpY );
1059	m_pcPrediction->predIntraDepthAng ( pcCU->getPattern(), uiLumaPredMode, pDepthMap, uiStride, uiWidth, uiHeight ); // could be replaced with directional intra prediction
1060	// using "predIntraLumaAng", but note:
1061	// - need to take care of neighbours with undefined depth
1062	// - special case for wedgelet mode (if available in normal views)
1063	// copy to picture array (for next intra prediction block)
1064	UInt uiZOrderIdx = pcCU->getZorderIdxInCU() + uiAbsPartIdx;
1065	Pel* pPicDepthMap = pcCU->getPic()->getPredDepthMap()->getLumaAddr( pcCU->getAddr(), uiZOrderIdx );
1066	Int iPicStride = pcCU->getPic()->getPredDepthMap()->getStride ();
1067	for( UInt uiY = 0; uiY < uiHeight; uiY++, pDepthMap += uiStride, pPicDepthMap += iPicStride )
1068	{
1069	for( UInt uiX = 0; uiX < uiWidth; uiX++ )
1070	{
1071	pPicDepthMap[ uiX ] = pDepthMap[ uiX ];
1072	}
1073	}
1074	}
1075	else
1076	{
1077	UInt uiNumQPart = pcCU->getPic()->getNumPartInCU() >> ( ( uiFullDepth + 1 ) << 1 );
1078	for( UInt uiPart = 0; uiPart < 4; uiPart++ )
1079	{
1080	xIntraPredictBlkDepthMap( pcCU, pcCUDepthMap, uiAbsPartIdx + uiPart * uiNumQPart, uiTrDepth + 1 );
1081	}
1082	}
1083	}
1084
1085
1086	Void
1087	TComDepthMapGenerator::xInterPredictPUDepthMap( TComDataCU* pcCU, TComYuv* pcCUDepthMap, UInt uiPartIdx )
1088	{
1089	if ( pcCU->getSlice()->getSPS()->getViewId() )
1090	{
1091	AOF( m_uiCurrViewId == pcCU->getSlice()->getSPS()->getViewId() );
1092	// check for interview prediction
1093	Int iWidth;
1094	Int iHeight;
1095	UInt uiAbsPartIdx;
1096	pcCU->getPartIndexAndSize( uiPartIdx, uiAbsPartIdx, iWidth, iHeight );
1097	TComCUMvField* aiCurrMvField[2] = { pcCU->getCUMvField( REF_PIC_LIST_0 ), pcCU->getCUMvField( REF_PIC_LIST_1 ) };
1098	Int aiCurrRefIdx [2] = { aiCurrMvField[0]->getRefIdx( uiAbsPartIdx ), aiCurrMvField[1]->getRefIdx( uiAbsPartIdx ) };
1099	Bool abCurrIntView[2] = { aiCurrRefIdx[0] >= 0 && pcCU->getSlice()->getRefPic( REF_PIC_LIST_0, aiCurrRefIdx[0] )->getSPS()->getViewId() != m_uiCurrViewId,
1100	aiCurrRefIdx[1] >= 0 && pcCU->getSlice()->getRefPic( REF_PIC_LIST_1, aiCurrRefIdx[1] )->getSPS()->getViewId() != m_uiCurrViewId };
1101	Bool bUsesInterViewPrd = ( abCurrIntView[0] \|\| abCurrIntView[1] );
1102	if( bUsesInterViewPrd )
1103	{
1104	xIViewPUDepthMapUpdate ( pcCU, pcCUDepthMap, uiPartIdx );
1105	}
1106	else
1107	{
1108	#if PDM_NO_INTER_UPDATE
1109	xInterPUDepthMapPrediction( pcCU, pcCUDepthMap, uiPartIdx );
1110	#else
1111	xInterPUDepthMapUpdate ( pcCU, pcCUDepthMap, uiPartIdx );
1112	#endif
1113	}
1114	}
1115	else
1116	{
1117	xInterPUDepthMapPrediction( pcCU, pcCUDepthMap, uiPartIdx );
1118	}
1119	}
1120
1121
1122	Void
1123	TComDepthMapGenerator::xIViewPUDepthMapUpdate( TComDataCU* pcCU, TComYuv* pcCUDepthMap, UInt uiPartIdx )
1124	{
1125	// get width, height, and part address
1126	Int iWidth;
1127	Int iHeight;
1128	UInt uiAbsPartIdx;
1129	pcCU->getPartIndexAndSize( uiPartIdx, uiAbsPartIdx, iWidth, iHeight );
1130	iWidth >>= m_uiSubSampExpX;
1131	iHeight >>= m_uiSubSampExpY;
1132
1133	// get depth values
1134	Int iDepthValue = PDM_UNDEFINED_DEPTH;
1135	Int aiPrdDepth[2] = { PDM_UNDEFINED_DEPTH, PDM_UNDEFINED_DEPTH };
1136	for( Int iRefListId = 0; iRefListId < 2; iRefListId++ )
1137	{
1138	RefPicList eRefPicList = RefPicList( iRefListId );
1139	TComCUMvField* pcCUMvField = pcCU->getCUMvField( eRefPicList );
1140	Int iRefIdx = pcCUMvField->getRefIdx( uiAbsPartIdx );
1141	UInt uiBaseId = ( iRefIdx >= 0 ? pcCU->getSlice()->getRefPic( eRefPicList, iRefIdx )->getSPS()->getViewId() : MAX_VIEW_NUM );
1142	Bool bInterview = ( iRefIdx >= 0 && uiBaseId < m_uiCurrViewId );
1143	if( bInterview )
1144	{
1145	Int iMvX = pcCUMvField->getMv( uiAbsPartIdx ).getHor();
1146	aiPrdDepth[ iRefListId ] = xGetVirtDepthFromDisparity( uiBaseId, iMvX );
1147	}
1148	}
1149	if( aiPrdDepth[ 0 ] != PDM_UNDEFINED_DEPTH && aiPrdDepth[ 1 ] != PDM_UNDEFINED_DEPTH )
1150	{
1151	iDepthValue = ( aiPrdDepth[ 0 ] + aiPrdDepth[ 1 ] + 1 ) >> 1;
1152	}
1153	else
1154	{
1155	iDepthValue = ( aiPrdDepth[ 0 ] != PDM_UNDEFINED_DEPTH ? aiPrdDepth[ 0 ] : aiPrdDepth[ 1 ] );
1156	AOT( iDepthValue == PDM_UNDEFINED_DEPTH );
1157	}
1158	iDepthValue = Max( 0, Min( PDM_MAX_ABS_VIRT_DEPTH, iDepthValue ) );
1159
1160	// set depth map for PU
1161	UInt uiBlkX = g_auiRasterToPelX[ g_auiZscanToRaster[ uiAbsPartIdx ] ] >> m_uiSubSampExpX;
1162	UInt uiBlkY = g_auiRasterToPelY[ g_auiZscanToRaster[ uiAbsPartIdx ] ] >> m_uiSubSampExpY;
1163	Pel* pDMSamples = pcCUDepthMap->getLumaAddr() + uiBlkY * pcCUDepthMap->getStride() + uiBlkX;
1164	Int iStride = pcCUDepthMap->getStride ();
1165	for( Int iY = 0; iY < iHeight; iY++, pDMSamples += iStride )
1166	{
1167	for( Int iX = 0; iX < iWidth; iX++)
1168	{
1169	pDMSamples[ iX ] = (Pel)iDepthValue;
1170	}
1171	}
1172	}
1173
1174
1175	Void
1176	TComDepthMapGenerator::xInterPUDepthMapUpdate( TComDataCU* pcCU, TComYuv* pcCUDepthMap, UInt uiPartIdx )
1177	{
1178	const Int iMaxAbsDeltaMvY = 8 << 2;
1179
1180	//===== determine block parameters for current access unit and current view =====
1181	Int iWidth;
1182	Int iHeight;
1183	UInt uiAbsPartIdx;
1184	pcCU->getPartIndexAndSize ( uiPartIdx, uiAbsPartIdx, iWidth, iHeight );
1185	UInt uiCurrViewId = pcCU->getSlice()->getSPS()->getViewId();
1186	Int iNum4x4BlksY = iHeight >> 2;
1187	Int iNum4x4BlksX = iWidth >> 2;
1188	iWidth >>= m_uiSubSampExpX;
1189	iHeight >>= m_uiSubSampExpY;
1190
1191	TComPicYuv* pcCurrDepthMap = pcCU->getPic()->getPredDepthMap();
1192	Pel* piCurrDepthMap = pcCurrDepthMap->getLumaAddr();
1193	Int iCurrStride = pcCurrDepthMap->getStride();
1194	TComCUMvField* aiCurrMvField[2] = { pcCU->getCUMvField( REF_PIC_LIST_0 ), pcCU->getCUMvField( REF_PIC_LIST_1 ) };
1195	Int aiCurrRefIdx [2] = { aiCurrMvField[0]->getRefIdx( uiAbsPartIdx ), aiCurrMvField[1]->getRefIdx( uiAbsPartIdx ) };
1196	Int iMinCurrListId = ( aiCurrRefIdx [0] < 0 ? 1 : 0 );
1197	Int iMaxCurrListId = ( aiCurrRefIdx [1] < 0 ? 0 : 1 );
1198	Int iCurrPUPosX;
1199	Int iCurrPUPosY;
1200	pcCurrDepthMap->getTopLeftSamplePos( pcCU->getAddr(), pcCU->getZorderIdxInCU() + uiAbsPartIdx, iCurrPUPosX, iCurrPUPosY );
1201	AOT( uiCurrViewId != m_uiCurrViewId );
1202	AOT( iMinCurrListId > iMaxCurrListId );
1203	AOT( aiCurrRefIdx[0] >= 0 && pcCU->getSlice()->getRefPic( REF_PIC_LIST_0, aiCurrRefIdx[0] )->getSPS()->getViewId() != uiCurrViewId );
1204	AOT( aiCurrRefIdx[1] >= 0 && pcCU->getSlice()->getRefPic( REF_PIC_LIST_1, aiCurrRefIdx[1] )->getSPS()->getViewId() != uiCurrViewId );
1205
1206	//===== determine parameters for current access unit and base view =====
1207	AOF( m_auiBaseIdList.size() );
1208	UInt uiBaseId = m_auiBaseIdList[ 0 ];
1209	TComPic* pcBasePic = m_pcAUPicAccess->getPic( uiBaseId );
1210	AOF( pcBasePic );
1211	TComPicYuv* pcBaseDepthMap = pcBasePic->getPredDepthMap();
1212	TComPicYuv* pcBaseRecPic = pcBasePic->getPicYuvRec ();
1213	Pel* piBaseDepthMap = pcBaseDepthMap->getLumaAddr();
1214	Int iBaseStride = pcBaseDepthMap->getStride();
1215	Int iShiftX = m_uiSubSampExpX + 2;
1216	Int iShiftY = m_uiSubSampExpY + 2;
1217	Int iAddX = ( 1 << iShiftX ) >> 1;
1218	Int iAddY = ( 1 << iShiftY ) >> 1;
1219
1220	//===== initialize 4x4 block arrays =====
1221	for( Int i4x4BlkY = 0; i4x4BlkY < iNum4x4BlksY; i4x4BlkY++ )
1222	{
1223	for( Int i4x4BlkX = 0; i4x4BlkX < iNum4x4BlksX; i4x4BlkX++ )
1224	{
1225	m_aabDepthSet[ i4x4BlkY ][ i4x4BlkX ] = false;
1226	m_aai4x4Depth[ i4x4BlkY ][ i4x4BlkX ] = PDM_UNDEFINED_DEPTH;
1227	}
1228	}
1229	Int iNum4x4Set = 0;
1230
1231	//===== determine depth based on 4x4 blocks =====
1232	for( Int i4x4BlkY = 0; i4x4BlkY < iNum4x4BlksY; i4x4BlkY++ )
1233	{
1234	for( Int i4x4BlkX = 0; i4x4BlkX < iNum4x4BlksX; i4x4BlkX++ )
1235	{
1236	// position parameters
1237	Int iCurrBlkPosX = iCurrPUPosX + ( ( i4x4BlkX << 2 ) >> m_uiSubSampExpX );
1238	Int iCurrBlkPosY = iCurrPUPosY + ( ( i4x4BlkY << 2 ) >> m_uiSubSampExpY );
1239	Int iCurrSamplePosX = iCurrBlkPosX + ( 1 >> m_uiSubSampExpX );
1240	Int iCurrSamplePosY = iCurrBlkPosY + ( 1 >> m_uiSubSampExpY );
1241	Int iCurrPredDepth = piCurrDepthMap[ iCurrSamplePosY * iCurrStride + iCurrSamplePosX ];
1242	Int iCurrPredDisp = xGetDisparityFromVirtDepth( uiBaseId, iCurrPredDepth );
1243	Int iBaseSamplePosX = iCurrSamplePosX + ( ( iCurrPredDisp + iAddX ) >> iShiftX );
1244	Int iBaseSamplePosY = iCurrSamplePosY;
1245	iBaseSamplePosX = Clip3( 0, pcBaseDepthMap->getWidth () - 1, iBaseSamplePosX );
1246	iBaseSamplePosY = Clip3( 0, pcBaseDepthMap->getHeight() - 1, iBaseSamplePosY );
1247
1248	// check for occlusion
1249	if( piBaseDepthMap[ iBaseSamplePosY * iBaseStride + iBaseSamplePosX ] != iCurrPredDepth )
1250	{
1251	continue;
1252	}
1253
1254	// determine base motion data and check prediction mode
1255	Int iBaseCUAddr;
1256	Int iBaseAbsPartIdx;
1257	pcBaseRecPic->getCUAddrAndPartIdx( iBaseSamplePosX << m_uiSubSampExpX, iBaseSamplePosY << m_uiSubSampExpY, iBaseCUAddr, iBaseAbsPartIdx );
1258	TComDataCU* pcBaseCU = pcBasePic->getCU( iBaseCUAddr );
1259	if( pcBaseCU->getPredictionMode( iBaseAbsPartIdx ) != MODE_INTER && pcBaseCU->getPredictionMode( iBaseAbsPartIdx ) != MODE_SKIP )
1260	{
1261	continue;
1262	}
1263
1264	// check whether base was inter-view predicted
1265	TComCUMvField* aiBaseMvField[2] = { pcBaseCU->getCUMvField( REF_PIC_LIST_0 ), pcBaseCU->getCUMvField( REF_PIC_LIST_1 ) };
1266	Int aiBaseRefIdx [2] = { aiBaseMvField[0]->getRefIdx( iBaseAbsPartIdx ), aiBaseMvField[1]->getRefIdx( iBaseAbsPartIdx ) };
1267	Bool abBaseIntView[2] = { aiBaseRefIdx[0] >= 0 && pcBaseCU->getSlice()->getRefPic( REF_PIC_LIST_0, aiBaseRefIdx[0] )->getSPS()->getViewId() != uiBaseId,
1268	aiBaseRefIdx[1] >= 0 && pcBaseCU->getSlice()->getRefPic( REF_PIC_LIST_1, aiBaseRefIdx[1] )->getSPS()->getViewId() != uiBaseId };
1269	if( abBaseIntView[0] \|\| abBaseIntView[1] )
1270	{ // current depth is reliable
1271	m_aai4x4Depth[i4x4BlkY][i4x4BlkX] = iCurrPredDepth;
1272	m_aabDepthSet[i4x4BlkY][i4x4BlkX] = true;
1273	iNum4x4Set++;
1274	continue;
1275	}
1276
1277	// determine depth candidates using an approximate 4-point relationship (if appropriate)
1278	std::vector<Int> aiDepthCand;
1279	Int iMinBaseListId = ( aiBaseRefIdx [0] < 0 ? 1 : 0 );
1280	Int iMaxBaseListId = ( aiBaseRefIdx [1] < 0 ? 0 : 1 );
1281	AOT( iMinBaseListId > iMaxBaseListId );
1282	for( Int iCurrRefListId = iMinCurrListId; iCurrRefListId <= iMaxCurrListId; iCurrRefListId++ )
1283	{
1284	RefPicList eCurrRefPicList = RefPicList( iCurrRefListId );
1285	Int iCurrRefPoc = pcCU->getSlice()->getRefPOC( eCurrRefPicList, aiCurrRefIdx[ iCurrRefListId ] );
1286	TComPic* pcCurrRefPic = pcCU->getSlice()->getRefPic( eCurrRefPicList, aiCurrRefIdx[ iCurrRefListId ] );
1287	TComPicYuv* pcCurrRefDMap = pcCurrRefPic->getPredDepthMap();
1288	Pel* piCurrRefDMap = pcCurrRefDMap->getLumaAddr();
1289	Int iCurrRefStride = pcCurrRefDMap->getStride();
1290	TComMv rcCurrMv = aiCurrMvField[ iCurrRefListId ]->getMv( uiAbsPartIdx );
1291	Int iCurrRefSamplePosX = iCurrSamplePosX + ( ( rcCurrMv.getHor() + iAddX ) >> iShiftX );
1292	Int iCurrRefSamplePosY = iCurrSamplePosY + ( ( rcCurrMv.getVer() + iAddY ) >> iShiftY );
1293	Int iCurrRefSamplePosXC = Clip3( 0, pcCurrRefDMap->getWidth () - 1, iCurrRefSamplePosX );
1294	Int iCurrRefSamplePosYC = Clip3( 0, pcCurrRefDMap->getHeight() - 1, iCurrRefSamplePosY );
1295	Int iCurrRefDepth = piCurrRefDMap[ iCurrRefSamplePosYC * iCurrRefStride + iCurrRefSamplePosXC ];
1296
1297	for( Int iBaseRefListId = iMinBaseListId; iBaseRefListId <= iMaxBaseListId; iBaseRefListId++ )
1298	{
1299	RefPicList eBaseRefPicList = RefPicList( iBaseRefListId );
1300	Int iBaseRefPoc = pcBaseCU->getSlice()->getRefPOC( eBaseRefPicList, aiBaseRefIdx[ iBaseRefListId ] );
1301
1302	if( iCurrRefPoc == iBaseRefPoc )
1303	{
1304	// location and depth for path currView/currAU -> currView/refAU -> baseView/refAU
1305	Int iCurrRefDisp = xGetDisparityFromVirtDepth( uiBaseId, iCurrRefDepth );
1306	Int iBaseRefSamplePosX = iCurrRefSamplePosX + ( ( iCurrRefDisp + iAddX ) >> iShiftX );
1307	Int iBaseRefSamplePosY = iCurrRefSamplePosY;
1308	TComPic* pcBaseRefPic = pcBaseCU->getSlice()->getRefPic( eBaseRefPicList, aiBaseRefIdx[ iBaseRefListId ] );
1309	TComPicYuv* pcBaseRefDMap = pcBaseRefPic->getPredDepthMap();
1310	Pel* piBaseRefDMap = pcBaseRefDMap->getLumaAddr();
1311	Int iBaseRefStride = pcBaseRefDMap->getStride();
1312	iBaseRefSamplePosX = Clip3( 0, pcBaseRefDMap->getWidth () - 1, iBaseRefSamplePosX );
1313	iBaseRefSamplePosY = Clip3( 0, pcBaseRefDMap->getHeight() - 1, iBaseRefSamplePosY );
1314	Int iBaseRefDepth = piBaseRefDMap[ iBaseRefSamplePosY * iBaseRefStride + iBaseRefSamplePosX ];
1315
1316	// location and depth for path currView/currAU ->baseView/currAU -> baseView/refAU
1317	TComMv rcBaseMv = aiBaseMvField[ iBaseRefListId ]->getMv( iBaseAbsPartIdx );
1318	Int iAbsDeltaMvY = ( rcBaseMv.getAbsVer() > rcCurrMv.getVer() ? rcBaseMv.getAbsVer() - rcCurrMv.getVer() : rcCurrMv.getVer() - rcBaseMv.getAbsVer() );
1319
1320	// check reliability (occlusion in reference access unit / vertical motion vector difference)
1321	if( iBaseRefDepth != iCurrRefDepth \|\| iAbsDeltaMvY > iMaxAbsDeltaMvY )
1322	{
1323	continue;
1324	}
1325
1326	// determine new depth
1327	Int iCurrCandDisp = iCurrRefDisp + rcCurrMv.getHor() - rcBaseMv.getHor();
1328	Int iCurrCandDepth = xGetVirtDepthFromDisparity( uiBaseId, iCurrCandDisp );
1329	aiDepthCand.push_back( iCurrCandDepth );
1330	} // iCurrRefPoc == iBaseRefPoc
1331	} // iBaseRefListId
1332	} // iCurrRefListId
1333
1334	// set depth for 4x4 block
1335	if( aiDepthCand.size() )
1336	{ // get depth with minimum change (probably most reliable)
1337	Int iMinAbsDepthChange = (1<<30);
1338	Int iDepthForMinChange = (1<<30);
1339	for( UInt uiCandId = 0; uiCandId < (UInt)aiDepthCand.size(); uiCandId++ )
1340	{
1341	Int iAbsDeltaDepth = ( aiDepthCand[uiCandId] > iCurrPredDepth ? aiDepthCand[uiCandId] > iCurrPredDepth : iCurrPredDepth - aiDepthCand[uiCandId] );
1342	if( iAbsDeltaDepth < iMinAbsDepthChange )
1343	{
1344	iMinAbsDepthChange = iAbsDeltaDepth;
1345	iDepthForMinChange = aiDepthCand[uiCandId];
1346	}
1347	}
1348	m_aai4x4Depth[i4x4BlkY][i4x4BlkX] = Min( Max( 0, iDepthForMinChange ), PDM_MAX_ABS_VIRT_DEPTH );
1349	m_aabDepthSet[i4x4BlkY][i4x4BlkX] = true;
1350	iNum4x4Set++;
1351	}
1352	} // i4x4BlkX
1353	} // i4x4BlkY
1354
1355	//===== fall back (take original depth for 4x4 blocks) ====
1356	if( iNum4x4Set < Max( 1, ( iNum4x4BlksY * iNum4x4BlksX ) >> 2 ) )
1357	{
1358	iNum4x4Set = 0;
1359	for( Int i4x4BlkY = 0; i4x4BlkY < iNum4x4BlksY; i4x4BlkY++ )
1360	{
1361	for( Int i4x4BlkX = 0; i4x4BlkX < iNum4x4BlksX; i4x4BlkX++ )
1362	{
1363	Int iCurrSamplePosX = iCurrPUPosX + ( ( ( i4x4BlkX << 2 ) + 1 ) >> m_uiSubSampExpX );
1364	Int iCurrSamplePosY = iCurrPUPosY + ( ( ( i4x4BlkY << 2 ) + 1 ) >> m_uiSubSampExpY );
1365	m_aai4x4Depth[i4x4BlkY][i4x4BlkX] = piCurrDepthMap[ iCurrSamplePosY * iCurrStride + iCurrSamplePosX ];
1366	m_aabDepthSet[i4x4BlkY][i4x4BlkX] = true;
1367	iNum4x4Set++;
1368	}
1369	}
1370	}
1371
1372	#if PDM_ONE_DEPTH_PER_PU
1373	//===== set average in 4x4 depth array =====
1374	Int iSum = 0;
1375	for( Int i4x4BlkY = 0; i4x4BlkY < iNum4x4BlksY; i4x4BlkY++ )
1376	{
1377	for( Int i4x4BlkX = 0; i4x4BlkX < iNum4x4BlksX; i4x4BlkX++ )
1378	{
1379	if( m_aabDepthSet[ i4x4BlkY ][ i4x4BlkX ] )
1380	{
1381	iSum += m_aai4x4Depth[ i4x4BlkY ][ i4x4BlkX ];
1382	}
1383	}
1384	}
1385	Int iDepth = ( iSum + ( iNum4x4Set >> 1 ) ) / iNum4x4Set;
1386	iNum4x4Set = iNum4x4BlksY * iNum4x4BlksX;
1387	for( Int i4x4BlkY = 0; i4x4BlkY < iNum4x4BlksY; i4x4BlkY++ )
1388	{
1389	for( Int i4x4BlkX = 0; i4x4BlkX < iNum4x4BlksX; i4x4BlkX++ )
1390	{
1391	m_aai4x4Depth[ i4x4BlkY ][ i4x4BlkX ] = iDepth;
1392	m_aabDepthSet[ i4x4BlkY ][ i4x4BlkX ] = true;
1393	}
1394	}
1395	#endif
1396
1397	//===== complete depth arrays =====
1398	while( iNum4x4BlksY * iNum4x4BlksX - iNum4x4Set )
1399	{
1400	for( Int i4x4BlkY = 0; i4x4BlkY < iNum4x4BlksY; i4x4BlkY++ )
1401	{
1402	for( Int i4x4BlkX = 0; i4x4BlkX < iNum4x4BlksX; i4x4BlkX++ )
1403	{
1404	if( !m_aabDepthSet[ i4x4BlkY ][ i4x4BlkX ] )
1405	{ // could also use minimum of neighbours (occlusions)
1406	Int iNumNeighbours = 0;
1407	Int iSumNeighbours = 0;
1408	if( i4x4BlkY > 0 && m_aabDepthSet[ i4x4BlkY-1 ][ i4x4BlkX ] ) { iSumNeighbours += m_aai4x4Depth[ i4x4BlkY-1 ][ i4x4BlkX ]; iNumNeighbours++; }
1409	if( i4x4BlkY < iNum4x4BlksY-1 && m_aabDepthSet[ i4x4BlkY+1 ][ i4x4BlkX ] ) { iSumNeighbours += m_aai4x4Depth[ i4x4BlkY+1 ][ i4x4BlkX ]; iNumNeighbours++; }
1410	if( i4x4BlkX > 0 && m_aabDepthSet[ i4x4BlkY ][ i4x4BlkX-1 ] ) { iSumNeighbours += m_aai4x4Depth[ i4x4BlkY ][ i4x4BlkX-1 ]; iNumNeighbours++; }
1411	if( i4x4BlkX < iNum4x4BlksX-1 && m_aabDepthSet[ i4x4BlkY ][ i4x4BlkX+1 ] ) { iSumNeighbours += m_aai4x4Depth[ i4x4BlkY ][ i4x4BlkX+1 ]; iNumNeighbours++; }
1412	if( iNumNeighbours )
1413	{
1414	m_aai4x4Depth[ i4x4BlkY ][ i4x4BlkX ] = ( iSumNeighbours + ( iNumNeighbours >> 1 ) ) / iNumNeighbours;
1415	m_aabDepthSet[ i4x4BlkY ][ i4x4BlkX ] = true;
1416	iNum4x4Set++;
1417	}
1418	}
1419	}
1420	}
1421	}
1422
1423	//===== set depth values =====
1424	UInt uiBlkX = g_auiRasterToPelX[ g_auiZscanToRaster[ uiAbsPartIdx ] ] >> m_uiSubSampExpX;
1425	UInt uiBlkY = g_auiRasterToPelY[ g_auiZscanToRaster[ uiAbsPartIdx ] ] >> m_uiSubSampExpY;
1426	Pel* piDepthMap = pcCUDepthMap->getLumaAddr() + uiBlkY * pcCUDepthMap->getStride() + uiBlkX;
1427	Int iCUStride = pcCUDepthMap->getStride ();
1428	for( Int iRow = 0; iRow < iHeight; iRow++, piDepthMap += iCUStride )
1429	{
1430	for( Int iCol = 0; iCol < iWidth; iCol++ )
1431	{
1432	piDepthMap[ iCol ] = m_aai4x4Depth[ (iRow << m_uiSubSampExpY) >> 2 ][ (iCol << m_uiSubSampExpX) >> 2 ];
1433	}
1434	}
1435	}
1436
1437
1438	Void
1439	TComDepthMapGenerator::xInterPUDepthMapPrediction( TComDataCU* pcCU, TComYuv* pcCUDepthMap, UInt uiPartIdx )
1440	{
1441	m_pcPrediction->motionCompensation( pcCU, pcCUDepthMap, REF_PIC_LIST_X, (Int)uiPartIdx, true, m_uiSubSampExpX, m_uiSubSampExpY );
1442	}
1443
1444
1445	Bool
1446	TComDepthMapGenerator::xGetPredDepth( TComDataCU* pcCU, UInt uiPartIdx, Int& riPrdDepth, Int* piPosX, Int* piPosY )
1447	{
1448	AOF ( m_bCreated && m_bInit );
1449	AOF ( pcCU );
1450	ROFRS( m_bPDMAvailable, false );
1451
1452	TComSlice* pcSlice = pcCU->getSlice ();
1453	TComPic* pcPic = pcCU->getPic ();
1454	TComSPS* pcSPS = pcSlice->getSPS();
1455	AOF ( pcPic->getPredDepthMap() );
1456	AOF ( pcSPS->getViewId() == m_uiCurrViewId );
1457
1458	//===== get predicted depth and disprity for middle position of current PU =====
1459	UInt uiPartAddr;
1460	Int iWidth;
1461	Int iHeight;
1462	pcCU->getPartIndexAndSize( uiPartIdx, uiPartAddr, iWidth, iHeight );
1463	TComPicYuv* pcPredDepthMap = pcPic->getPredDepthMap();
1464	Pel* piPredDepthMap = pcPredDepthMap->getLumaAddr ( 0 );
1465	Int iCurrStride = pcPredDepthMap->getStride ();
1466	Int iCurrPosX;
1467	Int iCurrPosY;
1468	pcPredDepthMap->getTopLeftSamplePos( pcCU->getAddr(), pcCU->getZorderIdxInCU() + uiPartAddr, iCurrPosX, iCurrPosY );
1469	iCurrPosX += ( ( iWidth >> m_uiSubSampExpX ) - 1 ) >> 1;
1470	iCurrPosY += ( ( iHeight >> m_uiSubSampExpY ) - 1 ) >> 1;
1471	riPrdDepth = piPredDepthMap[ iCurrPosX + iCurrPosY * iCurrStride ];
1472	if( piPosX )
1473	{
1474	*piPosX = iCurrPosX;
1475	}
1476	if( piPosY )
1477	{
1478	*piPosY = iCurrPosY;
1479	}
1480	return true;
1481	}
1482
1483	#endif // DEPTH_MAP_GENERATION
1484

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

Download in other formats: