ffmpeg/configure

4501 lines
135 KiB
Bash
Executable File

#!/bin/sh
#
# FFmpeg configure script
#
# Copyright (c) 2000-2002 Fabrice Bellard
# Copyright (c) 2005-2008 Diego Biurrun
# Copyright (c) 2005-2008 Mans Rullgard
#
# Prevent locale nonsense from breaking basic text processing.
LC_ALL=C
export LC_ALL
# make sure we are running under a compatible shell
# try to make this part work with most shells
try_exec(){
echo "Trying shell $1"
type "$1" > /dev/null 2>&1 && exec "$@"
}
unset foo
(: ${foo%%bar}) 2> /dev/null
E1="$?"
(: ${foo?}) 2> /dev/null
E2="$?"
if test "$E1" != 0 || test "$E2" = 0; then
echo "Broken shell detected. Trying alternatives."
export FF_CONF_EXEC
if test "0$FF_CONF_EXEC" -lt 1; then
FF_CONF_EXEC=1
try_exec bash "$0" "$@"
fi
if test "0$FF_CONF_EXEC" -lt 2; then
FF_CONF_EXEC=2
try_exec ksh "$0" "$@"
fi
if test "0$FF_CONF_EXEC" -lt 3; then
FF_CONF_EXEC=3
try_exec /usr/xpg4/bin/sh "$0" "$@"
fi
echo "No compatible shell script interpreter found."
echo "This configure script requires a POSIX-compatible shell"
echo "such as bash or ksh."
echo "THIS IS NOT A BUG IN FFMPEG, DO NOT REPORT IT AS SUCH."
echo "Instead, install a working POSIX-compatible shell."
echo "Disabling this configure test will create a broken FFmpeg."
if test "$BASH_VERSION" = '2.04.0(1)-release'; then
echo "This bash version ($BASH_VERSION) is broken on your platform."
echo "Upgrade to a later version if available."
fi
exit 1
fi
test -d /usr/xpg4/bin && PATH=/usr/xpg4/bin:$PATH
show_help(){
cat <<EOF
Usage: configure [options]
Options: [defaults in brackets after descriptions]
Help options:
--help print this message
--list-decoders show all available decoders
--list-encoders show all available encoders
--list-hwaccels show all available hardware accelerators
--list-demuxers show all available demuxers
--list-muxers show all available muxers
--list-parsers show all available parsers
--list-protocols show all available protocols
--list-bsfs show all available bitstream filters
--list-indevs show all available input devices
--list-outdevs show all available output devices
--list-filters show all available filters
Standard options:
--logfile=FILE log tests and output to FILE [config.log]
--disable-logging do not log configure debug information
--fatal-warnings fail if any configure warning is generated
--prefix=PREFIX install in PREFIX [$prefix]
--bindir=DIR install binaries in DIR [PREFIX/bin]
--datadir=DIR install data files in DIR [PREFIX/share/ffmpeg]
--libdir=DIR install libs in DIR [PREFIX/lib]
--shlibdir=DIR install shared libs in DIR [PREFIX/lib]
--incdir=DIR install includes in DIR [PREFIX/include]
--mandir=DIR install man page in DIR [PREFIX/share/man]
Licensing options:
--enable-gpl allow use of GPL code, the resulting libs
and binaries will be under GPL [no]
--enable-version3 upgrade (L)GPL to version 3 [no]
--enable-nonfree allow use of nonfree code, the resulting libs
and binaries will be unredistributable [no]
Configuration options:
--disable-static do not build static libraries [no]
--enable-shared build shared libraries [no]
--enable-small optimize for size instead of speed
--disable-runtime-cpudetect disable detecting cpu capabilities at runtime (smaller binary)
--enable-gray enable full grayscale support (slower color)
--disable-swscale-alpha disable alpha channel support in swscale
Program options:
--disable-programs do not build command line programs
--disable-ffmpeg disable ffmpeg build
--disable-ffplay disable ffplay build
--disable-ffprobe disable ffprobe build
--disable-ffserver disable ffserver build
Documentation options:
--disable-doc do not build documentation
--disable-htmlpages do not build HTML documentation pages
--disable-manpages do not build man documentation pages
--disable-podpages do not build POD documentation pages
--disable-txtpages do not build text documentation pages
Component options:
--disable-avdevice disable libavdevice build
--disable-avcodec disable libavcodec build
--disable-avformat disable libavformat build
--disable-swresample disable libswresample build
--disable-swscale disable libswscale build
--disable-postproc disable libpostproc build
--disable-avfilter disable libavfilter build
--enable-avresample enable libavresample build [no]
--disable-pthreads disable pthreads [auto]
--disable-w32threads disable Win32 threads [auto]
--disable-os2threads disable OS/2 threads [auto]
--enable-x11grab enable X11 grabbing [no]
--disable-network disable network support [no]
--disable-dct disable DCT code
--disable-dwt disable DWT code
--disable-lsp disable LSP code
--disable-lzo disable LZO decoder code
--disable-mdct disable MDCT code
--disable-rdft disable RDFT code
--disable-fft disable FFT code
--enable-dxva2 enable DXVA2 code
--enable-vaapi enable VAAPI code [autodetect]
--enable-vda enable VDA code [autodetect]
--enable-vdpau enable VDPAU code [autodetect]
Individual component options:
--disable-everything disable all components listed below
--disable-encoder=NAME disable encoder NAME
--enable-encoder=NAME enable encoder NAME
--disable-encoders disable all encoders
--disable-decoder=NAME disable decoder NAME
--enable-decoder=NAME enable decoder NAME
--disable-decoders disable all decoders
--disable-hwaccel=NAME disable hwaccel NAME
--enable-hwaccel=NAME enable hwaccel NAME
--disable-hwaccels disable all hwaccels
--disable-muxer=NAME disable muxer NAME
--enable-muxer=NAME enable muxer NAME
--disable-muxers disable all muxers
--disable-demuxer=NAME disable demuxer NAME
--enable-demuxer=NAME enable demuxer NAME
--disable-demuxers disable all demuxers
--enable-parser=NAME enable parser NAME
--disable-parser=NAME disable parser NAME
--disable-parsers disable all parsers
--enable-bsf=NAME enable bitstream filter NAME
--disable-bsf=NAME disable bitstream filter NAME
--disable-bsfs disable all bitstream filters
--enable-protocol=NAME enable protocol NAME
--disable-protocol=NAME disable protocol NAME
--disable-protocols disable all protocols
--enable-indev=NAME enable input device NAME
--disable-indev=NAME disable input device NAME
--disable-indevs disable input devices
--enable-outdev=NAME enable output device NAME
--disable-outdev=NAME disable output device NAME
--disable-outdevs disable output devices
--disable-devices disable all devices
--enable-filter=NAME enable filter NAME
--disable-filter=NAME disable filter NAME
--disable-filters disable all filters
External library support:
--enable-avisynth enable reading of AVISynth script files [no]
--enable-bzlib enable bzlib [autodetect]
--enable-fontconfig enable fontconfig
--enable-frei0r enable frei0r video filtering
--enable-gnutls enable gnutls [no]
--enable-libaacplus enable AAC+ encoding via libaacplus [no]
--enable-libass enable libass subtitles rendering [no]
--enable-libbluray enable BluRay reading using libbluray [no]
--enable-libcaca enable textual display using libcaca
--enable-libcelt enable CELT decoding via libcelt [no]
--enable-libcdio enable audio CD grabbing with libcdio
--enable-libdc1394 enable IIDC-1394 grabbing using libdc1394
and libraw1394 [no]
--enable-libfaac enable AAC encoding via libfaac [no]
--enable-libfdk-aac enable AAC encoding via libfdk-aac [no]
--enable-libflite enable flite (voice synthesis) support via libflite [no]
--enable-libfreetype enable libfreetype [no]
--enable-libgsm enable GSM de/encoding via libgsm [no]
--enable-libiec61883 enable iec61883 via libiec61883 [no]
--enable-libilbc enable iLBC de/encoding via libilbc [no]
--enable-libmodplug enable ModPlug via libmodplug [no]
--enable-libmp3lame enable MP3 encoding via libmp3lame [no]
--enable-libnut enable NUT (de)muxing via libnut,
native (de)muxer exists [no]
--enable-libopencore-amrnb enable AMR-NB de/encoding via libopencore-amrnb [no]
--enable-libopencore-amrwb enable AMR-WB decoding via libopencore-amrwb [no]
--enable-libopencv enable video filtering via libopencv [no]
--enable-libopenjpeg enable JPEG 2000 de/encoding via OpenJPEG [no]
--enable-libopus enable Opus decoding via libopus [no]
--enable-libpulse enable Pulseaudio input via libpulse [no]
--enable-librtmp enable RTMP[E] support via librtmp [no]
--enable-libschroedinger enable Dirac de/encoding via libschroedinger [no]
--enable-libspeex enable Speex de/encoding via libspeex [no]
--enable-libstagefright-h264 enable H.264 decoding via libstagefright [no]
--enable-libtheora enable Theora encoding via libtheora [no]
--enable-libtwolame enable MP2 encoding via libtwolame [no]
--enable-libutvideo enable Ut Video encoding and decoding via libutvideo [no]
--enable-libv4l2 enable libv4l2/v4l-utils [no]
--enable-libvo-aacenc enable AAC encoding via libvo-aacenc [no]
--enable-libvo-amrwbenc enable AMR-WB encoding via libvo-amrwbenc [no]
--enable-libvorbis enable Vorbis en/decoding via libvorbis,
native implementation exists [no]
--enable-libvpx enable VP8 de/encoding via libvpx [no]
--enable-libx264 enable H.264 encoding via x264 [no]
--enable-libxavs enable AVS encoding via xavs [no]
--enable-libxvid enable Xvid encoding via xvidcore,
native MPEG-4/Xvid encoder exists [no]
--enable-openal enable OpenAL 1.1 capture support [no]
--enable-openssl enable openssl [no]
--enable-zlib enable zlib [autodetect]
Advanced options (experts only):
--cross-prefix=PREFIX use PREFIX for compilation tools [$cross_prefix]
--enable-cross-compile assume a cross-compiler is used
--sysroot=PATH root of cross-build tree
--sysinclude=PATH location of cross-build system headers
--target-os=OS compiler targets OS [$target_os]
--target-exec=CMD command to run executables on target
--target-path=DIR path to view of build directory on target
--toolchain=NAME set tool defaults according to NAME
--nm=NM use nm tool NM [$nm_default]
--ar=AR use archive tool AR [$ar_default]
--as=AS use assembler AS [$as_default]
--yasmexe=EXE use yasm-compatible assembler EXE [$yasmexe_default]
--cc=CC use C compiler CC [$cc_default]
--cxx=CXX use C compiler CXX [$cxx_default]
--dep-cc=DEPCC use dependency generator DEPCC [$cc_default]
--ld=LD use linker LD [$ld_default]
--host-cc=HOSTCC use host C compiler HOSTCC
--host-cflags=HCFLAGS use HCFLAGS when compiling for host
--host-ld=HOSTLD use host linker HOSTLD
--host-ldflags=HLDFLAGS use HLDFLAGS when linking for host
--host-libs=HLIBS use libs HLIBS when linking for host
--host-os=OS compiler host OS [$target_os]
--extra-cflags=ECFLAGS add ECFLAGS to CFLAGS [$CFLAGS]
--extra-cxxflags=ECFLAGS add ECFLAGS to CXXFLAGS [$CXXFLAGS]
--extra-ldflags=ELDFLAGS add ELDFLAGS to LDFLAGS [$LDFLAGS]
--extra-libs=ELIBS add ELIBS [$ELIBS]
--extra-version=STRING version string suffix []
--optflags=OPTFLAGS override optimization-related compiler flags
--build-suffix=SUFFIX library name suffix []
--malloc-prefix=PREFIX prefix malloc and related names with PREFIX
--progs-suffix=SUFFIX program name suffix []
--arch=ARCH select architecture [$arch]
--cpu=CPU select the minimum required CPU (affects
instruction selection, may crash on older CPUs)
--enable-pic build position-independent code
--enable-sram allow use of on-chip SRAM
--enable-thumb compile for Thumb instruction set
--disable-symver disable symbol versioning
--enable-hardcoded-tables use hardcoded tables instead of runtime generation
--disable-safe-bitstream-reader
disable buffer boundary checking in bitreaders
(faster, but may crash)
--enable-memalign-hack emulate memalign, interferes with memory debuggers
--enable-lto use link-time optimization
Optimization options (experts only):
--disable-asm disable all assembler optimizations
--disable-altivec disable AltiVec optimizations
--disable-amd3dnow disable 3DNow! optimizations
--disable-amd3dnowext disable 3DNow! extended optimizations
--disable-mmx disable MMX optimizations
--disable-mmxext disable MMXEXT optimizations
--disable-sse disable SSE optimizations
--disable-sse2 disable SSE2 optimizations
--disable-sse3 disable SSE3 optimizations
--disable-ssse3 disable SSSE3 optimizations
--disable-sse4 disable SSE4 optimizations
--disable-sse42 disable SSE4.2 optimizations
--disable-avx disable AVX optimizations
--disable-fma4 disable FMA4 optimizations
--disable-armv5te disable armv5te optimizations
--disable-armv6 disable armv6 optimizations
--disable-armv6t2 disable armv6t2 optimizations
--disable-armvfp disable ARM VFP optimizations
--disable-neon disable NEON optimizations
--disable-vis disable VIS optimizations
--disable-inline-asm disable use of inline assembler
--disable-yasm disable use of yasm assembler
--disable-mips32r2 disable MIPS32R2 optimizations
--disable-mipsdspr1 disable MIPS DSP ASE R1 optimizations
--disable-mipsdspr2 disable MIPS DSP ASE R2 optimizations
--disable-mipsfpu disable floating point MIPS optimizations
--disable-fast-unaligned consider unaligned accesses slow
--postproc-version=V build libpostproc version V.
Where V can be '$ALT_PP_VER_MAJOR.$ALT_PP_VER_MINOR.$ALT_PP_VER_MICRO' or 'current'. [$postproc_version_default]
Developer options (useful when working on FFmpeg itself):
--enable-coverage build with test coverage instrumentation
--disable-debug disable debugging symbols
--enable-debug=LEVEL set the debug level [$debuglevel]
--disable-optimizations disable compiler optimizations
--enable-extra-warnings enable more compiler warnings
--disable-stripping disable stripping of executables and shared libraries
--assert-level=level 0(default), 1 or 2, amount of assertion testing,
2 causes a slowdown at runtime.
--enable-memory-poisoning fill heap uninitialized allocated space with arbitrary data
--valgrind=VALGRIND run "make fate" tests through valgrind to detect memory
leaks and errors, using the specified valgrind binary.
Cannot be combined with --target-exec
--enable-ftrapv Trap arithmetic overflows
--samples=PATH location of test samples for FATE, if not set use
\$FATE_SAMPLES at make invocation time.
--enable-xmm-clobber-test check XMM registers for clobbering (Win64-only;
should be used only for debugging purposes)
--enable-random randomly enable/disable components
--disable-random
--enable-random=LIST randomly enable/disable specific components or
--disable-random=LIST component groups. LIST is a comma-separated list
of NAME[:PROB] entries where NAME is a component
(group) and PROB the probability associated with
NAME (default 0.5).
--random-seed=VALUE seed value for --enable/disable-random
NOTE: Object files are built at the place where configure is launched.
EOF
exit 0
}
quotes='""'
log(){
echo "$@" >> $logfile
}
log_file(){
log BEGIN $1
pr -n -t $1 >> $logfile
log END $1
}
echolog(){
log "$@"
echo "$@"
}
warn(){
log "WARNING: $*"
WARNINGS="${WARNINGS}WARNING: $*\n"
}
die(){
echolog "$@"
cat <<EOF
If you think configure made a mistake, make sure you are using the latest
version from Git. If the latest version fails, report the problem to the
ffmpeg-user@ffmpeg.org mailing list or IRC #ffmpeg on irc.freenode.net.
EOF
if disabled logging; then
cat <<EOF
Rerun configure with logging enabled (do not use --disable-logging), and
include the log this produces with your report.
EOF
else
cat <<EOF
Include the log file "$logfile" produced by configure as this will help
solving the problem.
EOF
fi
exit 1
}
# Avoid locale weirdness, besides we really just want to translate ASCII.
toupper(){
echo "$@" | tr abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ
}
tolower(){
echo "$@" | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz
}
c_escape(){
echo "$*" | sed 's/["\\]/\\\0/g'
}
sh_quote(){
v=$(echo "$1" | sed "s/'/'\\\\''/g")
test "x$v" = "x${v#*[!A-Za-z0-9_/.+-]}" || v="'$v'"
echo "$v"
}
cleanws(){
echo "$@" | sed 's/^ *//;s/ */ /g;s/ *$//'
}
filter(){
pat=$1
shift
for v; do
eval "case $v in $pat) echo $v ;; esac"
done
}
filter_out(){
pat=$1
shift
for v; do
eval "case $v in $pat) ;; *) echo $v ;; esac"
done
}
map(){
m=$1
shift
for v; do eval $m; done
}
add_suffix(){
suffix=$1
shift
for v; do echo ${v}${suffix}; done
}
set_all(){
value=$1
shift
for var in $*; do
eval $var=$value
done
}
set_weak(){
value=$1
shift
for var; do
eval : \${$var:=$value}
done
}
set_safe(){
var=$1
shift
eval $(echo "$var" | sed 's/[^A-Za-z0-9_]/_/g')='$*'
}
get_safe(){
eval echo \$$(echo "$1" | sed 's/[^A-Za-z0-9_]/_/g')
}
pushvar(){
for var in $*; do
eval level=\${${var}_level:=0}
eval ${var}_${level}="\$$var"
eval ${var}_level=$(($level+1))
done
}
popvar(){
for var in $*; do
eval level=\${${var}_level:-0}
test $level = 0 && continue
eval level=$(($level-1))
eval $var="\${${var}_${level}}"
eval ${var}_level=$level
eval unset ${var}_${level}
done
}
enable(){
set_all yes $*
}
disable(){
set_all no $*
}
enable_weak(){
set_weak yes $*
}
disable_weak(){
set_weak no $*
}
enable_safe(){
for var; do
enable $(echo "$var" | sed 's/[^A-Za-z0-9_]/_/g')
done
}
disable_safe(){
for var; do
disable $(echo "$var" | sed 's/[^A-Za-z0-9_]/_/g')
done
}
do_enable_deep(){
for var; do
enabled $var && continue
eval sel="\$${var}_select"
eval sgs="\$${var}_suggest"
pushvar var sgs
enable_deep $sel
popvar sgs
enable_deep_weak $sgs
popvar var
done
}
enable_deep(){
do_enable_deep $*
enable $*
}
enable_deep_weak(){
do_enable_deep $*
enable_weak $*
}
enabled(){
test "${1#!}" = "$1" && op== || op=!=
eval test "x\$${1#!}" $op "xyes"
}
disabled(){
test "${1#!}" = "$1" && op== || op=!=
eval test "x\$${1#!}" $op "xno"
}
enabled_all(){
for opt; do
enabled $opt || return 1
done
}
disabled_all(){
for opt; do
disabled $opt || return 1
done
}
enabled_any(){
for opt; do
enabled $opt && return 0
done
}
disabled_any(){
for opt; do
disabled $opt && return 0
done
return 1
}
set_default(){
for opt; do
eval : \${$opt:=\$${opt}_default}
done
}
is_in(){
value=$1
shift
for var in $*; do
[ $var = $value ] && return 0
done
return 1
}
check_deps(){
for cfg; do
cfg="${cfg#!}"
enabled ${cfg}_checking && die "Circular dependency for $cfg."
disabled ${cfg}_checking && continue
enable ${cfg}_checking
eval dep_all="\$${cfg}_deps"
eval dep_any="\$${cfg}_deps_any"
eval dep_sel="\$${cfg}_select"
eval dep_sgs="\$${cfg}_suggest"
eval dep_ifa="\$${cfg}_if"
eval dep_ifn="\$${cfg}_if_any"
pushvar cfg dep_all dep_any dep_sel dep_sgs dep_ifa dep_ifn
check_deps $dep_all $dep_any $dep_sel $dep_sgs $dep_ifa $dep_ifn
popvar cfg dep_all dep_any dep_sel dep_sgs dep_ifa dep_ifn
[ -n "$dep_ifa" ] && { enabled_all $dep_ifa && enable_weak $cfg; }
[ -n "$dep_ifn" ] && { enabled_any $dep_ifn && enable_weak $cfg; }
enabled_all $dep_all || disable $cfg
enabled_any $dep_any || disable $cfg
disabled_any $dep_sel && disable $cfg
if enabled $cfg; then
eval dep_extralibs="\$${cfg}_extralibs"
test -n "$dep_extralibs" && add_extralibs $dep_extralibs
enable_deep $dep_sel
enable_deep_weak $dep_sgs
fi
disable ${cfg}_checking
done
}
print_config(){
pfx=$1
files=$2
shift 2
map 'eval echo "$v \${$v:-no}"' "$@" |
awk "BEGIN { split(\"$files\", files) }
{
c = \"$pfx\" toupper(\$1);
v = \$2;
sub(/yes/, 1, v);
sub(/no/, 0, v);
for (f in files) {
file = files[f];
if (file ~ /\\.h\$/) {
printf(\"#define %s %d\\n\", c, v) >>file;
} else if (file ~ /\\.asm\$/) {
printf(\"%%define %s %d\\n\", c, v) >>file;
} else if (file ~ /\\.mak\$/) {
n = -v ? \"\" : \"!\";
printf(\"%s%s=yes\\n\", n, c) >>file;
}
}
}"
}
print_enabled(){
suf=$1
shift
for v; do
enabled $v && printf "%s\n" ${v%$suf};
done
}
append(){
var=$1
shift
eval "$var=\"\$$var $*\""
}
prepend(){
var=$1
shift
eval "$var=\"$* \$$var\""
}
add_cppflags(){
append CPPFLAGS "$@"
}
add_cflags(){
append CFLAGS $($cflags_filter "$@")
}
add_cxxflags(){
append CXXFLAGS $($cflags_filter "$@")
}
add_asflags(){
append ASFLAGS $($asflags_filter "$@")
}
add_ldflags(){
append LDFLAGS $($ldflags_filter "$@")
}
add_extralibs(){
prepend extralibs $($ldflags_filter "$@")
}
add_host_cflags(){
append host_cflags $($host_cflags_filter "$@")
}
add_host_ldflags(){
append host_ldflags $($host_ldflags_filter "$@")
}
add_compat(){
append compat_objs $1
shift
map 'add_cppflags -D$v' "$@"
}
check_cmd(){
log "$@"
"$@" >> $logfile 2>&1
}
cc_o(){
eval printf '%s\\n' $CC_O
}
cc_e(){
eval printf '%s\\n' $CC_E
}
check_cc(){
log check_cc "$@"
cat > $TMPC
log_file $TMPC
check_cmd $cc $CPPFLAGS $CFLAGS "$@" $CC_C $(cc_o $TMPO) $TMPC
}
check_cxx(){
log check_cxx "$@"
cat > $TMPCPP
log_file $TMPCPP
check_cmd $cxx $CPPFLAGS $CFLAGS $CXXFLAGS "$@" $CXX_C -o $TMPO $TMPCPP
}
check_cpp(){
log check_cpp "$@"
cat > $TMPC
log_file $TMPC
check_cmd $cc $CPPFLAGS $CFLAGS "$@" $(cc_e $TMPO) $TMPC
}
as_o(){
eval printf '%s\\n' $AS_O
}
check_as(){
log check_as "$@"
cat > $TMPC
log_file $TMPC
check_cmd $as $CPPFLAGS $ASFLAGS "$@" $AS_C $(as_o $TMPO) $TMPC
}
check_inline_asm(){
log check_inline_asm "$@"
name="$1"
code="$2"
shift 2
disable $name
check_as "$@" <<EOF && enable $name
void foo(void){ __asm__ volatile($code); }
EOF
}
check_yasm(){
log check_yasm "$@"
echo "$1" > $TMPS
log_file $TMPS
shift 1
check_cmd $yasmexe $YASMFLAGS -Werror "$@" -o $TMPO $TMPS
}
ld_o(){
eval printf '%s\\n' $LD_O
}
check_ld(){
log check_ld "$@"
type=$1
shift 1
flags=$(filter_out '-l*' $@)
libs=$(filter '-l*' $@)
check_$type $($cflags_filter $flags) || return
flags=$($ldflags_filter $flags)
libs=$($ldflags_filter $libs)
check_cmd $ld $LDFLAGS $flags $(ld_o $TMPE) $TMPO $libs $extralibs
}
check_code(){
log check_code "$@"
check=$1
headers=$2
code=$3
shift 3
{
for hdr in $headers; do
echo "#include <$hdr>"
done
echo "int main(void) { $code; return 0; }"
} | check_$check "$@"
}
check_cppflags(){
log check_cppflags "$@"
check_cc "$@" <<EOF && append CPPFLAGS "$@"
int x;
EOF
}
check_cflags(){
log check_cflags "$@"
set -- $($cflags_filter "$@")
check_cc "$@" <<EOF && append CFLAGS "$@"
int x;
EOF
}
check_cxxflags(){
log check_cxxflags "$@"
set -- $($cflags_filter "$@")
check_cxx "$@" <<EOF && append CXXFLAGS "$@"
int x;
EOF
}
test_ldflags(){
log test_ldflags "$@"
check_ld "cc" "$@" <<EOF
int main(void){ return 0; }
EOF
}
check_ldflags(){
log check_ldflags "$@"
test_ldflags "$@" && add_ldflags "$@"
}
check_header(){
log check_header "$@"
header=$1
shift
disable_safe $header
check_cpp "$@" <<EOF && enable_safe $header
#include <$header>
int x;
EOF
}
check_func(){
log check_func "$@"
func=$1
shift
disable $func
check_ld "cc" "$@" <<EOF && enable $func
extern int $func();
int main(void){ $func(); }
EOF
}
check_mathfunc(){
log check_mathfunc "$@"
func=$1
narg=$2
shift 2
test $narg = 2 && args="f, g" || args="f"
disable $func
check_ld "cc" "$@" <<EOF && enable $func
#include <math.h>
float foo(float f, float g) { return $func($args); }
int main(void){ return (int) foo; }
EOF
}
check_func_headers(){
log check_func_headers "$@"
headers=$1
funcs=$2
shift 2
{
for hdr in $headers; do
echo "#include <$hdr>"
done
for func in $funcs; do
echo "long check_$func(void) { return (long) $func; }"
done
echo "int main(void) { return 0; }"
} | check_ld "cc" "$@" && enable $funcs && enable_safe $headers
}
check_class_headers_cpp(){
log check_class_headers_cpp "$@"
headers=$1
classes=$2
shift 2
{
for hdr in $headers; do
echo "#include <$hdr>"
done
echo "int main(void) { "
i=1
for class in $classes; do
echo "$class obj$i;"
i=$(expr $i + 1)
done
echo "return 0; }"
} | check_ld "cxx" "$@" && enable $funcs && enable_safe $headers
}
check_cpp_condition(){
log check_cpp_condition "$@"
header=$1
condition=$2
shift 2
check_cpp "$@" <<EOF
#include <$header>
#if !($condition)
#error "unsatisfied condition: $condition"
#endif
EOF
}
check_lib(){
log check_lib "$@"
header="$1"
func="$2"
shift 2
check_header $header && check_func $func "$@" && add_extralibs "$@"
}
check_lib2(){
log check_lib2 "$@"
headers="$1"
funcs="$2"
shift 2
check_func_headers "$headers" "$funcs" "$@" && add_extralibs "$@"
}
check_lib_cpp(){
log check_lib_cpp "$@"
headers="$1"
classes="$2"
shift 2
check_class_headers_cpp "$headers" "$classes" "$@" && add_extralibs "$@"
}
check_pkg_config(){
log check_pkg_config "$@"
pkg="$1"
headers="$2"
funcs="$3"
shift 3
$pkg_config --exists $pkg 2>/dev/null || return
pkg_cflags=$($pkg_config --cflags $pkg)
pkg_libs=$($pkg_config --libs $pkg)
check_func_headers "$headers" "$funcs" $pkg_cflags $pkg_libs "$@" &&
set_safe ${pkg}_cflags $pkg_cflags &&
set_safe ${pkg}_libs $pkg_libs
}
check_exec(){
check_ld "cc" "$@" && { enabled cross_compile || $TMPE >> $logfile 2>&1; }
}
check_exec_crash(){
code=$(cat)
# exit() is not async signal safe. _Exit (C99) and _exit (POSIX)
# are safe but may not be available everywhere. Thus we use
# raise(SIGTERM) instead. The check is run in a subshell so we
# can redirect the "Terminated" message from the shell. SIGBUS
# is not defined by standard C so it is used conditionally.
(check_exec "$@") >> $logfile 2>&1 <<EOF
#include <signal.h>
static void sighandler(int sig){
raise(SIGTERM);
}
int func(void){
$code
}
int (*func_ptr)(void) = func;
int main(void){
signal(SIGILL, sighandler);
signal(SIGFPE, sighandler);
signal(SIGSEGV, sighandler);
#ifdef SIGBUS
signal(SIGBUS, sighandler);
#endif
return func_ptr();
}
EOF
}
check_type(){
log check_type "$@"
headers=$1
type=$2
shift 2
disable_safe "$type"
check_code cc "$headers" "$type v" "$@" && enable_safe "$type"
}
check_struct(){
log check_type "$@"
headers=$1
struct=$2
member=$3
shift 3
disable_safe "${struct}_${member}"
check_code cc "$headers" "const void *p = &(($struct *)0)->$member" "$@" &&
enable_safe "${struct}_${member}"
}
require(){
name="$1"
header="$2"
func="$3"
shift 3
check_lib $header $func "$@" || die "ERROR: $name not found"
}
require2(){
name="$1"
headers="$2"
func="$3"
shift 3
check_lib2 "$headers" $func "$@" || die "ERROR: $name not found"
}
require_cpp(){
name="$1"
headers="$2"
classes="$3"
shift 3
check_lib_cpp "$headers" "$classes" "$@" || die "ERROR: $name not found"
}
require_pkg_config(){
pkg="$1"
check_pkg_config "$@" || die "ERROR: $pkg not found"
add_cflags $(get_safe ${pkg}_cflags)
add_extralibs $(get_safe ${pkg}_libs)
}
hostcc_o(){
eval printf '%s\\n' $HOSTCC_O
}
check_host_cc(){
log check_host_cc "$@"
cat > $TMPC
log_file $TMPC
check_cmd $host_cc $host_cflags "$@" $HOSTCC_C $(hostcc_o $TMPO) $TMPC
}
check_host_cflags(){
log check_host_cflags "$@"
set -- $($host_cflags_filter "$@")
check_host_cc "$@" <<EOF && append host_cflags "$@"
int x;
EOF
}
apply(){
file=$1
shift
"$@" < "$file" > "$file.tmp" && mv "$file.tmp" "$file" || rm "$file.tmp"
}
cp_if_changed(){
cmp -s "$1" "$2" && echo "$2 is unchanged" && return
mkdir -p "$(dirname $2)"
$cp_f "$1" "$2"
}
# CONFIG_LIST contains configurable options, while HAVE_LIST is for
# system-dependent things.
COMPONENT_LIST="
bsfs
decoders
demuxers
encoders
filters
hwaccels
indevs
muxers
outdevs
parsers
protocols
"
DOCUMENT_LIST="
doc
htmlpages
manpages
podpages
txtpages
"
PROGRAM_LIST="
ffplay
ffprobe
ffserver
ffmpeg
"
CONFIG_LIST="
$COMPONENT_LIST
$DOCUMENT_LIST
$PROGRAM_LIST
avcodec
avdevice
avfilter
avformat
avresample
avisynth
bzlib
crystalhd
dct
dwt
dxva2
fast_unaligned
fft
fontconfig
frei0r
ftrapv
gnutls
gpl
gray
hardcoded_tables
incompatible_fork_abi
libaacplus
libass
libbluray
libcaca
libcdio
libcelt
libdc1394
libfaac
libfdk_aac
libflite
libfreetype
libgsm
libiec61883
libilbc
libmodplug
libmp3lame
libnut
libopencore_amrnb
libopencore_amrwb
libopencv
libopenjpeg
libopus
libpulse
librtmp
libschroedinger
libspeex
libstagefright_h264
libtheora
libtwolame
libutvideo
libv4l2
libvo_aacenc
libvo_amrwbenc
libvorbis
libvpx
libx264
libxavs
libxvid
lsp
lzo
mdct
memalign_hack
memory_poisoning
network
nonfree
openal
openssl
pic
postproc
rdft
runtime_cpudetect
safe_bitstream_reader
shared
small
sram
static
swresample
swscale
swscale_alpha
thumb
vaapi
vda
vdpau
version3
xmm_clobber_test
x11grab
zlib
"
THREADS_LIST='
pthreads
w32threads
os2threads
'
ARCH_LIST='
aarch64
alpha
arm
avr32
avr32_ap
avr32_uc
bfin
ia64
m68k
mips
mips64
parisc
ppc
ppc64
s390
sh4
sparc
sparc64
tilegx
tilepro
tomi
x86
x86_32
x86_64
'
ARCH_EXT_LIST_X86='
amd3dnow
amd3dnowext
avx
fma4
mmx
mmxext
sse
sse2
sse3
sse4
sse42
ssse3
'
ARCH_EXT_LIST="
$ARCH_EXT_LIST_X86
altivec
armv5te
armv6
armv6t2
armvfp
neon
ppc4xx
vfpv3
vis
mipsfpu
mips32r2
mipsdspr1
mipsdspr2
"
HAVE_LIST_CMDLINE='
inline_asm
symver
yasm
'
HAVE_LIST_PUB='
bigendian
fast_unaligned
incompatible_fork_abi
'
MATH_FUNCS="
atanf
atan2f
cbrtf
cosf
exp2
exp2f
expf
isinf
isnan
ldexpf
llrint
llrintf
log2
log2f
log10f
lrint
lrintf
powf
rint
round
roundf
sinf
trunc
truncf
"
HAVE_LIST="
$ARCH_EXT_LIST
$(add_suffix _external $ARCH_EXT_LIST)
$(add_suffix _inline $ARCH_EXT_LIST)
$HAVE_LIST_CMDLINE
$HAVE_LIST_PUB
$THREADS_LIST
$MATH_FUNCS
aligned_malloc
aligned_stack
alsa_asoundlib_h
altivec_h
arpa_inet_h
asm_mod_q
asm_mod_y
asm_types_h
attribute_may_alias
attribute_packed
clock_gettime
closesocket
cmov
cpunop
CryptGenRandom
dcbzl
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
dlfcn_h
dlopen
dos_paths
dxva_h
ebp_available
ebx_available
fast_64bit
fast_clz
fast_cmov
fcntl
fork
getaddrinfo
gethrtime
getopt
GetProcessAffinityMask
GetProcessMemoryInfo
GetProcessTimes
GetSystemTimeAsFileTime
getrusage
getservbyport
gettimeofday
glob
gnu_as
ibm_asm
inet_aton
io_h
isatty
jack_port_get_latency_range
kbhit
ldbrx
libdc1394_1
libdc1394_2
local_aligned_16
local_aligned_8
localtime_r
loongson
lzo1x_999_compress
machine_ioctl_bt848_h
machine_ioctl_meteor_h
makeinfo
malloc_h
MapViewOfFile
memalign
mkstemp
mm_empty
mmap
mprotect
msvcrt
nanosleep
PeekNamedPipe
perl
pod2man
poll_h
posix_memalign
pthread_cancel
rdtsc
sched_getaffinity
sdl
sdl_video_size
setmode
setrlimit
Sleep
sndio_h
socklen_t
soundcard_h
strerror_r
struct_addrinfo
struct_group_source_req
struct_ip_mreq_source
struct_ipv6_mreq
struct_pollfd
struct_rusage_ru_maxrss
struct_sctp_event_subscribe
struct_sockaddr_in6
struct_sockaddr_sa_len
struct_sockaddr_storage
struct_v4l2_frmivalenum_discrete
symver_asm_label
symver_gnu_asm
sysconf
sysctl
sys_mman_h
sys_param_h
sys_resource_h
sys_select_h
sys_soundcard_h
sys_time_h
sys_videoio_h
termios_h
texi2html
threads
unistd_h
usleep
vfp_args
VirtualAlloc
windows_h
winsock2_h
xform_asm
xmm_clobbers
"
# options emitted with CONFIG_ prefix but not available on command line
CONFIG_EXTRA="
aandcttables
ac3dsp
avutil
error_resilience
gcrypt
golomb
gplv3
h264chroma
h264dsp
h264pred
h264qpel
huffman
lgplv3
lpc
mpegaudio
mpegaudiodsp
mpegvideo
mpegvideoenc
nettle
rangecoder
rtpdec
sinewin
vp3dsp
"
CMDLINE_SELECT="
$ARCH_EXT_LIST
$CONFIG_LIST
$HAVE_LIST_CMDLINE
$THREADS_LIST
asm
coverage
cross_compile
debug
extra_warnings
logging
lto
optimizations
stripping
"
PATHS_LIST='
bindir
datadir
incdir
libdir
mandir
prefix
shlibdir
'
CMDLINE_SET="
$PATHS_LIST
ar
arch
as
assert_level
build_suffix
cc
cpu
cross_prefix
cxx
dep_cc
extra_version
host_cc
host_cflags
host_ld
host_ldflags
host_libs
host_os
install
ld
logfile
malloc_prefix
nm
optflags
pkg_config
postproc_version
progs_suffix
random_seed
samples
strip
sysinclude
sysroot
target_exec
target_os
target_path
toolchain
valgrind
yasmexe
"
CMDLINE_APPEND="
extra_cflags
extra_cxxflags
"
# code dependency declarations
# architecture extensions
armv5te_deps="arm"
armv6_deps="arm"
armv6t2_deps="arm"
armvfp_deps="arm"
neon_deps="arm"
vfpv3_deps="armvfp"
mipsfpu_deps="mips"
mips32r2_deps="mips"
mipsdspr1_deps="mips"
mipsdspr2_deps="mips"
altivec_deps="ppc"
ppc4xx_deps="ppc"
vis_deps="sparc"
x86_64_suggest="cmov fast_cmov"
amd3dnow_deps="mmx"
amd3dnowext_deps="amd3dnow"
mmx_deps="x86"
mmxext_deps="mmx"
sse_deps="mmxext"
sse2_deps="sse"
sse3_deps="sse2"
ssse3_deps="sse3"
sse4_deps="ssse3"
sse42_deps="sse4"
avx_deps="sse42"
fma4_deps="avx"
mmx_external_deps="yasm"
mmx_inline_deps="inline_asm"
mmx_suggest="mmx_external mmx_inline"
for ext in $(filter_out mmx $ARCH_EXT_LIST_X86); do
eval dep=\$${ext}_deps
eval ${ext}_external_deps='"${dep}_external"'
eval ${ext}_inline_deps='"${dep}_inline"'
eval ${ext}_suggest='"${ext}_external ${ext}_inline"'
done
aligned_stack_if_any="ppc x86"
fast_64bit_if_any="alpha ia64 mips64 parisc64 ppc64 sparc64 x86_64"
fast_clz_if_any="alpha armv5te avr32 mips ppc x86"
fast_unaligned_if_any="armv6 ppc x86"
inline_asm_deps="!tms470"
need_memalign="altivec neon sse"
symver_if_any="symver_asm_label symver_gnu_asm"
log2_deps="!msvcrt"
# subsystems
dct_select="rdft"
mdct_select="fft"
rdft_select="fft"
mpegaudio_select="mpegaudiodsp"
mpegaudiodsp_select="dct"
mpegvideoenc_select="mpegvideo"
# decoders / encoders / hardware accelerators
aac_decoder_select="mdct sinewin"
aac_encoder_select="mdct sinewin"
aac_latm_decoder_select="aac_decoder aac_latm_parser"
ac3_decoder_select="mdct ac3dsp ac3_parser"
ac3_encoder_select="mdct ac3dsp"
ac3_fixed_encoder_select="mdct ac3dsp"
alac_encoder_select="lpc"
amrnb_decoder_select="lsp"
amrwb_decoder_select="lsp"
amv_encoder_select="aandcttables"
atrac1_decoder_select="mdct sinewin"
atrac3_decoder_select="mdct"
binkaudio_dct_decoder_select="mdct rdft dct sinewin"
binkaudio_rdft_decoder_select="mdct rdft sinewin"
cavs_decoder_select="golomb mpegvideo"
comfortnoise_encoder_select="lpc"
cook_decoder_select="mdct sinewin"
cscd_decoder_select="lzo"
cscd_decoder_suggest="zlib"
dca_decoder_select="mdct"
dirac_decoder_select="dwt golomb"
dnxhd_encoder_select="aandcttables mpegvideoenc"
dxa_decoder_select="zlib"
eac3_decoder_select="ac3_decoder"
eac3_encoder_select="ac3_encoder"
eamad_decoder_select="aandcttables error_resilience mpegvideo"
eatgq_decoder_select="aandcttables"
eatqi_decoder_select="aandcttables error_resilience mpegvideo"
exr_decoder_select="zlib"
ffv1_decoder_select="golomb rangecoder"
ffv1_encoder_select="rangecoder"
ffvhuff_encoder_select="huffman"
flac_decoder_select="golomb"
flac_encoder_select="golomb lpc"
flashsv_decoder_select="zlib"
flashsv_encoder_select="zlib"
flashsv2_encoder_select="zlib"
flashsv2_decoder_select="zlib"
flv_decoder_select="h263_decoder"
flv_encoder_select="h263_encoder"
fraps_decoder_select="huffman"
h261_decoder_select="error_resilience mpegvideo"
h261_encoder_select="aandcttables mpegvideoenc"
h263_decoder_select="error_resilience h263_parser mpegvideo"
h263_encoder_select="aandcttables error_resilience mpegvideoenc"
h263_vaapi_hwaccel_select="vaapi h263_decoder"
h263i_decoder_select="h263_decoder"
h263p_encoder_select="h263_encoder"
h264_crystalhd_decoder_select="crystalhd h264_mp4toannexb_bsf h264_parser"
h264_decoder_select="error_resilience golomb h264chroma h264dsp h264pred h264qpel mpegvideo"
h264_dxva2_hwaccel_deps="dxva2api_h"
h264_dxva2_hwaccel_select="dxva2 h264_decoder"
h264_vaapi_hwaccel_select="vaapi h264_decoder"
h264_vda_decoder_select="vda h264_parser h264_decoder"
h264_vda_hwaccel_deps="VideoDecodeAcceleration_VDADecoder_h pthreads"
h264_vda_hwaccel_select="vda h264_decoder"
h264_vdpau_decoder_select="vdpau h264_decoder"
huffyuv_encoder_select="huffman"
iac_decoder_select="fft mdct sinewin"
imc_decoder_select="fft mdct sinewin"
jpegls_decoder_select="golomb"
jpegls_encoder_select="golomb"
ljpeg_encoder_select="aandcttables mpegvideoenc"
loco_decoder_select="golomb"
mdec_decoder_select="error_resilience mpegvideo"
mjpeg_encoder_select="aandcttables mpegvideoenc"
mlp_decoder_select="mlp_parser"
mp1_decoder_select="mpegaudio"
mp1float_decoder_select="mpegaudio"
mp2_decoder_select="mpegaudio"
mp2float_decoder_select="mpegaudio"
mp3_decoder_select="mpegaudio"
mp3adu_decoder_select="mpegaudio"
mp3adufloat_decoder_select="mpegaudio"
mp3float_decoder_select="mpegaudio"
mp3on4_decoder_select="mpegaudio"
mp3on4float_decoder_select="mpegaudio"
mpc7_decoder_select="mpegaudiodsp"
mpc8_decoder_select="mpegaudiodsp"
mpeg_vdpau_decoder_select="vdpau mpegvideo_decoder"
mpeg_xvmc_decoder_deps="X11_extensions_XvMClib_h"
mpeg_xvmc_decoder_select="mpegvideo_decoder"
mpeg1_vdpau_decoder_select="vdpau mpeg1video_decoder"
mpeg1_vdpau_hwaccel_select="vdpau mpeg1video_decoder"
mpeg1video_decoder_select="error_resilience mpegvideo"
mpeg1video_encoder_select="aandcttables error_resilience mpegvideoenc"
mpeg2_crystalhd_decoder_select="crystalhd"
mpeg2_dxva2_hwaccel_deps="dxva2api_h"
mpeg2_dxva2_hwaccel_select="dxva2 mpeg2video_decoder"
mpeg2_vdpau_hwaccel_select="vdpau mpeg2video_decoder"
mpeg2_vaapi_hwaccel_select="vaapi mpeg2video_decoder"
mpeg2video_decoder_select="error_resilience mpegvideo"
mpeg2video_encoder_select="aandcttables error_resilience mpegvideoenc"
mpeg4_crystalhd_decoder_select="crystalhd"
mpeg4_decoder_select="h263_decoder mpeg4video_parser"
mpeg4_encoder_select="h263_encoder"
mpeg4_vaapi_hwaccel_select="vaapi mpeg4_decoder"
mpeg4_vdpau_decoder_select="vdpau mpeg4_decoder"
msmpeg4_crystalhd_decoder_select="crystalhd"
msmpeg4v1_decoder_select="h263_decoder"
msmpeg4v1_encoder_select="h263_encoder"
msmpeg4v2_decoder_select="h263_decoder"
msmpeg4v2_encoder_select="h263_encoder"
msmpeg4v3_decoder_select="h263_decoder"
msmpeg4v3_encoder_select="h263_encoder"
mss2_decoder_select="vc1_decoder"
nellymoser_decoder_select="mdct sinewin"
nellymoser_encoder_select="mdct sinewin"
nuv_decoder_select="lzo"
png_decoder_select="zlib"
png_encoder_select="zlib"
qcelp_decoder_select="lsp"
qdm2_decoder_select="mdct rdft mpegaudiodsp"
ra_144_encoder_select="lpc"
ralf_decoder_select="golomb"
rv10_decoder_select="h263_decoder"
rv10_encoder_select="h263_encoder"
rv20_decoder_select="h263_decoder"
rv20_encoder_select="h263_encoder"
rv30_decoder_select="error_resilience golomb h264chroma h264pred h264qpel mpegvideo"
rv40_decoder_select="error_resilience golomb h264chroma h264pred h264qpel mpegvideo"
shorten_decoder_select="golomb"
sipr_decoder_select="lsp"
snow_decoder_select="dwt rangecoder"
snow_encoder_select="aandcttables dwt error_resilience mpegvideoenc rangecoder"
sonic_decoder_select="golomb"
sonic_encoder_select="golomb"
sonic_ls_encoder_select="golomb"
svq1_decoder_select="error_resilience mpegvideo"
svq1_encoder_select="aandcttables error_resilience mpegvideoenc"
svq3_decoder_select="error_resilience golomb h264chroma h264dsp h264pred h264qpel mpegvideo"
svq3_decoder_suggest="zlib"
theora_decoder_select="vp3_decoder"
tiff_decoder_suggest="zlib"
tiff_encoder_suggest="zlib"
truehd_decoder_select="mlp_parser"
tscc_decoder_select="zlib"
twinvq_decoder_select="mdct lsp sinewin"
utvideo_encoder_select="huffman"
vc1_crystalhd_decoder_select="crystalhd"
vc1_decoder_select="h263_decoder h264chroma h264qpel"
vc1_dxva2_hwaccel_deps="dxva2api_h"
vc1_dxva2_hwaccel_select="dxva2 vc1_decoder"
vc1_vaapi_hwaccel_select="vaapi vc1_decoder"
vc1_vdpau_decoder_select="vdpau vc1_decoder"
vc1image_decoder_select="vc1_decoder"
vorbis_decoder_select="mdct"
vorbis_encoder_select="mdct"
vp3_decoder_select="vp3dsp"
vp5_decoder_select="vp3dsp"
vp6_decoder_select="huffman vp3dsp"
vp6a_decoder_select="vp6_decoder"
vp6f_decoder_select="vp6_decoder"
vp8_decoder_select="h264pred h264qpel"
wmapro_decoder_select="mdct sinewin"
wmav1_decoder_select="mdct sinewin"
wmav1_encoder_select="mdct sinewin"
wmav2_decoder_select="mdct sinewin"
wmav2_encoder_select="mdct sinewin"
wmavoice_decoder_select="lsp rdft dct mdct sinewin"
wmv1_decoder_select="h263_decoder"
wmv1_encoder_select="h263_encoder"
wmv2_decoder_select="h263_decoder"
wmv2_encoder_select="h263_encoder"
wmv3_decoder_select="vc1_decoder"
wmv3_crystalhd_decoder_select="crystalhd"
wmv3_dxva2_hwaccel_select="vc1_dxva2_hwaccel"
wmv3_vaapi_hwaccel_select="vc1_vaapi_hwaccel"
wmv3_vdpau_decoder_select="vc1_vdpau_decoder"
wmv3image_decoder_select="wmv3_decoder"
zerocodec_decoder_select="zlib"
zlib_decoder_select="zlib"
zlib_encoder_select="zlib"
zmbv_decoder_select="zlib"
zmbv_encoder_select="zlib"
crystalhd_deps="libcrystalhd_libcrystalhd_if_h"
vaapi_deps="va_va_h"
vda_deps="VideoDecodeAcceleration_VDADecoder_h pthreads"
vdpau_deps="vdpau_vdpau_h vdpau_vdpau_x11_h"
# parsers
h264_parser_select="error_resilience golomb h264dsp h264pred mpegvideo"
mpeg4video_parser_select="error_resilience mpegvideo"
mpegvideo_parser_select="error_resilience mpegvideo"
vc1_parser_select="error_resilience mpegvideo"
# external libraries
libaacplus_encoder_deps="libaacplus"
libcelt_decoder_deps="libcelt"
libfaac_encoder_deps="libfaac"
libfdk_aac_encoder_deps="libfdk_aac"
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"
libmodplug_demuxer_deps="libmodplug"
libmp3lame_encoder_deps="libmp3lame"
libopencore_amrnb_decoder_deps="libopencore_amrnb"
libopencore_amrnb_encoder_deps="libopencore_amrnb"
libopencore_amrwb_decoder_deps="libopencore_amrwb"
libopenjpeg_decoder_deps="libopenjpeg"
libopenjpeg_encoder_deps="libopenjpeg"
libopus_decoder_deps="libopus"
libopus_encoder_deps="libopus"
libschroedinger_decoder_deps="libschroedinger"
libschroedinger_encoder_deps="libschroedinger"
libspeex_decoder_deps="libspeex"
libspeex_encoder_deps="libspeex"
libstagefright_h264_decoder_deps="libstagefright_h264"
libtheora_encoder_deps="libtheora"
libtwolame_encoder_deps="libtwolame"
libvo_aacenc_encoder_deps="libvo_aacenc"
libvo_amrwbenc_encoder_deps="libvo_amrwbenc"
libvorbis_decoder_deps="libvorbis"
libvorbis_encoder_deps="libvorbis"
libvpx_decoder_deps="libvpx"
libvpx_encoder_deps="libvpx"
libx264_encoder_deps="libx264"
libx264rgb_encoder_deps="libx264"
libxavs_encoder_deps="libxavs"
libxvid_encoder_deps="libxvid"
libutvideo_decoder_deps="libutvideo"
libutvideo_encoder_deps="libutvideo"
# demuxers / muxers
ac3_demuxer_select="ac3_parser"
asf_stream_muxer_select="asf_muxer"
avisynth_demuxer_deps="avisynth"
dirac_demuxer_select="dirac_parser"
dts_demuxer_select="dca_parser"
dtshd_demuxer_select="dca_parser"
eac3_demuxer_select="ac3_parser"
f4v_muxer_select="mov_muxer"
flac_demuxer_select="flac_parser"
ipod_muxer_select="mov_muxer"
libnut_demuxer_deps="libnut"
libnut_muxer_deps="libnut"
matroska_audio_muxer_select="matroska_muxer"
matroska_demuxer_suggest="bzlib lzo zlib"
mov_demuxer_suggest="zlib"
mp3_demuxer_select="mpegaudio_parser"
mp4_muxer_select="mov_muxer"
mpegts_muxer_select="adts_muxer latm_muxer mpegvideo"
mpegtsraw_demuxer_select="mpegts_demuxer"
mxf_d10_muxer_select="mxf_muxer"
ogg_demuxer_select="golomb"
psp_muxer_select="mov_muxer"
rtp_demuxer_select="sdp_demuxer"
rtp_muxer_select="mpegvideo"
rtpdec_select="asf_demuxer rm_demuxer rtp_protocol mpegts_demuxer mov_demuxer"
rtsp_demuxer_select="http_protocol rtpdec"
rtsp_muxer_select="rtp_muxer http_protocol rtp_protocol"
sap_demuxer_select="sdp_demuxer"
sap_muxer_select="rtp_muxer rtp_protocol"
sdp_demuxer_select="rtpdec"
smoothstreaming_muxer_select="ismv_muxer"
spdif_muxer_select="aac_parser"
tak_demuxer_select="tak_parser"
tg2_muxer_select="mov_muxer"
tgp_muxer_select="mov_muxer"
w64_demuxer_deps="wav_demuxer"
# indevs / outdevs
alsa_indev_deps="alsa_asoundlib_h snd_pcm_htimestamp"
alsa_outdev_deps="alsa_asoundlib_h"
bktr_indev_deps_any="dev_bktr_ioctl_bt848_h machine_ioctl_bt848_h dev_video_bktr_ioctl_bt848_h dev_ic_bt8xx_h"
caca_outdev_deps="libcaca"
dshow_indev_deps="IBaseFilter"
dshow_indev_extralibs="-lpsapi -lole32 -lstrmiids -luuid"
dv1394_indev_deps="dv1394 dv_demuxer"
fbdev_indev_deps="linux_fb_h"
iec61883_indev_deps="libiec61883"
jack_indev_deps="jack_jack_h sem_timedwait"
lavfi_indev_deps="avfilter"
libcdio_indev_deps="libcdio"
libdc1394_indev_deps="libdc1394"
libv4l2_indev_deps="libv4l2"
openal_indev_deps="openal"
oss_indev_deps_any="soundcard_h sys_soundcard_h"
oss_outdev_deps_any="soundcard_h sys_soundcard_h"
pulse_indev_deps="libpulse"
sdl_outdev_deps="sdl"
sndio_indev_deps="sndio_h"
sndio_outdev_deps="sndio_h"
v4l_indev_deps="linux_videodev_h"
v4l2_indev_deps_any="linux_videodev2_h sys_videoio_h"
vfwcap_indev_deps="capCreateCaptureWindow vfwcap_defines"
vfwcap_indev_extralibs="-lavicap32"
x11grab_indev_deps="x11grab"
# protocols
bluray_protocol_deps="libbluray"
ffrtmpcrypt_protocol_deps="!librtmp_protocol"
ffrtmpcrypt_protocol_deps_any="gcrypt nettle openssl"
ffrtmpcrypt_protocol_select="tcp_protocol"
ffrtmphttp_protocol_deps="!librtmp_protocol"
ffrtmphttp_protocol_select="http_protocol"
gopher_protocol_deps="network"
httpproxy_protocol_deps="network"
httpproxy_protocol_select="tcp_protocol"
http_protocol_deps="network"
http_protocol_select="tcp_protocol"
https_protocol_select="tls_protocol"
librtmp_protocol_deps="librtmp"
librtmpe_protocol_deps="librtmp"
librtmps_protocol_deps="librtmp"
librtmpt_protocol_deps="librtmp"
librtmpte_protocol_deps="librtmp"
mmsh_protocol_select="http_protocol"
mmst_protocol_deps="network"
rtmp_protocol_deps="!librtmp_protocol"
rtmp_protocol_select="tcp_protocol"
rtmpe_protocol_select="ffrtmpcrypt_protocol"
rtmps_protocol_deps="!librtmp_protocol"
rtmps_protocol_select="tls_protocol"
rtmpt_protocol_select="ffrtmphttp_protocol"
rtmpte_protocol_select="ffrtmpcrypt_protocol ffrtmphttp_protocol"
rtmpts_protocol_select="ffrtmphttp_protocol https_protocol"
rtp_protocol_select="udp_protocol"
sctp_protocol_deps="network struct_sctp_event_subscribe"
tcp_protocol_deps="network"
tls_protocol_deps_any="openssl gnutls"
tls_protocol_select="tcp_protocol"
udp_protocol_deps="network"
# filters
aconvert_filter_deps="swresample"
amovie_filter_deps="avcodec avformat"
aresample_filter_deps="swresample"
ass_filter_deps="libass"
asyncts_filter_deps="avresample"
atempo_filter_deps="avcodec rdft"
blackframe_filter_deps="gpl"
boxblur_filter_deps="gpl"
colormatrix_filter_deps="gpl"
cropdetect_filter_deps="gpl"
decimate_filter_deps="gpl avcodec"
delogo_filter_deps="gpl"
deshake_filter_deps="avcodec"
drawtext_filter_deps="libfreetype"
ebur128_filter_deps="gpl"
flite_filter_deps="libflite"
frei0r_filter_deps="frei0r dlopen"
frei0r_filter_extralibs='$ldl'
frei0r_src_filter_deps="frei0r dlopen"
frei0r_src_filter_extralibs='$ldl'
geq_filter_deps="gpl"
hqdn3d_filter_deps="gpl"
hue_filter_deps="gpl"
movie_filter_deps="avcodec avformat"
mp_filter_deps="gpl avcodec swscale postproc inline_asm"
mptestsrc_filter_deps="gpl"
negate_filter_deps="lut_filter"
resample_filter_deps="avresample"
ocv_filter_deps="libopencv"
pan_filter_deps="swresample"
removelogo_filter_deps="avcodec avformat swscale"
scale_filter_deps="swscale"
smartblur_filter_deps="gpl swscale"
showspectrum_filter_deps="avcodec rdft"
super2xsai_filter_deps="gpl"
tinterlace_filter_deps="gpl"
yadif_filter_deps="gpl"
pixfmts_super2xsai_test_deps="super2xsai_filter"
tinterlace_merge_test_deps="tinterlace_filter"
tinterlace_pad_test_deps="tinterlace_filter"
# libraries
avdevice_deps="avcodec avformat"
avformat_deps="avcodec"
postproc_deps="gpl"
# programs
ffmpeg_deps="avcodec avfilter avformat swscale swresample"
ffmpeg_select="ffbuffersink_filter format_filter aformat_filter
setpts_filter null_filter anull_filter ffabuffersink_filter"
ffplay_deps="avcodec avformat swscale swresample sdl"
ffplay_select="ffbuffersink_filter rdft crop_filter"
ffprobe_deps="avcodec avformat"
ffserver_deps="avformat ffm_muxer fork rtp_protocol rtsp_demuxer"
ffserver_extralibs='$ldl'
# documentation
podpages_deps="perl"
manpages_deps="perl pod2man"
htmlpages_deps="texi2html"
txtpages_deps="makeinfo"
doc_deps_any="manpages htmlpages podpages txtpages"
# default parameters
logfile="config.log"
# installation paths
prefix_default="/usr/local"
bindir_default='${prefix}/bin'
datadir_default='${prefix}/share/ffmpeg'
incdir_default='${prefix}/include'
libdir_default='${prefix}/lib'
mandir_default='${prefix}/share/man'
shlibdir_default="$libdir_default"
postproc_version_default="current"
# toolchain
ar_default="ar"
cc_default="gcc"
cxx_default="g++"
host_cc_default="gcc"
cp_f="cp -f"
install="install"
ln_s="ln -sf"
nm_default="nm -g"
objformat="elf"
pkg_config_default=pkg-config
ranlib="ranlib"
strip_default="strip"
yasmexe_default="yasm"
nogas=":"
# machine
arch_default=$(uname -m)
cpu="generic"
# OS
target_os_default=$(tolower $(uname -s))
host_os=$target_os_default
# alternative libpostproc version
ALT_PP_VER_MAJOR=51
ALT_PP_VER_MINOR=2
ALT_PP_VER_MICRO=101
ALT_PP_VER=$ALT_PP_VER_MAJOR.$ALT_PP_VER_MINOR.$ALT_PP_VER_MICRO
# configurable options
enable $PROGRAM_LIST
enable $DOCUMENT_LIST
enable avcodec
enable avdevice
enable avfilter
enable avformat
enable avutil
enable postproc
enable stripping
enable swresample
enable swscale
enable asm
enable debug
enable doc
enable network
enable optimizations
enable runtime_cpudetect
enable safe_bitstream_reader
enable static
enable swscale_alpha
# build settings
SHFLAGS='-shared -Wl,-soname,$$(@F)'
FFSERVERLDFLAGS=-Wl,-E
LIBPREF="lib"
LIBSUF=".a"
FULLNAME='$(NAME)$(BUILDSUF)'
LIBNAME='$(LIBPREF)$(FULLNAME)$(LIBSUF)'
SLIBPREF="lib"
SLIBSUF=".so"
SLIBNAME='$(SLIBPREF)$(FULLNAME)$(SLIBSUF)'
SLIBNAME_WITH_VERSION='$(SLIBNAME).$(LIBVERSION)'
SLIBNAME_WITH_MAJOR='$(SLIBNAME).$(LIBMAJOR)'
LIB_INSTALL_EXTRA_CMD='$$(RANLIB) "$(LIBDIR)/$(LIBNAME)"'
SLIB_INSTALL_NAME='$(SLIBNAME_WITH_VERSION)'
SLIB_INSTALL_LINKS='$(SLIBNAME_WITH_MAJOR) $(SLIBNAME)'
asflags_filter=echo
cflags_filter=echo
ldflags_filter=echo
AS_C='-c'
AS_O='-o $@'
CC_C='-c'
CC_E='-E -o $@'
CC_O='-o $@'
CXX_C='-c'
CXX_O='-o $@'
LD_O='-o $@'
LD_LIB='-l%'
LD_PATH='-L'
HOSTCC_C='-c'
HOSTCC_O='-o $@'
HOSTLD_O='-o $@'
host_cflags='-D_ISOC99_SOURCE -D_XOPEN_SOURCE=600 -O3 -g'
host_libs='-lm'
host_cflags_filter=echo
host_ldflags_filter=echo
target_path='$(CURDIR)'
# since the object filename is not given with the -MM flag, the compiler
# is only able to print the basename, and we must add the path ourselves
DEPCMD='$(DEP$(1)) $(DEP$(1)FLAGS) $($(1)DEP_FLAGS) $< | sed -e "/^\#.*/d" -e "s,^[[:space:]]*$(*F)\\.o,$(@D)/$(*F).o," > $(@:.o=.d)'
DEPFLAGS='-MM'
# find source path
if test -f configure; then
source_path=.
else
source_path=$(cd $(dirname "$0"); pwd)
echo "$source_path" | grep -q '[[:blank:]]' &&
die "Out of tree builds are impossible with whitespace in source path."
test -e "$source_path/config.h" &&
die "Out of tree builds are impossible with config.h in source dir."
fi
for v in "$@"; do
r=${v#*=}
l=${v%"$r"}
r=$(sh_quote "$r")
FFMPEG_CONFIGURATION="${FFMPEG_CONFIGURATION# } ${l}${r}"
done
find_things(){
thing=$1
pattern=$2
file=$source_path/$3
sed -n "s/^[^#]*$pattern.*([^,]*, *\([^,]*\)\(,.*\)*).*/\1_$thing/p" "$file"
}
ENCODER_LIST=$(find_things encoder ENC libavcodec/allcodecs.c)
DECODER_LIST=$(find_things decoder DEC libavcodec/allcodecs.c)
HWACCEL_LIST=$(find_things hwaccel HWACCEL libavcodec/allcodecs.c)
PARSER_LIST=$(find_things parser PARSER libavcodec/allcodecs.c)
BSF_LIST=$(find_things bsf BSF libavcodec/allcodecs.c)
MUXER_LIST=$(find_things muxer _MUX libavformat/allformats.c)
DEMUXER_LIST=$(find_things demuxer DEMUX libavformat/allformats.c)
OUTDEV_LIST=$(find_things outdev OUTDEV libavdevice/alldevices.c)
INDEV_LIST=$(find_things indev _IN libavdevice/alldevices.c)
PROTOCOL_LIST=$(find_things protocol PROTOCOL libavformat/allformats.c)
FILTER_LIST=$(find_things filter FILTER libavfilter/allfilters.c)
ALL_COMPONENTS="
$BSF_LIST
$DECODER_LIST
$DEMUXER_LIST
$ENCODER_LIST
$FILTER_LIST
$HWACCEL_LIST
$INDEV_LIST
$MUXER_LIST
$OUTDEV_LIST
$PARSER_LIST
$PROTOCOL_LIST
"
for n in $COMPONENT_LIST; do
v=$(toupper ${n%s})_LIST
eval enable \$$v
eval ${n}_if_any="\$$v"
done
enable $ARCH_EXT_LIST
die_unknown(){
echo "Unknown option \"$1\"."
echo "See $0 --help for available options."
exit 1
}
show_list() {
suffix=_$1
shift
echo $* | sed s/$suffix//g | tr ' ' '\n' | sort | pr -3 -t
exit 0
}
rand_list(){
IFS=', '
set -- $*
unset IFS
for thing; do
comp=${thing%:*}
prob=${thing#$comp}
prob=${prob#:}
is_in ${comp} $COMPONENT_LIST && eval comp=\$$(toupper ${comp%s})_LIST
echo "prob ${prob:-0.5}"
printf '%s\n' $comp
done
}
do_random(){
action=$1
shift
random_seed=$(awk "BEGIN { srand($random_seed); print srand() }")
$action $(rand_list "$@" | awk "BEGIN { srand($random_seed) } \$1 == \"prob\" { prob = \$2; next } rand() < prob { print }")
}
for opt do
optval="${opt#*=}"
case "$opt" in
--extra-ldflags=*) add_ldflags $optval
;;
--extra-libs=*) add_extralibs $optval
;;
--disable-devices) disable $INDEV_LIST $OUTDEV_LIST
;;
--enable-debug=*) debuglevel="$optval"
;;
--disable-programs)
disable $PROGRAM_LIST
;;
--disable-everything)
map 'eval unset \${$(toupper ${v%s})_LIST}' $COMPONENT_LIST
;;
--enable-random|--disable-random)
action=${opt%%-random}
do_random ${action#--} $COMPONENT_LIST
;;
--enable-random=*|--disable-random=*)
action=${opt%%-random=*}
do_random ${action#--} $optval
;;
--enable-*=*|--disable-*=*)
eval $(echo "${opt%%=*}" | sed 's/--/action=/;s/-/ thing=/')
is_in "${thing}s" $COMPONENT_LIST || die_unknown "$opt"
eval list=\$$(toupper $thing)_LIST
name=$(echo "${optval}" | sed "s/,/_${thing}|/g")_${thing}
list=$(filter "$name" $list)
[ "$list" = "" ] && warn "Option $opt did not match anything"
$action $list
;;
--enable-?*|--disable-?*)
eval $(echo "$opt" | sed 's/--/action=/;s/-/ option=/;s/-/_/g')
if is_in $option $COMPONENT_LIST; then
test $action = disable && action=unset
eval $action \$$(toupper ${option%s})_LIST
elif is_in $option $CMDLINE_SELECT; then
$action $option
else
die_unknown $opt
fi
;;
--list-*)
NAME="${opt#--list-}"
is_in $NAME $COMPONENT_LIST || die_unknown $opt
NAME=${NAME%s}
eval show_list $NAME \$$(toupper $NAME)_LIST
;;
--help|-h) show_help
;;
--fatal-warnings) enable fatal_warnings
;;
*)
optname="${opt%%=*}"
optname="${optname#--}"
optname=$(echo "$optname" | sed 's/-/_/g')
if is_in $optname $CMDLINE_SET; then
eval $optname='$optval'
elif is_in $optname $CMDLINE_APPEND; then
append $optname "$optval"
else
die_unknown $opt
fi
;;
esac
done
disabled logging && logfile=/dev/null
echo "# $0 $FFMPEG_CONFIGURATION" > $logfile
set >> $logfile
test -n "$cross_prefix" && enable cross_compile
if enabled cross_compile; then
test -n "$arch" && test -n "$target_os" ||
die "Must specify target arch and OS when cross-compiling"
fi
set_default postproc_version
# Check if we should build alternative libpostproc version instead of current
if test "$postproc_version" = $ALT_PP_VER; then
LIBPOSTPROC_VERSION=$ALT_PP_VER
LIBPOSTPROC_VERSION_MAJOR=$ALT_PP_VER_MAJOR
LIBPOSTPROC_VERSION_MINOR=$ALT_PP_VER_MINOR
LIBPOSTPROC_VERSION_MICRO=$ALT_PP_VER_MICRO
elif test "$postproc_version" != current; then
die "Invalid argument to --postproc-version. See --help output."
fi
ar_default="${cross_prefix}${ar_default}"
cc_default="${cross_prefix}${cc_default}"
cxx_default="${cross_prefix}${cxx_default}"
nm_default="${cross_prefix}${nm_default}"
pkg_config_default="${cross_prefix}${pkg_config_default}"
ranlib="${cross_prefix}${ranlib}"
strip_default="${cross_prefix}${strip_default}"
sysinclude_default="${sysroot}/usr/include"
case "$toolchain" in
clang-asan)
cc_default="clang"
add_cflags -faddress-sanitizer
add_ldflags -faddress-sanitizer
;;
clang-tsan)
cc_default="clang"
add_cflags -fthread-sanitizer
add_ldflags -fthread-sanitizer
;;
msvc)
cc_default="c99wrap cl"
ld_default="c99wrap link"
nm_default="dumpbin -symbols"
ar_default="lib"
target_os_default="win32"
;;
?*)
die "Unknown toolchain $toolchain"
;;
esac
set_default arch cc cxx pkg_config strip sysinclude target_os yasmexe
enabled cross_compile || host_cc_default=$cc
set_default host_cc
if ! $pkg_config --version >/dev/null 2>&1; then
warn "$pkg_config not found, library detection may fail."
pkg_config=false
fi
exesuf() {
case $1 in
mingw32*|win32|win64|cygwin*|*-dos|freedos|opendos|os/2*|symbian) echo .exe ;;
esac
}
EXESUF=$(exesuf $target_os)
HOSTEXESUF=$(exesuf $host_os)
# set temporary file name
: ${TMPDIR:=$TEMPDIR}
: ${TMPDIR:=$TMP}
: ${TMPDIR:=/tmp}
if ! check_cmd mktemp -u XXXXXX; then
# simple replacement for missing mktemp
# NOT SAFE FOR GENERAL USE
mktemp(){
echo "${2%%XXX*}.${HOSTNAME}.${UID}.$$"
}
fi
tmpfile(){
tmp=$(mktemp -u "${TMPDIR}/ffconf.XXXXXXXX")$2 &&
(set -C; exec > $tmp) 2>/dev/null ||
die "Unable to create temporary file in $TMPDIR."
append TMPFILES $tmp
eval $1=$tmp
}
trap 'rm -f -- $TMPFILES' EXIT
tmpfile TMPASM .asm
tmpfile TMPC .c
tmpfile TMPCPP .cpp
tmpfile TMPE $EXESUF
tmpfile TMPH .h
tmpfile TMPO .o
tmpfile TMPS .S
tmpfile TMPSH .sh
tmpfile TMPV .ver
unset -f mktemp
chmod +x $TMPE
# make sure we can execute files in $TMPDIR
cat > $TMPSH 2>> $logfile <<EOF
#! /bin/sh
EOF
chmod +x $TMPSH >> $logfile 2>&1
if ! $TMPSH >> $logfile 2>&1; then
cat <<EOF
Unable to create and execute files in $TMPDIR. Set the TMPDIR environment
variable to another directory and make sure that it is not mounted noexec.
EOF
die "Sanity test failed."
fi
msvc_flags(){
for flag; do
case $flag in
-fomit-frame-pointer) echo -Oy ;;
-g) echo -Z7 ;;
-Wall) echo -W4 -wd4244 -wd4127 -wd4018 -wd4389 \
-wd4146 -wd4057 -wd4204 -wd4706 -wd4305 \
-wd4152 -wd4324 -we4013 -wd4100 -wd4214 \
-wd4554 \
-wd4996 -wd4273 ;;
-std=c99) ;;
-fno-math-errno) ;;
-fno-common) ;;
-fno-signed-zeros) ;;
-lz) echo zlib.lib ;;
-lavifil32) echo vfw32.lib ;;
-lavicap32) echo vfw32.lib user32.lib ;;
-l*) echo ${flag#-l}.lib ;;
*) echo $flag ;;
esac
done
}
pgi_flags(){
for flag; do
case $flag in
-flto) echo -Mipa=fast,libopt,libinline,vestigial ;;
-fomit-frame-pointer) echo -Mnoframe ;;
-g) echo -gopt ;;
*) echo $flag ;;
esac
done
}
suncc_flags(){
for flag; do
case $flag in
-march=*|-mcpu=*)
case "${flag#*=}" in
native) echo -xtarget=native ;;
v9|niagara) echo -xarch=sparc ;;
ultrasparc) echo -xarch=sparcvis ;;
ultrasparc3|niagara2) echo -xarch=sparcvis2 ;;
i586|pentium) echo -xchip=pentium ;;
i686|pentiumpro|pentium2) echo -xtarget=pentium_pro ;;
pentium3*|c3-2) echo -xtarget=pentium3 ;;
pentium-m) echo -xarch=sse2 -xchip=pentium3 ;;
pentium4*) echo -xtarget=pentium4 ;;
prescott|nocona) echo -xarch=sse3 -xchip=pentium4 ;;
*-sse3) echo -xarch=sse3 ;;
core2) echo -xarch=ssse3 -xchip=core2 ;;
amdfam10|barcelona|bdver*) echo -xarch=sse4_1 ;;
athlon-4|athlon-[mx]p) echo -xarch=ssea ;;
k8|opteron|athlon64|athlon-fx)
echo -xarch=sse2a ;;
athlon*) echo -xarch=pentium_proa ;;
esac
;;
-std=c99) echo -xc99 ;;
-fomit-frame-pointer) echo -xregs=frameptr ;;
-fPIC) echo -KPIC -xcode=pic32 ;;
-W*,*) echo $flag ;;
-f*-*|-W*) ;;
*) echo $flag ;;
esac
done
}
tms470_flags(){
for flag; do
case $flag in
-march=*|-mcpu=*)
case "${flag#*=}" in
armv7-a|cortex-a*) echo -mv=7a8 ;;
armv7-r|cortex-r*) echo -mv=7r4 ;;
armv7-m|cortex-m*) echo -mv=7m3 ;;
armv6*|arm11*) echo -mv=6 ;;
armv5*e|arm[79]*e*|arm9[24]6*|arm96*|arm102[26])
echo -mv=5e ;;
armv4*|arm7*|arm9[24]*) echo -mv=4 ;;
esac
;;
-mfpu=neon) echo --float_support=vfpv3 --neon ;;
-mfpu=vfp) echo --float_support=vfpv2 ;;
-mfpu=vfpv3) echo --float_support=vfpv3 ;;
-mfpu=vfpv3-d16) echo --float_support=vfpv3d16 ;;
-msoft-float) echo --float_support=vfplib ;;
-O[0-3]|-mf=*) echo $flag ;;
-g) echo -g -mn ;;
-pds=*) echo $flag ;;
-D*|-I*) echo $flag ;;
--gcc|--abi=*) echo $flag ;;
-me) echo $flag ;;
esac
done
}
probe_cc(){
pfx=$1
_cc=$2
unset _type _ident _cc_c _cc_e _cc_o _flags _cflags
unset _ld_o _ldflags _ld_lib _ld_path
unset _depflags _DEPCMD _DEPFLAGS
_flags_filter=echo
if $_cc -v 2>&1 | grep -q '^gcc.*LLVM'; then
_type=llvm_gcc
gcc_extra_ver=$(expr "$($_cc --version | head -n1)" : '.*\((.*)\)')
_ident="llvm-gcc $($_cc -dumpversion) $gcc_extra_ver"
_depflags='-MMD -MF $(@:.o=.d) -MT $@'
_cflags_speed='-O3'
_cflags_size='-Os'
elif $_cc -v 2>&1 | grep -qi ^gcc; then
_type=gcc
gcc_version=$($_cc --version | head -n1)
gcc_basever=$($_cc -dumpversion)
gcc_pkg_ver=$(expr "$gcc_version" : '[^ ]* \(([^)]*)\)')
gcc_ext_ver=$(expr "$gcc_version" : ".*$gcc_pkg_ver $gcc_basever \\(.*\\)")
_ident=$(cleanws "gcc $gcc_basever $gcc_pkg_ver $gcc_ext_ver")
if ! $_cc -dumpversion | grep -q '^2\.'; then
_depflags='-MMD -MF $(@:.o=.d) -MT $@'
fi
_cflags_speed='-O3'
_cflags_size='-Os'
elif $_cc --version 2>/dev/null | grep -q Intel; then
_type=icc
_ident=$($_cc --version | head -n1)
_depflags='-MMD'
_cflags_speed='-O3'
_cflags_size='-Os'
_cflags_noopt='-O1'
elif $_cc -v 2>&1 | grep -q xlc; then
_type=xlc
_ident=$($_cc -qversion 2>/dev/null | head -n1)
_cflags_speed='-O5'
_cflags_size='-O5 -qcompact'
elif $_cc -V 2>/dev/null | grep -q Compaq; then
_type=ccc
_ident=$($_cc -V | head -n1 | cut -d' ' -f1-3)
_DEPFLAGS='-M'
debuglevel=3
_ldflags='-Wl,-z,now' # calls to libots crash without this
_cflags_speed='-fast'
_cflags_size='-O1'
elif $_cc --vsn 2>/dev/null | grep -q "ARM C/C++ Compiler"; then
test -d "$sysroot" || die "No valid sysroot specified."
_type=armcc
_ident=$($_cc --vsn | head -n1)
armcc_conf="$PWD/armcc.conf"
$_cc --arm_linux_configure \
--arm_linux_config_file="$armcc_conf" \
--configure_sysroot="$sysroot" \
--configure_cpp_headers="$sysinclude" >>$logfile 2>&1 ||
die "Error creating armcc configuration file."
$_cc --vsn | grep -q RVCT && armcc_opt=rvct || armcc_opt=armcc
_flags="--arm_linux_config_file=$armcc_conf --translate_gcc"
as_default="${cross_prefix}gcc"
_depflags='-MMD'
_cflags_speed='-O3'
_cflags_size='-Os'
elif $_cc -version 2>/dev/null | grep -Eq 'TMS470|TI ARM'; then
_type=tms470
_ident=$($_cc -version | head -n1 | tr -s ' ')
_flags='--gcc --abi=eabi -me'
_cc_e='-ppl -fe=$@'
_cc_o='-fe=$@'
_depflags='-ppa -ppd=$(@:.o=.d)'
_cflags_speed='-O3 -mf=5'
_cflags_size='-O3 -mf=2'
_flags_filter=tms470_flags
elif $_cc -v 2>&1 | grep -q clang; then
_type=clang
_ident=$($_cc --version | head -n1)
_depflags='-MMD'
_cflags_speed='-O3'
_cflags_size='-Os'
elif $_cc -V 2>&1 | grep -q Sun; then
_type=suncc
_ident=$($_cc -V 2>&1 | head -n1 | cut -d' ' -f 2-)
_DEPCMD='$(DEP$(1)) $(DEP$(1)FLAGS) $($(1)DEP_FLAGS) $< | sed -e "1s,^.*: ,$@: ," -e "\$$!s,\$$, \\\," -e "1!s,^.*: , ," > $(@:.o=.d)'
_DEPFLAGS='-xM1 -xc99'
_ldflags='-std=c99'
_cflags_speed='-O5'
_cflags_size='-O5 -xspace'
_flags_filter=suncc_flags
elif $_cc -v 2>&1 | grep -q 'PathScale\|Path64'; then
_type=pathscale
_ident=$($_cc -v 2>&1 | head -n1 | tr -d :)
_depflags='-MMD -MF $(@:.o=.d) -MT $@'
_cflags_speed='-O2'
_cflags_size='-Os'
_flags_filter='filter_out -Wdisabled-optimization'
elif $_cc -v 2>&1 | grep -q Open64; then
_type=open64
_ident=$($_cc -v 2>&1 | head -n1 | tr -d :)
_depflags='-MMD -MF $(@:.o=.d) -MT $@'
_cflags_speed='-O2'
_cflags_size='-Os'
_flags_filter='filter_out -Wdisabled-optimization|-Wtype-limits|-fno-signed-zeros'
elif $_cc -V 2>&1 | grep -q Portland; then
_type=pgi
_ident="PGI $($_cc -V 2>&1 | awk '/^pgcc/ { print $2; exit }')"
opt_common='-alias=ansi -Mdse -Mlre -Mpre'
_cflags_speed="-O3 -Mautoinline -Munroll=c:4 $opt_common"
_cflags_size="-O2 -Munroll=c:1 $opt_common"
_cflags_noopt="-O1"
_flags_filter=pgi_flags
elif $_cc 2>&1 | grep -q Microsoft; then
_type=msvc
_ident=$($cc 2>&1 | head -n1)
_DEPCMD='$(DEP$(1)) $(DEP$(1)FLAGS) $($(1)DEP_FLAGS) $< 2>&1 | awk '\''/including/ { sub(/^.*file: */, ""); gsub(/\\/, "/"); if (!match($$0, / /)) print "$@:", $$0 }'\'' > $(@:.o=.d)'
_DEPFLAGS='$(CPPFLAGS) $(CFLAGS) -showIncludes -Zs'
_cflags_speed="-O2"
_cflags_size="-O1"
# Nonstandard output options, to avoid msys path conversion issues, relies on wrapper to remap it
if $_cc 2>&1 | grep -q Linker; then
_ld_o='-out $@'
else
_ld_o='-Fe$@'
fi
_cc_o='-Fo $@'
_cc_e='-P -Fi $@'
_flags_filter=msvc_flags
_ld_lib='lib%.a'
_ld_path='-libpath:'
_flags='-nologo'
_cflags='-D_USE_MATH_DEFINES -Dinline=__inline -FIstdlib.h -Dstrtoll=_strtoi64'
if [ $pfx = hostcc ]; then
append _cflags -Dsnprintf=_snprintf
fi
disable stripping
fi
eval ${pfx}_type=\$_type
eval ${pfx}_ident=\$_ident
}
set_ccvars(){
eval ${1}_C=\${_cc_c-\${${1}_C}}
eval ${1}_E=\${_cc_e-\${${1}_E}}
eval ${1}_O=\${_cc_o-\${${1}_O}}
if [ -n "$_depflags" ]; then
eval ${1}_DEPFLAGS=\$_depflags
else
eval ${1}DEP=\${_DEPCMD:-\$DEPCMD}
eval ${1}DEP_FLAGS=\${_DEPFLAGS:-\$DEPFLAGS}
eval DEP${1}FLAGS=\$_flags
fi
}
probe_cc cc "$cc"
cflags_filter=$_flags_filter
cflags_speed=$_cflags_speed
cflags_size=$_cflags_size
cflags_noopt=$_cflags_noopt
add_cflags $_flags $_cflags
cc_ldflags=$_ldflags
set_ccvars CC
probe_cc hostcc "$host_cc"
host_cflags_filter=$_flags_filter
add_host_cflags $_flags $_cflags
set_ccvars HOSTCC
test -n "$cc_type" && enable $cc_type ||
warn "Unknown C compiler $cc, unable to select optimal CFLAGS"
: ${as_default:=$cc}
: ${dep_cc_default:=$cc}
: ${ld_default:=$cc}
: ${host_ld_default:=$host_cc}
set_default ar as dep_cc ld host_ld
probe_cc as "$as"
asflags_filter=$_flags_filter
add_asflags $_flags $_cflags
set_ccvars AS
probe_cc ld "$ld"
ldflags_filter=$_flags_filter
add_ldflags $_flags $_ldflags
test "$cc_type" != "$ld_type" && add_ldflags $cc_ldflags
LD_O=${_ld_o-$LD_O}
LD_LIB=${_ld_lib-$LD_LIB}
LD_PATH=${_ld_path-$LD_PATH}
probe_cc hostld "$host_ld"
host_ldflags_filter=$_flags_filter
add_host_ldflags $_flags $_ldflags
HOSTLD_O=${_ld_o-$HOSTLD_O}
if [ -z "$CC_DEPFLAGS" ] && [ "$dep_cc" != "$cc" ]; then
probe_cc depcc "$dep_cc"
CCDEP=${_DEPCMD:-$DEPCMD}
CCDEP_FLAGS=${_DEPFLAGS:=$DEPFLAGS}
DEPCCFLAGS=$_flags
fi
if $ar 2>&1 | grep -q Microsoft; then
arflags="-nologo"
ar_o='-out:$@'
elif $ar 2>&1 | grep -q 'Texas Instruments'; then
arflags="rq"
ar_o='$@'
else
arflags="rc"
ar_o='$@'
fi
add_cflags $extra_cflags
add_cxxflags $extra_cxxflags
add_asflags $extra_cflags
if test -n "$sysroot"; then
case "$cc_type" in
gcc|llvm_gcc|clang)
add_cppflags --sysroot="$sysroot"
add_ldflags --sysroot="$sysroot"
;;
tms470)
add_cppflags -I"$sysinclude"
add_ldflags --sysroot="$sysroot"
;;
esac
fi
if test "$cpu" = host; then
enabled cross_compile && die "--cpu=host makes no sense when cross-compiling."
case "$cc_type" in
gcc|llvm_gcc)
check_native(){
$cc $1=native -v -c -o $TMPO $TMPC >$TMPE 2>&1 || return
sed -n "/cc1.*$1=/{
s/.*$1=\\([^ ]*\\).*/\\1/
p
q
}" $TMPE
}
cpu=$(check_native -march || check_native -mcpu)
;;
esac
test "${cpu:-host}" = host && die "--cpu=host not supported with compiler $cc"
fi
# Deal with common $arch aliases
case "$arch" in
aarch64|arm64)
arch="aarch64"
;;
arm*|iPad*)
arch="arm"
;;
mips*|IP*)
arch="mips"
;;
parisc*|hppa*)
arch="parisc"
;;
"Power Macintosh"|ppc*|powerpc*)
arch="ppc"
;;
s390|s390x)
arch="s390"
;;
sh4|sh)
arch="sh4"
;;
sun4u|sparc*)
arch="sparc"
;;
tilegx|tile-gx)
arch="tilegx"
;;
i[3-6]86|i86pc|BePC|x86pc|x86_64|x86_32|amd64)
arch="x86"
;;
esac
is_in $arch $ARCH_LIST || warn "unknown architecture $arch"
enable $arch
# Add processor-specific flags
if test "$cpu" = generic; then
: do nothing
elif enabled ppc; then
case $(tolower $cpu) in
601|ppc601|powerpc601)
cpuflags="-mcpu=601"
disable altivec
;;
603*|ppc603*|powerpc603*)
cpuflags="-mcpu=603"
disable altivec
;;
604*|ppc604*|powerpc604*)
cpuflags="-mcpu=604"
disable altivec
;;
g3|75*|ppc75*|powerpc75*)
cpuflags="-mcpu=750"
disable altivec
;;
g4|745*|ppc745*|powerpc745*)
cpuflags="-mcpu=7450"
;;
74*|ppc74*|powerpc74*)
cpuflags="-mcpu=7400"
;;
g5|970|ppc970|powerpc970)
cpuflags="-mcpu=970"
;;
power[3-7]*)
cpuflags="-mcpu=$cpu"
;;
cell)
cpuflags="-mcpu=cell"
enable ldbrx
;;
e500mc)
cpuflags="-mcpu=e500mc"
disable altivec
;;
e500v2)
cpuflags="-mcpu=8548 -mhard-float -mfloat-gprs=double"
disable altivec
;;
e500)
cpuflags="-mcpu=8540 -mhard-float"
disable altivec
;;
esac
elif enabled x86; then
case $cpu in
i[345]86|pentium)
cpuflags="-march=$cpu"
disable mmx
;;
# targets that do NOT support conditional mov (cmov)
pentium-mmx|k6|k6-[23]|winchip-c6|winchip2|c3)
cpuflags="-march=$cpu"
disable cmov
;;
# targets that do support conditional mov (cmov)
i686|pentiumpro|pentium[23]|pentium-m|athlon|athlon-tbird|athlon-4|athlon-[mx]p|athlon64*|k8*|opteron*|athlon-fx|core2|amdfam10|barcelona|atom|bdver*)
cpuflags="-march=$cpu"
enable cmov
enable fast_cmov
;;
# targets that do support conditional mov but on which it's slow
pentium4|pentium4m|prescott|nocona)
cpuflags="-march=$cpu"
enable cmov
disable fast_cmov
;;
esac
elif enabled sparc; then
case $cpu in
cypress|f93[04]|tsc701|sparcl*|supersparc|hypersparc|niagara|v[789])
cpuflags="-mcpu=$cpu"
disable vis
;;
ultrasparc*|niagara[234])
cpuflags="-mcpu=$cpu"
;;
esac
elif enabled arm; then
case $cpu in
armv*)
cpuflags="-march=$cpu"
subarch=$(echo $cpu | sed 's/[^a-z0-9]//g')
;;
*)
cpuflags="-mcpu=$cpu"
case $cpu in
cortex-a*) subarch=armv7a ;;
cortex-r*) subarch=armv7r ;;
cortex-m*) enable thumb; subarch=armv7m ;;
arm11*) subarch=armv6 ;;
arm[79]*e*|arm9[24]6*|arm96*|arm102[26]) subarch=armv5te ;;
armv4*|arm7*|arm9[24]*) subarch=armv4 ;;
esac
;;
esac
elif enabled alpha; then
enabled ccc && cpuflags="-arch $cpu" || cpuflags="-mcpu=$cpu"
elif enabled bfin; then
cpuflags="-mcpu=$cpu"
elif enabled mips; then
cpuflags="-march=$cpu"
case $cpu in
24kc)
disable mipsfpu
disable mipsdspr1
disable mipsdspr2
;;
24kf*)
disable mipsdspr1
disable mipsdspr2
;;
24kec|34kc|1004kc)
disable mipsfpu
disable mipsdspr2
;;
24kef*|34kf*|1004kf*)
disable mipsdspr2
;;
74kc)
disable mipsfpu
;;
esac
elif enabled avr32; then
case $cpu in
ap7[02]0[0-2])
subarch="avr32_ap"
cpuflags="-mpart=$cpu"
;;
ap)
subarch="avr32_ap"
cpuflags="-march=$cpu"
;;
uc3[ab]*)
subarch="avr32_uc"
cpuflags="-mcpu=$cpu"
;;
uc)
subarch="avr32_uc"
cpuflags="-march=$cpu"
;;
esac
elif enabled aarch64; then
case $cpu in
armv*)
cpuflags="-march=$cpu"
;;
*)
cpuflags="-mcpu=$cpu"
;;
esac
fi
add_cflags $cpuflags
add_asflags $cpuflags
# compiler sanity check
check_exec <<EOF
int main(void){ return 0; }
EOF
if test "$?" != 0; then
echo "$cc is unable to create an executable file."
if test -z "$cross_prefix" && ! enabled cross_compile ; then
echo "If $cc is a cross-compiler, use the --enable-cross-compile option."
echo "Only do this if you know what cross compiling means."
fi
die "C compiler test failed."
fi
add_cppflags -D_ISOC99_SOURCE
add_cxxflags -D__STDC_CONSTANT_MACROS
check_cflags -std=c99
check_cc -D_FILE_OFFSET_BITS=64 <<EOF && add_cppflags -D_FILE_OFFSET_BITS=64
#include <stdlib.h>
EOF
check_cc -D_LARGEFILE_SOURCE <<EOF && add_cppflags -D_LARGEFILE_SOURCE
#include <stdlib.h>
EOF
check_host_cflags -std=c99
check_host_cflags -Wall
check_64bit(){
arch32=$1
arch64=$2
expr=$3
check_code cc "" "int test[2*($expr) - 1]" &&
subarch=$arch64 || subarch=$arch32
}
case "$arch" in
alpha|ia64)
spic=$shared
;;
mips)
check_64bit mips mips64 '_MIPS_SIM > 1'
spic=$shared
;;
parisc)
check_64bit parisc parisc64 'sizeof(void *) > 4'
spic=$shared
;;
ppc)
check_64bit ppc ppc64 'sizeof(void *) > 4'
;;
sparc)
check_64bit sparc sparc64 'sizeof(void *) > 4'
spic=$shared
;;
x86)
check_64bit x86_32 x86_64 'sizeof(void *) > 4'
if test "$subarch" = "x86_64"; then
spic=$shared
fi
;;
ppc)
check_cc <<EOF && subarch="ppc64"
int test[(int)sizeof(char*) - 7];
EOF
;;
esac
enable $subarch
enabled spic && enable pic
# OS specific
case $target_os in
haiku)
prefix_default="/boot/common"
network_extralibs="-lnetwork"
host_libs=
;;
sunos)
FFSERVERLDFLAGS=""
SHFLAGS='-shared -Wl,-h,$$(@F)'
enabled x86 && SHFLAGS="-mimpure-text $SHFLAGS"
network_extralibs="-lsocket -lnsl"
add_cppflags -D__EXTENSIONS__ -D_XOPEN_SOURCE=600
# When using suncc to build, the Solaris linker will mark
# an executable with each instruction set encountered by
# the Solaris assembler. As our libraries contain their own
# guards for processor-specific code, instead suppress
# generation of the HWCAPS ELF section on Solaris x86 only.
enabled_all suncc x86 && echo "hwcap_1 = OVERRIDE;" > mapfile && add_ldflags -Wl,-M,mapfile
nm_default='nm -P -g'
;;
netbsd)
disable symver
oss_indev_extralibs="-lossaudio"
oss_outdev_extralibs="-lossaudio"
enabled gcc || check_ldflags -Wl,-zmuldefs
;;
openbsd|bitrig)
# On OpenBSD 4.5. the compiler does not use PIC unless
# explicitly using -fPIC. FFmpeg builds fine without PIC,
# however the generated executable will not do anything
# (simply quits with exit-code 1, no crash, no output).
# Thus explicitly enable PIC here.
enable pic
disable symver
SHFLAGS='-shared'
SLIBNAME_WITH_MAJOR='$(SLIBNAME).$(LIBVERSION)'
SLIB_INSTALL_LINKS=
oss_indev_extralibs="-lossaudio"
oss_outdev_extralibs="-lossaudio"
;;
dragonfly)
disable symver
;;
freebsd)
;;
bsd/os)
add_extralibs -lpoll -lgnugetopt
strip="strip -d"
;;
darwin)
gas="gas-preprocessor.pl $cc"
enabled ppc && add_asflags -force_cpusubtype_ALL
SHFLAGS='-dynamiclib -Wl,-single_module -Wl,-install_name,$(SHLIBDIR)/$(SLIBNAME_WITH_MAJOR),-current_version,$(LIBVERSION),-compatibility_version,$(LIBMAJOR)'
enabled x86_32 && append SHFLAGS -Wl,-read_only_relocs,suppress
strip="${strip} -x"
add_ldflags -Wl,-dynamic,-search_paths_first
SLIBSUF=".dylib"
SLIBNAME_WITH_VERSION='$(SLIBPREF)$(FULLNAME).$(LIBVERSION)$(SLIBSUF)'
SLIBNAME_WITH_MAJOR='$(SLIBPREF)$(FULLNAME).$(LIBMAJOR)$(SLIBSUF)'
FFSERVERLDFLAGS=-Wl,-bind_at_load
objformat="macho"
enabled x86_64 && objformat="macho64"
enabled_any pic shared ||
{ check_cflags -mdynamic-no-pic && add_asflags -mdynamic-no-pic; }
;;
mingw32*)
if test $target_os = "mingw32ce"; then
disable network
else
target_os=mingw32
fi
LIBTARGET=i386
if enabled x86_64; then
LIBTARGET="i386:x86-64"
elif enabled arm; then
LIBTARGET=arm-wince
fi
shlibdir_default="$bindir_default"
SLIBPREF=""
SLIBSUF=".dll"
SLIBNAME_WITH_VERSION='$(SLIBPREF)$(FULLNAME)-$(LIBVERSION)$(SLIBSUF)'
SLIBNAME_WITH_MAJOR='$(SLIBPREF)$(FULLNAME)-$(LIBMAJOR)$(SLIBSUF)'
dlltool="${cross_prefix}dlltool"
if check_cmd lib.exe -list; then
SLIB_EXTRA_CMD='-lib.exe /machine:$(LIBTARGET) /def:$$(@:$(SLIBSUF)=.def) /out:$(SUBDIR)$(SLIBNAME:$(SLIBSUF)=.lib)'
if enabled x86_64; then
LIBTARGET=x64
fi
elif check_cmd $dlltool --version; then
SLIB_EXTRA_CMD=-'$(DLLTOOL) -m $(LIBTARGET) -d $$(@:$(SLIBSUF)=.def) -l $(SUBDIR)$(SLIBNAME:$(SLIBSUF)=.lib) -D $(SLIBNAME_WITH_MAJOR)'
fi
SLIB_INSTALL_NAME='$(SLIBNAME_WITH_MAJOR)'
SLIB_INSTALL_LINKS=
SLIB_INSTALL_EXTRA_SHLIB='$(SLIBNAME:$(SLIBSUF)=.lib)'
SLIB_INSTALL_EXTRA_LIB='lib$(SLIBNAME:$(SLIBSUF)=.dll.a) $(SLIBNAME_WITH_MAJOR:$(SLIBSUF)=.def)'
SHFLAGS='-shared -Wl,--output-def,$$(@:$(SLIBSUF)=.def) -Wl,--out-implib,$(SUBDIR)lib$(SLIBNAME:$(SLIBSUF)=.dll.a) -Wl,--enable-runtime-pseudo-reloc -Wl,--enable-auto-image-base'
objformat="win32"
ranlib=:
enable dos_paths
add_cppflags -U__STRICT_ANSI__
;;
win32|win64)
if enabled shared; then
# Link to the import library instead of the normal static library
# for shared libs.
LD_LIB='%.lib'
# Cannot build shared and static libraries at the same time with
# MSVC.
disable static
fi
shlibdir_default="$bindir_default"
SLIBPREF=""
SLIBSUF=".dll"
SLIBNAME_WITH_VERSION='$(SLIBPREF)$(FULLNAME)-$(LIBVERSION)$(SLIBSUF)'
SLIBNAME_WITH_MAJOR='$(SLIBPREF)$(FULLNAME)-$(LIBMAJOR)$(SLIBSUF)'
SLIB_CREATE_DEF_CMD='makedef $(SUBDIR)lib$(NAME).ver $(OBJS) > $$(@:$(SLIBSUF)=.def)'
SLIB_INSTALL_NAME='$(SLIBNAME_WITH_MAJOR)'
SLIB_INSTALL_LINKS=
SLIB_INSTALL_EXTRA_SHLIB='$(SLIBNAME:$(SLIBSUF)=.lib)'
SLIB_INSTALL_EXTRA_LIB='$(SLIBNAME_WITH_MAJOR:$(SLIBSUF)=.def)'
SHFLAGS='-dll -def:$$(@:$(SLIBSUF)=.def) -implib:$(SUBDIR)$(SLIBNAME:$(SLIBSUF)=.lib)'
objformat="win32"
ranlib=:
enable dos_paths
;;
cygwin*)
target_os=cygwin
shlibdir_default="$bindir_default"
SLIBPREF="cyg"
SLIBSUF=".dll"
SLIBNAME_WITH_VERSION='$(SLIBPREF)$(FULLNAME)-$(LIBVERSION)$(SLIBSUF)'
SLIBNAME_WITH_MAJOR='$(SLIBPREF)$(FULLNAME)-$(LIBMAJOR)$(SLIBSUF)'
SLIB_INSTALL_NAME='$(SLIBNAME_WITH_MAJOR)'
SLIB_INSTALL_LINKS=
SLIB_INSTALL_EXTRA_LIB='lib$(FULLNAME).dll.a'
SHFLAGS='-shared -Wl,--out-implib,$(SUBDIR)lib$(FULLNAME).dll.a'
objformat="win32"
enable dos_paths
;;
*-dos|freedos|opendos)
network_extralibs="-lsocket"
objformat="coff"
enable dos_paths
add_cppflags -U__STRICT_ANSI__
;;
linux)
enable dv1394
;;
irix*)
target_os=irix
ranlib="echo ignoring ranlib"
;;
os/2*)
strip="lxlite -CS"
ln_s="cp -f"
objformat="aout"
add_cppflags -D_GNU_SOURCE
add_ldflags -Zomf -Zbin-files -Zargs-wild -Zmap
SHFLAGS='$(SUBDIR)$(NAME).def -Zdll -Zomf'
FFSERVERLDFLAGS=""
LIBSUF="_s.a"
SLIBPREF=""
SLIBSUF=".dll"
SLIBNAME_WITH_VERSION='$(SLIBPREF)$(NAME)-$(LIBVERSION)$(SLIBSUF)'
SLIBNAME_WITH_MAJOR='$(SLIBPREF)$(shell echo $(NAME) | cut -c1-6)$(LIBMAJOR)$(SLIBSUF)'
SLIB_CREATE_DEF_CMD='echo LIBRARY $(SLIBNAME_WITH_MAJOR) INITINSTANCE TERMINSTANCE > $(SUBDIR)$(NAME).def; \
echo PROTMODE >> $(SUBDIR)$(NAME).def; \
echo CODE PRELOAD MOVEABLE DISCARDABLE >> $(SUBDIR)$(NAME).def; \
echo DATA PRELOAD MOVEABLE MULTIPLE NONSHARED >> $(SUBDIR)$(NAME).def; \
echo EXPORTS >> $(SUBDIR)$(NAME).def; \
emxexp -o $(OBJS) >> $(SUBDIR)$(NAME).def'
SLIB_EXTRA_CMD='emximp -o $(SUBDIR)$(LIBPREF)$(NAME)_dll.a $(SUBDIR)$(NAME).def; \
emximp -o $(SUBDIR)$(LIBPREF)$(NAME)_dll.lib $(SUBDIR)$(NAME).def;'
SLIB_INSTALL_EXTRA_LIB='$(LIBPREF)$(NAME)_dll.a $(LIBPREF)$(NAME)_dll.lib'
enable dos_paths
enable_weak os2threads
;;
gnu/kfreebsd)
add_cppflags -D_BSD_SOURCE
;;
gnu)
;;
qnx)
add_cppflags -D_QNX_SOURCE
network_extralibs="-lsocket"
;;
symbian)
SLIBSUF=".dll"
enable dos_paths
add_cflags --include=$sysinclude/gcce/gcce.h -fvisibility=default
add_cppflags -D__GCCE__ -D__SYMBIAN32__ -DSYMBIAN_OE_POSIX_SIGNALS
add_ldflags -Wl,--target1-abs,--no-undefined \
-Wl,-Ttext,0x80000,-Tdata,0x1000000 -shared \
-Wl,--entry=_E32Startup -Wl,-u,_E32Startup
add_extralibs -l:eexe.lib -l:usrt2_2.lib -l:dfpaeabi.dso \
-l:drtaeabi.dso -l:scppnwdl.dso -lsupc++ -lgcc \
-l:libc.dso -l:libm.dso -l:euser.dso -l:libcrt0.lib
;;
osf1)
add_cppflags -D_OSF_SOURCE -D_POSIX_PII -D_REENTRANT
FFSERVERLDFLAGS=
;;
minix)
;;
plan9)
add_cppflags -D_C99_SNPRINTF_EXTENSION \
-D_REENTRANT_SOURCE \
-D_RESEARCH_SOURCE \
-DFD_SETSIZE=96 \
-DHAVE_SOCK_OPTS
add_compat strtod.o strtod=avpriv_strtod
network_extralibs='-lbsd'
exeobjs=compat/plan9/main.o
disable ffserver
ln_s='ln -s -f'
cp_f='cp'
;;
none)
;;
*)
die "Unknown OS '$target_os'."
;;
esac
# determine libc flavour
if check_cpp_condition features.h "defined __UCLIBC__"; then
libc_type=uclibc
add_cppflags -D_POSIX_C_SOURCE=200112 -D_XOPEN_SOURCE=600
elif check_cpp_condition features.h "defined __GLIBC__"; then
libc_type=glibc
add_cppflags -D_POSIX_C_SOURCE=200112 -D_XOPEN_SOURCE=600
elif check_header _mingw.h; then
libc_type=mingw
check_cpp_condition _mingw.h \
"defined (__MINGW64_VERSION_MAJOR) || (__MINGW32_MAJOR_VERSION > 3) || \
(__MINGW32_MAJOR_VERSION == 3 && __MINGW32_MINOR_VERSION >= 15)" ||
die "ERROR: MinGW runtime version must be >= 3.15."
if check_cpp_condition _mingw.h "defined(__MINGW64_VERSION_MAJOR) && \
__MINGW64_VERSION_MAJOR < 3"; then
add_compat msvcrt/snprintf.o
add_cflags "-include $source_path/compat/msvcrt/snprintf.h"
fi
elif check_cpp_condition newlib.h "defined _NEWLIB_VERSION"; then
libc_type=newlib
add_cppflags -U__STRICT_ANSI__
elif check_func_headers stdlib.h _get_doserrno; then
libc_type=msvcrt
add_compat strtod.o strtod=avpriv_strtod
add_compat msvcrt/snprintf.o snprintf=avpriv_snprintf \
_snprintf=avpriv_snprintf \
vsnprintf=avpriv_vsnprintf
elif check_cpp_condition stddef.h "defined __KLIBC__"; then
libc_type=klibc
fi
test -n "$libc_type" && enable $libc_type
# hacks for compiler/libc/os combinations
if enabled_all tms470 glibc; then
CPPFLAGS="-I${source_path}/compat/tms470 ${CPPFLAGS}"
add_cppflags -D__USER_LABEL_PREFIX__=
add_cppflags -D__builtin_memset=memset
add_cppflags -D__gnuc_va_list=va_list -D_VA_LIST_DEFINED
add_cflags -pds=48 # incompatible redefinition of macro
fi
esc(){
echo "$*" | sed 's/%/%25/g;s/:/%3a/g'
}
echo "config:$arch:$subarch:$cpu:$target_os:$(esc $cc_ident):$(esc $FFMPEG_CONFIGURATION)" >config.fate
check_cpp_condition stdlib.h "defined(__PIC__) || defined(__pic__) || defined(PIC)" && enable pic
set_default $PATHS_LIST
set_default nm
# we need to build at least one lib type
if ! enabled_any static shared; then
cat <<EOF
At least one library type must be built.
Specify --enable-static to build the static libraries or --enable-shared to
build the shared libraries as well. To only build the shared libraries specify
--disable-static in addition to --enable-shared.
EOF
exit 1;
fi
die_license_disabled() {
enabled $1 || { enabled $2 && die "$2 is $1 and --enable-$1 is not specified."; }
}
die_license_disabled_gpl() {
enabled $1 || { enabled $2 && die "$2 is incompatible with the gpl and --enable-$1 is not specified."; }
}
die_license_disabled gpl libcdio
die_license_disabled gpl libutvideo
die_license_disabled gpl libx264
die_license_disabled gpl libxavs
die_license_disabled gpl libxvid
die_license_disabled gpl x11grab
die_license_disabled nonfree libaacplus
die_license_disabled nonfree libfaac
enabled gpl && die_license_disabled_gpl nonfree libfdk_aac
enabled gpl && die_license_disabled_gpl nonfree openssl
die_license_disabled version3 libopencore_amrnb
die_license_disabled version3 libopencore_amrwb
die_license_disabled version3 libvo_aacenc
die_license_disabled version3 libvo_amrwbenc
enabled version3 && { enabled gpl && enable gplv3 || enable lgplv3; }
disabled optimizations || check_cflags -fomit-frame-pointer
enable_pic() {
enable pic
add_cppflags -DPIC
add_cflags -fPIC
add_asflags -fPIC
}
enabled pic && enable_pic
check_cc <<EOF || die "Symbol mangling check failed."
int ff_extern;
EOF
sym=$($nm $TMPO | awk '/ff_extern/{ print substr($0, match($0, /[^ \t]*ff_extern/)) }')
extern_prefix=${sym%%ff_extern*}
check_cc <<EOF && enable_weak inline_asm
void foo(void) { __asm__ volatile ("" ::); }
EOF
_restrict=
for restrict_keyword in restrict __restrict__ __restrict; do
check_cc <<EOF && _restrict=$restrict_keyword && break
void foo(char * $restrict_keyword p);
EOF
done
check_cc <<EOF && enable attribute_packed
struct { int x; } __attribute__((packed)) x;
EOF
check_cc <<EOF && enable attribute_may_alias
union { int x; } __attribute__((may_alias)) x;
EOF
check_cc <<EOF || die "endian test failed"
unsigned int endian = 'B' << 24 | 'I' << 16 | 'G' << 8 | 'E';
EOF
od -t x1 $TMPO | grep -q '42 *49 *47 *45' && enable bigendian
if enabled alpha; then
check_cflags -mieee
elif enabled arm; then
enabled thumb && check_cflags -mthumb || check_cflags -marm
nogas=die
if check_cpp_condition stddef.h "defined __ARM_PCS_VFP"; then
enable vfp_args
elif ! check_cpp_condition stddef.h "defined __ARM_PCS || defined __SOFTFP__"; then
case "${cross_prefix:-$cc}" in
*hardfloat*) enable vfp_args; fpabi=vfp ;;
*) check_ld "cc" <<EOF && enable vfp_args && fpabi=vfp || fpabi=soft ;;
__asm__ (".eabi_attribute 28, 1");
int main(void) { return 0; }
EOF
esac
warn "Compiler does not indicate floating-point ABI, guessing $fpabi."
fi
enabled armv5te && check_inline_asm armv5te '"qadd r0, r0, r0"'
enabled armv6 && check_inline_asm armv6 '"sadd16 r0, r0, r0"'
enabled armv6t2 && check_inline_asm armv6t2 '"movt r0, #0"'
enabled armvfp && check_inline_asm armvfp '"fadds s0, s0, s0"'
enabled neon && check_inline_asm neon '"vadd.i16 q0, q0, q0"'
enabled vfpv3 && check_inline_asm vfpv3 '"vmov.f32 s0, #1.0"'
check_inline_asm asm_mod_q '"add r0, %Q0, %R0" :: "r"((long long)0)'
check_inline_asm asm_mod_y '"vmul.i32 d0, d0, %y0" :: "x"(0)'
enabled_all armv6t2 shared !pic && enable_pic
elif enabled mips; then
check_inline_asm loongson '"dmult.g $1, $2, $3"'
enabled mips32r2 && add_cflags "-mips32r2" && add_asflags "-mips32r2" &&
check_inline_asm mips32r2 '"rotr $t0, $t1, 1"'
enabled mipsdspr1 && add_cflags "-mdsp" && add_asflags "-mdsp" &&
check_inline_asm mipsdspr1 '"addu.qb $t0, $t1, $t2"'
enabled mipsdspr2 && add_cflags "-mdspr2" && add_asflags "-mdspr2" &&
check_inline_asm mipsdspr2 '"absq_s.qb $t0, $t1"'
enabled mipsfpu && add_cflags "-mhard-float" && add_asflags "-mhard-float" &&
check_inline_asm mipsfpu '"madd.d $f0, $f2, $f4, $f6"'
elif enabled parisc; then
if enabled gcc; then
case $($cc -dumpversion) in
4.[3-8].*) check_cflags -fno-optimize-sibling-calls ;;
esac
fi
elif enabled ppc; then
enable local_aligned_8 local_aligned_16
check_inline_asm dcbzl '"dcbzl 0, %0" :: "r"(0)'
check_inline_asm ibm_asm '"add 0, 0, 0"'
check_inline_asm ppc4xx '"maclhw r10, r11, r12"'
check_inline_asm xform_asm '"lwzx %1, %y0" :: "Z"(*(int*)0), "r"(0)'
# AltiVec flags: The FSF version of GCC differs from the Apple version
if enabled altivec; then
nogas=warn
check_cflags -maltivec -mabi=altivec &&
{ check_header altivec.h && inc_altivec_h="#include <altivec.h>" ; } ||
check_cflags -faltivec
# check if our compiler supports Motorola AltiVec C API
check_cc <<EOF || disable altivec
$inc_altivec_h
int main(void) {
vector signed int v1 = (vector signed int) { 0 };
vector signed int v2 = (vector signed int) { 1 };
v1 = vec_add(v1, v2);
return 0;
}
EOF
enabled altivec || warn "Altivec disabled, possibly missing --cpu flag"
fi
elif enabled sparc; then
enabled vis && check_inline_asm vis '"pdist %f0, %f0, %f0"'
elif enabled x86; then
check_code ld intrin.h "__rdtsc()" "cc" && enable rdtsc
check_code ld mmintrin.h "_mm_empty()" "cc" && enable mm_empty
enable local_aligned_8 local_aligned_16
# check whether EBP is available on x86
# As 'i' is stored on the stack, this program will crash
# if the base pointer is used to access it because the
# base pointer is cleared in the inline assembly code.
check_exec_crash <<EOF && enable ebp_available
volatile int i=0;
__asm__ volatile ("xorl %%ebp, %%ebp" ::: "%ebp");
return i;
EOF
# check whether EBX is available on x86
check_inline_asm ebx_available '""::"b"(0)' &&
check_inline_asm ebx_available '"":::"%ebx"'
# check whether xmm clobbers are supported
check_inline_asm xmm_clobbers '"":::"%xmm0"'
# check whether binutils is new enough to compile SSSE3/MMXEXT
enabled ssse3 && check_inline_asm ssse3_inline '"pabsw %xmm0, %xmm0"'
enabled mmxext && check_inline_asm mmxext_inline '"pmaxub %mm0, %mm1"'
if ! disabled_any asm mmx yasm; then
if check_cmd $yasmexe --version; then
enabled x86_64 && yasm_extra="-m amd64"
yasm_debug="-g dwarf2"
elif check_cmd nasm -v; then
yasmexe=nasm
yasm_debug="-g -F dwarf"
enabled x86_64 && test "$objformat" = elf && objformat=elf64
fi
YASMFLAGS="-f $objformat $yasm_extra"
enabled pic && append YASMFLAGS "-DPIC"
test -n "$extern_prefix" && append YASMFLAGS "-DPREFIX"
case "$objformat" in
elf*) enabled debug && append YASMFLAGS $yasm_debug ;;
esac
check_yasm "pextrd [eax], xmm0, 1" && enable yasm ||
die "yasm not found, use --disable-yasm for a crippled build"
check_yasm "vextractf128 xmm0, ymm0, 0" || disable avx_external
check_yasm "vfmaddps ymm0, ymm1, ymm2, ymm3" || disable fma4_external
check_yasm "CPU amdnop" && enable cpunop
fi
case "$cpu" in
athlon*|opteron*|k8*|pentium|pentium-mmx|prescott|nocona|atom|geode)
disable fast_clz
;;
esac
fi
if enabled asm; then
as=${gas:=$as}
check_inline_asm gnu_as '".macro m n\n\\n:.int 0\n.endm\nm x"' ||
$nogas "GNU assembler not found, install gas-preprocessor"
fi
check_ldflags -Wl,--as-needed
if check_func dlopen; then
ldl=
elif check_func dlopen -ldl; then
ldl=-ldl
fi
if enabled network; then
check_type "sys/types.h sys/socket.h" socklen_t
check_type netdb.h "struct addrinfo"
check_type netinet/in.h "struct group_source_req" -D_BSD_SOURCE
check_type netinet/in.h "struct ip_mreq_source" -D_BSD_SOURCE
check_type netinet/in.h "struct ipv6_mreq" -D_DARWIN_C_SOURCE
check_type netinet/in.h "struct sockaddr_in6"
check_type poll.h "struct pollfd"
check_type "sys/types.h sys/socket.h" "struct sockaddr_storage"
check_struct "sys/types.h sys/socket.h" "struct sockaddr" sa_len
check_type netinet/sctp.h "struct sctp_event_subscribe"
check_func getaddrinfo $network_extralibs
check_func getservbyport $network_extralibs
# Prefer arpa/inet.h over winsock2
if check_header arpa/inet.h ; then
check_func closesocket
elif check_header winsock2.h ; then
check_func_headers winsock2.h closesocket -lws2 &&
network_extralibs="-lws2" ||
{ check_func_headers winsock2.h closesocket -lws2_32 &&
network_extralibs="-lws2_32"; }
check_func_headers ws2tcpip.h getaddrinfo $network_extralibs
check_type ws2tcpip.h socklen_t
check_type ws2tcpip.h "struct addrinfo"
check_type ws2tcpip.h "struct group_source_req"
check_type ws2tcpip.h "struct ip_mreq_source"
check_type ws2tcpip.h "struct ipv6_mreq"
check_type winsock2.h "struct pollfd"
check_type ws2tcpip.h "struct sockaddr_in6"
check_type ws2tcpip.h "struct sockaddr_storage"
check_struct winsock2.h "struct sockaddr" sa_len
else
disable network
fi
fi
# Solaris has nanosleep in -lrt, OpenSolaris no longer needs that
check_func nanosleep || { check_func nanosleep -lrt && add_extralibs -lrt; }
check_func clock_gettime || { check_func clock_gettime -lrt && add_extralibs -lrt; }
check_func fcntl
check_func fork
check_func gethrtime
check_func getopt
check_func getrusage
check_struct "sys/time.h sys/resource.h" "struct rusage" ru_maxrss
check_func gettimeofday
check_func inet_aton $network_extralibs
check_func isatty
check_func localtime_r
check_func ${malloc_prefix}memalign && enable memalign
check_func mkstemp
check_func mmap
check_func mprotect
check_func ${malloc_prefix}posix_memalign && enable posix_memalign
check_func_headers malloc.h _aligned_malloc && enable aligned_malloc
check_func setrlimit
check_func strerror_r
check_func sched_getaffinity
check_func sysconf
check_func sysctl
check_func usleep
check_func_headers conio.h kbhit
check_func_headers windows.h PeekNamedPipe
check_func_headers io.h setmode
check_func_headers lzo/lzo1x.h lzo1x_999_compress
check_lib2 "windows.h shellapi.h" CommandLineToArgvW -lshell32
check_lib2 "windows.h wincrypt.h" CryptGenRandom -ladvapi32
check_lib2 "windows.h psapi.h" GetProcessMemoryInfo -lpsapi
check_func_headers windows.h GetProcessAffinityMask
check_func_headers windows.h GetProcessTimes
check_func_headers windows.h GetSystemTimeAsFileTime
check_func_headers windows.h MapViewOfFile
check_func_headers windows.h Sleep
check_func_headers windows.h VirtualAlloc
check_func_headers glob.h glob
check_header direct.h
check_header dlfcn.h
check_header dxva.h
check_header dxva2api.h -D_WIN32_WINNT=0x0600
check_header io.h
check_header libcrystalhd/libcrystalhd_if.h
check_header malloc.h
check_header poll.h
check_header sys/mman.h
check_header sys/param.h
check_header sys/resource.h
check_header sys/select.h
check_header sys/time.h
check_header termios.h
check_header unistd.h
check_header vdpau/vdpau.h
check_header vdpau/vdpau_x11.h
check_header windows.h
check_header X11/extensions/XvMClib.h
check_header asm/types.h
disabled zlib || check_lib zlib.h zlibVersion -lz || disable zlib
disabled bzlib || check_lib2 bzlib.h BZ2_bzlibVersion -lbz2 || disable bzlib
# check for VDA header
if ! disabled vda && ! enabled ppc; then
if check_header VideoDecodeAcceleration/VDADecoder.h; then
enable vda
add_extralibs -framework CoreFoundation -framework VideoDecodeAcceleration -framework QuartzCore
fi
fi
if ! disabled w32threads && ! enabled pthreads; then
check_func _beginthreadex && enable w32threads
fi
# check for some common methods of building with pthread support
# do this before the optional library checks as some of them require pthreads
if ! disabled pthreads && ! enabled w32threads && ! enabled os2threads; then
enable pthreads
if check_func pthread_create; then
:
elif check_func pthread_create -pthread; then
add_cflags -pthread
add_extralibs -pthread
elif check_func pthread_create -pthreads; then
add_cflags -pthreads
add_extralibs -pthreads
elif check_func pthread_create -lpthreadGC2; then
add_extralibs -lpthreadGC2
elif ! check_lib pthread.h pthread_create -lpthread; then
disable pthreads
fi
fi
for thread in $THREADS_LIST; do
if enabled $thread; then
test -n "$thread_type" &&
die "ERROR: Only one thread type must be selected." ||
thread_type="$thread"
fi
done
if enabled pthreads; then
check_func pthread_cancel
fi
check_lib math.h sin -lm && LIBM="-lm"
disabled crystalhd || check_lib libcrystalhd/libcrystalhd_if.h DtsCrystalHDVersion -lcrystalhd || disable crystalhd
enabled vaapi && require vaapi va/va.h vaInitialize -lva
atan2f_args=2
ldexpf_args=2
powf_args=2
for func in $MATH_FUNCS; do
eval check_mathfunc $func \${${func}_args:-1}
done
# these are off by default, so fail if requested and not available
enabled avisynth && require2 vfw32 "windows.h vfw.h" AVIFileInit -lavifil32
enabled fontconfig && require_pkg_config fontconfig "fontconfig/fontconfig.h" FcInit
enabled frei0r && { check_header frei0r.h || die "ERROR: frei0r.h header not found"; }
enabled gnutls && require_pkg_config gnutls gnutls/gnutls.h gnutls_global_init
enabled libiec61883 && require libiec61883 libiec61883/iec61883.h iec61883_cmp_connect -lraw1394 -lavc1394 -lrom1394 -liec61883
enabled libaacplus && require "libaacplus >= 2.0.0" aacplus.h aacplusEncOpen -laacplus
enabled libass && require_pkg_config libass ass/ass.h ass_library_init
enabled libbluray && require libbluray libbluray/bluray.h bd_open -lbluray
enabled libcdio && require2 libcdio "cdio/cdda.h cdio/paranoia.h" cdio_cddap_open -lcdio_paranoia -lcdio_cdda -lcdio
enabled libcelt && require libcelt celt/celt.h celt_decode -lcelt0 &&
{ check_lib celt/celt.h celt_decoder_create_custom -lcelt0 ||
die "ERROR: libcelt must be installed and version must be >= 0.11.0."; }
enabled libcaca && require_pkg_config caca caca.h caca_create_canvas
enabled libfaac && require2 libfaac "stdint.h faac.h" faacEncGetVersion -lfaac
enabled libfdk_aac && require libfdk_aac fdk-aac/aacenc_lib.h aacEncOpen -lfdk-aac
flite_libs="-lflite_cmu_time_awb -lflite_cmu_us_awb -lflite_cmu_us_kal -lflite_cmu_us_kal16 -lflite_cmu_us_rms -lflite_cmu_us_slt -lflite_usenglish -lflite_cmulex -lflite"
enabled libflite && require2 libflite "flite/flite.h" flite_init $flite_libs
enabled libfreetype && require_pkg_config freetype2 "ft2build.h freetype/freetype.h" FT_Init_FreeType
enabled libgsm && require libgsm gsm/gsm.h gsm_create -lgsm
enabled libilbc && require libilbc ilbc.h WebRtcIlbcfix_InitDecode -lilbc
enabled libmodplug && require libmodplug libmodplug/modplug.h ModPlug_Load -lmodplug
enabled libmp3lame && require "libmp3lame >= 3.98.3" lame/lame.h lame_set_VBR_quality -lmp3lame
enabled libnut && require libnut libnut.h nut_demuxer_init -lnut
enabled libopencore_amrnb && require libopencore_amrnb opencore-amrnb/interf_dec.h Decoder_Interface_init -lopencore-amrnb
enabled libopencore_amrwb && require libopencore_amrwb opencore-amrwb/dec_if.h D_IF_init -lopencore-amrwb
enabled libopencv && require_pkg_config opencv opencv/cxcore.h cvCreateImageHeader
enabled libopenjpeg && require libopenjpeg openjpeg.h opj_version -lopenjpeg
enabled libopus && require_pkg_config opus opus_multistream.h opus_multistream_decoder_create
enabled libpulse && require_pkg_config libpulse-simple pulse/simple.h pa_simple_new
enabled librtmp && require_pkg_config librtmp librtmp/rtmp.h RTMP_Socket
enabled libschroedinger && require_pkg_config schroedinger-1.0 schroedinger/schro.h schro_init
enabled libspeex && require libspeex speex/speex.h speex_decoder_init -lspeex
enabled libstagefright_h264 && require_cpp libstagefright_h264 "binder/ProcessState.h media/stagefright/MetaData.h
media/stagefright/MediaBufferGroup.h media/stagefright/MediaDebug.h media/stagefright/MediaDefs.h
media/stagefright/OMXClient.h media/stagefright/OMXCodec.h" android::OMXClient -lstagefright -lmedia -lutils -lbinder -lgnustl_static
enabled libtheora && require libtheora theora/theoraenc.h th_info_init -ltheoraenc -ltheoradec -logg
enabled libtwolame && require libtwolame twolame.h twolame_init -ltwolame &&
{ check_lib twolame.h twolame_encode_buffer_float32_interleaved -ltwolame ||
die "ERROR: libtwolame must be installed and version must be >= 0.3.10"; }
enabled libutvideo && require_cpp utvideo "stdint.h stdlib.h utvideo/utvideo.h utvideo/Codec.h" 'CCodec*' -lutvideo -lstdc++
enabled libv4l2 && require_pkg_config libv4l2 libv4l2.h v4l2_ioctl
enabled libvo_aacenc && require libvo_aacenc vo-aacenc/voAAC.h voGetAACEncAPI -lvo-aacenc
enabled libvo_amrwbenc && require libvo_amrwbenc vo-amrwbenc/enc_if.h E_IF_init -lvo-amrwbenc
enabled libvorbis && require libvorbis vorbis/vorbisenc.h vorbis_info_init -lvorbisenc -lvorbis -logg
enabled libvpx && {
enabled libvpx_decoder && { check_lib2 "vpx/vpx_decoder.h vpx/vp8dx.h" vpx_codec_dec_init_ver -lvpx ||
die "ERROR: libvpx decoder must be installed and version must be >=0.9.1"; }
enabled libvpx_encoder && { check_lib2 "vpx/vpx_encoder.h vpx/vp8cx.h" "vpx_codec_enc_init_ver VP8E_SET_MAX_INTRA_BITRATE_PCT" -lvpx ||
die "ERROR: libvpx encoder version must be >=0.9.7"; } }
enabled libx264 && require libx264 x264.h x264_encoder_encode -lx264 &&
{ check_cpp_condition x264.h "X264_BUILD >= 118" ||
die "ERROR: libx264 must be installed and version must be >= 0.118."; }
enabled libxavs && require libxavs xavs.h xavs_encoder_encode -lxavs
enabled libxvid && require libxvid xvid.h xvid_global -lxvidcore
enabled openal && { { for al_libs in "${OPENAL_LIBS}" "-lopenal" "-lOpenAL32"; do
check_lib 'AL/al.h' alGetError "${al_libs}" && break; done } ||
die "ERROR: openal not found"; } &&
{ check_cpp_condition "AL/al.h" "defined(AL_VERSION_1_1)" ||
die "ERROR: openal must be installed and version must be 1.1 or compatible"; }
enabled openssl && { check_lib openssl/ssl.h SSL_library_init -lssl -lcrypto ||
check_lib openssl/ssl.h SSL_library_init -lssl32 -leay32 ||
check_lib openssl/ssl.h SSL_library_init -lssl -lcrypto -lws2_32 -lgdi32 ||
die "ERROR: openssl not found"; }
if enabled gnutls; then
{ check_lib nettle/bignum.h nettle_mpz_get_str_256 -lnettle -lhogweed -lgmp && enable nettle; } ||
{ check_lib gcrypt.h gcry_mpi_new -lgcrypt && enable gcrypt; }
fi
# libdc1394 check
if enabled libdc1394; then
{ check_lib dc1394/dc1394.h dc1394_new -ldc1394 -lraw1394 &&
enable libdc1394_2; } ||
{ check_lib libdc1394/dc1394_control.h dc1394_create_handle -ldc1394_control -lraw1394 &&
enable libdc1394_1; } ||
die "ERROR: No version of libdc1394 found "
fi
SDL_CONFIG="${cross_prefix}sdl-config"
if check_pkg_config sdl SDL_events.h SDL_PollEvent; then
check_cpp_condition SDL.h "(SDL_MAJOR_VERSION<<16 | SDL_MINOR_VERSION<<8 | SDL_PATCHLEVEL) >= 0x010201" $sdl_cflags &&
enable sdl &&
check_struct SDL.h SDL_VideoInfo current_w $sdl_cflags && enable sdl_video_size
else
if "${SDL_CONFIG}" --version > /dev/null 2>&1; then
sdl_cflags=$("${SDL_CONFIG}" --cflags)
sdl_libs=$("${SDL_CONFIG}" --libs)
check_func_headers SDL_version.h SDL_Linked_Version $sdl_cflags $sdl_libs &&
check_cpp_condition SDL.h "(SDL_MAJOR_VERSION<<16 | SDL_MINOR_VERSION<<8 | SDL_PATCHLEVEL) >= 0x010201" $sdl_cflags &&
enable sdl &&
check_struct SDL.h SDL_VideoInfo current_w $sdl_cflags && enable sdl_video_size
fi
fi
enabled sdl && add_cflags $sdl_cflags && add_extralibs $sdl_libs
texi2html --help 2> /dev/null | grep -q 'init-file' && enable texi2html || disable texi2html
makeinfo --version > /dev/null 2>&1 && enable makeinfo || disable makeinfo
perl --version > /dev/null 2>&1 && enable perl || disable perl
pod2man --help > /dev/null 2>&1 && enable pod2man || disable pod2man
check_header linux/fb.h
check_header linux/videodev.h
check_header linux/videodev2.h
check_struct linux/videodev2.h "struct v4l2_frmivalenum" discrete
check_header sys/videoio.h
check_func_headers "windows.h vfw.h" capCreateCaptureWindow "$vfwcap_indev_extralibs"
# check that WM_CAP_DRIVER_CONNECT is defined to the proper value
# w32api 3.12 had it defined wrong
check_cpp_condition vfw.h "WM_CAP_DRIVER_CONNECT > WM_USER" && enable vfwcap_defines
check_type "dshow.h" IBaseFilter
# check for ioctl_meteor.h, ioctl_bt848.h and alternatives
{ check_header dev/bktr/ioctl_meteor.h &&
check_header dev/bktr/ioctl_bt848.h; } ||
{ check_header machine/ioctl_meteor.h &&
check_header machine/ioctl_bt848.h; } ||
{ check_header dev/video/meteor/ioctl_meteor.h &&
check_header dev/video/bktr/ioctl_bt848.h; } ||
check_header dev/ic/bt8xx.h
check_header sndio.h
if check_struct sys/soundcard.h audio_buf_info bytes; then
enable_safe sys/soundcard.h
else
check_cc -D__BSD_VISIBLE -D__XSI_VISIBLE <<EOF && add_cppflags -D__BSD_VISIBLE -D__XSI_VISIBLE && enable_safe sys/soundcard.h
#include <sys/soundcard.h>
audio_buf_info abc;
EOF
fi
check_header soundcard.h
enabled_any alsa_indev alsa_outdev && check_lib2 alsa/asoundlib.h snd_pcm_htimestamp -lasound
enabled jack_indev && check_lib2 jack/jack.h jack_client_open -ljack && check_func sem_timedwait &&
check_func jack_port_get_latency_range -ljack
enabled_any sndio_indev sndio_outdev && check_lib2 sndio.h sio_open -lsndio
enabled x11grab &&
require X11 X11/Xlib.h XOpenDisplay -lX11 &&
require Xext X11/extensions/XShm.h XShmCreateImage -lXext &&
require Xfixes X11/extensions/Xfixes.h XFixesGetCursorImage -lXfixes
if ! disabled vaapi; then
check_lib va/va.h vaInitialize -lva && {
check_cpp_condition va/va_version.h "VA_CHECK_VERSION(0,32,0)" ||
warn "Please upgrade to VA-API >= 0.32 if you would like full VA-API support.";
} || disable vaapi
fi
if ! disabled vdpau && enabled vdpau_vdpau_h; then
check_cpp_condition vdpau/vdpau.h "defined VDP_DECODER_PROFILE_MPEG4_PART2_ASP" ||
{ echolog "Please upgrade to libvdpau >= 0.2 if you would like vdpau support." && disable vdpau; }
fi
enabled debug && add_cflags -g"$debuglevel" && add_asflags -g"$debuglevel"
enabled coverage && add_cflags "-fprofile-arcs -ftest-coverage" && add_ldflags "-fprofile-arcs -ftest-coverage"
test -n "$valgrind" && target_exec="$valgrind --error-exitcode=1 --malloc-fill=0x2a --track-origins=yes --leak-check=full --gen-suppressions=all --suppressions=$source_path/tests/fate-valgrind.supp"
# add some useful compiler flags if supported
check_cflags -Wdeclaration-after-statement
check_cflags -Wall
check_cflags -Wno-parentheses
check_cflags -Wno-switch
check_cflags -Wno-format-zero-length
check_cflags -Wdisabled-optimization
check_cflags -Wpointer-arith
check_cflags -Wredundant-decls
check_cflags -Wno-pointer-sign
check_cflags -Wwrite-strings
check_cflags -Wtype-limits
check_cflags -Wundef
check_cflags -Wmissing-prototypes
check_cflags -Wno-pointer-to-int-cast
check_cflags -Wstrict-prototypes
enabled extra_warnings && check_cflags -Winline
# add some linker flags
check_ldflags -Wl,--warn-common
check_ldflags -Wl,-rpath-link=libpostproc:libswresample:libswscale:libavfilter:libavdevice:libavformat:libavcodec:libavutil:libavresample
test_ldflags -Wl,-Bsymbolic && append SHFLAGS -Wl,-Bsymbolic
enabled xmm_clobber_test &&
check_ldflags -Wl,--wrap,avcodec_open2 \
-Wl,--wrap,avcodec_decode_audio4 \
-Wl,--wrap,avcodec_decode_video2 \
-Wl,--wrap,avcodec_decode_subtitle2 \
-Wl,--wrap,avcodec_encode_audio2 \
-Wl,--wrap,avcodec_encode_video \
-Wl,--wrap,avcodec_encode_subtitle \
-Wl,--wrap,sws_scale ||
disable xmm_clobber_test
echo "X{};" > $TMPV
if test_ldflags -Wl,--version-script,$TMPV; then
append SHFLAGS '-Wl,--version-script,\$(SUBDIR)lib\$(NAME).ver'
check_cc <<EOF && enable symver_asm_label
void ff_foo(void) __asm__ ("av_foo@VERSION");
void ff_foo(void) { ${inline_asm+__asm__($quotes);} }
EOF
check_cc <<EOF && enable symver_gnu_asm
__asm__(".symver ff_foo,av_foo@VERSION");
void ff_foo(void) {}
EOF
fi
if [ -z "$optflags" ]; then
if enabled small; then
optflags=$cflags_size
elif enabled optimizations; then
optflags=$cflags_speed
else
optflags=$cflags_noopt
fi
fi
check_optflags(){
check_cflags "$@"
enabled lto && check_ldflags "$@"
}
if enabled lto; then
test "$cc_type" != "$ld_type" && die "LTO requires same compiler and linker"
check_cflags -flto
check_ldflags -flto $cpuflags
fi
check_optflags $optflags
check_optflags -fno-math-errno
check_optflags -fno-signed-zeros
enabled ftrapv && check_cflags -ftrapv
check_cc -mno-red-zone <<EOF && noredzone_flags="-mno-red-zone"
int x;
EOF
if enabled icc; then
# Just warnings, no remarks
check_cflags -w1
# -wd: Disable following warnings
# 144, 167, 556: -Wno-pointer-sign
# 1292: attribute "foo" ignored
# 1419: external declaration in primary source file
# 10006: ignoring unknown option -fno-signed-zeros
# 10148: ignoring unknown option -Wno-parentheses
# 10156: ignoring option '-W'; no argument required
check_cflags -wd144,167,556,1292,1419,10006,10148,10156
# 11030: Warning unknown option --as-needed
# 10156: ignoring option '-export'; no argument required
check_ldflags -wd10156,11030
# Allow to compile with optimizations
check_ldflags -march=$cpu
# icc 11.0 and 11.1 work with ebp_available, but don't pass the test
enable ebp_available
if enabled x86_32; then
icc_version=$($cc -dumpversion)
test ${icc_version%%.*} -ge 11 &&
check_cflags -falign-stack=maintain-16-byte ||
disable aligned_stack
fi
elif enabled ccc; then
# disable some annoying warnings
add_cflags -msg_disable cvtu32to64
add_cflags -msg_disable embedcomment
add_cflags -msg_disable needconstext
add_cflags -msg_disable nomainieee
add_cflags -msg_disable ptrmismatch1
add_cflags -msg_disable unreachcode
elif enabled gcc; then
check_optflags -fno-tree-vectorize
check_cflags -Werror=implicit-function-declaration
check_cflags -Werror=missing-prototypes
check_cflags -Werror=vla
elif enabled llvm_gcc; then
check_cflags -mllvm -stack-alignment=16
elif enabled clang; then
check_cflags -mllvm -stack-alignment=16
check_cflags -Qunused-arguments
check_cflags -Werror=implicit-function-declaration
check_cflags -Werror=missing-prototypes
elif enabled armcc; then
# 2523: use of inline assembler is deprecated
add_cflags -W${armcc_opt},--diag_suppress=2523
add_cflags -W${armcc_opt},--diag_suppress=1207
add_cflags -W${armcc_opt},--diag_suppress=1293 # assignment in condition
add_cflags -W${armcc_opt},--diag_suppress=3343 # hardfp compat
add_cflags -W${armcc_opt},--diag_suppress=167 # pointer sign
add_cflags -W${armcc_opt},--diag_suppress=513 # pointer sign
elif enabled tms470; then
add_cflags -pds=824 -pds=837
elif enabled pathscale; then
add_cflags -fstrict-overflow -OPT:wrap_around_unsafe_opt=OFF
elif enabled msvc; then
enabled x86_32 && disable aligned_stack
fi
case $target_os in
plan9)
add_cppflags -Dmain=plan9_main
;;
esac
enabled_any $THREADS_LIST && enable threads
enabled asm || { arch=c; disable $ARCH_LIST $ARCH_EXT_LIST; }
check_deps $CONFIG_LIST \
$CONFIG_EXTRA \
$HAVE_LIST \
$ALL_COMPONENTS \
if test $target_os = "haiku"; then
disable memalign
disable posix_memalign
fi
! enabled_any memalign posix_memalign aligned_malloc &&
enabled_any $need_memalign && enable memalign_hack
# add_dep lib dep
# -> enable ${lib}_deps_${dep}
# -> add $dep to ${lib}_deps only once
add_dep() {
lib=$1
dep=$2
enabled "${lib}_deps_${dep}" && return 0
enable "${lib}_deps_${dep}"
prepend "${lib}_deps" $dep
}
# merge deps lib components
# merge all ${component}_deps into ${lib}_deps and ${lib}_deps_*
merge_deps() {
lib=$1
shift
for comp in $*; do
enabled $comp || continue
eval "dep=\"\$${comp}_deps\""
for d in $dep; do
add_dep $lib $d
done
done
}
merge_deps libavfilter $FILTER_LIST
echo "install prefix $prefix"
echo "source path $source_path"
echo "C compiler $cc"
echo "ARCH $arch ($cpu)"
if test "$build_suffix" != ""; then
echo "build suffix $build_suffix"
fi
if test "$progs_suffix" != ""; then
echo "progs suffix $progs_suffix"
fi
if test "$extra_version" != ""; then
echo "version string suffix $extra_version"
fi
echo "big-endian ${bigendian-no}"
echo "runtime cpu detection ${runtime_cpudetect-no}"
if enabled x86; then
echo "${yasmexe} ${yasm-no}"
echo "MMX enabled ${mmx-no}"
echo "MMXEXT enabled ${mmxext-no}"
echo "3DNow! enabled ${amd3dnow-no}"
echo "3DNow! extended enabled ${amd3dnowext-no}"
echo "SSE enabled ${sse-no}"
echo "SSSE3 enabled ${ssse3-no}"
echo "AVX enabled ${avx-no}"
echo "FMA4 enabled ${fma4-no}"
echo "CMOV enabled ${cmov-no}"
echo "CMOV is fast ${fast_cmov-no}"
echo "EBX available ${ebx_available-no}"
echo "EBP available ${ebp_available-no}"
fi
if enabled arm; then
echo "ARMv5TE enabled ${armv5te-no}"
echo "ARMv6 enabled ${armv6-no}"
echo "ARMv6T2 enabled ${armv6t2-no}"
echo "ARM VFP enabled ${armvfp-no}"
echo "NEON enabled ${neon-no}"
fi
if enabled mips; then
echo "MIPS FPU enabled ${mipsfpu-no}"
echo "MIPS32R2 enabled ${mips32r2-no}"
echo "MIPS DSP R1 enabled ${mipsdspr1-no}"
echo "MIPS DSP R2 enabled ${mipsdspr2-no}"
fi
if enabled ppc; then
echo "AltiVec enabled ${altivec-no}"
echo "PPC 4xx optimizations ${ppc4xx-no}"
echo "dcbzl available ${dcbzl-no}"
fi
if enabled sparc; then
echo "VIS enabled ${vis-no}"
fi
echo "debug symbols ${debug-no}"
echo "strip symbols ${stripping-no}"
echo "optimize for size ${small-no}"
echo "optimizations ${optimizations-no}"
echo "static ${static-no}"
echo "shared ${shared-no}"
echo "postprocessing support ${postproc-no}"
echo "new filter support ${avfilter-no}"
echo "network support ${network-no}"
echo "threading support ${thread_type-no}"
echo "safe bitstream reader ${safe_bitstream_reader-no}"
echo "SDL support ${sdl-no}"
echo "libdxva2 enabled ${dxva2-no}"
echo "libva enabled ${vaapi-no}"
echo "libvdpau enabled ${vdpau-no}"
echo "AVISynth enabled ${avisynth-no}"
echo "frei0r enabled ${frei0r-no}"
echo "gnutls enabled ${gnutls-no}"
echo "libaacplus enabled ${libaacplus-no}"
echo "libass enabled ${libass-no}"
echo "libcaca enabled ${libcaca-no}"
echo "libcdio support ${libcdio-no}"
echo "libcelt enabled ${libcelt-no}"
echo "libdc1394 support ${libdc1394-no}"
echo "libfaac enabled ${libfaac-no}"
echo "libfdk-aac enabled ${libfdk_aac-no}"
echo "libgsm enabled ${libgsm-no}"
echo "libiec61883 support ${libiec61883-no}"
echo "libilbc enabled ${libilbc-no}"
echo "libmodplug enabled ${libmodplug-no}"
echo "libmp3lame enabled ${libmp3lame-no}"
echo "libnut enabled ${libnut-no}"
echo "libopencore-amrnb support ${libopencore_amrnb-no}"
echo "libopencore-amrwb support ${libopencore_amrwb-no}"
echo "libopencv support ${libopencv-no}"
echo "libopenjpeg enabled ${libopenjpeg-no}"
echo "libopus enabled ${libopus-no}"
echo "libpulse enabled ${libpulse-no}"
echo "librtmp enabled ${librtmp-no}"
echo "libschroedinger enabled ${libschroedinger-no}"
echo "libspeex enabled ${libspeex-no}"
echo "libstagefright-h264 enabled ${libstagefright_h264-no}"
echo "libtheora enabled ${libtheora-no}"
echo "libtwolame enabled ${libtwolame-no}"
echo "libutvideo enabled ${libutvideo-no}"
echo "libv4l2 enabled ${libv4l2-no}"
echo "libvo-aacenc support ${libvo_aacenc-no}"
echo "libvo-amrwbenc support ${libvo_amrwbenc-no}"
echo "libvorbis enabled ${libvorbis-no}"
echo "libvpx enabled ${libvpx-no}"
echo "libx264 enabled ${libx264-no}"
echo "libxavs enabled ${libxavs-no}"
echo "libxvid enabled ${libxvid-no}"
echo "openal enabled ${openal-no}"
echo "openssl enabled ${openssl-no}"
echo "zlib enabled ${zlib-no}"
echo "bzlib enabled ${bzlib-no}"
echo "texi2html enabled ${texi2html-no}"
echo "perl enabled ${perl-no}"
echo "pod2man enabled ${pod2man-no}"
echo "makeinfo enabled ${makeinfo-no}"
test -n "$random_seed" &&
echo "random seed ${random_seed}"
echo
for type in decoder encoder hwaccel parser demuxer muxer protocol filter bsf indev outdev; do
echo "Enabled ${type}s:"
eval list=\$$(toupper $type)_LIST
print_enabled '_*' $list | sort | pr -r -3 -t
echo
done
license="LGPL version 2.1 or later"
if enabled nonfree; then
license="nonfree and unredistributable"
elif enabled gplv3; then
license="GPL version 3 or later"
elif enabled lgplv3; then
license="LGPL version 3 or later"
elif enabled gpl; then
license="GPL version 2 or later"
fi
echo "License: $license"
echo "Creating config.mak and config.h..."
test -e Makefile || $ln_s "$source_path/Makefile" .
enabled stripping || strip="echo skipping strip"
config_files="$TMPH config.mak"
cat > config.mak <<EOF
# Automatically generated by configure - do not modify!
ifndef FFMPEG_CONFIG_MAK
FFMPEG_CONFIG_MAK=1
FFMPEG_CONFIGURATION=$FFMPEG_CONFIGURATION
prefix=$prefix
LIBDIR=\$(DESTDIR)$libdir
SHLIBDIR=\$(DESTDIR)$shlibdir
INCDIR=\$(DESTDIR)$incdir
BINDIR=\$(DESTDIR)$bindir
DATADIR=\$(DESTDIR)$datadir
MANDIR=\$(DESTDIR)$mandir
SRC_PATH=$source_path
ifndef MAIN_MAKEFILE
SRC_PATH:=\$(SRC_PATH:.%=..%)
endif
CC_IDENT=$cc_ident
ARCH=$arch
CC=$cc
CXX=$cxx
AS=$as
LD=$ld
DEPCC=$dep_cc
DEPCCFLAGS=$DEPCCFLAGS \$(CPPFLAGS)
DEPAS=$as
DEPASFLAGS=$DEPASFLAGS \$(CPPFLAGS)
YASM=$yasmexe
DEPYASM=$yasmexe
AR=$ar
ARFLAGS=$arflags
AR_O=$ar_o
RANLIB=$ranlib
CP=cp -p
LN_S=$ln_s
STRIP=$strip
CPPFLAGS=$CPPFLAGS
CFLAGS=$CFLAGS
CXXFLAGS=$CXXFLAGS
ASFLAGS=$ASFLAGS
AS_C=$AS_C
AS_O=$AS_O
CC_C=$CC_C
CC_O=$CC_O
CXX_C=$CXX_C
CXX_O=$CXX_O
LD_O=$LD_O
LD_LIB=$LD_LIB
LD_PATH=$LD_PATH
DLLTOOL=$dlltool
LDFLAGS=$LDFLAGS
LDFLAGS-ffserver=$FFSERVERLDFLAGS
SHFLAGS=$SHFLAGS
YASMFLAGS=$YASMFLAGS
BUILDSUF=$build_suffix
PROGSSUF=$progs_suffix
FULLNAME=$FULLNAME
LIBPREF=$LIBPREF
LIBSUF=$LIBSUF
LIBNAME=$LIBNAME
SLIBPREF=$SLIBPREF
SLIBSUF=$SLIBSUF
EXESUF=$EXESUF
EXTRA_VERSION=$extra_version
CCDEP=$CCDEP
CXXDEP=$CXXDEP
CCDEP_FLAGS=$CCDEP_FLAGS
ASDEP=$ASDEP
ASDEP_FLAGS=$ASDEP_FLAGS
CC_DEPFLAGS=$CC_DEPFLAGS
AS_DEPFLAGS=$AS_DEPFLAGS
HOSTCC=$host_cc
HOSTLD=$host_ld
HOSTCFLAGS=$host_cflags
HOSTEXESUF=$HOSTEXESUF
HOSTLDFLAGS=$host_ldflags
HOSTLIBS=$host_libs
DEPHOSTCC=$host_cc
DEPHOSTCCFLAGS=$DEPHOSTCCFLAGS \$(HOSTCCFLAGS)
HOSTCCDEP=$HOSTCCDEP
HOSTCCDEP_FLAGS=$HOSTCCDEP_FLAGS
HOSTCC_DEPFLAGS=$HOSTCC_DEPFLAGS
HOSTCC_C=$HOSTCC_C
HOSTCC_O=$HOSTCC_O
HOSTLD_O=$HOSTLD_O
TARGET_EXEC=$target_exec
TARGET_PATH=$target_path
LIBS-ffplay=$sdl_libs
CFLAGS-ffplay=$sdl_cflags
ZLIB=$($ldflags_filter -lz)
LIB_INSTALL_EXTRA_CMD=$LIB_INSTALL_EXTRA_CMD
EXTRALIBS=$extralibs
COMPAT_OBJS=$compat_objs
EXEOBJS=$exeobjs
INSTALL=$install
LIBTARGET=${LIBTARGET}
SLIBNAME=${SLIBNAME}
SLIBNAME_WITH_VERSION=${SLIBNAME_WITH_VERSION}
SLIBNAME_WITH_MAJOR=${SLIBNAME_WITH_MAJOR}
SLIB_CREATE_DEF_CMD=${SLIB_CREATE_DEF_CMD}
SLIB_EXTRA_CMD=${SLIB_EXTRA_CMD}
SLIB_INSTALL_NAME=${SLIB_INSTALL_NAME}
SLIB_INSTALL_LINKS=${SLIB_INSTALL_LINKS}
SLIB_INSTALL_EXTRA_LIB=${SLIB_INSTALL_EXTRA_LIB}
SLIB_INSTALL_EXTRA_SHLIB=${SLIB_INSTALL_EXTRA_SHLIB}
SAMPLES:=${samples:-\$(FATE_SAMPLES)}
NOREDZONE_FLAGS=$noredzone_flags
EOF
get_version(){
lcname=$1
name=$(toupper $lcname)
file=$source_path/$lcname/version.h
eval $(awk "/#define ${name}_VERSION_M/ { print \$2 \"=\" \$3 }" "$file")
eval ${name}_VERSION=\$${name}_VERSION_MAJOR.\$${name}_VERSION_MINOR.\$${name}_VERSION_MICRO
eval echo "${lcname}_VERSION=\$${name}_VERSION" >> config.mak
eval echo "${lcname}_VERSION_MAJOR=\$${name}_VERSION_MAJOR" >> config.mak
}
get_version_old(){
name=$1
file=$source_path/$2
# This condition will be removed when we stop supporting old libpostproc versions
if ! test "$name" = LIBPOSTPROC || test "$postproc_version" = current; then
eval $(grep "#define ${name}_VERSION_M" "$file" | awk '{ print $2"="$3 }')
eval ${name}_VERSION=\$${name}_VERSION_MAJOR.\$${name}_VERSION_MINOR.\$${name}_VERSION_MICRO
fi
lcname=$(tolower $name)
eval echo "${lcname}_VERSION=\$${name}_VERSION" >> config.mak
eval echo "${lcname}_VERSION_MAJOR=\$${name}_VERSION_MAJOR" >> config.mak
}
get_version_old LIBPOSTPROC libpostproc/version.h
get_version libavcodec
get_version libavdevice
get_version libavfilter
get_version libavformat
get_version libavresample
get_version libavutil
get_version libswresample
get_version libswscale
cat > $TMPH <<EOF
/* Automatically generated by configure - do not modify! */
#ifndef FFMPEG_CONFIG_H
#define FFMPEG_CONFIG_H
#define FFMPEG_CONFIGURATION "$(c_escape $FFMPEG_CONFIGURATION)"
#define FFMPEG_LICENSE "$(c_escape $license)"
#define FFMPEG_DATADIR "$(eval c_escape $datadir)"
#define AVCONV_DATADIR "$(eval c_escape $datadir)"
#define CC_IDENT "$(c_escape ${cc_ident:-Unknown compiler})"
#define av_restrict $_restrict
#define EXTERN_PREFIX "${extern_prefix}"
#define EXTERN_ASM ${extern_prefix}
#define SLIBSUF "$SLIBSUF"
#define HAVE_MMX2 HAVE_MMXEXT
EOF
test -n "$assert_level" &&
echo "#define ASSERT_LEVEL $assert_level" >>$TMPH
test -n "$malloc_prefix" &&
echo "#define MALLOC_PREFIX $malloc_prefix" >>$TMPH
if enabled yasm; then
append config_files $TMPASM
printf '' >$TMPASM
fi
print_config ARCH_ "$config_files" $ARCH_LIST
print_config HAVE_ "$config_files" $HAVE_LIST
print_config CONFIG_ "$config_files" $CONFIG_LIST \
$CONFIG_EXTRA \
$ALL_COMPONENTS \
echo "#endif /* FFMPEG_CONFIG_H */" >> $TMPH
echo "endif # FFMPEG_CONFIG_MAK" >> config.mak
# Do not overwrite an unchanged config.h to avoid superfluous rebuilds.
cp_if_changed $TMPH config.h
touch .config
enabled yasm && cp_if_changed $TMPASM config.asm
cat > $TMPH <<EOF
/* Generated by ffconf */
#ifndef AVUTIL_AVCONFIG_H
#define AVUTIL_AVCONFIG_H
EOF
test "$postproc_version" != current && cat >> $TMPH <<EOF
#define LIBPOSTPROC_VERSION_MAJOR $LIBPOSTPROC_VERSION_MAJOR
#define LIBPOSTPROC_VERSION_MINOR $LIBPOSTPROC_VERSION_MINOR
#define LIBPOSTPROC_VERSION_MICRO $LIBPOSTPROC_VERSION_MICRO
EOF
print_config AV_HAVE_ $TMPH $HAVE_LIST_PUB
echo "#endif /* AVUTIL_AVCONFIG_H */" >> $TMPH
cp_if_changed $TMPH libavutil/avconfig.h
if test -n "$WARNINGS"; then
printf "\n$WARNINGS"
enabled fatal_warnings && exit 1
fi
# build pkg-config files
pkgconfig_generate(){
name=$1
shortname=${name#lib}${build_suffix}
comment=$2
version=$3
libs=$4
requires=$5
enabled ${name#lib} || return 0
mkdir -p $name
cat <<EOF > $name/$name.pc
prefix=$prefix
exec_prefix=\${prefix}
libdir=$libdir
includedir=$incdir
Name: $name
Description: $comment
Version: $version
Requires: $(enabled shared || echo $requires)
Requires.private: $(enabled shared && echo $requires)
Conflicts:
Libs: -L\${libdir} -l${shortname} $(enabled shared || echo $libs)
Libs.private: $(enabled shared && echo $libs)
Cflags: -I\${includedir}
EOF
mkdir -p doc/examples/pc-uninstalled
includedir=${source_path}
[ "$includedir" = . ] && includedir="\${pcfiledir}/../../.."
cat <<EOF > doc/examples/pc-uninstalled/$name.pc
prefix=
exec_prefix=
libdir=\${pcfiledir}/../../../$name
includedir=${includedir}
Name: $name
Description: $comment
Version: $version
Requires: $requires
Conflicts:
Libs: -L\${libdir} -l${shortname} $(enabled shared || echo $libs)
Cflags: -I\${includedir}
EOF
}
libavfilter_pc_deps="libavutil = $LIBAVUTIL_VERSION"
enabled libavfilter_deps_avcodec && prepend libavfilter_pc_deps "libavcodec = $LIBAVCODEC_VERSION,"
enabled libavfilter_deps_avformat && prepend libavfilter_pc_deps "libavformat = $LIBAVFORMAT_VERSION,"
enabled libavfilter_deps_swscale && prepend libavfilter_pc_deps "libswscale = $LIBSWSCALE_VERSION,"
enabled libavfilter_deps_swresample && prepend libavfilter_pc_deps "libswresample = $LIBSWRESAMPLE_VERSION,"
enabled libavfilter_deps_postproc && prepend libavfilter_pc_deps "libpostproc = $LIBPOSTPROC_VERSION,"
libavfilter_pc_deps=${libavfilter_pc_deps%, }
libavdevice_pc_deps="libavformat = $LIBAVFORMAT_VERSION"
enabled lavfi_indev && prepend libavdevice_pc_deps "libavfilter = $LIBAVFILTER_VERSION,"
pkgconfig_generate libavutil "FFmpeg utility library" "$LIBAVUTIL_VERSION" "$LIBM"
pkgconfig_generate libavcodec "FFmpeg codec library" "$LIBAVCODEC_VERSION" "$extralibs" "libavutil = $LIBAVUTIL_VERSION"
pkgconfig_generate libavformat "FFmpeg container format library" "$LIBAVFORMAT_VERSION" "$extralibs" "libavcodec = $LIBAVCODEC_VERSION"
pkgconfig_generate libavdevice "FFmpeg device handling library" "$LIBAVDEVICE_VERSION" "$extralibs" "$libavdevice_pc_deps"
pkgconfig_generate libavfilter "FFmpeg video filtering library" "$LIBAVFILTER_VERSION" "$extralibs" "$libavfilter_pc_deps"
pkgconfig_generate libpostproc "FFmpeg postprocessing library" "$LIBPOSTPROC_VERSION" "" "libavutil = $LIBAVUTIL_VERSION"
pkgconfig_generate libavresample "Libav audio resampling library" "$LIBAVRESAMPLE_VERSION" "$extralibs" "libavutil = $LIBAVUTIL_VERSION"
pkgconfig_generate libswscale "FFmpeg image rescaling library" "$LIBSWSCALE_VERSION" "$LIBM" "libavutil = $LIBAVUTIL_VERSION"
pkgconfig_generate libswresample "FFmpeg audio rescaling library" "$LIBSWRESAMPLE_VERSION" "$LIBM" "libavutil = $LIBAVUTIL_VERSION"
fix_ffmpeg_remote(){
git_remote_from=$1
git_remote_to=$2
fixme_remote=$(git --git-dir=$source_path/.git --work-tree=$source_path remote -v | grep $git_remote_from | cut -f 1 | sort | uniq)
if [ "$fixme_remote" != "" ]; then
echolog "
Outdated domain in git config, the official domain for ffmpeg git is since
November 2011, source.ffmpeg.org, both the old and the new point to the same
repository and server. To update it enter the following commands:
"
for remote in $fixme_remote; do
echolog "git remote set-url $remote $git_remote_to"
done
fi
}
if test -f "$source_path/.git/config"; then
remote_from=git.videolan.org
remote_to=source.ffmpeg.org
fix_ffmpeg_remote git@$remote_from:ffmpeg git@$remote_to:ffmpeg
fix_ffmpeg_remote git://$remote_from/ffmpeg git://$remote_to/ffmpeg
fi