Context navigation

source: 3DVCSoftware/trunk/source/Lib/TLibCommon/TComDepthMapGenerator.cpp @ 28

Visit:

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

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

Download in other formats: