BuildDependenciesScript.sh

#!/bin/bash

#Define used to force library rebuild. The default is to skip already built libraries
# However if using different architecture build options than last time then need to redo configure
FORCECONFIGURE=false
#Define how many threads to use when compiling files
COMPILETHREADS=10

#**************************TODO***********************
#Check performance of forcing compiler flags
# -march=core2 or -march=corei7   (core2=2007/2008, corei7=2009)
# -msse2 or -msse4.1 or -mavx (-msse2avx for vex) etc. (sse3=2004[Prescott P4], ssse3=2007[Core2,2011Bulldozer], sse4.1=2008[Core2Penryn,2011Bulldozer])
# -mfpmath=sse2 or -mfpmath=sse4.1 etc.
# At this point given that EVR and dxva is a requirement then sse3/core2 should be safe

#Change into the directory for this bash file
CURRDIR=$(pwd)
cd "$( dirname "${BASH_SOURCE[0]}" )" > /dev/null

#Function to return after completion of script
#  doExit Code
#    Code = Returned error code (0=success, 1=falure etc.)
doExit() {
    CODE=$1
    #Clean up any BS that we dont need
    cd "$( dirname "${BASH_SOURCE[0]}" )" > /dev/null
    doCleanBuilt
    cd $CURRDIR
    exit $CODE
}

#Function used to initialise build setting and configuration
#  doInit
doInit() {
    #Check the current architecture
    BUILDARCH=""
    if [[ $(env | grep PROCESSOR_ARCHITECTURE) =~ AMD64 || $(env | grep PROCESSOR_ARCHITEW6432) =~ AMD64 ]]; then
        BUILDARCH="x86_64"
    else
        BUILDARCH="x86"
    fi

    #Check the current build type.
    COMPILER=""
    OS=""
    COMPILER2=""
    ARCHSELECT=""
    if [[ "$OSTYPE" == *darwin* ]]; then
        OS="Mac"
        echo "Error: Mac currently not supported"
        doExit 1
    elif [[ "$OSTYPE" == *linux* ]]; then
        OS="Linux"
        COMPILER="gcc"
        COMPILER2="gcc"
        echo "Found Linux GNU build environment."
        local GCCARCH=$(gcc -dumpmachine)
        if [[ "$GCCARCH" == *x86_64* ]]; then
            ARCHSELECT="x86_64"
            echo "64 bit build environment detected"
        else
            ARCHSELECT="x86"
            echo "32 bit build environment detected"
        fi
        #Check if cross compile is supported
        if [ -e /usr/bin/x86_64-w64-mingw32-gcc ]; then
            #Prompt whether to use the cross compiler
            echo ""
            echo "Do you want to use the mingw cross compiler:"
            CROSSOPTS=("Dont use cross compiler" "Use cross compiler")
            select opt in "${CROSSOPTS[@]}"
            do
                case $opt in
                    "${CROSSOPTS[0]}" )
                        break
                        ;;
                    "${CROSSOPTS[1]}" )
                        COMPILER2="mingw"
                        break
                        ;;
                    *) echo invalid option;;
                esac
            done
        fi
    elif [[ "$OSTYPE" == *msys* ]]; then
        OS="Windows"
        COMPILER="mingw"
        #MSYS2 doesnt correctly set TEMP as it doesnt check case and so has both TEMP and temp
        unset temp
        unset tmp
        #Check if building with MSVC or a fixed mingw
        if [ -n "$VSINSTALLDIR" ]; then
            if [[ $INCLUDE == *Intel* ]]; then
                echo "Found Windows ICL build environment."
                COMPILER2="icl"
            else
                echo "Found Windows MSVC build environment."
                COMPILER2="msvc"
            fi
            #We can only compile the type based on the MSVC environment vars that have been set up
            if [[ "$LIB" == *amd64* ]]; then
                ARCHSELECT="x86_64"
                echo "64 bit build environment detected"
            else
                ARCHSELECT="x86"
                echo "32 bit build environment detected"
            fi
        else
            echo "Found Windows MinGW build environment."
            COMPILER2="mingw"
            if [ "$MSYSTEM" == "MINGW64" ] || [[ $PATH == *mingw64* ]]; then
                ARCHSELECT="x86_64"
                echo "64 bit build environment detected"
            elif [[ $PATH == *mingw32* ]]; then
                ARCHSELECT="x86"
                echo "32 bit build environment detected"
            elif [ "$BUILDARCH" == "x86_64" ]; then
                #Check if a 32b compiler is available
                if [ ! -e /mingw32/bin/gcc.exe ]; then
                    ARCHSELECT="x86_64"
                    echo "64 bit build environment detected"
                fi
            fi
        fi
    else
        echo "Error: Unknown operating system detected ($OSTYPE)"
        doExit 1
    fi

    #Prompt for user selection of build type
    if [ "$ARCHSELECT" == "" ]; then
        if [ "$BUILDARCH" == "x86_64" ]; then
            #Only prompt if can actually build anything other than x86 32b
            echo ""
            echo "Choose Build Type:"
            ARCHOPTS=("x86" "x64" "Both (x86, x86-64)")
            select opt in "${ARCHOPTS[@]}"
            do
                case $opt in
                    "${ARCHOPTS[0]}" )
                        ARCHSELECT="x86"
                        break
                        ;;
                    "${ARCHOPTS[1]}" )
                        ARCHSELECT="x86_64"
                        break
                        ;;
                    "${ARCHOPTS[2]}" )
                        ARCHSELECT="x86 x86_64"
                        break
                        ;;
                    *) echo invalid option;;
                esac
            done
        else
            ARCHSELECT="x86"
        fi
    fi

    #Prompt for user selection of build type
    CONFIGSELECT=""
    echo ""
    echo "Choose Configuration Type:"
    CONFIGOPTS=("Shared" "Static")
    select opt in "${CONFIGOPTS[@]}"
    do
        case $opt in
            "${CONFIGOPTS[0]}" )
                CONFIGSELECT="Shared"
                break
                ;;
            "${CONFIGOPTS[1]}" )
                CONFIGSELECT="Static"
                break
                ;;
            *) echo invalid option;;
        esac
    done

    #Prompt user for use of link time optimizations
    BUILDLTO=false
    if [ "$CONFIGSELECT" == "Static" ]; then
    echo ""
    echo "Choose to Enable Link Time Optimization:"
    LTOOPTS=("Disable Link Time Optimization" "Enable Link Time Optimization")
    select opt in "${LTOOPTS[@]}"
    do
        case $opt in
            "${LTOOPTS[0]}" )
                BUILDLTO=false
                break
                ;;
            "${LTOOPTS[1]}" )
                BUILDLTO=true
                break
                ;;
            *) echo invalid option;;
        esac
    done
    fi

    #Prompt user for use of additional dependency libraries
    EXTERNLIBS=false
    if [ "$COMPILER2" != "icl" ] && [ "$COMPILER2" != "msvc" ]; then
        echo ""
        echo "Choose Additional External Library Support:"
        EXTERNLIBSOPTS=("Enable External Libraries" "Disable External Libraries")
        select opt in "${EXTERNLIBSOPTS[@]}"
        do
            case $opt in
                "${EXTERNLIBSOPTS[0]}" )
                    echo " Building with external libraries"
                    EXTERNLIBS=true
                    break
                    ;;
                "${EXTERNLIBSOPTS[1]}" )
                    echo " Building without external libraries"
                    EXTERNLIBS=false
                    break
                    ;;
                *) echo invalid option;;
            esac
        done
    fi

    #Prompt user for use of non-free libraries
    NONFREE=false
    if $EXTERNLIBS; then
        echo ""
        echo "Choose Non-Free library support:"
        NONFREEOPTS=("Disable Non-Free libraries" "Enable Non-Free libraries")
        select opt in "${NONFREEOPTS[@]}"
        do
            case $opt in
                "${NONFREEOPTS[0]}" )
                    echo " Building without Non-Free libraries"
                    NONFREE=false
                    break
                    ;;
                "${NONFREEOPTS[1]}" )
                    echo " Building with Non-Free libraries"
                    NONFREE=true
                    break
                    ;;
                *) echo invalid option;;
            esac
        done
    fi

    #Prompt user for additional FATE test run after compilation
    FATETESTS=false
    echo ""
    echo "Perform additional FATE tests after compilation?:"
    FATEOPTS=("Enable FATE Test" "Disable FATE Tests")
    select opt in "${FATEOPTS[@]}"
    do
        case $opt in
            "${FATEOPTS[0]}" )
                echo " Running FATE tests after build"
                FATETESTS=true
                break
                ;;
            "${FATEOPTS[1]}" )
                echo " Not running FATE tests after build"
                FATETESTS=false
                break
                ;;
            *) echo invalid option;;
        esac
    done

    #Get config build/host variable
    BUILD32=""
    BUILD64=""
    BUILDPATH32=""
    BUILDPATH64=""
    HOST32=""
    HOST64=""
    if [ "$COMPILER" == "mingw" ]; then
        HOST32="i686-w64-mingw32"
        HOST64="x86_64-w64-mingw32"
        if [ "$BUILDARCH" == "x86" ]; then
            if [ -e /mingw32/bin/gcc.exe ]; then
                BUILDPATH32="/mingw32/bin"
                BUILD32="i686-w64-mingw32"
            else
                echo "Error: Could not find valid compiler (/mingw32)"
                doExit 1
            fi
        elif [ "$BUILDARCH" == "x86_64" ]; then
            if [ -e /mingw64/bin/gcc.exe ]; then
                BUILDPATH64="/mingw64/bin"
                BUILD64="x86_64-w64-mingw32"
                if [[ "$ARCHSELECT" != *x86_64* ]]; then
                    if [ -e /mingw32/bin/gcc.exe ]; then
                        BUILDPATH32="/mingw32/bin"
                        BUILD32="i686-w64-mingw32"
                    else
                        BUILDPATH32="/mingw64/bin"
                        BUILD32="x86_64-w64-mingw32"
                        echo "Warning: Cross Compilation detected. Using 64bit compiler to generate 32bit code"
                        echo "Error: Currently not properly supported"
                        doExit 1
                    fi
                fi
            elif [ -e /mingw32/bin/gcc.exe ]; then
                BUILDPATH64="/mingw32/bin"
                BUILD64="i686-w64-mingw32"
                BUILDPATH32="/mingw32/bin"
                BUILD32="i686-w64-mingw32"
                echo "Warning: Cross Compilation detected. Using 32bit compiler to generate 64bit code"
                echo "Error: Currently not properly supported"
                doExit 1
            else
                echo "Error: Could not find valid compiler (/mingw32, /mingw64)"
                doExit 1
            fi
        else
            echo "Error: Unknown Architecture ($BUILDARCH) being used"
            doExit 1
        fi
    elif [ "$COMPILER" == "gcc" ]; then
        BUILDPATH32="/bin"
        BUILDPATH64="/bin"
        if [ "$COMPILER2" == "mingw" ]; then
            HOST32="i686-w64-mingw32"
            HOST64="x86_64-w64-mingw32"
            BUILD32="x86_64-w64-mingw32"
            BUILD64="x86_64-w64-mingw32"
        else
            HOST32="x86-linux-gnu"
            HOST64="x86_64-linux-gnu"
            BUILD32="x86-linux-gnu"
            BUILD64="x86_64-linux-gnu"
        fi
    else
        echo "Error: Unknown Compiler ($COMPILER) being used"
        doExit 1
    fi

    echo ""
    #Create prefix for install locations
    PREFIX32="$PWD/$COMPILER2"32
    PREFIX64="$PWD/$COMPILER2"64
    PREFIX=$PREFIX32
    PREFIXBIN="$PREFIX/bin"
    PREFIXLIB="$PREFIX/lib"
    PREFIXINC="$PREFIX/include"
    PREFIXDATAROOT="$PREFIX/share"
    PREFIXLICENSE="$PREFIX/licenses"
    PREFIXSRC="$PWD/source"

    #Create environment variables
    PATHORIGINAL=$PATH
    CFLAGSORIGINAL=$CFLAGS
    CPPFLAGSORIGINAL=$CPPFLAGS
    CXXFLAGSORIGINAL=$CXXFLAGS
    LDFLAGSORIGINAL=$LDFLAGS
    if [ "$COMPILER2" == "icl" ] || [ "$COMPILER2" == "msvc" ]; then
        INCLUDEORIGINAL=$INCLUDE
        LIBORIGINAL=$LIB
        #Check if include and lib were passed correctly
        if [ "$INCLUDEORIGINAL" == "" ]; then
            echo "Warning: INCLUDE environment variable not found"
            INCLUDEORIGINAL=$TINCLUDE
        fi
        if [ "$LIBORIGINAL" == "" ]; then
            echo "Warning: LIB environment variable not found"
            LIBORIGINAL=$TLIB
        fi
        if [ "$INCLUDEORIGINAL" == "" ]; then
            echo "Error: No INCLUDE environment variable information found"
            doExit 1
        fi
        if [ "$LIBORIGINAL" == "" ]; then
            echo "Error: No LIB environment variable information found"
            doExit 1
        fi
    fi

    #Find OpenCL paths
    OPENCLDETECTED=false
    OPENCLINC=""
    OPENCLLIB32=""
    OPENCLLIB64=""
    if [ -n "$AMDAPPSDKROOT" ]; then
        echo "    Found AMD OpenCL SDK"
        OCLPATH="$(sh -c 'cd "$AMDAPPSDKROOT"; pwd')"
        #Need to update actual lib paths as these are just guesses
        #Add the found opencl paths
        OPENCLINC="$OCLPATH/include"
        OPENCLLIB32="$OCLPATH/lib/Win32"
        OPENCLLIB64="$OCLPATH/lib/x64"
        OPENCLDETECTED=true
    elif [ -n "$INTELOCLSDKROOT" ]; then
        echo "    Found Intel OpenCL SDK"
        OCLPATH="$(sh -c 'cd "$INTELOCLSDKROOT"; pwd')"
        #Add the found opencl paths
        OPENCLINC="$OCLPATH/include"
        OPENCLLIB32="$OCLPATH/lib/x86"
        OPENCLLIB64="$OCLPATH/lib/x64"
        OPENCLDETECTED=true
    elif [ -n "$CUDA_PATH" ]; then
        echo "    Found NVIDIA OpenCL SDK"
        OCLPATH="$(sh -c 'cd "$CUDA_PATH"; pwd')"
        #Add the found opencl paths
        OPENCLINC="$OCLPATH/include"
        OPENCLLIB32="$OCLPATH/lib/Win32"
        OPENCLLIB64="$OCLPATH/lib/x64"
        OPENCLDETECTED=true
    else
        echo "    WARNING: Couldn't locate OpenCL install"
    fi

    #Find MFX path
    #LIBMFXDETECTED=false
    #LIBMFXINC=""
    #LIBMFXLIB32=""
    #LIBMFXLIB64=""
    #if [ -n "$INTELMEDIASDKROOT" ]; then
    #    echo "    Found Intel Media SDK"
    #    LIBMFXPATH="$(sh -c 'cd "$INTELMEDIASDKROOT"; pwd')"
    #    #Add the found paths
    #    LIBMFXINC="$MFXPATH/include"
    #    LIBMFXLIB32="$MFXPATH/lib/win32"
    #    LIBMFXLIB64="$MFXPATH/lib/x64"
    #    LIBMFXDETECTED=true
    #else
    #    echo "    WARNING: Couldn't locate Intel Media SDK install"
    #fi

    #Find NVENC path
    #NVENCDETECTED=false
    #NVENCINC=""
    #if [ -n "$CUDA_PATH" ]; then
    #    CUDAPATH="$(sh -c 'cd "$CUDA_PATH"; pwd')"
    #    if [ -e "$CUDAPATH/include/nvEncodeAPI.h" ]; then
    #        echo "    Found NVIDIA Encode API"
    #    #Add the found paths
    #    NVENCINC="$CUDAPATH/include"
    #    NVENCDETECTED=true
    #    fi
    #else
    #    echo "    WARNING: Couldn't locate NVENC install"
    #fi
}

#Function to set environment for compilation of 32/64 bit code
#  doSetEnvironment ARCH
#    ARCH = Architecture to set environment to [x86, x86_64]
doSetEnvironment() {
    ARCH="$1"

    #Set variables based on arch
    if [ "$ARCH" == "x86" ]; then
        HOST=$HOST32
        BUILD=$BUILD32
        local BUILDPATH=$BUILDPATH32
        local OPENCLLIB=$OPENCLLIB32
        local LIBMFXLIB=$LIBMFXLIB32
        PREFIX=$PREFIX32
    elif [ "$ARCH" == "x86_64" ]; then
        HOST=$HOST64
        BUILD=$BUILD64
        local BUILDPATH=$BUILDPATH64
        local OPENCLLIB=$OPENCLLIB64
        local LIBMFXLIB=$LIBMFXLIB64
        PREFIX=$PREFIX64
    else
        echo "    Error: Unknown Architecture ($ARCH) being used"
        doExit 1
    fi
    PREFIXBIN="$PREFIX/bin"
    PREFIXLIB="$PREFIX/lib"
    PREFIXINC="$PREFIX/include"
    PREFIXDATAROOT="$PREFIX/share"
    PREFIXLICENSE="$PREFIX/licenses"
    mkdir -p $PREFIXBIN
    mkdir -p $PREFIXLIB
    mkdir -p $PREFIXINC
    mkdir -p $PREFIXLICENSE
    export PKG_CONFIG_PATH="$PREFIXLIB/pkgconfig"

    if [ "$COMPILER2" == "icl" ] || [ "$COMPILER2" == "msvc" ]; then
        #Export MSVC environment variables
        local TEMPINCLUDE=${PREFIXINC//'/d/'/'D:/'}
        local TEMPINCLUDE=${TEMPINCLUDE//'/c/'/'C:/'}
        local TEMPLIB=${PREFIXLIB//'/d/'/'D:/'}
        local TEMPLIB=${TEMPLIB//'/c/'/'C:/'}
        export INCLUDE="$TEMPINCLUDE;$INCLUDEORIGINAL"
        export LIB="$TEMPLIB;$LIBORIGINAL"
        if $OPENCLDETECTED; then
            local TEMPINCLUDE=${OPENCLINC//'/d/'/'D:/'}
            local TEMPINCLUDE=${TEMPINCLUDE//'/c/'/'C:/'}
            local TEMPLIB=${OPENCLLIB//'/d/'/'D:/'}
            local TEMPLIB=${TEMPLIB//'/c/'/'C:/'}
            export INCLUDE="$TEMPINCLUDE;$INCLUDE"
            export LIB="$TEMPLIB;$LIB"
        fi
        #if $LIBMFXDETECTED; then
        #    local TEMPINCLUDE=${LIBMFXINC//'/d/'/'D:/'}
        #    local TEMPINCLUDE=${TEMPINCLUDE//'/c/'/'C:/'}
        #    local TEMPLIB=${LIBMFXLIB//'/d/'/'D:/'}
        #    local TEMPLIB=${TEMPLIB//'/c/'/'C:/'}
        #    export INCLUDE="$TEMPINCLUDE;$INCLUDE"
        #    export LIB="$TEMPLIB;$LIB"
        #fi
    fi

    local CFLAGSADD=""
    local LDFLAGSADD=""
    if $OPENCLDETECTED; then
        local CFLAGSADD="-I$OPENCLINC $CFLAGSADD"
        local LDFLAGSADD="-L$OPENCLLIB $LDFLAGSADD"
    fi
    #if $LIBMFXDETECTED; then
    #    local CFLAGSADD="-I$LIBMFXINC $CFLAGSADD"
    #    local LDFLAGSADD="-L$LIBMFXLIB $LDFLAGSADD"
    #fi
    export CFLAGS="-I$PREFIXINC $CFLAGSORIGINAL $CFLAGSADD"
    export CPPFLAGS="-I$PREFIXINC $CPPFLAGSORIGINAL $CFLAGSADD"
    export CXXFLAGS="-I$PREFIXINC $CXXFLAGSORIGINAL $CFLAGSADD"
    export LDFLAGS="-L$PREFIXLIB $LDFLAGSORIGINAL $LDFLAGSADD"
    export PATH="$PREFIX:$PREFIXSRC:$PREFIXINC:$PREFIXLIB:$PREFIXBIN:$BUILDPATH:$PATHORIGINAL"

    # Force lto usage in dependency libs if enabled
    #if $BUILDLTO; then
    #    export CFLAGS="$CFLAGS -flto -fuse-linker-plugin"
    #    export CPPFLAGS="$CPPFLAGS -flto -fuse-linker-plugin"
    #    export CXXFLAGS="$CXXFLAGS -flto -fuse-linker-plugin"
    #    export LDFLAGS="$LDFLAGS -flto -fuse-linker-plugin"
    #    #Until default binutils has slim-lto support must use versions that support plugins
    #    export AS=gcc-as
    #    export AR=gcc-ar
    #    export NM=gcc-nm
    #    export RANLIB=gcc-ranlib
    #fi

    echo "    Environment set to '$ARCH'"
}

#Function to check if library(s) are already generated and valid
#  doCheckLibraryNotValid Libs NameString [Dependencies] [Shared]
#    Libs = String of space separated library names
#    NameString = Print friendly string (used for error reporting)
#    CodeFolder = Folder where library code is found
#    Dependencies = String of space separated library names of any libraries that this one(s) depends on
#    Shared = String specifying if this should check for Shared or Static libraries (default=Static)
#    return = If library does not exists or is not valid (1=not exist/valid, 0=exist)
doCheckLibraryNotValid() {
    local LIBS="$1"
    local NAMESTRING="$2"
    local CODEFOLDER="$3"
    local DEPLIBS="$4"
    #Loop through and check existence of each library
    local MISSINGLIB=false
    for LIBNAME in $LIBS
    do
        #Check if the library is already installed
        if [ "$CONFIGSELECT" == "Shared" ]; then
            #Determine shared library extension
            if [ "$COMPILER" == "mingw" ] || [ "$COMPILER2" == "mingw" ]; then
                local EXT="dll.a"
            else
                local EXT="so"
            fi
            if [ ! -e "$PREFIXBIN/$LIBNAME.$EXT" ] && [ ! -e "$PREFIXLIB/$LIBNAME.$EXT" ]; then
                local MISSINGLIB=true
            else
                if [ -e "$PREFIXBIN/$LIBNAME.$EXT" ]; then
                    local FOUNDNAME="$PREFIXBIN/$LIBNAME.$EXT"
                else
                    local FOUNDNAME="$PREFIXLIB/$LIBNAME.$EXT"
                fi
            fi
        else
        local EXT="a"
            if [ ! -e "$PREFIXLIB/$LIBNAME.$EXT" ]; then
                local MISSINGLIB=true
            else
                local FOUNDNAME="$PREFIXLIB/$LIBNAME.$EXT"
            fi
        fi
    done
    if $MISSINGLIB; then
        #Check that the required dependencies exist
        for DEPLIBNAME in $DEPLIBS
        do
            #Check that the dependency library was installed correctly
            if [ ! -e "$PREFIXLIB/$DEPLIBNAME.$EXT" ] && [ ! -e "$PREFIXBIN/$DEPLIBNAME.$EXT" ]; then
                echo "    Error: Could not find dependency ($DEPLIBNAME) for library $LIBNAME. Terminating"
                doExit 1
            fi
        done
        return 1
    else
        #Check whether rebuild is required
        for DEPLIBNAME in $DEPLIBS
        do
            #Check that this file is newer than all its dependencies
            if [ -e "$PREFIXBIN/$DEPLIBNAME.$EXT" ]; then
                local FOUNDDEPNAME="$PREFIXBIN/$DEPLIBNAME.$EXT"
            else
                local FOUNDDEPNAME="$PREFIXLIB/$DEPLIBNAME.$EXT"
            fi
            if [ "$FOUNDNAME" -ot "$FOUNDDEPNAME" ]; then
                echo "    Dependency ($DEPLIBNAME) of $NAMESTRING is newer than current built library. Needs recompiling"
                return 1
            fi
        done
        # Get last 3 commits and check if newer than lib
        local CURRDIR="$PWD"
        cd $PREFIXSRC/$CODEFOLDER
        for FILENAME in $(git log -10 --name-only --format="")
        do
            if [ "$FOUNDNAME" -ot "$FILENAME" ] && [[ "$FILENAME" != "SMP/"* ]]; then
                cd "$CURRDIR"
                echo "    Modified files ($FILENAME) of $NAMESTRING are newer than current built library. Needs recompiling"
                return 1
            fi
        done
        cd "$CURRDIR"
    fi
    return 0
}

#Function to generate a configure script using autoconf
#  doAutoConfigure ConfigFolder NameString
#    ConfigFolder = Folder where configure script is found
#    NameString = Print friendly string (used for error reporting)
doAutoConfigure() {
    local CONFFOLDER="$1"
    local SOURCENAME="$2"
    local CURRDIR="$PWD"
    cd $PREFIXSRC/$CONFFOLDER
    echo "    Generating Configure for $SOURCENAME..."
    local AUTOCONFIGLOG=$PREFIXSRC/$SOURCENAME-$ARCH-$COMPILER2-autoconfig.log
    #Check if we need to generate the configure script
    if [ -e ".bootstrap" ]; then
        local AUTOCONFIGCOMMANDLINE="./.bootstrap"
        if !( eval $AUTOCONFIGCOMMANDLINE &> $AUTOCONFIGLOG ); then
            echo "    Error: $SOURCENAME .bootstrapping failed"
            doExit 1
        fi
    elif [ -e "bootstrap" ]; then
        local AUTOCONFIGCOMMANDLINE="./bootstrap"
        if !( eval $AUTOCONFIGCOMMANDLINE &> $AUTOCONFIGLOG ); then
            echo "    Error: $SOURCENAME bootstrapping failed"
            doExit 1
        fi
    elif [ -e "bootstrap.sh" ]; then
        local AUTOCONFIGCOMMANDLINE="./bootstrap.sh"
        if !( eval $AUTOCONFIGCOMMANDLINE &> $AUTOCONFIGLOG ); then
            echo "    Error: $SOURCENAME bootstrap.sh failed"
            doExit 1
        fi
    else
        local AUTOCONFIGCOMMANDLINE="autoreconf -fiv"
        if !( eval $AUTOCONFIGCOMMANDLINE &> $AUTOCONFIGLOG ); then
            echo "    Error: $SOURCENAME auto-configuration failed"
            doExit 1
        fi
    fi
    cd "$CURRDIR"
}

#Function to configure a library
#  doConfigure ConfigFolder NameString [ConfigureOptions]
#    ConfigFolder = Folder where configure script is found
#    NameString = Print friendly string (used for error reporting)
#    ConfigureOptions = Options to pass to configure (Optional)
#    ConfigureOverrides = Environment overrides to set when calling configure
doConfigure() {
    local CONFFOLDER="$1"
    local SOURCENAME="$2"
    local CONFOPTIONS="$3"
    local CONFIGOVERRIDES="$4"
    local CURRDIR="$PWD"
    cd $PREFIXSRC/$CONFFOLDER
    echo "    Configuring $SOURCENAME..."
    local CONFIGLOG=$PREFIXSRC/$SOURCENAME-$ARCH-$COMPILER2-config.log
    #Run Configuration
    if [ -e "./Configure" ]; then
        local CONFIGCOMMANDLINE="$CONFIGOVERRIDES ./Configure $CONFOPTIONS"
    else
        local CONFIGCOMMANDLINE="$CONFIGOVERRIDES ./configure $CONFOPTIONS"
    fi
    if !( echo "$CONFIGCOMMANDLINE" &> $CONFIGLOG && \
        eval $CONFIGCOMMANDLINE &>> $CONFIGLOG ); then
        echo "    Error: $SOURCENAME configuration failed"
        cd "$CURRDIR"
        #Do a dist clean
        doClean $CONFFOLDER $SOURCENAME
        doExit 1
    fi
    cd "$CURRDIR"
}

#Function to generate and configure a library using an autogen script
#  doAutoGen ConfigFolder NameString [ConfigureOptions]
#    ConfigFolder = Folder where configure script is found
#    NameString = Print friendly string (used for error reporting)
#    ConfigureOptions = Options to pass to configure (Optional)
doAutoGen() {
    local CONFFOLDER="$1"
    local SOURCENAME="$2"
    local CONFOPTIONS="$3"
    local CURRDIR="$PWD"
    cd $PREFIXSRC/$CONFFOLDER
    echo "    Auto Generating $SOURCENAME..."
    local CONFIGLOG=$PREFIXSRC/$SOURCENAME-$ARCH-$COMPILER2-autoconfig.log
    #Run Configuration
    local CONFIGCOMMANDLINE="./autogen.sh $CONFOPTIONS"
    if !( eval $CONFIGCOMMANDLINE &> $CONFIGLOG ); then
        echo "    Error: $SOURCENAME generation and configuration failed"
        doExit 1
    fi
    cd "$CURRDIR"
}

#Function to use CMake to generate library build files
#  doCMake CMakeFolder NameString [CMakeOptions]
#    CMakeFolder = Folder where CMake script is found
#    NameString = Print friendly string (used for error reporting)
#    CMakeOptions = Options to pass to configure (Optional)
doCMake() {
    local CMAKEFOLDER="$1"
    local SOURCENAME="$2"
    local CMAKEOPTIONS="$3"
    local CURRDIR="$PWD"
    doCleanCMake $CMAKEFOLDER $SOURCENAME
    cd $PREFIXSRC/$CMAKEFOLDER
    echo "    CMake configuring $SOURCENAME..."
    #Create out of tree build to prevent source contamination
    CMAKETEMPFOLDER=CMakeBuildTempFolder
    mkdir $CMAKETEMPFOLDER
    cd $CMAKETEMPFOLDER
    #Run Configuration
    local CMAKELOG=$PREFIXSRC/$SOURCENAME-$ARCH-$COMPILER2-cmake.log
    local CMAKECOMMANDLINE="cmake ../ -DCMAKE_BUILD_TYPE:STRING=Release -DCMAKE_INSTALL_PREFIX=$PREFIX -DCMAKE_INCLUDE_PATH=$PREFIXINC -DCMAKE_LIBRARY_PATH=$PREFIXLIB -DCMAKE_LIBRARY_OUTPUT_DIRECTORY=$PREFIXLIB $CMAKEOPTIONS"
    if !( echo "$CMAKECOMMANDLINE" &> $CMAKELOG && \
        eval $CMAKECOMMANDLINE &>> $CMAKELOG ); then
        echo "    Error: $SOURCENAME Cmake configuration failed"
        cd "$CURRDIR"
        doCleanCMake $CMAKEFOLDER $SOURCENAME
        doExit 1
    fi
    #must fix absolute directory name passing in response files
    if [ "$OS" == "Windows" ]; then
        find . -type f -name "*.rsp" -exec sed -i 's@/c/@c:/@g' {} +
        find . -type f -name "*.rsp" -exec sed -i 's@/d/@d:/@g' {} +
        find . -type f -name "*.rsp" -exec sed -i 's@/e/@e:/@g' {} +
        find . -type f -name "*.rsp" -exec sed -i 's@/f/@f:/@g' {} +
    fi
    cd "$CURRDIR"
}

#Function to make a library
#  doMake MakeFolder NameString [MakeOptions]
#    MakeFolder = Folder where make script is found
#    NameString = Print friendly string (used for error reporting)
#    MakeOptions = Options to pass to make (Optional)
doMake() {
    local MAKEFOLDER="$1"
    local SOURCENAME="$2"
    local MAKEOPTIONS="$3"
    local CURRDIR="$PWD"
    cd $PREFIXSRC/$MAKEFOLDER
    echo "    Running make $MAKEOPTIONS on $SOURCENAME..."
    #Run Make
    local MAKECOMMANDLINE="make -j$COMPILETHREADS V=1 VERBOSE=1 $MAKEOPTIONS"
    local MAKELOG=$PREFIXSRC/$SOURCENAME-$ARCH-$COMPILER2-make.log
    if !( echo "$MAKECOMMANDLINE" &> $MAKELOG && \
        eval $MAKECOMMANDLINE &>> $MAKELOG ); then
        echo "    Error: $SOURCENAME make failed"
        cd "$CURRDIR"
        doClean $MAKEFOLDER $SOURCENAME
        doExit 1
    fi
    cd "$CURRDIR"
}

#Function to make and install a library
#  doMakeInstall MakeFolder NameString [MakeOptions]
#    MakeFolder = Folder where make script is found
#    NameString = Print friendly string (used for error reporting)
#    MakeOptions = Options to pass to make (Optional)
doMakeInstall() {
    local MAKEFOLDER="$1"
    local SOURCENAME="$2"
    local MAKEOPTIONS="$3"
    local CURRDIR="$PWD"
    cd $PREFIXSRC/$MAKEFOLDER
    echo "    Compiling $SOURCENAME..."
    #Run Make
    local MAKECOMMANDLINE="make -j$COMPILETHREADS V=1 VERBOSE=1 $MAKEOPTIONS"
    local INSTALLCOMMANDLINE="make $MAKEOPTIONS install"
    local MAKELOG=$PREFIXSRC/$SOURCENAME-$ARCH-$COMPILER2-makeinstall.log
    if !( echo "$MAKECOMMANDLINE" &> $MAKELOG && \
        eval $MAKECOMMANDLINE &>> $MAKELOG && \
        eval $INSTALLCOMMANDLINE &>> $MAKELOG ); then
        echo "    Error: $SOURCENAME compilation failed"
        cd "$CURRDIR"
        doClean $MAKEFOLDER $SOURCENAME
        doExit 1
    fi
    cd "$CURRDIR"
}

#Function to check an installed library was properly configured
#  doCheckInstall Libs [Shared]
#    Libs = String of space separated library names
#    Shared = String specifying if this should check for Shared or Static libraries (default=Static)
doCheckInstall() {
    #Loop through and check existence of each library
    for LIBNAME in $1
    do
        #Check that the library was installed correctly
        if [ "$4" == "Shared" ]; then
            #Determine shared library extension
            if [ "$COMPILER" == "mingw" ] || [ "$COMPILER2" == "mingw" ]; then
                local EXT=".dll.a"
            else
                local EXT="so"
            fi
            if [ ! -e "$PREFIXBIN/$LIBNAME.$EXT" ] && [ ! -e "$PREFIXLIB/$LIBNAME.$EXT" ]; then
                return 1
            fi
        elif [ "$4" == "Static" ] || [ "$4" == "" ]; then
            if [ ! -e "$PREFIXLIB/$LIBNAME.a" ]; then
                return 1
            fi
        fi
        #Check if this library created an '*.la' and if so we need to check for any errors due to outputLibs
        if [ -e $PREFIXLIB/$LIBNAME.la ]; then
            if !( sed -i -e 's@$PREFIX/$BUILD/lib/@$PREFIXLIB@g' $PREFIXLIB/$LIBNAME.la ) ||
                !( sed -i -e 's@$PREFIX/$HOST/lib/@$PREFIXLIB@g' $PREFIXLIB/$LIBNAME.la ); then
                echo "    Error: Could not correct library .la file for $LIBNAME"
                doExit 1
            fi
        fi
    done
}

#Function to fully clean any remaining file from a git folder
#  doGitClean MakeFolder NameString
#    MakeFolder = Folder where make script is found
#    NameString = Print friendly string (used for error reporting)
doGitClean() {
    local MAKEFOLDER="$1"
    local SOURCENAME="$2"
    local CURRDIR="$PWD"
    cd $PREFIXSRC/$MAKEFOLDER
    local GITCLEANCOMMANDLINE="git stash && git clean -xdf"
    eval $GITCLEANCOMMANDLINE &> /dev/null
    cd "$CURRDIR"
}

#Function to clean up after a make
#  doClean MakeFolder NameString
#    MakeFolder = Folder where make script is found
#    NameString = Print friendly string (used for error reporting)
doClean() {
    local MAKEFOLDER="$1"
    local SOURCENAME="$2"
    local CURRDIR="$PWD"
    cd $PREFIXSRC/$MAKEFOLDER
    echo "    Cleaning $SOURCENAME..."
    local CLEANCOMMANDLINE="make clean"
    eval $CLEANCOMMANDLINE &> /dev/null
    cd "$CURRDIR"
    doGitClean $MAKEFOLDER $SOURCENAME
}

#Function to fully clean up after a make
#  doFullClean MakeFolder NameString
#    MakeFolder = Folder where make script is found
#    NameString = Print friendly string (used for error reporting)
doFullClean() {
    local MAKEFOLDER="$1"
    local SOURCENAME="$2"
    local CURRDIR="$PWD"
    cd $PREFIXSRC/$MAKEFOLDER
    echo "    Cleaning $SOURCENAME..."
    local CLEANCOMMANDLINE="make clean"
    local DISTCLEANCOMMANDLINE="make distclean"
    local MAKELOG=$PREFIXSRC/$SOURCENAME-$ARCH-$COMPILER2-makeinstall.log
    eval $CLEANCOMMANDLINE &>> $MAKELOG
    eval $DISTCLEANCOMMANDLINE &>> $MAKELOG
    cd "$CURRDIR"
    doGitClean $MAKEFOLDER $SOURCENAME
}

#Function to clean up after a cmake
#  doCleanCMake MakeFolder NameString
#    MakeFolder = Folder where make script is found
#    NameString = Print friendly string (used for error reporting)
doCleanCMake() {
    local MAKEFOLDER="$1"
    local SOURCENAME="$2"
    local CURRDIR="$PWD"
    cd $PREFIXSRC/$MAKEFOLDER
    echo "    Cleaning CMake $SOURCENAME..."
    rm -rf $CMAKETEMPFOLDER
    cd $PREFIX
    rm -rf "CMake"
    cd $PREFIXLIB
    rm -rf "cmake"
    cd "$CURRDIR"
    doGitClean $MAKEFOLDER $SOURCENAME
}

#Function to create license file in install directory
#  doLicense MakeFolder NameString
#    MakeFolder = Folder where library is found
#    NameString = Print friendly string (used for error reporting and license name)
#    LicenseFile = The name of the file with license information
doLicense() {
    local MAKEFOLDER="$1"
    local SOURCENAME="$2"
    local LICENSEFILE="$3"
    echo "    Copying $SOURCENAME license..."
    local LICENSECOMMANDLINE="cp $PREFIXSRC/$MAKEFOLDER/$LICENSEFILE $PREFIXLICENSE/$SOURCENAME.txt"
    if !( eval $LICENSECOMMANDLINE &> /dev/null ); then
        echo "    Error: $SOURCENAME license copy failed"
        doExit 1
    fi

}

#Function to clean any previously installed components
#  doCleanInstall NameString IncludeDirs IncludeFiles [OtherDirs]
#    NameString = Print friendly string (used for error reporting)
#    LibFiles = String of space separated exported lib files.
#    IncludeDirs = String of space separated exported include folders.
#    IncludeFiles = String of space separated exported include files.
#    OtherDirs = String of space separated exported misc folders.
doCleanInstall() {
    local BCLEANED=0
    #Loop through and check existence of each lib file
    local LIBCOUNT=0
    local PKGCOUNT=0
    for ILIB in $2
    do
        #Check if the file exists
        if [ -e "$PREFIXLIB/$ILIB.dll.a" ]; then
            rm -f "$PREFIXLIB/$ILIB.dll.a"
            BCLEANED=1
            LIBCOUNT=`expr $LIBCOUNT + 1`
        elif [ -e "$PREFIXLIB/$ILIB.so" ]; then
            rm -f "$PREFIXLIB/$ILIB.so"
            rm -f "$PREFIXLIB"/*$ILIB.so*
            BCLEANED=1
            LIBCOUNT=`expr $LIBCOUNT + 1`
        fi
        if [ -e "$PREFIXLIB/$ILIB.a" ]; then
            rm -f "$PREFIXLIB/$ILIB.a"
            BCLEANED=1
            LIBCOUNT=`expr $LIBCOUNT + 1`
        fi
        # Check for pkgconfig
        if [ -e "$PKG_CONFIG_PATH/$ILIB.pc" ]; then
            rm -f "$PKG_CONFIG_PATH/$ILIB.pc"
            PKGCOUNT=`expr $PKGCOUNT + 1`
        fi
    done
    #Loop through and check existence of each include folder
    local DIRCOUNT=0
    for IDIR in $3
    do
        #Check if the folder exists
        if [ -d "$PREFIXINC/$IDIR" ]; then
            rm -rf "$PREFIXINC/$IDIR"
            BCLEANED=1
            DIRCOUNT=`expr $DIRCOUNT + 1`
        fi
    done
    #Loop through and check existence of each include file
    local FILECOUNT=0
    for IFILE in $4
    do
        #Check if the folder exists
        if [ -e "$PREFIXINC/$IFILE" ]; then
            rm "$PREFIXINC/$IFILE"
            BCLEANED=1
            FILECOUNT=`expr $FILECOUNT + 1`
        fi
    done
    #Loop through and check existence of each misc folder
    local MDIRCOUNT=0
    for MDIR in $5
    do
        #Check if the folder exists
        if [ -d "$PREFIX/$MDIR" ]; then
            rm -rf "$PREFIX/$MDIR"
            BCLEANED=1
            MDIRCOUNT=`expr $MDIRCOUNT + 1`
        fi
    done
    if (($BCLEANED)); then
        echo "    Existing installed files found for $1."
        echo "     Cleaned: $LIBCOUNT lib files, $PKGCOUNT pkgconfig files, $DIRCOUNT include directories, $FILECOUNT include files, $MDIRCOUNT misc directories."
    fi
}

#Function to clean any bogus built files or directories
#  doCleanBuilt
doCleanBuilt(){
    if [ -e "$PREFIX32/bin/" ]; then
        find "$PREFIX32/bin/" -type f -regextype posix-extended ! -iregex '.*\.(dll|so)$' -delete
    fi
    if [ -e "$PREFIX64/bin/" ]; then
        find "$PREFIX64/bin/" -type f -regextype posix-extended ! -iregex '.*\.(dll|so)$' -delete
    fi
    rm -rf "$PREFIXDATAROOT"
    rm -rf "$PREFIX/man"
}

#Functions to build each library
dobzip2() {
    echo ""
    echo "  bzip2..."
    local BZLIBFOLDER=bzip2
    local BZLIBLIBS="libbz2"
    doCheckLibraryNotValid "$BZLIBLIBS" "bzip2" "$BZLIBFOLDER" #Check if library is already built
    if (( $? )) || $FORCECONFIGURE; then
        doCleanInstall "bzip2" "$BZLIBLIBS" "" "bzlib.h"
        doGitClean "$BZLIBFOLDER" "bzip2"
        if [ "$CONFIGSELECT" == "Shared" ]; then
            local LOCALBUILDOPTS="-f Makefile-libbz2_so"
        else
            local LOCALBUILDOPTS=""
        fi
        doMakeInstall "$BZLIBFOLDER" "bzip2" "$LOCALBUILDOPTS PREFIX=$PREFIX"
        if [ "$CONFIGSELECT" == "Shared" ] && [ "$COMPILER" == "gcc" ] ; then
            mv "$PREFIXBIN/libbz2.so" "$PREFIXLIB/libbz2.so"
        fi
        doFullClean "$BZLIBFOLDER" "bzip2"
        doCheckInstall "$BZLIBLIBS"
        doLicense "$BZLIBFOLDER" "bzip2" "LICENSE"
    else
        echo "    Build bzip2 skipped (Already built)."
    fi
}

doenca() {
    echo ""
    echo "  enca..."
    local ENCAFOLDER=enca
    local ENCALIBS="libenca"
    doCheckLibraryNotValid "$ENCALIBS" "enca" "$ENCAFOLDER" #Check if library is already built
    if (( $? )) || $FORCECONFIGURE; then
        doCleanInstall "enca" "$ENCALIBS" "" "enca.h"
        doGitClean "$ENCAFOLDER" "enca"
        if [ "$CONFIGSELECT" == "Shared" ]; then
            local LOCALBUILDOPTS="--enable-shared --disable-static"
        else
            local LOCALBUILDOPTS="--disable-shared --enable-static"
        fi
        doConfigure "$ENCAFOLDER" "enca" "$LOCALBUILDOPTS --build=$BUILD --host=$HOST --with-libiconv-prefix=$PREFIX --bindir=$PREFIXBIN --libdir=$PREFIXLIB --includedir=$PREFIXINC --datarootdir=$PREFIXDATAROOT"
        doMakeInstall "$ENCAFOLDER" "enca" ""
        doFullClean "$ENCAFOLDER" "enca"
        doCheckInstall "$ENCALIBS"
        doLicense "$ENCAFOLDER" "enca" "COPYING"
    else
        echo "    Build enca skipped (Already built)."
    fi
}

doexpat() {
    echo ""
    echo "  expat..."
    local EXPATFOLDER=expat
    local EXPATLIBS="libexpat"
    doCheckLibraryNotValid "$EXPATLIBS" "expat" "$EXPATFOLDER" #Check if library is already built
    if (( $? )) || $FORCECONFIGURE; then
        doCleanInstall "expat" "$EXPATLIBS" "" "expat.h expat_external.h"
        doGitClean "$EXPATFOLDER" "expat"
        if [ "$CONFIGSELECT" == "Shared" ]; then
            local LOCALBUILDOPTS="--enable-shared --disable-static"
        else
            local LOCALBUILDOPTS="--disable-shared --enable-static"
        fi
        doConfigure "$EXPATFOLDER" "expat" "$LOCALBUILDOPTS --build=$BUILD --host=$HOST --bindir=$PREFIXBIN --libdir=$PREFIXLIB --includedir=$PREFIXINC --datarootdir=$PREFIXDATAROOT"
        doMakeInstall "$EXPATFOLDER" "expat" ""
        doFullClean "$EXPATFOLDER" "expat"
        doCheckInstall "$EXPATLIBS"
        doLicense "$EXPATFOLDER" "expat" "COPYING"
    else
        echo "    Build expat skipped (Already built)."
    fi
}

dofdkaac() {
    if $NONFREE; then
        echo ""
        echo "  fdk-aac..."
        local FDKFOLDER=fdk-aac
        local FDKLIBS="libfdk-aac"
        doCheckLibraryNotValid "$FDKLIBS" "fdk-aac" "$FDKFOLDER" #Check if library is already built
        if (( $? )) || (( $FDKISNEWSOURCE )) || $FORCECONFIGURE; then
            doCleanInstall "fdk-aac" "$FDKLIBS" "fdk-aac" ""
            doGitClean "$FDKFOLDER" "fdk-aac"
            doAutoConfigure "$FDKFOLDER" "fdk-aac"
            if [ "$CONFIGSELECT" == "Shared" ]; then
                local LOCALBUILDOPTS="--enable-shared --disable-static"
            else
                local LOCALBUILDOPTS="--disable-shared --enable-static"
            fi
            doConfigure "$FDKFOLDER" "fdk-aac" "$LOCALBUILDOPTS --build=$BUILD --host=$HOST --bindir=$PREFIXBIN --libdir=$PREFIXLIB --includedir=$PREFIXINC --datarootdir=$PREFIXDATAROOT"
            doMakeInstall "$FDKFOLDER" "fdk-aac" ""
            doFullClean "$FDKFOLDER" "fdk-aac"
            doCheckInstall "$FDKLIBS"
            doLicense "$FDKFOLDER" "fdk-aac" "NOTICE"
        else
            echo "    Build fdk-aac skipped (Already built)."
        fi
    fi
}

dofontconfig() {
    echo ""
    echo "  fontconfig..."
    local FONTCONFIGFOLDER=fontconfig
    local FONTCONFIGLIBS="libfontconfig"
    local FONTCONFIGDEPLIBS="libiconv libfreetype libxml2"
    doCheckLibraryNotValid "$FONTCONFIGLIBS" "fontconfig" "$FONTCONFIGFOLDER" "$FONTCONFIGDEPLIBS" #Check if library is already built
    if (( $? )) || $FORCECONFIGURE; then
        doCleanInstall "fontconfig" "$FONTCONFIGLIBS" "fontconfig" "" "fonts"
        doGitClean "$FONTCONFIGFOLDER" "fontconfig"
        if [ "$CONFIGSELECT" == "Shared" ]; then
            local LOCALBUILDOPTS="--enable-shared --disable-static"
        else
            local LOCALBUILDOPTS="--disable-shared --enable-static"
        fi
        doAutoGen "$FONTCONFIGFOLDER" "fontconfig" "$LOCALBUILDOPTS --build=$BUILD --host=$HOST --bindir=$PREFIXBIN --libdir=$PREFIXLIB --includedir=$PREFIXINC --datarootdir=$PREFIXDATAROOT --sysconfdir=$PREFIX --with-cache-dir=$PREFIX/cache/fontconfig --disable-docs --enable-iconv --with-libiconv-lib=$PREFIXLIB --with-libiconv-includes=$PREFIXINC --enable-libxml2"
        doMakeInstall "$FONTCONFIGFOLDER" "fontconfig" ""
        doFullClean "$FONTCONFIGFOLDER" "fontconfig"
        doCheckInstall "$FONTCONFIGLIBS"
        doLicense "$FONTCONFIGFOLDER" "fontconfig" "COPYING"
    else
        echo "    Build fontconfig skipped (Already built)."
    fi
}

dofreetype() {
    echo ""
    echo "  freetype..."
    local FREETYPEFOLDER=freetype2
    local FREETYPELIBS="libfreetype"
    doCheckLibraryNotValid "$FREETYPELIBS" "freetype" "$FREETYPEFOLDER" #Check if library is already built
    if (( $? )) || $FORCECONFIGURE; then
        doCleanInstall "freetype" "$FREETYPELIBS" "freetype2" ""
        doGitClean "$FREETYPEFOLDER" "freetype"
        doAutoGen "$FREETYPEFOLDER" "freetype"
        if [ "$CONFIGSELECT" == "Shared" ]; then
            local LOCALBUILDOPTS="--enable-shared --disable-static"
        else
            local LOCALBUILDOPTS="--disable-shared --enable-static"
        fi
        doConfigure "$FREETYPEFOLDER" "freetype" "$LOCALBUILDOPTS --build=$BUILD --host=$HOST --bindir=$PREFIXBIN --libdir=$PREFIXLIB --includedir=$PREFIXINC --datarootdir=$PREFIXDATAROOT --without-zlib --without-png --without-harfbuzz"
        doMakeInstall "$FREETYPEFOLDER" "freetype" ""
        doFullClean "$FREETYPEFOLDER" "freetype"
        doCheckInstall "$FREETYPELIBS"
        doLicense "$FREETYPEFOLDER" "freetype" "docs/LICENSE.TXT"
    else
        echo "    Build freetype skipped (Already built)."
    fi
}

dofribidi() {
    echo ""
    echo "  fribidi..."
    local FRIBIDIFOLDER=fribidi
    local FRIBIDILIBS="libfribidi"
    doCheckLibraryNotValid "$FRIBIDILIBS" "fribidi" "$FRIBIDIFOLDER" #Check if library is already built
    if (( $? )) || $FORCECONFIGURE; then
        doCleanInstall "fribidi" "$FRIBIDILIBS" "fribidi" ""
        doGitClean "$FRIBIDIFOLDER" "fribidi"
        doAutoConfigure "$FRIBIDIFOLDER" "fribidi"
        if [ "$CONFIGSELECT" == "Shared" ]; then
            local LOCALBUILDOPTS="--enable-shared --disable-static"
        else
            local LOCALBUILDOPTS="--disable-shared --enable-static"
        fi
        doConfigure "$FRIBIDIFOLDER" "fribidi" "$LOCALBUILDOPTS --build=$BUILD --host=$HOST --bindir=$PREFIXBIN --libdir=$PREFIXLIB --includedir=$PREFIXINC --datarootdir=$PREFIXDATAROOT"
        #Need to fix the Makefile to prevent errors when linking
        if !( sed -i -e 's/-export-symbols-regex "^fribidi_.*" $(am__append_1)/-export-symbols-regex "^fribidi_.*" # $(am__append_1)/g' $FRIBIDIFOLDER/lib/Makefile ); then
            echo "    Error: fribidi configuration update failed"
            doExit 1
        fi
        # Build fails with more than 1 thread due to gen.tag/packtab being used in multiple programs
        #   This causes fatal errors when these programs are built in parallel
        doMakeInstall "$FRIBIDIFOLDER" "fribidi" "-j1"
        doFullClean "$FRIBIDIFOLDER" "fribidi"
        doCheckInstall "$FRIBIDILIBS"
        doLicense "$FRIBIDIFOLDER" "fribidi" "COPYING"
    else
        echo "    Build fribidi skipped (Already built)."
    fi
}

dogmp() {
    echo ""
    echo "  gmp..."
    local GMPFOLDER=gmp
    local GMPLIBS="libgmp"
    doCheckLibraryNotValid "$GMPLIBS" "gmp" "$GMPFOLDER" #Check if library is already built
    if (( $? )) || $FORCECONFIGURE; then
        doCleanInstall "gmp" "$GMPLIBS" "" "gmp.h"
        doGitClean "$GMPFOLDER" "gmp"
        doAutoConfigure "$GMPFOLDER" "gmp"
        if [ "$CONFIGSELECT" == "Shared" ]; then
            local LOCALBUILDOPTS="--enable-shared --disable-static"
        else
            local LOCALBUILDOPTS="--disable-shared --enable-static"
        fi
        doConfigure "$GMPFOLDER" "gmp" "$LOCALBUILDOPTS --build=$BUILD --host=$HOST --bindir=$PREFIXBIN --libdir=$PREFIXLIB --includedir=$PREFIXINC --oldincludedir=$PREFIXINC --prefix=$PREFIX --datarootdir=$PREFIXDATAROOT --enable-maintainer-mode"
        doMakeInstall "$GMPFOLDER" "gmp" ""
        doFullClean "$GMPFOLDER" "gmp"
        doCheckInstall "$GMPLIBS"
        doLicense "$GMPFOLDER" "gmp" "COPYING.LESSERv3"
    else
        echo "    Build gmp skipped (Already built)."
    fi
}

dognutls() {
    echo ""
    echo "  gnutls..."
    local GNUTLSFOLDER=gnutls
    local GNUTLSLIBS="libgnutls"
    local GNUTLSDEPLIBS="libnettle libhogweed libz libgmp"
    doCheckLibraryNotValid "$GNUTLSLIBS" "gnutls" "$GNUTLSFOLDER" "$GNUTLSDEPLIBS" #Check if library is already built
    if (( $? )) || $FORCECONFIGURE; then
        doCleanInstall "gnutls" "$GNUTLSLIBS" "gnutls" ""
        doGitClean "$GNUTLSFOLDER" "gnutls"
        #Need to run separate bootstrapping procedure
        if [ -e "configure" ]; then
            rm -rf "$GNUTLSFOLDER/configure"
        fi
        doMake "$GNUTLSFOLDER" "gnutls" "bootstrap"
        if [ "$CONFIGSELECT" == "Shared" ]; then
            local LOCALBUILDOPTS="--enable-shared --disable-static"
        else
            local LOCALBUILDOPTS="--disable-shared --enable-static"
        fi
        if [ "$COMPILER" == "mingw" ] || [ "$COMPILER2" == "mingw" ]; then
            local LOCALOSSPECIFIC="--enable-threads=win32 --enable-local-libopts"
        else
            local LOCALOSSPECIFIC="--enable-threads=posix"
        fi
        doConfigure "$GNUTLSFOLDER" "gnutls" "$LOCALBUILDOPTS $LOCALOSSPECIFIC --build=$BUILD --host=$HOST --bindir=$PREFIXBIN --libdir=$PREFIXLIB --includedir=$PREFIXINC --datarootdir=$PREFIXDATAROOT --disable-cxx --disable-doc --disable-tools --disable-full-test-suite --disable-tests --with-libiconv-prefix=$PREFIX --with-libz-prefix=$PREFIX --disable-openssl-compatibility --disable-nls --without-libidn2 --without-idn --with-included-libtasn1 --with-included-unistring --without-p11-kit"
        doMakeInstall "$GNUTLSFOLDER" "gnutls" ""
        if [ "$COMPILER" == "mingw" ] || [ "$COMPILER2" == "mingw" ]; then
            #Need to fix the package config file to include win32 crypt lib
            if !( sed -i -e 's/-lws2_32/-lws2_32 -lcrypt32/g' $PKG_CONFIG_PATH/gnutls.pc ); then
                echo "    Error: gnutls package config update failed"
                doExit 1
            fi
        fi
        doFullClean "$GNUTLSFOLDER" "gnutls"
        doCheckInstall "$GNUTLSLIBS"
        doLicense "$GNUTLSFOLDER" "gnutls" "LICENSE"
    else
        echo "    Build gnutls skipped (Already built)."
    fi
}

doharfbuzz() {
    echo ""
    echo "  harfbuzz..."
    local HARFBUZZFOLDER=harfbuzz
    local HARFBUZZLIBS="libharfbuzz"
    local HARFBUZZDEPLIBS="libfreetype"
    doCheckLibraryNotValid "$HARFBUZZLIBS" "harfbuzz" "$HARFBUZZFOLDER" "$HARFBUZZDEPLIBS" #Check if library is already built
    if (( $? )) || $FORCECONFIGURE; then
        doCleanInstall "harfbuzz" "$HARFBUZZLIBS" "harfbuzz" ""
        doGitClean "$HARFBUZZFOLDER" "harfbuzz"
        if [ "$CONFIGSELECT" == "Shared" ]; then
            local LOCALBUILDOPTS="--enable-shared --disable-static"
        else
            local LOCALBUILDOPTS="--disable-shared --enable-static"
        fi
        doAutoGen "$HARFBUZZFOLDER" "harfbuzz" "$LOCALBUILDOPTS --with-freetype=yes --with-glib=no --build=$BUILD --host=$HOST --bindir=$PREFIXBIN --libdir=$PREFIXLIB --includedir=$PREFIXINC --datarootdir=$PREFIXDATAROOT"
        doMakeInstall "$HARFBUZZFOLDER" "harfbuzz" ""
        doFullClean "$HARFBUZZFOLDER" "harfbuzz"
        doCheckInstall "$HARFBUZZLIBS"
        doLicense "$HARFBUZZFOLDER" "harfbuzz" "COPYING"
    else
        echo "    Build harfbuzz skipped (Already built)."
    fi
}

dolibaacs() {
    echo ""
    echo "  libaacs..."
    local LIBAACSFOLDER=libaacs
    local LIBAACSLIBS="libaacs"
    local LIBAACSDEPLIBS="libgcrypt"
    doCheckLibraryNotValid "$LIBAACSLIBS" "libaacs" "$LIBAACSFOLDER" "$LIBAACSDEPLIBS" #Check if library is already built
    if (( $? )) || $FORCECONFIGURE; then
        doCleanInstall "libaacs" "$LIBAACSLIBS" "libaacs" ""
        doGitClean "$LIBAACSFOLDER" "libaacs"
        doAutoConfigure "$LIBAACSFOLDER" "libaacs"
        if [ "$CONFIGSELECT" == "Shared" ]; then
            local LOCALBUILDOPTS="--enable-shared --disable-static"
        else
            local LOCALBUILDOPTS="--disable-shared --enable-static"
        fi
        doConfigure "$LIBAACSFOLDER" "libaacs" "$LOCALBUILDOPTS --build=$BUILD --host=$HOST --bindir=$PREFIXBIN --libdir=$PREFIXLIB --includedir=$PREFIXINC --datarootdir=$PREFIXDATAROOT"
        doMakeInstall "$LIBAACSFOLDER" "libaacs" ""
        doFullClean "$LIBAACSFOLDER" "libaacs"
        doCheckInstall "$LIBAACSLIBS"
        doLicense "$LIBAACSFOLDER" "libaacs" "COPYING"
    else
        echo "    Build libaacs skipped (Already built)."
    fi
}

dolibass() {
    echo ""
    echo "  libass..."
    local LIBASSFOLDER=libass
    local LIBASSLIBS="libass"
    local LIBASSDEPLIBS="libfreetype libfontconfig libfribidi libharfbuzz"
    doCheckLibraryNotValid "$LIBASSLIBS" "ass" "$LIBASSFOLDER" "$LIBASSDEPLIBS" #Check if library is already built
    if (( $? )) || $FORCECONFIGURE; then
        doCleanInstall "libass" "$LIBASSLIBS" "ass" ""
        doGitClean "$LIBASSFOLDER" "libass"
        if [ "$CONFIGSELECT" == "Shared" ]; then
            local LOCALBUILDOPTS="--enable-shared --disable-static --disable-asm" #Currently a bug with asm and static build
        else
            local LOCALBUILDOPTS="--disable-shared --enable-static"
        fi
        doAutoGen "$LIBASSFOLDER" "libass"
        doConfigure "$LIBASSFOLDER" "libass" "$LOCALBUILDOPTS --enable-harfbuzz --build=$BUILD --host=$HOST --bindir=$PREFIXBIN --libdir=$PREFIXLIB --includedir=$PREFIXINC --datarootdir=$PREFIXDATAROOT"
        doMakeInstall "$LIBASSFOLDER" "libass" ""
        doFullClean "$LIBASSFOLDER" "libass"
        doCheckInstall "$LIBASSLIBS"
        doLicense "$LIBASSFOLDER" "libass" "COPYING"
    else
        echo "    Build libass skipped (Already built)."
    fi
}

dolibbdplus() {
    echo ""
    echo "  libbdplus..."
    local LIBBDPLUSFOLDER=libbdplus
    local LIBBDPLUSLIBS="libbdplus"
    local LIBBDPLUSDEPLIBS="libgcrypt"
    doCheckLibraryNotValid "$LIBBDPLUSLIBS" "libbdplus" "$LIBBDPLUSFOLDER" "$LIBBDPLUSDEPLIBS" #Check if library is already built
    if (( $? )) || $FORCECONFIGURE; then
        doCleanInstall "libbdplus" "$LIBBDPLUSLIBS" "libbdplus" ""
        doGitClean "$LIBBDPLUSFOLDER" "libbdplus"
        doAutoConfigure "$LIBBDPLUSFOLDER" "libbdplus"
        if [ "$CONFIGSELECT" == "Shared" ]; then
            local LOCALBUILDOPTS="--enable-shared --disable-static"
        else
            local LOCALBUILDOPTS="--disable-shared --enable-static"
        fi
        doConfigure "$LIBBDPLUSFOLDER" "libbdplus" "$LOCALBUILDOPTS --build=$BUILD --host=$HOST --bindir=$PREFIXBIN --libdir=$PREFIXLIB --includedir=$PREFIXINC --datarootdir=$PREFIXDATAROOT --with-libgcrypt-prefix=$PREFIX --with-gpg-error-prefix=$PREFIX --without-libaacs --disable-examples"
        doMakeInstall "$LIBBDPLUSFOLDER" "libbdplus" ""
        doFullClean "$LIBBDPLUSFOLDER" "libbdplus"
        doCheckInstall "$LIBBDPLUSLIBS"
        doLicense "$LIBBDPLUSFOLDER" "libbdplus" "COPYING"
    else
        echo "    Build libbdplus skipped (Already built)."
    fi
}

dolibbluray() {
    echo ""
    echo "  libbluray..."
    local LIBBLURAYFOLDER=libbluray
    local LIBBLURAYLIBS="libbluray"
    local LIBBLURAYDEPLIBS="libfreetype libfontconfig libxml2 libiconv"
    doCheckLibraryNotValid "$LIBBLURAYLIBS" "libbluray" "$LIBBLURAYFOLDER" "$LIBBLURAYDEPLIBS" #Check if library is already built
    if (( $? )) || $FORCECONFIGURE; then
        doCleanInstall "libbluray" "$LIBBLURAYLIBS" "libbluray" ""
        doGitClean "$LIBBLURAYFOLDER" "libbluray"
        doAutoConfigure "$LIBBLURAYFOLDER" "libbluray"
        if [ "$CONFIGSELECT" == "Shared" ]; then
            local LOCALBUILDOPTS="--enable-shared --disable-static"
        else
            local LOCALBUILDOPTS="--disable-shared --enable-static"
            echo "WARNING: libbluray only by default supports loading of shared libs dynamically at runtime"
        fi
        # libbluray needs ant installed - see https://ant.apache.org/manual/index.html
        doConfigure "$LIBBLURAYFOLDER" "libbluray" "$LOCALBUILDOPTS --build=$BUILD --host=$HOST --bindir=$PREFIXBIN --libdir=$PREFIXLIB --includedir=$PREFIXINC --datarootdir=$PREFIXDATAROOT --disable-examples --disable-doxygen-doc --disable-doxygen-dot --disable-doxygen-html --disable-doxygen-ps --disable-doxygen-pdf"
        doMakeInstall "$LIBBLURAYFOLDER" "libbluray" ""
        doFullClean "$LIBBLURAYFOLDER" "libbluray"
        doCheckInstall "$LIBBLURAYLIBS"
        doLicense "$LIBBLURAYFOLDER" "libbluray" "COPYING"
    else
        echo "    Build libbluray skipped (Already built)."
    fi
}

dolibcdio() {
    echo ""
    echo "  libcdio..."
    local LIBCDIOFOLDER=libcdio
    local LIBCDIOLIBS="libcdio"
    local LIBCDIODEPLIBS="libiconv"
    doCheckLibraryNotValid "$LIBCDIOLIBS" "libcdio" "$LIBCDIOFOLDER" "$LIBCDIODEPLIBS" #Check if library is already built
    if (( $? )) || $FORCECONFIGURE; then
        doCleanInstall "libcdio" "$LIBCDIOLIBS" "cdio" ""
        doGitClean "$LIBCDIOFOLDER" "libcdio"
        if [ "$CONFIGSELECT" == "Shared" ]; then
            local LOCALBUILDOPTS="--enable-shared --disable-static"
        else
            local LOCALBUILDOPTS="--disable-shared --enable-static"
        fi
        #  --enable-vcd-info - uses libvcd
        # also can use libcddb for cd information lookup
        doAutoGen "$LIBCDIOFOLDER" "libcdio" "$LOCALBUILDOPTS --build=$BUILD --host=$HOST --bindir=$PREFIXBIN --libdir=$PREFIXLIB --includedir=$PREFIXINC --datarootdir=$PREFIXDATAROOT --sysconfdir=$PREFIX --disable-example-progs --disable-cxx --without-cd-drive --without-cd-info --without-cdda-player --without-cd-read --without-iso-info --without-iso-read --with-libiconv-prefix=$PREFIX"
        doMakeInstall "$LIBCDIOFOLDER" "libcdio" ""
        doClean "$LIBCDIOFOLDER" "libcdio"
        doCheckInstall "$LIBCDIOLIBS"
        doLicense "$LIBCDIOFOLDER" "libcdio" "COPYING"
    else
        echo "    Build libcdio skipped (Already built)."
    fi
}

dolibcdioparanoi() {
    echo ""
    echo "  libcdio-paranoia..."
    local LIBCDIOPARANOIAFOLDER=libcdio-paranoia
    local LIBCDIOPARANOIALIBS="libcdio_cdda libcdio_paranoia"
    local LIBCDIOPARANOIADEPLIBS="libcdio"
    doCheckLibraryNotValid "$LIBCDIOPARANOIALIBS" "libcdio-paranoia" "$LIBCDIOPARANOIAFOLDER" "$LIBCDIOPARANOIADEPLIBS" #Check if library is already built
    if (( $? )) || $FORCECONFIGURE; then
        doCleanInstall "libcdio-paranoia" "$LIBCDIOPARANOIALIBS" "cdio/paranoia" ""
        doGitClean "$LIBCDIOPARANOIAFOLDER" "libcdio-paranoia"
        if [ "$CONFIGSELECT" == "Shared" ]; then
            local LOCALBUILDOPTS="--enable-shared --disable-static"
        else
            local LOCALBUILDOPTS="--disable-shared --enable-static"
        fi
        doAutoGen "$LIBCDIOPARANOIAFOLDER" "libcdio-paranoia" "$LOCALBUILDOPTS --build=$BUILD --host=$HOST --bindir=$PREFIXBIN --libdir=$PREFIXLIB --includedir=$PREFIXINC --datarootdir=$PREFIXDATAROOT --sysconfdir=$PREFIX --disable-example-progs --disable-cxx"
        doMakeInstall "$LIBCDIOPARANOIAFOLDER" "libcdio-paranoia" ""
        doFullClean "$LIBCDIOPARANOIAFOLDER" "libcdio-paranoia"
        doCheckInstall "$LIBCDIOPARANOIALIBS"
        doLicense "$LIBCDIOPARANOIAFOLDER" "libcdio-paranoia" "COPYING"
    else
        echo "    Build libcdio-paranoia skipped (Already built)."
    fi
}

dolibdvdcss() {
    echo ""
    echo "  libdvdcss..."
    local LIBDVDCSSFOLDER=libdvdcss
    local LIBDVDCSSLIBS="libdvdcss"
    doCheckLibraryNotValid "$LIBDVDCSSLIBS" "libdvdcss" "$LIBDVDCSSFOLDER" #Check if library is already built
    if (( $? )) || $FORCECONFIGURE; then
        doCleanInstall "libdvdcss" "$LIBDVDCSSLIBS" "dvdcss" ""
        doGitClean "$LIBDVDCSSFOLDER" "libdvdcss"
        doAutoConfigure "$LIBDVDCSSFOLDER" "libdvdcss"
        if [ "$CONFIGSELECT" == "Shared" ]; then
            local LOCALBUILDOPTS="--enable-shared --disable-static"
        else
            local LOCALBUILDOPTS="--disable-shared --enable-static"
        fi
        doConfigure "$LIBDVDCSSFOLDER" "libdvdcss" "$LOCALBUILDOPTS --build=$BUILD --host=$HOST --bindir=$PREFIXBIN --libdir=$PREFIXLIB --includedir=$PREFIXINC --datarootdir=$PREFIXDATAROOT --disable-apidoc"
        doMakeInstall "$LIBDVDCSSFOLDER" "libdvdcss" ""
        doFullClean "$LIBDVDCSSFOLDER" "libdvdcss"
        doCheckInstall "$LIBDVDCSSLIBS"
        doLicense "$LIBDVDCSSFOLDER" "libdvdcss" "COPYING"
    else
        echo "    Build libdvdcss skipped (Already built)."
    fi
}

dolibdvdnav() {
    echo ""
    echo "  libdvdnav..."
    local LIBDVDNAVFOLDER=libdvdnav
    local LIBDVDNAVLIBS="libdvdnav"
    local LIBDVDNAVDEPLIBS="libdvdread"
    doCheckLibraryNotValid "$LIBDVDNAVLIBS" "libdvdnav" "$LIBDVDNAVFOLDER" "$LIBDVDNAVDEPLIBS" #Check if library is already built
    if (( $? )) || $FORCECONFIGURE; then
        doCleanInstall "libdvdnav" "$LIBDVDNAVLIBS" "dvdnav" ""
        doGitClean "$LIBDVDNAVFOLDER" "libdvdnav"
        doAutoConfigure "$LIBDVDNAVFOLDER" "libdvdnav"
        if [ "$CONFIGSELECT" == "Shared" ]; then
            local LOCALBUILDOPTS="--enable-shared --disable-static"
        else
            local LOCALBUILDOPTS="--disable-shared --enable-static"
        fi
        doConfigure "$LIBDVDNAVFOLDER" "libdvdnav" "$LOCALBUILDOPTS --build=$BUILD --host=$HOST --bindir=$PREFIXBIN --libdir=$PREFIXLIB --includedir=$PREFIXINC --datarootdir=$PREFIXDATAROOT --disable-apidoc"
        doMakeInstall "$LIBDVDNAVFOLDER" "libdvdnav" ""
        doFullClean "$LIBDVDNAVFOLDER" "libdvdnav"
        doCheckInstall "$LIBDVDNAVLIBS"
        doLicense "$LIBDVDNAVFOLDER" "libdvdnav" "COPYING"
    else
        echo "    Build libdvdnav skipped (Already built)."
    fi
}

dolibdvdread() {
    echo ""
    echo "  libdvdread..."
    local LIBDVDREADFOLDER=libdvdread
    local LIBDVDREADLIBS="libdvdread"
    local LIBDVDREADDEPLIBS="libdvdcss"
    doCheckLibraryNotValid "$LIBDVDREADLIBS" "libdvdread" "$LIBDVDREADFOLDER" "$LIBDVDREADDEPLIBS" #Check if library is already built
    if (( $? )) || $FORCECONFIGURE; then
        doCleanInstall "libdvdread" "$LIBDVDREADLIBS" "dvdread" ""
        doGitClean "$LIBDVDREADFOLDER" "libdvdread"
        doAutoConfigure "$LIBDVDREADFOLDER" "libdvdread"
        if [ "$CONFIGSELECT" == "Shared" ]; then
            local LOCALBUILDOPTS="--enable-shared --disable-static"
        else
            local LOCALBUILDOPTS="--disable-shared --enable-static"
        fi
        doConfigure "$LIBDVDREADFOLDER" "libdvdread" "$LOCALBUILDOPTS --build=$BUILD --host=$HOST --bindir=$PREFIXBIN --libdir=$PREFIXLIB --includedir=$PREFIXINC --datarootdir=$PREFIXDATAROOT --disable-apidoc --with-libdvdcss"
        doMakeInstall "$LIBDVDREADFOLDER" "libdvdread" ""
        doFullClean "$LIBDVDREADFOLDER" "libdvdread"
        doCheckInstall "$LIBDVDREADLIBS"
        doLicense "$LIBDVDREADFOLDER" "libdvdread" "COPYING"
    else
        echo "    Build libdvdread skipped (Already built)."
    fi
}

dolibgcrypt() {
    echo ""
    echo "  libgcrypt..."
    local LIBGCRYPTFOLDER=libgcrypt
    local LIBGCRYPTLIBS="libgcrypt"
    local LIBGCRYPTDEPLIBS="libgpg-error"
    doCheckLibraryNotValid "$LIBGCRYPTLIBS" "libgcrypt" "$LIBGCRYPTFOLDER" "$LIBGCRYPTDEPLIBS" #Check if library is already built
    if (( $? )) || $FORCECONFIGURE; then
        doCleanInstall "libgcrypt" "$LIBGCRYPTLIBS" "" "gcrypt.h"
        doGitClean "$LIBGCRYPTFOLDER" "libgcrypt"
        doAutoGen "$LIBGCRYPTFOLDER" "libgcrypt"
        if [ "$CONFIGSELECT" == "Shared" ]; then
            local LOCALBUILDOPTS="--enable-shared --disable-static"
        else
            local LOCALBUILDOPTS="--disable-shared --enable-static"
        fi
        if [ "$COMPILER" == "mingw" ] || [ "$COMPILER2" == "mingw" ]; then
            local LOCALOSOPTS="--enable-threads=windows"
        else
            local LOCALOSOPTS="--enable-threads=posix"
        fi
        #There is a bug that causes linking with asm to fail??? not sure why
        doConfigure "$LIBGCRYPTFOLDER" "libgcrypt" "$LOCALBUILDOPTS --build=$BUILD --host=$HOST --bindir=$PREFIXBIN --libdir=$PREFIXLIB --includedir=$PREFIXINC --datarootdir=$PREFIXDATAROOT --sysconfdir=$PREFIX $LOCALOSOPTS --enable-maintainer-mode --disable-doc --disable-tests"
        # Build fails with more than 1 thread due to doc/version.texi being used before it is created
        doMakeInstall "$LIBGCRYPTFOLDER" "libgcrypt" ""
        doFullClean "$LIBGCRYPTFOLDER" "libgcrypt"
        doCheckInstall "$LIBGCRYPTLIBS"
        doLicense "$LIBGCRYPTFOLDER" "libgcrypt" "COPYING"
    else
        echo "    Build libgcrypt skipped (Already built)."
    fi
}

dolibgpgerror() {
    echo ""
    echo "  libgpg-error..."
    local LIBGPGERRORFOLDER=libgpg-error
    local LIBGPGERRORLIBS="libgpg-error"
    doCheckLibraryNotValid "$LIBGPGERRORLIBS" "libgpg-error" "$LIBGPGERRORFOLDER" #Check if library is already built
    if (( $? )) || $FORCECONFIGURE; then
        doCleanInstall "libgpg-error" "$LIBGPGERRORLIBS" "" "gpg-error.h"
        doGitClean "$LIBGPGERRORFOLDER" "libgpg-error"
        if [ "$CONFIGSELECT" == "Shared" ]; then
            local LOCALBUILDOPTS="--enable-shared --disable-static"
        else
            local LOCALBUILDOPTS="--disable-shared --enable-static"
        fi
        if [ "$COMPILER" == "mingw" ] || [ "$COMPILER2" == "mingw" ]; then
            local LOCALOSOPTS="--enable-threads=windows"
        else
            local LOCALOSOPTS="--enable-threads=posix"
        fi
        doAutoGen "$LIBGPGERRORFOLDER" "libgpg-error" ""
        doConfigure "$LIBGPGERRORFOLDER" "libgpg-error" "$LOCALBUILDOPTS --build=$BUILD --host=$HOST --bindir=$PREFIXBIN --libdir=$PREFIXLIB --includedir=$PREFIXINC --datarootdir=$PREFIXDATAROOT --sysconfdir=$PREFIX $LOCALOSOPTS --enable-maintainer-mode --disable-languages --disable-doc --disable-tests --with-libiconv-prefix=$PREFIX"
        doMakeInstall "$LIBGPGERRORFOLDER" "libgpg-error" ""
        doFullClean "$LIBGPGERRORFOLDER" "libgpg-error"
        doCheckInstall "$LIBGPGERRORLIBS"
        doLicense "$LIBGPGERRORFOLDER" "libgpg-error" "COPYING"
    else
        echo "    Build libgpg-error skipped (Already built)."
    fi
}

dolibiconv() {
    echo ""
    echo "  libiconv..."
    local LIBICONVFOLDER=libiconv
    #******TODO  Check which libs are actually needed
    local LIBICONVLIBS="libiconv libcharset"
    doCheckLibraryNotValid "$LIBICONVLIBS" "libiconv" "$LIBICONVFOLDER" #Check if library is already built
    if (( $? )) || $FORCECONFIGURE; then
        doCleanInstall "libiconv" "$LIBICONVLIBS" "" "iconv.h libcharset.h localcharset.h"
        doGitClean "$LIBICONVFOLDER" "libiconv"
        if [ "$CONFIGSELECT" == "Shared" ]; then
            local LOCALBUILDOPTS="--enable-shared --disable-static"
        else
            local LOCALBUILDOPTS="--disable-shared --enable-static"
        fi
        doAutoGen "$LIBICONVFOLDER" "libiconv" ""
        doConfigure "$LIBICONVFOLDER" "libiconv" "$LOCALBUILDOPTS --build=$BUILD --host=$HOST --bindir=$PREFIXBIN --libdir=$PREFIXLIB --includedir=$PREFIXINC --datarootdir=$PREFIXDATAROOT"
        doMakeInstall "$LIBICONVFOLDER" "libiconv" ""
        doFullClean "$LIBICONVFOLDER" "libiconv"
        doCheckInstall "$LIBICONVLIBS"
        doLicense "$LIBICONVFOLDER" "libiconv" "COPYING"
        #Delete the unecessary iconv.exe
        rm -f $PREFIXBIN/iconv.exe
    else
        echo "    Build libiconv skipped (Already built)."
    fi
}

dolibilbc() {
    echo ""
    echo "  libilbc..."
    local LIBILBCFOLDER=libilbc
    local LIBILBCLIBS="libilbc"
    doCheckLibraryNotValid "$LIBILBCLIBS" "libilbc" "$LIBILBCFOLDER" #Check if library is already built
    if (( $? )) || $FORCECONFIGURE; then
        doCleanInstall "libilbc" "$LIBILBCLIBS" "" "ilbc.h"
        doGitClean "$LIBILBCFOLDER" "libilbc"
        doAutoConfigure "$LIBILBCFOLDER" "libilbc"
        if [ "$CONFIGSELECT" == "Shared" ]; then
            local LOCALBUILDOPTS="--enable-shared --disable-static"
        else
            local LOCALBUILDOPTS="--disable-shared --enable-static"
        fi
        doConfigure "$LIBILBCFOLDER" "libilbc" "$LOCALBUILDOPTS --build=$BUILD --host=$HOST --bindir=$PREFIXBIN --libdir=$PREFIXLIB --includedir=$PREFIXINC --datarootdir=$PREFIXDATAROOT"
        doMakeInstall "$LIBILBCFOLDER" "libilbc" ""
        doFullClean "$LIBILBCFOLDER" "libilbc"
        doCheckInstall "$LIBILBCLIBS"
        doLicense "$LIBILBCFOLDER" "libilbc" "COPYING"
    else
        echo "    Build libilbc skipped (Already built)."
    fi
}

dolibgme() {
    echo ""
    echo "  libgme..."
    local LIBGMEFOLDER=game-music-emu
    local LIBGMELIBS="libgme"
    doCheckLibraryNotValid "$LIBGMELIBS" "libgme" "$LIBGMEFOLDER" #Check if library is already built
    if (( $? )) || $FORCECONFIGURE; then
        doCleanInstall "libgme" "$LIBGMELIBS" "gme" ""
        doGitClean "$LIBGMEFOLDER" "libgme"
        if [ "$CONFIGSELECT" == "Shared" ]; then
            local LOCALBUILDOPTS="-DBUILD_SHARED_LIBS=ON"
        else
            local LOCALBUILDOPTS="-DBUILD_SHARED_LIBS=OFF"
        fi
        doCMake "$LIBGMEFOLDER" "libgme" "-DCMAKE_INSTALL_PREFIX=$PREFIX $LOCALBUILDOPTS"
        doMakeInstall "$LIBGMEFOLDER/$CMAKETEMPFOLDER" "libgme" ""
        # libgme currently will always build a shared lib
        if [ "$CONFIGSELECT" == "Static" ]; then
            rm -f $PREFIXLIB/libgme.dll.a
            rm -f $PREFIXBIN/libgme.dll
        fi
        doCleanCMake "$LIBGMEFOLDER" "libgme"
        doCheckInstall "$LIBGMELIBS"
        doLicense "$LIBGMEFOLDER" "libgme" "license.txt"
    else
        echo "    Build libgme skipped (Already built)."
    fi
}

doliblzma() {
    echo ""
    echo "  liblzma..."
    local LIBLZMAFOLDER=liblzma
    #******TODO  Check which libs are actually needed
    local LIBLZMALIBS="liblzma"
    doCheckLibraryNotValid "$LIBLZMALIBS" "liblzma" "$LIBLZMAFOLDER" #Check if library is already built
    if (( $? )) || $FORCECONFIGURE; then
        doCleanInstall "liblzma" "$LIBLZMALIBS" "lzma" "lzma.h"
        doGitClean "$LIBLZMAFOLDER" "liblzma"
        if [ "$CONFIGSELECT" == "Shared" ]; then
            local LOCALBUILDOPTS="--enable-shared --disable-static"
        else
            local LOCALBUILDOPTS="--disable-shared --enable-static"
        fi
        doAutoGen "$LIBLZMAFOLDER" "liblzma" ""
        doConfigure "$LIBLZMAFOLDER" "liblzma" "$LOCALBUILDOPTS --build=$BUILD --host=$HOST --bindir=$PREFIXBIN --libdir=$PREFIXLIB --includedir=$PREFIXINC --datarootdir=$PREFIXDATAROOT --sysconfdir=$PREFIX --disable-xz --disable-xzdec --disable-lzmadec --disable-lzmainfo --disable-lzma-links --disable-scripts --with-libiconv-prefix=$PREFIX"
        doMakeInstall "$LIBLZMAFOLDER" "liblzma" ""
        doFullClean "$LIBLZMAFOLDER" "liblzma"
        doCheckInstall "$LIBLZMALIBS"
        doLicense "$LIBLZMAFOLDER" "liblzma" "COPYING.LGPLv2.1" #Technically its public domain but there isnt a file for that
    else
        echo "    Build liblzma skipped (Already built)."
    fi
}

dolibssh() {
    echo ""
    echo "  libssh..."
    local SSHFOLDER=libssh
    local SSHLIBS="libssh"
    local SSHDEPLIBS="libgcrypt libz"
    doCheckLibraryNotValid "$SSHLIBS" "libssh" "$SSHFOLDER" "$SSHDEPLIBS" #Check if library is already built
    if (( $? )) || $FORCECONFIGURE; then
        doCleanInstall "libssh" "$SSHLIBS libssh_threads" "libssh" ""
        doGitClean "$SSHFOLDER" "libssh"
        if [ "$CONFIGSELECT" == "Shared" ]; then
            local LOCALBUILDOPTS="-DWITH_STATIC_LIB:bool=off -DBUILD_SHARED_LIBS:bool=on"
        else
            local LOCALBUILDOPTS="-DWITH_STATIC_LIB:bool=on -DBUILD_SHARED_LIBS:bool=off"
        fi
        # Currently a bug whereby CMake does not include the gpg-error lib used by gcrypt causing linker errors
        if !( sed -i -e 's/${GCRYPT_LIBRARY}/${GCRYPT_LIBRARY} gpg-error/g' $SSHFOLDER/src/CMakeLists.txt ); then
            echo "    Error: libssh cmake update failed"
            doExit 1
        fi
        doCMake "$SSHFOLDER" "libssh" "$LOCALBUILDOPTS -DWITH_GCRYPT:bool=on -DBIN_INSTALL_DIR=$PREFIXBIN -DLIB_INSTALL_DIR=$PREFIXLIB -DINCLUDE_INSTALL_DIR=$PREFIXINC -DWITH_DEBUG_CALLTRACE:bool=off -DWITH_SSH1:bool=on -DLIBSSH_THREADS:bool=off -DWITH_EXAMPLES:bool=off"
        doMakeInstall "$SSHFOLDER/$CMAKETEMPFOLDER" "libssh" ""
        # Undo the cmake changes
        if !( sed -i -e 's/${GCRYPT_LIBRARY} gpg-error/${GCRYPT_LIBRARY}/g' $SSHFOLDER/src/CMakeLists.txt ); then
            echo "    Error: libssh cmake revert failed"
            doExit 1
        fi
        # libssh currently will always build a shared lib
        if [ "$CONFIGSELECT" == "Static" ]; then
            #update the pkg-config file to use static linkage
            if !( sed -i -e 's/Cflags: /Cflags: -DLIBSSH_STATIC /g' $PKG_CONFIG_PATH/libssh.pc ); then
                echo "    Error: libssh pkg-config update failed"
                doExit 1
            fi
            #Add the gcrypt requirements
            if !( echo -L$PREFIXLIB -lgcrypt >> $PKG_CONFIG_PATH/libssh.pc ); then
                echo "    Error: libssh pkg-config update failed"
                doExit 1
            fi
            rm -f "$PREFIXLIB"/libssh.dll*
            rm -f "$PREFIXBIN"/libssh.dll*
            rm -f "$PREFIXLIB"/libssh_threads.dll*
            rm -f "$PREFIXBIN"/libssh_threads.dll*
            rm -f "$PREFIXLIB"/libssh.so*
            rm -f "$PREFIXBIN"/libssh.so*
            rm -f "$PREFIXLIB"/libssh_threads.so*
            rm -f "$PREFIXBIN"/libssh_threads.so*
        fi
        doCleanCMake "$SSHFOLDER" "libssh"
        doCheckInstall "$SSHLIBS"
        doLicense "$SSHFOLDER" "libssh" "COPYING"
    else
        echo "    Build libssh skipped (Already built)."
    fi
}

dolibxml2() {
    echo ""
    echo "  libxml2..."
    local LIBXML2FOLDER=libxml2
    local LIBXML2LIBS="libxml2"
    local LIBXML2DEPLIBS="libz liblzma libiconv"
    doCheckLibraryNotValid "$LIBXML2LIBS" "libxml2" "$LIBXML2FOLDER" "$LIBXML2DEPLIBS" #Check if library is already built
    if (( $? )) || $FORCECONFIGURE; then
        doCleanInstall "libxml2" "$LIBXML2LIBS" "libxml2" ""
        doGitClean "$LIBXML2FOLDER" "libxml2"
        if [ "$CONFIGSELECT" == "Shared" ]; then
            local LOCALBUILDOPTS="--enable-shared --disable-static"
        else
            local LOCALBUILDOPTS="--disable-shared --enable-static"
        fi
        doAutoGen "$LIBXML2FOLDER" "libxml2" "$LOCALBUILDOPTS --build=$BUILD --host=$HOST --bindir=$PREFIXBIN --libdir=$PREFIXLIB --includedir=$PREFIXINC --datarootdir=$PREFIXDATAROOT --sysconfdir=$PREFIX --with-zlib=$PREFIX --with-lzma=$PREFIX --with-iconv=$PREFIX --without-python"
        doMakeInstall "$LIBXML2FOLDER" "libxml2" ""
        doFullClean "$LIBXML2FOLDER" "libxml2"
        doCheckInstall "$LIBXML2LIBS"
        doLicense "$LIBXML2FOLDER" "libxml2" "Copyright"
    else
        echo "    Build libxml2 skipped (Already built)."
    fi
}

dolibvpx() {
    echo ""
    echo "  libvpx..."
    local VPXFOLDER=libvpx
    local VPXLIBS="libvpx"
    doCheckLibraryNotValid "$VPXLIBS" "libvpx" "$VPXFOLDER" #Check if library is already built
    if (( $? )) || $FORCECONFIGURE; then
        doCleanInstall "libvpx" "$VPXLIBS" "vpx" ""
        doGitClean "$VPXFOLDER" "libvpx"
        if [ "$COMPILER" == "mingw" ] || [ "$COMPILER2" == "mingw" ]; then
            if [ "$ARCH" == "x86" ]; then
                local LOCALTARGET="x86-win32-gcc"
            elif [ "$ARCH" == "x86_64" ]; then
                local LOCALTARGET="x86_64-win64-gcc"
            fi
        elif [ "$COMPILER" == "gcc" ]; then
            if [ "$ARCH" == "x86" ]; then
                local LOCALTARGET="x86-linux-gcc"
            elif [ "$ARCH" == "x86_64" ]; then
                local LOCALTARGET="x86_64-linux-gcc"
            fi
        else
            echo "    Error: Unsupported compiler."
            doExit 1
        fi
        if [ "$CONFIGSELECT" == "Shared" ]; then
            local LOCALBUILDOPTS="--enable-shared --disable-static"
        else
            local LOCALBUILDOPTS="--disable-shared --enable-static"
        fi
        doConfigure "$VPXFOLDER" "libvpx" "$LOCALBUILDOPTS --target=$LOCALTARGET --prefix=$PREFIX --disable-unit-tests --disable-examples --disable-docs --disable-install-bins --enable-vp8 --enable-vp9 --enable-vp9-highbitdepth"
        if [ "$COMPILER" == "mingw" ]; then
            # There is a bug that causes compilation to fail due to an error in strip
            if !( sed -i -e 's/HAVE_GNU_STRIP=yes/HAVE_GNU_STRIP=no/g' $VPXFOLDER/libs-$LOCALTARGET.mk ); then
                echo "    Error: libvpx make update failed"
                doExit 1
            fi
        fi
        doMakeInstall "$VPXFOLDER" "libvpx" ""
        doClean "$VPXFOLDER" "libvpx"
        doCheckInstall "$VPXLIBS"
        doLicense "$VPXFOLDER" "libvpx" "LICENSE"
    else
        echo "    Build libvpx skipped (Already built)."
    fi
}

domfxdispatch() {
    echo ""
    echo "  mfx_dispatch..."
    local MFXDISPATCHFOLDER=mfx_dispatch
    local MFXDISPATCHLIBS="libmfx"
    doCheckLibraryNotValid "$MFXDISPATCHLIBS" "mfx_dispatch" "$MFXDISPATCHFOLDER" #Check if library is already built
    if (( $? )) || $FORCECONFIGURE; then
        doCleanInstall "mfx_dispatch" "$MFXDISPATCHLIBS" "mfx" ""
        doGitClean "$MFXDISPATCHFOLDER" "mfx_dispatch"
        doAutoConfigure "$MFXDISPATCHFOLDER" "mfx_dispatch"
        if [ "$CONFIGSELECT" == "Shared" ]; then
            local LOCALBUILDOPTS="--enable-shared --disable-static"
        else
            local LOCALBUILDOPTS="--disable-shared --enable-static"
        fi
        doConfigure "$MFXDISPATCHFOLDER" "mfx_dispatch" "$LOCALBUILDOPTS --build=$BUILD --host=$HOST --bindir=$PREFIXBIN --libdir=$PREFIXLIB --includedir=$PREFIXINC --datarootdir=$PREFIXDATAROOT"
        doMakeInstall "$MFXDISPATCHFOLDER" "mfx_dispatch" ""
        doFullClean "$MFXDISPATCHFOLDER" "mfx_dispatch"
        doCheckInstall "$MFXDISPATCHLIBS"
        doLicense "$MFXDISPATCHFOLDER" "mfx_dispatch" "COPYING"
    else
        echo "    Build mfx_dispatch skipped (Already built)."
    fi
}

domodplug() {
    echo ""
    echo "  modplug..."
    local MODPLUGFOLDER=modplug
    local MODPLUGLIBS="libmodplug"
    doCheckLibraryNotValid "$MODPLUGLIBS" "modplug" "$MODPLUGFOLDER" #Check if library is already built
    if (( $? )) || $FORCECONFIGURE; then
        doCleanInstall "modplug" "$MODPLUGLIBS" "libmodplug" "modplug.h"
        doGitClean "$MODPLUGFOLDER" "modplug"
        doAutoConfigure "$MODPLUGFOLDER" "modplug"
        if [ "$CONFIGSELECT" == "Shared" ]; then
            local LOCALBUILDOPTS="--enable-shared --disable-static"
        else
            local LOCALBUILDOPTS="--disable-shared --enable-static"
        fi
        doConfigure "$MODPLUGFOLDER" "modplug" "$LOCALBUILDOPTS --build=$BUILD --host=$HOST --bindir=$PREFIXBIN --libdir=$PREFIXLIB --includedir=$PREFIXINC --datarootdir=$PREFIXDATAROOT"
        doMakeInstall "$MODPLUGFOLDER" "modplug" ""
        if [ "$COMPILER" == "mingw" ] || [ "$COMPILER2" == "mingw" ]; then
            #Need to fix the package config file to include appropriate define to allow for linking statically
            if !( sed -i -e 's/-I${includedir}/-I${includedir} -DMODPLUG_BUILD/g' $PKG_CONFIG_PATH/libmodplug.pc ); then
                echo "    Error: modplug package config update failed"
                doExit 1
            fi
        fi
        doFullClean "$MODPLUGFOLDER" "modplug"
        doCheckInstall "$MODPLUGLIBS"
        doLicense "$MODPLUGFOLDER" "modplug" "COPYING"
    else
        echo "    Build modplug skipped (Already built)."
    fi
}

dolame() {
    echo ""
    echo "  mp3lame..."
    local LAMEFOLDER=lame
    local LAMELIBS="libmp3lame"
    doCheckLibraryNotValid "$LAMELIBS" "mp3lame" "$LAMEFOLDER" #Check if library is already built
    if (( $? )) || $FORCECONFIGURE; then
        doCleanInstall "mp3lame" "$LAMELIBS" "lame" ""
        doGitClean "$LAMEFOLDER" "mp3lame"
        if [ "$CONFIGSELECT" == "Shared" ]; then
            local LOCALBUILDOPTS="--enable-shared --disable-static"
        else
            local LOCALBUILDOPTS="--disable-shared --enable-static"
        fi
        #Lame configure was updated to use -msse2 as standard
        doConfigure "$LAMEFOLDER" "mp3lame" "$LOCALBUILDOPTS --build=$BUILD --host=$HOST --bindir=$PREFIXBIN --libdir=$PREFIXLIB --includedir=$PREFIXINC --datarootdir=$PREFIXDATAROOT --enable-nasm --enable-expopt=norm --disable-gtktest --disable-analyzer-hooks --disable-decoder --disable-frontend"
        doMakeInstall "$LAMEFOLDER" "mp3lame" ""
        doFullClean "$LAMEFOLDER" "mp3lame"
        doCheckInstall "$LAMELIBS"
        doLicense "$LAMEFOLDER" "mp3lame" "COPYING"
    else
        echo "    Build mp3lame skipped (Already built)."
    fi
}

donettle() {
    echo ""
    echo "  nettle..."
    local NETTLEFOLDER=nettle
    local NETTLELIBS="libnettle libhogweed"
    local NETTLEDEPLIBS="libgmp"
    doCheckLibraryNotValid "$NETTLELIBS" "nettle" "$NETTLEFOLDER" "$NETTLEDEPLIBS" #Check if library is already built
    if (( $? )) || $FORCECONFIGURE; then
        doCleanInstall "nettle" "$NETTLELIBS" "nettle" ""
        doGitClean "$NETTLEFOLDER" "nettle"
        doAutoConfigure "$NETTLEFOLDER" "nettle"
        if [ "$CONFIGSELECT" == "Shared" ]; then
            local LOCALBUILDOPTS="--enable-shared --disable-static"
        else
            local LOCALBUILDOPTS="--disable-shared --enable-static"
        fi
        doConfigure "$NETTLEFOLDER" "nettle" "$LOCALBUILDOPTS --build=$BUILD --host=$HOST --bindir=$PREFIXBIN --libdir=$PREFIXLIB --includedir=$PREFIXINC --datarootdir=$PREFIXDATAROOT --enable-assembler --disable-documentation --disable-openssl"
        doMakeInstall "$NETTLEFOLDER" "nettle" ""
        doFullClean "$NETTLEFOLDER" "nettle"
        doCheckInstall "$NETTLELIBS"
        doLicense "$NETTLEFOLDER" "nettle" "COPYING.LESSERv3"
    else
        echo "    Build nettle skipped (Already built)."
    fi
}

doogg() {
    echo ""
    echo "  ogg..."
    local OGGFOLDER=ogg
    local OGGLIBS="libogg"
    doCheckLibraryNotValid "$OGGLIBS" "ogg" "$OGGFOLDER" #Check if library is already built
    if (( $? )) || $FORCECONFIGURE; then
        doCleanInstall "ogg" "$OGGLIBS" "ogg" ""
        doGitClean "$OGGFOLDER" "ogg"
        doAutoGen "$OGGFOLDER" "ogg"
        if [ "$CONFIGSELECT" == "Shared" ]; then
            local LOCALBUILDOPTS="--enable-shared --disable-static"
        else
            local LOCALBUILDOPTS="--disable-shared --enable-static"
        fi
        doConfigure "$OGGFOLDER" "ogg" "$LOCALBUILDOPTS --build=$BUILD --host=$HOST --libdir=$PREFIXLIB --includedir=$PREFIXINC --datarootdir=$PREFIXDATAROOT"
        doMakeInstall "$OGGFOLDER" "ogg" ""
        doFullClean "$OGGFOLDER" "ogg"
        doCheckInstall "$OGGLIBS"
        doLicense "$OGGFOLDER" "ogg" "COPYING"
    else
        echo "    Build ogg skipped (Already built)."
    fi
}

doopenssl() {
    echo ""
    echo "  openssl..."
    local OPENSSLFOLDER=openssl
    local OPENSSLLIBS="libssl libcrypto"
    local OPENSSLDEPLIBS="libz"
    doCheckLibraryNotValid "$OPENSSLLIBS" "openssl" "$OPENSSLFOLDER" "$OPENSSLDEPLIBS" #Check if library is already built
    if (( $? )) || $FORCECONFIGURE; then
        doCleanInstall "openssl" "$OPENSSLLIBS" "openssl" "" "ssl"
        doGitClean "$OPENSSLFOLDER" "openssl"
        if [ "$COMPILER" == "mingw" ] || [ "$COMPILER2" == "mingw" ]; then
            if [ "$ARCH" == "x86" ]; then
                local LOCALADDOPTS="mingw"
            elif [ "$ARCH" == "x86_64" ]; then
                local LOCALADDOPTS="mingw64"
            fi
        elif [ "$OS" == "Linux" ]; then
            if [ "$ARCH" == "x86" ]; then
                local LOCALADDOPTS="linux-x86"
            elif [ "$ARCH" == "x86_64" ]; then
                local LOCALADDOPTS="linux-x86_64"
            fi
        else
            local LOCALADDOPTS=""
        fi
        if [ "$CONFIGSELECT" == "Shared" ]; then
            local LOCALBUILDOPTS="shared zlib-dynamic"
        else
            local LOCALBUILDOPTS="no-shared zlib"
        fi
        doConfigure "$OPENSSLFOLDER" "openssl" "--prefix=$PREFIX threads $LOCALBUILDOPTS $LOCALADDOPTS --with-zlib-include=$PREFIXINC --with-zlib-lib=$PREFIXLIB"
        doMakeInstall "$OPENSSLFOLDER" "openssl" ""
        doFullClean "$OPENSSLFOLDER" "openssl"
        doCheckInstall "$OPENSSLLIBS"
        doLicense "$OPENSSLFOLDER" "openssl" "LICENSE"
    else
        echo "    Build openssl skipped (Already built)."
    fi
}

doopus() {
    echo ""
    echo "  opus..."
    local OPUSFOLDER=opus
    local OPUSLIBS="libopus"
    doCheckLibraryNotValid "$OPUSLIBS" "opus" "$OPUSFOLDER" #Check if library is already built
    if (( $? )) || $FORCECONFIGURE; then
        doCleanInstall "opus" "$OPUSLIBS" "opus" ""
        doGitClean "$OPUSFOLDER" "opus"
        doAutoGen "$OPUSFOLDER" "opus"
        if [ "$CONFIGSELECT" == "Shared" ]; then
            local LOCALBUILDOPTS="--enable-shared --disable-static"
        else
            local LOCALBUILDOPTS="--disable-shared --enable-static"
        fi
        doConfigure "$OPUSFOLDER" "opus" "$LOCALBUILDOPTS --build=$BUILD --host=$HOST --bindir=$PREFIXBIN --libdir=$PREFIXLIB --includedir=$PREFIXINC --datarootdir=$PREFIXDATAROOT --disable-doc --disable-extra-programs --enable-intrinsics"
        doMakeInstall "$OPUSFOLDER" "opus" ""
        doFullClean "$OPUSFOLDER" "opus"
        doCheckInstall "$OPUSLIBS"
        doLicense "$OPUSFOLDER" "opus" "COPYING"
    else
        echo "    Build opus skipped (Already built)."
    fi
}

dortmp() {
    echo ""
    echo "  rtmp..."
    local RTMPFOLDER=rtmpdump
    local RTMPLIBS="librtmp"
    local RTMPDEPLIBS="libgnutls libhogweed libnettle libgmp libz"
    doCheckLibraryNotValid "$RTMPLIBS" "rtmp" "$RTMPFOLDER" "$RTMPDEPLIBS" #Check if library is already built
    if (( $? )) || $FORCECONFIGURE; then
        doCleanInstall "rtmp" "$RTMPLIBS" "librtmp" ""
        doGitClean "$RTMPFOLDER" "rtmp"
        if [ "$COMPILER" == "mingw" ] || [ "$COMPILER2" == "mingw" ]; then
            local LOCALADDOPTS="SYS=mingw"
        elif [ "$COMPILER" == "gcc" ]; then
            local LOCALADDOPTS="SYS=gcc"
        else
            local LOCALADDOPTS=""
            echo "    Error: Unsupported compiler"
            doExit 1
        fi
        if [ "$CONFIGSELECT" == "Shared" ]; then
            local LOCALBUILDOPTS="SHARED=yes"
        else
            local LOCALBUILDOPTS="SHARED=no"
        fi
        doMakeInstall "$RTMPFOLDER" "rtmp" "CRYPTO=GNUTLS $LOCALADDOPTS $LOCALBUILDOPTS prefix=$PREFIX incdir=$PREFIXINC/librtmp bindir=$PREFIXBIN sbindir=$PREFIXBIN libdir=$PREFIXLIB mandir=$PREFIXDATAROOT/man XLDFLAGS=\"$LDFLAGS\""
        doClean "$RTMPFOLDER" "rtmp"
        doCheckInstall "$RTMPLIBS"
        doLicense "$RTMPFOLDER" "rtmp" "COPYING"
    else
        echo "    Build rtmp skipped (Already built)."
    fi
}

dosdl() {
    echo ""
    echo "  sdl..."
    local SDLFOLDER=sdl
    local SDLLIBS="libSDL2"
    local SDLDEPLIBS="libiconv"
    doCheckLibraryNotValid "$SDLLIBS" "sdl" "$SDLFOLDER" "$SDLDEPLIBS" #Check if library is already built
    if (( $? )) || $FORCECONFIGURE; then
        doCleanInstall "sdl" "$SDLLIBS" "SDL" ""
        doGitClean "$SDLFOLDER" "sdl"
        doAutoGen "$SDLFOLDER" "sdl"
        if [ "$CONFIGSELECT" == "Shared" ]; then
            local LOCALBUILDOPTS="--enable-shared" # --disable-static" Currently broken withoutstatic build
        else
            local LOCALBUILDOPTS="--disable-shared --enable-static"
        fi
        if [ "$COMPILER" == "mingw" ] || [ "$COMPILER2" == "mingw" ]; then
            local LOCALBUILDOPTS="$LOCALBUILDOPTS --disable-pthreads --disable-alsatest --disable-esdtest"
        fi
        doConfigure "$SDLFOLDER" "sdl" "$LOCALBUILDOPTS --build=$BUILD --host=$HOST --bindir=$PREFIXBIN --libdir=$PREFIXLIB --includedir=$PREFIXINC --datarootdir=$PREFIXDATAROOT"
        doMakeInstall "$SDLFOLDER" "sdl" ""
        doFullClean "$SDLFOLDER" "sdl"
        doCheckInstall "$SDLLIBS"
        doLicense "$SDLFOLDER" "sdl" "COPYING.txt"
    else
        echo "    Build sdl skipped (Already built)."
    fi
}

dosoxr() {
    echo ""
    echo "  soxr..."
    local SOXRFOLDER=soxr
    local SOXRLIBS="libsoxr"
    doCheckLibraryNotValid "$SOXRLIBS" "soxr" "$SOXRFOLDER" #Check if library is already built
    if (( $? )) || $FORCECONFIGURE; then
        doCleanInstall "soxr" "$SOXRLIBS" "" "soxr.h soxr-lsr.h"
        doGitClean "$SOXRFOLDER" "soxr"
        #Check perf of using OpenMP (WITH_OPENMP:bool=off) If using then ffmpeg needs to be modified by changing configure script
        #   sed -i 's/require libsoxr soxr.h soxr_create -lsoxr/require libsoxr soxr.h soxr_create -lsoxr -lgomp/g' configure
        if [ "$CONFIGSELECT" == "Shared" ]; then
            local LOCALBUILDOPTS="-DBUILD_SHARED_LIBS:bool=on"
        else
            local LOCALBUILDOPTS="-DBUILD_SHARED_LIBS:bool=off"
        fi
        doCMake "$SOXRFOLDER" "soxr" "$LOCALBUILDOPTS -DWITH_OPENMP:bool=off -DBIN_INSTALL_DIR=$PREFIXBIN -DLIB_INSTALL_DIR=$PREFIXLIB -DINCLUDE_INSTALL_DIR=$PREFIXINC -DDOC_INSTALL_DIR=$PREFIXDATAROOT -DBUILD_TESTS:bool=off"
        doMakeInstall "$SOXRFOLDER/$CMAKETEMPFOLDER" "soxr" ""
        doCleanCMake "$SOXRFOLDER" "soxr"
        doCheckInstall "$SOXRLIBS"
        doLicense "$SOXRFOLDER" "soxr" "LICENCE"
    else
        echo "    Build soxr skipped (Already built)."
    fi
}

dospeex() {
    echo ""
    echo "  speex..."
    local SPEEXFOLDER=speex
    local SPEEXLIBS="libspeex"
    doCheckLibraryNotValid "$SPEEXLIBS" "speex" "$SPEEXFOLDER" #Check if library is already built
    if (( $? )) || $FORCECONFIGURE; then
        doCleanInstall "speex" "$SPEEXLIBS" "speex" ""
        doGitClean "$SPEEXFOLDER" "speex"
        doAutoGen "$SPEEXFOLDER" "speex"
        if [ "$CONFIGSELECT" == "Shared" ]; then
            local LOCALBUILDOPTS="--enable-shared --disable-static"
        else
            local LOCALBUILDOPTS="--disable-shared --enable-static"
        fi
        doConfigure "$SPEEXFOLDER" "speex" "$LOCALBUILDOPTS --build=$BUILD --host=$HOST --bindir=$PREFIXBIN --libdir=$PREFIXLIB --includedir=$PREFIXINC --datarootdir=$PREFIXDATAROOT --with-ogg-libraries=$PREFIXLIB --with-ogg-includes=$PREFIXINC --disable-oggtest --enable-sse --disable-binaries"
        doMakeInstall "$SPEEXFOLDER" "speex" ""
        doFullClean "$SPEEXFOLDER" "speex"
        doCheckInstall "$SPEEXLIBS"
        doLicense "$SPEEXFOLDER" "speex" "COPYING"
    else
        echo "    Build speex skipped (Already built)."
    fi
}

dotheora() {
    echo ""
    echo "  theora..."
    local THEORAFOLDER=theora
    local THEORALIBS="libtheora libtheoradec libtheoraenc"
    local THEORADEPLIBS="libogg"
    doCheckLibraryNotValid "$THEORALIBS" "theora" "$THEORAFOLDER" "$THEORADEPLIBS" #Check if library is already built
    if (( $? )) || $FORCECONFIGURE; then
        doCleanInstall "theora" "$THEORALIBS" "theora" ""
        doGitClean "$THEORAFOLDER" "theora"
        if [ "$CONFIGSELECT" == "Shared" ]; then
            local LOCALBUILDOPTS="--enable-shared --disable-static"
        else
            local LOCALBUILDOPTS="--disable-shared --enable-static"
        fi
        doAutoGen "$THEORAFOLDER" "theora" "$LOCALBUILDOPTS --build=$BUILD --host=$HOST --libdir=$PREFIXLIB --includedir=$PREFIXINC --datarootdir=$PREFIXDATAROOT --with-ogg-libraries=$PREFIXLIB --with-ogg-includes=$PREFIXINC --with-vorbis-libraries=$PREFIXLIB --with-vorbis-includes=$PREFIXINC --disable-oggtest --disable-vorbistest --disable-sdltest --disable-examples --disable-doc --disable-spec"
        doMakeInstall "$THEORAFOLDER" "theora" ""
        doFullClean "$THEORAFOLDER" "theora"
        doCheckInstall "$THEORALIBS"
        doLicense "$THEORAFOLDER" "theora" "COPYING"
    else
        echo "    Build theora skipped (Already built)."
    fi
}

dovorbis() {
    echo ""
    echo "  vorbis..."
    local VORBISFOLDER=vorbis
    local VORBISLIBS="libvorbis libvorbisfile libvorbisenc"
    local VORBISDEPLIBS="libogg"
    doCheckLibraryNotValid "$VORBISLIBS" "vorbis" "$VORBISFOLDER" "$VORBISDEPLIBS" #Check if library is already built
    if (( $? )) || $FORCECONFIGURE; then
        doCleanInstall "vorbis" "$VORBISLIBS" "vorbis" ""
        doGitClean "$VORBISFOLDER" "vorbis"
        doAutoGen "$VORBISFOLDER" "vorbis"
        if [ "$CONFIGSELECT" == "Shared" ]; then
            local LOCALBUILDOPTS="--enable-shared --disable-static"
        else
            local LOCALBUILDOPTS="--disable-shared --enable-static"
        fi
        doConfigure "$VORBISFOLDER" "vorbis" "$LOCALBUILDOPTS --build=$BUILD --host=$HOST --libdir=$PREFIXLIB --includedir=$PREFIXINC --datarootdir=$PREFIXDATAROOT --with-ogg-libraries=$PREFIXLIB --with-ogg-includes=$PREFIXINC --disable-oggtest"
        doMakeInstall "$VORBISFOLDER" "vorbis" ""
        doFullClean "$VORBISFOLDER" "vorbis"
        doCheckInstall "$VORBISLIBS"
        doLicense "$VORBISFOLDER" "vorbis" "COPYING"
    else
        echo "    Build vorbis skipped (Already built)."
    fi
}

dox264() {
    echo ""
    echo "  x264..."
    local X264FOLDER=x264
    local X264LIBS="libx264"
    doCheckLibraryNotValid "$X264LIBS" "x264" "$X264FOLDER" #Check if library is already built
    if (( $? )) || $FORCECONFIGURE; then
        doCleanInstall "x264" "$X264LIBS" "" "x264.h x264_config.h"
        doGitClean "$X264FOLDER" "x264"
        if [ "$COMPILER" == "mingw" ] || [ "$COMPILER2" == "mingw" ]; then
            local LOCALADDOPTS="--enable-win32thread" #This uses native win32 threads
        else
            local LOCALADDOPTS=""
        fi
        if [ "$CONFIGSELECT" == "Shared" ]; then
            local LOCALBUILDOPTS="--enable-shared --disable-static"
        else
            local LOCALBUILDOPTS="--disable-shared --enable-static"
        fi
        doConfigure "$X264FOLDER" "x264" "$LOCALBUILDOPTS --host=$HOST --libdir=$PREFIXLIB --includedir=$PREFIXINC --enable-strip --disable-cli --disable-gpac --disable-swscale $LOCALADDOPTS"
        doMakeInstall "$X264FOLDER" "x264" ""
        doFullClean "$X264FOLDER" "x264"
        doCheckInstall "$X264LIBS"
        doLicense "$X264FOLDER" "x264" "COPYING"
    else
        echo "    Build x264 skipped (Already built)."
    fi
}

dox265() {
    echo ""
    echo "  x265..."
    local X265FOLDER=x265
    local X265LIBS="libx265"
    doCheckLibraryNotValid "$X265LIBS" "x265" "$X265FOLDER" #Check if library is already built
    if (( $? )) || $FORCECONFIGURE; then
        doCleanInstall "x265" "$X265LIBS" "" "x265.h x265_config.h"
        doGitClean "$X265FOLDER" "x265"
        if [ "$CONFIGSELECT" == "Shared" ]; then
            local LOCALBUILDOPTS="-DENABLE_SHARED:bool=on"
        else
            local LOCALBUILDOPTS="-DENABLE_SHARED:bool=off"
        fi
        if [ "$COMPILER" == "mingw" ] || [ "$COMPILER2" == "mingw" ]; then
            local LOCALADDOPTS="-DWINXP_SUPPORT:bool=on"
        else
            local LOCALADDOPTS=""
        fi
        doCMake "$X265FOLDER/source" "x265" "$LOCALBUILDOPTS $LOCALADDOPTS -DBIN_INSTALL_PREFIX=$PREFIXBIN -DENABLE_CLI:bool=off"
        doMakeInstall "$X265FOLDER/source/$CMAKETEMPFOLDER" "x265" ""
        doCleanCMake "$X265FOLDER/source" "x265"
        doCheckInstall "$X265LIBS"
        doLicense "$X265FOLDER" "x265" "COPYING"
    else
        echo "    Build x265 skipped (Already built)."
    fi
}

doxvid() {
    echo ""
    echo "  xvid..."
    local XVIDFOLDER=xvid
    local XVIDLIBS="libxvidcore"
    doCheckLibraryNotValid "$XVIDLIBS" "xvid" "$XVIDFOLDER" #Check if library is already built
    if (( $? )) || $FORCECONFIGURE; then
        doCleanInstall "xvid" "$XVIDLIBS" "" "xvid.h"
        doGitClean "$XVIDFOLDER" "xvid"
        doAutoConfigure "$XVIDFOLDER/build/generic" "xvid"
        doConfigure "$XVIDFOLDER/build/generic" "xvid" "--build=$BUILD --host=$HOST --bindir=$PREFIXBIN --libdir=$PREFIXLIB --includedir=$PREFIXINC --datarootdir=$PREFIXDATAROOT"
        doMakeInstall "$XVIDFOLDER/build/generic" "xvid" ""
        # libxvidcore currently will always build a shared lib
        if [ "$CONFIGSELECT" == "Static" ]; then
            rm -f $PREFIXLIB/libxvidcore.dll.a
            rm -f $PREFIXBIN/libxvidcore.dll
        fi
        doFullClean "$XVIDFOLDER/build/generic" "xvid"
        doCheckInstall "$XVIDLIBS"
        doLicense "$XVIDFOLDER" "xvid" "LICENSE"
    else
        echo "    Build xvid skipped (Already built)."
    fi
}

dozlib() {
    echo ""
    echo "  zlib..."
    local ZLIBFOLDER=zlib
    local ZLIBLIBS="libz"
    doCheckLibraryNotValid "$ZLIBLIBS" "zlib" "$ZLIBFOLDER" #Check if library is already built
    if (( $? )) || $FORCECONFIGURE; then
        doCleanInstall "zlib" "$ZLIBLIBS" "" "zlib.h zconf.h"
        doGitClean "$ZLIBFOLDER" "zlib"
        if [ "$ARCH" == "x86" ]; then
            local LOCALADDOPTS=""
        elif [ "$ARCH" == "x86_64" ]; then
            local LOCALADDOPTS="--64"
        fi
        if [ "$CONFIGSELECT" == "Shared" ]; then
            local LOCALBUILDOPTS="--shared"
        else
            local LOCALBUILDOPTS="--static"
        fi
        if [ "$COMPILER" == "mingw" ] || [ "$COMPILER2" == "mingw" ]; then
            local LOCALADDOPTS="$LOCALADDOPTS --uname=mingw"
        fi
        doConfigure "$ZLIBFOLDER" "zlib" "$LOCALBUILDOPTS --prefix=$PREFIX --libdir=$PREFIXLIB --includedir=$PREFIXINC $LOCALADDOPTS" "CROSS_PREFIX=$BUILD-"
        doMakeInstall "$ZLIBFOLDER" "zlib" ""
        if [ "$CONFIGSELECT" == "Shared" ]; then
            if [ "$COMPILER" == "mingw" ] || [ "$COMPILER2" == "mingw" ]; then
                cp $PREFIXSRC/$ZLIBFOLDER/libz.dll.a $PREFIXLIB
                cp $PREFIXLIB/libz.dll $PREFIXBIN
                cp $PREFIXLIB/libz.dll.* $PREFIXBIN
            fi
        fi
        doFullClean "$ZLIBFOLDER" "zlib"
        doCheckInstall "$ZLIBLIBS"
        doLicense "$ZLIBFOLDER" "zlib" "README"
    else
        echo "    Build zlib skipped (Already built)."
    fi
}

doffmpeg() {
    echo ""
    echo "  ffmpeg..."
    local FFMPEGFOLDER=FFmpeg
    local FFMPEGLIBS="libavcodec ibavdevice libavfilter libavformat libpostproc libswresample libswscale libavutil"
    if $EXTERNLIBS; then
        local FFMPEGDEPLIBS="libbz2 libiconv libz liblzma libxml2 libmp3lame libvorbis libvorbisenc libtheoraenc libtheoradec libspeex libopus libilbc libx264 libx265 libxvidcore libvpx libgme libmodplug libsoxr libfreetype libfontconfig libfribidi libass libgnutls libssh libgmp libbluray libcdio libcdio_paranoia libmfx libSDL2"
        if $NONFREE; then
            FFMPEGDEPLIBS="$FFMPEGDEPLIBS libfdk-aac"
        fi
    else
        local FFMPEGDEPLIBS=""
    fi
    doCheckLibraryNotValid "$FFMPEGLIBS" "ffmpeg" "$FFMPEGFOLDER" "$FFMPEGDEPLIBS" "$CONFIGSELECT" #Check if library is already built
    if (( $? )) || $FORCECONFIGURE; then
        doCleanInstall "ffmpeg" "$FFMPEGLIBS" "$FFMPEGLIBS" ""
        doGitClean "$FFMPEGFOLDER" "ffmpeg"

        #Configure the arch and OS for FFMpeg
        if [ "$ARCH" == "x86" ]; then
            local TARGETARCH=32
        elif [ "$ARCH" == "x86_64" ]; then
            local TARGETARCH=64
        fi
        if [ "$COMPILER" == "mingw" ] || [ "$COMPILER2" == "mingw" ]; then
            #msvc/icl does not have unistd.h so opengl cannot be built
            if [ "$COMPILER2" == "icl" ]; then
                local FFMPEGOSSPECIFIC="--target-os=win$TARGETARCH --host-os=win32 --toolchain=icl --enable-w32threads --enable-avisynth --extra-cflags=-arch:SSE3"
            elif [ "$COMPILER2" == "msvc" ]; then
                local FFMPEGOSSPECIFIC="--target-os=win$TARGETARCH --toolchain=msvc --enable-w32threads --enable-avisynth --extra-cflags=-arch:SSE2"
            else
                local FFMPEGOSSPECIFIC="--target-os=mingw$TARGETARCH --enable-w32threads --enable-avisynth --enable-opengl --extra-cflags=-msse3"
            fi
        elif [ "$COMPILER" == "gcc" ]; then
            local FFMPEGOSSPECIFIC="--enable-pthreads --enable-opengl --extra-cflags=-msse3"
        else
            echo "    Error: Unknown Compiler Type ($COMPILER) being used"
            doExit 1
        fi

        #Configure build options
        if [ "$CONFIGSELECT" == "Shared" ]; then
            local LOCALBUILDOPTS="--enable-shared --disable-static"
        else
            local LOCALBUILDOPTS="--disable-shared --enable-static --pkg-config-flags=\"--static\""
        fi

        #Check for lto support
        if $BUILDLTO; then
            local LOCALBUILDOPTS="$LOCALBUILDOPTS --enable-lto"
        fi

        #Add additional configure options if building with non-free
        if $NONFREE; then
            local FFMPEGNONFREE="--enable-nonfree"
            local FFMPEGNONFREEEXTERN="--enable-libfdk-aac --enable-nvenc"
            local FFMPEGNONFREEENCODER="--enable-encoder=libfdk_aac --enable-encoder=nvenc_h264 --enable-encoder=nvenc_hevc"
        else
            local FFMPEGNONFREE=""
            local FFMPEGFDK=""
            local FFMPEGENABLEFDK=""
        fi

        if $OPENCLDETECTED; then
            local FFMPEGOPENCL="" #--enable-opencl windows lib not compatible format
        else
            local FFMPEGOPENCL=""
        fi

        if $LIBMFXDETECTED; then
            local FFMPEGLIBMFX="" #--enable-libmfx not detected by package config
        else
            local FFMPEGLIBMFX=""
        fi

        if $EXTERNLIBS; then
            local FFMPEGEXTERNLIBS="--enable-bzlib --enable-iconv --enable-zlib \
                --enable-libmp3lame --enable-libvorbis --enable-libspeex --enable-libopus --enable-libilbc \
                --enable-libtheora --enable-libx264 --enable-libx265 --enable-libxvid --enable-libvpx \
                --enable-libmodplug --enable-libgme --enable-libsoxr \
                --enable-libfreetype --enable-fontconfig --enable-libfribidi --enable-libass \
                --enable-gnutls --enable-gmp \
                --enable-libbluray --enable-libcdio --enable-libmfx --enable-sdl2 \
                $FFMPEGNONFREEEXTERN"
                #  --enable-libssh
        else
            local FFMPEGEXTERNLIBS="--disable-iconv --disable-bzlib --disable-zlib --disable-lzma --disable-xlib"
        fi

        if $FATETESTS; then
            local FFMPEGDISABLE="--disable-doc"
        else
            local FFMPEGDISABLE="--disable-doc --disable-programs"
        fi
        #
        doConfigure "$FFMPEGFOLDER" "ffmpeg" "--prefix=$PREFIX --libdir=$PREFIXLIB --incdir=$PREFIXINC --bindir=$PREFIXBIN \
                --enable-gpl --enable-version3 $FFMPEGNONFREE $LOCALBUILDOPTS \
                $FFMPEGDISABLE $FFMPEGOPENCL $FFMPEGLIBMFX \
                $FFMPEGOSSPECIFIC --arch=$ARCH \
                $FFMPEGEXTERNLIBS --disable-debug"
        doMakeInstall "$FFMPEGFOLDER" "ffmpeg" ""
        if ! $FATETESTS; then
            doFullClean "$FFMPEGFOLDER" "ffmpeg"
        fi
        doCheckInstall "$FFMPEGLIBS" "$CONFIGSELECT"
        doLicense "$FFMPEGFOLDER" "ffmpeg" "COPYING.GPLv3"
    else
        echo "    Build ffmpeg skipped (Already built)."
    fi
    if $FATETESTS; then
        local CURRDIR="$PWD"
        cd "$PREFIXSRC/$FFMPEGFOLDER"
        #read -rsn 1 -p "    Press any key to start FATE tests..."
        echo ""
        echo "    Downloading FATE samples..."
        local FATECOMMANDLINE1="make fate-rsync SAMPLES=../fate-suite/"
        local FATELOG=$PREFIXSRC/ffmpeg-$ARCH-$COMPILER2-FATE.log
        if !( eval $FATECOMMANDLINE1 &> $FATELOG ); then
            echo "    Error: FFmpeg FATE samples download failed"
        fi
        echo "    Running FATE..."
        local FATECOMMANDLINE2="make -j$COMPILETHREADS -k fate SAMPLES=../fate-suite/" # V=2
        if !( eval $FATECOMMANDLINE2 &> $FATELOG ); then
            echo "    Error: FFmpeg FATE test failed"
            cd "$CURRDIR"
            read -rsn 1 -p "    Press any key to clean files (this also cleans FATE logs)..."
            echo ""
            doFullClean "$FFMPEGFOLDER" "ffmpeg"
            doExit 1
        fi
        cd "$CURRDIR"
        doFullClean "$FFMPEGFOLDER" "ffmpeg"
    fi
}

doInit

cd $PREFIXSRC

#Build all the required libraries
for ARCHSEL in $ARCHSELECT
do
    doSetEnvironment $ARCHSEL  #Set the environment as needed
    if $EXTERNLIBS; then
        #***dobzip2
        #***dozlib
        #***dolibiconv        # -  can also use libintl ENABLE_NLS
        #***doliblzma
        ##doexpat            #  -no longer needed
        #***dolibxml2           #Requires iconv, z, lzma (Has UWP mods to several files)
        #***dofdkaac
        #***domodplug       #(Has UWP mods to several files)
        #***dolame
        #***doogg
        #***doopus
        #***dosoxr
        #***dospeex
        #***dovorbis           #Requires ogg
        #***dolibilbc
        #***dolibgme
        #***dolibvpx
        #***dotheora            #Requires ogg
        #***dox264
        #***dox265
        #***doxvid
        ##doenca             #  -no longer needed
        #***dofreetype      # (Has UWP mod new ftstdlib.h)
        #***dofontconfig         # Requires freetype, iconv, libxml2 -  can also use libintl ENABLE_NLS
        #***dofribidi
        #***doharfbuzz          #Requires freetype
        #doopenssl           #  -no longer needed
        #***dolibgpgerror     # -  can also use libintl ENABLE_NLS
        #***dolibgcrypt         #Requires libgpgerror 
        #***dolibssh            #Requires libgcrypt, z - can use either libgcrypt or openssl
        #***dogmp
        #***donettle            #Requires gmp
        #***dognutls            #Requires nettle (+hogweed), z, gmp -  can also use libintl ENABLE_NLS
        ##dortmp             #Requires gnutls, nettle (+hogweed), gmp, z - can use either gnutls or openssl #  -no longer needed
        #***dolibaacs           #Requires libgcrypt
        #***dolibass            #Requires freetype, fontconfig, fribidi, harfbuzz, iconv
        #dolibbdplus         #Requires libgcrypt
        #*dolibbluray         #Requires freetype, fontconfig, libxml2, iconv - #Just requires mods to bdj.c so that it statically links in java/openjdk
        #dolibdvdcss
        #dolibdvdread
        #dolibdvdnav         #requires dvdread
        #***dolibcdio           #Requires iconv -  can also use libvcd, libcddb
        #***dolibcdioparanoi    #Requires cdio
        #*domfxdispatch #Doesnt work as cant dynload dlls, so just need to modify so functions all fail in uwp
        #***dosdl
    fi
    #doffmpeg
done

#Prompt to remove the logs
echo ""
echo "Do you want to delete the build logs?:"
DELLOGOPTS=("Yes" "No")
select opt in "${DELLOGOPTS[@]}"
do
    case $opt in
        "${DELLOGOPTS[0]}" )
            echo " Deleting logs..."
            rm -rf "$PREFIXSRC"/*.log
            break
            ;;
        "${DELLOGOPTS[1]}" )
            break
            ;;
        *) echo invalid option;;
    esac
done

echo ""
echo "Completed Successfully"
doExit 0

#additional options that require testing
#   --enable-avisynth*           ++ Avs input
#   --disable-bzlib*                ++ BZLib is now used by deafult (zeranoe+)
#   --enable-chromaprint        -- enable audio fingerprinting with chromaprint
#    --enable-fontconfig*         ++ Subtitles (zeranoe+)
#   --enable-frei0r             ?? Frei0r video post-processing filters (zeranoe+)
#   --enable-gmp*                ++ enable gmp, needed for rtmp(t)e support if not using librtmp
#   --enable-gnutls*             ++ Support for SSL, TLS and DTLS (zeranoe+) !OpenSSL is not GPL compatible without explicit exception!
#   --disable-iconv*             ++ Converts between Unicode and other character encodings. Enabled by default (zeranoe+)
#    --enable-ladspa             -- Linux Audio Developers Simple Plugin API for filters and effects
#   --enable-libass*             ++ Subtitles (zeranoe+)
#    --enable-libbluray*            ++ bluray support (zeranoe+)
#    --enable-libbs2b             ?? stereo to binaural conversion filter for stereo audio with headphones (zeranoe+)
#   --enable-libcaca             ?? Display of graphics using coloured ASCII text (zeranoe+)
#    --enable-libcelt             -- CELT decoding via libcelt (celt superceeded by opus codec)
#    --enable-libcdio*             ++ cd io support
#    --enable-libdc1394             -- IIDC-1394 grabbing for firewire camera input
#    --enable-libebur128           -- enable libebur128 for EBU R128 measurement, now has own internal implementation
#    --enable-libfdk-aac*         ++ AAC encoder. Supports LC+HE. Is non-distribuatable with GPL reqs --enable-nonfree
#    --enable-libflite             -- Flite voice sythesis
#   --enable-libfreetype*         ++ Subtitle rendering (zeranoe+)
#   --enable-libfribidi*         ++ Use fribidi for better support of foreign languages in text overlay rendering
#    --enable-libgme*             ++ Game Music Emulation (zeranoe+)
#   --enable-libgsm                -- GSM en/decoding. Dont need the encoding abilities and ffmpeg has built in decoder (zeranoe+)
#    --enable-libiec61883        -- iec61883 transmission protocol used over firewire
#   --enable-libilbc*             ++ iLBC internet speech codec (zeranoe+). ffmpeg has no native support
#   --enable-libkvazaar            -- Alternate h265 encoder. Not as good as x265 but does come under LGPL
#   --enable-libmfx*            ++ Enable Intel Quicktime decoding/encoding via libmfx
#   --enable-libmodplug*         ++ Mod tracker audio files such as .mod, .s3m, .it, .xm (zeranoe+)
#   --enable-libmp3lame*           ++ Mp3 encoding (zeranoe+)
#   --enable-libnpp             -- enable NVIDIA Performance Primitives-based code, this is only possible when using non-free
#   --enable-libopencore-amrnb  -- AMR-NB de/encoding, Dont need the encoding abilities, ffmpeg has built in decoder (zeranoe+)
#   --enable-libopencore-amrwb  -- AMR-WB decoder, ffmpeg has built in decoder (zeranoe+)
#    --enable-libopencv             ?? enable video post processing
#    --enable-libopenh264        -- Alternate h264 encoder. Not as good as x264 but BSD and if use Cisco provided binaries is royalty free
#   --enable-libopenjpeg           -- JPEG2000 de/encoder, ffmpeg has built in decoder (also has an encoder) (zeranoe+)
#   --enable-libopenmpt         ?? enable decoding tracked files via libopenmpt (newer replacement for modplug)
#   --enable-libopus*           ++ Opus de/encoding, ffmpeg has built in decoder (zeranoe+)
#    --enable-libpulse            -- Pulseaudio input
#    --enable-librubberband        ?? rubberband filter for audio time-shifting and pitch-shifting
#   --enable-librtmp            -- RTMP stream support (zeranoe+)
#    --enable-libshine            -- Fixed-point mp3 encoding
#    --enable-libsmbclient        -- Allow modifying and accessing samba shares (non-windows only)
#    --enable-libsnappy            -- Enable Snappy encoder, ffmpeg has built in decoder
#   --enable-libsoxr*             ++ Audio resampling library thats added to libswresample that is apparently providing higher quality the libsamplerate although at higher latency (zeranoe+)
#   --enable-libspeex*            ++ Speex de/encode (zeranoe+)
#   --enable-libssh*            ++ SFTP protocol support
#    --enable-libtesseract        ?? OCR character recognition lib needed for ocr filter
#   --enable-libtheora*           ++ Theora video encoding, ffmpeg has built in decoder (zeranoe+)
#    --enable-libtwolame            -- MPEG Audio layer 2 encoder (zeranoe+)
#   --enable-libv4l2            -- libv4l2/v4l-utils decoding raw RDS data from V4L2 Radio devices
#   --enable-libvidstab            -- video stabilization (zeranoe+)
#   --enable-libvo-amrwbenc     -- AMR-WB internet audio codec encoding (zeranoe+)
#   --enable-libvorbis*           ++ Vorbis encoder, ffmpeg has built in encoder/decoder but the encoder does not provide comparable quality (zeranoe+)
#   --enable-libvpx*               ++ VP8/9 encoding -ffmpeg has own decoder (ffvp8/ffvp9) that apparently is faster (zeranoe+)
#   --enable-libwavpack            -- Wavpack encoding
#   --enable-libwebp            -- WebP image encoding (zeranoe+)
#   --enable-libx264*              ++ Required for x264 encode (zeranoe+)
#   --enable-libx265*              ++ Required for x265 encode (zeranoe+)
#   --enable-libxavs               -- AVS encoding, ffmpeg has built in decoder (zeranoe+)
#   --enable-libxcb                 -- X11 grabbing using xcb
#   --enable-libxvid*              ++ Xvid encode (zeranoe+)
#   --enable-libzimg            ?? enable z.lib, needed for zscale filter (zeranoe+)
#   --enable-libzmq                -- libzmq message passing
#   --enable-libzvbi            ++?? DVB teletext support
#   --disable-lzma*                ++ disable lzma. Enabled by default (zeranoe+)
#   --enable-decklink            -- Blackmagick decklink IO support
#   --enable-mmal                -- Broadcom HW decoding, found on rasberry pi and similar
#   --enable-netcdf             --?? needed for sofalizer filter
#   --enable-nvenc*                ++ NVIDIA HW encoder
#   --enable-openal                -- OpenAL capture support
#   --enable-opencl*            ++ OpenCL code
#   --enable-opengl*            ++ OpenGL code rendering
#   --enable-openssl            -- openssl for SSL, TLS and DTLS (instead of GnuTLS)
#   --disable-schannel            -- Used for TLS if no gnutls or openssl
#   --disable-sdl*                ++ Required for sdl device and ffplay
#   --disable-securetransport    -- OSX TLS support when gnutls/openssl is not available
#   --enable-x11grab            -- X11 grabbing
#   --disable-xlib                -- Used to interact directly with X11 server
#   --disable-zlib*                -- Required for LCL decode. Enabled by default (zeranoe+)