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
48namespace WelsSVCEnc {
49int32_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
69int32_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}
92int32_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}
101int32_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}
109int32_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
120int32_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}
173int32_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}
184int32_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}
193int32_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}
202int32_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
215void 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}
222void 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}
229void 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}
237void 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}
244void 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
252extern void WelsI4x4LumaPredDc_c(uint8_t *pPred, uint8_t *pRef, const int32_t iStride);
253extern void WelsI4x4LumaPredH_c(uint8_t *pPred, uint8_t *pRef, const int32_t iStride);
254extern void WelsI4x4LumaPredV_c(uint8_t *pPred, uint8_t *pRef, const int32_t iStride);
255
256int32_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}
291extern void WelsIChormaPredDc_c(uint8_t *pPred, uint8_t *pRef, const int32_t iStride);
292extern void WelsIChormaPredH_c(uint8_t *pPred, uint8_t *pRef, const int32_t iStride);
293extern void WelsIChormaPredV_c(uint8_t *pPred, uint8_t *pRef, const int32_t iStride);
294
295int32_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}
337int32_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
379extern void WelsI16x16LumaPredDc_c(uint8_t *pPred, uint8_t *pRef, const int32_t iStride);
380extern void WelsI16x16LumaPredH_c(uint8_t *pPred, uint8_t *pRef, const int32_t iStride);
381extern void WelsI16x16LumaPredV_c(uint8_t *pPred, uint8_t *pRef, const int32_t iStride);
382
383int32_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}
419int32_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
456void 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