source: 3DVCSoftware/branches/HTM-14.1-update-dev1-HHI/source/Lib/TLibCommon/TComRdCost.cpp @ 1209

Last change on this file since 1209 was 1209, checked in by hhi, 9 years ago

Alignment and reactivation of DMM and depth encoder optimizations:

  • new macro NH_3D_DMM for DMM functionality, including several clean-ups.
  • new macro NH_3D_SDC for SDC functionality, currently only used for covering common SDC and DMM parts.
  • new macro NH_3D_ENC_DEPTH for encoder optimizations related to depth.
  • temporary macro TEMP_SDC_CLEANUP for covering several proposed cleanups related to SDC and DMM.
  • Property svn:eol-style set to native
File size: 112.1 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-2015, 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     TComRdCost.cpp
35    \brief    RD cost computation class
36*/
37
38#include <math.h>
39#include <assert.h>
40#include <limits>
41#include "TComRom.h"
42#include "TComRdCost.h"
43#if NH_3D
44#include "TComDataCU.h"
45#include "TComRectangle.h"
46#endif
47
48//! \ingroup TLibCommon
49//! \{
50
51#if NH_3D_VSO
52// SAIT_VSO_EST_A0033
53Double TComRdCost::m_dDisparityCoeff = 1.0;
54#endif
55TComRdCost::TComRdCost()
56{
57  init();
58}
59
60TComRdCost::~TComRdCost()
61{
62}
63
64// Calculate RD functions
65#if NH_3D_VSO
66Double TComRdCost::calcRdCost( UInt uiBits, Dist uiDistortion, Bool bFlag, DFunc eDFunc )
67#else
68Double TComRdCost::calcRdCost( UInt uiBits, Distortion uiDistortion, Bool bFlag, DFunc eDFunc )
69#endif
70{
71  Double dRdCost = 0.0;
72  Double dLambda = 0.0;
73
74  switch ( eDFunc )
75  {
76    case DF_SSE:
77      assert(0);
78      break;
79    case DF_SAD:
80#if RExt__HIGH_BIT_DEPTH_SUPPORT
81      dLambda = m_dLambdaMotionSAD[0]; // 0 is valid, because for lossless blocks, the cost equation is modified to compensate.
82#else
83      dLambda = (Double)m_uiLambdaMotionSAD[0]; // 0 is valid, because for lossless blocks, the cost equation is modified to compensate.
84#endif
85      break;
86    case DF_DEFAULT:
87      dLambda =         m_dLambda;
88      break;
89    case DF_SSE_FRAME:
90      dLambda =         m_dFrameLambda;
91      break;
92    default:
93      assert (0);
94      break;
95  }
96
97  if (bFlag) //NOTE: this "bFlag" is never true
98  {
99    // Intra8x8, Intra4x4 Block only...
100    if (m_costMode != COST_STANDARD_LOSSY)
101    {
102      dRdCost = (Double(uiDistortion) / dLambda) + Double(uiBits); // all lossless costs would have uiDistortion=0, and therefore this cost function can be used.
103    }
104    else
105    {
106      dRdCost = (((Double)uiDistortion) + ((Double)uiBits * dLambda));
107    }
108  }
109  else
110  {
111    if (eDFunc == DF_SAD)
112    {
113      if (m_costMode != COST_STANDARD_LOSSY)
114      {
115        dRdCost = ((Double(uiDistortion) * 65536) / dLambda) + Double(uiBits); // all lossless costs would have uiDistortion=0, and therefore this cost function can be used.
116      }
117      else
118      {
119        dRdCost = floor(Double(uiDistortion) + (floor((Double(uiBits) * dLambda) + 0.5) / 65536.0));
120      }
121    }
122    else
123    {
124      if (m_costMode != COST_STANDARD_LOSSY)
125      {
126        dRdCost = (Double(uiDistortion) / dLambda) + Double(uiBits); // all lossless costs would have uiDistortion=0, and therefore this cost function can be used.
127      }
128      else
129      {
130        dRdCost = floor(Double(uiDistortion) + (Double(uiBits) * dLambda) + 0.5);
131      }
132    }
133  }
134
135  return dRdCost;
136}
137
138#if NH_3D_VSO
139Double TComRdCost::calcRdCost64( UInt64 uiBits, Dist64 uiDistortion, Bool bFlag, DFunc eDFunc )
140#else
141Double TComRdCost::calcRdCost64( UInt64 uiBits, UInt64 uiDistortion, Bool bFlag, DFunc eDFunc )
142#endif
143{
144  Double dRdCost = 0.0;
145  Double dLambda = 0.0;
146
147  switch ( eDFunc )
148  {
149    case DF_SSE:
150      assert(0);
151      break;
152    case DF_SAD:
153#if RExt__HIGH_BIT_DEPTH_SUPPORT
154      dLambda = m_dLambdaMotionSAD[0]; // 0 is valid, because for lossless blocks, the cost equation is modified to compensate.
155#else
156      dLambda = (Double)m_uiLambdaMotionSAD[0]; // 0 is valid, because for lossless blocks, the cost equation is modified to compensate.
157#endif
158      break;
159    case DF_DEFAULT:
160      dLambda =         m_dLambda;
161      break;
162    case DF_SSE_FRAME:
163      dLambda =         m_dFrameLambda;
164      break;
165    default:
166      assert (0);
167      break;
168  }
169
170  if (bFlag) //NOTE: this "bFlag" is never true
171  {
172    // Intra8x8, Intra4x4 Block only...
173    if (m_costMode != COST_STANDARD_LOSSY)
174    {
175      dRdCost = (Double(uiDistortion) / dLambda) + Double(uiBits); // all lossless costs would have uiDistortion=0, and therefore this cost function can be used.
176    }
177    else
178    {
179      dRdCost = (((Double)(Int64)uiDistortion) + ((Double)(Int64)uiBits * dLambda));
180    }
181  }
182  else
183  {
184    if (eDFunc == DF_SAD)
185    {
186      if (m_costMode != COST_STANDARD_LOSSY)
187      {
188        dRdCost = ((Double(uiDistortion) * 65536) / dLambda) + Double(uiBits); // all lossless costs would have uiDistortion=0, and therefore this cost function can be used.
189      }
190      else
191      {
192        dRdCost = floor(Double(uiDistortion) + (floor((Double(uiBits) * dLambda) + 0.5) / 65536.0));
193      }
194    }
195    else
196    {
197      if (m_costMode != COST_STANDARD_LOSSY)
198      {
199        dRdCost = (Double(uiDistortion) / dLambda) + Double(uiBits); // all lossless costs would have uiDistortion=0, and therefore this cost function can be used.
200      }
201      else
202      {
203        dRdCost = floor(Double(uiDistortion) + (Double(uiBits) * dLambda) + 0.5);
204      }
205    }
206  }
207
208  return dRdCost;
209}
210
211Void TComRdCost::setLambda( Double dLambda, const BitDepths &bitDepths )
212{
213  m_dLambda           = dLambda;
214  m_sqrtLambda        = sqrt(m_dLambda);
215#if RExt__HIGH_BIT_DEPTH_SUPPORT
216  m_dLambdaMotionSAD[0] = 65536.0 * m_sqrtLambda;
217  m_dLambdaMotionSSE[0] = 65536.0 * m_dLambda;
218#if FULL_NBIT
219  dLambda = 0.57 * pow(2.0, ((LOSSLESS_AND_MIXED_LOSSLESS_RD_COST_TEST_QP_PRIME - 12) / 3.0));
220#else
221  dLambda = 0.57 * pow(2.0, ((LOSSLESS_AND_MIXED_LOSSLESS_RD_COST_TEST_QP_PRIME - 12 - 6 * (bitDepths.recon[CHANNEL_TYPE_LUMA] - 8)) / 3.0));
222#endif
223  m_dLambdaMotionSAD[1] = 65536.0 * sqrt(dLambda);
224  m_dLambdaMotionSSE[1] = 65536.0 * dLambda;
225#else
226  m_uiLambdaMotionSAD[0] = (UInt)floor(65536.0 * m_sqrtLambda);
227  m_uiLambdaMotionSSE[0] = (UInt)floor(65536.0 * m_dLambda   );
228#if FULL_NBIT
229  dLambda = 0.57 * pow(2.0, ((LOSSLESS_AND_MIXED_LOSSLESS_RD_COST_TEST_QP_PRIME - 12) / 3.0));
230#else
231  dLambda = 0.57 * pow(2.0, ((LOSSLESS_AND_MIXED_LOSSLESS_RD_COST_TEST_QP_PRIME - 12 - 6 * (bitDepths.recon[CHANNEL_TYPE_LUMA] - 8)) / 3.0));
232#endif
233  m_uiLambdaMotionSAD[1] = (UInt)floor(65536.0 * sqrt(dLambda));
234  m_uiLambdaMotionSSE[1] = (UInt)floor(65536.0 * dLambda   );
235#endif
236}
237
238
239// Initalize Function Pointer by [eDFunc]
240Void TComRdCost::init()
241{
242  m_afpDistortFunc[DF_DEFAULT] = NULL;                  // for DF_DEFAULT
243
244  m_afpDistortFunc[DF_SSE    ] = TComRdCost::xGetSSE;
245  m_afpDistortFunc[DF_SSE4   ] = TComRdCost::xGetSSE4;
246  m_afpDistortFunc[DF_SSE8   ] = TComRdCost::xGetSSE8;
247  m_afpDistortFunc[DF_SSE16  ] = TComRdCost::xGetSSE16;
248  m_afpDistortFunc[DF_SSE32  ] = TComRdCost::xGetSSE32;
249  m_afpDistortFunc[DF_SSE64  ] = TComRdCost::xGetSSE64;
250  m_afpDistortFunc[DF_SSE16N ] = TComRdCost::xGetSSE16N;
251
252  m_afpDistortFunc[DF_SAD    ] = TComRdCost::xGetSAD;
253  m_afpDistortFunc[DF_SAD4   ] = TComRdCost::xGetSAD4;
254  m_afpDistortFunc[DF_SAD8   ] = TComRdCost::xGetSAD8;
255  m_afpDistortFunc[DF_SAD16  ] = TComRdCost::xGetSAD16;
256  m_afpDistortFunc[DF_SAD32  ] = TComRdCost::xGetSAD32;
257  m_afpDistortFunc[DF_SAD64  ] = TComRdCost::xGetSAD64;
258  m_afpDistortFunc[DF_SAD16N ] = TComRdCost::xGetSAD16N;
259
260  m_afpDistortFunc[DF_SADS   ] = TComRdCost::xGetSAD;
261  m_afpDistortFunc[DF_SADS4  ] = TComRdCost::xGetSAD4;
262  m_afpDistortFunc[DF_SADS8  ] = TComRdCost::xGetSAD8;
263  m_afpDistortFunc[DF_SADS16 ] = TComRdCost::xGetSAD16;
264  m_afpDistortFunc[DF_SADS32 ] = TComRdCost::xGetSAD32;
265  m_afpDistortFunc[DF_SADS64 ] = TComRdCost::xGetSAD64;
266  m_afpDistortFunc[DF_SADS16N] = TComRdCost::xGetSAD16N;
267
268  m_afpDistortFunc[DF_SAD12  ] = TComRdCost::xGetSAD12;
269  m_afpDistortFunc[DF_SAD24  ] = TComRdCost::xGetSAD24;
270  m_afpDistortFunc[DF_SAD48  ] = TComRdCost::xGetSAD48;
271
272  m_afpDistortFunc[DF_SADS12 ] = TComRdCost::xGetSAD12;
273  m_afpDistortFunc[DF_SADS24 ] = TComRdCost::xGetSAD24;
274  m_afpDistortFunc[DF_SADS48 ] = TComRdCost::xGetSAD48;
275
276  m_afpDistortFunc[DF_HADS   ] = TComRdCost::xGetHADs;
277  m_afpDistortFunc[DF_HADS4  ] = TComRdCost::xGetHADs;
278  m_afpDistortFunc[DF_HADS8  ] = TComRdCost::xGetHADs;
279  m_afpDistortFunc[DF_HADS16 ] = TComRdCost::xGetHADs;
280  m_afpDistortFunc[DF_HADS32 ] = TComRdCost::xGetHADs;
281  m_afpDistortFunc[DF_HADS64 ] = TComRdCost::xGetHADs;
282  m_afpDistortFunc[DF_HADS16N] = TComRdCost::xGetHADs;
283
284#if NH_3D_VSO
285  // SAIT_VSO_EST_A0033
286  m_afpDistortFunc[29]  = TComRdCost::xGetVSD;
287  m_afpDistortFunc[30]  = TComRdCost::xGetVSD4;
288  m_afpDistortFunc[31]  = TComRdCost::xGetVSD8;
289  m_afpDistortFunc[32]  = TComRdCost::xGetVSD16;
290  m_afpDistortFunc[33]  = TComRdCost::xGetVSD32;
291  m_afpDistortFunc[34]  = TComRdCost::xGetVSD64;
292  m_afpDistortFunc[35]  = TComRdCost::xGetVSD16N;
293#endif
294
295  m_costMode                   = COST_STANDARD_LOSSY;
296
297#if RExt__HIGH_BIT_DEPTH_SUPPORT
298  m_dCost                      = 0;
299#else
300  m_uiCost                     = 0;
301#endif
302  m_iCostScale                 = 0;
303
304#if NH_3D_VSO
305  m_bUseVSO                 = false;
306  m_uiVSOMode               = 0; 
307  m_fpDistortFuncVSO        = NULL; 
308  m_pcRenModel              = NULL; 
309
310  // SAIT_VSO_EST_A0033
311  m_bUseEstimatedVSD        = false; 
312#endif
313#if H_3D_DBBP
314  m_bUseMask                = false;
315#endif
316
317}
318
319// Static member function
320UInt TComRdCost::xGetExpGolombNumberOfBits( Int iVal )
321{
322  assert(iVal != std::numeric_limits<Int>::min());
323  UInt uiLength = 1;
324  UInt uiTemp   = ( iVal <= 0) ? (UInt(-iVal)<<1)+1: UInt(iVal<<1);
325
326  while ( 1 != uiTemp )
327  {
328    uiTemp >>= 1;
329    uiLength += 2;
330  }
331
332  return uiLength;
333}
334
335Void TComRdCost::setDistParam( UInt uiBlkWidth, UInt uiBlkHeight, DFunc eDFunc, DistParam& rcDistParam )
336{
337  // set Block Width / Height
338  rcDistParam.iCols    = uiBlkWidth;
339  rcDistParam.iRows    = uiBlkHeight;
340  rcDistParam.DistFunc = m_afpDistortFunc[eDFunc + g_aucConvertToBit[ rcDistParam.iCols ] + 1 ];
341
342#if H_3D_DBBP
343  if( m_bUseMask )
344  {
345    if( eDFunc >= DF_SSE && eDFunc <= DF_SSE16N )
346    {
347      rcDistParam.DistFunc = TComRdCost::xGetMaskedSSE;
348    }
349    else if( eDFunc >= DF_SAD && eDFunc <= DF_SADS16N )
350    {
351      rcDistParam.DistFunc = TComRdCost::xGetMaskedSAD;
352    }
353    else if( eDFunc >= DF_HADS && eDFunc <= DF_HADS16N )
354    {
355      rcDistParam.DistFunc = TComRdCost::xGetMaskedSAD;
356    }
357    else if( eDFunc >= DF_VSD && eDFunc <= DF_VSD16N )
358    {
359      rcDistParam.DistFunc = TComRdCost::xGetMaskedVSD;
360    }
361    else if( eDFunc >= DF_SAD12 && eDFunc <= DF_SADS48 )
362    {
363      rcDistParam.DistFunc = TComRdCost::xGetMaskedSAD;
364    }
365  }
366#endif
367  // initialize
368  rcDistParam.iSubShift  = 0;
369}
370
371// Setting the Distortion Parameter for Inter (ME)
372Void TComRdCost::setDistParam( TComPattern* pcPatternKey, Pel* piRefY, Int iRefStride, DistParam& rcDistParam )
373{
374  // set Original & Curr Pointer / Stride
375  rcDistParam.pOrg = pcPatternKey->getROIY();
376  rcDistParam.pCur = piRefY;
377
378  rcDistParam.iStrideOrg = pcPatternKey->getPatternLStride();
379  rcDistParam.iStrideCur = iRefStride;
380
381  // set Block Width / Height
382  rcDistParam.iCols    = pcPatternKey->getROIYWidth();
383  rcDistParam.iRows    = pcPatternKey->getROIYHeight();
384  rcDistParam.DistFunc = m_afpDistortFunc[DF_SAD + g_aucConvertToBit[ rcDistParam.iCols ] + 1 ];
385
386  if (rcDistParam.iCols == 12)
387  {
388    rcDistParam.DistFunc = m_afpDistortFunc[DF_SAD12];
389  }
390  else if (rcDistParam.iCols == 24)
391  {
392    rcDistParam.DistFunc = m_afpDistortFunc[DF_SAD24];
393  }
394  else if (rcDistParam.iCols == 48)
395  {
396    rcDistParam.DistFunc = m_afpDistortFunc[DF_SAD48];
397  }
398
399#if H_3D_DBBP
400  if( m_bUseMask )
401  {
402    rcDistParam.DistFunc = TComRdCost::xGetMaskedSAD;
403  }
404#endif
405  // initialize
406  rcDistParam.iSubShift  = 0;
407}
408
409// Setting the Distortion Parameter for Inter (subpel ME with step)
410Void TComRdCost::setDistParam( TComPattern* pcPatternKey, Pel* piRefY, Int iRefStride, Int iStep, DistParam& rcDistParam, Bool bHADME )
411{
412  // set Original & Curr Pointer / Stride
413  rcDistParam.pOrg = pcPatternKey->getROIY();
414  rcDistParam.pCur = piRefY;
415
416  rcDistParam.iStrideOrg = pcPatternKey->getPatternLStride();
417  rcDistParam.iStrideCur = iRefStride * iStep;
418
419  // set Step for interpolated buffer
420  rcDistParam.iStep = iStep;
421
422  // set Block Width / Height
423  rcDistParam.iCols    = pcPatternKey->getROIYWidth();
424  rcDistParam.iRows    = pcPatternKey->getROIYHeight();
425
426  // set distortion function
427  if ( !bHADME )
428  {
429    rcDistParam.DistFunc = m_afpDistortFunc[DF_SADS + g_aucConvertToBit[ rcDistParam.iCols ] + 1 ];
430    if (rcDistParam.iCols == 12)
431    {
432      rcDistParam.DistFunc = m_afpDistortFunc[DF_SADS12];
433    }
434    else if (rcDistParam.iCols == 24)
435    {
436      rcDistParam.DistFunc = m_afpDistortFunc[DF_SADS24];
437    }
438    else if (rcDistParam.iCols == 48)
439    {
440      rcDistParam.DistFunc = m_afpDistortFunc[DF_SADS48];
441    }
442  }
443  else
444  {
445    rcDistParam.DistFunc = m_afpDistortFunc[DF_HADS + g_aucConvertToBit[ rcDistParam.iCols ] + 1 ];
446  }
447
448#if H_3D_DBBP
449  if( m_bUseMask )
450  {
451    rcDistParam.DistFunc = TComRdCost::xGetMaskedSAD;
452  }
453#endif
454  // initialize
455  rcDistParam.iSubShift  = 0;
456}
457
458Void TComRdCost::setDistParam( DistParam& rcDP, Int bitDepth, Pel* p1, Int iStride1, Pel* p2, Int iStride2, Int iWidth, Int iHeight, Bool bHadamard )
459{
460  rcDP.pOrg       = p1;
461  rcDP.pCur       = p2;
462  rcDP.iStrideOrg = iStride1;
463  rcDP.iStrideCur = iStride2;
464  rcDP.iCols      = iWidth;
465  rcDP.iRows      = iHeight;
466  rcDP.iStep      = 1;
467  rcDP.iSubShift  = 0;
468  rcDP.bitDepth   = bitDepth;
469  rcDP.DistFunc   = m_afpDistortFunc[ ( bHadamard ? DF_HADS : DF_SADS ) + g_aucConvertToBit[ iWidth ] + 1 ];
470#if H_3D_DBBP
471  if( m_bUseMask )
472  {
473    rcDP.DistFunc = TComRdCost::xGetMaskedSAD;
474  }
475#endif
476}
477
478Distortion TComRdCost::calcHAD( Int bitDepth, Pel* pi0, Int iStride0, Pel* pi1, Int iStride1, Int iWidth, Int iHeight )
479{
480  Distortion uiSum = 0;
481  Int x, y;
482
483  if ( ( (iWidth % 8) == 0 ) && ( (iHeight % 8) == 0 ) )
484  {
485    for ( y=0; y<iHeight; y+= 8 )
486    {
487      for ( x=0; x<iWidth; x+= 8 )
488      {
489        uiSum += xCalcHADs8x8( &pi0[x], &pi1[x], iStride0, iStride1, 1 );
490      }
491      pi0 += iStride0*8;
492      pi1 += iStride1*8;
493    }
494  }
495  else
496  {
497    assert ( ( (iWidth % 4) == 0 ) && ( (iHeight % 4) == 0 ) );
498
499    for ( y=0; y<iHeight; y+= 4 )
500    {
501      for ( x=0; x<iWidth; x+= 4 )
502      {
503        uiSum += xCalcHADs4x4( &pi0[x], &pi1[x], iStride0, iStride1, 1 );
504      }
505      pi0 += iStride0*4;
506      pi1 += iStride1*4;
507    }
508  }
509
510  return ( uiSum >> DISTORTION_PRECISION_ADJUSTMENT(bitDepth-8) );
511}
512
513#if NH_3D_ENC_DEPTH
514UInt TComRdCost::calcVAR (Pel* pi0, Int stride, Int width, Int height, Int cuDepth, UInt maxCuWidth)
515{ 
516  Int temp = 0;
517
518  for (Int y = 0; y < height; y++)
519  {
520    for (Int x = 0; x < width; x++)
521    {
522      temp += pi0[ y * stride + x ]; 
523    }
524  }
525
526  Int cuMaxLog2Size = g_aucConvertToBit[maxCuWidth]+2;
527 
528  if ( width == 4 ) 
529  {
530    cuDepth = cuMaxLog2Size - 2;
531  }
532
533  temp = temp >> (cuMaxLog2Size-cuDepth) * 2;
534
535  UInt sum = 0;
536  for (Int y = 0; y < height; y++)
537  {
538    for (Int x = 0; x <  width; x++)
539    {
540      sum += (pi0[ y * stride + x ] - temp ) * (pi0[ y * stride + x ] - temp );
541    }
542  }
543  return (sum >> (cuMaxLog2Size-cuDepth)*2);
544
545}
546#endif
547
548
549Distortion TComRdCost::getDistPart( Int bitDepth, Pel* piCur, Int iCurStride,  Pel* piOrg, Int iOrgStride, UInt uiBlkWidth, UInt uiBlkHeight, const ComponentID compID, DFunc eDFunc )
550{
551  DistParam cDtParam;
552  setDistParam( uiBlkWidth, uiBlkHeight, eDFunc, cDtParam );
553  cDtParam.pOrg       = piOrg;
554  cDtParam.pCur       = piCur;
555  cDtParam.iStrideOrg = iOrgStride;
556  cDtParam.iStrideCur = iCurStride;
557  cDtParam.iStep      = 1;
558
559  cDtParam.bApplyWeight = false;
560  cDtParam.compIdx      = MAX_NUM_COMPONENT; // just for assert: to be sure it was set before use
561  cDtParam.bitDepth     = bitDepth;
562
563#if H_3D_IC
564  cDtParam.bUseIC       = false;
565#endif
566#if H_3D_INTER_SDC
567  cDtParam.bUseSDCMRSAD = false;
568#endif
569
570  if (isChroma(compID))
571  {
572    return ((Distortion) (m_distortionWeight[compID] * cDtParam.DistFunc( &cDtParam )));
573  }
574  else
575  {
576    return cDtParam.DistFunc( &cDtParam );
577  }
578}
579#if NH_3D_VSO
580// SAIT_VSO_EST_A0033
581UInt TComRdCost::getDistPartVSD( TComDataCU* pcCU, UInt uiPartOffset, Int bitDepth, Pel* piCur, Int iCurStride,  Pel* piOrg, Int iOrgStride, UInt uiBlkWidth, UInt uiBlkHeight,  Bool bHAD, DFunc eDFunc )
582{
583  AOT( ( m_dDisparityCoeff <= 0 ) || ( m_dDisparityCoeff > 10 ) );
584
585  Pel* piVirRec  = m_pcVideoRecPicYuv->getAddr( COMPONENT_Y, pcCU->getCtuRsAddr( ), pcCU->getZorderIdxInCtu()+uiPartOffset ); 
586  Pel* piVirOrg  = m_pcDepthPicYuv   ->getAddr( COMPONENT_Y, pcCU->getCtuRsAddr( ), pcCU->getZorderIdxInCtu()+uiPartOffset ); 
587  Int iVirStride = m_pcVideoRecPicYuv->getStride( COMPONENT_Y );   
588
589  DistParam cDtParam;
590  setDistParam( uiBlkWidth, uiBlkHeight, eDFunc, cDtParam );
591  cDtParam.pOrg       = piOrg;
592  cDtParam.pCur       = piCur;
593  cDtParam.pVirRec    = piVirRec;
594  cDtParam.pVirOrg    = piVirOrg;
595  cDtParam.iStrideVir = iVirStride;
596  cDtParam.iStrideOrg = iOrgStride;
597  cDtParam.iStrideCur = iCurStride;
598  cDtParam.iStep      = 1;
599
600  cDtParam.bApplyWeight = false; 
601
602  cDtParam.bitDepth   = bitDepth;
603
604  Dist dist = cDtParam.DistFunc( &cDtParam );
605
606  if ( m_bUseWVSO )   
607  {
608    Int iDWeight   = m_iDWeight   * m_iDWeight;
609    Int iVSOWeight = m_iVSDWeight * m_iVSDWeight;
610    Dist distDepth;
611
612    if ( !bHAD )
613    {
614      distDepth = (Dist) getDistPart( bitDepth, piCur, iCurStride, piOrg, iOrgStride, uiBlkWidth, uiBlkHeight, COMPONENT_Y);
615    }
616    else
617    {
618      distDepth = (Dist) calcHAD( bitDepth, piCur, iCurStride, piOrg, iOrgStride, uiBlkWidth, uiBlkHeight);
619    }
620
621    dist = (Dist) (iDWeight * distDepth + iVSOWeight * dist ) / ( iDWeight + iVSOWeight);
622  }
623
624  return (UInt) dist; 
625}
626#endif
627
628#if KWU_RC_MADPRED_E0227
629UInt TComRdCost::getSADPart ( Int bitDepth, Pel* pelCur, Int curStride,  Pel* pelOrg, Int orgStride, UInt width, UInt height )
630{
631  UInt SAD = 0;
632  Int shift = DISTORTION_PRECISION_ADJUSTMENT(bitDepth-8);
633  for ( Int i=0; i<height; i++ )
634  {
635    for( Int j=0; j<width; j++ )
636    {
637      SAD += abs((pelCur[j] - pelOrg[j])) >> shift;
638    }
639    pelCur = pelCur + curStride;
640    pelOrg = pelOrg + orgStride;
641  }
642  return SAD;
643}
644#endif
645
646// ====================================================================================================================
647// Distortion functions
648// ====================================================================================================================
649
650#if H_3D_DBBP
651// --------------------------------------------------------------------------------------------------------------------
652// Masked distortion functions
653// --------------------------------------------------------------------------------------------------------------------
654
655UInt TComRdCost::xGetMaskedSSE( DistParam* pcDtParam )
656{
657  Pel* piOrg   = pcDtParam->pOrg;
658  Pel* piCur   = pcDtParam->pCur;
659  Int  iRows   = pcDtParam->iRows;
660  Int  iCols   = pcDtParam->iCols;
661  Int  iStrideOrg = pcDtParam->iStrideOrg;
662  Int  iStrideCur = pcDtParam->iStrideCur;
663 
664  UInt uiSum = 0;
665 
666  UInt uiShift = DISTORTION_PRECISION_ADJUSTMENT((pcDtParam->bitDepth-8) << 1);
667 
668  Int iTemp;
669 
670  for( ; iRows != 0; iRows-- )
671  {
672    for (Int n = 0; n < iCols; n++ )
673    {
674      if( piOrg[n] != DBBP_INVALID_SHORT )
675      {
676        iTemp = piOrg[n  ] - piCur[n  ];
677        uiSum += ( iTemp * iTemp ) >> uiShift;
678      }
679    }
680    piOrg += iStrideOrg;
681    piCur += iStrideCur;
682  }
683 
684  return ( uiSum );
685}
686
687UInt TComRdCost::xGetMaskedSAD( DistParam* pcDtParam )
688{
689 
690  AOF(!pcDtParam->bApplyWeight);
691#if H_3D_IC
692  AOF(!pcDtParam->bUseIC);
693#endif
694 
695  Pel* piOrg   = pcDtParam->pOrg;
696  Pel* piCur   = pcDtParam->pCur;
697  Int  iRows   = pcDtParam->iRows;
698  Int  iCols   = pcDtParam->iCols;
699  Int  iStrideCur = pcDtParam->iStrideCur;
700  Int  iStrideOrg = pcDtParam->iStrideOrg;
701 
702  UInt uiSum = 0;
703 
704  for( ; iRows != 0; iRows-- )
705  {
706    for (Int n = 0; n < iCols; n++ )
707    {
708      if( piOrg[n] != DBBP_INVALID_SHORT )
709      {
710        uiSum += abs( piOrg[n] - piCur[n] );
711      }
712    }
713    piOrg += iStrideOrg;
714    piCur += iStrideCur;
715  }
716 
717  return uiSum >> DISTORTION_PRECISION_ADJUSTMENT(pcDtParam->bitDepth-8);
718}
719
720
721UInt TComRdCost::xGetMaskedVSD( DistParam* pcDtParam )
722{
723  Pel* piOrg    = pcDtParam->pOrg;
724  Pel* piCur    = pcDtParam->pCur;
725  Pel* piVirRec = pcDtParam->pVirRec;
726  Pel* piVirOrg = pcDtParam->pVirOrg;
727  Int  iRows    = pcDtParam->iRows;
728  Int  iCols    = pcDtParam->iCols;
729  Int  iStrideOrg = pcDtParam->iStrideOrg;
730  Int  iStrideCur = pcDtParam->iStrideCur;
731  Int  iStrideVir = pcDtParam->iStrideVir;
732 
733  UInt uiSum = 0;
734  UInt uiShift = DISTORTION_PRECISION_ADJUSTMENT(pcDtParam->bitDepth-8)<<1;
735 
736  Int dDM;
737 
738  for ( Int y = 0 ; y < iRows ; y++ )
739  {
740    for (Int x = 0; x < iCols; x++ )
741    {
742      if( piOrg[x] != DBBP_INVALID_SHORT )
743      {
744        dDM = (Int) ( piOrg[x  ] - piCur[x  ] );
745        uiSum += getVSDEstimate( dDM, piOrg, iStrideOrg, piVirRec, piVirOrg, iStrideVir, x, y ) >> uiShift;
746      }
747    }
748    piOrg += iStrideOrg;
749    piCur += iStrideCur;
750  }
751 
752  return ( uiSum );
753}
754#endif
755// --------------------------------------------------------------------------------------------------------------------
756// SAD
757// --------------------------------------------------------------------------------------------------------------------
758
759Distortion TComRdCost::xGetSAD( DistParam* pcDtParam )
760{
761  if ( pcDtParam->bApplyWeight )
762  {
763    return TComRdCostWeightPrediction::xGetSADw( pcDtParam );
764  }
765#if H_3D_IC
766  if( pcDtParam->bUseIC )
767  {
768    return xGetSADic( pcDtParam );
769  }
770#endif
771#if H_3D_INTER_SDC
772  if( pcDtParam->bUseSDCMRSAD )
773  {
774    return xGetSADic( pcDtParam );
775  }
776#endif
777
778  const Pel* piOrg   = pcDtParam->pOrg;
779  const Pel* piCur   = pcDtParam->pCur;
780  Int  iRows   = pcDtParam->iRows;
781  Int  iCols   = pcDtParam->iCols;
782  Int  iStrideCur = pcDtParam->iStrideCur;
783  Int  iStrideOrg = pcDtParam->iStrideOrg;
784
785  Distortion uiSum = 0;
786
787  for( ; iRows != 0; iRows-- )
788  {
789    for (Int n = 0; n < iCols; n++ )
790    {
791      uiSum += abs( piOrg[n] - piCur[n] );
792    }
793    piOrg += iStrideOrg;
794    piCur += iStrideCur;
795  }
796
797  return ( uiSum >> DISTORTION_PRECISION_ADJUSTMENT(pcDtParam->bitDepth-8) );
798}
799
800Distortion TComRdCost::xGetSAD4( DistParam* pcDtParam )
801{
802  if ( pcDtParam->bApplyWeight )
803  {
804    return TComRdCostWeightPrediction::xGetSADw( pcDtParam );
805  }
806
807#if H_3D_IC
808  if( pcDtParam->bUseIC )
809  {
810    return xGetSAD4ic( pcDtParam );
811  }
812#endif
813#if H_3D_INTER_SDC
814  if( pcDtParam->bUseSDCMRSAD )
815  {
816    return xGetSAD4ic( pcDtParam );
817  }
818#endif
819
820  const Pel* piOrg   = pcDtParam->pOrg;
821  const Pel* piCur   = pcDtParam->pCur;
822  Int  iRows   = pcDtParam->iRows;
823  Int  iSubShift  = pcDtParam->iSubShift;
824  Int  iSubStep   = ( 1 << iSubShift );
825  Int  iStrideCur = pcDtParam->iStrideCur*iSubStep;
826  Int  iStrideOrg = pcDtParam->iStrideOrg*iSubStep;
827
828  Distortion uiSum = 0;
829
830  for( ; iRows != 0; iRows-=iSubStep )
831  {
832    uiSum += abs( piOrg[0] - piCur[0] );
833    uiSum += abs( piOrg[1] - piCur[1] );
834    uiSum += abs( piOrg[2] - piCur[2] );
835    uiSum += abs( piOrg[3] - piCur[3] );
836
837    piOrg += iStrideOrg;
838    piCur += iStrideCur;
839  }
840
841  uiSum <<= iSubShift;
842  return ( uiSum >> DISTORTION_PRECISION_ADJUSTMENT(pcDtParam->bitDepth-8) );
843}
844
845Distortion TComRdCost::xGetSAD8( DistParam* pcDtParam )
846{
847  if ( pcDtParam->bApplyWeight )
848  {
849    return TComRdCostWeightPrediction::xGetSADw( pcDtParam );
850  }
851
852#if H_3D_IC
853  if( pcDtParam->bUseIC )
854  {
855    return xGetSAD8ic( pcDtParam );
856  }
857#endif
858#if H_3D_INTER_SDC
859  if( pcDtParam->bUseSDCMRSAD )
860  {
861    return xGetSAD8ic( pcDtParam );
862  }
863#endif
864
865  const Pel* piOrg      = pcDtParam->pOrg;
866  const Pel* piCur      = pcDtParam->pCur;
867  Int  iRows      = pcDtParam->iRows;
868  Int  iSubShift  = pcDtParam->iSubShift;
869  Int  iSubStep   = ( 1 << iSubShift );
870  Int  iStrideCur = pcDtParam->iStrideCur*iSubStep;
871  Int  iStrideOrg = pcDtParam->iStrideOrg*iSubStep;
872
873  Distortion uiSum = 0;
874
875  for( ; iRows != 0; iRows-=iSubStep )
876  {
877    uiSum += abs( piOrg[0] - piCur[0] );
878    uiSum += abs( piOrg[1] - piCur[1] );
879    uiSum += abs( piOrg[2] - piCur[2] );
880    uiSum += abs( piOrg[3] - piCur[3] );
881    uiSum += abs( piOrg[4] - piCur[4] );
882    uiSum += abs( piOrg[5] - piCur[5] );
883    uiSum += abs( piOrg[6] - piCur[6] );
884    uiSum += abs( piOrg[7] - piCur[7] );
885
886    piOrg += iStrideOrg;
887    piCur += iStrideCur;
888  }
889
890  uiSum <<= iSubShift;
891  return ( uiSum >> DISTORTION_PRECISION_ADJUSTMENT(pcDtParam->bitDepth-8) );
892}
893
894Distortion TComRdCost::xGetSAD16( DistParam* pcDtParam )
895{
896  if ( pcDtParam->bApplyWeight )
897  {
898    return TComRdCostWeightPrediction::xGetSADw( pcDtParam );
899  }
900
901#if H_3D_IC
902  if( pcDtParam->bUseIC )
903  {
904    return xGetSAD16ic( pcDtParam );
905  }
906#endif
907#if H_3D_INTER_SDC
908  if( pcDtParam->bUseSDCMRSAD )
909  {
910    return xGetSAD16ic( pcDtParam );
911  }
912#endif
913
914  const Pel* piOrg   = pcDtParam->pOrg;
915  const Pel* piCur   = pcDtParam->pCur;
916  Int  iRows   = pcDtParam->iRows;
917  Int  iSubShift  = pcDtParam->iSubShift;
918  Int  iSubStep   = ( 1 << iSubShift );
919  Int  iStrideCur = pcDtParam->iStrideCur*iSubStep;
920  Int  iStrideOrg = pcDtParam->iStrideOrg*iSubStep;
921
922  Distortion uiSum = 0;
923
924  for( ; iRows != 0; iRows-=iSubStep )
925  {
926    uiSum += abs( piOrg[0] - piCur[0] );
927    uiSum += abs( piOrg[1] - piCur[1] );
928    uiSum += abs( piOrg[2] - piCur[2] );
929    uiSum += abs( piOrg[3] - piCur[3] );
930    uiSum += abs( piOrg[4] - piCur[4] );
931    uiSum += abs( piOrg[5] - piCur[5] );
932    uiSum += abs( piOrg[6] - piCur[6] );
933    uiSum += abs( piOrg[7] - piCur[7] );
934    uiSum += abs( piOrg[8] - piCur[8] );
935    uiSum += abs( piOrg[9] - piCur[9] );
936    uiSum += abs( piOrg[10] - piCur[10] );
937    uiSum += abs( piOrg[11] - piCur[11] );
938    uiSum += abs( piOrg[12] - piCur[12] );
939    uiSum += abs( piOrg[13] - piCur[13] );
940    uiSum += abs( piOrg[14] - piCur[14] );
941    uiSum += abs( piOrg[15] - piCur[15] );
942
943    piOrg += iStrideOrg;
944    piCur += iStrideCur;
945  }
946
947  uiSum <<= iSubShift;
948  return ( uiSum >> DISTORTION_PRECISION_ADJUSTMENT(pcDtParam->bitDepth-8) );
949}
950
951Distortion TComRdCost::xGetSAD12( DistParam* pcDtParam )
952{
953  if ( pcDtParam->bApplyWeight )
954  {
955    return TComRdCostWeightPrediction::xGetSADw( pcDtParam );
956  }
957#if H_3D_IC
958  if( pcDtParam->bUseIC )
959  {
960    return xGetSAD12ic( pcDtParam );
961  }
962#endif
963#if H_3D_INTER_SDC
964  if( pcDtParam->bUseSDCMRSAD )
965  {
966    return xGetSAD12ic( pcDtParam );
967  }
968#endif
969
970  const Pel* piOrg   = pcDtParam->pOrg;
971  const Pel* piCur   = pcDtParam->pCur;
972  Int  iRows   = pcDtParam->iRows;
973  Int  iSubShift  = pcDtParam->iSubShift;
974  Int  iSubStep   = ( 1 << iSubShift );
975  Int  iStrideCur = pcDtParam->iStrideCur*iSubStep;
976  Int  iStrideOrg = pcDtParam->iStrideOrg*iSubStep;
977
978  Distortion uiSum = 0;
979
980  for( ; iRows != 0; iRows-=iSubStep )
981  {
982    uiSum += abs( piOrg[0] - piCur[0] );
983    uiSum += abs( piOrg[1] - piCur[1] );
984    uiSum += abs( piOrg[2] - piCur[2] );
985    uiSum += abs( piOrg[3] - piCur[3] );
986    uiSum += abs( piOrg[4] - piCur[4] );
987    uiSum += abs( piOrg[5] - piCur[5] );
988    uiSum += abs( piOrg[6] - piCur[6] );
989    uiSum += abs( piOrg[7] - piCur[7] );
990    uiSum += abs( piOrg[8] - piCur[8] );
991    uiSum += abs( piOrg[9] - piCur[9] );
992    uiSum += abs( piOrg[10] - piCur[10] );
993    uiSum += abs( piOrg[11] - piCur[11] );
994
995    piOrg += iStrideOrg;
996    piCur += iStrideCur;
997  }
998
999  uiSum <<= iSubShift;
1000  return ( uiSum >> DISTORTION_PRECISION_ADJUSTMENT(pcDtParam->bitDepth-8) );
1001}
1002
1003Distortion TComRdCost::xGetSAD16N( DistParam* pcDtParam )
1004{
1005#if H_3D_IC
1006  if( pcDtParam->bUseIC )
1007  {
1008    return xGetSAD16Nic( pcDtParam );
1009  }
1010#endif
1011#if H_3D_INTER_SDC
1012  if( pcDtParam->bUseSDCMRSAD )
1013  {
1014    return xGetSAD16Nic( pcDtParam );
1015  }
1016#endif
1017
1018  const Pel* piOrg   = pcDtParam->pOrg;
1019  const Pel* piCur   = pcDtParam->pCur;
1020  Int  iRows   = pcDtParam->iRows;
1021  Int  iCols   = pcDtParam->iCols;
1022  Int  iSubShift  = pcDtParam->iSubShift;
1023  Int  iSubStep   = ( 1 << iSubShift );
1024  Int  iStrideCur = pcDtParam->iStrideCur*iSubStep;
1025  Int  iStrideOrg = pcDtParam->iStrideOrg*iSubStep;
1026
1027  Distortion uiSum = 0;
1028
1029  for( ; iRows != 0; iRows-=iSubStep )
1030  {
1031    for (Int n = 0; n < iCols; n+=16 )
1032    {
1033      uiSum += abs( piOrg[n+ 0] - piCur[n+ 0] );
1034      uiSum += abs( piOrg[n+ 1] - piCur[n+ 1] );
1035      uiSum += abs( piOrg[n+ 2] - piCur[n+ 2] );
1036      uiSum += abs( piOrg[n+ 3] - piCur[n+ 3] );
1037      uiSum += abs( piOrg[n+ 4] - piCur[n+ 4] );
1038      uiSum += abs( piOrg[n+ 5] - piCur[n+ 5] );
1039      uiSum += abs( piOrg[n+ 6] - piCur[n+ 6] );
1040      uiSum += abs( piOrg[n+ 7] - piCur[n+ 7] );
1041      uiSum += abs( piOrg[n+ 8] - piCur[n+ 8] );
1042      uiSum += abs( piOrg[n+ 9] - piCur[n+ 9] );
1043      uiSum += abs( piOrg[n+10] - piCur[n+10] );
1044      uiSum += abs( piOrg[n+11] - piCur[n+11] );
1045      uiSum += abs( piOrg[n+12] - piCur[n+12] );
1046      uiSum += abs( piOrg[n+13] - piCur[n+13] );
1047      uiSum += abs( piOrg[n+14] - piCur[n+14] );
1048      uiSum += abs( piOrg[n+15] - piCur[n+15] );
1049    }
1050    piOrg += iStrideOrg;
1051    piCur += iStrideCur;
1052  }
1053
1054  uiSum <<= iSubShift;
1055  return ( uiSum >> DISTORTION_PRECISION_ADJUSTMENT(pcDtParam->bitDepth-8) );
1056}
1057
1058Distortion TComRdCost::xGetSAD32( DistParam* pcDtParam )
1059{
1060  if ( pcDtParam->bApplyWeight )
1061  {
1062    return TComRdCostWeightPrediction::xGetSADw( pcDtParam );
1063  }
1064
1065#if H_3D_IC
1066  if( pcDtParam->bUseIC )
1067  {
1068    return xGetSAD32ic( pcDtParam );
1069  }
1070#endif
1071#if H_3D_INTER_SDC
1072  if( pcDtParam->bUseSDCMRSAD )
1073  {
1074    return xGetSAD32ic( pcDtParam );
1075  }
1076#endif
1077
1078  const Pel* piOrg   = pcDtParam->pOrg;
1079  const Pel* piCur   = pcDtParam->pCur;
1080  Int  iRows   = pcDtParam->iRows;
1081  Int  iSubShift  = pcDtParam->iSubShift;
1082  Int  iSubStep   = ( 1 << iSubShift );
1083  Int  iStrideCur = pcDtParam->iStrideCur*iSubStep;
1084  Int  iStrideOrg = pcDtParam->iStrideOrg*iSubStep;
1085
1086  Distortion uiSum = 0;
1087
1088  for( ; iRows != 0; iRows-=iSubStep )
1089  {
1090    uiSum += abs( piOrg[0] - piCur[0] );
1091    uiSum += abs( piOrg[1] - piCur[1] );
1092    uiSum += abs( piOrg[2] - piCur[2] );
1093    uiSum += abs( piOrg[3] - piCur[3] );
1094    uiSum += abs( piOrg[4] - piCur[4] );
1095    uiSum += abs( piOrg[5] - piCur[5] );
1096    uiSum += abs( piOrg[6] - piCur[6] );
1097    uiSum += abs( piOrg[7] - piCur[7] );
1098    uiSum += abs( piOrg[8] - piCur[8] );
1099    uiSum += abs( piOrg[9] - piCur[9] );
1100    uiSum += abs( piOrg[10] - piCur[10] );
1101    uiSum += abs( piOrg[11] - piCur[11] );
1102    uiSum += abs( piOrg[12] - piCur[12] );
1103    uiSum += abs( piOrg[13] - piCur[13] );
1104    uiSum += abs( piOrg[14] - piCur[14] );
1105    uiSum += abs( piOrg[15] - piCur[15] );
1106    uiSum += abs( piOrg[16] - piCur[16] );
1107    uiSum += abs( piOrg[17] - piCur[17] );
1108    uiSum += abs( piOrg[18] - piCur[18] );
1109    uiSum += abs( piOrg[19] - piCur[19] );
1110    uiSum += abs( piOrg[20] - piCur[20] );
1111    uiSum += abs( piOrg[21] - piCur[21] );
1112    uiSum += abs( piOrg[22] - piCur[22] );
1113    uiSum += abs( piOrg[23] - piCur[23] );
1114    uiSum += abs( piOrg[24] - piCur[24] );
1115    uiSum += abs( piOrg[25] - piCur[25] );
1116    uiSum += abs( piOrg[26] - piCur[26] );
1117    uiSum += abs( piOrg[27] - piCur[27] );
1118    uiSum += abs( piOrg[28] - piCur[28] );
1119    uiSum += abs( piOrg[29] - piCur[29] );
1120    uiSum += abs( piOrg[30] - piCur[30] );
1121    uiSum += abs( piOrg[31] - piCur[31] );
1122
1123    piOrg += iStrideOrg;
1124    piCur += iStrideCur;
1125  }
1126
1127  uiSum <<= iSubShift;
1128  return ( uiSum >> DISTORTION_PRECISION_ADJUSTMENT(pcDtParam->bitDepth-8) );
1129}
1130
1131Distortion TComRdCost::xGetSAD24( DistParam* pcDtParam )
1132{
1133  if ( pcDtParam->bApplyWeight )
1134  {
1135    return TComRdCostWeightPrediction::xGetSADw( pcDtParam );
1136  }
1137
1138#if H_3D_IC
1139  if( pcDtParam->bUseIC )
1140  {
1141    return xGetSAD24ic( pcDtParam );
1142  }
1143#endif
1144#if H_3D_INTER_SDC
1145  if( pcDtParam->bUseSDCMRSAD )
1146  {
1147    return xGetSAD24ic( pcDtParam );
1148  }
1149#endif
1150
1151  const Pel* piOrg   = pcDtParam->pOrg;
1152  const Pel* piCur   = pcDtParam->pCur;
1153  Int  iRows   = pcDtParam->iRows;
1154  Int  iSubShift  = pcDtParam->iSubShift;
1155  Int  iSubStep   = ( 1 << iSubShift );
1156  Int  iStrideCur = pcDtParam->iStrideCur*iSubStep;
1157  Int  iStrideOrg = pcDtParam->iStrideOrg*iSubStep;
1158
1159  Distortion uiSum = 0;
1160
1161  for( ; iRows != 0; iRows-=iSubStep )
1162  {
1163    uiSum += abs( piOrg[0] - piCur[0] );
1164    uiSum += abs( piOrg[1] - piCur[1] );
1165    uiSum += abs( piOrg[2] - piCur[2] );
1166    uiSum += abs( piOrg[3] - piCur[3] );
1167    uiSum += abs( piOrg[4] - piCur[4] );
1168    uiSum += abs( piOrg[5] - piCur[5] );
1169    uiSum += abs( piOrg[6] - piCur[6] );
1170    uiSum += abs( piOrg[7] - piCur[7] );
1171    uiSum += abs( piOrg[8] - piCur[8] );
1172    uiSum += abs( piOrg[9] - piCur[9] );
1173    uiSum += abs( piOrg[10] - piCur[10] );
1174    uiSum += abs( piOrg[11] - piCur[11] );
1175    uiSum += abs( piOrg[12] - piCur[12] );
1176    uiSum += abs( piOrg[13] - piCur[13] );
1177    uiSum += abs( piOrg[14] - piCur[14] );
1178    uiSum += abs( piOrg[15] - piCur[15] );
1179    uiSum += abs( piOrg[16] - piCur[16] );
1180    uiSum += abs( piOrg[17] - piCur[17] );
1181    uiSum += abs( piOrg[18] - piCur[18] );
1182    uiSum += abs( piOrg[19] - piCur[19] );
1183    uiSum += abs( piOrg[20] - piCur[20] );
1184    uiSum += abs( piOrg[21] - piCur[21] );
1185    uiSum += abs( piOrg[22] - piCur[22] );
1186    uiSum += abs( piOrg[23] - piCur[23] );
1187
1188    piOrg += iStrideOrg;
1189    piCur += iStrideCur;
1190  }
1191
1192  uiSum <<= iSubShift;
1193  return ( uiSum >> DISTORTION_PRECISION_ADJUSTMENT(pcDtParam->bitDepth-8) );
1194}
1195
1196Distortion TComRdCost::xGetSAD64( DistParam* pcDtParam )
1197{
1198  if ( pcDtParam->bApplyWeight )
1199  {
1200    return TComRdCostWeightPrediction::xGetSADw( pcDtParam );
1201  }
1202
1203#if H_3D_IC
1204  if( pcDtParam->bUseIC )
1205  {
1206    return xGetSAD64ic( pcDtParam );
1207  }
1208#endif
1209#if H_3D_INTER_SDC
1210  if( pcDtParam->bUseSDCMRSAD )
1211  {
1212    return xGetSAD64ic( pcDtParam );
1213  }
1214#endif
1215
1216  const Pel* piOrg   = pcDtParam->pOrg;
1217  const Pel* piCur   = pcDtParam->pCur;
1218  Int  iRows   = pcDtParam->iRows;
1219  Int  iSubShift  = pcDtParam->iSubShift;
1220  Int  iSubStep   = ( 1 << iSubShift );
1221  Int  iStrideCur = pcDtParam->iStrideCur*iSubStep;
1222  Int  iStrideOrg = pcDtParam->iStrideOrg*iSubStep;
1223
1224  Distortion uiSum = 0;
1225
1226  for( ; iRows != 0; iRows-=iSubStep )
1227  {
1228    uiSum += abs( piOrg[0] - piCur[0] );
1229    uiSum += abs( piOrg[1] - piCur[1] );
1230    uiSum += abs( piOrg[2] - piCur[2] );
1231    uiSum += abs( piOrg[3] - piCur[3] );
1232    uiSum += abs( piOrg[4] - piCur[4] );
1233    uiSum += abs( piOrg[5] - piCur[5] );
1234    uiSum += abs( piOrg[6] - piCur[6] );
1235    uiSum += abs( piOrg[7] - piCur[7] );
1236    uiSum += abs( piOrg[8] - piCur[8] );
1237    uiSum += abs( piOrg[9] - piCur[9] );
1238    uiSum += abs( piOrg[10] - piCur[10] );
1239    uiSum += abs( piOrg[11] - piCur[11] );
1240    uiSum += abs( piOrg[12] - piCur[12] );
1241    uiSum += abs( piOrg[13] - piCur[13] );
1242    uiSum += abs( piOrg[14] - piCur[14] );
1243    uiSum += abs( piOrg[15] - piCur[15] );
1244    uiSum += abs( piOrg[16] - piCur[16] );
1245    uiSum += abs( piOrg[17] - piCur[17] );
1246    uiSum += abs( piOrg[18] - piCur[18] );
1247    uiSum += abs( piOrg[19] - piCur[19] );
1248    uiSum += abs( piOrg[20] - piCur[20] );
1249    uiSum += abs( piOrg[21] - piCur[21] );
1250    uiSum += abs( piOrg[22] - piCur[22] );
1251    uiSum += abs( piOrg[23] - piCur[23] );
1252    uiSum += abs( piOrg[24] - piCur[24] );
1253    uiSum += abs( piOrg[25] - piCur[25] );
1254    uiSum += abs( piOrg[26] - piCur[26] );
1255    uiSum += abs( piOrg[27] - piCur[27] );
1256    uiSum += abs( piOrg[28] - piCur[28] );
1257    uiSum += abs( piOrg[29] - piCur[29] );
1258    uiSum += abs( piOrg[30] - piCur[30] );
1259    uiSum += abs( piOrg[31] - piCur[31] );
1260    uiSum += abs( piOrg[32] - piCur[32] );
1261    uiSum += abs( piOrg[33] - piCur[33] );
1262    uiSum += abs( piOrg[34] - piCur[34] );
1263    uiSum += abs( piOrg[35] - piCur[35] );
1264    uiSum += abs( piOrg[36] - piCur[36] );
1265    uiSum += abs( piOrg[37] - piCur[37] );
1266    uiSum += abs( piOrg[38] - piCur[38] );
1267    uiSum += abs( piOrg[39] - piCur[39] );
1268    uiSum += abs( piOrg[40] - piCur[40] );
1269    uiSum += abs( piOrg[41] - piCur[41] );
1270    uiSum += abs( piOrg[42] - piCur[42] );
1271    uiSum += abs( piOrg[43] - piCur[43] );
1272    uiSum += abs( piOrg[44] - piCur[44] );
1273    uiSum += abs( piOrg[45] - piCur[45] );
1274    uiSum += abs( piOrg[46] - piCur[46] );
1275    uiSum += abs( piOrg[47] - piCur[47] );
1276    uiSum += abs( piOrg[48] - piCur[48] );
1277    uiSum += abs( piOrg[49] - piCur[49] );
1278    uiSum += abs( piOrg[50] - piCur[50] );
1279    uiSum += abs( piOrg[51] - piCur[51] );
1280    uiSum += abs( piOrg[52] - piCur[52] );
1281    uiSum += abs( piOrg[53] - piCur[53] );
1282    uiSum += abs( piOrg[54] - piCur[54] );
1283    uiSum += abs( piOrg[55] - piCur[55] );
1284    uiSum += abs( piOrg[56] - piCur[56] );
1285    uiSum += abs( piOrg[57] - piCur[57] );
1286    uiSum += abs( piOrg[58] - piCur[58] );
1287    uiSum += abs( piOrg[59] - piCur[59] );
1288    uiSum += abs( piOrg[60] - piCur[60] );
1289    uiSum += abs( piOrg[61] - piCur[61] );
1290    uiSum += abs( piOrg[62] - piCur[62] );
1291    uiSum += abs( piOrg[63] - piCur[63] );
1292
1293    piOrg += iStrideOrg;
1294    piCur += iStrideCur;
1295  }
1296
1297  uiSum <<= iSubShift;
1298  return ( uiSum >> DISTORTION_PRECISION_ADJUSTMENT(pcDtParam->bitDepth-8) );
1299}
1300
1301Distortion TComRdCost::xGetSAD48( DistParam* pcDtParam )
1302{
1303  if ( pcDtParam->bApplyWeight )
1304  {
1305    return TComRdCostWeightPrediction::xGetSADw( pcDtParam );
1306  }
1307#if H_3D_IC
1308  if( pcDtParam->bUseIC )
1309  {
1310    return xGetSAD48ic( pcDtParam );
1311  }
1312#endif
1313#if H_3D_INTER_SDC
1314  if( pcDtParam->bUseSDCMRSAD )
1315  {
1316    return xGetSAD48ic( pcDtParam );
1317  }
1318#endif
1319
1320  const Pel* piOrg   = pcDtParam->pOrg;
1321  const Pel* piCur   = pcDtParam->pCur;
1322  Int  iRows   = pcDtParam->iRows;
1323  Int  iSubShift  = pcDtParam->iSubShift;
1324  Int  iSubStep   = ( 1 << iSubShift );
1325  Int  iStrideCur = pcDtParam->iStrideCur*iSubStep;
1326  Int  iStrideOrg = pcDtParam->iStrideOrg*iSubStep;
1327
1328  Distortion uiSum = 0;
1329
1330  for( ; iRows != 0; iRows-=iSubStep )
1331  {
1332    uiSum += abs( piOrg[0] - piCur[0] );
1333    uiSum += abs( piOrg[1] - piCur[1] );
1334    uiSum += abs( piOrg[2] - piCur[2] );
1335    uiSum += abs( piOrg[3] - piCur[3] );
1336    uiSum += abs( piOrg[4] - piCur[4] );
1337    uiSum += abs( piOrg[5] - piCur[5] );
1338    uiSum += abs( piOrg[6] - piCur[6] );
1339    uiSum += abs( piOrg[7] - piCur[7] );
1340    uiSum += abs( piOrg[8] - piCur[8] );
1341    uiSum += abs( piOrg[9] - piCur[9] );
1342    uiSum += abs( piOrg[10] - piCur[10] );
1343    uiSum += abs( piOrg[11] - piCur[11] );
1344    uiSum += abs( piOrg[12] - piCur[12] );
1345    uiSum += abs( piOrg[13] - piCur[13] );
1346    uiSum += abs( piOrg[14] - piCur[14] );
1347    uiSum += abs( piOrg[15] - piCur[15] );
1348    uiSum += abs( piOrg[16] - piCur[16] );
1349    uiSum += abs( piOrg[17] - piCur[17] );
1350    uiSum += abs( piOrg[18] - piCur[18] );
1351    uiSum += abs( piOrg[19] - piCur[19] );
1352    uiSum += abs( piOrg[20] - piCur[20] );
1353    uiSum += abs( piOrg[21] - piCur[21] );
1354    uiSum += abs( piOrg[22] - piCur[22] );
1355    uiSum += abs( piOrg[23] - piCur[23] );
1356    uiSum += abs( piOrg[24] - piCur[24] );
1357    uiSum += abs( piOrg[25] - piCur[25] );
1358    uiSum += abs( piOrg[26] - piCur[26] );
1359    uiSum += abs( piOrg[27] - piCur[27] );
1360    uiSum += abs( piOrg[28] - piCur[28] );
1361    uiSum += abs( piOrg[29] - piCur[29] );
1362    uiSum += abs( piOrg[30] - piCur[30] );
1363    uiSum += abs( piOrg[31] - piCur[31] );
1364    uiSum += abs( piOrg[32] - piCur[32] );
1365    uiSum += abs( piOrg[33] - piCur[33] );
1366    uiSum += abs( piOrg[34] - piCur[34] );
1367    uiSum += abs( piOrg[35] - piCur[35] );
1368    uiSum += abs( piOrg[36] - piCur[36] );
1369    uiSum += abs( piOrg[37] - piCur[37] );
1370    uiSum += abs( piOrg[38] - piCur[38] );
1371    uiSum += abs( piOrg[39] - piCur[39] );
1372    uiSum += abs( piOrg[40] - piCur[40] );
1373    uiSum += abs( piOrg[41] - piCur[41] );
1374    uiSum += abs( piOrg[42] - piCur[42] );
1375    uiSum += abs( piOrg[43] - piCur[43] );
1376    uiSum += abs( piOrg[44] - piCur[44] );
1377    uiSum += abs( piOrg[45] - piCur[45] );
1378    uiSum += abs( piOrg[46] - piCur[46] );
1379    uiSum += abs( piOrg[47] - piCur[47] );
1380
1381    piOrg += iStrideOrg;
1382    piCur += iStrideCur;
1383  }
1384
1385  uiSum <<= iSubShift;
1386  return ( uiSum >> DISTORTION_PRECISION_ADJUSTMENT(pcDtParam->bitDepth-8) );
1387}
1388
1389
1390#if H_3D_IC || H_3D_INTER_SDC
1391UInt TComRdCost::xGetSADic( DistParam* pcDtParam )
1392{
1393  if ( pcDtParam->bApplyWeight )
1394  {
1395    return xGetSADw( pcDtParam );
1396  }
1397  Pel* piOrg   = pcDtParam->pOrg;
1398  Pel* piCur   = pcDtParam->pCur;
1399  Int  iRows   = pcDtParam->iRows;
1400  Int  iCols   = pcDtParam->iCols;
1401  Int  iStrideCur = pcDtParam->iStrideCur;
1402  Int  iStrideOrg = pcDtParam->iStrideOrg;
1403
1404  UInt uiSum = 0;
1405
1406  Int  iOrigAvg = 0, iCurAvg = 0;
1407  Int  iDeltaC;
1408
1409  for( ; iRows != 0; iRows-- )
1410  {
1411    for (Int n = 0; n < iCols; n++ )
1412    {
1413      iOrigAvg += piOrg[n];
1414      iCurAvg  += piCur[n];
1415    }
1416    piOrg += iStrideOrg;
1417    piCur += iStrideCur;
1418  }
1419
1420  piOrg   = pcDtParam->pOrg;
1421  piCur   = pcDtParam->pCur;
1422  iRows   = pcDtParam->iRows;
1423
1424  iDeltaC = (iOrigAvg - iCurAvg)/iCols/iRows;
1425
1426  for( ; iRows != 0; iRows-- )
1427  {
1428    for (Int n = 0; n < iCols; n++ )
1429    {
1430      uiSum += abs( piOrg[n] - piCur[n] - iDeltaC );
1431    }
1432    piOrg += iStrideOrg;
1433    piCur += iStrideCur;
1434  }
1435
1436  return ( uiSum >> DISTORTION_PRECISION_ADJUSTMENT( pcDtParam->bitDepth - 8 ) );
1437}
1438
1439UInt TComRdCost::xGetSAD4ic( DistParam* pcDtParam )
1440{
1441  if ( pcDtParam->bApplyWeight ) 
1442  {
1443    return xGetSADw( pcDtParam );
1444  }
1445  Pel* piOrg   = pcDtParam->pOrg;
1446  Pel* piCur   = pcDtParam->pCur;
1447  Int  iRows   = pcDtParam->iRows;
1448  Int  iSubShift  = pcDtParam->iSubShift;
1449  Int  iSubStep   = ( 1 << iSubShift );
1450  Int  iStrideCur = pcDtParam->iStrideCur*iSubStep;
1451  Int  iStrideOrg = pcDtParam->iStrideOrg*iSubStep;
1452
1453  UInt uiSum = 0;
1454
1455  Int  iOrigAvg = 0, iCurAvg = 0, uiRowCnt = 0;
1456  Int  iDeltaC;
1457
1458  for( ; iRows != 0; iRows-=iSubStep )
1459  {
1460    iOrigAvg += piOrg[0];
1461    iOrigAvg += piOrg[1];
1462    iOrigAvg += piOrg[2];
1463    iOrigAvg += piOrg[3];
1464
1465    iCurAvg  += piCur[0];
1466    iCurAvg  += piCur[1];
1467    iCurAvg  += piCur[2];
1468    iCurAvg  += piCur[3];
1469
1470    piOrg += iStrideOrg;
1471    piCur += iStrideCur;
1472    uiRowCnt++;
1473  }
1474
1475  piOrg   = pcDtParam->pOrg;
1476  piCur   = pcDtParam->pCur;
1477  iRows   = pcDtParam->iRows;
1478
1479  iDeltaC = uiRowCnt ? ((iOrigAvg - iCurAvg)/uiRowCnt/4) : 0;
1480
1481  for( ; iRows != 0; iRows-=iSubStep )
1482  {
1483    uiSum += abs( piOrg[0] - piCur[0] - iDeltaC );
1484    uiSum += abs( piOrg[1] - piCur[1] - iDeltaC );
1485    uiSum += abs( piOrg[2] - piCur[2] - iDeltaC );
1486    uiSum += abs( piOrg[3] - piCur[3] - iDeltaC );
1487
1488    piOrg += iStrideOrg;
1489    piCur += iStrideCur;
1490  }
1491
1492  uiSum <<= iSubShift;
1493  return ( uiSum >> DISTORTION_PRECISION_ADJUSTMENT( pcDtParam->bitDepth - 8 ) );
1494}
1495
1496UInt TComRdCost::xGetSAD8ic( DistParam* pcDtParam )
1497{
1498  if ( pcDtParam->bApplyWeight )
1499  {
1500    return xGetSADw( pcDtParam );
1501  }
1502  Pel* piOrg      = pcDtParam->pOrg;
1503  Pel* piCur      = pcDtParam->pCur;
1504  Int  iRows      = pcDtParam->iRows;
1505  Int  iSubShift  = pcDtParam->iSubShift;
1506  Int  iSubStep   = ( 1 << iSubShift );
1507  Int  iStrideCur = pcDtParam->iStrideCur*iSubStep;
1508  Int  iStrideOrg = pcDtParam->iStrideOrg*iSubStep;
1509
1510  UInt uiSum = 0;
1511
1512  Int  iOrigAvg = 0, iCurAvg = 0, uiRowCnt = 0;
1513  Int  iDeltaC;
1514
1515  for( ; iRows != 0; iRows-=iSubStep )
1516  {
1517    iOrigAvg += piOrg[0];
1518    iOrigAvg += piOrg[1];
1519    iOrigAvg += piOrg[2];
1520    iOrigAvg += piOrg[3];
1521    iOrigAvg += piOrg[4];
1522    iOrigAvg += piOrg[5];
1523    iOrigAvg += piOrg[6];
1524    iOrigAvg += piOrg[7];
1525
1526    iCurAvg  += piCur[0];
1527    iCurAvg  += piCur[1];
1528    iCurAvg  += piCur[2];
1529    iCurAvg  += piCur[3];
1530    iCurAvg  += piCur[4];
1531    iCurAvg  += piCur[5];
1532    iCurAvg  += piCur[6];
1533    iCurAvg  += piCur[7];
1534
1535    piOrg += iStrideOrg;
1536    piCur += iStrideCur;
1537    uiRowCnt++;
1538  }
1539
1540  piOrg   = pcDtParam->pOrg;
1541  piCur   = pcDtParam->pCur;
1542  iRows   = pcDtParam->iRows;
1543
1544  iDeltaC = uiRowCnt ? ((iOrigAvg - iCurAvg)/uiRowCnt/8) : 0;
1545
1546  for( ; iRows != 0; iRows-=iSubStep )
1547  {
1548    uiSum += abs( piOrg[0] - piCur[0] - iDeltaC );
1549    uiSum += abs( piOrg[1] - piCur[1] - iDeltaC );
1550    uiSum += abs( piOrg[2] - piCur[2] - iDeltaC );
1551    uiSum += abs( piOrg[3] - piCur[3] - iDeltaC );
1552    uiSum += abs( piOrg[4] - piCur[4] - iDeltaC );
1553    uiSum += abs( piOrg[5] - piCur[5] - iDeltaC );
1554    uiSum += abs( piOrg[6] - piCur[6] - iDeltaC );
1555    uiSum += abs( piOrg[7] - piCur[7] - iDeltaC );
1556
1557    piOrg += iStrideOrg;
1558    piCur += iStrideCur;
1559  }
1560
1561  uiSum <<= iSubShift;
1562  return ( uiSum >> DISTORTION_PRECISION_ADJUSTMENT( pcDtParam->bitDepth - 8 ) );
1563}
1564
1565UInt TComRdCost::xGetSAD16ic( DistParam* pcDtParam )
1566{
1567  if ( pcDtParam->bApplyWeight )
1568  {
1569    return xGetSADw( pcDtParam );
1570  }
1571  Pel* piOrg   = pcDtParam->pOrg;
1572  Pel* piCur   = pcDtParam->pCur;
1573  Int  iRows   = pcDtParam->iRows;
1574  Int  iSubShift  = pcDtParam->iSubShift;
1575  Int  iSubStep   = ( 1 << iSubShift );
1576  Int  iStrideCur = pcDtParam->iStrideCur*iSubStep;
1577  Int  iStrideOrg = pcDtParam->iStrideOrg*iSubStep;
1578
1579  UInt uiSum = 0;
1580
1581  Int iOrigAvg = 0, iCurAvg = 0, uiRowCnt = 0;
1582  Int iDeltaC;
1583
1584  for( ; iRows != 0; iRows-=iSubStep )
1585  {
1586    iOrigAvg += piOrg[0];
1587    iOrigAvg += piOrg[1];
1588    iOrigAvg += piOrg[2];
1589    iOrigAvg += piOrg[3];
1590    iOrigAvg += piOrg[4];
1591    iOrigAvg += piOrg[5];
1592    iOrigAvg += piOrg[6];
1593    iOrigAvg += piOrg[7];
1594    iOrigAvg += piOrg[8];
1595    iOrigAvg += piOrg[9];
1596    iOrigAvg += piOrg[10];
1597    iOrigAvg += piOrg[11];
1598    iOrigAvg += piOrg[12];
1599    iOrigAvg += piOrg[13];
1600    iOrigAvg += piOrg[14];
1601    iOrigAvg += piOrg[15];
1602
1603    iCurAvg  += piCur[0];
1604    iCurAvg  += piCur[1];
1605    iCurAvg  += piCur[2];
1606    iCurAvg  += piCur[3];
1607    iCurAvg  += piCur[4];
1608    iCurAvg  += piCur[5];
1609    iCurAvg  += piCur[6];
1610    iCurAvg  += piCur[7];
1611    iCurAvg  += piCur[8];
1612    iCurAvg  += piCur[9];
1613    iCurAvg  += piCur[10];
1614    iCurAvg  += piCur[11];
1615    iCurAvg  += piCur[12];
1616    iCurAvg  += piCur[13];
1617    iCurAvg  += piCur[14];
1618    iCurAvg  += piCur[15];
1619
1620    piOrg += iStrideOrg;
1621    piCur += iStrideCur;
1622    uiRowCnt++;
1623  }
1624
1625  piOrg   = pcDtParam->pOrg;
1626  piCur   = pcDtParam->pCur;
1627  iRows   = pcDtParam->iRows;
1628
1629  iDeltaC = uiRowCnt ? ((iOrigAvg - iCurAvg)/uiRowCnt/16) : 0;
1630
1631  for( ; iRows != 0; iRows-=iSubStep )
1632  {
1633    uiSum += abs( piOrg[0] - piCur[0] - iDeltaC );
1634    uiSum += abs( piOrg[1] - piCur[1] - iDeltaC );
1635    uiSum += abs( piOrg[2] - piCur[2] - iDeltaC );
1636    uiSum += abs( piOrg[3] - piCur[3] - iDeltaC );
1637    uiSum += abs( piOrg[4] - piCur[4] - iDeltaC );
1638    uiSum += abs( piOrg[5] - piCur[5] - iDeltaC );
1639    uiSum += abs( piOrg[6] - piCur[6] - iDeltaC );
1640    uiSum += abs( piOrg[7] - piCur[7] - iDeltaC );
1641    uiSum += abs( piOrg[8] - piCur[8] - iDeltaC );
1642    uiSum += abs( piOrg[9] - piCur[9] - iDeltaC );
1643    uiSum += abs( piOrg[10] - piCur[10] - iDeltaC );
1644    uiSum += abs( piOrg[11] - piCur[11] - iDeltaC );
1645    uiSum += abs( piOrg[12] - piCur[12] - iDeltaC );
1646    uiSum += abs( piOrg[13] - piCur[13] - iDeltaC );
1647    uiSum += abs( piOrg[14] - piCur[14] - iDeltaC );
1648    uiSum += abs( piOrg[15] - piCur[15] - iDeltaC );
1649
1650    piOrg += iStrideOrg;
1651    piCur += iStrideCur;
1652  }
1653
1654  uiSum <<= iSubShift;
1655  return ( uiSum >> DISTORTION_PRECISION_ADJUSTMENT( pcDtParam->bitDepth - 8 ) );
1656}
1657
1658UInt TComRdCost::xGetSAD12ic( DistParam* pcDtParam )
1659{
1660  if ( pcDtParam->bApplyWeight )
1661  {
1662    return xGetSADw( pcDtParam );
1663  }
1664  Pel* piOrg   = pcDtParam->pOrg;
1665  Pel* piCur   = pcDtParam->pCur;
1666  Int  iRows   = pcDtParam->iRows;
1667  Int  iSubShift  = pcDtParam->iSubShift;
1668  Int  iSubStep   = ( 1 << iSubShift );
1669  Int  iStrideCur = pcDtParam->iStrideCur*iSubStep;
1670  Int  iStrideOrg = pcDtParam->iStrideOrg*iSubStep;
1671
1672  UInt uiSum = 0;
1673
1674  Int  iOrigAvg = 0, iCurAvg = 0, uiRowCnt = 0;
1675  Int  iDeltaC;
1676
1677  for( ; iRows != 0; iRows-=iSubStep )
1678  {
1679    iOrigAvg += piOrg[0];
1680    iOrigAvg += piOrg[1];
1681    iOrigAvg += piOrg[2];
1682    iOrigAvg += piOrg[3];
1683    iOrigAvg += piOrg[4];
1684    iOrigAvg += piOrg[5];
1685    iOrigAvg += piOrg[6];
1686    iOrigAvg += piOrg[7];
1687    iOrigAvg += piOrg[8];
1688    iOrigAvg += piOrg[9];
1689    iOrigAvg += piOrg[10];
1690    iOrigAvg += piOrg[11];
1691
1692    iCurAvg  += piCur[0];
1693    iCurAvg  += piCur[1];
1694    iCurAvg  += piCur[2];
1695    iCurAvg  += piCur[3];
1696    iCurAvg  += piCur[4];
1697    iCurAvg  += piCur[5];
1698    iCurAvg  += piCur[6];
1699    iCurAvg  += piCur[7];
1700    iCurAvg  += piCur[8];
1701    iCurAvg  += piCur[9];
1702    iCurAvg  += piCur[10];
1703    iCurAvg  += piCur[11];
1704
1705    piOrg += iStrideOrg;
1706    piCur += iStrideCur;
1707    uiRowCnt++;
1708  }
1709
1710  piOrg   = pcDtParam->pOrg;
1711  piCur   = pcDtParam->pCur;
1712  iRows   = pcDtParam->iRows;
1713
1714  iDeltaC = uiRowCnt ? ((iOrigAvg - iCurAvg)/uiRowCnt/12) : 0;
1715
1716  for( ; iRows != 0; iRows-=iSubStep )
1717  {
1718    uiSum += abs( piOrg[0] - piCur[0] - iDeltaC );
1719    uiSum += abs( piOrg[1] - piCur[1] - iDeltaC );
1720    uiSum += abs( piOrg[2] - piCur[2] - iDeltaC );
1721    uiSum += abs( piOrg[3] - piCur[3] - iDeltaC );
1722    uiSum += abs( piOrg[4] - piCur[4] - iDeltaC );
1723    uiSum += abs( piOrg[5] - piCur[5] - iDeltaC );
1724    uiSum += abs( piOrg[6] - piCur[6] - iDeltaC );
1725    uiSum += abs( piOrg[7] - piCur[7] - iDeltaC );
1726    uiSum += abs( piOrg[8] - piCur[8] - iDeltaC );
1727    uiSum += abs( piOrg[9] - piCur[9] - iDeltaC );
1728    uiSum += abs( piOrg[10] - piCur[10] - iDeltaC );
1729    uiSum += abs( piOrg[11] - piCur[11] - iDeltaC );
1730
1731    piOrg += iStrideOrg;
1732    piCur += iStrideCur;
1733  }
1734
1735  uiSum <<= iSubShift;
1736  return ( uiSum >> DISTORTION_PRECISION_ADJUSTMENT( pcDtParam->bitDepth - 8 ) );
1737}
1738
1739
1740UInt TComRdCost::xGetSAD16Nic( DistParam* pcDtParam )
1741{
1742  Pel* piOrg   = pcDtParam->pOrg;
1743  Pel* piCur   = pcDtParam->pCur;
1744  Int  iRows   = pcDtParam->iRows;
1745  Int  iCols   = pcDtParam->iCols;
1746  Int  iSubShift  = pcDtParam->iSubShift;
1747  Int  iSubStep   = ( 1 << iSubShift );
1748  Int  iStrideCur = pcDtParam->iStrideCur*iSubStep;
1749  Int  iStrideOrg = pcDtParam->iStrideOrg*iSubStep;
1750
1751  UInt uiSum = 0;
1752
1753  Int iOrigAvg = 0, iCurAvg = 0, uiRowCnt = 0, uiColCnt = (iCols-1)/16 + 1;
1754  Int  iDeltaC;
1755
1756  for( ; iRows != 0; iRows-=iSubStep )
1757  {
1758    for (Int n = 0; n < iCols; n+=16 )
1759    {
1760      iOrigAvg += piOrg[n + 0];
1761      iOrigAvg += piOrg[n + 1];
1762      iOrigAvg += piOrg[n + 2];
1763      iOrigAvg += piOrg[n + 3];
1764      iOrigAvg += piOrg[n + 4];
1765      iOrigAvg += piOrg[n + 5];
1766      iOrigAvg += piOrg[n + 6];
1767      iOrigAvg += piOrg[n + 7];
1768      iOrigAvg += piOrg[n + 8];
1769      iOrigAvg += piOrg[n + 9];
1770      iOrigAvg += piOrg[n + 10];
1771      iOrigAvg += piOrg[n + 11];
1772      iOrigAvg += piOrg[n + 12];
1773      iOrigAvg += piOrg[n + 13];
1774      iOrigAvg += piOrg[n + 14];
1775      iOrigAvg += piOrg[n + 15];
1776
1777      iCurAvg  += piCur[n + 0];
1778      iCurAvg  += piCur[n + 1];
1779      iCurAvg  += piCur[n + 2];
1780      iCurAvg  += piCur[n + 3];
1781      iCurAvg  += piCur[n + 4];
1782      iCurAvg  += piCur[n + 5];
1783      iCurAvg  += piCur[n + 6];
1784      iCurAvg  += piCur[n + 7];
1785      iCurAvg  += piCur[n + 8];
1786      iCurAvg  += piCur[n + 9];
1787      iCurAvg  += piCur[n + 10];
1788      iCurAvg  += piCur[n + 11];
1789      iCurAvg  += piCur[n + 12];
1790      iCurAvg  += piCur[n + 13];
1791      iCurAvg  += piCur[n + 14];
1792      iCurAvg  += piCur[n + 15];
1793    }
1794    piOrg += iStrideOrg;
1795    piCur += iStrideCur;
1796    uiRowCnt++;
1797  }
1798  piOrg   = pcDtParam->pOrg;
1799  piCur   = pcDtParam->pCur;
1800  iRows   = pcDtParam->iRows;
1801
1802  iDeltaC = (uiRowCnt && uiColCnt) ? ((iOrigAvg - iCurAvg)/uiRowCnt/uiColCnt/16) : 0;
1803
1804  for( ; iRows != 0; iRows-=iSubStep )
1805  {
1806    for (Int n = 0; n < iCols; n+=16 )
1807    {
1808      uiSum += abs( piOrg[n+ 0] - piCur[n+ 0] - iDeltaC );
1809      uiSum += abs( piOrg[n+ 1] - piCur[n+ 1] - iDeltaC );
1810      uiSum += abs( piOrg[n+ 2] - piCur[n+ 2] - iDeltaC );
1811      uiSum += abs( piOrg[n+ 3] - piCur[n+ 3] - iDeltaC );
1812      uiSum += abs( piOrg[n+ 4] - piCur[n+ 4] - iDeltaC );
1813      uiSum += abs( piOrg[n+ 5] - piCur[n+ 5] - iDeltaC );
1814      uiSum += abs( piOrg[n+ 6] - piCur[n+ 6] - iDeltaC );
1815      uiSum += abs( piOrg[n+ 7] - piCur[n+ 7] - iDeltaC );
1816      uiSum += abs( piOrg[n+ 8] - piCur[n+ 8] - iDeltaC );
1817      uiSum += abs( piOrg[n+ 9] - piCur[n+ 9] - iDeltaC );
1818      uiSum += abs( piOrg[n+10] - piCur[n+10] - iDeltaC );
1819      uiSum += abs( piOrg[n+11] - piCur[n+11] - iDeltaC );
1820      uiSum += abs( piOrg[n+12] - piCur[n+12] - iDeltaC );
1821      uiSum += abs( piOrg[n+13] - piCur[n+13] - iDeltaC );
1822      uiSum += abs( piOrg[n+14] - piCur[n+14] - iDeltaC );
1823      uiSum += abs( piOrg[n+15] - piCur[n+15] - iDeltaC );
1824    }
1825    piOrg += iStrideOrg;
1826    piCur += iStrideCur;
1827  }
1828
1829  uiSum <<= iSubShift;
1830  return ( uiSum >> DISTORTION_PRECISION_ADJUSTMENT( pcDtParam->bitDepth - 8 ) );
1831}
1832
1833UInt TComRdCost::xGetSAD32ic( DistParam* pcDtParam )
1834{
1835  if ( pcDtParam->bApplyWeight )
1836  {
1837    return xGetSADw( pcDtParam );
1838  }
1839  Pel* piOrg   = pcDtParam->pOrg;
1840  Pel* piCur   = pcDtParam->pCur;
1841  Int  iRows   = pcDtParam->iRows;
1842  Int  iSubShift  = pcDtParam->iSubShift;
1843  Int  iSubStep   = ( 1 << iSubShift );
1844  Int  iStrideCur = pcDtParam->iStrideCur*iSubStep;
1845  Int  iStrideOrg = pcDtParam->iStrideOrg*iSubStep;
1846
1847  UInt uiSum = 0;
1848
1849  Int  iOrigAvg = 0, iCurAvg = 0, uiRowCnt = 0;
1850  Int  iDeltaC;
1851
1852  for( ; iRows != 0; iRows-=iSubStep )
1853  {
1854    iOrigAvg += piOrg[0];
1855    iOrigAvg += piOrg[1];
1856    iOrigAvg += piOrg[2];
1857    iOrigAvg += piOrg[3];
1858    iOrigAvg += piOrg[4];
1859    iOrigAvg += piOrg[5];
1860    iOrigAvg += piOrg[6];
1861    iOrigAvg += piOrg[7];
1862    iOrigAvg += piOrg[8];
1863    iOrigAvg += piOrg[9];
1864    iOrigAvg += piOrg[10];
1865    iOrigAvg += piOrg[11];
1866    iOrigAvg += piOrg[12];
1867    iOrigAvg += piOrg[13];
1868    iOrigAvg += piOrg[14];
1869    iOrigAvg += piOrg[15];
1870    iOrigAvg += piOrg[16];
1871    iOrigAvg += piOrg[17];
1872    iOrigAvg += piOrg[18];
1873    iOrigAvg += piOrg[19];
1874    iOrigAvg += piOrg[20];
1875    iOrigAvg += piOrg[21];
1876    iOrigAvg += piOrg[22];
1877    iOrigAvg += piOrg[23];
1878    iOrigAvg += piOrg[24];
1879    iOrigAvg += piOrg[25];
1880    iOrigAvg += piOrg[26];
1881    iOrigAvg += piOrg[27];
1882    iOrigAvg += piOrg[28];
1883    iOrigAvg += piOrg[29];
1884    iOrigAvg += piOrg[30];
1885    iOrigAvg += piOrg[31];
1886
1887    iCurAvg  += piCur[0];
1888    iCurAvg  += piCur[1];
1889    iCurAvg  += piCur[2];
1890    iCurAvg  += piCur[3];
1891    iCurAvg  += piCur[4];
1892    iCurAvg  += piCur[5];
1893    iCurAvg  += piCur[6];
1894    iCurAvg  += piCur[7];
1895    iCurAvg  += piCur[8];
1896    iCurAvg  += piCur[9];
1897    iCurAvg  += piCur[10];
1898    iCurAvg  += piCur[11];
1899    iCurAvg  += piCur[12];
1900    iCurAvg  += piCur[13];
1901    iCurAvg  += piCur[14];
1902    iCurAvg  += piCur[15];
1903    iCurAvg  += piCur[16];
1904    iCurAvg  += piCur[17];
1905    iCurAvg  += piCur[18];
1906    iCurAvg  += piCur[19];
1907    iCurAvg  += piCur[20];
1908    iCurAvg  += piCur[21];
1909    iCurAvg  += piCur[22];
1910    iCurAvg  += piCur[23];
1911    iCurAvg  += piCur[24];
1912    iCurAvg  += piCur[25];
1913    iCurAvg  += piCur[26];
1914    iCurAvg  += piCur[27];
1915    iCurAvg  += piCur[28];
1916    iCurAvg  += piCur[29];
1917    iCurAvg  += piCur[30];
1918    iCurAvg  += piCur[31];
1919
1920    piOrg += iStrideOrg;
1921    piCur += iStrideCur;
1922    uiRowCnt++;
1923  }
1924
1925  piOrg   = pcDtParam->pOrg;
1926  piCur   = pcDtParam->pCur;
1927  iRows   = pcDtParam->iRows;
1928
1929  iDeltaC = uiRowCnt ? ((iOrigAvg - iCurAvg)/uiRowCnt/32) : 0;
1930
1931  for( ; iRows != 0; iRows-=iSubStep )
1932  {
1933    uiSum += abs( piOrg[0] - piCur[0] - iDeltaC );
1934    uiSum += abs( piOrg[1] - piCur[1] - iDeltaC );
1935    uiSum += abs( piOrg[2] - piCur[2] - iDeltaC );
1936    uiSum += abs( piOrg[3] - piCur[3] - iDeltaC );
1937    uiSum += abs( piOrg[4] - piCur[4] - iDeltaC );
1938    uiSum += abs( piOrg[5] - piCur[5] - iDeltaC );
1939    uiSum += abs( piOrg[6] - piCur[6] - iDeltaC );
1940    uiSum += abs( piOrg[7] - piCur[7] - iDeltaC );
1941    uiSum += abs( piOrg[8] - piCur[8] - iDeltaC );
1942    uiSum += abs( piOrg[9] - piCur[9] - iDeltaC );
1943    uiSum += abs( piOrg[10] - piCur[10] - iDeltaC );
1944    uiSum += abs( piOrg[11] - piCur[11] - iDeltaC );
1945    uiSum += abs( piOrg[12] - piCur[12] - iDeltaC );
1946    uiSum += abs( piOrg[13] - piCur[13] - iDeltaC );
1947    uiSum += abs( piOrg[14] - piCur[14] - iDeltaC );
1948    uiSum += abs( piOrg[15] - piCur[15] - iDeltaC );
1949    uiSum += abs( piOrg[16] - piCur[16] - iDeltaC );
1950    uiSum += abs( piOrg[17] - piCur[17] - iDeltaC );
1951    uiSum += abs( piOrg[18] - piCur[18] - iDeltaC );
1952    uiSum += abs( piOrg[19] - piCur[19] - iDeltaC );
1953    uiSum += abs( piOrg[20] - piCur[20] - iDeltaC );
1954    uiSum += abs( piOrg[21] - piCur[21] - iDeltaC );
1955    uiSum += abs( piOrg[22] - piCur[22] - iDeltaC );
1956    uiSum += abs( piOrg[23] - piCur[23] - iDeltaC );
1957    uiSum += abs( piOrg[24] - piCur[24] - iDeltaC );
1958    uiSum += abs( piOrg[25] - piCur[25] - iDeltaC );
1959    uiSum += abs( piOrg[26] - piCur[26] - iDeltaC );
1960    uiSum += abs( piOrg[27] - piCur[27] - iDeltaC );
1961    uiSum += abs( piOrg[28] - piCur[28] - iDeltaC );
1962    uiSum += abs( piOrg[29] - piCur[29] - iDeltaC );
1963    uiSum += abs( piOrg[30] - piCur[30] - iDeltaC );
1964    uiSum += abs( piOrg[31] - piCur[31] - iDeltaC );
1965
1966    piOrg += iStrideOrg;
1967    piCur += iStrideCur;
1968  }
1969
1970  uiSum <<= iSubShift;
1971  return ( uiSum >> DISTORTION_PRECISION_ADJUSTMENT( pcDtParam->bitDepth - 8 ) );
1972}
1973
1974
1975UInt TComRdCost::xGetSAD24ic( DistParam* pcDtParam )
1976{
1977  if ( pcDtParam->bApplyWeight )
1978  {
1979    return xGetSADw( pcDtParam );
1980  }
1981  Pel* piOrg   = pcDtParam->pOrg;
1982  Pel* piCur   = pcDtParam->pCur;
1983  Int  iRows   = pcDtParam->iRows;
1984  Int  iSubShift  = pcDtParam->iSubShift;
1985  Int  iSubStep   = ( 1 << iSubShift );
1986  Int  iStrideCur = pcDtParam->iStrideCur*iSubStep;
1987  Int  iStrideOrg = pcDtParam->iStrideOrg*iSubStep;
1988
1989  UInt uiSum = 0;
1990
1991  Int  iOrigAvg = 0, iCurAvg = 0, uiRowCnt = 0;
1992  Int  iDeltaC;
1993
1994  for( ; iRows != 0; iRows-=iSubStep )
1995  {
1996    iOrigAvg += piOrg[0];
1997    iOrigAvg += piOrg[1];
1998    iOrigAvg += piOrg[2];
1999    iOrigAvg += piOrg[3];
2000    iOrigAvg += piOrg[4];
2001    iOrigAvg += piOrg[5];
2002    iOrigAvg += piOrg[6];
2003    iOrigAvg += piOrg[7];
2004    iOrigAvg += piOrg[8];
2005    iOrigAvg += piOrg[9];
2006    iOrigAvg += piOrg[10];
2007    iOrigAvg += piOrg[11];
2008    iOrigAvg += piOrg[12];
2009    iOrigAvg += piOrg[13];
2010    iOrigAvg += piOrg[14];
2011    iOrigAvg += piOrg[15];
2012    iOrigAvg += piOrg[16];
2013    iOrigAvg += piOrg[17];
2014    iOrigAvg += piOrg[18];
2015    iOrigAvg += piOrg[19];
2016    iOrigAvg += piOrg[20];
2017    iOrigAvg += piOrg[21];
2018    iOrigAvg += piOrg[22];
2019    iOrigAvg += piOrg[23];
2020
2021    iCurAvg  += piCur[0];
2022    iCurAvg  += piCur[1];
2023    iCurAvg  += piCur[2];
2024    iCurAvg  += piCur[3];
2025    iCurAvg  += piCur[4];
2026    iCurAvg  += piCur[5];
2027    iCurAvg  += piCur[6];
2028    iCurAvg  += piCur[7];
2029    iCurAvg  += piCur[8];
2030    iCurAvg  += piCur[9];
2031    iCurAvg  += piCur[10];
2032    iCurAvg  += piCur[11];
2033    iCurAvg  += piCur[12];
2034    iCurAvg  += piCur[13];
2035    iCurAvg  += piCur[14];
2036    iCurAvg  += piCur[15];
2037    iCurAvg  += piCur[16];
2038    iCurAvg  += piCur[17];
2039    iCurAvg  += piCur[18];
2040    iCurAvg  += piCur[19];
2041    iCurAvg  += piCur[20];
2042    iCurAvg  += piCur[21];
2043    iCurAvg  += piCur[22];
2044    iCurAvg  += piCur[23];
2045
2046    piOrg += iStrideOrg;
2047    piCur += iStrideCur;
2048    uiRowCnt++;
2049  }
2050
2051  piOrg   = pcDtParam->pOrg;
2052  piCur   = pcDtParam->pCur;
2053  iRows   = pcDtParam->iRows;
2054
2055  iDeltaC = uiRowCnt ? ((iOrigAvg - iCurAvg)/uiRowCnt/24) : 0;
2056
2057  for( ; iRows != 0; iRows-=iSubStep )
2058  {
2059    uiSum += abs( piOrg[0] - piCur[0] - iDeltaC );
2060    uiSum += abs( piOrg[1] - piCur[1] - iDeltaC );
2061    uiSum += abs( piOrg[2] - piCur[2] - iDeltaC );
2062    uiSum += abs( piOrg[3] - piCur[3] - iDeltaC );
2063    uiSum += abs( piOrg[4] - piCur[4] - iDeltaC );
2064    uiSum += abs( piOrg[5] - piCur[5] - iDeltaC );
2065    uiSum += abs( piOrg[6] - piCur[6] - iDeltaC );
2066    uiSum += abs( piOrg[7] - piCur[7] - iDeltaC );
2067    uiSum += abs( piOrg[8] - piCur[8] - iDeltaC );
2068    uiSum += abs( piOrg[9] - piCur[9] - iDeltaC );
2069    uiSum += abs( piOrg[10] - piCur[10] - iDeltaC );
2070    uiSum += abs( piOrg[11] - piCur[11] - iDeltaC );
2071    uiSum += abs( piOrg[12] - piCur[12] - iDeltaC );
2072    uiSum += abs( piOrg[13] - piCur[13] - iDeltaC );
2073    uiSum += abs( piOrg[14] - piCur[14] - iDeltaC );
2074    uiSum += abs( piOrg[15] - piCur[15] - iDeltaC );
2075    uiSum += abs( piOrg[16] - piCur[16] - iDeltaC );
2076    uiSum += abs( piOrg[17] - piCur[17] - iDeltaC );
2077    uiSum += abs( piOrg[18] - piCur[18] - iDeltaC );
2078    uiSum += abs( piOrg[19] - piCur[19] - iDeltaC );
2079    uiSum += abs( piOrg[20] - piCur[20] - iDeltaC );
2080    uiSum += abs( piOrg[21] - piCur[21] - iDeltaC );
2081    uiSum += abs( piOrg[22] - piCur[22] - iDeltaC );
2082    uiSum += abs( piOrg[23] - piCur[23] - iDeltaC );
2083
2084    piOrg += iStrideOrg;
2085    piCur += iStrideCur;
2086  }
2087
2088  uiSum <<= iSubShift;
2089  return ( uiSum >> DISTORTION_PRECISION_ADJUSTMENT( pcDtParam->bitDepth - 8 ) );
2090}
2091
2092UInt TComRdCost::xGetSAD64ic( DistParam* pcDtParam )
2093{
2094  if ( pcDtParam->bApplyWeight )
2095  {
2096    return xGetSADw( pcDtParam );
2097  }
2098  Pel* piOrg   = pcDtParam->pOrg;
2099  Pel* piCur   = pcDtParam->pCur;
2100  Int  iRows   = pcDtParam->iRows;
2101  Int  iSubShift  = pcDtParam->iSubShift;
2102  Int  iSubStep   = ( 1 << iSubShift );
2103  Int  iStrideCur = pcDtParam->iStrideCur*iSubStep;
2104  Int  iStrideOrg = pcDtParam->iStrideOrg*iSubStep;
2105
2106  UInt uiSum = 0;
2107
2108  Int  iOrigAvg = 0, iCurAvg = 0, uiRowCnt = 0;
2109  Int  iDeltaC;
2110
2111  for( ; iRows != 0; iRows-=iSubStep )
2112  {
2113    iOrigAvg += piOrg[0] ;
2114    iOrigAvg += piOrg[1] ;
2115    iOrigAvg += piOrg[2] ;
2116    iOrigAvg += piOrg[3] ;
2117    iOrigAvg += piOrg[4] ;
2118    iOrigAvg += piOrg[5] ;
2119    iOrigAvg += piOrg[6] ;
2120    iOrigAvg += piOrg[7] ;
2121    iOrigAvg += piOrg[8] ;
2122    iOrigAvg += piOrg[9] ;
2123    iOrigAvg += piOrg[10] ;
2124    iOrigAvg += piOrg[11] ;
2125    iOrigAvg += piOrg[12] ;
2126    iOrigAvg += piOrg[13] ;
2127    iOrigAvg += piOrg[14] ;
2128    iOrigAvg += piOrg[15] ;
2129    iOrigAvg += piOrg[16] ;
2130    iOrigAvg += piOrg[17] ;
2131    iOrigAvg += piOrg[18] ;
2132    iOrigAvg += piOrg[19] ;
2133    iOrigAvg += piOrg[20] ;
2134    iOrigAvg += piOrg[21] ;
2135    iOrigAvg += piOrg[22] ;
2136    iOrigAvg += piOrg[23] ;
2137    iOrigAvg += piOrg[24] ;
2138    iOrigAvg += piOrg[25] ;
2139    iOrigAvg += piOrg[26] ;
2140    iOrigAvg += piOrg[27] ;
2141    iOrigAvg += piOrg[28] ;
2142    iOrigAvg += piOrg[29] ;
2143    iOrigAvg += piOrg[30] ;
2144    iOrigAvg += piOrg[31] ;
2145    iOrigAvg += piOrg[32] ;
2146    iOrigAvg += piOrg[33] ;
2147    iOrigAvg += piOrg[34] ;
2148    iOrigAvg += piOrg[35] ;
2149    iOrigAvg += piOrg[36] ;
2150    iOrigAvg += piOrg[37] ;
2151    iOrigAvg += piOrg[38] ;
2152    iOrigAvg += piOrg[39] ;
2153    iOrigAvg += piOrg[40] ;
2154    iOrigAvg += piOrg[41] ;
2155    iOrigAvg += piOrg[42] ;
2156    iOrigAvg += piOrg[43] ;
2157    iOrigAvg += piOrg[44] ;
2158    iOrigAvg += piOrg[45] ;
2159    iOrigAvg += piOrg[46] ;
2160    iOrigAvg += piOrg[47] ;
2161    iOrigAvg += piOrg[48] ;
2162    iOrigAvg += piOrg[49] ;
2163    iOrigAvg += piOrg[50] ;
2164    iOrigAvg += piOrg[51] ;
2165    iOrigAvg += piOrg[52] ;
2166    iOrigAvg += piOrg[53] ;
2167    iOrigAvg += piOrg[54] ;
2168    iOrigAvg += piOrg[55] ;
2169    iOrigAvg += piOrg[56] ;
2170    iOrigAvg += piOrg[57] ;
2171    iOrigAvg += piOrg[58] ;
2172    iOrigAvg += piOrg[59] ;
2173    iOrigAvg += piOrg[60] ;
2174    iOrigAvg += piOrg[61] ;
2175    iOrigAvg += piOrg[62] ;
2176    iOrigAvg += piOrg[63] ;
2177
2178    iCurAvg += piCur[0] ;
2179    iCurAvg += piCur[1] ;
2180    iCurAvg += piCur[2] ;
2181    iCurAvg += piCur[3] ;
2182    iCurAvg += piCur[4] ;
2183    iCurAvg += piCur[5] ;
2184    iCurAvg += piCur[6] ;
2185    iCurAvg += piCur[7] ;
2186    iCurAvg += piCur[8] ;
2187    iCurAvg += piCur[9] ;
2188    iCurAvg += piCur[10] ;
2189    iCurAvg += piCur[11] ;
2190    iCurAvg += piCur[12] ;
2191    iCurAvg += piCur[13] ;
2192    iCurAvg += piCur[14] ;
2193    iCurAvg += piCur[15] ;
2194    iCurAvg += piCur[16] ;
2195    iCurAvg += piCur[17] ;
2196    iCurAvg += piCur[18] ;
2197    iCurAvg += piCur[19] ;
2198    iCurAvg += piCur[20] ;
2199    iCurAvg += piCur[21] ;
2200    iCurAvg += piCur[22] ;
2201    iCurAvg += piCur[23] ;
2202    iCurAvg += piCur[24] ;
2203    iCurAvg += piCur[25] ;
2204    iCurAvg += piCur[26] ;
2205    iCurAvg += piCur[27] ;
2206    iCurAvg += piCur[28] ;
2207    iCurAvg += piCur[29] ;
2208    iCurAvg += piCur[30] ;
2209    iCurAvg += piCur[31] ;
2210    iCurAvg += piCur[32] ;
2211    iCurAvg += piCur[33] ;
2212    iCurAvg += piCur[34] ;
2213    iCurAvg += piCur[35] ;
2214    iCurAvg += piCur[36] ;
2215    iCurAvg += piCur[37] ;
2216    iCurAvg += piCur[38] ;
2217    iCurAvg += piCur[39] ;
2218    iCurAvg += piCur[40] ;
2219    iCurAvg += piCur[41] ;
2220    iCurAvg += piCur[42] ;
2221    iCurAvg += piCur[43] ;
2222    iCurAvg += piCur[44] ;
2223    iCurAvg += piCur[45] ;
2224    iCurAvg += piCur[46] ;
2225    iCurAvg += piCur[47] ;
2226    iCurAvg += piCur[48] ;
2227    iCurAvg += piCur[49] ;
2228    iCurAvg += piCur[50] ;
2229    iCurAvg += piCur[51] ;
2230    iCurAvg += piCur[52] ;
2231    iCurAvg += piCur[53] ;
2232    iCurAvg += piCur[54] ;
2233    iCurAvg += piCur[55] ;
2234    iCurAvg += piCur[56] ;
2235    iCurAvg += piCur[57] ;
2236    iCurAvg += piCur[58] ;
2237    iCurAvg += piCur[59] ;
2238    iCurAvg += piCur[60] ;
2239    iCurAvg += piCur[61] ;
2240    iCurAvg += piCur[62] ;
2241    iCurAvg += piCur[63] ;
2242
2243    piOrg += iStrideOrg;
2244    piCur += iStrideCur;
2245    uiRowCnt++;
2246  }
2247
2248  piOrg   = pcDtParam->pOrg;
2249  piCur   = pcDtParam->pCur;
2250  iRows   = pcDtParam->iRows;
2251
2252  iDeltaC = uiRowCnt ? ((iOrigAvg - iCurAvg)/uiRowCnt/64) : 0;
2253
2254  for( ; iRows != 0; iRows-=iSubStep )
2255  {
2256    uiSum += abs( piOrg[0] - piCur[0] - iDeltaC );
2257    uiSum += abs( piOrg[1] - piCur[1] - iDeltaC );
2258    uiSum += abs( piOrg[2] - piCur[2] - iDeltaC );
2259    uiSum += abs( piOrg[3] - piCur[3] - iDeltaC );
2260    uiSum += abs( piOrg[4] - piCur[4] - iDeltaC );
2261    uiSum += abs( piOrg[5] - piCur[5] - iDeltaC );
2262    uiSum += abs( piOrg[6] - piCur[6] - iDeltaC );
2263    uiSum += abs( piOrg[7] - piCur[7] - iDeltaC );
2264    uiSum += abs( piOrg[8] - piCur[8] - iDeltaC );
2265    uiSum += abs( piOrg[9] - piCur[9] - iDeltaC );
2266    uiSum += abs( piOrg[10] - piCur[10] - iDeltaC );
2267    uiSum += abs( piOrg[11] - piCur[11] - iDeltaC );
2268    uiSum += abs( piOrg[12] - piCur[12] - iDeltaC );
2269    uiSum += abs( piOrg[13] - piCur[13] - iDeltaC );
2270    uiSum += abs( piOrg[14] - piCur[14] - iDeltaC );
2271    uiSum += abs( piOrg[15] - piCur[15] - iDeltaC );
2272    uiSum += abs( piOrg[16] - piCur[16] - iDeltaC );
2273    uiSum += abs( piOrg[17] - piCur[17] - iDeltaC );
2274    uiSum += abs( piOrg[18] - piCur[18] - iDeltaC );
2275    uiSum += abs( piOrg[19] - piCur[19] - iDeltaC );
2276    uiSum += abs( piOrg[20] - piCur[20] - iDeltaC );
2277    uiSum += abs( piOrg[21] - piCur[21] - iDeltaC );
2278    uiSum += abs( piOrg[22] - piCur[22] - iDeltaC );
2279    uiSum += abs( piOrg[23] - piCur[23] - iDeltaC );
2280    uiSum += abs( piOrg[24] - piCur[24] - iDeltaC );
2281    uiSum += abs( piOrg[25] - piCur[25] - iDeltaC );
2282    uiSum += abs( piOrg[26] - piCur[26] - iDeltaC );
2283    uiSum += abs( piOrg[27] - piCur[27] - iDeltaC );
2284    uiSum += abs( piOrg[28] - piCur[28] - iDeltaC );
2285    uiSum += abs( piOrg[29] - piCur[29] - iDeltaC );
2286    uiSum += abs( piOrg[30] - piCur[30] - iDeltaC );
2287    uiSum += abs( piOrg[31] - piCur[31] - iDeltaC );
2288    uiSum += abs( piOrg[32] - piCur[32] - iDeltaC );
2289    uiSum += abs( piOrg[33] - piCur[33] - iDeltaC );
2290    uiSum += abs( piOrg[34] - piCur[34] - iDeltaC );
2291    uiSum += abs( piOrg[35] - piCur[35] - iDeltaC );
2292    uiSum += abs( piOrg[36] - piCur[36] - iDeltaC );
2293    uiSum += abs( piOrg[37] - piCur[37] - iDeltaC );
2294    uiSum += abs( piOrg[38] - piCur[38] - iDeltaC );
2295    uiSum += abs( piOrg[39] - piCur[39] - iDeltaC );
2296    uiSum += abs( piOrg[40] - piCur[40] - iDeltaC );
2297    uiSum += abs( piOrg[41] - piCur[41] - iDeltaC );
2298    uiSum += abs( piOrg[42] - piCur[42] - iDeltaC );
2299    uiSum += abs( piOrg[43] - piCur[43] - iDeltaC );
2300    uiSum += abs( piOrg[44] - piCur[44] - iDeltaC );
2301    uiSum += abs( piOrg[45] - piCur[45] - iDeltaC );
2302    uiSum += abs( piOrg[46] - piCur[46] - iDeltaC );
2303    uiSum += abs( piOrg[47] - piCur[47] - iDeltaC );
2304    uiSum += abs( piOrg[48] - piCur[48] - iDeltaC );
2305    uiSum += abs( piOrg[49] - piCur[49] - iDeltaC );
2306    uiSum += abs( piOrg[50] - piCur[50] - iDeltaC );
2307    uiSum += abs( piOrg[51] - piCur[51] - iDeltaC );
2308    uiSum += abs( piOrg[52] - piCur[52] - iDeltaC );
2309    uiSum += abs( piOrg[53] - piCur[53] - iDeltaC );
2310    uiSum += abs( piOrg[54] - piCur[54] - iDeltaC );
2311    uiSum += abs( piOrg[55] - piCur[55] - iDeltaC );
2312    uiSum += abs( piOrg[56] - piCur[56] - iDeltaC );
2313    uiSum += abs( piOrg[57] - piCur[57] - iDeltaC );
2314    uiSum += abs( piOrg[58] - piCur[58] - iDeltaC );
2315    uiSum += abs( piOrg[59] - piCur[59] - iDeltaC );
2316    uiSum += abs( piOrg[60] - piCur[60] - iDeltaC );
2317    uiSum += abs( piOrg[61] - piCur[61] - iDeltaC );
2318    uiSum += abs( piOrg[62] - piCur[62] - iDeltaC );
2319    uiSum += abs( piOrg[63] - piCur[63] - iDeltaC );
2320
2321    piOrg += iStrideOrg;
2322    piCur += iStrideCur;
2323  }
2324
2325  uiSum <<= iSubShift;
2326  return ( uiSum >> DISTORTION_PRECISION_ADJUSTMENT( pcDtParam->bitDepth - 8 ) );
2327}
2328
2329
2330UInt TComRdCost::xGetSAD48ic( DistParam* pcDtParam )
2331{
2332  if ( pcDtParam->bApplyWeight )
2333  {
2334    return xGetSADw( pcDtParam );
2335  }
2336
2337  Pel* piOrg   = pcDtParam->pOrg;
2338  Pel* piCur   = pcDtParam->pCur;
2339  Int  iRows   = pcDtParam->iRows;
2340  Int  iSubShift  = pcDtParam->iSubShift;
2341  Int  iSubStep   = ( 1 << iSubShift );
2342  Int  iStrideCur = pcDtParam->iStrideCur*iSubStep;
2343  Int  iStrideOrg = pcDtParam->iStrideOrg*iSubStep;
2344
2345  UInt uiSum = 0;
2346
2347  Int  iOrigAvg = 0, iCurAvg = 0, uiRowCnt = 0;
2348  Int  iDeltaC;
2349
2350  for( ; iRows != 0; iRows-=iSubStep )
2351  {
2352    iOrigAvg += piOrg[0] ;
2353    iOrigAvg += piOrg[1] ;
2354    iOrigAvg += piOrg[2] ;
2355    iOrigAvg += piOrg[3] ;
2356    iOrigAvg += piOrg[4] ;
2357    iOrigAvg += piOrg[5] ;
2358    iOrigAvg += piOrg[6] ;
2359    iOrigAvg += piOrg[7] ;
2360    iOrigAvg += piOrg[8] ;
2361    iOrigAvg += piOrg[9] ;
2362    iOrigAvg += piOrg[10] ;
2363    iOrigAvg += piOrg[11] ;
2364    iOrigAvg += piOrg[12] ;
2365    iOrigAvg += piOrg[13] ;
2366    iOrigAvg += piOrg[14] ;
2367    iOrigAvg += piOrg[15] ;
2368    iOrigAvg += piOrg[16] ;
2369    iOrigAvg += piOrg[17] ;
2370    iOrigAvg += piOrg[18] ;
2371    iOrigAvg += piOrg[19] ;
2372    iOrigAvg += piOrg[20] ;
2373    iOrigAvg += piOrg[21] ;
2374    iOrigAvg += piOrg[22] ;
2375    iOrigAvg += piOrg[23] ;
2376    iOrigAvg += piOrg[24] ;
2377    iOrigAvg += piOrg[25] ;
2378    iOrigAvg += piOrg[26] ;
2379    iOrigAvg += piOrg[27] ;
2380    iOrigAvg += piOrg[28] ;
2381    iOrigAvg += piOrg[29] ;
2382    iOrigAvg += piOrg[30] ;
2383    iOrigAvg += piOrg[31] ;
2384    iOrigAvg += piOrg[32] ;
2385    iOrigAvg += piOrg[33] ;
2386    iOrigAvg += piOrg[34] ;
2387    iOrigAvg += piOrg[35] ;
2388    iOrigAvg += piOrg[36] ;
2389    iOrigAvg += piOrg[37] ;
2390    iOrigAvg += piOrg[38] ;
2391    iOrigAvg += piOrg[39] ;
2392    iOrigAvg += piOrg[40] ;
2393    iOrigAvg += piOrg[41] ;
2394    iOrigAvg += piOrg[42] ;
2395    iOrigAvg += piOrg[43] ;
2396    iOrigAvg += piOrg[44] ;
2397    iOrigAvg += piOrg[45] ;
2398    iOrigAvg += piOrg[46] ;
2399    iOrigAvg += piOrg[47] ;
2400
2401    iCurAvg += piCur[0] ;
2402    iCurAvg += piCur[1] ;
2403    iCurAvg += piCur[2] ;
2404    iCurAvg += piCur[3] ;
2405    iCurAvg += piCur[4] ;
2406    iCurAvg += piCur[5] ;
2407    iCurAvg += piCur[6] ;
2408    iCurAvg += piCur[7] ;
2409    iCurAvg += piCur[8] ;
2410    iCurAvg += piCur[9] ;
2411    iCurAvg += piCur[10] ;
2412    iCurAvg += piCur[11] ;
2413    iCurAvg += piCur[12] ;
2414    iCurAvg += piCur[13] ;
2415    iCurAvg += piCur[14] ;
2416    iCurAvg += piCur[15] ;
2417    iCurAvg += piCur[16] ;
2418    iCurAvg += piCur[17] ;
2419    iCurAvg += piCur[18] ;
2420    iCurAvg += piCur[19] ;
2421    iCurAvg += piCur[20] ;
2422    iCurAvg += piCur[21] ;
2423    iCurAvg += piCur[22] ;
2424    iCurAvg += piCur[23] ;
2425    iCurAvg += piCur[24] ;
2426    iCurAvg += piCur[25] ;
2427    iCurAvg += piCur[26] ;
2428    iCurAvg += piCur[27] ;
2429    iCurAvg += piCur[28] ;
2430    iCurAvg += piCur[29] ;
2431    iCurAvg += piCur[30] ;
2432    iCurAvg += piCur[31] ;
2433    iCurAvg += piCur[32] ;
2434    iCurAvg += piCur[33] ;
2435    iCurAvg += piCur[34] ;
2436    iCurAvg += piCur[35] ;
2437    iCurAvg += piCur[36] ;
2438    iCurAvg += piCur[37] ;
2439    iCurAvg += piCur[38] ;
2440    iCurAvg += piCur[39] ;
2441    iCurAvg += piCur[40] ;
2442    iCurAvg += piCur[41] ;
2443    iCurAvg += piCur[42] ;
2444    iCurAvg += piCur[43] ;
2445    iCurAvg += piCur[44] ;
2446    iCurAvg += piCur[45] ;
2447    iCurAvg += piCur[46] ;
2448    iCurAvg += piCur[47] ;
2449
2450    piOrg += iStrideOrg;
2451    piCur += iStrideCur;
2452    uiRowCnt++;
2453  }
2454
2455  piOrg   = pcDtParam->pOrg;
2456  piCur   = pcDtParam->pCur;
2457  iRows   = pcDtParam->iRows;
2458
2459  iDeltaC = uiRowCnt ? ((iOrigAvg - iCurAvg)/uiRowCnt/48) : 0;
2460
2461  for( ; iRows != 0; iRows-=iSubStep )
2462  {
2463    uiSum += abs( piOrg[0] - piCur[0] - iDeltaC );
2464    uiSum += abs( piOrg[1] - piCur[1] - iDeltaC );
2465    uiSum += abs( piOrg[2] - piCur[2] - iDeltaC );
2466    uiSum += abs( piOrg[3] - piCur[3] - iDeltaC );
2467    uiSum += abs( piOrg[4] - piCur[4] - iDeltaC );
2468    uiSum += abs( piOrg[5] - piCur[5] - iDeltaC );
2469    uiSum += abs( piOrg[6] - piCur[6] - iDeltaC );
2470    uiSum += abs( piOrg[7] - piCur[7] - iDeltaC );
2471    uiSum += abs( piOrg[8] - piCur[8] - iDeltaC );
2472    uiSum += abs( piOrg[9] - piCur[9] - iDeltaC );
2473    uiSum += abs( piOrg[10] - piCur[10] - iDeltaC );
2474    uiSum += abs( piOrg[11] - piCur[11] - iDeltaC );
2475    uiSum += abs( piOrg[12] - piCur[12] - iDeltaC );
2476    uiSum += abs( piOrg[13] - piCur[13] - iDeltaC );
2477    uiSum += abs( piOrg[14] - piCur[14] - iDeltaC );
2478    uiSum += abs( piOrg[15] - piCur[15] - iDeltaC );
2479    uiSum += abs( piOrg[16] - piCur[16] - iDeltaC );
2480    uiSum += abs( piOrg[17] - piCur[17] - iDeltaC );
2481    uiSum += abs( piOrg[18] - piCur[18] - iDeltaC );
2482    uiSum += abs( piOrg[19] - piCur[19] - iDeltaC );
2483    uiSum += abs( piOrg[20] - piCur[20] - iDeltaC );
2484    uiSum += abs( piOrg[21] - piCur[21] - iDeltaC );
2485    uiSum += abs( piOrg[22] - piCur[22] - iDeltaC );
2486    uiSum += abs( piOrg[23] - piCur[23] - iDeltaC );
2487    uiSum += abs( piOrg[24] - piCur[24] - iDeltaC );
2488    uiSum += abs( piOrg[25] - piCur[25] - iDeltaC );
2489    uiSum += abs( piOrg[26] - piCur[26] - iDeltaC );
2490    uiSum += abs( piOrg[27] - piCur[27] - iDeltaC );
2491    uiSum += abs( piOrg[28] - piCur[28] - iDeltaC );
2492    uiSum += abs( piOrg[29] - piCur[29] - iDeltaC );
2493    uiSum += abs( piOrg[30] - piCur[30] - iDeltaC );
2494    uiSum += abs( piOrg[31] - piCur[31] - iDeltaC );
2495    uiSum += abs( piOrg[32] - piCur[32] - iDeltaC );
2496    uiSum += abs( piOrg[33] - piCur[33] - iDeltaC );
2497    uiSum += abs( piOrg[34] - piCur[34] - iDeltaC );
2498    uiSum += abs( piOrg[35] - piCur[35] - iDeltaC );
2499    uiSum += abs( piOrg[36] - piCur[36] - iDeltaC );
2500    uiSum += abs( piOrg[37] - piCur[37] - iDeltaC );
2501    uiSum += abs( piOrg[38] - piCur[38] - iDeltaC );
2502    uiSum += abs( piOrg[39] - piCur[39] - iDeltaC );
2503    uiSum += abs( piOrg[40] - piCur[40] - iDeltaC );
2504    uiSum += abs( piOrg[41] - piCur[41] - iDeltaC );
2505    uiSum += abs( piOrg[42] - piCur[42] - iDeltaC );
2506    uiSum += abs( piOrg[43] - piCur[43] - iDeltaC );
2507    uiSum += abs( piOrg[44] - piCur[44] - iDeltaC );
2508    uiSum += abs( piOrg[45] - piCur[45] - iDeltaC );
2509    uiSum += abs( piOrg[46] - piCur[46] - iDeltaC );
2510    uiSum += abs( piOrg[47] - piCur[47] - iDeltaC );
2511
2512    piOrg += iStrideOrg;
2513    piCur += iStrideCur;
2514  }
2515
2516  uiSum <<= iSubShift;
2517  return ( uiSum >> DISTORTION_PRECISION_ADJUSTMENT( pcDtParam->bitDepth - 8 ) );
2518}
2519#endif
2520// --------------------------------------------------------------------------------------------------------------------
2521// SSE
2522// --------------------------------------------------------------------------------------------------------------------
2523
2524Distortion TComRdCost::xGetSSE( DistParam* pcDtParam )
2525{
2526  if ( pcDtParam->bApplyWeight )
2527  {
2528    return TComRdCostWeightPrediction::xGetSSEw( pcDtParam );
2529  }
2530  const Pel* piOrg   = pcDtParam->pOrg;
2531  const Pel* piCur   = pcDtParam->pCur;
2532  Int  iRows   = pcDtParam->iRows;
2533  Int  iCols   = pcDtParam->iCols;
2534  Int  iStrideOrg = pcDtParam->iStrideOrg;
2535  Int  iStrideCur = pcDtParam->iStrideCur;
2536
2537  Distortion uiSum   = 0;
2538  UInt       uiShift = DISTORTION_PRECISION_ADJUSTMENT((pcDtParam->bitDepth-8) << 1);
2539
2540  Intermediate_Int iTemp;
2541
2542  for( ; iRows != 0; iRows-- )
2543  {
2544    for (Int n = 0; n < iCols; n++ )
2545    {
2546      iTemp = piOrg[n  ] - piCur[n  ];
2547      uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2548    }
2549    piOrg += iStrideOrg;
2550    piCur += iStrideCur;
2551  }
2552
2553  return ( uiSum );
2554}
2555
2556Distortion TComRdCost::xGetSSE4( DistParam* pcDtParam )
2557{
2558  if ( pcDtParam->bApplyWeight )
2559  {
2560    assert( pcDtParam->iCols == 4 );
2561    return TComRdCostWeightPrediction::xGetSSEw( pcDtParam );
2562  }
2563  const Pel* piOrg   = pcDtParam->pOrg;
2564  const Pel* piCur   = pcDtParam->pCur;
2565  Int  iRows   = pcDtParam->iRows;
2566  Int  iStrideOrg = pcDtParam->iStrideOrg;
2567  Int  iStrideCur = pcDtParam->iStrideCur;
2568
2569  Distortion uiSum   = 0;
2570  UInt       uiShift = DISTORTION_PRECISION_ADJUSTMENT((pcDtParam->bitDepth-8) << 1);
2571
2572  Intermediate_Int  iTemp;
2573
2574  for( ; iRows != 0; iRows-- )
2575  {
2576
2577    iTemp = piOrg[0] - piCur[0]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2578    iTemp = piOrg[1] - piCur[1]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2579    iTemp = piOrg[2] - piCur[2]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2580    iTemp = piOrg[3] - piCur[3]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2581
2582    piOrg += iStrideOrg;
2583    piCur += iStrideCur;
2584  }
2585
2586  return ( uiSum );
2587}
2588
2589Distortion TComRdCost::xGetSSE8( DistParam* pcDtParam )
2590{
2591  if ( pcDtParam->bApplyWeight )
2592  {
2593    assert( pcDtParam->iCols == 8 );
2594    return TComRdCostWeightPrediction::xGetSSEw( pcDtParam );
2595  }
2596  const Pel* piOrg   = pcDtParam->pOrg;
2597  const Pel* piCur   = pcDtParam->pCur;
2598  Int  iRows   = pcDtParam->iRows;
2599  Int  iStrideOrg = pcDtParam->iStrideOrg;
2600  Int  iStrideCur = pcDtParam->iStrideCur;
2601
2602  Distortion uiSum   = 0;
2603  UInt       uiShift = DISTORTION_PRECISION_ADJUSTMENT((pcDtParam->bitDepth-8) << 1);
2604
2605  Intermediate_Int  iTemp;
2606
2607  for( ; iRows != 0; iRows-- )
2608  {
2609    iTemp = piOrg[0] - piCur[0]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2610    iTemp = piOrg[1] - piCur[1]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2611    iTemp = piOrg[2] - piCur[2]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2612    iTemp = piOrg[3] - piCur[3]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2613    iTemp = piOrg[4] - piCur[4]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2614    iTemp = piOrg[5] - piCur[5]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2615    iTemp = piOrg[6] - piCur[6]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2616    iTemp = piOrg[7] - piCur[7]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2617
2618    piOrg += iStrideOrg;
2619    piCur += iStrideCur;
2620  }
2621
2622  return ( uiSum );
2623}
2624
2625Distortion TComRdCost::xGetSSE16( DistParam* pcDtParam )
2626{
2627  if ( pcDtParam->bApplyWeight )
2628  {
2629    assert( pcDtParam->iCols == 16 );
2630    return TComRdCostWeightPrediction::xGetSSEw( pcDtParam );
2631  }
2632  const Pel* piOrg   = pcDtParam->pOrg;
2633  const Pel* piCur   = pcDtParam->pCur;
2634  Int  iRows   = pcDtParam->iRows;
2635  Int  iStrideOrg = pcDtParam->iStrideOrg;
2636  Int  iStrideCur = pcDtParam->iStrideCur;
2637
2638  Distortion uiSum   = 0;
2639  UInt       uiShift = DISTORTION_PRECISION_ADJUSTMENT((pcDtParam->bitDepth-8) << 1);
2640
2641  Intermediate_Int  iTemp;
2642
2643  for( ; iRows != 0; iRows-- )
2644  {
2645
2646    iTemp = piOrg[ 0] - piCur[ 0]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2647    iTemp = piOrg[ 1] - piCur[ 1]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2648    iTemp = piOrg[ 2] - piCur[ 2]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2649    iTemp = piOrg[ 3] - piCur[ 3]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2650    iTemp = piOrg[ 4] - piCur[ 4]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2651    iTemp = piOrg[ 5] - piCur[ 5]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2652    iTemp = piOrg[ 6] - piCur[ 6]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2653    iTemp = piOrg[ 7] - piCur[ 7]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2654    iTemp = piOrg[ 8] - piCur[ 8]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2655    iTemp = piOrg[ 9] - piCur[ 9]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2656    iTemp = piOrg[10] - piCur[10]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2657    iTemp = piOrg[11] - piCur[11]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2658    iTemp = piOrg[12] - piCur[12]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2659    iTemp = piOrg[13] - piCur[13]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2660    iTemp = piOrg[14] - piCur[14]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2661    iTemp = piOrg[15] - piCur[15]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2662
2663    piOrg += iStrideOrg;
2664    piCur += iStrideCur;
2665  }
2666
2667  return ( uiSum );
2668}
2669
2670Distortion TComRdCost::xGetSSE16N( DistParam* pcDtParam )
2671{
2672  if ( pcDtParam->bApplyWeight )
2673  {
2674    return TComRdCostWeightPrediction::xGetSSEw( pcDtParam );
2675  }
2676  const Pel* piOrg   = pcDtParam->pOrg;
2677  const Pel* piCur   = pcDtParam->pCur;
2678  Int  iRows   = pcDtParam->iRows;
2679  Int  iCols   = pcDtParam->iCols;
2680  Int  iStrideOrg = pcDtParam->iStrideOrg;
2681  Int  iStrideCur = pcDtParam->iStrideCur;
2682
2683  Distortion uiSum   = 0;
2684  UInt       uiShift = DISTORTION_PRECISION_ADJUSTMENT((pcDtParam->bitDepth-8) << 1);
2685
2686  Intermediate_Int  iTemp;
2687
2688  for( ; iRows != 0; iRows-- )
2689  {
2690    for (Int n = 0; n < iCols; n+=16 )
2691    {
2692
2693      iTemp = piOrg[n+ 0] - piCur[n+ 0]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2694      iTemp = piOrg[n+ 1] - piCur[n+ 1]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2695      iTemp = piOrg[n+ 2] - piCur[n+ 2]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2696      iTemp = piOrg[n+ 3] - piCur[n+ 3]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2697      iTemp = piOrg[n+ 4] - piCur[n+ 4]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2698      iTemp = piOrg[n+ 5] - piCur[n+ 5]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2699      iTemp = piOrg[n+ 6] - piCur[n+ 6]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2700      iTemp = piOrg[n+ 7] - piCur[n+ 7]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2701      iTemp = piOrg[n+ 8] - piCur[n+ 8]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2702      iTemp = piOrg[n+ 9] - piCur[n+ 9]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2703      iTemp = piOrg[n+10] - piCur[n+10]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2704      iTemp = piOrg[n+11] - piCur[n+11]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2705      iTemp = piOrg[n+12] - piCur[n+12]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2706      iTemp = piOrg[n+13] - piCur[n+13]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2707      iTemp = piOrg[n+14] - piCur[n+14]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2708      iTemp = piOrg[n+15] - piCur[n+15]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2709
2710    }
2711    piOrg += iStrideOrg;
2712    piCur += iStrideCur;
2713  }
2714
2715  return ( uiSum );
2716}
2717
2718Distortion TComRdCost::xGetSSE32( DistParam* pcDtParam )
2719{
2720  if ( pcDtParam->bApplyWeight )
2721  {
2722    assert( pcDtParam->iCols == 32 );
2723    return TComRdCostWeightPrediction::xGetSSEw( pcDtParam );
2724  }
2725  const Pel* piOrg   = pcDtParam->pOrg;
2726  const Pel* piCur   = pcDtParam->pCur;
2727  Int  iRows   = pcDtParam->iRows;
2728  Int  iStrideOrg = pcDtParam->iStrideOrg;
2729  Int  iStrideCur = pcDtParam->iStrideCur;
2730
2731  Distortion uiSum   = 0;
2732  UInt       uiShift = DISTORTION_PRECISION_ADJUSTMENT((pcDtParam->bitDepth-8) << 1);
2733
2734  Intermediate_Int  iTemp;
2735
2736  for( ; iRows != 0; iRows-- )
2737  {
2738
2739    iTemp = piOrg[ 0] - piCur[ 0]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2740    iTemp = piOrg[ 1] - piCur[ 1]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2741    iTemp = piOrg[ 2] - piCur[ 2]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2742    iTemp = piOrg[ 3] - piCur[ 3]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2743    iTemp = piOrg[ 4] - piCur[ 4]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2744    iTemp = piOrg[ 5] - piCur[ 5]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2745    iTemp = piOrg[ 6] - piCur[ 6]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2746    iTemp = piOrg[ 7] - piCur[ 7]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2747    iTemp = piOrg[ 8] - piCur[ 8]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2748    iTemp = piOrg[ 9] - piCur[ 9]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2749    iTemp = piOrg[10] - piCur[10]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2750    iTemp = piOrg[11] - piCur[11]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2751    iTemp = piOrg[12] - piCur[12]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2752    iTemp = piOrg[13] - piCur[13]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2753    iTemp = piOrg[14] - piCur[14]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2754    iTemp = piOrg[15] - piCur[15]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2755    iTemp = piOrg[16] - piCur[16]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2756    iTemp = piOrg[17] - piCur[17]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2757    iTemp = piOrg[18] - piCur[18]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2758    iTemp = piOrg[19] - piCur[19]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2759    iTemp = piOrg[20] - piCur[20]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2760    iTemp = piOrg[21] - piCur[21]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2761    iTemp = piOrg[22] - piCur[22]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2762    iTemp = piOrg[23] - piCur[23]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2763    iTemp = piOrg[24] - piCur[24]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2764    iTemp = piOrg[25] - piCur[25]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2765    iTemp = piOrg[26] - piCur[26]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2766    iTemp = piOrg[27] - piCur[27]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2767    iTemp = piOrg[28] - piCur[28]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2768    iTemp = piOrg[29] - piCur[29]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2769    iTemp = piOrg[30] - piCur[30]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2770    iTemp = piOrg[31] - piCur[31]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2771
2772    piOrg += iStrideOrg;
2773    piCur += iStrideCur;
2774  }
2775
2776  return ( uiSum );
2777}
2778
2779Distortion TComRdCost::xGetSSE64( DistParam* pcDtParam )
2780{
2781  if ( pcDtParam->bApplyWeight )
2782  {
2783    assert( pcDtParam->iCols == 64 );
2784    return TComRdCostWeightPrediction::xGetSSEw( pcDtParam );
2785  }
2786  const Pel* piOrg   = pcDtParam->pOrg;
2787  const Pel* piCur   = pcDtParam->pCur;
2788  Int  iRows   = pcDtParam->iRows;
2789  Int  iStrideOrg = pcDtParam->iStrideOrg;
2790  Int  iStrideCur = pcDtParam->iStrideCur;
2791
2792  Distortion uiSum   = 0;
2793  UInt       uiShift = DISTORTION_PRECISION_ADJUSTMENT((pcDtParam->bitDepth-8) << 1);
2794
2795  Intermediate_Int  iTemp;
2796
2797  for( ; iRows != 0; iRows-- )
2798  {
2799    iTemp = piOrg[ 0] - piCur[ 0]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2800    iTemp = piOrg[ 1] - piCur[ 1]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2801    iTemp = piOrg[ 2] - piCur[ 2]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2802    iTemp = piOrg[ 3] - piCur[ 3]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2803    iTemp = piOrg[ 4] - piCur[ 4]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2804    iTemp = piOrg[ 5] - piCur[ 5]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2805    iTemp = piOrg[ 6] - piCur[ 6]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2806    iTemp = piOrg[ 7] - piCur[ 7]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2807    iTemp = piOrg[ 8] - piCur[ 8]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2808    iTemp = piOrg[ 9] - piCur[ 9]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2809    iTemp = piOrg[10] - piCur[10]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2810    iTemp = piOrg[11] - piCur[11]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2811    iTemp = piOrg[12] - piCur[12]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2812    iTemp = piOrg[13] - piCur[13]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2813    iTemp = piOrg[14] - piCur[14]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2814    iTemp = piOrg[15] - piCur[15]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2815    iTemp = piOrg[16] - piCur[16]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2816    iTemp = piOrg[17] - piCur[17]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2817    iTemp = piOrg[18] - piCur[18]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2818    iTemp = piOrg[19] - piCur[19]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2819    iTemp = piOrg[20] - piCur[20]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2820    iTemp = piOrg[21] - piCur[21]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2821    iTemp = piOrg[22] - piCur[22]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2822    iTemp = piOrg[23] - piCur[23]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2823    iTemp = piOrg[24] - piCur[24]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2824    iTemp = piOrg[25] - piCur[25]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2825    iTemp = piOrg[26] - piCur[26]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2826    iTemp = piOrg[27] - piCur[27]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2827    iTemp = piOrg[28] - piCur[28]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2828    iTemp = piOrg[29] - piCur[29]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2829    iTemp = piOrg[30] - piCur[30]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2830    iTemp = piOrg[31] - piCur[31]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2831    iTemp = piOrg[32] - piCur[32]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2832    iTemp = piOrg[33] - piCur[33]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2833    iTemp = piOrg[34] - piCur[34]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2834    iTemp = piOrg[35] - piCur[35]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2835    iTemp = piOrg[36] - piCur[36]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2836    iTemp = piOrg[37] - piCur[37]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2837    iTemp = piOrg[38] - piCur[38]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2838    iTemp = piOrg[39] - piCur[39]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2839    iTemp = piOrg[40] - piCur[40]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2840    iTemp = piOrg[41] - piCur[41]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2841    iTemp = piOrg[42] - piCur[42]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2842    iTemp = piOrg[43] - piCur[43]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2843    iTemp = piOrg[44] - piCur[44]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2844    iTemp = piOrg[45] - piCur[45]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2845    iTemp = piOrg[46] - piCur[46]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2846    iTemp = piOrg[47] - piCur[47]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2847    iTemp = piOrg[48] - piCur[48]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2848    iTemp = piOrg[49] - piCur[49]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2849    iTemp = piOrg[50] - piCur[50]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2850    iTemp = piOrg[51] - piCur[51]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2851    iTemp = piOrg[52] - piCur[52]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2852    iTemp = piOrg[53] - piCur[53]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2853    iTemp = piOrg[54] - piCur[54]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2854    iTemp = piOrg[55] - piCur[55]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2855    iTemp = piOrg[56] - piCur[56]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2856    iTemp = piOrg[57] - piCur[57]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2857    iTemp = piOrg[58] - piCur[58]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2858    iTemp = piOrg[59] - piCur[59]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2859    iTemp = piOrg[60] - piCur[60]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2860    iTemp = piOrg[61] - piCur[61]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2861    iTemp = piOrg[62] - piCur[62]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2862    iTemp = piOrg[63] - piCur[63]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
2863
2864    piOrg += iStrideOrg;
2865    piCur += iStrideCur;
2866  }
2867
2868  return ( uiSum );
2869}
2870
2871#if NH_3D_VSO
2872//SAIT_VSO_EST_A0033
2873UInt TComRdCost::getVSDEstimate( Int dDM, Pel* pOrg, Int iOrgStride,  Pel* pVirRec, Pel* pVirOrg, Int iVirStride, Int x, Int y )
2874{ 
2875  // change to use bit depth from DistParam struct
2876  Double  dD = ( (Double) ( dDM >> ( ENC_INTERNAL_BIT_DEPTH - 8 ) ) ) * m_dDisparityCoeff;
2877
2878  Double dDepthWeight = ( pOrg[x] >=  ( (1<<(REN_BIT_DEPTH - 3)) + (1<<(REN_BIT_DEPTH - 2)) ) ? 4 : pOrg[x] > ((1<<REN_BIT_DEPTH) >> 4) ? (Float)(pOrg[x] - ((1<<REN_BIT_DEPTH) >> 4))/(Float)((1<<REN_BIT_DEPTH) >> 3) + 1 : 1.0 );
2879
2880  Double dTemp = ( 0.5 * fabs(dD) * dDepthWeight * ( abs( (Int) pVirRec[ x+y*iVirStride ] - (Int) pVirRec[ x-1+y*iVirStride ] ) + abs( (Int) pVirRec[ x+y*iVirStride ] - (Int) pVirRec[ x+1+y*iVirStride ] ) ) );
2881  Int iTemp = (Int) (((dTemp) < 0)? (Int)((dTemp) - 0.5) : (Int)((dTemp) + 0.5));
2882
2883  return (UInt) ( (iTemp*iTemp)>>1 );
2884}
2885
2886UInt TComRdCost::xGetVSD( DistParam* pcDtParam )
2887{
2888  Pel* piOrg    = pcDtParam->pOrg;
2889  Pel* piCur    = pcDtParam->pCur;
2890  Pel* piVirRec = pcDtParam->pVirRec;
2891  Pel* piVirOrg = pcDtParam->pVirOrg;
2892  Int  iRows    = pcDtParam->iRows;
2893  Int  iCols    = pcDtParam->iCols;
2894  Int  iStrideOrg = pcDtParam->iStrideOrg;
2895  Int  iStrideCur = pcDtParam->iStrideCur;
2896  Int  iStrideVir = pcDtParam->iStrideVir;
2897
2898  UInt uiSum = 0;
2899  UInt uiShift = DISTORTION_PRECISION_ADJUSTMENT(pcDtParam->bitDepth-8)<<1;
2900
2901  Int dDM;
2902
2903  for ( Int y = 0 ; y < iRows ; y++ )
2904  {
2905    for (Int x = 0; x < iCols; x++ )
2906    {
2907      dDM = (Int) ( piOrg[x  ] - piCur[x  ] );
2908      uiSum += getVSDEstimate( dDM, piOrg, iStrideOrg, piVirRec, piVirOrg, iStrideVir, x, y ) >> uiShift;
2909    }
2910    piOrg += iStrideOrg;
2911    piCur += iStrideCur; 
2912  }
2913
2914  return ( uiSum );
2915}
2916
2917UInt TComRdCost::xGetVSD4( DistParam* pcDtParam )
2918{
2919  Pel* piOrg   = pcDtParam->pOrg;
2920  Pel* piCur   = pcDtParam->pCur;
2921  Pel* piVirRec = pcDtParam->pVirRec;
2922  Pel* piVirOrg = pcDtParam->pVirOrg;
2923  Int  iRows   = pcDtParam->iRows;
2924  Int  iStrideOrg = pcDtParam->iStrideOrg;
2925  Int  iStrideCur = pcDtParam->iStrideCur;
2926  Int  iStrideVir = pcDtParam->iStrideVir;
2927
2928  UInt uiSum = 0;
2929  UInt uiShift = DISTORTION_PRECISION_ADJUSTMENT(pcDtParam->bitDepth-8)<<1;
2930
2931  Int dDM;
2932
2933  for ( Int y = 0 ; y < iRows ; y++ )
2934  {
2935    dDM = (Int) ( piOrg[0] - piCur[0] );  uiSum += ( getVSDEstimate( dDM, piOrg, iStrideOrg, piVirRec, piVirOrg, iStrideVir, 0, y ) ) >> uiShift;
2936    dDM = (Int) ( piOrg[1] - piCur[1] );  uiSum += ( getVSDEstimate( dDM, piOrg, iStrideOrg, piVirRec, piVirOrg, iStrideVir, 1, y ) ) >> uiShift;
2937    dDM = (Int) ( piOrg[2] - piCur[2] );  uiSum += ( getVSDEstimate( dDM, piOrg, iStrideOrg, piVirRec, piVirOrg, iStrideVir, 2, y ) ) >> uiShift;
2938    dDM = (Int) ( piOrg[3] - piCur[3] );  uiSum += ( getVSDEstimate( dDM, piOrg, iStrideOrg, piVirRec, piVirOrg, iStrideVir, 3, y ) ) >> uiShift;
2939
2940    piOrg += iStrideOrg;
2941    piCur += iStrideCur;
2942  }
2943
2944  return ( uiSum );
2945}
2946
2947UInt TComRdCost::xGetVSD8( DistParam* pcDtParam )
2948{
2949  Pel* piOrg   = pcDtParam->pOrg;
2950  Pel* piCur   = pcDtParam->pCur;
2951  Pel* piVirRec = pcDtParam->pVirRec;
2952  Pel* piVirOrg = pcDtParam->pVirOrg;
2953  Int  iRows   = pcDtParam->iRows;
2954  Int  iStrideOrg = pcDtParam->iStrideOrg;
2955  Int  iStrideCur = pcDtParam->iStrideCur;
2956  Int  iStrideVir = pcDtParam->iStrideVir;
2957
2958  UInt uiSum = 0;
2959  UInt uiShift = DISTORTION_PRECISION_ADJUSTMENT(pcDtParam->bitDepth-8)<<1;
2960
2961  Int dDM;
2962
2963  for ( Int y = 0 ; y < iRows ; y++ )
2964  {
2965    for (Int x = 0; x < 8; x++ )
2966    {
2967      dDM = (Int) ( piOrg[x] - piCur[x] );
2968      uiSum += getVSDEstimate( dDM, piOrg, iStrideOrg, piVirRec, piVirOrg, iStrideVir, x, y ) >> uiShift;
2969    }
2970    piOrg += iStrideOrg;
2971    piCur += iStrideCur;
2972  }
2973
2974  return ( uiSum );
2975}
2976
2977UInt TComRdCost::xGetVSD16( DistParam* pcDtParam )
2978{
2979  Pel* piOrg   = pcDtParam->pOrg;
2980  Pel* piCur   = pcDtParam->pCur;
2981  Pel* piVirRec = pcDtParam->pVirRec;
2982  Pel* piVirOrg = pcDtParam->pVirOrg;
2983  Int  iRows   = pcDtParam->iRows;
2984  Int  iStrideOrg = pcDtParam->iStrideOrg;
2985  Int  iStrideCur = pcDtParam->iStrideCur;
2986  Int  iStrideVir = pcDtParam->iStrideVir;
2987
2988  UInt uiSum = 0;
2989  UInt uiShift = DISTORTION_PRECISION_ADJUSTMENT(pcDtParam->bitDepth-8)<<1;
2990
2991  Int dDM;
2992
2993  for ( Int y = 0 ; y < iRows ; y++ )
2994  {
2995    for (Int x = 0; x < 16; x++ )
2996    {
2997      dDM = (Int) ( piOrg[x] - piCur[x] );
2998      uiSum += getVSDEstimate( dDM, piOrg, iStrideOrg, piVirRec, piVirOrg, iStrideVir, x, y ) >> uiShift;
2999    }
3000    piOrg += iStrideOrg;
3001    piCur += iStrideCur;
3002  }
3003
3004  return ( uiSum );
3005}
3006
3007UInt TComRdCost::xGetVSD16N( DistParam* pcDtParam )
3008{
3009  Pel* piOrg   = pcDtParam->pOrg;
3010  Pel* piCur   = pcDtParam->pCur;
3011  Pel* piVirRec = pcDtParam->pVirRec;
3012  Pel* piVirOrg = pcDtParam->pVirOrg;
3013  Int  iRows   = pcDtParam->iRows;
3014  Int  iCols   = pcDtParam->iCols;
3015  Int  iStrideOrg = pcDtParam->iStrideOrg;
3016  Int  iStrideCur = pcDtParam->iStrideCur;
3017  Int  iStrideVir = pcDtParam->iStrideVir;
3018
3019  UInt uiSum = 0;
3020  UInt uiShift = DISTORTION_PRECISION_ADJUSTMENT(pcDtParam->bitDepth-8)<<1;
3021
3022  Int dDM;
3023
3024  for ( Int y = 0 ; y < iRows ; y++ )
3025  {
3026    for (Int x = 0; x < iCols; x+=16 )
3027    {
3028      for ( Int k = 0 ; k < 16 ; k++ )
3029      {
3030        dDM = (Int) ( piOrg[x+k] - piCur[x+k] );
3031        uiSum += getVSDEstimate( dDM, piOrg, iStrideOrg, piVirRec, piVirOrg, iStrideVir, x+k, y ) >> uiShift;
3032      }
3033    }
3034    piOrg += iStrideOrg;
3035    piCur += iStrideCur;
3036  }
3037
3038  return ( uiSum );
3039}
3040
3041UInt TComRdCost::xGetVSD32( DistParam* pcDtParam )
3042{
3043  Pel* piOrg   = pcDtParam->pOrg;
3044  Pel* piCur   = pcDtParam->pCur;
3045  Pel* piVirRec = pcDtParam->pVirRec;
3046  Pel* piVirOrg = pcDtParam->pVirOrg;
3047  Int  iRows   = pcDtParam->iRows;
3048  Int  iStrideOrg = pcDtParam->iStrideOrg;
3049  Int  iStrideCur = pcDtParam->iStrideCur;
3050  Int  iStrideVir = pcDtParam->iStrideVir;
3051
3052  UInt uiSum = 0;
3053  UInt uiShift = DISTORTION_PRECISION_ADJUSTMENT(pcDtParam->bitDepth-8)<<1;
3054
3055  Int dDM;
3056
3057  for ( Int y = 0 ; y < iRows ; y++ )
3058  {
3059    for (Int x = 0; x < 32 ; x++ )
3060    {
3061      dDM = (Int) ( piOrg[x] - piCur[x] );
3062      uiSum += getVSDEstimate( dDM, piOrg, iStrideOrg, piVirRec, piVirOrg, iStrideVir, x, y ) >> uiShift;
3063    }
3064    piOrg += iStrideOrg;
3065    piCur += iStrideCur;
3066  }
3067
3068  return ( uiSum );
3069}
3070
3071UInt TComRdCost::xGetVSD64( DistParam* pcDtParam )
3072{
3073  Pel* piOrg      = pcDtParam->pOrg;
3074  Pel* piCur      = pcDtParam->pCur;
3075  Pel* piVirRec   = pcDtParam->pVirRec;
3076  Pel* piVirOrg   = pcDtParam->pVirOrg;
3077  Int  iRows      = pcDtParam->iRows;
3078  Int  iStrideOrg = pcDtParam->iStrideOrg;
3079  Int  iStrideCur = pcDtParam->iStrideCur;
3080  Int  iStrideVir = pcDtParam->iStrideVir;
3081
3082  UInt uiSum = 0;
3083  UInt uiShift = DISTORTION_PRECISION_ADJUSTMENT(pcDtParam->bitDepth-8)<<1;
3084
3085  Int dDM;
3086
3087  for ( Int y = 0 ; y < iRows ; y++ )
3088  {
3089    for (Int x = 0; x < 64; x++ )
3090    {
3091      dDM = (Int) ( piOrg[x] - piCur[x] );
3092      uiSum += getVSDEstimate( dDM, piOrg, iStrideOrg, piVirRec, piVirOrg, iStrideVir, x, y ) >> uiShift;
3093    }
3094    piOrg += iStrideOrg;
3095    piCur += iStrideCur;
3096  }
3097
3098  return ( uiSum );
3099}
3100
3101#endif
3102
3103// --------------------------------------------------------------------------------------------------------------------
3104// HADAMARD with step (used in fractional search)
3105// --------------------------------------------------------------------------------------------------------------------
3106
3107Distortion TComRdCost::xCalcHADs2x2( Pel *piOrg, Pel *piCur, Int iStrideOrg, Int iStrideCur, Int iStep )
3108{
3109  Distortion satd = 0;
3110  TCoeff diff[4], m[4];
3111  assert( iStep == 1 );
3112  diff[0] = piOrg[0             ] - piCur[0];
3113  diff[1] = piOrg[1             ] - piCur[1];
3114  diff[2] = piOrg[iStrideOrg    ] - piCur[0 + iStrideCur];
3115  diff[3] = piOrg[iStrideOrg + 1] - piCur[1 + iStrideCur];
3116  m[0] = diff[0] + diff[2];
3117  m[1] = diff[1] + diff[3];
3118  m[2] = diff[0] - diff[2];
3119  m[3] = diff[1] - diff[3];
3120
3121  satd += abs(m[0] + m[1]);
3122  satd += abs(m[0] - m[1]);
3123  satd += abs(m[2] + m[3]);
3124  satd += abs(m[2] - m[3]);
3125
3126  return satd;
3127}
3128
3129Distortion TComRdCost::xCalcHADs4x4( Pel *piOrg, Pel *piCur, Int iStrideOrg, Int iStrideCur, Int iStep )
3130{
3131  Int k;
3132  Distortion satd = 0;
3133  TCoeff diff[16], m[16], d[16];
3134
3135  assert( iStep == 1 );
3136  for( k = 0; k < 16; k+=4 )
3137  {
3138    diff[k+0] = piOrg[0] - piCur[0];
3139    diff[k+1] = piOrg[1] - piCur[1];
3140    diff[k+2] = piOrg[2] - piCur[2];
3141    diff[k+3] = piOrg[3] - piCur[3];
3142
3143    piCur += iStrideCur;
3144    piOrg += iStrideOrg;
3145  }
3146
3147  /*===== hadamard transform =====*/
3148  m[ 0] = diff[ 0] + diff[12];
3149  m[ 1] = diff[ 1] + diff[13];
3150  m[ 2] = diff[ 2] + diff[14];
3151  m[ 3] = diff[ 3] + diff[15];
3152  m[ 4] = diff[ 4] + diff[ 8];
3153  m[ 5] = diff[ 5] + diff[ 9];
3154  m[ 6] = diff[ 6] + diff[10];
3155  m[ 7] = diff[ 7] + diff[11];
3156  m[ 8] = diff[ 4] - diff[ 8];
3157  m[ 9] = diff[ 5] - diff[ 9];
3158  m[10] = diff[ 6] - diff[10];
3159  m[11] = diff[ 7] - diff[11];
3160  m[12] = diff[ 0] - diff[12];
3161  m[13] = diff[ 1] - diff[13];
3162  m[14] = diff[ 2] - diff[14];
3163  m[15] = diff[ 3] - diff[15];
3164
3165  d[ 0] = m[ 0] + m[ 4];
3166  d[ 1] = m[ 1] + m[ 5];
3167  d[ 2] = m[ 2] + m[ 6];
3168  d[ 3] = m[ 3] + m[ 7];
3169  d[ 4] = m[ 8] + m[12];
3170  d[ 5] = m[ 9] + m[13];
3171  d[ 6] = m[10] + m[14];
3172  d[ 7] = m[11] + m[15];
3173  d[ 8] = m[ 0] - m[ 4];
3174  d[ 9] = m[ 1] - m[ 5];
3175  d[10] = m[ 2] - m[ 6];
3176  d[11] = m[ 3] - m[ 7];
3177  d[12] = m[12] - m[ 8];
3178  d[13] = m[13] - m[ 9];
3179  d[14] = m[14] - m[10];
3180  d[15] = m[15] - m[11];
3181
3182  m[ 0] = d[ 0] + d[ 3];
3183  m[ 1] = d[ 1] + d[ 2];
3184  m[ 2] = d[ 1] - d[ 2];
3185  m[ 3] = d[ 0] - d[ 3];
3186  m[ 4] = d[ 4] + d[ 7];
3187  m[ 5] = d[ 5] + d[ 6];
3188  m[ 6] = d[ 5] - d[ 6];
3189  m[ 7] = d[ 4] - d[ 7];
3190  m[ 8] = d[ 8] + d[11];
3191  m[ 9] = d[ 9] + d[10];
3192  m[10] = d[ 9] - d[10];
3193  m[11] = d[ 8] - d[11];
3194  m[12] = d[12] + d[15];
3195  m[13] = d[13] + d[14];
3196  m[14] = d[13] - d[14];
3197  m[15] = d[12] - d[15];
3198
3199  d[ 0] = m[ 0] + m[ 1];
3200  d[ 1] = m[ 0] - m[ 1];
3201  d[ 2] = m[ 2] + m[ 3];
3202  d[ 3] = m[ 3] - m[ 2];
3203  d[ 4] = m[ 4] + m[ 5];
3204  d[ 5] = m[ 4] - m[ 5];
3205  d[ 6] = m[ 6] + m[ 7];
3206  d[ 7] = m[ 7] - m[ 6];
3207  d[ 8] = m[ 8] + m[ 9];
3208  d[ 9] = m[ 8] - m[ 9];
3209  d[10] = m[10] + m[11];
3210  d[11] = m[11] - m[10];
3211  d[12] = m[12] + m[13];
3212  d[13] = m[12] - m[13];
3213  d[14] = m[14] + m[15];
3214  d[15] = m[15] - m[14];
3215
3216  for (k=0; k<16; ++k)
3217  {
3218    satd += abs(d[k]);
3219  }
3220  satd = ((satd+1)>>1);
3221
3222  return satd;
3223}
3224
3225Distortion TComRdCost::xCalcHADs8x8( Pel *piOrg, Pel *piCur, Int iStrideOrg, Int iStrideCur, Int iStep )
3226{
3227  Int k, i, j, jj;
3228  Distortion sad = 0;
3229  TCoeff diff[64], m1[8][8], m2[8][8], m3[8][8];
3230  assert( iStep == 1 );
3231  for( k = 0; k < 64; k += 8 )
3232  {
3233    diff[k+0] = piOrg[0] - piCur[0];
3234    diff[k+1] = piOrg[1] - piCur[1];
3235    diff[k+2] = piOrg[2] - piCur[2];
3236    diff[k+3] = piOrg[3] - piCur[3];
3237    diff[k+4] = piOrg[4] - piCur[4];
3238    diff[k+5] = piOrg[5] - piCur[5];
3239    diff[k+6] = piOrg[6] - piCur[6];
3240    diff[k+7] = piOrg[7] - piCur[7];
3241
3242    piCur += iStrideCur;
3243    piOrg += iStrideOrg;
3244  }
3245
3246  //horizontal
3247  for (j=0; j < 8; j++)
3248  {
3249    jj = j << 3;
3250    m2[j][0] = diff[jj  ] + diff[jj+4];
3251    m2[j][1] = diff[jj+1] + diff[jj+5];
3252    m2[j][2] = diff[jj+2] + diff[jj+6];
3253    m2[j][3] = diff[jj+3] + diff[jj+7];
3254    m2[j][4] = diff[jj  ] - diff[jj+4];
3255    m2[j][5] = diff[jj+1] - diff[jj+5];
3256    m2[j][6] = diff[jj+2] - diff[jj+6];
3257    m2[j][7] = diff[jj+3] - diff[jj+7];
3258
3259    m1[j][0] = m2[j][0] + m2[j][2];
3260    m1[j][1] = m2[j][1] + m2[j][3];
3261    m1[j][2] = m2[j][0] - m2[j][2];
3262    m1[j][3] = m2[j][1] - m2[j][3];
3263    m1[j][4] = m2[j][4] + m2[j][6];
3264    m1[j][5] = m2[j][5] + m2[j][7];
3265    m1[j][6] = m2[j][4] - m2[j][6];
3266    m1[j][7] = m2[j][5] - m2[j][7];
3267
3268    m2[j][0] = m1[j][0] + m1[j][1];
3269    m2[j][1] = m1[j][0] - m1[j][1];
3270    m2[j][2] = m1[j][2] + m1[j][3];
3271    m2[j][3] = m1[j][2] - m1[j][3];
3272    m2[j][4] = m1[j][4] + m1[j][5];
3273    m2[j][5] = m1[j][4] - m1[j][5];
3274    m2[j][6] = m1[j][6] + m1[j][7];
3275    m2[j][7] = m1[j][6] - m1[j][7];
3276  }
3277
3278  //vertical
3279  for (i=0; i < 8; i++)
3280  {
3281    m3[0][i] = m2[0][i] + m2[4][i];
3282    m3[1][i] = m2[1][i] + m2[5][i];
3283    m3[2][i] = m2[2][i] + m2[6][i];
3284    m3[3][i] = m2[3][i] + m2[7][i];
3285    m3[4][i] = m2[0][i] - m2[4][i];
3286    m3[5][i] = m2[1][i] - m2[5][i];
3287    m3[6][i] = m2[2][i] - m2[6][i];
3288    m3[7][i] = m2[3][i] - m2[7][i];
3289
3290    m1[0][i] = m3[0][i] + m3[2][i];
3291    m1[1][i] = m3[1][i] + m3[3][i];
3292    m1[2][i] = m3[0][i] - m3[2][i];
3293    m1[3][i] = m3[1][i] - m3[3][i];
3294    m1[4][i] = m3[4][i] + m3[6][i];
3295    m1[5][i] = m3[5][i] + m3[7][i];
3296    m1[6][i] = m3[4][i] - m3[6][i];
3297    m1[7][i] = m3[5][i] - m3[7][i];
3298
3299    m2[0][i] = m1[0][i] + m1[1][i];
3300    m2[1][i] = m1[0][i] - m1[1][i];
3301    m2[2][i] = m1[2][i] + m1[3][i];
3302    m2[3][i] = m1[2][i] - m1[3][i];
3303    m2[4][i] = m1[4][i] + m1[5][i];
3304    m2[5][i] = m1[4][i] - m1[5][i];
3305    m2[6][i] = m1[6][i] + m1[7][i];
3306    m2[7][i] = m1[6][i] - m1[7][i];
3307  }
3308
3309  for (i = 0; i < 8; i++)
3310  {
3311    for (j = 0; j < 8; j++)
3312    {
3313      sad += abs(m2[i][j]);
3314    }
3315  }
3316
3317  sad=((sad+2)>>2);
3318
3319  return sad;
3320}
3321
3322
3323Distortion TComRdCost::xGetHADs( DistParam* pcDtParam )
3324{
3325  if ( pcDtParam->bApplyWeight )
3326  {
3327    return TComRdCostWeightPrediction::xGetHADsw( pcDtParam );
3328  }
3329#if H_3D_IC
3330  if( pcDtParam->bUseIC )
3331  {
3332    return xGetHADsic( pcDtParam );
3333  }
3334#endif
3335#if H_3D_INTER_SDC
3336  if( pcDtParam->bUseSDCMRSAD )
3337  {
3338    return xGetHADsic( pcDtParam );
3339  }
3340#endif
3341
3342  Pel* piOrg   = pcDtParam->pOrg;
3343  Pel* piCur   = pcDtParam->pCur;
3344  Int  iRows   = pcDtParam->iRows;
3345  Int  iCols   = pcDtParam->iCols;
3346  Int  iStrideCur = pcDtParam->iStrideCur;
3347  Int  iStrideOrg = pcDtParam->iStrideOrg;
3348  Int  iStep  = pcDtParam->iStep;
3349
3350  Int  x, y;
3351
3352  Distortion uiSum = 0;
3353
3354  if( ( iRows % 8 == 0) && (iCols % 8 == 0) )
3355  {
3356    Int  iOffsetOrg = iStrideOrg<<3;
3357    Int  iOffsetCur = iStrideCur<<3;
3358    for ( y=0; y<iRows; y+= 8 )
3359    {
3360      for ( x=0; x<iCols; x+= 8 )
3361      {
3362        uiSum += xCalcHADs8x8( &piOrg[x], &piCur[x*iStep], iStrideOrg, iStrideCur, iStep );
3363      }
3364      piOrg += iOffsetOrg;
3365      piCur += iOffsetCur;
3366    }
3367  }
3368  else if( ( iRows % 4 == 0) && (iCols % 4 == 0) )
3369  {
3370    Int  iOffsetOrg = iStrideOrg<<2;
3371    Int  iOffsetCur = iStrideCur<<2;
3372
3373    for ( y=0; y<iRows; y+= 4 )
3374    {
3375      for ( x=0; x<iCols; x+= 4 )
3376      {
3377        uiSum += xCalcHADs4x4( &piOrg[x], &piCur[x*iStep], iStrideOrg, iStrideCur, iStep );
3378      }
3379      piOrg += iOffsetOrg;
3380      piCur += iOffsetCur;
3381    }
3382  }
3383  else if( ( iRows % 2 == 0) && (iCols % 2 == 0) )
3384  {
3385    Int  iOffsetOrg = iStrideOrg<<1;
3386    Int  iOffsetCur = iStrideCur<<1;
3387    for ( y=0; y<iRows; y+=2 )
3388    {
3389      for ( x=0; x<iCols; x+=2 )
3390      {
3391        uiSum += xCalcHADs2x2( &piOrg[x], &piCur[x*iStep], iStrideOrg, iStrideCur, iStep );
3392      }
3393      piOrg += iOffsetOrg;
3394      piCur += iOffsetCur;
3395    }
3396  }
3397  else
3398  {
3399    assert(false);
3400  }
3401
3402  return ( uiSum >> DISTORTION_PRECISION_ADJUSTMENT(pcDtParam->bitDepth-8) );
3403}
3404
3405#if H_3D_IC || H_3D_INTER_SDC
3406UInt TComRdCost::xGetHADsic( DistParam* pcDtParam )
3407{
3408  if ( pcDtParam->bApplyWeight )
3409  {
3410    return xGetHADsw( pcDtParam );
3411  }
3412  Pel* piOrg   = pcDtParam->pOrg;
3413  Pel* piCur   = pcDtParam->pCur;
3414  Int  iRows   = pcDtParam->iRows;
3415  Int  iCols   = pcDtParam->iCols;
3416  Int  iStrideCur = pcDtParam->iStrideCur;
3417  Int  iStrideOrg = pcDtParam->iStrideOrg;
3418  Int  iStep  = pcDtParam->iStep;
3419
3420  Int  x, y;
3421
3422  UInt uiSum = 0;
3423
3424  Int  iOrigAvg = 0, iCurAvg = 0;
3425  Int  iDeltaC;
3426
3427  for ( y=0; y<iRows; y++ )
3428  {
3429    for ( x=0; x<iCols; x++ )
3430    {       
3431      iOrigAvg += piOrg[x];
3432      iCurAvg  += piCur[x];
3433    }
3434    piOrg += iStrideOrg;
3435    piCur += iStrideCur;
3436  }
3437
3438  piOrg   = pcDtParam->pOrg;
3439  piCur   = pcDtParam->pCur;
3440
3441  iDeltaC = (iOrigAvg - iCurAvg)/iRows/iCols;
3442
3443  for ( y=0; y<iRows; y++ )
3444  {
3445    for ( x=0; x<iCols; x++ )
3446    {       
3447      piOrg[x] -= iDeltaC;
3448    }
3449    piOrg += iStrideOrg;
3450  }
3451
3452  piOrg   = pcDtParam->pOrg;
3453
3454#if NS_HAD
3455  if( ( ( iRows % 8 == 0) && (iCols % 8 == 0) && ( iRows == iCols ) ) || ( ( iRows % 8 == 0 ) && (iCols % 8 == 0) && !pcDtParam->bUseNSHAD ) )
3456#else
3457  if( ( iRows % 8 == 0) && (iCols % 8 == 0) )
3458#endif
3459  {
3460    Int  iOffsetOrg = iStrideOrg<<3;
3461    Int  iOffsetCur = iStrideCur<<3;
3462    for ( y=0; y<iRows; y+= 8 )
3463    {
3464      for ( x=0; x<iCols; x+= 8 )
3465      {
3466        uiSum += xCalcHADs8x8( &piOrg[x], &piCur[x*iStep], iStrideOrg, iStrideCur, iStep );
3467      }
3468      piOrg += iOffsetOrg;
3469      piCur += iOffsetCur;
3470    }
3471  }
3472#if NS_HAD
3473  else if ( ( iCols > 8 ) && ( iCols > iRows ) && pcDtParam->bUseNSHAD ) 
3474  {
3475    Int  iOffsetOrg = iStrideOrg<<2;
3476    Int  iOffsetCur = iStrideCur<<2;
3477    for ( y=0; y<iRows; y+= 4 )
3478    {
3479      for ( x=0; x<iCols; x+= 16 )
3480      {
3481        uiSum += xCalcHADs16x4( &piOrg[x], &piCur[x*iStep], iStrideOrg, iStrideCur, iStep );
3482      }
3483      piOrg += iOffsetOrg;
3484      piCur += iOffsetCur;
3485    }
3486  }
3487  else if ( ( iRows > 8 ) && ( iCols < iRows ) && pcDtParam->bUseNSHAD ) 
3488  {
3489    Int  iOffsetOrg = iStrideOrg<<4;
3490    Int  iOffsetCur = iStrideCur<<4;
3491    for ( y=0; y<iRows; y+= 16 )
3492    {
3493      for ( x=0; x<iCols; x+= 4 )
3494      {
3495        uiSum += xCalcHADs4x16( &piOrg[x], &piCur[x*iStep], iStrideOrg, iStrideCur, iStep );
3496      }
3497      piOrg += iOffsetOrg;
3498      piCur += iOffsetCur;
3499    }
3500  }
3501#endif
3502  else if( ( iRows % 4 == 0) && (iCols % 4 == 0) )
3503  {
3504    Int  iOffsetOrg = iStrideOrg<<2;
3505    Int  iOffsetCur = iStrideCur<<2;
3506
3507    for ( y=0; y<iRows; y+= 4 )
3508    {
3509      for ( x=0; x<iCols; x+= 4 )
3510      {
3511        uiSum += xCalcHADs4x4( &piOrg[x], &piCur[x*iStep], iStrideOrg, iStrideCur, iStep );
3512      }
3513      piOrg += iOffsetOrg;
3514      piCur += iOffsetCur;
3515    }
3516  }
3517  else if( ( iRows % 2 == 0) && (iCols % 2 == 0) )
3518  {
3519    Int  iOffsetOrg = iStrideOrg<<1;
3520    Int  iOffsetCur = iStrideCur<<1;
3521    for ( y=0; y<iRows; y+=2 )
3522    {
3523      for ( x=0; x<iCols; x+=2 )
3524      {
3525        uiSum += xCalcHADs2x2( &piOrg[x], &piCur[x*iStep], iStrideOrg, iStrideCur, iStep );
3526      }
3527      piOrg += iOffsetOrg;
3528      piCur += iOffsetCur;
3529    }
3530  }
3531  else
3532  {
3533    assert(false);
3534  }
3535
3536  piOrg   = pcDtParam->pOrg;
3537
3538  for ( y=0; y<iRows; y++ )
3539  {
3540    for ( x=0; x<iCols; x++ )
3541    {       
3542      piOrg[x] += iDeltaC;
3543    }
3544    piOrg += iStrideOrg;
3545  }
3546
3547  return ( uiSum >> DISTORTION_PRECISION_ADJUSTMENT( pcDtParam->bitDepth - 8 ) );
3548}
3549#endif
3550#if NH_3D_VSO
3551Void TComRdCost::setLambdaVSO( Double dLambdaVSO )
3552{
3553  m_dLambdaVSO           = dLambdaVSO;
3554  m_dSqrtLambdaVSO       = sqrt(m_dLambdaVSO); 
3555  m_uiLambdaMotionSADVSO = (UInt)floor(65536.0 *       m_dSqrtLambdaVSO);
3556  m_uiLambdaMotionSSEVSO = (UInt)floor(65536.0 *       m_dLambdaVSO    );
3557}
3558#endif
3559#if NH_3D_VSO
3560Dist TComRdCost::xGetDistVSOMode4( Int iStartPosX, Int iStartPosY, Pel* piCur, Int iCurStride, Pel* piOrg, Int iOrgStride, UInt uiBlkWidth, UInt uiBlkHeight, Bool bSAD )
3561{ 
3562  AOT(bSAD); 
3563#if H_3D_VSO_EARLY_SKIP
3564  RMDist iDist = m_pcRenModel->getDist( iStartPosX, iStartPosY, (Int) uiBlkWidth, (Int) uiBlkHeight, iCurStride, piCur, piOrg, iOrgStride); 
3565#else
3566  RMDist iDist = m_pcRenModel->getDist( iStartPosX, iStartPosY, (Int) uiBlkWidth, (Int) uiBlkHeight, iCurStride, piCur ); 
3567#endif
3568
3569  RMDist iDistMin = (RMDist) RDO_DIST_MIN; 
3570  iDistMin = m_bAllowNegDist ? RDO_DIST_MIN : 0; 
3571 
3572  iDist = std::min( iDist, (RMDist) RDO_DIST_MAX);
3573  iDist = std::max( iDist, iDistMin);
3574  return (Dist) iDist;
3575}
3576
3577
3578Dist TComRdCost::getDistPartVSO( TComDataCU* pcCU, UInt uiAbsPartIndex, Int bitDepth, Pel* piCur, Int iCurStride, Pel* piOrg, Int iOrgStride, UInt uiBlkWidth, UInt uiBlkHeight, Bool bHAD )
3579{ 
3580  assert( m_bUseVSO ); 
3581  assert( this->m_fpDistortFuncVSO != 0 );
3582
3583  Int iPosX;
3584  Int iPosY; 
3585 
3586  pcCU->getPosInPic( uiAbsPartIndex, iPosX, iPosY ); 
3587   
3588  Dist dist = (this->*m_fpDistortFuncVSO) ( iPosX, iPosY, piCur, iCurStride, piOrg, iOrgStride, uiBlkWidth, uiBlkHeight, bHAD ); 
3589 
3590  if ( m_bUseWVSO )   
3591  {
3592    Int iDWeight   = m_iDWeight   * m_iDWeight  ;
3593    Int iVSOWeight = m_iVSOWeight * m_iVSOWeight;
3594    Dist distDepth;
3595   
3596    if ( !bHAD )
3597    {
3598       distDepth = (Dist) getDistPart( bitDepth, piCur, iCurStride, piOrg, iOrgStride, uiBlkWidth, uiBlkHeight, COMPONENT_Y);
3599    }
3600    else
3601    {
3602       distDepth = (Dist) calcHAD    ( bitDepth, piCur, iCurStride, piOrg, iOrgStride, uiBlkWidth, uiBlkHeight);
3603    }
3604   
3605    dist = (Dist) (iDWeight * distDepth + iVSOWeight * dist ) / ( iDWeight + iVSOWeight);
3606  }
3607  return dist; 
3608}; 
3609
3610
3611Void TComRdCost::setVSOMode( UInt uiIn )
3612{
3613  m_uiVSOMode = uiIn;
3614  switch (m_uiVSOMode )
3615  {
3616  case   4:
3617    m_fpDistortFuncVSO = &TComRdCost::xGetDistVSOMode4;
3618    break;
3619  default:
3620    assert(0); 
3621    break; 
3622  }
3623}
3624
3625
3626Double TComRdCost::calcRdCostVSO( UInt uiBits, Dist uiDistortion, Bool bFlag, DFunc eDFunc )
3627{
3628  assert( m_bUseLambdaScaleVSO );   
3629
3630  Double dRdCost = 0.0;
3631  Double dLambda = 0.0;   
3632
3633  switch ( eDFunc )
3634  {
3635  case DF_SSE:
3636    assert(0);
3637    break;
3638  case DF_SAD:
3639    dLambda = (Double)m_uiLambdaMotionSADVSO;
3640    break;
3641  case DF_DEFAULT:
3642    dLambda =         m_dLambdaVSO;
3643    break;
3644  case DF_SSE_FRAME:
3645    dLambda =         m_dFrameLambdaVSO;
3646    break;
3647  default:
3648    assert (0);
3649    break;
3650  }
3651
3652  if (bFlag)
3653  {
3654    // Intra8x8, Intra4x4 Block only...
3655#if SEQUENCE_LEVEL_LOSSLESS
3656    dRdCost = (Double)(uiBits);
3657#else
3658    dRdCost = (((Double)uiDistortion) + ((Double)uiBits * dLambda));
3659#endif
3660  }
3661  else
3662  {
3663    if (eDFunc == DF_SAD)
3664    {
3665      dRdCost = ((Double)uiDistortion + (Double)((Int)(uiBits * dLambda+.5)>>16));
3666      dRdCost = (Double)(Dist)floor(dRdCost);
3667    }
3668    else
3669    {
3670#if SEQUENCE_LEVEL_LOSSLESS
3671      dRdCost = (Double)(uiBits);
3672#else
3673      dRdCost = ((Double)uiDistortion + (Double)((Int)(uiBits * dLambda+.5)));
3674      dRdCost = (Double)(Dist)floor(dRdCost);
3675#endif
3676    }
3677  }
3678
3679  return dRdCost;
3680}
3681
3682Void TComRdCost::setRenModelData( const TComDataCU* pcCU, UInt uiAbsPartIndex, const TComYuv* pcYuv, const TComTURecurse* tuRecurseWithPU )
3683{
3684  const TComRectangle &puRect=tuRecurseWithPU->getRect(COMPONENT_Y);
3685  const UInt  uiCompWidth   = puRect.width;
3686  const UInt  uiCompHeight  = puRect.height;
3687
3688  const Pel*  piSrc         = pcYuv->getAddr( COMPONENT_Y, uiAbsPartIndex );
3689  const UInt  uiSrcStride   = pcYuv->getStride( COMPONENT_Y);
3690  setRenModelData( pcCU, uiAbsPartIndex, piSrc, uiSrcStride, uiCompWidth, uiCompHeight ); 
3691}
3692
3693Void TComRdCost::setRenModelData( const TComDataCU* pcCU, UInt uiAbsPartIndex, const Pel* piData, Int iStride, Int iBlkWidth, Int iBlkHeight )
3694{
3695  UInt iBlkX = g_auiRasterToPelX[g_auiZscanToRaster[uiAbsPartIndex]];
3696  UInt iBlkY = g_auiRasterToPelY[g_auiZscanToRaster[uiAbsPartIndex]];
3697
3698  Int iStartPosX = iBlkX + pcCU->getCUPelX();
3699  Int iStartPosY = iBlkY + pcCU->getCUPelY();
3700
3701  m_pcRenModel->setData( iStartPosX, iStartPosY, iBlkWidth, iBlkHeight, iStride, piData );
3702}
3703
3704Void TComRdCost::setAllowNegDist( Bool bAllowNegDist )
3705{
3706  m_bAllowNegDist = bAllowNegDist;
3707}
3708#endif
3709
3710//! \}
Note: See TracBrowser for help on using the repository browser.