configure

   1 #!/bin/sh
   2 ##
   3 ##  configure
   4 ##
   5 ##  This script is the front-end to the build system. It provides a similar
   6 ##  interface to standard configure scripts with some extra bits for dealing
   7 ##  with toolchains that differ from the standard POSIX interface and
   8 ##  for extracting subsets of the source tree. In theory, reusable parts
   9 ##  of this script were intended to live in build/make/configure.sh,
  10 ##  but in practice, the line is pretty blurry.
  11 ##
  12 ##  This build system is based in part on the FFmpeg configure script.
  13 ##
  14
  15 #source_path="`dirname \"$0\"`"
  16 source_path=${0%/*}
  17 . "${source_path}/build/make/configure.sh"
  18
  19 show_help(){
  20     show_help_pre
  21     cat << EOF
  22 Advanced options:
  23   ${toggle_libs}                  libraries
  24   ${toggle_examples}              examples
  25   ${toggle_tools}                 tools
  26   ${toggle_docs}                  documentation
  27   ${toggle_unit_tests}            unit tests
  28   ${toggle_decode_perf_tests}     build decoder perf tests with unit tests
  29   ${toggle_encode_perf_tests}     build encoder perf tests with unit tests
  30   --cpu=CPU                       tune for the specified CPU (ARM: cortex-a8, X86: sse3)
  31   --libc=PATH                     path to alternate libc
  32   --size-limit=WxH                max size to allow in the decoder
  33   --as={yasm|nasm|auto}           use specified assembler [auto, yasm preferred]
  34   --sdk-path=PATH                 path to root of sdk (android builds only)
  35   ${toggle_codec_srcs}            in/exclude codec library source code
  36   ${toggle_debug_libs}            in/exclude debug version of libraries
  37   ${toggle_static_msvcrt}         use static MSVCRT (VS builds only)
  38   ${toggle_vp9_highbitdepth}      use VP9 high bit depth (10/12) profiles
  39   ${toggle_better_hw_compatibility}
  40                                   enable encoder to produce streams with better
  41                                   hardware decoder compatibility
  42   ${toggle_vp8}                   VP8 codec support
  43   ${toggle_vp9}                   VP9 codec support
  44   ${toggle_internal_stats}        output of encoder internal stats for debug, if supported (encoders)
  45   ${toggle_postproc}              postprocessing
  46   ${toggle_vp9_postproc}          vp9 specific postprocessing
  47   ${toggle_multithread}           multithreaded encoding and decoding
  48   ${toggle_spatial_resampling}    spatial sampling (scaling) support
  49   ${toggle_realtime_only}         enable this option while building for real-time encoding
  50   ${toggle_onthefly_bitpacking}   enable on-the-fly bitpacking in real-time encoding
  51   ${toggle_error_concealment}     enable this option to get a decoder which is able to conceal losses
  52   ${toggle_coefficient_range_checking}
  53                                   enable decoder to check if intermediate
  54                                   transform coefficients are in valid range
  55   ${toggle_runtime_cpu_detect}    runtime cpu detection
  56   ${toggle_shared}                shared library support
  57   ${toggle_static}                static library support
  58   ${toggle_small}                 favor smaller size over speed
  59   ${toggle_postproc_visualizer}   macro block / block level visualizers
  60   ${toggle_multi_res_encoding}    enable multiple-resolution encoding
  61   ${toggle_temporal_denoising}    enable temporal denoising and disable the spatial denoiser
  62   ${toggle_vp9_temporal_denoising}
  63                                   enable vp9 temporal denoising
  64   ${toggle_webm_io}               enable input from and output to WebM container
  65   ${toggle_libyuv}                enable libyuv
  66
  67 Codecs:
  68   Codecs can be selectively enabled or disabled individually, or by family:
  69       --disable-<codec>
  70   is equivalent to:
  71       --disable-<codec>-encoder
  72       --disable-<codec>-decoder
  73
  74   Codecs available in this distribution:
  75 EOF
  76 #restore editor state '
  77
  78     family="";
  79     last_family="";
  80     c="";
  81     str="";
  82     for c in ${CODECS}; do
  83         family=${c%_*}
  84         if [ "${family}" != "${last_family}" ]; then
  85             [ -z "${str}" ] || echo "${str}"
  86             str="$(printf '    %10s:' ${family})"
  87         fi
  88         str="${str} $(printf '%10s' ${c#*_})"
  89         last_family=${family}
  90     done
  91     echo "${str}"
  92     show_help_post
  93 }
  94
  95 ##
  96 ## BEGIN APPLICATION SPECIFIC CONFIGURATION
  97 ##
  98
  99 # all_platforms is a list of all supported target platforms. Maintain
 100 # alphabetically by architecture, generic-gnu last.
 101 all_platforms="${all_platforms} arm64-android-gcc"
 102 all_platforms="${all_platforms} arm64-darwin-gcc"
 103 all_platforms="${all_platforms} arm64-linux-gcc"
 104 all_platforms="${all_platforms} arm64-win64-gcc"
 105 all_platforms="${all_platforms} armv7-android-gcc"   #neon Cortex-A8
 106 all_platforms="${all_platforms} armv7-darwin-gcc"    #neon Cortex-A8
 107 all_platforms="${all_platforms} armv7-linux-rvct"    #neon Cortex-A8
 108 all_platforms="${all_platforms} armv7-linux-gcc"     #neon Cortex-A8
 109 all_platforms="${all_platforms} armv7-none-rvct"     #neon Cortex-A8
 110 all_platforms="${all_platforms} armv7-win32-gcc"
 111 all_platforms="${all_platforms} armv7-win32-vs11"
 112 all_platforms="${all_platforms} armv7-win32-vs12"
 113 all_platforms="${all_platforms} armv7-win32-vs14"
 114 all_platforms="${all_platforms} armv7-win32-vs15"
 115 all_platforms="${all_platforms} armv7s-darwin-gcc"
 116 all_platforms="${all_platforms} armv8-linux-gcc"
 117 all_platforms="${all_platforms} mips32-linux-gcc"
 118 all_platforms="${all_platforms} mips64-linux-gcc"
 119 all_platforms="${all_platforms} ppc64le-linux-gcc"
 120 all_platforms="${all_platforms} sparc-solaris-gcc"
 121 all_platforms="${all_platforms} x86-android-gcc"
 122 all_platforms="${all_platforms} x86-darwin8-gcc"
 123 all_platforms="${all_platforms} x86-darwin8-icc"
 124 all_platforms="${all_platforms} x86-darwin9-gcc"
 125 all_platforms="${all_platforms} x86-darwin9-icc"
 126 all_platforms="${all_platforms} x86-darwin10-gcc"
 127 all_platforms="${all_platforms} x86-darwin11-gcc"
 128 all_platforms="${all_platforms} x86-darwin12-gcc"
 129 all_platforms="${all_platforms} x86-darwin13-gcc"
 130 all_platforms="${all_platforms} x86-darwin14-gcc"
 131 all_platforms="${all_platforms} x86-darwin15-gcc"
 132 all_platforms="${all_platforms} x86-darwin16-gcc"
 133 all_platforms="${all_platforms} x86-darwin17-gcc"
 134 all_platforms="${all_platforms} x86-iphonesimulator-gcc"
 135 all_platforms="${all_platforms} x86-linux-gcc"
 136 all_platforms="${all_platforms} x86-linux-icc"
 137 all_platforms="${all_platforms} x86-os2-gcc"
 138 all_platforms="${all_platforms} x86-solaris-gcc"
 139 all_platforms="${all_platforms} x86-win32-gcc"
 140 all_platforms="${all_platforms} x86-win32-vs10"
 141 all_platforms="${all_platforms} x86-win32-vs11"
 142 all_platforms="${all_platforms} x86-win32-vs12"
 143 all_platforms="${all_platforms} x86-win32-vs14"
 144 all_platforms="${all_platforms} x86-win32-vs15"
 145 all_platforms="${all_platforms} x86_64-android-gcc"
 146 all_platforms="${all_platforms} x86_64-darwin9-gcc"
 147 all_platforms="${all_platforms} x86_64-darwin10-gcc"
 148 all_platforms="${all_platforms} x86_64-darwin11-gcc"
 149 all_platforms="${all_platforms} x86_64-darwin12-gcc"
 150 all_platforms="${all_platforms} x86_64-darwin13-gcc"
 151 all_platforms="${all_platforms} x86_64-darwin14-gcc"
 152 all_platforms="${all_platforms} x86_64-darwin15-gcc"
 153 all_platforms="${all_platforms} x86_64-darwin16-gcc"
 154 all_platforms="${all_platforms} x86_64-darwin17-gcc"
 155 all_platforms="${all_platforms} x86_64-iphonesimulator-gcc"
 156 all_platforms="${all_platforms} x86_64-linux-gcc"
 157 all_platforms="${all_platforms} x86_64-linux-icc"
 158 all_platforms="${all_platforms} x86_64-solaris-gcc"
 159 all_platforms="${all_platforms} x86_64-win64-gcc"
 160 all_platforms="${all_platforms} x86_64-win64-vs10"
 161 all_platforms="${all_platforms} x86_64-win64-vs11"
 162 all_platforms="${all_platforms} x86_64-win64-vs12"
 163 all_platforms="${all_platforms} x86_64-win64-vs14"
 164 all_platforms="${all_platforms} x86_64-win64-vs15"
 165 all_platforms="${all_platforms} generic-gnu"
 166
 167 # all_targets is a list of all targets that can be configured
 168 # note that these should be in dependency order for now.
 169 all_targets="libs examples tools docs"
 170
 171 # all targets available are enabled, by default.
 172 for t in ${all_targets}; do
 173     [ -f "${source_path}/${t}.mk" ] && enable_feature ${t}
 174 done
 175
 176 if ! diff --version >/dev/null; then
 177   die "diff missing: Try installing diffutils via your package manager."
 178 fi
 179
 180 if ! perl --version >/dev/null; then
 181     die "Perl is required to build"
 182 fi
 183
 184 if [ "`cd \"${source_path}\" && pwd`" != "`pwd`" ]; then
 185   # test to see if source_path already configured
 186   if [ -f "${source_path}/vpx_config.h" ]; then
 187     die "source directory already configured; run 'make distclean' there first"
 188   fi
 189 fi
 190
 191 # check installed doxygen version
 192 doxy_version=$(doxygen --version 2>/dev/null)
 193 doxy_major=${doxy_version%%.*}
 194 if [ ${doxy_major:-0} -ge 1 ]; then
 195     doxy_version=${doxy_version#*.}
 196     doxy_minor=${doxy_version%%.*}
 197     doxy_patch=${doxy_version##*.}
 198
 199     [ $doxy_major -gt 1 ] && enable_feature doxygen
 200     [ $doxy_minor -gt 5 ] && enable_feature doxygen
 201     [ $doxy_minor -eq 5 ] && [ $doxy_patch -ge 3 ] && enable_feature doxygen
 202 fi
 203
 204 # disable codecs when their source directory does not exist
 205 [ -d "${source_path}/vp8" ] || disable_codec vp8
 206 [ -d "${source_path}/vp9" ] || disable_codec vp9
 207
 208 # install everything except the sources, by default. sources will have
 209 # to be enabled when doing dist builds, since that's no longer a common
 210 # case.
 211 enabled doxygen && enable_feature install_docs
 212 enable_feature install_bins
 213 enable_feature install_libs
 214
 215 enable_feature static
 216 enable_feature optimizations
 217 enable_feature dependency_tracking
 218 enable_feature spatial_resampling
 219 enable_feature multithread
 220 enable_feature os_support
 221 enable_feature temporal_denoising
 222
 223 CODECS="
 224     vp8_encoder
 225     vp8_decoder
 226     vp9_encoder
 227     vp9_decoder
 228 "
 229 CODEC_FAMILIES="
 230     vp8
 231     vp9
 232 "
 233
 234 ARCH_LIST="
 235     arm
 236     mips
 237     x86
 238     x86_64
 239     ppc
 240 "
 241 ARCH_EXT_LIST_X86="
 242     mmx
 243     sse
 244     sse2
 245     sse3
 246     ssse3
 247     sse4_1
 248     avx
 249     avx2
 250     avx512
 251 "
 252
 253 ARCH_EXT_LIST_LOONGSON="
 254     mmi
 255 "
 256
 257 ARCH_EXT_LIST="
 258     neon
 259     neon_asm
 260
 261     mips32
 262     dspr2
 263     msa
 264     mips64
 265
 266     ${ARCH_EXT_LIST_X86}
 267
 268     vsx
 269
 270     ${ARCH_EXT_LIST_LOONGSON}
 271 "
 272 HAVE_LIST="
 273     ${ARCH_EXT_LIST}
 274     vpx_ports
 275     pthread_h
 276     unistd_h
 277 "
 278 EXPERIMENT_LIST="
 279     fp_mb_stats
 280     emulate_hardware
 281 "
 282 CONFIG_LIST="
 283     dependency_tracking
 284     external_build
 285     install_docs
 286     install_bins
 287     install_libs
 288     install_srcs
 289     debug
 290     gprof
 291     gcov
 292     rvct
 293     gcc
 294     msvs
 295     pic
 296     big_endian
 297
 298     codec_srcs
 299     debug_libs
 300
 301     dequant_tokens
 302     dc_recon
 303     runtime_cpu_detect
 304     postproc
 305     vp9_postproc
 306     multithread
 307     internal_stats
 308     ${CODECS}
 309     ${CODEC_FAMILIES}
 310     encoders
 311     decoders
 312     static_msvcrt
 313     spatial_resampling
 314     realtime_only
 315     onthefly_bitpacking
 316     error_concealment
 317     shared
 318     static
 319     small
 320     postproc_visualizer
 321     os_support
 322     unit_tests
 323     webm_io
 324     libyuv
 325     decode_perf_tests
 326     encode_perf_tests
 327     multi_res_encoding
 328     temporal_denoising
 329     vp9_temporal_denoising
 330     consistent_recode
 331     coefficient_range_checking
 332     vp9_highbitdepth
 333     better_hw_compatibility
 334     experimental
 335     size_limit
 336     always_adjust_bpm
 337     ${EXPERIMENT_LIST}
 338 "
 339 CMDLINE_SELECT="
 340     dependency_tracking
 341     external_build
 342     extra_warnings
 343     werror
 344     install_docs
 345     install_bins
 346     install_libs
 347     install_srcs
 348     debug
 349     gprof
 350     gcov
 351     pic
 352     optimizations
 353     ccache
 354     runtime_cpu_detect
 355     thumb
 356
 357     libs
 358     examples
 359     tools
 360     docs
 361     libc
 362     as
 363     size_limit
 364     codec_srcs
 365     debug_libs
 366
 367     dequant_tokens
 368     dc_recon
 369     postproc
 370     vp9_postproc
 371     multithread
 372     internal_stats
 373     ${CODECS}
 374     ${CODEC_FAMILIES}
 375     static_msvcrt
 376     spatial_resampling
 377     realtime_only
 378     onthefly_bitpacking
 379     error_concealment
 380     shared
 381     static
 382     small
 383     postproc_visualizer
 384     unit_tests
 385     webm_io
 386     libyuv
 387     decode_perf_tests
 388     encode_perf_tests
 389     multi_res_encoding
 390     temporal_denoising
 391     vp9_temporal_denoising
 392     consistent_recode
 393     coefficient_range_checking
 394     better_hw_compatibility
 395     vp9_highbitdepth
 396     experimental
 397     always_adjust_bpm
 398 "
 399
 400 process_cmdline() {
 401     for opt do
 402         optval="${opt#*=}"
 403         case "$opt" in
 404         --disable-codecs)
 405           for c in ${CODEC_FAMILIES}; do disable_codec $c; done
 406           ;;
 407         --enable-?*|--disable-?*)
 408         eval `echo "$opt" | sed 's/--/action=/;s/-/ option=/;s/-/_/g'`
 409         if is_in ${option} ${EXPERIMENT_LIST}; then
 410             if enabled experimental; then
 411                 ${action}_feature $option
 412             else
 413                 log_echo "Ignoring $opt -- not in experimental mode."
 414             fi
 415         elif is_in ${option} "${CODECS} ${CODEC_FAMILIES}"; then
 416             ${action}_codec ${option}
 417         else
 418             process_common_cmdline $opt
 419         fi
 420         ;;
 421         *) process_common_cmdline "$opt"
 422         ;;
 423         esac
 424     done
 425 }
 426
 427 post_process_cmdline() {
 428     c=""
 429
 430     # Enable all detected codecs, if they haven't been disabled
 431     for c in ${CODECS}; do soft_enable $c; done
 432
 433     # Enable the codec family if any component of that family is enabled
 434     for c in ${CODECS}; do
 435         enabled $c && enable_feature ${c%_*}
 436     done
 437
 438     # Set the {en,de}coders variable if any algorithm in that class is enabled
 439     for c in ${CODECS}; do
 440         enabled ${c} && enable_feature ${c##*_}s
 441     done
 442 }
 443
 444
 445 process_targets() {
 446     enabled child || write_common_config_banner
 447     write_common_target_config_h ${BUILD_PFX}vpx_config.h
 448     write_common_config_targets
 449
 450     # Calculate the default distribution name, based on the enabled features
 451     cf=""
 452     DIST_DIR=vpx
 453     for cf in $CODEC_FAMILIES; do
 454         if enabled ${cf}_encoder && enabled ${cf}_decoder; then
 455             DIST_DIR="${DIST_DIR}-${cf}"
 456         elif enabled ${cf}_encoder; then
 457             DIST_DIR="${DIST_DIR}-${cf}cx"
 458         elif enabled ${cf}_decoder; then
 459             DIST_DIR="${DIST_DIR}-${cf}dx"
 460         fi
 461     done
 462     enabled debug_libs && DIST_DIR="${DIST_DIR}-debug"
 463     enabled codec_srcs && DIST_DIR="${DIST_DIR}-src"
 464     ! enabled postproc && ! enabled vp9_postproc && DIST_DIR="${DIST_DIR}-nopost"
 465     ! enabled multithread && DIST_DIR="${DIST_DIR}-nomt"
 466     ! enabled install_docs && DIST_DIR="${DIST_DIR}-nodocs"
 467     DIST_DIR="${DIST_DIR}-${tgt_isa}-${tgt_os}"
 468     case "${tgt_os}" in
 469     win*) enabled static_msvcrt && DIST_DIR="${DIST_DIR}mt" || DIST_DIR="${DIST_DIR}md"
 470           DIST_DIR="${DIST_DIR}-${tgt_cc}"
 471           ;;
 472     esac
 473     if [ -f "${source_path}/build/make/version.sh" ]; then
 474         ver=`"$source_path/build/make/version.sh" --bare "$source_path"`
 475         DIST_DIR="${DIST_DIR}-${ver}"
 476         VERSION_STRING=${ver}
 477         ver=${ver%%-*}
 478         VERSION_PATCH=${ver##*.}
 479         ver=${ver%.*}
 480         VERSION_MINOR=${ver##*.}
 481         ver=${ver#v}
 482         VERSION_MAJOR=${ver%.*}
 483     fi
 484     enabled child || cat <<EOF >> config.mk
 485
 486 PREFIX=${prefix}
 487 ifeq (\$(MAKECMDGOALS),dist)
 488 DIST_DIR?=${DIST_DIR}
 489 else
 490 DIST_DIR?=\$(DESTDIR)${prefix}
 491 endif
 492 LIBSUBDIR=${libdir##${prefix}/}
 493
 494 VERSION_STRING=${VERSION_STRING}
 495
 496 VERSION_MAJOR=${VERSION_MAJOR}
 497 VERSION_MINOR=${VERSION_MINOR}
 498 VERSION_PATCH=${VERSION_PATCH}
 499
 500 CONFIGURE_ARGS=${CONFIGURE_ARGS}
 501 EOF
 502     enabled child || echo "CONFIGURE_ARGS?=${CONFIGURE_ARGS}" >> config.mk
 503
 504     #
 505     # Write makefiles for all enabled targets
 506     #
 507     for tgt in libs examples tools docs solution; do
 508         tgt_fn="$tgt-$toolchain.mk"
 509
 510         if enabled $tgt; then
 511             echo "Creating makefiles for ${toolchain} ${tgt}"
 512             write_common_target_config_mk $tgt_fn ${BUILD_PFX}vpx_config.h
 513             #write_${tgt}_config
 514         fi
 515     done
 516
 517 }
 518
 519 process_detect() {
 520     if enabled shared; then
 521         # Can only build shared libs on a subset of platforms. Doing this check
 522         # here rather than at option parse time because the target auto-detect
 523         # magic happens after the command line has been parsed.
 524         case "${tgt_os}" in
 525         linux|os2|solaris|darwin*|iphonesimulator*)
 526             # Supported platforms
 527             ;;
 528         *)
 529             if enabled gnu; then
 530                 echo "--enable-shared is only supported on ELF; assuming this is OK"
 531             else
 532                 die "--enable-shared only supported on ELF, OS/2, and Darwin for now"
 533             fi
 534             ;;
 535         esac
 536     fi
 537     if [ -z "$CC" ] || enabled external_build; then
 538         echo "Bypassing toolchain for environment detection."
 539         enable_feature external_build
 540         check_header() {
 541             log fake_check_header "$@"
 542             header=$1
 543             shift
 544             var=`echo $header | sed 's/[^A-Za-z0-9_]/_/g'`
 545             disable_feature $var
 546             # Headers common to all environments
 547             case $header in
 548                 stdio.h)
 549                     true;
 550                 ;;
 551                 *)
 552                     result=false
 553                     for d in "$@"; do
 554                         [ -f "${d##-I}/$header" ] && result=true && break
 555                     done
 556                     ${result:-true}
 557             esac && enable_feature $var
 558
 559             # Specialize windows and POSIX environments.
 560             case $toolchain in
 561                 *-win*-*)
 562                     # Don't check for any headers in Windows builds.
 563                     false
 564                 ;;
 565                 *)
 566                     case $header in
 567                         pthread.h) true;;
 568                         unistd.h) true;;
 569                         *) false;;
 570                     esac && enable_feature $var
 571             esac
 572             enabled $var
 573         }
 574         check_ld() {
 575             true
 576         }
 577         check_lib() {
 578             true
 579         }
 580     fi
 581     check_header stdio.h || die "Unable to invoke compiler: ${CC} ${CFLAGS}"
 582     check_ld <<EOF || die "Toolchain is unable to link executables"
 583 int main(void) {return 0;}
 584 EOF
 585     # check system headers
 586
 587     # Use both check_header and check_lib here, since check_lib
 588     # could be a stub that always returns true.
 589     check_header pthread.h && check_lib -lpthread <<EOF || disable_feature pthread_h
 590 #include <pthread.h>
 591 #include <stddef.h>
 592 int main(void) { return pthread_create(NULL, NULL, NULL, NULL); }
 593 EOF
 594     check_header unistd.h # for sysconf(3) and friends.
 595
 596     check_header vpx/vpx_integer.h -I${source_path} && enable_feature vpx_ports
 597
 598     if enabled neon && ! enabled external_build; then
 599       check_header arm_neon.h || die "Unable to find arm_neon.h"
 600     fi
 601 }
 602
 603 process_toolchain() {
 604     process_common_toolchain
 605
 606     # Enable some useful compiler flags
 607     if enabled gcc; then
 608         enabled werror && check_add_cflags -Werror
 609         check_add_cflags -Wall
 610         check_add_cflags -Wdeclaration-after-statement
 611         check_add_cflags -Wdisabled-optimization
 612         check_add_cflags -Wfloat-conversion
 613         check_add_cflags -Wparentheses-equality
 614         check_add_cflags -Wpointer-arith
 615         check_add_cflags -Wtype-limits
 616         check_add_cflags -Wcast-qual
 617         check_add_cflags -Wvla
 618         check_add_cflags -Wimplicit-function-declaration
 619         check_add_cflags -Wuninitialized
 620         check_add_cflags -Wunused
 621         # -Wextra has some tricky cases. Rather than fix them all now, get the
 622         # flag for as many files as possible and fix the remaining issues
 623         # piecemeal.
 624         # https://bugs.chromium.org/p/webm/issues/detail?id=1069
 625         check_add_cflags -Wextra
 626         # check_add_cflags also adds to cxxflags. gtest does not do well with
 627         # these flags so add them explicitly to CFLAGS only.
 628         check_cflags -Wundef && add_cflags_only -Wundef
 629         check_cflags -Wframe-larger-than=52000 && \
 630           add_cflags_only -Wframe-larger-than=52000
 631         if enabled mips || [ -z "${INLINE}" ]; then
 632           enabled extra_warnings || check_add_cflags -Wno-unused-function
 633         fi
 634         # Avoid this warning for third_party C++ sources. Some reorganization
 635         # would be needed to apply this only to test/*.cc.
 636         check_cflags -Wshorten-64-to-32 && add_cflags_only -Wshorten-64-to-32
 637     fi
 638
 639     if enabled icc; then
 640         enabled werror && check_add_cflags -Werror
 641         check_add_cflags -Wall
 642         check_add_cflags -Wpointer-arith
 643
 644         # ICC has a number of floating point optimizations that we disable
 645         # in favor of deterministic output WRT to other compilers
 646         add_cflags -fp-model precise
 647     fi
 648
 649     # Enable extra, harmless warnings. These might provide additional insight
 650     # to what the compiler is doing and why, but in general, but they shouldn't
 651     # be treated as fatal, even if we're treating warnings as errors.
 652     GCC_EXTRA_WARNINGS="
 653         -Wdisabled-optimization
 654         -Winline
 655     "
 656     enabled gcc && EXTRA_WARNINGS="${GCC_EXTRA_WARNINGS}"
 657     RVCT_EXTRA_WARNINGS="
 658         --remarks
 659     "
 660     enabled rvct && EXTRA_WARNINGS="${RVCT_EXTRA_WARNINGS}"
 661     if enabled extra_warnings; then
 662         for w in ${EXTRA_WARNINGS}; do
 663             check_add_cflags ${w}
 664             enabled gcc && enabled werror && check_add_cflags -Wno-error=${w}
 665         done
 666     fi
 667
 668     # ccache only really works on gcc toolchains
 669     enabled gcc || soft_disable ccache
 670     if enabled mips; then
 671         enable_feature dequant_tokens
 672         enable_feature dc_recon
 673     fi
 674
 675     if enabled internal_stats; then
 676         enable_feature vp9_postproc
 677     fi
 678
 679     # Enable the postbuild target if building for visual studio.
 680     case "$tgt_cc" in
 681         vs*) enable_feature msvs
 682              enable_feature solution
 683              vs_version=${tgt_cc##vs}
 684              VCPROJ_SFX=vcxproj
 685              gen_vcproj_cmd=${source_path}/build/make/gen_msvs_vcxproj.sh
 686              enabled werror && gen_vcproj_cmd="${gen_vcproj_cmd} --enable-werror"
 687              all_targets="${all_targets} solution"
 688              INLINE="__inline"
 689         ;;
 690     esac
 691
 692     # Other toolchain specific defaults
 693     case $toolchain in x86*) soft_enable postproc;; esac
 694
 695     if enabled postproc_visualizer; then
 696         enabled postproc || die "postproc_visualizer requires postproc to be enabled"
 697     fi
 698
 699     # Enable unit tests by default if we have a working C++ compiler.
 700     case "$toolchain" in
 701         *-vs*)
 702             soft_enable unit_tests
 703             soft_enable webm_io
 704             soft_enable libyuv
 705         ;;
 706         *-android-*)
 707             check_add_cxxflags -std=c++11 && soft_enable webm_io
 708             soft_enable libyuv
 709             # GTestLog must be modified to use Android logging utilities.
 710         ;;
 711         *-darwin-*)
 712             # iOS/ARM builds do not work with gtest. This does not match
 713             # x86 targets.
 714         ;;
 715         *-iphonesimulator-*)
 716             check_add_cxxflags -std=c++11 && soft_enable webm_io
 717             soft_enable libyuv
 718         ;;
 719         *-win*)
 720             # Some mingw toolchains don't have pthread available by default.
 721             # Treat these more like visual studio where threading in gtest
 722             # would be disabled for the same reason.
 723             check_cxx "$@" <<EOF && soft_enable unit_tests
 724 int z;
 725 EOF
 726             check_add_cxxflags -std=c++11 && soft_enable webm_io
 727             check_cxx "$@" <<EOF && soft_enable libyuv
 728 int z;
 729 EOF
 730         ;;
 731         *)
 732             enabled pthread_h && check_cxx "$@" <<EOF && soft_enable unit_tests
 733 int z;
 734 EOF
 735             check_add_cxxflags -std=c++11 && soft_enable webm_io
 736             check_cxx "$@" <<EOF && soft_enable libyuv
 737 int z;
 738 EOF
 739         ;;
 740     esac
 741     # libwebm needs to be linked with C++ standard library
 742     enabled webm_io && LD=${CXX}
 743
 744     # append any user defined extra cflags
 745     if [ -n "${extra_cflags}" ] ; then
 746         check_add_cflags ${extra_cflags} || \
 747         die "Requested extra CFLAGS '${extra_cflags}' not supported by compiler"
 748     fi
 749     if [ -n "${extra_cxxflags}" ]; then
 750         check_add_cxxflags ${extra_cxxflags} || \
 751         die "Requested extra CXXFLAGS '${extra_cxxflags}' not supported by compiler"
 752     fi
 753 }
 754
 755
 756 ##
 757 ## END APPLICATION SPECIFIC CONFIGURATION
 758 ##
 759 CONFIGURE_ARGS="$@"
 760 process "$@"
 761 print_webm_license ${BUILD_PFX}vpx_config.c "/*" " */"
 762 cat <<EOF >> ${BUILD_PFX}vpx_config.c
 763 #include "vpx/vpx_codec.h"
 764 static const char* const cfg = "$CONFIGURE_ARGS";
 765 const char *vpx_codec_build_config(void) {return cfg;}
 766 EOF