libvpx: Pull from upstream

source/libvpx/configure

-#!/bin/bash
+#!/bin/sh
 ##
 ##  configure
 ##
 ##  This script is the front-end to the build system. It provides a similar
 ##  interface to standard configure scripts with some extra bits for dealing
 ##  with toolchains that differ from the standard POSIX interface and
 ##  for extracting subsets of the source tree. In theory, reusable parts
 ##  of this script were intended to live in build/make/configure.sh,
 ##  but in practice, the line is pretty blurry.
 ##
@@ skipping 134 matching lines @@
 all_platforms="${all_platforms} universal-darwin12-gcc"
 all_platforms="${all_platforms} universal-darwin13-gcc"
 all_platforms="${all_platforms} generic-gnu"
 
 # all_targets is a list of all targets that can be configured
 # note that these should be in dependency order for now.
 all_targets="libs examples docs"
 
 # all targets available are enabled, by default.
 for t in ${all_targets}; do
-    [ -f ${source_path}/${t}.mk ] && enable ${t}
+    [ -f ${source_path}/${t}.mk ] && enable_feature ${t}
 done
 
 # check installed doxygen version
 doxy_version=$(doxygen --version 2>/dev/null)
 doxy_major=${doxy_version%%.*}
 if [ ${doxy_major:-0} -ge 1 ]; then
     doxy_version=${doxy_version#*.}
     doxy_minor=${doxy_version%%.*}
     doxy_patch=${doxy_version##*.}
 
-    [ $doxy_major -gt 1 ] && enable doxygen
-    [ $doxy_minor -gt 5 ] && enable doxygen
-    [ $doxy_minor -eq 5 ] && [ $doxy_patch -ge 3 ] && enable doxygen
+    [ $doxy_major -gt 1 ] && enable_feature doxygen
+    [ $doxy_minor -gt 5 ] && enable_feature doxygen
+    [ $doxy_minor -eq 5 ] && [ $doxy_patch -ge 3 ] && enable_feature doxygen
 fi
 
 # install everything except the sources, by default. sources will have
 # to be enabled when doing dist builds, since that's no longer a common
 # case.
-enabled doxygen && php -v >/dev/null 2>&1 && enable install_docs
-enable install_bins
-enable install_libs
+enabled doxygen && php -v >/dev/null 2>&1 && enable_feature install_docs
+enable_feature install_bins
+enable_feature install_libs
 
-enable static
-enable optimizations
-enable fast_unaligned #allow unaligned accesses, if supported by hw
-enable md5
-enable spatial_resampling
-enable multithread
-enable os_support
-enable temporal_denoising
+enable_feature static
+enable_feature optimizations
+enable_feature fast_unaligned #allow unaligned accesses, if supported by hw
+enable_feature md5
+enable_feature spatial_resampling
+enable_feature multithread
+enable_feature os_support
+enable_feature temporal_denoising
 
-[ -d ${source_path}/../include ] && enable alt_tree_layout
+[ -d ${source_path}/../include ] && enable_feature alt_tree_layout
 for d in vp8 vp9; do
-    [ -d ${source_path}/${d} ] && disable alt_tree_layout;
+    [ -d ${source_path}/${d} ] && disable_feature alt_tree_layout;
 done
 
 if ! enabled alt_tree_layout; then
 # development environment
 [ -d ${source_path}/vp8 ] && CODECS="${CODECS} vp8_encoder vp8_decoder"
 [ -d ${source_path}/vp9 ] && CODECS="${CODECS} vp9_encoder vp9_decoder"
 else
 # customer environment
 [ -f ${source_path}/../include/vpx/vp8cx.h ] && CODECS="${CODECS} vp8_encoder"
 [ -f ${source_path}/../include/vpx/vp8dx.h ] && CODECS="${CODECS} vp8_decoder"
 [ -f ${source_path}/../include/vpx/vp9cx.h ] && CODECS="${CODECS} vp9_encoder"
 [ -f ${source_path}/../include/vpx/vp9dx.h ] && CODECS="${CODECS} vp9_decoder"
-[ -f ${source_path}/../include/vpx/vp8cx.h ] || disable vp8_encoder
-[ -f ${source_path}/../include/vpx/vp8dx.h ] || disable vp8_decoder
-[ -f ${source_path}/../include/vpx/vp9cx.h ] || disable vp9_encoder
-[ -f ${source_path}/../include/vpx/vp9dx.h ] || disable vp9_decoder
+[ -f ${source_path}/../include/vpx/vp8cx.h ] || disable_feature vp8_encoder
+[ -f ${source_path}/../include/vpx/vp8dx.h ] || disable_feature vp8_decoder
+[ -f ${source_path}/../include/vpx/vp9cx.h ] || disable_feature vp9_encoder
+[ -f ${source_path}/../include/vpx/vp9dx.h ] || disable_feature vp9_decoder
 
 [ -f ${source_path}/../lib/*/*mt.lib ] && soft_enable static_msvcrt
 fi
 
 CODECS="$(echo ${CODECS} | tr ' ' '\n')"
 CODEC_FAMILIES="$(for c in ${CODECS}; do echo ${c%_*}; done | sort | uniq)"
 
 ARCH_LIST="
     arm
     mips
@@ skipping 33 matching lines @@
     multiple_arf
     non420
     alpha
 "
 CONFIG_LIST="
     external_build
     install_docs
     install_bins
     install_libs
     install_srcs
+    use_x86inc
     debug
     gprof
     gcov
     rvct
     gcc
     msvs
     pic
     big_endian
 
     codec_srcs
@@ skipping 36 matching lines @@
     extra_warnings
     werror
     install_docs
     install_bins
     install_libs
     install_srcs
     debug
     gprof
     gcov
     pic
+    use_x86inc
     optimizations
     ccache
     runtime_cpu_detect
     thumb
 
     libs
     examples
     docs
     libc
     as
@@ skipping 23 matching lines @@
     multi_res_encoding
     temporal_denoising
     experimental
     decrypt
 "
 
 process_cmdline() {
     for opt do
         optval="${opt#*=}"
         case "$opt" in
-        --disable-codecs) for c in ${CODECS}; do disable $c; done ;;
+        --disable-codecs) for c in ${CODECS}; do disable_feature $c; done ;;
         --enable-?*|--disable-?*)
         eval `echo "$opt" | sed 's/--/action=/;s/-/ option=/;s/-/_/g'`
         if echo "${EXPERIMENT_LIST}" | grep "^ *$option\$" >/dev/null; then
             if enabled experimental; then
-                $action $option
+                ${action}_feature $option
             else
                 log_echo "Ignoring $opt -- not in experimental mode."
             fi
         else
             process_common_cmdline $opt
         fi
         ;;
         *) process_common_cmdline "$opt"
         ;;
         esac
     done
 }
 
 post_process_cmdline() {
     local c
 
     # If the codec family is disabled, disable all components of that family.
     # If the codec family is enabled, enable all components of that family.
     log_echo "Configuring selected codecs"
     for c in ${CODECS}; do
-        disabled ${c%%_*} && disable ${c}
-        enabled ${c%%_*} && enable ${c}
+        disabled ${c%%_*} && disable_feature ${c}
+        enabled ${c%%_*} && enable_feature ${c}
     done
 
     # Enable all detected codecs, if they haven't been disabled
     for c in ${CODECS}; do soft_enable $c; done
 
     # Enable the codec family if any component of that family is enabled
     for c in ${CODECS}; do
-        enabled $c && enable ${c%_*}
+        enabled $c && enable_feature ${c%_*}
     done
 
     # Set the {en,de}coders variable if any algorithm in that class is enabled
     for c in ${CODECS}; do
-        enabled ${c} && enable ${c##*_}s
+        enabled ${c} && enable_feature ${c##*_}s
     done
 }
 
 
 process_targets() {
     enabled child || write_common_config_banner
     enabled universal || write_common_target_config_h  ${BUILD_PFX}vpx_config.h
 
     # TODO: add host tools target (obj_int_extract, etc)
 
@@ skipping 89 matching lines @@
         if ! enabled linux; then
             if enabled gnu; then
                 echo "--enable-shared is only supported on ELF; assuming this is OK"
             else
                 die "--enable-shared only supported on ELF for now"
             fi
         fi
     fi
     if [ -z "$CC" ] || enabled external_build; then
         echo "Bypassing toolchain for environment detection."
-        enable external_build
+        enable_feature external_build
         check_header() {
             log fake_check_header "$@"
             header=$1
             shift
             var=`echo $header | sed 's/[^A-Za-z0-9_]/_/g'`
-            disable $var
+            disable_feature $var
             # Headers common to all environments
             case $header in
                 stdio.h)
                     true;
                 ;;
                 *)
                     local result=false
                     for d in "$@"; do
                         [ -f "${d##-I}/$header" ] && result=true && break
                     done
                     ${result:-true}
-            esac && enable $var
+            esac && enable_feature $var
 
             # Specialize windows and POSIX environments.
             case $toolchain in
                 *-win*-*)
                     case $header-$toolchain in
                         stdint*-gcc) true;;
                         *) false;;
-                    esac && enable $var
+                    esac && enable_feature $var
                     ;;
                 *)
                     case $header in
                         stdint.h) true;;
                         pthread.h) true;;
                         sys/mman.h) true;;
                         unistd.h) true;;
                         *) false;;
-                    esac && enable $var
+                    esac && enable_feature $var
             esac
             enabled $var
         }
         check_ld() {
             true
         }
     fi
     check_header stdio.h || die "Unable to invoke compiler: ${CC} ${CFLAGS}"
     check_ld <<EOF || die "Toolchain is unable to link executables"
 int main(void) {return 0;}
 EOF
     # check system headers
     check_header stdint.h
     check_header pthread.h
     check_header sys/mman.h
     check_header unistd.h # for sysconf(3) and friends.
 
-    check_header vpx/vpx_integer.h -I${source_path} && enable vpx_ports
+    check_header vpx/vpx_integer.h -I${source_path} && enable_feature vpx_ports
 }
 
 process_toolchain() {
     process_common_toolchain
 
     # Handle universal binaries for this architecture
     case $toolchain in
         universal-darwin*)
             local darwin_ver=${tgt_os##darwin}
 
@@ skipping 61 matching lines @@
     if enabled extra_warnings; then
         for w in ${EXTRA_WARNINGS}; do
             check_add_cflags ${w}
             enabled gcc && enabled werror && check_add_cflags -Wno-error=${w}
         done
     fi
 
     # ccache only really works on gcc toolchains
     enabled gcc || soft_disable ccache
     if enabled mips; then
-        enable dequant_tokens
-        enable dc_recon
+        enable_feature dequant_tokens
+        enable_feature dc_recon
     fi
 
     # Enable the postbuild target if building for visual studio.
     case "$tgt_cc" in
-        vs*) enable msvs
-             enable solution
+        vs*) enable_feature msvs
+             enable_feature solution
              vs_version=${tgt_cc##vs}
              case $vs_version in
              [789])
                  VCPROJ_SFX=vcproj
                  gen_vcproj_cmd=${source_path}/build/make/gen_msvs_proj.sh
                  ;;
              10|11)
                  VCPROJ_SFX=vcxproj
                  gen_vcproj_cmd=${source_path}/build/make/gen_msvs_vcxproj.sh
                  ;;
@@ skipping 42 matching lines @@
 ##
 ## END APPLICATION SPECIFIC CONFIGURATION
 ##
 CONFIGURE_ARGS="$@"
 process "$@"
 print_webm_license ${BUILD_PFX}vpx_config.c "/*" " */"
 cat <<EOF >> ${BUILD_PFX}vpx_config.c
 static const char* const cfg = "$CONFIGURE_ARGS";
 const char *vpx_codec_build_config(void) {return cfg;}
 EOF