source: 3DVCSoftware/trunk/source/Lib/TLibCommon/TComPrediction.cpp @ 747

Last change on this file since 747 was 724, checked in by tech, 10 years ago

Merged HTM-8.2-dev0@723.

  • Property svn:eol-style set to native
File size: 86.7 KB
RevLine 
[5]1/* The copyright in this software is being made available under the BSD
2 * License, included below. This software may be subject to other third party
3 * and contributor rights, including patent rights, and no such rights are
[56]4 * granted under this license. 
[5]5 *
[608]6 * Copyright (c) 2010-2013, ITU/ISO/IEC
[5]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.
[56]17 *  * Neither the name of the ITU/ISO/IEC nor the names of its contributors may
[5]18 *    be used to endorse or promote products derived from this software without
19 *    specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
31 * THE POSSIBILITY OF SUCH DAMAGE.
32 */
[2]33
34/** \file     TComPrediction.cpp
35    \brief    prediction class
36*/
37
38#include <memory.h>
39#include "TComPrediction.h"
40
[56]41//! \ingroup TLibCommon
42//! \{
43
[2]44// ====================================================================================================================
45// Constructor / destructor / initialize
46// ====================================================================================================================
47
48TComPrediction::TComPrediction()
49: m_pLumaRecBuffer(0)
[608]50, m_iLumaRecStride(0)
[2]51{
52  m_piYuvExt = NULL;
[608]53#if H_3D_VSP
54  m_pDepthBlock = (Int*) malloc(MAX_NUM_SPU_W*MAX_NUM_SPU_W*sizeof(Int));
55  if (m_pDepthBlock == NULL)
[296]56      printf("ERROR: UKTGHU, No memory allocated.\n");
57#endif
[2]58}
59
60TComPrediction::~TComPrediction()
61{
[608]62#if H_3D_VSP
63  if (m_pDepthBlock != NULL)
64      free(m_pDepthBlock);
65  m_cYuvDepthOnVsp.destroy();
[296]66#endif
[608]67
[2]68  delete[] m_piYuvExt;
69
70  m_acYuvPred[0].destroy();
71  m_acYuvPred[1].destroy();
72
73  m_cYuvPredTemp.destroy();
[608]74
75#if H_3D_ARP
[443]76  m_acYuvPredBase[0].destroy();
77  m_acYuvPredBase[1].destroy();
78#endif
[2]79  if( m_pLumaRecBuffer )
[56]80  {
81    delete [] m_pLumaRecBuffer;
82  }
83 
84  Int i, j;
85  for (i = 0; i < 4; i++)
86  {
87    for (j = 0; j < 4; j++)
88    {
89      m_filteredBlock[i][j].destroy();
90    }
91    m_filteredBlockTmp[i].destroy();
92  }
[2]93}
94
95Void TComPrediction::initTempBuff()
96{
97  if( m_piYuvExt == NULL )
98  {
[608]99    Int extWidth  = MAX_CU_SIZE + 16; 
100    Int extHeight = MAX_CU_SIZE + 1;
[56]101    Int i, j;
102    for (i = 0; i < 4; i++)
103    {
104      m_filteredBlockTmp[i].create(extWidth, extHeight + 7);
105      for (j = 0; j < 4; j++)
106      {
107        m_filteredBlock[i][j].create(extWidth, extHeight);
108      }
109    }
[608]110    m_iYuvExtHeight  = ((MAX_CU_SIZE + 2) << 4);
111    m_iYuvExtStride = ((MAX_CU_SIZE  + 8) << 4);
[2]112    m_piYuvExt = new Int[ m_iYuvExtStride * m_iYuvExtHeight ];
113
114    // new structure
[608]115    m_acYuvPred[0] .create( MAX_CU_SIZE, MAX_CU_SIZE );
116    m_acYuvPred[1] .create( MAX_CU_SIZE, MAX_CU_SIZE );
[2]117
[608]118    m_cYuvPredTemp.create( MAX_CU_SIZE, MAX_CU_SIZE );
119#if H_3D_ARP
[443]120    m_acYuvPredBase[0] .create( g_uiMaxCUWidth, g_uiMaxCUHeight );
121    m_acYuvPredBase[1] .create( g_uiMaxCUWidth, g_uiMaxCUHeight );
122#endif
[655]123#if H_3D_VSP
[608]124    m_cYuvDepthOnVsp.create( g_uiMaxCUWidth, g_uiMaxCUHeight );
125#endif
[2]126  }
127
[608]128  if (m_iLumaRecStride != (MAX_CU_SIZE>>1) + 1)
129  {
130    m_iLumaRecStride =  (MAX_CU_SIZE>>1) + 1;
131    if (!m_pLumaRecBuffer)
132    {
133      m_pLumaRecBuffer = new Pel[ m_iLumaRecStride * m_iLumaRecStride ];
134    }
135  }
136#if H_3D_IC
137  m_uiaShift[0] = 0;
[56]138  for( Int i = 1; i < 64; i++ )
139  {
[608]140    m_uiaShift[i] = ( (1 << 15) + i/2 ) / i;
141  }
142#endif
[2]143}
144
145// ====================================================================================================================
146// Public member functions
147// ====================================================================================================================
148
149// Function for calculating DC value of the reference samples used in Intra prediction
150Pel TComPrediction::predIntraGetPredValDC( Int* pSrc, Int iSrcStride, UInt iWidth, UInt iHeight, Bool bAbove, Bool bLeft )
151{
[608]152  assert(iWidth > 0 && iHeight > 0);
[2]153  Int iInd, iSum = 0;
154  Pel pDcVal;
155
156  if (bAbove)
157  {
158    for (iInd = 0;iInd < iWidth;iInd++)
[56]159    {
[2]160      iSum += pSrc[iInd-iSrcStride];
[56]161    }
[2]162  }
163  if (bLeft)
164  {
165    for (iInd = 0;iInd < iHeight;iInd++)
[56]166    {
[2]167      iSum += pSrc[iInd*iSrcStride-1];
[56]168    }
[2]169  }
170
171  if (bAbove && bLeft)
[56]172  {
[2]173    pDcVal = (iSum + iWidth) / (iWidth + iHeight);
[56]174  }
[2]175  else if (bAbove)
[56]176  {
[2]177    pDcVal = (iSum + iWidth/2) / iWidth;
[56]178  }
[2]179  else if (bLeft)
[56]180  {
[2]181    pDcVal = (iSum + iHeight/2) / iHeight;
[56]182  }
[2]183  else
[56]184  {
[2]185    pDcVal = pSrc[-1]; // Default DC value already calculated and placed in the prediction array if no neighbors are available
[56]186  }
187 
[2]188  return pDcVal;
189}
190
191// Function for deriving the angular Intra predictions
192
193/** Function for deriving the simplified angular intra predictions.
194 * \param pSrc pointer to reconstructed sample array
195 * \param srcStride the stride of the reconstructed sample array
196 * \param rpDst reference to pointer for the prediction sample array
197 * \param dstStride the stride of the prediction sample array
198 * \param width the width of the block
199 * \param height the height of the block
200 * \param dirMode the intra prediction mode index
201 * \param blkAboveAvailable boolean indication if the block above is available
202 * \param blkLeftAvailable boolean indication if the block to the left is available
203 *
204 * This function derives the prediction samples for the angular mode based on the prediction direction indicated by
205 * the prediction mode index. The prediction direction is given by the displacement of the bottom row of the block and
206 * the reference row above the block in the case of vertical prediction or displacement of the rightmost column
207 * of the block and reference column left from the block in the case of the horizontal prediction. The displacement
208 * is signalled at 1/32 pixel accuracy. When projection of the predicted pixel falls inbetween reference samples,
209 * the predicted value for the pixel is linearly interpolated from the reference samples. All reference samples are taken
210 * from the extended main reference.
211 */
[608]212Void TComPrediction::xPredIntraAng(Int bitDepth, Int* pSrc, Int srcStride, Pel*& rpDst, Int dstStride, UInt width, UInt height, UInt dirMode, Bool blkAboveAvailable, Bool blkLeftAvailable, Bool bFilter )
[2]213{
214  Int k,l;
215  Int blkSize        = width;
216  Pel* pDst          = rpDst;
217
218  // Map the mode index to main prediction direction and angle
[56]219  assert( dirMode > 0 ); //no planar
220  Bool modeDC        = dirMode < 2;
221  Bool modeHor       = !modeDC && (dirMode < 18);
222  Bool modeVer       = !modeDC && !modeHor;
223  Int intraPredAngle = modeVer ? (Int)dirMode - VER_IDX : modeHor ? -((Int)dirMode - HOR_IDX) : 0;
[2]224  Int absAng         = abs(intraPredAngle);
225  Int signAng        = intraPredAngle < 0 ? -1 : 1;
226
227  // Set bitshifts and scale the angle parameter to block size
228  Int angTable[9]    = {0,    2,    5,   9,  13,  17,  21,  26,  32};
229  Int invAngTable[9] = {0, 4096, 1638, 910, 630, 482, 390, 315, 256}; // (256 * 32) / Angle
230  Int invAngle       = invAngTable[absAng];
231  absAng             = angTable[absAng];
232  intraPredAngle     = signAng * absAng;
233
234  // Do the DC prediction
235  if (modeDC)
236  {
237    Pel dcval = predIntraGetPredValDC(pSrc, srcStride, width, height, blkAboveAvailable, blkLeftAvailable);
238
239    for (k=0;k<blkSize;k++)
240    {
241      for (l=0;l<blkSize;l++)
242      {
243        pDst[k*dstStride+l] = dcval;
244      }
245    }
246  }
247
248  // Do angular predictions
249  else
250  {
251    Pel* refMain;
252    Pel* refSide;
253    Pel  refAbove[2*MAX_CU_SIZE+1];
254    Pel  refLeft[2*MAX_CU_SIZE+1];
255
256    // Initialise the Main and Left reference array.
257    if (intraPredAngle < 0)
258    {
259      for (k=0;k<blkSize+1;k++)
260      {
261        refAbove[k+blkSize-1] = pSrc[k-srcStride-1];
262      }
263      for (k=0;k<blkSize+1;k++)
264      {
265        refLeft[k+blkSize-1] = pSrc[(k-1)*srcStride-1];
266      }
267      refMain = (modeVer ? refAbove : refLeft) + (blkSize-1);
268      refSide = (modeVer ? refLeft : refAbove) + (blkSize-1);
269
270      // Extend the Main reference to the left.
271      Int invAngleSum    = 128;       // rounding for (shift by 8)
272      for (k=-1; k>blkSize*intraPredAngle>>5; k--)
273      {
274        invAngleSum += invAngle;
275        refMain[k] = refSide[invAngleSum>>8];
276      }
277    }
278    else
279    {
280      for (k=0;k<2*blkSize+1;k++)
281      {
282        refAbove[k] = pSrc[k-srcStride-1];
283      }
284      for (k=0;k<2*blkSize+1;k++)
285      {
286        refLeft[k] = pSrc[(k-1)*srcStride-1];
287      }
288      refMain = modeVer ? refAbove : refLeft;
[56]289      refSide = modeVer ? refLeft  : refAbove;
[2]290    }
291
292    if (intraPredAngle == 0)
293    {
294      for (k=0;k<blkSize;k++)
295      {
296        for (l=0;l<blkSize;l++)
297        {
298          pDst[k*dstStride+l] = refMain[l+1];
299        }
300      }
[56]301
302      if ( bFilter )
303      {
304        for (k=0;k<blkSize;k++)
305        {
[608]306          pDst[k*dstStride] = Clip3(0, (1<<bitDepth)-1, pDst[k*dstStride] + (( refSide[k+1] - refSide[0] ) >> 1) );
[56]307        }
308      }
[2]309    }
310    else
311    {
312      Int deltaPos=0;
313      Int deltaInt;
314      Int deltaFract;
315      Int refMainIndex;
316
317      for (k=0;k<blkSize;k++)
318      {
319        deltaPos += intraPredAngle;
320        deltaInt   = deltaPos >> 5;
321        deltaFract = deltaPos & (32 - 1);
322
323        if (deltaFract)
324        {
325          // Do linear filtering
326          for (l=0;l<blkSize;l++)
327          {
328            refMainIndex        = l+deltaInt+1;
329            pDst[k*dstStride+l] = (Pel) ( ((32-deltaFract)*refMain[refMainIndex]+deltaFract*refMain[refMainIndex+1]+16) >> 5 );
330          }
331        }
332        else
333        {
334          // Just copy the integer samples
335          for (l=0;l<blkSize;l++)
336          {
337            pDst[k*dstStride+l] = refMain[l+deltaInt+1];
338          }
339        }
340      }
341    }
342
343    // Flip the block if this is the horizontal mode
344    if (modeHor)
345    {
346      Pel  tmp;
347      for (k=0;k<blkSize-1;k++)
348      {
349        for (l=k+1;l<blkSize;l++)
350        {
351          tmp                 = pDst[k*dstStride+l];
352          pDst[k*dstStride+l] = pDst[l*dstStride+k];
353          pDst[l*dstStride+k] = tmp;
354        }
355      }
356    }
357  }
358}
359
[608]360Void TComPrediction::predIntraLumaAng(TComPattern* pcTComPattern, UInt uiDirMode, Pel* piPred, UInt uiStride, Int iWidth, Int iHeight, Bool bAbove, Bool bLeft )
[2]361{
362  Pel *pDst = piPred;
363  Int *ptrSrc;
364
[56]365  assert( g_aucConvertToBit[ iWidth ] >= 0 ); //   4x  4
366  assert( g_aucConvertToBit[ iWidth ] <= 5 ); // 128x128
[2]367  assert( iWidth == iHeight  );
368
[56]369  ptrSrc = pcTComPattern->getPredictorPtr( uiDirMode, g_aucConvertToBit[ iWidth ] + 2, m_piYuvExt );
370
371  // get starting pixel in block
372  Int sw = 2 * iWidth + 1;
373
374  // Create the prediction
375  if ( uiDirMode == PLANAR_IDX )
376  {
377    xPredIntraPlanar( ptrSrc+sw+1, sw, pDst, uiStride, iWidth, iHeight );
378  }
379  else
380  {
[608]381    if ( (iWidth > 16) || (iHeight > 16) )
[56]382    {
[608]383      xPredIntraAng(g_bitDepthY, ptrSrc+sw+1, sw, pDst, uiStride, iWidth, iHeight, uiDirMode, bAbove, bLeft, false );
[56]384    }
[608]385    else
386    {
387      xPredIntraAng(g_bitDepthY, ptrSrc+sw+1, sw, pDst, uiStride, iWidth, iHeight, uiDirMode, bAbove, bLeft, true );
388
389      if( (uiDirMode == DC_IDX ) && bAbove && bLeft )
390      {
391        xDCPredFiltering( ptrSrc+sw+1, sw, pDst, uiStride, iWidth, iHeight);
392      }
393    }
[56]394  }
395}
396
397// Angular chroma
[608]398Void TComPrediction::predIntraChromaAng( Int* piSrc, UInt uiDirMode, Pel* piPred, UInt uiStride, Int iWidth, Int iHeight, Bool bAbove, Bool bLeft )
[56]399{
400  Pel *pDst = piPred;
401  Int *ptrSrc = piSrc;
402
[2]403  // get starting pixel in block
[56]404  Int sw = 2 * iWidth + 1;
[2]405
406  if ( uiDirMode == PLANAR_IDX )
407  {
408    xPredIntraPlanar( ptrSrc+sw+1, sw, pDst, uiStride, iWidth, iHeight );
[56]409  }
410  else
411  {
412    // Create the prediction
[608]413    xPredIntraAng(g_bitDepthC, ptrSrc+sw+1, sw, pDst, uiStride, iWidth, iHeight, uiDirMode, bAbove, bLeft, false );
[56]414  }
415}
416
[608]417#if H_3D_DIM
418Void TComPrediction::predIntraLumaDepth( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiIntraMode, Pel* piPred, UInt uiStride, Int iWidth, Int iHeight, Bool bFastEnc )
[56]419{
[608]420  assert( iWidth == iHeight  );
421  assert( iWidth >= DIM_MIN_SIZE && iWidth <= DIM_MAX_SIZE );
422  assert( isDimMode( uiIntraMode ) );
[56]423
[608]424  UInt dimType    = getDimType  ( uiIntraMode );
425  Bool dimDeltaDC = isDimDeltaDC( uiIntraMode );   
426  Bool isDmmMode  = (dimType <  DMM_NUM_TYPE);
[724]427#if !SEC_DMM3_RBC_F0147
[608]428  Bool isRbcMode  = (dimType == RBC_IDX);
[724]429#endif
[100]430
[608]431  Bool* biSegPattern  = NULL;
432  UInt  patternStride = 0;
[100]433
[608]434  // get partiton
435#if H_3D_DIM_DMM
436  TComWedgelet* dmmSegmentation = NULL;
437  if( isDmmMode )
[100]438  {
[608]439    switch( dimType )
[100]440    {
[608]441    case( DMM1_IDX ): 
[100]442      {
[608]443        dmmSegmentation = &(g_dmmWedgeLists[ g_aucConvertToBit[iWidth] ][ pcCU->getDmmWedgeTabIdx( dimType, uiAbsPartIdx ) ]);
444      } break;
[724]445#if !SEC_DMM3_RBC_F0147
[608]446    case( DMM3_IDX ): 
[100]447      {
[608]448        UInt uiTabIdx = 0;
449        if( bFastEnc ) { uiTabIdx = pcCU->getDmmWedgeTabIdx( dimType, uiAbsPartIdx ); }
450        else
[100]451        {
[608]452          uiTabIdx = xPredWedgeFromTex( pcCU, uiAbsPartIdx, iWidth, iHeight, pcCU->getDmm3IntraTabIdx( uiAbsPartIdx ) );
453          pcCU->setDmmWedgeTabIdxSubParts( uiTabIdx, dimType, uiAbsPartIdx, (pcCU->getDepth(0) + (pcCU->getPartitionSize(0) == SIZE_2Nx2N ? 0 : 1)) );
[100]454        }
[608]455        dmmSegmentation = &(g_dmmWedgeLists[ g_aucConvertToBit[iWidth] ][ uiTabIdx ]);
456      } break;
[724]457#endif
[608]458    case( DMM4_IDX ): 
[100]459      {
[608]460        dmmSegmentation = new TComWedgelet( iWidth, iHeight );
461        xPredContourFromTex( pcCU, uiAbsPartIdx, iWidth, iHeight, dmmSegmentation );
462      } break;
463    default: assert(0);
[100]464    }
[608]465    assert( dmmSegmentation );
466    biSegPattern  = dmmSegmentation->getPattern();
467    patternStride = dmmSegmentation->getStride ();
[100]468  }
[608]469#endif
470#if H_3D_DIM_RBC
471  if( isRbcMode )
472  {
473    biSegPattern  = pcCU->getEdgePartition( uiAbsPartIdx );
474    patternStride = iWidth;
475  }
476#endif
[100]477
[608]478  // get predicted partition values
479  assert( biSegPattern );
480  Int* piMask = NULL;
[724]481#if QC_DIM_DELTADC_UNIFY_F0132 || HHI_DIM_PREDSAMP_FIX_F0171
482  piMask = pcCU->getPattern()->getAdiOrgBuf( iWidth, iHeight, m_piYuvExt ); // no filtering
483#else
[608]484  if( isDmmMode ) piMask = pcCU->getPattern()->getAdiOrgBuf( iWidth, iHeight, m_piYuvExt ); // no filtering for DMM
485  else            piMask = pcCU->getPattern()->getPredictorPtr( 0, g_aucConvertToBit[ iWidth ] + 2, m_piYuvExt );
[724]486#endif
[608]487  assert( piMask );
488  Int maskStride = 2*iWidth + 1; 
489  Int* ptrSrc = piMask+maskStride+1;
490  Pel predDC1 = 0; Pel predDC2 = 0;
491  xPredBiSegDCs( ptrSrc, maskStride, biSegPattern, patternStride, predDC1, predDC2 );
492
493  // set segment values with deltaDC offsets
494  Pel segDC1 = 0;
495  Pel segDC2 = 0;
496  if( dimDeltaDC )
[100]497  {
[608]498    Pel deltaDC1 = pcCU->getDimDeltaDC( dimType, 0, uiAbsPartIdx );
499    Pel deltaDC2 = pcCU->getDimDeltaDC( dimType, 1, uiAbsPartIdx );
500#if H_3D_DIM_DMM
[724]501#if QC_DIM_DELTADC_UNIFY_F0132 && !SEC_DMM3_RBC_F0147
502    if( isDmmMode || isRbcMode)
503#else
[608]504    if( isDmmMode )
[724]505#endif
[608]506    {
507#if H_3D_DIM_DLT
508      segDC1 = pcCU->getSlice()->getVPS()->idx2DepthValue( pcCU->getSlice()->getLayerIdInVps(), pcCU->getSlice()->getVPS()->depthValue2idx( pcCU->getSlice()->getLayerIdInVps(), predDC1 ) + deltaDC1 );
509      segDC2 = pcCU->getSlice()->getVPS()->idx2DepthValue( pcCU->getSlice()->getLayerIdInVps(), pcCU->getSlice()->getVPS()->depthValue2idx( pcCU->getSlice()->getLayerIdInVps(), predDC2 ) + deltaDC2 );
510#else
511      segDC1 = ClipY( predDC1 + deltaDC1 );
512      segDC2 = ClipY( predDC2 + deltaDC2 );
513#endif
514    }
515#endif
[724]516#if H_3D_DIM_RBC && !QC_DIM_DELTADC_UNIFY_F0132
[608]517    if( isRbcMode )
518    {
519      xDeltaDCQuantScaleUp( pcCU, deltaDC1 );
520      xDeltaDCQuantScaleUp( pcCU, deltaDC2 );
521      segDC1 = ClipY( predDC1 + deltaDC1 );
522      segDC2 = ClipY( predDC2 + deltaDC2 );
523    }
524#endif
[100]525  }
[608]526  else
[100]527  {
[608]528    segDC1 = predDC1;
529    segDC2 = predDC2;
[100]530  }
531
[608]532  // set prediction signal
533  Pel* pDst = piPred;
534  xAssignBiSegDCs( pDst, uiStride, biSegPattern, patternStride, segDC1, segDC2 );
[100]535
[608]536#if H_3D_DIM_DMM
537  if( dimType == DMM4_IDX ) { dmmSegmentation->destroy(); delete dmmSegmentation; }
538#endif
[100]539}
[608]540#endif
[100]541
[608]542/** Function for checking identical motion.
543 * \param TComDataCU* pcCU
544 * \param UInt PartAddr
545 */
546Bool TComPrediction::xCheckIdenticalMotion ( TComDataCU* pcCU, UInt PartAddr )
[100]547{
[608]548  if( pcCU->getSlice()->isInterB() && !pcCU->getSlice()->getPPS()->getWPBiPred() )
[100]549  {
[608]550    if( pcCU->getCUMvField(REF_PIC_LIST_0)->getRefIdx(PartAddr) >= 0 && pcCU->getCUMvField(REF_PIC_LIST_1)->getRefIdx(PartAddr) >= 0)
[100]551    {
[608]552      Int RefPOCL0 = pcCU->getSlice()->getRefPic(REF_PIC_LIST_0, pcCU->getCUMvField(REF_PIC_LIST_0)->getRefIdx(PartAddr))->getPOC();
553      Int RefPOCL1 = pcCU->getSlice()->getRefPic(REF_PIC_LIST_1, pcCU->getCUMvField(REF_PIC_LIST_1)->getRefIdx(PartAddr))->getPOC();
554      if(RefPOCL0 == RefPOCL1 && pcCU->getCUMvField(REF_PIC_LIST_0)->getMv(PartAddr) == pcCU->getCUMvField(REF_PIC_LIST_1)->getMv(PartAddr))
[100]555      {
[608]556        return true;
[100]557      }
558    }
559  }
[608]560  return false;
[100]561}
562
[724]563#if MTK_SPIVMP_F0110
564Void TComPrediction::xGetSubPUAddrAndMerge(TComDataCU* pcCU, UInt uiPartAddr, Int iSPWidth, Int iSPHeight, Int iNumSPInOneLine, Int iNumSP, UInt* uiMergedSPW, UInt* uiMergedSPH, UInt* uiSPAddr )
565{
566  for (Int i = 0; i < iNumSP; i++)
567  {
568    uiMergedSPW[i] = iSPWidth;
569    uiMergedSPH[i] = iSPHeight;
570    pcCU->getSPAbsPartIdx(uiPartAddr, iSPWidth, iSPHeight, i, iNumSPInOneLine, uiSPAddr[i]);
571  }
572  // horizontal sub-PU merge
573  for (Int i=0; i<iNumSP; i++)
574  {
575    if (i % iNumSPInOneLine == iNumSPInOneLine - 1 || uiMergedSPW[i]==0 || uiMergedSPH[i]==0)
576    {
577      continue;
578    }
579    for (Int j=i+1; j<i+iNumSPInOneLine-i%iNumSPInOneLine; j++)
580    {
581      if (xCheckTwoSPMotion(pcCU, uiSPAddr[i], uiSPAddr[j]))
582      {
583        uiMergedSPW[i] += iSPWidth;
584        uiMergedSPW[j] = uiMergedSPH[j] = 0;
585      }
586      else
587      {
588        break;
589      }
590    }
591  }
592  //vertical sub-PU merge
593  for (Int i=0; i<iNumSP-iNumSPInOneLine; i++)
594  {
595    if (uiMergedSPW[i]==0 || uiMergedSPH[i]==0)
596    {
597      continue;
598    }
599    for (Int j=i+iNumSPInOneLine; j<iNumSP; j+=iNumSPInOneLine)
600    {
601      if (xCheckTwoSPMotion(pcCU, uiSPAddr[i], uiSPAddr[j]) && uiMergedSPW[i]==uiMergedSPW[j])
602      {
603        uiMergedSPH[i] += iSPHeight;
604        uiMergedSPH[j] = uiMergedSPW[j] = 0;
605      }
606      else
607      {
608        break;
609      }
610    }
611  }
612}
[608]613
[724]614Bool TComPrediction::xCheckTwoSPMotion ( TComDataCU* pcCU, UInt PartAddr0, UInt PartAddr1 )
615{
616  if( pcCU->getCUMvField(REF_PIC_LIST_0)->getRefIdx(PartAddr0) != pcCU->getCUMvField(REF_PIC_LIST_0)->getRefIdx(PartAddr1))
617  {
618    return false;
619  }
620  if( pcCU->getCUMvField(REF_PIC_LIST_1)->getRefIdx(PartAddr0) != pcCU->getCUMvField(REF_PIC_LIST_1)->getRefIdx(PartAddr1))
621  {
622    return false;
623  }
624
625  if (pcCU->getCUMvField(REF_PIC_LIST_0)->getRefIdx(PartAddr0) >= 0)
626  {
627    if (pcCU->getCUMvField(REF_PIC_LIST_0)->getMv(PartAddr0) != pcCU->getCUMvField(REF_PIC_LIST_0)->getMv(PartAddr1))
628    {
629      return false;
630    }
631  }
632
633  if (pcCU->getCUMvField(REF_PIC_LIST_1)->getRefIdx(PartAddr0) >= 0)
634  {
635    if (pcCU->getCUMvField(REF_PIC_LIST_1)->getMv(PartAddr0) != pcCU->getCUMvField(REF_PIC_LIST_1)->getMv(PartAddr1))
636    {
637      return false;
638    }
639  }
640  return true;
641}
642#endif
643
[56]644Void TComPrediction::motionCompensation ( TComDataCU* pcCU, TComYuv* pcYuvPred, RefPicList eRefPicList, Int iPartIdx )
645{
646  Int         iWidth;
647  Int         iHeight;
648  UInt        uiPartAddr;
649
650  if ( iPartIdx >= 0 )
651  {
652    pcCU->getPartIndexAndSize( iPartIdx, uiPartAddr, iWidth, iHeight );
[608]653#if H_3D_VSP
[622]654    if ( pcCU->getVSPFlag(uiPartAddr) == 0)
[56]655    {
656#endif
[608]657      if ( eRefPicList != REF_PIC_LIST_X )
[56]658      {
[608]659        if( pcCU->getSlice()->getPPS()->getUseWP())
660        {
661          xPredInterUni (pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred, true );
662        }
663        else
664        {
665          xPredInterUni (pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred );
666        }
667        if ( pcCU->getSlice()->getPPS()->getUseWP() )
668        {
669          xWeightedPredictionUni( pcCU, pcYuvPred, uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred );
670        }
[56]671      }
672      else
673      {
[724]674#if MTK_SPIVMP_F0110
675        if ( pcCU->getSPIVMPFlag(uiPartAddr)!=0) 
[608]676        {
[724]677          Int iNumSPInOneLine, iNumSP, iSPWidth, iSPHeight;
678
679          pcCU->getSPPara(iWidth, iHeight, iNumSP, iNumSPInOneLine, iSPWidth, iSPHeight);
680
681          UInt uiW[256], uiH[256];
682          UInt uiSPAddr[256];
683
684          xGetSubPUAddrAndMerge(pcCU, uiPartAddr, iSPWidth, iSPHeight, iNumSPInOneLine, iNumSP, uiW, uiH, uiSPAddr);
685
686          //MC
687          for (Int i = 0; i < iNumSP; i++)
688          {
689            if (uiW[i]==0 || uiH[i]==0)
690            {
691              continue;
692            }
693            if( xCheckIdenticalMotion( pcCU, uiSPAddr[i] ))
694            {
695              xPredInterUni (pcCU, uiSPAddr[i], uiW[i], uiH[i], REF_PIC_LIST_0, pcYuvPred );
696            }
697            else
698            {
699              xPredInterBi  (pcCU, uiSPAddr[i], uiW[i], uiH[i], pcYuvPred);
700            }
701          }
[608]702        }
703        else
704        {
[724]705#endif
706          if ( xCheckIdenticalMotion( pcCU, uiPartAddr ) )
707          {
708            xPredInterUni (pcCU, uiPartAddr, iWidth, iHeight, REF_PIC_LIST_0, pcYuvPred );
709          }
710          else
711          {
712            xPredInterBi  (pcCU, uiPartAddr, iWidth, iHeight, pcYuvPred );
713          }
714#if MTK_SPIVMP_F0110
[608]715        }
[724]716#endif
[56]717      }
[608]718#if H_3D_VSP
[56]719    }
720    else
721    {
[608]722      if ( xCheckIdenticalMotion( pcCU, uiPartAddr ) )
[622]723      {
[608]724        xPredInterUniVSP( pcCU, uiPartAddr, iWidth, iHeight, REF_PIC_LIST_0, pcYuvPred );
[622]725      }
[56]726      else
[622]727      {
[608]728        xPredInterBiVSP ( pcCU, uiPartAddr, iWidth, iHeight, pcYuvPred );
[622]729      }
[608]730    }
[296]731#endif
[2]732    return;
733  }
[56]734
735  for ( iPartIdx = 0; iPartIdx < pcCU->getNumPartInter(); iPartIdx++ )
736  {
737    pcCU->getPartIndexAndSize( iPartIdx, uiPartAddr, iWidth, iHeight );
738
[608]739#if H_3D_VSP
[622]740    if ( pcCU->getVSPFlag(uiPartAddr) == 0 )
[56]741    {
[189]742#endif
[608]743      if ( eRefPicList != REF_PIC_LIST_X )
[56]744      {
[608]745        if( pcCU->getSlice()->getPPS()->getUseWP())
746        {
747          xPredInterUni (pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred, true );
748        }
749        else
750        {
751          xPredInterUni (pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred );
752        }
753        if ( pcCU->getSlice()->getPPS()->getUseWP() )
754        {
755          xWeightedPredictionUni( pcCU, pcYuvPred, uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred );
756        }
[56]757      }
[608]758      else
[56]759      {
[724]760#if MTK_SPIVMP_F0110
761       if (pcCU->getSPIVMPFlag(uiPartAddr)!=0) 
762      {
763        Int iNumSPInOneLine, iNumSP, iSPWidth, iSPHeight;
764
765        pcCU->getSPPara(iWidth, iHeight, iNumSP, iNumSPInOneLine, iSPWidth, iSPHeight);
766
767        UInt uiW[256], uiH[256];
768        UInt uiSPAddr[256];
769
770        xGetSubPUAddrAndMerge(pcCU, uiPartAddr, iSPWidth, iSPHeight, iNumSPInOneLine, iNumSP, uiW, uiH, uiSPAddr);
771        //MC
772        for (Int i = 0; i < iNumSP; i++)
773        {
774          if (uiW[i]==0 || uiH[i]==0)
775          {
776            continue;
777          }
778          if( xCheckIdenticalMotion( pcCU, uiSPAddr[i] ))
779          {
780            xPredInterUni (pcCU, uiSPAddr[i], uiW[i], uiH[i], REF_PIC_LIST_0, pcYuvPred );
781          }
782          else
783          {
784            xPredInterBi  (pcCU, uiSPAddr[i], uiW[i], uiH[i], pcYuvPred);
785          }
786        }
787      }
788      else
789      {
790#endif
[608]791        if ( xCheckIdenticalMotion( pcCU, uiPartAddr ) )
792        {
793          xPredInterUni (pcCU, uiPartAddr, iWidth, iHeight, REF_PIC_LIST_0, pcYuvPred );
794        }
795        else
796        {
797          xPredInterBi  (pcCU, uiPartAddr, iWidth, iHeight, pcYuvPred );
798        }
[724]799#if MTK_SPIVMP_F0110
800       }
801#endif
[56]802      }
[608]803#if H_3D_VSP
[56]804    }
805    else
806    {
807      if ( xCheckIdenticalMotion( pcCU, uiPartAddr ) )
[622]808      {
[608]809        xPredInterUniVSP( pcCU, uiPartAddr, iWidth, iHeight, REF_PIC_LIST_0, pcYuvPred );
[622]810      }
[56]811      else
[622]812      {
[608]813        xPredInterBiVSP ( pcCU, uiPartAddr, iWidth, iHeight, pcYuvPred );
[622]814      }
[56]815    }
[608]816#endif
[56]817  }
818  return;
819}
[2]820
[608]821Void TComPrediction::xPredInterUni ( TComDataCU* pcCU, UInt uiPartAddr, Int iWidth, Int iHeight, RefPicList eRefPicList, TComYuv*& rpcYuvPred, Bool bi )
[296]822{
[608]823  Int         iRefIdx     = pcCU->getCUMvField( eRefPicList )->getRefIdx( uiPartAddr );           assert (iRefIdx >= 0);
824  TComMv      cMv         = pcCU->getCUMvField( eRefPicList )->getMv( uiPartAddr );
825  pcCU->clipMv(cMv);
826#if H_3D_ARP
[724]827#if QC_MTK_INTERVIEW_ARP_F0123_F0108
828  if(pcCU->getARPW( uiPartAddr ) > 0  && pcCU->getSlice()->getRefPic( eRefPicList, iRefIdx )->getPOC()== pcCU->getSlice()->getPOC())
829  {
830      xPredInterUniARPviewRef( pcCU , uiPartAddr , iWidth , iHeight , eRefPicList , rpcYuvPred , bi );
831  }
832  else
833#endif
[608]834  if(  pcCU->getARPW( uiPartAddr ) > 0 
835    && pcCU->getPartitionSize(uiPartAddr)==SIZE_2Nx2N
836    && pcCU->getSlice()->getRefPic( eRefPicList, iRefIdx )->getPOC()!= pcCU->getSlice()->getPOC() 
837    )
[443]838  {
[608]839    xPredInterUniARP( pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, rpcYuvPred, bi );
[443]840  }
[608]841  else
842  {
[443]843#endif
[608]844#if H_3D_IC
845    Bool bICFlag = pcCU->getICFlag( uiPartAddr ) && ( pcCU->getSlice()->getRefPic( eRefPicList, iRefIdx )->getViewIndex() != pcCU->getSlice()->getViewIndex() );
846    xPredInterLumaBlk  ( pcCU, pcCU->getSlice()->getRefPic( eRefPicList, iRefIdx )->getPicYuvRec(), uiPartAddr, &cMv, iWidth, iHeight, rpcYuvPred, bi
847#if H_3D_ARP
848      , false
[443]849#endif
[608]850      , bICFlag );
851    bICFlag = bICFlag && (iWidth > 8);
852    xPredInterChromaBlk( pcCU, pcCU->getSlice()->getRefPic( eRefPicList, iRefIdx )->getPicYuvRec(), uiPartAddr, &cMv, iWidth, iHeight, rpcYuvPred, bi
853#if H_3D_ARP
854      , false
[443]855#endif
[608]856      , bICFlag );
[443]857#else
[608]858  xPredInterLumaBlk  ( pcCU, pcCU->getSlice()->getRefPic( eRefPicList, iRefIdx )->getPicYuvRec(), uiPartAddr, &cMv, iWidth, iHeight, rpcYuvPred, bi );
859  xPredInterChromaBlk( pcCU, pcCU->getSlice()->getRefPic( eRefPicList, iRefIdx )->getPicYuvRec(), uiPartAddr, &cMv, iWidth, iHeight, rpcYuvPred, bi );
[443]860#endif
[608]861#if H_3D_ARP
[443]862  }
863#endif
864}
865
[608]866#if H_3D_VSP
867Void TComPrediction::xPredInterUniVSP( TComDataCU* pcCU, UInt uiPartAddr, Int iWidth, Int iHeight, RefPicList eRefPicList, TComYuv*& rpcYuvPred, Bool bi )
[56]868{
[608]869  // Get depth reference
[622]870  Int       depthRefViewIdx = pcCU->getDvInfo(uiPartAddr).m_aVIdxCan;
[655]871#if H_3D_FCO_VSP_DONBDV_E0163
872  TComPic* pRefPicBaseDepth = 0;
873  Bool     bIsCurrDepthCoded = false;
874  pRefPicBaseDepth  = pcCU->getSlice()->getIvPic( true, pcCU->getSlice()->getViewIndex() );
875  if ( pRefPicBaseDepth->getPicYuvRec() != NULL  ) 
876  {
877    bIsCurrDepthCoded = true;
878  }
879  else 
880  {
881    pRefPicBaseDepth = pcCU->getSlice()->getIvPic (true, depthRefViewIdx );
882  }
883#else
[608]884  TComPic* pRefPicBaseDepth = pcCU->getSlice()->getIvPic (true, depthRefViewIdx );
[655]885#endif
[608]886  assert(pRefPicBaseDepth != NULL);
887  TComPicYuv* pcBaseViewDepthPicYuv = pRefPicBaseDepth->getPicYuvRec();
888  assert(pcBaseViewDepthPicYuv != NULL);
[296]889
[608]890  // Get texture reference
891  Int iRefIdx = pcCU->getCUMvField( eRefPicList )->getRefIdx( uiPartAddr );
892  assert(iRefIdx >= 0);
893  TComPic* pRefPicBaseTxt = pcCU->getSlice()->getRefPic( eRefPicList, iRefIdx );
894  TComPicYuv* pcBaseViewTxtPicYuv = pRefPicBaseTxt->getPicYuvRec();
895  assert(pcBaseViewTxtPicYuv != NULL);
[56]896
[608]897  // Initialize LUT according to the reference viewIdx
898  Int txtRefViewIdx = pRefPicBaseTxt->getViewIndex();
899  Int* pShiftLUT    = pcCU->getSlice()->getDepthToDisparityB( txtRefViewIdx );
900  assert( txtRefViewIdx < pcCU->getSlice()->getViewIndex() );
[100]901
[608]902  // Do compensation
903  TComMv cDv  = pcCU->getDvInfo(uiPartAddr).m_acNBDV;
904  pcCU->clipMv(cDv);
[296]905
[655]906#if H_3D_FCO_VSP_DONBDV_E0163
907  if ( bIsCurrDepthCoded )
908  {
909      cDv.setZero();
910  }
911#endif
[608]912  // fetch virtual depth map
913  pcBaseViewDepthPicYuv->extendPicBorder();
[724]914
915#if MTK_F0109_LG_F0120_VSP_BLOCK
916  Int vspSize=0;
917  xGetVirtualDepth( pcCU, pcBaseViewDepthPicYuv, &cDv, uiPartAddr, iWidth, iHeight, &m_cYuvDepthOnVsp,vspSize );
918  // sub-PU based compensation
919  xPredInterLumaBlkFromDM   ( pcCU, pcBaseViewTxtPicYuv, &m_cYuvDepthOnVsp, pShiftLUT, &cDv, uiPartAddr, iWidth, iHeight, pcCU->getSlice()->getIsDepth(), rpcYuvPred, bi, vspSize);
920  xPredInterChromaBlkFromDM ( pcCU, pcBaseViewTxtPicYuv, &m_cYuvDepthOnVsp, pShiftLUT, &cDv, uiPartAddr, iWidth, iHeight, pcCU->getSlice()->getIsDepth(), rpcYuvPred, bi, vspSize);
921#else
[608]922  xGetVirtualDepth( pcCU, pcBaseViewDepthPicYuv, &cDv, uiPartAddr, iWidth, iHeight, &m_cYuvDepthOnVsp );
923  // sub-PU based compensation
924  xPredInterLumaBlkFromDM   ( pcCU, pcBaseViewTxtPicYuv, &m_cYuvDepthOnVsp, pShiftLUT, &cDv, uiPartAddr, iWidth, iHeight, pcCU->getSlice()->getIsDepth(), rpcYuvPred, bi );
925  xPredInterChromaBlkFromDM ( pcCU, pcBaseViewTxtPicYuv, &m_cYuvDepthOnVsp, pShiftLUT, &cDv, uiPartAddr, iWidth, iHeight, pcCU->getSlice()->getIsDepth(), rpcYuvPred, bi );
[724]926#endif
[608]927}
[296]928#endif
[189]929
[608]930#if H_3D_ARP
931Void TComPrediction::xPredInterUniARP( TComDataCU* pcCU, UInt uiPartAddr, Int iWidth, Int iHeight, RefPicList eRefPicList, TComYuv*& rpcYuvPred, Bool bi, TComMvField * pNewMvFiled )
932{
933  Int         iRefIdx      = pNewMvFiled ? pNewMvFiled->getRefIdx() : pcCU->getCUMvField( eRefPicList )->getRefIdx( uiPartAddr );           
934  TComMv      cMv          = pNewMvFiled ? pNewMvFiled->getMv()     : pcCU->getCUMvField( eRefPicList )->getMv( uiPartAddr );
935  Bool        bTobeScaled  = false;
936  TComPic* pcPicYuvBaseCol = NULL;
937  TComPic* pcPicYuvBaseRef = NULL;
[2]938
[608]939#if H_3D_NBDV
[443]940  DisInfo cDistparity;
941  cDistparity.bDV           = pcCU->getDvInfo(uiPartAddr).bDV;
942  if( cDistparity.bDV )
943  {
[608]944    cDistparity.m_acNBDV = pcCU->getDvInfo(0).m_acNBDV;
[443]945    assert(pcCU->getDvInfo(uiPartAddr).bDV ==  pcCU->getDvInfo(0).bDV);
[608]946    cDistparity.m_aVIdxCan = pcCU->getDvInfo(uiPartAddr).m_aVIdxCan;
[443]947  }
948#else
[608]949  assert(0); // ARP can be applied only when a DV is available
[443]950#endif
951
[608]952  UChar dW = cDistparity.bDV ? pcCU->getARPW ( uiPartAddr ) : 0;
953
954  if( cDistparity.bDV ) 
[443]955  {
[724]956#if SHARP_ARP_REF_CHECK_F0105
957    Int arpRefIdx = pcCU->getSlice()->getFirstTRefIdx(eRefPicList);
958    if( dW > 0 && pcCU->getSlice()->getRefPic( eRefPicList, arpRefIdx )->getPOC()!= pcCU->getSlice()->getPOC() )
959#else
[608]960    if( dW > 0 && pcCU->getSlice()->getRefPic( eRefPicList, 0 )->getPOC()!= pcCU->getSlice()->getPOC() )
[724]961#endif
[608]962    {
[443]963      bTobeScaled = true;
[608]964    }
965
966    pcPicYuvBaseCol =  pcCU->getSlice()->getBaseViewRefPic( pcCU->getSlice()->getPOC(),                              cDistparity.m_aVIdxCan );
[724]967
968#if SHARP_ARP_REF_CHECK_F0105
969    pcPicYuvBaseRef =  pcCU->getSlice()->getBaseViewRefPic( pcCU->getSlice()->getRefPic( eRefPicList, arpRefIdx )->getPOC(), cDistparity.m_aVIdxCan );
970
971    if (!pcCU->getSlice()->getArpRefPicAvailable( eRefPicList, cDistparity.m_aVIdxCan))
972#else
[608]973    pcPicYuvBaseRef =  pcCU->getSlice()->getBaseViewRefPic( pcCU->getSlice()->getRefPic( eRefPicList, 0 )->getPOC(), cDistparity.m_aVIdxCan );
974   
975    if( ( !pcPicYuvBaseCol || pcPicYuvBaseCol->getPOC() != pcCU->getSlice()->getPOC() ) || ( !pcPicYuvBaseRef || pcPicYuvBaseRef->getPOC() != pcCU->getSlice()->getRefPic( eRefPicList, 0 )->getPOC() ) )
[724]976#endif
[443]977    {
978      dW = 0;
979      bTobeScaled = false;
980    }
981    else
[608]982    {
[724]983#if SHARP_ARP_REF_CHECK_F0105
984      assert( pcPicYuvBaseCol->getPOC() == pcCU->getSlice()->getPOC() && pcPicYuvBaseRef->getPOC() == pcCU->getSlice()->getRefPic( eRefPicList, arpRefIdx )->getPOC() );
985#else
[443]986      assert( pcPicYuvBaseCol->getPOC() == pcCU->getSlice()->getPOC() && pcPicYuvBaseRef->getPOC() == pcCU->getSlice()->getRefPic( eRefPicList, 0 )->getPOC() );
[724]987#endif
[608]988    }
989
[443]990    if(bTobeScaled)
991    {     
[608]992      Int iCurrPOC    = pcCU->getSlice()->getPOC();
[443]993      Int iColRefPOC  = pcCU->getSlice()->getRefPOC( eRefPicList, iRefIdx );
994      Int iCurrRefPOC = pcCU->getSlice()->getRefPOC( eRefPicList,  0);
995      Int iScale = pcCU-> xGetDistScaleFactor(iCurrPOC, iCurrRefPOC, iCurrPOC, iColRefPOC);
996      if ( iScale != 4096 )
[608]997      {
[443]998        cMv = cMv.scaleMv( iScale );
[608]999      }
[443]1000      iRefIdx = 0;
1001    }
1002  }
[608]1003
[443]1004  pcCU->clipMv(cMv);
1005  TComPicYuv* pcPicYuvRef = pcCU->getSlice()->getRefPic( eRefPicList, iRefIdx )->getPicYuvRec();
[608]1006  xPredInterLumaBlk  ( pcCU, pcPicYuvRef, uiPartAddr, &cMv, iWidth, iHeight, rpcYuvPred, bi, true );
1007  xPredInterChromaBlk( pcCU, pcPicYuvRef, uiPartAddr, &cMv, iWidth, iHeight, rpcYuvPred, bi, true );
1008
[443]1009  if( dW > 0 )
1010  {
[608]1011    TComYuv * pYuvB0 = &m_acYuvPredBase[0];
[443]1012    TComYuv * pYuvB1  = &m_acYuvPredBase[1];
[608]1013
1014    TComMv cMVwithDisparity = cMv + cDistparity.m_acNBDV;
1015    pcCU->clipMv(cMVwithDisparity);
1016
1017    assert ( cDistparity.bDV );
1018
[443]1019    pcPicYuvRef = pcPicYuvBaseCol->getPicYuvRec();
[608]1020    xPredInterLumaBlk  ( pcCU, pcPicYuvRef, uiPartAddr, &cDistparity.m_acNBDV, iWidth, iHeight, pYuvB0, bi, true );
1021    xPredInterChromaBlk( pcCU, pcPicYuvRef, uiPartAddr, &cDistparity.m_acNBDV, iWidth, iHeight, pYuvB0, bi, true );
1022   
[443]1023    pcPicYuvRef = pcPicYuvBaseRef->getPicYuvRec();
[608]1024    xPredInterLumaBlk  ( pcCU, pcPicYuvRef, uiPartAddr, &cMVwithDisparity, iWidth, iHeight, pYuvB1, bi, true );
1025    xPredInterChromaBlk( pcCU, pcPicYuvRef, uiPartAddr, &cMVwithDisparity, iWidth, iHeight, pYuvB1, bi, true );
1026
1027    pYuvB0->subtractARP( pYuvB0 , pYuvB1 , uiPartAddr , iWidth , iHeight );
1028
1029    if( 2 == dW )
1030    {
1031      pYuvB0->multiplyARP( uiPartAddr , iWidth , iHeight , dW );
1032    }
1033    rpcYuvPred->addARP( rpcYuvPred , pYuvB0 , uiPartAddr , iWidth , iHeight , !bi );
[443]1034  }
1035}
[724]1036#if QC_MTK_INTERVIEW_ARP_F0123_F0108
1037Void TComPrediction::xPredInterUniARPviewRef( TComDataCU* pcCU, UInt uiPartAddr, Int iWidth, Int iHeight, RefPicList eRefPicList, TComYuv*& rpcYuvPred, Bool bi, TComMvField * pNewMvFiled )
1038{
1039  Int         iRefIdx       = pcCU->getCUMvField( eRefPicList )->getRefIdx( uiPartAddr );           
1040  TComMv      cDMv          = pcCU->getCUMvField( eRefPicList )->getMv( uiPartAddr );
1041  TComMv      cTempDMv      = cDMv;
1042  UChar       dW            = pcCU->getARPW ( uiPartAddr );
1043
1044  TComPic* pcPicYuvBaseTRef = NULL;
1045  TComPic* pcPicYuvCurrTRef = NULL;
1046  TComPic* pcPicYuvBaseCol  = pcCU->getSlice()->getRefPic( eRefPicList, iRefIdx ); 
1047  TComPicYuv* pcYuvBaseCol  = pcPicYuvBaseCol->getPicYuvRec();   
1048  Bool bTMVAvai = false;     
1049  TComMv cBaseTMV;
1050  if( pNewMvFiled )
1051  {
1052    iRefIdx = pNewMvFiled->getRefIdx(); 
1053    cDMv = pNewMvFiled->getMv();
1054  }
1055  pcCU->clipMv(cTempDMv);
1056
1057  assert(dW > 0);
1058#if SHARP_ARP_REF_CHECK_F0105
1059  if (!pcCU->getSlice()->getArpRefPicAvailable( eRefPicList, pcPicYuvBaseCol->getViewIndex()))
1060  {
1061    dW = 0;
1062  }
[443]1063#endif
[724]1064  Int uiLCUAddr,uiAbsPartAddr;
1065  Int irefPUX = pcCU->getCUPelX() + g_auiRasterToPelX[g_auiZscanToRaster[uiPartAddr]] + iWidth/2  + ((cDMv.getHor() + 2)>>2);
1066  Int irefPUY = pcCU->getCUPelY() + g_auiRasterToPelY[g_auiZscanToRaster[uiPartAddr]] + iHeight/2 + ((cDMv.getVer() + 2)>>2);
[443]1067
[724]1068  irefPUX = (Int)Clip3<Int>(0, pcCU->getSlice()->getSPS()-> getPicWidthInLumaSamples()-1, irefPUX);
1069  irefPUY = (Int)Clip3<Int>(0, pcCU->getSlice()->getSPS()->getPicHeightInLumaSamples()-1, irefPUY); 
1070  pcYuvBaseCol->getCUAddrAndPartIdx( irefPUX, irefPUY, uiLCUAddr, uiAbsPartAddr);
1071  TComDataCU *pColCU = pcPicYuvBaseCol->getCU( uiLCUAddr );
1072
1073  if(!pColCU->isIntra(uiAbsPartAddr))
1074  {
1075    TComMvField puMVField;
1076    for(Int iList = 0; iList < (pColCU->getSlice()->isInterB() ? 2: 1) && !bTMVAvai; iList ++)
1077    {
1078      RefPicList eRefPicListCurr = RefPicList(iList);
1079      Int iRef = pColCU->getCUMvField(eRefPicListCurr)->getRefIdx(uiAbsPartAddr);
1080      if( iRef != -1)
1081      {
1082        pcPicYuvBaseTRef = pColCU->getSlice()->getRefPic(eRefPicListCurr, iRef); 
1083        Int  iCurrPOC    = pColCU->getSlice()->getPOC();
1084        Int  iCurrRefPOC = pcPicYuvBaseTRef->getPOC();
1085        Int  iCurrRef    = pcCU->getSlice()->getFirstTRefIdx(eRefPicListCurr);
1086        if( iCurrRef >= 0)
1087        {
1088          pcPicYuvCurrTRef =  pcCU->getSlice()->getRefPic(eRefPicListCurr,iCurrRef); 
1089          Int iTargetPOC = pcPicYuvCurrTRef->getPOC();
1090          {
1091            pcPicYuvBaseTRef =  pcCU->getSlice()->getBaseViewRefPic(iTargetPOC,  pcPicYuvBaseCol->getViewIndex() ); 
1092            if(pcPicYuvBaseTRef)
1093            {
1094              cBaseTMV = pColCU->getCUMvField(eRefPicListCurr)->getMv(uiAbsPartAddr);
1095              Int iScale = pcCU-> xGetDistScaleFactor(iCurrPOC, iTargetPOC, iCurrPOC, iCurrRefPOC);
1096              if ( iScale != 4096 )
1097                cBaseTMV = cBaseTMV.scaleMv( iScale );                 
1098              bTMVAvai = true;
1099              break;
1100            }
1101          }
1102        }
1103      }
1104    }
1105  }
1106  if (bTMVAvai == false)
1107  { 
1108    bTMVAvai = true;
1109    cBaseTMV.set(0, 0);
1110    pcPicYuvBaseTRef =  pColCU->getSlice()->getRefPic(eRefPicList,  pcCU->getSlice()->getFirstTRefIdx(eRefPicList)); 
1111    pcPicYuvCurrTRef =  pcCU->getSlice()->getRefPic  (eRefPicList,  pcCU->getSlice()->getFirstTRefIdx(eRefPicList));     
1112  }
1113
1114  xPredInterLumaBlk  ( pcCU, pcYuvBaseCol, uiPartAddr, &cTempDMv, iWidth, iHeight, rpcYuvPred, bi,        bTMVAvai);
1115  xPredInterChromaBlk( pcCU, pcYuvBaseCol, uiPartAddr, &cTempDMv, iWidth, iHeight, rpcYuvPred, bi,        bTMVAvai);
1116
1117  if( dW > 0 && bTMVAvai ) 
1118  {
1119    TComYuv*    pYuvCurrTRef    = &m_acYuvPredBase[0];
1120    TComYuv*    pYuvBaseTRef    = &m_acYuvPredBase[1];
1121    TComPicYuv* pcYuvCurrTref   = pcPicYuvCurrTRef->getPicYuvRec();       
1122    TComPicYuv* pcYuvBaseTref   = pcPicYuvBaseTRef->getPicYuvRec(); 
1123    TComMv      cTempMv         = cDMv + cBaseTMV;
1124
1125    pcCU->clipMv(cBaseTMV);
1126    pcCU->clipMv(cTempMv);
1127
1128    xPredInterLumaBlk  ( pcCU, pcYuvCurrTref, uiPartAddr, &cBaseTMV, iWidth, iHeight, pYuvCurrTRef, bi,   true);
1129    xPredInterChromaBlk( pcCU, pcYuvCurrTref, uiPartAddr, &cBaseTMV, iWidth, iHeight, pYuvCurrTRef, bi,   true);
1130    xPredInterLumaBlk  ( pcCU, pcYuvBaseTref, uiPartAddr, &cTempMv,  iWidth, iHeight, pYuvBaseTRef, bi,   true); 
1131    xPredInterChromaBlk( pcCU, pcYuvBaseTref, uiPartAddr, &cTempMv,  iWidth, iHeight, pYuvBaseTRef, bi,   true); 
1132
1133    pYuvCurrTRef->subtractARP( pYuvCurrTRef , pYuvBaseTRef , uiPartAddr , iWidth , iHeight ); 
1134    if(dW == 2)
1135    {
1136      pYuvCurrTRef->multiplyARP( uiPartAddr , iWidth , iHeight , dW );
1137    }
1138    rpcYuvPred->addARP( rpcYuvPred , pYuvCurrTRef , uiPartAddr , iWidth , iHeight , !bi ); 
1139  }
1140}
1141#endif
1142
1143#endif
1144
[608]1145Void TComPrediction::xPredInterBi ( TComDataCU* pcCU, UInt uiPartAddr, Int iWidth, Int iHeight, TComYuv*& rpcYuvPred )
[2]1146{
[56]1147  TComYuv* pcMbYuv;
1148  Int      iRefIdx[2] = {-1, -1};
1149
1150  for ( Int iRefList = 0; iRefList < 2; iRefList++ )
1151  {
1152    RefPicList eRefPicList = (iRefList ? REF_PIC_LIST_1 : REF_PIC_LIST_0);
1153    iRefIdx[iRefList] = pcCU->getCUMvField( eRefPicList )->getRefIdx( uiPartAddr );
1154
1155    if ( iRefIdx[iRefList] < 0 )
1156    {
1157      continue;
1158    }
1159
1160    assert( iRefIdx[iRefList] < pcCU->getSlice()->getNumRefIdx(eRefPicList) );
1161
1162    pcMbYuv = &m_acYuvPred[iRefList];
1163    if( pcCU->getCUMvField( REF_PIC_LIST_0 )->getRefIdx( uiPartAddr ) >= 0 && pcCU->getCUMvField( REF_PIC_LIST_1 )->getRefIdx( uiPartAddr ) >= 0 )
1164    {
[608]1165      xPredInterUni ( pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcMbYuv, true );
[56]1166    }
1167    else
1168    {
[608]1169      if ( ( pcCU->getSlice()->getPPS()->getUseWP()       && pcCU->getSlice()->getSliceType() == P_SLICE ) || 
1170           ( pcCU->getSlice()->getPPS()->getWPBiPred() && pcCU->getSlice()->getSliceType() == B_SLICE ) )
[56]1171      {
[608]1172        xPredInterUni ( pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcMbYuv, true );
[56]1173      }
1174      else
1175      {
[608]1176        xPredInterUni ( pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcMbYuv );
[56]1177      }
1178    }
1179  }
[608]1180
1181  if ( pcCU->getSlice()->getPPS()->getWPBiPred() && pcCU->getSlice()->getSliceType() == B_SLICE  )
[56]1182  {
1183    xWeightedPredictionBi( pcCU, &m_acYuvPred[0], &m_acYuvPred[1], iRefIdx[0], iRefIdx[1], uiPartAddr, iWidth, iHeight, rpcYuvPred );
[608]1184  } 
[313]1185  else if ( pcCU->getSlice()->getPPS()->getUseWP() && pcCU->getSlice()->getSliceType() == P_SLICE )
1186  {
[608]1187    xWeightedPredictionUni( pcCU, &m_acYuvPred[0], uiPartAddr, iWidth, iHeight, REF_PIC_LIST_0, rpcYuvPred ); 
[313]1188  }
[56]1189  else
1190  {
[608]1191    xWeightedAverage( &m_acYuvPred[0], &m_acYuvPred[1], iRefIdx[0], iRefIdx[1], uiPartAddr, iWidth, iHeight, rpcYuvPred );
[56]1192  }
[2]1193}
1194
[608]1195#if H_3D_VSP
[296]1196
[608]1197Void TComPrediction::xPredInterBiVSP( TComDataCU* pcCU, UInt uiPartAddr, Int iWidth, Int iHeight, TComYuv*& rpcYuvPred )
1198{
1199  TComYuv* pcMbYuv;
1200  Int      iRefIdx[2] = {-1, -1};
1201  Bool     bi = (pcCU->getCUMvField( REF_PIC_LIST_0 )->getRefIdx( uiPartAddr ) >= 0 && pcCU->getCUMvField( REF_PIC_LIST_1 )->getRefIdx( uiPartAddr ) >= 0);
[296]1202
[608]1203  for ( Int iRefList = 0; iRefList < 2; iRefList++ )
[2]1204  {
[608]1205    RefPicList eRefPicList = RefPicList(iRefList);
1206    iRefIdx[iRefList] = pcCU->getCUMvField( eRefPicList )->getRefIdx( uiPartAddr );
[56]1207
[608]1208    if ( iRefIdx[iRefList] < 0 )
[622]1209    {
[608]1210      continue;
[622]1211    }
[608]1212    assert( iRefIdx[iRefList] < pcCU->getSlice()->getNumRefIdx(eRefPicList) );
[56]1213
[608]1214    pcMbYuv = &m_acYuvPred[iRefList];
1215    xPredInterUniVSP ( pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcMbYuv, bi );
[2]1216  }
[296]1217
[608]1218  xWeightedAverage( &m_acYuvPred[0], &m_acYuvPred[1], iRefIdx[0], iRefIdx[1], uiPartAddr, iWidth, iHeight, rpcYuvPred );
1219}
[296]1220
1221#endif
[56]1222
1223/**
1224 * \brief Generate motion-compensated luma block
1225 *
1226 * \param cu       Pointer to current CU
1227 * \param refPic   Pointer to reference picture
1228 * \param partAddr Address of block within CU
1229 * \param mv       Motion vector
1230 * \param width    Width of block
1231 * \param height   Height of block
1232 * \param dstPic   Pointer to destination picture
1233 * \param bi       Flag indicating whether bipred is used
1234 */
[608]1235Void TComPrediction::xPredInterLumaBlk( TComDataCU *cu, TComPicYuv *refPic, UInt partAddr, TComMv *mv, Int width, Int height, TComYuv *&dstPic, Bool bi
1236#if H_3D_ARP
1237    , Bool filterType
[189]1238#endif
[608]1239#if H_3D_IC
1240    , Bool bICFlag
1241#endif
1242  )
[56]1243{
1244  Int refStride = refPic->getStride(); 
1245  Int refOffset = ( mv->getHor() >> 2 ) + ( mv->getVer() >> 2 ) * refStride;
1246  Pel *ref      = refPic->getLumaAddr( cu->getAddr(), cu->getZorderIdxInCU() + partAddr ) + refOffset;
1247 
1248  Int dstStride = dstPic->getStride();
1249  Pel *dst      = dstPic->getLumaAddr( partAddr );
1250 
1251  Int xFrac = mv->getHor() & 0x3;
1252  Int yFrac = mv->getVer() & 0x3;
1253
[608]1254#if H_3D_IC
1255  if( cu->getSlice()->getIsDepth() )
1256  {
1257    refOffset = mv->getHor() + mv->getVer() * refStride;
1258    ref       = refPic->getLumaAddr( cu->getAddr(), cu->getZorderIdxInCU() + partAddr ) + refOffset;
1259    xFrac     = 0;
1260    yFrac     = 0;
1261  }
[56]1262#endif
1263  if ( yFrac == 0 )
[2]1264  {
[655]1265#if H_3D_IC
[608]1266    m_if.filterHorLuma( ref, refStride, dst, dstStride, width, height, xFrac,       !bi || bICFlag
1267#else
1268    m_if.filterHorLuma( ref, refStride, dst, dstStride, width, height, xFrac,       !bi
[443]1269#endif
[608]1270#if H_3D_ARP
1271    , filterType
1272#endif
1273      );
[2]1274  }
[56]1275  else if ( xFrac == 0 )
1276  {
[655]1277#if H_3D_IC
[608]1278    m_if.filterVerLuma( ref, refStride, dst, dstStride, width, height, yFrac, true, !bi || bICFlag
1279#else
1280    m_if.filterVerLuma( ref, refStride, dst, dstStride, width, height, yFrac, true, !bi
[443]1281#endif
[608]1282#if H_3D_ARP
1283    , filterType
1284#endif
1285      );
[56]1286  }
1287  else
1288  {
1289    Int tmpStride = m_filteredBlockTmp[0].getStride();
1290    Short *tmp    = m_filteredBlockTmp[0].getLumaAddr();
1291
1292    Int filterSize = NTAPS_LUMA;
1293    Int halfFilterSize = ( filterSize >> 1 );
1294
[443]1295    m_if.filterHorLuma(ref - (halfFilterSize-1)*refStride, refStride, tmp, tmpStride, width, height+filterSize-1, xFrac, false     
[608]1296#if H_3D_ARP
1297    , filterType
[443]1298#endif
[608]1299      );
[655]1300#if H_3D_IC
[608]1301    m_if.filterVerLuma(tmp + (halfFilterSize-1)*tmpStride, tmpStride, dst, dstStride, width, height,              yFrac, false, !bi || bICFlag
1302#else
[443]1303    m_if.filterVerLuma(tmp + (halfFilterSize-1)*tmpStride, tmpStride, dst, dstStride, width, height,              yFrac, false, !bi
[608]1304#endif
1305#if H_3D_ARP
1306    , filterType
[443]1307#endif
[608]1308      );   
[56]1309  }
[189]1310
[608]1311#if H_3D_IC
1312  if( bICFlag )
[189]1313  {
[608]1314    Int a, b, i, j;
1315    const Int iShift = IC_CONST_SHIFT;
1316
1317    xGetLLSICPrediction( cu, mv, refPic, a, b, TEXT_LUMA );
[189]1318
1319
[608]1320    for ( i = 0; i < height; i++ )
[189]1321    {
[608]1322      for ( j = 0; j < width; j++ )
[189]1323      {
[608]1324          dst[j] = Clip3( 0, ( 1 << g_bitDepthY ) - 1, ( ( a*dst[j] ) >> iShift ) + b );
[189]1325      }
1326      dst += dstStride;
1327    }
[655]1328
[608]1329    if(bi)
1330    {
1331      Pel *dst2      = dstPic->getLumaAddr( partAddr );
1332      Int shift = IF_INTERNAL_PREC - g_bitDepthY;
1333      for (i = 0; i < height; i++)
1334      {
1335        for (j = 0; j < width; j++)
1336        {
1337          Short val = dst2[j] << shift;
1338          dst2[j] = val - (Short)IF_INTERNAL_OFFS;
1339        }
1340        dst2 += dstStride;
1341      }
1342    }
[189]1343  }
1344#endif
[2]1345}
1346
[56]1347/**
1348 * \brief Generate motion-compensated chroma block
1349 *
1350 * \param cu       Pointer to current CU
1351 * \param refPic   Pointer to reference picture
1352 * \param partAddr Address of block within CU
1353 * \param mv       Motion vector
1354 * \param width    Width of block
1355 * \param height   Height of block
1356 * \param dstPic   Pointer to destination picture
1357 * \param bi       Flag indicating whether bipred is used
1358 */
[608]1359Void TComPrediction::xPredInterChromaBlk( TComDataCU *cu, TComPicYuv *refPic, UInt partAddr, TComMv *mv, Int width, Int height, TComYuv *&dstPic, Bool bi
1360#if H_3D_ARP
1361    , Bool filterType
[189]1362#endif
[608]1363#if H_3D_IC
1364    , Bool bICFlag
1365#endif
[443]1366  )
[2]1367{
[56]1368  Int     refStride  = refPic->getCStride();
1369  Int     dstStride  = dstPic->getCStride();
1370 
1371  Int     refOffset  = (mv->getHor() >> 3) + (mv->getVer() >> 3) * refStride;
1372 
1373  Pel*    refCb     = refPic->getCbAddr( cu->getAddr(), cu->getZorderIdxInCU() + partAddr ) + refOffset;
1374  Pel*    refCr     = refPic->getCrAddr( cu->getAddr(), cu->getZorderIdxInCU() + partAddr ) + refOffset;
1375 
1376  Pel* dstCb = dstPic->getCbAddr( partAddr );
1377  Pel* dstCr = dstPic->getCrAddr( partAddr );
1378 
1379  Int     xFrac  = mv->getHor() & 0x7;
1380  Int     yFrac  = mv->getVer() & 0x7;
1381  UInt    cxWidth  = width  >> 1;
1382  UInt    cxHeight = height >> 1;
1383 
1384  Int     extStride = m_filteredBlockTmp[0].getStride();
1385  Short*  extY      = m_filteredBlockTmp[0].getLumaAddr();
1386 
1387  Int filterSize = NTAPS_CHROMA;
1388 
1389  Int halfFilterSize = (filterSize>>1);
1390 
1391  if ( yFrac == 0 )
1392  {
[655]1393#if H_3D_IC
[608]1394    m_if.filterHorChroma(refCb, refStride, dstCb,  dstStride, cxWidth, cxHeight, xFrac, !bi || bICFlag
1395#else
[443]1396    m_if.filterHorChroma(refCb, refStride, dstCb,  dstStride, cxWidth, cxHeight, xFrac, !bi
[608]1397#endif
1398#if H_3D_ARP
1399    , filterType
1400#endif
[443]1401    );   
[655]1402#if H_3D_IC
[608]1403    m_if.filterHorChroma(refCr, refStride, dstCr,  dstStride, cxWidth, cxHeight, xFrac, !bi || bICFlag
1404#else
[443]1405    m_if.filterHorChroma(refCr, refStride, dstCr,  dstStride, cxWidth, cxHeight, xFrac, !bi
[608]1406#endif
1407#if H_3D_ARP
1408    , filterType
1409#endif
1410    );
[56]1411  }
1412  else if ( xFrac == 0 )
1413  {
[655]1414#if H_3D_IC
[608]1415    m_if.filterVerChroma(refCb, refStride, dstCb, dstStride, cxWidth, cxHeight, yFrac, true, !bi || bICFlag
1416#else
[443]1417    m_if.filterVerChroma(refCb, refStride, dstCb, dstStride, cxWidth, cxHeight, yFrac, true, !bi
[608]1418#endif
1419#if H_3D_ARP
1420    , filterType
1421#endif
1422    );
[655]1423#if H_3D_IC
[608]1424    m_if.filterVerChroma(refCr, refStride, dstCr, dstStride, cxWidth, cxHeight, yFrac, true, !bi || bICFlag
1425#else
[443]1426    m_if.filterVerChroma(refCr, refStride, dstCr, dstStride, cxWidth, cxHeight, yFrac, true, !bi
[608]1427#endif
1428#if H_3D_ARP
1429    , filterType
1430#endif
1431    );
[56]1432  }
1433  else
1434  {
[443]1435    m_if.filterHorChroma(refCb - (halfFilterSize-1)*refStride, refStride, extY,  extStride, cxWidth, cxHeight+filterSize-1, xFrac, false
[608]1436#if H_3D_ARP
1437    , filterType
1438#endif 
1439      );
[655]1440#if H_3D_IC
[608]1441    m_if.filterVerChroma(extY  + (halfFilterSize-1)*extStride, extStride, dstCb, dstStride, cxWidth, cxHeight  , yFrac, false, !bi || bICFlag
1442#else
[443]1443    m_if.filterVerChroma(extY  + (halfFilterSize-1)*extStride, extStride, dstCb, dstStride, cxWidth, cxHeight  , yFrac, false, !bi
[608]1444#endif
1445#if H_3D_ARP
1446    , filterType
1447#endif
1448      );
[56]1449   
[443]1450    m_if.filterHorChroma(refCr - (halfFilterSize-1)*refStride, refStride, extY,  extStride, cxWidth, cxHeight+filterSize-1, xFrac, false
[608]1451#if H_3D_ARP
1452    , filterType
1453#endif
1454      );
[655]1455#if H_3D_IC
[608]1456    m_if.filterVerChroma(extY  + (halfFilterSize-1)*extStride, extStride, dstCr, dstStride, cxWidth, cxHeight  , yFrac, false, !bi || bICFlag
1457#else
[443]1458    m_if.filterVerChroma(extY  + (halfFilterSize-1)*extStride, extStride, dstCr, dstStride, cxWidth, cxHeight  , yFrac, false, !bi
[608]1459#endif
1460#if H_3D_ARP
1461    , filterType
1462#endif
1463      );   
[56]1464  }
[608]1465
1466#if H_3D_IC
1467  if( bICFlag )
[189]1468  {
[608]1469    Int a, b, i, j;
1470    const Int iShift = IC_CONST_SHIFT;
1471    xGetLLSICPrediction( cu, mv, refPic, a, b, TEXT_CHROMA_U ); // Cb
1472    for ( i = 0; i < cxHeight; i++ )
[189]1473    {
[608]1474      for ( j = 0; j < cxWidth; j++ )
[189]1475      {
[608]1476          dstCb[j] = Clip3(  0, ( 1 << g_bitDepthC ) - 1, ( ( a*dstCb[j] ) >> iShift ) + b );
[189]1477      }
1478      dstCb += dstStride;
1479    }
[608]1480    xGetLLSICPrediction( cu, mv, refPic, a, b, TEXT_CHROMA_V ); // Cr
1481    for ( i = 0; i < cxHeight; i++ )
[189]1482    {
[608]1483      for ( j = 0; j < cxWidth; j++ )
[189]1484      {
[608]1485          dstCr[j] = Clip3( 0, ( 1 << g_bitDepthC ) - 1, ( ( a*dstCr[j] ) >> iShift ) + b );
[189]1486      }
1487      dstCr += dstStride;
1488    }
[655]1489
[608]1490    if(bi)
[296]1491    {
[608]1492      Pel* dstCb2 = dstPic->getCbAddr( partAddr );
1493      Pel* dstCr2 = dstPic->getCrAddr( partAddr );
1494      Int shift = IF_INTERNAL_PREC - g_bitDepthC;
1495      for (i = 0; i < cxHeight; i++)
[296]1496      {
[608]1497        for (j = 0; j < cxWidth; j++)
[296]1498        {
[608]1499          Short val = dstCb2[j] << shift;
1500          dstCb2[j] = val - (Short)IF_INTERNAL_OFFS;
[461]1501
[608]1502          val = dstCr2[j] << shift;
1503          dstCr2[j] = val - (Short)IF_INTERNAL_OFFS;
[296]1504        }
[608]1505        dstCb2 += dstStride;
1506        dstCr2 += dstStride;
[443]1507      }
1508    }
[296]1509  }
[443]1510#endif
[296]1511}
1512
[608]1513Void TComPrediction::xWeightedAverage( TComYuv* pcYuvSrc0, TComYuv* pcYuvSrc1, Int iRefIdx0, Int iRefIdx1, UInt uiPartIdx, Int iWidth, Int iHeight, TComYuv*& rpcYuvDst )
[2]1514{
[56]1515  if( iRefIdx0 >= 0 && iRefIdx1 >= 0 )
[2]1516  {
[56]1517    rpcYuvDst->addAvg( pcYuvSrc0, pcYuvSrc1, uiPartIdx, iWidth, iHeight );
[2]1518  }
[56]1519  else if ( iRefIdx0 >= 0 && iRefIdx1 <  0 )
[2]1520  {
[56]1521    pcYuvSrc0->copyPartToPartYuv( rpcYuvDst, uiPartIdx, iWidth, iHeight );
[2]1522  }
[56]1523  else if ( iRefIdx0 <  0 && iRefIdx1 >= 0 )
[2]1524  {
[56]1525    pcYuvSrc1->copyPartToPartYuv( rpcYuvDst, uiPartIdx, iWidth, iHeight );
1526  }
1527}
1528
1529// AMVP
[608]1530Void TComPrediction::getMvPredAMVP( TComDataCU* pcCU, UInt uiPartIdx, UInt uiPartAddr, RefPicList eRefPicList, TComMv& rcMvPred )
[56]1531{
1532  AMVPInfo* pcAMVPInfo = pcCU->getCUMvField(eRefPicList)->getAMVPInfo();
[608]1533  if( pcAMVPInfo->iN <= 1 )
[56]1534  {
1535    rcMvPred = pcAMVPInfo->m_acMvCand[0];
1536
1537    pcCU->setMVPIdxSubParts( 0, eRefPicList, uiPartAddr, uiPartIdx, pcCU->getDepth(uiPartAddr));
1538    pcCU->setMVPNumSubParts( pcAMVPInfo->iN, eRefPicList, uiPartAddr, uiPartIdx, pcCU->getDepth(uiPartAddr));
1539    return;
1540  }
1541
1542  assert(pcCU->getMVPIdx(eRefPicList,uiPartAddr) >= 0);
1543  rcMvPred = pcAMVPInfo->m_acMvCand[pcCU->getMVPIdx(eRefPicList,uiPartAddr)];
1544  return;
1545}
1546
1547/** Function for deriving planar intra prediction.
1548 * \param pSrc pointer to reconstructed sample array
1549 * \param srcStride the stride of the reconstructed sample array
1550 * \param rpDst reference to pointer for the prediction sample array
1551 * \param dstStride the stride of the prediction sample array
1552 * \param width the width of the block
1553 * \param height the height of the block
1554 *
1555 * This function derives the prediction samples for planar mode (intra coding).
1556 */
1557Void TComPrediction::xPredIntraPlanar( Int* pSrc, Int srcStride, Pel* rpDst, Int dstStride, UInt width, UInt height )
1558{
1559  assert(width == height);
1560
1561  Int k, l, bottomLeft, topRight;
1562  Int horPred;
[655]1563  Int leftColumn[MAX_CU_SIZE+1], topRow[MAX_CU_SIZE+1], bottomRow[MAX_CU_SIZE], rightColumn[MAX_CU_SIZE];
[56]1564  UInt blkSize = width;
1565  UInt offset2D = width;
1566  UInt shift1D = g_aucConvertToBit[ width ] + 2;
1567  UInt shift2D = shift1D + 1;
1568
1569  // Get left and above reference column and row
1570  for(k=0;k<blkSize+1;k++)
1571  {
1572    topRow[k] = pSrc[k-srcStride];
1573    leftColumn[k] = pSrc[k*srcStride-1];
1574  }
1575
1576  // Prepare intermediate variables used in interpolation
1577  bottomLeft = leftColumn[blkSize];
1578  topRight   = topRow[blkSize];
1579  for (k=0;k<blkSize;k++)
1580  {
1581    bottomRow[k]   = bottomLeft - topRow[k];
1582    rightColumn[k] = topRight   - leftColumn[k];
1583    topRow[k]      <<= shift1D;
1584    leftColumn[k]  <<= shift1D;
1585  }
1586
1587  // Generate prediction signal
1588  for (k=0;k<blkSize;k++)
1589  {
1590    horPred = leftColumn[k] + offset2D;
1591    for (l=0;l<blkSize;l++)
[2]1592    {
[56]1593      horPred += rightColumn[k];
1594      topRow[l] += bottomRow[l];
1595      rpDst[k*dstStride+l] = ( (horPred + topRow[l]) >> shift2D );
[2]1596    }
1597  }
1598}
1599
[608]1600/** Function for filtering intra DC predictor.
1601 * \param pSrc pointer to reconstructed sample array
1602 * \param iSrcStride the stride of the reconstructed sample array
1603 * \param rpDst reference to pointer for the prediction sample array
1604 * \param iDstStride the stride of the prediction sample array
1605 * \param iWidth the width of the block
1606 * \param iHeight the height of the block
[56]1607 *
[608]1608 * This function performs filtering left and top edges of the prediction samples for DC mode (intra coding).
[56]1609 */
[608]1610Void TComPrediction::xDCPredFiltering( Int* pSrc, Int iSrcStride, Pel*& rpDst, Int iDstStride, Int iWidth, Int iHeight )
[56]1611{
[608]1612  Pel* pDst = rpDst;
1613  Int x, y, iDstStride2, iSrcStride2;
[2]1614
[608]1615  // boundary pixels processing
1616  pDst[0] = (Pel)((pSrc[-iSrcStride] + pSrc[-1] + 2 * pDst[0] + 2) >> 2);
[56]1617
[608]1618  for ( x = 1; x < iWidth; x++ )
[2]1619  {
[608]1620    pDst[x] = (Pel)((pSrc[x - iSrcStride] +  3 * pDst[x] + 2) >> 2);
[2]1621  }
1622
[608]1623  for ( y = 1, iDstStride2 = iDstStride, iSrcStride2 = iSrcStride-1; y < iHeight; y++, iDstStride2+=iDstStride, iSrcStride2+=iSrcStride )
[56]1624  {
[608]1625    pDst[iDstStride2] = (Pel)((pSrc[iSrcStride2] + 3 * pDst[iDstStride2] + 2) >> 2);
[56]1626  }
[2]1627
[608]1628  return;
[2]1629}
[608]1630#if H_3D_IC
1631/** Function for deriving the position of first non-zero binary bit of a value
[56]1632 * \param x input value
1633 *
[608]1634 * This function derives the position of first non-zero binary bit of a value
[56]1635 */
1636Int GetMSB( UInt x )
1637{
1638  Int iMSB = 0, bits = ( sizeof( Int ) << 3 ), y = 1;
1639
1640  while( x > 1 )
1641  {
1642    bits >>= 1;
1643    y = x >> bits;
1644
1645    if( y )
1646    {
1647      x = y;
1648      iMSB += bits;
1649    }
1650  }
1651
1652  iMSB+=y;
1653
1654  return iMSB;
1655}
1656
1657
[608]1658/** Function for deriving LM illumination compensation.
[56]1659 */
[608]1660Void TComPrediction::xGetLLSICPrediction( TComDataCU* pcCU, TComMv *pMv, TComPicYuv *pRefPic, Int &a, Int &b, TextType eType )
[56]1661{
[608]1662  TComPicYuv *pRecPic = pcCU->getPic()->getPicYuvRec();
1663  Pel *pRec = NULL, *pRef = NULL;
1664  UInt uiWidth, uiHeight, uiTmpPartIdx;
1665  Int iRecStride = ( eType == TEXT_LUMA ) ? pRecPic->getStride() : pRecPic->getCStride();
1666  Int iRefStride = ( eType == TEXT_LUMA ) ? pRefPic->getStride() : pRefPic->getCStride();
1667  Int iCUPelX, iCUPelY, iRefX, iRefY, iRefOffset, iHor, iVer;
[56]1668
[608]1669  iCUPelX = pcCU->getCUPelX() + g_auiRasterToPelX[g_auiZscanToRaster[pcCU->getZorderIdxInCU()]];
1670  iCUPelY = pcCU->getCUPelY() + g_auiRasterToPelY[g_auiZscanToRaster[pcCU->getZorderIdxInCU()]];
1671  iHor = pcCU->getSlice()->getIsDepth() ? pMv->getHor() : ( ( pMv->getHor() + 2 ) >> 2 );
1672  iVer = pcCU->getSlice()->getIsDepth() ? pMv->getVer() : ( ( pMv->getVer() + 2 ) >> 2 );
1673  iRefX   = iCUPelX + iHor;
1674  iRefY   = iCUPelY + iVer;
1675  if( eType != TEXT_LUMA )
1676  {
1677    iHor = pcCU->getSlice()->getIsDepth() ? ( ( pMv->getHor() + 1 ) >> 1 ) : ( ( pMv->getHor() + 4 ) >> 3 );
1678    iVer = pcCU->getSlice()->getIsDepth() ? ( ( pMv->getVer() + 1 ) >> 1 ) : ( ( pMv->getVer() + 4 ) >> 3 );
1679  }
1680  uiWidth  = ( eType == TEXT_LUMA ) ? pcCU->getWidth( 0 )  : ( pcCU->getWidth( 0 )  >> 1 );
1681  uiHeight = ( eType == TEXT_LUMA ) ? pcCU->getHeight( 0 ) : ( pcCU->getHeight( 0 ) >> 1 );
[56]1682
1683  Int i, j, iCountShift = 0;
1684
1685  // LLS parameters estimation -->
1686
1687  Int x = 0, y = 0, xx = 0, xy = 0;
[608]1688  Int precShift = std::max(0, (( eType == TEXT_LUMA ) ? g_bitDepthY : g_bitDepthC) - 12);
[56]1689
[608]1690  if( pcCU->getPUAbove( uiTmpPartIdx, pcCU->getZorderIdxInCU() ) && iCUPelY > 0 && iRefY > 0 )
[56]1691  {
[608]1692    iRefOffset = iHor + iVer * iRefStride - iRefStride;
1693    if( eType == TEXT_LUMA )
[56]1694    {
[608]1695      pRef = pRefPic->getLumaAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() ) + iRefOffset;
1696      pRec = pRecPic->getLumaAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() ) - iRecStride;
[56]1697    }
[608]1698    else if( eType == TEXT_CHROMA_U )
[56]1699    {
[608]1700      pRef = pRefPic->getCbAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() ) + iRefOffset;
1701      pRec = pRecPic->getCbAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() ) - iRecStride;
[56]1702    }
[608]1703    else
1704    {
1705      assert( eType == TEXT_CHROMA_V );
1706      pRef = pRefPic->getCrAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() ) + iRefOffset;
1707      pRec = pRecPic->getCrAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() ) - iRecStride;
1708    }
[56]1709
[608]1710    for( j = 0; j < uiWidth; j+=2 )
[189]1711    {
1712      x += pRef[j];
1713      y += pRec[j];
[608]1714      xx += (pRef[j] * pRef[j])>>precShift;
1715      xy += (pRef[j] * pRec[j])>>precShift;
[189]1716    }
[608]1717    iCountShift += g_aucConvertToBit[ uiWidth ] + 1;
[189]1718  }
1719
1720
[608]1721  if( pcCU->getPULeft( uiTmpPartIdx, pcCU->getZorderIdxInCU() ) && iCUPelX > 0 && iRefX > 0 )
[189]1722  {
[608]1723    iRefOffset = iHor + iVer * iRefStride - 1;
1724    if( eType == TEXT_LUMA )
1725    {
1726      pRef = pRefPic->getLumaAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() ) + iRefOffset;
1727      pRec = pRecPic->getLumaAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() ) - 1;
1728    }
1729    else if( eType == TEXT_CHROMA_U )
1730    {
1731      pRef = pRefPic->getCbAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() ) + iRefOffset;
1732      pRec = pRecPic->getCbAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() ) - 1;
1733    }
1734    else
1735    {
1736      assert( eType == TEXT_CHROMA_V );
1737      pRef = pRefPic->getCrAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() ) + iRefOffset;
1738      pRec = pRecPic->getCrAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() ) - 1;
1739    }
1740
1741    for( i = 0; i < uiHeight; i+=2 )
[189]1742    {
1743      x += pRef[0];
1744      y += pRec[0];
[655]1745
[608]1746      xx += (pRef[0] * pRef[0])>>precShift;
1747      xy += (pRef[0] * pRec[0])>>precShift;
1748
1749      pRef += iRefStride*2;
1750      pRec += iRecStride*2;
[189]1751    }
[608]1752    iCountShift += iCountShift > 0 ? 1 : ( g_aucConvertToBit[ uiWidth ] + 1 );
[189]1753  }
1754
[608]1755  xy += xx >> IC_REG_COST_SHIFT;
1756  xx += xx >> IC_REG_COST_SHIFT;
1757  Int a1 = ( xy << iCountShift ) - ((y * x) >> precShift);
1758  Int a2 = ( xx << iCountShift ) - ((x * x) >> precShift);
1759  const Int iShift = IC_CONST_SHIFT;
1760  {
[189]1761    {
1762      const Int iShiftA2 = 6;
1763      const Int iAccuracyShift = 15;
1764
1765      Int iScaleShiftA2 = 0;
1766      Int iScaleShiftA1 = 0;
1767      Int a1s = a1;
1768      Int a2s = a2;
1769
[608]1770      a1 = Clip3(0, 2*a2, a1);
1771      iScaleShiftA2 = GetMSB( abs( a2 ) ) - iShiftA2;
1772      iScaleShiftA1 = iScaleShiftA2 - IC_SHIFT_DIFF;
[189]1773
1774      if( iScaleShiftA1 < 0 )
1775      {
1776        iScaleShiftA1 = 0;
1777      }
1778
1779      if( iScaleShiftA2 < 0 )
1780      {
1781        iScaleShiftA2 = 0;
1782      }
1783
1784      Int iScaleShiftA = iScaleShiftA2 + iAccuracyShift - iShift - iScaleShiftA1;
1785
[608]1786
[189]1787      a2s = a2 >> iScaleShiftA2;
1788
1789      a1s = a1 >> iScaleShiftA1;
1790
[608]1791      a = a1s * m_uiaShift[ a2s ];
1792      a = a >> iScaleShiftA;
[189]1793      b = (  y - ( ( a * x ) >> iShift ) + ( 1 << ( iCountShift - 1 ) ) ) >> iCountShift;
1794    }
1795  }   
1796}
[608]1797#endif
[189]1798
[608]1799#if H_3D_VSP
1800// not fully support iRatioTxtPerDepth* != 1
[724]1801#if MTK_F0109_LG_F0120_VSP_BLOCK
1802Void TComPrediction::xGetVirtualDepth( TComDataCU *cu, TComPicYuv *picRefDepth, TComMv *mv, UInt partAddr, Int width, Int height, TComYuv *yuvDepth, Int &vspSize, Int ratioTxtPerDepthX, Int ratioTxtPerDepthY )
1803#else
[608]1804Void TComPrediction::xGetVirtualDepth( TComDataCU *cu, TComPicYuv *picRefDepth, TComMv *mv, UInt partAddr, Int width, Int height, TComYuv *yuvDepth, Int ratioTxtPerDepthX, Int ratioTxtPerDepthY )
[724]1805#endif
[189]1806{
[608]1807  Int nTxtPerDepthX = H_3D_VSP_BLOCKSIZE;
1808  Int nTxtPerDepthY = H_3D_VSP_BLOCKSIZE;
[189]1809
[608]1810  Int refDepStride = picRefDepth->getStride();
[189]1811
[608]1812  Int refDepOffset  = ( (mv->getHor()+2) >> 2 ) + ( (mv->getVer()+2) >> 2 ) * refDepStride;
1813  Pel *refDepth     = picRefDepth->getLumaAddr( cu->getAddr(), cu->getZorderIdxInCU() + partAddr );
[189]1814
[608]1815  if( ratioTxtPerDepthX!=1 || ratioTxtPerDepthY!=1 )
[189]1816  {
[608]1817    Int posX, posY;
1818    refDepth    = picRefDepth->getLumaAddr( );
1819    cu->getPic()->getPicYuvRec()->getTopLeftSamplePos( cu->getAddr(), cu->getZorderIdxInCU() + partAddr, posX, posY ); // top-left position in texture
1820    posX /= ratioTxtPerDepthX; // texture position -> depth postion
1821    posY /= ratioTxtPerDepthY;
1822    refDepOffset += posX + posY * refDepStride;
[189]1823
[608]1824    width  /= ratioTxtPerDepthX; // texture size -> depth size
1825    height /= ratioTxtPerDepthY;
[189]1826  }
1827
[608]1828  refDepth += refDepOffset;
[189]1829
[608]1830  Int depStride = yuvDepth->getStride();
1831  Pel *depth = yuvDepth->getLumaAddr();
[189]1832
[724]1833#if !SHARP_VSP_BLOCK_IN_AMP_F0102
[608]1834  if( width<8 || height<8 )
1835  { // no split
1836    Int rightOffset = width - 1;
1837    Int depStrideBlock = depStride * nTxtPerDepthY;
1838    Pel *refDepthTop = refDepth;
1839    Pel *refDepthBot = refDepthTop + (height-1)*refDepStride;
[189]1840
[608]1841    Pel maxDepth = refDepthTop[0] > refDepthBot[0] ? refDepthTop[0] : refDepthBot[0];
1842    if( maxDepth < refDepthTop[rightOffset] ) { maxDepth = refDepthTop[rightOffset]; }
1843    if( maxDepth < refDepthBot[rightOffset] ) { maxDepth = refDepthBot[rightOffset]; }
1844
1845    for( Int sY=0; sY<height; sY+=nTxtPerDepthY )
1846    {
1847      for( Int sX=0; sX<width; sX+=nTxtPerDepthX )
1848      {
1849        depth[sX] = maxDepth;
1850      }
1851      depth += depStrideBlock;
1852    }
[724]1853#if MTK_F0109_LG_F0120_VSP_BLOCK
1854  if(width==4)
1855    vspSize=0;
1856  else
1857    vspSize=1;
1858#endif
[189]1859  }
1860  else
[608]1861  { // split to 4x8, or 8x4
1862    Int blocksize    = 8;
1863    Int subblocksize = 4;
1864    Int depStrideBlock = depStride * blocksize;
1865    Pel *depthTmp = NULL;
1866    Int depStrideTmp = depStride * nTxtPerDepthY;
1867    Int offset[4] = { 0, subblocksize-1, subblocksize, blocksize-1 };
1868    Pel *refDepthTmp[4] = { NULL, NULL, NULL, NULL };
1869    Pel repDepth4x8[2] = {0, 0};
1870    Pel repDepth8x4[2] = {0, 0};
[724]1871#endif
[189]1872
[724]1873#if !MTK_F0109_LG_F0120_VSP_BLOCK
1874#if SHARP_VSP_BLOCK_IN_AMP_F0102
1875    Int blocksize    = 8;
1876    Int subblocksize = 4;
1877    Int depStrideBlock = depStride * blocksize;
1878    Pel *depthTmp = NULL;
1879    Int depStrideTmp = depStride * nTxtPerDepthY;
1880    Int offset[4] = { 0, subblocksize-1, subblocksize, blocksize-1 };
1881    Pel *refDepthTmp[4] = { NULL, NULL, NULL, NULL };
1882#endif
[608]1883    Int refDepStrideBlock    = refDepStride * blocksize;
1884    Int refDepStrideSubBlock = refDepStride * subblocksize;
1885
1886    refDepthTmp[0] = refDepth;
1887    refDepthTmp[2] = refDepthTmp[0] + refDepStrideSubBlock;
1888    refDepthTmp[1] = refDepthTmp[2] - refDepStride;
1889    refDepthTmp[3] = refDepthTmp[1] + refDepStrideSubBlock;
1890
[724]1891#if SHARP_VSP_BLOCK_IN_AMP_F0102
1892    Int subBlockW, subBlockH;
1893    Int blockW, blockH;
1894    subBlockW = subBlockH = 8;
1895    if (height % 8)
1896    {
1897      subBlockW = 8;
1898      subBlockH = 4;
1899      blockW = width;  // no further split
1900      blockH = height; // no further split
1901    }
1902    else if (width % 8)
1903    {
1904      subBlockW = 4;
1905      subBlockH = 8;
1906      blockW = width;  // no further split
1907      blockH = height; // no further split
1908    }
1909    else
1910    {
1911      blockW = blockH = 8;
1912    }
1913    for( Int y=0; y<height; y+=blockH )
1914    {
1915      for( Int x=0; x<width; x+=blockW )
1916      {
1917        if (blockW == 8 && blockH == 8)
1918        {
1919          Bool ULvsBR = false, URvsBL = false;
1920          ULvsBR = refDepthTmp[0][x+offset[0]] < refDepthTmp[3][x+offset[3]];
1921          URvsBL = refDepthTmp[0][x+offset[3]] < refDepthTmp[3][x+offset[0]];
1922          if( ULvsBR ^ URvsBL )
1923          { // 4x8
1924            subBlockW = 4;
1925            subBlockH = 8;
1926          }
1927          else
1928          {
1929            subBlockW = 8;
1930            subBlockH = 4;
1931          }
1932        }
1933        for( Int yy=0; yy<blockH; yy+=subBlockH )
1934        {
1935          for( Int xx=0; xx<blockW; xx+=subBlockW )
1936          {
1937            Pel  maxDepthVal = 0;
1938            Int xP0, xP1, yP0, yP1;
1939            xP0 = x+xx;
1940            xP1 = x+xx+subBlockW-1;
1941            yP0 = yy;
1942            yP1 = yy+subBlockH-1;
1943            maxDepthVal = std::max( maxDepthVal, refDepthTmp[0][xP0+yP0*refDepStride]);
1944            maxDepthVal = std::max( maxDepthVal, refDepthTmp[0][xP1+yP0*refDepStride]);
1945            maxDepthVal = std::max( maxDepthVal, refDepthTmp[0][xP0+yP1*refDepStride]);
1946            maxDepthVal = std::max( maxDepthVal, refDepthTmp[0][xP1+yP1*refDepStride]);
1947            depthTmp = &depth[x+xx+yy*depStride];
1948            for( Int sY=0; sY<subBlockH; sY+=nTxtPerDepthY )
1949            {
1950              for( Int sX=0; sX<subBlockW; sX+=nTxtPerDepthX )
1951              {
1952                depthTmp[sX] = maxDepthVal;
1953              }
1954              depthTmp += depStrideTmp;
1955            }
1956          }
1957        }
1958      }
1959      refDepthTmp[0] += refDepStrideBlock;
1960      depth       += depStrideBlock;
1961    }
1962#else // SHARP_VSP_BLOCK_IN_AMP_F0102
[608]1963    for( Int y=0; y<height; y+=blocksize )
[189]1964    {
[608]1965      for( Int x=0; x<width; x+=blocksize )
1966      {
1967        Bool ULvsBR = false, URvsBL = false;
[189]1968
[608]1969        ULvsBR = refDepthTmp[0][x+offset[0]] < refDepthTmp[3][x+offset[3]];
1970        URvsBL = refDepthTmp[0][x+offset[3]] < refDepthTmp[3][x+offset[0]];
[189]1971
[608]1972        if( ULvsBR ^ URvsBL )
1973        { // 4x8
1974          repDepth4x8[0] = refDepthTmp[0][x+offset[0]] > refDepthTmp[0][x+offset[1]] ? refDepthTmp[0][x+offset[0]] : refDepthTmp[0][x+offset[1]];
1975          if( repDepth4x8[0] < refDepthTmp[3][x+offset[0]] )
1976          {
1977            repDepth4x8[0] = refDepthTmp[3][x+offset[0]];
1978          }
1979          if( repDepth4x8[0] < refDepthTmp[3][x+offset[1]] )
1980          {
1981            repDepth4x8[0] = refDepthTmp[3][x+offset[1]];
1982          }
1983          repDepth4x8[1] = refDepthTmp[0][x+offset[2]] > refDepthTmp[0][x+offset[3]] ? refDepthTmp[0][x+offset[2]] : refDepthTmp[0][x+offset[3]];
1984          if( repDepth4x8[1] < refDepthTmp[3][x+offset[2]] )
1985          {
1986            repDepth4x8[1] = refDepthTmp[3][x+offset[2]];
1987          }
1988          if( repDepth4x8[1] < refDepthTmp[3][x+offset[3]] )
1989          {
1990            repDepth4x8[1] = refDepthTmp[3][x+offset[3]];
1991          }
[189]1992
[608]1993          depthTmp = &depth[x];
1994          for( Int sY=0; sY<blocksize; sY+=nTxtPerDepthY )
1995          {
1996            for( Int sX=0; sX<subblocksize; sX+=nTxtPerDepthX )
1997            {
1998              depthTmp[sX] = repDepth4x8[0];
1999            }
2000            depthTmp += depStrideTmp;
2001          }
2002          depthTmp = &depth[x+subblocksize];
2003          for( Int sY=0; sY<blocksize; sY+=nTxtPerDepthY )
2004          {
2005            for( Int sX=0; sX<subblocksize; sX+=nTxtPerDepthX )
2006            {
2007              depthTmp[sX] = repDepth4x8[1];
2008            }
2009            depthTmp += depStrideTmp;
2010          }
2011        }
2012        else
2013        { // 8x4
2014          repDepth8x4[0] = refDepthTmp[0][x+offset[0]] > refDepthTmp[0][x+offset[3]] ? refDepthTmp[0][x+offset[0]] : refDepthTmp[0][x+offset[3]];
2015          if( repDepth8x4[0] < refDepthTmp[1][x+offset[0]] )
2016          {
2017            repDepth8x4[0] = refDepthTmp[1][x+offset[0]];
2018          }
2019          if( repDepth8x4[0] < refDepthTmp[1][x+offset[3]] )
2020          {
2021            repDepth8x4[0] = refDepthTmp[1][x+offset[3]];
2022          }
2023          repDepth8x4[1] = refDepthTmp[2][x+offset[0]] > refDepthTmp[2][x+offset[3]] ? refDepthTmp[2][x+offset[0]] : refDepthTmp[2][x+offset[3]];
2024          if( repDepth8x4[1] < refDepthTmp[3][x+offset[0]] )
2025          {
2026            repDepth8x4[1] = refDepthTmp[3][x+offset[0]];
2027          }
2028          if( repDepth8x4[1] < refDepthTmp[3][x+offset[3]] )
2029          {
2030            repDepth8x4[1] = refDepthTmp[3][x+offset[3]];
2031          }
2032         
2033          depthTmp = &depth[x];
2034          for( Int sY=0; sY<subblocksize; sY+=nTxtPerDepthY )
2035          {
2036            for( Int sX=0; sX<blocksize; sX+=nTxtPerDepthX )
2037            {
2038              depthTmp[sX] = repDepth8x4[0];
2039            }
2040            depthTmp += depStrideTmp;
2041          }
2042          for( Int sY=0; sY<subblocksize; sY+=nTxtPerDepthY )
2043          {
2044            for( Int sX=0; sX<blocksize; sX+=nTxtPerDepthX )
2045            {
2046              depthTmp[sX] = repDepth8x4[1];
2047            }
2048            depthTmp += depStrideTmp;
2049          }
2050        }
[189]2051      }
[608]2052      refDepthTmp[0] += refDepStrideBlock;
2053      refDepthTmp[1] += refDepStrideBlock;
2054      refDepthTmp[2] += refDepStrideBlock;
2055      refDepthTmp[3] += refDepStrideBlock;
2056      depth       += depStrideBlock;
2057    }
[724]2058#endif // SHARP_VSP_BLOCK_IN_AMP_F0102
2059#else
2060#if SHARP_VSP_BLOCK_IN_AMP_F0102
2061  if ((height % 8))
2062  {
2063    vspSize = 1; // 8x4
[608]2064  }
[724]2065  else if ((width % 8))
2066  {
2067    vspSize = 0; // 4x8
2068  }
2069  else
2070  {
2071    Bool ULvsBR, URvsBL;
2072    ULvsBR = refDepth[0]       < refDepth[refDepStride * (height-1) + width-1];
2073    URvsBL = refDepth[width-1] < refDepth[refDepStride * (height-1)];
2074    vspSize = ( ULvsBR ^ URvsBL ) ? 0 : 1;
2075  }
2076  Int subBlockW, subBlockH;
2077  Int depStrideTmp = depStride * nTxtPerDepthY;
2078  if (vspSize)
2079  {
2080    subBlockW = 8;
2081    subBlockH = 4;
2082  }
2083  else
2084  {
2085    subBlockW = 4;
2086    subBlockH = 8;
2087  }
2088  for( Int y=0; y<height; y+=subBlockH )
2089  {
2090    Pel *refDepthTmp[4];
2091    refDepthTmp[0] = refDepth + refDepStride * y;
2092    refDepthTmp[1] = refDepthTmp[0] + subBlockW - 1;
2093    refDepthTmp[2] = refDepthTmp[0] + refDepStride * (subBlockH - 1);
2094    refDepthTmp[3] = refDepthTmp[2] + subBlockW - 1;
2095    for( Int x=0; x<width; x+=subBlockW )
2096    {
2097      Pel  maxDepthVal;
2098      maxDepthVal = refDepthTmp[0][x];
2099      maxDepthVal = std::max( maxDepthVal, refDepthTmp[1][x]);
2100      maxDepthVal = std::max( maxDepthVal, refDepthTmp[2][x]);
2101      maxDepthVal = std::max( maxDepthVal, refDepthTmp[3][x]);
2102      Pel *depthTmp = &depth[x+y*depStride];
2103      for( Int sY=0; sY<subBlockH; sY+=nTxtPerDepthY )
2104      {
2105        for( Int sX=0; sX<subBlockW; sX+=nTxtPerDepthX )
2106        {
2107          depthTmp[sX] = maxDepthVal;
2108        }
2109        depthTmp += depStrideTmp;
2110      }
2111    }
2112  }
2113#else // SHARP_VSP_BLOCK_IN_AMP_F0102
2114    Int refDepStrideBlock    = refDepStride * height;
2115    Int refDepStrideSubBlock = refDepStride * height/2;
2116    refDepthTmp[0] = refDepth;
2117    refDepthTmp[2] = refDepthTmp[0] + refDepStrideSubBlock;
2118    refDepthTmp[1] = refDepthTmp[2] - refDepStride;
2119    refDepthTmp[3] = refDepthTmp[1] + refDepStrideSubBlock;
2120    offset[3] = width-1;
2121    Bool ULvsBR = false, URvsBL = false;
2122    ULvsBR = refDepthTmp[0][0+offset[0]] < refDepthTmp[3][0+offset[3]];
2123    URvsBL = refDepthTmp[0][0+offset[3]] < refDepthTmp[3][0+offset[0]];
2124    refDepStrideBlock    = refDepStride * blocksize;
2125    refDepStrideSubBlock = refDepStride * subblocksize;
2126    refDepthTmp[0] = refDepth;
2127    refDepthTmp[2] = refDepthTmp[0] + refDepStrideSubBlock;
2128    refDepthTmp[1] = refDepthTmp[2] - refDepStride;
2129    refDepthTmp[3] = refDepthTmp[1] + refDepStrideSubBlock;
2130    offset[3] = blocksize-1;
2131    if( ULvsBR ^ URvsBL )
2132    {
2133    vspSize = 0;//4x8
2134    for( Int y=0; y<height; y+=blocksize )
2135    {
2136      for( Int x=0; x<width; x+=blocksize )
2137      {
2138        { // 4x8
2139          repDepth4x8[0] = refDepthTmp[0][x+offset[0]] > refDepthTmp[0][x+offset[1]] ? refDepthTmp[0][x+offset[0]] : refDepthTmp[0][x+offset[1]];
2140          if( repDepth4x8[0] < refDepthTmp[3][x+offset[0]] )
2141          {
2142            repDepth4x8[0] = refDepthTmp[3][x+offset[0]];
2143          }
2144          if( repDepth4x8[0] < refDepthTmp[3][x+offset[1]] )
2145          {
2146            repDepth4x8[0] = refDepthTmp[3][x+offset[1]];
2147          }
2148          repDepth4x8[1] = refDepthTmp[0][x+offset[2]] > refDepthTmp[0][x+offset[3]] ? refDepthTmp[0][x+offset[2]] : refDepthTmp[0][x+offset[3]];
2149          if( repDepth4x8[1] < refDepthTmp[3][x+offset[2]] )
2150          {
2151            repDepth4x8[1] = refDepthTmp[3][x+offset[2]];
2152          }
2153          if( repDepth4x8[1] < refDepthTmp[3][x+offset[3]] )
2154          {
2155            repDepth4x8[1] = refDepthTmp[3][x+offset[3]];
2156  }
[189]2157
[724]2158          depthTmp = &depth[x];
2159          for( Int sY=0; sY<blocksize; sY+=nTxtPerDepthY )
2160          {
2161            for( Int sX=0; sX<subblocksize; sX+=nTxtPerDepthX )
2162            {
2163              depthTmp[sX] = repDepth4x8[0];
2164            }
2165            depthTmp += depStrideTmp;
2166          }
2167          depthTmp = &depth[x+subblocksize];
2168          for( Int sY=0; sY<blocksize; sY+=nTxtPerDepthY )
2169          {
2170            for( Int sX=0; sX<subblocksize; sX+=nTxtPerDepthX )
2171            {
2172              depthTmp[sX] = repDepth4x8[1];
2173            }
2174            depthTmp += depStrideTmp;
2175          }
2176        }
2177      }
2178      refDepthTmp[0] += refDepStrideBlock;
2179      refDepthTmp[1] += refDepStrideBlock;
2180      refDepthTmp[2] += refDepStrideBlock;
2181      refDepthTmp[3] += refDepStrideBlock;
2182      depth       += depStrideBlock;
2183    }
2184  }
2185  else
2186  { // 8x4
2187    vspSize = 1;
2188    for( Int y=0; y<height; y+=blocksize )
2189    {
2190      for( Int x=0; x<width; x+=blocksize )
2191      {
2192        repDepth8x4[0] = refDepthTmp[0][x+offset[0]] > refDepthTmp[0][x+offset[3]] ? refDepthTmp[0][x+offset[0]] : refDepthTmp[0][x+offset[3]];
2193        if( repDepth8x4[0] < refDepthTmp[1][x+offset[0]] )
2194        {
2195          repDepth8x4[0] = refDepthTmp[1][x+offset[0]];
2196        }
2197        if( repDepth8x4[0] < refDepthTmp[1][x+offset[3]] )
2198        {
2199          repDepth8x4[0] = refDepthTmp[1][x+offset[3]];
2200        }
2201        repDepth8x4[1] = refDepthTmp[2][x+offset[0]] > refDepthTmp[2][x+offset[3]] ? refDepthTmp[2][x+offset[0]] : refDepthTmp[2][x+offset[3]];
2202        if( repDepth8x4[1] < refDepthTmp[3][x+offset[0]] )
2203        {
2204          repDepth8x4[1] = refDepthTmp[3][x+offset[0]];
2205        }
2206        if( repDepth8x4[1] < refDepthTmp[3][x+offset[3]] )
2207        {
2208          repDepth8x4[1] = refDepthTmp[3][x+offset[3]];
2209        }
[189]2210
[724]2211        depthTmp = &depth[x];
2212        for( Int sY=0; sY<subblocksize; sY+=nTxtPerDepthY )
2213        {
2214          for( Int sX=0; sX<blocksize; sX+=nTxtPerDepthX )
2215          {
2216            depthTmp[sX] = repDepth8x4[0];
2217          }
2218          depthTmp += depStrideTmp;
2219        }
2220        for( Int sY=0; sY<subblocksize; sY+=nTxtPerDepthY )
2221        {
2222          for( Int sX=0; sX<blocksize; sX+=nTxtPerDepthX )
2223          {
2224            depthTmp[sX] = repDepth8x4[1];
2225          }
2226          depthTmp += depStrideTmp;
[608]2227}
[724]2228      }
2229      refDepthTmp[0] += refDepStrideBlock;
2230      refDepthTmp[1] += refDepStrideBlock;
2231      refDepthTmp[2] += refDepStrideBlock;
2232      refDepthTmp[3] += refDepStrideBlock;
2233      depth       += depStrideBlock;
2234    }
2235  }
2236#endif   
2237#endif
2238#if !SHARP_VSP_BLOCK_IN_AMP_F0102
2239  }
2240#endif
[608]2241
[724]2242
2243}
2244#if MTK_F0109_LG_F0120_VSP_BLOCK
2245Void TComPrediction::xPredInterLumaBlkFromDM( TComDataCU *cu, TComPicYuv *picRef, TComYuv *yuvDepth, Int* shiftLUT, TComMv *mv, UInt partAddr, Int width, Int height, Bool isDepth, TComYuv *&yuvDst, Bool isBi, Int vspSize)
2246#else
[608]2247Void TComPrediction::xPredInterLumaBlkFromDM( TComDataCU *cu, TComPicYuv *picRef, TComYuv *yuvDepth, Int* shiftLUT, TComMv *mv, UInt partAddr, Int width, Int height, Bool isDepth, TComYuv *&yuvDst, Bool isBi )
[724]2248#endif
[608]2249{
2250  Int nTxtPerDepthX = H_3D_VSP_BLOCKSIZE;
2251  Int nTxtPerDepthY = H_3D_VSP_BLOCKSIZE;
2252 
[724]2253#if MTK_F0109_LG_F0120_VSP_BLOCK
2254  nTxtPerDepthX = nTxtPerDepthX << vspSize;
2255  nTxtPerDepthY = nTxtPerDepthY << (1-vspSize);
2256#endif
[608]2257  Int refStride = picRef->getStride();
2258  Int dstStride = yuvDst->getStride();
2259  Int depStride = yuvDepth->getStride();
2260  Int refStrideBlock = refStride  * nTxtPerDepthY;
2261  Int dstStrideBlock = dstStride * nTxtPerDepthY;
2262  Int depStrideBlock = depStride * nTxtPerDepthY;
2263
2264  Pel *ref    = picRef->getLumaAddr( cu->getAddr(), cu->getZorderIdxInCU() + partAddr );
2265  Pel *dst    = yuvDst->getLumaAddr(partAddr);
2266  Pel *depth  = yuvDepth->getLumaAddr();
2267
2268#if H_3D_VSP_BLOCKSIZE == 1
2269#if H_3D_VSP_CONSTRAINED
2270  //get LUT based horizontal reference range
2271  Int range = xGetConstrainedSize(width, height);
2272
2273  // The minimum depth value
2274  Int minRelativePos = MAX_INT;
2275  Int maxRelativePos = MIN_INT;
2276
2277  Pel* depthTemp, *depthInitial=depth;
2278  for (Int yTxt = 0; yTxt < height; yTxt++)
2279  {
2280    for (Int xTxt = 0; xTxt < width; xTxt++)
2281    {
2282      if (depthPosX+xTxt < widthDepth)
[189]2283      {
[608]2284        depthTemp = depthInitial + xTxt;
[189]2285      }
2286      else
2287      {
[608]2288        depthTemp = depthInitial + (widthDepth - depthPosX - 1);
[189]2289      }
2290
[608]2291      Int disparity = shiftLUT[ *depthTemp ]; // << iShiftPrec;
2292      Int disparityInt = disparity >> 2;
[189]2293
[608]2294      if( disparity <= 0)
[189]2295      {
[608]2296        if (minRelativePos > disparityInt+xTxt)
2297        {
2298          minRelativePos = disparityInt+xTxt;
2299        }
[189]2300      }
2301      else
2302      {
[608]2303        if (maxRelativePos < disparityInt+xTxt)
2304        {
2305          maxRelativePos = disparityInt+xTxt;
2306        }
[189]2307      }
2308    }
[608]2309    if (depthPosY+yTxt < heightDepth)
2310    {
2311      depthInitial = depthInitial + depStride;
2312    }
2313  }
[56]2314
[608]2315  Int disparity_tmp = shiftLUT[ *depth ]; // << iShiftPrec;
2316  if (disparity_tmp <= 0)
[56]2317  {
[608]2318    maxRelativePos = minRelativePos + range -1 ;
[56]2319  }
[608]2320  else
[56]2321  {
[608]2322    minRelativePos = maxRelativePos - range +1 ;
[56]2323  }
[608]2324#endif
2325#endif // H_3D_VSP_BLOCKSIZE == 1
[56]2326
[608]2327  TComMv dv(0, 0);
[56]2328
[608]2329  for ( Int yTxt = 0; yTxt < height; yTxt += nTxtPerDepthY )
2330  {
2331    for ( Int xTxt = 0; xTxt < width; xTxt += nTxtPerDepthX )
2332    {
2333      Pel repDepth = depth[ xTxt ];
2334      assert( repDepth >= 0 && repDepth <= 255 );
2335
2336      Int disparity = shiftLUT[ repDepth ]; // remove << iShiftPrec ??
2337      Int xFrac = disparity & 0x3;
2338
2339      dv.setHor( disparity );
2340      cu->clipMv( dv );
2341
2342      Int refOffset = xTxt + (dv.getHor() >> 2);
2343     
2344#if H_3D_VSP_CONSTRAINED
2345      if(refOffset<minRelativePos || refOffset>maxRelativePos)
2346      {
2347        xFrac = 0;
2348      }
2349      refOffset = Clip3(minRelativePos, maxRelativePos, refOffset);
[5]2350#endif
[608]2351
2352      assert( ref[refOffset] >= 0 && ref[refOffset]<= 255 );
2353      m_if.filterHorLuma( &ref[refOffset], refStride, &dst[xTxt], dstStride, nTxtPerDepthX, nTxtPerDepthY, xFrac, !isBi );
2354    }
2355    ref   += refStrideBlock;
2356    dst   += dstStrideBlock;
2357    depth += depStrideBlock;
[443]2358  }
2359
2360}
[608]2361
[724]2362#if MTK_F0109_LG_F0120_VSP_BLOCK
2363Void TComPrediction::xPredInterChromaBlkFromDM  ( TComDataCU *cu, TComPicYuv *picRef, TComYuv *yuvDepth, Int* shiftLUT, TComMv *mv, UInt partAddr, Int width, Int height, Bool isDepth, TComYuv *&yuvDst, Bool isBi, Int vspSize)
2364#else
[608]2365Void TComPrediction::xPredInterChromaBlkFromDM  ( TComDataCU *cu, TComPicYuv *picRef, TComYuv *yuvDepth, Int* shiftLUT, TComMv *mv, UInt partAddr, Int width, Int height, Bool isDepth, TComYuv *&yuvDst, Bool isBi )
[724]2366#endif
[608]2367{
2368#if (H_3D_VSP_BLOCKSIZE==1)
2369  Int nTxtPerDepthX = 1;
2370  Int nTxtPerDepthY = 1;
[443]2371#else
[608]2372  Int nTxtPerDepthX = H_3D_VSP_BLOCKSIZE >> 1;
2373  Int nTxtPerDepthY = H_3D_VSP_BLOCKSIZE >> 1;
2374#endif
[2]2375
[724]2376#if MTK_F0109_LG_F0120_VSP_BLOCK
2377  nTxtPerDepthX = nTxtPerDepthX << vspSize;
2378  nTxtPerDepthY = nTxtPerDepthY << (1-vspSize);
2379#endif
[608]2380  Int refStride = picRef->getCStride();
2381  Int dstStride = yuvDst->getCStride();
2382  Int depStride = yuvDepth->getStride();
2383  Int refStrideBlock = refStride * nTxtPerDepthY;
2384  Int dstStrideBlock = dstStride * nTxtPerDepthY;
2385  Int depStrideBlock = depStride * (nTxtPerDepthY<<1);
[2]2386
[608]2387  Pel *refCb  = picRef->getCbAddr( cu->getAddr(), cu->getZorderIdxInCU() + partAddr );
2388  Pel *refCr  = picRef->getCrAddr( cu->getAddr(), cu->getZorderIdxInCU() + partAddr );
2389  Pel *dstCb  = yuvDst->getCbAddr(partAddr);
2390  Pel *dstCr  = yuvDst->getCrAddr(partAddr);
2391  Pel *depth  = yuvDepth->getLumaAddr();
[56]2392
[608]2393#if H_3D_VSP_BLOCKSIZE == 1
2394#if H_3D_VSP_CONSTRAINED
2395  //get LUT based horizontal reference range
2396  Int range = xGetConstrainedSize(width, height, false);
[296]2397
[608]2398  // The minimum depth value
2399  Int minRelativePos = MAX_INT;
2400  Int maxRelativePos = MIN_INT;
2401
2402  Int depthTmp;
2403  for (Int yTxt=0; yTxt<height; yTxt++)
[56]2404  {
[608]2405    for (Int xTxt=0; xTxt<width; xTxt++)
[56]2406    {
[608]2407      depthTmp = m_pDepthBlock[xTxt+yTxt*width];
2408      Int disparity = shiftLUT[ depthTmp ]; // << iShiftPrec;
2409      Int disparityInt = disparity >> 3;//in chroma resolution
2410
2411      if (disparityInt < 0)
[56]2412      {
[608]2413        if (minRelativePos > disparityInt+xTxt)
2414        {
2415          minRelativePos = disparityInt+xTxt;
2416        }
[56]2417      }
2418      else
2419      {
[608]2420        if (maxRelativePos < disparityInt+xTxt)
2421        {
2422          maxRelativePos = disparityInt+xTxt;
2423        }
[56]2424      }
2425    }
2426  }
2427
[608]2428  depthTmp = m_pDepthBlock[0];
2429  Int disparity_tmp = shiftLUT[ depthTmp ]; // << iShiftPrec;
2430  if ( disparity_tmp < 0 )
[56]2431  {
[608]2432    maxRelativePos = minRelativePos + range - 1;
[56]2433  }
[608]2434  else
[56]2435  {
[608]2436    minRelativePos = maxRelativePos - range + 1;
[56]2437  }
[2]2438
[608]2439#endif // H_3D_VSP_CONSTRAINED
2440#endif // H_3D_VSP_BLOCKSIZE == 1
2441
2442  TComMv dv(0, 0);
2443  // luma size -> chroma size
2444  height >>= 1;
2445  width  >>= 1;
2446
2447  for ( Int yTxt = 0; yTxt < height; yTxt += nTxtPerDepthY )
[5]2448  {
[608]2449    for ( Int xTxt = 0; xTxt < width; xTxt += nTxtPerDepthX )
[5]2450    {
[608]2451      Pel repDepth = depth[ xTxt<<1 ];
2452      assert( repDepth >= 0 && repDepth <= 255 );
2453
2454      Int disparity = shiftLUT[ repDepth ]; // remove << iShiftPrec;
2455      Int xFrac = disparity & 0x7;
2456     
2457      dv.setHor( disparity );
2458      cu->clipMv( dv );
2459
2460      Int refOffset = xTxt + (dv.getHor() >> 3);
2461
2462#if H_3D_VSP_CONSTRAINED
2463      if(refOffset<minRelativePos || refOffset>maxRelativePos)
[5]2464      {
[608]2465        xFrac = 0;
[5]2466      }
[608]2467      refOffset = Clip3(minRelativePos, maxRelativePos, refOffset);
2468#endif
2469
2470      assert( refCb[refOffset] >= 0 && refCb[refOffset]<= 255 );
2471      assert( refCr[refOffset] >= 0 && refCr[refOffset]<= 255 );
2472
2473      m_if.filterHorChroma( &refCb[refOffset], refStride, &dstCb[xTxt], dstStride, nTxtPerDepthX, nTxtPerDepthY, xFrac, !isBi );
2474      m_if.filterHorChroma( &refCr[refOffset], refStride, &dstCr[xTxt], dstStride, nTxtPerDepthX, nTxtPerDepthY, xFrac, !isBi );
[5]2475    }
[608]2476    refCb += refStrideBlock;
2477    refCr += refStrideBlock;
2478    dstCb += dstStrideBlock;
2479    dstCr += dstStrideBlock;
2480    depth += depStrideBlock;
[5]2481  }
2482}
[2]2483
[5]2484
[608]2485#if H_3D_VSP_CONSTRAINED
2486Int TComPrediction::xGetConstrainedSize(Int nPbW, Int nPbH, Bool bLuma)
[56]2487{
[608]2488  Int iSize = 0;
2489  if (bLuma)
[2]2490  {
[608]2491    Int iArea = (nPbW+7) * (nPbH+7);
2492    Int iAlpha = iArea / nPbH - nPbW - 7;
2493    iSize = iAlpha + nPbW;
[2]2494  }
[608]2495  else // chroma
2496  {
2497    Int iArea = (nPbW+2) * (nPbH+2);
2498    Int iAlpha = iArea / nPbH - nPbW - 4;
2499    iSize = iAlpha + nPbW;
2500  }
2501  return iSize;
[2]2502}
[608]2503#endif // H_3D_VSP_CONSTRAINED
[2]2504
[608]2505#endif // H_3D_VSP
2506
2507#if H_3D_DIM
2508Void TComPrediction::xPredBiSegDCs( Int* ptrSrc, UInt srcStride, Bool* biSegPattern, Int patternStride, Pel& predDC1, Pel& predDC2 )
[2]2509{
[608]2510  Int  refDC1, refDC2;
2511  const Int  iTR = (   patternStride - 1        ) - srcStride;
2512  const Int  iTM = ( ( patternStride - 1 ) >> 1 ) - srcStride;
2513  const Int  iLB = (   patternStride - 1        ) * srcStride - 1;
2514  const Int  iLM = ( ( patternStride - 1 ) >> 1 ) * srcStride - 1;
[2]2515
[608]2516  Bool bL = ( biSegPattern[0] != biSegPattern[(patternStride-1)*patternStride] );
2517  Bool bT = ( biSegPattern[0] != biSegPattern[(patternStride-1)]               );
2518
2519  if( bL == bT )
[56]2520  {
[608]2521    refDC1 = bL ? ( ptrSrc[iTR] + ptrSrc[iLB] )>>1 : 1<<( g_bitDepthY - 1 );
2522    refDC2 =      ( ptrSrc[ -1] + ptrSrc[-(Int)srcStride] )>>1;
[56]2523  }
2524  else
2525  {
[608]2526    refDC1 = bL ? ptrSrc[iLB] : ptrSrc[iTR];
2527    refDC2 = bL ? ptrSrc[iTM] : ptrSrc[iLM];
[56]2528  }
2529
[608]2530  predDC1 = biSegPattern[0] ? refDC1 : refDC2;
2531  predDC2 = biSegPattern[0] ? refDC2 : refDC1;
[2]2532}
2533
[608]2534Void TComPrediction::xAssignBiSegDCs( Pel* ptrDst, UInt dstStride, Bool* biSegPattern, Int patternStride, Pel valDC1, Pel valDC2 )
[56]2535{
[608]2536  if( dstStride == patternStride )
2537  {
2538    for( UInt k = 0; k < (patternStride * patternStride); k++ )
2539    {
2540      if( true == biSegPattern[k] ) { ptrDst[k] = valDC2; }
2541      else                          { ptrDst[k] = valDC1; }
2542    }
[443]2543  }
[608]2544  else
2545  {
2546    Pel* piTemp = ptrDst;
2547    for( UInt uiY = 0; uiY < patternStride; uiY++ )
2548    {
2549      for( UInt uiX = 0; uiX < patternStride; uiX++ )
2550      {
2551        if( true == biSegPattern[uiX] ) { piTemp[uiX] = valDC2; }
2552        else                            { piTemp[uiX] = valDC1; }
2553      }
2554      piTemp       += dstStride;
2555      biSegPattern += patternStride;
2556    }
[443]2557  }
[56]2558}
2559
[608]2560#if H_3D_DIM_DMM
[724]2561#if !SEC_DMM3_RBC_F0147
[608]2562UInt TComPrediction::xPredWedgeFromTex( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, UInt intraTabIdx )
[56]2563{
[608]2564  TComPic*      pcPicTex = pcCU->getSlice()->getTexturePic();
2565  assert( pcPicTex != NULL );
2566  TComDataCU*   pcColTexCU = pcPicTex->getCU(pcCU->getAddr());
2567  UInt          uiTexPartIdx = pcCU->getZorderIdxInCU() + uiAbsPartIdx;
2568  Int           uiColTexIntraDir = pcColTexCU->isIntra( uiTexPartIdx ) ? pcColTexCU->getLumaIntraDir( uiTexPartIdx ) : 255;
[56]2569
[622]2570  assert( uiColTexIntraDir > DC_IDX && uiColTexIntraDir < 35 );
2571  return g_aauiWdgLstM3[g_aucConvertToBit[uiWidth]][uiColTexIntraDir-2].at(intraTabIdx);
[56]2572}
[724]2573#endif
[56]2574
[608]2575Void TComPrediction::xPredContourFromTex( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, TComWedgelet* pcContourWedge )
[56]2576{
[608]2577  pcContourWedge->clear();
[56]2578
[608]2579  // get copy of co-located texture luma block
2580  TComYuv cTempYuv;
2581  cTempYuv.create( uiWidth, uiHeight ); 
2582  cTempYuv.clear();
2583  Pel* piRefBlkY = cTempYuv.getLumaAddr();
2584  xCopyTextureLumaBlock( pcCU, uiAbsPartIdx, piRefBlkY, uiWidth, uiHeight );
2585  piRefBlkY = cTempYuv.getLumaAddr();
[56]2586
[608]2587  // find contour for texture luma block
2588  UInt iDC = 0;
2589  for( UInt k = 0; k < (uiWidth*uiHeight); k++ ) 
2590  { 
2591    iDC += piRefBlkY[k]; 
2592  }
2593
[655]2594  Int cuMaxLog2Size = g_aucConvertToBit[g_uiMaxCUWidth]+2;   //
2595  iDC = iDC >> (cuMaxLog2Size - pcCU->getDepth(0))*2;        //  iDC /= (uiWidth*uiHeight);
2596
[608]2597  piRefBlkY = cTempYuv.getLumaAddr();
[56]2598
[608]2599  Bool* pabContourPattern = pcContourWedge->getPattern();
2600  for( UInt k = 0; k < (uiWidth*uiHeight); k++ ) 
[443]2601  { 
[608]2602    pabContourPattern[k] = (piRefBlkY[k] > iDC) ? true : false;
[443]2603  }
[608]2604
2605  cTempYuv.destroy();
[56]2606}
2607
[608]2608
2609Void TComPrediction::xCopyTextureLumaBlock( TComDataCU* pcCU, UInt uiAbsPartIdx, Pel* piDestBlockY, UInt uiWidth, UInt uiHeight )
[56]2610{
[608]2611  TComPicYuv* pcPicYuvRef = pcCU->getSlice()->getTexturePic()->getPicYuvRec();
2612  assert( pcPicYuvRef != NULL );
2613  Int         iRefStride = pcPicYuvRef->getStride();
2614  Pel*        piRefY = pcPicYuvRef->getLumaAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() + uiAbsPartIdx );
[56]2615
[608]2616  for ( Int y = 0; y < uiHeight; y++ )
[56]2617  {
[608]2618    ::memcpy(piDestBlockY, piRefY, sizeof(Pel)*uiWidth);
2619    piDestBlockY += uiWidth;
2620    piRefY += iRefStride;
[56]2621  }
2622}
[655]2623#endif
[56]2624
[608]2625#if H_3D_DIM_RBC
2626Void TComPrediction::xDeltaDCQuantScaleUp( TComDataCU* pcCU, Pel& rDeltaDC )
2627{
2628  Int  iSign  = rDeltaDC < 0 ? -1 : 1;
2629  UInt uiAbs  = abs( rDeltaDC );
[2]2630
[608]2631  Int iQp = pcCU->getQP(0);
2632  Double dMax = (Double)( 1<<( g_bitDepthY - 1 ) );
2633  Double dStepSize = Clip3( 1.0, dMax, pow( 2.0, iQp/10.0 - 2.0 ) );
2634
2635  rDeltaDC = iSign * roftoi( uiAbs * dStepSize );
2636  return;
[2]2637}
2638
[608]2639Void TComPrediction::xDeltaDCQuantScaleDown( TComDataCU*  pcCU, Pel& rDeltaDC )
[2]2640{
[608]2641  Int  iSign  = rDeltaDC < 0 ? -1 : 1;
2642  UInt uiAbs  = abs( rDeltaDC );
2643
2644  Int iQp = pcCU->getQP(0);
2645  Double dMax = (Double)( 1<<( g_bitDepthY - 1 ) );
2646  Double dStepSize = Clip3( 1.0, dMax, pow( 2.0, iQp/10.0 - 2.0 ) );
2647
2648  rDeltaDC = iSign * roftoi( uiAbs / dStepSize );
2649  return;
2650}
2651#endif
2652#if H_3D_DIM_SDC
2653Void TComPrediction::analyzeSegmentsSDC( Pel* pOrig, UInt uiStride, UInt uiSize, Pel* rpSegMeans, UInt uiNumSegments, Bool* pMask, UInt uiMaskStride
2654                                         ,UInt uiIntraMode
2655                                         ,Bool orgDC
2656                                        )
2657{
2658  Int iSumDepth[2];
2659  memset(iSumDepth, 0, sizeof(Int)*2);
2660  Int iSumPix[2];
2661  memset(iSumPix, 0, sizeof(Int)*2);
2662 
2663  if (orgDC == false)
[2]2664  {
[608]2665    if ( getDimType(uiIntraMode) == DMM1_IDX )
2666    {
2667      UChar ucSegmentLT = pMask[0];
2668      UChar ucSegmentRT = pMask[uiSize-1];
2669      UChar ucSegmentLB = pMask[uiMaskStride * (uiSize-1)]; 
2670      UChar ucSegmentRB = pMask[uiMaskStride * (uiSize-1) + (uiSize-1)]; 
2671
2672      rpSegMeans[ucSegmentLT] = pOrig[0];
2673      rpSegMeans[ucSegmentRT] = pOrig[uiSize-1];
2674      rpSegMeans[ucSegmentLB] = pOrig[uiStride * (uiSize-1) ];
2675      rpSegMeans[ucSegmentRB] = pOrig[uiStride * (uiSize-1) + (uiSize-1) ];
2676    }
2677    else if (uiIntraMode == PLANAR_IDX)
2678    {
2679      Pel* pLeftTop = pOrig;
2680      Pel* pRightTop = pOrig + (uiSize-1);
2681      Pel* pLeftBottom = (pOrig+ (uiStride*(uiSize-1)));
2682      Pel* pRightBottom = (pOrig+ (uiStride*(uiSize-1)) + (uiSize-1));
2683
2684      rpSegMeans[0] = (*pLeftTop + *pRightTop + *pLeftBottom + *pRightBottom + 2)>>2;
2685    }
2686    return;
[2]2687  }
[608]2688
2689  Int subSamplePix;
2690  if ( uiSize == 64 || uiSize == 32 )
[2]2691  {
[608]2692    subSamplePix = 2;
[2]2693  }
[608]2694  else
[2]2695  {
[608]2696    subSamplePix = 1;
[2]2697  }
[608]2698  for (Int y=0; y<uiSize; y+=subSamplePix)
[2]2699  {
[608]2700    for (Int x=0; x<uiSize; x+=subSamplePix)
2701    {
2702      UChar ucSegment = pMask?(UChar)pMask[x]:0;
2703      assert( ucSegment < uiNumSegments );
2704     
2705      iSumDepth[ucSegment] += pOrig[x];
2706      iSumPix[ucSegment]   += 1;
2707    }
2708   
2709    pOrig  += uiStride*subSamplePix;
2710    pMask  += uiMaskStride*subSamplePix;
[2]2711  }
[608]2712 
2713  // compute mean for each segment
2714  for( UChar ucSeg = 0; ucSeg < uiNumSegments; ucSeg++ )
[2]2715  {
[608]2716    if( iSumPix[ucSeg] > 0 )
2717      rpSegMeans[ucSeg] = iSumDepth[ucSeg] / iSumPix[ucSeg];
2718    else
2719      rpSegMeans[ucSeg] = 0;  // this happens for zero-segments
[2]2720  }
2721}
[608]2722#endif // H_3D_DIM_SDC
2723#endif
[56]2724//! \}
Note: See TracBrowser for help on using the repository browser.