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

Last change on this file since 56 was 56, checked in by hschwarz, 12 years ago

updated trunk (move to HM6.1)

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