Context navigation

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

Visit:

Last change on this file since 331 was 296, checked in by tech, 12 years ago
Reintegrated branch 5.1-dev0 rev. 295.
Property svn:eol-style set to `native`
File size: 80.5 KB

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

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

Download in other formats: