source: 3DVCSoftware/branches/HTM-3.1-LG/source/Lib/TLibCommon/TComDepthMapGenerator.cpp @ 97

Last change on this file since 97 was 97, checked in by lg, 12 years ago

Implemented the Region boundary chain coding (A0070) and R/D selection between Non-Zero Residual and All-Zero Residual Intra Coding (A0087) with macro: "LGE_EDGE_INTRA" and "LG_ZEROINTRADEPTHRESI_M26039"

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