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