Line | Branch | Exec | Source |
---|---|---|---|
1 | /* | ||
2 | * (c) 2001 Fabrice Bellard | ||
3 | * 2007 Marc Hoffman <marc.hoffman@analog.com> | ||
4 | * | ||
5 | * This file is part of FFmpeg. | ||
6 | * | ||
7 | * FFmpeg is free software; you can redistribute it and/or | ||
8 | * modify it under the terms of the GNU Lesser General Public | ||
9 | * License as published by the Free Software Foundation; either | ||
10 | * version 2.1 of the License, or (at your option) any later version. | ||
11 | * | ||
12 | * FFmpeg is distributed in the hope that it will be useful, | ||
13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
15 | * Lesser General Public License for more details. | ||
16 | * | ||
17 | * You should have received a copy of the GNU Lesser General Public | ||
18 | * License along with FFmpeg; if not, write to the Free Software | ||
19 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | ||
20 | */ | ||
21 | |||
22 | /** | ||
23 | * @file | ||
24 | * DCT test (c) 2001 Fabrice Bellard | ||
25 | * Started from sample code by Juan J. Sierralta P. | ||
26 | */ | ||
27 | |||
28 | #include "config.h" | ||
29 | #include "config_components.h" | ||
30 | #include <stdlib.h> | ||
31 | #include <stdio.h> | ||
32 | #include <string.h> | ||
33 | #if HAVE_UNISTD_H | ||
34 | #include <unistd.h> | ||
35 | #endif | ||
36 | #include <math.h> | ||
37 | |||
38 | #include "libavutil/cpu.h" | ||
39 | #include "libavutil/common.h" | ||
40 | #include "libavutil/emms.h" | ||
41 | #include "libavutil/internal.h" | ||
42 | #include "libavutil/lfg.h" | ||
43 | #include "libavutil/mem_internal.h" | ||
44 | #include "libavutil/time.h" | ||
45 | |||
46 | #include "libavcodec/dct.h" | ||
47 | #include "libavcodec/fdctdsp.h" | ||
48 | #include "libavcodec/idctdsp.h" | ||
49 | #include "libavcodec/simple_idct.h" | ||
50 | #include "libavcodec/xvididct.h" | ||
51 | #include "libavcodec/aandcttab.h" | ||
52 | #include "libavcodec/faandct.h" | ||
53 | #include "libavcodec/faanidct.h" | ||
54 | #include "libavcodec/dctref.h" | ||
55 | #if CONFIG_PRORES_DECODER | ||
56 | #include "libavcodec/proresdsp.c" | ||
57 | #endif | ||
58 | |||
59 | struct algo { | ||
60 | const char *name; | ||
61 | void (*func)(int16_t *block); | ||
62 | enum idct_permutation_type perm_type; | ||
63 | int cpu_flag; | ||
64 | int nonspec; | ||
65 | }; | ||
66 | |||
67 | static const struct algo fdct_tab[] = { | ||
68 | { "REF-DBL", ff_ref_fdct, FF_IDCT_PERM_NONE }, | ||
69 | { "IJG-AAN-INT", ff_fdct_ifast, FF_IDCT_PERM_NONE }, | ||
70 | { "IJG-LLM-INT", ff_jpeg_fdct_islow_8, FF_IDCT_PERM_NONE }, | ||
71 | #if CONFIG_FAANDCT | ||
72 | { "FAAN", ff_faandct, FF_IDCT_PERM_NONE }, | ||
73 | #endif /* CONFIG_FAANDCT */ | ||
74 | }; | ||
75 | |||
76 | #if CONFIG_PRORES_DECODER | ||
77 | 60000 | static void ff_prores_idct_wrap(int16_t *dst){ | |
78 | 60000 | LOCAL_ALIGNED(16, int16_t, qmat, [64]); | |
79 | int i; | ||
80 | |||
81 |
2/2✓ Branch 0 taken 3840000 times.
✓ Branch 1 taken 60000 times.
|
3900000 | for(i=0; i<64; i++){ |
82 | 3840000 | qmat[i]=4; | |
83 | } | ||
84 | 60000 | prores_idct_10(dst, qmat); | |
85 |
2/2✓ Branch 0 taken 3840000 times.
✓ Branch 1 taken 60000 times.
|
3900000 | for(i=0; i<64; i++) { |
86 | 3840000 | dst[i] -= 512; | |
87 | } | ||
88 | 60000 | } | |
89 | #endif | ||
90 | |||
91 | static const struct algo idct_tab[] = { | ||
92 | { "REF-DBL", ff_ref_idct, FF_IDCT_PERM_NONE }, | ||
93 | { "INT", ff_j_rev_dct, FF_IDCT_PERM_LIBMPEG2 }, | ||
94 | { "SIMPLE-C", ff_simple_idct_int16_8bit, FF_IDCT_PERM_NONE }, | ||
95 | { "SIMPLE-C10", ff_simple_idct_int16_10bit, FF_IDCT_PERM_NONE }, | ||
96 | { "SIMPLE-C12", ff_simple_idct_int16_12bit, FF_IDCT_PERM_NONE, 0, 1 }, | ||
97 | #if CONFIG_PRORES_DECODER | ||
98 | { "PR-C", ff_prores_idct_wrap, FF_IDCT_PERM_NONE, 0, 1 }, | ||
99 | #endif | ||
100 | #if CONFIG_FAANIDCT | ||
101 | { "FAANI", ff_faanidct, FF_IDCT_PERM_NONE }, | ||
102 | #endif /* CONFIG_FAANIDCT */ | ||
103 | #if CONFIG_MPEG4_DECODER | ||
104 | { "XVID", ff_xvid_idct, FF_IDCT_PERM_NONE, 0, 1 }, | ||
105 | #endif /* CONFIG_MPEG4_DECODER */ | ||
106 | }; | ||
107 | |||
108 | #if ARCH_AARCH64 | ||
109 | #include "aarch64/dct.c" | ||
110 | #elif ARCH_ARM | ||
111 | #include "arm/dct.c" | ||
112 | #elif ARCH_PPC | ||
113 | #include "ppc/dct.c" | ||
114 | #elif ARCH_X86 | ||
115 | #include "x86/dct.c" | ||
116 | #else | ||
117 | static const struct algo fdct_tab_arch[] = { { 0 } }; | ||
118 | static const struct algo idct_tab_arch[] = { { 0 } }; | ||
119 | #endif | ||
120 | |||
121 | #define AANSCALE_BITS 12 | ||
122 | |||
123 | #define NB_ITS 20000 | ||
124 | #define NB_ITS_SPEED 50000 | ||
125 | |||
126 | DECLARE_ALIGNED(16, static int16_t, block)[64]; | ||
127 | DECLARE_ALIGNED(8, static int16_t, block1)[64]; | ||
128 | |||
129 | 1120000 | static void init_block(int16_t block[64], int test, int is_idct, AVLFG *prng, int vals) | |
130 | { | ||
131 | int i, j; | ||
132 | |||
133 | 1120000 | memset(block, 0, 64 * sizeof(*block)); | |
134 | |||
135 |
3/4✓ Branch 0 taken 340000 times.
✓ Branch 1 taken 440000 times.
✓ Branch 2 taken 340000 times.
✗ Branch 3 not taken.
|
1120000 | switch (test) { |
136 | 340000 | case 0: | |
137 |
2/2✓ Branch 0 taken 21760000 times.
✓ Branch 1 taken 340000 times.
|
22100000 | for (i = 0; i < 64; i++) |
138 | 21760000 | block[i] = (av_lfg_get(prng) % (2*vals)) -vals; | |
139 |
1/2✓ Branch 0 taken 340000 times.
✗ Branch 1 not taken.
|
340000 | if (is_idct) { |
140 | 340000 | ff_ref_fdct(block); | |
141 |
2/2✓ Branch 0 taken 21760000 times.
✓ Branch 1 taken 340000 times.
|
22100000 | for (i = 0; i < 64; i++) |
142 | 21760000 | block[i] >>= 3; | |
143 | } | ||
144 | 340000 | break; | |
145 | 440000 | case 1: | |
146 | 440000 | j = av_lfg_get(prng) % 10 + 1; | |
147 |
2/2✓ Branch 0 taken 2413686 times.
✓ Branch 1 taken 440000 times.
|
2853686 | for (i = 0; i < j; i++) { |
148 | 2413686 | int idx = av_lfg_get(prng) % 64; | |
149 | 2413686 | block[idx] = av_lfg_get(prng) % (2*vals) -vals; | |
150 | } | ||
151 | 440000 | break; | |
152 | 340000 | case 2: | |
153 | 340000 | block[ 0] = av_lfg_get(prng) % (16*vals) - (8*vals); | |
154 | 340000 | block[63] = (block[0] & 1) ^ 1; | |
155 | 340000 | break; | |
156 | } | ||
157 | 1120000 | } | |
158 | |||
159 | 1120000 | static void permute(int16_t dst[64], const int16_t src[64], | |
160 | enum idct_permutation_type perm_type) | ||
161 | { | ||
162 | int i; | ||
163 | |||
164 | #if ARCH_X86 | ||
165 |
2/2✓ Branch 1 taken 60000 times.
✓ Branch 2 taken 1060000 times.
|
1120000 | if (permute_x86(dst, src, perm_type)) |
166 | 60000 | return; | |
167 | #endif | ||
168 | |||
169 |
3/4✓ Branch 0 taken 60000 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 480000 times.
✓ Branch 3 taken 520000 times.
|
1060000 | switch (perm_type) { |
170 | 60000 | case FF_IDCT_PERM_LIBMPEG2: | |
171 |
2/2✓ Branch 0 taken 3840000 times.
✓ Branch 1 taken 60000 times.
|
3900000 | for (i = 0; i < 64; i++) |
172 | 3840000 | dst[(i & 0x38) | ((i & 6) >> 1) | ((i & 1) << 2)] = src[i]; | |
173 | 60000 | break; | |
174 | ✗ | case FF_IDCT_PERM_PARTTRANS: | |
175 | ✗ | for (i = 0; i < 64; i++) | |
176 | ✗ | dst[(i & 0x24) | ((i & 3) << 3) | ((i >> 3) & 3)] = src[i]; | |
177 | ✗ | break; | |
178 | 480000 | case FF_IDCT_PERM_TRANSPOSE: | |
179 |
2/2✓ Branch 0 taken 30720000 times.
✓ Branch 1 taken 480000 times.
|
31200000 | for (i = 0; i < 64; i++) |
180 | 30720000 | dst[(i>>3) | ((i<<3)&0x38)] = src[i]; | |
181 | 480000 | break; | |
182 | 520000 | default: | |
183 |
2/2✓ Branch 0 taken 33280000 times.
✓ Branch 1 taken 520000 times.
|
33800000 | for (i = 0; i < 64; i++) |
184 | 33280000 | dst[i] = src[i]; | |
185 | 520000 | break; | |
186 | } | ||
187 | } | ||
188 | |||
189 | 56 | static int dct_error(const struct algo *dct, int test, int is_idct, int speed, const int bits) | |
190 | { | ||
191 |
2/2✓ Branch 0 taken 51 times.
✓ Branch 1 taken 5 times.
|
56 | void (*ref)(int16_t *block) = is_idct ? ff_ref_idct : ff_ref_fdct; |
192 | int it, i, scale; | ||
193 | int err_inf, v; | ||
194 | 56 | int64_t err2, ti, ti1, it1, err_sum = 0; | |
195 | 56 | int64_t sysErr[64], sysErrMax = 0; | |
196 | 56 | int64_t err2_matrix[64], err2_max = 0; | |
197 | 56 | int maxout = 0; | |
198 | 56 | int blockSumErrMax = 0, blockSumErr; | |
199 | AVLFG prng; | ||
200 | 56 | const int vals=1<<bits; | |
201 | double omse, ome; | ||
202 | int spec_err; | ||
203 | |||
204 | 56 | av_lfg_init(&prng, 1); | |
205 | |||
206 | 56 | err_inf = 0; | |
207 | 56 | err2 = 0; | |
208 |
2/2✓ Branch 0 taken 3584 times.
✓ Branch 1 taken 56 times.
|
3640 | for (i = 0; i < 64; i++) |
209 | 3584 | err2_matrix[i] = sysErr[i] = 0; | |
210 |
2/2✓ Branch 0 taken 1120000 times.
✓ Branch 1 taken 56 times.
|
1120056 | for (it = 0; it < NB_ITS; it++) { |
211 | 1120000 | init_block(block1, test, is_idct, &prng, vals); | |
212 | 1120000 | permute(block, block1, dct->perm_type); | |
213 | |||
214 | 1120000 | dct->func(block); | |
215 | 1120000 | emms_c(); | |
216 | |||
217 |
2/2✓ Branch 0 taken 20000 times.
✓ Branch 1 taken 1100000 times.
|
1120000 | if (!strcmp(dct->name, "IJG-AAN-INT")) { |
218 |
2/2✓ Branch 0 taken 1280000 times.
✓ Branch 1 taken 20000 times.
|
1300000 | for (i = 0; i < 64; i++) { |
219 | 1280000 | scale = 8 * (1 << (AANSCALE_BITS + 11)) / ff_aanscales[i]; | |
220 | 1280000 | block[i] = (block[i] * scale) >> AANSCALE_BITS; | |
221 | } | ||
222 | } | ||
223 | |||
224 | 1120000 | ref(block1); | |
225 |
2/2✓ Branch 0 taken 60000 times.
✓ Branch 1 taken 1060000 times.
|
1120000 | if (!strcmp(dct->name, "PR-SSE2")) |
226 |
2/2✓ Branch 0 taken 3840000 times.
✓ Branch 1 taken 60000 times.
|
3900000 | for (i = 0; i < 64; i++) |
227 | 3840000 | block1[i] = av_clip(block1[i], 4-512, 1019-512); | |
228 | |||
229 | 1120000 | blockSumErr = 0; | |
230 |
2/2✓ Branch 0 taken 71680000 times.
✓ Branch 1 taken 1120000 times.
|
72800000 | for (i = 0; i < 64; i++) { |
231 | 71680000 | int err = block[i] - block1[i]; | |
232 | 71680000 | err_sum += err; | |
233 | 71680000 | v = abs(err); | |
234 |
2/2✓ Branch 0 taken 61 times.
✓ Branch 1 taken 71679939 times.
|
71680000 | if (v > err_inf) |
235 | 61 | err_inf = v; | |
236 | 71680000 | err2_matrix[i] += v * (int64_t)v; | |
237 | 71680000 | err2 += v * (int64_t)v; | |
238 | 71680000 | sysErr[i] += block[i] - block1[i]; | |
239 | 71680000 | blockSumErr += v; | |
240 |
2/2✓ Branch 0 taken 756 times.
✓ Branch 1 taken 71679244 times.
|
71680000 | if (abs(block[i]) > maxout) |
241 | 756 | maxout = abs(block[i]); | |
242 | } | ||
243 |
2/2✓ Branch 0 taken 246 times.
✓ Branch 1 taken 1119754 times.
|
1120000 | if (blockSumErrMax < blockSumErr) |
244 | 246 | blockSumErrMax = blockSumErr; | |
245 | } | ||
246 |
2/2✓ Branch 0 taken 3584 times.
✓ Branch 1 taken 56 times.
|
3640 | for (i = 0; i < 64; i++) { |
247 | 3584 | sysErrMax = FFMAX(sysErrMax, FFABS(sysErr[i])); | |
248 | 3584 | err2_max = FFMAX(err2_max , FFABS(err2_matrix[i])); | |
249 | } | ||
250 | |||
251 |
2/2✓ Branch 0 taken 3584 times.
✓ Branch 1 taken 56 times.
|
3640 | for (i = 0; i < 64; i++) { |
252 |
2/2✓ Branch 0 taken 448 times.
✓ Branch 1 taken 3136 times.
|
3584 | if (i % 8 == 0) |
253 | 448 | printf("\n"); | |
254 | 3584 | printf("%7d ", (int) sysErr[i]); | |
255 | } | ||
256 | 56 | printf("\n"); | |
257 | |||
258 | 56 | omse = (double) err2 / NB_ITS / 64; | |
259 | 56 | ome = (double) err_sum / NB_ITS / 64; | |
260 | |||
261 |
7/8✓ Branch 0 taken 51 times.
✓ Branch 1 taken 5 times.
✓ Branch 2 taken 51 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 36 times.
✓ Branch 5 taken 15 times.
✓ Branch 6 taken 4 times.
✓ Branch 7 taken 32 times.
|
56 | spec_err = is_idct && (err_inf > 1 || omse > 0.02 || fabs(ome) > 0.0015); |
262 |
2/2✓ Branch 0 taken 39 times.
✓ Branch 1 taken 17 times.
|
56 | if (test < 2) |
263 |
6/6✓ Branch 0 taken 34 times.
✓ Branch 1 taken 5 times.
✓ Branch 2 taken 28 times.
✓ Branch 3 taken 6 times.
✓ Branch 4 taken 2 times.
✓ Branch 5 taken 26 times.
|
39 | spec_err = is_idct && ((double) err2_max / NB_ITS > 0.06 || (double) sysErrMax / NB_ITS > 0.015); |
264 | |||
265 | 56 | printf("%s %s: max_err=%d omse=%0.8f ome=%0.8f syserr=%0.8f maxout=%d blockSumErr=%d\n", | |
266 | 56 | is_idct ? "IDCT" : "DCT", dct->name, err_inf, | |
267 |
2/2✓ Branch 0 taken 51 times.
✓ Branch 1 taken 5 times.
|
56 | omse, ome, (double) sysErrMax / NB_ITS, |
268 | maxout, blockSumErrMax); | ||
269 | |||
270 |
3/4✓ Branch 0 taken 13 times.
✓ Branch 1 taken 43 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 13 times.
|
56 | if (spec_err && !dct->nonspec) { |
271 | ✗ | printf("Failed!\n"); | |
272 | ✗ | return 1; | |
273 | } | ||
274 | |||
275 |
1/2✓ Branch 0 taken 56 times.
✗ Branch 1 not taken.
|
56 | if (!speed) |
276 | 56 | return 0; | |
277 | |||
278 | /* speed test */ | ||
279 | |||
280 | ✗ | init_block(block, test, is_idct, &prng, vals); | |
281 | ✗ | permute(block1, block, dct->perm_type); | |
282 | |||
283 | ✗ | ti = av_gettime_relative(); | |
284 | ✗ | it1 = 0; | |
285 | do { | ||
286 | ✗ | for (it = 0; it < NB_ITS_SPEED; it++) { | |
287 | ✗ | memcpy(block, block1, sizeof(block)); | |
288 | ✗ | dct->func(block); | |
289 | } | ||
290 | ✗ | emms_c(); | |
291 | ✗ | it1 += NB_ITS_SPEED; | |
292 | ✗ | ti1 = av_gettime_relative() - ti; | |
293 | ✗ | } while (ti1 < 1000000); | |
294 | |||
295 | ✗ | printf("%s %s: %0.1f kdct/s\n", is_idct ? "IDCT" : "DCT", dct->name, | |
296 | ✗ | (double) it1 * 1000.0 / (double) ti1); | |
297 | |||
298 | ✗ | return 0; | |
299 | } | ||
300 | |||
301 | DECLARE_ALIGNED(8, static uint8_t, img_dest)[64]; | ||
302 | DECLARE_ALIGNED(8, static uint8_t, img_dest1)[64]; | ||
303 | |||
304 | 20000 | static void idct248_ref(uint8_t *dest, ptrdiff_t linesize, int16_t *block) | |
305 | { | ||
306 | static int init; | ||
307 | static double c8[8][8]; | ||
308 | static double c4[4][4]; | ||
309 | double block1[64], block2[64], block3[64]; | ||
310 | double s, sum, v; | ||
311 | int i, j, k; | ||
312 | |||
313 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 19999 times.
|
20000 | if (!init) { |
314 | 1 | init = 1; | |
315 | |||
316 |
2/2✓ Branch 0 taken 8 times.
✓ Branch 1 taken 1 times.
|
9 | for (i = 0; i < 8; i++) { |
317 | 8 | sum = 0; | |
318 |
2/2✓ Branch 0 taken 64 times.
✓ Branch 1 taken 8 times.
|
72 | for (j = 0; j < 8; j++) { |
319 |
2/2✓ Branch 0 taken 8 times.
✓ Branch 1 taken 56 times.
|
64 | s = (i == 0) ? sqrt(1.0 / 8.0) : sqrt(1.0 / 4.0); |
320 | 64 | c8[i][j] = s * cos(M_PI * i * (j + 0.5) / 8.0); | |
321 | 64 | sum += c8[i][j] * c8[i][j]; | |
322 | } | ||
323 | } | ||
324 | |||
325 |
2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 1 times.
|
5 | for (i = 0; i < 4; i++) { |
326 | 4 | sum = 0; | |
327 |
2/2✓ Branch 0 taken 16 times.
✓ Branch 1 taken 4 times.
|
20 | for (j = 0; j < 4; j++) { |
328 |
2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 12 times.
|
16 | s = (i == 0) ? sqrt(1.0 / 4.0) : sqrt(1.0 / 2.0); |
329 | 16 | c4[i][j] = s * cos(M_PI * i * (j + 0.5) / 4.0); | |
330 | 16 | sum += c4[i][j] * c4[i][j]; | |
331 | } | ||
332 | } | ||
333 | } | ||
334 | |||
335 | /* butterfly */ | ||
336 | 20000 | s = 0.5 * sqrt(2.0); | |
337 |
2/2✓ Branch 0 taken 80000 times.
✓ Branch 1 taken 20000 times.
|
100000 | for (i = 0; i < 4; i++) { |
338 |
2/2✓ Branch 0 taken 640000 times.
✓ Branch 1 taken 80000 times.
|
720000 | for (j = 0; j < 8; j++) { |
339 | 640000 | block1[8 * (2 * i) + j] = | |
340 | 640000 | (block[8 * (2 * i) + j] + block[8 * (2 * i + 1) + j]) * s; | |
341 | 640000 | block1[8 * (2 * i + 1) + j] = | |
342 | 640000 | (block[8 * (2 * i) + j] - block[8 * (2 * i + 1) + j]) * s; | |
343 | } | ||
344 | } | ||
345 | |||
346 | /* idct8 on lines */ | ||
347 |
2/2✓ Branch 0 taken 160000 times.
✓ Branch 1 taken 20000 times.
|
180000 | for (i = 0; i < 8; i++) { |
348 |
2/2✓ Branch 0 taken 1280000 times.
✓ Branch 1 taken 160000 times.
|
1440000 | for (j = 0; j < 8; j++) { |
349 | 1280000 | sum = 0; | |
350 |
2/2✓ Branch 0 taken 10240000 times.
✓ Branch 1 taken 1280000 times.
|
11520000 | for (k = 0; k < 8; k++) |
351 | 10240000 | sum += c8[k][j] * block1[8 * i + k]; | |
352 | 1280000 | block2[8 * i + j] = sum; | |
353 | } | ||
354 | } | ||
355 | |||
356 | /* idct4 */ | ||
357 |
2/2✓ Branch 0 taken 160000 times.
✓ Branch 1 taken 20000 times.
|
180000 | for (i = 0; i < 8; i++) { |
358 |
2/2✓ Branch 0 taken 640000 times.
✓ Branch 1 taken 160000 times.
|
800000 | for (j = 0; j < 4; j++) { |
359 | /* top */ | ||
360 | 640000 | sum = 0; | |
361 |
2/2✓ Branch 0 taken 2560000 times.
✓ Branch 1 taken 640000 times.
|
3200000 | for (k = 0; k < 4; k++) |
362 | 2560000 | sum += c4[k][j] * block2[8 * (2 * k) + i]; | |
363 | 640000 | block3[8 * (2 * j) + i] = sum; | |
364 | |||
365 | /* bottom */ | ||
366 | 640000 | sum = 0; | |
367 |
2/2✓ Branch 0 taken 2560000 times.
✓ Branch 1 taken 640000 times.
|
3200000 | for (k = 0; k < 4; k++) |
368 | 2560000 | sum += c4[k][j] * block2[8 * (2 * k + 1) + i]; | |
369 | 640000 | block3[8 * (2 * j + 1) + i] = sum; | |
370 | } | ||
371 | } | ||
372 | |||
373 | /* clamp and store the result */ | ||
374 |
2/2✓ Branch 0 taken 160000 times.
✓ Branch 1 taken 20000 times.
|
180000 | for (i = 0; i < 8; i++) { |
375 |
2/2✓ Branch 0 taken 1280000 times.
✓ Branch 1 taken 160000 times.
|
1440000 | for (j = 0; j < 8; j++) { |
376 | 1280000 | v = block3[8 * i + j]; | |
377 |
2/2✓ Branch 0 taken 53473 times.
✓ Branch 1 taken 1226527 times.
|
1280000 | if (v < 0) v = 0; |
378 |
2/2✓ Branch 0 taken 54705 times.
✓ Branch 1 taken 1171822 times.
|
1226527 | else if (v > 255) v = 255; |
379 | 1280000 | dest[i * linesize + j] = (int) rint(v); | |
380 | } | ||
381 | } | ||
382 | 20000 | } | |
383 | |||
384 | 1 | static void idct248_error(const char *name, | |
385 | void (*idct248_put)(uint8_t *dest, | ||
386 | ptrdiff_t line_size, | ||
387 | int16_t *block), | ||
388 | int speed) | ||
389 | { | ||
390 | int it, i, it1, ti, ti1, err_max, v; | ||
391 | AVLFG prng; | ||
392 | |||
393 | 1 | av_lfg_init(&prng, 1); | |
394 | |||
395 | /* just one test to see if code is correct (precision is less | ||
396 | important here) */ | ||
397 | 1 | err_max = 0; | |
398 |
2/2✓ Branch 0 taken 20000 times.
✓ Branch 1 taken 1 times.
|
20001 | for (it = 0; it < NB_ITS; it++) { |
399 | /* XXX: use forward transform to generate values */ | ||
400 |
2/2✓ Branch 0 taken 1280000 times.
✓ Branch 1 taken 20000 times.
|
1300000 | for (i = 0; i < 64; i++) |
401 | 1280000 | block1[i] = av_lfg_get(&prng) % 256 - 128; | |
402 | 20000 | block1[0] += 1024; | |
403 | |||
404 |
2/2✓ Branch 0 taken 1280000 times.
✓ Branch 1 taken 20000 times.
|
1300000 | for (i = 0; i < 64; i++) |
405 | 1280000 | block[i] = block1[i]; | |
406 | 20000 | idct248_ref(img_dest1, 8, block); | |
407 | |||
408 |
2/2✓ Branch 0 taken 1280000 times.
✓ Branch 1 taken 20000 times.
|
1300000 | for (i = 0; i < 64; i++) |
409 | 1280000 | block[i] = block1[i]; | |
410 | 20000 | idct248_put(img_dest, 8, block); | |
411 | |||
412 |
2/2✓ Branch 0 taken 1280000 times.
✓ Branch 1 taken 20000 times.
|
1300000 | for (i = 0; i < 64; i++) { |
413 | 1280000 | v = abs((int) img_dest[i] - (int) img_dest1[i]); | |
414 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1280000 times.
|
1280000 | if (v == 255) |
415 | ✗ | printf("%d %d\n", img_dest[i], img_dest1[i]); | |
416 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1279999 times.
|
1280000 | if (v > err_max) |
417 | 1 | err_max = v; | |
418 | } | ||
419 | #if 0 | ||
420 | printf("ref=\n"); | ||
421 | for(i=0;i<8;i++) { | ||
422 | int j; | ||
423 | for(j=0;j<8;j++) { | ||
424 | printf(" %3d", img_dest1[i*8+j]); | ||
425 | } | ||
426 | printf("\n"); | ||
427 | } | ||
428 | |||
429 | printf("out=\n"); | ||
430 | for(i=0;i<8;i++) { | ||
431 | int j; | ||
432 | for(j=0;j<8;j++) { | ||
433 | printf(" %3d", img_dest[i*8+j]); | ||
434 | } | ||
435 | printf("\n"); | ||
436 | } | ||
437 | #endif | ||
438 | } | ||
439 | 1 | printf("%s %s: err_inf=%d\n", 1 ? "IDCT248" : "DCT248", name, err_max); | |
440 | |||
441 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | if (!speed) |
442 | 1 | return; | |
443 | |||
444 | ✗ | ti = av_gettime_relative(); | |
445 | ✗ | it1 = 0; | |
446 | do { | ||
447 | ✗ | for (it = 0; it < NB_ITS_SPEED; it++) { | |
448 | ✗ | for (i = 0; i < 64; i++) | |
449 | ✗ | block[i] = block1[i]; | |
450 | ✗ | idct248_put(img_dest, 8, block); | |
451 | } | ||
452 | ✗ | emms_c(); | |
453 | ✗ | it1 += NB_ITS_SPEED; | |
454 | ✗ | ti1 = av_gettime_relative() - ti; | |
455 | ✗ | } while (ti1 < 1000000); | |
456 | |||
457 | ✗ | printf("%s %s: %0.1f kdct/s\n", 1 ? "IDCT248" : "DCT248", name, | |
458 | ✗ | (double) it1 * 1000.0 / (double) ti1); | |
459 | } | ||
460 | |||
461 | ✗ | static void help(void) | |
462 | { | ||
463 | ✗ | printf("dct-test [-i] [<test-number>] [<bits>]\n" | |
464 | "test-number 0 -> test with random matrixes\n" | ||
465 | " 1 -> test with random sparse matrixes\n" | ||
466 | " 2 -> do 3. test from MPEG-4 std\n" | ||
467 | "bits Number of time domain bits to use, 8 is default\n" | ||
468 | "-i test IDCT implementations\n" | ||
469 | "-4 test IDCT248 implementations\n" | ||
470 | "-t speed test\n"); | ||
471 | ✗ | } | |
472 | |||
473 | #if !HAVE_GETOPT | ||
474 | #include "compat/getopt.c" | ||
475 | #endif | ||
476 | |||
477 | 5 | int main(int argc, char **argv) | |
478 | { | ||
479 | 5 | int test_idct = 0, test_248_dct = 0; | |
480 | int c, i; | ||
481 | 5 | int test = 1; | |
482 | 5 | int speed = 0; | |
483 | 5 | int err = 0; | |
484 | 5 | int bits=8; | |
485 | |||
486 | 5 | ff_ref_dct_init(); | |
487 | |||
488 | for (;;) { | ||
489 | 9 | c = getopt(argc, argv, "ih4t"); | |
490 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 4 times.
|
9 | if (c == -1) |
491 | 5 | break; | |
492 |
2/4✓ Branch 0 taken 3 times.
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
4 | switch (c) { |
493 | 3 | case 'i': | |
494 | 3 | test_idct = 1; | |
495 | 3 | break; | |
496 | 1 | case '4': | |
497 | 1 | test_248_dct = 1; | |
498 | 1 | break; | |
499 | ✗ | case 't': | |
500 | ✗ | speed = 1; | |
501 | ✗ | break; | |
502 | ✗ | default: | |
503 | case 'h': | ||
504 | ✗ | help(); | |
505 | ✗ | return 0; | |
506 | } | ||
507 | } | ||
508 | |||
509 |
2/2✓ Branch 0 taken 3 times.
✓ Branch 1 taken 2 times.
|
5 | if (optind < argc) |
510 | 3 | test = atoi(argv[optind]); | |
511 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 5 times.
|
5 | if(optind+1 < argc) bits= atoi(argv[optind+1]); |
512 | |||
513 | 5 | printf("ffmpeg DCT/IDCT test\n"); | |
514 | |||
515 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 4 times.
|
5 | if (test_248_dct) { |
516 | 1 | idct248_error("SIMPLE-C", ff_simple_idct248_put, speed); | |
517 | } else { | ||
518 | 4 | const int cpu_flags = av_get_cpu_flags(); | |
519 |
2/2✓ Branch 0 taken 3 times.
✓ Branch 1 taken 1 times.
|
4 | if (test_idct) { |
520 |
2/2✓ Branch 0 taken 24 times.
✓ Branch 1 taken 3 times.
|
27 | for (i = 0; i < FF_ARRAY_ELEMS(idct_tab); i++) |
521 | 24 | err |= dct_error(&idct_tab[i], test, test_idct, speed, bits); | |
522 | |||
523 |
2/2✓ Branch 0 taken 27 times.
✓ Branch 1 taken 3 times.
|
30 | for (i = 0; idct_tab_arch[i].name; i++) |
524 |
1/2✓ Branch 0 taken 27 times.
✗ Branch 1 not taken.
|
27 | if (!(~cpu_flags & idct_tab_arch[i].cpu_flag)) |
525 | 27 | err |= dct_error(&idct_tab_arch[i], test, test_idct, speed, bits); | |
526 | } | ||
527 | #if CONFIG_FDCTDSP | ||
528 | else { | ||
529 |
2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 1 times.
|
5 | for (i = 0; i < FF_ARRAY_ELEMS(fdct_tab); i++) |
530 | 4 | err |= dct_error(&fdct_tab[i], test, test_idct, speed, bits); | |
531 | |||
532 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1 times.
|
2 | for (i = 0; fdct_tab_arch[i].name; i++) |
533 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | if (!(~cpu_flags & fdct_tab_arch[i].cpu_flag)) |
534 | 1 | err |= dct_error(&fdct_tab_arch[i], test, test_idct, speed, bits); | |
535 | } | ||
536 | #endif /* CONFIG_FDCTDSP */ | ||
537 | } | ||
538 | |||
539 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 5 times.
|
5 | if (err) |
540 | ✗ | printf("Error: %d.\n", err); | |
541 | |||
542 | 5 | return !!err; | |
543 | } | ||
544 |