Changsheng Wu
0480cb05fa
This patch is a basic enablement that supports riscv64 compile. We are working on adding vector optimizations with riscv64 rvv extensions, and will push the implementations later.
1774 lines
56 KiB
Bash
Executable File
1774 lines
56 KiB
Bash
Executable File
#!/bin/bash
|
|
|
|
if test x"$1" = x"-h" -o x"$1" = x"--help" ; then
|
|
cat <<EOF
|
|
Usage: ./configure [options]
|
|
|
|
Help:
|
|
-h, --help print this message
|
|
|
|
Standard options:
|
|
--prefix=PREFIX install architecture-independent files in PREFIX
|
|
[/usr/local]
|
|
--exec-prefix=EPREFIX install architecture-dependent files in EPREFIX
|
|
[PREFIX]
|
|
--bindir=DIR install binaries in DIR [EPREFIX/bin]
|
|
--libdir=DIR install libs in DIR [EPREFIX/lib]
|
|
--includedir=DIR install includes in DIR [PREFIX/include]
|
|
--extra-asflags=EASFLAGS add EASFLAGS to ASFLAGS
|
|
--extra-cflags=ECFLAGS add ECFLAGS to CFLAGS
|
|
--extra-ldflags=ELDFLAGS add ELDFLAGS to LDFLAGS
|
|
--extra-rcflags=ERCFLAGS add ERCFLAGS to RCFLAGS
|
|
|
|
Configuration options:
|
|
--disable-cli disable cli
|
|
--system-libx264 use system libx264 instead of internal
|
|
--enable-shared build shared library
|
|
--enable-static build static library
|
|
--disable-bashcompletion disable installation of bash-completion script
|
|
--enable-bashcompletion force installation of bash-completion script
|
|
--bashcompletionsdir=DIR install bash-completion script in DIR [auto]
|
|
--disable-opencl disable OpenCL features
|
|
--disable-gpl disable GPL-only features
|
|
--disable-thread disable multithreaded encoding
|
|
--disable-win32thread disable win32threads (windows only)
|
|
--disable-interlaced disable interlaced encoding support
|
|
--bit-depth=BIT_DEPTH set output bit depth (8, 10, all) [all]
|
|
--chroma-format=FORMAT output chroma format (400, 420, 422, 444, all) [all]
|
|
|
|
Advanced options:
|
|
--disable-asm disable platform-specific assembly optimizations
|
|
--enable-lto enable link-time optimization
|
|
--enable-debug add -g
|
|
--enable-gprof add -pg
|
|
--enable-strip add -s
|
|
--enable-pic build position-independent code
|
|
|
|
Cross-compilation:
|
|
--host=HOST build programs to run on HOST
|
|
--cross-prefix=PREFIX use PREFIX for compilation tools
|
|
--sysroot=SYSROOT root of cross-build tree
|
|
|
|
External library support:
|
|
--disable-avs disable avisynth support
|
|
--disable-swscale disable swscale support
|
|
--disable-lavf disable libavformat support
|
|
--disable-ffms disable ffmpegsource support
|
|
--disable-gpac disable gpac support
|
|
--disable-lsmash disable lsmash support
|
|
|
|
EOF
|
|
exit 1
|
|
fi
|
|
|
|
log_check() {
|
|
echo -n "checking $1... " >> config.log
|
|
}
|
|
|
|
log_ok() {
|
|
echo "yes" >> config.log
|
|
}
|
|
|
|
log_fail() {
|
|
echo "no" >> config.log
|
|
}
|
|
|
|
log_msg() {
|
|
echo "$1" >> config.log
|
|
}
|
|
|
|
cc_cflags() {
|
|
# several non gcc compilers issue an incredibly large number of warnings on high warning levels,
|
|
# suppress them by reducing the warning level rather than having to use #pragmas
|
|
for arg in $*; do
|
|
[[ "$arg" = -falign-loops* ]] && arg=
|
|
[ "$arg" = -fno-tree-vectorize ] && arg=
|
|
[ "$arg" = -Wshadow ] && arg=
|
|
[ "$arg" = -Wno-maybe-uninitialized ] && arg=
|
|
[[ "$arg" = -mpreferred-stack-boundary* ]] && arg=
|
|
[[ "$arg" = -l* ]] && arg=
|
|
[[ "$arg" = -L* ]] && arg=
|
|
if [ $compiler_style = MS ]; then
|
|
[ "$arg" = -ffast-math ] && arg="-fp:fast"
|
|
[ "$arg" = -Wall ] && arg=
|
|
[ "$arg" = -Werror ] && arg="-W3 -WX"
|
|
[ "$arg" = -g ] && arg=-Z7
|
|
[ "$arg" = -fomit-frame-pointer ] && arg=
|
|
[ "$arg" = -s ] && arg=
|
|
[ "$arg" = -fPIC ] && arg=
|
|
else
|
|
[ "$arg" = -ffast-math ] && arg=
|
|
[ "$arg" = -Wall ] && arg=
|
|
[ "$arg" = -Werror ] && arg="-w3 -Werror"
|
|
fi
|
|
[ $compiler = CL -a "$arg" = -O3 ] && arg=-O2
|
|
|
|
[ -n "$arg" ] && echo -n "$arg "
|
|
done
|
|
}
|
|
|
|
cl_ldflags() {
|
|
for arg in $*; do
|
|
arg=${arg/LIBPATH/libpath}
|
|
[ "${arg#-libpath:}" == "$arg" -a "${arg#-l}" != "$arg" ] && arg=${arg#-l}.lib
|
|
[ "${arg#-L}" != "$arg" ] && arg=-libpath:${arg#-L}
|
|
[ "$arg" = -Wl,--large-address-aware ] && arg=-largeaddressaware
|
|
[ "$arg" = -s ] && arg=
|
|
[ "$arg" = -Wl,-Bsymbolic ] && arg=
|
|
[ "$arg" = -fno-tree-vectorize ] && arg=
|
|
[ "$arg" = -Werror ] && arg=
|
|
[ "$arg" = -Wshadow ] && arg=
|
|
[ "$arg" = -Wmaybe-uninitialized ] && arg=
|
|
[[ "$arg" = -Qdiag-error* ]] && arg=
|
|
|
|
arg=${arg/pthreadGC/pthreadVC}
|
|
[ "$arg" = avifil32.lib ] && arg=vfw32.lib
|
|
[ "$arg" = gpac_static.lib ] && arg=libgpac_static.lib
|
|
[ "$arg" = gpac.lib ] && arg=libgpac.lib
|
|
[ "$arg" = x264.lib ] && arg=libx264.lib
|
|
|
|
[ -n "$arg" ] && echo -n "$arg "
|
|
done
|
|
}
|
|
|
|
cc_check() {
|
|
if [ -z "$3$4" ]; then
|
|
if [ -z "$1$2" ]; then
|
|
log_check "whether $CC works"
|
|
elif [ -z "$1" ]; then
|
|
log_check "for $2"
|
|
else
|
|
log_check "for $1"
|
|
fi
|
|
elif [ -z "$1" ]; then
|
|
if [ -z "$2" ]; then
|
|
if [ -z "$3" ]; then
|
|
log_check "whether $CC supports $4"
|
|
else
|
|
log_check "whether $CC supports $3"
|
|
fi
|
|
else
|
|
log_check "whether $CC supports $3 with $2"
|
|
fi
|
|
else
|
|
log_check "for $3 in $1";
|
|
fi
|
|
rm -f conftest.c
|
|
for arg in $1; do
|
|
echo "#include <$arg>" >> conftest.c
|
|
done
|
|
if [ -n "$4" ]; then
|
|
echo "$4" >> conftest.c
|
|
fi
|
|
echo "int main (void) { $3 return 0; }" >> conftest.c
|
|
if [ $compiler_style = MS ]; then
|
|
cc_cmd="$CC conftest.c $(cc_cflags $CFLAGS $CFLAGSCLI $CHECK_CFLAGS $2) -link $(cl_ldflags $2 $LDFLAGSCLI $LDFLAGS)"
|
|
else
|
|
cc_cmd="$CC conftest.c $CFLAGS $CFLAGSCLI $CHECK_CFLAGS $2 $LDFLAGSCLI $LDFLAGS -o conftest"
|
|
fi
|
|
if $cc_cmd >conftest.log 2>&1; then
|
|
res=$?
|
|
log_ok
|
|
else
|
|
res=$?
|
|
log_fail
|
|
log_msg "Failed commandline was:"
|
|
log_msg "--------------------------------------------------"
|
|
log_msg "$cc_cmd"
|
|
cat conftest.log >> config.log
|
|
log_msg "--------------------------------------------------"
|
|
log_msg "Failed program was:"
|
|
log_msg "--------------------------------------------------"
|
|
cat conftest.c >> config.log
|
|
log_msg "--------------------------------------------------"
|
|
fi
|
|
return $res
|
|
}
|
|
|
|
cpp_check() {
|
|
log_check "whether $3 is true"
|
|
rm -f conftest.c
|
|
for arg in $1; do
|
|
echo "#include <$arg>" >> conftest.c
|
|
done
|
|
echo -e "#if !($3) \n#error $4 \n#endif " >> conftest.c
|
|
if [ $compiler_style = MS ]; then
|
|
cpp_cmd="$CC conftest.c $(cc_cflags $CFLAGS $2) -P"
|
|
else
|
|
cpp_cmd="$CC conftest.c $CFLAGS $2 -E -o conftest"
|
|
fi
|
|
if $cpp_cmd >conftest.log 2>&1; then
|
|
res=$?
|
|
log_ok
|
|
else
|
|
res=$?
|
|
log_fail
|
|
log_msg "--------------------------------------------------"
|
|
cat conftest.log >> config.log
|
|
log_msg "--------------------------------------------------"
|
|
log_msg "Failed program was:"
|
|
log_msg "--------------------------------------------------"
|
|
cat conftest.c >> config.log
|
|
log_msg "--------------------------------------------------"
|
|
fi
|
|
return $res
|
|
}
|
|
|
|
as_check() {
|
|
log_check "whether $AS supports $1"
|
|
echo "$1" > conftest$AS_EXT
|
|
as_cmd="$AS conftest$AS_EXT $ASFLAGS $2 -o conftest.o"
|
|
if $as_cmd >conftest.log 2>&1; then
|
|
res=$?
|
|
log_ok
|
|
else
|
|
res=$?
|
|
log_fail
|
|
log_msg "Failed commandline was:"
|
|
log_msg "--------------------------------------------------"
|
|
log_msg "$as_cmd"
|
|
cat conftest.log >> config.log
|
|
log_msg "--------------------------------------------------"
|
|
log_msg "Failed program was:"
|
|
log_msg "--------------------------------------------------"
|
|
cat conftest$AS_EXT >> config.log
|
|
log_msg "--------------------------------------------------"
|
|
fi
|
|
return $res
|
|
}
|
|
|
|
as_archext_check() {
|
|
feature="$1"
|
|
instr="$2"
|
|
feature_upper="$(echo $feature | tr a-z A-Z)"
|
|
header=".arch $as_arch_level ${NL}"
|
|
if as_check "$header .arch_extension $feature" ; then
|
|
define HAVE_AS_ARCHEXT_${feature_upper}_DIRECTIVE
|
|
header="$header .arch_extension $feature ${NL}"
|
|
fi
|
|
as_check "$header $instr" && define HAVE_${feature_upper}
|
|
}
|
|
|
|
rc_check() {
|
|
log_check "whether $RC works"
|
|
echo "$1" > conftest.rc
|
|
if [ $compiler = GNU ]; then
|
|
rc_cmd="$RC $RCFLAGS -o conftest.o conftest.rc"
|
|
else
|
|
rc_cmd="$RC $RCFLAGS -foconftest.o conftest.rc"
|
|
fi
|
|
if $rc_cmd >conftest.log 2>&1; then
|
|
res=$?
|
|
log_ok
|
|
else
|
|
res=$?
|
|
log_fail
|
|
log_msg "Failed commandline was:"
|
|
log_msg "--------------------------------------------------"
|
|
log_msg "$rc_cmd"
|
|
cat conftest.log >> config.log
|
|
log_msg "--------------------------------------------------"
|
|
log_msg "Failed program was:"
|
|
log_msg "--------------------------------------------------"
|
|
cat conftest.rc >> config.log
|
|
log_msg "--------------------------------------------------"
|
|
fi
|
|
return $res
|
|
}
|
|
|
|
pkg_check() {
|
|
log_check "for packages: $1"
|
|
pkg_cmd="$PKGCONFIG --exists $1"
|
|
if $pkg_cmd >conftest.log 2>&1; then
|
|
res=$?
|
|
log_ok
|
|
else
|
|
res=$?
|
|
log_fail
|
|
log_msg "Failed commandline was:"
|
|
log_msg "--------------------------------------------------"
|
|
log_msg "$pkg_cmd"
|
|
cat conftest.log >> config.log
|
|
log_msg "--------------------------------------------------"
|
|
fi
|
|
return $res
|
|
}
|
|
|
|
define() {
|
|
echo "#define $1$([ -n "$2" ] && echo " $2" || echo " 1")" >> config.h
|
|
}
|
|
|
|
die() {
|
|
log_msg "DIED: $@"
|
|
echo "$@"
|
|
exit 1
|
|
}
|
|
|
|
configure_system_override() {
|
|
log_check "system libx264 configuration"
|
|
x264_config_path="$1/x264_config.h"
|
|
if [ -e "$x264_config_path" ]; then
|
|
res=$?
|
|
log_ok
|
|
arg="$(grep '#define X264_GPL ' $x264_config_path | sed -e 's/#define X264_GPL *//; s/ *$//')"
|
|
if [ -n "$arg" ]; then
|
|
[ "$arg" = 0 ] && arg="no" || arg="yes"
|
|
[ "$arg" != "$gpl" ] && die "Incompatible license with system libx264"
|
|
fi
|
|
arg="$(grep '#define X264_BIT_DEPTH ' $x264_config_path | sed -e 's/#define X264_BIT_DEPTH *//; s/ *$//')"
|
|
if [ -n "$arg" ]; then
|
|
[ "$arg" = 0 ] && arg="all"
|
|
if [ "$arg" != "$bit_depth" ]; then
|
|
echo "Override output bit depth with system libx264 configuration"
|
|
bit_depth="$arg"
|
|
fi
|
|
fi
|
|
arg="$(grep '#define X264_CHROMA_FORMAT ' $x264_config_path | sed -e 's/#define X264_CHROMA_FORMAT *//; s/ *$//')"
|
|
if [ -n "$arg" ]; then
|
|
[ "$arg" = 0 ] && arg="all" || arg="${arg#X264_CSP_I}"
|
|
if [ "$arg" != "$chroma_format" ]; then
|
|
echo "Override output chroma format with system libx264 configuration"
|
|
chroma_format="$arg"
|
|
fi
|
|
fi
|
|
arg="$(grep '#define X264_INTERLACED ' $x264_config_path | sed -e 's/#define X264_INTERLACED *//; s/ *$//')"
|
|
if [ -n "$arg" ]; then
|
|
[ "$arg" = 0 ] && arg="no" || arg="yes"
|
|
if [ "$arg" != "$interlaced" ]; then
|
|
echo "Override interlaced encoding support with system libx264 configuration"
|
|
interlaced="$arg"
|
|
fi
|
|
fi
|
|
else
|
|
res=$?
|
|
log_fail
|
|
log_msg "Failed search path was: $x264_config_path"
|
|
fi
|
|
return $res
|
|
}
|
|
|
|
rm -f x264_config.h config.h config.mak config.log x264.pc x264.def
|
|
rm -rf conftest*
|
|
|
|
# Construct a path to the specified directory relative to the working directory
|
|
relative_path() {
|
|
local base="${PWD%/}"
|
|
local path="$(cd "$1" >/dev/null; printf '%s/.' "${PWD%/}")"
|
|
local up=''
|
|
|
|
while [[ $path != "$base/"* ]]; do
|
|
base="${base%/*}"
|
|
up="../$up"
|
|
done
|
|
|
|
dirname "$up${path#"$base/"}"
|
|
}
|
|
|
|
SRCPATH="$(relative_path "$(dirname "$0")")"
|
|
echo "$SRCPATH" | grep -q ' ' && die "Out of tree builds are impossible with whitespace in source path."
|
|
[ -e "$SRCPATH/config.h" -o -e "$SRCPATH/x264_config.h" ] && die "Out of tree builds are impossible with config.h/x264_config.h in source dir."
|
|
|
|
prefix='/usr/local'
|
|
exec_prefix='${prefix}'
|
|
bindir='${exec_prefix}/bin'
|
|
libdir='${exec_prefix}/lib'
|
|
includedir='${prefix}/include'
|
|
DEVNULL='/dev/null'
|
|
|
|
cli="yes"
|
|
cli_libx264="internal"
|
|
shared="no"
|
|
static="no"
|
|
bashcompletion="auto"
|
|
bashcompletionsdir=""
|
|
avs="auto"
|
|
lavf="auto"
|
|
ffms="auto"
|
|
gpac="auto"
|
|
lsmash="auto"
|
|
mp4="no"
|
|
gpl="yes"
|
|
thread="auto"
|
|
swscale="auto"
|
|
asm="auto"
|
|
interlaced="yes"
|
|
lto="no"
|
|
debug="no"
|
|
gprof="no"
|
|
strip="no"
|
|
pic="no"
|
|
bit_depth="all"
|
|
chroma_format="all"
|
|
compiler="GNU"
|
|
compiler_style="GNU"
|
|
opencl="yes"
|
|
vsx="auto"
|
|
|
|
CFLAGS="$CFLAGS -Wall -I. -I\$(SRCPATH)"
|
|
CFLAGSSO="$CFLAGSSO"
|
|
CFLAGSCLI="$CFLAGSCLI"
|
|
LDFLAGS="$LDFLAGS"
|
|
LDFLAGSCLI="$LDFLAGSCLI"
|
|
ASFLAGS="$ASFLAGS -I. -I\$(SRCPATH)"
|
|
RCFLAGS="$RCFLAGS"
|
|
CHECK_CFLAGS=""
|
|
HAVE_GETOPT_LONG=1
|
|
cross_prefix=""
|
|
|
|
EXE=""
|
|
AS_EXT=".S"
|
|
NL="
|
|
"
|
|
|
|
# list of all preprocessor HAVE values we can define
|
|
CONFIG_HAVE="MALLOC_H ALTIVEC ALTIVEC_H MMX ARMV6 ARMV6T2 NEON AARCH64 BEOSTHREAD POSIXTHREAD WIN32THREAD THREAD LOG2F SWSCALE \
|
|
LAVF FFMS GPAC AVS GPL VECTOREXT INTERLACED CPU_COUNT OPENCL THP LSMASH X86_INLINE_ASM AS_FUNC INTEL_DISPATCHER \
|
|
MSA LSX MMAP WINRT VSX ARM_INLINE_ASM STRTOK_R CLOCK_GETTIME BITDEPTH8 BITDEPTH10 ELF_AUX_INFO GETAUXVAL \
|
|
SYSCONF SYNC_FETCH_AND_ADD \
|
|
DOTPROD I8MM SVE SVE2 \
|
|
RISCV64 RVV \
|
|
AS_ARCHEXT_DOTPROD_DIRECTIVE AS_ARCHEXT_I8MM_DIRECTIVE AS_ARCHEXT_SVE_DIRECTIVE AS_ARCHEXT_SVE2_DIRECTIVE"
|
|
|
|
# parse options
|
|
|
|
for opt do
|
|
optarg="${opt#*=}"
|
|
case "$opt" in
|
|
--prefix=*)
|
|
prefix="$optarg"
|
|
;;
|
|
--exec-prefix=*)
|
|
exec_prefix="$optarg"
|
|
;;
|
|
--bindir=*)
|
|
bindir="$optarg"
|
|
;;
|
|
--libdir=*)
|
|
libdir="$optarg"
|
|
;;
|
|
--includedir=*)
|
|
includedir="$optarg"
|
|
;;
|
|
--disable-cli)
|
|
cli="no"
|
|
;;
|
|
--system-libx264)
|
|
cli_libx264="system"
|
|
;;
|
|
--enable-shared)
|
|
shared="yes"
|
|
;;
|
|
--enable-static)
|
|
static="yes"
|
|
;;
|
|
--disable-bashcompletion)
|
|
bashcompletion="no"
|
|
;;
|
|
--enable-bashcompletion)
|
|
bashcompletion="yes"
|
|
;;
|
|
--bashcompletionsdir=*)
|
|
bashcompletionsdir="$optarg"
|
|
;;
|
|
--disable-asm)
|
|
asm="no"
|
|
;;
|
|
--disable-interlaced)
|
|
interlaced="no"
|
|
;;
|
|
--disable-avs)
|
|
avs="no"
|
|
;;
|
|
--disable-lavf)
|
|
lavf="no"
|
|
;;
|
|
--disable-ffms)
|
|
ffms="no"
|
|
;;
|
|
--disable-gpac)
|
|
gpac="no"
|
|
;;
|
|
--disable-lsmash)
|
|
lsmash="no"
|
|
;;
|
|
--disable-gpl)
|
|
gpl="no"
|
|
;;
|
|
--extra-asflags=*)
|
|
ASFLAGS="$ASFLAGS $optarg"
|
|
;;
|
|
--extra-cflags=*)
|
|
CFLAGS="$CFLAGS $optarg"
|
|
;;
|
|
--extra-ldflags=*)
|
|
LDFLAGS="$LDFLAGS $optarg"
|
|
;;
|
|
--extra-rcflags=*)
|
|
RCFLAGS="$RCFLAGS $optarg"
|
|
;;
|
|
--disable-thread)
|
|
thread="no"
|
|
;;
|
|
--disable-win32thread)
|
|
[ "$thread" != "no" ] && thread="posix"
|
|
;;
|
|
--disable-swscale)
|
|
swscale="no"
|
|
;;
|
|
--enable-lto)
|
|
lto="auto"
|
|
;;
|
|
--enable-debug)
|
|
debug="yes"
|
|
;;
|
|
--enable-gprof)
|
|
CFLAGS="$CFLAGS -pg"
|
|
LDFLAGS="$LDFLAGS -pg"
|
|
gprof="yes"
|
|
;;
|
|
--enable-strip)
|
|
strip="yes"
|
|
;;
|
|
--enable-pic)
|
|
pic="yes"
|
|
;;
|
|
--host=*)
|
|
host="$optarg"
|
|
;;
|
|
--disable-vsx)
|
|
vsx="no"
|
|
;;
|
|
--disable-opencl)
|
|
opencl="no"
|
|
;;
|
|
--cross-prefix=*)
|
|
cross_prefix="$optarg"
|
|
;;
|
|
--sysroot=*)
|
|
CFLAGS="$CFLAGS --sysroot=$optarg"
|
|
LDFLAGS="$LDFLAGS --sysroot=$optarg"
|
|
;;
|
|
--bit-depth=*)
|
|
bit_depth="$optarg"
|
|
if [ "$bit_depth" != "8" -a "$bit_depth" != "10" -a "$bit_depth" != "all" ]; then
|
|
echo "Supplied bit depth must be 8, 10 or all."
|
|
exit 1
|
|
fi
|
|
;;
|
|
--chroma-format=*)
|
|
chroma_format="$optarg"
|
|
if [ $chroma_format != "400" -a $chroma_format != "420" -a $chroma_format != "422" -a $chroma_format != "444" -a $chroma_format != "all" ]; then
|
|
echo "Supplied chroma format must be 400, 420, 422, 444 or all."
|
|
exit 1
|
|
fi
|
|
;;
|
|
*)
|
|
echo "Unknown option $opt, ignored"
|
|
;;
|
|
esac
|
|
done
|
|
|
|
[ "$cli" = "no" -a "$shared" = "no" -a "$static" = "no" ] && die "Nothing to build. Enable cli, shared or static."
|
|
|
|
CC="${CC-${cross_prefix}gcc}"
|
|
STRIP="${STRIP-${cross_prefix}strip}"
|
|
STRINGS="${STRINGS-${cross_prefix}strings}"
|
|
INSTALL="${INSTALL-install}"
|
|
PKGCONFIG="${PKGCONFIG-${cross_prefix}pkg-config}"
|
|
|
|
# ar and ranlib doesn't load the LTO plugin by default, prefer the gcc-prefixed wrappers which does.
|
|
if ${cross_prefix}gcc-ar --version >/dev/null 2>&1; then
|
|
AR="${AR-${cross_prefix}gcc-ar}"
|
|
else
|
|
AR="${AR-${cross_prefix}ar}"
|
|
fi
|
|
if ${cross_prefix}gcc-ranlib --version >/dev/null 2>&1; then
|
|
RANLIB="${RANLIB-${cross_prefix}gcc-ranlib}"
|
|
else
|
|
RANLIB="${RANLIB-${cross_prefix}ranlib}"
|
|
fi
|
|
|
|
if [ "x$host" = x ]; then
|
|
host="$(${SRCPATH}/config.guess)"
|
|
fi
|
|
# normalize a triplet into a quadruplet
|
|
host="$(${SRCPATH}/config.sub $host)"
|
|
|
|
# split $host
|
|
host_cpu="${host%%-*}"
|
|
host="${host#*-}"
|
|
host_vendor="${host%%-*}"
|
|
host_os="${host#*-}"
|
|
|
|
trap 'rm -rf conftest*' EXIT
|
|
|
|
# test for use of compilers that require specific handling
|
|
cc_base="$(basename "$CC")"
|
|
QPRE="-"
|
|
if [[ $host_os = mingw* || $host_os = msys* || $host_os = cygwin* ]]; then
|
|
if [[ "$cc_base" = icl || "$cc_base" = icl[\ .]* ]]; then
|
|
# Windows Intel Compiler creates dependency generation with absolute Windows paths, Cygwin's make does not support Windows paths.
|
|
[[ $host_os = cygwin* ]] && die "Windows Intel Compiler support requires MSYS"
|
|
compiler=ICL
|
|
compiler_style=MS
|
|
CFLAGS="$CFLAGS -Qstd=c99 -nologo -Qms0 -DHAVE_STRING_H -I\$(SRCPATH)/extras"
|
|
QPRE="-Q"
|
|
cpp_check '' '' '_MSC_VER >= 1400' || die "Windows Intel Compiler support requires Visual Studio 2005 or newer"
|
|
if cpp_check '' '' 'defined(_M_AMD64) || defined(_M_X64)' ; then
|
|
host_cpu=x86_64
|
|
elif cpp_check '' '' 'defined(_M_IX86)' ; then
|
|
host_cpu=i486
|
|
fi
|
|
if cc_check '' -Qdiag-error:10006,10157 ; then
|
|
CHECK_CFLAGS="$CHECK_CFLAGS -Qdiag-error:10006,10157"
|
|
fi
|
|
elif [[ "$cc_base" = cl || "$cc_base" = cl[\ .]* ]]; then
|
|
# Standard Microsoft Visual Studio
|
|
compiler=CL
|
|
compiler_style=MS
|
|
CFLAGS="$CFLAGS -nologo -GS- -DHAVE_STRING_H -I\$(SRCPATH)/extras"
|
|
cpp_check '' '' '_MSC_VER > 1800 || (_MSC_VER == 1800 && _MSC_FULL_VER >= 180030324)' || die "Microsoft Visual Studio support requires Visual Studio 2013 Update 2 or newer"
|
|
if cpp_check '' '' 'defined(_M_AMD64) || defined(_M_X64)' ; then
|
|
host_cpu=x86_64
|
|
elif cpp_check '' '' 'defined(_M_IX86)' ; then
|
|
host_cpu=i486
|
|
elif cpp_check '' '' 'defined(_M_ARM64)' ; then
|
|
host_cpu=aarch64
|
|
elif cpp_check '' '' 'defined(_M_ARM)' ; then
|
|
host_cpu=arm
|
|
fi
|
|
else
|
|
# MinGW uses broken pre-VS2015 Microsoft printf functions unless it's told to use the POSIX ones.
|
|
CFLAGS="$CFLAGS -D_POSIX_C_SOURCE=200112L"
|
|
fi
|
|
else
|
|
if [[ "$cc_base" = icc || "$cc_base" = icc[\ .]* ]]; then
|
|
AR="xiar"
|
|
compiler=ICC
|
|
fi
|
|
fi
|
|
|
|
if [ $compiler = GNU ]; then
|
|
if cc_check '' -Werror=unknown-warning-option ; then
|
|
CHECK_CFLAGS="$CHECK_CFLAGS -Werror=unknown-warning-option"
|
|
fi
|
|
if cc_check '' -Werror=unknown-attributes ; then
|
|
CHECK_CFLAGS="$CHECK_CFLAGS -Werror=unknown-attributes"
|
|
fi
|
|
if cc_check '' -Werror=attributes ; then
|
|
CHECK_CFLAGS="$CHECK_CFLAGS -Werror=attributes"
|
|
fi
|
|
if cc_check '' -Werror=ignored-attributes ; then
|
|
CHECK_CFLAGS="$CHECK_CFLAGS -Werror=ignored-attributes"
|
|
fi
|
|
if cc_check '' -Werror=implicit-function-declaration ; then
|
|
CHECK_CFLAGS="$CHECK_CFLAGS -Werror=implicit-function-declaration"
|
|
fi
|
|
fi
|
|
|
|
libm=""
|
|
case $host_os in
|
|
beos*)
|
|
SYS="BEOS"
|
|
define HAVE_MALLOC_H
|
|
;;
|
|
darwin*)
|
|
SYS="MACOSX"
|
|
libm="-lm"
|
|
if [ "$pic" = "no" ]; then
|
|
cc_check "" -mdynamic-no-pic && CFLAGS="$CFLAGS -mdynamic-no-pic"
|
|
fi
|
|
;;
|
|
dragonfly*)
|
|
SYS="DRAGONFLY"
|
|
libm="-lm"
|
|
;;
|
|
freebsd*)
|
|
SYS="FREEBSD"
|
|
libm="-lm"
|
|
;;
|
|
kfreebsd*-gnu)
|
|
SYS="FREEBSD"
|
|
define HAVE_MALLOC_H
|
|
libm="-lm"
|
|
;;
|
|
netbsd*)
|
|
SYS="NETBSD"
|
|
libm="-lm"
|
|
;;
|
|
openbsd*)
|
|
SYS="OPENBSD"
|
|
libm="-lm"
|
|
;;
|
|
*linux*)
|
|
SYS="LINUX"
|
|
define HAVE_MALLOC_H
|
|
libm="-lm"
|
|
;;
|
|
gnu*)
|
|
SYS="HURD"
|
|
define HAVE_MALLOC_H
|
|
libm="-lm"
|
|
;;
|
|
cygwin*|mingw*|msys*)
|
|
EXE=".exe"
|
|
if [[ $host_os = cygwin* ]] && cpp_check "" "" "defined(__CYGWIN__)" ; then
|
|
SYS="CYGWIN"
|
|
define HAVE_MALLOC_H
|
|
else
|
|
SYS="WINDOWS"
|
|
DEVNULL="NUL"
|
|
cc_check '' -lshell32 && LDFLAGSCLI="$LDFLAGSCLI -lshell32"
|
|
[ $compiler = GNU ] && RC="${RC-${cross_prefix}windres}" || RC="${RC-rc.exe}"
|
|
fi
|
|
;;
|
|
sunos*|solaris*)
|
|
SYS="SunOS"
|
|
define HAVE_MALLOC_H
|
|
libm="-lm"
|
|
if cc_check "" /usr/lib/64/values-xpg6.o; then
|
|
LDFLAGS="$LDFLAGS /usr/lib/64/values-xpg6.o"
|
|
else
|
|
LDFLAGS="$LDFLAGS /usr/lib/values-xpg6.o"
|
|
fi
|
|
if test -x /usr/ucb/install ; then
|
|
INSTALL=/usr/ucb/install
|
|
elif test -x /usr/bin/ginstall ; then
|
|
# OpenSolaris
|
|
INSTALL=/usr/bin/ginstall
|
|
elif test -x /usr/gnu/bin/install ; then
|
|
# OpenSolaris
|
|
INSTALL=/usr/gnu/bin/install
|
|
fi
|
|
HAVE_GETOPT_LONG=0
|
|
;;
|
|
*qnx*)
|
|
SYS="QNX"
|
|
define HAVE_MALLOC_H
|
|
libm="-lm"
|
|
HAVE_GETOPT_LONG=0
|
|
CFLAGS="$CFLAGS -I\$(SRCPATH)/extras"
|
|
;;
|
|
*haiku*)
|
|
SYS="HAIKU"
|
|
;;
|
|
*)
|
|
die "Unknown system $host, edit the configure"
|
|
;;
|
|
esac
|
|
|
|
LDFLAGS="$LDFLAGS $libm"
|
|
|
|
stack_alignment=4
|
|
case $host_cpu in
|
|
i*86)
|
|
ARCH="X86"
|
|
AS="${AS-nasm}"
|
|
AS_EXT=".asm"
|
|
ASFLAGS="$ASFLAGS -DARCH_X86_64=0 -I\$(SRCPATH)/common/x86/"
|
|
if [ $compiler = GNU ]; then
|
|
if [[ "$asm" == auto && "$CFLAGS" != *-march* ]]; then
|
|
CFLAGS="$CFLAGS -march=i686"
|
|
fi
|
|
if [[ "$asm" == auto && "$CFLAGS" != *-mfpmath* ]]; then
|
|
CFLAGS="$CFLAGS -mfpmath=sse -msse -msse2"
|
|
fi
|
|
CFLAGS="-m32 $CFLAGS"
|
|
LDFLAGS="-m32 $LDFLAGS"
|
|
fi
|
|
if [ "$SYS" = MACOSX ]; then
|
|
ASFLAGS="$ASFLAGS -f macho32 -DPREFIX"
|
|
elif [ "$SYS" = WINDOWS -o "$SYS" = CYGWIN ]; then
|
|
ASFLAGS="$ASFLAGS -f win32 -DPREFIX"
|
|
LDFLAGS="$LDFLAGS -Wl,--large-address-aware"
|
|
[ $compiler = GNU ] && LDFLAGS="$LDFLAGS -Wl,--dynamicbase,--nxcompat,--tsaware"
|
|
[ $compiler = GNU ] && RCFLAGS="--target=pe-i386 $RCFLAGS"
|
|
else
|
|
ASFLAGS="$ASFLAGS -f elf32"
|
|
fi
|
|
;;
|
|
x86_64)
|
|
ARCH="X86_64"
|
|
AS="${AS-nasm}"
|
|
AS_EXT=".asm"
|
|
ASFLAGS="$ASFLAGS -DARCH_X86_64=1 -I\$(SRCPATH)/common/x86/"
|
|
stack_alignment=16
|
|
[ $compiler = GNU ] && CFLAGS="-m64 $CFLAGS" && LDFLAGS="-m64 $LDFLAGS"
|
|
if [ "$SYS" = MACOSX ]; then
|
|
ASFLAGS="$ASFLAGS -f macho64 -DPREFIX"
|
|
if cc_check '' "-arch x86_64"; then
|
|
CFLAGS="$CFLAGS -arch x86_64"
|
|
LDFLAGS="$LDFLAGS -arch x86_64"
|
|
fi
|
|
elif [ "$SYS" = WINDOWS -o "$SYS" = CYGWIN ]; then
|
|
ASFLAGS="$ASFLAGS -f win64"
|
|
if [ $compiler = GNU ]; then
|
|
# only the GNU toolchain is inconsistent in prefixing function names with _
|
|
cc_check "" "-S" && grep -q "_main:" conftest && ASFLAGS="$ASFLAGS -DPREFIX"
|
|
cc_check "" "-Wl,--high-entropy-va" && LDFLAGS="$LDFLAGS -Wl,--high-entropy-va"
|
|
LDFLAGS="$LDFLAGS -Wl,--dynamicbase,--nxcompat,--tsaware"
|
|
LDFLAGSCLI="$LDFLAGSCLI -Wl,--image-base,0x140000000"
|
|
SOFLAGS="$SOFLAGS -Wl,--image-base,0x180000000"
|
|
RCFLAGS="--target=pe-x86-64 $RCFLAGS"
|
|
fi
|
|
else
|
|
ASFLAGS="$ASFLAGS -f elf64"
|
|
fi
|
|
;;
|
|
powerpc*)
|
|
ARCH="PPC"
|
|
if [ $asm = auto ] ; then
|
|
define HAVE_ALTIVEC
|
|
AS="${AS-${CC}}"
|
|
AS_EXT=".c"
|
|
if [ $SYS = MACOSX ] ; then
|
|
CFLAGS="$CFLAGS -faltivec -fastf -mcpu=G4"
|
|
else
|
|
CFLAGS="$CFLAGS -maltivec -mabi=altivec"
|
|
define HAVE_ALTIVEC_H
|
|
fi
|
|
if [ "$vsx" != "no" ] ; then
|
|
vsx="no"
|
|
if cc_check "" "-mvsx" ; then
|
|
CFLAGS="$CFLAGS -mvsx"
|
|
define HAVE_VSX
|
|
vsx="yes"
|
|
fi
|
|
fi
|
|
fi
|
|
;;
|
|
sparc)
|
|
ARCH="SPARC"
|
|
;;
|
|
mips*)
|
|
ARCH="MIPS"
|
|
AS="${AS-${CC}}"
|
|
AS_EXT=".c"
|
|
;;
|
|
loongarch*)
|
|
ARCH="LOONGARCH"
|
|
ASFLAGS="$ASFLAGS -c"
|
|
AS="${AS-${CC}}"
|
|
AS_EXT=".S"
|
|
;;
|
|
aarch64|arm64*)
|
|
ARCH="AARCH64"
|
|
stack_alignment=16
|
|
if [ "$SYS" = MACOSX ] ; then
|
|
AS="${AS-${CC}}"
|
|
ASFLAGS="$ASFLAGS -DPREFIX -DPIC"
|
|
if cc_check '' "-arch arm64"; then
|
|
CFLAGS="$CFLAGS -arch arm64"
|
|
LDFLAGS="$LDFLAGS -arch arm64"
|
|
ASFLAGS="$ASFLAGS -arch arm64"
|
|
fi
|
|
elif [ "$SYS" = WINDOWS ] && [ "$compiler" = CL ] ; then
|
|
AS="${AS-${SRCPATH}/tools/gas-preprocessor.pl -arch aarch64 -as-type armasm -- armasm64 -nologo}"
|
|
else
|
|
AS="${AS-${CC}}"
|
|
fi
|
|
;;
|
|
arm*)
|
|
ARCH="ARM"
|
|
if [ "$SYS" = MACOSX ] ; then
|
|
AS="${AS-${CC}}"
|
|
ASFLAGS="$ASFLAGS -DPREFIX -DPIC" # apple's ld doesn't support movw/movt relocations at all
|
|
# build for armv7 by default
|
|
if ! echo $CFLAGS | grep -Eq '\-arch' ; then
|
|
CFLAGS="$CFLAGS -arch armv7"
|
|
LDFLAGS="$LDFLAGS -arch armv7"
|
|
fi
|
|
elif [ "$SYS" = WINDOWS ] && [ "$compiler" = CL ] ; then
|
|
AS="${AS-${SRCPATH}/tools/gas-preprocessor.pl -arch arm -as-type armasm -force-thumb -- armasm -nologo -ignore 4509}"
|
|
elif [ "$SYS" = WINDOWS ] ; then
|
|
AS="${AS-${SRCPATH}/tools/gas-preprocessor.pl -arch arm -as-type clang -force-thumb -- ${CC} -mimplicit-it=always}"
|
|
else
|
|
AS="${AS-${CC}}"
|
|
fi
|
|
;;
|
|
riscv64)
|
|
ARCH="RISCV64"
|
|
stack_alignment=16
|
|
|
|
AS="${AS-${CC}}"
|
|
;;
|
|
s390|s390x)
|
|
ARCH="S390"
|
|
;;
|
|
hppa*|parisc*)
|
|
ARCH="PARISC"
|
|
;;
|
|
ia64)
|
|
ARCH="IA64"
|
|
;;
|
|
alpha*)
|
|
ARCH="ALPHA"
|
|
;;
|
|
*)
|
|
ARCH="$(echo $host_cpu | tr a-z A-Z)"
|
|
;;
|
|
esac
|
|
|
|
[ "$vsx" != "yes" ] && vsx="no"
|
|
|
|
if [ $SYS = WINDOWS ]; then
|
|
if ! rc_check "0 RCDATA {0}" ; then
|
|
RC=""
|
|
fi
|
|
|
|
if cpp_check "winapifamily.h" "" "!WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)" ; then
|
|
[ $compiler = CL ] || die "WinRT requires MSVC"
|
|
define HAVE_WINRT
|
|
CFLAGS="$CFLAGS -MD"
|
|
LDFLAGS="$LDFLAGS -appcontainer"
|
|
if ! cpp_check "" "" "defined(_WIN32_WINNT) && _WIN32_WINNT >= 0x0603" ; then
|
|
die "_WIN32_WINNT must be defined to at least 0x0603 (Windows 8.1) for WinRT"
|
|
elif cpp_check "" "" "_WIN32_WINNT >= 0x0A00" ; then
|
|
# Universal Windows Platform (Windows 10)
|
|
LDFLAGS="$LDFLAGS -lWindowsApp"
|
|
fi
|
|
cli="no"
|
|
opencl="no"
|
|
fi
|
|
fi
|
|
|
|
log_msg "x264 configure script"
|
|
if [ -n "$*" ]; then
|
|
msg="Command line options:"
|
|
for i in $@; do
|
|
msg="$msg \"$i\""
|
|
done
|
|
log_msg "$msg"
|
|
fi
|
|
log_msg ""
|
|
|
|
# check requirements
|
|
|
|
cc_check || die "No working C compiler found."
|
|
|
|
if [ $compiler_style = GNU ]; then
|
|
if cc_check '' -std=gnu99 'for( int i = 0; i < 9; i++ );' ; then
|
|
CFLAGS="$CFLAGS -std=gnu99 -D_GNU_SOURCE"
|
|
elif cc_check '' -std=c99 'for( int i = 0; i < 9; i++ );' ; then
|
|
CFLAGS="$CFLAGS -std=c99 -D_POSIX_C_SOURCE=200112L -D_BSD_SOURCE"
|
|
elif ! cc_check '' '' 'for( int i = 0; i < 9; i++ );' ; then
|
|
die "C99 compiler is needed for compilation."
|
|
fi
|
|
fi
|
|
|
|
if [ $shared = yes ] ; then
|
|
pic="yes"
|
|
fi
|
|
|
|
if cc_check '' '' '' '__attribute__((force_align_arg_pointer))' ; then
|
|
if [ $compiler = GNU -a \( $ARCH = X86 -o $ARCH = X86_64 \) ] ; then
|
|
if cc_check '' -mpreferred-stack-boundary=6 ; then
|
|
CFLAGS="$CFLAGS -mpreferred-stack-boundary=6"
|
|
stack_alignment=64
|
|
elif cc_check '' -mstack-alignment=64 ; then
|
|
CFLAGS="$CFLAGS -mstack-alignment=64"
|
|
stack_alignment=64
|
|
elif [ $stack_alignment -lt 16 ] ; then
|
|
if cc_check '' -mpreferred-stack-boundary=4 ; then
|
|
CFLAGS="$CFLAGS -mpreferred-stack-boundary=4"
|
|
stack_alignment=16
|
|
elif cc_check '' -mstack-alignment=16 ; then
|
|
CFLAGS="$CFLAGS -mstack-alignment=16"
|
|
stack_alignment=16
|
|
fi
|
|
fi
|
|
elif [ $compiler = ICC -a $ARCH = X86 ]; then
|
|
# icc on linux has various degrees of mod16 stack support
|
|
if [ $SYS = LINUX ]; then
|
|
# >= 12 defaults to a mod16 stack
|
|
if cpp_check "" "" "__INTEL_COMPILER >= 1200" ; then
|
|
stack_alignment=16
|
|
# 11 <= x < 12 is capable of keeping a mod16 stack, but defaults to not doing so.
|
|
elif cpp_check "" "" "__INTEL_COMPILER >= 1100" ; then
|
|
CFLAGS="$CFLAGS -falign-stack=assume-16-byte"
|
|
stack_alignment=16
|
|
fi
|
|
# < 11 is completely incapable of keeping a mod16 stack
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
if [ $asm = auto -a \( $ARCH = X86 -o $ARCH = X86_64 \) ] ; then
|
|
if ! as_check "vmovdqa32 [eax]{k1}{z}, zmm0" ; then
|
|
VER="$( ($AS --version || echo no assembler) 2>/dev/null | head -n 1 )"
|
|
echo "Found $VER"
|
|
echo "Minimum version is nasm-2.13"
|
|
echo "If you really want to compile without asm, configure with --disable-asm."
|
|
exit 1
|
|
fi
|
|
cc_check '' '' '__asm__("pabsw %xmm0, %xmm0");' && define HAVE_X86_INLINE_ASM
|
|
define HAVE_MMX
|
|
fi
|
|
|
|
if [ $asm = auto -a $ARCH = ARM ] ; then
|
|
# set flags so neon is built by default
|
|
[ $compiler == CL ] || echo $CFLAGS | grep -Eq '(-mcpu|-march|-mfpu)' || CFLAGS="$CFLAGS -mcpu=cortex-a8 -mfpu=neon"
|
|
|
|
cc_check '' '' '__asm__("add r0, r1, r2");' && define HAVE_ARM_INLINE_ASM
|
|
if [ $compiler = CL ] && cpp_check '' '' 'defined(_M_ARM) && _M_ARM >= 7' ; then
|
|
define HAVE_ARMV6
|
|
define HAVE_ARMV6T2
|
|
define HAVE_NEON
|
|
elif cc_check '' '' '__asm__("rev ip, ip");' ; then define HAVE_ARMV6
|
|
cc_check '' '' '__asm__("movt r0, #0");' && define HAVE_ARMV6T2
|
|
cc_check '' '' '__asm__("vadd.i16 q0, q0, q0");' && define HAVE_NEON
|
|
ASFLAGS="$ASFLAGS -c"
|
|
else
|
|
echo "You specified a pre-ARMv6 or Thumb-1 CPU in your CFLAGS."
|
|
echo "If you really want to run on such a CPU, configure with --disable-asm."
|
|
exit 1
|
|
fi
|
|
fi
|
|
|
|
if [ $asm = auto -a $ARCH = AARCH64 ] ; then
|
|
if [ $compiler != CL ] ; then
|
|
ASFLAGS="$ASFLAGS -c"
|
|
fi
|
|
if as_check "cmeq v0.8h, v0.8h, #0" ; then
|
|
define HAVE_AARCH64
|
|
define HAVE_NEON
|
|
else
|
|
echo "no NEON support, try adding -mfpu=neon to CFLAGS"
|
|
echo "If you really want to run on such a CPU, configure with --disable-asm."
|
|
exit 1
|
|
fi
|
|
# Check for higher .arch levels. We only need armv8.2-a in order to
|
|
# enable the extensions we want below - we primarily want to control
|
|
# them via .arch_extension. However:
|
|
#
|
|
# Clang before version 17 (Xcode versions before 16) didn't support
|
|
# controlling the dotprod/i8mm extensions via .arch_extension; thus
|
|
# try to enable them via the .arch level as well.
|
|
as_arch_level="armv8-a"
|
|
for level in armv8.2-a armv8.4-a armv8.6-a; do
|
|
as_check ".arch ${level}" && as_arch_level="$level"
|
|
done
|
|
# Clang before version 17 (Xcode versions before 16) also had a bug
|
|
# (https://github.com/llvm/llvm-project/issues/32220) causing a plain
|
|
# ".arch <level>" to not have any effect unless it had an extra
|
|
# "+<feature>" included - but it was activated on the next
|
|
# ".arch_extension" directive. Check if we can include "+crc" as dummy
|
|
# feature to make the .arch directive behave as expected and take
|
|
# effect right away.
|
|
as_check ".arch ${as_arch_level}+crc" && as_arch_level="${as_arch_level}+crc"
|
|
define AS_ARCH_LEVEL "$as_arch_level"
|
|
|
|
as_archext_check dotprod "udot v0.4s, v0.16b, v0.16b"
|
|
as_archext_check i8mm "usdot v0.4s, v0.16b, v0.16b"
|
|
as_archext_check sve "ptrue p0.b, vl16"
|
|
as_archext_check sve2 "smlalb z10.s, z2.h, z1.h"
|
|
fi
|
|
|
|
if [ $asm = auto -a \( $ARCH = ARM -o $ARCH = AARCH64 \) ] ; then
|
|
# check if the assembler supports '.func' (clang 3.5 does not)
|
|
as_check ".func test${NL}.endfunc" && define HAVE_AS_FUNC 1
|
|
fi
|
|
|
|
if [ $asm = auto -a $ARCH = MIPS ] ; then
|
|
if ! echo $CFLAGS | grep -Eq '(-march|-mmsa|-mno-msa)' ; then
|
|
cc_check '' '-mmsa -mfp64 -mhard-float' && CFLAGS="-mmsa -mfp64 -mhard-float $CFLAGS"
|
|
fi
|
|
|
|
if cc_check '' '' '__asm__("addvi.b $w0, $w1, 1");' ; then
|
|
define HAVE_MSA
|
|
else
|
|
echo "You specified a pre-MSA CPU in your CFLAGS."
|
|
echo "If you really want to run on such a CPU, configure with --disable-asm."
|
|
exit 1
|
|
fi
|
|
fi
|
|
|
|
if [ $asm = auto -a $ARCH = RISCV64 ] ; then
|
|
define HAVE_RISCV64
|
|
if cc_check '' '' '__asm__(".option arch, +v\n" "vsetvli t0, a0, e32, m1, ta, ma");' ; then
|
|
define HAVE_RVV
|
|
fi
|
|
|
|
ASFLAGS="$ASFLAGS -c"
|
|
fi
|
|
|
|
if [ $asm = auto -a $ARCH = LOONGARCH ] ; then
|
|
if cc_check '' '' '__asm__("xvadd.b $xr0, $xr1, $xr2");' ; then
|
|
# Use HAVE_LSX as the base flag, compiler support LA SIMD(LSX and LASX)
|
|
define HAVE_LSX
|
|
fi
|
|
fi
|
|
|
|
[ $asm = no ] && AS=""
|
|
[ "x$AS" = x ] && asm="no" || asm="yes"
|
|
|
|
define ARCH_$ARCH
|
|
define SYS_$SYS
|
|
|
|
define STACK_ALIGNMENT $stack_alignment
|
|
ASFLAGS="$ASFLAGS -DSTACK_ALIGNMENT=$stack_alignment"
|
|
|
|
# skip endianness check for Intel Compiler and MSVS, as all supported platforms are little. each have flags that will cause the check to fail as well
|
|
CPU_ENDIAN="little-endian"
|
|
if [ $compiler = GNU ]; then
|
|
echo "int i[2] = {0x42494745,0}; double f[2] = {0x1.0656e6469616ep+102,0};" > conftest.c
|
|
$CC $CFLAGS -fno-lto conftest.c -c -o conftest.o 2>/dev/null || die "endian test failed"
|
|
if (${STRINGS} -a conftest.o | grep -q BIGE) && (${STRINGS} -a conftest.o | grep -q FPendian) ; then
|
|
define WORDS_BIGENDIAN
|
|
CPU_ENDIAN="big-endian"
|
|
elif !(${STRINGS} -a conftest.o | grep -q EGIB && ${STRINGS} -a conftest.o | grep -q naidnePF) ; then
|
|
die "endian test failed"
|
|
fi
|
|
fi
|
|
|
|
if [ "$cli_libx264" = "system" -a "$shared" != "yes" ] ; then
|
|
[ "$static" = "yes" ] && die "Option --system-libx264 can not be used together with --enable-static"
|
|
if pkg_check x264 ; then
|
|
X264_LIBS="$($PKGCONFIG --libs x264)"
|
|
X264_CFLAGS="$($PKGCONFIG --cflags x264)"
|
|
X264_INCLUDE_DIR="${X264_INCLUDE_DIR-$($PKGCONFIG --variable=includedir x264)}"
|
|
configure_system_override "$X264_INCLUDE_DIR" || die "Detection of system libx264 configuration failed"
|
|
else
|
|
die "Can not find system libx264"
|
|
fi
|
|
fi
|
|
|
|
# autodetect options that weren't forced nor disabled
|
|
|
|
libpthread=""
|
|
if [ "$SYS" = "WINDOWS" -a "$thread" = "posix" ] ; then
|
|
if [ "$gpl" = "no" ] ; then
|
|
echo "Warning: pthread-win32 is LGPL and is therefore not supported with --disable-gpl"
|
|
thread="no"
|
|
elif cc_check pthread.h -lpthread "pthread_create(0,0,0,0);" ; then
|
|
libpthread="-lpthread"
|
|
elif cc_check pthread.h -lpthreadGC2 "pthread_create(0,0,0,0);" ; then
|
|
libpthread="-lpthreadGC2"
|
|
elif cc_check pthread.h "-lpthreadGC2 -lwsock32 -DPTW32_STATIC_LIB" "pthread_create(0,0,0,0);" ; then
|
|
libpthread="-lpthreadGC2 -lwsock32"
|
|
define PTW32_STATIC_LIB
|
|
elif cc_check pthread.h "-lpthreadGC2 -lws2_32 -DPTW32_STATIC_LIB" "pthread_create(0,0,0,0);" ; then
|
|
libpthread="-lpthreadGC2 -lws2_32"
|
|
define PTW32_STATIC_LIB
|
|
else
|
|
thread="no"
|
|
fi
|
|
elif [ "$thread" != "no" ] ; then
|
|
thread="no"
|
|
case $SYS in
|
|
BEOS)
|
|
thread="beos"
|
|
define HAVE_BEOSTHREAD
|
|
;;
|
|
WINDOWS)
|
|
thread="win32"
|
|
define HAVE_WIN32THREAD
|
|
;;
|
|
QNX)
|
|
cc_check pthread.h -lc "pthread_create(0,0,0,0);" && thread="posix" && libpthread="-lc"
|
|
;;
|
|
*)
|
|
if cc_check pthread.h -lpthread "pthread_create(0,0,0,0);" ; then
|
|
thread="posix"
|
|
libpthread="-lpthread"
|
|
else
|
|
cc_check pthread.h "" "pthread_create(0,0,0,0);" && thread="posix" && libpthread=""
|
|
fi
|
|
;;
|
|
esac
|
|
fi
|
|
if [ "$thread" = "posix" ]; then
|
|
LDFLAGS="$LDFLAGS $libpthread"
|
|
define HAVE_POSIXTHREAD
|
|
if [ "$SYS" = "LINUX" ] && cc_check sched.h "-D_GNU_SOURCE -Werror" "cpu_set_t p_aff; return CPU_COUNT(&p_aff);" ; then
|
|
define HAVE_CPU_COUNT
|
|
fi
|
|
fi
|
|
[ "$thread" != "no" ] && define HAVE_THREAD
|
|
|
|
if cc_check '' '' 'int *val; __sync_fetch_and_add(&val, 1);' ; then
|
|
define HAVE_SYNC_FETCH_AND_ADD
|
|
fi
|
|
|
|
if cc_check 'math.h' '' 'volatile float x = 2; return log2f(x);' ; then
|
|
define HAVE_LOG2F
|
|
fi
|
|
|
|
if cc_check 'string.h' '' 'strtok_r(0, 0, 0);' ; then
|
|
define HAVE_STRTOK_R
|
|
fi
|
|
|
|
if cc_check 'time.h' '' 'clock_gettime(CLOCK_MONOTONIC, 0);' ; then
|
|
define HAVE_CLOCK_GETTIME
|
|
elif cc_check 'time.h' '-lrt' 'clock_gettime(CLOCK_MONOTONIC, 0);' ; then
|
|
define HAVE_CLOCK_GETTIME
|
|
LDFLAGS="$LDFLAGS -lrt"
|
|
fi
|
|
|
|
if cc_check 'sys/auxv.h' '' 'getauxval(AT_HWCAP);' ; then
|
|
define HAVE_GETAUXVAL
|
|
fi
|
|
|
|
if cc_check 'sys/auxv.h' '' 'unsigned long auxv = 0; elf_aux_info(AT_HWCAP, &auxv, sizeof(auxv));' ; then
|
|
define HAVE_ELF_AUX_INFO
|
|
fi
|
|
|
|
if cc_check 'unistd.h' '' 'sysconf(0);' ; then
|
|
define HAVE_SYSCONF
|
|
fi
|
|
|
|
if [ "$SYS" != "WINDOWS" ] && cpp_check "sys/mman.h unistd.h" "" "defined(MAP_PRIVATE)"; then
|
|
define HAVE_MMAP
|
|
fi
|
|
|
|
if [ "$SYS" = "LINUX" -a \( "$ARCH" = "X86" -o "$ARCH" = "X86_64" \) ] && cc_check "sys/mman.h" "" "MADV_HUGEPAGE;" ; then
|
|
define HAVE_THP
|
|
fi
|
|
|
|
if [ "$cli" = "no" ] ; then
|
|
avs="no"
|
|
lavf="no"
|
|
ffms="no"
|
|
gpac="no"
|
|
lsmash="no"
|
|
mp4="no"
|
|
swscale="no"
|
|
fi
|
|
|
|
if [ "$swscale" = "auto" ] ; then
|
|
swscale="no"
|
|
if pkg_check 'libswscale libavutil' ; then
|
|
SWSCALE_LIBS="$SWSCALE_LIBS $($PKGCONFIG --libs libswscale libavutil)"
|
|
SWSCALE_CFLAGS="$SWSCALE_CFLAGS $($PKGCONFIG --cflags libswscale libavutil)"
|
|
fi
|
|
[ -z "$SWSCALE_LIBS" ] && SWSCALE_LIBS="-lswscale -lavutil"
|
|
|
|
if cc_check "libswscale/swscale.h" "$SWSCALE_CFLAGS $SWSCALE_LIBS" "sws_init_context(0,0,0);" ; then
|
|
if cc_check "libavutil/pixdesc.h" "$SWSCALE_CFLAGS $SWSCALE_LIBS" "AVComponentDescriptor x; x.depth = 8;" ; then
|
|
swscale="yes"
|
|
else
|
|
echo "Warning: libswscale is too old"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
if [ "$lavf" = "auto" ] ; then
|
|
lavf="no"
|
|
if pkg_check 'libavformat libavcodec libavutil' ; then
|
|
LAVF_LIBS="$LAVF_LIBS $($PKGCONFIG --libs libavformat libavcodec libavutil)"
|
|
LAVF_CFLAGS="$LAVF_CFLAGS $($PKGCONFIG --cflags libavformat libavcodec libavutil)"
|
|
fi
|
|
if [ -z "$LAVF_LIBS" ] && cc_check '' -lavformat ; then
|
|
LAVF_LIBS="-lavformat"
|
|
for lib in -lavcodec -lavresample -lswresample -lavutil -lbz2 -lz $libpthread -lole32 -luser32 -lws2_32 -lsecur32 ; do
|
|
cc_check "" $lib && LAVF_LIBS="$LAVF_LIBS $lib"
|
|
done
|
|
fi
|
|
|
|
if cc_check libavformat/avformat.h "$LAVF_CFLAGS $LAVF_LIBS" "av_demuxer_iterate(0);" ; then
|
|
if cc_check libavcodec/avcodec.h "$LAVF_CFLAGS $LAVF_LIBS" "avcodec_send_packet(0,0);" ; then
|
|
lavf="yes"
|
|
else
|
|
echo "Warning: libavformat is too old"
|
|
fi
|
|
fi
|
|
if [ "$lavf" = "yes" -a "$swscale" = "no" ]; then
|
|
echo "Warning: libavformat is not supported without swscale support"
|
|
lavf="no"
|
|
fi
|
|
fi
|
|
|
|
if [ "$ffms" = "auto" ] ; then
|
|
ffms_major="2"; ffms_minor="21"; ffms_micro="0"; ffms_bump="0"
|
|
ffms="no"
|
|
|
|
if pkg_check ffms2 ; then
|
|
FFMS2_LIBS="$FFMS2_LIBS $($PKGCONFIG --libs ffms2)"
|
|
FFMS2_CFLAGS="$FFMS2_CFLAGS $($PKGCONFIG --cflags ffms2)"
|
|
fi
|
|
[ -z "$FFMS2_LIBS" ] && FFMS2_LIBS="-lffms2"
|
|
|
|
if cc_check ffms.h "$FFMS2_CFLAGS $FFMS2_LIBS" "FFMS_DestroyVideoSource(0);" ; then
|
|
ffms="yes"
|
|
elif cc_check ffms.h "$FFMS2_CFLAGS $FFMS2_LIBS -lstdc++ $LAVF_LIBS" "FFMS_DestroyVideoSource(0);" ; then
|
|
ffms="yes"
|
|
FFMS2_LIBS="$FFMS2_LIBS -lstdc++ $LAVF_LIBS"
|
|
fi
|
|
|
|
error="ffms must be at least version $ffms_major.$ffms_minor.$ffms_micro.$ffms_bump"
|
|
if [ $ffms = "yes" ] && ! cpp_check "ffms.h" "$FFMS2_CFLAGS" "FFMS_VERSION >= (($ffms_major << 24) | ($ffms_minor << 16) | ($ffms_micro << 8) | $ffms_bump)" "$error"; then
|
|
ffms="no"
|
|
echo "Warning: $error"
|
|
fi
|
|
if [ "$ffms" = "yes" -a "$swscale" = "no" ]; then
|
|
echo "Warning: ffms is not supported without swscale support"
|
|
ffms="no"
|
|
fi
|
|
fi
|
|
|
|
if [ "$swscale" = "yes" ]; then
|
|
LDFLAGSCLI="$SWSCALE_LIBS $LDFLAGSCLI"
|
|
CFLAGS="$CFLAGS $SWSCALE_CFLAGS"
|
|
define HAVE_SWSCALE
|
|
if [ "$lavf" = "yes" ]; then
|
|
LDFLAGSCLI="$LAVF_LIBS $LDFLAGSCLI"
|
|
CFLAGS="$CFLAGS $LAVF_CFLAGS"
|
|
define HAVE_LAVF
|
|
fi
|
|
if [ "$ffms" = "yes" ]; then
|
|
LDFLAGSCLI="$FFMS2_LIBS $LDFLAGSCLI"
|
|
CFLAGS="$CFLAGS $FFMS2_CFLAGS"
|
|
define HAVE_FFMS
|
|
fi
|
|
fi
|
|
|
|
if [ "$lsmash" = "auto" ] ; then
|
|
lsmash="no"
|
|
if pkg_check liblsmash ; then
|
|
LSMASH_LIBS="$LSMASH_LIBS $($PKGCONFIG --libs liblsmash)"
|
|
LSMASH_CFLAGS="$LSMASH_CFLAGS $($PKGCONFIG --cflags liblsmash)"
|
|
fi
|
|
[ -z "$LSMASH_LIBS" ] && LSMASH_LIBS="-llsmash"
|
|
|
|
if cc_check lsmash.h "$LSMASH_CFLAGS $LSMASH_LIBS" "lsmash_destroy_root(0);" ; then
|
|
if cpp_check lsmash.h "$LSMASH_CFLAGS" "LSMASH_VERSION_MAJOR > 1 || (LSMASH_VERSION_MAJOR == 1 && LSMASH_VERSION_MINOR >= 5)" ; then
|
|
lsmash="yes"
|
|
else
|
|
echo "Warning: lsmash is too old, update to rev.895 or later"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
if [ "$gpac" = "auto" -a "$lsmash" != "yes" ] ; then
|
|
gpac="no"
|
|
if pkg_check gpac ; then
|
|
GPAC_LIBS_TMP="$GPAC_LIBS $($PKGCONFIG --libs gpac)"
|
|
GPAC_CFLAGS_TMP="$GPAC_CFLAGS $($PKGCONFIG --cflags gpac)"
|
|
if cc_check gpac/isomedia.h "$GPAC_CFLAGS_TMP $GPAC_LIBS_TMP" "gf_isom_close(0);" ; then
|
|
GPAC_LIBS="$GPAC_LIBS_TMP"
|
|
GPAC_CFLAGS="$GPAC_CFLAGS_TMP"
|
|
else
|
|
GPAC_LIBS_TMP="$GPAC_LIBS $($PKGCONFIG --static --libs gpac | sed 's/-lgpac //')"
|
|
GPAC_CFLAGS_TMP="$GPAC_CFLAGS $($PKGCONFIG --static --cflags gpac)"
|
|
if cc_check gpac/isomedia.h "$GPAC_CFLAGS_TMP $GPAC_LIBS_TMP" "gf_isom_close(0);" ; then
|
|
GPAC_LIBS="$GPAC_LIBS_TMP"
|
|
GPAC_CFLAGS="$GPAC_CFLAGS_TMP"
|
|
fi
|
|
fi
|
|
fi
|
|
if [ -z "$GPAC_LIBS" ] ; then
|
|
GPAC_LIBS="-lgpac_static"
|
|
cc_check "" -lz && GPAC_LIBS="$GPAC_LIBS -lz"
|
|
cc_check "" -ldl && GPAC_LIBS="$GPAC_LIBS -ldl"
|
|
if [ "$SYS" = "WINDOWS" ] ; then
|
|
cc_check "" -lws2_32 && GPAC_LIBS="$GPAC_LIBS -lws2_32"
|
|
cc_check "" -lwinmm && GPAC_LIBS="$GPAC_LIBS -lwinmm"
|
|
fi
|
|
fi
|
|
if cc_check gpac/isomedia.h "$GPAC_CFLAGS $GPAC_LIBS" "gf_isom_close(0);" ; then
|
|
if cc_check gpac/isomedia.h "$GPAC_CFLAGS $GPAC_LIBS" "gf_isom_set_pixel_aspect_ratio(0,0,0,0,0,0);" ; then
|
|
gpac="yes"
|
|
else
|
|
echo "Warning: gpac is too old, update to v0.8.0 or later"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
if [ "$lsmash" = "yes" ] ; then
|
|
mp4="lsmash"
|
|
LDFLAGSCLI="$LSMASH_LIBS $LDFLAGSCLI"
|
|
CFLAGS="$CFLAGS $LSMASH_CFLAGS"
|
|
define HAVE_LSMASH
|
|
elif [ "$gpac" = "yes" ] ; then
|
|
mp4="gpac"
|
|
LDFLAGSCLI="$GPAC_LIBS $LDFLAGSCLI"
|
|
CFLAGS="$CFLAGS $GPAC_CFLAGS"
|
|
define HAVE_GPAC
|
|
fi
|
|
|
|
if [ "$avs" = "auto" ] ; then
|
|
avs="no"
|
|
# cygwin can use avisynth if it can use LoadLibrary
|
|
if [ $SYS = WINDOWS ] || ([ $SYS = CYGWIN ] && cc_check windows.h "" "LoadLibraryW(0);") ; then
|
|
avs="yes"
|
|
define HAVE_AVS
|
|
elif [ "$SYS" = "LINUX" -o "$SYS" = "MACOSX" ] ; then
|
|
avs="yes"
|
|
define HAVE_AVS
|
|
AVS_LIBS="-ldl"
|
|
LDFLAGSCLI="$AVS_LIBS $LDFLAGSCLI"
|
|
elif [ "$SYS" = "DRAGONFLY" -o "$SYS" = "FREEBSD" -o "$SYS" = "NETBSD" -o "$SYS" = "OPENBSD" -o "$SYS" = "HAIKU" ] ; then
|
|
avs="yes"
|
|
define HAVE_AVS
|
|
# dlopen is exported from libc on both *BSD and Haiku
|
|
fi
|
|
fi
|
|
|
|
cc_check "stdint.h" "" "uint32_t test_vec __attribute__ ((vector_size (16))) = {0,1,2,3};" && define HAVE_VECTOREXT
|
|
|
|
if [ "$pic" = "yes" ] ; then
|
|
[ "$SYS" != WINDOWS -a "$SYS" != CYGWIN ] && CFLAGS="$CFLAGS -fPIC"
|
|
[[ "$ASFLAGS" != *"-DPIC"* ]] && ASFLAGS="$ASFLAGS -DPIC"
|
|
# resolve textrels in the x86 asm
|
|
cc_check stdio.h "-shared -Wl,-Bsymbolic" && SOFLAGS="$SOFLAGS -Wl,-Bsymbolic"
|
|
[ $SYS = SunOS -a "$ARCH" = "X86" ] && SOFLAGS="$SOFLAGS -mimpure-text"
|
|
fi
|
|
|
|
if [ "$debug" != "yes" -a "$gprof" != "yes" ]; then
|
|
CFLAGS="$CFLAGS -fomit-frame-pointer"
|
|
fi
|
|
|
|
if [ "$strip" = "yes" ]; then
|
|
LDFLAGS="$LDFLAGS -s"
|
|
fi
|
|
|
|
if [ "$debug" = "yes" ]; then
|
|
CFLAGS="-O1 -g $CFLAGS"
|
|
RCFLAGS="$RCFLAGS -DDEBUG"
|
|
else
|
|
CFLAGS="-O3 -ffast-math $CFLAGS"
|
|
if [ "$lto" = "auto" ] && [ $compiler = GNU ] && cc_check "" "-flto" ; then
|
|
lto="yes"
|
|
CFLAGS="$CFLAGS -flto"
|
|
LDFLAGS="$LDFLAGS -O3 -flto"
|
|
fi
|
|
fi
|
|
[ "$lto" = "auto" ] && lto="no"
|
|
|
|
if cc_check '' -fno-tree-vectorize ; then
|
|
CFLAGS="$CFLAGS -fno-tree-vectorize"
|
|
fi
|
|
|
|
if [ $SYS = WINDOWS -a $ARCH = X86 -a $compiler = GNU ] ; then
|
|
# workaround gcc/ld bug with alignment of static variables/arrays that are initialized to zero
|
|
cc_check '' -fno-zero-initialized-in-bss && CFLAGS="$CFLAGS -fno-zero-initialized-in-bss"
|
|
fi
|
|
|
|
if cc_check "stdio.h" "-D_LARGEFILE_SOURCE=1 -D_FILE_OFFSET_BITS=64" "fseeko(stdin,0,0);" ; then
|
|
define fseek fseeko
|
|
define ftell ftello
|
|
elif cc_check "stdio.h" "" "fseeko64(stdin,0,0);" ; then
|
|
define fseek fseeko64
|
|
define ftell ftello64
|
|
elif cc_check "stdio.h" "" "_fseeki64(stdin,0,0);" ; then
|
|
define fseek _fseeki64
|
|
define ftell _ftelli64
|
|
fi
|
|
|
|
if cc_check '' -Wshadow ; then
|
|
CFLAGS="-Wshadow $CFLAGS"
|
|
fi
|
|
|
|
if cc_check '' -Wmaybe-uninitialized ; then
|
|
CFLAGS="-Wno-maybe-uninitialized $CFLAGS"
|
|
fi
|
|
|
|
if [ $compiler = GNU ] && cc_check '' -fvisibility=hidden ; then
|
|
CFLAGS="$CFLAGS -fvisibility=hidden"
|
|
fi
|
|
|
|
if [ $compiler = ICC -o $compiler = ICL ] ; then
|
|
if cc_check 'extras/intel_dispatcher.h' '' 'x264_intel_dispatcher_override();' ; then
|
|
define HAVE_INTEL_DISPATCHER
|
|
fi
|
|
fi
|
|
|
|
if [ "$bit_depth" = "all" ]; then
|
|
define HAVE_BITDEPTH8
|
|
define HAVE_BITDEPTH10
|
|
elif [ "$bit_depth" -eq "8" ]; then
|
|
define HAVE_BITDEPTH8
|
|
elif [ "$bit_depth" -eq "10" ]; then
|
|
define HAVE_BITDEPTH10
|
|
opencl="no"
|
|
fi
|
|
|
|
if [ "$chroma_format" != "all" ]; then
|
|
define CHROMA_FORMAT CHROMA_$chroma_format
|
|
fi
|
|
|
|
[ $gpl = yes ] && define HAVE_GPL && x264_gpl=1 || x264_gpl=0
|
|
|
|
[ $interlaced = yes ] && define HAVE_INTERLACED && x264_interlaced=1 || x264_interlaced=0
|
|
|
|
libdl=""
|
|
if [ "$opencl" = "yes" ]; then
|
|
opencl="no"
|
|
# cygwin can use opencl if it can use LoadLibrary
|
|
if [ $SYS = WINDOWS ] || ([ $SYS = CYGWIN ] && cc_check windows.h "" "LoadLibraryW(0);") ; then
|
|
opencl="yes"
|
|
define HAVE_OPENCL "(BIT_DEPTH==8)"
|
|
elif [ "$SYS" = "LINUX" -o "$SYS" = "MACOSX" ] ; then
|
|
opencl="yes"
|
|
define HAVE_OPENCL "(BIT_DEPTH==8)"
|
|
libdl="-ldl"
|
|
fi
|
|
LDFLAGS="$LDFLAGS $libdl"
|
|
fi
|
|
|
|
#define undefined vars as 0
|
|
for var in $CONFIG_HAVE; do
|
|
grep -q "HAVE_$var " config.h || define HAVE_$var 0
|
|
done
|
|
|
|
# generate exported config file
|
|
|
|
[ "$bit_depth" = "all" ] && config_bit_depth="0" || config_bit_depth="$bit_depth"
|
|
[ "$chroma_format" = "all" ] && config_chroma_format="0" || config_chroma_format="X264_CSP_I$chroma_format"
|
|
cat > x264_config.h << EOF
|
|
#define X264_GPL $x264_gpl
|
|
#define X264_INTERLACED $x264_interlaced
|
|
#define X264_BIT_DEPTH $config_bit_depth
|
|
#define X264_CHROMA_FORMAT $config_chroma_format
|
|
EOF
|
|
|
|
${SRCPATH}/version.sh >> x264_config.h
|
|
|
|
if [ "$shared" = "yes" ]; then
|
|
CFLAGSSO="$CFLAGSSO -DX264_API_EXPORTS"
|
|
fi
|
|
|
|
if [ "$cli_libx264" = "system" ] ; then
|
|
if [ "$shared" = "yes" ]; then
|
|
if [ "$SYS" = "WINDOWS" -o "$SYS" = "CYGWIN" ]; then
|
|
CLI_LIBX264='$(IMPLIBNAME)'
|
|
else
|
|
CLI_LIBX264='$(SONAME)'
|
|
fi
|
|
CFLAGSCLI="$CFLAGSCLI -DX264_API_IMPORTS"
|
|
else
|
|
CLI_LIBX264=
|
|
LDFLAGSCLI="$X264_LIBS $LDFLAGSCLI"
|
|
CFLAGSCLI="$CFLAGSCLI $X264_CFLAGS"
|
|
cc_check 'stdint.h x264.h' '' 'x264_encoder_open(0);' || die "System libx264 can't be used for compilation of this version"
|
|
fi
|
|
else
|
|
CLI_LIBX264='$(LIBX264)'
|
|
fi
|
|
|
|
if [ $compiler_style = MS ]; then
|
|
DEPFLAGS=""
|
|
DEPCMD='@$(SRCPATH)/tools/msvsdepend.sh "$(CC)" "$(CFLAGS)" "$<" "$@" > $(@:.o=.d)'
|
|
AR="lib.exe -nologo -out:"
|
|
LD="link.exe -out:"
|
|
if [ $compiler = ICL ]; then
|
|
AR="xi$AR"
|
|
LD="xi$LD"
|
|
else
|
|
mslink="$(dirname "$(command -v cl.exe 2>/dev/null)")/link.exe"
|
|
[ -x "$mslink" ] && LD="\"$mslink\" -out:"
|
|
fi
|
|
HAVE_GETOPT_LONG=0
|
|
LDFLAGS="-nologo -incremental:no $(cl_ldflags $LDFLAGS)"
|
|
LDFLAGSCLI="$(cl_ldflags $LDFLAGSCLI)"
|
|
LIBX264=libx264.lib
|
|
RANLIB=
|
|
[ -n "$RC" ] && RCFLAGS="$RCFLAGS -nologo -I. -I\$(SRCPATH)/extras -fo"
|
|
STRIP=
|
|
if [ $debug = yes ]; then
|
|
LDFLAGS="-debug $LDFLAGS"
|
|
CFLAGS="-D_DEBUG $CFLAGS"
|
|
else
|
|
CFLAGS="-DNDEBUG $CFLAGS"
|
|
fi
|
|
else # gcc/icc
|
|
DEPFLAGS="${QPRE}MMD ${QPRE}MF"' $(@:.o=.d)'
|
|
DEPCMD=""
|
|
AR="$AR rc "
|
|
LD="$CC -o "
|
|
LIBX264=libx264.a
|
|
[ -n "$RC" ] && RCFLAGS="$RCFLAGS -I. -o "
|
|
fi
|
|
if [ $compiler != GNU ]; then
|
|
CFLAGS="$(cc_cflags $CFLAGS)"
|
|
CFLAGSSO="$(cc_cflags $CFLAGSSO)"
|
|
CFLAGSCLI="$(cc_cflags $CFLAGSCLI)"
|
|
fi
|
|
if [ $compiler = ICC -o $compiler = ICL ]; then
|
|
# icc does not define __SSE__ until SSE2 optimization and icl never defines it or _M_IX86_FP
|
|
[ \( $ARCH = X86_64 -o $ARCH = X86 \) -a $asm = yes ] && ! cpp_check "" "" "defined(__SSE__)" && define __SSE__
|
|
PROF_GEN_CC="${QPRE}prof-gen ${QPRE}prof-dir."
|
|
PROF_GEN_LD=
|
|
PROF_USE_CC="${QPRE}prof-use ${QPRE}prof-dir."
|
|
PROF_USE_LD=
|
|
elif [ $compiler = CL ]; then
|
|
# Visual Studio
|
|
# _M_IX86_FP is only defined on x86
|
|
[ $ARCH = X86 ] && cpp_check '' '' '_M_IX86_FP >= 1' && define __SSE__
|
|
[ $ARCH = X86_64 ] && define __SSE__
|
|
# As long as the cli application can't link against the dll, the dll can not be pgo'd.
|
|
# pgds are link flag specific and the -dll flag for creating the dll makes it unshareable with the cli
|
|
PROF_GEN_CC="-GL"
|
|
PROF_GEN_LD="-LTCG:PGINSTRUMENT"
|
|
PROF_USE_CC="-GL"
|
|
PROF_USE_LD="-LTCG:PGOPTIMIZE"
|
|
else
|
|
PROF_GEN_CC="-fprofile-generate"
|
|
PROF_GEN_LD="-fprofile-generate"
|
|
PROF_USE_CC="-fprofile-use"
|
|
PROF_USE_LD="-fprofile-use"
|
|
fi
|
|
|
|
# generate config files
|
|
|
|
cat > config.mak << EOF
|
|
SRCPATH=$SRCPATH
|
|
prefix=$prefix
|
|
exec_prefix=$exec_prefix
|
|
bindir=$bindir
|
|
libdir=$libdir
|
|
includedir=$includedir
|
|
SYS_ARCH=$ARCH
|
|
SYS=$SYS
|
|
CC=$CC
|
|
CFLAGS=$CFLAGS
|
|
CFLAGSSO=$CFLAGSSO
|
|
CFLAGSCLI=$CFLAGSCLI
|
|
COMPILER=$compiler
|
|
COMPILER_STYLE=$compiler_style
|
|
DEPCMD=$DEPCMD
|
|
DEPFLAGS=$DEPFLAGS
|
|
LD=$LD
|
|
LDFLAGS=$LDFLAGS
|
|
LDFLAGSCLI=$LDFLAGSCLI
|
|
LIBX264=$LIBX264
|
|
CLI_LIBX264=$CLI_LIBX264
|
|
AR=$AR
|
|
RANLIB=$RANLIB
|
|
STRIP=$STRIP
|
|
INSTALL=$INSTALL
|
|
AS=$AS
|
|
ASFLAGS=$ASFLAGS
|
|
RC=$RC
|
|
RCFLAGS=$RCFLAGS
|
|
EXE=$EXE
|
|
HAVE_GETOPT_LONG=$HAVE_GETOPT_LONG
|
|
DEVNULL=$DEVNULL
|
|
PROF_GEN_CC=$PROF_GEN_CC
|
|
PROF_GEN_LD=$PROF_GEN_LD
|
|
PROF_USE_CC=$PROF_USE_CC
|
|
PROF_USE_LD=$PROF_USE_LD
|
|
HAVE_OPENCL=$opencl
|
|
EOF
|
|
|
|
if [ $compiler_style = MS ]; then
|
|
echo 'CC_O=-Fo$@' >> config.mak
|
|
else
|
|
echo 'CC_O=-o $@' >> config.mak
|
|
fi
|
|
|
|
if [ "$cli" = "yes" ]; then
|
|
echo 'default: cli' >> config.mak
|
|
echo 'install: install-cli' >> config.mak
|
|
fi
|
|
|
|
if [ "$shared" = "yes" ]; then
|
|
API=$(grep '#define X264_BUILD' < ${SRCPATH}/x264.h | cut -f 3 -d ' ')
|
|
if [ "$SYS" = "WINDOWS" -o "$SYS" = "CYGWIN" ]; then
|
|
echo "SONAME=libx264-$API.dll" >> config.mak
|
|
if [ $compiler_style = MS ]; then
|
|
echo 'IMPLIBNAME=libx264.dll.lib' >> config.mak
|
|
echo "SOFLAGS=-dll -implib:\$(IMPLIBNAME) $SOFLAGS" >> config.mak
|
|
else
|
|
echo 'IMPLIBNAME=libx264.dll.a' >> config.mak
|
|
echo "SOFLAGS=-shared -Wl,--out-implib,\$(IMPLIBNAME) $SOFLAGS" >> config.mak
|
|
fi
|
|
elif [ "$SYS" = "MACOSX" ]; then
|
|
echo "SOSUFFIX=dylib" >> config.mak
|
|
echo "SONAME=libx264.$API.dylib" >> config.mak
|
|
echo "SOFLAGS=-shared -dynamiclib -Wl,-single_module -Wl,-read_only_relocs,suppress -install_name \$(DESTDIR)\$(libdir)/\$(SONAME) $SOFLAGS" >> config.mak
|
|
elif [ "$SYS" = "SunOS" ]; then
|
|
echo "SOSUFFIX=so" >> config.mak
|
|
echo "SONAME=libx264.so.$API" >> config.mak
|
|
echo "SOFLAGS=-shared -Wl,-h,\$(SONAME) $SOFLAGS" >> config.mak
|
|
else
|
|
echo "SOSUFFIX=so" >> config.mak
|
|
echo "SONAME=libx264.so.$API" >> config.mak
|
|
echo "SOFLAGS=-shared -Wl,-soname,\$(SONAME) $SOFLAGS" >> config.mak
|
|
fi
|
|
echo 'default: lib-shared' >> config.mak
|
|
echo 'install: install-lib-shared' >> config.mak
|
|
fi
|
|
|
|
if [ "$static" = "yes" ]; then
|
|
echo 'default: lib-static' >> config.mak
|
|
echo 'install: install-lib-static' >> config.mak
|
|
fi
|
|
|
|
if [ "$bashcompletion" = "auto" ]; then
|
|
if [ "$cli" = "no" ]; then
|
|
bashcompletion="no"
|
|
elif [[ -z "$bashcompletionsdir" && "$prefix" != "/usr" && "$prefix" != "/usr/"* ]]; then
|
|
bashcompletion="no"
|
|
fi
|
|
fi
|
|
|
|
if [ "$bashcompletion" != "no" ]; then
|
|
if [ -z "$bashcompletionsdir" ] && pkg_check bash-completion ; then
|
|
bashcompletionsdir="$($PKGCONFIG --variable=completionsdir bash-completion)"
|
|
fi
|
|
if [ -n "$bashcompletionsdir" ]; then
|
|
bashcompletion="yes"
|
|
echo 'install: install-bashcompletion' >> config.mak
|
|
echo "BASHCOMPLETIONSDIR=$bashcompletionsdir" >> config.mak
|
|
else
|
|
bashcompletion="no"
|
|
fi
|
|
fi
|
|
|
|
cat > x264.pc << EOF
|
|
prefix=$prefix
|
|
exec_prefix=$exec_prefix
|
|
libdir=$libdir
|
|
includedir=$includedir
|
|
|
|
Name: x264
|
|
Description: H.264 (MPEG4 AVC) encoder library
|
|
Version: $(grep POINTVER < x264_config.h | sed -e 's/.* "//; s/".*//; s/ .*//')
|
|
Libs: -L$libdir -lx264 $([ "$shared" = "yes" ] || echo $libpthread $libm $libdl)
|
|
Libs.private: $([ "$shared" = "yes" ] && echo $libpthread $libm $libdl)
|
|
Cflags: -I$includedir $([ "$shared" = "yes" ] && echo "-DX264_API_IMPORTS")
|
|
EOF
|
|
|
|
filters="crop select_every"
|
|
[ $swscale = yes ] && filters="resize $filters"
|
|
|
|
cat > conftest.log <<EOF
|
|
platform: $ARCH
|
|
byte order: $CPU_ENDIAN
|
|
system: $SYS
|
|
cli: $cli
|
|
libx264: $cli_libx264
|
|
shared: $shared
|
|
static: $static
|
|
bashcompletion: $bashcompletion
|
|
asm: $asm
|
|
interlaced: $interlaced
|
|
avs: $avs
|
|
lavf: $lavf
|
|
ffms: $ffms
|
|
mp4: $mp4
|
|
gpl: $gpl
|
|
thread: $thread
|
|
opencl: $opencl
|
|
filters: $filters
|
|
lto: $lto
|
|
debug: $debug
|
|
gprof: $gprof
|
|
strip: $strip
|
|
PIC: $pic
|
|
bit depth: $bit_depth
|
|
chroma format: $chroma_format
|
|
EOF
|
|
|
|
echo >> config.log
|
|
cat conftest.log >> config.log
|
|
cat conftest.log
|
|
|
|
[ "$SRCPATH" != "." ] && ln -sf ${SRCPATH}/Makefile ./Makefile
|
|
mkdir -p common/{aarch64,arm,mips,ppc,x86,loongarch,riscv64} encoder extras filters/video input output tools
|
|
|
|
echo
|
|
echo "You can run 'make' or 'make fprofiled' now."
|
|
|