source: 3DVCSoftware/branches/HTM-14.1-update-dev0/source/Lib/TLibCommon/TComRdCost.cpp @ 1199

Last change on this file since 1199 was 1196, checked in by tech, 9 years ago

Merged 14.0-dev0@1187.

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