diff options
Diffstat (limited to 'recipes')
| -rw-r--r-- | recipes/ffmpeg.recipe | 190 | ||||
| -rw-r--r-- | recipes/ffmpeg/0001-Add-Meson-build.patch | 13721 | ||||
| -rw-r--r-- | recipes/ffmpeg/0001-pkgconfig-fix-generation-to-use-prefix.patch | 27 |
3 files changed, 13798 insertions, 140 deletions
diff --git a/recipes/ffmpeg.recipe b/recipes/ffmpeg.recipe index 4462952e..4366a800 100644 --- a/recipes/ffmpeg.recipe +++ b/recipes/ffmpeg.recipe @@ -9,137 +9,101 @@ class Recipe(recipe.Recipe): url = 'https://ffmpeg.org/releases/%(name)s-%(version)s.tar.xz' tarball_checksum = '57be87c22d9b49c112b6d24bc67d42508660e6b718b3db89c44e47e289137082' patches = [ - name + '/0001-pkgconfig-fix-generation-to-use-prefix.patch', + name + '/0001-Add-Meson-build.patch', ] - btype = BuildType.MAKEFILE - configure_tpl = './configure --prefix=%(prefix)s --libdir=%(libdir)s \ - --ar="$AR" --as="$AS" --cc="$CC" --ld="$CC" --nm="$NM" --ranlib="$RANLIB" \ - --strip="$STRIP" --windres="$RC" \ - --enable-static --enable-pic --enable-shared \ - --disable-avdevice --disable-postproc --disable-swscale \ - --disable-programs --disable-ffplay --disable-ffprobe --disable-ffmpeg \ - --disable-encoder=flac --disable-protocols --disable-devices \ - --disable-network --disable-hwaccels --disable-dxva2 --disable-vdpau \ - --disable-filters --enable-filter=yadif --disable-doc --disable-d3d11va \ - --disable-audiotoolbox --disable-videotoolbox --disable-vaapi --disable-crystalhd \ - --disable-mediacodec --disable-mediafoundation --disable-nvenc --disable-mmal --disable-omx \ - --disable-omx-rpi --disable-cuda --disable-cuvid --disable-libmfx \ - --disable-libnpp --disable-iconv --disable-jni --disable-v4l2_m2m \ - --disable-vulkan --disable-large-tests --disable-stripping \ - --enable-optimizations --disable-nonfree --disable-version3 %(options)s' + btype = BuildType.MESON + meson_options = { + 'avdevice': 'disabled', + 'programs': 'disabled', + 'flac_encoder': 'disabled', + 'protocols': 'disabled', + 'devices': 'disabled', + 'network': 'disabled', + 'hwaccels': 'disabled', + 'dxva2': 'disabled', + 'vdpau': 'disabled', + 'filters': 'disabled', + 'yadif_filter': 'enabled', + # Uncomment the following option once implemented in the port + # 'doc': 'disabled', + 'd3d11va': 'disabled', + 'audiotoolbox': 'disabled', + 'videotoolbox': 'disabled', + 'vaapi': 'disabled', + 'crystalhd': 'disabled', + 'mediacodec': 'disabled', + 'mediafoundation' : 'disabled', + 'nvenc': 'disabled', + 'mmal': 'disabled', + 'omx': 'disabled', + 'omx_rpi': 'disabled', + 'cuda': 'disabled', + 'cuvid': 'disabled', + 'libmfx': 'disabled', + 'libnpp': 'disabled', + 'libnpp': 'disabled', + 'iconv': 'disabled', + 'jni': 'disabled', + 'v4l2_m2m': 'disabled', + 'vulkan': 'disabled', + 'tests': 'disabled', # To not waste time + # These two are redundant with Meson + # 'stripping': 'disabled', + # 'optimizations': 'enabled, + 'nonfree': 'disabled', + 'version3': 'disabled', + } deps = ['bzip2', 'zlib'] - files_libs = ['libavcodec', 'libavformat', 'libavutil', 'libswresample', 'libavfilter'] + files_libs = ['libavcodec', 'libavformat', 'libavutil', 'libswresample', 'libavfilter', 'libpostproc', 'libswscale'] files_devel = [] def prepare(self): + # Arch-specific flags + if self.config.target_arch == Architecture.X86: + if self.config.target_platform == Platform.IOS: + # Simulator doesn't like shared libs + self.library_type = LibraryType.STATIC + elif self.config.target_platform == Platform.ANDROID: + # ld.lld: error: relocation R_386_32 cannot be used against local symbol; recompile with -fPIC + # See https://github.com/FFmpeg/FFmpeg/blob/n6.0/libavutil/x86/x86inc.asm#L104-L108 + self.meson_options['asm'] = 'disabled' + # Populate self.files_devel files_devel_tpl = ['%(libdir)s/{}.la', '%(libdir)s/pkgconfig/{}.pc', 'include/{}'] - # ffmpeg can only build either shared or static on Windows, not both - if self.config.target_platform == Platform.WINDOWS: - self.library_type = LibraryType.SHARED - else: + if self.library_type != LibraryType.SHARED: files_devel_tpl += ['%(libdir)s/{}.a'] for lib in self.files_libs: self.files_devel += [tpl.format(lib) for tpl in files_devel_tpl] - # Default AS is $CC, except iOS (set below) - if Architecture.is_arm(self.config.target_arch): - if self.config.target_platform == Platform.IOS: - gas = self.get_env('GAS') - if gas: - self.set_env('AS', gas) - self.set_env('ASFLAGS', self.get_env('CPPFLAGS')) - else: - cc = self.get_env('CC') - if cc: - self.set_env('AS', cc) - - libavextraconf = '' - # Arch-specific flags - if self.config.target_platform == Platform.ANDROID: - if self.config.target_arch == Architecture.X86: - # libav internally aligns stacks, while Android doesn't - libavextraconf += " --extra-cflags='-mstackrealign'" - if self.config.target_arch in [Architecture.X86]: - # Fails to link into an android app with relocation warnings - # in the custom assembly - # https://stackoverflow.com/questions/34691970/ffmpeg-for-android-neon-build-has-text-relocations/34697703#34697703 - # https://issuetracker.google.com/issues/37067983 - # https://trac.ffmpeg.org/ticket/4928 - libavextraconf += " --disable-asm" - elif self.config.target_platform == Platform.IOS: - # Some optimisations that were previously silently disabled - # cause warnings now. Ignore them - libavextraconf += " --extra-cflags='-Wno-ignored-optimization-argument' " - if self.config.target_arch == Architecture.X86: - # Fails to link in gst-libav due to text relocations in - # custom assembly: - # ld: illegal text-relocation to 'anon' in libavfilter.a(vf_yadif.o) - # from '_ff_yadif_filter_line_ssse3' in libavfilter.a(vf_yadif.o) - # for architecture i386 - libavextraconf += ' --disable-asm ' - - # On windows, being a multilib toolchain, we have to always configure - # the cross-prefix - if self.config.cross_compiling() or \ - self.config.target_platform == Platform.WINDOWS: - libavextraconf += ' --enable-cross-compile' - target_os = self.config.target_platform - if target_os == Platform.WINDOWS: - target_os = 'mingw32' - elif target_os == Platform.IOS: - target_os = 'darwin' - target_arch = self.config.host.split('-', 1)[0] - if target_arch == 'aarch64': - target_arch = 'arm64' - libavextraconf += ' --target-os=' + target_os - libavextraconf += ' --arch=' + target_arch - libavextraconf += ' --cross-prefix={} '\ - .format(self.config.tools_prefix or self.config.host) - - self.configure_options += libavextraconf - # On Windows, make fails if V=1 is passed with: - # `couldn't commit memory for cygwin heap, Win32 error 0` - if self.config.platform == Platform.WINDOWS: - self.make.remove('V=1') - - async def configure(self): - await super(recipe.Recipe, self).configure() - libav_path = self.build_dir - if self.config.target_platform in [Platform.DARWIN, Platform.IOS]: - if self.config.target_arch == Architecture.X86: - replacements = {'HAVE_EBX_AVAILABLE=yes': 'HAVE_EBX_AVAILABLE=no', - 'HAVE_EBX_AVAILABLE 1': 'HAVE_EBX_AVAILABLE 0',} - shell.replace(os.path.join(libav_path, 'ffbuild', 'config.mak'), replacements) - shell.replace(os.path.join(libav_path, 'config.h'), replacements) - # log2 and log2f are not provided by bionic, but they are not checked - # properly - elif self.config.target_platform == Platform.ANDROID: - replacements = {'HAVE_LOG2 1': 'HAVE_LOG2 0', - 'HAVE_LOG2F 1': 'HAVE_LOG2F 0',} - shell.replace(os.path.join(libav_path, 'config.h'), replacements) - - v = DistroVersion.get_android_api_version(self.config.target_distro_version) - if self.config.target_arch in [Architecture.ARM, Architecture.ARMv7, Architecture.X86] and v < 21: - replacements = {'-D_FILE_OFFSET_BITS=64': '',} - shell.replace(os.path.join(libav_path, 'ffbuild', 'config.mak'), replacements) - def post_install(self): - LibtoolLibrary('avutil', None, None, None, - self.config.libdir, self.config.target_platform).save() - LibtoolLibrary('swresample', None, None, None, - self.config.libdir, self.config.target_platform, - deps=['avutil']).save() + # Meson does not generate la files LibtoolLibrary('avcodec', None, None, None, self.config.libdir, self.config.target_platform, - deps=['swresample', 'avutil', 'z']).save() + deps=['swresample', 'avutil', 'z'], + static_only=self.library_type == LibraryType.STATIC).save() + LibtoolLibrary('avfilter', None, None, None, + self.config.libdir, self.config.target_platform, + deps=['avformat', 'avcodec', 'swresample', 'avutil'], + static_only=self.library_type == LibraryType.STATIC).save() LibtoolLibrary('avformat', None, None, None, self.config.libdir, self.config.target_platform, - deps=['avcodec', 'swresample', 'avutil', 'bz2', 'z']).save() - LibtoolLibrary('avfilter', None, None, None, + deps=['avcodec', 'swresample', 'avutil', 'bz2', 'z'], + static_only=self.library_type == LibraryType.STATIC).save() + LibtoolLibrary('avutil', None, None, None, + self.config.libdir, self.config.target_platform, + static_only=self.library_type == LibraryType.STATIC).save() + LibtoolLibrary('postproc', None, None, None, + self.config.libdir, self.config.target_platform, + static_only=self.library_type == LibraryType.STATIC).save() + LibtoolLibrary('swresample', None, None, None, + self.config.libdir, self.config.target_platform, + deps=['avutil'], + static_only=self.library_type == LibraryType.STATIC).save() + LibtoolLibrary('swscale', None, None, None, self.config.libdir, self.config.target_platform, - deps=['avformat', 'avcodec', 'swresample', 'avutil']).save() + deps=['avutil'], + static_only=self.library_type == LibraryType.STATIC).save() super().post_install() diff --git a/recipes/ffmpeg/0001-Add-Meson-build.patch b/recipes/ffmpeg/0001-Add-Meson-build.patch new file mode 100644 index 00000000..62642816 --- /dev/null +++ b/recipes/ffmpeg/0001-Add-Meson-build.patch @@ -0,0 +1,13721 @@ +From f415dcb87223d61e13ba2f8fd823bdc4e53a057b Mon Sep 17 00:00:00 2001 +Message-ID: <f415dcb87223d61e13ba2f8fd823bdc4e53a057b.1694124333.git.amy@amyspark.me> +From: "L. E. Segovia" <amy@amyspark.me> +Date: Thu, 7 Sep 2023 22:05:23 +0000 +Subject: [PATCH] Add Meson build + +--- + README.meson | 87 + + capture_build_options.py | 29 + + ci/vs-arm64-cross-file.txt | 14 + + compat/windows/makedef.py | 118 + + depgraph.py | 1274 ++++++++ + depresolver.py | 198 ++ + ffbuild/bin2c.py | 39 + + fftools/meson.build | 72 + + find_things.py | 97 + + find_things_extern.py | 125 + + libavcodec/aarch64/meson.build | 74 + + libavcodec/arm/meson.build | 118 + + libavcodec/libavcodec.v.in | 6 + + libavcodec/meson.build | 1231 ++++++++ + libavcodec/neon/meson.build | 33 + + libavcodec/x86/meson.build | 207 ++ + libavdevice/libavdevice.v.in | 7 + + libavdevice/meson.build | 115 + + libavfilter/aarch64/meson.build | 34 + + libavfilter/dnn/meson.build | 35 + + libavfilter/libavfilter.v.in | 7 + + libavfilter/meson.build | 689 +++++ + libavfilter/x86/meson.build | 128 + + libavformat/libavformat.v.in | 6 + + libavformat/meson.build | 707 +++++ + libavutil/aarch64/meson.build | 43 + + libavutil/arm/meson.build | 47 + + libavutil/libavutil.v.in | 6 + + libavutil/meson.build | 350 +++ + libavutil/version.py | 99 + + libavutil/x86/meson.build | 53 + + libpostproc/libpostproc.v.in | 7 + + libpostproc/meson.build | 69 + + libswresample/aarch64/meson.build | 43 + + libswresample/arm/meson.build | 43 + + libswresample/libswresample.v.in | 7 + + libswresample/meson.build | 89 + + libswresample/x86/meson.build | 45 + + libswscale/aarch64/meson.build | 45 + + libswscale/arm/meson.build | 45 + + libswscale/libswscale.v.in | 7 + + libswscale/meson.build | 98 + + libswscale/x86/meson.build | 53 + + meson.build | 3584 +++++++++++++++++++++++ + meson_options.txt | 2397 +++++++++++++++ + parse_sources.py | 422 +++ + print_things.py | 62 + + rc_workaround.py | 32 + + recursive_selects.py | 65 + + subprojects/win-nasm/download-binary.py | 76 + + subprojects/win-nasm/meson.build | 41 + + subprojects/win-nasm/patch_nasm.py | 15 + + 52 files changed, 13293 insertions(+) + create mode 100644 README.meson + create mode 100644 capture_build_options.py + create mode 100644 ci/vs-arm64-cross-file.txt + create mode 100644 compat/windows/makedef.py + create mode 100644 depgraph.py + create mode 100644 depresolver.py + create mode 100644 ffbuild/bin2c.py + create mode 100644 fftools/meson.build + create mode 100755 find_things.py + create mode 100755 find_things_extern.py + create mode 100644 libavcodec/aarch64/meson.build + create mode 100644 libavcodec/arm/meson.build + create mode 100644 libavcodec/libavcodec.v.in + create mode 100644 libavcodec/meson.build + create mode 100644 libavcodec/neon/meson.build + create mode 100644 libavcodec/x86/meson.build + create mode 100644 libavdevice/libavdevice.v.in + create mode 100644 libavdevice/meson.build + create mode 100644 libavfilter/aarch64/meson.build + create mode 100644 libavfilter/dnn/meson.build + create mode 100644 libavfilter/libavfilter.v.in + create mode 100644 libavfilter/meson.build + create mode 100644 libavfilter/x86/meson.build + create mode 100644 libavformat/libavformat.v.in + create mode 100644 libavformat/meson.build + create mode 100644 libavutil/aarch64/meson.build + create mode 100644 libavutil/arm/meson.build + create mode 100644 libavutil/libavutil.v.in + create mode 100644 libavutil/meson.build + create mode 100644 libavutil/version.py + create mode 100644 libavutil/x86/meson.build + create mode 100644 libpostproc/libpostproc.v.in + create mode 100644 libpostproc/meson.build + create mode 100644 libswresample/aarch64/meson.build + create mode 100644 libswresample/arm/meson.build + create mode 100644 libswresample/libswresample.v.in + create mode 100644 libswresample/meson.build + create mode 100644 libswresample/x86/meson.build + create mode 100644 libswscale/aarch64/meson.build + create mode 100644 libswscale/arm/meson.build + create mode 100644 libswscale/libswscale.v.in + create mode 100644 libswscale/meson.build + create mode 100644 libswscale/x86/meson.build + create mode 100644 meson.build + create mode 100644 meson_options.txt + create mode 100644 parse_sources.py + create mode 100755 print_things.py + create mode 100755 rc_workaround.py + create mode 100644 recursive_selects.py + create mode 100755 subprojects/win-nasm/download-binary.py + create mode 100644 subprojects/win-nasm/meson.build + create mode 100755 subprojects/win-nasm/patch_nasm.py + +diff --git a/README.meson b/README.meson +new file mode 100644 +index 0000000000..d06c0c4dfe +--- /dev/null ++++ b/README.meson +@@ -0,0 +1,87 @@ ++# Building with meson: ++ ++Get meson 0.59, either from your distro's package manager, or using pip: ++ ++``` ++python3 -m pip install meson --user ++``` ++ ++Get ninja from a package manager (dnf, pacman, brew, ..) on Linux ++and MacOS, or with the installer on Windows, then in FFmpeg: ++ ++``` ++meson build && ninja -C build ++``` ++ ++Build FFmpeg without external dependencies: ++``` ++meson --auto-features=disabled build && ninja -C build ++``` ++ ++Known to build on Debian, Arch Linux, Windows, and macOS High Sierra. ++ ++# Running the tests: ++ ++``` ++meson test -C build ++``` ++ ++# Updating the FFmpeg base snapshot of the Meson port ++ ++It's complicated and at the moment not fully documented. It should only be ++needed when updating from one feature version to another, not for minor bug fix ++releases (assuming there aren't too many changes in `configure` between minor ++bug fix releases). ++ ++## Updating the tag ++ ++The procedure is as follows. First, merge the new tag `nMAJOR.MINOR.PATCH` into ++the `meson-MAJOR.MINOR` branch with the `ort` strategy and `theirs` option. ++For instance, if updating to `n5.1.3`, ++ ++```sh ++git merge -Xtheirs n5.1.3 --no-commit ++``` ++ ++This will automatically resolve conflicts to prefer the incoming tag's state, ++but if you're moving between minor versions, it **will result in broken ++files**. You can fix that by backporting the tag's state: ++ ++```sh ++git diff n5.1.3 HEAD <folder or file> | patch -p1 ++``` ++ ++Once done, hit `git commit` and make sure the message is a merge commit and that ++it looks like: ++ ++``` ++Merge tag 'n5.1.3' into meson-5.1 ++ ++FFmpeg 5.1 release ++``` ++ ++## Updating the Meson port ++ ++Once done, you need to apply the following generation scripts, usually with `py ++-3`. Then replace the current generated files with them, but make sure to bring ++back in the manual changes (that's the tedious part). ++ ++- `parse_sources.py` updates the meson.build files trying to keep manually ++ written parts as specified by the `#### --- [END] GENERATED --- ####` ++ specifiers ++ ++- `find_things_extern.py` and `find_things.py` update the meson_options.txt file ++ trying to keep manually written parts as specified by the ++ `#### --- [END] GENERATED [EXTERN|FILTER] OPTIONS --- ####` specifiers, ++ respectively ++ - run the scripts with the flag `--update-options` to trigger the update ++ ++- `recursive_selects.py` works in place, but you need to check the diff and ++ revert some of the changes. ++ ++Finally, bump versions and check what changed in `configure` since the last ++time, which is the other complicated bit, as it requires understanding of the ++somewhat complex ffmpeg build system and of the way it was reimplemented ++for the Meson port. Some documentation of that is at the top of `depgraph.py`. ++ ++Good luck! +diff --git a/capture_build_options.py b/capture_build_options.py +new file mode 100644 +index 0000000000..6e6a84ab86 +--- /dev/null ++++ b/capture_build_options.py +@@ -0,0 +1,29 @@ ++#!/usr/bin/env python3 ++# Copyright (c) 2022 L. E. Segovia <amy@amyspark.me> ++# ++# This file is part of the FFmpeg Meson build ++# ++# This library is free software; you can redistribute it and/or ++# modify it under the terms of the GNU Lesser General Public ++# License as published by the Free Software Foundation; either ++# version 2.1 of the License, or (at your option) any later version. ++# ++# This library is distributed in the hope that it will be useful, ++# but WITHOUT ANY WARRANTY; without even the implied warranty of ++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++# Lesser General Public License for more details. ++# ++# You should have received a copy of the GNU Lesser General Public ++# License along with this library; if not, see <http://www.gnu.org/licenses/>. ++ ++import re ++import os ++ ++if __name__ == '__main__': ++ with open(f'{os.environ["MESON_BUILD_ROOT"]}/meson-logs/meson-log.txt', encoding="utf-8", mode='r') as f: ++ lines = [line for line in f if 'Build Options' in line] ++ ++ options = re.match(r'Build Options:\s+(.+)$', lines[-1]) ++ ++ if options is not None: ++ print(options.group(1)) +diff --git a/ci/vs-arm64-cross-file.txt b/ci/vs-arm64-cross-file.txt +new file mode 100644 +index 0000000000..acfc9b5ade +--- /dev/null ++++ b/ci/vs-arm64-cross-file.txt +@@ -0,0 +1,14 @@ ++[host_machine] ++system = 'windows' ++cpu_family = 'aarch64' ++cpu = 'aarch64' ++endian = 'little' ++ ++[properties] ++needs_exe_wrapper = true ++ ++[binaries] ++ar = 'lib' ++c = 'cl' ++cpp = 'cl' ++pkgconfig = 'false' +diff --git a/compat/windows/makedef.py b/compat/windows/makedef.py +new file mode 100644 +index 0000000000..9b331e5a66 +--- /dev/null ++++ b/compat/windows/makedef.py +@@ -0,0 +1,118 @@ ++#!/usr/bin/env python3 ++# Copyright (c) 2022 L. E. Segovia <amy@amyspark.me> ++# ++# This file is part of the FFmpeg Meson build ++# ++# This library is free software; you can redistribute it and/or ++# modify it under the terms of the GNU Lesser General Public ++# License as published by the Free Software Foundation; either ++# version 2.1 of the License, or (at your option) any later version. ++# ++# This library is distributed in the hope that it will be useful, ++# but WITHOUT ANY WARRANTY; without even the implied warranty of ++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++# Lesser General Public License for more details. ++# ++# You should have received a copy of the GNU Lesser General Public ++# License along with this library; if not, see <http://www.gnu.org/licenses/>. ++ ++import argparse ++import pathlib ++import os ++import re ++import subprocess ++import tempfile ++ ++if __name__ == '__main__': ++ arg_parser = argparse.ArgumentParser( ++ description='Craft the Windows exports file') ++ ++ arg_parser.add_argument('vscript', metavar='VERSION_SCRIPT', ++ type=argparse.FileType('r'), help='Version script') ++ arg_parser.add_argument('--prefix', metavar='PREFIX', ++ help='Prefix for extern symbols') ++ arg_parser.add_argument('--nm', metavar='NM_PATH', type=pathlib.Path, ++ help='If specified, runs this instead of dumpbin (MinGW)') ++ arg_parser.add_argument('--dumpbin', metavar='DUMPBIN_PATH', type=pathlib.Path, ++ help='If specified, runs this instead of nm (MSVC)') ++ arg_parser.add_argument('libname', metavar='FILE', type=pathlib.Path, ++ help='Library to parse') ++ ++ args = arg_parser.parse_args() ++ ++ libname = args.libname ++ ++ if not libname.exists(): ++ raise FileNotFoundError( ++ errno.ENOENT, os.strerror(errno.ENOENT), libname) ++ ++ prefix = args.prefix or '' ++ started = 0 ++ regex = [] ++ ++ for line in args.vscript: ++ # We only care about global symbols ++ if re.match(r'^\s+global:', line): ++ started = 1 ++ line = re.sub(r'^\s+global: *', '', line) ++ else: ++ if re.match('^\s+local:', line): ++ started = 0 ++ ++ if started == 0: ++ continue ++ ++ line = line.replace(';', '') ++ ++ for exp in line.split(): ++ # Remove leading and trailing whitespace ++ regex.append(exp.strip()) ++ ++ if args.nm is not None: ++ # Use eval, since NM="nm -g" ++ # Add -j to ensure only symbol names are output (otherwise in macOS ++ # a race condition can occur in the redirection) ++ s = subprocess.run([args.nm, '--defined-only', ++ '-g', '-j', libname], stdout=subprocess.PIPE, stderr=subprocess.STDOUT, universal_newlines=True, check=False) ++ if s.returncode != 0: ++ # -j was added only in Binutils 2.37 ++ s = subprocess.run([args.nm, '--defined-only', ++ '-g', libname], stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, universal_newlines=True, check=True) ++ dump = s.stdout.splitlines() ++ # Exclude lines with ':' (object name) ++ dump = [x for x in dump if ":" not in x] ++ # Exclude blank lines ++ dump = [x for x in dump if len(x) > 0] ++ # Subst the prefix out ++ dump = [re.sub(f'^{prefix}', '', x) for x in dump] ++ else: ++ dump = subprocess.run([args.dumpbin, '-linkermember:1', libname], ++ stdout=subprocess.PIPE, stderr=subprocess.STDOUT, universal_newlines=True).stdout.splitlines() ++ # Find the index of the first line with ++ # "public symbols", keep the rest ++ # Then the line with " Summary", ++ # delete it and the rest ++ for i, line in enumerate(dump): ++ if 'public symbols' in line: ++ start = i ++ elif re.match(r'\s+Summary', line): ++ end = i ++ dump = dump[start:end] ++ # Substitute prefix out ++ dump = [re.sub(f'\s+{prefix}', ' ', x) for x in dump] ++ # Substitute big chonky spaces out ++ dump = [re.sub(f'\s+', ' ', x) for x in dump] ++ # Exclude blank lines ++ dump = [x for x in dump if len(x) > 0] ++ # Take only the *second* field (split by spaces) ++ # Python's split excludes whitespace at the beginning ++ dump = [x.split()[1] for x in dump] ++ ++ list = [] ++ for exp in regex: ++ for i in dump: ++ if re.match(f'^{exp}', i): ++ list.append(f' {i}') ++ ++ print("EXPORTS") ++ print("\n".join(sorted(set(list)))) +diff --git a/depgraph.py b/depgraph.py +new file mode 100644 +index 0000000000..d6f65769c7 +--- /dev/null ++++ b/depgraph.py +@@ -0,0 +1,1274 @@ ++''' ++This describes a dependency graph as a set of named nodes, the following ++was automatically generated by parsing the configure script, ++see recursive_selects.py ++ ++Each node can contain: ++'deps': All these components must be enabled for the component to be enabled ++'deps_any': At least one of these components must be enabled for the component to be enabled ++'conflict': The component cannot be enabled if any of those components is enabled ++'select': When the component is enabled, all these components must be enabled too ++'suggest': When the component is enabled, all these components *could* be enabled ++'if': If all these components are enabled, this component *could* be enabled ++'if_any': If any of these components are enabled, this component *could* be enabled ++''' ++ ++GRAPH = {'aac_adtstoasc_bsf': {'select': ['adts_header', 'mpeg4audio']}, ++ 'aac_at_decoder': {'deps': ['audiotoolbox'], 'select': ['aac_adtstoasc_bsf']}, ++ 'aac_at_encoder': {'deps': ['audiotoolbox'], 'select': ['audio_frame_queue']}, ++ 'aac_decoder': {'select': ['adts_header', 'mpeg4audio', 'sinewin']}, ++ 'aac_encoder': {'select': ['audio_frame_queue', ++ 'iirfilter', ++ 'lpc', ++ 'sinewin']}, ++ 'aac_fixed_decoder': {'select': ['adts_header', 'mpeg4audio']}, ++ 'aac_latm_decoder': {'select': ['aac_decoder', 'aac_latm_parser']}, ++ 'aac_mf_encoder': {'deps': ['mediafoundation']}, ++ 'aac_parser': {'select': ['adts_header', 'mpeg4audio']}, ++ 'ac3_at_decoder': {'deps': ['audiotoolbox'], 'select': ['ac3_parser']}, ++ 'ac3_decoder': {'select': ['ac3_parser', 'ac3dsp', 'bswapdsp', 'fmtconvert']}, ++ 'ac3_demuxer': {'select': ['ac3_parser']}, ++ 'ac3_encoder': {'select': ['ac3dsp', 'audiodsp', 'me_cmp']}, ++ 'ac3_fixed_decoder': {'select': ['ac3_parser', 'ac3dsp', 'bswapdsp']}, ++ 'ac3_fixed_encoder': {'select': ['ac3dsp', 'audiodsp', 'me_cmp']}, ++ 'ac3_mf_encoder': {'deps': ['mediafoundation']}, ++ 'acelp_kelvin_decoder': {'select': ['audiodsp']}, ++ 'act_demuxer': {'select': ['riffdec']}, ++ 'adpcm_g722_decoder': {'select': ['g722dsp']}, ++ 'adpcm_g722_encoder': {'select': ['g722dsp']}, ++ 'adpcm_ima_qt_at_decoder': {'deps': ['audiotoolbox']}, ++ 'adts_muxer': {'select': ['mpeg4audio']}, ++ 'aesni': {'deps': ['sse42']}, ++ 'agm_decoder': {'select': ['idctdsp']}, ++ 'aic_decoder': {'select': ['golomb', 'idctdsp']}, ++ 'aiff_muxer': {'select': ['iso_media']}, ++ 'alac_at_decoder': {'deps': ['audiotoolbox']}, ++ 'alac_at_encoder': {'deps': ['audiotoolbox'], 'select': ['audio_frame_queue']}, ++ 'alac_encoder': {'select': ['lpc']}, ++ 'aligned_stack': {'if_any': ['aarch64', 'ppc', 'x86']}, ++ 'als_decoder': {'select': ['bswapdsp', 'mpeg4audio']}, ++ 'alsa_indev': {'deps': ['alsa']}, ++ 'alsa_outdev': {'deps': ['alsa']}, ++ 'altivec': {'deps': ['ppc']}, ++ 'amd3dnow': {'deps': ['mmx']}, ++ 'amd3dnowext': {'deps': ['amd3dnow']}, ++ 'ametadata_filter': {'deps': ['avformat']}, ++ 'amf': {'deps_any': ['libdl', 'loadlibrary']}, ++ 'amovie_filter': {'deps': ['avcodec', 'avformat']}, ++ 'amr_nb_at_decoder': {'deps': ['audiotoolbox']}, ++ 'amrnb_decoder': {'select': ['lsp']}, ++ 'amrwb_decoder': {'select': ['lsp']}, ++ 'amv_decoder': {'select': ['sp5x_decoder', 'exif']}, ++ 'amv_encoder': {'select': ['jpegtables', 'mpegvideoenc']}, ++ 'amv_muxer': {'select': ['riffenc']}, ++ 'android_camera_indev': {'deps': ['android', ++ 'camera2ndk', ++ 'mediandk', ++ 'pthreads']}, ++ 'ape_decoder': {'select': ['bswapdsp', 'llauddsp']}, ++ 'apng_decoder': {'select': ['inflate_wrapper']}, ++ 'apng_encoder': {'select': ['deflate_wrapper', 'llvidencdsp']}, ++ 'aptx_encoder': {'select': ['audio_frame_queue']}, ++ 'aptx_hd_encoder': {'select': ['audio_frame_queue']}, ++ 'aresample_filter': {'deps': ['swresample']}, ++ 'armv5te': {'deps': ['arm']}, ++ 'armv6': {'deps': ['arm']}, ++ 'armv6t2': {'deps': ['arm']}, ++ 'armv8': {'deps': ['aarch64']}, ++ 'asf_demuxer': {'select': ['riffdec']}, ++ 'asf_muxer': {'select': ['riffenc']}, ++ 'asf_o_demuxer': {'select': ['riffdec']}, ++ 'asf_stream_muxer': {'select': ['asf_muxer']}, ++ 'asr_filter': {'deps': ['pocketsphinx']}, ++ 'ass_filter': {'deps': ['libass']}, ++ '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']}, ++ 'async_protocol': {'deps': ['threads']}, ++ 'atomics_gcc': {'if': ['sync_val_compare_and_swap']}, ++ 'atomics_suncc': {'if': ['atomic_cas_ptr', 'machine_rw_barrier']}, ++ 'atomics_win32': {'if': ['memorybarrier']}, ++ 'atrac1_decoder': {'select': ['sinewin']}, ++ 'audiotoolbox_outdev': {'deps': ['audiotoolbox', 'pthreads', 'coreaudio']}, # MANUAL https://ffmpeg.org/pipermail/ffmpeg-devel/2023-July/312785.html ++ 'av1_amf_encoder': {'deps': ['amf']}, ++ 'av1_cuvid_decoder': {'deps': ['cuvid', 'cuvidav1picparams']}, ++ 'av1_d3d11va2_hwaccel': {'deps': ['d3d11va', 'dxva_picparams_av1'], ++ 'select': ['av1_decoder']}, ++ 'av1_d3d11va_hwaccel': {'deps': ['d3d11va', 'dxva_picparams_av1'], ++ 'select': ['av1_decoder']}, ++ 'av1_decoder': {'select': ['av1_frame_split_bsf', 'cbs_av1']}, ++ 'av1_demuxer': {'select': ['av1_frame_merge_bsf', 'av1_parser']}, ++ 'av1_dxva2_hwaccel': {'deps': ['dxva2', 'dxva_picparams_av1'], ++ 'select': ['av1_decoder']}, ++ 'av1_frame_merge_bsf': {'select': ['cbs_av1']}, ++ 'av1_frame_split_bsf': {'select': ['cbs_av1']}, ++ 'av1_mediacodec_decoder': {'deps': ['mediacodec']}, ++ 'av1_metadata_bsf': {'select': ['cbs_av1']}, ++ 'av1_nvdec_hwaccel': {'deps': ['nvdec', 'cuvidav1picparams'], ++ 'select': ['av1_decoder']}, ++ 'av1_nvenc_encoder': {'deps': ['nvenc', 'nv_enc_pic_params_av1'], ++ 'select': ['atsc_a53']}, ++ 'av1_parser': {'select': ['cbs_av1']}, ++ 'av1_qsv_decoder': {'select': ['qsvdec']}, ++ 'av1_qsv_encoder': {'deps': ['libvpl'], 'select': ['qsvenc']}, ++ 'av1_vaapi_hwaccel': {'deps': ['vaapi', ++ 'vadecpictureparameterbufferav1_bit_depth_idx'], ++ 'select': ['av1_decoder']}, ++ 'av1_vdpau_hwaccel': {'deps': ['vdpau', 'vdppictureinfoav1'], ++ 'select': ['av1_decoder']}, ++ 'avcodec': {'deps': ['avutil'], 'suggest': ['libm', 'stdatomic']}, ++ 'avdevice': {'deps': ['avformat', 'avcodec', 'avutil'], ++ 'suggest': ['libm', 'stdatomic']}, ++ 'avfilter': {'deps': ['avutil'], 'suggest': ['libm', 'stdatomic']}, ++ 'avformat': {'deps': ['avcodec', 'avutil'], ++ 'suggest': ['libm', 'network', 'zlib', 'stdatomic']}, ++ 'avfoundation_indev': {'deps': ['avfoundation', ++ 'corevideo', ++ 'coremedia', ++ 'pthreads'], ++ 'suggest': ['coregraphics', 'applicationservices']}, ++ 'avgblur_opencl_filter': {'deps': ['opencl']}, ++ 'avgblur_vulkan_filter': {'deps': ['vulkan', 'spirv_compiler']}, ++ 'avi_demuxer': {'select': ['riffdec', 'exif']}, ++ 'avi_muxer': {'select': ['riffenc']}, ++ 'avif_muxer': {'select': ['mov_muxer']}, ++ 'avio_http_serve_files': {'deps': ['avformat', 'avutil', 'fork']}, ++ 'avio_list_dir': {'deps': ['avformat', 'avutil']}, ++ 'avio_read_callback': {'deps': ['avformat', 'avcodec', 'avutil']}, ++ 'avisynth': {'deps_any': ['libdl', 'loadlibrary']}, ++ 'avisynth_demuxer': {'deps': ['avisynth'], 'select': ['riffdec']}, ++ 'avutil': {'suggest': ['clock_gettime', ++ 'ffnvcodec', ++ 'libm', ++ 'libdrm', ++ 'libmfx', ++ 'opencl', ++ 'user32', ++ 'vaapi', ++ 'vulkan', ++ 'videotoolbox', ++ 'corefoundation', ++ 'corevideo', ++ 'coremedia', ++ 'bcrypt', ++ 'stdatomic']}, ++ 'avx': {'deps': ['sse42']}, ++ 'avx2': {'deps': ['avx']}, ++ 'avx512': {'deps': ['avx2']}, ++ 'avx512icl': {'deps': ['avx512']}, ++ 'azmq_filter': {'deps': ['libzmq']}, ++ 'bilateral_cuda_filter': {'deps': ['ffnvcodec'], ++ 'deps_any': ['cuda_nvcc', 'cuda_llvm']}, ++ 'bink_decoder': {'select': ['blockdsp', 'hpeldsp']}, ++ 'binkaudio_dct_decoder': {'select': ['wma_freqs']}, ++ 'binkaudio_rdft_decoder': {'select': ['wma_freqs']}, ++ 'bktr_indev': {'deps_any': ['dev_bktr_ioctl_bt848_h', ++ 'machine_ioctl_bt848_h', ++ 'dev_video_bktr_ioctl_bt848_h', ++ 'dev_ic_bt8xx_h']}, ++ 'blackframe_filter': {'deps': ['gpl']}, ++ 'blend_vulkan_filter': {'deps': ['vulkan', 'spirv_compiler']}, ++ 'bluray_protocol': {'deps': ['libbluray']}, ++ 'boxblur_filter': {'deps': ['gpl']}, ++ 'boxblur_opencl_filter': {'deps': ['opencl', 'gpl']}, ++ 'bs2b_filter': {'deps': ['libbs2b']}, ++ 'caca_outdev': {'deps': ['libcaca']}, ++ 'caf_demuxer': {'select': ['iso_media']}, ++ 'caf_muxer': {'select': ['iso_media']}, ++ 'cavs_decoder': {'select': ['blockdsp', ++ 'golomb', ++ 'h264chroma', ++ 'idctdsp', ++ 'qpeldsp', ++ 'videodsp']}, ++ 'cbs_av1': {'select': ['cbs']}, ++ 'cbs_h264': {'select': ['cbs']}, ++ 'cbs_h265': {'select': ['cbs']}, ++ 'cbs_jpeg': {'select': ['cbs']}, ++ 'cbs_mpeg2': {'select': ['cbs']}, ++ 'cbs_vp9': {'select': ['cbs']}, ++ 'chromaber_vulkan_filter': {'deps': ['vulkan', 'spirv_compiler']}, ++ 'chromakey_cuda_filter': {'deps': ['ffnvcodec'], ++ 'deps_any': ['cuda_nvcc', 'cuda_llvm']}, ++ 'chromaprint_muxer': {'deps': ['chromaprint']}, ++ 'clearvideo_decoder': {'select': ['idctdsp']}, ++ 'cllc_decoder': {'select': ['bswapdsp']}, ++ 'colorkey_opencl_filter': {'deps': ['opencl']}, ++ 'colormatrix_filter': {'deps': ['gpl']}, ++ 'colorspace_cuda_filter': {'deps': ['ffnvcodec'], ++ 'deps_any': ['cuda_nvcc', 'cuda_llvm']}, ++ 'comfortnoise_encoder': {'select': ['lpc']}, ++ 'convolution_opencl_filter': {'deps': ['opencl']}, ++ 'cook_decoder': {'select': ['audiodsp', 'sinewin']}, ++ 'coreimage_filter': {'deps': ['coreimage', 'appkit']}, ++ 'coreimagesrc_filter': {'deps': ['coreimage', 'appkit']}, ++ 'cover_rect_filter': {'deps': ['avcodec', 'avformat', 'gpl']}, ++ 'cpunop': {'deps': ['i686']}, ++ 'cri_decoder': {'select': ['mjpeg_decoder']}, ++ 'cropdetect_filter': {'deps': ['gpl']}, ++ 'crystalhd': {'deps': ['libcrystalhd_libcrystalhd_if_h']}, ++ 'cscd_decoder': {'suggest': ['zlib']}, ++ 'cuda': {'deps': ['ffnvcodec']}, ++ 'cuvid': {'deps': ['ffnvcodec']}, ++ 'd3d11va': {'deps': ['dxva_h', 'id3d11videodecoder', 'id3d11videocontext']}, ++ 'dash_demuxer': {'deps': ['libxml2']}, ++ 'dash_muxer': {'select': ['mp4_muxer']}, ++ 'dcbzl': {'deps': ['ppc']}, ++ 'dct': {'select': ['rdft']}, ++ 'ddagrab_filter': {'deps': ['d3d11va', ++ 'idxgioutput1', ++ 'dxgi_outdupl_frame_info']}, ++ 'dds_decoder': {'select': ['texturedsp']}, ++ 'decklink': {'deps_any': ['libdl', 'loadlibrary']}, ++ 'decklink_indev': {'deps': ['decklink', 'threads'], 'suggest': ['libzvbi']}, ++ 'decklink_outdev': {'deps': ['decklink', 'threads'], 'suggest': ['libklvanc']}, ++ 'decode_audio_example': {'deps': ['avcodec', 'avutil']}, ++ 'decode_filter_audio_example': {'deps': ['avfilter', ++ 'avcodec', ++ 'avformat', ++ 'avutil']}, ++ 'decode_filter_video_example': {'deps': ['avfilter', ++ 'avcodec', ++ 'avformat', ++ 'avutil']}, ++ 'decode_video_example': {'deps': ['avcodec', 'avutil']}, ++ 'deflate_wrapper': {'deps': ['zlib']}, ++ 'deinterlace_qsv_filter': {'deps': ['libmfx'], 'select': ['qsvvpp']}, ++ 'deinterlace_vaapi_filter': {'deps': ['vaapi']}, ++ 'delogo_filter': {'deps': ['gpl']}, ++ 'demux_decode_example': {'deps': ['avcodec', 'avformat', 'avutil']}, ++ 'denoise_vaapi_filter': {'deps': ['vaapi']}, ++ 'derain_filter': {'select': ['dnn']}, ++ 'deshake_filter': {'select': ['pixelutils']}, ++ 'deshake_opencl_filter': {'deps': ['opencl']}, ++ 'dilation_opencl_filter': {'deps': ['opencl']}, ++ 'dirac_decoder': {'select': ['dirac_parse', ++ 'dwt', ++ 'golomb', ++ 'videodsp', ++ 'mpegvideoenc']}, ++ 'dirac_demuxer': {'select': ['dirac_parser']}, ++ 'dirac_parse': {'select': ['golomb']}, ++ 'dnn': {'deps': ['avformat', 'swscale'], ++ 'suggest': ['libtensorflow', 'libopenvino']}, ++ 'dnn_classify_filter': {'select': ['dnn']}, ++ 'dnn_detect_filter': {'select': ['dnn']}, ++ 'dnn_processing_filter': {'select': ['dnn']}, ++ 'dnxhd_decoder': {'select': ['blockdsp', 'idctdsp']}, ++ 'dnxhd_encoder': {'select': ['blockdsp', ++ 'fdctdsp', ++ 'idctdsp', ++ 'mpegvideoenc', ++ 'pixblockdsp', ++ 'videodsp']}, ++ 'doc': {'deps_any': ['manpages', 'htmlpages', 'podpages', 'txtpages']}, ++ 'dovi_rpu': {'select': ['golomb']}, ++ 'drawtext_filter': {'deps': ['libfreetype'], ++ 'suggest': ['libfontconfig', 'libfribidi']}, ++ 'dshow_indev': {'deps': ['ibasefilter']}, ++ 'dts2pts_bsf': {'select': ['cbs_h264', 'h264parse']}, ++ 'dts_demuxer': {'select': ['dca_parser']}, ++ 'dtshd_demuxer': {'select': ['dca_parser']}, ++ 'dv_demuxer': {'select': ['dvprofile']}, ++ 'dv_muxer': {'select': ['dvprofile']}, ++ 'dvvideo_decoder': {'select': ['dvprofile', 'idctdsp']}, ++ 'dvvideo_encoder': {'select': ['dvprofile', ++ 'fdctdsp', ++ 'me_cmp', ++ 'pixblockdsp']}, ++ 'dxa_decoder': {'deps': ['zlib']}, ++ 'dxa_demuxer': {'select': ['riffdec']}, ++ 'dxv_decoder': {'select': ['lzf', 'texturedsp']}, ++ 'dxva2': {'deps': ['dxva2api_h', ++ 'dxva2_configpicturedecode', ++ 'ole32', ++ 'user32']}, ++ 'eac3_at_decoder': {'deps': ['audiotoolbox'], 'select': ['ac3_parser']}, ++ 'eac3_core_bsf': {'select': ['ac3_parser']}, ++ 'eac3_decoder': {'select': ['ac3_decoder']}, ++ 'eac3_demuxer': {'select': ['ac3_parser']}, ++ 'eac3_encoder': {'select': ['ac3_encoder']}, ++ 'eamad_decoder': {'select': ['aandcttables', 'blockdsp', 'bswapdsp']}, ++ 'eatgq_decoder': {'select': ['aandcttables']}, ++ 'eatqi_decoder': {'select': ['aandcttables', 'blockdsp', 'bswapdsp']}, ++ 'elbg_filter': {'deps': ['avcodec']}, ++ 'encode_audio_example': {'deps': ['avcodec', 'avutil']}, ++ 'encode_video_example': {'deps': ['avcodec', 'avutil']}, ++ 'eq_filter': {'deps': ['gpl']}, ++ 'erosion_opencl_filter': {'deps': ['opencl']}, ++ 'error_resilience': {'select': ['me_cmp']}, ++ 'exr_decoder': {'deps': ['zlib']}, ++ 'exr_encoder': {'deps': ['zlib']}, ++ 'extract_mvs_example': {'deps': ['avcodec', 'avformat', 'avutil']}, ++ 'f4v_muxer': {'select': ['mov_muxer']}, ++ 'faandct': {'deps': ['faan'], 'select': ['fdctdsp']}, ++ 'faanidct': {'deps': ['faan'], 'select': ['idctdsp']}, ++ 'fast_64bit': {'if_any': ['aarch64', ++ 'alpha', ++ 'ia64', ++ 'mips64', ++ 'parisc64', ++ 'ppc64', ++ 'riscv64', ++ 'sparc64', ++ 'x86_64']}, ++ 'fast_clz': {'if_any': ['aarch64', 'alpha', 'avr32', 'mips', 'ppc', 'x86']}, ++ 'fast_unaligned': {'if_any': ['aarch64', 'ppc', 'x86']}, ++ 'fbdev_indev': {'deps': ['linux_fb_h']}, ++ 'fbdev_outdev': {'deps': ['linux_fb_h']}, ++ 'ffmpeg': {'deps': ['avcodec', 'avfilter', 'avformat', 'threads'], ++ 'suggest': ['ole32', 'psapi', 'shell32']}, ++ 'ffnvcodec': {'deps_any': ['libdl', 'loadlibrary']}, ++ 'ffplay': {'deps': ['avcodec', 'avformat', 'swscale', 'swresample', 'sdl2'], ++ 'select': ['rdft', ++ 'crop_filter', ++ 'transpose_filter', ++ 'hflip_filter', ++ 'vflip_filter', ++ 'rotate_filter'], ++ 'suggest': ['shell32']}, ++ 'ffprobe': {'deps': ['avcodec', 'avformat'], 'suggest': ['shell32']}, ++ 'ffrtmpcrypt_protocol': {'conflict': ['librtmp_protocol'], ++ 'deps_any': ['gcrypt', 'gmp', 'openssl', 'mbedtls'], ++ 'select': ['tcp_protocol']}, ++ 'ffrtmphttp_protocol': {'conflict': ['librtmp_protocol'], ++ 'select': ['http_protocol']}, ++ 'ffv1_decoder': {'select': ['rangecoder']}, ++ 'ffv1_encoder': {'select': ['rangecoder']}, ++ 'ffvhuff_decoder': {'select': ['huffyuv_decoder']}, ++ 'ffvhuff_encoder': {'select': ['huffyuv_encoder']}, ++ 'fic_decoder': {'select': ['golomb']}, ++ 'fifo_muxer': {'deps': ['threads']}, ++ 'filter_audio_example': {'deps': ['avfilter', 'avutil']}, ++ 'filter_units_bsf': {'select': ['cbs']}, ++ 'find_rect_filter': {'deps': ['avcodec', 'avformat', 'gpl']}, ++ 'flac_demuxer': {'select': ['flac_parser']}, ++ 'flac_encoder': {'select': ['bswapdsp', 'lpc']}, ++ 'flashsv2_decoder': {'select': ['inflate_wrapper']}, ++ 'flashsv2_encoder': {'select': ['deflate_wrapper']}, ++ 'flashsv_decoder': {'select': ['inflate_wrapper']}, ++ 'flashsv_encoder': {'deps': ['zlib']}, ++ 'flip_vulkan_filter': {'deps': ['vulkan', 'spirv_compiler']}, ++ 'flite_filter': {'deps': ['libflite', 'threads']}, ++ 'flv_decoder': {'select': ['h263_decoder']}, ++ 'flv_encoder': {'select': ['h263_encoder']}, ++ 'flv_muxer': {'select': ['aac_adtstoasc_bsf']}, ++ 'fma3': {'deps': ['avx']}, ++ 'fma4': {'deps': ['avx']}, ++ 'fourxm_decoder': {'select': ['blockdsp', 'bswapdsp']}, ++ 'frame_thread_encoder': {'deps': ['encoders', 'threads']}, ++ 'framerate_filter': {'select': ['scene_sad']}, ++ 'fraps_decoder': {'select': ['bswapdsp', 'huffman']}, ++ 'freezedetect_filter': {'select': ['scene_sad']}, ++ 'frei0r': {'deps_any': ['libdl', 'loadlibrary']}, ++ 'frei0r_filter': {'deps': ['frei0r']}, ++ 'frei0r_src_filter': {'deps': ['frei0r']}, ++ 'fspp_filter': {'deps': ['gpl']}, ++ 'ftp_protocol': {'select': ['tcp_protocol']}, ++ 'g2m_decoder': {'deps': ['zlib'], ++ 'select': ['blockdsp', 'idctdsp', 'jpegtables']}, ++ 'g729_decoder': {'select': ['audiodsp']}, ++ 'gblur_vulkan_filter': {'deps': ['vulkan', 'spirv_compiler']}, ++ 'gdigrab_indev': {'deps': ['createdibsection'], 'select': ['bmp_decoder']}, ++ 'gopher_protocol': {'select': ['tcp_protocol']}, ++ 'gophers_protocol': {'select': ['tls_protocol']}, ++ 'gsm_ms_at_decoder': {'deps': ['audiotoolbox']}, ++ 'gxf_muxer': {'select': ['pcm_rechunk_bsf']}, ++ 'h261_decoder': {'select': ['mpegvideodec']}, ++ 'h261_encoder': {'select': ['mpegvideoenc']}, ++ 'h263_decoder': {'select': ['h263_parser', ++ 'h263dsp', ++ 'mpegvideodec', ++ 'qpeldsp']}, ++ 'h263_encoder': {'select': ['h263dsp', 'mpegvideoenc']}, ++ 'h263_v4l2m2m_decoder': {'deps': ['v4l2_m2m', 'h263_v4l2_m2m']}, ++ 'h263_v4l2m2m_encoder': {'deps': ['v4l2_m2m', 'h263_v4l2_m2m']}, ++ 'h263_vaapi_hwaccel': {'deps': ['vaapi'], 'select': ['h263_decoder']}, ++ 'h263_videotoolbox_hwaccel': {'deps': ['videotoolbox'], ++ 'select': ['h263_decoder']}, ++ 'h263i_decoder': {'select': ['h263_decoder']}, ++ 'h263p_decoder': {'select': ['h263_decoder']}, ++ 'h263p_encoder': {'select': ['h263_encoder']}, ++ 'h264_amf_encoder': {'deps': ['amf']}, ++ 'h264_crystalhd_decoder': {'select': ['crystalhd', ++ 'h264_mp4toannexb_bsf', ++ 'h264_parser']}, ++ 'h264_cuvid_decoder': {'deps': ['cuvid'], 'select': ['h264_mp4toannexb_bsf']}, ++ 'h264_d3d11va2_hwaccel': {'deps': ['d3d11va'], 'select': ['h264_decoder']}, ++ 'h264_d3d11va_hwaccel': {'deps': ['d3d11va'], 'select': ['h264_decoder']}, ++ 'h264_decoder': {'select': ['cabac', ++ 'golomb', ++ 'h264chroma', ++ 'h264dsp', ++ 'h264parse', ++ 'h264pred', ++ 'h264qpel', ++ 'h264_sei', ++ 'videodsp'], ++ 'suggest': ['error_resilience']}, ++ 'h264_dxva2_hwaccel': {'deps': ['dxva2'], 'select': ['h264_decoder']}, ++ 'h264_mediacodec_decoder': {'deps': ['mediacodec'], ++ 'select': ['h264_mp4toannexb_bsf', 'h264_parser']}, ++ 'h264_mediacodec_encoder': {'deps': ['mediacodec'], ++ 'select': ['h264_metadata']}, ++ 'h264_metadata_bsf': {'deps': ['const_nan'], 'select': ['cbs_h264']}, ++ 'h264_mf_encoder': {'deps': ['mediafoundation']}, ++ 'h264_mmal_decoder': {'deps': ['mmal']}, ++ 'h264_nvdec_hwaccel': {'deps': ['nvdec'], 'select': ['h264_decoder']}, ++ 'h264_nvenc_encoder': {'deps': ['nvenc'], 'select': ['atsc_a53']}, ++ 'h264_omx_encoder': {'deps': ['omx']}, ++ 'h264_parser': {'select': ['golomb', 'h264dsp', 'h264parse', 'h264_sei']}, ++ 'h264_qsv_decoder': {'select': ['h264_mp4toannexb_bsf', 'qsvdec']}, ++ 'h264_qsv_encoder': {'select': ['atsc_a53', 'qsvenc']}, ++ 'h264_redundant_pps_bsf': {'select': ['cbs_h264']}, ++ 'h264_rkmpp_decoder': {'deps': ['rkmpp'], 'select': ['h264_mp4toannexb_bsf']}, ++ 'h264_sei': {'select': ['atsc_a53', 'golomb']}, ++ 'h264_v4l2m2m_decoder': {'deps': ['v4l2_m2m', 'h264_v4l2_m2m'], ++ 'select': ['h264_mp4toannexb_bsf']}, ++ 'h264_v4l2m2m_encoder': {'deps': ['v4l2_m2m', 'h264_v4l2_m2m']}, ++ 'h264_vaapi_encoder': {'select': ['atsc_a53', 'cbs_h264', 'vaapi_encode']}, ++ 'h264_vaapi_hwaccel': {'deps': ['vaapi'], 'select': ['h264_decoder']}, ++ 'h264_vdpau_hwaccel': {'deps': ['vdpau'], 'select': ['h264_decoder']}, ++ 'h264_videotoolbox_encoder': {'deps': ['pthreads'], ++ 'select': ['atsc_a53', 'videotoolbox_encoder']}, ++ 'h264_videotoolbox_hwaccel': {'deps': ['videotoolbox'], ++ 'select': ['h264_decoder']}, ++ 'h264dsp': {'select': ['startcode']}, ++ 'hap_decoder': {'select': ['snappy', 'texturedsp']}, ++ 'hap_encoder': {'deps': ['libsnappy'], 'select': ['texturedspenc']}, ++ 'hds_muxer': {'select': ['flv_muxer']}, ++ 'hevc_amf_encoder': {'deps': ['amf']}, ++ 'hevc_cuvid_decoder': {'deps': ['cuvid'], 'select': ['hevc_mp4toannexb_bsf']}, ++ 'hevc_d3d11va2_hwaccel': {'deps': ['d3d11va', 'dxva_picparams_hevc'], ++ 'select': ['hevc_decoder']}, ++ 'hevc_d3d11va_hwaccel': {'deps': ['d3d11va', 'dxva_picparams_hevc'], ++ 'select': ['hevc_decoder']}, ++ 'hevc_decoder': {'select': ['bswapdsp', ++ 'cabac', ++ 'dovi_rpu', ++ 'golomb', ++ 'hevcparse', ++ 'hevc_sei', ++ 'videodsp']}, ++ 'hevc_dxva2_hwaccel': {'deps': ['dxva2', 'dxva_picparams_hevc'], ++ 'select': ['hevc_decoder']}, ++ 'hevc_mediacodec_decoder': {'deps': ['mediacodec'], ++ 'select': ['hevc_mp4toannexb_bsf', 'hevc_parser']}, ++ 'hevc_mediacodec_encoder': {'deps': ['mediacodec'], ++ 'select': ['hevc_metadata']}, ++ 'hevc_metadata_bsf': {'select': ['cbs_h265']}, ++ 'hevc_mf_encoder': {'deps': ['mediafoundation']}, ++ 'hevc_nvdec_hwaccel': {'deps': ['nvdec'], 'select': ['hevc_decoder']}, ++ 'hevc_nvenc_encoder': {'deps': ['nvenc'], 'select': ['atsc_a53']}, ++ 'hevc_parser': {'select': ['hevcparse', 'hevc_sei']}, ++ 'hevc_qsv_decoder': {'select': ['hevc_mp4toannexb_bsf', 'qsvdec']}, ++ 'hevc_qsv_encoder': {'select': ['hevcparse', 'qsvenc']}, ++ 'hevc_rkmpp_decoder': {'deps': ['rkmpp'], 'select': ['hevc_mp4toannexb_bsf']}, ++ 'hevc_sei': {'select': ['atsc_a53', 'golomb']}, ++ 'hevc_v4l2m2m_decoder': {'deps': ['v4l2_m2m', 'hevc_v4l2_m2m'], ++ 'select': ['hevc_mp4toannexb_bsf']}, ++ 'hevc_v4l2m2m_encoder': {'deps': ['v4l2_m2m', 'hevc_v4l2_m2m']}, ++ 'hevc_vaapi_encoder': {'deps': ['vaencpictureparameterbufferhevc'], ++ 'select': ['atsc_a53', 'cbs_h265', 'vaapi_encode']}, ++ 'hevc_vaapi_hwaccel': {'deps': ['vaapi', 'vapictureparameterbufferhevc'], ++ 'select': ['hevc_decoder']}, ++ 'hevc_vdpau_hwaccel': {'deps': ['vdpau', 'vdppictureinfohevc'], ++ 'select': ['hevc_decoder']}, ++ 'hevc_videotoolbox_encoder': {'deps': ['pthreads'], ++ 'select': ['atsc_a53', 'videotoolbox_encoder']}, ++ 'hevc_videotoolbox_hwaccel': {'deps': ['videotoolbox'], ++ 'select': ['hevc_decoder']}, ++ 'hevcparse': {'select': ['golomb']}, ++ 'hflip_vulkan_filter': {'deps': ['vulkan', 'spirv_compiler']}, ++ 'histeq_filter': {'deps': ['gpl']}, ++ 'hls_demuxer': {'select': ['adts_header', ++ 'ac3_parser', ++ 'mov_demuxer', ++ 'mpegts_demuxer']}, ++ 'hls_muxer': {'select': ['mov_muxer', 'mpegts_muxer'], ++ 'suggest': ['gcrypt', 'openssl']}, ++ 'hqdn3d_filter': {'deps': ['gpl']}, ++ 'hstack_qsv_filter': {'deps': ['libmfx'], 'select': ['qsvvpp']}, ++ 'hstack_vaapi_filter': {'deps': ['vaapi_1']}, ++ 'htmlpages': {'deps': ['perl'], 'deps_any': ['makeinfo_html', 'texi2html']}, ++ 'http_protocol': {'select': ['tcp_protocol'], 'suggest': ['zlib']}, ++ 'httpproxy_protocol': {'select': ['tcp_protocol'], 'suggest': ['zlib']}, ++ 'https_protocol': {'select': ['tls_protocol'], 'suggest': ['zlib']}, ++ 'huffyuv_decoder': {'select': ['bswapdsp', 'huffyuvdsp', 'llviddsp']}, ++ 'huffyuv_encoder': {'select': ['bswapdsp', ++ 'huffman', ++ 'huffyuvencdsp', ++ 'llvidencdsp']}, ++ 'hw_decode_example': {'deps': ['avcodec', 'avformat', 'avutil']}, ++ 'hwupload_cuda_filter': {'deps': ['ffnvcodec']}, ++ 'hymt_decoder': {'select': ['huffyuv_decoder']}, ++ 'i686': {'deps': ['x86']}, ++ 'iac_decoder': {'select': ['imc_decoder']}, ++ 'iccdetect_filter': {'deps': ['lcms2']}, ++ 'iccgen_filter': {'deps': ['lcms2']}, ++ 'icecast_protocol': {'select': ['http_protocol']}, ++ 'iec61883_indev': {'deps': ['libiec61883'], 'select': ['dv_demuxer']}, ++ 'ilbc_at_decoder': {'deps': ['audiotoolbox']}, ++ 'ilbc_at_encoder': {'deps': ['audiotoolbox'], 'select': ['audio_frame_queue']}, ++ 'image2_alias_pix_demuxer': {'select': ['image2_demuxer']}, ++ 'image2_brender_pix_demuxer': {'select': ['image2_demuxer']}, ++ 'imc_decoder': {'select': ['bswapdsp', 'sinewin']}, ++ 'imf_demuxer': {'deps': ['libxml2'], 'select': ['mxf_demuxer']}, ++ 'imm4_decoder': {'select': ['bswapdsp', 'idctdsp']}, ++ 'imm5_decoder': {'select': ['h264_decoder', 'hevc_decoder']}, ++ 'indeo3_decoder': {'select': ['hpeldsp']}, ++ 'indeo4_decoder': {'select': ['ividsp']}, ++ 'indeo5_decoder': {'select': ['ividsp']}, ++ 'inflate_wrapper': {'deps': ['zlib']}, ++ 'interlace_filter': {'deps': ['gpl']}, ++ 'interplay_video_decoder': {'select': ['hpeldsp']}, ++ 'intrax8': {'select': ['blockdsp', 'wmv2dsp']}, ++ 'intrinsics_neon': {'deps': ['neon']}, ++ 'ipfs_gateway_protocol': {'select': ['https_protocol']}, ++ 'ipns_gateway_protocol': {'select': ['https_protocol']}, ++ 'ipod_muxer': {'select': ['mov_muxer']}, ++ 'ipu_decoder': {'select': ['mpegvideodec']}, ++ 'ismv_muxer': {'select': ['mov_muxer']}, ++ 'iso_media': {'select': ['mpeg4audio']}, ++ 'ivf_muxer': {'select': ['av1_metadata_bsf', 'vp9_superframe_bsf']}, ++ 'jack_indev': {'deps': ['libjack'], ++ 'deps_any': ['sem_timedwait', 'dispatch_dispatch_h']}, ++ 'jpegls_decoder': {'select': ['mjpeg_decoder']}, ++ 'jv_decoder': {'select': ['blockdsp']}, ++ 'kerndeint_filter': {'deps': ['gpl']}, ++ 'kmsgrab_indev': {'deps': ['libdrm']}, ++ 'ladspa_filter': {'deps': ['ladspa', 'libdl']}, ++ 'lagarith_decoder': {'select': ['llviddsp']}, ++ 'lasx': {'deps': ['lsx']}, ++ 'latm_muxer': {'select': ['aac_adtstoasc_bsf', 'mpeg4audio']}, ++ 'lavfi_indev': {'deps': ['avfilter']}, ++ 'ldbrx': {'deps': ['ppc']}, ++ 'lensfun_filter': {'deps': ['liblensfun', 'version3']}, ++ 'libamqp_protocol': {'deps': ['librabbitmq'], 'select': ['network']}, ++ 'libaom_av1_decoder': {'deps': ['libaom']}, ++ 'libaom_av1_encoder': {'deps': ['libaom'], ++ 'select': ['extract_extradata_bsf']}, ++ 'libaribb24_decoder': {'deps': ['libaribb24']}, ++ 'libcdio_indev': {'deps': ['libcdio']}, ++ 'libcelt_decoder': {'deps': ['libcelt']}, ++ 'libcodec2_decoder': {'deps': ['libcodec2']}, ++ 'libcodec2_encoder': {'deps': ['libcodec2']}, ++ 'libdav1d_decoder': {'deps': ['libdav1d'], 'select': ['atsc_a53']}, ++ 'libdavs2_decoder': {'deps': ['libdavs2'], 'select': ['avs2_parser']}, ++ 'libdc1394_indev': {'deps': ['libdc1394']}, ++ 'libfdk_aac_decoder': {'deps': ['libfdk_aac']}, ++ 'libfdk_aac_encoder': {'deps': ['libfdk_aac'], ++ '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']}, ++ 'libjxl_decoder': {'deps': ['libjxl', 'libjxl_threads']}, ++ 'libjxl_encoder': {'deps': ['libjxl', 'libjxl_threads']}, ++ 'libkvazaar_encoder': {'deps': ['libkvazaar']}, ++ 'libmodplug_demuxer': {'deps': ['libmodplug']}, ++ 'libmp3lame_encoder': {'deps': ['libmp3lame'], ++ 'select': ['audio_frame_queue', 'mpegaudioheader']}, ++ 'libopencore_amrnb_decoder': {'deps': ['libopencore_amrnb']}, ++ 'libopencore_amrnb_encoder': {'deps': ['libopencore_amrnb'], ++ 'select': ['audio_frame_queue']}, ++ 'libopencore_amrwb_decoder': {'deps': ['libopencore_amrwb']}, ++ 'libopenh264_decoder': {'deps': ['libopenh264'], ++ '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'], 'select': ['audio_frame_queue']}, ++ 'libplacebo_filter': {'deps': ['libplacebo', 'vulkan']}, ++ 'librav1e_encoder': {'deps': ['librav1e']}, ++ 'librist_protocol': {'deps': ['librist'], 'select': ['network']}, ++ 'librsvg_decoder': {'deps': ['librsvg']}, ++ 'librtmp_protocol': {'deps': ['librtmp']}, ++ 'librtmpe_protocol': {'deps': ['librtmp']}, ++ 'librtmps_protocol': {'deps': ['librtmp']}, ++ 'librtmpt_protocol': {'deps': ['librtmp']}, ++ 'librtmpte_protocol': {'deps': ['librtmp']}, ++ 'libshine_encoder': {'deps': ['libshine'], ++ 'select': ['audio_frame_queue', 'mpegaudioheader']}, ++ 'libsmbclient_protocol': {'deps': ['libsmbclient', 'gplv3']}, ++ 'libspeex_decoder': {'deps': ['libspeex']}, ++ 'libspeex_encoder': {'deps': ['libspeex'], 'select': ['audio_frame_queue']}, ++ 'libsrt_protocol': {'deps': ['libsrt'], 'select': ['network']}, ++ 'libssh_protocol': {'deps': ['libssh']}, ++ 'libsvtav1_encoder': {'deps': ['libsvtav1']}, ++ 'libtheora_encoder': {'deps': ['libtheora']}, ++ 'libtls': {'conflict': ['openssl', 'gnutls', 'mbedtls']}, ++ 'libtwolame_encoder': {'deps': ['libtwolame']}, ++ 'libuavs3d_decoder': {'deps': ['libuavs3d']}, ++ 'libvmaf_filter': {'deps': ['libvmaf']}, ++ 'libvo_amrwbenc_encoder': {'deps': ['libvo_amrwbenc']}, ++ 'libvorbis_decoder': {'deps': ['libvorbis']}, ++ 'libvorbis_encoder': {'deps': ['libvorbis', 'libvorbisenc'], ++ '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_anim_encoder': {'deps': ['libwebp']}, ++ 'libwebp_encoder': {'deps': ['libwebp']}, ++ 'libx262_encoder': {'deps': ['libx262']}, ++ 'libx264_encoder': {'deps': ['libx264'], 'select': ['atsc_a53']}, ++ 'libx264rgb_encoder': {'deps': ['libx264'], 'select': ['libx264_encoder']}, ++ 'libx265_encoder': {'deps': ['libx265'], 'select': ['atsc_a53']}, ++ 'libxavs2_encoder': {'deps': ['libxavs2']}, ++ 'libxavs_encoder': {'deps': ['libxavs']}, ++ 'libxvid_encoder': {'deps': ['libxvid']}, ++ 'libzmq_protocol': {'deps': ['libzmq'], 'select': ['network']}, ++ 'libzvbi_teletext_decoder': {'deps': ['libzvbi']}, ++ 'linux_perf': {'deps': ['linux_perf_event_h']}, ++ 'ljpeg_encoder': {'select': ['jpegtables']}, ++ 'loongson2': {'deps': ['mips']}, ++ 'loongson3': {'deps': ['mips']}, ++ 'lscr_decoder': {'select': ['inflate_wrapper']}, ++ 'lsx': {'deps': ['loongarch']}, ++ 'lv2_filter': {'deps': ['lv2']}, ++ 'magicyuv_decoder': {'select': ['llviddsp']}, ++ 'magicyuv_encoder': {'select': ['llvidencdsp']}, ++ 'manpages': {'deps': ['perl', 'pod2man']}, ++ 'matroska_audio_muxer': {'select': ['matroska_muxer']}, ++ 'matroska_demuxer': {'select': ['riffdec'], 'suggest': ['bzlib', 'zlib']}, ++ 'matroska_muxer': {'select': ['mpeg4audio', ++ 'riffenc', ++ 'aac_adtstoasc_bsf', ++ 'pgs_frame_merge_bsf', ++ 'vp9_superframe_bsf']}, ++ 'mcdeint_filter': {'deps': ['avcodec', 'gpl']}, ++ 'mdct': {'select': ['fft']}, ++ 'mdec_decoder': {'select': ['blockdsp', 'bswapdsp', 'idctdsp']}, ++ 'me_cmp': {'select': ['idctdsp']}, ++ 'media100_decoder': {'select': ['media100_to_mjpegb_bsf', 'mjpegb_decoder']}, ++ 'mediafoundation': {'deps': ['mftransform_h', 'mfcreatealignedmemorybuffer']}, ++ 'metadata_filter': {'deps': ['avformat']}, ++ 'metasound_decoder': {'select': ['lsp', 'sinewin']}, ++ 'mimic_decoder': {'select': ['blockdsp', 'bswapdsp', 'hpeldsp', 'idctdsp']}, ++ 'minterpolate_filter': {'select': ['scene_sad']}, ++ 'mips32r2': {'deps': ['mips']}, ++ 'mips32r5': {'deps': ['mips']}, ++ 'mips32r6': {'deps': ['mips']}, ++ 'mips64r2': {'deps': ['mips']}, ++ 'mips64r6': {'deps': ['mips']}, ++ 'mipsdsp': {'deps': ['mips']}, ++ 'mipsdspr2': {'deps': ['mips']}, ++ 'mipsfpu': {'deps': ['mips']}, ++ 'mjpeg2jpeg_bsf': {'select': ['jpegtables']}, ++ 'mjpeg_cuvid_decoder': {'deps': ['cuvid']}, ++ 'mjpeg_decoder': {'select': ['blockdsp', ++ 'hpeldsp', ++ 'exif', ++ 'idctdsp', ++ 'jpegtables']}, ++ 'mjpeg_encoder': {'select': ['jpegtables', 'mpegvideoenc']}, ++ 'mjpeg_nvdec_hwaccel': {'deps': ['nvdec'], 'select': ['mjpeg_decoder']}, ++ 'mjpeg_qsv_decoder': {'select': ['qsvdec']}, ++ 'mjpeg_qsv_encoder': {'deps': ['libmfx'], 'select': ['qsvenc']}, ++ 'mjpeg_vaapi_encoder': {'deps': ['vaencpictureparameterbufferjpeg'], ++ 'select': ['cbs_jpeg', 'jpegtables', 'vaapi_encode']}, ++ 'mjpeg_vaapi_hwaccel': {'deps': ['vaapi'], 'select': ['mjpeg_decoder']}, ++ 'mjpegb_decoder': {'select': ['mjpeg_decoder']}, ++ 'mlp_decoder': {'select': ['mlp_parser']}, ++ 'mlp_demuxer': {'select': ['mlp_parser']}, ++ 'mlp_encoder': {'select': ['lpc', 'audio_frame_queue']}, ++ 'mmf_muxer': {'select': ['riffenc']}, ++ 'mmi': {'deps_any': ['loongson2', 'loongson3']}, ++ 'mmsh_protocol': {'select': ['http_protocol']}, ++ 'mmst_protocol': {'select': ['network']}, ++ 'mmx': {'deps': ['x86'], 'suggest': ['mmx_external', 'mmx_inline']}, ++ 'mmx_external': {'deps': ['x86asm']}, ++ 'mmx_inline': {'deps': ['inline_asm', 'x86']}, ++ 'mmxext': {'deps': ['mmx']}, ++ 'mobiclip_decoder': {'select': ['bswapdsp', 'golomb']}, ++ 'motionpixels_decoder': {'select': ['bswapdsp']}, ++ 'mov_demuxer': {'select': ['iso_media', 'riffdec'], 'suggest': ['zlib']}, ++ 'mov_muxer': {'select': ['iso_media', ++ 'riffenc', ++ 'rtpenc_chain', ++ 'vp9_superframe_bsf', ++ 'aac_adtstoasc_bsf', ++ 'ac3_parser']}, ++ 'movie_filter': {'deps': ['avcodec', 'avformat']}, ++ 'mp1_at_decoder': {'deps': ['audiotoolbox'], 'select': ['mpegaudioheader']}, ++ 'mp1_decoder': {'select': ['mpegaudio']}, ++ 'mp1float_decoder': {'select': ['mpegaudio']}, ++ 'mp2_at_decoder': {'deps': ['audiotoolbox'], 'select': ['mpegaudioheader']}, ++ 'mp2_decoder': {'select': ['mpegaudio']}, ++ 'mp2float_decoder': {'select': ['mpegaudio']}, ++ 'mp3_at_decoder': {'deps': ['audiotoolbox'], 'select': ['mpegaudioheader']}, ++ 'mp3_decoder': {'select': ['mpegaudio']}, ++ 'mp3_demuxer': {'select': ['mpegaudio_parser']}, ++ 'mp3_mf_encoder': {'deps': ['mediafoundation']}, ++ 'mp3_muxer': {'select': ['mpegaudioheader']}, ++ 'mp3adu_decoder': {'select': ['mpegaudio']}, ++ 'mp3adufloat_decoder': {'select': ['mpegaudio']}, ++ 'mp3float_decoder': {'select': ['mpegaudio']}, ++ 'mp3on4_decoder': {'select': ['mpegaudio', 'mpeg4audio']}, ++ 'mp3on4float_decoder': {'select': ['mpegaudio', 'mpeg4audio']}, ++ 'mp4_muxer': {'select': ['mov_muxer']}, ++ 'mpc7_decoder': {'select': ['bswapdsp', 'mpegaudiodsp']}, ++ 'mpc8_decoder': {'select': ['mpegaudiodsp']}, ++ 'mpdecimate_filter': {'deps': ['gpl'], 'select': ['pixelutils']}, ++ 'mpeg1_cuvid_decoder': {'deps': ['cuvid']}, ++ 'mpeg1_nvdec_hwaccel': {'deps': ['nvdec'], 'select': ['mpeg1video_decoder']}, ++ 'mpeg1_v4l2m2m_decoder': {'deps': ['v4l2_m2m', 'mpeg1_v4l2_m2m']}, ++ 'mpeg1_vdpau_hwaccel': {'deps': ['vdpau'], 'select': ['mpeg1video_decoder']}, ++ 'mpeg1_videotoolbox_hwaccel': {'deps': ['videotoolbox'], ++ 'select': ['mpeg1video_decoder']}, ++ 'mpeg1video_decoder': {'select': ['mpegvideodec']}, ++ 'mpeg1video_encoder': {'select': ['mpegvideoenc']}, ++ 'mpeg2_crystalhd_decoder': {'select': ['crystalhd']}, ++ 'mpeg2_cuvid_decoder': {'deps': ['cuvid']}, ++ 'mpeg2_d3d11va2_hwaccel': {'deps': ['d3d11va'], ++ 'select': ['mpeg2video_decoder']}, ++ 'mpeg2_d3d11va_hwaccel': {'deps': ['d3d11va'], ++ 'select': ['mpeg2video_decoder']}, ++ 'mpeg2_dxva2_hwaccel': {'deps': ['dxva2'], 'select': ['mpeg2video_decoder']}, ++ 'mpeg2_mediacodec_decoder': {'deps': ['mediacodec']}, ++ 'mpeg2_metadata_bsf': {'select': ['cbs_mpeg2']}, ++ 'mpeg2_mmal_decoder': {'deps': ['mmal']}, ++ 'mpeg2_nvdec_hwaccel': {'deps': ['nvdec'], 'select': ['mpeg2video_decoder']}, ++ 'mpeg2_qsv_decoder': {'select': ['qsvdec']}, ++ 'mpeg2_qsv_encoder': {'select': ['qsvenc']}, ++ 'mpeg2_v4l2m2m_decoder': {'deps': ['v4l2_m2m', 'mpeg2_v4l2_m2m']}, ++ 'mpeg2_vaapi_encoder': {'select': ['cbs_mpeg2', 'vaapi_encode']}, ++ 'mpeg2_vaapi_hwaccel': {'deps': ['vaapi'], 'select': ['mpeg2video_decoder']}, ++ 'mpeg2_vdpau_hwaccel': {'deps': ['vdpau'], 'select': ['mpeg2video_decoder']}, ++ 'mpeg2_videotoolbox_hwaccel': {'deps': ['videotoolbox'], ++ 'select': ['mpeg2video_decoder']}, ++ 'mpeg2video_decoder': {'select': ['mpegvideodec']}, ++ 'mpeg2video_encoder': {'select': ['mpegvideoenc']}, ++ 'mpeg4_crystalhd_decoder': {'select': ['crystalhd']}, ++ 'mpeg4_cuvid_decoder': {'deps': ['cuvid']}, ++ 'mpeg4_decoder': {'select': ['h263_decoder', 'mpeg4video_parser']}, ++ 'mpeg4_encoder': {'select': ['h263_encoder', 'qpeldsp']}, ++ 'mpeg4_mediacodec_decoder': {'deps': ['mediacodec']}, ++ 'mpeg4_mmal_decoder': {'deps': ['mmal']}, ++ 'mpeg4_nvdec_hwaccel': {'deps': ['nvdec'], 'select': ['mpeg4_decoder']}, ++ 'mpeg4_omx_encoder': {'deps': ['omx']}, ++ 'mpeg4_v4l2m2m_decoder': {'deps': ['v4l2_m2m', 'mpeg4_v4l2_m2m']}, ++ 'mpeg4_v4l2m2m_encoder': {'deps': ['v4l2_m2m', 'mpeg4_v4l2_m2m']}, ++ 'mpeg4_vaapi_hwaccel': {'deps': ['vaapi'], 'select': ['mpeg4_decoder']}, ++ 'mpeg4_vdpau_hwaccel': {'deps': ['vdpau'], 'select': ['mpeg4_decoder']}, ++ 'mpeg4_videotoolbox_hwaccel': {'deps': ['videotoolbox'], ++ 'select': ['mpeg4_decoder']}, ++ 'mpeg4video_parser': {'select': ['h263dsp', 'mpegvideodec', 'qpeldsp']}, ++ 'mpeg_er': {'select': ['error_resilience']}, ++ 'mpegaudio': {'select': ['mpegaudiodsp', 'mpegaudioheader']}, ++ 'mpegaudio_parser': {'select': ['mpegaudioheader']}, ++ 'mpegaudiodsp': {'select': ['dct']}, ++ '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']}, ++ 'mpegvideo': {'select': ['blockdsp', 'hpeldsp', 'idctdsp', 'videodsp']}, ++ 'mpegvideo_decoder': {'select': ['mpegvideodec']}, ++ 'mpegvideodec': {'select': ['h264chroma', 'mpegvideo', 'mpeg_er']}, ++ 'mpegvideoenc': {'select': ['aandcttables', ++ 'fdctdsp', ++ 'me_cmp', ++ 'mpegvideo', ++ 'pixblockdsp']}, ++ 'mptestsrc_filter': {'deps': ['gpl']}, ++ 'msa': {'deps': ['mipsfpu']}, ++ 'msa1_decoder': {'select': ['mss34dsp']}, ++ 'mscc_decoder': {'select': ['inflate_wrapper']}, ++ 'msmpeg4_crystalhd_decoder': {'select': ['crystalhd']}, ++ 'msmpeg4dec': {'select': ['h263_decoder']}, ++ 'msmpeg4enc': {'select': ['h263_encoder']}, ++ 'msmpeg4v1_decoder': {'select': ['msmpeg4dec']}, ++ 'msmpeg4v2_decoder': {'select': ['msmpeg4dec']}, ++ 'msmpeg4v2_encoder': {'select': ['msmpeg4enc']}, ++ 'msmpeg4v3_decoder': {'select': ['msmpeg4dec']}, ++ 'msmpeg4v3_encoder': {'select': ['msmpeg4enc']}, ++ 'mss2_decoder': {'select': ['mpegvideodec', 'qpeldsp', 'vc1_decoder']}, ++ 'mts2_decoder': {'select': ['jpegtables', 'mss34dsp']}, ++ 'mux_example': {'deps': ['avcodec', 'avformat', 'avutil', 'swscale']}, ++ 'mv30_decoder': {'select': ['aandcttables', 'blockdsp']}, ++ 'mvha_decoder': {'select': ['inflate_wrapper', 'llviddsp']}, ++ 'mwsc_decoder': {'select': ['inflate_wrapper']}, ++ 'mxf_d10_muxer': {'select': ['mxf_muxer']}, ++ 'mxf_muxer': {'select': ['pcm_rechunk_bsf']}, ++ 'mxf_opatom_muxer': {'select': ['mxf_muxer']}, ++ 'mxpeg_decoder': {'select': ['mjpeg_decoder']}, ++ 'negate_filter': {'deps': ['lut_filter']}, ++ 'nellymoser_decoder': {'select': ['sinewin']}, ++ 'nellymoser_encoder': {'select': ['audio_frame_queue', 'sinewin']}, ++ 'neon': {'deps_any': ['aarch64', 'arm']}, ++ 'nlmeans_opencl_filter': {'deps': ['opencl']}, ++ 'nnedi_filter': {'deps': ['gpl']}, ++ 'notchlc_decoder': {'select': ['lzf']}, ++ 'nut_muxer': {'select': ['riffenc']}, ++ 'nuv_decoder': {'select': ['idctdsp']}, ++ 'nuv_demuxer': {'select': ['riffdec']}, ++ 'nvdec': {'deps': ['ffnvcodec']}, ++ 'nvenc': {'deps': ['ffnvcodec'], 'deps_any': ['libdl', 'loadlibrary']}, ++ 'obu_demuxer': {'select': ['av1_frame_merge_bsf', 'av1_parser']}, ++ 'obu_muxer': {'select': ['av1_metadata_bsf']}, ++ 'ocr_filter': {'deps': ['libtesseract']}, ++ 'ocv_filter': {'deps': ['libopencv']}, ++ 'oga_muxer': {'select': ['ogg_muxer']}, ++ 'ogg_demuxer': {'select': ['dirac_parse']}, ++ 'ogv_muxer': {'select': ['ogg_muxer']}, ++ 'omx': {'deps': ['libdl', 'pthreads']}, ++ 'omx_rpi': {'select': ['omx']}, ++ 'openal_indev': {'deps': ['openal']}, ++ 'openclsrc_filter': {'deps': ['opencl']}, ++ 'opengl_outdev': {'deps': ['opengl'], 'suggest': ['sdl2']}, ++ 'opus_decoder': {'deps': ['swresample']}, ++ 'opus_encoder': {'select': ['audio_frame_queue']}, ++ 'opus_muxer': {'select': ['ogg_muxer']}, ++ 'oss_indev': {'deps_any': ['sys_soundcard_h']}, ++ 'oss_outdev': {'deps_any': ['sys_soundcard_h']}, ++ 'overlay_cuda_filter': {'deps': ['ffnvcodec'], ++ 'deps_any': ['cuda_nvcc', 'cuda_llvm']}, ++ 'overlay_opencl_filter': {'deps': ['opencl']}, ++ 'overlay_qsv_filter': {'deps': ['libmfx'], 'select': ['qsvvpp']}, ++ 'overlay_vaapi_filter': {'deps': ['vaapi', 'vaprocpipelinecaps_blend_flags']}, ++ 'overlay_vulkan_filter': {'deps': ['vulkan', 'spirv_compiler']}, ++ 'owdenoise_filter': {'deps': ['gpl']}, ++ 'pad_opencl_filter': {'deps': ['opencl']}, ++ 'pan_filter': {'deps': ['swresample']}, ++ 'pcm_alaw_at_decoder': {'deps': ['audiotoolbox']}, ++ 'pcm_alaw_at_encoder': {'deps': ['audiotoolbox'], ++ 'select': ['audio_frame_queue']}, ++ 'pcm_mulaw_at_decoder': {'deps': ['audiotoolbox']}, ++ 'pcm_mulaw_at_encoder': {'deps': ['audiotoolbox'], ++ 'select': ['audio_frame_queue']}, ++ 'perspective_filter': {'deps': ['gpl']}, ++ 'phase_filter': {'deps': ['gpl']}, ++ 'pixfmts_super2xsai_test': {'deps': ['super2xsai_filter']}, ++ 'png_decoder': {'select': ['inflate_wrapper']}, ++ 'png_encoder': {'select': ['deflate_wrapper', 'llvidencdsp']}, ++ 'podpages': {'deps': ['perl']}, ++ # See configure line 7531 -- requirement is a sham ++ 'postproc': {'deps': ['avutil'], 'suggest': ['libm', 'stdatomic']}, # MANUAL ++ 'power8': {'deps': ['vsx']}, ++ 'pp7_filter': {'deps': ['gpl']}, ++ 'pp_filter': {'deps': ['gpl', 'postproc']}, ++ 'ppc4xx': {'deps': ['ppc']}, ++ 'prewitt_opencl_filter': {'deps': ['opencl']}, ++ 'procamp_vaapi_filter': {'deps': ['vaapi']}, ++ 'program_opencl_filter': {'deps': ['opencl']}, ++ 'prores_aw_encoder': {'select': ['fdctdsp']}, ++ 'prores_decoder': {'select': ['blockdsp', 'idctdsp']}, ++ 'prores_encoder': {'select': ['fdctdsp']}, ++ 'prores_ks_encoder': {'select': ['fdctdsp']}, ++ 'prores_videotoolbox_encoder': {'deps': ['pthreads'], ++ 'select': ['videotoolbox_encoder']}, ++ 'prores_videotoolbox_hwaccel': {'deps': ['videotoolbox'], ++ 'select': ['prores_decoder']}, ++ 'psp_muxer': {'select': ['mov_muxer']}, ++ 'pullup_filter': {'deps': ['gpl']}, ++ 'pulse_indev': {'deps': ['libpulse']}, ++ 'pulse_outdev': {'deps': ['libpulse']}, ++ 'qcelp_decoder': {'select': ['lsp']}, ++ 'qdm2_at_decoder': {'deps': ['audiotoolbox']}, ++ 'qdm2_decoder': {'select': ['mpegaudiodsp']}, ++ 'qdmc_at_decoder': {'deps': ['audiotoolbox']}, ++ 'qsv': {'deps': ['libmfx']}, ++ 'qsv_decode_example': {'deps': ['avcodec', ++ 'avutil', ++ 'libmfx', ++ 'h264_qsv_decoder']}, ++ 'qsv_transcode_example': {'deps': ['avcodec', ++ 'avformat', ++ 'avutil', ++ 'h264_qsv_encoder']}, ++ 'qsvdec': {'select': ['qsv']}, ++ 'qsvenc': {'select': ['qsv']}, ++ 'qsvvpp': {'select': ['qsv']}, ++ 'ra_144_decoder': {'select': ['audiodsp']}, ++ 'ra_144_encoder': {'select': ['audio_frame_queue', 'lpc', 'audiodsp']}, ++ 'ralf_decoder': {'select': ['golomb']}, ++ 'rasc_decoder': {'select': ['inflate_wrapper']}, ++ 'rawvideo_decoder': {'select': ['bswapdsp']}, ++ 'rdft': {'select': ['fft']}, ++ 'remap_opencl_filter': {'deps': ['opencl']}, ++ 'removelogo_filter': {'deps': ['avcodec', 'avformat', 'swscale']}, ++ 'remux_example': {'deps': ['avcodec', 'avformat', 'avutil']}, ++ 'repeatfields_filter': {'deps': ['gpl']}, ++ 'resample_audio_example': {'deps': ['avutil', 'swresample']}, ++ 'roberts_opencl_filter': {'deps': ['opencl']}, ++ 'rscc_decoder': {'deps': ['zlib']}, ++ 'rtmp_protocol': {'conflict': ['librtmp_protocol'], ++ 'select': ['tcp_protocol'], ++ 'suggest': ['zlib']}, ++ 'rtmpe_protocol': {'select': ['ffrtmpcrypt_protocol'], 'suggest': ['zlib']}, ++ 'rtmps_protocol': {'conflict': ['librtmp_protocol'], ++ 'select': ['tls_protocol'], ++ 'suggest': ['zlib']}, ++ 'rtmpt_protocol': {'select': ['ffrtmphttp_protocol'], 'suggest': ['zlib']}, ++ 'rtmpte_protocol': {'select': ['ffrtmpcrypt_protocol', 'ffrtmphttp_protocol'], ++ 'suggest': ['zlib']}, ++ 'rtmpts_protocol': {'select': ['ffrtmphttp_protocol', 'https_protocol'], ++ 'suggest': ['zlib']}, ++ 'rtp_demuxer': {'select': ['sdp_demuxer']}, ++ 'rtp_mpegts_muxer': {'select': ['mpegts_muxer', 'rtp_muxer']}, ++ 'rtp_protocol': {'select': ['udp_protocol']}, ++ 'rtpdec': {'select': ['asf_demuxer', ++ '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']}, ++ 'rubberband_filter': {'deps': ['librubberband']}, ++ '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', ++ 'mpegvideodec', ++ 'rv34dsp']}, ++ 'rv40_decoder': {'select': ['golomb', ++ 'h264pred', ++ 'h264qpel', ++ 'mpegvideodec', ++ 'rv34dsp']}, ++ 'rvv': {'deps': ['riscv']}, ++ 'sab_filter': {'deps': ['gpl', 'swscale']}, ++ 'sap_demuxer': {'select': ['sdp_demuxer']}, ++ 'sap_muxer': {'select': ['rtp_muxer', 'rtp_protocol', 'rtpenc_chain']}, ++ 'scale2ref_filter': {'deps': ['swscale']}, ++ 'scale2ref_npp_filter': {'deps': ['ffnvcodec', 'libnpp']}, ++ 'scale_cuda_filter': {'deps': ['ffnvcodec'], ++ 'deps_any': ['cuda_nvcc', 'cuda_llvm']}, ++ 'scale_filter': {'deps': ['swscale']}, ++ 'scale_npp_filter': {'deps': ['ffnvcodec', 'libnpp']}, ++ 'scale_qsv_filter': {'deps': ['libmfx'], 'select': ['qsvvpp']}, ++ 'scale_vaapi_filter': {'deps': ['vaapi']}, ++ 'scale_video_example': {'deps': ['avutil', 'swscale']}, ++ 'scale_vulkan_filter': {'deps': ['vulkan', 'spirv_compiler']}, ++ 'scdet_filter': {'select': ['scene_sad']}, ++ 'schannel': {'conflict': ['openssl', 'gnutls', 'libtls', 'mbedtls']}, ++ 'screenpresso_decoder': {'deps': ['zlib']}, ++ 'sctp_protocol': {'deps': ['struct_sctp_event_subscribe', ++ 'struct_msghdr_msg_flags'], ++ 'select': ['network']}, ++ 'sdl2_outdev': {'deps': ['sdl2']}, ++ 'sdp_demuxer': {'select': ['rtpdec']}, ++ 'securetransport': {'conflict': ['openssl', 'gnutls', 'libtls', 'mbedtls']}, ++ 'select_filter': {'select': ['scene_sad']}, ++ 'setend': {'deps': ['arm']}, ++ 'sharpen_npp_filter': {'deps': ['ffnvcodec', 'libnpp']}, ++ 'sharpness_vaapi_filter': {'deps': ['vaapi']}, ++ 'shorten_decoder': {'select': ['bswapdsp']}, ++ 'show_metadata_example': {'deps': ['avformat', 'avutil']}, ++ 'showcqt_filter': {'deps': ['avformat', 'swscale'], ++ 'suggest': ['libfontconfig', 'libfreetype']}, ++ 'signature_filter': {'deps': ['gpl', 'avcodec', 'avformat']}, ++ 'simd_align_16': {'if_any': ['altivec', 'neon', 'sse']}, ++ 'simd_align_32': {'if_any': ['avx']}, ++ 'simd_align_64': {'if_any': ['avx512']}, ++ 'sipr_decoder': {'select': ['lsp']}, ++ 'smartblur_filter': {'deps': ['gpl', 'swscale']}, ++ 'smoothstreaming_muxer': {'select': ['ismv_muxer']}, ++ 'smvjpeg_decoder': {'select': ['mjpeg_decoder']}, ++ 'sndio_indev': {'deps': ['sndio']}, ++ 'sndio_outdev': {'deps': ['sndio']}, ++ 'snow_decoder': {'select': ['dwt', ++ 'h264qpel', ++ 'hpeldsp', ++ 'rangecoder', ++ 'videodsp']}, ++ 'snow_encoder': {'select': ['dwt', ++ 'h264qpel', ++ 'hpeldsp', ++ 'me_cmp', ++ 'mpegvideoenc', ++ 'rangecoder', ++ 'videodsp']}, ++ 'sobel_opencl_filter': {'deps': ['opencl']}, ++ 'sofalizer_filter': {'deps': ['libmysofa']}, ++ 'sonic_decoder': {'select': ['golomb', 'rangecoder']}, ++ 'sonic_encoder': {'select': ['golomb', 'rangecoder']}, ++ 'sonic_ls_encoder': {'select': ['golomb', 'rangecoder']}, ++ 'sp5x_decoder': {'select': ['mjpeg_decoder']}, ++ 'spdif_demuxer': {'select': ['adts_header']}, ++ 'spdif_muxer': {'select': ['adts_header']}, ++ 'speedhq_decoder': {'select': ['blockdsp', 'idctdsp']}, ++ 'speedhq_encoder': {'select': ['mpegvideoenc']}, ++ 'spp_filter': {'deps': ['gpl', 'avcodec'], ++ 'select': ['fft', ++ 'idctdsp', ++ 'fdctdsp', ++ 'me_cmp', ++ 'pixblockdsp']}, ++ 'spx_muxer': {'select': ['ogg_muxer']}, ++ 'sr_filter': {'deps': ['avformat', 'swscale'], 'select': ['dnn']}, ++ 'srgc_decoder': {'select': ['inflate_wrapper']}, ++ 'srtp_protocol': {'select': ['rtp_protocol', 'srtp']}, ++ 'sse': {'deps': ['mmxext']}, ++ 'sse2': {'deps': ['sse']}, ++ 'sse3': {'deps': ['sse2']}, ++ 'sse4': {'deps': ['ssse3']}, ++ 'sse42': {'deps': ['sse4']}, ++ 'ssse3': {'deps': ['sse3']}, ++ 'stereo3d_filter': {'deps': ['gpl']}, ++ 'subtitles_filter': {'deps': ['avformat', 'avcodec', 'libass']}, ++ 'super2xsai_filter': {'deps': ['gpl']}, ++ 'svq1_decoder': {'select': ['hpeldsp']}, ++ 'svq1_encoder': {'select': ['hpeldsp', 'me_cmp', 'mpegvideoenc']}, ++ 'svq3_decoder': {'select': ['golomb', ++ 'h264dsp', ++ 'h264parse', ++ 'h264pred', ++ 'hpeldsp', ++ 'tpeldsp', ++ 'videodsp'], ++ 'suggest': ['zlib']}, ++ 'swf_demuxer': {'suggest': ['zlib']}, ++ 'swresample': {'deps': ['avutil'], ++ 'suggest': ['libm', 'libsoxr', 'stdatomic']}, ++ 'swscale': {'deps': ['avutil'], 'suggest': ['libm', 'stdatomic']}, ++ 'symver': {'if_any': ['symver_asm_label', 'symver_gnu_asm']}, ++ 'tak_decoder': {'select': ['audiodsp']}, ++ 'tak_demuxer': {'select': ['tak_parser']}, ++ 'tcp_protocol': {'select': ['network']}, ++ 'tdsc_decoder': {'deps': ['zlib'], 'select': ['mjpeg_decoder']}, ++ 'tg2_muxer': {'select': ['mov_muxer']}, ++ 'tgp_muxer': {'select': ['mov_muxer']}, ++ 'theora_decoder': {'select': ['vp3_decoder']}, ++ 'thp_decoder': {'select': ['mjpeg_decoder']}, ++ 'thumbnail_cuda_filter': {'deps': ['ffnvcodec'], ++ 'deps_any': ['cuda_nvcc', 'cuda_llvm']}, ++ 'tiff_decoder': {'select': ['mjpeg_decoder'], 'suggest': ['zlib', 'lzma']}, ++ 'tiff_encoder': {'suggest': ['zlib']}, ++ 'tinterlace_filter': {'deps': ['gpl']}, ++ 'tinterlace_merge_test': {'deps': ['tinterlace_filter']}, ++ 'tinterlace_pad_test': {'deps': ['tinterlace_filter']}, ++ 'tls_protocol': {'deps_any': ['gnutls', ++ 'openssl', ++ 'schannel', ++ 'securetransport', ++ 'libtls', ++ 'mbedtls'], ++ 'select': ['tcp_protocol']}, ++ 'tonemap_filter': {'deps': ['const_nan']}, ++ 'tonemap_opencl_filter': {'deps': ['opencl', 'const_nan']}, ++ 'tonemap_vaapi_filter': {'deps': ['vaapi', ++ 'vaprocfilterparameterbufferhdrtonemapping']}, ++ 'trace_headers_bsf': {'select': ['cbs']}, ++ 'transcode_aac_example': {'deps': ['avcodec', 'avformat', 'swresample']}, ++ 'transcode_example': {'deps': ['avfilter', 'avcodec', 'avformat', 'avutil']}, ++ 'transpose_npp_filter': {'deps': ['ffnvcodec', 'libnpp']}, ++ 'transpose_opencl_filter': {'deps': ['opencl']}, ++ 'transpose_vaapi_filter': {'deps': ['vaapi', ++ 'vaprocpipelinecaps_rotation_flags']}, ++ 'transpose_vulkan_filter': {'deps': ['vulkan', 'spirv_compiler']}, ++ 'truehd_decoder': {'select': ['mlp_parser']}, ++ 'truehd_demuxer': {'select': ['mlp_parser']}, ++ 'truehd_encoder': {'select': ['lpc', 'audio_frame_queue']}, ++ 'truemotion2_decoder': {'select': ['bswapdsp']}, ++ 'truespeech_decoder': {'select': ['bswapdsp']}, ++ 'tscc_decoder': {'select': ['inflate_wrapper']}, ++ 'twinvq_decoder': {'select': ['lsp', 'sinewin']}, ++ 'txd_decoder': {'select': ['texturedsp']}, ++ 'txtpages': {'deps': ['perl', 'makeinfo']}, ++ 'udp_protocol': {'select': ['network']}, ++ 'udplite_protocol': {'select': ['network']}, ++ 'unix_protocol': {'deps': ['sys_un_h'], 'select': ['network']}, ++ 'unsharp_opencl_filter': {'deps': ['opencl']}, ++ 'uspp_filter': {'deps': ['gpl', 'avcodec']}, ++ 'utvideo_decoder': {'select': ['bswapdsp', 'llviddsp']}, ++ 'utvideo_encoder': {'select': ['bswapdsp', 'huffman', 'llvidencdsp']}, ++ 'v4l2_indev': {'deps_any': ['linux_videodev2_h', 'sys_videoio_h'], ++ 'suggest': ['libv4l2']}, ++ 'v4l2_m2m': {'deps': ['linux_videodev2_h', 'sem_timedwait']}, ++ 'v4l2_outdev': {'deps_any': ['linux_videodev2_h', 'sys_videoio_h'], ++ 'suggest': ['libv4l2']}, ++ 'vaapi_encode': {'deps': ['vaapi']}, ++ 'vaapi_encode_example': {'deps': ['avcodec', 'avutil', 'h264_vaapi_encoder']}, ++ 'vaapi_transcode_example': {'deps': ['avcodec', ++ 'avformat', ++ 'avutil', ++ 'h264_vaapi_encoder']}, ++ 'vaapi_x11': {'deps': ['xlib_x11']}, ++ 'vaguedenoiser_filter': {'deps': ['gpl']}, ++ 'valgrind_backtrace': {'conflict': ['optimizations'], ++ 'deps': ['valgrind_valgrind_h']}, ++ 'vapoursynth_demuxer': {'deps': ['vapoursynth']}, ++ 'vble_decoder': {'select': ['llviddsp']}, ++ 'vbn_decoder': {'select': ['texturedsp']}, ++ 'vbn_encoder': {'select': ['texturedspenc']}, ++ 'vc1_crystalhd_decoder': {'select': ['crystalhd']}, ++ 'vc1_cuvid_decoder': {'deps': ['cuvid']}, ++ 'vc1_d3d11va2_hwaccel': {'deps': ['d3d11va'], 'select': ['vc1_decoder']}, ++ 'vc1_d3d11va_hwaccel': {'deps': ['d3d11va'], 'select': ['vc1_decoder']}, ++ 'vc1_decoder': {'select': ['blockdsp', ++ 'h264qpel', ++ 'intrax8', ++ 'mpegvideodec', ++ 'qpeldsp', ++ 'vc1dsp']}, ++ 'vc1_dxva2_hwaccel': {'deps': ['dxva2'], 'select': ['vc1_decoder']}, ++ 'vc1_mmal_decoder': {'deps': ['mmal']}, ++ 'vc1_nvdec_hwaccel': {'deps': ['nvdec'], 'select': ['vc1_decoder']}, ++ 'vc1_parser': {'select': ['vc1dsp']}, ++ 'vc1_qsv_decoder': {'select': ['qsvdec']}, ++ 'vc1_v4l2m2m_decoder': {'deps': ['v4l2_m2m', 'vc1_v4l2_m2m']}, ++ 'vc1_vaapi_hwaccel': {'deps': ['vaapi'], 'select': ['vc1_decoder']}, ++ 'vc1_vdpau_hwaccel': {'deps': ['vdpau'], 'select': ['vc1_decoder']}, ++ 'vc1dsp': {'select': ['h264chroma', 'qpeldsp', 'startcode']}, ++ 'vc1image_decoder': {'select': ['vc1_decoder']}, ++ 'vflip_vulkan_filter': {'deps': ['vulkan', 'spirv_compiler']}, ++ 'vfp': {'deps_any': ['aarch64', 'arm']}, ++ 'vfpv3': {'deps': ['vfp']}, ++ 'vfwcap_indev': {'deps': ['vfw32', 'vfwcap_defines']}, ++ 'videotoolbox': {'deps': ['corefoundation', 'coremedia', 'corevideo'], ++ 'suggest': ['coreservices']}, ++ 'videotoolbox_encoder': {'deps': ['videotoolbox', ++ 'vtcompressionsessionpreparetoencodeframes']}, ++ 'videotoolbox_hwaccel': {'deps': ['videotoolbox', 'pthreads']}, ++ 'vidstabdetect_filter': {'deps': ['libvidstab']}, ++ 'vidstabtransform_filter': {'deps': ['libvidstab']}, ++ 'vobsub_demuxer': {'select': ['mpegps_demuxer']}, ++ 'vorbis_encoder': {'select': ['audio_frame_queue']}, ++ '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_cuvid_decoder': {'deps': ['cuvid']}, ++ 'vp8_decoder': {'select': ['h264pred', 'videodsp', 'vp8dsp']}, ++ 'vp8_mediacodec_decoder': {'deps': ['mediacodec']}, ++ 'vp8_nvdec_hwaccel': {'deps': ['nvdec'], 'select': ['vp8_decoder']}, ++ 'vp8_qsv_decoder': {'select': ['qsvdec']}, ++ 'vp8_rkmpp_decoder': {'deps': ['rkmpp']}, ++ 'vp8_v4l2m2m_decoder': {'deps': ['v4l2_m2m', 'vp8_v4l2_m2m']}, ++ 'vp8_v4l2m2m_encoder': {'deps': ['v4l2_m2m', 'vp8_v4l2_m2m']}, ++ 'vp8_vaapi_encoder': {'deps': ['vaencpictureparameterbuffervp8'], ++ 'select': ['vaapi_encode']}, ++ 'vp8_vaapi_hwaccel': {'deps': ['vaapi'], 'select': ['vp8_decoder']}, ++ 'vp9_cuvid_decoder': {'deps': ['cuvid']}, ++ 'vp9_d3d11va2_hwaccel': {'deps': ['d3d11va', 'dxva_picparams_vp9'], ++ 'select': ['vp9_decoder']}, ++ 'vp9_d3d11va_hwaccel': {'deps': ['d3d11va', 'dxva_picparams_vp9'], ++ 'select': ['vp9_decoder']}, ++ 'vp9_decoder': {'select': ['videodsp', ++ 'vp9_parser', ++ 'vp9_superframe_split_bsf']}, ++ 'vp9_dxva2_hwaccel': {'deps': ['dxva2', 'dxva_picparams_vp9'], ++ 'select': ['vp9_decoder']}, ++ 'vp9_mediacodec_decoder': {'deps': ['mediacodec']}, ++ 'vp9_metadata_bsf': {'select': ['cbs_vp9']}, ++ 'vp9_nvdec_hwaccel': {'deps': ['nvdec'], 'select': ['vp9_decoder']}, ++ 'vp9_qsv_decoder': {'select': ['qsvdec']}, ++ 'vp9_qsv_encoder': {'deps': ['libmfx', 'mfx_codec_vp9'], 'select': ['qsvenc']}, ++ 'vp9_rkmpp_decoder': {'deps': ['rkmpp']}, ++ 'vp9_v4l2m2m_decoder': {'deps': ['v4l2_m2m', 'vp9_v4l2_m2m']}, ++ 'vp9_vaapi_encoder': {'deps': ['vaencpictureparameterbuffervp9'], ++ 'select': ['vaapi_encode']}, ++ 'vp9_vaapi_hwaccel': {'deps': ['vaapi', ++ 'vadecpictureparameterbuffervp9_bit_depth'], ++ 'select': ['vp9_decoder']}, ++ 'vp9_vdpau_hwaccel': {'deps': ['vdpau', 'vdppictureinfovp9'], ++ 'select': ['vp9_decoder']}, ++ 'vp9_videotoolbox_hwaccel': {'deps': ['videotoolbox'], ++ 'select': ['vp9_decoder']}, ++ 'vpp_qsv_filter': {'deps': ['libmfx'], 'select': ['qsvvpp']}, ++ 'vstack_qsv_filter': {'deps': ['libmfx'], 'select': ['qsvvpp']}, ++ 'vstack_vaapi_filter': {'deps': ['vaapi_1']}, ++ 'vsx': {'deps': ['altivec']}, ++ 'vulkan': {'deps_any': ['libdl', 'loadlibrary']}, ++ 'w32threads': {'deps': ['atomics_native']}, ++ 'w64_demuxer': {'select': ['wav_demuxer']}, ++ 'w64_muxer': {'select': ['wav_muxer']}, ++ 'wav_demuxer': {'select': ['riffdec']}, ++ 'wav_muxer': {'select': ['riffenc']}, ++ 'wcmv_decoder': {'select': ['inflate_wrapper']}, ++ 'webm_chunk_muxer': {'select': ['webm_muxer']}, ++ 'webm_dash_manifest_demuxer': {'select': ['matroska_demuxer']}, ++ 'webp_decoder': {'select': ['vp8_decoder', 'exif']}, ++ 'wmalossless_decoder': {'select': ['llauddsp']}, ++ 'wmapro_decoder': {'select': ['sinewin', 'wma_freqs']}, ++ 'wmav1_decoder': {'select': ['sinewin', 'wma_freqs']}, ++ 'wmav1_encoder': {'select': ['sinewin', 'wma_freqs']}, ++ 'wmav2_decoder': {'select': ['sinewin', 'wma_freqs']}, ++ 'wmav2_encoder': {'select': ['sinewin', 'wma_freqs']}, ++ 'wmavoice_decoder': {'select': ['lsp', 'rdft', 'dct', 'sinewin']}, ++ 'wmv1_decoder': {'select': ['msmpeg4dec']}, ++ 'wmv1_encoder': {'select': ['msmpeg4enc']}, ++ 'wmv2_decoder': {'select': ['blockdsp', ++ 'error_resilience', ++ 'idctdsp', ++ 'intrax8', ++ 'msmpeg4dec', ++ 'videodsp', ++ 'wmv2dsp']}, ++ 'wmv2_encoder': {'select': ['msmpeg4enc', 'wmv2dsp']}, ++ 'wmv3_crystalhd_decoder': {'select': ['crystalhd']}, ++ 'wmv3_d3d11va2_hwaccel': {'select': ['vc1_d3d11va2_hwaccel']}, ++ 'wmv3_d3d11va_hwaccel': {'select': ['vc1_d3d11va_hwaccel']}, ++ 'wmv3_decoder': {'select': ['vc1_decoder']}, ++ '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']}, ++ 'wmv3image_decoder': {'select': ['wmv3_decoder']}, ++ 'wtv_demuxer': {'select': ['mpegts_demuxer', 'riffdec']}, ++ 'wtv_muxer': {'select': ['mpegts_muxer', 'riffenc']}, ++ 'x86_64': {'select': ['i686'], 'suggest': ['fast_cmov']}, ++ 'xcbgrab_indev': {'deps': ['libxcb'], ++ 'suggest': ['libxcb_shm', 'libxcb_shape', 'libxcb_xfixes']}, ++ 'xfade_opencl_filter': {'deps': ['opencl']}, ++ 'xma1_decoder': {'select': ['wmapro_decoder']}, ++ 'xma2_decoder': {'select': ['wmapro_decoder']}, ++ 'xmv_demuxer': {'select': ['riffdec']}, ++ 'xop': {'deps': ['avx']}, ++ 'xstack_qsv_filter': {'deps': ['libmfx'], 'select': ['qsvvpp']}, ++ 'xstack_vaapi_filter': {'deps': ['vaapi_1']}, ++ 'xv_outdev': {'deps': ['xlib_xv', 'xlib_x11', 'xlib_xext']}, ++ 'xwma_demuxer': {'select': ['riffdec']}, ++ 'yadif_cuda_filter': {'deps': ['ffnvcodec'], ++ 'deps_any': ['cuda_nvcc', 'cuda_llvm']}, ++ 'yadif_videotoolbox_filter': {'deps': ['metal', 'corevideo', 'videotoolbox']}, ++ 'ylc_decoder': {'select': ['bswapdsp']}, ++ 'zerocodec_decoder': {'select': ['inflate_wrapper']}, ++ 'zlib_decoder': {'select': ['inflate_wrapper']}, ++ 'zlib_encoder': {'select': ['deflate_wrapper']}, ++ 'zmbv_decoder': {'select': ['inflate_wrapper']}, ++ 'zmbv_encoder': {'select': ['deflate_wrapper']}, ++ 'zmq_filter': {'deps': ['libzmq']}, ++ 'zoompan_filter': {'deps': ['swscale']}, ++ 'zscale_filter': {'deps': ['libzimg', 'const_nan']}} ++ ++# Manually added ++ ++GRAPH['threads'] = {'if_any': ['pthreads', 'os2threads', 'w32threads']} ++GRAPH['atomics_native'] = {'if_any': ['atomics_gcc', 'atomics_suncc', 'atomics_win32']} +diff --git a/depresolver.py b/depresolver.py +new file mode 100644 +index 0000000000..7b4234010e +--- /dev/null ++++ b/depresolver.py +@@ -0,0 +1,198 @@ ++#!/usr/bin/env python3 ++ ++# Copyright (c) 2018 Mathieu Duponchelle <mathieu@centricular.com> ++# ++# This file is part of the FFmpeg Meson build ++# ++# This library is free software; you can redistribute it and/or ++# modify it under the terms of the GNU Lesser General Public ++# License as published by the Free Software Foundation; either ++# version 2.1 of the License, or (at your option) any later version. ++# ++# This library is distributed in the hope that it will be useful, ++# but WITHOUT ANY WARRANTY; without even the implied warranty of ++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++# Lesser General Public License for more details. ++# ++# You should have received a copy of the GNU Lesser General Public ++# License along with this library; if not, see <http://www.gnu.org/licenses/>. ++ ++''' ++Adapted from check_deps in the configure script. ++Based on the graph described in depgraph.py, and the system ++configuration, this script determines the components to enable. ++''' ++ ++import argparse ++import re ++import itertools ++import sys ++ ++from collections import defaultdict, OrderedDict ++ ++from depgraph import GRAPH ++ ++LIBRARY_LIST = [ ++ 'avcodec', ++ 'avdevice', ++ 'avfilter', ++ 'avformat', ++ 'avresample', ++ 'avutil', ++ 'postproc', ++ 'swresample', ++ 'swscale', ++] ++ ++ ++class CircularDependency(Exception): ++ pass ++ ++ ++def parse_conf(path): ++ res = {} ++ with open(path, 'r') as f: ++ for l in f.readlines(): ++ l = l.strip() ++ m = re.match('#define\s+(.*)\s+(.+)', l) ++ if m: ++ res[m.group(1).lower()] = int(m.group(2)) ++ return res ++ ++ ++def enabled(conf, thing): ++ return conf.get(thing, 0) == 1 ++ ++ ++def disabled(conf, thing): ++ return conf.get(thing, 1) == 0 ++ ++ ++def enable_weak(conf, thing): ++ conf[thing] = conf.get(thing, 1) ++ ++ ++def enable(conf, thing): ++ conf[thing] = 1 ++ ++ ++def disable(conf, thing): ++ conf[thing] = 0 ++ ++ ++def enable_deep(conf, thing): ++ if enabled(conf, thing): ++ return ++ ++ node = GRAPH.get(thing, {}) ++ dep_sel = node.get('select', []) ++ dep_sgs = node.get('suggest', []) ++ ++ for dep in dep_sel: ++ enable_deep(conf, dep) ++ enable(conf, dep) ++ ++ for dep in dep_sgs: ++ enable_deep_weak (conf, dep) ++ ++ ++def enable_deep_weak(conf, thing): ++ if disabled(conf, thing): ++ return ++ ++ enable_deep(conf, thing) ++ enable_weak(conf, thing) ++ ++ ++def resolve(conf, thing, flattened_deps, checking={}): ++ if thing in checking: ++ if checking[thing]: ++ raise CircularDependency(thing) ++ return ++ ++ checking[thing] = True ++ ++ node = GRAPH.get(thing, {}) ++ ++ dep_all = node.get('deps', []) ++ dep_any = node.get('deps_any', []) ++ dep_con = node.get('conflict', []) ++ dep_sel = node.get('select', []) ++ dep_sgs = node.get('suggest', []) ++ dep_ifa = node.get('if', []) ++ dep_ifn = node.get('if_any', []) ++ ++ for dep in itertools.chain(dep_all, dep_any, dep_con, dep_sel, dep_sgs, ++ dep_ifa, dep_ifn): ++ resolve(conf, dep, flattened_deps) ++ ++ if dep_ifa and all([enabled(conf, ifa) for ifa in dep_ifa]): ++ enable_weak(conf, thing) ++ ++ if dep_ifn and any([enabled(conf, ifn) for ifn in dep_ifn]): ++ enable_weak(conf, thing) ++ ++ if dep_all and not all([enabled(conf, dep) for dep in dep_all]): ++ disable(conf, thing) ++ ++ if dep_any and not any([enabled(conf, dep) for dep in dep_any]): ++ disable(conf, thing) ++ ++ if dep_con and not all([disabled(conf, con) for con in dep_con]): ++ disable(conf, thing) ++ ++ if dep_sel and any([disabled(conf, sel) for sel in dep_sel]): ++ disable(conf, thing) ++ ++ if enabled(conf, thing): ++ for dep in itertools.chain(dep_sel, dep_sgs): ++ enable_deep_weak(conf, dep) ++ ++ for dep in itertools.chain(dep_all, dep_any, dep_sel, dep_sgs): ++ if enabled(conf, dep): ++ flattened_deps[thing].update({dep: None}) ++ flattened_deps[thing].update(flattened_deps[dep]) ++ ++ checking[thing] = False ++ ++ ++def parse_components(path): ++ res = [] ++ with open(path, 'r') as f: ++ for l in f.readlines(): ++ l = l.strip() ++ m = re.match('#define\s+(.*)', l) ++ if m: ++ res.append(m.group(1).lower()) ++ return res ++ ++ ++if __name__=='__main__': ++ parser = argparse.ArgumentParser() ++ parser.add_argument('input') ++ parser.add_argument('components') ++ args = parser.parse_args() ++ ++ conf = parse_conf(args.input) ++ ++ flattened_deps = defaultdict(OrderedDict) ++ ++ things = parse_components(args.components) ++ things = [thing.lower() for thing in things] ++ ++ for thing in things: ++ resolve (conf, thing, flattened_deps) ++ ++ for thing in things: ++ if not thing in conf: ++ conf[thing] = 0 ++ ++ for key, value in conf.items(): ++ print ('%s=%d' % (key, value)) ++ ++ print('//BEGIN_DEPENDS') ++ ++ for comp, deps in flattened_deps.items(): ++ if enabled(conf, comp): ++ deps.update({comp: None}) ++ print ('%s=%s' % (comp, ','.join(deps))) +diff --git a/ffbuild/bin2c.py b/ffbuild/bin2c.py +new file mode 100644 +index 0000000000..de2840090a +--- /dev/null ++++ b/ffbuild/bin2c.py +@@ -0,0 +1,39 @@ ++#!/usr/bin/env python3 ++ ++# SPDX-FileCopyrightText: 2023 L. E. Segovia <amy@centricular.com> ++# SPDX-License-Identifier: BSD-3-Clause ++ ++from argparse import ArgumentParser ++from io import StringIO ++import os ++from pathlib import Path ++import re ++import shutil ++ ++if __name__ == '__main__': ++ parser = ArgumentParser(description='Converts a blob into a C array') ++ parser.add_argument('input', type=Path) ++ parser.add_argument('output', type=Path) ++ parser.add_argument('name', nargs='?') ++ ++ args = parser.parse_args() ++ ++ input: Path = args.input ++ output: Path = args.output ++ name: str | None = args.name ++ ++ if args.name is None: ++ name = re.sub(r'[^a-zA-Z0-9]', '_', output.stem) ++ ++ tmp = StringIO() ++ ++ with input.open('rb') as i: ++ length = os.path.getsize(input) ++ tmp.write(f"const unsigned char ff_{name}_data[] = {{") ++ while (byte := i.read(1)): ++ tmp.write(f"0x{int.from_bytes(byte):02x}, ") ++ print("0x00 };", file=tmp) ++ print(f"const unsigned int ff_{name}_len = {length};", file=tmp) ++ ++ tmp.seek(0) ++ shutil.copyfileobj(tmp, output.open('w', encoding='utf-8'), -1) +diff --git a/fftools/meson.build b/fftools/meson.build +new file mode 100644 +index 0000000000..200baccb5c +--- /dev/null ++++ b/fftools/meson.build +@@ -0,0 +1,72 @@ ++#### --- GENERATED --- #### ++ ++fftools_sources = files( ++ 'cmdutils.c', ++ 'opt_common.c', ++) ++ ++fftools_optional_sources = { ++ # MANUAL 'ffmpeg ' : files('ffmpeg_demux.c','ffmpeg_filter.c','ffmpeg_hw.c','ffmpeg_mux.c','ffmpeg_mux_init.c','ffmpeg_opt.c','objpool.c','sync_queue.c','thread_queue.c'), ++} ++ ++fftools_x86asm_optional_sources = { ++} ++ ++fftools_armv5te_optional_sources = { ++} ++ ++fftools_armv6_optional_sources = { ++} ++ ++fftools_armv8_optional_sources = { ++} ++ ++fftools_neon_optional_sources = { ++} ++ ++fftools_vfp_optional_sources = { ++} ++ ++fftools_mmx_optional_sources = { ++} ++ ++fftools_shlib_optional_sources = { ++} ++ ++fftools_slib_optional_sources = { ++} ++ ++fftools_optional_tests = { ++} ++ ++#### --- END GENERATED --- #### ++ ++ffmpeg_sources = files( ++ 'ffmpeg_demux.c', ++ 'ffmpeg_filter.c', ++ 'ffmpeg_hw.c', ++ 'ffmpeg_mux.c', ++ 'ffmpeg_mux_init.c', ++ 'ffmpeg_opt.c', ++ 'objpool.c', ++ 'sync_queue.c', ++ 'thread_queue.c', ++ 'ffmpeg.c' ++) ++ ++ffplay_sources = files( ++ 'ffplay.c' ++) ++ ++ffprobe_sources = files( ++ 'ffprobe.c' ++) ++ ++if host_machine.system() == 'windows' ++ fftoolsres = windows.compile_resources(files('fftoolsres.rc'), ++ depend_files: files('fftools.manifest'), ++ include_directories: include_directories('.') ++ ) ++ ++ fftools_sources += fftoolsres ++endif +diff --git a/find_things.py b/find_things.py +new file mode 100755 +index 0000000000..2782db2ae3 +--- /dev/null ++++ b/find_things.py +@@ -0,0 +1,97 @@ ++#!/usr/bin/env python3 ++ ++# Copyright (c) 2018 Mathieu Duponchelle <mathieu@centricular.com> ++# Copyright (c) 2022 L. E. Segovia <amy@amyspark.me> ++# ++# This file is part of the FFmpeg Meson build ++# ++# This library is free software; you can redistribute it and/or ++# modify it under the terms of the GNU Lesser General Public ++# License as published by the Free Software Foundation; either ++# version 2.1 of the License, or (at your option) any later version. ++# ++# This library is distributed in the hope that it will be useful, ++# but WITHOUT ANY WARRANTY; without even the implied warranty of ++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++# Lesser General Public License for more details. ++# ++# You should have received a copy of the GNU Lesser General Public ++# License along with this library; if not, see <http://www.gnu.org/licenses/>. ++ ++import argparse ++import re ++ ++def list_components(infile, full): ++ things = [] ++ ++ for line in infile: ++ if not full: ++ matches = re.match( ++ r'^extern\s+(?:const\s+)?AVFilter\s*ff_[^_]*_(.*);', line.strip()) ++ else: ++ matches = re.match(r'extern\s+(?:const\s+)?AVFilter\s*ff_(.*_.*);', line.strip()) ++ if (matches): ++ if not args.full: ++ things.append(('%s_filter' % matches.group(1).strip())) ++ else: ++ things.append(matches.group(1).strip()) ++ ++ return things ++ ++def update_meson_options(options): ++ has_generated = False ++ lines = [] ++ with open('meson_options.txt', 'r', encoding='utf8') as meson_file: ++ opening = '#### --- GENERATED FILTER OPTIONS --- ####\n' ++ closing = opening.replace('GENERATED', 'END GENERATED') ++ for l in meson_file.readlines(): ++ if l == opening: ++ has_generated = True ++ lines.append(l) ++ for option in options: ++ if re.match(f'^null(.*)_filter', option): ++ value = 'enabled' ++ else: ++ value = 'auto' ++ lines.append( ++ ('option(\'%s\', type: \'feature\', value: \'%s\')\n' % (option, value))) ++ lines.append( ++ "option('filters', type: 'feature', value: 'auto', description: 'Enable or disable all filters')\n") ++ elif l == closing: ++ lines.append(l) ++ has_generated = False ++ elif not has_generated: ++ lines.append(l) ++ ++ with open('meson_options.txt', 'w') as meson_file: ++ meson_file.write(''.join(lines)) ++ ++if __name__ == '__main__': ++ arg_parser = argparse.ArgumentParser(description='Find filter registrations in allfilters.c') ++ ++ arg_parser.add_argument('--update-options', action='store_true', ++ help='update the Meson options list and exit') ++ arg_parser.add_argument('--full', action='store_true') ++ arg_parser.add_argument('files', metavar='FILE', nargs='*', ++ type=argparse.FileType('r'), ++ help='File with lists of declarations, ' + ++ 'or "-" for standard input') ++ ++ args = arg_parser.parse_args() ++ ++ things = [] ++ ++ if args.update_options: ++ options = {} ++ with open('libavfilter/allfilters.c', 'r', encoding='utf-8') as infile: ++ components = list_components( ++ infile, False) ++ options = components ++ ++ update_meson_options(options) ++ else: ++ things = [] ++ for infile in args.files: ++ things += list_components(infile, args.full) ++ ++ print('\n'.join(things)) +diff --git a/find_things_extern.py b/find_things_extern.py +new file mode 100755 +index 0000000000..cf2d0c47ec +--- /dev/null ++++ b/find_things_extern.py +@@ -0,0 +1,125 @@ ++#!/usr/bin/env python3 ++ ++# Copyright (c) 2018 Mathieu Duponchelle <mathieu@centricular.com> ++# Copyright (c) 2022 L. E. Segovia <amy@amyspark.me> ++# ++# This file is part of the FFmpeg Meson build ++# ++# This library is free software; you can redistribute it and/or ++# modify it under the terms of the GNU Lesser General Public ++# License as published by the Free Software Foundation; either ++# version 2.1 of the License, or (at your option) any later version. ++# ++# This library is distributed in the hope that it will be useful, ++# but WITHOUT ANY WARRANTY; without even the implied warranty of ++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++# Lesser General Public License for more details. ++# ++# You should have received a copy of the GNU Lesser General Public ++# License along with this library; if not, see <http://www.gnu.org/licenses/>. ++ ++import argparse ++import re ++ ++EXTERN_THINGS = [ ++ ['FFOutputFormat', 'muxer', 'libavformat/allformats.c', 'muxer_list'], ++ ['AVInputFormat', 'demuxer', 'libavformat/allformats.c', 'demuxer_list'], ++ ['FFCodec', 'encoder', 'libavcodec/allcodecs.c', 'encoder_list'], ++ ['FFCodec', 'decoder', 'libavcodec/allcodecs.c', 'decoder_list'], ++ ['AVCodecParser', 'parser', 'libavcodec/parsers.c', 'parser_list'], ++ ['FFBitStreamFilter', 'bsf', 'libavcodec/bitstream_filters.c', 'bsf_list'], ++ ['AVHWAccel', 'hwaccel', 'libavcodec/hwaccels.h', 'hwaccel_list'], ++ ['URLProtocol', 'protocol', 'libavformat/protocols.c', 'protocol_list'], ++ ['FFOutputFormat', 'muxer', 'libavdevice/alldevices.c', 'outdev_list', 'outdev'], ++ ['AVInputFormat', 'demuxer', 'libavdevice/alldevices.c', 'indev_list', 'indev'], ++] ++ ++def list_components(infile, type, suffix, thing_suffix): ++ things = [] ++ ++ for line in infile: ++ matches = re.match(r'^extern.*' + type + ++ ' *ff_([^ ]*)_' + suffix + ';', line.strip()) ++ if matches: ++ things += [matches.group(1).strip()] ++ ++ return ['%s_%s' % (thing, thing_suffix) for thing in things] ++ ++def update_meson_options(options): ++ has_generated = False ++ lines = [] ++ with open('meson_options.txt', 'r', encoding='utf8') as meson_file: ++ opening = '#### --- GENERATED EXTERN OPTIONS --- ####\n' ++ closing = opening.replace('GENERATED', 'END GENERATED') ++ for l in meson_file.readlines(): ++ if l == opening: ++ has_generated = True ++ lines.append(l) ++ for component, list in options.items(): ++ lines.append(f'# Generated {component} options\n') ++ for option in list: ++ if re.match(f'^null_{component}', option): ++ value = 'enabled' ++ else: ++ value = 'auto' ++ lines.append( ++ ('option(\'%s\', type: \'feature\', value: \'%s\')\n' % (option, value))) ++ lines.append( ++ f"option('{component}s', type: 'feature', value: 'auto', description: 'Enable or disable all {component}s')\n") ++ lines.append('\n') ++ elif l == closing: ++ lines.append(l) ++ has_generated = False ++ elif not has_generated: ++ lines.append(l) ++ ++ with open('meson_options.txt', 'w') as meson_file: ++ meson_file.write(''.join(lines)) ++ ++# Used to extract list of muxers, demuxers, encoders, etc. ++if __name__ == '__main__': ++ arg_parser = argparse.ArgumentParser(description='Find extern declarations in all*.c') ++ ++ arg_parser.add_argument('--suffix', metavar='STRING', ++ default='', ++ help='Variable name suffix, e.g. muxer') ++ arg_parser.add_argument('--update-options', action='store_true', ++ help='update the Meson options list and exit') ++ arg_parser.add_argument('--type', metavar='STRING', ++ default='', ++ help='Variable type, e.g. AVOutputFormat') ++ arg_parser.add_argument('--thing-suffix', metavar='STRING', ++ default='', ++ help='suffix to add to the thing name') ++ arg_parser.add_argument('files', metavar='FILE', nargs='*', ++ type=argparse.FileType('r'), ++ help='File with lists of declarations, ' + ++ 'or "-" for standard input') ++ ++ args = arg_parser.parse_args() ++ ++ if args.update_options: ++ options = {} ++ ++ for extern_thing in EXTERN_THINGS: ++ type = extern_thing[0] ++ suffix = extern_thing[1] ++ filename = extern_thing[2] ++ ++ if len(extern_thing) > 4: ++ thing_suffix = extern_thing[4] ++ else: ++ thing_suffix = suffix ++ ++ with open(filename, 'r', encoding='utf-8') as infile: ++ components = list_components( ++ infile, type, suffix, thing_suffix) ++ options[thing_suffix] = components ++ ++ update_meson_options(options) ++ else: ++ things = [] ++ for infile in args.files: ++ things += list_components(infile, args.type, args.suffix, args.thing_suffix) ++ ++ print('\n'.join(things)) +diff --git a/libavcodec/aarch64/meson.build b/libavcodec/aarch64/meson.build +new file mode 100644 +index 0000000000..e154503df6 +--- /dev/null ++++ b/libavcodec/aarch64/meson.build +@@ -0,0 +1,74 @@ ++libavcodec_aarch64_optional_sources = { ++ 'aac_decoder' : files('aacpsdsp_init_aarch64.c','sbrdsp_init_aarch64.c'), ++ 'dca_decoder' : files('synth_filter_init.c'), ++ 'fft' : files('fft_init_aarch64.c'), ++ 'fmtconvert' : files('fmtconvert_init.c'), ++ 'h264chroma' : files('h264chroma_init_aarch64.c'), ++ 'h264dsp' : files('h264dsp_init_aarch64.c'), ++ 'h264pred' : files('h264pred_init.c'), ++ 'h264qpel' : files('h264qpel_init_aarch64.c'), ++ 'hpeldsp' : files('hpeldsp_init_aarch64.c'), ++ 'idctdsp' : files('idctdsp_init_aarch64.c'), ++ 'me_cmp' : files('me_cmp_init_aarch64.c'), ++ 'mpegaudiodsp' : files('mpegaudiodsp_init.c'), ++ 'neon_clobber_test' : files('neontest.c'), ++ 'opus_decoder' : files('opusdsp_init.c'), ++ 'pixblockdsp' : files('pixblockdsp_init_aarch64.c'), ++ 'rv40_decoder' : files('rv40dsp_init_aarch64.c'), ++ 'vc1dsp' : files('vc1dsp_init_aarch64.c'), ++ 'videodsp' : files('videodsp_init.c'), ++ 'vorbis_decoder' : files('vorbisdsp_init.c'), ++ 'vp8dsp' : files('vp8dsp_init_aarch64.c'), ++ 'vp9_decoder' : files('vp9dsp_init_10bpp_aarch64.c','vp9dsp_init_12bpp_aarch64.c','vp9mc_aarch64.S','vp9dsp_init_aarch64.c'), ++} ++ ++libavcodec_aarch64_x86asm_optional_sources = { ++} ++ ++libavcodec_aarch64_armv5te_optional_sources = { ++} ++ ++libavcodec_aarch64_armv6_optional_sources = { ++} ++ ++libavcodec_aarch64_armv8_optional_sources = { ++ 'videodsp' : files('videodsp.S'), ++} ++ ++libavcodec_aarch64_neon_optional_sources = { ++ 'aac_decoder' : files('sbrdsp_neon.S','aacpsdsp_neon.S'), ++ 'dca_decoder' : files('synth_filter_neon.S'), ++ 'fft' : files('fft_neon.S'), ++ 'fmtconvert' : files('fmtconvert_neon.S'), ++ 'h264chroma' : files('h264cmc_neon.S'), ++ 'h264dsp' : files('h264dsp_neon.S','h264idct_neon.S'), ++ 'h264pred' : files('h264pred_neon.S'), ++ 'h264qpel' : files('h264qpel_neon.S','hpeldsp_neon.S'), ++ 'hevc_decoder' : files('hevcdsp_idct_neon.S','hevcdsp_init_aarch64.c','hevcdsp_qpel_neon.S','hevcdsp_sao_neon.S'), ++ 'hpeldsp' : files('hpeldsp_neon.S'), ++ 'idctdsp' : files('idctdsp_neon.S','simple_idct_neon.S'), ++ 'mdct' : files('mdct_neon.S'), ++ 'me_cmp' : files('me_cmp_neon.S'), ++ 'mpegaudiodsp' : files('mpegaudiodsp_neon.S'), ++ 'opus_decoder' : files('opusdsp_neon.S'), ++ 'pixblockdsp' : files('pixblockdsp_neon.S'), ++ 'vc1dsp' : files('vc1dsp_neon.S'), ++ 'vorbis_decoder' : files('vorbisdsp_neon.S'), ++ 'vp8dsp' : files('vp8dsp_neon.S'), ++ 'vp9_decoder' : files('vp9itxfm_16bpp_neon.S','vp9itxfm_neon.S','vp9lpf_16bpp_neon.S','vp9lpf_neon.S','vp9mc_16bpp_neon.S','vp9mc_neon.S'), ++} ++ ++libavcodec_aarch64_vfp_optional_sources = { ++} ++ ++libavcodec_aarch64_mmx_optional_sources = { ++} ++ ++libavcodec_aarch64_shlib_optional_sources = { ++} ++ ++libavcodec_aarch64_slib_optional_sources = { ++} ++ ++libavcodec_aarch64_optional_tests = { ++} +diff --git a/libavcodec/arm/meson.build b/libavcodec/arm/meson.build +new file mode 100644 +index 0000000000..dfb13b22b8 +--- /dev/null ++++ b/libavcodec/arm/meson.build +@@ -0,0 +1,118 @@ ++libavcodec_arm_optional_sources = { ++ 'aac_decoder' : files('aacpsdsp_init_arm.c','sbrdsp_init_arm.c'), ++ 'ac3dsp' : files('ac3dsp_init_arm.c','ac3dsp_arm.S'), ++ 'audiodsp' : files('audiodsp_init_arm.c'), ++ 'blockdsp' : files('blockdsp_init_arm.c'), ++ 'dca_decoder' : files('synth_filter_init_arm.c'), ++ 'fft' : files('fft_init_arm.c'), ++ 'flac_decoder' : files('flacdsp_init_arm.c','flacdsp_arm.S'), ++ 'fmtconvert' : files('fmtconvert_init_arm.c'), ++ 'g722dsp' : files('g722dsp_init_arm.c'), ++ 'h264chroma' : files('h264chroma_init_arm.c'), ++ 'h264dsp' : files('h264dsp_init_arm.c'), ++ 'h264pred' : files('h264pred_init_arm.c'), ++ 'h264qpel' : files('h264qpel_init_arm.c'), ++ 'hevc_decoder' : files('hevcdsp_init_arm.c'), ++ 'hpeldsp' : files('hpeldsp_init_arm.c','hpeldsp_arm.S'), ++ 'idctdsp' : files('idctdsp_init_arm.c','idctdsp_arm.S','jrevdct_arm.S','simple_idct_arm.S'), ++ 'llauddsp' : files('lossless_audiodsp_init_arm.c'), ++ 'me_cmp' : files('me_cmp_init_arm.c'), ++ 'mlp_decoder' : files('mlpdsp_init_arm.c'), ++ 'mpegaudiodsp' : files('mpegaudiodsp_init_arm.c'), ++ 'mpegvideo' : files('mpegvideo_arm.c'), ++ 'mpegvideoenc' : files('mpegvideoencdsp_init_arm.c'), ++ 'neon_clobber_test' : files('neontest.c'), ++ 'pixblockdsp' : files('pixblockdsp_init_arm.c'), ++ 'rdft' : files('rdft_init_arm.c'), ++ 'rv34dsp' : files('rv34dsp_init_arm.c'), ++ 'rv40_decoder' : files('rv40dsp_init_arm.c'), ++ 'sbc_encoder' : files('sbcdsp_init_arm.c'), ++ 'truehd_decoder' : files('mlpdsp_init_arm.c'), ++ 'vc1dsp' : files('vc1dsp_init_arm.c'), ++ 'videodsp' : files('videodsp_init_arm.c'), ++ 'vorbis_decoder' : files('vorbisdsp_init_arm.c'), ++ 'vp3dsp' : files('vp3dsp_init_arm.c'), ++ 'vp6_decoder' : files('vp6dsp_init_arm.c'), ++ 'vp8dsp' : files('vp8dsp_init_arm.c'), ++ 'vp9_decoder' : files('vp9dsp_init_10bpp_arm.c','vp9dsp_init_12bpp_arm.c','vp9dsp_init_arm.c'), ++} ++ ++libavcodec_arm_x86asm_optional_sources = { ++} ++ ++libavcodec_arm_armv5te_optional_sources = { ++ 'idctdsp' : files('idctdsp_init_armv5te.c','simple_idct_armv5te.S'), ++ 'mlp_decoder' : files('mlpdsp_armv5te.S'), ++ 'mpegvideo' : files('mpegvideo_armv5te.c','mpegvideo_armv5te_s.S'), ++ 'truehd_decoder' : files('mlpdsp_armv5te.S'), ++ 'videodsp' : files('videodsp_init_armv5te.c','videodsp_armv5te.S'), ++} ++ ++libavcodec_arm_armv6_optional_sources = { ++ 'ac3dsp' : files('ac3dsp_armv6.S'), ++ 'hpeldsp' : files('hpeldsp_init_armv6.c','hpeldsp_armv6.S'), ++ 'idctdsp' : files('idctdsp_init_armv6.c','idctdsp_armv6.S','simple_idct_armv6.S'), ++ 'me_cmp' : files('me_cmp_armv6.S'), ++ 'mlp_decoder' : files('mlpdsp_armv6.S'), ++ 'mpegaudiodsp' : files('mpegaudiodsp_fixed_armv6.S'), ++ 'mpegvideoenc' : files('mpegvideoencdsp_armv6.S'), ++ 'pixblockdsp' : files('pixblockdsp_armv6.S'), ++ 'sbc_encoder' : files('sbcdsp_armv6.S'), ++ 'startcode' : files('startcode_armv6.S'), ++ 'truehd_decoder' : files('mlpdsp_armv6.S'), ++ 'vp8dsp' : files('vp8_armv6.S','vp8dsp_init_armv6.c','vp8dsp_armv6.S'), ++} ++ ++libavcodec_arm_armv8_optional_sources = { ++} ++ ++libavcodec_arm_neon_optional_sources = { ++ 'aac_decoder' : files('aacpsdsp_neon.S','sbrdsp_neon.S'), ++ 'ac3dsp' : files('ac3dsp_neon.S'), ++ 'audiodsp' : files('audiodsp_init_neon.c','audiodsp_neon.S','int_neon.S'), ++ 'blockdsp' : files('blockdsp_init_neon.c','blockdsp_neon.S'), ++ 'dca_decoder' : files('synth_filter_neon.S'), ++ 'fft' : files('fft_neon.S'), ++ 'fmtconvert' : files('fmtconvert_neon.S'), ++ 'g722dsp' : files('g722dsp_neon.S'), ++ 'h264chroma' : files('h264cmc_neon.S'), ++ 'h264dsp' : files('h264dsp_neon.S','h264idct_neon.S'), ++ 'h264pred' : files('h264pred_neon.S'), ++ 'h264qpel' : files('h264qpel_neon.S','hpeldsp_neon.S'), ++ 'hevc_decoder' : files('hevcdsp_init_neon.c','hevcdsp_deblock_neon.S','hevcdsp_idct_neon.S','hevcdsp_qpel_neon.S','hevcdsp_sao_neon.S'), ++ 'hpeldsp' : files('hpeldsp_init_neon.c','hpeldsp_neon.S'), ++ 'idctdsp' : files('idctdsp_init_neon.c','idctdsp_neon.S','simple_idct_neon.S'), ++ 'llauddsp' : files('lossless_audiodsp_neon.S'), ++ 'mdct' : files('mdct_neon.S'), ++ 'mpegvideo' : files('mpegvideo_neon.S'), ++ 'pixblockdsp' : files('pixblockdsp_neon.S'), ++ 'rdft' : files('rdft_neon.S'), ++ 'rv30_decoder' : files('rv34dsp_neon.S'), ++ 'rv40_decoder' : files('rv34dsp_neon.S','rv40dsp_neon.S'), ++ 'sbc_encoder' : files('sbcdsp_neon.S'), ++ 'vc1dsp' : files('vc1dsp_init_neon.c','vc1dsp_neon.S'), ++ 'vorbis_decoder' : files('vorbisdsp_neon.S'), ++ 'vp3dsp' : files('vp3dsp_neon.S'), ++ 'vp6_decoder' : files('vp6dsp_neon.S'), ++ 'vp8dsp' : files('vp8dsp_init_neon.c','vp8dsp_neon.S'), ++ 'vp9_decoder' : files('vp9itxfm_16bpp_neon.S','vp9itxfm_neon.S','vp9lpf_16bpp_neon.S','vp9lpf_neon.S','vp9mc_16bpp_neon.S','vp9mc_neon.S'), ++} ++ ++libavcodec_arm_vfp_optional_sources = { ++ 'dca_decoder' : files('synth_filter_vfp.S'), ++ 'fft' : files('fft_vfp.S'), ++ 'fmtconvert' : files('fmtconvert_vfp.S'), ++ 'mdct' : files('mdct_vfp.S'), ++} ++ ++libavcodec_arm_mmx_optional_sources = { ++} ++ ++libavcodec_arm_shlib_optional_sources = { ++} ++ ++libavcodec_arm_slib_optional_sources = { ++} ++ ++libavcodec_arm_optional_tests = { ++} +diff --git a/libavcodec/libavcodec.v.in b/libavcodec/libavcodec.v.in +new file mode 100644 +index 0000000000..1f9aac17ab +--- /dev/null ++++ b/libavcodec/libavcodec.v.in +@@ -0,0 +1,6 @@ ++LIBAVCODEC_@majorver@ { ++ global: ++ av*; ++ local: ++ *; ++}; +diff --git a/libavcodec/meson.build b/libavcodec/meson.build +new file mode 100644 +index 0000000000..f47061a494 +--- /dev/null ++++ b/libavcodec/meson.build +@@ -0,0 +1,1231 @@ ++#### --- GENERATED --- #### ++ ++libavcodec_sources = files( ++ 'ac3_parser.c', ++ 'adts_parser.c', ++ 'allcodecs.c', ++ 'avcodec.c', ++ 'avdct.c', ++ 'avpacket.c', ++ 'bitstream.c', ++ 'bitstream_filters.c', ++ 'bsf.c', ++ 'codec_desc.c', ++ 'codec_par.c', ++ 'd3d11va.c', ++ 'decode.c', ++ 'dirac.c', ++ 'dv_profile.c', ++ 'encode.c', ++ 'get_buffer.c', ++ 'imgconvert.c', ++ 'jni.c', ++ 'mathtables.c', ++ 'mediacodec.c', ++ 'mpeg12framerate.c', ++ 'options.c', ++ 'parser.c', ++ 'parsers.c', ++ 'profiles.c', ++ 'qsv_api.c', ++ 'raw.c', ++ 'utils.c', ++ 'version.c', ++ 'vlc.c', ++ 'vorbis_parser.c', ++ 'xiph.c', ++ 'dctref.c', ++) ++ ++libavcodec_headers = files( ++ 'ac3_parser.h', ++ 'adts_parser.h', ++ 'avcodec.h', ++ 'avdct.h', ++ 'avfft.h', ++ 'bsf.h', ++ 'codec.h', ++ 'codec_desc.h', ++ 'codec_id.h', ++ 'codec_par.h', ++ 'd3d11va.h', ++ 'defs.h', ++ 'dirac.h', ++ 'dv_profile.h', ++ 'dxva2.h', ++ 'jni.h', ++ 'mediacodec.h', ++ 'packet.h', ++ 'qsv.h', ++ 'vdpau.h', ++ 'version.h', ++ 'version_major.h', ++ 'videotoolbox.h', ++ 'vorbis_parser.h', ++ 'xvmc.h', ++) ++ ++libavcodec_optional_sources = { ++ 'a64multi5_encoder' : files('a64multienc.c','elbg.c'), ++ 'a64multi_encoder' : files('a64multienc.c','elbg.c'), ++ 'aac_adtstoasc_bsf' : files('aac_adtstoasc_bsf.c'), ++ 'aac_at_decoder' : files('audiotoolboxdec.c'), ++ 'aac_at_encoder' : files('audiotoolboxenc.c'), ++ 'aac_decoder' : files('aacdec.c','aactab.c','aacsbr.c','aacps_common.c','aacps_float.c','kbdwin.c','sbrdsp.c','aacpsdsp_float.c','cbrt_data.c'), ++ 'aac_encoder' : files('aacenc.c','aaccoder.c','aacenctab.c','aacpsy.c','aactab.c','aacenc_is.c','aacenc_tns.c','aacenc_ltp.c','aacenc_pred.c','psymodel.c','kbdwin.c','mpeg4audio_sample_rates.c'), ++ 'aac_fixed_decoder' : files('aacdec_fixed.c','aactab.c','aacsbr_fixed.c','aacps_common.c','aacps_fixed.c','kbdwin.c','sbrdsp_fixed.c','aacpsdsp_fixed.c','cbrt_data_fixed.c'), ++ 'aac_latm_parser' : files('latm_parser.c'), ++ 'aac_mf_encoder' : files('mfenc.c','mf_utils.c'), ++ 'aac_parser' : files('aac_parser.c','aac_ac3_parser.c'), ++ 'aandcttables' : files('aandcttab.c'), ++ 'aasc_decoder' : files('aasc.c','msrledec.c'), ++ 'ac3dsp' : files('ac3dsp.c','ac3.c','ac3tab.c'), ++ 'ac3_at_decoder' : files('audiotoolboxdec.c'), ++ 'ac3_decoder' : files('ac3dec_float.c','ac3dec_data.c','ac3.c','kbdwin.c','ac3tab.c','ac3_channel_layout_tab.c'), ++ 'ac3_encoder' : files('ac3enc_float.c','ac3enc.c','ac3tab.c','ac3.c','kbdwin.c'), ++ 'ac3_fixed_decoder' : files('ac3dec_fixed.c','ac3dec_data.c','ac3.c','kbdwin.c','ac3tab.c','ac3_channel_layout_tab.c'), ++ 'ac3_fixed_encoder' : files('ac3enc_fixed.c','ac3enc.c','ac3tab.c','ac3.c','kbdwin.c'), ++ 'ac3_mf_encoder' : files('mfenc.c','mf_utils.c'), ++ 'ac3_parser' : files('aac_ac3_parser.c','ac3tab.c','ac3_channel_layout_tab.c'), ++ 'acelp_kelvin_decoder' : files('g729dec.c','lsp.c','celp_math.c','celp_filters.c','acelp_filters.c','acelp_pitch_delay.c','acelp_vectors.c','g729postfilter.c'), ++ 'adpcm_4xm_decoder' : files('adpcm.c','adpcm_data.c'), ++ 'adpcm_adx_decoder' : files('adxdec.c','adx.c'), ++ 'adpcm_adx_encoder' : files('adxenc.c','adx.c'), ++ 'adpcm_afc_decoder' : files('adpcm.c','adpcm_data.c'), ++ 'adpcm_agm_decoder' : files('adpcm.c','adpcm_data.c'), ++ 'adpcm_aica_decoder' : files('adpcm.c','adpcm_data.c'), ++ 'adpcm_argo_decoder' : files('adpcm.c','adpcm_data.c'), ++ 'adpcm_argo_encoder' : files('adpcm.c','adpcm_data.c','adpcmenc.c'), ++ 'adpcm_ct_decoder' : files('adpcm.c','adpcm_data.c'), ++ 'adpcm_dtk_decoder' : files('adpcm.c','adpcm_data.c'), ++ 'adpcm_ea_decoder' : files('adpcm.c','adpcm_data.c'), ++ 'adpcm_ea_maxis_xa_decoder' : files('adpcm.c','adpcm_data.c'), ++ 'adpcm_ea_r1_decoder' : files('adpcm.c','adpcm_data.c'), ++ 'adpcm_ea_r2_decoder' : files('adpcm.c','adpcm_data.c'), ++ 'adpcm_ea_r3_decoder' : files('adpcm.c','adpcm_data.c'), ++ 'adpcm_ea_xas_decoder' : files('adpcm.c','adpcm_data.c'), ++ 'adpcm_g722_decoder' : files('g722.c','g722dsp.c','g722dec.c'), ++ 'adpcm_g722_encoder' : files('g722.c','g722dsp.c','g722enc.c'), ++ 'adpcm_g726le_decoder' : files('g726.c'), ++ 'adpcm_g726le_encoder' : files('g726.c'), ++ 'adpcm_g726_decoder' : files('g726.c'), ++ 'adpcm_g726_encoder' : files('g726.c'), ++ 'adpcm_ima_acorn_decoder' : files('adpcm.c','adpcm_data.c'), ++ 'adpcm_ima_alp_decoder' : files('adpcm.c','adpcm_data.c'), ++ 'adpcm_ima_alp_encoder' : files('adpcmenc.c','adpcm_data.c'), ++ 'adpcm_ima_amv_decoder' : files('adpcm.c','adpcm_data.c'), ++ 'adpcm_ima_amv_encoder' : files('adpcmenc.c','adpcm_data.c'), ++ 'adpcm_ima_apc_decoder' : files('adpcm.c','adpcm_data.c'), ++ 'adpcm_ima_apm_decoder' : files('adpcm.c','adpcm_data.c'), ++ 'adpcm_ima_apm_encoder' : files('adpcmenc.c','adpcm_data.c'), ++ 'adpcm_ima_cunning_decoder' : files('adpcm.c','adpcm_data.c'), ++ 'adpcm_ima_dat4_decoder' : files('adpcm.c','adpcm_data.c'), ++ 'adpcm_ima_dk3_decoder' : files('adpcm.c','adpcm_data.c'), ++ 'adpcm_ima_dk4_decoder' : files('adpcm.c','adpcm_data.c'), ++ 'adpcm_ima_ea_eacs_decoder' : files('adpcm.c','adpcm_data.c'), ++ 'adpcm_ima_ea_sead_decoder' : files('adpcm.c','adpcm_data.c'), ++ 'adpcm_ima_iss_decoder' : files('adpcm.c','adpcm_data.c'), ++ 'adpcm_ima_moflex_decoder' : files('adpcm.c','adpcm_data.c'), ++ 'adpcm_ima_mtf_decoder' : files('adpcm.c','adpcm_data.c'), ++ 'adpcm_ima_oki_decoder' : files('adpcm.c','adpcm_data.c'), ++ 'adpcm_ima_qt_at_decoder' : files('audiotoolboxdec.c'), ++ 'adpcm_ima_qt_decoder' : files('adpcm.c','adpcm_data.c'), ++ 'adpcm_ima_qt_encoder' : files('adpcmenc.c','adpcm_data.c'), ++ 'adpcm_ima_rad_decoder' : files('adpcm.c','adpcm_data.c'), ++ 'adpcm_ima_smjpeg_decoder' : files('adpcm.c','adpcm_data.c'), ++ 'adpcm_ima_ssi_decoder' : files('adpcm.c','adpcm_data.c'), ++ 'adpcm_ima_ssi_encoder' : files('adpcmenc.c','adpcm_data.c'), ++ 'adpcm_ima_wav_decoder' : files('adpcm.c','adpcm_data.c'), ++ 'adpcm_ima_wav_encoder' : files('adpcmenc.c','adpcm_data.c'), ++ 'adpcm_ima_ws_decoder' : files('adpcm.c','adpcm_data.c'), ++ 'adpcm_ima_ws_encoder' : files('adpcmenc.c','adpcm_data.c'), ++ 'adpcm_ms_decoder' : files('adpcm.c','adpcm_data.c'), ++ 'adpcm_ms_encoder' : files('adpcmenc.c','adpcm_data.c'), ++ 'adpcm_mtaf_decoder' : files('adpcm.c','adpcm_data.c'), ++ 'adpcm_psx_decoder' : files('adpcm.c','adpcm_data.c'), ++ 'adpcm_sbpro_2_decoder' : files('adpcm.c','adpcm_data.c'), ++ 'adpcm_sbpro_3_decoder' : files('adpcm.c','adpcm_data.c'), ++ 'adpcm_sbpro_4_decoder' : files('adpcm.c','adpcm_data.c'), ++ 'adpcm_swf_decoder' : files('adpcm.c','adpcm_data.c'), ++ 'adpcm_swf_encoder' : files('adpcmenc.c','adpcm_data.c'), ++ 'adpcm_thp_decoder' : files('adpcm.c','adpcm_data.c'), ++ 'adpcm_thp_le_decoder' : files('adpcm.c','adpcm_data.c'), ++ 'adpcm_vima_decoder' : files('vima.c','adpcm_data.c'), ++ 'adpcm_xa_decoder' : files('adpcm.c','adpcm_data.c'), ++ 'adpcm_xmd_decoder' : files('adpcm.c','adpcm_data.c'), ++ 'adpcm_yamaha_decoder' : files('adpcm.c','adpcm_data.c'), ++ 'adpcm_yamaha_encoder' : files('adpcmenc.c','adpcm_data.c'), ++ 'adpcm_zork_decoder' : files('adpcm.c','adpcm_data.c'), ++ 'adts_header' : files('adts_header.c','mpeg4audio_sample_rates.c'), ++ 'adx_parser' : files('adx_parser.c'), ++ 'agm_decoder' : files('agm.c','jpegquanttables.c'), ++ 'aic_decoder' : files('aic.c'), ++ 'alac_at_decoder' : files('audiotoolboxdec.c'), ++ 'alac_at_encoder' : files('audiotoolboxenc.c'), ++ 'alac_decoder' : files('alac.c','alac_data.c','alacdsp.c'), ++ 'alac_encoder' : files('alacenc.c','alac_data.c'), ++ 'alias_pix_decoder' : files('aliaspixdec.c'), ++ 'alias_pix_encoder' : files('aliaspixenc.c'), ++ 'als_decoder' : files('alsdec.c','bgmc.c','mlz.c'), ++ 'amf' : files('amfenc.c'), ++ 'amrnb_decoder' : files('amrnbdec.c','celp_filters.c','celp_math.c','acelp_filters.c','acelp_vectors.c','acelp_pitch_delay.c'), ++ 'amrwb_decoder' : files('amrwbdec.c','celp_filters.c','celp_math.c','acelp_filters.c','acelp_vectors.c','acelp_pitch_delay.c'), ++ 'amr_nb_at_decoder' : files('audiotoolboxdec.c'), ++ 'amr_parser' : files('amr_parser.c'), ++ 'amv_encoder' : files('mjpegenc.c','mjpegenc_common.c'), ++ 'anm_decoder' : files('anm.c'), ++ 'ansi_decoder' : files('ansi.c','cga_data.c'), ++ 'anull_decoder' : files('null.c'), ++ 'anull_encoder' : files('null.c'), ++ 'apac_decoder' : files('apac.c'), ++ 'ape_decoder' : files('apedec.c'), ++ 'apng_decoder' : files('png.c','pngdec.c','pngdsp.c'), ++ 'apng_encoder' : files('png.c','pngenc.c'), ++ 'aptx_decoder' : files('aptxdec.c','aptx.c'), ++ 'aptx_encoder' : files('aptxenc.c','aptx.c'), ++ 'aptx_hd_decoder' : files('aptxdec.c','aptx.c'), ++ 'aptx_hd_encoder' : files('aptxenc.c','aptx.c'), ++ 'arbc_decoder' : files('arbc.c'), ++ 'argo_decoder' : files('argo.c'), ++ 'ass_decoder' : files('assdec.c','ass.c'), ++ 'ass_encoder' : files('assenc.c','ass.c'), ++ 'asv1_decoder' : files('asvdec.c','asv.c','mpeg12data.c'), ++ 'asv1_encoder' : files('asvenc.c','asv.c','mpeg12data.c'), ++ 'asv2_decoder' : files('asvdec.c','asv.c','mpeg12data.c'), ++ 'asv2_encoder' : files('asvenc.c','asv.c','mpeg12data.c'), ++ 'atrac1_decoder' : files('atrac1.c','atrac.c'), ++ 'atrac3al_decoder' : files('atrac3.c','atrac.c'), ++ 'atrac3pal_decoder' : files('atrac3plusdec.c','atrac3plus.c','atrac3plusdsp.c','atrac.c'), ++ 'atrac3p_decoder' : files('atrac3plusdec.c','atrac3plus.c','atrac3plusdsp.c','atrac.c'), ++ 'atrac3_decoder' : files('atrac3.c','atrac.c'), ++ 'atrac9_decoder' : files('atrac9dec.c'), ++ 'atsc_a53' : files('atsc_a53.c'), ++ 'audiodsp' : files('audiodsp.c'), ++ 'audio_frame_queue' : files('audio_frame_queue.c'), ++ 'aura2_decoder' : files('aura.c'), ++ 'aura_decoder' : files('cyuv.c'), ++ 'av1_amf_encoder' : files('amfenc_av1.c'), ++ 'av1_cuvid_decoder' : files('cuviddec.c'), ++ 'av1_d3d11va_hwaccel' : files('dxva2_av1.c'), ++ 'av1_decoder' : files('av1dec.c'), ++ 'av1_dxva2_hwaccel' : files('dxva2_av1.c'), ++ 'av1_frame_merge_bsf' : files('av1_frame_merge_bsf.c'), ++ 'av1_frame_split_bsf' : files('av1_frame_split_bsf.c'), ++ 'av1_mediacodec_decoder' : files('mediacodecdec.c'), ++ 'av1_metadata_bsf' : files('av1_metadata_bsf.c'), ++ 'av1_nvdec_hwaccel' : files('nvdec_av1.c'), ++ 'av1_nvenc_encoder' : files('nvenc_av1.c','nvenc.c'), ++ 'av1_parser' : files('av1_parser.c'), ++ 'av1_qsv_encoder' : files('qsvenc_av1.c'), ++ 'av1_vaapi_hwaccel' : files('vaapi_av1.c'), ++ 'av1_vdpau_hwaccel' : files('vdpau_av1.c'), ++ 'avrn_decoder' : files('avrndec.c'), ++ 'avrp_decoder' : files('r210dec.c'), ++ 'avrp_encoder' : files('r210enc.c'), ++ 'avs2_parser' : files('avs2.c','avs2_parser.c'), ++ 'avs3_parser' : files('avs3_parser.c'), ++ 'avs_decoder' : files('avs.c'), ++ 'avui_decoder' : files('avuidec.c'), ++ 'avui_encoder' : files('avuienc.c'), ++ 'ayuv_decoder' : files('v408dec.c'), ++ 'ayuv_encoder' : files('v408enc.c'), ++ 'bethsoftvid_decoder' : files('bethsoftvideo.c'), ++ 'bfi_decoder' : files('bfi.c'), ++ 'binkaudio_dct_decoder' : files('binkaudio.c'), ++ 'binkaudio_rdft_decoder' : files('binkaudio.c'), ++ 'bink_decoder' : files('bink.c','binkdsp.c'), ++ 'bintext_decoder' : files('bintext.c','cga_data.c'), ++ 'bitpacked_decoder' : files('bitpacked_dec.c'), ++ 'bitpacked_encoder' : files('bitpacked_enc.c'), ++ 'blockdsp' : files('blockdsp.c'), ++ 'bmp_decoder' : files('bmp.c','msrledec.c'), ++ 'bmp_encoder' : files('bmpenc.c'), ++ 'bmp_parser' : files('bmp_parser.c'), ++ 'bmv_audio_decoder' : files('bmvaudio.c'), ++ 'bmv_video_decoder' : files('bmvvideo.c'), ++ 'bonk_decoder' : files('bonk.c'), ++ 'brender_pix_decoder' : files('brenderpix.c'), ++ 'bswapdsp' : files('bswapdsp.c'), ++ 'c93_decoder' : files('c93.c'), ++ 'cabac' : files('cabac.c'), ++ 'cavsvideo_parser' : files('cavs_parser.c'), ++ 'cavs_decoder' : files('cavs.c','cavsdec.c','cavsdsp.c','cavsdata.c'), ++ 'cbd2_decoder' : files('dpcm.c'), ++ 'cbs' : files('cbs.c','cbs_bsf.c'), ++ 'cbs_av1' : files('cbs_av1.c'), ++ 'cbs_h264' : files('cbs_h2645.c','cbs_sei.c','h2645_parse.c'), ++ 'cbs_h265' : files('cbs_h2645.c','cbs_sei.c','h2645_parse.c'), ++ 'cbs_jpeg' : files('cbs_jpeg.c'), ++ 'cbs_mpeg2' : files('cbs_mpeg2.c'), ++ 'cbs_vp9' : files('cbs_vp9.c'), ++ 'ccaption_decoder' : files('ccaption_dec.c','ass.c'), ++ 'cdgraphics_decoder' : files('cdgraphics.c'), ++ 'cdtoons_decoder' : files('cdtoons.c'), ++ 'cdxl_decoder' : files('cdxl.c'), ++ 'cfhd_decoder' : files('cfhd.c','cfhddata.c','cfhddsp.c'), ++ 'cfhd_encoder' : files('cfhdenc.c','cfhddata.c','cfhdencdsp.c'), ++ 'chomp_bsf' : files('chomp_bsf.c'), ++ 'cinepak_decoder' : files('cinepak.c'), ++ 'cinepak_encoder' : files('cinepakenc.c','elbg.c'), ++ 'clearvideo_decoder' : files('clearvideo.c'), ++ 'cljr_decoder' : files('cljrdec.c'), ++ 'cljr_encoder' : files('cljrenc.c'), ++ 'cllc_decoder' : files('cllc.c','canopus.c'), ++ 'comfortnoise_decoder' : files('cngdec.c','celp_filters.c'), ++ 'comfortnoise_encoder' : files('cngenc.c'), ++ 'cook_decoder' : files('cook.c'), ++ 'cook_parser' : files('cook_parser.c'), ++ 'cpia_decoder' : files('cpia.c'), ++ 'cri_decoder' : files('cri.c'), ++ 'cri_parser' : files('cri_parser.c'), ++ 'crystalhd' : files('crystalhd.c'), ++ 'cscd_decoder' : files('cscd.c'), ++ 'cyuv_decoder' : files('cyuv.c'), ++ 'd3d11va' : files('dxva2.c'), ++ 'dca_core_bsf' : files('dca_core_bsf.c'), ++ 'dca_decoder' : files('dcadec.c','dca.c','dcadata.c','dcahuff.c','dca_core.c','dca_exss.c','dca_xll.c','dca_lbr.c','dcadsp.c','dcadct.c','dca_sample_rate_tab.c','synth_filter.c'), ++ 'dca_encoder' : files('dcaenc.c','dcadata.c','dcahuff.c','dcaadpcm.c'), ++ 'dca_parser' : files('dca_parser.c','dca_exss.c','dca.c','dca_sample_rate_tab.c'), ++ 'dct' : files('dct.c','dct32_fixed.c','dct32_float.c'), ++ 'dds_decoder' : files('dds.c'), ++ 'deflate_wrapper' : files('zlib_wrapper.c'), ++ 'derf_dpcm_decoder' : files('dpcm.c'), ++ 'dfa_decoder' : files('dfa.c'), ++ 'dfpwm_decoder' : files('dfpwmdec.c'), ++ 'dfpwm_encoder' : files('dfpwmenc.c'), ++ 'dirac_decoder' : files('diracdec.c','dirac.c','diracdsp.c','diractab.c','dirac_arith.c','dirac_dwt.c','dirac_vlc.c'), ++ 'dirac_parser' : files('dirac_parser.c'), ++ 'dnxhd_decoder' : files('dnxhddec.c','dnxhddata.c'), ++ 'dnxhd_encoder' : files('dnxhdenc.c','dnxhddata.c'), ++ 'dnxhd_parser' : files('dnxhd_parser.c','dnxhddata.c'), ++ 'dolby_e_decoder' : files('dolby_e.c','dolby_e_parse.c','kbdwin.c'), ++ 'dolby_e_parser' : files('dolby_e_parser.c','dolby_e_parse.c'), ++ 'dovi_rpu' : files('dovi_rpu.c'), ++ 'dpx_decoder' : files('dpx.c'), ++ 'dpx_encoder' : files('dpxenc.c'), ++ 'dpx_parser' : files('dpx_parser.c'), ++ 'dsd_lsbf_decoder' : files('dsddec.c','dsd.c'), ++ 'dsd_lsbf_planar_decoder' : files('dsddec.c','dsd.c'), ++ 'dsd_msbf_decoder' : files('dsddec.c','dsd.c'), ++ 'dsd_msbf_planar_decoder' : files('dsddec.c','dsd.c'), ++ 'dsicinaudio_decoder' : files('dsicinaudio.c'), ++ 'dsicinvideo_decoder' : files('dsicinvideo.c'), ++ 'dss_sp_decoder' : files('dss_sp.c'), ++ 'dst_decoder' : files('dstdec.c','dsd.c'), ++ 'dts2pts_bsf' : files('dts2pts_bsf.c'), ++ 'dump_extradata_bsf' : files('dump_extradata_bsf.c'), ++ 'dvaudio_decoder' : files('dvaudiodec.c'), ++ 'dvaudio_parser' : files('dvaudio_parser.c'), ++ 'dvbsub_decoder' : files('dvbsubdec.c'), ++ 'dvbsub_encoder' : files('dvbsubenc.c'), ++ 'dvbsub_parser' : files('dvbsub_parser.c'), ++ 'dvdsub_decoder' : files('dvdsubdec.c','dvdsub.c'), ++ 'dvdsub_encoder' : files('dvdsubenc.c','dvdsub.c'), ++ 'dvdsub_parser' : files('dvdsub_parser.c'), ++ 'dvd_nav_parser' : files('dvd_nav_parser.c'), ++ 'dvvideo_decoder' : files('dvdec.c','dv.c','dvdata.c'), ++ 'dvvideo_encoder' : files('dvenc.c','dv.c','dvdata.c'), ++ 'dv_error_marker_bsf' : files('dv_error_marker_bsf.c'), ++ 'dxa_decoder' : files('dxa.c'), ++ 'dxtory_decoder' : files('dxtory.c'), ++ 'dxva2' : files('dxva2.c'), ++ 'dxv_decoder' : files('dxv.c'), ++ 'eac3_at_decoder' : files('audiotoolboxdec.c'), ++ 'eac3_core_bsf' : files('eac3_core_bsf.c'), ++ 'eac3_decoder' : files('eac3_data.c'), ++ 'eac3_encoder' : files('eac3enc.c','eac3_data.c'), ++ 'eacmv_decoder' : files('eacmv.c'), ++ 'eamad_decoder' : files('eamad.c','eaidct.c','mpeg12.c','mpeg12data.c'), ++ 'eatgq_decoder' : files('eatgq.c','eaidct.c'), ++ 'eatgv_decoder' : files('eatgv.c'), ++ 'eatqi_decoder' : files('eatqi.c','eaidct.c','mpeg12.c','mpeg12data.c'), ++ 'eightbps_decoder' : files('8bps.c'), ++ 'eightsvx_exp_decoder' : files('8svx.c'), ++ 'eightsvx_fib_decoder' : files('8svx.c'), ++ 'elbg_filter' : files('elbg.c'), ++ 'error_resilience' : files('error_resilience.c'), ++ 'escape124_decoder' : files('escape124.c'), ++ 'escape130_decoder' : files('escape130.c'), ++ 'evrc_decoder' : files('evrcdec.c','acelp_vectors.c','lsp.c'), ++ 'exif' : files('exif.c','tiff_common.c'), ++ 'exr_decoder' : files('exr.c','exrdsp.c','half2float.c'), ++ 'exr_encoder' : files('exrenc.c','float2half.c'), ++ 'extract_extradata_bsf' : files('extract_extradata_bsf.c','av1_parse.c','h2645_parse.c'), ++ 'faandct' : files('faandct.c'), ++ 'faanidct' : files('faanidct.c'), ++ 'fastaudio_decoder' : files('fastaudio.c'), ++ 'fdctdsp' : files('fdctdsp.c','jfdctfst.c','jfdctint.c'), ++ 'fft' : files('avfft.c','fft_float.c','fft_fixed_32.c','fft_init_table.c'), ++ 'ffv1_decoder' : files('ffv1dec.c','ffv1.c'), ++ 'ffv1_encoder' : files('ffv1enc.c','ffv1.c'), ++ 'ffwavesynth_decoder' : files('ffwavesynth.c'), ++ 'fic_decoder' : files('fic.c'), ++ 'filter_units_bsf' : files('filter_units_bsf.c'), ++ 'fits_decoder' : files('fitsdec.c','fits.c'), ++ 'fits_demuxer' : files('fits.c'), ++ 'fits_encoder' : files('fitsenc.c'), ++ 'flac_decoder' : files('flacdec.c','flacdata.c','flacdsp.c','flac.c'), ++ 'flac_encoder' : files('flacenc.c','flacdata.c','flacencdsp.c'), ++ 'flac_parser' : files('flac_parser.c','flacdata.c','flac.c'), ++ 'flashsv2_decoder' : files('flashsv.c'), ++ 'flashsv2_encoder' : files('flashsv2enc.c'), ++ 'flashsv_decoder' : files('flashsv.c'), ++ 'flashsv_encoder' : files('flashsvenc.c'), ++ 'flic_decoder' : files('flicvideo.c'), ++ 'flv_decoder' : files('flvdec.c'), ++ 'flv_encoder' : files('flvenc.c'), ++ 'fmtconvert' : files('fmtconvert.c'), ++ 'fmvc_decoder' : files('fmvc.c'), ++ 'fourxm_decoder' : files('4xm.c'), ++ 'frame_thread_encoder' : files('frame_thread_encoder.c'), ++ 'fraps_decoder' : files('fraps.c'), ++ 'frwu_decoder' : files('frwu.c'), ++ 'ftr_decoder' : files('ftr.c'), ++ 'ftr_parser' : files('ftr_parser.c'), ++ 'g2m_decoder' : files('g2meet.c','elsdec.c','mjpegdec_common.c'), ++ 'g723_1_decoder' : files('g723_1dec.c','g723_1.c','acelp_vectors.c','celp_filters.c','celp_math.c'), ++ 'g723_1_encoder' : files('g723_1enc.c','g723_1.c','acelp_vectors.c','celp_filters.c','celp_math.c'), ++ 'g723_1_parser' : files('g723_1_parser.c'), ++ 'g729_decoder' : files('g729dec.c','lsp.c','celp_math.c','celp_filters.c','acelp_filters.c','acelp_pitch_delay.c','acelp_vectors.c','g729postfilter.c'), ++ 'g729_parser' : files('g729_parser.c'), ++ 'gdv_decoder' : files('gdv.c'), ++ 'gem_decoder' : files('gemdec.c'), ++ 'gif_decoder' : files('gifdec.c','lzw.c'), ++ 'gif_encoder' : files('gif.c','lzwenc.c'), ++ 'gif_parser' : files('gif_parser.c'), ++ 'golomb' : files('golomb.c'), ++ 'gremlin_dpcm_decoder' : files('dpcm.c'), ++ 'gsm_decoder' : files('gsmdec.c','gsmdec_data.c','msgsmdec.c'), ++ 'gsm_ms_at_decoder' : files('audiotoolboxdec.c'), ++ 'gsm_ms_decoder' : files('gsmdec.c','gsmdec_data.c','msgsmdec.c'), ++ 'gsm_parser' : files('gsm_parser.c'), ++ 'h261_decoder' : files('h261dec.c','h261data.c','h261.c'), ++ 'h261_encoder' : files('h261enc.c','h261data.c','h261.c'), ++ 'h261_parser' : files('h261_parser.c'), ++ 'h263dsp' : files('h263dsp.c'), ++ 'h263i_decoder' : files('intelh263dec.c'), ++ 'h263_decoder' : files('h263dec.c','h263.c','ituh263dec.c','mpeg4video.c','mpeg4videodec.c','h263data.c'), ++ 'h263_encoder' : files('mpeg4video.c','h263.c','ituh263enc.c','h263data.c'), ++ 'h263_parser' : files('h263_parser.c'), ++ 'h263_v4l2m2m_decoder' : files('v4l2_m2m_dec.c'), ++ 'h263_v4l2m2m_encoder' : files('v4l2_m2m_enc.c'), ++ 'h263_vaapi_hwaccel' : files('vaapi_mpeg4.c'), ++ 'h263_videotoolbox_hwaccel' : files('videotoolbox.c'), ++ 'h264chroma' : files('h264chroma.c'), ++ 'h264dsp' : files('h264dsp.c','h264idct.c'), ++ 'h264parse' : files('h264_parse.c','h264_ps.c','h2645data.c','h2645_parse.c','h2645_vui.c'), ++ 'h264pred' : files('h264pred.c'), ++ 'h264qpel' : files('h264qpel.c'), ++ 'h264_amf_encoder' : files('amfenc_h264.c'), ++ 'h264_cuvid_decoder' : files('cuviddec.c'), ++ 'h264_d3d11va_hwaccel' : files('dxva2_h264.c'), ++ 'h264_decoder' : files('h264dec.c','h264_cabac.c','h264_cavlc.c','h264_direct.c','h264_loopfilter.c','h264_mb.c','h264_picture.c','h264_refs.c','h264_slice.c','h264data.c','h274.c'), ++ 'h264_dxva2_hwaccel' : files('dxva2_h264.c'), ++ 'h264_mediacodec_decoder' : files('mediacodecdec.c'), ++ 'h264_mediacodec_encoder' : files('mediacodecenc.c'), ++ 'h264_metadata_bsf' : files('h264_metadata_bsf.c','h264_levels.c','h2645data.c'), ++ 'h264_mf_encoder' : files('mfenc.c','mf_utils.c'), ++ 'h264_mmal_decoder' : files('mmaldec.c'), ++ 'h264_mp4toannexb_bsf' : files('h264_mp4toannexb_bsf.c'), ++ 'h264_nvdec_hwaccel' : files('nvdec_h264.c'), ++ 'h264_nvenc_encoder' : files('nvenc_h264.c','nvenc.c'), ++ 'h264_omx_encoder' : files('omx.c'), ++ 'h264_parser' : files('h264_parser.c','h264data.c'), ++ 'h264_qsv_decoder' : files('qsvdec.c'), ++ 'h264_qsv_encoder' : files('qsvenc_h264.c'), ++ 'h264_qsv_hwaccel' : files('qsvdec.c'), ++ 'h264_redundant_pps_bsf' : files('h264_redundant_pps_bsf.c'), ++ 'h264_rkmpp_decoder' : files('rkmppdec.c'), ++ 'h264_sei' : files('h264_sei.c','h2645_sei.c'), ++ 'h264_v4l2m2m_decoder' : files('v4l2_m2m_dec.c'), ++ 'h264_v4l2m2m_encoder' : files('v4l2_m2m_enc.c'), ++ 'h264_vaapi_encoder' : files('vaapi_encode_h264.c','h264_levels.c','h2645data.c'), ++ 'h264_vaapi_hwaccel' : files('vaapi_h264.c'), ++ 'h264_vdpau_hwaccel' : files('vdpau_h264.c'), ++ 'h264_videotoolbox_encoder' : files('videotoolboxenc.c'), ++ 'h264_videotoolbox_hwaccel' : files('videotoolbox.c'), ++ 'hapqa_extract_bsf' : files('hapqa_extract_bsf.c','hap.c'), ++ 'hap_decoder' : files('hapdec.c','hap.c'), ++ 'hap_encoder' : files('hapenc.c','hap.c'), ++ 'hca_decoder' : files('hcadec.c'), ++ 'hcom_decoder' : files('hcom.c'), ++ 'hdr_decoder' : files('hdrdec.c'), ++ 'hdr_encoder' : files('hdrenc.c'), ++ 'hdr_parser' : files('hdr_parser.c'), ++ 'hevcparse' : files('hevc_parse.c','hevc_ps.c','hevc_data.c','h2645data.c','h2645_parse.c','h2645_vui.c'), ++ 'hevc_amf_encoder' : files('amfenc_hevc.c'), ++ 'hevc_cuvid_decoder' : files('cuviddec.c'), ++ 'hevc_d3d11va_hwaccel' : files('dxva2_hevc.c'), ++ 'hevc_decoder' : files('hevcdec.c','hevc_mvs.c','hevc_cabac.c','hevc_refs.c','hevcpred.c','hevcdsp.c','hevc_filter.c','hevc_data.c','h274.c'), ++ 'hevc_dxva2_hwaccel' : files('dxva2_hevc.c'), ++ 'hevc_mediacodec_decoder' : files('mediacodecdec.c'), ++ 'hevc_mediacodec_encoder' : files('mediacodecenc.c'), ++ 'hevc_metadata_bsf' : files('h265_metadata_bsf.c','h265_profile_level.c','h2645data.c'), ++ 'hevc_mf_encoder' : files('mfenc.c','mf_utils.c'), ++ 'hevc_mp4toannexb_bsf' : files('hevc_mp4toannexb_bsf.c'), ++ 'hevc_nvdec_hwaccel' : files('nvdec_hevc.c'), ++ 'hevc_nvenc_encoder' : files('nvenc_hevc.c','nvenc.c'), ++ 'hevc_parser' : files('hevc_parser.c','hevc_data.c'), ++ 'hevc_qsv_decoder' : files('qsvdec.c'), ++ 'hevc_qsv_encoder' : files('qsvenc_hevc.c','hevc_ps_enc.c','hevc_data.c'), ++ 'hevc_qsv_hwaccel' : files('qsvdec.c'), ++ 'hevc_rkmpp_decoder' : files('rkmppdec.c'), ++ 'hevc_sei' : files('hevc_sei.c','h2645_sei.c','dynamic_hdr10_plus.c','dynamic_hdr_vivid.c'), ++ 'hevc_v4l2m2m_decoder' : files('v4l2_m2m_dec.c'), ++ 'hevc_v4l2m2m_encoder' : files('v4l2_m2m_enc.c'), ++ 'hevc_vaapi_encoder' : files('vaapi_encode_h265.c','h265_profile_level.c','h2645data.c'), ++ 'hevc_vaapi_hwaccel' : files('vaapi_hevc.c','h265_profile_level.c'), ++ 'hevc_vdpau_hwaccel' : files('vdpau_hevc.c','h265_profile_level.c'), ++ 'hevc_videotoolbox_encoder' : files('videotoolboxenc.c'), ++ 'hnm4_video_decoder' : files('hnm4video.c'), ++ 'hpeldsp' : files('hpeldsp.c'), ++ 'hqx_decoder' : files('hqx.c','hqxvlc.c','hqxdsp.c','canopus.c'), ++ 'hq_hqa_decoder' : files('hq_hqa.c','hq_hqadata.c','hq_hqadsp.c','canopus.c'), ++ 'huffman' : files('huffman.c'), ++ 'huffyuvdsp' : files('huffyuvdsp.c'), ++ 'huffyuvencdsp' : files('huffyuvencdsp.c'), ++ 'huffyuv_decoder' : files('huffyuv.c','huffyuvdec.c'), ++ 'huffyuv_encoder' : files('huffyuv.c','huffyuvenc.c'), ++ 'hymt_decoder' : files('huffyuv.c','huffyuvdec.c'), ++ 'idcin_decoder' : files('idcinvideo.c'), ++ 'idctdsp' : files('idctdsp.c','simple_idct.c','jrevdct.c'), ++ 'idf_decoder' : files('bintext.c','cga_data.c'), ++ 'iff_ilbm_decoder' : files('iff.c'), ++ 'iirfilter' : files('iirfilter.c'), ++ 'ilbc_at_decoder' : files('audiotoolboxdec.c'), ++ 'ilbc_at_encoder' : files('audiotoolboxenc.c'), ++ 'ilbc_decoder' : files('ilbcdec.c'), ++ 'imc_decoder' : files('imc.c'), ++ 'imm4_decoder' : files('imm4.c'), ++ 'imm5_decoder' : files('imm5.c'), ++ 'imx_dump_header_bsf' : files('imx_dump_header_bsf.c'), ++ 'indeo2_decoder' : files('indeo2.c'), ++ 'indeo3_decoder' : files('indeo3.c'), ++ 'indeo4_decoder' : files('indeo4.c','ivi.c'), ++ 'indeo5_decoder' : files('indeo5.c','ivi.c'), ++ 'inflate_wrapper' : files('zlib_wrapper.c'), ++ 'interplay_acm_decoder' : files('interplayacm.c'), ++ 'interplay_dpcm_decoder' : files('dpcm.c'), ++ 'interplay_video_decoder' : files('interplayvideo.c'), ++ 'intrax8' : files('intrax8.c','intrax8dsp.c','msmpeg4data.c'), ++ 'ipu_decoder' : files('mpeg12dec.c','mpeg12.c','mpeg12data.c'), ++ 'ipu_parser' : files('ipu_parser.c'), ++ 'ividsp' : files('ivi_dsp.c'), ++ 'jacosub_decoder' : files('jacosubdec.c','ass.c'), ++ 'jni' : files('ffjni.c','jni.c'), ++ 'jpeg2000_decoder' : files('jpeg2000dec.c','jpeg2000.c','jpeg2000dsp.c','jpeg2000dwt.c','mqcdec.c','mqc.c'), ++ 'jpeg2000_encoder' : files('j2kenc.c','mqcenc.c','mqc.c','jpeg2000.c','jpeg2000dwt.c'), ++ 'jpeg2000_parser' : files('jpeg2000_parser.c'), ++ 'jpegls_decoder' : files('jpeglsdec.c','jpegls.c'), ++ 'jpegls_encoder' : files('jpeglsenc.c','jpegls.c'), ++ 'jpegtables' : files('jpegtables.c'), ++ 'jv_decoder' : files('jvdec.c'), ++ 'kgv1_decoder' : files('kgv1dec.c'), ++ 'kmvc_decoder' : files('kmvc.c'), ++ 'lagarith_decoder' : files('lagarith.c','lagarithrac.c'), ++ 'lcms2' : files('fflcms2.c'), ++ 'libaom_av1_decoder' : files('libaomdec.c','libaom.c'), ++ 'libaom_av1_encoder' : files('libaomenc.c','libaom.c'), ++ 'libaribb24_decoder' : files('libaribb24.c','ass.c'), ++ 'libcelt_decoder' : files('libcelt_dec.c'), ++ 'libcodec2_decoder' : files('libcodec2.c'), ++ 'libcodec2_encoder' : files('libcodec2.c'), ++ 'libc_msvcrt' : files('file_open.c'), ++ 'libdav1d_decoder' : files('libdav1d.c'), ++ 'libdavs2_decoder' : files('libdavs2.c'), ++ 'libfdk_aac_decoder' : files('libfdk-aacdec.c'), ++ 'libfdk_aac_encoder' : files('libfdk-aacenc.c'), ++ 'libgsm_decoder' : files('libgsmdec.c'), ++ 'libgsm_encoder' : files('libgsmenc.c'), ++ 'libgsm_ms_decoder' : files('libgsmdec.c'), ++ 'libgsm_ms_encoder' : files('libgsmenc.c'), ++ 'libilbc_decoder' : files('libilbc.c'), ++ 'libilbc_encoder' : files('libilbc.c'), ++ 'libjxl_decoder' : files('libjxldec.c','libjxl.c'), ++ 'libjxl_encoder' : files('libjxlenc.c','libjxl.c'), ++ 'libkvazaar_encoder' : files('libkvazaar.c'), ++ 'libmp3lame_encoder' : files('libmp3lame.c'), ++ 'libopencore_amrnb_decoder' : files('libopencore-amr.c'), ++ 'libopencore_amrnb_encoder' : files('libopencore-amr.c'), ++ 'libopencore_amrwb_decoder' : files('libopencore-amr.c'), ++ 'libopenh264_decoder' : files('libopenh264dec.c','libopenh264.c'), ++ 'libopenh264_encoder' : files('libopenh264enc.c','libopenh264.c'), ++ 'libopenjpeg_decoder' : files('libopenjpegdec.c'), ++ 'libopenjpeg_encoder' : files('libopenjpegenc.c'), ++ 'libopus_decoder' : files('libopusdec.c','libopus.c','vorbis_data.c'), ++ 'libopus_encoder' : files('libopusenc.c','libopus.c','vorbis_data.c'), ++ 'librav1e_encoder' : files('librav1e.c'), ++ 'librsvg_decoder' : files('librsvgdec.c'), ++ 'libshine_encoder' : files('libshine.c'), ++ 'libspeex_decoder' : files('libspeexdec.c'), ++ 'libspeex_encoder' : files('libspeexenc.c'), ++ 'libsvtav1_encoder' : files('libsvtav1.c'), ++ 'libtheora_encoder' : files('libtheoraenc.c'), ++ 'libtwolame_encoder' : files('libtwolame.c'), ++ 'libuavs3d_decoder' : files('libuavs3d.c'), ++ 'libvorbis_decoder' : files('libvorbisdec.c'), ++ 'libvorbis_encoder' : files('libvorbisenc.c','vorbis_data.c'), ++ 'libvo_amrwbenc_encoder' : files('libvo-amrwbenc.c'), ++ 'libvpx_vp8_decoder' : files('libvpxdec.c'), ++ 'libvpx_vp8_encoder' : files('libvpxenc.c'), ++ 'libvpx_vp9_decoder' : files('libvpxdec.c','libvpx.c'), ++ 'libvpx_vp9_encoder' : files('libvpxenc.c','libvpx.c'), ++ 'libwebp_anim_encoder' : files('libwebpenc_common.c','libwebpenc_animencoder.c'), ++ 'libwebp_encoder' : files('libwebpenc_common.c','libwebpenc.c'), ++ 'libx262_encoder' : files('libx264.c'), ++ 'libx264_encoder' : files('libx264.c'), ++ 'libx265_encoder' : files('libx265.c'), ++ 'libxavs2_encoder' : files('libxavs2.c'), ++ 'libxavs_encoder' : files('libxavs.c'), ++ 'libxvid_encoder' : files('libxvid.c'), ++ 'libzvbi_teletext_decoder' : files('libzvbi-teletextdec.c','ass.c'), ++ 'ljpeg_encoder' : files('ljpegenc.c','mjpegenc_common.c'), ++ 'llauddsp' : files('lossless_audiodsp.c'), ++ 'llviddsp' : files('lossless_videodsp.c'), ++ 'llvidencdsp' : files('lossless_videoencdsp.c'), ++ 'loco_decoder' : files('loco.c'), ++ 'lpc' : files('lpc.c'), ++ 'lscr_decoder' : files('lscrdec.c','png.c','pngdec.c','pngdsp.c'), ++ 'lsp' : files('lsp.c'), ++ 'lzf' : files('lzf.c'), ++ 'm101_decoder' : files('m101.c'), ++ 'mace3_decoder' : files('mace.c'), ++ 'mace6_decoder' : files('mace.c'), ++ 'magicyuv_decoder' : files('magicyuv.c'), ++ 'magicyuv_encoder' : files('magicyuvenc.c'), ++ 'mdct' : files('mdct_float.c','mdct_fixed_32.c'), ++ 'mdec_decoder' : files('mdec.c','mpeg12.c','mpeg12data.c'), ++ 'media100_decoder' : files('mjpegbdec.c'), ++ 'media100_to_mjpegb_bsf' : files('media100_to_mjpegb_bsf.c'), ++ 'mediacodec' : files('mediacodecdec_common.c','mediacodec_surface.c','mediacodec_wrapper.c','mediacodec_sw_buffer.c'), ++ 'metasound_decoder' : files('metasound.c','twinvq.c'), ++ 'me_cmp' : files('me_cmp.c'), ++ 'microdvd_decoder' : files('microdvddec.c','ass.c'), ++ 'mimic_decoder' : files('mimic.c'), ++ 'misc4_decoder' : files('misc4.c'), ++ 'misc4_parser' : files('misc4_parser.c'), ++ 'mjpeg2jpeg_bsf' : files('mjpeg2jpeg_bsf.c'), ++ 'mjpega_dump_header_bsf' : files('mjpega_dump_header_bsf.c'), ++ 'mjpegb_decoder' : files('mjpegbdec.c'), ++ 'mjpeg_cuvid_decoder' : files('cuviddec.c'), ++ 'mjpeg_decoder' : files('mjpegdec.c','mjpegdec_common.c'), ++ 'mjpeg_encoder' : files('mjpegenc.c','mjpegenc_common.c','mjpegenc_huffman.c'), ++ 'mjpeg_nvdec_hwaccel' : files('nvdec_mjpeg.c'), ++ 'mjpeg_parser' : files('mjpeg_parser.c'), ++ 'mjpeg_qsv_decoder' : files('qsvdec.c'), ++ 'mjpeg_qsv_encoder' : files('qsvenc_jpeg.c'), ++ 'mjpeg_vaapi_encoder' : files('vaapi_encode_mjpeg.c'), ++ 'mjpeg_vaapi_hwaccel' : files('vaapi_mjpeg.c'), ++ 'mlp_decoder' : files('mlpdec.c','mlpdsp.c'), ++ 'mlp_encoder' : files('mlpenc.c','mlp.c'), ++ 'mlp_parser' : files('mlp_parse.c','mlp_parser.c','mlp.c'), ++ 'mmvideo_decoder' : files('mmvideo.c'), ++ 'mobiclip_decoder' : files('mobiclip.c'), ++ 'motionpixels_decoder' : files('motionpixels.c'), ++ 'mov2textsub_bsf' : files('movsub_bsf.c'), ++ 'movtext_decoder' : files('movtextdec.c','ass.c'), ++ 'movtext_encoder' : files('movtextenc.c','ass_split.c'), ++ 'mp1float_decoder' : files('mpegaudiodec_float.c'), ++ 'mp1_at_decoder' : files('audiotoolboxdec.c'), ++ 'mp1_decoder' : files('mpegaudiodec_fixed.c'), ++ 'mp2fixed_encoder' : files('mpegaudioenc_fixed.c','mpegaudio.c','mpegaudiodata.c','mpegaudiodsp_data.c','mpegaudiotabs.c'), ++ 'mp2float_decoder' : files('mpegaudiodec_float.c'), ++ 'mp2_at_decoder' : files('audiotoolboxdec.c'), ++ 'mp2_decoder' : files('mpegaudiodec_fixed.c'), ++ 'mp2_encoder' : files('mpegaudioenc_float.c','mpegaudio.c','mpegaudiodata.c','mpegaudiodsp_data.c','mpegaudiotabs.c'), ++ 'mp3adufloat_decoder' : files('mpegaudiodec_float.c'), ++ 'mp3adu_decoder' : files('mpegaudiodec_fixed.c'), ++ 'mp3float_decoder' : files('mpegaudiodec_float.c'), ++ 'mp3on4float_decoder' : files('mpegaudiodec_float.c'), ++ 'mp3on4_decoder' : files('mpegaudiodec_fixed.c'), ++ 'mp3_at_decoder' : files('audiotoolboxdec.c'), ++ 'mp3_decoder' : files('mpegaudiodec_fixed.c'), ++ 'mp3_header_decompress_bsf' : files('mp3_header_decompress_bsf.c','mpegaudiotabs.c'), ++ 'mp3_mf_encoder' : files('mfenc.c','mf_utils.c'), ++ 'mpc7_decoder' : files('mpc7.c','mpc.c'), ++ 'mpc8_decoder' : files('mpc8.c','mpc.c'), ++ 'mpeg1video_decoder' : files('mpeg12dec.c','mpeg12.c','mpeg12data.c'), ++ 'mpeg1video_encoder' : files('mpeg12enc.c','mpeg12.c'), ++ 'mpeg1_cuvid_decoder' : files('cuviddec.c'), ++ 'mpeg1_nvdec_hwaccel' : files('nvdec_mpeg12.c'), ++ 'mpeg1_v4l2m2m_decoder' : files('v4l2_m2m_dec.c'), ++ 'mpeg1_vdpau_hwaccel' : files('vdpau_mpeg12.c'), ++ 'mpeg1_videotoolbox_hwaccel' : files('videotoolbox.c'), ++ 'mpeg2video_decoder' : files('mpeg12dec.c','mpeg12.c','mpeg12data.c'), ++ 'mpeg2video_encoder' : files('mpeg12enc.c','mpeg12.c'), ++ 'mpeg2_cuvid_decoder' : files('cuviddec.c'), ++ 'mpeg2_d3d11va_hwaccel' : files('dxva2_mpeg2.c'), ++ 'mpeg2_dxva2_hwaccel' : files('dxva2_mpeg2.c'), ++ 'mpeg2_mediacodec_decoder' : files('mediacodecdec.c'), ++ 'mpeg2_metadata_bsf' : files('mpeg2_metadata_bsf.c'), ++ 'mpeg2_mmal_decoder' : files('mmaldec.c'), ++ 'mpeg2_nvdec_hwaccel' : files('nvdec_mpeg12.c'), ++ 'mpeg2_qsv_decoder' : files('qsvdec.c'), ++ 'mpeg2_qsv_encoder' : files('qsvenc_mpeg2.c'), ++ 'mpeg2_qsv_hwaccel' : files('qsvdec.c'), ++ 'mpeg2_v4l2m2m_decoder' : files('v4l2_m2m_dec.c'), ++ 'mpeg2_vaapi_encoder' : files('vaapi_encode_mpeg2.c'), ++ 'mpeg2_vaapi_hwaccel' : files('vaapi_mpeg2.c'), ++ 'mpeg2_vdpau_hwaccel' : files('vdpau_mpeg12.c'), ++ 'mpeg2_videotoolbox_hwaccel' : files('videotoolbox.c'), ++ 'mpeg4audio' : files('mpeg4audio.c','mpeg4audio_sample_rates.c'), ++ 'mpeg4video_parser' : files('mpeg4video_parser.c','h263.c','mpeg4videodec.c','mpeg4video.c','ituh263dec.c','h263dec.c','h263data.c'), ++ 'mpeg4_cuvid_decoder' : files('cuviddec.c'), ++ 'mpeg4_decoder' : files('mpeg4videodsp.c','xvididct.c'), ++ 'mpeg4_encoder' : files('mpeg4videoenc.c'), ++ 'mpeg4_mediacodec_decoder' : files('mediacodecdec.c'), ++ 'mpeg4_nvdec_hwaccel' : files('nvdec_mpeg4.c'), ++ 'mpeg4_omx_encoder' : files('omx.c'), ++ 'mpeg4_unpack_bframes_bsf' : files('mpeg4_unpack_bframes_bsf.c'), ++ 'mpeg4_v4l2m2m_decoder' : files('v4l2_m2m_dec.c'), ++ 'mpeg4_v4l2m2m_encoder' : files('v4l2_m2m_enc.c'), ++ 'mpeg4_vaapi_hwaccel' : files('vaapi_mpeg4.c'), ++ 'mpeg4_vdpau_hwaccel' : files('vdpau_mpeg4.c'), ++ 'mpeg4_videotoolbox_hwaccel' : files('videotoolbox.c'), ++ 'mpegaudio' : files('mpegaudio.c','mpegaudiodec_common.c','mpegaudiodata.c'), ++ 'mpegaudiodsp' : files('mpegaudiodsp.c','mpegaudiodsp_data.c','mpegaudiodsp_fixed.c','mpegaudiodsp_float.c'), ++ 'mpegaudioheader' : files('mpegaudiodecheader.c','mpegaudiotabs.c'), ++ 'mpegaudio_parser' : files('mpegaudio_parser.c'), ++ 'mpegvideo' : files('mpegvideo.c','rl.c','mpegvideo_motion.c','mpegvideodata.c','mpegpicture.c','to_upper4.c'), ++ 'mpegvideodec' : files('mpegvideo_dec.c','mpegutils.c'), ++ 'mpegvideoenc' : files('mpegvideo_enc.c','mpeg12data.c','motion_est.c','ratecontrol.c','mpegvideoencdsp.c'), ++ 'mpegvideo_decoder' : files('mpeg12dec.c','mpeg12.c','mpeg12data.c'), ++ 'mpegvideo_parser' : files('mpegvideo_parser.c','mpeg12.c','mpeg12data.c'), ++ 'mpeg_er' : files('mpeg_er.c'), ++ 'mpl2_decoder' : files('mpl2dec.c','ass.c'), ++ 'msa1_decoder' : files('mss3.c'), ++ 'mscc_decoder' : files('mscc.c'), ++ 'msmpeg4dec' : files('msmpeg4dec.c','msmpeg4.c','msmpeg4data.c','msmpeg4_vc1_data.c'), ++ 'msmpeg4enc' : files('msmpeg4enc.c','msmpeg4.c','msmpeg4data.c','msmpeg4_vc1_data.c'), ++ 'msnsiren_decoder' : files('siren.c'), ++ 'msp2_decoder' : files('msp2dec.c'), ++ 'msrle_decoder' : files('msrle.c','msrledec.c'), ++ 'mss1_decoder' : files('mss1.c','mss12.c'), ++ 'mss2_decoder' : files('mss2.c','mss12.c','mss2dsp.c','wmv2data.c'), ++ 'mss34dsp' : files('mss34dsp.c','jpegquanttables.c'), ++ 'msvideo1_decoder' : files('msvideo1.c'), ++ 'msvideo1_encoder' : files('msvideo1enc.c','elbg.c'), ++ 'mszh_decoder' : files('lcldec.c'), ++ 'mts2_decoder' : files('mss4.c'), ++ 'mv30_decoder' : files('mv30.c'), ++ 'mvc1_decoder' : files('mvcdec.c'), ++ 'mvc2_decoder' : files('mvcdec.c'), ++ 'mvdv_decoder' : files('midivid.c'), ++ 'mvha_decoder' : files('mvha.c'), ++ 'mwsc_decoder' : files('mwsc.c'), ++ 'mxpeg_decoder' : files('mxpegdec.c'), ++ 'nellymoser_decoder' : files('nellymoserdec.c','nellymoser.c'), ++ 'nellymoser_encoder' : files('nellymoserenc.c','nellymoser.c'), ++ 'noise_bsf' : files('noise_bsf.c'), ++ 'notchlc_decoder' : files('notchlc.c'), ++ 'null_bsf' : files('null_bsf.c'), ++ 'nuv_decoder' : files('nuv.c','rtjpeg.c','jpegquanttables.c'), ++ 'nvdec' : files('nvdec.c'), ++ 'on2avc_decoder' : files('on2avc.c','on2avcdata.c'), ++ 'opus_decoder' : files('opusdec.c','opusdec_celt.c','opus_celt.c','opus_pvq.c','opus_silk.c','opustab.c','vorbis_data.c','opusdsp.c','opus_parse.c','opus_rc.c'), ++ 'opus_encoder' : files('opusenc.c','opusenc_psy.c','opus_celt.c','opus_pvq.c','opus_rc.c','opustab.c'), ++ 'opus_metadata_bsf' : files('opus_metadata_bsf.c'), ++ 'opus_parser' : files('opus_parser.c','opus_parse.c','vorbis_data.c'), ++ 'paf_audio_decoder' : files('pafaudio.c'), ++ 'paf_video_decoder' : files('pafvideo.c'), ++ 'pam_decoder' : files('pnmdec.c','pnm.c'), ++ 'pam_encoder' : files('pamenc.c'), ++ 'pbm_decoder' : files('pnmdec.c','pnm.c'), ++ 'pbm_encoder' : files('pnmenc.c'), ++ 'pcm_alaw_at_decoder' : files('audiotoolboxdec.c'), ++ 'pcm_alaw_at_encoder' : files('audiotoolboxenc.c'), ++ 'pcm_alaw_decoder' : files('pcm.c'), ++ 'pcm_alaw_encoder' : files('pcm.c'), ++ 'pcm_bluray_decoder' : files('pcm-bluray.c'), ++ 'pcm_bluray_encoder' : files('pcm-blurayenc.c'), ++ 'pcm_dvd_decoder' : files('pcm-dvd.c'), ++ 'pcm_dvd_encoder' : files('pcm-dvdenc.c'), ++ 'pcm_f16le_decoder' : files('pcm.c'), ++ 'pcm_f24le_decoder' : files('pcm.c'), ++ 'pcm_f32be_decoder' : files('pcm.c'), ++ 'pcm_f32be_encoder' : files('pcm.c'), ++ 'pcm_f32le_decoder' : files('pcm.c'), ++ 'pcm_f32le_encoder' : files('pcm.c'), ++ 'pcm_f64be_decoder' : files('pcm.c'), ++ 'pcm_f64be_encoder' : files('pcm.c'), ++ 'pcm_f64le_decoder' : files('pcm.c'), ++ 'pcm_f64le_encoder' : files('pcm.c'), ++ 'pcm_lxf_decoder' : files('pcm.c'), ++ 'pcm_mulaw_at_decoder' : files('audiotoolboxdec.c'), ++ 'pcm_mulaw_at_encoder' : files('audiotoolboxenc.c'), ++ 'pcm_mulaw_decoder' : files('pcm.c'), ++ 'pcm_mulaw_encoder' : files('pcm.c'), ++ 'pcm_rechunk_bsf' : files('pcm_rechunk_bsf.c'), ++ 'pcm_s16be_decoder' : files('pcm.c'), ++ 'pcm_s16be_encoder' : files('pcm.c'), ++ 'pcm_s16be_planar_decoder' : files('pcm.c'), ++ 'pcm_s16be_planar_encoder' : files('pcm.c'), ++ 'pcm_s16le_decoder' : files('pcm.c'), ++ 'pcm_s16le_encoder' : files('pcm.c'), ++ 'pcm_s16le_planar_decoder' : files('pcm.c'), ++ 'pcm_s16le_planar_encoder' : files('pcm.c'), ++ 'pcm_s24be_decoder' : files('pcm.c'), ++ 'pcm_s24be_encoder' : files('pcm.c'), ++ 'pcm_s24daud_decoder' : files('pcm.c'), ++ 'pcm_s24daud_encoder' : files('pcm.c'), ++ 'pcm_s24le_decoder' : files('pcm.c'), ++ 'pcm_s24le_encoder' : files('pcm.c'), ++ 'pcm_s24le_planar_decoder' : files('pcm.c'), ++ 'pcm_s24le_planar_encoder' : files('pcm.c'), ++ 'pcm_s32be_decoder' : files('pcm.c'), ++ 'pcm_s32be_encoder' : files('pcm.c'), ++ 'pcm_s32le_decoder' : files('pcm.c'), ++ 'pcm_s32le_encoder' : files('pcm.c'), ++ 'pcm_s32le_planar_decoder' : files('pcm.c'), ++ 'pcm_s32le_planar_encoder' : files('pcm.c'), ++ 'pcm_s64be_decoder' : files('pcm.c'), ++ 'pcm_s64be_encoder' : files('pcm.c'), ++ 'pcm_s64le_decoder' : files('pcm.c'), ++ 'pcm_s64le_encoder' : files('pcm.c'), ++ 'pcm_s8_decoder' : files('pcm.c'), ++ 'pcm_s8_encoder' : files('pcm.c'), ++ 'pcm_s8_planar_decoder' : files('pcm.c'), ++ 'pcm_s8_planar_encoder' : files('pcm.c'), ++ 'pcm_sga_decoder' : files('pcm.c'), ++ 'pcm_u16be_decoder' : files('pcm.c'), ++ 'pcm_u16be_encoder' : files('pcm.c'), ++ 'pcm_u16le_decoder' : files('pcm.c'), ++ 'pcm_u16le_encoder' : files('pcm.c'), ++ 'pcm_u24be_decoder' : files('pcm.c'), ++ 'pcm_u24be_encoder' : files('pcm.c'), ++ 'pcm_u24le_decoder' : files('pcm.c'), ++ 'pcm_u24le_encoder' : files('pcm.c'), ++ 'pcm_u32be_decoder' : files('pcm.c'), ++ 'pcm_u32be_encoder' : files('pcm.c'), ++ 'pcm_u32le_decoder' : files('pcm.c'), ++ 'pcm_u32le_encoder' : files('pcm.c'), ++ 'pcm_u8_decoder' : files('pcm.c'), ++ 'pcm_u8_encoder' : files('pcm.c'), ++ 'pcm_vidc_decoder' : files('pcm.c'), ++ 'pcm_vidc_encoder' : files('pcm.c'), ++ 'pcx_decoder' : files('pcx.c'), ++ 'pcx_encoder' : files('pcxenc.c'), ++ 'pfm_decoder' : files('pnmdec.c','pnm.c'), ++ 'pfm_encoder' : files('pnmenc.c'), ++ 'pgmyuv_decoder' : files('pnmdec.c','pnm.c'), ++ 'pgmyuv_encoder' : files('pnmenc.c'), ++ 'pgm_decoder' : files('pnmdec.c','pnm.c'), ++ 'pgm_encoder' : files('pnmenc.c'), ++ 'pgssub_decoder' : files('pgssubdec.c'), ++ 'pgs_frame_merge_bsf' : files('pgs_frame_merge_bsf.c'), ++ 'pgx_decoder' : files('pgxdec.c'), ++ 'phm_decoder' : files('pnmdec.c','pnm.c','half2float.c'), ++ 'phm_encoder' : files('pnmenc.c','float2half.c'), ++ 'photocd_decoder' : files('photocd.c'), ++ 'pictor_decoder' : files('pictordec.c','cga_data.c'), ++ 'pixblockdsp' : files('pixblockdsp.c'), ++ 'pixlet_decoder' : files('pixlet.c'), ++ 'pjs_decoder' : files('textdec.c','ass.c'), ++ 'png_decoder' : files('png.c','pngdec.c','pngdsp.c'), ++ 'png_encoder' : files('png.c','pngenc.c'), ++ 'png_parser' : files('png_parser.c'), ++ 'pnm_parser' : files('pnm_parser.c','pnm.c'), ++ 'ppm_decoder' : files('pnmdec.c','pnm.c'), ++ 'ppm_encoder' : files('pnmenc.c'), ++ 'prores_aw_encoder' : files('proresenc_anatoliy.c','proresdata.c'), ++ 'prores_decoder' : files('proresdec2.c','proresdsp.c','proresdata.c'), ++ 'prores_encoder' : files('proresenc_anatoliy.c','proresdata.c'), ++ 'prores_ks_encoder' : files('proresenc_kostya.c','proresdata.c'), ++ 'prores_metadata_bsf' : files('prores_metadata_bsf.c'), ++ 'prores_videotoolbox_encoder' : files('videotoolboxenc.c'), ++ 'prosumer_decoder' : files('prosumer.c'), ++ 'psd_decoder' : files('psd.c'), ++ 'ptx_decoder' : files('ptx.c'), ++ 'qcelp_decoder' : files('qcelpdec.c','celp_filters.c','acelp_vectors.c','acelp_filters.c'), ++ 'qdm2_at_decoder' : files('audiotoolboxdec.c'), ++ 'qdm2_decoder' : files('qdm2.c'), ++ 'qdmc_at_decoder' : files('audiotoolboxdec.c'), ++ 'qdmc_decoder' : files('qdmc.c'), ++ 'qdraw_decoder' : files('qdrw.c'), ++ 'qoi_decoder' : files('qoidec.c'), ++ 'qoi_encoder' : files('qoienc.c'), ++ 'qoi_parser' : files('qoi_parser.c'), ++ 'qpeg_decoder' : files('qpeg.c'), ++ 'qpeldsp' : files('qpeldsp.c'), ++ 'qsv' : files('qsv.c'), ++ 'qsvdec' : files('qsvdec.c'), ++ 'qsvenc' : files('qsvenc.c'), ++ 'qtrle_decoder' : files('qtrle.c'), ++ 'qtrle_encoder' : files('qtrleenc.c'), ++ 'r10k_decoder' : files('r210dec.c'), ++ 'r10k_encoder' : files('r210enc.c'), ++ 'r210_decoder' : files('r210dec.c'), ++ 'r210_encoder' : files('r210enc.c'), ++ 'ralf_decoder' : files('ralf.c'), ++ 'rangecoder' : files('rangecoder.c'), ++ 'rasc_decoder' : files('rasc.c'), ++ 'rawvideo_decoder' : files('rawdec.c'), ++ 'rawvideo_encoder' : files('rawenc.c'), ++ 'ra_144_decoder' : files('ra144dec.c','ra144.c','celp_filters.c'), ++ 'ra_144_encoder' : files('ra144enc.c','ra144.c','celp_filters.c'), ++ 'ra_288_decoder' : files('ra288.c','celp_filters.c'), ++ 'rdft' : files('rdft.c'), ++ 'realtext_decoder' : files('realtextdec.c','ass.c'), ++ 'remove_extradata_bsf' : files('remove_extradata_bsf.c','av1_parse.c'), ++ 'rka_decoder' : files('rka.c'), ++ 'rl2_decoder' : files('rl2.c'), ++ 'roq_decoder' : files('roqvideodec.c','roqvideo.c'), ++ 'roq_dpcm_decoder' : files('dpcm.c'), ++ 'roq_dpcm_encoder' : files('roqaudioenc.c'), ++ 'roq_encoder' : files('roqvideoenc.c','roqvideo.c','elbg.c'), ++ 'rpza_decoder' : files('rpza.c'), ++ 'rpza_encoder' : files('rpzaenc.c'), ++ 'rscc_decoder' : files('rscc.c'), ++ 'rv10_decoder' : files('rv10.c'), ++ 'rv10_encoder' : files('rv10enc.c'), ++ 'rv20_decoder' : files('rv10.c'), ++ 'rv20_encoder' : files('rv20enc.c'), ++ 'rv30_decoder' : files('rv30.c','rv34.c','rv30dsp.c'), ++ 'rv30_parser' : files('rv34_parser.c'), ++ 'rv34dsp' : files('rv34dsp.c'), ++ 'rv40_decoder' : files('rv40.c','rv34.c','rv40dsp.c'), ++ 'rv40_parser' : files('rv34_parser.c'), ++ 's302m_decoder' : files('s302m.c'), ++ 's302m_encoder' : files('s302menc.c'), ++ 'sami_decoder' : files('samidec.c','ass.c','htmlsubtitles.c'), ++ 'sanm_decoder' : files('sanm.c'), ++ 'sbc_decoder' : files('sbcdec.c','sbcdec_data.c','sbc.c'), ++ 'sbc_encoder' : files('sbcenc.c','sbc.c','sbcdsp.c','sbcdsp_data.c'), ++ 'sbc_parser' : files('sbc_parser.c'), ++ 'scpr_decoder' : files('scpr.c'), ++ 'screenpresso_decoder' : files('screenpresso.c'), ++ 'sdx2_dpcm_decoder' : files('dpcm.c'), ++ 'setts_bsf' : files('setts_bsf.c'), ++ 'sga_decoder' : files('sga.c'), ++ 'sgirle_decoder' : files('sgirledec.c'), ++ 'sgi_decoder' : files('sgidec.c'), ++ 'sgi_encoder' : files('sgienc.c','rle.c'), ++ 'sheervideo_decoder' : files('sheervideo.c'), ++ 'shorten_decoder' : files('shorten.c'), ++ 'simbiosis_imx_decoder' : files('imx.c'), ++ 'sinewin' : files('sinewin.c'), ++ 'sipr_decoder' : files('sipr.c','acelp_pitch_delay.c','celp_math.c','acelp_vectors.c','acelp_filters.c','celp_filters.c','sipr16k.c'), ++ 'sipr_parser' : files('sipr_parser.c'), ++ 'siren_decoder' : files('siren.c'), ++ 'smackaud_decoder' : files('smacker.c'), ++ 'smacker_decoder' : files('smacker.c'), ++ 'smc_decoder' : files('smc.c'), ++ 'smc_encoder' : files('smcenc.c'), ++ 'snappy' : files('snappy.c'), ++ 'snow_decoder' : files('snowdec.c','snow.c','snow_dwt.c'), ++ 'snow_encoder' : files('snowenc.c','snow.c','snow_dwt.c','h263.c','h263data.c','ituh263enc.c'), ++ 'sol_dpcm_decoder' : files('dpcm.c'), ++ 'sonic_decoder' : files('sonic.c'), ++ 'sonic_encoder' : files('sonic.c'), ++ 'sonic_ls_encoder' : files('sonic.c'), ++ 'sp5x_decoder' : files('sp5xdec.c'), ++ 'speedhq_decoder' : files('speedhqdec.c','speedhq.c','mpeg12.c','mpeg12data.c'), ++ 'speedhq_encoder' : files('speedhq.c','mpeg12data.c','mpeg12enc.c','speedhqenc.c'), ++ 'speex_decoder' : files('speexdec.c'), ++ 'srgc_decoder' : files('mscc.c'), ++ 'srt_decoder' : files('srtdec.c','ass.c','htmlsubtitles.c'), ++ 'srt_encoder' : files('srtenc.c','ass_split.c'), ++ 'ssa_decoder' : files('assdec.c','ass.c'), ++ 'ssa_encoder' : files('assenc.c','ass.c'), ++ 'startcode' : files('startcode.c'), ++ 'stl_decoder' : files('textdec.c','ass.c'), ++ 'subrip_decoder' : files('srtdec.c','ass.c','htmlsubtitles.c'), ++ 'subrip_encoder' : files('srtenc.c','ass_split.c'), ++ 'subviewer1_decoder' : files('textdec.c','ass.c'), ++ 'subviewer_decoder' : files('subviewerdec.c','ass.c'), ++ 'sunrast_decoder' : files('sunrast.c'), ++ 'sunrast_encoder' : files('sunrastenc.c'), ++ 'svq1_decoder' : files('svq1dec.c','svq1.c','h263data.c'), ++ 'svq1_encoder' : files('svq1enc.c','svq1.c','h263data.c','h263.c','ituh263enc.c'), ++ 'svq3_decoder' : files('svq3.c','mpegutils.c','h264data.c'), ++ 'tak_decoder' : files('takdec.c','tak.c','takdsp.c'), ++ 'tak_demuxer' : files('tak.c'), ++ 'tak_parser' : files('tak_parser.c','tak.c'), ++ 'targa_decoder' : files('targa.c'), ++ 'targa_encoder' : files('targaenc.c','rle.c'), ++ 'targa_y216_decoder' : files('targa_y216dec.c'), ++ 'tdsc_decoder' : files('tdsc.c'), ++ 'text2movsub_bsf' : files('movsub_bsf.c'), ++ 'texturedsp' : files('texturedsp.c'), ++ 'texturedspenc' : files('texturedspenc.c'), ++ 'text_decoder' : files('textdec.c','ass.c'), ++ 'text_encoder' : files('srtenc.c','ass_split.c'), ++ 'threads' : files('pthread.c','pthread_slice.c','pthread_frame.c'), ++ 'tiertexseqvideo_decoder' : files('tiertexseqv.c'), ++ 'tiff_decoder' : files('tiff.c','lzw.c','faxcompr.c','tiff_common.c'), ++ 'tiff_encoder' : files('tiffenc.c','rle.c','lzwenc.c'), ++ 'tmv_decoder' : files('tmv.c','cga_data.c'), ++ 'tpeldsp' : files('tpeldsp.c'), ++ 'trace_headers_bsf' : files('trace_headers_bsf.c'), ++ 'truehd_core_bsf' : files('truehd_core_bsf.c','mlp_parse.c','mlp.c'), ++ 'truehd_decoder' : files('mlpdec.c','mlpdsp.c'), ++ 'truehd_encoder' : files('mlpenc.c','mlp.c'), ++ 'truemotion1_decoder' : files('truemotion1.c'), ++ 'truemotion2rt_decoder' : files('truemotion2rt.c'), ++ 'truemotion2_decoder' : files('truemotion2.c'), ++ 'truespeech_decoder' : files('truespeech.c'), ++ 'tscc2_decoder' : files('tscc2.c'), ++ 'tscc_decoder' : files('tscc.c','msrledec.c'), ++ 'tta_decoder' : files('tta.c','ttadata.c','ttadsp.c'), ++ 'tta_encoder' : files('ttaenc.c','ttaencdsp.c','ttadata.c'), ++ 'ttml_encoder' : files('ttmlenc.c','ass_split.c'), ++ 'twinvq_decoder' : files('twinvqdec.c','twinvq.c'), ++ 'txd_decoder' : files('txd.c'), ++ 'ulti_decoder' : files('ulti.c'), ++ 'utvideo_decoder' : files('utvideodec.c','utvideodsp.c'), ++ 'utvideo_encoder' : files('utvideoenc.c'), ++ 'v210x_decoder' : files('v210x.c'), ++ 'v210_decoder' : files('v210dec.c'), ++ 'v210_encoder' : files('v210enc.c'), ++ 'v308_decoder' : files('v308dec.c'), ++ 'v308_encoder' : files('v308enc.c'), ++ 'v408_decoder' : files('v408dec.c'), ++ 'v408_encoder' : files('v408enc.c'), ++ 'v410_decoder' : files('v410dec.c'), ++ 'v410_encoder' : files('v410enc.c'), ++ 'v4l2_m2m' : files('v4l2_m2m.c','v4l2_context.c','v4l2_buffers.c','v4l2_fmt.c'), ++ 'vaapi' : files('vaapi_decode.c'), ++ 'vaapi_encode' : files('vaapi_encode.c'), ++ 'vble_decoder' : files('vble.c'), ++ 'vbn_decoder' : files('vbndec.c'), ++ 'vbn_encoder' : files('vbnenc.c'), ++ 'vb_decoder' : files('vb.c'), ++ 'vc1dsp' : files('vc1dsp.c'), ++ 'vc1_cuvid_decoder' : files('cuviddec.c'), ++ 'vc1_d3d11va_hwaccel' : files('dxva2_vc1.c'), ++ 'vc1_decoder' : files('vc1dec.c','vc1_block.c','vc1_loopfilter.c','vc1_mc.c','vc1_pred.c','vc1.c','vc1data.c','msmpeg4_vc1_data.c','wmv2data.c'), ++ 'vc1_dxva2_hwaccel' : files('dxva2_vc1.c'), ++ 'vc1_mmal_decoder' : files('mmaldec.c'), ++ 'vc1_nvdec_hwaccel' : files('nvdec_vc1.c'), ++ 'vc1_parser' : files('vc1_parser.c','vc1.c','vc1data.c','wmv2data.c'), ++ 'vc1_qsv_decoder' : files('qsvdec.c'), ++ 'vc1_qsv_hwaccel' : files('qsvdec.c'), ++ 'vc1_v4l2m2m_decoder' : files('v4l2_m2m_dec.c'), ++ 'vc1_vaapi_hwaccel' : files('vaapi_vc1.c'), ++ 'vc1_vdpau_hwaccel' : files('vdpau_vc1.c'), ++ 'vc2_encoder' : files('vc2enc.c','vc2enc_dwt.c','diractab.c'), ++ 'vcr1_decoder' : files('vcr1.c'), ++ 'vdpau' : files('vdpau.c'), ++ 'videodsp' : files('videodsp.c'), ++ 'videotoolbox' : files('videotoolbox.c'), ++ 'vmdaudio_decoder' : files('vmdaudio.c'), ++ 'vmdvideo_decoder' : files('vmdvideo.c'), ++ 'vmnc_decoder' : files('vmnc.c'), ++ 'vnull_decoder' : files('null.c'), ++ 'vnull_encoder' : files('null.c'), ++ 'vorbis_decoder' : files('vorbisdec.c','vorbisdsp.c','vorbis.c','vorbis_data.c'), ++ 'vorbis_encoder' : files('vorbisenc.c','vorbis.c','vorbis_data.c'), ++ 'vp3dsp' : files('vp3dsp.c'), ++ 'vp3_decoder' : files('vp3.c','jpegquanttables.c'), ++ 'vp3_parser' : files('vp3_parser.c'), ++ 'vp56dsp' : files('vp56dsp.c'), ++ 'vp5_decoder' : files('vp5.c','vp56.c','vp56data.c','vpx_rac.c'), ++ 'vp6_decoder' : files('vp6.c','vp56.c','vp56data.c','vp6dsp.c','vpx_rac.c'), ++ 'vp7_decoder' : files('vp8.c','vpx_rac.c'), ++ 'vp8dsp' : files('vp8dsp.c'), ++ 'vp8_cuvid_decoder' : files('cuviddec.c'), ++ 'vp8_decoder' : files('vp8.c','vpx_rac.c'), ++ 'vp8_mediacodec_decoder' : files('mediacodecdec.c'), ++ 'vp8_nvdec_hwaccel' : files('nvdec_vp8.c'), ++ 'vp8_parser' : files('vp8_parser.c'), ++ 'vp8_qsv_decoder' : files('qsvdec.c'), ++ 'vp8_qsv_hwaccel' : files('qsvdec.c'), ++ 'vp8_rkmpp_decoder' : files('rkmppdec.c'), ++ 'vp8_v4l2m2m_decoder' : files('v4l2_m2m_dec.c'), ++ 'vp8_v4l2m2m_encoder' : files('v4l2_m2m_enc.c'), ++ 'vp8_vaapi_encoder' : files('vaapi_encode_vp8.c'), ++ 'vp8_vaapi_hwaccel' : files('vaapi_vp8.c'), ++ 'vp9_cuvid_decoder' : files('cuviddec.c'), ++ 'vp9_d3d11va_hwaccel' : files('dxva2_vp9.c'), ++ 'vp9_decoder' : files('vp9.c','vp9data.c','vp9dsp.c','vp9lpf.c','vp9recon.c','vp9block.c','vp9prob.c','vp9mvs.c','vpx_rac.c','vp9dsp_8bpp.c','vp9dsp_10bpp.c','vp9dsp_12bpp.c'), ++ 'vp9_dxva2_hwaccel' : files('dxva2_vp9.c'), ++ 'vp9_mediacodec_decoder' : files('mediacodecdec.c'), ++ 'vp9_metadata_bsf' : files('vp9_metadata_bsf.c'), ++ 'vp9_nvdec_hwaccel' : files('nvdec_vp9.c'), ++ 'vp9_parser' : files('vp9_parser.c'), ++ 'vp9_qsv_encoder' : files('qsvenc_vp9.c'), ++ 'vp9_raw_reorder_bsf' : files('vp9_raw_reorder_bsf.c'), ++ 'vp9_rkmpp_decoder' : files('rkmppdec.c'), ++ 'vp9_superframe_bsf' : files('vp9_superframe_bsf.c'), ++ 'vp9_superframe_split_bsf' : files('vp9_superframe_split_bsf.c'), ++ 'vp9_v4l2m2m_decoder' : files('v4l2_m2m_dec.c'), ++ 'vp9_vaapi_encoder' : files('vaapi_encode_vp9.c'), ++ 'vp9_vaapi_hwaccel' : files('vaapi_vp9.c'), ++ 'vp9_vdpau_hwaccel' : files('vdpau_vp9.c'), ++ 'vp9_videotoolbox_hwaccel' : files('videotoolbox_vp9.c'), ++ 'vplayer_decoder' : files('textdec.c','ass.c'), ++ 'vqa_decoder' : files('vqavideo.c'), ++ 'vqc_decoder' : files('vqcdec.c'), ++ 'wady_dpcm_decoder' : files('dpcm.c'), ++ 'wavarc_decoder' : files('wavarc.c'), ++ 'wavpack_decoder' : files('wavpack.c','wavpackdata.c','dsd.c'), ++ 'wavpack_encoder' : files('wavpackdata.c','wavpackenc.c'), ++ 'wbmp_decoder' : files('wbmpdec.c'), ++ 'wbmp_encoder' : files('wbmpenc.c'), ++ 'wcmv_decoder' : files('wcmv.c'), ++ 'webp_decoder' : files('webp.c'), ++ 'webp_parser' : files('webp_parser.c'), ++ 'webvtt_decoder' : files('webvttdec.c','ass.c'), ++ 'webvtt_encoder' : files('webvttenc.c','ass_split.c'), ++ 'wmalossless_decoder' : files('wmalosslessdec.c','wma_common.c'), ++ 'wmapro_decoder' : files('wmaprodec.c','wma.c','wma_common.c'), ++ 'wmav1_decoder' : files('wmadec.c','wma.c','wma_common.c','aactab.c'), ++ 'wmav1_encoder' : files('wmaenc.c','wma.c','wma_common.c','aactab.c'), ++ 'wmav2_decoder' : files('wmadec.c','wma.c','wma_common.c','aactab.c'), ++ 'wmav2_encoder' : files('wmaenc.c','wma.c','wma_common.c','aactab.c'), ++ 'wmavoice_decoder' : files('wmavoice.c','celp_filters.c','acelp_vectors.c','acelp_filters.c'), ++ 'wma_freqs' : files('wma_freqs.c'), ++ 'wmv2dsp' : files('wmv2dsp.c'), ++ 'wmv2_decoder' : files('wmv2dec.c','wmv2.c','wmv2data.c'), ++ 'wmv2_encoder' : files('wmv2enc.c','wmv2.c','wmv2data.c'), ++ 'wnv1_decoder' : files('wnv1.c'), ++ 'wrapped_avframe_decoder' : files('wrapped_avframe.c'), ++ 'wrapped_avframe_encoder' : files('wrapped_avframe.c'), ++ 'ws_snd1_decoder' : files('ws-snd1.c'), ++ 'xan_dpcm_decoder' : files('dpcm.c'), ++ 'xan_wc3_decoder' : files('xan.c'), ++ 'xan_wc4_decoder' : files('xxan.c'), ++ 'xbin_decoder' : files('bintext.c','cga_data.c'), ++ 'xbm_decoder' : files('xbmdec.c'), ++ 'xbm_encoder' : files('xbmenc.c'), ++ 'xbm_parser' : files('xbm_parser.c'), ++ 'xface_decoder' : files('xfacedec.c','xface.c'), ++ 'xface_encoder' : files('xfaceenc.c','xface.c'), ++ 'xl_decoder' : files('xl.c'), ++ 'xma1_decoder' : files('wmaprodec.c','wma.c','wma_common.c'), ++ 'xma2_decoder' : files('wmaprodec.c','wma.c','wma_common.c'), ++ 'xma_parser' : files('xma_parser.c'), ++ 'xpm_decoder' : files('xpmdec.c'), ++ 'xsub_decoder' : files('xsubdec.c'), ++ 'xsub_encoder' : files('xsubenc.c'), ++ 'xwd_decoder' : files('xwddec.c'), ++ 'xwd_encoder' : files('xwdenc.c'), ++ 'xwd_parser' : files('xwd_parser.c'), ++ 'y41p_decoder' : files('y41pdec.c'), ++ 'y41p_encoder' : files('y41penc.c'), ++ 'ylc_decoder' : files('ylc.c'), ++ 'yop_decoder' : files('yop.c'), ++ 'yuv4_decoder' : files('yuv4dec.c'), ++ 'yuv4_encoder' : files('yuv4enc.c'), ++ 'zero12v_decoder' : files('012v.c'), ++ 'zerocodec_decoder' : files('zerocodec.c'), ++ 'zlib_decoder' : files('lcldec.c'), ++ 'zlib_encoder' : files('lclenc.c'), ++ 'zmbv_decoder' : files('zmbv.c'), ++ 'zmbv_encoder' : files('zmbvenc.c'), ++} ++ ++libavcodec_x86asm_optional_sources = { ++} ++ ++libavcodec_armv5te_optional_sources = { ++} ++ ++libavcodec_armv6_optional_sources = { ++} ++ ++libavcodec_armv8_optional_sources = { ++} ++ ++libavcodec_neon_optional_sources = { ++} ++ ++libavcodec_vfp_optional_sources = { ++} ++ ++libavcodec_mmx_optional_sources = { ++} ++ ++libavcodec_shlib_sources = files( ++ 'log2_tab.c', ++ 'reverse.c', ++) ++ ++libavcodec_shlib_optional_sources = { ++} ++ ++libavcodec_slib_optional_sources = { ++} ++ ++libavcodec_tests = [ ++ ['avcodec', files('tests/avcodec.c')], ++ ['avpacket', files('tests/avpacket.c')], ++ ['bitstream_be', files('tests/bitstream_be.c')], ++ ['bitstream_le', files('tests/bitstream_le.c')], ++ ['celp_math', files('tests/celp_math.c')], ++ ['codec_desc', files('tests/codec_desc.c')], ++ ['htmlsubtitles', files('tests/htmlsubtitles.c')], ++ ['jpeg2000dwt', files('tests/jpeg2000dwt.c')], ++ ['mathops', files('tests/mathops.c')], ++] ++ ++libavcodec_optional_tests = { ++ 'cabac' : [ ++ ['cabac', files('tests/cabac.c')], ++ ], ++ 'dct' : [ ++ ['avfft', files('tests/avfft.c')], ++ ], ++ 'fft' : [ ++ ['fft', files('tests/fft.c')], ++ ['fft-fixed32', files('tests/fft-fixed32.c')], ++ ], ++ 'golomb' : [ ++ ['golomb', files('tests/golomb.c')], ++ ], ++ 'h264_metadata_bsf' : [ ++ ['h264_levels', files('tests/h264_levels.c')], ++ ], ++ 'hevc_metadata_bsf' : [ ++ ['h265_levels', files('tests/h265_levels.c')], ++ ], ++ 'idctdsp' : [ ++ ['dct', files('tests/dct.c')], ++ ], ++ 'iirfilter' : [ ++ ['iirfilter', files('tests/iirfilter.c')], ++ ], ++ 'mjpeg_encoder' : [ ++ ['mjpegenc_huffman', files('tests/mjpegenc_huffman.c')], ++ ], ++ 'mmx' : [ ++ ['motion', files('tests/motion.c')], ++ ], ++ 'mpegvideo' : [ ++ ['mpeg12framerate', files('tests/mpeg12framerate.c')], ++ ], ++ 'rangecoder' : [ ++ ['rangecoder', files('tests/rangecoder.c')], ++ ], ++ 'snow_encoder' : [ ++ ['snowenc', files('tests/snowenc.c')], ++ ], ++} ++ ++#### --- END GENERATED --- #### ++ ++kwargs = {'prefix': '#include "libavcodec/version.h"'} + get_version_define_kwargs ++ ++libavcodec_majorver = cc.get_define('LIBAVCODEC_VERSION_MAJOR', kwargs: kwargs) ++minorver = cc.get_define('LIBAVCODEC_VERSION_MINOR', kwargs: kwargs) ++microver = cc.get_define('LIBAVCODEC_VERSION_MICRO', kwargs: kwargs) ++ ++libavcodec_version = f'@libavcodec_majorver@.@minorver@.@microver@' ++ ++# Version file ++ver_conf = configuration_data() ++ver_conf.set('majorver', libavcodec_majorver) ++ver_conf.set('minorver', minorver) ++ver_conf.set('microver', microver) ++ ++install_headers(libavcodec_headers, subdir: 'libavcodec') ++ ++configure_file( ++ input: 'libavcodec.v.in', ++ output: 'libavcodec.ver', ++ configuration: ver_conf, ++) ++ ++subdir('aarch64') ++subdir('arm') ++subdir('x86') +diff --git a/libavcodec/neon/meson.build b/libavcodec/neon/meson.build +new file mode 100644 +index 0000000000..e5e5dc9a50 +--- /dev/null ++++ b/libavcodec/neon/meson.build +@@ -0,0 +1,33 @@ ++libavcodec_neon_optional_sources = { ++ 'mpegvideo' : files('mpegvideo.c'), ++} ++ ++libavcodec_neon_x86asm_optional_sources = { ++} ++ ++libavcodec_neon_armv5te_optional_sources = { ++} ++ ++libavcodec_neon_armv6_optional_sources = { ++} ++ ++libavcodec_neon_armv8_optional_sources = { ++} ++ ++libavcodec_neon_neon_optional_sources = { ++} ++ ++libavcodec_neon_vfp_optional_sources = { ++} ++ ++libavcodec_neon_mmx_optional_sources = { ++} ++ ++libavcodec_neon_shlib_optional_sources = { ++} ++ ++libavcodec_neon_slib_optional_sources = { ++} ++ ++libavcodec_neon_optional_tests = { ++} +diff --git a/libavcodec/x86/meson.build b/libavcodec/x86/meson.build +new file mode 100644 +index 0000000000..4446fef534 +--- /dev/null ++++ b/libavcodec/x86/meson.build +@@ -0,0 +1,207 @@ ++#### --- GENERATED --- #### ++ ++libavcodec_x86_sources = files( ++ 'constants.c', ++) ++ ++libavcodec_x86_optional_sources = { ++ 'aac_decoder' : files('aacpsdsp_init.c','sbrdsp_init.c'), ++ 'aac_encoder' : files('aacencdsp_init.c'), ++ 'ac3dsp' : files('ac3dsp_init.c'), ++ 'adpcm_g722_decoder' : files('g722dsp_init.c'), ++ 'adpcm_g722_encoder' : files('g722dsp_init.c'), ++ 'alac_decoder' : files('alacdsp_init.c'), ++ 'apng_decoder' : files('pngdsp_init.c'), ++ 'audiodsp' : files('audiodsp_init.c'), ++ 'blockdsp' : files('blockdsp_init.c'), ++ 'bswapdsp' : files('bswapdsp_init.c'), ++ 'cavs_decoder' : files('cavsdsp.c'), ++ 'cfhd_decoder' : files('cfhddsp_init.c'), ++ 'cfhd_encoder' : files('cfhdencdsp_init.c'), ++ 'dca_decoder' : files('dcadsp_init.c','synth_filter_init.c'), ++ 'dct' : files('dct_init.c'), ++ 'dirac_decoder' : files('diracdsp_init.c','dirac_dwt_init.c'), ++ 'dnxhd_encoder' : files('dnxhdenc_init.c'), ++ 'exr_decoder' : files('exrdsp_init.c'), ++ 'fdctdsp' : files('fdctdsp_init.c'), ++ 'fft' : files('fft_init.c'), ++ 'flac_decoder' : files('flacdsp_init.c'), ++ 'flac_encoder' : files('flacencdsp_init.c'), ++ 'fmtconvert' : files('fmtconvert_init.c'), ++ 'h263dsp' : files('h263dsp_init.c'), ++ 'h264chroma' : files('h264chroma_init.c'), ++ 'h264dsp' : files('h264dsp_init.c'), ++ 'h264pred' : files('h264_intrapred_init.c'), ++ 'h264qpel' : files('h264_qpel.c'), ++ 'hevc_decoder' : files('hevcdsp_init.c'), ++ 'hpeldsp' : files('hpeldsp_init.c'), ++ 'huffyuvdsp' : files('huffyuvdsp_init.c'), ++ 'huffyuvencdsp' : files('huffyuvencdsp_init.c'), ++ 'idctdsp' : files('idctdsp_init.c'), ++ 'jpeg2000_decoder' : files('jpeg2000dsp_init.c'), ++ 'llauddsp' : files('lossless_audiodsp_init.c'), ++ 'llviddsp' : files('lossless_videodsp_init.c'), ++ 'llvidencdsp' : files('lossless_videoencdsp_init.c'), ++ 'lpc' : files('lpc_init.c'), ++ 'lscr_decoder' : files('pngdsp_init.c'), ++ 'me_cmp' : files('me_cmp_init.c'), ++ 'mlp_decoder' : files('mlpdsp_init.c'), ++ 'mpeg4_decoder' : files('mpeg4videodsp.c','xvididct_init.c'), ++ 'mpegaudiodsp' : files('mpegaudiodsp.c'), ++ 'mpegvideo' : files('mpegvideo.c'), ++ 'mpegvideoenc' : files('mpegvideoenc.c','mpegvideoencdsp_init.c'), ++ 'opus_decoder' : files('opusdsp_init.c'), ++ 'opus_encoder' : files('celt_pvq_init.c'), ++ 'pixblockdsp' : files('pixblockdsp_init.c'), ++ 'png_decoder' : files('pngdsp_init.c'), ++ 'prores_decoder' : files('proresdsp_init.c'), ++ 'prores_lgpl_decoder' : files('proresdsp_init.c'), ++ 'qpeldsp' : files('qpeldsp_init.c'), ++ 'rv34dsp' : files('rv34dsp_init.c'), ++ 'rv40_decoder' : files('rv40dsp_init.c'), ++ 'sbc_encoder' : files('sbcdsp_init.c'), ++ 'svq1_encoder' : files('svq1enc_init.c'), ++ 'tak_decoder' : files('takdsp_init.c'), ++ 'truehd_decoder' : files('mlpdsp_init.c'), ++ 'tta_decoder' : files('ttadsp_init.c'), ++ 'tta_encoder' : files('ttaencdsp_init.c'), ++ 'utvideo_decoder' : files('utvideodsp_init.c'), ++ 'v210_decoder' : files('v210-init.c'), ++ 'v210_encoder' : files('v210enc_init.c'), ++ 'vc1dsp' : files('vc1dsp_init.c'), ++ 'videodsp' : files('videodsp_init.c'), ++ 'vorbis_decoder' : files('vorbisdsp_init.c'), ++ 'vp3dsp' : files('vp3dsp_init.c'), ++ 'vp3_decoder' : files('hpeldsp_vp3_init.c'), ++ 'vp6_decoder' : files('vp6dsp_init.c'), ++ 'vp8dsp' : files('vp8dsp_init.c'), ++ 'vp9_decoder' : files('vp9dsp_init.c','vp9dsp_init_10bpp.c','vp9dsp_init_12bpp.c','vp9dsp_init_16bpp.c'), ++ 'webp_decoder' : files('vp8dsp_init.c'), ++ 'xmm_clobber_test' : files('w64xmmtest.c'), ++} ++ ++libavcodec_x86_x86asm_optional_sources = { ++ 'aac_decoder' : files('aacpsdsp.asm','sbrdsp.asm'), ++ 'aac_encoder' : files('aacencdsp.asm'), ++ 'ac3dsp' : files('ac3dsp.asm','ac3dsp_downmix.asm'), ++ 'adpcm_g722_decoder' : files('g722dsp.asm'), ++ 'adpcm_g722_encoder' : files('g722dsp.asm'), ++ 'alac_decoder' : files('alacdsp.asm'), ++ 'apng_decoder' : files('pngdsp.asm'), ++ 'audiodsp' : files('audiodsp.asm'), ++ 'blockdsp' : files('blockdsp.asm'), ++ 'bswapdsp' : files('bswapdsp.asm'), ++ 'cavs_decoder' : files('cavsidct.asm'), ++ 'cfhd_decoder' : files('cfhddsp.asm'), ++ 'cfhd_encoder' : [], # MANUAL ++ 'dca_decoder' : files('dcadsp.asm','synth_filter.asm'), ++ 'dct' : files('dct32.asm'), ++ 'dirac_decoder' : files('diracdsp.asm','dirac_dwt.asm'), ++ 'dnxhd_encoder' : files('dnxhdenc.asm'), ++ 'exr_decoder' : files('exrdsp.asm'), ++ 'fft' : files('fft.asm'), ++ 'flac_decoder' : files('flacdsp.asm'), ++ 'flac_encoder' : files('flac_dsp_gpl.asm'), ++ 'fmtconvert' : files('fmtconvert.asm'), ++ 'h263dsp' : files('h263_loopfilter.asm'), ++ 'h264chroma' : files('h264_chromamc.asm','h264_chromamc_10bit.asm'), ++ 'h264dsp' : files('h264_deblock.asm','h264_deblock_10bit.asm','h264_idct.asm','h264_idct_10bit.asm','h264_weight.asm','h264_weight_10bit.asm'), ++ 'h264pred' : files('h264_intrapred.asm','h264_intrapred_10bit.asm'), ++ 'h264qpel' : files('h264_qpel_8bit.asm','h264_qpel_10bit.asm','fpel.asm','qpel.asm'), ++ 'hevc_decoder' : files('hevc_add_res.asm','hevc_deblock.asm','hevc_idct.asm','hevc_mc.asm','hevc_sao.asm','hevc_sao_10bit.asm'), ++ 'hpeldsp' : files('fpel.asm','hpeldsp.asm'), ++ 'huffyuvdsp' : files('huffyuvdsp.asm'), ++ 'huffyuvencdsp' : files('huffyuvencdsp.asm'), ++ 'idctdsp' : files('idctdsp.asm'), # MANUAL ++ 'jpeg2000_decoder' : files('jpeg2000dsp.asm'), ++ 'llauddsp' : files('lossless_audiodsp.asm'), ++ 'llviddsp' : files('lossless_videodsp.asm'), ++ 'llvidencdsp' : files('lossless_videoencdsp.asm'), ++ 'lpc' : files('lpc.asm'), ++ 'lscr_decoder' : files('pngdsp.asm'), ++ 'me_cmp' : files('me_cmp.asm'), ++ 'mlp_decoder' : [], # MANUAL ++ 'mpeg4_decoder' : files('xvididct.asm'), ++ 'mpegaudiodsp' : files('imdct36.asm'), ++ 'mpegvideoenc' : files('mpegvideoencdsp.asm'), ++ 'opus_decoder' : files('opusdsp.asm'), ++ 'opus_encoder' : files('celt_pvq_search.asm'), ++ 'pixblockdsp' : files('pixblockdsp.asm'), ++ 'png_decoder' : files('pngdsp.asm'), ++ 'prores_decoder' : [], # MANUAL ++ 'prores_lgpl_decoder' : [], # MANUAL ++ 'qpeldsp' : files('qpeldsp.asm','fpel.asm','qpel.asm'), ++ 'rv34dsp' : files('rv34dsp.asm'), ++ 'rv40_decoder' : files('rv40dsp.asm'), ++ 'sbc_encoder' : files('sbcdsp.asm'), ++ 'svq1_encoder' : files('svq1enc.asm'), ++ 'tak_decoder' : files('takdsp.asm'), ++ 'truehd_decoder' : [], # MANUAL ++ 'tta_decoder' : files('ttadsp.asm'), ++ 'tta_encoder' : files('ttaencdsp.asm'), ++ 'utvideo_decoder' : files('utvideodsp.asm'), ++ 'v210_decoder' : files('v210.asm'), ++ 'v210_encoder' : files('v210enc.asm'), ++ 'vc1dsp' : files('vc1dsp_loopfilter.asm','vc1dsp_mc.asm'), ++ 'videodsp' : files('videodsp.asm'), ++ 'vorbis_decoder' : files('vorbisdsp.asm'), ++ 'vp3dsp' : files('vp3dsp.asm'), ++ 'vp3_decoder' : files('hpeldsp_vp3.asm'), ++ 'vp6_decoder' : files('vp6dsp.asm'), ++ 'vp8dsp' : files('vp8dsp.asm','vp8dsp_loopfilter.asm'), ++ 'vp9_decoder' : files('vp9intrapred.asm','vp9intrapred_16bpp.asm','vp9itxfm.asm','vp9itxfm_16bpp.asm','vp9lpf.asm','vp9lpf_16bpp.asm','vp9mc.asm','vp9mc_16bpp.asm'), ++ 'webp_decoder' : files('vp8dsp.asm'), ++} ++ ++libavcodec_x86_armv5te_optional_sources = { ++} ++ ++libavcodec_x86_armv6_optional_sources = { ++} ++ ++libavcodec_x86_armv8_optional_sources = { ++} ++ ++libavcodec_x86_neon_optional_sources = { ++} ++ ++libavcodec_x86_vfp_optional_sources = { ++} ++ ++libavcodec_x86_mmx_optional_sources = { ++ 'fdctdsp' : files('fdct.c'), ++ 'snow_decoder' : files('snowdsp.c'), ++ 'snow_encoder' : files('snowdsp.c'), ++ 'vc1dsp' : files('vc1dsp_mmx.c'), ++} ++ ++libavcodec_x86_shlib_optional_sources = { ++} ++ ++libavcodec_x86_slib_optional_sources = { ++} ++ ++libavcodec_x86_optional_tests = { ++} ++ ++#### --- END GENERATED --- #### ++ ++# This file results in empty codegen and empty PDB generation otherwise. ++# https://bugzilla.nasm.us/show_bug.cgi?id=3392738 ++# https://developercommunity.visualstudio.com/t/MSVC-Hangs-when-compiling-ffmpeg-When-l/10233953 ++if conf.get('x86_32', 0) == 1 ++ libavcodec_x86_x86asm_optional_sources += { ++ 'idctdsp': libavcodec_x86_x86asm_optional_sources ['idctdsp'] + files('simple_idct.asm') ++ } ++elif conf.get('x86_64', 0) == 1 ++ # Alternatively, ++ # panic: ../libavcodec/x86/simple_idct10.asm: assertion cv8_state.source_files != NULL failed at output/codeview.c:512 ++ libavcodec_x86_x86asm_optional_sources += { ++ 'idctdsp': libavcodec_x86_x86asm_optional_sources ['idctdsp'] + files('simple_idct10.asm'), ++ 'mlp_decoder': libavcodec_x86_x86asm_optional_sources ['mlp_decoder'] + files('mlpdsp.asm'), ++ 'cfhd_encoder': libavcodec_x86_x86asm_optional_sources ['cfhd_encoder'] + files('cfhdencdsp.asm'), ++ 'prores_decoder': libavcodec_x86_x86asm_optional_sources ['prores_decoder'] + files('proresdsp.asm'), ++ 'prores_lgpl_decoder': libavcodec_x86_x86asm_optional_sources ['prores_lgpl_decoder'] + files('proresdsp.asm'), ++ 'truehd_decoder': libavcodec_x86_x86asm_optional_sources ['truehd_decoder'] + files('mlpdsp.asm'), ++ } ++endif +diff --git a/libavdevice/libavdevice.v.in b/libavdevice/libavdevice.v.in +new file mode 100644 +index 0000000000..f4a6a829ab +--- /dev/null ++++ b/libavdevice/libavdevice.v.in +@@ -0,0 +1,7 @@ ++LIBAVDEVICE_@majorver@ { ++ global: ++ avdevice_*; ++ av_*; ++ local: ++ *; ++}; +diff --git a/libavdevice/meson.build b/libavdevice/meson.build +new file mode 100644 +index 0000000000..e50ccf331d +--- /dev/null ++++ b/libavdevice/meson.build +@@ -0,0 +1,115 @@ ++kwargs = {'prefix': '#include "libavdevice/version.h"'} + get_version_define_kwargs ++ ++libavdevice_majorver = cc.get_define('LIBAVDEVICE_VERSION_MAJOR', kwargs: kwargs) ++minorver = cc.get_define('LIBAVDEVICE_VERSION_MINOR', kwargs: kwargs) ++microver = cc.get_define('LIBAVDEVICE_VERSION_MICRO', kwargs: kwargs) ++ ++libavdevice_version = f'@libavdevice_majorver@.@minorver@.@microver@' ++ ++#### --- GENERATED --- #### ++ ++libavdevice_sources = files( ++ 'alldevices.c', ++ 'avdevice.c', ++ 'utils.c', ++ 'version.c', ++) ++ ++libavdevice_headers = files( ++ 'avdevice.h', ++ 'version.h', ++ 'version_major.h', ++) ++ ++libavdevice_optional_sources = { ++ 'alsa_indev' : files('alsa_dec.c','alsa.c','timefilter.c'), ++ 'alsa_outdev' : files('alsa_enc.c','alsa.c'), ++ 'android_camera_indev' : files('android_camera.c'), ++ 'audiotoolbox_outdev' : files('audiotoolbox.m'), ++ 'avfoundation_indev' : files('avfoundation.m'), ++ 'bktr_indev' : files('bktr.c'), ++ 'caca_outdev' : files('caca.c'), ++ 'decklink_indev' : files('decklink_dec.cpp','decklink_dec_c.c','decklink_common.cpp'), ++ 'decklink_outdev' : files('decklink_enc.cpp','decklink_enc_c.c','decklink_common.cpp'), ++ 'dshow_indev' : files('dshow_crossbar.c','dshow.c','dshow_enummediatypes.c','dshow_enumpins.c','dshow_filter.c','dshow_pin.c','dshow_common.c'), ++ 'fbdev_indev' : files('fbdev_dec.c','fbdev_common.c'), ++ 'fbdev_outdev' : files('fbdev_enc.c','fbdev_common.c'), ++ 'gdigrab_indev' : files('gdigrab.c'), ++ 'iec61883_indev' : files('iec61883.c'), ++ 'jack_indev' : files('jack.c','timefilter.c'), ++ 'kmsgrab_indev' : files('kmsgrab.c'), ++ 'lavfi_indev' : files('lavfi.c'), ++ 'libcdio_indev' : files('libcdio.c'), ++ 'libc_msvcrt' : files('file_open.c'), ++ 'libdc1394_indev' : files('libdc1394.c'), ++ 'openal_indev' : files('openal-dec.c'), ++ 'opengl_outdev' : files('opengl_enc.c'), ++ 'oss_indev' : files('oss_dec.c','oss.c'), ++ 'oss_outdev' : files('oss_enc.c','oss.c'), ++ 'pulse_indev' : files('pulse_audio_dec.c','pulse_audio_common.c','timefilter.c'), ++ 'pulse_outdev' : files('pulse_audio_enc.c','pulse_audio_common.c'), ++ 'sdl2_outdev' : files('sdl2.c'), ++ 'sndio_indev' : files('sndio_dec.c','sndio.c'), ++ 'sndio_outdev' : files('sndio_enc.c','sndio.c'), ++ 'v4l2_indev' : files('v4l2.c','v4l2-common.c','timefilter.c'), ++ 'v4l2_outdev' : files('v4l2enc.c','v4l2-common.c'), ++ 'vfwcap_indev' : files('vfwcap.c'), ++ 'xcbgrab_indev' : files('xcbgrab.c'), ++ 'xv_outdev' : files('xv.c'), ++} ++ ++libavdevice_x86asm_optional_sources = { ++} ++ ++libavdevice_armv5te_optional_sources = { ++} ++ ++libavdevice_armv6_optional_sources = { ++} ++ ++libavdevice_armv8_optional_sources = { ++} ++ ++libavdevice_neon_optional_sources = { ++} ++ ++libavdevice_vfp_optional_sources = { ++} ++ ++libavdevice_mmx_optional_sources = { ++} ++ ++libavdevice_shlib_optional_sources = { ++ 'decklink_indev' : files('reverse.c'), ++} ++ ++libavdevice_slib_optional_sources = { ++} ++ ++libavdevice_optional_tests = { ++ 'jack_indev' : [ ++ ['timefilter', files('tests/timefilter.c')], ++ ], ++} ++ ++languages_map += { ++ 'audiotoolbox_outdev': ['objc'], ++ 'avfoundation_indev': ['objc'], ++ 'decklink_outdev': ['cpp'], ++ 'decklink_indev': ['cpp'], ++} ++#### --- END GENERATED --- #### ++ ++# Version file ++ver_conf = configuration_data() ++ver_conf.set('majorver', libavdevice_majorver) ++ver_conf.set('minorver', minorver) ++ver_conf.set('microver', microver) ++ ++install_headers(libavdevice_headers, subdir: 'libavdevice') ++ ++configure_file( ++ input: 'libavdevice.v.in', ++ output: 'libavdevice.ver', ++ configuration: ver_conf, ++) +diff --git a/libavfilter/aarch64/meson.build b/libavfilter/aarch64/meson.build +new file mode 100644 +index 0000000000..d222167519 +--- /dev/null ++++ b/libavfilter/aarch64/meson.build +@@ -0,0 +1,34 @@ ++libavfilter_aarch64_optional_sources = { ++ 'nlmeans_filter' : files('vf_nlmeans_init.c'), ++} ++ ++libavfilter_aarch64_x86asm_optional_sources = { ++} ++ ++libavfilter_aarch64_armv5te_optional_sources = { ++} ++ ++libavfilter_aarch64_armv6_optional_sources = { ++} ++ ++libavfilter_aarch64_armv8_optional_sources = { ++} ++ ++libavfilter_aarch64_neon_optional_sources = { ++ 'nlmeans_filter' : files('vf_nlmeans_neon.S'), ++} ++ ++libavfilter_aarch64_vfp_optional_sources = { ++} ++ ++libavfilter_aarch64_mmx_optional_sources = { ++} ++ ++libavfilter_aarch64_shlib_optional_sources = { ++} ++ ++libavfilter_aarch64_slib_optional_sources = { ++} ++ ++libavfilter_aarch64_optional_tests = { ++} +diff --git a/libavfilter/dnn/meson.build b/libavfilter/dnn/meson.build +new file mode 100644 +index 0000000000..2bb85e734d +--- /dev/null ++++ b/libavfilter/dnn/meson.build +@@ -0,0 +1,35 @@ ++libavfilter_dnn_optional_sources = { ++ 'dnn' : files('dnn_interface.c','dnn_io_proc.c','queue.c','safe_queue.c','dnn_backend_common.c','dnn_backend_native.c','dnn_backend_native_layers.c','dnn_backend_native_layer_avgpool.c','dnn_backend_native_layer_dense.c','dnn_backend_native_layer_pad.c','dnn_backend_native_layer_conv2d.c','dnn_backend_native_layer_depth2space.c','dnn_backend_native_layer_maximum.c','dnn_backend_native_layer_mathbinary.c','dnn_backend_native_layer_mathunary.c'), ++ 'libopenvino' : files('dnn_backend_openvino.c'), ++ 'libtensorflow' : files('dnn_backend_tf.c'), ++} ++ ++libavfilter_dnn_x86asm_optional_sources = { ++} ++ ++libavfilter_dnn_armv5te_optional_sources = { ++} ++ ++libavfilter_dnn_armv6_optional_sources = { ++} ++ ++libavfilter_dnn_armv8_optional_sources = { ++} ++ ++libavfilter_dnn_neon_optional_sources = { ++} ++ ++libavfilter_dnn_vfp_optional_sources = { ++} ++ ++libavfilter_dnn_mmx_optional_sources = { ++} ++ ++libavfilter_dnn_shlib_optional_sources = { ++} ++ ++libavfilter_dnn_slib_optional_sources = { ++} ++ ++libavfilter_dnn_optional_tests = { ++} +diff --git a/libavfilter/libavfilter.v.in b/libavfilter/libavfilter.v.in +new file mode 100644 +index 0000000000..8665ee4bcb +--- /dev/null ++++ b/libavfilter/libavfilter.v.in +@@ -0,0 +1,7 @@ ++LIBAVFILTER_@majorver@ { ++ global: ++ avfilter_*; ++ av_*; ++ local: ++ *; ++}; +diff --git a/libavfilter/meson.build b/libavfilter/meson.build +new file mode 100644 +index 0000000000..3c87b00368 +--- /dev/null ++++ b/libavfilter/meson.build +@@ -0,0 +1,689 @@ ++kwargs = {'prefix': '#include "libavfilter/version.h"'} + get_version_define_kwargs ++ ++libavfilter_majorver = cc.get_define('LIBAVFILTER_VERSION_MAJOR', kwargs: kwargs) ++minorver = cc.get_define('LIBAVFILTER_VERSION_MINOR', kwargs: kwargs) ++microver = cc.get_define('LIBAVFILTER_VERSION_MICRO', kwargs: kwargs) ++ ++libavfilter_version = f'@libavfilter_majorver@.@minorver@.@microver@' ++ ++#### --- GENERATED --- #### ++ ++libavfilter_sources = files( ++ 'allfilters.c', ++ 'audio.c', ++ 'avfilter.c', ++ 'avfiltergraph.c', ++ 'buffersink.c', ++ 'buffersrc.c', ++ 'colorspace.c', ++ 'drawutils.c', ++ 'fifo.c', ++ 'formats.c', ++ 'framepool.c', ++ 'framequeue.c', ++ 'graphdump.c', ++ 'graphparser.c', ++ 'version.c', ++ 'video.c', ++) ++ ++libavfilter_headers = files( ++ 'avfilter.h', ++ 'buffersink.h', ++ 'buffersrc.h', ++ 'version.h', ++ 'version_major.h', ++) ++ ++libavfilter_optional_sources = { ++ 'a3dscope_filter' : files('avf_a3dscope.c'), ++ 'abench_filter' : files('f_bench.c'), ++ 'abitscope_filter' : files('avf_abitscope.c'), ++ 'acompressor_filter' : files('af_sidechaincompress.c'), ++ 'acontrast_filter' : files('af_acontrast.c'), ++ 'acopy_filter' : files('af_acopy.c'), ++ 'acrossfade_filter' : files('af_afade.c'), ++ 'acrossover_filter' : files('af_acrossover.c'), ++ 'acrusher_filter' : files('af_acrusher.c'), ++ 'acue_filter' : files('f_cue.c'), ++ 'addroi_filter' : files('vf_addroi.c'), ++ 'adeclick_filter' : files('af_adeclick.c'), ++ 'adeclip_filter' : files('af_adeclick.c'), ++ 'adecorrelate_filter' : files('af_adecorrelate.c'), ++ 'adelay_filter' : files('af_adelay.c'), ++ 'adenorm_filter' : files('af_adenorm.c'), ++ 'aderivative_filter' : files('af_aderivative.c'), ++ 'adrawgraph_filter' : files('f_drawgraph.c'), ++ 'adrc_filter' : files('af_adrc.c'), ++ 'adynamicequalizer_filter' : files('af_adynamicequalizer.c'), ++ 'adynamicsmooth_filter' : files('af_adynamicsmooth.c'), ++ 'aecho_filter' : files('af_aecho.c'), ++ 'aemphasis_filter' : files('af_aemphasis.c'), ++ 'aevalsrc_filter' : files('aeval.c'), ++ 'aeval_filter' : files('aeval.c'), ++ 'aexciter_filter' : files('af_aexciter.c'), ++ 'afade_filter' : files('af_afade.c'), ++ 'afdelaysrc_filter' : files('asrc_afdelaysrc.c'), ++ 'afftdn_filter' : files('af_afftdn.c'), ++ 'afftfilt_filter' : files('af_afftfilt.c'), ++ 'afirsrc_filter' : files('asrc_afirsrc.c'), ++ 'afir_filter' : files('af_afir.c'), ++ 'aformat_filter' : files('af_aformat.c'), ++ 'afreqshift_filter' : files('af_afreqshift.c'), ++ 'afwtdn_filter' : files('af_afwtdn.c'), ++ 'agate_filter' : files('af_agate.c'), ++ 'agraphmonitor_filter' : files('f_graphmonitor.c'), ++ 'ahistogram_filter' : files('avf_ahistogram.c'), ++ 'aiir_filter' : files('af_aiir.c'), ++ 'aintegral_filter' : files('af_aderivative.c'), ++ 'ainterleave_filter' : files('f_interleave.c'), ++ 'alatency_filter' : files('f_latency.c'), ++ 'alimiter_filter' : files('af_alimiter.c'), ++ 'allpass_filter' : files('af_biquads.c'), ++ 'allrgb_filter' : files('vsrc_testsrc.c'), ++ 'allyuv_filter' : files('vsrc_testsrc.c'), ++ 'aloop_filter' : files('f_loop.c'), ++ 'alphaextract_filter' : files('vf_extractplanes.c'), ++ 'alphamerge_filter' : files('vf_alphamerge.c','framesync.c'), ++ 'amerge_filter' : files('af_amerge.c'), ++ 'ametadata_filter' : files('f_metadata.c'), ++ 'amix_filter' : files('af_amix.c'), ++ 'amovie_filter' : files('src_movie.c'), ++ 'amplify_filter' : files('vf_amplify.c'), ++ 'amultiply_filter' : files('af_amultiply.c'), ++ 'anequalizer_filter' : files('af_anequalizer.c'), ++ 'anlmdn_filter' : files('af_anlmdn.c'), ++ 'anlmf_filter' : files('af_anlms.c'), ++ 'anlms_filter' : files('af_anlms.c'), ++ 'anoisesrc_filter' : files('asrc_anoisesrc.c'), ++ 'anullsink_filter' : files('asink_anullsink.c'), ++ 'anullsrc_filter' : files('asrc_anullsrc.c'), ++ 'anull_filter' : files('af_anull.c'), ++ 'apad_filter' : files('af_apad.c'), ++ 'aperms_filter' : files('f_perms.c'), ++ 'aphasemeter_filter' : files('avf_aphasemeter.c'), ++ 'aphaser_filter' : files('af_aphaser.c','generate_wave_table.c'), ++ 'aphaseshift_filter' : files('af_afreqshift.c'), ++ 'apsyclip_filter' : files('af_apsyclip.c'), ++ 'apulsator_filter' : files('af_apulsator.c'), ++ 'arealtime_filter' : files('f_realtime.c'), ++ 'aresample_filter' : files('af_aresample.c'), ++ 'areverse_filter' : files('f_reverse.c'), ++ 'arnndn_filter' : files('af_arnndn.c'), ++ 'asdr_filter' : files('af_asdr.c'), ++ 'asegment_filter' : files('f_segment.c'), ++ 'aselect_filter' : files('f_select.c'), ++ 'asendcmd_filter' : files('f_sendcmd.c'), ++ 'asetnsamples_filter' : files('af_asetnsamples.c'), ++ 'asetpts_filter' : files('setpts.c'), ++ 'asetrate_filter' : files('af_asetrate.c'), ++ 'asettb_filter' : files('settb.c'), ++ 'ashowinfo_filter' : files('af_ashowinfo.c'), ++ 'asidedata_filter' : files('f_sidedata.c'), ++ 'asoftclip_filter' : files('af_asoftclip.c'), ++ 'aspectralstats_filter' : files('af_aspectralstats.c'), ++ 'asplit_filter' : files('split.c'), ++ 'asr_filter' : files('af_asr.c'), ++ 'ass_filter' : files('vf_subtitles.c'), ++ 'astats_filter' : files('af_astats.c'), ++ 'astreamselect_filter' : files('f_streamselect.c','framesync.c'), ++ 'asubboost_filter' : files('af_asubboost.c'), ++ 'asubcut_filter' : files('af_asupercut.c'), ++ 'asupercut_filter' : files('af_asupercut.c'), ++ 'asuperpass_filter' : files('af_asupercut.c'), ++ 'asuperstop_filter' : files('af_asupercut.c'), ++ 'atadenoise_filter' : files('vf_atadenoise.c'), ++ 'atempo_filter' : files('af_atempo.c'), ++ 'atilt_filter' : files('af_atilt.c'), ++ 'atrim_filter' : files('trim.c'), ++ 'avectorscope_filter' : files('avf_avectorscope.c'), ++ 'avgblur_filter' : files('vf_avgblur.c'), ++ 'avgblur_opencl_filter' : files('vf_avgblur_opencl.c','opencl.c','opencl/avgblur.cl','boxblur.c'), ++ 'avgblur_vulkan_filter' : files('vf_avgblur_vulkan.c','vulkan.c','vulkan_filter.c'), ++ 'avsynctest_filter' : files('src_avsynctest.c'), ++ 'axcorrelate_filter' : files('af_axcorrelate.c'), ++ 'azmq_filter' : files('f_zmq.c'), ++ 'backgroundkey_filter' : files('vf_backgroundkey.c'), ++ 'bandpass_filter' : files('af_biquads.c'), ++ 'bandreject_filter' : files('af_biquads.c'), ++ 'bass_filter' : files('af_biquads.c'), ++ 'bbox_filter' : files('bbox.c','vf_bbox.c'), ++ 'bench_filter' : files('f_bench.c'), ++ # 'bilateral_cuda_filter' : files('vf_bilateral_cuda.c'), ++ 'bilateral_filter' : files('vf_bilateral.c'), ++ 'biquad_filter' : files('af_biquads.c'), ++ 'bitplanenoise_filter' : files('vf_bitplanenoise.c'), ++ 'blackdetect_filter' : files('vf_blackdetect.c'), ++ 'blackframe_filter' : files('vf_blackframe.c'), ++ 'blend_filter' : files('vf_blend.c','framesync.c'), ++ 'blend_vulkan_filter' : files('vf_blend_vulkan.c','framesync.c','vulkan.c','vulkan_filter.c'), ++ 'blockdetect_filter' : files('vf_blockdetect.c'), ++ 'blurdetect_filter' : files('vf_blurdetect.c','edge_common.c'), ++ 'bm3d_filter' : files('vf_bm3d.c','framesync.c'), ++ 'boxblur_filter' : files('vf_boxblur.c','boxblur.c'), ++ 'boxblur_opencl_filter' : files('vf_avgblur_opencl.c','opencl.c','opencl/avgblur.cl','boxblur.c'), ++ 'bs2b_filter' : files('af_bs2b.c'), ++ 'bwdif_filter' : files('vf_bwdif.c','yadif_common.c'), ++ 'cas_filter' : files('vf_cas.c'), ++ 'cellauto_filter' : files('vsrc_cellauto.c'), ++ 'channelmap_filter' : files('af_channelmap.c'), ++ 'channelsplit_filter' : files('af_channelsplit.c'), ++ 'chorus_filter' : files('af_chorus.c','generate_wave_table.c'), ++ 'chromaber_vulkan_filter' : files('vf_chromaber_vulkan.c','vulkan.c','vulkan_filter.c'), ++ 'chromahold_filter' : files('vf_chromakey.c'), ++ # 'chromakey_cuda_filter' : files('vf_chromakey_cuda.c'), ++ 'chromakey_filter' : files('vf_chromakey.c'), ++ 'chromanr_filter' : files('vf_chromanr.c'), ++ 'chromashift_filter' : files('vf_chromashift.c'), ++ 'ciescope_filter' : files('vf_ciescope.c'), ++ 'codecview_filter' : files('vf_codecview.c','qp_table.c'), ++ 'colorbalance_filter' : files('vf_colorbalance.c'), ++ 'colorchannelmixer_filter' : files('vf_colorchannelmixer.c'), ++ 'colorchart_filter' : files('vsrc_testsrc.c'), ++ 'colorcontrast_filter' : files('vf_colorcontrast.c'), ++ 'colorcorrect_filter' : files('vf_colorcorrect.c'), ++ 'colorhold_filter' : files('vf_colorkey.c'), ++ 'colorize_filter' : files('vf_colorize.c'), ++ 'colorkey_filter' : files('vf_colorkey.c'), ++ 'colorkey_opencl_filter' : files('vf_colorkey_opencl.c','opencl.c','opencl/colorkey.cl'), ++ 'colorlevels_filter' : files('vf_colorlevels.c'), ++ 'colormap_filter' : files('vf_colormap.c'), ++ 'colormatrix_filter' : files('vf_colormatrix.c'), ++ # 'colorspace_cuda_filter' : files('vf_colorspace_cuda.c','cuda/load_helper.c'), ++ 'colorspace_filter' : files('vf_colorspace.c','colorspacedsp.c'), ++ 'colorspectrum_filter' : files('vsrc_testsrc.c'), ++ 'colortemperature_filter' : files('vf_colortemperature.c'), ++ 'color_filter' : files('vsrc_testsrc.c'), ++ 'compand_filter' : files('af_compand.c'), ++ 'compensationdelay_filter' : files('af_compensationdelay.c'), ++ 'concat_filter' : files('avf_concat.c'), ++ 'convolution_filter' : files('vf_convolution.c'), ++ 'convolution_opencl_filter' : files('vf_convolution_opencl.c','opencl.c','opencl/convolution.cl'), ++ 'convolve_filter' : files('vf_convolve.c','framesync.c'), ++ 'copy_filter' : files('vf_copy.c'), ++ 'coreimagesrc_filter' : files('vf_coreimage.m'), ++ 'coreimage_filter' : files('vf_coreimage.m'), ++ 'corr_filter' : files('vf_corr.c','framesync.c'), ++ 'cover_rect_filter' : files('vf_cover_rect.c','lavfutils.c'), ++ 'cropdetect_filter' : files('vf_cropdetect.c'), ++ 'crop_filter' : files('vf_crop.c'), ++ 'crossfeed_filter' : files('af_crossfeed.c'), ++ 'crystalizer_filter' : files('af_crystalizer.c'), ++ 'cue_filter' : files('f_cue.c'), ++ 'curves_filter' : files('vf_curves.c'), ++ 'datascope_filter' : files('vf_datascope.c'), ++ 'dblur_filter' : files('vf_dblur.c'), ++ 'dcshift_filter' : files('af_dcshift.c'), ++ 'dctdnoiz_filter' : files('vf_dctdnoiz.c'), ++ 'ddagrab_filter' : files('vsrc_ddagrab.c'), ++ 'deband_filter' : files('vf_deband.c'), ++ 'deblock_filter' : files('vf_deblock.c'), ++ 'decimate_filter' : files('vf_decimate.c'), ++ 'deconvolve_filter' : files('vf_convolve.c','framesync.c'), ++ 'dedot_filter' : files('vf_dedot.c'), ++ 'deesser_filter' : files('af_deesser.c'), ++ 'deflate_filter' : files('vf_neighbor.c'), ++ 'deflicker_filter' : files('vf_deflicker.c'), ++ 'deinterlace_qsv_filter' : files('vf_vpp_qsv.c'), ++ 'deinterlace_vaapi_filter' : files('vf_deinterlace_vaapi.c','vaapi_vpp.c'), ++ 'dejudder_filter' : files('vf_dejudder.c'), ++ 'delogo_filter' : files('vf_delogo.c'), ++ 'denoise_vaapi_filter' : files('vf_misc_vaapi.c','vaapi_vpp.c'), ++ 'derain_filter' : files('vf_derain.c'), ++ 'deshake_filter' : files('vf_deshake.c','transform.c'), ++ 'deshake_opencl_filter' : files('vf_deshake_opencl.c','opencl.c','opencl/deshake.cl','transform.c'), ++ 'despill_filter' : files('vf_despill.c'), ++ 'detelecine_filter' : files('vf_detelecine.c'), ++ 'dialoguenhance_filter' : files('af_dialoguenhance.c'), ++ 'dilation_filter' : files('vf_neighbor.c'), ++ 'dilation_opencl_filter' : files('vf_neighbor_opencl.c','opencl.c','opencl/neighbor.cl'), ++ 'displace_filter' : files('vf_displace.c','framesync.c'), ++ 'dnn' : files('dnn_filter_common.c'), ++ 'dnn_classify_filter' : files('vf_dnn_classify.c'), ++ 'dnn_detect_filter' : files('vf_dnn_detect.c'), ++ 'dnn_processing_filter' : files('vf_dnn_processing.c'), ++ 'doubleweave_filter' : files('vf_weave.c'), ++ 'drawbox_filter' : files('vf_drawbox.c'), ++ 'drawgraph_filter' : files('f_drawgraph.c'), ++ 'drawgrid_filter' : files('vf_drawbox.c'), ++ 'drawtext_filter' : files('vf_drawtext.c'), ++ 'drmeter_filter' : files('af_drmeter.c'), ++ 'dynaudnorm_filter' : files('af_dynaudnorm.c'), ++ 'earwax_filter' : files('af_earwax.c'), ++ 'ebur128_filter' : files('f_ebur128.c'), ++ 'edgedetect_filter' : files('vf_edgedetect.c','edge_common.c'), ++ 'elbg_filter' : files('vf_elbg.c'), ++ 'entropy_filter' : files('vf_entropy.c'), ++ 'epx_filter' : files('vf_epx.c'), ++ 'equalizer_filter' : files('af_biquads.c'), ++ 'eq_filter' : files('vf_eq.c'), ++ 'erosion_filter' : files('vf_neighbor.c'), ++ 'erosion_opencl_filter' : files('vf_neighbor_opencl.c','opencl.c','opencl/neighbor.cl'), ++ 'estdif_filter' : files('vf_estdif.c'), ++ 'exposure_filter' : files('vf_exposure.c'), ++ 'extractplanes_filter' : files('vf_extractplanes.c'), ++ 'extrastereo_filter' : files('af_extrastereo.c'), ++ 'fade_filter' : files('vf_fade.c'), ++ 'feedback_filter' : files('vf_feedback.c'), ++ 'fftdnoiz_filter' : files('vf_fftdnoiz.c'), ++ 'fftfilt_filter' : files('vf_fftfilt.c'), ++ 'fieldhint_filter' : files('vf_fieldhint.c'), ++ 'fieldmatch_filter' : files('vf_fieldmatch.c'), ++ 'fieldorder_filter' : files('vf_fieldorder.c'), ++ 'field_filter' : files('vf_field.c'), ++ 'fillborders_filter' : files('vf_fillborders.c'), ++ 'find_rect_filter' : files('vf_find_rect.c','lavfutils.c'), ++ 'firequalizer_filter' : files('af_firequalizer.c'), ++ 'flanger_filter' : files('af_flanger.c','generate_wave_table.c'), ++ 'flite_filter' : files('asrc_flite.c'), ++ 'floodfill_filter' : files('vf_floodfill.c'), ++ 'format_filter' : files('vf_format.c'), ++ 'fps_filter' : files('vf_fps.c'), ++ 'framepack_filter' : files('vf_framepack.c'), ++ 'framerate_filter' : files('vf_framerate.c'), ++ 'framestep_filter' : files('vf_framestep.c'), ++ 'freezedetect_filter' : files('vf_freezedetect.c'), ++ 'freezeframes_filter' : files('vf_freezeframes.c'), ++ 'frei0r_filter' : files('vf_frei0r.c'), ++ 'frei0r_src_filter' : files('vf_frei0r.c'), ++ 'fspp_filter' : files('vf_fspp.c','qp_table.c'), ++ 'gblur_filter' : files('vf_gblur.c'), ++ 'gblur_vulkan_filter' : files('vf_gblur_vulkan.c','vulkan.c','vulkan_filter.c'), ++ 'geq_filter' : files('vf_geq.c'), ++ 'gradfun_filter' : files('vf_gradfun.c'), ++ 'gradients_filter' : files('vsrc_gradients.c'), ++ 'graphmonitor_filter' : files('f_graphmonitor.c'), ++ 'grayworld_filter' : files('vf_grayworld.c'), ++ 'greyedge_filter' : files('vf_colorconstancy.c'), ++ 'guided_filter' : files('vf_guided.c'), ++ 'haas_filter' : files('af_haas.c'), ++ 'haldclutsrc_filter' : files('vsrc_testsrc.c'), ++ 'haldclut_filter' : files('vf_lut3d.c','framesync.c'), ++ 'hdcd_filter' : files('af_hdcd.c'), ++ 'headphone_filter' : files('af_headphone.c'), ++ 'hflip_filter' : files('vf_hflip.c'), ++ 'hflip_vulkan_filter' : files('vf_flip_vulkan.c','vulkan.c'), ++ 'highpass_filter' : files('af_biquads.c'), ++ 'highshelf_filter' : files('af_biquads.c'), ++ 'hilbert_filter' : files('asrc_hilbert.c'), ++ 'histeq_filter' : files('vf_histeq.c'), ++ 'histogram_filter' : files('vf_histogram.c'), ++ 'hqdn3d_filter' : files('vf_hqdn3d.c'), ++ 'hqx_filter' : files('vf_hqx.c'), ++ 'hstack_filter' : files('vf_stack.c','framesync.c'), ++ 'hstack_qsv_filter' : files('vf_stack_qsv.c','framesync.c'), ++ 'hstack_vaapi_filter' : files('vf_stack_vaapi.c','framesync.c','vaapi_vpp.c'), ++ 'hsvhold_filter' : files('vf_hsvkey.c'), ++ 'hsvkey_filter' : files('vf_hsvkey.c'), ++ 'huesaturation_filter' : files('vf_huesaturation.c'), ++ 'hue_filter' : files('vf_hue.c'), ++ 'hwdownload_filter' : files('vf_hwdownload.c'), ++ 'hwmap_filter' : files('vf_hwmap.c'), ++ 'hwupload_cuda_filter' : files('vf_hwupload_cuda.c'), ++ 'hwupload_filter' : files('vf_hwupload.c'), ++ 'hysteresis_filter' : files('vf_hysteresis.c','framesync.c'), ++ 'iccdetect_filter' : files('vf_iccdetect.c','fflcms2.c'), ++ 'iccgen_filter' : files('vf_iccgen.c','fflcms2.c'), ++ 'identity_filter' : files('vf_identity.c'), ++ 'idet_filter' : files('vf_idet.c'), ++ 'il_filter' : files('vf_il.c'), ++ 'inflate_filter' : files('vf_neighbor.c'), ++ 'interlace_filter' : files('vf_tinterlace.c'), ++ 'interleave_filter' : files('f_interleave.c'), ++ 'join_filter' : files('af_join.c'), ++ 'kerndeint_filter' : files('vf_kerndeint.c'), ++ 'kirsch_filter' : files('vf_convolution.c'), ++ 'ladspa_filter' : files('af_ladspa.c'), ++ 'lagfun_filter' : files('vf_lagfun.c'), ++ 'latency_filter' : files('f_latency.c'), ++ 'lenscorrection_filter' : files('vf_lenscorrection.c'), ++ 'lensfun_filter' : files('vf_lensfun.c'), ++ 'libc_msvcrt' : files('file_open.c'), ++ 'libplacebo_filter' : files('vf_libplacebo.c','vulkan.c','vulkan_filter.c'), ++ 'libvmaf_filter' : files('vf_libvmaf.c','framesync.c'), ++ 'life_filter' : files('vsrc_life.c'), ++ 'limitdiff_filter' : files('vf_limitdiff.c','framesync.c'), ++ 'limiter_filter' : files('vf_limiter.c'), ++ 'loop_filter' : files('f_loop.c'), ++ 'loudnorm_filter' : files('af_loudnorm.c','ebur128.c'), ++ 'lowpass_filter' : files('af_biquads.c'), ++ 'lowshelf_filter' : files('af_biquads.c'), ++ 'lumakey_filter' : files('vf_lumakey.c'), ++ 'lut1d_filter' : files('vf_lut3d.c'), ++ 'lut2_filter' : files('vf_lut2.c','framesync.c'), ++ 'lut3d_filter' : files('vf_lut3d.c','framesync.c'), ++ 'lutrgb_filter' : files('vf_lut.c'), ++ 'lutyuv_filter' : files('vf_lut.c'), ++ 'lut_filter' : files('vf_lut.c'), ++ 'lv2_filter' : files('af_lv2.c'), ++ 'mandelbrot_filter' : files('vsrc_mandelbrot.c'), ++ 'maskedclamp_filter' : files('vf_maskedclamp.c','framesync.c'), ++ 'maskedmax_filter' : files('vf_maskedminmax.c','framesync.c'), ++ 'maskedmerge_filter' : files('vf_maskedmerge.c','framesync.c'), ++ 'maskedmin_filter' : files('vf_maskedminmax.c','framesync.c'), ++ 'maskedthreshold_filter' : files('vf_maskedthreshold.c','framesync.c'), ++ 'maskfun_filter' : files('vf_maskfun.c'), ++ 'mcdeint_filter' : files('vf_mcdeint.c'), ++ 'mcompand_filter' : files('af_mcompand.c'), ++ 'median_filter' : files('vf_median.c'), ++ 'mergeplanes_filter' : files('vf_mergeplanes.c','framesync.c'), ++ 'mestimate_filter' : files('vf_mestimate.c','motion_estimation.c'), ++ 'metadata_filter' : files('f_metadata.c'), ++ 'midequalizer_filter' : files('vf_midequalizer.c','framesync.c'), ++ 'minterpolate_filter' : files('vf_minterpolate.c','motion_estimation.c'), ++ 'mix_filter' : files('vf_mix.c','framesync.c'), ++ 'monochrome_filter' : files('vf_monochrome.c'), ++ 'morpho_filter' : files('vf_morpho.c'), ++ 'movie_filter' : files('src_movie.c'), ++ 'mpdecimate_filter' : files('vf_mpdecimate.c'), ++ 'mptestsrc_filter' : files('vsrc_mptestsrc.c'), ++ 'multiply_filter' : files('vf_multiply.c'), ++ 'negate_filter' : files('vf_negate.c'), ++ 'nlmeans_filter' : files('vf_nlmeans.c'), ++ 'nlmeans_opencl_filter' : files('vf_nlmeans_opencl.c','opencl.c','opencl/nlmeans.cl'), ++ 'nnedi_filter' : files('vf_nnedi.c'), ++ 'noformat_filter' : files('vf_format.c'), ++ 'noise_filter' : files('vf_noise.c'), ++ 'normalize_filter' : files('vf_normalize.c'), ++ 'nullsink_filter' : files('vsink_nullsink.c'), ++ 'nullsrc_filter' : files('vsrc_testsrc.c'), ++ 'null_filter' : files('vf_null.c'), ++ 'ocr_filter' : files('vf_ocr.c'), ++ 'ocv_filter' : files('vf_libopencv.c'), ++ 'openclsrc_filter' : files('vf_program_opencl.c','opencl.c'), ++ 'oscilloscope_filter' : files('vf_datascope.c'), ++ # 'overlay_cuda_filter' : files('vf_overlay_cuda.c','framesync.c','cuda/load_helper.c'), ++ 'overlay_filter' : files('vf_overlay.c','framesync.c'), ++ 'overlay_opencl_filter' : files('vf_overlay_opencl.c','opencl.c','opencl/overlay.cl','framesync.c'), ++ 'overlay_qsv_filter' : files('vf_overlay_qsv.c','framesync.c'), ++ 'overlay_vaapi_filter' : files('vf_overlay_vaapi.c','framesync.c','vaapi_vpp.c'), ++ 'overlay_vulkan_filter' : files('vf_overlay_vulkan.c','vulkan.c','vulkan_filter.c'), ++ 'owdenoise_filter' : files('vf_owdenoise.c'), ++ 'pad_filter' : files('vf_pad.c'), ++ 'pad_opencl_filter' : files('vf_pad_opencl.c','opencl.c','opencl/pad.cl'), ++ 'pal100bars_filter' : files('vsrc_testsrc.c'), ++ 'pal75bars_filter' : files('vsrc_testsrc.c'), ++ 'palettegen_filter' : files('vf_palettegen.c','palette.c'), ++ 'paletteuse_filter' : files('vf_paletteuse.c','framesync.c','palette.c'), ++ 'pan_filter' : files('af_pan.c'), ++ 'perms_filter' : files('f_perms.c'), ++ 'perspective_filter' : files('vf_perspective.c'), ++ 'phase_filter' : files('vf_phase.c'), ++ 'photosensitivity_filter' : files('vf_photosensitivity.c'), ++ 'pixdesctest_filter' : files('vf_pixdesctest.c'), ++ 'pixelize_filter' : files('vf_pixelize.c'), ++ 'pixscope_filter' : files('vf_datascope.c'), ++ 'pp7_filter' : files('vf_pp7.c','qp_table.c'), ++ 'pp_filter' : files('vf_pp.c','qp_table.c'), ++ 'premultiply_filter' : files('vf_premultiply.c','framesync.c'), ++ 'prewitt_filter' : files('vf_convolution.c'), ++ 'prewitt_opencl_filter' : files('vf_convolution_opencl.c','opencl.c','opencl/convolution.cl'), ++ 'procamp_vaapi_filter' : files('vf_procamp_vaapi.c','vaapi_vpp.c'), ++ 'program_opencl_filter' : files('vf_program_opencl.c','opencl.c','framesync.c'), ++ 'pseudocolor_filter' : files('vf_pseudocolor.c'), ++ 'psnr_filter' : files('vf_psnr.c','framesync.c'), ++ 'pullup_filter' : files('vf_pullup.c'), ++ 'qp_filter' : files('vf_qp.c'), ++ 'qsvvpp' : files('qsvvpp.c'), ++ 'random_filter' : files('vf_random.c'), ++ 'readeia608_filter' : files('vf_readeia608.c'), ++ 'readvitc_filter' : files('vf_readvitc.c'), ++ 'realtime_filter' : files('f_realtime.c'), ++ 'remap_filter' : files('vf_remap.c','framesync.c'), ++ 'remap_opencl_filter' : files('vf_remap_opencl.c','framesync.c','opencl.c','opencl/remap.cl'), ++ 'removegrain_filter' : files('vf_removegrain.c'), ++ 'removelogo_filter' : files('bbox.c','lswsutils.c','lavfutils.c','vf_removelogo.c'), ++ 'repeatfields_filter' : files('vf_repeatfields.c'), ++ 'replaygain_filter' : files('af_replaygain.c'), ++ 'reverse_filter' : files('f_reverse.c'), ++ 'rgbashift_filter' : files('vf_chromashift.c'), ++ 'rgbtestsrc_filter' : files('vsrc_testsrc.c'), ++ 'roberts_filter' : files('vf_convolution.c'), ++ 'roberts_opencl_filter' : files('vf_convolution_opencl.c','opencl.c','opencl/convolution.cl'), ++ 'rotate_filter' : files('vf_rotate.c'), ++ 'rubberband_filter' : files('af_rubberband.c'), ++ 'sab_filter' : files('vf_sab.c'), ++ 'scale2ref_filter' : files('vf_scale.c','scale_eval.c'), ++ 'scale2ref_npp_filter' : files('vf_scale_npp.c','scale_eval.c'), ++ # 'scale_cuda_filter' : files('vf_scale_cuda.c','scale_eval.c'), ++ 'scale_filter' : files('vf_scale.c','scale_eval.c'), ++ 'scale_npp_filter' : files('vf_scale_npp.c','scale_eval.c'), ++ 'scale_qsv_filter' : files('vf_vpp_qsv.c'), ++ 'scale_vaapi_filter' : files('vf_scale_vaapi.c','scale_eval.c','vaapi_vpp.c'), ++ 'scale_vulkan_filter' : files('vf_scale_vulkan.c','vulkan.c','vulkan_filter.c'), ++ 'scdet_filter' : files('vf_scdet.c'), ++ 'scene_sad' : files('scene_sad.c'), ++ 'scharr_filter' : files('vf_convolution.c'), ++ 'scroll_filter' : files('vf_scroll.c'), ++ 'segment_filter' : files('f_segment.c'), ++ 'selectivecolor_filter' : files('vf_selectivecolor.c'), ++ 'select_filter' : files('f_select.c'), ++ 'sendcmd_filter' : files('f_sendcmd.c'), ++ 'separatefields_filter' : files('vf_separatefields.c'), ++ 'setdar_filter' : files('vf_aspect.c'), ++ 'setfield_filter' : files('vf_setparams.c'), ++ 'setparams_filter' : files('vf_setparams.c'), ++ 'setpts_filter' : files('setpts.c'), ++ 'setrange_filter' : files('vf_setparams.c'), ++ 'setsar_filter' : files('vf_aspect.c'), ++ 'settb_filter' : files('settb.c'), ++ 'sharpen_npp_filter' : files('vf_sharpen_npp.c'), ++ 'sharpness_vaapi_filter' : files('vf_misc_vaapi.c','vaapi_vpp.c'), ++ 'shear_filter' : files('vf_shear.c'), ++ 'showcqt_filter' : files('avf_showcqt.c','lswsutils.c','lavfutils.c'), ++ 'showcwt_filter' : files('avf_showcwt.c'), ++ 'showfreqs_filter' : files('avf_showfreqs.c'), ++ 'showinfo_filter' : files('vf_showinfo.c'), ++ 'showpalette_filter' : files('vf_showpalette.c'), ++ 'showspatial_filter' : files('avf_showspatial.c'), ++ 'showspectrumpic_filter' : files('avf_showspectrum.c'), ++ 'showspectrum_filter' : files('avf_showspectrum.c'), ++ 'showvolume_filter' : files('avf_showvolume.c'), ++ 'showwavespic_filter' : files('avf_showwaves.c'), ++ 'showwaves_filter' : files('avf_showwaves.c'), ++ 'shuffleframes_filter' : files('vf_shuffleframes.c'), ++ 'shufflepixels_filter' : files('vf_shufflepixels.c'), ++ 'shuffleplanes_filter' : files('vf_shuffleplanes.c'), ++ 'sidechaincompress_filter' : files('af_sidechaincompress.c'), ++ 'sidechaingate_filter' : files('af_agate.c'), ++ 'sidedata_filter' : files('f_sidedata.c'), ++ 'sierpinski_filter' : files('vsrc_sierpinski.c'), ++ 'signalstats_filter' : files('vf_signalstats.c'), ++ 'signature_filter' : files('vf_signature.c'), ++ 'silencedetect_filter' : files('af_silencedetect.c'), ++ 'silenceremove_filter' : files('af_silenceremove.c'), ++ 'sinc_filter' : files('asrc_sinc.c'), ++ 'sine_filter' : files('asrc_sine.c'), ++ 'siti_filter' : files('vf_siti.c'), ++ 'smartblur_filter' : files('vf_smartblur.c'), ++ 'smptebars_filter' : files('vsrc_testsrc.c'), ++ 'smptehdbars_filter' : files('vsrc_testsrc.c'), ++ 'sobel_filter' : files('vf_convolution.c'), ++ 'sobel_opencl_filter' : files('vf_convolution_opencl.c','opencl.c','opencl/convolution.cl'), ++ 'sofalizer_filter' : files('af_sofalizer.c'), ++ 'spectrumsynth_filter' : files('vaf_spectrumsynth.c'), ++ 'speechnorm_filter' : files('af_speechnorm.c'), ++ 'split_filter' : files('split.c'), ++ 'spp_filter' : files('vf_spp.c','qp_table.c'), ++ 'sr_filter' : files('vf_sr.c'), ++ 'ssim360_filter' : files('vf_ssim360.c','framesync.c'), ++ 'ssim_filter' : files('vf_ssim.c','framesync.c'), ++ 'stereo3d_filter' : files('vf_stereo3d.c'), ++ 'stereotools_filter' : files('af_stereotools.c'), ++ 'stereowiden_filter' : files('af_stereowiden.c'), ++ 'streamselect_filter' : files('f_streamselect.c','framesync.c'), ++ 'subtitles_filter' : files('vf_subtitles.c'), ++ 'super2xsai_filter' : files('vf_super2xsai.c'), ++ 'superequalizer_filter' : files('af_superequalizer.c'), ++ 'surround_filter' : files('af_surround.c'), ++ 'swaprect_filter' : files('vf_swaprect.c'), ++ 'swapuv_filter' : files('vf_swapuv.c'), ++ 'tblend_filter' : files('vf_blend.c','framesync.c'), ++ 'telecine_filter' : files('vf_telecine.c'), ++ 'testsrc2_filter' : files('vsrc_testsrc.c'), ++ 'testsrc_filter' : files('vsrc_testsrc.c'), ++ 'thistogram_filter' : files('vf_histogram.c'), ++ 'threads' : files('pthread.c'), ++ 'threshold_filter' : files('vf_threshold.c','framesync.c'), ++ # 'thumbnail_cuda_filter' : files('vf_thumbnail_cuda.c','cuda/load_helper.c'), ++ 'thumbnail_filter' : files('vf_thumbnail.c'), ++ 'tile_filter' : files('vf_tile.c'), ++ 'tinterlace_filter' : files('vf_tinterlace.c'), ++ 'tlut2_filter' : files('vf_lut2.c','framesync.c'), ++ 'tmedian_filter' : files('vf_xmedian.c','framesync.c'), ++ 'tmidequalizer_filter' : files('vf_tmidequalizer.c'), ++ 'tmix_filter' : files('vf_mix.c','framesync.c'), ++ 'tonemap_filter' : files('vf_tonemap.c'), ++ 'tonemap_opencl_filter' : files('vf_tonemap_opencl.c','opencl.c','opencl/tonemap.cl','opencl/colorspace_common.cl'), ++ 'tonemap_vaapi_filter' : files('vf_tonemap_vaapi.c','vaapi_vpp.c'), ++ 'tpad_filter' : files('vf_tpad.c'), ++ 'transpose_filter' : files('vf_transpose.c'), ++ 'transpose_npp_filter' : files('vf_transpose_npp.c'), ++ 'transpose_opencl_filter' : files('vf_transpose_opencl.c','opencl.c','opencl/transpose.cl'), ++ 'transpose_vaapi_filter' : files('vf_transpose_vaapi.c','vaapi_vpp.c'), ++ 'transpose_vulkan_filter' : files('vf_transpose_vulkan.c','vulkan.c','vulkan_filter.c'), ++ 'treble_filter' : files('af_biquads.c'), ++ 'tremolo_filter' : files('af_tremolo.c'), ++ 'trim_filter' : files('trim.c'), ++ 'unpremultiply_filter' : files('vf_premultiply.c','framesync.c'), ++ 'unsharp_filter' : files('vf_unsharp.c'), ++ 'unsharp_opencl_filter' : files('vf_unsharp_opencl.c','opencl.c','opencl/unsharp.cl'), ++ 'untile_filter' : files('vf_untile.c'), ++ 'uspp_filter' : files('vf_uspp.c','qp_table.c'), ++ 'v360_filter' : files('vf_v360.c'), ++ 'vaguedenoiser_filter' : files('vf_vaguedenoiser.c'), ++ 'varblur_filter' : files('vf_varblur.c','framesync.c'), ++ 'vectorscope_filter' : files('vf_vectorscope.c'), ++ 'vflip_filter' : files('vf_vflip.c'), ++ 'vflip_vulkan_filter' : files('vf_flip_vulkan.c','vulkan.c'), ++ 'vfrdet_filter' : files('vf_vfrdet.c'), ++ 'vibrance_filter' : files('vf_vibrance.c'), ++ 'vibrato_filter' : files('af_vibrato.c','generate_wave_table.c'), ++ 'vidstabdetect_filter' : files('vidstabutils.c','vf_vidstabdetect.c'), ++ 'vidstabtransform_filter' : files('vidstabutils.c','vf_vidstabtransform.c'), ++ 'vif_filter' : files('vf_vif.c','framesync.c'), ++ 'vignette_filter' : files('vf_vignette.c'), ++ 'virtualbass_filter' : files('af_virtualbass.c'), ++ 'vmafmotion_filter' : files('vf_vmafmotion.c','framesync.c'), ++ 'volumedetect_filter' : files('af_volumedetect.c'), ++ 'volume_filter' : files('af_volume.c'), ++ 'vpp_qsv_filter' : files('vf_vpp_qsv.c'), ++ 'vstack_filter' : files('vf_stack.c','framesync.c'), ++ 'vstack_qsv_filter' : files('vf_stack_qsv.c','framesync.c'), ++ 'vstack_vaapi_filter' : files('vf_stack_vaapi.c','framesync.c','vaapi_vpp.c'), ++ 'w3fdif_filter' : files('vf_w3fdif.c'), ++ 'waveform_filter' : files('vf_waveform.c'), ++ 'weave_filter' : files('vf_weave.c'), ++ 'xbr_filter' : files('vf_xbr.c'), ++ 'xcorrelate_filter' : files('vf_convolve.c','framesync.c'), ++ 'xfade_filter' : files('vf_xfade.c'), ++ 'xfade_opencl_filter' : files('vf_xfade_opencl.c','opencl.c','opencl/xfade.cl'), ++ 'xmedian_filter' : files('vf_xmedian.c','framesync.c'), ++ 'xstack_filter' : files('vf_stack.c','framesync.c'), ++ 'xstack_qsv_filter' : files('vf_stack_qsv.c','framesync.c'), ++ 'xstack_vaapi_filter' : files('vf_stack_vaapi.c','framesync.c','vaapi_vpp.c'), ++ # 'yadif_cuda_filter' : files('vf_yadif_cuda.c','yadif_common.c','cuda/load_helper.c'), ++ 'yadif_filter' : files('vf_yadif.c','yadif_common.c'), ++ 'yadif_videotoolbox_filter' : files('vf_yadif_videotoolbox.m','metal/utils.m','yadif_common.c'), # MANUAL ++ 'yaepblur_filter' : files('vf_yaepblur.c'), ++ 'yuvtestsrc_filter' : files('vsrc_testsrc.c'), ++ 'zmq_filter' : files('f_zmq.c'), ++ 'zoompan_filter' : files('vf_zoompan.c'), ++ 'zscale_filter' : files('vf_zscale.c'), ++} ++ ++libavfilter_x86asm_optional_sources = { ++} ++ ++libavfilter_armv5te_optional_sources = { ++} ++ ++libavfilter_armv6_optional_sources = { ++} ++ ++libavfilter_armv8_optional_sources = { ++} ++ ++libavfilter_neon_optional_sources = { ++} ++ ++libavfilter_vfp_optional_sources = { ++} ++ ++libavfilter_mmx_optional_sources = { ++} ++ ++libavfilter_shlib_sources = files( ++ 'log2_tab.c', ++) ++ ++libavfilter_shlib_optional_sources = { ++} ++ ++libavfilter_slib_optional_sources = { ++} ++ ++libavfilter_tests = [ ++ ['drawutils', files('tests/drawutils.c')], ++ # MANUAL ['filtfmts', files('tests/filtfmts.c')], ++ ['formats', files('tests/formats.c')], ++ # MANUAL ['integral', files('tests/integral.c')], ++] ++ ++libavfilter_optional_tests = { ++ 'dnn' : [ ++ ['dnn-layer-avgpool', files('tests/dnn-layer-avgpool.c')], ++ ['dnn-layer-conv2d', files('tests/dnn-layer-conv2d.c')], ++ ['dnn-layer-dense', files('tests/dnn-layer-dense.c')], ++ ['dnn-layer-depth2space', files('tests/dnn-layer-depth2space.c')], ++ ['dnn-layer-mathbinary', files('tests/dnn-layer-mathbinary.c')], ++ ['dnn-layer-mathunary', files('tests/dnn-layer-mathunary.c')], ++ ['dnn-layer-maximum', files('tests/dnn-layer-maximum.c')], ++ ['dnn-layer-pad', files('tests/dnn-layer-pad.c')], ++ ], ++ 'nlmeans_filter': [ ++ ['integral', files('tests/integral.c')], ++ ] ++} ++ ++languages_map += { ++ 'coreimage_filter': ['objc'], ++ 'yadif_videotoolbox_filter': ['objc'], ++ 'coreimagesrc_filter': ['objc'], ++} ++#### --- END GENERATED --- #### ++subdir('dnn') ++ ++dnn_sources = libavfilter_optional_sources.get('dnn') + libavfilter_dnn_optional_sources.get('dnn') ++ ++libavfilter_optional_sources += {'dnn': dnn_sources} ++ ++if conf.get('yadif_videotoolbox_filter') == 1 ++ gen_objects = [] ++ x = metalcc.process( ++ files('metal/vf_yadif_videotoolbox.metal',) ++ ) ++ y = metallib.process(x) ++ gen_objects += bin2c.process(y) ++ libavfilter_optional_sources += { ++ 'yadif_videotoolbox_filter' : libavfilter_optional_sources['yadif_videotoolbox_filter'] + gen_objects, ++ } ++endif ++ ++# Version file ++ver_conf = configuration_data() ++ver_conf.set('majorver', libavfilter_majorver) ++ver_conf.set('minorver', minorver) ++ver_conf.set('microver', microver) ++ ++ ++install_headers(libavfilter_headers, subdir: 'libavfilter') ++ ++configure_file( ++ input: 'libavfilter.v.in', ++ output: 'libavfilter.ver', ++ configuration: ver_conf, ++) ++ ++subdir('aarch64') ++subdir('x86') +diff --git a/libavfilter/x86/meson.build b/libavfilter/x86/meson.build +new file mode 100644 +index 0000000000..3e0bae10c0 +--- /dev/null ++++ b/libavfilter/x86/meson.build +@@ -0,0 +1,128 @@ ++#### --- GENERATED --- #### ++ ++libavfilter_x86_optional_sources = { ++ 'afir_filter' : files('af_afir_init.c'), ++ 'anlmdn_filter' : files('af_anlmdn_init.c'), ++ 'atadenoise_filter' : files('vf_atadenoise_init.c'), ++ 'blend_filter' : files('vf_blend_init.c'), ++ 'bwdif_filter' : files('vf_bwdif_init.c'), ++ 'colorspace_filter' : files('colorspacedsp_init.c'), ++ 'convolution_filter' : files('vf_convolution_init.c'), ++ 'eq_filter' : files('vf_eq_init.c'), ++ 'framerate_filter' : files('vf_framerate_init.c'), ++ 'fspp_filter' : files('vf_fspp_init.c'), ++ 'gblur_filter' : files('vf_gblur_init.c'), ++ 'gradfun_filter' : files('vf_gradfun_init.c'), ++ 'hflip_filter' : files('vf_hflip_init.c'), ++ 'hqdn3d_filter' : files('vf_hqdn3d_init.c'), ++ 'idet_filter' : files('vf_idet_init.c'), ++ 'interlace_filter' : files('vf_tinterlace_init.c'), ++ 'limiter_filter' : files('vf_limiter_init.c'), ++ 'lut3d_filter' : files('vf_lut3d_init.c'), ++ 'maskedclamp_filter' : files('vf_maskedclamp_init.c'), ++ 'maskedmerge_filter' : files('vf_maskedmerge_init.c'), ++ 'nlmeans_filter' : files('vf_nlmeans_init.c'), ++ 'noise_filter' : files('vf_noise.c'), ++ 'overlay_filter' : files('vf_overlay_init.c'), ++ 'pp7_filter' : files('vf_pp7_init.c'), ++ 'psnr_filter' : files('vf_psnr_init.c'), ++ 'pullup_filter' : files('vf_pullup_init.c'), ++ 'removegrain_filter' : files('vf_removegrain_init.c'), ++ 'scene_sad' : files('scene_sad_init.c'), ++ 'showcqt_filter' : files('avf_showcqt_init.c'), ++ 'spp_filter' : files('vf_spp.c'), ++ 'ssim_filter' : files('vf_ssim_init.c'), ++ 'stereo3d_filter' : files('vf_stereo3d_init.c'), ++ 'tblend_filter' : files('vf_blend_init.c'), ++ 'threshold_filter' : files('vf_threshold_init.c'), ++ 'tinterlace_filter' : files('vf_tinterlace_init.c'), ++ 'transpose_filter' : files('vf_transpose_init.c'), ++ 'v360_filter' : files('vf_v360_init.c'), ++ 'volume_filter' : files('af_volume_init.c'), ++ 'w3fdif_filter' : files('vf_w3fdif_init.c'), ++ 'yadif_filter' : files('vf_yadif_init.c'), ++} ++ ++libavfilter_x86_x86asm_optional_sources = { ++ 'afir_filter' : files('af_afir.asm'), ++ 'anlmdn_filter' : files('af_anlmdn.asm'), ++ 'atadenoise_filter' : [], # MANUAL ++ 'blend_filter' : files('vf_blend.asm'), ++ 'bwdif_filter' : files('vf_bwdif.asm'), ++ 'colorspace_filter' : files('colorspacedsp.asm'), ++ 'convolution_filter' : files('vf_convolution.asm'), ++ 'eq_filter' : files('vf_eq.asm'), ++ 'framerate_filter' : files('vf_framerate.asm'), ++ 'fspp_filter' : files('vf_fspp.asm'), ++ 'gblur_filter' : files('vf_gblur.asm'), ++ 'gradfun_filter' : files('vf_gradfun.asm'), ++ 'hflip_filter' : files('vf_hflip.asm'), ++ 'hqdn3d_filter' : files('vf_hqdn3d.asm'), ++ 'idet_filter' : files('vf_idet.asm'), ++ 'interlace_filter' : files('vf_interlace.asm'), ++ 'limiter_filter' : files('vf_limiter.asm'), ++ 'lut3d_filter' : files('vf_lut3d.asm'), ++ 'maskedclamp_filter' : files('vf_maskedclamp.asm'), ++ 'maskedmerge_filter' : files('vf_maskedmerge.asm'), ++ 'nlmeans_filter' : [], # MANUAL ++ 'overlay_filter' : files('vf_overlay.asm'), ++ 'pp7_filter' : files('vf_pp7.asm'), ++ 'psnr_filter' : files('vf_psnr.asm'), ++ 'pullup_filter' : files('vf_pullup.asm'), ++ 'removegrain_filter' : files('vf_removegrain.asm'), ++ 'scene_sad' : files('scene_sad.asm'), ++ 'showcqt_filter' : files('avf_showcqt.asm'), ++ 'ssim_filter' : files('vf_ssim.asm'), ++ 'stereo3d_filter' : files('vf_stereo3d.asm'), ++ 'tblend_filter' : files('vf_blend.asm'), ++ 'threshold_filter' : files('vf_threshold.asm'), ++ 'tinterlace_filter' : files('vf_interlace.asm'), ++ 'transpose_filter' : files('vf_transpose.asm'), ++ 'v360_filter' : files('vf_v360.asm'), ++ 'volume_filter' : files('af_volume.asm'), ++ 'w3fdif_filter' : files('vf_w3fdif.asm'), ++ 'yadif_filter' : files('vf_yadif.asm','yadif-16.asm','yadif-10.asm'), ++} ++ ++libavfilter_x86_armv5te_optional_sources = { ++} ++ ++libavfilter_x86_armv6_optional_sources = { ++} ++ ++libavfilter_x86_armv8_optional_sources = { ++} ++ ++libavfilter_x86_neon_optional_sources = { ++} ++ ++libavfilter_x86_vfp_optional_sources = { ++} ++ ++libavfilter_x86_mmx_optional_sources = { ++} ++ ++libavfilter_x86_shlib_optional_sources = { ++} ++ ++libavfilter_x86_slib_optional_sources = { ++} ++ ++libavfilter_x86_optional_tests = { ++} ++ ++#### --- END GENERATED --- #### ++ ++# This file results in empty codegen and empty PDB generation otherwise. ++# https://bugzilla.nasm.us/show_bug.cgi?id=3392738 ++# https://developercommunity.visualstudio.com/t/MSVC-Hangs-when-compiling-ffmpeg-When-l/10233953 ++if conf.get('x86_64', 0) == 1 ++ # Alternatively, ++ # panic: ../libavcodec/x86/simple_idct10.asm: assertion cv8_state.source_files != NULL failed at output/codeview.c:512 ++ libavfilter_x86_x86asm_optional_sources += { ++ 'atadenoise_filter': libavfilter_x86_x86asm_optional_sources ['atadenoise_filter'] + files('vf_atadenoise.asm'), ++ } ++ libavfilter_x86_x86asm_optional_sources += { ++ 'nlmeans_filter': libavfilter_x86_x86asm_optional_sources ['nlmeans_filter'] + files('vf_nlmeans.asm'), ++ } ++endif +diff --git a/libavformat/libavformat.v.in b/libavformat/libavformat.v.in +new file mode 100644 +index 0000000000..a4557a0c1b +--- /dev/null ++++ b/libavformat/libavformat.v.in +@@ -0,0 +1,6 @@ ++LIBAVFORMAT_@majorver@ { ++ global: ++ av*; ++ local: ++ *; ++}; +diff --git a/libavformat/meson.build b/libavformat/meson.build +new file mode 100644 +index 0000000000..0335c5ba09 +--- /dev/null ++++ b/libavformat/meson.build +@@ -0,0 +1,707 @@ ++kwargs = {'prefix': '#include "libavformat/version.h"'} + get_version_define_kwargs ++ ++libavformat_majorver = cc.get_define('LIBAVFORMAT_VERSION_MAJOR', kwargs: kwargs) ++minorver = cc.get_define('LIBAVFORMAT_VERSION_MINOR', kwargs: kwargs) ++microver = cc.get_define('LIBAVFORMAT_VERSION_MICRO', kwargs: kwargs) ++ ++libavformat_version = f'@libavformat_majorver@.@minorver@.@microver@' ++ ++#### --- GENERATED --- #### ++ ++libavformat_sources = files( ++ 'allformats.c', ++ 'avformat.c', ++ 'avio.c', ++ 'aviobuf.c', ++ 'demux.c', ++ 'demux_utils.c', ++ 'dump.c', ++ 'dv.c', ++ 'format.c', ++ 'id3v1.c', ++ 'id3v2.c', ++ 'isom_tags.c', ++ 'metadata.c', ++ 'mux.c', ++ 'mux_utils.c', ++ 'options.c', ++ 'os_support.c', ++ 'protocols.c', ++ 'riff.c', ++ 'sdp.c', ++ 'seek.c', ++ 'url.c', ++ 'utils.c', ++ 'version.c', ++) ++ ++libavformat_headers = files( ++ 'avformat.h', ++ 'avio.h', ++ 'version.h', ++ 'version_major.h', ++) ++ ++libavformat_optional_sources = { ++ 'a64_muxer' : files('a64.c','rawenc.c'), ++ 'aac_demuxer' : files('aacdec.c','apetag.c','img2.c','rawdec.c'), ++ 'aax_demuxer' : files('aaxdec.c'), ++ 'aa_demuxer' : files('aadec.c'), ++ 'ac3_demuxer' : files('ac3dec.c','rawdec.c'), ++ 'ac3_muxer' : files('rawenc.c'), ++ 'ace_demuxer' : files('acedec.c'), ++ 'acm_demuxer' : files('acm.c','rawdec.c'), ++ 'act_demuxer' : files('act.c'), ++ 'adf_demuxer' : files('bintext.c','sauce.c'), ++ 'adp_demuxer' : files('adp.c'), ++ 'ads_demuxer' : files('ads.c'), ++ 'adts_muxer' : files('adtsenc.c','apetag.c','img2.c','id3v2enc.c'), ++ 'adx_demuxer' : files('adxdec.c'), ++ 'adx_muxer' : files('rawenc.c'), ++ 'aea_demuxer' : files('aea.c','pcm.c'), ++ 'afc_demuxer' : files('afc.c'), ++ 'aiff_demuxer' : files('aiffdec.c','aiff.c','pcm.c','mov_chan.c','replaygain.c'), ++ 'aiff_muxer' : files('aiffenc.c','aiff.c','id3v2enc.c'), ++ 'aix_demuxer' : files('aixdec.c'), ++ 'alp_demuxer' : files('alp.c'), ++ 'alp_muxer' : files('alp.c','rawenc.c'), ++ 'amrnb_demuxer' : files('amr.c','rawdec.c'), ++ 'amrwb_demuxer' : files('amr.c','rawdec.c'), ++ 'amr_demuxer' : files('amr.c','rawdec.c'), ++ 'amr_muxer' : files('amr.c','rawenc.c'), ++ 'amv_muxer' : files('amvenc.c'), ++ 'anm_demuxer' : files('anm.c'), ++ 'apac_demuxer' : files('apac.c','rawdec.c'), ++ 'apc_demuxer' : files('apc.c'), ++ 'ape_demuxer' : files('ape.c','apetag.c','img2.c'), ++ 'apm_demuxer' : files('apm.c'), ++ 'apm_muxer' : files('apm.c','rawenc.c'), ++ 'apng_demuxer' : files('apngdec.c'), ++ 'apng_muxer' : files('apngenc.c'), ++ 'applehttp_protocol' : files('hlsproto.c'), ++ 'aptx_demuxer' : files('aptxdec.c'), ++ 'aptx_hd_demuxer' : files('aptxdec.c'), ++ 'aptx_hd_muxer' : files('rawenc.c'), ++ 'aptx_muxer' : files('rawenc.c'), ++ 'aqtitle_demuxer' : files('aqtitledec.c','subtitles.c'), ++ 'argo_asf_demuxer' : files('argo_asf.c'), ++ 'argo_asf_muxer' : files('argo_asf.c'), ++ 'argo_brp_demuxer' : files('argo_brp.c','argo_asf.c'), ++ 'argo_cvg_demuxer' : files('argo_cvg.c'), ++ 'argo_cvg_muxer' : files('argo_cvg.c'), ++ 'asf_demuxer' : files('asfdec_f.c','asf.c','asfcrypt.c','asf_tags.c','avlanguage.c'), ++ 'asf_muxer' : files('asfenc.c','asf.c','avlanguage.c'), ++ 'asf_o_demuxer' : files('asfdec_o.c','asf.c','asfcrypt.c','asf_tags.c','avlanguage.c'), ++ 'ass_demuxer' : files('assdec.c','subtitles.c'), ++ 'ass_muxer' : files('assenc.c'), ++ 'ast_demuxer' : files('ast.c','astdec.c'), ++ 'ast_muxer' : files('ast.c','astenc.c'), ++ 'async_protocol' : files('async.c'), ++ 'au_demuxer' : files('au.c','pcm.c'), ++ 'au_muxer' : files('au.c','rawenc.c'), ++ 'av1_demuxer' : files('av1dec.c'), ++ 'avisynth_demuxer' : files('avisynth.c'), ++ 'avi_demuxer' : files('avidec.c'), ++ 'avi_muxer' : files('avienc.c','mpegtsenc.c','avlanguage.c','rawutils.c'), ++ 'avm2_muxer' : files('swfenc.c','swf.c'), ++ 'avr_demuxer' : files('avr.c','pcm.c'), ++ 'avs2_demuxer' : files('avs2dec.c','rawdec.c'), ++ 'avs2_muxer' : files('rawenc.c'), ++ 'avs3_demuxer' : files('avs3dec.c','rawdec.c'), ++ 'avs3_muxer' : files('rawenc.c'), ++ 'avs_demuxer' : files('avs.c','voc_packet.c','voc.c'), ++ 'bethsoftvid_demuxer' : files('bethsoftvid.c'), ++ 'bfi_demuxer' : files('bfi.c'), ++ 'bfstm_demuxer' : files('brstm.c'), ++ 'binka_demuxer' : files('binka.c'), ++ 'bink_demuxer' : files('bink.c'), ++ 'bintext_demuxer' : files('bintext.c','sauce.c'), ++ 'bitpacked_demuxer' : files('rawvideodec.c'), ++ 'bit_demuxer' : files('bit.c'), ++ 'bit_muxer' : files('bit.c'), ++ 'bluray_protocol' : files('bluray.c'), ++ 'bmv_demuxer' : files('bmv.c'), ++ 'boa_demuxer' : files('boadec.c'), ++ 'bonk_demuxer' : files('bonk.c','rawdec.c'), ++ 'brstm_demuxer' : files('brstm.c'), ++ 'c93_demuxer' : files('c93.c','voc_packet.c','voc.c'), ++ 'cache_protocol' : files('cache.c'), ++ 'caf_demuxer' : files('cafdec.c','caf.c','mov_chan.c','mov_esds.c'), ++ 'caf_muxer' : files('cafenc.c','caf.c','riff.c'), ++ 'cavsvideo_demuxer' : files('cavsvideodec.c','rawdec.c'), ++ 'cavsvideo_muxer' : files('rawenc.c'), ++ 'cdg_demuxer' : files('cdg.c'), ++ 'cdxl_demuxer' : files('cdxl.c'), ++ 'chromaprint_muxer' : files('chromaprint.c'), ++ 'cine_demuxer' : files('cinedec.c'), ++ 'codec2raw_demuxer' : files('codec2.c','pcm.c'), ++ 'codec2raw_muxer' : files('rawenc.c'), ++ 'codec2_demuxer' : files('codec2.c','pcm.c'), ++ 'codec2_muxer' : files('codec2.c','rawenc.c'), ++ 'concatf_protocol' : files('concat.c'), ++ 'concat_demuxer' : files('concatdec.c'), ++ 'concat_protocol' : files('concat.c'), ++ 'crc_muxer' : files('crcenc.c'), ++ 'crypto_protocol' : files('crypto.c'), ++ 'dash_demuxer' : files('dash.c','dashdec.c'), ++ 'dash_muxer' : files('dash.c','dashenc.c','hlsplaylist.c'), ++ 'data_demuxer' : files('rawdec.c'), ++ 'data_muxer' : files('rawenc.c'), ++ 'data_protocol' : files('data_uri.c'), ++ 'daud_demuxer' : files('dauddec.c'), ++ 'daud_muxer' : files('daudenc.c'), ++ 'dcstr_demuxer' : files('dcstr.c'), ++ 'derf_demuxer' : files('derf.c','pcm.c'), ++ 'dfa_demuxer' : files('dfa.c'), ++ 'dfpwm_demuxer' : files('dfpwmdec.c','pcm.c'), ++ 'dfpwm_muxer' : files('rawenc.c'), ++ 'dhav_demuxer' : files('dhav.c'), ++ 'dirac_demuxer' : files('diracdec.c','rawdec.c'), ++ 'dirac_muxer' : files('rawenc.c'), ++ 'dnxhd_demuxer' : files('dnxhddec.c','rawdec.c'), ++ 'dnxhd_muxer' : files('rawenc.c'), ++ 'dsf_demuxer' : files('dsfdec.c'), ++ 'dsicin_demuxer' : files('dsicin.c'), ++ 'dss_demuxer' : files('dss.c'), ++ 'dtshd_demuxer' : files('dtshddec.c'), ++ 'dts_demuxer' : files('dtsdec.c','rawdec.c'), ++ 'dts_muxer' : files('rawenc.c'), ++ 'dvbsub_demuxer' : files('dvbsub.c','rawdec.c'), ++ 'dvbtxt_demuxer' : files('dvbtxt.c','rawdec.c'), ++ 'dv_muxer' : files('dvenc.c'), ++ 'dxa_demuxer' : files('dxa.c'), ++ 'eac3_demuxer' : files('ac3dec.c','rawdec.c'), ++ 'eac3_muxer' : files('rawenc.c'), ++ 'ea_cdata_demuxer' : files('eacdata.c'), ++ 'ea_demuxer' : files('electronicarts.c'), ++ 'epaf_demuxer' : files('epafdec.c','pcm.c'), ++ 'fd_protocol' : files('file.c'), ++ 'ffmetadata_demuxer' : files('ffmetadec.c'), ++ 'ffmetadata_muxer' : files('ffmetaenc.c'), ++ 'ffrtmpcrypt_protocol' : files('rtmpcrypt.c','rtmpdigest.c','rtmpdh.c'), ++ 'ffrtmphttp_protocol' : files('rtmphttp.c'), ++ 'fifo_muxer' : files('fifo.c'), ++ 'fifo_test_muxer' : files('fifo_test.c'), ++ 'file_protocol' : files('file.c'), ++ 'filmstrip_demuxer' : files('filmstripdec.c'), ++ 'filmstrip_muxer' : files('filmstripenc.c','rawenc.c'), ++ 'fits_demuxer' : files('fitsdec.c'), ++ 'fits_muxer' : files('fitsenc.c'), ++ 'flac_demuxer' : files('flacdec.c','rawdec.c','flac_picture.c','oggparsevorbis.c','replaygain.c','vorbiscomment.c'), ++ 'flac_muxer' : files('flacenc.c','flacenc_header.c','vorbiscomment.c'), ++ 'flic_demuxer' : files('flic.c'), ++ 'flv_demuxer' : files('flvdec.c'), ++ 'flv_muxer' : files('flvenc.c','avc.c'), ++ 'fourxm_demuxer' : files('4xm.c'), ++ 'framecrc_muxer' : files('framecrcenc.c','framehash.c'), ++ 'framehash_muxer' : files('hashenc.c','framehash.c'), ++ 'framemd5_muxer' : files('hashenc.c','framehash.c'), ++ 'frm_demuxer' : files('frmdec.c'), ++ 'fsb_demuxer' : files('fsb.c'), ++ 'ftp_protocol' : files('ftp.c','urldecode.c'), ++ 'fwse_demuxer' : files('fwse.c','pcm.c'), ++ 'g722_demuxer' : files('g722.c','rawdec.c'), ++ 'g722_muxer' : files('rawenc.c'), ++ 'g723_1_demuxer' : files('g723_1.c'), ++ 'g723_1_muxer' : files('rawenc.c'), ++ 'g726le_demuxer' : files('g726.c'), ++ 'g726le_muxer' : files('rawenc.c'), ++ 'g726_demuxer' : files('g726.c'), ++ 'g726_muxer' : files('rawenc.c'), ++ 'g729_demuxer' : files('g729dec.c'), ++ 'gdv_demuxer' : files('gdv.c'), ++ 'genh_demuxer' : files('genh.c'), ++ 'gif_demuxer' : files('gifdec.c'), ++ 'gif_muxer' : files('gif.c'), ++ 'gnutls' : files('tls_gnutls.c'), ++ 'gophers_protocol' : files('gopher.c'), ++ 'gopher_protocol' : files('gopher.c'), ++ 'gsm_demuxer' : files('gsmdec.c'), ++ 'gsm_muxer' : files('rawenc.c'), ++ 'gxf_demuxer' : files('gxf.c'), ++ 'gxf_muxer' : files('gxfenc.c'), ++ 'h261_demuxer' : files('h261dec.c','rawdec.c'), ++ 'h261_muxer' : files('rawenc.c'), ++ 'h263_demuxer' : files('h263dec.c','rawdec.c'), ++ 'h263_muxer' : files('rawenc.c'), ++ 'h264_demuxer' : files('h264dec.c','rawdec.c'), ++ 'h264_muxer' : files('rawenc.c'), ++ 'hash_muxer' : files('hashenc.c'), ++ 'hca_demuxer' : files('hca.c'), ++ 'hcom_demuxer' : files('hcom.c','pcm.c'), ++ 'hds_muxer' : files('hdsenc.c'), ++ 'hevc_demuxer' : files('hevcdec.c','rawdec.c'), ++ 'hevc_muxer' : files('rawenc.c'), ++ 'hls_demuxer' : files('hls.c','hls_sample_encryption.c'), ++ 'hls_muxer' : files('hlsenc.c','hlsplaylist.c','avc.c'), ++ 'hls_protocol' : files('hlsproto.c'), ++ 'hnm_demuxer' : files('hnm.c'), ++ 'httpproxy_protocol' : files('http.c','httpauth.c','urldecode.c'), ++ 'https_protocol' : files('http.c','httpauth.c','urldecode.c'), ++ 'http_protocol' : files('http.c','httpauth.c','urldecode.c'), ++ 'icecast_protocol' : files('icecast.c'), ++ 'ico_demuxer' : files('icodec.c'), ++ 'ico_muxer' : files('icoenc.c'), ++ 'idcin_demuxer' : files('idcin.c'), ++ 'idf_demuxer' : files('bintext.c','sauce.c'), ++ 'iff_demuxer' : files('iff.c'), ++ 'ifv_demuxer' : files('ifv.c'), ++ 'ilbc_demuxer' : files('ilbc.c'), ++ 'ilbc_muxer' : files('ilbc.c','rawenc.c'), ++ 'image2pipe_demuxer' : files('img2dec.c','img2.c'), ++ 'image2pipe_muxer' : files('img2enc.c','img2.c'), ++ 'image2_alias_pix_demuxer' : files('img2_alias_pix.c'), ++ 'image2_brender_pix_demuxer' : files('img2_brender_pix.c'), ++ 'image2_demuxer' : files('img2dec.c','img2.c'), ++ 'image2_muxer' : files('img2enc.c','img2.c'), ++ 'image_bmp_pipe_demuxer' : files('img2dec.c','img2.c'), ++ 'image_cri_pipe_demuxer' : files('img2dec.c','img2.c'), ++ 'image_dds_pipe_demuxer' : files('img2dec.c','img2.c'), ++ 'image_dpx_pipe_demuxer' : files('img2dec.c','img2.c'), ++ 'image_exr_pipe_demuxer' : files('img2dec.c','img2.c'), ++ 'image_gem_pipe_demuxer' : files('img2dec.c','img2.c'), ++ 'image_gif_pipe_demuxer' : files('img2dec.c','img2.c'), ++ 'image_hdr_pipe_demuxer' : files('img2dec.c','img2.c'), ++ 'image_j2k_pipe_demuxer' : files('img2dec.c','img2.c'), ++ 'image_jpegls_pipe_demuxer' : files('img2dec.c','img2.c'), ++ 'image_jpegxl_pipe_demuxer' : files('img2dec.c','img2.c','jpegxl_probe.c'), ++ 'image_jpeg_pipe_demuxer' : files('img2dec.c','img2.c'), ++ 'image_pam_pipe_demuxer' : files('img2dec.c','img2.c'), ++ 'image_pbm_pipe_demuxer' : files('img2dec.c','img2.c'), ++ 'image_pcx_pipe_demuxer' : files('img2dec.c','img2.c'), ++ 'image_pfm_pipe_demuxer' : files('img2dec.c','img2.c'), ++ 'image_pgmyuv_pipe_demuxer' : files('img2dec.c','img2.c'), ++ 'image_pgm_pipe_demuxer' : files('img2dec.c','img2.c'), ++ 'image_pgx_pipe_demuxer' : files('img2dec.c','img2.c'), ++ 'image_phm_pipe_demuxer' : files('img2dec.c','img2.c'), ++ 'image_photocd_pipe_demuxer' : files('img2dec.c','img2.c'), ++ 'image_pictor_pipe_demuxer' : files('img2dec.c','img2.c'), ++ 'image_png_pipe_demuxer' : files('img2dec.c','img2.c'), ++ 'image_ppm_pipe_demuxer' : files('img2dec.c','img2.c'), ++ 'image_psd_pipe_demuxer' : files('img2dec.c','img2.c'), ++ 'image_qdraw_pipe_demuxer' : files('img2dec.c','img2.c'), ++ 'image_qoi_pipe_demuxer' : files('img2dec.c','img2.c'), ++ 'image_sgi_pipe_demuxer' : files('img2dec.c','img2.c'), ++ 'image_sunrast_pipe_demuxer' : files('img2dec.c','img2.c'), ++ 'image_svg_pipe_demuxer' : files('img2dec.c','img2.c'), ++ 'image_tiff_pipe_demuxer' : files('img2dec.c','img2.c'), ++ 'image_webp_pipe_demuxer' : files('img2dec.c','img2.c'), ++ 'image_xbm_pipe_demuxer' : files('img2dec.c','img2.c'), ++ 'image_xpm_pipe_demuxer' : files('img2dec.c','img2.c'), ++ 'image_xwd_pipe_demuxer' : files('img2dec.c','img2.c'), ++ 'imf_demuxer' : files('imfdec.c','imf_cpl.c'), ++ 'ingenient_demuxer' : files('ingenientdec.c','rawdec.c'), ++ 'ipfs_gateway_protocol' : files('ipfsgateway.c'), ++ 'ipmovie_demuxer' : files('ipmovie.c'), ++ 'ipns_gateway_protocol' : files('ipfsgateway.c'), ++ 'ipu_demuxer' : files('ipudec.c','rawdec.c'), ++ 'ircam_demuxer' : files('ircamdec.c','ircam.c','pcm.c'), ++ 'ircam_muxer' : files('ircamenc.c','ircam.c','rawenc.c'), ++ 'iso_media' : files('isom.c'), ++ 'iss_demuxer' : files('iss.c'), ++ 'iv8_demuxer' : files('iv8.c'), ++ 'ivf_demuxer' : files('ivfdec.c'), ++ 'ivf_muxer' : files('ivfenc.c'), ++ 'ivr_demuxer' : files('rmdec.c','rm.c','rmsipr.c'), ++ 'jacosub_demuxer' : files('jacosubdec.c','subtitles.c'), ++ 'jacosub_muxer' : files('jacosubenc.c','rawenc.c'), ++ 'jv_demuxer' : files('jvdec.c'), ++ 'kux_demuxer' : files('flvdec.c'), ++ 'kvag_demuxer' : files('kvag.c'), ++ 'kvag_muxer' : files('kvag.c','rawenc.c'), ++ 'laf_demuxer' : files('lafdec.c'), ++ 'latm_muxer' : files('latmenc.c','rawenc.c'), ++ 'libamqp_protocol' : files('libamqp.c','urldecode.c'), ++ 'libc_msvcrt' : files('file_open.c'), ++ 'libgme_demuxer' : files('libgme.c'), ++ 'libmodplug_demuxer' : files('libmodplug.c'), ++ 'libopenmpt_demuxer' : files('libopenmpt.c'), ++ 'librist_protocol' : files('librist.c'), ++ 'librtmpe_protocol' : files('librtmp.c'), ++ 'librtmps_protocol' : files('librtmp.c'), ++ 'librtmpte_protocol' : files('librtmp.c'), ++ 'librtmpt_protocol' : files('librtmp.c'), ++ 'librtmp_protocol' : files('librtmp.c'), ++ 'libsmbclient_protocol' : files('libsmbclient.c'), ++ 'libsrt_protocol' : files('libsrt.c'), ++ 'libssh_protocol' : files('libssh.c'), ++ 'libtls' : files('tls_libtls.c'), ++ 'libzmq_protocol' : files('libzmq.c'), ++ 'live_flv_demuxer' : files('flvdec.c'), ++ 'lmlm4_demuxer' : files('lmlm4.c'), ++ 'loas_demuxer' : files('loasdec.c','rawdec.c'), ++ 'lrc_demuxer' : files('lrcdec.c','lrc.c','subtitles.c'), ++ 'lrc_muxer' : files('lrcenc.c','lrc.c'), ++ 'luodat_demuxer' : files('luodatdec.c'), ++ 'lvf_demuxer' : files('lvfdec.c'), ++ 'lxf_demuxer' : files('lxfdec.c'), ++ 'm4v_demuxer' : files('m4vdec.c','rawdec.c'), ++ 'm4v_muxer' : files('rawenc.c'), ++ 'matroska_demuxer' : files('matroskadec.c','matroska.c','flac_picture.c','rmsipr.c','oggparsevorbis.c','vorbiscomment.c','qtpalette.c','replaygain.c','dovi_isom.c'), ++ 'matroska_muxer' : files('matroskaenc.c','matroska.c','av1.c','avc.c','hevc.c','flacenc_header.c','avlanguage.c','vorbiscomment.c','wv.c','dovi_isom.c'), ++ 'mbedtls' : files('tls_mbedtls.c'), ++ 'mca_demuxer' : files('mca.c'), ++ 'mcc_demuxer' : files('mccdec.c','subtitles.c'), ++ 'md5_muxer' : files('hashenc.c'), ++ 'md5_protocol' : files('md5proto.c'), ++ 'mgsts_demuxer' : files('mgsts.c'), ++ 'microdvd_demuxer' : files('microdvddec.c','subtitles.c'), ++ 'microdvd_muxer' : files('microdvdenc.c'), ++ 'mjpeg_2000_demuxer' : files('rawdec.c','mj2kdec.c'), ++ 'mjpeg_demuxer' : files('rawdec.c'), ++ 'mjpeg_muxer' : files('rawenc.c'), ++ 'mkvtimestamp_v2_muxer' : files('mkvtimestamp_v2.c'), ++ 'mlp_demuxer' : files('rawdec.c','mlpdec.c'), ++ 'mlp_muxer' : files('rawenc.c'), ++ 'mlv_demuxer' : files('mlvdec.c','riffdec.c'), ++ 'mmf_demuxer' : files('mmf.c'), ++ 'mmf_muxer' : files('mmf.c','rawenc.c'), ++ 'mmsh_protocol' : files('mmsh.c','mms.c','asf_tags.c'), ++ 'mmst_protocol' : files('mmst.c','mms.c','asf_tags.c'), ++ 'mm_demuxer' : files('mm.c'), ++ 'mods_demuxer' : files('mods.c'), ++ 'moflex_demuxer' : files('moflex.c'), ++ 'mov_demuxer' : files('mov.c','mov_chan.c','mov_esds.c','qtpalette.c','replaygain.c','dovi_isom.c'), ++ 'mov_muxer' : files('movenc.c','av1.c','avc.c','hevc.c','vpcc.c','movenchint.c','mov_chan.c','rtp.c','movenccenc.c','movenc_ttml.c','rawutils.c','dovi_isom.c'), ++ 'mp2_muxer' : files('rawenc.c'), ++ 'mp3_demuxer' : files('mp3dec.c','replaygain.c'), ++ 'mp3_muxer' : files('mp3enc.c','rawenc.c','id3v2enc.c'), ++ 'mpc8_demuxer' : files('mpc8.c','apetag.c','img2.c'), ++ 'mpc_demuxer' : files('mpc.c','apetag.c','img2.c'), ++ 'mpeg1system_muxer' : files('mpegenc.c'), ++ 'mpeg1vcd_muxer' : files('mpegenc.c'), ++ 'mpeg1video_muxer' : files('rawenc.c'), ++ 'mpeg2dvd_muxer' : files('mpegenc.c'), ++ 'mpeg2svcd_muxer' : files('mpegenc.c'), ++ 'mpeg2video_muxer' : files('rawenc.c'), ++ 'mpeg2vob_muxer' : files('mpegenc.c'), ++ 'mpegps_demuxer' : files('mpeg.c'), ++ 'mpegts_demuxer' : files('mpegts.c'), ++ 'mpegts_muxer' : files('mpegtsenc.c'), ++ 'mpegvideo_demuxer' : files('mpegvideodec.c','rawdec.c'), ++ 'mpjpeg_demuxer' : files('mpjpegdec.c'), ++ 'mpjpeg_muxer' : files('mpjpeg.c'), ++ 'mpl2_demuxer' : files('mpl2dec.c','subtitles.c'), ++ 'mpsub_demuxer' : files('mpsubdec.c','subtitles.c'), ++ 'msf_demuxer' : files('msf.c'), ++ 'msnwc_tcp_demuxer' : files('msnwc_tcp.c'), ++ 'msp_demuxer' : files('mspdec.c'), ++ 'mtaf_demuxer' : files('mtaf.c'), ++ 'mtv_demuxer' : files('mtv.c'), ++ 'musx_demuxer' : files('musx.c'), ++ 'mvi_demuxer' : files('mvi.c'), ++ 'mv_demuxer' : files('mvdec.c'), ++ 'mxf_demuxer' : files('mxfdec.c','mxf.c','avlanguage.c'), ++ 'mxf_muxer' : files('mxfenc.c','mxf.c','avc.c'), ++ 'mxg_demuxer' : files('mxg.c'), ++ 'nc_demuxer' : files('ncdec.c'), ++ 'network' : files('network.c'), ++ 'nistsphere_demuxer' : files('nistspheredec.c','pcm.c'), ++ 'nsp_demuxer' : files('nspdec.c','pcm.c'), ++ 'nsv_demuxer' : files('nsvdec.c'), ++ 'null_muxer' : files('nullenc.c'), ++ 'nut_demuxer' : files('nutdec.c','nut.c'), ++ 'nut_muxer' : files('nutenc.c','nut.c'), ++ 'nuv_demuxer' : files('nuv.c'), ++ 'obu_demuxer' : files('av1dec.c'), ++ 'obu_muxer' : files('rawenc.c'), ++ 'oga_muxer' : files('oggenc.c','vorbiscomment.c'), ++ 'ogg_demuxer' : files('oggdec.c','oggparsecelt.c','oggparsedirac.c','oggparseflac.c','oggparseogm.c','oggparseopus.c','oggparseskeleton.c','oggparsespeex.c','oggparsetheora.c','oggparsevorbis.c','oggparsevp8.c','replaygain.c','vorbiscomment.c','flac_picture.c'), ++ 'ogg_muxer' : files('oggenc.c','vorbiscomment.c'), ++ 'ogv_muxer' : files('oggenc.c','vorbiscomment.c'), ++ 'oma_demuxer' : files('omadec.c','pcm.c','oma.c'), ++ 'oma_muxer' : files('omaenc.c','rawenc.c','oma.c','id3v2enc.c'), ++ 'openssl' : files('tls_openssl.c'), ++ 'opus_muxer' : files('oggenc.c','vorbiscomment.c'), ++ 'paf_demuxer' : files('paf.c'), ++ 'pcm_alaw_demuxer' : files('pcmdec.c','pcm.c'), ++ 'pcm_alaw_muxer' : files('pcmenc.c','rawenc.c'), ++ 'pcm_f32be_demuxer' : files('pcmdec.c','pcm.c'), ++ 'pcm_f32be_muxer' : files('pcmenc.c','rawenc.c'), ++ 'pcm_f32le_demuxer' : files('pcmdec.c','pcm.c'), ++ 'pcm_f32le_muxer' : files('pcmenc.c','rawenc.c'), ++ 'pcm_f64be_demuxer' : files('pcmdec.c','pcm.c'), ++ 'pcm_f64be_muxer' : files('pcmenc.c','rawenc.c'), ++ 'pcm_f64le_demuxer' : files('pcmdec.c','pcm.c'), ++ 'pcm_f64le_muxer' : files('pcmenc.c','rawenc.c'), ++ 'pcm_mulaw_demuxer' : files('pcmdec.c','pcm.c'), ++ 'pcm_mulaw_muxer' : files('pcmenc.c','rawenc.c'), ++ 'pcm_s16be_demuxer' : files('pcmdec.c','pcm.c'), ++ 'pcm_s16be_muxer' : files('pcmenc.c','rawenc.c'), ++ 'pcm_s16le_demuxer' : files('pcmdec.c','pcm.c'), ++ 'pcm_s16le_muxer' : files('pcmenc.c','rawenc.c'), ++ 'pcm_s24be_demuxer' : files('pcmdec.c','pcm.c'), ++ 'pcm_s24be_muxer' : files('pcmenc.c','rawenc.c'), ++ 'pcm_s24le_demuxer' : files('pcmdec.c','pcm.c'), ++ 'pcm_s24le_muxer' : files('pcmenc.c','rawenc.c'), ++ 'pcm_s32be_demuxer' : files('pcmdec.c','pcm.c'), ++ 'pcm_s32be_muxer' : files('pcmenc.c','rawenc.c'), ++ 'pcm_s32le_demuxer' : files('pcmdec.c','pcm.c'), ++ 'pcm_s32le_muxer' : files('pcmenc.c','rawenc.c'), ++ 'pcm_s8_demuxer' : files('pcmdec.c','pcm.c'), ++ 'pcm_s8_muxer' : files('pcmenc.c','rawenc.c'), ++ 'pcm_u16be_demuxer' : files('pcmdec.c','pcm.c'), ++ 'pcm_u16be_muxer' : files('pcmenc.c','rawenc.c'), ++ 'pcm_u16le_demuxer' : files('pcmdec.c','pcm.c'), ++ 'pcm_u16le_muxer' : files('pcmenc.c','rawenc.c'), ++ 'pcm_u24be_demuxer' : files('pcmdec.c','pcm.c'), ++ 'pcm_u24be_muxer' : files('pcmenc.c','rawenc.c'), ++ 'pcm_u24le_demuxer' : files('pcmdec.c','pcm.c'), ++ 'pcm_u24le_muxer' : files('pcmenc.c','rawenc.c'), ++ 'pcm_u32be_demuxer' : files('pcmdec.c','pcm.c'), ++ 'pcm_u32be_muxer' : files('pcmenc.c','rawenc.c'), ++ 'pcm_u32le_demuxer' : files('pcmdec.c','pcm.c'), ++ 'pcm_u32le_muxer' : files('pcmenc.c','rawenc.c'), ++ 'pcm_u8_demuxer' : files('pcmdec.c','pcm.c'), ++ 'pcm_u8_muxer' : files('pcmenc.c','rawenc.c'), ++ 'pcm_vidc_demuxer' : files('pcmdec.c','pcm.c'), ++ 'pcm_vidc_muxer' : files('pcmenc.c','rawenc.c'), ++ 'pipe_protocol' : files('file.c'), ++ 'pjs_demuxer' : files('pjsdec.c','subtitles.c'), ++ 'pmp_demuxer' : files('pmpdec.c'), ++ 'pp_bnk_demuxer' : files('pp_bnk.c'), ++ 'prompeg_protocol' : files('prompeg.c'), ++ 'pva_demuxer' : files('pva.c'), ++ 'pvf_demuxer' : files('pvfdec.c','pcm.c'), ++ 'qcp_demuxer' : files('qcp.c'), ++ 'r3d_demuxer' : files('r3d.c'), ++ 'rawvideo_demuxer' : files('rawvideodec.c'), ++ 'rawvideo_muxer' : files('rawenc.c'), ++ 'realtext_demuxer' : files('realtextdec.c','subtitles.c'), ++ 'redspark_demuxer' : files('redspark.c'), ++ 'riffdec' : files('riffdec.c'), ++ 'riffenc' : files('riffenc.c'), ++ 'rka_demuxer' : files('rka.c','apetag.c','img2.c'), ++ 'rl2_demuxer' : files('rl2.c'), ++ 'rm_demuxer' : files('rmdec.c','rm.c','rmsipr.c'), ++ 'rm_muxer' : files('rmenc.c','rm.c'), ++ 'roq_demuxer' : files('idroqdec.c'), ++ 'roq_muxer' : files('idroqenc.c','rawenc.c'), ++ 'rpl_demuxer' : files('rpl.c'), ++ 'rsd_demuxer' : files('rsd.c'), ++ 'rso_demuxer' : files('rsodec.c','rso.c','pcm.c'), ++ 'rso_muxer' : files('rsoenc.c','rso.c','rawenc.c'), ++ 'rtmpe_protocol' : files('rtmpproto.c','rtmpdigest.c','rtmppkt.c'), ++ 'rtmps_protocol' : files('rtmpproto.c','rtmpdigest.c','rtmppkt.c'), ++ 'rtmpte_protocol' : files('rtmpproto.c','rtmpdigest.c','rtmppkt.c'), ++ 'rtmpts_protocol' : files('rtmpproto.c','rtmpdigest.c','rtmppkt.c'), ++ 'rtmpt_protocol' : files('rtmpproto.c','rtmpdigest.c','rtmppkt.c'), ++ 'rtmp_protocol' : files('rtmpproto.c','rtmpdigest.c','rtmppkt.c'), ++ 'rtpdec' : files('rdt.c','rtp.c','rtpdec.c','rtpdec_ac3.c','rtpdec_amr.c','rtpdec_asf.c','rtpdec_dv.c','rtpdec_g726.c','rtpdec_h261.c','rtpdec_h263.c','rtpdec_h263_rfc2190.c','rtpdec_h264.c','rtpdec_hevc.c','rtpdec_ilbc.c','rtpdec_jpeg.c','rtpdec_latm.c','rtpdec_mpa_robust.c','rtpdec_mpeg12.c','rtpdec_mpeg4.c','rtpdec_mpegts.c','rtpdec_qcelp.c','rtpdec_qdm2.c','rtpdec_qt.c','rtpdec_rfc4175.c','rtpdec_svq3.c','rtpdec_vc2hq.c','rtpdec_vp8.c','rtpdec_vp9.c','rtpdec_xiph.c'), ++ 'rtpenc_chain' : files('rtpenc_chain.c','rtp.c'), ++ 'rtp_mpegts_muxer' : files('rtpenc_mpegts.c'), ++ 'rtp_muxer' : files('rtp.c','rtpenc_aac.c','rtpenc_latm.c','rtpenc_amr.c','rtpenc_h261.c','rtpenc_h263.c','rtpenc_h263_rfc2190.c','rtpenc_h264_hevc.c','rtpenc_jpeg.c','rtpenc_mpv.c','rtpenc.c','rtpenc_rfc4175.c','rtpenc_vc2hq.c','rtpenc_vp8.c','rtpenc_vp9.c','rtpenc_xiph.c','avc.c','hevc.c'), ++ 'rtp_protocol' : files('rtpproto.c','ip.c'), ++ 'rtsp_demuxer' : files('rtsp.c','rtspdec.c','httpauth.c','urldecode.c'), ++ 'rtsp_muxer' : files('rtsp.c','rtspenc.c','httpauth.c','urldecode.c'), ++ 's337m_demuxer' : files('s337m.c','spdif.c'), ++ 'sami_demuxer' : files('samidec.c','subtitles.c'), ++ 'sap_demuxer' : files('sapdec.c'), ++ 'sap_muxer' : files('sapenc.c'), ++ 'sbc_demuxer' : files('sbcdec.c','rawdec.c'), ++ 'sbc_muxer' : files('rawenc.c'), ++ 'sbg_demuxer' : files('sbgdec.c'), ++ 'scc_demuxer' : files('sccdec.c','subtitles.c'), ++ 'scc_muxer' : files('sccenc.c'), ++ 'scd_demuxer' : files('scd.c'), ++ 'schannel' : files('tls_schannel.c'), ++ 'sctp_protocol' : files('sctp.c'), ++ 'sdns_demuxer' : files('sdns.c'), ++ 'sdp_demuxer' : files('rtsp.c'), ++ 'sdr2_demuxer' : files('sdr2.c'), ++ 'sds_demuxer' : files('sdsdec.c'), ++ 'sdx_demuxer' : files('sdxdec.c','pcm.c'), ++ 'securetransport' : files('tls_securetransport.c'), ++ 'segafilm_demuxer' : files('segafilm.c'), ++ 'segafilm_muxer' : files('segafilmenc.c'), ++ 'segment_muxer' : files('segment.c'), ++ 'ser_demuxer' : files('serdec.c'), ++ 'sga_demuxer' : files('sga.c'), ++ 'shorten_demuxer' : files('shortendec.c','rawdec.c'), ++ 'siff_demuxer' : files('siff.c'), ++ 'simbiosis_imx_demuxer' : files('imx.c'), ++ 'sln_demuxer' : files('pcmdec.c','pcm.c'), ++ 'smacker_demuxer' : files('smacker.c'), ++ 'smjpeg_demuxer' : files('smjpegdec.c','smjpeg.c'), ++ 'smjpeg_muxer' : files('smjpegenc.c','smjpeg.c'), ++ 'smoothstreaming_muxer' : files('smoothstreamingenc.c'), ++ 'smush_demuxer' : files('smush.c'), ++ 'sol_demuxer' : files('sol.c','pcm.c'), ++ 'sox_demuxer' : files('soxdec.c','pcm.c'), ++ 'sox_muxer' : files('soxenc.c','rawenc.c'), ++ 'spdif_demuxer' : files('spdif.c','spdifdec.c'), ++ 'spdif_muxer' : files('spdif.c','spdifenc.c'), ++ 'speex_muxer' : files('oggenc.c','vorbiscomment.c'), ++ 'srtp' : files('srtp.c'), ++ 'srtp_protocol' : files('srtpproto.c','srtp.c'), ++ 'srt_demuxer' : files('srtdec.c','subtitles.c'), ++ 'srt_muxer' : files('srtenc.c'), ++ 'stl_demuxer' : files('stldec.c','subtitles.c'), ++ 'streamhash_muxer' : files('hashenc.c'), ++ 'stream_segment_muxer' : files('segment.c'), ++ 'str_demuxer' : files('psxstr.c'), ++ 'subfile_protocol' : files('subfile.c'), ++ 'subviewer1_demuxer' : files('subviewer1dec.c','subtitles.c'), ++ 'subviewer_demuxer' : files('subviewerdec.c','subtitles.c'), ++ 'sup_demuxer' : files('supdec.c'), ++ 'sup_muxer' : files('supenc.c'), ++ 'svag_demuxer' : files('svag.c'), ++ 'svs_demuxer' : files('svs.c'), ++ 'swf_demuxer' : files('swfdec.c','swf.c'), ++ 'swf_muxer' : files('swfenc.c','swf.c'), ++ 'tak_demuxer' : files('takdec.c','apetag.c','img2.c','rawdec.c'), ++ 'tcp_protocol' : files('tcp.c'), ++ 'tedcaptions_demuxer' : files('tedcaptionsdec.c','subtitles.c'), ++ 'tee_muxer' : files('tee.c','tee_common.c'), ++ 'tee_protocol' : files('teeproto.c','tee_common.c'), ++ 'thp_demuxer' : files('thp.c'), ++ 'threedostr_demuxer' : files('3dostr.c'), ++ 'tiertexseq_demuxer' : files('tiertexseq.c'), ++ 'tls_protocol' : files('tls.c'), ++ 'tmv_demuxer' : files('tmv.c'), ++ 'truehd_demuxer' : files('rawdec.c','mlpdec.c'), ++ 'truehd_muxer' : files('rawenc.c'), ++ 'tta_demuxer' : files('tta.c','apetag.c','img2.c'), ++ 'tta_muxer' : files('ttaenc.c','apetag.c','img2.c'), ++ 'ttml_muxer' : files('ttmlenc.c'), ++ 'tty_demuxer' : files('tty.c','sauce.c'), ++ 'txd_demuxer' : files('txd.c'), ++ 'ty_demuxer' : files('ty.c'), ++ 'udplite_protocol' : files('udp.c','ip.c'), ++ 'udp_protocol' : files('udp.c','ip.c'), ++ 'uncodedframecrc_muxer' : files('uncodedframecrcenc.c','framehash.c'), ++ 'unix_protocol' : files('unix.c'), ++ 'v210x_demuxer' : files('rawvideodec.c'), ++ 'v210_demuxer' : files('rawvideodec.c'), ++ 'vag_demuxer' : files('vag.c'), ++ 'vapoursynth_demuxer' : files('vapoursynth.c'), ++ 'vc1t_demuxer' : files('vc1test.c'), ++ 'vc1t_muxer' : files('vc1testenc.c'), ++ 'vc1_demuxer' : files('rawdec.c','vc1dec.c'), ++ 'vc1_muxer' : files('rawenc.c'), ++ 'vividas_demuxer' : files('vividas.c'), ++ 'vivo_demuxer' : files('vivo.c'), ++ 'vmd_demuxer' : files('sierravmd.c'), ++ 'vobsub_demuxer' : files('subtitles.c'), ++ 'voc_demuxer' : files('vocdec.c','voc_packet.c','voc.c'), ++ 'voc_muxer' : files('vocenc.c','voc.c'), ++ 'vpk_demuxer' : files('vpk.c'), ++ 'vplayer_demuxer' : files('vplayerdec.c','subtitles.c'), ++ 'vqf_demuxer' : files('vqf.c'), ++ 'w64_demuxer' : files('wavdec.c','w64.c','pcm.c'), ++ 'w64_muxer' : files('wavenc.c','w64.c'), ++ 'wady_demuxer' : files('wady.c','pcm.c'), ++ 'wavarc_demuxer' : files('wavarc.c'), ++ 'wav_demuxer' : files('wavdec.c','pcm.c'), ++ 'wav_muxer' : files('wavenc.c'), ++ 'wc3_demuxer' : files('wc3movie.c'), ++ 'webm_chunk_muxer' : files('webm_chunk.c'), ++ 'webm_dash_manifest_muxer' : files('webmdashenc.c'), ++ 'webm_muxer' : files('matroskaenc.c','matroska.c','av1.c','avlanguage.c'), ++ 'webp_muxer' : files('webpenc.c'), ++ 'webvtt_demuxer' : files('webvttdec.c','subtitles.c'), ++ 'webvtt_muxer' : files('webvttenc.c'), ++ 'wsaud_demuxer' : files('westwood_aud.c'), ++ 'wsaud_muxer' : files('westwood_audenc.c'), ++ 'wsd_demuxer' : files('wsddec.c','rawdec.c'), ++ 'wsvqa_demuxer' : files('westwood_vqa.c'), ++ 'wtv_demuxer' : files('wtvdec.c','wtv_common.c','asf.c'), ++ 'wtv_muxer' : files('wtvenc.c','wtv_common.c','asf.c'), ++ 'wve_demuxer' : files('wvedec.c','pcm.c'), ++ 'wv_demuxer' : files('wvdec.c','wv.c','apetag.c','img2.c'), ++ 'wv_muxer' : files('wvenc.c','wv.c','apetag.c','img2.c'), ++ 'xa_demuxer' : files('xa.c'), ++ 'xbin_demuxer' : files('bintext.c','sauce.c'), ++ 'xmd_demuxer' : files('xmd.c','pcm.c'), ++ 'xmv_demuxer' : files('xmv.c'), ++ 'xvag_demuxer' : files('xvag.c'), ++ 'xwma_demuxer' : files('xwma.c'), ++ 'yop_demuxer' : files('yop.c'), ++ 'yuv4mpegpipe_demuxer' : files('yuv4mpegdec.c'), ++ 'yuv4mpegpipe_muxer' : files('yuv4mpegenc.c'), ++} ++ ++libavformat_x86asm_optional_sources = { ++} ++ ++libavformat_armv5te_optional_sources = { ++} ++ ++libavformat_armv6_optional_sources = { ++} ++ ++libavformat_armv8_optional_sources = { ++} ++ ++libavformat_neon_optional_sources = { ++} ++ ++libavformat_vfp_optional_sources = { ++} ++ ++libavformat_mmx_optional_sources = { ++} ++ ++libavformat_shlib_sources = files( ++ 'log2_tab.c', ++ 'to_upper4.c', ++) ++ ++libavformat_shlib_optional_sources = { ++ 'flv_muxer' : files('mpeg4audio_sample_rates.c'), ++ 'hls_demuxer' : files('ac3_channel_layout_tab.c'), ++ 'iso_media' : files('mpegaudiotabs.c'), ++ 'matroska_demuxer' : files('mpeg4audio_sample_rates.c'), ++ 'mov_demuxer' : files('ac3_channel_layout_tab.c'), ++ 'mp3_muxer' : files('mpegaudiotabs.c'), ++ 'mxf_muxer' : files('golomb_tab.c'), ++ 'nut_muxer' : files('mpegaudiotabs.c'), ++ 'rtpdec' : files('jpegtables.c'), ++ 'rtp_muxer' : files('golomb_tab.c','jpegtables.c','mpeg4audio_sample_rates.c'), ++ 'spdif_muxer' : files('dca_sample_rate_tab.c'), ++} ++ ++libavformat_slib_optional_sources = { ++} ++ ++libavformat_tests = [ ++ # MANUAL ['seek', files('tests/seek.c')], ++ ['url', files('tests/url.c')], ++ ['seek_utils', files('tests/seek_utils.c')], ++] ++ ++libavformat_optional_tests = { ++ 'ffrtmpcrypt_protocol' : [ ++ ['rtmpdh', files('tests/rtmpdh.c')], ++ ], ++ 'fifo_muxer' : [ ++ ], ++ 'imf_demuxer' : [ ++ ['imf', files('tests/imf.c')], ++ ], ++ 'mov_muxer' : [ ++ ['movenc', files('tests/movenc.c')], ++ ], ++ 'network' : [ ++ ['noproxy', files('tests/noproxy.c')], ++ ], ++ 'srtp' : [ ++ ['srtp', files('tests/srtp.c')], ++ ], ++} ++ ++#### --- END GENERATED --- #### ++ ++# Version file ++ver_conf = configuration_data() ++ver_conf.set('majorver', libavcodec_majorver) ++ver_conf.set('minorver', minorver) ++ver_conf.set('microver', microver) ++ ++install_headers(libavformat_headers, subdir: 'libavformat') ++ ++configure_file( ++ input: 'libavformat.v.in', ++ output: 'libavformat.ver', ++ configuration: ver_conf, ++) +diff --git a/libavutil/aarch64/meson.build b/libavutil/aarch64/meson.build +new file mode 100644 +index 0000000000..abf6ac6617 +--- /dev/null ++++ b/libavutil/aarch64/meson.build +@@ -0,0 +1,43 @@ ++libavutil_aarch64_sources = files( ++ 'cpu.c', ++ 'float_dsp_init.c', ++ 'tx_float_init.c', ++) ++ ++libavutil_aarch64_optional_sources = { ++} ++ ++libavutil_aarch64_x86asm_optional_sources = { ++} ++ ++libavutil_aarch64_armv5te_optional_sources = { ++} ++ ++libavutil_aarch64_armv6_optional_sources = { ++} ++ ++libavutil_aarch64_armv8_optional_sources = { ++} ++ ++libavutil_aarch64_neon_sources = files( ++ 'float_dsp_neon.S', ++ 'tx_float_neon.S', ++) ++ ++libavutil_aarch64_neon_optional_sources = { ++} ++ ++libavutil_aarch64_vfp_optional_sources = { ++} ++ ++libavutil_aarch64_mmx_optional_sources = { ++} ++ ++libavutil_aarch64_shlib_optional_sources = { ++} ++ ++libavutil_aarch64_slib_optional_sources = { ++} ++ ++libavutil_aarch64_optional_tests = { ++} +diff --git a/libavutil/arm/meson.build b/libavutil/arm/meson.build +new file mode 100644 +index 0000000000..186609dfb9 +--- /dev/null ++++ b/libavutil/arm/meson.build +@@ -0,0 +1,47 @@ ++libavutil_arm_sources = files( ++ 'cpu.c', ++ 'float_dsp_init_arm.c', ++) ++ ++libavutil_arm_optional_sources = { ++} ++ ++libavutil_arm_x86asm_optional_sources = { ++} ++ ++libavutil_arm_armv5te_optional_sources = { ++} ++ ++libavutil_arm_armv6_optional_sources = { ++} ++ ++libavutil_arm_armv8_optional_sources = { ++} ++ ++libavutil_arm_neon_sources = files( ++ 'float_dsp_init_neon.c', ++ 'float_dsp_neon.S', ++) ++ ++libavutil_arm_neon_optional_sources = { ++} ++ ++libavutil_arm_vfp_sources = files( ++ 'float_dsp_init_vfp.c', ++ 'float_dsp_vfp.S', ++) ++ ++libavutil_arm_vfp_optional_sources = { ++} ++ ++libavutil_arm_mmx_optional_sources = { ++} ++ ++libavutil_arm_shlib_optional_sources = { ++} ++ ++libavutil_arm_slib_optional_sources = { ++} ++ ++libavutil_arm_optional_tests = { ++} +diff --git a/libavutil/libavutil.v.in b/libavutil/libavutil.v.in +new file mode 100644 +index 0000000000..a4037cf0b8 +--- /dev/null ++++ b/libavutil/libavutil.v.in +@@ -0,0 +1,6 @@ ++LIBAVUTIL_@majorver@ { ++ global: ++ av*; ++ local: ++ *; ++}; +diff --git a/libavutil/meson.build b/libavutil/meson.build +new file mode 100644 +index 0000000000..7a7595d487 +--- /dev/null ++++ b/libavutil/meson.build +@@ -0,0 +1,350 @@ ++#### --- GENERATED --- #### ++ ++libavutil_sources = files( ++ 'adler32.c', ++ 'aes.c', ++ 'aes_ctr.c', ++ 'ambient_viewing_environment.c', ++ 'audio_fifo.c', ++ 'avstring.c', ++ 'avsscanf.c', ++ 'base64.c', ++ 'blowfish.c', ++ 'bprint.c', ++ 'buffer.c', ++ 'cast5.c', ++ 'camellia.c', ++ 'channel_layout.c', ++ 'cpu.c', ++ 'crc.c', ++ 'csp.c', ++ 'des.c', ++ 'detection_bbox.c', ++ 'dict.c', ++ 'display.c', ++ 'dovi_meta.c', ++ 'downmix_info.c', ++ 'encryption_info.c', ++ 'error.c', ++ 'eval.c', ++ 'fifo.c', ++ 'file.c', ++ 'file_open.c', ++ 'float_dsp.c', ++ 'fixed_dsp.c', ++ 'frame.c', ++ 'hash.c', ++ 'hdr_dynamic_metadata.c', ++ 'hdr_dynamic_vivid_metadata.c', ++ 'hmac.c', ++ 'hwcontext.c', ++ 'imgutils.c', ++ 'integer.c', ++ 'intmath.c', ++ 'lfg.c', ++ 'lls.c', ++ 'log.c', ++ 'log2_tab.c', ++ 'lzo.c', ++ 'mathematics.c', ++ 'mastering_display_metadata.c', ++ 'md5.c', ++ 'mem.c', ++ 'murmur3.c', ++ 'opt.c', ++ 'parseutils.c', ++ 'pixdesc.c', ++ 'pixelutils.c', ++ 'random_seed.c', ++ 'rational.c', ++ 'reverse.c', ++ 'rc4.c', ++ 'ripemd.c', ++ 'samplefmt.c', ++ 'sha.c', ++ 'sha512.c', ++ 'slicethread.c', ++ 'spherical.c', ++ 'stereo3d.c', ++ 'threadmessage.c', ++ 'time.c', ++ 'timecode.c', ++ 'tree.c', ++ 'twofish.c', ++ 'utils.c', ++ 'xga_font_data.c', ++ 'xtea.c', ++ 'tea.c', ++ 'tx.c', ++ 'tx_float.c', ++ 'tx_double.c', ++ 'tx_int32.c', ++ 'uuid.c', ++ 'version.c', ++ 'video_enc_params.c', ++ 'film_grain_params.c', ++) ++ ++libavutil_headers = files( ++ 'adler32.h', ++ 'aes.h', ++ 'aes_ctr.h', ++ 'ambient_viewing_environment.h', ++ 'attributes.h', ++ 'audio_fifo.h', ++ 'avassert.h', ++ 'avstring.h', ++ 'avutil.h', ++ 'base64.h', ++ 'blowfish.h', ++ 'bprint.h', ++ 'bswap.h', ++ 'buffer.h', ++ 'cast5.h', ++ 'camellia.h', ++ 'channel_layout.h', ++ 'common.h', ++ 'cpu.h', ++ 'crc.h', ++ 'csp.h', ++ 'des.h', ++ 'detection_bbox.h', ++ 'dict.h', ++ 'display.h', ++ 'dovi_meta.h', ++ 'downmix_info.h', ++ 'encryption_info.h', ++ 'error.h', ++ 'eval.h', ++ 'fifo.h', ++ 'file.h', ++ 'frame.h', ++ 'hash.h', ++ 'hdr_dynamic_metadata.h', ++ 'hdr_dynamic_vivid_metadata.h', ++ 'hmac.h', ++ 'hwcontext.h', ++ 'hwcontext_cuda.h', ++ 'hwcontext_d3d11va.h', ++ 'hwcontext_drm.h', ++ 'hwcontext_dxva2.h', ++ 'hwcontext_qsv.h', ++ 'hwcontext_mediacodec.h', ++ 'hwcontext_opencl.h', ++ 'hwcontext_vaapi.h', ++ 'hwcontext_videotoolbox.h', ++ 'hwcontext_vdpau.h', ++ 'hwcontext_vulkan.h', ++ 'imgutils.h', ++ 'intfloat.h', ++ 'intreadwrite.h', ++ 'lfg.h', ++ 'log.h', ++ 'lzo.h', ++ 'macros.h', ++ 'mathematics.h', ++ 'mastering_display_metadata.h', ++ 'md5.h', ++ 'mem.h', ++ 'motion_vector.h', ++ 'murmur3.h', ++ 'opt.h', ++ 'parseutils.h', ++ 'pixdesc.h', ++ 'pixelutils.h', ++ 'pixfmt.h', ++ 'random_seed.h', ++ 'rc4.h', ++ 'rational.h', ++ 'replaygain.h', ++ 'ripemd.h', ++ 'samplefmt.h', ++ 'sha.h', ++ 'sha512.h', ++ 'spherical.h', ++ 'stereo3d.h', ++ 'threadmessage.h', ++ 'time.h', ++ 'timecode.h', ++ 'timestamp.h', ++ 'tree.h', ++ 'twofish.h', ++ 'uuid.h', ++ 'version.h', ++ 'video_enc_params.h', ++ 'xtea.h', ++ 'tea.h', ++ 'tx.h', ++ 'film_grain_params.h', ++) ++ ++libavutil_optional_sources = { ++ 'cuda' : files('hwcontext_cuda.c'), ++ 'd3d11va' : files('hwcontext_d3d11va.c'), ++ 'dxva2' : files('hwcontext_dxva2.c'), ++ 'libdrm' : files('hwcontext_drm.c'), ++ 'macos_kperf' : files('macos_kperf.c'), ++ 'mediacodec' : files('hwcontext_mediacodec.c'), ++ 'opencl' : files('hwcontext_opencl.c'), ++ 'qsv' : files('hwcontext_qsv.c'), ++ 'vaapi' : files('hwcontext_vaapi.c'), ++ 'vdpau' : files('hwcontext_vdpau.c'), ++ 'videotoolbox' : files('hwcontext_videotoolbox.c'), ++ 'vulkan' : files('hwcontext_vulkan.c','hwcontext_stub.c'), ++} ++ ++libavutil_x86asm_optional_sources = { ++} ++ ++libavutil_armv5te_optional_sources = { ++} ++ ++libavutil_armv6_optional_sources = { ++} ++ ++libavutil_armv8_optional_sources = { ++} ++ ++libavutil_neon_optional_sources = { ++} ++ ++libavutil_vfp_optional_sources = { ++} ++ ++libavutil_mmx_optional_sources = { ++} ++ ++libavutil_shlib_optional_sources = { ++} ++ ++libavutil_slib_optional_sources = { ++} ++ ++libavutil_tests = [ ++ ['adler32', files('tests/adler32.c')], ++ ['aes', files('tests/aes.c')], ++ ['aes_ctr', files('tests/aes_ctr.c')], ++ ['audio_fifo', files('tests/audio_fifo.c')], ++ ['avstring', files('tests/avstring.c')], ++ ['base64', files('tests/base64.c')], ++ ['blowfish', files('tests/blowfish.c')], ++ ['bprint', files('tests/bprint.c')], ++ ['cast5', files('tests/cast5.c')], ++ ['camellia', files('tests/camellia.c')], ++ ['channel_layout', files('tests/channel_layout.c')], ++ ['color_utils', files('tests/color_utils.c')], ++ ['cpu', files('tests/cpu.c')], ++ ['crc', files('tests/crc.c')], ++ ['des', files('tests/des.c')], ++ ['dict', files('tests/dict.c')], ++ ['display', files('tests/display.c')], ++ ['encryption_info', files('tests/encryption_info.c')], ++ ['error', files('tests/error.c')], ++ ['eval', files('tests/eval.c')], ++ ['file', files('tests/file.c')], ++ ['fifo', files('tests/fifo.c')], ++ ['hash', files('tests/hash.c')], ++ ['hmac', files('tests/hmac.c')], ++ ['hwdevice', files('tests/hwdevice.c')], ++ ['integer', files('tests/integer.c')], ++ ['imgutils', files('tests/imgutils.c')], ++ ['lfg', files('tests/lfg.c')], ++ ['lls', files('tests/lls.c')], ++ ['log', files('tests/log.c')], ++ ['md5', files('tests/md5.c')], ++ ['murmur3', files('tests/murmur3.c')], ++ ['opt', files('tests/opt.c')], ++ ['pca', files('tests/pca.c')], ++ ['parseutils', files('tests/parseutils.c')], ++ ['pixdesc', files('tests/pixdesc.c')], ++ # MANUAL ['pixelutils', files('tests/pixelutils.c')], ++ ['pixfmt_best', files('tests/pixfmt_best.c')], ++ ['random_seed', files('tests/random_seed.c')], ++ ['rational', files('tests/rational.c')], ++ ['ripemd', files('tests/ripemd.c')], ++ ['sha', files('tests/sha.c')], ++ ['sha512', files('tests/sha512.c')], ++ ['softfloat', files('tests/softfloat.c')], ++ ['tree', files('tests/tree.c')], ++ ['twofish', files('tests/twofish.c')], ++ # MANUAL ['utf8', files('tests/utf8.c')], ++ ['uuid', files('tests/uuid.c')], ++ ['xtea', files('tests/xtea.c')], ++ ['tea', files('tests/tea.c')], ++] ++ ++libavutil_optional_tests = { ++ # This test is meant to be run manually (it uses argv unchecked) ++ # 'lzo1x_999_compress' : [ ++ # ['lzo', files('tests/lzo.c'), { ++ # 'extra_libs': ['lzo2'], # MANUAL ++ # }], ++ # ], ++ 'threads' : [ ++ ['cpu_init', files('tests/cpu_init.c'), { ++ 'extra_libs': ['threads'], # MANUAL ++ }], ++ ], ++ 'pixelutils': [ ++ ['pixelutils', files('tests/pixelutils.c'), {}] # MANUAL ++ ], ++} ++ ++#### --- END GENERATED --- #### ++ ++install_headers(libavutil_headers, subdir: 'libavutil') ++ ++# Lavu configuration file ++lavu_conf = configuration_data() ++foreach config: have_list_pub ++ lavu_conf.set('AV_HAVE_@0@'.format(config.to_upper()), conf.get(config.to_lower())) ++endforeach ++ ++configure_file( ++ output: 'avconfig.h', ++ configuration: lavu_conf, ++ install_dir: join_paths(get_option('includedir'), 'libavutil'), ++ install: true, ++) ++ ++kwargs = {'prefix': '#include "libavutil/version.h"'} + get_version_define_kwargs ++ ++libavutil_majorver = cc.get_define('LIBAVUTIL_VERSION_MAJOR', kwargs: kwargs) ++minorver = cc.get_define('LIBAVUTIL_VERSION_MINOR', kwargs: kwargs) ++microver = cc.get_define('LIBAVUTIL_VERSION_MICRO', kwargs: kwargs) ++ ++libavutil_version = f'@libavutil_majorver@.@minorver@.@microver@' ++ ++# Version file ++ver_conf = configuration_data() ++ver_conf.set('majorver', libavutil_majorver) ++ver_conf.set('minorver', minorver) ++ver_conf.set('microver', microver) ++ ++configure_file( ++ input: 'libavutil.v.in', ++ output: 'libavutil.ver', ++ configuration: ver_conf, ++) ++ ++ffversion_h = custom_target('ffversion.h', ++ output: 'ffversion.h', ++ build_always_stale: true, ++ command: [ ++ find_program('version.py', required: true), ++ '--git', ++ find_program('git', required: true), ++ meson.project_source_root(), ++ '@OUTPUT@', ++ '' ++ ], ++ build_by_default: true, ++ install_dir: join_paths(get_option('includedir'), 'libavutil'), ++ install: true, ++) ++ ++subdir('aarch64') ++subdir('arm') ++subdir('x86') ++ ++libavutil_sources += compat_objs +diff --git a/libavutil/version.py b/libavutil/version.py +new file mode 100644 +index 0000000000..8b133f0860 +--- /dev/null ++++ b/libavutil/version.py +@@ -0,0 +1,99 @@ ++#!/usr/bin/env python3 ++ ++# Copyright (c) 2018 Mathieu Duponchelle <mathieu@centricular.com> ++# ++# This file is part of the FFmpeg Meson build ++# ++# This library is free software; you can redistribute it and/or ++# modify it under the terms of the GNU Lesser General Public ++# License as published by the Free Software Foundation; either ++# version 2.1 of the License, or (at your option) any later version. ++# ++# This library is distributed in the hope that it will be useful, ++# but WITHOUT ANY WARRANTY; without even the implied warranty of ++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++# Lesser General Public License for more details. ++# ++# You should have received a copy of the GNU Lesser General Public ++# License along with this library; if not, see <http://www.gnu.org/licenses/>. ++ ++import argparse ++import subprocess ++import os ++import pathlib ++import re ++import sys ++ ++if __name__=='__main__': ++ parser = argparse.ArgumentParser() ++ parser.add_argument('--git', type=pathlib.Path, help='Path to the Git executable', default='git') ++ parser.add_argument('rootdir') ++ parser.add_argument('output') ++ parser.add_argument('extraversion') ++ args = parser.parse_args() ++ ++ original_dir = os.getcwd() ++ ++ os.chdir(args.rootdir) ++ is_release = True ++ with open('RELEASE', 'r') as f: ++ release_contents = f.read() ++ if 'git' in release_contents: ++ is_release = False ++ ++ if is_release: ++ res = subprocess.run([args.git, 'describe', '--tags', '--always'], stdout=subprocess.PIPE) ++ else: ++ res = subprocess.run([args.git, 'describe', '--tags', '--match', 'N'], stdout=subprocess.PIPE) ++ ++ revision = res.stdout.decode() ++ ++ if not revision: ++ res = subprocess.run([args.git, 'log' , '-1', '--pretty=format:git-%cd-%h', '--date=short'], stdout=subprocess.PIPE) ++ revision = res.stdout.decode() ++ ++ git_hash = '' ++ if not revision: ++ basename = os.path.basename(os.getcwd()) ++ m = re.match(r'ffmpeg-(HEAD-)?([0-9]{7})$', basename) ++ if m: ++ git_hash = ''.join([m.group(1) or '', m.group(2)]) ++ ++ if not revision: ++ revision = release_contents ++ ++ revision = revision.strip() ++ ++ if revision and git_hash: ++ revision = '%s-%s' % (revision, git_hash) ++ ++ try: ++ with open('VERSION', 'r') as f: ++ version_contents = f.read() ++ version = version_contents.strip() ++ except FileNotFoundError: ++ version = revision ++ ++ if args.extraversion: ++ version = '%s-%s' % (version, args.extraversion) ++ ++ if not args.output: ++ print (version) ++ sys.exit(0) ++ ++ os.chdir(original_dir) ++ ++ old_revision = None ++ if os.path.exists(args.output): ++ with open(args.output, 'r') as f: ++ for line in f: ++ parts = line.split() ++ if len(parts) >= 3 and parts[0] == '#define' and parts[1] == 'FFMPEG_VERSION': ++ old_revision = parts[2].split('"')[1] ++ break ++ ++ if revision != old_revision: ++ with open(args.output, 'w') as f: ++ f.write('/* Automatically generated by version.py, do not manually edit! */\n') ++ f.write('#pragma once\n') ++ f.write('#define FFMPEG_VERSION "%s"\n' % revision) +diff --git a/libavutil/x86/meson.build b/libavutil/x86/meson.build +new file mode 100644 +index 0000000000..a892ad0548 +--- /dev/null ++++ b/libavutil/x86/meson.build +@@ -0,0 +1,53 @@ ++libavutil_x86_sources = files( ++ 'cpu.c', ++ 'fixed_dsp_init.c', ++ 'float_dsp_init.c', ++ 'imgutils_init.c', ++ 'lls_init.c', ++) ++ ++libavutil_x86_optional_sources = { ++ 'pixelutils' : files('pixelutils_init.c'), ++ 'x86asm' : files('tx_float_init.c'), ++} ++ ++libavutil_x86_x86asm_sources = files( ++ 'cpuid.asm', ++ 'fixed_dsp.asm', ++ 'float_dsp.asm', ++ 'imgutils.asm', ++ 'lls.asm', ++ 'tx_float.asm', ++) ++ ++libavutil_x86_x86asm_optional_sources = { ++ 'mmx_external' : files('emms.asm'), # MANUAL ++ 'pixelutils' : files('pixelutils.asm'), ++} ++ ++libavutil_x86_armv5te_optional_sources = { ++} ++ ++libavutil_x86_armv6_optional_sources = { ++} ++ ++libavutil_x86_armv8_optional_sources = { ++} ++ ++libavutil_x86_neon_optional_sources = { ++} ++ ++libavutil_x86_vfp_optional_sources = { ++} ++ ++libavutil_x86_mmx_optional_sources = { ++} ++ ++libavutil_x86_shlib_optional_sources = { ++} ++ ++libavutil_x86_slib_optional_sources = { ++} ++ ++libavutil_x86_optional_tests = { ++} +diff --git a/libpostproc/libpostproc.v.in b/libpostproc/libpostproc.v.in +new file mode 100644 +index 0000000000..c6ef9b3963 +--- /dev/null ++++ b/libpostproc/libpostproc.v.in +@@ -0,0 +1,7 @@ ++LIBPOSTPROC_@majorver@ { ++ global: ++ postproc_*; ++ pp_*; ++ local: ++ *; ++}; +diff --git a/libpostproc/meson.build b/libpostproc/meson.build +new file mode 100644 +index 0000000000..633e9f76df +--- /dev/null ++++ b/libpostproc/meson.build +@@ -0,0 +1,69 @@ ++kwargs = {'prefix': '#include "libpostproc/version.h"'} + get_version_define_kwargs ++ ++libpostproc_majorver = cc.get_define('LIBPOSTPROC_VERSION_MAJOR', kwargs: kwargs) ++minorver = cc.get_define('LIBPOSTPROC_VERSION_MINOR', kwargs: kwargs) ++microver = cc.get_define('LIBPOSTPROC_VERSION_MICRO', kwargs: kwargs) ++ ++libpostproc_version = f'@libpostproc_majorver@.@minorver@.@microver@' ++ ++#### --- GENERATED --- #### ++ ++libpostproc_sources = files( ++ 'postprocess.c', ++ 'version.c', ++) ++ ++libpostproc_headers = files( ++ 'postprocess.h', ++ 'version.h', ++ 'version_major.h', ++) ++ ++libpostproc_optional_sources = { ++} ++ ++libpostproc_x86asm_optional_sources = { ++} ++ ++libpostproc_armv5te_optional_sources = { ++} ++ ++libpostproc_armv6_optional_sources = { ++} ++ ++libpostproc_armv8_optional_sources = { ++} ++ ++libpostproc_neon_optional_sources = { ++} ++ ++libpostproc_vfp_optional_sources = { ++} ++ ++libpostproc_mmx_optional_sources = { ++} ++ ++libpostproc_shlib_optional_sources = { ++} ++ ++libpostproc_slib_optional_sources = { ++} ++ ++libpostproc_optional_tests = { ++} ++ ++#### --- END GENERATED --- #### ++ ++# Version file ++ver_conf = configuration_data() ++ver_conf.set('majorver', libpostproc_majorver) ++ver_conf.set('minorver', minorver) ++ver_conf.set('microver', microver) ++ ++install_headers(libpostproc_headers, subdir: 'libpostproc') ++ ++configure_file( ++ input: 'libpostproc.v.in', ++ output: 'libpostproc.ver', ++ configuration: ver_conf, ++) +diff --git a/libswresample/aarch64/meson.build b/libswresample/aarch64/meson.build +new file mode 100644 +index 0000000000..da998259e1 +--- /dev/null ++++ b/libswresample/aarch64/meson.build +@@ -0,0 +1,43 @@ ++libswresample_aarch64_sources = files( ++ 'audio_convert_init.c', ++ 'resample_init.c', ++) ++ ++libswresample_aarch64_optional_sources = { ++ 'neon_clobber_test' : files('neontest.c'), ++} ++ ++libswresample_aarch64_x86asm_optional_sources = { ++} ++ ++libswresample_aarch64_armv5te_optional_sources = { ++} ++ ++libswresample_aarch64_armv6_optional_sources = { ++} ++ ++libswresample_aarch64_armv8_optional_sources = { ++} ++ ++libswresample_aarch64_neon_sources = files( ++ 'audio_convert_neon.S', ++ 'resample.S', ++) ++ ++libswresample_aarch64_neon_optional_sources = { ++} ++ ++libswresample_aarch64_vfp_optional_sources = { ++} ++ ++libswresample_aarch64_mmx_optional_sources = { ++} ++ ++libswresample_aarch64_shlib_optional_sources = { ++} ++ ++libswresample_aarch64_slib_optional_sources = { ++} ++ ++libswresample_aarch64_optional_tests = { ++} +diff --git a/libswresample/arm/meson.build b/libswresample/arm/meson.build +new file mode 100644 +index 0000000000..bc98c24840 +--- /dev/null ++++ b/libswresample/arm/meson.build +@@ -0,0 +1,43 @@ ++libswresample_arm_sources = files( ++ 'audio_convert_init.c', ++ 'resample_init.c', ++) ++ ++libswresample_arm_optional_sources = { ++ 'neon_clobber_test' : files('neontest.c'), ++} ++ ++libswresample_arm_x86asm_optional_sources = { ++} ++ ++libswresample_arm_armv5te_optional_sources = { ++} ++ ++libswresample_arm_armv6_optional_sources = { ++} ++ ++libswresample_arm_armv8_optional_sources = { ++} ++ ++libswresample_arm_neon_sources = files( ++ 'audio_convert_neon.S', ++ 'resample.S', ++) ++ ++libswresample_arm_neon_optional_sources = { ++} ++ ++libswresample_arm_vfp_optional_sources = { ++} ++ ++libswresample_arm_mmx_optional_sources = { ++} ++ ++libswresample_arm_shlib_optional_sources = { ++} ++ ++libswresample_arm_slib_optional_sources = { ++} ++ ++libswresample_arm_optional_tests = { ++} +diff --git a/libswresample/libswresample.v.in b/libswresample/libswresample.v.in +new file mode 100644 +index 0000000000..575e99e0d6 +--- /dev/null ++++ b/libswresample/libswresample.v.in +@@ -0,0 +1,7 @@ ++LIBSWRESAMPLE_@majorver@ { ++ global: ++ swr_*; ++ swresample_*; ++ local: ++ *; ++}; +diff --git a/libswresample/meson.build b/libswresample/meson.build +new file mode 100644 +index 0000000000..9415557357 +--- /dev/null ++++ b/libswresample/meson.build +@@ -0,0 +1,89 @@ ++kwargs = {'prefix': '#include "libswresample/version.h"'} + get_version_define_kwargs ++ ++libswresample_majorver = cc.get_define('LIBSWRESAMPLE_VERSION_MAJOR', kwargs: kwargs) ++minorver = cc.get_define('LIBSWRESAMPLE_VERSION_MINOR', kwargs: kwargs) ++microver = cc.get_define('LIBSWRESAMPLE_VERSION_MICRO', kwargs: kwargs) ++ ++libswresample_version = f'@libswresample_majorver@.@minorver@.@microver@' ++ ++#### --- GENERATED --- #### ++ ++libswresample_sources = files( ++ 'audioconvert.c', ++ 'dither.c', ++ 'options.c', ++ 'rematrix.c', ++ 'resample.c', ++ 'resample_dsp.c', ++ 'swresample.c', ++ 'swresample_frame.c', ++ 'version.c', ++) ++ ++libswresample_headers = files( ++ 'swresample.h', ++ 'version.h', ++ 'version_major.h', ++) ++ ++libswresample_optional_sources = { ++ 'libsoxr' : files('soxr_resample.c'), ++} ++ ++libswresample_x86asm_optional_sources = { ++} ++ ++libswresample_armv5te_optional_sources = { ++} ++ ++libswresample_armv6_optional_sources = { ++} ++ ++libswresample_armv8_optional_sources = { ++} ++ ++libswresample_neon_optional_sources = { ++} ++ ++libswresample_vfp_optional_sources = { ++} ++ ++libswresample_mmx_optional_sources = { ++} ++ ++libswresample_shlib_sources = files( ++ 'log2_tab.c', ++) ++ ++libswresample_shlib_optional_sources = { ++} ++ ++libswresample_slib_optional_sources = { ++} ++ ++libswresample_tests = [ ++ ['swresample', files('tests/swresample.c')], ++] ++ ++libswresample_optional_tests = { ++} ++ ++#### --- END GENERATED --- #### ++ ++# Version file ++ver_conf = configuration_data() ++ver_conf.set('majorver', libswresample_majorver) ++ver_conf.set('minorver', minorver) ++ver_conf.set('microver', microver) ++ ++install_headers(libswresample_headers, subdir: 'libswresample') ++ ++configure_file( ++ input: 'libswresample.v.in', ++ output: 'libswresample.ver', ++ configuration: ver_conf, ++) ++ ++subdir('aarch64') ++subdir('arm') ++subdir('x86') +diff --git a/libswresample/x86/meson.build b/libswresample/x86/meson.build +new file mode 100644 +index 0000000000..5907491058 +--- /dev/null ++++ b/libswresample/x86/meson.build +@@ -0,0 +1,45 @@ ++libswresample_x86_sources = files( ++ 'audio_convert_init.c', ++ 'rematrix_init.c', ++ 'resample_init.c', ++) ++ ++libswresample_x86_optional_sources = { ++ 'xmm_clobber_test' : files('w64xmmtest.c'), ++} ++ ++libswresample_x86_x86asm_sources = files( ++ 'audio_convert.asm', ++ 'rematrix.asm', ++ 'resample.asm', ++) ++ ++libswresample_x86_x86asm_optional_sources = { ++} ++ ++libswresample_x86_armv5te_optional_sources = { ++} ++ ++libswresample_x86_armv6_optional_sources = { ++} ++ ++libswresample_x86_armv8_optional_sources = { ++} ++ ++libswresample_x86_neon_optional_sources = { ++} ++ ++libswresample_x86_vfp_optional_sources = { ++} ++ ++libswresample_x86_mmx_optional_sources = { ++} ++ ++libswresample_x86_shlib_optional_sources = { ++} ++ ++libswresample_x86_slib_optional_sources = { ++} ++ ++libswresample_x86_optional_tests = { ++} +diff --git a/libswscale/aarch64/meson.build b/libswscale/aarch64/meson.build +new file mode 100644 +index 0000000000..f3444967ff +--- /dev/null ++++ b/libswscale/aarch64/meson.build +@@ -0,0 +1,45 @@ ++libswscale_aarch64_sources = files( ++ 'rgb2rgb.c', ++ 'swscale.c', ++ 'swscale_unscaled.c', ++) ++ ++libswscale_aarch64_optional_sources = { ++} ++ ++libswscale_aarch64_x86asm_optional_sources = { ++} ++ ++libswscale_aarch64_armv5te_optional_sources = { ++} ++ ++libswscale_aarch64_armv6_optional_sources = { ++} ++ ++libswscale_aarch64_armv8_optional_sources = { ++} ++ ++libswscale_aarch64_neon_sources = files( ++ 'hscale.S', ++ 'output.S', ++ 'rgb2rgb_neon.S', ++ 'yuv2rgb_neon.S', ++) ++ ++libswscale_aarch64_neon_optional_sources = { ++} ++ ++libswscale_aarch64_vfp_optional_sources = { ++} ++ ++libswscale_aarch64_mmx_optional_sources = { ++} ++ ++libswscale_aarch64_shlib_optional_sources = { ++} ++ ++libswscale_aarch64_slib_optional_sources = { ++} ++ ++libswscale_aarch64_optional_tests = { ++} +diff --git a/libswscale/arm/meson.build b/libswscale/arm/meson.build +new file mode 100644 +index 0000000000..af5e49fb38 +--- /dev/null ++++ b/libswscale/arm/meson.build +@@ -0,0 +1,45 @@ ++libswscale_arm_sources = files( ++ 'swscale.c', ++ 'swscale_unscaled.c', ++) ++ ++libswscale_arm_optional_sources = { ++} ++ ++libswscale_arm_x86asm_optional_sources = { ++} ++ ++libswscale_arm_armv5te_optional_sources = { ++} ++ ++libswscale_arm_armv6_optional_sources = { ++} ++ ++libswscale_arm_armv8_optional_sources = { ++} ++ ++libswscale_arm_neon_sources = files( ++ 'rgb2yuv_neon_32.S', ++ 'rgb2yuv_neon_16.S', ++ 'hscale.S', ++ 'output.S', ++ 'yuv2rgb_neon.S', ++) ++ ++libswscale_arm_neon_optional_sources = { ++} ++ ++libswscale_arm_vfp_optional_sources = { ++} ++ ++libswscale_arm_mmx_optional_sources = { ++} ++ ++libswscale_arm_shlib_optional_sources = { ++} ++ ++libswscale_arm_slib_optional_sources = { ++} ++ ++libswscale_arm_optional_tests = { ++} +diff --git a/libswscale/libswscale.v.in b/libswscale/libswscale.v.in +new file mode 100644 +index 0000000000..518b7abd8d +--- /dev/null ++++ b/libswscale/libswscale.v.in +@@ -0,0 +1,7 @@ ++LIBSWSCALE_@majorver@ { ++ global: ++ swscale_*; ++ sws_*; ++ local: ++ *; ++}; +diff --git a/libswscale/meson.build b/libswscale/meson.build +new file mode 100644 +index 0000000000..732e695efc +--- /dev/null ++++ b/libswscale/meson.build +@@ -0,0 +1,98 @@ ++kwargs = {'prefix': '#include "libswscale/version.h"'} + get_version_define_kwargs ++ ++libswscale_majorver = cc.get_define('LIBSWSCALE_VERSION_MAJOR', kwargs: kwargs) ++minorver = cc.get_define('LIBSWSCALE_VERSION_MINOR', kwargs: kwargs) ++microver = cc.get_define('LIBSWSCALE_VERSION_MICRO', kwargs: kwargs) ++ ++libswscale_version = f'@libswscale_majorver@.@minorver@.@microver@' ++ ++#### --- GENERATED --- #### ++ ++libswscale_sources = files( ++ 'alphablend.c', ++ 'hscale.c', ++ 'hscale_fast_bilinear.c', ++ 'gamma.c', ++ 'half2float.c', ++ 'input.c', ++ 'options.c', ++ 'output.c', ++ 'rgb2rgb.c', ++ 'slice.c', ++ 'swscale.c', ++ 'swscale_unscaled.c', ++ 'utils.c', ++ 'version.c', ++ 'yuv2rgb.c', ++ 'vscale.c', ++) ++ ++libswscale_headers = files( ++ 'swscale.h', ++ 'version.h', ++ 'version_major.h', ++) ++ ++libswscale_optional_sources = { ++} ++ ++libswscale_x86asm_optional_sources = { ++} ++ ++libswscale_armv5te_optional_sources = { ++} ++ ++libswscale_armv6_optional_sources = { ++} ++ ++libswscale_armv8_optional_sources = { ++} ++ ++libswscale_neon_optional_sources = { ++} ++ ++libswscale_vfp_optional_sources = { ++} ++ ++libswscale_mmx_optional_sources = { ++} ++ ++libswscale_shlib_sources = files( ++ 'log2_tab.c', ++) ++ ++libswscale_shlib_optional_sources = { ++} ++ ++libswscale_slib_optional_sources = { ++} ++ ++libswscale_tests = [ ++ ['colorspace', files('tests/colorspace.c')], ++ ['floatimg_cmp', files('tests/floatimg_cmp.c')], ++ ['pixdesc_query', files('tests/pixdesc_query.c')], ++ # MANUAL ['swscale', files('tests/swscale.c')], ++] ++ ++libswscale_optional_tests = { ++} ++ ++#### --- END GENERATED --- #### ++ ++# Version file ++ver_conf = configuration_data() ++ver_conf.set('majorver', libswscale_majorver) ++ver_conf.set('minorver', minorver) ++ver_conf.set('microver', microver) ++ ++install_headers(libswscale_headers, subdir: 'libswscale') ++ ++configure_file( ++ input: 'libswscale.v.in', ++ output: 'libswscale.ver', ++ configuration: ver_conf, ++) ++ ++subdir('aarch64') ++subdir('arm') ++subdir('x86') +diff --git a/libswscale/x86/meson.build b/libswscale/x86/meson.build +new file mode 100644 +index 0000000000..553e27c70d +--- /dev/null ++++ b/libswscale/x86/meson.build +@@ -0,0 +1,53 @@ ++libswscale_x86_sources = files( ++ 'rgb2rgb.c', ++ 'swscale.c', ++ 'yuv2rgb.c', ++) ++ ++libswscale_x86_optional_sources = { ++ 'xmm_clobber_test' : files('w64xmmtest.c'), ++} ++ ++libswscale_x86_x86asm_sources = files( ++ 'input.asm', ++ 'output.asm', ++ 'scale.asm', ++ 'scale_avx2.asm', ++ 'rgb_2_rgb.asm', ++ 'yuv_2_rgb.asm', ++ 'yuv2yuvX.asm', ++) ++ ++libswscale_x86_x86asm_optional_sources = { ++} ++ ++libswscale_x86_armv5te_optional_sources = { ++} ++ ++libswscale_x86_armv6_optional_sources = { ++} ++ ++libswscale_x86_armv8_optional_sources = { ++} ++ ++libswscale_x86_neon_optional_sources = { ++} ++ ++libswscale_x86_vfp_optional_sources = { ++} ++ ++libswscale_x86_mmx_sources = files( ++ 'hscale_fast_bilinear_simd.c', ++) ++ ++libswscale_x86_mmx_optional_sources = { ++} ++ ++libswscale_x86_shlib_optional_sources = { ++} ++ ++libswscale_x86_slib_optional_sources = { ++} ++ ++libswscale_x86_optional_tests = { ++} +diff --git a/meson.build b/meson.build +new file mode 100644 +index 0000000000..904a254cab +--- /dev/null ++++ b/meson.build +@@ -0,0 +1,3584 @@ ++# Copyright (c) 2018 Mathieu Duponchelle <mathieu@centricular.com> ++# Copyright (c) 2023 L. E. Segovia <amy@centricular.com> ++# ++# This file is part of the FFmpeg Meson build ++# ++# This library is free software; you can redistribute it and/or ++# modify it under the terms of the GNU Lesser General Public ++# License as published by the Free Software Foundation; either ++# version 2.1 of the License, or (at your option) any later version. ++# ++# This library is distributed in the hope that it will be useful, ++# but WITHOUT ANY WARRANTY; without even the implied warranty of ++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++# Lesser General Public License for more details. ++# ++# You should have received a copy of the GNU Lesser General Public ++# License along with this library; if not, see <http://www.gnu.org/licenses/>. ++ ++project('FFmpeg', 'c', ++ meson_version: '>= 0.60', ++ license: 'LGPL2.1+', ++ # C11 is needed for Metal support ++ # Static libraries by default following upstream ++ default_options: [ 'buildtype=debugoptimized', 'c_std=c11', 'cpp_std=c++11', 'default_library=static'], ++ version: '6.0.0', ++) ++ ++# HOWTO: ++# ++# Get meson >= 0.60 from pip or your distro's package manager then: ++# ++# meson build && ninja -C build ++ ++# Overview of the configure process: ++# ++# This port is relatively faithful to the original configure script: ++# We first gather system information (compiler checks, dependencies, ..), ++# then pass this information through a temporary configure file to a ++# script named "depresolver.py". This script implements the logic implemented ++# in the configure script by the "check_deps" function, the dependency ++# graph lives in a python file named "depgraph.py". ++# ++# That graph is made up of a set of nodes, each optionally containing ++# information about the components it selects, depends on or conflicts ++# with. ++# ++# The depresolver script returns two things: ++# ++# * A set of key-value pairs, indicating for each component whether ++# it was enabled or not. ++# * A second set of key-value pairs, associating to each component ++# the set of enabled components it depended upon. ++# ++# The first set is used to determine which sources to compile in, ++# using the dictionaries present in the relevant meson.build definitions ++# in the subdirectories (eg. libavutil/meson.build) ++# ++# The second set is used to compute the external dependencies passed ++# to the various build targets, when a component is compiled into library ++# we check whether a @0@_flattened_deps.format(component) variable was ++# set, and add it to the set of dependencies for that library. ++# ++# Various other python scripts have been implemented to reproduce other ++# bits of logic in the configure script, eg. find_things.py ... ++# TODO: ++# ++# * Assembler extensions (mmx etc..) ++# * Porting the FATE test suite ++# * Continue going over the configure script and importing various ++# bits of logic ++ffmpeg_toplevel_builddir = meson.current_build_dir() ++ffmpeg_toplevel_inc = include_directories('.') ++common_incs = [ffmpeg_toplevel_inc] ++ ++python3 = import('python').find_installation() ++ ++windows = import('windows') ++ ++cc = meson.get_compiler('c') ++ ++languages_map = {} ++ ++is_msvc = cc.get_define('_MSC_VER') != '' ++ ++if cc.get_argument_syntax() == 'msvc' ++ # Ignore several spurious warnings for things FFmpeg does very commonly ++ # If a warning is completely useless and spammy, use '/wdXXXX' to suppress it ++ # If a warning is harmless but hard to fix, use '/woXXXX' so it's shown once ++ # NOTE: Only add warnings here if you are sure they're spurious or they're ++ # for a pattern that ffmpeg does not care about ++ add_project_arguments( ++ '/wo4005', # macro redefinition (this likely need to be fixed) ++ '/wd4018', # implicit signed/unsigned conversion ++ '/wd4146', # unary minus on unsigned (beware INT_MIN) ++ '/wd4244', # lossy type conversion (e.g. double -> int) ++ '/wd4305', # truncating type conversion (e.g. double -> float) ++ '/wd4554', # operator precedence ++ '/wd4114', # same type qualifier used more than once ++ '/wd4028', # formal parameter {n} different from declaration ++ '/wd4090', # 'function': different 'const' qualifiers ++ '/wd4133', # 'type' : incompatible types - from 'type1' to 'type2' ++ cc.get_supported_arguments(['/utf-8']), # set the input encoding to utf-8 ++ language : 'c') ++endif ++ ++project_c_args = [ ++ '-D_ISOC99_SOURCE', ++ '-D_GNU_SOURCE', ++ '-D_LARGEFILE_SOURCE', ++ '-Wno-parentheses', ++ '-Wno-pointer-sign', ++ '-Wno-switch', ++ '-Wno-format-truncation', ++ '-Wno-deprecated-declarations', ++ '-Wno-unused-function', ++ '-Wno-maybe-uninitialized', ++ '-Wno-discarded-qualifiers', ++ '-Wno-unused-variable', ++ '-Wno-bool-operation', ++ '-Wno-incompatible-pointer-types', ++ '-Wno-address', ++] ++ ++# Work around meson subprojects ignoring default_options ++# https://github.com/mesonbuild/meson/issues/1889#issuecomment-1275991958 ++if meson.is_subproject() and meson.version().version_compare('< 0.63') ++ project_c_args += ['-std=c11'] ++endif ++ ++project_c_args = cc.get_supported_arguments(project_c_args) ++ ++thread_dep = dependency('threads') ++ ++common_deps = [thread_dep] ++ ++if host_machine.system() == 'windows' ++ common_deps += [cc.find_library('ws2_32')] ++endif ++ ++conf = configuration_data() ++ ++compat_objs = [] ++ ++document_list = [ ++ 'doc', ++ 'htmlpages', ++ 'manpages', ++ 'podpages', ++ 'txtpages', ++] ++ ++example_list = [ ++ 'avio_http_serve_files_example', ++ 'avio_list_dir_example', ++ 'avio_read_callback_example', ++ 'decode_audio_example', ++ 'decode_filter_audio_example', ++ 'decode_filter_video_example', ++ 'decode_video_example', ++ 'demux_decode_example', ++ 'encode_audio_example', ++ 'encode_video_example', ++ 'extract_mvs_example', ++ 'filter_audio_example', ++ 'hw_decode_example', ++ 'mux_example', ++ 'qsv_decode_example', ++ 'remux_example', ++ 'resample_audio_example', ++ 'scale_video_example', ++ 'show_metadata_example', ++ 'transcode_aac_example', ++ 'transcode_example', ++ 'vaapi_encode_example', ++ 'vaapi_transcode_example', ++ 'qsv_transcode_example', ++] ++ ++arch_list = [ ++ 'aarch64', ++ 'alpha', ++ 'arm', ++ 'avr32', ++ 'avr32_ap', ++ 'avr32_uc', ++ 'bfin', ++ 'ia64', ++ 'loongarch', ++ 'loongarch32', ++ 'loongarch64', ++ 'm68k', ++ 'mips', ++ 'mips64', ++ 'parisc', ++ 'ppc', ++ 'ppc64', ++ 'riscv', ++ '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_ppc = [ ++ 'altivec', ++ 'dcbzl', ++ 'ldbrx', ++ 'power8', ++ 'ppc4xx', ++ 'vsx', ++] ++ ++arch_ext_list_mips = [ ++ 'mipsfpu', ++ 'mips32r2', ++ 'mips32r5', ++ 'mips64r2', ++ 'mips32r6', ++ 'mips64r6', ++ 'mipsdsp', ++ 'mipsdspr2', ++ 'msa', ++] ++ ++arch_ext_list_loongson = [ ++ 'loongson2', ++ 'loongson3', ++ 'mmi', ++ 'lsx', ++ 'lasx', ++] ++ ++arch_ext_list_x86_simd = [ ++ 'aesni', ++ 'amd3dnow', ++ 'amd3dnowext', ++ 'avx', ++ 'avx2', ++ 'avx512', ++ 'avx512icl', ++ 'fma3', ++ 'fma4', ++ 'mmx', ++ 'mmxext', ++ 'sse', ++ 'sse2', ++ 'sse3', ++ 'sse4', ++ 'sse42', ++ 'ssse3', ++ 'xop', ++] ++ ++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', ++ 'fast_float16', ++ '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', ++] ++ ++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', ++ 'getauxval', ++ 'getenv', ++ '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', ++ 'prctl', ++ 'pthread_cancel', ++ 'sched_getaffinity', ++ 'SecItemImport', ++ 'SetConsoleTextAttribute', ++ 'SetConsoleCtrlHandler', ++ 'setmode', ++ 'setrlimit', ++ 'Sleep', ++ 'strerror_r', ++ 'sysconf', ++ 'sysctl', ++ 'usleep', ++ 'UTGetOSTypeFromString', ++ 'VirtualAlloc', ++ 'wglGetProcAddress', ++] ++ ++system_libraries = [ ++ 'bcrypt', ++ 'vaapi_drm', ++ 'vaapi_x11', ++ 'vdpau_x11', ++] ++ ++threads_list = [ ++ 'pthreads', ++ 'os2threads', ++ 'w32threads', ++] ++ ++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 = [ ++ 'DPI_AWARENESS_CONTEXT', ++ 'IDXGIOutput5', ++ 'kCMVideoCodecType_HEVC', ++ 'kCMVideoCodecType_HEVCWithAlpha', ++ 'kCMVideoCodecType_VP9', ++ 'kCVPixelFormatType_420YpCbCr10BiPlanarVideoRange', ++ 'kCVPixelFormatType_422YpCbCr8BiPlanarVideoRange', ++ 'kCVPixelFormatType_422YpCbCr10BiPlanarVideoRange', ++ 'kCVPixelFormatType_422YpCbCr16BiPlanarVideoRange', ++ 'kCVPixelFormatType_444YpCbCr8BiPlanarVideoRange', ++ 'kCVPixelFormatType_444YpCbCr10BiPlanarVideoRange', ++ 'kCVPixelFormatType_444YpCbCr16BiPlanarVideoRange', ++ 'kCVImageBufferTransferFunction_SMPTE_ST_2084_PQ', ++ 'kCVImageBufferTransferFunction_ITU_R_2100_HLG', ++ 'kCVImageBufferTransferFunction_Linear', ++ 'kCVImageBufferYCbCrMatrix_ITU_R_2020', ++ 'kCVImageBufferColorPrimaries_ITU_R_2020', ++ 'kCVImageBufferTransferFunction_ITU_R_2020', ++ 'kCVImageBufferTransferFunction_SMPTE_ST_428_1', ++ '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', ++] ++ ++asm = get_option('asm') ++inline_asm = get_option('inline_asm') ++ ++conf.set10('asm', asm.allowed()) ++conf.set10('faan', true) ++conf.set10('faandct', true) ++conf.set10('faanidct', true) ++conf.set10('optimizations', get_option('optimization') != '0') ++conf.set10('runtime_cpudetect', true) ++conf.set10('safe_bitstream_reader', true) ++conf.set10('swscale_alpha', true) ++ ++if inline_asm.allowed() ++ conf.set10('inline_asm', ++ cc.compiles( ++ 'void foo(void){ __asm__ volatile(@0@); }'.format('"" ::'), ++ name: 'inline_asm' ++ ) ++ ) ++else ++ conf.set10('inline_asm', false) ++endif ++ ++arch_ext_list_external = [] ++arch_ext_list_inline = [] ++ ++foreach arch_ext : arch_ext_list ++ conf.set10(arch_ext, conf.get('asm') == 1) ++ conf.set10('@0@_external'.format(arch_ext), conf.get('asm') == 1) ++ conf.set10('@0@_inline'.format(arch_ext), conf.get('asm') == 1 and conf.get('inline_asm') == 1) ++ arch_ext_list_external += ['@0@_external'.format(arch_ext)] ++ arch_ext_list_inline += ['@0@_inline'.format(arch_ext)] ++endforeach ++ ++have_list = (arch_ext_list + arch_ext_list_external + arch_ext_list_inline + arch_features + ++ builtin_list + have_list_cmdline + ++ have_list_pub + headers_list + intrinsics_list + math_funcs + system_features + system_funcs + ++ system_libraries + threads_list + toolchain_features + types_list + [ ++ 'gzip', ++ 'makeinfo', ++ 'makeinfo_html', ++ 'mmx2', ++ 'opencl_d3d11', ++ 'opencl_drm_arm', ++ 'opencl_drm_beignet', ++ 'opencl_dxva2', ++ 'opencl_vaapi_beignet', ++ 'opencl_vaapi_intel_media', ++ 'perl', ++ 'pod2man', ++ 'texi2html', ++ 'xmllint', ++ 'zlib_gzip' ++]) ++ ++arch_features = [ ++ ['aligned_stack', ['aarch64', 'ppc', 'x86']], ++ ['fast_64bit', ['aarch64', 'alpha', 'ia64', 'mips64', 'parisc64', 'ppc64', 'riscv64', 'sparc64', 'x86_64']], ++ ['fast_clz', ['aarch64', 'alpha', 'avr32', 'mips', 'ppc', 'x86']], ++ ['simd_align_16', ['altivec', 'neon', 'sse']], ++ ['simd_align_32', ['avx']], ++ ['simd_align_64', ['avx512']], ++] ++ ++ioctl_meteor_headers = [ ++ ['dev/bktr/ioctl_meteor.h', 'dev/bktr/ioctl_bt848.h'], ++ ['machine/ioctl_meteor.h', 'machine/ioctl_bt848.h'], ++ ['dev/video/meteor/ioctl_meteor.h', 'dev/video/bktr/ioctl_bt848.h'], ++ ['dev/ic/bt8xx.h']] ++ ++headers_found = false ++ ++foreach headers : ioctl_meteor_headers ++ if not headers_found ++ n_headers_found = 0 ++ foreach header : headers ++ header_found = cc.has_header(header) ++ if header_found ++ n_headers_found += 1 ++ endif ++ endforeach ++ ++ headers_found = headers.length() == n_headers_found ++ ++ foreach header : headers ++ conf.set10(header.underscorify(), headers_found) ++ endforeach ++ endif ++endforeach ++ ++check_structs = [ ++ ['struct rusage', 'ru_maxrss', '#include <sys/time.h>\n#include<sys/resource.h>\n'], ++ ['struct stat', 'st_mtim.tv_nsec', '#include <sys/stat.h>\n#define _BSD_SOURCE'], ++] ++ ++external_autodetect_library_list = [ ++ 'alsa', ++ 'appkit', ++ 'avfoundation', ++ 'bzlib', ++ 'coreimage', ++ 'iconv', ++ 'libxcb', ++ 'libxcb_shm', ++ 'libxcb_shape', ++ 'libxcb_xfixes', ++ 'lzma', ++ 'mediafoundation', ++ 'metal', ++ 'schannel', ++ 'sdl2', ++ 'securetransport', ++ 'sndio', ++ 'xlib', ++ 'zlib', ++] ++ ++library_gpl_list = [ ++ 'avisynth', ++ 'frei0r', ++ 'libcdio', ++ 'libdavs2', ++ 'librubberband', ++ 'libvidstab', ++ 'libx264', ++ 'libx265', ++ 'libxavs', ++ 'libxavs2', ++ 'libxvid', ++] ++ ++library_nonfree_list = [ ++ 'decklink', ++ 'libfdk_aac', ++ 'libtls', ++] ++ ++library_version3_list = [ ++ 'gmp', ++ 'libaribb24', ++ 'liblensfun', ++ 'libopencore_amrnb', ++ 'libopencore_amrwb', ++ 'libvo_amrwbenc', ++ 'mbedtls', ++ 'rkmpp', ++] ++ ++library_gplv3_list = [ ++ 'libsmbclient', ++] ++ ++all_checks = [] ++ ++cpp_cond = ''' ++#include <@0@> ++ ++#if !(@1@) ++#error "unsatisfied condition: @1@" ++#endif ++ ++int main(void) { ++ return 0; ++} ++''' ++ ++check_winapi_family = ''' ++#ifdef WINAPI_FAMILY ++#include <winapifamily.h> ++#if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) ++#error not desktop ++#endif ++#endif ++ ++int main(void) { ++ return 0; ++} ++''' ++ ++libc_type = '' ++ ++if cc.links(cpp_cond.format('features.h', 'defined __UCLIBC__')) ++ libc_type = 'uclibc' ++ project_c_args += ['-D_POSIX_C_SOURCE=200112', '-D_XOPEN_SOURCE=600'] ++elif cc.links(cpp_cond.format('features.h', 'defined __GLIBC__')) ++ libc_type = 'glibc' ++ project_c_args += ['-D_POSIX_C_SOURCE=200112', '-D_XOPEN_SOURCE=600'] ++elif cc.links(cpp_cond.format('newlib.h', 'defined _NEWLIB_VERSION')) ++ libc_type = 'newlib' ++ project_c_args += ['-U__STRICT_ANSI__', '-D_XOPEN_SOURCE=600'] ++elif cc.links(cpp_cond.format('_mingw.h', 'defined __MINGW64_VERSION_MAJOR')) ++ libc_type = 'mingw64' ++ if cc.links(cpp_cond.format('_mingw.h', '__MINGW64_VERSION_MAJOR < 3')) ++ compat_objs += files('compat/msvcrt/snprintf.c') ++ project_c_args += ['-include', meson.current_source_dir() / 'compat/msvcrt/snprintf.h'] ++ endif ++ project_c_args += ['-U__STRICT_ANSI__', '-D__USE_MINGW_ANSI_STDIO=1'] ++ if cc.get_id() == 'gcc' ++ project_c_args += ['-D__printf__=__gnu_printf__'] ++ endif ++ if cc.links(cpp_cond.format('windows.h', '!defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0600')) ++ project_c_args += ['-D_WIN32_WINNT=0x0600'] ++ endif ++elif (cc.links(cpp_cond.format('_mingw.h', 'defined __MINGW_VERSION')) or ++ cc.links(cpp_cond.format('_mingw.h', 'defined __MINGW32_VERSION'))) ++ libc_type = 'mingw32' ++ if cc.links(cpp_cond.format('_mingw.h', '__MINGW32_MAJOR_VERSION > 3 || (__MINGW32_MAJOR_VERSION == 3 && __MINGW32_MINOR_VERSION >= 15')) ++ error('MinGW32 runtime version must be >= 3.15') ++ endif ++ project_c_args += ['-U__STRICT_ANSI__', '-D__USE_MINGW_ANSI_STDIO=1'] ++ if cc.links(cpp_cond.format('_mingw.h', '__MSVCRT_VERSION__ < 0x0700')) ++ project_c_args += ['-D__MSVCRT_VERSION__=0x0700'] ++ endif ++ if cc.links(cpp_cond.format('windows.h', '!defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0600')) ++ project_c_args += ['-D_WIN32_WINNT=0x0600'] ++ endif ++ if cc.get_id() == 'gcc' ++ project_c_args += ['-D__printf__=__gnu_printf__'] ++ endif ++elif cc.links(cpp_cond.format('crtversion.h', 'defined _VC_CRT_MAJOR_VERSION')) ++ libc_type = 'msvcrt' ++ if cc.links(cpp_cond.format('crtversion.h', '_VC_CRT_MAJOR_VERSION < 14')) ++ compat_objs += files('compat/strtod.c') ++ project_c_args += ['-Dstrtod=avpriv_strtod'] ++ compat_objs += files('compat/snprintf.c') ++ project_c_args += [ ++ '-Dsnprintf=avpriv_snprintf', ++ '-D_snprintf=avpriv_snprintf', ++ '-Dvsnprintf=avpriv_vsnprintf', ++ ] ++ endif ++ project_c_args += ['-D_USE_MATH_DEFINES', '-D_CRT_SECURE_NO_WARNINGS', '-D_CRT_NONSTDC_NO_WARNINGS'] ++ if (cc.links(cpp_cond.format('stdlib.h', 'defined(_WIN32_WINNT)')) or ++ cc.links(check_winapi_family)) ++ project_c_args += ['-D_WIN32_WINNT=0x0600'] ++ endif ++ if not cc.has_function('strtoll') ++ project_c_args += ['-Dstrtoll=_strtoi64'] ++ endif ++ if not cc.has_function('strtoull') ++ project_c_args += ['-Dstrtoull=_strtoui64'] ++ endif ++elif cc.links(cpp_cond.format('stddef.h', 'defined __KLIBC__')) ++ libc_type = 'klibc' ++elif cc.links(cpp_cond.format('stddef.h', 'defined __BIONIC__')) ++ libc_type = 'bionic' ++ ++ # hacks for compiler/libc/os combinations ++ compat_objs += files('compat/strtod.c') ++ project_c_args += [ ++ '-Dstrtod=avpriv_strtod', ++ ] ++elif cc.links(cpp_cond.format('sys/brand.h', 'defined LABELED_BRAND_NAME')) ++ libc_type = 'solaris' ++ project_c_args += ['-D__EXTENSIONS__', '-D_XOPEN_SOURCE=600'] ++endif ++ ++if not cc.has_function('localtime_r', prefix: '#include <time.h>', args: project_c_args) ++ if cc.has_function('localtime_r', prefix: '#include <time.h>', args: project_c_args + ['-D_POSIX_C_SOURCE=200112', '-D_XOPEN_SOURCE=600']) ++ project_c_args += ['-D_POSIX_C_SOURCE=200112', '-D_XOPEN_SOURCE=600'] ++ endif ++endif ++ ++conf.set10('float16', cc.has_type('_Float16', args: project_c_args)) ++ ++if libc_type != '' ++ conf.set('libc_@0@'.format(libc_type), 1) ++endif ++ ++# PIC is Meson managed, the compiler may not support it by ++# default but can be enabled through b_staticpic ++conf.set10('pic', get_option('b_staticpic')) ++ ++conf.set10('winrt', cc.links(cpp_cond.format('windows.h', '!WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)'))) ++ ++d3d11va_extra_deps = [] ++ ++conf.set10('uwp', cc.compiles('''#ifdef WINAPI_FAMILY ++#include <winapifamily.h> ++#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) ++#error desktop, not uwp ++#else ++// WINAPI_FAMILY_APP, WINAPI_FAMILY_PHONE_APP => UWP ++#endif ++#else ++#error no family set ++#endif''', name: 'is UWP')) ++if conf.get('uwp') == 1 ++ d3d11va_extra_deps += [ ++ cc.find_library('dxgi'), ++ cc.find_library('d3d11') ++ ] ++endif ++ ++check_framework = [ ++ ['AppKit'], ++ ['AudioToolbox'], ++ ['AVFoundation'], ++ ['CoreImage'], ++ ['Metal'], ++ ['VideoToolbox'], ++] ++ ++test_check_framework = [ ++ 'CoreFoundation', ++ 'CoreMedia', ++ 'CoreVideo', ++ 'CoreAudio', ++] ++ ++avfoundation_indev_extra_deps = dependency('appleframeworks', modules: 'Foundation', required: get_option('avfoundation_indev').enabled()) ++audiotoolbox_outdev_extra_deps = dependency('appleframeworks', modules: ['AudioToolbox', 'CoreAudio'], required: get_option('audiotoolbox_outdev').enabled()) ++coreimage_filter_extra_deps = dependency('appleframeworks', modules: 'OpenGL', required: get_option('coreimage_filter').enabled()) ++coreimagesrc_filter_extra_deps = dependency('appleframeworks', modules: 'OpenGL', required: get_option('coreimage_filter').enabled()) ++videotoolbox_extra_deps = dependency('appleframeworks', modules: 'QuartzCore', required: get_option('videotoolbox').enabled()) ++ ++foreach check : check_framework ++ all_checks += [['framework', check]] ++endforeach ++ ++check_pkg_config = [ ++ ['alsa', ['alsa/asoundlib.h'], ['snd_pcm_htimestamp'], {}], ++ ['chromaprint', ['chromaprint.h'], ['chromaprint_get_version'], {'pkg': 'chromaprint'}], ++ ['ffnvcodec', ['ffnvcodec/nvEncodeAPI.h', 'ffnvcodec/dynlink_cuda.h', 'ffnvcodec/dynlink_cuviddec.h', 'ffnvcodec/dynlink_nvcuvid.h'], ++ [], {'versions': ['>= 12.0.16.0', ['>= 11.1.5.2', '< 12.0'], ['>= 11.0.10.2', '< 11.1'], ['>= 8.1.24.11', '< 8.2']]}], ++ ['libgme', ['gme/gme.h'], ['gme_new_emu'], {}], ++ ['gnutls', ['gnutls/gnutls.h'], ['gnutls_global_init'], {}], ++ ['lcms2', ['lcms2.h'], ['cmsCreateContext'], {'pkg': 'lcms2', 'version': '>= 2.13'}], ++ ['libaom', ['aom/aom_codec.h'], ['aom_codec_version'], {'pkg': 'aom', 'version': '>= 0.1.0'}], ++ ['libaribb24', ['aribb24/aribb24.h'], ['arib_instance_new'], {'pkg': 'aribb24', 'version': '> 1.0.3'}], ++ ['lv2', ['lilv-0/lilv/lilv.h'], ['lilv_world_new'], {'pkg': 'lilv-0'}], ++ ['libass', ['ass/ass.h'], ['ass_library_init'], {'pkg': 'libass', 'version': '>= 0.11.0'}], ++ ['libbluray', ['libbluray/bluray.h'], ['bd_open'], {}], ++ ['libbs2b', ['bs2b.h'], ['bs2b_open'], {}], ++ ['libcaca', ['caca.h'], ['caca_create_canvas'], {'pkg': 'caca'}], ++ ['libcdio', ['cdio/cdda.h', 'cdio/paranoia.h'], ['cdio_cddap_open'], {'pkg': 'libcdio_paranoia'}], ++ ['libcdio', ['cdio/paranoia/cdda.h', 'cdio/paranoia/paranoia.h'], ['cdio_cddap_open'], {'pkg': 'libcdio_paranoia'}], ++ ['libdavs2', ['davs2.h'], ['davs2_decoder_open'], {'pkg': 'davs2', 'version': '>= 1.6.0'}], ++ ['libdc1394', ['dc1394/dc1394.h'], ['dc1394_new'], {'pkg': 'libdc1394-2'}], ++ ['libdrm', ['xf86drm.h'], ['drmGetVersion'], {}], ++ ['libfdk_aac', ['fdk-aac/aacenc_lib.h'], ['aacEncOpen'], {'pkg': 'fdk-aac'}], ++ ['libfontconfig', ['fontconfig/fontconfig.h'], ['FcInit'], {'pkg': 'fontconfig'}], ++ ['libfreetype', ['ft2build.h', 'FT_FREETYPE_H'], ['FT_Init_FreeType'], {'pkg': 'freetype2'}], ++ ['libfribidi', ['fribidi.h'], ['fribidi_version_info'], {'pkg': 'fribidi'}], ++ ['libjack', ['jack/jack.h'], ['jack_port_get_latency_range'], {'pkg': 'jack'}], ++ ['libjxl', ['jxl/decode.h'], ['JxlDecoderVersion'], {'pkg': 'libjxl', 'version': '>= 0.7.0'}], ++ ['libklvanc', ['libklvanc/vanc.h'], ['klvanc_context_create'], {}], ++ ['libkvazaar', ['kvazaar.h'], ['kvz_api_get'], {'pkg': 'kvazaar', 'version': '>= 0.8.1'}], ++ ['liblensfun', ['lensfun.h'], ['lf_db_new'], {'pkg': 'lensfun'}], ++ ['libmfx', ['mfx/mfxvideo.h'], ['MFXInit'], {'pkg': 'libmfx', 'version': ['>= 1.28', '< 2.0']}], ++ ['libmodplug', ['libmodplug/modplug.h'], ['ModPlug_Load'], {}], ++ ['libopencv', ['opencv2/core/core_c.h'], ['cvCreateImageHeader'], {'pkg': 'opencv'}], ++ ['libopencv', ['opencv/cxcore.h'], ['cvCreateImageHeader'], {'pkg': 'opencv'}], ++ ['libopenh264', ['wels/codec_api.h'], ['WelsGetCodecVersion'], {'pkg': 'openh264'}], ++ ['libdav1d', ['dav1d/dav1d.h'], ['dav1d_version'], {'pkg': 'dav1d', 'version': '>= 0.4.0'}], ++ ['libopenjpeg', ['openjpeg.h'], ['opj_version'], {'pkg': 'libopenjp2', ++ 'version': '>= 2.1.0'}], ++ ['libopenjpeg', ['openjpeg.h'], ['opj_version'], {'pkg': 'libopenjp2', ++ 'version': '>= 2.1.0', ++ 'c_args': ['-DOPJ_STATIC']}], ++ ['libopenmpt', ['libopenmpt/libopenmpt.h'], ['openmpt_module_create'], {'version': '>= 0.2.6557'}], ++ ['libopus', ['opus_multistream.h'], ['opus_multistream_decoder_create', 'opus_multistream_surround_encoder_create'], {'pkg': 'opus'}], ++ ['libplacebo', ['libplacebo/vulkan.h'], ['pl_vulkan_create'], {'pkg': 'libplacebo', 'version': '>= 4.192.0'}], ++ ['libpulse', ['pulse/pulseaudio.h'], ['pa_context_new'], {}], ++ ['librabbitmq', ['amqp.h'], ['amqp_new_connection'], {'pkg': 'librabbitmq', 'version': '>= 0.7.1'}], ++ ['librav1e', ['rav1e.h'], ['rav1e_context_new'], {'pkg': 'rav1e', 'version': '>= 0.5.0'}], ++ ['librist', ['librist/librist.h'], ['rist_receiver_create'], {'pkg': 'rist', 'version': '>= 0.2.7'}], ++ ['librsvg', ['librsvg-2.0/librsvg/rsvg.h'], ['rsvg_handle_render_cairo'], {'pkg': 'librsvg-2.0'}], ++ ['librtmp', ['librtmp/rtmp.h'], ['RTMP_Socket'], {}], ++ ['librubberband', ['rubberband/rubberband-c.h'], ['rubberband_new'], {'pkg': 'rubberband', 'version': '>= 1.8.1'}], ++ ['spirv_compiler', ['shaderc/shaderc.h'], ['shaderc_compiler_initialize'], {'pkg': 'shaderc', 'version': '>= 2019.'}], ++ ['libshine', ['shine/layer3.h'], ['shine_encode_buffer'], {'pkg': 'shine'}], ++ ['libsmbclient', ['libsmbclient.h'], ['smbc_init'], {'pkg': 'smbclient'}], ++ ['libssh', ['libssh/sftp.h'], ['sftp_init'], {}], ++ ['libspeex', ['speex/speex.h'], ['speex_decoder_init'], {'pkg': 'speex'}], ++ ['libsrt', ['srt/srt.h'], ['srt_socket'], {'pkg': 'srt', 'version': '>= 1.2.0'}], ++ ['libsvtav1', ['EbSvtAv1Enc.h'], ['svt_av1_enc_init_handle'], {'pkg': 'SvtAv1Enc', 'version': '>= 0.9.0'}], ++ ['libtesseract', ['tesseract/capi.h'], ['TessBaseAPICreate'], {'pkg': 'tesseract'}], ++ ['libtls', ['tls.h'], ['tls_configure'], {}], ++ ['libv4l2', ['libv4l2.h'], ['v4l2_ioctl'], {}], ++ ['libvidstab', ['vid.stab/libvidstab.h'], ['vsMotionDetectInit'], {'pkg': 'vidstab', 'version': '>= 0.98'}], ++ ['libvmaf', ['libvmaf.h'], ['compute_vmaf'], {'version': '>= 2.0.0'}], ++ ['libvorbis', ['vorbis/codec.h'], ['vorbis_info_init'], {'pkg': 'vorbis'}], ++ ['libvorbisenc', ['vorbis/vorbisenc.h'], ['vorbis_encode_init'], {'pkg': 'vorbisenc'}], ++ ['libvpl', ['mfxvideo.h', 'mfxdispatcher.h'], ['MFXLoad'], {'pkg': 'vpl', 'version': '>= 2.6'}], ++ ['libvpx', ['vpx/vpx_decoder.h', 'vpx/vpx_encoder.h'], [], {'pkg': 'vpx', 'version': '>= 1.4.0'}], ++ ['libvpx_vp8_decoder', ['vpx/vpx_decoder.h', 'vpx/vp8dx.h'], ['vpx_codec_vp8_dx'], {'pkg': 'vpx', 'version': '>= 1.4.0'}], ++ ['libvpx_vp8_encoder', ['vpx/vpx_encoder.h', 'vpx/vp8cx.h'], ['vpx_codec_vp8_cx'], {'pkg': 'vpx', 'version': '>= 1.4.0'}], ++ ['libvpx_vp9_decoder', ['vpx/vpx_decoder.h', 'vpx/vp8dx.h'], ['vpx_codec_vp9_dx'], {'pkg': 'vpx', 'version': '>= 1.4.0'}], ++ ['libvpx_vp9_encoder', ['vpx/vpx_encoder.h', 'vpx/vp8cx.h'], ['vpx_codec_vp9_cx'], {'pkg': 'vpx', 'version': '>= 1.4.0'}], ++ ['libwebp', ['webp/encode.h'], ['WebPGetEncoderVersion'], {'version': '>= 0.2.0'}], ++ ['libwebp_anim_encoder', ['webp/mux.h'], ['WebPAnimEncoderOptionsInit'], {'pkg': 'libwebpmux', 'version': '>= 0.4.0'}], ++ ['libx264', ['stdint.h', 'x264.h'], ['x264_encoder_encode'], {'pkg': 'x264'}], ++ ['libx265', ['x265.h'], ['x265_api_get'], {'pkg': 'x265'}], ++ ['libxcb', ['xcb/xcb.h'], ['xcb_connect'], {'pkg': 'xcb', 'version': '>= 1.4'}], ++ ['libxcb_shm', ['xcb/shm.h'], ['xcb_shm_attach'], {'pkg': 'xcb-shm'}], ++ ['libxcb_shape', ['xcb/shape.h'], ['xcb_shape_get_rectangles'], {'pkg': 'xcb-shape'}], ++ ['libxcb_xfixes', ['xcb/xfixes.h'], ['xcb_xfixes_get_cursor_image'], {'pkg': 'xcb-xfixes'}], ++ ['libxml2', ['libxml2/libxml/xmlversion.h'], ['xmlCheckVersion'], {'pkg': 'libxml-2.0'}], ++ ['libzimg', ['zimg.h'], ['zimg_get_api_version'], {'pkg': 'zimg', 'version': '>= 2.7.0'}], ++ ['libzmq', ['zmq.h'], ['zmq_ctx_new'], {}], ++ ['libzvbi', ['libzvbi.h'], ['vbi_decoder_new'], {'pkg': 'zvbi-0.2'}], ++ ['mbedtls', ['mbedtls/x509_crt.h'], ['mbedtls_x509_crt_init'], {'pkg': 'mbedtls'}], ++ ['mbedtls', ['mbedtls/ssl.h'], ['mbedtls_ssl_init'], {'pkg': 'mbedtls'}], ++ ['openal', ['AL/al.h'], ['alGetError'], {'pkg': 'openal', 'version': '>= 1.1'}], ++ ['openssl', ['openssl/ssl.h'], ['OPENSSL_init_ssl'], {'pkg': 'openssl', 'version': '>= 3.0.0'}], ++ ['openssl', ['openssl/ssl.h'], ['OPENSSL_init_ssl', 'SSL_library_init'], {'has_any_func': true}], ++ ['pocketsphinx', ['pocketsphinx/pocketsphinx.h'], ['ps_init'], {}], ++ ['rkmpp', ['rockchip/rk_mpi.h'], ['mpp_create'], {'pkg': 'rockchip_mpp'}], ++ ['rockchip_mpp', ['rockchip/rk_mpi.h'], ['mpp_create'], {'version': '>= 1.3.7'}], ++ ['sdl2', ['SDL_events.h'], ['SDL_PollEvent'], {'version': ['>= 2.0.1', '< 3.0.0']}], ++ ['sndio', ['sndio.h'], ['sio_open'], {'pkg': 'sndio'}], ++ ['vapoursynth', ['VSScript.h'], ['vsscript_init'], {'pkg': 'vapoursynth-script', 'version': '>= 42'}], ++ ['vulkan', ['vulkan/vulkan.h'], ['vkCreateInstance'], {'pkg': 'vulkan', 'version': '>= 1.2.189'}], ++ ['xlib_x11', ['X11/Xlib.h'], ['XPending'], {'pkg': 'xlib'}], ++ ['xlib_xext', ['X11/Xlib.h', 'X11/extensions/XShm.h'], ['XShmAttach'], {'pkg': 'xext'}], ++ ['xlib_xv', ['X11/Xlib.h', 'X11/extensions/Xvlib.h'], ['XvGetPortAttribute'], {'pkg': 'xv'}], ++] ++ ++foreach check : check_pkg_config ++ all_checks += [['pkg-config', check]] ++endforeach ++ ++conf.set10('vdpau', cc.has_header('vdpau/vdpau.h') and ++ cc.get_define('VDP_DECODER_PROFILE_MPEG4_PART2_ASP', prefix: '#include <vdpau/vdpau.h>') != '') ++ ++conf.set10('nanosleep', cc.has_function('nanosleep', prefix: '#include <time.h>')) ++ ++check_components = [ ++ ['advapi32', ['windows.h'], ['RegCloseKey'], ['advapi32']], ++ ['avisynth', ['avisynth/avisynth_c.h', 'avisynth/avs/version.h'], [], []], ++ ['alsa', ['alsa/asoundlib.h'], ['snd_pcm_htimestamp'], ['asound']], ++ ['android', ['android/native_window.h'], ['ANativeWindow_acquire'], ['android']], ++ ['bcrypt', ['windows.h', 'bcrypt.h'], ['BCryptGenRandom'], ['bcrypt'],{'defines': ['BCRYPT_RNG_ALGORITHM']}], ++ ['bzlib', ['bzlib.h'], ['BZ2_bzlibVersion'], ['bz2']], ++ ['camera2ndk', ['stdbool.h', 'stdint.h', 'camera/NdkCameraManager.h'], ['ACameraManager_create'], ['camera2ndk']], ++ ['decklink', ['DeckLinkAPI.h'], [], []], ++ ['libcelt', ['celt/celt.h'], ['celt_decoder_create_custom'], ['celt0']], ++ ['chromaprint', ['chromaprint.h'], ['chromaprint_get_version'], ['chromaprint']], ++ ['clock_gettime', ['time.h'], ['clock_gettime'], []], ++ ['clock_gettime', ['time.h'], ['clock_gettime'], ['rt']], ++ ['cuda_sdk', ['cuda.h'], ['cuCtxCreate'], ['cuda']], ++ # FFmpeg deprecated CrystalHD in 6.0 ++ # ['crystalhd', ['stdint.h', 'libcrystalhd/libcrystalhd_if.h'], ['DtsCrystalHDVersion'], ['crystalhd']], ++ ['frei0r', ['frei0r.h'], [], []], ++ ['iconv', ['iconv.h'], ['iconv'], ['iconv']], ++ ['libgme', ['gme/gme.h'], ['gme_new_emu'], ['gme', 'stdc++']], ++ ['gcrypt', ['gcrypt.h'], ['gcry_mpi_new'], ['gcrypt']], ++ ['gmp', ['gmp.h'], ['mpz_export'], ['gmp']], ++ ['ladspa', ['ladspa.h', 'dlfcn.h'], [], []], ++ ['libcdio', ['cdio/cdda.h', 'cdio/paranoia.h'], ['cdio_cddap_open'], ['cdio_paranoia', 'cdio_cdda', 'cdio']], ++ ['libcdio', ['cdio/paranoia/cdda.h', 'cdio/paranoia/paranoia.h'], ['cdio_cddap_open'], ['cdio_paranoia', 'cdio_cdda', 'cdio']], ++ ['libcodec2', ['codec2/codec2.h'], ['codec2_create'], ['codec2']], ++ ['libdl', ['dlfcn.h'], ['dlopen', 'dlsym'], []], ++ ['libdl', ['dlfcn.h'], ['dlopen', 'dlsym'], ['dl']], ++ ['libfdk_aac', ['fdk-aac/aacenc_lib.h'], ['aacEncOpen'], ['fdk-aac']], ++ ['libflite', ['flite/flite.h'], ['flite_init'], ['flite_cmu_time_awb', 'flite_cmu_us_awb', 'flite_cmu_us_kal', ++ 'flite_cmu_us_kal16', 'flite_cmu_us_rms', 'flite_cmu_us_slt', ++ 'flite_usenglish', 'flite_cmulex', 'flite']], ++ ['libgsm', ['gsm.h'], ['gsm_create'], ['gsm']], ++ ['libgsm', ['gsm/gsm.h'], ['gsm_create'], ['gsm']], ++ ['libiec61883', ['libiec61883/iec61883.h'], ['iec61883_cmp_connect'], ['raw1394', 'avc1394', 'rom1394', 'iec61883']], ++ ['libilbc', ['ilbc.h'], ['WebRtcIlbcfix_InitDecode'], ['lbc']], ++ ['libjxl', ['jxl/thread_parallel_runner.h'], ['JxlThreadParallelRunner'], ['libjxl_threads']], ++ ['libm', ['math.h'], ['sin'], ['m'], {'always-check': true}], # always check for libm don't provide an option to disable it ++ ['libopenvino', ['c_api/ie_c_api.h'], ['ie_c_api_version'], ['inference_engine_c_api']], ++ ['libnpp', ['npp.h'], ['nppGetLibVersion'], ['nppig', 'nppicc', 'nppc', 'nppidei', 'nppif']], ++ ['libnpp', ['npp.h'], ['nppGetLibVersion'], ['nppi', 'nppif', 'nppc', 'nppidei']], ++ ['libopencore_amrnb', ['opencore-amrnb/interf_dec.h'], ['Decoder_Interface_init'], ['opencore-amrnb']], ++ ['libopencore_amrwb', ['opencore-amrwb/dec_if.h'], ['D_IF_init'], ['opencore-amrwb']], ++ ['libopencv', ['opencv2/core/core_c.h'], ['cvCreateImageHeader'], ['opencv_core', 'opencv_imgproc']], ++ ['libsmbclient', ['libsmbclient.h'], ['smbc_init'], ['smbclient']], ++ ['libsnappy', ['snappy-c.h'], ['snappy_compress'], ['snappy', 'stdc++']], ++ ['libsoxr', ['soxr.h'], ['soxr_create'], ['soxr']], ++ ['libtensorflow', ['tensorflow/c/c_api.h'], ['TF_Version'], ['tensorflow']], ++ ['libtheora', ['theora/theoraenc.h'], ['th_info_init'], ['theoraenc', 'theoradec', 'ogg']], ++ ['libtwolame', ['twolame.h'], ['twolame_init', 'twolame_encode_buffer_float32_interleaved'], ['twolame']], ++ ['libvo_amrwbenc', ['vo-amrwbenc/enc_if.h'], ['E_IF_init'], ['vo-amrwbenc']], ++ ['libvpx_vp8_decoder', ['vpx/vpx_decoder.h', 'vpx/vp8dx.h'], ['vpx_codec_vp8_dx'], ['vpx'], ++ {'defines': ['VPX_IMG_FMT_HIGHBITDEPTH'], 'extra_deps': ['libm_extra_deps', 'thread_dep']}], ++ ['libvpx_vp8_encoder', ['vpx/vpx_encoder.h', 'vpx/vp8cx.h'], ['vpx_codec_vp8_cx'], ['vpx'], ++ {'defines': ['VPX_IMG_FMT_HIGHBITDEPTH'], 'extra_deps': ['libm_extra_deps', 'thread_dep']}], ++ ['libvpx_vp9_decoder', ['vpx/vpx_decoder.h', 'vpx/vp8dx.h'], ['vpx_codec_vp9_dx'], ['vpx'], ++ {'defines': ['VPX_IMG_FMT_HIGHBITDEPTH'], 'extra_deps': ['libm_extra_deps', 'thread_dep']}], ++ ['libvpx_vp9_encoder', ['vpx/vpx_encoder.h', 'vpx/vp8cx.h'], ['vpx_codec_vp9_cx'], ['vpx'], ++ {'defines': ['VPX_IMG_FMT_HIGHBITDEPTH'], 'extra_deps': ['libm_extra_deps', 'thread_dep']}], ++ ['libxvid', ['xvid.h'], ['xvid_global'], ['xvidcore']], ++ ['linux_fb_h', ['linux/fb.h'], [], []], ++ ['lzma', ['lzma.h'], ['lzma_version_number'], ['lzma']], ++ ['mbedtls', ['mbedtls/ssl.h'], ['mbedtls_ssl_init'], ['mbedtls', 'mbedx509', 'mbedcrypto']], ++ ['mediandk', ['stdint.h', 'media/NdkImage.h'], ['AImage_delete'], ['mediandk']], ++ ['mmal', ['interface/mmal/mmal.h'], ['mmal_port_connect'], ['mmal_core', 'mmal_util', 'mmal_vc_client', 'bcm_host']], ++ ['nanosleep', ['time.h'], ['nanosleep'], ['rt']], ++ ['ole32', ['windows.h'], ['CoTaskMemFree'], ['ole32']], ++ ['omx', ['OMX_Core.h'], [], []], ++ ['openal', ['AL/al.h'], ['alGetError'], ['openal']], ++ ['openal', ['AL/al.h'], ['alGetError'], ['OpenAL32']], ++ # FIXME- Get opencl working - remove the disabler() at that time. ++ ['opencl', ['CL/cl.h'], ['clEnqueueNDRangeKernel'], ['OpenCL', disabler()]], ++ ['opengl', ['GL/glx.h'], ['glXGetProcAddress'], ['GL']], ++ ['opengl', ['windows.h'], ['wglGetProcAddress'], ['opengl32', 'gdi32']], ++ ['openssl', ['openssl/ssl.h'], ['SSL_library_init'], ['ssl', 'crypto']], ++ ['openssl', ['openssl/ssl.h'], ['SSL_library_init'], ['ssl32', 'eay32']], ++ ['openssl', ['openssl/ssl.h'], ['SSL_library_init'], ['ssl', 'crypto', 'ws2_32', 'gdi32']], ++ ['psapi', ['windows.h', 'psapi.h'], ['GetProcessMemoryInfo'], ['psapi']], ++ ['shell32', ['windows.h', 'shellapi.h'], ['CommandLineToArgvW'], ['shell32']], ++ ['sndio', ['sndio.h'], ['sio_open'], ['sndio']], ++ ['user32', ['windows.h', 'winuser.h'], ['GetShellWindow'], ['user32']], ++ ['vfw32', ['windows.h', 'vfw.h'], ['capCreateCaptureWindow'], ['vfw3']], ++ ['vaapi', ['va/va.h'], ['vaInitialize'], ['va']], ++ ['zlib', ['zlib.h'], ['zlibVersion'], ['z']], ++ ++ # Libraries with preconditions ++ ['vaapi_drm', ['va/va.h', 'va/va_drm.h'], ['vaGetDisplayDRM'], ['va', 'va-drm'], ++ {'preconditions': ['vaapi']}], ++ ['vaapi_x11', ['va/va.h', 'va/va_x11.h'], ['vaGetDisplay'], ['va', 'va-x11', 'X11'], ++ {'preconditions': ['vaapi', 'xlib_x11']}], ++ ['vdpau_x11', ['vdpau/vdpau.h', 'vdpau/vdpau_x11.h'], ['vdp_device_create_x11'], ['vdpau', 'X11'], ++ {'preconditions' : ['vdpau']}], ++ ['libmfx', ['mfx/mfxvideo.h', 'mfx/mfxdefs.h'], ['MFXInit'], ['libmfx'], ++ {'preconditions': ['advapi32'], 'extra_deps': ['advapi32_extra_deps']}], ++ ['libmp3lame', ['lame/lame.h'], ['lame_set_VBR_quality'], ['mp3lame'], ++ {'preconditions': ['libm'], 'extra_deps': ['libm_extra_deps']}], ++ ['libmysofa', ['mysofa.h'], ['mysofa_load'], ['mysofa'], ++ {'preconditions': ['zlib'], 'extra_deps': ['zlib_extra_deps']}], ++ ['libx264', ['stdint.h', 'x264.h'], ['x264_encoder_encode'], ['x264'], ++ {'preconditions': ['libm'], 'extra_deps': ['libm_extra_deps']}], ++ ['libxavs', ['stdint.h', 'xavs.h'], ['xavs_encoder_encode'], ['xavs'], ++ {'preconditions': ['libm'], 'extra_deps': ['libm_extra_deps']}], ++ ['xlib_x11', ['X11/Xlib.h'], ['XPending'], ['X11']], ++ ['xlib_xext', ['X11/Xlib.h', 'X11/extensions/XShm.h'], ['XShmAttach'], ['Xext']], ++ ['xlib_xv', ['X11/Xlib.h', 'X11/extensions/Xvlib.h'], ['XvGetPortAttribute'], ['Xv']], ++] ++ ++if get_option('avfoundation').allowed() ++ conf.set10('coregraphics', false) ++ conf.set10('applicationservices', false) ++ ++ check_components += [ ++ ['coregraphics', ['CoreGraphics/CoreGraphics.h'], ['CGGetActiveDisplayList'], [], {'frameworks': ['CoreGraphics']}], ++ ['applicationservices', ['ApplicationServices/ApplicationServices.h'], ['CGGetActiveDisplayList'], [], {'frameworks': ['ApplicationServices']}] ++ ] ++endif ++ ++if get_option('videotoolbox').allowed() ++ conf.set10('coreservices', false) ++ ++ check_components += [ ++ ['coreservices', ['CoreServices/CoreServices.h'], ['UTGetOSTypeFromString'], [], {'frameworks': ['CoreServices']}], ++ ] ++endif ++ ++check_header_funcs = [ ++ ['aligned_malloc', ['malloc.h'], {'funcs': ['_aligned_malloc']}], ++ ['arc4random', ['stdlib.h']], ++ ['kbhit', ['conio.h']], ++ ['setmode', ['io.h']], ++ ['lzo1x_999_compress', ['lzo/lzo1x.h']], ++ ['mach_absolute_time', ['mach/mach_time.h']], ++ ['getenv', ['stdlib.h']], ++ ['lstat', ['sys/stat.h']], ++ ['getauxval', ['sys/auxv.h']], ++ ['GetProcessAffinityMask', ['windows.h']], ++ ['GetProcessTimes', ['windows.h']], ++ ['GetSystemTimeAsFileTime', ['windows.h']], ++ ['LoadLibrary', ['windows.h']], ++ ['MapViewOfFile', ['windows.h']], ++ ['PeekNamedPipe', ['windows.h']], ++ ['SetConsoleTextAttribute', ['windows.h']], ++ ['SetConsoleCtrlHandler', ['windows.h']], ++ ['Sleep', ['windows.h']], ++ ['VirtualAlloc', ['windows.h']], ++ ['glob', ['glob.h']], ++ ['MFCreateAlignedMemoryBuffer', ['mfapi.h'], {'link_with': ['mfplat', 'mfuuid', 'ole32', 'strmiids']}], ++ ['CreateDIBSection', ['windows.h'], {'link_with': ['gdi32']}], ++ ['InitializeSecurityContext', ['windows.h', 'security.h'], {'link_with': ['secur32'], 'c_args': ['-DSECURITY_WIN32']}], ++ ['atomic_cas_ptr', ['atomic.h']], ++ ['machine_rw_barrier', ['mbarrier.h'], {'funcs': ['__machine_rw_barrier']}], ++ ['MemoryBarrier', ['windows.h']], ++ ['posix_memalign', ['stdlib.h']], ++ ['sem_timedwait', ['semaphore.h'], {'preconditions': ['pthreads'], 'extra_deps': ['thread_dep']}], ++ ['prctl', ['sys/prctl.h']], ++ ['iconv', ['iconv.h']], ++] ++ ++foreach func : math_funcs ++ check_header_funcs += [[func, ['math.h'], {'extra_deps': ['libm_extra_deps']}]] ++endforeach ++ ++check_funcs = [ ++ ['getaddrinfo'], ++ ['inet_aton'], ++ ['memalign'], ++ ['access'], ++ ['fcntl'], ++ ['fork'], ++ ['gethrtime'], ++ ['getopt'], ++ ['getrusage'], ++ ['gettimeofday'], ++ ['isatty'], ++ ['mkstemp'], ++ ['mmap'], ++ ['mprotect'], ++ ['sched_getaffinity'], ++ ['setrlimit'], ++ ['strerror_r'], ++ ['sysconf'], ++ ['sysctl'], ++ ['usleep'], ++ ['pthread_join', {'preconditions': ['pthreads'], 'extra_deps': ['thread_dep']}], ++ ['pthread_create', {'preconditions': ['pthreads'], 'extra_deps': ['thread_dep']}], ++ ['pthread_cancel', {'preconditions': ['pthreads'], 'extra_deps': ['thread_dep']}], ++ ['sync_val_compare_and_swap', {'funcs': ['__sync_val_compare_and_swap']}], ++ ['gmtime_r'], ++ ['localtime_r'], ++] ++ ++if get_option('securetransport').allowed() ++ conf.set10('securetransport', false) ++ check_components += [ ++ ['securetransport', ['Security/SecureTransport.h', 'Security/Security.h'], ['SSLCreateContext'], [], {'frameworks': ['CoreFoundation', 'Security']}], ++ ] ++ check_funcs += [ ++ ['SecIdentityCreate', {'c_args': ['-Wl,-framework,CoreFoundation', '-Wl,-framework,Security']}], ++ ['SecItemImport', {'c_args': ['-Wl,-framework,CoreFoundation', '-Wl,-framework,Security']}], ++ ] ++endif ++ ++check_types = [ ++ ['DXVA_PicParams_AV1', ['windows.h', 'dxva.h'], {'c_args': ['-DWINAPI_FAMILY=WINAPI_FAMILY_DESKTOP_APP', '-D_CRT_BUILD_DESKTOP_APP=0']}], ++ ['DXVA_PicParams_HEVC', ['windows.h', 'dxva.h'], {'c_args': ['-DWINAPI_FAMILY=WINAPI_FAMILY_DESKTOP_APP', '-D_CRT_BUILD_DESKTOP_APP=0']}], ++ ['DXVA_PicParams_VP9', ['windows.h', 'dxva.h'], {'c_args': ['-DWINAPI_FAMILY=WINAPI_FAMILY_DESKTOP_APP', '-D_CRT_BUILD_DESKTOP_APP=0']}], ++ ['DXGI_OUTDUPL_FRAME_INFO', ['windows.h', 'dxgi1_2.h']], ++ ['IDXGIOutput1', ['windows.h', 'dxgi1_2.h']], ++ ['IDXGIOutput5', ['windows.h', 'dxgi1_5.h']], ++ ['ID3D11VideoDecoder', ['windows.h', 'd3d11.h']], ++ ['ID3D11VideoContext', ['windows.h', 'd3d11.h']], ++ ['DPI_AWARENESS_CONTEXT', ['windows.h'], {'c_args': ['-D_WIN32_WINNT=0x0A00']}], ++ ['DXVA2_ConfigPictureDecode', ['d3d9.h', 'dxva2api.h'], {'c_args': ['-D_WIN32_WINNT=0x0602']}], ++ ['VAPictureParameterBufferHEVC', ['va/va.h', 'va/va_dec_hevc.h']], ++ ['VAPictureParameterBufferVP8', ['va/va.h', 'va/va_dec_vp8.h']], ++ ['VAProcPipelineParameterBuffer', ['va/va.h', 'va/va_vpp.h']], ++ ['VAProcPipelineParameterBuffer', ['va/va.h', 'va/va_vpp.h']], ++ ['VAEncPictureParameterBufferH264', ['va/va.h', 'va/va_enc_h264.h']], ++ ['VAEncPictureParameterBufferHEVC', ['va/va.h', 'va/va_enc_hevc.h']], ++ ['VAEncPictureParameterBufferJPEG', ['va/va.h', 'va/va_enc_mpeg2.h']], ++ ['VAEncPictureParameterBufferMPEG2', ['va/va.h', 'va/va_enc_mpeg2.h']], ++ ['VAEncPictureParameterBufferVP8', ['va/va.h', 'va/va_enc_vp8.h']], ++ ['VAEncPictureParameterBufferVP9', ['va/va.h', 'va/va_enc_vp9.h']], ++ ['VdpPictureInfoHEVC', ['vdpau/vdpau.h']], ++ ['IBaseFilter', ['dshow.h']], ++ ['clCreateImageFromFdINTEL_fn', ['CL/cl_intel.h'], ++ {'preconditions': ['libdrm', 'opencl']}], ++ ['clCreateFromVA_APIMediaSurfaceINTEL_fn', ['CL/cl.h', 'CL/va_ext.h'], ++ {'preconditions': ['vaapi', 'opencl', 'libmfx']}], ++ ['cl_dx9_surface_info_khr', ['CL/cl_dx9_media_sharing.h'], ++ {'preconditions': ['dxva2', 'opencl']}], ++ ['clGetDeviceIDsFromD3D11KHR_fn', ['CL/cl_d3d11.h'], ++ {'preconditions': ['d3d11va', 'opencl']}], ++ ['struct addrinfo', ['netdb.h']], ++ ['struct group_source_req', ['netinet/in.h']], ++ ['struct ip_mreq_source', ['netinet/in.h']], ++ ['struct ipv6_mreq', ['netinet/in.h']], ++ ['struct pollfd', ['poll.h']], ++ ['struct sctp_event_subscribe', ['netinet/sctp.h']], ++ ['struct sockaddr_in6', ['netinet/in.h']], ++ ['struct sockaddr_storage', ['sys/types.h', 'sys/socket.h']], ++ ['socklen_t', ['sys/types.h', 'sys/socket.h']], ++ ['VdpPictureInfoHEVC', ['vdpau/vdpau.h']], ++ ['VdpPictureInfoVP9', ['vdpau/vdpau.h']], ++ ['VdpPictureInfoAV1', ['vdpau/vdpau.h']], ++] ++ ++if get_option('videotoolbox').allowed() ++ check_types += [ ++ ['kCMVideoCodecType_HEVC', ['CoreMedia/CMFormatDescription.h'], {'frameworks': ['CoreMedia']}], ++ ['kCMVideoCodecType_HEVCWithAlpha', ['CoreMedia/CMFormatDescription.h'], {'frameworks': ['CoreMedia']}], ++ ['kCMVideoCodecType_VP9', ['CoreMedia/CMFormatDescription.h'], {'frameworks': ['CoreMedia']}], ++ ['kCVPixelFormatType_420YpCbCr10BiPlanarVideoRange', ['CoreVideo/CVPixelBuffer.h'], {'frameworks': ['CoreVideo']}], ++ ['kCVPixelFormatType_422YpCbCr8BiPlanarVideoRange', ['CoreVideo/CVPixelBuffer.h'], {'frameworks': ['CoreVideo']}], ++ ['kCVPixelFormatType_422YpCbCr10BiPlanarVideoRange', ['CoreVideo/CVPixelBuffer.h'], {'frameworks': ['CoreVideo']}], ++ ['kCVPixelFormatType_422YpCbCr16BiPlanarVideoRange', ['CoreVideo/CVPixelBuffer.h'], {'frameworks': ['CoreVideo']}], ++ ['kCVPixelFormatType_444YpCbCr8BiPlanarVideoRange', ['CoreVideo/CVPixelBuffer.h'], {'frameworks': ['CoreVideo']}], ++ ['kCVPixelFormatType_444YpCbCr10BiPlanarVideoRange', ['CoreVideo/CVPixelBuffer.h'], {'frameworks': ['CoreVideo']}], ++ ['kCVPixelFormatType_444YpCbCr16BiPlanarVideoRange', ['CoreVideo/CVPixelBuffer.h'], {'frameworks': ['CoreVideo']}], ++ ['kCVImageBufferTransferFunction_SMPTE_ST_2084_PQ', ['CoreVideo/CVImageBuffer.h'], {'frameworks': ['CoreVideo']}], ++ ['kCVImageBufferTransferFunction_ITU_R_2100_HLG', ['CoreVideo/CVImageBuffer.h'], {'frameworks': ['CoreVideo']}], ++ ['kCVImageBufferTransferFunction_Linear', ['CoreVideo/CVImageBuffer.h'], {'frameworks': ['CoreVideo']}], ++ ['kCVImageBufferYCbCrMatrix_ITU_R_2020', ['CoreVideo/CVImageBuffer.h'], {'frameworks': ['CoreVideo']}], ++ ['kCVImageBufferColorPrimaries_ITU_R_2020', ['CoreVideo/CVImageBuffer.h'], {'frameworks': ['CoreVideo']}], ++ ['kCVImageBufferTransferFunction_ITU_R_2020', ['CoreVideo/CVImageBuffer.h'], {'frameworks': ['CoreVideo']}], ++ ['kCVImageBufferTransferFunction_SMPTE_ST_428_1', ['CoreVideo/CVImageBuffer.h'], {'frameworks': ['CoreVideo']}], ++ ] ++endif ++ ++if cc.has_header('arpa/inet.h') ++ conf.set('arpa_inet_h', 1) ++ check_funcs += [['closesocket']] ++elif cc.has_header('winsock2.h') ++ conf.set('winsock2_h', 1) ++ # FIXME network_extralibs ++ check_header_funcs += [ ++ ['closesocket', ['winsock2.h']], ++ ['getaddrinfo', ['ws2tcpip.h']], ++ ] ++ check_types += [ ++ ['socklen_t', ['ws2tcpip.h']], ++ ['struct addrinfo', ['ws2tcpip.h']], ++ ['struct group_source_req', ['ws2tcpip.h']], ++ ['struct ip_mreq_source', ['ws2tcpip.h']], ++ ['struct ipv6_mreq', ['ws2tcpip.h']], ++ ['struct pollfd', ['winsock2.h']], ++ ['struct sockaddr_in6', ['ws2tcpip.h']], ++ ['struct sockaddr_storage', ['ws2tcpip.h']], ++ ] ++endif ++ ++check_headers = [ ++ ['direct.h'], ++ ['dirent.h'], ++ ['dxgidebug.h'], ++ ['dxva.h'], ++ ['dxva2api.h', {'c_args': ['-D_WIN32_WINNT=0x0600']}], ++ ['mftransform.h'], ++ ['msa.h'], ++ ['net/udplite.h'], ++ ['sys/param.h'], ++ ['sys/resource.h'], ++ ['sys/select.h'], ++ ['sys/soundcard.h'], ++ ['sys/un.h'], ++ ['sys/videoio.h'], ++ ['termios.h'], ++ ['unistd.h'], ++ ['valgrind/valgrind.h'], ++ ['asm/types.h'], ++] ++ ++if host_machine.system() == 'darwin' ++ check_headers += [['dispatch/dispatch.h']] ++elif host_machine.system() == 'android' and get_option('jni').allowed() ++ check_headers += [['jni.h']] ++endif ++ ++foreach check : check_components ++ all_checks += [['component', check]] ++endforeach ++ ++foreach check : check_funcs ++ all_checks += [['func', check]] ++endforeach ++ ++foreach check : check_header_funcs ++ all_checks += [['header-func', check]] ++endforeach ++ ++foreach check : check_types ++ all_checks += [['type', check]] ++endforeach ++ ++foreach check : check_headers ++ all_checks += [['header', check]] ++endforeach ++ ++external_library_list = library_gpl_list + library_nonfree_list + library_version3_list + library_gplv3_list + [ ++ 'chromaprint', ++ 'gcrypt', ++ 'gnutls', ++ 'jni', ++ 'ladspa', ++ 'lcms2', ++ 'libaom', ++ 'libass', ++ 'libbluray', ++ 'libbs2b', ++ 'libcaca', ++ 'libcelt', ++ 'libcodec2', ++ 'libdav1d', ++ 'libdc1394', ++ 'libdrm', ++ 'libflite', ++ 'libfontconfig', ++ 'libfreetype', ++ 'libfribidi', ++ 'libglslang', ++ 'libgme', ++ 'libgsm', ++ 'libiec61883', ++ 'libilbc', ++ 'libjack', ++ 'libjxl', ++ 'libklvanc', ++ 'libkvazaar', ++ 'libmodplug', ++ 'libmp3lame', ++ 'libmysofa', ++ 'libopencv', ++ 'libopenh264', ++ 'libopenjpeg', ++ 'libopenmpt', ++ 'libopenvino', ++ 'libopus', ++ 'libplacebo', ++ 'libpulse', ++ 'librabbitmq', ++ 'librav1e', ++ 'librist', ++ 'librsvg', ++ 'librtmp', ++ 'libshaderc', ++ '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', ++ 'openssl', ++ 'pocketsphinx', ++ 'vapoursynth', ++] ++ ++hwaccel_autodetect_library_list = [ ++ 'amf', ++ 'audiotoolbox', ++ 'crystalhd', ++ 'cuda', ++ 'cuda_llvm', ++ 'cuvid', ++ 'd3d11va', ++ 'dxva2', ++ 'ffnvcodec', ++ 'nvdec', ++ 'nvenc', ++ 'vaapi', ++ 'vdpau', ++ 'videotoolbox', ++ 'vulkan', ++ 'v4l2_m2m', ++] ++ ++autodetect_libs = ( ++ external_autodetect_library_list + ++ hwaccel_autodetect_library_list + ++ threads_list ++) ++ ++# 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', ++ 'libvpl', ++ 'mmal', ++ 'omx', ++ 'opencl', ++] ++ ++subsystem_list = [ ++ 'dct', ++ 'dwt', ++ 'error_resilience', ++ 'faan', ++ 'fast_unaligned', ++ 'fft', ++ 'lsp', ++ 'mdct', ++ 'pixelutils', ++ 'network', ++ 'rdft', ++] ++ ++feature_list = [ ++ 'ftrapv', ++ 'gray', ++ 'hardcoded_tables', ++ 'omx_rpi', ++ 'runtime_cpudetect', ++ 'safe_bitstream_reader', ++ 'shared', ++ 'small', ++ 'static', ++ 'swscale_alpha', ++] ++ ++network_funcs = [ ++ 'getaddrinfo', ++ 'inet_aton', ++] ++ ++extra_funcs = [] ++ ++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', ++ 'deflate_wrapper', ++ 'dirac_parse', ++ 'dnn', ++ 'dovi_rpu', ++ 'dvprofile', ++ 'exif', ++ 'faandct', ++ 'faanidct', ++ 'fdctdsp', ++ 'fmtconvert', ++ 'frame_thread_encoder', ++ 'g722dsp', ++ 'golomb', ++ 'gplv3', ++ 'h263dsp', ++ 'h264chroma', ++ 'h264dsp', ++ 'h264parse', ++ 'h264pred', ++ 'h264qpel', ++ 'h264_sei', ++ 'hevcparse', ++ 'hevc_sei', ++ 'hpeldsp', ++ 'huffman', ++ 'huffyuvdsp', ++ 'huffyuvencdsp', ++ 'idctdsp', ++ 'iirfilter', ++ 'inflate_wrapper', ++ 'intrax8', ++ 'iso_media', ++ 'ividsp', ++ 'jpegtables', ++ 'lgplv3', ++ 'libx262', ++ 'llauddsp', ++ 'llviddsp', ++ 'llvidencdsp', ++ 'lpc', ++ 'lzf', ++ 'me_cmp', ++ 'mpeg_er', ++ 'mpegaudio', ++ 'mpegaudiodsp', ++ 'mpegaudioheader', ++ 'mpeg4audio', ++ 'mpegvideo', ++ 'mpegvideodec', ++ 'mpegvideoenc', ++ 'msmpeg4dec', ++ 'msmpeg4enc', ++ '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', ++] ++ ++license_list = [ ++ 'gpl', ++ 'nonfree', ++ 'version3', ++] ++ ++library_list = [ ++ 'avdevice', ++ 'avfilter', ++ 'swscale', ++ 'postproc', ++ 'avformat', ++ 'avcodec', ++ 'swresample', ++ 'avutil', ++] ++ ++program_list = [ ++ 'ffplay', ++ 'ffprobe', ++ 'ffmpeg', ++] ++ ++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 ++ ++foreach component : component_list ++ conf.set10(component, get_option(component).allowed()) ++endforeach ++ ++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', ++ 'macos_kperf', ++ 'memory_poisoning', ++ 'neon_clobber_test', ++ 'ossfuzz', ++ 'pic', ++ 'ptx_compression', ++ 'thumb', ++ 'valgrind_backtrace', ++ 'xmm_clobber_test', ++ ] + ++ component_list ++) ++ ++check_compiles = [ ++ ['v4l2_m2m', ['linux/videodev2.h'], 'int i = V4L2_CAP_VIDEO_M2M_MPLANE | V4L2_CAP_VIDEO_M2M | V4L2_BUF_FLAG_LAST;'], ++ ['pragma_deprecated', [], 'int main(void) {_Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\""); return 0; }'], ++ ['const_nan', ['math.h'], 'struct { double d; } static const bar[] = { { NAN } };'], ++ ['intrinsics_neon', ['arm_neon.h'], 'int16x8_t test = vdupq_n_s16(0);'], ++] ++ ++check_links = [ ++ ['stdatomic', ['stdatomic.h'], 'int main(void) {atomic_int foo, bar = ATOMIC_VAR_INIT(-1); atomic_store(&foo, 0); foo += bar;}', {'link_with': ['atomic']}], ++ ['stdatomic', ['stdatomic.h'], 'int main(void) {atomic_int foo, bar = ATOMIC_VAR_INIT(-1); atomic_store(&foo, 0); foo += bar;}'], ++] ++ ++v4l2m2m_formats = [ ++ ['vc1', 'VC1_ANNEX_G'], ++ ['mpeg1'], ++ ['mpeg2'], ++ ['mpeg4'], ++ ['hevc'], ++ ['h263'], ++ ['h264'], ++ ['vp8'], ++ ['vp9'], ++] ++ ++foreach format : v4l2m2m_formats ++ suffix = format.length() > 1 ? format[1] : format[0].to_upper() ++ check_compiles += [['@0@_v4l2_m2m'.format(format[0]), ['sys/time.h', 'linux/videodev2.h'], 'int i = V4L2_PIX_FMT_@0@;'.format(suffix)]] ++endforeach ++ ++foreach check : check_compiles ++ all_checks += [['compiles', check]] ++endforeach ++ ++foreach check : check_links ++ all_checks += [['links', check]] ++endforeach ++ ++foreach arch : arch_list ++ conf.set(arch, 0) ++endforeach ++ ++foreach lib : threads_list ++ conf.set(lib, 0) ++endforeach ++ ++foreach check_struct : check_structs ++ conf_name = '@0@_@1@'.format(check_struct[0].underscorify(), check_struct[1].underscorify()) ++ ++ conf.set10(conf_name, ++ cc.has_member(check_struct[0], check_struct[1], prefix : check_struct[2])) ++endforeach ++ ++foreach license : license_list ++ conf.set10(license, not get_option(license).disabled()) ++endforeach ++ ++foreach lib : library_list ++ conf.set10(lib, get_option(lib).allowed()) ++endforeach ++ ++arch = 'c' ++ ++cpu = host_machine.cpu_family() ++ ++if cpu == 'x86' ++ arch = 'x86' ++ conf.set('x86', 1) ++ conf.set('i686', 1) ++ conf.set('x86_32', 1) ++ conf.set('fast_cmov', 1) ++elif cpu == 'x86_64' ++ arch = 'x86' ++ conf.set('x86', 1) ++ conf.set('i686', 1) ++ conf.set('x86_64', 1) ++elif cpu == 'aarch64' ++ # FIXME: Implement assembly support for MSVC ++ # It relies on Meson adding support for armasm and MASM, ++ # see foreach check : asm_as_checks below. ++ if cc.get_id() == 'msvc' ++ warning('Using aarch64 assembly on MSVC is not yet supported by Meson.') ++ else ++ arch = 'aarch64' ++ conf.set('aarch64', 1) ++ endif ++elif cpu == 'arm' ++ arch = 'arm' ++ conf.set('arm', 1) ++endif ++ ++foreach feature : arch_features ++ name = feature[0] ++ have = false ++ conditions = feature[1] ++ foreach condition: conditions ++ if conf.get(condition, 0) == 1 ++ have = true ++ endif ++ endforeach ++ ++ conf.set10(name, have) ++endforeach ++ ++if cc.get_id() == 'clang' ++ if conf.get('x86_32') == 1 ++ # Clang doesn't support maintaining alignment without assuming the ++ # same alignment in every function. If 16 byte alignment would be ++ # enabled, one would also have to either add attribute_align_arg on ++ # every single entry point into the libraries or enable -mstackrealign ++ # (doing stack realignment in every single function). ++ ++ if ['windows', 'freebsd', 'netbsd', 'openbsd'].contains(host_machine.system()) ++ conf.set('aligned_stack', 0) ++ else ++ project_c_args += cc.get_supported_arguments([ ++ '-mllvm -stack-alignment=16', ++ '-mstack-alignment=16' ++ ]) ++ endif ++ else ++ project_c_args += cc.get_supported_arguments([ ++ '-mllvm -stack-alignment=16', ++ '-mstack-alignment=16' ++ ]) ++ endif ++elif cc.get_id() == 'msvc' ++ if conf.get('x86_32') == 1 ++ conf.set('aligned_stack', 0) ++ endif ++ # the new SSA optimzer in VS2015 U3 is mis-optimizing some parts of the code ++ # Issue has been fixed in MSVC v19.00.24218. ++ if cc.links(cpp_cond.format('windows.h', '_MSC_FULL_VER < 190024218')) ++ project_c_args += cc.get_supported_arguments([ ++ 'd2SSAOptimizer-' ++ ]) ++ endif ++ if conf.get('x86_32') == 1 and (get_option('buildtype') == 'debug' or get_option('optimization') == '0') ++ project_c_args += cc.get_supported_arguments([ ++ '-Oy-' ++ ]) ++ endif ++endif ++ ++conf.set10('static', get_option('default_library') != 'shared') ++conf.set10('shared', get_option('default_library') != 'static') ++ ++conf.set10('bigendian', host_machine.endian() == 'big') ++conf.set10('fast_unaligned', ['x86', 'x86_64', 'aarch', 'ppc'].contains(host_machine.cpu_family())) ++ ++if conf.get('float16') == 1 ++ if conf.get('x86') == 1 ++ # https://developercommunity.visualstudio.com/t/AVX512F-does-not-allow-detecting-the-F16/10345004 ++ conf.set10('fast_float16', cc.links(cpp_cond.format('stddef.h', 'defined(__F16C__) || defined(__AVX2__)'), args: project_c_args)) ++ elif conf.get('arm') == 1 or conf.get('aarch64') == 1 ++ conf.set10('fast_float16', true) ++ endif ++endif ++ ++conf.set('frame_thread_encoder', 1) ++ ++# these filters depend on removed avcodec APIs ++# they are kept disabled for now, but will be removed if ++# nobody updates and re-enables them ++conf.set('mcdeint_filter', 0) ++conf.set('uspp_filter', 0) ++ ++if host_machine.system() == 'windows' ++ conf.set('symver', 0) ++ conf.set('dos_paths', 1) ++ # https://ffmpeg.org/pipermail/ffmpeg-devel/2023-August/313023.html ++ project_c_args += cc.get_supported_arguments('-DWIN32_LEAN_AND_MEAN', '-wd4005', '-Wp,-w') ++endif ++ ++if ['linux', 'openbsd', 'android'].contains(host_machine.system()) ++ conf.set('section_data_rel_ro', 1) ++endif ++ ++foreach f : test_check_framework ++ name = f.underscorify().to_lower() ++ dep = dependency('appleframeworks', modules: f, required: false) ++ conf.set10(name, false) ++ if cc.has_header('@0@/@0@.h'.format(f), dependencies: dep) ++ conf.set10(name, true) ++ common_deps += [dep] ++ endif ++endforeach ++ ++# Our option names can't be 1:1 mapping because newer meson versions disallow ++# options with language prefixes i.e. "cuda_sdk" in our case ++options_map = { ++ 'cuda_llvm' : 'ff_cuda_llvm', ++ 'cuda_sdk' : 'ff_cuda_sdk', ++ 'linux_fb_h' : 'linux_fbdev', ++} ++ ++# Mark specifically enabled, but normally autodetected libraries as requested. ++foreach component : autodetect_libs ++ opt_name = options_map.get(component, component) ++ if get_option(opt_name).enabled() ++ conf.set10(component, true) ++ endif ++endforeach ++ ++foreach check : all_checks ++ check_type = check[0] ++ check = check[1] ++ ++ name = check[0] ++ opt_name = options_map.get(name, name) ++ ++ if check_type == 'func' ++ headers = [] ++ elif check_type == 'header' ++ headers = [name] ++ elif check_type == 'framework' ++ headers = ['@0@/@0@.h'.format(name)] ++ else ++ headers = check[1] ++ endif ++ ++ opts = {} ++ link_withs = [] ++ frameworks = [] ++ funcs = [] ++ compiles = '' ++ links = '' ++ type = '' ++ ++ if check_type == 'pkg-config' ++ if check.length() > 3 ++ opts = check[3] ++ endif ++ elif check_type == 'component' ++ link_withs = check[3] ++ if check.length() > 4 ++ opts = check[4] ++ endif ++ elif check_type == 'header-func' ++ if check.length() > 2 ++ opts = check[2] ++ endif ++ elif check_type == 'func' or check_type == 'header' ++ if check.length() > 1 ++ opts = check[1] ++ endif ++ elif check_type == 'compiles' ++ if check.length() > 3 ++ opts = check[3] ++ endif ++ compiles = check[2] ++ elif check_type == 'links' ++ if check.length() > 3 ++ opts = check[3] ++ endif ++ links = check[2] ++ elif check_type == 'type' ++ if check.length() > 2 ++ opts = check[2] ++ endif ++ type = name ++ elif check_type == 'framework' ++ opt_name = name.underscorify().to_lower() ++ frameworks = [name] ++ endif ++ ++ if check_type == 'header-func' or check_type == 'func' ++ funcs = opts.get('funcs', [name]) ++ elif check_type == 'pkg-config' or check_type == 'component' ++ funcs = check[2] ++ endif ++ ++ if check_type != 'component' ++ link_withs = opts.get('link_with', []) ++ endif ++ if check_type != 'framework' ++ frameworks = opts.get('frameworks', []) ++ endif ++ ++ found = false ++ ++ if conf.get(name.underscorify(), 0) == 0 ++ defines = opts.get('defines', []) ++ has_any_func = opts.get('has_any_func', false) ++ c_args = opts.get('c_args', []) ++ extra_deps = [] ++ ++ foreach dep_name : opts.get('extra_deps', []) ++ extra_deps += [get_variable(dep_name, [])] ++ endforeach ++ ++ prefix = '' ++ ++ found = true ++ ++ preconditions = opts.get('preconditions', []) ++ ++ foreach precondition : preconditions ++ if precondition in autodetect_libs ++ opt_name = options_map.get(precondition, precondition) ++ if get_option(opt_name).allowed() ++ found = found and conf.get(precondition, 1) == 1 ++ else ++ found = found and conf.get(precondition, 0) == 1 ++ endif ++ else ++ found = found and conf.get(precondition) == 1 ++ endif ++ endforeach ++ ++ # FIXME: or should these just be preconditions in the list above instead? ++ disabled = false ++ if get_option('gpl').disabled() ++ gpl_list = library_gpl_list + library_gplv3_list ++ disabled = gpl_list.contains(name) ++ endif ++ if get_option('version3').disabled() ++ v3_list = library_gplv3_list + library_version3_list ++ disabled = disabled or v3_list.contains(name) ++ endif ++ if get_option('nonfree').disabled() ++ nonfree_list = library_nonfree_list + hwaccel_library_nonfree_list ++ disabled = disabled or nonfree_list.contains(name) ++ endif ++ ++ if disabled ++ if get_option(opt_name).enabled() ++ error('Incompatible options combination: @0@ requested, but has disabled license.'.format(name)) ++ endif ++ message('Skipping @0@ because of license'.format(name)) ++ found = false ++ endif ++ ++ if found ++ if check_type == 'framework' ++ foreach f : frameworks ++ req = get_option(opt_name) ++ dep = dependency('appleframeworks', modules : f, required: req) ++ found = found and dep.found() ++ extra_deps += dep ++ endforeach ++ elif check_type != 'pkg-config' ++ foreach link_with : link_withs ++ if check_type == 'component' and not ('always-check' in opts) ++ req = get_option(opt_name) ++ else ++ req = false ++ endif ++ dep = cc.find_library(link_with, required : req) ++ found = found and dep.found() ++ extra_deps += dep ++ endforeach ++ foreach f : frameworks ++ if check_type == 'component' and not ('always-check' in opts) ++ req = get_option(opt_name) ++ else ++ req = false ++ endif ++ dep = dependency('appleframeworks', modules : f, required: req) ++ found = found and dep.found() ++ extra_deps += dep ++ endforeach ++ else ++ req = get_option(opt_name) ++ pkg_name = opts.get('pkg', name) ++ if opts.has_key('versions') ++ foreach version: opts['versions'] ++ dep = dependency(pkg_name, required: false, version: version) ++ endforeach ++ ++ if not dep.found() and req.enabled() ++ error('@0@ @1@ could not be found'.format(pkg_name, opts['versions'])) ++ endif ++ elif opts.has_key('version') ++ dep = dependency(pkg_name, required : req, version: opts.get('version')) ++ else ++ dep = dependency(pkg_name, required : req) ++ endif ++ found = dep.found() and dep.type_name() != 'internal' ++ extra_deps += dep ++ endif ++ endif ++ ++ if found ++ foreach header : headers ++ if header.endswith('.h') ++ prefix += '#include <@0@>\n'.format(header) ++ else ++ prefix += '#include @0@\n'.format(header) ++ endif ++ ++ if not conf.has(header.underscorify()) ++ has_header = cc.has_header(header, dependencies: extra_deps) ++ conf.set10(header.underscorify().to_lower(), has_header) ++ found = found and has_header ++ endif ++ endforeach ++ endif ++ ++ if found ++ n_funcs_found = 0 ++ foreach symbol : funcs ++ if check_type == 'header-func' ++ if cc.has_header_symbol(headers[0], symbol, dependencies : extra_deps, prefix: prefix, args : c_args + project_c_args) ++ n_funcs_found += 1 ++ endif ++ else ++ if cc.has_function(symbol, dependencies : extra_deps, prefix: prefix, args : c_args + project_c_args) ++ n_funcs_found += 1 ++ endif ++ endif ++ endforeach ++ if has_any_func ++ found = n_funcs_found >= 1 ++ else ++ found = n_funcs_found == funcs.length() ++ endif ++ endif ++ ++ if found ++ n_defines_found = 0 ++ foreach symbol : defines ++ if cc.get_define(symbol, dependencies : extra_deps, prefix: prefix, args : c_args + project_c_args) != '' ++ n_defines_found += 1 ++ endif ++ endforeach ++ found = n_defines_found == defines.length() ++ endif ++ ++ if found and compiles != '' ++ found = cc.compiles('\n\n'.join([prefix, compiles]), dependencies : extra_deps, args : c_args + project_c_args, name: name) ++ endif ++ ++ if found and links != '' ++ found = cc.links('\n\n'.join([prefix, links]), dependencies : extra_deps, args : c_args + project_c_args, name: name) ++ endif ++ ++ if found and type != '' ++ found = cc.has_type(type, prefix : prefix, dependencies : extra_deps, args : c_args + project_c_args) ++ endif ++ ++ if check_type != 'header' ++ conf.set10(name.underscorify().to_lower(), found) ++ endif ++ ++ foreach symbol : funcs + defines ++ conf.set10(symbol.to_lower(), found) ++ endforeach ++ ++ if found ++ set_variable('@0@_extra_deps'.format(name.underscorify().to_lower()), extra_deps) ++ else ++ set_variable('@0@_extra_deps'.format(name.underscorify().to_lower()), []) ++ endif ++ endif ++endforeach ++ ++# MANUAL: Mathieu already treats all enables as enable_weak. But they can ++# only be enabled if the check is missing (ie. they're placeholders) ++# or they've already passed ++foreach component : external_autodetect_library_list + hwaccel_autodetect_library_list ++ opt_name = options_map.get(component, component) ++ if conf.get(component, 1) == 1 ++ conf.set10(component, get_option(opt_name).allowed()) ++ endif ++endforeach ++ ++xcrun = disabler() ++bin2c = disabler() ++metalcc = disabler() ++metallib = disabler() ++ ++if conf.get('metal') == 1 ++ appleclang_sdk = '' ++ # determine the subsystem ++ is_macos = cc.get_define('TARGET_OS_OSX', prefix: '#include <TargetConditionals.h>') ++ is_ios = cc.get_define('TARGET_OS_IOS', prefix: '#include <TargetConditionals.h>') ++ is_tvos = cc.get_define('TARGET_OS_TV', prefix: '#include <TargetConditionals.h>') ++ if is_ios == '1' ++ appleclang_sdk = 'iphoneos' ++ elif is_tvos == '1' ++ appleclang_sdk = 'tvos' ++ elif is_macos == '1' ++ appleclang_sdk = 'macos' ++ else ++ warning('Unable to detect target OS SDK for Metal, assuming macOS') ++ appleclang_sdk = 'macos' ++ endif ++ ++ xcrun = find_program('xcrun', required: true) ++ ++ if run_command(xcrun, '-sdk', appleclang_sdk, 'metal', '-v', check: false).returncode() == 0 ++ metalcc = generator(xcrun, ++ output : '@BASENAME@.metalair', ++ arguments: ['-sdk', 'macosx', 'metal', '@INPUT@', '-o', '@OUTPUT@'] ++ ) ++ metallib = generator(xcrun, ++ output : '@BASENAME@.metallib', ++ arguments: ['-sdk', 'macosx', 'metallib', '--split-module-without-linking', '@INPUT@', '-o', '@OUTPUT@'] ++ ) ++ bin2c_exe = find_program('ffbuild/bin2c.py', required: get_option('metal')) ++ bin2c = generator(bin2c_exe, ++ output : '@BASENAME@.metallib.c', ++ arguments: ['@INPUT@', '@OUTPUT@'] ++ ) ++ else ++ conf.set10('metal', false) ++ endif ++endif ++ ++if conf.get('w32threads') == 0 and conf.get('pthreads') == 0 ++ conf.set10('w32threads', cc.has_function('_beginthreadex', prefix: '#include <process.h>') ++ and cc.has_type('CONDITION_VARIABLE', prefix : '#include <windows.h>') ++ and cc.has_type('INIT_ONCE', prefix : '#include <windows.h>')) ++ ++ if conf.get('w32threads') == 0 and conf.get('winrt') == 1 ++ conf.set10('w32threads', cc.has_function('CreateThread', prefix: '#include <windows.h>') ) ++ endif ++endif ++ ++# check for some common methods of building with pthread support ++# do this before the optional library checks as some of them require pthreads ++if conf.get('pthreads') == 0 and conf.get('w32threads') == 0 and conf.get('os2threads') == 0 ++ conf.set10('pthreads', cc.links(''' ++ #include <pthread.h> ++ int main() ++ { ++ static pthread_mutex_t atomic_lock = PTHREAD_MUTEX_INITIALIZER; ++ return 0; ++ } ++ ''', name: 'the thread library is pthreads', dependencies: thread_dep)) ++ if conf.get('pthreads') == 1 ++ conf.set10('sem_timedwait', cc.links(''' ++ #include <semaphore.h> ++ int main() ++ { ++ sem_t *s; sem_init(s,0,0); sem_timedwait(s,0); sem_destroy(s); ++ return 0; ++ } ++ ''', name: 'has pthreads semaphores available', dependencies: thread_dep)) ++ conf.set10('pthread_cancel', cc.has_function('pthread_cancel', dependencies: thread_dep)) ++ endif ++endif ++ ++if host_machine.system() == 'android' and get_option('jni').allowed() ++ if conf.get('jni_h') == 1 and not (conf.get('pthreads') == 1) ++ error('jni not found') ++ endif ++endif ++ ++# FIXME: the source parser needs a case for the TLS-OBJS ++are_protocols_disabled = get_option('protocols').disabled() ++if get_option('tls_protocol').disable_auto_if(are_protocols_disabled).disabled() ++ conf.set10('gnutls', false) ++ conf.set10('openssl', false) ++ conf.set10('schannel', false) ++ conf.set10('securetransport', false) ++ conf.set10('libtls', false) ++ conf.set10('mbedtls', false) ++endif ++ ++if conf.get('gnutls') == 1 and conf.get('openssl') == 1 ++ error('GnuTLS and OpenSSL must not be enabled at the same time.') ++endif ++ ++if conf.get('gnutls') == 1 and conf.get('mbedtls') == 1 ++ error('GnuTLS and mbedTLS must not be enabled at the same time.') ++endif ++ ++if conf.get('openssl') == 1 and conf.get('mbedtls') == 1 ++ error('OpenSSL and mbedTLS must not be enabled at the same time.') ++endif ++ ++# Manual check for OpenSSL ++if conf.get('openssl') == 1 ++ test_openssl_dep = dependency('openssl', required: false, version: '>= 3.0.0') ++ if test_openssl_dep.found() ++ is_blocked_by_license = not get_option('version3').disabled() or get_option('gpl').disabled() or not get_option('nonfree').disabled() ++ if is_blocked_by_license ++ error('OpenSSL >=3.0.0 requires -Dversion3=enabled') ++ endif ++ else ++ is_blocked_by_license = not get_option('gpl').disabled() and get_option('nonfree').disabled() ++ if is_blocked_by_license ++ error('OpenSSL <3.0.0 is incompatible with the gpl') ++ endif ++ endif ++endif ++ ++schannel_extra_deps = [] ++ ++if conf.get('schannel') == 1 ++ secur32_dep = cc.find_library('secur32', required: false) ++ if cc.links(cpp_cond.format('winerror.h', 'defined(SEC_I_CONTEXT_EXPIRED)'), dependencies: secur32_dep, name: 'schannel dependency works') ++ schannel_extra_deps += [secur32_dep] ++ else ++ conf.set('schannel', 0) ++ endif ++endif ++ ++# Manual check for avisynth ++if conf.get('avisynth') == 1 ++ if not cc.links(cpp_cond.format('avisynth/avs/version.h', 'AVS_MAJOR_VER >= 3 && AVS_MINOR_VER >= 7 && AVS_BUGFIX_VER >= 1 || AVS_MAJOR_VER >= 3 && AVS_MINOR_VER > 7 || AVS_MAJOR_VER > 3'), name: 'avisynth version') ++ error('AviSynth+ header version must be >= 3.7.1') ++ endif ++endif ++ ++# Manual check for libmfx ++if conf.get('libmfx') == 1 ++ if not cc.links(cpp_cond.format('mfx/mfxdefs.h', 'MFX_VERSION >= 1028 && MFX_VERSION < 2000'), name: 'libmfx version') ++ error('libmfx version must be >= 1.28 and < 2.0') ++ else ++ warning('build FFmpeg against libmfx 1.x, obsolete features of libmfx such as OPAQUE memory,') ++ warning('multi-frame encode, user plugins and LA_EXT rate control mode are enabled') ++ endif ++ conf.set10('MFX_CODEC_VP9'.to_lower(), cc.has_header_symbol('mfxstructures.h', 'MFX_CODEC_VP9')) ++endif ++ ++# Manual check for libx264 ++if conf.get('libx264') == 1 ++ if is_msvc ++ if not cc.links(cpp_cond.format('x264.h', 'X264_BUILD >= 122'), name: 'libx264 version') ++ warning('libx264 version must be >= 1.22') ++ conf.set('libx264', 0) ++ endif ++ else ++ if not cc.links(cpp_cond.format('x264.h', 'X264_BUILD >= 158'), name: 'libx264 version') ++ warning('libx264 version must be >= 1.58') ++ conf.set('libx264', 0) ++ endif ++ endif ++endif ++ ++if conf.get('libmfx') == 1 and conf.get('libvpl') == 1 ++ error('can not use libmfx and libvpl together') ++endif ++ ++if conf.get('opengl') == 1 and not cc.has_header('GL/glext.h') ++ conf.set('opengl', 0) ++endif ++ ++if conf.get('libx265') == 1 ++ if not cc.links(cpp_cond.format('x265.h', 'X265_BUILD >= 89'), name: 'libx265 version') ++ warning('X265_BUILD too old, disabling') ++ conf.set('libx265', 0) ++ endif ++endif ++ ++if conf.get('libzvbi') == 1 ++ conf.set('libzvbi', cc.compute_int( ++ 'VBI_VERSION_MAJOR > 0 || VBI_VERSION_MINOR > 2 || VBI_VERSION_MINOR == 2 && VBI_VERSION_MICRO >= 28', ++ prefix: '#include <libzvbi.h>', dependencies: libzvbi_extra_deps)) ++endif ++ ++foreach req : ['xlib_x11', 'xlib_xext', 'xlib_xv'] ++ if conf.get(req) == 0 ++ conf.set10('xlib', false) ++ break ++ endif ++endforeach ++ ++x86asm_type = 'none' ++ ++x86asm_checks = [] ++ ++asm_inline_checks = [ ++ ['"1:\\n"', 'inline_asm_labels'], ++ ['"Label:\\n"', 'inline_asm_nonlocal_labels'] ++] ++ ++extern_prefix = cc.symbols_have_underscore_prefix() ? '_' : '' ++ ++asm_insn_checks = [] ++ ++asm_as_checks = [] ++ ++if host_machine.system() == 'windows' ++ asm_format = conf.get('x86_64') == 1 ? 'win64' : 'win32' ++elif host_machine.system() == 'darwin' ++ asm_format = conf.get('x86_64') == 1 ? 'macho64' : 'macho32' ++else ++ asm_format = conf.get('x86_64') == 1 ? 'elf64' : 'elf32' ++endif ++ ++conf.set('x86asm', 0) ++asm_args = [] ++ ++if conf.get('pic') == 1 ++ project_c_args += ['-DPIC'] ++ asm_args += ['-DPIC'] ++endif ++ ++if conf.get('x86') == 1 ++ is_broken_android_api = cc.links(cpp_cond.format('android/api-level.h', '__ANDROID_API__ < 24'), name: 'compiling for Android API <24') ++ ++ if is_broken_android_api and conf.get('x86_64') == 0 ++ # https://stackoverflow.com/questions/34691970/ffmpeg-for-android-neon-build-has-text-relocations/34697703#34697703 ++ # https://issuetracker.google.com/issues/37067983 ++ # https://trac.ffmpeg.org/ticket/4928 ++ warning('Disabling inline assembly due to Google banning non-position independent assembly code.') ++ conf.set10('inline_asm', false) ++ endif ++ ++ # Manual: check for binutils enforcing value ranges ++ # https://sourceware.org/bugzilla/show_bug.cgi?id=30578 ++ # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=108941 ++ if conf.get('inline_asm') == 1 ++ _binutils_bug_args = [] ++ if get_option('optimization') != '0' ++ _binutils_bug_args += ['-O@0@'.format(get_option('optimization'))] ++ endif ++ if not cc.compiles( ++ ''' ++ #include <stdint.h> ++ #include <string.h> ++ ++ typedef struct GetBitContext { ++ const uint8_t *buffer; ++ int index; ++ } GetBitContext; ++ ++ union unaligned_32 { uint32_t l; } __attribute__((packed)) __attribute__((may_alias)); ++ ++ static __attribute__((always_inline)) inline __attribute__((const)) uint32_t av_bswap32(uint32_t x) ++ { ++ return ((((x) << 8 & 0xff00) | ((x) >> 8 & 0x00ff)) << 16 | ((((x) >> 16) << 8 & 0xff00) | (((x) >> 16) >> 8 & 0x00ff))); ++ } ++ ++ static inline uint32_t NEG_USR32(uint32_t a, int8_t s){ ++ __asm__ ("shrl %1, %0\n\t" ++ : "+r" (a) ++ : "ic" ((uint8_t)(-s)) ++ ); ++ return a; ++ } ++ ++ static inline unsigned int get_bits(GetBitContext *s, int n) ++ { ++ register unsigned int tmp; ++ unsigned int re_index = (s)->index; unsigned int __attribute__((unused)) re_cache; ++ ((void)0); ++ re_cache = av_bswap32((((const union unaligned_32 *) ((s)->buffer + (re_index >> 3)))->l)) << (re_index & 7); ++ tmp = NEG_USR32(re_cache, n); ++ return tmp; ++ } ++ ++ typedef struct AC3HeaderInfo { ++ uint8_t sr_code; ++ } AC3HeaderInfo; ++ ++ typedef enum { ++ AAC_AC3_PARSE_ERROR_SAMPLE_RATE = -0x3030c0a, ++ } AACAC3ParseError; ++ ++ int ff_ac3_parse_header(GetBitContext *gbc, AC3HeaderInfo *hdr) ++ { ++ hdr->sr_code = get_bits(gbc, 2); ++ return 0; ++ } ++ ++ ''', ++ name: 'binutils has a working shrl instruction, Sourceware #30578, GCC # 108941', ++ args: _binutils_bug_args ++ ) ++ warning('''Your version of binutils rejects undefined behaviour which ++ FFmpeg relies on, when optimization levels are set to higher than -O0. ++ Please contact the developers and forward these references: ++ ++ https://sourceware.org/bugzilla/show_bug.cgi?id=30578 ++ https://gcc.gnu.org/bugzilla/show_bug.cgi?id=108941 ++ ++ and the included test case. ++ ++ Disabling inline assembly now, there may be a performance hit. ++ ''') ++ conf.set('inline_asm', 0) ++ endif ++ endif ++ ++ conf.set10('rdtsc', cc.has_function('__rdtsc', prefix: '#include <intrin.h>')) ++ conf.set10('mm_empty', cc.has_function('_mm_empty', prefix: '#include <mmintrin.h>')) ++ ++ conf.set('local_aligned', 1) ++ ++ # Manual: the configure script never checks if x86asm is enabled outside ++ # of an x86 context. So I fix those semantics here. ++ conf.set10('x86asm', get_option('asm').allowed() and (conf.get('mmx', 1) == 1) and get_option('x86asm').allowed()) ++ ++ # Manual: Skip Nasm building for iOS simulator because of an Apple lld bug ++ # ld: warning: ignoring file libavutil.a, building for iOS Simulator-x86_64 but ++ # attempting to link with file built for iOS Simulator-x86_64 ++ is_simulator = false ++ if cc.has_header('TargetConditionals.h') ++ is_simulator = cc.get_define('TARGET_OS_SIMULATOR', prefix: '#include <TargetConditionals.h>') == '1' ++ endif ++ if is_simulator ++ warning('Disabling inline assembly because Apple Clang cannot link Nasm assembly for the Simulator.') ++ conf.set10('x86asm', false) ++ endif ++ ++ if conf.get('x86asm') == 1 ++ conf.set('x86asm', 0) ++ nasm_version = '>=0' ++ if host_machine.system() == 'windows' ++ nasm_version = '>=2.12' ++ endif ++ x86asm = find_program('nasm', version: nasm_version, required: false) ++ x86asm_type = 'nasm' ++ if not x86asm.found() ++ subproject('win-nasm') ++ x86asm = find_program('nasm', version: nasm_version, required: false) ++ endif ++ if not x86asm.found() ++ x86asm = find_program('yasm', required: false) ++ x86asm_type = 'yasm' ++ endif ++ conf.set10('x86asm', x86asm.found()) ++ if x86asm.found() ++ if cc.get_linker_id().contains('lld') and cpu == 'x86' and not ['windows', 'cygwin'].contains(host_machine.system()) ++ # x86inc.asm ignores the PIC flag when compiling for x86 which unfortunately ++ # causes text relocations in the object files generated by the assembler. We ++ # must disable the warning to allow linking with lld. Unlike gold, ld which ++ # will silently allow text relocations, lld support must be explicit. ++ # ++ # See https://crbug.com/911658#c19 for more information. Tracked upstream at ++ # https://trac.ffmpeg.org/ticket/7878 ++ add_project_link_arguments('-Wl,-z,notext', language: 'c') ++ endif ++ x86asm_checks += [ ++ ['CPU amdnop', 'cpunop'], ++ ['vmovdqa32 [eax]{k1}{z}, zmm0', 'avx512_external'], ++ ['vpdpwssds zmm31{k1}{z}, zmm29, zmm28', 'avx512icl_external'], ++ ['vextracti128 xmm0, ymm0, 0', 'avx2_external'], ++ ['vfmaddps ymm0, ymm1, ymm2, ymm3', 'fma4_external'], ++ ['vpmacsdd xmm0, xmm1, xmm2, xmm3', 'xop_external'], ++ ] ++ ++ asm_inline_checks += [ ++ ['"":::"%xmm0"', 'xmm_clobbers'], ++ ['"pabsw %xmm0, %xmm0"', 'ssse3_inline'], ++ ['"pmaxub %mm0, %mm1"', 'mmxext_inline'], ++ ] ++ endif ++ endif ++ ++ ebp_available = false ++ ebp_available_test = '''#include <signal.h> ++ static void sighandler(int sig){ ++ raise(SIGTERM); ++ } ++ int foo(void){ ++ volatile int i=0; ++ __asm__ volatile ("xorl %%ebp, %%ebp" ::: "%ebp"); ++ return i; ++ } ++ 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(); ++ } ++ ''' ++ if meson.is_cross_build() ++ ebp_available = cc.links(ebp_available_test, name: 'if_ebp_available_this_should_crash') ++ else ++ ebp_available = cc.run(ebp_available_test, name: 'if_ebp_available_this_should_crash').returncode() != 0 ++ endif ++ ++ # FFmpeg upstream doesn't know that EBP is always unavailable ++ # under Clang if stack realignment is used. This is probably ++ # because the only compilers still supporting the architecture ++ # are the Android NDK and MSYS CLANG32. ++ # Thus an additional check on aligned_stack is done here. ++ # See: ++ # - https://github.com/android/ndk/issues/693 ++ # - https://bugs.llvm.org/show_bug.cgi?id=37542 ++ if is_broken_android_api and conf.get('x86_64') == 0 ++ warning('''x86 targets prior to Android Nougat (API 24) need ++ -mstackrealign to properly align stack for global constructors. ++ See https://github.com/android-ndk/ndk/issues/635''') ++ project_c_args += ['-mstackrealign'] ++ ++ # Zero in EBP because the preamble now consumes an additional register. ++ ebp_available = false ++ endif ++ conf.set10('ebp_available', conf.get('aligned_stack') == 1 and ebp_available) ++ ++ asm_inline_checks += [ ++ ['""::"b"(0)', 'ebx_available_1'], ++ ['"":::"%ebx"', 'ebx_available_2'], ++ ['"movl @0@test, %eax"'.format(extern_prefix), 'inline_asm_direct_symbol_refs_1'], ++ ['"movl @0@test(%rip), %eax"'.format(extern_prefix), 'inline_asm_direct_symbol_refs_2'], ++ ['"":::"%xmm0"', 'xmm_clobbers'], ++ ['"pabsw %xmm0, %xmm0"', 'ssse3_inline'], ++ ['"pmaxub %mm0, %mm1"', 'mmxext_inline'], ++ ] ++elif conf.get('aarch64') == 1 ++ asm_insn_checks += [ ++ ['prfm pldl1strm, [x0]', 'armv8'], ++ ['ext v0.8B, v0.8B, v1.8B, #1', 'neon'], ++ ['fmadd d0, d0, d1, d2', 'vfp'], ++ ] ++elif conf.get('arm') == 1 ++ if cc.has_argument('-mfp16-format=ieee') ++ project_c_args += ['-mfp16-format=ieee'] ++ endif ++ ++ if cc.get_id() == 'msvc' ++ conf.set10('thumb', cc.has_header_symbol('stddef.h', '_M_ARMT')) ++ endif ++ if cc.has_header_symbol('stddef.h', '__thumb__') ++ conf.set10('thumb', cc.compiles( ++ 'float func(float a, float b){ return a+b; }', ++ name: 'weak_thumb')) ++ endif ++ if conf.get('thumb', 0) == 1 ++ if cc.has_argument('-mthumb') ++ project_c_args += ['-mthumb'] ++ endif ++ elif cc.has_argument('-marm') ++ project_c_args += ['-marm'] ++ endif ++ ++ if cc.has_header_symbol('stddef.h', '__ARM_PCS_VFP') ++ conf.set('vfp_args', 1) ++ elif cc.links(cpp_cond.format('stddef.h', 'defined _M_ARM_FP && _M_ARM_FP >= 30'), name: 'vfp_args_fp') ++ conf.set('vfp_args', 1) ++ elif not cc.links(cpp_cond.format('stddef.h', 'defined __ARM_PCS || defined __SOFTFP__'), name: 'arm_pcs_or_softfp') and host_machine.system() != 'darwin' ++ if not cc.has_header_symbol('stddef.h', '__SOFTFP__') ++ conf.set('vfp_args', 1) ++ conf.set('fpabi', 'vfp') ++ elif cc.links('__asm__ (".eabi_attribute 28, 1"); int main(void) { return 0; }', name: 'vfp_abi_check') ++ conf.set('vfp_args', 1) ++ conf.set('fpabi', 'vfp') ++ else ++ conf.set('fpabi', 'soft') ++ endif ++ ++ message('Floating point ABI: @0@'.format(conf.get('fpabi'))) ++ endif ++ ++ asm_insn_checks += [ ++ ['qadd r0, r0, r0', 'armv5te'], ++ ['sadd16 r0, r0, r0', 'armv6'], ++ ['movt r0, #0', 'armv6t2'], ++ ['vadd.i16 q0, q0, q0', 'neon'], ++ ['fadds s0, s0, s0', 'vfp'], ++ ['vmov.f32 s0, #1.0', 'vfpv3'], ++ ['setend be', 'setend'] ++ ] ++ ++ asm_inline_checks += [ ++ ['"add r0, %Q0, %R0" :: "r"((long long)0)', 'asm_mod_q'] ++ ] ++ ++ asm_as_checks += [ ++ ['.arch armv7-a', 'as_arch_directive'], ++ ['ra .dn d0.i16', 'as_dn_directive'], ++ ['.fpu neon', 'as_fpu_directive'] ++ ] ++ ++ # llvm's integrated assembler supports .object_arch from llvm 3.5 ++ if asm_format == 'elf32' or asm_format == 'elf64' ++ asm_as_checks += [ ++ ['.object_arch armv4', 'as_object_arch'] ++ ] ++ endif ++endif ++ ++# Add debug args explicitly ++# yasm: `-g <format>` ++# nasm: ` -g -F <format>` ++# The only modern debugging format supported by either is DWARF ++# ++# nasm and yasm don't support DWARF in the PE format (Windows) ++if asm_format.startswith('win') ++ if cc.get_define('_MSC_FULL_VER') != '' ++ debug_format = 'cv8' ++ else ++ debug_format = 'null' ++ endif ++else ++ # Supported on Linux, BSD, macOS ++ debug_format = 'dwarf' ++endif ++# Add the format args ++if x86asm_type == 'yasm' ++ if debug_format == 'dwarf' ++ asm_args += ['-g', 'dwarf2'] ++ elif debug_format == 'cv8' ++ asm_args += ['-g', 'cv8'] ++ else ++ asm_args += ['-g', 'null'] ++ endif ++elif x86asm_type == 'nasm' ++ if debug_format == 'dwarf' ++ asm_args += ['-g', '-F', 'dwarf'] ++ else ++ asm_args += ['-g'] ++ endif ++endif ++ ++asm_inc = join_paths(meson.current_source_dir(), 'libavutil/x86/') ++ ++if extern_prefix != '' ++ asm_args += ['-DPREFIX'] ++endif ++ ++foreach ext : arch_ext_list_x86_simd ++ if ext == 'mmx' ++ continue ++ endif ++ ++ inline = '@0@_inline'.format(ext) ++ external = '@0@_external'.format(ext) ++ conf.set10(inline, conf.get(ext) == 1 and conf.get('inline_asm') == 1 and conf.get('x86') == 1) ++ conf.set10(external, conf.get(ext) == 1 and conf.get('x86asm') == 1) ++endforeach ++ ++foreach check: x86asm_checks ++ f = configure_file( ++ command: [python3, '-c', 'import sys; print(sys.argv[1])', '@0@'.format(check[0])], ++ input: 'configure', ++ output: '@0@.asm'.format(check[1]), ++ capture: true, ++ ) ++ ++ result = run_command(x86asm, '-f', asm_format, asm_args, '-Werror', f, '-o', meson.current_build_dir() / '@0@.o'.format(check[1]), check: false) ++ ++ if conf.get('asm') == 1 ++ conf.set10(check[1], result.returncode() == 0) ++ ++ if result.returncode() != 0 ++ message('@0@ x86 asm check failed: @1@'.format(check[1], result.stderr().strip())) ++ endif ++ else ++ conf.set10(check[1], false) ++ endif ++endforeach ++ ++foreach check : asm_insn_checks ++ asm_inline_checks += [ ++ ['"@0@"'.format(check[0]), '@0@_inline'.format(check[1])] ++ ] ++ asm_as_checks += [ ++ [check[0], '@0@_external'.format(check[1])] ++ ] ++endforeach ++ ++foreach check: asm_inline_checks ++ if conf.get('inline_asm') == 1 ++ result = cc.compiles( ++ 'void foo(void){ __asm__ volatile(@0@); }'.format(check[0]), ++ name: check[1] ++ ) ++ ++ conf.set10(check[1], result) ++ else ++ conf.set10(check[1], false) ++ endif ++endforeach ++ ++if (conf.get('arm', 0) == 1 or conf.get('aarch64', 0) == 1) and cc.get_id() != 'msvc' ++ asm_as_checks += [ ++ [''' ++ .macro m n, y:vararg=0 ++ .int \y ++ .endm ++ m x ++ ''', 'vararg'], ++ ] ++ ++ if conf.get('arm', 0) == 1 ++ asm_as_checks += [ ++ ['.altmacro', 'gnu_as'] ++ ] ++ endif ++ ++ asm_as_checks += [ ++ ['''.func test ++ .endfunc''', 'as_func'] ++ ] ++endif ++ ++can_run_asm_checks = false ++ ++foreach check : asm_as_checks ++ # It is possible to run compile checks on generated files, however, ++ # Meson versions earlier than 1.2.0 do not set the lookup path ++ # correctly, causing Python to fail opening it. ++ # https://github.com/mesonbuild/meson/issues/11983 ++ if can_run_asm_checks ++ f = configure_file( ++ command: [python3, '-c', 'import sys; print(sys.argv[1])', '@0@'.format(check[0])], ++ input: 'configure', ++ output: '@0@.S'.format(check[1]), ++ capture: true, ++ ) ++ conf.set10(check[1], cc.compiles( ++ f, ++ args: ['-x', 'assembler'], ++ name: check[1] ++ )) ++ else ++ conf.set10(check[1], false) ++ endif ++endforeach ++ ++if conf.get('x86') == 1 ++ conf.set10('ebx_available', conf.get('ebx_available_1') == 1 and conf.get('ebx_available_2') == 1) ++ message('EBX available: @0@'.format(conf.get('ebx_available'))) ++ conf.set10('inline_asm_direct_symbol_refs', conf.get('inline_asm_direct_symbol_refs_1') == 1 or conf.get('inline_asm_direct_symbol_refs_2') == 1) ++ message('Inline assembly direct symbol references available: @0@'.format(conf.get('inline_asm_direct_symbol_refs'))) ++endif ++ ++arm_skip_checks = conf.get('arm', 0) == 1 and (host_machine.system() == 'linux' or host_machine.system() == 'android') ++ ++# If the ASM checks couldn't be run, we need to update the state ++# of ALL Arm instruction sets ++# That's apart from the upstream's linux/android check ++if not arm_skip_checks or not can_run_asm_checks ++ foreach ext : arch_ext_list_arm ++ inline = '@0@_inline'.format(ext) ++ external = '@0@_external'.format(ext) ++ conf.set10(ext, conf.get(inline, 0) == 1 or conf.get(external, 0) == 1) ++ endforeach ++endif ++ ++if get_option('b_lto') ++ conf.set10('inline_asm_direct_symbol_refs', false) ++endif ++ ++extern_things = [ ++ ['FFOutputFormat', 'muxer', 'libavformat/allformats.c', 'muxer_list'], ++ ['AVInputFormat', 'demuxer', 'libavformat/allformats.c', 'demuxer_list'], ++ ['FFCodec', 'encoder', 'libavcodec/allcodecs.c', 'encoder_list'], ++ ['FFCodec', 'decoder', 'libavcodec/allcodecs.c', 'decoder_list'], ++ ['AVCodecParser', 'parser', 'libavcodec/parsers.c', 'parser_list'], ++ ['FFBitStreamFilter', 'bsf', 'libavcodec/bitstream_filters.c', 'bsf_list'], ++ ['AVHWAccel', 'hwaccel', 'libavcodec/hwaccels.h', 'hwaccel_list'], ++ ['URLProtocol', 'protocol', 'libavformat/protocols.c', 'protocol_list'], ++ ['FFOutputFormat', 'muxer', 'libavdevice/alldevices.c', 'outdev_list', 'outdev'], ++ ['AVInputFormat', 'demuxer', 'libavdevice/alldevices.c', 'indev_list', 'indev'], ++] ++ ++find_things_extern = find_program('find_things_extern.py') ++ ++foreach extern_thing : extern_things ++ c_type = extern_thing[0] ++ type = extern_thing[1] ++ filename = extern_thing[2] ++ variable_name = extern_thing[3] ++ ++ if extern_thing.length() > 4 ++ thing_suffix = extern_thing[4] ++ else ++ thing_suffix = type ++ endif ++ ++ result = run_command(find_things_extern, ++ '--type=@0@'.format(c_type), ++ '--suffix=@0@'.format(type), ++ '--thing-suffix=@0@'.format(thing_suffix), ++ files(filename), ++ check: true) ++ list = result.stdout().strip().split('\n') ++ ++ thing_allowed = get_option('@0@s'.format(thing_suffix)).allowed() ++ ++ foreach elem : list ++ opt = get_option(elem) ++ conf.set(elem, (opt.enabled() or (opt.allowed() and thing_allowed)).to_int()) ++ endforeach ++ ++ set_variable(variable_name, list) ++endforeach ++ ++find_things = find_program('find_things.py') ++ ++result = run_command(find_things, files('libavfilter/allfilters.c'), check: true) ++filter_list = result.stdout().strip().split('\n') ++ ++filters_allowed = get_option('filters').allowed() ++ ++foreach filter : filter_list ++ opt = get_option(filter) ++ if conf.get(filter, 1) == 1 ++ conf.set(filter, (opt.enabled() or (opt.allowed() and filters_allowed)).to_int()) ++ else ++ message('Skipping @0@ because of manual disabling'.format(filter)) ++ endif ++endforeach ++ ++old_cli = get_option('cli') ++new_programs = get_option('programs').disable_auto_if(old_cli.disabled()) ++ ++foreach program : program_list ++ conf.set10(program, new_programs.allowed() and get_option(program).allowed()) ++endforeach ++ ++conf.set10('network', get_option('network').allowed()) ++ ++result = run_command(find_things, '--full', files('libavfilter/allfilters.c'), check: true) ++full_filter_list = result.stdout().strip().split('\n') ++ ++avcodec_components_list = bsf_list + decoder_list + encoder_list + hwaccel_list + parser_list ++avdevice_components_list = indev_list + outdev_list ++avfilter_components_list = filter_list ++avformat_components_list = demuxer_list + muxer_list + protocol_list ++ ++if not get_option('devices').allowed() ++ foreach device : indev_list ++ conf.set10(device, false) ++ endforeach ++ foreach device : outdev_list ++ conf.set10(device, false) ++ endforeach ++endif ++ ++all_components = avcodec_components_list + avdevice_components_list + avfilter_components_list + avformat_components_list ++ ++tmpconfig_h = configure_file(configuration: conf, output: 'tmpconfig.h') ++ ++# Working around Windows command line limitation ++components_to_resolve = configuration_data() ++foreach comp : config_list + config_extra + have_list + all_components ++ components_to_resolve.set(comp, true) ++endforeach ++components_h = configure_file(configuration: components_to_resolve, output: 'components.h') ++ ++dep_resolver = find_program('depresolver.py') ++ ++res = run_command(dep_resolver, tmpconfig_h, components_h, check: true) ++ ++conf = configuration_data() ++ ++split = res.stdout().split('//BEGIN_DEPENDS') ++resolved = split[0] ++flattened_deps = split[1] ++ ++foreach kv : resolved.split() ++ split = kv.split('=') ++ k = split[0] ++ v = split[1].to_int() ++ ++ conf.set(k, v) ++endforeach ++ ++foreach kv : flattened_deps.split() ++ split = kv.split('=') ++ k = split[0] ++ v = split[1].split(',') ++ ++ set_variable('@0@_flattened_deps'.format(k), v) ++endforeach ++ ++dshow_indev_extra_deps = [] ++ ++if host_machine.system() == 'windows' ++ foreach libname: ['psapi', 'ole32', 'strmiids', 'uuid', 'oleaut32', 'shlwapi'] ++ dshow_indev_extra_deps += [cc.find_library(libname, required: false)] ++ endforeach ++endif ++ ++foreach comp : avcodec_components_list ++ avcodec_flattened_deps += get_variable('@0@_flattened_deps'.format(comp), []) ++endforeach ++ ++foreach comp : avdevice_components_list ++ avdevice_flattened_deps += get_variable('@0@_flattened_deps'.format(comp), []) ++endforeach ++ ++foreach comp : avfilter_components_list ++ avfilter_flattened_deps += get_variable('@0@_flattened_deps'.format(comp), []) ++endforeach ++ ++foreach comp : avformat_components_list ++ avformat_flattened_deps += get_variable('@0@_flattened_deps'.format(comp), []) ++endforeach ++ ++get_version_define_kwargs = { ++ 'include_directories': ffmpeg_toplevel_inc, ++ 'args': '-I' + ffmpeg_toplevel_builddir, ++} ++ ++subdir('libavutil') ++subdir('libpostproc') ++subdir('libswresample') ++subdir('libswscale') ++subdir('libavcodec') ++subdir('libavformat') ++subdir('libavfilter') ++subdir('libavdevice') ++subdir('fftools') ++ ++util_list = ['cuda', 'd3d11va', 'dxva2', 'libdrm', 'lzo', 'mediacodec', 'opencl', 'qsv', 'vaapi', 'vdpau', 'videotoolbox'] ++ ++ ++things_to_print = [ ++ ['libavcodec/codec_list.c', 'FFCodec', 'codec_list', encoder_list + decoder_list], ++ ['libavcodec/parser_list.c', 'AVCodecParser', 'parser_list', parser_list], ++ ['libavcodec/bsf_list.c', 'FFBitStreamFilter', 'bitstream_filters', bsf_list], ++ ['libavformat/muxer_list.c', 'FFOutputFormat', 'muxer_list', muxer_list], ++ ['libavformat/demuxer_list.c', 'AVInputFormat', 'demuxer_list', demuxer_list], ++ ['libavformat/protocol_list.c', 'URLProtocol', 'url_protocols', protocol_list], ++ ['libavdevice/outdev_list.c', 'FFOutputFormat', 'outdev_list', outdev_list], ++ ['libavdevice/indev_list.c', 'AVInputFormat', 'indev_list', indev_list], ++ ['libavfilter/filter_list.c', 'AVFilter', 'filter_list', filter_list], ++] ++ ++print_things = find_program('print_things.py') ++ ++foreach thing : things_to_print ++ list = [] ++ ctr = 0 ++ foreach comp : thing[3] ++ if conf.get(comp) == 1 ++ if thing[1] == 'AVFilter' ++ comp_name = full_filter_list[ctr] ++ elif thing[2] == 'indev_list' ++ comp_name = '@0@_demuxer'.format(comp.split('_indev')[0]) ++ elif thing[2] == 'outdev_list' ++ comp_name = '@0@_muxer'.format(comp.split('_outdev')[0]) ++ else ++ comp_name = comp ++ endif ++ ++ list += [comp_name] ++ endif ++ ctr += 1 ++ endforeach ++ ++ if thing[1] == 'AVFilter' ++ list += ['asrc_abuffer', 'vsrc_buffer', 'asink_abuffer', 'vsink_buffer'] ++ endif ++ ++ res = run_command(print_things, ++ '--filename=@0@'.format(join_paths(meson.current_build_dir(), thing[0])), ++ '--struct-name=@0@'.format(thing[1]), ++ '--name=@0@'.format(thing[2]), ++ list, check: true) ++endforeach ++ ++if conf.get('stdatomic') == 0 ++ if conf.get('atomics_gcc', 0) == 1 ++ common_incs += [include_directories('compat/atomics/gcc')] ++ elif conf.get('atomics_win32', 0) == 1 ++ common_incs += [include_directories('compat/atomics/win32')] ++ elif conf.get('pthreads', 0) == 1 ++ compat_objs += files('compat/atomics/pthread/stdatomic.c') ++ common_incs += [include_directories('compat/atomics/pthread')] ++ elif conf.get('threads', 0) == 1 ++ error('Threading is enabled, but no atomics are available') ++ else ++ common_incs += [include_directories('compat/atomics/dummy')] ++ endif ++endif ++ ++add_project_arguments(project_c_args, language: 'c') ++ ++libavcodec_optional_deps = [iconv_extra_deps + android_extra_deps] ++libavutil_optional_deps = [vaapi_drm_extra_deps + vaapi_x11_extra_deps + vdpau_x11_extra_deps] ++libswresample_optional_deps = [libsoxr_extra_deps] ++ ++common_deps += libm_extra_deps ++ ++libs_deps = [ ++ ['avutil', []], ++ ['postproc', ['libavutil']], ++ ['swresample', ['libavutil']], ++ ['swscale', ['libavutil']], ++ ['avcodec', ['libavutil']], ++ ['avformat', ['libavutil', 'libavcodec']], ++ ['avfilter', ['libavutil']], ++ ['avdevice', ['libavutil', 'libavformat', 'libavcodec']], ++] ++ ++built_libs = [] ++ ++foreach built_lib : libs_deps ++ if conf.get(built_lib[0]) == 1 ++ built_libs += [built_lib] ++ endif ++endforeach ++ ++makedef = find_program('compat/windows/makedef.py') ++ ++makedef_args = [makedef] ++ ++if not is_msvc ++ nm = find_program('nm', required: true) ++ makedef_args += ['--nm', nm] ++else ++ dumpbin = find_program('dumpbin', required: true) ++ makedef_args += ['--dumpbin', dumpbin] ++endif ++ ++makedef_args += ['--prefix', extern_prefix] ++ ++final_conf = configuration_data() ++ ++if meson.version().version_compare('>=1.1.0') ++ ffmpeg_configuration = meson.build_options().strip() ++else ++ extractor = find_program('capture_build_options.py', required: true) ++ ffmpeg_configuration = run_command(extractor, check: true).stdout().strip() ++endif ++final_conf.set_quoted('FFMPEG_CONFIGURATION', ffmpeg_configuration) ++final_conf.set('CONFIG_THIS_YEAR', 2022) ++final_conf.set_quoted('FFMPEG_DATADIR', join_paths(get_option('prefix'), get_option('datadir'))) ++final_conf.set_quoted('AVCONV_DATADIR', join_paths(get_option('prefix'), get_option('datadir'))) ++final_conf.set_quoted('CC_IDENT', '@0@ @1@'.format(cc.get_id(), cc.version())) ++final_conf.set_quoted('BUILDSUF', '') ++final_conf.set_quoted('SLIBSUF', host_machine.system() == 'windows' ? '.dll' : '.so') ++final_conf.set('SWS_MAX_FILTER_SIZE', 256) ++final_conf.set('EXTERN_ASM', extern_prefix) ++final_conf.set_quoted('EXTERN_PREFIX', extern_prefix) ++ ++if not get_option('nonfree').disabled() ++ license = 'nonfree and unredistributable' ++elif not get_option('gpl').disabled() and not get_option('version3').disabled() ++ license = 'GPL version 3 or later' ++elif not get_option('version3').disabled() ++ license = 'LGPL version 3 or later' ++elif not get_option('gpl').disabled() ++ license = 'GPL version 2 or later' ++else ++ license = 'LGPL version 2.1 or later' ++endif ++final_conf.set_quoted('FFMPEG_LICENSE', license) ++ ++if not get_option('version3').disabled() ++ if not get_option('gpl').disabled() ++ conf.set('gplv3', 1) ++ else ++ conf.set('lgplv3', 1) ++ endif ++endif ++ ++conf.set('mmx2', conf.get('mmxext')) ++ ++foreach restrict_kw : ['restrict', '__restrict__', '__restrict', ''] ++ if not final_conf.has('av_restrict') and cc.compiles('void foo(char * @0@ p);'.format(restrict_kw)) ++ final_conf.set('av_restrict', restrict_kw) ++ endif ++endforeach ++ ++foreach a: arch_list ++ final_conf.set('ARCH_@0@'.format(a.to_upper()), conf.get(a.to_lower())) ++endforeach ++ ++foreach have: have_list ++ final_conf.set('HAVE_@0@'.format(have.to_upper()), conf.get(have.to_lower())) ++endforeach ++ ++foreach config: config_list + config_extra ++ final_conf.set('CONFIG_@0@'.format(config.to_upper()), conf.get(config.to_lower())) ++endforeach ++ ++config_h = configure_file( ++ output: 'config.h', ++ configuration: final_conf, ++) ++ ++components_conf = configuration_data() ++ ++foreach config: all_components ++ components_conf.set('CONFIG_@0@'.format(config.to_upper()), conf.get(config.to_lower())) ++endforeach ++ ++config_asm = configure_file( ++ output: 'config.asm', ++ output_format: 'nasm', ++ configuration: final_conf, ++) ++ ++config_components_h = configure_file( ++ output: 'config_components.h', ++ configuration: components_conf, ++) ++ ++rc = find_program('rc_workaround.py', required: host_machine.system() == 'windows') ++ ++build_tests = get_option('tests').allowed() ++ ++foreach built_lib : built_libs ++ sources = get_variable('lib@0@_sources'.format(built_lib[0])) + [ffversion_h] ++ x86asm_sources = [] ++ tests = get_variable('lib@0@_tests'.format(built_lib[0]), []) ++ gen_objects = [] ++ optional_deps = get_variable('lib@0@_optional_deps'.format(built_lib[0]), []) ++ ++ sources += get_variable('lib@0@_@1@_sources'.format(built_lib[0], arch), []) ++ ++ if conf.get('shared', 0) == 1 ++ sources += get_variable('lib@0@_shlib_sources'.format(built_lib[0]), []) ++ sources += get_variable('lib@0@_@1@_shlib_sources'.format(built_lib[0], arch), []) ++ else ++ sources += get_variable('lib@0@_slib_sources'.format(built_lib[0]), []) ++ sources += get_variable('lib@0@_@1@_slib_sources'.format(built_lib[0], arch), []) ++ endif ++ ++ if host_machine.system() == 'windows' ++ # In subproject mode, the file that will be read (if present) ++ # is the config.h of the *root* project, instead of our config.h. ++ # This is because -I folder take effect *after* the .rc ++ # file's directory, and *after* Ninja's build directory. ++ rc_tgt = custom_target( ++ '@0@res.rc'.format(built_lib[0]), ++ input : ['lib@0@/@0@res.rc'.format(built_lib[0])], ++ output : ['@PLAINNAME@'], ++ command : [rc, '@INPUT@', meson.current_build_dir()], ++ capture: true ++ ) ++ sources += windows.compile_resources( ++ rc_tgt, ++ include_directories: ffmpeg_toplevel_inc, ++ depends: ffversion_h, ++ ) ++ endif ++ ++ foreach arch_ext : arch_list ++ if conf.get(arch_ext, 0) == 1 ++ sources += get_variable('lib@0@_@1@_sources'.format(built_lib[0], arch_ext), []) ++ endif ++ endforeach ++ ++ foreach arch_ext : arch_ext_list ++ if conf.get(arch_ext, 0) == 1 ++ sources += get_variable('lib@0@_@1@_@2@_sources'.format(built_lib[0], arch, arch_ext), []) ++ endif ++ endforeach ++ ++ if conf.get('x86asm') == 1 ++ x86asm_sources += get_variable('lib@0@_x86_x86asm_sources'.format(built_lib[0]), []) ++ endif ++ ++ optional_sources = get_variable('lib@0@_optional_sources'.format(built_lib[0]), {}) ++ optional_tests = get_variable('lib@0@_optional_tests'.format(built_lib[0]), {}) ++ ++ foreach comp_name, comp_sources : optional_sources ++ if conf.get(comp_name, 0) == 1 ++ sources += comp_sources ++ endif ++ ++ if languages_map.has_key(comp_name) ++ foreach lang: languages_map[comp_name] ++ add_languages(languages_map[comp_name], required: get_option(comp_name).enabled(), native: false) ++ endforeach ++ endif ++ endforeach ++ ++ if conf.get('shared', 0) == 1 ++ optional_sources = get_variable('lib@0@_shlib_optional_sources'.format(built_lib[0]), {}) ++ else ++ optional_sources = get_variable('lib@0@_slib_optional_sources'.format(built_lib[0]), {}) ++ endif ++ foreach comp_name, comp_sources : optional_sources ++ if conf.get(comp_name, 0) == 1 ++ sources += comp_sources ++ endif ++ endforeach ++ ++ optional_sources = get_variable('lib@0@_@1@_optional_sources'.format(built_lib[0], arch), {}) ++ foreach comp_name, comp_sources : optional_sources ++ if conf.get(comp_name, 0) == 1 ++ sources += comp_sources ++ endif ++ endforeach ++ ++ if conf.get('x86asm') == 1 ++ optional_sources = get_variable('lib@0@_@1@_x86asm_optional_sources'.format(built_lib[0], arch), {}) ++ foreach comp_name, comp_sources : optional_sources ++ if conf.get(comp_name, 0) == 1 ++ x86asm_sources += comp_sources ++ endif ++ endforeach ++ endif ++ ++ foreach arch_ext : arch_ext_list ++ if conf.get(arch_ext, 0) == 1 ++ optional_sources = get_variable('lib@0@_@1@_@2@_optional_sources'.format(built_lib[0], arch, arch_ext), {}) ++ foreach comp_name, comp_sources : optional_sources ++ if conf.get(comp_name, 0) == 1 ++ sources += comp_sources ++ endif ++ endforeach ++ endif ++ endforeach ++ ++ foreach comp_name, comp_tests : optional_tests ++ if conf.get(comp_name, 0) == 1 ++ tests += comp_tests ++ endif ++ endforeach ++ ++ foreach dep_comp_name: get_variable('@0@_flattened_deps'.format(built_lib[0]), []) ++ if dep_comp_name == built_lib[0] ++ continue ++ endif ++ if library_list.contains(dep_comp_name) ++ optional_deps += [get_variable('lib@0@_dep'.format(dep_comp_name))] ++ endif ++ optional_deps += get_variable('@0@_extra_deps'.format(dep_comp_name), []) ++ endforeach ++ ++ deps = common_deps + optional_deps ++ ++ link_with = [] ++ ++ version = get_variable('lib@0@_majorver'.format(built_lib[0])) ++ ++ if x86asm_sources.length() > 0 ++ # FIXME dedup should happen in meson ++ deduped_sources = [] ++ foreach source : x86asm_sources ++ if not deduped_sources.contains(source) ++ deduped_sources += [source] ++ endif ++ endforeach ++ ++ asm_gen = generator(x86asm, ++ output : '@BASENAME@.asm.o', ++ arguments : asm_args + [ ++ '-f', asm_format, ++ '-i', meson.current_source_dir() + '/', ++ '-i', meson.current_build_dir() + '/', ++ '-i', join_paths(meson.current_source_dir(), 'lib@0@'.format(built_lib[0]), 'x86', ''), ++ '-P', join_paths(meson.current_build_dir(), 'config.asm'), ++ '@INPUT@', ++ '-o', '@OUTPUT@']) ++ ++ gen_objects += asm_gen.process(deduped_sources) ++ endif ++ ++ vflag = '-Wl,--version-script,@0@/lib@1@/lib@1@.ver'.format(meson.current_build_dir(), built_lib[0]) ++ c_args = ['-DHAVE_AV_CONFIG_H', '-DBUILDING_@0@'.format(built_lib[0])] ++ ++ link_args = cc.get_supported_link_arguments([vflag]) ++ ++ static_link_args = [] ++ ++ if is_msvc and (get_option('buildtype') == 'debug' or get_option('optimization') == '0') ++ message('Applying MSVC link workaround for Debug mode and static libraries.') ++ static_link_args += cc.get_supported_link_arguments('/FORCE:UNRESOLVED') ++ link_args += cc.get_supported_link_arguments('/FORCE:UNRESOLVED') ++ endif ++ ++ static_lib = static_library('@0@-static'.format(built_lib[0]), sources + gen_objects + [config_h, config_components_h], ++ dependencies: deps, ++ include_directories: common_incs, ++ link_with: link_with, ++ link_args: static_link_args, ++ c_args: c_args, ++ pic: conf.get('pic') == 1, ++ implicit_include_directories : false, ++ ) ++ ++ vs_module_def = custom_target('@0@-def'.format(built_lib[0]), ++ output: '@0@.def'.format(built_lib[0]), ++ command: [makedef_args, '@0@/lib@1@/lib@1@.ver'.format(meson.current_build_dir(), built_lib[0]), static_lib], ++ capture: true ++ ) ++ ++ lib = library(built_lib[0], ++ objects: static_lib.extract_all_objects(recursive: true), ++ dependencies: deps, ++ soversion: version, ++ include_directories: common_incs, ++ link_with: link_with, ++ link_args: link_args, ++ c_args: c_args, ++ pic: conf.get('pic') == 1, ++ vs_module_defs: vs_module_def, ++ implicit_include_directories : false, ++ install: true, ++ ) ++ ++ set_variable('lib@0@'.format(built_lib[0]), lib) ++ ++ declared_dep = declare_dependency(link_with: lib, ++ include_directories: include_directories('.'), ++ dependencies: deps, ++ version: get_variable('lib@0@_version'.format(built_lib[0])) ++ ) ++ ++ set_variable('lib@0@_dep'.format(built_lib[0]), declared_dep) ++ ++ if build_tests ++ foreach test_ : tests ++ test_name = test_[0] ++ test_sources = test_[1] ++ opts = test_.get(2, {}) ++ test_deps = deps ++ ++ extra_libs = opts.get('extra_libs', []) ++ foreach libname: extra_libs ++ if libname == 'threads' and thread_dep.found() ++ test_deps += [thread_dep] ++ else ++ test_deps += [cc.find_library(libname)] ++ endif ++ endforeach ++ ++ exe = executable('test_@0@_@1@'.format(built_lib[0], test_name), test_sources, ++ c_args: c_args, ++ dependencies: test_deps, ++ include_directories: common_incs, ++ link_args: static_link_args, ++ link_with: [static_lib] + link_with, ++ implicit_include_directories : false, ++ pie: get_option('b_pie') and (conf.get('pic') == 1) ++ ) ++ ++ test('@0@_@1@'.format(built_lib[0], test_name), exe, ++ timeout: 180, ++ workdir: join_paths(meson.current_source_dir(), 'lib@0@'.format(built_lib[0]), 'tests')) ++ endforeach ++ endif ++endforeach ++ ++built_exe_list = [] ++ ++foreach program : program_list ++ if conf.get(program) == 1 ++ built_exe_list += program ++ endif ++endforeach ++ ++foreach built_exe : built_exe_list ++ sources = get_variable('fftools_sources', []) + [ffversion_h] ++ sources += get_variable('fftools_optional_sources', {}).get(built_exe, []) ++ sources += get_variable('@0@_sources'.format(built_exe), []) ++ optional_deps = [] ++ ++ message('Checking @0@ dependencies'.format(built_exe)) ++ ++ optional_sources = get_variable('@0@_optional_sources'.format(built_exe), {}) ++ ++ foreach comp_name, comp_sources : optional_sources ++ if conf.get(comp_name, 0) == 1 ++ sources += comp_sources ++ endif ++ endforeach ++ ++ foreach dep_comp_name: get_variable('@0@_flattened_deps'.format(built_exe), []) ++ optional_deps += get_variable('@0@_extra_deps'.format(dep_comp_name), []) ++ endforeach ++ ++ message('Gathered @0@ optional deps'.format(optional_deps.length())) ++ ++ deps = common_deps + optional_deps ++ ++ foreach built_lib: built_libs ++ deps += [get_variable('lib@0@_dep'.format(built_lib[0]))] ++ endforeach ++ ++ exe = executable(built_exe, sources + [config_h, config_components_h], ++ install: true, ++ dependencies: deps, ++ include_directories: common_incs, ++ implicit_include_directories : false, ++ pie: get_option('b_pie') and (conf.get('pic') == 1) ++ ) ++ ++ set_variable('@0@_exe'.format(built_exe[0]), exe) ++endforeach ++ ++pkg = import('pkgconfig') ++ ++pkg_infos = [ ++ ['Multimedia utilities', 'avutil'], ++ ['FFmpeg postprocessing library', 'postproc'], ++ ['FFmpeg audio resampling library', 'swresample'], ++ ['FFmpeg image rescaling library', 'swscale'], ++ ['Multimedia codecs', 'avcodec'], ++ ['Multimedia formats', 'avformat'], ++ ['Media device handling', 'avdevice'], ++ ['Audio/video filtering library', 'avfilter'], ++] ++ ++foreach pkg_info : pkg_infos ++ if conf.get(pkg_info[1]) == 0 ++ continue ++ endif ++ libname = 'lib@0@'.format(pkg_info[1]) ++ pkg.generate(get_variable(libname), ++ filebase: libname, ++ description: pkg_info[0], ++ version: get_variable(libname + '_version') ++ ) ++endforeach ++ ++### Summary ++ ++# Put this at the end so people see it ++if conf.get('x86_32') == 1 and is_msvc ++ # -Dasm=enabled seems to hang reliably on some Visual Studio 2019 installations, ask users to report back to us ++ if conf.get('asm') == 1 and cc.version().version_compare('<19.30') ++ warning('Using VS 2019 x86 with `asm` enabled: if you see a hang while linking, please report an issue at https://gitlab.freedesktop.org/gstreamer/meson-ports/ffmpeg/-/issues') ++ endif ++ # MSVC x86 -> x86 cannot cope with the amount of PDB information ++ if (new_programs.allowed() or build_tests) and conf.get('shared') == 0 ++ warning('Using VS x86 with static libraries: if you see a hang while linking, please disable programs and tests, or report an issue at https://gitlab.freedesktop.org/gstreamer/meson-ports/ffmpeg/-/issues') ++ endif ++endif ++ ++thread_type = '' ++foreach t : threads_list ++ if conf.get(t) == 1 ++ thread_type = t ++ break ++ endif ++endforeach ++ ++summary({ ++ 'License': license, ++ 'static': conf.get('static').is_odd(), ++ 'shared': conf.get('shared').is_odd(), ++ 'postprocessing support': conf.get('postproc').is_odd(), ++ 'network support': conf.get('network').is_odd(), ++ 'threading support': thread_type, ++ 'safe bitstream reader': conf.get('safe_bitstream_reader').is_odd(), ++}, section: 'Basics', bool_yn: true) ++ ++if conf.get('x86') == 1 ++ summary({ ++ 'standalone assembly': conf.get('x86asm').is_odd(), ++ 'x86 assembler': get_variable('x86asm_type', 'none'), ++ 'MMX': conf.get('mmx').is_odd(), ++ 'MMXEXT': conf.get('mmxext').is_odd(), ++ '3DNow!': conf.get('amd3dnow').is_odd(), ++ '3DNow! extended': conf.get('amd3dnowext').is_odd(), ++ 'SSE': conf.get('sse').is_odd(), ++ 'SSSE3': conf.get('ssse3').is_odd(), ++ 'AESNI': conf.get('aesni').is_odd(), ++ 'AVX': conf.get('avx').is_odd(), ++ 'AVX2': conf.get('avx2').is_odd(), ++ 'AVX-512': conf.get('avx512').is_odd(), ++ 'AVX-512ICL': conf.get('avx512icl').is_odd(), ++ 'XOP': conf.get('xop').is_odd(), ++ 'FMA3': conf.get('fma3').is_odd(), ++ 'FMA4': conf.get('fma4').is_odd(), ++ 'i686 features': conf.get('i686').is_odd(), ++ 'CMOV is fast': conf.get('fast_cmov').is_odd(), ++ 'EBX available': conf.get('ebx_available').is_odd(), ++ 'EBP available': conf.get('ebp_available').is_odd(), ++ }, section: 'x86', bool_yn: true) ++endif ++if conf.get('aarch64') == 1 ++ summary({ ++ 'NEON': conf.get('neon').is_odd(), ++ 'VFP': conf.get('vfp').is_odd(), ++ }, section: 'Arm64', bool_yn: true) ++endif ++if conf.get('arm') == 1 ++ summary({ ++ 'ARMv5TE': conf.get('armv5te').is_odd(), ++ 'ARMv6': conf.get('armv6').is_odd(), ++ 'ARMv6T2': conf.get('armv6t2').is_odd(), ++ 'VFP': conf.get('vfp').is_odd(), ++ 'NEON': conf.get('neon').is_odd(), ++ 'THUMB': conf.get('thumb').is_odd(), ++ }, section: 'Arm', bool_yn: true) ++endif ++if conf.get('mips') == 1 ++ summary({ ++ 'MIPS FPU': conf.get('mipsfpu').is_odd(), ++ 'MIPS DSP R1': conf.get('mipsdsp').is_odd(), ++ 'MIPS DSP R2': conf.get('mipsdspr2').is_odd(), ++ 'MIPS MSA': conf.get('msa').is_odd(), ++ 'LOONGSON MMI': conf.get('mmi').is_odd(), ++ }, section: 'MIPS', bool_yn: true) ++endif ++if conf.get('ppc') == 1 ++ summary({ ++ 'AltiVec': conf.get('altivec').is_odd(), ++ 'VSX': conf.get('vsx').is_odd(), ++ 'POWER8': conf.get('power8').is_odd(), ++ 'PPC 4xx optimizations': conf.get('ppc4xx').is_odd(), ++ 'dcbzl available': conf.get('dcbzl').is_odd(), ++ }, section: 'PowerPC', bool_yn: true) ++endif ++if conf.get('loongarch') == 1 ++ summary({ ++ 'LSX': conf.get('lsx').is_odd(), ++ 'LASX': conf.get('lasx').is_odd(), ++ }, section: 'Loongson', bool_yn: true) ++endif ++if conf.get('riscv') == 1 ++ summary({ ++ 'RISC-V Vector': conf.get('rvv').is_odd(), ++ }, section: 'RISC-V', bool_yn: true) ++endif ++ ++d = {} ++v = [] ++foreach lib : external_library_list + external_autodetect_library_list ++ if conf.get(lib) == 1 ++ v += [lib] ++ endif ++endforeach ++d += {'External libraries': v} ++ ++v = [] ++foreach lib : hwaccel_library_list + hwaccel_autodetect_library_list ++ if conf.get(lib) == 1 ++ v += [lib] ++ endif ++endforeach ++d += {'External libraries providing hardware acceleration': v} ++ ++v = [] ++foreach lib : library_list ++ if conf.get(lib) == 1 ++ v += [lib] ++ endif ++endforeach ++d += {'Libraries': v} ++ ++v = [] ++foreach lib : program_list ++ if conf.get(lib) == 1 ++ v += [lib] ++ endif ++endforeach ++d += {'Programs': v} ++ ++# uncomment if needed ++# foreach type : ['decoder', 'encoder', 'hwaccel', 'parser', 'demuxer', 'muxer', 'protocol', 'filter', 'bsf', 'indev', 'outdev'] ++# k = 'Enabled @0@s'.format(type) ++# v = [] ++# if type == 'indev' ++# suffix = '_@0@'.format('demuxer') ++# elif type == 'outdev' ++# suffix = '_@0@'.format('muxer') ++# else ++# suffix = '_@0@'.format(type) ++# endif ++# foreach component : get_variable('@0@_list'.format(type)) ++# if conf.get(component) == 1 ++# v += [component.replace(suffix, '')] ++# endif ++# endforeach ++# d += {k: v} ++# endforeach ++summary(d, section: 'Components', list_sep: ' ') +diff --git a/meson_options.txt b/meson_options.txt +new file mode 100644 +index 0000000000..682c774c46 +--- /dev/null ++++ b/meson_options.txt +@@ -0,0 +1,2397 @@ ++# pkg-config options ++option('alsa', type: 'feature', value: 'auto') ++option('avisynth', type: 'feature', value: 'disabled') ++option('decklink', type: 'feature', value: 'disabled') ++option('ffnvcodec', type: 'feature', value: 'auto') ++option('frei0r', type: 'feature', value: 'disabled') ++option('iconv', type: 'feature', value: 'disabled') ++option('libgme', type: 'feature', value: 'disabled') ++option('gnutls', type: 'feature', value: 'disabled') ++option('libaom', type: 'feature', value: 'disabled') ++option('ladspa', type: 'feature', value: 'disabled') ++option('lcms2', type: 'feature', value: 'disabled') ++option('lv2', type: 'feature', value: 'disabled') ++option('libass', type: 'feature', value: 'disabled') ++option('libbluray', type: 'feature', value: 'disabled') ++option('libbs2b', type: 'feature', value: 'disabled') ++option('libcaca', type: 'feature', value: 'disabled') ++option('libcdio', type: 'feature', value: 'disabled') ++option('libdavs2', type: 'feature', value: 'disabled') ++option('libdc1394', type: 'feature', value: 'disabled') ++option('libdrm', type: 'feature', value: 'disabled') ++option('libfdk_aac', type: 'feature', value: 'disabled') ++option('libfontconfig', type: 'feature', value: 'disabled') ++option('libfreetype', type: 'feature', value: 'disabled') ++option('libfribidi', type: 'feature', value: 'disabled') ++option('libjack', type: 'feature', value: 'disabled') ++option('libjxl', type: 'feature', value: 'disabled') ++option('libklvanc', type: 'feature', value: 'disabled') ++option('libkvazaar', type: 'feature', value: 'disabled') ++option('liblensfun', type: 'feature', value: 'disabled') ++option('libglslang', type: 'feature', value: 'disabled') ++option('libmfx', type: 'feature', value: 'disabled') ++option('libmodplug', type: 'feature', value: 'disabled') ++option('libopencv', type: 'feature', value: 'disabled') ++option('libopenh264', type: 'feature', value: 'disabled') ++option('libopenjpeg', type: 'feature', value: 'disabled') ++option('libopenmpt', type: 'feature', value: 'disabled') ++option('libopenvino', type: 'feature', value: 'disabled') ++option('libopus', type: 'feature', value: 'disabled') ++option('libplacebo', type: 'feature', value: 'disabled') ++option('libpulse', type: 'feature', value: 'disabled') ++option('librabbitmq', type: 'feature', value: 'disabled') ++option('librav1e', type: 'feature', value: 'disabled') ++option('librist', type: 'feature', value: 'disabled') ++option('librsvg', type: 'feature', value: 'disabled') ++option('librtmp', type: 'feature', value: 'disabled') ++option('librubberband', type: 'feature', value: 'disabled') ++option('libshine', type: 'feature', value: 'disabled') ++option('libsmbclient', type: 'feature', value: 'disabled') ++option('libssh', type: 'feature', value: 'disabled') ++option('libspeex', type: 'feature', value: 'disabled') ++option('libsrt', type: 'feature', value: 'disabled') ++option('libsvtav1', type: 'feature', value: 'disabled') ++option('libtensorflow', type: 'feature', value: 'disabled') ++option('libtesseract', type: 'feature', value: 'disabled') ++option('libtls', type: 'feature', value: 'disabled') ++option('libv4l2', type: 'feature', value: 'disabled') ++option('libvidstab', type: 'feature', value: 'disabled') ++option('libvmaf', type: 'feature', value: 'disabled') ++option('libvorbis', type: 'feature', value: 'disabled') ++option('libvorbisenc', type: 'feature', value: 'disabled') ++option('libvpl', type: 'feature', value: 'disabled') ++option('libvpx', type: 'feature', value: 'disabled') ++option('libwebp', type: 'feature', value: 'disabled') ++option('libx264', type: 'feature', value: 'disabled') ++option('libx265', type: 'feature', value: 'disabled') ++option('libxcb', type: 'feature', value: 'auto') ++option('libxcb_shm', type: 'feature', value: 'auto') ++option('libxcb_shape', type: 'feature', value: 'auto') ++option('libxcb_xfixes', type: 'feature', value: 'auto') ++option('libxml2', type: 'feature', value: 'disabled') ++option('libzimg', type: 'feature', value: 'disabled') ++option('libzmq', type: 'feature', value: 'disabled') ++option('libzvbi', type: 'feature', value: 'disabled') ++option('mbedtls', type: 'feature', value: 'disabled') ++option('openssl', type: 'feature', value: 'disabled') ++option('rkmpp', type: 'feature', value: 'disabled') ++option('rockchip_mpp', type: 'feature', value: 'disabled') ++option('sdl2', type: 'feature', value: 'auto') ++option('vapoursynth', type: 'feature', value: 'disabled') ++ ++# library options ++option('advapi32', type: 'feature', value: 'auto') ++option('amf', type: 'feature', value: 'disabled') ++option('android', type: 'feature', value: 'auto') ++option('appkit', type: 'feature', value: 'auto') ++option('applicationservices', type: 'feature', value: 'auto') ++option('audiotoolbox', type: 'feature', value: 'auto') ++option('avfoundation', type: 'feature', value: 'auto') ++option('bcrypt', type: 'feature', value: 'auto') ++option('bzlib', type: 'feature', value: 'auto') ++option('camera2ndk', type: 'feature', value: 'auto') ++option('chromaprint', type: 'feature', value: 'disabled') ++option('clock_gettime', type: 'feature', value: 'auto') ++option('coreimage', type: 'feature', value: 'auto') ++option('coregraphics', type: 'feature', value: 'auto') ++option('coreservices', type: 'feature', value: 'auto') ++option('crystalhd', type: 'feature', value: 'auto') ++option('cuda', type: 'feature', value: 'disabled') ++option('cuvid', type: 'feature', value: 'disabled') ++option('ff_cuda_llvm', type: 'feature', value: 'disabled') # ff_cuda_llvm in ffmpeg ++option('ff_cuda_sdk', type: 'feature', value: 'auto') # cuda_sdk in ffmpeg ++option('d3d11va', type: 'feature', value: 'auto') ++option('dxva2', type: 'feature', value: 'auto') ++option('gcrypt', type: 'feature', value: 'disabled') ++option('gmp', type: 'feature', value: 'disabled') ++option('jni', type : 'feature', value : 'auto') ++option('libaribb24', type: 'feature', value: 'disabled') ++option('libcelt', type: 'feature', value: 'disabled') ++option('libcodec2', type: 'feature', value: 'disabled') ++option('libdav1d', type: 'feature', value: 'disabled') ++option('libdl', type: 'feature', value: 'auto') ++option('libflite', type: 'feature', value: 'disabled') ++option('libgsm', type: 'feature', value: 'disabled') ++option('libiec61883', type: 'feature', value: 'disabled') ++option('libilbc', type: 'feature', value: 'disabled') ++option('libmp3lame', type: 'feature', value: 'disabled') ++option('libmysofa', type: 'feature', value: 'disabled') ++option('libnpp', type: 'feature', value: 'disabled') ++option('libopencore_amrnb', type: 'feature', value: 'disabled') ++option('libopencore_amrwb', type: 'feature', value: 'disabled') ++option('libsnappy', type: 'feature', value: 'disabled') ++option('libsoxr', type: 'feature', value: 'disabled') ++option('libtheora', type: 'feature', value: 'disabled') ++option('libtwolame', type: 'feature', value: 'disabled') ++option('libuavs3d', type: 'feature', value: 'disabled') ++option('libvo_amrwbenc', type: 'feature', value: 'disabled') ++option('libxavs', type: 'feature', value: 'disabled') ++option('libxavs2', type: 'feature', value: 'disabled') ++option('libxvid', type: 'feature', value: 'disabled') ++option('linux_fbdev', type: 'feature', value: 'disabled') ++option('lzma', type: 'feature', value: 'auto') ++option('mediacodec', type : 'feature', value : 'auto') ++option('mediafoundation', type: 'feature', value: 'auto') ++option('mediandk', type: 'feature', value: 'disabled') ++option('metal', type: 'feature', value: 'disabled') ++option('mmal', type: 'feature', value: 'disabled') ++option('nvdec', type: 'feature', value: 'disabled') ++option('nvenc', type: 'feature', value: 'disabled') ++option('nanosleep', type: 'feature', value: 'auto') ++option('ole32', type: 'feature', value: 'auto') ++option('omx', type: 'feature', value: 'disabled') ++option('omx_rpi', type: 'feature', value: 'disabled') ++option('openal', type: 'feature', value: 'disabled') ++option('opencl', type: 'feature', value: 'disabled') ++option('opengl', type: 'feature', value: 'disabled') ++option('pocketsphinx', type: 'feature', value: 'disabled') ++option('psapi', type: 'feature', value: 'disabled') ++option('securetransport', type: 'feature', value: 'auto') ++option('schannel', type: 'feature', value: 'auto') ++option('shell32', type: 'feature', value: 'disabled') ++option('spirv_compiler', type: 'feature', value: 'disabled') ++option('sndio', type: 'feature', value: 'disabled') ++option('user32', type: 'feature', value: 'auto') ++option('vfw32', type: 'feature', value: 'disabled') ++option('v4l2_m2m', type: 'feature', value: 'disabled') ++option('vaapi', type: 'feature', value: 'disabled') ++option('vaapi_drm', type: 'feature', value: 'disabled') ++option('vaapi_x11', type: 'feature', value: 'disabled') ++option('vdpau', type: 'feature', value: 'disabled') ++option('vdpau_x11', type: 'feature', value: 'disabled') ++option('videotoolbox', type: 'feature', value: 'auto') ++option('vulkan', type: 'feature', value: 'disabled') ++option('xlib', type: 'feature', value: 'disabled') ++option('xlib_x11', type: 'feature', value: 'disabled') ++option('xlib_xext', type: 'feature', value: 'disabled') ++option('xlib_xv', type: 'feature', value: 'disabled') ++option('zlib', type: 'feature', value: 'auto') ++ ++#### --- GENERATED EXTERN OPTIONS --- #### ++# Generated muxer options ++option('a64_muxer', type: 'feature', value: 'auto') ++option('ac3_muxer', type: 'feature', value: 'auto') ++option('adts_muxer', type: 'feature', value: 'auto') ++option('adx_muxer', type: 'feature', value: 'auto') ++option('aiff_muxer', type: 'feature', value: 'auto') ++option('alp_muxer', type: 'feature', value: 'auto') ++option('amr_muxer', type: 'feature', value: 'auto') ++option('amv_muxer', type: 'feature', value: 'auto') ++option('apm_muxer', type: 'feature', value: 'auto') ++option('apng_muxer', type: 'feature', value: 'auto') ++option('aptx_muxer', type: 'feature', value: 'auto') ++option('aptx_hd_muxer', type: 'feature', value: 'auto') ++option('argo_asf_muxer', type: 'feature', value: 'auto') ++option('argo_cvg_muxer', type: 'feature', value: 'auto') ++option('asf_muxer', type: 'feature', value: 'auto') ++option('ass_muxer', type: 'feature', value: 'auto') ++option('ast_muxer', type: 'feature', value: 'auto') ++option('asf_stream_muxer', type: 'feature', value: 'auto') ++option('au_muxer', type: 'feature', value: 'auto') ++option('avi_muxer', type: 'feature', value: 'auto') ++option('avif_muxer', type: 'feature', value: 'auto') ++option('avm2_muxer', type: 'feature', value: 'auto') ++option('avs2_muxer', type: 'feature', value: 'auto') ++option('avs3_muxer', type: 'feature', value: 'auto') ++option('bit_muxer', type: 'feature', value: 'auto') ++option('caf_muxer', type: 'feature', value: 'auto') ++option('cavsvideo_muxer', type: 'feature', value: 'auto') ++option('codec2_muxer', type: 'feature', value: 'auto') ++option('codec2raw_muxer', type: 'feature', value: 'auto') ++option('crc_muxer', type: 'feature', value: 'auto') ++option('dash_muxer', type: 'feature', value: 'auto') ++option('data_muxer', type: 'feature', value: 'auto') ++option('daud_muxer', type: 'feature', value: 'auto') ++option('dfpwm_muxer', type: 'feature', value: 'auto') ++option('dirac_muxer', type: 'feature', value: 'auto') ++option('dnxhd_muxer', type: 'feature', value: 'auto') ++option('dts_muxer', type: 'feature', value: 'auto') ++option('dv_muxer', type: 'feature', value: 'auto') ++option('eac3_muxer', type: 'feature', value: 'auto') ++option('f4v_muxer', type: 'feature', value: 'auto') ++option('ffmetadata_muxer', type: 'feature', value: 'auto') ++option('fifo_muxer', type: 'feature', value: 'auto') ++option('fifo_test_muxer', type: 'feature', value: 'auto') ++option('filmstrip_muxer', type: 'feature', value: 'auto') ++option('fits_muxer', type: 'feature', value: 'auto') ++option('flac_muxer', type: 'feature', value: 'auto') ++option('flv_muxer', type: 'feature', value: 'auto') ++option('framecrc_muxer', type: 'feature', value: 'auto') ++option('framehash_muxer', type: 'feature', value: 'auto') ++option('framemd5_muxer', type: 'feature', value: 'auto') ++option('g722_muxer', type: 'feature', value: 'auto') ++option('g723_1_muxer', type: 'feature', value: 'auto') ++option('g726_muxer', type: 'feature', value: 'auto') ++option('g726le_muxer', type: 'feature', value: 'auto') ++option('gif_muxer', type: 'feature', value: 'auto') ++option('gsm_muxer', type: 'feature', value: 'auto') ++option('gxf_muxer', type: 'feature', value: 'auto') ++option('h261_muxer', type: 'feature', value: 'auto') ++option('h263_muxer', type: 'feature', value: 'auto') ++option('h264_muxer', type: 'feature', value: 'auto') ++option('hash_muxer', type: 'feature', value: 'auto') ++option('hds_muxer', type: 'feature', value: 'auto') ++option('hevc_muxer', type: 'feature', value: 'auto') ++option('hls_muxer', type: 'feature', value: 'auto') ++option('ico_muxer', type: 'feature', value: 'auto') ++option('ilbc_muxer', type: 'feature', value: 'auto') ++option('image2_muxer', type: 'feature', value: 'auto') ++option('image2pipe_muxer', type: 'feature', value: 'auto') ++option('ipod_muxer', type: 'feature', value: 'auto') ++option('ircam_muxer', type: 'feature', value: 'auto') ++option('ismv_muxer', type: 'feature', value: 'auto') ++option('ivf_muxer', type: 'feature', value: 'auto') ++option('jacosub_muxer', type: 'feature', value: 'auto') ++option('kvag_muxer', type: 'feature', value: 'auto') ++option('latm_muxer', type: 'feature', value: 'auto') ++option('lrc_muxer', type: 'feature', value: 'auto') ++option('m4v_muxer', type: 'feature', value: 'auto') ++option('md5_muxer', type: 'feature', value: 'auto') ++option('matroska_muxer', type: 'feature', value: 'auto') ++option('matroska_audio_muxer', type: 'feature', value: 'auto') ++option('microdvd_muxer', type: 'feature', value: 'auto') ++option('mjpeg_muxer', type: 'feature', value: 'auto') ++option('mlp_muxer', type: 'feature', value: 'auto') ++option('mmf_muxer', type: 'feature', value: 'auto') ++option('mov_muxer', type: 'feature', value: 'auto') ++option('mp2_muxer', type: 'feature', value: 'auto') ++option('mp3_muxer', type: 'feature', value: 'auto') ++option('mp4_muxer', type: 'feature', value: 'auto') ++option('mpeg1system_muxer', type: 'feature', value: 'auto') ++option('mpeg1vcd_muxer', type: 'feature', value: 'auto') ++option('mpeg1video_muxer', type: 'feature', value: 'auto') ++option('mpeg2dvd_muxer', type: 'feature', value: 'auto') ++option('mpeg2svcd_muxer', type: 'feature', value: 'auto') ++option('mpeg2video_muxer', type: 'feature', value: 'auto') ++option('mpeg2vob_muxer', type: 'feature', value: 'auto') ++option('mpegts_muxer', type: 'feature', value: 'auto') ++option('mpjpeg_muxer', type: 'feature', value: 'auto') ++option('mxf_muxer', type: 'feature', value: 'auto') ++option('mxf_d10_muxer', type: 'feature', value: 'auto') ++option('mxf_opatom_muxer', type: 'feature', value: 'auto') ++option('null_muxer', type: 'feature', value: 'enabled') ++option('nut_muxer', type: 'feature', value: 'auto') ++option('obu_muxer', type: 'feature', value: 'auto') ++option('oga_muxer', type: 'feature', value: 'auto') ++option('ogg_muxer', type: 'feature', value: 'auto') ++option('ogv_muxer', type: 'feature', value: 'auto') ++option('oma_muxer', type: 'feature', value: 'auto') ++option('opus_muxer', type: 'feature', value: 'auto') ++option('pcm_alaw_muxer', type: 'feature', value: 'auto') ++option('pcm_mulaw_muxer', type: 'feature', value: 'auto') ++option('pcm_vidc_muxer', type: 'feature', value: 'auto') ++option('pcm_f64be_muxer', type: 'feature', value: 'auto') ++option('pcm_f64le_muxer', type: 'feature', value: 'auto') ++option('pcm_f32be_muxer', type: 'feature', value: 'auto') ++option('pcm_f32le_muxer', type: 'feature', value: 'auto') ++option('pcm_s32be_muxer', type: 'feature', value: 'auto') ++option('pcm_s32le_muxer', type: 'feature', value: 'auto') ++option('pcm_s24be_muxer', type: 'feature', value: 'auto') ++option('pcm_s24le_muxer', type: 'feature', value: 'auto') ++option('pcm_s16be_muxer', type: 'feature', value: 'auto') ++option('pcm_s16le_muxer', type: 'feature', value: 'auto') ++option('pcm_s8_muxer', type: 'feature', value: 'auto') ++option('pcm_u32be_muxer', type: 'feature', value: 'auto') ++option('pcm_u32le_muxer', type: 'feature', value: 'auto') ++option('pcm_u24be_muxer', type: 'feature', value: 'auto') ++option('pcm_u24le_muxer', type: 'feature', value: 'auto') ++option('pcm_u16be_muxer', type: 'feature', value: 'auto') ++option('pcm_u16le_muxer', type: 'feature', value: 'auto') ++option('pcm_u8_muxer', type: 'feature', value: 'auto') ++option('psp_muxer', type: 'feature', value: 'auto') ++option('rawvideo_muxer', type: 'feature', value: 'auto') ++option('rm_muxer', type: 'feature', value: 'auto') ++option('roq_muxer', type: 'feature', value: 'auto') ++option('rso_muxer', type: 'feature', value: 'auto') ++option('rtp_muxer', type: 'feature', value: 'auto') ++option('rtp_mpegts_muxer', type: 'feature', value: 'auto') ++option('rtsp_muxer', type: 'feature', value: 'auto') ++option('sap_muxer', type: 'feature', value: 'auto') ++option('sbc_muxer', type: 'feature', value: 'auto') ++option('scc_muxer', type: 'feature', value: 'auto') ++option('segafilm_muxer', type: 'feature', value: 'auto') ++option('segment_muxer', type: 'feature', value: 'auto') ++option('stream_segment_muxer', type: 'feature', value: 'auto') ++option('smjpeg_muxer', type: 'feature', value: 'auto') ++option('smoothstreaming_muxer', type: 'feature', value: 'auto') ++option('sox_muxer', type: 'feature', value: 'auto') ++option('spx_muxer', type: 'feature', value: 'auto') ++option('spdif_muxer', type: 'feature', value: 'auto') ++option('srt_muxer', type: 'feature', value: 'auto') ++option('streamhash_muxer', type: 'feature', value: 'auto') ++option('sup_muxer', type: 'feature', value: 'auto') ++option('swf_muxer', type: 'feature', value: 'auto') ++option('tee_muxer', type: 'feature', value: 'auto') ++option('tg2_muxer', type: 'feature', value: 'auto') ++option('tgp_muxer', type: 'feature', value: 'auto') ++option('mkvtimestamp_v2_muxer', type: 'feature', value: 'auto') ++option('truehd_muxer', type: 'feature', value: 'auto') ++option('tta_muxer', type: 'feature', value: 'auto') ++option('ttml_muxer', type: 'feature', value: 'auto') ++option('uncodedframecrc_muxer', type: 'feature', value: 'auto') ++option('vc1_muxer', type: 'feature', value: 'auto') ++option('vc1t_muxer', type: 'feature', value: 'auto') ++option('voc_muxer', type: 'feature', value: 'auto') ++option('w64_muxer', type: 'feature', value: 'auto') ++option('wav_muxer', type: 'feature', value: 'auto') ++option('webm_muxer', type: 'feature', value: 'auto') ++option('webm_dash_manifest_muxer', type: 'feature', value: 'auto') ++option('webm_chunk_muxer', type: 'feature', value: 'auto') ++option('webp_muxer', type: 'feature', value: 'auto') ++option('webvtt_muxer', type: 'feature', value: 'auto') ++option('wsaud_muxer', type: 'feature', value: 'auto') ++option('wtv_muxer', type: 'feature', value: 'auto') ++option('wv_muxer', type: 'feature', value: 'auto') ++option('yuv4mpegpipe_muxer', type: 'feature', value: 'auto') ++option('chromaprint_muxer', type: 'feature', value: 'auto') ++option('muxers', type: 'feature', value: 'auto', description: 'Enable or disable all muxers') ++ ++# Generated demuxer options ++option('aa_demuxer', type: 'feature', value: 'auto') ++option('aac_demuxer', type: 'feature', value: 'auto') ++option('aax_demuxer', type: 'feature', value: 'auto') ++option('ac3_demuxer', type: 'feature', value: 'auto') ++option('ace_demuxer', type: 'feature', value: 'auto') ++option('acm_demuxer', type: 'feature', value: 'auto') ++option('act_demuxer', type: 'feature', value: 'auto') ++option('adf_demuxer', type: 'feature', value: 'auto') ++option('adp_demuxer', type: 'feature', value: 'auto') ++option('ads_demuxer', type: 'feature', value: 'auto') ++option('adx_demuxer', type: 'feature', value: 'auto') ++option('aea_demuxer', type: 'feature', value: 'auto') ++option('afc_demuxer', type: 'feature', value: 'auto') ++option('aiff_demuxer', type: 'feature', value: 'auto') ++option('aix_demuxer', type: 'feature', value: 'auto') ++option('alp_demuxer', type: 'feature', value: 'auto') ++option('amr_demuxer', type: 'feature', value: 'auto') ++option('amrnb_demuxer', type: 'feature', value: 'auto') ++option('amrwb_demuxer', type: 'feature', value: 'auto') ++option('anm_demuxer', type: 'feature', value: 'auto') ++option('apac_demuxer', type: 'feature', value: 'auto') ++option('apc_demuxer', type: 'feature', value: 'auto') ++option('ape_demuxer', type: 'feature', value: 'auto') ++option('apm_demuxer', type: 'feature', value: 'auto') ++option('apng_demuxer', type: 'feature', value: 'auto') ++option('aptx_demuxer', type: 'feature', value: 'auto') ++option('aptx_hd_demuxer', type: 'feature', value: 'auto') ++option('aqtitle_demuxer', type: 'feature', value: 'auto') ++option('argo_asf_demuxer', type: 'feature', value: 'auto') ++option('argo_brp_demuxer', type: 'feature', value: 'auto') ++option('argo_cvg_demuxer', type: 'feature', value: 'auto') ++option('asf_demuxer', type: 'feature', value: 'auto') ++option('asf_o_demuxer', type: 'feature', value: 'auto') ++option('ass_demuxer', type: 'feature', value: 'auto') ++option('ast_demuxer', type: 'feature', value: 'auto') ++option('au_demuxer', type: 'feature', value: 'auto') ++option('av1_demuxer', type: 'feature', value: 'auto') ++option('avi_demuxer', type: 'feature', value: 'auto') ++option('avisynth_demuxer', type: 'feature', value: 'auto') ++option('avr_demuxer', type: 'feature', value: 'auto') ++option('avs_demuxer', type: 'feature', value: 'auto') ++option('avs2_demuxer', type: 'feature', value: 'auto') ++option('avs3_demuxer', type: 'feature', value: 'auto') ++option('bethsoftvid_demuxer', type: 'feature', value: 'auto') ++option('bfi_demuxer', type: 'feature', value: 'auto') ++option('bintext_demuxer', type: 'feature', value: 'auto') ++option('bink_demuxer', type: 'feature', value: 'auto') ++option('binka_demuxer', type: 'feature', value: 'auto') ++option('bit_demuxer', type: 'feature', value: 'auto') ++option('bitpacked_demuxer', type: 'feature', value: 'auto') ++option('bmv_demuxer', type: 'feature', value: 'auto') ++option('bfstm_demuxer', type: 'feature', value: 'auto') ++option('brstm_demuxer', type: 'feature', value: 'auto') ++option('boa_demuxer', type: 'feature', value: 'auto') ++option('bonk_demuxer', type: 'feature', value: 'auto') ++option('c93_demuxer', type: 'feature', value: 'auto') ++option('caf_demuxer', type: 'feature', value: 'auto') ++option('cavsvideo_demuxer', type: 'feature', value: 'auto') ++option('cdg_demuxer', type: 'feature', value: 'auto') ++option('cdxl_demuxer', type: 'feature', value: 'auto') ++option('cine_demuxer', type: 'feature', value: 'auto') ++option('codec2_demuxer', type: 'feature', value: 'auto') ++option('codec2raw_demuxer', type: 'feature', value: 'auto') ++option('concat_demuxer', type: 'feature', value: 'auto') ++option('dash_demuxer', type: 'feature', value: 'auto') ++option('data_demuxer', type: 'feature', value: 'auto') ++option('daud_demuxer', type: 'feature', value: 'auto') ++option('dcstr_demuxer', type: 'feature', value: 'auto') ++option('derf_demuxer', type: 'feature', value: 'auto') ++option('dfa_demuxer', type: 'feature', value: 'auto') ++option('dfpwm_demuxer', type: 'feature', value: 'auto') ++option('dhav_demuxer', type: 'feature', value: 'auto') ++option('dirac_demuxer', type: 'feature', value: 'auto') ++option('dnxhd_demuxer', type: 'feature', value: 'auto') ++option('dsf_demuxer', type: 'feature', value: 'auto') ++option('dsicin_demuxer', type: 'feature', value: 'auto') ++option('dss_demuxer', type: 'feature', value: 'auto') ++option('dts_demuxer', type: 'feature', value: 'auto') ++option('dtshd_demuxer', type: 'feature', value: 'auto') ++option('dv_demuxer', type: 'feature', value: 'auto') ++option('dvbsub_demuxer', type: 'feature', value: 'auto') ++option('dvbtxt_demuxer', type: 'feature', value: 'auto') ++option('dxa_demuxer', type: 'feature', value: 'auto') ++option('ea_demuxer', type: 'feature', value: 'auto') ++option('ea_cdata_demuxer', type: 'feature', value: 'auto') ++option('eac3_demuxer', type: 'feature', value: 'auto') ++option('epaf_demuxer', type: 'feature', value: 'auto') ++option('ffmetadata_demuxer', type: 'feature', value: 'auto') ++option('filmstrip_demuxer', type: 'feature', value: 'auto') ++option('fits_demuxer', type: 'feature', value: 'auto') ++option('flac_demuxer', type: 'feature', value: 'auto') ++option('flic_demuxer', type: 'feature', value: 'auto') ++option('flv_demuxer', type: 'feature', value: 'auto') ++option('live_flv_demuxer', type: 'feature', value: 'auto') ++option('fourxm_demuxer', type: 'feature', value: 'auto') ++option('frm_demuxer', type: 'feature', value: 'auto') ++option('fsb_demuxer', type: 'feature', value: 'auto') ++option('fwse_demuxer', type: 'feature', value: 'auto') ++option('g722_demuxer', type: 'feature', value: 'auto') ++option('g723_1_demuxer', type: 'feature', value: 'auto') ++option('g726_demuxer', type: 'feature', value: 'auto') ++option('g726le_demuxer', type: 'feature', value: 'auto') ++option('g729_demuxer', type: 'feature', value: 'auto') ++option('gdv_demuxer', type: 'feature', value: 'auto') ++option('genh_demuxer', type: 'feature', value: 'auto') ++option('gif_demuxer', type: 'feature', value: 'auto') ++option('gsm_demuxer', type: 'feature', value: 'auto') ++option('gxf_demuxer', type: 'feature', value: 'auto') ++option('h261_demuxer', type: 'feature', value: 'auto') ++option('h263_demuxer', type: 'feature', value: 'auto') ++option('h264_demuxer', type: 'feature', value: 'auto') ++option('hca_demuxer', type: 'feature', value: 'auto') ++option('hcom_demuxer', type: 'feature', value: 'auto') ++option('hevc_demuxer', type: 'feature', value: 'auto') ++option('hls_demuxer', type: 'feature', value: 'auto') ++option('hnm_demuxer', type: 'feature', value: 'auto') ++option('ico_demuxer', type: 'feature', value: 'auto') ++option('idcin_demuxer', type: 'feature', value: 'auto') ++option('idf_demuxer', type: 'feature', value: 'auto') ++option('iff_demuxer', type: 'feature', value: 'auto') ++option('ifv_demuxer', type: 'feature', value: 'auto') ++option('ilbc_demuxer', type: 'feature', value: 'auto') ++option('image2_demuxer', type: 'feature', value: 'auto') ++option('image2pipe_demuxer', type: 'feature', value: 'auto') ++option('image2_alias_pix_demuxer', type: 'feature', value: 'auto') ++option('image2_brender_pix_demuxer', type: 'feature', value: 'auto') ++option('imf_demuxer', type: 'feature', value: 'auto') ++option('ingenient_demuxer', type: 'feature', value: 'auto') ++option('ipmovie_demuxer', type: 'feature', value: 'auto') ++option('ipu_demuxer', type: 'feature', value: 'auto') ++option('ircam_demuxer', type: 'feature', value: 'auto') ++option('iss_demuxer', type: 'feature', value: 'auto') ++option('iv8_demuxer', type: 'feature', value: 'auto') ++option('ivf_demuxer', type: 'feature', value: 'auto') ++option('ivr_demuxer', type: 'feature', value: 'auto') ++option('jacosub_demuxer', type: 'feature', value: 'auto') ++option('jv_demuxer', type: 'feature', value: 'auto') ++option('kux_demuxer', type: 'feature', value: 'auto') ++option('kvag_demuxer', type: 'feature', value: 'auto') ++option('laf_demuxer', type: 'feature', value: 'auto') ++option('lmlm4_demuxer', type: 'feature', value: 'auto') ++option('loas_demuxer', type: 'feature', value: 'auto') ++option('luodat_demuxer', type: 'feature', value: 'auto') ++option('lrc_demuxer', type: 'feature', value: 'auto') ++option('lvf_demuxer', type: 'feature', value: 'auto') ++option('lxf_demuxer', type: 'feature', value: 'auto') ++option('m4v_demuxer', type: 'feature', value: 'auto') ++option('mca_demuxer', type: 'feature', value: 'auto') ++option('mcc_demuxer', type: 'feature', value: 'auto') ++option('matroska_demuxer', type: 'feature', value: 'auto') ++option('mgsts_demuxer', type: 'feature', value: 'auto') ++option('microdvd_demuxer', type: 'feature', value: 'auto') ++option('mjpeg_demuxer', type: 'feature', value: 'auto') ++option('mjpeg_2000_demuxer', type: 'feature', value: 'auto') ++option('mlp_demuxer', type: 'feature', value: 'auto') ++option('mlv_demuxer', type: 'feature', value: 'auto') ++option('mm_demuxer', type: 'feature', value: 'auto') ++option('mmf_demuxer', type: 'feature', value: 'auto') ++option('mods_demuxer', type: 'feature', value: 'auto') ++option('moflex_demuxer', type: 'feature', value: 'auto') ++option('mov_demuxer', type: 'feature', value: 'auto') ++option('mp3_demuxer', type: 'feature', value: 'auto') ++option('mpc_demuxer', type: 'feature', value: 'auto') ++option('mpc8_demuxer', type: 'feature', value: 'auto') ++option('mpegps_demuxer', type: 'feature', value: 'auto') ++option('mpegts_demuxer', type: 'feature', value: 'auto') ++option('mpegtsraw_demuxer', type: 'feature', value: 'auto') ++option('mpegvideo_demuxer', type: 'feature', value: 'auto') ++option('mpjpeg_demuxer', type: 'feature', value: 'auto') ++option('mpl2_demuxer', type: 'feature', value: 'auto') ++option('mpsub_demuxer', type: 'feature', value: 'auto') ++option('msf_demuxer', type: 'feature', value: 'auto') ++option('msnwc_tcp_demuxer', type: 'feature', value: 'auto') ++option('msp_demuxer', type: 'feature', value: 'auto') ++option('mtaf_demuxer', type: 'feature', value: 'auto') ++option('mtv_demuxer', type: 'feature', value: 'auto') ++option('musx_demuxer', type: 'feature', value: 'auto') ++option('mv_demuxer', type: 'feature', value: 'auto') ++option('mvi_demuxer', type: 'feature', value: 'auto') ++option('mxf_demuxer', type: 'feature', value: 'auto') ++option('mxg_demuxer', type: 'feature', value: 'auto') ++option('nc_demuxer', type: 'feature', value: 'auto') ++option('nistsphere_demuxer', type: 'feature', value: 'auto') ++option('nsp_demuxer', type: 'feature', value: 'auto') ++option('nsv_demuxer', type: 'feature', value: 'auto') ++option('nut_demuxer', type: 'feature', value: 'auto') ++option('nuv_demuxer', type: 'feature', value: 'auto') ++option('obu_demuxer', type: 'feature', value: 'auto') ++option('ogg_demuxer', type: 'feature', value: 'auto') ++option('oma_demuxer', type: 'feature', value: 'auto') ++option('paf_demuxer', type: 'feature', value: 'auto') ++option('pcm_alaw_demuxer', type: 'feature', value: 'auto') ++option('pcm_mulaw_demuxer', type: 'feature', value: 'auto') ++option('pcm_vidc_demuxer', type: 'feature', value: 'auto') ++option('pcm_f64be_demuxer', type: 'feature', value: 'auto') ++option('pcm_f64le_demuxer', type: 'feature', value: 'auto') ++option('pcm_f32be_demuxer', type: 'feature', value: 'auto') ++option('pcm_f32le_demuxer', type: 'feature', value: 'auto') ++option('pcm_s32be_demuxer', type: 'feature', value: 'auto') ++option('pcm_s32le_demuxer', type: 'feature', value: 'auto') ++option('pcm_s24be_demuxer', type: 'feature', value: 'auto') ++option('pcm_s24le_demuxer', type: 'feature', value: 'auto') ++option('pcm_s16be_demuxer', type: 'feature', value: 'auto') ++option('pcm_s16le_demuxer', type: 'feature', value: 'auto') ++option('pcm_s8_demuxer', type: 'feature', value: 'auto') ++option('pcm_u32be_demuxer', type: 'feature', value: 'auto') ++option('pcm_u32le_demuxer', type: 'feature', value: 'auto') ++option('pcm_u24be_demuxer', type: 'feature', value: 'auto') ++option('pcm_u24le_demuxer', type: 'feature', value: 'auto') ++option('pcm_u16be_demuxer', type: 'feature', value: 'auto') ++option('pcm_u16le_demuxer', type: 'feature', value: 'auto') ++option('pcm_u8_demuxer', type: 'feature', value: 'auto') ++option('pjs_demuxer', type: 'feature', value: 'auto') ++option('pmp_demuxer', type: 'feature', value: 'auto') ++option('pp_bnk_demuxer', type: 'feature', value: 'auto') ++option('pva_demuxer', type: 'feature', value: 'auto') ++option('pvf_demuxer', type: 'feature', value: 'auto') ++option('qcp_demuxer', type: 'feature', value: 'auto') ++option('r3d_demuxer', type: 'feature', value: 'auto') ++option('rawvideo_demuxer', type: 'feature', value: 'auto') ++option('realtext_demuxer', type: 'feature', value: 'auto') ++option('redspark_demuxer', type: 'feature', value: 'auto') ++option('rka_demuxer', type: 'feature', value: 'auto') ++option('rl2_demuxer', type: 'feature', value: 'auto') ++option('rm_demuxer', type: 'feature', value: 'auto') ++option('roq_demuxer', type: 'feature', value: 'auto') ++option('rpl_demuxer', type: 'feature', value: 'auto') ++option('rsd_demuxer', type: 'feature', value: 'auto') ++option('rso_demuxer', type: 'feature', value: 'auto') ++option('rtp_demuxer', type: 'feature', value: 'auto') ++option('rtsp_demuxer', type: 'feature', value: 'auto') ++option('s337m_demuxer', type: 'feature', value: 'auto') ++option('sami_demuxer', type: 'feature', value: 'auto') ++option('sap_demuxer', type: 'feature', value: 'auto') ++option('sbc_demuxer', type: 'feature', value: 'auto') ++option('sbg_demuxer', type: 'feature', value: 'auto') ++option('scc_demuxer', type: 'feature', value: 'auto') ++option('scd_demuxer', type: 'feature', value: 'auto') ++option('sdns_demuxer', type: 'feature', value: 'auto') ++option('sdp_demuxer', type: 'feature', value: 'auto') ++option('sdr2_demuxer', type: 'feature', value: 'auto') ++option('sds_demuxer', type: 'feature', value: 'auto') ++option('sdx_demuxer', type: 'feature', value: 'auto') ++option('segafilm_demuxer', type: 'feature', value: 'auto') ++option('ser_demuxer', type: 'feature', value: 'auto') ++option('sga_demuxer', type: 'feature', value: 'auto') ++option('shorten_demuxer', type: 'feature', value: 'auto') ++option('siff_demuxer', type: 'feature', value: 'auto') ++option('simbiosis_imx_demuxer', type: 'feature', value: 'auto') ++option('sln_demuxer', type: 'feature', value: 'auto') ++option('smacker_demuxer', type: 'feature', value: 'auto') ++option('smjpeg_demuxer', type: 'feature', value: 'auto') ++option('smush_demuxer', type: 'feature', value: 'auto') ++option('sol_demuxer', type: 'feature', value: 'auto') ++option('sox_demuxer', type: 'feature', value: 'auto') ++option('spdif_demuxer', type: 'feature', value: 'auto') ++option('srt_demuxer', type: 'feature', value: 'auto') ++option('str_demuxer', type: 'feature', value: 'auto') ++option('stl_demuxer', type: 'feature', value: 'auto') ++option('subviewer1_demuxer', type: 'feature', value: 'auto') ++option('subviewer_demuxer', type: 'feature', value: 'auto') ++option('sup_demuxer', type: 'feature', value: 'auto') ++option('svag_demuxer', type: 'feature', value: 'auto') ++option('svs_demuxer', type: 'feature', value: 'auto') ++option('swf_demuxer', type: 'feature', value: 'auto') ++option('tak_demuxer', type: 'feature', value: 'auto') ++option('tedcaptions_demuxer', type: 'feature', value: 'auto') ++option('thp_demuxer', type: 'feature', value: 'auto') ++option('threedostr_demuxer', type: 'feature', value: 'auto') ++option('tiertexseq_demuxer', type: 'feature', value: 'auto') ++option('tmv_demuxer', type: 'feature', value: 'auto') ++option('truehd_demuxer', type: 'feature', value: 'auto') ++option('tta_demuxer', type: 'feature', value: 'auto') ++option('txd_demuxer', type: 'feature', value: 'auto') ++option('tty_demuxer', type: 'feature', value: 'auto') ++option('ty_demuxer', type: 'feature', value: 'auto') ++option('v210_demuxer', type: 'feature', value: 'auto') ++option('v210x_demuxer', type: 'feature', value: 'auto') ++option('vag_demuxer', type: 'feature', value: 'auto') ++option('vc1_demuxer', type: 'feature', value: 'auto') ++option('vc1t_demuxer', type: 'feature', value: 'auto') ++option('vividas_demuxer', type: 'feature', value: 'auto') ++option('vivo_demuxer', type: 'feature', value: 'auto') ++option('vmd_demuxer', type: 'feature', value: 'auto') ++option('vobsub_demuxer', type: 'feature', value: 'auto') ++option('voc_demuxer', type: 'feature', value: 'auto') ++option('vpk_demuxer', type: 'feature', value: 'auto') ++option('vplayer_demuxer', type: 'feature', value: 'auto') ++option('vqf_demuxer', type: 'feature', value: 'auto') ++option('w64_demuxer', type: 'feature', value: 'auto') ++option('wady_demuxer', type: 'feature', value: 'auto') ++option('wavarc_demuxer', type: 'feature', value: 'auto') ++option('wav_demuxer', type: 'feature', value: 'auto') ++option('wc3_demuxer', type: 'feature', value: 'auto') ++option('webm_dash_manifest_demuxer', type: 'feature', value: 'auto') ++option('webvtt_demuxer', type: 'feature', value: 'auto') ++option('wsaud_demuxer', type: 'feature', value: 'auto') ++option('wsd_demuxer', type: 'feature', value: 'auto') ++option('wsvqa_demuxer', type: 'feature', value: 'auto') ++option('wtv_demuxer', type: 'feature', value: 'auto') ++option('wve_demuxer', type: 'feature', value: 'auto') ++option('wv_demuxer', type: 'feature', value: 'auto') ++option('xa_demuxer', type: 'feature', value: 'auto') ++option('xbin_demuxer', type: 'feature', value: 'auto') ++option('xmd_demuxer', type: 'feature', value: 'auto') ++option('xmv_demuxer', type: 'feature', value: 'auto') ++option('xvag_demuxer', type: 'feature', value: 'auto') ++option('xwma_demuxer', type: 'feature', value: 'auto') ++option('yop_demuxer', type: 'feature', value: 'auto') ++option('yuv4mpegpipe_demuxer', type: 'feature', value: 'auto') ++option('image_bmp_pipe_demuxer', type: 'feature', value: 'auto') ++option('image_cri_pipe_demuxer', type: 'feature', value: 'auto') ++option('image_dds_pipe_demuxer', type: 'feature', value: 'auto') ++option('image_dpx_pipe_demuxer', type: 'feature', value: 'auto') ++option('image_exr_pipe_demuxer', type: 'feature', value: 'auto') ++option('image_gem_pipe_demuxer', type: 'feature', value: 'auto') ++option('image_gif_pipe_demuxer', type: 'feature', value: 'auto') ++option('image_hdr_pipe_demuxer', type: 'feature', value: 'auto') ++option('image_j2k_pipe_demuxer', type: 'feature', value: 'auto') ++option('image_jpeg_pipe_demuxer', type: 'feature', value: 'auto') ++option('image_jpegls_pipe_demuxer', type: 'feature', value: 'auto') ++option('image_jpegxl_pipe_demuxer', type: 'feature', value: 'auto') ++option('image_pam_pipe_demuxer', type: 'feature', value: 'auto') ++option('image_pbm_pipe_demuxer', type: 'feature', value: 'auto') ++option('image_pcx_pipe_demuxer', type: 'feature', value: 'auto') ++option('image_pfm_pipe_demuxer', type: 'feature', value: 'auto') ++option('image_pgmyuv_pipe_demuxer', type: 'feature', value: 'auto') ++option('image_pgm_pipe_demuxer', type: 'feature', value: 'auto') ++option('image_pgx_pipe_demuxer', type: 'feature', value: 'auto') ++option('image_phm_pipe_demuxer', type: 'feature', value: 'auto') ++option('image_photocd_pipe_demuxer', type: 'feature', value: 'auto') ++option('image_pictor_pipe_demuxer', type: 'feature', value: 'auto') ++option('image_png_pipe_demuxer', type: 'feature', value: 'auto') ++option('image_ppm_pipe_demuxer', type: 'feature', value: 'auto') ++option('image_psd_pipe_demuxer', type: 'feature', value: 'auto') ++option('image_qdraw_pipe_demuxer', type: 'feature', value: 'auto') ++option('image_qoi_pipe_demuxer', type: 'feature', value: 'auto') ++option('image_sgi_pipe_demuxer', type: 'feature', value: 'auto') ++option('image_svg_pipe_demuxer', type: 'feature', value: 'auto') ++option('image_sunrast_pipe_demuxer', type: 'feature', value: 'auto') ++option('image_tiff_pipe_demuxer', type: 'feature', value: 'auto') ++option('image_vbn_pipe_demuxer', type: 'feature', value: 'auto') ++option('image_webp_pipe_demuxer', type: 'feature', value: 'auto') ++option('image_xbm_pipe_demuxer', type: 'feature', value: 'auto') ++option('image_xpm_pipe_demuxer', type: 'feature', value: 'auto') ++option('image_xwd_pipe_demuxer', type: 'feature', value: 'auto') ++option('libgme_demuxer', type: 'feature', value: 'auto') ++option('libmodplug_demuxer', type: 'feature', value: 'auto') ++option('libopenmpt_demuxer', type: 'feature', value: 'auto') ++option('vapoursynth_demuxer', type: 'feature', value: 'auto') ++option('demuxers', type: 'feature', value: 'auto', description: 'Enable or disable all demuxers') ++ ++# Generated encoder options ++option('a64multi_encoder', type: 'feature', value: 'auto') ++option('a64multi5_encoder', type: 'feature', value: 'auto') ++option('alias_pix_encoder', type: 'feature', value: 'auto') ++option('amv_encoder', type: 'feature', value: 'auto') ++option('apng_encoder', type: 'feature', value: 'auto') ++option('asv1_encoder', type: 'feature', value: 'auto') ++option('asv2_encoder', type: 'feature', value: 'auto') ++option('avrp_encoder', type: 'feature', value: 'auto') ++option('avui_encoder', type: 'feature', value: 'auto') ++option('ayuv_encoder', type: 'feature', value: 'auto') ++option('bitpacked_encoder', type: 'feature', value: 'auto') ++option('bmp_encoder', type: 'feature', value: 'auto') ++option('cfhd_encoder', type: 'feature', value: 'auto') ++option('cinepak_encoder', type: 'feature', value: 'auto') ++option('cljr_encoder', type: 'feature', value: 'auto') ++option('comfortnoise_encoder', type: 'feature', value: 'auto') ++option('dnxhd_encoder', type: 'feature', value: 'auto') ++option('dpx_encoder', type: 'feature', value: 'auto') ++option('dvvideo_encoder', type: 'feature', value: 'auto') ++option('exr_encoder', type: 'feature', value: 'auto') ++option('ffv1_encoder', type: 'feature', value: 'auto') ++option('ffvhuff_encoder', type: 'feature', value: 'auto') ++option('fits_encoder', type: 'feature', value: 'auto') ++option('flashsv_encoder', type: 'feature', value: 'auto') ++option('flashsv2_encoder', type: 'feature', value: 'auto') ++option('flv_encoder', type: 'feature', value: 'auto') ++option('gif_encoder', type: 'feature', value: 'auto') ++option('h261_encoder', type: 'feature', value: 'auto') ++option('h263_encoder', type: 'feature', value: 'auto') ++option('h263p_encoder', type: 'feature', value: 'auto') ++option('h264_mediacodec_encoder', type: 'feature', value: 'auto') ++option('hap_encoder', type: 'feature', value: 'auto') ++option('huffyuv_encoder', type: 'feature', value: 'auto') ++option('jpeg2000_encoder', type: 'feature', value: 'auto') ++option('jpegls_encoder', type: 'feature', value: 'auto') ++option('ljpeg_encoder', type: 'feature', value: 'auto') ++option('magicyuv_encoder', type: 'feature', value: 'auto') ++option('mjpeg_encoder', type: 'feature', value: 'auto') ++option('mpeg1video_encoder', type: 'feature', value: 'auto') ++option('mpeg2video_encoder', type: 'feature', value: 'auto') ++option('mpeg4_encoder', type: 'feature', value: 'auto') ++option('msmpeg4v2_encoder', type: 'feature', value: 'auto') ++option('msmpeg4v3_encoder', type: 'feature', value: 'auto') ++option('msvideo1_encoder', type: 'feature', value: 'auto') ++option('pam_encoder', type: 'feature', value: 'auto') ++option('pbm_encoder', type: 'feature', value: 'auto') ++option('pcx_encoder', type: 'feature', value: 'auto') ++option('pfm_encoder', type: 'feature', value: 'auto') ++option('pgm_encoder', type: 'feature', value: 'auto') ++option('pgmyuv_encoder', type: 'feature', value: 'auto') ++option('phm_encoder', type: 'feature', value: 'auto') ++option('png_encoder', type: 'feature', value: 'auto') ++option('ppm_encoder', type: 'feature', value: 'auto') ++option('prores_encoder', type: 'feature', value: 'auto') ++option('prores_aw_encoder', type: 'feature', value: 'auto') ++option('prores_ks_encoder', type: 'feature', value: 'auto') ++option('qoi_encoder', type: 'feature', value: 'auto') ++option('qtrle_encoder', type: 'feature', value: 'auto') ++option('r10k_encoder', type: 'feature', value: 'auto') ++option('r210_encoder', type: 'feature', value: 'auto') ++option('rawvideo_encoder', type: 'feature', value: 'auto') ++option('roq_encoder', type: 'feature', value: 'auto') ++option('rpza_encoder', type: 'feature', value: 'auto') ++option('rv10_encoder', type: 'feature', value: 'auto') ++option('rv20_encoder', type: 'feature', value: 'auto') ++option('s302m_encoder', type: 'feature', value: 'auto') ++option('sgi_encoder', type: 'feature', value: 'auto') ++option('smc_encoder', type: 'feature', value: 'auto') ++option('snow_encoder', type: 'feature', value: 'auto') ++option('speedhq_encoder', type: 'feature', value: 'auto') ++option('sunrast_encoder', type: 'feature', value: 'auto') ++option('svq1_encoder', type: 'feature', value: 'auto') ++option('targa_encoder', type: 'feature', value: 'auto') ++option('tiff_encoder', type: 'feature', value: 'auto') ++option('utvideo_encoder', type: 'feature', value: 'auto') ++option('v210_encoder', type: 'feature', value: 'auto') ++option('v308_encoder', type: 'feature', value: 'auto') ++option('v408_encoder', type: 'feature', value: 'auto') ++option('v410_encoder', type: 'feature', value: 'auto') ++option('vbn_encoder', type: 'feature', value: 'auto') ++option('vc2_encoder', type: 'feature', value: 'auto') ++option('wbmp_encoder', type: 'feature', value: 'auto') ++option('wrapped_avframe_encoder', type: 'feature', value: 'auto') ++option('wmv1_encoder', type: 'feature', value: 'auto') ++option('wmv2_encoder', type: 'feature', value: 'auto') ++option('xbm_encoder', type: 'feature', value: 'auto') ++option('xface_encoder', type: 'feature', value: 'auto') ++option('xwd_encoder', type: 'feature', value: 'auto') ++option('y41p_encoder', type: 'feature', value: 'auto') ++option('yuv4_encoder', type: 'feature', value: 'auto') ++option('zlib_encoder', type: 'feature', value: 'auto') ++option('zmbv_encoder', type: 'feature', value: 'auto') ++option('aac_encoder', type: 'feature', value: 'auto') ++option('ac3_encoder', type: 'feature', value: 'auto') ++option('ac3_fixed_encoder', type: 'feature', value: 'auto') ++option('alac_encoder', type: 'feature', value: 'auto') ++option('aptx_encoder', type: 'feature', value: 'auto') ++option('aptx_hd_encoder', type: 'feature', value: 'auto') ++option('dca_encoder', type: 'feature', value: 'auto') ++option('dfpwm_encoder', type: 'feature', value: 'auto') ++option('eac3_encoder', type: 'feature', value: 'auto') ++option('flac_encoder', type: 'feature', value: 'auto') ++option('g723_1_encoder', type: 'feature', value: 'auto') ++option('hdr_encoder', type: 'feature', value: 'auto') ++option('mlp_encoder', type: 'feature', value: 'auto') ++option('mp2_encoder', type: 'feature', value: 'auto') ++option('mp2fixed_encoder', type: 'feature', value: 'auto') ++option('nellymoser_encoder', type: 'feature', value: 'auto') ++option('opus_encoder', type: 'feature', value: 'auto') ++option('ra_144_encoder', type: 'feature', value: 'auto') ++option('sbc_encoder', type: 'feature', value: 'auto') ++option('sonic_encoder', type: 'feature', value: 'auto') ++option('sonic_ls_encoder', type: 'feature', value: 'auto') ++option('truehd_encoder', type: 'feature', value: 'auto') ++option('tta_encoder', type: 'feature', value: 'auto') ++option('vorbis_encoder', type: 'feature', value: 'auto') ++option('wavpack_encoder', type: 'feature', value: 'auto') ++option('wmav1_encoder', type: 'feature', value: 'auto') ++option('wmav2_encoder', type: 'feature', value: 'auto') ++option('pcm_alaw_encoder', type: 'feature', value: 'auto') ++option('pcm_bluray_encoder', type: 'feature', value: 'auto') ++option('pcm_dvd_encoder', type: 'feature', value: 'auto') ++option('pcm_f32be_encoder', type: 'feature', value: 'auto') ++option('pcm_f32le_encoder', type: 'feature', value: 'auto') ++option('pcm_f64be_encoder', type: 'feature', value: 'auto') ++option('pcm_f64le_encoder', type: 'feature', value: 'auto') ++option('pcm_mulaw_encoder', type: 'feature', value: 'auto') ++option('pcm_s8_encoder', type: 'feature', value: 'auto') ++option('pcm_s8_planar_encoder', type: 'feature', value: 'auto') ++option('pcm_s16be_encoder', type: 'feature', value: 'auto') ++option('pcm_s16be_planar_encoder', type: 'feature', value: 'auto') ++option('pcm_s16le_encoder', type: 'feature', value: 'auto') ++option('pcm_s16le_planar_encoder', type: 'feature', value: 'auto') ++option('pcm_s24be_encoder', type: 'feature', value: 'auto') ++option('pcm_s24daud_encoder', type: 'feature', value: 'auto') ++option('pcm_s24le_encoder', type: 'feature', value: 'auto') ++option('pcm_s24le_planar_encoder', type: 'feature', value: 'auto') ++option('pcm_s32be_encoder', type: 'feature', value: 'auto') ++option('pcm_s32le_encoder', type: 'feature', value: 'auto') ++option('pcm_s32le_planar_encoder', type: 'feature', value: 'auto') ++option('pcm_s64be_encoder', type: 'feature', value: 'auto') ++option('pcm_s64le_encoder', type: 'feature', value: 'auto') ++option('pcm_u8_encoder', type: 'feature', value: 'auto') ++option('pcm_u16be_encoder', type: 'feature', value: 'auto') ++option('pcm_u16le_encoder', type: 'feature', value: 'auto') ++option('pcm_u24be_encoder', type: 'feature', value: 'auto') ++option('pcm_u24le_encoder', type: 'feature', value: 'auto') ++option('pcm_u32be_encoder', type: 'feature', value: 'auto') ++option('pcm_u32le_encoder', type: 'feature', value: 'auto') ++option('pcm_vidc_encoder', type: 'feature', value: 'auto') ++option('roq_dpcm_encoder', type: 'feature', value: 'auto') ++option('adpcm_adx_encoder', type: 'feature', value: 'auto') ++option('adpcm_argo_encoder', type: 'feature', value: 'auto') ++option('adpcm_g722_encoder', type: 'feature', value: 'auto') ++option('adpcm_g726_encoder', type: 'feature', value: 'auto') ++option('adpcm_g726le_encoder', type: 'feature', value: 'auto') ++option('adpcm_ima_amv_encoder', type: 'feature', value: 'auto') ++option('adpcm_ima_alp_encoder', type: 'feature', value: 'auto') ++option('adpcm_ima_apm_encoder', type: 'feature', value: 'auto') ++option('adpcm_ima_qt_encoder', type: 'feature', value: 'auto') ++option('adpcm_ima_ssi_encoder', type: 'feature', value: 'auto') ++option('adpcm_ima_wav_encoder', type: 'feature', value: 'auto') ++option('adpcm_ima_ws_encoder', type: 'feature', value: 'auto') ++option('adpcm_ms_encoder', type: 'feature', value: 'auto') ++option('adpcm_swf_encoder', type: 'feature', value: 'auto') ++option('adpcm_yamaha_encoder', type: 'feature', value: 'auto') ++option('ssa_encoder', type: 'feature', value: 'auto') ++option('ass_encoder', type: 'feature', value: 'auto') ++option('dvbsub_encoder', type: 'feature', value: 'auto') ++option('dvdsub_encoder', type: 'feature', value: 'auto') ++option('movtext_encoder', type: 'feature', value: 'auto') ++option('srt_encoder', type: 'feature', value: 'auto') ++option('subrip_encoder', type: 'feature', value: 'auto') ++option('text_encoder', type: 'feature', value: 'auto') ++option('ttml_encoder', type: 'feature', value: 'auto') ++option('webvtt_encoder', type: 'feature', value: 'auto') ++option('xsub_encoder', type: 'feature', value: 'auto') ++option('aac_at_encoder', type: 'feature', value: 'auto') ++option('alac_at_encoder', type: 'feature', value: 'auto') ++option('ilbc_at_encoder', type: 'feature', value: 'auto') ++option('pcm_alaw_at_encoder', type: 'feature', value: 'auto') ++option('pcm_mulaw_at_encoder', type: 'feature', value: 'auto') ++option('libaom_av1_encoder', type: 'feature', value: 'auto') ++option('libcodec2_encoder', type: 'feature', value: 'auto') ++option('libfdk_aac_encoder', type: 'feature', value: 'auto') ++option('libgsm_encoder', type: 'feature', value: 'auto') ++option('libgsm_ms_encoder', type: 'feature', value: 'auto') ++option('libilbc_encoder', type: 'feature', value: 'auto') ++option('libjxl_encoder', type: 'feature', value: 'auto') ++option('libmp3lame_encoder', type: 'feature', value: 'auto') ++option('libopencore_amrnb_encoder', type: 'feature', value: 'auto') ++option('libopenjpeg_encoder', type: 'feature', value: 'auto') ++option('libopus_encoder', type: 'feature', value: 'auto') ++option('librav1e_encoder', type: 'feature', value: 'auto') ++option('libshine_encoder', type: 'feature', value: 'auto') ++option('libspeex_encoder', type: 'feature', value: 'auto') ++option('libsvtav1_encoder', type: 'feature', value: 'auto') ++option('libtheora_encoder', type: 'feature', value: 'auto') ++option('libtwolame_encoder', type: 'feature', value: 'auto') ++option('libvo_amrwbenc_encoder', type: 'feature', value: 'auto') ++option('libvorbis_encoder', type: 'feature', value: 'auto') ++option('libvpx_vp8_encoder', type: 'feature', value: 'auto') ++option('libvpx_vp9_encoder', type: 'feature', value: 'auto') ++option('libwebp_anim_encoder', type: 'feature', value: 'auto') ++option('libwebp_encoder', type: 'feature', value: 'auto') ++option('libx262_encoder', type: 'feature', value: 'auto') ++option('libx264_encoder', type: 'feature', value: 'auto') ++option('libx264rgb_encoder', type: 'feature', value: 'auto') ++option('libx265_encoder', type: 'feature', value: 'auto') ++option('libxavs_encoder', type: 'feature', value: 'auto') ++option('libxavs2_encoder', type: 'feature', value: 'auto') ++option('libxvid_encoder', type: 'feature', value: 'auto') ++option('aac_mf_encoder', type: 'feature', value: 'auto') ++option('ac3_mf_encoder', type: 'feature', value: 'auto') ++option('h263_v4l2m2m_encoder', type: 'feature', value: 'auto') ++option('av1_nvenc_encoder', type: 'feature', value: 'auto') ++option('av1_qsv_encoder', type: 'feature', value: 'auto') ++option('av1_amf_encoder', type: 'feature', value: 'auto') ++option('libopenh264_encoder', type: 'feature', value: 'auto') ++option('h264_amf_encoder', type: 'feature', value: 'auto') ++option('h264_mf_encoder', type: 'feature', value: 'auto') ++option('h264_nvenc_encoder', type: 'feature', value: 'auto') ++option('h264_omx_encoder', type: 'feature', value: 'auto') ++option('h264_qsv_encoder', type: 'feature', value: 'auto') ++option('h264_v4l2m2m_encoder', type: 'feature', value: 'auto') ++option('h264_vaapi_encoder', type: 'feature', value: 'auto') ++option('h264_videotoolbox_encoder', type: 'feature', value: 'auto') ++option('hevc_amf_encoder', type: 'feature', value: 'auto') ++option('hevc_mediacodec_encoder', type: 'feature', value: 'auto') ++option('hevc_mf_encoder', type: 'feature', value: 'auto') ++option('hevc_nvenc_encoder', type: 'feature', value: 'auto') ++option('hevc_qsv_encoder', type: 'feature', value: 'auto') ++option('hevc_v4l2m2m_encoder', type: 'feature', value: 'auto') ++option('hevc_vaapi_encoder', type: 'feature', value: 'auto') ++option('hevc_videotoolbox_encoder', type: 'feature', value: 'auto') ++option('libkvazaar_encoder', type: 'feature', value: 'auto') ++option('mjpeg_qsv_encoder', type: 'feature', value: 'auto') ++option('mjpeg_vaapi_encoder', type: 'feature', value: 'auto') ++option('mp3_mf_encoder', type: 'feature', value: 'auto') ++option('mpeg2_qsv_encoder', type: 'feature', value: 'auto') ++option('mpeg2_vaapi_encoder', type: 'feature', value: 'auto') ++option('mpeg4_omx_encoder', type: 'feature', value: 'auto') ++option('mpeg4_v4l2m2m_encoder', type: 'feature', value: 'auto') ++option('prores_videotoolbox_encoder', type: 'feature', value: 'auto') ++option('vp8_v4l2m2m_encoder', type: 'feature', value: 'auto') ++option('vp8_vaapi_encoder', type: 'feature', value: 'auto') ++option('vp9_vaapi_encoder', type: 'feature', value: 'auto') ++option('vp9_qsv_encoder', type: 'feature', value: 'auto') ++option('vnull_encoder', type: 'feature', value: 'auto') ++option('anull_encoder', type: 'feature', value: 'auto') ++option('encoders', type: 'feature', value: 'auto', description: 'Enable or disable all encoders') ++ ++# Generated decoder options ++option('aasc_decoder', type: 'feature', value: 'auto') ++option('aic_decoder', type: 'feature', value: 'auto') ++option('alias_pix_decoder', type: 'feature', value: 'auto') ++option('agm_decoder', type: 'feature', value: 'auto') ++option('amv_decoder', type: 'feature', value: 'auto') ++option('anm_decoder', type: 'feature', value: 'auto') ++option('ansi_decoder', type: 'feature', value: 'auto') ++option('apng_decoder', type: 'feature', value: 'auto') ++option('arbc_decoder', type: 'feature', value: 'auto') ++option('argo_decoder', type: 'feature', value: 'auto') ++option('asv1_decoder', type: 'feature', value: 'auto') ++option('asv2_decoder', type: 'feature', value: 'auto') ++option('aura_decoder', type: 'feature', value: 'auto') ++option('aura2_decoder', type: 'feature', value: 'auto') ++option('avrp_decoder', type: 'feature', value: 'auto') ++option('avrn_decoder', type: 'feature', value: 'auto') ++option('avs_decoder', type: 'feature', value: 'auto') ++option('avui_decoder', type: 'feature', value: 'auto') ++option('ayuv_decoder', type: 'feature', value: 'auto') ++option('bethsoftvid_decoder', type: 'feature', value: 'auto') ++option('bfi_decoder', type: 'feature', value: 'auto') ++option('bink_decoder', type: 'feature', value: 'auto') ++option('bitpacked_decoder', type: 'feature', value: 'auto') ++option('bmp_decoder', type: 'feature', value: 'auto') ++option('bmv_video_decoder', type: 'feature', value: 'auto') ++option('brender_pix_decoder', type: 'feature', value: 'auto') ++option('c93_decoder', type: 'feature', value: 'auto') ++option('cavs_decoder', type: 'feature', value: 'auto') ++option('cdgraphics_decoder', type: 'feature', value: 'auto') ++option('cdtoons_decoder', type: 'feature', value: 'auto') ++option('cdxl_decoder', type: 'feature', value: 'auto') ++option('cfhd_decoder', type: 'feature', value: 'auto') ++option('cinepak_decoder', type: 'feature', value: 'auto') ++option('clearvideo_decoder', type: 'feature', value: 'auto') ++option('cljr_decoder', type: 'feature', value: 'auto') ++option('cllc_decoder', type: 'feature', value: 'auto') ++option('comfortnoise_decoder', type: 'feature', value: 'auto') ++option('cpia_decoder', type: 'feature', value: 'auto') ++option('cri_decoder', type: 'feature', value: 'auto') ++option('cscd_decoder', type: 'feature', value: 'auto') ++option('cyuv_decoder', type: 'feature', value: 'auto') ++option('dds_decoder', type: 'feature', value: 'auto') ++option('dfa_decoder', type: 'feature', value: 'auto') ++option('dirac_decoder', type: 'feature', value: 'auto') ++option('dnxhd_decoder', type: 'feature', value: 'auto') ++option('dpx_decoder', type: 'feature', value: 'auto') ++option('dsicinvideo_decoder', type: 'feature', value: 'auto') ++option('dvaudio_decoder', type: 'feature', value: 'auto') ++option('dvvideo_decoder', type: 'feature', value: 'auto') ++option('dxa_decoder', type: 'feature', value: 'auto') ++option('dxtory_decoder', type: 'feature', value: 'auto') ++option('dxv_decoder', type: 'feature', value: 'auto') ++option('eacmv_decoder', type: 'feature', value: 'auto') ++option('eamad_decoder', type: 'feature', value: 'auto') ++option('eatgq_decoder', type: 'feature', value: 'auto') ++option('eatgv_decoder', type: 'feature', value: 'auto') ++option('eatqi_decoder', type: 'feature', value: 'auto') ++option('eightbps_decoder', type: 'feature', value: 'auto') ++option('eightsvx_exp_decoder', type: 'feature', value: 'auto') ++option('eightsvx_fib_decoder', type: 'feature', value: 'auto') ++option('escape124_decoder', type: 'feature', value: 'auto') ++option('escape130_decoder', type: 'feature', value: 'auto') ++option('exr_decoder', type: 'feature', value: 'auto') ++option('ffv1_decoder', type: 'feature', value: 'auto') ++option('ffvhuff_decoder', type: 'feature', value: 'auto') ++option('fic_decoder', type: 'feature', value: 'auto') ++option('fits_decoder', type: 'feature', value: 'auto') ++option('flashsv_decoder', type: 'feature', value: 'auto') ++option('flashsv2_decoder', type: 'feature', value: 'auto') ++option('flic_decoder', type: 'feature', value: 'auto') ++option('flv_decoder', type: 'feature', value: 'auto') ++option('fmvc_decoder', type: 'feature', value: 'auto') ++option('fourxm_decoder', type: 'feature', value: 'auto') ++option('fraps_decoder', type: 'feature', value: 'auto') ++option('frwu_decoder', type: 'feature', value: 'auto') ++option('g2m_decoder', type: 'feature', value: 'auto') ++option('gdv_decoder', type: 'feature', value: 'auto') ++option('gem_decoder', type: 'feature', value: 'auto') ++option('gif_decoder', type: 'feature', value: 'auto') ++option('h261_decoder', type: 'feature', value: 'auto') ++option('h263_decoder', type: 'feature', value: 'auto') ++option('h263i_decoder', type: 'feature', value: 'auto') ++option('h263p_decoder', type: 'feature', value: 'auto') ++option('h263_v4l2m2m_decoder', type: 'feature', value: 'auto') ++option('h264_decoder', type: 'feature', value: 'auto') ++option('h264_crystalhd_decoder', type: 'feature', value: 'auto') ++option('h264_v4l2m2m_decoder', type: 'feature', value: 'auto') ++option('h264_mediacodec_decoder', type: 'feature', value: 'auto') ++option('h264_mmal_decoder', type: 'feature', value: 'auto') ++option('h264_qsv_decoder', type: 'feature', value: 'auto') ++option('h264_rkmpp_decoder', type: 'feature', value: 'auto') ++option('hap_decoder', type: 'feature', value: 'auto') ++option('hevc_decoder', type: 'feature', value: 'auto') ++option('hevc_qsv_decoder', type: 'feature', value: 'auto') ++option('hevc_rkmpp_decoder', type: 'feature', value: 'auto') ++option('hevc_v4l2m2m_decoder', type: 'feature', value: 'auto') ++option('hnm4_video_decoder', type: 'feature', value: 'auto') ++option('hq_hqa_decoder', type: 'feature', value: 'auto') ++option('hqx_decoder', type: 'feature', value: 'auto') ++option('huffyuv_decoder', type: 'feature', value: 'auto') ++option('hymt_decoder', type: 'feature', value: 'auto') ++option('idcin_decoder', type: 'feature', value: 'auto') ++option('iff_ilbm_decoder', type: 'feature', value: 'auto') ++option('imm4_decoder', type: 'feature', value: 'auto') ++option('imm5_decoder', type: 'feature', value: 'auto') ++option('indeo2_decoder', type: 'feature', value: 'auto') ++option('indeo3_decoder', type: 'feature', value: 'auto') ++option('indeo4_decoder', type: 'feature', value: 'auto') ++option('indeo5_decoder', type: 'feature', value: 'auto') ++option('interplay_video_decoder', type: 'feature', value: 'auto') ++option('ipu_decoder', type: 'feature', value: 'auto') ++option('jpeg2000_decoder', type: 'feature', value: 'auto') ++option('jpegls_decoder', type: 'feature', value: 'auto') ++option('jv_decoder', type: 'feature', value: 'auto') ++option('kgv1_decoder', type: 'feature', value: 'auto') ++option('kmvc_decoder', type: 'feature', value: 'auto') ++option('lagarith_decoder', type: 'feature', value: 'auto') ++option('loco_decoder', type: 'feature', value: 'auto') ++option('lscr_decoder', type: 'feature', value: 'auto') ++option('m101_decoder', type: 'feature', value: 'auto') ++option('magicyuv_decoder', type: 'feature', value: 'auto') ++option('mdec_decoder', type: 'feature', value: 'auto') ++option('media100_decoder', type: 'feature', value: 'auto') ++option('mimic_decoder', type: 'feature', value: 'auto') ++option('mjpeg_decoder', type: 'feature', value: 'auto') ++option('mjpegb_decoder', type: 'feature', value: 'auto') ++option('mmvideo_decoder', type: 'feature', value: 'auto') ++option('mobiclip_decoder', type: 'feature', value: 'auto') ++option('motionpixels_decoder', type: 'feature', value: 'auto') ++option('mpeg1video_decoder', type: 'feature', value: 'auto') ++option('mpeg2video_decoder', type: 'feature', value: 'auto') ++option('mpeg4_decoder', type: 'feature', value: 'auto') ++option('mpeg4_crystalhd_decoder', type: 'feature', value: 'auto') ++option('mpeg4_v4l2m2m_decoder', type: 'feature', value: 'auto') ++option('mpeg4_mmal_decoder', type: 'feature', value: 'auto') ++option('mpegvideo_decoder', type: 'feature', value: 'auto') ++option('mpeg1_v4l2m2m_decoder', type: 'feature', value: 'auto') ++option('mpeg2_mmal_decoder', type: 'feature', value: 'auto') ++option('mpeg2_crystalhd_decoder', type: 'feature', value: 'auto') ++option('mpeg2_v4l2m2m_decoder', type: 'feature', value: 'auto') ++option('mpeg2_qsv_decoder', type: 'feature', value: 'auto') ++option('mpeg2_mediacodec_decoder', type: 'feature', value: 'auto') ++option('msa1_decoder', type: 'feature', value: 'auto') ++option('mscc_decoder', type: 'feature', value: 'auto') ++option('msmpeg4v1_decoder', type: 'feature', value: 'auto') ++option('msmpeg4v2_decoder', type: 'feature', value: 'auto') ++option('msmpeg4v3_decoder', type: 'feature', value: 'auto') ++option('msmpeg4_crystalhd_decoder', type: 'feature', value: 'auto') ++option('msp2_decoder', type: 'feature', value: 'auto') ++option('msrle_decoder', type: 'feature', value: 'auto') ++option('mss1_decoder', type: 'feature', value: 'auto') ++option('mss2_decoder', type: 'feature', value: 'auto') ++option('msvideo1_decoder', type: 'feature', value: 'auto') ++option('mszh_decoder', type: 'feature', value: 'auto') ++option('mts2_decoder', type: 'feature', value: 'auto') ++option('mv30_decoder', type: 'feature', value: 'auto') ++option('mvc1_decoder', type: 'feature', value: 'auto') ++option('mvc2_decoder', type: 'feature', value: 'auto') ++option('mvdv_decoder', type: 'feature', value: 'auto') ++option('mvha_decoder', type: 'feature', value: 'auto') ++option('mwsc_decoder', type: 'feature', value: 'auto') ++option('mxpeg_decoder', type: 'feature', value: 'auto') ++option('notchlc_decoder', type: 'feature', value: 'auto') ++option('nuv_decoder', type: 'feature', value: 'auto') ++option('paf_video_decoder', type: 'feature', value: 'auto') ++option('pam_decoder', type: 'feature', value: 'auto') ++option('pbm_decoder', type: 'feature', value: 'auto') ++option('pcx_decoder', type: 'feature', value: 'auto') ++option('pfm_decoder', type: 'feature', value: 'auto') ++option('pgm_decoder', type: 'feature', value: 'auto') ++option('pgmyuv_decoder', type: 'feature', value: 'auto') ++option('pgx_decoder', type: 'feature', value: 'auto') ++option('phm_decoder', type: 'feature', value: 'auto') ++option('photocd_decoder', type: 'feature', value: 'auto') ++option('pictor_decoder', type: 'feature', value: 'auto') ++option('pixlet_decoder', type: 'feature', value: 'auto') ++option('png_decoder', type: 'feature', value: 'auto') ++option('ppm_decoder', type: 'feature', value: 'auto') ++option('prores_decoder', type: 'feature', value: 'auto') ++option('prosumer_decoder', type: 'feature', value: 'auto') ++option('psd_decoder', type: 'feature', value: 'auto') ++option('ptx_decoder', type: 'feature', value: 'auto') ++option('qdraw_decoder', type: 'feature', value: 'auto') ++option('qoi_decoder', type: 'feature', value: 'auto') ++option('qpeg_decoder', type: 'feature', value: 'auto') ++option('qtrle_decoder', type: 'feature', value: 'auto') ++option('r10k_decoder', type: 'feature', value: 'auto') ++option('r210_decoder', type: 'feature', value: 'auto') ++option('rasc_decoder', type: 'feature', value: 'auto') ++option('rawvideo_decoder', type: 'feature', value: 'auto') ++option('rka_decoder', type: 'feature', value: 'auto') ++option('rl2_decoder', type: 'feature', value: 'auto') ++option('roq_decoder', type: 'feature', value: 'auto') ++option('rpza_decoder', type: 'feature', value: 'auto') ++option('rscc_decoder', type: 'feature', value: 'auto') ++option('rv10_decoder', type: 'feature', value: 'auto') ++option('rv20_decoder', type: 'feature', value: 'auto') ++option('rv30_decoder', type: 'feature', value: 'auto') ++option('rv40_decoder', type: 'feature', value: 'auto') ++option('s302m_decoder', type: 'feature', value: 'auto') ++option('sanm_decoder', type: 'feature', value: 'auto') ++option('scpr_decoder', type: 'feature', value: 'auto') ++option('screenpresso_decoder', type: 'feature', value: 'auto') ++option('sga_decoder', type: 'feature', value: 'auto') ++option('sgi_decoder', type: 'feature', value: 'auto') ++option('sgirle_decoder', type: 'feature', value: 'auto') ++option('sheervideo_decoder', type: 'feature', value: 'auto') ++option('simbiosis_imx_decoder', type: 'feature', value: 'auto') ++option('smacker_decoder', type: 'feature', value: 'auto') ++option('smc_decoder', type: 'feature', value: 'auto') ++option('smvjpeg_decoder', type: 'feature', value: 'auto') ++option('snow_decoder', type: 'feature', value: 'auto') ++option('sp5x_decoder', type: 'feature', value: 'auto') ++option('speedhq_decoder', type: 'feature', value: 'auto') ++option('speex_decoder', type: 'feature', value: 'auto') ++option('srgc_decoder', type: 'feature', value: 'auto') ++option('sunrast_decoder', type: 'feature', value: 'auto') ++option('svq1_decoder', type: 'feature', value: 'auto') ++option('svq3_decoder', type: 'feature', value: 'auto') ++option('targa_decoder', type: 'feature', value: 'auto') ++option('targa_y216_decoder', type: 'feature', value: 'auto') ++option('tdsc_decoder', type: 'feature', value: 'auto') ++option('theora_decoder', type: 'feature', value: 'auto') ++option('thp_decoder', type: 'feature', value: 'auto') ++option('tiertexseqvideo_decoder', type: 'feature', value: 'auto') ++option('tiff_decoder', type: 'feature', value: 'auto') ++option('tmv_decoder', type: 'feature', value: 'auto') ++option('truemotion1_decoder', type: 'feature', value: 'auto') ++option('truemotion2_decoder', type: 'feature', value: 'auto') ++option('truemotion2rt_decoder', type: 'feature', value: 'auto') ++option('tscc_decoder', type: 'feature', value: 'auto') ++option('tscc2_decoder', type: 'feature', value: 'auto') ++option('txd_decoder', type: 'feature', value: 'auto') ++option('ulti_decoder', type: 'feature', value: 'auto') ++option('utvideo_decoder', type: 'feature', value: 'auto') ++option('v210_decoder', type: 'feature', value: 'auto') ++option('v210x_decoder', type: 'feature', value: 'auto') ++option('v308_decoder', type: 'feature', value: 'auto') ++option('v408_decoder', type: 'feature', value: 'auto') ++option('v410_decoder', type: 'feature', value: 'auto') ++option('vb_decoder', type: 'feature', value: 'auto') ++option('vbn_decoder', type: 'feature', value: 'auto') ++option('vble_decoder', type: 'feature', value: 'auto') ++option('vc1_decoder', type: 'feature', value: 'auto') ++option('vc1_crystalhd_decoder', type: 'feature', value: 'auto') ++option('vc1image_decoder', type: 'feature', value: 'auto') ++option('vc1_mmal_decoder', type: 'feature', value: 'auto') ++option('vc1_qsv_decoder', type: 'feature', value: 'auto') ++option('vc1_v4l2m2m_decoder', type: 'feature', value: 'auto') ++option('vcr1_decoder', type: 'feature', value: 'auto') ++option('vmdvideo_decoder', type: 'feature', value: 'auto') ++option('vmnc_decoder', type: 'feature', value: 'auto') ++option('vp3_decoder', type: 'feature', value: 'auto') ++option('vp4_decoder', type: 'feature', value: 'auto') ++option('vp5_decoder', type: 'feature', value: 'auto') ++option('vp6_decoder', type: 'feature', value: 'auto') ++option('vp6a_decoder', type: 'feature', value: 'auto') ++option('vp6f_decoder', type: 'feature', value: 'auto') ++option('vp7_decoder', type: 'feature', value: 'auto') ++option('vp8_decoder', type: 'feature', value: 'auto') ++option('vp8_rkmpp_decoder', type: 'feature', value: 'auto') ++option('vp8_v4l2m2m_decoder', type: 'feature', value: 'auto') ++option('vp9_decoder', type: 'feature', value: 'auto') ++option('vp9_rkmpp_decoder', type: 'feature', value: 'auto') ++option('vp9_v4l2m2m_decoder', type: 'feature', value: 'auto') ++option('vqa_decoder', type: 'feature', value: 'auto') ++option('vqc_decoder', type: 'feature', value: 'auto') ++option('wbmp_decoder', type: 'feature', value: 'auto') ++option('webp_decoder', type: 'feature', value: 'auto') ++option('wcmv_decoder', type: 'feature', value: 'auto') ++option('wrapped_avframe_decoder', type: 'feature', value: 'auto') ++option('wmv1_decoder', type: 'feature', value: 'auto') ++option('wmv2_decoder', type: 'feature', value: 'auto') ++option('wmv3_decoder', type: 'feature', value: 'auto') ++option('wmv3_crystalhd_decoder', type: 'feature', value: 'auto') ++option('wmv3image_decoder', type: 'feature', value: 'auto') ++option('wnv1_decoder', type: 'feature', value: 'auto') ++option('xan_wc3_decoder', type: 'feature', value: 'auto') ++option('xan_wc4_decoder', type: 'feature', value: 'auto') ++option('xbm_decoder', type: 'feature', value: 'auto') ++option('xface_decoder', type: 'feature', value: 'auto') ++option('xl_decoder', type: 'feature', value: 'auto') ++option('xpm_decoder', type: 'feature', value: 'auto') ++option('xwd_decoder', type: 'feature', value: 'auto') ++option('y41p_decoder', type: 'feature', value: 'auto') ++option('ylc_decoder', type: 'feature', value: 'auto') ++option('yop_decoder', type: 'feature', value: 'auto') ++option('yuv4_decoder', type: 'feature', value: 'auto') ++option('zero12v_decoder', type: 'feature', value: 'auto') ++option('zerocodec_decoder', type: 'feature', value: 'auto') ++option('zlib_decoder', type: 'feature', value: 'auto') ++option('zmbv_decoder', type: 'feature', value: 'auto') ++option('aac_decoder', type: 'feature', value: 'auto') ++option('aac_fixed_decoder', type: 'feature', value: 'auto') ++option('aac_latm_decoder', type: 'feature', value: 'auto') ++option('ac3_decoder', type: 'feature', value: 'auto') ++option('ac3_fixed_decoder', type: 'feature', value: 'auto') ++option('acelp_kelvin_decoder', type: 'feature', value: 'auto') ++option('alac_decoder', type: 'feature', value: 'auto') ++option('als_decoder', type: 'feature', value: 'auto') ++option('amrnb_decoder', type: 'feature', value: 'auto') ++option('amrwb_decoder', type: 'feature', value: 'auto') ++option('apac_decoder', type: 'feature', value: 'auto') ++option('ape_decoder', type: 'feature', value: 'auto') ++option('aptx_decoder', type: 'feature', value: 'auto') ++option('aptx_hd_decoder', type: 'feature', value: 'auto') ++option('atrac1_decoder', type: 'feature', value: 'auto') ++option('atrac3_decoder', type: 'feature', value: 'auto') ++option('atrac3al_decoder', type: 'feature', value: 'auto') ++option('atrac3p_decoder', type: 'feature', value: 'auto') ++option('atrac3pal_decoder', type: 'feature', value: 'auto') ++option('atrac9_decoder', type: 'feature', value: 'auto') ++option('binkaudio_dct_decoder', type: 'feature', value: 'auto') ++option('binkaudio_rdft_decoder', type: 'feature', value: 'auto') ++option('bmv_audio_decoder', type: 'feature', value: 'auto') ++option('bonk_decoder', type: 'feature', value: 'auto') ++option('cook_decoder', type: 'feature', value: 'auto') ++option('dca_decoder', type: 'feature', value: 'auto') ++option('dfpwm_decoder', type: 'feature', value: 'auto') ++option('dolby_e_decoder', type: 'feature', value: 'auto') ++option('dsd_lsbf_decoder', type: 'feature', value: 'auto') ++option('dsd_msbf_decoder', type: 'feature', value: 'auto') ++option('dsd_lsbf_planar_decoder', type: 'feature', value: 'auto') ++option('dsd_msbf_planar_decoder', type: 'feature', value: 'auto') ++option('dsicinaudio_decoder', type: 'feature', value: 'auto') ++option('dss_sp_decoder', type: 'feature', value: 'auto') ++option('dst_decoder', type: 'feature', value: 'auto') ++option('eac3_decoder', type: 'feature', value: 'auto') ++option('evrc_decoder', type: 'feature', value: 'auto') ++option('fastaudio_decoder', type: 'feature', value: 'auto') ++option('ffwavesynth_decoder', type: 'feature', value: 'auto') ++option('flac_decoder', type: 'feature', value: 'auto') ++option('ftr_decoder', type: 'feature', value: 'auto') ++option('g723_1_decoder', type: 'feature', value: 'auto') ++option('g729_decoder', type: 'feature', value: 'auto') ++option('gsm_decoder', type: 'feature', value: 'auto') ++option('gsm_ms_decoder', type: 'feature', value: 'auto') ++option('hca_decoder', type: 'feature', value: 'auto') ++option('hcom_decoder', type: 'feature', value: 'auto') ++option('hdr_decoder', type: 'feature', value: 'auto') ++option('iac_decoder', type: 'feature', value: 'auto') ++option('ilbc_decoder', type: 'feature', value: 'auto') ++option('imc_decoder', type: 'feature', value: 'auto') ++option('interplay_acm_decoder', type: 'feature', value: 'auto') ++option('mace3_decoder', type: 'feature', value: 'auto') ++option('mace6_decoder', type: 'feature', value: 'auto') ++option('metasound_decoder', type: 'feature', value: 'auto') ++option('misc4_decoder', type: 'feature', value: 'auto') ++option('mlp_decoder', type: 'feature', value: 'auto') ++option('mp1_decoder', type: 'feature', value: 'auto') ++option('mp1float_decoder', type: 'feature', value: 'auto') ++option('mp2_decoder', type: 'feature', value: 'auto') ++option('mp2float_decoder', type: 'feature', value: 'auto') ++option('mp3float_decoder', type: 'feature', value: 'auto') ++option('mp3_decoder', type: 'feature', value: 'auto') ++option('mp3adufloat_decoder', type: 'feature', value: 'auto') ++option('mp3adu_decoder', type: 'feature', value: 'auto') ++option('mp3on4float_decoder', type: 'feature', value: 'auto') ++option('mp3on4_decoder', type: 'feature', value: 'auto') ++option('mpc7_decoder', type: 'feature', value: 'auto') ++option('mpc8_decoder', type: 'feature', value: 'auto') ++option('msnsiren_decoder', type: 'feature', value: 'auto') ++option('nellymoser_decoder', type: 'feature', value: 'auto') ++option('on2avc_decoder', type: 'feature', value: 'auto') ++option('opus_decoder', type: 'feature', value: 'auto') ++option('paf_audio_decoder', type: 'feature', value: 'auto') ++option('qcelp_decoder', type: 'feature', value: 'auto') ++option('qdm2_decoder', type: 'feature', value: 'auto') ++option('qdmc_decoder', type: 'feature', value: 'auto') ++option('ra_144_decoder', type: 'feature', value: 'auto') ++option('ra_288_decoder', type: 'feature', value: 'auto') ++option('ralf_decoder', type: 'feature', value: 'auto') ++option('sbc_decoder', type: 'feature', value: 'auto') ++option('shorten_decoder', type: 'feature', value: 'auto') ++option('sipr_decoder', type: 'feature', value: 'auto') ++option('siren_decoder', type: 'feature', value: 'auto') ++option('smackaud_decoder', type: 'feature', value: 'auto') ++option('sonic_decoder', type: 'feature', value: 'auto') ++option('tak_decoder', type: 'feature', value: 'auto') ++option('truehd_decoder', type: 'feature', value: 'auto') ++option('truespeech_decoder', type: 'feature', value: 'auto') ++option('tta_decoder', type: 'feature', value: 'auto') ++option('twinvq_decoder', type: 'feature', value: 'auto') ++option('vmdaudio_decoder', type: 'feature', value: 'auto') ++option('vorbis_decoder', type: 'feature', value: 'auto') ++option('wavarc_decoder', type: 'feature', value: 'auto') ++option('wavpack_decoder', type: 'feature', value: 'auto') ++option('wmalossless_decoder', type: 'feature', value: 'auto') ++option('wmapro_decoder', type: 'feature', value: 'auto') ++option('wmav1_decoder', type: 'feature', value: 'auto') ++option('wmav2_decoder', type: 'feature', value: 'auto') ++option('wmavoice_decoder', type: 'feature', value: 'auto') ++option('ws_snd1_decoder', type: 'feature', value: 'auto') ++option('xma1_decoder', type: 'feature', value: 'auto') ++option('xma2_decoder', type: 'feature', value: 'auto') ++option('pcm_alaw_decoder', type: 'feature', value: 'auto') ++option('pcm_bluray_decoder', type: 'feature', value: 'auto') ++option('pcm_dvd_decoder', type: 'feature', value: 'auto') ++option('pcm_f16le_decoder', type: 'feature', value: 'auto') ++option('pcm_f24le_decoder', type: 'feature', value: 'auto') ++option('pcm_f32be_decoder', type: 'feature', value: 'auto') ++option('pcm_f32le_decoder', type: 'feature', value: 'auto') ++option('pcm_f64be_decoder', type: 'feature', value: 'auto') ++option('pcm_f64le_decoder', type: 'feature', value: 'auto') ++option('pcm_lxf_decoder', type: 'feature', value: 'auto') ++option('pcm_mulaw_decoder', type: 'feature', value: 'auto') ++option('pcm_s8_decoder', type: 'feature', value: 'auto') ++option('pcm_s8_planar_decoder', type: 'feature', value: 'auto') ++option('pcm_s16be_decoder', type: 'feature', value: 'auto') ++option('pcm_s16be_planar_decoder', type: 'feature', value: 'auto') ++option('pcm_s16le_decoder', type: 'feature', value: 'auto') ++option('pcm_s16le_planar_decoder', type: 'feature', value: 'auto') ++option('pcm_s24be_decoder', type: 'feature', value: 'auto') ++option('pcm_s24daud_decoder', type: 'feature', value: 'auto') ++option('pcm_s24le_decoder', type: 'feature', value: 'auto') ++option('pcm_s24le_planar_decoder', type: 'feature', value: 'auto') ++option('pcm_s32be_decoder', type: 'feature', value: 'auto') ++option('pcm_s32le_decoder', type: 'feature', value: 'auto') ++option('pcm_s32le_planar_decoder', type: 'feature', value: 'auto') ++option('pcm_s64be_decoder', type: 'feature', value: 'auto') ++option('pcm_s64le_decoder', type: 'feature', value: 'auto') ++option('pcm_sga_decoder', type: 'feature', value: 'auto') ++option('pcm_u8_decoder', type: 'feature', value: 'auto') ++option('pcm_u16be_decoder', type: 'feature', value: 'auto') ++option('pcm_u16le_decoder', type: 'feature', value: 'auto') ++option('pcm_u24be_decoder', type: 'feature', value: 'auto') ++option('pcm_u24le_decoder', type: 'feature', value: 'auto') ++option('pcm_u32be_decoder', type: 'feature', value: 'auto') ++option('pcm_u32le_decoder', type: 'feature', value: 'auto') ++option('pcm_vidc_decoder', type: 'feature', value: 'auto') ++option('cbd2_dpcm_decoder', type: 'feature', value: 'auto') ++option('derf_dpcm_decoder', type: 'feature', value: 'auto') ++option('gremlin_dpcm_decoder', type: 'feature', value: 'auto') ++option('interplay_dpcm_decoder', type: 'feature', value: 'auto') ++option('roq_dpcm_decoder', type: 'feature', value: 'auto') ++option('sdx2_dpcm_decoder', type: 'feature', value: 'auto') ++option('sol_dpcm_decoder', type: 'feature', value: 'auto') ++option('xan_dpcm_decoder', type: 'feature', value: 'auto') ++option('wady_dpcm_decoder', type: 'feature', value: 'auto') ++option('adpcm_4xm_decoder', type: 'feature', value: 'auto') ++option('adpcm_adx_decoder', type: 'feature', value: 'auto') ++option('adpcm_afc_decoder', type: 'feature', value: 'auto') ++option('adpcm_agm_decoder', type: 'feature', value: 'auto') ++option('adpcm_aica_decoder', type: 'feature', value: 'auto') ++option('adpcm_argo_decoder', type: 'feature', value: 'auto') ++option('adpcm_ct_decoder', type: 'feature', value: 'auto') ++option('adpcm_dtk_decoder', type: 'feature', value: 'auto') ++option('adpcm_ea_decoder', type: 'feature', value: 'auto') ++option('adpcm_ea_maxis_xa_decoder', type: 'feature', value: 'auto') ++option('adpcm_ea_r1_decoder', type: 'feature', value: 'auto') ++option('adpcm_ea_r2_decoder', type: 'feature', value: 'auto') ++option('adpcm_ea_r3_decoder', type: 'feature', value: 'auto') ++option('adpcm_ea_xas_decoder', type: 'feature', value: 'auto') ++option('adpcm_g722_decoder', type: 'feature', value: 'auto') ++option('adpcm_g726_decoder', type: 'feature', value: 'auto') ++option('adpcm_g726le_decoder', type: 'feature', value: 'auto') ++option('adpcm_ima_acorn_decoder', type: 'feature', value: 'auto') ++option('adpcm_ima_amv_decoder', type: 'feature', value: 'auto') ++option('adpcm_ima_alp_decoder', type: 'feature', value: 'auto') ++option('adpcm_ima_apc_decoder', type: 'feature', value: 'auto') ++option('adpcm_ima_apm_decoder', type: 'feature', value: 'auto') ++option('adpcm_ima_cunning_decoder', type: 'feature', value: 'auto') ++option('adpcm_ima_dat4_decoder', type: 'feature', value: 'auto') ++option('adpcm_ima_dk3_decoder', type: 'feature', value: 'auto') ++option('adpcm_ima_dk4_decoder', type: 'feature', value: 'auto') ++option('adpcm_ima_ea_eacs_decoder', type: 'feature', value: 'auto') ++option('adpcm_ima_ea_sead_decoder', type: 'feature', value: 'auto') ++option('adpcm_ima_iss_decoder', type: 'feature', value: 'auto') ++option('adpcm_ima_moflex_decoder', type: 'feature', value: 'auto') ++option('adpcm_ima_mtf_decoder', type: 'feature', value: 'auto') ++option('adpcm_ima_oki_decoder', type: 'feature', value: 'auto') ++option('adpcm_ima_qt_decoder', type: 'feature', value: 'auto') ++option('adpcm_ima_rad_decoder', type: 'feature', value: 'auto') ++option('adpcm_ima_ssi_decoder', type: 'feature', value: 'auto') ++option('adpcm_ima_smjpeg_decoder', type: 'feature', value: 'auto') ++option('adpcm_ima_wav_decoder', type: 'feature', value: 'auto') ++option('adpcm_ima_ws_decoder', type: 'feature', value: 'auto') ++option('adpcm_ms_decoder', type: 'feature', value: 'auto') ++option('adpcm_mtaf_decoder', type: 'feature', value: 'auto') ++option('adpcm_psx_decoder', type: 'feature', value: 'auto') ++option('adpcm_sbpro_2_decoder', type: 'feature', value: 'auto') ++option('adpcm_sbpro_3_decoder', type: 'feature', value: 'auto') ++option('adpcm_sbpro_4_decoder', type: 'feature', value: 'auto') ++option('adpcm_swf_decoder', type: 'feature', value: 'auto') ++option('adpcm_thp_decoder', type: 'feature', value: 'auto') ++option('adpcm_thp_le_decoder', type: 'feature', value: 'auto') ++option('adpcm_vima_decoder', type: 'feature', value: 'auto') ++option('adpcm_xa_decoder', type: 'feature', value: 'auto') ++option('adpcm_xmd_decoder', type: 'feature', value: 'auto') ++option('adpcm_yamaha_decoder', type: 'feature', value: 'auto') ++option('adpcm_zork_decoder', type: 'feature', value: 'auto') ++option('ssa_decoder', type: 'feature', value: 'auto') ++option('ass_decoder', type: 'feature', value: 'auto') ++option('ccaption_decoder', type: 'feature', value: 'auto') ++option('dvbsub_decoder', type: 'feature', value: 'auto') ++option('dvdsub_decoder', type: 'feature', value: 'auto') ++option('jacosub_decoder', type: 'feature', value: 'auto') ++option('microdvd_decoder', type: 'feature', value: 'auto') ++option('movtext_decoder', type: 'feature', value: 'auto') ++option('mpl2_decoder', type: 'feature', value: 'auto') ++option('pgssub_decoder', type: 'feature', value: 'auto') ++option('pjs_decoder', type: 'feature', value: 'auto') ++option('realtext_decoder', type: 'feature', value: 'auto') ++option('sami_decoder', type: 'feature', value: 'auto') ++option('srt_decoder', type: 'feature', value: 'auto') ++option('stl_decoder', type: 'feature', value: 'auto') ++option('subrip_decoder', type: 'feature', value: 'auto') ++option('subviewer_decoder', type: 'feature', value: 'auto') ++option('subviewer1_decoder', type: 'feature', value: 'auto') ++option('text_decoder', type: 'feature', value: 'auto') ++option('vplayer_decoder', type: 'feature', value: 'auto') ++option('webvtt_decoder', type: 'feature', value: 'auto') ++option('xsub_decoder', type: 'feature', value: 'auto') ++option('aac_at_decoder', type: 'feature', value: 'auto') ++option('ac3_at_decoder', type: 'feature', value: 'auto') ++option('adpcm_ima_qt_at_decoder', type: 'feature', value: 'auto') ++option('alac_at_decoder', type: 'feature', value: 'auto') ++option('amr_nb_at_decoder', type: 'feature', value: 'auto') ++option('eac3_at_decoder', type: 'feature', value: 'auto') ++option('gsm_ms_at_decoder', type: 'feature', value: 'auto') ++option('ilbc_at_decoder', type: 'feature', value: 'auto') ++option('mp1_at_decoder', type: 'feature', value: 'auto') ++option('mp2_at_decoder', type: 'feature', value: 'auto') ++option('mp3_at_decoder', type: 'feature', value: 'auto') ++option('pcm_alaw_at_decoder', type: 'feature', value: 'auto') ++option('pcm_mulaw_at_decoder', type: 'feature', value: 'auto') ++option('qdmc_at_decoder', type: 'feature', value: 'auto') ++option('qdm2_at_decoder', type: 'feature', value: 'auto') ++option('libaribb24_decoder', type: 'feature', value: 'auto') ++option('libcelt_decoder', type: 'feature', value: 'auto') ++option('libcodec2_decoder', type: 'feature', value: 'auto') ++option('libdav1d_decoder', type: 'feature', value: 'auto') ++option('libdavs2_decoder', type: 'feature', value: 'auto') ++option('libfdk_aac_decoder', type: 'feature', value: 'auto') ++option('libgsm_decoder', type: 'feature', value: 'auto') ++option('libgsm_ms_decoder', type: 'feature', value: 'auto') ++option('libilbc_decoder', type: 'feature', value: 'auto') ++option('libjxl_decoder', type: 'feature', value: 'auto') ++option('libopencore_amrnb_decoder', type: 'feature', value: 'auto') ++option('libopencore_amrwb_decoder', type: 'feature', value: 'auto') ++option('libopenjpeg_decoder', type: 'feature', value: 'auto') ++option('libopus_decoder', type: 'feature', value: 'auto') ++option('librsvg_decoder', type: 'feature', value: 'auto') ++option('libspeex_decoder', type: 'feature', value: 'auto') ++option('libuavs3d_decoder', type: 'feature', value: 'auto') ++option('libvorbis_decoder', type: 'feature', value: 'auto') ++option('libvpx_vp8_decoder', type: 'feature', value: 'auto') ++option('libvpx_vp9_decoder', type: 'feature', value: 'auto') ++option('libzvbi_teletext_decoder', type: 'feature', value: 'auto') ++option('bintext_decoder', type: 'feature', value: 'auto') ++option('xbin_decoder', type: 'feature', value: 'auto') ++option('idf_decoder', type: 'feature', value: 'auto') ++option('libaom_av1_decoder', type: 'feature', value: 'auto') ++option('av1_decoder', type: 'feature', value: 'auto') ++option('av1_cuvid_decoder', type: 'feature', value: 'auto') ++option('av1_mediacodec_decoder', type: 'feature', value: 'auto') ++option('av1_qsv_decoder', type: 'feature', value: 'auto') ++option('libopenh264_decoder', type: 'feature', value: 'auto') ++option('h264_cuvid_decoder', type: 'feature', value: 'auto') ++option('hevc_cuvid_decoder', type: 'feature', value: 'auto') ++option('hevc_mediacodec_decoder', type: 'feature', value: 'auto') ++option('mjpeg_cuvid_decoder', type: 'feature', value: 'auto') ++option('mjpeg_qsv_decoder', type: 'feature', value: 'auto') ++option('mpeg1_cuvid_decoder', type: 'feature', value: 'auto') ++option('mpeg2_cuvid_decoder', type: 'feature', value: 'auto') ++option('mpeg4_cuvid_decoder', type: 'feature', value: 'auto') ++option('mpeg4_mediacodec_decoder', type: 'feature', value: 'auto') ++option('vc1_cuvid_decoder', type: 'feature', value: 'auto') ++option('vp8_cuvid_decoder', type: 'feature', value: 'auto') ++option('vp8_mediacodec_decoder', type: 'feature', value: 'auto') ++option('vp8_qsv_decoder', type: 'feature', value: 'auto') ++option('vp9_cuvid_decoder', type: 'feature', value: 'auto') ++option('vp9_mediacodec_decoder', type: 'feature', value: 'auto') ++option('vp9_qsv_decoder', type: 'feature', value: 'auto') ++option('vnull_decoder', type: 'feature', value: 'auto') ++option('anull_decoder', type: 'feature', value: 'auto') ++option('decoders', type: 'feature', value: 'auto', description: 'Enable or disable all decoders') ++ ++# Generated parser options ++option('aac_parser', type: 'feature', value: 'auto') ++option('aac_latm_parser', type: 'feature', value: 'auto') ++option('ac3_parser', type: 'feature', value: 'auto') ++option('adx_parser', type: 'feature', value: 'auto') ++option('amr_parser', type: 'feature', value: 'auto') ++option('av1_parser', type: 'feature', value: 'auto') ++option('avs2_parser', type: 'feature', value: 'auto') ++option('avs3_parser', type: 'feature', value: 'auto') ++option('bmp_parser', type: 'feature', value: 'auto') ++option('cavsvideo_parser', type: 'feature', value: 'auto') ++option('cook_parser', type: 'feature', value: 'auto') ++option('cri_parser', type: 'feature', value: 'auto') ++option('dca_parser', type: 'feature', value: 'auto') ++option('dirac_parser', type: 'feature', value: 'auto') ++option('dnxhd_parser', type: 'feature', value: 'auto') ++option('dolby_e_parser', type: 'feature', value: 'auto') ++option('dpx_parser', type: 'feature', value: 'auto') ++option('dvaudio_parser', type: 'feature', value: 'auto') ++option('dvbsub_parser', type: 'feature', value: 'auto') ++option('dvdsub_parser', type: 'feature', value: 'auto') ++option('dvd_nav_parser', type: 'feature', value: 'auto') ++option('flac_parser', type: 'feature', value: 'auto') ++option('ftr_parser', type: 'feature', value: 'auto') ++option('g723_1_parser', type: 'feature', value: 'auto') ++option('g729_parser', type: 'feature', value: 'auto') ++option('gif_parser', type: 'feature', value: 'auto') ++option('gsm_parser', type: 'feature', value: 'auto') ++option('h261_parser', type: 'feature', value: 'auto') ++option('h263_parser', type: 'feature', value: 'auto') ++option('h264_parser', type: 'feature', value: 'auto') ++option('hevc_parser', type: 'feature', value: 'auto') ++option('hdr_parser', type: 'feature', value: 'auto') ++option('ipu_parser', type: 'feature', value: 'auto') ++option('jpeg2000_parser', type: 'feature', value: 'auto') ++option('misc4_parser', type: 'feature', value: 'auto') ++option('mjpeg_parser', type: 'feature', value: 'auto') ++option('mlp_parser', type: 'feature', value: 'auto') ++option('mpeg4video_parser', type: 'feature', value: 'auto') ++option('mpegaudio_parser', type: 'feature', value: 'auto') ++option('mpegvideo_parser', type: 'feature', value: 'auto') ++option('opus_parser', type: 'feature', value: 'auto') ++option('png_parser', type: 'feature', value: 'auto') ++option('pnm_parser', type: 'feature', value: 'auto') ++option('qoi_parser', type: 'feature', value: 'auto') ++option('rv30_parser', type: 'feature', value: 'auto') ++option('rv40_parser', type: 'feature', value: 'auto') ++option('sbc_parser', type: 'feature', value: 'auto') ++option('sipr_parser', type: 'feature', value: 'auto') ++option('tak_parser', type: 'feature', value: 'auto') ++option('vc1_parser', type: 'feature', value: 'auto') ++option('vorbis_parser', type: 'feature', value: 'auto') ++option('vp3_parser', type: 'feature', value: 'auto') ++option('vp8_parser', type: 'feature', value: 'auto') ++option('vp9_parser', type: 'feature', value: 'auto') ++option('webp_parser', type: 'feature', value: 'auto') ++option('xbm_parser', type: 'feature', value: 'auto') ++option('xma_parser', type: 'feature', value: 'auto') ++option('xwd_parser', type: 'feature', value: 'auto') ++option('parsers', type: 'feature', value: 'auto', description: 'Enable or disable all parsers') ++ ++# Generated bsf options ++option('aac_adtstoasc_bsf', type: 'feature', value: 'auto') ++option('av1_frame_merge_bsf', type: 'feature', value: 'auto') ++option('av1_frame_split_bsf', type: 'feature', value: 'auto') ++option('av1_metadata_bsf', type: 'feature', value: 'auto') ++option('chomp_bsf', type: 'feature', value: 'auto') ++option('dump_extradata_bsf', type: 'feature', value: 'auto') ++option('dca_core_bsf', type: 'feature', value: 'auto') ++option('dts2pts_bsf', type: 'feature', value: 'auto') ++option('dv_error_marker_bsf', type: 'feature', value: 'auto') ++option('eac3_core_bsf', type: 'feature', value: 'auto') ++option('extract_extradata_bsf', type: 'feature', value: 'auto') ++option('filter_units_bsf', type: 'feature', value: 'auto') ++option('h264_metadata_bsf', type: 'feature', value: 'auto') ++option('h264_mp4toannexb_bsf', type: 'feature', value: 'auto') ++option('h264_redundant_pps_bsf', type: 'feature', value: 'auto') ++option('hapqa_extract_bsf', type: 'feature', value: 'auto') ++option('hevc_metadata_bsf', type: 'feature', value: 'auto') ++option('hevc_mp4toannexb_bsf', type: 'feature', value: 'auto') ++option('imx_dump_header_bsf', type: 'feature', value: 'auto') ++option('media100_to_mjpegb_bsf', type: 'feature', value: 'auto') ++option('mjpeg2jpeg_bsf', type: 'feature', value: 'auto') ++option('mjpega_dump_header_bsf', type: 'feature', value: 'auto') ++option('mp3_header_decompress_bsf', type: 'feature', value: 'auto') ++option('mpeg2_metadata_bsf', type: 'feature', value: 'auto') ++option('mpeg4_unpack_bframes_bsf', type: 'feature', value: 'auto') ++option('mov2textsub_bsf', type: 'feature', value: 'auto') ++option('noise_bsf', type: 'feature', value: 'auto') ++option('null_bsf', type: 'feature', value: 'enabled') ++option('opus_metadata_bsf', type: 'feature', value: 'auto') ++option('pcm_rechunk_bsf', type: 'feature', value: 'auto') ++option('pgs_frame_merge_bsf', type: 'feature', value: 'auto') ++option('prores_metadata_bsf', type: 'feature', value: 'auto') ++option('remove_extradata_bsf', type: 'feature', value: 'auto') ++option('setts_bsf', type: 'feature', value: 'auto') ++option('text2movsub_bsf', type: 'feature', value: 'auto') ++option('trace_headers_bsf', type: 'feature', value: 'auto') ++option('truehd_core_bsf', type: 'feature', value: 'auto') ++option('vp9_metadata_bsf', type: 'feature', value: 'auto') ++option('vp9_raw_reorder_bsf', type: 'feature', value: 'auto') ++option('vp9_superframe_bsf', type: 'feature', value: 'auto') ++option('vp9_superframe_split_bsf', type: 'feature', value: 'auto') ++option('bsfs', type: 'feature', value: 'auto', description: 'Enable or disable all bsfs') ++ ++# Generated hwaccel options ++option('av1_d3d11va_hwaccel', type: 'feature', value: 'auto') ++option('av1_d3d11va2_hwaccel', type: 'feature', value: 'auto') ++option('av1_dxva2_hwaccel', type: 'feature', value: 'auto') ++option('av1_nvdec_hwaccel', type: 'feature', value: 'auto') ++option('av1_vaapi_hwaccel', type: 'feature', value: 'auto') ++option('av1_vdpau_hwaccel', type: 'feature', value: 'auto') ++option('h263_vaapi_hwaccel', type: 'feature', value: 'auto') ++option('h263_videotoolbox_hwaccel', type: 'feature', value: 'auto') ++option('h264_d3d11va_hwaccel', type: 'feature', value: 'auto') ++option('h264_d3d11va2_hwaccel', type: 'feature', value: 'auto') ++option('h264_dxva2_hwaccel', type: 'feature', value: 'auto') ++option('h264_nvdec_hwaccel', type: 'feature', value: 'auto') ++option('h264_vaapi_hwaccel', type: 'feature', value: 'auto') ++option('h264_vdpau_hwaccel', type: 'feature', value: 'auto') ++option('h264_videotoolbox_hwaccel', type: 'feature', value: 'auto') ++option('hevc_d3d11va_hwaccel', type: 'feature', value: 'auto') ++option('hevc_d3d11va2_hwaccel', type: 'feature', value: 'auto') ++option('hevc_dxva2_hwaccel', type: 'feature', value: 'auto') ++option('hevc_nvdec_hwaccel', type: 'feature', value: 'auto') ++option('hevc_vaapi_hwaccel', type: 'feature', value: 'auto') ++option('hevc_vdpau_hwaccel', type: 'feature', value: 'auto') ++option('hevc_videotoolbox_hwaccel', type: 'feature', value: 'auto') ++option('mjpeg_nvdec_hwaccel', type: 'feature', value: 'auto') ++option('mjpeg_vaapi_hwaccel', type: 'feature', value: 'auto') ++option('mpeg1_nvdec_hwaccel', type: 'feature', value: 'auto') ++option('mpeg1_vdpau_hwaccel', type: 'feature', value: 'auto') ++option('mpeg1_videotoolbox_hwaccel', type: 'feature', value: 'auto') ++option('mpeg2_d3d11va_hwaccel', type: 'feature', value: 'auto') ++option('mpeg2_d3d11va2_hwaccel', type: 'feature', value: 'auto') ++option('mpeg2_nvdec_hwaccel', type: 'feature', value: 'auto') ++option('mpeg2_dxva2_hwaccel', type: 'feature', value: 'auto') ++option('mpeg2_vaapi_hwaccel', type: 'feature', value: 'auto') ++option('mpeg2_vdpau_hwaccel', type: 'feature', value: 'auto') ++option('mpeg2_videotoolbox_hwaccel', type: 'feature', value: 'auto') ++option('mpeg4_nvdec_hwaccel', type: 'feature', value: 'auto') ++option('mpeg4_vaapi_hwaccel', type: 'feature', value: 'auto') ++option('mpeg4_vdpau_hwaccel', type: 'feature', value: 'auto') ++option('mpeg4_videotoolbox_hwaccel', type: 'feature', value: 'auto') ++option('prores_videotoolbox_hwaccel', type: 'feature', value: 'auto') ++option('vc1_d3d11va_hwaccel', type: 'feature', value: 'auto') ++option('vc1_d3d11va2_hwaccel', type: 'feature', value: 'auto') ++option('vc1_dxva2_hwaccel', type: 'feature', value: 'auto') ++option('vc1_nvdec_hwaccel', type: 'feature', value: 'auto') ++option('vc1_vaapi_hwaccel', type: 'feature', value: 'auto') ++option('vc1_vdpau_hwaccel', type: 'feature', value: 'auto') ++option('vp8_nvdec_hwaccel', type: 'feature', value: 'auto') ++option('vp8_vaapi_hwaccel', type: 'feature', value: 'auto') ++option('vp9_d3d11va_hwaccel', type: 'feature', value: 'auto') ++option('vp9_d3d11va2_hwaccel', type: 'feature', value: 'auto') ++option('vp9_dxva2_hwaccel', type: 'feature', value: 'auto') ++option('vp9_nvdec_hwaccel', type: 'feature', value: 'auto') ++option('vp9_vaapi_hwaccel', type: 'feature', value: 'auto') ++option('vp9_vdpau_hwaccel', type: 'feature', value: 'auto') ++option('vp9_videotoolbox_hwaccel', type: 'feature', value: 'auto') ++option('wmv3_d3d11va_hwaccel', type: 'feature', value: 'auto') ++option('wmv3_d3d11va2_hwaccel', type: 'feature', value: 'auto') ++option('wmv3_dxva2_hwaccel', type: 'feature', value: 'auto') ++option('wmv3_nvdec_hwaccel', type: 'feature', value: 'auto') ++option('wmv3_vaapi_hwaccel', type: 'feature', value: 'auto') ++option('wmv3_vdpau_hwaccel', type: 'feature', value: 'auto') ++option('hwaccels', type: 'feature', value: 'auto', description: 'Enable or disable all hwaccels') ++ ++# Generated protocol options ++option('async_protocol', type: 'feature', value: 'auto') ++option('bluray_protocol', type: 'feature', value: 'auto') ++option('cache_protocol', type: 'feature', value: 'auto') ++option('concat_protocol', type: 'feature', value: 'auto') ++option('concatf_protocol', type: 'feature', value: 'auto') ++option('crypto_protocol', type: 'feature', value: 'auto') ++option('data_protocol', type: 'feature', value: 'auto') ++option('fd_protocol', type: 'feature', value: 'auto') ++option('ffrtmpcrypt_protocol', type: 'feature', value: 'auto') ++option('ffrtmphttp_protocol', type: 'feature', value: 'auto') ++option('file_protocol', type: 'feature', value: 'auto') ++option('ftp_protocol', type: 'feature', value: 'auto') ++option('gopher_protocol', type: 'feature', value: 'auto') ++option('gophers_protocol', type: 'feature', value: 'auto') ++option('hls_protocol', type: 'feature', value: 'auto') ++option('http_protocol', type: 'feature', value: 'auto') ++option('httpproxy_protocol', type: 'feature', value: 'auto') ++option('https_protocol', type: 'feature', value: 'auto') ++option('icecast_protocol', type: 'feature', value: 'auto') ++option('mmsh_protocol', type: 'feature', value: 'auto') ++option('mmst_protocol', type: 'feature', value: 'auto') ++option('md5_protocol', type: 'feature', value: 'auto') ++option('pipe_protocol', type: 'feature', value: 'auto') ++option('prompeg_protocol', type: 'feature', value: 'auto') ++option('rtmp_protocol', type: 'feature', value: 'auto') ++option('rtmpe_protocol', type: 'feature', value: 'auto') ++option('rtmps_protocol', type: 'feature', value: 'auto') ++option('rtmpt_protocol', type: 'feature', value: 'auto') ++option('rtmpte_protocol', type: 'feature', value: 'auto') ++option('rtmpts_protocol', type: 'feature', value: 'auto') ++option('rtp_protocol', type: 'feature', value: 'auto') ++option('sctp_protocol', type: 'feature', value: 'auto') ++option('srtp_protocol', type: 'feature', value: 'auto') ++option('subfile_protocol', type: 'feature', value: 'auto') ++option('tee_protocol', type: 'feature', value: 'auto') ++option('tcp_protocol', type: 'feature', value: 'auto') ++option('tls_protocol', type: 'feature', value: 'auto') ++option('udp_protocol', type: 'feature', value: 'auto') ++option('udplite_protocol', type: 'feature', value: 'auto') ++option('unix_protocol', type: 'feature', value: 'auto') ++option('libamqp_protocol', type: 'feature', value: 'auto') ++option('librist_protocol', type: 'feature', value: 'auto') ++option('librtmp_protocol', type: 'feature', value: 'auto') ++option('librtmpe_protocol', type: 'feature', value: 'auto') ++option('librtmps_protocol', type: 'feature', value: 'auto') ++option('librtmpt_protocol', type: 'feature', value: 'auto') ++option('librtmpte_protocol', type: 'feature', value: 'auto') ++option('libsrt_protocol', type: 'feature', value: 'auto') ++option('libssh_protocol', type: 'feature', value: 'auto') ++option('libsmbclient_protocol', type: 'feature', value: 'auto') ++option('libzmq_protocol', type: 'feature', value: 'auto') ++option('ipfs_gateway_protocol', type: 'feature', value: 'auto') ++option('ipns_gateway_protocol', type: 'feature', value: 'auto') ++option('protocols', type: 'feature', value: 'auto', description: 'Enable or disable all protocols') ++ ++# Generated outdev options ++option('alsa_outdev', type: 'feature', value: 'auto') ++option('audiotoolbox_outdev', type: 'feature', value: 'auto') ++option('caca_outdev', type: 'feature', value: 'auto') ++option('decklink_outdev', type: 'feature', value: 'auto') ++option('fbdev_outdev', type: 'feature', value: 'auto') ++option('opengl_outdev', type: 'feature', value: 'auto') ++option('oss_outdev', type: 'feature', value: 'auto') ++option('pulse_outdev', type: 'feature', value: 'auto') ++option('sdl2_outdev', type: 'feature', value: 'auto') ++option('sndio_outdev', type: 'feature', value: 'auto') ++option('v4l2_outdev', type: 'feature', value: 'auto') ++option('xv_outdev', type: 'feature', value: 'auto') ++option('outdevs', type: 'feature', value: 'auto', description: 'Enable or disable all outdevs') ++ ++# Generated indev options ++option('alsa_indev', type: 'feature', value: 'auto') ++option('android_camera_indev', type: 'feature', value: 'auto') ++option('avfoundation_indev', type: 'feature', value: 'auto') ++option('bktr_indev', type: 'feature', value: 'auto') ++option('decklink_indev', type: 'feature', value: 'auto') ++option('dshow_indev', type: 'feature', value: 'auto') ++option('fbdev_indev', type: 'feature', value: 'auto') ++option('gdigrab_indev', type: 'feature', value: 'auto') ++option('iec61883_indev', type: 'feature', value: 'auto') ++option('jack_indev', type: 'feature', value: 'auto') ++option('kmsgrab_indev', type: 'feature', value: 'auto') ++option('lavfi_indev', type: 'feature', value: 'auto') ++option('openal_indev', type: 'feature', value: 'auto') ++option('oss_indev', type: 'feature', value: 'auto') ++option('pulse_indev', type: 'feature', value: 'auto') ++option('sndio_indev', type: 'feature', value: 'auto') ++option('v4l2_indev', type: 'feature', value: 'auto') ++option('vfwcap_indev', type: 'feature', value: 'auto') ++option('xcbgrab_indev', type: 'feature', value: 'auto') ++option('libcdio_indev', type: 'feature', value: 'auto') ++option('libdc1394_indev', type: 'feature', value: 'auto') ++option('indevs', type: 'feature', value: 'auto', description: 'Enable or disable all indevs') ++ ++#### --- END GENERATED EXTERN OPTIONS --- #### ++ ++#### --- GENERATED FILTER OPTIONS --- #### ++option('abench_filter', type: 'feature', value: 'auto') ++option('acompressor_filter', type: 'feature', value: 'auto') ++option('acontrast_filter', type: 'feature', value: 'auto') ++option('acopy_filter', type: 'feature', value: 'auto') ++option('acue_filter', type: 'feature', value: 'auto') ++option('acrossfade_filter', type: 'feature', value: 'auto') ++option('acrossover_filter', type: 'feature', value: 'auto') ++option('acrusher_filter', type: 'feature', value: 'auto') ++option('adeclick_filter', type: 'feature', value: 'auto') ++option('adeclip_filter', type: 'feature', value: 'auto') ++option('adecorrelate_filter', type: 'feature', value: 'auto') ++option('adelay_filter', type: 'feature', value: 'auto') ++option('adenorm_filter', type: 'feature', value: 'auto') ++option('aderivative_filter', type: 'feature', value: 'auto') ++option('adrc_filter', type: 'feature', value: 'auto') ++option('adynamicequalizer_filter', type: 'feature', value: 'auto') ++option('adynamicsmooth_filter', type: 'feature', value: 'auto') ++option('aecho_filter', type: 'feature', value: 'auto') ++option('aemphasis_filter', type: 'feature', value: 'auto') ++option('aeval_filter', type: 'feature', value: 'auto') ++option('aexciter_filter', type: 'feature', value: 'auto') ++option('afade_filter', type: 'feature', value: 'auto') ++option('afftdn_filter', type: 'feature', value: 'auto') ++option('afftfilt_filter', type: 'feature', value: 'auto') ++option('afir_filter', type: 'feature', value: 'auto') ++option('aformat_filter', type: 'feature', value: 'auto') ++option('afreqshift_filter', type: 'feature', value: 'auto') ++option('afwtdn_filter', type: 'feature', value: 'auto') ++option('agate_filter', type: 'feature', value: 'auto') ++option('aiir_filter', type: 'feature', value: 'auto') ++option('aintegral_filter', type: 'feature', value: 'auto') ++option('ainterleave_filter', type: 'feature', value: 'auto') ++option('alatency_filter', type: 'feature', value: 'auto') ++option('alimiter_filter', type: 'feature', value: 'auto') ++option('allpass_filter', type: 'feature', value: 'auto') ++option('aloop_filter', type: 'feature', value: 'auto') ++option('amerge_filter', type: 'feature', value: 'auto') ++option('ametadata_filter', type: 'feature', value: 'auto') ++option('amix_filter', type: 'feature', value: 'auto') ++option('amultiply_filter', type: 'feature', value: 'auto') ++option('anequalizer_filter', type: 'feature', value: 'auto') ++option('anlmdn_filter', type: 'feature', value: 'auto') ++option('anlmf_filter', type: 'feature', value: 'auto') ++option('anlms_filter', type: 'feature', value: 'auto') ++option('anull_filter', type: 'feature', value: 'auto') ++option('apad_filter', type: 'feature', value: 'auto') ++option('aperms_filter', type: 'feature', value: 'auto') ++option('aphaser_filter', type: 'feature', value: 'auto') ++option('aphaseshift_filter', type: 'feature', value: 'auto') ++option('apsyclip_filter', type: 'feature', value: 'auto') ++option('apulsator_filter', type: 'feature', value: 'auto') ++option('arealtime_filter', type: 'feature', value: 'auto') ++option('aresample_filter', type: 'feature', value: 'auto') ++option('areverse_filter', type: 'feature', value: 'auto') ++option('arnndn_filter', type: 'feature', value: 'auto') ++option('asdr_filter', type: 'feature', value: 'auto') ++option('asegment_filter', type: 'feature', value: 'auto') ++option('aselect_filter', type: 'feature', value: 'auto') ++option('asendcmd_filter', type: 'feature', value: 'auto') ++option('asetnsamples_filter', type: 'feature', value: 'auto') ++option('asetpts_filter', type: 'feature', value: 'auto') ++option('asetrate_filter', type: 'feature', value: 'auto') ++option('asettb_filter', type: 'feature', value: 'auto') ++option('ashowinfo_filter', type: 'feature', value: 'auto') ++option('asidedata_filter', type: 'feature', value: 'auto') ++option('asoftclip_filter', type: 'feature', value: 'auto') ++option('aspectralstats_filter', type: 'feature', value: 'auto') ++option('asplit_filter', type: 'feature', value: 'auto') ++option('asr_filter', type: 'feature', value: 'auto') ++option('astats_filter', type: 'feature', value: 'auto') ++option('astreamselect_filter', type: 'feature', value: 'auto') ++option('asubboost_filter', type: 'feature', value: 'auto') ++option('asubcut_filter', type: 'feature', value: 'auto') ++option('asupercut_filter', type: 'feature', value: 'auto') ++option('asuperpass_filter', type: 'feature', value: 'auto') ++option('asuperstop_filter', type: 'feature', value: 'auto') ++option('atempo_filter', type: 'feature', value: 'auto') ++option('atilt_filter', type: 'feature', value: 'auto') ++option('atrim_filter', type: 'feature', value: 'auto') ++option('axcorrelate_filter', type: 'feature', value: 'auto') ++option('azmq_filter', type: 'feature', value: 'auto') ++option('bandpass_filter', type: 'feature', value: 'auto') ++option('bandreject_filter', type: 'feature', value: 'auto') ++option('bass_filter', type: 'feature', value: 'auto') ++option('biquad_filter', type: 'feature', value: 'auto') ++option('bs2b_filter', type: 'feature', value: 'auto') ++option('channelmap_filter', type: 'feature', value: 'auto') ++option('channelsplit_filter', type: 'feature', value: 'auto') ++option('chorus_filter', type: 'feature', value: 'auto') ++option('compand_filter', type: 'feature', value: 'auto') ++option('compensationdelay_filter', type: 'feature', value: 'auto') ++option('crossfeed_filter', type: 'feature', value: 'auto') ++option('crystalizer_filter', type: 'feature', value: 'auto') ++option('dcshift_filter', type: 'feature', value: 'auto') ++option('deesser_filter', type: 'feature', value: 'auto') ++option('dialoguenhance_filter', type: 'feature', value: 'auto') ++option('drmeter_filter', type: 'feature', value: 'auto') ++option('dynaudnorm_filter', type: 'feature', value: 'auto') ++option('earwax_filter', type: 'feature', value: 'auto') ++option('ebur128_filter', type: 'feature', value: 'auto') ++option('equalizer_filter', type: 'feature', value: 'auto') ++option('extrastereo_filter', type: 'feature', value: 'auto') ++option('firequalizer_filter', type: 'feature', value: 'auto') ++option('flanger_filter', type: 'feature', value: 'auto') ++option('haas_filter', type: 'feature', value: 'auto') ++option('hdcd_filter', type: 'feature', value: 'auto') ++option('headphone_filter', type: 'feature', value: 'auto') ++option('highpass_filter', type: 'feature', value: 'auto') ++option('highshelf_filter', type: 'feature', value: 'auto') ++option('join_filter', type: 'feature', value: 'auto') ++option('ladspa_filter', type: 'feature', value: 'auto') ++option('loudnorm_filter', type: 'feature', value: 'auto') ++option('lowpass_filter', type: 'feature', value: 'auto') ++option('lowshelf_filter', type: 'feature', value: 'auto') ++option('lv2_filter', type: 'feature', value: 'auto') ++option('mcompand_filter', type: 'feature', value: 'auto') ++option('pan_filter', type: 'feature', value: 'auto') ++option('replaygain_filter', type: 'feature', value: 'auto') ++option('rubberband_filter', type: 'feature', value: 'auto') ++option('sidechaincompress_filter', type: 'feature', value: 'auto') ++option('sidechaingate_filter', type: 'feature', value: 'auto') ++option('silencedetect_filter', type: 'feature', value: 'auto') ++option('silenceremove_filter', type: 'feature', value: 'auto') ++option('sofalizer_filter', type: 'feature', value: 'auto') ++option('speechnorm_filter', type: 'feature', value: 'auto') ++option('stereotools_filter', type: 'feature', value: 'auto') ++option('stereowiden_filter', type: 'feature', value: 'auto') ++option('superequalizer_filter', type: 'feature', value: 'auto') ++option('surround_filter', type: 'feature', value: 'auto') ++option('tiltshelf_filter', type: 'feature', value: 'auto') ++option('treble_filter', type: 'feature', value: 'auto') ++option('tremolo_filter', type: 'feature', value: 'auto') ++option('vibrato_filter', type: 'feature', value: 'auto') ++option('virtualbass_filter', type: 'feature', value: 'auto') ++option('volume_filter', type: 'feature', value: 'auto') ++option('volumedetect_filter', type: 'feature', value: 'auto') ++option('aevalsrc_filter', type: 'feature', value: 'auto') ++option('afdelaysrc_filter', type: 'feature', value: 'auto') ++option('afirsrc_filter', type: 'feature', value: 'auto') ++option('anoisesrc_filter', type: 'feature', value: 'auto') ++option('anullsrc_filter', type: 'feature', value: 'auto') ++option('flite_filter', type: 'feature', value: 'auto') ++option('hilbert_filter', type: 'feature', value: 'auto') ++option('sinc_filter', type: 'feature', value: 'auto') ++option('sine_filter', type: 'feature', value: 'auto') ++option('anullsink_filter', type: 'feature', value: 'auto') ++option('addroi_filter', type: 'feature', value: 'auto') ++option('alphaextract_filter', type: 'feature', value: 'auto') ++option('alphamerge_filter', type: 'feature', value: 'auto') ++option('amplify_filter', type: 'feature', value: 'auto') ++option('ass_filter', type: 'feature', value: 'auto') ++option('atadenoise_filter', type: 'feature', value: 'auto') ++option('avgblur_filter', type: 'feature', value: 'auto') ++option('avgblur_opencl_filter', type: 'feature', value: 'auto') ++option('avgblur_vulkan_filter', type: 'feature', value: 'auto') ++option('backgroundkey_filter', type: 'feature', value: 'auto') ++option('bbox_filter', type: 'feature', value: 'auto') ++option('bench_filter', type: 'feature', value: 'auto') ++option('bilateral_filter', type: 'feature', value: 'auto') ++option('bilateral_cuda_filter', type: 'feature', value: 'auto') ++option('bitplanenoise_filter', type: 'feature', value: 'auto') ++option('blackdetect_filter', type: 'feature', value: 'auto') ++option('blackframe_filter', type: 'feature', value: 'auto') ++option('blend_filter', type: 'feature', value: 'auto') ++option('blend_vulkan_filter', type: 'feature', value: 'auto') ++option('blockdetect_filter', type: 'feature', value: 'auto') ++option('blurdetect_filter', type: 'feature', value: 'auto') ++option('bm3d_filter', type: 'feature', value: 'auto') ++option('boxblur_filter', type: 'feature', value: 'auto') ++option('boxblur_opencl_filter', type: 'feature', value: 'auto') ++option('bwdif_filter', type: 'feature', value: 'auto') ++option('cas_filter', type: 'feature', value: 'auto') ++option('chromaber_vulkan_filter', type: 'feature', value: 'auto') ++option('chromahold_filter', type: 'feature', value: 'auto') ++option('chromakey_filter', type: 'feature', value: 'auto') ++option('chromakey_cuda_filter', type: 'feature', value: 'auto') ++option('chromanr_filter', type: 'feature', value: 'auto') ++option('chromashift_filter', type: 'feature', value: 'auto') ++option('ciescope_filter', type: 'feature', value: 'auto') ++option('codecview_filter', type: 'feature', value: 'auto') ++option('colorbalance_filter', type: 'feature', value: 'auto') ++option('colorchannelmixer_filter', type: 'feature', value: 'auto') ++option('colorcontrast_filter', type: 'feature', value: 'auto') ++option('colorcorrect_filter', type: 'feature', value: 'auto') ++option('colorize_filter', type: 'feature', value: 'auto') ++option('colorkey_filter', type: 'feature', value: 'auto') ++option('colorkey_opencl_filter', type: 'feature', value: 'auto') ++option('colorhold_filter', type: 'feature', value: 'auto') ++option('colorlevels_filter', type: 'feature', value: 'auto') ++option('colormap_filter', type: 'feature', value: 'auto') ++option('colormatrix_filter', type: 'feature', value: 'auto') ++option('colorspace_filter', type: 'feature', value: 'auto') ++option('colorspace_cuda_filter', type: 'feature', value: 'auto') ++option('colortemperature_filter', type: 'feature', value: 'auto') ++option('convolution_filter', type: 'feature', value: 'auto') ++option('convolution_opencl_filter', type: 'feature', value: 'auto') ++option('convolve_filter', type: 'feature', value: 'auto') ++option('copy_filter', type: 'feature', value: 'auto') ++option('coreimage_filter', type: 'feature', value: 'auto') ++option('corr_filter', type: 'feature', value: 'auto') ++option('cover_rect_filter', type: 'feature', value: 'auto') ++option('crop_filter', type: 'feature', value: 'auto') ++option('cropdetect_filter', type: 'feature', value: 'auto') ++option('cue_filter', type: 'feature', value: 'auto') ++option('curves_filter', type: 'feature', value: 'auto') ++option('datascope_filter', type: 'feature', value: 'auto') ++option('dblur_filter', type: 'feature', value: 'auto') ++option('dctdnoiz_filter', type: 'feature', value: 'auto') ++option('deband_filter', type: 'feature', value: 'auto') ++option('deblock_filter', type: 'feature', value: 'auto') ++option('decimate_filter', type: 'feature', value: 'auto') ++option('deconvolve_filter', type: 'feature', value: 'auto') ++option('dedot_filter', type: 'feature', value: 'auto') ++option('deflate_filter', type: 'feature', value: 'auto') ++option('deflicker_filter', type: 'feature', value: 'auto') ++option('deinterlace_qsv_filter', type: 'feature', value: 'auto') ++option('deinterlace_vaapi_filter', type: 'feature', value: 'auto') ++option('dejudder_filter', type: 'feature', value: 'auto') ++option('delogo_filter', type: 'feature', value: 'auto') ++option('denoise_vaapi_filter', type: 'feature', value: 'auto') ++option('derain_filter', type: 'feature', value: 'auto') ++option('deshake_filter', type: 'feature', value: 'auto') ++option('deshake_opencl_filter', type: 'feature', value: 'auto') ++option('despill_filter', type: 'feature', value: 'auto') ++option('detelecine_filter', type: 'feature', value: 'auto') ++option('dilation_filter', type: 'feature', value: 'auto') ++option('dilation_opencl_filter', type: 'feature', value: 'auto') ++option('displace_filter', type: 'feature', value: 'auto') ++option('dnn_classify_filter', type: 'feature', value: 'auto') ++option('dnn_detect_filter', type: 'feature', value: 'auto') ++option('dnn_processing_filter', type: 'feature', value: 'auto') ++option('doubleweave_filter', type: 'feature', value: 'auto') ++option('drawbox_filter', type: 'feature', value: 'auto') ++option('drawgraph_filter', type: 'feature', value: 'auto') ++option('drawgrid_filter', type: 'feature', value: 'auto') ++option('drawtext_filter', type: 'feature', value: 'auto') ++option('edgedetect_filter', type: 'feature', value: 'auto') ++option('elbg_filter', type: 'feature', value: 'auto') ++option('entropy_filter', type: 'feature', value: 'auto') ++option('epx_filter', type: 'feature', value: 'auto') ++option('eq_filter', type: 'feature', value: 'auto') ++option('erosion_filter', type: 'feature', value: 'auto') ++option('erosion_opencl_filter', type: 'feature', value: 'auto') ++option('estdif_filter', type: 'feature', value: 'auto') ++option('exposure_filter', type: 'feature', value: 'auto') ++option('extractplanes_filter', type: 'feature', value: 'auto') ++option('fade_filter', type: 'feature', value: 'auto') ++option('feedback_filter', type: 'feature', value: 'auto') ++option('fftdnoiz_filter', type: 'feature', value: 'auto') ++option('fftfilt_filter', type: 'feature', value: 'auto') ++option('field_filter', type: 'feature', value: 'auto') ++option('fieldhint_filter', type: 'feature', value: 'auto') ++option('fieldmatch_filter', type: 'feature', value: 'auto') ++option('fieldorder_filter', type: 'feature', value: 'auto') ++option('fillborders_filter', type: 'feature', value: 'auto') ++option('find_rect_filter', type: 'feature', value: 'auto') ++option('flip_vulkan_filter', type: 'feature', value: 'auto') ++option('floodfill_filter', type: 'feature', value: 'auto') ++option('format_filter', type: 'feature', value: 'auto') ++option('fps_filter', type: 'feature', value: 'auto') ++option('framepack_filter', type: 'feature', value: 'auto') ++option('framerate_filter', type: 'feature', value: 'auto') ++option('framestep_filter', type: 'feature', value: 'auto') ++option('freezedetect_filter', type: 'feature', value: 'auto') ++option('freezeframes_filter', type: 'feature', value: 'auto') ++option('frei0r_filter', type: 'feature', value: 'auto') ++option('fspp_filter', type: 'feature', value: 'auto') ++option('gblur_filter', type: 'feature', value: 'auto') ++option('gblur_vulkan_filter', type: 'feature', value: 'auto') ++option('geq_filter', type: 'feature', value: 'auto') ++option('gradfun_filter', type: 'feature', value: 'auto') ++option('graphmonitor_filter', type: 'feature', value: 'auto') ++option('grayworld_filter', type: 'feature', value: 'auto') ++option('greyedge_filter', type: 'feature', value: 'auto') ++option('guided_filter', type: 'feature', value: 'auto') ++option('haldclut_filter', type: 'feature', value: 'auto') ++option('hflip_filter', type: 'feature', value: 'auto') ++option('hflip_vulkan_filter', type: 'feature', value: 'auto') ++option('histeq_filter', type: 'feature', value: 'auto') ++option('histogram_filter', type: 'feature', value: 'auto') ++option('hqdn3d_filter', type: 'feature', value: 'auto') ++option('hqx_filter', type: 'feature', value: 'auto') ++option('hstack_filter', type: 'feature', value: 'auto') ++option('hsvhold_filter', type: 'feature', value: 'auto') ++option('hsvkey_filter', type: 'feature', value: 'auto') ++option('hue_filter', type: 'feature', value: 'auto') ++option('huesaturation_filter', type: 'feature', value: 'auto') ++option('hwdownload_filter', type: 'feature', value: 'auto') ++option('hwmap_filter', type: 'feature', value: 'auto') ++option('hwupload_filter', type: 'feature', value: 'auto') ++option('hwupload_cuda_filter', type: 'feature', value: 'auto') ++option('hysteresis_filter', type: 'feature', value: 'auto') ++option('iccdetect_filter', type: 'feature', value: 'auto') ++option('iccgen_filter', type: 'feature', value: 'auto') ++option('identity_filter', type: 'feature', value: 'auto') ++option('idet_filter', type: 'feature', value: 'auto') ++option('il_filter', type: 'feature', value: 'auto') ++option('inflate_filter', type: 'feature', value: 'auto') ++option('interlace_filter', type: 'feature', value: 'auto') ++option('interleave_filter', type: 'feature', value: 'auto') ++option('kerndeint_filter', type: 'feature', value: 'auto') ++option('kirsch_filter', type: 'feature', value: 'auto') ++option('lagfun_filter', type: 'feature', value: 'auto') ++option('latency_filter', type: 'feature', value: 'auto') ++option('lenscorrection_filter', type: 'feature', value: 'auto') ++option('lensfun_filter', type: 'feature', value: 'auto') ++option('libplacebo_filter', type: 'feature', value: 'auto') ++option('libvmaf_filter', type: 'feature', value: 'auto') ++option('limitdiff_filter', type: 'feature', value: 'auto') ++option('limiter_filter', type: 'feature', value: 'auto') ++option('loop_filter', type: 'feature', value: 'auto') ++option('lumakey_filter', type: 'feature', value: 'auto') ++option('lut_filter', type: 'feature', value: 'auto') ++option('lut1d_filter', type: 'feature', value: 'auto') ++option('lut2_filter', type: 'feature', value: 'auto') ++option('lut3d_filter', type: 'feature', value: 'auto') ++option('lutrgb_filter', type: 'feature', value: 'auto') ++option('lutyuv_filter', type: 'feature', value: 'auto') ++option('maskedclamp_filter', type: 'feature', value: 'auto') ++option('maskedmax_filter', type: 'feature', value: 'auto') ++option('maskedmerge_filter', type: 'feature', value: 'auto') ++option('maskedmin_filter', type: 'feature', value: 'auto') ++option('maskedthreshold_filter', type: 'feature', value: 'auto') ++option('maskfun_filter', type: 'feature', value: 'auto') ++option('mcdeint_filter', type: 'feature', value: 'auto') ++option('median_filter', type: 'feature', value: 'auto') ++option('mergeplanes_filter', type: 'feature', value: 'auto') ++option('mestimate_filter', type: 'feature', value: 'auto') ++option('metadata_filter', type: 'feature', value: 'auto') ++option('midequalizer_filter', type: 'feature', value: 'auto') ++option('minterpolate_filter', type: 'feature', value: 'auto') ++option('mix_filter', type: 'feature', value: 'auto') ++option('monochrome_filter', type: 'feature', value: 'auto') ++option('morpho_filter', type: 'feature', value: 'auto') ++option('mpdecimate_filter', type: 'feature', value: 'auto') ++option('msad_filter', type: 'feature', value: 'auto') ++option('multiply_filter', type: 'feature', value: 'auto') ++option('negate_filter', type: 'feature', value: 'auto') ++option('nlmeans_filter', type: 'feature', value: 'auto') ++option('nlmeans_opencl_filter', type: 'feature', value: 'auto') ++option('nnedi_filter', type: 'feature', value: 'auto') ++option('noformat_filter', type: 'feature', value: 'auto') ++option('noise_filter', type: 'feature', value: 'auto') ++option('normalize_filter', type: 'feature', value: 'auto') ++option('null_filter', type: 'feature', value: 'enabled') ++option('ocr_filter', type: 'feature', value: 'auto') ++option('ocv_filter', type: 'feature', value: 'auto') ++option('oscilloscope_filter', type: 'feature', value: 'auto') ++option('overlay_filter', type: 'feature', value: 'auto') ++option('overlay_opencl_filter', type: 'feature', value: 'auto') ++option('overlay_qsv_filter', type: 'feature', value: 'auto') ++option('overlay_vaapi_filter', type: 'feature', value: 'auto') ++option('overlay_vulkan_filter', type: 'feature', value: 'auto') ++option('overlay_cuda_filter', type: 'feature', value: 'auto') ++option('owdenoise_filter', type: 'feature', value: 'auto') ++option('pad_filter', type: 'feature', value: 'auto') ++option('pad_opencl_filter', type: 'feature', value: 'auto') ++option('palettegen_filter', type: 'feature', value: 'auto') ++option('paletteuse_filter', type: 'feature', value: 'auto') ++option('perms_filter', type: 'feature', value: 'auto') ++option('perspective_filter', type: 'feature', value: 'auto') ++option('phase_filter', type: 'feature', value: 'auto') ++option('photosensitivity_filter', type: 'feature', value: 'auto') ++option('pixdesctest_filter', type: 'feature', value: 'auto') ++option('pixelize_filter', type: 'feature', value: 'auto') ++option('pixscope_filter', type: 'feature', value: 'auto') ++option('pp_filter', type: 'feature', value: 'auto') ++option('pp7_filter', type: 'feature', value: 'auto') ++option('premultiply_filter', type: 'feature', value: 'auto') ++option('prewitt_filter', type: 'feature', value: 'auto') ++option('prewitt_opencl_filter', type: 'feature', value: 'auto') ++option('procamp_vaapi_filter', type: 'feature', value: 'auto') ++option('program_opencl_filter', type: 'feature', value: 'auto') ++option('pseudocolor_filter', type: 'feature', value: 'auto') ++option('psnr_filter', type: 'feature', value: 'auto') ++option('pullup_filter', type: 'feature', value: 'auto') ++option('qp_filter', type: 'feature', value: 'auto') ++option('random_filter', type: 'feature', value: 'auto') ++option('readeia608_filter', type: 'feature', value: 'auto') ++option('readvitc_filter', type: 'feature', value: 'auto') ++option('realtime_filter', type: 'feature', value: 'auto') ++option('remap_filter', type: 'feature', value: 'auto') ++option('remap_opencl_filter', type: 'feature', value: 'auto') ++option('removegrain_filter', type: 'feature', value: 'auto') ++option('removelogo_filter', type: 'feature', value: 'auto') ++option('repeatfields_filter', type: 'feature', value: 'auto') ++option('reverse_filter', type: 'feature', value: 'auto') ++option('rgbashift_filter', type: 'feature', value: 'auto') ++option('roberts_filter', type: 'feature', value: 'auto') ++option('roberts_opencl_filter', type: 'feature', value: 'auto') ++option('rotate_filter', type: 'feature', value: 'auto') ++option('sab_filter', type: 'feature', value: 'auto') ++option('scale_filter', type: 'feature', value: 'auto') ++option('scale_cuda_filter', type: 'feature', value: 'auto') ++option('scale_npp_filter', type: 'feature', value: 'auto') ++option('scale_qsv_filter', type: 'feature', value: 'auto') ++option('scale_vaapi_filter', type: 'feature', value: 'auto') ++option('scale_vulkan_filter', type: 'feature', value: 'auto') ++option('scale2ref_filter', type: 'feature', value: 'auto') ++option('scale2ref_npp_filter', type: 'feature', value: 'auto') ++option('scdet_filter', type: 'feature', value: 'auto') ++option('scharr_filter', type: 'feature', value: 'auto') ++option('scroll_filter', type: 'feature', value: 'auto') ++option('segment_filter', type: 'feature', value: 'auto') ++option('select_filter', type: 'feature', value: 'auto') ++option('selectivecolor_filter', type: 'feature', value: 'auto') ++option('sendcmd_filter', type: 'feature', value: 'auto') ++option('separatefields_filter', type: 'feature', value: 'auto') ++option('setdar_filter', type: 'feature', value: 'auto') ++option('setfield_filter', type: 'feature', value: 'auto') ++option('setparams_filter', type: 'feature', value: 'auto') ++option('setpts_filter', type: 'feature', value: 'auto') ++option('setrange_filter', type: 'feature', value: 'auto') ++option('setsar_filter', type: 'feature', value: 'auto') ++option('settb_filter', type: 'feature', value: 'auto') ++option('sharpen_npp_filter', type: 'feature', value: 'auto') ++option('sharpness_vaapi_filter', type: 'feature', value: 'auto') ++option('shear_filter', type: 'feature', value: 'auto') ++option('showinfo_filter', type: 'feature', value: 'auto') ++option('showpalette_filter', type: 'feature', value: 'auto') ++option('shuffleframes_filter', type: 'feature', value: 'auto') ++option('shufflepixels_filter', type: 'feature', value: 'auto') ++option('shuffleplanes_filter', type: 'feature', value: 'auto') ++option('sidedata_filter', type: 'feature', value: 'auto') ++option('signalstats_filter', type: 'feature', value: 'auto') ++option('signature_filter', type: 'feature', value: 'auto') ++option('siti_filter', type: 'feature', value: 'auto') ++option('smartblur_filter', type: 'feature', value: 'auto') ++option('sobel_filter', type: 'feature', value: 'auto') ++option('sobel_opencl_filter', type: 'feature', value: 'auto') ++option('split_filter', type: 'feature', value: 'auto') ++option('spp_filter', type: 'feature', value: 'auto') ++option('sr_filter', type: 'feature', value: 'auto') ++option('ssim_filter', type: 'feature', value: 'auto') ++option('ssim360_filter', type: 'feature', value: 'auto') ++option('stereo3d_filter', type: 'feature', value: 'auto') ++option('streamselect_filter', type: 'feature', value: 'auto') ++option('subtitles_filter', type: 'feature', value: 'auto') ++option('super2xsai_filter', type: 'feature', value: 'auto') ++option('swaprect_filter', type: 'feature', value: 'auto') ++option('swapuv_filter', type: 'feature', value: 'auto') ++option('tblend_filter', type: 'feature', value: 'auto') ++option('telecine_filter', type: 'feature', value: 'auto') ++option('thistogram_filter', type: 'feature', value: 'auto') ++option('threshold_filter', type: 'feature', value: 'auto') ++option('thumbnail_filter', type: 'feature', value: 'auto') ++option('thumbnail_cuda_filter', type: 'feature', value: 'auto') ++option('tile_filter', type: 'feature', value: 'auto') ++option('tinterlace_filter', type: 'feature', value: 'auto') ++option('tlut2_filter', type: 'feature', value: 'auto') ++option('tmedian_filter', type: 'feature', value: 'auto') ++option('tmidequalizer_filter', type: 'feature', value: 'auto') ++option('tmix_filter', type: 'feature', value: 'auto') ++option('tonemap_filter', type: 'feature', value: 'auto') ++option('tonemap_opencl_filter', type: 'feature', value: 'auto') ++option('tonemap_vaapi_filter', type: 'feature', value: 'auto') ++option('tpad_filter', type: 'feature', value: 'auto') ++option('transpose_filter', type: 'feature', value: 'auto') ++option('transpose_npp_filter', type: 'feature', value: 'auto') ++option('transpose_opencl_filter', type: 'feature', value: 'auto') ++option('transpose_vaapi_filter', type: 'feature', value: 'auto') ++option('transpose_vulkan_filter', type: 'feature', value: 'auto') ++option('trim_filter', type: 'feature', value: 'auto') ++option('unpremultiply_filter', type: 'feature', value: 'auto') ++option('unsharp_filter', type: 'feature', value: 'auto') ++option('unsharp_opencl_filter', type: 'feature', value: 'auto') ++option('untile_filter', type: 'feature', value: 'auto') ++option('uspp_filter', type: 'feature', value: 'auto') ++option('v360_filter', type: 'feature', value: 'auto') ++option('vaguedenoiser_filter', type: 'feature', value: 'auto') ++option('varblur_filter', type: 'feature', value: 'auto') ++option('vectorscope_filter', type: 'feature', value: 'auto') ++option('vflip_filter', type: 'feature', value: 'auto') ++option('vflip_vulkan_filter', type: 'feature', value: 'auto') ++option('vfrdet_filter', type: 'feature', value: 'auto') ++option('vibrance_filter', type: 'feature', value: 'auto') ++option('vidstabdetect_filter', type: 'feature', value: 'auto') ++option('vidstabtransform_filter', type: 'feature', value: 'auto') ++option('vif_filter', type: 'feature', value: 'auto') ++option('vignette_filter', type: 'feature', value: 'auto') ++option('vmafmotion_filter', type: 'feature', value: 'auto') ++option('vpp_qsv_filter', type: 'feature', value: 'auto') ++option('vstack_filter', type: 'feature', value: 'auto') ++option('w3fdif_filter', type: 'feature', value: 'auto') ++option('waveform_filter', type: 'feature', value: 'auto') ++option('weave_filter', type: 'feature', value: 'auto') ++option('xbr_filter', type: 'feature', value: 'auto') ++option('xcorrelate_filter', type: 'feature', value: 'auto') ++option('xfade_filter', type: 'feature', value: 'auto') ++option('xfade_opencl_filter', type: 'feature', value: 'auto') ++option('xmedian_filter', type: 'feature', value: 'auto') ++option('xstack_filter', type: 'feature', value: 'auto') ++option('yadif_filter', type: 'feature', value: 'auto') ++option('yadif_cuda_filter', type: 'feature', value: 'auto') ++option('yadif_videotoolbox_filter', type: 'feature', value: 'auto') ++option('yaepblur_filter', type: 'feature', value: 'auto') ++option('zmq_filter', type: 'feature', value: 'auto') ++option('zoompan_filter', type: 'feature', value: 'auto') ++option('zscale_filter', type: 'feature', value: 'auto') ++option('hstack_vaapi_filter', type: 'feature', value: 'auto') ++option('vstack_vaapi_filter', type: 'feature', value: 'auto') ++option('xstack_vaapi_filter', type: 'feature', value: 'auto') ++option('hstack_qsv_filter', type: 'feature', value: 'auto') ++option('vstack_qsv_filter', type: 'feature', value: 'auto') ++option('xstack_qsv_filter', type: 'feature', value: 'auto') ++option('allrgb_filter', type: 'feature', value: 'auto') ++option('allyuv_filter', type: 'feature', value: 'auto') ++option('cellauto_filter', type: 'feature', value: 'auto') ++option('color_filter', type: 'feature', value: 'auto') ++option('colorchart_filter', type: 'feature', value: 'auto') ++option('colorspectrum_filter', type: 'feature', value: 'auto') ++option('coreimagesrc_filter', type: 'feature', value: 'auto') ++option('ddagrab_filter', type: 'feature', value: 'auto') ++option('frei0r_src_filter', type: 'feature', value: 'auto') ++option('gradients_filter', type: 'feature', value: 'auto') ++option('haldclutsrc_filter', type: 'feature', value: 'auto') ++option('life_filter', type: 'feature', value: 'auto') ++option('mandelbrot_filter', type: 'feature', value: 'auto') ++option('mptestsrc_filter', type: 'feature', value: 'auto') ++option('nullsrc_filter', type: 'feature', value: 'enabled') ++option('openclsrc_filter', type: 'feature', value: 'auto') ++option('pal75bars_filter', type: 'feature', value: 'auto') ++option('pal100bars_filter', type: 'feature', value: 'auto') ++option('rgbtestsrc_filter', type: 'feature', value: 'auto') ++option('sierpinski_filter', type: 'feature', value: 'auto') ++option('smptebars_filter', type: 'feature', value: 'auto') ++option('smptehdbars_filter', type: 'feature', value: 'auto') ++option('testsrc_filter', type: 'feature', value: 'auto') ++option('testsrc2_filter', type: 'feature', value: 'auto') ++option('yuvtestsrc_filter', type: 'feature', value: 'auto') ++option('nullsink_filter', type: 'feature', value: 'enabled') ++option('a3dscope_filter', type: 'feature', value: 'auto') ++option('abitscope_filter', type: 'feature', value: 'auto') ++option('adrawgraph_filter', type: 'feature', value: 'auto') ++option('agraphmonitor_filter', type: 'feature', value: 'auto') ++option('ahistogram_filter', type: 'feature', value: 'auto') ++option('aphasemeter_filter', type: 'feature', value: 'auto') ++option('avectorscope_filter', type: 'feature', value: 'auto') ++option('concat_filter', type: 'feature', value: 'auto') ++option('showcqt_filter', type: 'feature', value: 'auto') ++option('showcwt_filter', type: 'feature', value: 'auto') ++option('showfreqs_filter', type: 'feature', value: 'auto') ++option('showspatial_filter', type: 'feature', value: 'auto') ++option('showspectrum_filter', type: 'feature', value: 'auto') ++option('showspectrumpic_filter', type: 'feature', value: 'auto') ++option('showvolume_filter', type: 'feature', value: 'auto') ++option('showwaves_filter', type: 'feature', value: 'auto') ++option('showwavespic_filter', type: 'feature', value: 'auto') ++option('spectrumsynth_filter', type: 'feature', value: 'auto') ++option('avsynctest_filter', type: 'feature', value: 'auto') ++option('amovie_filter', type: 'feature', value: 'auto') ++option('movie_filter', type: 'feature', value: 'auto') ++option('abuffer_filter', type: 'feature', value: 'auto') ++option('buffer_filter', type: 'feature', value: 'auto') ++option('afifo_filter', type: 'feature', value: 'auto') ++option('fifo_filter', type: 'feature', value: 'auto') ++option('filters', type: 'feature', value: 'auto', description: 'Enable or disable all filters') ++#### --- END GENERATED FILTER OPTIONS --- #### ++ ++# Licensing options ++option('gpl', type: 'feature', value: 'disabled', ++ description: 'Allow use of GPL code, the resulting libs and binaries will be under GPL') ++option('version3', type: 'feature', value: 'disabled', ++ description: 'Upgrade (L)GPL to version 3') ++option('nonfree', type: 'feature', value: 'disabled', ++ description: 'Allow use of nonfree code, the resulting libs and binaries will be unredistributable') ++ ++# FFmpeg libraries to build ++option('avcodec', type: 'feature', value: 'enabled', description: 'Build libavcodec') ++option('avdevice', type: 'feature', value: 'enabled', description: 'Build libavdevice') ++option('avfilter', type: 'feature', value: 'enabled', description: 'Build libavfilder') ++option('avformat', type: 'feature', value: 'enabled', description: 'Build libavformat') ++option('avutil', type: 'feature', value: 'enabled', description: 'Build libavutil') ++option('swresample', type: 'feature', value: 'enabled', description: 'Build libswresample') ++option('swscale', type: 'feature', value: 'enabled', description: 'Build libswscale') ++option('postproc', type: 'feature', value: 'enabled', description: 'Build libpostproc') ++ ++# Tools ++option('ffmpeg', type: 'feature', value: 'enabled', description: 'Build ffmpeg') ++option('ffplay', type: 'feature', value: 'enabled', description: 'Build ffplay') ++option('ffprobe', type: 'feature', value: 'enabled', description: 'Build ffprobe') ++ ++# ASM options ++option('asm', type: 'feature', value: 'enabled', description: 'Enable assembly optimizations') ++option('x86asm', type: 'feature', value: 'auto', description: 'Enable use of standalone x86 assembly') ++option('inline_asm', type: 'feature', value: 'enabled', description: 'Enable inline assembly optimizations') ++ ++# other options ++# cli is disabled by default to speed up the build since it links statically ++option('cli', type: 'feature', value: 'disabled', deprecated: true) ++option('programs', type: 'feature', value: 'auto', description: 'Build command line programs') ++option('network', type: 'feature', value: 'auto', description: 'Enable network support') ++option('devices', type: 'feature', value: 'auto', description: 'Enable all input/output devices') ++option('pthreads', type: 'feature', value: 'auto', description: 'Enable pthreads') ++option('w32threads', type: 'feature', value: 'auto', description: 'Enable Win32 threads') ++option('os2threads', type: 'feature', value: 'disabled', description: 'Enable OS/2 support') ++option('tests', type : 'feature', value : 'auto', description : 'Build tests', yield : true) ++option('large_tests', type : 'feature', value : 'disabled') +diff --git a/parse_sources.py b/parse_sources.py +new file mode 100644 +index 0000000000..858140fe15 +--- /dev/null ++++ b/parse_sources.py +@@ -0,0 +1,422 @@ ++# Copyright (c) 2018 Mathieu Duponchelle <mathieu@centricular.com> ++# ++# This file is part of the FFmpeg Meson build ++# ++# This library is free software; you can redistribute it and/or ++# modify it under the terms of the GNU Lesser General Public ++# License as published by the Free Software Foundation; either ++# version 2.1 of the License, or (at your option) any later version. ++# ++# This library is distributed in the hope that it will be useful, ++# but WITHOUT ANY WARRANTY; without even the implied warranty of ++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++# Lesser General Public License for more details. ++# ++# You should have received a copy of the GNU Lesser General Public ++# License along with this library; if not, see <http://www.gnu.org/licenses/>. ++ ++ ++import re ++import os ++import io ++import sys ++from pprint import pprint ++from collections import defaultdict ++ ++ASM_EXTS = ['asm', 'S', 'c'] ++ ++SOURCE_TYPE_EXTS_MAP = { ++ 'c': ['c', 'cpp', 'm', 'cl', 'S'], ++ 'h': ['h'], ++ 'asm': ASM_EXTS, ++ 'armv5te': ASM_EXTS, ++ 'armv6': ASM_EXTS, ++ 'armv8': ASM_EXTS, ++ 'vfp': ASM_EXTS, ++ 'neon': ASM_EXTS, ++ 'test-prog': ['c'], ++ 'mmx': ['c'], ++ 'shlib': ['c'], ++ 'slib': ['c'], ++} ++SOURCE_TYPE_DOUBLE_EXTS_MAP = { ++ 'metallib.o': ['metal'] ++} ++SOURCE_TYPE_DIRS = {'test-prog': 'tests'} ++ ++ ++def add_source(f, source: str, prefix='', suffix=''): ++ if not source.startswith(('opencl/', 'metal/', 'cuda/')): ++ source = os.path.basename(source) ++ f.write("%s'%s'%s" % (prefix, source, suffix)) ++ ++ ++def add_language(languages_map, ext, label): ++ if ext == 'cpp': ++ languages_map[label].add('cpp') ++ elif ext == 'm': ++ languages_map[label].add('objc') ++ ++ ++def make_to_meson(path): ++ source_maps = { ++ 'c': defaultdict(list), ++ 'asm': defaultdict(list), ++ 'armv5te': defaultdict(list), ++ 'armv6': defaultdict(list), ++ 'armv8': defaultdict(list), ++ 'vfp': defaultdict(list), ++ 'neon': defaultdict(list), ++ 'test-prog': defaultdict(list), ++ 'mmx': defaultdict(list), ++ 'shlib': defaultdict(list), ++ 'slib': defaultdict(list), ++ } ++ ++ skipped = set() ++ ++ with open(os.path.join(path, 'Makefile'), 'r') as f: ++ accum = [] ++ accumulate = False ++ optional = False ++ source_type = None ++ languages_map = defaultdict(set) ++ ++ for l in f.readlines(): ++ l = l.strip() ++ l = l.rsplit('#', 1)[0] ++ ++ if accumulate: ++ ofiles = l ++ elif re.match('OBJS-.*CONFIG.*\+\=.*', l): ++ label, ofiles = l.split('+=') ++ label = label.split('CONFIG_')[1].rstrip(' )') ++ source_type = 'c' # arguable ^^ ++ elif re.match('OBJS-.*HAVE.*\+\=.*', l): ++ label, ofiles = l.split('+=') ++ label = label.split('HAVE_')[1].rstrip(' )') ++ source_type = 'c' ++ elif re.match('OBJS-ffmpeg\s+\+\=.*', l): ++ label, ofiles = l.split('+=') ++ label = label.split('OBJS-')[1] ++ source_type = 'c' # arguable ^^ ++ elif re.match('DNN-OBJS-.*CONFIG.*\+\=.*', l): ++ label, ofiles = l.split('+=') ++ label = label.split('CONFIG_')[1].rstrip(' )') ++ source_type = 'c' # arguable too ^^ ++ elif re.match('HEADERS.*=.*', l): ++ label = 'headers' ++ ofiles = l.split('=')[1] ++ source_type = 'h' ++ elif re.match('OBJS.*=.*', l): ++ label = '' ++ ofiles = l.split('=')[1] ++ source_type = 'c' ++ elif re.match('X86ASM-OBJS-.*CONFIG.*\+\=.*', l): ++ label, ofiles = l.split('+=') ++ label = label.split('CONFIG_')[1].rstrip(' )') ++ source_type = 'asm' ++ elif re.match('X86ASM-OBJS.*=.*', l): ++ label = '' ++ ofiles = l.split('=')[1] ++ source_type = 'asm' ++ elif re.match('SLIBOBJS-.*CONFIG.*\+\=.*', l): ++ label, ofiles = l.split('+=') ++ label = label.split('CONFIG_')[1].rstrip(' )') ++ source_type = 'slib' ++ elif re.match('SHLIBOBJS-.*CONFIG.*\+\=.*', l): ++ label, ofiles = l.split('+=') ++ label = label.split('CONFIG_')[1].rstrip(' )') ++ source_type = 'shlib' ++ elif re.match('SLIBOBJS.*=.*', l): ++ label = '' ++ ofiles = l.split('=')[1] ++ source_type = 'slib' ++ elif re.match('SHLIBOBJS.*=.*', l): ++ label = '' ++ ofiles = l.split('=')[1] ++ source_type = 'shlib' ++ elif re.match('TLS-OBJS-.*CONFIG.*\+\=.*', l): ++ label, ofiles = l.split('+=') ++ label = label.split('CONFIG_')[1].rstrip(' )') ++ source_type = 'c' # arguable ^^ ++ elif re.match('MMX-OBJS-.*CONFIG.*\+\=.*', l): ++ label, ofiles = l.split('+=') ++ label = label.split('CONFIG_')[1].rstrip(' )') ++ source_type = 'mmx' ++ elif re.match('MMX-OBJS-.*HAVE.*\+\=.*', l): ++ label, ofiles = l.split('+=') ++ label = label.split('HAVE_')[1].rstrip(' )') ++ source_type = 'mmx' ++ elif re.match('MMX-OBJS.*=.*', l): ++ label = '' ++ ofiles = l.split('=')[1] ++ source_type = 'mmx' ++ elif re.match('ARMV5TE-OBJS-.*CONFIG.*\+\=.*', l): ++ label, ofiles = l.split('+=') ++ label = label.split('CONFIG_')[1].rstrip(' )') ++ source_type = 'armv5te' ++ elif re.match('ARMV5TE-OBJS-.*HAVE.*\+\=.*', l): ++ label, ofiles = l.split('+=') ++ label = label.split('HAVE_')[1].rstrip(' )') ++ source_type = 'armv5te' ++ elif re.match('ARMV5TE-OBJS.*=.*', l): ++ label = '' ++ ofiles = l.split('=')[1] ++ source_type = 'armv5te' ++ elif re.match('ARMV6-OBJS-.*CONFIG.*\+\=.*', l): ++ label, ofiles = l.split('+=') ++ label = label.split('CONFIG_')[1].rstrip(' )') ++ source_type = 'armv6' ++ elif re.match('ARMV6-OBJS-.*HAVE.*\+\=.*', l): ++ label, ofiles = l.split('+=') ++ label = label.split('HAVE_')[1].rstrip(' )') ++ source_type = 'armv6' ++ elif re.match('ARMV6-OBJS.*=.*', l): ++ label = '' ++ ofiles = l.split('=')[1] ++ source_type = 'armv6' ++ elif re.match('ARMV8-OBJS-.*CONFIG.*\+\=.*', l): ++ label, ofiles = l.split('+=') ++ label = label.split('CONFIG_')[1].rstrip(' )') ++ source_type = 'armv8' ++ elif re.match('ARMV8-OBJS-.*HAVE.*\+\=.*', l): ++ label, ofiles = l.split('+=') ++ label = label.split('HAVE_')[1].rstrip(' )') ++ source_type = 'armv8' ++ elif re.match('ARMV8-OBJS.*=.*', l): ++ label = '' ++ ofiles = l.split('=')[1] ++ source_type = 'armv8' ++ elif re.match('VFP-OBJS-.*CONFIG.*\+\=.*', l): ++ label, ofiles = l.split('+=') ++ label = label.split('CONFIG_')[1].rstrip(' )') ++ source_type = 'vfp' ++ elif re.match('VFP-OBJS-.*HAVE.*\+\=.*', l): ++ label, ofiles = l.split('+=') ++ label = label.split('HAVE_')[1].rstrip(' )') ++ source_type = 'vfp' ++ elif re.match('VFP-OBJS.*=.*', l): ++ label = '' ++ ofiles = l.split('=')[1] ++ source_type = 'vfp' ++ elif re.match('NEON-OBJS-.*CONFIG.*\+\=.*', l): ++ label, ofiles = l.split('+=') ++ label = label.split('CONFIG_')[1].rstrip(' )') ++ source_type = 'neon' ++ elif re.match('NEON-OBJS-.*HAVE.*\+\=.*', l): ++ label, ofiles = l.split('+=') ++ label = label.split('HAVE_')[1].rstrip(' )') ++ source_type = 'neon' ++ elif re.match('NEON-OBJS.*=.*', l): ++ label = '' ++ ofiles = l.split('=')[1] ++ source_type = 'neon' ++ elif re.match('TESTPROGS-.*CONFIG.*\+\=.*', l): ++ label, ofiles = l.split('+=') ++ label = label.split('CONFIG_')[1].rstrip(' )') ++ source_type = 'test-prog' ++ elif re.match('TESTPROGS-.*HAVE.*\+\=.*', l): ++ label, ofiles = l.split('+=') ++ label = label.split('HAVE_')[1].rstrip(' )') ++ source_type = 'test-prog' ++ elif re.match('TESTOBJS.*=', l): ++ label = '' ++ ofiles = l.split('=')[1] ++ source_type = 'c' ++ elif re.match('TESTPROGS.*=', l): ++ label = '' ++ ofiles = l.split('=')[1] ++ source_type = "test-prog" ++ else: ++ continue ++ ++ accumulate = ofiles.endswith('\\') ++ ofiles = ofiles.strip('\\') ++ ofiles = ofiles.split() ++ exts = SOURCE_TYPE_EXTS_MAP[source_type] ++ ifiles = [] ++ for ofile in ofiles: ++ basename = ofile.split('.') ++ if len(basename) > 2: ++ exts = SOURCE_TYPE_DOUBLE_EXTS_MAP.get('.'.join(basename[1:]), []) ++ fname = basename[0] ++ for ext in exts: ++ tmpf = fname + '.' + ext ++ if os.path.exists(os.path.join(path, SOURCE_TYPE_DIRS.get(source_type, ''), tmpf)): ++ ifiles.append(tmpf) ++ add_language(languages_map, ext, label) ++ break ++ elif os.path.exists(os.path.join(path, SOURCE_TYPE_DIRS.get(source_type, ''), os.path.basename(tmpf))): ++ ifiles.append(tmpf) ++ add_language(languages_map, ext, label) ++ break ++ ++ if len([of for of in ofiles if not of.startswith("$")]) != len(ifiles): ++ print("WARNING: %s and %s size don't match, not building!" % ([of for of in ofiles if not of.startswith("$")], ifiles)) ++ skipped.add(label) ++ ++ if accumulate: ++ accum += ifiles ++ else: ++ map_ = source_maps.get(source_type, source_maps['c']) ++ map_[label] += accum + ifiles ++ accum = [] ++ ++ # Makefiles can end with '\' and this is just a porting script ;) ++ if accum: ++ map_ = source_maps.get(source_type, source_maps['c']) ++ map_[label] += accum ++ accum = [] ++ ++ ++ lines = [] ++ has_not_generated = False ++ try: ++ with open(os.path.join(path, 'meson.build'), 'r') as meson_file: ++ for l in meson_file.readlines(): ++ if l == '#### --- GENERATED --- ####\n': ++ lines += [l, '\n'] ++ has_not_generated = True ++ break ++ lines.append(l) ++ except FileNotFoundError: ++ pass ++ ++ f = io.StringIO() ++ ++ source_types = ( ++ ('', source_maps['c']), ++ ('x86asm_', source_maps['asm']), ++ ('armv5te_', source_maps['armv5te']), ++ ('armv6_', source_maps['armv6']), ++ ('armv8_', source_maps['armv8']), ++ ('neon_', source_maps['neon']), ++ ('vfp_', source_maps['vfp']), ++ ('mmx_', source_maps['mmx']), ++ ('shlib_', source_maps['shlib']), ++ ('slib_', source_maps['slib']) ++ ) ++ ++ for source_type, map_ in source_types: ++ default_sources = map_.pop('', []) ++ ++ if default_sources: ++ f.write('%ssources = files(\n' % '_'.join((path.replace('/', '_'), source_type))) ++ for source in default_sources: ++ if '$' in source: ++ print ('Warning: skipping %s' % source) ++ continue ++ add_source(f, source, prefix=' ', suffix=',\n') ++ f.write(')\n\n') ++ ++ default_sources = map_.pop('headers', []) ++ ++ if default_sources: ++ f.write('%sheaders = files(\n' % '_'.join((path.replace('/', '_'), source_type))) ++ for source in default_sources: ++ if '$' in source: ++ print ('Warning: skipping %s' % source) ++ continue ++ add_source(f, source, prefix=' ', suffix=',\n') ++ f.write(')\n\n') ++ ++ f.write('%soptional_sources = {\n' % '_'.join((path.replace('/', '_'), source_type))) ++ for label in sorted (map_): ++ if label in skipped: ++ f.write(" # '%s' : files(" % label.lower()) ++ else: ++ f.write(" '%s' : files(" % label.lower()) ++ l = len (map_[label]) ++ for i, source in enumerate(map_[label]): ++ if '$' in source: ++ print ('Warning: skipping %s' % source) ++ continue ++ add_source(f, source) ++ if i + 1 < l: ++ f.write(',') ++ f.write('),\n') ++ f.write('}\n\n') ++ ++ test_source_map = source_maps['test-prog'] ++ ++ default_test_sources = test_source_map.pop('', []) ++ ++ if default_test_sources: ++ f.write('%s_tests = [\n' % path.replace('/', '_')) ++ for source in default_test_sources: ++ if '$' in source: ++ print ('Warning: skipping %s' % source) ++ continue ++ basename = os.path.basename(source) ++ testname = os.path.splitext(basename)[0] ++ f.write(" ['%s', files('tests/%s')],\n" % (testname, basename)) ++ f.write(']\n\n') ++ ++ f.write('%s_optional_tests = {\n' % path.replace('/', '_')) ++ for label in sorted (test_source_map): ++ f.write(" '%s' : [\n" % label.lower()) ++ for source in test_source_map[label]: ++ if '$' in source: ++ print ('Warning: skipping %s' % source) ++ continue ++ basename = os.path.basename(source) ++ testname = os.path.splitext(basename)[0] ++ f.write(" ['%s', files('tests/%s')],\n" % (testname, basename)) ++ f.write(' ],\n') ++ f.write('}\n\n') ++ ++ if languages_map: ++ f.write('languages_map += {\n') ++ for label, languages in languages_map.items(): ++ f.write(" '%s': %s,\n" % (label.lower(), list(languages))) ++ f.write('}\n') ++ ++ if has_not_generated: ++ lines.append(f.getvalue()) ++ with open(os.path.join(path, 'meson.build'), 'r') as meson_file: ++ out_generated = False ++ for l in meson_file.readlines(): ++ if l == '#### --- END GENERATED --- ####\n': ++ out_generated = True ++ if out_generated: ++ lines.append(l) ++ content = ''.join(lines) ++ else: ++ content = f.getvalue() ++ ++ ++ with open(os.path.join(path, 'meson.build'), 'w') as meson_file: ++ meson_file.write(content) ++ ++paths = [ ++ 'fftools', ++ 'libavdevice', ++ 'libavformat', ++ 'libavutil', ++ 'libavutil/aarch64', ++ 'libavutil/arm', ++ 'libavutil/x86', ++ 'libswscale', ++ 'libswscale/aarch64', ++ 'libswscale/arm', ++ 'libswscale/x86', ++ 'libavcodec', ++ 'libavcodec/aarch64', ++ 'libavcodec/arm', ++ 'libavcodec/neon', ++ 'libavcodec/x86', ++ 'libswresample', ++ 'libswresample/aarch64', ++ 'libswresample/arm', ++ 'libswresample/x86', ++ 'libavfilter', ++ 'libavfilter/aarch64', ++ 'libavfilter/x86', ++ 'libavfilter/dnn', ++ 'libpostproc', ++] ++ ++if __name__=='__main__': ++ for path in paths: ++ make_to_meson(path) +diff --git a/print_things.py b/print_things.py +new file mode 100755 +index 0000000000..5b523aa441 +--- /dev/null ++++ b/print_things.py +@@ -0,0 +1,62 @@ ++#!/usr/bin/env python3 ++ ++# Copyright (c) 2018 Mathieu Duponchelle <mathieu@centricular.com> ++# ++# This file is part of the FFmpeg Meson build ++# ++# This library is free software; you can redistribute it and/or ++# modify it under the terms of the GNU Lesser General Public ++# License as published by the Free Software Foundation; either ++# version 2.1 of the License, or (at your option) any later version. ++# ++# This library is distributed in the hope that it will be useful, ++# but WITHOUT ANY WARRANTY; without even the implied warranty of ++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++# Lesser General Public License for more details. ++# ++# You should have received a copy of the GNU Lesser General Public ++# License along with this library; if not, see <http://www.gnu.org/licenses/>. ++ ++import os ++import sys ++import filecmp ++import argparse ++ ++def replace_if_changed(new, old): ++ ''' ++ Compare contents and only replace if changed to avoid triggering a rebuild. ++ ''' ++ try: ++ changed = not filecmp.cmp(new, old, shallow=False) ++ except FileNotFoundError: ++ changed = True ++ if changed: ++ os.replace(new, old) ++ else: ++ os.remove(new) ++ ++# Used to output list of muxers, demuxers, encoders, etc. ++if __name__ == '__main__': ++ arg_parser = argparse.ArgumentParser(description='print elements lists') ++ arg_parser.add_argument('--struct-name', metavar='STRING', ++ default='', ++ help='Struct name, eg AVCodec') ++ arg_parser.add_argument('--name', metavar='STRING', ++ default='', ++ help='Variable name, eg codec_list') ++ arg_parser.add_argument('--filename', metavar='STRING', ++ default='', ++ help='File to print lists of declarations to') ++ arg_parser.add_argument('things', metavar='STRING', nargs='*', ++ default='', ++ help='List of things') ++ ++ args = arg_parser.parse_args() ++ ++ tmp_filename = args.filename + '~' ++ with open(tmp_filename, 'w') as f: ++ f.write('static const %s * const %s[] = {\n' % (args.struct_name, args.name)) ++ for thing in args.things: ++ f.write(' &ff_%s,\n' % (thing)) ++ f.write(' NULL };\n') ++ replace_if_changed(tmp_filename, args.filename) +diff --git a/rc_workaround.py b/rc_workaround.py +new file mode 100755 +index 0000000000..add4b4c199 +--- /dev/null ++++ b/rc_workaround.py +@@ -0,0 +1,32 @@ ++#!/usr/bin/env python3 ++ ++# SPDX-FileCopyrightText: 2023 L. E. Segovia <amy@centricular.com> ++# SPDX-License-Identifier: BSD-3-Clause ++ ++from argparse import ArgumentParser ++from pathlib import Path ++import os ++import re ++ ++if __name__ == '__main__': ++ parser = ArgumentParser(description='Patch .rc file to work around RC include precedences') ++ parser.add_argument('input', type=Path, help='Input file to patch') ++ parser.add_argument('build_folder', type=Path, help='Build folder') ++ ++ args = parser.parse_args() ++ ++ base_folder: Path = args.input.parent ++ ++ build_folder: Path = args.build_folder ++ ++ common_root = os.path.relpath(build_folder, base_folder) ++ ++ relative_path = Path(common_root).as_posix() ++ ++ with args.input.open('r', encoding='utf-8') as f: ++ for line in f.readlines(): ++ if re.match('^#include "config.h"', line): ++ # use <folder of the input>/../.../config.h ++ print(f'#include "{relative_path}/config.h"') ++ else: ++ print(line.strip()) +diff --git a/recursive_selects.py b/recursive_selects.py +new file mode 100644 +index 0000000000..e6c3618419 +--- /dev/null ++++ b/recursive_selects.py +@@ -0,0 +1,65 @@ ++# Copyright (c) 2018 Mathieu Duponchelle <mathieu@centricular.com> ++# ++# This file is part of the FFmpeg Meson build ++# ++# This library is free software; you can redistribute it and/or ++# modify it under the terms of the GNU Lesser General Public ++# License as published by the Free Software Foundation; either ++# version 2.1 of the License, or (at your option) any later version. ++# ++# This library is distributed in the hope that it will be useful, ++# but WITHOUT ANY WARRANTY; without even the implied warranty of ++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++# Lesser General Public License for more details. ++# ++# You should have received a copy of the GNU Lesser General Public ++# License along with this library; if not, see <http://www.gnu.org/licenses/>. ++ ++import re ++from collections import defaultdict ++ ++GRAPH = defaultdict(dict) ++ ++def build_graph(pattern): ++ with open('configure', 'r') as f: ++ for l in f.readlines(): ++ l = l.strip() ++ if re.match(r'^.*_' + pattern + '=\".*\"$', l): ++ label, selector = l.split('=') ++ ++ if '$' in label or '$' in selector: ++ print ('Warning: skip line: %s', l) ++ continue ++ ++ label = label.rsplit('_', 1 + pattern.count('_'))[0].lower() ++ ++ parent_labels = [plabel.lower() for plabel in selector.strip('\"').split()] ++ GRAPH[label][pattern] = parent_labels ++ ++build_graph('select') ++build_graph('deps') ++build_graph('suggest') ++build_graph('deps_any') ++build_graph('conflict') ++build_graph('if') ++build_graph('if_any') ++ ++from pprint import pformat ++with open('depgraph.py', 'w') as f: ++ f.write('''\'\'\' ++This describes a dependency graph as a set of named nodes, the following ++was automatically generated by parsing the configure script, ++see recursive_selects.py ++ ++Each node can contain: ++'deps': All these components must be enabled for the component to be enabled ++'deps_any': At least one of these components must be enabled for the component to be enabled ++'conflict': The component cannot be enabled if any of those components is enabled ++'select': When the component is enabled, all these components must be enabled too ++'suggest': When the component is enabled, all these components *could* be enabled ++'if': If all these components are enabled, this component *could* be enabled ++'if_any': If any of these components are enabled, this component *could* be enabled ++\'\'\' ++ ++''') ++ f.write ('GRAPH = %s\n' % pformat (dict(GRAPH))) +diff --git a/subprojects/win-nasm/download-binary.py b/subprojects/win-nasm/download-binary.py +new file mode 100755 +index 0000000000..047ae7bd4c +--- /dev/null ++++ b/subprojects/win-nasm/download-binary.py +@@ -0,0 +1,76 @@ ++#!/usr/bin/env python3 ++# SPDX-FileCopyrightText: 2020 Nirbheek Chauhan <nirbheek@centricular.com> ++# SPDX-FileCopyrightText: 2023 L. E. Segovia <amy@centricular.com> ++# SPDX-License-Ref: LGPL-2.1-or-later ++ ++import os ++import sys ++import ssl ++import zipfile ++import hashlib ++import urllib.request ++import urllib.error ++ ++# Disable certificate checking because it always fails on Windows ++# We verify the checksum anyway. ++ctx = ssl.create_default_context() ++ctx.check_hostname = False ++ctx.verify_mode = ssl.CERT_NONE ++ ++BASENAME = 'nasm-{}-{}.zip' ++UPSTREAM_URL = 'https://www.nasm.us/pub/nasm/releasebuilds/{}/{}/{}' ++GSTREAMER_URL = 'https://gstreamer.freedesktop.org/src/mirror/{}' ++ ++version = sys.argv[1] ++if sys.argv[2] == 'darwin': ++ arch = 'macosx' ++elif sys.argv[2] == 'x86_64': ++ arch = 'win64' ++else: ++ arch = 'win32' ++zip_sha256 = sys.argv[3] ++source_dir = os.path.join(os.environ['MESON_SOURCE_ROOT'], os.environ['MESON_SUBDIR']) ++dest = BASENAME.format(version, arch) ++dest_path = os.path.join(source_dir, dest) ++ ++def get_sha256(zipf): ++ hasher = hashlib.sha256() ++ with open(zipf, 'rb') as f: ++ hasher.update(f.read()) ++ return hasher.hexdigest() ++ ++if os.path.isfile(dest_path): ++ found_sha256 = get_sha256(dest_path) ++ if found_sha256 == zip_sha256: ++ print('{} already downloaded'.format(dest)) ++ else: ++ os.remove(dest) ++ print('{} checksum mismatch, redownloading'.format(dest), file=sys.stderr) ++ ++if not os.path.isfile(dest_path): ++ for url in (GSTREAMER_URL.format(dest), UPSTREAM_URL.format(version, arch, dest)): ++ print('Downloading {} to {}'.format(url, dest)) ++ try: ++ with open(dest_path, 'wb') as d: ++ f = urllib.request.urlopen(url, context=ctx) ++ d.write(f.read()) ++ break ++ except BaseException as ex: ++ print(ex, file=sys.stderr) ++ print('Failed to download from {!r}, trying mirror...'.format(url), file=sys.stderr) ++ continue ++ else: ++ curdir = os.path.dirname(sys.argv[0]) ++ print('Couldn\'t download {!r}! Try downloading it manually and ' ++ 'placing it into {!r}'.format(dest, curdir), file=sys.stderr) ++ sys.exit(1) ++ ++found_sha256 = get_sha256(dest_path) ++if found_sha256 != zip_sha256: ++ print('SHA256 of downloaded file {} was {} instead of {}' ++ ''.format(dest, found_sha256, zip_sha256), file=sys.stderr) ++ sys.exit(1) ++ ++print('Extracting {}'.format(dest)) ++zf = zipfile.ZipFile(dest_path, "r") ++zf.extractall(path=source_dir) +diff --git a/subprojects/win-nasm/meson.build b/subprojects/win-nasm/meson.build +new file mode 100644 +index 0000000000..ef796103d8 +--- /dev/null ++++ b/subprojects/win-nasm/meson.build +@@ -0,0 +1,41 @@ ++project('nasm', version : '2.16.01') ++ ++download_binary = find_program(meson.current_source_dir() / 'download-binary.py') ++ ++arch = host_machine.system() ++ ++if not ['windows', 'darwin'].contains(arch) ++ warning('Can only download nasm for Windows or macOS, sorry') ++ subdir_done() ++endif ++ ++message('Downloading and extracting nasm binaries for @0@...'.format(arch)) ++ ++if arch == 'windows' ++ arch = host_machine.cpu_family() ++ if arch == 'x86_64' ++ zip_hash = '029eed31faf0d2c5f95783294432cbea6c15bf633430f254bb3c1f195c67ca3a' ++ else ++ zip_hash = 'e289fa70c88594b092c916344bb8bfcd6896b604bfab284ab57b1372997c820c' ++ endif ++else ++ # macOS binaries are only identified as architecture "macosx" ++ zip_hash = 'd53c9a1bc9cd92d22e37924d31e9c68413fa03104fd165a6e7b7faf8800a1822' ++endif ++ ++download = run_command(download_binary, meson.project_version(), arch, zip_hash) ++ ++if download.returncode() != 0 ++ warning('Download failed: @0@'.format(download.stderr().strip())) ++ subdir_done() ++endif ++ ++nasm_path = meson.current_source_dir() / 'nasm-@0@'.format(meson.project_version()) ++ ++if host_machine.system() != 'windows' ++ # Fix ZIP permissions -- zipfile doesn't support this extended format ++ patch_nasm = find_program('patch_nasm.py', required: true) ++ run_command(patch_nasm, nasm_path, check: true) ++endif ++ ++meson.override_find_program('nasm', find_program(nasm_path / 'nasm')) +diff --git a/subprojects/win-nasm/patch_nasm.py b/subprojects/win-nasm/patch_nasm.py +new file mode 100755 +index 0000000000..366892146d +--- /dev/null ++++ b/subprojects/win-nasm/patch_nasm.py +@@ -0,0 +1,15 @@ ++#!/usr/bin/env python3 ++ ++# SPDX-FileCopyrightText: 2023 L. E. Segovia <amy@amyspark.me> ++# SPDX-License-Identifier: BSD-3-Clause ++ ++from pathlib import Path ++import os ++import stat ++from argparse import ArgumentParser ++ ++if __name__ == '__main__': ++ parser = ArgumentParser(description='Make Nasm executable') ++ parser.add_argument('dir', type=Path, help='Source directory') ++ args = parser.parse_args() ++ os.chmod(args.dir / "nasm", stat.S_IRUSR | stat.S_IRGRP | stat.S_IROTH | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH | stat.S_IWUSR) +-- +2.42.0 + diff --git a/recipes/ffmpeg/0001-pkgconfig-fix-generation-to-use-prefix.patch b/recipes/ffmpeg/0001-pkgconfig-fix-generation-to-use-prefix.patch deleted file mode 100644 index c7d670fb..00000000 --- a/recipes/ffmpeg/0001-pkgconfig-fix-generation-to-use-prefix.patch +++ /dev/null @@ -1,27 +0,0 @@ -From 8f5d2c0283c4cbc430ac30a6efef999c33bdb2c9 Mon Sep 17 00:00:00 2001 -From: =?UTF-8?q?St=C3=A9phane=20Cerveau?= <scerveau@igalia.com> -Date: Fri, 4 Nov 2022 12:20:25 +0100 -Subject: [PATCH] pkgconfig: fix generation to use prefix - ---- - ffbuild/pkgconfig_generate.sh | 4 ++-- - 1 file changed, 2 insertions(+), 2 deletions(-) - -diff --git a/ffbuild/pkgconfig_generate.sh b/ffbuild/pkgconfig_generate.sh -index e5de671..679413e 100755 ---- a/ffbuild/pkgconfig_generate.sh -+++ b/ffbuild/pkgconfig_generate.sh -@@ -29,8 +29,8 @@ version=$(grep ${name}_VERSION= $name/${name}.version | cut -d= -f2) - cat <<EOF > $name/$fullname.pc - prefix=$prefix - exec_prefix=\${prefix} --libdir=$libdir --includedir=$incdir -+libdir=\${prefix}/lib -+includedir=\${prefix}/include - - Name: $fullname - Description: $comment --- -2.34.1 - |