Commit | Line | Data |
---|---|---|
2ba45a60 DM |
1 | /* |
2 | * This file is part of FFmpeg. | |
3 | * | |
4 | * FFmpeg is free software; you can redistribute it and/or | |
5 | * modify it under the terms of the GNU Lesser General Public | |
6 | * License as published by the Free Software Foundation; either | |
7 | * version 2.1 of the License, or (at your option) any later version. | |
8 | * | |
9 | * FFmpeg is distributed in the hope that it will be useful, | |
10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
12 | * Lesser General Public License for more details. | |
13 | * | |
14 | * You should have received a copy of the GNU Lesser General Public | |
15 | * License along with FFmpeg; if not, write to the Free Software | |
16 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | |
17 | */ | |
18 | ||
19 | #include <stdint.h> | |
20 | ||
21 | #include "cpu.h" | |
22 | #include "cpu_internal.h" | |
23 | #include "config.h" | |
24 | #include "opt.h" | |
25 | #include "common.h" | |
26 | ||
27 | #if HAVE_SCHED_GETAFFINITY | |
28 | #ifndef _GNU_SOURCE | |
29 | # define _GNU_SOURCE | |
30 | #endif | |
31 | #include <sched.h> | |
32 | #endif | |
33 | #if HAVE_GETPROCESSAFFINITYMASK | |
34 | #include <windows.h> | |
35 | #endif | |
36 | #if HAVE_SYSCTL | |
37 | #if HAVE_SYS_PARAM_H | |
38 | #include <sys/param.h> | |
39 | #endif | |
40 | #include <sys/types.h> | |
41 | #include <sys/sysctl.h> | |
42 | #endif | |
43 | #if HAVE_UNISTD_H | |
44 | #include <unistd.h> | |
45 | #endif | |
46 | ||
47 | static int flags, checked; | |
48 | ||
49 | void av_force_cpu_flags(int arg){ | |
50 | if ( (arg & ( AV_CPU_FLAG_3DNOW | | |
51 | AV_CPU_FLAG_3DNOWEXT | | |
52 | AV_CPU_FLAG_SSE | | |
53 | AV_CPU_FLAG_SSE2 | | |
54 | AV_CPU_FLAG_SSE2SLOW | | |
55 | AV_CPU_FLAG_SSE3 | | |
56 | AV_CPU_FLAG_SSE3SLOW | | |
57 | AV_CPU_FLAG_SSSE3 | | |
58 | AV_CPU_FLAG_SSE4 | | |
59 | AV_CPU_FLAG_SSE42 | | |
60 | AV_CPU_FLAG_AVX | | |
61 | AV_CPU_FLAG_XOP | | |
62 | AV_CPU_FLAG_FMA3 | | |
63 | AV_CPU_FLAG_FMA4 | | |
64 | AV_CPU_FLAG_AVX2 )) | |
65 | && !(arg & AV_CPU_FLAG_MMX)) { | |
66 | av_log(NULL, AV_LOG_WARNING, "MMX implied by specified flags\n"); | |
67 | arg |= AV_CPU_FLAG_MMX; | |
68 | } | |
69 | ||
70 | flags = arg; | |
71 | checked = arg != -1; | |
72 | } | |
73 | ||
74 | int av_get_cpu_flags(void) | |
75 | { | |
76 | if (checked) | |
77 | return flags; | |
78 | ||
79 | if (ARCH_AARCH64) | |
80 | flags = ff_get_cpu_flags_aarch64(); | |
81 | if (ARCH_ARM) | |
82 | flags = ff_get_cpu_flags_arm(); | |
83 | if (ARCH_PPC) | |
84 | flags = ff_get_cpu_flags_ppc(); | |
85 | if (ARCH_X86) | |
86 | flags = ff_get_cpu_flags_x86(); | |
87 | ||
88 | checked = 1; | |
89 | return flags; | |
90 | } | |
91 | ||
92 | void av_set_cpu_flags_mask(int mask) | |
93 | { | |
94 | checked = 0; | |
95 | flags = av_get_cpu_flags() & mask; | |
96 | checked = 1; | |
97 | } | |
98 | ||
99 | int av_parse_cpu_flags(const char *s) | |
100 | { | |
101 | #define CPUFLAG_MMXEXT (AV_CPU_FLAG_MMX | AV_CPU_FLAG_MMXEXT | AV_CPU_FLAG_CMOV) | |
102 | #define CPUFLAG_3DNOW (AV_CPU_FLAG_3DNOW | AV_CPU_FLAG_MMX) | |
103 | #define CPUFLAG_3DNOWEXT (AV_CPU_FLAG_3DNOWEXT | CPUFLAG_3DNOW) | |
104 | #define CPUFLAG_SSE (AV_CPU_FLAG_SSE | CPUFLAG_MMXEXT) | |
105 | #define CPUFLAG_SSE2 (AV_CPU_FLAG_SSE2 | CPUFLAG_SSE) | |
106 | #define CPUFLAG_SSE2SLOW (AV_CPU_FLAG_SSE2SLOW | CPUFLAG_SSE2) | |
107 | #define CPUFLAG_SSE3 (AV_CPU_FLAG_SSE3 | CPUFLAG_SSE2) | |
108 | #define CPUFLAG_SSE3SLOW (AV_CPU_FLAG_SSE3SLOW | CPUFLAG_SSE3) | |
109 | #define CPUFLAG_SSSE3 (AV_CPU_FLAG_SSSE3 | CPUFLAG_SSE3) | |
110 | #define CPUFLAG_SSE4 (AV_CPU_FLAG_SSE4 | CPUFLAG_SSSE3) | |
111 | #define CPUFLAG_SSE42 (AV_CPU_FLAG_SSE42 | CPUFLAG_SSE4) | |
112 | #define CPUFLAG_AVX (AV_CPU_FLAG_AVX | CPUFLAG_SSE42) | |
113 | #define CPUFLAG_XOP (AV_CPU_FLAG_XOP | CPUFLAG_AVX) | |
114 | #define CPUFLAG_FMA3 (AV_CPU_FLAG_FMA3 | CPUFLAG_AVX) | |
115 | #define CPUFLAG_FMA4 (AV_CPU_FLAG_FMA4 | CPUFLAG_AVX) | |
116 | #define CPUFLAG_AVX2 (AV_CPU_FLAG_AVX2 | CPUFLAG_AVX) | |
117 | #define CPUFLAG_BMI1 (AV_CPU_FLAG_BMI1) | |
118 | #define CPUFLAG_BMI2 (AV_CPU_FLAG_BMI2 | CPUFLAG_BMI1) | |
119 | static const AVOption cpuflags_opts[] = { | |
120 | { "flags" , NULL, 0, AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT64_MIN, INT64_MAX, .unit = "flags" }, | |
121 | #if ARCH_PPC | |
122 | { "altivec" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_ALTIVEC }, .unit = "flags" }, | |
123 | #elif ARCH_X86 | |
124 | { "mmx" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_MMX }, .unit = "flags" }, | |
125 | { "mmxext" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CPUFLAG_MMXEXT }, .unit = "flags" }, | |
126 | { "sse" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CPUFLAG_SSE }, .unit = "flags" }, | |
127 | { "sse2" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CPUFLAG_SSE2 }, .unit = "flags" }, | |
128 | { "sse2slow", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CPUFLAG_SSE2SLOW }, .unit = "flags" }, | |
129 | { "sse3" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CPUFLAG_SSE3 }, .unit = "flags" }, | |
130 | { "sse3slow", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CPUFLAG_SSE3SLOW }, .unit = "flags" }, | |
131 | { "ssse3" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CPUFLAG_SSSE3 }, .unit = "flags" }, | |
132 | { "atom" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_ATOM }, .unit = "flags" }, | |
133 | { "sse4.1" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CPUFLAG_SSE4 }, .unit = "flags" }, | |
134 | { "sse4.2" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CPUFLAG_SSE42 }, .unit = "flags" }, | |
135 | { "avx" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CPUFLAG_AVX }, .unit = "flags" }, | |
136 | { "xop" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CPUFLAG_XOP }, .unit = "flags" }, | |
137 | { "fma3" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CPUFLAG_FMA3 }, .unit = "flags" }, | |
138 | { "fma4" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CPUFLAG_FMA4 }, .unit = "flags" }, | |
139 | { "avx2" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CPUFLAG_AVX2 }, .unit = "flags" }, | |
140 | { "bmi1" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CPUFLAG_BMI1 }, .unit = "flags" }, | |
141 | { "bmi2" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CPUFLAG_BMI2 }, .unit = "flags" }, | |
142 | { "3dnow" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CPUFLAG_3DNOW }, .unit = "flags" }, | |
143 | { "3dnowext", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CPUFLAG_3DNOWEXT }, .unit = "flags" }, | |
144 | { "cmov", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_CMOV }, .unit = "flags" }, | |
145 | #elif ARCH_ARM | |
146 | { "armv5te", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_ARMV5TE }, .unit = "flags" }, | |
147 | { "armv6", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_ARMV6 }, .unit = "flags" }, | |
148 | { "armv6t2", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_ARMV6T2 }, .unit = "flags" }, | |
149 | { "vfp", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_VFP }, .unit = "flags" }, | |
150 | { "vfpv3", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_VFPV3 }, .unit = "flags" }, | |
151 | { "neon", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_NEON }, .unit = "flags" }, | |
152 | #elif ARCH_AARCH64 | |
153 | { "armv8", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_ARMV8 }, .unit = "flags" }, | |
154 | { "neon", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_NEON }, .unit = "flags" }, | |
155 | { "vfp", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_VFP }, .unit = "flags" }, | |
156 | #endif | |
157 | { NULL }, | |
158 | }; | |
159 | static const AVClass class = { | |
160 | .class_name = "cpuflags", | |
161 | .item_name = av_default_item_name, | |
162 | .option = cpuflags_opts, | |
163 | .version = LIBAVUTIL_VERSION_INT, | |
164 | }; | |
165 | ||
166 | int flags = 0, ret; | |
167 | const AVClass *pclass = &class; | |
168 | ||
169 | if ((ret = av_opt_eval_flags(&pclass, &cpuflags_opts[0], s, &flags)) < 0) | |
170 | return ret; | |
171 | ||
172 | return flags & INT_MAX; | |
173 | } | |
174 | ||
175 | int av_parse_cpu_caps(unsigned *flags, const char *s) | |
176 | { | |
177 | static const AVOption cpuflags_opts[] = { | |
178 | { "flags" , NULL, 0, AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT64_MIN, INT64_MAX, .unit = "flags" }, | |
179 | #if ARCH_PPC | |
180 | { "altivec" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_ALTIVEC }, .unit = "flags" }, | |
181 | #elif ARCH_X86 | |
182 | { "mmx" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_MMX }, .unit = "flags" }, | |
183 | { "mmx2" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_MMX2 }, .unit = "flags" }, | |
184 | { "mmxext" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_MMX2 }, .unit = "flags" }, | |
185 | { "sse" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_SSE }, .unit = "flags" }, | |
186 | { "sse2" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_SSE2 }, .unit = "flags" }, | |
187 | { "sse2slow", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_SSE2SLOW }, .unit = "flags" }, | |
188 | { "sse3" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_SSE3 }, .unit = "flags" }, | |
189 | { "sse3slow", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_SSE3SLOW }, .unit = "flags" }, | |
190 | { "ssse3" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_SSSE3 }, .unit = "flags" }, | |
191 | { "atom" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_ATOM }, .unit = "flags" }, | |
192 | { "sse4.1" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_SSE4 }, .unit = "flags" }, | |
193 | { "sse4.2" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_SSE42 }, .unit = "flags" }, | |
194 | { "avx" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_AVX }, .unit = "flags" }, | |
195 | { "xop" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_XOP }, .unit = "flags" }, | |
196 | { "fma3" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_FMA3 }, .unit = "flags" }, | |
197 | { "fma4" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_FMA4 }, .unit = "flags" }, | |
198 | { "avx2" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_AVX2 }, .unit = "flags" }, | |
199 | { "bmi1" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_BMI1 }, .unit = "flags" }, | |
200 | { "bmi2" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_BMI2 }, .unit = "flags" }, | |
201 | { "3dnow" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_3DNOW }, .unit = "flags" }, | |
202 | { "3dnowext", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_3DNOWEXT }, .unit = "flags" }, | |
203 | { "cmov", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_CMOV }, .unit = "flags" }, | |
204 | ||
205 | #define CPU_FLAG_P2 AV_CPU_FLAG_CMOV | AV_CPU_FLAG_MMX | |
206 | #define CPU_FLAG_P3 CPU_FLAG_P2 | AV_CPU_FLAG_MMX2 | AV_CPU_FLAG_SSE | |
207 | #define CPU_FLAG_P4 CPU_FLAG_P3| AV_CPU_FLAG_SSE2 | |
208 | { "pentium2", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CPU_FLAG_P2 }, .unit = "flags" }, | |
209 | { "pentium3", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CPU_FLAG_P3 }, .unit = "flags" }, | |
210 | { "pentium4", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CPU_FLAG_P4 }, .unit = "flags" }, | |
211 | ||
212 | #define CPU_FLAG_K62 AV_CPU_FLAG_MMX | AV_CPU_FLAG_3DNOW | |
213 | #define CPU_FLAG_ATHLON CPU_FLAG_K62 | AV_CPU_FLAG_CMOV | AV_CPU_FLAG_3DNOWEXT | AV_CPU_FLAG_MMX2 | |
214 | #define CPU_FLAG_ATHLONXP CPU_FLAG_ATHLON | AV_CPU_FLAG_SSE | |
215 | #define CPU_FLAG_K8 CPU_FLAG_ATHLONXP | AV_CPU_FLAG_SSE2 | |
216 | { "k6", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_MMX }, .unit = "flags" }, | |
217 | { "k62", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CPU_FLAG_K62 }, .unit = "flags" }, | |
218 | { "athlon", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CPU_FLAG_ATHLON }, .unit = "flags" }, | |
219 | { "athlonxp", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CPU_FLAG_ATHLONXP }, .unit = "flags" }, | |
220 | { "k8", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CPU_FLAG_K8 }, .unit = "flags" }, | |
221 | #elif ARCH_ARM | |
222 | { "armv5te", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_ARMV5TE }, .unit = "flags" }, | |
223 | { "armv6", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_ARMV6 }, .unit = "flags" }, | |
224 | { "armv6t2", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_ARMV6T2 }, .unit = "flags" }, | |
225 | { "vfp", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_VFP }, .unit = "flags" }, | |
226 | { "vfpv3", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_VFPV3 }, .unit = "flags" }, | |
227 | { "neon", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_NEON }, .unit = "flags" }, | |
228 | { "setend", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_SETEND }, .unit = "flags" }, | |
229 | #elif ARCH_AARCH64 | |
230 | { "armv8", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_ARMV8 }, .unit = "flags" }, | |
231 | { "neon", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_NEON }, .unit = "flags" }, | |
232 | { "vfp", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_VFP }, .unit = "flags" }, | |
233 | #endif | |
234 | { NULL }, | |
235 | }; | |
236 | static const AVClass class = { | |
237 | .class_name = "cpuflags", | |
238 | .item_name = av_default_item_name, | |
239 | .option = cpuflags_opts, | |
240 | .version = LIBAVUTIL_VERSION_INT, | |
241 | }; | |
242 | const AVClass *pclass = &class; | |
243 | ||
244 | return av_opt_eval_flags(&pclass, &cpuflags_opts[0], s, flags); | |
245 | } | |
246 | ||
247 | int av_cpu_count(void) | |
248 | { | |
249 | static volatile int printed; | |
250 | ||
251 | int nb_cpus = 1; | |
252 | #if HAVE_SCHED_GETAFFINITY && defined(CPU_COUNT) | |
253 | cpu_set_t cpuset; | |
254 | ||
255 | CPU_ZERO(&cpuset); | |
256 | ||
257 | if (!sched_getaffinity(0, sizeof(cpuset), &cpuset)) | |
258 | nb_cpus = CPU_COUNT(&cpuset); | |
259 | #elif HAVE_GETPROCESSAFFINITYMASK | |
260 | DWORD_PTR proc_aff, sys_aff; | |
261 | if (GetProcessAffinityMask(GetCurrentProcess(), &proc_aff, &sys_aff)) | |
262 | nb_cpus = av_popcount64(proc_aff); | |
263 | #elif HAVE_SYSCTL && defined(HW_NCPU) | |
264 | int mib[2] = { CTL_HW, HW_NCPU }; | |
265 | size_t len = sizeof(nb_cpus); | |
266 | ||
267 | if (sysctl(mib, 2, &nb_cpus, &len, NULL, 0) == -1) | |
268 | nb_cpus = 0; | |
269 | #elif HAVE_SYSCONF && defined(_SC_NPROC_ONLN) | |
270 | nb_cpus = sysconf(_SC_NPROC_ONLN); | |
271 | #elif HAVE_SYSCONF && defined(_SC_NPROCESSORS_ONLN) | |
272 | nb_cpus = sysconf(_SC_NPROCESSORS_ONLN); | |
273 | #endif | |
274 | ||
275 | if (!printed) { | |
276 | av_log(NULL, AV_LOG_DEBUG, "detected %d logical cores\n", nb_cpus); | |
277 | printed = 1; | |
278 | } | |
279 | ||
280 | return nb_cpus; | |
281 | } | |
282 | ||
283 | #ifdef TEST | |
284 | ||
285 | #include <stdio.h> | |
286 | #include "avstring.h" | |
287 | ||
288 | #if !HAVE_GETOPT | |
289 | #include "compat/getopt.c" | |
290 | #endif | |
291 | ||
292 | static const struct { | |
293 | int flag; | |
294 | const char *name; | |
295 | } cpu_flag_tab[] = { | |
296 | #if ARCH_AARCH64 | |
297 | { AV_CPU_FLAG_ARMV8, "armv8" }, | |
298 | { AV_CPU_FLAG_NEON, "neon" }, | |
299 | { AV_CPU_FLAG_VFP, "vfp" }, | |
300 | #elif ARCH_ARM | |
301 | { AV_CPU_FLAG_ARMV5TE, "armv5te" }, | |
302 | { AV_CPU_FLAG_ARMV6, "armv6" }, | |
303 | { AV_CPU_FLAG_ARMV6T2, "armv6t2" }, | |
304 | { AV_CPU_FLAG_VFP, "vfp" }, | |
305 | { AV_CPU_FLAG_VFPV3, "vfpv3" }, | |
306 | { AV_CPU_FLAG_NEON, "neon" }, | |
307 | { AV_CPU_FLAG_SETEND, "setend" }, | |
308 | #elif ARCH_PPC | |
309 | { AV_CPU_FLAG_ALTIVEC, "altivec" }, | |
310 | #elif ARCH_X86 | |
311 | { AV_CPU_FLAG_MMX, "mmx" }, | |
312 | { AV_CPU_FLAG_MMXEXT, "mmxext" }, | |
313 | { AV_CPU_FLAG_SSE, "sse" }, | |
314 | { AV_CPU_FLAG_SSE2, "sse2" }, | |
315 | { AV_CPU_FLAG_SSE2SLOW, "sse2slow" }, | |
316 | { AV_CPU_FLAG_SSE3, "sse3" }, | |
317 | { AV_CPU_FLAG_SSE3SLOW, "sse3slow" }, | |
318 | { AV_CPU_FLAG_SSSE3, "ssse3" }, | |
319 | { AV_CPU_FLAG_ATOM, "atom" }, | |
320 | { AV_CPU_FLAG_SSE4, "sse4.1" }, | |
321 | { AV_CPU_FLAG_SSE42, "sse4.2" }, | |
322 | { AV_CPU_FLAG_AVX, "avx" }, | |
323 | { AV_CPU_FLAG_XOP, "xop" }, | |
324 | { AV_CPU_FLAG_FMA3, "fma3" }, | |
325 | { AV_CPU_FLAG_FMA4, "fma4" }, | |
326 | { AV_CPU_FLAG_3DNOW, "3dnow" }, | |
327 | { AV_CPU_FLAG_3DNOWEXT, "3dnowext" }, | |
328 | { AV_CPU_FLAG_CMOV, "cmov" }, | |
329 | { AV_CPU_FLAG_AVX2, "avx2" }, | |
330 | { AV_CPU_FLAG_BMI1, "bmi1" }, | |
331 | { AV_CPU_FLAG_BMI2, "bmi2" }, | |
332 | #endif | |
333 | { 0 } | |
334 | }; | |
335 | ||
336 | static void print_cpu_flags(int cpu_flags, const char *type) | |
337 | { | |
338 | int i; | |
339 | ||
340 | printf("cpu_flags(%s) = 0x%08X\n", type, cpu_flags); | |
341 | printf("cpu_flags_str(%s) =", type); | |
342 | for (i = 0; cpu_flag_tab[i].flag; i++) | |
343 | if (cpu_flags & cpu_flag_tab[i].flag) | |
344 | printf(" %s", cpu_flag_tab[i].name); | |
345 | printf("\n"); | |
346 | } | |
347 | ||
348 | ||
349 | int main(int argc, char **argv) | |
350 | { | |
351 | int cpu_flags_raw = av_get_cpu_flags(); | |
352 | int cpu_flags_eff; | |
353 | int cpu_count = av_cpu_count(); | |
354 | char threads[5] = "auto"; | |
355 | int i; | |
356 | ||
357 | for(i = 0; cpu_flag_tab[i].flag; i++) { | |
358 | unsigned tmp = 0; | |
359 | if (av_parse_cpu_caps(&tmp, cpu_flag_tab[i].name) < 0) { | |
360 | fprintf(stderr, "Table missing %s\n", cpu_flag_tab[i].name); | |
361 | return 4; | |
362 | } | |
363 | } | |
364 | ||
365 | if (cpu_flags_raw < 0) | |
366 | return 1; | |
367 | ||
368 | for (;;) { | |
369 | int c = getopt(argc, argv, "c:t:"); | |
370 | if (c == -1) | |
371 | break; | |
372 | switch (c) { | |
373 | case 'c': | |
374 | { | |
375 | unsigned flags = av_get_cpu_flags(); | |
376 | if (av_parse_cpu_caps(&flags, optarg) < 0) | |
377 | return 2; | |
378 | ||
379 | av_force_cpu_flags(flags); | |
380 | break; | |
381 | } | |
382 | case 't': | |
383 | { | |
384 | int len = av_strlcpy(threads, optarg, sizeof(threads)); | |
385 | if (len >= sizeof(threads)) { | |
386 | fprintf(stderr, "Invalid thread count '%s'\n", optarg); | |
387 | return 2; | |
388 | } | |
389 | } | |
390 | } | |
391 | } | |
392 | ||
393 | cpu_flags_eff = av_get_cpu_flags(); | |
394 | ||
395 | if (cpu_flags_eff < 0) | |
396 | return 3; | |
397 | ||
398 | print_cpu_flags(cpu_flags_raw, "raw"); | |
399 | print_cpu_flags(cpu_flags_eff, "effective"); | |
400 | printf("threads = %s (cpu_count = %d)\n", threads, cpu_count); | |
401 | ||
402 | return 0; | |
403 | } | |
404 | ||
405 | #endif |