blob: a55db5e3a4070c61487eafd5dc4a55247654c8e1 [file] [log] [blame]
#!/bin/sh
## Copyright (c) 2023, Alliance for Open Media. All rights reserved.
##
## This source code is subject to the terms of the BSD 2 Clause License and
## the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
## was not distributed with this source code in the LICENSE file, you can
## obtain it at www.aomedia.org/license/software. If the Alliance for Open
## Media Patent License 1.0 was not distributed with this source code in the
## PATENTS file, you can obtain it at www.aomedia.org/license/patent.
##
## This script checks the bit exactness between C and SIMD
## implementations of AV1 encoder.
##
. $(dirname $0)/tools_common.sh
PRESETS="good rt"
LOWBD_CIF_CLIP="yuv_raw_input"
LOWBD_480p_CLIP="yuv_480p_raw_input"
LOWBD_720p_CLIP="y4m_720p_input"
HIGHBD_CLIP="y4m_360p_10bit_input"
SC_CLIP="y4m_screen_input"
OUT_FILE_SUFFIX=".ivf"
SCRIPT_DIR=$(dirname "$0")
LIBAOM_SOURCE_DIR=$(cd ${SCRIPT_DIR}/..; pwd)
# Clips used in test.
YUV_RAW_INPUT="${LIBAOM_TEST_DATA_PATH}/hantro_collage_w352h288.yuv"
YUV_480P_RAW_INPUT="${LIBAOM_TEST_DATA_PATH}/niklas_640_480_30.yuv"
Y4M_360P_10BIT_INPUT="${LIBAOM_TEST_DATA_PATH}/crowd_run_360p_10_150f.y4m"
Y4M_720P_INPUT="${LIBAOM_TEST_DATA_PATH}/niklas_1280_720_30.y4m"
Y4M_SCREEN_INPUT="${LIBAOM_TEST_DATA_PATH}/wikipedia_420_360p_60f.y4m"
# Number of frames to test.
AV1_ENCODE_C_VS_SIMD_TEST_FRAME_LIMIT=35
# Create a temporary directory for output files.
if [ -n "${TMPDIR}" ]; then
AOM_TEST_TEMP_ROOT="${TMPDIR}"
elif [ -n "${TEMPDIR}" ]; then
AOM_TEST_TEMP_ROOT="${TEMPDIR}"
else
AOM_TEST_TEMP_ROOT=/tmp
fi
AOM_TEST_OUTPUT_DIR="${AOM_TEST_TEMP_ROOT}/av1_test_$$"
if ! mkdir -p "${AOM_TEST_OUTPUT_DIR}" || \
[ ! -d "${AOM_TEST_OUTPUT_DIR}" ]; then
echo "${0##*/}: Cannot create output directory, giving up."
echo "${0##*/}: AOM_TEST_OUTPUT_DIR=${AOM_TEST_OUTPUT_DIR}"
exit 1
fi
elog() {
echo "$@" 1>&2
}
# Echoes path to $1 when it's executable and exists in ${AOM_TEST_OUTPUT_DIR},
# or an empty string. Caller is responsible for testing the string once the
# function returns.
av1_enc_tool_path() {
local target="$1"
local preset="$2"
local tool_path="${AOM_TEST_OUTPUT_DIR}/build_target_${target}/aomenc_${preset}"
if [ ! -x "${tool_path}" ]; then
tool_path=""
fi
echo "${tool_path}"
}
# Environment check: Make sure input and source directories are available.
av1_c_vs_simd_enc_verify_environment () {
if [ ! -e "${YUV_RAW_INPUT}" ]; then
elog "libaom test data must exist in LIBAOM_TEST_DATA_PATH."
return 1
fi
if [ ! -e "${Y4M_360P_10BIT_INPUT}" ]; then
elog "libaom test data must exist in LIBAOM_TEST_DATA_PATH."
return 1
fi
if [ ! -e "${YUV_480P_RAW_INPUT}" ]; then
elog "libaom test data must exist in LIBAOM_TEST_DATA_PATH."
return 1
fi
if [ ! -e "${Y4M_720P_INPUT}" ]; then
elog "libaom test data must exist in LIBAOM_TEST_DATA_PATH."
return 1
fi
if [ ! -e "${Y4M_SCREEN_INPUT}" ]; then
elog "libaom test data must exist in LIBAOM_TEST_DATA_PATH."
return 1
fi
if [ ! -d "$LIBAOM_SOURCE_DIR" ]; then
elog "LIBAOM_SOURCE_DIR does not exist."
return 1
fi
}
# This is not needed since tools_common.sh does the same cleanup.
# Keep the code here for our reference.
# cleanup() {
# rm -rf ${AOM_TEST_OUTPUT_DIR}
# }
# Echo AOM_SIMD_CAPS_MASK for different instruction set architecture.
avx2() {
echo "0x1FF"
}
avx() {
echo "0x17F"
}
sse4_2() {
echo "0x13F"
}
sse4_1() {
echo "0x03F"
}
ssse3() {
echo "0x01F"
}
sse3() {
echo "0x00F"
}
sse2() {
echo "0x007"
}
get_bitrates() {
local content=$1
local preset=$2
# Bit-rates:
local bitrate_lowres_good="300"
local bitrate_480p_good="500"
local bitrate_720p_good="1000"
local bitrate_scc_360p_good="500"
local bitrate_lowres_rt="200"
local bitrate_480p_rt="300"
local bitrate_720p_rt="600"
local bitrate_scc_360p_rt="300"
local bitrate_hbd_360p="500"
if [ "${preset}" = "good" ]; then
if [ "${content}" = "yuv_raw_input" ]; then
echo "${bitrate_lowres_good}"
elif [ "${content}" = "yuv_480p_raw_input" ]; then
echo "${bitrate_480p_good}"
elif [ "${content}" = "y4m_720p_input" ]; then
echo "${bitrate_720p_good}"
elif [ "${content}" = "y4m_screen_input" ]; then
echo "${bitrate_scc_360p_good}"
elif [ "${content}" = "y4m_360p_10bit_input" ]; then
echo "${bitrate_hbd_360p}"
else
elog "Invalid content"
fi
elif [ "${preset}" = "rt" ]; then
if [ "${content}" = "yuv_raw_input" ]; then
echo "${bitrate_lowres_rt}"
elif [ "${content}" = "yuv_480p_raw_input" ]; then
echo "${bitrate_480p_rt}"
elif [ "${content}" = "y4m_720p_input" ]; then
echo "${bitrate_720p_rt}"
elif [ "${content}" = "y4m_screen_input" ]; then
echo "${bitrate_scc_360p_rt}"
elif [ "${content}" = "y4m_360p_10bit_input" ]; then
echo "${bitrate_hbd_360p}"
else
elog "Invalid content"
fi
else
elog "invalid preset"
fi
}
# Echo clip details to be used as input to aomenc.
yuv_raw_input() {
echo ""${YUV_RAW_INPUT}"
--width=352
--height=288
--bit-depth=8"
}
y4m_360p_10bit_input() {
echo ""${Y4M_360P_10BIT_INPUT}"
--bit-depth=10"
}
yuv_480p_raw_input() {
echo ""${YUV_480P_RAW_INPUT}"
--width=640
--height=480
--bit-depth=8"
}
y4m_720p_input() {
echo ""${Y4M_720P_INPUT}"
--bit-depth=8"
}
y4m_screen_input() {
echo ""${Y4M_SCREEN_INPUT}"
--tune-content=screen
--enable-palette=1
--bit-depth=8"
}
has_x86_isa_extn() {
instruction_set=$1
if ! grep -q "$instruction_set" /proc/cpuinfo; then
# This instruction set is not supported.
return 1
fi
}
# Echo good encode params for use with AV1 encoder.
av1_encode_good_params() {
echo "--good \
--ivf \
--profile=0 \
--static-thresh=0 \
--threads=1 \
--tile-columns=0 \
--tile-rows=0 \
--verbose \
--end-usage=vbr \
--kf-max-dist=160 \
--kf-min-dist=0 \
--max-q=63 \
--min-q=0 \
--overshoot-pct=100 \
--undershoot-pct=100 \
--passes=2 \
--arnr-maxframes=7 \
--arnr-strength=5 \
--auto-alt-ref=1 \
--drop-frame=0 \
--frame-parallel=0 \
--lag-in-frames=35 \
--maxsection-pct=2000 \
--minsection-pct=0 \
--sharpness=0"
}
# Echo realtime encode params for use with AV1 encoder.
av1_encode_rt_params() {
echo "--rt \
--ivf \
--profile=0 \
--static-thresh=0 \
--threads=1 \
--tile-columns=0 \
--tile-rows=0 \
--verbose \
--end-usage=cbr \
--kf-max-dist=90000 \
--max-q=58 \
--min-q=2 \
--overshoot-pct=50 \
--undershoot-pct=50 \
--passes=1 \
--aq-mode=3 \
--buf-initial-sz=500 \
--buf-optimal-sz=600 \
--buf-sz=1000 \
--coeff-cost-upd-freq=3 \
--dv-cost-upd-freq=3 \
--mode-cost-upd-freq=3 \
--mv-cost-upd-freq=3 \
--deltaq-mode=0 \
--enable-global-motion=0 \
--enable-obmc=0 \
--enable-order-hint=0 \
--enable-ref-frame-mvs=0 \
--enable-tpl-model=0 \
--enable-warped-motion=0 \
--lag-in-frames=0 \
--max-intra-rate=300 \
--noise-sensitivity=0"
}
# Configures for the given target in AOM_TEST_OUTPUT_DIR/build_target_${target}
# directory.
av1_enc_build() {
local target="$1"
local cmake_command="$2"
local tmp_build_dir=${AOM_TEST_OUTPUT_DIR}/build_target_${target}
if [ -d "$tmp_build_dir" ]; then
rm -rf $tmp_build_dir
fi
mkdir -p $tmp_build_dir
cd $tmp_build_dir
local cmake_common_args="-DCONFIG_EXCLUDE_SIMD_MISMATCH=1 \
-DCMAKE_BUILD_TYPE=Release \
-DENABLE_CCACHE=1 \
'-DCMAKE_C_FLAGS_RELEASE=-O3 -g' \
'-DCMAKE_CXX_FLAGS_RELEASE=-O3 -g' \
-DENABLE_DOCS=0 -DENABLE_TESTS=0 -DENABLE_TOOLS=0"
for preset in $PRESETS; do
echo "Building target[${preset} encoding]: ${target}"
if [ "${preset}" = "good" ]; then
local cmake_extra_args="-DCONFIG_AV1_HIGHBITDEPTH=1"
elif [ "${preset}" = "rt" ]; then
local cmake_extra_args="-DCONFIG_REALTIME_ONLY=1 -DCONFIG_AV1_HIGHBITDEPTH=0"
else
elog "Invalid preset"
return 1
fi
if ! eval "$cmake_command" "${cmake_common_args}" "${cmake_extra_args}" \
${devnull}; then
elog "cmake failure"
return 1
fi
if ! eval make -j$(nproc) aomenc ${devnull}; then
elog "build failure"
return 1
fi
mv aomenc aomenc_${preset}
done
echo "Done building target: ${target}"
}
compare_enc_output() {
local target=$1
local cpu=$2
local clip=$3
local bitrate=$4
local preset=$5
if ! diff -q ${AOM_TEST_OUTPUT_DIR}/Out-generic-"${clip}"-${preset}-${bitrate}kbps-cpu${cpu}${OUT_FILE_SUFFIX} \
${AOM_TEST_OUTPUT_DIR}/Out-${target}-"${clip}"-${preset}-${bitrate}kbps-cpu${cpu}${OUT_FILE_SUFFIX}; then
elog "C vs ${target} encode mismatches for ${clip}, at ${bitrate} kbps, speed ${cpu}, ${preset} preset"
return 1
fi
}
av1_enc_test() {
local encoder="$1"
local arch="$2"
local target="$3"
local preset="$4"
if [ -z "$(av1_enc_tool_path "${target}" "${preset}")" ]; then
elog "aomenc_{preset} not found. It must exist in ${AOM_TEST_OUTPUT_DIR}/build_target_${target} path"
return 1
fi
if [ "${preset}" = "good" ]; then
if [ "${arch}" = "x86_64" ]; then
local min_cpu_used=0
local max_cpu_used=6
elif [ "${arch}" = "x86" ]; then
local min_cpu_used=2
local max_cpu_used=3
fi
local test_params=av1_encode_good_params
elif [ "${preset}" = "rt" ]; then
local min_cpu_used=5
local max_cpu_used=11
local test_params=av1_encode_rt_params
else
elog "Invalid preset"
return 1
fi
for cpu in $(seq $min_cpu_used $max_cpu_used); do
if [ "${preset}" = "good" ]; then
if [ "${arch}" = "x86_64" ]; then
if [ "${cpu}" -lt 2 ]; then
local test_clips="${LOWBD_CIF_CLIP} ${HIGHBD_CLIP}"
elif [ "${cpu}" -lt 5 ]; then
local test_clips="${LOWBD_480p_CLIP} ${HIGHBD_CLIP}"
else
local test_clips="${LOWBD_720p_CLIP} ${HIGHBD_CLIP}"
fi
elif [ "${arch}" = "x86" ]; then
local test_clips="${LOWBD_CIF_CLIP} ${HIGHBD_CLIP}"
elif [ "${arch}" = "arm64" ]; then
local test_clips="${LOWBD_CIF_CLIP} ${HIGHBD_CLIP}"
fi
elif [ "${preset}" = "rt" ]; then
if [ "${cpu}" -lt 8 ]; then
local test_clips="${LOWBD_CIF_CLIP} ${SC_CLIP}"
else
local test_clips="${LOWBD_480p_CLIP} ${SC_CLIP}"
fi
else
elog "Invalid preset"
return 1
fi
for clip in ${test_clips}; do
local test_bitrates=$(get_bitrates ${clip} ${preset})
for bitrate in ${test_bitrates}; do
eval "${encoder}" $($clip) $($test_params) \
"--limit=${AV1_ENCODE_C_VS_SIMD_TEST_FRAME_LIMIT}" \
"--cpu-used=${cpu}" "--target-bitrate=${bitrate}" "-o" \
${AOM_TEST_OUTPUT_DIR}/Out-${target}-"${clip}"-${preset}-${bitrate}kbps-cpu${cpu}${OUT_FILE_SUFFIX} \
${devnull}
if [ "${target}" != "generic" ]; then
if ! compare_enc_output ${target} $cpu ${clip} $bitrate ${preset}; then
# Found a mismatch
return 1
fi
fi
done
done
done
}
av1_test_generic() {
local arch=$1
local target="generic"
if [ $arch = "x86_64" ]; then
local cmake_command="cmake $LIBAOM_SOURCE_DIR -DAOM_TARGET_CPU=${target}"
elif [ $arch = "x86" ]; then
# As AV1 encode output differs for x86 32-bit and 64-bit platforms
# (BUG=aomedia:3479), the x86 32-bit C-only build is generated separately.
# The cmake command line option -DENABLE_MMX=0 flag disables all SIMD
# optimizations, and generates a C-only binary.
local cmake_command="cmake $LIBAOM_SOURCE_DIR -DENABLE_MMX=0 \
-DCMAKE_TOOLCHAIN_FILE=${LIBAOM_SOURCE_DIR}/build/cmake/toolchains/i686-linux-gcc.cmake"
fi
echo "Build for: Generic ${arch}"
if ! av1_enc_build "${target}" "${cmake_command}"; then
return 1
fi
for preset in $PRESETS; do
local encoder="$(av1_enc_tool_path "${target}" "${preset}")"
av1_enc_test $encoder "${arch}" "${target}" "${preset}"
done
}
# This function encodes AV1 bitstream by enabling SSE2, SSE3, SSSE3, SSE4_1, SSE4_2, AVX, AVX2 as
# there are no functions with MMX, SSE and AVX512 specialization.
# The value of environment variable 'AOM_SIMD_CAPS_MASK' controls enabling of different instruction
# set extension optimizations. The value of the flag 'AOM_SIMD_CAPS_MASK' and the corresponding
# instruction set extension optimization enabled are as follows:
# SSE4_2 AVX2 AVX SSE4_1 SSSE3 SSE3 SSE2 SSE MMX
# 1 1 1 1 1 1 1 1 1 -> 0x1FF -> Enable AVX2 and lower variants
# 1 0 1 1 1 1 1 1 1 -> 0x17F -> Enable AVX and lower variants
# 1 0 0 1 1 1 1 1 1 -> 0x13F -> Enable SSE4_2 and lower variants
# 0 0 0 1 1 1 1 1 1 -> 0x03F -> Enable SSE4_1 and lower variants
# 0 0 0 0 1 1 1 1 1 -> 0x01F -> Enable SSSE3 and lower variants
# 0 0 0 0 0 1 1 1 1 -> 0x00F -> Enable SSE3 and lower variants
# 0 0 0 0 0 0 1 1 1 -> 0x007 -> Enable SSE2 and lower variants
# 0 0 0 0 0 0 0 1 1 -> 0x003 -> Enable SSE and lower variants
# 0 0 0 0 0 0 0 0 1 -> 0x001 -> Enable MMX
## NOTE: In x86_64 platform, it is not possible to enable sse/mmx/c using "AOM_SIMD_CAPS_MASK" as
# all x86_64 platforms implement sse2.
av1_test_x86() {
local arch=$1
if ! uname -m | grep -q "x86"; then
elog "Machine architecture is not x86 or x86_64"
return 0
fi
if [ $arch = "x86" ]; then
local target="x86-linux"
local cmake_command="cmake \
$LIBAOM_SOURCE_DIR \
-DCMAKE_TOOLCHAIN_FILE=${LIBAOM_SOURCE_DIR}/build/cmake/toolchains/i686-linux-gcc.cmake"
elif [ $arch = "x86_64" ]; then
local target="x86_64-linux"
local cmake_command="cmake $LIBAOM_SOURCE_DIR"
fi
# Available x86 isa variants: "avx2 avx sse4_2 sse4_1 ssse3 sse3 sse2"
local x86_isa_variants="avx2 sse4_2 sse2"
echo "Build for x86: ${target}"
if ! av1_enc_build "${target}" "${cmake_command}"; then
return 1
fi
for preset in $PRESETS; do
local encoder="$(av1_enc_tool_path "${target}" "${preset}")"
for isa in $x86_isa_variants; do
# Note that if has_x86_isa_extn returns 1, it is false, and vice versa.
if ! has_x86_isa_extn $isa; then
echo "${isa} is not supported in this machine"
continue
fi
export AOM_SIMD_CAPS_MASK=$($isa)
if ! av1_enc_test $encoder "${arch}" "${target}" "${preset}"; then
# Found a mismatch
return 1
fi
unset AOM_SIMD_CAPS_MASK
done
done
}
av1_test_arm() {
local arch="arm64"
local target="arm64-linux-gcc"
local cmake_command="cmake $LIBAOM_SOURCE_DIR \
-DCMAKE_TOOLCHAIN_FILE=$LIBAOM_SOURCE_DIR/build/cmake/toolchains/${target}.cmake \
-DCMAKE_C_FLAGS=-Wno-maybe-uninitialized"
echo "Build for arm64: ${target}"
if ! av1_enc_build "${target}" "${cmake_command}"; then
return 1
fi
for preset in $PRESETS; do
local encoder="$(av1_enc_tool_path "${target}" "${preset}")"
if ! av1_enc_test "qemu-aarch64 -L /usr/aarch64-linux-gnu ${encoder}" "${arch}" "${target}" "${preset}"; then
# Found a mismatch
return 1
fi
done
}
av1_c_vs_simd_enc_test () {
# Test x86 (32 bit)
# x86 requires the i686-linux-gnu toolchain:
# $ sudo apt-get install g++-i686-linux-gnu
echo "av1 test for x86 (32 bit): Started."
# Encode 'C' only
av1_test_generic "x86"
# Encode with SIMD optimizations enabled
if ! av1_test_x86 "x86"; then
echo "av1 test for x86 (32 bit): Done, test failed."
return 1
else
echo "av1 test for x86 (32 bit): Done, all tests passed."
fi
# Test x86_64 (64 bit)
if [ "$(eval uname -m)" = "x86_64" ]; then
echo "av1 test for x86_64 (64 bit): Started."
# Encode 'C' only
av1_test_generic "x86_64"
# Encode with SIMD optimizations enabled
if ! av1_test_x86 "x86_64"; then
echo "av1 test for x86_64 (64 bit): Done, test failed."
return 1
else
echo "av1 test for x86_64 (64 bit): Done, all tests passed."
fi
fi
# Test ARM
echo "av1_test_arm: Started."
if ! av1_test_arm; then
echo "av1 test for arm: Done, test failed."
return 1
else
echo "av1 test for arm: Done, all tests passed."
fi
}
run_tests av1_c_vs_simd_enc_verify_environment av1_c_vs_simd_enc_test