Context navigation

TComRdCost.cpp @ 1373

Visit:

Last change on this file since 1373 was 1373, checked in by tech, 8 years ago
Macro fixes.
Property svn:eol-style set to `native`
File size: 110.8 KB

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

Note: See TracBrowser for help on using the repository browser.

JCT-3V 3D-HEVC

Context navigation

source: 3DVCSoftware/branches/HTM-15.2-dev/source/Lib/TLibCommon/TComRdCost.cpp @ 1373

Download in other formats: