History

Pretty printed the C++ code with astyle

Ethan Hugg committed 12 years ago

Commit ff6b6691 parent 063709c225 files · +48457 −51954Browse files

Showing the changes to codec/encoder/core/src/sample.cpp (1 of 225 files). Show all

Unified · Split

codec/encoder/core/src/sample.cpp+489−531
@@ -1,531 +1,489 @@
1−/*!
2− * \copy
3− * Copyright (c) 2009-2013, Cisco Systems
4− * All rights reserved.
5− *
6− * Redistribution and use in source and binary forms, with or without
7− * modification, are permitted provided that the following conditions
8− * are met:
9− *
10− * * Redistributions of source code must retain the above copyright
11− * notice, this list of conditions and the following disclaimer.
12− *
13− * * Redistributions in binary form must reproduce the above copyright
14− * notice, this list of conditions and the following disclaimer in
15− * the documentation and/or other materials provided with the
16− * distribution.
17− *
18− * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19− * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20− * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21− * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22− * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23− * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24− * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25− * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26− * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27− * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28− * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29− * POSSIBILITY OF SUCH DAMAGE.
30− *
31− *
32− * \file sample.c
33− *
34− * \brief compute SAD and SATD
35− *
36− * \date 2009.06.02 Created
37− *
38− *************************************************************************************
39− */
40−
41−#include "sample.h"
42−#include "macros.h"
43−
44−#include "mc.h"
45−#include "cpu_core.h"
46−#include "array_stack_align.h"
47−
48−namespace WelsSVCEnc {
49−int32_t WelsSampleSad4x4_c( uint8_t* pSample1, int32_t iStride1, uint8_t* pSample2, int32_t iStride2 )
50−{
51− int32_t iSadSum = 0;
52− int32_t i = 0;
53− uint8_t* pSrc1 = pSample1;
54− uint8_t* pSrc2 = pSample2;
55− for ( i = 0; i < 4; i++ )
56− {
57− iSadSum += WELS_ABS( ( pSrc1[0] - pSrc2[0] ) );
58− iSadSum += WELS_ABS( ( pSrc1[1] - pSrc2[1] ) );
59− iSadSum += WELS_ABS( ( pSrc1[2] - pSrc2[2] ) );
60− iSadSum += WELS_ABS( ( pSrc1[3] - pSrc2[3] ) );
61−
62− pSrc1 += iStride1;
63− pSrc2 += iStride2;
64− }
65−
66− return iSadSum;
67−}
68−
69−int32_t WelsSampleSad8x8_c( uint8_t* pSample1, int32_t iStride1, uint8_t* pSample2, int32_t iStride2 )
70−{
71− int32_t iSadSum = 0;
72− int32_t i = 0;
73− uint8_t* pSrc1 = pSample1;
74− uint8_t* pSrc2 = pSample2;
75− for ( i = 0; i < 8; i++ )
76− {
77− iSadSum += WELS_ABS( ( pSrc1[0] - pSrc2[0] ) );
78− iSadSum += WELS_ABS( ( pSrc1[1] - pSrc2[1] ) );
79− iSadSum += WELS_ABS( ( pSrc1[2] - pSrc2[2] ) );
80− iSadSum += WELS_ABS( ( pSrc1[3] - pSrc2[3] ) );
81− iSadSum += WELS_ABS( ( pSrc1[4] - pSrc2[4] ) );
82− iSadSum += WELS_ABS( ( pSrc1[5] - pSrc2[5] ) );
83− iSadSum += WELS_ABS( ( pSrc1[6] - pSrc2[6] ) );
84− iSadSum += WELS_ABS( ( pSrc1[7] - pSrc2[7] ) );
85−
86− pSrc1 += iStride1;
87− pSrc2 += iStride2;
88− }
89−
90− return iSadSum;
91−}
92−int32_t WelsSampleSad16x8_c( uint8_t* pSample1, int32_t iStride1, uint8_t* pSample2, int32_t iStride2 )
93−{
94− int32_t iSadSum = 0;
95−
96− iSadSum += WelsSampleSad8x8_c( pSample1, iStride1, pSample2, iStride2 );
97− iSadSum += WelsSampleSad8x8_c( pSample1 + 8, iStride1, pSample2 + 8, iStride2 );
98−
99− return iSadSum;
100−}
101−int32_t WelsSampleSad8x16_c( uint8_t* pSample1, int32_t iStride1, uint8_t* pSample2, int32_t iStride2 )
102−{
103− int32_t iSadSum = 0;
104− iSadSum += WelsSampleSad8x8_c( pSample1, iStride1, pSample2, iStride2 );
105− iSadSum += WelsSampleSad8x8_c( pSample1+(iStride1<<3), iStride1, pSample2+(iStride2<<3), iStride2 );
106−
107− return iSadSum;
108−}
109−int32_t WelsSampleSad16x16_c( uint8_t* pSample1, int32_t iStride1, uint8_t* pSample2, int32_t iStride2 )
110−{
111− int32_t iSadSum = 0;
112− iSadSum += WelsSampleSad8x8_c( pSample1, iStride1, pSample2, iStride2 );
113− iSadSum += WelsSampleSad8x8_c( pSample1+8, iStride1, pSample2+8, iStride2 );
114− iSadSum += WelsSampleSad8x8_c( pSample1+(iStride1<<3), iStride1, pSample2+(iStride2<<3), iStride2 );
115− iSadSum += WelsSampleSad8x8_c( pSample1+(iStride1<<3)+8, iStride1, pSample2+(iStride2<<3)+8, iStride2 );
116−
117− return iSadSum;
118−}
119−
120−int32_t WelsSampleSatd4x4_c( uint8_t* pSample1, int32_t iStride1, uint8_t* pSample2, int32_t iStride2 )
121−{
122− int32_t iSatdSum = 0;
123− int32_t pSampleMix[4][4] = { 0 };
124− int32_t iSample0, iSample1, iSample2, iSample3;
125− int32_t i = 0;
126− uint8_t* pSrc1 = pSample1;
127− uint8_t* pSrc2 = pSample2;
128−
129− //step 1: get the difference
130− for( i = 0; i < 4; i++ )
131− {
132− pSampleMix[i][0] = pSrc1[0] - pSrc2[0];
133− pSampleMix[i][1] = pSrc1[1] - pSrc2[1];
134− pSampleMix[i][2] = pSrc1[2] - pSrc2[2];
135− pSampleMix[i][3] = pSrc1[3] - pSrc2[3];
136−
137− pSrc1 += iStride1;
138− pSrc2 += iStride2;
139− }
140−
141− //step 2: horizontal transform
142− for ( i = 0; i < 4; i++ )
143− {
144− iSample0 = pSampleMix[i][0] + pSampleMix[i][2];
145− iSample1 = pSampleMix[i][1] + pSampleMix[i][3];
146− iSample2 = pSampleMix[i][0] - pSampleMix[i][2];
147− iSample3 = pSampleMix[i][1] - pSampleMix[i][3];
148−
149− pSampleMix[i][0] = iSample0 + iSample1;
150− pSampleMix[i][1] = iSample2 + iSample3;
151− pSampleMix[i][2] = iSample2 - iSample3;
152− pSampleMix[i][3] = iSample0 - iSample1;
153− }
154−
155− //step 3: vertical transform and get the sum of SATD
156− for ( i = 0; i < 4; i++ )
157− {
158− iSample0 = pSampleMix[0][i] + pSampleMix[2][i];
159− iSample1 = pSampleMix[1][i] + pSampleMix[3][i];
160− iSample2 = pSampleMix[0][i] - pSampleMix[2][i];
161− iSample3 = pSampleMix[1][i] - pSampleMix[3][i];
162−
163− pSampleMix[0][i] = iSample0 + iSample1;
164− pSampleMix[1][i] = iSample2 + iSample3;
165− pSampleMix[2][i] = iSample2 - iSample3;
166− pSampleMix[3][i] = iSample0 - iSample1;
167−
168− iSatdSum += ( WELS_ABS( pSampleMix[0][i] ) + WELS_ABS( pSampleMix[1][i] ) + WELS_ABS( pSampleMix[2][i] ) + WELS_ABS( pSampleMix[3][i] ) );
169− }
170−
171− return ( (iSatdSum+1)>>1 );
172−}
173−int32_t WelsSampleSatd8x8_c( uint8_t* pSample1, int32_t iStride1, uint8_t* pSample2, int32_t iStride2 )
174−{
175− int32_t iSatdSum = 0;
176−
177− iSatdSum += WelsSampleSatd4x4_c( pSample1, iStride1, pSample2, iStride2 );
178− iSatdSum += WelsSampleSatd4x4_c( pSample1+4, iStride1, pSample2+4, iStride2 );
179− iSatdSum += WelsSampleSatd4x4_c( pSample1+(iStride1<<2), iStride1, pSample2+(iStride2<<2), iStride2 );
180− iSatdSum += WelsSampleSatd4x4_c( pSample1+(iStride1<<2)+4, iStride1, pSample2+(iStride2<<2)+4, iStride2 );
181−
182− return iSatdSum;
183−}
184−int32_t WelsSampleSatd16x8_c( uint8_t* pSample1, int32_t iStride1, uint8_t* pSample2, int32_t iStride2 )
185−{
186− int32_t iSatdSum = 0;
187−
188− iSatdSum += WelsSampleSatd8x8_c( pSample1, iStride1, pSample2, iStride2 );
189− iSatdSum += WelsSampleSatd8x8_c( pSample1+8, iStride1, pSample2+8, iStride2 );
190−
191− return iSatdSum;
192−}
193−int32_t WelsSampleSatd8x16_c( uint8_t* pSample1, int32_t iStride1, uint8_t* pSample2, int32_t iStride2 )
194−{
195− int32_t iSatdSum = 0;
196−
197− iSatdSum += WelsSampleSatd8x8_c( pSample1, iStride1, pSample2, iStride2 );
198− iSatdSum += WelsSampleSatd8x8_c( pSample1+(iStride1<<3), iStride1, pSample2+(iStride2<<3), iStride2 );
199−
200− return iSatdSum;
201−}
202−int32_t WelsSampleSatd16x16_c( uint8_t* pSample1, int32_t iStride1, uint8_t* pSample2, int32_t iStride2 )
203−{
204− int32_t iSatdSum = 0;
205−
206− iSatdSum += WelsSampleSatd8x8_c( pSample1, iStride1, pSample2, iStride2 );
207− iSatdSum += WelsSampleSatd8x8_c( pSample1+8, iStride1, pSample2+8, iStride2 );
208− iSatdSum += WelsSampleSatd8x8_c( pSample1+(iStride1<<3), iStride1, pSample2+(iStride2<<3), iStride2 );
209− iSatdSum += WelsSampleSatd8x8_c( pSample1+(iStride1<<3)+8, iStride1, pSample2+(iStride2<<3)+8, iStride2 );
210−
211− return iSatdSum;
212−}
213−
214−
215−void WelsSampleSadFour16x16_c( uint8_t *iSample1, int32_t iStride1, uint8_t *iSample2, int32_t iStride2, int32_t* pSad)
216−{
217− *(pSad) = WelsSampleSad16x16_c(iSample1, iStride1, (iSample2-iStride2), iStride2);
218− *(pSad + 1) = WelsSampleSad16x16_c(iSample1, iStride1, (iSample2+iStride2), iStride2);
219− *(pSad + 2) = WelsSampleSad16x16_c(iSample1, iStride1, (iSample2-1), iStride2);
220− *(pSad + 3) = WelsSampleSad16x16_c(iSample1, iStride1, (iSample2+1), iStride2);
221−}
222−void WelsSampleSadFour16x8_c(uint8_t *iSample1, int32_t iStride1, uint8_t *iSample2, int32_t iStride2, int32_t* pSad)
223−{
224− *(pSad) = WelsSampleSad16x8_c(iSample1, iStride1, (iSample2-iStride2), iStride2);
225− *(pSad + 1) = WelsSampleSad16x8_c(iSample1, iStride1, (iSample2+iStride2), iStride2);
226− *(pSad + 2) = WelsSampleSad16x8_c(iSample1, iStride1, (iSample2-1), iStride2);
227− *(pSad + 3) = WelsSampleSad16x8_c(iSample1, iStride1, (iSample2+1), iStride2);
228−}
229−void WelsSampleSadFour8x16_c( uint8_t *iSample1, int32_t iStride1, uint8_t *iSample2, int32_t iStride2, int32_t* pSad)
230−{
231− *(pSad) = WelsSampleSad8x16_c(iSample1, iStride1, (iSample2-iStride2), iStride2);
232− *(pSad + 1) = WelsSampleSad8x16_c(iSample1, iStride1, (iSample2+iStride2), iStride2);
233− *(pSad + 2) = WelsSampleSad8x16_c(iSample1, iStride1, (iSample2-1), iStride2);
234− *(pSad + 3) = WelsSampleSad8x16_c(iSample1, iStride1, (iSample2+1), iStride2);
235−
236−}
237−void WelsSampleSadFour8x8_c( uint8_t *iSample1, int32_t iStride1, uint8_t *iSample2, int32_t iStride2, int32_t* pSad)
238−{
239− *(pSad) = WelsSampleSad8x8_c(iSample1, iStride1, (iSample2-iStride2), iStride2);
240− *(pSad + 1) = WelsSampleSad8x8_c(iSample1, iStride1, (iSample2+iStride2), iStride2);
241− *(pSad + 2) = WelsSampleSad8x8_c(iSample1, iStride1, (iSample2-1), iStride2);
242− *(pSad + 3) = WelsSampleSad8x8_c(iSample1, iStride1, (iSample2+1), iStride2);
243−}
244−void WelsSampleSadFour4x4_c( uint8_t *iSample1, int32_t iStride1, uint8_t *iSample2, int32_t iStride2, int32_t* pSad)
245−{
246− *(pSad) = WelsSampleSad4x4_c(iSample1, iStride1, (iSample2-iStride2), iStride2);
247− *(pSad + 1) = WelsSampleSad4x4_c(iSample1, iStride1, (iSample2+iStride2), iStride2);
248− *(pSad + 2) = WelsSampleSad4x4_c(iSample1, iStride1, (iSample2-1), iStride2);
249− *(pSad + 3) = WelsSampleSad4x4_c(iSample1, iStride1, (iSample2+1), iStride2);
250−}
251−
252−extern void WelsI4x4LumaPredDc_c(uint8_t *pPred, uint8_t *pRef, const int32_t iStride);
253−extern void WelsI4x4LumaPredH_c(uint8_t *pPred, uint8_t *pRef, const int32_t iStride);
254−extern void WelsI4x4LumaPredV_c(uint8_t *pPred, uint8_t *pRef, const int32_t iStride);
255−
256−int32_t WelsSampleSatdIntra4x4Combined3_c(uint8_t *pDec, int32_t iDecStride, uint8_t *pEnc, int32_t iEncStride, uint8_t *pDst,
257− int32_t *pBestMode, int32_t iLambda2, int32_t iLambda1, int32_t iLambda0)
258−{
259− int32_t iBestMode = -1;
260− int32_t iCurCost, iBestCost = INT_MAX;
261− ENFORCE_STACK_ALIGN_2D(uint8_t, uiLocalBuffer, 3, 16, 16)
262−
263− WelsI4x4LumaPredDc_c(uiLocalBuffer[2], pDec, iDecStride);
264− iCurCost = WelsSampleSatd4x4_c(uiLocalBuffer[2], 4, pEnc, iEncStride) + iLambda2;
265− if (iCurCost < iBestCost)
266− {
267− iBestMode = 2;
268− iBestCost = iCurCost;
269− }
270−
271− WelsI4x4LumaPredH_c(uiLocalBuffer[1], pDec, iDecStride);
272− iCurCost = WelsSampleSatd4x4_c(uiLocalBuffer[1], 4, pEnc, iEncStride) + iLambda1;
273− if (iCurCost < iBestCost)
274− {
275− iBestMode = 1;
276− iBestCost = iCurCost;
277− }
278− WelsI4x4LumaPredV_c(uiLocalBuffer[0], pDec, iDecStride);
279− iCurCost = WelsSampleSatd4x4_c(uiLocalBuffer[0], 4, pEnc, iEncStride) + iLambda0;
280− if (iCurCost < iBestCost)
281− {
282− iBestMode = 0;
283− iBestCost = iCurCost;
284− }
285−
286− memcpy(pDst, uiLocalBuffer[iBestMode], 16*sizeof(uint8_t)); // confirmed_safe_unsafe_usage
287− *pBestMode = iBestMode;
288−
289− return iBestCost;
290−}
291−extern void WelsIChormaPredDc_c(uint8_t *pPred, uint8_t *pRef, const int32_t iStride);
292−extern void WelsIChormaPredH_c(uint8_t *pPred, uint8_t *pRef, const int32_t iStride);
293−extern void WelsIChormaPredV_c(uint8_t *pPred, uint8_t *pRef, const int32_t iStride);
294−
295−int32_t WelsSampleSatdIntra8x8Combined3_c(uint8_t *pDecCb, int32_t iDecStride, uint8_t *pEncCb, int32_t iEncStride,
296− int32_t *pBestMode, int32_t iLambda, uint8_t *pDstChroma,uint8_t *pDecCr,uint8_t *pEncCr)
297−{
298− int32_t iBestMode = -1;
299− int32_t iCurCost, iBestCost = INT_MAX;
300−
301− WelsIChormaPredV_c(pDstChroma, pDecCb, iDecStride);
302− WelsIChormaPredV_c(pDstChroma+64, pDecCr, iDecStride);
303− iCurCost = WelsSampleSatd8x8_c(pDstChroma, 8, pEncCb, iEncStride);
304− iCurCost += WelsSampleSatd8x8_c(pDstChroma+64, 8, pEncCr, iEncStride) + iLambda * 2;
305−
306− if (iCurCost < iBestCost)
307− {
308− iBestMode = 2;
309− iBestCost = iCurCost;
310− }
311−
312− WelsIChormaPredH_c(pDstChroma, pDecCb, iDecStride);
313− WelsIChormaPredH_c(pDstChroma+64, pDecCr, iDecStride);
314− iCurCost = WelsSampleSatd8x8_c(pDstChroma, 8, pEncCb, iEncStride);
315− iCurCost += WelsSampleSatd8x8_c(pDstChroma+64, 8, pEncCr, iEncStride) + iLambda * 2;
316− if (iCurCost < iBestCost)
317− {
318− iBestMode = 1;
319− iBestCost = iCurCost;
320− }
321− WelsIChormaPredDc_c(pDstChroma, pDecCb, iDecStride);
322− WelsIChormaPredDc_c(pDstChroma+64, pDecCr, iDecStride);
323− iCurCost = WelsSampleSatd8x8_c(pDstChroma, 8, pEncCb, iEncStride);
324− iCurCost += WelsSampleSatd8x8_c(pDstChroma+64, 8, pEncCr, iEncStride);
325− if (iCurCost < iBestCost)
326− {
327− iBestMode = 0;
328− iBestCost = iCurCost;
329− }
330−
331− *pBestMode = iBestMode;
332−
333− return iBestCost;
334−
335−
336−}
337−int32_t WelsSampleSadIntra8x8Combined3_c(uint8_t *pDecCb, int32_t iDecStride, uint8_t *pEncCb, int32_t iEncStride,
338− int32_t *pBestMode, int32_t iLambda, uint8_t *pDstChroma,uint8_t *pDecCr,uint8_t *pEncCr)
339−{
340− int32_t iBestMode = -1;
341− int32_t iCurCost, iBestCost = INT_MAX;
342−
343− WelsIChormaPredV_c(pDstChroma, pDecCb, iDecStride);
344− WelsIChormaPredV_c(pDstChroma+64, pDecCr, iDecStride);
345− iCurCost = WelsSampleSad8x8_c(pDstChroma, 8, pEncCb, iEncStride);
346− iCurCost += WelsSampleSad8x8_c(pDstChroma+64, 8, pEncCr, iEncStride) + iLambda * 2;
347−
348− if (iCurCost < iBestCost)
349− {
350− iBestMode = 2;
351− iBestCost = iCurCost;
352− }
353−
354− WelsIChormaPredH_c(pDstChroma, pDecCb, iDecStride);
355− WelsIChormaPredH_c(pDstChroma+64, pDecCr, iDecStride);
356− iCurCost = WelsSampleSad8x8_c(pDstChroma, 8, pEncCb, iEncStride);
357− iCurCost += WelsSampleSad8x8_c(pDstChroma+64, 8, pEncCr, iEncStride) + iLambda * 2;
358− if (iCurCost < iBestCost)
359− {
360− iBestMode = 1;
361− iBestCost = iCurCost;
362− }
363− WelsIChormaPredDc_c(pDstChroma, pDecCb, iDecStride);
364− WelsIChormaPredDc_c(pDstChroma+64, pDecCr, iDecStride);
365− iCurCost = WelsSampleSad8x8_c(pDstChroma, 8, pEncCb, iEncStride);
366− iCurCost += WelsSampleSad8x8_c(pDstChroma+64, 8, pEncCr, iEncStride);
367− if (iCurCost < iBestCost)
368− {
369− iBestMode = 0;
370− iBestCost = iCurCost;
371− }
372−
373− *pBestMode = iBestMode;
374−
375− return iBestCost;
376−
377−}
378−
379−extern void WelsI16x16LumaPredDc_c(uint8_t *pPred, uint8_t *pRef, const int32_t iStride);
380−extern void WelsI16x16LumaPredH_c(uint8_t *pPred, uint8_t *pRef, const int32_t iStride);
381−extern void WelsI16x16LumaPredV_c(uint8_t *pPred, uint8_t *pRef, const int32_t iStride);
382−
383−int32_t WelsSampleSatdIntra16x16Combined3_c(uint8_t *pDec, int32_t iDecStride, uint8_t *pEnc, int32_t iEncStride,
384− int32_t *pBestMode, int32_t iLambda, uint8_t *pDst)
385−{
386− int32_t iBestMode = -1;
387− int32_t iCurCost, iBestCost = INT_MAX;
388−
389− WelsI16x16LumaPredV_c(pDst, pDec, iDecStride);
390− iCurCost = WelsSampleSatd16x16_c(pDst, 16, pEnc, iEncStride);
391−
392− if (iCurCost < iBestCost)
393− {
394− iBestMode = 0;
395− iBestCost = iCurCost;
396− }
397−
398− WelsI16x16LumaPredH_c(pDst, pDec, iDecStride);
399− iCurCost = WelsSampleSatd16x16_c(pDst, 16, pEnc, iEncStride) + iLambda * 2;
400− if (iCurCost < iBestCost)
401− {
402− iBestMode = 1;
403− iBestCost = iCurCost;
404− }
405− WelsI16x16LumaPredDc_c(pDst, pDec, iDecStride);
406− iCurCost = WelsSampleSatd16x16_c(pDst, 16, pEnc, iEncStride) + iLambda * 2;
407− if (iCurCost < iBestCost)
408− {
409− iBestMode = 2;
410− iBestCost = iCurCost;
411− }
412−
413− *pBestMode = iBestMode;
414−
415− return iBestCost;
416−
417−
418−}
419−int32_t WelsSampleSadIntra16x16Combined3_c(uint8_t *pDec, int32_t iDecStride, uint8_t *pEnc, int32_t iEncStride,
420− int32_t *pBestMode, int32_t iLambda, uint8_t *pDst)
421−{
422− int32_t iBestMode = -1;
423− int32_t iCurCost, iBestCost = INT_MAX;
424−
425− WelsI16x16LumaPredV_c(pDst, pDec, iDecStride);
426− iCurCost = WelsSampleSad16x16_c(pDst, 16, pEnc, iEncStride);
427−
428− if (iCurCost < iBestCost)
429− {
430− iBestMode = 0;
431− iBestCost = iCurCost;
432− }
433−
434− WelsI16x16LumaPredH_c(pDst, pDec, iDecStride);
435− iCurCost = WelsSampleSad16x16_c(pDst, 16, pEnc, iEncStride) + iLambda * 2;
436− if (iCurCost < iBestCost)
437− {
438− iBestMode = 1;
439− iBestCost = iCurCost;
440− }
441− WelsI16x16LumaPredDc_c(pDst, pDec, iDecStride);
442− iCurCost = WelsSampleSad16x16_c(pDst, 16, pEnc, iEncStride) + iLambda * 2;
443− if (iCurCost < iBestCost)
444− {
445− iBestMode = 2;
446− iBestCost = iCurCost;
447− }
448−
449− *pBestMode = iBestMode;
450−
451− return iBestCost;
452−
453−
454−}
455−
456−void WelsInitSampleSadFunc( SWelsFuncPtrList *pFuncList, uint32_t uiCpuFlag)
457−{
458− //pfSampleSad init
459− pFuncList->sSampleDealingFuncs.pfSampleSad[BLOCK_16x16] = WelsSampleSad16x16_c;
460− pFuncList->sSampleDealingFuncs.pfSampleSad[BLOCK_16x8 ] = WelsSampleSad16x8_c;
461− pFuncList->sSampleDealingFuncs.pfSampleSad[BLOCK_8x16 ] = WelsSampleSad8x16_c;
462− pFuncList->sSampleDealingFuncs.pfSampleSad[BLOCK_8x8 ] = WelsSampleSad8x8_c;
463− pFuncList->sSampleDealingFuncs.pfSampleSad[BLOCK_4x4 ] = WelsSampleSad4x4_c;
464−
465− //pfSampleSatd init
466− pFuncList->sSampleDealingFuncs.pfSampleSatd[BLOCK_16x16] = WelsSampleSatd16x16_c;
467− pFuncList->sSampleDealingFuncs.pfSampleSatd[BLOCK_16x8 ] = WelsSampleSatd16x8_c;
468− pFuncList->sSampleDealingFuncs.pfSampleSatd[BLOCK_8x16 ] = WelsSampleSatd8x16_c;
469− pFuncList->sSampleDealingFuncs.pfSampleSatd[BLOCK_8x8 ] = WelsSampleSatd8x8_c;
470− pFuncList->sSampleDealingFuncs.pfSampleSatd[BLOCK_4x4 ] = WelsSampleSatd4x4_c;
471−
472− pFuncList->sSampleDealingFuncs.pfSample4Sad[BLOCK_16x16] = WelsSampleSadFour16x16_c;
473− pFuncList->sSampleDealingFuncs.pfSample4Sad[BLOCK_16x8] = WelsSampleSadFour16x8_c;
474− pFuncList->sSampleDealingFuncs.pfSample4Sad[BLOCK_8x16] = WelsSampleSadFour8x16_c;
475− pFuncList->sSampleDealingFuncs.pfSample4Sad[BLOCK_8x8] = WelsSampleSadFour8x8_c;
476− pFuncList->sSampleDealingFuncs.pfSample4Sad[BLOCK_4x4] = WelsSampleSadFour4x4_c;
477−
478− pFuncList->sSampleDealingFuncs.pfIntra4x4Combined3Satd = NULL;
479− pFuncList->sSampleDealingFuncs.pfIntra8x8Combined3Satd = NULL;
480− pFuncList->sSampleDealingFuncs.pfIntra8x8Combined3Sad = NULL;
481− pFuncList->sSampleDealingFuncs.pfIntra16x16Combined3Satd = NULL;
482− pFuncList->sSampleDealingFuncs.pfIntra16x16Combined3Sad = NULL;
483−
484−#if defined (X86_ASM)
485− if ( uiCpuFlag & WELS_CPU_MMXEXT )
486− {
487− pFuncList->sSampleDealingFuncs.pfSampleSad[BLOCK_4x4 ] = WelsSampleSad4x4_mmx;
488− }
489−
490− if ( uiCpuFlag & WELS_CPU_SSE2 )
491− {
492− pFuncList->sSampleDealingFuncs.pfSampleSad[BLOCK_16x16] = WelsSampleSad16x16_sse2;
493− pFuncList->sSampleDealingFuncs.pfSampleSad[BLOCK_16x8 ] = WelsSampleSad16x8_sse2;
494− pFuncList->sSampleDealingFuncs.pfSampleSad[BLOCK_8x16] = WelsSampleSad8x16_sse2;
495− pFuncList->sSampleDealingFuncs.pfSampleSad[BLOCK_8x8] = WelsSampleSad8x8_sse21;
496−
497− pFuncList->sSampleDealingFuncs.pfSample4Sad[BLOCK_16x16] = WelsSampleSadFour16x16_sse2;
498− pFuncList->sSampleDealingFuncs.pfSample4Sad[BLOCK_16x8] = WelsSampleSadFour16x8_sse2;
499− pFuncList->sSampleDealingFuncs.pfSample4Sad[BLOCK_8x16] = WelsSampleSadFour8x16_sse2;
500− pFuncList->sSampleDealingFuncs.pfSample4Sad[BLOCK_8x8] = WelsSampleSadFour8x8_sse2;
501− pFuncList->sSampleDealingFuncs.pfSample4Sad[BLOCK_4x4] = WelsSampleSadFour4x4_sse2;
502−
503− pFuncList->sSampleDealingFuncs.pfSampleSatd[BLOCK_4x4 ] = WelsSampleSatd4x4_sse2;
504− pFuncList->sSampleDealingFuncs.pfSampleSatd[BLOCK_8x8 ] = WelsSampleSatd8x8_sse2;
505− pFuncList->sSampleDealingFuncs.pfSampleSatd[BLOCK_8x16 ] = WelsSampleSatd8x16_sse2;
506− pFuncList->sSampleDealingFuncs.pfSampleSatd[BLOCK_16x8 ] = WelsSampleSatd16x8_sse2;
507− pFuncList->sSampleDealingFuncs.pfSampleSatd[BLOCK_16x16] = WelsSampleSatd16x16_sse2;
508− pFuncList->sSampleDealingFuncs.pfIntra4x4Combined3Satd = WelsSmpleSatdThree4x4_sse2;
509− }
510−
511− if (uiCpuFlag & WELS_CPU_SSSE3)
512− {
513− pFuncList->sSampleDealingFuncs.pfIntra16x16Combined3Sad = WelsIntra16x16Combined3Sad_ssse3;
514− }
515−
516− if( uiCpuFlag & WELS_CPU_SSE41 )
517− {
518− pFuncList->sSampleDealingFuncs.pfSampleSatd[BLOCK_16x16] = WelsSampleSatd16x16_sse41;
519− pFuncList->sSampleDealingFuncs.pfSampleSatd[BLOCK_16x8] = WelsSampleSatd16x8_sse41;
520− pFuncList->sSampleDealingFuncs.pfSampleSatd[BLOCK_8x16] = WelsSampleSatd8x16_sse41;
521− pFuncList->sSampleDealingFuncs.pfSampleSatd[BLOCK_8x8] = WelsSampleSatd8x8_sse41;
522− pFuncList->sSampleDealingFuncs.pfSampleSatd[BLOCK_4x4] = WelsSampleSatd4x4_sse41;
523− pFuncList->sSampleDealingFuncs.pfIntra16x16Combined3Satd = WelsIntra16x16Combined3Satd_sse41;
524− pFuncList->sSampleDealingFuncs.pfIntra8x8Combined3Satd = WelsIntraChroma8x8Combined3Satd_sse41;
525− }
526−
527−#endif //(X86_ASM)
528−
529−}
530−
531−} // namespace WelsSVCEnc
1+/*!
2+ * \copy
3+ * Copyright (c) 2009-2013, Cisco Systems
4+ * All rights reserved.
5+ *
6+ * Redistribution and use in source and binary forms, with or without
7+ * modification, are permitted provided that the following conditions
8+ * are met:
9+ *
10+ * * Redistributions of source code must retain the above copyright
11+ * notice, this list of conditions and the following disclaimer.
12+ *
13+ * * Redistributions in binary form must reproduce the above copyright
14+ * notice, this list of conditions and the following disclaimer in
15+ * the documentation and/or other materials provided with the
16+ * distribution.
17+ *
18+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22+ * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29+ * POSSIBILITY OF SUCH DAMAGE.
30+ *
31+ *
32+ * \file sample.c
33+ *
34+ * \brief compute SAD and SATD
35+ *
36+ * \date 2009.06.02 Created
37+ *
38+ *************************************************************************************
39+ */
40+
41+#include "sample.h"
42+#include "macros.h"
43+
44+#include "mc.h"
45+#include "cpu_core.h"
46+#include "array_stack_align.h"
47+
48+namespace WelsSVCEnc {
49+int32_t WelsSampleSad4x4_c (uint8_t* pSample1, int32_t iStride1, uint8_t* pSample2, int32_t iStride2) {
50+ int32_t iSadSum = 0;
51+ int32_t i = 0;
52+ uint8_t* pSrc1 = pSample1;
53+ uint8_t* pSrc2 = pSample2;
54+ for (i = 0; i < 4; i++) {
55+ iSadSum += WELS_ABS ((pSrc1[0] - pSrc2[0]));
56+ iSadSum += WELS_ABS ((pSrc1[1] - pSrc2[1]));
57+ iSadSum += WELS_ABS ((pSrc1[2] - pSrc2[2]));
58+ iSadSum += WELS_ABS ((pSrc1[3] - pSrc2[3]));
59+
60+ pSrc1 += iStride1;
61+ pSrc2 += iStride2;
62+ }
63+
64+ return iSadSum;
65+}
66+
67+int32_t WelsSampleSad8x8_c (uint8_t* pSample1, int32_t iStride1, uint8_t* pSample2, int32_t iStride2) {
68+ int32_t iSadSum = 0;
69+ int32_t i = 0;
70+ uint8_t* pSrc1 = pSample1;
71+ uint8_t* pSrc2 = pSample2;
72+ for (i = 0; i < 8; i++) {
73+ iSadSum += WELS_ABS ((pSrc1[0] - pSrc2[0]));
74+ iSadSum += WELS_ABS ((pSrc1[1] - pSrc2[1]));
75+ iSadSum += WELS_ABS ((pSrc1[2] - pSrc2[2]));
76+ iSadSum += WELS_ABS ((pSrc1[3] - pSrc2[3]));
77+ iSadSum += WELS_ABS ((pSrc1[4] - pSrc2[4]));
78+ iSadSum += WELS_ABS ((pSrc1[5] - pSrc2[5]));
79+ iSadSum += WELS_ABS ((pSrc1[6] - pSrc2[6]));
80+ iSadSum += WELS_ABS ((pSrc1[7] - pSrc2[7]));
81+
82+ pSrc1 += iStride1;
83+ pSrc2 += iStride2;
84+ }
85+
86+ return iSadSum;
87+}
88+int32_t WelsSampleSad16x8_c (uint8_t* pSample1, int32_t iStride1, uint8_t* pSample2, int32_t iStride2) {
89+ int32_t iSadSum = 0;
90+
91+ iSadSum += WelsSampleSad8x8_c (pSample1, iStride1, pSample2, iStride2);
92+ iSadSum += WelsSampleSad8x8_c (pSample1 + 8, iStride1, pSample2 + 8, iStride2);
93+
94+ return iSadSum;
95+}
96+int32_t WelsSampleSad8x16_c (uint8_t* pSample1, int32_t iStride1, uint8_t* pSample2, int32_t iStride2) {
97+ int32_t iSadSum = 0;
98+ iSadSum += WelsSampleSad8x8_c (pSample1, iStride1, pSample2, iStride2);
99+ iSadSum += WelsSampleSad8x8_c (pSample1 + (iStride1 << 3), iStride1, pSample2 + (iStride2 << 3), iStride2);
100+
101+ return iSadSum;
102+}
103+int32_t WelsSampleSad16x16_c (uint8_t* pSample1, int32_t iStride1, uint8_t* pSample2, int32_t iStride2) {
104+ int32_t iSadSum = 0;
105+ iSadSum += WelsSampleSad8x8_c (pSample1, iStride1, pSample2, iStride2);
106+ iSadSum += WelsSampleSad8x8_c (pSample1 + 8, iStride1, pSample2 + 8, iStride2);
107+ iSadSum += WelsSampleSad8x8_c (pSample1 + (iStride1 << 3), iStride1, pSample2 + (iStride2 << 3), iStride2);
108+ iSadSum += WelsSampleSad8x8_c (pSample1 + (iStride1 << 3) + 8, iStride1, pSample2 + (iStride2 << 3) + 8, iStride2);
109+
110+ return iSadSum;
111+}
112+
113+int32_t WelsSampleSatd4x4_c (uint8_t* pSample1, int32_t iStride1, uint8_t* pSample2, int32_t iStride2) {
114+ int32_t iSatdSum = 0;
115+ int32_t pSampleMix[4][4] = { 0 };
116+ int32_t iSample0, iSample1, iSample2, iSample3;
117+ int32_t i = 0;
118+ uint8_t* pSrc1 = pSample1;
119+ uint8_t* pSrc2 = pSample2;
120+
121+ //step 1: get the difference
122+ for (i = 0; i < 4; i++) {
123+ pSampleMix[i][0] = pSrc1[0] - pSrc2[0];
124+ pSampleMix[i][1] = pSrc1[1] - pSrc2[1];
125+ pSampleMix[i][2] = pSrc1[2] - pSrc2[2];
126+ pSampleMix[i][3] = pSrc1[3] - pSrc2[3];
127+
128+ pSrc1 += iStride1;
129+ pSrc2 += iStride2;
130+ }
131+
132+ //step 2: horizontal transform
133+ for (i = 0; i < 4; i++) {
134+ iSample0 = pSampleMix[i][0] + pSampleMix[i][2];
135+ iSample1 = pSampleMix[i][1] + pSampleMix[i][3];
136+ iSample2 = pSampleMix[i][0] - pSampleMix[i][2];
137+ iSample3 = pSampleMix[i][1] - pSampleMix[i][3];
138+
139+ pSampleMix[i][0] = iSample0 + iSample1;
140+ pSampleMix[i][1] = iSample2 + iSample3;
141+ pSampleMix[i][2] = iSample2 - iSample3;
142+ pSampleMix[i][3] = iSample0 - iSample1;
143+ }
144+
145+ //step 3: vertical transform and get the sum of SATD
146+ for (i = 0; i < 4; i++) {
147+ iSample0 = pSampleMix[0][i] + pSampleMix[2][i];
148+ iSample1 = pSampleMix[1][i] + pSampleMix[3][i];
149+ iSample2 = pSampleMix[0][i] - pSampleMix[2][i];
150+ iSample3 = pSampleMix[1][i] - pSampleMix[3][i];
151+
152+ pSampleMix[0][i] = iSample0 + iSample1;
153+ pSampleMix[1][i] = iSample2 + iSample3;
154+ pSampleMix[2][i] = iSample2 - iSample3;
155+ pSampleMix[3][i] = iSample0 - iSample1;
156+
157+ iSatdSum += (WELS_ABS (pSampleMix[0][i]) + WELS_ABS (pSampleMix[1][i]) + WELS_ABS (pSampleMix[2][i]) + WELS_ABS (
158+ pSampleMix[3][i]));
159+ }
160+
161+ return ((iSatdSum + 1) >> 1);
162+}
163+int32_t WelsSampleSatd8x8_c (uint8_t* pSample1, int32_t iStride1, uint8_t* pSample2, int32_t iStride2) {
164+ int32_t iSatdSum = 0;
165+
166+ iSatdSum += WelsSampleSatd4x4_c (pSample1, iStride1, pSample2, iStride2);
167+ iSatdSum += WelsSampleSatd4x4_c (pSample1 + 4, iStride1, pSample2 + 4, iStride2);
168+ iSatdSum += WelsSampleSatd4x4_c (pSample1 + (iStride1 << 2), iStride1, pSample2 + (iStride2 << 2), iStride2);
169+ iSatdSum += WelsSampleSatd4x4_c (pSample1 + (iStride1 << 2) + 4, iStride1, pSample2 + (iStride2 << 2) + 4, iStride2);
170+
171+ return iSatdSum;
172+}
173+int32_t WelsSampleSatd16x8_c (uint8_t* pSample1, int32_t iStride1, uint8_t* pSample2, int32_t iStride2) {
174+ int32_t iSatdSum = 0;
175+
176+ iSatdSum += WelsSampleSatd8x8_c (pSample1, iStride1, pSample2, iStride2);
177+ iSatdSum += WelsSampleSatd8x8_c (pSample1 + 8, iStride1, pSample2 + 8, iStride2);
178+
179+ return iSatdSum;
180+}
181+int32_t WelsSampleSatd8x16_c (uint8_t* pSample1, int32_t iStride1, uint8_t* pSample2, int32_t iStride2) {
182+ int32_t iSatdSum = 0;
183+
184+ iSatdSum += WelsSampleSatd8x8_c (pSample1, iStride1, pSample2, iStride2);
185+ iSatdSum += WelsSampleSatd8x8_c (pSample1 + (iStride1 << 3), iStride1, pSample2 + (iStride2 << 3), iStride2);
186+
187+ return iSatdSum;
188+}
189+int32_t WelsSampleSatd16x16_c (uint8_t* pSample1, int32_t iStride1, uint8_t* pSample2, int32_t iStride2) {
190+ int32_t iSatdSum = 0;
191+
192+ iSatdSum += WelsSampleSatd8x8_c (pSample1, iStride1, pSample2, iStride2);
193+ iSatdSum += WelsSampleSatd8x8_c (pSample1 + 8, iStride1, pSample2 + 8, iStride2);
194+ iSatdSum += WelsSampleSatd8x8_c (pSample1 + (iStride1 << 3), iStride1, pSample2 + (iStride2 << 3), iStride2);
195+ iSatdSum += WelsSampleSatd8x8_c (pSample1 + (iStride1 << 3) + 8, iStride1, pSample2 + (iStride2 << 3) + 8, iStride2);
196+
197+ return iSatdSum;
198+}
199+
200+
201+void WelsSampleSadFour16x16_c (uint8_t* iSample1, int32_t iStride1, uint8_t* iSample2, int32_t iStride2,
202+ int32_t* pSad) {
203+ * (pSad) = WelsSampleSad16x16_c (iSample1, iStride1, (iSample2 - iStride2), iStride2);
204+ * (pSad + 1) = WelsSampleSad16x16_c (iSample1, iStride1, (iSample2 + iStride2), iStride2);
205+ * (pSad + 2) = WelsSampleSad16x16_c (iSample1, iStride1, (iSample2 - 1), iStride2);
206+ * (pSad + 3) = WelsSampleSad16x16_c (iSample1, iStride1, (iSample2 + 1), iStride2);
207+}
208+void WelsSampleSadFour16x8_c (uint8_t* iSample1, int32_t iStride1, uint8_t* iSample2, int32_t iStride2, int32_t* pSad) {
209+ * (pSad) = WelsSampleSad16x8_c (iSample1, iStride1, (iSample2 - iStride2), iStride2);
210+ * (pSad + 1) = WelsSampleSad16x8_c (iSample1, iStride1, (iSample2 + iStride2), iStride2);
211+ * (pSad + 2) = WelsSampleSad16x8_c (iSample1, iStride1, (iSample2 - 1), iStride2);
212+ * (pSad + 3) = WelsSampleSad16x8_c (iSample1, iStride1, (iSample2 + 1), iStride2);
213+}
214+void WelsSampleSadFour8x16_c (uint8_t* iSample1, int32_t iStride1, uint8_t* iSample2, int32_t iStride2, int32_t* pSad) {
215+ * (pSad) = WelsSampleSad8x16_c (iSample1, iStride1, (iSample2 - iStride2), iStride2);
216+ * (pSad + 1) = WelsSampleSad8x16_c (iSample1, iStride1, (iSample2 + iStride2), iStride2);
217+ * (pSad + 2) = WelsSampleSad8x16_c (iSample1, iStride1, (iSample2 - 1), iStride2);
218+ * (pSad + 3) = WelsSampleSad8x16_c (iSample1, iStride1, (iSample2 + 1), iStride2);
219+
220+}
221+void WelsSampleSadFour8x8_c (uint8_t* iSample1, int32_t iStride1, uint8_t* iSample2, int32_t iStride2, int32_t* pSad) {
222+ * (pSad) = WelsSampleSad8x8_c (iSample1, iStride1, (iSample2 - iStride2), iStride2);
223+ * (pSad + 1) = WelsSampleSad8x8_c (iSample1, iStride1, (iSample2 + iStride2), iStride2);
224+ * (pSad + 2) = WelsSampleSad8x8_c (iSample1, iStride1, (iSample2 - 1), iStride2);
225+ * (pSad + 3) = WelsSampleSad8x8_c (iSample1, iStride1, (iSample2 + 1), iStride2);
226+}
227+void WelsSampleSadFour4x4_c (uint8_t* iSample1, int32_t iStride1, uint8_t* iSample2, int32_t iStride2, int32_t* pSad) {
228+ * (pSad) = WelsSampleSad4x4_c (iSample1, iStride1, (iSample2 - iStride2), iStride2);
229+ * (pSad + 1) = WelsSampleSad4x4_c (iSample1, iStride1, (iSample2 + iStride2), iStride2);
230+ * (pSad + 2) = WelsSampleSad4x4_c (iSample1, iStride1, (iSample2 - 1), iStride2);
231+ * (pSad + 3) = WelsSampleSad4x4_c (iSample1, iStride1, (iSample2 + 1), iStride2);
232+}
233+
234+extern void WelsI4x4LumaPredDc_c (uint8_t* pPred, uint8_t* pRef, const int32_t iStride);
235+extern void WelsI4x4LumaPredH_c (uint8_t* pPred, uint8_t* pRef, const int32_t iStride);
236+extern void WelsI4x4LumaPredV_c (uint8_t* pPred, uint8_t* pRef, const int32_t iStride);
237+
238+int32_t WelsSampleSatdIntra4x4Combined3_c (uint8_t* pDec, int32_t iDecStride, uint8_t* pEnc, int32_t iEncStride,
239+ uint8_t* pDst,
240+ int32_t* pBestMode, int32_t iLambda2, int32_t iLambda1, int32_t iLambda0) {
241+ int32_t iBestMode = -1;
242+ int32_t iCurCost, iBestCost = INT_MAX;
243+ ENFORCE_STACK_ALIGN_2D (uint8_t, uiLocalBuffer, 3, 16, 16)
244+
245+ WelsI4x4LumaPredDc_c (uiLocalBuffer[2], pDec, iDecStride);
246+ iCurCost = WelsSampleSatd4x4_c (uiLocalBuffer[2], 4, pEnc, iEncStride) + iLambda2;
247+ if (iCurCost < iBestCost) {
248+ iBestMode = 2;
249+ iBestCost = iCurCost;
250+ }
251+
252+ WelsI4x4LumaPredH_c (uiLocalBuffer[1], pDec, iDecStride);
253+ iCurCost = WelsSampleSatd4x4_c (uiLocalBuffer[1], 4, pEnc, iEncStride) + iLambda1;
254+ if (iCurCost < iBestCost) {
255+ iBestMode = 1;
256+ iBestCost = iCurCost;
257+ }
258+ WelsI4x4LumaPredV_c (uiLocalBuffer[0], pDec, iDecStride);
259+ iCurCost = WelsSampleSatd4x4_c (uiLocalBuffer[0], 4, pEnc, iEncStride) + iLambda0;
260+ if (iCurCost < iBestCost) {
261+ iBestMode = 0;
262+ iBestCost = iCurCost;
263+ }
264+
265+ memcpy (pDst, uiLocalBuffer[iBestMode], 16 * sizeof (uint8_t)); // confirmed_safe_unsafe_usage
266+ *pBestMode = iBestMode;
267+
268+ return iBestCost;
269+}
270+extern void WelsIChormaPredDc_c (uint8_t* pPred, uint8_t* pRef, const int32_t iStride);
271+extern void WelsIChormaPredH_c (uint8_t* pPred, uint8_t* pRef, const int32_t iStride);
272+extern void WelsIChormaPredV_c (uint8_t* pPred, uint8_t* pRef, const int32_t iStride);
273+
274+int32_t WelsSampleSatdIntra8x8Combined3_c (uint8_t* pDecCb, int32_t iDecStride, uint8_t* pEncCb, int32_t iEncStride,
275+ int32_t* pBestMode, int32_t iLambda, uint8_t* pDstChroma, uint8_t* pDecCr, uint8_t* pEncCr) {
276+ int32_t iBestMode = -1;
277+ int32_t iCurCost, iBestCost = INT_MAX;
278+
279+ WelsIChormaPredV_c (pDstChroma, pDecCb, iDecStride);
280+ WelsIChormaPredV_c (pDstChroma + 64, pDecCr, iDecStride);
281+ iCurCost = WelsSampleSatd8x8_c (pDstChroma, 8, pEncCb, iEncStride);
282+ iCurCost += WelsSampleSatd8x8_c (pDstChroma + 64, 8, pEncCr, iEncStride) + iLambda * 2;
283+
284+ if (iCurCost < iBestCost) {
285+ iBestMode = 2;
286+ iBestCost = iCurCost;
287+ }
288+
289+ WelsIChormaPredH_c (pDstChroma, pDecCb, iDecStride);
290+ WelsIChormaPredH_c (pDstChroma + 64, pDecCr, iDecStride);
291+ iCurCost = WelsSampleSatd8x8_c (pDstChroma, 8, pEncCb, iEncStride);
292+ iCurCost += WelsSampleSatd8x8_c (pDstChroma + 64, 8, pEncCr, iEncStride) + iLambda * 2;
293+ if (iCurCost < iBestCost) {
294+ iBestMode = 1;
295+ iBestCost = iCurCost;
296+ }
297+ WelsIChormaPredDc_c (pDstChroma, pDecCb, iDecStride);
298+ WelsIChormaPredDc_c (pDstChroma + 64, pDecCr, iDecStride);
299+ iCurCost = WelsSampleSatd8x8_c (pDstChroma, 8, pEncCb, iEncStride);
300+ iCurCost += WelsSampleSatd8x8_c (pDstChroma + 64, 8, pEncCr, iEncStride);
301+ if (iCurCost < iBestCost) {
302+ iBestMode = 0;
303+ iBestCost = iCurCost;
304+ }
305+
306+ *pBestMode = iBestMode;
307+
308+ return iBestCost;
309+
310+
311+}
312+int32_t WelsSampleSadIntra8x8Combined3_c (uint8_t* pDecCb, int32_t iDecStride, uint8_t* pEncCb, int32_t iEncStride,
313+ int32_t* pBestMode, int32_t iLambda, uint8_t* pDstChroma, uint8_t* pDecCr, uint8_t* pEncCr) {
314+ int32_t iBestMode = -1;
315+ int32_t iCurCost, iBestCost = INT_MAX;
316+
317+ WelsIChormaPredV_c (pDstChroma, pDecCb, iDecStride);
318+ WelsIChormaPredV_c (pDstChroma + 64, pDecCr, iDecStride);
319+ iCurCost = WelsSampleSad8x8_c (pDstChroma, 8, pEncCb, iEncStride);
320+ iCurCost += WelsSampleSad8x8_c (pDstChroma + 64, 8, pEncCr, iEncStride) + iLambda * 2;
321+
322+ if (iCurCost < iBestCost) {
323+ iBestMode = 2;
324+ iBestCost = iCurCost;
325+ }
326+
327+ WelsIChormaPredH_c (pDstChroma, pDecCb, iDecStride);
328+ WelsIChormaPredH_c (pDstChroma + 64, pDecCr, iDecStride);
329+ iCurCost = WelsSampleSad8x8_c (pDstChroma, 8, pEncCb, iEncStride);
330+ iCurCost += WelsSampleSad8x8_c (pDstChroma + 64, 8, pEncCr, iEncStride) + iLambda * 2;
331+ if (iCurCost < iBestCost) {
332+ iBestMode = 1;
333+ iBestCost = iCurCost;
334+ }
335+ WelsIChormaPredDc_c (pDstChroma, pDecCb, iDecStride);
336+ WelsIChormaPredDc_c (pDstChroma + 64, pDecCr, iDecStride);
337+ iCurCost = WelsSampleSad8x8_c (pDstChroma, 8, pEncCb, iEncStride);
338+ iCurCost += WelsSampleSad8x8_c (pDstChroma + 64, 8, pEncCr, iEncStride);
339+ if (iCurCost < iBestCost) {
340+ iBestMode = 0;
341+ iBestCost = iCurCost;
342+ }
343+
344+ *pBestMode = iBestMode;
345+
346+ return iBestCost;
347+
348+}
349+
350+extern void WelsI16x16LumaPredDc_c (uint8_t* pPred, uint8_t* pRef, const int32_t iStride);
351+extern void WelsI16x16LumaPredH_c (uint8_t* pPred, uint8_t* pRef, const int32_t iStride);
352+extern void WelsI16x16LumaPredV_c (uint8_t* pPred, uint8_t* pRef, const int32_t iStride);
353+
354+int32_t WelsSampleSatdIntra16x16Combined3_c (uint8_t* pDec, int32_t iDecStride, uint8_t* pEnc, int32_t iEncStride,
355+ int32_t* pBestMode, int32_t iLambda, uint8_t* pDst) {
356+ int32_t iBestMode = -1;
357+ int32_t iCurCost, iBestCost = INT_MAX;
358+
359+ WelsI16x16LumaPredV_c (pDst, pDec, iDecStride);
360+ iCurCost = WelsSampleSatd16x16_c (pDst, 16, pEnc, iEncStride);
361+
362+ if (iCurCost < iBestCost) {
363+ iBestMode = 0;
364+ iBestCost = iCurCost;
365+ }
366+
367+ WelsI16x16LumaPredH_c (pDst, pDec, iDecStride);
368+ iCurCost = WelsSampleSatd16x16_c (pDst, 16, pEnc, iEncStride) + iLambda * 2;
369+ if (iCurCost < iBestCost) {
370+ iBestMode = 1;
371+ iBestCost = iCurCost;
372+ }
373+ WelsI16x16LumaPredDc_c (pDst, pDec, iDecStride);
374+ iCurCost = WelsSampleSatd16x16_c (pDst, 16, pEnc, iEncStride) + iLambda * 2;
375+ if (iCurCost < iBestCost) {
376+ iBestMode = 2;
377+ iBestCost = iCurCost;
378+ }
379+
380+ *pBestMode = iBestMode;
381+
382+ return iBestCost;
383+
384+
385+}
386+int32_t WelsSampleSadIntra16x16Combined3_c (uint8_t* pDec, int32_t iDecStride, uint8_t* pEnc, int32_t iEncStride,
387+ int32_t* pBestMode, int32_t iLambda, uint8_t* pDst) {
388+ int32_t iBestMode = -1;
389+ int32_t iCurCost, iBestCost = INT_MAX;
390+
391+ WelsI16x16LumaPredV_c (pDst, pDec, iDecStride);
392+ iCurCost = WelsSampleSad16x16_c (pDst, 16, pEnc, iEncStride);
393+
394+ if (iCurCost < iBestCost) {
395+ iBestMode = 0;
396+ iBestCost = iCurCost;
397+ }
398+
399+ WelsI16x16LumaPredH_c (pDst, pDec, iDecStride);
400+ iCurCost = WelsSampleSad16x16_c (pDst, 16, pEnc, iEncStride) + iLambda * 2;
401+ if (iCurCost < iBestCost) {
402+ iBestMode = 1;
403+ iBestCost = iCurCost;
404+ }
405+ WelsI16x16LumaPredDc_c (pDst, pDec, iDecStride);
406+ iCurCost = WelsSampleSad16x16_c (pDst, 16, pEnc, iEncStride) + iLambda * 2;
407+ if (iCurCost < iBestCost) {
408+ iBestMode = 2;
409+ iBestCost = iCurCost;
410+ }
411+
412+ *pBestMode = iBestMode;
413+
414+ return iBestCost;
415+
416+
417+}
418+
419+void WelsInitSampleSadFunc (SWelsFuncPtrList* pFuncList, uint32_t uiCpuFlag) {
420+ //pfSampleSad init
421+ pFuncList->sSampleDealingFuncs.pfSampleSad[BLOCK_16x16] = WelsSampleSad16x16_c;
422+ pFuncList->sSampleDealingFuncs.pfSampleSad[BLOCK_16x8 ] = WelsSampleSad16x8_c;
423+ pFuncList->sSampleDealingFuncs.pfSampleSad[BLOCK_8x16 ] = WelsSampleSad8x16_c;
424+ pFuncList->sSampleDealingFuncs.pfSampleSad[BLOCK_8x8 ] = WelsSampleSad8x8_c;
425+ pFuncList->sSampleDealingFuncs.pfSampleSad[BLOCK_4x4 ] = WelsSampleSad4x4_c;
426+
427+ //pfSampleSatd init
428+ pFuncList->sSampleDealingFuncs.pfSampleSatd[BLOCK_16x16] = WelsSampleSatd16x16_c;
429+ pFuncList->sSampleDealingFuncs.pfSampleSatd[BLOCK_16x8 ] = WelsSampleSatd16x8_c;
430+ pFuncList->sSampleDealingFuncs.pfSampleSatd[BLOCK_8x16 ] = WelsSampleSatd8x16_c;
431+ pFuncList->sSampleDealingFuncs.pfSampleSatd[BLOCK_8x8 ] = WelsSampleSatd8x8_c;
432+ pFuncList->sSampleDealingFuncs.pfSampleSatd[BLOCK_4x4 ] = WelsSampleSatd4x4_c;
433+
434+ pFuncList->sSampleDealingFuncs.pfSample4Sad[BLOCK_16x16] = WelsSampleSadFour16x16_c;
435+ pFuncList->sSampleDealingFuncs.pfSample4Sad[BLOCK_16x8] = WelsSampleSadFour16x8_c;
436+ pFuncList->sSampleDealingFuncs.pfSample4Sad[BLOCK_8x16] = WelsSampleSadFour8x16_c;
437+ pFuncList->sSampleDealingFuncs.pfSample4Sad[BLOCK_8x8] = WelsSampleSadFour8x8_c;
438+ pFuncList->sSampleDealingFuncs.pfSample4Sad[BLOCK_4x4] = WelsSampleSadFour4x4_c;
439+
440+ pFuncList->sSampleDealingFuncs.pfIntra4x4Combined3Satd = NULL;
441+ pFuncList->sSampleDealingFuncs.pfIntra8x8Combined3Satd = NULL;
442+ pFuncList->sSampleDealingFuncs.pfIntra8x8Combined3Sad = NULL;
443+ pFuncList->sSampleDealingFuncs.pfIntra16x16Combined3Satd = NULL;
444+ pFuncList->sSampleDealingFuncs.pfIntra16x16Combined3Sad = NULL;
445+
446+#if defined (X86_ASM)
447+ if (uiCpuFlag & WELS_CPU_MMXEXT) {
448+ pFuncList->sSampleDealingFuncs.pfSampleSad[BLOCK_4x4 ] = WelsSampleSad4x4_mmx;
449+ }
450+
451+ if (uiCpuFlag & WELS_CPU_SSE2) {
452+ pFuncList->sSampleDealingFuncs.pfSampleSad[BLOCK_16x16] = WelsSampleSad16x16_sse2;
453+ pFuncList->sSampleDealingFuncs.pfSampleSad[BLOCK_16x8 ] = WelsSampleSad16x8_sse2;
454+ pFuncList->sSampleDealingFuncs.pfSampleSad[BLOCK_8x16] = WelsSampleSad8x16_sse2;
455+ pFuncList->sSampleDealingFuncs.pfSampleSad[BLOCK_8x8] = WelsSampleSad8x8_sse21;
456+
457+ pFuncList->sSampleDealingFuncs.pfSample4Sad[BLOCK_16x16] = WelsSampleSadFour16x16_sse2;
458+ pFuncList->sSampleDealingFuncs.pfSample4Sad[BLOCK_16x8] = WelsSampleSadFour16x8_sse2;
459+ pFuncList->sSampleDealingFuncs.pfSample4Sad[BLOCK_8x16] = WelsSampleSadFour8x16_sse2;
460+ pFuncList->sSampleDealingFuncs.pfSample4Sad[BLOCK_8x8] = WelsSampleSadFour8x8_sse2;
461+ pFuncList->sSampleDealingFuncs.pfSample4Sad[BLOCK_4x4] = WelsSampleSadFour4x4_sse2;
462+
463+ pFuncList->sSampleDealingFuncs.pfSampleSatd[BLOCK_4x4 ] = WelsSampleSatd4x4_sse2;
464+ pFuncList->sSampleDealingFuncs.pfSampleSatd[BLOCK_8x8 ] = WelsSampleSatd8x8_sse2;
465+ pFuncList->sSampleDealingFuncs.pfSampleSatd[BLOCK_8x16 ] = WelsSampleSatd8x16_sse2;
466+ pFuncList->sSampleDealingFuncs.pfSampleSatd[BLOCK_16x8 ] = WelsSampleSatd16x8_sse2;
467+ pFuncList->sSampleDealingFuncs.pfSampleSatd[BLOCK_16x16] = WelsSampleSatd16x16_sse2;
468+ pFuncList->sSampleDealingFuncs.pfIntra4x4Combined3Satd = WelsSmpleSatdThree4x4_sse2;
469+ }
470+
471+ if (uiCpuFlag & WELS_CPU_SSSE3) {
472+ pFuncList->sSampleDealingFuncs.pfIntra16x16Combined3Sad = WelsIntra16x16Combined3Sad_ssse3;
473+ }
474+
475+ if (uiCpuFlag & WELS_CPU_SSE41) {
476+ pFuncList->sSampleDealingFuncs.pfSampleSatd[BLOCK_16x16] = WelsSampleSatd16x16_sse41;
477+ pFuncList->sSampleDealingFuncs.pfSampleSatd[BLOCK_16x8] = WelsSampleSatd16x8_sse41;
478+ pFuncList->sSampleDealingFuncs.pfSampleSatd[BLOCK_8x16] = WelsSampleSatd8x16_sse41;
479+ pFuncList->sSampleDealingFuncs.pfSampleSatd[BLOCK_8x8] = WelsSampleSatd8x8_sse41;
480+ pFuncList->sSampleDealingFuncs.pfSampleSatd[BLOCK_4x4] = WelsSampleSatd4x4_sse41;
481+ pFuncList->sSampleDealingFuncs.pfIntra16x16Combined3Satd = WelsIntra16x16Combined3Satd_sse41;
482+ pFuncList->sSampleDealingFuncs.pfIntra8x8Combined3Satd = WelsIntraChroma8x8Combined3Satd_sse41;
483+ }
484+
485+#endif //(X86_ASM)
486+
487+}
488+
489+} // namespace WelsSVCEnc

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t