#!/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. ## ## This build system is based in part on the FFmpeg configure script. ## #source_path="`dirname \"$0\"`" source_path=${0%/*} . "${source_path}/build/make/configure.sh" show_help(){ show_help_pre cat << EOF Advanced options: ${toggle_libs} libraries ${toggle_examples} examples ${toggle_docs} documentation ${toggle_unit_tests} unit tests ${toggle_decode_perf_tests} build decoder perf tests with unit tests --libc=PATH path to alternate libc --as={yasm|nasm|auto} use specified assembler [auto, yasm preferred] --sdk-path=PATH path to root of sdk (android builds only) ${toggle_fast_unaligned} don't use unaligned accesses, even when supported by hardware [auto] ${toggle_codec_srcs} in/exclude codec library source code ${toggle_debug_libs} in/exclude debug version of libraries ${toggle_static_msvcrt} use static MSVCRT (VS builds only) ${toggle_vp8} VP8 codec support ${toggle_vp9} VP9 codec support ${toggle_internal_stats} output of encoder internal stats for debug, if supported (encoders) ${toggle_mem_tracker} track memory usage ${toggle_postproc} postprocessing ${toggle_vp9_postproc} vp9 specific postprocessing ${toggle_multithread} multithreaded encoding and decoding ${toggle_spatial_resampling} spatial sampling (scaling) support ${toggle_realtime_only} enable this option while building for real-time encoding ${toggle_onthefly_bitpacking} enable on-the-fly bitpacking in real-time encoding ${toggle_error_concealment} enable this option to get a decoder which is able to conceal losses ${toggle_runtime_cpu_detect} runtime cpu detection ${toggle_shared} shared library support ${toggle_static} static library support ${toggle_small} favor smaller size over speed ${toggle_postproc_visualizer} macro block / block level visualizers ${toggle_multi_res_encoding} enable multiple-resolution encoding ${toggle_temporal_denoising} enable temporal denoising and disable the spatial denoiser ${toggle_webm_io} enable input from and output to WebM container Codecs: Codecs can be selectively enabled or disabled individually, or by family: --disable-<codec> is equivalent to: --disable-<codec>-encoder --disable-<codec>-decoder Codecs available in this distribution: EOF #restore editor state ' local family; local last_family; local c; local str; for c in ${CODECS}; do family=${c%_*} if [ "${family}" != "${last_family}" ]; then [ -z "${str}" ] || echo "${str}" str="$(printf ' %10s:' ${family})" fi str="${str} $(printf '%10s' ${c#*_})" last_family=${family} done echo "${str}" show_help_post } ## ## BEGIN APPLICATION SPECIFIC CONFIGURATION ## # all_platforms is a list of all supported target platforms. Maintain # alphabetically by architecture, generic-gnu last. all_platforms="${all_platforms} armv5te-android-gcc" all_platforms="${all_platforms} armv5te-linux-rvct" all_platforms="${all_platforms} armv5te-linux-gcc" all_platforms="${all_platforms} armv5te-none-rvct" all_platforms="${all_platforms} armv6-darwin-gcc" all_platforms="${all_platforms} armv6-linux-rvct" all_platforms="${all_platforms} armv6-linux-gcc" all_platforms="${all_platforms} armv6-none-rvct" all_platforms="${all_platforms} armv7-android-gcc" #neon Cortex-A8 all_platforms="${all_platforms} armv7-darwin-gcc" #neon Cortex-A8 all_platforms="${all_platforms} armv7-linux-rvct" #neon Cortex-A8 all_platforms="${all_platforms} armv7-linux-gcc" #neon Cortex-A8 all_platforms="${all_platforms} armv7-none-rvct" #neon Cortex-A8 all_platforms="${all_platforms} armv7-win32-vs11" all_platforms="${all_platforms} armv7-win32-vs12" all_platforms="${all_platforms} mips32-linux-gcc" all_platforms="${all_platforms} ppc32-darwin8-gcc" all_platforms="${all_platforms} ppc32-darwin9-gcc" all_platforms="${all_platforms} ppc32-linux-gcc" all_platforms="${all_platforms} ppc64-darwin8-gcc" all_platforms="${all_platforms} ppc64-darwin9-gcc" all_platforms="${all_platforms} ppc64-linux-gcc" all_platforms="${all_platforms} sparc-solaris-gcc" all_platforms="${all_platforms} x86-android-gcc" all_platforms="${all_platforms} x86-darwin8-gcc" all_platforms="${all_platforms} x86-darwin8-icc" all_platforms="${all_platforms} x86-darwin9-gcc" all_platforms="${all_platforms} x86-darwin9-icc" all_platforms="${all_platforms} x86-darwin10-gcc" all_platforms="${all_platforms} x86-darwin11-gcc" all_platforms="${all_platforms} x86-darwin12-gcc" all_platforms="${all_platforms} x86-darwin13-gcc" all_platforms="${all_platforms} x86-linux-gcc" all_platforms="${all_platforms} x86-linux-icc" all_platforms="${all_platforms} x86-os2-gcc" all_platforms="${all_platforms} x86-solaris-gcc" all_platforms="${all_platforms} x86-win32-gcc" all_platforms="${all_platforms} x86-win32-vs7" all_platforms="${all_platforms} x86-win32-vs8" all_platforms="${all_platforms} x86-win32-vs9" all_platforms="${all_platforms} x86-win32-vs10" all_platforms="${all_platforms} x86-win32-vs11" all_platforms="${all_platforms} x86-win32-vs12" all_platforms="${all_platforms} x86_64-darwin9-gcc" all_platforms="${all_platforms} x86_64-darwin10-gcc" all_platforms="${all_platforms} x86_64-darwin11-gcc" all_platforms="${all_platforms} x86_64-darwin12-gcc" all_platforms="${all_platforms} x86_64-darwin13-gcc" all_platforms="${all_platforms} x86_64-linux-gcc" all_platforms="${all_platforms} x86_64-linux-icc" all_platforms="${all_platforms} x86_64-solaris-gcc" all_platforms="${all_platforms} x86_64-win64-gcc" all_platforms="${all_platforms} x86_64-win64-vs8" all_platforms="${all_platforms} x86_64-win64-vs9" all_platforms="${all_platforms} x86_64-win64-vs10" all_platforms="${all_platforms} x86_64-win64-vs11" all_platforms="${all_platforms} x86_64-win64-vs12" all_platforms="${all_platforms} universal-darwin8-gcc" all_platforms="${all_platforms} universal-darwin9-gcc" all_platforms="${all_platforms} universal-darwin10-gcc" all_platforms="${all_platforms} universal-darwin11-gcc" 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_feature ${t} done if ! perl --version >/dev/null; then die "Perl is required to build" fi if [ "`cd ${source_path} && pwd`" != "`pwd`" ]; then # test to see if source_path already configured if [ -f ${source_path}/vpx_config.h ]; then die "source directory already configured; run 'make distclean' there first" fi fi # 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_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_feature install_docs enable_feature install_bins enable_feature install_libs enable_feature static enable_feature optimizations enable_feature fast_unaligned #allow unaligned accesses, if supported by hw enable_feature spatial_resampling enable_feature multithread enable_feature os_support enable_feature temporal_denoising [ -d ${source_path}/../include ] && enable_feature alt_tree_layout for d in vp8 vp9; do [ -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_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 x86 x86_64 ppc32 ppc64 " ARCH_EXT_LIST=" edsp media neon mips32 dspr2 mmx sse sse2 sse3 ssse3 sse4_1 avx avx2 altivec " HAVE_LIST=" ${ARCH_EXT_LIST} vpx_ports stdint_h alt_tree_layout pthread_h sys_mman_h unistd_h " EXPERIMENT_LIST=" multiple_arf 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 debug_libs fast_unaligned mem_manager mem_tracker mem_checks dequant_tokens dc_recon runtime_cpu_detect postproc vp9_postproc multithread internal_stats ${CODECS} ${CODEC_FAMILIES} encoders decoders static_msvcrt spatial_resampling realtime_only onthefly_bitpacking error_concealment shared static small postproc_visualizer os_support unit_tests webm_io decode_perf_tests multi_res_encoding temporal_denoising experimental decrypt ${EXPERIMENT_LIST} " CMDLINE_SELECT=" external_build 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 fast_unaligned codec_srcs debug_libs dequant_tokens dc_recon postproc vp9_postproc multithread internal_stats ${CODECS} ${CODEC_FAMILIES} static_msvcrt mem_tracker spatial_resampling realtime_only onthefly_bitpacking error_concealment shared static small postproc_visualizer unit_tests webm_io decode_perf_tests 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_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}_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_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_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_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) # For fat binaries, call configure recursively to configure for each # binary architecture to be included. if enabled universal; then # Call configure (ourselves) for each subarchitecture for arch in $fat_bin_archs; do BUILD_PFX=${arch}/ toolchain=${arch} $self --child $cmdline_args || exit $? done fi # The write_common_config (config.mk) logic is deferred until after the # recursive calls to configure complete, because we want our universal # targets to be executed last. write_common_config_targets enabled universal && echo "FAT_ARCHS=${fat_bin_archs}" >> config.mk # Calculate the default distribution name, based on the enabled features local cf local DIST_DIR=vpx for cf in $CODEC_FAMILIES; do if enabled ${cf}_encoder && enabled ${cf}_decoder; then DIST_DIR="${DIST_DIR}-${cf}" elif enabled ${cf}_encoder; then DIST_DIR="${DIST_DIR}-${cf}cx" elif enabled ${cf}_decoder; then DIST_DIR="${DIST_DIR}-${cf}dx" fi done enabled debug_libs && DIST_DIR="${DIST_DIR}-debug" enabled codec_srcs && DIST_DIR="${DIST_DIR}-src" ! enabled postproc && ! enabled vp9_postproc && DIST_DIR="${DIST_DIR}-nopost" ! enabled multithread && DIST_DIR="${DIST_DIR}-nomt" ! enabled install_docs && DIST_DIR="${DIST_DIR}-nodocs" DIST_DIR="${DIST_DIR}-${tgt_isa}-${tgt_os}" case "${tgt_os}" in win*) enabled static_msvcrt && DIST_DIR="${DIST_DIR}mt" || DIST_DIR="${DIST_DIR}md" DIST_DIR="${DIST_DIR}-${tgt_cc}" ;; esac if [ -f "${source_path}/build/make/version.sh" ]; then local ver=`"$source_path/build/make/version.sh" --bare $source_path` DIST_DIR="${DIST_DIR}-${ver}" VERSION_STRING=${ver} ver=${ver%%-*} VERSION_PATCH=${ver##*.} ver=${ver%.*} VERSION_MINOR=${ver##*.} ver=${ver#v} VERSION_MAJOR=${ver%.*} fi enabled child || cat <<EOF >> config.mk PREFIX=${prefix} ifeq (\$(MAKECMDGOALS),dist) DIST_DIR?=${DIST_DIR} else DIST_DIR?=\$(DESTDIR)${prefix} endif LIBSUBDIR=${libdir##${prefix}/} VERSION_STRING=${VERSION_STRING} VERSION_MAJOR=${VERSION_MAJOR} VERSION_MINOR=${VERSION_MINOR} VERSION_PATCH=${VERSION_PATCH} CONFIGURE_ARGS=${CONFIGURE_ARGS} EOF enabled child || echo "CONFIGURE_ARGS?=${CONFIGURE_ARGS}" >> config.mk # # Write makefiles for all enabled targets # for tgt in libs examples docs solution; do local tgt_fn="$tgt-$toolchain.mk" if enabled $tgt; then echo "Creating makefiles for ${toolchain} ${tgt}" write_common_target_config_mk $tgt_fn ${BUILD_PFX}vpx_config.h #write_${tgt}_config fi done } process_detect() { if enabled shared; then # Can only build shared libs on a subset of platforms. Doing this check # here rather than at option parse time because the target auto-detect # magic happens after the command line has been parsed. 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_feature external_build check_header() { log fake_check_header "$@" header=$1 shift var=`echo $header | sed 's/[^A-Za-z0-9_]/_/g'` 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_feature $var # Specialize windows and POSIX environments. case $toolchain in *-win*-*) case $header-$toolchain in stdint*-gcc) true;; *) false;; esac && enable_feature $var ;; *) case $header in stdint.h) true;; pthread.h) true;; sys/mman.h) true;; unistd.h) true;; *) false;; 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_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} # Snow Leopard (10.6/darwin10) dropped support for PPC # Include PPC support for all prior versions if [ $darwin_ver -lt 10 ]; then fat_bin_archs="$fat_bin_archs ppc32-${tgt_os}-gcc" fi # Tiger (10.4/darwin8) brought support for x86 if [ $darwin_ver -ge 8 ]; then fat_bin_archs="$fat_bin_archs x86-${tgt_os}-${tgt_cc}" fi # Leopard (10.5/darwin9) brought 64 bit support if [ $darwin_ver -ge 9 ]; then fat_bin_archs="$fat_bin_archs x86_64-${tgt_os}-${tgt_cc}" fi ;; esac # Enable some useful compiler flags if enabled gcc; then enabled werror && check_add_cflags -Werror check_add_cflags -Wall check_add_cflags -Wdeclaration-after-statement check_add_cflags -Wdisabled-optimization check_add_cflags -Wpointer-arith check_add_cflags -Wtype-limits check_add_cflags -Wcast-qual check_add_cflags -Wvla check_add_cflags -Wimplicit-function-declaration check_add_cflags -Wuninitialized check_add_cflags -Wunused-variable case ${CC} in *clang*) # libvpx and/or clang have issues with aliasing: # https://code.google.com/p/webm/issues/detail?id=603 # work around them until they are fixed check_add_cflags -fno-strict-aliasing ;; *) check_add_cflags -Wunused-but-set-variable ;; esac enabled extra_warnings || check_add_cflags -Wno-unused-function fi if enabled icc; then enabled werror && check_add_cflags -Werror check_add_cflags -Wall check_add_cflags -Wpointer-arith # ICC has a number of floating point optimizations that we disable # in favor of deterministic output WRT to other compilers add_cflags -fp-model precise fi # Enable extra, harmless warnings. These might provide additional insight # to what the compiler is doing and why, but in general, but they shouldn't # be treated as fatal, even if we're treating warnings as errors. GCC_EXTRA_WARNINGS=" -Wdisabled-optimization -Winline " enabled gcc && EXTRA_WARNINGS="${GCC_EXTRA_WARNINGS}" RVCT_EXTRA_WARNINGS=" --remarks " enabled rvct && EXTRA_WARNINGS="${RVCT_EXTRA_WARNINGS}" 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_feature dequant_tokens enable_feature dc_recon fi if enabled internal_stats; then enable_feature vp9_postproc fi # Enable the postbuild target if building for visual studio. case "$tgt_cc" in 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|12) VCPROJ_SFX=vcxproj gen_vcproj_cmd=${source_path}/build/make/gen_msvs_vcxproj.sh enabled werror && gen_vcproj_cmd="${gen_vcproj_cmd} --enable-werror" ;; esac all_targets="${all_targets} solution" INLINE="__forceinline" ;; esac # Other toolchain specific defaults case $toolchain in x86*|ppc*|universal*) soft_enable postproc;; esac if enabled postproc_visualizer; then enabled postproc || die "postproc_visualizer requires postproc to be enabled" fi # Enable WebM IO by default. soft_enable webm_io # Enable unit tests by default if we have a working C++ compiler. case "$toolchain" in *-vs*) soft_enable unit_tests ;; *-android-*) # GTestLog must be modified to use Android logging utilities. ;; *-darwin-*) # iOS/ARM builds do not work with gtest. This does not match # x86 targets. ;; *-win*) # Some mingw toolchains don't have pthread available by default. # Treat these more like visual studio where threading in gtest # would be disabled for the same reason. check_cxx "$@" <<EOF && soft_enable unit_tests int z; EOF ;; *) enabled pthread_h && check_cxx "$@" <<EOF && soft_enable unit_tests int z; EOF ;; esac } ## ## 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