source: 3DVCSoftware/branches/HTM-7.0-Fix/source/Lib/TLibCommon/TComPrediction.cpp @ 458

Last change on this file since 458 was 458, checked in by tech, 11 years ago

Added NCKU_BUG_FIX related to disparity derivation.

  • Property svn:eol-style set to native
File size: 144.0 KB
Line 
1/* The copyright in this software is being made available under the BSD
2 * License, included below. This software may be subject to other third party
3 * and contributor rights, including patent rights, and no such rights are
4 * granted under this license. 
5 *
6 * Copyright (c) 2010-2012, 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
48#if LGE_EDGE_INTRA_A0070
49#define MAX_DISTANCE_EDGEINTRA 255
50#endif
51
52#if HHI_DELTADC_DLT_D0035
53#define GetDepthValue2Idx(val)     (pcCU->getSlice()->getSPS()->depthValue2idx(val))
54#define GetIdx2DepthValue(val)     (pcCU->getSlice()->getSPS()->idx2DepthValue(val))
55#endif
56
57#if MERL_General_Fix
58#if MERL_VSP_C0152
59#if MERL_CVSP_D0165
60Int TComPrediction::m_iRangeLuma[12]   = {14, 34, 21, 15, 36, 26, 21, 49, 41, 36, 80, 72};
61Int TComPrediction::m_iRangeChroma[12] = { 2,  8,  5,  4, 11,  9,  8, 19, 17, 15, 34, 32};
62#endif
63#endif
64#endif
65
66TComPrediction::TComPrediction()
67: m_pLumaRecBuffer(0)
68{
69  m_piYuvExt = NULL;
70#if MERL_VSP_C0152
71  m_pDepth = (Int*) malloc(64*64*sizeof(Int)); // TODO: Use a smart way to determine the size of the array
72  if (m_pDepth == NULL)
73  {
74      printf("ERROR: UKTGHU, No memory allocated.\n");
75  }
76#endif
77}
78
79TComPrediction::~TComPrediction()
80{
81 
82#if MERL_VSP_C0152
83  if (m_pDepth != NULL)
84  {
85      free(m_pDepth);
86  }
87#endif
88  delete[] m_piYuvExt;
89
90  m_acYuvPred[0].destroy();
91  m_acYuvPred[1].destroy();
92
93  m_cYuvPredTemp.destroy();
94#if QC_ARP_D0177
95  m_acYuvPredBase[0].destroy();
96  m_acYuvPredBase[1].destroy();
97  m_acYuvDiff[0].destroy();
98  m_acYuvDiff[1].destroy();
99#endif
100  if( m_pLumaRecBuffer )
101  {
102    delete [] m_pLumaRecBuffer;
103  }
104 
105  Int i, j;
106  for (i = 0; i < 4; i++)
107  {
108    for (j = 0; j < 4; j++)
109    {
110      m_filteredBlock[i][j].destroy();
111    }
112    m_filteredBlockTmp[i].destroy();
113  }
114}
115
116Void TComPrediction::initTempBuff()
117{
118  if( m_piYuvExt == NULL )
119  {
120    Int extWidth  = g_uiMaxCUWidth + 16; 
121    Int extHeight = g_uiMaxCUHeight + 1;
122    Int i, j;
123    for (i = 0; i < 4; i++)
124    {
125      m_filteredBlockTmp[i].create(extWidth, extHeight + 7);
126      for (j = 0; j < 4; j++)
127      {
128        m_filteredBlock[i][j].create(extWidth, extHeight);
129      }
130    }
131    m_iYuvExtHeight  = ((g_uiMaxCUHeight + 2) << 4);
132    m_iYuvExtStride = ((g_uiMaxCUWidth  + 8) << 4);
133    m_piYuvExt = new Int[ m_iYuvExtStride * m_iYuvExtHeight ];
134
135    // new structure
136    m_acYuvPred[0] .create( g_uiMaxCUWidth, g_uiMaxCUHeight );
137    m_acYuvPred[1] .create( g_uiMaxCUWidth, g_uiMaxCUHeight );
138
139    m_cYuvPredTemp.create( g_uiMaxCUWidth, g_uiMaxCUHeight );
140#if QC_ARP_D0177
141    m_acYuvPredBase[0] .create( g_uiMaxCUWidth, g_uiMaxCUHeight );
142    m_acYuvPredBase[1] .create( g_uiMaxCUWidth, g_uiMaxCUHeight );
143    m_acYuvDiff    [0] .create( g_uiMaxCUWidth, g_uiMaxCUHeight );
144    m_acYuvDiff    [1] .create( g_uiMaxCUWidth, g_uiMaxCUHeight );
145#endif
146  }
147
148  m_iLumaRecStride =  (g_uiMaxCUWidth>>1) + 1;
149  m_pLumaRecBuffer = new Pel[ m_iLumaRecStride * m_iLumaRecStride ];
150
151  for( Int i = 1; i < 64; i++ )
152  {
153    m_uiaShift[i-1] = ( (1 << 15) + i/2 ) / i;
154  }
155}
156
157// ====================================================================================================================
158// Public member functions
159// ====================================================================================================================
160
161// Function for calculating DC value of the reference samples used in Intra prediction
162Pel TComPrediction::predIntraGetPredValDC( Int* pSrc, Int iSrcStride, UInt iWidth, UInt iHeight, Bool bAbove, Bool bLeft )
163{
164  Int iInd, iSum = 0;
165  Pel pDcVal;
166
167  if (bAbove)
168  {
169    for (iInd = 0;iInd < iWidth;iInd++)
170    {
171      iSum += pSrc[iInd-iSrcStride];
172    }
173  }
174  if (bLeft)
175  {
176    for (iInd = 0;iInd < iHeight;iInd++)
177    {
178      iSum += pSrc[iInd*iSrcStride-1];
179    }
180  }
181
182  if (bAbove && bLeft)
183  {
184    pDcVal = (iSum + iWidth) / (iWidth + iHeight);
185  }
186  else if (bAbove)
187  {
188    pDcVal = (iSum + iWidth/2) / iWidth;
189  }
190  else if (bLeft)
191  {
192    pDcVal = (iSum + iHeight/2) / iHeight;
193  }
194  else
195  {
196    pDcVal = pSrc[-1]; // Default DC value already calculated and placed in the prediction array if no neighbors are available
197  }
198 
199  return pDcVal;
200}
201
202// Function for deriving the angular Intra predictions
203
204/** Function for deriving the simplified angular intra predictions.
205 * \param pSrc pointer to reconstructed sample array
206 * \param srcStride the stride of the reconstructed sample array
207 * \param rpDst reference to pointer for the prediction sample array
208 * \param dstStride the stride of the prediction sample array
209 * \param width the width of the block
210 * \param height the height of the block
211 * \param dirMode the intra prediction mode index
212 * \param blkAboveAvailable boolean indication if the block above is available
213 * \param blkLeftAvailable boolean indication if the block to the left is available
214 *
215 * This function derives the prediction samples for the angular mode based on the prediction direction indicated by
216 * the prediction mode index. The prediction direction is given by the displacement of the bottom row of the block and
217 * the reference row above the block in the case of vertical prediction or displacement of the rightmost column
218 * of the block and reference column left from the block in the case of the horizontal prediction. The displacement
219 * is signalled at 1/32 pixel accuracy. When projection of the predicted pixel falls inbetween reference samples,
220 * the predicted value for the pixel is linearly interpolated from the reference samples. All reference samples are taken
221 * from the extended main reference.
222 */
223Void TComPrediction::xPredIntraAng( Int* pSrc, Int srcStride, Pel*& rpDst, Int dstStride, UInt width, UInt height, UInt dirMode, Bool blkAboveAvailable, Bool blkLeftAvailable, Bool bFilter )
224{
225  Int k,l;
226  Int blkSize        = width;
227  Pel* pDst          = rpDst;
228
229  // Map the mode index to main prediction direction and angle
230  assert( dirMode > 0 ); //no planar
231  Bool modeDC        = dirMode < 2;
232  Bool modeHor       = !modeDC && (dirMode < 18);
233  Bool modeVer       = !modeDC && !modeHor;
234  Int intraPredAngle = modeVer ? (Int)dirMode - VER_IDX : modeHor ? -((Int)dirMode - HOR_IDX) : 0;
235  Int absAng         = abs(intraPredAngle);
236  Int signAng        = intraPredAngle < 0 ? -1 : 1;
237
238  // Set bitshifts and scale the angle parameter to block size
239  Int angTable[9]    = {0,    2,    5,   9,  13,  17,  21,  26,  32};
240  Int invAngTable[9] = {0, 4096, 1638, 910, 630, 482, 390, 315, 256}; // (256 * 32) / Angle
241  Int invAngle       = invAngTable[absAng];
242  absAng             = angTable[absAng];
243  intraPredAngle     = signAng * absAng;
244
245  // Do the DC prediction
246  if (modeDC)
247  {
248    Pel dcval = predIntraGetPredValDC(pSrc, srcStride, width, height, blkAboveAvailable, blkLeftAvailable);
249
250    for (k=0;k<blkSize;k++)
251    {
252      for (l=0;l<blkSize;l++)
253      {
254        pDst[k*dstStride+l] = dcval;
255      }
256    }
257  }
258
259  // Do angular predictions
260  else
261  {
262    Pel* refMain;
263    Pel* refSide;
264    Pel  refAbove[2*MAX_CU_SIZE+1];
265    Pel  refLeft[2*MAX_CU_SIZE+1];
266
267    // Initialise the Main and Left reference array.
268    if (intraPredAngle < 0)
269    {
270      for (k=0;k<blkSize+1;k++)
271      {
272        refAbove[k+blkSize-1] = pSrc[k-srcStride-1];
273      }
274      for (k=0;k<blkSize+1;k++)
275      {
276        refLeft[k+blkSize-1] = pSrc[(k-1)*srcStride-1];
277      }
278      refMain = (modeVer ? refAbove : refLeft) + (blkSize-1);
279      refSide = (modeVer ? refLeft : refAbove) + (blkSize-1);
280
281      // Extend the Main reference to the left.
282      Int invAngleSum    = 128;       // rounding for (shift by 8)
283      for (k=-1; k>blkSize*intraPredAngle>>5; k--)
284      {
285        invAngleSum += invAngle;
286        refMain[k] = refSide[invAngleSum>>8];
287      }
288    }
289    else
290    {
291      for (k=0;k<2*blkSize+1;k++)
292      {
293        refAbove[k] = pSrc[k-srcStride-1];
294      }
295      for (k=0;k<2*blkSize+1;k++)
296      {
297        refLeft[k] = pSrc[(k-1)*srcStride-1];
298      }
299      refMain = modeVer ? refAbove : refLeft;
300      refSide = modeVer ? refLeft  : refAbove;
301    }
302
303    if (intraPredAngle == 0)
304    {
305      for (k=0;k<blkSize;k++)
306      {
307        for (l=0;l<blkSize;l++)
308        {
309          pDst[k*dstStride+l] = refMain[l+1];
310        }
311      }
312
313      if ( bFilter )
314      {
315        for (k=0;k<blkSize;k++)
316        {
317          pDst[k*dstStride] = Clip ( pDst[k*dstStride] + (( refSide[k+1] - refSide[0] ) >> 1) );
318        }
319      }
320    }
321    else
322    {
323      Int deltaPos=0;
324      Int deltaInt;
325      Int deltaFract;
326      Int refMainIndex;
327
328      for (k=0;k<blkSize;k++)
329      {
330        deltaPos += intraPredAngle;
331        deltaInt   = deltaPos >> 5;
332        deltaFract = deltaPos & (32 - 1);
333
334        if (deltaFract)
335        {
336          // Do linear filtering
337          for (l=0;l<blkSize;l++)
338          {
339            refMainIndex        = l+deltaInt+1;
340            pDst[k*dstStride+l] = (Pel) ( ((32-deltaFract)*refMain[refMainIndex]+deltaFract*refMain[refMainIndex+1]+16) >> 5 );
341          }
342        }
343        else
344        {
345          // Just copy the integer samples
346          for (l=0;l<blkSize;l++)
347          {
348            pDst[k*dstStride+l] = refMain[l+deltaInt+1];
349          }
350        }
351      }
352    }
353
354    // Flip the block if this is the horizontal mode
355    if (modeHor)
356    {
357      Pel  tmp;
358      for (k=0;k<blkSize-1;k++)
359      {
360        for (l=k+1;l<blkSize;l++)
361        {
362          tmp                 = pDst[k*dstStride+l];
363          pDst[k*dstStride+l] = pDst[l*dstStride+k];
364          pDst[l*dstStride+k] = tmp;
365        }
366      }
367    }
368  }
369}
370
371Void TComPrediction::predIntraLumaAng(TComPattern* pcTComPattern, UInt uiDirMode, Pel* piPred, UInt uiStride, Int iWidth, Int iHeight,  TComDataCU* pcCU, Bool bAbove, Bool bLeft )
372{
373  Pel *pDst = piPred;
374  Int *ptrSrc;
375
376  assert( g_aucConvertToBit[ iWidth ] >= 0 ); //   4x  4
377  assert( g_aucConvertToBit[ iWidth ] <= 5 ); // 128x128
378  assert( iWidth == iHeight  );
379
380  ptrSrc = pcTComPattern->getPredictorPtr( uiDirMode, g_aucConvertToBit[ iWidth ] + 2, m_piYuvExt );
381
382  // get starting pixel in block
383  Int sw = 2 * iWidth + 1;
384
385  // Create the prediction
386  if ( uiDirMode == PLANAR_IDX )
387  {
388    xPredIntraPlanar( ptrSrc+sw+1, sw, pDst, uiStride, iWidth, iHeight );
389  }
390  else
391  {
392    xPredIntraAng( ptrSrc+sw+1, sw, pDst, uiStride, iWidth, iHeight, uiDirMode, bAbove, bLeft, true );
393
394    if( (uiDirMode == DC_IDX ) && bAbove && bLeft )
395    {
396      xDCPredFiltering( ptrSrc+sw+1, sw, pDst, uiStride, iWidth, iHeight);
397    }
398  }
399}
400
401// Angular chroma
402Void TComPrediction::predIntraChromaAng( TComPattern* pcTComPattern, Int* piSrc, UInt uiDirMode, Pel* piPred, UInt uiStride, Int iWidth, Int iHeight, TComDataCU* pcCU, Bool bAbove, Bool bLeft )
403{
404  Pel *pDst = piPred;
405  Int *ptrSrc = piSrc;
406
407  // get starting pixel in block
408  Int sw = 2 * iWidth + 1;
409
410  if ( uiDirMode == PLANAR_IDX )
411  {
412    xPredIntraPlanar( ptrSrc+sw+1, sw, pDst, uiStride, iWidth, iHeight );
413  }
414  else
415  {
416    // Create the prediction
417    xPredIntraAng( ptrSrc+sw+1, sw, pDst, uiStride, iWidth, iHeight, uiDirMode, bAbove, bLeft, false );
418  }
419}
420
421/** Function for checking identical motion.
422 * \param TComDataCU* pcCU
423 * \param UInt PartAddr
424 */
425Bool TComPrediction::xCheckIdenticalMotion ( TComDataCU* pcCU, UInt PartAddr )
426{
427  if( pcCU->getSlice()->isInterB() && pcCU->getSlice()->getPPS()->getWPBiPredIdc() == 0 )
428  {
429    if( pcCU->getCUMvField(REF_PIC_LIST_0)->getRefIdx(PartAddr) >= 0 && pcCU->getCUMvField(REF_PIC_LIST_1)->getRefIdx(PartAddr) >= 0)
430    {
431      Int RefPOCL0    = pcCU->getSlice()->getRefPic(REF_PIC_LIST_0, pcCU->getCUMvField(REF_PIC_LIST_0)->getRefIdx(PartAddr))->getPOC();
432      Int RefViewIdL0 = pcCU->getSlice()->getRefPic(REF_PIC_LIST_0, pcCU->getCUMvField(REF_PIC_LIST_0)->getRefIdx(PartAddr))->getViewId();
433      Int RefPOCL1    = pcCU->getSlice()->getRefPic(REF_PIC_LIST_1, pcCU->getCUMvField(REF_PIC_LIST_1)->getRefIdx(PartAddr))->getPOC();
434      Int RefViewIdL1 = pcCU->getSlice()->getRefPic(REF_PIC_LIST_1, pcCU->getCUMvField(REF_PIC_LIST_1)->getRefIdx(PartAddr))->getViewId();
435      if(RefPOCL0 == RefPOCL1 && RefViewIdL0 == RefViewIdL1 && pcCU->getCUMvField(REF_PIC_LIST_0)->getMv(PartAddr) == pcCU->getCUMvField(REF_PIC_LIST_1)->getMv(PartAddr))
436      {
437        return true;
438      }
439    }
440  }
441  return false;
442}
443
444#if LGE_EDGE_INTRA_A0070
445Void TComPrediction::predIntraLumaEdge ( TComDataCU* pcCU, TComPattern* pcTComPattern, UInt uiAbsPartIdx, Int iWidth, Int iHeight, Pel* piPred, UInt uiStride, Bool bDelta )
446{
447  Pel *piDst = piPred;
448  Int *piSrc;
449  Int iSrcStride = ( iWidth<<1 ) + 1;
450  Int iDstStride = uiStride;
451
452  piSrc = pcTComPattern->getPredictorPtr( 0, g_aucConvertToBit[ iWidth ] + 2, m_piYuvExt );
453
454  xPredIntraEdge ( pcCU, uiAbsPartIdx, iWidth, iHeight, piSrc, iSrcStride, piDst, iDstStride
455#if LGE_EDGE_INTRA_DELTA_DC
456    , bDelta
457#endif
458    );
459}
460
461Pel  TComPrediction::xGetNearestNeighbor( Int x, Int y, Int* pSrc, Int srcStride, Int iWidth, Int iHeight, Bool* bpRegion )
462{
463  Bool bLeft = (x < y) ? true : false;
464  Bool bFound = false;
465  Int  iFoundX = -1, iFoundY = -1;
466  Int  cResult = 0;
467
468  UChar* piTopDistance = new UChar[iWidth];
469  UChar* piLeftDistance = new UChar[iHeight];
470
471  for( Int i = 0; i < iWidth; i++ )
472  {
473    int Abs = x > i ? x - i : i - x;
474    piTopDistance[ i ] = y + Abs;
475
476    Abs = y > i ? y - i : i - y;
477    piLeftDistance[ i ] = x + Abs;
478  }
479
480  for( Int dist = 0; dist < MAX_DISTANCE_EDGEINTRA && !bFound; dist++ )
481  {
482    if( !bLeft )
483    {
484      for( Int i = 0; i < iWidth; i++ )
485      {
486        if( piTopDistance[ i ] == dist )
487        {
488          if( bpRegion[ i ] == bpRegion[ x + y * iWidth ] )
489          {
490            iFoundX = i;
491            iFoundY = 0;
492            bFound = true;
493          }
494        }
495      }
496      for( Int i = 0; i < iHeight; i++ )
497      {
498        if( piLeftDistance[ i ] == dist )
499        {
500          if( bpRegion[ i * iWidth ] == bpRegion[ x + y * iWidth ] )
501          {
502            iFoundX = 0;
503            iFoundY = i;
504            bFound = true;
505          }
506        }
507      }
508    }
509    else
510    {
511      for( Int i = 0; i < iHeight; i++ )
512      {
513        if( piLeftDistance[ i ] == dist )
514        {
515          if( bpRegion[ i * iWidth ] == bpRegion[ x + y * iWidth ] )
516          {
517            iFoundX = 0;
518            iFoundY = i;
519            bFound = true;
520          }
521        }
522      }
523      for( Int i = 0; i < iWidth; i++ )
524      {
525        if( piTopDistance[ i ] == dist )
526        {
527          if( bpRegion[ i ] == bpRegion[ x + y * iWidth ] )
528          {
529            iFoundX = i;
530            iFoundY = 0;
531            bFound = true;
532          }
533        }
534      }
535    }
536  }
537
538  if( iFoundY == 0 )
539  {
540    cResult = pSrc[ iFoundX + 1 ];
541  }
542  else // iFoundX == 0
543  {
544    cResult = pSrc[ (iFoundY + 1) * srcStride ];
545  }
546
547  delete[] piTopDistance;  piTopDistance = NULL;
548  delete[] piLeftDistance; piLeftDistance = NULL;
549
550  assert( bFound );
551
552  return cResult;
553}
554
555Void TComPrediction::xPredIntraEdge( TComDataCU* pcCU, UInt uiAbsPartIdx, Int iWidth, Int iHeight, Int* pSrc, Int srcStride, Pel*& rpDst, Int dstStride, Bool bDelta )
556{
557  Pel* pDst = rpDst;
558  Bool* pbRegion = pcCU->getEdgePartition( uiAbsPartIdx );
559
560  // Do prediction
561  {
562#if QC_DC_PREDICTOR_D0183
563    Int iMean0, iMean1;
564    getPredDCs( pbRegion, iWidth, pSrc+srcStride+1, srcStride, iMean0, iMean1 );
565#else
566    //UInt uiSum0 = 0, uiSum1 = 0;
567    Int iSum0 = 0, iSum1 = 0;
568    //UInt uiMean0, uiMean1;
569    Int iMean0, iMean1;
570    //UInt uiCount0 = 0, uiCount1 = 0;
571    Int iCount0 = 0, iCount1 = 0;
572    for( UInt ui = 0; ui < iWidth; ui++ )
573    {
574      if( pbRegion[ ui ] == false )
575      {
576        iSum0 += (pSrc[ ui + 1 ]);
577        iCount0++;
578      }
579      else
580      {
581        iSum1 += (pSrc[ ui + 1 ]);
582        iCount1++;
583      }
584    }
585    for( UInt ui = 0; ui < iHeight; ui++ ) // (0,0) recount (to avoid division)
586    {
587      if( pbRegion[ ui * iWidth ] == false )
588      {
589        iSum0 += (pSrc[ (ui + 1) * srcStride ]);
590        iCount0++;
591      }
592      else
593      {
594        iSum1 += (pSrc[ (ui + 1) * srcStride ]);
595        iCount1++;
596      }
597    }
598    if( iCount0 == 0 )
599      assert(false);
600    if( iCount1 == 0 )
601      assert(false);
602    iMean0 = iSum0 / iCount0; // TODO : integer op.
603    iMean1 = iSum1 / iCount1;
604#endif
605#if LGE_EDGE_INTRA_DELTA_DC
606    if( bDelta ) 
607    {
608      Int iDeltaDC0 = pcCU->getEdgeDeltaDC0( uiAbsPartIdx );
609      Int iDeltaDC1 = pcCU->getEdgeDeltaDC1( uiAbsPartIdx );
610      xDeltaDCQuantScaleUp( pcCU, iDeltaDC0 );
611      xDeltaDCQuantScaleUp( pcCU, iDeltaDC1 );
612      iMean0 = Clip( iMean0 + iDeltaDC0 );
613      iMean1 = Clip( iMean1 + iDeltaDC1 );
614    }
615#endif
616    for( UInt ui = 0; ui < iHeight; ui++ )
617    {
618      for( UInt uii = 0; uii < iWidth; uii++ )
619      {
620        if( pbRegion[ uii + ui * iWidth ] == false )
621          pDst[ uii + ui * dstStride ] = iMean0;
622        else
623          pDst[ uii + ui * dstStride ] = iMean1;
624      }
625    }
626  }
627}
628#endif
629
630#if DEPTH_MAP_GENERATION
631#if MERL_VSP_C0152
632Void TComPrediction::motionCompensation( TComDataCU* pcCU, TComYuv* pcYuvPred, UInt uiAbsPartIdx, RefPicList eRefPicList, Int iPartIdx, Bool bPrdDepthMap, UInt uiSubSampExpX, UInt uiSubSampExpY )
633#else
634Void TComPrediction::motionCompensation( TComDataCU* pcCU, TComYuv* pcYuvPred, RefPicList eRefPicList, Int iPartIdx, Bool bPrdDepthMap, UInt uiSubSampExpX, UInt uiSubSampExpY )
635#endif
636#else
637#if MERL_VSP_C0152
638Void TComPrediction::motionCompensation ( TComDataCU* pcCU, TComYuv* pcYuvPred, UInt uiAbsPartIdx, RefPicList eRefPicList, Int iPartIdx )
639#else
640Void TComPrediction::motionCompensation ( TComDataCU* pcCU, TComYuv* pcYuvPred, RefPicList eRefPicList, Int iPartIdx )
641#endif
642#endif
643{
644  Int         iWidth;
645  Int         iHeight;
646  UInt        uiPartAddr;
647
648  if ( iPartIdx >= 0 )
649  {
650    pcCU->getPartIndexAndSize( iPartIdx, uiPartAddr, iWidth, iHeight );
651
652#if DEPTH_MAP_GENERATION
653    if( bPrdDepthMap )
654    {
655      iWidth  >>= uiSubSampExpX;
656      iHeight >>= uiSubSampExpY;
657    }
658#endif
659
660    if ( eRefPicList != REF_PIC_LIST_X )
661    {
662#if LGE_ILLUCOMP_B0045
663      if( pcCU->getSlice()->getPPS()->getUseWP() && !pcCU->getICFlag(uiPartAddr))
664#else
665      if( pcCU->getSlice()->getPPS()->getUseWP())
666#endif
667      {
668#if MERL_VSP_C0152
669        xPredInterUni (pcCU, uiPartAddr, uiAbsPartIdx+uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred, iPartIdx, bPrdDepthMap, uiSubSampExpX, uiSubSampExpY, true );
670#else
671        xPredInterUni (pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred, iPartIdx, bPrdDepthMap, uiSubSampExpX, uiSubSampExpY, true );
672#endif
673      }
674      else
675      {
676#if MERL_VSP_C0152
677        xPredInterUni (pcCU, uiPartAddr, uiAbsPartIdx+uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred, iPartIdx, bPrdDepthMap, uiSubSampExpX, uiSubSampExpY, false );
678#else       
679        xPredInterUni (pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred, iPartIdx, bPrdDepthMap, uiSubSampExpX, uiSubSampExpY, false );
680#endif
681      }
682#if LGE_ILLUCOMP_B0045
683      if( pcCU->getSlice()->getPPS()->getUseWP() && !pcCU->getICFlag(uiPartAddr) )
684#else
685      if ( pcCU->getSlice()->getPPS()->getUseWP() )
686#endif
687      {
688        xWeightedPredictionUni( pcCU, pcYuvPred, uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred, iPartIdx );
689      }
690    }
691    else
692    {
693      if( xCheckIdenticalMotion( pcCU, uiPartAddr ) && !bPrdDepthMap )
694      {
695#if MERL_VSP_C0152
696        xPredInterUni (pcCU, uiPartAddr, uiAbsPartIdx+uiPartAddr, iWidth, iHeight, REF_PIC_LIST_0, pcYuvPred, iPartIdx, bPrdDepthMap, uiSubSampExpX, uiSubSampExpY, false );
697#else
698        xPredInterUni (pcCU, uiPartAddr, iWidth, iHeight, REF_PIC_LIST_0, pcYuvPred, iPartIdx, bPrdDepthMap, uiSubSampExpX, uiSubSampExpY, false );
699#endif
700      }
701      else
702      {
703#if MERL_VSP_C0152
704        xPredInterBi  (pcCU, uiPartAddr, uiAbsPartIdx+uiPartAddr, iWidth, iHeight, uiSubSampExpX, uiSubSampExpY, pcYuvPred, iPartIdx, bPrdDepthMap );
705#else
706        xPredInterBi  (pcCU, uiPartAddr, iWidth, iHeight, uiSubSampExpX, uiSubSampExpY, pcYuvPred, iPartIdx, bPrdDepthMap );
707#endif
708      }
709    }
710    return;
711  }
712
713  for ( iPartIdx = 0; iPartIdx < pcCU->getNumPartInter(); iPartIdx++ )
714  {
715    pcCU->getPartIndexAndSize( iPartIdx, uiPartAddr, iWidth, iHeight );
716
717    if( bPrdDepthMap )
718    {
719      iWidth  >>= uiSubSampExpX;
720      iHeight >>= uiSubSampExpY;
721    }
722
723    if ( eRefPicList != REF_PIC_LIST_X )
724    {
725#if LGE_ILLUCOMP_B0045
726      if( pcCU->getSlice()->getPPS()->getUseWP() && !pcCU->getICFlag(uiPartAddr))
727#else
728      if( pcCU->getSlice()->getPPS()->getUseWP())
729#endif
730      {
731#if MERL_VSP_C0152
732        xPredInterUni (pcCU, uiPartAddr, uiAbsPartIdx+uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred, iPartIdx, bPrdDepthMap, uiSubSampExpX, uiSubSampExpY, true );
733#else
734        xPredInterUni (pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred, iPartIdx, bPrdDepthMap, uiSubSampExpX, uiSubSampExpY, true );
735#endif
736  }
737  else
738  {
739#if MERL_VSP_C0152
740        xPredInterUni (pcCU, uiPartAddr, uiAbsPartIdx+uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred, iPartIdx, bPrdDepthMap, uiSubSampExpX, uiSubSampExpY, false );
741#else
742        xPredInterUni (pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred, iPartIdx, bPrdDepthMap, uiSubSampExpX, uiSubSampExpY, false );
743#endif
744      }
745#if MERL_VSP_C0152
746      xPredInterUni (pcCU, uiPartAddr, uiAbsPartIdx+uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred, iPartIdx, bPrdDepthMap, uiSubSampExpX, uiSubSampExpY, false );
747#else
748      xPredInterUni (pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred, iPartIdx, bPrdDepthMap, uiSubSampExpX, uiSubSampExpY, false );
749#endif
750
751#if LGE_ILLUCOMP_B0045
752      if( pcCU->getSlice()->getPPS()->getUseWP() && !pcCU->getICFlag(uiPartAddr))
753#else
754      if( pcCU->getSlice()->getPPS()->getUseWP())
755#endif
756      {
757        xWeightedPredictionUni( pcCU, pcYuvPred, uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred, iPartIdx );
758      }
759    }
760    else
761    {
762      if ( xCheckIdenticalMotion( pcCU, uiPartAddr ) )
763      {
764#if MERL_VSP_C0152
765        xPredInterUni (pcCU, uiPartAddr, uiAbsPartIdx+uiPartAddr, iWidth, iHeight, REF_PIC_LIST_0, pcYuvPred, iPartIdx, bPrdDepthMap, uiSubSampExpX, uiSubSampExpY, false );
766#else
767        xPredInterUni (pcCU, uiPartAddr, iWidth, iHeight, REF_PIC_LIST_0, pcYuvPred, iPartIdx, bPrdDepthMap, uiSubSampExpX, uiSubSampExpY, false );
768#endif
769      }
770      else
771      {
772#if MERL_VSP_C0152
773        xPredInterBi  (pcCU, uiPartAddr, uiAbsPartIdx+uiPartAddr, iWidth, iHeight, uiSubSampExpX, uiSubSampExpY, pcYuvPred, iPartIdx, bPrdDepthMap );
774#else
775        xPredInterBi  (pcCU, uiPartAddr, iWidth, iHeight, uiSubSampExpX, uiSubSampExpY, pcYuvPred, iPartIdx, bPrdDepthMap );
776#endif   
777      }
778    }
779  }
780  return;
781}
782
783#if H3D_IVRP & !QC_ARP_D0177
784Void TComPrediction::residualPrediction(TComDataCU* pcCU, TComYuv* pcYuvPred, TComYuv* pcYuvResPred)
785{
786  Int         iWidth;
787  Int         iHeight;
788  UInt        uiPartAddr;
789
790  pcCU->getPartIndexAndSize( 0, uiPartAddr, iWidth, iHeight );
791
792  Bool bResAvail = false;
793
794  bResAvail = pcCU->getResidualSamples( 0, true, pcYuvResPred );
795
796  assert (bResAvail);
797
798  pcYuvPred->add(pcYuvResPred, iWidth, iHeight);
799}
800#endif
801
802#if MERL_General_Fix
803#if MERL_VSP_C0152
804// Function to perform VSP block compensation
805Void  TComPrediction::xPredInterVSPBlk(TComDataCU* pcCU, UInt uiPartAddr, UInt uiAbsPartIdx, Int iWidth, Int iHeight, TComMv cMv, RefPicList eRefPicList, TComYuv*& rpcYuvPred
806                                     , Bool bi
807#if !MERL_Bi_VSP_D0166
808                                     , Int vspIdx
809#endif
810                                       )
811{
812  TComPic*    pRefPicBaseTxt        = NULL;
813  TComPicYuv* pcBaseViewTxtPicYuv   = NULL;
814  TComPicYuv* pcBaseViewDepthPicYuv = NULL;
815  Int iBlkX = 0;
816  Int iBlkY = 0;
817  Int* pShiftLUT;
818  Int  iShiftPrec;
819
820#if !MERL_VSP_NBDV_RefVId_Fix_D0166
821  pRefPicBaseTxt        = pcCU->getSlice()->getRefPicBaseTxt();
822  pcBaseViewTxtPicYuv   = pRefPicBaseTxt->getPicYuvRec();
823  TComPic* pRefPicBaseDepth = pcCU->getSlice()->getRefPicBaseDepth();
824  pcBaseViewDepthPicYuv     = pRefPicBaseDepth->getPicYuvRec();
825
826  Int iBlkX = ( pcCU->getAddr() % pRefPicBaseDepth->getFrameWidthInCU() ) * g_uiMaxCUWidth  + g_auiRasterToPelX[ g_auiZscanToRaster[ uiAbsPartIdx ] ];
827  Int iBlkY = ( pcCU->getAddr() / pRefPicBaseDepth->getFrameWidthInCU() ) * g_uiMaxCUHeight + g_auiRasterToPelY[ g_auiZscanToRaster[ uiAbsPartIdx ] ];
828  pcCU->getSlice()->getBWVSPLUTParam(pShiftLUT, iShiftPrec);
829  xPredInterLumaBlkFromDM  ( pcBaseViewTxtPicYuv, pcBaseViewDepthPicYuv, pShiftLUT, iShiftPrec, &cMv, uiPartAddr, iBlkX,    iBlkY,    iWidth,    iHeight,    pcCU->getSlice()->getSPS()->isDepth(), rpcYuvPred );
830  xPredInterChromaBlkFromDM( pcBaseViewTxtPicYuv, pcBaseViewDepthPicYuv, pShiftLUT, iShiftPrec, &cMv, uiPartAddr, iBlkX>>1, iBlkY>>1, iWidth>>1, iHeight>>1, pcCU->getSlice()->getSPS()->isDepth(), rpcYuvPred );
831
832#else // MERL_VSP_NBDV_RefVId_Fix_D0166
833   // Step 1: get depth reference
834#if QC_BVSP_CleanUP_D0191
835  RefPicList privateRefPicList = REF_PIC_LIST_0;
836  Int refIdxList0 = pcCU->getCUMvField( REF_PIC_LIST_0 )->getRefIdx( uiPartAddr );
837  Int refIdxList1 = pcCU->getCUMvField( REF_PIC_LIST_1 )->getRefIdx( uiPartAddr );
838  privateRefPicList = refIdxList0 != NOT_VALID ? REF_PIC_LIST_0 : REF_PIC_LIST_1;
839  if(privateRefPicList == REF_PIC_LIST_1 && refIdxList1== NOT_VALID )
840  {
841    assert(0);
842  }
843  Int privateRefIdx = privateRefPicList == REF_PIC_LIST_0 ? refIdxList0 : refIdxList1;
844  Int viewId = pcCU->getSlice()->getRefViewId(privateRefPicList, privateRefIdx);
845  Int refPoc = pcCU->getSlice()->getRefPOC(privateRefPicList, privateRefIdx);
846#else
847  //recover VSP reference frame according to negative refIdx number
848  RefPicList privateRefPicList = (RefPicList) pcCU->getVSPDir( uiPartAddr );
849  assert(privateRefPicList == REF_PIC_LIST_0 || privateRefPicList == REF_PIC_LIST_1);
850  Int  refIdx = -1-pcCU->getCUMvField( privateRefPicList )->getRefIdx( uiPartAddr ); // texture ref index, a trick when storing refIdx
851  Int  viewId = pcCU->getSlice()->getRefViewId(privateRefPicList, refIdx);  // texture view id
852  Int  refPoc = pcCU->getSlice()->getRefPOC(privateRefPicList, refIdx);     // texture POC
853#endif
854  TComPic* pRefPicBaseDepth = pcCU->getSlice()->getDepthRefPic(viewId, refPoc);
855
856  pcBaseViewDepthPicYuv = pRefPicBaseDepth->getPicYuvRec();
857  assert(refPoc == pcCU->getSlice()->getPOC());
858  assert(pRefPicBaseDepth != NULL);
859  assert(pcBaseViewDepthPicYuv != NULL);
860
861  iBlkX = ( pcCU->getAddr() % pRefPicBaseDepth->getFrameWidthInCU() ) * g_uiMaxCUWidth  + g_auiRasterToPelX[ g_auiZscanToRaster[ uiAbsPartIdx ] ];
862  iBlkY = ( pcCU->getAddr() / pRefPicBaseDepth->getFrameWidthInCU() ) * g_uiMaxCUHeight + g_auiRasterToPelY[ g_auiZscanToRaster[ uiAbsPartIdx ] ];
863#if MERL_Bi_VSP_D0166
864  // Step 2: get texture reference
865  pRefPicBaseTxt = xGetVspRefTxt( pcCU, uiPartAddr, eRefPicList);
866  pcBaseViewTxtPicYuv = pRefPicBaseTxt->getPicYuvRec();
867  assert(pcBaseViewTxtPicYuv != NULL);
868
869  // initialize the LUT according to the reference view idx
870  pcCU->getSlice()->getBWVSPLUTParam(pShiftLUT, iShiftPrec, pRefPicBaseTxt->getViewId());
871
872  // Step 3: Do compensation
873  xPredInterLumaBlkFromDM  ( pcBaseViewTxtPicYuv, pcBaseViewDepthPicYuv, pShiftLUT, iShiftPrec, &cMv, uiPartAddr, iBlkX,    iBlkY,    iWidth,    iHeight,    pcCU->getSlice()->getSPS()->isDepth(), rpcYuvPred, bi );
874  xPredInterChromaBlkFromDM( pcBaseViewTxtPicYuv, pcBaseViewDepthPicYuv, pShiftLUT, iShiftPrec, &cMv, uiPartAddr, iBlkX>>1, iBlkY>>1, iWidth>>1, iHeight>>1, pcCU->getSlice()->getSPS()->isDepth(), rpcYuvPred, bi );
875#else
876  // Step 2: get texture reference
877  pRefPicBaseTxt = pcCU->getSlice()->getRefPic(privateRefPicList, refIdx);
878  pcBaseViewTxtPicYuv = pRefPicBaseTxt->getPicYuvRec();
879  assert(pcBaseViewTxtPicYuv != NULL);
880
881  //initialize the LUT according to the reference view idx
882  pcCU->getSlice()->getBWVSPLUTParam(pShiftLUT, iShiftPrec, pRefPicBaseTxt->getViewId());
883
884  // Step 3: Do compensation
885  xPredInterLumaBlkFromDM  ( pcBaseViewTxtPicYuv, pcBaseViewDepthPicYuv, pShiftLUT, iShiftPrec, &cMv, uiPartAddr, iBlkX,    iBlkY,    iWidth,    iHeight,    pcCU->getSlice()->getSPS()->isDepth(), vspIdx, rpcYuvPred );
886  xPredInterChromaBlkFromDM( pcBaseViewTxtPicYuv, pcBaseViewDepthPicYuv, pShiftLUT, iShiftPrec, &cMv, uiPartAddr, iBlkX>>1, iBlkY>>1, iWidth>>1, iHeight>>1, pcCU->getSlice()->getSPS()->isDepth(), vspIdx, rpcYuvPred );
887#endif
888
889#endif
890}
891
892#endif
893
894#if MERL_Bi_VSP_D0166
895TComPic*  TComPrediction::xGetVspRefTxt(TComDataCU* pcCU, UInt uiPartAddr, RefPicList eRefPicList)
896{
897#if QC_BVSP_CleanUP_D0191
898  RefPicList privateRefPicList = REF_PIC_LIST_0;
899  Int refIdxList0 = pcCU->getCUMvField( REF_PIC_LIST_0 )->getRefIdx( uiPartAddr );
900  Int refIdxList1 = pcCU->getCUMvField( REF_PIC_LIST_1 )->getRefIdx( uiPartAddr );
901  privateRefPicList = refIdxList0 != NOT_VALID ? REF_PIC_LIST_0 : REF_PIC_LIST_1;
902  if(privateRefPicList == REF_PIC_LIST_1 && refIdxList1==NOT_VALID )
903  {
904    assert(0);
905  }
906  Int privateRefIdx = privateRefPicList == REF_PIC_LIST_0 ? refIdxList0 : refIdxList1;
907  Int viewId = pcCU->getSlice()->getRefViewId(privateRefPicList, privateRefIdx);
908#else
909  RefPicList  privateRefPicList = (RefPicList) pcCU->getVSPDir( uiPartAddr );
910  Int         refIdx = -1-pcCU->getCUMvField( privateRefPicList )->getRefIdx( uiPartAddr ); // texture ref index, a trick when storing refIdx
911  Int         viewId = pcCU->getSlice()->getRefViewId(privateRefPicList, refIdx);  // texture view id
912#endif
913  TComPic*    refPic = NULL;
914
915  assert(privateRefPicList == REF_PIC_LIST_0 || privateRefPicList == REF_PIC_LIST_1);
916
917  if (privateRefPicList == eRefPicList)
918  {
919#if QC_BVSP_CleanUP_D0191
920    Int  refIdxt = pcCU->getCUMvField( eRefPicList )->getRefIdx( uiPartAddr );
921#else
922    Int  refIdxt = -1-pcCU->getCUMvField( eRefPicList )->getRefIdx( uiPartAddr );
923#endif
924    assert(refIdxt>= 0);
925    refPic = pcCU->getSlice()->getRefPic(eRefPicList, refIdxt);
926  }
927  else
928  {
929    // Find the other interview reference in order to do VSP
930    RefPicList otherRefPicList = privateRefPicList == REF_PIC_LIST_0 ? REF_PIC_LIST_1 : REF_PIC_LIST_0;
931    Bool isFound = false;
932    for (Int iRefIdx = 0; iRefIdx <pcCU->getSlice()->getNumRefIdx(otherRefPicList); iRefIdx ++ )
933    {
934      Int refViewIdx  = pcCU->getSlice()->getRefViewId( otherRefPicList, iRefIdx);
935      if ( (refViewIdx != pcCU->getSlice()->getViewId()) && (refViewIdx != viewId ) )
936      {
937        refPic = pcCU->getSlice()->getRefPic(otherRefPicList, iRefIdx);
938        isFound = true;
939        break;
940      }
941    }
942
943    if (isFound == false)
944    {
945#if QC_BVSP_CleanUP_D0191
946      Int  refIdxTxt = pcCU->getCUMvField( privateRefPicList )->getRefIdx( uiPartAddr );
947#else
948      Int  refIdxTxt = -1-pcCU->getCUMvField( privateRefPicList )->getRefIdx( uiPartAddr );
949#endif
950      assert(refIdxTxt >= 0);
951      refPic = pcCU->getSlice()->getRefPic(privateRefPicList, refIdxTxt);
952    }
953    assert(isFound);
954  }
955  assert(refPic != NULL);
956  return refPic;
957}
958#endif
959#endif
960
961#if MERL_VSP_C0152
962Void TComPrediction::xPredInterUni ( TComDataCU* pcCU, UInt uiPartAddr, UInt uiAbsPartIdx, Int iWidth, Int iHeight, RefPicList eRefPicList, TComYuv*& rpcYuvPred, Int iPartIdx, Bool bPrdDepthMap, UInt uiSubSampExpX, UInt uiSubSampExpY, Bool bi )
963#else
964Void TComPrediction::xPredInterUni ( TComDataCU* pcCU, UInt uiPartAddr, Int iWidth, Int iHeight, RefPicList eRefPicList, TComYuv*& rpcYuvPred, Int iPartIdx, Bool bPrdDepthMap, UInt uiSubSampExpX, UInt uiSubSampExpY, Bool bi )
965#endif
966{
967#if MERL_VSP_C0152
968  Int  iRefIdx = pcCU->getCUMvField( eRefPicList )->getRefIdx( uiPartAddr );   
969  Int  vspIdx  = pcCU->getVSPIndex(uiPartAddr);
970  if (vspIdx != 0)
971  {
972#if !QC_BVSP_CleanUP_D0191
973    if (iRefIdx >= 0)
974    {
975      printf("vspIdx = %d, iRefIdx = %d\n", vspIdx, iRefIdx);
976    }
977    assert (iRefIdx < 0); // assert (iRefIdx == NOT_VALID);
978#endif
979  }
980  else
981  {
982    assert (iRefIdx >= 0);
983  }
984#else
985  Int         iRefIdx     = pcCU->getCUMvField( eRefPicList )->getRefIdx( uiPartAddr );           assert (iRefIdx >= 0);
986#endif
987
988  TComMv cMv = pcCU->getCUMvField( eRefPicList )->getMv( uiPartAddr );
989  pcCU->clipMv(cMv);
990
991#if DEPTH_MAP_GENERATION
992  if( bPrdDepthMap )
993  {
994    UInt uiRShift = 0;
995    if( pcCU->getPic()->getStoredPDMforV2() == 1 )
996      xPredInterPrdDepthMap( pcCU, pcCU->getSlice()->getRefPic( eRefPicList, iRefIdx )->getPredDepthMapTemp(), uiPartAddr, &cMv, iWidth, iHeight, uiSubSampExpX, uiSubSampExpY, rpcYuvPred, uiRShift, 0 );
997    else
998      xPredInterPrdDepthMap( pcCU, pcCU->getSlice()->getRefPic( eRefPicList, iRefIdx )->getPredDepthMap(), uiPartAddr, &cMv, iWidth, iHeight, uiSubSampExpX, uiSubSampExpY, rpcYuvPred, uiRShift, 0 );
999
1000    return;
1001  }
1002#endif
1003#if QC_ARP_D0177
1004  if(
1005#if MERL_General_Fix // TODO: Maybe logically redundant, but easier to read. Need verification before being removed
1006#if MERL_VSP_C0152
1007       vspIdx == 0 &&
1008#endif
1009#endif
1010       pcCU->getSlice()->getSPS()->isDepth() == false
1011    && pcCU->getSlice()->getSPS()->getViewId() > 0
1012    && pcCU->getSlice()->getSPS()->getUseAdvRP() > 0
1013    && pcCU->getARPW( uiPartAddr ) > 0 
1014    && pcCU->getSlice()->getRefPic( eRefPicList, iRefIdx )->getPOC()!= pcCU->getSlice()->getPOC()
1015    && (pcCU->getPartitionSize(uiPartAddr)==SIZE_2Nx2N || pcCU->isSkipped(uiPartAddr))
1016    )
1017  {
1018    xPredInterUniARP( pcCU , uiPartAddr , iWidth , iHeight , eRefPicList , rpcYuvPred , iPartIdx , bi );
1019  }
1020  else
1021  {
1022#endif
1023#if HHI_FULL_PEL_DEPTH_MAP_MV_ACC
1024  if( pcCU->getSlice()->getSPS()->isDepth() )
1025  {
1026#if MERL_VSP_C0152
1027    if (vspIdx != 0)
1028    { // depth, vsp compensation
1029#if !MERL_General_Fix
1030      // get depth estimator here
1031      TComPic* pRefPicBaseDepth = pcCU->getSlice()->getRefPicBaseDepth();
1032      TComPicYuv* pcBaseViewDepthPicYuv = NULL;
1033      if (vspIdx < 4) // spatial
1034      {
1035        pcBaseViewDepthPicYuv = pRefPicBaseDepth->getPicYuvRec();
1036      }
1037      Int iBlkX = ( pcCU->getAddr() % pRefPicBaseDepth->getFrameWidthInCU() ) * g_uiMaxCUWidth  + g_auiRasterToPelX[ g_auiZscanToRaster[ uiAbsPartIdx ] ];
1038      Int iBlkY = ( pcCU->getAddr() / pRefPicBaseDepth->getFrameWidthInCU() ) * g_uiMaxCUHeight + g_auiRasterToPelY[ g_auiZscanToRaster[ uiAbsPartIdx ] ];
1039      Int* pShiftLUT;
1040      Int iShiftPrec;
1041      pcCU->getSlice()->getBWVSPLUTParam(pShiftLUT, iShiftPrec);
1042      //using disparity to find the depth block of the base view as the depth block estimator of the current block
1043      //using depth block estimator and base view texture to get Backward warping
1044      xPredInterLumaBlkFromDM  ( pcBaseViewDepthPicYuv, pcBaseViewDepthPicYuv, pShiftLUT, iShiftPrec, &cMv, uiPartAddr, iBlkX,    iBlkY,    iWidth,    iHeight,     pcCU->getSlice()->getSPS()->isDepth(), vspIdx, rpcYuvPred );
1045      xPredInterChromaBlkFromDM( pcBaseViewDepthPicYuv, pcBaseViewDepthPicYuv, pShiftLUT, iShiftPrec, &cMv, uiPartAddr, iBlkX>>1, iBlkY>>1, iWidth>>1, iHeight>>1,  pcCU->getSlice()->getSPS()->isDepth(), vspIdx, rpcYuvPred );
1046#else
1047#if MERL_Bi_VSP_D0166
1048      xPredInterVSPBlk(pcCU, uiPartAddr, uiAbsPartIdx, iWidth, iHeight, cMv, eRefPicList, rpcYuvPred, bi );
1049#else
1050      xPredInterVSPBlk(pcCU, uiPartAddr, uiAbsPartIdx, iWidth, iHeight, cMv, eRefPicList, rpcYuvPred, bi, vspIdx );
1051#endif
1052#endif
1053    }
1054    else
1055    {
1056#endif
1057      UInt uiRShift = ( bi ? 14-g_uiBitDepth-g_uiBitIncrement : 0 );
1058      UInt uiOffset = bi ? IF_INTERNAL_OFFS : 0;
1059#if LGE_ILLUCOMP_DEPTH_C0046
1060    Bool bICFlag = pcCU->getICFlag(uiPartAddr) && (pcCU->getSlice()->getRefViewId( eRefPicList, iRefIdx ) != pcCU->getSlice()->getViewId());
1061#endif
1062#if DEPTH_MAP_GENERATION
1063    xPredInterPrdDepthMap( pcCU, pcCU->getSlice()->getRefPic( eRefPicList, iRefIdx )->getPicYuvRec(), uiPartAddr, &cMv, iWidth, iHeight, 0, 0, rpcYuvPred, uiRShift, uiOffset
1064#if LGE_ILLUCOMP_DEPTH_C0046
1065        , bICFlag
1066#endif
1067        );
1068#else
1069      xPredInterPrdDepthMap( pcCU, pcCU->getSlice()->getRefPic( eRefPicList, iRefIdx )->getPicYuvRec(), uiPartAddr, &cMv, iWidth, iHeight, rpcYuvPred, uiRShift, uiOffset );
1070#endif
1071#if MERL_VSP_C0152
1072    }
1073#endif// MERL_VSP_C0152 //else
1074  }
1075  else  // texture
1076  {
1077#endif
1078#if MERL_VSP_C0152
1079    if ( vspIdx != 0 )
1080    { // texture, vsp compensation
1081#if !MERL_General_Fix
1082      TComPic*    pRefPicBaseTxt        = pcCU->getSlice()->getRefPicBaseTxt();
1083      TComPicYuv* pcBaseViewTxtPicYuv   = pRefPicBaseTxt->getPicYuvRec();
1084      TComPicYuv* pcBaseViewDepthPicYuv = NULL;
1085      if (vspIdx < 4) // spatial
1086      {
1087        TComPic* pRefPicBaseDepth = pcCU->getSlice()->getRefPicBaseDepth();
1088        pcBaseViewDepthPicYuv     = pRefPicBaseDepth->getPicYuvRec();
1089      }
1090      Int iBlkX = ( pcCU->getAddr() % pRefPicBaseTxt->getFrameWidthInCU() ) * g_uiMaxCUWidth  + g_auiRasterToPelX[ g_auiZscanToRaster[ uiAbsPartIdx ] ];
1091      Int iBlkY = ( pcCU->getAddr() / pRefPicBaseTxt->getFrameWidthInCU() ) * g_uiMaxCUHeight + g_auiRasterToPelY[ g_auiZscanToRaster[ uiAbsPartIdx ] ];
1092      Int* pShiftLUT;
1093      Int iShiftPrec;
1094      pcCU->getSlice()->getBWVSPLUTParam(pShiftLUT, iShiftPrec);
1095
1096      //using disparity to find the depth block of the base view as the depth block estimator of the current block
1097      //using depth block estimator and base view texture to get Backward warping
1098      xPredInterLumaBlkFromDM  ( pcBaseViewTxtPicYuv, pcBaseViewDepthPicYuv, pShiftLUT, iShiftPrec, &cMv, uiPartAddr, iBlkX,    iBlkY,    iWidth,    iHeight,    pcCU->getSlice()->getSPS()->isDepth(), vspIdx, rpcYuvPred );
1099      xPredInterChromaBlkFromDM( pcBaseViewTxtPicYuv, pcBaseViewDepthPicYuv, pShiftLUT, iShiftPrec, &cMv, uiPartAddr, iBlkX>>1, iBlkY>>1, iWidth>>1, iHeight>>1, pcCU->getSlice()->getSPS()->isDepth(), vspIdx, rpcYuvPred );
1100#else
1101#if MERL_Bi_VSP_D0166
1102      xPredInterVSPBlk(pcCU, uiPartAddr, uiAbsPartIdx, iWidth, iHeight, cMv, eRefPicList, rpcYuvPred, bi );
1103#else
1104      xPredInterVSPBlk(pcCU, uiPartAddr, uiAbsPartIdx, iWidth, iHeight, cMv, eRefPicList, rpcYuvPred, bi, vspIdx );
1105#endif
1106#endif
1107    }
1108    else//texture not VSP
1109    {
1110#endif //MERL_VSP_C0152
1111#if LGE_ILLUCOMP_B0045
1112      Bool bICFlag = pcCU->getICFlag(uiPartAddr) && (pcCU->getSlice()->getRefViewId( eRefPicList, iRefIdx ) != pcCU->getSlice()->getViewId());
1113
1114      xPredInterLumaBlk  ( pcCU, pcCU->getSlice()->getRefPic( eRefPicList, iRefIdx )->getPicYuvRec(), uiPartAddr, &cMv, iWidth, iHeight, rpcYuvPred, bi, bICFlag);
1115#else
1116      xPredInterLumaBlk  ( pcCU, pcCU->getSlice()->getRefPic( eRefPicList, iRefIdx )->getPicYuvRec(), uiPartAddr, &cMv, iWidth, iHeight, rpcYuvPred, bi );
1117#endif
1118#if MERL_VSP_C0152
1119     } //texture not VSP
1120#endif
1121#if HHI_FULL_PEL_DEPTH_MAP_MV_ACC
1122  }
1123#endif
1124
1125#if MERL_VSP_C0152
1126  if ( vspIdx == 0 )//Not VSP
1127  {
1128#endif
1129#if LGE_ILLUCOMP_B0045
1130  Bool bICFlag = pcCU->getICFlag(uiPartAddr) && (pcCU->getSlice()->getRefViewId( eRefPicList, iRefIdx ) != pcCU->getSlice()->getViewId());
1131
1132  xPredInterChromaBlk( pcCU, pcCU->getSlice()->getRefPic( eRefPicList, iRefIdx )->getPicYuvRec(), uiPartAddr, &cMv, iWidth, iHeight, rpcYuvPred, bi, bICFlag );
1133#else
1134  xPredInterChromaBlk( pcCU, pcCU->getSlice()->getRefPic( eRefPicList, iRefIdx )->getPicYuvRec(), uiPartAddr, &cMv, iWidth, iHeight, rpcYuvPred, bi );
1135#endif
1136#if MERL_VSP_C0152
1137   }
1138#endif
1139#if QC_ARP_D0177
1140  }
1141#endif
1142}
1143
1144#if QC_ARP_D0177
1145Void TComPrediction::xPredInterUniARP( TComDataCU* pcCU, UInt uiPartAddr, Int iWidth, Int iHeight, RefPicList eRefPicList, TComYuv*& rpcYuvPred, Int iPartIdx, Bool bi, TComMvField * pNewMvFiled )
1146{
1147  Int         iRefIdx     = pcCU->getCUMvField( eRefPicList )->getRefIdx( uiPartAddr );           
1148  TComMv      cMv         = pcCU->getCUMvField( eRefPicList )->getMv( uiPartAddr );
1149  Bool        bTobeScaled = false;
1150  UChar dW = pcCU->getARPW ( uiPartAddr );
1151  TComPic* pcPicYuvBaseCol =  NULL;
1152  TComPic* pcPicYuvBaseRef =  NULL;
1153  DisInfo cDistparity;
1154
1155  if( pNewMvFiled )
1156  {
1157    iRefIdx = pNewMvFiled->getRefIdx(); 
1158    cMv = pNewMvFiled->getMv();
1159  }
1160
1161#if QC_CU_NBDV_D0181
1162  cDistparity.bDV           = pcCU->getDvInfo(uiPartAddr).bDV;
1163  if( cDistparity.bDV )
1164  {
1165#if MERL_VSP_C0152
1166    cDistparity.m_acMvCand[0] = pcCU->getDvInfo(0).m_acMvCandNoRef[0];
1167#else
1168    cDistparity.m_acMvCand[0] = pcCU->getDvInfo(0).m_acMvCand[0];
1169#endif
1170    assert(pcCU->getDvInfo(uiPartAddr).bDV ==  pcCU->getDvInfo(0).bDV);
1171    cDistparity.m_aVIdxCan[0] = pcCU->getDvInfo(uiPartAddr).m_aVIdxCan[0];
1172    cDistparity.iN            = pcCU->getDvInfo(uiPartAddr).iN;
1173  }
1174  else
1175    cDistparity.iN    =  0;
1176#else
1177  pcCU->getDisMvpCandNBDV( iPartIdx, uiPartAddr,  &cDistparity, false );
1178#endif
1179
1180  dW = !cDistparity.iN ? 0: dW;
1181  if( cDistparity.iN ) 
1182  {
1183    if(dW > 0 && pcCU->getSlice()->getRefPic( eRefPicList, 0 )->getPOC()!= pcCU->getSlice()->getPOC())
1184      bTobeScaled = true;
1185    pcPicYuvBaseCol =  pcCU->getSlice()->getBaseViewRefPic( pcCU->getSlice()->getPOC(),                              cDistparity.m_aVIdxCan[0] );
1186    pcPicYuvBaseRef =  pcCU->getSlice()->getBaseViewRefPic( pcCU->getSlice()->getRefPic( eRefPicList, 0 )->getPOC(), cDistparity.m_aVIdxCan[0] );
1187    if( (!pcPicYuvBaseCol || pcPicYuvBaseCol->getPOC() != pcCU->getSlice()->getPOC()) || (!pcPicYuvBaseRef || pcPicYuvBaseRef->getPOC() != pcCU->getSlice()->getRefPic( eRefPicList, 0 )->getPOC() ))
1188    {
1189      dW = 0;
1190      bTobeScaled = false;
1191    }
1192    else
1193      assert( pcPicYuvBaseCol->getPOC() == pcCU->getSlice()->getPOC() && pcPicYuvBaseRef->getPOC() == pcCU->getSlice()->getRefPic( eRefPicList, 0 )->getPOC() );
1194    if(bTobeScaled)
1195    {     
1196      Int iCurrPOC = pcCU->getSlice()->getPOC();
1197      Int iColRefPOC  = pcCU->getSlice()->getRefPOC( eRefPicList, iRefIdx );
1198      Int iCurrRefPOC = pcCU->getSlice()->getRefPOC( eRefPicList,  0);
1199      Int iScale = pcCU-> xGetDistScaleFactor(iCurrPOC, iCurrRefPOC, iCurrPOC, iColRefPOC);
1200      if ( iScale != 4096 )
1201        cMv = cMv.scaleMv( iScale );
1202      iRefIdx = 0;
1203    }
1204  }
1205  pcCU->clipMv(cMv);
1206  TComPicYuv* pcPicYuvRef = pcCU->getSlice()->getRefPic( eRefPicList, iRefIdx )->getPicYuvRec();
1207  xPredInterLumaBlk  ( pcCU, pcPicYuvRef, uiPartAddr, &cMv, iWidth, iHeight, rpcYuvPred, bi
1208#if LGE_ILLUCOMP_B0045
1209    , false
1210#endif
1211    , true 
1212    );
1213  xPredInterChromaBlk( pcCU, pcPicYuvRef, uiPartAddr, &cMv, iWidth, iHeight, rpcYuvPred, bi
1214#if LGE_ILLUCOMP_B0045
1215    , false
1216#endif
1217    , true
1218    );
1219  if( dW > 0 )
1220  {
1221    TComYuv * pYuvmB0 = &m_acYuvPredBase[0];
1222    TComYuv * pYuvB1  = &m_acYuvPredBase[1];
1223    assert ( cDistparity.iN == 1 );
1224    pcPicYuvRef = pcPicYuvBaseCol->getPicYuvRec();
1225    xPredInterLumaBlk  ( pcCU, pcPicYuvRef, uiPartAddr, &cDistparity.m_acMvCand[0], iWidth, iHeight, pYuvB1, bi
1226#if LGE_ILLUCOMP_B0045
1227      , false
1228#endif
1229      ,  true
1230      );
1231    xPredInterChromaBlk( pcCU, pcPicYuvRef, uiPartAddr, &cDistparity.m_acMvCand[0], iWidth, iHeight, pYuvB1, bi
1232#if LGE_ILLUCOMP_B0045
1233      , false
1234#endif
1235      , true
1236      );
1237    pcPicYuvRef = pcPicYuvBaseRef->getPicYuvRec();
1238    TComMv cMVwithDisparity = cMv + cDistparity.m_acMvCand[0];
1239    pcCU->clipMv(cMVwithDisparity);
1240    xPredInterLumaBlk  ( pcCU, pcPicYuvRef, uiPartAddr, &cMVwithDisparity, iWidth, iHeight, pYuvmB0, bi
1241#if LGE_ILLUCOMP_B0045
1242      , false
1243#endif
1244      , true
1245      );
1246    xPredInterChromaBlk( pcCU, pcPicYuvRef, uiPartAddr, &cMVwithDisparity, iWidth, iHeight, pYuvmB0, bi
1247#if LGE_ILLUCOMP_B0045
1248      , false
1249#endif
1250      , true
1251      );
1252    pYuvB1->subtractARP( pYuvB1 , pYuvmB0 , uiPartAddr , iWidth , iHeight );
1253    if(dW == 2)
1254      pYuvB1->multiplyARP( uiPartAddr , iWidth , iHeight , dW );
1255    rpcYuvPred->addARP( rpcYuvPred , pYuvB1 , uiPartAddr , iWidth , iHeight , !bi );
1256  }
1257}
1258#endif
1259
1260#if MERL_VSP_C0152
1261Void TComPrediction::xPredInterBi ( TComDataCU* pcCU, UInt uiPartAddr, UInt uiAbsPartIdx, Int iWidth, Int iHeight, UInt uiSubSampExpX, UInt uiSubSampExpY, TComYuv*& rpcYuvPred, Int iPartIdx, Bool bPrdDepthMap )
1262#else
1263Void TComPrediction::xPredInterBi ( TComDataCU* pcCU, UInt uiPartAddr, Int iWidth, Int iHeight, UInt uiSubSampExpX, UInt uiSubSampExpY, TComYuv*& rpcYuvPred, Int iPartIdx, Bool bPrdDepthMap )
1264#endif
1265{
1266  TComYuv* pcMbYuv;
1267  Int      iRefIdx[2] = {-1, -1};
1268
1269#if MERL_Bi_VSP_D0166
1270  Bool biDecision = 0;
1271  Int  predDirVSP = 0;
1272#if QC_BVSP_CleanUP_D0191
1273  RefPicList privateRefPicList = REF_PIC_LIST_0;
1274#endif
1275  if (pcCU->getVSPIndex(uiPartAddr) != 0) // is VSP
1276  {
1277    Int biVSPAvail = 0;
1278    //test whether VSP is Bi or Uni
1279    //Step1. Get derived DV view id
1280#if QC_BVSP_CleanUP_D0191
1281    RefPicList otherRefPicList = REF_PIC_LIST_1;
1282    Int refIdxList0 = pcCU->getCUMvField( REF_PIC_LIST_0 )->getRefIdx( uiPartAddr );
1283    Int refIdxList1 = pcCU->getCUMvField( REF_PIC_LIST_1 )->getRefIdx( uiPartAddr );
1284    privateRefPicList = refIdxList0 != NOT_VALID ? REF_PIC_LIST_0 : REF_PIC_LIST_1;
1285    if(privateRefPicList == REF_PIC_LIST_1 && refIdxList1==NOT_VALID )
1286    {
1287      assert(0);
1288    }
1289    Int privateRefIdx = privateRefPicList == REF_PIC_LIST_0 ? refIdxList0 : refIdxList1;
1290    Int viewId = pcCU->getSlice()->getRefViewId(privateRefPicList, privateRefIdx);
1291    Int refPoc = pcCU->getSlice()->getRefPOC(privateRefPicList, privateRefIdx);
1292#else
1293    Int  refIdx = pcCU->getCUMvField( privateRefPicList )->getRefIdx( uiPartAddr );
1294    RefPicList privateRefPicList = (RefPicList) pcCU->getVSPDir( uiPartAddr );
1295    RefPicList otherRefPicList = privateRefPicList == REF_PIC_LIST_0 ? REF_PIC_LIST_1 : REF_PIC_LIST_0;
1296    assert(privateRefPicList == REF_PIC_LIST_0 || privateRefPicList == REF_PIC_LIST_1);
1297    Int  refIdx = -1-pcCU->getCUMvField( privateRefPicList )->getRefIdx( uiPartAddr );
1298    assert(refIdx >= 0);
1299    Int  viewId = pcCU->getSlice()->getRefViewId(privateRefPicList, refIdx);
1300    Int  refPoc = pcCU->getSlice()->getRefPOC(privateRefPicList, refIdx);
1301#endif
1302    assert(refPoc == pcCU->getSlice()->getPOC());
1303//    if(refPoc != pcCU->getSlice()->getPOC() )
1304//    {
1305//      printf("refPOC= %d, and current POC=%d\n", refPoc, pcCU->getSlice()->getPOC() );
1306//    }
1307    //Step 2. Get initial prediction direction value according to reference picture list availability
1308    Int iInterDir = ((pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_0) > 0 && pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_1) > 0) ? 3 :
1309      (pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_0) > 0 ? 1 : 2)); 
1310    //Step 3.  Check the availability of Bi VSP by checking the interview reference availability in the other reference list
1311    if(iInterDir == 3)
1312    {
1313      for (Int jRefIdx = 0; jRefIdx <pcCU->getSlice()->getNumRefIdx(otherRefPicList); jRefIdx++ )
1314      {
1315        Int refViewIdx  = pcCU->getSlice()->getRefViewId( otherRefPicList, jRefIdx);
1316        if ( (refViewIdx != pcCU->getSlice()->getViewId()) && (refViewIdx != viewId ) )
1317        {
1318          biVSPAvail = 1;
1319          break;
1320        }
1321      }
1322    }
1323    //Step 4. Update the Bi VSP prediction direction
1324    if ( iInterDir == 3 && biVSPAvail == 1)
1325    {
1326      biDecision   = 1;
1327      predDirVSP = 3;
1328    }
1329    else
1330    {
1331      biDecision = 0;
1332      if ( privateRefPicList == REF_PIC_LIST_0 )
1333        predDirVSP = 1;
1334      else
1335        predDirVSP = 2;
1336    }
1337  }
1338  else 
1339  {//not VSP
1340    if( ( pcCU->getCUMvField( REF_PIC_LIST_0 )->getRefIdx( uiPartAddr ) >= 0 && pcCU->getCUMvField( REF_PIC_LIST_1 )->getRefIdx( uiPartAddr ) >= 0 ) )
1341      biDecision = 1;
1342    else
1343      biDecision = 0;
1344  }
1345#endif
1346
1347  for ( Int iRefList = 0; iRefList < 2; iRefList++ )
1348  {
1349    RefPicList eRefPicList = (iRefList ? REF_PIC_LIST_1 : REF_PIC_LIST_0);
1350    iRefIdx[iRefList] = pcCU->getCUMvField( eRefPicList )->getRefIdx( uiPartAddr );
1351
1352#if MERL_VSP_C0152
1353    if(!pcCU->getVSPIndex(uiPartAddr))
1354    {
1355      if ( iRefIdx[iRefList] < 0 )
1356      {
1357        continue;
1358      }
1359    }
1360    else
1361    {
1362
1363#if !MERL_Bi_VSP_D0166 //both lists should go
1364      if ( iRefList == REF_PIC_LIST_1 && iRefIdx[iRefList] < 0 ) // iRefIdx[iRefList] ==NOT_VALID
1365      {
1366        continue;
1367      }
1368#else
1369      //Reference list loop termination
1370#if QC_BVSP_CleanUP_D0191
1371      RefPicList privateVSPRefPicList = privateRefPicList;
1372#else
1373      RefPicList privateVSPRefPicList = (RefPicList) pcCU->getVSPDir( uiPartAddr );
1374#endif
1375      if( (pcCU->getVSPIndex(uiPartAddr)!=0) &&  iRefList != privateVSPRefPicList && !biDecision  ) 
1376      {//when VSP mode, if it is uni prediction, the other reference list should skip
1377        continue;
1378      }
1379#endif
1380
1381    }
1382#else
1383    if ( iRefIdx[iRefList] < 0 )
1384    {
1385      continue;
1386    }
1387#endif
1388
1389    assert( iRefIdx[iRefList] < pcCU->getSlice()->getNumRefIdx(eRefPicList) );
1390
1391    pcMbYuv = &m_acYuvPred[iRefList];
1392
1393#if MERL_Bi_VSP_D0166
1394    if(biDecision == 1)
1395#else
1396    if( pcCU->getCUMvField( REF_PIC_LIST_0 )->getRefIdx( uiPartAddr ) >= 0 && pcCU->getCUMvField( REF_PIC_LIST_1 )->getRefIdx( uiPartAddr ) >= 0 )
1397#endif
1398    {
1399#if MERL_VSP_C0152
1400      xPredInterUni ( pcCU, uiPartAddr, uiAbsPartIdx, iWidth, iHeight, eRefPicList, pcMbYuv, iPartIdx, bPrdDepthMap, uiSubSampExpX, uiSubSampExpY, true );
1401#else
1402      xPredInterUni ( pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcMbYuv, iPartIdx, bPrdDepthMap, uiSubSampExpX, uiSubSampExpY, true );
1403#endif
1404    }
1405    else
1406    {
1407#if FIX_LGE_WP_FOR_3D_C0223
1408      if ( ( pcCU->getSlice()->getPPS()->getUseWP()      && pcCU->getSlice()->getSliceType() == P_SLICE ) || 
1409         ( pcCU->getSlice()->getPPS()->getWPBiPredIdc() && pcCU->getSlice()->getSliceType() == B_SLICE ) )
1410#else
1411      if ( pcCU->getSlice()->getPPS()->getWPBiPredIdc() )
1412#endif
1413      {
1414#if MERL_VSP_C0152
1415        xPredInterUni ( pcCU, uiPartAddr, uiAbsPartIdx, iWidth, iHeight, eRefPicList, pcMbYuv, iPartIdx, bPrdDepthMap, uiSubSampExpX, uiSubSampExpY, true );
1416#else
1417        xPredInterUni ( pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcMbYuv, iPartIdx, bPrdDepthMap, uiSubSampExpX, uiSubSampExpY, true );
1418#endif
1419      }
1420      else
1421      {
1422#if MERL_VSP_C0152
1423        xPredInterUni ( pcCU, uiPartAddr, uiAbsPartIdx, iWidth, iHeight, eRefPicList, pcMbYuv, iPartIdx, bPrdDepthMap, uiSubSampExpX, uiSubSampExpY, false );
1424#else
1425        xPredInterUni ( pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcMbYuv, iPartIdx, bPrdDepthMap, uiSubSampExpX, uiSubSampExpY, false );
1426#endif
1427      }
1428    }
1429  }
1430#if FIX_LGE_WP_FOR_3D_C0223
1431  if ( pcCU->getSlice()->getPPS()->getWPBiPredIdc() && pcCU->getSlice()->getSliceType() == B_SLICE  )
1432#else
1433  if ( pcCU->getSlice()->getPPS()->getWPBiPredIdc() )
1434#endif
1435  {
1436#if MERL_VSP_C0152
1437#if !MERL_Bi_VSP_D0166
1438    if(pcCU->getVSPIndex(uiPartAddr))
1439      m_acYuvPred[0].copyPartToPartYuv( rpcYuvPred, uiPartAddr, iWidth, iHeight );
1440    else
1441#endif
1442#endif
1443    xWeightedPredictionBi( pcCU, &m_acYuvPred[0], &m_acYuvPred[1], iRefIdx[0], iRefIdx[1], uiPartAddr, iWidth, iHeight, rpcYuvPred );
1444  }
1445#if FIX_LGE_WP_FOR_3D_C0223
1446  else if ( pcCU->getSlice()->getPPS()->getUseWP() && pcCU->getSlice()->getSliceType() == P_SLICE )
1447
1448  {
1449#if MERL_VSP_C0152
1450#if !MERL_Bi_VSP_D0166
1451    if(pcCU->getVSPIndex(uiPartAddr))
1452      m_acYuvPred[0].copyPartToPartYuv( rpcYuvPred, uiPartAddr, iWidth, iHeight );
1453    else
1454#endif
1455#endif
1456      xWeightedPredictionUni( pcCU, &m_acYuvPred[0], uiPartAddr, iWidth, iHeight, REF_PIC_LIST_0, rpcYuvPred, iPartIdx ); 
1457  }
1458#endif
1459  else
1460  {
1461    if ( bPrdDepthMap )
1462    {
1463      xWeightedAveragePdm( pcCU, &m_acYuvPred[0], &m_acYuvPred[1], iRefIdx[0], iRefIdx[1], uiPartAddr, iWidth, iHeight, rpcYuvPred, uiSubSampExpX, uiSubSampExpY );
1464    }
1465    else
1466    {
1467#if MERL_VSP_C0152
1468#if !MERL_Bi_VSP_D0166
1469      if(pcCU->getVSPIndex(uiPartAddr))
1470        m_acYuvPred[0].copyPartToPartYuv( rpcYuvPred, uiPartAddr, iWidth, iHeight );
1471      else
1472        xWeightedAverage( pcCU, &m_acYuvPred[0], &m_acYuvPred[1], iRefIdx[0], iRefIdx[1], uiPartAddr, iWidth, iHeight, rpcYuvPred );
1473#else
1474      xWeightedAverage( pcCU, &m_acYuvPred[0], &m_acYuvPred[1], iRefIdx[0], iRefIdx[1], uiPartAddr, iWidth, iHeight, rpcYuvPred, predDirVSP );
1475#endif
1476#else
1477      xWeightedAverage( pcCU, &m_acYuvPred[0], &m_acYuvPred[1], iRefIdx[0], iRefIdx[1], uiPartAddr, iWidth, iHeight, rpcYuvPred );
1478#endif
1479    }
1480  }
1481}
1482
1483
1484
1485Void
1486TComPrediction::xPredInterPrdDepthMap( TComDataCU* pcCU, TComPicYuv* pcPicYuvRef, UInt uiPartAddr, TComMv* pcMv, Int iWidth, Int iHeight, UInt uiSubSampExpX, UInt uiSubSampExpY, TComYuv*& rpcYuv, UInt uiRShift, UInt uiOffset
1487#if LGE_ILLUCOMP_DEPTH_C0046
1488, Bool bICFlag
1489#endif
1490)
1491{
1492  Int     iShiftX     = 2 + uiSubSampExpX;
1493  Int     iShiftY     = 2 + uiSubSampExpY;
1494  Int     iAddX       = ( 1 << iShiftX ) >> 1;
1495  Int     iAddY       = ( 1 << iShiftY ) >> 1;
1496  Int     iHor        = ( pcMv->getHor() + iAddX ) >> iShiftX;
1497  Int     iVer        = ( pcMv->getVer() + iAddY ) >> iShiftY;
1498#if HHI_FULL_PEL_DEPTH_MAP_MV_ACC
1499  if( pcCU->getSlice()->getSPS()->isDepth() )
1500  {
1501    iHor = pcMv->getHor();
1502    iVer = pcMv->getVer();
1503  }
1504#endif
1505  Int     iRefStride  = pcPicYuvRef->getStride();
1506  Int     iDstStride  = rpcYuv->getStride();
1507  Int     iRefOffset  = iHor + iVer * iRefStride;
1508
1509  Pel*    piRefY      = pcPicYuvRef->getLumaAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() + uiPartAddr ) + iRefOffset;
1510  Pel*    piDstY      = rpcYuv->getLumaAddr( uiPartAddr );
1511
1512  for( Int y = 0; y < iHeight; y++, piDstY += iDstStride, piRefY += iRefStride )
1513  {
1514    for( Int x = 0; x < iWidth; x++ )
1515    {
1516      piDstY[ x ] = ( piRefY[ x ] << uiRShift ) - uiOffset;
1517    }
1518  }
1519
1520#if LGE_ILLUCOMP_DEPTH_C0046
1521  if(bICFlag)
1522  {
1523    Int a, b, iShift;
1524    TComMv tTmpMV(pcMv->getHor()<<2, pcMv->getVer()<<2);
1525
1526    piRefY      = pcPicYuvRef->getLumaAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() + uiPartAddr ) + iRefOffset;
1527    piDstY      = rpcYuv->getLumaAddr( uiPartAddr );
1528
1529    xGetLLSICPrediction(pcCU, &tTmpMV, pcPicYuvRef, a, b, iShift);
1530
1531    for( Int y = 0; y < iHeight; y++, piDstY += iDstStride, piRefY += iRefStride )
1532    {
1533      for( Int x = 0; x < iWidth; x++ )
1534      {
1535        if(uiOffset)
1536        {
1537          Int iIFshift = IF_INTERNAL_PREC - ( g_uiBitDepth + g_uiBitIncrement );
1538          piDstY[ x ] = ( (a*piDstY[ x ]+a*IF_INTERNAL_OFFS) >> iShift ) + b*(1<<iIFshift) - IF_INTERNAL_OFFS;
1539        }
1540        else
1541          piDstY[ x ] = Clip( ( (a*piDstY[ x ]) >> iShift ) + b );
1542      }
1543    }
1544  }
1545#endif
1546}
1547
1548
1549/**
1550 * \brief Generate motion-compensated luma block
1551 *
1552 * \param cu       Pointer to current CU
1553 * \param refPic   Pointer to reference picture
1554 * \param partAddr Address of block within CU
1555 * \param mv       Motion vector
1556 * \param width    Width of block
1557 * \param height   Height of block
1558 * \param dstPic   Pointer to destination picture
1559 * \param bi       Flag indicating whether bipred is used
1560 */
1561#if LGE_ILLUCOMP_B0045
1562Void TComPrediction::xPredInterLumaBlk( TComDataCU *cu, TComPicYuv *refPic, UInt partAddr, TComMv *mv, Int width, Int height, TComYuv *&dstPic, Bool bi, Bool bICFlag
1563#if QC_ARP_D0177
1564    ,
1565    Int filterType
1566#endif
1567    )
1568#else
1569Void TComPrediction::xPredInterLumaBlk( TComDataCU *cu, TComPicYuv *refPic, UInt partAddr, TComMv *mv, Int width, Int height, TComYuv *&dstPic, Bool bi
1570#if QC_ARP_D0177
1571    ,
1572    Int filterType
1573#endif
1574    )
1575#endif
1576{
1577  Int refStride = refPic->getStride(); 
1578  Int refOffset = ( mv->getHor() >> 2 ) + ( mv->getVer() >> 2 ) * refStride;
1579  Pel *ref      = refPic->getLumaAddr( cu->getAddr(), cu->getZorderIdxInCU() + partAddr ) + refOffset;
1580 
1581  Int dstStride = dstPic->getStride();
1582  Pel *dst      = dstPic->getLumaAddr( partAddr );
1583 
1584  Int xFrac = mv->getHor() & 0x3;
1585  Int yFrac = mv->getVer() & 0x3;
1586
1587#if HHI_FULL_PEL_DEPTH_MAP_MV_ACC
1588  assert( ! cu->getSlice()->getIsDepth() || ( xFrac == 0 && yFrac == 0 ) );
1589#endif
1590
1591  if ( yFrac == 0 )
1592  {
1593    m_if.filterHorLuma( ref, refStride, dst, dstStride, width, height, xFrac,       !bi
1594#if QC_ARP_D0177
1595    ,
1596    filterType
1597#endif
1598    );
1599  }
1600  else if ( xFrac == 0 )
1601  {
1602    m_if.filterVerLuma( ref, refStride, dst, dstStride, width, height, yFrac, true, !bi
1603#if QC_ARP_D0177
1604    ,
1605    filterType
1606#endif
1607    );
1608  }
1609  else
1610  {
1611    Int tmpStride = m_filteredBlockTmp[0].getStride();
1612    Short *tmp    = m_filteredBlockTmp[0].getLumaAddr();
1613
1614    Int filterSize = NTAPS_LUMA;
1615    Int halfFilterSize = ( filterSize >> 1 );
1616
1617    m_if.filterHorLuma(ref - (halfFilterSize-1)*refStride, refStride, tmp, tmpStride, width, height+filterSize-1, xFrac, false     
1618 #if QC_ARP_D0177
1619    ,
1620    filterType
1621#endif
1622    );
1623    m_if.filterVerLuma(tmp + (halfFilterSize-1)*tmpStride, tmpStride, dst, dstStride, width, height,              yFrac, false, !bi
1624 #if QC_ARP_D0177
1625    ,
1626    filterType
1627#endif
1628    );   
1629  }
1630
1631#if LGE_ILLUCOMP_B0045
1632  if(bICFlag)
1633  {
1634    Int a, b, iShift, i, j;
1635
1636    xGetLLSICPrediction(cu, mv, refPic, a, b, iShift);
1637
1638    for (i = 0; i < height; i++)
1639    {
1640      for (j = 0; j < width; j++)
1641      {
1642        if(bi)
1643        {
1644          Int iIFshift = IF_INTERNAL_PREC - ( g_uiBitDepth + g_uiBitIncrement );
1645          dst[j] = ( (a*dst[j]+a*IF_INTERNAL_OFFS) >> iShift ) + b*(1<<iIFshift) - IF_INTERNAL_OFFS;
1646        }
1647        else
1648          dst[j] = Clip( ( (a*dst[j]) >> iShift ) + b );
1649      }
1650      dst += dstStride;
1651    }
1652  }
1653#endif
1654}
1655
1656/**
1657 * \brief Generate motion-compensated chroma block
1658 *
1659 * \param cu       Pointer to current CU
1660 * \param refPic   Pointer to reference picture
1661 * \param partAddr Address of block within CU
1662 * \param mv       Motion vector
1663 * \param width    Width of block
1664 * \param height   Height of block
1665 * \param dstPic   Pointer to destination picture
1666 * \param bi       Flag indicating whether bipred is used
1667 */
1668#if LGE_ILLUCOMP_B0045
1669Void TComPrediction::xPredInterChromaBlk( TComDataCU *cu, TComPicYuv *refPic, UInt partAddr, TComMv *mv, Int width, Int height, TComYuv *&dstPic, Bool bi, Bool bICFlag
1670#if QC_ARP_D0177
1671    ,
1672    Int filterType
1673#endif   
1674    )
1675#else
1676Void TComPrediction::xPredInterChromaBlk( TComDataCU *cu, TComPicYuv *refPic, UInt partAddr, TComMv *mv, Int width, Int height, TComYuv *&dstPic, Bool bi
1677#if QC_ARP_D0177
1678  , Int filterType
1679#endif
1680  )
1681#endif
1682{
1683  Int     refStride  = refPic->getCStride();
1684  Int     dstStride  = dstPic->getCStride();
1685 
1686  Int     refOffset  = (mv->getHor() >> 3) + (mv->getVer() >> 3) * refStride;
1687 
1688  Pel*    refCb     = refPic->getCbAddr( cu->getAddr(), cu->getZorderIdxInCU() + partAddr ) + refOffset;
1689  Pel*    refCr     = refPic->getCrAddr( cu->getAddr(), cu->getZorderIdxInCU() + partAddr ) + refOffset;
1690 
1691  Pel* dstCb = dstPic->getCbAddr( partAddr );
1692  Pel* dstCr = dstPic->getCrAddr( partAddr );
1693 
1694  Int     xFrac  = mv->getHor() & 0x7;
1695  Int     yFrac  = mv->getVer() & 0x7;
1696  UInt    cxWidth  = width  >> 1;
1697  UInt    cxHeight = height >> 1;
1698 
1699  Int     extStride = m_filteredBlockTmp[0].getStride();
1700  Short*  extY      = m_filteredBlockTmp[0].getLumaAddr();
1701 
1702  Int filterSize = NTAPS_CHROMA;
1703 
1704  Int halfFilterSize = (filterSize>>1);
1705 
1706  if ( yFrac == 0 )
1707  {
1708    m_if.filterHorChroma(refCb, refStride, dstCb,  dstStride, cxWidth, cxHeight, xFrac, !bi
1709#if QC_ARP_D0177
1710    ,
1711    filterType
1712#endif   
1713    );   
1714    m_if.filterHorChroma(refCr, refStride, dstCr,  dstStride, cxWidth, cxHeight, xFrac, !bi
1715#if QC_ARP_D0177
1716    ,
1717    filterType
1718#endif   
1719    );   
1720  }
1721  else if ( xFrac == 0 )
1722  {
1723    m_if.filterVerChroma(refCb, refStride, dstCb, dstStride, cxWidth, cxHeight, yFrac, true, !bi
1724 #if QC_ARP_D0177
1725    ,
1726    filterType
1727#endif   
1728    );   
1729    m_if.filterVerChroma(refCr, refStride, dstCr, dstStride, cxWidth, cxHeight, yFrac, true, !bi
1730 #if QC_ARP_D0177
1731    ,
1732    filterType
1733#endif   
1734    );   
1735  }
1736  else
1737  {
1738    m_if.filterHorChroma(refCb - (halfFilterSize-1)*refStride, refStride, extY,  extStride, cxWidth, cxHeight+filterSize-1, xFrac, false
1739#if QC_ARP_D0177
1740    ,
1741    filterType
1742#endif   
1743    );
1744    m_if.filterVerChroma(extY  + (halfFilterSize-1)*extStride, extStride, dstCb, dstStride, cxWidth, cxHeight  , yFrac, false, !bi
1745#if QC_ARP_D0177
1746    ,
1747    filterType
1748#endif   
1749    );
1750   
1751    m_if.filterHorChroma(refCr - (halfFilterSize-1)*refStride, refStride, extY,  extStride, cxWidth, cxHeight+filterSize-1, xFrac, false
1752#if QC_ARP_D0177
1753    ,
1754    filterType
1755#endif   
1756    );
1757    m_if.filterVerChroma(extY  + (halfFilterSize-1)*extStride, extStride, dstCr, dstStride, cxWidth, cxHeight  , yFrac, false, !bi
1758#if QC_ARP_D0177
1759    ,
1760    filterType
1761#endif   
1762    );   
1763  }
1764#if LGE_ILLUCOMP_B0045
1765  if(bICFlag)
1766  {
1767    Int a, b, iShift, i, j;
1768    xGetLLSICPredictionChroma(cu, mv, refPic, a, b, iShift, 0); // Cb
1769    for (i = 0; i < cxHeight; i++)
1770    {
1771      for (j = 0; j < cxWidth; j++)
1772      {
1773        if(bi)
1774        {
1775          Int iIFshift = IF_INTERNAL_PREC - ( g_uiBitDepth + g_uiBitIncrement );
1776          dstCb[j] = ( (a*dstCb[j]+a*IF_INTERNAL_OFFS) >> iShift ) + b*(1<<iIFshift) - IF_INTERNAL_OFFS;
1777        }
1778        else
1779          dstCb[j] = Clip3(0, 255, ((a*dstCb[j])>>iShift)+b);
1780      }
1781      dstCb += dstStride;
1782    }
1783
1784    xGetLLSICPredictionChroma(cu, mv, refPic, a, b, iShift, 1); // Cr
1785    for (i = 0; i < cxHeight; i++)
1786    {
1787      for (j = 0; j < cxWidth; j++)
1788      {
1789        if(bi)
1790        {
1791          Int iIFshift = IF_INTERNAL_PREC - ( g_uiBitDepth + g_uiBitIncrement );
1792          dstCr[j] = ( (a*dstCr[j]+a*IF_INTERNAL_OFFS) >> iShift ) + b*(1<<iIFshift) - IF_INTERNAL_OFFS;
1793        }
1794        else
1795          dstCr[j] = Clip3(0, 255, ((a*dstCr[j])>>iShift)+b);
1796      }
1797      dstCr += dstStride;
1798    }
1799  }
1800#endif
1801}
1802
1803#if MERL_VSP_C0152
1804// Input:
1805// refPic: Ref picture. Full picture, with padding
1806// posX, posY:     PU position, texture
1807// sizeX, sizeY: PU size
1808// partAddr: z-order index
1809// mv: disparity vector. derived from neighboring blocks
1810//
1811// Output: dstPic, PU predictor 64x64
1812Void TComPrediction::xPredInterLumaBlkFromDM( TComPicYuv *refPic, TComPicYuv *pPicBaseDepth, Int* pShiftLUT, Int iShiftPrec, TComMv* mv, UInt partAddr,Int posX, Int posY, Int sizeX, Int sizeY, Bool isDepth
1813#if !MERL_Bi_VSP_D0166
1814                                            , Int vspIdx
1815#endif
1816                                            , TComYuv *&dstPic
1817#if MERL_Bi_VSP_D0166
1818                                            , Bool bi
1819#endif         
1820                                            )
1821{
1822  Int widthLuma;
1823  Int heightLuma;
1824
1825  if (isDepth)
1826  {
1827    widthLuma   =  pPicBaseDepth->getWidth();
1828    heightLuma  =  pPicBaseDepth->getHeight();
1829  }
1830  else
1831  {
1832    widthLuma   =  refPic->getWidth();
1833    heightLuma  =  refPic->getHeight();
1834  }
1835
1836#if MERL_VSP_BLOCKSIZE_C0152 != 1
1837  Int widthDepth  = pPicBaseDepth->getWidth();
1838  Int heightDepth = pPicBaseDepth->getHeight();
1839#endif
1840
1841#if MERL_CVSP_D0165
1842  Int widthDepth  = pPicBaseDepth->getWidth();
1843  Int heightDepth = pPicBaseDepth->getHeight();
1844#endif
1845
1846  Int nTxtPerDepthX = widthLuma  / ( pPicBaseDepth->getWidth() );  // texture pixel # per depth pixel
1847  Int nTxtPerDepthY = heightLuma / ( pPicBaseDepth->getHeight() );
1848
1849  Int refStride = refPic->getStride();
1850  Int dstStride = dstPic->getStride();
1851  Int depStride =  pPicBaseDepth->getStride();
1852#if LGE_ROUND_OFFSET_D0135
1853  Int depthPosX = Clip3(0,   widthLuma - sizeX,  (posX/nTxtPerDepthX) + ((mv->getHor()+2)>>2));
1854  Int depthPosY = Clip3(0,   heightLuma- sizeY,  (posY/nTxtPerDepthY) + ((mv->getVer()+2)>>2));
1855#else
1856  Int depthPosX = Clip3(0,   widthLuma - sizeX,  (posX/nTxtPerDepthX) + (mv->getHor()>>2));
1857  Int depthPosY = Clip3(0,   heightLuma- sizeY,  (posY/nTxtPerDepthY) + (mv->getVer()>>2));
1858#endif
1859  Pel *ref    = refPic->getLumaAddr() + posX + posY * refStride;
1860  Pel *dst    = dstPic->getLumaAddr(partAddr);
1861  Pel *depth  = pPicBaseDepth->getLumaAddr() + depthPosX + depthPosY * depStride;
1862
1863#if MERL_VSP_BLOCKSIZE_C0152 != 1
1864#if MERL_VSP_BLOCKSIZE_C0152 == 2
1865  Int  dW = sizeX>>1;
1866  Int  dH = sizeY>>1;
1867#endif
1868#if MERL_VSP_BLOCKSIZE_C0152 == 4
1869  Int  dW = sizeX>>2;
1870  Int  dH = sizeY>>2;
1871#endif
1872  {
1873    Pel* depthi = depth;
1874    for (Int j = 0; j < dH; j++)
1875    {
1876      for (Int i = 0; i < dW; i++)
1877      {
1878        Pel* depthTmp;
1879#if MERL_VSP_BLOCKSIZE_C0152 == 2
1880        if (depthPosX + (i<<1) < widthDepth)
1881          depthTmp = depthi + (i << 1);
1882        else
1883          depthTmp = depthi + (widthDepth - depthPosX - 1);
1884#endif
1885#if MERL_VSP_BLOCKSIZE_C0152 == 4
1886        if (depthPosX + (i<<2) < widthDepth)
1887          depthTmp = depthi + (i << 2);
1888        else
1889          depthTmp = depthi + (widthDepth - depthPosX - 1);
1890#endif
1891        Int maxV = 0;
1892#if MTK_DEPTH_TO_DISP_D0138
1893        for (Int blockj = 0; blockj < MERL_VSP_BLOCKSIZE_C0152; blockj+=(MERL_VSP_BLOCKSIZE_C0152-1))
1894#else
1895        for (Int blockj = 0; blockj < MERL_VSP_BLOCKSIZE_C0152; blockj++)
1896#endif
1897        {
1898          Int iX = 0;
1899#if MTK_DEPTH_TO_DISP_D0138
1900          for (Int blocki = 0; blocki < MERL_VSP_BLOCKSIZE_C0152; blocki+=(MERL_VSP_BLOCKSIZE_C0152-1))
1901#else
1902          for (Int blocki = 0; blocki < MERL_VSP_BLOCKSIZE_C0152; blocki++)
1903#endif
1904          {
1905            if (maxV < depthTmp[iX])
1906              maxV = depthTmp[iX];
1907#if MERL_VSP_BLOCKSIZE_C0152 == 2
1908            if (depthPosX + (i<<1) + blocki < widthDepth - 1)
1909#else // MERL_VSP_BLOCKSIZE_C0152 == 4
1910            if (depthPosX + (i<<2) + blocki < widthDepth - 1)
1911#endif
1912
1913#if NCKU_BUG_FIX
1914    iX = (MERL_VSP_BLOCKSIZE_C0152-1);
1915#else
1916    iX++;
1917#endif
1918          }
1919#if MERL_VSP_BLOCKSIZE_C0152 == 2
1920          if (depthPosY + (j<<1) + blockj < heightDepth - 1)
1921#else // MERL_VSP_BLOCKSIZE_C0152 == 4
1922          if (depthPosY + (j<<2) + blockj < heightDepth - 1)
1923#endif
1924#if NCKU_BUG_FIX
1925    depthTmp += depStride * (MERL_VSP_BLOCKSIZE_C0152-1);
1926#else
1927    depthTmp += depStride;
1928#endif
1929        }
1930        m_pDepth[i+j*dW] = maxV;
1931      } // end of i < dW
1932#if MERL_VSP_BLOCKSIZE_C0152 == 2
1933      if (depthPosY + ((j+1)<<1) < heightDepth)
1934        depthi += (depStride << 1);
1935      else
1936        depthi  = depth + (heightDepth-depthPosY-1)*depStride;
1937#endif
1938#if MERL_VSP_BLOCKSIZE_C0152 == 4
1939      if (depthPosY + ((j+1)<<2) < heightDepth) // heightDepth-1
1940        depthi += (depStride << 2);
1941      else
1942        depthi  = depth + (heightDepth-depthPosY-1)*depStride; // the last line
1943#endif
1944    }
1945  }
1946#endif
1947 
1948#if MERL_General_Fix
1949#if MERL_VSP_BLOCKSIZE_C0152 == 1
1950#if MERL_CVSP_D0165
1951  //get LUT based horizontal reference range
1952  Int range = 0;
1953  if( sizeX == 4 && sizeY == 8 )
1954    range = m_iRangeLuma[0];
1955  else if( sizeX == 8 && sizeY == 4 )
1956    range = m_iRangeLuma[1];
1957  else if( sizeX == 8 && sizeY == 8 )
1958    range = m_iRangeLuma[2];
1959  else if( sizeX == 8 && sizeY == 16 )
1960    range = m_iRangeLuma[3];
1961  else if( sizeX == 16 && sizeY == 8 )
1962    range = m_iRangeLuma[4];
1963  else if( sizeX == 16 && sizeY == 16 )
1964    range = m_iRangeLuma[5];
1965  else if( sizeX == 16 && sizeY == 32 )
1966    range = m_iRangeLuma[6];
1967  else if( sizeX == 32 && sizeY == 16 )
1968    range = m_iRangeLuma[7];
1969  else if( sizeX == 32 && sizeY == 32 )
1970    range = m_iRangeLuma[8];
1971  else if( sizeX == 32 && sizeY == 64 )
1972    range = m_iRangeLuma[9];
1973  else if( sizeX == 64 && sizeY == 32 )
1974    range = m_iRangeLuma[10];
1975  else if( sizeX == 64 && sizeY == 64 )
1976    range = m_iRangeLuma[11];
1977  else 
1978    assert(0);
1979
1980  // The minimum depth value
1981  Int minRelativePos = 5000;
1982  Int maxRelativePos = -5000;
1983
1984  Pel* depthTemp, *depthInitial=depth;
1985  for (Int yTxt =0; yTxt<sizeY; yTxt++)
1986  {
1987    for (Int xTxt =0; xTxt<sizeX; xTxt++)
1988    {
1989      if (depthPosX+xTxt < widthDepth)
1990        depthTemp = depthInitial + xTxt;
1991      else
1992        depthTemp = depthInitial + (widthDepth - depthPosX - 1);
1993
1994      Int disparity = pShiftLUT[ *depthTemp ] << iShiftPrec;
1995      Int disparityInt = disparity >> 2;
1996
1997      if( disparity <= 0)
1998      {
1999        if (minRelativePos > disparityInt+xTxt)
2000            minRelativePos = disparityInt+xTxt;
2001      }
2002      else
2003      {
2004        if (maxRelativePos < disparityInt+xTxt)
2005            maxRelativePos = disparityInt+xTxt;
2006      }
2007    }
2008    if (depthPosY+yTxt < heightDepth)
2009      depthInitial = depthInitial + depStride;
2010  }
2011
2012  Int disparity_tmp = pShiftLUT[ *depth ] << iShiftPrec;
2013  if (disparity_tmp <= 0)
2014    maxRelativePos = minRelativePos + range -1 ;
2015  else
2016    minRelativePos = maxRelativePos - range +1 ;
2017#endif
2018#endif
2019#endif
2020
2021#if MERL_VSP_BLOCKSIZE_C0152 != 1
2022  Int yDepth = 0;
2023#endif
2024  for ( Int yTxt = 0; yTxt < sizeY; yTxt += nTxtPerDepthY )
2025  {
2026    for ( Int xTxt = 0, xDepth = 0; xTxt < sizeX; xTxt += nTxtPerDepthX, xDepth++ )
2027    {
2028      Pel repDepth = 0; // to store the depth value used for warping
2029#if MERL_VSP_BLOCKSIZE_C0152 == 1
2030      repDepth = depth[xDepth];
2031#endif
2032#if MERL_VSP_BLOCKSIZE_C0152 == 2
2033      repDepth = m_pDepth[(xTxt>>1) + (yTxt>>1)*dW];
2034#endif
2035#if MERL_VSP_BLOCKSIZE_C0152 == 4
2036      repDepth = m_pDepth[(xTxt>>2) + (yTxt>>2)*dW];
2037#endif
2038
2039      assert( repDepth >= 0 && repDepth <= 255 );
2040      Int disparity = pShiftLUT[ repDepth ] << iShiftPrec;
2041      Int refOffset = xTxt + (disparity >> 2);
2042      Int xFrac = disparity & 0x3;
2043#if MERL_CVSP_D0165
2044      if(refOffset<minRelativePos || refOffset>maxRelativePos)
2045        xFrac = 0;
2046      refOffset = Clip3(minRelativePos, maxRelativePos, refOffset);
2047#endif
2048      Int absX  = posX + refOffset;
2049
2050      if (xFrac == 0)
2051        absX = Clip3(0, widthLuma-1, absX);
2052      else
2053        absX = Clip3(4, widthLuma-5, absX);
2054
2055      refOffset = absX - posX;
2056
2057      assert( ref[refOffset] >= 0 && ref[refOffset]<= 255 );
2058#if MERL_Bi_VSP_D0166
2059      m_if.filterHorLuma( &ref[refOffset], refStride, &dst[xTxt], dstStride, nTxtPerDepthX, nTxtPerDepthY, xFrac, !bi );
2060#else
2061      m_if.filterHorLuma( &ref[refOffset], refStride, &dst[xTxt], dstStride, nTxtPerDepthX, nTxtPerDepthY, xFrac, true );
2062#endif
2063
2064    }
2065    ref   += refStride*nTxtPerDepthY;
2066    dst   += dstStride*nTxtPerDepthY;
2067    depth += depStride;
2068#if MERL_VSP_BLOCKSIZE_C0152 != 1
2069    yDepth++;
2070#endif
2071
2072  }
2073}
2074
2075Void TComPrediction::xPredInterChromaBlkFromDM ( TComPicYuv *refPic, TComPicYuv *pPicBaseDepth, Int* pShiftLUT, Int iShiftPrec, TComMv*mv, UInt partAddr, Int posX, Int posY, Int sizeX, Int sizeY, Bool isDepth
2076#if !MERL_Bi_VSP_D0166
2077                                               , Int vspIdx
2078#endif
2079                                               , TComYuv *&dstPic
2080#if MERL_Bi_VSP_D0166
2081                                               , Bool bi
2082#endif
2083                                               )
2084{
2085  Int refStride = refPic->getCStride();
2086  Int dstStride = dstPic->getCStride();
2087  Int depStride = pPicBaseDepth->getStride();
2088
2089  Int widthChroma, heightChroma;
2090  if( isDepth)
2091  {
2092     widthChroma   = pPicBaseDepth->getWidth()>>1;
2093     heightChroma  = pPicBaseDepth->getHeight()>>1;
2094  }
2095  else
2096  {
2097     widthChroma   = refPic->getWidth()>>1;
2098     heightChroma  = refPic->getHeight()>>1;
2099  }
2100
2101  // Below is only for Texture chroma component
2102
2103  Int widthDepth  = pPicBaseDepth->getWidth();
2104  Int heightDepth = pPicBaseDepth->getHeight();
2105
2106  Int nTxtPerDepthX, nTxtPerDepthY;  // Number of texture samples per one depth sample
2107  Int nDepthPerTxtX, nDepthPerTxtY;  // Number of depth samples per one texture sample
2108
2109  Int depthPosX;  // Starting position in depth image
2110  Int depthPosY;
2111
2112  if ( widthChroma > widthDepth )
2113  {
2114    nTxtPerDepthX = widthChroma / widthDepth;
2115    nDepthPerTxtX = 1;
2116#if LGE_ROUND_OFFSET_D0135
2117    depthPosX = posX / nTxtPerDepthX + ((mv->getHor()+2)>>2);        //mv denotes the disparity for VSP
2118#else
2119    depthPosX = posX / nTxtPerDepthX + (mv->getHor()>>2);        //mv denotes the disparity for VSP
2120#endif
2121  }
2122  else
2123  {
2124    nTxtPerDepthX = 1;
2125    nDepthPerTxtX = widthDepth / widthChroma;
2126#if LGE_ROUND_OFFSET_D0135
2127    depthPosX = posX * nDepthPerTxtX + ((mv->getHor()+2)>>2);        //mv denotes the disparity for VSP
2128#else
2129    depthPosX = posX * nDepthPerTxtX + (mv->getHor()>>2);        //mv denotes the disparity for VSP
2130#endif
2131  }
2132  depthPosX = Clip3(0, widthDepth - (sizeX<<1), depthPosX);
2133  if ( heightChroma > heightDepth )
2134  {
2135    nTxtPerDepthY = heightChroma / heightDepth;
2136    nDepthPerTxtY = 1;
2137#if LGE_ROUND_OFFSET_D0135
2138    depthPosY = posY / nTxtPerDepthY + ((mv->getVer()+2)>>2);     //mv denotes the disparity for VSP
2139#else
2140    depthPosY = posY / nTxtPerDepthY + (mv->getVer()>>2);     //mv denotes the disparity for VSP
2141#endif
2142  }
2143  else
2144  {
2145    nTxtPerDepthY = 1;
2146    nDepthPerTxtY = heightDepth / heightChroma;
2147#if LGE_ROUND_OFFSET_D0135
2148    depthPosY = posY * nDepthPerTxtY + ((mv->getVer()+2)>>2);     //mv denotes the disparity for VSP
2149#else
2150    depthPosY = posY * nDepthPerTxtY + (mv->getVer()>>2);     //mv denotes the disparity for VSP
2151#endif
2152  }
2153  depthPosY = Clip3(0, heightDepth - (sizeY<<1), depthPosY);
2154
2155  Pel *refCb  = refPic->getCbAddr() + posX + posY * refStride;
2156  Pel *refCr  = refPic->getCrAddr() + posX + posY * refStride;
2157  Pel *dstCb  = dstPic->getCbAddr(partAddr);
2158  Pel *dstCr  = dstPic->getCrAddr(partAddr);
2159  Pel *depth  = pPicBaseDepth->getLumaAddr() + depthPosX + depthPosY * depStride;  // move the pointer to the current depth pixel position
2160 
2161  Int refStrideBlock = refStride * nTxtPerDepthY;
2162  Int dstStrideBlock = dstStride * nTxtPerDepthY;
2163  Int depStrideBlock = depStride * nDepthPerTxtY;
2164
2165#if !MERL_Bi_VSP_D0166
2166  if (isDepth)
2167  {
2168     // DT: Since the call for this function is redundant, ..
2169     for (Int y = 0; y < sizeY; y++)
2170     {
2171       for (Int x = 0; x < sizeX; x++)
2172       {
2173         dstCb[x] = 128;
2174         dstCr[x] = 128;
2175       }
2176       dstCb += dstStride;
2177       dstCr += dstStride;
2178     }
2179     return;
2180  }
2181#endif
2182
2183  if ( widthChroma > widthDepth ) // We assume
2184  {
2185    assert( heightChroma > heightDepth );
2186    printf("This branch should never been reached.\n");
2187    exit(0);
2188  }
2189  else
2190  {
2191#if MERL_VSP_BLOCKSIZE_C0152 == 1
2192  Int  dW = sizeX;
2193  Int  dH = sizeY;
2194  Int  sW = 2; // search window size
2195  Int  sH = 2;
2196#endif
2197#if MERL_VSP_BLOCKSIZE_C0152 == 2
2198  Int  dW = sizeX;
2199  Int  dH = sizeY;
2200  Int  sW = 2; // search window size
2201  Int  sH = 2;
2202#endif
2203#if MERL_VSP_BLOCKSIZE_C0152 == 4
2204  Int  dW = sizeX>>1;
2205  Int  dH = sizeY>>1;
2206  Int  sW = 4; // search window size
2207  Int  sH = 4;
2208#endif
2209
2210  {
2211    Pel* depthi = depth;
2212    for (Int j = 0; j < dH; j++)
2213    {
2214      for (Int i = 0; i < dW; i++)
2215      {
2216        Pel* depthTmp;
2217#if MERL_VSP_BLOCKSIZE_C0152 == 1
2218        depthTmp = depthi + (i << 1);
2219#endif
2220#if MERL_VSP_BLOCKSIZE_C0152 == 2
2221        if (depthPosX + (i<<1) < widthDepth)
2222          depthTmp = depthi + (i << 1);
2223        else
2224          depthTmp = depthi + (widthDepth - depthPosX - 1);
2225#endif
2226#if MERL_VSP_BLOCKSIZE_C0152 == 4
2227        if (depthPosX + (i<<2) < widthDepth)
2228          depthTmp = depthi + (i << 2);
2229        else
2230          depthTmp = depthi + (widthDepth - depthPosX - 1);
2231#endif
2232        Int maxV = 0;
2233#if NCKU_BUG_FIX
2234        for (Int blockj = 0; blockj < sH; blockj+=(sH-1))
2235#else
2236        for (Int blockj = 0; blockj < sH; blockj++)
2237#endif
2238        {
2239          Int iX = 0;
2240#if NCKU_BUG_FIX
2241          for (Int blocki = 0; blocki < sW; blocki+=(sW-1))
2242#else
2243          for (Int blocki = 0; blocki < sW; blocki++)
2244#endif
2245          {
2246            if (maxV < depthTmp[iX])
2247              maxV = depthTmp[iX];
2248            if (depthPosX + i*sW + blocki < widthDepth - 1)
2249#if NCKU_BUG_FIX
2250                iX = (sW-1);
2251#else
2252                iX++;
2253#endif
2254          }
2255          if (depthPosY + j*sH + blockj < heightDepth - 1)
2256#if NCKU_BUG_FIX
2257                depthTmp += depStride * (sH-1);
2258#else
2259                depthTmp += depStride;
2260#endif
2261        }
2262        m_pDepth[i+j*dW] = maxV;
2263      } // end of i < dW
2264#if MERL_VSP_BLOCKSIZE_C0152 == 1
2265      if (depthPosY + ((j+1)<<1) < heightDepth)
2266        depthi += (depStride << 1);
2267      else
2268        depthi  = depth + (heightDepth-1)*depStride;
2269#endif
2270#if MERL_VSP_BLOCKSIZE_C0152 == 2
2271      if (depthPosY + ((j+1)<<1) < heightDepth)
2272        depthi += (depStride << 1);
2273      else
2274        depthi  = depth + (heightDepth-depthPosY-1)*depStride;
2275#endif
2276#if MERL_VSP_BLOCKSIZE_C0152 == 4
2277      if (depthPosY + ((j+1)<<2) < heightDepth) // heightDepth-1
2278        depthi += (depStride << 2);
2279      else
2280        depthi  = depth + (heightDepth-depthPosY-1)*depStride; // the last line
2281#endif
2282    }
2283  }
2284
2285
2286#if MERL_General_Fix
2287#if MERL_VSP_BLOCKSIZE_C0152 == 1
2288#if MERL_CVSP_D0165
2289  //get LUT based horizontal reference range
2290  Int range=0;
2291  if( sizeX == 2 && sizeY == 4 )
2292    range = m_iRangeChroma[0];
2293  else if( sizeX == 4 && sizeY == 2 )
2294    range = m_iRangeChroma[1];
2295  else if( sizeX == 4 && sizeY == 4 )
2296    range = m_iRangeChroma[2];
2297  else if( sizeX == 4 && sizeY == 8 )
2298    range = m_iRangeChroma[3];
2299  else if( sizeX == 8 && sizeY == 4 )
2300    range = m_iRangeChroma[4];
2301  else if( sizeX == 8 && sizeY == 8 )
2302    range = m_iRangeChroma[5];
2303  else if( sizeX == 8 && sizeY == 16 )
2304    range = m_iRangeChroma[6];
2305  else if( sizeX == 16 && sizeY == 8 )
2306    range = m_iRangeChroma[7];
2307  else if( sizeX == 16 && sizeY == 16 )
2308    range = m_iRangeChroma[8];
2309  else if( sizeX == 16 && sizeY == 32 )
2310    range = m_iRangeChroma[9];
2311  else if( sizeX == 32 && sizeY == 16 )
2312    range = m_iRangeChroma[10];
2313  else if( sizeX == 32 && sizeY == 32 )
2314    range = m_iRangeChroma[11];
2315  else
2316    assert(0);
2317 
2318  // The minimum depth value
2319  Int minRelativePos = 5000;
2320  Int maxRelativePos = -5000;
2321
2322  Int depthTmp;
2323  for (Int yTxt=0; yTxt<sizeY; yTxt++)
2324  {
2325    for (Int xTxt=0; xTxt<sizeX; xTxt++)
2326    {
2327      depthTmp = m_pDepth[xTxt+yTxt*dW];
2328      Int disparity = pShiftLUT[ depthTmp ] << iShiftPrec;
2329      Int disparityInt = disparity >> 3;//in chroma resolution
2330
2331      if (disparityInt < 0)
2332      {
2333        if (minRelativePos > disparityInt+xTxt)
2334            minRelativePos = disparityInt+xTxt;
2335      }
2336      else
2337      {
2338        if (maxRelativePos < disparityInt+xTxt)
2339            maxRelativePos = disparityInt+xTxt;
2340      }
2341    }
2342  }
2343
2344  depthTmp = m_pDepth[0];
2345  Int disparity_tmp = pShiftLUT[ depthTmp ] << iShiftPrec;
2346  if ( disparity_tmp < 0 )
2347    maxRelativePos = minRelativePos + range - 1;
2348  else
2349    minRelativePos = maxRelativePos - range + 1;
2350
2351#endif
2352#endif
2353#endif
2354
2355    // (sizeX, sizeY) is Chroma block size
2356    for ( Int yTxt = 0, yDepth = 0; yTxt < sizeY; yTxt += nTxtPerDepthY, yDepth += nDepthPerTxtY )
2357    {
2358      for ( Int xTxt = 0, xDepth = 0; xTxt < sizeX; xTxt += nTxtPerDepthX, xDepth += nDepthPerTxtX )
2359      {
2360        Pel repDepth = 0; // to store the depth value used for warping
2361#if MERL_VSP_BLOCKSIZE_C0152 == 1
2362        repDepth = m_pDepth[(xTxt) + (yTxt)*dW];
2363#endif
2364#if MERL_VSP_BLOCKSIZE_C0152 == 2
2365        repDepth = m_pDepth[(xTxt) + (yTxt)*dW];
2366#endif
2367#if MERL_VSP_BLOCKSIZE_C0152 == 4
2368        repDepth = m_pDepth[(xTxt>>1) + (yTxt>>1)*dW];
2369#endif
2370
2371      // calculate the offset in the reference picture
2372        Int disparity = pShiftLUT[ repDepth ] << iShiftPrec;
2373        Int refOffset = xTxt + (disparity >> 3); // in integer pixel in chroma image
2374        Int xFrac = disparity & 0x7;
2375#if MERL_CVSP_D0165
2376        if(refOffset < minRelativePos || refOffset > maxRelativePos)
2377          xFrac = 0;
2378        refOffset = Clip3(minRelativePos, maxRelativePos, refOffset);
2379#endif
2380        Int absX  = posX + refOffset;
2381
2382        if (xFrac == 0)
2383          absX = Clip3(0, widthChroma-1, absX);
2384        else
2385          absX = Clip3(4, widthChroma-5, absX);
2386
2387        refOffset = absX - posX;
2388
2389        assert( refCb[refOffset] >= 0 && refCb[refOffset]<= 255 );
2390        assert( refCr[refOffset] >= 0 && refCr[refOffset]<= 255 );
2391#if MERL_Bi_VSP_D0166
2392        m_if.filterHorChroma(&refCb[refOffset], refStride, &dstCb[xTxt],  dstStride, nTxtPerDepthX, nTxtPerDepthY, xFrac, !bi);
2393        m_if.filterHorChroma(&refCr[refOffset], refStride, &dstCr[xTxt],  dstStride, nTxtPerDepthX, nTxtPerDepthY, xFrac, !bi);
2394#else
2395        m_if.filterHorChroma(&refCb[refOffset], refStride, &dstCb[xTxt],  dstStride, nTxtPerDepthX, nTxtPerDepthY, xFrac, true);
2396        m_if.filterHorChroma(&refCr[refOffset], refStride, &dstCr[xTxt],  dstStride, nTxtPerDepthX, nTxtPerDepthY, xFrac, true);
2397#endif
2398
2399      }
2400      refCb += refStrideBlock;
2401      refCr += refStrideBlock;
2402      dstCb += dstStrideBlock;
2403      dstCr += dstStrideBlock;
2404      depth += depStrideBlock;
2405    }
2406  }
2407
2408}
2409
2410#endif // MERL_VSP_C0152
2411
2412#if DEPTH_MAP_GENERATION
2413Void TComPrediction::xWeightedAveragePdm( TComDataCU* pcCU, TComYuv* pcYuvSrc0, TComYuv* pcYuvSrc1, Int iRefIdx0, Int iRefIdx1, UInt uiPartIdx, Int iWidth, Int iHeight, TComYuv*& rpcYuvDst, UInt uiSubSampExpX, UInt uiSubSampExpY )
2414{
2415
2416  if( iRefIdx0 >= 0 && iRefIdx1 >= 0 )
2417  {
2418    rpcYuvDst->addAvgPdm( pcYuvSrc0, pcYuvSrc1, uiPartIdx, iWidth, iHeight, uiSubSampExpX, uiSubSampExpY );
2419  }
2420  else if ( iRefIdx0 >= 0 && iRefIdx1 <  0 )
2421  {
2422    pcYuvSrc0->copyPartToPartYuvPdm( rpcYuvDst, uiPartIdx, iWidth, iHeight, uiSubSampExpX, uiSubSampExpY );
2423  }
2424  else if ( iRefIdx0 <  0 && iRefIdx1 >= 0 )
2425  {
2426    pcYuvSrc1->copyPartToPartYuvPdm( rpcYuvDst, uiPartIdx, iWidth, iHeight, uiSubSampExpX, uiSubSampExpY );
2427  }
2428  else
2429  {
2430    assert (0);
2431  }
2432}
2433#endif
2434
2435Void TComPrediction::xWeightedAverage( TComDataCU* pcCU, TComYuv* pcYuvSrc0, TComYuv* pcYuvSrc1, Int iRefIdx0, Int iRefIdx1, UInt uiPartIdx, Int iWidth, Int iHeight, TComYuv*& rpcYuvDst
2436#if MERL_Bi_VSP_D0166
2437                                 , Int predDirVSP
2438#endif
2439  )
2440{
2441#if MERL_Bi_VSP_D0166
2442  Bool isVSP = 0;
2443  if (pcCU->getVSPIndex(uiPartIdx)!=0)//is VSP
2444  {
2445    isVSP = 1;
2446  }
2447
2448  if(( !isVSP && iRefIdx0 >= 0 && iRefIdx1 >= 0 ) || ( isVSP && predDirVSP == 3 ))
2449#else
2450  if( iRefIdx0 >= 0 && iRefIdx1 >= 0 )
2451#endif
2452  {
2453    rpcYuvDst->addAvg( pcYuvSrc0, pcYuvSrc1, uiPartIdx, iWidth, iHeight );
2454  }
2455#if MERL_Bi_VSP_D0166
2456  else if ( ( !isVSP && iRefIdx0 >= 0 && iRefIdx1 <  0 ) || ( isVSP && predDirVSP == 1))
2457#else
2458  else if ( iRefIdx0 >= 0 && iRefIdx1 <  0 )
2459#endif
2460  {
2461    pcYuvSrc0->copyPartToPartYuv( rpcYuvDst, uiPartIdx, iWidth, iHeight );
2462  }
2463#if MERL_Bi_VSP_D0166
2464  else if (( !isVSP && iRefIdx0 <  0 && iRefIdx1 >= 0 ) || ( isVSP && predDirVSP == 2))
2465#else
2466  else if ( iRefIdx0 <  0 && iRefIdx1 >= 0 )
2467#endif
2468  {
2469    pcYuvSrc1->copyPartToPartYuv( rpcYuvDst, uiPartIdx, iWidth, iHeight );
2470  }
2471#if MERL_Bi_VSP_D0166
2472  else
2473  {//for debug test only
2474    assert(0);
2475  }
2476#endif
2477}
2478
2479// AMVP
2480Void TComPrediction::getMvPredAMVP( TComDataCU* pcCU, UInt uiPartIdx, UInt uiPartAddr, RefPicList eRefPicList, Int iRefIdx, TComMv& rcMvPred )
2481{
2482  AMVPInfo* pcAMVPInfo = pcCU->getCUMvField(eRefPicList)->getAMVPInfo();
2483
2484  if( pcCU->getAMVPMode(uiPartAddr) == AM_NONE || (pcAMVPInfo->iN <= 1 && pcCU->getAMVPMode(uiPartAddr) == AM_EXPL) )
2485  {
2486    rcMvPred = pcAMVPInfo->m_acMvCand[0];
2487
2488    pcCU->setMVPIdxSubParts( 0, eRefPicList, uiPartAddr, uiPartIdx, pcCU->getDepth(uiPartAddr));
2489    pcCU->setMVPNumSubParts( pcAMVPInfo->iN, eRefPicList, uiPartAddr, uiPartIdx, pcCU->getDepth(uiPartAddr));
2490    return;
2491  }
2492
2493  assert(pcCU->getMVPIdx(eRefPicList,uiPartAddr) >= 0);
2494  rcMvPred = pcAMVPInfo->m_acMvCand[pcCU->getMVPIdx(eRefPicList,uiPartAddr)];
2495  return;
2496}
2497
2498/** Function for deriving planar intra prediction.
2499 * \param pSrc pointer to reconstructed sample array
2500 * \param srcStride the stride of the reconstructed sample array
2501 * \param rpDst reference to pointer for the prediction sample array
2502 * \param dstStride the stride of the prediction sample array
2503 * \param width the width of the block
2504 * \param height the height of the block
2505 *
2506 * This function derives the prediction samples for planar mode (intra coding).
2507 */
2508Void TComPrediction::xPredIntraPlanar( Int* pSrc, Int srcStride, Pel* rpDst, Int dstStride, UInt width, UInt height )
2509{
2510  assert(width == height);
2511
2512  Int k, l, bottomLeft, topRight;
2513  Int horPred;
2514  Int leftColumn[MAX_CU_SIZE], topRow[MAX_CU_SIZE], bottomRow[MAX_CU_SIZE], rightColumn[MAX_CU_SIZE];
2515  UInt blkSize = width;
2516  UInt offset2D = width;
2517  UInt shift1D = g_aucConvertToBit[ width ] + 2;
2518  UInt shift2D = shift1D + 1;
2519
2520  // Get left and above reference column and row
2521  for(k=0;k<blkSize+1;k++)
2522  {
2523    topRow[k] = pSrc[k-srcStride];
2524    leftColumn[k] = pSrc[k*srcStride-1];
2525  }
2526
2527  // Prepare intermediate variables used in interpolation
2528  bottomLeft = leftColumn[blkSize];
2529  topRight   = topRow[blkSize];
2530  for (k=0;k<blkSize;k++)
2531  {
2532    bottomRow[k]   = bottomLeft - topRow[k];
2533    rightColumn[k] = topRight   - leftColumn[k];
2534    topRow[k]      <<= shift1D;
2535    leftColumn[k]  <<= shift1D;
2536  }
2537
2538  // Generate prediction signal
2539  for (k=0;k<blkSize;k++)
2540  {
2541    horPred = leftColumn[k] + offset2D;
2542    for (l=0;l<blkSize;l++)
2543    {
2544      horPred += rightColumn[k];
2545      topRow[l] += bottomRow[l];
2546      rpDst[k*dstStride+l] = ( (horPred + topRow[l]) >> shift2D );
2547    }
2548  }
2549}
2550
2551/** Function for deriving chroma LM intra prediction.
2552 * \param pcPattern pointer to neighbouring pixel access pattern
2553 * \param piSrc pointer to reconstructed chroma sample array
2554 * \param pPred pointer for the prediction sample array
2555 * \param uiPredStride the stride of the prediction sample array
2556 * \param uiCWidth the width of the chroma block
2557 * \param uiCHeight the height of the chroma block
2558 * \param uiChromaId boolean indication of chroma component
2559 *
2560 * This function derives the prediction samples for chroma LM mode (chroma intra coding)
2561 */
2562Void TComPrediction::predLMIntraChroma( TComPattern* pcPattern, Int* piSrc, Pel* pPred, UInt uiPredStride, UInt uiCWidth, UInt uiCHeight, UInt uiChromaId )
2563{
2564  UInt uiWidth  = 2 * uiCWidth;
2565
2566  xGetLLSPrediction( pcPattern, piSrc+uiWidth+2, uiWidth+1, pPred, uiPredStride, uiCWidth, uiCHeight, 1 ); 
2567}
2568
2569/** Function for deriving downsampled luma sample of current chroma block and its above, left causal pixel
2570 * \param pcPattern pointer to neighbouring pixel access pattern
2571 * \param uiCWidth the width of the chroma block
2572 * \param uiCHeight the height of the chroma block
2573 *
2574 * This function derives downsampled luma sample of current chroma block and its above, left causal pixel
2575 */
2576Void TComPrediction::getLumaRecPixels( TComPattern* pcPattern, UInt uiCWidth, UInt uiCHeight )
2577{
2578  UInt uiWidth  = 2 * uiCWidth;
2579  UInt uiHeight = 2 * uiCHeight; 
2580
2581  Pel* pRecSrc = pcPattern->getROIY();
2582  Pel* pDst0 = m_pLumaRecBuffer + m_iLumaRecStride + 1;
2583
2584  Int iRecSrcStride = pcPattern->getPatternLStride();
2585  Int iRecSrcStride2 = iRecSrcStride << 1;
2586  Int iDstStride = m_iLumaRecStride;
2587  Int iSrcStride = ( max( uiWidth, uiHeight ) << 1 ) + 1;
2588
2589  Int* ptrSrc = pcPattern->getAdiOrgBuf( uiWidth, uiHeight, m_piYuvExt );
2590
2591  // initial pointers
2592  Pel* pDst = pDst0 - 1 - iDstStride; 
2593  Int* piSrc = ptrSrc;
2594
2595  // top left corner downsampled from ADI buffer
2596  // don't need this point
2597
2598  // top row downsampled from ADI buffer
2599  pDst++;     
2600  piSrc ++;
2601  for (Int i = 0; i < uiCWidth; i++)
2602  {
2603    pDst[i] = ((piSrc[2*i] * 2 ) + piSrc[2*i - 1] + piSrc[2*i + 1] + 2) >> 2;
2604  }
2605
2606  // left column downsampled from ADI buffer
2607  pDst = pDst0 - 1; 
2608  piSrc = ptrSrc + iSrcStride;
2609  for (Int j = 0; j < uiCHeight; j++)
2610  {
2611    pDst[0] = ( piSrc[0] + piSrc[iSrcStride] ) >> 1;
2612    piSrc += iSrcStride << 1; 
2613    pDst += iDstStride;   
2614  }
2615
2616  // inner part from reconstructed picture buffer
2617  for( Int j = 0; j < uiCHeight; j++ )
2618  {
2619    for (Int i = 0; i < uiCWidth; i++)
2620    {
2621      pDst0[i] = (pRecSrc[2*i] + pRecSrc[2*i + iRecSrcStride]) >> 1;
2622    }
2623
2624    pDst0 += iDstStride;
2625    pRecSrc += iRecSrcStride2;
2626  }
2627}
2628
2629/** Function for deriving the positon of first non-zero binary bit of a value
2630 * \param x input value
2631 *
2632 * This function derives the positon of first non-zero binary bit of a value
2633 */
2634Int GetMSB( UInt x )
2635{
2636  Int iMSB = 0, bits = ( sizeof( Int ) << 3 ), y = 1;
2637
2638  while( x > 1 )
2639  {
2640    bits >>= 1;
2641    y = x >> bits;
2642
2643    if( y )
2644    {
2645      x = y;
2646      iMSB += bits;
2647    }
2648  }
2649
2650  iMSB+=y;
2651
2652  return iMSB;
2653}
2654
2655/** Function for counting leading number of zeros/ones
2656 * \param x input value
2657 \ This function counts leading number of zeros for positive numbers and
2658 \ leading number of ones for negative numbers. This can be implemented in
2659 \ single instructure cycle on many processors.
2660 */
2661
2662Short CountLeadingZerosOnes (Short x)
2663{
2664  Short clz;
2665  Short i;
2666
2667  if(x == 0)
2668  {
2669    clz = 0;
2670  }
2671  else
2672  {
2673    if (x == -1)
2674    {
2675      clz = 15;
2676    }
2677    else
2678    {
2679      if(x < 0)
2680      {
2681        x = ~x;
2682      }
2683      clz = 15;
2684      for(i = 0;i < 15;++i)
2685      {
2686        if(x) 
2687        {
2688          clz --;
2689        }
2690        x = x >> 1;
2691      }
2692    }
2693  }
2694  return clz;
2695}
2696
2697/** Function for deriving LM intra prediction.
2698 * \param pcPattern pointer to neighbouring pixel access pattern
2699 * \param pSrc0 pointer to reconstructed chroma sample array
2700 * \param iSrcStride the stride of reconstructed chroma sample array
2701 * \param pDst0 reference to pointer for the prediction sample array
2702 * \param iDstStride the stride of the prediction sample array
2703 * \param uiWidth the width of the chroma block
2704 * \param uiHeight the height of the chroma block
2705 * \param uiExt0 line number of neiggboirng pixels for calculating LM model parameter, default value is 1
2706 *
2707 * This function derives the prediction samples for chroma LM mode (chroma intra coding)
2708 */
2709Void TComPrediction::xGetLLSPrediction( TComPattern* pcPattern, Int* pSrc0, Int iSrcStride, Pel* pDst0, Int iDstStride, UInt uiWidth, UInt uiHeight, UInt uiExt0 )
2710{
2711
2712  Pel  *pDst, *pLuma;
2713  Int  *pSrc;
2714
2715  Int  iLumaStride = m_iLumaRecStride;
2716  Pel* pLuma0 = m_pLumaRecBuffer + uiExt0 * iLumaStride + uiExt0;
2717
2718  Int i, j, iCountShift = 0;
2719
2720  UInt uiExt = uiExt0;
2721
2722  // LLS parameters estimation -->
2723
2724  Int x = 0, y = 0, xx = 0, xy = 0;
2725
2726  pSrc  = pSrc0  - iSrcStride;
2727  pLuma = pLuma0 - iLumaStride;
2728
2729  for( j = 0; j < uiWidth; j++ )
2730  {
2731    x += pLuma[j];
2732    y += pSrc[j];
2733    xx += pLuma[j] * pLuma[j];
2734    xy += pLuma[j] * pSrc[j];
2735  }
2736  iCountShift += g_aucConvertToBit[ uiWidth ] + 2;
2737
2738  pSrc  = pSrc0 - uiExt;
2739  pLuma = pLuma0 - uiExt;
2740
2741  for( i = 0; i < uiHeight; i++ )
2742  {
2743    x += pLuma[0];
2744    y += pSrc[0];
2745    xx += pLuma[0] * pLuma[0];
2746    xy += pLuma[0] * pSrc[0];
2747
2748    pSrc  += iSrcStride;
2749    pLuma += iLumaStride;
2750  }
2751  iCountShift += iCountShift > 0 ? 1 : ( g_aucConvertToBit[ uiWidth ] + 2 );
2752
2753  Int iTempShift = ( g_uiBitDepth + g_uiBitIncrement ) + g_aucConvertToBit[ uiWidth ] + 3 - 15;
2754
2755  if(iTempShift > 0)
2756  {
2757    x  = ( x +  ( 1 << ( iTempShift - 1 ) ) ) >> iTempShift;
2758    y  = ( y +  ( 1 << ( iTempShift - 1 ) ) ) >> iTempShift;
2759    xx = ( xx + ( 1 << ( iTempShift - 1 ) ) ) >> iTempShift;
2760    xy = ( xy + ( 1 << ( iTempShift - 1 ) ) ) >> iTempShift;
2761    iCountShift -= iTempShift;
2762  }
2763
2764  Int a, b, iShift = 13;
2765
2766  if( iCountShift == 0 )
2767  {
2768    a = 0;
2769    b = 1 << (g_uiBitDepth + g_uiBitIncrement - 1);
2770    iShift = 0;
2771  }
2772  else
2773  {
2774    Int a1 = ( xy << iCountShift ) - y * x;
2775    Int a2 = ( xx << iCountShift ) - x * x;             
2776
2777    {
2778      const Int iShiftA2 = 6;
2779      const Int iShiftA1 = 15;
2780      const Int iAccuracyShift = 15;
2781
2782      Int iScaleShiftA2 = 0;
2783      Int iScaleShiftA1 = 0;
2784      Int a1s = a1;
2785      Int a2s = a2;
2786
2787      iScaleShiftA1 = GetMSB( abs( a1 ) ) - iShiftA1;
2788      iScaleShiftA2 = GetMSB( abs( a2 ) ) - iShiftA2; 
2789
2790      if( iScaleShiftA1 < 0 )
2791      {
2792        iScaleShiftA1 = 0;
2793      }
2794     
2795      if( iScaleShiftA2 < 0 )
2796      {
2797        iScaleShiftA2 = 0;
2798      }
2799     
2800      Int iScaleShiftA = iScaleShiftA2 + iAccuracyShift - iShift - iScaleShiftA1;
2801
2802      a2s = a2 >> iScaleShiftA2;
2803
2804      a1s = a1 >> iScaleShiftA1;
2805
2806      if (a2s >= 1)
2807      {
2808        a = a1s * m_uiaShift[ a2s - 1];
2809      }
2810      else
2811      {
2812        a = 0;
2813      }
2814     
2815      if( iScaleShiftA < 0 )
2816      {
2817        a = a << -iScaleShiftA;
2818      }
2819      else
2820      {
2821        a = a >> iScaleShiftA;
2822      }
2823     
2824       a = Clip3(-( 1 << 15 ), ( 1 << 15 ) - 1, a); 
2825     
2826      Int minA = -(1 << (6));
2827      Int maxA = (1 << 6) - 1;
2828      if( a <= maxA && a >= minA )
2829      {
2830        // do nothing
2831      }
2832      else
2833      {
2834        Short n = CountLeadingZerosOnes(a);
2835        a = a >> (9-n);
2836        iShift -= (9-n);
2837      }
2838
2839      b = (  y - ( ( a * x ) >> iShift ) + ( 1 << ( iCountShift - 1 ) ) ) >> iCountShift;
2840    }
2841  }   
2842
2843  // <-- end of LLS parameters estimation
2844
2845  // get prediction -->
2846  uiExt = uiExt0;
2847  pLuma = pLuma0;
2848  pDst = pDst0;
2849
2850  for( i = 0; i < uiHeight; i++ )
2851  {
2852    for( j = 0; j < uiWidth; j++ )
2853    {
2854      pDst[j] = Clip( ( ( a * pLuma[j] ) >> iShift ) + b );
2855    }
2856   
2857    pDst  += iDstStride;
2858    pLuma += iLumaStride;
2859  }
2860  // <-- end of get prediction
2861
2862}
2863
2864
2865#if LGE_ILLUCOMP_B0045
2866/** Function for deriving LM illumination compensation.
2867 */
2868Void TComPrediction::xGetLLSICPrediction(TComDataCU* pcCU, TComMv *pMv, TComPicYuv *pRefPic, Int &a, Int &b, Int &iShift)
2869{
2870  TComPicYuv *pRecPic = pcCU->getPic()->getPicYuvRec();
2871  Pel *pRec, *pRef;
2872  UInt uiWidth, uiHeight, uiTmpPartIdx;
2873  Int iRecStride = pRecPic->getStride(), iRefStride = pRefPic->getStride();
2874  Int iCUPelX, iCUPelY, iRefX, iRefY, iRefOffset;
2875
2876  iCUPelX = pcCU->getCUPelX() + g_auiRasterToPelX[g_auiZscanToRaster[pcCU->getZorderIdxInCU()]];
2877  iCUPelY = pcCU->getCUPelY() + g_auiRasterToPelY[g_auiZscanToRaster[pcCU->getZorderIdxInCU()]];
2878#if LGE_ROUND_OFFSET_D0135
2879  iRefX   = iCUPelX + ((pMv->getHor()+2) >> 2);
2880  iRefY   = iCUPelY + ((pMv->getVer()+2) >> 2);
2881#else
2882  iRefX   = iCUPelX + (pMv->getHor() >> 2);
2883  iRefY   = iCUPelY + (pMv->getVer() >> 2);
2884#endif
2885  uiWidth = pcCU->getWidth(0);
2886  uiHeight = pcCU->getHeight(0);
2887
2888  Int i, j, iCountShift = 0;
2889
2890  // LLS parameters estimation -->
2891
2892  Int x = 0, y = 0, xx = 0, xy = 0;
2893
2894  if(pcCU->getPUAbove(uiTmpPartIdx, pcCU->getZorderIdxInCU()) && iCUPelY > 0 && iRefY > 0)
2895  {
2896#if LGE_ROUND_OFFSET_D0135
2897    iRefOffset = ( (pMv->getHor()+2) >> 2 ) + ( (pMv->getVer()+2) >> 2 ) * iRefStride - iRefStride;
2898#else
2899    iRefOffset = ( pMv->getHor() >> 2 ) + ( pMv->getVer() >> 2 ) * iRefStride - iRefStride;
2900#endif
2901    pRef = pRefPic->getLumaAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() ) + iRefOffset;
2902    pRec = pRecPic->getLumaAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() ) - iRecStride;
2903
2904    for( j = 0; j < uiWidth; j++ )
2905    {
2906      x += pRef[j];
2907      y += pRec[j];
2908      xx += pRef[j] * pRef[j];
2909      xy += pRef[j] * pRec[j];
2910    }
2911    iCountShift += g_aucConvertToBit[ uiWidth ] + 2;
2912  }
2913
2914
2915  if(pcCU->getPULeft(uiTmpPartIdx, pcCU->getZorderIdxInCU()) && iCUPelX > 0 && iRefX > 0)
2916  {
2917#if LGE_ROUND_OFFSET_D0135
2918    iRefOffset = ( (pMv->getHor()+2) >> 2 ) + ( (pMv->getVer()+2) >> 2 ) * iRefStride - 1;
2919#else
2920    iRefOffset = ( pMv->getHor() >> 2 ) + ( pMv->getVer() >> 2 ) * iRefStride - 1;
2921#endif
2922    pRef = pRefPic->getLumaAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() ) + iRefOffset;
2923    pRec = pRecPic->getLumaAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() ) - 1;
2924
2925    for( i = 0; i < uiHeight; i++ )
2926    {
2927      x += pRef[0];
2928      y += pRec[0];
2929      xx += pRef[0] * pRef[0];
2930      xy += pRef[0] * pRec[0];
2931
2932      pRef += iRefStride;
2933      pRec += iRecStride;
2934    }
2935    iCountShift += iCountShift > 0 ? 1 : ( g_aucConvertToBit[ uiWidth ] + 2 );
2936  }
2937
2938  Int iTempShift = ( g_uiBitDepth + g_uiBitIncrement ) + g_aucConvertToBit[ uiWidth ] + 3 - 15;
2939
2940  if(iTempShift > 0)
2941  {
2942    x  = ( x +  ( 1 << ( iTempShift - 1 ) ) ) >> iTempShift;
2943    y  = ( y +  ( 1 << ( iTempShift - 1 ) ) ) >> iTempShift;
2944    xx = ( xx + ( 1 << ( iTempShift - 1 ) ) ) >> iTempShift;
2945    xy = ( xy + ( 1 << ( iTempShift - 1 ) ) ) >> iTempShift;
2946    iCountShift -= iTempShift;
2947  }
2948
2949  iShift = 13;
2950
2951  if( iCountShift == 0 )
2952  {
2953    a = 1;
2954    b = 0;
2955    iShift = 0;
2956  }
2957  else
2958  {
2959    Int a1 = ( xy << iCountShift ) - y * x;
2960    Int a2 = ( xx << iCountShift ) - x * x;             
2961
2962    {
2963      const Int iShiftA2 = 6;
2964      const Int iShiftA1 = 15;
2965      const Int iAccuracyShift = 15;
2966
2967      Int iScaleShiftA2 = 0;
2968      Int iScaleShiftA1 = 0;
2969      Int a1s = a1;
2970      Int a2s = a2;
2971
2972      iScaleShiftA1 = GetMSB( abs( a1 ) ) - iShiftA1;
2973      iScaleShiftA2 = GetMSB( abs( a2 ) ) - iShiftA2; 
2974
2975      if( iScaleShiftA1 < 0 )
2976      {
2977        iScaleShiftA1 = 0;
2978      }
2979
2980      if( iScaleShiftA2 < 0 )
2981      {
2982        iScaleShiftA2 = 0;
2983      }
2984
2985      Int iScaleShiftA = iScaleShiftA2 + iAccuracyShift - iShift - iScaleShiftA1;
2986
2987      a2s = a2 >> iScaleShiftA2;
2988
2989      a1s = a1 >> iScaleShiftA1;
2990
2991      if (a2s >= 1)
2992      {
2993        a = a1s * m_uiaShift[ a2s - 1];
2994      }
2995      else
2996      {
2997        a = 0;
2998      }
2999
3000      if( iScaleShiftA < 0 )
3001      {
3002        a = a << -iScaleShiftA;
3003      }
3004      else
3005      {
3006        a = a >> iScaleShiftA;
3007      }
3008
3009      a = Clip3(-( 1 << 15 ), ( 1 << 15 ) - 1, a); 
3010
3011      Int minA = -(1 << (6));
3012      Int maxA = (1 << 6) - 1;
3013      if( a <= maxA && a >= minA )
3014      {
3015        // do nothing
3016      }
3017      else
3018      {
3019        Short n = CountLeadingZerosOnes(a);
3020        a = a >> (9-n);
3021        iShift -= (9-n);
3022      }
3023
3024      b = (  y - ( ( a * x ) >> iShift ) + ( 1 << ( iCountShift - 1 ) ) ) >> iCountShift;
3025    }
3026  }   
3027}
3028
3029Void TComPrediction::xGetLLSICPredictionChroma(TComDataCU* pcCU, TComMv *pMv, TComPicYuv *pRefPic, Int &a, Int &b, Int &iShift, Int iChromaId)
3030{
3031  TComPicYuv *pRecPic = pcCU->getPic()->getPicYuvRec();
3032  Pel *pRec = NULL, *pRef = NULL;
3033  UInt uiWidth, uiHeight, uiTmpPartIdx;
3034  Int iRecStride = pRecPic->getCStride(), iRefStride = pRefPic->getCStride();
3035  Int iCUPelX, iCUPelY, iRefX, iRefY, iRefOffset;
3036
3037  iCUPelX = pcCU->getCUPelX() + g_auiRasterToPelX[g_auiZscanToRaster[pcCU->getZorderIdxInCU()]];
3038  iCUPelY = pcCU->getCUPelY() + g_auiRasterToPelY[g_auiZscanToRaster[pcCU->getZorderIdxInCU()]];
3039#if LGE_ROUND_OFFSET_D0135
3040  iRefX   = iCUPelX + ((pMv->getHor()+2) >> 2);
3041  iRefY   = iCUPelY + ((pMv->getVer()+2) >> 2);
3042#else
3043  iRefX   = iCUPelX + (pMv->getHor() >> 2);
3044  iRefY   = iCUPelY + (pMv->getVer() >> 2);
3045#endif
3046  uiWidth = pcCU->getWidth(0) >> 1;
3047  uiHeight = pcCU->getHeight(0) >> 1;
3048
3049  Int i, j, iCountShift = 0;
3050
3051  // LLS parameters estimation -->
3052
3053  Int x = 0, y = 0, xx = 0, xy = 0;
3054
3055  if(pcCU->getPUAbove(uiTmpPartIdx, pcCU->getZorderIdxInCU()) && iCUPelY > 0 && iRefY > 0)
3056  {
3057#if LGE_ROUND_OFFSET_D0135
3058    iRefOffset = ( (pMv->getHor()+4) >> 3 ) + ( (pMv->getVer()+4) >> 3 ) * iRefStride - iRefStride;
3059#else
3060    iRefOffset = ( pMv->getHor() >> 3 ) + ( pMv->getVer() >> 3 ) * iRefStride - iRefStride;
3061#endif
3062    if (iChromaId == 0) // Cb
3063    {
3064      pRef = pRefPic->getCbAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() ) + iRefOffset;
3065      pRec = pRecPic->getCbAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() ) - iRecStride;
3066    }
3067    else if (iChromaId == 1) // Cr
3068    {
3069      pRef = pRefPic->getCrAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() ) + iRefOffset;
3070      pRec = pRecPic->getCrAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() ) - iRecStride;
3071    }
3072
3073    for( j = 0; j < uiWidth; j++ )
3074    {
3075      x += pRef[j];
3076      y += pRec[j];
3077      xx += pRef[j] * pRef[j];
3078      xy += pRef[j] * pRec[j];
3079    }
3080    iCountShift += g_aucConvertToBit[ uiWidth ] + 2;
3081  }
3082
3083
3084  if(pcCU->getPULeft(uiTmpPartIdx, pcCU->getZorderIdxInCU()) && iCUPelX > 0 && iRefX > 0)
3085  {
3086#if LGE_ROUND_OFFSET_D0135
3087    iRefOffset = ( (pMv->getHor()+4) >> 3 ) + ( (pMv->getVer()+4) >> 3 ) * iRefStride - 1;
3088#else
3089    iRefOffset = ( pMv->getHor() >> 3 ) + ( pMv->getVer() >> 3 ) * iRefStride - 1;
3090#endif
3091    if (iChromaId == 0) // Cb
3092    {
3093      pRef = pRefPic->getCbAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() ) + iRefOffset;
3094      pRec = pRecPic->getCbAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() ) - 1;
3095    }
3096    else if (iChromaId == 1) // Cr
3097    {
3098      pRef = pRefPic->getCrAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() ) + iRefOffset;
3099      pRec = pRecPic->getCrAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() ) - 1;
3100    }
3101
3102    for( i = 0; i < uiHeight; i++ )
3103    {
3104      x += pRef[0];
3105      y += pRec[0];
3106      xx += pRef[0] * pRef[0];
3107      xy += pRef[0] * pRec[0];
3108
3109      pRef += iRefStride;
3110      pRec += iRecStride;
3111    }
3112    iCountShift += iCountShift > 0 ? 1 : ( g_aucConvertToBit[ uiWidth ] + 2 );
3113  }
3114
3115  Int iTempShift = ( g_uiBitDepth + g_uiBitIncrement ) + g_aucConvertToBit[ uiWidth ] + 3 - 15;
3116
3117  if(iTempShift > 0)
3118  {
3119    x  = ( x +  ( 1 << ( iTempShift - 1 ) ) ) >> iTempShift;
3120    y  = ( y +  ( 1 << ( iTempShift - 1 ) ) ) >> iTempShift;
3121    xx = ( xx + ( 1 << ( iTempShift - 1 ) ) ) >> iTempShift;
3122    xy = ( xy + ( 1 << ( iTempShift - 1 ) ) ) >> iTempShift;
3123    iCountShift -= iTempShift;
3124  }
3125
3126  iShift = 13;
3127
3128  if( iCountShift == 0 )
3129  {
3130    a = 1;
3131    b = 0;
3132    iShift = 0;
3133  }
3134  else
3135  {
3136    Int a1 = ( xy << iCountShift ) - y * x;
3137    Int a2 = ( xx << iCountShift ) - x * x;             
3138
3139    {
3140      const Int iShiftA2 = 6;
3141      const Int iShiftA1 = 15;
3142      const Int iAccuracyShift = 15;
3143
3144      Int iScaleShiftA2 = 0;
3145      Int iScaleShiftA1 = 0;
3146      Int a1s = a1;
3147      Int a2s = a2;
3148
3149      iScaleShiftA1 = GetMSB( abs( a1 ) ) - iShiftA1;
3150      iScaleShiftA2 = GetMSB( abs( a2 ) ) - iShiftA2; 
3151
3152      if( iScaleShiftA1 < 0 )
3153      {
3154        iScaleShiftA1 = 0;
3155      }
3156
3157      if( iScaleShiftA2 < 0 )
3158      {
3159        iScaleShiftA2 = 0;
3160      }
3161
3162      Int iScaleShiftA = iScaleShiftA2 + iAccuracyShift - iShift - iScaleShiftA1;
3163
3164      a2s = a2 >> iScaleShiftA2;
3165
3166      a1s = a1 >> iScaleShiftA1;
3167
3168      if (a2s >= 1)
3169      {
3170        a = a1s * m_uiaShift[ a2s - 1];
3171      }
3172      else
3173      {
3174        a = 0;
3175      }
3176
3177      if( iScaleShiftA < 0 )
3178      {
3179        a = a << -iScaleShiftA;
3180      }
3181      else
3182      {
3183        a = a >> iScaleShiftA;
3184      }
3185
3186      a = Clip3(-( 1 << 15 ), ( 1 << 15 ) - 1, a); 
3187
3188      Int minA = -(1 << (6));
3189      Int maxA = (1 << 6) - 1;
3190      if( a <= maxA && a >= minA )
3191      {
3192        // do nothing
3193      }
3194      else
3195      {
3196        Short n = CountLeadingZerosOnes(a);
3197        a = a >> (9-n);
3198        iShift -= (9-n);
3199      }
3200
3201      b = (  y - ( ( a * x ) >> iShift ) + ( 1 << ( iCountShift - 1 ) ) ) >> iCountShift;
3202    }
3203  }   
3204}
3205#endif
3206/** Function for filtering intra DC predictor.
3207 * \param pSrc pointer to reconstructed sample array
3208 * \param iSrcStride the stride of the reconstructed sample array
3209 * \param rpDst reference to pointer for the prediction sample array
3210 * \param iDstStride the stride of the prediction sample array
3211 * \param iWidth the width of the block
3212 * \param iHeight the height of the block
3213 *
3214 * This function performs filtering left and top edges of the prediction samples for DC mode (intra coding).
3215 */
3216Void TComPrediction::xDCPredFiltering( Int* pSrc, Int iSrcStride, Pel*& rpDst, Int iDstStride, Int iWidth, Int iHeight )
3217{
3218  Pel* pDst = rpDst;
3219  Int x, y, iDstStride2, iSrcStride2;
3220
3221  // boundary pixels processing
3222  pDst[0] = (Pel)((pSrc[-iSrcStride] + pSrc[-1] + 2 * pDst[0] + 2) >> 2);
3223
3224  for ( x = 1; x < iWidth; x++ )
3225  {
3226    pDst[x] = (Pel)((pSrc[x - iSrcStride] +  3 * pDst[x] + 2) >> 2);
3227  }
3228
3229  for ( y = 1, iDstStride2 = iDstStride, iSrcStride2 = iSrcStride-1; y < iHeight; y++, iDstStride2+=iDstStride, iSrcStride2+=iSrcStride )
3230  {
3231    pDst[iDstStride2] = (Pel)((pSrc[iSrcStride2] + 3 * pDst[iDstStride2] + 2) >> 2);
3232  }
3233
3234  return;
3235}
3236
3237#if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
3238Void TComPrediction::predIntraLumaDMM( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiMode, Pel* piPred, UInt uiStride, Int iWidth, Int iHeight, Bool bAbove, Bool bLeft, Bool bEncoder )
3239{
3240#if HHI_DMM_WEDGE_INTRA
3241  if( uiMode == DMM_WEDGE_FULL_IDX        ) { xPredIntraWedgeFull ( pcCU, uiAbsPartIdx, piPred, uiStride, iWidth, iHeight, bAbove, bLeft, bEncoder, false, pcCU->getWedgeFullTabIdx ( uiAbsPartIdx ) ); }
3242  if( uiMode == DMM_WEDGE_FULL_D_IDX      ) { xPredIntraWedgeFull ( pcCU, uiAbsPartIdx, piPred, uiStride, iWidth, iHeight, bAbove, bLeft, bEncoder, true,  pcCU->getWedgeFullTabIdx( uiAbsPartIdx ), pcCU->getWedgeFullDeltaDC1( uiAbsPartIdx ), pcCU->getWedgeFullDeltaDC2( uiAbsPartIdx ) ); }
3243  if( uiMode == DMM_WEDGE_PREDDIR_IDX     ) { xPredIntraWedgeDir  ( pcCU, uiAbsPartIdx, piPred, uiStride, iWidth, iHeight, bAbove, bLeft, bEncoder, false, pcCU->getWedgePredDirDeltaEnd( uiAbsPartIdx ) ); }
3244  if( uiMode == DMM_WEDGE_PREDDIR_D_IDX   ) { xPredIntraWedgeDir  ( pcCU, uiAbsPartIdx, piPred, uiStride, iWidth, iHeight, bAbove, bLeft, bEncoder, true,  pcCU->getWedgePredDirDeltaEnd( uiAbsPartIdx ), pcCU->getWedgePredDirDeltaDC1( uiAbsPartIdx ), pcCU->getWedgePredDirDeltaDC2( uiAbsPartIdx ) ); }
3245#endif
3246#if HHI_DMM_PRED_TEX
3247  if( uiMode == DMM_WEDGE_PREDTEX_IDX     ) { xPredIntraWedgeTex  ( pcCU, uiAbsPartIdx, piPred, uiStride, iWidth, iHeight, bAbove, bLeft, bEncoder, false ); }
3248  if( uiMode == DMM_WEDGE_PREDTEX_D_IDX   ) { xPredIntraWedgeTex  ( pcCU, uiAbsPartIdx, piPred, uiStride, iWidth, iHeight, bAbove, bLeft, bEncoder, true, pcCU->getWedgePredTexDeltaDC1( uiAbsPartIdx ), pcCU->getWedgePredTexDeltaDC2( uiAbsPartIdx ) ); }
3249  if( uiMode == DMM_CONTOUR_PREDTEX_IDX   ) { xPredIntraContourTex( pcCU, uiAbsPartIdx, piPred, uiStride, iWidth, iHeight, bAbove, bLeft, bEncoder, false ); }
3250  if( uiMode == DMM_CONTOUR_PREDTEX_D_IDX ) { xPredIntraContourTex( pcCU, uiAbsPartIdx, piPred, uiStride, iWidth, iHeight, bAbove, bLeft, bEncoder, true, pcCU->getContourPredTexDeltaDC1( uiAbsPartIdx ), pcCU->getContourPredTexDeltaDC2( uiAbsPartIdx ) ); }
3251#endif
3252}
3253
3254#if QC_DC_PREDICTOR_D0183
3255Void TComPrediction::getPredDCs( Bool* pbPattern, Int iStride, Int* piMask, Int iMaskStride, Int& riPredDC1, Int& riPredDC2 )
3256{
3257  Int  iDC1, iDC2;
3258  const Int  iTR = (   iStride - 1        ) - iMaskStride;
3259  const Int  iTM = ( ( iStride - 1 ) >> 1 ) - iMaskStride;
3260  const Int  iLB = (   iStride - 1        ) * iMaskStride - 1;
3261  const Int  iLM = ( ( iStride - 1 ) >> 1 ) * iMaskStride - 1;
3262  const UInt uiBitDepth = g_uiBitDepth + g_uiBitIncrement;
3263
3264  Bool bL = ( pbPattern[0] != pbPattern[(iStride-1)*iStride] );
3265  Bool bT = ( pbPattern[0] != pbPattern[(iStride-1)]         );
3266
3267  if( bL == bT )
3268  {
3269    iDC1 = bL ? ( piMask[iTR] + piMask[iLB] )>>1 : 1<<( uiBitDepth - 1 );
3270    iDC2 =      ( piMask[ -1] + piMask[-iMaskStride] )>>1;
3271  }
3272  else
3273  {
3274    iDC1 = bL ? piMask[iLB] : piMask[iTR];
3275    iDC2 = bL ? piMask[iTM] : piMask[iLM];
3276  }
3277
3278  riPredDC1 = pbPattern[0] ? iDC1 : iDC2;
3279  riPredDC2 = pbPattern[0] ? iDC2 : iDC1;
3280}
3281#else
3282Void TComPrediction::getWedgePredDCs( TComWedgelet* pcWedgelet, Int* piMask, Int iMaskStride, Int& riPredDC1, Int& riPredDC2, Bool bAbove, Bool bLeft )
3283{
3284  riPredDC1 = ( 1<<( g_uiBitDepth + g_uiBitIncrement - 1) ); //pred val, if no neighbors are available
3285  riPredDC2 = ( 1<<( g_uiBitDepth + g_uiBitIncrement - 1) );
3286
3287  if( !bAbove && !bLeft ) { return; }
3288
3289  UInt uiNumSmpDC1 = 0, uiNumSmpDC2 = 0;
3290  Int iPredDC1 = 0, iPredDC2 = 0;
3291
3292  Bool* pabWedgePattern = pcWedgelet->getPattern();
3293  UInt  uiWedgeStride   = pcWedgelet->getStride();
3294
3295#if HS_REFERENCE_SUBSAMPLE_C0154
3296  Int subSamplePix;
3297  if ( pcWedgelet->getWidth() == 32 )
3298  {
3299    subSamplePix = 2;
3300  }
3301  else
3302  {
3303    subSamplePix = 1;
3304  }
3305#endif
3306
3307  if( bAbove )
3308  {
3309#if HS_REFERENCE_SUBSAMPLE_C0154
3310    for( Int k = 0; k < pcWedgelet->getWidth(); k+=subSamplePix )
3311#else
3312    for( Int k = 0; k < pcWedgelet->getWidth(); k++ )
3313#endif
3314    {
3315      if( true == pabWedgePattern[k] )
3316      {
3317        iPredDC2 += piMask[k-iMaskStride];
3318        uiNumSmpDC2++;
3319      }
3320      else
3321      {
3322        iPredDC1 += piMask[k-iMaskStride];
3323        uiNumSmpDC1++;
3324      }
3325    }
3326  }
3327  if( bLeft )
3328  {
3329#if HS_REFERENCE_SUBSAMPLE_C0154
3330    for( Int k = 0; k < pcWedgelet->getHeight(); k+=subSamplePix )
3331#else
3332    for( Int k = 0; k < pcWedgelet->getHeight(); k++ )
3333#endif
3334    {
3335      if( true == pabWedgePattern[k*uiWedgeStride] )
3336      {
3337        iPredDC2 += piMask[k*iMaskStride-1];
3338        uiNumSmpDC2++;
3339      } 
3340      else
3341      {
3342        iPredDC1 += piMask[k*iMaskStride-1];
3343        uiNumSmpDC1++;
3344      }
3345    }
3346  }
3347
3348  if( uiNumSmpDC1 > 0 )
3349  {
3350    iPredDC1 /= uiNumSmpDC1;
3351    riPredDC1 = iPredDC1;
3352  }
3353  if( uiNumSmpDC2 > 0 )
3354  {
3355    iPredDC2 /= uiNumSmpDC2;
3356    riPredDC2 = iPredDC2;
3357  }
3358}
3359#endif
3360
3361Void TComPrediction::calcWedgeDCs( TComWedgelet* pcWedgelet, Pel* piOrig, UInt uiStride, Int& riDC1, Int& riDC2 )
3362{
3363  UInt uiDC1 = 0;
3364  UInt uiDC2 = 0;
3365  UInt uiNumPixDC1 = 0, uiNumPixDC2 = 0;
3366  Bool* pabWedgePattern = pcWedgelet->getPattern();
3367  if( uiStride == pcWedgelet->getStride() )
3368  {
3369    for( UInt k = 0; k < (pcWedgelet->getWidth() * pcWedgelet->getHeight()); k++ )
3370    {
3371      if( true == pabWedgePattern[k] ) 
3372      {
3373        uiDC2 += piOrig[k];
3374        uiNumPixDC2++;
3375      }
3376      else
3377      {
3378        uiDC1 += piOrig[k];
3379        uiNumPixDC1++;
3380      }
3381    }
3382  }
3383  else
3384  {
3385    Pel* piTemp = piOrig;
3386    UInt uiWedgeStride = pcWedgelet->getStride();
3387    for( UInt uiY = 0; uiY < pcWedgelet->getHeight(); uiY++ )
3388    {
3389      for( UInt uiX = 0; uiX < pcWedgelet->getWidth(); uiX++ )
3390      {
3391        if( true == pabWedgePattern[uiX] ) 
3392        {
3393          uiDC2 += piTemp[uiX];
3394          uiNumPixDC2++;
3395        }
3396        else
3397        {
3398          uiDC1 += piTemp[uiX];
3399          uiNumPixDC1++;
3400        }
3401      }
3402      piTemp          += uiStride;
3403      pabWedgePattern += uiWedgeStride;
3404    }
3405  }
3406
3407  if( uiNumPixDC1 > 0 ) { riDC1 = uiDC1 / uiNumPixDC1; }
3408  else                  { riDC1 = ( 1<<( g_uiBitDepth + g_uiBitIncrement - 1) ); }
3409
3410  if( uiNumPixDC2 > 0 ) { riDC2 = uiDC2 / uiNumPixDC2; }
3411  else                  { riDC2 = ( 1<<( g_uiBitDepth + g_uiBitIncrement - 1) ); }
3412}
3413
3414Void TComPrediction::assignWedgeDCs2Pred( TComWedgelet* pcWedgelet, Pel* piPred, UInt uiStride, Int iDC1, Int iDC2 )
3415{
3416  Bool* pabWedgePattern = pcWedgelet->getPattern();
3417
3418  if( uiStride == pcWedgelet->getStride() )
3419  {
3420    for( UInt k = 0; k < (pcWedgelet->getWidth() * pcWedgelet->getHeight()); k++ )
3421    {
3422      if( true == pabWedgePattern[k] ) 
3423      {
3424        piPred[k] = iDC2;
3425      }
3426      else
3427      {
3428        piPred[k] = iDC1;
3429      }
3430    }
3431  }
3432  else
3433  {
3434    Pel* piTemp = piPred;
3435    UInt uiWedgeStride = pcWedgelet->getStride();
3436    for( UInt uiY = 0; uiY < pcWedgelet->getHeight(); uiY++ )
3437    {
3438      for( UInt uiX = 0; uiX < pcWedgelet->getWidth(); uiX++ )
3439      {
3440        if( true == pabWedgePattern[uiX] ) 
3441        {
3442          piTemp[uiX] = iDC2;
3443        }
3444        else
3445        {
3446          piTemp[uiX] = iDC1;
3447        }
3448      }
3449      piTemp          += uiStride;
3450      pabWedgePattern += uiWedgeStride;
3451    }
3452  }
3453}
3454
3455Void TComPrediction::xDeltaDCQuantScaleUp( TComDataCU* pcCU, Int& riDeltaDC )
3456{
3457  Int  iSign  = riDeltaDC < 0 ? -1 : 1;
3458  UInt uiAbs  = abs( riDeltaDC );
3459
3460  Int iQp = pcCU->getQP(0);
3461  Double dMax = (Double)( 1<<( g_uiBitDepth + g_uiBitIncrement - 1) );
3462  Double dStepSize = Clip3( 1.0, dMax, pow( 2.0, iQp/10.0 + g_iDeltaDCsQuantOffset ) );
3463
3464  riDeltaDC = iSign * roftoi( uiAbs * dStepSize );
3465  return;
3466}
3467
3468Void TComPrediction::xDeltaDCQuantScaleDown( TComDataCU*  pcCU, Int& riDeltaDC )
3469{
3470  Int  iSign  = riDeltaDC < 0 ? -1 : 1;
3471  UInt uiAbs  = abs( riDeltaDC );
3472
3473  Int iQp = pcCU->getQP(0);
3474  Double dMax = (Double)( 1<<( g_uiBitDepth + g_uiBitIncrement - 1) );
3475  Double dStepSize = Clip3( 1.0, dMax, pow( 2.0, iQp/10.0 + g_iDeltaDCsQuantOffset ) );
3476
3477  riDeltaDC = iSign * roftoi( uiAbs / dStepSize );
3478  return;
3479}
3480#endif
3481
3482#if HHI_DMM_PRED_TEX
3483Void TComPrediction::getBestContourFromTex( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, TComWedgelet* pcContourWedge )
3484{
3485  pcContourWedge->clear();
3486
3487  // get copy of co-located texture luma block
3488  TComYuv cTempYuv;
3489  cTempYuv.create( uiWidth, uiHeight ); 
3490  cTempYuv.clear();
3491  Pel* piRefBlkY = cTempYuv.getLumaAddr();
3492  copyTextureLumaBlock( pcCU, uiAbsPartIdx, piRefBlkY, uiWidth, uiHeight );
3493  piRefBlkY = cTempYuv.getLumaAddr();
3494
3495  // find contour for texture luma block
3496  UInt iDC = 0;
3497  for( UInt k = 0; k < (uiWidth*uiHeight); k++ ) 
3498  { 
3499    iDC += piRefBlkY[k]; 
3500  }
3501  iDC /= (uiWidth*uiHeight);
3502  piRefBlkY = cTempYuv.getLumaAddr();
3503
3504  Bool* pabContourPattern = pcContourWedge->getPattern();
3505  for( UInt k = 0; k < (uiWidth*uiHeight); k++ ) 
3506  { 
3507    pabContourPattern[k] = (piRefBlkY[k] > iDC) ? true : false;
3508  }
3509
3510  cTempYuv.destroy();
3511}
3512
3513#if LGE_DMM3_SIMP_C0044
3514/**
3515 - fetch best Wedgelet pattern at decoder
3516 */
3517UInt TComPrediction::getBestWedgeFromTex( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, UInt IntraTabIdx)
3518{
3519  assert( uiWidth >= DMM_WEDGEMODEL_MIN_SIZE && uiWidth <= DMM_WEDGEMODEL_MAX_SIZE );
3520
3521  UInt          uiBestTabIdx = 0;
3522  TComPic*      pcPicTex = pcCU->getSlice()->getTexturePic();
3523  TComDataCU*   pcColTexCU = pcPicTex->getCU(pcCU->getAddr());
3524  UInt          uiTexPartIdx = pcCU->getZorderIdxInCU() + uiAbsPartIdx;
3525  Int           uiColTexIntraDir = pcColTexCU->isIntra( uiTexPartIdx ) ? pcColTexCU->getLumaIntraDir( uiTexPartIdx ) : 255;
3526
3527  std::vector< std::vector<UInt> > pauiWdgLstSz = g_aauiWdgLstM3[g_aucConvertToBit[uiWidth]];
3528
3529  if( uiColTexIntraDir > DC_IDX && uiColTexIntraDir < 35 )
3530  {
3531    std::vector<UInt>* pauiWdgLst = &pauiWdgLstSz[uiColTexIntraDir-2];
3532    uiBestTabIdx    =   pauiWdgLst->at(IntraTabIdx);
3533  }
3534  else
3535  {
3536    WedgeNodeList* pacWedgeNodeList = &g_aacWedgeNodeLists[(g_aucConvertToBit[uiWidth])];
3537    uiBestTabIdx = pacWedgeNodeList->at(IntraTabIdx).getPatternIdx();
3538  }
3539
3540  return uiBestTabIdx;
3541}
3542#endif
3543
3544#if LGE_DMM3_SIMP_C0044
3545/**
3546 - calculate best Wedgelet pattern at encoder
3547 */
3548UInt TComPrediction::getBestWedgeFromTex( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, Pel* piOrigi, UInt uiStride, UInt & ruiIntraTabIdx)
3549#else
3550UInt TComPrediction::getBestWedgeFromTex( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight )
3551#endif
3552{
3553  assert( uiWidth >= DMM_WEDGEMODEL_MIN_SIZE && uiWidth <= DMM_WEDGEMODEL_MAX_SIZE );
3554
3555  // get copy of co-located texture luma block
3556  TComYuv cTempYuv; 
3557  cTempYuv.create( uiWidth, uiHeight ); 
3558  cTempYuv.clear();
3559  Pel* piRefBlkY = cTempYuv.getLumaAddr();
3560
3561  copyTextureLumaBlock( pcCU, uiAbsPartIdx, piRefBlkY, uiWidth, uiHeight );
3562  piRefBlkY = cTempYuv.getLumaAddr();
3563
3564  // local pred buffer
3565  TComYuv cPredYuv; 
3566  cPredYuv.create( uiWidth, uiHeight ); 
3567  cPredYuv.clear();
3568  Pel* piPred = cPredYuv.getLumaAddr();
3569
3570  UInt uiPredStride = cPredYuv.getStride();
3571
3572  // wedge search
3573  TComWedgeDist cWedgeDist;
3574  UInt uiBestDist = MAX_UINT;
3575  UInt uiBestTabIdx = 0;
3576  Int  iDC1 = 0;
3577  Int  iDC2 = 0;
3578  WedgeList* pacWedgeList = &g_aacWedgeLists[(g_aucConvertToBit[uiWidth])];
3579#if LGE_DMM3_SIMP_C0044
3580  ruiIntraTabIdx  = 0;
3581#endif
3582  TComPic*      pcPicTex = pcCU->getSlice()->getTexturePic();
3583  TComDataCU* pcColTexCU = pcPicTex->getCU(pcCU->getAddr());
3584  UInt      uiTexPartIdx = pcCU->getZorderIdxInCU() + uiAbsPartIdx;
3585  Int   uiColTexIntraDir = pcColTexCU->isIntra( uiTexPartIdx ) ? pcColTexCU->getLumaIntraDir( uiTexPartIdx ) : 255;
3586
3587  std::vector< std::vector<UInt> > pauiWdgLstSz = g_aauiWdgLstM3[g_aucConvertToBit[uiWidth]];
3588  if( uiColTexIntraDir > DC_IDX && uiColTexIntraDir < 35 )
3589  {
3590    std::vector<UInt>* pauiWdgLst = &pauiWdgLstSz[uiColTexIntraDir-2];
3591    for( UInt uiIdxW = 0; uiIdxW < pauiWdgLst->size(); uiIdxW++ )
3592    {
3593      UInt uiIdx     =   pauiWdgLst->at(uiIdxW);
3594#if LGE_DMM3_SIMP_C0044
3595      calcWedgeDCs       ( &(pacWedgeList->at(uiIdx)), piOrigi,   uiWidth,      iDC1, iDC2 );
3596#else
3597      calcWedgeDCs       ( &(pacWedgeList->at(uiIdx)), piRefBlkY, uiWidth,      iDC1, iDC2 );
3598#endif
3599      assignWedgeDCs2Pred( &(pacWedgeList->at(uiIdx)), piPred,    uiPredStride, iDC1, iDC2 );
3600
3601#if LGE_DMM3_SIMP_C0044
3602      UInt uiActDist = cWedgeDist.getDistPart( piPred, uiPredStride, piOrigi, uiStride, uiWidth, uiHeight, WedgeDist_SAD );
3603#else
3604      UInt uiActDist = cWedgeDist.getDistPart( piPred, uiPredStride, piRefBlkY, uiWidth, uiWidth, uiHeight, WedgeDist_SAD );
3605#endif
3606
3607      if( uiActDist < uiBestDist || uiBestDist == MAX_UINT )
3608      {
3609        uiBestDist   = uiActDist;
3610        uiBestTabIdx = uiIdx;
3611#if LGE_DMM3_SIMP_C0044
3612        ruiIntraTabIdx = uiIdxW;
3613#endif
3614      }
3615    }
3616  }
3617  else
3618  {
3619    WedgeNodeList* pacWedgeNodeList = &g_aacWedgeNodeLists[(g_aucConvertToBit[uiWidth])];
3620    UInt uiBestNodeDist = MAX_UINT;
3621    UInt uiBestNodeId   = 0;
3622    for( UInt uiNodeId = 0; uiNodeId < pacWedgeNodeList->size(); uiNodeId++ )
3623    {
3624#if LGE_DMM3_SIMP_C0044
3625      calcWedgeDCs       ( &(pacWedgeList->at(pacWedgeNodeList->at(uiNodeId).getPatternIdx())), piOrigi, uiWidth,      iDC1, iDC2 );
3626#else
3627      calcWedgeDCs       ( &(pacWedgeList->at(pacWedgeNodeList->at(uiNodeId).getPatternIdx())), piRefBlkY, uiWidth,      iDC1, iDC2 );
3628#endif
3629      assignWedgeDCs2Pred( &(pacWedgeList->at(pacWedgeNodeList->at(uiNodeId).getPatternIdx())), piPred,    uiPredStride, iDC1, iDC2 );
3630
3631#if LGE_DMM3_SIMP_C0044
3632      UInt uiActDist = cWedgeDist.getDistPart( piPred, uiPredStride, piOrigi, uiStride, uiWidth, uiHeight, WedgeDist_SAD );
3633#else
3634      UInt uiActDist = cWedgeDist.getDistPart( piPred, uiPredStride, piRefBlkY, uiWidth, uiWidth, uiHeight, WedgeDist_SAD );
3635#endif
3636
3637      if( uiActDist < uiBestNodeDist || uiBestNodeDist == MAX_UINT )
3638      {
3639        uiBestNodeDist = uiActDist;
3640        uiBestNodeId   = uiNodeId;
3641#if LGE_DMM3_SIMP_C0044
3642        ruiIntraTabIdx = uiNodeId;
3643#endif
3644      }
3645    }
3646#if LGE_DMM3_SIMP_C0044
3647    uiBestTabIdx = pacWedgeNodeList->at(uiBestNodeId).getPatternIdx();
3648#else
3649    // refinement
3650    uiBestDist   = uiBestNodeDist;
3651    uiBestTabIdx = pacWedgeNodeList->at(uiBestNodeId).getPatternIdx();
3652    for( UInt uiRefId = 0; uiRefId < NUM_WEDGE_REFINES; uiRefId++ )
3653    {
3654      if( pacWedgeNodeList->at(uiBestNodeId).getRefineIdx( uiRefId ) != NO_IDX )
3655      {
3656        calcWedgeDCs       ( &(pacWedgeList->at(pacWedgeNodeList->at(uiBestNodeId).getRefineIdx( uiRefId ))), piRefBlkY, uiWidth,      iDC1, iDC2 );
3657        assignWedgeDCs2Pred( &(pacWedgeList->at(pacWedgeNodeList->at(uiBestNodeId).getRefineIdx( uiRefId ))), piPred,    uiPredStride, iDC1, iDC2 );
3658
3659        UInt uiActDist = cWedgeDist.getDistPart( piPred, uiPredStride, piRefBlkY, uiWidth, uiWidth, uiHeight, WedgeDist_SAD );
3660
3661        if( uiActDist < uiBestDist || uiBestDist == MAX_UINT )
3662        {
3663          uiBestDist   = uiActDist;
3664          uiBestTabIdx = pacWedgeNodeList->at(uiBestNodeId).getRefineIdx( uiRefId );
3665        }
3666      }
3667    }
3668#endif
3669  }
3670
3671  cPredYuv.destroy();
3672  cTempYuv.destroy();
3673  return uiBestTabIdx;
3674}
3675
3676Void TComPrediction::copyTextureLumaBlock( TComDataCU* pcCU, UInt uiAbsPartIdx, Pel* piDestBlockY, UInt uiWidth, UInt uiHeight )
3677{
3678  TComPicYuv* pcPicYuvRef = pcCU->getSlice()->getTexturePic()->getPicYuvRec();
3679  Int         iRefStride = pcPicYuvRef->getStride();
3680  Pel*        piRefY;
3681
3682  piRefY = pcPicYuvRef->getLumaAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() + uiAbsPartIdx );
3683
3684  for ( Int y = 0; y < uiHeight; y++ )
3685  {
3686    ::memcpy(piDestBlockY, piRefY, sizeof(Pel)*uiWidth);
3687//    ::memset(piDestBlockY, 128, sizeof(Pel)*uiWidth);
3688    piDestBlockY += uiWidth;
3689    piRefY += iRefStride;
3690  }
3691}
3692
3693Void TComPrediction::xPredIntraWedgeTex( TComDataCU* pcCU, UInt uiAbsPartIdx, Pel* piPred, UInt uiStride, Int iWidth, Int iHeight, Bool bAbove, Bool bLeft, Bool bEncoder, Bool bDelta, Int iDeltaDC1, Int iDeltaDC2 )
3694{
3695  assert( iWidth >= DMM_WEDGEMODEL_MIN_SIZE && iWidth <= DMM_WEDGEMODEL_MAX_SIZE );
3696  WedgeList* pacWedgeList = &g_aacWedgeLists[(g_aucConvertToBit[iWidth])];
3697
3698  // get wedge pattern
3699  UInt uiTextureWedgeTabIdx = 0;
3700  if( bEncoder ) 
3701  {
3702    // encoder: load stored wedge pattern from CU
3703    uiTextureWedgeTabIdx = pcCU->getWedgePredTexTabIdx( uiAbsPartIdx );
3704  }
3705  else
3706  {
3707    // decoder: get and store wedge pattern in CU
3708      // decoder: get and store wedge pattern in CU
3709#if LGE_DMM3_SIMP_C0044
3710    UInt uiIntraTabIdx   = pcCU->getWedgePredTexIntraTabIdx ( uiAbsPartIdx );
3711    uiTextureWedgeTabIdx = getBestWedgeFromTex( pcCU, uiAbsPartIdx, (UInt)iWidth, (UInt)iHeight, uiIntraTabIdx );
3712#else
3713    uiTextureWedgeTabIdx = getBestWedgeFromTex( pcCU, uiAbsPartIdx, (UInt)iWidth, (UInt)iHeight );
3714#endif
3715
3716    UInt uiDepth = (pcCU->getDepth(0)) + (pcCU->getPartitionSize(0) == SIZE_2Nx2N ? 0 : 1);
3717    pcCU->setWedgePredTexTabIdxSubParts( uiTextureWedgeTabIdx, uiAbsPartIdx, uiDepth );
3718  }
3719  TComWedgelet* pcWedgelet = &(pacWedgeList->at(uiTextureWedgeTabIdx));
3720
3721  // get wedge pred DCs
3722  Int iPredDC1 = 0;
3723  Int iPredDC2 = 0;
3724  Int* piMask = pcCU->getPattern()->getAdiOrgBuf( iWidth, iHeight, m_piYuvExt );
3725  Int iMaskStride = ( iWidth<<1 ) + 1;
3726  piMask += iMaskStride+1;
3727#if QC_DC_PREDICTOR_D0183
3728  getPredDCs( pcWedgelet->getPattern(), pcWedgelet->getStride(), piMask, iMaskStride, iPredDC1, iPredDC2 );
3729#else
3730  getWedgePredDCs( pcWedgelet, piMask, iMaskStride, iPredDC1, iPredDC2, bAbove, bLeft );
3731#endif
3732
3733  // assign wedge pred DCs to prediction
3734  if( bDelta ) 
3735  { 
3736#if HHI_DELTADC_DLT_D0035
3737    assignWedgeDCs2Pred( pcWedgelet, piPred, uiStride, GetIdx2DepthValue( GetDepthValue2Idx(iPredDC1) + iDeltaDC1 ), GetIdx2DepthValue( GetDepthValue2Idx(iPredDC2) + iDeltaDC2 ) ); 
3738#else
3739    assignWedgeDCs2Pred( pcWedgelet, piPred, uiStride, Clip( iPredDC1+iDeltaDC1 ), Clip( iPredDC2+iDeltaDC2 ) ); 
3740#endif
3741  }
3742  else 
3743  { 
3744    assignWedgeDCs2Pred( pcWedgelet, piPred, uiStride, iPredDC1, iPredDC2 ); 
3745  }
3746}
3747
3748Void TComPrediction::xPredIntraContourTex( TComDataCU* pcCU, UInt uiAbsPartIdx, Pel* piPred, UInt uiStride, Int iWidth, Int iHeight, Bool bAbove, Bool bLeft, Bool bEncoder, Bool bDelta, Int iDeltaDC1, Int iDeltaDC2 )
3749{
3750  // get contour pattern
3751  TComWedgelet* pcContourWedge = new TComWedgelet( iWidth, iHeight );
3752  getBestContourFromTex( pcCU, uiAbsPartIdx, (UInt)iWidth, (UInt)iHeight, pcContourWedge );
3753
3754  // get wedge pred DCs
3755  Int iPredDC1 = 0;
3756  Int iPredDC2 = 0;
3757  Int* piMask = pcCU->getPattern()->getAdiOrgBuf( iWidth, iHeight, m_piYuvExt );
3758  Int iMaskStride = ( iWidth<<1 ) + 1;
3759  piMask += iMaskStride+1;
3760#if QC_DC_PREDICTOR_D0183
3761  getPredDCs( pcContourWedge->getPattern(), pcContourWedge->getStride(), piMask, iMaskStride, iPredDC1, iPredDC2 );
3762#else
3763  getWedgePredDCs( pcContourWedge, piMask, iMaskStride, iPredDC1, iPredDC2, bAbove, bLeft );
3764#endif
3765
3766  // assign wedge pred DCs to prediction
3767  if( bDelta ) 
3768  { 
3769#if HHI_DELTADC_DLT_D0035
3770    assignWedgeDCs2Pred( pcContourWedge, piPred, uiStride, GetIdx2DepthValue( GetDepthValue2Idx(iPredDC1) + iDeltaDC1 ), GetIdx2DepthValue( GetDepthValue2Idx(iPredDC2) + iDeltaDC2 ) ); 
3771#else
3772    assignWedgeDCs2Pred( pcContourWedge, piPred, uiStride, Clip( iPredDC1+iDeltaDC1 ), Clip( iPredDC2+iDeltaDC2 ) ); 
3773#endif
3774  }
3775  else 
3776  { 
3777    assignWedgeDCs2Pred( pcContourWedge, piPred, uiStride, iPredDC1, iPredDC2 ); 
3778  }
3779
3780  pcContourWedge->destroy();
3781  delete pcContourWedge;
3782}
3783#endif // HHI_DMM_PRED_TEX
3784
3785#if HHI_DMM_WEDGE_INTRA
3786UInt TComPrediction::getBestContinueWedge( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, Int iDeltaEnd )
3787{
3788  UInt uiThisBlockSize = uiWidth;
3789  assert( uiThisBlockSize >= DMM_WEDGEMODEL_MIN_SIZE && uiThisBlockSize <= DMM_WEDGEMODEL_MAX_SIZE );
3790  WedgeRefList* pacContDWedgeRefList = &g_aacWedgeRefLists[(g_aucConvertToBit[uiThisBlockSize])];
3791
3792  UInt uiPredDirWedgeTabIdx = 0;
3793  TComDataCU* pcTempCU;
3794  UInt        uiTempPartIdx;
3795  // 1st: try continue above wedgelet
3796  pcTempCU = pcCU->getPUAbove( uiTempPartIdx, pcCU->getZorderIdxInCU() + uiAbsPartIdx );
3797  if( pcTempCU )
3798  {
3799    UChar uhLumaIntraDir = pcTempCU->getLumaIntraDir( uiTempPartIdx );
3800    if( DMM_WEDGE_FULL_IDX      == uhLumaIntraDir || 
3801        DMM_WEDGE_FULL_D_IDX    == uhLumaIntraDir || 
3802        DMM_WEDGE_PREDDIR_IDX   == uhLumaIntraDir || 
3803        DMM_WEDGE_PREDDIR_D_IDX == uhLumaIntraDir
3804#if HHI_DMM_PRED_TEX
3805        ||
3806        DMM_WEDGE_PREDTEX_IDX   == uhLumaIntraDir ||
3807        DMM_WEDGE_PREDTEX_D_IDX == uhLumaIntraDir   
3808#endif
3809      )
3810    {
3811      UInt uiRefWedgeSize = (UInt)g_aucIntraSizeIdxToWedgeSize[pcTempCU->getIntraSizeIdx( uiTempPartIdx )];
3812      WedgeList* pacWedgeList = &g_aacWedgeLists[(g_aucConvertToBit[uiRefWedgeSize])];
3813
3814      // get offset between current and reference block
3815      UInt uiOffsetX = 0;
3816      UInt uiOffsetY = 0;
3817      xGetBlockOffset( pcCU, uiAbsPartIdx, pcTempCU, uiTempPartIdx, uiOffsetX, uiOffsetY );
3818
3819      // get reference wedgelet
3820      UInt uiRefWedgeTabIdx = 0;
3821      switch( uhLumaIntraDir )
3822      {
3823      case( DMM_WEDGE_FULL_IDX      ): { uiRefWedgeTabIdx = pcTempCU->getWedgeFullTabIdx   ( uiTempPartIdx ); } break;
3824      case( DMM_WEDGE_FULL_D_IDX    ): { uiRefWedgeTabIdx = pcTempCU->getWedgeFullTabIdx   ( uiTempPartIdx ); } break;
3825      case( DMM_WEDGE_PREDDIR_IDX   ): { uiRefWedgeTabIdx = pcTempCU->getWedgePredDirTabIdx( uiTempPartIdx ); } break;
3826      case( DMM_WEDGE_PREDDIR_D_IDX ): { uiRefWedgeTabIdx = pcTempCU->getWedgePredDirTabIdx( uiTempPartIdx ); } break;
3827#if HHI_DMM_PRED_TEX
3828      case( DMM_WEDGE_PREDTEX_IDX   ): { uiRefWedgeTabIdx = pcTempCU->getWedgePredTexTabIdx( uiTempPartIdx ); } break;
3829      case( DMM_WEDGE_PREDTEX_D_IDX ): { uiRefWedgeTabIdx = pcTempCU->getWedgePredTexTabIdx( uiTempPartIdx ); } break;
3830#endif
3831      default: { assert( 0 ); return uiPredDirWedgeTabIdx; }
3832      }
3833      TComWedgelet* pcRefWedgelet;
3834      pcRefWedgelet = &(pacWedgeList->at( uiRefWedgeTabIdx ));
3835
3836      // find reference wedgelet, if direction is suitable for continue wedge
3837      if( pcRefWedgelet->checkPredDirAbovePossible( uiThisBlockSize, uiOffsetX ) )
3838      {
3839        UChar uhContD_Xs, uhContD_Ys, uhContD_Xe, uhContD_Ye;
3840        pcRefWedgelet->getPredDirStartEndAbove( uhContD_Xs, uhContD_Ys, uhContD_Xe, uhContD_Ye, uiThisBlockSize, uiOffsetX, iDeltaEnd );
3841        getWedgePatternIdx( pacContDWedgeRefList, uiPredDirWedgeTabIdx, uhContD_Xs, uhContD_Ys, uhContD_Xe, uhContD_Ye );
3842        return uiPredDirWedgeTabIdx;
3843      }
3844    }
3845  }
3846
3847  // 2nd: try continue left wedglelet
3848  pcTempCU = pcCU->getPULeft( uiTempPartIdx, pcCU->getZorderIdxInCU() + uiAbsPartIdx );
3849  if( pcTempCU )
3850  {
3851    UChar uhLumaIntraDir = pcTempCU->getLumaIntraDir( uiTempPartIdx );
3852    if( DMM_WEDGE_FULL_IDX      == uhLumaIntraDir || 
3853        DMM_WEDGE_FULL_D_IDX    == uhLumaIntraDir || 
3854        DMM_WEDGE_PREDDIR_IDX   == uhLumaIntraDir || 
3855        DMM_WEDGE_PREDDIR_D_IDX == uhLumaIntraDir
3856#if HHI_DMM_PRED_TEX
3857        ||
3858        DMM_WEDGE_PREDTEX_IDX   == uhLumaIntraDir ||
3859        DMM_WEDGE_PREDTEX_D_IDX == uhLumaIntraDir   
3860#endif
3861      )
3862    {
3863      UInt uiRefWedgeSize = (UInt)g_aucIntraSizeIdxToWedgeSize[pcTempCU->getIntraSizeIdx( uiTempPartIdx )];
3864      WedgeList* pacWedgeList = &g_aacWedgeLists[(g_aucConvertToBit[uiRefWedgeSize])];
3865
3866      // get offset between current and reference block
3867      UInt uiOffsetX = 0;
3868      UInt uiOffsetY = 0;
3869      xGetBlockOffset( pcCU, uiAbsPartIdx, pcTempCU, uiTempPartIdx, uiOffsetX, uiOffsetY );
3870
3871      // get reference wedgelet
3872      UInt uiRefWedgeTabIdx = 0;
3873      switch( uhLumaIntraDir )
3874      {
3875      case( DMM_WEDGE_FULL_IDX      ): { uiRefWedgeTabIdx = pcTempCU->getWedgeFullTabIdx   ( uiTempPartIdx ); } break;
3876      case( DMM_WEDGE_FULL_D_IDX    ): { uiRefWedgeTabIdx = pcTempCU->getWedgeFullTabIdx   ( uiTempPartIdx ); } break;
3877      case( DMM_WEDGE_PREDDIR_IDX   ): { uiRefWedgeTabIdx = pcTempCU->getWedgePredDirTabIdx( uiTempPartIdx ); } break;
3878      case( DMM_WEDGE_PREDDIR_D_IDX ): { uiRefWedgeTabIdx = pcTempCU->getWedgePredDirTabIdx( uiTempPartIdx ); } break;
3879#if HHI_DMM_PRED_TEX
3880      case( DMM_WEDGE_PREDTEX_IDX   ): { uiRefWedgeTabIdx = pcTempCU->getWedgePredTexTabIdx( uiTempPartIdx ); } break;
3881      case( DMM_WEDGE_PREDTEX_D_IDX ): { uiRefWedgeTabIdx = pcTempCU->getWedgePredTexTabIdx( uiTempPartIdx ); } break;
3882#endif
3883      default: { assert( 0 ); return uiPredDirWedgeTabIdx; }
3884      }
3885      TComWedgelet* pcRefWedgelet;
3886      pcRefWedgelet = &(pacWedgeList->at( uiRefWedgeTabIdx ));
3887
3888      // find reference wedgelet, if direction is suitable for continue wedge
3889      if( pcRefWedgelet->checkPredDirLeftPossible( uiThisBlockSize, uiOffsetY ) )
3890      {
3891        UChar uhContD_Xs, uhContD_Ys, uhContD_Xe, uhContD_Ye;
3892        pcRefWedgelet->getPredDirStartEndLeft( uhContD_Xs, uhContD_Ys, uhContD_Xe, uhContD_Ye, uiThisBlockSize, uiOffsetY, iDeltaEnd );
3893        getWedgePatternIdx( pacContDWedgeRefList, uiPredDirWedgeTabIdx, uhContD_Xs, uhContD_Ys, uhContD_Xe, uhContD_Ye );
3894        return uiPredDirWedgeTabIdx;
3895      }
3896    }
3897  }
3898
3899  // 3rd: (default) make wedglet from intra dir and max slope point
3900  Int iSlopeX = 0;
3901  Int iSlopeY = 0;
3902  UInt uiStartPosX = 0;
3903  UInt uiStartPosY = 0;
3904  if( xGetWedgeIntraDirPredData( pcCU, uiAbsPartIdx, uiThisBlockSize, iSlopeX, iSlopeY, uiStartPosX, uiStartPosY ) )
3905  {
3906    UChar uhContD_Xs, uhContD_Ys, uhContD_Xe, uhContD_Ye;
3907    xGetWedgeIntraDirStartEnd( pcCU, uiAbsPartIdx, uiThisBlockSize, iSlopeX, iSlopeY, uiStartPosX, uiStartPosY, uhContD_Xs, uhContD_Ys, uhContD_Xe, uhContD_Ye, iDeltaEnd );
3908    getWedgePatternIdx( pacContDWedgeRefList, uiPredDirWedgeTabIdx, uhContD_Xs, uhContD_Ys, uhContD_Xe, uhContD_Ye );
3909    return uiPredDirWedgeTabIdx;
3910  }
3911
3912  return uiPredDirWedgeTabIdx;
3913}
3914
3915Bool TComPrediction::getWedgePatternIdx( WedgeRefList* pcWedgeRefList, UInt& ruiTabIdx, UChar uhXs, UChar uhYs, UChar uhXe, UChar uhYe )
3916{
3917  ruiTabIdx = 0;
3918
3919  for( UInt uiIdx = 0; uiIdx < pcWedgeRefList->size(); uiIdx++ )
3920  {
3921    TComWedgeRef* pcTestWedgeRef = &(pcWedgeRefList->at(uiIdx));
3922
3923    if( pcTestWedgeRef->getStartX() == uhXs &&
3924      pcTestWedgeRef->getStartY() == uhYs &&
3925      pcTestWedgeRef->getEndX()   == uhXe &&
3926      pcTestWedgeRef->getEndY()   == uhYe    )
3927    {
3928      ruiTabIdx = pcTestWedgeRef->getRefIdx();
3929      return true;
3930    }
3931  }
3932
3933  return false;
3934}
3935
3936Void TComPrediction::xPredIntraWedgeFull( TComDataCU* pcCU, UInt uiAbsPartIdx, Pel* piPred, UInt uiStride, Int iWidth, Int iHeight, Bool bAbove, Bool bLeft, Bool bEncoder, Bool bDelta, UInt uiTabIdx, Int iDeltaDC1, Int iDeltaDC2 )
3937{
3938  assert( iWidth >= DMM_WEDGEMODEL_MIN_SIZE && iWidth <= DMM_WEDGEMODEL_MAX_SIZE );
3939  WedgeList* pacWedgeList = &g_aacWedgeLists[(g_aucConvertToBit[iWidth])];
3940  TComWedgelet* pcWedgelet = &(pacWedgeList->at(uiTabIdx));
3941
3942  // get wedge pred DCs
3943  Int iPredDC1 = 0;
3944  Int iPredDC2 = 0;
3945
3946  Int* piMask = pcCU->getPattern()->getAdiOrgBuf( iWidth, iHeight, m_piYuvExt );
3947  Int iMaskStride = ( iWidth<<1 ) + 1;
3948  piMask += iMaskStride+1;
3949#if QC_DC_PREDICTOR_D0183
3950  getPredDCs( pcWedgelet->getPattern(), pcWedgelet->getStride(), piMask, iMaskStride, iPredDC1, iPredDC2 );
3951#else
3952  getWedgePredDCs( pcWedgelet, piMask, iMaskStride, iPredDC1, iPredDC2, bAbove, bLeft );
3953#endif
3954
3955  // assign wedge pred DCs to prediction
3956  if( bDelta ) 
3957  { 
3958#if HHI_DELTADC_DLT_D0035
3959    assignWedgeDCs2Pred( pcWedgelet, piPred, uiStride, GetIdx2DepthValue( GetDepthValue2Idx(iPredDC1) + iDeltaDC1 ), GetIdx2DepthValue( GetDepthValue2Idx(iPredDC2) + iDeltaDC2 ) ); 
3960#else
3961    assignWedgeDCs2Pred( pcWedgelet, piPred, uiStride, Clip( iPredDC1+iDeltaDC1 ), Clip( iPredDC2+iDeltaDC2 ) ); 
3962#endif
3963  }
3964  else 
3965  { 
3966    assignWedgeDCs2Pred( pcWedgelet, piPred, uiStride, iPredDC1, iPredDC2 ); 
3967  }
3968}
3969
3970Void TComPrediction::xPredIntraWedgeDir( TComDataCU* pcCU, UInt uiAbsPartIdx, Pel* piPred, UInt uiStride, Int iWidth, Int iHeight, Bool bAbove, Bool bLeft, Bool bEncoder, Bool bDelta, Int iWedgeDeltaEnd, Int iDeltaDC1, Int iDeltaDC2 )
3971{
3972  assert( iWidth >= DMM_WEDGEMODEL_MIN_SIZE && iWidth <= DMM_WEDGEMODEL_MAX_SIZE );
3973  WedgeList* pacWedgeList = &g_aacWedgeLists[(g_aucConvertToBit[iWidth])];
3974
3975  // get wedge pattern
3976  UInt uiDirWedgeTabIdx = 0;
3977  if( bEncoder )
3978  {
3979    // encoder: load stored wedge pattern from CU
3980    uiDirWedgeTabIdx = pcCU->getWedgePredDirTabIdx( uiAbsPartIdx );
3981  }
3982  else
3983  {
3984    uiDirWedgeTabIdx = getBestContinueWedge( pcCU, uiAbsPartIdx, iWidth, iHeight, iWedgeDeltaEnd );
3985
3986    UInt uiDepth = (pcCU->getDepth(0)) + (pcCU->getPartitionSize(0) == SIZE_2Nx2N ? 0 : 1);
3987    pcCU->setWedgePredDirTabIdxSubParts( uiDirWedgeTabIdx, uiAbsPartIdx, uiDepth );
3988  }
3989  TComWedgelet* pcWedgelet = &(pacWedgeList->at(uiDirWedgeTabIdx));
3990
3991  // get wedge pred DCs
3992  Int iPredDC1 = 0;
3993  Int iPredDC2 = 0;
3994
3995  Int* piMask = pcCU->getPattern()->getAdiOrgBuf( iWidth, iHeight, m_piYuvExt );
3996  Int iMaskStride = ( iWidth<<1 ) + 1;
3997  piMask += iMaskStride+1;
3998#if QC_DC_PREDICTOR_D0183
3999  getPredDCs( pcWedgelet->getPattern(), pcWedgelet->getStride(), piMask, iMaskStride, iPredDC1, iPredDC2 );
4000#else
4001  getWedgePredDCs( pcWedgelet, piMask, iMaskStride, iPredDC1, iPredDC2, bAbove, bLeft );
4002#endif
4003
4004  // assign wedge pred DCs to prediction
4005  if( bDelta ) 
4006  { 
4007#if HHI_DELTADC_DLT_D0035
4008    assignWedgeDCs2Pred( pcWedgelet, piPred, uiStride, GetIdx2DepthValue( GetDepthValue2Idx(iPredDC1) + iDeltaDC1 ), GetIdx2DepthValue( GetDepthValue2Idx(iPredDC2) + iDeltaDC2 ) ); 
4009#else
4010    assignWedgeDCs2Pred( pcWedgelet, piPred, uiStride, Clip( iPredDC1+iDeltaDC1 ), Clip( iPredDC2+iDeltaDC2 ) ); 
4011#endif
4012  }
4013  else 
4014  { 
4015    assignWedgeDCs2Pred( pcWedgelet, piPred, uiStride, iPredDC1, iPredDC2 ); 
4016  }
4017}
4018
4019Void TComPrediction::xGetBlockOffset( TComDataCU* pcCU, UInt uiAbsPartIdx, TComDataCU* pcRefCU, UInt uiRefAbsPartIdx, UInt& ruiOffsetX, UInt& ruiOffsetY )
4020{
4021  ruiOffsetX = 0;
4022  ruiOffsetY = 0;
4023
4024  // get offset between current and above/left block
4025  UInt uiThisOriginX = pcCU->getCUPelX() + g_auiRasterToPelX[ g_auiZscanToRaster[uiAbsPartIdx] ];
4026  UInt uiThisOriginY = pcCU->getCUPelY() + g_auiRasterToPelY[ g_auiZscanToRaster[uiAbsPartIdx] ];
4027
4028  UInt uiNumPartInRefCU = pcRefCU->getTotalNumPart();
4029  UInt uiMaxDepthRefCU = 0;
4030  while( uiNumPartInRefCU > 1 )
4031  {
4032    uiNumPartInRefCU >>= 2;
4033    uiMaxDepthRefCU++;
4034  }
4035
4036  UInt uiDepthRefPU = (pcRefCU->getDepth(uiRefAbsPartIdx)) + (pcRefCU->getPartitionSize(uiRefAbsPartIdx) == SIZE_2Nx2N ? 0 : 1);
4037  UInt uiShifts = (uiMaxDepthRefCU - uiDepthRefPU)*2;
4038  UInt uiRefBlockOriginPartIdx = (uiRefAbsPartIdx>>uiShifts)<<uiShifts;
4039
4040  UInt uiRefOriginX = pcRefCU->getCUPelX() + g_auiRasterToPelX[ g_auiZscanToRaster[uiRefBlockOriginPartIdx] ];
4041  UInt uiRefOriginY = pcRefCU->getCUPelY() + g_auiRasterToPelY[ g_auiZscanToRaster[uiRefBlockOriginPartIdx] ];
4042
4043  if( (uiThisOriginX - uiRefOriginX) > 0 ) { ruiOffsetX = (UInt)(uiThisOriginX - uiRefOriginX); }
4044  if( (uiThisOriginY - uiRefOriginY) > 0 ) { ruiOffsetY = (UInt)(uiThisOriginY - uiRefOriginY); }
4045}
4046
4047Bool TComPrediction::xGetWedgeIntraDirPredData( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiBlockSize, Int& riSlopeX, Int& riSlopeY, UInt& ruiStartPosX, UInt& ruiStartPosY )
4048{
4049  riSlopeX     = 0;
4050  riSlopeY     = 0;
4051  ruiStartPosX = 0;
4052  ruiStartPosY = 0;
4053
4054  // 1st step: get wedge start point (max. slope)
4055  Int* piSource = pcCU->getPattern()->getAdiOrgBuf( uiBlockSize, uiBlockSize, m_piYuvExt );
4056  Int iSourceStride = ( uiBlockSize<<1 ) + 1;
4057
4058  UInt uiSlopeMaxAbove = 0;
4059  UInt uiPosSlopeMaxAbove = 0;
4060  for( UInt uiPosHor = 0; uiPosHor < (uiBlockSize-1); uiPosHor++ )
4061  {
4062    if( abs( piSource[uiPosHor+1] - piSource[uiPosHor] ) > uiSlopeMaxAbove )
4063    {
4064      uiSlopeMaxAbove = abs( piSource[uiPosHor+1] - piSource[uiPosHor] );
4065      uiPosSlopeMaxAbove = uiPosHor;
4066    }
4067  }
4068
4069  UInt uiSlopeMaxLeft = 0;
4070  UInt uiPosSlopeMaxLeft = 0;
4071  for( UInt uiPosVer = 0; uiPosVer < (uiBlockSize-1); uiPosVer++ )
4072  {
4073    if( abs( piSource[(uiPosVer+1)*iSourceStride] - piSource[uiPosVer*iSourceStride] ) > uiSlopeMaxLeft )
4074    {
4075      uiSlopeMaxLeft = abs( piSource[(uiPosVer+1)*iSourceStride] - piSource[uiPosVer*iSourceStride] );
4076      uiPosSlopeMaxLeft = uiPosVer;
4077    }
4078  }
4079
4080  if( uiSlopeMaxAbove == 0 && uiSlopeMaxLeft == 0 ) 
4081  { 
4082    return false; 
4083  }
4084
4085  if( uiSlopeMaxAbove > uiSlopeMaxLeft )
4086  {
4087    ruiStartPosX = uiPosSlopeMaxAbove;
4088    ruiStartPosY = 0;
4089  }
4090  else
4091  {
4092    ruiStartPosX = 0;
4093    ruiStartPosY = uiPosSlopeMaxLeft;
4094  }
4095
4096  // 2nd step: derive wedge direction
4097  Int uiPreds[3] = {-1, -1, -1};
4098  Int iMode = -1;
4099  Int iPredNum = pcCU->getIntraDirLumaPredictor( uiAbsPartIdx, uiPreds, &iMode ); 
4100
4101  UInt uiDirMode = 0;
4102  if( iMode >= 0 ) { iPredNum = iMode; }
4103  if( iPredNum == 1 ) { uiDirMode = uiPreds[0]; }
4104  if( iPredNum == 2 ) { uiDirMode = uiPreds[1]; }
4105
4106  if( uiDirMode < 2 ) { return false; } // no planar & DC
4107
4108  Bool modeHor       = (uiDirMode < 18);
4109  Bool modeVer       = !modeHor;
4110  Int intraPredAngle = modeVer ? (Int)uiDirMode - VER_IDX : modeHor ? -((Int)uiDirMode - HOR_IDX) : 0;
4111  Int absAng         = abs(intraPredAngle);
4112  Int signAng        = intraPredAngle < 0 ? -1 : 1;
4113  Int angTable[9]    = {0,2,5,9,13,17,21,26,32};
4114  absAng             = angTable[absAng];
4115  intraPredAngle     = signAng * absAng;
4116
4117  // 3rd step: set slope for direction
4118  if( modeHor )
4119  {
4120    if( intraPredAngle > 0 )
4121    {
4122      riSlopeX = -32;
4123      riSlopeY = intraPredAngle;
4124    }
4125    else
4126    {
4127      riSlopeX = 32;
4128      riSlopeY = -intraPredAngle;
4129    }
4130  }
4131  else if( modeVer )
4132  {
4133    if( intraPredAngle > 0 )
4134    {
4135      riSlopeX = intraPredAngle;
4136      riSlopeY = -32;
4137    }
4138    else
4139    {
4140      riSlopeX = -intraPredAngle;
4141      riSlopeY = 32;
4142    }
4143  }
4144
4145  return true;
4146}
4147
4148Void TComPrediction::xGetWedgeIntraDirStartEnd( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiBlockSize, Int iDeltaX, Int iDeltaY, UInt uiPMSPosX, UInt uiPMSPosY, UChar& ruhXs, UChar& ruhYs, UChar& ruhXe, UChar& ruhYe, Int iDeltaEnd )
4149{
4150  ruhXs = 0;
4151  ruhYs = 0;
4152  ruhXe = 0;
4153  ruhYe = 0;
4154
4155  // scaling of start pos and block size to wedge resolution
4156  UInt uiScaledStartPosX = 0;
4157  UInt uiScaledStartPosY = 0;
4158  UInt uiScaledBlockSize = 0;
4159  WedgeResolution eWedgeRes = g_aeWedgeResolutionList[(UInt)g_aucConvertToBit[uiBlockSize]];
4160  switch( eWedgeRes )
4161  {
4162  case( DOUBLE_PEL ): { uiScaledStartPosX = (uiPMSPosX>>1); uiScaledStartPosY = (uiPMSPosY>>1); uiScaledBlockSize = (uiBlockSize>>1); break; }
4163  case(   FULL_PEL ): { uiScaledStartPosX =  uiPMSPosX;     uiScaledStartPosY =  uiPMSPosY;     uiScaledBlockSize =  uiBlockSize;     break; }
4164  case(   HALF_PEL ): { uiScaledStartPosX = (uiPMSPosX<<1); uiScaledStartPosY = (uiPMSPosY<<1); uiScaledBlockSize = (uiBlockSize<<1); break; }
4165  }
4166  Int iMaxPos = (Int)uiScaledBlockSize - 1;
4167
4168  // case above
4169  if( uiScaledStartPosX > 0 && uiScaledStartPosY == 0 )
4170  {
4171    ruhXs = (UChar)uiScaledStartPosX;
4172    ruhYs = 0;
4173
4174    if( iDeltaY == 0 )
4175    {
4176      if( iDeltaX < 0 )
4177      {
4178        ruhXe = 0;
4179        ruhYe = (UChar)std::min( std::max( iDeltaEnd, 0 ), iMaxPos );
4180        return;
4181      }
4182      else
4183      {
4184        ruhXe = (UChar)iMaxPos;
4185        ruhYe = (UChar)std::min( std::max( -iDeltaEnd, 0 ), iMaxPos );
4186        std::swap( ruhXs, ruhXe );
4187        std::swap( ruhYs, ruhYe );
4188        return;
4189      }
4190    }
4191
4192    // regular case
4193    Int iVirtualEndX = (Int)ruhXs + roftoi( (Double)iMaxPos * ((Double)iDeltaX / (Double)iDeltaY) );
4194
4195    if( iVirtualEndX < 0 )
4196    {
4197      Int iYe = roftoi( (Double)(0 - (Int)ruhXs) * ((Double)iDeltaY / (Double)iDeltaX) ) + iDeltaEnd;
4198      if( iYe < (Int)uiScaledBlockSize )
4199      {
4200        ruhXe = 0;
4201        ruhYe = (UChar)std::max( iYe, 0 );
4202        return;
4203      }
4204      else
4205      {
4206        ruhXe = (UChar)std::min( (iYe - iMaxPos), iMaxPos );
4207        ruhYe = (UChar)iMaxPos;
4208        return;
4209      }
4210    }
4211    else if( iVirtualEndX > iMaxPos )
4212    {
4213      Int iYe = roftoi( (Double)(iMaxPos - (Int)ruhXs) * ((Double)iDeltaY / (Double)iDeltaX) ) - iDeltaEnd;
4214      if( iYe < (Int)uiScaledBlockSize )
4215      {
4216        ruhXe = (UChar)iMaxPos;
4217        ruhYe = (UChar)std::max( iYe, 0 );
4218        std::swap( ruhXs, ruhXe );
4219        std::swap( ruhYs, ruhYe );
4220        return;
4221      }
4222      else
4223      {
4224        ruhXe = (UChar)std::max( (iMaxPos - (iYe - iMaxPos)), 0 );
4225        ruhYe = (UChar)iMaxPos;
4226        return;
4227      }
4228    }
4229    else
4230    {
4231      Int iXe = iVirtualEndX + iDeltaEnd;
4232      if( iXe < 0 )
4233      {
4234        ruhXe = 0;
4235        ruhYe = (UChar)std::max( (iMaxPos + iXe), 0 );
4236        return;
4237      }
4238      else if( iXe > iMaxPos )
4239      {
4240        ruhXe = (UChar)iMaxPos;
4241        ruhYe = (UChar)std::max( (iMaxPos - (iXe - iMaxPos)), 0 );
4242        std::swap( ruhXs, ruhXe );
4243        std::swap( ruhYs, ruhYe );
4244        return;
4245      }
4246      else
4247      {
4248        ruhXe = (UChar)iXe;
4249        ruhYe = (UChar)iMaxPos;
4250        return;
4251      }
4252    }
4253  }
4254
4255  // case left
4256  if( uiScaledStartPosY > 0 && uiScaledStartPosX == 0 )
4257  {
4258    ruhXs = 0;
4259    ruhYs = (UChar)uiScaledStartPosY;
4260
4261    if( iDeltaX == 0 )
4262    {
4263      if( iDeltaY < 0 )
4264      {
4265        ruhXe = (UChar)std::min( std::max( -iDeltaEnd, 0 ), iMaxPos );
4266        ruhYe = 0;
4267        std::swap( ruhXs, ruhXe );
4268        std::swap( ruhYs, ruhYe );
4269        return;
4270      }
4271      else
4272      {
4273        ruhXe = (UChar)std::min( std::max( iDeltaEnd, 0 ), iMaxPos );
4274        ruhYe = (UChar)iMaxPos;
4275        return; 
4276      }
4277    }
4278
4279    // regular case
4280    Int iVirtualEndY = (Int)ruhYs + roftoi( (Double)iMaxPos * ((Double)iDeltaY / (Double)iDeltaX) );
4281
4282    if( iVirtualEndY < 0 )
4283    {
4284      Int iXe = roftoi( (Double)(0 - (Int)ruhYs ) * ((Double)iDeltaX / (Double)iDeltaY) ) - iDeltaEnd;
4285      if( iXe < (Int)uiScaledBlockSize )
4286      {
4287        ruhXe = (UChar)std::max( iXe, 0 );
4288        ruhYe = 0;
4289        std::swap( ruhXs, ruhXe );
4290        std::swap( ruhYs, ruhYe );
4291        return;
4292      }
4293      else
4294      {
4295        ruhXe = (UChar)iMaxPos;
4296        ruhYe = (UChar)std::min( (iXe - iMaxPos), iMaxPos );
4297        std::swap( ruhXs, ruhXe );
4298        std::swap( ruhYs, ruhYe );
4299        return;
4300      }
4301    }
4302    else if( iVirtualEndY > (uiScaledBlockSize-1) )
4303    {
4304      Int iXe = roftoi( (Double)((Int)(uiScaledBlockSize-1) - (Int)ruhYs ) * ((Double)iDeltaX / (Double)iDeltaY) ) + iDeltaEnd;
4305      if( iXe < (Int)uiScaledBlockSize )
4306      {
4307        ruhXe = (UChar)std::max( iXe, 0 );
4308        ruhYe = (UChar)(uiScaledBlockSize-1);
4309        return;
4310      }
4311      else
4312      {
4313        ruhXe = (UChar)iMaxPos;
4314        ruhYe = (UChar)std::max( (iMaxPos - (iXe - iMaxPos)), 0 );
4315        std::swap( ruhXs, ruhXe );
4316        std::swap( ruhYs, ruhYe );
4317        return;
4318      }
4319    }
4320    else
4321    {
4322      Int iYe = iVirtualEndY - iDeltaEnd;
4323      if( iYe < 0 )
4324      {
4325        ruhXe = (UChar)std::max( (iMaxPos + iYe), 0 );
4326        ruhYe = 0;
4327        std::swap( ruhXs, ruhXe );
4328        std::swap( ruhYs, ruhYe );
4329        return;
4330      }
4331      else if( iYe > iMaxPos )
4332      {
4333        ruhXe = (UChar)std::max( (iMaxPos - (iYe - iMaxPos)), 0 );
4334        ruhYe = (UChar)iMaxPos;
4335        return;
4336      }
4337      else
4338      {
4339        ruhXe = (UChar)iMaxPos;
4340        ruhYe = (UChar)iYe;
4341        std::swap( ruhXs, ruhXe );
4342        std::swap( ruhYs, ruhYe );
4343        return;
4344      }
4345    }
4346  }
4347
4348  // case origin
4349  if( uiScaledStartPosX == 0 && uiScaledStartPosY == 0 )
4350  {
4351    if( iDeltaX*iDeltaY < 0 )
4352    {
4353      return;
4354    }
4355
4356    ruhXs = 0;
4357    ruhYs = 0;
4358
4359    if( iDeltaY == 0 )
4360    {
4361      ruhXe = (UChar)iMaxPos;
4362      ruhYe = 0;
4363      std::swap( ruhXs, ruhXe );
4364      std::swap( ruhYs, ruhYe );
4365      return;
4366    }
4367
4368    if( iDeltaX == 0 )
4369    {
4370      ruhXe = 0;
4371      ruhYe = (UChar)iMaxPos;
4372      return;
4373    }
4374
4375    Int iVirtualEndX = (Int)ruhXs + roftoi( (Double)iMaxPos * ((Double)iDeltaX / (Double)iDeltaY) );
4376
4377    if( iVirtualEndX > iMaxPos )
4378    {
4379      Int iYe = roftoi( (Double)((Int)iMaxPos - (Int)ruhXs) * ((Double)iDeltaY / (Double)iDeltaX) ) - iDeltaEnd;
4380      if( iYe < (Int)uiScaledBlockSize )
4381      {
4382        ruhXe = (UChar)(uiScaledBlockSize-1);
4383        ruhYe = (UChar)std::max( iYe, 0 );
4384        std::swap( ruhXs, ruhXe );
4385        std::swap( ruhYs, ruhYe );
4386        return;
4387      }
4388      else
4389      {
4390        ruhXe = (UChar)std::max( (iMaxPos - (iYe - iMaxPos)), 0 );
4391        ruhYe = (UChar)(uiScaledBlockSize-1);
4392        return;
4393      }
4394    }
4395    else
4396    {
4397      Int iXe = iVirtualEndX + iDeltaEnd;
4398      if( iXe < 0 )
4399      {
4400        ruhXe = 0;
4401        ruhYe = (UChar)std::max( (iMaxPos + iXe), 0 );
4402        return;
4403      }
4404      else if( iXe > iMaxPos )
4405      {
4406        ruhXe = (UChar)(uiScaledBlockSize-1);
4407        ruhYe = (UChar)std::max( (iMaxPos - (iXe - iMaxPos)), 0 );
4408        std::swap( ruhXs, ruhXe );
4409        std::swap( ruhYs, ruhYe );
4410        return;
4411      }
4412      else
4413      {
4414        ruhXe = (UChar)iXe;
4415        ruhYe = (UChar)(uiScaledBlockSize-1);
4416        return;
4417      }
4418    }
4419  }
4420}
4421#endif
4422
4423Void
4424TComPrediction::predIntraDepthAng(TComPattern* pcTComPattern, UInt uiDirMode, Pel* piPred, UInt uiStride, Int iWidth, Int iHeight )
4425{
4426  Pel*  pDst    = piPred;
4427  Int*  ptrSrc  = pcTComPattern->getAdiOrgBuf( iWidth, iHeight, m_piYuvExt );
4428  Int   sw      = ( iWidth<<1 ) + 1;
4429  xPredIntraAngDepth( ptrSrc+sw+1, sw, pDst, uiStride, iWidth, iHeight, uiDirMode );
4430}
4431
4432Int
4433TComPrediction::xGetDCDepth( Int* pSrc, Int iDelta, Int iBlkSize )
4434{
4435  Int iDC    = PDM_UNDEFINED_DEPTH;
4436  Int iSum   = 0;
4437  Int iNum   = 0;
4438  for( Int k = 0; k < iBlkSize; k++, pSrc += iDelta )
4439  {
4440    if( *pSrc != PDM_UNDEFINED_DEPTH )
4441    {
4442      iSum += *pSrc;
4443      iNum ++;
4444    }
4445  }
4446  if( iNum )
4447  {
4448    iDC = ( iSum + ( iNum >> 1 ) ) / iNum;
4449  }
4450  return iDC;
4451}
4452
4453Int
4454TComPrediction::xGetDCValDepth( Int iVal1, Int iVal2, Int iVal3, Int iVal4 )
4455{
4456  if     ( iVal1 != PDM_UNDEFINED_DEPTH )   return iVal1;
4457  else if( iVal2 != PDM_UNDEFINED_DEPTH )   return iVal2;
4458  else if( iVal3 != PDM_UNDEFINED_DEPTH )   return iVal3;
4459  return   iVal4;
4460}
4461
4462Void
4463TComPrediction::xPredIntraAngDepth( Int* pSrc, Int srcStride, Pel* pDst, Int dstStride, UInt width, UInt height, UInt dirMode )
4464{
4465  AOF( width == height );
4466  Int blkSize       = width;
4467  Int iDCAbove      = xGetDCDepth( pSrc - srcStride,                               1, blkSize );
4468  Int iDCAboveRight = xGetDCDepth( pSrc - srcStride + blkSize,                     1, blkSize );
4469  Int iDCLeft       = xGetDCDepth( pSrc -         1,                       srcStride, blkSize );
4470  Int iDCBelowLeft  = xGetDCDepth( pSrc -         1 + blkSize * srcStride, srcStride, blkSize );
4471  Int iWgt, iDC1, iDC2;
4472  if( dirMode < 2 ) // 1..2
4473  {
4474    iDC1  = xGetDCValDepth( iDCAbove, iDCAboveRight, iDCLeft,  iDCBelowLeft  );
4475    iDC2  = xGetDCValDepth( iDCLeft,  iDCBelowLeft,  iDCAbove, iDCAboveRight );
4476    iWgt  = 8;
4477  }
4478  else if( dirMode < 11 ) // 3..10
4479  {
4480    iDC1  = xGetDCValDepth( iDCLeft,  iDCBelowLeft,  iDCAbove, iDCAboveRight );
4481    iDC2  = xGetDCValDepth( iDCBelowLeft,  iDCLeft,  iDCAbove, iDCAboveRight );
4482    iWgt  = 6 + dirMode; 
4483  }
4484  else if( dirMode < 27 ) // 11..26
4485  {
4486    iDC1  = xGetDCValDepth( iDCAbove, iDCAboveRight, iDCLeft,  iDCBelowLeft  );
4487    iDC2  = xGetDCValDepth( iDCLeft,  iDCBelowLeft,  iDCAbove, iDCAboveRight );
4488    iWgt  = dirMode - 10;
4489  }
4490  else if( dirMode < 35 ) // 27..34
4491  {
4492    iDC1  = xGetDCValDepth( iDCAbove, iDCAboveRight, iDCLeft,  iDCBelowLeft  );
4493    iDC2  = xGetDCValDepth( iDCAboveRight, iDCAbove, iDCLeft,  iDCBelowLeft  );
4494    iWgt  = 42 - dirMode;
4495  }
4496  else // (wedgelet -> use simple DC prediction
4497  {
4498    iDC1  = xGetDCValDepth( iDCAbove, iDCAboveRight, iDCLeft,  iDCBelowLeft  );
4499    iDC2  = xGetDCValDepth( iDCLeft,  iDCBelowLeft,  iDCAbove, iDCAboveRight );
4500    iWgt  = 8;
4501  }
4502  Int iWgt2   = 16 - iWgt;
4503  Int iDCVal  = ( iWgt * iDC1 + iWgt2 * iDC2 + 8 ) >> 4;
4504
4505  // set depth
4506  for( Int iY = 0; iY < blkSize; iY++, pDst += dstStride )
4507  {
4508    for( Int iX = 0; iX < blkSize; iX++ )
4509    {
4510      pDst[ iX ] = iDCVal;
4511    }
4512  }
4513}
4514
4515//! \}
Note: See TracBrowser for help on using the repository browser.