source: 3DVCSoftware/branches/0.2-poznan-univ/source/Lib/TLibCommon/TComDepthMapGenerator.cpp @ 12

Last change on this file since 12 was 12, checked in by poznan-univ, 12 years ago

Poznan Tools

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