[libav.git] / configure

#!/bin/sh
#
# Libav 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 LIBAV, DO NOT REPORT IT AS SUCH."
    echo "Instead, install a working POSIX-compatible shell."
    echo "Disabling this configure test will create a broken Libav."
    if test "$BASH_VERSION" = '2.04.0(1)-release'; then
        echo "This bash version ($BASH_VERSION) is broken on your platform."
        echo "Upgrade to a later version if available."
    fi
    exit 1
fi

test -d /usr/xpg4/bin && PATH=/usr/xpg4/bin:$PATH

show_help(){
    cat <<EOF
Usage: configure [options]
Options: [defaults in brackets after descriptions]

Help options:
  --help                   print this message
  --quiet                  Suppress showing informative output
  --list-decoders          show all available decoders
  --list-encoders          show all available encoders
  --list-hwaccels          show all available hardware accelerators
  --list-demuxers          show all available demuxers
  --list-muxers            show all available muxers
  --list-parsers           show all available parsers
  --list-protocols         show all available protocols
  --list-bsfs              show all available bitstream filters
  --list-indevs            show all available input devices
  --list-outdevs           show all available output devices
  --list-filters           show all available filters

Standard options:
  --logfile=FILE           log tests and output to FILE [avbuild/config.log]
  --disable-logging        do not log configure debug information
  --prefix=PREFIX          install in PREFIX [$prefix_default]
  --bindir=DIR             install binaries in DIR [PREFIX/bin]
  --datadir=DIR            install data files in DIR [PREFIX/share/avconv]
  --docdir=DIR             install documentation in DIR [PREFIX/share/doc/libav]
  --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]
  --enable-rpath           use rpath when linking programs (USE WITH CARE)

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
  --enable-runtime-cpudetect detect CPU capabilities at runtime (bigger 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-avconv         disable avconv build
  --disable-avplay         disable avplay build
  --disable-avprobe        disable avprobe build
  --disable-avserver       deprecated, does nothing

Component options:
  --disable-doc            do not build documentation
  --disable-pod2man        do not build manual pages
  --disable-texi2html      do not build HTML documentation
  --disable-avdevice       disable libavdevice build
  --disable-avcodec        disable libavcodec build
  --disable-avformat       disable libavformat build
  --disable-avutil         disable libavutil build
  --disable-swscale        disable libswscale build
  --disable-avfilter       disable video filter support [no]
  --disable-avresample     disable libavresample build [no]
  --disable-pthreads       disable pthreads [auto]
  --disable-w32threads     disable Win32 threads [auto]
  --disable-network        disable network support [no]
  --disable-dct            disable DCT code
  --disable-error-resilience disable error resilience code
  --disable-lsp            disable LSP code
  --disable-lzo            disable LZO decoder code
  --disable-mdct           disable MDCT code
  --disable-rdft           disable RDFT code
  --disable-fft            disable FFT code
  --disable-faan           disable floating point AAN (I)DCT code

Individual component options:
  --disable-everything     disable all components listed below
  --disable-encoder=NAME   disable encoder NAME
  --enable-encoder=NAME    enable encoder NAME
  --disable-encoders       disable all encoders
  --disable-decoder=NAME   disable decoder NAME
  --enable-decoder=NAME    enable decoder NAME
  --disable-decoders       disable all decoders
  --disable-hwaccel=NAME   disable hwaccel NAME
  --enable-hwaccel=NAME    enable hwaccel NAME
  --disable-hwaccels       disable all hwaccels
  --disable-muxer=NAME     disable muxer NAME
  --enable-muxer=NAME      enable muxer NAME
  --disable-muxers         disable all muxers
  --disable-demuxer=NAME   disable demuxer NAME
  --enable-demuxer=NAME    enable demuxer NAME
  --disable-demuxers       disable all demuxers
  --enable-parser=NAME     enable parser NAME
  --disable-parser=NAME    disable parser NAME
  --disable-parsers        disable all parsers
  --enable-bsf=NAME        enable bitstream filter NAME
  --disable-bsf=NAME       disable bitstream filter NAME
  --disable-bsfs           disable all bitstream filters
  --enable-protocol=NAME   enable protocol NAME
  --disable-protocol=NAME  disable protocol NAME
  --disable-protocols      disable all protocols
  --enable-indev=NAME      enable input device NAME
  --disable-indev=NAME     disable input device NAME
  --disable-indevs         disable input devices
  --enable-outdev=NAME     enable output device NAME
  --disable-outdev=NAME    disable output device NAME
  --disable-outdevs        disable output devices
  --disable-devices        disable all devices
  --enable-filter=NAME     enable filter NAME
  --disable-filter=NAME    disable filter NAME
  --disable-filters        disable all filters

External library support:

  Using any of the following switches will allow Libav to link to the
  corresponding external library. All the components depending on that library
  will become enabled, if all their other dependencies are met and they are not
  explicitly disabled. E.g. --enable-libwavpack will enable linking to
  libwavpack and allow the libwavpack encoder to be built, unless it is
  specifically disabled with --disable-encoder=libwavpack.

  Note that only the system libraries are auto-detected. All the other external
  libraries must be explicitly enabled.

  Also note that the following help text describes the purpose of the libraries
  themselves, not all their features will necessarily be usable by Libav.

  --enable-avisynth          video frameserver
  --enable-avxsynth          Linux version of AviSynth
  --enable-bzlib             bzip2 compression [autodetect]
  --enable-frei0r            video filtering plugins
  --enable-gnutls            crypto
  --enable-libbs2b           Bauer stereophonic-to-binaural DSP
  --enable-libcdio           audio CD input
  --enable-libdc1394         IEEE 1394/Firewire camera input
  --enable-libdcadec         DCA audio decoding
  --enable-libfaac           AAC audio encoding
  --enable-libfdk-aac        AAC audio encoding/decoding
  --enable-libfontconfig     font configuration and management
  --enable-libfreetype       font rendering
  --enable-libgsm            GSM audio encoding/decoding
  --enable-libhdcd           HDCD decoding filter
  --enable-libilbc           ILBC audio encoding/decoding
  --enable-libkvazaar        HEVC video encoding
  --enable-libmp3lame        MP3 audio encoding
  --enable-libopencore-amrnb AMR-NB audio encoding/decoding
  --enable-libopencore-amrwb AMR-WB audio decoding
  --enable-libopencv         computer vision
  --enable-libopenh264       H.264 video encoding/decoding
  --enable-libopenjpeg       JPEG 2000 image encoding/decoding
  --enable-libopus           Opus audio encoding/decoding
  --enable-libpulse          Pulseaudio sound server
  --enable-librtmp           RTMP streaming
  --enable-libschroedinger   Dirac video encoding/decoding
  --enable-libsnappy         snappy compression
  --enable-libspeex          Speex audio encoding/decoding
  --enable-libtheora         Theora video encoding/decoding
  --enable-libtwolame        MP2 audio encoding
  --enable-libvo-aacenc      AAC audio encoding
  --enable-libvo-amrwbenc    AMR-WB audio encoding
  --enable-libvorbis         Vorbis audio encoding/decoding
  --enable-libvpx            VP* video encoding/decoding
  --enable-libwavpack        Wavpack audio encoding/decoding
  --enable-libwebp           WebP image encoding/decoding
  --enable-libx264           H.264 video encoding
  --enable-libx265           HEVC video encoding
  --enable-libxavs           Chinese AVS video encoding
  --enable-libxcb            X window system protocol communication
  --enable-libxcb-shm        X11 shm communication [auto]
  --enable-libxcb-xfixes     X11 mouse rendering [auto]
  --enable-libxvid           MPEG-4 ASP video encoding
  --enable-openssl           crypto
  --enable-zlib              compression [autodetect]

  The following libraries provide various hardware acceleration features:
  --enable-cuda    Nvidia CUDA (dynamically linked)
  --enable-d3d11va Microsoft Direct3D 11 video acceleration [auto]
  --enable-dxva2   Microsoft DirectX 9 video acceleration [auto]
  --enable-libmfx  Intel MediaSDK (AKA Quick Sync Video)
  --enable-libnpp  Nvidia CUDA processing
  --enable-mmal    Broadcom Multi-Media Abstraction Layer (Raspberry Pi)
  --enable-nvenc   Nvidia video encoding
  --enable-omx     OpenMAX IL
  --enable-omx-rpi OpenMAX IL for Raspberry Pi
  --enable-vaapi   Video Acceleration API (mainly Unix/Intel)
  --enable-vda     Apple Video Decode Acceleration [auto]
  --enable-vdpau   Nvidia Video Decode and Presentation API for Unix [auto]

Toolchain options:
  --arch=ARCH              select architecture [$arch]
  --cpu=CPU                select the minimum required CPU (affects
                           instruction selection, may crash on older CPUs)
  --cross-prefix=PREFIX    use PREFIX for compilation tools [$cross_prefix]
  --enable-cross-compile   assume a cross-compiler is used
  --sysroot=PATH           root of cross-build tree
  --sysinclude=PATH        location of cross-build system headers
  --target-os=OS           compiler targets OS [$target_os]
  --target-exec=CMD        command to run executables on target
  --target-path=DIR        path to view of build directory on target
  --target-samples=DIR     path to samples directory on target
  --toolchain=NAME         set tool defaults according to NAME
  --nm=NM                  use nm tool
  --ar=AR                  use archive tool AR [$ar_default]
  --as=AS                  use assembler AS [$as_default]
  --cc=CC                  use C compiler CC [$cc_default]
  --objcc=OCC              use ObjC compiler OCC [$cc_default]
  --dep-cc=DEPCC           use dependency generator DEPCC [$cc_default]
  --ld=LD                  use linker LD
  --x86asmexe=X86ASM       use x86 assembler X86ASM
  --pkg-config=PKGCONFIG   use pkg-config tool PKGCONFIG [$pkg_config_default]
  --pkg-config-flags=FLAGS pass additional flags to pkgconf []
  --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-objcflags=FLAGS  add FLAGS to OBJCFLAGS [$CFLAGS]
  --extra-ldflags=ELDFLAGS add ELDFLAGS to LDFLAGS [$LDFLAGS]
  --extra-ldexeflags=ELDFLAGS add ELDFLAGS to LDEXEFLAGS [$LDEXEFLAGS]
  --extra-libs=ELIBS       add ELIBS [$ELIBS]
  --extra-version=STRING   version string suffix []
  --optflags=OPTFLAGS      override optimization-related compiler flags
  --enable-pic             build position-independent code
  --enable-thumb           compile for Thumb instruction set
  --enable-lto             use link-time optimization
  --env="ENV=override"     override the environment variables

Advanced options (experts only):
  --malloc-prefix=PREFIX   prefix malloc and related names with PREFIX
  --custom-allocator=NAME  use a supported custom allocator
  --disable-symver         disable symbol versioning
  --enable-hardcoded-tables use hardcoded tables instead of runtime generation
  --disable-safe-bitstream-reader
                           disable buffer boundary checking in bitreaders
                           (faster, but may crash)
  --enable-sram            allow use of on-chip SRAM

Optimization options (experts only):
  --disable-asm            disable all assembly optimizations
  --disable-altivec        disable AltiVec optimizations
  --disable-vsx            disable VSX optimizations
  --disable-power8         disable POWER8 optimizations
  --disable-amd3dnow       disable 3DNow! optimizations
  --disable-amd3dnowext    disable 3DNow! extended optimizations
  --disable-mmx            disable MMX optimizations
  --disable-mmxext         disable MMXEXT optimizations
  --disable-sse            disable SSE optimizations
  --disable-sse2           disable SSE2 optimizations
  --disable-sse3           disable SSE3 optimizations
  --disable-ssse3          disable SSSE3 optimizations
  --disable-sse4           disable SSE4 optimizations
  --disable-sse42          disable SSE4.2 optimizations
  --disable-avx            disable AVX optimizations
  --disable-xop            disable XOP optimizations
  --disable-fma3           disable FMA3 optimizations
  --disable-fma4           disable FMA4 optimizations
  --disable-avx2           disable AVX2 optimizations
  --disable-armv5te        disable armv5te optimizations
  --disable-armv6          disable armv6 optimizations
  --disable-armv6t2        disable armv6t2 optimizations
  --disable-vfp            disable VFP optimizations
  --disable-neon           disable NEON optimizations
  --disable-inline-asm     disable use of inline assembly
  --disable-x86asm         disable use of standalone x86 assembly

Developer options (useful when working on Libav itself):
  --disable-debug          disable debugging symbols
  --enable-debug=LEVEL     set the debug level [$debuglevel]
  --disable-optimizations  disable compiler optimizations
  --enable-extra-warnings  enable more compiler warnings
  --samples=PATH           location of test samples for FATE, if not set use
                           \$LIBAV_SAMPLES at make invocation time.
  --enable-neon-clobber-test check NEON registers for clobbering (should be
                           used only for debugging purposes)
  --enable-xmm-clobber-test check XMM registers for clobbering (Win64-only;
                           should be used only for debugging purposes)
  --enable-random          randomly enable/disable components
  --disable-random
  --enable-random=LIST     randomly enable/disable specific components or
  --disable-random=LIST    component groups. LIST is a comma-separated list
                           of NAME[:PROB] entries where NAME is a component
                           (group) and PROB the probability associated with
                           NAME (default 0.5).
  --random-seed=VALUE      seed value for --enable/disable-random
  --disable-valgrind-backtrace do not print a backtrace under Valgrind
                           (only applies to --disable-optimizations builds)
  --ignore-tests=TESTS     comma-separated list (without "fate-" prefix
                           in the name) of tests whose result is ignored

NOTE: Object files are built at the place where configure is launched.
EOF
  exit 0
}

quotes='""'

log(){
    echo "$@" >> $logfile
}

log_file(){
    log BEGIN $1
    i=1
    while read line; do
        printf '%5s   %s\n' "${i}" "${line}"
        i=$(($i+1))
    done < $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
libav-tools@libav.org mailing list or IRC #libav 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) printf '%s ' $v ;; esac"
    done
}

filter_out(){
    pat=$1
    shift
    for v; do
        eval "case $v in $pat) ;; *) printf '%s ' $v ;; esac"
    done
}

map(){
    m=$1
    shift
    for v; do eval $m; done
}

add_suffix(){
    suffix=$1
    shift
    for v; do echo ${v}${suffix}; done
}

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 pvar in $*; do
        eval level=\${${pvar}_level:=0}
        eval ${pvar}_${level}="\$$pvar"
        eval ${pvar}_level=$(($level+1))
    done
}

popvar(){
    for pvar in $*; do
        eval level=\${${pvar}_level:-0}
        test $level = 0 && continue
        eval level=$(($level-1))
        eval $pvar="\${${pvar}_${level}}"
        eval ${pvar}_level=$level
        eval unset ${pvar}_${level}
    done
}

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(){
    for var; do
        disabled $var && continue
        pushvar var
        do_enable_deep $var
        popvar var
        enable_weak $var
    done
}

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
        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_con="\$${cfg}_conflict"
        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_con dep_sel dep_sgs dep_ifa dep_ifn
        check_deps $dep_all $dep_any $dep_con $dep_sel $dep_sgs $dep_ifa $dep_ifn
        popvar cfg dep_all dep_any dep_con 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_all $dep_con || disable $cfg
        disabled_any $dep_sel && disable $cfg

        if enabled $cfg; then
            enable_deep $dep_sel
            enable_deep_weak $dep_sgs
            for dep in $dep_all $dep_any $dep_sgs; do
                # filter out library deps, these do not belong in extralibs
                is_in $dep $LIBRARY_LIST && continue
                enabled $dep && eval append ${cfg}_extralibs ${dep}_extralibs
            done
        fi

        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\""
}

unique(){
    var=$1
    uniq_list=""
    for tok in $(eval echo \$$var); do
        uniq_list="$(filter_out $tok $uniq_list) $tok"
    done
    eval "$var=\"${uniq_list}\""
}

resolve(){
    var=$1
    tmpvar=
    for entry in $(eval echo \$$var); do
        tmpvar="$tmpvar $(eval echo \$${entry})"
    done
    eval "$var=\"${tmpvar}\""
}

add_cppflags(){
    append CPPFLAGS "$@"
}

add_cflags(){
    append CFLAGS $($cflags_filter "$@")
}

add_cflags_headers(){
    append CFLAGS_HEADERS $($cflags_filter "$@")
}

add_asflags(){
    append ASFLAGS $($asflags_filter "$@")
}

add_objcflags(){
    append OBJCFLAGS $($objcflags_filter "$@")
}

add_ldflags(){
    append LDFLAGS $($ldflags_filter "$@")
}

add_ldexeflags(){
    append LDEXEFLAGS $($ldflags_filter "$@")
}

add_stripflags(){
    append STRIPFLAGS "$@"
}

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_objcc(){
    log check_objcc "$@"
    cat > $TMPC
    log_file $TMPC
    check_cmd $objcc $CPPFLAGS $CFLAGS $OBJCFLAGS "$@" $OBJCC_C $(cc_o $TMPO) $TMPC
}

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_x86asm(){
    log check_x86asm "$@"
    echo "$1" > $TMPS
    log_file $TMPS
    shift 1
    check_cmd $x86asmexe $X86ASMFLAGS "$@" -o $TMPO $TMPS
}

ld_o(){
    eval printf '%s\\n' $LD_O
}

check_ld(){
    log check_ld "$@"
    flags=$(filter_out '-l*' "$@")
    libs=$(filter '-l*' "$@")
    check_cc $($cflags_filter $flags) || return
    flags=$($ldflags_filter $flags)
    libs=$($ldflags_filter $libs)
    check_cmd $ld $LDFLAGS $flags $(ld_o $TMPE) $TMPO $libs $extralibs
}

print_include(){
    hdr=$1
    test "${hdr%.h}" = "${hdr}" &&
        echo "#include $hdr"    ||
        echo "#include <$hdr>"
}

check_code(){
    log check_code "$@"
    check=$1
    headers=$2
    code=$3
    shift 3
    {
        for hdr in $headers; do
            print_include $hdr
        done
        echo "int main(void) { $code; return 0; }"
    } | check_$check "$@"
}

check_cppflags(){
    log check_cppflags "$@"
    check_cpp "$@" <<EOF && append CPPFLAGS "$@"
#include <stdlib.h>;
EOF
}

test_cflags(){
    log test_cflags "$@"
    set -- $($cflags_filter "$@")
    check_cc "$@" <<EOF
int x;
EOF
}

check_cflags(){
    log check_cflags "$@"
    test_cflags "$@" && add_cflags "$@"
}

test_objcflags(){
    log test_objcflags "$@"
    set -- $($objcflags_filter "$@")
    check_objcc "$@" <<EOF
int x;
EOF
}

check_objcflags(){
    log check_objcflags "$@"
    test_objcflags "$@" && add_objcflags "$@"
}

test_ldflags(){
    log test_ldflags "$@"
    check_ld "$@" <<EOF
int main(void){ return 0; }
EOF
}

check_ldflags(){
    log check_ldflags "$@"
    test_ldflags "$@" && add_ldflags "$@"
}

test_stripflags(){
    log test_stripflags "$@"
    # call check_cc to get a fresh TMPO
    check_cc <<EOF
int main(void) { return 0; }
EOF
    check_cmd $strip $STRIPFLAGS "$@" $TMPO
}

check_stripflags(){
    log check_stripflags "$@"
    test_stripflags "$@" && add_stripflags "$@"
}

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 "$@" <<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 "$@" <<EOF && enable $func
#include <math.h>
float foo(float f, float g) { return $func($args); }
int main(void){ return 0; }
EOF
}

check_func_headers(){
    log check_func_headers "$@"
    headers=$1
    funcs=$2
    shift 2
    {
        for hdr in $headers; do
            print_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 "$@" && 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
}

test_cflags_cpp(){
    log test_cflags_cpp "$@"
    flags=$1
    condition=$2
    shift 2
    set -- $($cflags_filter "$flags")
    check_cpp "$@" <<EOF
#if !($condition)
#error "unsatisfied condition: $condition"
#endif
EOF
}

check_lib(){
    log check_lib "$@"
    name="$1"
    headers="$2"
    funcs="$3"
    shift 3
    disable $name
    check_func_headers "$headers" "$funcs" "$@" &&
        enable $name && eval ${name}_extralibs="\$@"
}

check_pkg_config(){
    log check_pkg_config "$@"
    name="$1"
    pkg_version="$2"
    pkg="${2%% *}"
    headers="$3"
    funcs="$4"
    shift 4
    disable $name
    check_cmd $pkg_config --exists --print-errors $pkg_version || return
    pkg_cflags=$($pkg_config --cflags $pkg_config_flags $pkg)
    pkg_libs=$($pkg_config --libs $pkg_config_flags $pkg)
    check_func_headers "$headers" "$funcs" $pkg_cflags $pkg_libs "$@" &&
        enable $name &&
        add_cflags    "$pkg_cflags" &&
        eval $(sanitize_var_name ${name}_extralibs)="\$pkg_libs"
}

check_exec(){
    check_ld "$@" && { enabled cross_compile || $TMPE >> $logfile 2>&1; }
}

check_exec_crash(){
    log check_exec_crash "$@"
    code=$(cat)

    # exit() is not async signal safe.  _Exit (C99) and _exit (POSIX)
    # are safe but may not be available everywhere.  Thus we use
    # raise(SIGTERM) instead.  The check is run in a subshell so we
    # can redirect the "Terminated" message from the shell.  SIGBUS
    # is not defined by standard C so it is used conditionally.

    (check_exec "$@") >> $logfile 2>&1 <<EOF
#include <signal.h>
static void sighandler(int sig){
    raise(SIGTERM);
}
int foo(void){
    $code
}
int (*func_ptr)(void) = foo;
int main(void){
    signal(SIGILL, sighandler);
    signal(SIGFPE, sighandler);
    signal(SIGSEGV, sighandler);
#ifdef SIGBUS
    signal(SIGBUS, sighandler);
#endif
    return func_ptr();
}
EOF
}

check_type(){
    log check_type "$@"
    headers=$1
    type=$2
    shift 2
    disable_safe "$type"
    check_code cc "$headers" "$type v" "$@" && enable_safe "$type"
}

check_struct(){
    log check_struct "$@"
    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}"
}

check_builtin(){
    log check_builtin "$@"
    name=$1
    headers=$2
    builtin=$3
    shift 3
    disable "$name"
    check_code ld "$headers" "$builtin" "$@" && enable "$name"
}

check_compile_assert(){
    log check_compile_assert "$@"
    name=$1
    headers=$2
    condition=$3
    shift 3
    disable "$name"
    check_code cc "$headers" "char c[2 * !!($condition) - 1]" "$@" && enable "$name"
}

require(){
    log require "$@"
    name_version="$1"
    name="${1%% *}"
    headers="$2"
    func="$3"
    shift 3
    check_lib $name "$headers" $func "$@" || die "ERROR: $name_version not found"
}

require_header(){
    log require "$@"
    header="$1"
    shift
    check_header "$header" "$@" || die "ERROR: $header not found"
}

require_cpp_condition(){
    log require "$@"
    header="$1"
    condition="$2"
    shift 2
    check_cpp_condition "$header" "$condition" "$@" || die "ERROR: $condition not satisfied"
}

require_pkg_config(){
    log require_pkg_config "$@"
    pkg_version="$2"
    check_pkg_config "$@" || die "ERROR: $pkg_version not found"
}

hostcc_e(){
    eval printf '%s\\n' $HOSTCC_E
}

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_cpp(){
    log check_host_cpp "$@"
    cat > $TMPC
    log_file $TMPC
    check_cmd $host_cc $host_cppflags $host_cflags "$@" $(hostcc_e $TMPO) $TMPC
}

check_host_cppflags(){
    log check_host_cppflags "$@"
    check_host_cpp "$@" <<EOF && append host_cppflags "$@"
#include <stdlib.h>;
EOF
}

check_host_cflags(){
    log check_host_cflags "$@"
    set -- $($host_cflags_filter "$@")
    check_host_cc "$@" <<EOF && append host_cflags "$@"
int x;
EOF
}

check_host_cpp_condition(){
    log check_host_cpp_condition "$@"
    header=$1
    condition=$2
    shift 2
    check_host_cpp "$@" <<EOF
#include <$header>
#if !($condition)
#error "unsatisfied condition: $condition"
#endif
EOF
}

apply(){
    file=$1
    shift
    "$@" < "$file" > "$file.tmp" && mv "$file.tmp" "$file" || rm "$file.tmp"
}

cp_if_changed(){
    cmp -s "$1" "$2" && { test "$quiet" != "yes" && echo "$2 is unchanged"; } && return
    mkdir -p "$(dirname $2)"
    cp -f "$1" "$2"
}

# CONFIG_LIST contains configurable options, while HAVE_LIST is for
# system-dependent things.

AVCODEC_COMPONENTS="
    bsfs
    decoders
    encoders
    hwaccels
    parsers
"

AVDEVICE_COMPONENTS="
    indevs
    outdevs
"
AVFILTER_COMPONENTS="
    filters
"
AVFORMAT_COMPONENTS="
    demuxers
    muxers
    protocols
"

AVRESAMPLE_COMPONENTS=""
AVUTIL_COMPONENTS=""

COMPONENT_LIST="
    $AVCODEC_COMPONENTS
    $AVDEVICE_COMPONENTS
    $AVFILTER_COMPONENTS
    $AVFORMAT_COMPONENTS
    $AVRESAMPLE_COMPONENTS
    $AVUTIL_COMPONENTS
"

EXAMPLE_LIST="
    decode_audio_example
    decode_video_example
    encode_audio_example
    encode_video_example
    filter_audio_example
    metadata_example
    output_example
    qsvdec_example
    transcode_aac_example
"

# catchall list of things that require external libs to link
EXTRALIBS_LIST="
    cpu_init
    cws2fws
"

HWACCEL_LIBRARY_NONFREE_LIST="
    cuda
    libnpp
"
HWACCEL_LIBRARY_LIST="
    $HWACCEL_LIBRARY_NONFREE_LIST
    d3d11va
    dxva2
    libmfx
    mmal
    nvenc
    omx
    vaapi
    vda
    vdpau
"

EXTERNAL_LIBRARY_GPL_LIST="
    libcdio
    libx264
    libx265
    libxavs
    libxvid
"

EXTERNAL_LIBRARY_NONFREE_LIST="
    libfaac
    libfdk_aac
    openssl
"

EXTERNAL_LIBRARY_VERSION3_LIST="
    libopencore_amrnb
    libopencore_amrwb
    libvo_aacenc
    libvo_amrwbenc
"

EXTERNAL_LIBRARY_LIST="
    $EXTERNAL_LIBRARY_GPL_LIST
    $EXTERNAL_LIBRARY_NONFREE_LIST
    $EXTERNAL_LIBRARY_VERSION3_LIST
    avisynth
    avxsynth
    frei0r
    gnutls
    libbs2b
    libdc1394
    libdcadec
    libfontconfig
    libfreetype
    libgsm
    libhdcd
    libilbc
    libkvazaar
    libmp3lame
    libopencv
    libopenh264
    libopenjpeg
    libopus
    libpulse
    librtmp
    libschroedinger
    libsnappy
    libspeex
    libtheora
    libtwolame
    libvorbis
    libvpx
    libwavpack
    libwebp
    libxcb
    libxcb_shm
    libxcb_xfixes
"

SYSTEM_LIBRARY_LIST="
    bzlib
    zlib
"

FEATURE_LIST="
    gray
    hardcoded_tables
    omx_rpi
    runtime_cpudetect
    safe_bitstream_reader
    shared
    small
    sram
    static
    swscale_alpha
"

LIBRARY_LIST="
    avcodec
    avdevice
    avfilter
    avformat
    avresample
    avutil
    swscale
"

LICENSE_LIST="
    gpl
    nonfree
    version3
"

PROGRAM_LIST="
    avconv
    avplay
    avprobe
"

SUBSYSTEM_LIST="
    dct
    doc
    error_resilience
    faan
    fft
    lsp
    lzo
    mdct
    network
    rdft
"

# COMPONENT_LIST needs to come last to ensure correct dependency checking
CONFIG_LIST="
    $EXAMPLE_LIST
    $EXTERNAL_LIBRARY_LIST
    $HWACCEL_LIBRARY_LIST
    $FEATURE_LIST
    $LICENSE_LIST
    $LIBRARY_LIST
    $PROGRAM_LIST
    $SUBSYSTEM_LIST
    $SYSTEM_LIBRARY_LIST
    neon_clobber_test
    pic
    pod2man
    texi2html
    thumb
    valgrind_backtrace
    xmm_clobber_test
    $COMPONENT_LIST
"

THREADS_LIST="
    pthreads
    w32threads
"

ATOMICS_LIST="
    atomics_gcc
    atomics_suncc
    atomics_win32
"

ARCH_LIST="
    aarch64
    alpha
    arm
    avr32
    avr32_ap
    avr32_uc
    bfin
    ia64
    m68k
    mips
    mips64
    parisc
    ppc
    ppc64
    s390
    sh4
    sparc
    sparc64
    tilegx
    tilepro
    tomi
    x86
    x86_32
    x86_64
"

ARCH_EXT_LIST_ARM="
    armv5te
    armv6
    armv6t2
    armv8
    neon
    vfp
    vfpv3
"

ARCH_EXT_LIST_X86_SIMD="
    amd3dnow
    amd3dnowext
    avx
    avx2
    fma3
    fma4
    mmx
    mmxext
    sse
    sse2
    sse3
    sse4
    sse42
    ssse3
    xop
"

ARCH_EXT_LIST_PPC="
    altivec
    dcbzl
    ldbrx
    power8
    ppc4xx
    vsx
"

ARCH_EXT_LIST_X86="
    $ARCH_EXT_LIST_X86_SIMD
    cpunop
    i686
"

ARCH_EXT_LIST_MIPS="
    loongson
    mips32r1
    mips64r1
    mips32r2
    mips64r2
    mips32r6
    mips64r6
"

ARCH_EXT_LIST="
    $ARCH_EXT_LIST_ARM
    $ARCH_EXT_LIST_MIPS
    $ARCH_EXT_LIST_PPC
    $ARCH_EXT_LIST_X86
    vis
"

ARCH_FEATURES="
    aligned_stack
    fast_64bit
    fast_clz
    fast_cmov
    local_aligned_8
    local_aligned_16
    local_aligned_32
    simd_align_16
    simd_align_32
"

BUILTIN_LIST="
    atomic_cas_ptr
    machine_rw_barrier
    MemoryBarrier
    mm_empty
    rdtsc
    sem_timedwait
    sync_val_compare_and_swap
"
HAVE_LIST_CMDLINE="
    inline_asm
    symver
    x86asm
"

HAVE_LIST_PUB="
    bigendian
    fast_unaligned
"

HEADERS_LIST="
    AVFoundation_AVFoundation_h
    alsa_asoundlib_h
    altivec_h
    arpa_inet_h
    cdio_paranoia_h
    cdio_paranoia_paranoia_h
    d3d11_h
    dispatch_dispatch_h
    dev_bktr_ioctl_bt848_h
    dev_bktr_ioctl_meteor_h
    dev_ic_bt8xx_h
    dev_video_bktr_ioctl_bt848_h
    dev_video_meteor_ioctl_meteor_h
    direct_h
    dlfcn_h
    dxva_h
    gsm_h
    io_h
    mach_mach_time_h
    machine_ioctl_bt848_h
    machine_ioctl_meteor_h
    malloc_h
    poll_h
    sndio_h
    soundcard_h
    stdatomic_h
    sys_mman_h
    sys_param_h
    sys_resource_h
    sys_select_h
    sys_soundcard_h
    sys_time_h
    sys_un_h
    sys_videoio_h
    unistd_h
    valgrind_valgrind_h
    windows_h
    winsock2_h
"

INTRINSICS_LIST="
    intrinsics_neon
"

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
"

SYSTEM_FUNCS="
    aligned_malloc
    clock_gettime
    closesocket
    CommandLineToArgvW
    CoTaskMemFree
    CryptGenRandom
    fcntl
    flt_lim
    fork
    getaddrinfo
    gethrtime
    getopt
    GetProcessAffinityMask
    GetProcessMemoryInfo
    GetProcessTimes
    getrusage
    GetSystemTimeAsFileTime
    gettimeofday
    gmtime_r
    inet_aton
    isatty
    jack_port_get_latency_range
    LoadLibrary
    localtime_r
    mach_absolute_time
    MapViewOfFile
    memalign
    mkstemp
    mmap
    mprotect
    nanosleep
    posix_memalign
    sched_getaffinity
    SetConsoleTextAttribute
    setmode
    setrlimit
    Sleep
    strerror_r
    sysconf
    sysctl
    usleep
    VirtualAlloc
"

TOOLCHAIN_FEATURES="
    as_dn_directive
    as_fpu_directive
    as_func
    as_object_arch
    asm_mod_q
    attribute_may_alias
    attribute_packed
    blocks_extension
    ebp_available
    ebx_available
    gnu_as
    ibm_asm
    inline_asm_labels
    pragma_deprecated
    symver_asm_label
    symver_gnu_asm
    vfp_args
    xform_asm
    xmm_clobbers
"

TYPES_LIST="
    CONDITION_VARIABLE_Ptr
    socklen_t
    struct_addrinfo
    struct_group_source_req
    struct_ip_mreq_source
    struct_ipv6_mreq
    struct_pollfd
    struct_rusage_ru_maxrss
    struct_sockaddr_in6
    struct_sockaddr_sa_len
    struct_sockaddr_storage
    struct_v4l2_frmivalenum_discrete
"

HAVE_LIST="
    $ARCH_EXT_LIST
    $(add_suffix _external $ARCH_EXT_LIST)
    $(add_suffix _inline   $ARCH_EXT_LIST)
    $ARCH_FEATURES
    $BUILTIN_LIST
    $HAVE_LIST_CMDLINE
    $HAVE_LIST_PUB
    $HEADERS_LIST
    $INTRINSICS_LIST
    $MATH_FUNCS
    $SYSTEM_FUNCS
    $THREADS_LIST
    $TOOLCHAIN_FEATURES
    $TYPES_LIST
    dos_paths
    dxva2_lib
    libc_msvcrt
    MMAL_PARAMETER_VIDEO_MAX_NUM_CALLBACKS
    sdl
    section_data_rel_ro
    threads
    vaapi_drm
    vaapi_x11
    vdpau_x11
"

# options emitted with CONFIG_ prefix but not available on the command line
CONFIG_EXTRA="
    aandcttables
    ac3dsp
    audio_frame_queue
    audiodsp
    blockdsp
    bswapdsp
    cabac
    dirac_parse
    dvprofile
    faandct
    faanidct
    fdctdsp
    flacdsp
    fmtconvert
    g722dsp
    gmp
    golomb
    gplv3
    h263dsp
    h264chroma
    h264dsp
    h264parse
    h264pred
    h264qpel
    hevc_ps
    hpeldsp
    huffman
    huffyuvdsp
    huffyuvencdsp
    idctdsp
    iirfilter
    imdct15
    intrax8
    iso_media
    ividsp
    jpegtables
    lgplv3
    libx262
    libxcb_shape
    lpc
    lzf
    me_cmp
    mpeg_er
    mpegaudio
    mpegaudiodsp
    mpegaudioheader
    mpegvideo
    mpegvideoenc
    mss34dsp
    pixblockdsp
    qpeldsp
    qsv
    qsvdec
    qsvenc
    rangecoder
    riffdec
    riffenc
    rtpdec
    rtpenc_chain
    rv34dsp
    sinewin
    snappy
    srtp
    startcode
    texturedsp
    texturedspenc
    tpeldsp
    vaapi_encode
    vc1dsp
    videodsp
    vp3dsp
    vp56dsp
    vp8dsp
    wma_freqs
    wmv2dsp
"

CMDLINE_SELECT="
    $ARCH_EXT_LIST
    $CONFIG_LIST
    $HAVE_LIST_CMDLINE
    $THREADS_LIST
    asm
    cross_compile
    debug
    extra_warnings
    logging
    lto
    optimizations
    rpath
"

PATHS_LIST="
    bindir
    datadir
    docdir
    incdir
    libdir
    mandir
    prefix
    shlibdir
"

CMDLINE_SET="
    $PATHS_LIST
    ar
    arch
    as
    cc
    objcc
    cpu
    cross_prefix
    custom_allocator
    dep_cc
    env
    extra_version
    host_cc
    host_cflags
    host_extralibs
    host_ld
    host_ldflags
    host_os
    ignore_tests
    ld
    logfile
    malloc_prefix
    nm
    optflags
    pkg_config
    pkg_config_flags
    random_seed
    samples
    sysinclude
    sysroot
    target_exec
    target_os
    target_path
    target_samples
    toolchain
    x86asmexe
"

CMDLINE_APPEND="
    extra_cflags
    extra_objcflags
    host_cppflags
"

# code dependency declarations

# architecture extensions

armv5te_deps="arm"
armv6_deps="arm"
armv6t2_deps="arm"
armv8_deps="aarch64"
neon_deps_any="aarch64 arm"
intrinsics_neon_deps="neon"
vfp_deps_any="aarch64 arm"
vfpv3_deps="vfp"

map 'eval ${v}_inline_deps=inline_asm' $ARCH_EXT_LIST_ARM

altivec_deps="ppc"
ppc4xx_deps="ppc"
vsx_deps="altivec"
power8_deps="vsx"

cpunop_deps="i686"
x86_64_select="i686"
x86_64_suggest="fast_cmov"

amd3dnow_deps="mmx"
amd3dnowext_deps="amd3dnow"
i686_deps="x86"
mmx_deps="x86"
mmxext_deps="mmx"
sse_deps="mmxext"
sse2_deps="sse"
sse3_deps="sse2"
ssse3_deps="sse3"
sse4_deps="ssse3"
sse42_deps="sse4"
avx_deps="sse42"
xop_deps="avx"
fma3_deps="avx"
fma4_deps="avx"
avx2_deps="avx"

mmx_external_deps="x86asm"
mmx_inline_deps="inline_asm"
mmx_suggest="mmx_external mmx_inline"

for ext in $(filter_out mmx $ARCH_EXT_LIST_X86_SIMD); do
    eval dep=\$${ext}_deps
    eval ${ext}_external_deps='"${dep}_external"'
    eval ${ext}_inline_deps='"${dep}_inline"'
    eval ${ext}_suggest='"${ext}_external ${ext}_inline"'
done

aligned_stack_if_any="aarch64 ppc x86"
fast_64bit_if_any="aarch64 alpha ia64 mips64 parisc64 ppc64 sparc64 x86_64"
fast_clz_if_any="aarch64 alpha avr32 mips ppc x86"
fast_unaligned_if_any="aarch64 ppc x86"
simd_align_16_if_any="altivec neon sse"
simd_align_32_if_any="avx"

# system capabilities
symver_if_any="symver_asm_label symver_gnu_asm"
valgrind_backtrace_conflict="optimizations"
valgrind_backtrace_deps="valgrind_valgrind_h"

# threading support
atomics_gcc_if="sync_val_compare_and_swap"
atomics_suncc_if="atomic_cas_ptr machine_rw_barrier"
atomics_win32_if="MemoryBarrier"
atomics_native_if_any="$ATOMICS_LIST"
w32threads_deps="atomics_native"
threads_if_any="$THREADS_LIST"

# subsystems
dct_select="rdft"
dirac_parse_select="golomb"
error_resilience_select="me_cmp"
faandct_deps="faan fdctdsp"
faanidct_deps="faan idctdsp"
h264dsp_select="startcode"
hevc_ps_select="golomb"
intrax8_select="blockdsp idctdsp"
mdct_select="fft"
rdft_select="fft"
me_cmp_select="fdctdsp idctdsp pixblockdsp"
mpeg_er_select="error_resilience"
mpegaudio_select="mpegaudiodsp mpegaudioheader"
mpegaudiodsp_select="dct"
mpegvideo_select="blockdsp hpeldsp idctdsp me_cmp mpeg_er videodsp"
mpegvideoenc_select="me_cmp mpegvideo pixblockdsp qpeldsp"
vc1dsp_select="h264chroma qpeldsp startcode"

# decoders / encoders
aac_decoder_select="imdct15 mdct sinewin"
aac_encoder_select="audio_frame_queue iirfilter mdct sinewin"
aac_latm_decoder_select="aac_decoder aac_latm_parser"
ac3_decoder_select="ac3_parser ac3dsp bswapdsp fmtconvert mdct"
ac3_encoder_select="ac3dsp audiodsp mdct me_cmp"
ac3_fixed_encoder_select="ac3dsp audiodsp mdct me_cmp"
adpcm_g722_decoder_select="g722dsp"
adpcm_g722_encoder_select="g722dsp"
aic_decoder_select="golomb idctdsp"
alac_encoder_select="lpc"
als_decoder_select="bswapdsp"
amrnb_decoder_select="lsp"
amrwb_decoder_select="lsp"
amv_decoder_select="sp5x_decoder"
ape_decoder_select="bswapdsp"
asv1_decoder_select="blockdsp bswapdsp idctdsp"
asv1_encoder_select="bswapdsp fdctdsp pixblockdsp"
asv2_decoder_select="blockdsp bswapdsp idctdsp"
asv2_encoder_select="bswapdsp fdctdsp pixblockdsp"
atrac1_decoder_select="mdct sinewin"
atrac3_decoder_select="mdct"
atrac3p_decoder_select="mdct sinewin"
bink_decoder_select="blockdsp hpeldsp"
binkaudio_dct_decoder_select="mdct rdft dct sinewin wma_freqs"
binkaudio_rdft_decoder_select="mdct rdft sinewin wma_freqs"
cavs_decoder_select="blockdsp golomb h264chroma idctdsp qpeldsp videodsp"
cllc_decoder_select="bswapdsp"
comfortnoise_encoder_select="lpc"
cook_decoder_select="audiodsp mdct sinewin"
cscd_decoder_select="lzo"
cscd_decoder_suggest="zlib"
dca_decoder_select="fmtconvert mdct"
dds_decoder_select="texturedsp"
dnxhd_decoder_select="blockdsp idctdsp"
dnxhd_encoder_select="aandcttables blockdsp fdctdsp idctdsp mpegvideoenc pixblockdsp"
dvvideo_decoder_select="dvprofile idctdsp"
dvvideo_encoder_select="dvprofile fdctdsp me_cmp pixblockdsp"
dxa_decoder_deps="zlib"
dxv_decoder_select="lzf texturedsp"
eac3_decoder_select="ac3_decoder"
eac3_encoder_select="ac3_encoder"
eamad_decoder_select="aandcttables blockdsp bswapdsp idctdsp mpegvideo"
eatgq_decoder_select="aandcttables idctdsp"
eatqi_decoder_select="aandcttables blockdsp bswapdsp idctdsp"
exr_decoder_deps="zlib"
ffv1_decoder_select="rangecoder"
ffv1_encoder_select="rangecoder"
ffvhuff_decoder_select="huffyuv_decoder"
ffvhuff_encoder_select="huffyuv_encoder"
fic_decoder_select="golomb"
flac_decoder_select="flacdsp"
flac_encoder_select="bswapdsp flacdsp lpc"
flashsv_decoder_deps="zlib"
flashsv_encoder_deps="zlib"
flashsv2_decoder_deps="zlib"
flv_decoder_select="h263_decoder"
flv_encoder_select="h263_encoder"
fourxm_decoder_select="blockdsp bswapdsp"
fraps_decoder_select="bswapdsp huffman"
g2m_decoder_deps="zlib"
g2m_decoder_select="blockdsp idctdsp jpegtables"
h261_decoder_select="mpeg_er mpegvideo"
h261_encoder_select="aandcttables mpegvideoenc"
h263_decoder_select="error_resilience h263_parser h263dsp mpeg_er mpegvideo qpeldsp"
h263_encoder_select="aandcttables h263dsp mpegvideoenc"
h263i_decoder_select="h263_decoder"
h263p_encoder_select="h263_encoder"
h264_decoder_select="cabac golomb h264chroma h264dsp h264parse h264pred h264qpel videodsp"
h264_decoder_suggest="error_resilience"
hap_decoder_select="snappy texturedsp"
hap_encoder_deps="libsnappy"
hap_encoder_select="texturedspenc"
hevc_decoder_select="bswapdsp cabac hevc_ps videodsp"
huffyuv_decoder_select="bswapdsp huffyuvdsp"
huffyuv_encoder_select="bswapdsp huffman huffyuvencdsp"
iac_decoder_select="imc_decoder"
imc_decoder_select="bswapdsp fft mdct sinewin"
indeo3_decoder_select="hpeldsp"
indeo4_decoder_select="ividsp"
indeo5_decoder_select="ividsp"
interplay_video_decoder_select="hpeldsp"
jpegls_decoder_select="mjpeg_decoder"
jv_decoder_select="blockdsp"
lagarith_decoder_select="huffyuvdsp"
ljpeg_encoder_select="aandcttables idctdsp jpegtables"
magicyuv_decoder_select="huffyuvdsp"
mdec_decoder_select="blockdsp idctdsp mpegvideo"
metasound_decoder_select="lsp mdct sinewin"
mimic_decoder_select="blockdsp bswapdsp hpeldsp idctdsp"
mjpeg_decoder_select="blockdsp hpeldsp idctdsp jpegtables"
mjpeg_encoder_select="aandcttables jpegtables mpegvideoenc"
mjpegb_decoder_select="mjpeg_decoder"
mlp_decoder_select="mlp_parser"
motionpixels_decoder_select="bswapdsp"
mp1_decoder_select="mpegaudio"
mp1float_decoder_select="mpegaudio"
mp2_decoder_select="mpegaudio"
mp2float_decoder_select="mpegaudio"
mp3_decoder_select="mpegaudio"
mp3adu_decoder_select="mpegaudio"
mp3adufloat_decoder_select="mpegaudio"
mp3float_decoder_select="mpegaudio"
mp3on4_decoder_select="mpegaudio"
mp3on4float_decoder_select="mpegaudio"
mpc7_decoder_select="bswapdsp mpegaudiodsp"
mpc8_decoder_select="mpegaudiodsp"
mpeg_xvmc_decoder_deps="X11_extensions_XvMClib_h"
mpeg_xvmc_decoder_select="mpeg2video_decoder"
mpeg1video_decoder_select="error_resilience mpeg_er mpegvideo"
mpeg1video_encoder_select="aandcttables mpegvideoenc"
mpeg2video_decoder_select="error_resilience mpeg_er mpegvideo"
mpeg2video_encoder_select="aandcttables mpegvideoenc"
mpeg4_decoder_select="h263_decoder mpeg4video_parser"
mpeg4_encoder_select="h263_encoder"
msa1_decoder_select="mss34dsp"
msmpeg4v1_decoder_select="h263_decoder"
msmpeg4v2_decoder_select="h263_decoder"
msmpeg4v2_encoder_select="h263_encoder"
msmpeg4v3_decoder_select="h263_decoder"
msmpeg4v3_encoder_select="h263_encoder"
mss2_decoder_select="error_resilience mpeg_er mpegvideo qpeldsp vc1_decoder"
mts2_decoder_select="mss34dsp"
mxpeg_decoder_select="mjpeg_decoder"
nellymoser_decoder_select="mdct sinewin"
nellymoser_encoder_select="audio_frame_queue mdct sinewin"
nuv_decoder_select="idctdsp lzo"
on2avc_decoder_select="mdct"
opus_decoder_deps="avresample"
opus_decoder_select="imdct15"
png_decoder_deps="zlib"
png_encoder_deps="zlib"
png_encoder_select="huffyuvencdsp"
prores_decoder_select="idctdsp"
prores_encoder_select="fdctdsp"
qcelp_decoder_select="lsp"
qdm2_decoder_select="mdct rdft mpegaudiodsp"
ra_144_encoder_select="audio_frame_queue lpc"
ralf_decoder_select="golomb"
rscc_decoder_deps="zlib"
rv10_decoder_select="error_resilience h263_decoder h263dsp mpeg_er"
rv10_encoder_select="h263_encoder"
rv20_decoder_select="error_resilience h263_decoder h263dsp mpeg_er"
rv20_encoder_select="h263_encoder"
rv30_decoder_select="error_resilience golomb h264chroma h264pred h264qpel mpeg_er mpegvideo rv34dsp videodsp"
rv40_decoder_select="error_resilience golomb h264chroma h264pred h264qpel mpeg_er mpegvideo rv34dsp videodsp"
screenpresso_decoder_deps="zlib"
sipr_decoder_select="lsp"
sp5x_decoder_select="mjpeg_decoder"
svq1_decoder_select="hpeldsp"
svq1_encoder_select="aandcttables hpeldsp me_cmp mpegvideoenc"
svq3_decoder_select="golomb h264dsp h264parse h264pred hpeldsp tpeldsp videodsp"
svq3_decoder_suggest="zlib"
tak_decoder_select="audiodsp"
tdsc_decoder_deps="zlib"
tdsc_decoder_select="mjpeg_decoder"
theora_decoder_select="vp3_decoder"
thp_decoder_select="mjpeg_decoder"
tiff_decoder_suggest="zlib"
tiff_encoder_suggest="zlib"
truehd_decoder_select="mlp_decoder"
truemotion2_decoder_select="bswapdsp"
truespeech_decoder_select="bswapdsp"
tscc_decoder_deps="zlib"
txd_decoder_select="texturedsp"
twinvq_decoder_select="mdct lsp sinewin"
utvideo_decoder_select="bswapdsp"
utvideo_encoder_select="bswapdsp huffman huffyuvencdsp"
vble_decoder_select="huffyuvdsp"
vc1_decoder_select="blockdsp error_resilience h263_decoder h264qpel intrax8 mpeg_er mpegvideo vc1dsp"
vc1image_decoder_select="vc1_decoder"
vorbis_decoder_select="mdct"
vorbis_encoder_select="mdct"
vp3_decoder_select="hpeldsp vp3dsp videodsp"
vp5_decoder_select="h264chroma hpeldsp videodsp vp3dsp vp56dsp"
vp6_decoder_select="h264chroma hpeldsp huffman videodsp vp3dsp vp56dsp"
vp6a_decoder_select="vp6_decoder"
vp6f_decoder_select="vp6_decoder"
vp7_decoder_select="h264pred videodsp vp8dsp"
vp8_decoder_select="h264pred videodsp vp8dsp"
vp9_decoder_select="videodsp vp9_superframe_split_bsf"
webp_decoder_select="vp8_decoder"
wmapro_decoder_select="mdct sinewin wma_freqs"
wmav1_decoder_select="mdct sinewin wma_freqs"
wmav1_encoder_select="mdct sinewin wma_freqs"
wmav2_decoder_select="mdct sinewin wma_freqs"
wmav2_encoder_select="mdct sinewin wma_freqs"
wmavoice_decoder_select="lsp rdft dct mdct sinewin"
wmv1_decoder_select="h263_decoder"
wmv1_encoder_select="h263_encoder"
wmv2_decoder_select="blockdsp error_resilience h263_decoder idctdsp intrax8 videodsp wmv2dsp"
wmv2_encoder_select="h263_encoder wmv2dsp"
wmv3_decoder_select="vc1_decoder"
wmv3image_decoder_select="wmv3_decoder"
zerocodec_decoder_deps="zlib"
zlib_decoder_deps="zlib"
zlib_encoder_deps="zlib"
zmbv_decoder_deps="zlib"
zmbv_encoder_deps="zlib"

# hardware accelerators
d3d11va_deps="d3d11_h dxva_h ID3D11VideoDecoder"
dxva2_deps="dxva2api_h DXVA2_ConfigPictureDecode"
dxva2_lib_deps="dxva2"
vda_deps="VideoDecodeAcceleration_VDADecoder_h blocks_extension pthreads"
vda_extralibs="-framework CoreFoundation -framework VideoDecodeAcceleration -framework QuartzCore"

h263_vaapi_hwaccel_deps="vaapi"
h263_vaapi_hwaccel_select="h263_decoder"
h264_d3d11va_hwaccel_deps="d3d11va"
h264_d3d11va_hwaccel_select="h264_decoder"
h264_dxva2_hwaccel_deps="dxva2"
h264_dxva2_hwaccel_select="h264_decoder"
h264_mmal_hwaccel_deps="mmal"
h264_qsv_hwaccel_deps="libmfx"
h264_vaapi_hwaccel_deps="vaapi"
h264_vaapi_hwaccel_select="h264_decoder"
h264_vda_hwaccel_deps="vda"
h264_vda_hwaccel_select="h264_decoder"
h264_vda_old_hwaccel_deps="vda"
h264_vda_old_hwaccel_select="h264_decoder"
h264_vdpau_hwaccel_deps="vdpau"
h264_vdpau_hwaccel_select="h264_decoder"
hevc_d3d11va_hwaccel_deps="d3d11va DXVA_PicParams_HEVC"
hevc_d3d11va_hwaccel_select="hevc_decoder"
hevc_dxva2_hwaccel_deps="dxva2 DXVA_PicParams_HEVC"
hevc_dxva2_hwaccel_select="hevc_decoder"
hevc_qsv_hwaccel_deps="libmfx"
hevc_vaapi_hwaccel_deps="vaapi VAPictureParameterBufferHEVC"
hevc_vaapi_hwaccel_select="hevc_decoder"
hevc_vdpau_hwaccel_deps="vdpau VdpPictureInfoHEVC"
hevc_vdpau_hwaccel_select="hevc_decoder"
mpeg1_vdpau_hwaccel_deps="vdpau"
mpeg1_vdpau_hwaccel_select="mpeg1video_decoder"
mpeg2_d3d11va_hwaccel_deps="d3d11va"
mpeg2_d3d11va_hwaccel_select="mpeg2video_decoder"
mpeg2_dxva2_hwaccel_deps="dxva2"
mpeg2_dxva2_hwaccel_select="mpeg2video_decoder"
mpeg2_mmal_hwaccel_deps="mmal"
mpeg2_qsv_hwaccel_deps="libmfx"
mpeg2_vaapi_hwaccel_deps="vaapi"
mpeg2_vaapi_hwaccel_select="mpeg2video_decoder"
mpeg2_vdpau_hwaccel_deps="vdpau"
mpeg2_vdpau_hwaccel_select="mpeg2video_decoder"
mpeg4_vaapi_hwaccel_deps="vaapi"
mpeg4_vaapi_hwaccel_select="mpeg4_decoder"
mpeg4_vdpau_hwaccel_deps="vdpau"
mpeg4_vdpau_hwaccel_select="mpeg4_decoder"
vc1_d3d11va_hwaccel_deps="d3d11va"
vc1_d3d11va_hwaccel_select="vc1_decoder"
vc1_dxva2_hwaccel_deps="dxva2"
vc1_dxva2_hwaccel_select="vc1_decoder"
vc1_mmal_hwaccel_deps="mmal"
vc1_qsv_hwaccel_deps="libmfx"
vc1_vaapi_hwaccel_deps="vaapi"
vc1_vaapi_hwaccel_select="vc1_decoder"
vc1_vdpau_hwaccel_deps="vdpau"
vc1_vdpau_hwaccel_select="vc1_decoder"
vp8_qsv_hwaccel_deps="libmfx"
vp8_vaapi_hwaccel_deps="vaapi VAPictureParameterBufferVP8"
vp8_vaapi_hwaccel_select="vp8_decoder"
wmv3_d3d11va_hwaccel_select="vc1_d3d11va_hwaccel"
wmv3_dxva2_hwaccel_select="vc1_dxva2_hwaccel"
wmv3_vaapi_hwaccel_select="vc1_vaapi_hwaccel"
wmv3_vdpau_hwaccel_select="vc1_vdpau_hwaccel"

# hardware-accelerated codecs
nvenc_deps_any="libdl LoadLibrary"
omx_deps="libdl pthreads"
omx_rpi_select="omx"
qsvdec_select="qsv"
qsvenc_select="qsv"
vaapi_encode_deps="vaapi"

hwupload_cuda_filter_deps="cuda"
scale_npp_filter_deps="cuda libnpp"

h264_mmal_decoder_deps="mmal"
h264_nvenc_encoder_deps="nvenc"
h264_omx_encoder_deps="omx"
h264_qsv_decoder_deps="libmfx"
h264_qsv_decoder_select="h264_mp4toannexb_bsf h264_parser qsvdec h264_qsv_hwaccel"
h264_qsv_encoder_deps="libmfx"
h264_qsv_encoder_select="qsvenc"
h264_vaapi_encoder_deps="VAEncPictureParameterBufferH264"
h264_vaapi_encoder_select="vaapi_encode golomb"
hevc_nvenc_encoder_deps="nvenc"
hevc_qsv_decoder_deps="libmfx"
hevc_qsv_decoder_select="hevc_mp4toannexb_bsf hevc_parser hevc_qsv_hwaccel qsvdec"
hevc_qsv_encoder_deps="libmfx"
hevc_qsv_encoder_select="hevc_ps qsvenc"
hevc_vaapi_encoder_deps="VAEncPictureParameterBufferHEVC"
hevc_vaapi_encoder_select="vaapi_encode golomb"
mjpeg_vaapi_encoder_deps="VAEncPictureParameterBufferJPEG"
mjpeg_vaapi_encoder_select="vaapi_encode jpegtables"
mpeg2_mmal_decoder_deps="mmal"
mpeg2_qsv_decoder_deps="libmfx"
mpeg2_qsv_decoder_select="qsvdec mpeg2_qsv_hwaccel mpegvideo_parser"
mpeg2_qsv_encoder_deps="libmfx"
mpeg2_qsv_encoder_select="qsvenc"
mpeg2_vaapi_encoder_deps="VAEncPictureParameterBufferMPEG2"
mpeg2_vaapi_encoder_select="vaapi_encode"
mpeg4_omx_encoder_deps="omx"
vc1_mmal_decoder_deps="mmal"
vc1_qsv_decoder_deps="libmfx"
vc1_qsv_decoder_select="qsvdec vc1_qsv_hwaccel vc1_parser"
vp8_qsv_decoder_deps="libmfx"
vp8_qsv_decoder_select="qsvdec vp8_qsv_hwaccel vp8_parser"
vp8_vaapi_encoder_deps="VAEncPictureParameterBufferVP8"
vp8_vaapi_encoder_select="vaapi_encode"

nvenc_h264_encoder_select="h264_nvenc_encoder"
nvenc_hevc_encoder_select="hevc_nvenc_encoder"

# parsers
h264_parser_select="golomb h264dsp h264parse"
hevc_parser_select="hevc_ps"
mpegaudio_parser_select="mpegaudioheader"
mpegvideo_parser_select="mpegvideo"
mpeg4video_parser_select="error_resilience h263dsp mpegvideo qpeldsp"
vc1_parser_select="vc1dsp"

# bitstream_filters
mjpeg2jpeg_bsf_select="jpegtables"

# external libraries
avisynth_deps="LoadLibrary"
avxsynth_deps="libdl"
avisynth_demuxer_deps_any="avisynth avxsynth"
avisynth_demuxer_select="riffdec"
libdcadec_decoder_deps="libdcadec"
libfaac_encoder_deps="libfaac"
libfaac_encoder_select="audio_frame_queue"
libfdk_aac_decoder_deps="libfdk_aac"
libfdk_aac_encoder_deps="libfdk_aac"
libfdk_aac_encoder_select="audio_frame_queue"
libgsm_decoder_deps="libgsm"
libgsm_encoder_deps="libgsm"
libgsm_ms_decoder_deps="libgsm"
libgsm_ms_encoder_deps="libgsm"
libilbc_decoder_deps="libilbc"
libilbc_encoder_deps="libilbc"
libkvazaar_encoder_deps="libkvazaar"
libmp3lame_encoder_deps="libmp3lame"
libmp3lame_encoder_select="audio_frame_queue mpegaudioheader"
libopencore_amrnb_decoder_deps="libopencore_amrnb"
libopencore_amrnb_encoder_deps="libopencore_amrnb"
libopencore_amrnb_encoder_select="audio_frame_queue"
libopencore_amrwb_decoder_deps="libopencore_amrwb"
libopenh264_decoder_deps="libopenh264"
libopenh264_decoder_select="h264_mp4toannexb_bsf"
libopenh264_encoder_deps="libopenh264"
libopenjpeg_decoder_deps="libopenjpeg"
libopenjpeg_encoder_deps="libopenjpeg"
libopus_decoder_deps="libopus"
libopus_encoder_deps="libopus"
libopus_encoder_select="audio_frame_queue"
libschroedinger_decoder_deps="libschroedinger"
libschroedinger_encoder_deps="libschroedinger"
libspeex_decoder_deps="libspeex"
libspeex_encoder_deps="libspeex"
libspeex_encoder_select="audio_frame_queue"
libtheora_encoder_deps="libtheora"
libtwolame_encoder_deps="libtwolame"
libvo_aacenc_encoder_deps="libvo_aacenc"
libvo_aacenc_encoder_select="audio_frame_queue"
libvo_amrwbenc_encoder_deps="libvo_amrwbenc"
libvorbis_encoder_deps="libvorbis"
libvorbis_encoder_select="audio_frame_queue"
libvpx_vp8_decoder_deps="libvpx"
libvpx_vp8_encoder_deps="libvpx"
libvpx_vp9_decoder_deps="libvpx"
libvpx_vp9_encoder_deps="libvpx"
libwavpack_encoder_deps="libwavpack"
libwavpack_encoder_select="audio_frame_queue"
libwebp_encoder_deps="libwebp"
libx262_encoder_deps="libx262"
libx264_encoder_deps="libx264"
libx265_encoder_deps="libx265"
libxavs_encoder_deps="libxavs"
libxvid_encoder_deps="libxvid mkstemp"

# demuxers / muxers
ac3_demuxer_select="ac3_parser"
asf_demuxer_select="riffdec"
asf_muxer_select="riffenc"
asf_stream_muxer_select="asf_muxer"
avi_demuxer_select="iso_media riffdec"
avi_muxer_select="riffenc"
caf_demuxer_select="iso_media riffdec"
dash_muxer_select="mp4_muxer"
dirac_demuxer_select="dirac_parser"
dv_demuxer_select="dvprofile"
dv_muxer_select="dvprofile"
dxa_demuxer_select="riffdec"
eac3_demuxer_select="ac3_parser"
f4v_muxer_select="mov_muxer"
flac_demuxer_select="flac_parser"
hds_muxer_select="flv_muxer"
hls_muxer_select="mpegts_muxer"
ipod_muxer_select="mov_muxer"
ismv_muxer_select="mov_muxer"
matroska_audio_muxer_select="matroska_muxer"
matroska_demuxer_select="iso_media riffdec"
matroska_demuxer_suggest="bzlib lzo zlib"
matroska_muxer_select="iso_media riffenc"
mmf_muxer_select="riffenc"
mov_demuxer_select="iso_media riffdec"
mov_demuxer_suggest="zlib"
mov_muxer_select="iso_media riffenc rtpenc_chain"
mp3_demuxer_select="mpegaudio_parser"
mp3_muxer_select="mpegaudioheader"
mp4_muxer_select="mov_muxer"
mpegts_demuxer_select="iso_media"
mpegts_muxer_select="adts_muxer latm_muxer"
mpegtsraw_demuxer_select="mpegts_demuxer"
mxf_d10_muxer_select="mxf_muxer"
nut_muxer_select="riffenc"
nuv_demuxer_select="riffdec"
oga_muxer_select="ogg_muxer"
ogg_demuxer_select="dirac_parse"
opus_muxer_select="ogg_muxer"
psp_muxer_select="mov_muxer"
rtp_demuxer_select="sdp_demuxer"
rtpdec_select="asf_demuxer jpegtables mov_demuxer mpegts_demuxer rm_demuxer rtp_protocol srtp"
rtsp_demuxer_select="http_protocol rtpdec"
rtsp_muxer_select="rtp_muxer http_protocol rtp_protocol rtpenc_chain"
sap_demuxer_select="sdp_demuxer"
sap_muxer_select="rtp_muxer rtp_protocol rtpenc_chain"
sdp_demuxer_select="rtpdec"
smoothstreaming_muxer_select="ismv_muxer"
spdif_muxer_select="aac_parser"
spx_muxer_select="ogg_muxer"
swf_demuxer_suggest="zlib"
tak_demuxer_select="tak_parser"
tg2_muxer_select="mov_muxer"
tgp_muxer_select="mov_muxer"
w64_demuxer_select="wav_demuxer"
wav_demuxer_select="riffdec"
wav_muxer_select="riffenc"
webm_muxer_select="iso_media riffenc"
wtv_demuxer_select="mpegts_demuxer riffdec"
xmv_demuxer_select="riffdec"
xwma_demuxer_select="riffdec"

# indevs / outdevs
alsa_indev_deps="alsa"
alsa_outdev_deps="alsa"
avfoundation_indev_deps="AVFoundation_AVFoundation_h objc_arc pthreads"
avfoundation_indev_extralibs="-framework Foundation -framework AVFoundation -framework CoreVideo -framework CoreMedia"
bktr_indev_deps_any="dev_bktr_ioctl_bt848_h machine_ioctl_bt848_h dev_video_bktr_ioctl_bt848_h dev_ic_bt8xx_h"
dv1394_indev_deps="dv1394"
dv1394_indev_select="dv_demuxer"
fbdev_indev_deps="linux_fb_h"
jack_indev_deps="jack"
jack_indev_deps_any="sem_timedwait dispatch_dispatch_h"
libcdio_indev_deps="libcdio"
libdc1394_indev_deps="libdc1394"
oss_indev_deps_any="soundcard_h sys_soundcard_h"
oss_outdev_deps_any="soundcard_h sys_soundcard_h"
pulse_indev_deps="libpulse"
sndio_indev_deps="sndio"
sndio_outdev_deps="sndio"
v4l2_indev_deps_any="linux_videodev2_h sys_videoio_h"
vfwcap_indev_deps="vfw32 vfwcap_defines"
xcbgrab_indev_deps="libxcb libxcb_shape"
xcbgrab_indev_suggest="libxcb_shm libxcb_xfixes"

# protocols
ffrtmpcrypt_protocol_conflict="librtmp_protocol"
ffrtmpcrypt_protocol_deps_any="gmp openssl"
ffrtmpcrypt_protocol_select="tcp_protocol"
ffrtmphttp_protocol_conflict="librtmp_protocol"
ffrtmphttp_protocol_select="http_protocol"
gopher_protocol_select="network"
http_protocol_select="tcp_protocol"
httpproxy_protocol_select="tcp_protocol"
https_protocol_select="tls_protocol"
icecast_protocol_select="http_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_select="network"
rtmp_protocol_conflict="librtmp_protocol"
rtmp_protocol_select="tcp_protocol"
rtmpe_protocol_select="ffrtmpcrypt_protocol"
rtmps_protocol_conflict="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="struct_sctp_event_subscribe"
sctp_protocol_select="network"
srtp_protocol_select="rtp_protocol srtp"
tcp_protocol_select="network"
tls_gnutls_protocol_deps="gnutls"
tls_gnutls_protocol_select="tcp_protocol"
tls_openssl_protocol_conflict="tls_gnutls_protocol"
tls_openssl_protocol_deps="openssl"
tls_openssl_protocol_select="tcp_protocol"
tls_protocol_deps_any="tls_gnutls_protocol tls_openssl_protocol"
udp_protocol_select="network"
unix_protocol_deps="sys_un_h"
unix_protocol_select="network"

# filters
asyncts_filter_deps="avresample"
blackframe_filter_deps="gpl"
boxblur_filter_deps="gpl"
bs2b_filter_deps="libbs2b"
cropdetect_filter_deps="gpl"
deinterlace_qsv_filter_deps="libmfx"
deinterlace_vaapi_filter_deps="vaapi"
delogo_filter_deps="gpl"
drawtext_filter_deps="libfreetype"
drawtext_filter_suggest="libfontconfig"
frei0r_filter_deps="frei0r libdl"
frei0r_src_filter_deps="frei0r libdl"
hdcd_filter_deps="libhdcd"
hqdn3d_filter_deps="gpl"
interlace_filter_deps="gpl"
movie_filter_deps="avcodec avformat"
ocv_filter_deps="libopencv"
resample_filter_deps="avresample"
scale_filter_deps="swscale"
scale_qsv_filter_deps="libmfx"
scale_vaapi_filter_deps="vaapi VAProcPipelineParameterBuffer"

# examples
decode_audio_example_deps="avcodec avutil"
decode_video_example_deps="avcodec avutil"
encode_audio_example_deps="avcodec avutil"
encode_video_example_deps="avcodec avutil"
filter_audio_example_deps="avfilter avutil"
metadata_example_deps="avformat avutil"
output_example_deps="avcodec avformat avresample avutil swscale"
qsvdec_example_deps="avcodec avutil libmfx h264_qsv_decoder"
transcode_aac_example_deps="avcodec avformat avresample"

# EXTRALIBS_LIST
cpu_init_extralibs="pthreads_extralibs"
cws2fws_extralibs="zlib_extralibs"

# libraries, in linking order
avcodec_deps="avutil"
avcodec_select="null_bsf"
avdevice_deps="avformat avcodec avutil"
avfilter_deps="avutil"
avformat_deps="avcodec avutil"
avformat_suggest="network"
avresample_deps="avutil"
swscale_deps="avutil"

avcodec_extralibs="pthreads_extralibs libm_extralibs"
avdevice_extralibs="libm_extralibs"
avformat_extralibs="libm_extralibs"
avfilter_extralibs="pthreads_extralibs libm_extralibs"
avresample_extralibs="libm_extralibs"
avutil_extralibs="clock_gettime_extralibs cuda_extralibs libm_extralibs libmfx_extralibs nanosleep_extralibs pthreads_extralibs user32_extralibs vaapi_extralibs vaapi_drm_extralibs vaapi_x11_extralibs vdpau_x11_extralibs wincrypt_extralibs"
swscale_extralibs="libm_extralibs"

# programs
avconv_deps="avcodec avfilter avformat avresample swscale"
avconv_select="aformat_filter anull_filter asyncts_filter atrim_filter format_filter
               fps_filter null_filter resample_filter scale_filter
               trim_filter"
avconv_suggest="dxva2_lib ole32 psapi shell32"
avplay_deps="avcodec avfilter avformat avresample sdl"
avplay_select="rdft format_filter transpose_filter hflip_filter vflip_filter"
avplay_suggest="shell32"
avprobe_deps="avcodec avformat"
avprobe_suggest="shell32"

# documentation
pod2man_deps="doc"
texi2html_deps="doc"

# default parameters

logfile="avbuild/config.log"

# installation paths
prefix_default="/usr/local"
bindir_default='${prefix}/bin'
datadir_default='${prefix}/share/avconv'
docdir_default='${prefix}/share/doc/libav'
incdir_default='${prefix}/include'
libdir_default='${prefix}/lib'
mandir_default='${prefix}/share/man'
shlibdir_default="$libdir_default"

# toolchain
ar_default="ar"
cc_default="gcc"
host_cc_default="gcc"
x86asmexe_default="nasm"
ln_s="ln -s -f"
nm_default="nm -g"
pkg_config_default=pkg-config
ranlib="ranlib"
strip="strip"
version_script='--version-script'

# machine
arch_default=$(uname -m)
cpu="generic"
intrinsics="none"

# OS
target_os_default=$(tolower $(uname -s))
host_os=$target_os_default

# configurable options
enable $EXAMPLE_LIST $LIBRARY_LIST $PROGRAM_LIST

enable asm
enable debug
enable doc
enable faan faandct faanidct
enable optimizations
enable safe_bitstream_reader
enable static
enable swscale_alpha
enable valgrind_backtrace

# By default, enable only those hwaccels that have no external dependencies.
enable d3d11va dxva2 vda vdpau

# internal components are enabled by default
enable $EXTRALIBS_LIST

# Avoid external, non-system, libraries getting enabled by dependency resolution
disable $EXTERNAL_LIBRARY_LIST

# build settings
SHFLAGS='-shared -Wl,-soname,$$(@F)'
LIBPREF="lib"
LIBSUF=".a"
LIBNAME='$(LIBPREF)$(NAME)$(LIBSUF)'
SLIBPREF="lib"
SLIBSUF=".so"
SLIBNAME='$(SLIBPREF)$(NAME)$(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)'
VERSION_SCRIPT_POSTPROCESS_CMD="cat"

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 $@'
OBJCC_C='-c'
OBJCC_E='-E -o $@'
OBJCC_O='-o $@'
X86ASM_O='-o $@'
LD_O='-o $@'
LD_LIB='-l%'
LD_PATH='-L'
HOSTCC_C='-c'
HOSTCC_E='-E -o $@'
HOSTCC_O='-o $@'
HOSTLD_O='-o $@'

host_extralibs='-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'

mkdir -p avbuild

# 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")
    LIBAV_CONFIGURATION="${LIBAV_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)
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)
FILTER_LIST=$(find_things   filter   FILTER   libavfilter/allfilters.c)

find_things_extern(){
    thing=$1
    pattern=$2
    file=$source_path/$3
    sed -n "s/^[^#]*extern.*$pattern *ff_\([^ ]*\)_$thing;/\1_$thing/p" "$file"
}

BSF_LIST=$(find_things_extern bsf AVBitStreamFilter libavcodec/bitstream_filters.c)
PROTOCOL_LIST=$(find_things_extern protocol URLProtocol libavformat/protocols.c)

AVCODEC_COMPONENTS_LIST="
    $BSF_LIST
    $DECODER_LIST
    $ENCODER_LIST
    $HWACCEL_LIST
    $PARSER_LIST
"

AVDEVICE_COMPONENTS_LIST="
    $INDEV_LIST
    $OUTDEV_LIST
"

AVFILTER_COMPONENTS_LIST="
    $FILTER_LIST
"

AVFORMAT_COMPONENTS_LIST="
    $DEMUXER_LIST
    $MUXER_LIST
    $PROTOCOL_LIST
"

ALL_COMPONENTS="
    $AVCODEC_COMPONENTS_LIST
    $AVDEVICE_COMPONENTS_LIST
    $AVFILTER_COMPONENTS_LIST
    $AVFORMAT_COMPONENTS_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
}

print_3_columns() {
    printf "%-25s %-25s %-25s\n" $(cat | tr ' ' '\n' | sort)
}

show_list() {
    suffix=_$1
    shift
    echo $* | sed s/$suffix//g | print_3_columns
    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-ldexeflags=*)
            add_ldexeflags $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
        ;;
        --disable-all)
            map 'eval unset \${$(toupper ${v%s})_LIST}' $COMPONENT_LIST
            disable $LIBRARY_LIST $PROGRAM_LIST doc
        ;;
        --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}
            $action $(filter "$name" $list)
        ;;
        --enable-avserver|--disable-avserver*)
            warn "avserver has been removed, the ${opt} option is only"\
                 "provided for compatibility and will be removed in the future"
        ;;
        --enable-yasm|--disable-yasm)
            warn "The ${opt} option is only provided for compatibility and will be\n"\
                 "removed in the future. Use --enable-x86asm / --disable-x86asm instead."
            test $opt = --enable-yasm && x86asm=yes || x86asm=no
        ;;
        --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
        ;;
        --quiet|-q) quiet=yes
        ;;
        *)
            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

for e in $env; do
    eval "export $e"
done

disabled logging && logfile=/dev/null

# Die early if licensing-related configure options are incompatible.
die_license_disabled() {
    enabled $1 || { enabled $v && die "$v is $1 and --enable-$1 is not specified."; }
}

map "die_license_disabled gpl"      $EXTERNAL_LIBRARY_GPL_LIST
map "die_license_disabled nonfree"  $EXTERNAL_LIBRARY_NONFREE_LIST $HWACCEL_LIBRARY_NONFREE_LIST
map "die_license_disabled version3" $EXTERNAL_LIBRARY_VERSION3_LIST

enabled version3 && { enabled gpl && enable gplv3 || enable lgplv3; }

# Disable all the library-specific components if the library itself
# is disabled, see AVCODEC_LIST and following _LIST variables.

disable_components(){
    disabled ${1} && disable $(
        eval components="\$$(toupper ${1})_COMPONENTS"
        map 'eval echo \${$(toupper ${v%s})_LIST}' $components
    )
}

map 'disable_components $v' $LIBRARY_LIST

echo "# $0 $LIBAV_CONFIGURATION" > $logfile
set >> $logfile

case "$toolchain" in
    *-asan)
        cc_default="${toolchain%-asan}"
        add_cflags  -fsanitize=address
        add_ldflags -fsanitize=address
    ;;
    *-msan)
        cc_default="${toolchain%-msan}"
        add_cflags  -fsanitize=memory -fsanitize-memory-track-origins
        add_ldflags -fsanitize=memory
    ;;
    *-tsan)
        cc_default="${toolchain%-tsan}"
        add_cflags  -fsanitize=thread -fPIE
        add_ldflags -fsanitize=thread -pie
        case "$toolchain" in
            gcc-tsan)
                add_cflags  -fPIC
                add_ldflags -fPIC
                ;;
        esac
    ;;
    *-usan)
        cc_default="${toolchain%-usan}"
        add_cflags  -fsanitize=undefined
        add_ldflags -fsanitize=undefined
        case "$toolchain" in
            clang-usan)
                add_cflags -O1
                ;;
        esac
    ;;
    valgrind-*)
        target_exec_default="valgrind"
        case "$toolchain" in
            valgrind-massif)
                target_exec_args="--alloc-fn=av_malloc --alloc-fn=av_mallocz"
                ;;
            valgrind-memcheck)
                target_exec_args="--track-origins=yes --leak-check=full"
                ;;
        esac
    ;;
    msvc)
        # Check whether the current MSVC version needs the C99 converter.
        # From MSVC 2013 (compiler major version 18) onwards, it does actually
        # support enough of C99 to build libav. Default to the new
        # behaviour if the regexp was unable to match anything, since this
        # successfully parses the version number of existing supported
        # versions that require the converter (MSVC 2010 and 2012).
        cl_major_ver=$(cl 2>&1 | sed -n 's/.*Version \([[:digit:]]\{1,\}\)\..*/\1/p')
        if [ -z "$cl_major_ver" ] || [ $cl_major_ver -ge 18 ]; then
            cc_default="cl"
        else
            cc_default="c99wrap cl"
        fi
        ld_default="$source_path/compat/windows/mslink"
        nm_default="dumpbin -symbols"
        ar_default="lib"
        case "$arch" in
        arm*)
            as_default="armasm"
            ;;
        esac
        target_os_default="win32"
        # Use a relative path for TMPDIR. This makes sure all the
        # ffconf temp files are written with a relative path, avoiding
        # issues with msys/win32 path conversion for MSVC parameters
        # such as -Fo<file> or -out:<file>.
        TMPDIR=.
    ;;
    icl)
        cc_default="icl"
        ld_default="xilink"
        nm_default="dumpbin -symbols"
        ar_default="xilib"
        target_os_default="win32"
        TMPDIR=.
    ;;
    gcov)
        add_cflags  -fprofile-arcs -ftest-coverage
        add_ldflags -fprofile-arcs -ftest-coverage
    ;;
    llvm-cov)
        add_cflags -fprofile-arcs -ftest-coverage
        add_ldflags --coverage
    ;;
    hardened)
        add_cppflags -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=2
        add_cflags   -fno-strict-overflow -fstack-protector-all
        add_ldflags  -Wl,-z,relro -Wl,-z,now
    ;;
    ?*)
        die "Unknown toolchain $toolchain"
    ;;
esac

test -n "$cross_prefix" && enable cross_compile

if enabled cross_compile; then
    test -n "$arch" && test -n "$target_os" ||
        die "Must specify target arch (--arch) and OS (--target-os) when cross-compiling"
fi

ar_default="${cross_prefix}${ar_default}"
cc_default="${cross_prefix}${cc_default}"
objcc_default="${cross_prefix}${objcc_default}"
x86asmexe_default="${cross_prefix}${x86asmexe_default}"
nm_default="${cross_prefix}${nm_default}"
pkg_config_default="${cross_prefix}${pkg_config_default}"
ranlib="${cross_prefix}${ranlib}"
strip="${cross_prefix}${strip}"

sysinclude_default="${sysroot}/usr/include"

set_default arch cc pkg_config sysinclude target_exec target_os x86asmexe
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*|mingw64*|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(){
        tmpname="${2%%XXX*}.${HOSTNAME}.${UID}.$$"
        echo "$tmpname"
        mkdir "$tmpname"
    }
fi

AVTMPDIR=$(mktemp -d "${TMPDIR}/avconf.XXXXXXXX" 2> /dev/null) ||
    die "Unable to create temporary directory in $TMPDIR."

tmpfile(){
    tmp="${AVTMPDIR}/test"$2
    (set -C; exec > $tmp) 2> /dev/null ||
        die "Unable to create temporary file in $AVTMPDIR."
    eval $1=$tmp
}

trap 'rm -rf -- "$AVTMPDIR"' EXIT
trap 'exit 2' INT

tmpfile TMPASM .asm
tmpfile TMPC   .c
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

armasm_flags(){
    for flag; do
        case $flag in
            # Filter out MSVC cl.exe options from cflags that shouldn't
            # be passed to gas-preprocessor
            -M[TD]*)                                            ;;
            *)                  echo $flag                      ;;
        esac
   done
}

ccc_flags(){
    for flag; do
        case $flag in
            -std=c99)           echo -c99                       ;;
            -mcpu=*)            echo -arch ${flag#*=}           ;;
            -mieee)             echo -ieee                      ;;
            -O*|-fast)          echo $flag                      ;;
            -fno-math-errno)    echo -assume nomath_errno       ;;
            -g)                 echo -g3                        ;;
            -Wall)              echo -msg_enable level2         ;;
            -Wno-pointer-sign)  echo -msg_disable ptrmismatch1  ;;
            -Wl,*)              echo $flag                      ;;
            -f*|-W*)                                            ;;
            *)                  echo $flag                      ;;
        esac
   done
}

cparser_flags(){
    for flag; do
        case $flag in
            -Wno-switch)             echo -Wno-switch-enum ;;
            -Wno-format-zero-length) ;;
            -Wdisabled-optimization) ;;
            -Wno-pointer-sign)       echo -Wno-other ;;
            *)                       echo $flag ;;
        esac
    done
}

msvc_common_flags(){
    for flag; do
        case $flag in
            # In addition to specifying certain flags under the compiler
            # specific filters, they must be specified here as well or else the
            # generic catch all at the bottom will print the original flag.
            -Wall)                ;;
            -Wextra)              ;;
            -std=c99)             ;;
            # Common flags
            -fomit-frame-pointer) ;;
            -g)                   echo -Z7 ;;
            -fno-math-errno)      ;;
            -fno-common)          ;;
            -fno-signed-zeros)    ;;
            -fPIC)                ;;
            -mthumb)              ;;
            -march=*)             ;;
            -lz)                  echo zlib.lib ;;
            -lx264)               echo libx264.lib ;;
            -l*)                  echo ${flag#-l}.lib ;;
            -L*)                  echo -libpath:${flag#-L} ;;
            *)                    echo $flag ;;
        esac
    done
}

msvc_flags(){
    msvc_common_flags "$@"
    for flag; do
        case $flag in
            -Wall)                echo -W3 -wd4018 -wd4146 -wd4244 -wd4305     \
                                       -wd4554 ;;
            -Wextra)              echo -W4 -wd4244 -wd4127 -wd4018 -wd4389     \
                                       -wd4146 -wd4057 -wd4204 -wd4706 -wd4305 \
                                       -wd4152 -wd4324 -we4013 -wd4100 -wd4214 \
                                       -wd4273 -wd4554 -wd4701 -wd4703 ;;
        esac
    done
}

icl_flags(){
    msvc_common_flags "$@"
    for flag; do
        case $flag in
            # Despite what Intel's documentation says -Wall, which is supported
            # on Windows, does enable remarks so disable them here.
            -Wall)                echo $flag -Qdiag-disable:remark ;;
            -std=c99)             echo -Qstd=c99 ;;
        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   ;;
                    corei7)           echo -xarch=sse4_2 -xchip=nehalem  ;;
                    corei7-avx)       echo -xarch=avx -xchip=sandybridge ;;
                    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*|-mimpure-text)                      ;;
            -shared)              echo -G                 ;;
            *)                    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