History

Add UT for VaaCalc Functions.

zhiliang wang committed 12 years ago

Commit 0163eb51 parent 0951c8f4 files · +851 −2Browse files

Showing the changes to test/processing/ProcessUT_VaaCalc.cpp (1 of 4 files). Show all

Unified · Split

test/processing/ProcessUT_VaaCalc.cpp+847−0
@@ -0,0 +1,847 @@
1#include <gtest/gtest.h>
2#include "cpu.h"
3#include "cpu_core.h"
4#include "util.h"
5#include "macros.h"
6#include "IWelsVP.h"
7#include "vaacalculation.h"
8
9using namespace nsWelsVP;
10
11void VAACalcSadSsd_ref (const uint8_t* pCurData, const uint8_t* pRefData, int32_t iPicWidth, int32_t iPicHeight,
12 int32_t iPicStride,
13 int32_t* pFrameSad, int32_t* pSad8x8, int32_t* pSum16x16, int32_t* psqsum16x16, int32_t* psqdiff16x16) {
14 const uint8_t* tmp_ref = pRefData;
15 const uint8_t* tmp_cur = pCurData;
16 int32_t iMbWidth = (iPicWidth >> 4);
17 int32_t mb_height = (iPicHeight >> 4);
18 int32_t mb_index = 0;
19 int32_t pic_stride_x8 = iPicStride << 3;
20 int32_t step = (iPicStride << 4) - iPicWidth;
21
22 *pFrameSad = 0;
23 for (int32_t i = 0; i < mb_height; i ++) {
24 for (int32_t j = 0; j < iMbWidth; j ++) {
25 int32_t k, l;
26 int32_t l_sad, l_sqdiff, l_sum, l_sqsum;
27 const uint8_t* tmp_cur_row;
28 const uint8_t* tmp_ref_row;
29
30 pSum16x16[mb_index] = 0;
31 psqsum16x16[mb_index] = 0;
32 psqdiff16x16[mb_index] = 0;
33
34 l_sad = l_sqdiff = l_sum = l_sqsum = 0;
35 tmp_cur_row = tmp_cur;
36 tmp_ref_row = tmp_ref;
37 for (k = 0; k < 8; k ++) {
38 for (l = 0; l < 8; l ++) {
39 int32_t diff = WELS_ABS (tmp_cur_row[l] - tmp_ref_row[l]);
40 l_sad += diff;
41 l_sqdiff += diff * diff;
42 l_sum += tmp_cur_row[l];
43 l_sqsum += tmp_cur_row[l] * tmp_cur_row[l];
44 }
45 tmp_cur_row += iPicStride;
46 tmp_ref_row += iPicStride;
47 }
48 *pFrameSad += l_sad;
49 pSad8x8[ (mb_index << 2) + 0] = l_sad;
50 pSum16x16[mb_index] += l_sum;
51 psqsum16x16[mb_index] += l_sqsum;
52 psqdiff16x16[mb_index] += l_sqdiff;
53
54 l_sad = l_sqdiff = l_sum = l_sqsum = 0;
55 tmp_cur_row = tmp_cur + 8;
56 tmp_ref_row = tmp_ref + 8;
57 for (k = 0; k < 8; k ++) {
58 for (l = 0; l < 8; l ++) {
59 int32_t diff = WELS_ABS (tmp_cur_row[l] - tmp_ref_row[l]);
60 l_sad += diff;
61 l_sqdiff += diff * diff;
62 l_sum += tmp_cur_row[l];
63 l_sqsum += tmp_cur_row[l] * tmp_cur_row[l];
64 }
65 tmp_cur_row += iPicStride;
66 tmp_ref_row += iPicStride;
67 }
68 *pFrameSad += l_sad;
69 pSad8x8[ (mb_index << 2) + 1] = l_sad;
70 pSum16x16[mb_index] += l_sum;
71 psqsum16x16[mb_index] += l_sqsum;
72 psqdiff16x16[mb_index] += l_sqdiff;
73
74 l_sad = l_sqdiff = l_sum = l_sqsum = 0;
75 tmp_cur_row = tmp_cur + pic_stride_x8;
76 tmp_ref_row = tmp_ref + pic_stride_x8;
77 for (k = 0; k < 8; k ++) {
78 for (l = 0; l < 8; l ++) {
79 int32_t diff = WELS_ABS (tmp_cur_row[l] - tmp_ref_row[l]);
80 l_sad += diff;
81 l_sqdiff += diff * diff;
82 l_sum += tmp_cur_row[l];
83 l_sqsum += tmp_cur_row[l] * tmp_cur_row[l];
84 }
85 tmp_cur_row += iPicStride;
86 tmp_ref_row += iPicStride;
87 }
88 *pFrameSad += l_sad;
89 pSad8x8[ (mb_index << 2) + 2] = l_sad;
90 pSum16x16[mb_index] += l_sum;
91 psqsum16x16[mb_index] += l_sqsum;
92 psqdiff16x16[mb_index] += l_sqdiff;
93
94 l_sad = l_sqdiff = l_sum = l_sqsum = 0;
95 tmp_cur_row = tmp_cur + pic_stride_x8 + 8;
96 tmp_ref_row = tmp_ref + pic_stride_x8 + 8;
97 for (k = 0; k < 8; k ++) {
98 for (l = 0; l < 8; l ++) {
99 int32_t diff = WELS_ABS (tmp_cur_row[l] - tmp_ref_row[l]);
100 l_sad += diff;
101 l_sqdiff += diff * diff;
102 l_sum += tmp_cur_row[l];
103 l_sqsum += tmp_cur_row[l] * tmp_cur_row[l];
104 }
105 tmp_cur_row += iPicStride;
106 tmp_ref_row += iPicStride;
107 }
108 *pFrameSad += l_sad;
109 pSad8x8[ (mb_index << 2) + 3] = l_sad;
110 pSum16x16[mb_index] += l_sum;
111 psqsum16x16[mb_index] += l_sqsum;
112 psqdiff16x16[mb_index] += l_sqdiff;
113
114
115 tmp_ref += 16;
116 tmp_cur += 16;
117 ++mb_index;
118 }
119 tmp_ref += step;
120 tmp_cur += step;
121 }
122}
123void VAACalcSadVar_ref (const uint8_t* pCurData, const uint8_t* pRefData, int32_t iPicWidth, int32_t iPicHeight,
124 int32_t iPicStride,
125 int32_t* pFrameSad, int32_t* pSad8x8, int32_t* pSum16x16, int32_t* psqsum16x16) {
126 const uint8_t* tmp_ref = pRefData;
127 const uint8_t* tmp_cur = pCurData;
128 int32_t iMbWidth = (iPicWidth >> 4);
129 int32_t mb_height = (iPicHeight >> 4);
130 int32_t mb_index = 0;
131 int32_t pic_stride_x8 = iPicStride << 3;
132 int32_t step = (iPicStride << 4) - iPicWidth;
133
134 *pFrameSad = 0;
135 for (int32_t i = 0; i < mb_height; i ++) {
136 for (int32_t j = 0; j < iMbWidth; j ++) {
137 int32_t k, l;
138 int32_t l_sad, l_sum, l_sqsum;
139 const uint8_t* tmp_cur_row;
140 const uint8_t* tmp_ref_row;
141
142 pSum16x16[mb_index] = 0;
143 psqsum16x16[mb_index] = 0;
144
145 l_sad = l_sum = l_sqsum = 0;
146 tmp_cur_row = tmp_cur;
147 tmp_ref_row = tmp_ref;
148 for (k = 0; k < 8; k ++) {
149 for (l = 0; l < 8; l ++) {
150 int32_t diff = WELS_ABS (tmp_cur_row[l] - tmp_ref_row[l]);
151 l_sad += diff;
152 l_sum += tmp_cur_row[l];
153 l_sqsum += tmp_cur_row[l] * tmp_cur_row[l];
154 }
155 tmp_cur_row += iPicStride;
156 tmp_ref_row += iPicStride;
157 }
158 *pFrameSad += l_sad;
159 pSad8x8[ (mb_index << 2) + 0] = l_sad;
160 pSum16x16[mb_index] += l_sum;
161 psqsum16x16[mb_index] += l_sqsum;
162
163 l_sad = l_sum = l_sqsum = 0;
164 tmp_cur_row = tmp_cur + 8;
165 tmp_ref_row = tmp_ref + 8;
166 for (k = 0; k < 8; k ++) {
167 for (l = 0; l < 8; l ++) {
168 int32_t diff = WELS_ABS (tmp_cur_row[l] - tmp_ref_row[l]);
169 l_sad += diff;
170 l_sum += tmp_cur_row[l];
171 l_sqsum += tmp_cur_row[l] * tmp_cur_row[l];
172 }
173 tmp_cur_row += iPicStride;
174 tmp_ref_row += iPicStride;
175 }
176 *pFrameSad += l_sad;
177 pSad8x8[ (mb_index << 2) + 1] = l_sad;
178 pSum16x16[mb_index] += l_sum;
179 psqsum16x16[mb_index] += l_sqsum;
180
181 l_sad = l_sum = l_sqsum = 0;
182 tmp_cur_row = tmp_cur + pic_stride_x8;
183 tmp_ref_row = tmp_ref + pic_stride_x8;
184 for (k = 0; k < 8; k ++) {
185 for (l = 0; l < 8; l ++) {
186 int32_t diff = WELS_ABS (tmp_cur_row[l] - tmp_ref_row[l]);
187 l_sad += diff;
188 l_sum += tmp_cur_row[l];
189 l_sqsum += tmp_cur_row[l] * tmp_cur_row[l];
190 }
191 tmp_cur_row += iPicStride;
192 tmp_ref_row += iPicStride;
193 }
194 *pFrameSad += l_sad;
195 pSad8x8[ (mb_index << 2) + 2] = l_sad;
196 pSum16x16[mb_index] += l_sum;
197 psqsum16x16[mb_index] += l_sqsum;
198
199 l_sad = l_sum = l_sqsum = 0;
200 tmp_cur_row = tmp_cur + pic_stride_x8 + 8;
201 tmp_ref_row = tmp_ref + pic_stride_x8 + 8;
202 for (k = 0; k < 8; k ++) {
203 for (l = 0; l < 8; l ++) {
204 int32_t diff = WELS_ABS (tmp_cur_row[l] - tmp_ref_row[l]);
205 l_sad += diff;
206 l_sum += tmp_cur_row[l];
207 l_sqsum += tmp_cur_row[l] * tmp_cur_row[l];
208 }
209 tmp_cur_row += iPicStride;
210 tmp_ref_row += iPicStride;
211 }
212 *pFrameSad += l_sad;
213 pSad8x8[ (mb_index << 2) + 3] = l_sad;
214 pSum16x16[mb_index] += l_sum;
215 psqsum16x16[mb_index] += l_sqsum;
216
217
218 tmp_ref += 16;
219 tmp_cur += 16;
220 ++mb_index;
221 }
222 tmp_ref += step;
223 tmp_cur += step;
224 }
225}
226
227void VAACalcSad_ref (const uint8_t* pCurData, const uint8_t* pRefData, int32_t iPicWidth, int32_t iPicHeight,
228 int32_t iPicStride,
229 int32_t* pFrameSad, int32_t* pSad8x8) {
230 const uint8_t* tmp_ref = pRefData;
231 const uint8_t* tmp_cur = pCurData;
232 int32_t iMbWidth = (iPicWidth >> 4);
233 int32_t mb_height = (iPicHeight >> 4);
234 int32_t mb_index = 0;
235 int32_t pic_stride_x8 = iPicStride << 3;
236 int32_t step = (iPicStride << 4) - iPicWidth;
237
238 *pFrameSad = 0;
239 for (int32_t i = 0; i < mb_height; i ++) {
240 for (int32_t j = 0; j < iMbWidth; j ++) {
241 int32_t k, l;
242 int32_t l_sad;
243 const uint8_t* tmp_cur_row;
244 const uint8_t* tmp_ref_row;
245
246 l_sad = 0;
247 tmp_cur_row = tmp_cur;
248 tmp_ref_row = tmp_ref;
249 for (k = 0; k < 8; k ++) {
250 for (l = 0; l < 8; l ++) {
251 int32_t diff = WELS_ABS (tmp_cur_row[l] - tmp_ref_row[l]);
252 l_sad += diff;
253 }
254 tmp_cur_row += iPicStride;
255 tmp_ref_row += iPicStride;
256 }
257 *pFrameSad += l_sad;
258 pSad8x8[ (mb_index << 2) + 0] = l_sad;
259
260 l_sad = 0;
261 tmp_cur_row = tmp_cur + 8;
262 tmp_ref_row = tmp_ref + 8;
263 for (k = 0; k < 8; k ++) {
264 for (l = 0; l < 8; l ++) {
265 int32_t diff = WELS_ABS (tmp_cur_row[l] - tmp_ref_row[l]);
266 l_sad += diff;
267 }
268 tmp_cur_row += iPicStride;
269 tmp_ref_row += iPicStride;
270 }
271 *pFrameSad += l_sad;
272 pSad8x8[ (mb_index << 2) + 1] = l_sad;
273
274 l_sad = 0;
275 tmp_cur_row = tmp_cur + pic_stride_x8;
276 tmp_ref_row = tmp_ref + pic_stride_x8;
277 for (k = 0; k < 8; k ++) {
278 for (l = 0; l < 8; l ++) {
279 int32_t diff = WELS_ABS (tmp_cur_row[l] - tmp_ref_row[l]);
280 l_sad += diff;
281 }
282 tmp_cur_row += iPicStride;
283 tmp_ref_row += iPicStride;
284 }
285 *pFrameSad += l_sad;
286 pSad8x8[ (mb_index << 2) + 2] = l_sad;
287
288 l_sad = 0;
289 tmp_cur_row = tmp_cur + pic_stride_x8 + 8;
290 tmp_ref_row = tmp_ref + pic_stride_x8 + 8;
291 for (k = 0; k < 8; k ++) {
292 for (l = 0; l < 8; l ++) {
293 int32_t diff = WELS_ABS (tmp_cur_row[l] - tmp_ref_row[l]);
294 l_sad += diff;
295 }
296 tmp_cur_row += iPicStride;
297 tmp_ref_row += iPicStride;
298 }
299 *pFrameSad += l_sad;
300 pSad8x8[ (mb_index << 2) + 3] = l_sad;
301
302 tmp_ref += 16;
303 tmp_cur += 16;
304 ++mb_index;
305 }
306 tmp_ref += step;
307 tmp_cur += step;
308 }
309}
310
311void VAACalcSadSsdBgd_ref (const uint8_t* pCurData, const uint8_t* pRefData, int32_t iPicWidth, int32_t iPicHeight,
312 int32_t iPicStride,
313 int32_t* pFrameSad, int32_t* pSad8x8, int32_t* pSum16x16, int32_t* psqsum16x16, int32_t* psqdiff16x16, int32_t* pSd8x8,
314 uint8_t* pMad8x8) {
315 const uint8_t* tmp_ref = pRefData;
316 const uint8_t* tmp_cur = pCurData;
317 int32_t iMbWidth = (iPicWidth >> 4);
318 int32_t mb_height = (iPicHeight >> 4);
319 int32_t mb_index = 0;
320 int32_t pic_stride_x8 = iPicStride << 3;
321 int32_t step = (iPicStride << 4) - iPicWidth;
322
323 *pFrameSad = 0;
324 for (int32_t i = 0; i < mb_height; i ++) {
325 for (int32_t j = 0; j < iMbWidth; j ++) {
326 int32_t k, l;
327 int32_t l_sad, l_sqdiff, l_sum, l_sqsum, l_sd, l_mad;
328 const uint8_t* tmp_cur_row;
329 const uint8_t* tmp_ref_row;
330
331 pSum16x16[mb_index] = 0;
332 psqsum16x16[mb_index] = 0;
333 psqdiff16x16[mb_index] = 0;
334
335 l_sd = l_mad = l_sad = l_sqdiff = l_sum = l_sqsum = 0;
336 tmp_cur_row = tmp_cur;
337 tmp_ref_row = tmp_ref;
338 for (k = 0; k < 8; k ++) {
339 for (l = 0; l < 8; l ++) {
340 int32_t diff = tmp_cur_row[l] - tmp_ref_row[l];
341 int32_t abs_diff = WELS_ABS (diff);
342
343 l_sd += diff;
344 if (abs_diff > l_mad) {
345 l_mad = abs_diff;
346 }
347 l_sad += abs_diff;
348 l_sqdiff += abs_diff * abs_diff;
349 l_sum += tmp_cur_row[l];
350 l_sqsum += tmp_cur_row[l] * tmp_cur_row[l];
351 }
352 tmp_cur_row += iPicStride;
353 tmp_ref_row += iPicStride;
354 }
355 *pFrameSad += l_sad;
356 pSad8x8[ (mb_index << 2) + 0] = l_sad;
357 pSum16x16[mb_index] += l_sum;
358 psqsum16x16[mb_index] += l_sqsum;
359 psqdiff16x16[mb_index] += l_sqdiff;
360 pSd8x8[ (mb_index << 2) + 0] = l_sd;
361 pMad8x8[ (mb_index << 2) + 0] = l_mad;
362
363
364 l_sd = l_mad = l_sad = l_sqdiff = l_sum = l_sqsum = 0;
365 tmp_cur_row = tmp_cur + 8;
366 tmp_ref_row = tmp_ref + 8;
367 for (k = 0; k < 8; k ++) {
368 for (l = 0; l < 8; l ++) {
369 int32_t diff = tmp_cur_row[l] - tmp_ref_row[l];
370 int32_t abs_diff = WELS_ABS (diff);
371
372 l_sd += diff;
373 if (abs_diff > l_mad) {
374 l_mad = abs_diff;
375 }
376 l_sad += abs_diff;
377 l_sqdiff += abs_diff * abs_diff;
378 l_sum += tmp_cur_row[l];
379 l_sqsum += tmp_cur_row[l] * tmp_cur_row[l];
380 }
381 tmp_cur_row += iPicStride;
382 tmp_ref_row += iPicStride;
383 }
384 *pFrameSad += l_sad;
385 pSad8x8[ (mb_index << 2) + 1] = l_sad;
386 pSum16x16[mb_index] += l_sum;
387 psqsum16x16[mb_index] += l_sqsum;
388 psqdiff16x16[mb_index] += l_sqdiff;
389 pSd8x8[ (mb_index << 2) + 1] = l_sd;
390 pMad8x8[ (mb_index << 2) + 1] = l_mad;
391
392 l_sd = l_mad = l_sad = l_sqdiff = l_sum = l_sqsum = 0;
393 tmp_cur_row = tmp_cur + pic_stride_x8;
394 tmp_ref_row = tmp_ref + pic_stride_x8;
395 for (k = 0; k < 8; k ++) {
396 for (l = 0; l < 8; l ++) {
397 int32_t diff = tmp_cur_row[l] - tmp_ref_row[l];
398 int32_t abs_diff = WELS_ABS (diff);
399
400 l_sd += diff;
401 if (abs_diff > l_mad) {
402 l_mad = abs_diff;
403 }
404 l_sad += abs_diff;
405 l_sqdiff += abs_diff * abs_diff;
406 l_sum += tmp_cur_row[l];
407 l_sqsum += tmp_cur_row[l] * tmp_cur_row[l];
408 }
409 tmp_cur_row += iPicStride;
410 tmp_ref_row += iPicStride;
411 }
412 *pFrameSad += l_sad;
413 pSad8x8[ (mb_index << 2) + 2] = l_sad;
414 pSum16x16[mb_index] += l_sum;
415 psqsum16x16[mb_index] += l_sqsum;
416 psqdiff16x16[mb_index] += l_sqdiff;
417 pSd8x8[ (mb_index << 2) + 2] = l_sd;
418 pMad8x8[ (mb_index << 2) + 2] = l_mad;
419
420 l_sd = l_mad = l_sad = l_sqdiff = l_sum = l_sqsum = 0;
421 tmp_cur_row = tmp_cur + pic_stride_x8 + 8;
422 tmp_ref_row = tmp_ref + pic_stride_x8 + 8;
423 for (k = 0; k < 8; k ++) {
424 for (l = 0; l < 8; l ++) {
425 int32_t diff = tmp_cur_row[l] - tmp_ref_row[l];
426 int32_t abs_diff = WELS_ABS (diff);
427
428 l_sd += diff;
429 if (abs_diff > l_mad) {
430 l_mad = abs_diff;
431 }
432 l_sad += abs_diff;
433 l_sqdiff += abs_diff * abs_diff;
434 l_sum += tmp_cur_row[l];
435 l_sqsum += tmp_cur_row[l] * tmp_cur_row[l];
436 }
437 tmp_cur_row += iPicStride;
438 tmp_ref_row += iPicStride;
439 }
440 *pFrameSad += l_sad;
441 pSad8x8[ (mb_index << 2) + 3] = l_sad;
442 pSum16x16[mb_index] += l_sum;
443 psqsum16x16[mb_index] += l_sqsum;
444 psqdiff16x16[mb_index] += l_sqdiff;
445 pSd8x8[ (mb_index << 2) + 3] = l_sd;
446 pMad8x8[ (mb_index << 2) + 3] = l_mad;
447
448 tmp_ref += 16;
449 tmp_cur += 16;
450 ++mb_index;
451 }
452 tmp_ref += step;
453 tmp_cur += step;
454 }
455}
456
457void VAACalcSadBgd_ref (const uint8_t* pCurData, const uint8_t* pRefData, int32_t iPicWidth, int32_t iPicHeight,
458 int32_t iPicStride,
459 int32_t* pFrameSad, int32_t* pSad8x8, int32_t* pSd8x8, uint8_t* pMad8x8) {
460 const uint8_t* tmp_ref = pRefData;
461 const uint8_t* tmp_cur = pCurData;
462 int32_t iMbWidth = (iPicWidth >> 4);
463 int32_t mb_height = (iPicHeight >> 4);
464 int32_t mb_index = 0;
465 int32_t pic_stride_x8 = iPicStride << 3;
466 int32_t step = (iPicStride << 4) - iPicWidth;
467
468 *pFrameSad = 0;
469 for (int32_t i = 0; i < mb_height; i ++) {
470 for (int32_t j = 0; j < iMbWidth; j ++) {
471 int32_t k, l;
472 int32_t l_sad, l_sd, l_mad;
473 const uint8_t* tmp_cur_row;
474 const uint8_t* tmp_ref_row;
475
476 l_mad = l_sd = l_sad = 0;
477 tmp_cur_row = tmp_cur;
478 tmp_ref_row = tmp_ref;
479 for (k = 0; k < 8; k ++) {
480 for (l = 0; l < 8; l ++) {
481 int32_t diff = tmp_cur_row[l] - tmp_ref_row[l];
482 int32_t abs_diff = WELS_ABS (diff);
483 l_sd += diff;
484 l_sad += abs_diff;
485 if (abs_diff > l_mad) {
486 l_mad = abs_diff;
487 }
488 }
489 tmp_cur_row += iPicStride;
490 tmp_ref_row += iPicStride;
491 }
492 *pFrameSad += l_sad;
493 pSad8x8[ (mb_index << 2) + 0] = l_sad;
494 pSd8x8[ (mb_index << 2) + 0] = l_sd;
495 pMad8x8[ (mb_index << 2) + 0] = l_mad;
496
497 l_mad = l_sd = l_sad = 0;
498 tmp_cur_row = tmp_cur + 8;
499 tmp_ref_row = tmp_ref + 8;
500 for (k = 0; k < 8; k ++) {
501 for (l = 0; l < 8; l ++) {
502 int32_t diff = tmp_cur_row[l] - tmp_ref_row[l];
503 int32_t abs_diff = WELS_ABS (diff);
504 l_sd += diff;
505 l_sad += abs_diff;
506 if (abs_diff > l_mad) {
507 l_mad = abs_diff;
508 }
509 }
510 tmp_cur_row += iPicStride;
511 tmp_ref_row += iPicStride;
512 }
513 *pFrameSad += l_sad;
514 pSad8x8[ (mb_index << 2) + 1] = l_sad;
515 pSd8x8[ (mb_index << 2) + 1] = l_sd;
516 pMad8x8[ (mb_index << 2) + 1] = l_mad;
517
518 l_mad = l_sd = l_sad = 0;
519 tmp_cur_row = tmp_cur + pic_stride_x8;
520 tmp_ref_row = tmp_ref + pic_stride_x8;
521 for (k = 0; k < 8; k ++) {
522 for (l = 0; l < 8; l ++) {
523 int32_t diff = tmp_cur_row[l] - tmp_ref_row[l];
524 int32_t abs_diff = WELS_ABS (diff);
525 l_sd += diff;
526 l_sad += abs_diff;
527 if (abs_diff > l_mad) {
528 l_mad = abs_diff;
529 }
530 }
531 tmp_cur_row += iPicStride;
532 tmp_ref_row += iPicStride;
533 }
534 *pFrameSad += l_sad;
535 pSad8x8[ (mb_index << 2) + 2] = l_sad;
536 pSd8x8[ (mb_index << 2) + 2] = l_sd;
537 pMad8x8[ (mb_index << 2) + 2] = l_mad;
538
539 l_mad = l_sd = l_sad = 0;
540 tmp_cur_row = tmp_cur + pic_stride_x8 + 8;
541 tmp_ref_row = tmp_ref + pic_stride_x8 + 8;
542 for (k = 0; k < 8; k ++) {
543 for (l = 0; l < 8; l ++) {
544 int32_t diff = tmp_cur_row[l] - tmp_ref_row[l];
545 int32_t abs_diff = WELS_ABS (diff);
546 l_sd += diff;
547 l_sad += abs_diff;
548 if (abs_diff > l_mad) {
549 l_mad = abs_diff;
550 }
551 }
552 tmp_cur_row += iPicStride;
553 tmp_ref_row += iPicStride;
554 }
555 *pFrameSad += l_sad;
556 pSad8x8[ (mb_index << 2) + 3] = l_sad;
557 pSd8x8[ (mb_index << 2) + 3] = l_sd;
558 pMad8x8[ (mb_index << 2) + 3] = l_mad;
559
560 tmp_ref += 16;
561 tmp_cur += 16;
562 ++mb_index;
563 }
564 tmp_ref += step;
565 tmp_cur += step;
566 }
567}
568
569#define BUFFER_SIZE (320*320)
570
571#define GENERATE_VAACalcSad_UT(func, ASM, CPUFLAGS) \
572TEST (VAACalcFuncTest, func) { \
573 if (ASM) {\
574 int32_t iCpuCores = 0; \
575 uint32_t m_uiCpuFeatureFlag = WelsCPUFeatureDetect (&iCpuCores); \
576 if (0 == (m_uiCpuFeatureFlag & CPUFLAGS)) \
577 return; \
578 } \
579 ENFORCE_STACK_ALIGN_1D (uint8_t, cur_data_c, BUFFER_SIZE, 16); \
580 ENFORCE_STACK_ALIGN_1D (uint8_t, ref_data_c, BUFFER_SIZE, 16); \
581 ENFORCE_STACK_ALIGN_1D (int32_t, psad8x8_c, BUFFER_SIZE/64, 16); \
582 int32_t pic_width_c; \
583 int32_t pic_height_c; \
584 int32_t pic_stride_c; \
585 int32_t psadframe_c; \
586 ENFORCE_STACK_ALIGN_1D (uint8_t, cur_data_a, BUFFER_SIZE, 16); \
587 ENFORCE_STACK_ALIGN_1D (uint8_t, ref_data_a, BUFFER_SIZE, 16); \
588 ENFORCE_STACK_ALIGN_1D (int32_t, psad8x8_a, BUFFER_SIZE/64, 16); \
589 int32_t pic_width_a; \
590 int32_t pic_height_a; \
591 int32_t pic_stride_a; \
592 int32_t psadframe_a; \
593 pic_width_c = pic_width_a = 320-16; \
594 pic_height_c = pic_height_a = 320; \
595 pic_stride_c = pic_stride_a = 320; \
596 psadframe_c = psadframe_a = 0; \
597 for (int j=0; j<BUFFER_SIZE; j++) { \
598 cur_data_c[j] = cur_data_a[j] = (rand()%256); \
599 ref_data_c[j] = ref_data_a[j] = (rand()%256); \
600 psad8x8_c[j%(BUFFER_SIZE/64)] = psad8x8_a[j%(BUFFER_SIZE/64)] = (rand()%256); \
601 } \
602 VAACalcSad_ref (cur_data_c, ref_data_c, pic_width_c, pic_height_c, pic_stride_c, &psadframe_c, psad8x8_c); \
603 func (cur_data_a, ref_data_a, pic_width_a, pic_height_a, pic_stride_a, &psadframe_a, psad8x8_a); \
604 ASSERT_EQ (psadframe_a, psadframe_c); \
605 for (int j=0; j<(BUFFER_SIZE/64); j++) \
606 ASSERT_EQ (psad8x8_a[j], psad8x8_c[j]); \
607}
608
609
610#define GENERATE_VAACalcSadBgd_UT(func, ASM, CPUFLAGS) \
611TEST (VAACalcFuncTest, func) { \
612 if (ASM) {\
613 int32_t iCpuCores = 0; \
614 uint32_t m_uiCpuFeatureFlag = WelsCPUFeatureDetect (&iCpuCores); \
615 if (0 == (m_uiCpuFeatureFlag & CPUFLAGS)) \
616 return; \
617 } \
618 ENFORCE_STACK_ALIGN_1D (uint8_t, cur_data_c, BUFFER_SIZE, 16); \
619 ENFORCE_STACK_ALIGN_1D (uint8_t, ref_data_c, BUFFER_SIZE, 16); \
620 ENFORCE_STACK_ALIGN_1D (int32_t, psad8x8_c, BUFFER_SIZE/64, 16); \
621 ENFORCE_STACK_ALIGN_1D (int32_t, psd8x8_c, BUFFER_SIZE/64, 16); \
622 ENFORCE_STACK_ALIGN_1D (uint8_t, pmad8x8_c, BUFFER_SIZE/64, 16); \
623 int32_t pic_width_c; \
624 int32_t pic_height_c; \
625 int32_t pic_stride_c; \
626 int32_t psadframe_c; \
627 ENFORCE_STACK_ALIGN_1D (uint8_t, cur_data_a, BUFFER_SIZE, 16); \
628 ENFORCE_STACK_ALIGN_1D (uint8_t, ref_data_a, BUFFER_SIZE, 16); \
629 ENFORCE_STACK_ALIGN_1D (int32_t, psad8x8_a, BUFFER_SIZE/64, 16); \
630 ENFORCE_STACK_ALIGN_1D (int32_t, psd8x8_a, BUFFER_SIZE/64, 16); \
631 ENFORCE_STACK_ALIGN_1D (uint8_t, pmad8x8_a, BUFFER_SIZE/64, 16); \
632 int32_t pic_width_a; \
633 int32_t pic_height_a; \
634 int32_t pic_stride_a; \
635 int32_t psadframe_a; \
636 pic_width_c = pic_width_a = 320-16; \
637 pic_height_c = pic_height_a = 320; \
638 pic_stride_c = pic_stride_a = 320; \
639 psadframe_c = psadframe_a = 0; \
640 for (int j=0; j<BUFFER_SIZE; j++) { \
641 cur_data_c[j] = cur_data_a[j] = (rand()%256); \
642 ref_data_c[j] = ref_data_a[j] = (rand()%256); \
643 psad8x8_c[j%(BUFFER_SIZE/64)] = psad8x8_a[j%(BUFFER_SIZE/64)] = (rand()%256); \
644 psd8x8_c[j%(BUFFER_SIZE/64)] = psd8x8_a[j%(BUFFER_SIZE/64)] = (rand()%256); \
645 pmad8x8_c[j%(BUFFER_SIZE/64)] = pmad8x8_a[j%(BUFFER_SIZE/64)] = (rand()%256); \
646 } \
647 VAACalcSadBgd_ref (cur_data_c, ref_data_c, pic_width_c, pic_height_c, pic_stride_c, &psadframe_c, psad8x8_c, psd8x8_c, pmad8x8_c); \
648 func (cur_data_a, ref_data_a, pic_width_a, pic_height_a, pic_stride_a, &psadframe_a, psad8x8_a, psd8x8_a, pmad8x8_a); \
649 ASSERT_EQ (psadframe_a, psadframe_c); \
650 for (int j=0; j<(BUFFER_SIZE/64); j++) {\
651 ASSERT_EQ (psad8x8_a[j], psad8x8_c[j]); \
652 ASSERT_EQ (psd8x8_a[j], psd8x8_c[j]); \
653 ASSERT_EQ (pmad8x8_a[j], pmad8x8_c[j]); \
654 } \
655}
656
657#define GENERATE_VAACalcSadSsd_UT(func, ASM, CPUFLAGS) \
658TEST (VAACalcFuncTest, func) { \
659 if (ASM) {\
660 int32_t iCpuCores = 0; \
661 uint32_t m_uiCpuFeatureFlag = WelsCPUFeatureDetect (&iCpuCores); \
662 if (0 == (m_uiCpuFeatureFlag & CPUFLAGS)) \
663 return; \
664 } \
665 ENFORCE_STACK_ALIGN_1D (uint8_t, cur_data_c, BUFFER_SIZE, 16); \
666 ENFORCE_STACK_ALIGN_1D (uint8_t, ref_data_c, BUFFER_SIZE, 16); \
667 ENFORCE_STACK_ALIGN_1D (int32_t, psad8x8_c, BUFFER_SIZE/64, 16); \
668 ENFORCE_STACK_ALIGN_1D (int32_t, psum16x16_c, BUFFER_SIZE/256, 16); \
669 ENFORCE_STACK_ALIGN_1D (int32_t, psqsum16x16_c, BUFFER_SIZE/256, 16); \
670 ENFORCE_STACK_ALIGN_1D (int32_t, psqdiff16x16_c, BUFFER_SIZE/256, 16); \
671 int32_t pic_width_c; \
672 int32_t pic_height_c; \
673 int32_t pic_stride_c; \
674 int32_t psadframe_c; \
675 ENFORCE_STACK_ALIGN_1D (uint8_t, cur_data_a, BUFFER_SIZE, 16); \
676 ENFORCE_STACK_ALIGN_1D (uint8_t, ref_data_a, BUFFER_SIZE, 16); \
677 ENFORCE_STACK_ALIGN_1D (int32_t, psad8x8_a, BUFFER_SIZE/64, 16); \
678 ENFORCE_STACK_ALIGN_1D (int32_t, psum16x16_a, BUFFER_SIZE/256, 16); \
679 ENFORCE_STACK_ALIGN_1D (int32_t, psqsum16x16_a, BUFFER_SIZE/256, 16); \
680 ENFORCE_STACK_ALIGN_1D (int32_t, psqdiff16x16_a, BUFFER_SIZE/256, 16); \
681 int32_t pic_width_a; \
682 int32_t pic_height_a; \
683 int32_t pic_stride_a; \
684 int32_t psadframe_a; \
685 pic_width_c = pic_width_a = 320-16; \
686 pic_height_c = pic_height_a = 320; \
687 pic_stride_c = pic_stride_a = 320; \
688 psadframe_c = psadframe_a = 0; \
689 for (int j=0; j<BUFFER_SIZE; j++) { \
690 cur_data_c[j] = cur_data_a[j] = (rand()%256); \
691 ref_data_c[j] = ref_data_a[j] = (rand()%256); \
692 psad8x8_c[j%(BUFFER_SIZE/64)] = psad8x8_a[j%(BUFFER_SIZE/64)] = (rand()%256); \
693 psum16x16_c[j%(BUFFER_SIZE/256)] = psum16x16_a[j%(BUFFER_SIZE/256)] = (rand()%256); \
694 psqsum16x16_c[j%(BUFFER_SIZE/256)] = psqsum16x16_a[j%(BUFFER_SIZE/256)] = (rand()%256); \
695 psqdiff16x16_c[j%(BUFFER_SIZE/256)] = psqdiff16x16_a[j%(BUFFER_SIZE/256)] = (rand()%256); \
696 } \
697 VAACalcSadSsd_ref (cur_data_c, ref_data_c, pic_width_c, pic_height_c, pic_stride_c, &psadframe_c, psad8x8_c, psum16x16_c, psqsum16x16_c, psqdiff16x16_c); \
698 func (cur_data_a, ref_data_a, pic_width_a, pic_height_a, pic_stride_a, &psadframe_a, psad8x8_a, psum16x16_a, psqsum16x16_a, psqdiff16x16_a); \
699 ASSERT_EQ (psadframe_a, psadframe_c); \
700 for (int j=0; j<(BUFFER_SIZE/64); j++) {\
701 ASSERT_EQ (psad8x8_a[j], psad8x8_c[j]); \
702 } \
703 for (int j=0; j<(BUFFER_SIZE/256); j++) {\
704 ASSERT_EQ (psum16x16_a[j], psum16x16_c[j]); \
705 ASSERT_EQ (psqsum16x16_a[j], psqsum16x16_c[j]); \
706 ASSERT_EQ (psqdiff16x16_a[j], psqdiff16x16_c[j]); \
707 } \
708}
709
710#define GENERATE_VAACalcSadVar_UT(func, ASM, CPUFLAGS) \
711TEST (VAACalcFuncTest, func) { \
712 if (ASM) {\
713 int32_t iCpuCores = 0; \
714 uint32_t m_uiCpuFeatureFlag = WelsCPUFeatureDetect (&iCpuCores); \
715 if (0 == (m_uiCpuFeatureFlag & CPUFLAGS)) \
716 return; \
717 } \
718 ENFORCE_STACK_ALIGN_1D (uint8_t, cur_data_c, BUFFER_SIZE, 16); \
719 ENFORCE_STACK_ALIGN_1D (uint8_t, ref_data_c, BUFFER_SIZE, 16); \
720 ENFORCE_STACK_ALIGN_1D (int32_t, psad8x8_c, BUFFER_SIZE/64, 16); \
721 ENFORCE_STACK_ALIGN_1D (int32_t, psum16x16_c, BUFFER_SIZE/256, 16); \
722 ENFORCE_STACK_ALIGN_1D (int32_t, psqsum16x16_c, BUFFER_SIZE/256, 16); \
723 int32_t pic_width_c; \
724 int32_t pic_height_c; \
725 int32_t pic_stride_c; \
726 int32_t psadframe_c; \
727 ENFORCE_STACK_ALIGN_1D (uint8_t, cur_data_a, BUFFER_SIZE, 16); \
728 ENFORCE_STACK_ALIGN_1D (uint8_t, ref_data_a, BUFFER_SIZE, 16); \
729 ENFORCE_STACK_ALIGN_1D (int32_t, psad8x8_a, BUFFER_SIZE/64, 16); \
730 ENFORCE_STACK_ALIGN_1D (int32_t, psum16x16_a, BUFFER_SIZE/256, 16); \
731 ENFORCE_STACK_ALIGN_1D (int32_t, psqsum16x16_a, BUFFER_SIZE/256, 16); \
732 int32_t pic_width_a; \
733 int32_t pic_height_a; \
734 int32_t pic_stride_a; \
735 int32_t psadframe_a; \
736 pic_width_c = pic_width_a = 320-16; \
737 pic_height_c = pic_height_a = 320; \
738 pic_stride_c = pic_stride_a = 320; \
739 psadframe_c = psadframe_a = 0; \
740 for (int j=0; j<BUFFER_SIZE; j++) { \
741 cur_data_c[j] = cur_data_a[j] = (rand()%256); \
742 ref_data_c[j] = ref_data_a[j] = (rand()%256); \
743 psad8x8_c[j%(BUFFER_SIZE/64)] = psad8x8_a[j%(BUFFER_SIZE/64)] = (rand()%256); \
744 psum16x16_c[j%(BUFFER_SIZE/256)] = psum16x16_a[j%(BUFFER_SIZE/256)] = (rand()%256); \
745 psqsum16x16_c[j%(BUFFER_SIZE/256)] = psqsum16x16_a[j%(BUFFER_SIZE/256)] = (rand()%256); \
746 } \
747 VAACalcSadVar_ref (cur_data_c, ref_data_c, pic_width_c, pic_height_c, pic_stride_c, &psadframe_c, psad8x8_c, psum16x16_c, psqsum16x16_c); \
748 func (cur_data_a, ref_data_a, pic_width_a, pic_height_a, pic_stride_a, &psadframe_a, psad8x8_a, psum16x16_a, psqsum16x16_a); \
749 ASSERT_EQ (psadframe_a, psadframe_c); \
750 for (int j=0; j<(BUFFER_SIZE/64); j++) {\
751 ASSERT_EQ (psad8x8_a[j], psad8x8_c[j]); \
752 } \
753 for (int j=0; j<(BUFFER_SIZE/256); j++) {\
754 ASSERT_EQ (psum16x16_a[j], psum16x16_c[j]); \
755 ASSERT_EQ (psqsum16x16_a[j], psqsum16x16_c[j]); \
756 } \
757}
758
759#define GENERATE_VAACalcSadSsdBgd_UT(func, ASM, CPUFLAGS) \
760TEST (VAACalcFuncTest, func) { \
761 if (ASM) {\
762 int32_t iCpuCores = 0; \
763 uint32_t m_uiCpuFeatureFlag = WelsCPUFeatureDetect (&iCpuCores); \
764 if (0 == (m_uiCpuFeatureFlag & CPUFLAGS)) \
765 return; \
766 } \
767 ENFORCE_STACK_ALIGN_1D (uint8_t, cur_data_c, BUFFER_SIZE, 16); \
768 ENFORCE_STACK_ALIGN_1D (uint8_t, ref_data_c, BUFFER_SIZE, 16); \
769 ENFORCE_STACK_ALIGN_1D (int32_t, psad8x8_c, BUFFER_SIZE/64, 16); \
770 ENFORCE_STACK_ALIGN_1D (int32_t, psd8x8_c, BUFFER_SIZE/64, 16); \
771 ENFORCE_STACK_ALIGN_1D (uint8_t, pmad8x8_c, BUFFER_SIZE/64, 16); \
772 ENFORCE_STACK_ALIGN_1D (int32_t, psum16x16_c, BUFFER_SIZE/256, 16); \
773 ENFORCE_STACK_ALIGN_1D (int32_t, psqsum16x16_c, BUFFER_SIZE/256, 16); \
774 ENFORCE_STACK_ALIGN_1D (int32_t, psqdiff16x16_c, BUFFER_SIZE/256, 16); \
775 int32_t pic_width_c; \
776 int32_t pic_height_c; \
777 int32_t pic_stride_c; \
778 int32_t psadframe_c; \
779 ENFORCE_STACK_ALIGN_1D (uint8_t, cur_data_a, BUFFER_SIZE, 16); \
780 ENFORCE_STACK_ALIGN_1D (uint8_t, ref_data_a, BUFFER_SIZE, 16); \
781 ENFORCE_STACK_ALIGN_1D (int32_t, psad8x8_a, BUFFER_SIZE/64, 16); \
782 ENFORCE_STACK_ALIGN_1D (int32_t, psd8x8_a, BUFFER_SIZE/64, 16); \
783 ENFORCE_STACK_ALIGN_1D (uint8_t, pmad8x8_a, BUFFER_SIZE/64, 16); \
784 ENFORCE_STACK_ALIGN_1D (int32_t, psum16x16_a, BUFFER_SIZE/256, 16); \
785 ENFORCE_STACK_ALIGN_1D (int32_t, psqsum16x16_a, BUFFER_SIZE/256, 16); \
786 ENFORCE_STACK_ALIGN_1D (int32_t, psqdiff16x16_a, BUFFER_SIZE/256, 16); \
787 int32_t pic_width_a; \
788 int32_t pic_height_a; \
789 int32_t pic_stride_a; \
790 int32_t psadframe_a; \
791 pic_width_c = pic_width_a = 320-16; \
792 pic_height_c = pic_height_a = 320; \
793 pic_stride_c = pic_stride_a = 320; \
794 psadframe_c = psadframe_a = 0; \
795 for (int j=0; j<BUFFER_SIZE; j++) { \
796 cur_data_c[j] = cur_data_a[j] = (rand()%256); \
797 ref_data_c[j] = ref_data_a[j] = (rand()%256); \
798 psad8x8_c[j%(BUFFER_SIZE/64)] = psad8x8_a[j%(BUFFER_SIZE/64)] = (rand()%256); \
799 psd8x8_c[j%(BUFFER_SIZE/64)] = psd8x8_a[j%(BUFFER_SIZE/64)] = (rand()%256); \
800 pmad8x8_c[j%(BUFFER_SIZE/64)] = pmad8x8_a[j%(BUFFER_SIZE/64)] = (rand()%256); \
801 psum16x16_c[j%(BUFFER_SIZE/256)] = psum16x16_a[j%(BUFFER_SIZE/256)] = (rand()%256); \
802 psqsum16x16_c[j%(BUFFER_SIZE/256)] = psqsum16x16_a[j%(BUFFER_SIZE/256)] = (rand()%256); \
803 psqdiff16x16_c[j%(BUFFER_SIZE/256)] = psqdiff16x16_a[j%(BUFFER_SIZE/256)] = (rand()%256); \
804 } \
805 VAACalcSadSsdBgd_ref (cur_data_c, ref_data_c, pic_width_c, pic_height_c, pic_stride_c, &psadframe_c, psad8x8_c, psum16x16_c, psqsum16x16_c, psqdiff16x16_c, psd8x8_c, pmad8x8_c); \
806 func (cur_data_a, ref_data_a, pic_width_a, pic_height_a, pic_stride_a, &psadframe_a, psad8x8_a, psum16x16_a, psqsum16x16_a, psqdiff16x16_a, psd8x8_a, pmad8x8_a); \
807 ASSERT_EQ (psadframe_a, psadframe_c); \
808 for (int j=0; j<(BUFFER_SIZE/64); j++) {\
809 ASSERT_EQ (psad8x8_a[j], psad8x8_c[j]); \
810 ASSERT_EQ (psd8x8_a[j], psd8x8_c[j]); \
811 ASSERT_EQ (pmad8x8_a[j], pmad8x8_c[j]); \
812 } \
813 for (int j=0; j<(BUFFER_SIZE/256); j++) {\
814 ASSERT_EQ (psum16x16_a[j], psum16x16_c[j]); \
815 ASSERT_EQ (psqsum16x16_a[j], psqsum16x16_c[j]); \
816 ASSERT_EQ (psqdiff16x16_a[j], psqdiff16x16_c[j]); \
817 } \
818}
819
820GENERATE_VAACalcSad_UT (VAACalcSad_c, 0, 0)
821GENERATE_VAACalcSadBgd_UT (VAACalcSadBgd_c, 0, 0)
822GENERATE_VAACalcSadSsdBgd_UT (VAACalcSadSsdBgd_c, 0, 0)
823GENERATE_VAACalcSadSsd_UT (VAACalcSadSsd_c, 0, 0)
824GENERATE_VAACalcSadVar_UT (VAACalcSadVar_c, 0, 0)
825#if defined(X86_ASM)
826GENERATE_VAACalcSad_UT (VAACalcSad_sse2, 1, WELS_CPU_SSE2)
827GENERATE_VAACalcSadBgd_UT (VAACalcSadBgd_sse2, 1, WELS_CPU_SSE2)
828GENERATE_VAACalcSadSsdBgd_UT (VAACalcSadSsdBgd_sse2, 1, WELS_CPU_SSE2)
829GENERATE_VAACalcSadSsd_UT (VAACalcSadSsd_sse2, 1, WELS_CPU_SSE2)
830GENERATE_VAACalcSadVar_UT (VAACalcSadVar_sse2, 1, WELS_CPU_SSE2)
831#endif
832
833#if defined(HAVE_NEON)
834GENERATE_VAACalcSad_UT (VAACalcSad_neon, 1, WELS_CPU_NEON)
835GENERATE_VAACalcSadBgd_UT (VAACalcSadBgd_neon, 1, WELS_CPU_NEON)
836GENERATE_VAACalcSadSsdBgd_UT (VAACalcSadSsdBgd_neon, 1, WELS_CPU_NEON)
837GENERATE_VAACalcSadSsd_UT (VAACalcSadSsd_neon, 1, WELS_CPU_NEON)
838GENERATE_VAACalcSadVar_UT (VAACalcSadVar_neon, 1, WELS_CPU_NEON)
839#endif
840
841#if defined(HAVE_NEON_AARCH64)
842GENERATE_VAACalcSad_UT (VAACalcSad_AArch64_neon, 1, WELS_CPU_NEON)
843GENERATE_VAACalcSadBgd_UT (VAACalcSadBgd_AArch64_neon, 1, WELS_CPU_NEON)
844GENERATE_VAACalcSadSsdBgd_UT (VAACalcSadSsdBgd_AArch64_neon, 1, WELS_CPU_NEON)
845GENERATE_VAACalcSadSsd_UT (VAACalcSadSsd_AArch64_neon, 1, WELS_CPU_NEON)
846GENERATE_VAACalcSadVar_UT (VAACalcSadVar_AArch64_neon, 1, WELS_CPU_NEON)
847#endif

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