source: 3DVCSoftware/branches/HTM-9.2-dev0/source/Lib/TLibCommon/TComPrediction.cpp @ 764

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

Cleanup part 1

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