#!/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

--disable-all disable building components, libraries and programs

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-avutil disable libavutil 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]

--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

Hardware accelerators:

--enable-dxva2 enable DXVA2 code

--enable-vaapi enable VAAPI code

--enable-vda enable VDA code

--enable-vdpau enable VDPAU code

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-iconv enable iconv [autodetect]

--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-libsoxr enable Include libsoxr resampling [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 and VP9 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-x11grab enable X11 grabbing [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-cppflags=HCPPFLAGS use HCPPFLAGS when compiling for host

--host-ld=HOSTLD use host linker HOSTLD

--host-ldflags=HLDFLAGS use HLDFLAGS when linking for host

--host-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-vfp disable 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

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

[email protected] 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

}

sanitize_var_name(){

echo $@ | sed 's/[^A-Za-z0-9_]/_/g'

}

set_safe(){

var=$1

shift

eval $(sanitize_var_name "$var")='$*'

}

get_safe(){

eval echo \$$(sanitize_var_name "$1")

}

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

}

do_check_deps(){

for cfg; do

cfg="${cfg#!}"

enabled ${cfg}_checking && die "Circular dependency for $cfg."

disabled ${cfg}_checking && continue

enable ${cfg}_checking

append allopts $cfg

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

do_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

enable_deep $dep_sel

enable_deep_weak $dep_sgs

fi

disable ${cfg}_checking

done

}

check_deps(){

unset allopts

do_check_deps "$@"

for cfg in $allopts; do

enabled $cfg || continue

eval dep_extralibs="\$${cfg}_extralibs"

test -n "$dep_extralibs" && add_extralibs $dep_extralibs

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_cppflags(){

append host_cppflags "$@"

}

add_host_cflags(){

append host_cflags $($host_cflags_filter "$@")

}

add_host_ldflags(){

append host_ldflags $($host_ldflags_filter "$@")

}

add_compat(){

append compat_objs $1

shift

map 'add_cppflags -D$v' "$@"

}

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 > $TMPS

log_file $TMPS

check_cmd $as $CPPFLAGS $ASFLAGS "$@" $AS_C $(as_o $TMPO) $TMPS

}

check_inline_asm(){

log check_inline_asm "$@"

name="$1"

code="$2"

shift 2

disable $name

check_cc "$@" <<EOF && enable $name

void foo(void){ __asm__ volatile($code); }

EOF

}

check_insn(){

log check_insn "$@"

check_inline_asm ${1}_inline "\"$2\""

echo "$2" | check_as && enable ${1}_external || disable ${1}_external

}

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*|*.so' $@)

libs=$(filter '-l*|*.so' $@)

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);

}