source: 3DVCSoftware/branches/HTM-5.1-dev0/source/Lib/TLibCommon/TComDepthMapGenerator.cpp @ 280

Last change on this file since 280 was 280, checked in by tech, 11 years ago

Integration of branch dev 2.

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