1 /* 2 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard 3 * 4 * This file is part of FFmpeg. 5 * 6 * FFmpeg is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU Lesser General Public 8 * License as published by the Free Software Foundation; either 9 * version 2.1 of the License, or (at your option) any later version. 10 * 11 * FFmpeg is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 * Lesser General Public License for more details. 15 * 16 * You should have received a copy of the GNU Lesser General Public 17 * License along with FFmpeg; if not, write to the Free Software 18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 19 */ 20 21 module ffmpeg.libavutil.cpu; 22 23 extern (C): 24 import ffmpeg; @nogc nothrow: 25 26 enum AV_CPU_FLAG_FORCE = 0x80000000; /* force usage of selected flags (OR) */ 27 28 /* lower 16 bits - CPU features */ 29 enum AV_CPU_FLAG_MMX = 0x0001; ///< standard MMX 30 enum AV_CPU_FLAG_MMXEXT = 0x0002; ///< SSE integer functions or AMD MMX ext 31 enum AV_CPU_FLAG_MMX2 = 0x0002; ///< SSE integer functions or AMD MMX ext 32 enum AV_CPU_FLAG_3DNOW = 0x0004; ///< AMD 3DNOW 33 enum AV_CPU_FLAG_SSE = 0x0008; ///< SSE functions 34 enum AV_CPU_FLAG_SSE2 = 0x0010; ///< PIV SSE2 functions 35 enum AV_CPU_FLAG_SSE2SLOW = 0x40000000; ///< SSE2 supported, but usually not faster 36 ///< than regular MMX/SSE (e.g. Core1) 37 enum AV_CPU_FLAG_3DNOWEXT = 0x0020; ///< AMD 3DNowExt 38 enum AV_CPU_FLAG_SSE3 = 0x0040; ///< Prescott SSE3 functions 39 enum AV_CPU_FLAG_SSE3SLOW = 0x20000000; ///< SSE3 supported, but usually not faster 40 ///< than regular MMX/SSE (e.g. Core1) 41 enum AV_CPU_FLAG_SSSE3 = 0x0080; ///< Conroe SSSE3 functions 42 enum AV_CPU_FLAG_SSSE3SLOW = 0x4000000; ///< SSSE3 supported, but usually not faster 43 enum AV_CPU_FLAG_ATOM = 0x10000000; ///< Atom processor, some SSSE3 instructions are slower 44 enum AV_CPU_FLAG_SSE4 = 0x0100; ///< Penryn SSE4.1 functions 45 enum AV_CPU_FLAG_SSE42 = 0x0200; ///< Nehalem SSE4.2 functions 46 enum AV_CPU_FLAG_AESNI = 0x80000; ///< Advanced Encryption Standard functions 47 enum AV_CPU_FLAG_AVX = 0x4000; ///< AVX functions: requires OS support even if YMM registers aren't used 48 enum AV_CPU_FLAG_AVXSLOW = 0x8000000; ///< AVX supported, but slow when using YMM registers (e.g. Bulldozer) 49 enum AV_CPU_FLAG_XOP = 0x0400; ///< Bulldozer XOP functions 50 enum AV_CPU_FLAG_FMA4 = 0x0800; ///< Bulldozer FMA4 functions 51 enum AV_CPU_FLAG_CMOV = 0x1000; ///< supports cmov instruction 52 enum AV_CPU_FLAG_AVX2 = 0x8000; ///< AVX2 functions: requires OS support even if YMM registers aren't used 53 enum AV_CPU_FLAG_FMA3 = 0x10000; ///< Haswell FMA3 functions 54 enum AV_CPU_FLAG_BMI1 = 0x20000; ///< Bit Manipulation Instruction Set 1 55 enum AV_CPU_FLAG_BMI2 = 0x40000; ///< Bit Manipulation Instruction Set 2 56 enum AV_CPU_FLAG_AVX512 = 0x100000; ///< AVX-512 functions: requires OS support even if YMM/ZMM registers aren't used 57 58 enum AV_CPU_FLAG_ALTIVEC = 0x0001; ///< standard 59 enum AV_CPU_FLAG_VSX = 0x0002; ///< ISA 2.06 60 enum AV_CPU_FLAG_POWER8 = 0x0004; ///< ISA 2.07 61 62 enum AV_CPU_FLAG_ARMV5TE = 1 << 0; 63 enum AV_CPU_FLAG_ARMV6 = 1 << 1; 64 enum AV_CPU_FLAG_ARMV6T2 = 1 << 2; 65 enum AV_CPU_FLAG_VFP = 1 << 3; 66 enum AV_CPU_FLAG_VFPV3 = 1 << 4; 67 enum AV_CPU_FLAG_NEON = 1 << 5; 68 enum AV_CPU_FLAG_ARMV8 = 1 << 6; 69 enum AV_CPU_FLAG_VFP_VM = 1 << 7; ///< VFPv2 vector mode, deprecated in ARMv7-A and unavailable in various CPUs implementations 70 enum AV_CPU_FLAG_SETEND = 1 << 16; 71 72 /** 73 * Return the flags which specify extensions supported by the CPU. 74 * The returned value is affected by av_force_cpu_flags() if that was used 75 * before. So av_get_cpu_flags() can easily be used in an application to 76 * detect the enabled cpu flags. 77 */ 78 int av_get_cpu_flags (); 79 80 /** 81 * Disables cpu detection and forces the specified flags. 82 * -1 is a special case that disables forcing of specific flags. 83 */ 84 void av_force_cpu_flags (int flags); 85 86 /** 87 * Set a mask on flags returned by av_get_cpu_flags(). 88 * This function is mainly useful for testing. 89 * Please use av_force_cpu_flags() and av_get_cpu_flags() instead which are more flexible 90 */ 91 void av_set_cpu_flags_mask (int mask); 92 93 /** 94 * Parse CPU flags from a string. 95 * 96 * The returned flags contain the specified flags as well as related unspecified flags. 97 * 98 * This function exists only for compatibility with libav. 99 * Please use av_parse_cpu_caps() when possible. 100 * @return a combination of AV_CPU_* flags, negative on error. 101 */ 102 int av_parse_cpu_flags (const(char)* s); 103 104 /** 105 * Parse CPU caps from a string and update the given AV_CPU_* flags based on that. 106 * 107 * @return negative on error. 108 */ 109 int av_parse_cpu_caps (uint* flags, const(char)* s); 110 111 /** 112 * @return the number of logical CPU cores present. 113 */ 114 int av_cpu_count (); 115 116 /** 117 * Get the maximum data alignment that may be required by FFmpeg. 118 * 119 * Note that this is affected by the build configuration and the CPU flags mask, 120 * so e.g. if the CPU supports AVX, but libavutil has been built with 121 * --disable-avx or the AV_CPU_FLAG_AVX flag has been disabled through 122 * av_set_cpu_flags_mask(), then this function will behave as if AVX is not 123 * present. 124 */ 125 size_t av_cpu_max_align (); 126 127 /* AVUTIL_CPU_H */