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

 show_help(){

 cat <<EOF
 Usage: configure [options]
 Options: [defaults in brackets after descriptions]
 
 Standard options:
   --help                   print this message

   --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]
 
 Configuration options:
   --disable-static         do not build static libraries [no]
   --enable-shared          build shared libraries [no]
   --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]
   --disable-doc            do not build documentation
   --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-swscale        disable libswscale build

   --disable-postproc       disable libpostproc build

   --disable-avfilter       disable video filter support [no]

   --disable-pthreads       disable pthreads [auto]

   --enable-w32threads      use Win32 threads [no]
   --enable-x11grab         enable X11 grabbing [no]
   --disable-network        disable network support [no]
   --enable-gray            enable full grayscale support (slower color)
   --disable-swscale-alpha  disable alpha channel support in swscale
   --disable-fastdiv        disable table-based division
   --enable-small           optimize for size instead of speed
   --disable-aandct         disable AAN DCT code

   --disable-dct            disable DCT code

   --disable-fft            disable FFT code
   --disable-golomb         disable Golomb code

   --disable-huffman        disable Huffman code

   --disable-lpc            disable LPC code
   --disable-mdct           disable MDCT code
   --disable-rdft           disable RDFT code

   --enable-vaapi           enable VAAPI code

   --enable-vdpau           enable VDPAU code

   --disable-dxva2          disable DXVA2 code

   --enable-runtime-cpudetect detect cpu capabilities at runtime (bigger binary)
   --enable-hardcoded-tables use hardcoded tables instead of runtime generation
   --enable-memalign-hack   emulate memalign, interferes with memory debuggers

   --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
   --disable-indev=NAME     disable input device NAME
   --disable-outdev=NAME    disable output device NAME
   --disable-indevs         disable input devices
   --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
   --list-decoders          show all available decoders
   --list-encoders          show all available encoders
   --list-hwaccels          show all available hardware accelerators
   --list-muxers            show all available muxers
   --list-demuxers          show all available demuxers
   --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
 
 External library support:
   --enable-avisynth        enable reading of AVISynth script files [no]
   --enable-bzlib           enable bzlib [autodetect]

   --enable-libcelt         enable CELT/Opus decoding via libcelt [no]

   --enable-frei0r          enable frei0r video filtering

   --enable-libaacplus      enable AAC+ encoding via libaacplus [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-libdc1394       enable IIDC-1394 grabbing using libdc1394
                            and libraw1394 [no]
   --enable-libdirac        enable Dirac support via libdirac [no]
   --enable-libfaac         enable FAAC support via libfaac [no]

   --enable-libfreetype     enable libfreetype [no]

   --enable-libgsm          enable GSM support via libgsm [no]
   --enable-libmp3lame      enable MP3 encoding via libmp3lame [no]
   --enable-libnut          enable NUT (de)muxing via libnut,
                            native (de)muxer exists [no]
   --enable-libopenjpeg     enable JPEG 2000 decoding via OpenJPEG [no]

   --enable-librtmp         enable RTMP[E] support via librtmp [no]

   --enable-libschroedinger enable Dirac support via libschroedinger [no]

   --enable-libspeex        enable Speex encoding and decoding via libspeex [no]

   --enable-libtheora       enable Theora encoding via libtheora [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 encoding via libvorbis,
                            native implementation exists [no]

   --enable-libvpx          enable VP8 support 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-mlib            enable Sun medialib [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
   --nm=NM                  use nm tool

   --ar=AR                  use archive tool AR [$ar_default]

   --as=AS                  use assembler AS [$as_default]
   --cc=CC                  use C compiler CC [$cc_default]
   --ld=LD                  use linker LD
   --host-cc=HOSTCC         use host C compiler HOSTCC
   --host-cflags=HCFLAGS    use HCFLAGS when compiling for host
   --host-ldflags=HLDFLAGS  use HLDFLAGS when linking for host
   --host-libs=HLIBS        use libs HLIBS when linking for host
   --extra-cflags=ECFLAGS   add ECFLAGS to CFLAGS [$CFLAGS]
   --extra-ldflags=ELDFLAGS add ELDFLAGS to LDFLAGS [$LDFLAGS]
   --extra-libs=ELIBS       add ELIBS [$ELIBS]
   --extra-version=STRING   version string suffix []
   --build-suffix=SUFFIX    library name suffix []
   --arch=ARCH              select architecture [$arch]
   --cpu=CPU                select the minimum required CPU (affects
                            instruction selection, may crash on older CPUs)

   --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-mmx2           disable MMX2 optimizations
   --disable-sse            disable SSE optimizations
   --disable-ssse3          disable SSSE3 optimizations

   --disable-avx            disable AVX optimizations

   --disable-armv5te        disable armv5te optimizations
   --disable-armv6          disable armv6 optimizations
   --disable-armv6t2        disable armv6t2 optimizations
   --disable-armvfp         disable ARM VFP optimizations
   --disable-iwmmxt         disable iwmmxt optimizations
   --disable-mmi            disable MMI optimizations
   --disable-neon           disable neon optimizations
   --disable-vis            disable VIS optimizations
   --disable-yasm           disable use of yasm assembler
   --enable-pic             build position-independent code

   --malloc-prefix=PFX      prefix malloc and related names with PFX

   --enable-sram            allow use of on-chip SRAM

   --disable-symver         disable symbol versioning

 Developer options (useful when working on FFmpeg itself):

   --disable-debug          disable debugging symbols
   --enable-debug=LEVEL     set the debug level [$debuglevel]
   --disable-optimizations  disable compiler optimizations
   --enable-extra-warnings  enable more compiler warnings

   --disable-stripping      disable stripping of executables and shared libraries

   --samples=PATH           location of test samples for FATE, if not set use
                            \$FATE_SAMPLES at make invocation time.

 
 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

 }
 

 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 && echo "%define $2"
 }
 

 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 "$1" = -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 $($filter_cppflags "$@")

 }
 

 add_cflags(){

     append CFLAGS $($filter_cflags "$@")

 }
 

 add_asflags(){

     append ASFLAGS $($filter_asflags "$@")

 }
 

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

     prepend extralibs "$@"

 }
 

 check_cmd(){

     log "$@"

     "$@" >> $logfile 2>&1

 }
 

 check_cc(){

     log check_cc "$@"

     cat > $TMPC

     log_file $TMPC

     check_cmd $cc $CPPFLAGS $CFLAGS "$@" -c -o $TMPO $TMPC

 }
 
 check_cpp(){
     log check_cpp "$@"

     cat > $TMPC

     log_file $TMPC

     check_cmd $cc $CPPFLAGS $CFLAGS "$@" -E -o $TMPO $TMPC

 }
 

 check_as(){
     log check_as "$@"
     cat > $TMPC
     log_file $TMPC

     check_cmd $as $CPPFLAGS $ASFLAGS "$@" -c -o $TMPO $TMPC

 }
 

 check_asm(){
     log check_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 "$@" -o $TMPO $TMPS
 }
 

 check_ld(){

     log check_ld "$@"

     flags=''
     libs=''
     for f; do
         test "${f}" = "${f#-l}" && flags="$flags $f" || libs="$libs $f"
     done

     check_cc $($filter_cflags $flags) || return

     check_cmd $ld $LDFLAGS $flags -o $TMPE $TMPO $libs $extralibs

 }
 

 check_cppflags(){
     log check_cppflags "$@"

     set -- $($filter_cppflags "$@")
     check_cc "$@" <<EOF && append CPPFLAGS "$@"

 int x;
 EOF
 }
 

 check_cflags(){

     log check_cflags "$@"

     set -- $($filter_cflags "$@")
     check_cc "$@" <<EOF && append CFLAGS "$@"

 int x;
 EOF
 }
 

 test_ldflags(){
     log test_ldflags "$@"
     check_ld "$@" <<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 "$@" <<EOF && enable $func

 extern int $func();

 int main(void){ $func(); }

 EOF
 }
 

 check_mathfunc(){

     log check_mathfunc "$@"

     func=$1
     shift
     disable $func
     check_ld "$@" <<EOF && enable $func
 #include <math.h>

 float foo(float f) { return $func(f); }
 int main(void){ return 0; }

 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 "$@" && enable $funcs && enable_safe $headers

 }
 

 check_cpp_condition(){
     log check_cpp_condition "$@"
     header=$1
     condition=$2

     shift 2
     check_cpp $($filter_cppflags "$@") <<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_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 "$@" && { 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 main(void){

     signal(SIGILL, sighandler);
     signal(SIGFPE, sighandler);
     signal(SIGSEGV, sighandler);
 #ifdef SIGBUS
     signal(SIGBUS, sighandler);
 #endif
     { $code }
 }
 EOF
 }
 

 check_type(){
     log check_type "$@"
     headers=$1
     type=$2
     shift 2

     disable_safe "$type"

     incs=""
     for hdr in $headers; do
         incs="$incs
 #include <$hdr>"
     done

     check_cc "$@" <<EOF && enable_safe "$type"

 $incs
 $type v;
 EOF
 }
 

 check_struct(){
     log check_type "$@"
     headers=$1
     struct=$2
     member=$3
     shift 3
     disable_safe "${struct}_${member}"
     incs=""
     for hdr in $headers; do
         incs="$incs
 #include <$hdr>"
     done
     check_cc "$@" <<EOF && enable_safe "${struct}_${member}"
 $incs
 const void *p = &(($struct *)0)->$member;
 EOF
 }
 

 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_pkg_config(){
     pkg="$1"
     check_pkg_config "$@" || die "ERROR: $pkg not found"
     add_cflags    $(get_safe ${pkg}_cflags)
     add_extralibs $(get_safe ${pkg}_libs)
 }
 

 check_host_cc(){
     log check_host_cc "$@"
     cat > $TMPC
     log_file $TMPC
     check_cmd $host_cc $host_cflags "$@" -c -o $TMPO $TMPC
 }
 
 check_host_cflags(){
     log check_host_cflags "$@"
     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" ||
         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
 "
 
 CONFIG_LIST="
     $COMPONENT_LIST

     aandct

     ac3dsp

     avcodec
     avdevice

     avfilter

     avformat

     avisynth

     bzlib

     crystalhd

     dct

     doc

     dwt

     dxva2

     fastdiv

     ffmpeg
     ffplay

     ffprobe

     ffserver

     fft

     frei0r

     golomb

     gpl

     gray

     h264dsp

     h264pred

     hardcoded_tables

     huffman

     libaacplus
     libcdio

     libcelt

     libdc1394

     libdirac

     libfaac

     libfreetype

     libgsm

     libmp3lame

     libnut

     libopencore_amrnb
     libopencore_amrwb

     libopencv

     libopenjpeg

     librtmp

     libschroedinger

     libspeex

     libtheora

     libvo_aacenc

     libvo_amrwbenc

     libvorbis

     libvpx

     libx264

     libxavs

     libxvid

     lpc

     lsp

     mdct

     memalign_hack

     mlib

     mpegaudiodsp

     network

     nonfree

     pic

     postproc

     rdft

     rtpdec

     runtime_cpudetect

     shared

     sinewin

     small

     sram

     static

     swscale

     swscale_alpha

     vaapi
     vdpau

     version3

     x11grab

     zlib

 "

 THREADS_LIST='
     pthreads
     w32threads
 '
 

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

     altivec

     amd3dnow

     amd3dnowext

     armv5te

     armv6

     armv6t2

     armvfp

     avx

     iwmmxt
     mmi
     mmx

     mmx2

     neon

     ppc4xx

     sse

     ssse3

     vfpv3

     vis

 '
 

 HAVE_LIST_PUB='
     bigendian

     fast_unaligned

 '
 

 HAVE_LIST="
     $ARCH_EXT_LIST

     $HAVE_LIST_PUB

     $THREADS_LIST

     aligned_stack

     alsa_asoundlib_h

     altivec_h

     arpa_inet_h

     attribute_may_alias

     attribute_packed

     bswap

     closesocket

     cmov

     dcbzl

     dev_bktr_ioctl_bt848_h
     dev_bktr_ioctl_meteor_h
     dev_ic_bt8xx_h
     dev_video_meteor_ioctl_meteor_h
     dev_video_bktr_ioctl_bt848_h

     dlfcn_h

     dlopen

     dos_paths

     ebp_available
     ebx_available

     exp2
     exp2f

     fast_64bit

     fast_clz

     fast_cmov

     fcntl

     fork

     getaddrinfo

     gethrtime

     GetProcessMemoryInfo

     GetProcessTimes

     getrusage

     gnu_as

     struct_rusage_ru_maxrss

     ibm_asm

     inet_aton

     inline_asm

     isatty

     kbhit

     ldbrx

     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

     malloc_h

     MapViewOfFile

     memalign

     mkstemp

     mmap

     pld

     posix_memalign

     round
     roundf

     sdl
     sdl_video_size

     setmode

     sndio_h

     socklen_t

     soundcard_h

     poll_h

     setrlimit

     strerror_r

     strtok_r

     struct_addrinfo

     struct_ipv6_mreq
     struct_sockaddr_in6

     struct_sockaddr_sa_len

     struct_sockaddr_storage

     symver
     symver_gnu_asm
     symver_asm_label

     sys_mman_h

     sys_resource_h

     sys_select_h

     sys_soundcard_h

     sys_videoio_h

     ten_operands

     termios_h

     threads

     trunc

     truncf

     vfp_args

     VirtualAlloc

     winsock2_h

     xform_asm

     xmm_clobbers

     yasm

 "

 # options emitted with CONFIG_ prefix but not available on command line
 CONFIG_EXTRA="

     avutil

     gplv3
     lgplv3

 "
 

 CMDLINE_SELECT="

     $ARCH_EXT_LIST

     $CONFIG_LIST

     $THREADS_LIST

     asm

     cross_compile

     debug
     extra_warnings

     logging

     optimizations

     stripping

     symver

     yasm

 "

 
 PATHS_LIST='

     bindir

     datadir

     incdir
     libdir
     mandir
     prefix
     shlibdir

 '
 
 CMDLINE_SET="
     $PATHS_LIST

     ar

     arch

     as

     build_suffix
     cc
     cpu
     cross_prefix

     dep_cc

     extra_version

     host_cc
     host_cflags
     host_ldflags
     host_libs

     host_os

     install

     ld

     logfile

     malloc_prefix

     nm

     pkg_config

     samples

     strip

     sysinclude
     sysroot

     target_exec

     target_os

     target_path

 "

 CMDLINE_APPEND="
     extra_cflags
 "
 

 # code dependency declarations
 

 # architecture extensions

 armv5te_deps="arm"
 armv6_deps="arm"

 armv6t2_deps="arm"

 armvfp_deps="arm"
 iwmmxt_deps="arm"

 neon_deps="arm"

 vfpv3_deps="armvfp"

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

 mmx2_deps="mmx"
 sse_deps="mmx"
 ssse3_deps="sse"

 avx_deps="ssse3"

 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"

 need_memalign="altivec neon sse"

 inline_asm_deps="!tms470"

 symver_if_any="symver_asm_label symver_gnu_asm"
 

 # subsystems

 dct_select="rdft"

 mdct_select="fft"
 rdft_select="fft"

 mpegaudiodsp_select="dct"

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

 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"

 cook_decoder_select="mdct sinewin"

 cscd_decoder_suggest="zlib"

 dca_decoder_select="mdct"

 dnxhd_encoder_select="aandct"

 dxa_decoder_select="zlib"

 eac3_decoder_select="ac3_decoder"

 eac3_encoder_select="mdct ac3dsp"

 eamad_decoder_select="aandct"

 eatgq_decoder_select="aandct"

 eatqi_decoder_select="aandct"

 ffv1_decoder_select="golomb"
 flac_decoder_select="golomb"

 flac_encoder_select="golomb lpc"

 flashsv_decoder_select="zlib"
 flashsv_encoder_select="zlib"

 flashsv2_encoder_select="zlib"

 flv_decoder_select="h263_decoder"

 flv_encoder_select="h263_encoder"

 fraps_decoder_select="huffman"

 h261_encoder_select="aandct"

 h263_decoder_select="h263_parser"

 h263_encoder_select="aandct"

 h263_vaapi_hwaccel_select="vaapi h263_decoder"

 h263i_decoder_select="h263_decoder"

 h263p_encoder_select="h263_encoder"

 h264_decoder_select="golomb h264dsp h264pred"

 h264_crystalhd_decoder_select="crystalhd h264_mp4toannexb_bsf h264_parser"

 h264_dxva2_hwaccel_deps="dxva2api_h"
 h264_dxva2_hwaccel_select="dxva2 h264_decoder"

 h264_vaapi_hwaccel_select="vaapi"

 h264_vdpau_decoder_select="vdpau h264_decoder"

 imc_decoder_select="fft mdct sinewin"

 jpegls_decoder_select="golomb"
 jpegls_encoder_select="golomb"

 ljpeg_encoder_select="aandct"

 loco_decoder_select="golomb"

 mjpeg_encoder_select="aandct"

 mlp_decoder_select="mlp_parser"

 mp1_decoder_select="mpegaudiodsp"
 mp2_decoder_select="mpegaudiodsp"
 mp3adu_decoder_select="mpegaudiodsp"
 mp3_decoder_select="mpegaudiodsp"
 mp3on4_decoder_select="mpegaudiodsp"
 mp1float_decoder_select="mpegaudiodsp"
 mp2float_decoder_select="mpegaudiodsp"
 mp3adufloat_decoder_select="mpegaudiodsp"
 mp3float_decoder_select="mpegaudiodsp"
 mp3on4float_decoder_select="mpegaudiodsp"

 mpeg1video_encoder_select="aandct"
 mpeg2video_encoder_select="aandct"

 mpeg4_decoder_select="h263_decoder mpeg4video_parser"

 mpeg4_encoder_select="h263_encoder"

 mpeg_vdpau_decoder_select="vdpau mpegvideo_decoder"
 mpeg1_vdpau_decoder_select="vdpau mpeg1video_decoder"

 mpeg1_vdpau_hwaccel_select="vdpau mpeg1video_decoder"

 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"

 mpeg4_crystalhd_decoder_select="crystalhd"

 mpeg4_vaapi_hwaccel_select="vaapi mpeg4_decoder"

 mpeg4_vdpau_decoder_select="vdpau mpeg4_decoder"

 mpeg_xvmc_decoder_deps="X11_extensions_XvMClib_h"

 mpeg_xvmc_decoder_select="mpegvideo_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"

 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"

 rv10_decoder_select="h263_decoder"

 rv10_encoder_select="h263_encoder"

 rv20_decoder_select="h263_decoder"

 rv20_encoder_select="h263_encoder"

 rv30_decoder_select="golomb h264pred"
 rv40_decoder_select="golomb h264pred"

 shorten_decoder_select="golomb"

 sipr_decoder_select="lsp"

 snow_decoder_select="dwt"
 snow_encoder_select="aandct dwt"

 sonic_decoder_select="golomb"
 sonic_encoder_select="golomb"
 sonic_ls_encoder_select="golomb"

 svq1_encoder_select="aandct"

 svq3_decoder_select="golomb h264dsp h264pred"

 svq3_decoder_suggest="zlib"

 theora_decoder_select="vp3_decoder"

 tiff_decoder_suggest="zlib"
 tiff_encoder_suggest="zlib"

 truehd_decoder_select="mlp_decoder"

 tscc_decoder_select="zlib"

 twinvq_decoder_select="mdct lsp sinewin"

 vc1_decoder_select="h263_decoder"

 vc1_crystalhd_decoder_select="crystalhd"

 vc1_dxva2_hwaccel_deps="dxva2api_h DXVA_PictureParameters_wDecodedPictureIndex"

 vc1_dxva2_hwaccel_select="dxva2 vc1_decoder"

 vc1_vaapi_hwaccel_select="vaapi vc1_decoder"
 vc1_vdpau_decoder_select="vdpau vc1_decoder"

 vorbis_decoder_select="mdct"
 vorbis_encoder_select="mdct"

 vp6_decoder_select="huffman"

 vp6a_decoder_select="vp6_decoder"
 vp6f_decoder_select="vp6_decoder"

 vp8_decoder_select="h264pred"

 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"

 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"

 vdpau_deps="vdpau_vdpau_h vdpau_vdpau_x11_h"
 

 # parsers

 h264_parser_select="golomb h264dsp h264pred"

 # external libraries

 libaacplus_encoder_deps="libaacplus"

 libcelt_decoder_deps="libcelt"

 libdirac_decoder_deps="libdirac !libschroedinger"

 libdirac_encoder_deps="libdirac"

 libfaac_encoder_deps="libfaac"

 libgsm_decoder_deps="libgsm"
 libgsm_encoder_deps="libgsm"

 libgsm_ms_decoder_deps="libgsm"
 libgsm_ms_encoder_deps="libgsm"

 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"

 libschroedinger_decoder_deps="libschroedinger"
 libschroedinger_encoder_deps="libschroedinger"

 libspeex_decoder_deps="libspeex"

 libspeex_encoder_deps="libspeex"

 libtheora_encoder_deps="libtheora"

 libvo_aacenc_encoder_deps="libvo_aacenc"

 libvo_amrwbenc_encoder_deps="libvo_amrwbenc"

 libvorbis_encoder_deps="libvorbis"

 libvpx_decoder_deps="libvpx"

 libvpx_encoder_deps="libvpx"

 libx264_encoder_deps="libx264"

 libxavs_encoder_deps="libxavs"

 libxvid_encoder_deps="libxvid"

 # demuxers / muxers

 ac3_demuxer_select="ac3_parser"

 asf_stream_muxer_select="asf_muxer"

 avisynth_demuxer_deps="avisynth"

 dirac_demuxer_select="dirac_parser"

 eac3_demuxer_select="ac3_parser"

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

 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"

 spdif_muxer_select="aac_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"

 dshow_indev_deps="IBaseFilter"
 dshow_indev_extralibs="-lpsapi -lole32 -lstrmiids -luuid"

 dv1394_indev_deps="dv1394 dv_demuxer"

 fbdev_indev_deps="linux_fb_h"

 jack_indev_deps="jack_jack_h sem_timedwait"

 libdc1394_indev_deps="libdc1394"
 oss_indev_deps_any="soundcard_h sys_soundcard_h"
 oss_outdev_deps_any="soundcard_h sys_soundcard_h"

 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"

 x11_grab_device_indev_deps="x11grab XShmCreateImage"

 x11_grab_device_indev_extralibs="-lX11 -lXext -lXfixes"

 # protocols

 gopher_protocol_deps="network"

 http_protocol_deps="network"

 http_protocol_select="tcp_protocol"

 mmsh_protocol_select="http_protocol"

 mmst_protocol_deps="network"

 rtmp_protocol_select="tcp_protocol"
 rtp_protocol_select="udp_protocol"

 tcp_protocol_deps="network"

 udp_protocol_deps="network"

 # filters

 blackframe_filter_deps="gpl"

 cropdetect_filter_deps="gpl"

 drawtext_filter_deps="libfreetype"

 frei0r_filter_deps="frei0r dlopen strtok_r"

 frei0r_src_filter_deps="frei0r dlopen strtok_r"

 hqdn3d_filter_deps="gpl"

 movie_filter_deps="avcodec avformat"
 mp_filter_deps="gpl avcodec"

 negate_filter_deps="lut_filter"

 ocv_filter_deps="libopencv"

 scale_filter_deps="swscale"

 yadif_filter_deps="gpl"

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

 postproc_deps="gpl"

 # programs

 ffmpeg_deps="avcodec avformat swscale"

 ffmpeg_select="buffer_filter buffersink_filter"

 ffplay_deps="avcodec avformat swscale sdl"

 ffplay_select="rdft"

 ffprobe_deps="avcodec avformat"

 ffserver_deps="avformat ffm_muxer fork rtp_protocol rtsp_demuxer"

 ffserver_extralibs='$ldl'

 doc_deps="texi2html"

 # tests
 
 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
 }
 

 set_ne_test_deps(){
     eval ${1}_be_test_deps="bigendian"
     eval ${1}_le_test_deps="!bigendian"
 }
 

 mxf_d10_test_deps="avfilter"
 seek_lavf_mxf_d10_test_deps="mxf_d10_test"
 

 test_deps _encoder _decoder                                             \
     adpcm_g726=g726                                                     \
     adpcm_ima_qt                                                        \
     adpcm_ima_wav                                                       \
     adpcm_ms                                                            \
     adpcm_swf                                                           \
     adpcm_yamaha=adpcm_yam                                              \
     alac                                                                \
     asv1                                                                \
     asv2                                                                \
     bmp                                                                 \

     dnxhd="dnxhd_1080i dnxhd_720p dnxhd_720p_rd"                        \

     dvvideo="dv dv50"                                                   \
     ffv1                                                                \
     flac                                                                \
     flashsv                                                             \
     flv                                                                 \
     gif                                                                 \
     h261                                                                \
     h263="h263 h263p"                                                   \
     huffyuv                                                             \
     jpegls                                                              \
     mjpeg="jpg mjpeg ljpeg"                                             \
     mp2                                                                 \
     mpeg1video="mpeg mpeg1b"                                            \
     mpeg2video="mpeg2 mpeg2thread"                                      \
     mpeg4="mpeg4 mpeg4adv mpeg4nr mpeg4thread error rc"                 \

     msmpeg4v3=msmpeg4                                                   \

     msmpeg4v2                                                           \
     pbm=pbmpipe                                                         \
     pcx                                                                 \
     pgm="pgm pgmpipe"                                                   \

     png                                                                 \

     ppm="ppm ppmpipe"                                                   \
     rawvideo="rgb yuv"                                                  \
     roq                                                                 \
     rv10                                                                \
     rv20                                                                \
     sgi                                                                 \
     snow="snow snowll"                                                  \
     svq1                                                                \
     targa=tga                                                           \
     tiff                                                                \
     wmav1                                                               \
     wmav2                                                               \
     wmv1                                                                \
     wmv2                                                                \
 
 test_deps _muxer _demuxer                                               \
     aiff                                                                \
     pcm_alaw=alaw                                                       \
     asf                                                                 \
     au                                                                  \
     avi                                                                 \
     dv=dv_fmt                                                           \
     ffm                                                                 \
     flv=flv_fmt                                                         \
     gxf                                                                 \
     matroska=mkv                                                        \
     mmf                                                                 \
     mov                                                                 \
     pcm_mulaw=mulaw                                                     \

     mxf="mxf mxf_d10"                                                   \

     nut                                                                 \
     ogg                                                                 \
     rawvideo=pixfmt                                                     \
     rm                                                                  \
     swf                                                                 \
     mpegts=ts                                                           \
     voc                                                                 \
     wav                                                                 \
     yuv4mpegpipe=yuv4mpeg                                               \
 

 ac3_fixed_test_deps="ac3_fixed_encoder ac3_decoder rm_muxer rm_demuxer"

 mpg_test_deps="mpeg1system_muxer mpegps_demuxer"

 
 set_ne_test_deps pixdesc

 set_ne_test_deps pixfmts_copy

 set_ne_test_deps pixfmts_crop

 set_ne_test_deps pixfmts_hflip

 set_ne_test_deps pixfmts_null
 set_ne_test_deps pixfmts_pad
 set_ne_test_deps pixfmts_scale
 set_ne_test_deps pixfmts_vflip

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

 
 # toolchain

 ar_default="ar"

 cc_default="gcc"

 cc_version=\"unknown\"

 host_cc_default="gcc"

 install="install"

 ln_s="ln -sf"

 nm_default="nm"

 objformat="elf"

 pkg_config_default=pkg-config

 ranlib="ranlib"

 strip_default="strip"

 yasmexe="yasm"

 nogas=":"

 nm_opts='-g'
 

 # machine

 arch_default=$(uname -m)

 cpu="generic"

 
 # OS

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

 
 # configurable options

 enable avcodec
 enable avdevice

 enable avfilter

 enable avformat

 enable avutil

 enable asm

 enable debug

 enable doc

 enable fastdiv

 enable ffmpeg
 enable ffplay

 enable ffprobe

 enable ffserver
 enable network

 enable optimizations

 enable postproc

 enable protocols

 enable static

 enable stripping

 enable swscale

 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)"'

 CC_O='-o $@'
 

 host_cflags='-D_ISOC99_SOURCE -O3 -g'

 host_libs='-lm'
 

 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

 DEPEND_CMD='$(DEPCC) $(DEPFLAGS) $< | sed -e "/^\#.*/d" -e "s,^[[:space:]]*$(*F)\\.o,$(@D)/$(*F).o," > $(@:.o=.d)'

 DEPFLAGS='$(CPPFLAGS) $(CFLAGS) -MM'

 # find source path

 if test -f configure; then

     source_path="$(pwd)"

     disable source_path_used

 else

     source_path=$(cd $(dirname "$0"); pwd)
     enable source_path_used

     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)

 find_tests(){

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

 }
 
 ACODEC_TESTS=$(find_tests acodec)
 VCODEC_TESTS=$(find_tests vsynth1)
 LAVF_TESTS=$(find_tests lavf)

 LAVFI_TESTS=$(find_tests lavfi)

 SEEK_TESTS=$(find_tests seek seek_)

 pcm_test_deps=$(map 'echo ${v%_*}_decoder $v' $(filter pcm_* $ENCODER_LIST))
 

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

 enable $ARCH_EXT_LIST $ACODEC_TESTS $VCODEC_TESTS $LAVF_TESTS $LAVFI_TESTS $SEEK_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
 }
 

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

 ar_default="${cross_prefix}${ar_default}"

 cc_default="${cross_prefix}${cc_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"
 

 set_default cc nm pkg_config strip sysinclude

 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 TMPC  .c
 tmpfile TMPE  $EXESUF
 tmpfile TMPH  .h
 tmpfile TMPO  .o
 tmpfile TMPS  .S

 tmpfile TMPV  .ver

 tmpfile TMPSH .sh

 tmpfile TMPASM .asm

 
 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
 

 filter_cflags=echo
 filter_cppflags=echo
 filter_asflags=echo
 

 if   $cc -v 2>&1 | grep -q '^gcc.*LLVM'; then
     cc_type=llvm_gcc
     cc_version=__VERSION__
     gcc_extra_ver=$(expr "$($cc --version | head -n1)" : '.*\((.*)\)')
     cc_ident="llvm-gcc $($cc -dumpversion) $gcc_extra_ver"
     CC_DEPFLAGS='-MMD -MF $(@:.o=.d) -MT $@'
     AS_DEPFLAGS='-MMD -MF $(@:.o=.d) -MT $@'
     speed_cflags='-O3'
     size_cflags='-Os'
 elif $cc -v 2>&1 | grep -qi ^gcc; then

     cc_type=gcc

     cc_version=__VERSION__

     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 \\(.*\\)")
     cc_ident=$(cleanws "gcc $gcc_basever $gcc_pkg_ver $gcc_ext_ver")

     if ! $cc -dumpversion | grep -q '^2\.'; then
         CC_DEPFLAGS='-MMD -MF $(@:.o=.d) -MT $@'
         AS_DEPFLAGS='-MMD -MF $(@:.o=.d) -MT $@'
     fi

     speed_cflags='-O3'
     size_cflags='-Os'

 elif $cc --version 2>/dev/null | grep -q Intel; then
     cc_type=icc

     cc_version="AV_STRINGIFY(__INTEL_COMPILER)"

     cc_ident=$($cc --version | head -n1)

     icc_version=$($cc -dumpversion)

     CC_DEPFLAGS='-MMD'
     AS_DEPFLAGS='-MMD'

     speed_cflags='-O3'
     size_cflags='-Os'

     noopt_cflags='-O1'

 elif $cc -v 2>&1 | grep -q xlc; then
     cc_type=xlc

     cc_version="AV_STRINGIFY(__IBMC__)"

     cc_ident=$($cc -qversion 2>/dev/null | head -n1)

     speed_cflags='-O5'
     size_cflags='-O5 -qcompact'

 elif $cc -V 2>/dev/null | grep -q Compaq; then
     cc_type=ccc

     cc_version="AV_STRINGIFY(__DECC_VER)"

     cc_ident=$($cc -V | head -n1 | cut -d' ' -f1-3)

     DEPFLAGS='$(CPPFLAGS) $(CFLAGS) -M'

     debuglevel=3

     add_ldflags -Wl,-z,now # calls to libots crash without this

     speed_cflags='-fast'
     size_cflags='-O1'

 elif $cc --vsn 2>/dev/null | grep -q "ARM C/C++ Compiler"; then

     test -d "$sysroot" || die "No valid sysroot specified."
     cc_type=armcc

     cc_version="AV_STRINGIFY(__ARMCC_VERSION)"

     cc_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

     cc="$cc --arm_linux_config_file=$armcc_conf --translate_gcc"

     as_default="${cross_prefix}gcc"

     CC_DEPFLAGS='-MMD'
     AS_DEPFLAGS='-MMD'

     speed_cflags='-O3'
     size_cflags='-Os'

     filter_asflags="filter_out -W${armcc_opt}*"

 elif $cc -version 2>/dev/null | grep -q TMS470; then
     cc_type=tms470

     cc_version="AV_STRINGIFY(__TI_COMPILER_VERSION__)"

     cc_ident=$($cc -version | head -n1 | tr -s ' ')

     cc="$cc --gcc --abi=eabi -eo=.o -mc -me"
     CC_O='-fr=$(@D)'
     as_default="${cross_prefix}gcc"
     ld_default="${cross_prefix}gcc"
     TMPO=$(basename $TMPC .c).o
     append TMPFILES $TMPO
     add_cflags -D__gnuc_va_list=va_list -D__USER_LABEL_PREFIX__=

     CC_DEPFLAGS='-ppa -ppd=$(@:.o=.d)'
     AS_DEPFLAGS='-MMD'

     speed_cflags='-O3 -mf=5'
     size_cflags='-O3 -mf=2'

     filter_cflags=tms470_flags
     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        ;;

                 -msoft-float)   echo --float_support=vfplib       ;;

                 -O[0-3]|-mf=*)  echo $flag                        ;;

                 -g)             echo -g -mn                       ;;

                 -pds=*)         echo $flag                        ;;

             esac
         done
     }

 elif $cc -v 2>&1 | grep -q clang; then
     cc_type=clang

     $cc -dM -E $TMPC | grep -q __clang_version__ &&
         cc_version=__clang_version__ || cc_version=__VERSION__

     cc_ident=$($cc --version | head -n1)

     CC_DEPFLAGS='-MMD'
     AS_DEPFLAGS='-MMD'

     speed_cflags='-O3'
     size_cflags='-Os'

 elif $cc -V 2>&1 | grep -q Sun; then
     cc_type=suncc
     cc_version="AV_STRINGIFY(__SUNPRO_C)"

     cc_ident=$($cc -V 2>&1 | head -n1 | cut -d' ' -f 2-)

     DEPEND_CMD='$(DEPCC) $(DEPFLAGS) $< | sed -e "1s,^.*: ,$@: ," -e "\$$!s,\$$, \\\," -e "1!s,^.*: , ," > $(@:.o=.d)'

     DEPFLAGS='$(CPPFLAGS) $(CFLAGS) -xM1'

     speed_cflags='-O5'
     size_cflags='-O5 -xspace'

     filter_cflags=suncc_flags
     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)       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
     }

 elif $cc -v 2>&1 | grep -q 'PathScale\|Path64'; then

     cc_type=pathscale
     cc_version=__PATHSCALE__
     cc_ident=$($cc -v 2>&1 | head -n1 | tr -d :)
     CC_DEPFLAGS='-MMD -MF $(@:.o=.d) -MT $@'
     AS_DEPFLAGS='-MMD -MF $(@:.o=.d) -MT $@'
     speed_cflags='-O2'
     size_cflags='-Os'

     filter_cflags='filter_out -Wdisabled-optimization'

 elif $cc -v 2>&1 | grep -q Open64; then
     cc_type=open64
     cc_version=__OPEN64__
     cc_ident=$($cc -v 2>&1 | head -n1 | tr -d :)
     CC_DEPFLAGS='-MMD -MF $(@:.o=.d) -MT $@'
     AS_DEPFLAGS='-MMD -MF $(@:.o=.d) -MT $@'
     speed_cflags='-O2'
     size_cflags='-Os'

     filter_cflags='filter_out -Wdisabled-optimization|-Wtype-limits|-fno-signed-zeros'

 fi
 

 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}

 set_default ar as dep_cc ld

 test -n "$CC_DEPFLAGS" || CCDEP=$DEPEND_CMD
 test -n "$AS_DEPFLAGS" || ASDEP=$DEPEND_CMD
 

 add_cflags $extra_cflags

 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 "/$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*)
         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)
         arch="ppc"
     ;;

     ppc64|powerpc64)

         arch="ppc"
         subarch="ppc64"
     ;;
     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|power4*)

             cpuflags="-mcpu=970 -mpowerpc-gfxopt -mpowerpc64"
         ;;

         cell)

             cpuflags="-mcpu=cell"
             enable ldbrx
         ;;

         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)

             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*)                               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"

 
 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

 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_cc <<EOF && subarch="x86_64"

         int test[(int)sizeof(char*) - 7];

 EOF

         if test "$subarch" = "x86_64"; then

             spic=$shared

         fi

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

         nm_opts='-P -g'

         ;;
     netbsd)

         disable symver

         oss_indev_extralibs="-lossaudio"
         oss_outdev_extralibs="-lossaudio"

         ;;
     openbsd)

         enable malloc_aligned

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

         oss_indev_extralibs="-lossaudio"
         oss_outdev_extralibs="-lossaudio"

         ;;

     dragonfly)
         enable malloc_aligned
         disable symver
         ;;
     freebsd)

         enable malloc_aligned

         ;;
     bsd/os)

         add_extralibs -lpoll -lgnugetopt

         strip="strip -d"

         ;;
     darwin)

         enable malloc_aligned

         gas="gas-preprocessor.pl $cc"

         enabled ppc && add_asflags -force_cpusubtype_ALL

         SHFLAGS='-dynamiclib -Wl,-single_module -Wl,-install_name,$(SHLIBDIR)/$(SLIBNAME),-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

             enable malloc_aligned

             LIBTARGET=x64

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

         SLIB_EXTRA_CMD='-lib.exe /machine:$(LIBTARGET) /def:$$(@:$(SLIBSUF)=.def) /out:$(SUBDIR)$(SLIBNAME_WITH_MAJOR:$(SLIBSUF)=.lib)'

         SLIB_INSTALL_EXTRA_CMD='-install -m 644 $(SUBDIR)$(SLIBNAME_WITH_MAJOR:$(SLIBSUF)=.lib) "$(SHLIBDIR)/$(SLIBNAME:$(SLIBSUF)=.lib)"; \

             install -m 644 $(SUBDIR)$(SLIBNAME_WITH_MAJOR:$(SLIBSUF)=.lib) "$(SHLIBDIR)/$(SLIBNAME_WITH_MAJOR:$(SLIBSUF)=.lib)"; \
             install -d "$(LIBDIR)"; \
             install -m 644 $(SUBDIR)lib$(SLIBNAME:$(SLIBSUF)=.dll.a) "$(LIBDIR)/lib$(SLIBNAME:$(SLIBSUF)=.dll.a)"'

         SLIB_UNINSTALL_EXTRA_CMD='rm -f "$(SHLIBDIR)/$(SLIBNAME:$(SLIBSUF)=.lib)"'

         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"

         enable dos_paths

         check_cflags -fno-common

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

         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)'
         SHFLAGS='-shared -Wl,--enable-auto-image-base'

         objformat="win32"

         enable dos_paths

         check_cflags -fno-common

         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_CMD='install -m 644 $(SUBDIR)$(LIBPREF)$(NAME)_dll.a $(SUBDIR)$(LIBPREF)$(NAME)_dll.lib "$(LIBDIR)"'

         SLIB_UNINSTALL_EXTRA_CMD='rm -f "$(LIBDIR)"/$(LIBPREF)$(NAME)_dll.a "$(LIBDIR)"/$(LIBPREF)$(NAME)_dll.lib'

         enable dos_paths

         ;;

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

     none)
         ;;

     *)

         die "Unknown OS '$target_os'."

         ;;
 esac
 

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

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

 set_default $PATHS_LIST
 

 # 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
 

 disabled static && LIBNAME=""

 die_license_disabled() {

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

 }
 
 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

 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 $nm_opts $TMPO | awk '/ff_extern/{ print substr($0, match($0, /[^ \t]*ff_extern/)) }')

 extern_prefix=${sym%%ff_extern*}
 

 check_cc <<EOF && enable 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

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

 
     # We have to check if pld is a nop and disable it.
     check_asm pld '"pld [r0]"'
 
     enabled armv5te && check_asm armv5te '"qadd r0, r0, r0"'
     enabled armv6   && check_asm armv6   '"sadd16 r0, r0, r0"'
     enabled armv6t2 && check_asm armv6t2 '"movt r0, #0"'
     enabled armvfp  && check_asm armvfp  '"fadds s0, s0, s0"'
     enabled iwmmxt  && check_asm iwmmxt  '"wunpckelub wr6, wr4"'
     enabled neon    && check_asm neon    '"vadd.i16 q0, q0, q0"'

     enabled vfpv3   && check_asm vfpv3   '"vmov.f32 s0, #1.0"'

     enabled_all armv6t2 shared !pic && enable_pic
 

 elif enabled mips; then

     check_asm loongson '"dmult.g $1, $2, $3"'
     enabled mmi     && check_asm mmi     '"lq $2, 0($2)"'

 elif enabled ppc; then

     enable local_aligned_8 local_aligned_16
 

     check_asm dcbzl     '"dcbzl 0, %0" :: "r"(0)'

     check_asm ibm_asm   '"add 0, 0, 0"'

     check_asm ppc4xx    '"maclhw r10, r11, r12"'

     check_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, v2, v3;
     v1 = vec_add(v2,v3);
     return 0;
 }
 EOF
 
         # check if our compiler supports braces for vector declarations
         check_cc <<EOF || die "You need a compiler that supports {} in AltiVec vector declarations."
 $inc_altivec_h
 int main (void) { (vector int) {1}; return 0; }
 EOF
     fi

 elif enabled sparc; then

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

 elif enabled x86; then

     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_asm ebx_available '""::"b"(0)' &&
         check_asm ebx_available '"":::"%ebx"'

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

     # check whether more than 10 operands are supported
     check_cc <<EOF && enable ten_operands
 int main(void) {
     int x=0;
     __asm__ volatile(
         ""
         :"+&rm"(x), "+&rm"(x), "+&rm"(x), "+&rm"(x), "+&rm"(x), "+&rm"(x)
     );
     return 0;
 }
 EOF
 

     # check whether binutils is new enough to compile SSSE3/MMX2

     enabled ssse3 && check_asm ssse3 '"pabsw %xmm0, %xmm0"'

     enabled mmx2  && check_asm mmx2  '"pmaxub %mm0, %mm1"'

 
     check_asm bswap '"bswap %%eax" ::: "%eax"'

     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

     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_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 ipv6_mreq" -D_DARWIN_C_SOURCE
     check_type netinet/in.h "struct sockaddr_in6"
     check_type "sys/types.h sys/socket.h" "struct sockaddr_storage"
     check_struct "sys/types.h sys/socket.h" "struct sockaddr" sa_len
     # 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_type ws2tcpip.h socklen_t
         check_type ws2tcpip.h "struct addrinfo"
         check_type ws2tcpip.h "struct ipv6_mreq"
         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  fcntl

 check_func  fork

 check_func  getaddrinfo $network_extralibs

 check_func  gethrtime
 check_func  getrusage

 check_struct "sys/time.h sys/resource.h" "struct rusage" ru_maxrss

 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  setrlimit

 check_func  strerror_r

 check_func  strtok_r

 check_func_headers conio.h kbhit

 check_func_headers io.h setmode

 check_func_headers lzo/lzo1x.h lzo1x_999_compress

 check_lib2 "windows.h psapi.h" GetProcessMemoryInfo -lpsapi

 check_func_headers windows.h GetProcessTimes

 check_func_headers windows.h MapViewOfFile

 check_func_headers windows.h VirtualAlloc

 check_header dlfcn.h

 check_header dxva2api.h

 check_header libcrystalhd/libcrystalhd_if.h

 check_header malloc.h

 check_header poll.h

 check_header sys/mman.h

 check_header sys/resource.h

 check_header sys/select.h

 check_header termios.h

 check_header vdpau/vdpau.h
 check_header vdpau/vdpau_x11.h

 check_header X11/extensions/XvMClib.h

 check_struct dxva2api.h DXVA_PictureParameters wDecodedPictureIndex
 

 disabled  zlib || check_lib   zlib.h      zlibVersion -lz   || disable  zlib

 disabled bzlib || check_lib2 bzlib.h BZ2_bzlibVersion -lbz2 || disable bzlib

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

 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 exp2
 check_mathfunc exp2f
 check_mathfunc llrint

 check_mathfunc llrintf

 check_mathfunc log2
 check_mathfunc log2f
 check_mathfunc lrint
 check_mathfunc lrintf
 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 libcelt    && require libcelt celt/celt.h celt_decode -lcelt0