configure

#!/bin/bash

#-----------------------------------------------------------------------------------------
#    VCEEnc by rigaya
#  -----------------------------------------------------------------------------------------
#   &#12477;&#12540;&#12473;&#12467;&#12540;&#12489;&#12395;&#12388;&#12356;&#12390;
#   &#12539;&#28961;&#20445;&#35388;&#12391;&#12377;&#12290;
#   &#12539;&#26412;&#12477;&#12540;&#12473;&#12467;&#12540;&#12489;&#12434;&#20351;&#29992;&#12375;&#12383;&#12371;&#12392;&#12395;&#12424;&#12427;&#12356;&#12363;&#12394;&#12427;&#25613;&#23475;&#12539;&#12488;&#12521;&#12502;&#12523;&#12395;&#12388;&#12356;&#12390;rigaya&#12399;&#36012;&#20219;&#12434;&#36000;&#12356;&#12414;&#12379;&#12435;&#12290;
#   &#20197;&#19978;&#12395;&#20102;&#35299;&#12375;&#12390;&#38914;&#12369;&#12427;&#22580;&#21512;&#12289;&#26412;&#12477;&#12540;&#12473;&#12467;&#12540;&#12489;&#12398;&#20351;&#29992;&#12289;&#35079;&#35069;&#12289;&#25913;&#22793;&#12289;&#20877;&#38930;&#24067;&#12434;&#34892;&#12387;&#12390;&#38914;&#12356;&#12390;&#27083;&#12356;&#12414;&#12379;&#12435;&#12290;
#  -----------------------------------------------------------------------------------------

CNF_LOG=config.log

cnf_write()
{
    echo "$*"
    echo "$*" >> ${CNF_LOG}
}
cnf_print()
{
    printf "$*"
    echo "$*" >> ${CNF_LOG}
}

write_config_mak()
{
    echo $1
    echo $1 >> config.mak
}

write_enc_config()
{
    echo $1
    echo $1 >> VCECore/rgy_config.h
}

write_app_rev()
{
    echo $1
    echo $1 >> VCECore/rgy_rev.h
}

cxx_check()
{
    echo "" >> ${CNF_LOG}
    if [ -n "$1" ]; then
        printf "checking for $1..."
        echo "### - checking for $1... --------------" >> ${CNF_LOG}
    else 
        echo "### - test start --------------" >> ${CNF_LOG}
    fi
    echo "#include <iostream>" > cxx_check.c
    if [ -n "$3" ]; then
        echo "#include <$3>" >> cxx_check.c
    fi 
    if [ -n "$4" ]; then
        echo "extern \"C\" {" >> cxx_check.c
        echo "#include <$4>" >> cxx_check.c
        echo "}" >> cxx_check.c
    fi 
    echo "int main(void){ $5; std::cout << \"Hello World!\" << std::endl; return 0;}" >> cxx_check.c
    CXX_CMD="$CXX -w cxx_check.c $2 -o cxx_check"
    echo "------ command ------------" >> ${CNF_LOG}
    echo ${CXX_CMD} >> ${CNF_LOG}
    echo "------ test ---------------" >> ${CNF_LOG}
    cat cxx_check.c >> ${CNF_LOG}
    echo "---------------------------" >> ${CNF_LOG}
    $CXX_CMD 2>> ${CNF_LOG}
    #$CXX cxx_check.c $1 -o cxx_check
    ret=$?
    rm -f cxx_check*
    echo "### - test fin -> ${ret} ----------" >> ${CNF_LOG}
    return $ret
}

regex_check()
{
    echo "#include <iostream>" > cxx_check.c
    echo "#include <string>" >> cxx_check.c
    echo "#include <regex>" >> cxx_check.c
    echo "int main(void){ try { std::regex re(R\"(\d+)\"); std::string test(\"1234\"); return std::regex_match(test, re) ? 0 : 1; } catch (...) { return 1; } }" >> cxx_check.c
    $CXX cxx_check.c $1 -o cxx_check 2>/dev/null
    ret=$?
    if [ $ret -ne 0 ]; then
        rm -f cxx_check*
        return $ret
    fi
    ./cxx_check 2>/dev/null
    ret=$?
    rm -f cxx_check*
    return $ret
}

rm -f config.* .depend VCECore/rgy_config.h VCECore/rgy_rev.h

PKGCONFIG="pkg-config"
USE_PKGCONFIG=1

ENABLE_DEBUG=0
CC=${CC:-gcc}
CXX=${CXX:-g++}
LD=${LD:-g++}
PROGRAM=vceencc
PREFIX=${PREFIX:-/usr/local}
EXTRACXXFLAGS=""
EXTRALDFLAGS=""
SRCS=""
X86_64=1
NO_RDTSCP_INTRIN=0
CARGO=${CARGO:-cargo}
ENABLE_LTO=0

ENABLE_CPP_REGEX=1

LIBVA_SUPPORT=1
LIBVA_X11_SUPPORT=1
LIBVA_DRM_SUPPORT=1

OPENCL_HEADERS=""

VULKAN_HEADERS=""

CHECK_LIBAV_NAMES="libswresample libavutil libavcodec libavformat libavfilter libavdevice"
LIBAV_CFLAGS=""
LIBAV_LIBS=""
ENABLE_AVSW_READER=1
AV_CHANNEL_LAYOUT_STRUCT_AVAIL=1
AV_FRAME_DURATION_AVAIL=1
AVCODEC_PAR_CODED_SIDE_DATA_AVAIL=1

CHECK_VAPOURSYNTH_NAMES="vapoursynth vapoursynth-script"
ENABLE_VAPOURSYNTH=1
VAPOURSYNTH_LIBS=""
VAPOURSYNTH_CFLAGS=""

CHECK_AVISYNTH_NAMES="avisynth"
ENABLE_AVISYNTH=1
AVISYNTH_CFLAGS=""

CHECK_LIBASS_NAMES="libass"
LIBASS_CFLAGS=""
LIBASS_LIBS=""
ENABLE_LIBASS=1

CHECK_LIBPLACEBO_NAMES="libplacebo"
LIBPLACEBO_CFLAGS=""
LIBPLACEBO_LIBS=""
ENABLE_LIBPLACEBO=0
LIBPLACEBO_API_VER=338

CHECK_VULKAN_NAMES="vulkan"
VULKAN_CFLAGS=""
ENABLE_VULKAN=1

LIBDOVI_CFLAGS=""
LIBDOVI_LIBS=""
ENABLE_LIBDOVI=1

LIBHDR10PLUS_CFLAGS=""
LIBHDR10PLUS_LIBS=""
ENABLE_LIBHDR10PLUS=1

DTL_CFLAGS="-I./dtl"
ENABLE_DTL=1

CLRNG_CXXFLAGS="-I./clRNG/src/include"

CPPCODEC_CFLAGS="-I./cppcodec"

print_help()
{
cat << EOF
Usage: ./configure [options]

options:
  -h, --help               print this message

  --prefix=PREFIX          install vceencc into PREFIX/bin [${PREFIX}]

  --cxx=CC                 set C compiler path [${CC}]
  --cxx=CXX                set C++ compiler path [${CXX}]
  --pkg-config=PKGCONFIG   set pkg-config path [${PKGCONFIG}]
  --enable-debug           compile in debug configuration [${ENABLE_DEBUG}]
  --enable-lto             compile with lto [${ENABLE_LTO}]

  --opencl-headers         set opencl headers path [${OPENCL_HEADERS}]
  --vulkan-headers         set vulkan headers path [${VULKAN_HEADERS}]

  --extra-cxxflags=XCFLAGS add XCFLAGS to CXXFLAGS
  --extra-ldflags=XLDFLAGS add XLDFLAGS to LDFLAGS

  --disable-vapoursynth    disable vapoursynth support [auto]
  --disable-avisynth       disable avisynth support [auto]
  --disable-libass         disable libass support [auto]
  --disable-dtl            disable dtl support [auto]
EOF
}

SRCDIR=$(dirname "$0")
if [ "${SRCDIR}" == "`pwd`" ]; then
    SRCDIR=.
fi

for opt; do
    optarg="${opt#*=}"
    case "$opt" in
         -h)
            print_help
            exit 0
            ;;
         --help)
            print_help
            exit 0
            ;;
        --prefix=*)
            PREFIX="$optarg"
            ;;
        --cc=*)
            CC="$optarg"
            ;;
        --cxx=*)
            CXX="$optarg"
            LD="$optarg"
            ;;
        --extra-cxxflags=*)
            EXTRACXXFLAGS="$optarg"
            ;;
        --extra-ldflags=*)
            EXTRALDFLAGS="$optarg"
            ;;
        --enable-debug)
            ENABLE_DEBUG=1
            ;;
        --enable-lto)
            ENABLE_LTO=1
            ;;
        --opencl-headers=*)
            OPENCL_HEADERS="$optarg"
            ;;
        --disable-vapoursynth)
            ENABLE_VAPOURSYNTH=0
            ;;
        --disable-avisynth)
            ENABLE_AVISYNTH=0
            ;;
        --disable-libass)
            ENABLE_LIBASS=0
            ;;
        --disable-dtl)
            ENABLE_DTL=0
            ;;
        --pkg-config=*)
            PKGCONFIG="$optarg"
            ;;
        *)
            echo "unknown option $opt"
            exit 1
            ;;
    esac
done

## log
echo "" > ${CNF_LOG}
echo "CNF_LOG=${CNF_LOG}" >> ${CNF_LOG}
echo "PKGCONFIG=${PKGCONFIG}" >> ${CNF_LOG}
echo "USE_PKGCONFIG=${USE_PKGCONFIG}" >> ${CNF_LOG}
echo "ENABLE_DEBUG=${ENABLE_DEBUG}" >> ${CNF_LOG}
echo "CC=${CC}" >> ${CNF_LOG}
echo "CXX=${CXX}" >> ${CNF_LOG}
echo "PROGRAM=${PROGRAM}" >> ${CNF_LOG}
echo "PREFIX=${PREFIX}" >> ${CNF_LOG}
echo "EXTRACXXFLAGS=${EXTRACXXFLAGS}" >> ${CNF_LOG}
echo "EXTRALDFLAGS=${EXTRALDFLAGS}" >> ${CNF_LOG}
echo "OPENCL_HEADERS=${OPENCL_HEADERS}" >> ${CNF_LOG}
echo "X86_64=${X86_64}" >> ${CNF_LOG}
echo "ENABLE_CPP_REGEX=${ENABLE_CPP_REGEX}" >> ${CNF_LOG}
echo "CHECK_LIBAV_NAMES=${CHECK_LIBAV_NAMES}" >> ${CNF_LOG}
echo "ENABLE_AVSW_READER=${ENABLE_AVSW_READER}" >> ${CNF_LOG}
echo "ENABLE_VAPOURSYNTH=${ENABLE_VAPOURSYNTH}" >> ${CNF_LOG}
echo "ENABLE_AVISYNTH=${ENABLE_AVISYNTH}" >> ${CNF_LOG}
echo "ENABLE_LIBASS=${ENABLE_LIBASS}" >> ${CNF_LOG}
echo "ENABLE_DTL=${ENABLE_DTL}" >> ${CNF_LOG}

for file in "${CXX}" "${LD}"; do
    if [ ! `type -p $file 2> /dev/null` ]; then
        cnf_write $file not found
        exit 1
    fi
done

cnf_print "checking for ${CXX}..."
if ! cxx_check "" ; then
    cnf_write "${CXX} does not work"
    exit 1
fi
cnf_write "OK"

if [ `echo | ${CXX} -E -dM - | egrep "WIN32|WIN64" | wc --lines` -ne 0 ]; then
    cnf_write "This script does not support Windows platform."
    cnf_write "For Windows, use Visual Studio."
    exit 1 
fi

if [ `echo | ${CXX} -E -dM - | grep "x86_64" | wc --lines` -eq 0 ]; then
    X86_64=0
fi

CFLAGS="-Wall -Wno-missing-braces -Wno-unknown-pragmas -Wno-unused \
-DLINUX -DUNIX -D_FILE_OFFSET_BITS=64 -D__USE_LARGEFILE64 -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS"
CXXFLAGS="-Wall -Wno-missing-braces -Wno-unknown-pragmas -Wno-unused \
-DLINUX -DUNIX -D_FILE_OFFSET_BITS=64 -D__USE_LARGEFILE64 -D__STDC_FORMAT_MACROS -D__STDC_CONSTANT_MACROS \
-I${SRCDIR} -I${SRCDIR}/AMF/amf/public/include -I${SRCDIR}/AMF/amf/public/include/core -I${SRCDIR}/AMF/amf/public/include/components \
-I${SRCDIR}/VCECore -I${SRCDIR}/tinyxml2 -I${SRCDIR}/ttmath \
"

if cxx_check "-Wno-unknown-warning-option" "${CXXFLAGS} -Wno-unknown-warning-option ${LDFLAGS}" ; then
    CFLAGS="${CFLAGS} -Wno-unknown-warning-option"
    CXXFLAGS="${CXXFLAGS} -Wno-unknown-warning-option"
    cnf_write "OK"
else
    cnf_write "Skip"
fi

LDFLAGS="-L. -ldl -lm -lstdc++ -lstdc++fs"
if [ $X86_64 -ne 0 ]; then
    CFLAGS="${CFLAGS} -DLINUX64 -m64"
    CXXFLAGS="${CXXFLAGS} -DLINUX64 -m64"
    LDFLAGS="${LDFLAGS} -m64"
else
    CFLAGS="${CFLAGS} -DLINUX32 -m32"
    CXXFLAGS="${CXXFLAGS} -DLINUX32 -m32"
    LDFLAGS="${LDFLAGS} -m32"
fi

if cxx_check "pthread" "${CXXFLAGS} -pthread ${LDFLAGS} -lpthread" ; then
    CXXFLAGS="$CXXFLAGS -pthread"
    LDFLAGS="${LDFLAGS} -lpthread"
else
    cnf_write "pthread not installed." 
    exit 1
fi
cnf_write "OK"

if cxx_check "c++17" "${CXXFLAGS} -std=c++17 ${LDFLAGS}" ; then
    CXXFLAGS="$CXXFLAGS -std=c++17"
else
    cnf_write "${CXX} does not work with -std=c++17"
    exit 1
fi
cnf_write "OK"

if cxx_check "-msse4.1" "${CXXFLAGS} -msse4.1 ${LDFLAGS}" ; then
    CXXFLAGS="$CXXFLAGS -msse4.1"
else
    cnf_write "SSE4.1 not supported with this compiler." 
    exit 1
fi
cnf_write "OK"

if ! cxx_check "__rdtscp()" "${CXXFLAGS} ${LDFLAGS}" "" "x86intrin.h" "unsigned int a = 0; auto i = __rdtscp(&a);" ; then
    CXXFLAGS="${CXXFLAGS} -DNO_RDTSCP_INTRIN=1"
    cnf_write "no"
else
    cnf_write "yes"
fi

if [ ! $ENABLE_DEBUG -eq 0 ]; then
    cnf_write "configuring for debug..."
    CXXFLAGS="${CXXFLAGS} -O0 -g -D_DEBUG"
    CFLAGS="${CFLAGS} -O0 -g -D_DEBUG"
else
    cnf_write "configuring for speed..."
    CXXFLAGS="${CXXFLAGS} -O3 -DNDEBUG=1"
    CFLAGS="${CFLAGS} -O3 -DNDEBUG=1"
    if cxx_check "-mfpmath=sse" "${CXXFLAGS} -mfpmath=sse ${LDFLAGS}" ; then
        CXXFLAGS="$CXXFLAGS -mfpmath=sse"
        cnf_write "yes"
    fi
    if cxx_check "-fPIE" "${CXXFLAGS} -fPIE ${LDFLAGS}" ; then
        CXXFLAGS="$CXXFLAGS -fPIE"
        CFLAGS="$CFLAGS -fPIE"
        cnf_write "yes"
    fi
    if ${CXX} -dM -E -x c /dev/null | grep "__clang__" > /dev/null; then
        IS_CLANG=1
    else
        IS_CLANG=0
    fi
    if [ $IS_CLANG -eq 0 ]; then
        if cxx_check "-ffast-math" "${CXXFLAGS} -ffast-math ${LDFLAGS}" ; then
            CXXFLAGS="$CXXFLAGS -ffast-math"
            cnf_write "yes"
        fi
    fi
    if cxx_check "-fomit-frame-pointer" "${CXXFLAGS} -fomit-frame-pointer ${LDFLAGS}" ; then
        CXXFLAGS="$CXXFLAGS -fomit-frame-pointer"
        cnf_write "yes"
    fi
    LDFLAGS="$LDFLAGS -Wl,-s"

	if [ $ENABLE_LTO -ne 0 ]; then
		CXXFLAGS="$CXXFLAGS -flto"
		LDFLAGS="$LDFLAGS -flto"
	fi
fi

cnf_print "checking for pkg-config..."
export PKG_CONFIG_PATH=$PKG_CONFIG_PATH:$PREFIX/lib/pkgconfig
type -p $PKGCONFIG 2>/dev/null 1>/dev/null
if [ $? -ne 0 ]; then
    cnf_write "${PKGCONFIG} does not exist."
    USE_PKGCONFIG=0
fi
cnf_write "OK"

if [ -n "$EXTRACXXFLAGS" ]; then
    printf "checking --extra-cflags..."
    if ! cxx_check "${CXXFLAGS} ${EXTRACXXFLAGS} ${LDFLAGS}" ; then
        cnf_write "--extra-cflags=${EXTRACXXFLAGS} does not work"
        exit 1
    fi
    cnf_write "OK"
fi

if [ -n "$EXTRALDFLAGS" ]; then
    if ! cxx_check "--extra-ldflags" "${CXXFLAGS} ${EXTRACXXFLAGS} ${LDFLAGS} ${EXTRALDFLAGS}" ; then
        cnf_write "--extra-ldflags=${EXTRALDFLAGS} does not work"
        exit 1
    fi
    cnf_write "OK"
fi

OPENCL_CXXFLAGS=
if [ "${OPENCL_HEADERS}" != "" ]; then
    OPENCL_CXXFLAGS=-I${OPENCL_HEADERS}
fi
if cxx_check "opencl-headers" "${CXXFLAGS} ${OPENCL_CXXFLAGS}" "" "CL/opencl.h" "cl_int test = 0;" ; then
    CXXFLAGS="${CXXFLAGS} ${OPENCL_CXXFLAGS}"
    cnf_write "yes"
else
    cnf_write "OpenCL headers not installed." 
    exit 1
fi

if cxx_check "clRNG-headers" "${CXXFLAGS} ${CLRNG_CXXFLAGS}" "" "clRNG/clRNG.h" "clrngStatus sts = (clrngStatus)0;" ; then
    CXXFLAGS="${CXXFLAGS} ${CLRNG_CXXFLAGS}"
    CFLAGS="${CFLAGS} ${CLRNG_CXXFLAGS}"
    cnf_write "yes"
else
    cnf_write "clRNG headers missing." 
    exit 1
fi

if [ $ENABLE_AVSW_READER -ne 0 ]; then
    if [ $USE_PKGCONFIG -ne 0 ]; then
        printf "checking libavcodec with pkg-config..."
        if ! ${PKGCONFIG} --exists $CHECK_LIBAV_NAMES ; then
            cnf_write "libs could not be detected by ${PKGCONFIG}. [ PKG_CONFIG_PATH=${PKG_CONFIG_PATH} ]"
        else
            cnf_write "OK"
            LIBAV_LIBS=`${PKGCONFIG} --libs ${CHECK_LIBAV_NAMES}`
            LIBAV_CFLAGS=`${PKGCONFIG} --cflags ${CHECK_LIBAV_NAMES}`
        fi
    fi
    
    if [ -z "$LIBAV_LIBS" ]; then
        LIBAV_LIBS=""
        for lib in $CHECK_LIB_NAMES; do
            LIBAV_LIBS="${LIBAV_LIBS} -l${lib#lib}"
        done
        cnf_write "lib settings might be inaqurate."
    fi

    if ! cxx_check "libavutil" "${CXXFLAGS} ${EXTRACXXFLAGS} ${LIBAV_CFLAGS} ${LDFLAGS} ${EXTRALDFLAGS} ${LIBAV_LIBS}" "" "libavutil/avutil.h" "avutil_version();" ; then
        cnf_write "no"
        ENABLE_AVSW_READER=0
    else
        cnf_write "yes"
    fi
    
    if ! cxx_check "libavcodec" "${CXXFLAGS} ${EXTRACXXFLAGS} ${LIBAV_CFLAGS} ${LDFLAGS} ${EXTRALDFLAGS} ${LIBAV_LIBS}" "" "libavcodec/avcodec.h" "avcodec_find_decoder((AVCodecID)0);" ; then
        cnf_write "no"
        ENABLE_AVSW_READER=0
    else
        cnf_write "yes"
    fi
    
    if ! cxx_check "libavformat" "${CXXFLAGS} ${EXTRACXXFLAGS} ${LIBAV_CFLAGS} ${LDFLAGS} ${EXTRALDFLAGS} ${LIBAV_LIBS}" "" "libavformat/avformat.h" "avformat_find_stream_info(0,0);" ; then
        cnf_write "no"
        ENABLE_AVSW_READER=0
    else
        cnf_write "yes"
    fi
    
    if ! cxx_check "libavfilter" "${CXXFLAGS} ${EXTRACXXFLAGS} ${LIBAV_CFLAGS} ${LDFLAGS} ${EXTRALDFLAGS} ${LIBAV_LIBS}" "" "libavfilter/avfilter.h" "avfilter_version();" ; then
        cnf_write "no"
        ENABLE_AVSW_READER=0
    else
        cnf_write "yes"
    fi
    
    if ! cxx_check "libswresample" "${CXXFLAGS} ${EXTRACXXFLAGS} ${LIBAV_CFLAGS} ${LDFLAGS} ${EXTRALDFLAGS} ${LIBAV_LIBS}" "" "libswresample/swresample.h" "swr_alloc();" ; then
        cnf_write "no"
        ENABLE_AVSW_READER=0
    else
        cnf_write "yes"
    fi
    
    if ! cxx_check "AVChannelLayout" "${CXXFLAGS} ${EXTRACXXFLAGS} ${LIBAV_CFLAGS} ${LDFLAGS} ${EXTRALDFLAGS} ${LIBAV_LIBS}" "" "libavutil/channel_layout.h" "AVChannelLayout ch_layout;" ; then
        cnf_write "no"
        AV_CHANNEL_LAYOUT_STRUCT_AVAIL=0
    else
        cnf_write "yes"
    fi
    
    if ! cxx_check "AVFrame::duration" "${CXXFLAGS} ${EXTRACXXFLAGS} ${LIBAV_CFLAGS} ${LDFLAGS} ${EXTRALDFLAGS} ${LIBAV_LIBS}" "" "libavutil/frame.h" "AVFrame *frame; frame->duration = 0;" ; then
        cnf_write "no"
        AV_FRAME_DURATION_AVAIL=0
    else
        cnf_write "yes"
    fi
    
    if ! cxx_check "AVCodecParameters::coded_side_data" "${CXXFLAGS} ${EXTRACXXFLAGS} ${LIBAV_CFLAGS} ${LDFLAGS} ${EXTRALDFLAGS} ${LIBAV_LIBS}" "" "libavcodec/codec_par.h" "AVCodecParameters *codecpar; codecpar->coded_side_data = 0;" ; then
        cnf_write "no"
        AVCODEC_PAR_CODED_SIDE_DATA_AVAIL=0
    else
        cnf_write "yes"
    fi
    if [ $ENABLE_AVSW_READER -eq 0 ]; then
        cnf_write "libavutil, libavcodec, libavformat, libavfilter, libswresample are required to build vceencc."
        exit 1
    fi
fi

cnf_print "Checking for dovi..."
if ! ${PKGCONFIG} --exists dovi ; then
    cnf_write "couldn't find system wide libdovi, trying included one."
    cnf_print "checking for $CARGO..."
    type -p $CARGO 2>/dev/null 1>/dev/null
    if [ $? -ne 0 ]; then
        cnf_write "${CARGO} does not exist."
        ENABLE_LIBDOVI=0
    else
        cnf_write "OK"
    fi
    if [ $ENABLE_LIBDOVI -ne 0 ]; then
        CARGO=${CARGO} ./build_libdovi.sh
        LIBDOVI_PC=$(find `pwd`/build_libdovi -name 'dovi.pc')
        cnf_print "checking libdovi with pkg-config..."
        if ! ${PKGCONFIG} --exists ${LIBDOVI_PC} ; then
            cnf_write "libs could not be detected by ${PKGCONFIG}. [ PKG_CONFIG_PATH=${PKG_CONFIG_PATH} ]"
        else
            cnf_write "OK"
            LIBDOVI_LIBS=`${PKGCONFIG} --libs --static ${LIBDOVI_PC}`
            LIBDOVI_CFLAGS=`${PKGCONFIG} --cflags ${LIBDOVI_PC}`
        fi
        if ! cxx_check "rpu_parser.h" "${CXXFLAGS} ${EXTRACXXFLAGS} ${LIBDOVI_CFLAGS} ${LDFLAGS} ${EXTRALDFLAGS} ${LIBDOVI_LIBS}" "libdovi/rpu_parser.h" "" "dovi_parse_rpu(nullptr, 0);" ; then
            cnf_write "no"
            ENABLE_LIBDOVI=0
            LIBDOVI_LIBS=""
            LIBDOVI_CFLAGS=""
        else
            cnf_write "yes"
        fi
    fi
else
    cnf_write "OK"
    LIBDOVI_LIBS=`${PKGCONFIG} --libs --static dovi`
    LIBDOVI_CFLAGS=`${PKGCONFIG} --cflags dovi`
fi

cnf_print "Checking for hdr10plus..."
if ! ${PKGCONFIG} --exists hdr10plus ; then
    cnf_write "couldn't find system wide libhdr10plus, trying included one."
    cnf_print "checking for $CARGO..."
    type -p $CARGO 2>/dev/null 1>/dev/null
    if [ $? -ne 0 ]; then
        cnf_write "${CARGO} does not exist."
        ENABLE_LIBHDR10PLUS=0
    else
        cnf_write "OK"
    fi
    if [ $ENABLE_LIBHDR10PLUS -ne 0 ]; then
        CARGO=${CARGO} ./build_libhdr10plus.sh
        LIBHDR10PLUS_PC=$(find `pwd`/build_libhdr10plus -name 'hdr10plus-rs.pc')
        cnf_print "checking libhdr10plus with pkg-config..."
        if ! ${PKGCONFIG} --exists ${LIBHDR10PLUS_PC} ; then
            cnf_write "libs could not be detected by ${PKGCONFIG}. [ PKG_CONFIG_PATH=${PKG_CONFIG_PATH} ]"
	    ENABLE_LIBHDR10PLUS=0
        else
            cnf_write "OK"
            LIBHDR10PLUS_LIBS=`${PKGCONFIG} --libs --static ${LIBHDR10PLUS_PC}`
            LIBHDR10PLUS_CFLAGS=`${PKGCONFIG} --cflags ${LIBHDR10PLUS_PC}`
        fi
    fi
else
    cnf_write "OK"
    LIBHDR10PLUS_LIBS=`${PKGCONFIG} --libs --static hdr10plus-rs`
    LIBHDR10PLUS_CFLAGS=`${PKGCONFIG} --cflags hdr10plus-rs`
fi
if [ $ENABLE_LIBHDR10PLUS -ne 0 ]; then
    if ! cxx_check "hdr10plus.h" "${CXXFLAGS} ${EXTRACXXFLAGS} ${LIBHDR10PLUS_CFLAGS} ${LDFLAGS} ${EXTRALDFLAGS} ${LIBHDR10PLUS_LIBS}" "libhdr10plus-rs/hdr10plus.h" "" "hdr10plus_rs_parse_json(nullptr);" ; then
        cnf_write "no"
            ENABLE_LIBHDR10PLUS=0
            LIBHDR10PLUS_LIBS=""
            LIBHDR10PLUS_CFLAGS=""
    else
        cnf_write "yes"
    fi
fi

if [ $ENABLE_VULKAN -ne 0 ]; then
    cnf_print "checking vulkan with pkg-config..."
    if ! ${PKGCONFIG} --exists ${CHECK_VULKAN_NAMES} ; then
        cnf_write "libs could not be detected by ${PKGCONFIG}. [ PKG_CONFIG_PATH=${PKG_CONFIG_PATH} ]"
    else
        cnf_write "OK"
        VULKAN_CFLAGS=`${PKGCONFIG} --cflags ${CHECK_VULKAN_NAMES}`
    fi
    if ! cxx_check "vulkan/vulkan.h" "${CXXFLAGS} ${EXTRACXXFLAGS} ${LIBAV_CFLAGS} ${VULKAN_CFLAGS} ${LDFLAGS} ${EXTRALDFLAGS} ${LIBAV_LIBS}" "" "vulkan/vulkan.h" "std::cout << VK_HEADER_VERSION << std::endl;" ; then
        cnf_write "no"
        cnf_write "vulkan headers not installed." 
        exit 1
    else
        cnf_write "yes"
    fi
fi
if [ $ENABLE_VULKAN -eq 0 ]; then
    ENABLE_LIBPLACEBO=0
fi

if [ $ENABLE_LIBPLACEBO -ne 0 ]; then
    cnf_print "checking libplacebo with pkg-config..."
    if ! ${PKGCONFIG} --exists ${CHECK_LIBPLACEBO_NAMES} ; then
        cnf_write "libs could not be detected by ${PKGCONFIG}. [ PKG_CONFIG_PATH=${PKG_CONFIG_PATH} ]"
    else
        cnf_write "OK"
        #LIBPLACEBO_LIBS=`${PKGCONFIG} --libs ${CHECK_LIBPLACEBO_NAMES}`
        LIBPLACEBO_CFLAGS=`${PKGCONFIG} --cflags ${CHECK_LIBPLACEBO_NAMES}`
    fi
    if ! cxx_check "libplacebo/config.h" "${CXXFLAGS} ${EXTRACXXFLAGS} ${LIBAV_CFLAGS} ${LIBPLACEBO_CFLAGS} ${LDFLAGS} ${EXTRALDFLAGS} ${LIBAV_LIBS} ${LIBPLACEBO_LIBS}" "" "libplacebo/config.h" "std::cout << PL_API_VER << std::endl;" ; then
        cnf_write "no"
        ENABLE_LIBPLACEBO=0
    else
        cnf_write "yes"
    fi
    cnf_print "checking for libplacebo API version..."
    PL_API_VER=`echo "#include <iostream>" > cxx_check.c; echo "#include <libplacebo/config.h>" >> cxx_check.c; echo "int main(void){ std::cout << PL_API_VER << std::endl; return 0;}" >> cxx_check.c; $CXX cxx_check.c ${CXXFLAGS} ${EXTRACXXFLAGS} ${LIBAV_CFLAGS} ${LIBPLACEBO_CFLAGS} ${LDFLAGS} ${EXTRALDFLAGS} ${LIBAV_LIBS} ${LIBPLACEBO_LIBS} -o cxx_check 2>/dev/null; ./cxx_check 2>/dev/null; rm -f cxx_check*`
    if [ -z "$PL_API_VER" ]; then
        cnf_write "fail"
        ENABLE_LIBPLACEBO=0
    else
        if [ $PL_API_VER -lt $LIBPLACEBO_API_VER ]; then
            cnf_write "fail (${PL_API_VER})"
            cnf_write "libplacebo API version >= ${LIBPLACEBO_API_VER} required."
            ENABLE_LIBPLACEBO=0
        else
            cnf_write "OK (${PL_API_VER})"
        fi
    fi
    if [ $ENABLE_LIBPLACEBO -eq 0 ]; then
        LIBPLACEBO_CFLAGS=""
        LIBPLACEBO_LIBS=""
    fi
fi

if [ $ENABLE_VAPOURSYNTH -ne 0 ]; then
    printf "checking vapoursynth with pkg-config..."
    if ! ${PKGCONFIG} --exists ${CHECK_VAPOURSYNTH_NAMES} ; then
        cnf_write "libs could not be detected by ${PKGCONFIG}. [ PKG_CONFIG_PATH=${PKG_CONFIG_PATH} ]"
    else
        cnf_write "OK"
        VAPOURSYNTH_LIBS=`${PKGCONFIG} --libs ${CHECK_VAPOURSYNTH_NAMES}`
        VAPOURSYNTH_CFLAGS=`${PKGCONFIG} --cflags ${CHECK_VAPOURSYNTH_NAMES}`
    fi
    if ! cxx_check "VapourSynth.h" "${CXXFLAGS} ${EXTRACXXFLAGS} ${LIBAV_CFLAGS} ${VAPOURSYNTH_CFLAGS} ${LDFLAGS} ${EXTRALDFLAGS} ${LIBAV_LIBS} ${VAPOURSYNTH_LIBS}" "VapourSynth.h" "" "" ; then
        cnf_write "no"
        ENABLE_VAPOURSYNTH=0
    else
        cnf_write "yes"
    fi
    if ! cxx_check "VSScript.h" "${CXXFLAGS} ${EXTRACXXFLAGS} ${LIBAV_CFLAGS} ${VAPOURSYNTH_CFLAGS} ${LDFLAGS} ${EXTRALDFLAGS} ${LIBAV_LIBS} ${VAPOURSYNTH_LIBS}" "VSScript.h" "" "" ; then
        cnf_write "no"
        ENABLE_VAPOURSYNTH=0
    else
        cnf_write "yes"
    fi
    if [ $ENABLE_VAPOURSYNTH -eq 0 ]; then
        VAPOURSYNTH_CFLAGS=""
        VAPOURSYNTH_LIBS=""
    fi
fi

if [ $ENABLE_AVISYNTH -ne 0 ]; then
    printf "checking avisynth with pkg-config..."
    if ! ${PKGCONFIG} --exists ${CHECK_AVISYNTH_NAMES} ; then
        cnf_write "libs could not be detected by ${PKGCONFIG}. [ PKG_CONFIG_PATH=${PKG_CONFIG_PATH} ]"
    else
        cnf_write "OK"
        AVISYNTH_LIBS=`${PKGCONFIG} --libs ${CHECK_AVISYNTH_NAMES}`
        AVISYNTH_CFLAGS=`${PKGCONFIG} --cflags ${CHECK_AVISYNTH_NAMES}`
    fi
    if ! cxx_check "avisynth_c.h" "${CXXFLAGS} ${EXTRACXXFLAGS} ${LIBAV_CFLAGS} ${AVISYNTH_CFLAGS} ${LDFLAGS} ${EXTRALDFLAGS} ${AVISYNTH_LIBS}" "avisynth_c.h" "" "" ; then
        cnf_write "no"
        ENABLE_AVISYNTH=0
    else
        cnf_write "yes"
    fi
    if [ $ENABLE_AVISYNTH -eq 0 ]; then
        AVISYNTH_CFLAGS=""
        AVISYNTH_LIBS=""
    fi
fi

if [ $ENABLE_LIBASS -ne 0 ]; then
    printf "checking libass with pkg-config..."
    if ! ${PKGCONFIG} --exists ${CHECK_LIBASS_NAMES} ; then
        cnf_write "libs could not be detected by ${PKGCONFIG}. [ PKG_CONFIG_PATH=${PKG_CONFIG_PATH} ]"
    else
        cnf_write "OK"
        LIBASS_LIBS=`${PKGCONFIG} --libs ${CHECK_LIBASS_NAMES}`
        LIBASS_CFLAGS=`${PKGCONFIG} --cflags ${CHECK_LIBASS_NAMES}`
    fi
    if ! cxx_check "ass/ass.h" "${CXXFLAGS} ${EXTRACXXFLAGS} ${LDFLAGS} ${EXTRALDFLAGS}" "" "ass/ass.h" "" ; then
        cnf_write "no"
        ENABLE_LIBASS=0
    else
        cnf_write "yes"
    fi
    if [ $ENABLE_LIBASS -eq 0 ]; then
        LIBASS_CFLAGS=""
        LIBASS_LIBS=""
    fi
fi

if [ $ENABLE_DTL -ne 0 ]; then
    if ! cxx_check "dtl/dtl.hpp" "${CXXFLAGS} ${EXTRACXXFLAGS} ${LDFLAGS} ${EXTRALDFLAGS}" "dtl/dtl/dtl.hpp" "" "" ; then
        if ! cxx_check "dtl/dtl.hpp" "${CXXFLAGS} ${EXTRACXXFLAGS} ${LDFLAGS} ${EXTRALDFLAGS}" "dtl/dtl.hpp" "" "" ; then
            cnf_write "no"
            ENABLE_DTL=0
        else
            cnf_write "yes"
        fi
    else
        DTL_CFLAGS="-I./dtl"
        cnf_write "yes"
    fi
fi

SRC_VCECORE=" \
convert_csp.cpp             convert_csp_avx.cpp \
convert_csp_avx2.cpp        convert_csp_sse2.cpp           convert_csp_sse41.cpp       convert_csp_ssse3.cpp \
cpu_info.cpp                gpu_info.cpp                   gpuz_info.cpp               logo.cpp \
rgy_aspect_ratio.cpp        rgy_avlog.cpp \
rgy_avutil.cpp              rgy_bitstream.cpp              rgy_bitstream_avx2.cpp      rgy_bitstream_avx512bw.cpp \
rgy_chapter.cpp \
rgy_cmd.cpp                 rgy_codepage.cpp               rgy_def.cpp \
rgy_device.cpp              rgy_device_info_cache.cpp      rgy_device_usage.cpp        rgy_device_vulkan.cpp \
rgy_env.cpp                 rgy_err.cpp                    rgy_event.cpp \
rgy_faw.cpp                 rgy_faw_avx2.cpp               rgy_faw_avx512bw.cpp \
rgy_filesystem.cpp \
rgy_filter.cpp              rgy_filter_afs.cpp             rgy_filter_afs_analyze.cpp  rgy_filter_afs_filter.cpp \
rgy_filter_afs_merge.cpp    rgy_filter_afs_synthesize.cpp  rgy_filter_cl.cpp \
rgy_filter_colorspace.cpp   rgy_filter_crop.cpp            rgy_filter_convolution3d.cpp  rgy_filter_curves.cpp \
rgy_filter_deband.cpp       rgy_filter_decimate.cpp        rgy_filter_decomb.cpp       rgy_filter_delogo.cpp \
rgy_filter_denoise_dct.cpp  rgy_filter_denoise_fft3d.cpp   rgy_filter_denoise_knn.cpp     rgy_filter_denoise_nlmeans.cpp \
rgy_filter_denoise_pmd.cpp  rgy_filter_edgelevel.cpp       rgy_filter_libplacebo.cpp      rgy_filter_mpdecimate.cpp   rgy_filter_nnedi.cpp \
rgy_filter_overlay.cpp      rgy_filter_pad.cpp             rgy_filter_resize.cpp       rgy_filter_rff.cpp \
rgy_filter_smooth.cpp \
rgy_filter_ssim.cpp         rgy_filter_subburn.cpp         rgy_filter_transform.cpp    rgy_filter_tweak.cpp \
rgy_filter_unsharp.cpp      rgy_filter_warpsharp.cpp       rgy_filter_yadif.cpp \
rgy_frame.cpp               rgy_frame_info.cpp             rgy_hdr10plus.cpp           rgy_ini.cpp \
rgy_input.cpp               rgy_input_avcodec.cpp          rgy_input_avi.cpp           rgy_input_avs.cpp \
rgy_input_raw.cpp           rgy_input_sm.cpp               rgy_input_vpy.cpp           rgy_language.cpp \
rgy_libdovi.cpp             rgy_libplacebo.cpp \
rgy_level_av1.cpp           rgy_level_h264.cpp             rgy_level_hevc.cpp \
rgy_memmem.cpp              rgy_memmem_avx2.cpp            rgy_memmem_avx512bw.cpp \
rgy_log.cpp                 rgy_opencl.cpp                 rgy_output.cpp              rgy_output_avcodec.cpp \
rgy_perf_counter.cpp        rgy_perf_monitor.cpp           rgy_pipe.cpp                rgy_pipe_linux.cpp \
rgy_prm.cpp                 rgy_resource.cpp               rgy_simd.cpp                rgy_status.cpp \
rgy_thread_affinity.cpp     rgy_timecode.cpp               rgy_util.cpp                rgy_version.cpp \
rgy_vulkan.cpp              rgy_wav_parser.cpp \
vce_amf.cpp                 vce_filter.cpp                 vce_cmd.cpp                 vce_core.cpp \
vce_device.cpp              vce_param.cpp                  vce_util.cpp \
"

SRC_VCECORE_CL=" \
rgy_filter.cl                 rgy_filter_afs_analyze.cl   rgy_filter_afs_filter.cl       rgy_filter_afs_merge.cl \
rgy_filter_afs_synthesize.cl  rgy_filter_convolution3d.cl rgy_filter_curves.cl \
rgy_filter_deband.cl          rgy_filter_deband_gen_rand.cl  rgy_filter_decimate.cl      rgy_filter_decomb.cl \
rgy_filter_delogo.cl \
rgy_filter_denoise_dct.cl     rgy_filter_denoise_fft3d.cl rgy_filter_denoise_knn.cl      rgy_filter_denoise_nlmeans.cl \
rgy_filter_denoise_pmd.cl     rgy_filter_edgelevel.cl \
rgy_filter_mpdecimate.cl      rgy_filter_nnedi_common.cl  rgy_filter_nnedi_k0.cl         rgy_filter_nnedi_k1.cl \
rgy_filter_overlay.cl         rgy_filter_pad.cl           rgy_filter_resize.cl           rgy_filter_smooth.cl \
rgy_filter_ssim.cl            rgy_filter_subburn.cl       rgy_filter_transform.cl        rgy_filter_tweak.cl \
rgy_filter_unsharp.cl         rgy_filter_warpsharp.cl     rgy_filter_yadif.cl \
"

SRC_VCECORE_H=" \
rgy_filter_colorspace_func.h \
"

SRC_CLRNG=" \
clRNG.c private.c \
"

SRC_CLRNG_CLH=" \
clRNG/src/include/clRNG/clRNG.clh \
clRNG/src/include/clRNG/mrg31k3p.clh \
"

SRC_CLRNG_H=" \
clRNG/src/include/clRNG/private/mrg31k3p.c.h \
"

SRC_TINYXML2="tinyxml2.cpp"

PYW_PERF_MONITOR="perf_monitor.pyw"

RESOURCE_NNEDI_WEIGHT="nnedi3_weights.bin"

SRC_VCEENCC="VCEEncC.cpp"

# for src in $SRC_MFX_DISPATCH; do
#     SRCS="$SRCS mfx_dispatch/src/$src"
# done

for src in $SRC_VCECORE; do
    SRCS="$SRCS VCECore/$src"
done

for src in $SRC_CLRNG; do
    SRCCS="$SRCCS clRNG/src/library/$src"
done

for cls in $SRC_VCECORE_CL; do
    RCLS="$RCLS VCECore/$cls"
done

for hs in $SRC_VCECORE_H; do
    RHS="$RHS VCECore/$hs"
done

for hs in $SRC_CLRNG_H; do
    RHS="$RHS $hs"
done

for cls in $SRC_CLRNG_CLH; do
    RCLHS="$RCLHS $cls"
done

for pyw in $PYW_PERF_MONITOR; do
    PYWS="$PYWS PerfMonitor/$pyw"
done

for rcs in $RESOURCE_NNEDI_WEIGHT; do
    RBINS="$RBINS resource/$rcs"
done

for src in $SRC_TINYXML2; do
    SRCS="$SRCS tinyxml2/$src"
done

for src in $SRC_VCEENCC; do
    SRCS="$SRCS VCEEncC/$src"
done

ENCODER_REV=`git rev-list HEAD | wc --lines`

cnf_write ""
cnf_write "Creating config.mak, rgy_config.h..."
echo "SRCS = $SRCS" >> config.mak
echo "SRCCS = $SRCCS" >> config.mak
echo "PYWS = $PYWS" >> config.mak
echo "RBINS = $RBINS" >> config.mak
echo "RHS = $RHS" >> config.mak
echo "RCLS = $RCLS" >> config.mak
echo "RCLHS = $RCLHS" >> config.mak
write_config_mak "SRCDIR = $SRCDIR"
write_config_mak "CC  = $CC"
write_config_mak "CXX = $CXX"
write_config_mak "LD  = $LD"
write_config_mak "PROGRAM = $PROGRAM"
write_config_mak "ENABLE_DEBUG = $ENABLE_DEBUG"
write_config_mak "CFLAGS = $CFLAGS"
write_config_mak "CXXFLAGS = $CXXFLAGS $EXTRACXXFLAGS $LIBAV_CFLAGS $VAPOURSYNTH_CFLAGS $AVISYNTH_CFLAGS $LIBASS_CFLAGS $DTL_CFLAGS $CPPCODEC_CFLAGS $VULKAN_CFLAGS $LIBPLACEBO_CFLAGS $LIBDOVI_CFLAGS $LIBHDR10PLUS_CFLAGS"
write_config_mak "LDFLAGS = $LDFLAGS $EXTRALDFLAGS $LIBAV_LIBS $LIBASS_LIBS $LIBDOVI_LIBS $LIBHDR10PLUS_LIBS"
write_config_mak "PREFIX = $PREFIX"
echo "X86_64 = ${X86_64}"
write_app_rev    "#define ENCODER_REV                  \"$ENCODER_REV\""
write_enc_config "#define ENABLE_RAW_READER             1"
write_enc_config "#define ENABLE_AVI_READER             0"
write_enc_config "#define ENABLE_AVISYNTH_READER        $ENABLE_AVISYNTH"
write_enc_config "#define ENABLE_VAPOURSYNTH_READER     $ENABLE_VAPOURSYNTH"
write_enc_config "#define ENABLE_AVSW_READER            $ENABLE_AVSW_READER" 
write_enc_config "#define ENABLE_SM_READER              0"
write_enc_config "#define ENABLE_CUSTOM_VPP             1"
write_enc_config "#define ENABLE_LIBASS_SUBBURN         $ENABLE_LIBASS"
write_enc_config "#define ENABLE_OPENCL                 1"
write_enc_config "#define ENABLE_AVCODEC_OUT_THREAD     1"
write_enc_config "#define AV_CHANNEL_LAYOUT_STRUCT_AVAIL $AV_CHANNEL_LAYOUT_STRUCT_AVAIL"
write_enc_config "#define AV_FRAME_DURATION_AVAIL        $AV_FRAME_DURATION_AVAIL"
write_enc_config "#define AVCODEC_PAR_CODED_SIDE_DATA_AVAIL $AVCODEC_PAR_CODED_SIDE_DATA_AVAIL"
write_enc_config "#define ENABLE_CPP_REGEX              $ENABLE_CPP_REGEX"
write_enc_config "#define ENABLE_DTL                    $ENABLE_DTL"
write_enc_config "#define ENABLE_LIBDOVI                $ENABLE_LIBDOVI"
write_enc_config "#define ENABLE_LIBHDR10PLUS           $ENABLE_LIBHDR10PLUS"
write_enc_config "#define ENABLE_VULKAN                 $ENABLE_VULKAN"
write_enc_config "#define ENABLE_LIBPLACEBO             $ENABLE_LIBPLACEBO"

cnf_write "successfully generated config.mak, rgy_config.h"