configure

   1 #!/bin/bash
   2 ##
   3 ##  Copyright (c) 2010 The VP8 project authors. All Rights Reserved.
   4 ##
   5 ##  Use of this source code is governed by a BSD-style license and patent
   6 ##  grant that can be found in the LICENSE file in the root of the source
   7 ##  tree. All contributing project authors may be found in the AUTHORS
   8 ##  file in the root of the source tree.
   9 ##
  10
  11
  12 #source_path="`dirname \"$0\"`"
  13 source_path=${0%/*}
  14 . "${source_path}/build/make/configure.sh"
  15
  16 show_help(){
  17     show_help_pre
  18     cat << EOF
  19 Advanced options:
  20   ${toggle_libs}                  don't build libraries
  21   ${toggle_examples}              don't build examples
  22   --libc=PATH                     path to alternate libc
  23   ${toggle_fast_unaligned}        don't use unaligned accesses, even when
  24                                   supported by hardware [auto]
  25   ${toggle_codec_srcs}            in/exclude codec library source code
  26   ${toggle_debug_libs}            in/exclude debug version of libraries
  27   ${toggle_eval_limit}            enable limited evaluation build
  28   ${toggle_md5}                   support for output of checksum data
  29   ${toggle_static_msvcrt}         use static MSVCRT (VS builds only)
  30   ${toggle_vp8}                   VP8 codec support
  31   ${toggle_psnr}                  output of PSNR data, if supported (encoders)
  32   ${toggle_mem_tracker}           track memory usage
  33   ${toggle_eval_limit}            decoder limitted to 500 frames
  34   ${toggle_postproc}              postprocessing
  35   ${toggle_multithread}           multithreaded encoding and decoding.
  36   ${toggle_spatial_resampling}    spatial sampling (scaling) support
  37   ${toggle_realtime_only}         enable this option while building for real-time encoding
  38   ${toggle_runtime_cpu_detect}    runtime cpu detection
  39
  40 Codecs:
  41   Codecs can be selectively enabled or disabled individually, or by family:
  42       --disable-<codec>
  43   is equivalent to:
  44       --disable-<codec>-encoder
  45       --disable-<codec>-decoder
  46
  47   Codecs available in this distribution:
  48 EOF
  49 #restore editor state '
  50
  51     local family;
  52     local last_family;
  53     local c;
  54     local str;
  55     for c in ${CODECS}; do
  56         family=${c%_*}
  57         if [ "${family}" != "${last_family}" ]; then
  58             [ -z "${str}" ] || echo "${str}"
  59             str="$(printf '    %10s:' ${family})"
  60         fi
  61         str="${str} $(printf '%10s' ${c#*_})"
  62         last_family=${family}
  63     done
  64     echo "${str}"
  65     show_help_post
  66 }
  67
  68 ##
  69 ## BEGIN APPLICATION SPECIFIC CONFIGURATION
  70 ##
  71
  72 # all_platforms is a list of all supported target platforms. Maintain
  73 # alphabetically by architecture, generic-gnu last.
  74 all_platforms="${all_platforms} armv5te-linux-rvct"
  75 all_platforms="${all_platforms} armv5te-linux-gcc"
  76 all_platforms="${all_platforms} armv5te-symbian-gcc"
  77 all_platforms="${all_platforms} armv5te-wince-vs8"
  78 all_platforms="${all_platforms} armv6-darwin-gcc"
  79 all_platforms="${all_platforms} armv6-linux-rvct"
  80 all_platforms="${all_platforms} armv6-linux-gcc"
  81 all_platforms="${all_platforms} armv6-symbian-gcc"
  82 all_platforms="${all_platforms} armv6-wince-vs8"
  83 all_platforms="${all_platforms} iwmmxt-linux-rvct"
  84 all_platforms="${all_platforms} iwmmxt-linux-gcc"
  85 all_platforms="${all_platforms} iwmmxt-wince-vs8"
  86 all_platforms="${all_platforms} iwmmxt2-linux-rvct"
  87 all_platforms="${all_platforms} iwmmxt2-linux-gcc"
  88 all_platforms="${all_platforms} iwmmxt2-wince-vs8"
  89 all_platforms="${all_platforms} armv7-darwin-gcc"    #neon Cortex-A8
  90 all_platforms="${all_platforms} armv7-linux-rvct"    #neon Cortex-A8
  91 all_platforms="${all_platforms} armv7-linux-gcc"     #neon Cortex-A8
  92 all_platforms="${all_platforms} mips32-linux-gcc"
  93 all_platforms="${all_platforms} ppc32-darwin8-gcc"
  94 all_platforms="${all_platforms} ppc32-darwin9-gcc"
  95 all_platforms="${all_platforms} ppc64-darwin8-gcc"
  96 all_platforms="${all_platforms} ppc64-darwin9-gcc"
  97 all_platforms="${all_platforms} ppc64-linux-gcc"
  98 all_platforms="${all_platforms} x86-darwin8-gcc"
  99 all_platforms="${all_platforms} x86-darwin8-icc"
 100 all_platforms="${all_platforms} x86-darwin9-gcc"
 101 all_platforms="${all_platforms} x86-darwin9-icc"
 102 all_platforms="${all_platforms} x86-linux-gcc"
 103 all_platforms="${all_platforms} x86-linux-icc"
 104 all_platforms="${all_platforms} x86-solaris-gcc"
 105 all_platforms="${all_platforms} x86-win32-gcc"
 106 all_platforms="${all_platforms} x86-win32-vs7"
 107 all_platforms="${all_platforms} x86-win32-vs8"
 108 all_platforms="${all_platforms} x86_64-darwin9-gcc"
 109 all_platforms="${all_platforms} x86_64-linux-gcc"
 110 all_platforms="${all_platforms} x86_64-solaris-gcc"
 111 all_platforms="${all_platforms} x86_64-win64-vs8"
 112 all_platforms="${all_platforms} universal-darwin8-gcc"
 113 all_platforms="${all_platforms} universal-darwin9-gcc"
 114 all_platforms="${all_platforms} generic-gnu"
 115
 116 # all_targets is a list of all targets that can be configured
 117 # note that these should be in dependency order for now.
 118 all_targets="libs examples docs"
 119
 120 # all targets available are enabled, by default.
 121 for t in ${all_targets}; do
 122     [ -f ${source_path}/${t}.mk ] && enable ${t}
 123 done
 124
 125 # check installed doxygen version
 126 doxy_version=$(doxygen --version 2>/dev/null)
 127 doxy_major=${doxy_version%%.*}
 128 if [ ${doxy_major:-0} -ge 1 ]; then
 129     doxy_version=${doxy_version#*.}
 130     doxy_minor=${doxy_version%%.*}
 131     doxy_patch=${doxy_version##*.}
 132
 133     [ $doxy_major -gt 1 ] && enable doxygen
 134     [ $doxy_minor -gt 5 ] && enable doxygen
 135     [ $doxy_minor -eq 5 ] && [ $doxy_patch -ge 3 ] && enable doxygen
 136 fi
 137
 138 # install everything except the sources, by default. sources will have
 139 # to be enabled when doing dist builds, since that's no longer a common
 140 # case.
 141 enabled doxygen && php -v >/dev/null 2>&1 && enable install_docs
 142 enable install_bins
 143 enable install_libs
 144
 145 enable optimizations
 146 enable fast_unaligned #allow unaligned accesses, if supported by hw
 147 enable md5
 148 enable spatial_resampling
 149 enable multithread
 150
 151 [ -d ${source_path}/../include ] && enable alt_tree_layout
 152 for d in vp8; do
 153     [ -d ${source_path}/${d} ] && disable alt_tree_layout;
 154 done
 155
 156 if ! enabled alt_tree_layout; then
 157 # development environment
 158 [ -d ${source_path}/vp8 ] && CODECS="${CODECS} vp8_encoder vp8_decoder"
 159 else
 160 # customer environment
 161 [ -f ${source_path}/../include/vpx/vp8cx.h ] && CODECS="${CODECS} vp8_encoder"
 162 [ -f ${source_path}/../include/vpx/vp8dx.h ] && CODECS="${CODECS} vp8_decoder"
 163
 164 [ -f ${source_path}/../lib/*/*mt.lib ] && soft_enable static_msvcrt
 165 fi
 166
 167 CODECS="$(echo ${CODECS} | tr ' ' '\n')"
 168 CODEC_FAMILIES="$(for c in ${CODECS}; do echo ${c%_*}; done | sort | uniq)"
 169
 170 ARCH_LIST="
 171     arm
 172     mips
 173     x86
 174     x86_64
 175     ppc32
 176     ppc64
 177 "
 178 ARCH_EXT_LIST="
 179     armv5te
 180     armv6
 181     armv7
 182     iwmmxt
 183     iwmmxt2
 184
 185     mips32
 186
 187     mmx
 188     sse
 189     sse2
 190     sse3
 191     ssse3
 192
 193     altivec
 194 "
 195 HAVE_LIST="
 196     ${ARCH_EXT_LIST}
 197     vpx_ports
 198     stdint_h
 199     alt_tree_layout
 200     pthread_h
 201     sys_mman_h
 202 "
 203 CONFIG_LIST="
 204     external_build
 205     install_docs
 206     install_bins
 207     install_libs
 208     install_srcs
 209     debug
 210     gprof
 211     gcov
 212     rvct
 213     gcc
 214     msvs
 215     pic
 216     big_endian
 217
 218     codec_srcs
 219     debug_libs
 220     fast_unaligned
 221     mem_manager
 222     mem_tracker
 223     mem_checks
 224     md5
 225
 226     dequant_tokens
 227     dc_recon
 228     new_tokens
 229     eval_limit
 230     runtime_cpu_detect
 231     postproc
 232     postproc_generic
 233     multithread
 234     psnr
 235     ${CODECS}
 236     ${CODEC_FAMILIES}
 237     encoders
 238     decoders
 239     static_msvcrt
 240     spatial_resampling
 241     realtime_only
 242 "
 243 CMDLINE_SELECT="
 244     extra_warnings
 245     werror
 246     install_docs
 247     install_bins
 248     install_libs
 249     install_srcs
 250     debug
 251     gprof
 252     gcov
 253     pic
 254     optimizations
 255     ccache
 256     runtime_cpu_detect
 257
 258     libs
 259     examples
 260     libc
 261     fast_unaligned
 262     codec_srcs
 263     debug_libs
 264     md5
 265
 266     dequant_tokens
 267     dc_recon
 268     new_tokens
 269     eval_limit
 270     postproc
 271     postproc_generic
 272     multithread
 273     psnr
 274     ${CODECS}
 275     ${CODEC_FAMILIES}
 276     static_msvcrt
 277     mem_tracker
 278     spatial_resampling
 279     realtime_only
 280 "
 281
 282 process_cmdline() {
 283     for opt do
 284         optval="${opt#*=}"
 285         case "$opt" in
 286         --disable-codecs) for c in ${CODECS}; do disable $c; done ;;
 287         *) process_common_cmdline $opt
 288         ;;
 289         esac
 290     done
 291 }
 292
 293 post_process_cmdline() {
 294     local c
 295
 296     # If the codec family is disabled, disable all components of that family.
 297     # If the codec family is enabled, enable all components of that family.
 298     log_echo "Configuring selected codecs"
 299     for c in ${CODECS}; do
 300         disabled ${c%%_*} && disable ${c}
 301         enabled ${c%%_*} && enable ${c}
 302     done
 303
 304     # Enable all detected codecs, if they haven't been disabled
 305     for c in ${CODECS}; do soft_enable $c; done
 306
 307     # Enable the codec family if any component of that family is enabled
 308     for c in ${CODECS}; do
 309         enabled $c && enable ${c%_*}
 310     done
 311
 312     # Set the {en,de}coders variable if any algorithm in that class is enabled
 313     for c in ${CODECS}; do
 314         enabled ${c} && enable ${c##*_}s
 315     done
 316
 317
 318 }
 319
 320
 321 process_targets() {
 322     enabled child || write_common_config_banner
 323     enabled universal || write_common_target_config_h  ${BUILD_PFX}vpx_config.h
 324
 325     # TODO: add host tools target (obj_int_extract, etc)
 326
 327     # For fat binaries, call configure recursively to configure for each
 328     # binary architecture to be included.
 329     if enabled universal; then
 330         # Call configure (ourselves) for each subarchitecture
 331         for arch in $fat_bin_archs; do
 332             BUILD_PFX=${arch}/ toolchain=${arch} $self --child $cmdline_args || exit $?
 333         done
 334     fi
 335
 336     # The write_common_config (config.mk) logic is deferred until after the
 337     # recursive calls to configure complete, becuase we want our universal
 338     # targets to be executed last.
 339     write_common_config_targets
 340     enabled universal && echo "FAT_ARCHS=${fat_bin_archs}" >> config.mk
 341
 342     # Calculate the default distribution name, based on the enabled features
 343     local cf
 344     local DIST_DIR=vpx
 345     for cf in $CODEC_FAMILIES; do
 346         if enabled ${cf}_encoder && enabled ${cf}_decoder; then
 347             DIST_DIR="${DIST_DIR}-${cf}"
 348         elif enabled ${cf}_encoder; then
 349             DIST_DIR="${DIST_DIR}-${cf}cx"
 350         elif enabled ${cf}_decoder; then
 351             DIST_DIR="${DIST_DIR}-${cf}dx"
 352         fi
 353     done
 354     enabled debug_libs && DIST_DIR="${DIST_DIR}-debug"
 355     enabled codec_srcs && DIST_DIR="${DIST_DIR}-src"
 356     ! enabled postproc && DIST_DIR="${DIST_DIR}-nopost"
 357     ! enabled multithread && DIST_DIR="${DIST_DIR}-nomt"
 358     enabled eval_limit && DIST_DIR="${DIST_DIR}-eval"
 359     ! enabled install_docs && DIST_DIR="${DIST_DIR}-nodocs"
 360     DIST_DIR="${DIST_DIR}-${tgt_isa}-${tgt_os}"
 361     case "${tgt_os}" in
 362     win*) enabled static_msvcrt && DIST_DIR="${DIST_DIR}mt" || DIST_DIR="${DIST_DIR}md"
 363           DIST_DIR="${DIST_DIR}-${tgt_cc}"
 364           ;;
 365     esac
 366     if [ -f "${source_path}/build/make/version.sh" ]; then
 367         local ver=`"$source_path/build/make/version.sh" --bare $source_path`
 368         DIST_DIR="${DIST_DIR}-${ver}"
 369     fi
 370     enabled child || cat <<EOF >> config.mk
 371 ifeq (\$(MAKECMDGOALS),dist)
 372 DESTDIR?=${DIST_DIR}
 373 else
 374 DESTDIR?=/usr/local
 375 endif
 376 DIST_DIR?=\$(DESTDIR)
 377 EOF
 378     enabled child || echo "CONFIGURE_ARGS?=${CONFIGURE_ARGS}" >> config.mk
 379
 380     #
 381     # Write makefiles for all enabled targets
 382     #
 383     for tgt in libs examples docs solution; do
 384         local tgt_fn="$tgt-$toolchain.mk"
 385
 386         if enabled $tgt; then
 387             echo "Creating makefiles for ${toolchain} ${tgt}"
 388             write_common_target_config_mk $tgt_fn ${BUILD_PFX}vpx_config.h
 389             #write_${tgt}_config
 390         fi
 391     done
 392
 393 }
 394
 395 process_detect() {
 396     if [ -z "$CC" ]; then
 397         echo "Bypassing toolchain for environment detection."
 398         enable external_build
 399         check_header() {
 400             log fake_check_header "$@"
 401             header=$1
 402             shift
 403             var=`echo $header | sed 's/[^A-Za-z0-9_]/_/g'`
 404             disable $var
 405             case $header in
 406                 stdio.h)
 407                     true;
 408                 ;;
 409                 *)
 410                     local result=false
 411                     for d in "$@"; do
 412                         [ -f "${d##-I}/$header" ] && result=true && break
 413                     done
 414                     ${result:-true}
 415             esac && enable $var
 416         }
 417         check_ld() {
 418             true
 419         }
 420     fi
 421     check_header stdio.h || die "Unable to invoke compiler: ${CC} ${CFLAGS}"
 422     check_ld <<EOF || die "Toolchain is unable to link executables"
 423 int main(void) {return 0;}
 424 EOF
 425     # check system headers
 426     check_header stdint.h
 427     check_header pthread.h
 428     check_header sys/mman.h
 429
 430     check_header vpx/vpx_integer.h -I${source_path} && enable vpx_ports
 431 }
 432
 433 process_toolchain() {
 434     process_common_toolchain
 435
 436     # Handle universal binaries for this architecture
 437     case $toolchain in
 438         universal-darwin*)
 439             local darwin_ver=${tgt_os##darwin}
 440             fat_bin_archs="$fat_bin_archs ppc32-${tgt_os}-gcc"
 441
 442             # Intel
 443             fat_bin_archs="$fat_bin_archs x86-${tgt_os}-${tgt_cc}"
 444             if [ $darwin_ver -gt 8 ]; then
 445                 fat_bin_archs="$fat_bin_archs x86_64-${tgt_os}-${tgt_cc}"
 446             fi
 447             ;;
 448     esac
 449
 450
 451     # Enable some useful compiler flags
 452     if enabled gcc; then
 453         enabled werror && check_add_cflags -Werror
 454         check_add_cflags -Wall
 455         check_add_cflags -Wdeclaration-after-statement
 456         check_add_cflags -Wdisabled-optimization
 457         check_add_cflags -Wpointer-arith
 458         check_add_cflags -Wtype-limits
 459         check_add_cflags -Wcast-qual
 460         enabled extra_warnings || check_add_cflags -Wno-unused
 461     fi
 462
 463     if enabled icc; then
 464         enabled werror && check_add_cflags -Werror
 465         check_add_cflags -Wall
 466         check_add_cflags -Wpointer-arith
 467
 468         # ICC has a number of floating point optimizations that we disable
 469         # in favor of deterministic output WRT to other compilers
 470         add_cflags -fp-model precise
 471     fi
 472
 473     # Enable extra, harmless warnings. These might provide additional insight
 474     # to what the compiler is doing and why, but in general, but they shouldn't
 475     # be treated as fatal, even if we're treating warnings as errors.
 476     GCC_EXTRA_WARNINGS="
 477         -Wdisabled-optimization
 478         -Winline
 479     "
 480     enabled gcc && EXTRA_WARNINGS="${GCC_EXTRA_WARNINGS}"
 481     RVCT_EXTRA_WARNINGS="
 482         --remarks
 483     "
 484     enabled rvct && EXTRA_WARNINGS="${RVCT_EXTRA_WARNINGS}"
 485     if enabled extra_warnings; then
 486         for w in ${EXTRA_WARNINGS}; do
 487             check_add_cflags ${w}
 488             enabled gcc && enabled werror && check_add_cflags -Wno-error=${w}
 489         done
 490     fi
 491
 492     # ccache only really works on gcc toolchains
 493     enabled gcc || soft_disable ccache
 494     if enabled mips; then
 495         enable dequant_tokens
 496         enable dc_recon
 497     fi
 498
 499     # Enable the postbuild target if building for visual studio.
 500     case "$tgt_cc" in
 501         vs*) enable msvs
 502              enable solution
 503              vs_version=${tgt_cc##vs}
 504              all_targets="${all_targets} solution"
 505              INLINE=__inline
 506              FORCEINLINE=__forceinline
 507         ;;
 508     esac
 509
 510     # Other toolchain specific defaults
 511     case $toolchain in x86*|ppc*|universal*) soft_enable postproc;; esac
 512 }
 513
 514
 515 ##
 516 ## END APPLICATION SPECIFIC CONFIGURATION
 517 ##
 518 CONFIGURE_ARGS="$@"
 519 process "$@"
 520 cat <<EOF > ${BUILD_PFX}vpx_config.c
 521 static const char* const cfg = "$CONFIGURE_ARGS";
 522 const char *vpx_codec_build_config(void) {return cfg;}
 523 EOF