source: 3DVCSoftware/branches/HTM-14.1-update-dev3/source/Lib/TLibCommon/TComRdCost.cpp

Last change on this file was 1270, checked in by tech, 9 years ago

Merged 14.1-update-dev4-Qualcomm@1266

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