mirror of
https://github.com/mpv-player/mpv.git
synced 2024-09-20 03:52:22 +02:00
7d11eda72e
Libav seems rather dead: no release for 2 years, no new git commits in
master for almost a year (with one exception ~6 months ago). From what I
can tell, some developers resigned themselves to the horrifying idea to
post patches to ffmpeg-devel instead, while the rest of the developers
went on to greener pastures.
Libav was a better project than FFmpeg. Unfortunately, FFmpeg won,
because it managed to keep the name and website. Libav was pushed more
and more into obscurity: while there was initially a big push for Libav,
FFmpeg just remained "in place" and visible for most people. FFmpeg was
slowly draining all manpower and energy from Libav. A big part of this
was that FFmpeg stole code from Libav (regular merges of the entire
Libav git tree), making it some sort of Frankenstein mirror of Libav,
think decaying zombie with additional legs ("features") nailed to it.
"Stealing" surely is the wrong word; I'm just aping the language that
some of the FFmpeg members used to use. All that is in the past now, I'm
probably the only person left who is annoyed by this, and with this
commit I'm putting this decade long problem finally to an end. I just
thought I'd express my annoyance about this fucking shitshow one last
time.
The most intrusive change in this commit is the resample filter, which
originally used libavresample. Since the FFmpeg developer refused to
enable libavresample by default for drama reasons, and the API was
slightly different, so the filter used some big preprocessor mess to
make it compatible to libswresample. All that falls away now. The
simplification to the build system is also significant.
1085 lines
37 KiB
Python
1085 lines
37 KiB
Python
# vi: ft=python
|
|
|
|
import sys, os, re
|
|
sys.path.insert(0, os.path.join(os.getcwd(), 'waftools'))
|
|
sys.path.insert(0, os.getcwd())
|
|
from shlex import split
|
|
from waflib.Configure import conf
|
|
from waflib.Tools import c_preproc
|
|
from waflib import Utils
|
|
from waftools.checks.generic import *
|
|
from waftools.checks.custom import *
|
|
|
|
c_preproc.go_absolute=True # enable system folders
|
|
c_preproc.standard_includes.append('/usr/local/include')
|
|
|
|
APPNAME = 'mpv'
|
|
|
|
"""
|
|
Dependency identifiers (for win32 vs. Unix):
|
|
wscript / C source meaning
|
|
--------------------------------------------------------------------------
|
|
posix / HAVE_POSIX: defined on Linux, OSX, Cygwin
|
|
(Cygwin emulates POSIX APIs on Windows)
|
|
mingw / __MINGW32__: defined if posix is not defined
|
|
(Windows without Cygwin)
|
|
os-win32 / _WIN32: defined if basic windows.h API is available
|
|
win32-desktop / HAVE_WIN32_DESKTOP: defined if desktop windows.h API is available
|
|
uwp / HAVE_UWP: defined if building for UWP (basic Windows only)
|
|
"""
|
|
|
|
build_options = [
|
|
{
|
|
'name': '--lgpl',
|
|
'desc': 'LGPL (version 2.1 or later) build',
|
|
'default': 'disable',
|
|
'func': check_true,
|
|
}, {
|
|
'name': 'gpl',
|
|
'desc': 'GPL (version 2 or later) build',
|
|
'deps': '!lgpl',
|
|
'func': check_true,
|
|
}, {
|
|
'name': '--cplayer',
|
|
'desc': 'mpv CLI player',
|
|
'default': 'enable',
|
|
'func': check_true
|
|
}, {
|
|
'name': '--libmpv-shared',
|
|
'desc': 'shared library',
|
|
'default': 'disable',
|
|
'func': check_true
|
|
}, {
|
|
'name': '--libmpv-static',
|
|
'desc': 'static library',
|
|
'default': 'disable',
|
|
'deps': '!libmpv-shared',
|
|
'func': check_true
|
|
}, {
|
|
'name': '--static-build',
|
|
'desc': 'static build',
|
|
'default': 'disable',
|
|
'func': check_true
|
|
}, {
|
|
'name': '--build-date',
|
|
'desc': 'whether to include binary compile time',
|
|
'default': 'enable',
|
|
'func': check_true
|
|
}, {
|
|
'name': '--optimize',
|
|
'desc': 'whether to optimize',
|
|
'default': 'enable',
|
|
'func': check_true
|
|
}, {
|
|
'name': '--debug-build',
|
|
'desc': 'whether to compile-in debugging information',
|
|
'default': 'enable',
|
|
'func': check_true
|
|
}, {
|
|
'name': '--tests',
|
|
'desc': 'unit tests (development only)',
|
|
'default': 'disable',
|
|
'func': check_true
|
|
}, {
|
|
# Reminder: normally always built, but enabled by MPV_LEAK_REPORT.
|
|
# Building it can be disabled only by defining NDEBUG through CFLAGS.
|
|
'name': '--ta-leak-report',
|
|
'desc': 'enable ta leak report by default (development only)',
|
|
'default': 'disable',
|
|
'func': check_true
|
|
}, {
|
|
'name': '--manpage-build',
|
|
'desc': 'manpage generation',
|
|
'func': check_ctx_vars('RST2MAN')
|
|
}, {
|
|
'name': '--html-build',
|
|
'desc': 'html manual generation',
|
|
'func': check_ctx_vars('RST2HTML'),
|
|
'default': 'disable',
|
|
}, {
|
|
'name': '--pdf-build',
|
|
'desc': 'pdf manual generation',
|
|
'func': check_ctx_vars('RST2PDF'),
|
|
'default': 'disable',
|
|
}, {
|
|
'name': 'libdl',
|
|
'desc': 'dynamic loader',
|
|
'func': check_libs(['dl'], check_statement('dlfcn.h', 'dlopen("", 0)'))
|
|
}, {
|
|
'name': '--cplugins',
|
|
'desc': 'C plugins',
|
|
'deps': 'libdl && !os-win32',
|
|
'func': check_cc(linkflags=['-rdynamic']),
|
|
}, {
|
|
# does nothing - left for backward and forward compatibility
|
|
'name': '--asm',
|
|
'desc': 'inline assembly (currently without effect)',
|
|
'default': 'enable',
|
|
'func': check_true,
|
|
}, {
|
|
'name': '--clang-database',
|
|
'desc': 'generate a clang compilation database',
|
|
'func': check_true,
|
|
'default': 'disable',
|
|
} , {
|
|
'name': '--swift-static',
|
|
'desc': 'static Swift linking',
|
|
'deps': 'os-darwin',
|
|
'func': check_ctx_vars('SWIFT_LIB_STATIC'),
|
|
'default': 'disable'
|
|
}
|
|
]
|
|
|
|
main_dependencies = [
|
|
{
|
|
'name': 'noexecstack',
|
|
'desc': 'compiler support for noexecstack',
|
|
'func': check_cc(linkflags='-Wl,-z,noexecstack')
|
|
}, {
|
|
'name': 'noexecstack',
|
|
'desc': 'linker support for --nxcompat --no-seh --dynamicbase',
|
|
'func': check_cc(linkflags=['-Wl,--nxcompat', '-Wl,--no-seh', '-Wl,--dynamicbase'])
|
|
} , {
|
|
'name': 'libm',
|
|
'desc': '-lm',
|
|
'func': check_cc(lib='m')
|
|
}, {
|
|
'name': 'mingw',
|
|
'desc': 'MinGW',
|
|
'deps': 'os-win32',
|
|
'func': check_statement('stdlib.h', 'int x = __MINGW32__;'
|
|
'int y = __MINGW64_VERSION_MAJOR'),
|
|
}, {
|
|
'name': 'posix',
|
|
'desc': 'POSIX environment',
|
|
'func': check_statement(['unistd.h'], 'long x = _POSIX_VERSION'),
|
|
}, {
|
|
'name': '--android',
|
|
'desc': 'Android environment',
|
|
'func': check_statement('android/api-level.h', '(void)__ANDROID__'), # arbitrary android-specific header
|
|
}, {
|
|
'name': '--tvos',
|
|
'desc': 'tvOS environment',
|
|
'func': check_statement(
|
|
['TargetConditionals.h', 'assert.h'],
|
|
'static_assert(TARGET_OS_TV, "TARGET_OS_TV defined to zero!")'
|
|
),
|
|
}, {
|
|
'name': '--egl-android',
|
|
'desc': 'Android EGL support',
|
|
'deps': 'android',
|
|
'groups': [ 'gl' ],
|
|
'func': check_cc(lib=['android', 'EGL']),
|
|
}, {
|
|
'name': 'posix-or-mingw',
|
|
'desc': 'development environment',
|
|
'deps': 'posix || mingw',
|
|
'func': check_true,
|
|
'req': True,
|
|
'fmsg': 'Unable to find either POSIX or MinGW-w64 environment, ' \
|
|
'or compiler does not work.',
|
|
}, {
|
|
'name': '--swift',
|
|
'desc': 'macOS Swift build tools',
|
|
'deps': 'os-darwin',
|
|
'func': check_swift,
|
|
}, {
|
|
'name': '--uwp',
|
|
'desc': 'Universal Windows Platform',
|
|
'default': 'disable',
|
|
'deps': 'os-win32 && mingw && !cplayer',
|
|
'func': check_cc(lib=['windowsapp']),
|
|
}, {
|
|
'name': 'win32-desktop',
|
|
'desc': 'win32 desktop APIs',
|
|
'deps': '(os-win32 || os-cygwin) && !uwp',
|
|
'func': check_cc(lib=['winmm', 'gdi32', 'ole32', 'uuid', 'avrt', 'dwmapi', 'version']),
|
|
}, {
|
|
'name': '--win32-internal-pthreads',
|
|
'desc': 'internal pthread wrapper for win32 (Vista+)',
|
|
'deps': 'os-win32 && !posix',
|
|
'func': check_true,
|
|
}, {
|
|
'name': 'pthreads',
|
|
'desc': 'POSIX threads',
|
|
'func': check_pthreads,
|
|
'req': True,
|
|
'fmsg': 'Unable to find pthreads support.'
|
|
}, {
|
|
'name': 'gnuc',
|
|
'desc': 'GNU C extensions',
|
|
'func': check_statement([], "__GNUC__"),
|
|
}, {
|
|
'name': 'stdatomic',
|
|
'desc': 'stdatomic.h',
|
|
'func': check_libs(['atomic'],
|
|
check_statement('stdatomic.h',
|
|
'atomic_int_least64_t test = ATOMIC_VAR_INIT(123);'
|
|
'atomic_fetch_add(&test, 1)'))
|
|
}, {
|
|
# C11; technically we require C11, but aligned_alloc() is not in MinGW
|
|
'name': 'aligned_alloc',
|
|
'desc': 'C11 aligned_alloc()',
|
|
'func': check_statement('stdlib.h', 'aligned_alloc(1, 1)'),
|
|
}, {
|
|
'name': 'atomics',
|
|
'desc': 'stdatomic.h support or slow emulation',
|
|
'func': check_true,
|
|
'req': True,
|
|
'deps': 'stdatomic || gnuc',
|
|
}, {
|
|
'name': 'librt',
|
|
'desc': 'linking with -lrt',
|
|
'deps': 'pthreads',
|
|
'func': check_cc(lib='rt')
|
|
}, {
|
|
'name': '--iconv',
|
|
'desc': 'iconv',
|
|
'func': check_iconv,
|
|
'req': True,
|
|
'fmsg': "Unable to find iconv which should be part of a standard \
|
|
compilation environment. Aborting. If you really mean to compile without \
|
|
iconv support use --disable-iconv.",
|
|
}, {
|
|
'name': 'dos-paths',
|
|
'desc': 'w32/dos paths',
|
|
'deps': 'os-win32 || os-cygwin',
|
|
'func': check_true
|
|
}, {
|
|
'name': 'posix-spawn-native',
|
|
'desc': 'spawnp()/kill() POSIX support',
|
|
'func': check_statement(['spawn.h', 'signal.h'],
|
|
'posix_spawnp(0,0,0,0,0,0); kill(0,0)'),
|
|
'deps': '!mingw && !tvos',
|
|
}, {
|
|
'name': 'posix-spawn-android',
|
|
'desc': 'spawnp()/kill() Android replacement',
|
|
'func': check_true,
|
|
'deps': 'android && !posix-spawn-native',
|
|
},{
|
|
'name': 'posix-spawn',
|
|
'desc': 'any spawnp()/kill() support',
|
|
'deps': 'posix-spawn-native || posix-spawn-android',
|
|
'func': check_true,
|
|
}, {
|
|
'name': 'win32-pipes',
|
|
'desc': 'Windows pipe support',
|
|
'func': check_true,
|
|
'deps': 'win32-desktop && !posix',
|
|
}, {
|
|
'name': 'glob-posix',
|
|
'desc': 'glob() POSIX support',
|
|
'deps': '!(os-win32 || os-cygwin)',
|
|
'func': check_statement('glob.h', 'glob("filename", 0, 0, 0)'),
|
|
}, {
|
|
'name': 'glob-win32',
|
|
'desc': 'glob() win32 replacement',
|
|
'deps': '!posix && (os-win32 || os-cygwin)',
|
|
'func': check_true
|
|
}, {
|
|
'name': 'glob',
|
|
'desc': 'any glob() support',
|
|
'deps': 'glob-posix || glob-win32',
|
|
'func': check_true,
|
|
}, {
|
|
'name': 'fchmod',
|
|
'desc': 'fchmod()',
|
|
'func': check_statement('sys/stat.h', 'fchmod(0, 0)'),
|
|
}, {
|
|
'name': 'vt.h',
|
|
'desc': 'vt.h',
|
|
'func': check_statement(['sys/vt.h', 'sys/ioctl.h'],
|
|
'int m; ioctl(0, VT_GETMODE, &m)'),
|
|
}, {
|
|
'name': 'gbm.h',
|
|
'desc': 'gbm.h',
|
|
'func': check_cc(header_name=['stdio.h', 'gbm.h']),
|
|
}, {
|
|
'name': 'glibc-thread-name',
|
|
'desc': 'GLIBC API for setting thread name',
|
|
'func': check_statement('pthread.h',
|
|
'pthread_setname_np(pthread_self(), "ducks")',
|
|
use=['pthreads']),
|
|
}, {
|
|
'name': 'osx-thread-name',
|
|
'desc': 'OSX API for setting thread name',
|
|
'deps': '!glibc-thread-name',
|
|
'func': check_statement('pthread.h',
|
|
'pthread_setname_np("ducks")', use=['pthreads']),
|
|
}, {
|
|
'name': 'bsd-thread-name',
|
|
'desc': 'BSD API for setting thread name',
|
|
'deps': '!(glibc-thread-name || osx-thread-name)',
|
|
'func': check_statement('pthread.h',
|
|
'pthread_set_name_np(pthread_self(), "ducks")',
|
|
use=['pthreads']),
|
|
}, {
|
|
'name': 'bsd-fstatfs',
|
|
'desc': "BSD's fstatfs()",
|
|
'func': check_statement(['sys/param.h', 'sys/mount.h'],
|
|
'struct statfs fs; fstatfs(0, &fs); fs.f_fstypename')
|
|
}, {
|
|
'name': 'linux-fstatfs',
|
|
'desc': "Linux's fstatfs()",
|
|
'deps': 'os-linux',
|
|
'func': check_statement('sys/vfs.h',
|
|
'struct statfs fs; fstatfs(0, &fs); fs.f_namelen')
|
|
}, {
|
|
'name': 'memfd_create',
|
|
'desc': "Linux's memfd_create()",
|
|
'deps': 'os-linux',
|
|
'func': check_statement('sys/mman.h',
|
|
'memfd_create("mpv", MFD_CLOEXEC | MFD_ALLOW_SEALING)')
|
|
}, {
|
|
'name': '--libsmbclient',
|
|
'desc': 'Samba support (makes mpv GPLv3)',
|
|
'deps': 'libdl && gpl',
|
|
'func': check_pkg_config('smbclient'),
|
|
'default': 'disable',
|
|
'module': 'input',
|
|
}, {
|
|
'name' : '--lua',
|
|
'desc' : 'Lua',
|
|
'func': check_lua,
|
|
}, {
|
|
'name' : '--javascript',
|
|
'desc' : 'Javascript (MuJS backend)',
|
|
'func': check_pkg_config('mujs', '>= 1.0.0'),
|
|
}, {
|
|
'name': '--libass',
|
|
'desc': 'SSA/ASS support',
|
|
'func': check_pkg_config('libass', '>= 0.12.1'),
|
|
'req': True,
|
|
'fmsg': "Unable to find development files for libass, or the version " +
|
|
"found is too old. Aborting. If you really mean to compile " +
|
|
"without libass support use --disable-libass."
|
|
}, {
|
|
'name': '--libass-osd',
|
|
'desc': 'libass OSD support',
|
|
'deps': 'libass',
|
|
'func': check_true,
|
|
}, {
|
|
'name': 'dummy-osd',
|
|
'desc': 'dummy OSD support',
|
|
'deps': '!libass-osd',
|
|
'func': check_true,
|
|
} , {
|
|
'name': '--zlib',
|
|
'desc': 'zlib',
|
|
'func': check_libs(['z'],
|
|
check_statement('zlib.h', 'inflate(0, Z_NO_FLUSH)')),
|
|
'req': True,
|
|
'fmsg': 'Unable to find development files for zlib.'
|
|
}, {
|
|
'name': '--libbluray',
|
|
'desc': 'Bluray support',
|
|
'func': check_pkg_config('libbluray', '>= 0.3.0'),
|
|
#'default': 'disable',
|
|
}, {
|
|
'name': '--dvdnav',
|
|
'desc': 'dvdnav support',
|
|
'deps': 'gpl',
|
|
'func': check_pkg_config('dvdnav', '>= 4.2.0',
|
|
'dvdread', '>= 4.1.0'),
|
|
'default': 'disable',
|
|
}, {
|
|
'name': '--cdda',
|
|
'desc': 'cdda support (libcdio)',
|
|
'deps': 'gpl',
|
|
'func': check_pkg_config('libcdio_paranoia'),
|
|
'default': 'disable',
|
|
}, {
|
|
'name': '--uchardet',
|
|
'desc': 'uchardet support',
|
|
'deps': 'iconv',
|
|
'func': check_pkg_config('uchardet'),
|
|
}, {
|
|
'name': '--rubberband',
|
|
'desc': 'librubberband support',
|
|
'func': check_pkg_config('rubberband', '>= 1.8.0'),
|
|
}, {
|
|
'name': '--zimg',
|
|
'deps': 'aligned_alloc',
|
|
'desc': 'libzimg support (high quality software scaler)',
|
|
'func': check_pkg_config('zimg', '>= 2.9'),
|
|
}, {
|
|
'name': '--lcms2',
|
|
'desc': 'LCMS2 support',
|
|
'func': check_pkg_config('lcms2', '>= 2.6'),
|
|
}, {
|
|
'name': '--vapoursynth',
|
|
'desc': 'VapourSynth filter bridge',
|
|
'func': check_pkg_config('vapoursynth', '>= 24',
|
|
'vapoursynth-script', '>= 23'),
|
|
}, {
|
|
'name': '--libarchive',
|
|
'desc': 'libarchive wrapper for reading zip files and more',
|
|
'func': check_pkg_config('libarchive >= 3.4.0'),
|
|
}, {
|
|
'name': '--dvbin',
|
|
'desc': 'DVB input module',
|
|
'deps': 'gpl',
|
|
'func': check_true,
|
|
'default': 'disable',
|
|
}, {
|
|
'name': '--sdl2',
|
|
'desc': 'SDL2',
|
|
'func': check_pkg_config('sdl2'),
|
|
'default': 'disable',
|
|
}, {
|
|
'name': '--sdl2-gamepad',
|
|
'desc': 'SDL2 gamepad input',
|
|
'deps': 'sdl2',
|
|
'func': check_true,
|
|
}
|
|
]
|
|
|
|
libav_dependencies = [
|
|
{
|
|
'name': 'ffmpeg',
|
|
'desc': 'FFmpeg library',
|
|
'func': check_pkg_config('libavutil', '>= 56.12.100',
|
|
'libavcodec', '>= 58.16.100',
|
|
'libavformat', '>= 58.9.100',
|
|
'libswscale', '>= 5.0.101',
|
|
'libavfilter', '>= 7.14.100',
|
|
'libswresample', '>= 3.0.100'),
|
|
'req': True,
|
|
'fmsg': "Unable to find development files for some of the required \
|
|
FFmpeg libraries. Git master is recommended."
|
|
}, {
|
|
'name': '--libavdevice',
|
|
'desc': 'libavdevice',
|
|
'func': check_pkg_config('libavdevice', '>= 57.0.0'),
|
|
}, {
|
|
'name': '--ffmpeg-strict-abi',
|
|
'desc': 'Disable all known FFmpeg ABI violations',
|
|
'func': check_true,
|
|
'default': 'disable',
|
|
}
|
|
]
|
|
|
|
audio_output_features = [
|
|
{
|
|
'name': '--sdl2-audio',
|
|
'desc': 'SDL2 audio output',
|
|
'deps': 'sdl2',
|
|
'func': check_true,
|
|
}, {
|
|
'name': '--oss-audio',
|
|
'desc': 'OSS',
|
|
'func': check_cc(header_name='sys/soundcard.h'),
|
|
'deps': 'posix && gpl',
|
|
}, {
|
|
'name': '--rsound',
|
|
'desc': 'RSound audio output',
|
|
'func': check_statement('rsound.h', 'rsd_init(NULL)', lib='rsound')
|
|
}, {
|
|
'name': '--sndio',
|
|
'desc': 'sndio audio input/output',
|
|
'func': check_statement('sndio.h',
|
|
'struct sio_par par; sio_initpar(&par); const char *s = SIO_DEVANY', lib='sndio'),
|
|
'default': 'disable'
|
|
}, {
|
|
'name': '--pulse',
|
|
'desc': 'PulseAudio audio output',
|
|
'func': check_pkg_config('libpulse', '>= 1.0')
|
|
}, {
|
|
'name': '--jack',
|
|
'desc': 'JACK audio output',
|
|
'deps': 'gpl',
|
|
'func': check_pkg_config('jack'),
|
|
}, {
|
|
'name': '--openal',
|
|
'desc': 'OpenAL audio output',
|
|
'func': check_pkg_config('openal', '>= 1.13'),
|
|
'default': 'disable'
|
|
}, {
|
|
'name': '--opensles',
|
|
'desc': 'OpenSL ES audio output',
|
|
'func': check_statement('SLES/OpenSLES.h', 'slCreateEngine', lib="OpenSLES"),
|
|
}, {
|
|
'name': '--alsa',
|
|
'desc': 'ALSA audio output',
|
|
'func': check_pkg_config('alsa', '>= 1.0.18'),
|
|
}, {
|
|
'name': '--coreaudio',
|
|
'desc': 'CoreAudio audio output',
|
|
'func': check_cc(
|
|
fragment=load_fragment('coreaudio.c'),
|
|
framework_name=['CoreFoundation', 'CoreAudio', 'AudioUnit', 'AudioToolbox'])
|
|
}, {
|
|
'name': '--audiounit',
|
|
'desc': 'AudioUnit output for iOS',
|
|
'deps': 'atomics',
|
|
'func': check_cc(
|
|
fragment=load_fragment('audiounit.c'),
|
|
framework_name=['Foundation', 'AudioToolbox'])
|
|
}, {
|
|
'name': '--wasapi',
|
|
'desc': 'WASAPI audio output',
|
|
'deps': 'os-win32 || os-cygwin',
|
|
'func': check_cc(fragment=load_fragment('wasapi.c')),
|
|
}
|
|
]
|
|
|
|
video_output_features = [
|
|
{
|
|
'name': '--sdl2-video',
|
|
'desc': 'SDL2 video output',
|
|
'deps': 'sdl2',
|
|
'deps_neg': 'cocoa',
|
|
'func': check_true,
|
|
}, {
|
|
'name': '--cocoa',
|
|
'desc': 'Cocoa',
|
|
'func': check_cocoa
|
|
}, {
|
|
'name': '--drm',
|
|
'desc': 'DRM',
|
|
'deps': 'vt.h',
|
|
'func': check_pkg_config('libdrm', '>= 2.4.74'),
|
|
}, {
|
|
'name': '--gbm',
|
|
'desc': 'GBM',
|
|
'deps': 'gbm.h',
|
|
'func': check_pkg_config('gbm'),
|
|
} , {
|
|
'name': '--wayland-scanner',
|
|
'desc': 'wayland-scanner',
|
|
'func': check_program('wayland-scanner', 'WAYSCAN')
|
|
} , {
|
|
'name': '--wayland-protocols',
|
|
'desc': 'wayland-protocols',
|
|
'func': check_wl_protocols
|
|
} , {
|
|
'name': '--wayland',
|
|
'desc': 'Wayland',
|
|
'deps': 'wayland-protocols && wayland-scanner',
|
|
'func': check_pkg_config('wayland-client', '>= 1.15.0',
|
|
'wayland-cursor', '>= 1.15.0',
|
|
'xkbcommon', '>= 0.3.0'),
|
|
} , {
|
|
'name': '--x11',
|
|
'desc': 'X11',
|
|
'deps': 'gpl',
|
|
'func': check_pkg_config('x11', '>= 1.0.0',
|
|
'xscrnsaver', '>= 1.0.0',
|
|
'xext', '>= 1.0.0',
|
|
'xinerama', '>= 1.0.0',
|
|
'xrandr', '>= 1.2.0'),
|
|
} , {
|
|
'name': '--xv',
|
|
'desc': 'Xv video output',
|
|
'deps': 'x11',
|
|
'func': check_pkg_config('xv'),
|
|
} , {
|
|
'name': '--gl-cocoa',
|
|
'desc': 'OpenGL Cocoa Backend',
|
|
'deps': 'cocoa',
|
|
'groups': [ 'gl' ],
|
|
'func': check_statement('IOSurface/IOSurface.h',
|
|
'IOSurfaceRef surface;',
|
|
framework='IOSurface',
|
|
cflags=['-DGL_SILENCE_DEPRECATION'])
|
|
} , {
|
|
'name': '--gl-x11',
|
|
'desc': 'OpenGL X11 Backend',
|
|
'deps': 'x11',
|
|
'groups': [ 'gl' ],
|
|
'func': check_libs(['GL', 'GL Xdamage'],
|
|
check_cc(fragment=load_fragment('gl_x11.c'),
|
|
use=['x11', 'libdl', 'pthreads']))
|
|
} , {
|
|
'name': '--egl',
|
|
'desc': 'EGL 1.4',
|
|
'groups': [ 'gl' ],
|
|
'func': compose_checks(
|
|
check_pkg_config('egl'),
|
|
check_statement(['EGL/egl.h'], 'int x[EGL_VERSION_1_4]')
|
|
),
|
|
} , {
|
|
'name': '--egl-x11',
|
|
'desc': 'OpenGL X11 EGL Backend',
|
|
'deps': 'x11 && egl',
|
|
'groups': [ 'gl' ],
|
|
'func': check_true,
|
|
} , {
|
|
'name': '--egl-drm',
|
|
'desc': 'OpenGL DRM EGL Backend',
|
|
'deps': 'drm && gbm',
|
|
'groups': [ 'gl' ],
|
|
'func': check_pkg_config('egl'),
|
|
} , {
|
|
'name': '--gl-wayland',
|
|
'desc': 'OpenGL Wayland Backend',
|
|
'deps': 'wayland',
|
|
'groups': [ 'gl' ],
|
|
'func': check_pkg_config('wayland-egl', '>= 9.0.0',
|
|
'egl', '>= 1.5')
|
|
} , {
|
|
'name': '--gl-win32',
|
|
'desc': 'OpenGL Win32 Backend',
|
|
'deps': 'win32-desktop',
|
|
'groups': [ 'gl' ],
|
|
'func': check_statement('windows.h', 'wglCreateContext(0)',
|
|
lib='opengl32')
|
|
} , {
|
|
'name': '--gl-dxinterop',
|
|
'desc': 'OpenGL/DirectX Interop Backend',
|
|
'deps': 'gl-win32',
|
|
'groups': [ 'gl' ],
|
|
'func': compose_checks(
|
|
check_statement(['GL/gl.h', 'GL/wglext.h'], 'int i = WGL_ACCESS_WRITE_DISCARD_NV'),
|
|
check_statement('d3d9.h', 'IDirect3D9Ex *d'))
|
|
} , {
|
|
'name': '--egl-angle',
|
|
'desc': 'OpenGL ANGLE headers',
|
|
'deps': 'os-win32 || os-cygwin',
|
|
'groups': [ 'gl' ],
|
|
'func': check_statement(['EGL/egl.h', 'EGL/eglext.h'],
|
|
'int x = EGL_D3D_TEXTURE_2D_SHARE_HANDLE_ANGLE')
|
|
} , {
|
|
'name': '--egl-angle-lib',
|
|
'desc': 'OpenGL Win32 ANGLE Library',
|
|
'deps': 'egl-angle',
|
|
'groups': [ 'gl' ],
|
|
'func': check_statement(['EGL/egl.h'],
|
|
'eglCreateWindowSurface(0, 0, 0, 0)',
|
|
cflags=['-DGL_APICALL=', '-DEGLAPI=',
|
|
'-DANGLE_NO_ALIASES', '-DANGLE_EXPORT='],
|
|
lib=['EGL', 'GLESv2', 'dxguid', 'd3d9',
|
|
'gdi32', 'stdc++'])
|
|
}, {
|
|
'name': '--egl-angle-win32',
|
|
'desc': 'OpenGL Win32 ANGLE Backend',
|
|
'deps': 'egl-angle && win32-desktop',
|
|
'groups': [ 'gl' ],
|
|
'func': check_true,
|
|
} , {
|
|
'name': '--vdpau',
|
|
'desc': 'VDPAU acceleration',
|
|
'deps': 'x11',
|
|
'func': check_pkg_config('vdpau', '>= 0.2'),
|
|
} , {
|
|
'name': '--vdpau-gl-x11',
|
|
'desc': 'VDPAU with OpenGL/X11',
|
|
'deps': 'vdpau && gl-x11',
|
|
'func': check_true,
|
|
}, {
|
|
'name': '--vaapi',
|
|
'desc': 'VAAPI acceleration',
|
|
'deps': 'libdl && (x11 || wayland || egl-drm)',
|
|
'func': check_pkg_config('libva', '>= 1.1.0'),
|
|
}, {
|
|
'name': '--vaapi-x11',
|
|
'desc': 'VAAPI (X11 support)',
|
|
'deps': 'vaapi && x11',
|
|
'func': check_pkg_config('libva-x11', '>= 1.1.0'),
|
|
}, {
|
|
'name': '--vaapi-wayland',
|
|
'desc': 'VAAPI (Wayland support)',
|
|
'deps': 'vaapi && gl-wayland',
|
|
'func': check_pkg_config('libva-wayland', '>= 1.1.0'),
|
|
}, {
|
|
'name': '--vaapi-drm',
|
|
'desc': 'VAAPI (DRM/EGL support)',
|
|
'deps': 'vaapi && egl-drm',
|
|
'func': check_pkg_config('libva-drm', '>= 1.1.0'),
|
|
}, {
|
|
'name': '--vaapi-x-egl',
|
|
'desc': 'VAAPI EGL on X11',
|
|
'deps': 'vaapi-x11 && egl-x11',
|
|
'func': check_true,
|
|
}, {
|
|
'name': 'vaapi-egl',
|
|
'desc': 'VAAPI EGL',
|
|
'deps': 'vaapi-x-egl || vaapi-wayland || vaapi-drm',
|
|
'func': check_true,
|
|
}, {
|
|
'name': '--caca',
|
|
'desc': 'CACA',
|
|
'deps': 'gpl',
|
|
'func': check_pkg_config('caca', '>= 0.99.beta18'),
|
|
}, {
|
|
'name': '--jpeg',
|
|
'desc': 'JPEG support',
|
|
'func': check_cc(header_name=['stdio.h', 'jpeglib.h'],
|
|
lib='jpeg', use='libm'),
|
|
}, {
|
|
'name': '--direct3d',
|
|
'desc': 'Direct3D support',
|
|
'deps': 'win32-desktop && gpl',
|
|
'func': check_cc(header_name='d3d9.h'),
|
|
}, {
|
|
'name': 'shaderc-shared',
|
|
'desc': 'libshaderc SPIR-V compiler (shared library)',
|
|
'deps': '!static-build',
|
|
'groups': ['shaderc'],
|
|
'func': check_cc(header_name='shaderc/shaderc.h', lib='shaderc_shared'),
|
|
}, {
|
|
'name': 'shaderc-static',
|
|
'desc': 'libshaderc SPIR-V compiler (static library)',
|
|
'deps': '!shaderc-shared',
|
|
'groups': ['shaderc'],
|
|
'func': check_cc(header_name='shaderc/shaderc.h',
|
|
lib=['shaderc_combined', 'stdc++']),
|
|
}, {
|
|
'name': '--shaderc',
|
|
'desc': 'libshaderc SPIR-V compiler',
|
|
'deps': 'shaderc-shared || shaderc-static',
|
|
'func': check_true,
|
|
}, {
|
|
'name': 'spirv-cross-shared',
|
|
'desc': 'SPIRV-Cross SPIR-V shader converter (shared library)',
|
|
'deps': '!static-build',
|
|
'groups': ['spirv-cross'],
|
|
'func': check_pkg_config('spirv-cross-c-shared'),
|
|
}, {
|
|
'name': 'spirv-cross-static',
|
|
'desc': 'SPIRV-Cross SPIR-V shader converter (static library)',
|
|
'deps': '!spirv-cross-shared',
|
|
'groups': ['spirv-cross'],
|
|
'func': check_pkg_config('spirv-cross'),
|
|
}, {
|
|
'name': '--spirv-cross',
|
|
'desc': 'SPIRV-Cross SPIR-V shader converter',
|
|
'deps': 'spirv-cross-shared || spirv-cross-static',
|
|
'func': check_true,
|
|
}, {
|
|
'name': '--d3d11',
|
|
'desc': 'Direct3D 11 video output',
|
|
'deps': 'win32-desktop && shaderc && spirv-cross',
|
|
'func': check_cc(header_name=['d3d11_1.h', 'dxgi1_6.h']),
|
|
}, {
|
|
'name': '--rpi',
|
|
'desc': 'Raspberry Pi support',
|
|
'func': check_pkg_config('brcmegl'),
|
|
} , {
|
|
'name': '--ios-gl',
|
|
'desc': 'iOS OpenGL ES hardware decoding interop support',
|
|
'func': check_statement('OpenGLES/ES3/glext.h', '(void)GL_RGB32F'), # arbitrary OpenGL ES 3.0 symbol
|
|
} , {
|
|
'name': '--plain-gl',
|
|
'desc': 'OpenGL without platform-specific code (e.g. for libmpv)',
|
|
'deps': 'libmpv-shared || libmpv-static',
|
|
'func': check_true,
|
|
}, {
|
|
'name': '--gl',
|
|
'desc': 'OpenGL context support',
|
|
'deps': 'gl-cocoa || gl-x11 || egl-x11 || egl-drm || '
|
|
+ 'gl-win32 || gl-wayland || rpi || '
|
|
+ 'plain-gl',
|
|
'func': check_true,
|
|
'req': True,
|
|
'fmsg': "No OpenGL video output found or enabled. " +
|
|
"Aborting. If you really mean to compile without OpenGL " +
|
|
"video outputs use --disable-gl.",
|
|
}, {
|
|
'name': '--libplacebo',
|
|
'desc': 'libplacebo support',
|
|
'func': check_pkg_config('libplacebo >= 1.18.0'),
|
|
}, {
|
|
'name': '--vulkan',
|
|
'desc': 'Vulkan context support',
|
|
'deps': 'libplacebo',
|
|
'func': check_pkg_config('vulkan'),
|
|
}, {
|
|
'name': 'vaapi-vulkan',
|
|
'desc': 'VAAPI Vulkan',
|
|
'deps': 'vaapi && vulkan',
|
|
'func': check_true,
|
|
}, {
|
|
'name': 'egl-helpers',
|
|
'desc': 'EGL helper functions',
|
|
'deps': 'egl-x11 || rpi || gl-wayland || egl-drm || ' +
|
|
'egl-angle-win32 || egl-android',
|
|
'func': check_true
|
|
}
|
|
]
|
|
|
|
hwaccel_features = [
|
|
{
|
|
'name': 'videotoolbox-hwaccel',
|
|
'desc': 'libavcodec videotoolbox hwaccel',
|
|
'deps': 'gl-cocoa || ios-gl',
|
|
'func': check_true,
|
|
}, {
|
|
'name': '--videotoolbox-gl',
|
|
'desc': 'Videotoolbox with OpenGL',
|
|
'deps': 'gl-cocoa && videotoolbox-hwaccel',
|
|
'func': check_true
|
|
}, {
|
|
'name': '--d3d-hwaccel',
|
|
'desc': 'D3D11VA hwaccel',
|
|
'deps': 'os-win32',
|
|
'func': check_true,
|
|
}, {
|
|
'name': '--d3d9-hwaccel',
|
|
'desc': 'DXVA2 hwaccel',
|
|
'deps': 'd3d-hwaccel',
|
|
'func': check_true,
|
|
}, {
|
|
'name': '--gl-dxinterop-d3d9',
|
|
'desc': 'OpenGL/DirectX Interop Backend DXVA2 interop',
|
|
'deps': 'gl-dxinterop && d3d9-hwaccel',
|
|
'groups': [ 'gl' ],
|
|
'func': check_true,
|
|
}, {
|
|
'name': 'ffnvcodec',
|
|
'desc': 'CUDA Headers and dynamic loader',
|
|
'func': check_pkg_config('ffnvcodec >= 8.2.15.7'),
|
|
}, {
|
|
'name': '--cuda-hwaccel',
|
|
'desc': 'CUDA acceleration',
|
|
'deps': 'ffnvcodec',
|
|
'func': check_true,
|
|
}, {
|
|
'name': '--cuda-interop',
|
|
'desc': 'CUDA with graphics interop',
|
|
'deps': '(gl || vulkan) && cuda-hwaccel',
|
|
'func': check_true,
|
|
}, {
|
|
'name': '--rpi-mmal',
|
|
'desc': 'Raspberry Pi MMAL hwaccel',
|
|
'deps': 'rpi',
|
|
'func': check_pkg_config('mmal'),
|
|
}
|
|
]
|
|
|
|
standalone_features = [
|
|
{
|
|
'name': 'win32-executable',
|
|
'desc': 'w32 executable',
|
|
'deps': 'os-win32 || !(!(os-cygwin))',
|
|
'func': check_ctx_vars('WINDRES')
|
|
}, {
|
|
'name': '--macos-touchbar',
|
|
'desc': 'macOS Touch Bar support',
|
|
'deps': 'cocoa',
|
|
'func': check_cc(
|
|
fragment=load_fragment('touchbar.m'),
|
|
framework_name=['AppKit'],
|
|
compile_filename='test-touchbar.m',
|
|
linkflags='-fobjc-arc')
|
|
}, {
|
|
'name': '--macos-10-11-features',
|
|
'desc': 'macOS 10.11 SDK Features',
|
|
'deps': 'cocoa',
|
|
'func': check_macos_sdk('10.11')
|
|
}, {
|
|
'name': '--macos-10-12-2-features',
|
|
'desc': 'macOS 10.12.2 SDK Features',
|
|
'deps': 'cocoa',
|
|
'func': check_macos_sdk('10.12.2')
|
|
}, {
|
|
'name': '--macos-10-14-features',
|
|
'desc': 'macOS 10.14 SDK Features',
|
|
'deps': 'cocoa',
|
|
'func': check_macos_sdk('10.14')
|
|
},{
|
|
'name': '--macos-media-player',
|
|
'desc': 'macOS Media Player support',
|
|
'deps': 'macos-10-12-2-features && swift',
|
|
'func': check_true
|
|
}, {
|
|
'name': '--macos-cocoa-cb',
|
|
'desc': 'macOS libmpv backend',
|
|
'deps': 'cocoa && swift',
|
|
'func': check_true
|
|
}
|
|
]
|
|
|
|
_INSTALL_DIRS_LIST = [
|
|
('confdir', '${SYSCONFDIR}/mpv', 'configuration files'),
|
|
('zshdir', '${DATADIR}/zsh/site-functions', 'zsh completion functions'),
|
|
('confloaddir', '${CONFDIR}', 'configuration files load directory'),
|
|
('bashdir', '${DATADIR}/bash-completion/completions', 'bash completion functions'),
|
|
]
|
|
|
|
def options(opt):
|
|
opt.load('compiler_c')
|
|
opt.load('waf_customizations')
|
|
opt.load('features')
|
|
opt.load('gnu_dirs')
|
|
|
|
#remove unused options from gnu_dirs
|
|
opt.parser.remove_option("--sbindir")
|
|
opt.parser.remove_option("--libexecdir")
|
|
opt.parser.remove_option("--sharedstatedir")
|
|
opt.parser.remove_option("--localstatedir")
|
|
opt.parser.remove_option("--oldincludedir")
|
|
opt.parser.remove_option("--infodir")
|
|
opt.parser.remove_option("--localedir")
|
|
opt.parser.remove_option("--dvidir")
|
|
opt.parser.remove_option("--pdfdir")
|
|
opt.parser.remove_option("--psdir")
|
|
|
|
libdir = opt.parser.get_option('--libdir')
|
|
if libdir:
|
|
# Replace any mention of lib64 as we keep the default
|
|
# for libdir the same as before the waf update.
|
|
libdir.help = libdir.help.replace('lib64', 'lib')
|
|
|
|
group = opt.get_option_group("Installation directories")
|
|
for ident, default, desc in _INSTALL_DIRS_LIST:
|
|
group.add_option('--{0}'.format(ident),
|
|
type = 'string',
|
|
dest = ident,
|
|
default = default,
|
|
help = 'directory for installing {0} [{1}]' \
|
|
.format(desc, default.replace('${','').replace('}','')))
|
|
|
|
group = opt.get_option_group("build and install options")
|
|
group.add_option('--variant',
|
|
default = '',
|
|
help = 'variant name for saving configuration and build results')
|
|
|
|
opt.parse_features('build and install options', build_options)
|
|
optional_features = main_dependencies + libav_dependencies
|
|
opt.parse_features('optional features', optional_features)
|
|
opt.parse_features('audio outputs', audio_output_features)
|
|
opt.parse_features('video outputs', video_output_features)
|
|
opt.parse_features('hwaccels', hwaccel_features)
|
|
opt.parse_features('standalone app', standalone_features)
|
|
|
|
group = opt.get_option_group("optional features")
|
|
group.add_option('--lua',
|
|
type = 'string',
|
|
dest = 'LUA_VER',
|
|
help = "select Lua package which should be autodetected. Choices: 51 51deb 51obsd 51fbsd 52 52deb 52arch 52fbsd luajit")
|
|
group.add_option('--swift-flags',
|
|
type = 'string',
|
|
dest = 'SWIFT_FLAGS',
|
|
help = "Optional Swift compiler flags")
|
|
|
|
@conf
|
|
def is_optimization(ctx):
|
|
return getattr(ctx.options, 'enable_optimize')
|
|
|
|
@conf
|
|
def is_debug_build(ctx):
|
|
return getattr(ctx.options, 'enable_debug-build')
|
|
|
|
def configure(ctx):
|
|
from waflib import Options
|
|
ctx.resetenv(ctx.options.variant)
|
|
ctx.check_waf_version(mini='1.8.4')
|
|
target = os.environ.get('TARGET')
|
|
(cc, pkg_config, ar, windres) = ('cc', 'pkg-config', 'ar', 'windres')
|
|
|
|
if target:
|
|
cc = '-'.join([target, 'gcc'])
|
|
pkg_config = '-'.join([target, pkg_config])
|
|
ar = '-'.join([target, ar])
|
|
windres = '-'.join([target, windres])
|
|
|
|
ctx.find_program(cc, var='CC')
|
|
ctx.find_program(pkg_config, var='PKG_CONFIG')
|
|
ctx.find_program(ar, var='AR')
|
|
ctx.find_program('rst2html', var='RST2HTML', mandatory=False)
|
|
ctx.find_program('rst2man', var='RST2MAN', mandatory=False)
|
|
ctx.find_program('rst2pdf', var='RST2PDF', mandatory=False)
|
|
ctx.find_program(windres, var='WINDRES', mandatory=False)
|
|
ctx.find_program('perl', var='BIN_PERL', mandatory=False)
|
|
|
|
ctx.add_os_flags('LIBRARY_PATH')
|
|
|
|
ctx.load('compiler_c')
|
|
ctx.load('waf_customizations')
|
|
ctx.load('dependencies')
|
|
ctx.load('detections.compiler_swift')
|
|
ctx.load('detections.compiler')
|
|
ctx.load('detections.devices')
|
|
ctx.load('gnu_dirs')
|
|
|
|
# if libdir is not set in command line options,
|
|
# override the gnu_dirs default in order to
|
|
# always have `lib/` as the library directory.
|
|
if not getattr(Options.options, 'LIBDIR', None):
|
|
ctx.env['LIBDIR'] = Utils.subst_vars(os.path.join('${EXEC_PREFIX}', 'lib'), ctx.env)
|
|
|
|
for ident, _, _ in _INSTALL_DIRS_LIST:
|
|
varname = ident.upper()
|
|
ctx.env[varname] = getattr(ctx.options, ident)
|
|
|
|
# keep substituting vars, until the paths are fully expanded
|
|
while re.match('\$\{([^}]+)\}', ctx.env[varname]):
|
|
ctx.env[varname] = Utils.subst_vars(ctx.env[varname], ctx.env)
|
|
|
|
ctx.parse_dependencies(build_options)
|
|
ctx.parse_dependencies(main_dependencies)
|
|
ctx.parse_dependencies(libav_dependencies)
|
|
ctx.parse_dependencies(audio_output_features)
|
|
ctx.parse_dependencies(video_output_features)
|
|
ctx.parse_dependencies(hwaccel_features)
|
|
|
|
if ctx.options.LUA_VER:
|
|
ctx.options.enable_lua = True
|
|
|
|
if ctx.options.SWIFT_FLAGS:
|
|
ctx.env.SWIFT_FLAGS.extend(split(ctx.options.SWIFT_FLAGS))
|
|
|
|
ctx.parse_dependencies(standalone_features)
|
|
|
|
ctx.load('generators.headers')
|
|
|
|
if not ctx.dependency_satisfied('build-date'):
|
|
ctx.env.CFLAGS += ['-DNO_BUILD_TIMESTAMPS']
|
|
|
|
if ctx.dependency_satisfied('clang-database'):
|
|
ctx.load('clang_compilation_database')
|
|
|
|
if ctx.dependency_satisfied('cplugins'):
|
|
# We need to export the libmpv symbols, since the mpv binary itself is
|
|
# not linked against libmpv. The C plugin needs to be able to pick
|
|
# up the libmpv symbols from the binary. We still restrict the set
|
|
# of exported symbols via mpv.def.
|
|
ctx.env.LINKFLAGS += ['-rdynamic']
|
|
|
|
ctx.store_dependencies_lists()
|
|
|
|
def __write_version__(ctx):
|
|
ctx.env.VERSIONH_ST = '--versionh="%s"'
|
|
ctx.env.CWD_ST = '--cwd="%s"'
|
|
ctx.env.VERSIONSH_CWD = [ctx.srcnode.abspath()]
|
|
|
|
ctx(
|
|
source = 'version.sh',
|
|
target = 'version.h',
|
|
rule = 'sh ${SRC} ${CWD_ST:VERSIONSH_CWD} ${VERSIONH_ST:TGT}',
|
|
always = True,
|
|
update_outputs = True)
|
|
|
|
def build(ctx):
|
|
if ctx.options.variant not in ctx.all_envs:
|
|
from waflib import Errors
|
|
raise Errors.WafError(
|
|
'The project was not configured: run "waf --variant={0} configure" first!'
|
|
.format(ctx.options.variant))
|
|
ctx.unpack_dependencies_lists()
|
|
ctx.add_group('versionh')
|
|
ctx.add_group('sources')
|
|
|
|
ctx.set_group('versionh')
|
|
__write_version__(ctx)
|
|
ctx.set_group('sources')
|
|
ctx.load('wscript_build')
|
|
|
|
def init(ctx):
|
|
from waflib.Build import BuildContext, CleanContext, InstallContext, UninstallContext
|
|
for y in (BuildContext, CleanContext, InstallContext, UninstallContext):
|
|
class tmp(y):
|
|
variant = ctx.options.variant
|
|
|
|
# This is needed because waf initializes the ConfigurationContext with
|
|
# an arbitrary setenv('') which would rewrite the previous configuration
|
|
# cache for the default variant if the configure step finishes.
|
|
# Ideally ConfigurationContext should just let us override this at class
|
|
# level like the other Context subclasses do with variant
|
|
from waflib.Configure import ConfigurationContext
|
|
class cctx(ConfigurationContext):
|
|
def resetenv(self, name):
|
|
self.all_envs = {}
|
|
self.setenv(name)
|