History

Initial Commit

Ethan Hugg committed 12 years ago

Commit 70e5e621 parent bd509b2308 files · +97095 −-5Browse files

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

Unified · Split

codec/encoder/core/src/sample.cpp+531−0
@@ -0,0 +1,531 @@
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

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