| #!/bin/sh |
| # |
| # FFmpeg configure script |
| # |
| # Copyright (c) 2000-2002 Fabrice Bellard |
| # Copyright (c) 2005-2008 Diego Biurrun |
| # Copyright (c) 2005-2008 Mans Rullgard |
| # |
| |
| # Prevent locale nonsense from breaking basic text processing. |
| LC_ALL=C |
| export LC_ALL |
| |
| # make sure we are running under a compatible shell |
| # try to make this part work with most shells |
| |
| try_exec(){ |
| echo "Trying shell $1" |
| type "$1" > /dev/null 2>&1 && exec "$@" |
| } |
| |
| unset foo |
| (: ${foo%%bar}) 2> /dev/null |
| E1="$?" |
| |
| (: ${foo?}) 2> /dev/null |
| E2="$?" |
| |
| if test "$E1" != 0 || test "$E2" = 0; then |
| echo "Broken shell detected. Trying alternatives." |
| export FF_CONF_EXEC |
| if test "0$FF_CONF_EXEC" -lt 1; then |
| FF_CONF_EXEC=1 |
| try_exec bash "$0" "$@" |
| fi |
| if test "0$FF_CONF_EXEC" -lt 2; then |
| FF_CONF_EXEC=2 |
| try_exec ksh "$0" "$@" |
| fi |
| if test "0$FF_CONF_EXEC" -lt 3; then |
| FF_CONF_EXEC=3 |
| try_exec /usr/xpg4/bin/sh "$0" "$@" |
| fi |
| echo "No compatible shell script interpreter found." |
| echo "This configure script requires a POSIX-compatible shell" |
| echo "such as bash or ksh." |
| echo "THIS IS NOT A BUG IN FFMPEG, DO NOT REPORT IT AS SUCH." |
| echo "Instead, install a working POSIX-compatible shell." |
| echo "Disabling this configure test will create a broken FFmpeg." |
| if test "$BASH_VERSION" = '2.04.0(1)-release'; then |
| echo "This bash version ($BASH_VERSION) is broken on your platform." |
| echo "Upgrade to a later version if available." |
| fi |
| exit 1 |
| fi |
| |
| test -d /usr/xpg4/bin && PATH=/usr/xpg4/bin:$PATH |
| |
| show_help(){ |
| cat <<EOF |
| Usage: configure [options] |
| Options: [defaults in brackets after descriptions] |
| |
| Help options: |
| --help print this message |
| --quiet Suppress showing informative output |
| --list-decoders show all available decoders |
| --list-encoders show all available encoders |
| --list-hwaccels show all available hardware accelerators |
| --list-demuxers show all available demuxers |
| --list-muxers show all available muxers |
| --list-parsers show all available parsers |
| --list-protocols show all available protocols |
| --list-bsfs show all available bitstream filters |
| --list-indevs show all available input devices |
| --list-outdevs show all available output devices |
| --list-filters show all available filters |
| |
| Standard options: |
| --logfile=FILE log tests and output to FILE [ffbuild/config.log] |
| --disable-logging do not log configure debug information |
| --fatal-warnings fail if any configure warning is generated |
| --prefix=PREFIX install in PREFIX [$prefix_default] |
| --bindir=DIR install binaries in DIR [PREFIX/bin] |
| --datadir=DIR install data files in DIR [PREFIX/share/ffmpeg] |
| --docdir=DIR install documentation in DIR [PREFIX/share/doc/ffmpeg] |
| --libdir=DIR install libs in DIR [PREFIX/lib] |
| --shlibdir=DIR install shared libs in DIR [LIBDIR] |
| --incdir=DIR install includes in DIR [PREFIX/include] |
| --mandir=DIR install man page in DIR [PREFIX/share/man] |
| --pkgconfigdir=DIR install pkg-config files in DIR [LIBDIR/pkgconfig] |
| --enable-rpath use rpath to allow installing libraries in paths |
| not part of the dynamic linker search path |
| use rpath when linking programs (USE WITH CARE) |
| --install-name-dir=DIR Darwin directory name for installed targets |
| |
| Licensing options: |
| --enable-gpl allow use of GPL code, the resulting libs |
| and binaries will be under GPL [no] |
| --enable-version3 upgrade (L)GPL to version 3 [no] |
| --enable-nonfree allow use of nonfree code, the resulting libs |
| and binaries will be unredistributable [no] |
| |
| Configuration options: |
| --disable-static do not build static libraries [no] |
| --enable-shared build shared libraries [no] |
| --enable-small optimize for size instead of speed |
| --disable-runtime-cpudetect disable detecting CPU capabilities at runtime (smaller binary) |
| --enable-gray enable full grayscale support (slower color) |
| --disable-swscale-alpha disable alpha channel support in swscale |
| --disable-all disable building components, libraries and programs |
| --disable-autodetect disable automatically detected external libraries [no] |
| |
| Program options: |
| --disable-programs do not build command line programs |
| --disable-ffmpeg disable ffmpeg build |
| --disable-ffplay disable ffplay build |
| --disable-ffprobe disable ffprobe build |
| |
| Documentation options: |
| --disable-doc do not build documentation |
| --disable-htmlpages do not build HTML documentation pages |
| --disable-manpages do not build man documentation pages |
| --disable-podpages do not build POD documentation pages |
| --disable-txtpages do not build text documentation pages |
| |
| Component options: |
| --disable-avdevice disable libavdevice build |
| --disable-avcodec disable libavcodec build |
| --disable-avformat disable libavformat build |
| --disable-swresample disable libswresample build |
| --disable-swscale disable libswscale build |
| --disable-postproc disable libpostproc build |
| --disable-avfilter disable libavfilter build |
| --enable-avresample enable libavresample build (deprecated) [no] |
| --disable-pthreads disable pthreads [autodetect] |
| --disable-w32threads disable Win32 threads [autodetect] |
| --disable-os2threads disable OS/2 threads [autodetect] |
| --disable-network disable network support [no] |
| --disable-dct disable DCT code |
| --disable-dwt disable DWT code |
| --disable-error-resilience disable error resilience code |
| --disable-lsp disable LSP code |
| --disable-lzo disable LZO decoder code |
| --disable-mdct disable MDCT code |
| --disable-rdft disable RDFT code |
| --disable-fft disable FFT code |
| --disable-faan disable floating point AAN (I)DCT code |
| --disable-pixelutils disable pixel utils in libavutil |
| |
| Individual component options: |
| --disable-everything disable all components listed below |
| --disable-encoder=NAME disable encoder NAME |
| --enable-encoder=NAME enable encoder NAME |
| --disable-encoders disable all encoders |
| --disable-decoder=NAME disable decoder NAME |
| --enable-decoder=NAME enable decoder NAME |
| --disable-decoders disable all decoders |
| --disable-hwaccel=NAME disable hwaccel NAME |
| --enable-hwaccel=NAME enable hwaccel NAME |
| --disable-hwaccels disable all hwaccels |
| --disable-muxer=NAME disable muxer NAME |
| --enable-muxer=NAME enable muxer NAME |
| --disable-muxers disable all muxers |
| --disable-demuxer=NAME disable demuxer NAME |
| --enable-demuxer=NAME enable demuxer NAME |
| --disable-demuxers disable all demuxers |
| --enable-parser=NAME enable parser NAME |
| --disable-parser=NAME disable parser NAME |
| --disable-parsers disable all parsers |
| --enable-bsf=NAME enable bitstream filter NAME |
| --disable-bsf=NAME disable bitstream filter NAME |
| --disable-bsfs disable all bitstream filters |
| --enable-protocol=NAME enable protocol NAME |
| --disable-protocol=NAME disable protocol NAME |
| --disable-protocols disable all protocols |
| --enable-indev=NAME enable input device NAME |
| --disable-indev=NAME disable input device NAME |
| --disable-indevs disable input devices |
| --enable-outdev=NAME enable output device NAME |
| --disable-outdev=NAME disable output device NAME |
| --disable-outdevs disable output devices |
| --disable-devices disable all devices |
| --enable-filter=NAME enable filter NAME |
| --disable-filter=NAME disable filter NAME |
| --disable-filters disable all filters |
| |
| External library support: |
| |
| Using any of the following switches will allow FFmpeg to link to the |
| corresponding external library. All the components depending on that library |
| will become enabled, if all their other dependencies are met and they are not |
| explicitly disabled. E.g. --enable-libopus will enable linking to |
| libopus and allow the libopus encoder to be built, unless it is |
| specifically disabled with --disable-encoder=libopus. |
| |
| Note that only the system libraries are auto-detected. All the other external |
| libraries must be explicitly enabled. |
| |
| Also note that the following help text describes the purpose of the libraries |
| themselves, not all their features will necessarily be usable by FFmpeg. |
| |
| --disable-alsa disable ALSA support [autodetect] |
| --disable-appkit disable Apple AppKit framework [autodetect] |
| --disable-avfoundation disable Apple AVFoundation framework [autodetect] |
| --enable-avisynth enable reading of AviSynth script files [no] |
| --disable-bzlib disable bzlib [autodetect] |
| --disable-coreimage disable Apple CoreImage framework [autodetect] |
| --enable-chromaprint enable audio fingerprinting with chromaprint [no] |
| --enable-frei0r enable frei0r video filtering [no] |
| --enable-gcrypt enable gcrypt, needed for rtmp(t)e support |
| if openssl, librtmp or gmp is not used [no] |
| --enable-gmp enable gmp, needed for rtmp(t)e support |
| if openssl or librtmp is not used [no] |
| --enable-gnutls enable gnutls, needed for https support |
| if openssl, libtls or mbedtls is not used [no] |
| --disable-iconv disable iconv [autodetect] |
| --enable-jni enable JNI support [no] |
| --enable-ladspa enable LADSPA audio filtering [no] |
| --enable-libaom enable AV1 video encoding/decoding via libaom [no] |
| --enable-libaribb24 enable ARIB text and caption decoding via libaribb24 [no] |
| --enable-libass enable libass subtitles rendering, |
| needed for subtitles and ass filter [no] |
| --enable-libbluray enable BluRay reading using libbluray [no] |
| --enable-libbs2b enable bs2b DSP library [no] |
| --enable-libcaca enable textual display using libcaca [no] |
| --enable-libcelt enable CELT decoding via libcelt [no] |
| --enable-libcdio enable audio CD grabbing with libcdio [no] |
| --enable-libcodec2 enable codec2 en/decoding using libcodec2 [no] |
| --enable-libdav1d enable AV1 decoding via libdav1d [no] |
| --enable-libdavs2 enable AVS2 decoding via libdavs2 [no] |
| --enable-libdc1394 enable IIDC-1394 grabbing using libdc1394 |
| and libraw1394 [no] |
| --enable-libfdk-aac enable AAC de/encoding via libfdk-aac [no] |
| --enable-libflite enable flite (voice synthesis) support via libflite [no] |
| --enable-libfontconfig enable libfontconfig, useful for drawtext filter [no] |
| --enable-libfreetype enable libfreetype, needed for drawtext filter [no] |
| --enable-libfribidi enable libfribidi, improves drawtext filter [no] |
| --enable-libglslang enable GLSL->SPIRV compilation via libglslang [no] |
| --enable-libgme enable Game Music Emu via libgme [no] |
| --enable-libgsm enable GSM de/encoding via libgsm [no] |
| --enable-libiec61883 enable iec61883 via libiec61883 [no] |
| --enable-libilbc enable iLBC de/encoding via libilbc [no] |
| --enable-libjack enable JACK audio sound server [no] |
| --enable-libklvanc enable Kernel Labs VANC processing [no] |
| --enable-libkvazaar enable HEVC encoding via libkvazaar [no] |
| --enable-liblensfun enable lensfun lens correction [no] |
| --enable-libmodplug enable ModPlug via libmodplug [no] |
| --enable-libmp3lame enable MP3 encoding via libmp3lame [no] |
| --enable-libopencore-amrnb enable AMR-NB de/encoding via libopencore-amrnb [no] |
| --enable-libopencore-amrwb enable AMR-WB decoding via libopencore-amrwb [no] |
| --enable-libopencv enable video filtering via libopencv [no] |
| --enable-libopenh264 enable H.264 encoding via OpenH264 [no] |
| --enable-libopenjpeg enable JPEG 2000 de/encoding via OpenJPEG [no] |
| --enable-libopenmpt enable decoding tracked files via libopenmpt [no] |
| --enable-libopenvino enable OpenVINO as a DNN module backend |
| for DNN based filters like dnn_processing [no] |
| --enable-libopus enable Opus de/encoding via libopus [no] |
| --enable-libpulse enable Pulseaudio input via libpulse [no] |
| --enable-librabbitmq enable RabbitMQ library [no] |
| --enable-librav1e enable AV1 encoding via rav1e [no] |
| --enable-librsvg enable SVG rasterization via librsvg [no] |
| --enable-librubberband enable rubberband needed for rubberband filter [no] |
| --enable-librtmp enable RTMP[E] support via librtmp [no] |
| --enable-libshine enable fixed-point MP3 encoding via libshine [no] |
| --enable-libsmbclient enable Samba protocol via libsmbclient [no] |
| --enable-libsnappy enable Snappy compression, needed for hap encoding [no] |
| --enable-libsoxr enable Include libsoxr resampling [no] |
| --enable-libspeex enable Speex de/encoding via libspeex [no] |
| --enable-libsrt enable Haivision SRT protocol via libsrt [no] |
| --enable-libssh enable SFTP protocol via libssh [no] |
| --enable-libsvtav1 enable AV1 encoding via SVT [no] |
| --enable-libtensorflow enable TensorFlow as a DNN module backend |
| for DNN based filters like sr [no] |
| --enable-libtesseract enable Tesseract, needed for ocr filter [no] |
| --enable-libtheora enable Theora encoding via libtheora [no] |
| --enable-libtls enable LibreSSL (via libtls), needed for https support |
| if openssl, gnutls or mbedtls is not used [no] |
| --enable-libtwolame enable MP2 encoding via libtwolame [no] |
| --enable-libuavs3d enable AVS3 decoding via libuavs3d [no] |
| --enable-libv4l2 enable libv4l2/v4l-utils [no] |
| --enable-libvidstab enable video stabilization using vid.stab [no] |
| --enable-libvmaf enable vmaf filter via libvmaf [no] |
| --enable-libvo-amrwbenc enable AMR-WB encoding via libvo-amrwbenc [no] |
| --enable-libvorbis enable Vorbis en/decoding via libvorbis, |
| native implementation exists [no] |
| --enable-libvpx enable VP8 and VP9 de/encoding via libvpx [no] |
| --enable-libwebp enable WebP encoding via libwebp [no] |
| --enable-libx264 enable H.264 encoding via x264 [no] |
| --enable-libx265 enable HEVC encoding via x265 [no] |
| --enable-libxavs enable AVS encoding via xavs [no] |
| --enable-libxavs2 enable AVS2 encoding via xavs2 [no] |
| --enable-libxcb enable X11 grabbing using XCB [autodetect] |
| --enable-libxcb-shm enable X11 grabbing shm communication [autodetect] |
| --enable-libxcb-xfixes enable X11 grabbing mouse rendering [autodetect] |
| --enable-libxcb-shape enable X11 grabbing shape rendering [autodetect] |
| --enable-libxvid enable Xvid encoding via xvidcore, |
| native MPEG-4/Xvid encoder exists [no] |
| --enable-libxml2 enable XML parsing using the C library libxml2, needed |
| for dash demuxing support [no] |
| --enable-libzimg enable z.lib, needed for zscale filter [no] |
| --enable-libzmq enable message passing via libzmq [no] |
| --enable-libzvbi enable teletext support via libzvbi [no] |
| --enable-lv2 enable LV2 audio filtering [no] |
| --disable-lzma disable lzma [autodetect] |
| --enable-decklink enable Blackmagic DeckLink I/O support [no] |
| --enable-mbedtls enable mbedTLS, needed for https support |
| if openssl, gnutls or libtls is not used [no] |
| --enable-mediacodec enable Android MediaCodec support [no] |
| --enable-mediafoundation enable encoding via MediaFoundation [auto] |
| --enable-libmysofa enable libmysofa, needed for sofalizer filter [no] |
| --enable-openal enable OpenAL 1.1 capture support [no] |
| --enable-opencl enable OpenCL processing [no] |
| --enable-opengl enable OpenGL rendering [no] |
| --enable-openssl enable openssl, needed for https support |
| if gnutls, libtls or mbedtls is not used [no] |
| --enable-pocketsphinx enable PocketSphinx, needed for asr filter [no] |
| --disable-sndio disable sndio support [autodetect] |
| --disable-schannel disable SChannel SSP, needed for TLS support on |
| Windows if openssl and gnutls are not used [autodetect] |
| --disable-sdl2 disable sdl2 [autodetect] |
| --disable-securetransport disable Secure Transport, needed for TLS support |
| on OSX if openssl and gnutls are not used [autodetect] |
| --enable-vapoursynth enable VapourSynth demuxer [no] |
| --enable-vulkan enable Vulkan code [no] |
| --disable-xlib disable xlib [autodetect] |
| --disable-zlib disable zlib [autodetect] |
| |
| The following libraries provide various hardware acceleration features: |
| --disable-amf disable AMF video encoding code [autodetect] |
| --disable-audiotoolbox disable Apple AudioToolbox code [autodetect] |
| --enable-cuda-nvcc enable Nvidia CUDA compiler [no] |
| --disable-cuda-llvm disable CUDA compilation using clang [autodetect] |
| --disable-cuvid disable Nvidia CUVID support [autodetect] |
| --disable-d3d11va disable Microsoft Direct3D 11 video acceleration code [autodetect] |
| --disable-dxva2 disable Microsoft DirectX 9 video acceleration code [autodetect] |
| --disable-ffnvcodec disable dynamically linked Nvidia code [autodetect] |
| --enable-libdrm enable DRM code (Linux) [no] |
| --enable-libmfx enable Intel MediaSDK (AKA Quick Sync Video) code via libmfx [no] |
| --enable-libnpp enable Nvidia Performance Primitives-based code [no] |
| --enable-mmal enable Broadcom Multi-Media Abstraction Layer (Raspberry Pi) via MMAL [no] |
| --disable-nvdec disable Nvidia video decoding acceleration (via hwaccel) [autodetect] |
| --disable-nvenc disable Nvidia video encoding code [autodetect] |
| --enable-omx enable OpenMAX IL code [no] |
| --enable-omx-rpi enable OpenMAX IL code for Raspberry Pi [no] |
| --enable-rkmpp enable Rockchip Media Process Platform code [no] |
| --disable-v4l2-m2m disable V4L2 mem2mem code [autodetect] |
| --disable-vaapi disable Video Acceleration API (mainly Unix/Intel) code [autodetect] |
| --disable-vdpau disable Nvidia Video Decode and Presentation API for Unix code [autodetect] |
| --disable-videotoolbox disable VideoToolbox code [autodetect] |
| |
| Toolchain options: |
| --arch=ARCH select architecture [$arch] |
| --cpu=CPU select the minimum required CPU (affects |
| instruction selection, may crash on older CPUs) |
| --cross-prefix=PREFIX use PREFIX for compilation tools [$cross_prefix] |
| --progs-suffix=SUFFIX program name suffix [] |
| --enable-cross-compile assume a cross-compiler is used |
| --sysroot=PATH root of cross-build tree |
| --sysinclude=PATH location of cross-build system headers |
| --target-os=OS compiler targets OS [$target_os] |
| --target-exec=CMD command to run executables on target |
| --target-path=DIR path to view of build directory on target |
| --target-samples=DIR path to samples directory on target |
| --tempprefix=PATH force fixed dir/prefix instead of mktemp for checks |
| --toolchain=NAME set tool defaults according to NAME |
| (gcc-asan, clang-asan, gcc-msan, clang-msan, |
| gcc-tsan, clang-tsan, gcc-usan, clang-usan, |
| valgrind-massif, valgrind-memcheck, |
| msvc, icl, gcov, llvm-cov, hardened) |
| --nm=NM use nm tool NM [$nm_default] |
| --ar=AR use archive tool AR [$ar_default] |
| --as=AS use assembler AS [$as_default] |
| --ln_s=LN_S use symbolic link tool LN_S [$ln_s_default] |
| --strip=STRIP use strip tool STRIP [$strip_default] |
| --windres=WINDRES use windows resource compiler WINDRES [$windres_default] |
| --x86asmexe=EXE use nasm-compatible assembler EXE [$x86asmexe_default] |
| --cc=CC use C compiler CC [$cc_default] |
| --cxx=CXX use C compiler CXX [$cxx_default] |
| --objcc=OCC use ObjC compiler OCC [$cc_default] |
| --dep-cc=DEPCC use dependency generator DEPCC [$cc_default] |
| --nvcc=NVCC use Nvidia CUDA compiler NVCC or clang [$nvcc_default] |
| --ld=LD use linker LD [$ld_default] |
| --pkg-config=PKGCONFIG use pkg-config tool PKGCONFIG [$pkg_config_default] |
| --pkg-config-flags=FLAGS pass additional flags to pkgconf [] |
| --ranlib=RANLIB use ranlib RANLIB [$ranlib_default] |
| --doxygen=DOXYGEN use DOXYGEN to generate API doc [$doxygen_default] |
| --host-cc=HOSTCC use host C compiler HOSTCC |
| --host-cflags=HCFLAGS use HCFLAGS when compiling for host |
| --host-cppflags=HCPPFLAGS use HCPPFLAGS when compiling for host |
| --host-ld=HOSTLD use host linker HOSTLD |
| --host-ldflags=HLDFLAGS use HLDFLAGS when linking for host |
| --host-extralibs=HLIBS use libs HLIBS when linking for host |
| --host-os=OS compiler host OS [$target_os] |
| --extra-cflags=ECFLAGS add ECFLAGS to CFLAGS [$CFLAGS] |
| --extra-cxxflags=ECFLAGS add ECFLAGS to CXXFLAGS [$CXXFLAGS] |
| --extra-objcflags=FLAGS add FLAGS to OBJCFLAGS [$CFLAGS] |
| --extra-ldflags=ELDFLAGS add ELDFLAGS to LDFLAGS [$LDFLAGS] |
| --extra-ldexeflags=ELDFLAGS add ELDFLAGS to LDEXEFLAGS [$LDEXEFLAGS] |
| --extra-ldsoflags=ELDFLAGS add ELDFLAGS to LDSOFLAGS [$LDSOFLAGS] |
| --extra-libs=ELIBS add ELIBS [$ELIBS] |
| --extra-version=STRING version string suffix [] |
| --optflags=OPTFLAGS override optimization-related compiler flags |
| --nvccflags=NVCCFLAGS override nvcc flags [$nvccflags_default] |
| --build-suffix=SUFFIX library name suffix [] |
| --enable-pic build position-independent code |
| --enable-thumb compile for Thumb instruction set |
| --enable-lto use link-time optimization |
| --env="ENV=override" override the environment variables |
| |
| Advanced options (experts only): |
| --malloc-prefix=PREFIX prefix malloc and related names with PREFIX |
| --custom-allocator=NAME use a supported custom allocator |
| --disable-symver disable symbol versioning |
| --enable-hardcoded-tables use hardcoded tables instead of runtime generation |
| --disable-safe-bitstream-reader |
| disable buffer boundary checking in bitreaders |
| (faster, but may crash) |
| --sws-max-filter-size=N the max filter size swscale uses [$sws_max_filter_size_default] |
| |
| Optimization options (experts only): |
| --disable-asm disable all assembly optimizations |
| --disable-altivec disable AltiVec optimizations |
| --disable-vsx disable VSX optimizations |
| --disable-power8 disable POWER8 optimizations |
| --disable-amd3dnow disable 3DNow! optimizations |
| --disable-amd3dnowext disable 3DNow! extended optimizations |
| --disable-mmx disable MMX optimizations |
| --disable-mmxext disable MMXEXT optimizations |
| --disable-sse disable SSE optimizations |
| --disable-sse2 disable SSE2 optimizations |
| --disable-sse3 disable SSE3 optimizations |
| --disable-ssse3 disable SSSE3 optimizations |
| --disable-sse4 disable SSE4 optimizations |
| --disable-sse42 disable SSE4.2 optimizations |
| --disable-avx disable AVX optimizations |
| --disable-xop disable XOP optimizations |
| --disable-fma3 disable FMA3 optimizations |
| --disable-fma4 disable FMA4 optimizations |
| --disable-avx2 disable AVX2 optimizations |
| --disable-avx512 disable AVX-512 optimizations |
| --disable-aesni disable AESNI optimizations |
| --disable-armv5te disable armv5te optimizations |
| --disable-armv6 disable armv6 optimizations |
| --disable-armv6t2 disable armv6t2 optimizations |
| --disable-vfp disable VFP optimizations |
| --disable-neon disable NEON optimizations |
| --disable-inline-asm disable use of inline assembly |
| --disable-x86asm disable use of standalone x86 assembly |
| --disable-mipsdsp disable MIPS DSP ASE R1 optimizations |
| --disable-mipsdspr2 disable MIPS DSP ASE R2 optimizations |
| --disable-msa disable MSA optimizations |
| --disable-msa2 disable MSA2 optimizations |
| --disable-mipsfpu disable floating point MIPS optimizations |
| --disable-mmi disable Loongson SIMD optimizations |
| --disable-fast-unaligned consider unaligned accesses slow |
| |
| Developer options (useful when working on FFmpeg itself): |
| --disable-debug disable debugging symbols |
| --enable-debug=LEVEL set the debug level [$debuglevel] |
| --disable-optimizations disable compiler optimizations |
| --enable-extra-warnings enable more compiler warnings |
| --disable-stripping disable stripping of executables and shared libraries |
| --assert-level=level 0(default), 1 or 2, amount of assertion testing, |
| 2 causes a slowdown at runtime. |
| --enable-memory-poisoning fill heap uninitialized allocated space with arbitrary data |
| --valgrind=VALGRIND run "make fate" tests through valgrind to detect memory |
| leaks and errors, using the specified valgrind binary. |
| Cannot be combined with --target-exec |
| --enable-ftrapv Trap arithmetic overflows |
| --samples=PATH location of test samples for FATE, if not set use |
| \$FATE_SAMPLES at make invocation time. |
| --enable-neon-clobber-test check NEON registers for clobbering (should be |
| used only for debugging purposes) |
| --enable-xmm-clobber-test check XMM registers for clobbering (Win64-only; |
| should be used only for debugging purposes) |
| --enable-random randomly enable/disable components |
| --disable-random |
| --enable-random=LIST randomly enable/disable specific components or |
| --disable-random=LIST component groups. LIST is a comma-separated list |
| of NAME[:PROB] entries where NAME is a component |
| (group) and PROB the probability associated with |
| NAME (default 0.5). |
| --random-seed=VALUE seed value for --enable/disable-random |
| --disable-valgrind-backtrace do not print a backtrace under Valgrind |
| (only applies to --disable-optimizations builds) |
| --enable-ossfuzz Enable building fuzzer tool |
| --libfuzzer=PATH path to libfuzzer |
| --ignore-tests=TESTS comma-separated list (without "fate-" prefix |
| in the name) of tests whose result is ignored |
| --enable-linux-perf enable Linux Performance Monitor API |
| --disable-large-tests disable tests that use a large amount of memory |
| |
| NOTE: Object files are built at the place where configure is launched. |
| EOF |
| exit 0 |
| } |
| |
| if test -t 1 && which tput >/dev/null 2>&1; then |
| ncolors=$(tput colors) |
| if test -n "$ncolors" && test $ncolors -ge 8; then |
| bold_color=$(tput bold) |
| warn_color=$(tput setaf 3) |
| error_color=$(tput setaf 1) |
| reset_color=$(tput sgr0) |
| fi |
| # 72 used instead of 80 since that's the default of pr |
| ncols=$(tput cols) |
| fi |
| : ${ncols:=72} |
| |
| log(){ |
| echo "$@" >> $logfile |
| } |
| |
| log_file(){ |
| log BEGIN "$1" |
| log_file_i=1 |
| while IFS= read -r log_file_line; do |
| printf '%5d\t%s\n' "$log_file_i" "$log_file_line" |
| log_file_i=$(($log_file_i+1)) |
| done < "$1" >> "$logfile" |
| log END "$1" |
| } |
| |
| warn(){ |
| log "WARNING: $*" |
| WARNINGS="${WARNINGS}WARNING: $*\n" |
| } |
| |
| die(){ |
| log "$@" |
| echo "$error_color$bold_color$@$reset_color" |
| cat <<EOF |
| |
| If you think configure made a mistake, make sure you are using the latest |
| version from Git. If the latest version fails, report the problem to the |
| ffmpeg-user@ffmpeg.org mailing list or IRC #ffmpeg on irc.freenode.net. |
| EOF |
| if disabled logging; then |
| cat <<EOF |
| Rerun configure with logging enabled (do not use --disable-logging), and |
| include the log this produces with your report. |
| EOF |
| else |
| cat <<EOF |
| Include the log file "$logfile" produced by configure as this will help |
| solve the problem. |
| EOF |
| fi |
| exit 1 |
| } |
| |
| # Avoid locale weirdness, besides we really just want to translate ASCII. |
| toupper(){ |
| echo "$@" | tr abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ |
| } |
| |
| tolower(){ |
| echo "$@" | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz |
| } |
| |
| c_escape(){ |
| echo "$*" | sed 's/["\\]/\\\0/g' |
| } |
| |
| sh_quote(){ |
| v=$(echo "$1" | sed "s/'/'\\\\''/g") |
| test "x$v" = "x${v#*[!A-Za-z0-9_/.+-]}" || v="'$v'" |
| echo "$v" |
| } |
| |
| cleanws(){ |
| echo "$@" | sed 's/^ *//;s/[[:space:]][[:space:]]*/ /g;s/ *$//' |
| } |
| |
| filter(){ |
| pat=$1 |
| shift |
| for v; do |
| eval "case '$v' in $pat) printf '%s ' '$v' ;; esac" |
| done |
| } |
| |
| filter_out(){ |
| pat=$1 |
| shift |
| for v; do |
| eval "case '$v' in $pat) ;; *) printf '%s ' '$v' ;; esac" |
| done |
| } |
| |
| map(){ |
| m=$1 |
| shift |
| for v; do eval $m; done |
| } |
| |
| add_suffix(){ |
| suffix=$1 |
| shift |
| for v; do echo ${v}${suffix}; done |
| } |
| |
| remove_suffix(){ |
| suffix=$1 |
| shift |
| for v; do echo ${v%$suffix}; done |
| } |
| |
| set_all(){ |
| value=$1 |
| shift |
| for var in $*; do |
| eval $var=$value |
| done |
| } |
| |
| set_weak(){ |
| value=$1 |
| shift |
| for var; do |
| eval : \${$var:=$value} |
| done |
| } |
| |
| sanitize_var_name(){ |
| echo $@ | sed 's/[^A-Za-z0-9_]/_/g' |
| } |
| |
| set_sanitized(){ |
| var=$1 |
| shift |
| eval $(sanitize_var_name "$var")='$*' |
| } |
| |
| get_sanitized(){ |
| eval echo \$$(sanitize_var_name "$1") |
| } |
| |
| pushvar(){ |
| for pvar in $*; do |
| eval level=\${${pvar}_level:=0} |
| eval ${pvar}_${level}="\$$pvar" |
| eval ${pvar}_level=$(($level+1)) |
| done |
| } |
| |
| popvar(){ |
| for pvar in $*; do |
| eval level=\${${pvar}_level:-0} |
| test $level = 0 && continue |
| eval level=$(($level-1)) |
| eval $pvar="\${${pvar}_${level}}" |
| eval ${pvar}_level=$level |
| eval unset ${pvar}_${level} |
| done |
| } |
| |
| request(){ |
| for var in $*; do |
| eval ${var}_requested=yes |
| eval $var= |
| done |
| } |
| |
| warn_if_gets_disabled(){ |
| for var in $*; do |
| WARN_IF_GETS_DISABLED_LIST="$WARN_IF_GETS_DISABLED_LIST $var" |
| done |
| } |
| |
| enable(){ |
| set_all yes $* |
| } |
| |
| disable(){ |
| set_all no $* |
| } |
| |
| disable_with_reason(){ |
| disable $1 |
| eval "${1}_disable_reason=\"$2\"" |
| if requested $1; then |
| die "ERROR: $1 requested, but $2" |
| fi |
| } |
| |
| enable_weak(){ |
| set_weak yes $* |
| } |
| |
| disable_weak(){ |
| set_weak no $* |
| } |
| |
| enable_sanitized(){ |
| for var; do |
| enable $(sanitize_var_name $var) |
| done |
| } |
| |
| disable_sanitized(){ |
| for var; do |
| disable $(sanitize_var_name $var) |
| done |
| } |
| |
| do_enable_deep(){ |
| for var; do |
| enabled $var && continue |
| set -- $var |
| eval enable_deep \$${var}_select |
| var=$1 |
| eval enable_deep_weak \$${var}_suggest |
| done |
| } |
| |
| enable_deep(){ |
| do_enable_deep $* |
| enable $* |
| } |
| |
| enable_deep_weak(){ |
| for var; do |
| disabled $var && continue |
| set -- $var |
| do_enable_deep $var |
| var=$1 |
| enable_weak $var |
| done |
| } |
| |
| requested(){ |
| test "${1#!}" = "$1" && op="=" || op="!=" |
| eval test "x\$${1#!}_requested" $op "xyes" |
| } |
| |
| enabled(){ |
| test "${1#!}" = "$1" && op="=" || op="!=" |
| eval test "x\$${1#!}" $op "xyes" |
| } |
| |
| disabled(){ |
| test "${1#!}" = "$1" && op="=" || op="!=" |
| eval test "x\$${1#!}" $op "xno" |
| } |
| |
| enabled_all(){ |
| for opt; do |
| enabled $opt || return 1 |
| done |
| } |
| |
| disabled_all(){ |
| for opt; do |
| disabled $opt || return 1 |
| done |
| } |
| |
| enabled_any(){ |
| for opt; do |
| enabled $opt && return 0 |
| done |
| } |
| |
| disabled_any(){ |
| for opt; do |
| disabled $opt && return 0 |
| done |
| return 1 |
| } |
| |
| set_default(){ |
| for opt; do |
| eval : \${$opt:=\$${opt}_default} |
| done |
| } |
| |
| is_in(){ |
| value=$1 |
| shift |
| for var in $*; do |
| [ $var = $value ] && return 0 |
| done |
| return 1 |
| } |
| |
| # The cfg loop is very hot (several thousands iterations), and in bash also |
| # potentialy quite slow. Try to abort the iterations early, preferably without |
| # calling functions. 70%+ of the time cfg is already done or without deps. |
| check_deps(){ |
| for cfg; do |
| eval [ x\$${cfg}_checking = xdone ] && continue |
| eval [ x\$${cfg}_checking = xinprogress ] && die "Circular dependency for $cfg." |
| |
| eval " |
| dep_all=\$${cfg}_deps |
| dep_any=\$${cfg}_deps_any |
| dep_con=\$${cfg}_conflict |
| dep_sel=\$${cfg}_select |
| dep_sgs=\$${cfg}_suggest |
| dep_ifa=\$${cfg}_if |
| dep_ifn=\$${cfg}_if_any |
| " |
| |
| # most of the time here $cfg has no deps - avoid costly no-op work |
| if [ "$dep_all$dep_any$dep_con$dep_sel$dep_sgs$dep_ifa$dep_ifn" ]; then |
| eval ${cfg}_checking=inprogress |
| |
| set -- $cfg "$dep_all" "$dep_any" "$dep_con" "$dep_sel" "$dep_sgs" "$dep_ifa" "$dep_ifn" |
| check_deps $dep_all $dep_any $dep_con $dep_sel $dep_sgs $dep_ifa $dep_ifn |
| cfg=$1; dep_all=$2; dep_any=$3; dep_con=$4; dep_sel=$5 dep_sgs=$6; dep_ifa=$7; dep_ifn=$8 |
| |
| [ -n "$dep_ifa" ] && { enabled_all $dep_ifa && enable_weak $cfg; } |
| [ -n "$dep_ifn" ] && { enabled_any $dep_ifn && enable_weak $cfg; } |
| enabled_all $dep_all || { disable_with_reason $cfg "not all dependencies are satisfied: $dep_all"; } |
| enabled_any $dep_any || { disable_with_reason $cfg "not any dependency is satisfied: $dep_any"; } |
| disabled_all $dep_con || { disable_with_reason $cfg "some conflicting dependencies are unsatisfied: $dep_con"; } |
| disabled_any $dep_sel && { disable_with_reason $cfg "some selected dependency is unsatisfied: $dep_sel"; } |
| |
| enabled $cfg && enable_deep_weak $dep_sel $dep_sgs |
| |
| for dep in $dep_all $dep_any $dep_sel $dep_sgs; do |
| # filter out library deps, these do not belong in extralibs |
| is_in $dep $LIBRARY_LIST && continue |
| enabled $dep && eval append ${cfg}_extralibs ${dep}_extralibs |
| done |
| fi |
| |
| eval ${cfg}_checking=done |
| done |
| } |
| |
| print_config(){ |
| pfx=$1 |
| files=$2 |
| shift 2 |
| map 'eval echo "$v \${$v:-no}"' "$@" | |
| awk "BEGIN { split(\"$files\", files) } |
| { |
| c = \"$pfx\" toupper(\$1); |
| v = \$2; |
| sub(/yes/, 1, v); |
| sub(/no/, 0, v); |
| for (f in files) { |
| file = files[f]; |
| if (file ~ /\\.h\$/) { |
| printf(\"#define %s %d\\n\", c, v) >>file; |
| } else if (file ~ /\\.asm\$/) { |
| printf(\"%%define %s %d\\n\", c, v) >>file; |
| } else if (file ~ /\\.mak\$/) { |
| n = -v ? \"\" : \"!\"; |
| printf(\"%s%s=yes\\n\", n, c) >>file; |
| } else if (file ~ /\\.texi\$/) { |
| pre = -v ? \"\" : \"@c \"; |
| yesno = \$2; |
| c2 = tolower(c); |
| gsub(/_/, \"-\", c2); |
| printf(\"%s@set %s %s\\n\", pre, c2, yesno) >>file; |
| } |
| } |
| }" |
| } |
| |
| print_enabled(){ |
| suf=$1 |
| shift |
| for v; do |
| enabled $v && printf "%s\n" ${v%$suf} |
| done |
| } |
| |
| append(){ |
| var=$1 |
| shift |
| eval "$var=\"\$$var $*\"" |
| } |
| |
| prepend(){ |
| var=$1 |
| shift |
| eval "$var=\"$* \$$var\"" |
| } |
| |
| reverse () { |
| eval ' |
| reverse_out= |
| for v in $'$1'; do |
| reverse_out="$v $reverse_out" |
| done |
| '$1'=$reverse_out |
| ' |
| } |
| |
| # keeps the last occurence of each non-unique item |
| unique(){ |
| unique_out= |
| eval unique_in=\$$1 |
| reverse unique_in |
| for v in $unique_in; do |
| # " $unique_out" +space such that every item is surrounded with spaces |
| case " $unique_out" in *" $v "*) continue; esac # already in list |
| unique_out="$unique_out$v " |
| done |
| reverse unique_out |
| eval $1=\$unique_out |
| } |
| |
| resolve(){ |
| resolve_out= |
| eval resolve_in=\$$1 |
| for v in $resolve_in; do |
| eval 'resolve_out="$resolve_out$'$v' "' |
| done |
| eval $1=\$resolve_out |
| } |
| |
| add_cppflags(){ |
| append CPPFLAGS "$@" |
| } |
| |
| add_cflags(){ |
| append CFLAGS $($cflags_filter "$@") |
| } |
| |
| add_cflags_headers(){ |
| append CFLAGS_HEADERS $($cflags_filter "$@") |
| } |
| |
| add_cxxflags(){ |
| append CXXFLAGS $($cflags_filter "$@") |
| } |
| |
| add_objcflags(){ |
| append OBJCFLAGS $($objcflags_filter "$@") |
| } |
| |
| add_asflags(){ |
| append ASFLAGS $($asflags_filter "$@") |
| } |
| |
| add_ldflags(){ |
| append LDFLAGS $($ldflags_filter "$@") |
| } |
| |
| add_ldexeflags(){ |
| append LDEXEFLAGS $($ldflags_filter "$@") |
| } |
| |
| add_ldsoflags(){ |
| append LDSOFLAGS $($ldflags_filter "$@") |
| } |
| |
| add_extralibs(){ |
| prepend extralibs $($ldflags_filter "$@") |
| } |
| |
| add_stripflags(){ |
| append ASMSTRIPFLAGS "$@" |
| } |
| |
| add_host_cppflags(){ |
| append host_cppflags "$@" |
| } |
| |
| add_host_cflags(){ |
| append host_cflags $($host_cflags_filter "$@") |
| } |
| |
| add_host_ldflags(){ |
| append host_ldflags $($host_ldflags_filter "$@") |
| } |
| |
| add_compat(){ |
| append compat_objs $1 |
| shift |
| map 'add_cppflags -D$v' "$@" |
| } |
| |
| test_cmd(){ |
| log "$@" |
| "$@" >> $logfile 2>&1 |
| } |
| |
| test_stat(){ |
| log test_stat "$@" |
| stat "$1" >> $logfile 2>&1 |
| } |
| |
| cc_e(){ |
| eval printf '%s\\n' $CC_E |
| } |
| |
| cc_o(){ |
| eval printf '%s\\n' $CC_O |
| } |
| |
| as_o(){ |
| eval printf '%s\\n' $AS_O |
| } |
| |
| x86asm_o(){ |
| eval printf '%s\\n' $X86ASM_O |
| } |
| |
| ld_o(){ |
| eval printf '%s\\n' $LD_O |
| } |
| |
| hostcc_e(){ |
| eval printf '%s\\n' $HOSTCC_E |
| } |
| |
| hostcc_o(){ |
| eval printf '%s\\n' $HOSTCC_O |
| } |
| |
| nvcc_o(){ |
| eval printf '%s\\n' $NVCC_O |
| } |
| |
| test_cc(){ |
| log test_cc "$@" |
| cat > $TMPC |
| log_file $TMPC |
| test_cmd $cc $CPPFLAGS $CFLAGS "$@" $CC_C $(cc_o $TMPO) $TMPC |
| } |
| |
| test_cxx(){ |
| log test_cxx "$@" |
| cat > $TMPCPP |
| log_file $TMPCPP |
| test_cmd $cxx $CPPFLAGS $CFLAGS $CXXFLAGS "$@" $CXX_C -o $TMPO $TMPCPP |
| } |
| |
| test_objcc(){ |
| log test_objcc "$@" |
| cat > $TMPM |
| log_file $TMPM |
| test_cmd $objcc -Werror=missing-prototypes $CPPFLAGS $CFLAGS $OBJCFLAGS "$@" $OBJCC_C $(cc_o $TMPO) $TMPM |
| } |
| |
| test_nvcc(){ |
| log test_nvcc "$@" |
| cat > $TMPCU |
| log_file $TMPCU |
| tmpcu_=$TMPCU |
| tmpo_=$TMPO |
| [ -x "$(command -v cygpath)" ] && tmpcu_=$(cygpath -m $tmpcu_) && tmpo_=$(cygpath -m $tmpo_) |
| test_cmd $nvcc $nvccflags "$@" $NVCC_C $(nvcc_o $tmpo_) $tmpcu_ |
| } |
| |
| check_nvcc() { |
| log check_nvcc "$@" |
| name=$1 |
| shift 1 |
| disabled $name && return |
| disable $name |
| test_nvcc "$@" <<EOF && enable $name |
| extern "C" { |
| __global__ void hello(unsigned char *data) {} |
| } |
| EOF |
| } |
| |
| test_cpp(){ |
| log test_cpp "$@" |
| cat > $TMPC |
| log_file $TMPC |
| test_cmd $cc $CPPFLAGS $CFLAGS "$@" $(cc_e $TMPO) $TMPC |
| } |
| |
| test_as(){ |
| log test_as "$@" |
| cat > $TMPS |
| log_file $TMPS |
| test_cmd $as $CPPFLAGS $ASFLAGS "$@" $AS_C $(as_o $TMPO) $TMPS |
| } |
| |
| test_x86asm(){ |
| log test_x86asm "$@" |
| echo "$1" > $TMPASM |
| log_file $TMPASM |
| shift |
| test_cmd $x86asmexe $X86ASMFLAGS -Werror "$@" $(x86asm_o $TMPO) $TMPASM |
| } |
| |
| check_cmd(){ |
| log check_cmd "$@" |
| cmd=$1 |
| disabled $cmd && return |
| disable $cmd |
| test_cmd $@ && enable $cmd |
| } |
| |
| check_as(){ |
| log check_as "$@" |
| name=$1 |
| code=$2 |
| shift 2 |
| disable $name |
| test_as $@ <<EOF && enable $name |
| $code |
| EOF |
| } |
| |
| check_inline_asm(){ |
| log check_inline_asm "$@" |
| name="$1" |
| code="$2" |
| shift 2 |
| disable $name |
| test_cc "$@" <<EOF && enable $name |
| void foo(void){ __asm__ volatile($code); } |
| EOF |
| } |
| |
| check_inline_asm_flags(){ |
| log check_inline_asm_flags "$@" |
| name="$1" |
| code="$2" |
| flags='' |
| shift 2 |
| while [ "$1" != "" ]; do |
| append flags $1 |
| shift |
| done; |
| disable $name |
| cat > $TMPC <<EOF |
| void foo(void){ __asm__ volatile($code); } |
| EOF |
| log_file $TMPC |
| test_cmd $cc $CPPFLAGS $CFLAGS $flags "$@" $CC_C $(cc_o $TMPO) $TMPC && |
| enable $name && add_cflags $flags && add_asflags $flags && add_ldflags $flags |
| } |
| |
| check_insn(){ |
| log check_insn "$@" |
| check_inline_asm ${1}_inline "\"$2\"" |
| check_as ${1}_external "$2" |
| } |
| |
| check_x86asm(){ |
| log check_x86asm "$@" |
| name=$1 |
| shift |
| disable $name |
| test_x86asm "$@" && enable $name |
| } |
| |
| test_ld(){ |
| log test_ld "$@" |
| type=$1 |
| shift 1 |
| flags=$(filter_out '-l*|*.so' $@) |
| libs=$(filter '-l*|*.so' $@) |
| test_$type $($cflags_filter $flags) || return |
| flags=$($ldflags_filter $flags) |
| libs=$($ldflags_filter $libs) |
| test_cmd $ld $LDFLAGS $LDEXEFLAGS $flags $(ld_o $TMPE) $TMPO $libs $extralibs |
| } |
| |
| check_ld(){ |
| log check_ld "$@" |
| type=$1 |
| name=$2 |
| shift 2 |
| disable $name |
| test_ld $type $@ && enable $name |
| } |
| |
| print_include(){ |
| hdr=$1 |
| test "${hdr%.h}" = "${hdr}" && |
| echo "#include $hdr" || |
| echo "#include <$hdr>" |
| } |
| |
| test_code(){ |
| log test_code "$@" |
| check=$1 |
| headers=$2 |
| code=$3 |
| shift 3 |
| { |
| for hdr in $headers; do |
| print_include $hdr |
| done |
| echo "int main(void) { $code; return 0; }" |
| } | test_$check "$@" |
| } |
| |
| check_cppflags(){ |
| log check_cppflags "$@" |
| test_cpp "$@" <<EOF && append CPPFLAGS "$@" |
| #include <stdlib.h> |
| EOF |
| } |
| |
| test_cflags(){ |
| log test_cflags "$@" |
| set -- $($cflags_filter "$@") |
| test_cc "$@" <<EOF |
| int x; |
| EOF |
| } |
| |
| check_cflags(){ |
| log check_cflags "$@" |
| test_cflags "$@" && add_cflags "$@" |
| } |
| |
| check_cxxflags(){ |
| log check_cxxflags "$@" |
| set -- $($cflags_filter "$@") |
| test_cxx "$@" <<EOF && append CXXFLAGS "$@" |
| int x; |
| EOF |
| } |
| |
| test_objcflags(){ |
| log test_objcflags "$@" |
| set -- $($objcflags_filter "$@") |
| test_objcc "$@" <<EOF |
| int x; |
| EOF |
| } |
| |
| check_objcflags(){ |
| log check_objcflags "$@" |
| test_objcflags "$@" && add_objcflags "$@" |
| } |
| |
| test_ldflags(){ |
| log test_ldflags "$@" |
| set -- $($ldflags_filter "$@") |
| test_ld "cc" "$@" <<EOF |
| int main(void){ return 0; } |
| EOF |
| } |
| |
| check_ldflags(){ |
| log check_ldflags "$@" |
| test_ldflags "$@" && add_ldflags "$@" |
| } |
| |
| test_stripflags(){ |
| log test_stripflags "$@" |
| # call test_cc to get a fresh TMPO |
| test_cc <<EOF |
| int main(void) { return 0; } |
| EOF |
| test_cmd $strip $ASMSTRIPFLAGS "$@" $TMPO |
| } |
| |
| check_stripflags(){ |
| log check_stripflags "$@" |
| test_stripflags "$@" && add_stripflags "$@" |
| } |
| |
| check_headers(){ |
| log check_headers "$@" |
| headers=$1 |
| shift |
| disable_sanitized $headers |
| { |
| for hdr in $headers; do |
| print_include $hdr |
| done |
| echo "int x;" |
| } | test_cpp "$@" && enable_sanitized $headers |
| } |
| |
| check_header_objcc(){ |
| log check_header_objcc "$@" |
| rm -f -- "$TMPO" |
| header=$1 |
| shift |
| disable_sanitized $header |
| { |
| echo "#include <$header>" |
| echo "int main(void) { return 0; }" |
| } | test_objcc && test_stat "$TMPO" && enable_sanitized $header |
| } |
| |
| check_apple_framework(){ |
| log check_apple_framework "$@" |
| framework="$1" |
| name="$(tolower $framework)" |
| header="${framework}/${framework}.h" |
| disable $name |
| check_header_objcc $header && |
| enable $name && eval ${name}_extralibs='"-framework $framework"' |
| } |
| |
| check_func(){ |
| log check_func "$@" |
| func=$1 |
| shift |
| disable $func |
| test_ld "cc" "$@" <<EOF && enable $func |
| extern int $func(); |
| int main(void){ $func(); } |
| EOF |
| } |
| |
| check_complexfunc(){ |
| log check_complexfunc "$@" |
| func=$1 |
| narg=$2 |
| shift 2 |
| test $narg = 2 && args="f, g" || args="f * I" |
| disable $func |
| test_ld "cc" "$@" <<EOF && enable $func |
| #include <complex.h> |
| #include <math.h> |
| float foo(complex float f, complex float g) { return $func($args); } |
| int main(void){ return (int) foo; } |
| EOF |
| } |
| |
| check_mathfunc(){ |
| log check_mathfunc "$@" |
| func=$1 |
| narg=$2 |
| shift 2 |
| test $narg = 2 && args="f, g" || args="f" |
| disable $func |
| test_ld "cc" "$@" <<EOF && enable $func |
| #include <math.h> |
| float foo(float f, float g) { return $func($args); } |
| int main(void){ return (int) foo; } |
| EOF |
| } |
| |
| check_func_headers(){ |
| log check_func_headers "$@" |
| headers=$1 |
| funcs=$2 |
| shift 2 |
| { |
| for hdr in $headers; do |
| print_include $hdr |
| done |
| echo "#include <stdint.h>" |
| for func in $funcs; do |
| echo "long check_$func(void) { return (long) $func; }" |
| done |
| echo "int main(void) { int ret = 0;" |
| # LTO could optimize out the test functions without this |
| for func in $funcs; do |
| echo " ret |= ((intptr_t)check_$func) & 0xFFFF;" |
| done |
| echo "return ret; }" |
| } | test_ld "cc" "$@" && enable $funcs && enable_sanitized $headers |
| } |
| |
| check_class_headers_cpp(){ |
| log check_class_headers_cpp "$@" |
| headers=$1 |
| classes=$2 |
| shift 2 |
| { |
| for hdr in $headers; do |
| echo "#include <$hdr>" |
| done |
| echo "int main(void) { " |
| i=1 |
| for class in $classes; do |
| echo "$class obj$i;" |
| i=$(expr $i + 1) |
| done |
| echo "return 0; }" |
| } | test_ld "cxx" "$@" && enable $funcs && enable_sanitized $headers |
| } |
| |
| test_cpp_condition(){ |
| log test_cpp_condition "$@" |
| header=$1 |
| condition=$2 |
| shift 2 |
| test_cpp "$@" <<EOF |
| #include <$header> |
| #if !($condition) |
| #error "unsatisfied condition: $condition" |
| #endif |
| EOF |
| } |
| |
| check_cpp_condition(){ |
| log check_cpp_condition "$@" |
| name=$1 |
| shift 1 |
| disable $name |
| test_cpp_condition "$@" && enable $name |
| } |
| |
| test_cflags_cc(){ |
| log test_cflags_cc "$@" |
| flags=$1 |
| header=$2 |
| condition=$3 |
| shift 3 |
| set -- $($cflags_filter "$flags") |
| test_cc "$@" <<EOF |
| #include <$header> |
| #if !($condition) |
| #error "unsatisfied condition: $condition" |
| #endif |
| EOF |
| } |
| |
| check_lib(){ |
| log check_lib "$@" |
| name="$1" |
| headers="$2" |
| funcs="$3" |
| shift 3 |
| disable $name |
| check_func_headers "$headers" "$funcs" "$@" && |
| enable $name && eval ${name}_extralibs="\$@" |
| } |
| |
| check_lib_cpp(){ |
| log check_lib_cpp "$@" |
| name="$1" |
| headers="$2" |
| classes="$3" |
| shift 3 |
| disable $name |
| check_class_headers_cpp "$headers" "$classes" "$@" && |
| enable $name && eval ${name}_extralibs="\$@" |
| } |
| |
| test_pkg_config(){ |
| log test_pkg_config "$@" |
| name="$1" |
| pkg_version="$2" |
| pkg="${2%% *}" |
| headers="$3" |
| funcs="$4" |
| shift 4 |
| disable $name |
| test_cmd $pkg_config --exists --print-errors $pkg_version || return |
| pkg_cflags=$($pkg_config --cflags $pkg_config_flags $pkg) |
| pkg_libs=$($pkg_config --libs $pkg_config_flags $pkg) |
| check_func_headers "$headers" "$funcs" $pkg_cflags $pkg_libs "$@" && |
| enable $name && |
| set_sanitized "${name}_cflags" $pkg_cflags && |
| set_sanitized "${name}_extralibs" $pkg_libs |
| } |
| |
| check_pkg_config(){ |
| log check_pkg_config "$@" |
| name="$1" |
| test_pkg_config "$@" && |
| eval add_cflags \$${name}_cflags |
| } |
| |
| test_exec(){ |
| test_ld "cc" "$@" && { enabled cross_compile || $TMPE >> $logfile 2>&1; } |
| } |
| |
| check_exec_crash(){ |
| log check_exec_crash "$@" |
| code=$(cat) |
| |
| # exit() is not async signal safe. _Exit (C99) and _exit (POSIX) |
| # are safe but may not be available everywhere. Thus we use |
| # raise(SIGTERM) instead. The check is run in a subshell so we |
| # can redirect the "Terminated" message from the shell. SIGBUS |
| # is not defined by standard C so it is used conditionally. |
| |
| (test_exec "$@") >> $logfile 2>&1 <<EOF |
| #include <signal.h> |
| static void sighandler(int sig){ |
| raise(SIGTERM); |
| } |
| int foo(void){ |
| $code |
| } |
| int (*func_ptr)(void) = foo; |
| int main(void){ |
| signal(SIGILL, sighandler); |
| signal(SIGFPE, sighandler); |
| signal(SIGSEGV, sighandler); |
| #ifdef SIGBUS |
| signal(SIGBUS, sighandler); |
| #endif |
| return func_ptr(); |
| } |
| EOF |
| } |
| |
| check_type(){ |
| log check_type "$@" |
| headers=$1 |
| type=$2 |
| shift 2 |
| disable_sanitized "$type" |
| test_code cc "$headers" "$type v" "$@" && enable_sanitized "$type" |
| } |
| |
| check_struct(){ |
| log check_struct "$@" |
| headers=$1 |
| struct=$2 |
| member=$3 |
| shift 3 |
| disable_sanitized "${struct}_${member}" |
| test_code cc "$headers" "const void *p = &(($struct *)0)->$member" "$@" && |
| enable_sanitized "${struct}_${member}" |
| } |
| |
| check_builtin(){ |
| log check_builtin "$@" |
| name=$1 |
| headers=$2 |
| builtin=$3 |
| shift 3 |
| disable "$name" |
| test_code ld "$headers" "$builtin" "cc" "$@" && enable "$name" |
| } |
| |
| check_compile_assert(){ |
| log check_compile_assert "$@" |
| name=$1 |
| headers=$2 |
| condition=$3 |
| shift 3 |
| disable "$name" |
| test_code cc "$headers" "char c[2 * !!($condition) - 1]" "$@" && enable "$name" |
| } |
| |
| check_cc(){ |
| log check_cc "$@" |
| name=$1 |
| shift |
| disable "$name" |
| test_code cc "$@" && enable "$name" |
| } |
| |
| require(){ |
| log require "$@" |
| name_version="$1" |
| name="${1%% *}" |
| shift |
| check_lib $name "$@" || die "ERROR: $name_version not found" |
| } |
| |
| require_cc(){ |
| log require_cc "$@" |
| name="$1" |
| check_cc "$@" || die "ERROR: $name failed" |
| } |
| |
| require_cpp(){ |
| log require_cpp "$@" |
| name_version="$1" |
| name="${1%% *}" |
| shift |
| check_lib_cpp "$name" "$@" || die "ERROR: $name_version not found" |
| } |
| |
| require_headers(){ |
| log require_headers "$@" |
| headers="$1" |
| check_headers "$@" || die "ERROR: $headers not found" |
| } |
| |
| require_cpp_condition(){ |
| log require_cpp_condition "$@" |
| condition="$3" |
| check_cpp_condition "$@" || die "ERROR: $condition not satisfied" |
| } |
| |
| require_pkg_config(){ |
| log require_pkg_config "$@" |
| pkg_version="$2" |
| check_pkg_config "$@" || die "ERROR: $pkg_version not found using pkg-config$pkg_config_fail_message" |
| } |
| |
| test_host_cc(){ |
| log test_host_cc "$@" |
| cat > $TMPC |
| log_file $TMPC |
| test_cmd $host_cc $host_cflags "$@" $HOSTCC_C $(hostcc_o $TMPO) $TMPC |
| } |
| |
| test_host_cpp(){ |
| log test_host_cpp "$@" |
| cat > $TMPC |
| log_file $TMPC |
| test_cmd $host_cc $host_cppflags $host_cflags "$@" $(hostcc_e $TMPO) $TMPC |
| } |
| |
| check_host_cppflags(){ |
| log check_host_cppflags "$@" |
| test_host_cpp "$@" <<EOF && append host_cppflags "$@" |
| #include <stdlib.h> |
| EOF |
| } |
| |
| check_host_cflags(){ |
| log check_host_cflags "$@" |
| set -- $($host_cflags_filter "$@") |
| test_host_cc "$@" <<EOF && append host_cflags "$@" |
| int x; |
| EOF |
| } |
| |
| test_host_cpp_condition(){ |
| log test_host_cpp_condition "$@" |
| header=$1 |
| condition=$2 |
| shift 2 |
| test_host_cpp "$@" <<EOF |
| #include <$header> |
| #if !($condition) |
| #error "unsatisfied condition: $condition" |
| #endif |
| EOF |
| } |
| |
| check_host_cpp_condition(){ |
| log check_host_cpp_condition "$@" |
| name=$1 |
| shift 1 |
| disable $name |
| test_host_cpp_condition "$@" && enable $name |
| } |
| |
| cp_if_changed(){ |
| cmp -s "$1" "$2" && { test "$quiet" != "yes" && echo "$2 is unchanged"; } && return |
| mkdir -p "$(dirname $2)" |
| cp -f "$1" "$2" |
| } |
| |
| # CONFIG_LIST contains configurable options, while HAVE_LIST is for |
| # system-dependent things. |
| |
| AVCODEC_COMPONENTS=" |
| bsfs |
| decoders |
| encoders |
| hwaccels |
| parsers |
| " |
| |
| AVDEVICE_COMPONENTS=" |
| indevs |
| outdevs |
| " |
| |
| AVFILTER_COMPONENTS=" |
| filters |
| " |
| |
| AVFORMAT_COMPONENTS=" |
| demuxers |
| muxers |
| protocols |
| " |
| |
| COMPONENT_LIST=" |
| $AVCODEC_COMPONENTS |
| $AVDEVICE_COMPONENTS |
| $AVFILTER_COMPONENTS |
| $AVFORMAT_COMPONENTS |
| " |
| |
| EXAMPLE_LIST=" |
| avio_list_dir_example |
| avio_reading_example |
| decode_audio_example |
| decode_video_example |
| demuxing_decoding_example |
| encode_audio_example |
| encode_video_example |
| extract_mvs_example |
| filter_audio_example |
| filtering_audio_example |
| filtering_video_example |
| http_multiclient_example |
| hw_decode_example |
| metadata_example |
| muxing_example |
| qsvdec_example |
| remuxing_example |
| resampling_audio_example |
| scaling_video_example |
| transcode_aac_example |
| transcoding_example |
| vaapi_encode_example |
| vaapi_transcode_example |
| " |
| |
| EXTERNAL_AUTODETECT_LIBRARY_LIST=" |
| alsa |
| appkit |
| avfoundation |
| bzlib |
| coreimage |
| iconv |
| libxcb |
| libxcb_shm |
| libxcb_shape |
| libxcb_xfixes |
| lzma |
| mediafoundation |
| schannel |
| sdl2 |
| securetransport |
| sndio |
| xlib |
| zlib |
| " |
| |
| EXTERNAL_LIBRARY_GPL_LIST=" |
| avisynth |
| frei0r |
| libcdio |
| libdavs2 |
| librubberband |
| libvidstab |
| libx264 |
| libx265 |
| libxavs |
| libxavs2 |
| libxvid |
| " |
| |
| EXTERNAL_LIBRARY_NONFREE_LIST=" |
| decklink |
| libfdk_aac |
| openssl |
| libtls |
| " |
| |
| EXTERNAL_LIBRARY_VERSION3_LIST=" |
| gmp |
| libaribb24 |
| liblensfun |
| libopencore_amrnb |
| libopencore_amrwb |
| libvo_amrwbenc |
| mbedtls |
| rkmpp |
| " |
| |
| EXTERNAL_LIBRARY_GPLV3_LIST=" |
| libsmbclient |
| " |
| |
| EXTERNAL_LIBRARY_LIST=" |
| $EXTERNAL_LIBRARY_GPL_LIST |
| $EXTERNAL_LIBRARY_NONFREE_LIST |
| $EXTERNAL_LIBRARY_VERSION3_LIST |
| $EXTERNAL_LIBRARY_GPLV3_LIST |
| chromaprint |
| gcrypt |
| gnutls |
| jni |
| ladspa |
| libaom |
| libass |
| libbluray |
| libbs2b |
| libcaca |
| libcelt |
| libcodec2 |
| libdav1d |
| libdc1394 |
| libdrm |
| libflite |
| libfontconfig |
| libfreetype |
| libfribidi |
| libglslang |
| libgme |
| libgsm |
| libiec61883 |
| libilbc |
| libjack |
| libklvanc |
| libkvazaar |
| libmodplug |
| libmp3lame |
| libmysofa |
| libopencv |
| libopenh264 |
| libopenjpeg |
| libopenmpt |
| libopenvino |
| libopus |
| libpulse |
| librabbitmq |
| librav1e |
| librsvg |
| librtmp |
| libshine |
| libsmbclient |
| libsnappy |
| libsoxr |
| libspeex |
| libsrt |
| libssh |
| libsvtav1 |
| libtensorflow |
| libtesseract |
| libtheora |
| libtwolame |
| libuavs3d |
| libv4l2 |
| libvmaf |
| libvorbis |
| libvpx |
| libwebp |
| libxml2 |
| libzimg |
| libzmq |
| libzvbi |
| lv2 |
| mediacodec |
| openal |
| opengl |
| pocketsphinx |
| vapoursynth |
| " |
| |
| HWACCEL_AUTODETECT_LIBRARY_LIST=" |
| amf |
| audiotoolbox |
| crystalhd |
| cuda |
| cuda_llvm |
| cuvid |
| d3d11va |
| dxva2 |
| ffnvcodec |
| nvdec |
| nvenc |
| vaapi |
| vdpau |
| videotoolbox |
| v4l2_m2m |
| xvmc |
| " |
| |
| # catchall list of things that require external libs to link |
| EXTRALIBS_LIST=" |
| cpu_init |
| cws2fws |
| " |
| |
| HWACCEL_LIBRARY_NONFREE_LIST=" |
| cuda_nvcc |
| cuda_sdk |
| libnpp |
| " |
| |
| HWACCEL_LIBRARY_LIST=" |
| $HWACCEL_LIBRARY_NONFREE_LIST |
| libmfx |
| mmal |
| omx |
| opencl |
| vulkan |
| " |
| |
| DOCUMENT_LIST=" |
| doc |
| htmlpages |
| manpages |
| podpages |
| txtpages |
| " |
| |
| FEATURE_LIST=" |
| ftrapv |
| gray |
| hardcoded_tables |
| omx_rpi |
| runtime_cpudetect |
| safe_bitstream_reader |
| shared |
| small |
| static |
| swscale_alpha |
| " |
| |
| # this list should be kept in linking order |
| LIBRARY_LIST=" |
| avdevice |
| avfilter |
| swscale |
| postproc |
| avformat |
| avcodec |
| swresample |
| avresample |
| avutil |
| " |
| |
| LICENSE_LIST=" |
| gpl |
| nonfree |
| version3 |
| " |
| |
| PROGRAM_LIST=" |
| ffplay |
| ffprobe |
| ffmpeg |
| " |
| |
| SUBSYSTEM_LIST=" |
| dct |
| dwt |
| error_resilience |
| faan |
| fast_unaligned |
| fft |
| lsp |
| lzo |
| mdct |
| pixelutils |
| network |
| rdft |
| " |
| |
| # COMPONENT_LIST needs to come last to ensure correct dependency checking |
| CONFIG_LIST=" |
| $DOCUMENT_LIST |
| $EXAMPLE_LIST |
| $EXTERNAL_LIBRARY_LIST |
| $EXTERNAL_AUTODETECT_LIBRARY_LIST |
| $HWACCEL_LIBRARY_LIST |
| $HWACCEL_AUTODETECT_LIBRARY_LIST |
| $FEATURE_LIST |
| $LICENSE_LIST |
| $LIBRARY_LIST |
| $PROGRAM_LIST |
| $SUBSYSTEM_LIST |
| autodetect |
| fontconfig |
| large_tests |
| linux_perf |
| memory_poisoning |
| neon_clobber_test |
| ossfuzz |
| pic |
| thumb |
| valgrind_backtrace |
| xmm_clobber_test |
| $COMPONENT_LIST |
| " |
| |
| THREADS_LIST=" |
| pthreads |
| os2threads |
| w32threads |
| " |
| |
| ATOMICS_LIST=" |
| atomics_gcc |
| atomics_suncc |
| atomics_win32 |
| " |
| |
| AUTODETECT_LIBS=" |
| $EXTERNAL_AUTODETECT_LIBRARY_LIST |
| $HWACCEL_AUTODETECT_LIBRARY_LIST |
| $THREADS_LIST |
| " |
| |
| ARCH_LIST=" |
| aarch64 |
| alpha |
| arm |
| avr32 |
| avr32_ap |
| avr32_uc |
| bfin |
| ia64 |
| m68k |
| mips |
| mips64 |
| parisc |
| ppc |
| ppc64 |
| s390 |
| sh4 |
| sparc |
| sparc64 |
| tilegx |
| tilepro |
| tomi |
| x86 |
| x86_32 |
| x86_64 |
| " |
| |
| ARCH_EXT_LIST_ARM=" |
| armv5te |
| armv6 |
| armv6t2 |
| armv8 |
| neon |
| vfp |
| vfpv3 |
| setend |
| " |
| |
| ARCH_EXT_LIST_MIPS=" |
| mipsfpu |
| mips32r2 |
| mips32r5 |
| mips64r2 |
| mips32r6 |
| mips64r6 |
| mipsdsp |
| mipsdspr2 |
| msa |
| msa2 |
| " |
| |
| ARCH_EXT_LIST_LOONGSON=" |
| loongson2 |
| loongson3 |
| mmi |
| " |
| |
| ARCH_EXT_LIST_X86_SIMD=" |
| aesni |
| amd3dnow |
| amd3dnowext |
| avx |
| avx2 |
| avx512 |
| fma3 |
| fma4 |
| mmx |
| mmxext |
| sse |
| sse2 |
| sse3 |
| sse4 |
| sse42 |
| ssse3 |
| xop |
| " |
| |
| ARCH_EXT_LIST_PPC=" |
| altivec |
| dcbzl |
| ldbrx |
| power8 |
| ppc4xx |
| vsx |
| " |
| |
| ARCH_EXT_LIST_X86=" |
| $ARCH_EXT_LIST_X86_SIMD |
| cpunop |
| i686 |
| " |
| |
| ARCH_EXT_LIST=" |
| $ARCH_EXT_LIST_ARM |
| $ARCH_EXT_LIST_PPC |
| $ARCH_EXT_LIST_X86 |
| $ARCH_EXT_LIST_MIPS |
| $ARCH_EXT_LIST_LOONGSON |
| " |
| |
| ARCH_FEATURES=" |
| aligned_stack |
| fast_64bit |
| fast_clz |
| fast_cmov |
| local_aligned |
| simd_align_16 |
| simd_align_32 |
| simd_align_64 |
| " |
| |
| BUILTIN_LIST=" |
| atomic_cas_ptr |
| machine_rw_barrier |
| MemoryBarrier |
| mm_empty |
| rdtsc |
| sem_timedwait |
| sync_val_compare_and_swap |
| " |
| HAVE_LIST_CMDLINE=" |
| inline_asm |
| symver |
| x86asm |
| " |
| |
| HAVE_LIST_PUB=" |
| bigendian |
| fast_unaligned |
| " |
| |
| HEADERS_LIST=" |
| arpa_inet_h |
| asm_types_h |
| cdio_paranoia_h |
| cdio_paranoia_paranoia_h |
| cuda_h |
| dispatch_dispatch_h |
| dev_bktr_ioctl_bt848_h |
| dev_bktr_ioctl_meteor_h |
| dev_ic_bt8xx_h |
| dev_video_bktr_ioctl_bt848_h |
| dev_video_meteor_ioctl_meteor_h |
| direct_h |
| dirent_h |
| dxgidebug_h |
| dxva_h |
| ES2_gl_h |
| gsm_h |
| io_h |
| linux_dma_buf_h |
| linux_perf_event_h |
| machine_ioctl_bt848_h |
| machine_ioctl_meteor_h |
| malloc_h |
| opencv2_core_core_c_h |
| OpenGL_gl3_h |
| poll_h |
| sys_param_h |
| sys_resource_h |
| sys_select_h |
| sys_soundcard_h |
| sys_time_h |
| sys_un_h |
| sys_videoio_h |
| termios_h |
| udplite_h |
| unistd_h |
| valgrind_valgrind_h |
| windows_h |
| winsock2_h |
| " |
| |
| INTRINSICS_LIST=" |
| intrinsics_neon |
| " |
| |
| COMPLEX_FUNCS=" |
| cabs |
| cexp |
| " |
| |
| MATH_FUNCS=" |
| atanf |
| atan2f |
| cbrt |
| cbrtf |
| copysign |
| cosf |
| erf |
| exp2 |
| exp2f |
| expf |
| hypot |
| isfinite |
| isinf |
| isnan |
| ldexpf |
| llrint |
| llrintf |
| log2 |
| log2f |
| log10f |
| lrint |
| lrintf |
| powf |
| rint |
| round |
| roundf |
| sinf |
| trunc |
| truncf |
| " |
| |
| SYSTEM_FEATURES=" |
| dos_paths |
| libc_msvcrt |
| MMAL_PARAMETER_VIDEO_MAX_NUM_CALLBACKS |
| section_data_rel_ro |
| threads |
| uwp |
| winrt |
| " |
| |
| SYSTEM_FUNCS=" |
| access |
| aligned_malloc |
| arc4random |
| clock_gettime |
| closesocket |
| CommandLineToArgvW |
| fcntl |
| getaddrinfo |
| gethrtime |
| getopt |
| GetModuleHandle |
| GetProcessAffinityMask |
| GetProcessMemoryInfo |
| GetProcessTimes |
| getrusage |
| GetStdHandle |
| GetSystemTimeAsFileTime |
| gettimeofday |
| glob |
| glXGetProcAddress |
| gmtime_r |
| inet_aton |
| isatty |
| kbhit |
| localtime_r |
| lstat |
| lzo1x_999_compress |
| mach_absolute_time |
| MapViewOfFile |
| memalign |
| mkstemp |
| mmap |
| mprotect |
| nanosleep |
| PeekNamedPipe |
| posix_memalign |
| pthread_cancel |
| sched_getaffinity |
| SecItemImport |
| SetConsoleTextAttribute |
| SetConsoleCtrlHandler |
| SetDllDirectory |
| setmode |
| setrlimit |
| Sleep |
| strerror_r |
| sysconf |
| sysctl |
| usleep |
| UTGetOSTypeFromString |
| VirtualAlloc |
| wglGetProcAddress |
| " |
| |
| SYSTEM_LIBRARIES=" |
| bcrypt |
| vaapi_drm |
| vaapi_x11 |
| vdpau_x11 |
| " |
| |
| TOOLCHAIN_FEATURES=" |
| as_arch_directive |
| as_dn_directive |
| as_fpu_directive |
| as_func |
| as_object_arch |
| asm_mod_q |
| blocks_extension |
| ebp_available |
| ebx_available |
| gnu_as |
| gnu_windres |
| ibm_asm |
| inline_asm_direct_symbol_refs |
| inline_asm_labels |
| inline_asm_nonlocal_labels |
| pragma_deprecated |
| rsync_contimeout |
| symver_asm_label |
| symver_gnu_asm |
| vfp_args |
| xform_asm |
| xmm_clobbers |
| " |
| |
| TYPES_LIST=" |
| kCMVideoCodecType_HEVC |
| kCVPixelFormatType_420YpCbCr10BiPlanarVideoRange |
| kCVImageBufferTransferFunction_SMPTE_ST_2084_PQ |
| kCVImageBufferTransferFunction_ITU_R_2100_HLG |
| kCVImageBufferTransferFunction_Linear |
| socklen_t |
| struct_addrinfo |
| struct_group_source_req |
| struct_ip_mreq_source |
| struct_ipv6_mreq |
| struct_msghdr_msg_flags |
| struct_pollfd |
| struct_rusage_ru_maxrss |
| struct_sctp_event_subscribe |
| struct_sockaddr_in6 |
| struct_sockaddr_sa_len |
| struct_sockaddr_storage |
| struct_stat_st_mtim_tv_nsec |
| struct_v4l2_frmivalenum_discrete |
| " |
| |
| HAVE_LIST=" |
| $ARCH_EXT_LIST |
| $(add_suffix _external $ARCH_EXT_LIST) |
| $(add_suffix _inline $ARCH_EXT_LIST) |
| $ARCH_FEATURES |
| $BUILTIN_LIST |
| $COMPLEX_FUNCS |
| $HAVE_LIST_CMDLINE |
| $HAVE_LIST_PUB |
| $HEADERS_LIST |
| $INTRINSICS_LIST |
| $MATH_FUNCS |
| $SYSTEM_FEATURES |
| $SYSTEM_FUNCS |
| $SYSTEM_LIBRARIES |
| $THREADS_LIST |
| $TOOLCHAIN_FEATURES |
| $TYPES_LIST |
| libdrm_getfb2 |
| makeinfo |
| makeinfo_html |
| opencl_d3d11 |
| opencl_drm_arm |
| opencl_drm_beignet |
| opencl_dxva2 |
| opencl_vaapi_beignet |
| opencl_vaapi_intel_media |
| perl |
| pod2man |
| texi2html |
| " |
| |
| # options emitted with CONFIG_ prefix but not available on the command line |
| CONFIG_EXTRA=" |
| aandcttables |
| ac3dsp |
| adts_header |
| atsc_a53 |
| audio_frame_queue |
| audiodsp |
| blockdsp |
| bswapdsp |
| cabac |
| cbs |
| cbs_av1 |
| cbs_h264 |
| cbs_h265 |
| cbs_jpeg |
| cbs_mpeg2 |
| cbs_vp9 |
| dirac_parse |
| dnn |
| dvprofile |
| exif |
| faandct |
| faanidct |
| fdctdsp |
| flacdsp |
| fmtconvert |
| frame_thread_encoder |
| g722dsp |
| golomb |
| gplv3 |
| h263dsp |
| h264chroma |
| h264dsp |
| h264parse |
| h264pred |
| h264qpel |
| hevcparse |
| hpeldsp |
| huffman |
| huffyuvdsp |
| huffyuvencdsp |
| idctdsp |
| iirfilter |
| mdct15 |
| intrax8 |
| iso_media |
| ividsp |
| jpegtables |
| lgplv3 |
| libx262 |
| llauddsp |
| llviddsp |
| llvidencdsp |
| lpc |
| lzf |
| me_cmp |
| mpeg_er |
| mpegaudio |
| mpegaudiodsp |
| mpegaudioheader |
| mpegvideo |
| mpegvideoenc |
| mss34dsp |
| pixblockdsp |
| qpeldsp |
| qsv |
| qsvdec |
| qsvenc |
| qsvvpp |
| rangecoder |
| riffdec |
| riffenc |
| rtpdec |
| rtpenc_chain |
| rv34dsp |
| scene_sad |
| sinewin |
| snappy |
| srtp |
| startcode |
| texturedsp |
| texturedspenc |
| tpeldsp |
| vaapi_1 |
| vaapi_encode |
| vc1dsp |
| videodsp |
| vp3dsp |
| vp56dsp |
| vp8dsp |
| wma_freqs |
| wmv2dsp |
| " |
| |
| CMDLINE_SELECT=" |
| $ARCH_EXT_LIST |
| $CONFIG_LIST |
| $HAVE_LIST_CMDLINE |
| $THREADS_LIST |
| asm |
| cross_compile |
| debug |
| extra_warnings |
| logging |
| lto |
| optimizations |
| rpath |
| stripping |
| " |
| |
| PATHS_LIST=" |
| bindir |
| datadir |
| docdir |
| incdir |
| libdir |
| mandir |
| pkgconfigdir |
| prefix |
| shlibdir |
| install_name_dir |
| " |
| |
| CMDLINE_SET=" |
| $PATHS_LIST |
| ar |
| arch |
| as |
| assert_level |
| build_suffix |
| cc |
| objcc |
| cpu |
| cross_prefix |
| custom_allocator |
| cxx |
| dep_cc |
| doxygen |
| env |
| extra_version |
| gas |
| host_cc |
| host_cflags |
| host_extralibs |
| host_ld |
| host_ldflags |
| host_os |
| ignore_tests |
| install |
| ld |
| ln_s |
| logfile |
| malloc_prefix |
| nm |
| optflags |
| nvcc |
| nvccflags |
| pkg_config |
| pkg_config_flags |
| progs_suffix |
| random_seed |
| ranlib |
| samples |
| strip |
| sws_max_filter_size |
| sysinclude |
| sysroot |
| target_exec |
| target_os |
| target_path |
| target_samples |
| tempprefix |
| toolchain |
| valgrind |
| windres |
| x86asmexe |
| " |
| |
| CMDLINE_APPEND=" |
| extra_cflags |
| extra_cxxflags |
| extra_objcflags |
| host_cppflags |
| " |
| |
| # code dependency declarations |
| |
| # architecture extensions |
| |
| armv5te_deps="arm" |
| armv6_deps="arm" |
| armv6t2_deps="arm" |
| armv8_deps="aarch64" |
| neon_deps_any="aarch64 arm" |
| intrinsics_neon_deps="neon" |
| vfp_deps_any="aarch64 arm" |
| vfpv3_deps="vfp" |
| setend_deps="arm" |
| |
| map 'eval ${v}_inline_deps=inline_asm' $ARCH_EXT_LIST_ARM |
| |
| altivec_deps="ppc" |
| dcbzl_deps="ppc" |
| ldbrx_deps="ppc" |
| ppc4xx_deps="ppc" |
| vsx_deps="altivec" |
| power8_deps="vsx" |
| |
| loongson2_deps="mips" |
| loongson3_deps="mips" |
| mips32r2_deps="mips" |
| mips32r5_deps="mips" |
| mips32r6_deps="mips" |
| mips64r2_deps="mips" |
| mips64r6_deps="mips" |
| mipsfpu_deps="mips" |
| mipsdsp_deps="mips" |
| mipsdspr2_deps="mips" |
| mmi_deps_any="loongson2 loongson3" |
| msa_deps="mipsfpu" |
| msa2_deps="msa" |
| |
| cpunop_deps="i686" |
| x86_64_select="i686" |
| x86_64_suggest="fast_cmov" |
| |
| amd3dnow_deps="mmx" |
| amd3dnowext_deps="amd3dnow" |
| i686_deps="x86" |
| mmx_deps="x86" |
| mmxext_deps="mmx" |
| sse_deps="mmxext" |
| sse2_deps="sse" |
| sse3_deps="sse2" |
| ssse3_deps="sse3" |
| sse4_deps="ssse3" |
| sse42_deps="sse4" |
| aesni_deps="sse42" |
| avx_deps="sse42" |
| xop_deps="avx" |
| fma3_deps="avx" |
| fma4_deps="avx" |
| avx2_deps="avx" |
| avx512_deps="avx2" |
| |
| mmx_external_deps="x86asm" |
| mmx_inline_deps="inline_asm x86" |
| mmx_suggest="mmx_external mmx_inline" |
| |
| for ext in $(filter_out mmx $ARCH_EXT_LIST_X86_SIMD); do |
| eval dep=\$${ext}_deps |
| eval ${ext}_external_deps='"${dep}_external"' |
| eval ${ext}_inline_deps='"${dep}_inline"' |
| eval ${ext}_suggest='"${ext}_external ${ext}_inline"' |
| done |
| |
| aligned_stack_if_any="aarch64 ppc x86" |
| fast_64bit_if_any="aarch64 alpha ia64 mips64 parisc64 ppc64 sparc64 x86_64" |
| fast_clz_if_any="aarch64 alpha avr32 mips ppc x86" |
| fast_unaligned_if_any="aarch64 ppc x86" |
| simd_align_16_if_any="altivec neon sse" |
| simd_align_32_if_any="avx" |
| simd_align_64_if_any="avx512" |
| |
| # system capabilities |
| linux_perf_deps="linux_perf_event_h" |
| symver_if_any="symver_asm_label symver_gnu_asm" |
| valgrind_backtrace_conflict="optimizations" |
| valgrind_backtrace_deps="valgrind_valgrind_h" |
| |
| # threading support |
| atomics_gcc_if="sync_val_compare_and_swap" |
| atomics_suncc_if="atomic_cas_ptr machine_rw_barrier" |
| atomics_win32_if="MemoryBarrier" |
| atomics_native_if_any="$ATOMICS_LIST" |
| w32threads_deps="atomics_native" |
| threads_if_any="$THREADS_LIST" |
| |
| # subsystems |
| cbs_av1_select="cbs" |
| cbs_h264_select="cbs" |
| cbs_h265_select="cbs" |
| cbs_jpeg_select="cbs" |
| cbs_mpeg2_select="cbs" |
| cbs_vp9_select="cbs" |
| dct_select="rdft" |
| dirac_parse_select="golomb" |
| dnn_suggest="libtensorflow libopenvino" |
| dnn_deps="swscale" |
| error_resilience_select="me_cmp" |
| faandct_deps="faan" |
| faandct_select="fdctdsp" |
| faanidct_deps="faan" |
| faanidct_select="idctdsp" |
| h264dsp_select="startcode" |
| hevcparse_select="atsc_a53 golomb" |
| frame_thread_encoder_deps="encoders threads" |
| intrax8_select="blockdsp idctdsp" |
| mdct_select="fft" |
| mdct15_select="fft" |
| me_cmp_select="fdctdsp idctdsp pixblockdsp" |
| mpeg_er_select="error_resilience" |
| mpegaudio_select="mpegaudiodsp mpegaudioheader" |
| mpegaudiodsp_select="dct" |
| mpegvideo_select="blockdsp h264chroma hpeldsp idctdsp me_cmp mpeg_er videodsp" |
| mpegvideoenc_select="aandcttables me_cmp mpegvideo pixblockdsp qpeldsp" |
| vc1dsp_select="h264chroma qpeldsp startcode" |
| rdft_select="fft" |
| |
| # decoders / encoders |
| aac_decoder_select="adts_header mdct15 mdct sinewin" |
| aac_fixed_decoder_select="adts_header mdct" |
| aac_encoder_select="audio_frame_queue iirfilter lpc mdct sinewin" |
| aac_latm_decoder_select="aac_decoder aac_latm_parser" |
| ac3_decoder_select="ac3_parser ac3dsp bswapdsp fmtconvert mdct" |
| ac3_fixed_decoder_select="ac3_parser ac3dsp bswapdsp mdct" |
| ac3_encoder_select="ac3dsp audiodsp mdct me_cmp" |
| ac3_fixed_encoder_select="ac3dsp audiodsp mdct me_cmp" |
| acelp_kelvin_decoder_select="audiodsp" |
| adpcm_g722_decoder_select="g722dsp" |
| adpcm_g722_encoder_select="g722dsp" |
| aic_decoder_select="golomb idctdsp" |
| alac_encoder_select="lpc" |
| als_decoder_select="bswapdsp" |
| amrnb_decoder_select="lsp" |
| amrwb_decoder_select="lsp" |
| amv_decoder_select="sp5x_decoder exif" |
| amv_encoder_select="jpegtables mpegvideoenc" |
| ape_decoder_select="bswapdsp llauddsp" |
| apng_decoder_deps="zlib" |
| apng_encoder_deps="zlib" |
| apng_encoder_select="llvidencdsp" |
| aptx_decoder_select="audio_frame_queue" |
| aptx_encoder_select="audio_frame_queue" |
| aptx_hd_decoder_select="audio_frame_queue" |
| aptx_hd_encoder_select="audio_frame_queue" |
| asv1_decoder_select="blockdsp bswapdsp idctdsp" |
| asv1_encoder_select="aandcttables bswapdsp fdctdsp pixblockdsp" |
| asv2_decoder_select="blockdsp bswapdsp idctdsp" |
| asv2_encoder_select="aandcttables bswapdsp fdctdsp pixblockdsp" |
| atrac1_decoder_select="mdct sinewin" |
| atrac3_decoder_select="mdct" |
| atrac3al_decoder_select="mdct" |
| atrac3p_decoder_select="mdct sinewin" |
| atrac3pal_decoder_select="mdct sinewin" |
| atrac9_decoder_select="mdct" |
| av1_decoder_select="cbs_av1" |
| bink_decoder_select="blockdsp hpeldsp" |
| binkaudio_dct_decoder_select="mdct rdft dct sinewin wma_freqs" |
| binkaudio_rdft_decoder_select="mdct rdft sinewin wma_freqs" |
| cavs_decoder_select="blockdsp golomb h264chroma idctdsp qpeldsp videodsp" |
| clearvideo_decoder_select="idctdsp" |
| cllc_decoder_select="bswapdsp" |
| comfortnoise_encoder_select="lpc" |
| cook_decoder_select="audiodsp mdct sinewin" |
| cscd_decoder_select="lzo" |
| cscd_decoder_suggest="zlib" |
| dca_decoder_select="mdct" |
| dca_encoder_select="mdct" |
| dds_decoder_select="texturedsp" |
| dirac_decoder_select="dirac_parse dwt golomb videodsp mpegvideoenc" |
| dnxhd_decoder_select="blockdsp idctdsp" |
| dnxhd_encoder_select="blockdsp fdctdsp idctdsp mpegvideoenc pixblockdsp" |
| dolby_e_decoder_select="mdct" |
| dvvideo_decoder_select="dvprofile idctdsp" |
| dvvideo_encoder_select="dvprofile fdctdsp me_cmp pixblockdsp" |
| dxa_decoder_deps="zlib" |
| dxv_decoder_select="lzf texturedsp" |
| eac3_decoder_select="ac3_decoder" |
| eac3_encoder_select="ac3_encoder" |
| eamad_decoder_select="aandcttables blockdsp bswapdsp idctdsp mpegvideo" |
| eatgq_decoder_select="aandcttables" |
| eatqi_decoder_select="aandcttables blockdsp bswapdsp idctdsp" |
| exr_decoder_deps="zlib" |
| exr_encoder_deps="zlib" |
| ffv1_decoder_select="rangecoder" |
| ffv1_encoder_select="rangecoder" |
| ffvhuff_decoder_select="huffyuv_decoder" |
| ffvhuff_encoder_select="huffyuv_encoder" |
| fic_decoder_select="golomb" |
| flac_decoder_select="flacdsp" |
| flac_encoder_select="bswapdsp flacdsp lpc" |
| flashsv2_decoder_deps="zlib" |
| flashsv2_encoder_deps="zlib" |
| flashsv_decoder_deps="zlib" |
| flashsv_encoder_deps="zlib" |
| flv_decoder_select="h263_decoder" |
| flv_encoder_select="h263_encoder" |
| fourxm_decoder_select="blockdsp bswapdsp" |
| fraps_decoder_select="bswapdsp huffman" |
| g2m_decoder_deps="zlib" |
| g2m_decoder_select="blockdsp idctdsp jpegtables" |
| g729_decoder_select="audiodsp" |
| h261_decoder_select="mpegvideo" |
| h261_encoder_select="mpegvideoenc" |
| h263_decoder_select="h263_parser h263dsp mpegvideo qpeldsp" |
| h263_encoder_select="h263dsp mpegvideoenc" |
| h263i_decoder_select="h263_decoder" |
| h263p_decoder_select="h263_decoder" |
| h263p_encoder_select="h263_encoder" |
| h264_decoder_select="atsc_a53 cabac golomb h264chroma h264dsp h264parse h264pred h264qpel videodsp" |
| h264_decoder_suggest="error_resilience" |
| hap_decoder_select="snappy texturedsp" |
| hap_encoder_deps="libsnappy" |
| hap_encoder_select="texturedspenc" |
| hevc_decoder_select="atsc_a53 bswapdsp cabac golomb hevcparse videodsp" |
| huffyuv_decoder_select="bswapdsp huffyuvdsp llviddsp" |
| huffyuv_encoder_select="bswapdsp huffman huffyuvencdsp llvidencdsp" |
| hymt_decoder_select="huffyuv_decoder" |
| iac_decoder_select="imc_decoder" |
| imc_decoder_select="bswapdsp fft mdct sinewin" |
| imm4_decoder_select="bswapdsp" |
| imm5_decoder_select="h264_decoder hevc_decoder" |
| indeo3_decoder_select="hpeldsp" |
| indeo4_decoder_select="ividsp" |
| indeo5_decoder_select="ividsp" |
| interplay_video_decoder_select="hpeldsp" |
| jpegls_decoder_select="mjpeg_decoder" |
| jv_decoder_select="blockdsp" |
| lagarith_decoder_select="llviddsp" |
| ljpeg_encoder_select="idctdsp jpegtables" |
| lscr_decoder_deps="zlib" |
| magicyuv_decoder_select="llviddsp" |
| magicyuv_encoder_select="llvidencdsp" |
| mdec_decoder_select="blockdsp bswapdsp idctdsp mpegvideo" |
| metasound_decoder_select="lsp mdct sinewin" |
| mimic_decoder_select="blockdsp bswapdsp hpeldsp idctdsp" |
| mjpeg_decoder_select="blockdsp hpeldsp exif idctdsp jpegtables" |
| mjpeg_encoder_select="jpegtables mpegvideoenc" |
| mjpegb_decoder_select="mjpeg_decoder" |
| mlp_decoder_select="mlp_parser" |
| mlp_encoder_select="lpc audio_frame_queue" |
| mobiclip_decoder_select="bswapdsp golomb" |
| motionpixels_decoder_select="bswapdsp" |
| mp1_decoder_select="mpegaudio" |
| mp1float_decoder_select="mpegaudio" |
| mp2_decoder_select="mpegaudio" |
| mp2float_decoder_select="mpegaudio" |
| mp3_decoder_select="mpegaudio" |
| mp3adu_decoder_select="mpegaudio" |
| mp3adufloat_decoder_select="mpegaudio" |
| mp3float_decoder_select="mpegaudio" |
| mp3on4_decoder_select="mpegaudio" |
| mp3on4float_decoder_select="mpegaudio" |
| mpc7_decoder_select="bswapdsp mpegaudiodsp" |
| mpc8_decoder_select="mpegaudiodsp" |
| mpegvideo_decoder_select="mpegvideo" |
| mpeg1video_decoder_select="mpegvideo" |
| mpeg1video_encoder_select="mpegvideoenc h263dsp" |
| mpeg2video_decoder_select="mpegvideo" |
| mpeg2video_encoder_select="mpegvideoenc h263dsp" |
| mpeg4_decoder_select="h263_decoder mpeg4video_parser" |
| mpeg4_encoder_select="h263_encoder" |
| msa1_decoder_select="mss34dsp" |
| mscc_decoder_deps="zlib" |
| msmpeg4v1_decoder_select="h263_decoder" |
| msmpeg4v2_decoder_select="h263_decoder" |
| msmpeg4v2_encoder_select="h263_encoder" |
| msmpeg4v3_decoder_select="h263_decoder" |
| msmpeg4v3_encoder_select="h263_encoder" |
| mss2_decoder_select="mpegvideo qpeldsp vc1_decoder" |
| mts2_decoder_select="jpegtables mss34dsp" |
| mv30_decoder_select="aandcttables blockdsp" |
| mvha_decoder_deps="zlib" |
| mvha_decoder_select="llviddsp" |
| mwsc_decoder_deps="zlib" |
| mxpeg_decoder_select="mjpeg_decoder" |
| nellymoser_decoder_select="mdct sinewin" |
| nellymoser_encoder_select="audio_frame_queue mdct sinewin" |
| notchlc_decoder_select="lzf" |
| nuv_decoder_select="idctdsp lzo" |
| on2avc_decoder_select="mdct" |
| opus_decoder_deps="swresample" |
| opus_decoder_select="mdct15" |
| opus_encoder_select="audio_frame_queue mdct15" |
| png_decoder_deps="zlib" |
| png_encoder_deps="zlib" |
| png_encoder_select="llvidencdsp" |
| prores_decoder_select="blockdsp idctdsp" |
| prores_encoder_select="fdctdsp" |
| qcelp_decoder_select="lsp" |
| qdm2_decoder_select="mdct rdft mpegaudiodsp" |
| ra_144_decoder_select="audiodsp" |
| ra_144_encoder_select="audio_frame_queue lpc audiodsp" |
| ralf_decoder_select="golomb" |
| rasc_decoder_deps="zlib" |
| rawvideo_decoder_select="bswapdsp" |
| rscc_decoder_deps="zlib" |
| rtjpeg_decoder_select="me_cmp" |
| rv10_decoder_select="h263_decoder" |
| rv10_encoder_select="h263_encoder" |
| rv20_decoder_select="h263_decoder" |
| rv20_encoder_select="h263_encoder" |
| rv30_decoder_select="golomb h264pred h264qpel mpegvideo rv34dsp" |
| rv40_decoder_select="golomb h264pred h264qpel mpegvideo rv34dsp" |
| screenpresso_decoder_deps="zlib" |
| shorten_decoder_select="bswapdsp" |
| sipr_decoder_select="lsp" |
| smvjpeg_decoder_select="mjpeg_decoder" |
| snow_decoder_select="dwt h264qpel hpeldsp me_cmp rangecoder videodsp" |
| snow_encoder_select="dwt h264qpel hpeldsp me_cmp mpegvideoenc rangecoder" |
| sonic_decoder_select="golomb rangecoder" |
| sonic_encoder_select="golomb rangecoder" |
| sonic_ls_encoder_select="golomb rangecoder" |
| sp5x_decoder_select="mjpeg_decoder" |
| speedhq_decoder_select="mpegvideo" |
| speedhq_encoder_select="mpegvideoenc" |
| srgc_decoder_deps="zlib" |
| svq1_decoder_select="hpeldsp" |
| svq1_encoder_select="hpeldsp me_cmp mpegvideoenc" |
| svq3_decoder_select="golomb h264dsp h264parse h264pred hpeldsp tpeldsp videodsp" |
| svq3_decoder_suggest="zlib" |
| tak_decoder_select="audiodsp" |
| tdsc_decoder_deps="zlib" |
| tdsc_decoder_select="mjpeg_decoder" |
| theora_decoder_select="vp3_decoder" |
| thp_decoder_select="mjpeg_decoder" |
| tiff_decoder_select="mjpeg_decoder" |
| tiff_decoder_suggest="zlib lzma" |
| tiff_encoder_suggest="zlib" |
| truehd_decoder_select="mlp_parser" |
| truehd_encoder_select="lpc audio_frame_queue" |
| truemotion2_decoder_select="bswapdsp" |
| truespeech_decoder_select="bswapdsp" |
| tscc_decoder_deps="zlib" |
| twinvq_decoder_select="mdct lsp sinewin" |
| txd_decoder_select="texturedsp" |
| utvideo_decoder_select="bswapdsp llviddsp" |
| utvideo_encoder_select="bswapdsp huffman llvidencdsp" |
| vble_decoder_select="llviddsp" |
| vc1_decoder_select="blockdsp h263_decoder h264qpel intrax8 mpegvideo vc1dsp" |
| vc1image_decoder_select="vc1_decoder" |
| vorbis_decoder_select="mdct" |
| vorbis_encoder_select="audio_frame_queue mdct" |
| vp3_decoder_select="hpeldsp vp3dsp videodsp" |
| vp4_decoder_select="vp3_decoder" |
| vp5_decoder_select="h264chroma hpeldsp videodsp vp3dsp vp56dsp" |
| vp6_decoder_select="h264chroma hpeldsp huffman videodsp vp3dsp vp56dsp" |
| vp6a_decoder_select="vp6_decoder" |
| vp6f_decoder_select="vp6_decoder" |
| vp7_decoder_select="h264pred videodsp vp8dsp" |
| vp8_decoder_select="h264pred videodsp vp8dsp" |
| vp9_decoder_select="videodsp vp9_parser vp9_superframe_split_bsf" |
| wcmv_decoder_deps="zlib" |
| webp_decoder_select="vp8_decoder exif" |
| wmalossless_decoder_select="llauddsp" |
| wmapro_decoder_select="mdct sinewin wma_freqs" |
| wmav1_decoder_select="mdct sinewin wma_freqs" |
| wmav1_encoder_select="mdct sinewin wma_freqs" |
| wmav2_decoder_select="mdct sinewin wma_freqs" |
| wmav2_encoder_select="mdct sinewin wma_freqs" |
| wmavoice_decoder_select="lsp rdft dct mdct sinewin" |
| wmv1_decoder_select="h263_decoder" |
| wmv1_encoder_select="h263_encoder" |
| wmv2_decoder_select="blockdsp error_resilience h263_decoder idctdsp intrax8 videodsp wmv2dsp" |
| wmv2_encoder_select="h263_encoder wmv2dsp" |
| wmv3_decoder_select="vc1_decoder" |
| wmv3image_decoder_select="wmv3_decoder" |
| xma1_decoder_select="wmapro_decoder" |
| xma2_decoder_select="wmapro_decoder" |
| ylc_decoder_select="bswapdsp" |
| zerocodec_decoder_deps="zlib" |
| zlib_decoder_deps="zlib" |
| zlib_encoder_deps="zlib" |
| zmbv_decoder_deps="zlib" |
| zmbv_encoder_deps="zlib" |
| |
| # hardware accelerators |
| crystalhd_deps="libcrystalhd_libcrystalhd_if_h" |
| cuda_deps="ffnvcodec" |
| cuvid_deps="ffnvcodec" |
| d3d11va_deps="dxva_h ID3D11VideoDecoder ID3D11VideoContext" |
| dxva2_deps="dxva2api_h DXVA2_ConfigPictureDecode ole32 user32" |
| ffnvcodec_deps_any="libdl LoadLibrary" |
| nvdec_deps="ffnvcodec" |
| vaapi_x11_deps="xlib" |
| videotoolbox_hwaccel_deps="videotoolbox pthreads" |
| videotoolbox_hwaccel_extralibs="-framework QuartzCore" |
| xvmc_deps="X11_extensions_XvMClib_h" |
| |
| av1_d3d11va_hwaccel_deps="d3d11va DXVA_PicParams_AV1" |
| av1_d3d11va_hwaccel_select="av1_decoder" |
| av1_d3d11va2_hwaccel_deps="d3d11va DXVA_PicParams_AV1" |
| av1_d3d11va2_hwaccel_select="av1_decoder" |
| av1_dxva2_hwaccel_deps="dxva2 DXVA_PicParams_AV1" |
| av1_dxva2_hwaccel_select="av1_decoder" |
| av1_nvdec_hwaccel_deps="nvdec CUVIDAV1PICPARAMS" |
| av1_nvdec_hwaccel_select="av1_decoder" |
| av1_vaapi_hwaccel_deps="vaapi VADecPictureParameterBufferAV1_bit_depth_idx" |
| av1_vaapi_hwaccel_select="av1_decoder" |
| h263_vaapi_hwaccel_deps="vaapi" |
| h263_vaapi_hwaccel_select="h263_decoder" |
| h263_videotoolbox_hwaccel_deps="videotoolbox" |
| h263_videotoolbox_hwaccel_select="h263_decoder" |
| h264_d3d11va_hwaccel_deps="d3d11va" |
| h264_d3d11va_hwaccel_select="h264_decoder" |
| h264_d3d11va2_hwaccel_deps="d3d11va" |
| h264_d3d11va2_hwaccel_select="h264_decoder" |
| h264_dxva2_hwaccel_deps="dxva2" |
| h264_dxva2_hwaccel_select="h264_decoder" |
| h264_nvdec_hwaccel_deps="nvdec" |
| h264_nvdec_hwaccel_select="h264_decoder" |
| h264_vaapi_hwaccel_deps="vaapi" |
| h264_vaapi_hwaccel_select="h264_decoder" |
| h264_vdpau_hwaccel_deps="vdpau" |
| h264_vdpau_hwaccel_select="h264_decoder" |
| h264_videotoolbox_hwaccel_deps="videotoolbox" |
| h264_videotoolbox_hwaccel_select="h264_decoder" |
| hevc_d3d11va_hwaccel_deps="d3d11va DXVA_PicParams_HEVC" |
| hevc_d3d11va_hwaccel_select="hevc_decoder" |
| hevc_d3d11va2_hwaccel_deps="d3d11va DXVA_PicParams_HEVC" |
| hevc_d3d11va2_hwaccel_select="hevc_decoder" |
| hevc_dxva2_hwaccel_deps="dxva2 DXVA_PicParams_HEVC" |
| hevc_dxva2_hwaccel_select="hevc_decoder" |
| hevc_nvdec_hwaccel_deps="nvdec" |
| hevc_nvdec_hwaccel_select="hevc_decoder" |
| hevc_vaapi_hwaccel_deps="vaapi VAPictureParameterBufferHEVC" |
| hevc_vaapi_hwaccel_select="hevc_decoder" |
| hevc_vdpau_hwaccel_deps="vdpau VdpPictureInfoHEVC" |
| hevc_vdpau_hwaccel_select="hevc_decoder" |
| hevc_videotoolbox_hwaccel_deps="videotoolbox" |
| hevc_videotoolbox_hwaccel_select="hevc_decoder" |
| mjpeg_nvdec_hwaccel_deps="nvdec" |
| mjpeg_nvdec_hwaccel_select="mjpeg_decoder" |
| mjpeg_vaapi_hwaccel_deps="vaapi" |
| mjpeg_vaapi_hwaccel_select="mjpeg_decoder" |
| mpeg_xvmc_hwaccel_deps="xvmc" |
| mpeg_xvmc_hwaccel_select="mpeg2video_decoder" |
| mpeg1_nvdec_hwaccel_deps="nvdec" |
| mpeg1_nvdec_hwaccel_select="mpeg1video_decoder" |
| mpeg1_vdpau_hwaccel_deps="vdpau" |
| mpeg1_vdpau_hwaccel_select="mpeg1video_decoder" |
| mpeg1_videotoolbox_hwaccel_deps="videotoolbox" |
| mpeg1_videotoolbox_hwaccel_select="mpeg1video_decoder" |
| mpeg1_xvmc_hwaccel_deps="xvmc" |
| mpeg1_xvmc_hwaccel_select="mpeg1video_decoder" |
| mpeg2_d3d11va_hwaccel_deps="d3d11va" |
| mpeg2_d3d11va_hwaccel_select="mpeg2video_decoder" |
| mpeg2_d3d11va2_hwaccel_deps="d3d11va" |
| mpeg2_d3d11va2_hwaccel_select="mpeg2video_decoder" |
| mpeg2_dxva2_hwaccel_deps="dxva2" |
| mpeg2_dxva2_hwaccel_select="mpeg2video_decoder" |
| mpeg2_nvdec_hwaccel_deps="nvdec" |
| mpeg2_nvdec_hwaccel_select="mpeg2video_decoder" |
| mpeg2_vaapi_hwaccel_deps="vaapi" |
| mpeg2_vaapi_hwaccel_select="mpeg2video_decoder" |
| mpeg2_vdpau_hwaccel_deps="vdpau" |
| mpeg2_vdpau_hwaccel_select="mpeg2video_decoder" |
| mpeg2_videotoolbox_hwaccel_deps="videotoolbox" |
| mpeg2_videotoolbox_hwaccel_select="mpeg2video_decoder" |
| mpeg2_xvmc_hwaccel_deps="xvmc" |
| mpeg2_xvmc_hwaccel_select="mpeg2video_decoder" |
| mpeg4_nvdec_hwaccel_deps="nvdec" |
| mpeg4_nvdec_hwaccel_select="mpeg4_decoder" |
| mpeg4_vaapi_hwaccel_deps="vaapi" |
| mpeg4_vaapi_hwaccel_select="mpeg4_decoder" |
| mpeg4_vdpau_hwaccel_deps="vdpau" |
| mpeg4_vdpau_hwaccel_select="mpeg4_decoder" |
| mpeg4_videotoolbox_hwaccel_deps="videotoolbox" |
| mpeg4_videotoolbox_hwaccel_select="mpeg4_decoder" |
| vc1_d3d11va_hwaccel_deps="d3d11va" |
| vc1_d3d11va_hwaccel_select="vc1_decoder" |
| vc1_d3d11va2_hwaccel_deps="d3d11va" |
| vc1_d3d11va2_hwaccel_select="vc1_decoder" |
| vc1_dxva2_hwaccel_deps="dxva2" |
| vc1_dxva2_hwaccel_select="vc1_decoder" |
| vc1_nvdec_hwaccel_deps="nvdec" |
| vc1_nvdec_hwaccel_select="vc1_decoder" |
| vc1_vaapi_hwaccel_deps="vaapi" |
| vc1_vaapi_hwaccel_select="vc1_decoder" |
| vc1_vdpau_hwaccel_deps="vdpau" |
| vc1_vdpau_hwaccel_select="vc1_decoder" |
| vp8_nvdec_hwaccel_deps="nvdec" |
| vp8_nvdec_hwaccel_select="vp8_decoder" |
| vp8_vaapi_hwaccel_deps="vaapi" |
| vp8_vaapi_hwaccel_select="vp8_decoder" |
| vp9_d3d11va_hwaccel_deps="d3d11va DXVA_PicParams_VP9" |
| vp9_d3d11va_hwaccel_select="vp9_decoder" |
| vp9_d3d11va2_hwaccel_deps="d3d11va DXVA_PicParams_VP9" |
| vp9_d3d11va2_hwaccel_select="vp9_decoder" |
| vp9_dxva2_hwaccel_deps="dxva2 DXVA_PicParams_VP9" |
| vp9_dxva2_hwaccel_select="vp9_decoder" |
| vp9_nvdec_hwaccel_deps="nvdec" |
| vp9_nvdec_hwaccel_select="vp9_decoder" |
| vp9_vaapi_hwaccel_deps="vaapi VADecPictureParameterBufferVP9_bit_depth" |
| vp9_vaapi_hwaccel_select="vp9_decoder" |
| vp9_vdpau_hwaccel_deps="vdpau VdpPictureInfoVP9" |
| vp9_vdpau_hwaccel_select="vp9_decoder" |
| wmv3_d3d11va_hwaccel_select="vc1_d3d11va_hwaccel" |
| wmv3_d3d11va2_hwaccel_select="vc1_d3d11va2_hwaccel" |
| wmv3_dxva2_hwaccel_select="vc1_dxva2_hwaccel" |
| wmv3_nvdec_hwaccel_select="vc1_nvdec_hwaccel" |
| wmv3_vaapi_hwaccel_select="vc1_vaapi_hwaccel" |
| wmv3_vdpau_hwaccel_select="vc1_vdpau_hwaccel" |
| |
| # hardware-accelerated codecs |
| mediafoundation_deps="mftransform_h MFCreateAlignedMemoryBuffer" |
| mediafoundation_extralibs="-lmfplat -lmfuuid -lole32 -lstrmiids" |
| omx_deps="libdl pthreads" |
| omx_rpi_select="omx" |
| qsv_deps="libmfx" |
| qsvdec_select="qsv" |
| qsvenc_select="qsv" |
| qsvvpp_select="qsv" |
| vaapi_encode_deps="vaapi" |
| v4l2_m2m_deps="linux_videodev2_h sem_timedwait" |
| |
| hwupload_cuda_filter_deps="ffnvcodec" |
| scale_npp_filter_deps="ffnvcodec libnpp" |
| scale_cuda_filter_deps="ffnvcodec" |
| scale_cuda_filter_deps_any="cuda_nvcc cuda_llvm" |
| thumbnail_cuda_filter_deps="ffnvcodec" |
| thumbnail_cuda_filter_deps_any="cuda_nvcc cuda_llvm" |
| transpose_npp_filter_deps="ffnvcodec libnpp" |
| overlay_cuda_filter_deps="ffnvcodec" |
| overlay_cuda_filter_deps_any="cuda_nvcc cuda_llvm" |
| |
| amf_deps_any="libdl LoadLibrary" |
| nvenc_deps="ffnvcodec" |
| nvenc_deps_any="libdl LoadLibrary" |
| nvenc_encoder_deps="nvenc" |
| |
| aac_mf_encoder_deps="mediafoundation" |
| ac3_mf_encoder_deps="mediafoundation" |
| av1_cuvid_decoder_deps="cuvid CUVIDAV1PICPARAMS" |
| h263_v4l2m2m_decoder_deps="v4l2_m2m h263_v4l2_m2m" |
| h263_v4l2m2m_encoder_deps="v4l2_m2m h263_v4l2_m2m" |
| h264_amf_encoder_deps="amf" |
| h264_crystalhd_decoder_select="crystalhd h264_mp4toannexb_bsf h264_parser" |
| h264_cuvid_decoder_deps="cuvid" |
| h264_cuvid_decoder_select="h264_mp4toannexb_bsf" |
| h264_mediacodec_decoder_deps="mediacodec" |
| h264_mediacodec_decoder_select="h264_mp4toannexb_bsf h264_parser" |
| h264_mf_encoder_deps="mediafoundation" |
| h264_mmal_decoder_deps="mmal" |
| h264_nvenc_encoder_deps="nvenc" |
| h264_nvenc_encoder_select="atsc_a53" |
| h264_omx_encoder_deps="omx" |
| h264_qsv_decoder_select="h264_mp4toannexb_bsf qsvdec" |
| h264_qsv_encoder_select="atsc_a53 qsvenc" |
| h264_rkmpp_decoder_deps="rkmpp" |
| h264_rkmpp_decoder_select="h264_mp4toannexb_bsf" |
| h264_vaapi_encoder_select="cbs_h264 vaapi_encode" |
| h264_v4l2m2m_decoder_deps="v4l2_m2m h264_v4l2_m2m" |
| h264_v4l2m2m_decoder_select="h264_mp4toannexb_bsf" |
| h264_v4l2m2m_encoder_deps="v4l2_m2m h264_v4l2_m2m" |
| hevc_amf_encoder_deps="amf" |
| hevc_cuvid_decoder_deps="cuvid" |
| hevc_cuvid_decoder_select="hevc_mp4toannexb_bsf" |
| hevc_mediacodec_decoder_deps="mediacodec" |
| hevc_mediacodec_decoder_select="hevc_mp4toannexb_bsf hevc_parser" |
| hevc_mf_encoder_deps="mediafoundation" |
| hevc_nvenc_encoder_deps="nvenc" |
| hevc_nvenc_encoder_select="atsc_a53" |
| hevc_qsv_decoder_select="hevc_mp4toannexb_bsf qsvdec" |
| hevc_qsv_encoder_select="hevcparse qsvenc" |
| hevc_rkmpp_decoder_deps="rkmpp" |
| hevc_rkmpp_decoder_select="hevc_mp4toannexb_bsf" |
| hevc_vaapi_encoder_deps="VAEncPictureParameterBufferHEVC" |
| hevc_vaapi_encoder_select="cbs_h265 vaapi_encode" |
| hevc_v4l2m2m_decoder_deps="v4l2_m2m hevc_v4l2_m2m" |
| hevc_v4l2m2m_decoder_select="hevc_mp4toannexb_bsf" |
| hevc_v4l2m2m_encoder_deps="v4l2_m2m hevc_v4l2_m2m" |
| mjpeg_cuvid_decoder_deps="cuvid" |
| mjpeg_qsv_decoder_select="qsvdec" |
| mjpeg_qsv_encoder_deps="libmfx" |
| mjpeg_qsv_encoder_select="qsvenc" |
| mjpeg_vaapi_encoder_deps="VAEncPictureParameterBufferJPEG" |
| mjpeg_vaapi_encoder_select="cbs_jpeg jpegtables vaapi_encode" |
| mp3_mf_encoder_deps="mediafoundation" |
| mpeg1_cuvid_decoder_deps="cuvid" |
| mpeg1_v4l2m2m_decoder_deps="v4l2_m2m mpeg1_v4l2_m2m" |
| mpeg2_crystalhd_decoder_select="crystalhd" |
| mpeg2_cuvid_decoder_deps="cuvid" |
| mpeg2_mmal_decoder_deps="mmal" |
| mpeg2_mediacodec_decoder_deps="mediacodec" |
| mpeg2_qsv_decoder_select="qsvdec" |
| mpeg2_qsv_encoder_select="qsvenc" |
| mpeg2_vaapi_encoder_select="cbs_mpeg2 vaapi_encode" |
| mpeg2_v4l2m2m_decoder_deps="v4l2_m2m mpeg2_v4l2_m2m" |
| mpeg4_crystalhd_decoder_select="crystalhd" |
| mpeg4_cuvid_decoder_deps="cuvid" |
| mpeg4_mediacodec_decoder_deps="mediacodec" |
| mpeg4_mmal_decoder_deps="mmal" |
| mpeg4_omx_encoder_deps="omx" |
| mpeg4_v4l2m2m_decoder_deps="v4l2_m2m mpeg4_v4l2_m2m" |
| mpeg4_v4l2m2m_encoder_deps="v4l2_m2m mpeg4_v4l2_m2m" |
| msmpeg4_crystalhd_decoder_select="crystalhd" |
| nvenc_h264_encoder_select="h264_nvenc_encoder" |
| nvenc_hevc_encoder_select="hevc_nvenc_encoder" |
| vc1_crystalhd_decoder_select="crystalhd" |
| vc1_cuvid_decoder_deps="cuvid" |
| vc1_mmal_decoder_deps="mmal" |
| vc1_qsv_decoder_select="qsvdec" |
| vc1_v4l2m2m_decoder_deps="v4l2_m2m vc1_v4l2_m2m" |
| vp8_cuvid_decoder_deps="cuvid" |
| vp8_mediacodec_decoder_deps="mediacodec" |
| vp8_qsv_decoder_select="qsvdec" |
| vp8_rkmpp_decoder_deps="rkmpp" |
| vp8_vaapi_encoder_deps="VAEncPictureParameterBufferVP8" |
| vp8_vaapi_encoder_select="vaapi_encode" |
| vp8_v4l2m2m_decoder_deps="v4l2_m2m vp8_v4l2_m2m" |
| vp8_v4l2m2m_encoder_deps="v4l2_m2m vp8_v4l2_m2m" |
| vp9_cuvid_decoder_deps="cuvid" |
| vp9_mediacodec_decoder_deps="mediacodec" |
| vp9_qsv_decoder_select="qsvdec" |
| vp9_rkmpp_decoder_deps="rkmpp" |
| vp9_vaapi_encoder_deps="VAEncPictureParameterBufferVP9" |
| vp9_vaapi_encoder_select="vaapi_encode" |
| vp9_qsv_encoder_deps="libmfx MFX_CODEC_VP9" |
| vp9_qsv_encoder_select="qsvenc" |
| vp9_v4l2m2m_decoder_deps="v4l2_m2m vp9_v4l2_m2m" |
| wmv3_crystalhd_decoder_select="crystalhd" |
| av1_qsv_decoder_select="qsvdec" |
| |
| # parsers |
| aac_parser_select="adts_header" |
| av1_parser_select="cbs_av1" |
| h264_parser_select="atsc_a53 golomb h264dsp h264parse" |
| hevc_parser_select="hevcparse" |
| mpegaudio_parser_select="mpegaudioheader" |
| mpegvideo_parser_select="mpegvideo" |
| mpeg4video_parser_select="h263dsp mpegvideo qpeldsp" |
| vc1_parser_select="vc1dsp" |
| |
| # bitstream_filters |
| aac_adtstoasc_bsf_select="adts_header" |
| av1_frame_merge_bsf_select="cbs_av1" |
| av1_frame_split_bsf_select="cbs_av1" |
| av1_metadata_bsf_select="cbs_av1" |
| eac3_core_bsf_select="ac3_parser" |
| filter_units_bsf_select="cbs" |
| h264_metadata_bsf_deps="const_nan" |
| h264_metadata_bsf_select="cbs_h264" |
| h264_redundant_pps_bsf_select="cbs_h264" |
| hevc_metadata_bsf_select="cbs_h265" |
| mjpeg2jpeg_bsf_select="jpegtables" |
| mpeg2_metadata_bsf_select="cbs_mpeg2" |
| trace_headers_bsf_select="cbs" |
| vp9_metadata_bsf_select="cbs_vp9" |
| |
| # external libraries |
| aac_at_decoder_deps="audiotoolbox" |
| aac_at_decoder_select="aac_adtstoasc_bsf" |
| ac3_at_decoder_deps="audiotoolbox" |
| ac3_at_decoder_select="ac3_parser" |
| adpcm_ima_qt_at_decoder_deps="audiotoolbox" |
| alac_at_decoder_deps="audiotoolbox" |
| amr_nb_at_decoder_deps="audiotoolbox" |
| avisynth_deps_any="libdl LoadLibrary" |
| avisynth_demuxer_deps="avisynth" |
| avisynth_demuxer_select="riffdec" |
| eac3_at_decoder_deps="audiotoolbox" |
| eac3_at_decoder_select="ac3_parser" |
| gsm_ms_at_decoder_deps="audiotoolbox" |
| ilbc_at_decoder_deps="audiotoolbox" |
| mp1_at_decoder_deps="audiotoolbox" |
| mp2_at_decoder_deps="audiotoolbox" |
| mp3_at_decoder_deps="audiotoolbox" |
| mp1_at_decoder_select="mpegaudioheader" |
| mp2_at_decoder_select="mpegaudioheader" |
| mp3_at_decoder_select="mpegaudioheader" |
| pcm_alaw_at_decoder_deps="audiotoolbox" |
| pcm_mulaw_at_decoder_deps="audiotoolbox" |
| qdmc_decoder_select="fft" |
| qdmc_at_decoder_deps="audiotoolbox" |
| qdm2_at_decoder_deps="audiotoolbox" |
| aac_at_encoder_deps="audiotoolbox" |
| aac_at_encoder_select="audio_frame_queue" |
| alac_at_encoder_deps="audiotoolbox" |
| alac_at_encoder_select="audio_frame_queue" |
| ilbc_at_encoder_deps="audiotoolbox" |
| ilbc_at_encoder_select="audio_frame_queue" |
| pcm_alaw_at_encoder_deps="audiotoolbox" |
| pcm_alaw_at_encoder_select="audio_frame_queue" |
| pcm_mulaw_at_encoder_deps="audiotoolbox" |
| pcm_mulaw_at_encoder_select="audio_frame_queue" |
| chromaprint_muxer_deps="chromaprint" |
| h264_videotoolbox_encoder_deps="pthreads" |
| h264_videotoolbox_encoder_select="atsc_a53 videotoolbox_encoder" |
| hevc_videotoolbox_encoder_deps="pthreads" |
| hevc_videotoolbox_encoder_select="atsc_a53 videotoolbox_encoder" |
| libaom_av1_decoder_deps="libaom" |
| libaom_av1_encoder_deps="libaom" |
| libaom_av1_encoder_select="extract_extradata_bsf" |
| libaribb24_decoder_deps="libaribb24" |
| libcelt_decoder_deps="libcelt" |
| libcodec2_decoder_deps="libcodec2" |
| libcodec2_encoder_deps="libcodec2" |
| libdav1d_decoder_deps="libdav1d" |
| libdav1d_decoder_select="atsc_a53" |
| libdavs2_decoder_deps="libdavs2" |
| libfdk_aac_decoder_deps="libfdk_aac" |
| libfdk_aac_encoder_deps="libfdk_aac" |
| libfdk_aac_encoder_select="audio_frame_queue" |
| libgme_demuxer_deps="libgme" |
| libgsm_decoder_deps="libgsm" |
| libgsm_encoder_deps="libgsm" |
| libgsm_ms_decoder_deps="libgsm" |
| libgsm_ms_encoder_deps="libgsm" |
| libilbc_decoder_deps="libilbc" |
| libilbc_encoder_deps="libilbc" |
| libkvazaar_encoder_deps="libkvazaar" |
| libmodplug_demuxer_deps="libmodplug" |
| libmp3lame_encoder_deps="libmp3lame" |
| libmp3lame_encoder_select="audio_frame_queue mpegaudioheader" |
| libopencore_amrnb_decoder_deps="libopencore_amrnb" |
| libopencore_amrnb_encoder_deps="libopencore_amrnb" |
| libopencore_amrnb_encoder_select="audio_frame_queue" |
| libopencore_amrwb_decoder_deps="libopencore_amrwb" |
| libopenh264_decoder_deps="libopenh264" |
| libopenh264_decoder_select="h264_mp4toannexb_bsf" |
| libopenh264_encoder_deps="libopenh264" |
| libopenjpeg_decoder_deps="libopenjpeg" |
| libopenjpeg_encoder_deps="libopenjpeg" |
| libopenmpt_demuxer_deps="libopenmpt" |
| libopus_decoder_deps="libopus" |
| libopus_encoder_deps="libopus" |
| libopus_encoder_select="audio_frame_queue" |
| librav1e_encoder_deps="librav1e" |
| librav1e_encoder_select="extract_extradata_bsf" |
| librsvg_decoder_deps="librsvg" |
| libshine_encoder_deps="libshine" |
| libshine_encoder_select="audio_frame_queue" |
| libspeex_decoder_deps="libspeex" |
| libspeex_encoder_deps="libspeex" |
| libspeex_encoder_select="audio_frame_queue" |
| libsvtav1_encoder_deps="libsvtav1" |
| libtheora_encoder_deps="libtheora" |
| libtwolame_encoder_deps="libtwolame" |
| libuavs3d_decoder_deps="libuavs3d" |
| libvo_amrwbenc_encoder_deps="libvo_amrwbenc" |
| libvorbis_decoder_deps="libvorbis" |
| libvorbis_encoder_deps="libvorbis libvorbisenc" |
| libvorbis_encoder_select="audio_frame_queue" |
| libvpx_vp8_decoder_deps="libvpx" |
| libvpx_vp8_encoder_deps="libvpx" |
| libvpx_vp9_decoder_deps="libvpx" |
| libvpx_vp9_encoder_deps="libvpx" |
| libwebp_encoder_deps="libwebp" |
| libwebp_anim_encoder_deps="libwebp" |
| libx262_encoder_deps="libx262" |
| libx264_encoder_deps="libx264" |
| libx264_encoder_select="atsc_a53" |
| libx264rgb_encoder_deps="libx264 x264_csp_bgr" |
| libx264rgb_encoder_select="libx264_encoder" |
| libx265_encoder_deps="libx265" |
| libxavs_encoder_deps="libxavs" |
| libxavs2_encoder_deps="libxavs2" |
| libxvid_encoder_deps="libxvid" |
| libzvbi_teletext_decoder_deps="libzvbi" |
| vapoursynth_demuxer_deps="vapoursynth" |
| videotoolbox_suggest="coreservices" |
| videotoolbox_deps="corefoundation coremedia corevideo" |
| videotoolbox_encoder_deps="videotoolbox VTCompressionSessionPrepareToEncodeFrames" |
| |
| # demuxers / muxers |
| ac3_demuxer_select="ac3_parser" |
| act_demuxer_select="riffdec" |
| aiff_muxer_select="iso_media" |
| asf_demuxer_select="riffdec" |
| asf_o_demuxer_select="riffdec" |
| asf_muxer_select="riffenc" |
| asf_stream_muxer_select="asf_muxer" |
| av1_demuxer_select="av1_frame_merge_bsf av1_parser" |
| avi_demuxer_select="riffdec exif" |
| avi_muxer_select="riffenc" |
| caf_demuxer_select="iso_media" |
| caf_muxer_select="iso_media" |
| dash_muxer_select="mp4_muxer" |
| dash_demuxer_deps="libxml2" |
| dirac_demuxer_select="dirac_parser" |
| dts_demuxer_select="dca_parser" |
| dtshd_demuxer_select="dca_parser" |
| dv_demuxer_select="dvprofile" |
| dv_muxer_select="dvprofile" |
| dxa_demuxer_select="riffdec" |
| eac3_demuxer_select="ac3_parser" |
| f4v_muxer_select="mov_muxer" |
| fifo_muxer_deps="threads" |
| flac_demuxer_select="flac_parser" |
| flv_muxer_select="aac_adtstoasc_bsf" |
| gxf_muxer_select="pcm_rechunk_bsf" |
| hds_muxer_select="flv_muxer" |
| hls_muxer_select="mpegts_muxer" |
| hls_muxer_suggest="gcrypt openssl" |
| image2_alias_pix_demuxer_select="image2_demuxer" |
| image2_brender_pix_demuxer_select="image2_demuxer" |
| ipod_muxer_select="mov_muxer" |
| ismv_muxer_select="mov_muxer" |
| ivf_muxer_select="av1_metadata_bsf vp9_superframe_bsf" |
| latm_muxer_select="aac_adtstoasc_bsf" |
| matroska_audio_muxer_select="matroska_muxer" |
| matroska_demuxer_select="riffdec" |
| matroska_demuxer_suggest="bzlib lzo zlib" |
| matroska_muxer_select="riffenc vp9_superframe_bsf aac_adtstoasc_bsf" |
| mlp_demuxer_select="mlp_parser" |
| mmf_muxer_select="riffenc" |
| mov_demuxer_select="iso_media riffdec" |
| mov_demuxer_suggest="zlib" |
| mov_muxer_select="iso_media riffenc rtpenc_chain vp9_superframe_bsf aac_adtstoasc_bsf" |
| mp3_demuxer_select="mpegaudio_parser" |
| mp3_muxer_select="mpegaudioheader" |
| mp4_muxer_select="mov_muxer" |
| mpegts_demuxer_select="iso_media" |
| mpegts_muxer_select="ac3_parser adts_muxer latm_muxer h264_mp4toannexb_bsf hevc_mp4toannexb_bsf" |
| mpegtsraw_demuxer_select="mpegts_demuxer" |
| mxf_muxer_select="golomb pcm_rechunk_bsf" |
| mxf_d10_muxer_select="mxf_muxer" |
| mxf_opatom_muxer_select="mxf_muxer" |
| nut_muxer_select="riffenc" |
| nuv_demuxer_select="riffdec" |
| obu_demuxer_select="av1_frame_merge_bsf av1_parser" |
| oga_muxer_select="ogg_muxer" |
| ogg_demuxer_select="dirac_parse" |
| ogv_muxer_select="ogg_muxer" |
| opus_muxer_select="ogg_muxer" |
| psp_muxer_select="mov_muxer" |
| rtp_demuxer_select="sdp_demuxer" |
| rtp_muxer_select="golomb jpegtables" |
| rtpdec_select="asf_demuxer jpegtables mov_demuxer mpegts_demuxer rm_demuxer rtp_protocol srtp" |
| rtsp_demuxer_select="http_protocol rtpdec" |
| rtsp_muxer_select="rtp_muxer http_protocol rtp_protocol rtpenc_chain" |
| sap_demuxer_select="sdp_demuxer" |
| sap_muxer_select="rtp_muxer rtp_protocol rtpenc_chain" |
| sdp_demuxer_select="rtpdec" |
| smoothstreaming_muxer_select="ismv_muxer" |
| spdif_demuxer_select="adts_header" |
| spdif_muxer_select="adts_header" |
| spx_muxer_select="ogg_muxer" |
| swf_demuxer_suggest="zlib" |
| tak_demuxer_select="tak_parser" |
| truehd_demuxer_select="mlp_parser" |
| tg2_muxer_select="mov_muxer" |
| tgp_muxer_select="mov_muxer" |
| vobsub_demuxer_select="mpegps_demuxer" |
| w64_demuxer_select="wav_demuxer" |
| w64_muxer_select="wav_muxer" |
| wav_demuxer_select="riffdec" |
| wav_muxer_select="riffenc" |
| webm_chunk_muxer_select="webm_muxer" |
| webm_muxer_select="riffenc" |
| webm_dash_manifest_demuxer_select="matroska_demuxer" |
| wtv_demuxer_select="mpegts_demuxer riffdec" |
| wtv_muxer_select="mpegts_muxer riffenc" |
| xmv_demuxer_select="riffdec" |
| xwma_demuxer_select="riffdec" |
| |
| # indevs / outdevs |
| android_camera_indev_deps="android camera2ndk mediandk pthreads" |
| android_camera_indev_extralibs="-landroid -lcamera2ndk -lmediandk" |
| alsa_indev_deps="alsa" |
| alsa_outdev_deps="alsa" |
| avfoundation_indev_deps="avfoundation corevideo coremedia pthreads" |
| avfoundation_indev_suggest="coregraphics applicationservices" |
| avfoundation_indev_extralibs="-framework Foundation" |
| audiotoolbox_outdev_deps="audiotoolbox pthreads" |
| audiotoolbox_outdev_extralibs="-framework AudioToolbox -framework CoreAudio" |
| bktr_indev_deps_any="dev_bktr_ioctl_bt848_h machine_ioctl_bt848_h dev_video_bktr_ioctl_bt848_h dev_ic_bt8xx_h" |
| caca_outdev_deps="libcaca" |
| decklink_deps_any="libdl LoadLibrary" |
| decklink_indev_deps="decklink threads" |
| decklink_indev_extralibs="-lstdc++" |
| decklink_outdev_deps="decklink threads" |
| decklink_outdev_suggest="libklvanc" |
| decklink_outdev_extralibs="-lstdc++" |
| dshow_indev_deps="IBaseFilter" |
| dshow_indev_extralibs="-lpsapi -lole32 -lstrmiids -luuid -loleaut32 -lshlwapi" |
| fbdev_indev_deps="linux_fb_h" |
| fbdev_outdev_deps="linux_fb_h" |
| gdigrab_indev_deps="CreateDIBSection" |
| gdigrab_indev_extralibs="-lgdi32" |
| gdigrab_indev_select="bmp_decoder" |
| iec61883_indev_deps="libiec61883" |
| jack_indev_deps="libjack" |
| jack_indev_deps_any="sem_timedwait dispatch_dispatch_h" |
| kmsgrab_indev_deps="libdrm" |
| lavfi_indev_deps="avfilter" |
| libcdio_indev_deps="libcdio" |
| libdc1394_indev_deps="libdc1394" |
| openal_indev_deps="openal" |
| opengl_outdev_deps="opengl" |
| opengl_outdev_suggest="sdl2" |
| oss_indev_deps_any="sys_soundcard_h" |
| oss_outdev_deps_any="sys_soundcard_h" |
| pulse_indev_deps="libpulse" |
| pulse_outdev_deps="libpulse" |
| sdl2_outdev_deps="sdl2" |
| sndio_indev_deps="sndio" |
| sndio_outdev_deps="sndio" |
| v4l2_indev_deps_any="linux_videodev2_h sys_videoio_h" |
| v4l2_indev_suggest="libv4l2" |
| v4l2_outdev_deps_any="linux_videodev2_h sys_videoio_h" |
| v4l2_outdev_suggest="libv4l2" |
| vfwcap_indev_deps="vfw32 vfwcap_defines" |
| xcbgrab_indev_deps="libxcb" |
| xcbgrab_indev_suggest="libxcb_shm libxcb_shape libxcb_xfixes" |
| xv_outdev_deps="xlib" |
| |
| # protocols |
| async_protocol_deps="threads" |
| bluray_protocol_deps="libbluray" |
| ffrtmpcrypt_protocol_conflict="librtmp_protocol" |
| ffrtmpcrypt_protocol_deps_any="gcrypt gmp openssl mbedtls" |
| ffrtmpcrypt_protocol_select="tcp_protocol" |
| ffrtmphttp_protocol_conflict="librtmp_protocol" |
| ffrtmphttp_protocol_select="http_protocol" |
| ftp_protocol_select="tcp_protocol" |
| gopher_protocol_select="network" |
| http_protocol_select="tcp_protocol" |
| http_protocol_suggest="zlib" |
| httpproxy_protocol_select="tcp_protocol" |
| httpproxy_protocol_suggest="zlib" |
| https_protocol_select="tls_protocol" |
| https_protocol_suggest="zlib" |
| icecast_protocol_select="http_protocol" |
| mmsh_protocol_select="http_protocol" |
| mmst_protocol_select="network" |
| rtmp_protocol_conflict="librtmp_protocol" |
| rtmp_protocol_select="tcp_protocol" |
| rtmp_protocol_suggest="zlib" |
| rtmpe_protocol_select="ffrtmpcrypt_protocol" |
| rtmpe_protocol_suggest="zlib" |
| rtmps_protocol_conflict="librtmp_protocol" |
| rtmps_protocol_select="tls_protocol" |
| rtmps_protocol_suggest="zlib" |
| rtmpt_protocol_select="ffrtmphttp_protocol" |
| rtmpt_protocol_suggest="zlib" |
| rtmpte_protocol_select="ffrtmpcrypt_protocol ffrtmphttp_protocol" |
| rtmpte_protocol_suggest="zlib" |
| rtmpts_protocol_select="ffrtmphttp_protocol https_protocol" |
| rtmpts_protocol_suggest="zlib" |
| rtp_protocol_select="udp_protocol" |
| schannel_conflict="openssl gnutls libtls mbedtls" |
| sctp_protocol_deps="struct_sctp_event_subscribe struct_msghdr_msg_flags" |
| sctp_protocol_select="network" |
| securetransport_conflict="openssl gnutls libtls mbedtls" |
| srtp_protocol_select="rtp_protocol srtp" |
| tcp_protocol_select="network" |
| tls_protocol_deps_any="gnutls openssl schannel securetransport libtls mbedtls" |
| tls_protocol_select="tcp_protocol" |
| udp_protocol_select="network" |
| udplite_protocol_select="network" |
| unix_protocol_deps="sys_un_h" |
| unix_protocol_select="network" |
| |
| # external library protocols |
| libamqp_protocol_deps="librabbitmq" |
| libamqp_protocol_select="network" |
| librtmp_protocol_deps="librtmp" |
| librtmpe_protocol_deps="librtmp" |
| librtmps_protocol_deps="librtmp" |
| librtmpt_protocol_deps="librtmp" |
| librtmpte_protocol_deps="librtmp" |
| libsmbclient_protocol_deps="libsmbclient gplv3" |
| libsrt_protocol_deps="libsrt" |
| libsrt_protocol_select="network" |
| libssh_protocol_deps="libssh" |
| libtls_conflict="openssl gnutls mbedtls" |
| libzmq_protocol_deps="libzmq" |
| libzmq_protocol_select="network" |
| |
| # filters |
| afftdn_filter_deps="avcodec" |
| afftdn_filter_select="fft" |
| afftfilt_filter_deps="avcodec" |
| afftfilt_filter_select="fft" |
| afir_filter_deps="avcodec" |
| afir_filter_select="rdft" |
| amovie_filter_deps="avcodec avformat" |
| aresample_filter_deps="swresample" |
| asoftclip_filter_deps="swresample" |
| asr_filter_deps="pocketsphinx" |
| ass_filter_deps="libass" |
| atempo_filter_deps="avcodec" |
| atempo_filter_select="rdft" |
| avgblur_opencl_filter_deps="opencl" |
| avgblur_vulkan_filter_deps="vulkan libglslang" |
|