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

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-ffmpeg         disable ffmpeg build
  --disable-ffplay         disable ffplay build
  --disable-ffprobe        disable ffprobe build
  --disable-ffserver       disable ffserver build
  --disable-avdevice       disable libavdevice build
  --disable-avcodec        disable libavcodec build
  --disable-avformat       disable libavformat build
  --disable-swresample     disable libswresample build
  --disable-swscale        disable libswscale build
  --disable-postproc       disable libpostproc build
  --disable-avfilter       disable libavfilter build
  --enable-avresample      enable libavresample build [no]
  --disable-pthreads       disable pthreads [auto]
  --disable-w32threads     disable Win32 threads [auto]
  --disable-os2threads     disable OS/2 threads [auto]
  --enable-x11grab         enable X11 grabbing [no]
  --disable-network        disable network support [no]
  --disable-dct            disable DCT code
  --disable-dwt            disable DWT code
  --disable-lsp            disable LSP code
  --disable-mdct           disable MDCT code
  --disable-rdft           disable RDFT code
  --disable-fft            disable FFT code
  --enable-dxva2           enable DXVA2 code
  --enable-vaapi           enable VAAPI code [autodetect]
  --enable-vda             enable VDA code   [autodetect]
  --enable-vdpau           enable VDPAU code [autodetect]

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

External library support:
  --enable-avisynth        enable reading of AVISynth script files [no]
  --enable-bzlib           enable bzlib [autodetect]
  --enable-fontconfig      enable fontconfig
  --enable-frei0r          enable frei0r video filtering
  --enable-gnutls          enable gnutls [no]
  --enable-libaacplus      enable AAC+ encoding via libaacplus [no]
  --enable-libass          enable libass subtitles rendering [no]
  --enable-libbluray       enable BluRay reading using libbluray [no]
  --enable-libcaca         enable textual display using libcaca
  --enable-libcelt         enable CELT decoding via libcelt [no]
  --enable-libcdio         enable audio CD grabbing with libcdio
  --enable-libdc1394       enable IIDC-1394 grabbing using libdc1394
                           and libraw1394 [no]
  --enable-libfaac         enable AAC encoding via libfaac [no]
  --enable-libfdk-aac      enable AAC encoding via libfdk-aac [no]
  --enable-libflite        enable flite (voice synthesis) support via libflite [no]
  --enable-libfreetype     enable libfreetype [no]
  --enable-libgsm          enable GSM de/encoding via libgsm [no]
  --enable-libiec61883     enable iec61883 via libiec61883 [no]
  --enable-libilbc         enable iLBC de/encoding via libilbc [no]
  --enable-libmodplug      enable ModPlug via libmodplug [no]
  --enable-libmp3lame      enable MP3 encoding via libmp3lame [no]
  --enable-libnut          enable NUT (de)muxing via libnut,
                           native (de)muxer exists [no]
  --enable-libopencore-amrnb enable AMR-NB de/encoding via libopencore-amrnb [no]
  --enable-libopencore-amrwb enable AMR-WB decoding via libopencore-amrwb [no]
  --enable-libopencv       enable video filtering via libopencv [no]
  --enable-libopenjpeg     enable JPEG 2000 de/encoding via OpenJPEG [no]
  --enable-libopus         enable Opus decoding via libopus [no]
  --enable-libpulse        enable Pulseaudio input via libpulse [no]
  --enable-librtmp         enable RTMP[E] support via librtmp [no]
  --enable-libschroedinger enable Dirac de/encoding via libschroedinger [no]
  --enable-libspeex        enable Speex de/encoding via libspeex [no]
  --enable-libstagefright-h264  enable H.264 decoding via libstagefright [no]
  --enable-libtheora       enable Theora encoding via libtheora [no]
  --enable-libtwolame      enable MP2 encoding via libtwolame [no]
  --enable-libutvideo      enable Ut Video encoding and decoding via libutvideo [no]
  --enable-libv4l2         enable libv4l2/v4l-utils [no]
  --enable-libvo-aacenc    enable AAC encoding via libvo-aacenc [no]
  --enable-libvo-amrwbenc  enable AMR-WB encoding via libvo-amrwbenc [no]
  --enable-libvorbis       enable Vorbis en/decoding via libvorbis,
                           native implementation exists [no]
  --enable-libvpx          enable VP8 de/encoding via libvpx [no]
  --enable-libx264         enable H.264 encoding via x264 [no]
  --enable-libxavs         enable AVS encoding via xavs [no]
  --enable-libxvid         enable Xvid encoding via xvidcore,
                           native MPEG-4/Xvid encoder exists [no]
  --enable-openal          enable OpenAL 1.1 capture support [no]
  --enable-openssl         enable openssl [no]
  --enable-zlib            enable zlib [autodetect]

Advanced options (experts only):
  --cross-prefix=PREFIX    use PREFIX for compilation tools [$cross_prefix]
  --enable-cross-compile   assume a cross-compiler is used
  --sysroot=PATH           root of cross-build tree
  --sysinclude=PATH        location of cross-build system headers
  --target-os=OS           compiler targets OS [$target_os]
  --target-exec=CMD        command to run executables on target
  --target-path=DIR        path to view of build directory on target
  --toolchain=NAME         set tool defaults according to NAME
  --nm=NM                  use nm tool NM [$nm_default]
  --ar=AR                  use archive tool AR [$ar_default]
  --as=AS                  use assembler AS [$as_default]
  --yasmexe=EXE            use yasm-compatible assembler EXE [$yasmexe_default]
  --cc=CC                  use C compiler CC [$cc_default]
  --cxx=CXX                use C compiler CXX [$cxx_default]
  --dep-cc=DEPCC           use dependency generator DEPCC [$cc_default]
  --ld=LD                  use linker LD [$ld_default]
  --host-cc=HOSTCC         use host C compiler HOSTCC
  --host-cflags=HCFLAGS    use HCFLAGS when compiling for host
  --host-ld=HOSTLD         use host linker HOSTLD
  --host-ldflags=HLDFLAGS  use HLDFLAGS when linking for host
  --host-libs=HLIBS        use libs HLIBS when linking for host
  --host-os=OS             compiler host OS [$target_os]
  --extra-cflags=ECFLAGS   add ECFLAGS to CFLAGS [$CFLAGS]
  --extra-cxxflags=ECFLAGS add ECFLAGS to CXXFLAGS [$CXXFLAGS]
  --extra-ldflags=ELDFLAGS add ELDFLAGS to LDFLAGS [$LDFLAGS]
  --extra-libs=ELIBS       add ELIBS [$ELIBS]
  --extra-version=STRING   version string suffix []
  --optflags=OPTFLAGS      override optimization-related compiler flags
  --build-suffix=SUFFIX    library name suffix []
  --malloc-prefix=PREFIX   prefix malloc and related names with PREFIX
  --progs-suffix=SUFFIX    program name suffix []
  --arch=ARCH              select architecture [$arch]
  --cpu=CPU                select the minimum required CPU (affects
                           instruction selection, may crash on older CPUs)
  --enable-pic             build position-independent code
  --enable-sram            allow use of on-chip SRAM
  --enable-thumb           compile for Thumb instruction set
  --disable-symver         disable symbol versioning
  --enable-hardcoded-tables use hardcoded tables instead of runtime generation
  --disable-safe-bitstream-reader
                           disable buffer boundary checking in bitreaders
                           (faster, but may crash)
  --enable-memalign-hack   emulate memalign, interferes with memory debuggers
  --enable-lto             use link-time optimization

Optimization options (experts only):
  --disable-asm            disable all assembler optimizations
  --disable-altivec        disable AltiVec optimizations
  --disable-amd3dnow       disable 3DNow! optimizations
  --disable-amd3dnowext    disable 3DNow! extended optimizations
  --disable-mmx            disable MMX optimizations
  --disable-mmxext         disable MMXEXT optimizations
  --disable-sse            disable SSE optimizations
  --disable-sse2           disable SSE2 optimizations
  --disable-sse3           disable SSE3 optimizations
  --disable-ssse3          disable SSSE3 optimizations
  --disable-sse4           disable SSE4 optimizations
  --disable-sse42          disable SSE4.2 optimizations
  --disable-avx            disable AVX optimizations
  --disable-fma4           disable FMA4 optimizations
  --disable-armv5te        disable armv5te optimizations
  --disable-armv6          disable armv6 optimizations
  --disable-armv6t2        disable armv6t2 optimizations
  --disable-armvfp         disable ARM VFP optimizations
  --disable-neon           disable NEON optimizations
  --disable-vis            disable VIS optimizations
  --disable-inline-asm     disable use of inline assembler
  --disable-yasm           disable use of yasm assembler
  --disable-mips32r2       disable MIPS32R2 optimizations
  --disable-mipsdspr1      disable MIPS DSP ASE R1 optimizations
  --disable-mipsdspr2      disable MIPS DSP ASE R2 optimizations
  --disable-mipsfpu        disable floating point MIPS optimizations
  --disable-fast-unaligned consider unaligned accesses slow
  --postproc-version=V     build libpostproc version V.
                           Where V can be '$ALT_PP_VER_MAJOR.$ALT_PP_VER_MINOR.$ALT_PP_VER_MICRO' or 'current'. [$postproc_version_default]

Developer options (useful when working on FFmpeg itself):
  --enable-coverage        build with test coverage instrumentation
  --disable-debug          disable debugging symbols
  --enable-debug=LEVEL     set the debug level [$debuglevel]
  --disable-optimizations  disable compiler optimizations
  --enable-extra-warnings  enable more compiler warnings
  --disable-stripping      disable stripping of executables and shared libraries
  --assert-level=level     0(default), 1 or 2, amount of assertion testing,
                           2 causes a slowdown at runtime.
  --enable-memory-poisoning fill heap uninitialized allocated space with arbitrary data
  --valgrind=VALGRIND      run "make fate" tests through valgrind to detect memory
                           leaks and errors, using the specified valgrind binary.
                           Cannot be combined with --target-exec
  --enable-ftrapv          Trap arithmetic overflows
  --samples=PATH           location of test samples for FATE, if not set use
                           \$FATE_SAMPLES at make invocation time.
  --enable-xmm-clobber-test check XMM registers for clobbering (Win64-only;
                           should be used only for debugging purposes)
  --enable-random          randomly enable/disable components
  --disable-random
  --enable-random=LIST     randomly enable/disable specific components or
  --disable-random=LIST    component groups. LIST is a comma-separated list
                           of NAME[:PROB] entries where NAME is a component
                           (group) and PROB the probability associated with
                           NAME (default 0.5).
  --random-seed=VALUE      seed value for --enable/disable-random

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

quotes='""'

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

log_file(){
    log BEGIN $1
    pr -n -t $1 >> $logfile
    log END $1
}

echolog(){
    log "$@"
    echo "$@"
}

warn(){
    log "WARNING: $*"
    WARNINGS="${WARNINGS}WARNING: $*\n"
}

die(){
    echolog "$@"
    cat <<EOF

If you think configure made a mistake, make sure you are using the latest
version from Git.  If the latest version fails, report the problem to the
ffmpeg-user@ffmpeg.org mailing list or IRC #ffmpeg on irc.freenode.net.
EOF
    if disabled logging; then
        cat <<EOF
Rerun configure with logging enabled (do not use --disable-logging), and
include the log this produces with your report.
EOF
    else
        cat <<EOF
Include the log file "$logfile" produced by configure as this will help
solving the problem.
EOF
    fi
    exit 1
}

# Avoid locale weirdness, besides we really just want to translate ASCII.
toupper(){
    echo "$@" | tr abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ
}

tolower(){
    echo "$@" | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz
}

c_escape(){
    echo "$*" | sed 's/["\\]/\\\0/g'
}

sh_quote(){
    v=$(echo "$1" | sed "s/'/'\\\\''/g")
    test "x$v" = "x${v#*[!A-Za-z0-9_/.+-]}" || v="'$v'"
    echo "$v"
}

cleanws(){
    echo "$@" | sed 's/^ *//;s/  */ /g;s/ *$//'
}

filter(){
    pat=$1
    shift
    for v; do
        eval "case $v in $pat) echo $v ;; esac"
    done
}

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

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

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

set_all(){
    value=$1
    shift
    for var in $*; do
        eval $var=$value
    done
}

set_weak(){
    value=$1
    shift
    for var; do
        eval : \${$var:=$value}
    done
}

set_safe(){
    var=$1
    shift
    eval $(echo "$var" | sed 's/[^A-Za-z0-9_]/_/g')='$*'
}

get_safe(){
    eval echo \$$(echo "$1" | sed 's/[^A-Za-z0-9_]/_/g')
}

pushvar(){
    for var in $*; do
        eval level=\${${var}_level:=0}
        eval ${var}_${level}="\$$var"
        eval ${var}_level=$(($level+1))
    done
}

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

enable(){
    set_all yes $*
}

disable(){
    set_all no $*
}

enable_weak(){
    set_weak yes $*
}

disable_weak(){
    set_weak no $*
}

enable_safe(){
    for var; do
        enable $(echo "$var" | sed 's/[^A-Za-z0-9_]/_/g')
    done
}

disable_safe(){
    for var; do
        disable $(echo "$var" | sed 's/[^A-Za-z0-9_]/_/g')
    done
}

do_enable_deep(){
    for var; do
        enabled $var && continue
        eval sel="\$${var}_select"
        eval sgs="\$${var}_suggest"
        pushvar var sgs
        enable_deep $sel
        popvar sgs
        enable_deep_weak $sgs
        popvar var
    done
}

enable_deep(){
    do_enable_deep $*
    enable $*
}

enable_deep_weak(){
    do_enable_deep $*
    enable_weak $*
}

enabled(){
    test "${1#!}" = "$1" && op== || op=!=
    eval test "x\$${1#!}" $op "xyes"
}

disabled(){
    test "${1#!}" = "$1" && op== || op=!=
    eval test "x\$${1#!}" $op "xno"
}

enabled_all(){
    for opt; do
        enabled $opt || return 1
    done
}

disabled_all(){
    for opt; do
        disabled $opt || return 1
    done
}

enabled_any(){
    for opt; do
        enabled $opt && return 0
    done
}

disabled_any(){
    for opt; do
        disabled $opt && return 0
    done
    return 1
}

set_default(){
    for opt; do
        eval : \${$opt:=\$${opt}_default}
    done
}

is_in(){
    value=$1
    shift
    for var in $*; do
        [ $var = $value ] && return 0
    done
    return 1
}

check_deps(){
    for cfg; do
        cfg="${cfg#!}"
        enabled ${cfg}_checking && die "Circular dependency for $cfg."
        disabled ${cfg}_checking && continue
        enable ${cfg}_checking

        eval dep_all="\$${cfg}_deps"
        eval dep_any="\$${cfg}_deps_any"
        eval dep_sel="\$${cfg}_select"
        eval dep_sgs="\$${cfg}_suggest"
        eval dep_ifa="\$${cfg}_if"
        eval dep_ifn="\$${cfg}_if_any"

        pushvar cfg dep_all dep_any dep_sel dep_sgs dep_ifa dep_ifn
        check_deps $dep_all $dep_any $dep_sel $dep_sgs $dep_ifa $dep_ifn
        popvar cfg dep_all dep_any dep_sel dep_sgs dep_ifa dep_ifn

        [ -n "$dep_ifa" ] && { enabled_all $dep_ifa && enable_weak $cfg; }
        [ -n "$dep_ifn" ] && { enabled_any $dep_ifn && enable_weak $cfg; }
        enabled_all  $dep_all || disable $cfg
        enabled_any  $dep_any || disable $cfg
        disabled_any $dep_sel && disable $cfg

        if enabled $cfg; then
            eval dep_extralibs="\$${cfg}_extralibs"
            test -n "$dep_extralibs" && add_extralibs $dep_extralibs
            enable_deep $dep_sel
            enable_deep_weak $dep_sgs
        fi

        disable ${cfg}_checking
    done
}

print_config_h(){
    enabled $1 && v=1 || v=0
    echo "#define $2 $v"
}

print_config_mak(){
    enabled $1 && v= || v=!
    echo "$v$2=yes"
}

print_config_asm(){
    enabled $1 && v=1 || v=0
    echo "%define $2 $v"
}

print_config(){
    pfx=$1
    files=$2
    shift 2
    for cfg; do
        ucname="$(toupper $cfg)"
        for f in $files; do
            "print_config_${f##*.}" $cfg ${pfx}${ucname} >>$f
        done
    done
}

print_enabled(){
    test x"$1" = x-n && end=" " && shift || end="\n"
    suf=$1
    shift
    for v; do
        enabled $v && printf "%s$end" ${v%$suf};
    done
}

append(){
    var=$1
    shift
    eval "$var=\"\$$var $*\""
}

prepend(){
    var=$1
    shift
    eval "$var=\"$* \$$var\""
}

add_cppflags(){
    append CPPFLAGS "$@"
}

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

add_cxxflags(){
    append CXXFLAGS $($cflags_filter "$@")
}

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

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

add_extralibs(){
    prepend extralibs $($ldflags_filter "$@")
}

add_host_cflags(){
    append host_cflags $($host_cflags_filter "$@")
}

add_host_ldflags(){
    append host_ldflags $($host_ldflags_filter "$@")
}

check_cmd(){
    log "$@"
    "$@" >> $logfile 2>&1
}

cc_o(){
    eval printf '%s\\n' $CC_O
}

cc_e(){
    eval printf '%s\\n' $CC_E
}

check_cc(){
    log check_cc "$@"
    cat > $TMPC
    log_file $TMPC
    check_cmd $cc $CPPFLAGS $CFLAGS "$@" $CC_C $(cc_o $TMPO) $TMPC
}

check_cxx(){
    log check_cxx "$@"
    cat > $TMPCPP
    log_file $TMPCPP
    check_cmd $cxx $CPPFLAGS $CFLAGS $CXXFLAGS "$@" $CXX_C -o $TMPO $TMPCPP
}

check_cpp(){
    log check_cpp "$@"
    cat > $TMPC
    log_file $TMPC
    check_cmd $cc $CPPFLAGS $CFLAGS "$@" $(cc_e $TMPO) $TMPC
}

as_o(){
    eval printf '%s\\n' $AS_O
}

check_as(){
    log check_as "$@"
    cat > $TMPC
    log_file $TMPC
    check_cmd $as $CPPFLAGS $ASFLAGS "$@" $AS_C $(as_o $TMPO) $TMPC
}

check_inline_asm(){
    log check_inline_asm "$@"
    name="$1"
    code="$2"
    shift 2
    disable $name
    check_as "$@" <<EOF && enable $name
void foo(void){ __asm__ volatile($code); }
EOF
}

check_yasm(){
    log check_yasm "$@"
    echo "$1" > $TMPS
    log_file $TMPS
    shift 1
    check_cmd $yasmexe $YASMFLAGS -Werror "$@" -o $TMPO $TMPS
}

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

check_ld(){
    log check_ld "$@"
    type=$1
    shift 1
    flags=''
    libs=''
    for f; do
        test "${f}" = "${f#-l}" && flags="$flags $f" || libs="$libs $f"
    done
    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
    shift
    disable $func
    check_ld "cc" "$@" <<EOF && enable $func
#include <math.h>
float foo(float f) { return $func(f); }
int main(void){ return (int) foo; }
EOF
}

check_func_headers(){
    log check_func_headers "$@"
    headers=$1
    funcs=$2
    shift 2
    {
        for hdr in $headers; do
            echo "#include <$hdr>"
        done
        for func in $funcs; do
            echo "long check_$func(void) { return (long) $func; }"
        done
        echo "int main(void) { return 0; }"
    } | check_ld "cc" "$@" && enable $funcs && enable_safe $headers
}

check_class_headers_cpp(){
    log check_class_headers_cpp "$@"
    headers=$1
    classes=$2
    shift 2
    {
        for hdr in $headers; do
            echo "#include <$hdr>"
        done
        echo "int main(void) { "
        i=1
        for class in $classes; do
            echo "$class obj$i;"
            i=$(expr $i + 1)
        done
        echo "return 0; }"
    } | check_ld "cxx" "$@" && enable $funcs && enable_safe $headers
}

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

check_lib(){
    log check_lib "$@"
    header="$1"
    func="$2"
    shift 2
    check_header $header && check_func $func "$@" && add_extralibs "$@"
}

check_lib2(){
    log check_lib2 "$@"
    headers="$1"
    funcs="$2"
    shift 2
    check_func_headers "$headers" "$funcs" "$@" && add_extralibs "$@"
}

check_lib_cpp(){
    log check_lib_cpp "$@"
    headers="$1"
    classes="$2"
    shift 2
    check_class_headers_cpp "$headers" "$classes" "$@" && add_extralibs "$@"
}

check_pkg_config(){
    log check_pkg_config "$@"
    pkg="$1"
    headers="$2"
    funcs="$3"
    shift 3
    $pkg_config --exists $pkg 2>/dev/null || return
    pkg_cflags=$($pkg_config --cflags $pkg)
    pkg_libs=$($pkg_config --libs $pkg)
    check_func_headers "$headers" "$funcs" $pkg_cflags $pkg_libs "$@" &&
        set_safe ${pkg}_cflags $pkg_cflags   &&
        set_safe ${pkg}_libs   $pkg_libs
}

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

check_exec_crash(){
    code=$(cat)

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

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

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

check_struct(){
    log check_type "$@"
    headers=$1
    struct=$2
    member=$3
    shift 3
    disable_safe "${struct}_${member}"
    check_code cc "$headers" "const void *p = &(($struct *)0)->$member" "$@" &&
        enable_safe "${struct}_${member}"
}

require(){
    name="$1"
    header="$2"
    func="$3"
    shift 3
    check_lib $header $func "$@" || die "ERROR: $name not found"
}

require2(){
    name="$1"
    headers="$2"
    func="$3"
    shift 3
    check_lib2 "$headers" $func "$@" || die "ERROR: $name not found"
}

require_cpp(){
    name="$1"
    headers="$2"
    classes="$3"
    shift 3
    check_lib_cpp "$headers" "$classes" "$@" || die "ERROR: $name not found"
}

require_pkg_config(){
    pkg="$1"
    check_pkg_config "$@" || die "ERROR: $pkg not found"
    add_cflags    $(get_safe ${pkg}_cflags)
    add_extralibs $(get_safe ${pkg}_libs)
}

hostcc_o(){
    eval printf '%s\\n' $HOSTCC_O
}

check_host_cc(){
    log check_host_cc "$@"
    cat > $TMPC
    log_file $TMPC
    check_cmd $host_cc $host_cflags "$@" $HOSTCC_C $(hostcc_o $TMPO) $TMPC
}

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

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

cp_if_changed(){
    cmp -s "$1" "$2" && echo "$2 is unchanged" && return
    mkdir -p "$(dirname $2)"
    cp -f "$1" "$2"
}

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

COMPONENT_LIST="
    bsfs
    decoders
    demuxers
    encoders
    filters
    hwaccels
    indevs
    muxers
    outdevs
    parsers
    protocols
"

DOCUMENT_LIST="
    doc
    htmlpages
    manpages
    podpages
    txtpages
"

PROGRAM_LIST="
    ffplay
    ffprobe
    ffserver
    ffmpeg
"

CONFIG_LIST="
    $COMPONENT_LIST
    $DOCUMENT_LIST
    $PROGRAM_LIST
    avcodec
    avdevice
    avfilter
    avformat
    avresample
    avisynth
    bzlib
    crystalhd
    dct
    dwt
    dxva2
    fast_unaligned
    fft
    fontconfig
    frei0r
    ftrapv
    gnutls
    gpl
    gray
    hardcoded_tables
    incompatible_fork_abi
    libaacplus
    libass
    libbluray
    libcaca
    libcdio
    libcelt
    libdc1394
    libfaac
    libfdk_aac
    libflite
    libfreetype
    libgsm
    libiec61883
    libilbc
    libmodplug
    libmp3lame
    libnut
    libopencore_amrnb
    libopencore_amrwb
    libopencv
    libopenjpeg
    libopus
    libpulse
    librtmp
    libschroedinger
    libspeex
    libstagefright_h264
    libtheora
    libtwolame
    libutvideo
    libv4l2
    libvo_aacenc
    libvo_amrwbenc
    libvorbis
    libvpx
    libx264
    libxavs
    libxvid
    lsp
    mdct
    memalign_hack
    memory_poisoning
    network
    nonfree
    openal
    openssl
    pic
    postproc
    rdft
    runtime_cpudetect
    safe_bitstream_reader
    shared
    small
    sram
    static
    swresample
    swscale
    swscale_alpha
    thumb
    vaapi
    vda
    vdpau
    version3
    xmm_clobber_test
    x11grab
    zlib
"

THREADS_LIST='
    pthreads
    w32threads
    os2threads
'

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

ARCH_EXT_LIST_X86='
    amd3dnow
    amd3dnowext
    avx
    fma4
    mmx
    mmxext
    sse
    sse2
    sse3
    sse4
    sse42
    ssse3
'

ARCH_EXT_LIST="
    $ARCH_EXT_LIST_X86
    altivec
    armv5te
    armv6
    armv6t2
    armvfp
    neon
    ppc4xx
    vfpv3
    vis
    mipsfpu
    mips32r2
    mipsdspr1
    mipsdspr2
"

HAVE_LIST_CMDLINE='
    inline_asm
    symver
    yasm
'

HAVE_LIST_PUB='
    bigendian
    fast_unaligned
    incompatible_fork_abi
'

HAVE_LIST="
    $ARCH_EXT_LIST
    $(add_suffix _external $ARCH_EXT_LIST)
    $(add_suffix _inline   $ARCH_EXT_LIST)
    $HAVE_LIST_CMDLINE
    $HAVE_LIST_PUB
    $THREADS_LIST
    aligned_malloc
    aligned_stack
    alsa_asoundlib_h
    altivec_h
    arpa_inet_h
    asm_mod_q
    asm_mod_y
    asm_types_h
    attribute_may_alias
    attribute_packed
    broken_snprintf
    cbrtf
    clock_gettime
    closesocket
    cmov
    cpunop
    CryptGenRandom
    dcbzl
    dev_bktr_ioctl_bt848_h
    dev_bktr_ioctl_meteor_h
    dev_ic_bt8xx_h
    dev_video_bktr_ioctl_bt848_h
    dev_video_meteor_ioctl_meteor_h
    direct_h
    dlfcn_h
    dlopen
    dos_paths
    dxva_h
    ebp_available
    ebx_available
    exp2
    exp2f
    fast_64bit
    fast_clz
    fast_cmov
    fcntl
    fork
    getaddrinfo
    gethrtime
    getopt
    GetProcessAffinityMask
    GetProcessMemoryInfo
    GetProcessTimes
    GetSystemTimeAsFileTime
    getrusage
    gettimeofday
    glob
    gnu_as
    ibm_asm
    inet_aton
    io_h
    isatty
    isinf
    isnan
    jack_port_get_latency_range
    kbhit
    ldbrx
    libdc1394_1
    libdc1394_2
    llrint
    llrintf
    local_aligned_16
    local_aligned_8
    localtime_r
    log2
    log2f
    loongson
    lrint
    lrintf
    lzo1x_999_compress
    machine_ioctl_bt848_h
    machine_ioctl_meteor_h
    makeinfo
    malloc_h
    MapViewOfFile
    memalign
    mkstemp
    mm_empty
    mmap
    msvcrt
    nanosleep
    PeekNamedPipe
    perl
    pod2man
    poll_h
    posix_memalign
    pthread_cancel
    rdtsc
    rint
    round
    roundf
    sched_getaffinity
    sdl
    sdl_video_size
    setmode
    setrlimit
    Sleep
    sndio_h
    socklen_t
    soundcard_h
    strerror_r
    struct_addrinfo
    struct_group_source_req
    struct_ip_mreq_source
    struct_ipv6_mreq
    struct_pollfd
    struct_rusage_ru_maxrss
    struct_sctp_event_subscribe
    struct_sockaddr_in6
    struct_sockaddr_sa_len
    struct_sockaddr_storage
    struct_v4l2_frmivalenum_discrete
    symver_asm_label
    symver_gnu_asm
    sysconf
    sysctl
    sys_mman_h
    sys_param_h
    sys_resource_h
    sys_select_h
    sys_soundcard_h
    sys_time_h
    sys_videoio_h
    termios_h
    texi2html
    threads
    trunc
    truncf
    unistd_h
    usleep
    vfp_args
    VirtualAlloc
    windows_h
    winsock2_h
    xform_asm
    xmm_clobbers
"

# options emitted with CONFIG_ prefix but not available on command line
CONFIG_EXTRA="
    aandcttables
    ac3dsp
    avutil
    error_resilience
    gcrypt
    golomb
    gplv3
    h264chroma
    h264dsp
    h264pred
    h264qpel
    huffman
    lgplv3
    lpc
    mpegaudio
    mpegaudiodsp
    mpegvideo
    mpegvideoenc
    nettle
    rangecoder
    rtpdec
    sinewin
    vp3dsp
"

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

PATHS_LIST='
    bindir
    datadir
    incdir
    libdir
    mandir
    prefix
    shlibdir
'

CMDLINE_SET="
    $PATHS_LIST
    ar
    arch
    as
    assert_level
    build_suffix
    cc
    cpu
    cross_prefix
    cxx
    dep_cc
    extra_version
    host_cc
    host_cflags
    host_ld
    host_ldflags
    host_libs
    host_os
    install
    ld
    logfile
    malloc_prefix
    nm
    optflags
    pkg_config
    postproc_version
    progs_suffix
    random_seed
    samples
    strip
    sysinclude
    sysroot
    target_exec
    target_os
    target_path
    toolchain
    valgrind
    yasmexe
"

CMDLINE_APPEND="
    extra_cflags
    extra_cxxflags
"

# code dependency declarations

# architecture extensions

armv5te_deps="arm"
armv6_deps="arm"
armv6t2_deps="arm"
armvfp_deps="arm"
neon_deps="arm"
vfpv3_deps="armvfp"

mipsfpu_deps="mips"
mips32r2_deps="mips"
mipsdspr1_deps="mips"
mipsdspr2_deps="mips"

altivec_deps="ppc"
ppc4xx_deps="ppc"

vis_deps="sparc"

x86_64_suggest="cmov fast_cmov"

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

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

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

aligned_stack_if_any="ppc x86"
fast_64bit_if_any="alpha ia64 mips64 parisc64 ppc64 sparc64 x86_64"
fast_clz_if_any="alpha armv5te avr32 mips ppc x86"
fast_unaligned_if_any="armv6 ppc x86"

inline_asm_deps="!tms470"
need_memalign="altivec neon sse"

symver_if_any="symver_asm_label symver_gnu_asm"

log2_deps="!msvcrt"

# subsystems
dct_select="rdft"
mdct_select="fft"
rdft_select="fft"
mpegaudio_select="mpegaudiodsp"
mpegaudiodsp_select="dct"
mpegvideoenc_select="mpegvideo"

# decoders / encoders / hardware accelerators
aac_decoder_select="mdct sinewin"
aac_encoder_select="mdct sinewin"
aac_latm_decoder_select="aac_decoder aac_latm_parser"
ac3_decoder_select="mdct ac3dsp ac3_parser"
ac3_encoder_select="mdct ac3dsp"
ac3_fixed_encoder_select="mdct ac3dsp"
alac_encoder_select="lpc"
amrnb_decoder_select="lsp"
amrwb_decoder_select="lsp"
amv_encoder_select="aandcttables"
atrac1_decoder_select="mdct sinewin"
atrac3_decoder_select="mdct"
binkaudio_dct_decoder_select="mdct rdft dct sinewin"
binkaudio_rdft_decoder_select="mdct rdft sinewin"
cavs_decoder_select="golomb mpegvideo"
cook_decoder_select="mdct sinewin"
cscd_decoder_suggest="zlib"
dca_decoder_select="mdct"
dirac_decoder_select="dwt golomb"
dnxhd_encoder_select="aandcttables mpegvideoenc"
dxa_decoder_select="zlib"
eac3_decoder_select="ac3_decoder"
eac3_encoder_select="ac3_encoder"
eamad_decoder_select="aandcttables error_resilience mpegvideo"
eatgq_decoder_select="aandcttables"
eatqi_decoder_select="aandcttables error_resilience mpegvideo"
exr_decoder_select="zlib"
ffv1_decoder_select="golomb rangecoder"
ffv1_encoder_select="rangecoder"
ffvhuff_encoder_select="huffman"
flac_decoder_select="golomb"
flac_encoder_select="golomb lpc"
flashsv_decoder_select="zlib"
flashsv_encoder_select="zlib"
flashsv2_encoder_select="zlib"
flashsv2_decoder_select="zlib"
flv_decoder_select="h263_decoder"
flv_encoder_select="h263_encoder"
fraps_decoder_select="huffman"
h261_decoder_select="error_resilience mpegvideo"
h261_encoder_select="aandcttables mpegvideoenc"
h263_decoder_select="error_resilience h263_parser mpegvideo"
h263_encoder_select="aandcttables error_resilience mpegvideoenc"
h263_vaapi_hwaccel_select="vaapi h263_decoder"
h263i_decoder_select="h263_decoder"
h263p_encoder_select="h263_encoder"
h264_crystalhd_decoder_select="crystalhd h264_mp4toannexb_bsf h264_parser"
h264_decoder_select="error_resilience golomb h264chroma h264dsp h264pred h264qpel mpegvideo"
h264_dxva2_hwaccel_deps="dxva2api_h"
h264_dxva2_hwaccel_select="dxva2 h264_decoder"
h264_vaapi_hwaccel_select="vaapi h264_decoder"
h264_vda_decoder_select="vda h264_parser h264_decoder"
h264_vda_hwaccel_deps="VideoDecodeAcceleration_VDADecoder_h pthreads"
h264_vda_hwaccel_select="vda h264_decoder"
h264_vdpau_decoder_select="vdpau h264_decoder"
huffyuv_encoder_select="huffman"
iac_decoder_select="fft mdct sinewin"
imc_decoder_select="fft mdct sinewin"
jpegls_decoder_select="golomb"
jpegls_encoder_select="golomb"
ljpeg_encoder_select="aandcttables mpegvideoenc"
loco_decoder_select="golomb"
mdec_decoder_select="error_resilience mpegvideo"
mjpeg_encoder_select="aandcttables mpegvideoenc"
mlp_decoder_select="mlp_parser"
mp1_decoder_select="mpegaudio"
mp1float_decoder_select="mpegaudio"
mp2_decoder_select="mpegaudio"
mp2float_decoder_select="mpegaudio"
mp3_decoder_select="mpegaudio"
mp3adu_decoder_select="mpegaudio"
mp3adufloat_decoder_select="mpegaudio"
mp3float_decoder_select="mpegaudio"
mp3on4_decoder_select="mpegaudio"
mp3on4float_decoder_select="mpegaudio"
mpc7_decoder_select="mpegaudiodsp"
mpc8_decoder_select="mpegaudiodsp"
mpeg_vdpau_decoder_select="vdpau mpegvideo_decoder"
mpeg_xvmc_decoder_deps="X11_extensions_XvMClib_h"
mpeg_xvmc_decoder_select="mpegvideo_decoder"
mpeg1_vdpau_decoder_select="vdpau mpeg1video_decoder"
mpeg1_vdpau_hwaccel_select="vdpau mpeg1video_decoder"
mpeg1video_decoder_select="error_resilience mpegvideo"
mpeg1video_encoder_select="aandcttables error_resilience mpegvideoenc"
mpeg2_crystalhd_decoder_select="crystalhd"
mpeg2_dxva2_hwaccel_deps="dxva2api_h"
mpeg2_dxva2_hwaccel_select="dxva2 mpeg2video_decoder"
mpeg2_vdpau_hwaccel_select="vdpau mpeg2video_decoder"
mpeg2_vaapi_hwaccel_select="vaapi mpeg2video_decoder"
mpeg2video_decoder_select="error_resilience mpegvideo"
mpeg2video_encoder_select="aandcttables error_resilience mpegvideoenc"
mpeg4_crystalhd_decoder_select="crystalhd"
mpeg4_decoder_select="h263_decoder mpeg4video_parser"
mpeg4_encoder_select="h263_encoder"
mpeg4_vaapi_hwaccel_select="vaapi mpeg4_decoder"
mpeg4_vdpau_decoder_select="vdpau mpeg4_decoder"
msmpeg4_crystalhd_decoder_select="crystalhd"
msmpeg4v1_decoder_select="h263_decoder"
msmpeg4v1_encoder_select="h263_encoder"
msmpeg4v2_decoder_select="h263_decoder"
msmpeg4v2_encoder_select="h263_encoder"
msmpeg4v3_decoder_select="h263_decoder"
msmpeg4v3_encoder_select="h263_encoder"
mss2_decoder_select="vc1_decoder"
nellymoser_decoder_select="mdct sinewin"
nellymoser_encoder_select="mdct sinewin"
png_decoder_select="zlib"
png_encoder_select="zlib"
qcelp_decoder_select="lsp"
qdm2_decoder_select="mdct rdft mpegaudiodsp"
ra_144_encoder_select="lpc"
ralf_decoder_select="golomb"
rv10_decoder_select="h263_decoder"
rv10_encoder_select="h263_encoder"
rv20_decoder_select="h263_decoder"
rv20_encoder_select="h263_encoder"
rv30_decoder_select="error_resilience golomb h264chroma h264pred h264qpel mpegvideo"
rv40_decoder_select="error_resilience golomb h264chroma h264pred h264qpel mpegvideo"
shorten_decoder_select="golomb"
sipr_decoder_select="lsp"
snow_decoder_select="dwt rangecoder"
snow_encoder_select="aandcttables dwt error_resilience mpegvideoenc rangecoder"
sonic_decoder_select="golomb"
sonic_encoder_select="golomb"
sonic_ls_encoder_select="golomb"
svq1_decoder_select="error_resilience mpegvideo"
svq1_encoder_select="aandcttables error_resilience mpegvideoenc"
svq3_decoder_select="error_resilience golomb h264chroma h264dsp h264pred h264qpel mpegvideo"
svq3_decoder_suggest="zlib"
theora_decoder_select="vp3_decoder"
tiff_decoder_suggest="zlib"
tiff_encoder_suggest="zlib"
truehd_decoder_select="mlp_parser"
tscc_decoder_select="zlib"
twinvq_decoder_select="mdct lsp sinewin"
utvideo_encoder_select="huffman"
vc1_crystalhd_decoder_select="crystalhd"
vc1_decoder_select="h263_decoder h264chroma h264qpel"
vc1_dxva2_hwaccel_deps="dxva2api_h"
vc1_dxva2_hwaccel_select="dxva2 vc1_decoder"
vc1_vaapi_hwaccel_select="vaapi vc1_decoder"
vc1_vdpau_decoder_select="vdpau vc1_decoder"
vc1image_decoder_select="vc1_decoder"
vorbis_decoder_select="mdct"
vorbis_encoder_select="mdct"
vp3_decoder_select="vp3dsp"
vp5_decoder_select="vp3dsp"
vp6_decoder_select="huffman vp3dsp"
vp6a_decoder_select="vp6_decoder"
vp6f_decoder_select="vp6_decoder"
vp8_decoder_select="h264pred h264qpel"
wmapro_decoder_select="mdct sinewin"
wmav1_decoder_select="mdct sinewin"
wmav1_encoder_select="mdct sinewin"
wmav2_decoder_select="mdct sinewin"
wmav2_encoder_select="mdct sinewin"
wmavoice_decoder_select="lsp rdft dct mdct sinewin"
wmv1_decoder_select="h263_decoder"
wmv1_encoder_select="h263_encoder"
wmv2_decoder_select="h263_decoder"
wmv2_encoder_select="h263_encoder"
wmv3_decoder_select="vc1_decoder"
wmv3_crystalhd_decoder_select="crystalhd"
wmv3_dxva2_hwaccel_select="vc1_dxva2_hwaccel"
wmv3_vaapi_hwaccel_select="vc1_vaapi_hwaccel"
wmv3_vdpau_decoder_select="vc1_vdpau_decoder"
wmv3image_decoder_select="wmv3_decoder"
zerocodec_decoder_select="zlib"
zlib_decoder_select="zlib"
zlib_encoder_select="zlib"
zmbv_decoder_select="zlib"
zmbv_encoder_select="zlib"

crystalhd_deps="libcrystalhd_libcrystalhd_if_h"
vaapi_deps="va_va_h"
vda_deps="VideoDecodeAcceleration_VDADecoder_h pthreads"
vdpau_deps="vdpau_vdpau_h vdpau_vdpau_x11_h"

# parsers
h264_parser_select="error_resilience golomb h264dsp h264pred mpegvideo"
mpeg4video_parser_select="error_resilience mpegvideo"
mpegvideo_parser_select="error_resilience mpegvideo"
vc1_parser_select="error_resilience mpegvideo"

# external libraries
libaacplus_encoder_deps="libaacplus"
libcelt_decoder_deps="libcelt"
libfaac_encoder_deps="libfaac"
libfdk_aac_encoder_deps="libfdk_aac"
libgsm_decoder_deps="libgsm"
libgsm_encoder_deps="libgsm"
libgsm_ms_decoder_deps="libgsm"
libgsm_ms_encoder_deps="libgsm"
libilbc_decoder_deps="libilbc"
libilbc_encoder_deps="libilbc"
libmodplug_demuxer_deps="libmodplug"
libmp3lame_encoder_deps="libmp3lame"
libopencore_amrnb_decoder_deps="libopencore_amrnb"
libopencore_amrnb_encoder_deps="libopencore_amrnb"
libopencore_amrwb_decoder_deps="libopencore_amrwb"
libopenjpeg_decoder_deps="libopenjpeg"
libopenjpeg_encoder_deps="libopenjpeg"
libopus_decoder_deps="libopus"
libopus_encoder_deps="libopus"
libschroedinger_decoder_deps="libschroedinger"
libschroedinger_encoder_deps="libschroedinger"
libspeex_decoder_deps="libspeex"
libspeex_encoder_deps="libspeex"
libstagefright_h264_decoder_deps="libstagefright_h264"
libtheora_encoder_deps="libtheora"
libtwolame_encoder_deps="libtwolame"
libvo_aacenc_encoder_deps="libvo_aacenc"
libvo_amrwbenc_encoder_deps="libvo_amrwbenc"
libvorbis_decoder_deps="libvorbis"
libvorbis_encoder_deps="libvorbis"
libvpx_decoder_deps="libvpx"
libvpx_encoder_deps="libvpx"
libx264_encoder_deps="libx264"
libx264rgb_encoder_deps="libx264"
libxavs_encoder_deps="libxavs"
libxvid_encoder_deps="libxvid"
libutvideo_decoder_deps="libutvideo"
libutvideo_encoder_deps="libutvideo"

# demuxers / muxers
ac3_demuxer_select="ac3_parser"
asf_stream_muxer_select="asf_muxer"
avisynth_demuxer_deps="avisynth"
dirac_demuxer_select="dirac_parser"
dts_demuxer_select="dca_parser"
dtshd_demuxer_select="dca_parser"
eac3_demuxer_select="ac3_parser"
f4v_muxer_select="mov_muxer"
flac_demuxer_select="flac_parser"
ipod_muxer_select="mov_muxer"
libnut_demuxer_deps="libnut"
libnut_muxer_deps="libnut"
matroska_audio_muxer_select="matroska_muxer"
matroska_demuxer_suggest="zlib bzlib"
mov_demuxer_suggest="zlib"
mp3_demuxer_select="mpegaudio_parser"
mp4_muxer_select="mov_muxer"
mpegts_muxer_select="adts_muxer latm_muxer mpegvideo"
mpegtsraw_demuxer_select="mpegts_demuxer"
mxf_d10_muxer_select="mxf_muxer"
ogg_demuxer_select="golomb"
psp_muxer_select="mov_muxer"
rtp_demuxer_select="sdp_demuxer"
rtp_muxer_select="mpegvideo"
rtpdec_select="asf_demuxer rm_demuxer rtp_protocol mpegts_demuxer mov_demuxer"
rtsp_demuxer_select="http_protocol rtpdec"
rtsp_muxer_select="rtp_muxer http_protocol rtp_protocol"
sap_demuxer_select="sdp_demuxer"
sap_muxer_select="rtp_muxer rtp_protocol"
sdp_demuxer_select="rtpdec"
smoothstreaming_muxer_select="ismv_muxer"
spdif_muxer_select="aac_parser"
tak_demuxer_select="tak_parser"
tg2_muxer_select="mov_muxer"
tgp_muxer_select="mov_muxer"
w64_demuxer_deps="wav_demuxer"

# indevs / outdevs
alsa_indev_deps="alsa_asoundlib_h snd_pcm_htimestamp"
alsa_outdev_deps="alsa_asoundlib_h"
bktr_indev_deps_any="dev_bktr_ioctl_bt848_h machine_ioctl_bt848_h dev_video_bktr_ioctl_bt848_h dev_ic_bt8xx_h"
caca_outdev_deps="libcaca"
dshow_indev_deps="IBaseFilter"
dshow_indev_extralibs="-lpsapi -lole32 -lstrmiids -luuid"
dv1394_indev_deps="dv1394 dv_demuxer"
fbdev_indev_deps="linux_fb_h"
iec61883_indev_deps="libiec61883"
jack_indev_deps="jack_jack_h sem_timedwait"
lavfi_indev_deps="avfilter"
libcdio_indev_deps="libcdio"
libdc1394_indev_deps="libdc1394"
libv4l2_indev_deps="libv4l2"
openal_indev_deps="openal"
oss_indev_deps_any="soundcard_h sys_soundcard_h"
oss_outdev_deps_any="soundcard_h sys_soundcard_h"
pulse_indev_deps="libpulse"
sdl_outdev_deps="sdl"
sndio_indev_deps="sndio_h"
sndio_outdev_deps="sndio_h"
v4l_indev_deps="linux_videodev_h"
v4l2_indev_deps_any="linux_videodev2_h sys_videoio_h"
vfwcap_indev_deps="capCreateCaptureWindow vfwcap_defines"
vfwcap_indev_extralibs="-lavicap32"
x11grab_indev_deps="x11grab"

# protocols
bluray_protocol_deps="libbluray"
ffrtmpcrypt_protocol_deps="!librtmp_protocol"
ffrtmpcrypt_protocol_deps_any="gcrypt nettle openssl"
ffrtmpcrypt_protocol_select="tcp_protocol"
ffrtmphttp_protocol_deps="!librtmp_protocol"
ffrtmphttp_protocol_select="http_protocol"
gopher_protocol_deps="network"
httpproxy_protocol_deps="network"
httpproxy_protocol_select="tcp_protocol"
http_protocol_deps="network"
http_protocol_select="tcp_protocol"
https_protocol_select="tls_protocol"
librtmp_protocol_deps="librtmp"
librtmpe_protocol_deps="librtmp"
librtmps_protocol_deps="librtmp"
librtmpt_protocol_deps="librtmp"
librtmpte_protocol_deps="librtmp"
mmsh_protocol_select="http_protocol"
mmst_protocol_deps="network"
rtmp_protocol_deps="!librtmp_protocol"
rtmp_protocol_select="tcp_protocol"
rtmpe_protocol_select="ffrtmpcrypt_protocol"
rtmps_protocol_deps="!librtmp_protocol"
rtmps_protocol_select="tls_protocol"
rtmpt_protocol_select="ffrtmphttp_protocol"
rtmpte_protocol_select="ffrtmpcrypt_protocol ffrtmphttp_protocol"
rtmpts_protocol_select="ffrtmphttp_protocol https_protocol"
rtp_protocol_select="udp_protocol"
sctp_protocol_deps="network struct_sctp_event_subscribe"
tcp_protocol_deps="network"
tls_protocol_deps_any="openssl gnutls"
tls_protocol_select="tcp_protocol"
udp_protocol_deps="network"

# filters
aconvert_filter_deps="swresample"
amovie_filter_deps="avcodec avformat"
aresample_filter_deps="swresample"
ass_filter_deps="libass"
asyncts_filter_deps="avresample"
atempo_filter_deps="avcodec rdft"
blackframe_filter_deps="gpl"
boxblur_filter_deps="gpl"
colormatrix_filter_deps="gpl"
cropdetect_filter_deps="gpl"
decimate_filter_deps="gpl avcodec"
delogo_filter_deps="gpl"
deshake_filter_deps="avcodec"
drawtext_filter_deps="libfreetype"
ebur128_filter_deps="gpl"
flite_filter_deps="libflite"
frei0r_filter_deps="frei0r dlopen"
frei0r_filter_extralibs='$ldl'
frei0r_src_filter_deps="frei0r dlopen"
frei0r_src_filter_extralibs='$ldl'
hqdn3d_filter_deps="gpl"
movie_filter_deps="avcodec avformat"
mp_filter_deps="gpl avcodec swscale postproc inline_asm"
mptestsrc_filter_deps="gpl"
negate_filter_deps="lut_filter"
resample_filter_deps="avresample"
ocv_filter_deps="libopencv"
pan_filter_deps="swresample"
removelogo_filter_deps="avcodec avformat swscale"
scale_filter_deps="swscale"
smartblur_filter_deps="gpl swscale"
showspectrum_filter_deps="avcodec rdft"
super2xsai_filter_deps="gpl"
tinterlace_filter_deps="gpl"
yadif_filter_deps="gpl"
pixfmts_super2xsai_test_deps="super2xsai_filter"
tinterlace_merge_test_deps="tinterlace_filter"
tinterlace_pad_test_deps="tinterlace_filter"

# libraries
avdevice_deps="avcodec avformat"
avformat_deps="avcodec"
postproc_deps="gpl"

# programs
ffmpeg_deps="avcodec avfilter avformat swscale swresample"
ffmpeg_select="ffbuffersink_filter format_filter aformat_filter
               setpts_filter null_filter anull_filter ffabuffersink_filter"
ffplay_deps="avcodec avformat swscale swresample sdl"
ffplay_select="ffbuffersink_filter rdft crop_filter"
ffprobe_deps="avcodec avformat"
ffserver_deps="avformat ffm_muxer fork rtp_protocol rtsp_demuxer"
ffserver_extralibs='$ldl'

# documentation
podpages_deps="perl"
manpages_deps="perl pod2man"
htmlpages_deps="texi2html"
txtpages_deps="makeinfo"
doc_deps_any="manpages htmlpages podpages txtpages"

# tests
colormatrix1_test_deps="colormatrix_filter"
colormatrix2_test_deps="colormatrix_filter"
mpg_test_deps="mpeg1system_muxer mpegps_demuxer"
png_test_deps="zlib"
pp_test_deps="mp_filter"
pp2_test_deps="mp_filter"
pp3_test_deps="mp_filter"
pp4_test_deps="mp_filter"
pp5_test_deps="mp_filter"
pp6_test_deps="mp_filter"
seek_flashsv_flv_test_deps="zlib"
seek_lavf_mxf_d10_test_deps="mxf_d10_test"

test_deps(){
    suf1=$1
    suf2=$2
    shift 2
    for v; do
        dep=${v%=*}
        tests=${v#*=}
        for name in ${tests}; do
            append ${name}_test_deps ${dep}$suf1 ${dep}$suf2
        done
    done
}

test_deps _muxer _demuxer                                               \
    aiff                                                                \
    pcm_alaw=alaw                                                       \
    asf                                                                 \
    au                                                                  \
    avi                                                                 \
    dv=dv_fmt                                                           \
    ffm                                                                 \
    flv=flv_fmt                                                         \
    gxf                                                                 \
    matroska=mkv                                                        \
    mmf                                                                 \
    mov="mov ismv"                                                      \
    pcm_mulaw=mulaw                                                     \
    mxf="mxf mxf_d10"                                                   \
    nut                                                                 \
    ogg="ogg ogg_vp3"                                                   \
    rawvideo=pixfmt                                                     \
    rm                                                                  \
    swf                                                                 \
    mpegts=ts                                                           \
    voc                                                                 \
    wav                                                                 \
    yuv4mpegpipe=yuv4mpeg                                               \

# default parameters

logfile="config.log"

# installation paths
prefix_default="/usr/local"
bindir_default='${prefix}/bin'
datadir_default='${prefix}/share/ffmpeg'
incdir_default='${prefix}/include'
libdir_default='${prefix}/lib'
mandir_default='${prefix}/share/man'
shlibdir_default="$libdir_default"
postproc_version_default="current"

# toolchain
ar_default="ar"
cc_default="gcc"
cxx_default="g++"
host_cc_default="gcc"
install="install"
ln_s="ln -sf"
nm_default="nm -g"
objformat="elf"
pkg_config_default=pkg-config
ranlib="ranlib"
strip_default="strip"
yasmexe_default="yasm"

nogas=":"

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

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

# alternative libpostproc version
ALT_PP_VER_MAJOR=51
ALT_PP_VER_MINOR=2
ALT_PP_VER_MICRO=101
ALT_PP_VER=$ALT_PP_VER_MAJOR.$ALT_PP_VER_MINOR.$ALT_PP_VER_MICRO

# configurable options
enable $PROGRAM_LIST
enable $DOCUMENT_LIST

enable avcodec
enable avdevice
enable avfilter
enable avformat
enable avutil
enable postproc
enable stripping
enable swresample
enable swscale

enable asm
enable debug
enable doc
enable network
enable optimizations
enable runtime_cpudetect
enable safe_bitstream_reader
enable static
enable swscale_alpha

# build settings
SHFLAGS='-shared -Wl,-soname,$$(@F)'
FFSERVERLDFLAGS=-Wl,-E
LIBPREF="lib"
LIBSUF=".a"
FULLNAME='$(NAME)$(BUILDSUF)'
LIBNAME='$(LIBPREF)$(FULLNAME)$(LIBSUF)'
SLIBPREF="lib"
SLIBSUF=".so"
SLIBNAME='$(SLIBPREF)$(FULLNAME)$(SLIBSUF)'
SLIBNAME_WITH_VERSION='$(SLIBNAME).$(LIBVERSION)'
SLIBNAME_WITH_MAJOR='$(SLIBNAME).$(LIBMAJOR)'
LIB_INSTALL_EXTRA_CMD='$$(RANLIB) "$(LIBDIR)/$(LIBNAME)"'
SLIB_INSTALL_NAME='$(SLIBNAME_WITH_VERSION)'
SLIB_INSTALL_LINKS='$(SLIBNAME_WITH_MAJOR) $(SLIBNAME)'

asflags_filter=echo
cflags_filter=echo
ldflags_filter=echo

AS_C='-c'
AS_O='-o $@'
CC_C='-c'
CC_E='-E -o $@'
CC_O='-o $@'
CXX_C='-c'
CXX_O='-o $@'
LD_O='-o $@'
LD_LIB='-l%'
LD_PATH='-L'
HOSTCC_C='-c'
HOSTCC_O='-o $@'
HOSTLD_O='-o $@'

host_cflags='-D_ISOC99_SOURCE -D_XOPEN_SOURCE=600 -O3 -g'
host_libs='-lm'
host_cflags_filter=echo
host_ldflags_filter=echo

target_path='$(CURDIR)'

# since the object filename is not given with the -MM flag, the compiler
# is only able to print the basename, and we must add the path ourselves
DEPCMD='$(DEP$(1)) $(DEP$(1)FLAGS) $($(1)DEP_FLAGS) $< | sed -e "/^\#.*/d" -e "s,^[[:space:]]*$(*F)\\.o,$(@D)/$(*F).o," > $(@:.o=.d)'
DEPFLAGS='-MM'

# find source path
if test -f configure; then
    source_path=.
else
    source_path=$(cd $(dirname "$0"); pwd)
    echo "$source_path" | grep -q '[[:blank:]]' &&
        die "Out of tree builds are impossible with whitespace in source path."
    test -e "$source_path/config.h" &&
        die "Out of tree builds are impossible with config.h in source dir."
fi

for v in "$@"; do
    r=${v#*=}
    l=${v%"$r"}
    r=$(sh_quote "$r")
    FFMPEG_CONFIGURATION="${FFMPEG_CONFIGURATION# } ${l}${r}"
done

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

ENCODER_LIST=$(find_things  encoder  ENC      libavcodec/allcodecs.c)
DECODER_LIST=$(find_things  decoder  DEC      libavcodec/allcodecs.c)
HWACCEL_LIST=$(find_things  hwaccel  HWACCEL  libavcodec/allcodecs.c)
PARSER_LIST=$(find_things   parser   PARSER   libavcodec/allcodecs.c)
BSF_LIST=$(find_things      bsf      BSF      libavcodec/allcodecs.c)
MUXER_LIST=$(find_things    muxer    _MUX     libavformat/allformats.c)
DEMUXER_LIST=$(find_things  demuxer  DEMUX    libavformat/allformats.c)
OUTDEV_LIST=$(find_things   outdev   OUTDEV   libavdevice/alldevices.c)
INDEV_LIST=$(find_things    indev    _IN      libavdevice/alldevices.c)
PROTOCOL_LIST=$(find_things protocol PROTOCOL libavformat/allformats.c)
FILTER_LIST=$(find_things   filter   FILTER   libavfilter/allfilters.c)

ALL_COMPONENTS="
    $BSF_LIST
    $DECODER_LIST
    $DEMUXER_LIST
    $ENCODER_LIST
    $FILTER_LIST
    $HWACCEL_LIST
    $INDEV_LIST
    $MUXER_LIST
    $OUTDEV_LIST
    $PARSER_LIST
    $PROTOCOL_LIST
"

find_tests(){
    map "echo ${2}\${v}_test" $(ls "$source_path"/tests/ref/$1 | grep -v '[^-a-z0-9_]')
}

LAVF_FATE_TESTS=$(find_tests lavf-fate)
LAVF_TESTS=$(find_tests lavf)
LAVFI_TESTS=$(find_tests lavfi)
SEEK_TESTS=$(find_tests seek seek_)

ALL_TESTS="$LAVF_FATE_TESTS $LAVF_TESTS $LAVFI_TESTS $SEEK_TESTS"

for n in $COMPONENT_LIST; do
    v=$(toupper ${n%s})_LIST
    eval enable \$$v
    eval ${n}_if_any="\$$v"
done

enable $ARCH_EXT_LIST $ALL_TESTS

die_unknown(){
    echo "Unknown option \"$1\"."
    echo "See $0 --help for available options."
    exit 1
}

show_list() {
    suffix=_$1
    shift
    echo $* | sed s/$suffix//g | tr ' ' '\n' | sort | pr -3 -t
    exit 0
}

rand_list(){
    IFS=', '
    set -- $*
    unset IFS
    for thing; do
        comp=${thing%:*}
        prob=${thing#$comp}
        prob=${prob#:}
        is_in ${comp} $COMPONENT_LIST && eval comp=\$$(toupper ${comp%s})_LIST
        echo "prob ${prob:-0.5}"
        printf '%s\n' $comp
    done
}

do_random(){
    action=$1
    shift
    random_seed=$(awk "BEGIN { srand($random_seed); print srand() }")
    $action $(rand_list "$@" | awk "BEGIN { srand($random_seed) } \$1 == \"prob\" { prob = \$2; next } rand() < prob { print }")
}

for opt do
    optval="${opt#*=}"
    case "$opt" in
    --extra-ldflags=*) add_ldflags $optval
    ;;
    --extra-libs=*) add_extralibs $optval
    ;;
    --disable-devices) disable $INDEV_LIST $OUTDEV_LIST
    ;;
    --enable-debug=*) debuglevel="$optval"
    ;;
    --disable-everything)
    map 'eval unset \${$(toupper ${v%s})_LIST}' $COMPONENT_LIST
    ;;
    --enable-random|--disable-random)
    action=${opt%%-random}
    do_random ${action#--} $COMPONENT_LIST
    ;;
    --enable-random=*|--disable-random=*)
    action=${opt%%-random=*}
    do_random ${action#--} $optval
    ;;
    --enable-*=*|--disable-*=*)
    eval $(echo "${opt%%=*}" | sed 's/--/action=/;s/-/ thing=/')
    is_in "${thing}s" $COMPONENT_LIST || die_unknown "$opt"
    eval list=\$$(toupper $thing)_LIST
    name=$(echo "${optval}" | sed "s/,/_${thing}|/g")_${thing}
    $action $(filter "$name" $list)
    ;;
    --enable-?*|--disable-?*)
    eval $(echo "$opt" | sed 's/--/action=/;s/-/ option=/;s/-/_/g')
    if is_in $option $COMPONENT_LIST; then
        test $action = disable && action=unset
        eval $action \$$(toupper ${option%s})_LIST
    elif is_in $option $CMDLINE_SELECT; then
        $action $option
    else
        die_unknown $opt
    fi
    ;;
    --list-*)
        NAME="${opt#--list-}"
        is_in $NAME $COMPONENT_LIST || die_unknown $opt
        NAME=${NAME%s}
        eval show_list $NAME \$$(toupper $NAME)_LIST
    ;;
    --help|-h) show_help
    ;;
    *)
    optname="${opt%%=*}"
    optname="${optname#--}"
    optname=$(echo "$optname" | sed 's/-/_/g')
    if is_in $optname $CMDLINE_SET; then
        eval $optname='$optval'
    elif is_in $optname $CMDLINE_APPEND; then
        append $optname "$optval"
    else
         die_unknown $opt
    fi
    ;;
    esac
done

disabled logging && logfile=/dev/null

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

test -n "$cross_prefix" && enable cross_compile

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

set_default arch target_os postproc_version

# Check if we should build alternative libpostproc version instead of current
if   test "$postproc_version" = $ALT_PP_VER; then
  LIBPOSTPROC_VERSION=$ALT_PP_VER
  LIBPOSTPROC_VERSION_MAJOR=$ALT_PP_VER_MAJOR
  LIBPOSTPROC_VERSION_MINOR=$ALT_PP_VER_MINOR
  LIBPOSTPROC_VERSION_MICRO=$ALT_PP_VER_MICRO
elif test "$postproc_version" != current; then
  die "Invalid argument to --postproc-version. See --help output."
fi

ar_default="${cross_prefix}${ar_default}"
cc_default="${cross_prefix}${cc_default}"
cxx_default="${cross_prefix}${cxx_default}"
nm_default="${cross_prefix}${nm_default}"
pkg_config_default="${cross_prefix}${pkg_config_default}"
ranlib="${cross_prefix}${ranlib}"
strip_default="${cross_prefix}${strip_default}"

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

case "$toolchain" in
    msvc)
        cc_default="c99wrap cl"
        ld_default="c99wrap link"
        nm_default="dumpbin -symbols"
        ar_default="lib"
    ;;
    ?*)
        die "Unknown toolchain $toolchain"
    ;;
esac

set_default cc cxx pkg_config strip sysinclude yasmexe
enabled cross_compile || host_cc_default=$cc
set_default host_cc

if ! $pkg_config --version >/dev/null 2>&1; then
    warn "$pkg_config not found, library detection may fail."
    pkg_config=false
fi

exesuf() {
    case $1 in
        mingw32*|cygwin*|*-dos|freedos|opendos|os/2*|symbian) echo .exe ;;
    esac
}

EXESUF=$(exesuf $target_os)
HOSTEXESUF=$(exesuf $host_os)

# set temporary file name
: ${TMPDIR:=$TEMPDIR}
: ${TMPDIR:=$TMP}
: ${TMPDIR:=/tmp}

if ! check_cmd mktemp -u XXXXXX; then
    # simple replacement for missing mktemp
    # NOT SAFE FOR GENERAL USE
    mktemp(){
        echo "${2%%XXX*}.${HOSTNAME}.${UID}.$$"
    }
fi

tmpfile(){
    tmp=$(mktemp -u "${TMPDIR}/ffconf.XXXXXXXX")$2 &&
        (set -C; exec > $tmp) 2>/dev/null ||
        die "Unable to create temporary file in $TMPDIR."
    append TMPFILES $tmp
    eval $1=$tmp
}

trap 'rm -f -- $TMPFILES' EXIT

tmpfile TMPASM .asm
tmpfile TMPC   .c
tmpfile TMPCPP .cpp
tmpfile TMPE   $EXESUF
tmpfile TMPH   .h
tmpfile TMPO   .o
tmpfile TMPS   .S
tmpfile TMPSH  .sh
tmpfile TMPV   .ver

unset -f mktemp

chmod +x $TMPE

# make sure we can execute files in $TMPDIR
cat > $TMPSH 2>> $logfile <<EOF
#! /bin/sh
EOF
chmod +x $TMPSH >> $logfile 2>&1
if ! $TMPSH >> $logfile 2>&1; then
    cat <<EOF
Unable to create and execute files in $TMPDIR.  Set the TMPDIR environment
variable to another directory and make sure that it is not mounted noexec.
EOF
    die "Sanity test failed."
fi

msvc_flags(){
    for flag; do
        case $flag in
            -fomit-frame-pointer) echo -Oy ;;
            -g)                   echo -Z7 ;;
            -Wall)                echo -W4 -wd4244 -wd4127 -wd4018 -wd4389 \
                                       -wd4146 -wd4057 -wd4204 -wd4706 -wd4305 \
                                       -wd4152 -wd4324 -we4013 -wd4100 -wd4214 \
                                       -wd4996 -wd4554 ;;
            -std=c99)             ;;
            -fno-math-errno)      ;;
            -fno-common)          ;;
            -fno-signed-zeros)    ;;
            -lz)                  echo zlib.lib ;;
            -lavifil32)           echo vfw32.lib ;;
            -lavicap32)           echo vfw32.lib user32.lib ;;
            -l*)                  echo ${flag#-l}.lib ;;
            *)                    echo $flag ;;
        esac
    done
}

pgi_flags(){
    for flag; do
        case $flag in
            -flto)                echo -Mipa=fast,libopt,libinline,vestigial ;;
            -fomit-frame-pointer) echo -Mnoframe ;;
            -g)                   echo -gopt ;;
            *)                    echo $flag ;;
        esac
    done
}

suncc_flags(){
    for flag; do
        case $flag in
            -march=*|-mcpu=*)
                case "${flag#*=}" in
                    native)                   echo -xtarget=native       ;;
                    v9|niagara)               echo -xarch=sparc          ;;
                    ultrasparc)               echo -xarch=sparcvis       ;;
                    ultrasparc3|niagara2)     echo -xarch=sparcvis2      ;;
                    i586|pentium)             echo -xchip=pentium        ;;
                    i686|pentiumpro|pentium2) echo -xtarget=pentium_pro  ;;
                    pentium3*|c3-2)           echo -xtarget=pentium3     ;;
                    pentium-m)          echo -xarch=sse2 -xchip=pentium3 ;;
                    pentium4*)          echo -xtarget=pentium4           ;;
                    prescott|nocona)    echo -xarch=sse3 -xchip=pentium4 ;;
                    *-sse3)             echo -xarch=sse3                 ;;
                    core2)              echo -xarch=ssse3 -xchip=core2   ;;
                    amdfam10|barcelona|bdver*) echo -xarch=sse4_1        ;;
                    athlon-4|athlon-[mx]p)    echo -xarch=ssea           ;;
                    k8|opteron|athlon64|athlon-fx)
                                              echo -xarch=sse2a          ;;
                    athlon*)                  echo -xarch=pentium_proa   ;;
                esac
                ;;
            -std=c99)             echo -xc99              ;;
            -fomit-frame-pointer) echo -xregs=frameptr    ;;
            -fPIC)                echo -KPIC -xcode=pic32 ;;
            -W*,*)                echo $flag              ;;
            -f*-*|-W*)                                    ;;
            *)                    echo $flag              ;;
        esac
    done
}

tms470_flags(){
    for flag; do
        case $flag in
            -march=*|-mcpu=*)
                case "${flag#*=}" in
                    armv7-a|cortex-a*)      echo -mv=7a8 ;;
                    armv7-r|cortex-r*)      echo -mv=7r4 ;;
                    armv7-m|cortex-m*)      echo -mv=7m3 ;;
                    armv6*|arm11*)          echo -mv=6   ;;
                    armv5*e|arm[79]*e*|arm9[24]6*|arm96*|arm102[26])
                                            echo -mv=5e  ;;
                    armv4*|arm7*|arm9[24]*) echo -mv=4   ;;
                esac
                ;;
            -mfpu=neon)     echo --float_support=vfpv3 --neon ;;
            -mfpu=vfp)      echo --float_support=vfpv2        ;;
            -mfpu=vfpv3)    echo --float_support=vfpv3        ;;
            -mfpu=vfpv3-d16) echo --float_support=vfpv3d16    ;;
            -msoft-float)   echo --float_support=vfplib       ;;
            -O[0-3]|-mf=*)  echo $flag                        ;;
            -g)             echo -g -mn                       ;;
            -pds=*)         echo $flag                        ;;
            -D*|-I*)        echo $flag                        ;;
            --gcc|--abi=*)  echo $flag                        ;;
            -me)            echo $flag                        ;;
        esac
    done
}

probe_cc(){
    pfx=$1
    _cc=$2

    unset _type _ident _cc_c _cc_e _cc_o _flags _cflags
    unset _ld_o _ldflags _ld_lib _ld_path
    unset _depflags _DEPCMD _DEPFLAGS
    _flags_filter=echo

    if $_cc -v 2>&1 | grep -q '^gcc.*LLVM'; then
        _type=llvm_gcc
        gcc_extra_ver=$(expr "$($_cc --version | head -n1)" : '.*\((.*)\)')
        _ident="llvm-gcc $($_cc -dumpversion) $gcc_extra_ver"
        _depflags='-MMD -MF $(@:.o=.d) -MT $@'
        _cflags_speed='-O3'
        _cflags_size='-Os'
    elif $_cc -v 2>&1 | grep -qi ^gcc; then
        _type=gcc
        gcc_version=$($_cc --version | head -n1)
        gcc_basever=$($_cc -dumpversion)
        gcc_pkg_ver=$(expr "$gcc_version" : '[^ ]* \(([^)]*)\)')
        gcc_ext_ver=$(expr "$gcc_version" : ".*$gcc_pkg_ver $gcc_basever \\(.*\\)")
        _ident=$(cleanws "gcc $gcc_basever $gcc_pkg_ver $gcc_ext_ver")
        if ! $_cc -dumpversion | grep -q '^2\.'; then
            _depflags='-MMD -MF $(@:.o=.d) -MT $@'
        fi
        _cflags_speed='-O3'
        _cflags_size='-Os'
    elif $_cc --version 2>/dev/null | grep -q Intel; then
        _type=icc
        _ident=$($_cc --version | head -n1)
        _depflags='-MMD'
        _cflags_speed='-O3'
        _cflags_size='-Os'
        _cflags_noopt='-O1'
    elif $_cc -v 2>&1 | grep -q xlc; then
        _type=xlc
        _ident=$($_cc -qversion 2>/dev/null | head -n1)
        _cflags_speed='-O5'
        _cflags_size='-O5 -qcompact'
    elif $_cc -V 2>/dev/null | grep -q Compaq; then
        _type=ccc
        _ident=$($_cc -V | head -n1 | cut -d' ' -f1-3)
        _DEPFLAGS='-M'
        debuglevel=3
        _ldflags='-Wl,-z,now' # calls to libots crash without this
        _cflags_speed='-fast'
        _cflags_size='-O1'
    elif $_cc --vsn 2>/dev/null | grep -q "ARM C/C++ Compiler"; then
        test -d "$sysroot" || die "No valid sysroot specified."
        _type=armcc
        _ident=$($_cc --vsn | head -n1)
        armcc_conf="$PWD/armcc.conf"
        $_cc --arm_linux_configure                 \
             --arm_linux_config_file="$armcc_conf" \
             --configure_sysroot="$sysroot"        \
             --configure_cpp_headers="$sysinclude" >>$logfile 2>&1 ||
             die "Error creating armcc configuration file."
        $_cc --vsn | grep -q RVCT && armcc_opt=rvct || armcc_opt=armcc
        _flags="--arm_linux_config_file=$armcc_conf --translate_gcc"
        as_default="${cross_prefix}gcc"
        _depflags='-MMD'
        _cflags_speed='-O3'
        _cflags_size='-Os'
    elif $_cc -version 2>/dev/null | grep -Eq 'TMS470|TI ARM'; then
        _type=tms470
        _ident=$($_cc -version | head -n1 | tr -s ' ')
        _flags='--gcc --abi=eabi -me'
        _cflags='-D__gnuc_va_list=va_list -D__USER_LABEL_PREFIX__='
        _cc_e='-ppl -fe=$@'
        _cc_o='-fe=$@'
        as_default="${cross_prefix}gcc"
        ld_default="${cross_prefix}gcc"
        _depflags='-ppa -ppd=$(@:.o=.d)'
        _cflags_speed='-O3 -mf=5'
        _cflags_size='-O3 -mf=2'
        _flags_filter=tms470_flags
    elif $_cc -v 2>&1 | grep -q clang; then
        _type=clang
        _ident=$($_cc --version | head -n1)
        _depflags='-MMD'
        _cflags_speed='-O3'
        _cflags_size='-Os'
    elif $_cc -V 2>&1 | grep -q Sun; then
        _type=suncc
        _ident=$($_cc -V 2>&1 | head -n1 | cut -d' ' -f 2-)
        _DEPCMD='$(DEP$(1)) $(DEP$(1)FLAGS) $($(1)DEP_FLAGS) $< | sed -e "1s,^.*: ,$@: ," -e "\$$!s,\$$, \\\," -e "1!s,^.*: , ," > $(@:.o=.d)'
        _DEPFLAGS='-xM1 -xc99'
        _ldflags='-std=c99'
        _cflags_speed='-O5'
        _cflags_size='-O5 -xspace'
        _flags_filter=suncc_flags
    elif $_cc -v 2>&1 | grep -q 'PathScale\|Path64'; then
        _type=pathscale
        _ident=$($_cc -v 2>&1 | head -n1 | tr -d :)
        _depflags='-MMD -MF $(@:.o=.d) -MT $@'
        _cflags_speed='-O2'
        _cflags_size='-Os'
        _flags_filter='filter_out -Wdisabled-optimization'
    elif $_cc -v 2>&1 | grep -q Open64; then
        _type=open64
        _ident=$($_cc -v 2>&1 | head -n1 | tr -d :)
        _depflags='-MMD -MF $(@:.o=.d) -MT $@'
        _cflags_speed='-O2'
        _cflags_size='-Os'
        _flags_filter='filter_out -Wdisabled-optimization|-Wtype-limits|-fno-signed-zeros'
    elif $_cc -V 2>&1 | grep -q Portland; then
        _type=pgi
        _ident="PGI $($_cc -V 2>&1 | awk '/^pgcc/ { print $2; exit }')"
        opt_common='-alias=ansi -Mdse -Mlre -Mpre'
        _cflags_speed="-O3 -Mautoinline -Munroll=c:4 $opt_common"
        _cflags_size="-O2 -Munroll=c:1 $opt_common"
        _cflags_noopt="-O1"
        _flags_filter=pgi_flags
    elif $_cc 2>&1 | grep -q Microsoft; then
        _type=msvc
        _ident=$($cc 2>&1 | head -n1)
        _DEPCMD='$(DEP$(1)) $(DEP$(1)FLAGS) $($(1)DEP_FLAGS) $< 2>&1 | awk '\''/including/ { sub(/^.*file: */, ""); gsub(/\\/, "/"); if (!match($$0, / /)) print "$@:", $$0 }'\'' > $(@:.o=.d)'
        _DEPFLAGS='$(CPPFLAGS) $(CFLAGS) -showIncludes -Zs'
        _cflags_speed="-O2"
        _cflags_size="-O1"
        # Nonstandard output options, to avoid msys path conversion issues, relies on wrapper to remap it
        if $_cc 2>&1 | grep -q Linker; then
            _ld_o='-out $@'
        else
            _ld_o='-Fe$@'
        fi
        _cc_o='-Fo $@'
        _cc_e='-P -Fi $@'
        _flags_filter=msvc_flags
        _ld_lib='lib%.a'
        _ld_path='-libpath:'
        _flags='-nologo'
        _cflags='-D_USE_MATH_DEFINES -Dinline=__inline -FIstdlib.h -Dstrtoll=_strtoi64'
        if [ $pfx = hostcc ]; then
            append _cflags -Dsnprintf=_snprintf
        fi
        disable stripping
    fi

    eval ${pfx}_type=\$_type
    eval ${pfx}_ident=\$_ident
}

set_ccvars(){
    eval ${1}_C=\${_cc_c-\${${1}_C}}
    eval ${1}_E=\${_cc_e-\${${1}_E}}
    eval ${1}_O=\${_cc_o-\${${1}_O}}

    if [ -n "$_depflags" ]; then
        eval ${1}_DEPFLAGS=\$_depflags
    else
        eval ${1}DEP=\${_DEPCMD:-\$DEPCMD}
        eval ${1}DEP_FLAGS=\${_DEPFLAGS:-\$DEPFLAGS}
        eval DEP${1}FLAGS=\$_flags
    fi
}

probe_cc cc "$cc"
cflags_filter=$_flags_filter
cflags_speed=$_cflags_speed
cflags_size=$_cflags_size
cflags_noopt=$_cflags_noopt
add_cflags $_flags $_cflags
cc_ldflags=$_ldflags
set_ccvars CC

probe_cc hostcc "$host_cc"
host_cflags_filter=$_flags_filter
add_host_cflags  $_flags $_cflags
set_ccvars HOSTCC

test -n "$cc_type" && enable $cc_type ||
    warn "Unknown C compiler $cc, unable to select optimal CFLAGS"

: ${as_default:=$cc}
: ${dep_cc_default:=$cc}
: ${ld_default:=$cc}
: ${host_ld_default:=$host_cc}
set_default ar as dep_cc ld host_ld

probe_cc as "$as"
asflags_filter=$_flags_filter
add_asflags $_flags $_cflags
set_ccvars AS

probe_cc ld "$ld"
ldflags_filter=$_flags_filter
add_ldflags $_flags $_ldflags
test "$cc_type" != "$ld_type" && add_ldflags $cc_ldflags
LD_O=${_ld_o-$LD_O}
LD_LIB=${_ld_lib-$LD_LIB}
LD_PATH=${_ld_path-$LD_PATH}

probe_cc hostld "$host_ld"
host_ldflags_filter=$_flags_filter
add_host_ldflags $_flags $_ldflags
HOSTLD_O=${_ld_o-$HOSTLD_O}

if [ -z "$CC_DEPFLAGS" ] && [ "$dep_cc" != "$cc" ]; then
    probe_cc depcc "$dep_cc"
    CCDEP=${_DEPCMD:-$DEPCMD}
    CCDEP_FLAGS=${_DEPFLAGS:=$DEPFLAGS}
    DEPCCFLAGS=$_flags
fi

if $ar 2>&1 | grep -q Microsoft; then
    arflags="-nologo"
    ar_o='-out:$@'
elif $ar 2>&1 | grep -q 'Texas Instruments'; then
    arflags="rq"
    ar_o='$@'
else
    arflags="rc"
    ar_o='$@'
fi

add_cflags $extra_cflags
add_cxxflags $extra_cxxflags
add_asflags $extra_cflags

if test -n "$sysroot"; then
    case "$cc_type" in
        gcc|llvm_gcc|clang)
            add_cppflags --sysroot="$sysroot"
            add_ldflags --sysroot="$sysroot"
        ;;
        tms470)
            add_cppflags -I"$sysinclude"
            add_ldflags  --sysroot="$sysroot"
        ;;
    esac
fi

if test "$cpu" = host; then
    enabled cross_compile && die "--cpu=host makes no sense when cross-compiling."

    case "$cc_type" in
        gcc|llvm_gcc)
            check_native(){
                $cc $1=native -v -c -o $TMPO $TMPC >$TMPE 2>&1 || return
                sed -n "/cc1.*$1=/{
                            s/.*$1=\\([^ ]*\\).*/\\1/
                            p
                            q
                        }" $TMPE
            }
            cpu=$(check_native -march || check_native -mcpu)
        ;;
    esac

    test "${cpu:-host}" = host && die "--cpu=host not supported with compiler $cc"
fi

# Deal with common $arch aliases
case "$arch" in
    arm*|iPad*)
        arch="arm"
    ;;
    mips|mipsel|IP*)
        arch="mips"
    ;;
    mips64*)
        arch="mips"
        subarch="mips64"
    ;;
    parisc|hppa)
        arch="parisc"
    ;;
    parisc64|hppa64)
        arch="parisc"
        subarch="parisc64"
    ;;
    "Power Macintosh"|ppc|powerpc|ppc64|powerpc64)
        arch="ppc"
    ;;
    s390|s390x)
        arch="s390"
    ;;
    sh4|sh)
        arch="sh4"
    ;;
    sun4u|sparc64)
        arch="sparc"
        subarch="sparc64"
    ;;
    i[3-6]86|i86pc|BePC|x86pc|x86_64|x86_32|amd64)
        arch="x86"
    ;;
esac

is_in $arch $ARCH_LIST || warn "unknown architecture $arch"
enable $arch

# Add processor-specific flags
if test "$cpu" = generic; then
    : do nothing
elif enabled ppc; then

    case $(tolower $cpu) in
        601|ppc601|powerpc601)
            cpuflags="-mcpu=601"
            disable altivec
        ;;
        603*|ppc603*|powerpc603*)
            cpuflags="-mcpu=603"
            disable altivec
        ;;
        604*|ppc604*|powerpc604*)
            cpuflags="-mcpu=604"
            disable altivec
        ;;
        g3|75*|ppc75*|powerpc75*)
            cpuflags="-mcpu=750 -mpowerpc-gfxopt"
            disable altivec
        ;;
        g4|745*|ppc745*|powerpc745*)
            cpuflags="-mcpu=7450 -mpowerpc-gfxopt"
        ;;
        74*|ppc74*|powerpc74*)
            cpuflags="-mcpu=7400 -mpowerpc-gfxopt"
        ;;
        g5|970|ppc970|powerpc970)
            cpuflags="-mcpu=970 -mpowerpc-gfxopt -mpowerpc64"
        ;;
        power[3-7]*)
            cpuflags="-mcpu=$cpu -mpowerpc-gfxopt -mpowerpc64"
        ;;
        cell)
            cpuflags="-mcpu=cell"
            enable ldbrx
        ;;
        e500mc)
            cpuflags="-mcpu=e500mc"
            disable altivec
        ;;
        e500v2)
            cpuflags="-mcpu=8548 -mhard-float -mfloat-gprs=double"
            disable altivec
        ;;
        e500)
            cpuflags="-mcpu=8540 -mhard-float"
            disable altivec
        ;;
    esac

elif enabled x86; then

    case $cpu in
        i[345]86|pentium)
            cpuflags="-march=$cpu"
            disable mmx
        ;;
        # targets that do NOT support conditional mov (cmov)
        pentium-mmx|k6|k6-[23]|winchip-c6|winchip2|c3)
            cpuflags="-march=$cpu"
            disable cmov
        ;;
        # targets that do support conditional mov (cmov)
        i686|pentiumpro|pentium[23]|pentium-m|athlon|athlon-tbird|athlon-4|athlon-[mx]p|athlon64*|k8*|opteron*|athlon-fx|core2|amdfam10|barcelona|atom|bdver*)
            cpuflags="-march=$cpu"
            enable cmov
            enable fast_cmov
        ;;
        # targets that do support conditional mov but on which it's slow
        pentium4|pentium4m|prescott|nocona)
            cpuflags="-march=$cpu"
            enable cmov
            disable fast_cmov
        ;;
    esac

elif enabled sparc; then

    case $cpu in
        niagara)
            cpuflags="-mcpu=$cpu"
            disable vis
        ;;
        sparc64)
            cpuflags="-mcpu=v9"
        ;;
    esac

elif enabled arm; then

    case $cpu in
        armv*)
            cpuflags="-march=$cpu"
            subarch=$(echo $cpu | sed 's/[^a-z0-9]//g')
        ;;
        *)
            cpuflags="-mcpu=$cpu"
            case $cpu in
                cortex-a*)                               subarch=armv7a  ;;
                cortex-r*)                               subarch=armv7r  ;;
                cortex-m*)                 enable thumb; subarch=armv7m  ;;
                arm11*)                                  subarch=armv6   ;;
                arm[79]*e*|arm9[24]6*|arm96*|arm102[26]) subarch=armv5te ;;
                armv4*|arm7*|arm9[24]*)                  subarch=armv4   ;;
            esac
        ;;
    esac

elif enabled alpha; then

    enabled ccc && cpuflags="-arch $cpu" || cpuflags="-mcpu=$cpu"

elif enabled bfin; then

    cpuflags="-mcpu=$cpu"

elif enabled mips; then

    cpuflags="-march=$cpu"

    case $cpu in
        24kc)
            disable mipsfpu
            disable mipsdspr1
            disable mipsdspr2
        ;;
        24kf*)
            disable mipsdspr1
            disable mipsdspr2
        ;;
        24kec|34kc|1004kc)
            disable mipsfpu
            disable mipsdspr2
        ;;
        24kef*|34kf*|1004kf*)
            disable mipsdspr2
        ;;
        74kc)
            disable mipsfpu
        ;;
    esac

elif enabled avr32; then

    case $cpu in
        ap7[02]0[0-2])
            subarch="avr32_ap"
            cpuflags="-mpart=$cpu"
        ;;
        ap)
            subarch="avr32_ap"
            cpuflags="-march=$cpu"
        ;;
        uc3[ab]*)
            subarch="avr32_uc"
            cpuflags="-mcpu=$cpu"
        ;;
        uc)
            subarch="avr32_uc"
            cpuflags="-march=$cpu"
        ;;
    esac

fi

add_cflags $cpuflags
add_asflags $cpuflags

# compiler sanity check
check_exec <<EOF
int main(void){ return 0; }
EOF
if test "$?" != 0; then
    echo "$cc is unable to create an executable file."
    if test -z "$cross_prefix" && ! enabled cross_compile ; then
        echo "If $cc is a cross-compiler, use the --enable-cross-compile option."
        echo "Only do this if you know what cross compiling means."
    fi
    die "C compiler test failed."
fi

add_cppflags -D_ISOC99_SOURCE
add_cxxflags -D__STDC_CONSTANT_MACROS
check_cflags -std=c99
check_cc -D_FILE_OFFSET_BITS=64 <<EOF && add_cppflags -D_FILE_OFFSET_BITS=64
#include <stdlib.h>
EOF
check_cc -D_LARGEFILE_SOURCE <<EOF && add_cppflags -D_LARGEFILE_SOURCE
#include <stdlib.h>
EOF

check_host_cflags -std=c99
check_host_cflags -Wall

case "$arch" in
    alpha|ia64|mips|parisc|sparc)
        spic=$shared
    ;;
    x86)
        subarch="x86_32"
        check_code cc "" "int test[(int)sizeof(char*) - 7]" && subarch="x86_64"
        if test "$subarch" = "x86_64"; then
            spic=$shared
        fi
    ;;
    ppc)
        check_cc <<EOF && subarch="ppc64"
        int test[(int)sizeof(char*) - 7];
EOF
    ;;
esac

enable $subarch
enabled spic && enable pic

# OS specific
case $target_os in
    haiku)
        prefix_default="/boot/common"
        network_extralibs="-lnetwork"
        host_libs=
        ;;
    sunos)
        FFSERVERLDFLAGS=""
        SHFLAGS='-shared -Wl,-h,$$(@F)'
        enabled x86 && SHFLAGS="-mimpure-text $SHFLAGS"
        network_extralibs="-lsocket -lnsl"
        add_cppflags -D__EXTENSIONS__ -D_XOPEN_SOURCE=600
        # When using suncc to build, the Solaris linker will mark
        # an executable with each instruction set encountered by
        # the Solaris assembler.  As our libraries contain their own
        # guards for processor-specific code, instead suppress
        # generation of the HWCAPS ELF section on Solaris x86 only.
        enabled_all suncc x86 && echo "hwcap_1 = OVERRIDE;" > mapfile && add_ldflags -Wl,-M,mapfile
        nm_default='nm -P -g'
        ;;
    netbsd)
        disable symver
        oss_indev_extralibs="-lossaudio"
        oss_outdev_extralibs="-lossaudio"
        enabled gcc || check_ldflags -Wl,-zmuldefs
        ;;
    openbsd|bitrig)
        # On OpenBSD 4.5. the compiler does not use PIC unless
        # explicitly using -fPIC. FFmpeg builds fine without PIC,
        # however the generated executable will not do anything
        # (simply quits with exit-code 1, no crash, no output).
        # Thus explicitly enable PIC here.
        enable pic
        disable symver
        SHFLAGS='-shared'
        SLIBNAME_WITH_MAJOR='$(SLIBNAME).$(LIBVERSION)'
        SLIB_INSTALL_LINKS=
        oss_indev_extralibs="-lossaudio"
        oss_outdev_extralibs="-lossaudio"
        ;;
    dragonfly)
        disable symver
        ;;
    freebsd)
        ;;
    bsd/os)
        add_extralibs -lpoll -lgnugetopt
        strip="strip -d"
        ;;
    darwin)
        gas="gas-preprocessor.pl $cc"
        enabled ppc && add_asflags -force_cpusubtype_ALL
        SHFLAGS='-dynamiclib -Wl,-single_module -Wl,-install_name,$(SHLIBDIR)/$(SLIBNAME_WITH_MAJOR),-current_version,$(LIBVERSION),-compatibility_version,$(LIBMAJOR)'
        enabled x86_32 && append SHFLAGS -Wl,-read_only_relocs,suppress
        strip="${strip} -x"
        add_ldflags -Wl,-dynamic,-search_paths_first
        SLIBSUF=".dylib"
        SLIBNAME_WITH_VERSION='$(SLIBPREF)$(FULLNAME).$(LIBVERSION)$(SLIBSUF)'
        SLIBNAME_WITH_MAJOR='$(SLIBPREF)$(FULLNAME).$(LIBMAJOR)$(SLIBSUF)'
        FFSERVERLDFLAGS=-Wl,-bind_at_load
        objformat="macho"
        enabled x86_64 && objformat="macho64"
        enabled_any pic shared ||
            { check_cflags -mdynamic-no-pic && add_asflags -mdynamic-no-pic; }
        ;;
    mingw32*)
        if test $target_os = "mingw32ce"; then
            disable network
        else
            target_os=mingw32
        fi
        LIBTARGET=i386
        if enabled x86_64; then
            LIBTARGET="i386:x86-64"
        elif enabled arm; then
            LIBTARGET=arm-wince
        fi
        shlibdir_default="$bindir_default"
        SLIBPREF=""
        SLIBSUF=".dll"
        SLIBNAME_WITH_VERSION='$(SLIBPREF)$(FULLNAME)-$(LIBVERSION)$(SLIBSUF)'
        SLIBNAME_WITH_MAJOR='$(SLIBPREF)$(FULLNAME)-$(LIBMAJOR)$(SLIBSUF)'
        dlltool="${cross_prefix}dlltool"
        if check_cmd lib.exe -list; then
            SLIB_EXTRA_CMD='-lib.exe /machine:$(LIBTARGET) /def:$$(@:$(SLIBSUF)=.def) /out:$(SUBDIR)$(SLIBNAME:$(SLIBSUF)=.lib)'
            if enabled x86_64; then
                LIBTARGET=x64
            fi
        elif check_cmd $dlltool --version; then
            SLIB_EXTRA_CMD=-'$(DLLTOOL) -m $(LIBTARGET) -d $$(@:$(SLIBSUF)=.def) -l $(SUBDIR)$(SLIBNAME:$(SLIBSUF)=.lib) -D $(SLIBNAME_WITH_MAJOR)'
        fi
        SLIB_INSTALL_NAME='$(SLIBNAME_WITH_MAJOR)'
        SLIB_INSTALL_LINKS=
        SLIB_INSTALL_EXTRA_SHLIB='$(SLIBNAME:$(SLIBSUF)=.lib)'
        SLIB_INSTALL_EXTRA_LIB='lib$(SLIBNAME:$(SLIBSUF)=.dll.a) $(SLIBNAME_WITH_MAJOR:$(SLIBSUF)=.def)'
        SHFLAGS='-shared -Wl,--output-def,$$(@:$(SLIBSUF)=.def) -Wl,--out-implib,$(SUBDIR)lib$(SLIBNAME:$(SLIBSUF)=.dll.a) -Wl,--enable-runtime-pseudo-reloc -Wl,--enable-auto-image-base'
        objformat="win32"
        ranlib=:
        enable dos_paths
        add_cppflags -U__STRICT_ANSI__
        ;;
    cygwin*)
        target_os=cygwin
        shlibdir_default="$bindir_default"
        SLIBPREF="cyg"
        SLIBSUF=".dll"
        SLIBNAME_WITH_VERSION='$(SLIBPREF)$(FULLNAME)-$(LIBVERSION)$(SLIBSUF)'
        SLIBNAME_WITH_MAJOR='$(SLIBPREF)$(FULLNAME)-$(LIBMAJOR)$(SLIBSUF)'
        SLIB_INSTALL_NAME='$(SLIBNAME_WITH_MAJOR)'
        SLIB_INSTALL_LINKS=
        SLIB_INSTALL_EXTRA_LIB='lib$(FULLNAME).dll.a'
        SHFLAGS='-shared -Wl,--out-implib,$(SUBDIR)lib$(FULLNAME).dll.a'
        objformat="win32"
        enable dos_paths
        add_cppflags -U__STRICT_ANSI__
        ;;
    *-dos|freedos|opendos)
        network_extralibs="-lsocket"
        objformat="coff"
        enable dos_paths
        add_cppflags -U__STRICT_ANSI__
        ;;
    linux)
        add_cppflags -D_POSIX_C_SOURCE=200112 -D_XOPEN_SOURCE=600
        enable dv1394
        ;;
    irix*)
        target_os=irix
        ranlib="echo ignoring ranlib"
        ;;
    os/2*)
        strip="lxlite -CS"
        ln_s="cp -f"
        objformat="aout"
        add_cppflags -D_GNU_SOURCE
        add_ldflags -Zomf -Zbin-files -Zargs-wild -Zmap
        SHFLAGS='$(SUBDIR)$(NAME).def -Zdll -Zomf'
        FFSERVERLDFLAGS=""
        LIBSUF="_s.a"
        SLIBPREF=""
        SLIBSUF=".dll"
        SLIBNAME_WITH_VERSION='$(SLIBPREF)$(NAME)-$(LIBVERSION)$(SLIBSUF)'
        SLIBNAME_WITH_MAJOR='$(SLIBPREF)$(shell echo $(NAME) | cut -c1-6)$(LIBMAJOR)$(SLIBSUF)'
        SLIB_CREATE_DEF_CMD='echo LIBRARY $(SLIBNAME_WITH_MAJOR) INITINSTANCE TERMINSTANCE > $(SUBDIR)$(NAME).def; \
            echo PROTMODE >> $(SUBDIR)$(NAME).def; \
            echo CODE PRELOAD MOVEABLE DISCARDABLE >> $(SUBDIR)$(NAME).def; \
            echo DATA PRELOAD MOVEABLE MULTIPLE NONSHARED >> $(SUBDIR)$(NAME).def; \
            echo EXPORTS >> $(SUBDIR)$(NAME).def; \
            emxexp -o $(OBJS) >> $(SUBDIR)$(NAME).def'
        SLIB_EXTRA_CMD='emximp -o $(SUBDIR)$(LIBPREF)$(NAME)_dll.a $(SUBDIR)$(NAME).def; \
            emximp -o $(SUBDIR)$(LIBPREF)$(NAME)_dll.lib $(SUBDIR)$(NAME).def;'
        SLIB_INSTALL_EXTRA_LIB='$(LIBPREF)$(NAME)_dll.a $(LIBPREF)$(NAME)_dll.lib'
        enable dos_paths
        enable_weak os2threads
        ;;
    gnu/kfreebsd)
        add_cppflags -D_POSIX_C_SOURCE=200112 -D_XOPEN_SOURCE=600 -D_BSD_SOURCE
        ;;
    gnu)
        add_cppflags -D_POSIX_C_SOURCE=200112 -D_XOPEN_SOURCE=600
        ;;
    qnx)
        add_cppflags -D_QNX_SOURCE
        network_extralibs="-lsocket"
        ;;
    symbian)
        SLIBSUF=".dll"
        enable dos_paths
        add_cflags --include=$sysinclude/gcce/gcce.h -fvisibility=default
        add_cppflags -D__GCCE__ -D__SYMBIAN32__ -DSYMBIAN_OE_POSIX_SIGNALS
        add_ldflags -Wl,--target1-abs,--no-undefined \
                    -Wl,-Ttext,0x80000,-Tdata,0x1000000 -shared \
                    -Wl,--entry=_E32Startup -Wl,-u,_E32Startup
        add_extralibs -l:eexe.lib -l:usrt2_2.lib -l:dfpaeabi.dso \
                      -l:drtaeabi.dso -l:scppnwdl.dso -lsupc++ -lgcc \
                      -l:libc.dso -l:libm.dso -l:euser.dso -l:libcrt0.lib
        ;;
    osf1)
        add_cppflags -D_OSF_SOURCE -D_POSIX_PII -D_REENTRANT
        FFSERVERLDFLAGS=
        ;;
    minix)
        ;;
    none)
        ;;
    *)
        die "Unknown OS '$target_os'."
        ;;
esac

# determine libc flavour

if check_cpp_condition features.h "defined __UCLIBC__"; then
    libc_type=uclibc
elif check_cpp_condition features.h "defined __GLIBC__"; then
    libc_type=glibc
elif check_header _mingw.h; then
    libc_type=mingw
    check_cpp_condition _mingw.h \
        "defined (__MINGW64_VERSION_MAJOR) || (__MINGW32_MAJOR_VERSION > 3) || \
            (__MINGW32_MAJOR_VERSION == 3 && __MINGW32_MINOR_VERSION >= 15)" ||
        die "ERROR: MinGW runtime version must be >= 3.15."
    if check_cpp_condition _mingw.h "defined(__MINGW64_VERSION_MAJOR) && \
            __MINGW64_VERSION_MAJOR < 3"; then
        enable broken_snprintf
        add_cflags "-include $source_path/compat/msvcrt/snprintf.h"
    fi
elif check_cpp_condition newlib.h "defined _NEWLIB_VERSION"; then
    libc_type=newlib
elif check_func_headers stdlib.h _get_doserrno; then
    libc_type=msvcrt
    enable broken_snprintf
    add_cflags -Dstrtod=avpriv_strtod
    add_cflags -Dsnprintf=avpriv_snprintf   \
               -D_snprintf=avpriv_snprintf  \
               -Dvsnprintf=avpriv_vsnprintf
elif check_cpp_condition stddef.h "defined __KLIBC__"; then
    libc_type=klibc
fi

test -n "$libc_type" && enable $libc_type

esc(){
    echo "$*" | sed 's/%/%25/g;s/:/%3a/g'
}

echo "config:$arch:$subarch:$cpu:$target_os:$(esc $cc_ident):$(esc $FFMPEG_CONFIGURATION)" >config.fate

check_cpp_condition stdlib.h "defined(__PIC__) || defined(__pic__) || defined(PIC)" && enable pic

set_default $PATHS_LIST
set_default nm

# we need to build at least one lib type
if ! enabled_any static shared; then
    cat <<EOF
At least one library type must be built.
Specify --enable-static to build the static libraries or --enable-shared to
build the shared libraries as well. To only build the shared libraries specify
--disable-static in addition to --enable-shared.
EOF
    exit 1;
fi

die_license_disabled() {
    enabled $1 || { enabled $2 && die "$2 is $1 and --enable-$1 is not specified."; }
}

die_license_disabled_gpl() {
    enabled $1 || { enabled $2 && die "$2 is incompatible with the gpl and --enable-$1 is not specified."; }
}

die_license_disabled gpl libcdio
die_license_disabled gpl libutvideo
die_license_disabled gpl libx264
die_license_disabled gpl libxavs
die_license_disabled gpl libxvid
die_license_disabled gpl x11grab

die_license_disabled nonfree libaacplus
die_license_disabled nonfree libfaac
enabled gpl && die_license_disabled_gpl nonfree libfdk_aac
enabled gpl && die_license_disabled_gpl nonfree openssl

die_license_disabled version3 libopencore_amrnb
die_license_disabled version3 libopencore_amrwb
die_license_disabled version3 libvo_aacenc
die_license_disabled version3 libvo_amrwbenc

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

disabled optimizations || check_cflags -fomit-frame-pointer

enable_pic() {
    enable pic
    add_cppflags -DPIC
    add_cflags   -fPIC
    add_asflags  -fPIC
}

enabled pic && enable_pic

check_cc <<EOF || die "Symbol mangling check failed."
int ff_extern;
EOF
sym=$($nm $TMPO | awk '/ff_extern/{ print substr($0, match($0, /[^ \t]*ff_extern/)) }')
extern_prefix=${sym%%ff_extern*}

check_cc <<EOF && enable_weak inline_asm
void foo(void) { __asm__ volatile ("" ::); }
EOF

_restrict=
for restrict_keyword in restrict __restrict__ __restrict; do
    check_cc <<EOF && _restrict=$restrict_keyword && break
void foo(char * $restrict_keyword p);
EOF
done

check_cc <<EOF && enable attribute_packed
struct { int x; } __attribute__((packed)) x;
EOF

check_cc <<EOF && enable attribute_may_alias
union { int x; } __attribute__((may_alias)) x;
EOF

check_cc <<EOF || die "endian test failed"
unsigned int endian = 'B' << 24 | 'I' << 16 | 'G' << 8 | 'E';
EOF
od -t x1 $TMPO | grep -q '42 *49 *47 *45' && enable bigendian

if enabled alpha; then

    check_cflags -mieee

elif enabled arm; then

    enabled thumb && check_cflags -mthumb || check_cflags -marm
    nogas=die

    if     check_cpp_condition stddef.h "defined __ARM_PCS_VFP"; then
        enable vfp_args
    elif ! check_cpp_condition stddef.h "defined __ARM_PCS || defined __SOFTFP__"; then
        case "${cross_prefix:-$cc}" in
            *hardfloat*)         enable vfp_args;   fpabi=vfp ;;
            *) check_ld "cc" <<EOF && enable vfp_args && fpabi=vfp || fpabi=soft ;;
__asm__ (".eabi_attribute 28, 1");
int main(void) { return 0; }
EOF
        esac
        warn "Compiler does not indicate floating-point ABI, guessing $fpabi."
    fi

    enabled armv5te && check_inline_asm armv5te '"qadd r0, r0, r0"'
    enabled armv6   && check_inline_asm armv6   '"sadd16 r0, r0, r0"'
    enabled armv6t2 && check_inline_asm armv6t2 '"movt r0, #0"'
    enabled armvfp  && check_inline_asm armvfp  '"fadds s0, s0, s0"'
    enabled neon    && check_inline_asm neon    '"vadd.i16 q0, q0, q0"'
    enabled vfpv3   && check_inline_asm vfpv3   '"vmov.f32 s0, #1.0"'

    check_inline_asm asm_mod_q '"add r0, %Q0, %R0" :: "r"((long long)0)'
    check_inline_asm asm_mod_y '"vmul.i32 d0, d0, %y0" :: "x"(0)'

    enabled_all armv6t2 shared !pic && enable_pic

elif enabled mips; then

    check_inline_asm loongson '"dmult.g $1, $2, $3"'
    enabled mips32r2  && add_cflags "-mips32r2" && add_asflags "-mips32r2" &&
     check_inline_asm mips32r2  '"rotr $t0, $t1, 1"'
    enabled mipsdspr1 && add_cflags "-mdsp" && add_asflags "-mdsp" &&
     check_inline_asm mipsdspr1 '"addu.qb $t0, $t1, $t2"'
    enabled mipsdspr2 && add_cflags "-mdspr2" && add_asflags "-mdspr2" &&
     check_inline_asm mipsdspr2 '"absq_s.qb $t0, $t1"'
    enabled mipsfpu   && add_cflags "-mhard-float" && add_asflags "-mhard-float" &&
     check_inline_asm mipsfpu   '"madd.d $f0, $f2, $f4, $f6"'

elif enabled ppc; then

    enable local_aligned_8 local_aligned_16

    check_inline_asm dcbzl     '"dcbzl 0, %0" :: "r"(0)'
    check_inline_asm ibm_asm   '"add 0, 0, 0"'
    check_inline_asm ppc4xx    '"maclhw r10, r11, r12"'
    check_inline_asm xform_asm '"lwzx %1, %y0" :: "Z"(*(int*)0), "r"(0)'

    # AltiVec flags: The FSF version of GCC differs from the Apple version
    if enabled altivec; then
        nogas=warn
        check_cflags -maltivec -mabi=altivec &&
        { check_header altivec.h && inc_altivec_h="#include <altivec.h>" ; } ||
        check_cflags -faltivec

        # check if our compiler supports Motorola AltiVec C API
        check_cc <<EOF || disable altivec
$inc_altivec_h
int main(void) {
    vector signed int v1 = (vector signed int) { 0 };
    vector signed int v2 = (vector signed int) { 1 };
    v1 = vec_add(v1, v2);
    return 0;
}
EOF

        enabled altivec || warn "Altivec disabled, possibly missing --cpu flag"
    fi

elif enabled sparc; then

    enabled vis &&
        check_inline_asm vis '"pdist %f0, %f0, %f0"' -mcpu=ultrasparc &&
            add_cflags -mcpu=ultrasparc -mtune=ultrasparc

elif enabled x86; then

    check_code ld intrin.h "__rdtsc()" "cc" && enable rdtsc

    check_code ld mmintrin.h "_mm_empty()" "cc" && enable mm_empty

    enable local_aligned_8 local_aligned_16

    # check whether EBP is available on x86
    # As 'i' is stored on the stack, this program will crash
    # if the base pointer is used to access it because the
    # base pointer is cleared in the inline assembly code.
    check_exec_crash <<EOF && enable ebp_available
volatile int i=0;
__asm__ volatile ("xorl %%ebp, %%ebp" ::: "%ebp");
return i;
EOF

    # check whether EBX is available on x86
    check_inline_asm ebx_available '""::"b"(0)' &&
        check_inline_asm ebx_available '"":::"%ebx"'

    # check whether xmm clobbers are supported
    check_inline_asm xmm_clobbers '"":::"%xmm0"'

    # check whether binutils is new enough to compile SSSE3/MMXEXT
    enabled ssse3  && check_inline_asm ssse3_inline  '"pabsw %xmm0, %xmm0"'
    enabled mmxext && check_inline_asm mmxext_inline '"pmaxub %mm0, %mm1"'

    if ! disabled_any asm mmx yasm; then
        if check_cmd $yasmexe --version; then
            enabled x86_64 && yasm_extra="-m amd64"
            yasm_debug="-g dwarf2"
        elif check_cmd nasm -v; then
            yasmexe=nasm
            yasm_debug="-g -F dwarf"
            enabled x86_64 && test "$objformat" = elf && objformat=elf64
        fi

        YASMFLAGS="-f $objformat $yasm_extra"
        enabled pic               && append YASMFLAGS "-DPIC"
        test -n "$extern_prefix"  && append YASMFLAGS "-DPREFIX"
        case "$objformat" in
            elf*) enabled debug && append YASMFLAGS $yasm_debug ;;
        esac

        check_yasm "pextrd [eax], xmm0, 1" && enable yasm ||
            die "yasm not found, use --disable-yasm for a crippled build"
        check_yasm "vextractf128 xmm0, ymm0, 0"      || disable avx_external
        check_yasm "vfmaddps ymm0, ymm1, ymm2, ymm3" || disable fma4_external
        check_yasm "CPU amdnop" && enable cpunop
    fi

    case "$cpu" in
        athlon*|opteron*|k8*|pentium|pentium-mmx|prescott|nocona|atom|geode)
            disable fast_clz
        ;;
    esac

fi

if enabled asm; then
    as=${gas:=$as}
    check_inline_asm gnu_as '".macro m n\n\\n:.int 0\n.endm\nm x"' ||
        $nogas "GNU assembler not found, install gas-preprocessor"
fi

check_ldflags -Wl,--as-needed

if check_func dlopen; then
    ldl=
elif check_func dlopen -ldl; then
    ldl=-ldl
fi

if enabled network; then
    check_type "sys/types.h sys/socket.h" socklen_t
    check_type netdb.h "struct addrinfo"
    check_type netinet/in.h "struct group_source_req" -D_BSD_SOURCE
    check_type netinet/in.h "struct ip_mreq_source" -D_BSD_SOURCE
    check_type netinet/in.h "struct ipv6_mreq" -D_DARWIN_C_SOURCE
    check_type netinet/in.h "struct sockaddr_in6"
    check_type poll.h "struct pollfd"
    check_type "sys/types.h sys/socket.h" "struct sockaddr_storage"
    check_struct "sys/types.h sys/socket.h" "struct sockaddr" sa_len
    check_type netinet/sctp.h "struct sctp_event_subscribe"
    check_func getaddrinfo $network_extralibs
    # Prefer arpa/inet.h over winsock2
    if check_header arpa/inet.h ; then
        check_func closesocket
    elif check_header winsock2.h ; then
        check_func_headers winsock2.h closesocket -lws2 &&
            network_extralibs="-lws2" ||
        { check_func_headers winsock2.h closesocket -lws2_32 &&
            network_extralibs="-lws2_32"; }
        check_func_headers ws2tcpip.h getaddrinfo $network_extralibs
        check_type ws2tcpip.h socklen_t
        check_type ws2tcpip.h "struct addrinfo"
        check_type ws2tcpip.h "struct group_source_req"
        check_type ws2tcpip.h "struct ip_mreq_source"
        check_type ws2tcpip.h "struct ipv6_mreq"
        check_type winsock2.h "struct pollfd"
        check_type ws2tcpip.h "struct sockaddr_in6"
        check_type ws2tcpip.h "struct sockaddr_storage"
        check_struct winsock2.h "struct sockaddr" sa_len
    else
        disable network
    fi
fi

# Solaris has nanosleep in -lrt, OpenSolaris no longer needs that
check_func nanosleep || { check_func nanosleep -lrt && add_extralibs -lrt; }

check_func  clock_gettime || { check_func clock_gettime -lrt && add_extralibs -lrt; }
check_func  fcntl
check_func  fork
check_func  gethrtime
check_func  getopt
check_func  getrusage
check_struct "sys/time.h sys/resource.h" "struct rusage" ru_maxrss
check_func  gettimeofday
check_func  inet_aton $network_extralibs
check_func  isatty
check_func  localtime_r
check_func  ${malloc_prefix}memalign            && enable memalign
check_func  mkstemp
check_func  mmap
check_func  ${malloc_prefix}posix_memalign      && enable posix_memalign
check_func_headers malloc.h _aligned_malloc     && enable aligned_malloc
check_func  setrlimit
check_func  strerror_r
check_func  sched_getaffinity
check_func  sysconf
check_func  sysctl
check_func  usleep
check_func_headers conio.h kbhit
check_func_headers windows.h PeekNamedPipe
check_func_headers io.h setmode
check_func_headers lzo/lzo1x.h lzo1x_999_compress
check_lib2 "windows.h shellapi.h" CommandLineToArgvW -lshell32
check_lib2 "windows.h wincrypt.h" CryptGenRandom -ladvapi32
check_lib2 "windows.h psapi.h" GetProcessMemoryInfo -lpsapi
check_func_headers windows.h GetProcessAffinityMask
check_func_headers windows.h GetProcessTimes
check_func_headers windows.h GetSystemTimeAsFileTime
check_func_headers windows.h MapViewOfFile
check_func_headers windows.h Sleep
check_func_headers windows.h VirtualAlloc
check_func_headers glob.h glob

check_header direct.h
check_header dlfcn.h
check_header dxva.h
check_header dxva2api.h -D_WIN32_WINNT=0x0600
check_header io.h
check_header libcrystalhd/libcrystalhd_if.h
check_header malloc.h
check_header poll.h
check_header sys/mman.h
check_header sys/param.h
check_header sys/resource.h
check_header sys/select.h
check_header sys/time.h
check_header termios.h
check_header unistd.h
check_header vdpau/vdpau.h
check_header vdpau/vdpau_x11.h
check_header windows.h
check_header X11/extensions/XvMClib.h
check_header asm/types.h

disabled  zlib || check_lib   zlib.h      zlibVersion -lz   || disable  zlib
disabled bzlib || check_lib2 bzlib.h BZ2_bzlibVersion -lbz2 || disable bzlib

# check for VDA header
if ! disabled vda && ! enabled ppc; then
    if check_header VideoDecodeAcceleration/VDADecoder.h; then
        enable vda
        add_extralibs -framework CoreFoundation -framework VideoDecodeAcceleration -framework QuartzCore
    fi
fi

if ! disabled w32threads && ! enabled pthreads; then
    check_func _beginthreadex && enable w32threads
fi

# check for some common methods of building with pthread support
# do this before the optional library checks as some of them require pthreads
if ! disabled pthreads && ! enabled w32threads && ! enabled os2threads; then
    enable pthreads
    if check_func pthread_create; then
        :
    elif check_func pthread_create -pthread; then
        add_cflags -pthread
        add_extralibs -pthread
    elif check_func pthread_create -pthreads; then
        add_cflags -pthreads
        add_extralibs -pthreads
    elif check_func pthread_create -lpthreadGC2; then
        add_extralibs -lpthreadGC2
    elif ! check_lib pthread.h pthread_create -lpthread; then
        disable pthreads
    fi
fi

for thread in $THREADS_LIST; do
    if enabled $thread; then
        test -n "$thread_type" &&
            die "ERROR: Only one thread type must be selected." ||
            thread_type="$thread"
    fi
done

if enabled pthreads; then
  check_func pthread_cancel
fi

check_lib math.h sin -lm && LIBM="-lm"
disabled crystalhd || check_lib libcrystalhd/libcrystalhd_if.h DtsCrystalHDVersion -lcrystalhd || disable crystalhd
enabled vaapi && require vaapi va/va.h vaInitialize -lva

check_mathfunc cbrtf
check_mathfunc exp2
check_mathfunc exp2f
check_mathfunc isinf
check_mathfunc isnan
check_mathfunc llrint
check_mathfunc llrintf
check_mathfunc log2
check_mathfunc log2f
check_mathfunc lrint
check_mathfunc lrintf
check_mathfunc rint
check_mathfunc round
check_mathfunc roundf
check_mathfunc trunc
check_mathfunc truncf

# these are off by default, so fail if requested and not available
enabled avisynth   && require2 vfw32 "windows.h vfw.h" AVIFileInit -lavifil32
enabled fontconfig && require_pkg_config fontconfig "fontconfig/fontconfig.h" FcInit
enabled frei0r     && { check_header frei0r.h || die "ERROR: frei0r.h header not found"; }
enabled gnutls     && require_pkg_config gnutls gnutls/gnutls.h gnutls_global_init
enabled libiec61883 && require libiec61883 libiec61883/iec61883.h iec61883_cmp_connect -lraw1394 -lavc1394 -lrom1394 -liec61883
enabled libaacplus && require  "libaacplus >= 2.0.0" aacplus.h aacplusEncOpen -laacplus
enabled libass     && require_pkg_config libass ass/ass.h ass_library_init
enabled libbluray  && require libbluray libbluray/bluray.h bd_open -lbluray
enabled libcdio    && require2 libcdio "cdio/cdda.h cdio/paranoia.h" cdio_cddap_open "-lcdio_paranoia -lcdio_cdda -lcdio"
enabled libcelt    && require libcelt celt/celt.h celt_decode -lcelt0 &&
                      { check_lib celt/celt.h celt_decoder_create_custom -lcelt0 ||
                        die "ERROR: libcelt must be installed and version must be >= 0.11.0."; }
enabled libcaca    && require_pkg_config caca caca.h caca_create_canvas
enabled libfaac    && require2 libfaac "stdint.h faac.h" faacEncGetVersion -lfaac
enabled libfdk_aac && require  libfdk_aac fdk-aac/aacenc_lib.h aacEncOpen -lfdk-aac
flite_libs="-lflite_cmu_time_awb -lflite_cmu_us_awb -lflite_cmu_us_kal -lflite_cmu_us_kal16 -lflite_cmu_us_rms -lflite_cmu_us_slt -lflite_usenglish -lflite_cmulex -lflite"
enabled libflite   && require2 libflite "flite/flite.h" flite_init $flite_libs
enabled libfreetype && require_pkg_config freetype2 "ft2build.h freetype/freetype.h" FT_Init_FreeType
enabled libgsm     && require  libgsm gsm/gsm.h gsm_create -lgsm
enabled libilbc    && require  libilbc ilbc.h WebRtcIlbcfix_InitDecode -lilbc
enabled libmodplug && require  libmodplug libmodplug/modplug.h ModPlug_Load -lmodplug
enabled libmp3lame && require  "libmp3lame >= 3.98.3" lame/lame.h lame_set_VBR_quality -lmp3lame
enabled libnut     && require  libnut libnut.h nut_demuxer_init -lnut
enabled libopencore_amrnb  && require libopencore_amrnb opencore-amrnb/interf_dec.h Decoder_Interface_init -lopencore-amrnb
enabled libopencore_amrwb  && require libopencore_amrwb opencore-amrwb/dec_if.h D_IF_init -lopencore-amrwb
enabled libopencv  && require_pkg_config opencv opencv/cxcore.h cvCreateImageHeader
enabled libopenjpeg && require libopenjpeg openjpeg.h opj_version -lopenjpeg
enabled libopus    && require_pkg_config opus opus_multistream.h opus_multistream_decoder_create
enabled libpulse && require_pkg_config libpulse-simple pulse/simple.h pa_simple_new
enabled librtmp    && require_pkg_config librtmp librtmp/rtmp.h RTMP_Socket
enabled libschroedinger && require_pkg_config schroedinger-1.0 schroedinger/schro.h schro_init
enabled libspeex   && require  libspeex speex/speex.h speex_decoder_init -lspeex
enabled libstagefright_h264  && require_cpp libstagefright_h264 "binder/ProcessState.h media/stagefright/MetaData.h
    media/stagefright/MediaBufferGroup.h media/stagefright/MediaDebug.h media/stagefright/MediaDefs.h
    media/stagefright/OMXClient.h media/stagefright/OMXCodec.h" android::OMXClient -lstagefright -lmedia -lutils -lbinder -lgnustl_static
enabled libtheora  && require  libtheora theora/theoraenc.h th_info_init -ltheoraenc -ltheoradec -logg
enabled libtwolame && require  libtwolame twolame.h twolame_init -ltwolame &&
                      { check_lib twolame.h twolame_encode_buffer_float32_interleaved -ltwolame ||
                        die "ERROR: libtwolame must be installed and version must be >= 0.3.10"; }
enabled libutvideo    && require_cpp utvideo "stdint.h stdlib.h utvideo/utvideo.h utvideo/Codec.h" 'CCodec*' -lutvideo -lstdc++
enabled libv4l2    && require_pkg_config libv4l2 libv4l2.h v4l2_ioctl
enabled libvo_aacenc && require libvo_aacenc vo-aacenc/voAAC.h voGetAACEncAPI -lvo-aacenc
enabled libvo_amrwbenc && require libvo_amrwbenc vo-amrwbenc/enc_if.h E_IF_init -lvo-amrwbenc
enabled libvorbis  && require  libvorbis vorbis/vorbisenc.h vorbis_info_init -lvorbisenc -lvorbis -logg
enabled libvpx     && {
    enabled libvpx_decoder && { check_lib2 "vpx/vpx_decoder.h vpx/vp8dx.h" vpx_codec_dec_init_ver -lvpx ||
                                die "ERROR: libvpx decoder must be installed and version must be >=0.9.1"; }
    enabled libvpx_encoder && { check_lib2 "vpx/vpx_encoder.h vpx/vp8cx.h" "vpx_codec_enc_init_ver VP8E_SET_MAX_INTRA_BITRATE_PCT" -lvpx ||
                                die "ERROR: libvpx encoder version must be >=0.9.7"; } }
enabled libx264    && require  libx264 x264.h x264_encoder_encode -lx264 &&
                      { check_cpp_condition x264.h "X264_BUILD >= 118" ||
                        die "ERROR: libx264 must be installed and version must be >= 0.118."; }
enabled libxavs    && require  libxavs xavs.h xavs_encoder_encode -lxavs
enabled libxvid    && require  libxvid xvid.h xvid_global -lxvidcore
enabled openal     && { { for al_libs in "${OPENAL_LIBS}" "-lopenal" "-lOpenAL32"; do
                        check_lib 'AL/al.h' alGetError "${al_libs}" && break; done } ||
                        die "ERROR: openal not found"; } &&
                      { check_cpp_condition "AL/al.h" "defined(AL_VERSION_1_1)" ||
                        die "ERROR: openal must be installed and version must be 1.1 or compatible"; }
enabled openssl    && { check_lib openssl/ssl.h SSL_library_init -lssl -lcrypto ||
                        check_lib openssl/ssl.h SSL_library_init -lssl32 -leay32 ||
                        check_lib openssl/ssl.h SSL_library_init -lssl -lcrypto -lws2_32 -lgdi32 ||
                        die "ERROR: openssl not found"; }

if enabled gnutls; then
    { check_lib nettle/bignum.h nettle_mpz_get_str_256 -lnettle -lhogweed -lgmp && enable nettle; } ||
    { check_lib gcrypt.h gcry_mpi_new -lgcrypt && enable gcrypt; }
fi

# libdc1394 check
if enabled libdc1394; then
    { check_lib dc1394/dc1394.h dc1394_new -ldc1394 -lraw1394 &&
        enable libdc1394_2; } ||
    { check_lib libdc1394/dc1394_control.h dc1394_create_handle -ldc1394_control -lraw1394 &&
        enable libdc1394_1; } ||
    die "ERROR: No version of libdc1394 found "
fi

SDL_CONFIG="${cross_prefix}sdl-config"
if check_pkg_config sdl SDL_events.h SDL_PollEvent; then
    check_cpp_condition SDL.h "(SDL_MAJOR_VERSION<<16 | SDL_MINOR_VERSION<<8 | SDL_PATCHLEVEL) >= 0x010201" $sdl_cflags &&
    enable sdl &&
    check_struct SDL.h SDL_VideoInfo current_w $sdl_cflags && enable sdl_video_size
else
  if "${SDL_CONFIG}" --version > /dev/null 2>&1; then
    sdl_cflags=$("${SDL_CONFIG}" --cflags)
    sdl_libs=$("${SDL_CONFIG}" --libs)
    check_func_headers SDL_version.h SDL_Linked_Version $sdl_cflags $sdl_libs &&
    check_cpp_condition SDL.h "(SDL_MAJOR_VERSION<<16 | SDL_MINOR_VERSION<<8 | SDL_PATCHLEVEL) >= 0x010201" $sdl_cflags &&
    enable sdl &&
    check_struct SDL.h SDL_VideoInfo current_w $sdl_cflags && enable sdl_video_size
  fi
fi
enabled sdl && add_cflags $sdl_cflags && add_extralibs $sdl_libs

texi2html --help 2> /dev/null | grep -q 'init-file' && enable texi2html || disable texi2html
makeinfo --version > /dev/null 2>&1 && enable makeinfo  || disable makeinfo
perl --version > /dev/null 2>&1 && enable perl || disable perl
pod2man --help > /dev/null 2>&1 && enable pod2man || disable pod2man

check_header linux/fb.h
check_header linux/videodev.h
check_header linux/videodev2.h
check_struct linux/videodev2.h "struct v4l2_frmivalenum" discrete

check_header sys/videoio.h

check_func_headers "windows.h vfw.h" capCreateCaptureWindow "$vfwcap_indev_extralibs"
# check that WM_CAP_DRIVER_CONNECT is defined to the proper value
# w32api 3.12 had it defined wrong
check_cpp_condition vfw.h "WM_CAP_DRIVER_CONNECT > WM_USER" && enable vfwcap_defines

check_type "dshow.h" IBaseFilter

# check for ioctl_meteor.h, ioctl_bt848.h and alternatives
{ check_header dev/bktr/ioctl_meteor.h &&
  check_header dev/bktr/ioctl_bt848.h; } ||
{ check_header machine/ioctl_meteor.h &&
  check_header machine/ioctl_bt848.h; } ||
{ check_header dev/video/meteor/ioctl_meteor.h &&
  check_header dev/video/bktr/ioctl_bt848.h; } ||
check_header dev/ic/bt8xx.h

check_header sndio.h
if check_struct sys/soundcard.h audio_buf_info bytes; then
    enable_safe sys/soundcard.h
else
    check_cc -D__BSD_VISIBLE -D__XSI_VISIBLE <<EOF && add_cppflags -D__BSD_VISIBLE -D__XSI_VISIBLE && enable_safe sys/soundcard.h
    #include <sys/soundcard.h>
    audio_buf_info abc;
EOF
fi
check_header soundcard.h

enabled_any alsa_indev alsa_outdev && check_lib2 alsa/asoundlib.h snd_pcm_htimestamp -lasound

enabled jack_indev && check_lib2 jack/jack.h jack_client_open -ljack && check_func sem_timedwait &&
    check_func jack_port_get_latency_range -ljack

enabled_any sndio_indev sndio_outdev && check_lib2 sndio.h sio_open -lsndio

enabled x11grab                                           &&
require X11 X11/Xlib.h XOpenDisplay -lX11                 &&
require Xext X11/extensions/XShm.h XShmCreateImage -lXext &&
require Xfixes X11/extensions/Xfixes.h XFixesGetCursorImage -lXfixes

if ! disabled vaapi; then
    check_lib va/va.h vaInitialize -lva && {
        check_cpp_condition va/va_version.h "VA_CHECK_VERSION(0,32,0)" ||
        warn "Please upgrade to VA-API >= 0.32 if you would like full VA-API support.";
    } || disable vaapi
fi

if ! disabled vdpau && enabled vdpau_vdpau_h; then
    check_cpp_condition vdpau/vdpau.h "defined VDP_DECODER_PROFILE_MPEG4_PART2_ASP" ||
        { echolog "Please upgrade to libvdpau >= 0.2 if you would like vdpau support." && disable vdpau; }
fi

enabled debug && add_cflags -g"$debuglevel" && add_asflags -g"$debuglevel"
enabled coverage && add_cflags "-fprofile-arcs -ftest-coverage" && add_ldflags "-fprofile-arcs -ftest-coverage"
test -n "$valgrind" && target_exec="$valgrind --error-exitcode=1 --malloc-fill=0x2a --track-origins=yes --leak-check=full --gen-suppressions=all --suppressions=$source_path/tests/fate-valgrind.supp"

# add some useful compiler flags if supported
check_cflags -Wdeclaration-after-statement
check_cflags -Wall
check_cflags -Wno-parentheses
check_cflags -Wno-switch
check_cflags -Wno-format-zero-length
check_cflags -Wdisabled-optimization
check_cflags -Wpointer-arith
check_cflags -Wredundant-decls
check_cflags -Wno-pointer-sign
check_cflags -Wwrite-strings
check_cflags -Wtype-limits
check_cflags -Wundef
check_cflags -Wmissing-prototypes
check_cflags -Wno-pointer-to-int-cast
check_cflags -Wstrict-prototypes
enabled extra_warnings && check_cflags -Winline

# add some linker flags
check_ldflags -Wl,--warn-common
check_ldflags -Wl,-rpath-link=libpostproc:libswresample:libswscale:libavfilter:libavdevice:libavformat:libavcodec:libavutil:libavresample
test_ldflags -Wl,-Bsymbolic && append SHFLAGS -Wl,-Bsymbolic

enabled xmm_clobber_test &&
    check_ldflags -Wl,--wrap,avcodec_open2              \
                  -Wl,--wrap,avcodec_decode_audio4      \
                  -Wl,--wrap,avcodec_decode_video2      \
                  -Wl,--wrap,avcodec_decode_subtitle2   \
                  -Wl,--wrap,avcodec_encode_audio2      \
                  -Wl,--wrap,avcodec_encode_video       \
                  -Wl,--wrap,avcodec_encode_subtitle    \
                  -Wl,--wrap,sws_scale ||
    disable xmm_clobber_test

echo "X{};" > $TMPV
if test_ldflags -Wl,--version-script,$TMPV; then
    append SHFLAGS '-Wl,--version-script,\$(SUBDIR)lib\$(NAME).ver'
    check_cc <<EOF && enable symver_asm_label
void ff_foo(void) __asm__ ("av_foo@VERSION");
void ff_foo(void) { ${inline_asm+__asm__($quotes);} }
EOF
    check_cc <<EOF && enable symver_gnu_asm
__asm__(".symver ff_foo,av_foo@VERSION");
void ff_foo(void) {}
EOF
fi

if [ -z "$optflags" ]; then
    if enabled small; then
        optflags=$cflags_size
    elif enabled optimizations; then
        optflags=$cflags_speed
    else
        optflags=$cflags_noopt
    fi
fi

check_optflags(){
    check_cflags "$@"
    enabled lto && check_ldflags "$@"
}


if enabled lto; then
    test "$cc_type" != "$ld_type" && die "LTO requires same compiler and linker"
    check_cflags  -flto
    check_ldflags -flto $cpuflags
fi

check_optflags $optflags
check_optflags -fno-math-errno
check_optflags -fno-signed-zeros

enabled ftrapv && check_cflags -ftrapv

check_cc -mno-red-zone <<EOF && noredzone_flags="-mno-red-zone"
int x;
EOF


if enabled icc; then
    # Just warnings, no remarks
    check_cflags -w1
    # -wd: Disable following warnings
    # 144, 167, 556: -Wno-pointer-sign
    # 1292: attribute "foo" ignored
    # 1419: external declaration in primary source file
    # 10006: ignoring unknown option -fno-signed-zeros
    # 10148: ignoring unknown option -Wno-parentheses
    # 10156: ignoring option '-W'; no argument required
    check_cflags -wd144,167,556,1292,1419,10006,10148,10156
    # 11030: Warning unknown option --as-needed
    # 10156: ignoring option '-export'; no argument required
    check_ldflags -wd10156,11030
    # Allow to compile with optimizations
    check_ldflags -march=$cpu
    # icc 11.0 and 11.1 work with ebp_available, but don't pass the test
    enable ebp_available
    if enabled x86_32; then
        icc_version=$($cc -dumpversion)
        test ${icc_version%%.*} -ge 11 &&
            check_cflags -falign-stack=maintain-16-byte ||
            disable aligned_stack
    fi
elif enabled ccc; then
    # disable some annoying warnings
    add_cflags -msg_disable cvtu32to64
    add_cflags -msg_disable embedcomment
    add_cflags -msg_disable needconstext
    add_cflags -msg_disable nomainieee
    add_cflags -msg_disable ptrmismatch1
    add_cflags -msg_disable unreachcode
elif enabled gcc; then
    check_optflags -fno-tree-vectorize
    check_cflags -Werror=implicit-function-declaration
    check_cflags -Werror=missing-prototypes
    check_cflags -Werror=vla
elif enabled llvm_gcc; then
    check_cflags -mllvm -stack-alignment=16
elif enabled clang; then
    check_cflags -mllvm -stack-alignment=16
    check_cflags -Qunused-arguments
elif enabled armcc; then
    # 2523: use of inline assembler is deprecated
    add_cflags -W${armcc_opt},--diag_suppress=2523
    add_cflags -W${armcc_opt},--diag_suppress=1207
    add_cflags -W${armcc_opt},--diag_suppress=1293 # assignment in condition
    add_cflags -W${armcc_opt},--diag_suppress=3343 # hardfp compat
    add_cflags -W${armcc_opt},--diag_suppress=167  # pointer sign
    add_cflags -W${armcc_opt},--diag_suppress=513  # pointer sign
elif enabled tms470; then
    add_cflags -pds=824 -pds=837
elif enabled pathscale; then
    add_cflags -fstrict-overflow -OPT:wrap_around_unsafe_opt=OFF
elif enabled msvc; then
    enabled x86_32 && disable aligned_stack
fi

enabled_any $THREADS_LIST      && enable threads

enabled asm || { arch=c; disable $ARCH_LIST $ARCH_EXT_LIST; }

check_deps $CONFIG_LIST       \
           $CONFIG_EXTRA      \
           $HAVE_LIST         \
           $ALL_COMPONENTS    \
           $ALL_TESTS         \


if test $target_os = "haiku"; then
    disable memalign
    disable posix_memalign
fi

! enabled_any memalign posix_memalign aligned_malloc &&
    enabled_any $need_memalign && enable memalign_hack

# add_dep lib dep
# -> enable ${lib}_deps_${dep}
# -> add $dep to ${lib}_deps only once
add_dep() {
    lib=$1
    dep=$2
    enabled "${lib}_deps_${dep}" && return 0
    enable  "${lib}_deps_${dep}"
    prepend "${lib}_deps" $dep
}

# merge deps lib components
# merge all ${component}_deps into ${lib}_deps and ${lib}_deps_*
merge_deps() {
    lib=$1
    shift
    for comp in $*; do
        enabled $comp || continue
        eval "dep=\"\$${comp}_deps\""
        for d in $dep; do
            add_dep $lib $d
        done
    done
}

merge_deps libavfilter $FILTER_LIST

echo "install prefix            $prefix"
echo "source path               $source_path"
echo "C compiler                $cc"
echo "ARCH                      $arch ($cpu)"
if test "$build_suffix" != ""; then
    echo "build suffix              $build_suffix"
fi
if test "$progs_suffix" != ""; then
    echo "progs suffix              $progs_suffix"
fi
if test "$extra_version" != ""; then
    echo "version string suffix     $extra_version"
fi
echo "big-endian                ${bigendian-no}"
echo "runtime cpu detection     ${runtime_cpudetect-no}"
if enabled x86; then
    echo "${yasmexe}                      ${yasm-no}"
    echo "MMX enabled               ${mmx-no}"
    echo "MMXEXT enabled            ${mmxext-no}"
    echo "3DNow! enabled            ${amd3dnow-no}"
    echo "3DNow! extended enabled   ${amd3dnowext-no}"
    echo "SSE enabled               ${sse-no}"
    echo "SSSE3 enabled             ${ssse3-no}"
    echo "AVX enabled               ${avx-no}"
    echo "FMA4 enabled              ${fma4-no}"
    echo "CMOV enabled              ${cmov-no}"
    echo "CMOV is fast              ${fast_cmov-no}"
    echo "EBX available             ${ebx_available-no}"
    echo "EBP available             ${ebp_available-no}"
fi
if enabled arm; then
    echo "ARMv5TE enabled           ${armv5te-no}"
    echo "ARMv6 enabled             ${armv6-no}"
    echo "ARMv6T2 enabled           ${armv6t2-no}"
    echo "ARM VFP enabled           ${armvfp-no}"
    echo "NEON enabled              ${neon-no}"
fi
if enabled mips; then
    echo "MIPS FPU enabled          ${mipsfpu-no}"
    echo "MIPS32R2 enabled          ${mips32r2-no}"
    echo "MIPS DSP R1 enabled       ${mipsdspr1-no}"
    echo "MIPS DSP R2 enabled       ${mipsdspr2-no}"
fi
if enabled ppc; then
    echo "AltiVec enabled           ${altivec-no}"
    echo "PPC 4xx optimizations     ${ppc4xx-no}"
    echo "dcbzl available           ${dcbzl-no}"
fi
if enabled sparc; then
    echo "VIS enabled               ${vis-no}"
fi
echo "debug symbols             ${debug-no}"
echo "strip symbols             ${stripping-no}"
echo "optimize for size         ${small-no}"
echo "optimizations             ${optimizations-no}"
echo "static                    ${static-no}"
echo "shared                    ${shared-no}"
echo "postprocessing support    ${postproc-no}"
echo "new filter support        ${avfilter-no}"
echo "network support           ${network-no}"
echo "threading support         ${thread_type-no}"
echo "safe bitstream reader     ${safe_bitstream_reader-no}"
echo "SDL support               ${sdl-no}"
echo "libdxva2 enabled          ${dxva2-no}"
echo "libva enabled             ${vaapi-no}"
echo "libvdpau enabled          ${vdpau-no}"
echo "AVISynth enabled          ${avisynth-no}"
echo "frei0r enabled            ${frei0r-no}"
echo "gnutls enabled            ${gnutls-no}"
echo "libaacplus enabled        ${libaacplus-no}"
echo "libass enabled            ${libass-no}"
echo "libcaca enabled           ${libcaca-no}"
echo "libcdio support           ${libcdio-no}"
echo "libcelt enabled           ${libcelt-no}"
echo "libdc1394 support         ${libdc1394-no}"
echo "libfaac enabled           ${libfaac-no}"
echo "libfdk-aac enabled        ${libfdk_aac-no}"
echo "libgsm enabled            ${libgsm-no}"
echo "libiec61883 support       ${libiec61883-no}"
echo "libilbc enabled           ${libilbc-no}"
echo "libmodplug enabled        ${libmodplug-no}"
echo "libmp3lame enabled        ${libmp3lame-no}"
echo "libnut enabled            ${libnut-no}"
echo "libopencore-amrnb support ${libopencore_amrnb-no}"
echo "libopencore-amrwb support ${libopencore_amrwb-no}"
echo "libopencv support         ${libopencv-no}"
echo "libopenjpeg enabled       ${libopenjpeg-no}"
echo "libopus enabled           ${libopus-no}"
echo "libpulse enabled          ${libpulse-no}"
echo "librtmp enabled           ${librtmp-no}"
echo "libschroedinger enabled   ${libschroedinger-no}"
echo "libspeex enabled          ${libspeex-no}"
echo "libstagefright-h264 enabled    ${libstagefright_h264-no}"
echo "libtheora enabled         ${libtheora-no}"
echo "libtwolame enabled        ${libtwolame-no}"
echo "libutvideo enabled        ${libutvideo-no}"
echo "libv4l2 enabled           ${libv4l2-no}"
echo "libvo-aacenc support      ${libvo_aacenc-no}"
echo "libvo-amrwbenc support    ${libvo_amrwbenc-no}"
echo "libvorbis enabled         ${libvorbis-no}"
echo "libvpx enabled            ${libvpx-no}"
echo "libx264 enabled           ${libx264-no}"
echo "libxavs enabled           ${libxavs-no}"
echo "libxvid enabled           ${libxvid-no}"
echo "openal enabled            ${openal-no}"
echo "openssl enabled           ${openssl-no}"
echo "zlib enabled              ${zlib-no}"
echo "bzlib enabled             ${bzlib-no}"
echo "texi2html enabled         ${texi2html-no}"
echo "perl enabled              ${perl-no}"
echo "pod2man enabled           ${pod2man-no}"
echo "makeinfo enabled          ${makeinfo-no}"
test -n "$random_seed" &&
    echo "random seed               ${random_seed}"
echo

for type in decoder encoder hwaccel parser demuxer muxer protocol filter bsf indev outdev; do
    echo "Enabled ${type}s:"
    eval list=\$$(toupper $type)_LIST
    print_enabled '_*' $list | sort | pr -r -3 -t
    echo
done

license="LGPL version 2.1 or later"
if enabled nonfree; then
    license="nonfree and unredistributable"
elif enabled gplv3; then
    license="GPL version 3 or later"
elif enabled lgplv3; then
    license="LGPL version 3 or later"
elif enabled gpl; then
    license="GPL version 2 or later"
fi

echo "License: $license"

echo "Creating config.mak and config.h..."

test -e Makefile || $ln_s "$source_path/Makefile" .

enabled stripping || strip="echo skipping strip"

config_files="$TMPH config.mak"

cat > config.mak <<EOF
# Automatically generated by configure - do not modify!
ifndef FFMPEG_CONFIG_MAK
FFMPEG_CONFIG_MAK=1
FFMPEG_CONFIGURATION=$FFMPEG_CONFIGURATION
prefix=$prefix
LIBDIR=\$(DESTDIR)$libdir
SHLIBDIR=\$(DESTDIR)$shlibdir
INCDIR=\$(DESTDIR)$incdir
BINDIR=\$(DESTDIR)$bindir
DATADIR=\$(DESTDIR)$datadir
MANDIR=\$(DESTDIR)$mandir
SRC_PATH=$source_path
ifndef MAIN_MAKEFILE
SRC_PATH:=\$(SRC_PATH:.%=..%)
endif
CC_IDENT=$cc_ident
ARCH=$arch
CC=$cc
CXX=$cxx
AS=$as
LD=$ld
DEPCC=$dep_cc
DEPCCFLAGS=$DEPCCFLAGS \$(CPPFLAGS)
DEPAS=$as
DEPASFLAGS=$DEPASFLAGS \$(CPPFLAGS)
YASM=$yasmexe
DEPYASM=$yasmexe
AR=$ar
ARFLAGS=$arflags
AR_O=$ar_o
RANLIB=$ranlib
CP=cp -p
LN_S=$ln_s
STRIP=$strip
CPPFLAGS=$CPPFLAGS
CFLAGS=$CFLAGS
CXXFLAGS=$CXXFLAGS
ASFLAGS=$ASFLAGS
AS_C=$AS_C
AS_O=$AS_O
CC_C=$CC_C
CC_O=$CC_O
CXX_C=$CXX_C
CXX_O=$CXX_O
LD_O=$LD_O
LD_LIB=$LD_LIB
LD_PATH=$LD_PATH
DLLTOOL=$dlltool
LDFLAGS=$LDFLAGS
LDFLAGS-ffserver=$FFSERVERLDFLAGS
SHFLAGS=$SHFLAGS
YASMFLAGS=$YASMFLAGS
BUILDSUF=$build_suffix
PROGSSUF=$progs_suffix
FULLNAME=$FULLNAME
LIBPREF=$LIBPREF
LIBSUF=$LIBSUF
LIBNAME=$LIBNAME
SLIBPREF=$SLIBPREF
SLIBSUF=$SLIBSUF
EXESUF=$EXESUF
EXTRA_VERSION=$extra_version
CCDEP=$CCDEP
CXXDEP=$CXXDEP
CCDEP_FLAGS=$CCDEP_FLAGS
ASDEP=$ASDEP
ASDEP_FLAGS=$ASDEP_FLAGS
CC_DEPFLAGS=$CC_DEPFLAGS
AS_DEPFLAGS=$AS_DEPFLAGS
HOSTCC=$host_cc
HOSTLD=$host_ld
HOSTCFLAGS=$host_cflags
HOSTEXESUF=$HOSTEXESUF
HOSTLDFLAGS=$host_ldflags
HOSTLIBS=$host_libs
DEPHOSTCC=$host_cc
DEPHOSTCCFLAGS=$DEPHOSTCCFLAGS \$(HOSTCCFLAGS)
HOSTCCDEP=$HOSTCCDEP
HOSTCCDEP_FLAGS=$HOSTCCDEP_FLAGS
HOSTCC_DEPFLAGS=$HOSTCC_DEPFLAGS
HOSTCC_C=$HOSTCC_C
HOSTCC_O=$HOSTCC_O
HOSTLD_O=$HOSTLD_O
TARGET_EXEC=$target_exec
TARGET_PATH=$target_path
LIBS-ffplay=$sdl_libs
CFLAGS-ffplay=$sdl_cflags
ZLIB=$($ldflags_filter -lz)
LIB_INSTALL_EXTRA_CMD=$LIB_INSTALL_EXTRA_CMD
EXTRALIBS=$extralibs
INSTALL=$install
LIBTARGET=${LIBTARGET}
SLIBNAME=${SLIBNAME}
SLIBNAME_WITH_VERSION=${SLIBNAME_WITH_VERSION}
SLIBNAME_WITH_MAJOR=${SLIBNAME_WITH_MAJOR}
SLIB_CREATE_DEF_CMD=${SLIB_CREATE_DEF_CMD}
SLIB_EXTRA_CMD=${SLIB_EXTRA_CMD}
SLIB_INSTALL_NAME=${SLIB_INSTALL_NAME}
SLIB_INSTALL_LINKS=${SLIB_INSTALL_LINKS}
SLIB_INSTALL_EXTRA_LIB=${SLIB_INSTALL_EXTRA_LIB}
SLIB_INSTALL_EXTRA_SHLIB=${SLIB_INSTALL_EXTRA_SHLIB}
SAMPLES:=${samples:-\$(FATE_SAMPLES)}
NOREDZONE_FLAGS=$noredzone_flags
EOF

get_version(){
    lcname=$1
    name=$(toupper $lcname)
    file=$source_path/$lcname/version.h
    eval $(grep "#define ${name}_VERSION_M" "$file" | awk '{ print $2"="$3 }')
    eval ${name}_VERSION=\$${name}_VERSION_MAJOR.\$${name}_VERSION_MINOR.\$${name}_VERSION_MICRO
    eval echo "${lcname}_VERSION=\$${name}_VERSION" >> config.mak
    eval echo "${lcname}_VERSION_MAJOR=\$${name}_VERSION_MAJOR" >> config.mak
}

get_version_old(){
    name=$1
    file=$source_path/$2
# This condition will be removed when we stop supporting old libpostproc versions
if ! test "$name" = LIBPOSTPROC || test "$postproc_version" = current; then
    eval $(grep "#define ${name}_VERSION_M" "$file" | awk '{ print $2"="$3 }')
    eval ${name}_VERSION=\$${name}_VERSION_MAJOR.\$${name}_VERSION_MINOR.\$${name}_VERSION_MICRO
fi
    lcname=$(tolower $name)
    eval echo "${lcname}_VERSION=\$${name}_VERSION" >> config.mak
    eval echo "${lcname}_VERSION_MAJOR=\$${name}_VERSION_MAJOR" >> config.mak
}

get_version_old LIBPOSTPROC libpostproc/version.h

get_version libavcodec
get_version libavdevice
get_version libavfilter
get_version libavformat
get_version libavresample
get_version libavutil
get_version libswresample
get_version libswscale

cat > $TMPH <<EOF
/* Automatically generated by configure - do not modify! */
#ifndef FFMPEG_CONFIG_H
#define FFMPEG_CONFIG_H
#define FFMPEG_CONFIGURATION "$(c_escape $FFMPEG_CONFIGURATION)"
#define FFMPEG_LICENSE "$(c_escape $license)"
#define FFMPEG_DATADIR "$(eval c_escape $datadir)"
#define AVCONV_DATADIR "$(eval c_escape $datadir)"
#define CC_IDENT "$(c_escape ${cc_ident:-Unknown compiler})"
#define av_restrict $_restrict
#define EXTERN_PREFIX "${extern_prefix}"
#define EXTERN_ASM ${extern_prefix}
#define SLIBSUF "$SLIBSUF"
#define HAVE_MMX2 HAVE_MMXEXT
EOF

test -n "$assert_level" &&
    echo "#define ASSERT_LEVEL $assert_level" >>$TMPH

test -n "$malloc_prefix" &&
    echo "#define MALLOC_PREFIX $malloc_prefix" >>$TMPH

if enabled yasm; then
    append config_files $TMPASM
    printf '' >$TMPASM
fi

print_config ARCH_   "$config_files" $ARCH_LIST
print_config HAVE_   "$config_files" $HAVE_LIST
print_config CONFIG_ "$config_files" $CONFIG_LIST       \
                                     $CONFIG_EXTRA      \
                                     $ALL_COMPONENTS    \

cat >>config.mak <<EOF
LAVF_FATE_TESTS=$(print_enabled -n _test $LAVF_FATE_TESTS)
LAVF_TESTS=$(print_enabled   -n _test $LAVF_TESTS)
LAVFI_TESTS=$(print_enabled  -n _test $LAVFI_TESTS)
SEEK_TESTS=$(print_enabled   -n _test $SEEK_TESTS)
EOF

echo "#endif /* FFMPEG_CONFIG_H */" >> $TMPH
echo "endif # FFMPEG_CONFIG_MAK" >> config.mak

# Do not overwrite an unchanged config.h to avoid superfluous rebuilds.
cp_if_changed $TMPH config.h
touch .config

enabled yasm && cp_if_changed $TMPASM config.asm

cat > $TMPH <<EOF
/* Generated by ffconf */
#ifndef AVUTIL_AVCONFIG_H
#define AVUTIL_AVCONFIG_H
EOF

test "$postproc_version" != current && cat >> $TMPH <<EOF
#define LIBPOSTPROC_VERSION_MAJOR $LIBPOSTPROC_VERSION_MAJOR
#define LIBPOSTPROC_VERSION_MINOR $LIBPOSTPROC_VERSION_MINOR
#define LIBPOSTPROC_VERSION_MICRO $LIBPOSTPROC_VERSION_MICRO
EOF

print_config AV_HAVE_ $TMPH $HAVE_LIST_PUB

echo "#endif /* AVUTIL_AVCONFIG_H */" >> $TMPH

cp_if_changed $TMPH libavutil/avconfig.h

test -n "$WARNINGS" && printf "\n$WARNINGS"

# build pkg-config files

pkgconfig_generate(){
    name=$1
    shortname=${name#lib}${build_suffix}
    comment=$2
    version=$3
    libs=$4
    requires=$5
    enabled ${name#lib} || return 0
    mkdir -p $name
    cat <<EOF > $name/$name.pc
prefix=$prefix
exec_prefix=\${prefix}
libdir=$libdir
includedir=$incdir

Name: $name
Description: $comment
Version: $version
Requires: $(enabled shared || echo $requires)
Requires.private: $(enabled shared && echo $requires)
Conflicts:
Libs: -L\${libdir} -l${shortname} $(enabled shared || echo $libs)
Libs.private: $(enabled shared && echo $libs)
Cflags: -I\${includedir}
EOF

mkdir -p doc/examples/pc-uninstalled
includedir=${source_path}
[ "$includedir" = . ] && includedir="\${pcfiledir}/../../.."
    cat <<EOF > doc/examples/pc-uninstalled/$name.pc
prefix=
exec_prefix=
libdir=\${pcfiledir}/../../../$name
includedir=${includedir}

Name: $name
Description: $comment
Version: $version
Requires: $requires
Conflicts:
Libs: -L\${libdir} -l${shortname} $(enabled shared || echo $libs)
Cflags: -I\${includedir}
EOF
}

libavfilter_pc_deps=""
enabled libavfilter_deps_avcodec    && prepend libavfilter_pc_deps "libavcodec = $LIBAVCODEC_VERSION,"
enabled libavfilter_deps_avformat   && prepend libavfilter_pc_deps "libavformat = $LIBAVFORMAT_VERSION,"
enabled libavfilter_deps_swscale    && prepend libavfilter_pc_deps "libswscale = $LIBSWSCALE_VERSION,"
enabled libavfilter_deps_swresample && prepend libavfilter_pc_deps "libswresample = $LIBSWRESAMPLE_VERSION,"
enabled libavfilter_deps_postproc   && prepend libavfilter_pc_deps "libpostproc = $LIBPOSTPROC_VERSION,"
libavfilter_pc_deps=${libavfilter_pc_deps%, }

libavdevice_pc_deps="libavformat = $LIBAVFORMAT_VERSION"
enabled lavfi_indev && prepend libavdevice_pc_deps "libavfilter = $LIBAVFILTER_VERSION,"

pkgconfig_generate libavutil "FFmpeg utility library" "$LIBAVUTIL_VERSION" "$LIBM"
pkgconfig_generate libavcodec "FFmpeg codec library" "$LIBAVCODEC_VERSION" "$extralibs" "libavutil = $LIBAVUTIL_VERSION"
pkgconfig_generate libavformat "FFmpeg container format library" "$LIBAVFORMAT_VERSION" "$extralibs" "libavcodec = $LIBAVCODEC_VERSION"
pkgconfig_generate libavdevice "FFmpeg device handling library" "$LIBAVDEVICE_VERSION" "$extralibs" "$libavdevice_pc_deps"
pkgconfig_generate libavfilter "FFmpeg video filtering library" "$LIBAVFILTER_VERSION" "$extralibs" "$libavfilter_pc_deps"
pkgconfig_generate libpostproc "FFmpeg postprocessing library" "$LIBPOSTPROC_VERSION" "" "libavutil = $LIBAVUTIL_VERSION"
pkgconfig_generate libavresample "Libav audio resampling library" "$LIBAVRESAMPLE_VERSION" "$extralibs"
pkgconfig_generate libswscale "FFmpeg image rescaling library" "$LIBSWSCALE_VERSION" "$LIBM" "libavutil = $LIBAVUTIL_VERSION"
pkgconfig_generate libswresample "FFmpeg audio rescaling library" "$LIBSWRESAMPLE_VERSION" "$LIBM" "libavutil = $LIBAVUTIL_VERSION"

fix_ffmpeg_remote(){
    git_remote_from=$1
    git_remote_to=$2
    fixme_remote=$(git --git-dir=$source_path/.git --work-tree=$source_path remote -v | grep $git_remote_from | cut -f 1 | sort | uniq)
    if [ "$fixme_remote" != "" ]; then
        echolog "
Outdated domain in git config, the official domain for ffmpeg git is since
November 2011, source.ffmpeg.org, both the old and the new point to the same
repository and server. To update it enter the following commands:
"
        for remote in $fixme_remote; do
            echolog "git remote set-url $remote $git_remote_to"
        done
    fi
}

if test -f "$source_path/.git/config"; then
    remote_from=git.videolan.org
    remote_to=source.ffmpeg.org
    fix_ffmpeg_remote git@$remote_from:ffmpeg   git@$remote_to:ffmpeg
    fix_ffmpeg_remote git://$remote_from/ffmpeg git://$remote_to/ffmpeg
fi