Port renaming changes from AOMedia
Cherry-Picked the following commits:
0defd8f Changed "WebM" to "AOMedia" & "webm" to "aomedia"
54e6676 Replace "VPx" by "AVx"
5082a36 Change "Vpx" to "Avx"
7df44f1 Replace "Vp9" w/ "Av1"
967f722 Remove kVp9CodecId
828f30c Change "Vp8" to "AOM"
030b5ff AUTHORS regenerated
2524cae Add ref-mv experimental flag
016762b Change copyright notice to AOMedia form
81e5526 Replace vp9 w/ av1
9b94565 Add missing files
fa8ca9f Change "vp9" to "av1"
ec838b7 Convert "vp8" to "aom"
80edfa0 Change "VP9" to "AV1"
d1a11fb Change "vp8" to "aom"
7b58251 Point to WebM test data
dd1a5c8 Replace "VP8" with "AOM"
ff00fc0 Change "VPX" to "AOM"
01dee0b Change "vp10" to "av1" in source code
cebe6f0 Convert "vpx" to "aom"
17b0567 rename vp10*.mk to av1_*.mk
fe5f8a8 rename files vp10_* to av1_*
Change-Id: I6fc3d18eb11fc171e46140c836ad5339cf6c9419
diff --git a/test/acm_random.h b/test/acm_random.h
index aec4c6b..d57a9df 100644
--- a/test/acm_random.h
+++ b/test/acm_random.h
@@ -13,7 +13,7 @@
#include "third_party/googletest/src/include/gtest/gtest.h"
-#include "aom/vpx_integer.h"
+#include "aom/aom_integer.h"
namespace libaom_test {
diff --git a/test/active_map_refresh_test.cc b/test/active_map_refresh_test.cc
index 994d474..a04bd57 100644
--- a/test/active_map_refresh_test.cc
+++ b/test/active_map_refresh_test.cc
@@ -17,7 +17,7 @@
namespace {
// Check if any pixel in a 16x16 macroblock varies between frames.
-int CheckMb(const vpx_image_t ¤t, const vpx_image_t &previous, int mb_r,
+int CheckMb(const aom_image_t ¤t, const aom_image_t &previous, int mb_r,
int mb_c) {
for (int plane = 0; plane < 3; plane++) {
int r = 16 * mb_r;
@@ -45,8 +45,8 @@
return 0;
}
-void GenerateMap(int mb_rows, int mb_cols, const vpx_image_t ¤t,
- const vpx_image_t &previous, uint8_t *map) {
+void GenerateMap(int mb_rows, int mb_cols, const aom_image_t ¤t,
+ const aom_image_t &previous, uint8_t *map) {
for (int mb_r = 0; mb_r < mb_rows; ++mb_r) {
for (int mb_c = 0; mb_c < mb_cols; ++mb_c) {
map[mb_r * mb_cols + mb_c] = CheckMb(current, previous, mb_r, mb_c);
@@ -74,13 +74,13 @@
::libaom_test::Y4mVideoSource *y4m_video =
static_cast<libaom_test::Y4mVideoSource *>(video);
if (video->frame() == 1) {
- encoder->Control(VP8E_SET_CPUUSED, cpu_used_);
- encoder->Control(VP9E_SET_AQ_MODE, kAqModeCyclicRefresh);
+ encoder->Control(AOME_SET_CPUUSED, cpu_used_);
+ encoder->Control(AV1E_SET_AQ_MODE, kAqModeCyclicRefresh);
} else if (video->frame() >= 2 && video->img()) {
- vpx_image_t *current = video->img();
- vpx_image_t *previous = y4m_holder_->img();
+ aom_image_t *current = video->img();
+ aom_image_t *previous = y4m_holder_->img();
ASSERT_TRUE(previous != NULL);
- vpx_active_map_t map = vpx_active_map_t();
+ aom_active_map_t map = aom_active_map_t();
const int width = static_cast<int>(current->d_w);
const int height = static_cast<int>(current->d_h);
const int mb_width = (width + 15) / 16;
@@ -90,7 +90,7 @@
map.cols = mb_width;
map.rows = mb_height;
map.active_map = active_map;
- encoder->Control(VP8E_SET_ACTIVEMAP, &map);
+ encoder->Control(AOME_SET_ACTIVEMAP, &map);
delete[] active_map;
}
if (video->img()) {
@@ -109,15 +109,15 @@
cfg_.rc_resize_allowed = 0;
cfg_.rc_min_quantizer = 8;
cfg_.rc_max_quantizer = 30;
- cfg_.g_pass = VPX_RC_ONE_PASS;
- cfg_.rc_end_usage = VPX_CBR;
+ cfg_.g_pass = AOM_RC_ONE_PASS;
+ cfg_.rc_end_usage = AOM_CBR;
cfg_.kf_max_dist = 90000;
-#if CONFIG_VP10
- const int nframes = codec_ == &libaom_test::kVP10 ? 10 : 30;
+#if CONFIG_AV1
+ const int nframes = codec_ == &libaom_test::kAV1 ? 10 : 30;
#else
const int nframes = 30;
-#endif // CONFIG_VP10
+#endif // CONFIG_AV1
::libaom_test::Y4mVideoSource video("desktop_credits.y4m", 0, nframes);
::libaom_test::Y4mVideoSource video_holder("desktop_credits.y4m", 0, nframes);
video_holder.Begin();
@@ -126,9 +126,9 @@
ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
}
-#if CONFIG_VP10
-VP10_INSTANTIATE_TEST_CASE(ActiveMapRefreshTest,
- ::testing::Values(::libaom_test::kRealTime),
- ::testing::Range(5, 6));
-#endif // CONFIG_VP10
+#if CONFIG_AV1
+AV1_INSTANTIATE_TEST_CASE(ActiveMapRefreshTest,
+ ::testing::Values(::libaom_test::kRealTime),
+ ::testing::Range(5, 6));
+#endif // CONFIG_AV1
} // namespace
diff --git a/test/active_map_test.cc b/test/active_map_test.cc
index 35da706..717ed20 100644
--- a/test/active_map_test.cc
+++ b/test/active_map_test.cc
@@ -36,9 +36,9 @@
virtual void PreEncodeFrameHook(::libaom_test::VideoSource *video,
::libaom_test::Encoder *encoder) {
if (video->frame() == 1) {
- encoder->Control(VP8E_SET_CPUUSED, cpu_used_);
+ encoder->Control(AOME_SET_CPUUSED, cpu_used_);
} else if (video->frame() == 3) {
- vpx_active_map_t map = vpx_active_map_t();
+ aom_active_map_t map = aom_active_map_t();
/* clang-format off */
uint8_t active_map[9 * 13] = {
1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0,
@@ -57,13 +57,13 @@
ASSERT_EQ(map.cols, 13u);
ASSERT_EQ(map.rows, 9u);
map.active_map = active_map;
- encoder->Control(VP8E_SET_ACTIVEMAP, &map);
+ encoder->Control(AOME_SET_ACTIVEMAP, &map);
} else if (video->frame() == 15) {
- vpx_active_map_t map = vpx_active_map_t();
+ aom_active_map_t map = aom_active_map_t();
map.cols = (kWidth + 15) / 16;
map.rows = (kHeight + 15) / 16;
map.active_map = NULL;
- encoder->Control(VP8E_SET_ACTIVEMAP, &map);
+ encoder->Control(AOME_SET_ACTIVEMAP, &map);
}
}
@@ -72,8 +72,8 @@
cfg_.g_lag_in_frames = 0;
cfg_.rc_target_bitrate = 400;
cfg_.rc_resize_allowed = 0;
- cfg_.g_pass = VPX_RC_ONE_PASS;
- cfg_.rc_end_usage = VPX_CBR;
+ cfg_.g_pass = AOM_RC_ONE_PASS;
+ cfg_.rc_end_usage = AOM_CBR;
cfg_.kf_max_dist = 90000;
::libaom_test::I420VideoSource video("hantro_odd.yuv", kWidth, kHeight, 30,
1, 0, 20);
@@ -90,12 +90,12 @@
TEST_P(ActiveMapTestLarge, Test) { DoTest(); }
-VP10_INSTANTIATE_TEST_CASE(ActiveMapTestLarge,
- ::testing::Values(::libaom_test::kRealTime),
- ::testing::Range(0, 5));
+AV1_INSTANTIATE_TEST_CASE(ActiveMapTestLarge,
+ ::testing::Values(::libaom_test::kRealTime),
+ ::testing::Range(0, 5));
-VP10_INSTANTIATE_TEST_CASE(ActiveMapTest,
- ::testing::Values(::libaom_test::kRealTime),
- ::testing::Range(5, 9));
+AV1_INSTANTIATE_TEST_CASE(ActiveMapTest,
+ ::testing::Values(::libaom_test::kRealTime),
+ ::testing::Range(5, 9));
} // namespace
diff --git a/test/add_noise_test.cc b/test/add_noise_test.cc
index 62f14b4..768ac36 100644
--- a/test/add_noise_test.cc
+++ b/test/add_noise_test.cc
@@ -11,10 +11,10 @@
#include "test/clear_system_state.h"
#include "test/register_state_check.h"
#include "third_party/googletest/src/include/gtest/gtest.h"
-#include "./vpx_dsp_rtcd.h"
-#include "aom/vpx_integer.h"
+#include "./aom_dsp_rtcd.h"
+#include "aom/aom_integer.h"
#include "aom_dsp/postproc.h"
-#include "aom_mem/vpx_mem.h"
+#include "aom_mem/aom_mem.h"
namespace {
@@ -46,7 +46,7 @@
const int height = 64;
const int image_size = width * height;
char noise[3072];
- const int clamp = vpx_setup_noise(4.4, sizeof(noise), noise);
+ const int clamp = aom_setup_noise(4.4, sizeof(noise), noise);
for (int i = 0; i < 16; i++) {
blackclamp[i] = clamp;
@@ -54,7 +54,7 @@
bothclamp[i] = 2 * clamp;
}
- uint8_t *const s = reinterpret_cast<uint8_t *>(vpx_calloc(image_size, 1));
+ uint8_t *const s = reinterpret_cast<uint8_t *>(aom_calloc(image_size, 1));
memset(s, 99, image_size);
ASM_REGISTER_STATE_CHECK(GetParam()(s, noise, blackclamp, whiteclamp,
@@ -95,7 +95,7 @@
EXPECT_LT(static_cast<int>(s[i]), 255 - clamp) << "i = " << i;
}
- vpx_free(s);
+ aom_free(s);
}
TEST_P(AddNoiseTest, CheckCvsAssembly) {
@@ -107,7 +107,7 @@
const int image_size = width * height;
char noise[3072];
- const int clamp = vpx_setup_noise(4.4, sizeof(noise), noise);
+ const int clamp = aom_setup_noise(4.4, sizeof(noise), noise);
for (int i = 0; i < 16; i++) {
blackclamp[i] = clamp;
@@ -115,8 +115,8 @@
bothclamp[i] = 2 * clamp;
}
- uint8_t *const s = reinterpret_cast<uint8_t *>(vpx_calloc(image_size, 1));
- uint8_t *const d = reinterpret_cast<uint8_t *>(vpx_calloc(image_size, 1));
+ uint8_t *const s = reinterpret_cast<uint8_t *>(aom_calloc(image_size, 1));
+ uint8_t *const d = reinterpret_cast<uint8_t *>(aom_calloc(image_size, 1));
memset(s, 99, image_size);
memset(d, 99, image_size);
@@ -125,27 +125,27 @@
ASM_REGISTER_STATE_CHECK(GetParam()(s, noise, blackclamp, whiteclamp,
bothclamp, width, height, width));
srand(0);
- ASM_REGISTER_STATE_CHECK(vpx_plane_add_noise_c(
+ ASM_REGISTER_STATE_CHECK(aom_plane_add_noise_c(
d, noise, blackclamp, whiteclamp, bothclamp, width, height, width));
for (int i = 0; i < image_size; ++i) {
EXPECT_EQ(static_cast<int>(s[i]), static_cast<int>(d[i])) << "i = " << i;
}
- vpx_free(d);
- vpx_free(s);
+ aom_free(d);
+ aom_free(s);
}
INSTANTIATE_TEST_CASE_P(C, AddNoiseTest,
- ::testing::Values(vpx_plane_add_noise_c));
+ ::testing::Values(aom_plane_add_noise_c));
#if HAVE_SSE2
INSTANTIATE_TEST_CASE_P(SSE2, AddNoiseTest,
- ::testing::Values(vpx_plane_add_noise_sse2));
+ ::testing::Values(aom_plane_add_noise_sse2));
#endif
#if HAVE_MSA
INSTANTIATE_TEST_CASE_P(MSA, AddNoiseTest,
- ::testing::Values(vpx_plane_add_noise_msa));
+ ::testing::Values(aom_plane_add_noise_msa));
#endif
} // namespace
diff --git a/test/altref_test.cc b/test/altref_test.cc
index 2592914..29d6a63 100644
--- a/test/altref_test.cc
+++ b/test/altref_test.cc
@@ -26,29 +26,29 @@
virtual void SetUp() {
InitializeConfig();
SetMode(encoding_mode_);
- cfg_.rc_end_usage = VPX_VBR;
+ cfg_.rc_end_usage = AOM_VBR;
cfg_.g_threads = 0;
}
virtual void PreEncodeFrameHook(::libaom_test::VideoSource *video,
::libaom_test::Encoder *encoder) {
if (video->frame() == 0) {
- encoder->Control(VP8E_SET_CPUUSED, cpu_used_);
- encoder->Control(VP8E_SET_ENABLEAUTOALTREF, 1);
-#if CONFIG_VP10_ENCODER
+ encoder->Control(AOME_SET_CPUUSED, cpu_used_);
+ encoder->Control(AOME_SET_ENABLEAUTOALTREF, 1);
+#if CONFIG_AV1_ENCODER
// override test default for tile columns if necessary.
- if (GET_PARAM(0) == &libaom_test::kVP10) {
- encoder->Control(VP9E_SET_TILE_COLUMNS, 6);
+ if (GET_PARAM(0) == &libaom_test::kAV1) {
+ encoder->Control(AV1E_SET_TILE_COLUMNS, 6);
}
#endif
}
frame_flags_ =
- (video->frame() == forced_kf_frame_num_) ? VPX_EFLAG_FORCE_KF : 0;
+ (video->frame() == forced_kf_frame_num_) ? AOM_EFLAG_FORCE_KF : 0;
}
- virtual void FramePktHook(const vpx_codec_cx_pkt_t *pkt) {
+ virtual void FramePktHook(const aom_codec_cx_pkt_t *pkt) {
if (frame_num_ == forced_kf_frame_num_) {
- ASSERT_TRUE(!!(pkt->data.frame.flags & VPX_FRAME_IS_KEY))
+ ASSERT_TRUE(!!(pkt->data.frame.flags & AOM_FRAME_IS_KEY))
<< "Frame #" << frame_num_ << " isn't a keyframe!";
}
++frame_num_;
@@ -61,7 +61,7 @@
};
TEST_P(AltRefForcedKeyTestLarge, Frame1IsKey) {
- const vpx_rational timebase = { 1, 30 };
+ const aom_rational timebase = { 1, 30 };
const int lag_values[] = { 3, 15, 25, -1 };
forced_kf_frame_num_ = 1;
@@ -75,7 +75,7 @@
}
TEST_P(AltRefForcedKeyTestLarge, ForcedFrameIsKey) {
- const vpx_rational timebase = { 1, 30 };
+ const aom_rational timebase = { 1, 30 };
const int lag_values[] = { 3, 15, 25, -1 };
for (int i = 0; lag_values[i] != -1; ++i) {
@@ -88,8 +88,8 @@
}
}
-VP10_INSTANTIATE_TEST_CASE(AltRefForcedKeyTestLarge,
- ::testing::Values(::libaom_test::kOnePassGood),
- ::testing::Range(0, 9));
+AV1_INSTANTIATE_TEST_CASE(AltRefForcedKeyTestLarge,
+ ::testing::Values(::libaom_test::kOnePassGood),
+ ::testing::Range(0, 9));
} // namespace
diff --git a/test/android/Android.mk b/test/android/Android.mk
index 4f0565a..d337fa5 100644
--- a/test/android/Android.mk
+++ b/test/android/Android.mk
@@ -6,7 +6,7 @@
# in the file PATENTS. All contributing project authors may
# be found in the AUTHORS file in the root of the source tree.
#
-# This make file builds vpx_test app for android.
+# This make file builds aom_test app for android.
# The test app itself runs on the command line through adb shell
# The paths are really messed up as the libaom make file
# expects to be made from a parent directory.
@@ -42,9 +42,9 @@
LOCAL_STATIC_LIBRARIES := gtest libwebm
ifeq ($(ENABLE_SHARED),1)
- LOCAL_SHARED_LIBRARIES := vpx
+ LOCAL_SHARED_LIBRARIES := aom
else
- LOCAL_STATIC_LIBRARIES += vpx
+ LOCAL_STATIC_LIBRARIES += aom
endif
include $(LOCAL_PATH)/test/test.mk
diff --git a/test/android/README b/test/android/README
index e5b25d5..35c8297 100644
--- a/test/android/README
+++ b/test/android/README
@@ -1,4 +1,4 @@
-Android.mk will build vpx unittests on android.
+Android.mk will build aom unittests on android.
1) Configure libaom from the parent directory:
./libaom/configure --target=armv7-android-gcc --enable-external-build \
--enable-postproc --disable-install-srcs --enable-multi-res-encoding \
@@ -29,4 +29,4 @@
adb shell
(on device)
cd /data/local/tmp
-LD_LIBRARY_PATH=. ./vpx_test
+LD_LIBRARY_PATH=. ./aom_test
diff --git a/test/aomdec.sh b/test/aomdec.sh
new file mode 100755
index 0000000..c471f10
--- /dev/null
+++ b/test/aomdec.sh
@@ -0,0 +1,116 @@
+#!/bin/sh
+##
+## Copyright (c) 2014 The WebM project authors. All Rights Reserved.
+##
+## Use of this source code is governed by a BSD-style license
+## that can be found in the LICENSE file in the root of the source
+## tree. An additional intellectual property rights grant can be found
+## in the file PATENTS. All contributing project authors may
+## be found in the AUTHORS file in the root of the source tree.
+##
+## This file tests aomdec. To add new tests to this file, do the following:
+## 1. Write a shell function (this is your test).
+## 2. Add the function to aomdec_tests (on a new line).
+##
+. $(dirname $0)/tools_common.sh
+
+# Environment check: Make sure input is available.
+aomdec_verify_environment() {
+ if [ ! -e "${VP8_IVF_FILE}" ] || [ ! -e "${AV1_WEBM_FILE}" ] || \
+ [ ! -e "${AV1_FPM_WEBM_FILE}" ] || \
+ [ ! -e "${AV1_LT_50_FRAMES_WEBM_FILE}" ] ; then
+ elog "Libaom test data must exist in LIBVPX_TEST_DATA_PATH."
+ return 1
+ fi
+ if [ -z "$(aom_tool_path aomdec)" ]; then
+ elog "aomdec not found. It must exist in LIBAOM_BIN_PATH or its parent."
+ return 1
+ fi
+}
+
+# Wrapper function for running aomdec with pipe input. Requires that
+# LIBAOM_BIN_PATH points to the directory containing aomdec. $1 is used as the
+# input file path and shifted away. All remaining parameters are passed through
+# to aomdec.
+aomdec_pipe() {
+ local readonly decoder="$(aom_tool_path aomdec)"
+ local readonly input="$1"
+ shift
+ cat "${input}" | eval "${AOM_TEST_PREFIX}" "${decoder}" - "$@" ${devnull}
+}
+
+# Wrapper function for running aomdec. Requires that LIBAOM_BIN_PATH points to
+# the directory containing aomdec. $1 one is used as the input file path and
+# shifted away. All remaining parameters are passed through to aomdec.
+aomdec() {
+ local readonly decoder="$(aom_tool_path aomdec)"
+ local readonly input="$1"
+ shift
+ eval "${AOM_TEST_PREFIX}" "${decoder}" "$input" "$@" ${devnull}
+}
+
+aomdec_can_decode_vp8() {
+ if [ "$(vp8_decode_available)" = "yes" ]; then
+ echo yes
+ fi
+}
+
+aomdec_can_decode_av1() {
+ if [ "$(av1_decode_available)" = "yes" ]; then
+ echo yes
+ fi
+}
+
+aomdec_vp8_ivf() {
+ if [ "$(aomdec_can_decode_vp8)" = "yes" ]; then
+ aomdec "${VP8_IVF_FILE}" --summary --noblit
+ fi
+}
+
+aomdec_vp8_ivf_pipe_input() {
+ if [ "$(aomdec_can_decode_vp8)" = "yes" ]; then
+ aomdec_pipe "${VP8_IVF_FILE}" --summary --noblit
+ fi
+}
+
+aomdec_av1_webm() {
+ if [ "$(aomdec_can_decode_av1)" = "yes" ] && \
+ [ "$(webm_io_available)" = "yes" ]; then
+ aomdec "${AV1_WEBM_FILE}" --summary --noblit
+ fi
+}
+
+aomdec_av1_webm_frame_parallel() {
+ if [ "$(aomdec_can_decode_av1)" = "yes" ] && \
+ [ "$(webm_io_available)" = "yes" ]; then
+ for threads in 2 3 4 5 6 7 8; do
+ aomdec "${AV1_FPM_WEBM_FILE}" --summary --noblit --threads=$threads \
+ --frame-parallel
+ done
+ fi
+}
+
+aomdec_av1_webm_less_than_50_frames() {
+ # ensure that reaching eof in webm_guess_framerate doesn't result in invalid
+ # frames in actual webm_read_frame calls.
+ if [ "$(aomdec_can_decode_av1)" = "yes" ] && \
+ [ "$(webm_io_available)" = "yes" ]; then
+ local readonly decoder="$(aom_tool_path aomdec)"
+ local readonly expected=10
+ local readonly num_frames=$(${AOM_TEST_PREFIX} "${decoder}" \
+ "${AV1_LT_50_FRAMES_WEBM_FILE}" --summary --noblit 2>&1 \
+ | awk '/^[0-9]+ decoded frames/ { print $1 }')
+ if [ "$num_frames" -ne "$expected" ]; then
+ elog "Output frames ($num_frames) != expected ($expected)"
+ return 1
+ fi
+ fi
+}
+
+aomdec_tests="aomdec_vp8_ivf
+ aomdec_vp8_ivf_pipe_input
+ aomdec_av1_webm
+ aomdec_av1_webm_frame_parallel
+ aomdec_av1_webm_less_than_50_frames"
+
+run_tests aomdec_verify_environment "${aomdec_tests}"
diff --git a/test/aomenc.sh b/test/aomenc.sh
new file mode 100755
index 0000000..5edc1de
--- /dev/null
+++ b/test/aomenc.sh
@@ -0,0 +1,429 @@
+#!/bin/sh
+##
+## Copyright (c) 2014 The WebM project authors. All Rights Reserved.
+##
+## Use of this source code is governed by a BSD-style license
+## that can be found in the LICENSE file in the root of the source
+## tree. An additional intellectual property rights grant can be found
+## in the file PATENTS. All contributing project authors may
+## be found in the AUTHORS file in the root of the source tree.
+##
+## This file tests aomenc using hantro_collage_w352h288.yuv as input. To add
+## new tests to this file, do the following:
+## 1. Write a shell function (this is your test).
+## 2. Add the function to aomenc_tests (on a new line).
+##
+. $(dirname $0)/tools_common.sh
+
+readonly TEST_FRAMES=10
+
+# Environment check: Make sure input is available.
+aomenc_verify_environment() {
+ if [ ! -e "${YUV_RAW_INPUT}" ]; then
+ elog "The file ${YUV_RAW_INPUT##*/} must exist in LIBVPX_TEST_DATA_PATH."
+ return 1
+ fi
+ if [ "$(aomenc_can_encode_av1)" = "yes" ]; then
+ if [ ! -e "${Y4M_NOSQ_PAR_INPUT}" ]; then
+ elog "The file ${Y4M_NOSQ_PAR_INPUT##*/} must exist in"
+ elog "LIBVPX_TEST_DATA_PATH."
+ return 1
+ fi
+ fi
+ if [ -z "$(aom_tool_path aomenc)" ]; then
+ elog "aomenc not found. It must exist in LIBAOM_BIN_PATH or its parent."
+ return 1
+ fi
+}
+
+aomenc_can_encode_vp8() {
+ if [ "$(vp8_encode_available)" = "yes" ]; then
+ echo yes
+ fi
+}
+
+aomenc_can_encode_av1() {
+ if [ "$(av1_encode_available)" = "yes" ]; then
+ echo yes
+ fi
+}
+
+# Echo aomenc command line parameters allowing use of
+# hantro_collage_w352h288.yuv as input.
+yuv_input_hantro_collage() {
+ echo ""${YUV_RAW_INPUT}"
+ --width="${YUV_RAW_INPUT_WIDTH}"
+ --height="${YUV_RAW_INPUT_HEIGHT}""
+}
+
+y4m_input_non_square_par() {
+ echo ""${Y4M_NOSQ_PAR_INPUT}""
+}
+
+y4m_input_720p() {
+ echo ""${Y4M_720P_INPUT}""
+}
+
+# Echo default aomenc real time encoding params. $1 is the codec, which defaults
+# to vp8 if unspecified.
+aomenc_rt_params() {
+ local readonly codec="${1:-vp8}"
+ echo "--codec=${codec}
+ --buf-initial-sz=500
+ --buf-optimal-sz=600
+ --buf-sz=1000
+ --cpu-used=-6
+ --end-usage=cbr
+ --error-resilient=1
+ --kf-max-dist=90000
+ --lag-in-frames=0
+ --max-intra-rate=300
+ --max-q=56
+ --min-q=2
+ --noise-sensitivity=0
+ --overshoot-pct=50
+ --passes=1
+ --profile=0
+ --resize-allowed=0
+ --rt
+ --static-thresh=0
+ --undershoot-pct=50"
+}
+
+# Wrapper function for running aomenc with pipe input. Requires that
+# LIBAOM_BIN_PATH points to the directory containing aomenc. $1 is used as the
+# input file path and shifted away. All remaining parameters are passed through
+# to aomenc.
+aomenc_pipe() {
+ local readonly encoder="$(aom_tool_path aomenc)"
+ local readonly input="$1"
+ shift
+ cat "${input}" | eval "${AOM_TEST_PREFIX}" "${encoder}" - \
+ --test-decode=fatal \
+ "$@" ${devnull}
+}
+
+# Wrapper function for running aomenc. Requires that LIBAOM_BIN_PATH points to
+# the directory containing aomenc. $1 one is used as the input file path and
+# shifted away. All remaining parameters are passed through to aomenc.
+aomenc() {
+ local readonly encoder="$(aom_tool_path aomenc)"
+ local readonly input="$1"
+ shift
+ eval "${AOM_TEST_PREFIX}" "${encoder}" "${input}" \
+ --test-decode=fatal \
+ "$@" ${devnull}
+}
+
+aomenc_vp8_ivf() {
+ if [ "$(aomenc_can_encode_vp8)" = "yes" ]; then
+ local readonly output="${AOM_TEST_OUTPUT_DIR}/vp8.ivf"
+ aomenc $(yuv_input_hantro_collage) \
+ --codec=vp8 \
+ --limit="${TEST_FRAMES}" \
+ --ivf \
+ --output="${output}"
+
+ if [ ! -e "${output}" ]; then
+ elog "Output file does not exist."
+ return 1
+ fi
+ fi
+}
+
+aomenc_vp8_webm() {
+ if [ "$(aomenc_can_encode_vp8)" = "yes" ] && \
+ [ "$(webm_io_available)" = "yes" ]; then
+ local readonly output="${AOM_TEST_OUTPUT_DIR}/vp8.webm"
+ aomenc $(yuv_input_hantro_collage) \
+ --codec=vp8 \
+ --limit="${TEST_FRAMES}" \
+ --output="${output}"
+
+ if [ ! -e "${output}" ]; then
+ elog "Output file does not exist."
+ return 1
+ fi
+ fi
+}
+
+aomenc_vp8_webm_rt() {
+ if [ "$(aomenc_can_encode_vp8)" = "yes" ] && \
+ [ "$(webm_io_available)" = "yes" ]; then
+ local readonly output="${AOM_TEST_OUTPUT_DIR}/vp8_rt.webm"
+ aomenc $(yuv_input_hantro_collage) \
+ $(aomenc_rt_params vp8) \
+ --output="${output}"
+ if [ ! -e "${output}" ]; then
+ elog "Output file does not exist."
+ return 1
+ fi
+ fi
+}
+
+aomenc_vp8_webm_2pass() {
+ if [ "$(aomenc_can_encode_vp8)" = "yes" ] && \
+ [ "$(webm_io_available)" = "yes" ]; then
+ local readonly output="${AOM_TEST_OUTPUT_DIR}/vp8.webm"
+ aomenc $(yuv_input_hantro_collage) \
+ --codec=vp8 \
+ --limit="${TEST_FRAMES}" \
+ --output="${output}" \
+ --passes=2
+
+ if [ ! -e "${output}" ]; then
+ elog "Output file does not exist."
+ return 1
+ fi
+ fi
+}
+
+aomenc_vp8_webm_lag10_frames20() {
+ if [ "$(aomenc_can_encode_vp8)" = "yes" ] && \
+ [ "$(webm_io_available)" = "yes" ]; then
+ local readonly lag_total_frames=20
+ local readonly lag_frames=10
+ local readonly output="${AOM_TEST_OUTPUT_DIR}/vp8_lag10_frames20.webm"
+ aomenc $(yuv_input_hantro_collage) \
+ --codec=vp8 \
+ --limit="${lag_total_frames}" \
+ --lag-in-frames="${lag_frames}" \
+ --output="${output}" \
+ --auto-alt-ref=1 \
+ --passes=2
+
+ if [ ! -e "${output}" ]; then
+ elog "Output file does not exist."
+ return 1
+ fi
+ fi
+}
+
+aomenc_vp8_ivf_piped_input() {
+ if [ "$(aomenc_can_encode_vp8)" = "yes" ]; then
+ local readonly output="${AOM_TEST_OUTPUT_DIR}/vp8_piped_input.ivf"
+ aomenc_pipe $(yuv_input_hantro_collage) \
+ --codec=vp8 \
+ --limit="${TEST_FRAMES}" \
+ --ivf \
+ --output="${output}"
+
+ if [ ! -e "${output}" ]; then
+ elog "Output file does not exist."
+ return 1
+ fi
+ fi
+}
+
+aomenc_av1_ivf() {
+ if [ "$(aomenc_can_encode_av1)" = "yes" ]; then
+ local readonly output="${AOM_TEST_OUTPUT_DIR}/av1.ivf"
+ aomenc $(yuv_input_hantro_collage) \
+ --codec=av1 \
+ --limit="${TEST_FRAMES}" \
+ --ivf \
+ --output="${output}"
+
+ if [ ! -e "${output}" ]; then
+ elog "Output file does not exist."
+ return 1
+ fi
+ fi
+}
+
+aomenc_av1_webm() {
+ if [ "$(aomenc_can_encode_av1)" = "yes" ] && \
+ [ "$(webm_io_available)" = "yes" ]; then
+ local readonly output="${AOM_TEST_OUTPUT_DIR}/av1.webm"
+ aomenc $(yuv_input_hantro_collage) \
+ --codec=av1 \
+ --limit="${TEST_FRAMES}" \
+ --output="${output}"
+
+ if [ ! -e "${output}" ]; then
+ elog "Output file does not exist."
+ return 1
+ fi
+ fi
+}
+
+aomenc_av1_webm_rt() {
+ if [ "$(aomenc_can_encode_av1)" = "yes" ] && \
+ [ "$(webm_io_available)" = "yes" ]; then
+ local readonly output="${AOM_TEST_OUTPUT_DIR}/av1_rt.webm"
+ aomenc $(yuv_input_hantro_collage) \
+ $(aomenc_rt_params av1) \
+ --output="${output}"
+
+ if [ ! -e "${output}" ]; then
+ elog "Output file does not exist."
+ return 1
+ fi
+ fi
+}
+
+aomenc_av1_webm_rt_multithread_tiled() {
+ if [ "$(aomenc_can_encode_av1)" = "yes" ] && \
+ [ "$(webm_io_available)" = "yes" ]; then
+ local readonly output="${AOM_TEST_OUTPUT_DIR}/av1_rt_multithread_tiled.webm"
+ local readonly tilethread_min=2
+ local readonly tilethread_max=4
+ local readonly num_threads="$(seq ${tilethread_min} ${tilethread_max})"
+ local readonly num_tile_cols="$(seq ${tilethread_min} ${tilethread_max})"
+
+ for threads in ${num_threads}; do
+ for tile_cols in ${num_tile_cols}; do
+ aomenc $(y4m_input_720p) \
+ $(aomenc_rt_params av1) \
+ --threads=${threads} \
+ --tile-columns=${tile_cols} \
+ --output="${output}"
+ done
+ done
+
+ if [ ! -e "${output}" ]; then
+ elog "Output file does not exist."
+ return 1
+ fi
+
+ rm "${output}"
+ fi
+}
+
+aomenc_av1_webm_rt_multithread_tiled_frameparallel() {
+ if [ "$(aomenc_can_encode_av1)" = "yes" ] && \
+ [ "$(webm_io_available)" = "yes" ]; then
+ local readonly output="${AOM_TEST_OUTPUT_DIR}/av1_rt_mt_t_fp.webm"
+ local readonly tilethread_min=2
+ local readonly tilethread_max=4
+ local readonly num_threads="$(seq ${tilethread_min} ${tilethread_max})"
+ local readonly num_tile_cols="$(seq ${tilethread_min} ${tilethread_max})"
+
+ for threads in ${num_threads}; do
+ for tile_cols in ${num_tile_cols}; do
+ aomenc $(y4m_input_720p) \
+ $(aomenc_rt_params av1) \
+ --threads=${threads} \
+ --tile-columns=${tile_cols} \
+ --frame-parallel=1 \
+ --output="${output}"
+ done
+ done
+
+ if [ ! -e "${output}" ]; then
+ elog "Output file does not exist."
+ return 1
+ fi
+
+ rm "${output}"
+ fi
+}
+
+aomenc_av1_webm_2pass() {
+ if [ "$(aomenc_can_encode_av1)" = "yes" ] && \
+ [ "$(webm_io_available)" = "yes" ]; then
+ local readonly output="${AOM_TEST_OUTPUT_DIR}/av1.webm"
+ aomenc $(yuv_input_hantro_collage) \
+ --codec=av1 \
+ --limit="${TEST_FRAMES}" \
+ --output="${output}" \
+ --passes=2
+
+ if [ ! -e "${output}" ]; then
+ elog "Output file does not exist."
+ return 1
+ fi
+ fi
+}
+
+aomenc_av1_ivf_lossless() {
+ if [ "$(aomenc_can_encode_av1)" = "yes" ]; then
+ local readonly output="${AOM_TEST_OUTPUT_DIR}/av1_lossless.ivf"
+ aomenc $(yuv_input_hantro_collage) \
+ --codec=av1 \
+ --limit="${TEST_FRAMES}" \
+ --ivf \
+ --output="${output}" \
+ --lossless=1
+
+ if [ ! -e "${output}" ]; then
+ elog "Output file does not exist."
+ return 1
+ fi
+ fi
+}
+
+aomenc_av1_ivf_minq0_maxq0() {
+ if [ "$(aomenc_can_encode_av1)" = "yes" ]; then
+ local readonly output="${AOM_TEST_OUTPUT_DIR}/av1_lossless_minq0_maxq0.ivf"
+ aomenc $(yuv_input_hantro_collage) \
+ --codec=av1 \
+ --limit="${TEST_FRAMES}" \
+ --ivf \
+ --output="${output}" \
+ --min-q=0 \
+ --max-q=0
+
+ if [ ! -e "${output}" ]; then
+ elog "Output file does not exist."
+ return 1
+ fi
+ fi
+}
+
+aomenc_av1_webm_lag10_frames20() {
+ if [ "$(aomenc_can_encode_av1)" = "yes" ] && \
+ [ "$(webm_io_available)" = "yes" ]; then
+ local readonly lag_total_frames=20
+ local readonly lag_frames=10
+ local readonly output="${AOM_TEST_OUTPUT_DIR}/av1_lag10_frames20.webm"
+ aomenc $(yuv_input_hantro_collage) \
+ --codec=av1 \
+ --limit="${lag_total_frames}" \
+ --lag-in-frames="${lag_frames}" \
+ --output="${output}" \
+ --passes=2 \
+ --auto-alt-ref=1
+
+ if [ ! -e "${output}" ]; then
+ elog "Output file does not exist."
+ return 1
+ fi
+ fi
+}
+
+# TODO(fgalligan): Test that DisplayWidth is different than video width.
+aomenc_av1_webm_non_square_par() {
+ if [ "$(aomenc_can_encode_av1)" = "yes" ] && \
+ [ "$(webm_io_available)" = "yes" ]; then
+ local readonly output="${AOM_TEST_OUTPUT_DIR}/av1_non_square_par.webm"
+ aomenc $(y4m_input_non_square_par) \
+ --codec=av1 \
+ --limit="${TEST_FRAMES}" \
+ --output="${output}"
+
+ if [ ! -e "${output}" ]; then
+ elog "Output file does not exist."
+ return 1
+ fi
+ fi
+}
+
+aomenc_tests="aomenc_vp8_ivf
+ aomenc_vp8_webm
+ aomenc_vp8_webm_rt
+ aomenc_vp8_webm_2pass
+ aomenc_vp8_webm_lag10_frames20
+ aomenc_vp8_ivf_piped_input
+ aomenc_av1_ivf
+ aomenc_av1_webm
+ aomenc_av1_webm_rt
+ aomenc_av1_webm_rt_multithread_tiled
+ aomenc_av1_webm_rt_multithread_tiled_frameparallel
+ aomenc_av1_webm_2pass
+ aomenc_av1_ivf_lossless
+ aomenc_av1_ivf_minq0_maxq0
+ aomenc_av1_webm_lag10_frames20
+ aomenc_av1_webm_non_square_par"
+
+run_tests aomenc_verify_environment "${aomenc_tests}"
diff --git a/test/aq_segment_test.cc b/test/aq_segment_test.cc
index bd4e51e..17e0555 100644
--- a/test/aq_segment_test.cc
+++ b/test/aq_segment_test.cc
@@ -32,9 +32,9 @@
virtual void PreEncodeFrameHook(::libaom_test::VideoSource *video,
::libaom_test::Encoder *encoder) {
if (video->frame() == 1) {
- encoder->Control(VP8E_SET_CPUUSED, set_cpu_used_);
- encoder->Control(VP9E_SET_AQ_MODE, aq_mode_);
- encoder->Control(VP8E_SET_MAX_INTRA_BITRATE_PCT, 100);
+ encoder->Control(AOME_SET_CPUUSED, set_cpu_used_);
+ encoder->Control(AV1E_SET_AQ_MODE, aq_mode_);
+ encoder->Control(AOME_SET_MAX_INTRA_BITRATE_PCT, 100);
}
}
@@ -43,7 +43,7 @@
cfg_.kf_max_dist = 12;
cfg_.rc_min_quantizer = 8;
cfg_.rc_max_quantizer = 56;
- cfg_.rc_end_usage = VPX_CBR;
+ cfg_.rc_end_usage = AOM_CBR;
cfg_.g_lag_in_frames = 6;
cfg_.rc_buf_initial_sz = 500;
cfg_.rc_buf_optimal_sz = 500;
@@ -78,12 +78,12 @@
TEST_P(AqSegmentTestLarge, TestNoMisMatchAQ3) { DoTest(3); }
-VP10_INSTANTIATE_TEST_CASE(AqSegmentTest,
- ::testing::Values(::libaom_test::kRealTime,
- ::libaom_test::kOnePassGood),
- ::testing::Range(5, 9));
-VP10_INSTANTIATE_TEST_CASE(AqSegmentTestLarge,
- ::testing::Values(::libaom_test::kRealTime,
- ::libaom_test::kOnePassGood),
- ::testing::Range(3, 5));
+AV1_INSTANTIATE_TEST_CASE(AqSegmentTest,
+ ::testing::Values(::libaom_test::kRealTime,
+ ::libaom_test::kOnePassGood),
+ ::testing::Range(5, 9));
+AV1_INSTANTIATE_TEST_CASE(AqSegmentTestLarge,
+ ::testing::Values(::libaom_test::kRealTime,
+ ::libaom_test::kOnePassGood),
+ ::testing::Range(3, 5));
} // namespace
diff --git a/test/arf_freq_test.cc b/test/arf_freq_test.cc
index 83a0337..d319cbe 100644
--- a/test/arf_freq_test.cc
+++ b/test/arf_freq_test.cc
@@ -32,8 +32,8 @@
unsigned int framerate_num;
unsigned int framerate_den;
unsigned int input_bit_depth;
- vpx_img_fmt fmt;
- vpx_bit_depth_t bit_depth;
+ aom_img_fmt fmt;
+ aom_bit_depth_t bit_depth;
unsigned int profile;
} TestVideoParam;
@@ -44,14 +44,14 @@
const TestVideoParam kTestVectors[] = {
// artificially increase framerate to trigger default check
- { "hantro_collage_w352h288.yuv", 352, 288, 5000, 1, 8, VPX_IMG_FMT_I420,
- VPX_BITS_8, 0 },
- { "hantro_collage_w352h288.yuv", 352, 288, 30, 1, 8, VPX_IMG_FMT_I420,
- VPX_BITS_8, 0 },
- { "rush_hour_444.y4m", 352, 288, 30, 1, 8, VPX_IMG_FMT_I444, VPX_BITS_8, 1 },
-#if CONFIG_VP9_HIGHBITDEPTH
+ { "hantro_collage_w352h288.yuv", 352, 288, 5000, 1, 8, AOM_IMG_FMT_I420,
+ AOM_BITS_8, 0 },
+ { "hantro_collage_w352h288.yuv", 352, 288, 30, 1, 8, AOM_IMG_FMT_I420,
+ AOM_BITS_8, 0 },
+ { "rush_hour_444.y4m", 352, 288, 30, 1, 8, AOM_IMG_FMT_I444, AOM_BITS_8, 1 },
+#if CONFIG_AOM_HIGHBITDEPTH
// Add list of profile 2/3 test videos here ...
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#endif // CONFIG_AOM_HIGHBITDEPTH
};
const TestEncodeParam kEncodeVectors[] = {
@@ -62,7 +62,7 @@
const int kMinArfVectors[] = {
// NOTE: 0 refers to the default built-in logic in:
- // vp9_rc_get_default_min_gf_interval(...)
+ // av1_rc_get_default_min_gf_interval(...)
0, 4, 8, 12, 15
};
@@ -90,10 +90,10 @@
SetMode(test_encode_param_.mode);
if (test_encode_param_.mode != ::libaom_test::kRealTime) {
cfg_.g_lag_in_frames = 25;
- cfg_.rc_end_usage = VPX_VBR;
+ cfg_.rc_end_usage = AOM_VBR;
} else {
cfg_.g_lag_in_frames = 0;
- cfg_.rc_end_usage = VPX_CBR;
+ cfg_.rc_end_usage = AOM_CBR;
cfg_.rc_buf_sz = 1000;
cfg_.rc_buf_initial_sz = 500;
cfg_.rc_buf_optimal_sz = 600;
@@ -106,7 +106,7 @@
run_of_visible_frames_ = 0;
}
- int GetNumFramesInPkt(const vpx_codec_cx_pkt_t *pkt) {
+ int GetNumFramesInPkt(const aom_codec_cx_pkt_t *pkt) {
const uint8_t *buffer = reinterpret_cast<uint8_t *>(pkt->data.frame.buf);
const uint8_t marker = buffer[pkt->data.frame.sz - 1];
const int mag = ((marker >> 3) & 3) + 1;
@@ -123,8 +123,8 @@
return frames;
}
- virtual void FramePktHook(const vpx_codec_cx_pkt_t *pkt) {
- if (pkt->kind != VPX_CODEC_CX_FRAME_PKT) return;
+ virtual void FramePktHook(const aom_codec_cx_pkt_t *pkt) {
+ if (pkt->kind != AOM_CODEC_CX_FRAME_PKT) return;
const int frames = GetNumFramesInPkt(pkt);
if (frames == 1) {
run_of_visible_frames_++;
@@ -145,15 +145,15 @@
virtual void PreEncodeFrameHook(::libaom_test::VideoSource *video,
::libaom_test::Encoder *encoder) {
if (video->frame() == 0) {
- encoder->Control(VP9E_SET_FRAME_PARALLEL_DECODING, 1);
- encoder->Control(VP9E_SET_TILE_COLUMNS, 4);
- encoder->Control(VP8E_SET_CPUUSED, test_encode_param_.cpu_used);
- encoder->Control(VP9E_SET_MIN_GF_INTERVAL, min_arf_requested_);
+ encoder->Control(AV1E_SET_FRAME_PARALLEL_DECODING, 1);
+ encoder->Control(AV1E_SET_TILE_COLUMNS, 4);
+ encoder->Control(AOME_SET_CPUUSED, test_encode_param_.cpu_used);
+ encoder->Control(AV1E_SET_MIN_GF_INTERVAL, min_arf_requested_);
if (test_encode_param_.mode != ::libaom_test::kRealTime) {
- encoder->Control(VP8E_SET_ENABLEAUTOALTREF, 1);
- encoder->Control(VP8E_SET_ARNR_MAXFRAMES, 7);
- encoder->Control(VP8E_SET_ARNR_STRENGTH, 5);
- encoder->Control(VP8E_SET_ARNR_TYPE, 3);
+ encoder->Control(AOME_SET_ENABLEAUTOALTREF, 1);
+ encoder->Control(AOME_SET_ARNR_MAXFRAMES, 7);
+ encoder->Control(AOME_SET_ARNR_STRENGTH, 5);
+ encoder->Control(AOME_SET_ARNR_TYPE, 3);
}
}
}
@@ -164,7 +164,7 @@
if (min_arf_requested_)
return min_arf_requested_;
else
- return vp10_rc_get_default_min_gf_interval(
+ return av1_rc_get_default_min_gf_interval(
test_video_param_.width, test_video_param_.height,
(double)test_video_param_.framerate_num /
test_video_param_.framerate_den);
@@ -185,8 +185,8 @@
cfg_.g_profile = test_video_param_.profile;
cfg_.g_input_bit_depth = test_video_param_.input_bit_depth;
cfg_.g_bit_depth = test_video_param_.bit_depth;
- init_flags_ = VPX_CODEC_USE_PSNR;
- if (cfg_.g_bit_depth > 8) init_flags_ |= VPX_CODEC_USE_HIGHBITDEPTH;
+ init_flags_ = AOM_CODEC_USE_PSNR;
+ if (cfg_.g_bit_depth > 8) init_flags_ |= AOM_CODEC_USE_HIGHBITDEPTH;
testing::internal::scoped_ptr<libaom_test::VideoSource> video;
if (is_extension_y4m(test_video_param_.filename)) {
@@ -209,24 +209,24 @@
}
}
-#if CONFIG_VP9_HIGHBITDEPTH || CONFIG_EXT_REFS
-#if CONFIG_VP10_ENCODER
+#if CONFIG_AOM_HIGHBITDEPTH || CONFIG_EXT_REFS
+#if CONFIG_AV1_ENCODER
// TODO(angiebird): 25-29 fail in high bitdepth mode.
// TODO(zoeliu): This ArfFreqTest does not work with BWDREF_FRAME, as
// BWDREF_FRAME is also a non-show frame, and the minimum run between two
// consecutive BWDREF_FRAME's may vary between 1 and any arbitrary positive
// number as long as it does not exceed the gf_group interval.
INSTANTIATE_TEST_CASE_P(
- DISABLED_VP10, ArfFreqTestLarge,
+ DISABLED_AV1, ArfFreqTestLarge,
::testing::Combine(
- ::testing::Values(static_cast<const libaom_test::CodecFactory *>(
- &libaom_test::kVP10)),
+ ::testing::Values(
+ static_cast<const libaom_test::CodecFactory *>(&libaom_test::kAV1)),
::testing::ValuesIn(kTestVectors), ::testing::ValuesIn(kEncodeVectors),
::testing::ValuesIn(kMinArfVectors)));
-#endif // CONFIG_VP10_ENCODER
+#endif // CONFIG_AV1_ENCODER
#else
-VP10_INSTANTIATE_TEST_CASE(ArfFreqTestLarge, ::testing::ValuesIn(kTestVectors),
- ::testing::ValuesIn(kEncodeVectors),
- ::testing::ValuesIn(kMinArfVectors));
-#endif // CONFIG_VP9_HIGHBITDEPTH || CONFIG_EXT_REFS
+AV1_INSTANTIATE_TEST_CASE(ArfFreqTestLarge, ::testing::ValuesIn(kTestVectors),
+ ::testing::ValuesIn(kEncodeVectors),
+ ::testing::ValuesIn(kMinArfVectors));
+#endif // CONFIG_AOM_HIGHBITDEPTH || CONFIG_EXT_REFS
} // namespace
diff --git a/test/vp10_ans_test.cc b/test/av1_ans_test.cc
similarity index 84%
rename from test/vp10_ans_test.cc
rename to test/av1_ans_test.cc
index ddedbea..20fc223 100644
--- a/test/vp10_ans_test.cc
+++ b/test/av1_ans_test.cc
@@ -8,7 +8,7 @@
* be found in the AUTHORS file in the root of the source tree.
*/
-#define VP10_FORCE_VPXBOOL_TREEWRITER
+#define AV1_FORCE_AOMBOOL_TREEWRITER
#include <assert.h>
#include <math.h>
@@ -124,25 +124,25 @@
return ans_read_end(&d);
}
-bool check_vpxbool(const PvVec &pv_vec, uint8_t *buf) {
- vpx_writer w;
- vpx_reader r;
- vpx_start_encode(&w, buf);
+bool check_aombool(const PvVec &pv_vec, uint8_t *buf) {
+ aom_writer w;
+ aom_reader r;
+ aom_start_encode(&w, buf);
std::clock_t start = std::clock();
for (PvVec::const_iterator it = pv_vec.begin(); it != pv_vec.end(); ++it) {
- vpx_write(&w, it->second, 256 - it->first);
+ aom_write(&w, it->second, 256 - it->first);
}
std::clock_t enc_time = std::clock() - start;
- vpx_stop_encode(&w);
+ aom_stop_encode(&w);
bool okay = true;
- vpx_reader_init(&r, buf, w.pos, NULL, NULL);
+ aom_reader_init(&r, buf, w.pos, NULL, NULL);
start = std::clock();
for (PvVec::const_iterator it = pv_vec.begin(); it != pv_vec.end(); ++it) {
- okay &= vpx_read(&r, 256 - it->first) == it->second;
+ okay &= aom_read(&r, 256 - it->first) == it->second;
}
std::clock_t dec_time = std::clock() - start;
- printf("VPX size %d enc_time %f dec_time %f\n", w.pos,
+ printf("AOM size %d enc_time %f dec_time %f\n", w.pos,
static_cast<float>(enc_time) / CLOCKS_PER_SEC,
static_cast<float>(dec_time) / CLOCKS_PER_SEC);
return okay;
@@ -212,8 +212,8 @@
return ans_read_end(&d);
}
-void build_tree(vpx_tree_index *tree, int num_syms) {
- vpx_tree_index i;
+void build_tree(aom_tree_index *tree, int num_syms) {
+ aom_tree_index i;
int sym = 0;
for (i = 0; i < num_syms - 1; ++i) {
tree[2 * i] = sym--;
@@ -232,7 +232,7 @@
* / \
* -sym2 -sym3
*/
-void tab2tree(const rans_sym *tab, int tab_size, vpx_prob *treep) {
+void tab2tree(const rans_sym *tab, int tab_size, aom_prob *treep) {
const unsigned basep = rans_precision;
unsigned pleft = basep;
for (int i = 0; i < tab_size - 1; ++i) {
@@ -263,8 +263,8 @@
tab[i].len = len;
}
-void build_tpb(vpx_prob probs[/*num_syms*/],
- vpx_tree_index tree[/*2*num_syms*/],
+void build_tpb(aom_prob probs[/*num_syms*/],
+ aom_tree_index tree[/*2*num_syms*/],
sym_bools bit_len[/*num_syms*/],
const rans_sym sym_tab[/*num_syms*/], int num_syms) {
tab2tree(sym_tab, num_syms, probs);
@@ -272,38 +272,38 @@
make_tree_bits_tab(bit_len, num_syms);
}
-bool check_vpxtree(const std::vector<int> &sym_vec, const rans_sym *sym_tab,
+bool check_aomtree(const std::vector<int> &sym_vec, const rans_sym *sym_tab,
uint8_t *buf) {
- vpx_writer w;
- vpx_reader r;
- vpx_start_encode(&w, buf);
+ aom_writer w;
+ aom_reader r;
+ aom_start_encode(&w, buf);
- vpx_prob probs[kDistinctSyms];
- vpx_tree_index tree[2 * kDistinctSyms];
+ aom_prob probs[kDistinctSyms];
+ aom_tree_index tree[2 * kDistinctSyms];
sym_bools bit_len[kDistinctSyms];
build_tpb(probs, tree, bit_len, sym_tab, kDistinctSyms);
std::clock_t start = std::clock();
for (std::vector<int>::const_iterator it = sym_vec.begin();
it != sym_vec.end(); ++it) {
- vp10_write_tree(&w, tree, probs, bit_len[*it].bits, bit_len[*it].len, 0);
+ av1_write_tree(&w, tree, probs, bit_len[*it].bits, bit_len[*it].len, 0);
}
std::clock_t enc_time = std::clock() - start;
- vpx_stop_encode(&w);
- vpx_reader_init(&r, buf, w.pos, NULL, NULL);
+ aom_stop_encode(&w);
+ aom_reader_init(&r, buf, w.pos, NULL, NULL);
start = std::clock();
for (std::vector<int>::const_iterator it = sym_vec.begin();
it != sym_vec.end(); ++it) {
- if (vpx_read_tree(&r, tree, probs) != *it) return false;
+ if (aom_read_tree(&r, tree, probs) != *it) return false;
}
std::clock_t dec_time = std::clock() - start;
- printf("VPXtree size %u enc_time %f dec_time %f\n", w.pos,
+ printf("AOMtree size %u enc_time %f dec_time %f\n", w.pos,
static_cast<float>(enc_time) / CLOCKS_PER_SEC,
static_cast<float>(dec_time) / CLOCKS_PER_SEC);
return true;
}
-class Vp10AbsTest : public ::testing::Test {
+class Av1AbsTest : public ::testing::Test {
protected:
static void SetUpTestCase() { pv_vec_ = abs_encode_build_vals(kNumBools); }
virtual void SetUp() { buf_ = new uint8_t[kNumBools / 8]; }
@@ -312,9 +312,9 @@
static PvVec pv_vec_;
uint8_t *buf_;
};
-PvVec Vp10AbsTest::pv_vec_;
+PvVec Av1AbsTest::pv_vec_;
-class Vp10AnsTest : public ::testing::Test {
+class Av1AnsTest : public ::testing::Test {
protected:
static void SetUpTestCase() {
sym_vec_ = ans_encode_build_vals(rans_sym_tab, kNumSyms);
@@ -325,17 +325,17 @@
static std::vector<int> sym_vec_;
uint8_t *buf_;
};
-std::vector<int> Vp10AnsTest::sym_vec_;
+std::vector<int> Av1AnsTest::sym_vec_;
-TEST_F(Vp10AbsTest, Vpxbool) { EXPECT_TRUE(check_vpxbool(pv_vec_, buf_)); }
-TEST_F(Vp10AbsTest, Rabs) { EXPECT_TRUE(check_rabs(pv_vec_, buf_)); }
-TEST_F(Vp10AbsTest, RabsAsc) { EXPECT_TRUE(check_rabs_asc(pv_vec_, buf_)); }
-TEST_F(Vp10AbsTest, Uabs) { EXPECT_TRUE(check_uabs(pv_vec_, buf_)); }
+TEST_F(Av1AbsTest, Avxbool) { EXPECT_TRUE(check_aombool(pv_vec_, buf_)); }
+TEST_F(Av1AbsTest, Rabs) { EXPECT_TRUE(check_rabs(pv_vec_, buf_)); }
+TEST_F(Av1AbsTest, RabsAsc) { EXPECT_TRUE(check_rabs_asc(pv_vec_, buf_)); }
+TEST_F(Av1AbsTest, Uabs) { EXPECT_TRUE(check_uabs(pv_vec_, buf_)); }
-TEST_F(Vp10AnsTest, Rans) {
+TEST_F(Av1AnsTest, Rans) {
EXPECT_TRUE(check_rans(sym_vec_, rans_sym_tab, buf_));
}
-TEST_F(Vp10AnsTest, Vpxtree) {
- EXPECT_TRUE(check_vpxtree(sym_vec_, rans_sym_tab, buf_));
+TEST_F(Av1AnsTest, Avxtree) {
+ EXPECT_TRUE(check_aomtree(sym_vec_, rans_sym_tab, buf_));
}
} // namespace
diff --git a/test/vp10_convolve_optimz_test.cc b/test/av1_convolve_optimz_test.cc
similarity index 79%
rename from test/vp10_convolve_optimz_test.cc
rename to test/av1_convolve_optimz_test.cc
index cb8b8fb..6bbda33 100644
--- a/test/vp10_convolve_optimz_test.cc
+++ b/test/av1_convolve_optimz_test.cc
@@ -10,7 +10,7 @@
#include "third_party/googletest/src/include/gtest/gtest.h"
-#include "./vp10_rtcd.h"
+#include "./av1_rtcd.h"
#include "test/acm_random.h"
#include "test/clear_system_state.h"
#include "test/register_state_check.h"
@@ -23,7 +23,7 @@
typedef void (*conv_filter_t)(const uint8_t *, int, uint8_t *, int, int, int,
const InterpFilterParams, const int, int, int);
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
typedef void (*hbd_conv_filter_t)(const uint16_t *, int, uint16_t *, int, int,
int, const InterpFilterParams, const int, int,
int, int);
@@ -35,7 +35,7 @@
typedef tuple<int, int> BlockDimension;
typedef tuple<conv_filter_t, conv_filter_t, BlockDimension, INTERP_FILTER, int,
int> ConvParams;
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
// Test parameter list:
// <convolve_horiz_func, convolve_vert_func,
// <width, height>, filter_params, subpel_x_q4, avg, bit_dpeth>
@@ -55,9 +55,9 @@
const int stride = 128;
const int x_step_q4 = 16;
-class VP10ConvolveOptimzTest : public ::testing::TestWithParam<ConvParams> {
+class AV1ConvolveOptimzTest : public ::testing::TestWithParam<ConvParams> {
public:
- virtual ~VP10ConvolveOptimzTest() {}
+ virtual ~AV1ConvolveOptimzTest() {}
virtual void SetUp() {
conv_horiz_ = GET_PARAM(0);
conv_vert_ = GET_PARAM(1);
@@ -103,7 +103,7 @@
int avg_;
};
-void VP10ConvolveOptimzTest::PrepFilterBuffer(int w, int h) {
+void AV1ConvolveOptimzTest::PrepFilterBuffer(int w, int h) {
int r, c;
ACMRandom rnd(ACMRandom::DeterministicSeed());
@@ -128,7 +128,7 @@
}
}
-void VP10ConvolveOptimzTest::DiffFilterBuffer() {
+void AV1ConvolveOptimzTest::DiffFilterBuffer() {
int r, c;
const uint8_t *dst_ptr = dst_;
const uint8_t *dst_ref_ptr = dst_ref_;
@@ -146,13 +146,13 @@
}
}
-void VP10ConvolveOptimzTest::RunHorizFilterBitExactCheck() {
+void AV1ConvolveOptimzTest::RunHorizFilterBitExactCheck() {
PrepFilterBuffer(testMaxBlk, testMaxBlk);
- InterpFilterParams filter_params = vp10_get_interp_filter_params(filter_);
+ InterpFilterParams filter_params = av1_get_interp_filter_params(filter_);
- vp10_convolve_horiz_c(src_ref_, stride, dst_ref_, stride, width_, height_,
- filter_params, subpel_, x_step_q4, avg_);
+ av1_convolve_horiz_c(src_ref_, stride, dst_ref_, stride, width_, height_,
+ filter_params, subpel_, x_step_q4, avg_);
conv_horiz_(src_, stride, dst_, stride, width_, height_, filter_params,
subpel_, x_step_q4, avg_);
@@ -166,9 +166,9 @@
(((height_ - 1) * 16 + subpel_) >> SUBPEL_BITS) + filter_params.taps;
PrepFilterBuffer(testMaxBlk, testMaxBlk);
- vp10_convolve_horiz_c(src_ref_, stride, dst_ref_, stride, width_,
- intermediate_height, filter_params, subpel_, x_step_q4,
- avg_);
+ av1_convolve_horiz_c(src_ref_, stride, dst_ref_, stride, width_,
+ intermediate_height, filter_params, subpel_, x_step_q4,
+ avg_);
conv_horiz_(src_, stride, dst_, stride, width_, intermediate_height,
filter_params, subpel_, x_step_q4, avg_);
@@ -176,13 +176,13 @@
DiffFilterBuffer();
}
-void VP10ConvolveOptimzTest::RunVertFilterBitExactCheck() {
+void AV1ConvolveOptimzTest::RunVertFilterBitExactCheck() {
PrepFilterBuffer(testMaxBlk, testMaxBlk);
- InterpFilterParams filter_params = vp10_get_interp_filter_params(filter_);
+ InterpFilterParams filter_params = av1_get_interp_filter_params(filter_);
- vp10_convolve_vert_c(src_ref_, stride, dst_ref_, stride, width_, height_,
- filter_params, subpel_, x_step_q4, avg_);
+ av1_convolve_vert_c(src_ref_, stride, dst_ref_, stride, width_, height_,
+ filter_params, subpel_, x_step_q4, avg_);
conv_vert_(src_, stride, dst_, stride, width_, height_, filter_params,
subpel_, x_step_q4, avg_);
@@ -190,10 +190,10 @@
DiffFilterBuffer();
}
-TEST_P(VP10ConvolveOptimzTest, HorizBitExactCheck) {
+TEST_P(AV1ConvolveOptimzTest, HorizBitExactCheck) {
RunHorizFilterBitExactCheck();
}
-TEST_P(VP10ConvolveOptimzTest, VerticalBitExactCheck) {
+TEST_P(AV1ConvolveOptimzTest, VerticalBitExactCheck) {
RunVertFilterBitExactCheck();
}
@@ -219,20 +219,20 @@
#if HAVE_SSSE3 && CONFIG_EXT_INTERP
INSTANTIATE_TEST_CASE_P(
- SSSE3, VP10ConvolveOptimzTest,
- ::testing::Combine(::testing::Values(vp10_convolve_horiz_ssse3),
- ::testing::Values(vp10_convolve_vert_ssse3),
+ SSSE3, AV1ConvolveOptimzTest,
+ ::testing::Combine(::testing::Values(av1_convolve_horiz_ssse3),
+ ::testing::Values(av1_convolve_vert_ssse3),
::testing::ValuesIn(kBlockDim),
::testing::ValuesIn(kFilter),
::testing::ValuesIn(kSubpelQ4),
::testing::ValuesIn(kAvg)));
#endif // HAVE_SSSE3 && CONFIG_EXT_INTERP
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
typedef ::testing::TestWithParam<HbdConvParams> TestWithHbdConvParams;
-class VP10HbdConvolveOptimzTest : public TestWithHbdConvParams {
+class AV1HbdConvolveOptimzTest : public TestWithHbdConvParams {
public:
- virtual ~VP10HbdConvolveOptimzTest() {}
+ virtual ~AV1HbdConvolveOptimzTest() {}
virtual void SetUp() {
conv_horiz_ = GET_PARAM(0);
conv_vert_ = GET_PARAM(1);
@@ -280,7 +280,7 @@
int bit_depth_;
};
-void VP10HbdConvolveOptimzTest::PrepFilterBuffer(int w, int h) {
+void AV1HbdConvolveOptimzTest::PrepFilterBuffer(int w, int h) {
int r, c;
ACMRandom rnd(ACMRandom::DeterministicSeed());
@@ -303,7 +303,7 @@
}
}
-void VP10HbdConvolveOptimzTest::DiffFilterBuffer() {
+void AV1HbdConvolveOptimzTest::DiffFilterBuffer() {
int r, c;
const uint16_t *dst_ptr = dst_;
const uint16_t *dst_ref_ptr = dst_ref_;
@@ -322,14 +322,14 @@
}
}
-void VP10HbdConvolveOptimzTest::RunHorizFilterBitExactCheck() {
+void AV1HbdConvolveOptimzTest::RunHorizFilterBitExactCheck() {
PrepFilterBuffer(testMaxBlk, testMaxBlk);
- InterpFilterParams filter_params = vp10_get_interp_filter_params(filter_);
+ InterpFilterParams filter_params = av1_get_interp_filter_params(filter_);
- vp10_highbd_convolve_horiz_c(src_, stride, dst_ref_, stride, width_, height_,
- filter_params, subpel_, x_step_q4, avg_,
- bit_depth_);
+ av1_highbd_convolve_horiz_c(src_, stride, dst_ref_, stride, width_, height_,
+ filter_params, subpel_, x_step_q4, avg_,
+ bit_depth_);
conv_horiz_(src_, stride, dst_, stride, width_, height_, filter_params,
subpel_, x_step_q4, avg_, bit_depth_);
@@ -343,9 +343,9 @@
(((height_ - 1) * 16 + subpel_) >> SUBPEL_BITS) + filter_params.taps;
PrepFilterBuffer(testMaxBlk, testMaxBlk);
- vp10_highbd_convolve_horiz_c(src_, stride, dst_ref_, stride, width_,
- intermediate_height, filter_params, subpel_,
- x_step_q4, avg_, bit_depth_);
+ av1_highbd_convolve_horiz_c(src_, stride, dst_ref_, stride, width_,
+ intermediate_height, filter_params, subpel_,
+ x_step_q4, avg_, bit_depth_);
conv_horiz_(src_, stride, dst_, stride, width_, intermediate_height,
filter_params, subpel_, x_step_q4, avg_, bit_depth_);
@@ -353,14 +353,14 @@
DiffFilterBuffer();
}
-void VP10HbdConvolveOptimzTest::RunVertFilterBitExactCheck() {
+void AV1HbdConvolveOptimzTest::RunVertFilterBitExactCheck() {
PrepFilterBuffer(testMaxBlk, testMaxBlk);
- InterpFilterParams filter_params = vp10_get_interp_filter_params(filter_);
+ InterpFilterParams filter_params = av1_get_interp_filter_params(filter_);
- vp10_highbd_convolve_vert_c(src_, stride, dst_ref_, stride, width_, height_,
- filter_params, subpel_, x_step_q4, avg_,
- bit_depth_);
+ av1_highbd_convolve_vert_c(src_, stride, dst_ref_, stride, width_, height_,
+ filter_params, subpel_, x_step_q4, avg_,
+ bit_depth_);
conv_vert_(src_, stride, dst_, stride, width_, height_, filter_params,
subpel_, x_step_q4, avg_, bit_depth_);
@@ -368,10 +368,10 @@
DiffFilterBuffer();
}
-TEST_P(VP10HbdConvolveOptimzTest, HorizBitExactCheck) {
+TEST_P(AV1HbdConvolveOptimzTest, HorizBitExactCheck) {
RunHorizFilterBitExactCheck();
}
-TEST_P(VP10HbdConvolveOptimzTest, VertBitExactCheck) {
+TEST_P(AV1HbdConvolveOptimzTest, VertBitExactCheck) {
RunVertFilterBitExactCheck();
}
@@ -380,14 +380,14 @@
const int kBitdepth[] = { 10, 12 };
INSTANTIATE_TEST_CASE_P(
- SSE4_1, VP10HbdConvolveOptimzTest,
- ::testing::Combine(::testing::Values(vp10_highbd_convolve_horiz_sse4_1),
- ::testing::Values(vp10_highbd_convolve_vert_sse4_1),
+ SSE4_1, AV1HbdConvolveOptimzTest,
+ ::testing::Combine(::testing::Values(av1_highbd_convolve_horiz_sse4_1),
+ ::testing::Values(av1_highbd_convolve_vert_sse4_1),
::testing::ValuesIn(kBlockDim),
::testing::ValuesIn(kFilter),
::testing::ValuesIn(kSubpelQ4),
::testing::ValuesIn(kAvg),
::testing::ValuesIn(kBitdepth)));
#endif // HAVE_SSE4_1 && CONFIG_EXT_INTERP
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#endif // CONFIG_AOM_HIGHBITDEPTH
} // namespace
diff --git a/test/vp10_convolve_test.cc b/test/av1_convolve_test.cc
similarity index 72%
rename from test/vp10_convolve_test.cc
rename to test/av1_convolve_test.cc
index 2ec6ae7..69273de 100644
--- a/test/vp10_convolve_test.cc
+++ b/test/av1_convolve_test.cc
@@ -1,11 +1,11 @@
#include "third_party/googletest/src/include/gtest/gtest.h"
-#include "./vp10_rtcd.h"
-#include "./vpx_dsp_rtcd.h"
+#include "./av1_rtcd.h"
+#include "./aom_dsp_rtcd.h"
#include "test/acm_random.h"
#include "av1/common/filter.h"
-#include "av1/common/vp10_convolve.h"
-#include "aom_dsp/vpx_dsp_common.h"
+#include "av1/common/av1_convolve.h"
+#include "aom_dsp/aom_dsp_common.h"
#include "aom_ports/mem.h"
using libaom_test::ACMRandom;
@@ -13,22 +13,22 @@
namespace {
void setup_convolve() {
#if HAVE_SSSE3 && CONFIG_RUNTIME_CPU_DETECT
- vp10_convolve_horiz = vp10_convolve_horiz_c;
- vp10_convolve_vert = vp10_convolve_vert_c;
+ av1_convolve_horiz = av1_convolve_horiz_c;
+ av1_convolve_vert = av1_convolve_vert_c;
#endif
}
-TEST(VP10ConvolveTest, vp10_convolve8) {
+TEST(AV1ConvolveTest, av1_convolve8) {
ACMRandom rnd(ACMRandom::DeterministicSeed());
#if CONFIG_DUAL_FILTER
INTERP_FILTER interp_filter[4] = { EIGHTTAP_REGULAR, EIGHTTAP_REGULAR,
EIGHTTAP_REGULAR, EIGHTTAP_REGULAR };
InterpFilterParams filter_params =
- vp10_get_interp_filter_params(interp_filter[0]);
+ av1_get_interp_filter_params(interp_filter[0]);
#else
INTERP_FILTER interp_filter = EIGHTTAP_REGULAR;
InterpFilterParams filter_params =
- vp10_get_interp_filter_params(interp_filter);
+ av1_get_interp_filter_params(interp_filter);
#endif
int filter_size = filter_params.taps;
int filter_center = filter_size / 2 - 1;
@@ -52,30 +52,30 @@
src[i] = rnd.Rand16() % (1 << 8);
}
- vp10_convolve(src + src_stride * filter_center + filter_center, src_stride,
- dst, dst_stride, w, h, interp_filter, subpel_x_q4, x_step_q4,
- subpel_y_q4, y_step_q4, avg);
+ av1_convolve(src + src_stride * filter_center + filter_center, src_stride,
+ dst, dst_stride, w, h, interp_filter, subpel_x_q4, x_step_q4,
+ subpel_y_q4, y_step_q4, avg);
const int16_t *x_filter =
- vp10_get_interp_filter_subpel_kernel(filter_params, subpel_x_q4);
+ av1_get_interp_filter_subpel_kernel(filter_params, subpel_x_q4);
const int16_t *y_filter =
- vp10_get_interp_filter_subpel_kernel(filter_params, subpel_y_q4);
+ av1_get_interp_filter_subpel_kernel(filter_params, subpel_y_q4);
- vpx_convolve8_c(src + src_stride * filter_center + filter_center, src_stride,
+ aom_convolve8_c(src + src_stride * filter_center + filter_center, src_stride,
dst1, dst_stride, x_filter, 16, y_filter, 16, w, h);
EXPECT_EQ(dst[0], dst1[0]);
}
-TEST(VP10ConvolveTest, vp10_convolve) {
+TEST(AV1ConvolveTest, av1_convolve) {
ACMRandom rnd(ACMRandom::DeterministicSeed());
#if CONFIG_DUAL_FILTER
INTERP_FILTER interp_filter[4] = { EIGHTTAP_REGULAR, EIGHTTAP_REGULAR,
EIGHTTAP_REGULAR, EIGHTTAP_REGULAR };
InterpFilterParams filter_params =
- vp10_get_interp_filter_params(interp_filter[0]);
+ av1_get_interp_filter_params(interp_filter[0]);
#else
INTERP_FILTER interp_filter = EIGHTTAP_REGULAR;
InterpFilterParams filter_params =
- vp10_get_interp_filter_params(interp_filter);
+ av1_get_interp_filter_params(interp_filter);
#endif
int filter_size = filter_params.taps;
int filter_center = filter_size / 2 - 1;
@@ -100,14 +100,14 @@
for (subpel_x_q4 = 0; subpel_x_q4 < 16; subpel_x_q4++) {
for (subpel_y_q4 = 0; subpel_y_q4 < 16; subpel_y_q4++) {
- vp10_convolve(src + src_stride * filter_center + filter_center,
- src_stride, dst, dst_stride, w, h, interp_filter,
- subpel_x_q4, x_step_q4, subpel_y_q4, y_step_q4, avg);
+ av1_convolve(src + src_stride * filter_center + filter_center, src_stride,
+ dst, dst_stride, w, h, interp_filter, subpel_x_q4, x_step_q4,
+ subpel_y_q4, y_step_q4, avg);
const int16_t *x_filter =
- vp10_get_interp_filter_subpel_kernel(filter_params, subpel_x_q4);
+ av1_get_interp_filter_subpel_kernel(filter_params, subpel_x_q4);
const int16_t *y_filter =
- vp10_get_interp_filter_subpel_kernel(filter_params, subpel_y_q4);
+ av1_get_interp_filter_subpel_kernel(filter_params, subpel_y_q4);
int temp[12];
int dst_ref = 0;
@@ -125,17 +125,17 @@
}
}
-TEST(VP10ConvolveTest, vp10_convolve_avg) {
+TEST(AV1ConvolveTest, av1_convolve_avg) {
ACMRandom rnd(ACMRandom::DeterministicSeed());
#if CONFIG_DUAL_FILTER
INTERP_FILTER interp_filter[4] = { EIGHTTAP_REGULAR, EIGHTTAP_REGULAR,
EIGHTTAP_REGULAR, EIGHTTAP_REGULAR };
InterpFilterParams filter_params =
- vp10_get_interp_filter_params(interp_filter[0]);
+ av1_get_interp_filter_params(interp_filter[0]);
#else
INTERP_FILTER interp_filter = EIGHTTAP_REGULAR;
InterpFilterParams filter_params =
- vp10_get_interp_filter_params(interp_filter);
+ av1_get_interp_filter_params(interp_filter);
#endif
int filter_size = filter_params.taps;
int filter_center = filter_size / 2 - 1;
@@ -168,40 +168,40 @@
for (subpel_x_q4 = 0; subpel_x_q4 < 16; subpel_x_q4++) {
for (subpel_y_q4 = 0; subpel_y_q4 < 16; subpel_y_q4++) {
avg = 0;
- vp10_convolve(src0 + offset, src_stride, dst0, dst_stride, w, h,
- interp_filter, subpel_x_q4, x_step_q4, subpel_y_q4,
- y_step_q4, avg);
+ av1_convolve(src0 + offset, src_stride, dst0, dst_stride, w, h,
+ interp_filter, subpel_x_q4, x_step_q4, subpel_y_q4,
+ y_step_q4, avg);
avg = 0;
- vp10_convolve(src1 + offset, src_stride, dst1, dst_stride, w, h,
- interp_filter, subpel_x_q4, x_step_q4, subpel_y_q4,
- y_step_q4, avg);
+ av1_convolve(src1 + offset, src_stride, dst1, dst_stride, w, h,
+ interp_filter, subpel_x_q4, x_step_q4, subpel_y_q4,
+ y_step_q4, avg);
avg = 0;
- vp10_convolve(src0 + offset, src_stride, dst, dst_stride, w, h,
- interp_filter, subpel_x_q4, x_step_q4, subpel_y_q4,
- y_step_q4, avg);
+ av1_convolve(src0 + offset, src_stride, dst, dst_stride, w, h,
+ interp_filter, subpel_x_q4, x_step_q4, subpel_y_q4,
+ y_step_q4, avg);
avg = 1;
- vp10_convolve(src1 + offset, src_stride, dst, dst_stride, w, h,
- interp_filter, subpel_x_q4, x_step_q4, subpel_y_q4,
- y_step_q4, avg);
+ av1_convolve(src1 + offset, src_stride, dst, dst_stride, w, h,
+ interp_filter, subpel_x_q4, x_step_q4, subpel_y_q4,
+ y_step_q4, avg);
EXPECT_EQ(dst[0], ROUND_POWER_OF_TWO(dst0[0] + dst1[0], 1));
}
}
}
-#if CONFIG_VP9_HIGHBITDEPTH
-TEST(VP10ConvolveTest, vp10_highbd_convolve) {
+#if CONFIG_AOM_HIGHBITDEPTH
+TEST(AV1ConvolveTest, av1_highbd_convolve) {
ACMRandom rnd(ACMRandom::DeterministicSeed());
#if CONFIG_DUAL_FILTER
INTERP_FILTER interp_filter[4] = { EIGHTTAP_REGULAR, EIGHTTAP_REGULAR,
EIGHTTAP_REGULAR, EIGHTTAP_REGULAR };
InterpFilterParams filter_params =
- vp10_get_interp_filter_params(interp_filter[0]);
+ av1_get_interp_filter_params(interp_filter[0]);
#else
INTERP_FILTER interp_filter = EIGHTTAP_REGULAR;
InterpFilterParams filter_params =
- vp10_get_interp_filter_params(interp_filter);
+ av1_get_interp_filter_params(interp_filter);
#endif
int filter_size = filter_params.taps;
int filter_center = filter_size / 2 - 1;
@@ -225,15 +225,15 @@
for (subpel_x_q4 = 0; subpel_x_q4 < 16; subpel_x_q4++) {
for (subpel_y_q4 = 0; subpel_y_q4 < 16; subpel_y_q4++) {
- vp10_highbd_convolve(
+ av1_highbd_convolve(
CONVERT_TO_BYTEPTR(src + src_stride * filter_center + filter_center),
src_stride, CONVERT_TO_BYTEPTR(dst), dst_stride, w, h, interp_filter,
subpel_x_q4, x_step_q4, subpel_y_q4, y_step_q4, avg, bd);
const int16_t *x_filter =
- vp10_get_interp_filter_subpel_kernel(filter_params, subpel_x_q4);
+ av1_get_interp_filter_subpel_kernel(filter_params, subpel_x_q4);
const int16_t *y_filter =
- vp10_get_interp_filter_subpel_kernel(filter_params, subpel_y_q4);
+ av1_get_interp_filter_subpel_kernel(filter_params, subpel_y_q4);
int temp[12];
int dst_ref = 0;
@@ -252,17 +252,17 @@
}
}
-TEST(VP10ConvolveTest, vp10_highbd_convolve_avg) {
+TEST(AV1ConvolveTest, av1_highbd_convolve_avg) {
ACMRandom rnd(ACMRandom::DeterministicSeed());
#if CONFIG_DUAL_FILTER
INTERP_FILTER interp_filter[4] = { EIGHTTAP_REGULAR, EIGHTTAP_REGULAR,
EIGHTTAP_REGULAR, EIGHTTAP_REGULAR };
InterpFilterParams filter_params =
- vp10_get_interp_filter_params(interp_filter[0]);
+ av1_get_interp_filter_params(interp_filter[0]);
#else
INTERP_FILTER interp_filter = EIGHTTAP_REGULAR;
InterpFilterParams filter_params =
- vp10_get_interp_filter_params(interp_filter);
+ av1_get_interp_filter_params(interp_filter);
#endif
int filter_size = filter_params.taps;
int filter_center = filter_size / 2 - 1;
@@ -294,41 +294,41 @@
int offset = filter_size * filter_center + filter_center;
avg = 0;
- vp10_highbd_convolve(CONVERT_TO_BYTEPTR(src0 + offset), src_stride,
- CONVERT_TO_BYTEPTR(dst0), dst_stride, w, h,
- interp_filter, subpel_x_q4, x_step_q4, subpel_y_q4,
- y_step_q4, avg, bd);
+ av1_highbd_convolve(CONVERT_TO_BYTEPTR(src0 + offset), src_stride,
+ CONVERT_TO_BYTEPTR(dst0), dst_stride, w, h,
+ interp_filter, subpel_x_q4, x_step_q4, subpel_y_q4,
+ y_step_q4, avg, bd);
avg = 0;
- vp10_highbd_convolve(CONVERT_TO_BYTEPTR(src1 + offset), src_stride,
- CONVERT_TO_BYTEPTR(dst1), dst_stride, w, h,
- interp_filter, subpel_x_q4, x_step_q4, subpel_y_q4,
- y_step_q4, avg, bd);
+ av1_highbd_convolve(CONVERT_TO_BYTEPTR(src1 + offset), src_stride,
+ CONVERT_TO_BYTEPTR(dst1), dst_stride, w, h,
+ interp_filter, subpel_x_q4, x_step_q4, subpel_y_q4,
+ y_step_q4, avg, bd);
avg = 0;
- vp10_highbd_convolve(CONVERT_TO_BYTEPTR(src0 + offset), src_stride,
- CONVERT_TO_BYTEPTR(dst), dst_stride, w, h,
- interp_filter, subpel_x_q4, x_step_q4, subpel_y_q4,
- y_step_q4, avg, bd);
+ av1_highbd_convolve(CONVERT_TO_BYTEPTR(src0 + offset), src_stride,
+ CONVERT_TO_BYTEPTR(dst), dst_stride, w, h,
+ interp_filter, subpel_x_q4, x_step_q4, subpel_y_q4,
+ y_step_q4, avg, bd);
avg = 1;
- vp10_highbd_convolve(CONVERT_TO_BYTEPTR(src1 + offset), src_stride,
- CONVERT_TO_BYTEPTR(dst), dst_stride, w, h,
- interp_filter, subpel_x_q4, x_step_q4, subpel_y_q4,
- y_step_q4, avg, bd);
+ av1_highbd_convolve(CONVERT_TO_BYTEPTR(src1 + offset), src_stride,
+ CONVERT_TO_BYTEPTR(dst), dst_stride, w, h,
+ interp_filter, subpel_x_q4, x_step_q4, subpel_y_q4,
+ y_step_q4, avg, bd);
EXPECT_EQ(dst[0], ROUND_POWER_OF_TWO(dst0[0] + dst1[0], 1));
}
}
}
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#endif // CONFIG_AOM_HIGHBITDEPTH
#define CONVOLVE_SPEED_TEST 0
#if CONVOLVE_SPEED_TEST
#define highbd_convolve_speed(func, block_size, frame_size) \
- TEST(VP10ConvolveTest, func##_speed_##block_size##_##frame_size) { \
+ TEST(AV1ConvolveTest, func##_speed_##block_size##_##frame_size) { \
ACMRandom rnd(ACMRandom::DeterministicSeed()); \
INTERP_FILTER interp_filter = EIGHTTAP; \
InterpFilterParams filter_params = \
- vp10_get_interp_filter_params(interp_filter); \
+ av1_get_interp_filter_params(interp_filter); \
int filter_size = filter_params.tap; \
int filter_center = filter_size / 2 - 1; \
DECLARE_ALIGNED(16, uint16_t, \
@@ -346,9 +346,9 @@
int h = block_size; \
\
const int16_t *filter_x = \
- vp10_get_interp_filter_kernel(filter_params, subpel_x_q4); \
+ av1_get_interp_filter_kernel(filter_params, subpel_x_q4); \
const int16_t *filter_y = \
- vp10_get_interp_filter_kernel(filter_params, subpel_y_q4); \
+ av1_get_interp_filter_kernel(filter_params, subpel_y_q4); \
\
for (int i = 0; i < src_stride * src_stride; i++) { \
src[i] = rnd.Rand16() % (1 << bd); \
@@ -376,11 +376,11 @@
}
#define lowbd_convolve_speed(func, block_size, frame_size) \
- TEST(VP10ConvolveTest, func##_speed_l_##block_size##_##frame_size) { \
+ TEST(AV1ConvolveTest, func##_speed_l_##block_size##_##frame_size) { \
ACMRandom rnd(ACMRandom::DeterministicSeed()); \
INTERP_FILTER interp_filter = EIGHTTAP; \
InterpFilterParams filter_params = \
- vp10_get_interp_filter_params(interp_filter); \
+ av1_get_interp_filter_params(interp_filter); \
int filter_size = filter_params.tap; \
int filter_center = filter_size / 2 - 1; \
DECLARE_ALIGNED(16, uint8_t, src[(frame_size + 7) * (frame_size + 7)]); \
@@ -397,9 +397,9 @@
int h = block_size; \
\
const int16_t *filter_x = \
- vp10_get_interp_filter_kernel(filter_params, subpel_x_q4); \
+ av1_get_interp_filter_kernel(filter_params, subpel_x_q4); \
const int16_t *filter_y = \
- vp10_get_interp_filter_kernel(filter_params, subpel_y_q4); \
+ av1_get_interp_filter_kernel(filter_params, subpel_y_q4); \
\
for (int i = 0; i < src_stride * src_stride; i++) { \
src[i] = rnd.Rand16() % (1 << bd); \
@@ -424,28 +424,28 @@
}
// This experiment shows that when frame size is 64x64
-// vpx_highbd_convolve8_sse2 and vpx_convolve8_sse2's speed are similar.
+// aom_highbd_convolve8_sse2 and aom_convolve8_sse2's speed are similar.
// However when frame size becomes 1024x1024
-// vpx_highbd_convolve8_sse2 is around 50% slower than vpx_convolve8_sse2
+// aom_highbd_convolve8_sse2 is around 50% slower than aom_convolve8_sse2
// we think the bottleneck is from memory IO
-highbd_convolve_speed(vpx_highbd_convolve8_sse2, 8, 64);
-highbd_convolve_speed(vpx_highbd_convolve8_sse2, 16, 64);
-highbd_convolve_speed(vpx_highbd_convolve8_sse2, 32, 64);
-highbd_convolve_speed(vpx_highbd_convolve8_sse2, 64, 64);
+highbd_convolve_speed(aom_highbd_convolve8_sse2, 8, 64);
+highbd_convolve_speed(aom_highbd_convolve8_sse2, 16, 64);
+highbd_convolve_speed(aom_highbd_convolve8_sse2, 32, 64);
+highbd_convolve_speed(aom_highbd_convolve8_sse2, 64, 64);
-lowbd_convolve_speed(vpx_convolve8_sse2, 8, 64);
-lowbd_convolve_speed(vpx_convolve8_sse2, 16, 64);
-lowbd_convolve_speed(vpx_convolve8_sse2, 32, 64);
-lowbd_convolve_speed(vpx_convolve8_sse2, 64, 64);
+lowbd_convolve_speed(aom_convolve8_sse2, 8, 64);
+lowbd_convolve_speed(aom_convolve8_sse2, 16, 64);
+lowbd_convolve_speed(aom_convolve8_sse2, 32, 64);
+lowbd_convolve_speed(aom_convolve8_sse2, 64, 64);
-highbd_convolve_speed(vpx_highbd_convolve8_sse2, 8, 1024);
-highbd_convolve_speed(vpx_highbd_convolve8_sse2, 16, 1024);
-highbd_convolve_speed(vpx_highbd_convolve8_sse2, 32, 1024);
-highbd_convolve_speed(vpx_highbd_convolve8_sse2, 64, 1024);
+highbd_convolve_speed(aom_highbd_convolve8_sse2, 8, 1024);
+highbd_convolve_speed(aom_highbd_convolve8_sse2, 16, 1024);
+highbd_convolve_speed(aom_highbd_convolve8_sse2, 32, 1024);
+highbd_convolve_speed(aom_highbd_convolve8_sse2, 64, 1024);
-lowbd_convolve_speed(vpx_convolve8_sse2, 8, 1024);
-lowbd_convolve_speed(vpx_convolve8_sse2, 16, 1024);
-lowbd_convolve_speed(vpx_convolve8_sse2, 32, 1024);
-lowbd_convolve_speed(vpx_convolve8_sse2, 64, 1024);
+lowbd_convolve_speed(aom_convolve8_sse2, 8, 1024);
+lowbd_convolve_speed(aom_convolve8_sse2, 16, 1024);
+lowbd_convolve_speed(aom_convolve8_sse2, 32, 1024);
+lowbd_convolve_speed(aom_convolve8_sse2, 64, 1024);
#endif // CONVOLVE_SPEED_TEST
} // namespace
diff --git a/test/vp10_dct_test.cc b/test/av1_dct_test.cc
similarity index 92%
rename from test/vp10_dct_test.cc
rename to test/av1_dct_test.cc
index 5d31adf..82b0199 100644
--- a/test/vp10_dct_test.cc
+++ b/test/av1_dct_test.cc
@@ -15,7 +15,7 @@
#include "third_party/googletest/src/include/gtest/gtest.h"
#include "test/acm_random.h"
#include "test/util.h"
-#include "./vpx_config.h"
+#include "./aom_config.h"
#include "aom_ports/msvc.h"
#undef CONFIG_COEFFICIENT_RANGE_CHECKING
@@ -83,8 +83,8 @@
};
typedef std::tr1::tuple<FdctFunc, FdctFuncRef, int, int> FdctParam;
-class Vp10FwdTxfm : public TransTestBase,
- public ::testing::TestWithParam<FdctParam> {
+class AV1FwdTxfm : public TransTestBase,
+ public ::testing::TestWithParam<FdctParam> {
public:
virtual void SetUp() {
fwd_txfm_ = GET_PARAM(0);
@@ -95,10 +95,10 @@
virtual void TearDown() {}
};
-TEST_P(Vp10FwdTxfm, RunFwdAccuracyCheck) { RunFwdAccuracyCheck(); }
+TEST_P(AV1FwdTxfm, RunFwdAccuracyCheck) { RunFwdAccuracyCheck(); }
INSTANTIATE_TEST_CASE_P(
- C, Vp10FwdTxfm,
+ C, AV1FwdTxfm,
::testing::Values(FdctParam(&fdct4, &reference_dct_1d, 4, 1),
FdctParam(&fdct8, &reference_dct_1d, 8, 1),
FdctParam(&fdct16, &reference_dct_1d, 16, 2)));
diff --git a/test/vp10_ext_tile_test.cc b/test/av1_ext_tile_test.cc
similarity index 70%
rename from test/vp10_ext_tile_test.cc
rename to test/av1_ext_tile_test.cc
index 6ca7ec8..9563fd5 100644
--- a/test/vp10_ext_tile_test.cc
+++ b/test/av1_ext_tile_test.cc
@@ -29,31 +29,31 @@
const int kImgWidth = 704;
const int kImgHeight = 576;
-class VP10ExtTileTest
+class AV1ExtTileTest
: public ::libaom_test::EncoderTest,
public ::libaom_test::CodecTestWith2Params<libaom_test::TestMode, int> {
protected:
- VP10ExtTileTest()
+ AV1ExtTileTest()
: EncoderTest(GET_PARAM(0)), encoding_mode_(GET_PARAM(1)),
set_cpu_used_(GET_PARAM(2)) {
- init_flags_ = VPX_CODEC_USE_PSNR;
- vpx_codec_dec_cfg_t cfg = vpx_codec_dec_cfg_t();
+ init_flags_ = AOM_CODEC_USE_PSNR;
+ aom_codec_dec_cfg_t cfg = aom_codec_dec_cfg_t();
cfg.w = kImgWidth;
cfg.h = kImgHeight;
decoder_ = codec_->CreateDecoder(cfg, 0);
- decoder_->Control(VP10_SET_DECODE_TILE_ROW, -1);
- decoder_->Control(VP10_SET_DECODE_TILE_COL, -1);
+ decoder_->Control(AV1_SET_DECODE_TILE_ROW, -1);
+ decoder_->Control(AV1_SET_DECODE_TILE_COL, -1);
// Allocate buffer to store tile image.
- vpx_img_alloc(&tile_img_, VPX_IMG_FMT_I420, kImgWidth, kImgHeight, 32);
+ aom_img_alloc(&tile_img_, AOM_IMG_FMT_I420, kImgWidth, kImgHeight, 32);
md5_.clear();
tile_md5_.clear();
}
- virtual ~VP10ExtTileTest() {
- vpx_img_free(&tile_img_);
+ virtual ~AV1ExtTileTest() {
+ aom_img_free(&tile_img_);
delete decoder_;
}
@@ -62,7 +62,7 @@
SetMode(encoding_mode_);
cfg_.g_lag_in_frames = 0;
- cfg_.rc_end_usage = VPX_VBR;
+ cfg_.rc_end_usage = AOM_VBR;
cfg_.g_error_resilient = 1;
cfg_.rc_max_quantizer = 56;
@@ -73,30 +73,30 @@
::libaom_test::Encoder *encoder) {
if (video->frame() == 0) {
// Encode setting
- encoder->Control(VP8E_SET_CPUUSED, set_cpu_used_);
- encoder->Control(VP8E_SET_ENABLEAUTOALTREF, 0);
- encoder->Control(VP9E_SET_FRAME_PARALLEL_DECODING, 1);
+ encoder->Control(AOME_SET_CPUUSED, set_cpu_used_);
+ encoder->Control(AOME_SET_ENABLEAUTOALTREF, 0);
+ encoder->Control(AV1E_SET_FRAME_PARALLEL_DECODING, 1);
// The tile size is 64x64.
- encoder->Control(VP9E_SET_TILE_COLUMNS, kTileSize);
- encoder->Control(VP9E_SET_TILE_ROWS, kTileSize);
+ encoder->Control(AV1E_SET_TILE_COLUMNS, kTileSize);
+ encoder->Control(AV1E_SET_TILE_ROWS, kTileSize);
#if CONFIG_EXT_PARTITION
// Always use 64x64 max partition.
- encoder->Control(VP10E_SET_SUPERBLOCK_SIZE, VPX_SUPERBLOCK_SIZE_64X64);
+ encoder->Control(AV1E_SET_SUPERBLOCK_SIZE, AOM_SUPERBLOCK_SIZE_64X64);
#endif
}
if (video->frame() == 1) {
frame_flags_ =
- VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF;
+ AOM_EFLAG_NO_UPD_LAST | AOM_EFLAG_NO_UPD_GF | AOM_EFLAG_NO_UPD_ARF;
}
}
- virtual void DecompressedFrameHook(const vpx_image_t &img,
- vpx_codec_pts_t pts) {
+ virtual void DecompressedFrameHook(const aom_image_t &img,
+ aom_codec_pts_t pts) {
// Skip 1 already decoded frame to be consistent with the decoder in this
// test.
- if (pts == (vpx_codec_pts_t)kSkip) return;
+ if (pts == (aom_codec_pts_t)kSkip) return;
// Calculate MD5 as the reference.
::libaom_test::MD5 md5_res;
@@ -104,32 +104,32 @@
md5_.push_back(md5_res.Get());
}
- virtual void FramePktHook(const vpx_codec_cx_pkt_t *pkt) {
+ virtual void FramePktHook(const aom_codec_cx_pkt_t *pkt) {
// Skip decoding 1 frame.
- if (pkt->data.frame.pts == (vpx_codec_pts_t)kSkip) return;
+ if (pkt->data.frame.pts == (aom_codec_pts_t)kSkip) return;
- bool IsLastFrame = (pkt->data.frame.pts == (vpx_codec_pts_t)(kLimit - 1));
+ bool IsLastFrame = (pkt->data.frame.pts == (aom_codec_pts_t)(kLimit - 1));
// Decode the first (kLimit - 1) frames as whole frame, and decode the last
// frame in single tiles.
for (int r = 0; r < kImgHeight / kTIleSizeInPixels; ++r) {
for (int c = 0; c < kImgWidth / kTIleSizeInPixels; ++c) {
if (!IsLastFrame) {
- decoder_->Control(VP10_SET_DECODE_TILE_ROW, -1);
- decoder_->Control(VP10_SET_DECODE_TILE_COL, -1);
+ decoder_->Control(AV1_SET_DECODE_TILE_ROW, -1);
+ decoder_->Control(AV1_SET_DECODE_TILE_COL, -1);
} else {
- decoder_->Control(VP10_SET_DECODE_TILE_ROW, r);
- decoder_->Control(VP10_SET_DECODE_TILE_COL, c);
+ decoder_->Control(AV1_SET_DECODE_TILE_ROW, r);
+ decoder_->Control(AV1_SET_DECODE_TILE_COL, c);
}
- const vpx_codec_err_t res = decoder_->DecodeFrame(
+ const aom_codec_err_t res = decoder_->DecodeFrame(
reinterpret_cast<uint8_t *>(pkt->data.frame.buf),
pkt->data.frame.sz);
- if (res != VPX_CODEC_OK) {
+ if (res != AOM_CODEC_OK) {
abort_ = true;
- ASSERT_EQ(VPX_CODEC_OK, res);
+ ASSERT_EQ(AOM_CODEC_OK, res);
}
- const vpx_image_t *img = decoder_->GetDxData().Next();
+ const aom_image_t *img = decoder_->GetDxData().Next();
if (!IsLastFrame) {
if (img) {
@@ -168,29 +168,29 @@
::libaom_test::TestMode encoding_mode_;
int set_cpu_used_;
::libaom_test::Decoder *decoder_;
- vpx_image_t tile_img_;
+ aom_image_t tile_img_;
std::vector<std::string> md5_;
std::vector<std::string> tile_md5_;
};
-TEST_P(VP10ExtTileTest, DecoderResultTest) {
+TEST_P(AV1ExtTileTest, DecoderResultTest) {
::libaom_test::I420VideoSource video("hantro_collage_w352h288.yuv", kImgWidth,
kImgHeight, 30, 1, 0, kLimit);
cfg_.rc_target_bitrate = 500;
- cfg_.g_error_resilient = VPX_ERROR_RESILIENT_DEFAULT;
+ cfg_.g_error_resilient = AOM_ERROR_RESILIENT_DEFAULT;
cfg_.g_lag_in_frames = 0;
cfg_.g_threads = 1;
// Tile encoding
- init_flags_ = VPX_CODEC_USE_PSNR;
+ init_flags_ = AOM_CODEC_USE_PSNR;
ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
// Compare to check if two vectors are equal.
ASSERT_EQ(md5_, tile_md5_);
}
-VP10_INSTANTIATE_TEST_CASE(
+AV1_INSTANTIATE_TEST_CASE(
// Now only test 2-pass mode.
- VP10ExtTileTest, ::testing::Values(::libaom_test::kTwoPassGood),
+ AV1ExtTileTest, ::testing::Values(::libaom_test::kTwoPassGood),
::testing::Range(0, 4));
} // namespace
diff --git a/test/av1_fht16x16_test.cc b/test/av1_fht16x16_test.cc
new file mode 100644
index 0000000..a9b2549
--- /dev/null
+++ b/test/av1_fht16x16_test.cc
@@ -0,0 +1,220 @@
+/*
+ * Copyright (c) 2016 The WebM project authors. All Rights Reserved.
+ *
+ * Use of this source code is governed by a BSD-style license
+ * that can be found in the LICENSE file in the root of the source
+ * tree. An additional intellectual property rights grant can be found
+ * in the file PATENTS. All contributing project authors may
+ * be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "third_party/googletest/src/include/gtest/gtest.h"
+
+#include "./av1_rtcd.h"
+#include "./aom_dsp_rtcd.h"
+
+#include "test/acm_random.h"
+#include "test/clear_system_state.h"
+#include "test/register_state_check.h"
+#include "test/transform_test_base.h"
+#include "test/util.h"
+#include "aom_ports/mem.h"
+
+using libaom_test::ACMRandom;
+
+namespace {
+typedef void (*IhtFunc)(const tran_low_t *in, uint8_t *out, int stride,
+ int tx_type);
+using std::tr1::tuple;
+using libaom_test::FhtFunc;
+typedef tuple<FhtFunc, IhtFunc, int, aom_bit_depth_t, int> Ht16x16Param;
+
+void fht16x16_ref(const int16_t *in, tran_low_t *out, int stride, int tx_type) {
+ av1_fht16x16_c(in, out, stride, tx_type);
+}
+
+#if CONFIG_AOM_HIGHBITDEPTH
+typedef void (*IHbdHtFunc)(const tran_low_t *in, uint8_t *out, int stride,
+ int tx_type, int bd);
+typedef void (*HbdHtFunc)(const int16_t *input, int32_t *output, int stride,
+ int tx_type, int bd);
+
+// Target optimized function, tx_type, bit depth
+typedef tuple<HbdHtFunc, int, int> HighbdHt16x16Param;
+
+void highbd_fht16x16_ref(const int16_t *in, int32_t *out, int stride,
+ int tx_type, int bd) {
+ av1_fwd_txfm2d_16x16_c(in, out, stride, tx_type, bd);
+}
+#endif // CONFIG_AOM_HIGHBITDEPTH
+
+class AV1Trans16x16HT : public libaom_test::TransformTestBase,
+ public ::testing::TestWithParam<Ht16x16Param> {
+ public:
+ virtual ~AV1Trans16x16HT() {}
+
+ virtual void SetUp() {
+ fwd_txfm_ = GET_PARAM(0);
+ inv_txfm_ = GET_PARAM(1);
+ tx_type_ = GET_PARAM(2);
+ pitch_ = 16;
+ fwd_txfm_ref = fht16x16_ref;
+ bit_depth_ = GET_PARAM(3);
+ mask_ = (1 << bit_depth_) - 1;
+ num_coeffs_ = GET_PARAM(4);
+ }
+ virtual void TearDown() { libaom_test::ClearSystemState(); }
+
+ protected:
+ void RunFwdTxfm(const int16_t *in, tran_low_t *out, int stride) {
+ fwd_txfm_(in, out, stride, tx_type_);
+ }
+
+ void RunInvTxfm(const tran_low_t *out, uint8_t *dst, int stride) {
+ inv_txfm_(out, dst, stride, tx_type_);
+ }
+
+ FhtFunc fwd_txfm_;
+ IhtFunc inv_txfm_;
+};
+
+TEST_P(AV1Trans16x16HT, CoeffCheck) { RunCoeffCheck(); }
+
+#if CONFIG_AOM_HIGHBITDEPTH
+class AV1HighbdTrans16x16HT
+ : public ::testing::TestWithParam<HighbdHt16x16Param> {
+ public:
+ virtual ~AV1HighbdTrans16x16HT() {}
+
+ virtual void SetUp() {
+ fwd_txfm_ = GET_PARAM(0);
+ fwd_txfm_ref_ = highbd_fht16x16_ref;
+ tx_type_ = GET_PARAM(1);
+ bit_depth_ = GET_PARAM(2);
+ mask_ = (1 << bit_depth_) - 1;
+ num_coeffs_ = 256;
+
+ input_ = reinterpret_cast<int16_t *>(
+ aom_memalign(16, sizeof(int16_t) * num_coeffs_));
+ output_ = reinterpret_cast<int32_t *>(
+ aom_memalign(16, sizeof(int32_t) * num_coeffs_));
+ output_ref_ = reinterpret_cast<int32_t *>(
+ aom_memalign(16, sizeof(int32_t) * num_coeffs_));
+ }
+
+ virtual void TearDown() {
+ aom_free(input_);
+ aom_free(output_);
+ aom_free(output_ref_);
+ libaom_test::ClearSystemState();
+ }
+
+ protected:
+ void RunBitexactCheck();
+
+ private:
+ HbdHtFunc fwd_txfm_;
+ HbdHtFunc fwd_txfm_ref_;
+ int tx_type_;
+ int bit_depth_;
+ int mask_;
+ int num_coeffs_;
+ int16_t *input_;
+ int32_t *output_;
+ int32_t *output_ref_;
+};
+
+void AV1HighbdTrans16x16HT::RunBitexactCheck() {
+ ACMRandom rnd(ACMRandom::DeterministicSeed());
+ int i, j;
+ const int stride = 16;
+ const int num_tests = 1000;
+
+ for (i = 0; i < num_tests; ++i) {
+ for (j = 0; j < num_coeffs_; ++j) {
+ input_[j] = (rnd.Rand16() & mask_) - (rnd.Rand16() & mask_);
+ }
+
+ fwd_txfm_ref_(input_, output_ref_, stride, tx_type_, bit_depth_);
+ ASM_REGISTER_STATE_CHECK(
+ fwd_txfm_(input_, output_, stride, tx_type_, bit_depth_));
+
+ for (j = 0; j < num_coeffs_; ++j) {
+ EXPECT_EQ(output_ref_[j], output_[j])
+ << "Not bit-exact result at index: " << j << " at test block: " << i;
+ }
+ }
+}
+
+TEST_P(AV1HighbdTrans16x16HT, HighbdCoeffCheck) { RunBitexactCheck(); }
+#endif // CONFIG_AOM_HIGHBITDEPTH
+
+using std::tr1::make_tuple;
+
+#if HAVE_SSE2
+const Ht16x16Param kArrayHt16x16Param_sse2[] = {
+ make_tuple(&av1_fht16x16_sse2, &av1_iht16x16_256_add_sse2, 0, AOM_BITS_8,
+ 256),
+ make_tuple(&av1_fht16x16_sse2, &av1_iht16x16_256_add_sse2, 1, AOM_BITS_8,
+ 256),
+ make_tuple(&av1_fht16x16_sse2, &av1_iht16x16_256_add_sse2, 2, AOM_BITS_8,
+ 256),
+ make_tuple(&av1_fht16x16_sse2, &av1_iht16x16_256_add_sse2, 3, AOM_BITS_8,
+ 256),
+#if CONFIG_EXT_TX
+ make_tuple(&av1_fht16x16_sse2, &av1_iht16x16_256_add_sse2, 4, AOM_BITS_8,
+ 256),
+ make_tuple(&av1_fht16x16_sse2, &av1_iht16x16_256_add_sse2, 5, AOM_BITS_8,
+ 256),
+ make_tuple(&av1_fht16x16_sse2, &av1_iht16x16_256_add_sse2, 6, AOM_BITS_8,
+ 256),
+ make_tuple(&av1_fht16x16_sse2, &av1_iht16x16_256_add_sse2, 7, AOM_BITS_8,
+ 256),
+ make_tuple(&av1_fht16x16_sse2, &av1_iht16x16_256_add_sse2, 8, AOM_BITS_8,
+ 256),
+ make_tuple(&av1_fht16x16_sse2, &av1_iht16x16_256_add_sse2, 10, AOM_BITS_8,
+ 256),
+ make_tuple(&av1_fht16x16_sse2, &av1_iht16x16_256_add_sse2, 11, AOM_BITS_8,
+ 256),
+ make_tuple(&av1_fht16x16_sse2, &av1_iht16x16_256_add_sse2, 12, AOM_BITS_8,
+ 256),
+ make_tuple(&av1_fht16x16_sse2, &av1_iht16x16_256_add_sse2, 13, AOM_BITS_8,
+ 256),
+ make_tuple(&av1_fht16x16_sse2, &av1_iht16x16_256_add_sse2, 14, AOM_BITS_8,
+ 256),
+ make_tuple(&av1_fht16x16_sse2, &av1_iht16x16_256_add_sse2, 15, AOM_BITS_8,
+ 256)
+#endif // CONFIG_EXT_TX
+};
+INSTANTIATE_TEST_CASE_P(SSE2, AV1Trans16x16HT,
+ ::testing::ValuesIn(kArrayHt16x16Param_sse2));
+#endif // HAVE_SSE2
+
+#if HAVE_SSE4_1 && CONFIG_AOM_HIGHBITDEPTH
+const HighbdHt16x16Param kArrayHBDHt16x16Param_sse4_1[] = {
+ make_tuple(&av1_fwd_txfm2d_16x16_sse4_1, 0, 10),
+ make_tuple(&av1_fwd_txfm2d_16x16_sse4_1, 0, 12),
+ make_tuple(&av1_fwd_txfm2d_16x16_sse4_1, 1, 10),
+ make_tuple(&av1_fwd_txfm2d_16x16_sse4_1, 1, 12),
+ make_tuple(&av1_fwd_txfm2d_16x16_sse4_1, 2, 10),
+ make_tuple(&av1_fwd_txfm2d_16x16_sse4_1, 2, 12),
+ make_tuple(&av1_fwd_txfm2d_16x16_sse4_1, 3, 10),
+ make_tuple(&av1_fwd_txfm2d_16x16_sse4_1, 3, 12),
+#if CONFIG_EXT_TX
+ make_tuple(&av1_fwd_txfm2d_16x16_sse4_1, 4, 10),
+ make_tuple(&av1_fwd_txfm2d_16x16_sse4_1, 4, 12),
+ make_tuple(&av1_fwd_txfm2d_16x16_sse4_1, 5, 10),
+ make_tuple(&av1_fwd_txfm2d_16x16_sse4_1, 5, 12),
+ make_tuple(&av1_fwd_txfm2d_16x16_sse4_1, 6, 10),
+ make_tuple(&av1_fwd_txfm2d_16x16_sse4_1, 6, 12),
+ make_tuple(&av1_fwd_txfm2d_16x16_sse4_1, 7, 10),
+ make_tuple(&av1_fwd_txfm2d_16x16_sse4_1, 7, 12),
+ make_tuple(&av1_fwd_txfm2d_16x16_sse4_1, 8, 10),
+ make_tuple(&av1_fwd_txfm2d_16x16_sse4_1, 8, 12),
+#endif // CONFIG_EXT_TX
+};
+INSTANTIATE_TEST_CASE_P(SSE4_1, AV1HighbdTrans16x16HT,
+ ::testing::ValuesIn(kArrayHBDHt16x16Param_sse4_1));
+#endif // HAVE_SSE4_1 && CONFIG_AOM_HIGHBITDEPTH
+
+} // namespace
diff --git a/test/av1_fht4x4_test.cc b/test/av1_fht4x4_test.cc
new file mode 100644
index 0000000..104b8652
--- /dev/null
+++ b/test/av1_fht4x4_test.cc
@@ -0,0 +1,207 @@
+/*
+ * Copyright (c) 2016 The WebM project authors. All Rights Reserved.
+ *
+ * Use of this source code is governed by a BSD-style license
+ * that can be found in the LICENSE file in the root of the source
+ * tree. An additional intellectual property rights grant can be found
+ * in the file PATENTS. All contributing project authors may
+ * be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "third_party/googletest/src/include/gtest/gtest.h"
+
+#include "./av1_rtcd.h"
+#include "./aom_dsp_rtcd.h"
+
+#include "test/acm_random.h"
+#include "test/clear_system_state.h"
+#include "test/register_state_check.h"
+#include "test/transform_test_base.h"
+#include "test/util.h"
+#include "aom_ports/mem.h"
+
+using libaom_test::ACMRandom;
+
+namespace {
+typedef void (*IhtFunc)(const tran_low_t *in, uint8_t *out, int stride,
+ int tx_type);
+using std::tr1::tuple;
+using libaom_test::FhtFunc;
+typedef tuple<FhtFunc, IhtFunc, int, aom_bit_depth_t, int> Ht4x4Param;
+
+void fht4x4_ref(const int16_t *in, tran_low_t *out, int stride, int tx_type) {
+ av1_fht4x4_c(in, out, stride, tx_type);
+}
+
+#if CONFIG_AOM_HIGHBITDEPTH
+typedef void (*IhighbdHtFunc)(const tran_low_t *in, uint8_t *out, int stride,
+ int tx_type, int bd);
+typedef void (*HBDFhtFunc)(const int16_t *input, int32_t *output, int stride,
+ int tx_type, int bd);
+
+// HighbdHt4x4Param argument list:
+// <Target optimized function, tx_type, bit depth>
+typedef tuple<HBDFhtFunc, int, int> HighbdHt4x4Param;
+
+void highbe_fht4x4_ref(const int16_t *in, int32_t *out, int stride, int tx_type,
+ int bd) {
+ av1_fwd_txfm2d_4x4_c(in, out, stride, tx_type, bd);
+}
+#endif // CONFIG_AOM_HIGHBITDEPTH
+
+class AV1Trans4x4HT : public libaom_test::TransformTestBase,
+ public ::testing::TestWithParam<Ht4x4Param> {
+ public:
+ virtual ~AV1Trans4x4HT() {}
+
+ virtual void SetUp() {
+ fwd_txfm_ = GET_PARAM(0);
+ inv_txfm_ = GET_PARAM(1);
+ tx_type_ = GET_PARAM(2);
+ pitch_ = 4;
+ fwd_txfm_ref = fht4x4_ref;
+ bit_depth_ = GET_PARAM(3);
+ mask_ = (1 << bit_depth_) - 1;
+ num_coeffs_ = GET_PARAM(4);
+ }
+ virtual void TearDown() { libaom_test::ClearSystemState(); }
+
+ protected:
+ void RunFwdTxfm(const int16_t *in, tran_low_t *out, int stride) {
+ fwd_txfm_(in, out, stride, tx_type_);
+ }
+
+ void RunInvTxfm(const tran_low_t *out, uint8_t *dst, int stride) {
+ inv_txfm_(out, dst, stride, tx_type_);
+ }
+
+ FhtFunc fwd_txfm_;
+ IhtFunc inv_txfm_;
+};
+
+TEST_P(AV1Trans4x4HT, CoeffCheck) { RunCoeffCheck(); }
+
+#if CONFIG_AOM_HIGHBITDEPTH
+class AV1HighbdTrans4x4HT : public ::testing::TestWithParam<HighbdHt4x4Param> {
+ public:
+ virtual ~AV1HighbdTrans4x4HT() {}
+
+ virtual void SetUp() {
+ fwd_txfm_ = GET_PARAM(0);
+ fwd_txfm_ref_ = highbe_fht4x4_ref;
+ tx_type_ = GET_PARAM(1);
+ bit_depth_ = GET_PARAM(2);
+ mask_ = (1 << bit_depth_) - 1;
+ num_coeffs_ = 16;
+
+ input_ = reinterpret_cast<int16_t *>(
+ aom_memalign(16, sizeof(int16_t) * num_coeffs_));
+ output_ = reinterpret_cast<int32_t *>(
+ aom_memalign(16, sizeof(int32_t) * num_coeffs_));
+ output_ref_ = reinterpret_cast<int32_t *>(
+ aom_memalign(16, sizeof(int32_t) * num_coeffs_));
+ }
+
+ virtual void TearDown() {
+ aom_free(input_);
+ aom_free(output_);
+ aom_free(output_ref_);
+ libaom_test::ClearSystemState();
+ }
+
+ protected:
+ void RunBitexactCheck();
+
+ private:
+ HBDFhtFunc fwd_txfm_;
+ HBDFhtFunc fwd_txfm_ref_;
+ int tx_type_;
+ int bit_depth_;
+ int mask_;
+ int num_coeffs_;
+ int16_t *input_;
+ int32_t *output_;
+ int32_t *output_ref_;
+};
+
+void AV1HighbdTrans4x4HT::RunBitexactCheck() {
+ ACMRandom rnd(ACMRandom::DeterministicSeed());
+ int i, j;
+ const int stride = 4;
+ const int num_tests = 1000;
+ const int num_coeffs = 16;
+
+ for (i = 0; i < num_tests; ++i) {
+ for (j = 0; j < num_coeffs; ++j) {
+ input_[j] = (rnd.Rand16() & mask_) - (rnd.Rand16() & mask_);
+ }
+
+ fwd_txfm_ref_(input_, output_ref_, stride, tx_type_, bit_depth_);
+ fwd_txfm_(input_, output_, stride, tx_type_, bit_depth_);
+
+ for (j = 0; j < num_coeffs; ++j) {
+ EXPECT_EQ(output_[j], output_ref_[j])
+ << "Not bit-exact result at index: " << j << " at test block: " << i;
+ }
+ }
+}
+
+TEST_P(AV1HighbdTrans4x4HT, HighbdCoeffCheck) { RunBitexactCheck(); }
+#endif // CONFIG_AOM_HIGHBITDEPTH
+
+using std::tr1::make_tuple;
+
+#if HAVE_SSE2
+const Ht4x4Param kArrayHt4x4Param_sse2[] = {
+ make_tuple(&av1_fht4x4_sse2, &av1_iht4x4_16_add_sse2, 0, AOM_BITS_8, 16),
+ make_tuple(&av1_fht4x4_sse2, &av1_iht4x4_16_add_sse2, 1, AOM_BITS_8, 16),
+ make_tuple(&av1_fht4x4_sse2, &av1_iht4x4_16_add_sse2, 2, AOM_BITS_8, 16),
+ make_tuple(&av1_fht4x4_sse2, &av1_iht4x4_16_add_sse2, 3, AOM_BITS_8, 16),
+#if CONFIG_EXT_TX
+ make_tuple(&av1_fht4x4_sse2, &av1_iht4x4_16_add_sse2, 4, AOM_BITS_8, 16),
+ make_tuple(&av1_fht4x4_sse2, &av1_iht4x4_16_add_sse2, 5, AOM_BITS_8, 16),
+ make_tuple(&av1_fht4x4_sse2, &av1_iht4x4_16_add_sse2, 6, AOM_BITS_8, 16),
+ make_tuple(&av1_fht4x4_sse2, &av1_iht4x4_16_add_sse2, 7, AOM_BITS_8, 16),
+ make_tuple(&av1_fht4x4_sse2, &av1_iht4x4_16_add_sse2, 8, AOM_BITS_8, 16),
+ make_tuple(&av1_fht4x4_sse2, &av1_iht4x4_16_add_sse2, 10, AOM_BITS_8, 16),
+ make_tuple(&av1_fht4x4_sse2, &av1_iht4x4_16_add_sse2, 11, AOM_BITS_8, 16),
+ make_tuple(&av1_fht4x4_sse2, &av1_iht4x4_16_add_sse2, 12, AOM_BITS_8, 16),
+ make_tuple(&av1_fht4x4_sse2, &av1_iht4x4_16_add_sse2, 13, AOM_BITS_8, 16),
+ make_tuple(&av1_fht4x4_sse2, &av1_iht4x4_16_add_sse2, 14, AOM_BITS_8, 16),
+ make_tuple(&av1_fht4x4_sse2, &av1_iht4x4_16_add_sse2, 15, AOM_BITS_8, 16)
+#endif // CONFIG_EXT_TX
+};
+INSTANTIATE_TEST_CASE_P(SSE2, AV1Trans4x4HT,
+ ::testing::ValuesIn(kArrayHt4x4Param_sse2));
+#endif // HAVE_SSE2
+
+#if HAVE_SSE4_1 && CONFIG_AOM_HIGHBITDEPTH
+const HighbdHt4x4Param kArrayHighbdHt4x4Param[] = {
+ make_tuple(&av1_fwd_txfm2d_4x4_sse4_1, 0, 10),
+ make_tuple(&av1_fwd_txfm2d_4x4_sse4_1, 0, 12),
+ make_tuple(&av1_fwd_txfm2d_4x4_sse4_1, 1, 10),
+ make_tuple(&av1_fwd_txfm2d_4x4_sse4_1, 1, 12),
+ make_tuple(&av1_fwd_txfm2d_4x4_sse4_1, 2, 10),
+ make_tuple(&av1_fwd_txfm2d_4x4_sse4_1, 2, 12),
+ make_tuple(&av1_fwd_txfm2d_4x4_sse4_1, 3, 10),
+ make_tuple(&av1_fwd_txfm2d_4x4_sse4_1, 3, 12),
+#if CONFIG_EXT_TX
+ make_tuple(&av1_fwd_txfm2d_4x4_sse4_1, 4, 10),
+ make_tuple(&av1_fwd_txfm2d_4x4_sse4_1, 4, 12),
+ make_tuple(&av1_fwd_txfm2d_4x4_sse4_1, 5, 10),
+ make_tuple(&av1_fwd_txfm2d_4x4_sse4_1, 5, 12),
+ make_tuple(&av1_fwd_txfm2d_4x4_sse4_1, 6, 10),
+ make_tuple(&av1_fwd_txfm2d_4x4_sse4_1, 6, 12),
+ make_tuple(&av1_fwd_txfm2d_4x4_sse4_1, 7, 10),
+ make_tuple(&av1_fwd_txfm2d_4x4_sse4_1, 7, 12),
+ make_tuple(&av1_fwd_txfm2d_4x4_sse4_1, 8, 10),
+ make_tuple(&av1_fwd_txfm2d_4x4_sse4_1, 8, 12),
+#endif // CONFIG_EXT_TX
+};
+
+INSTANTIATE_TEST_CASE_P(SSE4_1, AV1HighbdTrans4x4HT,
+ ::testing::ValuesIn(kArrayHighbdHt4x4Param));
+
+#endif // HAVE_SSE4_1 && CONFIG_AOM_HIGHBITDEPTH
+
+} // namespace
diff --git a/test/av1_fht8x8_test.cc b/test/av1_fht8x8_test.cc
new file mode 100644
index 0000000..3e8a4c8
--- /dev/null
+++ b/test/av1_fht8x8_test.cc
@@ -0,0 +1,205 @@
+/*
+ * Copyright (c) 2016 The WebM project authors. All Rights Reserved.
+ *
+ * Use of this source code is governed by a BSD-style license
+ * that can be found in the LICENSE file in the root of the source
+ * tree. An additional intellectual property rights grant can be found
+ * in the file PATENTS. All contributing project authors may
+ * be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "third_party/googletest/src/include/gtest/gtest.h"
+
+#include "./av1_rtcd.h"
+#include "./aom_dsp_rtcd.h"
+
+#include "test/acm_random.h"
+#include "test/clear_system_state.h"
+#include "test/register_state_check.h"
+#include "test/transform_test_base.h"
+#include "test/util.h"
+#include "aom_ports/mem.h"
+
+using libaom_test::ACMRandom;
+
+namespace {
+typedef void (*IhtFunc)(const tran_low_t *in, uint8_t *out, int stride,
+ int tx_type);
+
+using libaom_test::FhtFunc;
+using std::tr1::tuple;
+typedef tuple<FhtFunc, IhtFunc, int, aom_bit_depth_t, int> Ht8x8Param;
+
+void fht8x8_ref(const int16_t *in, tran_low_t *out, int stride, int tx_type) {
+ av1_fht8x8_c(in, out, stride, tx_type);
+}
+
+#if CONFIG_AOM_HIGHBITDEPTH
+typedef void (*IHbdHtFunc)(const tran_low_t *in, uint8_t *out, int stride,
+ int tx_type, int bd);
+typedef void (*HbdHtFunc)(const int16_t *input, int32_t *output, int stride,
+ int tx_type, int bd);
+// Target optimized function, tx_type, bit depth
+typedef tuple<HbdHtFunc, int, int> HighbdHt8x8Param;
+
+void highbd_fht8x8_ref(const int16_t *in, int32_t *out, int stride, int tx_type,
+ int bd) {
+ av1_fwd_txfm2d_8x8_c(in, out, stride, tx_type, bd);
+}
+#endif // CONFIG_AOM_HIGHBITDEPTH
+
+class AV1Trans8x8HT : public libaom_test::TransformTestBase,
+ public ::testing::TestWithParam<Ht8x8Param> {
+ public:
+ virtual ~AV1Trans8x8HT() {}
+
+ virtual void SetUp() {
+ fwd_txfm_ = GET_PARAM(0);
+ inv_txfm_ = GET_PARAM(1);
+ tx_type_ = GET_PARAM(2);
+ pitch_ = 8;
+ fwd_txfm_ref = fht8x8_ref;
+ bit_depth_ = GET_PARAM(3);
+ mask_ = (1 << bit_depth_) - 1;
+ num_coeffs_ = GET_PARAM(4);
+ }
+ virtual void TearDown() { libaom_test::ClearSystemState(); }
+
+ protected:
+ void RunFwdTxfm(const int16_t *in, tran_low_t *out, int stride) {
+ fwd_txfm_(in, out, stride, tx_type_);
+ }
+
+ void RunInvTxfm(const tran_low_t *out, uint8_t *dst, int stride) {
+ inv_txfm_(out, dst, stride, tx_type_);
+ }
+
+ FhtFunc fwd_txfm_;
+ IhtFunc inv_txfm_;
+};
+
+TEST_P(AV1Trans8x8HT, CoeffCheck) { RunCoeffCheck(); }
+
+#if CONFIG_AOM_HIGHBITDEPTH
+class AV1HighbdTrans8x8HT : public ::testing::TestWithParam<HighbdHt8x8Param> {
+ public:
+ virtual ~AV1HighbdTrans8x8HT() {}
+
+ virtual void SetUp() {
+ fwd_txfm_ = GET_PARAM(0);
+ fwd_txfm_ref_ = highbd_fht8x8_ref;
+ tx_type_ = GET_PARAM(1);
+ bit_depth_ = GET_PARAM(2);
+ mask_ = (1 << bit_depth_) - 1;
+ num_coeffs_ = 64;
+
+ input_ = reinterpret_cast<int16_t *>(
+ aom_memalign(16, sizeof(int16_t) * num_coeffs_));
+ output_ = reinterpret_cast<int32_t *>(
+ aom_memalign(16, sizeof(int32_t) * num_coeffs_));
+ output_ref_ = reinterpret_cast<int32_t *>(
+ aom_memalign(16, sizeof(int32_t) * num_coeffs_));
+ }
+
+ virtual void TearDown() {
+ aom_free(input_);
+ aom_free(output_);
+ aom_free(output_ref_);
+ libaom_test::ClearSystemState();
+ }
+
+ protected:
+ void RunBitexactCheck();
+
+ private:
+ HbdHtFunc fwd_txfm_;
+ HbdHtFunc fwd_txfm_ref_;
+ int tx_type_;
+ int bit_depth_;
+ int mask_;
+ int num_coeffs_;
+ int16_t *input_;
+ int32_t *output_;
+ int32_t *output_ref_;
+};
+
+void AV1HighbdTrans8x8HT::RunBitexactCheck() {
+ ACMRandom rnd(ACMRandom::DeterministicSeed());
+ int i, j;
+ const int stride = 8;
+ const int num_tests = 1000;
+ const int num_coeffs = 64;
+
+ for (i = 0; i < num_tests; ++i) {
+ for (j = 0; j < num_coeffs; ++j) {
+ input_[j] = (rnd.Rand16() & mask_) - (rnd.Rand16() & mask_);
+ }
+
+ fwd_txfm_ref_(input_, output_ref_, stride, tx_type_, bit_depth_);
+ ASM_REGISTER_STATE_CHECK(
+ fwd_txfm_(input_, output_, stride, tx_type_, bit_depth_));
+
+ for (j = 0; j < num_coeffs; ++j) {
+ EXPECT_EQ(output_ref_[j], output_[j])
+ << "Not bit-exact result at index: " << j << " at test block: " << i;
+ }
+ }
+}
+
+TEST_P(AV1HighbdTrans8x8HT, HighbdCoeffCheck) { RunBitexactCheck(); }
+#endif // CONFIG_AOM_HIGHBITDEPTH
+
+using std::tr1::make_tuple;
+
+#if HAVE_SSE2
+const Ht8x8Param kArrayHt8x8Param_sse2[] = {
+ make_tuple(&av1_fht8x8_sse2, &av1_iht8x8_64_add_sse2, 0, AOM_BITS_8, 64),
+ make_tuple(&av1_fht8x8_sse2, &av1_iht8x8_64_add_sse2, 1, AOM_BITS_8, 64),
+ make_tuple(&av1_fht8x8_sse2, &av1_iht8x8_64_add_sse2, 2, AOM_BITS_8, 64),
+ make_tuple(&av1_fht8x8_sse2, &av1_iht8x8_64_add_sse2, 3, AOM_BITS_8, 64),
+#if CONFIG_EXT_TX
+ make_tuple(&av1_fht8x8_sse2, &av1_iht8x8_64_add_sse2, 4, AOM_BITS_8, 64),
+ make_tuple(&av1_fht8x8_sse2, &av1_iht8x8_64_add_sse2, 5, AOM_BITS_8, 64),
+ make_tuple(&av1_fht8x8_sse2, &av1_iht8x8_64_add_sse2, 6, AOM_BITS_8, 64),
+ make_tuple(&av1_fht8x8_sse2, &av1_iht8x8_64_add_sse2, 7, AOM_BITS_8, 64),
+ make_tuple(&av1_fht8x8_sse2, &av1_iht8x8_64_add_sse2, 8, AOM_BITS_8, 64),
+ make_tuple(&av1_fht8x8_sse2, &av1_iht8x8_64_add_sse2, 10, AOM_BITS_8, 64),
+ make_tuple(&av1_fht8x8_sse2, &av1_iht8x8_64_add_sse2, 11, AOM_BITS_8, 64),
+ make_tuple(&av1_fht8x8_sse2, &av1_iht8x8_64_add_sse2, 12, AOM_BITS_8, 64),
+ make_tuple(&av1_fht8x8_sse2, &av1_iht8x8_64_add_sse2, 13, AOM_BITS_8, 64),
+ make_tuple(&av1_fht8x8_sse2, &av1_iht8x8_64_add_sse2, 14, AOM_BITS_8, 64),
+ make_tuple(&av1_fht8x8_sse2, &av1_iht8x8_64_add_sse2, 15, AOM_BITS_8, 64)
+#endif // CONFIG_EXT_TX
+};
+INSTANTIATE_TEST_CASE_P(SSE2, AV1Trans8x8HT,
+ ::testing::ValuesIn(kArrayHt8x8Param_sse2));
+#endif // HAVE_SSE2
+
+#if HAVE_SSE4_1 && CONFIG_AOM_HIGHBITDEPTH
+const HighbdHt8x8Param kArrayHBDHt8x8Param_sse4_1[] = {
+ make_tuple(&av1_fwd_txfm2d_8x8_sse4_1, 0, 10),
+ make_tuple(&av1_fwd_txfm2d_8x8_sse4_1, 0, 12),
+ make_tuple(&av1_fwd_txfm2d_8x8_sse4_1, 1, 10),
+ make_tuple(&av1_fwd_txfm2d_8x8_sse4_1, 1, 12),
+ make_tuple(&av1_fwd_txfm2d_8x8_sse4_1, 2, 10),
+ make_tuple(&av1_fwd_txfm2d_8x8_sse4_1, 2, 12),
+ make_tuple(&av1_fwd_txfm2d_8x8_sse4_1, 3, 10),
+ make_tuple(&av1_fwd_txfm2d_8x8_sse4_1, 3, 12),
+#if CONFIG_EXT_TX
+ make_tuple(&av1_fwd_txfm2d_8x8_sse4_1, 4, 10),
+ make_tuple(&av1_fwd_txfm2d_8x8_sse4_1, 4, 12),
+ make_tuple(&av1_fwd_txfm2d_8x8_sse4_1, 5, 10),
+ make_tuple(&av1_fwd_txfm2d_8x8_sse4_1, 5, 12),
+ make_tuple(&av1_fwd_txfm2d_8x8_sse4_1, 6, 10),
+ make_tuple(&av1_fwd_txfm2d_8x8_sse4_1, 6, 12),
+ make_tuple(&av1_fwd_txfm2d_8x8_sse4_1, 7, 10),
+ make_tuple(&av1_fwd_txfm2d_8x8_sse4_1, 7, 12),
+ make_tuple(&av1_fwd_txfm2d_8x8_sse4_1, 8, 10),
+ make_tuple(&av1_fwd_txfm2d_8x8_sse4_1, 8, 12),
+#endif // CONFIG_EXT_TX
+};
+INSTANTIATE_TEST_CASE_P(SSE4_1, AV1HighbdTrans8x8HT,
+ ::testing::ValuesIn(kArrayHBDHt8x8Param_sse4_1));
+#endif // HAVE_SSE4_1 && CONFIG_AOM_HIGHBITDEPTH
+
+} // namespace
diff --git a/test/vp10_fwd_txfm1d_test.cc b/test/av1_fwd_txfm1d_test.cc
similarity index 89%
rename from test/vp10_fwd_txfm1d_test.cc
rename to test/av1_fwd_txfm1d_test.cc
index 2b9cfe5..03bed19 100644
--- a/test/vp10_fwd_txfm1d_test.cc
+++ b/test/av1_fwd_txfm1d_test.cc
@@ -8,8 +8,8 @@
* be found in the AUTHORS file in the root of the source tree.
*/
-#include "av1/common/vp10_fwd_txfm1d.h"
-#include "test/vp10_txfm_test.h"
+#include "av1/common/av1_fwd_txfm1d.h"
+#include "test/av1_txfm_test.h"
using libaom_test::ACMRandom;
using libaom_test::input_base;
@@ -26,15 +26,15 @@
const int txfm_size_ls[5] = { 4, 8, 16, 32 };
const TxfmFunc fwd_txfm_func_ls[2][5] = {
- { vp10_fdct4_new, vp10_fdct8_new, vp10_fdct16_new, vp10_fdct32_new, NULL },
- { vp10_fadst4_new, vp10_fadst8_new, vp10_fadst16_new, vp10_fadst32_new, NULL }
+ { av1_fdct4_new, av1_fdct8_new, av1_fdct16_new, av1_fdct32_new, NULL },
+ { av1_fadst4_new, av1_fadst8_new, av1_fadst16_new, av1_fadst32_new, NULL }
};
// the maximum stage number of fwd/inv 1d dct/adst txfm is 12
const int8_t cos_bit[12] = { 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14 };
const int8_t range_bit[12] = { 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32 };
-TEST(vp10_fwd_txfm1d, round_shift) {
+TEST(av1_fwd_txfm1d, round_shift) {
EXPECT_EQ(round_shift(7, 1), 4);
EXPECT_EQ(round_shift(-7, 1), -3);
@@ -45,12 +45,12 @@
EXPECT_EQ(round_shift(-8, 2), -2);
}
-TEST(vp10_fwd_txfm1d, get_max_bit) {
+TEST(av1_fwd_txfm1d, get_max_bit) {
int max_bit = get_max_bit(8);
EXPECT_EQ(max_bit, 3);
}
-TEST(vp10_fwd_txfm1d, cospi_arr) {
+TEST(av1_fwd_txfm1d, cospi_arr) {
for (int i = 0; i < 7; i++) {
for (int j = 0; j < 64; j++) {
EXPECT_EQ(cospi_arr[i][j],
@@ -59,7 +59,7 @@
}
}
-TEST(vp10_fwd_txfm1d, clamp_block) {
+TEST(av1_fwd_txfm1d, clamp_block) {
int16_t block[5][5] = { { 7, -5, 6, -3, 9 },
{ 7, -5, 6, -3, 9 },
{ 7, -5, 6, -3, 9 },
@@ -84,7 +84,7 @@
}
}
-TEST(vp10_fwd_txfm1d, accuracy) {
+TEST(av1_fwd_txfm1d, accuracy) {
ACMRandom rnd(ACMRandom::DeterministicSeed());
for (int si = 0; si < txfm_size_num; ++si) {
int txfm_size = txfm_size_ls[si];
diff --git a/test/av1_fwd_txfm2d_test.cc b/test/av1_fwd_txfm2d_test.cc
new file mode 100644
index 0000000..675edb0
--- /dev/null
+++ b/test/av1_fwd_txfm2d_test.cc
@@ -0,0 +1,178 @@
+/*
+ * Copyright (c) 2015 The WebM project authors. All Rights Reserved.
+ *
+ * Use of this source code is governed by a BSD-style license
+ * that can be found in the LICENSE file in the root of the source
+ * tree. An additional intellectual property rights grant can be found
+ * in the file PATENTS. All contributing project authors may
+ * be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "test/acm_random.h"
+#include "test/util.h"
+#include "test/av1_txfm_test.h"
+#include "av1/common/av1_txfm.h"
+#include "./av1_rtcd.h"
+
+using libaom_test::ACMRandom;
+using libaom_test::input_base;
+using libaom_test::bd;
+using libaom_test::compute_avg_abs_error;
+using libaom_test::Fwd_Txfm2d_Func;
+using libaom_test::TYPE_TXFM;
+
+namespace {
+#if CONFIG_AOM_HIGHBITDEPTH
+// tx_type_, tx_size_, max_error_, max_avg_error_
+typedef std::tr1::tuple<TX_TYPE, TX_SIZE, double, double> AV1FwdTxfm2dParam;
+
+class AV1FwdTxfm2d : public ::testing::TestWithParam<AV1FwdTxfm2dParam> {
+ public:
+ virtual void SetUp() {
+ tx_type_ = GET_PARAM(0);
+ tx_size_ = GET_PARAM(1);
+ max_error_ = GET_PARAM(2);
+ max_avg_error_ = GET_PARAM(3);
+ count_ = 500;
+ TXFM_2D_FLIP_CFG fwd_txfm_flip_cfg =
+ av1_get_fwd_txfm_cfg(tx_type_, tx_size_);
+ const TXFM_2D_CFG *fwd_txfm_cfg = fwd_txfm_flip_cfg.cfg;
+ int amplify_bit = fwd_txfm_cfg->shift[0] + fwd_txfm_cfg->shift[1] +
+ fwd_txfm_cfg->shift[2];
+ ud_flip_ = fwd_txfm_flip_cfg.ud_flip;
+ lr_flip_ = fwd_txfm_flip_cfg.lr_flip;
+ amplify_factor_ =
+ amplify_bit >= 0 ? (1 << amplify_bit) : (1.0 / (1 << -amplify_bit));
+
+ fwd_txfm_ = libaom_test::fwd_txfm_func_ls[tx_size_];
+ txfm1d_size_ = libaom_test::get_txfm1d_size(tx_size_);
+ txfm2d_size_ = txfm1d_size_ * txfm1d_size_;
+ get_txfm1d_type(tx_type_, &type0_, &type1_);
+ input_ = reinterpret_cast<int16_t *>(
+ aom_memalign(16, sizeof(input_[0]) * txfm2d_size_));
+ output_ = reinterpret_cast<int32_t *>(
+ aom_memalign(16, sizeof(output_[0]) * txfm2d_size_));
+ ref_input_ = reinterpret_cast<double *>(
+ aom_memalign(16, sizeof(ref_input_[0]) * txfm2d_size_));
+ ref_output_ = reinterpret_cast<double *>(
+ aom_memalign(16, sizeof(ref_output_[0]) * txfm2d_size_));
+ }
+
+ void RunFwdAccuracyCheck() {
+ ACMRandom rnd(ACMRandom::DeterministicSeed());
+ double avg_abs_error = 0;
+ for (int ci = 0; ci < count_; ci++) {
+ for (int ni = 0; ni < txfm2d_size_; ++ni) {
+ input_[ni] = rnd.Rand16() % input_base;
+ ref_input_[ni] = static_cast<double>(input_[ni]);
+ output_[ni] = 0;
+ ref_output_[ni] = 0;
+ }
+
+ fwd_txfm_(input_, output_, txfm1d_size_, tx_type_, bd);
+
+ if (lr_flip_ && ud_flip_)
+ libaom_test::fliplrud(ref_input_, txfm1d_size_, txfm1d_size_);
+ else if (lr_flip_)
+ libaom_test::fliplr(ref_input_, txfm1d_size_, txfm1d_size_);
+ else if (ud_flip_)
+ libaom_test::flipud(ref_input_, txfm1d_size_, txfm1d_size_);
+
+ reference_hybrid_2d(ref_input_, ref_output_, txfm1d_size_, type0_,
+ type1_);
+
+ for (int ni = 0; ni < txfm2d_size_; ++ni) {
+ ref_output_[ni] = round(ref_output_[ni] * amplify_factor_);
+ EXPECT_GE(max_error_,
+ fabs(output_[ni] - ref_output_[ni]) / amplify_factor_);
+ }
+ avg_abs_error += compute_avg_abs_error<int32_t, double>(
+ output_, ref_output_, txfm2d_size_);
+ }
+
+ avg_abs_error /= amplify_factor_;
+ avg_abs_error /= count_;
+ // max_abs_avg_error comes from upper bound of avg_abs_error
+ // printf("type0: %d type1: %d txfm_size: %d accuracy_avg_abs_error:
+ // %f\n", type0_, type1_, txfm1d_size_, avg_abs_error);
+ EXPECT_GE(max_avg_error_, avg_abs_error);
+ }
+
+ virtual void TearDown() {
+ aom_free(input_);
+ aom_free(output_);
+ aom_free(ref_input_);
+ aom_free(ref_output_);
+ }
+
+ private:
+ double max_error_;
+ double max_avg_error_;
+ int count_;
+ double amplify_factor_;
+ TX_TYPE tx_type_;
+ TX_SIZE tx_size_;
+ int txfm1d_size_;
+ int txfm2d_size_;
+ Fwd_Txfm2d_Func fwd_txfm_;
+ TYPE_TXFM type0_;
+ TYPE_TXFM type1_;
+ int16_t *input_;
+ int32_t *output_;
+ double *ref_input_;
+ double *ref_output_;
+ int ud_flip_; // flip upside down
+ int lr_flip_; // flip left to right
+};
+
+TEST_P(AV1FwdTxfm2d, RunFwdAccuracyCheck) { RunFwdAccuracyCheck(); }
+const AV1FwdTxfm2dParam av1_fwd_txfm2d_param_c[] = {
+#if CONFIG_EXT_TX
+ AV1FwdTxfm2dParam(FLIPADST_DCT, TX_4X4, 2, 0.2),
+ AV1FwdTxfm2dParam(DCT_FLIPADST, TX_4X4, 2, 0.2),
+ AV1FwdTxfm2dParam(FLIPADST_FLIPADST, TX_4X4, 2, 0.2),
+ AV1FwdTxfm2dParam(ADST_FLIPADST, TX_4X4, 2, 0.2),
+ AV1FwdTxfm2dParam(FLIPADST_ADST, TX_4X4, 2, 0.2),
+ AV1FwdTxfm2dParam(FLIPADST_DCT, TX_8X8, 5, 0.6),
+ AV1FwdTxfm2dParam(DCT_FLIPADST, TX_8X8, 5, 0.6),
+ AV1FwdTxfm2dParam(FLIPADST_FLIPADST, TX_8X8, 5, 0.6),
+ AV1FwdTxfm2dParam(ADST_FLIPADST, TX_8X8, 5, 0.6),
+ AV1FwdTxfm2dParam(FLIPADST_ADST, TX_8X8, 5, 0.6),
+ AV1FwdTxfm2dParam(FLIPADST_DCT, TX_16X16, 11, 1.5),
+ AV1FwdTxfm2dParam(DCT_FLIPADST, TX_16X16, 11, 1.5),
+ AV1FwdTxfm2dParam(FLIPADST_FLIPADST, TX_16X16, 11, 1.5),
+ AV1FwdTxfm2dParam(ADST_FLIPADST, TX_16X16, 11, 1.5),
+ AV1FwdTxfm2dParam(FLIPADST_ADST, TX_16X16, 11, 1.5),
+ AV1FwdTxfm2dParam(FLIPADST_DCT, TX_32X32, 70, 7),
+ AV1FwdTxfm2dParam(DCT_FLIPADST, TX_32X32, 70, 7),
+ AV1FwdTxfm2dParam(FLIPADST_FLIPADST, TX_32X32, 70, 7),
+ AV1FwdTxfm2dParam(ADST_FLIPADST, TX_32X32, 70, 7),
+ AV1FwdTxfm2dParam(FLIPADST_ADST, TX_32X32, 70, 7),
+#endif
+ AV1FwdTxfm2dParam(DCT_DCT, TX_4X4, 2, 0.2),
+ AV1FwdTxfm2dParam(ADST_DCT, TX_4X4, 2, 0.2),
+ AV1FwdTxfm2dParam(DCT_ADST, TX_4X4, 2, 0.2),
+ AV1FwdTxfm2dParam(ADST_ADST, TX_4X4, 2, 0.2),
+ AV1FwdTxfm2dParam(DCT_DCT, TX_8X8, 5, 0.6),
+ AV1FwdTxfm2dParam(ADST_DCT, TX_8X8, 5, 0.6),
+ AV1FwdTxfm2dParam(DCT_ADST, TX_8X8, 5, 0.6),
+ AV1FwdTxfm2dParam(ADST_ADST, TX_8X8, 5, 0.6),
+ AV1FwdTxfm2dParam(DCT_DCT, TX_16X16, 11, 1.5),
+ AV1FwdTxfm2dParam(ADST_DCT, TX_16X16, 11, 1.5),
+ AV1FwdTxfm2dParam(DCT_ADST, TX_16X16, 11, 1.5),
+ AV1FwdTxfm2dParam(ADST_ADST, TX_16X16, 11, 1.5),
+ AV1FwdTxfm2dParam(DCT_DCT, TX_32X32, 70, 7),
+ AV1FwdTxfm2dParam(ADST_DCT, TX_32X32, 70, 7),
+ AV1FwdTxfm2dParam(DCT_ADST, TX_32X32, 70, 7),
+ AV1FwdTxfm2dParam(ADST_ADST, TX_32X32, 70, 7)
+};
+
+INSTANTIATE_TEST_CASE_P(C, AV1FwdTxfm2d,
+ ::testing::ValuesIn(av1_fwd_txfm2d_param_c));
+
+#endif // CONFIG_AOM_HIGHBITDEPTH
+} // namespace
diff --git a/test/vp10_highbd_iht_test.cc b/test/av1_highbd_iht_test.cc
similarity index 82%
rename from test/vp10_highbd_iht_test.cc
rename to test/av1_highbd_iht_test.cc
index 6190971..648e744 100644
--- a/test/vp10_highbd_iht_test.cc
+++ b/test/av1_highbd_iht_test.cc
@@ -10,13 +10,13 @@
#include "third_party/googletest/src/include/gtest/gtest.h"
-#include "./vp10_rtcd.h"
+#include "./av1_rtcd.h"
#include "test/acm_random.h"
#include "test/clear_system_state.h"
#include "test/register_state_check.h"
#include "test/util.h"
#include "av1/common/enums.h"
-#include "aom_dsp/vpx_dsp_common.h"
+#include "aom_dsp/aom_dsp_common.h"
#include "aom_ports/mem.h"
namespace {
@@ -39,9 +39,9 @@
// bit_depth>
typedef tuple<HbdHtFunc, IHbdHtFunc, IHbdHtFunc, int, int, int> IHbdHtParam;
-class VP10HighbdInvHTNxN : public ::testing::TestWithParam<IHbdHtParam> {
+class AV1HighbdInvHTNxN : public ::testing::TestWithParam<IHbdHtParam> {
public:
- virtual ~VP10HighbdInvHTNxN() {}
+ virtual ~AV1HighbdInvHTNxN() {}
virtual void SetUp() {
txfm_ref_ = GET_PARAM(0);
@@ -52,25 +52,25 @@
bit_depth_ = GET_PARAM(5);
input_ = reinterpret_cast<int16_t *>(
- vpx_memalign(16, sizeof(input_[0]) * num_coeffs_));
+ aom_memalign(16, sizeof(input_[0]) * num_coeffs_));
// Note:
// Inverse transform input buffer is 32-byte aligned
// Refer to <root>/av1/encoder/context_tree.c, function,
// void alloc_mode_context().
coeffs_ = reinterpret_cast<int32_t *>(
- vpx_memalign(32, sizeof(coeffs_[0]) * num_coeffs_));
+ aom_memalign(32, sizeof(coeffs_[0]) * num_coeffs_));
output_ = reinterpret_cast<uint16_t *>(
- vpx_memalign(32, sizeof(output_[0]) * num_coeffs_));
+ aom_memalign(32, sizeof(output_[0]) * num_coeffs_));
output_ref_ = reinterpret_cast<uint16_t *>(
- vpx_memalign(32, sizeof(output_ref_[0]) * num_coeffs_));
+ aom_memalign(32, sizeof(output_ref_[0]) * num_coeffs_));
}
virtual void TearDown() {
- vpx_free(input_);
- vpx_free(coeffs_);
- vpx_free(output_);
- vpx_free(output_ref_);
+ aom_free(input_);
+ aom_free(coeffs_);
+ aom_free(output_);
+ aom_free(output_ref_);
libaom_test::ClearSystemState();
}
@@ -103,7 +103,7 @@
uint16_t *output_ref_;
};
-void VP10HighbdInvHTNxN::RunBitexactCheck() {
+void AV1HighbdInvHTNxN::RunBitexactCheck() {
ACMRandom rnd(ACMRandom::DeterministicSeed());
const int stride = GetStride();
const int num_tests = 20000;
@@ -128,22 +128,22 @@
}
}
-TEST_P(VP10HighbdInvHTNxN, InvTransResultCheck) { RunBitexactCheck(); }
+TEST_P(AV1HighbdInvHTNxN, InvTransResultCheck) { RunBitexactCheck(); }
using std::tr1::make_tuple;
-#if HAVE_SSE4_1 && CONFIG_VP9_HIGHBITDEPTH
-#define PARAM_LIST_4X4 \
- &vp10_fwd_txfm2d_4x4_c, &vp10_inv_txfm2d_add_4x4_sse4_1, \
- &vp10_inv_txfm2d_add_4x4_c, 16
+#if HAVE_SSE4_1 && CONFIG_AOM_HIGHBITDEPTH
+#define PARAM_LIST_4X4 \
+ &av1_fwd_txfm2d_4x4_c, &av1_inv_txfm2d_add_4x4_sse4_1, \
+ &av1_inv_txfm2d_add_4x4_c, 16
-#define PARAM_LIST_8X8 \
- &vp10_fwd_txfm2d_8x8_c, &vp10_inv_txfm2d_add_8x8_sse4_1, \
- &vp10_inv_txfm2d_add_8x8_c, 64
+#define PARAM_LIST_8X8 \
+ &av1_fwd_txfm2d_8x8_c, &av1_inv_txfm2d_add_8x8_sse4_1, \
+ &av1_inv_txfm2d_add_8x8_c, 64
-#define PARAM_LIST_16X16 \
- &vp10_fwd_txfm2d_16x16_c, &vp10_inv_txfm2d_add_16x16_sse4_1, \
- &vp10_inv_txfm2d_add_16x16_c, 256
+#define PARAM_LIST_16X16 \
+ &av1_fwd_txfm2d_16x16_c, &av1_inv_txfm2d_add_16x16_sse4_1, \
+ &av1_inv_txfm2d_add_16x16_c, 256
const IHbdHtParam kArrayIhtParam[] = {
// 16x16
@@ -211,8 +211,8 @@
#endif
};
-INSTANTIATE_TEST_CASE_P(SSE4_1, VP10HighbdInvHTNxN,
+INSTANTIATE_TEST_CASE_P(SSE4_1, AV1HighbdInvHTNxN,
::testing::ValuesIn(kArrayIhtParam));
-#endif // HAVE_SSE4_1 && CONFIG_VP9_HIGHBITDEPTH
+#endif // HAVE_SSE4_1 && CONFIG_AOM_HIGHBITDEPTH
} // namespace
diff --git a/test/vp10_inv_txfm1d_test.cc b/test/av1_inv_txfm1d_test.cc
similarity index 82%
rename from test/vp10_inv_txfm1d_test.cc
rename to test/av1_inv_txfm1d_test.cc
index 744aae8..110d4c3 100644
--- a/test/vp10_inv_txfm1d_test.cc
+++ b/test/av1_inv_txfm1d_test.cc
@@ -8,9 +8,9 @@
* be found in the AUTHORS file in the root of the source tree.
*/
-#include "test/vp10_txfm_test.h"
-#include "av1/common/vp10_fwd_txfm1d.h"
-#include "av1/common/vp10_inv_txfm1d.h"
+#include "test/av1_txfm_test.h"
+#include "av1/common/av1_fwd_txfm1d.h"
+#include "av1/common/av1_inv_txfm1d.h"
using libaom_test::ACMRandom;
using libaom_test::input_base;
@@ -21,20 +21,20 @@
const int txfm_size_ls[5] = { 4, 8, 16, 32 };
const TxfmFunc fwd_txfm_func_ls[2][5] = {
- { vp10_fdct4_new, vp10_fdct8_new, vp10_fdct16_new, vp10_fdct32_new, NULL },
- { vp10_fadst4_new, vp10_fadst8_new, vp10_fadst16_new, vp10_fadst32_new, NULL }
+ { av1_fdct4_new, av1_fdct8_new, av1_fdct16_new, av1_fdct32_new, NULL },
+ { av1_fadst4_new, av1_fadst8_new, av1_fadst16_new, av1_fadst32_new, NULL }
};
const TxfmFunc inv_txfm_func_ls[2][5] = {
- { vp10_idct4_new, vp10_idct8_new, vp10_idct16_new, vp10_idct32_new, NULL },
- { vp10_iadst4_new, vp10_iadst8_new, vp10_iadst16_new, vp10_iadst32_new, NULL }
+ { av1_idct4_new, av1_idct8_new, av1_idct16_new, av1_idct32_new, NULL },
+ { av1_iadst4_new, av1_iadst8_new, av1_iadst16_new, av1_iadst32_new, NULL }
};
// the maximum stage number of fwd/inv 1d dct/adst txfm is 12
const int8_t cos_bit[12] = { 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14 };
const int8_t range_bit[12] = { 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32 };
-TEST(vp10_inv_txfm1d, round_trip) {
+TEST(av1_inv_txfm1d, round_trip) {
ACMRandom rnd(ACMRandom::DeterministicSeed());
for (int si = 0; si < txfm_size_num; ++si) {
int txfm_size = txfm_size_ls[si];
diff --git a/test/av1_inv_txfm2d_test.cc b/test/av1_inv_txfm2d_test.cc
new file mode 100644
index 0000000..55a745f
--- /dev/null
+++ b/test/av1_inv_txfm2d_test.cc
@@ -0,0 +1,157 @@
+/*
+ * Copyright (c) 2015 The WebM project authors. All Rights Reserved.
+ *
+ * Use of this source code is governed by a BSD-style license
+ * that can be found in the LICENSE file in the root of the source
+ * tree. An additional intellectual property rights grant can be found
+ * in the file PATENTS. All contributing project authors may
+ * be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "./av1_rtcd.h"
+#include "test/acm_random.h"
+#include "test/util.h"
+#include "test/av1_txfm_test.h"
+#include "av1/common/av1_inv_txfm2d_cfg.h"
+
+using libaom_test::ACMRandom;
+using libaom_test::input_base;
+using libaom_test::bd;
+using libaom_test::compute_avg_abs_error;
+using libaom_test::Fwd_Txfm2d_Func;
+using libaom_test::Inv_Txfm2d_Func;
+
+namespace {
+
+#if CONFIG_AOM_HIGHBITDEPTH
+// AV1InvTxfm2dParam argument list:
+// tx_type_, tx_size_, max_error_, max_avg_error_
+typedef std::tr1::tuple<TX_TYPE, TX_SIZE, int, double> AV1InvTxfm2dParam;
+
+class AV1InvTxfm2d : public ::testing::TestWithParam<AV1InvTxfm2dParam> {
+ public:
+ virtual void SetUp() {
+ tx_type_ = GET_PARAM(0);
+ tx_size_ = GET_PARAM(1);
+ max_error_ = GET_PARAM(2);
+ max_avg_error_ = GET_PARAM(3);
+ txfm1d_size_ = libaom_test::get_txfm1d_size(tx_size_);
+ txfm2d_size_ = txfm1d_size_ * txfm1d_size_;
+ count_ = 500;
+
+ input_ = reinterpret_cast<int16_t *>(
+ aom_memalign(16, sizeof(int16_t) * txfm2d_size_));
+ ref_input_ = reinterpret_cast<uint16_t *>(
+ aom_memalign(16, sizeof(uint16_t) * txfm2d_size_));
+ output_ = reinterpret_cast<int32_t *>(
+ aom_memalign(16, sizeof(int32_t) * txfm2d_size_));
+ }
+
+ void RunRoundtripCheck() {
+ const Fwd_Txfm2d_Func fwd_txfm_func =
+ libaom_test::fwd_txfm_func_ls[tx_size_];
+ const Inv_Txfm2d_Func inv_txfm_func =
+ libaom_test::inv_txfm_func_ls[tx_size_];
+ double avg_abs_error = 0;
+ ACMRandom rnd(ACMRandom::DeterministicSeed());
+ for (int ci = 0; ci < count_; ci++) {
+ for (int ni = 0; ni < txfm2d_size_; ++ni) {
+ if (ci == 0) {
+ int extreme_input = input_base - 1;
+ input_[ni] = extreme_input; // extreme case
+ ref_input_[ni] = 0;
+ } else {
+ input_[ni] = rnd.Rand16() % input_base;
+ ref_input_[ni] = 0;
+ }
+ }
+
+ fwd_txfm_func(input_, output_, txfm1d_size_, tx_type_, bd);
+ inv_txfm_func(output_, ref_input_, txfm1d_size_, tx_type_, bd);
+
+ for (int ni = 0; ni < txfm2d_size_; ++ni) {
+ EXPECT_GE(max_error_, abs(input_[ni] - ref_input_[ni]));
+ }
+ avg_abs_error += compute_avg_abs_error<int16_t, uint16_t>(
+ input_, ref_input_, txfm2d_size_);
+ }
+
+ avg_abs_error /= count_;
+ // max_abs_avg_error comes from upper bound of
+ // printf("txfm1d_size: %d accuracy_avg_abs_error: %f\n",
+ // txfm1d_size_, avg_abs_error);
+ EXPECT_GE(max_avg_error_, avg_abs_error);
+ }
+
+ virtual void TearDown() {
+ aom_free(input_);
+ aom_free(output_);
+ aom_free(ref_input_);
+ }
+
+ private:
+ int count_;
+ int max_error_;
+ double max_avg_error_;
+ TX_TYPE tx_type_;
+ TX_SIZE tx_size_;
+ int txfm1d_size_;
+ int txfm2d_size_;
+ int16_t *input_;
+ uint16_t *ref_input_;
+ int32_t *output_;
+};
+
+TEST_P(AV1InvTxfm2d, RunRoundtripCheck) { RunRoundtripCheck(); }
+
+const AV1InvTxfm2dParam av1_inv_txfm2d_param[] = {
+#if CONFIG_EXT_TX
+ AV1InvTxfm2dParam(FLIPADST_DCT, TX_4X4, 2, 0.002),
+ AV1InvTxfm2dParam(DCT_FLIPADST, TX_4X4, 2, 0.002),
+ AV1InvTxfm2dParam(FLIPADST_FLIPADST, TX_4X4, 2, 0.002),
+ AV1InvTxfm2dParam(ADST_FLIPADST, TX_4X4, 2, 0.002),
+ AV1InvTxfm2dParam(FLIPADST_ADST, TX_4X4, 2, 0.002),
+ AV1InvTxfm2dParam(FLIPADST_DCT, TX_8X8, 2, 0.02),
+ AV1InvTxfm2dParam(DCT_FLIPADST, TX_8X8, 2, 0.02),
+ AV1InvTxfm2dParam(FLIPADST_FLIPADST, TX_8X8, 2, 0.02),
+ AV1InvTxfm2dParam(ADST_FLIPADST, TX_8X8, 2, 0.02),
+ AV1InvTxfm2dParam(FLIPADST_ADST, TX_8X8, 2, 0.02),
+ AV1InvTxfm2dParam(FLIPADST_DCT, TX_16X16, 2, 0.04),
+ AV1InvTxfm2dParam(DCT_FLIPADST, TX_16X16, 2, 0.04),
+ AV1InvTxfm2dParam(FLIPADST_FLIPADST, TX_16X16, 11, 0.04),
+ AV1InvTxfm2dParam(ADST_FLIPADST, TX_16X16, 2, 0.04),
+ AV1InvTxfm2dParam(FLIPADST_ADST, TX_16X16, 2, 0.04),
+ AV1InvTxfm2dParam(FLIPADST_DCT, TX_32X32, 4, 0.4),
+ AV1InvTxfm2dParam(DCT_FLIPADST, TX_32X32, 4, 0.4),
+ AV1InvTxfm2dParam(FLIPADST_FLIPADST, TX_32X32, 4, 0.4),
+ AV1InvTxfm2dParam(ADST_FLIPADST, TX_32X32, 4, 0.4),
+ AV1InvTxfm2dParam(FLIPADST_ADST, TX_32X32, 4, 0.4),
+#endif
+ AV1InvTxfm2dParam(DCT_DCT, TX_4X4, 2, 0.002),
+ AV1InvTxfm2dParam(ADST_DCT, TX_4X4, 2, 0.002),
+ AV1InvTxfm2dParam(DCT_ADST, TX_4X4, 2, 0.002),
+ AV1InvTxfm2dParam(ADST_ADST, TX_4X4, 2, 0.002),
+ AV1InvTxfm2dParam(DCT_DCT, TX_8X8, 2, 0.02),
+ AV1InvTxfm2dParam(ADST_DCT, TX_8X8, 2, 0.02),
+ AV1InvTxfm2dParam(DCT_ADST, TX_8X8, 2, 0.02),
+ AV1InvTxfm2dParam(ADST_ADST, TX_8X8, 2, 0.02),
+ AV1InvTxfm2dParam(DCT_DCT, TX_16X16, 2, 0.04),
+ AV1InvTxfm2dParam(ADST_DCT, TX_16X16, 2, 0.04),
+ AV1InvTxfm2dParam(DCT_ADST, TX_16X16, 2, 0.04),
+ AV1InvTxfm2dParam(ADST_ADST, TX_16X16, 2, 0.04),
+ AV1InvTxfm2dParam(DCT_DCT, TX_32X32, 4, 0.4),
+ AV1InvTxfm2dParam(ADST_DCT, TX_32X32, 4, 0.4),
+ AV1InvTxfm2dParam(DCT_ADST, TX_32X32, 4, 0.4),
+ AV1InvTxfm2dParam(ADST_ADST, TX_32X32, 4, 0.4)
+};
+
+INSTANTIATE_TEST_CASE_P(C, AV1InvTxfm2d,
+ ::testing::ValuesIn(av1_inv_txfm2d_param));
+
+#endif // CONFIG_AOM_HIGHBITDEPTH
+
+} // namespace
diff --git a/test/vp10_inv_txfm_test.cc b/test/av1_inv_txfm_test.cc
similarity index 81%
rename from test/vp10_inv_txfm_test.cc
rename to test/av1_inv_txfm_test.cc
index df8787d..c3e2eea 100644
--- a/test/vp10_inv_txfm_test.cc
+++ b/test/av1_inv_txfm_test.cc
@@ -14,16 +14,16 @@
#include "third_party/googletest/src/include/gtest/gtest.h"
-#include "./vp10_rtcd.h"
-#include "./vpx_dsp_rtcd.h"
+#include "./av1_rtcd.h"
+#include "./aom_dsp_rtcd.h"
#include "test/acm_random.h"
#include "test/clear_system_state.h"
#include "test/register_state_check.h"
#include "test/util.h"
#include "av1/common/blockd.h"
#include "av1/common/scan.h"
-#include "aom/vpx_integer.h"
-#include "av1/common/vp10_inv_txfm.h"
+#include "aom/aom_integer.h"
+#include "av1/common/av1_inv_txfm.h"
using libaom_test::ACMRandom;
@@ -87,8 +87,8 @@
};
typedef std::tr1::tuple<IdctFunc, IdctFuncRef, int, int> IdctParam;
-class Vp10InvTxfm : public TransTestBase,
- public ::testing::TestWithParam<IdctParam> {
+class AV1InvTxfm : public TransTestBase,
+ public ::testing::TestWithParam<IdctParam> {
public:
virtual void SetUp() {
fwd_txfm_ = GET_PARAM(0);
@@ -99,24 +99,24 @@
virtual void TearDown() {}
};
-TEST_P(Vp10InvTxfm, RunInvAccuracyCheck) { RunInvAccuracyCheck(); }
+TEST_P(AV1InvTxfm, RunInvAccuracyCheck) { RunInvAccuracyCheck(); }
INSTANTIATE_TEST_CASE_P(
- C, Vp10InvTxfm,
- ::testing::Values(IdctParam(&vp10_idct4_c, &reference_idct_1d, 4, 1),
- IdctParam(&vp10_idct8_c, &reference_idct_1d, 8, 2),
- IdctParam(&vp10_idct16_c, &reference_idct_1d, 16, 4),
- IdctParam(&vp10_idct32_c, &reference_idct_1d, 32, 6)));
+ C, AV1InvTxfm,
+ ::testing::Values(IdctParam(&av1_idct4_c, &reference_idct_1d, 4, 1),
+ IdctParam(&av1_idct8_c, &reference_idct_1d, 8, 2),
+ IdctParam(&av1_idct16_c, &reference_idct_1d, 16, 4),
+ IdctParam(&av1_idct32_c, &reference_idct_1d, 32, 6)));
typedef void (*FwdTxfmFunc)(const int16_t *in, tran_low_t *out, int stride);
typedef void (*InvTxfmFunc)(const tran_low_t *in, uint8_t *out, int stride);
typedef std::tr1::tuple<FwdTxfmFunc, InvTxfmFunc, InvTxfmFunc, TX_SIZE, int>
PartialInvTxfmParam;
const int kMaxNumCoeffs = 1024;
-class Vp10PartialIDctTest
+class AV1PartialIDctTest
: public ::testing::TestWithParam<PartialInvTxfmParam> {
public:
- virtual ~Vp10PartialIDctTest() {}
+ virtual ~AV1PartialIDctTest() {}
virtual void SetUp() {
ftxfm_ = GET_PARAM(0);
full_itxfm_ = GET_PARAM(1);
@@ -135,7 +135,7 @@
InvTxfmFunc partial_itxfm_;
};
-TEST_P(Vp10PartialIDctTest, RunQuantCheck) {
+TEST_P(AV1PartialIDctTest, RunQuantCheck) {
ACMRandom rnd(ACMRandom::DeterministicSeed());
int size;
switch (tx_size_) {
@@ -201,7 +201,7 @@
<< "Error: partial inverse transform produces different results";
}
-TEST_P(Vp10PartialIDctTest, ResultsMatch) {
+TEST_P(AV1PartialIDctTest, ResultsMatch) {
ACMRandom rnd(ACMRandom::DeterministicSeed());
int size;
switch (tx_size_) {
@@ -256,19 +256,19 @@
using std::tr1::make_tuple;
INSTANTIATE_TEST_CASE_P(
- C, Vp10PartialIDctTest,
- ::testing::Values(make_tuple(&vp10_fdct32x32_c, &vp10_idct32x32_1024_add_c,
- &vp10_idct32x32_34_add_c, TX_32X32, 34),
- make_tuple(&vp10_fdct32x32_c, &vp10_idct32x32_1024_add_c,
- &vp10_idct32x32_1_add_c, TX_32X32, 1),
- make_tuple(&vp10_fdct16x16_c, &vp10_idct16x16_256_add_c,
- &vp10_idct16x16_10_add_c, TX_16X16, 10),
- make_tuple(&vp10_fdct16x16_c, &vp10_idct16x16_256_add_c,
- &vp10_idct16x16_1_add_c, TX_16X16, 1),
- make_tuple(&vp10_fdct8x8_c, &vp10_idct8x8_64_add_c,
- &vp10_idct8x8_12_add_c, TX_8X8, 12),
- make_tuple(&vp10_fdct8x8_c, &vp10_idct8x8_64_add_c,
- &vp10_idct8x8_1_add_c, TX_8X8, 1),
- make_tuple(&vp10_fdct4x4_c, &vp10_idct4x4_16_add_c,
- &vp10_idct4x4_1_add_c, TX_4X4, 1)));
+ C, AV1PartialIDctTest,
+ ::testing::Values(make_tuple(&av1_fdct32x32_c, &av1_idct32x32_1024_add_c,
+ &av1_idct32x32_34_add_c, TX_32X32, 34),
+ make_tuple(&av1_fdct32x32_c, &av1_idct32x32_1024_add_c,
+ &av1_idct32x32_1_add_c, TX_32X32, 1),
+ make_tuple(&av1_fdct16x16_c, &av1_idct16x16_256_add_c,
+ &av1_idct16x16_10_add_c, TX_16X16, 10),
+ make_tuple(&av1_fdct16x16_c, &av1_idct16x16_256_add_c,
+ &av1_idct16x16_1_add_c, TX_16X16, 1),
+ make_tuple(&av1_fdct8x8_c, &av1_idct8x8_64_add_c,
+ &av1_idct8x8_12_add_c, TX_8X8, 12),
+ make_tuple(&av1_fdct8x8_c, &av1_idct8x8_64_add_c,
+ &av1_idct8x8_1_add_c, TX_8X8, 1),
+ make_tuple(&av1_fdct4x4_c, &av1_idct4x4_16_add_c,
+ &av1_idct4x4_1_add_c, TX_4X4, 1)));
} // namespace
diff --git a/test/vp10_quantize_test.cc b/test/av1_quantize_test.cc
similarity index 87%
rename from test/vp10_quantize_test.cc
rename to test/av1_quantize_test.cc
index f3990ae..88cddb3 100644
--- a/test/vp10_quantize_test.cc
+++ b/test/av1_quantize_test.cc
@@ -12,8 +12,8 @@
#include "third_party/googletest/src/include/gtest/gtest.h"
-#include "./vpx_config.h"
-#include "./vp10_rtcd.h"
+#include "./aom_config.h"
+#include "./av1_rtcd.h"
#include "test/acm_random.h"
#include "test/clear_system_state.h"
#include "test/register_state_check.h"
@@ -45,7 +45,7 @@
const int dequantRange = 32768;
const int coeffRange = (1 << 20) - 1;
-class VP10QuantizeTest : public ::testing::TestWithParam<QuantizeFuncParams> {
+class AV1QuantizeTest : public ::testing::TestWithParam<QuantizeFuncParams> {
public:
void RunQuantizeTest() {
ACMRandom rnd(ACMRandom::DeterministicSeed());
@@ -70,7 +70,7 @@
QuantizeFpFunc quanFunc = params_.qFunc;
QuantizeFpFunc quanFuncRef = params_.qFuncRef;
- const scan_order scanOrder = vp10_default_scan_orders[txSize];
+ const scan_order scanOrder = av1_default_scan_orders[txSize];
for (int i = 0; i < numTests; i++) {
int err_count = 0;
ref_eob = eob = -1;
@@ -137,7 +137,7 @@
int log_scale = (txSize == TX_32X32);
QuantizeFpFunc quanFunc = params_.qFunc;
QuantizeFpFunc quanFuncRef = params_.qFuncRef;
- const scan_order scanOrder = vp10_default_scan_orders[txSize];
+ const scan_order scanOrder = av1_default_scan_orders[txSize];
for (int i = 0; i < numTests; i++) {
ref_eob = eob = -1;
@@ -175,7 +175,7 @@
virtual void TearDown() { libaom_test::ClearSystemState(); }
- virtual ~VP10QuantizeTest() {}
+ virtual ~AV1QuantizeTest() {}
private:
TX_SIZE getTxSize(int count) {
@@ -195,19 +195,19 @@
QuantizeFuncParams params_;
};
-TEST_P(VP10QuantizeTest, BitExactCheck) { RunQuantizeTest(); }
-TEST_P(VP10QuantizeTest, EobVerify) { RunEobTest(); }
+TEST_P(AV1QuantizeTest, BitExactCheck) { RunQuantizeTest(); }
+TEST_P(AV1QuantizeTest, EobVerify) { RunEobTest(); }
#if HAVE_SSE4_1
INSTANTIATE_TEST_CASE_P(
- SSE4_1, VP10QuantizeTest,
- ::testing::Values(QuantizeFuncParams(&vp10_highbd_quantize_fp_sse4_1,
- &vp10_highbd_quantize_fp_c, 16),
- QuantizeFuncParams(&vp10_highbd_quantize_fp_sse4_1,
- &vp10_highbd_quantize_fp_c, 64),
- QuantizeFuncParams(&vp10_highbd_quantize_fp_sse4_1,
- &vp10_highbd_quantize_fp_c, 256),
- QuantizeFuncParams(&vp10_highbd_quantize_fp_sse4_1,
- &vp10_highbd_quantize_fp_c, 1024)));
+ SSE4_1, AV1QuantizeTest,
+ ::testing::Values(QuantizeFuncParams(&av1_highbd_quantize_fp_sse4_1,
+ &av1_highbd_quantize_fp_c, 16),
+ QuantizeFuncParams(&av1_highbd_quantize_fp_sse4_1,
+ &av1_highbd_quantize_fp_c, 64),
+ QuantizeFuncParams(&av1_highbd_quantize_fp_sse4_1,
+ &av1_highbd_quantize_fp_c, 256),
+ QuantizeFuncParams(&av1_highbd_quantize_fp_sse4_1,
+ &av1_highbd_quantize_fp_c, 1024)));
#endif // HAVE_SSE4_1
} // namespace
diff --git a/test/vp10_txfm_test.cc b/test/av1_txfm_test.cc
similarity index 99%
rename from test/vp10_txfm_test.cc
rename to test/av1_txfm_test.cc
index 718d71b..8dc6321 100644
--- a/test/vp10_txfm_test.cc
+++ b/test/av1_txfm_test.cc
@@ -9,7 +9,7 @@
*/
#include <stdio.h>
-#include "test/vp10_txfm_test.h"
+#include "test/av1_txfm_test.h"
namespace libaom_test {
diff --git a/test/vp10_txfm_test.h b/test/av1_txfm_test.h
similarity index 84%
rename from test/vp10_txfm_test.h
rename to test/av1_txfm_test.h
index bfae073..8f0022d 100644
--- a/test/vp10_txfm_test.h
+++ b/test/av1_txfm_test.h
@@ -8,8 +8,8 @@
* be found in the AUTHORS file in the root of the source tree.
*/
-#ifndef VP10_TXFM_TEST_H_
-#define VP10_TXFM_TEST_H_
+#ifndef AV1_TXFM_TEST_H_
+#define AV1_TXFM_TEST_H_
#include <stdio.h>
#include <stdlib.h>
@@ -22,8 +22,8 @@
#include "test/acm_random.h"
#include "av1/common/enums.h"
-#include "av1/common/vp10_txfm.h"
-#include "./vp10_rtcd.h"
+#include "av1/common/av1_txfm.h"
+#include "./av1_rtcd.h"
namespace libaom_test {
typedef enum {
@@ -75,17 +75,17 @@
static const int bd = 10;
static const int input_base = (1 << bd);
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
static const Fwd_Txfm2d_Func fwd_txfm_func_ls[TX_SIZES] = {
- vp10_fwd_txfm2d_4x4_c, vp10_fwd_txfm2d_8x8_c, vp10_fwd_txfm2d_16x16_c,
- vp10_fwd_txfm2d_32x32_c
+ av1_fwd_txfm2d_4x4_c, av1_fwd_txfm2d_8x8_c, av1_fwd_txfm2d_16x16_c,
+ av1_fwd_txfm2d_32x32_c
};
static const Inv_Txfm2d_Func inv_txfm_func_ls[TX_SIZES] = {
- vp10_inv_txfm2d_add_4x4_c, vp10_inv_txfm2d_add_8x8_c,
- vp10_inv_txfm2d_add_16x16_c, vp10_inv_txfm2d_add_32x32_c
+ av1_inv_txfm2d_add_4x4_c, av1_inv_txfm2d_add_8x8_c,
+ av1_inv_txfm2d_add_16x16_c, av1_inv_txfm2d_add_32x32_c
};
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#endif // CONFIG_AOM_HIGHBITDEPTH
} // namespace libaom_test
-#endif // VP10_TXFM_TEST_H_
+#endif // AV1_TXFM_TEST_H_
diff --git a/test/vp10_wedge_utils_test.cc b/test/av1_wedge_utils_test.cc
similarity index 88%
rename from test/vp10_wedge_utils_test.cc
rename to test/av1_wedge_utils_test.cc
index 127a32f..539e9ef 100644
--- a/test/vp10_wedge_utils_test.cc
+++ b/test/av1_wedge_utils_test.cc
@@ -10,12 +10,12 @@
#include "third_party/googletest/src/include/gtest/gtest.h"
-#include "./vpx_config.h"
+#include "./aom_config.h"
-#include "./vpx_dsp_rtcd.h"
-#include "./vp10_rtcd.h"
+#include "./aom_dsp_rtcd.h"
+#include "./av1_rtcd.h"
-#include "aom_dsp/vpx_dsp_common.h"
+#include "aom_dsp/aom_dsp_common.h"
#include "av1/common/enums.h"
@@ -34,7 +34,7 @@
static const int16_t kInt13Max = (1 << 12) - 1;
//////////////////////////////////////////////////////////////////////////////
-// vp10_wedge_sse_from_residuals - functionality
+// av1_wedge_sse_from_residuals - functionality
//////////////////////////////////////////////////////////////////////////////
class WedgeUtilsSSEFuncTest : public testing::Test {
@@ -99,17 +99,17 @@
p1[j] = clamp(s[j] + rng_(33) - 16, 0, UINT8_MAX);
}
- vpx_blend_a64_mask(p, w, p0, w, p1, w, m, w, h, w, 0, 0);
+ aom_blend_a64_mask(p, w, p0, w, p1, w, m, w, h, w, 0, 0);
- vpx_subtract_block(h, w, r0, w, s, w, p0, w);
- vpx_subtract_block(h, w, r1, w, s, w, p1, w);
+ aom_subtract_block(h, w, r0, w, s, w, p0, w);
+ aom_subtract_block(h, w, r1, w, s, w, p1, w);
- vpx_subtract_block(h, w, r_ref, w, s, w, p, w);
+ aom_subtract_block(h, w, r_ref, w, s, w, p, w);
equiv_blend_residuals(r_tst, r0, r1, m, N);
for (int i = 0; i < N; ++i) ASSERT_EQ(r_ref[i], r_tst[i]);
- uint64_t ref_sse = vpx_sum_squares_i16(r_ref, N);
+ uint64_t ref_sse = aom_sum_squares_i16(r_ref, N);
uint64_t tst_sse = equiv_sse_from_residuals(r0, r1, m, N);
ASSERT_EQ(ref_sse, tst_sse);
@@ -146,14 +146,14 @@
for (int i = 0; i < N; i++) r0[i] = r1[i] + d[i];
const uint64_t ref_res = sse_from_residuals(r0, r1, m, N);
- const uint64_t tst_res = vp10_wedge_sse_from_residuals(r1, d, m, N);
+ const uint64_t tst_res = av1_wedge_sse_from_residuals(r1, d, m, N);
ASSERT_EQ(ref_res, tst_res);
}
}
//////////////////////////////////////////////////////////////////////////////
-// vp10_wedge_sse_from_residuals - optimizations
+// av1_wedge_sse_from_residuals - optimizations
//////////////////////////////////////////////////////////////////////////////
typedef uint64_t (*FSSE)(const int16_t *r1, const int16_t *d, const uint8_t *m,
@@ -220,13 +220,13 @@
#if HAVE_SSE2
INSTANTIATE_TEST_CASE_P(
SSE2, WedgeUtilsSSEOptTest,
- ::testing::Values(TestFuncsFSSE(vp10_wedge_sse_from_residuals_c,
- vp10_wedge_sse_from_residuals_sse2)));
+ ::testing::Values(TestFuncsFSSE(av1_wedge_sse_from_residuals_c,
+ av1_wedge_sse_from_residuals_sse2)));
#endif // HAVE_SSE2
//////////////////////////////////////////////////////////////////////////////
-// vp10_wedge_sign_from_residuals
+// av1_wedge_sign_from_residuals
//////////////////////////////////////////////////////////////////////////////
typedef int (*FSign)(const int16_t *ds, const uint8_t *m, int N, int64_t limit);
@@ -251,12 +251,12 @@
m[i] = rng_(MAX_MASK_VALUE + 1);
}
- const int maxN = VPXMIN(kMaxSize, MAX_SB_SQUARE);
+ const int maxN = AOMMIN(kMaxSize, MAX_SB_SQUARE);
const int N = 64 * (rng_(maxN / 64 - 1) + 1);
int64_t limit;
- limit = (int64_t)vpx_sum_squares_i16(r0, N);
- limit -= (int64_t)vpx_sum_squares_i16(r1, N);
+ limit = (int64_t)aom_sum_squares_i16(r0, N);
+ limit -= (int64_t)aom_sum_squares_i16(r1, N);
limit *= (1 << WEDGE_WEIGHT_BITS) / 2;
for (int i = 0; i < N; i++)
@@ -306,12 +306,12 @@
for (int i = 0; i < MAX_SB_SQUARE; ++i) m[i] = MAX_MASK_VALUE;
- const int maxN = VPXMIN(kMaxSize, MAX_SB_SQUARE);
+ const int maxN = AOMMIN(kMaxSize, MAX_SB_SQUARE);
const int N = 64 * (rng_(maxN / 64 - 1) + 1);
int64_t limit;
- limit = (int64_t)vpx_sum_squares_i16(r0, N);
- limit -= (int64_t)vpx_sum_squares_i16(r1, N);
+ limit = (int64_t)aom_sum_squares_i16(r0, N);
+ limit -= (int64_t)aom_sum_squares_i16(r1, N);
limit *= (1 << WEDGE_WEIGHT_BITS) / 2;
for (int i = 0; i < N; i++)
@@ -329,13 +329,13 @@
INSTANTIATE_TEST_CASE_P(
SSE2, WedgeUtilsSignOptTest,
- ::testing::Values(TestFuncsFSign(vp10_wedge_sign_from_residuals_c,
- vp10_wedge_sign_from_residuals_sse2)));
+ ::testing::Values(TestFuncsFSign(av1_wedge_sign_from_residuals_c,
+ av1_wedge_sign_from_residuals_sse2)));
#endif // HAVE_SSE2
//////////////////////////////////////////////////////////////////////////////
-// vp10_wedge_compute_delta_squares
+// av1_wedge_compute_delta_squares
//////////////////////////////////////////////////////////////////////////////
typedef void (*FDS)(int16_t *d, const int16_t *a, const int16_t *b, int N);
@@ -374,8 +374,8 @@
INSTANTIATE_TEST_CASE_P(
SSE2, WedgeUtilsDeltaSquaresOptTest,
- ::testing::Values(TestFuncsFDS(vp10_wedge_compute_delta_squares_c,
- vp10_wedge_compute_delta_squares_sse2)));
+ ::testing::Values(TestFuncsFDS(av1_wedge_compute_delta_squares_c,
+ av1_wedge_compute_delta_squares_sse2)));
#endif // HAVE_SSE2
diff --git a/test/avg_test.cc b/test/avg_test.cc
index eb3e8b1..d2b83cd 100644
--- a/test/avg_test.cc
+++ b/test/avg_test.cc
@@ -14,14 +14,14 @@
#include "third_party/googletest/src/include/gtest/gtest.h"
-#include "./vpx_config.h"
-#include "./vpx_dsp_rtcd.h"
+#include "./aom_config.h"
+#include "./aom_dsp_rtcd.h"
#include "test/acm_random.h"
#include "test/clear_system_state.h"
#include "test/register_state_check.h"
#include "test/util.h"
-#include "aom_mem/vpx_mem.h"
+#include "aom_mem/aom_mem.h"
using libaom_test::ACMRandom;
@@ -32,11 +32,11 @@
static void SetUpTestCase() {
source_data_ = reinterpret_cast<uint8_t *>(
- vpx_memalign(kDataAlignment, kDataBlockSize));
+ aom_memalign(kDataAlignment, kDataBlockSize));
}
static void TearDownTestCase() {
- vpx_free(source_data_);
+ aom_free(source_data_);
source_data_ = NULL;
}
@@ -131,15 +131,15 @@
protected:
virtual void SetUp() {
hbuf_asm_ = reinterpret_cast<int16_t *>(
- vpx_memalign(kDataAlignment, sizeof(*hbuf_asm_) * 16));
+ aom_memalign(kDataAlignment, sizeof(*hbuf_asm_) * 16));
hbuf_c_ = reinterpret_cast<int16_t *>(
- vpx_memalign(kDataAlignment, sizeof(*hbuf_c_) * 16));
+ aom_memalign(kDataAlignment, sizeof(*hbuf_c_) * 16));
}
virtual void TearDown() {
- vpx_free(hbuf_c_);
+ aom_free(hbuf_c_);
hbuf_c_ = NULL;
- vpx_free(hbuf_asm_);
+ aom_free(hbuf_asm_);
hbuf_asm_ = NULL;
}
@@ -194,13 +194,13 @@
satd_func_ = GET_PARAM(1);
rnd_.Reset(ACMRandom::DeterministicSeed());
src_ = reinterpret_cast<int16_t *>(
- vpx_memalign(16, sizeof(*src_) * satd_size_));
+ aom_memalign(16, sizeof(*src_) * satd_size_));
ASSERT_TRUE(src_ != NULL);
}
virtual void TearDown() {
libaom_test::ClearSystemState();
- vpx_free(src_);
+ aom_free(src_);
}
void FillConstant(const int16_t val) {
@@ -309,86 +309,86 @@
INSTANTIATE_TEST_CASE_P(
C, AverageTest,
- ::testing::Values(make_tuple(16, 16, 1, 8, &vpx_avg_8x8_c),
- make_tuple(16, 16, 1, 4, &vpx_avg_4x4_c)));
+ ::testing::Values(make_tuple(16, 16, 1, 8, &aom_avg_8x8_c),
+ make_tuple(16, 16, 1, 4, &aom_avg_4x4_c)));
INSTANTIATE_TEST_CASE_P(C, SatdTest,
- ::testing::Values(make_tuple(16, &vpx_satd_c),
- make_tuple(64, &vpx_satd_c),
- make_tuple(256, &vpx_satd_c),
- make_tuple(1024, &vpx_satd_c)));
+ ::testing::Values(make_tuple(16, &aom_satd_c),
+ make_tuple(64, &aom_satd_c),
+ make_tuple(256, &aom_satd_c),
+ make_tuple(1024, &aom_satd_c)));
#if HAVE_SSE2
INSTANTIATE_TEST_CASE_P(
SSE2, AverageTest,
- ::testing::Values(make_tuple(16, 16, 0, 8, &vpx_avg_8x8_sse2),
- make_tuple(16, 16, 5, 8, &vpx_avg_8x8_sse2),
- make_tuple(32, 32, 15, 8, &vpx_avg_8x8_sse2),
- make_tuple(16, 16, 0, 4, &vpx_avg_4x4_sse2),
- make_tuple(16, 16, 5, 4, &vpx_avg_4x4_sse2),
- make_tuple(32, 32, 15, 4, &vpx_avg_4x4_sse2)));
+ ::testing::Values(make_tuple(16, 16, 0, 8, &aom_avg_8x8_sse2),
+ make_tuple(16, 16, 5, 8, &aom_avg_8x8_sse2),
+ make_tuple(32, 32, 15, 8, &aom_avg_8x8_sse2),
+ make_tuple(16, 16, 0, 4, &aom_avg_4x4_sse2),
+ make_tuple(16, 16, 5, 4, &aom_avg_4x4_sse2),
+ make_tuple(32, 32, 15, 4, &aom_avg_4x4_sse2)));
INSTANTIATE_TEST_CASE_P(
SSE2, IntProRowTest,
- ::testing::Values(make_tuple(16, &vpx_int_pro_row_sse2, &vpx_int_pro_row_c),
- make_tuple(32, &vpx_int_pro_row_sse2, &vpx_int_pro_row_c),
- make_tuple(64, &vpx_int_pro_row_sse2,
- &vpx_int_pro_row_c)));
+ ::testing::Values(make_tuple(16, &aom_int_pro_row_sse2, &aom_int_pro_row_c),
+ make_tuple(32, &aom_int_pro_row_sse2, &aom_int_pro_row_c),
+ make_tuple(64, &aom_int_pro_row_sse2,
+ &aom_int_pro_row_c)));
INSTANTIATE_TEST_CASE_P(
SSE2, IntProColTest,
- ::testing::Values(make_tuple(16, &vpx_int_pro_col_sse2, &vpx_int_pro_col_c),
- make_tuple(32, &vpx_int_pro_col_sse2, &vpx_int_pro_col_c),
- make_tuple(64, &vpx_int_pro_col_sse2,
- &vpx_int_pro_col_c)));
+ ::testing::Values(make_tuple(16, &aom_int_pro_col_sse2, &aom_int_pro_col_c),
+ make_tuple(32, &aom_int_pro_col_sse2, &aom_int_pro_col_c),
+ make_tuple(64, &aom_int_pro_col_sse2,
+ &aom_int_pro_col_c)));
INSTANTIATE_TEST_CASE_P(SSE2, SatdTest,
- ::testing::Values(make_tuple(16, &vpx_satd_sse2),
- make_tuple(64, &vpx_satd_sse2),
- make_tuple(256, &vpx_satd_sse2),
- make_tuple(1024, &vpx_satd_sse2)));
+ ::testing::Values(make_tuple(16, &aom_satd_sse2),
+ make_tuple(64, &aom_satd_sse2),
+ make_tuple(256, &aom_satd_sse2),
+ make_tuple(1024, &aom_satd_sse2)));
#endif
#if HAVE_NEON
INSTANTIATE_TEST_CASE_P(
NEON, AverageTest,
- ::testing::Values(make_tuple(16, 16, 0, 8, &vpx_avg_8x8_neon),
- make_tuple(16, 16, 5, 8, &vpx_avg_8x8_neon),
- make_tuple(32, 32, 15, 8, &vpx_avg_8x8_neon),
- make_tuple(16, 16, 0, 4, &vpx_avg_4x4_neon),
- make_tuple(16, 16, 5, 4, &vpx_avg_4x4_neon),
- make_tuple(32, 32, 15, 4, &vpx_avg_4x4_neon)));
+ ::testing::Values(make_tuple(16, 16, 0, 8, &aom_avg_8x8_neon),
+ make_tuple(16, 16, 5, 8, &aom_avg_8x8_neon),
+ make_tuple(32, 32, 15, 8, &aom_avg_8x8_neon),
+ make_tuple(16, 16, 0, 4, &aom_avg_4x4_neon),
+ make_tuple(16, 16, 5, 4, &aom_avg_4x4_neon),
+ make_tuple(32, 32, 15, 4, &aom_avg_4x4_neon)));
INSTANTIATE_TEST_CASE_P(
NEON, IntProRowTest,
- ::testing::Values(make_tuple(16, &vpx_int_pro_row_neon, &vpx_int_pro_row_c),
- make_tuple(32, &vpx_int_pro_row_neon, &vpx_int_pro_row_c),
- make_tuple(64, &vpx_int_pro_row_neon,
- &vpx_int_pro_row_c)));
+ ::testing::Values(make_tuple(16, &aom_int_pro_row_neon, &aom_int_pro_row_c),
+ make_tuple(32, &aom_int_pro_row_neon, &aom_int_pro_row_c),
+ make_tuple(64, &aom_int_pro_row_neon,
+ &aom_int_pro_row_c)));
INSTANTIATE_TEST_CASE_P(
NEON, IntProColTest,
- ::testing::Values(make_tuple(16, &vpx_int_pro_col_neon, &vpx_int_pro_col_c),
- make_tuple(32, &vpx_int_pro_col_neon, &vpx_int_pro_col_c),
- make_tuple(64, &vpx_int_pro_col_neon,
- &vpx_int_pro_col_c)));
+ ::testing::Values(make_tuple(16, &aom_int_pro_col_neon, &aom_int_pro_col_c),
+ make_tuple(32, &aom_int_pro_col_neon, &aom_int_pro_col_c),
+ make_tuple(64, &aom_int_pro_col_neon,
+ &aom_int_pro_col_c)));
INSTANTIATE_TEST_CASE_P(NEON, SatdTest,
- ::testing::Values(make_tuple(16, &vpx_satd_neon),
- make_tuple(64, &vpx_satd_neon),
- make_tuple(256, &vpx_satd_neon),
- make_tuple(1024, &vpx_satd_neon)));
+ ::testing::Values(make_tuple(16, &aom_satd_neon),
+ make_tuple(64, &aom_satd_neon),
+ make_tuple(256, &aom_satd_neon),
+ make_tuple(1024, &aom_satd_neon)));
#endif
#if HAVE_MSA
INSTANTIATE_TEST_CASE_P(
MSA, AverageTest,
- ::testing::Values(make_tuple(16, 16, 0, 8, &vpx_avg_8x8_msa),
- make_tuple(16, 16, 5, 8, &vpx_avg_8x8_msa),
- make_tuple(32, 32, 15, 8, &vpx_avg_8x8_msa),
- make_tuple(16, 16, 0, 4, &vpx_avg_4x4_msa),
- make_tuple(16, 16, 5, 4, &vpx_avg_4x4_msa),
- make_tuple(32, 32, 15, 4, &vpx_avg_4x4_msa)));
+ ::testing::Values(make_tuple(16, 16, 0, 8, &aom_avg_8x8_msa),
+ make_tuple(16, 16, 5, 8, &aom_avg_8x8_msa),
+ make_tuple(32, 32, 15, 8, &aom_avg_8x8_msa),
+ make_tuple(16, 16, 0, 4, &aom_avg_4x4_msa),
+ make_tuple(16, 16, 5, 4, &aom_avg_4x4_msa),
+ make_tuple(32, 32, 15, 4, &aom_avg_4x4_msa)));
#endif
} // namespace
diff --git a/test/blend_a64_mask_1d_test.cc b/test/blend_a64_mask_1d_test.cc
index c5c5929..f0f8d65 100644
--- a/test/blend_a64_mask_1d_test.cc
+++ b/test/blend_a64_mask_1d_test.cc
@@ -17,11 +17,11 @@
#include "test/function_equivalence_test.h"
-#include "./vpx_config.h"
-#include "./vpx_dsp_rtcd.h"
-#include "aom/vpx_integer.h"
+#include "./aom_config.h"
+#include "./aom_dsp_rtcd.h"
+#include "aom/aom_integer.h"
-#include "./vp10_rtcd.h"
+#include "./av1_rtcd.h"
#include "av1/common/enums.h"
@@ -142,7 +142,7 @@
}
for (int i = 0; i < kMaxMaskSize; ++i)
- mask_[i] = rng_(VPX_BLEND_A64_MAX_ALPHA + 1);
+ mask_[i] = rng_(AOM_BLEND_A64_MAX_ALPHA + 1);
Common();
}
@@ -158,7 +158,7 @@
}
for (int i = 0; i < kMaxMaskSize; ++i)
- mask_[i] = rng_(2) + VPX_BLEND_A64_MAX_ALPHA - 1;
+ mask_[i] = rng_(2) + AOM_BLEND_A64_MAX_ALPHA - 1;
Common();
}
@@ -174,7 +174,7 @@
for (int row = 0; row < h; ++row)
for (int col = 0; col < w; ++col) mask2d[row][col] = mask[col];
- vpx_blend_a64_mask_c(dst, dst_stride, src0, src0_stride, src1, src1_stride,
+ aom_blend_a64_mask_c(dst, dst_stride, src0, src0_stride, src1, src1_stride,
&mask2d[0][0], BlendA64Mask1DTest8B::kMaxMaskSize, h, w,
0, 0);
}
@@ -189,25 +189,25 @@
for (int row = 0; row < h; ++row)
for (int col = 0; col < w; ++col) mask2d[row][col] = mask[row];
- vpx_blend_a64_mask_c(dst, dst_stride, src0, src0_stride, src1, src1_stride,
+ aom_blend_a64_mask_c(dst, dst_stride, src0, src0_stride, src1, src1_stride,
&mask2d[0][0], BlendA64Mask1DTest8B::kMaxMaskSize, h, w,
0, 0);
}
INSTANTIATE_TEST_CASE_P(
C, BlendA64Mask1DTest8B,
- ::testing::Values(TestFuncs(blend_a64_hmask_ref, vpx_blend_a64_hmask_c),
- TestFuncs(blend_a64_vmask_ref, vpx_blend_a64_vmask_c)));
+ ::testing::Values(TestFuncs(blend_a64_hmask_ref, aom_blend_a64_hmask_c),
+ TestFuncs(blend_a64_vmask_ref, aom_blend_a64_vmask_c)));
#if HAVE_SSE4_1
INSTANTIATE_TEST_CASE_P(
SSE4_1, BlendA64Mask1DTest8B,
::testing::Values(
- TestFuncs(blend_a64_hmask_ref, vpx_blend_a64_hmask_sse4_1),
- TestFuncs(blend_a64_vmask_ref, vpx_blend_a64_vmask_sse4_1)));
+ TestFuncs(blend_a64_hmask_ref, aom_blend_a64_hmask_sse4_1),
+ TestFuncs(blend_a64_vmask_ref, aom_blend_a64_vmask_sse4_1)));
#endif // HAVE_SSE4_1
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
//////////////////////////////////////////////////////////////////////////////
// High bit-depth version
//////////////////////////////////////////////////////////////////////////////
@@ -253,7 +253,7 @@
}
for (int i = 0; i < kMaxMaskSize; ++i)
- mask_[i] = rng_(VPX_BLEND_A64_MAX_ALPHA + 1);
+ mask_[i] = rng_(AOM_BLEND_A64_MAX_ALPHA + 1);
Common();
}
@@ -278,7 +278,7 @@
}
for (int i = 0; i < kMaxMaskSize; ++i)
- mask_[i] = rng_(2) + VPX_BLEND_A64_MAX_ALPHA - 1;
+ mask_[i] = rng_(2) + AOM_BLEND_A64_MAX_ALPHA - 1;
Common();
}
@@ -294,7 +294,7 @@
for (int row = 0; row < h; ++row)
for (int col = 0; col < w; ++col) mask2d[row][col] = mask[col];
- vpx_highbd_blend_a64_mask_c(
+ aom_highbd_blend_a64_mask_c(
dst, dst_stride, src0, src0_stride, src1, src1_stride, &mask2d[0][0],
BlendA64Mask1DTestHBD::kMaxMaskSize, h, w, 0, 0, bd);
}
@@ -309,7 +309,7 @@
for (int row = 0; row < h; ++row)
for (int col = 0; col < w; ++col) mask2d[row][col] = mask[row];
- vpx_highbd_blend_a64_mask_c(
+ aom_highbd_blend_a64_mask_c(
dst, dst_stride, src0, src0_stride, src1, src1_stride, &mask2d[0][0],
BlendA64Mask1DTestHBD::kMaxMaskSize, h, w, 0, 0, bd);
}
@@ -317,18 +317,18 @@
INSTANTIATE_TEST_CASE_P(
C, BlendA64Mask1DTestHBD,
::testing::Values(TestFuncsHBD(highbd_blend_a64_hmask_ref,
- vpx_highbd_blend_a64_hmask_c),
+ aom_highbd_blend_a64_hmask_c),
TestFuncsHBD(highbd_blend_a64_vmask_ref,
- vpx_highbd_blend_a64_vmask_c)));
+ aom_highbd_blend_a64_vmask_c)));
#if HAVE_SSE4_1
INSTANTIATE_TEST_CASE_P(
SSE4_1, BlendA64Mask1DTestHBD,
::testing::Values(TestFuncsHBD(highbd_blend_a64_hmask_ref,
- vpx_highbd_blend_a64_hmask_sse4_1),
+ aom_highbd_blend_a64_hmask_sse4_1),
TestFuncsHBD(highbd_blend_a64_vmask_ref,
- vpx_highbd_blend_a64_vmask_sse4_1)));
+ aom_highbd_blend_a64_vmask_sse4_1)));
#endif // HAVE_SSE4_1
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#endif // CONFIG_AOM_HIGHBITDEPTH
} // namespace
diff --git a/test/blend_a64_mask_test.cc b/test/blend_a64_mask_test.cc
index 3fe6112..4c9b1d2 100644
--- a/test/blend_a64_mask_test.cc
+++ b/test/blend_a64_mask_test.cc
@@ -17,11 +17,11 @@
#include "test/function_equivalence_test.h"
-#include "./vpx_config.h"
-#include "./vpx_dsp_rtcd.h"
-#include "aom/vpx_integer.h"
+#include "./aom_config.h"
+#include "./aom_dsp_rtcd.h"
+#include "aom/aom_integer.h"
-#include "./vp10_rtcd.h"
+#include "./av1_rtcd.h"
#include "av1/common/enums.h"
@@ -154,7 +154,7 @@
}
for (int i = 0; i < kMaxMaskSize; ++i)
- mask_[i] = rng_(VPX_BLEND_A64_MAX_ALPHA + 1);
+ mask_[i] = rng_(AOM_BLEND_A64_MAX_ALPHA + 1);
Common();
}
@@ -170,7 +170,7 @@
}
for (int i = 0; i < kMaxMaskSize; ++i)
- mask_[i] = rng_(2) + VPX_BLEND_A64_MAX_ALPHA - 1;
+ mask_[i] = rng_(2) + AOM_BLEND_A64_MAX_ALPHA - 1;
Common();
}
@@ -179,10 +179,10 @@
#if HAVE_SSE4_1
INSTANTIATE_TEST_CASE_P(SSE4_1_C_COMPARE, BlendA64MaskTest8B,
::testing::Values(TestFuncs(
- vpx_blend_a64_mask_c, vpx_blend_a64_mask_sse4_1)));
+ aom_blend_a64_mask_c, aom_blend_a64_mask_sse4_1)));
#endif // HAVE_SSE4_1
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
//////////////////////////////////////////////////////////////////////////////
// High bit-depth version
//////////////////////////////////////////////////////////////////////////////
@@ -229,7 +229,7 @@
}
for (int i = 0; i < kMaxMaskSize; ++i)
- mask_[i] = rng_(VPX_BLEND_A64_MAX_ALPHA + 1);
+ mask_[i] = rng_(AOM_BLEND_A64_MAX_ALPHA + 1);
Common();
}
@@ -254,7 +254,7 @@
}
for (int i = 0; i < kMaxMaskSize; ++i)
- mask_[i] = rng_(2) + VPX_BLEND_A64_MAX_ALPHA - 1;
+ mask_[i] = rng_(2) + AOM_BLEND_A64_MAX_ALPHA - 1;
Common();
}
@@ -263,8 +263,8 @@
#if HAVE_SSE4_1
INSTANTIATE_TEST_CASE_P(
SSE4_1_C_COMPARE, BlendA64MaskTestHBD,
- ::testing::Values(TestFuncsHBD(vpx_highbd_blend_a64_mask_c,
- vpx_highbd_blend_a64_mask_sse4_1)));
+ ::testing::Values(TestFuncsHBD(aom_highbd_blend_a64_mask_c,
+ aom_highbd_blend_a64_mask_sse4_1)));
#endif // HAVE_SSE4_1
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#endif // CONFIG_AOM_HIGHBITDEPTH
} // namespace
diff --git a/test/boolcoder_test.cc b/test/boolcoder_test.cc
index 949907b..551a08f 100644
--- a/test/boolcoder_test.cc
+++ b/test/boolcoder_test.cc
@@ -15,7 +15,7 @@
#include "third_party/googletest/src/include/gtest/gtest.h"
#include "test/acm_random.h"
-#include "aom/vpx_integer.h"
+#include "aom/aom_integer.h"
#include "aom_dsp/bitreader.h"
#include "aom_dsp/bitwriter.h"
@@ -25,7 +25,7 @@
const int num_tests = 10;
} // namespace
-TEST(VP9, TestBitIO) {
+TEST(AV1, TestBitIO) {
ACMRandom rnd(ACMRandom::DeterministicSeed());
for (int n = 0; n < num_tests; ++n) {
for (int method = 0; method <= 7; ++method) { // we generate various proba
@@ -51,9 +51,9 @@
const int random_seed = 6432;
const int kBufferSize = 10000;
ACMRandom bit_rnd(random_seed);
- vpx_writer bw;
+ aom_writer bw;
uint8_t bw_buffer[kBufferSize];
- vpx_start_encode(&bw, bw_buffer);
+ aom_start_encode(&bw, bw_buffer);
int bit = (bit_method == 0) ? 0 : (bit_method == 1) ? 1 : 0;
for (int i = 0; i < kBitsToTest; ++i) {
@@ -62,16 +62,16 @@
} else if (bit_method == 3) {
bit = bit_rnd(2);
}
- vpx_write(&bw, bit, static_cast<int>(probas[i]));
+ aom_write(&bw, bit, static_cast<int>(probas[i]));
}
- vpx_stop_encode(&bw);
+ aom_stop_encode(&bw);
// First bit should be zero
GTEST_ASSERT_EQ(bw_buffer[0] & 0x80, 0);
- vpx_reader br;
- vpx_reader_init(&br, bw_buffer, kBufferSize, NULL, NULL);
+ aom_reader br;
+ aom_reader_init(&br, bw_buffer, kBufferSize, NULL, NULL);
bit_rnd.Reset(random_seed);
for (int i = 0; i < kBitsToTest; ++i) {
if (bit_method == 2) {
@@ -79,7 +79,7 @@
} else if (bit_method == 3) {
bit = bit_rnd(2);
}
- GTEST_ASSERT_EQ(vpx_read(&br, probas[i]), bit)
+ GTEST_ASSERT_EQ(aom_read(&br, probas[i]), bit)
<< "pos: " << i << " / " << kBitsToTest
<< " bit_method: " << bit_method << " method: " << method;
}
diff --git a/test/borders_test.cc b/test/borders_test.cc
index e631da5..39125c0 100644
--- a/test/borders_test.cc
+++ b/test/borders_test.cc
@@ -32,16 +32,16 @@
virtual void PreEncodeFrameHook(::libaom_test::VideoSource *video,
::libaom_test::Encoder *encoder) {
if (video->frame() == 1) {
- encoder->Control(VP8E_SET_CPUUSED, 1);
- encoder->Control(VP8E_SET_ENABLEAUTOALTREF, 1);
- encoder->Control(VP8E_SET_ARNR_MAXFRAMES, 7);
- encoder->Control(VP8E_SET_ARNR_STRENGTH, 5);
- encoder->Control(VP8E_SET_ARNR_TYPE, 3);
+ encoder->Control(AOME_SET_CPUUSED, 1);
+ encoder->Control(AOME_SET_ENABLEAUTOALTREF, 1);
+ encoder->Control(AOME_SET_ARNR_MAXFRAMES, 7);
+ encoder->Control(AOME_SET_ARNR_STRENGTH, 5);
+ encoder->Control(AOME_SET_ARNR_TYPE, 3);
}
}
- virtual void FramePktHook(const vpx_codec_cx_pkt_t *pkt) {
- if (pkt->data.frame.flags & VPX_FRAME_IS_KEY) {
+ virtual void FramePktHook(const aom_codec_cx_pkt_t *pkt) {
+ if (pkt->data.frame.flags & AOM_FRAME_IS_KEY) {
}
}
};
@@ -79,6 +79,6 @@
ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
}
-VP10_INSTANTIATE_TEST_CASE(BordersTest,
- ::testing::Values(::libaom_test::kTwoPassGood));
+AV1_INSTANTIATE_TEST_CASE(BordersTest,
+ ::testing::Values(::libaom_test::kTwoPassGood));
} // namespace
diff --git a/test/clear_system_state.h b/test/clear_system_state.h
index b80cceb..e8fcf6d 100644
--- a/test/clear_system_state.h
+++ b/test/clear_system_state.h
@@ -10,7 +10,7 @@
#ifndef TEST_CLEAR_SYSTEM_STATE_H_
#define TEST_CLEAR_SYSTEM_STATE_H_
-#include "./vpx_config.h"
+#include "./aom_config.h"
#if ARCH_X86 || ARCH_X86_64
#include "aom_ports/x86.h"
#endif
@@ -21,7 +21,7 @@
// test cases.
inline void ClearSystemState() {
#if ARCH_X86 || ARCH_X86_64
- vpx_reset_mmx_state();
+ aom_reset_mmx_state();
#endif
}
diff --git a/test/codec_factory.h b/test/codec_factory.h
index abbf2e1..84d40a1 100644
--- a/test/codec_factory.h
+++ b/test/codec_factory.h
@@ -10,14 +10,14 @@
#ifndef TEST_CODEC_FACTORY_H_
#define TEST_CODEC_FACTORY_H_
-#include "./vpx_config.h"
-#include "aom/vpx_decoder.h"
-#include "aom/vpx_encoder.h"
-#if CONFIG_VP10_ENCODER
-#include "aom/vp8cx.h"
+#include "./aom_config.h"
+#include "aom/aom_decoder.h"
+#include "aom/aom_encoder.h"
+#if CONFIG_AV1_ENCODER
+#include "aom/aomcx.h"
#endif
-#if CONFIG_VP10_DECODER
-#include "aom/vp8dx.h"
+#if CONFIG_AV1_DECODER
+#include "aom/aomdx.h"
#endif
#include "test/decode_test_driver.h"
@@ -32,20 +32,20 @@
virtual ~CodecFactory() {}
- virtual Decoder *CreateDecoder(vpx_codec_dec_cfg_t cfg,
+ virtual Decoder *CreateDecoder(aom_codec_dec_cfg_t cfg,
unsigned long deadline) const = 0;
- virtual Decoder *CreateDecoder(vpx_codec_dec_cfg_t cfg,
- const vpx_codec_flags_t flags,
+ virtual Decoder *CreateDecoder(aom_codec_dec_cfg_t cfg,
+ const aom_codec_flags_t flags,
unsigned long deadline) // NOLINT(runtime/int)
const = 0;
- virtual Encoder *CreateEncoder(vpx_codec_enc_cfg_t cfg,
+ virtual Encoder *CreateEncoder(aom_codec_enc_cfg_t cfg,
unsigned long deadline,
const unsigned long init_flags,
TwopassStatsStore *stats) const = 0;
- virtual vpx_codec_err_t DefaultEncoderConfig(vpx_codec_enc_cfg_t *cfg,
+ virtual aom_codec_err_t DefaultEncoderConfig(aom_codec_enc_cfg_t *cfg,
int usage) const = 0;
};
@@ -69,96 +69,96 @@
std::tr1::tuple<const libaom_test::CodecFactory *, T1, T2, T3> > {};
/*
- * VP10 Codec Definitions
+ * AV1 Codec Definitions
*/
-#if CONFIG_VP10
-class VP10Decoder : public Decoder {
+#if CONFIG_AV1
+class AV1Decoder : public Decoder {
public:
- VP10Decoder(vpx_codec_dec_cfg_t cfg, unsigned long deadline)
+ AV1Decoder(aom_codec_dec_cfg_t cfg, unsigned long deadline)
: Decoder(cfg, deadline) {}
- VP10Decoder(vpx_codec_dec_cfg_t cfg, const vpx_codec_flags_t flag,
- unsigned long deadline) // NOLINT
+ AV1Decoder(aom_codec_dec_cfg_t cfg, const aom_codec_flags_t flag,
+ unsigned long deadline) // NOLINT
: Decoder(cfg, flag, deadline) {}
protected:
- virtual vpx_codec_iface_t *CodecInterface() const {
-#if CONFIG_VP10_DECODER
- return &vpx_codec_vp10_dx_algo;
+ virtual aom_codec_iface_t *CodecInterface() const {
+#if CONFIG_AV1_DECODER
+ return &aom_codec_av1_dx_algo;
#else
return NULL;
#endif
}
};
-class VP10Encoder : public Encoder {
+class AV1Encoder : public Encoder {
public:
- VP10Encoder(vpx_codec_enc_cfg_t cfg, unsigned long deadline,
- const unsigned long init_flags, TwopassStatsStore *stats)
+ AV1Encoder(aom_codec_enc_cfg_t cfg, unsigned long deadline,
+ const unsigned long init_flags, TwopassStatsStore *stats)
: Encoder(cfg, deadline, init_flags, stats) {}
protected:
- virtual vpx_codec_iface_t *CodecInterface() const {
-#if CONFIG_VP10_ENCODER
- return &vpx_codec_vp10_cx_algo;
+ virtual aom_codec_iface_t *CodecInterface() const {
+#if CONFIG_AV1_ENCODER
+ return &aom_codec_av1_cx_algo;
#else
return NULL;
#endif
}
};
-class VP10CodecFactory : public CodecFactory {
+class AV1CodecFactory : public CodecFactory {
public:
- VP10CodecFactory() : CodecFactory() {}
+ AV1CodecFactory() : CodecFactory() {}
- virtual Decoder *CreateDecoder(vpx_codec_dec_cfg_t cfg,
+ virtual Decoder *CreateDecoder(aom_codec_dec_cfg_t cfg,
unsigned long deadline) const {
return CreateDecoder(cfg, 0, deadline);
}
- virtual Decoder *CreateDecoder(vpx_codec_dec_cfg_t cfg,
- const vpx_codec_flags_t flags,
+ virtual Decoder *CreateDecoder(aom_codec_dec_cfg_t cfg,
+ const aom_codec_flags_t flags,
unsigned long deadline) const { // NOLINT
-#if CONFIG_VP10_DECODER
- return new VP10Decoder(cfg, flags, deadline);
+#if CONFIG_AV1_DECODER
+ return new AV1Decoder(cfg, flags, deadline);
#else
return NULL;
#endif
}
- virtual Encoder *CreateEncoder(vpx_codec_enc_cfg_t cfg,
+ virtual Encoder *CreateEncoder(aom_codec_enc_cfg_t cfg,
unsigned long deadline,
const unsigned long init_flags,
TwopassStatsStore *stats) const {
-#if CONFIG_VP10_ENCODER
- return new VP10Encoder(cfg, deadline, init_flags, stats);
+#if CONFIG_AV1_ENCODER
+ return new AV1Encoder(cfg, deadline, init_flags, stats);
#else
return NULL;
#endif
}
- virtual vpx_codec_err_t DefaultEncoderConfig(vpx_codec_enc_cfg_t *cfg,
+ virtual aom_codec_err_t DefaultEncoderConfig(aom_codec_enc_cfg_t *cfg,
int usage) const {
-#if CONFIG_VP10_ENCODER
- return vpx_codec_enc_config_default(&vpx_codec_vp10_cx_algo, cfg, usage);
+#if CONFIG_AV1_ENCODER
+ return aom_codec_enc_config_default(&aom_codec_av1_cx_algo, cfg, usage);
#else
- return VPX_CODEC_INCAPABLE;
+ return AOM_CODEC_INCAPABLE;
#endif
}
};
-const libaom_test::VP10CodecFactory kVP10;
+const libaom_test::AV1CodecFactory kAV1;
-#define VP10_INSTANTIATE_TEST_CASE(test, ...) \
+#define AV1_INSTANTIATE_TEST_CASE(test, ...) \
INSTANTIATE_TEST_CASE_P( \
- VP10, test, \
+ AV1, test, \
::testing::Combine( \
::testing::Values(static_cast<const libaom_test::CodecFactory *>( \
- &libaom_test::kVP10)), \
+ &libaom_test::kAV1)), \
__VA_ARGS__))
#else
-#define VP10_INSTANTIATE_TEST_CASE(test, ...)
-#endif // CONFIG_VP10
+#define AV1_INSTANTIATE_TEST_CASE(test, ...)
+#endif // CONFIG_AV1
} // namespace libaom_test
#endif // TEST_CODEC_FACTORY_H_
diff --git a/test/convolve_test.cc b/test/convolve_test.cc
index 910c4ec..f31ae02 100644
--- a/test/convolve_test.cc
+++ b/test/convolve_test.cc
@@ -12,15 +12,15 @@
#include "third_party/googletest/src/include/gtest/gtest.h"
-#include "./vpx_config.h"
-#include "./vpx_dsp_rtcd.h"
+#include "./aom_config.h"
+#include "./aom_dsp_rtcd.h"
#include "test/acm_random.h"
#include "test/clear_system_state.h"
#include "test/register_state_check.h"
#include "test/util.h"
-#include "aom_dsp/vpx_dsp_common.h"
-#include "aom_dsp/vpx_filter.h"
-#include "aom_mem/vpx_mem.h"
+#include "aom_dsp/aom_dsp_common.h"
+#include "aom_dsp/aom_filter.h"
+#include "aom_mem/aom_mem.h"
#include "aom_ports/mem.h"
namespace {
@@ -64,7 +64,7 @@
typedef std::tr1::tuple<int, int, const ConvolveFunctions *> ConvolveParam;
-#if CONFIG_VP10 && CONFIG_EXT_PARTITION
+#if CONFIG_AV1 && CONFIG_EXT_PARTITION
#define ALL_SIZES(convolve_fn) \
make_tuple(128, 64, &convolve_fn), make_tuple(64, 128, &convolve_fn), \
make_tuple(128, 128, &convolve_fn), make_tuple(4, 4, &convolve_fn), \
@@ -83,11 +83,11 @@
make_tuple(16, 32, &convolve_fn), make_tuple(32, 32, &convolve_fn), \
make_tuple(64, 32, &convolve_fn), make_tuple(32, 64, &convolve_fn), \
make_tuple(64, 64, &convolve_fn)
-#endif // CONFIG_VP10 && CONFIG_EXT_PARTITION
+#endif // CONFIG_AV1 && CONFIG_EXT_PARTITION
// Reference 8-tap subpixel filter, slightly modified to fit into this test.
-#define VP9_FILTER_WEIGHT 128
-#define VP9_FILTER_SHIFT 7
+#define AV1_FILTER_WEIGHT 128
+#define AV1_FILTER_SHIFT 7
uint8_t clip_pixel(int x) { return x < 0 ? 0 : x > 255 ? 255 : x; }
void filter_block2d_8_c(const uint8_t *src_ptr, const unsigned int src_stride,
@@ -125,10 +125,10 @@
(src_ptr[2] * HFilter[2]) + (src_ptr[3] * HFilter[3]) +
(src_ptr[4] * HFilter[4]) + (src_ptr[5] * HFilter[5]) +
(src_ptr[6] * HFilter[6]) + (src_ptr[7] * HFilter[7]) +
- (VP9_FILTER_WEIGHT >> 1); // Rounding
+ (AV1_FILTER_WEIGHT >> 1); // Rounding
// Normalize back to 0-255...
- *output_ptr = clip_pixel(temp >> VP9_FILTER_SHIFT);
+ *output_ptr = clip_pixel(temp >> AV1_FILTER_SHIFT);
++src_ptr;
output_ptr += intermediate_height;
}
@@ -146,10 +146,10 @@
(src_ptr[2] * VFilter[2]) + (src_ptr[3] * VFilter[3]) +
(src_ptr[4] * VFilter[4]) + (src_ptr[5] * VFilter[5]) +
(src_ptr[6] * VFilter[6]) + (src_ptr[7] * VFilter[7]) +
- (VP9_FILTER_WEIGHT >> 1); // Rounding
+ (AV1_FILTER_WEIGHT >> 1); // Rounding
// Normalize back to 0-255...
- *dst_ptr++ = clip_pixel(temp >> VP9_FILTER_SHIFT);
+ *dst_ptr++ = clip_pixel(temp >> AV1_FILTER_SHIFT);
src_ptr += intermediate_height;
}
src_ptr += intermediate_next_stride;
@@ -185,7 +185,7 @@
output_height);
}
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
void highbd_filter_block2d_8_c(const uint16_t *src_ptr,
const unsigned int src_stride,
const int16_t *HFilter, const int16_t *VFilter,
@@ -224,10 +224,10 @@
(src_ptr[2] * HFilter[2]) + (src_ptr[3] * HFilter[3]) +
(src_ptr[4] * HFilter[4]) + (src_ptr[5] * HFilter[5]) +
(src_ptr[6] * HFilter[6]) + (src_ptr[7] * HFilter[7]) +
- (VP9_FILTER_WEIGHT >> 1); // Rounding
+ (AV1_FILTER_WEIGHT >> 1); // Rounding
// Normalize back to 0-255...
- *output_ptr = clip_pixel_highbd(temp >> VP9_FILTER_SHIFT, bd);
+ *output_ptr = clip_pixel_highbd(temp >> AV1_FILTER_SHIFT, bd);
++src_ptr;
output_ptr += intermediate_height;
}
@@ -248,10 +248,10 @@
(src_ptr[2] * VFilter[2]) + (src_ptr[3] * VFilter[3]) +
(src_ptr[4] * VFilter[4]) + (src_ptr[5] * VFilter[5]) +
(src_ptr[6] * VFilter[6]) + (src_ptr[7] * VFilter[7]) +
- (VP9_FILTER_WEIGHT >> 1); // Rounding
+ (AV1_FILTER_WEIGHT >> 1); // Rounding
// Normalize back to 0-255...
- *dst_ptr++ = clip_pixel_highbd(temp >> VP9_FILTER_SHIFT, bd);
+ *dst_ptr++ = clip_pixel_highbd(temp >> AV1_FILTER_SHIFT, bd);
src_ptr += intermediate_height;
}
src_ptr += intermediate_next_stride;
@@ -287,45 +287,45 @@
highbd_block2d_average_c(tmp, kMaxDimension, dst_ptr, dst_stride,
output_width, output_height);
}
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#endif // CONFIG_AOM_HIGHBITDEPTH
class ConvolveTest : public ::testing::TestWithParam<ConvolveParam> {
public:
static void SetUpTestCase() {
// Force input_ to be unaligned, output to be 16 byte aligned.
input_ = reinterpret_cast<uint8_t *>(
- vpx_memalign(kDataAlignment, kInputBufferSize + 1)) +
+ aom_memalign(kDataAlignment, kInputBufferSize + 1)) +
1;
output_ = reinterpret_cast<uint8_t *>(
- vpx_memalign(kDataAlignment, kOutputBufferSize));
+ aom_memalign(kDataAlignment, kOutputBufferSize));
output_ref_ = reinterpret_cast<uint8_t *>(
- vpx_memalign(kDataAlignment, kOutputBufferSize));
-#if CONFIG_VP9_HIGHBITDEPTH
- input16_ = reinterpret_cast<uint16_t *>(vpx_memalign(
+ aom_memalign(kDataAlignment, kOutputBufferSize));
+#if CONFIG_AOM_HIGHBITDEPTH
+ input16_ = reinterpret_cast<uint16_t *>(aom_memalign(
kDataAlignment, (kInputBufferSize + 1) * sizeof(uint16_t))) +
1;
output16_ = reinterpret_cast<uint16_t *>(
- vpx_memalign(kDataAlignment, (kOutputBufferSize) * sizeof(uint16_t)));
+ aom_memalign(kDataAlignment, (kOutputBufferSize) * sizeof(uint16_t)));
output16_ref_ = reinterpret_cast<uint16_t *>(
- vpx_memalign(kDataAlignment, (kOutputBufferSize) * sizeof(uint16_t)));
+ aom_memalign(kDataAlignment, (kOutputBufferSize) * sizeof(uint16_t)));
#endif
}
virtual void TearDown() { libaom_test::ClearSystemState(); }
static void TearDownTestCase() {
- vpx_free(input_ - 1);
+ aom_free(input_ - 1);
input_ = NULL;
- vpx_free(output_);
+ aom_free(output_);
output_ = NULL;
- vpx_free(output_ref_);
+ aom_free(output_ref_);
output_ref_ = NULL;
-#if CONFIG_VP9_HIGHBITDEPTH
- vpx_free(input16_ - 1);
+#if CONFIG_AOM_HIGHBITDEPTH
+ aom_free(input16_ - 1);
input16_ = NULL;
- vpx_free(output16_);
+ aom_free(output16_);
output16_ = NULL;
- vpx_free(output16_ref_);
+ aom_free(output16_ref_);
output16_ref_ = NULL;
#endif
}
@@ -355,7 +355,7 @@
virtual void SetUp() {
UUT_ = GET_PARAM(2);
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
if (UUT_->use_highbd_ != 0)
mask_ = (1 << UUT_->use_highbd_) - 1;
else
@@ -373,12 +373,12 @@
for (int i = 0; i < kInputBufferSize; ++i) {
if (i & 1) {
input_[i] = 255;
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
input16_[i] = mask_;
#endif
} else {
input_[i] = prng.Rand8Extremes();
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
input16_[i] = prng.Rand16() & mask_;
#endif
}
@@ -387,14 +387,14 @@
void SetConstantInput(int value) {
memset(input_, value, kInputBufferSize);
-#if CONFIG_VP9_HIGHBITDEPTH
- vpx_memset16(input16_, value, kInputBufferSize);
+#if CONFIG_AOM_HIGHBITDEPTH
+ aom_memset16(input16_, value, kInputBufferSize);
#endif
}
void CopyOutputToRef() {
memcpy(output_ref_, output_, kOutputBufferSize);
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
memcpy(output16_ref_, output16_,
kOutputBufferSize * sizeof(output16_ref_[0]));
#endif
@@ -408,7 +408,7 @@
uint8_t *input() const {
const int offset = BorderTop() * kOuterBlockSize + BorderLeft();
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
if (UUT_->use_highbd_ == 0) {
return input_ + offset;
} else {
@@ -421,7 +421,7 @@
uint8_t *output() const {
const int offset = BorderTop() * kOuterBlockSize + BorderLeft();
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
if (UUT_->use_highbd_ == 0) {
return output_ + offset;
} else {
@@ -434,7 +434,7 @@
uint8_t *output_ref() const {
const int offset = BorderTop() * kOuterBlockSize + BorderLeft();
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
if (UUT_->use_highbd_ == 0) {
return output_ref_ + offset;
} else {
@@ -446,7 +446,7 @@
}
uint16_t lookup(uint8_t *list, int index) const {
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
if (UUT_->use_highbd_ == 0) {
return list[index];
} else {
@@ -458,7 +458,7 @@
}
void assign_val(uint8_t *list, int index, uint16_t val) const {
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
if (UUT_->use_highbd_ == 0) {
list[index] = (uint8_t)val;
} else {
@@ -474,7 +474,7 @@
const int16_t *HFilter, const int16_t *VFilter, uint8_t *dst_ptr,
unsigned int dst_stride, unsigned int output_width,
unsigned int output_height) {
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
if (UUT_->use_highbd_ == 0) {
filter_average_block2d_8_c(src_ptr, src_stride, HFilter, VFilter, dst_ptr,
dst_stride, output_width, output_height);
@@ -497,7 +497,7 @@
unsigned int dst_stride,
unsigned int output_width,
unsigned int output_height) {
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
if (UUT_->use_highbd_ == 0) {
filter_block2d_8_c(src_ptr, src_stride, HFilter, VFilter, dst_ptr,
dst_stride, output_width, output_height);
@@ -517,7 +517,7 @@
static uint8_t *input_;
static uint8_t *output_;
static uint8_t *output_ref_;
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
static uint16_t *input16_;
static uint16_t *output16_;
static uint16_t *output16_ref_;
@@ -528,7 +528,7 @@
uint8_t *ConvolveTest::input_ = NULL;
uint8_t *ConvolveTest::output_ = NULL;
uint8_t *ConvolveTest::output_ref_ = NULL;
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
uint16_t *ConvolveTest::input16_ = NULL;
uint16_t *ConvolveTest::output16_ = NULL;
uint16_t *ConvolveTest::output16_ref_ = NULL;
@@ -635,7 +635,7 @@
TEST(ConvolveTest, FiltersWontSaturateWhenAddedPairwise) {
for (int filter_bank = 0; filter_bank < kNumFilterBanks; ++filter_bank) {
const InterpKernel *filters =
- vp9_filter_kernels[static_cast<INTERP_FILTER>(filter_bank)];
+ av1_filter_kernels[static_cast<INTERP_FILTER>(filter_bank)];
for (int i = 0; i < kNumFilters; i++) {
const int p0 = filters[i][0] + filters[i][1];
const int p1 = filters[i][2] + filters[i][3];
@@ -658,7 +658,7 @@
TEST_P(ConvolveTest, MatchesReferenceSubpixelFilter) {
uint8_t *const in = input();
uint8_t *const out = output();
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
uint8_t ref8[kOutputStride * kMaxDimension];
uint16_t ref16[kOutputStride * kMaxDimension];
uint8_t *ref;
@@ -673,7 +673,7 @@
for (int filter_bank = 0; filter_bank < kNumFilterBanks; ++filter_bank) {
const InterpKernel *filters =
- vp9_filter_kernels[static_cast<INTERP_FILTER>(filter_bank)];
+ av1_filter_kernels[static_cast<INTERP_FILTER>(filter_bank)];
for (int filter_x = 0; filter_x < kNumFilters; ++filter_x) {
for (int filter_y = 0; filter_y < kNumFilters; ++filter_y) {
@@ -715,7 +715,7 @@
TEST_P(ConvolveTest, MatchesReferenceAveragingSubpixelFilter) {
uint8_t *const in = input();
uint8_t *const out = output();
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
uint8_t ref8[kOutputStride * kMaxDimension];
uint16_t ref16[kOutputStride * kMaxDimension];
uint8_t *ref;
@@ -733,7 +733,7 @@
for (int y = 0; y < Height(); ++y) {
for (int x = 0; x < Width(); ++x) {
uint16_t r;
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
if (UUT_->use_highbd_ == 0 || UUT_->use_highbd_ == 8) {
r = prng.Rand8Extremes();
} else {
@@ -750,7 +750,7 @@
for (int filter_bank = 0; filter_bank < kNumFilterBanks; ++filter_bank) {
const InterpKernel *filters =
- vp9_filter_kernels[static_cast<INTERP_FILTER>(filter_bank)];
+ av1_filter_kernels[static_cast<INTERP_FILTER>(filter_bank)];
for (int filter_x = 0; filter_x < kNumFilters; ++filter_x) {
for (int filter_y = 0; filter_y < kNumFilters; ++filter_y) {
@@ -792,7 +792,7 @@
TEST_P(ConvolveTest, FilterExtremes) {
uint8_t *const in = input();
uint8_t *const out = output();
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
uint8_t ref8[kOutputStride * kMaxDimension];
uint16_t ref16[kOutputStride * kMaxDimension];
uint8_t *ref;
@@ -810,7 +810,7 @@
for (int y = 0; y < Height(); ++y) {
for (int x = 0; x < Width(); ++x) {
uint16_t r;
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
if (UUT_->use_highbd_ == 0 || UUT_->use_highbd_ == 8) {
r = prng.Rand8Extremes();
} else {
@@ -829,7 +829,7 @@
while (seed_val < 256) {
for (int y = 0; y < 8; ++y) {
for (int x = 0; x < 8; ++x) {
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
assign_val(in, y * kOutputStride + x - SUBPEL_TAPS / 2 + 1,
((seed_val >> (axis ? y : x)) & 1) * mask_);
#else
@@ -847,7 +847,7 @@
for (int filter_bank = 0; filter_bank < kNumFilterBanks; ++filter_bank) {
const InterpKernel *filters =
- vp9_filter_kernels[static_cast<INTERP_FILTER>(filter_bank)];
+ av1_filter_kernels[static_cast<INTERP_FILTER>(filter_bank)];
for (int filter_x = 0; filter_x < kNumFilters; ++filter_x) {
for (int filter_y = 0; filter_y < kNumFilters; ++filter_y) {
wrapper_filter_block2d_8_c(in, kInputStride, filters[filter_x],
@@ -889,7 +889,7 @@
TEST_P(ConvolveTest, CheckScalingFiltering) {
uint8_t *const in = input();
uint8_t *const out = output();
- const InterpKernel *const eighttap = vp9_filter_kernels[EIGHTTAP];
+ const InterpKernel *const eighttap = av1_filter_kernels[EIGHTTAP];
SetConstantInput(127);
@@ -916,13 +916,13 @@
using std::tr1::make_tuple;
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
#define WRAP(func, bd) \
void wrap_##func##_##bd( \
const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, \
ptrdiff_t dst_stride, const int16_t *filter_x, int filter_x_stride, \
const int16_t *filter_y, int filter_y_stride, int w, int h) { \
- vpx_highbd_##func(src, src_stride, dst, dst_stride, filter_x, \
+ aom_highbd_##func(src, src_stride, dst, dst_stride, filter_x, \
filter_x_stride, filter_y, filter_y_stride, w, h, bd); \
}
#if HAVE_SSE2 && ARCH_X86_64
@@ -1005,17 +1005,17 @@
#else
const ConvolveFunctions convolve8_c(
- vpx_convolve_copy_c, vpx_convolve_avg_c, vpx_convolve8_horiz_c,
- vpx_convolve8_avg_horiz_c, vpx_convolve8_vert_c, vpx_convolve8_avg_vert_c,
- vpx_convolve8_c, vpx_convolve8_avg_c, vpx_scaled_horiz_c,
- vpx_scaled_avg_horiz_c, vpx_scaled_vert_c, vpx_scaled_avg_vert_c,
- vpx_scaled_2d_c, vpx_scaled_avg_2d_c, 0);
+ aom_convolve_copy_c, aom_convolve_avg_c, aom_convolve8_horiz_c,
+ aom_convolve8_avg_horiz_c, aom_convolve8_vert_c, aom_convolve8_avg_vert_c,
+ aom_convolve8_c, aom_convolve8_avg_c, aom_scaled_horiz_c,
+ aom_scaled_avg_horiz_c, aom_scaled_vert_c, aom_scaled_avg_vert_c,
+ aom_scaled_2d_c, aom_scaled_avg_2d_c, 0);
const ConvolveParam kArrayConvolve_c[] = { ALL_SIZES(convolve8_c) };
#endif
INSTANTIATE_TEST_CASE_P(C, ConvolveTest, ::testing::ValuesIn(kArrayConvolve_c));
#if HAVE_SSE2 && ARCH_X86_64
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
const ConvolveFunctions convolve8_sse2(
wrap_convolve_copy_sse2_8, wrap_convolve_avg_sse2_8,
wrap_convolve8_horiz_sse2_8, wrap_convolve8_avg_horiz_sse2_8,
@@ -1045,25 +1045,25 @@
ALL_SIZES(convolve12_sse2) };
#else
const ConvolveFunctions convolve8_sse2(
- vpx_convolve_copy_sse2, vpx_convolve_avg_sse2, vpx_convolve8_horiz_sse2,
- vpx_convolve8_avg_horiz_sse2, vpx_convolve8_vert_sse2,
- vpx_convolve8_avg_vert_sse2, vpx_convolve8_sse2, vpx_convolve8_avg_sse2,
- vpx_scaled_horiz_c, vpx_scaled_avg_horiz_c, vpx_scaled_vert_c,
- vpx_scaled_avg_vert_c, vpx_scaled_2d_c, vpx_scaled_avg_2d_c, 0);
+ aom_convolve_copy_sse2, aom_convolve_avg_sse2, aom_convolve8_horiz_sse2,
+ aom_convolve8_avg_horiz_sse2, aom_convolve8_vert_sse2,
+ aom_convolve8_avg_vert_sse2, aom_convolve8_sse2, aom_convolve8_avg_sse2,
+ aom_scaled_horiz_c, aom_scaled_avg_horiz_c, aom_scaled_vert_c,
+ aom_scaled_avg_vert_c, aom_scaled_2d_c, aom_scaled_avg_2d_c, 0);
const ConvolveParam kArrayConvolve_sse2[] = { ALL_SIZES(convolve8_sse2) };
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#endif // CONFIG_AOM_HIGHBITDEPTH
INSTANTIATE_TEST_CASE_P(SSE2, ConvolveTest,
::testing::ValuesIn(kArrayConvolve_sse2));
#endif
#if HAVE_SSSE3
const ConvolveFunctions convolve8_ssse3(
- vpx_convolve_copy_c, vpx_convolve_avg_c, vpx_convolve8_horiz_ssse3,
- vpx_convolve8_avg_horiz_ssse3, vpx_convolve8_vert_ssse3,
- vpx_convolve8_avg_vert_ssse3, vpx_convolve8_ssse3, vpx_convolve8_avg_ssse3,
- vpx_scaled_horiz_c, vpx_scaled_avg_horiz_c, vpx_scaled_vert_c,
- vpx_scaled_avg_vert_c, vpx_scaled_2d_ssse3, vpx_scaled_avg_2d_c, 0);
+ aom_convolve_copy_c, aom_convolve_avg_c, aom_convolve8_horiz_ssse3,
+ aom_convolve8_avg_horiz_ssse3, aom_convolve8_vert_ssse3,
+ aom_convolve8_avg_vert_ssse3, aom_convolve8_ssse3, aom_convolve8_avg_ssse3,
+ aom_scaled_horiz_c, aom_scaled_avg_horiz_c, aom_scaled_vert_c,
+ aom_scaled_avg_vert_c, aom_scaled_2d_ssse3, aom_scaled_avg_2d_c, 0);
const ConvolveParam kArrayConvolve8_ssse3[] = { ALL_SIZES(convolve8_ssse3) };
INSTANTIATE_TEST_CASE_P(SSSE3, ConvolveTest,
@@ -1072,11 +1072,11 @@
#if HAVE_AVX2 && HAVE_SSSE3
const ConvolveFunctions convolve8_avx2(
- vpx_convolve_copy_c, vpx_convolve_avg_c, vpx_convolve8_horiz_avx2,
- vpx_convolve8_avg_horiz_ssse3, vpx_convolve8_vert_avx2,
- vpx_convolve8_avg_vert_ssse3, vpx_convolve8_avx2, vpx_convolve8_avg_ssse3,
- vpx_scaled_horiz_c, vpx_scaled_avg_horiz_c, vpx_scaled_vert_c,
- vpx_scaled_avg_vert_c, vpx_scaled_2d_c, vpx_scaled_avg_2d_c, 0);
+ aom_convolve_copy_c, aom_convolve_avg_c, aom_convolve8_horiz_avx2,
+ aom_convolve8_avg_horiz_ssse3, aom_convolve8_vert_avx2,
+ aom_convolve8_avg_vert_ssse3, aom_convolve8_avx2, aom_convolve8_avg_ssse3,
+ aom_scaled_horiz_c, aom_scaled_avg_horiz_c, aom_scaled_vert_c,
+ aom_scaled_avg_vert_c, aom_scaled_2d_c, aom_scaled_avg_2d_c, 0);
const ConvolveParam kArrayConvolve8_avx2[] = { ALL_SIZES(convolve8_avx2) };
INSTANTIATE_TEST_CASE_P(AVX2, ConvolveTest,
@@ -1084,21 +1084,21 @@
#endif // HAVE_AVX2 && HAVE_SSSE3
// TODO(any): Make NEON versions support 128x128 128x64 64x128 block sizes
-#if HAVE_NEON && !(CONFIG_VP10 && CONFIG_EXT_PARTITION)
+#if HAVE_NEON && !(CONFIG_AV1 && CONFIG_EXT_PARTITION)
#if HAVE_NEON_ASM
const ConvolveFunctions convolve8_neon(
- vpx_convolve_copy_neon, vpx_convolve_avg_neon, vpx_convolve8_horiz_neon,
- vpx_convolve8_avg_horiz_neon, vpx_convolve8_vert_neon,
- vpx_convolve8_avg_vert_neon, vpx_convolve8_neon, vpx_convolve8_avg_neon,
- vpx_scaled_horiz_c, vpx_scaled_avg_horiz_c, vpx_scaled_vert_c,
- vpx_scaled_avg_vert_c, vpx_scaled_2d_c, vpx_scaled_avg_2d_c, 0);
+ aom_convolve_copy_neon, aom_convolve_avg_neon, aom_convolve8_horiz_neon,
+ aom_convolve8_avg_horiz_neon, aom_convolve8_vert_neon,
+ aom_convolve8_avg_vert_neon, aom_convolve8_neon, aom_convolve8_avg_neon,
+ aom_scaled_horiz_c, aom_scaled_avg_horiz_c, aom_scaled_vert_c,
+ aom_scaled_avg_vert_c, aom_scaled_2d_c, aom_scaled_avg_2d_c, 0);
#else // HAVE_NEON
const ConvolveFunctions convolve8_neon(
- vpx_convolve_copy_neon, vpx_convolve_avg_neon, vpx_convolve8_horiz_neon,
- vpx_convolve8_avg_horiz_neon, vpx_convolve8_vert_neon,
- vpx_convolve8_avg_vert_neon, vpx_convolve8_neon, vpx_convolve8_avg_neon,
- vpx_scaled_horiz_c, vpx_scaled_avg_horiz_c, vpx_scaled_vert_c,
- vpx_scaled_avg_vert_c, vpx_scaled_2d_c, vpx_scaled_avg_2d_c, 0);
+ aom_convolve_copy_neon, aom_convolve_avg_neon, aom_convolve8_horiz_neon,
+ aom_convolve8_avg_horiz_neon, aom_convolve8_vert_neon,
+ aom_convolve8_avg_vert_neon, aom_convolve8_neon, aom_convolve8_avg_neon,
+ aom_scaled_horiz_c, aom_scaled_avg_horiz_c, aom_scaled_vert_c,
+ aom_scaled_avg_vert_c, aom_scaled_2d_c, aom_scaled_avg_2d_c, 0);
#endif // HAVE_NEON_ASM
const ConvolveParam kArrayConvolve8_neon[] = { ALL_SIZES(convolve8_neon) };
@@ -1107,13 +1107,13 @@
#endif // HAVE_NEON
// TODO(any): Make DSPR2 versions support 128x128 128x64 64x128 block sizes
-#if HAVE_DSPR2 && !(CONFIG_VP10 && CONFIG_EXT_PARTITION)
+#if HAVE_DSPR2 && !(CONFIG_AV1 && CONFIG_EXT_PARTITION)
const ConvolveFunctions convolve8_dspr2(
- vpx_convolve_copy_dspr2, vpx_convolve_avg_dspr2, vpx_convolve8_horiz_dspr2,
- vpx_convolve8_avg_horiz_dspr2, vpx_convolve8_vert_dspr2,
- vpx_convolve8_avg_vert_dspr2, vpx_convolve8_dspr2, vpx_convolve8_avg_dspr2,
- vpx_scaled_horiz_c, vpx_scaled_avg_horiz_c, vpx_scaled_vert_c,
- vpx_scaled_avg_vert_c, vpx_scaled_2d_c, vpx_scaled_avg_2d_c, 0);
+ aom_convolve_copy_dspr2, aom_convolve_avg_dspr2, aom_convolve8_horiz_dspr2,
+ aom_convolve8_avg_horiz_dspr2, aom_convolve8_vert_dspr2,
+ aom_convolve8_avg_vert_dspr2, aom_convolve8_dspr2, aom_convolve8_avg_dspr2,
+ aom_scaled_horiz_c, aom_scaled_avg_horiz_c, aom_scaled_vert_c,
+ aom_scaled_avg_vert_c, aom_scaled_2d_c, aom_scaled_avg_2d_c, 0);
const ConvolveParam kArrayConvolve8_dspr2[] = { ALL_SIZES(convolve8_dspr2) };
INSTANTIATE_TEST_CASE_P(DSPR2, ConvolveTest,
@@ -1121,13 +1121,13 @@
#endif // HAVE_DSPR2
// TODO(any): Make MSA versions support 128x128 128x64 64x128 block sizes
-#if HAVE_MSA && !(CONFIG_VP10 && CONFIG_EXT_PARTITION)
+#if HAVE_MSA && !(CONFIG_AV1 && CONFIG_EXT_PARTITION)
const ConvolveFunctions convolve8_msa(
- vpx_convolve_copy_msa, vpx_convolve_avg_msa, vpx_convolve8_horiz_msa,
- vpx_convolve8_avg_horiz_msa, vpx_convolve8_vert_msa,
- vpx_convolve8_avg_vert_msa, vpx_convolve8_msa, vpx_convolve8_avg_msa,
- vpx_scaled_horiz_c, vpx_scaled_avg_horiz_c, vpx_scaled_vert_c,
- vpx_scaled_avg_vert_c, vpx_scaled_2d_c, vpx_scaled_avg_2d_c, 0);
+ aom_convolve_copy_msa, aom_convolve_avg_msa, aom_convolve8_horiz_msa,
+ aom_convolve8_avg_horiz_msa, aom_convolve8_vert_msa,
+ aom_convolve8_avg_vert_msa, aom_convolve8_msa, aom_convolve8_avg_msa,
+ aom_scaled_horiz_c, aom_scaled_avg_horiz_c, aom_scaled_vert_c,
+ aom_scaled_avg_vert_c, aom_scaled_2d_c, aom_scaled_avg_2d_c, 0);
const ConvolveParam kArrayConvolve8_msa[] = { ALL_SIZES(convolve8_msa) };
INSTANTIATE_TEST_CASE_P(MSA, ConvolveTest,
diff --git a/test/cpu_speed_test.cc b/test/cpu_speed_test.cc
index d7ad2ef..b9d0ed7 100644
--- a/test/cpu_speed_test.cc
+++ b/test/cpu_speed_test.cc
@@ -25,7 +25,7 @@
CpuSpeedTest()
: EncoderTest(GET_PARAM(0)), encoding_mode_(GET_PARAM(1)),
set_cpu_used_(GET_PARAM(2)), min_psnr_(kMaxPSNR),
- tune_content_(VPX_CONTENT_DEFAULT) {}
+ tune_content_(AOM_CONTENT_DEFAULT) {}
virtual ~CpuSpeedTest() {}
virtual void SetUp() {
@@ -33,10 +33,10 @@
SetMode(encoding_mode_);
if (encoding_mode_ != ::libaom_test::kRealTime) {
cfg_.g_lag_in_frames = 25;
- cfg_.rc_end_usage = VPX_VBR;
+ cfg_.rc_end_usage = AOM_VBR;
} else {
cfg_.g_lag_in_frames = 0;
- cfg_.rc_end_usage = VPX_CBR;
+ cfg_.rc_end_usage = AOM_CBR;
}
}
@@ -45,18 +45,18 @@
virtual void PreEncodeFrameHook(::libaom_test::VideoSource *video,
::libaom_test::Encoder *encoder) {
if (video->frame() == 1) {
- encoder->Control(VP8E_SET_CPUUSED, set_cpu_used_);
- encoder->Control(VP9E_SET_TUNE_CONTENT, tune_content_);
+ encoder->Control(AOME_SET_CPUUSED, set_cpu_used_);
+ encoder->Control(AV1E_SET_TUNE_CONTENT, tune_content_);
if (encoding_mode_ != ::libaom_test::kRealTime) {
- encoder->Control(VP8E_SET_ENABLEAUTOALTREF, 1);
- encoder->Control(VP8E_SET_ARNR_MAXFRAMES, 7);
- encoder->Control(VP8E_SET_ARNR_STRENGTH, 5);
- encoder->Control(VP8E_SET_ARNR_TYPE, 3);
+ encoder->Control(AOME_SET_ENABLEAUTOALTREF, 1);
+ encoder->Control(AOME_SET_ARNR_MAXFRAMES, 7);
+ encoder->Control(AOME_SET_ARNR_STRENGTH, 5);
+ encoder->Control(AOME_SET_ARNR_TYPE, 3);
}
}
}
- virtual void PSNRPktHook(const vpx_codec_cx_pkt_t *pkt) {
+ virtual void PSNRPktHook(const aom_codec_cx_pkt_t *pkt) {
if (pkt->data.psnr.psnr[0] < min_psnr_) min_psnr_ = pkt->data.psnr.psnr[0];
}
@@ -86,7 +86,7 @@
::libaom_test::I420VideoSource video("hantro_odd.yuv", 208, 144, 30, 1, 0,
10);
- init_flags_ = VPX_CODEC_USE_PSNR;
+ init_flags_ = AOM_CODEC_USE_PSNR;
ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
EXPECT_GE(min_psnr_, kMaxPSNR);
@@ -101,7 +101,7 @@
cfg_.rc_max_quantizer = 0;
cfg_.rc_min_quantizer = 0;
- init_flags_ = VPX_CODEC_USE_PSNR;
+ init_flags_ = AOM_CODEC_USE_PSNR;
ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
EXPECT_GE(min_psnr_, kMaxPSNR);
@@ -115,9 +115,9 @@
cfg_.rc_target_bitrate = 2000;
cfg_.rc_max_quantizer = 63;
cfg_.rc_min_quantizer = 0;
- tune_content_ = VPX_CONTENT_SCREEN;
+ tune_content_ = AOM_CONTENT_SCREEN;
- init_flags_ = VPX_CODEC_USE_PSNR;
+ init_flags_ = AOM_CODEC_USE_PSNR;
ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
}
@@ -168,12 +168,12 @@
TEST_P(CpuSpeedTestLarge, TestEncodeHighBitrate) { TestEncodeHighBitrate(); }
TEST_P(CpuSpeedTestLarge, TestLowBitrate) { TestLowBitrate(); }
-VP10_INSTANTIATE_TEST_CASE(CpuSpeedTest,
- ::testing::Values(::libaom_test::kTwoPassGood,
- ::libaom_test::kOnePassGood),
- ::testing::Range(1, 3));
-VP10_INSTANTIATE_TEST_CASE(CpuSpeedTestLarge,
- ::testing::Values(::libaom_test::kTwoPassGood,
- ::libaom_test::kOnePassGood),
- ::testing::Range(0, 1));
+AV1_INSTANTIATE_TEST_CASE(CpuSpeedTest,
+ ::testing::Values(::libaom_test::kTwoPassGood,
+ ::libaom_test::kOnePassGood),
+ ::testing::Range(1, 3));
+AV1_INSTANTIATE_TEST_CASE(CpuSpeedTestLarge,
+ ::testing::Values(::libaom_test::kTwoPassGood,
+ ::libaom_test::kOnePassGood),
+ ::testing::Range(0, 1));
} // namespace
diff --git a/test/cx_set_ref.sh b/test/cx_set_ref.sh
index 7f1e604..9c825ab 100755
--- a/test/cx_set_ref.sh
+++ b/test/cx_set_ref.sh
@@ -18,18 +18,18 @@
# Environment check: $YUV_RAW_INPUT is required.
cx_set_ref_verify_environment() {
if [ ! -e "${YUV_RAW_INPUT}" ]; then
- echo "Libvpx test data must exist in LIBVPX_TEST_DATA_PATH."
+ echo "Libaom test data must exist in LIBVPX_TEST_DATA_PATH."
return 1
fi
}
# Runs cx_set_ref and updates the reference frame before encoding frame 90.
# $1 is the codec name.
-vpx_set_ref() {
+aom_set_ref() {
local codec="$1"
- local encoder="${LIBAOM_BIN_PATH}/vpxcx_set_ref${VPX_TEST_EXE_SUFFIX}"
+ local encoder="${LIBAOM_BIN_PATH}/aomcx_set_ref${AOM_TEST_EXE_SUFFIX}"
- local output_file="${VPX_TEST_OUTPUT_DIR}/${codec}cx_set_ref_${codec}.ivf"
+ local output_file="${AOM_TEST_OUTPUT_DIR}/${codec}cx_set_ref_${codec}.ivf"
local ref_frame_num=90
if [ ! -x "${encoder}" ]; then
@@ -38,11 +38,11 @@
fi
if [ "$codec" = "vp8" ]; then
- eval "${VPX_TEST_PREFIX}" "${encoder}" "${YUV_RAW_INPUT_WIDTH}" \
+ eval "${AOM_TEST_PREFIX}" "${encoder}" "${YUV_RAW_INPUT_WIDTH}" \
"${YUV_RAW_INPUT_HEIGHT}" "${YUV_RAW_INPUT}" "${output_file}" \
"${ref_frame_num}" ${devnull}
else
- eval "${VPX_TEST_PREFIX}" "${encoder}" "${codec}" "${YUV_RAW_INPUT_WIDTH}" \
+ eval "${AOM_TEST_PREFIX}" "${encoder}" "${codec}" "${YUV_RAW_INPUT_WIDTH}" \
"${YUV_RAW_INPUT_HEIGHT}" "${YUV_RAW_INPUT}" "${output_file}" \
"${ref_frame_num}" ${devnull}
fi
@@ -50,12 +50,12 @@
[ -e "${output_file}" ] || return 1
}
-cx_set_ref_vp10() {
- if [ "$(vp10_encode_available)" = "yes" ]; then
- vpx_set_ref vp10 || return 1
+cx_set_ref_av1() {
+ if [ "$(av1_encode_available)" = "yes" ]; then
+ aom_set_ref av1 || return 1
fi
}
-cx_set_ref_tests="cx_set_ref_vp10"
+cx_set_ref_tests="cx_set_ref_av1"
run_tests cx_set_ref_verify_environment "${cx_set_ref_tests}"
diff --git a/test/datarate_test.cc b/test/datarate_test.cc
index 6e66f21..6d59ef8 100644
--- a/test/datarate_test.cc
+++ b/test/datarate_test.cc
@@ -7,14 +7,14 @@
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
-#include "./vpx_config.h"
+#include "./aom_config.h"
#include "third_party/googletest/src/include/gtest/gtest.h"
#include "test/codec_factory.h"
#include "test/encode_test_driver.h"
#include "test/i420_video_source.h"
#include "test/util.h"
#include "test/y4m_video_source.h"
-#include "aom/vpx_codec.h"
+#include "aom/aom_codec.h"
namespace {
@@ -50,7 +50,7 @@
virtual void PreEncodeFrameHook(::libaom_test::VideoSource *video,
::libaom_test::Encoder *encoder) {
- if (video->frame() == 0) encoder->Control(VP8E_SET_CPUUSED, set_cpu_used_);
+ if (video->frame() == 0) encoder->Control(AOME_SET_CPUUSED, set_cpu_used_);
if (denoiser_offon_test_) {
ASSERT_GT(denoiser_offon_period_, 0)
@@ -61,16 +61,16 @@
}
}
- encoder->Control(VP9E_SET_NOISE_SENSITIVITY, denoiser_on_);
+ encoder->Control(AV1E_SET_NOISE_SENSITIVITY, denoiser_on_);
- const vpx_rational_t tb = video->timebase();
+ const aom_rational_t tb = video->timebase();
timebase_ = static_cast<double>(tb.num) / tb.den;
duration_ = 0;
}
- virtual void FramePktHook(const vpx_codec_cx_pkt_t *pkt) {
+ virtual void FramePktHook(const aom_codec_cx_pkt_t *pkt) {
// Time since last timestamp = duration.
- vpx_codec_pts_t duration = pkt->data.frame.pts - last_pts_;
+ aom_codec_pts_t duration = pkt->data.frame.pts - last_pts_;
if (duration > 1) {
// If first drop not set and we have a drop set it to this time.
@@ -107,7 +107,7 @@
effective_datarate_ = (bits_total_ / 1000.0) / duration_;
}
- vpx_codec_pts_t last_pts_;
+ aom_codec_pts_t last_pts_;
double timebase_;
int frame_number_; // Counter for number of non-dropped/encoded frames.
int tot_frame_number_; // Counter for total number of input frames.
@@ -116,7 +116,7 @@
double effective_datarate_;
int set_cpu_used_;
int64_t bits_in_buffer_model_;
- vpx_codec_pts_t first_drop_;
+ aom_codec_pts_t first_drop_;
int num_drops_;
int denoiser_on_;
int denoiser_offon_test_;
@@ -128,7 +128,7 @@
cfg_.rc_min_quantizer = 0;
cfg_.rc_max_quantizer = 63;
cfg_.g_error_resilient = 0;
- cfg_.rc_end_usage = VPX_VBR;
+ cfg_.rc_end_usage = AOM_VBR;
cfg_.g_lag_in_frames = 0;
::libaom_test::I420VideoSource video("hantro_collage_w352h288.yuv", 352, 288,
@@ -152,7 +152,7 @@
cfg_.rc_dropframe_thresh = 1;
cfg_.rc_min_quantizer = 0;
cfg_.rc_max_quantizer = 63;
- cfg_.rc_end_usage = VPX_CBR;
+ cfg_.rc_end_usage = AOM_CBR;
cfg_.g_lag_in_frames = 0;
::libaom_test::I420VideoSource video("hantro_collage_w352h288.yuv", 352, 288,
@@ -181,7 +181,7 @@
cfg_.rc_dropframe_thresh = 1;
cfg_.rc_min_quantizer = 0;
cfg_.rc_max_quantizer = 63;
- cfg_.rc_end_usage = VPX_CBR;
+ cfg_.rc_end_usage = AOM_CBR;
for (int i = 250; i < 900; i += 200) {
cfg_.rc_target_bitrate = i;
@@ -210,7 +210,7 @@
cfg_.rc_dropframe_thresh = 10;
cfg_.rc_min_quantizer = 0;
cfg_.rc_max_quantizer = 50;
- cfg_.rc_end_usage = VPX_CBR;
+ cfg_.rc_end_usage = AOM_CBR;
cfg_.rc_target_bitrate = 200;
cfg_.g_lag_in_frames = 0;
// TODO(marpan): Investigate datarate target failures with a smaller keyframe
@@ -221,7 +221,7 @@
30, 1, 0, 140);
const int kDropFrameThreshTestStep = 30;
- vpx_codec_pts_t last_drop = 140;
+ aom_codec_pts_t last_drop = 140;
int last_num_drops = 0;
for (int i = 10; i < 100; i += kDropFrameThreshTestStep) {
cfg_.rc_dropframe_thresh = i;
@@ -244,8 +244,8 @@
}
}
-VP10_INSTANTIATE_TEST_CASE(DatarateTestLarge,
- ::testing::Values(::libaom_test::kOnePassGood,
- ::libaom_test::kRealTime),
- ::testing::Range(2, 9));
+AV1_INSTANTIATE_TEST_CASE(DatarateTestLarge,
+ ::testing::Values(::libaom_test::kOnePassGood,
+ ::libaom_test::kRealTime),
+ ::testing::Range(2, 9));
} // namespace
diff --git a/test/dct16x16_test.cc b/test/dct16x16_test.cc
index 8233a52..70b1ba2 100644
--- a/test/dct16x16_test.cc
+++ b/test/dct16x16_test.cc
@@ -14,16 +14,16 @@
#include "third_party/googletest/src/include/gtest/gtest.h"
-#include "./vp10_rtcd.h"
-#include "./vpx_dsp_rtcd.h"
+#include "./av1_rtcd.h"
+#include "./aom_dsp_rtcd.h"
#include "test/acm_random.h"
#include "test/clear_system_state.h"
#include "test/register_state_check.h"
#include "test/util.h"
#include "av1/common/entropy.h"
#include "av1/common/scan.h"
-#include "aom/vpx_codec.h"
-#include "aom/vpx_integer.h"
+#include "aom/aom_codec.h"
+#include "aom/aom_integer.h"
#include "aom_ports/mem.h"
#include "aom_ports/msvc.h" // for round()
@@ -229,37 +229,37 @@
typedef void (*IhtFunc)(const tran_low_t *in, uint8_t *out, int stride,
int tx_type);
-typedef std::tr1::tuple<FdctFunc, IdctFunc, int, vpx_bit_depth_t> Dct16x16Param;
-typedef std::tr1::tuple<FhtFunc, IhtFunc, int, vpx_bit_depth_t> Ht16x16Param;
-typedef std::tr1::tuple<IdctFunc, IdctFunc, int, vpx_bit_depth_t>
+typedef std::tr1::tuple<FdctFunc, IdctFunc, int, aom_bit_depth_t> Dct16x16Param;
+typedef std::tr1::tuple<FhtFunc, IhtFunc, int, aom_bit_depth_t> Ht16x16Param;
+typedef std::tr1::tuple<IdctFunc, IdctFunc, int, aom_bit_depth_t>
Idct16x16Param;
void fdct16x16_ref(const int16_t *in, tran_low_t *out, int stride,
int /*tx_type*/) {
- vpx_fdct16x16_c(in, out, stride);
+ aom_fdct16x16_c(in, out, stride);
}
void idct16x16_ref(const tran_low_t *in, uint8_t *dest, int stride,
int /*tx_type*/) {
- vpx_idct16x16_256_add_c(in, dest, stride);
+ aom_idct16x16_256_add_c(in, dest, stride);
}
void fht16x16_ref(const int16_t *in, tran_low_t *out, int stride, int tx_type) {
- vp10_fht16x16_c(in, out, stride, tx_type);
+ av1_fht16x16_c(in, out, stride, tx_type);
}
void iht16x16_ref(const tran_low_t *in, uint8_t *dest, int stride,
int tx_type) {
- vp10_iht16x16_256_add_c(in, dest, stride, tx_type);
+ av1_iht16x16_256_add_c(in, dest, stride, tx_type);
}
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
void idct16x16_10(const tran_low_t *in, uint8_t *out, int stride) {
- vpx_highbd_idct16x16_256_add_c(in, out, stride, 10);
+ aom_highbd_idct16x16_256_add_c(in, out, stride, 10);
}
void idct16x16_12(const tran_low_t *in, uint8_t *out, int stride) {
- vpx_highbd_idct16x16_256_add_c(in, out, stride, 12);
+ aom_highbd_idct16x16_256_add_c(in, out, stride, 12);
}
void idct16x16_10_ref(const tran_low_t *in, uint8_t *out, int stride,
@@ -273,39 +273,39 @@
}
void iht16x16_10(const tran_low_t *in, uint8_t *out, int stride, int tx_type) {
- vp10_highbd_iht16x16_256_add_c(in, out, stride, tx_type, 10);
+ av1_highbd_iht16x16_256_add_c(in, out, stride, tx_type, 10);
}
void iht16x16_12(const tran_low_t *in, uint8_t *out, int stride, int tx_type) {
- vp10_highbd_iht16x16_256_add_c(in, out, stride, tx_type, 12);
+ av1_highbd_iht16x16_256_add_c(in, out, stride, tx_type, 12);
}
#if HAVE_SSE2
void idct16x16_10_add_10_c(const tran_low_t *in, uint8_t *out, int stride) {
- vpx_highbd_idct16x16_10_add_c(in, out, stride, 10);
+ aom_highbd_idct16x16_10_add_c(in, out, stride, 10);
}
void idct16x16_10_add_12_c(const tran_low_t *in, uint8_t *out, int stride) {
- vpx_highbd_idct16x16_10_add_c(in, out, stride, 12);
+ aom_highbd_idct16x16_10_add_c(in, out, stride, 12);
}
void idct16x16_256_add_10_sse2(const tran_low_t *in, uint8_t *out, int stride) {
- vpx_highbd_idct16x16_256_add_sse2(in, out, stride, 10);
+ aom_highbd_idct16x16_256_add_sse2(in, out, stride, 10);
}
void idct16x16_256_add_12_sse2(const tran_low_t *in, uint8_t *out, int stride) {
- vpx_highbd_idct16x16_256_add_sse2(in, out, stride, 12);
+ aom_highbd_idct16x16_256_add_sse2(in, out, stride, 12);
}
void idct16x16_10_add_10_sse2(const tran_low_t *in, uint8_t *out, int stride) {
- vpx_highbd_idct16x16_10_add_sse2(in, out, stride, 10);
+ aom_highbd_idct16x16_10_add_sse2(in, out, stride, 10);
}
void idct16x16_10_add_12_sse2(const tran_low_t *in, uint8_t *out, int stride) {
- vpx_highbd_idct16x16_10_add_sse2(in, out, stride, 12);
+ aom_highbd_idct16x16_10_add_sse2(in, out, stride, 12);
}
#endif // HAVE_SSE2
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#endif // CONFIG_AOM_HIGHBITDEPTH
class Trans16x16TestBase {
public:
@@ -326,18 +326,18 @@
DECLARE_ALIGNED(16, tran_low_t, test_temp_block[kNumCoeffs]);
DECLARE_ALIGNED(16, uint8_t, dst[kNumCoeffs]);
DECLARE_ALIGNED(16, uint8_t, src[kNumCoeffs]);
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
DECLARE_ALIGNED(16, uint16_t, dst16[kNumCoeffs]);
DECLARE_ALIGNED(16, uint16_t, src16[kNumCoeffs]);
#endif
// Initialize a test block with input range [-mask_, mask_].
for (int j = 0; j < kNumCoeffs; ++j) {
- if (bit_depth_ == VPX_BITS_8) {
+ if (bit_depth_ == AOM_BITS_8) {
src[j] = rnd.Rand8();
dst[j] = rnd.Rand8();
test_input_block[j] = src[j] - dst[j];
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
} else {
src16[j] = rnd.Rand16() & mask_;
dst16[j] = rnd.Rand16() & mask_;
@@ -348,9 +348,9 @@
ASM_REGISTER_STATE_CHECK(
RunFwdTxfm(test_input_block, test_temp_block, pitch_));
- if (bit_depth_ == VPX_BITS_8) {
+ if (bit_depth_ == AOM_BITS_8) {
ASM_REGISTER_STATE_CHECK(RunInvTxfm(test_temp_block, dst, pitch_));
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
} else {
ASM_REGISTER_STATE_CHECK(
RunInvTxfm(test_temp_block, CONVERT_TO_BYTEPTR(dst16), pitch_));
@@ -358,9 +358,9 @@
}
for (int j = 0; j < kNumCoeffs; ++j) {
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
const int32_t diff =
- bit_depth_ == VPX_BITS_8 ? dst[j] - src[j] : dst16[j] - src16[j];
+ bit_depth_ == AOM_BITS_8 ? dst[j] - src[j] : dst16[j] - src16[j];
#else
const int32_t diff = dst[j] - src[j];
#endif
@@ -437,7 +437,7 @@
DECLARE_ALIGNED(16, uint8_t, dst[kNumCoeffs]);
DECLARE_ALIGNED(16, uint8_t, ref[kNumCoeffs]);
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
DECLARE_ALIGNED(16, uint16_t, dst16[kNumCoeffs]);
DECLARE_ALIGNED(16, uint16_t, ref16[kNumCoeffs]);
#endif
@@ -457,7 +457,7 @@
// clear reconstructed pixel buffers
memset(dst, 0, kNumCoeffs * sizeof(uint8_t));
memset(ref, 0, kNumCoeffs * sizeof(uint8_t));
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
memset(dst16, 0, kNumCoeffs * sizeof(uint16_t));
memset(ref16, 0, kNumCoeffs * sizeof(uint16_t));
#endif
@@ -466,10 +466,10 @@
output_ref_block[0] = (output_ref_block[0] / dc_thred) * dc_thred;
for (int j = 1; j < kNumCoeffs; ++j)
output_ref_block[j] = (output_ref_block[j] / ac_thred) * ac_thred;
- if (bit_depth_ == VPX_BITS_8) {
+ if (bit_depth_ == AOM_BITS_8) {
inv_txfm_ref(output_ref_block, ref, pitch_, tx_type_);
ASM_REGISTER_STATE_CHECK(RunInvTxfm(output_ref_block, dst, pitch_));
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
} else {
inv_txfm_ref(output_ref_block, CONVERT_TO_BYTEPTR(ref16), pitch_,
tx_type_);
@@ -477,9 +477,9 @@
RunInvTxfm(output_ref_block, CONVERT_TO_BYTEPTR(dst16), pitch_));
#endif
}
- if (bit_depth_ == VPX_BITS_8) {
+ if (bit_depth_ == AOM_BITS_8) {
for (int j = 0; j < kNumCoeffs; ++j) EXPECT_EQ(ref[j], dst[j]);
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
} else {
for (int j = 0; j < kNumCoeffs; ++j) EXPECT_EQ(ref16[j], dst16[j]);
#endif
@@ -494,26 +494,26 @@
DECLARE_ALIGNED(16, tran_low_t, coeff[kNumCoeffs]);
DECLARE_ALIGNED(16, uint8_t, dst[kNumCoeffs]);
DECLARE_ALIGNED(16, uint8_t, src[kNumCoeffs]);
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
DECLARE_ALIGNED(16, uint16_t, dst16[kNumCoeffs]);
DECLARE_ALIGNED(16, uint16_t, src16[kNumCoeffs]);
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#endif // CONFIG_AOM_HIGHBITDEPTH
for (int i = 0; i < count_test_block; ++i) {
double out_r[kNumCoeffs];
// Initialize a test block with input range [-255, 255].
for (int j = 0; j < kNumCoeffs; ++j) {
- if (bit_depth_ == VPX_BITS_8) {
+ if (bit_depth_ == AOM_BITS_8) {
src[j] = rnd.Rand8();
dst[j] = rnd.Rand8();
in[j] = src[j] - dst[j];
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
} else {
src16[j] = rnd.Rand16() & mask_;
dst16[j] = rnd.Rand16() & mask_;
in[j] = src16[j] - dst16[j];
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#endif // CONFIG_AOM_HIGHBITDEPTH
}
}
@@ -521,22 +521,22 @@
for (int j = 0; j < kNumCoeffs; ++j)
coeff[j] = static_cast<tran_low_t>(round(out_r[j]));
- if (bit_depth_ == VPX_BITS_8) {
+ if (bit_depth_ == AOM_BITS_8) {
ASM_REGISTER_STATE_CHECK(RunInvTxfm(coeff, dst, 16));
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
} else {
ASM_REGISTER_STATE_CHECK(
RunInvTxfm(coeff, CONVERT_TO_BYTEPTR(dst16), 16));
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#endif // CONFIG_AOM_HIGHBITDEPTH
}
for (int j = 0; j < kNumCoeffs; ++j) {
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
const uint32_t diff =
- bit_depth_ == VPX_BITS_8 ? dst[j] - src[j] : dst16[j] - src16[j];
+ bit_depth_ == AOM_BITS_8 ? dst[j] - src[j] : dst16[j] - src16[j];
#else
const uint32_t diff = dst[j] - src[j];
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#endif // CONFIG_AOM_HIGHBITDEPTH
const uint32_t error = diff * diff;
EXPECT_GE(1u, error) << "Error: 16x16 IDCT has error " << error
<< " at index " << j;
@@ -548,14 +548,14 @@
ACMRandom rnd(ACMRandom::DeterministicSeed());
const int count_test_block = 10000;
const int eob = 10;
- const int16_t *scan = vp10_default_scan_orders[TX_16X16].scan;
+ const int16_t *scan = av1_default_scan_orders[TX_16X16].scan;
DECLARE_ALIGNED(16, tran_low_t, coeff[kNumCoeffs]);
DECLARE_ALIGNED(16, uint8_t, dst[kNumCoeffs]);
DECLARE_ALIGNED(16, uint8_t, ref[kNumCoeffs]);
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
DECLARE_ALIGNED(16, uint16_t, dst16[kNumCoeffs]);
DECLARE_ALIGNED(16, uint16_t, ref16[kNumCoeffs]);
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#endif // CONFIG_AOM_HIGHBITDEPTH
for (int i = 0; i < count_test_block; ++i) {
for (int j = 0; j < kNumCoeffs; ++j) {
@@ -565,34 +565,34 @@
} else {
coeff[scan[j]] = 0;
}
- if (bit_depth_ == VPX_BITS_8) {
+ if (bit_depth_ == AOM_BITS_8) {
dst[j] = 0;
ref[j] = 0;
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
} else {
dst16[j] = 0;
ref16[j] = 0;
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#endif // CONFIG_AOM_HIGHBITDEPTH
}
}
- if (bit_depth_ == VPX_BITS_8) {
+ if (bit_depth_ == AOM_BITS_8) {
ref_txfm(coeff, ref, pitch_);
ASM_REGISTER_STATE_CHECK(RunInvTxfm(coeff, dst, pitch_));
} else {
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
ref_txfm(coeff, CONVERT_TO_BYTEPTR(ref16), pitch_);
ASM_REGISTER_STATE_CHECK(
RunInvTxfm(coeff, CONVERT_TO_BYTEPTR(dst16), pitch_));
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#endif // CONFIG_AOM_HIGHBITDEPTH
}
for (int j = 0; j < kNumCoeffs; ++j) {
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
const uint32_t diff =
- bit_depth_ == VPX_BITS_8 ? dst[j] - ref[j] : dst16[j] - ref16[j];
+ bit_depth_ == AOM_BITS_8 ? dst[j] - ref[j] : dst16[j] - ref16[j];
#else
const uint32_t diff = dst[j] - ref[j];
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#endif // CONFIG_AOM_HIGHBITDEPTH
const uint32_t error = diff * diff;
EXPECT_EQ(0u, error) << "Error: 16x16 IDCT Comparison has error "
<< error << " at index " << j;
@@ -602,7 +602,7 @@
int pitch_;
int tx_type_;
- vpx_bit_depth_t bit_depth_;
+ aom_bit_depth_t bit_depth_;
int mask_;
FhtFunc fwd_txfm_ref;
IhtFunc inv_txfm_ref;
@@ -622,10 +622,10 @@
fwd_txfm_ref = fdct16x16_ref;
inv_txfm_ref = idct16x16_ref;
mask_ = (1 << bit_depth_) - 1;
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
switch (bit_depth_) {
- case VPX_BITS_10: inv_txfm_ref = idct16x16_10_ref; break;
- case VPX_BITS_12: inv_txfm_ref = idct16x16_12_ref; break;
+ case AOM_BITS_10: inv_txfm_ref = idct16x16_10_ref; break;
+ case AOM_BITS_12: inv_txfm_ref = idct16x16_12_ref; break;
default: inv_txfm_ref = idct16x16_ref; break;
}
#else
@@ -674,10 +674,10 @@
fwd_txfm_ref = fht16x16_ref;
inv_txfm_ref = iht16x16_ref;
mask_ = (1 << bit_depth_) - 1;
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
switch (bit_depth_) {
- case VPX_BITS_10: inv_txfm_ref = iht16x16_10; break;
- case VPX_BITS_12: inv_txfm_ref = iht16x16_12; break;
+ case AOM_BITS_10: inv_txfm_ref = iht16x16_10; break;
+ case AOM_BITS_12: inv_txfm_ref = iht16x16_12; break;
default: inv_txfm_ref = iht16x16_ref; break;
}
#else
@@ -741,7 +741,7 @@
}
class PartialTrans16x16Test : public ::testing::TestWithParam<
- std::tr1::tuple<FdctFunc, vpx_bit_depth_t> > {
+ std::tr1::tuple<FdctFunc, aom_bit_depth_t> > {
public:
virtual ~PartialTrans16x16Test() {}
virtual void SetUp() {
@@ -752,12 +752,12 @@
virtual void TearDown() { libaom_test::ClearSystemState(); }
protected:
- vpx_bit_depth_t bit_depth_;
+ aom_bit_depth_t bit_depth_;
FdctFunc fwd_txfm_;
};
TEST_P(PartialTrans16x16Test, Extremes) {
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
const int16_t maxval =
static_cast<int16_t>(clip_pixel_highbd(1 << 30, bit_depth_));
#else
@@ -779,7 +779,7 @@
}
TEST_P(PartialTrans16x16Test, Random) {
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
const int16_t maxval =
static_cast<int16_t>(clip_pixel_highbd(1 << 30, bit_depth_));
#else
@@ -802,139 +802,135 @@
using std::tr1::make_tuple;
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
INSTANTIATE_TEST_CASE_P(
C, Trans16x16DCT,
::testing::Values(
- make_tuple(&vpx_highbd_fdct16x16_c, &idct16x16_10, 0, VPX_BITS_10),
- make_tuple(&vpx_highbd_fdct16x16_c, &idct16x16_12, 0, VPX_BITS_12),
- make_tuple(&vpx_fdct16x16_c, &vpx_idct16x16_256_add_c, 0, VPX_BITS_8)));
+ make_tuple(&aom_highbd_fdct16x16_c, &idct16x16_10, 0, AOM_BITS_10),
+ make_tuple(&aom_highbd_fdct16x16_c, &idct16x16_12, 0, AOM_BITS_12),
+ make_tuple(&aom_fdct16x16_c, &aom_idct16x16_256_add_c, 0, AOM_BITS_8)));
#else
INSTANTIATE_TEST_CASE_P(C, Trans16x16DCT,
- ::testing::Values(make_tuple(&vpx_fdct16x16_c,
- &vpx_idct16x16_256_add_c,
- 0, VPX_BITS_8)));
-#endif // CONFIG_VP9_HIGHBITDEPTH
+ ::testing::Values(make_tuple(&aom_fdct16x16_c,
+ &aom_idct16x16_256_add_c,
+ 0, AOM_BITS_8)));
+#endif // CONFIG_AOM_HIGHBITDEPTH
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
INSTANTIATE_TEST_CASE_P(
C, Trans16x16HT,
::testing::Values(
- make_tuple(&vp10_highbd_fht16x16_c, &iht16x16_10, 0, VPX_BITS_10),
- make_tuple(&vp10_highbd_fht16x16_c, &iht16x16_10, 1, VPX_BITS_10),
- make_tuple(&vp10_highbd_fht16x16_c, &iht16x16_10, 2, VPX_BITS_10),
- make_tuple(&vp10_highbd_fht16x16_c, &iht16x16_10, 3, VPX_BITS_10),
- make_tuple(&vp10_highbd_fht16x16_c, &iht16x16_12, 0, VPX_BITS_12),
- make_tuple(&vp10_highbd_fht16x16_c, &iht16x16_12, 1, VPX_BITS_12),
- make_tuple(&vp10_highbd_fht16x16_c, &iht16x16_12, 2, VPX_BITS_12),
- make_tuple(&vp10_highbd_fht16x16_c, &iht16x16_12, 3, VPX_BITS_12),
- make_tuple(&vp10_fht16x16_c, &vp10_iht16x16_256_add_c, 0, VPX_BITS_8),
- make_tuple(&vp10_fht16x16_c, &vp10_iht16x16_256_add_c, 1, VPX_BITS_8),
- make_tuple(&vp10_fht16x16_c, &vp10_iht16x16_256_add_c, 2, VPX_BITS_8),
- make_tuple(&vp10_fht16x16_c, &vp10_iht16x16_256_add_c, 3, VPX_BITS_8)));
+ make_tuple(&av1_highbd_fht16x16_c, &iht16x16_10, 0, AOM_BITS_10),
+ make_tuple(&av1_highbd_fht16x16_c, &iht16x16_10, 1, AOM_BITS_10),
+ make_tuple(&av1_highbd_fht16x16_c, &iht16x16_10, 2, AOM_BITS_10),
+ make_tuple(&av1_highbd_fht16x16_c, &iht16x16_10, 3, AOM_BITS_10),
+ make_tuple(&av1_highbd_fht16x16_c, &iht16x16_12, 0, AOM_BITS_12),
+ make_tuple(&av1_highbd_fht16x16_c, &iht16x16_12, 1, AOM_BITS_12),
+ make_tuple(&av1_highbd_fht16x16_c, &iht16x16_12, 2, AOM_BITS_12),
+ make_tuple(&av1_highbd_fht16x16_c, &iht16x16_12, 3, AOM_BITS_12),
+ make_tuple(&av1_fht16x16_c, &av1_iht16x16_256_add_c, 0, AOM_BITS_8),
+ make_tuple(&av1_fht16x16_c, &av1_iht16x16_256_add_c, 1, AOM_BITS_8),
+ make_tuple(&av1_fht16x16_c, &av1_iht16x16_256_add_c, 2, AOM_BITS_8),
+ make_tuple(&av1_fht16x16_c, &av1_iht16x16_256_add_c, 3, AOM_BITS_8)));
INSTANTIATE_TEST_CASE_P(
C, PartialTrans16x16Test,
- ::testing::Values(make_tuple(&vpx_highbd_fdct16x16_1_c, VPX_BITS_8),
- make_tuple(&vpx_highbd_fdct16x16_1_c, VPX_BITS_10),
- make_tuple(&vpx_highbd_fdct16x16_1_c, VPX_BITS_12)));
+ ::testing::Values(make_tuple(&aom_highbd_fdct16x16_1_c, AOM_BITS_8),
+ make_tuple(&aom_highbd_fdct16x16_1_c, AOM_BITS_10),
+ make_tuple(&aom_highbd_fdct16x16_1_c, AOM_BITS_12)));
#else
INSTANTIATE_TEST_CASE_P(
C, Trans16x16HT,
::testing::Values(
- make_tuple(&vp10_fht16x16_c, &vp10_iht16x16_256_add_c, 0, VPX_BITS_8),
- make_tuple(&vp10_fht16x16_c, &vp10_iht16x16_256_add_c, 1, VPX_BITS_8),
- make_tuple(&vp10_fht16x16_c, &vp10_iht16x16_256_add_c, 2, VPX_BITS_8),
- make_tuple(&vp10_fht16x16_c, &vp10_iht16x16_256_add_c, 3, VPX_BITS_8)));
+ make_tuple(&av1_fht16x16_c, &av1_iht16x16_256_add_c, 0, AOM_BITS_8),
+ make_tuple(&av1_fht16x16_c, &av1_iht16x16_256_add_c, 1, AOM_BITS_8),
+ make_tuple(&av1_fht16x16_c, &av1_iht16x16_256_add_c, 2, AOM_BITS_8),
+ make_tuple(&av1_fht16x16_c, &av1_iht16x16_256_add_c, 3, AOM_BITS_8)));
INSTANTIATE_TEST_CASE_P(C, PartialTrans16x16Test,
- ::testing::Values(make_tuple(&vpx_fdct16x16_1_c,
- VPX_BITS_8)));
-#endif // CONFIG_VP9_HIGHBITDEPTH
+ ::testing::Values(make_tuple(&aom_fdct16x16_1_c,
+ AOM_BITS_8)));
+#endif // CONFIG_AOM_HIGHBITDEPTH
-#if HAVE_NEON_ASM && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
+#if HAVE_NEON_ASM && !CONFIG_AOM_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
INSTANTIATE_TEST_CASE_P(
NEON, Trans16x16DCT,
- ::testing::Values(make_tuple(&vpx_fdct16x16_c, &vpx_idct16x16_256_add_neon,
- 0, VPX_BITS_8)));
+ ::testing::Values(make_tuple(&aom_fdct16x16_c, &aom_idct16x16_256_add_neon,
+ 0, AOM_BITS_8)));
#endif
-#if HAVE_SSE2 && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
+#if HAVE_SSE2 && !CONFIG_AOM_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
INSTANTIATE_TEST_CASE_P(
SSE2, Trans16x16DCT,
- ::testing::Values(make_tuple(&vpx_fdct16x16_sse2,
- &vpx_idct16x16_256_add_sse2, 0, VPX_BITS_8)));
+ ::testing::Values(make_tuple(&aom_fdct16x16_sse2,
+ &aom_idct16x16_256_add_sse2, 0, AOM_BITS_8)));
INSTANTIATE_TEST_CASE_P(
SSE2, Trans16x16HT,
- ::testing::Values(make_tuple(&vp10_fht16x16_sse2,
- &vp10_iht16x16_256_add_sse2, 0, VPX_BITS_8),
- make_tuple(&vp10_fht16x16_sse2,
- &vp10_iht16x16_256_add_sse2, 1, VPX_BITS_8),
- make_tuple(&vp10_fht16x16_sse2,
- &vp10_iht16x16_256_add_sse2, 2, VPX_BITS_8),
- make_tuple(&vp10_fht16x16_sse2,
- &vp10_iht16x16_256_add_sse2, 3, VPX_BITS_8)));
+ ::testing::Values(make_tuple(&av1_fht16x16_sse2, &av1_iht16x16_256_add_sse2,
+ 0, AOM_BITS_8),
+ make_tuple(&av1_fht16x16_sse2, &av1_iht16x16_256_add_sse2,
+ 1, AOM_BITS_8),
+ make_tuple(&av1_fht16x16_sse2, &av1_iht16x16_256_add_sse2,
+ 2, AOM_BITS_8),
+ make_tuple(&av1_fht16x16_sse2, &av1_iht16x16_256_add_sse2,
+ 3, AOM_BITS_8)));
INSTANTIATE_TEST_CASE_P(SSE2, PartialTrans16x16Test,
- ::testing::Values(make_tuple(&vpx_fdct16x16_1_sse2,
- VPX_BITS_8)));
-#endif // HAVE_SSE2 && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
+ ::testing::Values(make_tuple(&aom_fdct16x16_1_sse2,
+ AOM_BITS_8)));
+#endif // HAVE_SSE2 && !CONFIG_AOM_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
-#if HAVE_SSE2 && CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
+#if HAVE_SSE2 && CONFIG_AOM_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
INSTANTIATE_TEST_CASE_P(
SSE2, Trans16x16DCT,
::testing::Values(
- make_tuple(&vpx_highbd_fdct16x16_sse2, &idct16x16_10, 0, VPX_BITS_10),
- make_tuple(&vpx_highbd_fdct16x16_c, &idct16x16_256_add_10_sse2, 0,
- VPX_BITS_10),
- make_tuple(&vpx_highbd_fdct16x16_sse2, &idct16x16_12, 0, VPX_BITS_12),
- make_tuple(&vpx_highbd_fdct16x16_c, &idct16x16_256_add_12_sse2, 0,
- VPX_BITS_12),
- make_tuple(&vpx_fdct16x16_sse2, &vpx_idct16x16_256_add_c, 0,
- VPX_BITS_8)));
+ make_tuple(&aom_highbd_fdct16x16_sse2, &idct16x16_10, 0, AOM_BITS_10),
+ make_tuple(&aom_highbd_fdct16x16_c, &idct16x16_256_add_10_sse2, 0,
+ AOM_BITS_10),
+ make_tuple(&aom_highbd_fdct16x16_sse2, &idct16x16_12, 0, AOM_BITS_12),
+ make_tuple(&aom_highbd_fdct16x16_c, &idct16x16_256_add_12_sse2, 0,
+ AOM_BITS_12),
+ make_tuple(&aom_fdct16x16_sse2, &aom_idct16x16_256_add_c, 0,
+ AOM_BITS_8)));
INSTANTIATE_TEST_CASE_P(
SSE2, Trans16x16HT,
- ::testing::Values(make_tuple(&vp10_fht16x16_sse2, &vp10_iht16x16_256_add_c,
- 0, VPX_BITS_8),
- make_tuple(&vp10_fht16x16_sse2, &vp10_iht16x16_256_add_c,
- 1, VPX_BITS_8),
- make_tuple(&vp10_fht16x16_sse2, &vp10_iht16x16_256_add_c,
- 2, VPX_BITS_8),
- make_tuple(&vp10_fht16x16_sse2, &vp10_iht16x16_256_add_c,
- 3, VPX_BITS_8)));
+ ::testing::Values(
+ make_tuple(&av1_fht16x16_sse2, &av1_iht16x16_256_add_c, 0, AOM_BITS_8),
+ make_tuple(&av1_fht16x16_sse2, &av1_iht16x16_256_add_c, 1, AOM_BITS_8),
+ make_tuple(&av1_fht16x16_sse2, &av1_iht16x16_256_add_c, 2, AOM_BITS_8),
+ make_tuple(&av1_fht16x16_sse2, &av1_iht16x16_256_add_c, 3,
+ AOM_BITS_8)));
// Optimizations take effect at a threshold of 3155, so we use a value close to
// that to test both branches.
INSTANTIATE_TEST_CASE_P(
SSE2, InvTrans16x16DCT,
::testing::Values(make_tuple(&idct16x16_10_add_10_c,
- &idct16x16_10_add_10_sse2, 3167, VPX_BITS_10),
+ &idct16x16_10_add_10_sse2, 3167, AOM_BITS_10),
make_tuple(&idct16x16_10, &idct16x16_256_add_10_sse2,
- 3167, VPX_BITS_10),
+ 3167, AOM_BITS_10),
make_tuple(&idct16x16_10_add_12_c,
- &idct16x16_10_add_12_sse2, 3167, VPX_BITS_12),
+ &idct16x16_10_add_12_sse2, 3167, AOM_BITS_12),
make_tuple(&idct16x16_12, &idct16x16_256_add_12_sse2,
- 3167, VPX_BITS_12)));
+ 3167, AOM_BITS_12)));
INSTANTIATE_TEST_CASE_P(SSE2, PartialTrans16x16Test,
- ::testing::Values(make_tuple(&vpx_fdct16x16_1_sse2,
- VPX_BITS_8)));
-#endif // HAVE_SSE2 && CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
+ ::testing::Values(make_tuple(&aom_fdct16x16_1_sse2,
+ AOM_BITS_8)));
+#endif // HAVE_SSE2 && CONFIG_AOM_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
-#if HAVE_MSA && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
+#if HAVE_MSA && !CONFIG_AOM_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
INSTANTIATE_TEST_CASE_P(MSA, Trans16x16DCT,
- ::testing::Values(make_tuple(&vpx_fdct16x16_msa,
- &vpx_idct16x16_256_add_msa,
- 0, VPX_BITS_8)));
+ ::testing::Values(make_tuple(&aom_fdct16x16_msa,
+ &aom_idct16x16_256_add_msa,
+ 0, AOM_BITS_8)));
#if !CONFIG_EXT_TX
INSTANTIATE_TEST_CASE_P(
MSA, Trans16x16HT,
- ::testing::Values(make_tuple(&vp10_fht16x16_msa, &vp10_iht16x16_256_add_msa,
- 0, VPX_BITS_8),
- make_tuple(&vp10_fht16x16_msa, &vp10_iht16x16_256_add_msa,
- 1, VPX_BITS_8),
- make_tuple(&vp10_fht16x16_msa, &vp10_iht16x16_256_add_msa,
- 2, VPX_BITS_8),
- make_tuple(&vp10_fht16x16_msa, &vp10_iht16x16_256_add_msa,
- 3, VPX_BITS_8)));
+ ::testing::Values(
+ make_tuple(&av1_fht16x16_msa, &av1_iht16x16_256_add_msa, 0, AOM_BITS_8),
+ make_tuple(&av1_fht16x16_msa, &av1_iht16x16_256_add_msa, 1, AOM_BITS_8),
+ make_tuple(&av1_fht16x16_msa, &av1_iht16x16_256_add_msa, 2, AOM_BITS_8),
+ make_tuple(&av1_fht16x16_msa, &av1_iht16x16_256_add_msa, 3,
+ AOM_BITS_8)));
#endif // !CONFIG_EXT_TX
INSTANTIATE_TEST_CASE_P(MSA, PartialTrans16x16Test,
- ::testing::Values(make_tuple(&vpx_fdct16x16_1_msa,
- VPX_BITS_8)));
-#endif // HAVE_MSA && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
+ ::testing::Values(make_tuple(&aom_fdct16x16_1_msa,
+ AOM_BITS_8)));
+#endif // HAVE_MSA && !CONFIG_AOM_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
} // namespace
diff --git a/test/dct32x32_test.cc b/test/dct32x32_test.cc
index 629f878..c5faa9e 100644
--- a/test/dct32x32_test.cc
+++ b/test/dct32x32_test.cc
@@ -14,16 +14,16 @@
#include "third_party/googletest/src/include/gtest/gtest.h"
-#include "./vp10_rtcd.h"
-#include "./vpx_config.h"
-#include "./vpx_dsp_rtcd.h"
+#include "./av1_rtcd.h"
+#include "./aom_config.h"
+#include "./aom_dsp_rtcd.h"
#include "test/acm_random.h"
#include "test/clear_system_state.h"
#include "test/register_state_check.h"
#include "test/util.h"
#include "av1/common/entropy.h"
-#include "aom/vpx_codec.h"
-#include "aom/vpx_integer.h"
+#include "aom/aom_codec.h"
+#include "aom/aom_integer.h"
#include "aom_ports/mem.h"
#include "aom_ports/msvc.h" // for round()
@@ -65,18 +65,18 @@
typedef void (*FwdTxfmFunc)(const int16_t *in, tran_low_t *out, int stride);
typedef void (*InvTxfmFunc)(const tran_low_t *in, uint8_t *out, int stride);
-typedef std::tr1::tuple<FwdTxfmFunc, InvTxfmFunc, int, vpx_bit_depth_t>
+typedef std::tr1::tuple<FwdTxfmFunc, InvTxfmFunc, int, aom_bit_depth_t>
Trans32x32Param;
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
void idct32x32_10(const tran_low_t *in, uint8_t *out, int stride) {
- vpx_highbd_idct32x32_1024_add_c(in, out, stride, 10);
+ aom_highbd_idct32x32_1024_add_c(in, out, stride, 10);
}
void idct32x32_12(const tran_low_t *in, uint8_t *out, int stride) {
- vpx_highbd_idct32x32_1024_add_c(in, out, stride, 12);
+ aom_highbd_idct32x32_1024_add_c(in, out, stride, 12);
}
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#endif // CONFIG_AOM_HIGHBITDEPTH
class Trans32x32Test : public ::testing::TestWithParam<Trans32x32Param> {
public:
@@ -94,7 +94,7 @@
protected:
int version_;
- vpx_bit_depth_t bit_depth_;
+ aom_bit_depth_t bit_depth_;
int mask_;
FwdTxfmFunc fwd_txfm_;
InvTxfmFunc inv_txfm_;
@@ -109,7 +109,7 @@
DECLARE_ALIGNED(16, tran_low_t, test_temp_block[kNumCoeffs]);
DECLARE_ALIGNED(16, uint8_t, dst[kNumCoeffs]);
DECLARE_ALIGNED(16, uint8_t, src[kNumCoeffs]);
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
DECLARE_ALIGNED(16, uint16_t, dst16[kNumCoeffs]);
DECLARE_ALIGNED(16, uint16_t, src16[kNumCoeffs]);
#endif
@@ -117,11 +117,11 @@
for (int i = 0; i < count_test_block; ++i) {
// Initialize a test block with input range [-mask_, mask_].
for (int j = 0; j < kNumCoeffs; ++j) {
- if (bit_depth_ == VPX_BITS_8) {
+ if (bit_depth_ == AOM_BITS_8) {
src[j] = rnd.Rand8();
dst[j] = rnd.Rand8();
test_input_block[j] = src[j] - dst[j];
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
} else {
src16[j] = rnd.Rand16() & mask_;
dst16[j] = rnd.Rand16() & mask_;
@@ -131,9 +131,9 @@
}
ASM_REGISTER_STATE_CHECK(fwd_txfm_(test_input_block, test_temp_block, 32));
- if (bit_depth_ == VPX_BITS_8) {
+ if (bit_depth_ == AOM_BITS_8) {
ASM_REGISTER_STATE_CHECK(inv_txfm_(test_temp_block, dst, 32));
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
} else {
ASM_REGISTER_STATE_CHECK(
inv_txfm_(test_temp_block, CONVERT_TO_BYTEPTR(dst16), 32));
@@ -141,9 +141,9 @@
}
for (int j = 0; j < kNumCoeffs; ++j) {
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
const int32_t diff =
- bit_depth_ == VPX_BITS_8 ? dst[j] - src[j] : dst16[j] - src16[j];
+ bit_depth_ == AOM_BITS_8 ? dst[j] - src[j] : dst16[j] - src16[j];
#else
const int32_t diff = dst[j] - src[j];
#endif
@@ -178,7 +178,7 @@
input_block[j] = (rnd.Rand16() & mask_) - (rnd.Rand16() & mask_);
const int stride = 32;
- vpx_fdct32x32_c(input_block, output_ref_block, stride);
+ aom_fdct32x32_c(input_block, output_ref_block, stride);
ASM_REGISTER_STATE_CHECK(fwd_txfm_(input_block, output_block, stride));
if (version_ == 0) {
@@ -213,7 +213,7 @@
}
const int stride = 32;
- vpx_fdct32x32_c(input_extreme_block, output_ref_block, stride);
+ aom_fdct32x32_c(input_extreme_block, output_ref_block, stride);
ASM_REGISTER_STATE_CHECK(
fwd_txfm_(input_extreme_block, output_block, stride));
@@ -242,7 +242,7 @@
DECLARE_ALIGNED(16, tran_low_t, coeff[kNumCoeffs]);
DECLARE_ALIGNED(16, uint8_t, dst[kNumCoeffs]);
DECLARE_ALIGNED(16, uint8_t, src[kNumCoeffs]);
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
DECLARE_ALIGNED(16, uint16_t, dst16[kNumCoeffs]);
DECLARE_ALIGNED(16, uint16_t, src16[kNumCoeffs]);
#endif
@@ -252,11 +252,11 @@
// Initialize a test block with input range [-255, 255]
for (int j = 0; j < kNumCoeffs; ++j) {
- if (bit_depth_ == VPX_BITS_8) {
+ if (bit_depth_ == AOM_BITS_8) {
src[j] = rnd.Rand8();
dst[j] = rnd.Rand8();
in[j] = src[j] - dst[j];
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
} else {
src16[j] = rnd.Rand16() & mask_;
dst16[j] = rnd.Rand16() & mask_;
@@ -268,17 +268,17 @@
reference_32x32_dct_2d(in, out_r);
for (int j = 0; j < kNumCoeffs; ++j)
coeff[j] = static_cast<tran_low_t>(round(out_r[j]));
- if (bit_depth_ == VPX_BITS_8) {
+ if (bit_depth_ == AOM_BITS_8) {
ASM_REGISTER_STATE_CHECK(inv_txfm_(coeff, dst, 32));
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
} else {
ASM_REGISTER_STATE_CHECK(inv_txfm_(coeff, CONVERT_TO_BYTEPTR(dst16), 32));
#endif
}
for (int j = 0; j < kNumCoeffs; ++j) {
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
const int diff =
- bit_depth_ == VPX_BITS_8 ? dst[j] - src[j] : dst16[j] - src16[j];
+ bit_depth_ == AOM_BITS_8 ? dst[j] - src[j] : dst16[j] - src16[j];
#else
const int diff = dst[j] - src[j];
#endif
@@ -291,7 +291,7 @@
class PartialTrans32x32Test
: public ::testing::TestWithParam<
- std::tr1::tuple<FwdTxfmFunc, vpx_bit_depth_t> > {
+ std::tr1::tuple<FwdTxfmFunc, aom_bit_depth_t> > {
public:
virtual ~PartialTrans32x32Test() {}
virtual void SetUp() {
@@ -302,12 +302,12 @@
virtual void TearDown() { libaom_test::ClearSystemState(); }
protected:
- vpx_bit_depth_t bit_depth_;
+ aom_bit_depth_t bit_depth_;
FwdTxfmFunc fwd_txfm_;
};
TEST_P(PartialTrans32x32Test, Extremes) {
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
const int16_t maxval =
static_cast<int16_t>(clip_pixel_highbd(1 << 30, bit_depth_));
#else
@@ -329,7 +329,7 @@
}
TEST_P(PartialTrans32x32Test, Random) {
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
const int16_t maxval =
static_cast<int16_t>(clip_pixel_highbd(1 << 30, bit_depth_));
#else
@@ -352,92 +352,92 @@
using std::tr1::make_tuple;
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
INSTANTIATE_TEST_CASE_P(
C, Trans32x32Test,
::testing::Values(
- make_tuple(&vpx_highbd_fdct32x32_c, &idct32x32_10, 0, VPX_BITS_10),
- make_tuple(&vpx_highbd_fdct32x32_rd_c, &idct32x32_10, 1, VPX_BITS_10),
- make_tuple(&vpx_highbd_fdct32x32_c, &idct32x32_12, 0, VPX_BITS_12),
- make_tuple(&vpx_highbd_fdct32x32_rd_c, &idct32x32_12, 1, VPX_BITS_12),
- make_tuple(&vpx_fdct32x32_c, &vpx_idct32x32_1024_add_c, 0, VPX_BITS_8),
- make_tuple(&vpx_fdct32x32_rd_c, &vpx_idct32x32_1024_add_c, 1,
- VPX_BITS_8)));
+ make_tuple(&aom_highbd_fdct32x32_c, &idct32x32_10, 0, AOM_BITS_10),
+ make_tuple(&aom_highbd_fdct32x32_rd_c, &idct32x32_10, 1, AOM_BITS_10),
+ make_tuple(&aom_highbd_fdct32x32_c, &idct32x32_12, 0, AOM_BITS_12),
+ make_tuple(&aom_highbd_fdct32x32_rd_c, &idct32x32_12, 1, AOM_BITS_12),
+ make_tuple(&aom_fdct32x32_c, &aom_idct32x32_1024_add_c, 0, AOM_BITS_8),
+ make_tuple(&aom_fdct32x32_rd_c, &aom_idct32x32_1024_add_c, 1,
+ AOM_BITS_8)));
INSTANTIATE_TEST_CASE_P(
C, PartialTrans32x32Test,
- ::testing::Values(make_tuple(&vpx_highbd_fdct32x32_1_c, VPX_BITS_8),
- make_tuple(&vpx_highbd_fdct32x32_1_c, VPX_BITS_10),
- make_tuple(&vpx_highbd_fdct32x32_1_c, VPX_BITS_12)));
+ ::testing::Values(make_tuple(&aom_highbd_fdct32x32_1_c, AOM_BITS_8),
+ make_tuple(&aom_highbd_fdct32x32_1_c, AOM_BITS_10),
+ make_tuple(&aom_highbd_fdct32x32_1_c, AOM_BITS_12)));
#else
INSTANTIATE_TEST_CASE_P(
C, Trans32x32Test,
- ::testing::Values(make_tuple(&vpx_fdct32x32_c, &vpx_idct32x32_1024_add_c, 0,
- VPX_BITS_8),
- make_tuple(&vpx_fdct32x32_rd_c, &vpx_idct32x32_1024_add_c,
- 1, VPX_BITS_8)));
+ ::testing::Values(make_tuple(&aom_fdct32x32_c, &aom_idct32x32_1024_add_c, 0,
+ AOM_BITS_8),
+ make_tuple(&aom_fdct32x32_rd_c, &aom_idct32x32_1024_add_c,
+ 1, AOM_BITS_8)));
INSTANTIATE_TEST_CASE_P(C, PartialTrans32x32Test,
- ::testing::Values(make_tuple(&vpx_fdct32x32_1_c,
- VPX_BITS_8)));
-#endif // CONFIG_VP9_HIGHBITDEPTH
+ ::testing::Values(make_tuple(&aom_fdct32x32_1_c,
+ AOM_BITS_8)));
+#endif // CONFIG_AOM_HIGHBITDEPTH
-#if HAVE_NEON && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
+#if HAVE_NEON && !CONFIG_AOM_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
INSTANTIATE_TEST_CASE_P(
NEON, Trans32x32Test,
- ::testing::Values(make_tuple(&vpx_fdct32x32_c, &vpx_idct32x32_1024_add_neon,
- 0, VPX_BITS_8),
- make_tuple(&vpx_fdct32x32_rd_c,
- &vpx_idct32x32_1024_add_neon, 1, VPX_BITS_8)));
-#endif // HAVE_NEON && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
+ ::testing::Values(make_tuple(&aom_fdct32x32_c, &aom_idct32x32_1024_add_neon,
+ 0, AOM_BITS_8),
+ make_tuple(&aom_fdct32x32_rd_c,
+ &aom_idct32x32_1024_add_neon, 1, AOM_BITS_8)));
+#endif // HAVE_NEON && !CONFIG_AOM_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
-#if HAVE_SSE2 && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
+#if HAVE_SSE2 && !CONFIG_AOM_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
INSTANTIATE_TEST_CASE_P(
SSE2, Trans32x32Test,
- ::testing::Values(make_tuple(&vpx_fdct32x32_sse2,
- &vpx_idct32x32_1024_add_sse2, 0, VPX_BITS_8),
- make_tuple(&vpx_fdct32x32_rd_sse2,
- &vpx_idct32x32_1024_add_sse2, 1, VPX_BITS_8)));
+ ::testing::Values(make_tuple(&aom_fdct32x32_sse2,
+ &aom_idct32x32_1024_add_sse2, 0, AOM_BITS_8),
+ make_tuple(&aom_fdct32x32_rd_sse2,
+ &aom_idct32x32_1024_add_sse2, 1, AOM_BITS_8)));
INSTANTIATE_TEST_CASE_P(SSE2, PartialTrans32x32Test,
- ::testing::Values(make_tuple(&vpx_fdct32x32_1_sse2,
- VPX_BITS_8)));
-#endif // HAVE_SSE2 && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
+ ::testing::Values(make_tuple(&aom_fdct32x32_1_sse2,
+ AOM_BITS_8)));
+#endif // HAVE_SSE2 && !CONFIG_AOM_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
-#if HAVE_SSE2 && CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
+#if HAVE_SSE2 && CONFIG_AOM_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
INSTANTIATE_TEST_CASE_P(
SSE2, Trans32x32Test,
::testing::Values(
- make_tuple(&vpx_highbd_fdct32x32_sse2, &idct32x32_10, 0, VPX_BITS_10),
- make_tuple(&vpx_highbd_fdct32x32_rd_sse2, &idct32x32_10, 1,
- VPX_BITS_10),
- make_tuple(&vpx_highbd_fdct32x32_sse2, &idct32x32_12, 0, VPX_BITS_12),
- make_tuple(&vpx_highbd_fdct32x32_rd_sse2, &idct32x32_12, 1,
- VPX_BITS_12),
- make_tuple(&vpx_fdct32x32_sse2, &vpx_idct32x32_1024_add_c, 0,
- VPX_BITS_8),
- make_tuple(&vpx_fdct32x32_rd_sse2, &vpx_idct32x32_1024_add_c, 1,
- VPX_BITS_8)));
+ make_tuple(&aom_highbd_fdct32x32_sse2, &idct32x32_10, 0, AOM_BITS_10),
+ make_tuple(&aom_highbd_fdct32x32_rd_sse2, &idct32x32_10, 1,
+ AOM_BITS_10),
+ make_tuple(&aom_highbd_fdct32x32_sse2, &idct32x32_12, 0, AOM_BITS_12),
+ make_tuple(&aom_highbd_fdct32x32_rd_sse2, &idct32x32_12, 1,
+ AOM_BITS_12),
+ make_tuple(&aom_fdct32x32_sse2, &aom_idct32x32_1024_add_c, 0,
+ AOM_BITS_8),
+ make_tuple(&aom_fdct32x32_rd_sse2, &aom_idct32x32_1024_add_c, 1,
+ AOM_BITS_8)));
INSTANTIATE_TEST_CASE_P(SSE2, PartialTrans32x32Test,
- ::testing::Values(make_tuple(&vpx_fdct32x32_1_sse2,
- VPX_BITS_8)));
-#endif // HAVE_SSE2 && CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
+ ::testing::Values(make_tuple(&aom_fdct32x32_1_sse2,
+ AOM_BITS_8)));
+#endif // HAVE_SSE2 && CONFIG_AOM_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
-#if HAVE_AVX2 && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
+#if HAVE_AVX2 && !CONFIG_AOM_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
INSTANTIATE_TEST_CASE_P(
AVX2, Trans32x32Test,
- ::testing::Values(make_tuple(&vpx_fdct32x32_avx2,
- &vpx_idct32x32_1024_add_sse2, 0, VPX_BITS_8),
- make_tuple(&vpx_fdct32x32_rd_avx2,
- &vpx_idct32x32_1024_add_sse2, 1, VPX_BITS_8)));
-#endif // HAVE_AVX2 && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
+ ::testing::Values(make_tuple(&aom_fdct32x32_avx2,
+ &aom_idct32x32_1024_add_sse2, 0, AOM_BITS_8),
+ make_tuple(&aom_fdct32x32_rd_avx2,
+ &aom_idct32x32_1024_add_sse2, 1, AOM_BITS_8)));
+#endif // HAVE_AVX2 && !CONFIG_AOM_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
-#if HAVE_MSA && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
+#if HAVE_MSA && !CONFIG_AOM_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
INSTANTIATE_TEST_CASE_P(
MSA, Trans32x32Test,
- ::testing::Values(make_tuple(&vpx_fdct32x32_msa,
- &vpx_idct32x32_1024_add_msa, 0, VPX_BITS_8),
- make_tuple(&vpx_fdct32x32_rd_msa,
- &vpx_idct32x32_1024_add_msa, 1, VPX_BITS_8)));
+ ::testing::Values(make_tuple(&aom_fdct32x32_msa,
+ &aom_idct32x32_1024_add_msa, 0, AOM_BITS_8),
+ make_tuple(&aom_fdct32x32_rd_msa,
+ &aom_idct32x32_1024_add_msa, 1, AOM_BITS_8)));
INSTANTIATE_TEST_CASE_P(MSA, PartialTrans32x32Test,
- ::testing::Values(make_tuple(&vpx_fdct32x32_1_msa,
- VPX_BITS_8)));
-#endif // HAVE_MSA && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
+ ::testing::Values(make_tuple(&aom_fdct32x32_1_msa,
+ AOM_BITS_8)));
+#endif // HAVE_MSA && !CONFIG_AOM_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
} // namespace
diff --git a/test/decode_api_test.cc b/test/decode_api_test.cc
index 6aceaba..6ea33d5 100644
--- a/test/decode_api_test.cc
+++ b/test/decode_api_test.cc
@@ -10,47 +10,47 @@
#include "third_party/googletest/src/include/gtest/gtest.h"
-#include "./vpx_config.h"
+#include "./aom_config.h"
#include "test/ivf_video_source.h"
-#include "aom/vp8dx.h"
-#include "aom/vpx_decoder.h"
+#include "aom/aomdx.h"
+#include "aom/aom_decoder.h"
namespace {
#define NELEMENTS(x) static_cast<int>(sizeof(x) / sizeof(x[0]))
TEST(DecodeAPI, InvalidParams) {
- static const vpx_codec_iface_t *kCodecs[] = {
-#if CONFIG_VP10_DECODER
- &vpx_codec_vp10_dx_algo,
+ static const aom_codec_iface_t *kCodecs[] = {
+#if CONFIG_AV1_DECODER
+ &aom_codec_av1_dx_algo,
#endif
};
uint8_t buf[1] = { 0 };
- vpx_codec_ctx_t dec;
+ aom_codec_ctx_t dec;
- EXPECT_EQ(VPX_CODEC_INVALID_PARAM, vpx_codec_dec_init(NULL, NULL, NULL, 0));
- EXPECT_EQ(VPX_CODEC_INVALID_PARAM, vpx_codec_dec_init(&dec, NULL, NULL, 0));
- EXPECT_EQ(VPX_CODEC_INVALID_PARAM, vpx_codec_decode(NULL, NULL, 0, NULL, 0));
- EXPECT_EQ(VPX_CODEC_INVALID_PARAM, vpx_codec_decode(NULL, buf, 0, NULL, 0));
- EXPECT_EQ(VPX_CODEC_INVALID_PARAM,
- vpx_codec_decode(NULL, buf, NELEMENTS(buf), NULL, 0));
- EXPECT_EQ(VPX_CODEC_INVALID_PARAM,
- vpx_codec_decode(NULL, NULL, NELEMENTS(buf), NULL, 0));
- EXPECT_EQ(VPX_CODEC_INVALID_PARAM, vpx_codec_destroy(NULL));
- EXPECT_TRUE(vpx_codec_error(NULL) != NULL);
+ EXPECT_EQ(AOM_CODEC_INVALID_PARAM, aom_codec_dec_init(NULL, NULL, NULL, 0));
+ EXPECT_EQ(AOM_CODEC_INVALID_PARAM, aom_codec_dec_init(&dec, NULL, NULL, 0));
+ EXPECT_EQ(AOM_CODEC_INVALID_PARAM, aom_codec_decode(NULL, NULL, 0, NULL, 0));
+ EXPECT_EQ(AOM_CODEC_INVALID_PARAM, aom_codec_decode(NULL, buf, 0, NULL, 0));
+ EXPECT_EQ(AOM_CODEC_INVALID_PARAM,
+ aom_codec_decode(NULL, buf, NELEMENTS(buf), NULL, 0));
+ EXPECT_EQ(AOM_CODEC_INVALID_PARAM,
+ aom_codec_decode(NULL, NULL, NELEMENTS(buf), NULL, 0));
+ EXPECT_EQ(AOM_CODEC_INVALID_PARAM, aom_codec_destroy(NULL));
+ EXPECT_TRUE(aom_codec_error(NULL) != NULL);
for (int i = 0; i < NELEMENTS(kCodecs); ++i) {
- EXPECT_EQ(VPX_CODEC_INVALID_PARAM,
- vpx_codec_dec_init(NULL, kCodecs[i], NULL, 0));
+ EXPECT_EQ(AOM_CODEC_INVALID_PARAM,
+ aom_codec_dec_init(NULL, kCodecs[i], NULL, 0));
- EXPECT_EQ(VPX_CODEC_OK, vpx_codec_dec_init(&dec, kCodecs[i], NULL, 0));
- EXPECT_EQ(VPX_CODEC_UNSUP_BITSTREAM,
- vpx_codec_decode(&dec, buf, NELEMENTS(buf), NULL, 0));
- EXPECT_EQ(VPX_CODEC_INVALID_PARAM,
- vpx_codec_decode(&dec, NULL, NELEMENTS(buf), NULL, 0));
- EXPECT_EQ(VPX_CODEC_INVALID_PARAM, vpx_codec_decode(&dec, buf, 0, NULL, 0));
+ EXPECT_EQ(AOM_CODEC_OK, aom_codec_dec_init(&dec, kCodecs[i], NULL, 0));
+ EXPECT_EQ(AOM_CODEC_UNSUP_BITSTREAM,
+ aom_codec_decode(&dec, buf, NELEMENTS(buf), NULL, 0));
+ EXPECT_EQ(AOM_CODEC_INVALID_PARAM,
+ aom_codec_decode(&dec, NULL, NELEMENTS(buf), NULL, 0));
+ EXPECT_EQ(AOM_CODEC_INVALID_PARAM, aom_codec_decode(&dec, buf, 0, NULL, 0));
- EXPECT_EQ(VPX_CODEC_OK, vpx_codec_destroy(&dec));
+ EXPECT_EQ(AOM_CODEC_OK, aom_codec_destroy(&dec));
}
}
diff --git a/test/decode_perf_test.cc b/test/decode_perf_test.cc
index 04ca12f..0699863 100644
--- a/test/decode_perf_test.cc
+++ b/test/decode_perf_test.cc
@@ -17,9 +17,9 @@
#include "test/md5_helper.h"
#include "test/util.h"
#include "test/webm_video_source.h"
-#include "aom_ports/vpx_timer.h"
+#include "aom_ports/aom_timer.h"
#include "./ivfenc.h"
-#include "./vpx_version.h"
+#include "./aom_version.h"
using std::tr1::make_tuple;
@@ -37,26 +37,26 @@
*/
typedef std::tr1::tuple<const char *, unsigned> DecodePerfParam;
-const DecodePerfParam kVP9DecodePerfVectors[] = {
- make_tuple("vp90-2-bbb_426x240_tile_1x1_180kbps.webm", 1),
- make_tuple("vp90-2-bbb_640x360_tile_1x2_337kbps.webm", 2),
- make_tuple("vp90-2-bbb_854x480_tile_1x2_651kbps.webm", 2),
- make_tuple("vp90-2-bbb_1280x720_tile_1x4_1310kbps.webm", 4),
- make_tuple("vp90-2-bbb_1920x1080_tile_1x1_2581kbps.webm", 1),
- make_tuple("vp90-2-bbb_1920x1080_tile_1x4_2586kbps.webm", 4),
- make_tuple("vp90-2-bbb_1920x1080_tile_1x4_fpm_2304kbps.webm", 4),
- make_tuple("vp90-2-sintel_426x182_tile_1x1_171kbps.webm", 1),
- make_tuple("vp90-2-sintel_640x272_tile_1x2_318kbps.webm", 2),
- make_tuple("vp90-2-sintel_854x364_tile_1x2_621kbps.webm", 2),
- make_tuple("vp90-2-sintel_1280x546_tile_1x4_1257kbps.webm", 4),
- make_tuple("vp90-2-sintel_1920x818_tile_1x4_fpm_2279kbps.webm", 4),
- make_tuple("vp90-2-tos_426x178_tile_1x1_181kbps.webm", 1),
- make_tuple("vp90-2-tos_640x266_tile_1x2_336kbps.webm", 2),
- make_tuple("vp90-2-tos_854x356_tile_1x2_656kbps.webm", 2),
- make_tuple("vp90-2-tos_854x356_tile_1x2_fpm_546kbps.webm", 2),
- make_tuple("vp90-2-tos_1280x534_tile_1x4_1306kbps.webm", 4),
- make_tuple("vp90-2-tos_1280x534_tile_1x4_fpm_952kbps.webm", 4),
- make_tuple("vp90-2-tos_1920x800_tile_1x4_fpm_2335kbps.webm", 4),
+const DecodePerfParam kAV1DecodePerfVectors[] = {
+ make_tuple("av10-2-bbb_426x240_tile_1x1_180kbps.webm", 1),
+ make_tuple("av10-2-bbb_640x360_tile_1x2_337kbps.webm", 2),
+ make_tuple("av10-2-bbb_854x480_tile_1x2_651kbps.webm", 2),
+ make_tuple("av10-2-bbb_1280x720_tile_1x4_1310kbps.webm", 4),
+ make_tuple("av10-2-bbb_1920x1080_tile_1x1_2581kbps.webm", 1),
+ make_tuple("av10-2-bbb_1920x1080_tile_1x4_2586kbps.webm", 4),
+ make_tuple("av10-2-bbb_1920x1080_tile_1x4_fpm_2304kbps.webm", 4),
+ make_tuple("av10-2-sintel_426x182_tile_1x1_171kbps.webm", 1),
+ make_tuple("av10-2-sintel_640x272_tile_1x2_318kbps.webm", 2),
+ make_tuple("av10-2-sintel_854x364_tile_1x2_621kbps.webm", 2),
+ make_tuple("av10-2-sintel_1280x546_tile_1x4_1257kbps.webm", 4),
+ make_tuple("av10-2-sintel_1920x818_tile_1x4_fpm_2279kbps.webm", 4),
+ make_tuple("av10-2-tos_426x178_tile_1x1_181kbps.webm", 1),
+ make_tuple("av10-2-tos_640x266_tile_1x2_336kbps.webm", 2),
+ make_tuple("av10-2-tos_854x356_tile_1x2_656kbps.webm", 2),
+ make_tuple("av10-2-tos_854x356_tile_1x2_fpm_546kbps.webm", 2),
+ make_tuple("av10-2-tos_1280x534_tile_1x4_1306kbps.webm", 4),
+ make_tuple("av10-2-tos_1280x534_tile_1x4_fpm_952kbps.webm", 4),
+ make_tuple("av10-2-tos_1920x800_tile_1x4_fpm_2335kbps.webm", 4),
};
/*
@@ -79,19 +79,19 @@
libaom_test::WebMVideoSource video(video_name);
video.Init();
- vpx_codec_dec_cfg_t cfg = vpx_codec_dec_cfg_t();
+ aom_codec_dec_cfg_t cfg = aom_codec_dec_cfg_t();
cfg.threads = threads;
- libaom_test::VP9Decoder decoder(cfg, 0);
+ libaom_test::AV1Decoder decoder(cfg, 0);
- vpx_usec_timer t;
- vpx_usec_timer_start(&t);
+ aom_usec_timer t;
+ aom_usec_timer_start(&t);
for (video.Begin(); video.cxdata() != NULL; video.Next()) {
decoder.DecodeFrame(video.cxdata(), video.frame_size());
}
- vpx_usec_timer_mark(&t);
- const double elapsed_secs = double(vpx_usec_timer_elapsed(&t)) / kUsecsInSec;
+ aom_usec_timer_mark(&t);
+ const double elapsed_secs = double(aom_usec_timer_elapsed(&t)) / kUsecsInSec;
const unsigned frames = video.frame_number();
const double fps = double(frames) / elapsed_secs;
@@ -106,18 +106,18 @@
printf("}\n");
}
-INSTANTIATE_TEST_CASE_P(VP9, DecodePerfTest,
- ::testing::ValuesIn(kVP9DecodePerfVectors));
+INSTANTIATE_TEST_CASE_P(AV1, DecodePerfTest,
+ ::testing::ValuesIn(kAV1DecodePerfVectors));
-class VP9NewEncodeDecodePerfTest
+class AV1NewEncodeDecodePerfTest
: public ::libaom_test::EncoderTest,
public ::libaom_test::CodecTestWithParam<libaom_test::TestMode> {
protected:
- VP9NewEncodeDecodePerfTest()
+ AV1NewEncodeDecodePerfTest()
: EncoderTest(GET_PARAM(0)), encoding_mode_(GET_PARAM(1)), speed_(0),
outfile_(0), out_frames_(0) {}
- virtual ~VP9NewEncodeDecodePerfTest() {}
+ virtual ~AV1NewEncodeDecodePerfTest() {}
virtual void SetUp() {
InitializeConfig();
@@ -133,15 +133,15 @@
cfg_.rc_buf_initial_sz = 500;
cfg_.rc_buf_optimal_sz = 600;
cfg_.rc_resize_allowed = 0;
- cfg_.rc_end_usage = VPX_VBR;
+ cfg_.rc_end_usage = AOM_VBR;
}
virtual void PreEncodeFrameHook(::libaom_test::VideoSource *video,
::libaom_test::Encoder *encoder) {
if (video->frame() == 1) {
- encoder->Control(VP8E_SET_CPUUSED, speed_);
- encoder->Control(VP9E_SET_FRAME_PARALLEL_DECODING, 1);
- encoder->Control(VP9E_SET_TILE_COLUMNS, 2);
+ encoder->Control(AOME_SET_CPUUSED, speed_);
+ encoder->Control(AV1E_SET_FRAME_PARALLEL_DECODING, 1);
+ encoder->Control(AV1E_SET_TILE_COLUMNS, 2);
}
}
@@ -155,18 +155,18 @@
virtual void EndPassHook() {
if (outfile_ != NULL) {
if (!fseek(outfile_, 0, SEEK_SET))
- ivf_write_file_header(outfile_, &cfg_, VP9_FOURCC, out_frames_);
+ ivf_write_file_header(outfile_, &cfg_, AV1_FOURCC, out_frames_);
fclose(outfile_);
outfile_ = NULL;
}
}
- virtual void FramePktHook(const vpx_codec_cx_pkt_t *pkt) {
+ virtual void FramePktHook(const aom_codec_cx_pkt_t *pkt) {
++out_frames_;
// Write initial file header if first frame.
if (pkt->data.frame.pts == 0)
- ivf_write_file_header(outfile_, &cfg_, VP9_FOURCC, out_frames_);
+ ivf_write_file_header(outfile_, &cfg_, AV1_FOURCC, out_frames_);
// Write frame header and data.
ivf_write_frame_header(outfile_, out_frames_, pkt->data.frame.sz);
@@ -197,26 +197,26 @@
int frames;
};
-const EncodePerfTestVideo kVP9EncodePerfTestVectors[] = {
+const EncodePerfTestVideo kAV1EncodePerfTestVectors[] = {
EncodePerfTestVideo("niklas_1280_720_30.yuv", 1280, 720, 600, 470),
};
-TEST_P(VP9NewEncodeDecodePerfTest, PerfTest) {
+TEST_P(AV1NewEncodeDecodePerfTest, PerfTest) {
SetUp();
// TODO(JBB): Make this work by going through the set of given files.
const int i = 0;
- const vpx_rational timebase = { 33333333, 1000000000 };
+ const aom_rational timebase = { 33333333, 1000000000 };
cfg_.g_timebase = timebase;
- cfg_.rc_target_bitrate = kVP9EncodePerfTestVectors[i].bitrate;
+ cfg_.rc_target_bitrate = kAV1EncodePerfTestVectors[i].bitrate;
- init_flags_ = VPX_CODEC_USE_PSNR;
+ init_flags_ = AOM_CODEC_USE_PSNR;
- const char *video_name = kVP9EncodePerfTestVectors[i].name;
+ const char *video_name = kAV1EncodePerfTestVectors[i].name;
libaom_test::I420VideoSource video(
- video_name, kVP9EncodePerfTestVectors[i].width,
- kVP9EncodePerfTestVectors[i].height, timebase.den, timebase.num, 0,
- kVP9EncodePerfTestVectors[i].frames);
+ video_name, kAV1EncodePerfTestVectors[i].width,
+ kAV1EncodePerfTestVectors[i].height, timebase.den, timebase.num, 0,
+ kAV1EncodePerfTestVectors[i].frames);
set_speed(2);
ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
@@ -226,21 +226,21 @@
libaom_test::IVFVideoSource decode_video(kNewEncodeOutputFile);
decode_video.Init();
- vpx_codec_dec_cfg_t cfg = vpx_codec_dec_cfg_t();
+ aom_codec_dec_cfg_t cfg = aom_codec_dec_cfg_t();
cfg.threads = threads;
- libaom_test::VP9Decoder decoder(cfg, 0);
+ libaom_test::AV1Decoder decoder(cfg, 0);
- vpx_usec_timer t;
- vpx_usec_timer_start(&t);
+ aom_usec_timer t;
+ aom_usec_timer_start(&t);
for (decode_video.Begin(); decode_video.cxdata() != NULL;
decode_video.Next()) {
decoder.DecodeFrame(decode_video.cxdata(), decode_video.frame_size());
}
- vpx_usec_timer_mark(&t);
+ aom_usec_timer_mark(&t);
const double elapsed_secs =
- static_cast<double>(vpx_usec_timer_elapsed(&t)) / kUsecsInSec;
+ static_cast<double>(aom_usec_timer_elapsed(&t)) / kUsecsInSec;
const unsigned decode_frames = decode_video.frame_number();
const double fps = static_cast<double>(decode_frames) / elapsed_secs;
@@ -255,6 +255,6 @@
printf("}\n");
}
-VP10_INSTANTIATE_TEST_CASE(VP9NewEncodeDecodePerfTest,
- ::testing::Values(::libaom_test::kTwoPassGood));
+AV1_INSTANTIATE_TEST_CASE(AV1NewEncodeDecodePerfTest,
+ ::testing::Values(::libaom_test::kTwoPassGood));
} // namespace
diff --git a/test/decode_test_driver.cc b/test/decode_test_driver.cc
index 4484d47..65dea5c 100644
--- a/test/decode_test_driver.cc
+++ b/test/decode_test_driver.cc
@@ -18,24 +18,24 @@
namespace libaom_test {
const char kVP8Name[] = "WebM Project VP8";
-const char kVP10Name[] = "WebM Project VP10";
+const char kAV1Name[] = "WebM Project AV1";
-vpx_codec_err_t Decoder::PeekStream(const uint8_t *cxdata, size_t size,
- vpx_codec_stream_info_t *stream_info) {
- return vpx_codec_peek_stream_info(
+aom_codec_err_t Decoder::PeekStream(const uint8_t *cxdata, size_t size,
+ aom_codec_stream_info_t *stream_info) {
+ return aom_codec_peek_stream_info(
CodecInterface(), cxdata, static_cast<unsigned int>(size), stream_info);
}
-vpx_codec_err_t Decoder::DecodeFrame(const uint8_t *cxdata, size_t size) {
+aom_codec_err_t Decoder::DecodeFrame(const uint8_t *cxdata, size_t size) {
return DecodeFrame(cxdata, size, NULL);
}
-vpx_codec_err_t Decoder::DecodeFrame(const uint8_t *cxdata, size_t size,
+aom_codec_err_t Decoder::DecodeFrame(const uint8_t *cxdata, size_t size,
void *user_priv) {
- vpx_codec_err_t res_dec;
+ aom_codec_err_t res_dec;
InitOnce();
API_REGISTER_STATE_CHECK(
- res_dec = vpx_codec_decode(
+ res_dec = aom_codec_decode(
&decoder_, cxdata, static_cast<unsigned int>(size), user_priv, 0));
return res_dec;
}
@@ -45,32 +45,32 @@
return strncmp(kVP8Name, codec_name, sizeof(kVP8Name) - 1) == 0;
}
-bool Decoder::IsVP10() const {
+bool Decoder::IsAV1() const {
const char *codec_name = GetDecoderName();
- return strncmp(kVP10Name, codec_name, sizeof(kVP10Name) - 1) == 0;
+ return strncmp(kAV1Name, codec_name, sizeof(kAV1Name) - 1) == 0;
}
void DecoderTest::HandlePeekResult(Decoder *const decoder,
CompressedVideoSource *video,
- const vpx_codec_err_t res_peek) {
+ const aom_codec_err_t res_peek) {
const bool is_vp8 = decoder->IsVP8();
if (is_vp8) {
/* Vp8's implementation of PeekStream returns an error if the frame you
- * pass it is not a keyframe, so we only expect VPX_CODEC_OK on the first
+ * pass it is not a keyframe, so we only expect AOM_CODEC_OK on the first
* frame, which must be a keyframe. */
if (video->frame_number() == 0)
- ASSERT_EQ(VPX_CODEC_OK, res_peek) << "Peek return failed: "
- << vpx_codec_err_to_string(res_peek);
+ ASSERT_EQ(AOM_CODEC_OK, res_peek) << "Peek return failed: "
+ << aom_codec_err_to_string(res_peek);
} else {
- /* The Vp9 implementation of PeekStream returns an error only if the
- * data passed to it isn't a valid Vp9 chunk. */
- ASSERT_EQ(VPX_CODEC_OK, res_peek) << "Peek return failed: "
- << vpx_codec_err_to_string(res_peek);
+ /* The Av1 implementation of PeekStream returns an error only if the
+ * data passed to it isn't a valid Av1 chunk. */
+ ASSERT_EQ(AOM_CODEC_OK, res_peek) << "Peek return failed: "
+ << aom_codec_err_to_string(res_peek);
}
}
void DecoderTest::RunLoop(CompressedVideoSource *video,
- const vpx_codec_dec_cfg_t &dec_cfg) {
+ const aom_codec_dec_cfg_t &dec_cfg) {
Decoder *const decoder = codec_->CreateDecoder(dec_cfg, flags_, 0);
ASSERT_TRUE(decoder != NULL);
bool end_of_file = false;
@@ -80,27 +80,27 @@
video->Next()) {
PreDecodeFrameHook(*video, decoder);
- vpx_codec_stream_info_t stream_info;
+ aom_codec_stream_info_t stream_info;
stream_info.sz = sizeof(stream_info);
if (video->cxdata() != NULL) {
- const vpx_codec_err_t res_peek = decoder->PeekStream(
+ const aom_codec_err_t res_peek = decoder->PeekStream(
video->cxdata(), video->frame_size(), &stream_info);
HandlePeekResult(decoder, video, res_peek);
ASSERT_FALSE(::testing::Test::HasFailure());
- vpx_codec_err_t res_dec =
+ aom_codec_err_t res_dec =
decoder->DecodeFrame(video->cxdata(), video->frame_size());
if (!HandleDecodeResult(res_dec, *video, decoder)) break;
} else {
// Signal end of the file to the decoder.
- const vpx_codec_err_t res_dec = decoder->DecodeFrame(NULL, 0);
- ASSERT_EQ(VPX_CODEC_OK, res_dec) << decoder->DecodeError();
+ const aom_codec_err_t res_dec = decoder->DecodeFrame(NULL, 0);
+ ASSERT_EQ(AOM_CODEC_OK, res_dec) << decoder->DecodeError();
end_of_file = true;
}
DxDataIterator dec_iter = decoder->GetDxData();
- const vpx_image_t *img = NULL;
+ const aom_image_t *img = NULL;
// Get decompressed data
while ((img = dec_iter.Next()))
@@ -110,14 +110,14 @@
}
void DecoderTest::RunLoop(CompressedVideoSource *video) {
- vpx_codec_dec_cfg_t dec_cfg = vpx_codec_dec_cfg_t();
+ aom_codec_dec_cfg_t dec_cfg = aom_codec_dec_cfg_t();
RunLoop(video, dec_cfg);
}
-void DecoderTest::set_cfg(const vpx_codec_dec_cfg_t &dec_cfg) {
+void DecoderTest::set_cfg(const aom_codec_dec_cfg_t &dec_cfg) {
memcpy(&cfg_, &dec_cfg, sizeof(cfg_));
}
-void DecoderTest::set_flags(const vpx_codec_flags_t flags) { flags_ = flags; }
+void DecoderTest::set_flags(const aom_codec_flags_t flags) { flags_ = flags; }
} // namespace libaom_test
diff --git a/test/decode_test_driver.h b/test/decode_test_driver.h
index 04ae46f..32c0c3f 100644
--- a/test/decode_test_driver.h
+++ b/test/decode_test_driver.h
@@ -12,8 +12,8 @@
#define TEST_DECODE_TEST_DRIVER_H_
#include <cstring>
#include "third_party/googletest/src/include/gtest/gtest.h"
-#include "./vpx_config.h"
-#include "aom/vpx_decoder.h"
+#include "./aom_config.h"
+#include "aom/aom_decoder.h"
namespace libaom_test {
@@ -23,14 +23,14 @@
// Provides an object to handle decoding output
class DxDataIterator {
public:
- explicit DxDataIterator(vpx_codec_ctx_t *decoder)
+ explicit DxDataIterator(aom_codec_ctx_t *decoder)
: decoder_(decoder), iter_(NULL) {}
- const vpx_image_t *Next() { return vpx_codec_get_frame(decoder_, &iter_); }
+ const aom_image_t *Next() { return aom_codec_get_frame(decoder_, &iter_); }
private:
- vpx_codec_ctx_t *decoder_;
- vpx_codec_iter_t iter_;
+ aom_codec_ctx_t *decoder_;
+ aom_codec_iter_t iter_;
};
// Provides a simplified interface to manage one video decoding.
@@ -38,12 +38,12 @@
// as more tests are added.
class Decoder {
public:
- Decoder(vpx_codec_dec_cfg_t cfg, unsigned long deadline)
+ Decoder(aom_codec_dec_cfg_t cfg, unsigned long deadline)
: cfg_(cfg), flags_(0), deadline_(deadline), init_done_(false) {
memset(&decoder_, 0, sizeof(decoder_));
}
- Decoder(vpx_codec_dec_cfg_t cfg, const vpx_codec_flags_t flag,
+ Decoder(aom_codec_dec_cfg_t cfg, const aom_codec_flags_t flag,
unsigned long deadline) // NOLINT
: cfg_(cfg),
flags_(flag),
@@ -52,73 +52,73 @@
memset(&decoder_, 0, sizeof(decoder_));
}
- virtual ~Decoder() { vpx_codec_destroy(&decoder_); }
+ virtual ~Decoder() { aom_codec_destroy(&decoder_); }
- vpx_codec_err_t PeekStream(const uint8_t *cxdata, size_t size,
- vpx_codec_stream_info_t *stream_info);
+ aom_codec_err_t PeekStream(const uint8_t *cxdata, size_t size,
+ aom_codec_stream_info_t *stream_info);
- vpx_codec_err_t DecodeFrame(const uint8_t *cxdata, size_t size);
+ aom_codec_err_t DecodeFrame(const uint8_t *cxdata, size_t size);
- vpx_codec_err_t DecodeFrame(const uint8_t *cxdata, size_t size,
+ aom_codec_err_t DecodeFrame(const uint8_t *cxdata, size_t size,
void *user_priv);
DxDataIterator GetDxData() { return DxDataIterator(&decoder_); }
void set_deadline(unsigned long deadline) { deadline_ = deadline; }
- void Control(int ctrl_id, int arg) { Control(ctrl_id, arg, VPX_CODEC_OK); }
+ void Control(int ctrl_id, int arg) { Control(ctrl_id, arg, AOM_CODEC_OK); }
void Control(int ctrl_id, const void *arg) {
InitOnce();
- const vpx_codec_err_t res = vpx_codec_control_(&decoder_, ctrl_id, arg);
- ASSERT_EQ(VPX_CODEC_OK, res) << DecodeError();
+ const aom_codec_err_t res = aom_codec_control_(&decoder_, ctrl_id, arg);
+ ASSERT_EQ(AOM_CODEC_OK, res) << DecodeError();
}
- void Control(int ctrl_id, int arg, vpx_codec_err_t expected_value) {
+ void Control(int ctrl_id, int arg, aom_codec_err_t expected_value) {
InitOnce();
- const vpx_codec_err_t res = vpx_codec_control_(&decoder_, ctrl_id, arg);
+ const aom_codec_err_t res = aom_codec_control_(&decoder_, ctrl_id, arg);
ASSERT_EQ(expected_value, res) << DecodeError();
}
const char *DecodeError() {
- const char *detail = vpx_codec_error_detail(&decoder_);
- return detail ? detail : vpx_codec_error(&decoder_);
+ const char *detail = aom_codec_error_detail(&decoder_);
+ return detail ? detail : aom_codec_error(&decoder_);
}
// Passes the external frame buffer information to libaom.
- vpx_codec_err_t SetFrameBufferFunctions(
- vpx_get_frame_buffer_cb_fn_t cb_get,
- vpx_release_frame_buffer_cb_fn_t cb_release, void *user_priv) {
+ aom_codec_err_t SetFrameBufferFunctions(
+ aom_get_frame_buffer_cb_fn_t cb_get,
+ aom_release_frame_buffer_cb_fn_t cb_release, void *user_priv) {
InitOnce();
- return vpx_codec_set_frame_buffer_functions(&decoder_, cb_get, cb_release,
+ return aom_codec_set_frame_buffer_functions(&decoder_, cb_get, cb_release,
user_priv);
}
const char *GetDecoderName() const {
- return vpx_codec_iface_name(CodecInterface());
+ return aom_codec_iface_name(CodecInterface());
}
bool IsVP8() const;
- bool IsVP10() const;
+ bool IsAV1() const;
- vpx_codec_ctx_t *GetDecoder() { return &decoder_; }
+ aom_codec_ctx_t *GetDecoder() { return &decoder_; }
protected:
- virtual vpx_codec_iface_t *CodecInterface() const = 0;
+ virtual aom_codec_iface_t *CodecInterface() const = 0;
void InitOnce() {
if (!init_done_) {
- const vpx_codec_err_t res =
- vpx_codec_dec_init(&decoder_, CodecInterface(), &cfg_, flags_);
- ASSERT_EQ(VPX_CODEC_OK, res) << DecodeError();
+ const aom_codec_err_t res =
+ aom_codec_dec_init(&decoder_, CodecInterface(), &cfg_, flags_);
+ ASSERT_EQ(AOM_CODEC_OK, res) << DecodeError();
init_done_ = true;
}
}
- vpx_codec_ctx_t decoder_;
- vpx_codec_dec_cfg_t cfg_;
- vpx_codec_flags_t flags_;
+ aom_codec_ctx_t decoder_;
+ aom_codec_dec_cfg_t cfg_;
+ aom_codec_flags_t flags_;
unsigned int deadline_;
bool init_done_;
};
@@ -129,31 +129,31 @@
// Main decoding loop
virtual void RunLoop(CompressedVideoSource *video);
virtual void RunLoop(CompressedVideoSource *video,
- const vpx_codec_dec_cfg_t &dec_cfg);
+ const aom_codec_dec_cfg_t &dec_cfg);
- virtual void set_cfg(const vpx_codec_dec_cfg_t &dec_cfg);
- virtual void set_flags(const vpx_codec_flags_t flags);
+ virtual void set_cfg(const aom_codec_dec_cfg_t &dec_cfg);
+ virtual void set_flags(const aom_codec_flags_t flags);
// Hook to be called before decompressing every frame.
virtual void PreDecodeFrameHook(const CompressedVideoSource & /*video*/,
Decoder * /*decoder*/) {}
// Hook to be called to handle decode result. Return true to continue.
- virtual bool HandleDecodeResult(const vpx_codec_err_t res_dec,
+ virtual bool HandleDecodeResult(const aom_codec_err_t res_dec,
const CompressedVideoSource & /*video*/,
Decoder *decoder) {
- EXPECT_EQ(VPX_CODEC_OK, res_dec) << decoder->DecodeError();
- return VPX_CODEC_OK == res_dec;
+ EXPECT_EQ(AOM_CODEC_OK, res_dec) << decoder->DecodeError();
+ return AOM_CODEC_OK == res_dec;
}
// Hook to be called on every decompressed frame.
- virtual void DecompressedFrameHook(const vpx_image_t & /*img*/,
+ virtual void DecompressedFrameHook(const aom_image_t & /*img*/,
const unsigned int /*frame_number*/) {}
// Hook to be called on peek result
virtual void HandlePeekResult(Decoder *const decoder,
CompressedVideoSource *video,
- const vpx_codec_err_t res_peek);
+ const aom_codec_err_t res_peek);
protected:
explicit DecoderTest(const CodecFactory *codec)
@@ -162,8 +162,8 @@
virtual ~DecoderTest() {}
const CodecFactory *codec_;
- vpx_codec_dec_cfg_t cfg_;
- vpx_codec_flags_t flags_;
+ aom_codec_dec_cfg_t cfg_;
+ aom_codec_flags_t flags_;
};
} // namespace libaom_test
diff --git a/test/decode_to_md5.sh b/test/decode_to_md5.sh
index 54d1593..e5c6a01 100755
--- a/test/decode_to_md5.sh
+++ b/test/decode_to_md5.sh
@@ -16,10 +16,10 @@
. $(dirname $0)/tools_common.sh
# Environment check: Make sure input is available:
-# $VP8_IVF_FILE and $VP9_IVF_FILE are required.
+# $VP8_IVF_FILE and $AV1_IVF_FILE are required.
decode_to_md5_verify_environment() {
- if [ ! -e "${VP8_IVF_FILE}" ] || [ ! -e "${VP9_IVF_FILE}" ]; then
- echo "Libvpx test data must exist in LIBVPX_TEST_DATA_PATH."
+ if [ ! -e "${VP8_IVF_FILE}" ] || [ ! -e "${AV1_IVF_FILE}" ]; then
+ echo "Libaom test data must exist in LIBVPX_TEST_DATA_PATH."
return 1
fi
}
@@ -28,18 +28,18 @@
# interpreted as codec name and used solely to name the output file. $3 is the
# expected md5 sum: It must match that of the final frame.
decode_to_md5() {
- local decoder="${LIBAOM_BIN_PATH}/decode_to_md5${VPX_TEST_EXE_SUFFIX}"
+ local decoder="${LIBAOM_BIN_PATH}/decode_to_md5${AOM_TEST_EXE_SUFFIX}"
local input_file="$1"
local codec="$2"
local expected_md5="$3"
- local output_file="${VPX_TEST_OUTPUT_DIR}/decode_to_md5_${codec}"
+ local output_file="${AOM_TEST_OUTPUT_DIR}/decode_to_md5_${codec}"
if [ ! -x "${decoder}" ]; then
elog "${decoder} does not exist or is not executable."
return 1
fi
- eval "${VPX_TEST_PREFIX}" "${decoder}" "${input_file}" "${output_file}" \
+ eval "${AOM_TEST_PREFIX}" "${decoder}" "${input_file}" "${output_file}" \
${devnull}
[ -e "${output_file}" ] || return 1
@@ -58,16 +58,16 @@
fi
}
-decode_to_md5_vp9() {
+decode_to_md5_av1() {
# expected MD5 sum for the last frame.
local expected_md5="2952c0eae93f3dadd1aa84c50d3fd6d2"
- if [ "$(vp9_decode_available)" = "yes" ]; then
- decode_to_md5 "${VP9_IVF_FILE}" "vp9" "${expected_md5}"
+ if [ "$(av1_decode_available)" = "yes" ]; then
+ decode_to_md5 "${AV1_IVF_FILE}" "av1" "${expected_md5}"
fi
}
decode_to_md5_tests="decode_to_md5_vp8
- decode_to_md5_vp9"
+ decode_to_md5_av1"
run_tests decode_to_md5_verify_environment "${decode_to_md5_tests}"
diff --git a/test/decode_with_drops.sh b/test/decode_with_drops.sh
index bb2416a..2a8ce99 100755
--- a/test/decode_with_drops.sh
+++ b/test/decode_with_drops.sh
@@ -16,10 +16,10 @@
. $(dirname $0)/tools_common.sh
# Environment check: Make sure input is available:
-# $VP8_IVF_FILE and $VP9_IVF_FILE are required.
+# $VP8_IVF_FILE and $AV1_IVF_FILE are required.
decode_with_drops_verify_environment() {
- if [ ! -e "${VP8_IVF_FILE}" ] || [ ! -e "${VP9_IVF_FILE}" ]; then
- echo "Libvpx test data must exist in LIBVPX_TEST_DATA_PATH."
+ if [ ! -e "${VP8_IVF_FILE}" ] || [ ! -e "${AV1_IVF_FILE}" ]; then
+ echo "Libaom test data must exist in LIBVPX_TEST_DATA_PATH."
return 1
fi
}
@@ -28,10 +28,10 @@
# to name the output file. $3 is the drop mode, and is passed directly to
# decode_with_drops.
decode_with_drops() {
- local decoder="${LIBAOM_BIN_PATH}/decode_with_drops${VPX_TEST_EXE_SUFFIX}"
+ local decoder="${LIBAOM_BIN_PATH}/decode_with_drops${AOM_TEST_EXE_SUFFIX}"
local input_file="$1"
local codec="$2"
- local output_file="${VPX_TEST_OUTPUT_DIR}/decode_with_drops_${codec}"
+ local output_file="${AOM_TEST_OUTPUT_DIR}/decode_with_drops_${codec}"
local drop_mode="$3"
if [ ! -x "${decoder}" ]; then
@@ -39,7 +39,7 @@
return 1
fi
- eval "${VPX_TEST_PREFIX}" "${decoder}" "${input_file}" "${output_file}" \
+ eval "${AOM_TEST_PREFIX}" "${decoder}" "${input_file}" "${output_file}" \
"${drop_mode}" ${devnull}
[ -e "${output_file}" ] || return 1
@@ -59,21 +59,21 @@
fi
}
-# Decodes $VP9_IVF_FILE while dropping frames, twice: once in sequence mode,
+# Decodes $AV1_IVF_FILE while dropping frames, twice: once in sequence mode,
# and once in pattern mode.
-# Note: This test assumes that $VP9_IVF_FILE has exactly 20 frames, and could
+# Note: This test assumes that $AV1_IVF_FILE has exactly 20 frames, and could
# break if the file is modified.
-decode_with_drops_vp9() {
- if [ "$(vp9_decode_available)" = "yes" ]; then
+decode_with_drops_av1() {
+ if [ "$(av1_decode_available)" = "yes" ]; then
# Test sequence mode: Drop frames 2-28.
- decode_with_drops "${VP9_IVF_FILE}" "vp9" "2-19"
+ decode_with_drops "${AV1_IVF_FILE}" "av1" "2-19"
# Test pattern mode: Drop 3 of every 4 frames.
- decode_with_drops "${VP9_IVF_FILE}" "vp9" "3/4"
+ decode_with_drops "${AV1_IVF_FILE}" "av1" "3/4"
fi
}
decode_with_drops_tests="decode_with_drops_vp8
- decode_with_drops_vp9"
+ decode_with_drops_av1"
run_tests decode_with_drops_verify_environment "${decode_with_drops_tests}"
diff --git a/test/denoiser_sse2_test.cc b/test/denoiser_sse2_test.cc
index 571f3cf..115839b 100644
--- a/test/denoiser_sse2_test.cc
+++ b/test/denoiser_sse2_test.cc
@@ -19,7 +19,7 @@
#include "test/util.h"
#include "aom_scale/yv12config.h"
-#include "aom/vpx_integer.h"
+#include "aom/aom_integer.h"
#include "av1/common/reconinter.h"
#include "av1/encoder/context_tree.h"
#include "av1/encoder/denoiser.h"
@@ -29,9 +29,9 @@
namespace {
const int kNumPixels = 64 * 64;
-class VP9DenoiserTest : public ::testing::TestWithParam<BLOCK_SIZE> {
+class AV1DenoiserTest : public ::testing::TestWithParam<BLOCK_SIZE> {
public:
- virtual ~VP9DenoiserTest() {}
+ virtual ~AV1DenoiserTest() {}
virtual void SetUp() { bs_ = GetParam(); }
@@ -41,7 +41,7 @@
BLOCK_SIZE bs_;
};
-TEST_P(VP9DenoiserTest, BitexactCheck) {
+TEST_P(AV1DenoiserTest, BitexactCheck) {
ACMRandom rnd(ACMRandom::DeterministicSeed());
const int count_test_block = 4000;
@@ -72,11 +72,11 @@
mc_avg_block[j] = (temp < 0) ? 0 : ((temp > 255) ? 255 : temp);
}
- ASM_REGISTER_STATE_CHECK(vp9_denoiser_filter_c(sig_block, 64, mc_avg_block,
+ ASM_REGISTER_STATE_CHECK(av1_denoiser_filter_c(sig_block, 64, mc_avg_block,
64, avg_block_c, 64, 0, bs_,
motion_magnitude_random));
- ASM_REGISTER_STATE_CHECK(vp9_denoiser_filter_sse2(
+ ASM_REGISTER_STATE_CHECK(av1_denoiser_filter_sse2(
sig_block, 64, mc_avg_block, 64, avg_block_sse2, 64, 0, bs_,
motion_magnitude_random));
@@ -90,7 +90,7 @@
}
// Test for all block size.
-INSTANTIATE_TEST_CASE_P(SSE2, VP9DenoiserTest,
+INSTANTIATE_TEST_CASE_P(SSE2, AV1DenoiserTest,
::testing::Values(BLOCK_8X8, BLOCK_8X16, BLOCK_16X8,
BLOCK_16X16, BLOCK_16X32, BLOCK_32X16,
BLOCK_32X32, BLOCK_32X64, BLOCK_64X32,
diff --git a/test/encode_api_test.cc b/test/encode_api_test.cc
index dc3a52b..c45c761 100644
--- a/test/encode_api_test.cc
+++ b/test/encode_api_test.cc
@@ -10,52 +10,52 @@
#include "third_party/googletest/src/include/gtest/gtest.h"
-#include "./vpx_config.h"
-#include "aom/vp8cx.h"
-#include "aom/vpx_encoder.h"
+#include "./aom_config.h"
+#include "aom/aomcx.h"
+#include "aom/aom_encoder.h"
namespace {
#define NELEMENTS(x) static_cast<int>(sizeof(x) / sizeof(x[0]))
TEST(EncodeAPI, InvalidParams) {
- static const vpx_codec_iface_t *kCodecs[] = {
-#if CONFIG_VP10_ENCODER
- &vpx_codec_vp10_cx_algo,
+ static const aom_codec_iface_t *kCodecs[] = {
+#if CONFIG_AV1_ENCODER
+ &aom_codec_av1_cx_algo,
#endif
};
uint8_t buf[1] = { 0 };
- vpx_image_t img;
- vpx_codec_ctx_t enc;
- vpx_codec_enc_cfg_t cfg;
+ aom_image_t img;
+ aom_codec_ctx_t enc;
+ aom_codec_enc_cfg_t cfg;
- EXPECT_EQ(&img, vpx_img_wrap(&img, VPX_IMG_FMT_I420, 1, 1, 1, buf));
+ EXPECT_EQ(&img, aom_img_wrap(&img, AOM_IMG_FMT_I420, 1, 1, 1, buf));
- EXPECT_EQ(VPX_CODEC_INVALID_PARAM, vpx_codec_enc_init(NULL, NULL, NULL, 0));
- EXPECT_EQ(VPX_CODEC_INVALID_PARAM, vpx_codec_enc_init(&enc, NULL, NULL, 0));
- EXPECT_EQ(VPX_CODEC_INVALID_PARAM, vpx_codec_encode(NULL, NULL, 0, 0, 0, 0));
- EXPECT_EQ(VPX_CODEC_INVALID_PARAM, vpx_codec_encode(NULL, &img, 0, 0, 0, 0));
- EXPECT_EQ(VPX_CODEC_INVALID_PARAM, vpx_codec_destroy(NULL));
- EXPECT_EQ(VPX_CODEC_INVALID_PARAM,
- vpx_codec_enc_config_default(NULL, NULL, 0));
- EXPECT_EQ(VPX_CODEC_INVALID_PARAM,
- vpx_codec_enc_config_default(NULL, &cfg, 0));
- EXPECT_TRUE(vpx_codec_error(NULL) != NULL);
+ EXPECT_EQ(AOM_CODEC_INVALID_PARAM, aom_codec_enc_init(NULL, NULL, NULL, 0));
+ EXPECT_EQ(AOM_CODEC_INVALID_PARAM, aom_codec_enc_init(&enc, NULL, NULL, 0));
+ EXPECT_EQ(AOM_CODEC_INVALID_PARAM, aom_codec_encode(NULL, NULL, 0, 0, 0, 0));
+ EXPECT_EQ(AOM_CODEC_INVALID_PARAM, aom_codec_encode(NULL, &img, 0, 0, 0, 0));
+ EXPECT_EQ(AOM_CODEC_INVALID_PARAM, aom_codec_destroy(NULL));
+ EXPECT_EQ(AOM_CODEC_INVALID_PARAM,
+ aom_codec_enc_config_default(NULL, NULL, 0));
+ EXPECT_EQ(AOM_CODEC_INVALID_PARAM,
+ aom_codec_enc_config_default(NULL, &cfg, 0));
+ EXPECT_TRUE(aom_codec_error(NULL) != NULL);
for (int i = 0; i < NELEMENTS(kCodecs); ++i) {
- SCOPED_TRACE(vpx_codec_iface_name(kCodecs[i]));
- EXPECT_EQ(VPX_CODEC_INVALID_PARAM,
- vpx_codec_enc_init(NULL, kCodecs[i], NULL, 0));
- EXPECT_EQ(VPX_CODEC_INVALID_PARAM,
- vpx_codec_enc_init(&enc, kCodecs[i], NULL, 0));
- EXPECT_EQ(VPX_CODEC_INVALID_PARAM,
- vpx_codec_enc_config_default(kCodecs[i], &cfg, 1));
+ SCOPED_TRACE(aom_codec_iface_name(kCodecs[i]));
+ EXPECT_EQ(AOM_CODEC_INVALID_PARAM,
+ aom_codec_enc_init(NULL, kCodecs[i], NULL, 0));
+ EXPECT_EQ(AOM_CODEC_INVALID_PARAM,
+ aom_codec_enc_init(&enc, kCodecs[i], NULL, 0));
+ EXPECT_EQ(AOM_CODEC_INVALID_PARAM,
+ aom_codec_enc_config_default(kCodecs[i], &cfg, 1));
- EXPECT_EQ(VPX_CODEC_OK, vpx_codec_enc_config_default(kCodecs[i], &cfg, 0));
- EXPECT_EQ(VPX_CODEC_OK, vpx_codec_enc_init(&enc, kCodecs[i], &cfg, 0));
- EXPECT_EQ(VPX_CODEC_OK, vpx_codec_encode(&enc, NULL, 0, 0, 0, 0));
+ EXPECT_EQ(AOM_CODEC_OK, aom_codec_enc_config_default(kCodecs[i], &cfg, 0));
+ EXPECT_EQ(AOM_CODEC_OK, aom_codec_enc_init(&enc, kCodecs[i], &cfg, 0));
+ EXPECT_EQ(AOM_CODEC_OK, aom_codec_encode(&enc, NULL, 0, 0, 0, 0));
- EXPECT_EQ(VPX_CODEC_OK, vpx_codec_destroy(&enc));
+ EXPECT_EQ(AOM_CODEC_OK, aom_codec_destroy(&enc));
}
}
diff --git a/test/encode_perf_test.cc b/test/encode_perf_test.cc
index 7f33d55..39330aa 100644
--- a/test/encode_perf_test.cc
+++ b/test/encode_perf_test.cc
@@ -9,14 +9,14 @@
*/
#include <string>
#include "third_party/googletest/src/include/gtest/gtest.h"
-#include "./vpx_config.h"
-#include "./vpx_version.h"
+#include "./aom_config.h"
+#include "./aom_version.h"
#include "test/codec_factory.h"
#include "test/encode_test_driver.h"
#include "test/i420_video_source.h"
#include "test/util.h"
#include "test/y4m_video_source.h"
-#include "aom_ports/vpx_timer.h"
+#include "aom_ports/aom_timer.h"
namespace {
@@ -35,7 +35,7 @@
int frames;
};
-const EncodePerfTestVideo kVP9EncodePerfTestVectors[] = {
+const EncodePerfTestVideo kAV1EncodePerfTestVectors[] = {
EncodePerfTestVideo("desktop_640_360_30.yuv", 640, 360, 200, 2484),
EncodePerfTestVideo("kirland_640_480_30.yuv", 640, 480, 200, 300),
EncodePerfTestVideo("macmarcomoving_640_480_30.yuv", 640, 480, 200, 987),
@@ -53,15 +53,15 @@
#define NELEMENTS(x) (sizeof((x)) / sizeof((x)[0]))
-class VP9EncodePerfTest
+class AV1EncodePerfTest
: public ::libaom_test::EncoderTest,
public ::libaom_test::CodecTestWithParam<libaom_test::TestMode> {
protected:
- VP9EncodePerfTest()
+ AV1EncodePerfTest()
: EncoderTest(GET_PARAM(0)), min_psnr_(kMaxPsnr), nframes_(0),
encoding_mode_(GET_PARAM(1)), speed_(0), threads_(1) {}
- virtual ~VP9EncodePerfTest() {}
+ virtual ~AV1EncodePerfTest() {}
virtual void SetUp() {
InitializeConfig();
@@ -77,7 +77,7 @@
cfg_.rc_buf_initial_sz = 500;
cfg_.rc_buf_optimal_sz = 600;
cfg_.rc_resize_allowed = 0;
- cfg_.rc_end_usage = VPX_CBR;
+ cfg_.rc_end_usage = AOM_CBR;
cfg_.g_error_resilient = 1;
cfg_.g_threads = threads_;
}
@@ -86,10 +86,10 @@
::libaom_test::Encoder *encoder) {
if (video->frame() == 0) {
const int log2_tile_columns = 3;
- encoder->Control(VP8E_SET_CPUUSED, speed_);
- encoder->Control(VP9E_SET_TILE_COLUMNS, log2_tile_columns);
- encoder->Control(VP9E_SET_FRAME_PARALLEL_DECODING, 1);
- encoder->Control(VP8E_SET_ENABLEAUTOALTREF, 0);
+ encoder->Control(AOME_SET_CPUUSED, speed_);
+ encoder->Control(AV1E_SET_TILE_COLUMNS, log2_tile_columns);
+ encoder->Control(AV1E_SET_FRAME_PARALLEL_DECODING, 1);
+ encoder->Control(AOME_SET_ENABLEAUTOALTREF, 0);
}
}
@@ -98,7 +98,7 @@
nframes_ = 0;
}
- virtual void PSNRPktHook(const vpx_codec_cx_pkt_t *pkt) {
+ virtual void PSNRPktHook(const aom_codec_cx_pkt_t *pkt) {
if (pkt->data.psnr.psnr[0] < min_psnr_) {
min_psnr_ = pkt->data.psnr.psnr[0];
}
@@ -121,41 +121,41 @@
unsigned int threads_;
};
-TEST_P(VP9EncodePerfTest, PerfTest) {
- for (size_t i = 0; i < NELEMENTS(kVP9EncodePerfTestVectors); ++i) {
+TEST_P(AV1EncodePerfTest, PerfTest) {
+ for (size_t i = 0; i < NELEMENTS(kAV1EncodePerfTestVectors); ++i) {
for (size_t j = 0; j < NELEMENTS(kEncodePerfTestSpeeds); ++j) {
for (size_t k = 0; k < NELEMENTS(kEncodePerfTestThreads); ++k) {
- if (kVP9EncodePerfTestVectors[i].width < 512 &&
+ if (kAV1EncodePerfTestVectors[i].width < 512 &&
kEncodePerfTestThreads[k] > 1)
continue;
- else if (kVP9EncodePerfTestVectors[i].width < 1024 &&
+ else if (kAV1EncodePerfTestVectors[i].width < 1024 &&
kEncodePerfTestThreads[k] > 2)
continue;
set_threads(kEncodePerfTestThreads[k]);
SetUp();
- const vpx_rational timebase = { 33333333, 1000000000 };
+ const aom_rational timebase = { 33333333, 1000000000 };
cfg_.g_timebase = timebase;
- cfg_.rc_target_bitrate = kVP9EncodePerfTestVectors[i].bitrate;
+ cfg_.rc_target_bitrate = kAV1EncodePerfTestVectors[i].bitrate;
- init_flags_ = VPX_CODEC_USE_PSNR;
+ init_flags_ = AOM_CODEC_USE_PSNR;
- const unsigned frames = kVP9EncodePerfTestVectors[i].frames;
- const char *video_name = kVP9EncodePerfTestVectors[i].name;
+ const unsigned frames = kAV1EncodePerfTestVectors[i].frames;
+ const char *video_name = kAV1EncodePerfTestVectors[i].name;
libaom_test::I420VideoSource video(
- video_name, kVP9EncodePerfTestVectors[i].width,
- kVP9EncodePerfTestVectors[i].height, timebase.den, timebase.num, 0,
- kVP9EncodePerfTestVectors[i].frames);
+ video_name, kAV1EncodePerfTestVectors[i].width,
+ kAV1EncodePerfTestVectors[i].height, timebase.den, timebase.num, 0,
+ kAV1EncodePerfTestVectors[i].frames);
set_speed(kEncodePerfTestSpeeds[j]);
- vpx_usec_timer t;
- vpx_usec_timer_start(&t);
+ aom_usec_timer t;
+ aom_usec_timer_start(&t);
ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
- vpx_usec_timer_mark(&t);
- const double elapsed_secs = vpx_usec_timer_elapsed(&t) / kUsecsInSec;
+ aom_usec_timer_mark(&t);
+ const double elapsed_secs = aom_usec_timer_elapsed(&t) / kUsecsInSec;
const double fps = frames / elapsed_secs;
const double minimum_psnr = min_psnr();
std::string display_name(video_name);
@@ -182,6 +182,6 @@
}
}
-VP10_INSTANTIATE_TEST_CASE(VP9EncodePerfTest,
- ::testing::Values(::libaom_test::kRealTime));
+AV1_INSTANTIATE_TEST_CASE(AV1EncodePerfTest,
+ ::testing::Values(::libaom_test::kRealTime));
} // namespace
diff --git a/test/encode_test_driver.cc b/test/encode_test_driver.cc
index cb1df9b..915036f 100644
--- a/test/encode_test_driver.cc
+++ b/test/encode_test_driver.cc
@@ -12,7 +12,7 @@
#include "third_party/googletest/src/include/gtest/gtest.h"
-#include "./vpx_config.h"
+#include "./aom_config.h"
#include "aom_ports/mem.h"
#include "test/codec_factory.h"
#include "test/decode_test_driver.h"
@@ -22,8 +22,8 @@
namespace libaom_test {
void Encoder::InitEncoder(VideoSource *video) {
- vpx_codec_err_t res;
- const vpx_image_t *img = video->img();
+ aom_codec_err_t res;
+ const aom_image_t *img = video->img();
if (video->img() && !encoder_.priv) {
cfg_.g_w = img->d_w;
@@ -31,18 +31,18 @@
cfg_.g_timebase = video->timebase();
cfg_.rc_twopass_stats_in = stats_->buf();
- res = vpx_codec_enc_init(&encoder_, CodecInterface(), &cfg_, init_flags_);
- ASSERT_EQ(VPX_CODEC_OK, res) << EncoderError();
+ res = aom_codec_enc_init(&encoder_, CodecInterface(), &cfg_, init_flags_);
+ ASSERT_EQ(AOM_CODEC_OK, res) << EncoderError();
-#if CONFIG_VP10_ENCODER
- if (CodecInterface() == &vpx_codec_vp10_cx_algo) {
-// Default to 1 tile column for VP10. With CONFIG_EXT_TILE, the
+#if CONFIG_AV1_ENCODER
+ if (CodecInterface() == &aom_codec_av1_cx_algo) {
+// Default to 1 tile column for AV1. With CONFIG_EXT_TILE, the
// default is already the largest possible tile size
#if !CONFIG_EXT_TILE
const int log2_tile_columns = 0;
- res = vpx_codec_control_(&encoder_, VP9E_SET_TILE_COLUMNS,
+ res = aom_codec_control_(&encoder_, AV1E_SET_TILE_COLUMNS,
log2_tile_columns);
- ASSERT_EQ(VPX_CODEC_OK, res) << EncoderError();
+ ASSERT_EQ(AOM_CODEC_OK, res) << EncoderError();
#endif // !CONFIG_EXT_TILE
} else
#endif
@@ -60,8 +60,8 @@
// Handle twopass stats
CxDataIterator iter = GetCxData();
- while (const vpx_codec_cx_pkt_t *pkt = iter.Next()) {
- if (pkt->kind != VPX_CODEC_STATS_PKT) continue;
+ while (const aom_codec_cx_pkt_t *pkt = iter.Next()) {
+ if (pkt->kind != AOM_CODEC_STATS_PKT) continue;
stats_->Append(*pkt);
}
@@ -69,48 +69,48 @@
void Encoder::EncodeFrameInternal(const VideoSource &video,
const unsigned long frame_flags) {
- vpx_codec_err_t res;
- const vpx_image_t *img = video.img();
+ aom_codec_err_t res;
+ const aom_image_t *img = video.img();
// Handle frame resizing
if (cfg_.g_w != img->d_w || cfg_.g_h != img->d_h) {
cfg_.g_w = img->d_w;
cfg_.g_h = img->d_h;
- res = vpx_codec_enc_config_set(&encoder_, &cfg_);
- ASSERT_EQ(VPX_CODEC_OK, res) << EncoderError();
+ res = aom_codec_enc_config_set(&encoder_, &cfg_);
+ ASSERT_EQ(AOM_CODEC_OK, res) << EncoderError();
}
// Encode the frame
- API_REGISTER_STATE_CHECK(res = vpx_codec_encode(&encoder_, img, video.pts(),
+ API_REGISTER_STATE_CHECK(res = aom_codec_encode(&encoder_, img, video.pts(),
video.duration(), frame_flags,
deadline_));
- ASSERT_EQ(VPX_CODEC_OK, res) << EncoderError();
+ ASSERT_EQ(AOM_CODEC_OK, res) << EncoderError();
}
void Encoder::Flush() {
- const vpx_codec_err_t res =
- vpx_codec_encode(&encoder_, NULL, 0, 0, 0, deadline_);
+ const aom_codec_err_t res =
+ aom_codec_encode(&encoder_, NULL, 0, 0, 0, deadline_);
if (!encoder_.priv)
- ASSERT_EQ(VPX_CODEC_ERROR, res) << EncoderError();
+ ASSERT_EQ(AOM_CODEC_ERROR, res) << EncoderError();
else
- ASSERT_EQ(VPX_CODEC_OK, res) << EncoderError();
+ ASSERT_EQ(AOM_CODEC_OK, res) << EncoderError();
}
void EncoderTest::InitializeConfig() {
- const vpx_codec_err_t res = codec_->DefaultEncoderConfig(&cfg_, 0);
- dec_cfg_ = vpx_codec_dec_cfg_t();
- ASSERT_EQ(VPX_CODEC_OK, res);
+ const aom_codec_err_t res = codec_->DefaultEncoderConfig(&cfg_, 0);
+ dec_cfg_ = aom_codec_dec_cfg_t();
+ ASSERT_EQ(AOM_CODEC_OK, res);
}
void EncoderTest::SetMode(TestMode mode) {
switch (mode) {
- case kRealTime: deadline_ = VPX_DL_REALTIME; break;
+ case kRealTime: deadline_ = AOM_DL_REALTIME; break;
case kOnePassGood:
- case kTwoPassGood: deadline_ = VPX_DL_GOOD_QUALITY; break;
+ case kTwoPassGood: deadline_ = AOM_DL_GOOD_QUALITY; break;
case kOnePassBest:
- case kTwoPassBest: deadline_ = VPX_DL_BEST_QUALITY; break;
+ case kTwoPassBest: deadline_ = AOM_DL_BEST_QUALITY; break;
default: ASSERT_TRUE(false) << "Unexpected mode " << mode;
}
@@ -148,7 +148,7 @@
// The function should return "true" most of the time, therefore no early
// break-out is implemented within the match checking process.
-static bool compare_img(const vpx_image_t *img1, const vpx_image_t *img2,
+static bool compare_img(const aom_image_t *img1, const aom_image_t *img2,
int *const mismatch_row, int *const mismatch_col,
int *const mismatch_plane, int *const mismatch_pix1,
int *const mismatch_pix2) {
@@ -164,35 +164,35 @@
return false;
}
- if (!compare_plane(img1->planes[VPX_PLANE_Y], img1->stride[VPX_PLANE_Y],
- img2->planes[VPX_PLANE_Y], img2->stride[VPX_PLANE_Y], w_y,
+ if (!compare_plane(img1->planes[AOM_PLANE_Y], img1->stride[AOM_PLANE_Y],
+ img2->planes[AOM_PLANE_Y], img2->stride[AOM_PLANE_Y], w_y,
h_y, mismatch_row, mismatch_col, mismatch_pix1,
mismatch_pix2)) {
- if (mismatch_plane != NULL) *mismatch_plane = VPX_PLANE_Y;
+ if (mismatch_plane != NULL) *mismatch_plane = AOM_PLANE_Y;
return false;
}
- if (!compare_plane(img1->planes[VPX_PLANE_U], img1->stride[VPX_PLANE_U],
- img2->planes[VPX_PLANE_U], img2->stride[VPX_PLANE_U], w_uv,
+ if (!compare_plane(img1->planes[AOM_PLANE_U], img1->stride[AOM_PLANE_U],
+ img2->planes[AOM_PLANE_U], img2->stride[AOM_PLANE_U], w_uv,
h_uv, mismatch_row, mismatch_col, mismatch_pix1,
mismatch_pix2)) {
- if (mismatch_plane != NULL) *mismatch_plane = VPX_PLANE_U;
+ if (mismatch_plane != NULL) *mismatch_plane = AOM_PLANE_U;
return false;
}
- if (!compare_plane(img1->planes[VPX_PLANE_V], img1->stride[VPX_PLANE_V],
- img2->planes[VPX_PLANE_V], img2->stride[VPX_PLANE_V], w_uv,
+ if (!compare_plane(img1->planes[AOM_PLANE_V], img1->stride[AOM_PLANE_V],
+ img2->planes[AOM_PLANE_V], img2->stride[AOM_PLANE_V], w_uv,
h_uv, mismatch_row, mismatch_col, mismatch_pix1,
mismatch_pix2)) {
- if (mismatch_plane != NULL) *mismatch_plane = VPX_PLANE_U;
+ if (mismatch_plane != NULL) *mismatch_plane = AOM_PLANE_U;
return false;
}
return true;
}
-void EncoderTest::MismatchHook(const vpx_image_t *img_enc,
- const vpx_image_t *img_dec) {
+void EncoderTest::MismatchHook(const aom_image_t *img_enc,
+ const aom_image_t *img_dec) {
int mismatch_row = 0;
int mismatch_col = 0;
int mismatch_plane = 0;
@@ -212,7 +212,7 @@
}
void EncoderTest::RunLoop(VideoSource *video) {
- vpx_codec_dec_cfg_t dec_cfg = vpx_codec_dec_cfg_t();
+ aom_codec_dec_cfg_t dec_cfg = aom_codec_dec_cfg_t();
stats_.Reset();
@@ -221,11 +221,11 @@
last_pts_ = 0;
if (passes_ == 1)
- cfg_.g_pass = VPX_RC_ONE_PASS;
+ cfg_.g_pass = AOM_RC_ONE_PASS;
else if (pass == 0)
- cfg_.g_pass = VPX_RC_FIRST_PASS;
+ cfg_.g_pass = AOM_RC_FIRST_PASS;
else
- cfg_.g_pass = VPX_RC_LAST_PASS;
+ cfg_.g_pass = AOM_RC_LAST_PASS;
BeginPassHook(pass);
testing::internal::scoped_ptr<Encoder> encoder(
@@ -239,16 +239,16 @@
unsigned long dec_init_flags = 0; // NOLINT
// Use fragment decoder if encoder outputs partitions.
// NOTE: fragment decoder and partition encoder are only supported by VP8.
- if (init_flags_ & VPX_CODEC_USE_OUTPUT_PARTITION)
- dec_init_flags |= VPX_CODEC_USE_INPUT_FRAGMENTS;
+ if (init_flags_ & AOM_CODEC_USE_OUTPUT_PARTITION)
+ dec_init_flags |= AOM_CODEC_USE_INPUT_FRAGMENTS;
testing::internal::scoped_ptr<Decoder> decoder(
codec_->CreateDecoder(dec_cfg, dec_init_flags, 0));
-#if CONFIG_VP10 && CONFIG_EXT_TILE
- if (decoder->IsVP10()) {
+#if CONFIG_AV1 && CONFIG_EXT_TILE
+ if (decoder->IsAV1()) {
// Set dec_cfg.tile_row = -1 and dec_cfg.tile_col = -1 so that the whole
// frame is decoded.
- decoder->Control(VP10_SET_DECODE_TILE_ROW, -1);
- decoder->Control(VP10_SET_DECODE_TILE_COL, -1);
+ decoder->Control(AV1_SET_DECODE_TILE_ROW, -1);
+ decoder->Control(AV1_SET_DECODE_TILE_COL, -1);
}
#endif
@@ -264,14 +264,14 @@
bool has_cxdata = false;
bool has_dxdata = false;
- while (const vpx_codec_cx_pkt_t *pkt = iter.Next()) {
+ while (const aom_codec_cx_pkt_t *pkt = iter.Next()) {
pkt = MutateEncoderOutputHook(pkt);
again = true;
switch (pkt->kind) {
- case VPX_CODEC_CX_FRAME_PKT:
+ case AOM_CODEC_CX_FRAME_PKT:
has_cxdata = true;
if (decoder.get() != NULL && DoDecode()) {
- vpx_codec_err_t res_dec = decoder->DecodeFrame(
+ aom_codec_err_t res_dec = decoder->DecodeFrame(
(const uint8_t *)pkt->data.frame.buf, pkt->data.frame.sz);
if (!HandleDecodeResult(res_dec, *video, decoder.get())) break;
@@ -283,22 +283,22 @@
FramePktHook(pkt);
break;
- case VPX_CODEC_PSNR_PKT: PSNRPktHook(pkt); break;
+ case AOM_CODEC_PSNR_PKT: PSNRPktHook(pkt); break;
default: break;
}
}
// Flush the decoder when there are no more fragments.
- if ((init_flags_ & VPX_CODEC_USE_OUTPUT_PARTITION) && has_dxdata) {
- const vpx_codec_err_t res_dec = decoder->DecodeFrame(NULL, 0);
+ if ((init_flags_ & AOM_CODEC_USE_OUTPUT_PARTITION) && has_dxdata) {
+ const aom_codec_err_t res_dec = decoder->DecodeFrame(NULL, 0);
if (!HandleDecodeResult(res_dec, *video, decoder.get())) break;
}
if (has_dxdata && has_cxdata) {
- const vpx_image_t *img_enc = encoder->GetPreviewFrame();
+ const aom_image_t *img_enc = encoder->GetPreviewFrame();
DxDataIterator dec_iter = decoder->GetDxData();
- const vpx_image_t *img_dec = dec_iter.Next();
+ const aom_image_t *img_dec = dec_iter.Next();
if (img_enc && img_dec) {
const bool res =
compare_img(img_enc, img_dec, NULL, NULL, NULL, NULL, NULL);
diff --git a/test/encode_test_driver.h b/test/encode_test_driver.h
index 5762be5..f74faf8 100644
--- a/test/encode_test_driver.h
+++ b/test/encode_test_driver.h
@@ -15,11 +15,11 @@
#include "third_party/googletest/src/include/gtest/gtest.h"
-#include "./vpx_config.h"
-#if CONFIG_VP10_ENCODER
-#include "aom/vp8cx.h"
+#include "./aom_config.h"
+#if CONFIG_AV1_ENCODER
+#include "aom/aomcx.h"
#endif
-#include "aom/vpx_encoder.h"
+#include "aom/aom_encoder.h"
namespace libaom_test {
@@ -48,28 +48,28 @@
// Provides an object to handle the libaom get_cx_data() iteration pattern
class CxDataIterator {
public:
- explicit CxDataIterator(vpx_codec_ctx_t *encoder)
+ explicit CxDataIterator(aom_codec_ctx_t *encoder)
: encoder_(encoder), iter_(NULL) {}
- const vpx_codec_cx_pkt_t *Next() {
- return vpx_codec_get_cx_data(encoder_, &iter_);
+ const aom_codec_cx_pkt_t *Next() {
+ return aom_codec_get_cx_data(encoder_, &iter_);
}
private:
- vpx_codec_ctx_t *encoder_;
- vpx_codec_iter_t iter_;
+ aom_codec_ctx_t *encoder_;
+ aom_codec_iter_t iter_;
};
// Implements an in-memory store for libaom twopass statistics
class TwopassStatsStore {
public:
- void Append(const vpx_codec_cx_pkt_t &pkt) {
+ void Append(const aom_codec_cx_pkt_t &pkt) {
buffer_.append(reinterpret_cast<char *>(pkt.data.twopass_stats.buf),
pkt.data.twopass_stats.sz);
}
- vpx_fixed_buf_t buf() {
- const vpx_fixed_buf_t buf = { &buffer_[0], buffer_.size() };
+ aom_fixed_buf_t buf() {
+ const aom_fixed_buf_t buf = { &buffer_[0], buffer_.size() };
return buf;
}
@@ -86,64 +86,64 @@
// level of abstraction will be fleshed out as more tests are written.
class Encoder {
public:
- Encoder(vpx_codec_enc_cfg_t cfg, unsigned long deadline,
+ Encoder(aom_codec_enc_cfg_t cfg, unsigned long deadline,
const unsigned long init_flags, TwopassStatsStore *stats)
: cfg_(cfg), deadline_(deadline), init_flags_(init_flags), stats_(stats) {
memset(&encoder_, 0, sizeof(encoder_));
}
- virtual ~Encoder() { vpx_codec_destroy(&encoder_); }
+ virtual ~Encoder() { aom_codec_destroy(&encoder_); }
CxDataIterator GetCxData() { return CxDataIterator(&encoder_); }
void InitEncoder(VideoSource *video);
- const vpx_image_t *GetPreviewFrame() {
- return vpx_codec_get_preview_frame(&encoder_);
+ const aom_image_t *GetPreviewFrame() {
+ return aom_codec_get_preview_frame(&encoder_);
}
- // This is a thin wrapper around vpx_codec_encode(), so refer to
- // vpx_encoder.h for its semantics.
+ // This is a thin wrapper around aom_codec_encode(), so refer to
+ // aom_encoder.h for its semantics.
void EncodeFrame(VideoSource *video, const unsigned long frame_flags);
// Convenience wrapper for EncodeFrame()
void EncodeFrame(VideoSource *video) { EncodeFrame(video, 0); }
void Control(int ctrl_id, int arg) {
- const vpx_codec_err_t res = vpx_codec_control_(&encoder_, ctrl_id, arg);
- ASSERT_EQ(VPX_CODEC_OK, res) << EncoderError();
+ const aom_codec_err_t res = aom_codec_control_(&encoder_, ctrl_id, arg);
+ ASSERT_EQ(AOM_CODEC_OK, res) << EncoderError();
}
void Control(int ctrl_id, int *arg) {
- const vpx_codec_err_t res = vpx_codec_control_(&encoder_, ctrl_id, arg);
- ASSERT_EQ(VPX_CODEC_OK, res) << EncoderError();
+ const aom_codec_err_t res = aom_codec_control_(&encoder_, ctrl_id, arg);
+ ASSERT_EQ(AOM_CODEC_OK, res) << EncoderError();
}
- void Control(int ctrl_id, struct vpx_scaling_mode *arg) {
- const vpx_codec_err_t res = vpx_codec_control_(&encoder_, ctrl_id, arg);
- ASSERT_EQ(VPX_CODEC_OK, res) << EncoderError();
+ void Control(int ctrl_id, struct aom_scaling_mode *arg) {
+ const aom_codec_err_t res = aom_codec_control_(&encoder_, ctrl_id, arg);
+ ASSERT_EQ(AOM_CODEC_OK, res) << EncoderError();
}
-#if CONFIG_VP10_ENCODER
- void Control(int ctrl_id, vpx_active_map_t *arg) {
- const vpx_codec_err_t res = vpx_codec_control_(&encoder_, ctrl_id, arg);
- ASSERT_EQ(VPX_CODEC_OK, res) << EncoderError();
+#if CONFIG_AV1_ENCODER
+ void Control(int ctrl_id, aom_active_map_t *arg) {
+ const aom_codec_err_t res = aom_codec_control_(&encoder_, ctrl_id, arg);
+ ASSERT_EQ(AOM_CODEC_OK, res) << EncoderError();
}
#endif
- void Config(const vpx_codec_enc_cfg_t *cfg) {
- const vpx_codec_err_t res = vpx_codec_enc_config_set(&encoder_, cfg);
- ASSERT_EQ(VPX_CODEC_OK, res) << EncoderError();
+ void Config(const aom_codec_enc_cfg_t *cfg) {
+ const aom_codec_err_t res = aom_codec_enc_config_set(&encoder_, cfg);
+ ASSERT_EQ(AOM_CODEC_OK, res) << EncoderError();
cfg_ = *cfg;
}
void set_deadline(unsigned long deadline) { deadline_ = deadline; }
protected:
- virtual vpx_codec_iface_t *CodecInterface() const = 0;
+ virtual aom_codec_iface_t *CodecInterface() const = 0;
const char *EncoderError() {
- const char *detail = vpx_codec_error_detail(&encoder_);
- return detail ? detail : vpx_codec_error(&encoder_);
+ const char *detail = aom_codec_error_detail(&encoder_);
+ return detail ? detail : aom_codec_error(&encoder_);
}
// Encode an image
@@ -153,8 +153,8 @@
// Flush the encoder on EOS
void Flush();
- vpx_codec_ctx_t encoder_;
- vpx_codec_enc_cfg_t cfg_;
+ aom_codec_ctx_t encoder_;
+ aom_codec_enc_cfg_t cfg_;
unsigned long deadline_;
unsigned long init_flags_;
TwopassStatsStore *stats_;
@@ -204,10 +204,10 @@
Encoder * /*encoder*/) {}
// Hook to be called on every compressed data packet.
- virtual void FramePktHook(const vpx_codec_cx_pkt_t * /*pkt*/) {}
+ virtual void FramePktHook(const aom_codec_cx_pkt_t * /*pkt*/) {}
// Hook to be called on every PSNR packet.
- virtual void PSNRPktHook(const vpx_codec_cx_pkt_t * /*pkt*/) {}
+ virtual void PSNRPktHook(const aom_codec_cx_pkt_t * /*pkt*/) {}
// Hook to determine whether the encode loop should continue.
virtual bool Continue() const {
@@ -219,35 +219,35 @@
virtual bool DoDecode() const { return 1; }
// Hook to handle encode/decode mismatch
- virtual void MismatchHook(const vpx_image_t *img1, const vpx_image_t *img2);
+ virtual void MismatchHook(const aom_image_t *img1, const aom_image_t *img2);
// Hook to be called on every decompressed frame.
- virtual void DecompressedFrameHook(const vpx_image_t & /*img*/,
- vpx_codec_pts_t /*pts*/) {}
+ virtual void DecompressedFrameHook(const aom_image_t & /*img*/,
+ aom_codec_pts_t /*pts*/) {}
// Hook to be called to handle decode result. Return true to continue.
- virtual bool HandleDecodeResult(const vpx_codec_err_t res_dec,
+ virtual bool HandleDecodeResult(const aom_codec_err_t res_dec,
const VideoSource & /*video*/,
Decoder *decoder) {
- EXPECT_EQ(VPX_CODEC_OK, res_dec) << decoder->DecodeError();
- return VPX_CODEC_OK == res_dec;
+ EXPECT_EQ(AOM_CODEC_OK, res_dec) << decoder->DecodeError();
+ return AOM_CODEC_OK == res_dec;
}
// Hook that can modify the encoder's output data
- virtual const vpx_codec_cx_pkt_t *MutateEncoderOutputHook(
- const vpx_codec_cx_pkt_t *pkt) {
+ virtual const aom_codec_cx_pkt_t *MutateEncoderOutputHook(
+ const aom_codec_cx_pkt_t *pkt) {
return pkt;
}
bool abort_;
- vpx_codec_enc_cfg_t cfg_;
- vpx_codec_dec_cfg_t dec_cfg_;
+ aom_codec_enc_cfg_t cfg_;
+ aom_codec_dec_cfg_t dec_cfg_;
unsigned int passes_;
unsigned long deadline_;
TwopassStatsStore stats_;
unsigned long init_flags_;
unsigned long frame_flags_;
- vpx_codec_pts_t last_pts_;
+ aom_codec_pts_t last_pts_;
};
} // namespace libaom_test
diff --git a/test/encoder_parms_get_to_decoder.cc b/test/encoder_parms_get_to_decoder.cc
index e2fe537..5d44290 100644
--- a/test/encoder_parms_get_to_decoder.cc
+++ b/test/encoder_parms_get_to_decoder.cc
@@ -14,7 +14,7 @@
#include "test/encode_test_driver.h"
#include "test/util.h"
#include "test/y4m_video_source.h"
-#include "av1/vp10_dx_iface.c"
+#include "av1/av1_dx_iface.c"
namespace {
@@ -28,7 +28,7 @@
int frames;
};
-const EncodePerfTestVideo kVP9EncodePerfTestVectors[] = {
+const EncodePerfTestVideo kAV1EncodePerfTestVectors[] = {
{ "niklas_1280_720_30.y4m", 1280, 720, 600, 10 },
};
@@ -38,29 +38,29 @@
int32_t lossless;
int32_t error_resilient;
int32_t frame_parallel;
- vpx_color_range_t color_range;
- vpx_color_space_t cs;
+ aom_color_range_t color_range;
+ aom_color_space_t cs;
int render_size[2];
// TODO(JBB): quantizers / bitrate
};
-const EncodeParameters kVP9EncodeParameterSet[] = {
- { 0, 0, 0, 1, 0, VPX_CR_STUDIO_RANGE, VPX_CS_BT_601, { 0, 0 } },
- { 0, 0, 0, 0, 0, VPX_CR_FULL_RANGE, VPX_CS_BT_709, { 0, 0 } },
- { 0, 0, 1, 0, 0, VPX_CR_FULL_RANGE, VPX_CS_BT_2020, { 0, 0 } },
- { 0, 2, 0, 0, 1, VPX_CR_STUDIO_RANGE, VPX_CS_UNKNOWN, { 640, 480 } },
+const EncodeParameters kAV1EncodeParameterSet[] = {
+ { 0, 0, 0, 1, 0, AOM_CR_STUDIO_RANGE, AOM_CS_BT_601, { 0, 0 } },
+ { 0, 0, 0, 0, 0, AOM_CR_FULL_RANGE, AOM_CS_BT_709, { 0, 0 } },
+ { 0, 0, 1, 0, 0, AOM_CR_FULL_RANGE, AOM_CS_BT_2020, { 0, 0 } },
+ { 0, 2, 0, 0, 1, AOM_CR_STUDIO_RANGE, AOM_CS_UNKNOWN, { 640, 480 } },
// TODO(JBB): Test profiles (requires more work).
};
-class VpxEncoderParmsGetToDecoder
+class AvxEncoderParmsGetToDecoder
: public ::libaom_test::EncoderTest,
public ::libaom_test::CodecTestWith2Params<EncodeParameters,
EncodePerfTestVideo> {
protected:
- VpxEncoderParmsGetToDecoder()
+ AvxEncoderParmsGetToDecoder()
: EncoderTest(GET_PARAM(0)), encode_parms(GET_PARAM(1)) {}
- virtual ~VpxEncoderParmsGetToDecoder() {}
+ virtual ~AvxEncoderParmsGetToDecoder() {}
virtual void SetUp() {
InitializeConfig();
@@ -75,32 +75,32 @@
virtual void PreEncodeFrameHook(::libaom_test::VideoSource *video,
::libaom_test::Encoder *encoder) {
if (video->frame() == 1) {
- encoder->Control(VP9E_SET_COLOR_SPACE, encode_parms.cs);
- encoder->Control(VP9E_SET_COLOR_RANGE, encode_parms.color_range);
- encoder->Control(VP9E_SET_LOSSLESS, encode_parms.lossless);
- encoder->Control(VP9E_SET_FRAME_PARALLEL_DECODING,
+ encoder->Control(AV1E_SET_COLOR_SPACE, encode_parms.cs);
+ encoder->Control(AV1E_SET_COLOR_RANGE, encode_parms.color_range);
+ encoder->Control(AV1E_SET_LOSSLESS, encode_parms.lossless);
+ encoder->Control(AV1E_SET_FRAME_PARALLEL_DECODING,
encode_parms.frame_parallel);
- encoder->Control(VP9E_SET_TILE_ROWS, encode_parms.tile_rows);
- encoder->Control(VP9E_SET_TILE_COLUMNS, encode_parms.tile_cols);
- encoder->Control(VP8E_SET_CPUUSED, kCpuUsed);
- encoder->Control(VP8E_SET_ENABLEAUTOALTREF, 1);
- encoder->Control(VP8E_SET_ARNR_MAXFRAMES, 7);
- encoder->Control(VP8E_SET_ARNR_STRENGTH, 5);
- encoder->Control(VP8E_SET_ARNR_TYPE, 3);
+ encoder->Control(AV1E_SET_TILE_ROWS, encode_parms.tile_rows);
+ encoder->Control(AV1E_SET_TILE_COLUMNS, encode_parms.tile_cols);
+ encoder->Control(AOME_SET_CPUUSED, kCpuUsed);
+ encoder->Control(AOME_SET_ENABLEAUTOALTREF, 1);
+ encoder->Control(AOME_SET_ARNR_MAXFRAMES, 7);
+ encoder->Control(AOME_SET_ARNR_STRENGTH, 5);
+ encoder->Control(AOME_SET_ARNR_TYPE, 3);
if (encode_parms.render_size[0] > 0 && encode_parms.render_size[1] > 0)
- encoder->Control(VP9E_SET_RENDER_SIZE, encode_parms.render_size);
+ encoder->Control(AV1E_SET_RENDER_SIZE, encode_parms.render_size);
}
}
- virtual bool HandleDecodeResult(const vpx_codec_err_t res_dec,
+ virtual bool HandleDecodeResult(const aom_codec_err_t res_dec,
const libaom_test::VideoSource & /*video*/,
libaom_test::Decoder *decoder) {
- vpx_codec_ctx_t *const vp9_decoder = decoder->GetDecoder();
- vpx_codec_alg_priv_t *const priv =
- reinterpret_cast<vpx_codec_alg_priv_t *>(vp9_decoder->priv);
+ aom_codec_ctx_t *const av1_decoder = decoder->GetDecoder();
+ aom_codec_alg_priv_t *const priv =
+ reinterpret_cast<aom_codec_alg_priv_t *>(av1_decoder->priv);
FrameWorkerData *const worker_data =
reinterpret_cast<FrameWorkerData *>(priv->frame_workers[0].data1);
- VP10_COMMON *const common = &worker_data->pbi->common;
+ AV1_COMMON *const common = &worker_data->pbi->common;
if (encode_parms.lossless) {
EXPECT_EQ(0, common->base_qindex);
@@ -122,8 +122,8 @@
EXPECT_EQ(encode_parms.tile_cols, common->log2_tile_cols);
EXPECT_EQ(encode_parms.tile_rows, common->log2_tile_rows);
- EXPECT_EQ(VPX_CODEC_OK, res_dec) << decoder->DecodeError();
- return VPX_CODEC_OK == res_dec;
+ EXPECT_EQ(AOM_CODEC_OK, res_dec) << decoder->DecodeError();
+ return AOM_CODEC_OK == res_dec;
}
EncodePerfTestVideo test_video_;
@@ -132,8 +132,8 @@
EncodeParameters encode_parms;
};
-TEST_P(VpxEncoderParmsGetToDecoder, BitstreamParms) {
- init_flags_ = VPX_CODEC_USE_PSNR;
+TEST_P(AvxEncoderParmsGetToDecoder, BitstreamParms) {
+ init_flags_ = AOM_CODEC_USE_PSNR;
libaom_test::VideoSource *const video =
new libaom_test::Y4mVideoSource(test_video_.name, 0, test_video_.frames);
@@ -143,7 +143,7 @@
delete video;
}
-VP10_INSTANTIATE_TEST_CASE(VpxEncoderParmsGetToDecoder,
- ::testing::ValuesIn(kVP9EncodeParameterSet),
- ::testing::ValuesIn(kVP9EncodePerfTestVectors));
+AV1_INSTANTIATE_TEST_CASE(AvxEncoderParmsGetToDecoder,
+ ::testing::ValuesIn(kAV1EncodeParameterSet),
+ ::testing::ValuesIn(kAV1EncodePerfTestVectors));
} // namespace
diff --git a/test/end_to_end_test.cc b/test/end_to_end_test.cc
index 693df78..dfcc015 100644
--- a/test/end_to_end_test.cc
+++ b/test/end_to_end_test.cc
@@ -26,10 +26,10 @@
// List of psnr thresholds for speed settings 0-7 and 5 encoding modes
const double kPsnrThreshold[][5] = {
// Note:
-// VP10 HBD average PSNR is slightly lower than VP9.
+// AV1 HBD average PSNR is slightly lower than AV1.
// We make two cases here to enable the testing and
// guard picture quality.
-#if CONFIG_VP10_ENCODER && CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AV1_ENCODER && CONFIG_AOM_HIGHBITDEPTH
{ 36.0, 37.0, 37.0, 37.0, 37.0 }, { 31.0, 36.0, 36.0, 36.0, 36.0 },
{ 31.0, 35.0, 35.0, 35.0, 35.0 }, { 31.0, 34.0, 34.0, 34.0, 34.0 },
{ 31.0, 33.0, 33.0, 33.0, 33.0 }, { 31.0, 32.0, 32.0, 32.0, 32.0 },
@@ -39,32 +39,32 @@
{ 34.0, 35.0, 35.0, 35.0, 35.0 }, { 33.0, 34.0, 34.0, 34.0, 34.0 },
{ 32.0, 33.0, 33.0, 33.0, 33.0 }, { 31.0, 32.0, 32.0, 32.0, 32.0 },
{ 30.0, 31.0, 31.0, 31.0, 31.0 }, { 29.0, 30.0, 30.0, 30.0, 30.0 },
-#endif // CONFIG_VP9_HIGHBITDEPTH && CONFIG_VP10_ENCODER
+#endif // CONFIG_AOM_HIGHBITDEPTH && CONFIG_AV1_ENCODER
};
typedef struct {
const char *filename;
unsigned int input_bit_depth;
- vpx_img_fmt fmt;
- vpx_bit_depth_t bit_depth;
+ aom_img_fmt fmt;
+ aom_bit_depth_t bit_depth;
unsigned int profile;
} TestVideoParam;
const TestVideoParam kTestVectors[] = {
- { "park_joy_90p_8_420.y4m", 8, VPX_IMG_FMT_I420, VPX_BITS_8, 0 },
- { "park_joy_90p_8_422.y4m", 8, VPX_IMG_FMT_I422, VPX_BITS_8, 1 },
- { "park_joy_90p_8_444.y4m", 8, VPX_IMG_FMT_I444, VPX_BITS_8, 1 },
- { "park_joy_90p_8_440.yuv", 8, VPX_IMG_FMT_I440, VPX_BITS_8, 1 },
-#if CONFIG_VP9_HIGHBITDEPTH
- { "park_joy_90p_10_420.y4m", 10, VPX_IMG_FMT_I42016, VPX_BITS_10, 2 },
- { "park_joy_90p_10_422.y4m", 10, VPX_IMG_FMT_I42216, VPX_BITS_10, 3 },
- { "park_joy_90p_10_444.y4m", 10, VPX_IMG_FMT_I44416, VPX_BITS_10, 3 },
- { "park_joy_90p_10_440.yuv", 10, VPX_IMG_FMT_I44016, VPX_BITS_10, 3 },
- { "park_joy_90p_12_420.y4m", 12, VPX_IMG_FMT_I42016, VPX_BITS_12, 2 },
- { "park_joy_90p_12_422.y4m", 12, VPX_IMG_FMT_I42216, VPX_BITS_12, 3 },
- { "park_joy_90p_12_444.y4m", 12, VPX_IMG_FMT_I44416, VPX_BITS_12, 3 },
- { "park_joy_90p_12_440.yuv", 12, VPX_IMG_FMT_I44016, VPX_BITS_12, 3 },
-#endif // CONFIG_VP9_HIGHBITDEPTH
+ { "park_joy_90p_8_420.y4m", 8, AOM_IMG_FMT_I420, AOM_BITS_8, 0 },
+ { "park_joy_90p_8_422.y4m", 8, AOM_IMG_FMT_I422, AOM_BITS_8, 1 },
+ { "park_joy_90p_8_444.y4m", 8, AOM_IMG_FMT_I444, AOM_BITS_8, 1 },
+ { "park_joy_90p_8_440.yuv", 8, AOM_IMG_FMT_I440, AOM_BITS_8, 1 },
+#if CONFIG_AOM_HIGHBITDEPTH
+ { "park_joy_90p_10_420.y4m", 10, AOM_IMG_FMT_I42016, AOM_BITS_10, 2 },
+ { "park_joy_90p_10_422.y4m", 10, AOM_IMG_FMT_I42216, AOM_BITS_10, 3 },
+ { "park_joy_90p_10_444.y4m", 10, AOM_IMG_FMT_I44416, AOM_BITS_10, 3 },
+ { "park_joy_90p_10_440.yuv", 10, AOM_IMG_FMT_I44016, AOM_BITS_10, 3 },
+ { "park_joy_90p_12_420.y4m", 12, AOM_IMG_FMT_I42016, AOM_BITS_12, 2 },
+ { "park_joy_90p_12_422.y4m", 12, AOM_IMG_FMT_I42216, AOM_BITS_12, 3 },
+ { "park_joy_90p_12_444.y4m", 12, AOM_IMG_FMT_I44416, AOM_BITS_12, 3 },
+ { "park_joy_90p_12_440.yuv", 12, AOM_IMG_FMT_I44016, AOM_BITS_12, 3 },
+#endif // CONFIG_AOM_HIGHBITDEPTH
};
// Encoding modes tested
@@ -101,10 +101,10 @@
SetMode(encoding_mode_);
if (encoding_mode_ != ::libaom_test::kRealTime) {
cfg_.g_lag_in_frames = 5;
- cfg_.rc_end_usage = VPX_VBR;
+ cfg_.rc_end_usage = AOM_VBR;
} else {
cfg_.g_lag_in_frames = 0;
- cfg_.rc_end_usage = VPX_CBR;
+ cfg_.rc_end_usage = AOM_CBR;
cfg_.rc_buf_sz = 1000;
cfg_.rc_buf_initial_sz = 500;
cfg_.rc_buf_optimal_sz = 600;
@@ -117,7 +117,7 @@
nframes_ = 0;
}
- virtual void PSNRPktHook(const vpx_codec_cx_pkt_t *pkt) {
+ virtual void PSNRPktHook(const aom_codec_cx_pkt_t *pkt) {
psnr_ += pkt->data.psnr.psnr[0];
nframes_++;
}
@@ -125,19 +125,19 @@
virtual void PreEncodeFrameHook(::libaom_test::VideoSource *video,
::libaom_test::Encoder *encoder) {
if (video->frame() == 1) {
- encoder->Control(VP9E_SET_FRAME_PARALLEL_DECODING, 1);
- encoder->Control(VP9E_SET_TILE_COLUMNS, 4);
- encoder->Control(VP8E_SET_CPUUSED, cpu_used_);
+ encoder->Control(AV1E_SET_FRAME_PARALLEL_DECODING, 1);
+ encoder->Control(AV1E_SET_TILE_COLUMNS, 4);
+ encoder->Control(AOME_SET_CPUUSED, cpu_used_);
// Test screen coding tools at cpu_used = 1 && encoding mode is two-pass.
if (cpu_used_ == 1 && encoding_mode_ == ::libaom_test::kTwoPassGood)
- encoder->Control(VP9E_SET_TUNE_CONTENT, VPX_CONTENT_SCREEN);
+ encoder->Control(AV1E_SET_TUNE_CONTENT, AOM_CONTENT_SCREEN);
else
- encoder->Control(VP9E_SET_TUNE_CONTENT, VPX_CONTENT_DEFAULT);
+ encoder->Control(AV1E_SET_TUNE_CONTENT, AOM_CONTENT_DEFAULT);
if (encoding_mode_ != ::libaom_test::kRealTime) {
- encoder->Control(VP8E_SET_ENABLEAUTOALTREF, 1);
- encoder->Control(VP8E_SET_ARNR_MAXFRAMES, 7);
- encoder->Control(VP8E_SET_ARNR_STRENGTH, 5);
- encoder->Control(VP8E_SET_ARNR_TYPE, 3);
+ encoder->Control(AOME_SET_ENABLEAUTOALTREF, 1);
+ encoder->Control(AOME_SET_ARNR_MAXFRAMES, 7);
+ encoder->Control(AOME_SET_ARNR_STRENGTH, 5);
+ encoder->Control(AOME_SET_ARNR_TYPE, 3);
}
}
}
@@ -166,8 +166,8 @@
cfg_.g_profile = test_video_param_.profile;
cfg_.g_input_bit_depth = test_video_param_.input_bit_depth;
cfg_.g_bit_depth = test_video_param_.bit_depth;
- init_flags_ = VPX_CODEC_USE_PSNR;
- if (cfg_.g_bit_depth > 8) init_flags_ |= VPX_CODEC_USE_HIGHBITDEPTH;
+ init_flags_ = AOM_CODEC_USE_PSNR;
+ if (cfg_.g_bit_depth > 8) init_flags_ |= AOM_CODEC_USE_HIGHBITDEPTH;
libaom_test::VideoSource *video;
if (is_extension_y4m(test_video_param_.filename)) {
@@ -185,8 +185,8 @@
delete (video);
}
-VP10_INSTANTIATE_TEST_CASE(EndToEndTestLarge,
- ::testing::ValuesIn(kEncodingModeVectors),
- ::testing::ValuesIn(kTestVectors),
- ::testing::ValuesIn(kCpuUsedVectors));
+AV1_INSTANTIATE_TEST_CASE(EndToEndTestLarge,
+ ::testing::ValuesIn(kEncodingModeVectors),
+ ::testing::ValuesIn(kTestVectors),
+ ::testing::ValuesIn(kCpuUsedVectors));
} // namespace
diff --git a/test/error_block_test.cc b/test/error_block_test.cc
index 8047e3d..05e643a 100644
--- a/test/error_block_test.cc
+++ b/test/error_block_test.cc
@@ -14,27 +14,27 @@
#include "third_party/googletest/src/include/gtest/gtest.h"
-#include "./vpx_config.h"
-#include "./vp10_rtcd.h"
+#include "./aom_config.h"
+#include "./av1_rtcd.h"
#include "test/acm_random.h"
#include "test/clear_system_state.h"
#include "test/register_state_check.h"
#include "test/util.h"
#include "av1/common/entropy.h"
-#include "aom/vpx_codec.h"
-#include "aom/vpx_integer.h"
+#include "aom/aom_codec.h"
+#include "aom/aom_integer.h"
using libaom_test::ACMRandom;
namespace {
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
const int kNumIterations = 1000;
typedef int64_t (*ErrorBlockFunc)(const tran_low_t *coeff,
const tran_low_t *dqcoeff,
intptr_t block_size, int64_t *ssz, int bps);
-typedef std::tr1::tuple<ErrorBlockFunc, ErrorBlockFunc, vpx_bit_depth_t>
+typedef std::tr1::tuple<ErrorBlockFunc, ErrorBlockFunc, aom_bit_depth_t>
ErrorBlockParam;
class ErrorBlockTest : public ::testing::TestWithParam<ErrorBlockParam> {
@@ -49,7 +49,7 @@
virtual void TearDown() { libaom_test::ClearSystemState(); }
protected:
- vpx_bit_depth_t bit_depth_;
+ aom_bit_depth_t bit_depth_;
ErrorBlockFunc error_block_op_;
ErrorBlockFunc ref_error_block_op_;
};
@@ -160,13 +160,13 @@
INSTANTIATE_TEST_CASE_P(
SSE2, ErrorBlockTest,
- ::testing::Values(make_tuple(&vp10_highbd_block_error_sse2,
- &vp10_highbd_block_error_c, VPX_BITS_10),
- make_tuple(&vp10_highbd_block_error_sse2,
- &vp10_highbd_block_error_c, VPX_BITS_12),
- make_tuple(&vp10_highbd_block_error_sse2,
- &vp10_highbd_block_error_c, VPX_BITS_8)));
+ ::testing::Values(make_tuple(&av1_highbd_block_error_sse2,
+ &av1_highbd_block_error_c, AOM_BITS_10),
+ make_tuple(&av1_highbd_block_error_sse2,
+ &av1_highbd_block_error_c, AOM_BITS_12),
+ make_tuple(&av1_highbd_block_error_sse2,
+ &av1_highbd_block_error_c, AOM_BITS_8)));
#endif // HAVE_SSE2
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#endif // CONFIG_AOM_HIGHBITDEPTH
} // namespace
diff --git a/test/error_resilience_test.cc b/test/error_resilience_test.cc
index f86f85d..7b55fba 100644
--- a/test/error_resilience_test.cc
+++ b/test/error_resilience_test.cc
@@ -49,7 +49,7 @@
mismatch_nframes_ = 0;
}
- virtual void PSNRPktHook(const vpx_codec_cx_pkt_t *pkt) {
+ virtual void PSNRPktHook(const aom_codec_cx_pkt_t *pkt) {
psnr_ += pkt->data.psnr.psnr[0];
nframes_++;
}
@@ -57,15 +57,15 @@
virtual void PreEncodeFrameHook(libaom_test::VideoSource *video,
::libaom_test::Encoder * /*encoder*/) {
frame_flags_ &=
- ~(VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF);
+ ~(AOM_EFLAG_NO_UPD_LAST | AOM_EFLAG_NO_UPD_GF | AOM_EFLAG_NO_UPD_ARF);
if (droppable_nframes_ > 0 &&
- (cfg_.g_pass == VPX_RC_LAST_PASS || cfg_.g_pass == VPX_RC_ONE_PASS)) {
+ (cfg_.g_pass == AOM_RC_LAST_PASS || cfg_.g_pass == AOM_RC_ONE_PASS)) {
for (unsigned int i = 0; i < droppable_nframes_; ++i) {
if (droppable_frames_[i] == video->frame()) {
std::cout << "Encoding droppable frame: " << droppable_frames_[i]
<< "\n";
- frame_flags_ |= (VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF |
- VP8_EFLAG_NO_UPD_ARF);
+ frame_flags_ |= (AOM_EFLAG_NO_UPD_LAST | AOM_EFLAG_NO_UPD_GF |
+ AOM_EFLAG_NO_UPD_ARF);
return;
}
}
@@ -84,7 +84,7 @@
virtual bool DoDecode() const {
if (error_nframes_ > 0 &&
- (cfg_.g_pass == VPX_RC_LAST_PASS || cfg_.g_pass == VPX_RC_ONE_PASS)) {
+ (cfg_.g_pass == AOM_RC_LAST_PASS || cfg_.g_pass == AOM_RC_ONE_PASS)) {
for (unsigned int i = 0; i < error_nframes_; ++i) {
if (error_frames_[i] == nframes_ - 1) {
std::cout << " Skipping decoding frame: "
@@ -96,7 +96,7 @@
return 1;
}
- virtual void MismatchHook(const vpx_image_t *img1, const vpx_image_t *img2) {
+ virtual void MismatchHook(const aom_image_t *img1, const aom_image_t *img2) {
double mismatch_psnr = compute_psnr(img1, img2);
mismatch_psnr_ += mismatch_psnr;
++mismatch_nframes_;
@@ -142,12 +142,12 @@
};
TEST_P(ErrorResilienceTestLarge, OnVersusOff) {
- const vpx_rational timebase = { 33333333, 1000000000 };
+ const aom_rational timebase = { 33333333, 1000000000 };
cfg_.g_timebase = timebase;
cfg_.rc_target_bitrate = 2000;
cfg_.g_lag_in_frames = 10;
- init_flags_ = VPX_CODEC_USE_PSNR;
+ init_flags_ = AOM_CODEC_USE_PSNR;
libaom_test::I420VideoSource video("hantro_collage_w352h288.yuv", 352, 288,
timebase.den, timebase.num, 0, 30);
@@ -177,21 +177,21 @@
// frames (i.e., frames that don't update any reference buffers).
// Check both isolated and consecutive loss.
TEST_P(ErrorResilienceTestLarge, DropFramesWithoutRecovery) {
- const vpx_rational timebase = { 33333333, 1000000000 };
+ const aom_rational timebase = { 33333333, 1000000000 };
cfg_.g_timebase = timebase;
cfg_.rc_target_bitrate = 500;
// FIXME(debargha): Fix this to work for any lag.
// Currently this test only works for lag = 0
cfg_.g_lag_in_frames = 0;
- init_flags_ = VPX_CODEC_USE_PSNR;
+ init_flags_ = AOM_CODEC_USE_PSNR;
libaom_test::I420VideoSource video("hantro_collage_w352h288.yuv", 352, 288,
timebase.den, timebase.num, 0, 40);
// Error resilient mode ON.
cfg_.g_error_resilient = 1;
- cfg_.kf_mode = VPX_KF_DISABLED;
+ cfg_.kf_mode = AOM_KF_DISABLED;
// Set an arbitrary set of error frames same as droppable frames.
// In addition to isolated loss/drop, add a long consecutive series
@@ -231,5 +231,5 @@
#endif
}
-VP10_INSTANTIATE_TEST_CASE(ErrorResilienceTestLarge, ONE_PASS_TEST_MODES);
+AV1_INSTANTIATE_TEST_CASE(ErrorResilienceTestLarge, ONE_PASS_TEST_MODES);
} // namespace
diff --git a/test/ethread_test.cc b/test/ethread_test.cc
index 0a32458..e62b78e 100644
--- a/test/ethread_test.cc
+++ b/test/ethread_test.cc
@@ -18,22 +18,22 @@
#include "test/y4m_video_source.h"
namespace {
-class VPxEncoderThreadTest
+class AVxEncoderThreadTest
: public ::libaom_test::EncoderTest,
public ::libaom_test::CodecTestWith2Params<libaom_test::TestMode, int> {
protected:
- VPxEncoderThreadTest()
+ AVxEncoderThreadTest()
: EncoderTest(GET_PARAM(0)), encoder_initialized_(false),
encoding_mode_(GET_PARAM(1)), set_cpu_used_(GET_PARAM(2)) {
- init_flags_ = VPX_CODEC_USE_PSNR;
- vpx_codec_dec_cfg_t cfg = vpx_codec_dec_cfg_t();
+ init_flags_ = AOM_CODEC_USE_PSNR;
+ aom_codec_dec_cfg_t cfg = aom_codec_dec_cfg_t();
cfg.w = 1280;
cfg.h = 720;
decoder_ = codec_->CreateDecoder(cfg, 0);
-#if CONFIG_VP10 && CONFIG_EXT_TILE
- if (decoder_->IsVP10()) {
- decoder_->Control(VP10_SET_DECODE_TILE_ROW, -1);
- decoder_->Control(VP10_SET_DECODE_TILE_COL, -1);
+#if CONFIG_AV1 && CONFIG_EXT_TILE
+ if (decoder_->IsAV1()) {
+ decoder_->Control(AV1_SET_DECODE_TILE_ROW, -1);
+ decoder_->Control(AV1_SET_DECODE_TILE_COL, -1);
}
#endif
@@ -41,7 +41,7 @@
md5_dec_.clear();
md5_enc_.clear();
}
- virtual ~VPxEncoderThreadTest() { delete decoder_; }
+ virtual ~AVxEncoderThreadTest() { delete decoder_; }
virtual void SetUp() {
InitializeConfig();
@@ -49,12 +49,12 @@
if (encoding_mode_ != ::libaom_test::kRealTime) {
cfg_.g_lag_in_frames = 3;
- cfg_.rc_end_usage = VPX_VBR;
+ cfg_.rc_end_usage = AOM_VBR;
cfg_.rc_2pass_vbr_minsection_pct = 5;
cfg_.rc_2pass_vbr_maxsection_pct = 2000;
} else {
cfg_.g_lag_in_frames = 0;
- cfg_.rc_end_usage = VPX_CBR;
+ cfg_.rc_end_usage = AOM_CBR;
cfg_.g_error_resilient = 1;
}
cfg_.rc_max_quantizer = 56;
@@ -68,35 +68,35 @@
virtual void PreEncodeFrameHook(::libaom_test::VideoSource * /*video*/,
::libaom_test::Encoder *encoder) {
if (!encoder_initialized_) {
-#if CONFIG_VP10 && CONFIG_EXT_TILE
- encoder->Control(VP9E_SET_TILE_COLUMNS, 1);
- if (codec_ == &libaom_test::kVP10) {
+#if CONFIG_AV1 && CONFIG_EXT_TILE
+ encoder->Control(AV1E_SET_TILE_COLUMNS, 1);
+ if (codec_ == &libaom_test::kAV1) {
// TODO(geza): Start using multiple tile rows when the multi-threaded
// encoder can handle them
- encoder->Control(VP9E_SET_TILE_ROWS, 32);
+ encoder->Control(AV1E_SET_TILE_ROWS, 32);
} else {
- encoder->Control(VP9E_SET_TILE_ROWS, 0);
+ encoder->Control(AV1E_SET_TILE_ROWS, 0);
}
#else
// Encode 4 tile columns.
- encoder->Control(VP9E_SET_TILE_COLUMNS, 2);
- encoder->Control(VP9E_SET_TILE_ROWS, 0);
-#endif // CONFIG_VP10 && CONFIG_EXT_TILE
- encoder->Control(VP8E_SET_CPUUSED, set_cpu_used_);
+ encoder->Control(AV1E_SET_TILE_COLUMNS, 2);
+ encoder->Control(AV1E_SET_TILE_ROWS, 0);
+#endif // CONFIG_AV1 && CONFIG_EXT_TILE
+ encoder->Control(AOME_SET_CPUUSED, set_cpu_used_);
if (encoding_mode_ != ::libaom_test::kRealTime) {
- encoder->Control(VP8E_SET_ENABLEAUTOALTREF, 1);
- encoder->Control(VP8E_SET_ARNR_MAXFRAMES, 7);
- encoder->Control(VP8E_SET_ARNR_STRENGTH, 5);
- encoder->Control(VP8E_SET_ARNR_TYPE, 3);
+ encoder->Control(AOME_SET_ENABLEAUTOALTREF, 1);
+ encoder->Control(AOME_SET_ARNR_MAXFRAMES, 7);
+ encoder->Control(AOME_SET_ARNR_STRENGTH, 5);
+ encoder->Control(AOME_SET_ARNR_TYPE, 3);
} else {
- encoder->Control(VP8E_SET_ENABLEAUTOALTREF, 0);
- encoder->Control(VP9E_SET_AQ_MODE, 3);
+ encoder->Control(AOME_SET_ENABLEAUTOALTREF, 0);
+ encoder->Control(AV1E_SET_AQ_MODE, 3);
}
encoder_initialized_ = true;
}
}
- virtual void FramePktHook(const vpx_codec_cx_pkt_t *pkt) {
+ virtual void FramePktHook(const aom_codec_cx_pkt_t *pkt) {
size_enc_.push_back(pkt->data.frame.sz);
::libaom_test::MD5 md5_enc;
@@ -104,13 +104,13 @@
pkt->data.frame.sz);
md5_enc_.push_back(md5_enc.Get());
- const vpx_codec_err_t res = decoder_->DecodeFrame(
+ const aom_codec_err_t res = decoder_->DecodeFrame(
reinterpret_cast<uint8_t *>(pkt->data.frame.buf), pkt->data.frame.sz);
- if (res != VPX_CODEC_OK) {
+ if (res != AOM_CODEC_OK) {
abort_ = true;
- ASSERT_EQ(VPX_CODEC_OK, res);
+ ASSERT_EQ(AOM_CODEC_OK, res);
}
- const vpx_image_t *img = decoder_->GetDxData().Next();
+ const aom_image_t *img = decoder_->GetDxData().Next();
if (img) {
::libaom_test::MD5 md5_res;
@@ -125,7 +125,7 @@
// Encode using single thread.
cfg_.g_threads = 1;
- init_flags_ = VPX_CODEC_USE_PSNR;
+ init_flags_ = AOM_CODEC_USE_PSNR;
ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
std::vector<size_t> single_thr_size_enc;
std::vector<std::string> single_thr_md5_enc;
@@ -165,19 +165,19 @@
std::vector<std::string> md5_dec_;
};
-TEST_P(VPxEncoderThreadTest, EncoderResultTest) { DoTest(); }
+TEST_P(AVxEncoderThreadTest, EncoderResultTest) { DoTest(); }
-class VPxEncoderThreadTestLarge : public VPxEncoderThreadTest {};
+class AVxEncoderThreadTestLarge : public AVxEncoderThreadTest {};
-TEST_P(VPxEncoderThreadTestLarge, EncoderResultTest) { DoTest(); }
+TEST_P(AVxEncoderThreadTestLarge, EncoderResultTest) { DoTest(); }
-VP10_INSTANTIATE_TEST_CASE(VPxEncoderThreadTest,
- ::testing::Values(::libaom_test::kTwoPassGood,
- ::libaom_test::kOnePassGood),
- ::testing::Range(3, 9));
+AV1_INSTANTIATE_TEST_CASE(AVxEncoderThreadTest,
+ ::testing::Values(::libaom_test::kTwoPassGood,
+ ::libaom_test::kOnePassGood),
+ ::testing::Range(3, 9));
-VP10_INSTANTIATE_TEST_CASE(VPxEncoderThreadTestLarge,
- ::testing::Values(::libaom_test::kTwoPassGood,
- ::libaom_test::kOnePassGood),
- ::testing::Range(1, 3));
+AV1_INSTANTIATE_TEST_CASE(AVxEncoderThreadTestLarge,
+ ::testing::Values(::libaom_test::kTwoPassGood,
+ ::libaom_test::kOnePassGood),
+ ::testing::Range(1, 3));
} // namespace
diff --git a/test/examples.sh b/test/examples.sh
index 1ee120a..8c0aff4 100755
--- a/test/examples.sh
+++ b/test/examples.sh
@@ -24,6 +24,6 @@
for test in ${example_tests}; do
# Source each test script so that exporting variables can be avoided.
- VPX_TEST_NAME="$(basename ${test%.*})"
+ AOM_TEST_NAME="$(basename ${test%.*})"
. "${test}"
done
diff --git a/test/fdct4x4_test.cc b/test/fdct4x4_test.cc
index dda6e68..4498b7b 100644
--- a/test/fdct4x4_test.cc
+++ b/test/fdct4x4_test.cc
@@ -14,16 +14,16 @@
#include "third_party/googletest/src/include/gtest/gtest.h"
-#include "./vp10_rtcd.h"
-#include "./vpx_dsp_rtcd.h"
+#include "./av1_rtcd.h"
+#include "./aom_dsp_rtcd.h"
#include "test/acm_random.h"
#include "test/clear_system_state.h"
#include "test/register_state_check.h"
#include "test/transform_test_base.h"
#include "test/util.h"
#include "av1/common/entropy.h"
-#include "aom/vpx_codec.h"
-#include "aom/vpx_integer.h"
+#include "aom/aom_codec.h"
+#include "aom/aom_integer.h"
#include "aom_ports/mem.h"
using libaom_test::ACMRandom;
@@ -35,59 +35,59 @@
int tx_type);
using libaom_test::FhtFunc;
-typedef std::tr1::tuple<FdctFunc, IdctFunc, int, vpx_bit_depth_t, int>
+typedef std::tr1::tuple<FdctFunc, IdctFunc, int, aom_bit_depth_t, int>
Dct4x4Param;
-typedef std::tr1::tuple<FhtFunc, IhtFunc, int, vpx_bit_depth_t, int> Ht4x4Param;
+typedef std::tr1::tuple<FhtFunc, IhtFunc, int, aom_bit_depth_t, int> Ht4x4Param;
void fdct4x4_ref(const int16_t *in, tran_low_t *out, int stride,
int /*tx_type*/) {
- vpx_fdct4x4_c(in, out, stride);
+ aom_fdct4x4_c(in, out, stride);
}
void fht4x4_ref(const int16_t *in, tran_low_t *out, int stride, int tx_type) {
- vp10_fht4x4_c(in, out, stride, tx_type);
+ av1_fht4x4_c(in, out, stride, tx_type);
}
void fwht4x4_ref(const int16_t *in, tran_low_t *out, int stride,
int /*tx_type*/) {
- vp10_fwht4x4_c(in, out, stride);
+ av1_fwht4x4_c(in, out, stride);
}
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
void idct4x4_10(const tran_low_t *in, uint8_t *out, int stride) {
- vpx_highbd_idct4x4_16_add_c(in, out, stride, 10);
+ aom_highbd_idct4x4_16_add_c(in, out, stride, 10);
}
void idct4x4_12(const tran_low_t *in, uint8_t *out, int stride) {
- vpx_highbd_idct4x4_16_add_c(in, out, stride, 12);
+ aom_highbd_idct4x4_16_add_c(in, out, stride, 12);
}
void iht4x4_10(const tran_low_t *in, uint8_t *out, int stride, int tx_type) {
- vp10_highbd_iht4x4_16_add_c(in, out, stride, tx_type, 10);
+ av1_highbd_iht4x4_16_add_c(in, out, stride, tx_type, 10);
}
void iht4x4_12(const tran_low_t *in, uint8_t *out, int stride, int tx_type) {
- vp10_highbd_iht4x4_16_add_c(in, out, stride, tx_type, 12);
+ av1_highbd_iht4x4_16_add_c(in, out, stride, tx_type, 12);
}
void iwht4x4_10(const tran_low_t *in, uint8_t *out, int stride) {
- vpx_highbd_iwht4x4_16_add_c(in, out, stride, 10);
+ aom_highbd_iwht4x4_16_add_c(in, out, stride, 10);
}
void iwht4x4_12(const tran_low_t *in, uint8_t *out, int stride) {
- vpx_highbd_iwht4x4_16_add_c(in, out, stride, 12);
+ aom_highbd_iwht4x4_16_add_c(in, out, stride, 12);
}
#if HAVE_SSE2
void idct4x4_10_sse2(const tran_low_t *in, uint8_t *out, int stride) {
- vpx_highbd_idct4x4_16_add_sse2(in, out, stride, 10);
+ aom_highbd_idct4x4_16_add_sse2(in, out, stride, 10);
}
void idct4x4_12_sse2(const tran_low_t *in, uint8_t *out, int stride) {
- vpx_highbd_idct4x4_16_add_sse2(in, out, stride, 12);
+ aom_highbd_idct4x4_16_add_sse2(in, out, stride, 12);
}
#endif // HAVE_SSE2
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#endif // CONFIG_AOM_HIGHBITDEPTH
class Trans4x4DCT : public libaom_test::TransformTestBase,
public ::testing::TestWithParam<Dct4x4Param> {
@@ -202,143 +202,139 @@
TEST_P(Trans4x4WHT, InvAccuracyCheck) { RunInvAccuracyCheck(0); }
using std::tr1::make_tuple;
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
INSTANTIATE_TEST_CASE_P(
C, Trans4x4DCT,
::testing::Values(
- make_tuple(&vpx_highbd_fdct4x4_c, &idct4x4_10, 0, VPX_BITS_10, 16),
- make_tuple(&vpx_highbd_fdct4x4_c, &idct4x4_12, 0, VPX_BITS_12, 16),
- make_tuple(&vpx_fdct4x4_c, &vpx_idct4x4_16_add_c, 0, VPX_BITS_8, 16)));
+ make_tuple(&aom_highbd_fdct4x4_c, &idct4x4_10, 0, AOM_BITS_10, 16),
+ make_tuple(&aom_highbd_fdct4x4_c, &idct4x4_12, 0, AOM_BITS_12, 16),
+ make_tuple(&aom_fdct4x4_c, &aom_idct4x4_16_add_c, 0, AOM_BITS_8, 16)));
#else
INSTANTIATE_TEST_CASE_P(C, Trans4x4DCT,
- ::testing::Values(make_tuple(&vpx_fdct4x4_c,
- &vpx_idct4x4_16_add_c, 0,
- VPX_BITS_8, 16)));
-#endif // CONFIG_VP9_HIGHBITDEPTH
+ ::testing::Values(make_tuple(&aom_fdct4x4_c,
+ &aom_idct4x4_16_add_c, 0,
+ AOM_BITS_8, 16)));
+#endif // CONFIG_AOM_HIGHBITDEPTH
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
INSTANTIATE_TEST_CASE_P(
C, Trans4x4HT,
::testing::Values(
- make_tuple(&vp10_highbd_fht4x4_c, &iht4x4_10, 0, VPX_BITS_10, 16),
- make_tuple(&vp10_highbd_fht4x4_c, &iht4x4_10, 1, VPX_BITS_10, 16),
- make_tuple(&vp10_highbd_fht4x4_c, &iht4x4_10, 2, VPX_BITS_10, 16),
- make_tuple(&vp10_highbd_fht4x4_c, &iht4x4_10, 3, VPX_BITS_10, 16),
- make_tuple(&vp10_highbd_fht4x4_c, &iht4x4_12, 0, VPX_BITS_12, 16),
- make_tuple(&vp10_highbd_fht4x4_c, &iht4x4_12, 1, VPX_BITS_12, 16),
- make_tuple(&vp10_highbd_fht4x4_c, &iht4x4_12, 2, VPX_BITS_12, 16),
- make_tuple(&vp10_highbd_fht4x4_c, &iht4x4_12, 3, VPX_BITS_12, 16),
- make_tuple(&vp10_fht4x4_c, &vp10_iht4x4_16_add_c, 0, VPX_BITS_8, 16),
- make_tuple(&vp10_fht4x4_c, &vp10_iht4x4_16_add_c, 1, VPX_BITS_8, 16),
- make_tuple(&vp10_fht4x4_c, &vp10_iht4x4_16_add_c, 2, VPX_BITS_8, 16),
- make_tuple(&vp10_fht4x4_c, &vp10_iht4x4_16_add_c, 3, VPX_BITS_8, 16)));
+ make_tuple(&av1_highbd_fht4x4_c, &iht4x4_10, 0, AOM_BITS_10, 16),
+ make_tuple(&av1_highbd_fht4x4_c, &iht4x4_10, 1, AOM_BITS_10, 16),
+ make_tuple(&av1_highbd_fht4x4_c, &iht4x4_10, 2, AOM_BITS_10, 16),
+ make_tuple(&av1_highbd_fht4x4_c, &iht4x4_10, 3, AOM_BITS_10, 16),
+ make_tuple(&av1_highbd_fht4x4_c, &iht4x4_12, 0, AOM_BITS_12, 16),
+ make_tuple(&av1_highbd_fht4x4_c, &iht4x4_12, 1, AOM_BITS_12, 16),
+ make_tuple(&av1_highbd_fht4x4_c, &iht4x4_12, 2, AOM_BITS_12, 16),
+ make_tuple(&av1_highbd_fht4x4_c, &iht4x4_12, 3, AOM_BITS_12, 16),
+ make_tuple(&av1_fht4x4_c, &av1_iht4x4_16_add_c, 0, AOM_BITS_8, 16),
+ make_tuple(&av1_fht4x4_c, &av1_iht4x4_16_add_c, 1, AOM_BITS_8, 16),
+ make_tuple(&av1_fht4x4_c, &av1_iht4x4_16_add_c, 2, AOM_BITS_8, 16),
+ make_tuple(&av1_fht4x4_c, &av1_iht4x4_16_add_c, 3, AOM_BITS_8, 16)));
#else
INSTANTIATE_TEST_CASE_P(
C, Trans4x4HT,
::testing::Values(
- make_tuple(&vp10_fht4x4_c, &vp10_iht4x4_16_add_c, 0, VPX_BITS_8, 16),
- make_tuple(&vp10_fht4x4_c, &vp10_iht4x4_16_add_c, 1, VPX_BITS_8, 16),
- make_tuple(&vp10_fht4x4_c, &vp10_iht4x4_16_add_c, 2, VPX_BITS_8, 16),
- make_tuple(&vp10_fht4x4_c, &vp10_iht4x4_16_add_c, 3, VPX_BITS_8, 16)));
-#endif // CONFIG_VP9_HIGHBITDEPTH
+ make_tuple(&av1_fht4x4_c, &av1_iht4x4_16_add_c, 0, AOM_BITS_8, 16),
+ make_tuple(&av1_fht4x4_c, &av1_iht4x4_16_add_c, 1, AOM_BITS_8, 16),
+ make_tuple(&av1_fht4x4_c, &av1_iht4x4_16_add_c, 2, AOM_BITS_8, 16),
+ make_tuple(&av1_fht4x4_c, &av1_iht4x4_16_add_c, 3, AOM_BITS_8, 16)));
+#endif // CONFIG_AOM_HIGHBITDEPTH
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
INSTANTIATE_TEST_CASE_P(
C, Trans4x4WHT,
::testing::Values(
- make_tuple(&vp10_highbd_fwht4x4_c, &iwht4x4_10, 0, VPX_BITS_10, 16),
- make_tuple(&vp10_highbd_fwht4x4_c, &iwht4x4_12, 0, VPX_BITS_12, 16),
- make_tuple(&vp10_fwht4x4_c, &vpx_iwht4x4_16_add_c, 0, VPX_BITS_8, 16)));
+ make_tuple(&av1_highbd_fwht4x4_c, &iwht4x4_10, 0, AOM_BITS_10, 16),
+ make_tuple(&av1_highbd_fwht4x4_c, &iwht4x4_12, 0, AOM_BITS_12, 16),
+ make_tuple(&av1_fwht4x4_c, &aom_iwht4x4_16_add_c, 0, AOM_BITS_8, 16)));
#else
INSTANTIATE_TEST_CASE_P(C, Trans4x4WHT,
- ::testing::Values(make_tuple(&vp10_fwht4x4_c,
- &vpx_iwht4x4_16_add_c, 0,
- VPX_BITS_8, 16)));
-#endif // CONFIG_VP9_HIGHBITDEPTH
+ ::testing::Values(make_tuple(&av1_fwht4x4_c,
+ &aom_iwht4x4_16_add_c, 0,
+ AOM_BITS_8, 16)));
+#endif // CONFIG_AOM_HIGHBITDEPTH
-#if HAVE_NEON_ASM && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
+#if HAVE_NEON_ASM && !CONFIG_AOM_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
INSTANTIATE_TEST_CASE_P(NEON, Trans4x4DCT,
- ::testing::Values(make_tuple(&vpx_fdct4x4_c,
- &vpx_idct4x4_16_add_neon,
- 0, VPX_BITS_8, 16)));
-#endif // HAVE_NEON_ASM && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
+ ::testing::Values(make_tuple(&aom_fdct4x4_c,
+ &aom_idct4x4_16_add_neon,
+ 0, AOM_BITS_8, 16)));
+#endif // HAVE_NEON_ASM && !CONFIG_AOM_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
-#if HAVE_NEON && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
+#if HAVE_NEON && !CONFIG_AOM_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
INSTANTIATE_TEST_CASE_P(
NEON, Trans4x4HT,
::testing::Values(
- make_tuple(&vp10_fht4x4_c, &vp10_iht4x4_16_add_neon, 0, VPX_BITS_8, 16),
- make_tuple(&vp10_fht4x4_c, &vp10_iht4x4_16_add_neon, 1, VPX_BITS_8, 16),
- make_tuple(&vp10_fht4x4_c, &vp10_iht4x4_16_add_neon, 2, VPX_BITS_8, 16),
- make_tuple(&vp10_fht4x4_c, &vp10_iht4x4_16_add_neon, 3, VPX_BITS_8,
- 16)));
-#endif // HAVE_NEON && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
+ make_tuple(&av1_fht4x4_c, &av1_iht4x4_16_add_neon, 0, AOM_BITS_8, 16),
+ make_tuple(&av1_fht4x4_c, &av1_iht4x4_16_add_neon, 1, AOM_BITS_8, 16),
+ make_tuple(&av1_fht4x4_c, &av1_iht4x4_16_add_neon, 2, AOM_BITS_8, 16),
+ make_tuple(&av1_fht4x4_c, &av1_iht4x4_16_add_neon, 3, AOM_BITS_8, 16)));
+#endif // HAVE_NEON && !CONFIG_AOM_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
#if HAVE_SSE2 && !CONFIG_EMULATE_HARDWARE
INSTANTIATE_TEST_CASE_P(
SSE2, Trans4x4WHT,
- ::testing::Values(make_tuple(&vp10_fwht4x4_c, &vpx_iwht4x4_16_add_c, 0,
- VPX_BITS_8, 16),
- make_tuple(&vp10_fwht4x4_c, &vpx_iwht4x4_16_add_sse2, 0,
- VPX_BITS_8, 16)));
+ ::testing::Values(make_tuple(&av1_fwht4x4_c, &aom_iwht4x4_16_add_c, 0,
+ AOM_BITS_8, 16),
+ make_tuple(&av1_fwht4x4_c, &aom_iwht4x4_16_add_sse2, 0,
+ AOM_BITS_8, 16)));
#endif
-#if HAVE_SSE2 && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
+#if HAVE_SSE2 && !CONFIG_AOM_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
INSTANTIATE_TEST_CASE_P(SSE2, Trans4x4DCT,
- ::testing::Values(make_tuple(&vpx_fdct4x4_sse2,
- &vpx_idct4x4_16_add_sse2,
- 0, VPX_BITS_8, 16)));
+ ::testing::Values(make_tuple(&aom_fdct4x4_sse2,
+ &aom_idct4x4_16_add_sse2,
+ 0, AOM_BITS_8, 16)));
INSTANTIATE_TEST_CASE_P(
SSE2, Trans4x4HT,
- ::testing::Values(make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_sse2, 0,
- VPX_BITS_8, 16),
- make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_sse2, 1,
- VPX_BITS_8, 16),
- make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_sse2, 2,
- VPX_BITS_8, 16),
- make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_sse2, 3,
- VPX_BITS_8, 16)));
-#endif // HAVE_SSE2 && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
+ ::testing::Values(make_tuple(&av1_fht4x4_sse2, &av1_iht4x4_16_add_sse2, 0,
+ AOM_BITS_8, 16),
+ make_tuple(&av1_fht4x4_sse2, &av1_iht4x4_16_add_sse2, 1,
+ AOM_BITS_8, 16),
+ make_tuple(&av1_fht4x4_sse2, &av1_iht4x4_16_add_sse2, 2,
+ AOM_BITS_8, 16),
+ make_tuple(&av1_fht4x4_sse2, &av1_iht4x4_16_add_sse2, 3,
+ AOM_BITS_8, 16)));
+#endif // HAVE_SSE2 && !CONFIG_AOM_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
-#if HAVE_SSE2 && CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
+#if HAVE_SSE2 && CONFIG_AOM_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
INSTANTIATE_TEST_CASE_P(
SSE2, Trans4x4DCT,
::testing::Values(
- make_tuple(&vpx_highbd_fdct4x4_c, &idct4x4_10_sse2, 0, VPX_BITS_10, 16),
- make_tuple(&vpx_highbd_fdct4x4_sse2, &idct4x4_10_sse2, 0, VPX_BITS_10,
+ make_tuple(&aom_highbd_fdct4x4_c, &idct4x4_10_sse2, 0, AOM_BITS_10, 16),
+ make_tuple(&aom_highbd_fdct4x4_sse2, &idct4x4_10_sse2, 0, AOM_BITS_10,
16),
- make_tuple(&vpx_highbd_fdct4x4_c, &idct4x4_12_sse2, 0, VPX_BITS_12, 16),
- make_tuple(&vpx_highbd_fdct4x4_sse2, &idct4x4_12_sse2, 0, VPX_BITS_12,
+ make_tuple(&aom_highbd_fdct4x4_c, &idct4x4_12_sse2, 0, AOM_BITS_12, 16),
+ make_tuple(&aom_highbd_fdct4x4_sse2, &idct4x4_12_sse2, 0, AOM_BITS_12,
16),
- make_tuple(&vpx_fdct4x4_sse2, &vpx_idct4x4_16_add_c, 0, VPX_BITS_8,
+ make_tuple(&aom_fdct4x4_sse2, &aom_idct4x4_16_add_c, 0, AOM_BITS_8,
16)));
INSTANTIATE_TEST_CASE_P(
SSE2, Trans4x4HT,
::testing::Values(
- make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_c, 0, VPX_BITS_8, 16),
- make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_c, 1, VPX_BITS_8, 16),
- make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_c, 2, VPX_BITS_8, 16),
- make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_c, 3, VPX_BITS_8,
- 16)));
-#endif // HAVE_SSE2 && CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
+ make_tuple(&av1_fht4x4_sse2, &av1_iht4x4_16_add_c, 0, AOM_BITS_8, 16),
+ make_tuple(&av1_fht4x4_sse2, &av1_iht4x4_16_add_c, 1, AOM_BITS_8, 16),
+ make_tuple(&av1_fht4x4_sse2, &av1_iht4x4_16_add_c, 2, AOM_BITS_8, 16),
+ make_tuple(&av1_fht4x4_sse2, &av1_iht4x4_16_add_c, 3, AOM_BITS_8, 16)));
+#endif // HAVE_SSE2 && CONFIG_AOM_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
-#if HAVE_MSA && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
+#if HAVE_MSA && !CONFIG_AOM_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
INSTANTIATE_TEST_CASE_P(MSA, Trans4x4DCT,
- ::testing::Values(make_tuple(&vpx_fdct4x4_msa,
- &vpx_idct4x4_16_add_msa, 0,
- VPX_BITS_8, 16)));
+ ::testing::Values(make_tuple(&aom_fdct4x4_msa,
+ &aom_idct4x4_16_add_msa, 0,
+ AOM_BITS_8, 16)));
#if !CONFIG_EXT_TX
INSTANTIATE_TEST_CASE_P(
MSA, Trans4x4HT,
- ::testing::Values(make_tuple(&vp10_fht4x4_msa, &vp10_iht4x4_16_add_msa, 0,
- VPX_BITS_8, 16),
- make_tuple(&vp10_fht4x4_msa, &vp10_iht4x4_16_add_msa, 1,
- VPX_BITS_8, 16),
- make_tuple(&vp10_fht4x4_msa, &vp10_iht4x4_16_add_msa, 2,
- VPX_BITS_8, 16),
- make_tuple(&vp10_fht4x4_msa, &vp10_iht4x4_16_add_msa, 3,
- VPX_BITS_8, 16)));
+ ::testing::Values(
+ make_tuple(&av1_fht4x4_msa, &av1_iht4x4_16_add_msa, 0, AOM_BITS_8, 16),
+ make_tuple(&av1_fht4x4_msa, &av1_iht4x4_16_add_msa, 1, AOM_BITS_8, 16),
+ make_tuple(&av1_fht4x4_msa, &av1_iht4x4_16_add_msa, 2, AOM_BITS_8, 16),
+ make_tuple(&av1_fht4x4_msa, &av1_iht4x4_16_add_msa, 3, AOM_BITS_8,
+ 16)));
#endif // !CONFIG_EXT_TX
-#endif // HAVE_MSA && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
+#endif // HAVE_MSA && !CONFIG_AOM_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
} // namespace
diff --git a/test/fdct8x8_test.cc b/test/fdct8x8_test.cc
index 5f07468..8cfcbc1 100644
--- a/test/fdct8x8_test.cc
+++ b/test/fdct8x8_test.cc
@@ -14,16 +14,16 @@
#include "third_party/googletest/src/include/gtest/gtest.h"
-#include "./vp10_rtcd.h"
-#include "./vpx_dsp_rtcd.h"
+#include "./av1_rtcd.h"
+#include "./aom_dsp_rtcd.h"
#include "test/acm_random.h"
#include "test/clear_system_state.h"
#include "test/register_state_check.h"
#include "test/util.h"
#include "av1/common/entropy.h"
#include "av1/common/scan.h"
-#include "aom/vpx_codec.h"
-#include "aom/vpx_integer.h"
+#include "aom/aom_codec.h"
+#include "aom/aom_integer.h"
#include "aom_ports/mem.h"
using libaom_test::ACMRandom;
@@ -43,9 +43,9 @@
typedef void (*IhtFunc)(const tran_low_t *in, uint8_t *out, int stride,
int tx_type);
-typedef std::tr1::tuple<FdctFunc, IdctFunc, int, vpx_bit_depth_t> Dct8x8Param;
-typedef std::tr1::tuple<FhtFunc, IhtFunc, int, vpx_bit_depth_t> Ht8x8Param;
-typedef std::tr1::tuple<IdctFunc, IdctFunc, int, vpx_bit_depth_t> Idct8x8Param;
+typedef std::tr1::tuple<FdctFunc, IdctFunc, int, aom_bit_depth_t> Dct8x8Param;
+typedef std::tr1::tuple<FhtFunc, IhtFunc, int, aom_bit_depth_t> Ht8x8Param;
+typedef std::tr1::tuple<IdctFunc, IdctFunc, int, aom_bit_depth_t> Idct8x8Param;
void reference_8x8_dct_1d(const double in[8], double out[8]) {
const double kInvSqrt2 = 0.707106781186547524400844362104;
@@ -78,57 +78,57 @@
void fdct8x8_ref(const int16_t *in, tran_low_t *out, int stride,
int /*tx_type*/) {
- vpx_fdct8x8_c(in, out, stride);
+ aom_fdct8x8_c(in, out, stride);
}
void fht8x8_ref(const int16_t *in, tran_low_t *out, int stride, int tx_type) {
- vp10_fht8x8_c(in, out, stride, tx_type);
+ av1_fht8x8_c(in, out, stride, tx_type);
}
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
void idct8x8_10(const tran_low_t *in, uint8_t *out, int stride) {
- vpx_highbd_idct8x8_64_add_c(in, out, stride, 10);
+ aom_highbd_idct8x8_64_add_c(in, out, stride, 10);
}
void idct8x8_12(const tran_low_t *in, uint8_t *out, int stride) {
- vpx_highbd_idct8x8_64_add_c(in, out, stride, 12);
+ aom_highbd_idct8x8_64_add_c(in, out, stride, 12);
}
void iht8x8_10(const tran_low_t *in, uint8_t *out, int stride, int tx_type) {
- vp10_highbd_iht8x8_64_add_c(in, out, stride, tx_type, 10);
+ av1_highbd_iht8x8_64_add_c(in, out, stride, tx_type, 10);
}
void iht8x8_12(const tran_low_t *in, uint8_t *out, int stride, int tx_type) {
- vp10_highbd_iht8x8_64_add_c(in, out, stride, tx_type, 12);
+ av1_highbd_iht8x8_64_add_c(in, out, stride, tx_type, 12);
}
#if HAVE_SSE2
void idct8x8_10_add_10_c(const tran_low_t *in, uint8_t *out, int stride) {
- vpx_highbd_idct8x8_10_add_c(in, out, stride, 10);
+ aom_highbd_idct8x8_10_add_c(in, out, stride, 10);
}
void idct8x8_10_add_12_c(const tran_low_t *in, uint8_t *out, int stride) {
- vpx_highbd_idct8x8_10_add_c(in, out, stride, 12);
+ aom_highbd_idct8x8_10_add_c(in, out, stride, 12);
}
void idct8x8_10_add_10_sse2(const tran_low_t *in, uint8_t *out, int stride) {
- vpx_highbd_idct8x8_10_add_sse2(in, out, stride, 10);
+ aom_highbd_idct8x8_10_add_sse2(in, out, stride, 10);
}
void idct8x8_10_add_12_sse2(const tran_low_t *in, uint8_t *out, int stride) {
- vpx_highbd_idct8x8_10_add_sse2(in, out, stride, 12);
+ aom_highbd_idct8x8_10_add_sse2(in, out, stride, 12);
}
void idct8x8_64_add_10_sse2(const tran_low_t *in, uint8_t *out, int stride) {
- vpx_highbd_idct8x8_64_add_sse2(in, out, stride, 10);
+ aom_highbd_idct8x8_64_add_sse2(in, out, stride, 10);
}
void idct8x8_64_add_12_sse2(const tran_low_t *in, uint8_t *out, int stride) {
- vpx_highbd_idct8x8_64_add_sse2(in, out, stride, 12);
+ aom_highbd_idct8x8_64_add_sse2(in, out, stride, 12);
}
#endif // HAVE_SSE2
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#endif // CONFIG_AOM_HIGHBITDEPTH
class FwdTrans8x8TestBase {
public:
@@ -213,7 +213,7 @@
DECLARE_ALIGNED(16, tran_low_t, test_temp_block[64]);
DECLARE_ALIGNED(16, uint8_t, dst[64]);
DECLARE_ALIGNED(16, uint8_t, src[64]);
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
DECLARE_ALIGNED(16, uint16_t, dst16[64]);
DECLARE_ALIGNED(16, uint16_t, src16[64]);
#endif
@@ -221,11 +221,11 @@
for (int i = 0; i < count_test_block; ++i) {
// Initialize a test block with input range [-mask_, mask_].
for (int j = 0; j < 64; ++j) {
- if (bit_depth_ == VPX_BITS_8) {
+ if (bit_depth_ == AOM_BITS_8) {
src[j] = rnd.Rand8();
dst[j] = rnd.Rand8();
test_input_block[j] = src[j] - dst[j];
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
} else {
src16[j] = rnd.Rand16() & mask_;
dst16[j] = rnd.Rand16() & mask_;
@@ -247,9 +247,9 @@
test_temp_block[j] *= 4;
}
}
- if (bit_depth_ == VPX_BITS_8) {
+ if (bit_depth_ == AOM_BITS_8) {
ASM_REGISTER_STATE_CHECK(RunInvTxfm(test_temp_block, dst, pitch_));
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
} else {
ASM_REGISTER_STATE_CHECK(
RunInvTxfm(test_temp_block, CONVERT_TO_BYTEPTR(dst16), pitch_));
@@ -257,9 +257,9 @@
}
for (int j = 0; j < 64; ++j) {
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
const int diff =
- bit_depth_ == VPX_BITS_8 ? dst[j] - src[j] : dst16[j] - src16[j];
+ bit_depth_ == AOM_BITS_8 ? dst[j] - src[j] : dst16[j] - src16[j];
#else
const int diff = dst[j] - src[j];
#endif
@@ -289,7 +289,7 @@
DECLARE_ALIGNED(16, tran_low_t, ref_temp_block[64]);
DECLARE_ALIGNED(16, uint8_t, dst[64]);
DECLARE_ALIGNED(16, uint8_t, src[64]);
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
DECLARE_ALIGNED(16, uint16_t, dst16[64]);
DECLARE_ALIGNED(16, uint16_t, src16[64]);
#endif
@@ -297,7 +297,7 @@
for (int i = 0; i < count_test_block; ++i) {
// Initialize a test block with input range [-mask_, mask_].
for (int j = 0; j < 64; ++j) {
- if (bit_depth_ == VPX_BITS_8) {
+ if (bit_depth_ == AOM_BITS_8) {
if (i == 0) {
src[j] = 255;
dst[j] = 0;
@@ -309,7 +309,7 @@
dst[j] = rnd.Rand8() % 2 ? 255 : 0;
}
test_input_block[j] = src[j] - dst[j];
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
} else {
if (i == 0) {
src16[j] = mask_;
@@ -330,9 +330,9 @@
RunFwdTxfm(test_input_block, test_temp_block, pitch_));
ASM_REGISTER_STATE_CHECK(
fwd_txfm_ref(test_input_block, ref_temp_block, pitch_, tx_type_));
- if (bit_depth_ == VPX_BITS_8) {
+ if (bit_depth_ == AOM_BITS_8) {
ASM_REGISTER_STATE_CHECK(RunInvTxfm(test_temp_block, dst, pitch_));
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
} else {
ASM_REGISTER_STATE_CHECK(
RunInvTxfm(test_temp_block, CONVERT_TO_BYTEPTR(dst16), pitch_));
@@ -340,9 +340,9 @@
}
for (int j = 0; j < 64; ++j) {
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
const int diff =
- bit_depth_ == VPX_BITS_8 ? dst[j] - src[j] : dst16[j] - src16[j];
+ bit_depth_ == AOM_BITS_8 ? dst[j] - src[j] : dst16[j] - src16[j];
#else
const int diff = dst[j] - src[j];
#endif
@@ -375,7 +375,7 @@
DECLARE_ALIGNED(16, tran_low_t, coeff[kNumCoeffs]);
DECLARE_ALIGNED(16, uint8_t, dst[kNumCoeffs]);
DECLARE_ALIGNED(16, uint8_t, src[kNumCoeffs]);
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
DECLARE_ALIGNED(16, uint16_t, src16[kNumCoeffs]);
DECLARE_ALIGNED(16, uint16_t, dst16[kNumCoeffs]);
#endif
@@ -385,11 +385,11 @@
// Initialize a test block with input range [-255, 255].
for (int j = 0; j < kNumCoeffs; ++j) {
- if (bit_depth_ == VPX_BITS_8) {
+ if (bit_depth_ == AOM_BITS_8) {
src[j] = rnd.Rand8() % 2 ? 255 : 0;
dst[j] = src[j] > 0 ? 0 : 255;
in[j] = src[j] - dst[j];
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
} else {
src16[j] = rnd.Rand8() % 2 ? mask_ : 0;
dst16[j] = src16[j] > 0 ? 0 : mask_;
@@ -402,9 +402,9 @@
for (int j = 0; j < kNumCoeffs; ++j)
coeff[j] = static_cast<tran_low_t>(round(out_r[j]));
- if (bit_depth_ == VPX_BITS_8) {
+ if (bit_depth_ == AOM_BITS_8) {
ASM_REGISTER_STATE_CHECK(RunInvTxfm(coeff, dst, pitch_));
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
} else {
ASM_REGISTER_STATE_CHECK(
RunInvTxfm(coeff, CONVERT_TO_BYTEPTR(dst16), pitch_));
@@ -412,9 +412,9 @@
}
for (int j = 0; j < kNumCoeffs; ++j) {
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
const int diff =
- bit_depth_ == VPX_BITS_8 ? dst[j] - src[j] : dst16[j] - src16[j];
+ bit_depth_ == AOM_BITS_8 ? dst[j] - src[j] : dst16[j] - src16[j];
#else
const int diff = dst[j] - src[j];
#endif
@@ -460,11 +460,11 @@
DECLARE_ALIGNED(16, tran_low_t, coeff[kNumCoeffs]);
DECLARE_ALIGNED(16, uint8_t, dst[kNumCoeffs]);
DECLARE_ALIGNED(16, uint8_t, ref[kNumCoeffs]);
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
DECLARE_ALIGNED(16, uint16_t, dst16[kNumCoeffs]);
DECLARE_ALIGNED(16, uint16_t, ref16[kNumCoeffs]);
#endif
- const int16_t *scan = vp10_default_scan_orders[TX_8X8].scan;
+ const int16_t *scan = av1_default_scan_orders[TX_8X8].scan;
for (int i = 0; i < count_test_block; ++i) {
for (int j = 0; j < kNumCoeffs; ++j) {
@@ -474,20 +474,20 @@
} else {
coeff[scan[j]] = 0;
}
- if (bit_depth_ == VPX_BITS_8) {
+ if (bit_depth_ == AOM_BITS_8) {
dst[j] = 0;
ref[j] = 0;
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
} else {
dst16[j] = 0;
ref16[j] = 0;
#endif
}
}
- if (bit_depth_ == VPX_BITS_8) {
+ if (bit_depth_ == AOM_BITS_8) {
ref_txfm(coeff, ref, pitch_);
ASM_REGISTER_STATE_CHECK(RunInvTxfm(coeff, dst, pitch_));
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
} else {
ref_txfm(coeff, CONVERT_TO_BYTEPTR(ref16), pitch_);
ASM_REGISTER_STATE_CHECK(
@@ -496,9 +496,9 @@
}
for (int j = 0; j < kNumCoeffs; ++j) {
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
const int diff =
- bit_depth_ == VPX_BITS_8 ? dst[j] - ref[j] : dst16[j] - ref16[j];
+ bit_depth_ == AOM_BITS_8 ? dst[j] - ref[j] : dst16[j] - ref16[j];
#else
const int diff = dst[j] - ref[j];
#endif
@@ -511,7 +511,7 @@
int pitch_;
int tx_type_;
FhtFunc fwd_txfm_ref;
- vpx_bit_depth_t bit_depth_;
+ aom_bit_depth_t bit_depth_;
int mask_;
};
@@ -622,99 +622,98 @@
using std::tr1::make_tuple;
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
INSTANTIATE_TEST_CASE_P(
C, FwdTrans8x8DCT,
::testing::Values(
- make_tuple(&vpx_fdct8x8_c, &vpx_idct8x8_64_add_c, 0, VPX_BITS_8),
- make_tuple(&vpx_highbd_fdct8x8_c, &idct8x8_10, 0, VPX_BITS_10),
- make_tuple(&vpx_highbd_fdct8x8_c, &idct8x8_12, 0, VPX_BITS_12)));
+ make_tuple(&aom_fdct8x8_c, &aom_idct8x8_64_add_c, 0, AOM_BITS_8),
+ make_tuple(&aom_highbd_fdct8x8_c, &idct8x8_10, 0, AOM_BITS_10),
+ make_tuple(&aom_highbd_fdct8x8_c, &idct8x8_12, 0, AOM_BITS_12)));
#else
INSTANTIATE_TEST_CASE_P(C, FwdTrans8x8DCT,
- ::testing::Values(make_tuple(&vpx_fdct8x8_c,
- &vpx_idct8x8_64_add_c, 0,
- VPX_BITS_8)));
-#endif // CONFIG_VP9_HIGHBITDEPTH
+ ::testing::Values(make_tuple(&aom_fdct8x8_c,
+ &aom_idct8x8_64_add_c, 0,
+ AOM_BITS_8)));
+#endif // CONFIG_AOM_HIGHBITDEPTH
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
INSTANTIATE_TEST_CASE_P(
C, FwdTrans8x8HT,
::testing::Values(
- make_tuple(&vp10_fht8x8_c, &vp10_iht8x8_64_add_c, 0, VPX_BITS_8),
- make_tuple(&vp10_highbd_fht8x8_c, &iht8x8_10, 0, VPX_BITS_10),
- make_tuple(&vp10_highbd_fht8x8_c, &iht8x8_10, 1, VPX_BITS_10),
- make_tuple(&vp10_highbd_fht8x8_c, &iht8x8_10, 2, VPX_BITS_10),
- make_tuple(&vp10_highbd_fht8x8_c, &iht8x8_10, 3, VPX_BITS_10),
- make_tuple(&vp10_highbd_fht8x8_c, &iht8x8_12, 0, VPX_BITS_12),
- make_tuple(&vp10_highbd_fht8x8_c, &iht8x8_12, 1, VPX_BITS_12),
- make_tuple(&vp10_highbd_fht8x8_c, &iht8x8_12, 2, VPX_BITS_12),
- make_tuple(&vp10_highbd_fht8x8_c, &iht8x8_12, 3, VPX_BITS_12),
- make_tuple(&vp10_fht8x8_c, &vp10_iht8x8_64_add_c, 1, VPX_BITS_8),
- make_tuple(&vp10_fht8x8_c, &vp10_iht8x8_64_add_c, 2, VPX_BITS_8),
- make_tuple(&vp10_fht8x8_c, &vp10_iht8x8_64_add_c, 3, VPX_BITS_8)));
+ make_tuple(&av1_fht8x8_c, &av1_iht8x8_64_add_c, 0, AOM_BITS_8),
+ make_tuple(&av1_highbd_fht8x8_c, &iht8x8_10, 0, AOM_BITS_10),
+ make_tuple(&av1_highbd_fht8x8_c, &iht8x8_10, 1, AOM_BITS_10),
+ make_tuple(&av1_highbd_fht8x8_c, &iht8x8_10, 2, AOM_BITS_10),
+ make_tuple(&av1_highbd_fht8x8_c, &iht8x8_10, 3, AOM_BITS_10),
+ make_tuple(&av1_highbd_fht8x8_c, &iht8x8_12, 0, AOM_BITS_12),
+ make_tuple(&av1_highbd_fht8x8_c, &iht8x8_12, 1, AOM_BITS_12),
+ make_tuple(&av1_highbd_fht8x8_c, &iht8x8_12, 2, AOM_BITS_12),
+ make_tuple(&av1_highbd_fht8x8_c, &iht8x8_12, 3, AOM_BITS_12),
+ make_tuple(&av1_fht8x8_c, &av1_iht8x8_64_add_c, 1, AOM_BITS_8),
+ make_tuple(&av1_fht8x8_c, &av1_iht8x8_64_add_c, 2, AOM_BITS_8),
+ make_tuple(&av1_fht8x8_c, &av1_iht8x8_64_add_c, 3, AOM_BITS_8)));
#else
INSTANTIATE_TEST_CASE_P(
C, FwdTrans8x8HT,
::testing::Values(
- make_tuple(&vp10_fht8x8_c, &vp10_iht8x8_64_add_c, 0, VPX_BITS_8),
- make_tuple(&vp10_fht8x8_c, &vp10_iht8x8_64_add_c, 1, VPX_BITS_8),
- make_tuple(&vp10_fht8x8_c, &vp10_iht8x8_64_add_c, 2, VPX_BITS_8),
- make_tuple(&vp10_fht8x8_c, &vp10_iht8x8_64_add_c, 3, VPX_BITS_8)));
-#endif // CONFIG_VP9_HIGHBITDEPTH
+ make_tuple(&av1_fht8x8_c, &av1_iht8x8_64_add_c, 0, AOM_BITS_8),
+ make_tuple(&av1_fht8x8_c, &av1_iht8x8_64_add_c, 1, AOM_BITS_8),
+ make_tuple(&av1_fht8x8_c, &av1_iht8x8_64_add_c, 2, AOM_BITS_8),
+ make_tuple(&av1_fht8x8_c, &av1_iht8x8_64_add_c, 3, AOM_BITS_8)));
+#endif // CONFIG_AOM_HIGHBITDEPTH
-#if HAVE_NEON_ASM && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
+#if HAVE_NEON_ASM && !CONFIG_AOM_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
INSTANTIATE_TEST_CASE_P(NEON, FwdTrans8x8DCT,
- ::testing::Values(make_tuple(&vpx_fdct8x8_neon,
- &vpx_idct8x8_64_add_neon,
- 0, VPX_BITS_8)));
-#endif // HAVE_NEON_ASM && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
+ ::testing::Values(make_tuple(&aom_fdct8x8_neon,
+ &aom_idct8x8_64_add_neon,
+ 0, AOM_BITS_8)));
+#endif // HAVE_NEON_ASM && !CONFIG_AOM_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
-#if HAVE_NEON && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
+#if HAVE_NEON && !CONFIG_AOM_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
INSTANTIATE_TEST_CASE_P(
NEON, FwdTrans8x8HT,
::testing::Values(
- make_tuple(&vp10_fht8x8_c, &vp10_iht8x8_64_add_neon, 0, VPX_BITS_8),
- make_tuple(&vp10_fht8x8_c, &vp10_iht8x8_64_add_neon, 1, VPX_BITS_8),
- make_tuple(&vp10_fht8x8_c, &vp10_iht8x8_64_add_neon, 2, VPX_BITS_8),
- make_tuple(&vp10_fht8x8_c, &vp10_iht8x8_64_add_neon, 3, VPX_BITS_8)));
-#endif // HAVE_NEON && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
+ make_tuple(&av1_fht8x8_c, &av1_iht8x8_64_add_neon, 0, AOM_BITS_8),
+ make_tuple(&av1_fht8x8_c, &av1_iht8x8_64_add_neon, 1, AOM_BITS_8),
+ make_tuple(&av1_fht8x8_c, &av1_iht8x8_64_add_neon, 2, AOM_BITS_8),
+ make_tuple(&av1_fht8x8_c, &av1_iht8x8_64_add_neon, 3, AOM_BITS_8)));
+#endif // HAVE_NEON && !CONFIG_AOM_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
-#if HAVE_SSE2 && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
+#if HAVE_SSE2 && !CONFIG_AOM_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
INSTANTIATE_TEST_CASE_P(SSE2, FwdTrans8x8DCT,
- ::testing::Values(make_tuple(&vpx_fdct8x8_sse2,
- &vpx_idct8x8_64_add_sse2,
- 0, VPX_BITS_8)));
+ ::testing::Values(make_tuple(&aom_fdct8x8_sse2,
+ &aom_idct8x8_64_add_sse2,
+ 0, AOM_BITS_8)));
INSTANTIATE_TEST_CASE_P(
SSE2, FwdTrans8x8HT,
::testing::Values(
- make_tuple(&vp10_fht8x8_sse2, &vp10_iht8x8_64_add_sse2, 0, VPX_BITS_8),
- make_tuple(&vp10_fht8x8_sse2, &vp10_iht8x8_64_add_sse2, 1, VPX_BITS_8),
- make_tuple(&vp10_fht8x8_sse2, &vp10_iht8x8_64_add_sse2, 2, VPX_BITS_8),
- make_tuple(&vp10_fht8x8_sse2, &vp10_iht8x8_64_add_sse2, 3,
- VPX_BITS_8)));
-#endif // HAVE_SSE2 && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
+ make_tuple(&av1_fht8x8_sse2, &av1_iht8x8_64_add_sse2, 0, AOM_BITS_8),
+ make_tuple(&av1_fht8x8_sse2, &av1_iht8x8_64_add_sse2, 1, AOM_BITS_8),
+ make_tuple(&av1_fht8x8_sse2, &av1_iht8x8_64_add_sse2, 2, AOM_BITS_8),
+ make_tuple(&av1_fht8x8_sse2, &av1_iht8x8_64_add_sse2, 3, AOM_BITS_8)));
+#endif // HAVE_SSE2 && !CONFIG_AOM_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
-#if HAVE_SSE2 && CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
+#if HAVE_SSE2 && CONFIG_AOM_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
INSTANTIATE_TEST_CASE_P(
SSE2, FwdTrans8x8DCT,
- ::testing::Values(make_tuple(&vpx_fdct8x8_sse2, &vpx_idct8x8_64_add_c, 0,
- VPX_BITS_8),
- make_tuple(&vpx_highbd_fdct8x8_c, &idct8x8_64_add_10_sse2,
- 12, VPX_BITS_10),
- make_tuple(&vpx_highbd_fdct8x8_sse2,
- &idct8x8_64_add_10_sse2, 12, VPX_BITS_10),
- make_tuple(&vpx_highbd_fdct8x8_c, &idct8x8_64_add_12_sse2,
- 12, VPX_BITS_12),
- make_tuple(&vpx_highbd_fdct8x8_sse2,
- &idct8x8_64_add_12_sse2, 12, VPX_BITS_12)));
+ ::testing::Values(make_tuple(&aom_fdct8x8_sse2, &aom_idct8x8_64_add_c, 0,
+ AOM_BITS_8),
+ make_tuple(&aom_highbd_fdct8x8_c, &idct8x8_64_add_10_sse2,
+ 12, AOM_BITS_10),
+ make_tuple(&aom_highbd_fdct8x8_sse2,
+ &idct8x8_64_add_10_sse2, 12, AOM_BITS_10),
+ make_tuple(&aom_highbd_fdct8x8_c, &idct8x8_64_add_12_sse2,
+ 12, AOM_BITS_12),
+ make_tuple(&aom_highbd_fdct8x8_sse2,
+ &idct8x8_64_add_12_sse2, 12, AOM_BITS_12)));
INSTANTIATE_TEST_CASE_P(
SSE2, FwdTrans8x8HT,
::testing::Values(
- make_tuple(&vp10_fht8x8_sse2, &vp10_iht8x8_64_add_c, 0, VPX_BITS_8),
- make_tuple(&vp10_fht8x8_sse2, &vp10_iht8x8_64_add_c, 1, VPX_BITS_8),
- make_tuple(&vp10_fht8x8_sse2, &vp10_iht8x8_64_add_c, 2, VPX_BITS_8),
- make_tuple(&vp10_fht8x8_sse2, &vp10_iht8x8_64_add_c, 3, VPX_BITS_8)));
+ make_tuple(&av1_fht8x8_sse2, &av1_iht8x8_64_add_c, 0, AOM_BITS_8),
+ make_tuple(&av1_fht8x8_sse2, &av1_iht8x8_64_add_c, 1, AOM_BITS_8),
+ make_tuple(&av1_fht8x8_sse2, &av1_iht8x8_64_add_c, 2, AOM_BITS_8),
+ make_tuple(&av1_fht8x8_sse2, &av1_iht8x8_64_add_c, 3, AOM_BITS_8)));
// Optimizations take effect at a threshold of 6201, so we use a value close to
// that to test both branches.
@@ -722,34 +721,34 @@
SSE2, InvTrans8x8DCT,
::testing::Values(
make_tuple(&idct8x8_10_add_10_c, &idct8x8_10_add_10_sse2, 6225,
- VPX_BITS_10),
- make_tuple(&idct8x8_10, &idct8x8_64_add_10_sse2, 6225, VPX_BITS_10),
+ AOM_BITS_10),
+ make_tuple(&idct8x8_10, &idct8x8_64_add_10_sse2, 6225, AOM_BITS_10),
make_tuple(&idct8x8_10_add_12_c, &idct8x8_10_add_12_sse2, 6225,
- VPX_BITS_12),
- make_tuple(&idct8x8_12, &idct8x8_64_add_12_sse2, 6225, VPX_BITS_12)));
-#endif // HAVE_SSE2 && CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
+ AOM_BITS_12),
+ make_tuple(&idct8x8_12, &idct8x8_64_add_12_sse2, 6225, AOM_BITS_12)));
+#endif // HAVE_SSE2 && CONFIG_AOM_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
-#if HAVE_SSSE3 && ARCH_X86_64 && !CONFIG_VP9_HIGHBITDEPTH && \
+#if HAVE_SSSE3 && ARCH_X86_64 && !CONFIG_AOM_HIGHBITDEPTH && \
!CONFIG_EMULATE_HARDWARE
INSTANTIATE_TEST_CASE_P(SSSE3, FwdTrans8x8DCT,
- ::testing::Values(make_tuple(&vpx_fdct8x8_ssse3,
- &vpx_idct8x8_64_add_ssse3,
- 0, VPX_BITS_8)));
+ ::testing::Values(make_tuple(&aom_fdct8x8_ssse3,
+ &aom_idct8x8_64_add_ssse3,
+ 0, AOM_BITS_8)));
#endif
-#if HAVE_MSA && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
+#if HAVE_MSA && !CONFIG_AOM_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
INSTANTIATE_TEST_CASE_P(MSA, FwdTrans8x8DCT,
- ::testing::Values(make_tuple(&vpx_fdct8x8_msa,
- &vpx_idct8x8_64_add_msa, 0,
- VPX_BITS_8)));
+ ::testing::Values(make_tuple(&aom_fdct8x8_msa,
+ &aom_idct8x8_64_add_msa, 0,
+ AOM_BITS_8)));
#if !CONFIG_EXT_TX
INSTANTIATE_TEST_CASE_P(
MSA, FwdTrans8x8HT,
::testing::Values(
- make_tuple(&vp10_fht8x8_msa, &vp10_iht8x8_64_add_msa, 0, VPX_BITS_8),
- make_tuple(&vp10_fht8x8_msa, &vp10_iht8x8_64_add_msa, 1, VPX_BITS_8),
- make_tuple(&vp10_fht8x8_msa, &vp10_iht8x8_64_add_msa, 2, VPX_BITS_8),
- make_tuple(&vp10_fht8x8_msa, &vp10_iht8x8_64_add_msa, 3, VPX_BITS_8)));
+ make_tuple(&av1_fht8x8_msa, &av1_iht8x8_64_add_msa, 0, AOM_BITS_8),
+ make_tuple(&av1_fht8x8_msa, &av1_iht8x8_64_add_msa, 1, AOM_BITS_8),
+ make_tuple(&av1_fht8x8_msa, &av1_iht8x8_64_add_msa, 2, AOM_BITS_8),
+ make_tuple(&av1_fht8x8_msa, &av1_iht8x8_64_add_msa, 3, AOM_BITS_8)));
#endif // !CONFIG_EXT_TX
-#endif // HAVE_MSA && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
+#endif // HAVE_MSA && !CONFIG_AOM_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
} // namespace
diff --git a/test/frame_size_tests.cc b/test/frame_size_tests.cc
index ff05119..4faa304 100644
--- a/test/frame_size_tests.cc
+++ b/test/frame_size_tests.cc
@@ -13,19 +13,19 @@
namespace {
-class VP9FrameSizeTestsLarge : public ::libaom_test::EncoderTest,
+class AV1FrameSizeTestsLarge : public ::libaom_test::EncoderTest,
public ::testing::Test {
protected:
- VP9FrameSizeTestsLarge()
- : EncoderTest(&::libaom_test::kVP10), expected_res_(VPX_CODEC_OK) {}
- virtual ~VP9FrameSizeTestsLarge() {}
+ AV1FrameSizeTestsLarge()
+ : EncoderTest(&::libaom_test::kAV1), expected_res_(AOM_CODEC_OK) {}
+ virtual ~AV1FrameSizeTestsLarge() {}
virtual void SetUp() {
InitializeConfig();
SetMode(::libaom_test::kRealTime);
}
- virtual bool HandleDecodeResult(const vpx_codec_err_t res_dec,
+ virtual bool HandleDecodeResult(const aom_codec_err_t res_dec,
const libaom_test::VideoSource & /*video*/,
libaom_test::Decoder *decoder) {
EXPECT_EQ(expected_res_, res_dec) << decoder->DecodeError();
@@ -35,35 +35,35 @@
virtual void PreEncodeFrameHook(::libaom_test::VideoSource *video,
::libaom_test::Encoder *encoder) {
if (video->frame() == 1) {
- encoder->Control(VP8E_SET_CPUUSED, 7);
- encoder->Control(VP8E_SET_ENABLEAUTOALTREF, 1);
- encoder->Control(VP8E_SET_ARNR_MAXFRAMES, 7);
- encoder->Control(VP8E_SET_ARNR_STRENGTH, 5);
- encoder->Control(VP8E_SET_ARNR_TYPE, 3);
+ encoder->Control(AOME_SET_CPUUSED, 7);
+ encoder->Control(AOME_SET_ENABLEAUTOALTREF, 1);
+ encoder->Control(AOME_SET_ARNR_MAXFRAMES, 7);
+ encoder->Control(AOME_SET_ARNR_STRENGTH, 5);
+ encoder->Control(AOME_SET_ARNR_TYPE, 3);
}
}
int expected_res_;
};
-TEST_F(VP9FrameSizeTestsLarge, TestInvalidSizes) {
+TEST_F(AV1FrameSizeTestsLarge, TestInvalidSizes) {
::libaom_test::RandomVideoSource video;
#if CONFIG_SIZE_LIMIT
video.SetSize(DECODE_WIDTH_LIMIT + 16, DECODE_HEIGHT_LIMIT + 16);
video.set_limit(2);
- expected_res_ = VPX_CODEC_CORRUPT_FRAME;
+ expected_res_ = AOM_CODEC_CORRUPT_FRAME;
ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
#endif
}
-TEST_F(VP9FrameSizeTestsLarge, ValidSizes) {
+TEST_F(AV1FrameSizeTestsLarge, ValidSizes) {
::libaom_test::RandomVideoSource video;
#if CONFIG_SIZE_LIMIT
video.SetSize(DECODE_WIDTH_LIMIT, DECODE_HEIGHT_LIMIT);
video.set_limit(2);
- expected_res_ = VPX_CODEC_OK;
+ expected_res_ = AOM_CODEC_OK;
ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
#else
// This test produces a pretty large single frame allocation, (roughly
@@ -79,17 +79,17 @@
video.SetSize(4096, 4096);
#endif
video.set_limit(2);
- expected_res_ = VPX_CODEC_OK;
+ expected_res_ = AOM_CODEC_OK;
ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
#endif
}
-TEST_F(VP9FrameSizeTestsLarge, OneByOneVideo) {
+TEST_F(AV1FrameSizeTestsLarge, OneByOneVideo) {
::libaom_test::RandomVideoSource video;
video.SetSize(1, 1);
video.set_limit(2);
- expected_res_ = VPX_CODEC_OK;
+ expected_res_ = AOM_CODEC_OK;
ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
}
} // namespace
diff --git a/test/hadamard_test.cc b/test/hadamard_test.cc
index 1f86e9c..bc8a406 100644
--- a/test/hadamard_test.cc
+++ b/test/hadamard_test.cc
@@ -12,7 +12,7 @@
#include "third_party/googletest/src/include/gtest/gtest.h"
-#include "./vpx_dsp_rtcd.h"
+#include "./aom_dsp_rtcd.h"
#include "test/acm_random.h"
#include "test/register_state_check.h"
@@ -145,21 +145,21 @@
}
INSTANTIATE_TEST_CASE_P(C, Hadamard8x8Test,
- ::testing::Values(&vpx_hadamard_8x8_c));
+ ::testing::Values(&aom_hadamard_8x8_c));
#if HAVE_SSE2
INSTANTIATE_TEST_CASE_P(SSE2, Hadamard8x8Test,
- ::testing::Values(&vpx_hadamard_8x8_sse2));
+ ::testing::Values(&aom_hadamard_8x8_sse2));
#endif // HAVE_SSE2
#if HAVE_SSSE3 && ARCH_X86_64
INSTANTIATE_TEST_CASE_P(SSSE3, Hadamard8x8Test,
- ::testing::Values(&vpx_hadamard_8x8_ssse3));
+ ::testing::Values(&aom_hadamard_8x8_ssse3));
#endif // HAVE_SSSE3 && ARCH_X86_64
#if HAVE_NEON
INSTANTIATE_TEST_CASE_P(NEON, Hadamard8x8Test,
- ::testing::Values(&vpx_hadamard_8x8_neon));
+ ::testing::Values(&aom_hadamard_8x8_neon));
#endif // HAVE_NEON
class Hadamard16x16Test : public HadamardTestBase {};
@@ -206,15 +206,15 @@
}
INSTANTIATE_TEST_CASE_P(C, Hadamard16x16Test,
- ::testing::Values(&vpx_hadamard_16x16_c));
+ ::testing::Values(&aom_hadamard_16x16_c));
#if HAVE_SSE2
INSTANTIATE_TEST_CASE_P(SSE2, Hadamard16x16Test,
- ::testing::Values(&vpx_hadamard_16x16_sse2));
+ ::testing::Values(&aom_hadamard_16x16_sse2));
#endif // HAVE_SSE2
#if HAVE_NEON
INSTANTIATE_TEST_CASE_P(NEON, Hadamard16x16Test,
- ::testing::Values(&vpx_hadamard_16x16_neon));
+ ::testing::Values(&aom_hadamard_16x16_neon));
#endif // HAVE_NEON
} // namespace
diff --git a/test/hbd_metrics_test.cc b/test/hbd_metrics_test.cc
index a7c1ec3..d22b804 100644
--- a/test/hbd_metrics_test.cc
+++ b/test/hbd_metrics_test.cc
@@ -15,7 +15,7 @@
#include "third_party/googletest/src/include/gtest/gtest.h"
#include "test/acm_random.h"
#include "test/util.h"
-#include "./vpx_config.h"
+#include "./aom_config.h"
#include "aom_dsp/psnr.h"
#include "aom_dsp/ssim.h"
#include "aom_ports/mem.h"
@@ -36,14 +36,14 @@
const YV12_BUFFER_CONFIG *dest, uint32_t in_bd,
uint32_t bd) {
PSNR_STATS psnr;
- vpx_calc_highbd_psnr(source, dest, &psnr, bd, in_bd);
+ aom_calc_highbd_psnr(source, dest, &psnr, bd, in_bd);
return psnr.psnr[0];
}
double compute_psnr(const YV12_BUFFER_CONFIG *source,
const YV12_BUFFER_CONFIG *dest) {
PSNR_STATS psnr;
- vpx_calc_psnr(source, dest, &psnr);
+ aom_calc_psnr(source, dest, &psnr);
return psnr.psnr[0];
}
@@ -51,40 +51,40 @@
const YV12_BUFFER_CONFIG *dest, uint32_t in_bd,
uint32_t bd) {
double tempy, tempu, tempv;
- return vpx_psnrhvs(source, dest, &tempy, &tempu, &tempv, bd, in_bd);
+ return aom_psnrhvs(source, dest, &tempy, &tempu, &tempv, bd, in_bd);
}
double compute_psnrhvs(const YV12_BUFFER_CONFIG *source,
const YV12_BUFFER_CONFIG *dest) {
double tempy, tempu, tempv;
- return vpx_psnrhvs(source, dest, &tempy, &tempu, &tempv, 8, 8);
+ return aom_psnrhvs(source, dest, &tempy, &tempu, &tempv, 8, 8);
}
double compute_hbd_fastssim(const YV12_BUFFER_CONFIG *source,
const YV12_BUFFER_CONFIG *dest, uint32_t in_bd,
uint32_t bd) {
double tempy, tempu, tempv;
- return vpx_calc_fastssim(source, dest, &tempy, &tempu, &tempv, bd, in_bd);
+ return aom_calc_fastssim(source, dest, &tempy, &tempu, &tempv, bd, in_bd);
}
double compute_fastssim(const YV12_BUFFER_CONFIG *source,
const YV12_BUFFER_CONFIG *dest) {
double tempy, tempu, tempv;
- return vpx_calc_fastssim(source, dest, &tempy, &tempu, &tempv, 8, 8);
+ return aom_calc_fastssim(source, dest, &tempy, &tempu, &tempv, 8, 8);
}
-double compute_hbd_vpxssim(const YV12_BUFFER_CONFIG *source,
+double compute_hbd_aomssim(const YV12_BUFFER_CONFIG *source,
const YV12_BUFFER_CONFIG *dest, uint32_t in_bd,
uint32_t bd) {
double ssim, weight;
- ssim = vpx_highbd_calc_ssim(source, dest, &weight, bd, in_bd);
+ ssim = aom_highbd_calc_ssim(source, dest, &weight, bd, in_bd);
return 100 * pow(ssim / weight, 8.0);
}
-double compute_vpxssim(const YV12_BUFFER_CONFIG *source,
+double compute_aomssim(const YV12_BUFFER_CONFIG *source,
const YV12_BUFFER_CONFIG *dest) {
double ssim, weight;
- ssim = vpx_calc_ssim(source, dest, &weight);
+ ssim = aom_calc_ssim(source, dest, &weight);
return 100 * pow(ssim / weight, 8.0);
}
@@ -108,10 +108,10 @@
memset(&hbd_src, 0, sizeof(hbd_src));
memset(&hbd_dst, 0, sizeof(hbd_dst));
- vpx_alloc_frame_buffer(&lbd_src, width, height, 1, 1, 0, 32, 16);
- vpx_alloc_frame_buffer(&lbd_dst, width, height, 1, 1, 0, 32, 16);
- vpx_alloc_frame_buffer(&hbd_src, width, height, 1, 1, 1, 32, 16);
- vpx_alloc_frame_buffer(&hbd_dst, width, height, 1, 1, 1, 32, 16);
+ aom_alloc_frame_buffer(&lbd_src, width, height, 1, 1, 0, 32, 16);
+ aom_alloc_frame_buffer(&lbd_dst, width, height, 1, 1, 0, 32, 16);
+ aom_alloc_frame_buffer(&hbd_src, width, height, 1, 1, 1, 32, 16);
+ aom_alloc_frame_buffer(&hbd_dst, width, height, 1, 1, 1, 32, 16);
memset(lbd_src.buffer_alloc, kPixFiller, lbd_src.buffer_alloc_sz);
while (i < lbd_src.buffer_alloc_sz) {
@@ -157,10 +157,10 @@
hbd_db = hbd_metric_(&hbd_src, &hbd_dst, input_bit_depth_, bit_depth_);
EXPECT_LE(fabs(lbd_db - hbd_db), threshold_);
- vpx_free_frame_buffer(&lbd_src);
- vpx_free_frame_buffer(&lbd_dst);
- vpx_free_frame_buffer(&hbd_src);
- vpx_free_frame_buffer(&hbd_dst);
+ aom_free_frame_buffer(&lbd_src);
+ aom_free_frame_buffer(&lbd_dst);
+ aom_free_frame_buffer(&hbd_src);
+ aom_free_frame_buffer(&hbd_dst);
}
int input_bit_depth_;
@@ -195,14 +195,14 @@
static const double kPhvs_thresh = 0.3;
INSTANTIATE_TEST_CASE_P(
- VPXSSIM, HBDMetricsTest,
- ::testing::Values(MetricTestTParam(&compute_vpxssim, &compute_hbd_vpxssim,
+ AOMSSIM, HBDMetricsTest,
+ ::testing::Values(MetricTestTParam(&compute_aomssim, &compute_hbd_aomssim,
8, 10, kSsim_thresh),
- MetricTestTParam(&compute_vpxssim, &compute_hbd_vpxssim,
+ MetricTestTParam(&compute_aomssim, &compute_hbd_aomssim,
10, 10, kPhvs_thresh),
- MetricTestTParam(&compute_vpxssim, &compute_hbd_vpxssim,
+ MetricTestTParam(&compute_aomssim, &compute_hbd_aomssim,
8, 12, kSsim_thresh),
- MetricTestTParam(&compute_vpxssim, &compute_hbd_vpxssim,
+ MetricTestTParam(&compute_aomssim, &compute_hbd_aomssim,
12, 12, kPhvs_thresh)));
INSTANTIATE_TEST_CASE_P(
FASTSSIM, HBDMetricsTest,
diff --git a/test/i420_video_source.h b/test/i420_video_source.h
index d1324af..8e817ec 100644
--- a/test/i420_video_source.h
+++ b/test/i420_video_source.h
@@ -24,7 +24,7 @@
I420VideoSource(const std::string &file_name, unsigned int width,
unsigned int height, int rate_numerator, int rate_denominator,
unsigned int start, int limit)
- : YUVVideoSource(file_name, VPX_IMG_FMT_I420, width, height,
+ : YUVVideoSource(file_name, AOM_IMG_FMT_I420, width, height,
rate_numerator, rate_denominator, start, limit) {}
};
diff --git a/test/idct8x8_test.cc b/test/idct8x8_test.cc
index 52d3f4f..9957ee6 100644
--- a/test/idct8x8_test.cc
+++ b/test/idct8x8_test.cc
@@ -14,9 +14,9 @@
#include "third_party/googletest/src/include/gtest/gtest.h"
-#include "./vpx_dsp_rtcd.h"
+#include "./aom_dsp_rtcd.h"
#include "test/acm_random.h"
-#include "aom/vpx_integer.h"
+#include "aom/aom_integer.h"
#include "aom_ports/msvc.h" // for round()
using libaom_test::ACMRandom;
@@ -53,7 +53,7 @@
for (int i = 0; i < 64; ++i) output[i] *= 2;
}
-TEST(VP9Idct8x8Test, AccuracyCheck) {
+TEST(AV1Idct8x8Test, AccuracyCheck) {
ACMRandom rnd(ACMRandom::DeterministicSeed());
const int count_test_block = 10000;
for (int i = 0; i < count_test_block; ++i) {
@@ -72,7 +72,7 @@
reference_dct_2d(input, output_r);
for (int j = 0; j < 64; ++j)
coeff[j] = static_cast<tran_low_t>(round(output_r[j]));
- vpx_idct8x8_64_add_c(coeff, dst, 8);
+ aom_idct8x8_64_add_c(coeff, dst, 8);
for (int j = 0; j < 64; ++j) {
const int diff = dst[j] - src[j];
const int error = diff * diff;
diff --git a/test/idct_test.cc b/test/idct_test.cc
index a1264a8..db6734c 100644
--- a/test/idct_test.cc
+++ b/test/idct_test.cc
@@ -8,13 +8,14 @@
* be found in the AUTHORS file in the root of the source tree.
*/
-#include "./vpx_config.h"
+#include "./aom_config.h"
+#include "./aom_rtcd.h"
#include "third_party/googletest/src/include/gtest/gtest.h"
#include "test/clear_system_state.h"
#include "test/register_state_check.h"
-#include "aom/vpx_integer.h"
+#include "aom/aom_integer.h"
typedef void (*IdctFunc)(int16_t *input, unsigned char *pred_ptr,
int pred_stride, unsigned char *dst_ptr,
@@ -108,13 +109,13 @@
EXPECT_EQ(0, output[i]) << "i==" << i;
}
-INSTANTIATE_TEST_CASE_P(C, IDCTTest, ::testing::Values(vp8_short_idct4x4llm_c));
+INSTANTIATE_TEST_CASE_P(C, IDCTTest, ::testing::Values(aom_short_idct4x4llm_c));
#if HAVE_MMX
INSTANTIATE_TEST_CASE_P(MMX, IDCTTest,
- ::testing::Values(vp8_short_idct4x4llm_mmx));
+ ::testing::Values(aom_short_idct4x4llm_mmx));
#endif
#if HAVE_MSA
INSTANTIATE_TEST_CASE_P(MSA, IDCTTest,
- ::testing::Values(vp8_short_idct4x4llm_msa));
+ ::testing::Values(aom_short_idct4x4llm_msa));
#endif
}
diff --git a/test/intrapred_test.cc b/test/intrapred_test.cc
index 0cedb12..efa57f7 100644
--- a/test/intrapred_test.cc
+++ b/test/intrapred_test.cc
@@ -12,15 +12,15 @@
#include "third_party/googletest/src/include/gtest/gtest.h"
-#include "./vpx_config.h"
-#include "./vpx_dsp_rtcd.h"
+#include "./aom_config.h"
+#include "./aom_dsp_rtcd.h"
#include "test/acm_random.h"
#include "test/clear_system_state.h"
#include "test/register_state_check.h"
#include "test/util.h"
#include "av1/common/blockd.h"
#include "av1/common/pred_common.h"
-#include "aom_mem/vpx_mem.h"
+#include "aom_mem/aom_mem.h"
namespace {
@@ -43,7 +43,7 @@
int bit_depth;
};
-class VP9IntraPredTest : public ::testing::TestWithParam<IntraPredFunc> {
+class AV1IntraPredTest : public ::testing::TestWithParam<IntraPredFunc> {
public:
void RunTest(uint16_t *left_col, uint16_t *above_data, uint16_t *dst,
uint16_t *ref_dst) {
@@ -114,7 +114,7 @@
IntraPredFunc params_;
};
-TEST_P(VP9IntraPredTest, IntraPredTests) {
+TEST_P(AV1IntraPredTest, IntraPredTests) {
// max block size is 32
DECLARE_ALIGNED(16, uint16_t, left_col[2 * 32]);
DECLARE_ALIGNED(16, uint16_t, above_data[2 * 32 + 32]);
@@ -124,88 +124,88 @@
}
#if HAVE_SSE2
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
INSTANTIATE_TEST_CASE_P(
- SSE2_TO_C_8, VP9IntraPredTest,
- ::testing::Values(IntraPredFunc(&vpx_highbd_dc_predictor_32x32_sse2,
- &vpx_highbd_dc_predictor_32x32_c, 32, 8),
- IntraPredFunc(&vpx_highbd_tm_predictor_16x16_sse2,
- &vpx_highbd_tm_predictor_16x16_c, 16, 8),
- IntraPredFunc(&vpx_highbd_tm_predictor_32x32_sse2,
- &vpx_highbd_tm_predictor_32x32_c, 32, 8),
- IntraPredFunc(&vpx_highbd_dc_predictor_4x4_sse2,
- &vpx_highbd_dc_predictor_4x4_c, 4, 8),
- IntraPredFunc(&vpx_highbd_dc_predictor_8x8_sse2,
- &vpx_highbd_dc_predictor_8x8_c, 8, 8),
- IntraPredFunc(&vpx_highbd_dc_predictor_16x16_sse2,
- &vpx_highbd_dc_predictor_16x16_c, 16, 8),
- IntraPredFunc(&vpx_highbd_v_predictor_4x4_sse2,
- &vpx_highbd_v_predictor_4x4_c, 4, 8),
- IntraPredFunc(&vpx_highbd_v_predictor_8x8_sse2,
- &vpx_highbd_v_predictor_8x8_c, 8, 8),
- IntraPredFunc(&vpx_highbd_v_predictor_16x16_sse2,
- &vpx_highbd_v_predictor_16x16_c, 16, 8),
- IntraPredFunc(&vpx_highbd_v_predictor_32x32_sse2,
- &vpx_highbd_v_predictor_32x32_c, 32, 8),
- IntraPredFunc(&vpx_highbd_tm_predictor_4x4_sse2,
- &vpx_highbd_tm_predictor_4x4_c, 4, 8),
- IntraPredFunc(&vpx_highbd_tm_predictor_8x8_sse2,
- &vpx_highbd_tm_predictor_8x8_c, 8, 8)));
+ SSE2_TO_C_8, AV1IntraPredTest,
+ ::testing::Values(IntraPredFunc(&aom_highbd_dc_predictor_32x32_sse2,
+ &aom_highbd_dc_predictor_32x32_c, 32, 8),
+ IntraPredFunc(&aom_highbd_tm_predictor_16x16_sse2,
+ &aom_highbd_tm_predictor_16x16_c, 16, 8),
+ IntraPredFunc(&aom_highbd_tm_predictor_32x32_sse2,
+ &aom_highbd_tm_predictor_32x32_c, 32, 8),
+ IntraPredFunc(&aom_highbd_dc_predictor_4x4_sse2,
+ &aom_highbd_dc_predictor_4x4_c, 4, 8),
+ IntraPredFunc(&aom_highbd_dc_predictor_8x8_sse2,
+ &aom_highbd_dc_predictor_8x8_c, 8, 8),
+ IntraPredFunc(&aom_highbd_dc_predictor_16x16_sse2,
+ &aom_highbd_dc_predictor_16x16_c, 16, 8),
+ IntraPredFunc(&aom_highbd_v_predictor_4x4_sse2,
+ &aom_highbd_v_predictor_4x4_c, 4, 8),
+ IntraPredFunc(&aom_highbd_v_predictor_8x8_sse2,
+ &aom_highbd_v_predictor_8x8_c, 8, 8),
+ IntraPredFunc(&aom_highbd_v_predictor_16x16_sse2,
+ &aom_highbd_v_predictor_16x16_c, 16, 8),
+ IntraPredFunc(&aom_highbd_v_predictor_32x32_sse2,
+ &aom_highbd_v_predictor_32x32_c, 32, 8),
+ IntraPredFunc(&aom_highbd_tm_predictor_4x4_sse2,
+ &aom_highbd_tm_predictor_4x4_c, 4, 8),
+ IntraPredFunc(&aom_highbd_tm_predictor_8x8_sse2,
+ &aom_highbd_tm_predictor_8x8_c, 8, 8)));
INSTANTIATE_TEST_CASE_P(
- SSE2_TO_C_10, VP9IntraPredTest,
- ::testing::Values(IntraPredFunc(&vpx_highbd_dc_predictor_32x32_sse2,
- &vpx_highbd_dc_predictor_32x32_c, 32, 10),
- IntraPredFunc(&vpx_highbd_tm_predictor_16x16_sse2,
- &vpx_highbd_tm_predictor_16x16_c, 16, 10),
- IntraPredFunc(&vpx_highbd_tm_predictor_32x32_sse2,
- &vpx_highbd_tm_predictor_32x32_c, 32, 10),
- IntraPredFunc(&vpx_highbd_dc_predictor_4x4_sse2,
- &vpx_highbd_dc_predictor_4x4_c, 4, 10),
- IntraPredFunc(&vpx_highbd_dc_predictor_8x8_sse2,
- &vpx_highbd_dc_predictor_8x8_c, 8, 10),
- IntraPredFunc(&vpx_highbd_dc_predictor_16x16_sse2,
- &vpx_highbd_dc_predictor_16x16_c, 16, 10),
- IntraPredFunc(&vpx_highbd_v_predictor_4x4_sse2,
- &vpx_highbd_v_predictor_4x4_c, 4, 10),
- IntraPredFunc(&vpx_highbd_v_predictor_8x8_sse2,
- &vpx_highbd_v_predictor_8x8_c, 8, 10),
- IntraPredFunc(&vpx_highbd_v_predictor_16x16_sse2,
- &vpx_highbd_v_predictor_16x16_c, 16, 10),
- IntraPredFunc(&vpx_highbd_v_predictor_32x32_sse2,
- &vpx_highbd_v_predictor_32x32_c, 32, 10),
- IntraPredFunc(&vpx_highbd_tm_predictor_4x4_sse2,
- &vpx_highbd_tm_predictor_4x4_c, 4, 10),
- IntraPredFunc(&vpx_highbd_tm_predictor_8x8_sse2,
- &vpx_highbd_tm_predictor_8x8_c, 8, 10)));
+ SSE2_TO_C_10, AV1IntraPredTest,
+ ::testing::Values(IntraPredFunc(&aom_highbd_dc_predictor_32x32_sse2,
+ &aom_highbd_dc_predictor_32x32_c, 32, 10),
+ IntraPredFunc(&aom_highbd_tm_predictor_16x16_sse2,
+ &aom_highbd_tm_predictor_16x16_c, 16, 10),
+ IntraPredFunc(&aom_highbd_tm_predictor_32x32_sse2,
+ &aom_highbd_tm_predictor_32x32_c, 32, 10),
+ IntraPredFunc(&aom_highbd_dc_predictor_4x4_sse2,
+ &aom_highbd_dc_predictor_4x4_c, 4, 10),
+ IntraPredFunc(&aom_highbd_dc_predictor_8x8_sse2,
+ &aom_highbd_dc_predictor_8x8_c, 8, 10),
+ IntraPredFunc(&aom_highbd_dc_predictor_16x16_sse2,
+ &aom_highbd_dc_predictor_16x16_c, 16, 10),
+ IntraPredFunc(&aom_highbd_v_predictor_4x4_sse2,
+ &aom_highbd_v_predictor_4x4_c, 4, 10),
+ IntraPredFunc(&aom_highbd_v_predictor_8x8_sse2,
+ &aom_highbd_v_predictor_8x8_c, 8, 10),
+ IntraPredFunc(&aom_highbd_v_predictor_16x16_sse2,
+ &aom_highbd_v_predictor_16x16_c, 16, 10),
+ IntraPredFunc(&aom_highbd_v_predictor_32x32_sse2,
+ &aom_highbd_v_predictor_32x32_c, 32, 10),
+ IntraPredFunc(&aom_highbd_tm_predictor_4x4_sse2,
+ &aom_highbd_tm_predictor_4x4_c, 4, 10),
+ IntraPredFunc(&aom_highbd_tm_predictor_8x8_sse2,
+ &aom_highbd_tm_predictor_8x8_c, 8, 10)));
INSTANTIATE_TEST_CASE_P(
- SSE2_TO_C_12, VP9IntraPredTest,
- ::testing::Values(IntraPredFunc(&vpx_highbd_dc_predictor_32x32_sse2,
- &vpx_highbd_dc_predictor_32x32_c, 32, 12),
- IntraPredFunc(&vpx_highbd_tm_predictor_16x16_sse2,
- &vpx_highbd_tm_predictor_16x16_c, 16, 12),
- IntraPredFunc(&vpx_highbd_tm_predictor_32x32_sse2,
- &vpx_highbd_tm_predictor_32x32_c, 32, 12),
- IntraPredFunc(&vpx_highbd_dc_predictor_4x4_sse2,
- &vpx_highbd_dc_predictor_4x4_c, 4, 12),
- IntraPredFunc(&vpx_highbd_dc_predictor_8x8_sse2,
- &vpx_highbd_dc_predictor_8x8_c, 8, 12),
- IntraPredFunc(&vpx_highbd_dc_predictor_16x16_sse2,
- &vpx_highbd_dc_predictor_16x16_c, 16, 12),
- IntraPredFunc(&vpx_highbd_v_predictor_4x4_sse2,
- &vpx_highbd_v_predictor_4x4_c, 4, 12),
- IntraPredFunc(&vpx_highbd_v_predictor_8x8_sse2,
- &vpx_highbd_v_predictor_8x8_c, 8, 12),
- IntraPredFunc(&vpx_highbd_v_predictor_16x16_sse2,
- &vpx_highbd_v_predictor_16x16_c, 16, 12),
- IntraPredFunc(&vpx_highbd_v_predictor_32x32_sse2,
- &vpx_highbd_v_predictor_32x32_c, 32, 12),
- IntraPredFunc(&vpx_highbd_tm_predictor_4x4_sse2,
- &vpx_highbd_tm_predictor_4x4_c, 4, 12),
- IntraPredFunc(&vpx_highbd_tm_predictor_8x8_sse2,
- &vpx_highbd_tm_predictor_8x8_c, 8, 12)));
+ SSE2_TO_C_12, AV1IntraPredTest,
+ ::testing::Values(IntraPredFunc(&aom_highbd_dc_predictor_32x32_sse2,
+ &aom_highbd_dc_predictor_32x32_c, 32, 12),
+ IntraPredFunc(&aom_highbd_tm_predictor_16x16_sse2,
+ &aom_highbd_tm_predictor_16x16_c, 16, 12),
+ IntraPredFunc(&aom_highbd_tm_predictor_32x32_sse2,
+ &aom_highbd_tm_predictor_32x32_c, 32, 12),
+ IntraPredFunc(&aom_highbd_dc_predictor_4x4_sse2,
+ &aom_highbd_dc_predictor_4x4_c, 4, 12),
+ IntraPredFunc(&aom_highbd_dc_predictor_8x8_sse2,
+ &aom_highbd_dc_predictor_8x8_c, 8, 12),
+ IntraPredFunc(&aom_highbd_dc_predictor_16x16_sse2,
+ &aom_highbd_dc_predictor_16x16_c, 16, 12),
+ IntraPredFunc(&aom_highbd_v_predictor_4x4_sse2,
+ &aom_highbd_v_predictor_4x4_c, 4, 12),
+ IntraPredFunc(&aom_highbd_v_predictor_8x8_sse2,
+ &aom_highbd_v_predictor_8x8_c, 8, 12),
+ IntraPredFunc(&aom_highbd_v_predictor_16x16_sse2,
+ &aom_highbd_v_predictor_16x16_c, 16, 12),
+ IntraPredFunc(&aom_highbd_v_predictor_32x32_sse2,
+ &aom_highbd_v_predictor_32x32_c, 32, 12),
+ IntraPredFunc(&aom_highbd_tm_predictor_4x4_sse2,
+ &aom_highbd_tm_predictor_4x4_c, 4, 12),
+ IntraPredFunc(&aom_highbd_tm_predictor_8x8_sse2,
+ &aom_highbd_tm_predictor_8x8_c, 8, 12)));
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#endif // CONFIG_AOM_HIGHBITDEPTH
#endif // HAVE_SSE2
} // namespace
diff --git a/test/level_test.cc b/test/level_test.cc
index 0a12668..3c46903 100644
--- a/test/level_test.cc
+++ b/test/level_test.cc
@@ -29,10 +29,10 @@
SetMode(encoding_mode_);
if (encoding_mode_ != ::libaom_test::kRealTime) {
cfg_.g_lag_in_frames = 25;
- cfg_.rc_end_usage = VPX_VBR;
+ cfg_.rc_end_usage = AOM_VBR;
} else {
cfg_.g_lag_in_frames = 0;
- cfg_.rc_end_usage = VPX_CBR;
+ cfg_.rc_end_usage = AOM_CBR;
}
cfg_.rc_2pass_vbr_minsection_pct = 5;
cfg_.rc_2pass_vbr_maxsection_pct = 2000;
@@ -44,17 +44,17 @@
virtual void PreEncodeFrameHook(::libaom_test::VideoSource *video,
::libaom_test::Encoder *encoder) {
if (video->frame() == 0) {
- encoder->Control(VP8E_SET_CPUUSED, cpu_used_);
- encoder->Control(VP9E_SET_TARGET_LEVEL, target_level_);
- encoder->Control(VP9E_SET_MIN_GF_INTERVAL, min_gf_internal_);
+ encoder->Control(AOME_SET_CPUUSED, cpu_used_);
+ encoder->Control(AV1E_SET_TARGET_LEVEL, target_level_);
+ encoder->Control(AV1E_SET_MIN_GF_INTERVAL, min_gf_internal_);
if (encoding_mode_ != ::libaom_test::kRealTime) {
- encoder->Control(VP8E_SET_ENABLEAUTOALTREF, 1);
- encoder->Control(VP8E_SET_ARNR_MAXFRAMES, 7);
- encoder->Control(VP8E_SET_ARNR_STRENGTH, 5);
- encoder->Control(VP8E_SET_ARNR_TYPE, 3);
+ encoder->Control(AOME_SET_ENABLEAUTOALTREF, 1);
+ encoder->Control(AOME_SET_ARNR_MAXFRAMES, 7);
+ encoder->Control(AOME_SET_ARNR_STRENGTH, 5);
+ encoder->Control(AOME_SET_ARNR_TYPE, 3);
}
}
- encoder->Control(VP9E_GET_LEVEL, &level_);
+ encoder->Control(AV1E_GET_LEVEL, &level_);
ASSERT_LE(level_, 51);
ASSERT_GE(level_, 0);
}
@@ -90,26 +90,26 @@
TEST_P(LevelTest, TestTargetLevelApi) {
::libaom_test::I420VideoSource video("hantro_odd.yuv", 208, 144, 30, 1, 0, 1);
- static const vpx_codec_iface_t *codec = &vpx_codec_vp9_cx_algo;
- vpx_codec_ctx_t enc;
- vpx_codec_enc_cfg_t cfg;
- EXPECT_EQ(VPX_CODEC_OK, vpx_codec_enc_config_default(codec, &cfg, 0));
- EXPECT_EQ(VPX_CODEC_OK, vpx_codec_enc_init(&enc, codec, &cfg, 0));
+ static const aom_codec_iface_t *codec = &aom_codec_av1_cx_algo;
+ aom_codec_ctx_t enc;
+ aom_codec_enc_cfg_t cfg;
+ EXPECT_EQ(AOM_CODEC_OK, aom_codec_enc_config_default(codec, &cfg, 0));
+ EXPECT_EQ(AOM_CODEC_OK, aom_codec_enc_init(&enc, codec, &cfg, 0));
for (int level = 0; level <= 256; ++level) {
if (level == 10 || level == 11 || level == 20 || level == 21 ||
level == 30 || level == 31 || level == 40 || level == 41 ||
level == 50 || level == 51 || level == 52 || level == 60 ||
level == 61 || level == 62 || level == 0 || level == 255)
- EXPECT_EQ(VPX_CODEC_OK,
- vpx_codec_control(&enc, VP9E_SET_TARGET_LEVEL, level));
+ EXPECT_EQ(AOM_CODEC_OK,
+ aom_codec_control(&enc, AV1E_SET_TARGET_LEVEL, level));
else
- EXPECT_EQ(VPX_CODEC_INVALID_PARAM,
- vpx_codec_control(&enc, VP9E_SET_TARGET_LEVEL, level));
+ EXPECT_EQ(AOM_CODEC_INVALID_PARAM,
+ aom_codec_control(&enc, AV1E_SET_TARGET_LEVEL, level));
}
- EXPECT_EQ(VPX_CODEC_OK, vpx_codec_destroy(&enc));
+ EXPECT_EQ(AOM_CODEC_OK, aom_codec_destroy(&enc));
}
-VP9_INSTANTIATE_TEST_CASE(LevelTest,
+AV1_INSTANTIATE_TEST_CASE(LevelTest,
::testing::Values(::libaom_test::kTwoPassGood,
::libaom_test::kOnePassGood),
::testing::Range(0, 9));
diff --git a/test/lossless_test.cc b/test/lossless_test.cc
index 3989e93..8a94248 100644
--- a/test/lossless_test.cc
+++ b/test/lossless_test.cc
@@ -10,7 +10,7 @@
#include "third_party/googletest/src/include/gtest/gtest.h"
-#include "./vpx_config.h"
+#include "./aom_config.h"
#include "test/codec_factory.h"
#include "test/encode_test_driver.h"
#include "test/i420_video_source.h"
@@ -42,7 +42,7 @@
// Only call Control if quantizer > 0 to verify that using quantizer
// alone will activate lossless
if (cfg_.rc_max_quantizer > 0 || cfg_.rc_min_quantizer > 0) {
- encoder->Control(VP9E_SET_LOSSLESS, 1);
+ encoder->Control(AV1E_SET_LOSSLESS, 1);
}
}
}
@@ -52,7 +52,7 @@
nframes_ = 0;
}
- virtual void PSNRPktHook(const vpx_codec_cx_pkt_t *pkt) {
+ virtual void PSNRPktHook(const aom_codec_cx_pkt_t *pkt) {
if (pkt->data.psnr.psnr[0] < psnr_) psnr_ = pkt->data.psnr.psnr[0];
}
@@ -65,14 +65,14 @@
};
TEST_P(LosslessTestLarge, TestLossLessEncoding) {
- const vpx_rational timebase = { 33333333, 1000000000 };
+ const aom_rational timebase = { 33333333, 1000000000 };
cfg_.g_timebase = timebase;
cfg_.rc_target_bitrate = 2000;
cfg_.g_lag_in_frames = 25;
cfg_.rc_min_quantizer = 0;
cfg_.rc_max_quantizer = 0;
- init_flags_ = VPX_CODEC_USE_PSNR;
+ init_flags_ = AOM_CODEC_USE_PSNR;
// intentionally changed the dimension for better testing coverage
libaom_test::I420VideoSource video("hantro_collage_w352h288.yuv", 352, 288,
@@ -92,7 +92,7 @@
cfg_.rc_min_quantizer = 0;
cfg_.rc_max_quantizer = 0;
- init_flags_ = VPX_CODEC_USE_PSNR;
+ init_flags_ = AOM_CODEC_USE_PSNR;
ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
const double psnr_lossless = GetMinPsnr();
@@ -100,7 +100,7 @@
}
TEST_P(LosslessTestLarge, TestLossLessEncodingCtrl) {
- const vpx_rational timebase = { 33333333, 1000000000 };
+ const aom_rational timebase = { 33333333, 1000000000 };
cfg_.g_timebase = timebase;
cfg_.rc_target_bitrate = 2000;
cfg_.g_lag_in_frames = 25;
@@ -109,7 +109,7 @@
cfg_.rc_min_quantizer = 10;
cfg_.rc_max_quantizer = 20;
- init_flags_ = VPX_CODEC_USE_PSNR;
+ init_flags_ = AOM_CODEC_USE_PSNR;
libaom_test::I420VideoSource video("hantro_collage_w352h288.yuv", 352, 288,
timebase.den, timebase.num, 0, 5);
@@ -118,7 +118,7 @@
EXPECT_GE(psnr_lossless, kMaxPsnr);
}
-VP10_INSTANTIATE_TEST_CASE(LosslessTestLarge,
- ::testing::Values(::libaom_test::kOnePassGood,
- ::libaom_test::kTwoPassGood));
+AV1_INSTANTIATE_TEST_CASE(LosslessTestLarge,
+ ::testing::Values(::libaom_test::kOnePassGood,
+ ::libaom_test::kTwoPassGood));
} // namespace
diff --git a/test/lpf_8_test.cc b/test/lpf_8_test.cc
index 3088b4a..b187574 100644
--- a/test/lpf_8_test.cc
+++ b/test/lpf_8_test.cc
@@ -14,15 +14,15 @@
#include "third_party/googletest/src/include/gtest/gtest.h"
-#include "./vpx_config.h"
-#include "./vpx_dsp_rtcd.h"
+#include "./aom_config.h"
+#include "./aom_dsp_rtcd.h"
#include "test/acm_random.h"
#include "test/clear_system_state.h"
#include "test/register_state_check.h"
#include "test/util.h"
#include "av1/common/entropy.h"
#include "av1/common/loopfilter.h"
-#include "aom/vpx_integer.h"
+#include "aom/aom_integer.h"
using libaom_test::ACMRandom;
@@ -34,7 +34,7 @@
const int number_of_iterations = 10000;
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
typedef void (*loop_op_t)(uint16_t *s, int p, const uint8_t *blimit,
const uint8_t *limit, const uint8_t *thresh, int bd);
typedef void (*dual_loop_op_t)(uint16_t *s, int p, const uint8_t *blimit0,
@@ -48,7 +48,7 @@
const uint8_t *limit0, const uint8_t *thresh0,
const uint8_t *blimit1, const uint8_t *limit1,
const uint8_t *thresh1);
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#endif // CONFIG_AOM_HIGHBITDEPTH
typedef std::tr1::tuple<loop_op_t, loop_op_t, int> loop8_param_t;
typedef std::tr1::tuple<dual_loop_op_t, dual_loop_op_t, int> dualloop8_param_t;
@@ -94,14 +94,14 @@
TEST_P(Loop8Test6Param, OperationCheck) {
ACMRandom rnd(ACMRandom::DeterministicSeed());
const int count_test_block = number_of_iterations;
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
int32_t bd = bit_depth_;
DECLARE_ALIGNED(16, uint16_t, s[kNumCoeffs]);
DECLARE_ALIGNED(16, uint16_t, ref_s[kNumCoeffs]);
#else
DECLARE_ALIGNED(8, uint8_t, s[kNumCoeffs]);
DECLARE_ALIGNED(8, uint8_t, ref_s[kNumCoeffs]);
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#endif // CONFIG_AOM_HIGHBITDEPTH
int err_count_total = 0;
int first_failure = -1;
for (int i = 0; i < count_test_block; ++i) {
@@ -149,7 +149,7 @@
}
ref_s[j] = s[j];
}
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
ref_loopfilter_op_(ref_s + 8 + p * 8, p, blimit, limit, thresh, bd);
ASM_REGISTER_STATE_CHECK(
loopfilter_op_(s + 8 + p * 8, p, blimit, limit, thresh, bd));
@@ -157,7 +157,7 @@
ref_loopfilter_op_(ref_s + 8 + p * 8, p, blimit, limit, thresh);
ASM_REGISTER_STATE_CHECK(
loopfilter_op_(s + 8 + p * 8, p, blimit, limit, thresh));
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#endif // CONFIG_AOM_HIGHBITDEPTH
for (int j = 0; j < kNumCoeffs; ++j) {
err_count += ref_s[j] != s[j];
@@ -176,18 +176,18 @@
TEST_P(Loop8Test6Param, ValueCheck) {
ACMRandom rnd(ACMRandom::DeterministicSeed());
const int count_test_block = number_of_iterations;
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
const int32_t bd = bit_depth_;
DECLARE_ALIGNED(16, uint16_t, s[kNumCoeffs]);
DECLARE_ALIGNED(16, uint16_t, ref_s[kNumCoeffs]);
#else
DECLARE_ALIGNED(8, uint8_t, s[kNumCoeffs]);
DECLARE_ALIGNED(8, uint8_t, ref_s[kNumCoeffs]);
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#endif // CONFIG_AOM_HIGHBITDEPTH
int err_count_total = 0;
int first_failure = -1;
- // NOTE: The code in vp9_loopfilter.c:update_sharpness computes mblim as a
+ // NOTE: The code in av1_loopfilter.c:update_sharpness computes mblim as a
// function of sharpness_lvl and the loopfilter lvl as:
// block_inside_limit = lvl >> ((sharpness_lvl > 0) + (sharpness_lvl > 4));
// ...
@@ -218,7 +218,7 @@
s[j] = rnd.Rand16() & mask_;
ref_s[j] = s[j];
}
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
ref_loopfilter_op_(ref_s + 8 + p * 8, p, blimit, limit, thresh, bd);
ASM_REGISTER_STATE_CHECK(
loopfilter_op_(s + 8 + p * 8, p, blimit, limit, thresh, bd));
@@ -226,7 +226,7 @@
ref_loopfilter_op_(ref_s + 8 + p * 8, p, blimit, limit, thresh);
ASM_REGISTER_STATE_CHECK(
loopfilter_op_(s + 8 + p * 8, p, blimit, limit, thresh));
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#endif // CONFIG_AOM_HIGHBITDEPTH
for (int j = 0; j < kNumCoeffs; ++j) {
err_count += ref_s[j] != s[j];
}
@@ -244,14 +244,14 @@
TEST_P(Loop8Test9Param, OperationCheck) {
ACMRandom rnd(ACMRandom::DeterministicSeed());
const int count_test_block = number_of_iterations;
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
const int32_t bd = bit_depth_;
DECLARE_ALIGNED(16, uint16_t, s[kNumCoeffs]);
DECLARE_ALIGNED(16, uint16_t, ref_s[kNumCoeffs]);
#else
DECLARE_ALIGNED(8, uint8_t, s[kNumCoeffs]);
DECLARE_ALIGNED(8, uint8_t, ref_s[kNumCoeffs]);
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#endif // CONFIG_AOM_HIGHBITDEPTH
int err_count_total = 0;
int first_failure = -1;
for (int i = 0; i < count_test_block; ++i) {
@@ -311,7 +311,7 @@
}
ref_s[j] = s[j];
}
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
ref_loopfilter_op_(ref_s + 8 + p * 8, p, blimit0, limit0, thresh0, blimit1,
limit1, thresh1, bd);
ASM_REGISTER_STATE_CHECK(loopfilter_op_(s + 8 + p * 8, p, blimit0, limit0,
@@ -322,7 +322,7 @@
limit1, thresh1);
ASM_REGISTER_STATE_CHECK(loopfilter_op_(s + 8 + p * 8, p, blimit0, limit0,
thresh0, blimit1, limit1, thresh1));
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#endif // CONFIG_AOM_HIGHBITDEPTH
for (int j = 0; j < kNumCoeffs; ++j) {
err_count += ref_s[j] != s[j];
}
@@ -340,13 +340,13 @@
TEST_P(Loop8Test9Param, ValueCheck) {
ACMRandom rnd(ACMRandom::DeterministicSeed());
const int count_test_block = number_of_iterations;
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
DECLARE_ALIGNED(16, uint16_t, s[kNumCoeffs]);
DECLARE_ALIGNED(16, uint16_t, ref_s[kNumCoeffs]);
#else
DECLARE_ALIGNED(8, uint8_t, s[kNumCoeffs]);
DECLARE_ALIGNED(8, uint8_t, ref_s[kNumCoeffs]);
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#endif // CONFIG_AOM_HIGHBITDEPTH
int err_count_total = 0;
int first_failure = -1;
for (int i = 0; i < count_test_block; ++i) {
@@ -380,7 +380,7 @@
s[j] = rnd.Rand16() & mask_;
ref_s[j] = s[j];
}
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
const int32_t bd = bit_depth_;
ref_loopfilter_op_(ref_s + 8 + p * 8, p, blimit0, limit0, thresh0, blimit1,
limit1, thresh1, bd);
@@ -392,7 +392,7 @@
limit1, thresh1);
ASM_REGISTER_STATE_CHECK(loopfilter_op_(s + 8 + p * 8, p, blimit0, limit0,
thresh0, blimit1, limit1, thresh1));
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#endif // CONFIG_AOM_HIGHBITDEPTH
for (int j = 0; j < kNumCoeffs; ++j) {
err_count += ref_s[j] != s[j];
}
@@ -410,128 +410,128 @@
using std::tr1::make_tuple;
#if HAVE_SSE2
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
INSTANTIATE_TEST_CASE_P(
SSE2, Loop8Test6Param,
- ::testing::Values(make_tuple(&vpx_highbd_lpf_horizontal_4_sse2,
- &vpx_highbd_lpf_horizontal_4_c, 8),
- make_tuple(&vpx_highbd_lpf_vertical_4_sse2,
- &vpx_highbd_lpf_vertical_4_c, 8),
- make_tuple(&vpx_highbd_lpf_horizontal_8_sse2,
- &vpx_highbd_lpf_horizontal_8_c, 8),
- make_tuple(&vpx_highbd_lpf_horizontal_edge_8_sse2,
- &vpx_highbd_lpf_horizontal_edge_8_c, 8),
- make_tuple(&vpx_highbd_lpf_horizontal_edge_16_sse2,
- &vpx_highbd_lpf_horizontal_edge_16_c, 8),
- make_tuple(&vpx_highbd_lpf_vertical_8_sse2,
- &vpx_highbd_lpf_vertical_8_c, 8),
- make_tuple(&vpx_highbd_lpf_vertical_16_sse2,
- &vpx_highbd_lpf_vertical_16_c, 8),
- make_tuple(&vpx_highbd_lpf_horizontal_4_sse2,
- &vpx_highbd_lpf_horizontal_4_c, 10),
- make_tuple(&vpx_highbd_lpf_vertical_4_sse2,
- &vpx_highbd_lpf_vertical_4_c, 10),
- make_tuple(&vpx_highbd_lpf_horizontal_8_sse2,
- &vpx_highbd_lpf_horizontal_8_c, 10),
- make_tuple(&vpx_highbd_lpf_horizontal_edge_8_sse2,
- &vpx_highbd_lpf_horizontal_edge_8_c, 10),
- make_tuple(&vpx_highbd_lpf_horizontal_edge_16_sse2,
- &vpx_highbd_lpf_horizontal_edge_16_c, 10),
- make_tuple(&vpx_highbd_lpf_vertical_8_sse2,
- &vpx_highbd_lpf_vertical_8_c, 10),
- make_tuple(&vpx_highbd_lpf_vertical_16_sse2,
- &vpx_highbd_lpf_vertical_16_c, 10),
- make_tuple(&vpx_highbd_lpf_horizontal_4_sse2,
- &vpx_highbd_lpf_horizontal_4_c, 12),
- make_tuple(&vpx_highbd_lpf_vertical_4_sse2,
- &vpx_highbd_lpf_vertical_4_c, 12),
- make_tuple(&vpx_highbd_lpf_horizontal_8_sse2,
- &vpx_highbd_lpf_horizontal_8_c, 12),
- make_tuple(&vpx_highbd_lpf_horizontal_edge_8_sse2,
- &vpx_highbd_lpf_horizontal_edge_8_c, 12),
- make_tuple(&vpx_highbd_lpf_horizontal_edge_16_sse2,
- &vpx_highbd_lpf_horizontal_edge_16_c, 12),
- make_tuple(&vpx_highbd_lpf_vertical_8_sse2,
- &vpx_highbd_lpf_vertical_8_c, 12),
- make_tuple(&vpx_highbd_lpf_vertical_16_sse2,
- &vpx_highbd_lpf_vertical_16_c, 12),
- make_tuple(&vpx_highbd_lpf_vertical_16_dual_sse2,
- &vpx_highbd_lpf_vertical_16_dual_c, 8),
- make_tuple(&vpx_highbd_lpf_vertical_16_dual_sse2,
- &vpx_highbd_lpf_vertical_16_dual_c, 10),
- make_tuple(&vpx_highbd_lpf_vertical_16_dual_sse2,
- &vpx_highbd_lpf_vertical_16_dual_c, 12)));
+ ::testing::Values(make_tuple(&aom_highbd_lpf_horizontal_4_sse2,
+ &aom_highbd_lpf_horizontal_4_c, 8),
+ make_tuple(&aom_highbd_lpf_vertical_4_sse2,
+ &aom_highbd_lpf_vertical_4_c, 8),
+ make_tuple(&aom_highbd_lpf_horizontal_8_sse2,
+ &aom_highbd_lpf_horizontal_8_c, 8),
+ make_tuple(&aom_highbd_lpf_horizontal_edge_8_sse2,
+ &aom_highbd_lpf_horizontal_edge_8_c, 8),
+ make_tuple(&aom_highbd_lpf_horizontal_edge_16_sse2,
+ &aom_highbd_lpf_horizontal_edge_16_c, 8),
+ make_tuple(&aom_highbd_lpf_vertical_8_sse2,
+ &aom_highbd_lpf_vertical_8_c, 8),
+ make_tuple(&aom_highbd_lpf_vertical_16_sse2,
+ &aom_highbd_lpf_vertical_16_c, 8),
+ make_tuple(&aom_highbd_lpf_horizontal_4_sse2,
+ &aom_highbd_lpf_horizontal_4_c, 10),
+ make_tuple(&aom_highbd_lpf_vertical_4_sse2,
+ &aom_highbd_lpf_vertical_4_c, 10),
+ make_tuple(&aom_highbd_lpf_horizontal_8_sse2,
+ &aom_highbd_lpf_horizontal_8_c, 10),
+ make_tuple(&aom_highbd_lpf_horizontal_edge_8_sse2,
+ &aom_highbd_lpf_horizontal_edge_8_c, 10),
+ make_tuple(&aom_highbd_lpf_horizontal_edge_16_sse2,
+ &aom_highbd_lpf_horizontal_edge_16_c, 10),
+ make_tuple(&aom_highbd_lpf_vertical_8_sse2,
+ &aom_highbd_lpf_vertical_8_c, 10),
+ make_tuple(&aom_highbd_lpf_vertical_16_sse2,
+ &aom_highbd_lpf_vertical_16_c, 10),
+ make_tuple(&aom_highbd_lpf_horizontal_4_sse2,
+ &aom_highbd_lpf_horizontal_4_c, 12),
+ make_tuple(&aom_highbd_lpf_vertical_4_sse2,
+ &aom_highbd_lpf_vertical_4_c, 12),
+ make_tuple(&aom_highbd_lpf_horizontal_8_sse2,
+ &aom_highbd_lpf_horizontal_8_c, 12),
+ make_tuple(&aom_highbd_lpf_horizontal_edge_8_sse2,
+ &aom_highbd_lpf_horizontal_edge_8_c, 12),
+ make_tuple(&aom_highbd_lpf_horizontal_edge_16_sse2,
+ &aom_highbd_lpf_horizontal_edge_16_c, 12),
+ make_tuple(&aom_highbd_lpf_vertical_8_sse2,
+ &aom_highbd_lpf_vertical_8_c, 12),
+ make_tuple(&aom_highbd_lpf_vertical_16_sse2,
+ &aom_highbd_lpf_vertical_16_c, 12),
+ make_tuple(&aom_highbd_lpf_vertical_16_dual_sse2,
+ &aom_highbd_lpf_vertical_16_dual_c, 8),
+ make_tuple(&aom_highbd_lpf_vertical_16_dual_sse2,
+ &aom_highbd_lpf_vertical_16_dual_c, 10),
+ make_tuple(&aom_highbd_lpf_vertical_16_dual_sse2,
+ &aom_highbd_lpf_vertical_16_dual_c, 12)));
#else
INSTANTIATE_TEST_CASE_P(
SSE2, Loop8Test6Param,
::testing::Values(
- make_tuple(&vpx_lpf_horizontal_4_sse2, &vpx_lpf_horizontal_4_c, 8),
- make_tuple(&vpx_lpf_horizontal_8_sse2, &vpx_lpf_horizontal_8_c, 8),
- make_tuple(&vpx_lpf_horizontal_edge_8_sse2,
- &vpx_lpf_horizontal_edge_8_c, 8),
- make_tuple(&vpx_lpf_horizontal_edge_16_sse2,
- &vpx_lpf_horizontal_edge_16_c, 8),
- make_tuple(&vpx_lpf_vertical_4_sse2, &vpx_lpf_vertical_4_c, 8),
- make_tuple(&vpx_lpf_vertical_8_sse2, &vpx_lpf_vertical_8_c, 8),
- make_tuple(&vpx_lpf_vertical_16_sse2, &vpx_lpf_vertical_16_c, 8),
- make_tuple(&vpx_lpf_vertical_16_dual_sse2, &vpx_lpf_vertical_16_dual_c,
+ make_tuple(&aom_lpf_horizontal_4_sse2, &aom_lpf_horizontal_4_c, 8),
+ make_tuple(&aom_lpf_horizontal_8_sse2, &aom_lpf_horizontal_8_c, 8),
+ make_tuple(&aom_lpf_horizontal_edge_8_sse2,
+ &aom_lpf_horizontal_edge_8_c, 8),
+ make_tuple(&aom_lpf_horizontal_edge_16_sse2,
+ &aom_lpf_horizontal_edge_16_c, 8),
+ make_tuple(&aom_lpf_vertical_4_sse2, &aom_lpf_vertical_4_c, 8),
+ make_tuple(&aom_lpf_vertical_8_sse2, &aom_lpf_vertical_8_c, 8),
+ make_tuple(&aom_lpf_vertical_16_sse2, &aom_lpf_vertical_16_c, 8),
+ make_tuple(&aom_lpf_vertical_16_dual_sse2, &aom_lpf_vertical_16_dual_c,
8)));
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#endif // CONFIG_AOM_HIGHBITDEPTH
#endif
-#if HAVE_AVX2 && (!CONFIG_VP9_HIGHBITDEPTH)
+#if HAVE_AVX2 && (!CONFIG_AOM_HIGHBITDEPTH)
INSTANTIATE_TEST_CASE_P(
AVX2, Loop8Test6Param,
- ::testing::Values(make_tuple(&vpx_lpf_horizontal_edge_8_avx2,
- &vpx_lpf_horizontal_edge_8_c, 8),
- make_tuple(&vpx_lpf_horizontal_edge_16_avx2,
- &vpx_lpf_horizontal_edge_16_c, 8)));
+ ::testing::Values(make_tuple(&aom_lpf_horizontal_edge_8_avx2,
+ &aom_lpf_horizontal_edge_8_c, 8),
+ make_tuple(&aom_lpf_horizontal_edge_16_avx2,
+ &aom_lpf_horizontal_edge_16_c, 8)));
#endif
#if HAVE_SSE2
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
INSTANTIATE_TEST_CASE_P(
SSE2, Loop8Test9Param,
- ::testing::Values(make_tuple(&vpx_highbd_lpf_horizontal_4_dual_sse2,
- &vpx_highbd_lpf_horizontal_4_dual_c, 8),
- make_tuple(&vpx_highbd_lpf_horizontal_8_dual_sse2,
- &vpx_highbd_lpf_horizontal_8_dual_c, 8),
- make_tuple(&vpx_highbd_lpf_vertical_4_dual_sse2,
- &vpx_highbd_lpf_vertical_4_dual_c, 8),
- make_tuple(&vpx_highbd_lpf_vertical_8_dual_sse2,
- &vpx_highbd_lpf_vertical_8_dual_c, 8),
- make_tuple(&vpx_highbd_lpf_horizontal_4_dual_sse2,
- &vpx_highbd_lpf_horizontal_4_dual_c, 10),
- make_tuple(&vpx_highbd_lpf_horizontal_8_dual_sse2,
- &vpx_highbd_lpf_horizontal_8_dual_c, 10),
- make_tuple(&vpx_highbd_lpf_vertical_4_dual_sse2,
- &vpx_highbd_lpf_vertical_4_dual_c, 10),
- make_tuple(&vpx_highbd_lpf_vertical_8_dual_sse2,
- &vpx_highbd_lpf_vertical_8_dual_c, 10),
- make_tuple(&vpx_highbd_lpf_horizontal_4_dual_sse2,
- &vpx_highbd_lpf_horizontal_4_dual_c, 12),
- make_tuple(&vpx_highbd_lpf_horizontal_8_dual_sse2,
- &vpx_highbd_lpf_horizontal_8_dual_c, 12),
- make_tuple(&vpx_highbd_lpf_vertical_4_dual_sse2,
- &vpx_highbd_lpf_vertical_4_dual_c, 12),
- make_tuple(&vpx_highbd_lpf_vertical_8_dual_sse2,
- &vpx_highbd_lpf_vertical_8_dual_c, 12)));
+ ::testing::Values(make_tuple(&aom_highbd_lpf_horizontal_4_dual_sse2,
+ &aom_highbd_lpf_horizontal_4_dual_c, 8),
+ make_tuple(&aom_highbd_lpf_horizontal_8_dual_sse2,
+ &aom_highbd_lpf_horizontal_8_dual_c, 8),
+ make_tuple(&aom_highbd_lpf_vertical_4_dual_sse2,
+ &aom_highbd_lpf_vertical_4_dual_c, 8),
+ make_tuple(&aom_highbd_lpf_vertical_8_dual_sse2,
+ &aom_highbd_lpf_vertical_8_dual_c, 8),
+ make_tuple(&aom_highbd_lpf_horizontal_4_dual_sse2,
+ &aom_highbd_lpf_horizontal_4_dual_c, 10),
+ make_tuple(&aom_highbd_lpf_horizontal_8_dual_sse2,
+ &aom_highbd_lpf_horizontal_8_dual_c, 10),
+ make_tuple(&aom_highbd_lpf_vertical_4_dual_sse2,
+ &aom_highbd_lpf_vertical_4_dual_c, 10),
+ make_tuple(&aom_highbd_lpf_vertical_8_dual_sse2,
+ &aom_highbd_lpf_vertical_8_dual_c, 10),
+ make_tuple(&aom_highbd_lpf_horizontal_4_dual_sse2,
+ &aom_highbd_lpf_horizontal_4_dual_c, 12),
+ make_tuple(&aom_highbd_lpf_horizontal_8_dual_sse2,
+ &aom_highbd_lpf_horizontal_8_dual_c, 12),
+ make_tuple(&aom_highbd_lpf_vertical_4_dual_sse2,
+ &aom_highbd_lpf_vertical_4_dual_c, 12),
+ make_tuple(&aom_highbd_lpf_vertical_8_dual_sse2,
+ &aom_highbd_lpf_vertical_8_dual_c, 12)));
#else
INSTANTIATE_TEST_CASE_P(
SSE2, Loop8Test9Param,
- ::testing::Values(make_tuple(&vpx_lpf_horizontal_4_dual_sse2,
- &vpx_lpf_horizontal_4_dual_c, 8),
- make_tuple(&vpx_lpf_horizontal_8_dual_sse2,
- &vpx_lpf_horizontal_8_dual_c, 8),
- make_tuple(&vpx_lpf_vertical_4_dual_sse2,
- &vpx_lpf_vertical_4_dual_c, 8),
- make_tuple(&vpx_lpf_vertical_8_dual_sse2,
- &vpx_lpf_vertical_8_dual_c, 8)));
-#endif // CONFIG_VP9_HIGHBITDEPTH
+ ::testing::Values(make_tuple(&aom_lpf_horizontal_4_dual_sse2,
+ &aom_lpf_horizontal_4_dual_c, 8),
+ make_tuple(&aom_lpf_horizontal_8_dual_sse2,
+ &aom_lpf_horizontal_8_dual_c, 8),
+ make_tuple(&aom_lpf_vertical_4_dual_sse2,
+ &aom_lpf_vertical_4_dual_c, 8),
+ make_tuple(&aom_lpf_vertical_8_dual_sse2,
+ &aom_lpf_vertical_8_dual_c, 8)));
+#endif // CONFIG_AOM_HIGHBITDEPTH
#endif
#if HAVE_NEON
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
// No neon high bitdepth functions.
#else
INSTANTIATE_TEST_CASE_P(
@@ -541,83 +541,83 @@
// Using #if inside the macro is unsupported on MSVS but the tests are
// not
// currently built for MSVS with ARM and NEON.
- make_tuple(&vpx_lpf_horizontal_edge_8_neon,
- &vpx_lpf_horizontal_edge_8_c, 8),
- make_tuple(&vpx_lpf_horizontal_edge_16_neon,
- &vpx_lpf_horizontal_edge_16_c, 8),
- make_tuple(&vpx_lpf_vertical_16_neon, &vpx_lpf_vertical_16_c, 8),
- make_tuple(&vpx_lpf_vertical_16_dual_neon, &vpx_lpf_vertical_16_dual_c,
+ make_tuple(&aom_lpf_horizontal_edge_8_neon,
+ &aom_lpf_horizontal_edge_8_c, 8),
+ make_tuple(&aom_lpf_horizontal_edge_16_neon,
+ &aom_lpf_horizontal_edge_16_c, 8),
+ make_tuple(&aom_lpf_vertical_16_neon, &aom_lpf_vertical_16_c, 8),
+ make_tuple(&aom_lpf_vertical_16_dual_neon, &aom_lpf_vertical_16_dual_c,
8),
#endif // HAVE_NEON_ASM
- make_tuple(&vpx_lpf_horizontal_8_neon, &vpx_lpf_horizontal_8_c, 8),
- make_tuple(&vpx_lpf_vertical_8_neon, &vpx_lpf_vertical_8_c, 8),
- make_tuple(&vpx_lpf_horizontal_4_neon, &vpx_lpf_horizontal_4_c, 8),
- make_tuple(&vpx_lpf_vertical_4_neon, &vpx_lpf_vertical_4_c, 8)));
+ make_tuple(&aom_lpf_horizontal_8_neon, &aom_lpf_horizontal_8_c, 8),
+ make_tuple(&aom_lpf_vertical_8_neon, &aom_lpf_vertical_8_c, 8),
+ make_tuple(&aom_lpf_horizontal_4_neon, &aom_lpf_horizontal_4_c, 8),
+ make_tuple(&aom_lpf_vertical_4_neon, &aom_lpf_vertical_4_c, 8)));
INSTANTIATE_TEST_CASE_P(NEON, Loop8Test9Param,
::testing::Values(
#if HAVE_NEON_ASM
- make_tuple(&vpx_lpf_horizontal_8_dual_neon,
- &vpx_lpf_horizontal_8_dual_c, 8),
- make_tuple(&vpx_lpf_vertical_8_dual_neon,
- &vpx_lpf_vertical_8_dual_c, 8),
+ make_tuple(&aom_lpf_horizontal_8_dual_neon,
+ &aom_lpf_horizontal_8_dual_c, 8),
+ make_tuple(&aom_lpf_vertical_8_dual_neon,
+ &aom_lpf_vertical_8_dual_c, 8),
#endif // HAVE_NEON_ASM
- make_tuple(&vpx_lpf_horizontal_4_dual_neon,
- &vpx_lpf_horizontal_4_dual_c, 8),
- make_tuple(&vpx_lpf_vertical_4_dual_neon,
- &vpx_lpf_vertical_4_dual_c, 8)));
-#endif // CONFIG_VP9_HIGHBITDEPTH
+ make_tuple(&aom_lpf_horizontal_4_dual_neon,
+ &aom_lpf_horizontal_4_dual_c, 8),
+ make_tuple(&aom_lpf_vertical_4_dual_neon,
+ &aom_lpf_vertical_4_dual_c, 8)));
+#endif // CONFIG_AOM_HIGHBITDEPTH
#endif // HAVE_NEON
-#if HAVE_DSPR2 && !CONFIG_VP9_HIGHBITDEPTH
+#if HAVE_DSPR2 && !CONFIG_AOM_HIGHBITDEPTH
INSTANTIATE_TEST_CASE_P(
DSPR2, Loop8Test6Param,
::testing::Values(
- make_tuple(&vpx_lpf_horizontal_4_dspr2, &vpx_lpf_horizontal_4_c, 8),
- make_tuple(&vpx_lpf_horizontal_8_dspr2, &vpx_lpf_horizontal_8_c, 8),
- make_tuple(&vpx_lpf_horizontal_edge_8, &vpx_lpf_horizontal_edge_8, 8),
- make_tuple(&vpx_lpf_horizontal_edge_16, &vpx_lpf_horizontal_edge_16, 8),
- make_tuple(&vpx_lpf_vertical_4_dspr2, &vpx_lpf_vertical_4_c, 8),
- make_tuple(&vpx_lpf_vertical_8_dspr2, &vpx_lpf_vertical_8_c, 8),
- make_tuple(&vpx_lpf_vertical_16_dspr2, &vpx_lpf_vertical_16_c, 8),
- make_tuple(&vpx_lpf_vertical_16_dual_dspr2, &vpx_lpf_vertical_16_dual_c,
+ make_tuple(&aom_lpf_horizontal_4_dspr2, &aom_lpf_horizontal_4_c, 8),
+ make_tuple(&aom_lpf_horizontal_8_dspr2, &aom_lpf_horizontal_8_c, 8),
+ make_tuple(&aom_lpf_horizontal_edge_8, &aom_lpf_horizontal_edge_8, 8),
+ make_tuple(&aom_lpf_horizontal_edge_16, &aom_lpf_horizontal_edge_16, 8),
+ make_tuple(&aom_lpf_vertical_4_dspr2, &aom_lpf_vertical_4_c, 8),
+ make_tuple(&aom_lpf_vertical_8_dspr2, &aom_lpf_vertical_8_c, 8),
+ make_tuple(&aom_lpf_vertical_16_dspr2, &aom_lpf_vertical_16_c, 8),
+ make_tuple(&aom_lpf_vertical_16_dual_dspr2, &aom_lpf_vertical_16_dual_c,
8)));
INSTANTIATE_TEST_CASE_P(
DSPR2, Loop8Test9Param,
- ::testing::Values(make_tuple(&vpx_lpf_horizontal_4_dual_dspr2,
- &vpx_lpf_horizontal_4_dual_c, 8),
- make_tuple(&vpx_lpf_horizontal_8_dual_dspr2,
- &vpx_lpf_horizontal_8_dual_c, 8),
- make_tuple(&vpx_lpf_vertical_4_dual_dspr2,
- &vpx_lpf_vertical_4_dual_c, 8),
- make_tuple(&vpx_lpf_vertical_8_dual_dspr2,
- &vpx_lpf_vertical_8_dual_c, 8)));
-#endif // HAVE_DSPR2 && !CONFIG_VP9_HIGHBITDEPTH
+ ::testing::Values(make_tuple(&aom_lpf_horizontal_4_dual_dspr2,
+ &aom_lpf_horizontal_4_dual_c, 8),
+ make_tuple(&aom_lpf_horizontal_8_dual_dspr2,
+ &aom_lpf_horizontal_8_dual_c, 8),
+ make_tuple(&aom_lpf_vertical_4_dual_dspr2,
+ &aom_lpf_vertical_4_dual_c, 8),
+ make_tuple(&aom_lpf_vertical_8_dual_dspr2,
+ &aom_lpf_vertical_8_dual_c, 8)));
+#endif // HAVE_DSPR2 && !CONFIG_AOM_HIGHBITDEPTH
-#if HAVE_MSA && (!CONFIG_VP9_HIGHBITDEPTH)
+#if HAVE_MSA && (!CONFIG_AOM_HIGHBITDEPTH)
INSTANTIATE_TEST_CASE_P(
MSA, Loop8Test6Param,
::testing::Values(
- make_tuple(&vpx_lpf_horizontal_4_msa, &vpx_lpf_horizontal_4_c, 8),
- make_tuple(&vpx_lpf_horizontal_8_msa, &vpx_lpf_horizontal_8_c, 8),
- make_tuple(&vpx_lpf_horizontal_edge_8_msa, &vpx_lpf_horizontal_edge_8_c,
+ make_tuple(&aom_lpf_horizontal_4_msa, &aom_lpf_horizontal_4_c, 8),
+ make_tuple(&aom_lpf_horizontal_8_msa, &aom_lpf_horizontal_8_c, 8),
+ make_tuple(&aom_lpf_horizontal_edge_8_msa, &aom_lpf_horizontal_edge_8_c,
8),
- make_tuple(&vpx_lpf_horizontal_edge_16_msa,
- &vpx_lpf_horizontal_edge_16_c, 8),
- make_tuple(&vpx_lpf_vertical_4_msa, &vpx_lpf_vertical_4_c, 8),
- make_tuple(&vpx_lpf_vertical_8_msa, &vpx_lpf_vertical_8_c, 8),
- make_tuple(&vpx_lpf_vertical_16_msa, &vpx_lpf_vertical_16_c, 8)));
+ make_tuple(&aom_lpf_horizontal_edge_16_msa,
+ &aom_lpf_horizontal_edge_16_c, 8),
+ make_tuple(&aom_lpf_vertical_4_msa, &aom_lpf_vertical_4_c, 8),
+ make_tuple(&aom_lpf_vertical_8_msa, &aom_lpf_vertical_8_c, 8),
+ make_tuple(&aom_lpf_vertical_16_msa, &aom_lpf_vertical_16_c, 8)));
INSTANTIATE_TEST_CASE_P(
MSA, Loop8Test9Param,
- ::testing::Values(make_tuple(&vpx_lpf_horizontal_4_dual_msa,
- &vpx_lpf_horizontal_4_dual_c, 8),
- make_tuple(&vpx_lpf_horizontal_8_dual_msa,
- &vpx_lpf_horizontal_8_dual_c, 8),
- make_tuple(&vpx_lpf_vertical_4_dual_msa,
- &vpx_lpf_vertical_4_dual_c, 8),
- make_tuple(&vpx_lpf_vertical_8_dual_msa,
- &vpx_lpf_vertical_8_dual_c, 8)));
-#endif // HAVE_MSA && (!CONFIG_VP9_HIGHBITDEPTH)
+ ::testing::Values(make_tuple(&aom_lpf_horizontal_4_dual_msa,
+ &aom_lpf_horizontal_4_dual_c, 8),
+ make_tuple(&aom_lpf_horizontal_8_dual_msa,
+ &aom_lpf_horizontal_8_dual_c, 8),
+ make_tuple(&aom_lpf_vertical_4_dual_msa,
+ &aom_lpf_vertical_4_dual_c, 8),
+ make_tuple(&aom_lpf_vertical_8_dual_msa,
+ &aom_lpf_vertical_8_dual_c, 8)));
+#endif // HAVE_MSA && (!CONFIG_AOM_HIGHBITDEPTH)
} // namespace
diff --git a/test/masked_sad_test.cc b/test/masked_sad_test.cc
index b9af5ad..68ff0be 100644
--- a/test/masked_sad_test.cc
+++ b/test/masked_sad_test.cc
@@ -18,9 +18,9 @@
#include "test/register_state_check.h"
#include "test/util.h"
-#include "./vpx_config.h"
-#include "./vpx_dsp_rtcd.h"
-#include "aom/vpx_integer.h"
+#include "./aom_config.h"
+#include "./aom_dsp_rtcd.h"
+#include "aom/aom_integer.h"
using libaom_test::ACMRandom;
@@ -81,7 +81,7 @@
<< "First failed at test case " << first_failure;
}
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
typedef unsigned int (*HighbdMaskedSADFunc)(const uint8_t *a, int a_stride,
const uint8_t *b, int b_stride,
const uint8_t *m, int m_stride);
@@ -138,7 +138,7 @@
<< "Error: High BD Masked SAD Test, C output doesn't match SSSE3 output. "
<< "First failed at test case " << first_failure;
}
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#endif // CONFIG_AOM_HIGHBITDEPTH
using std::tr1::make_tuple;
@@ -147,60 +147,60 @@
SSSE3_C_COMPARE, MaskedSADTest,
::testing::Values(
#if CONFIG_EXT_PARTITION
- make_tuple(&vpx_masked_sad128x128_ssse3, &vpx_masked_sad128x128_c),
- make_tuple(&vpx_masked_sad128x64_ssse3, &vpx_masked_sad128x64_c),
- make_tuple(&vpx_masked_sad64x128_ssse3, &vpx_masked_sad64x128_c),
+ make_tuple(&aom_masked_sad128x128_ssse3, &aom_masked_sad128x128_c),
+ make_tuple(&aom_masked_sad128x64_ssse3, &aom_masked_sad128x64_c),
+ make_tuple(&aom_masked_sad64x128_ssse3, &aom_masked_sad64x128_c),
#endif // CONFIG_EXT_PARTITION
- make_tuple(&vpx_masked_sad64x64_ssse3, &vpx_masked_sad64x64_c),
- make_tuple(&vpx_masked_sad64x32_ssse3, &vpx_masked_sad64x32_c),
- make_tuple(&vpx_masked_sad32x64_ssse3, &vpx_masked_sad32x64_c),
- make_tuple(&vpx_masked_sad32x32_ssse3, &vpx_masked_sad32x32_c),
- make_tuple(&vpx_masked_sad32x16_ssse3, &vpx_masked_sad32x16_c),
- make_tuple(&vpx_masked_sad16x32_ssse3, &vpx_masked_sad16x32_c),
- make_tuple(&vpx_masked_sad16x16_ssse3, &vpx_masked_sad16x16_c),
- make_tuple(&vpx_masked_sad16x8_ssse3, &vpx_masked_sad16x8_c),
- make_tuple(&vpx_masked_sad8x16_ssse3, &vpx_masked_sad8x16_c),
- make_tuple(&vpx_masked_sad8x8_ssse3, &vpx_masked_sad8x8_c),
- make_tuple(&vpx_masked_sad8x4_ssse3, &vpx_masked_sad8x4_c),
- make_tuple(&vpx_masked_sad4x8_ssse3, &vpx_masked_sad4x8_c),
- make_tuple(&vpx_masked_sad4x4_ssse3, &vpx_masked_sad4x4_c)));
-#if CONFIG_VP9_HIGHBITDEPTH
+ make_tuple(&aom_masked_sad64x64_ssse3, &aom_masked_sad64x64_c),
+ make_tuple(&aom_masked_sad64x32_ssse3, &aom_masked_sad64x32_c),
+ make_tuple(&aom_masked_sad32x64_ssse3, &aom_masked_sad32x64_c),
+ make_tuple(&aom_masked_sad32x32_ssse3, &aom_masked_sad32x32_c),
+ make_tuple(&aom_masked_sad32x16_ssse3, &aom_masked_sad32x16_c),
+ make_tuple(&aom_masked_sad16x32_ssse3, &aom_masked_sad16x32_c),
+ make_tuple(&aom_masked_sad16x16_ssse3, &aom_masked_sad16x16_c),
+ make_tuple(&aom_masked_sad16x8_ssse3, &aom_masked_sad16x8_c),
+ make_tuple(&aom_masked_sad8x16_ssse3, &aom_masked_sad8x16_c),
+ make_tuple(&aom_masked_sad8x8_ssse3, &aom_masked_sad8x8_c),
+ make_tuple(&aom_masked_sad8x4_ssse3, &aom_masked_sad8x4_c),
+ make_tuple(&aom_masked_sad4x8_ssse3, &aom_masked_sad4x8_c),
+ make_tuple(&aom_masked_sad4x4_ssse3, &aom_masked_sad4x4_c)));
+#if CONFIG_AOM_HIGHBITDEPTH
INSTANTIATE_TEST_CASE_P(SSSE3_C_COMPARE, HighbdMaskedSADTest,
::testing::Values(
#if CONFIG_EXT_PARTITION
- make_tuple(&vpx_highbd_masked_sad128x128_ssse3,
- &vpx_highbd_masked_sad128x128_c),
- make_tuple(&vpx_highbd_masked_sad128x64_ssse3,
- &vpx_highbd_masked_sad128x64_c),
- make_tuple(&vpx_highbd_masked_sad64x128_ssse3,
- &vpx_highbd_masked_sad64x128_c),
+ make_tuple(&aom_highbd_masked_sad128x128_ssse3,
+ &aom_highbd_masked_sad128x128_c),
+ make_tuple(&aom_highbd_masked_sad128x64_ssse3,
+ &aom_highbd_masked_sad128x64_c),
+ make_tuple(&aom_highbd_masked_sad64x128_ssse3,
+ &aom_highbd_masked_sad64x128_c),
#endif // CONFIG_EXT_PARTITION
- make_tuple(&vpx_highbd_masked_sad64x64_ssse3,
- &vpx_highbd_masked_sad64x64_c),
- make_tuple(&vpx_highbd_masked_sad64x32_ssse3,
- &vpx_highbd_masked_sad64x32_c),
- make_tuple(&vpx_highbd_masked_sad32x64_ssse3,
- &vpx_highbd_masked_sad32x64_c),
- make_tuple(&vpx_highbd_masked_sad32x32_ssse3,
- &vpx_highbd_masked_sad32x32_c),
- make_tuple(&vpx_highbd_masked_sad32x16_ssse3,
- &vpx_highbd_masked_sad32x16_c),
- make_tuple(&vpx_highbd_masked_sad16x32_ssse3,
- &vpx_highbd_masked_sad16x32_c),
- make_tuple(&vpx_highbd_masked_sad16x16_ssse3,
- &vpx_highbd_masked_sad16x16_c),
- make_tuple(&vpx_highbd_masked_sad16x8_ssse3,
- &vpx_highbd_masked_sad16x8_c),
- make_tuple(&vpx_highbd_masked_sad8x16_ssse3,
- &vpx_highbd_masked_sad8x16_c),
- make_tuple(&vpx_highbd_masked_sad8x8_ssse3,
- &vpx_highbd_masked_sad8x8_c),
- make_tuple(&vpx_highbd_masked_sad8x4_ssse3,
- &vpx_highbd_masked_sad8x4_c),
- make_tuple(&vpx_highbd_masked_sad4x8_ssse3,
- &vpx_highbd_masked_sad4x8_c),
- make_tuple(&vpx_highbd_masked_sad4x4_ssse3,
- &vpx_highbd_masked_sad4x4_c)));
-#endif // CONFIG_VP9_HIGHBITDEPTH
+ make_tuple(&aom_highbd_masked_sad64x64_ssse3,
+ &aom_highbd_masked_sad64x64_c),
+ make_tuple(&aom_highbd_masked_sad64x32_ssse3,
+ &aom_highbd_masked_sad64x32_c),
+ make_tuple(&aom_highbd_masked_sad32x64_ssse3,
+ &aom_highbd_masked_sad32x64_c),
+ make_tuple(&aom_highbd_masked_sad32x32_ssse3,
+ &aom_highbd_masked_sad32x32_c),
+ make_tuple(&aom_highbd_masked_sad32x16_ssse3,
+ &aom_highbd_masked_sad32x16_c),
+ make_tuple(&aom_highbd_masked_sad16x32_ssse3,
+ &aom_highbd_masked_sad16x32_c),
+ make_tuple(&aom_highbd_masked_sad16x16_ssse3,
+ &aom_highbd_masked_sad16x16_c),
+ make_tuple(&aom_highbd_masked_sad16x8_ssse3,
+ &aom_highbd_masked_sad16x8_c),
+ make_tuple(&aom_highbd_masked_sad8x16_ssse3,
+ &aom_highbd_masked_sad8x16_c),
+ make_tuple(&aom_highbd_masked_sad8x8_ssse3,
+ &aom_highbd_masked_sad8x8_c),
+ make_tuple(&aom_highbd_masked_sad8x4_ssse3,
+ &aom_highbd_masked_sad8x4_c),
+ make_tuple(&aom_highbd_masked_sad4x8_ssse3,
+ &aom_highbd_masked_sad4x8_c),
+ make_tuple(&aom_highbd_masked_sad4x4_ssse3,
+ &aom_highbd_masked_sad4x4_c)));
+#endif // CONFIG_AOM_HIGHBITDEPTH
#endif // HAVE_SSSE3
} // namespace
diff --git a/test/masked_variance_test.cc b/test/masked_variance_test.cc
index 36fde93..3e44bf7 100644
--- a/test/masked_variance_test.cc
+++ b/test/masked_variance_test.cc
@@ -18,12 +18,12 @@
#include "test/register_state_check.h"
#include "test/util.h"
-#include "./vpx_config.h"
-#include "./vpx_dsp_rtcd.h"
-#include "aom/vpx_codec.h"
-#include "aom/vpx_integer.h"
-#include "aom_dsp/vpx_filter.h"
-#include "aom_mem/vpx_mem.h"
+#include "./aom_config.h"
+#include "./aom_dsp_rtcd.h"
+#include "aom/aom_codec.h"
+#include "aom/aom_integer.h"
+#include "aom_dsp/aom_filter.h"
+#include "aom_mem/aom_mem.h"
using libaom_test::ACMRandom;
@@ -248,8 +248,8 @@
<< " y_offset = " << first_failure_y;
}
-#if CONFIG_VP9_HIGHBITDEPTH
-typedef std::tr1::tuple<MaskedVarianceFunc, MaskedVarianceFunc, vpx_bit_depth_t>
+#if CONFIG_AOM_HIGHBITDEPTH
+typedef std::tr1::tuple<MaskedVarianceFunc, MaskedVarianceFunc, aom_bit_depth_t>
HighbdMaskedVarianceParam;
class HighbdMaskedVarianceTest
@@ -267,7 +267,7 @@
protected:
MaskedVarianceFunc opt_func_;
MaskedVarianceFunc ref_func_;
- vpx_bit_depth_t bit_depth_;
+ aom_bit_depth_t bit_depth_;
};
TEST_P(HighbdMaskedVarianceTest, OperationCheck) {
@@ -325,9 +325,9 @@
int msk_stride = MAX_SB_SIZE;
for (int i = 0; i < 8; ++i) {
- vpx_memset16(src_ptr, (i & 0x1) ? ((1 << bit_depth_) - 1) : 0,
+ aom_memset16(src_ptr, (i & 0x1) ? ((1 << bit_depth_) - 1) : 0,
MAX_SB_SIZE * MAX_SB_SIZE);
- vpx_memset16(ref_ptr, (i & 0x2) ? ((1 << bit_depth_) - 1) : 0,
+ aom_memset16(ref_ptr, (i & 0x2) ? ((1 << bit_depth_) - 1) : 0,
MAX_SB_SIZE * MAX_SB_SIZE);
memset(msk_ptr, (i & 0x4) ? 64 : 0, MAX_SB_SIZE * MAX_SB_SIZE);
@@ -349,7 +349,7 @@
}
typedef std::tr1::tuple<MaskedSubPixelVarianceFunc, MaskedSubPixelVarianceFunc,
- vpx_bit_depth_t> HighbdMaskedSubPixelVarianceParam;
+ aom_bit_depth_t> HighbdMaskedSubPixelVarianceParam;
class HighbdMaskedSubPixelVarianceTest
: public ::testing::TestWithParam<HighbdMaskedSubPixelVarianceParam> {
@@ -366,7 +366,7 @@
protected:
MaskedSubPixelVarianceFunc opt_func_;
MaskedSubPixelVarianceFunc ref_func_;
- vpx_bit_depth_t bit_depth_;
+ aom_bit_depth_t bit_depth_;
};
TEST_P(HighbdMaskedSubPixelVarianceTest, OperationCheck) {
@@ -442,9 +442,9 @@
for (int xoffset = 0; xoffset < BIL_SUBPEL_SHIFTS; xoffset++) {
for (int yoffset = 0; yoffset < BIL_SUBPEL_SHIFTS; yoffset++) {
for (int i = 0; i < 8; ++i) {
- vpx_memset16(src_ptr, (i & 0x1) ? ((1 << bit_depth_) - 1) : 0,
+ aom_memset16(src_ptr, (i & 0x1) ? ((1 << bit_depth_) - 1) : 0,
(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1));
- vpx_memset16(ref_ptr, (i & 0x2) ? ((1 << bit_depth_) - 1) : 0,
+ aom_memset16(ref_ptr, (i & 0x2) ? ((1 << bit_depth_) - 1) : 0,
(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1));
memset(msk_ptr, (i & 0x4) ? 64 : 0,
(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1));
@@ -474,7 +474,7 @@
<< " x_offset = " << first_failure_x
<< " y_offset = " << first_failure_y;
}
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#endif // CONFIG_AOM_HIGHBITDEPTH
using std::tr1::make_tuple;
@@ -483,306 +483,306 @@
SSSE3_C_COMPARE, MaskedVarianceTest,
::testing::Values(
#if CONFIG_EXT_PARTITION
- make_tuple(&vpx_masked_variance128x128_ssse3,
- &vpx_masked_variance128x128_c),
- make_tuple(&vpx_masked_variance128x64_ssse3,
- &vpx_masked_variance128x64_c),
- make_tuple(&vpx_masked_variance64x128_ssse3,
- &vpx_masked_variance64x128_c),
+ make_tuple(&aom_masked_variance128x128_ssse3,
+ &aom_masked_variance128x128_c),
+ make_tuple(&aom_masked_variance128x64_ssse3,
+ &aom_masked_variance128x64_c),
+ make_tuple(&aom_masked_variance64x128_ssse3,
+ &aom_masked_variance64x128_c),
#endif // CONFIG_EXT_PARTITION
- make_tuple(&vpx_masked_variance64x64_ssse3,
- &vpx_masked_variance64x64_c),
- make_tuple(&vpx_masked_variance64x32_ssse3,
- &vpx_masked_variance64x32_c),
- make_tuple(&vpx_masked_variance32x64_ssse3,
- &vpx_masked_variance32x64_c),
- make_tuple(&vpx_masked_variance32x32_ssse3,
- &vpx_masked_variance32x32_c),
- make_tuple(&vpx_masked_variance32x16_ssse3,
- &vpx_masked_variance32x16_c),
- make_tuple(&vpx_masked_variance16x32_ssse3,
- &vpx_masked_variance16x32_c),
- make_tuple(&vpx_masked_variance16x16_ssse3,
- &vpx_masked_variance16x16_c),
- make_tuple(&vpx_masked_variance16x8_ssse3, &vpx_masked_variance16x8_c),
- make_tuple(&vpx_masked_variance8x16_ssse3, &vpx_masked_variance8x16_c),
- make_tuple(&vpx_masked_variance8x8_ssse3, &vpx_masked_variance8x8_c),
- make_tuple(&vpx_masked_variance8x4_ssse3, &vpx_masked_variance8x4_c),
- make_tuple(&vpx_masked_variance4x8_ssse3, &vpx_masked_variance4x8_c),
- make_tuple(&vpx_masked_variance4x4_ssse3, &vpx_masked_variance4x4_c)));
+ make_tuple(&aom_masked_variance64x64_ssse3,
+ &aom_masked_variance64x64_c),
+ make_tuple(&aom_masked_variance64x32_ssse3,
+ &aom_masked_variance64x32_c),
+ make_tuple(&aom_masked_variance32x64_ssse3,
+ &aom_masked_variance32x64_c),
+ make_tuple(&aom_masked_variance32x32_ssse3,
+ &aom_masked_variance32x32_c),
+ make_tuple(&aom_masked_variance32x16_ssse3,
+ &aom_masked_variance32x16_c),
+ make_tuple(&aom_masked_variance16x32_ssse3,
+ &aom_masked_variance16x32_c),
+ make_tuple(&aom_masked_variance16x16_ssse3,
+ &aom_masked_variance16x16_c),
+ make_tuple(&aom_masked_variance16x8_ssse3, &aom_masked_variance16x8_c),
+ make_tuple(&aom_masked_variance8x16_ssse3, &aom_masked_variance8x16_c),
+ make_tuple(&aom_masked_variance8x8_ssse3, &aom_masked_variance8x8_c),
+ make_tuple(&aom_masked_variance8x4_ssse3, &aom_masked_variance8x4_c),
+ make_tuple(&aom_masked_variance4x8_ssse3, &aom_masked_variance4x8_c),
+ make_tuple(&aom_masked_variance4x4_ssse3, &aom_masked_variance4x4_c)));
INSTANTIATE_TEST_CASE_P(
SSSE3_C_COMPARE, MaskedSubPixelVarianceTest,
::testing::Values(
#if CONFIG_EXT_PARTITION
- make_tuple(&vpx_masked_sub_pixel_variance128x128_ssse3,
- &vpx_masked_sub_pixel_variance128x128_c),
- make_tuple(&vpx_masked_sub_pixel_variance128x64_ssse3,
- &vpx_masked_sub_pixel_variance128x64_c),
- make_tuple(&vpx_masked_sub_pixel_variance64x128_ssse3,
- &vpx_masked_sub_pixel_variance64x128_c),
+ make_tuple(&aom_masked_sub_pixel_variance128x128_ssse3,
+ &aom_masked_sub_pixel_variance128x128_c),
+ make_tuple(&aom_masked_sub_pixel_variance128x64_ssse3,
+ &aom_masked_sub_pixel_variance128x64_c),
+ make_tuple(&aom_masked_sub_pixel_variance64x128_ssse3,
+ &aom_masked_sub_pixel_variance64x128_c),
#endif // CONFIG_EXT_PARTITION
- make_tuple(&vpx_masked_sub_pixel_variance64x64_ssse3,
- &vpx_masked_sub_pixel_variance64x64_c),
- make_tuple(&vpx_masked_sub_pixel_variance64x32_ssse3,
- &vpx_masked_sub_pixel_variance64x32_c),
- make_tuple(&vpx_masked_sub_pixel_variance32x64_ssse3,
- &vpx_masked_sub_pixel_variance32x64_c),
- make_tuple(&vpx_masked_sub_pixel_variance32x32_ssse3,
- &vpx_masked_sub_pixel_variance32x32_c),
- make_tuple(&vpx_masked_sub_pixel_variance32x16_ssse3,
- &vpx_masked_sub_pixel_variance32x16_c),
- make_tuple(&vpx_masked_sub_pixel_variance16x32_ssse3,
- &vpx_masked_sub_pixel_variance16x32_c),
- make_tuple(&vpx_masked_sub_pixel_variance16x16_ssse3,
- &vpx_masked_sub_pixel_variance16x16_c),
- make_tuple(&vpx_masked_sub_pixel_variance16x8_ssse3,
- &vpx_masked_sub_pixel_variance16x8_c),
- make_tuple(&vpx_masked_sub_pixel_variance8x16_ssse3,
- &vpx_masked_sub_pixel_variance8x16_c),
- make_tuple(&vpx_masked_sub_pixel_variance8x8_ssse3,
- &vpx_masked_sub_pixel_variance8x8_c),
- make_tuple(&vpx_masked_sub_pixel_variance8x4_ssse3,
- &vpx_masked_sub_pixel_variance8x4_c),
- make_tuple(&vpx_masked_sub_pixel_variance4x8_ssse3,
- &vpx_masked_sub_pixel_variance4x8_c),
- make_tuple(&vpx_masked_sub_pixel_variance4x4_ssse3,
- &vpx_masked_sub_pixel_variance4x4_c)));
+ make_tuple(&aom_masked_sub_pixel_variance64x64_ssse3,
+ &aom_masked_sub_pixel_variance64x64_c),
+ make_tuple(&aom_masked_sub_pixel_variance64x32_ssse3,
+ &aom_masked_sub_pixel_variance64x32_c),
+ make_tuple(&aom_masked_sub_pixel_variance32x64_ssse3,
+ &aom_masked_sub_pixel_variance32x64_c),
+ make_tuple(&aom_masked_sub_pixel_variance32x32_ssse3,
+ &aom_masked_sub_pixel_variance32x32_c),
+ make_tuple(&aom_masked_sub_pixel_variance32x16_ssse3,
+ &aom_masked_sub_pixel_variance32x16_c),
+ make_tuple(&aom_masked_sub_pixel_variance16x32_ssse3,
+ &aom_masked_sub_pixel_variance16x32_c),
+ make_tuple(&aom_masked_sub_pixel_variance16x16_ssse3,
+ &aom_masked_sub_pixel_variance16x16_c),
+ make_tuple(&aom_masked_sub_pixel_variance16x8_ssse3,
+ &aom_masked_sub_pixel_variance16x8_c),
+ make_tuple(&aom_masked_sub_pixel_variance8x16_ssse3,
+ &aom_masked_sub_pixel_variance8x16_c),
+ make_tuple(&aom_masked_sub_pixel_variance8x8_ssse3,
+ &aom_masked_sub_pixel_variance8x8_c),
+ make_tuple(&aom_masked_sub_pixel_variance8x4_ssse3,
+ &aom_masked_sub_pixel_variance8x4_c),
+ make_tuple(&aom_masked_sub_pixel_variance4x8_ssse3,
+ &aom_masked_sub_pixel_variance4x8_c),
+ make_tuple(&aom_masked_sub_pixel_variance4x4_ssse3,
+ &aom_masked_sub_pixel_variance4x4_c)));
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
INSTANTIATE_TEST_CASE_P(
SSSE3_C_COMPARE, HighbdMaskedVarianceTest,
::testing::Values(
#if CONFIG_EXT_PARTITION
- make_tuple(&vpx_highbd_masked_variance128x128_ssse3,
- &vpx_highbd_masked_variance128x128_c, VPX_BITS_8),
- make_tuple(&vpx_highbd_masked_variance128x64_ssse3,
- &vpx_highbd_masked_variance128x64_c, VPX_BITS_8),
- make_tuple(&vpx_highbd_masked_variance64x128_ssse3,
- &vpx_highbd_masked_variance64x128_c, VPX_BITS_8),
+ make_tuple(&aom_highbd_masked_variance128x128_ssse3,
+ &aom_highbd_masked_variance128x128_c, AOM_BITS_8),
+ make_tuple(&aom_highbd_masked_variance128x64_ssse3,
+ &aom_highbd_masked_variance128x64_c, AOM_BITS_8),
+ make_tuple(&aom_highbd_masked_variance64x128_ssse3,
+ &aom_highbd_masked_variance64x128_c, AOM_BITS_8),
#endif // CONFIG_EXT_PARTITION
- make_tuple(&vpx_highbd_masked_variance64x64_ssse3,
- &vpx_highbd_masked_variance64x64_c, VPX_BITS_8),
- make_tuple(&vpx_highbd_masked_variance64x32_ssse3,
- &vpx_highbd_masked_variance64x32_c, VPX_BITS_8),
- make_tuple(&vpx_highbd_masked_variance32x64_ssse3,
- &vpx_highbd_masked_variance32x64_c, VPX_BITS_8),
- make_tuple(&vpx_highbd_masked_variance32x32_ssse3,
- &vpx_highbd_masked_variance32x32_c, VPX_BITS_8),
- make_tuple(&vpx_highbd_masked_variance32x16_ssse3,
- &vpx_highbd_masked_variance32x16_c, VPX_BITS_8),
- make_tuple(&vpx_highbd_masked_variance16x32_ssse3,
- &vpx_highbd_masked_variance16x32_c, VPX_BITS_8),
- make_tuple(&vpx_highbd_masked_variance16x16_ssse3,
- &vpx_highbd_masked_variance16x16_c, VPX_BITS_8),
- make_tuple(&vpx_highbd_masked_variance16x8_ssse3,
- &vpx_highbd_masked_variance16x8_c, VPX_BITS_8),
- make_tuple(&vpx_highbd_masked_variance8x16_ssse3,
- &vpx_highbd_masked_variance8x16_c, VPX_BITS_8),
- make_tuple(&vpx_highbd_masked_variance8x8_ssse3,
- &vpx_highbd_masked_variance8x8_c, VPX_BITS_8),
- make_tuple(&vpx_highbd_masked_variance8x4_ssse3,
- &vpx_highbd_masked_variance8x4_c, VPX_BITS_8),
- make_tuple(&vpx_highbd_masked_variance4x8_ssse3,
- &vpx_highbd_masked_variance4x8_c, VPX_BITS_8),
- make_tuple(&vpx_highbd_masked_variance4x4_ssse3,
- &vpx_highbd_masked_variance4x4_c, VPX_BITS_8),
+ make_tuple(&aom_highbd_masked_variance64x64_ssse3,
+ &aom_highbd_masked_variance64x64_c, AOM_BITS_8),
+ make_tuple(&aom_highbd_masked_variance64x32_ssse3,
+ &aom_highbd_masked_variance64x32_c, AOM_BITS_8),
+ make_tuple(&aom_highbd_masked_variance32x64_ssse3,
+ &aom_highbd_masked_variance32x64_c, AOM_BITS_8),
+ make_tuple(&aom_highbd_masked_variance32x32_ssse3,
+ &aom_highbd_masked_variance32x32_c, AOM_BITS_8),
+ make_tuple(&aom_highbd_masked_variance32x16_ssse3,
+ &aom_highbd_masked_variance32x16_c, AOM_BITS_8),
+ make_tuple(&aom_highbd_masked_variance16x32_ssse3,
+ &aom_highbd_masked_variance16x32_c, AOM_BITS_8),
+ make_tuple(&aom_highbd_masked_variance16x16_ssse3,
+ &aom_highbd_masked_variance16x16_c, AOM_BITS_8),
+ make_tuple(&aom_highbd_masked_variance16x8_ssse3,
+ &aom_highbd_masked_variance16x8_c, AOM_BITS_8),
+ make_tuple(&aom_highbd_masked_variance8x16_ssse3,
+ &aom_highbd_masked_variance8x16_c, AOM_BITS_8),
+ make_tuple(&aom_highbd_masked_variance8x8_ssse3,
+ &aom_highbd_masked_variance8x8_c, AOM_BITS_8),
+ make_tuple(&aom_highbd_masked_variance8x4_ssse3,
+ &aom_highbd_masked_variance8x4_c, AOM_BITS_8),
+ make_tuple(&aom_highbd_masked_variance4x8_ssse3,
+ &aom_highbd_masked_variance4x8_c, AOM_BITS_8),
+ make_tuple(&aom_highbd_masked_variance4x4_ssse3,
+ &aom_highbd_masked_variance4x4_c, AOM_BITS_8),
#if CONFIG_EXT_PARTITION
- make_tuple(&vpx_highbd_10_masked_variance128x128_ssse3,
- &vpx_highbd_10_masked_variance128x128_c, VPX_BITS_10),
- make_tuple(&vpx_highbd_10_masked_variance128x64_ssse3,
- &vpx_highbd_10_masked_variance128x64_c, VPX_BITS_10),
- make_tuple(&vpx_highbd_10_masked_variance64x128_ssse3,
- &vpx_highbd_10_masked_variance64x128_c, VPX_BITS_10),
+ make_tuple(&aom_highbd_10_masked_variance128x128_ssse3,
+ &aom_highbd_10_masked_variance128x128_c, AOM_BITS_10),
+ make_tuple(&aom_highbd_10_masked_variance128x64_ssse3,
+ &aom_highbd_10_masked_variance128x64_c, AOM_BITS_10),
+ make_tuple(&aom_highbd_10_masked_variance64x128_ssse3,
+ &aom_highbd_10_masked_variance64x128_c, AOM_BITS_10),
#endif // CONFIG_EXT_PARTITION
- make_tuple(&vpx_highbd_10_masked_variance64x64_ssse3,
- &vpx_highbd_10_masked_variance64x64_c, VPX_BITS_10),
- make_tuple(&vpx_highbd_10_masked_variance64x32_ssse3,
- &vpx_highbd_10_masked_variance64x32_c, VPX_BITS_10),
- make_tuple(&vpx_highbd_10_masked_variance32x64_ssse3,
- &vpx_highbd_10_masked_variance32x64_c, VPX_BITS_10),
- make_tuple(&vpx_highbd_10_masked_variance32x32_ssse3,
- &vpx_highbd_10_masked_variance32x32_c, VPX_BITS_10),
- make_tuple(&vpx_highbd_10_masked_variance32x16_ssse3,
- &vpx_highbd_10_masked_variance32x16_c, VPX_BITS_10),
- make_tuple(&vpx_highbd_10_masked_variance16x32_ssse3,
- &vpx_highbd_10_masked_variance16x32_c, VPX_BITS_10),
- make_tuple(&vpx_highbd_10_masked_variance16x16_ssse3,
- &vpx_highbd_10_masked_variance16x16_c, VPX_BITS_10),
- make_tuple(&vpx_highbd_10_masked_variance16x8_ssse3,
- &vpx_highbd_10_masked_variance16x8_c, VPX_BITS_10),
- make_tuple(&vpx_highbd_10_masked_variance8x16_ssse3,
- &vpx_highbd_10_masked_variance8x16_c, VPX_BITS_10),
- make_tuple(&vpx_highbd_10_masked_variance8x8_ssse3,
- &vpx_highbd_10_masked_variance8x8_c, VPX_BITS_10),
- make_tuple(&vpx_highbd_10_masked_variance8x4_ssse3,
- &vpx_highbd_10_masked_variance8x4_c, VPX_BITS_10),
- make_tuple(&vpx_highbd_10_masked_variance4x8_ssse3,
- &vpx_highbd_10_masked_variance4x8_c, VPX_BITS_10),
- make_tuple(&vpx_highbd_10_masked_variance4x4_ssse3,
- &vpx_highbd_10_masked_variance4x4_c, VPX_BITS_10),
+ make_tuple(&aom_highbd_10_masked_variance64x64_ssse3,
+ &aom_highbd_10_masked_variance64x64_c, AOM_BITS_10),
+ make_tuple(&aom_highbd_10_masked_variance64x32_ssse3,
+ &aom_highbd_10_masked_variance64x32_c, AOM_BITS_10),
+ make_tuple(&aom_highbd_10_masked_variance32x64_ssse3,
+ &aom_highbd_10_masked_variance32x64_c, AOM_BITS_10),
+ make_tuple(&aom_highbd_10_masked_variance32x32_ssse3,
+ &aom_highbd_10_masked_variance32x32_c, AOM_BITS_10),
+ make_tuple(&aom_highbd_10_masked_variance32x16_ssse3,
+ &aom_highbd_10_masked_variance32x16_c, AOM_BITS_10),
+ make_tuple(&aom_highbd_10_masked_variance16x32_ssse3,
+ &aom_highbd_10_masked_variance16x32_c, AOM_BITS_10),
+ make_tuple(&aom_highbd_10_masked_variance16x16_ssse3,
+ &aom_highbd_10_masked_variance16x16_c, AOM_BITS_10),
+ make_tuple(&aom_highbd_10_masked_variance16x8_ssse3,
+ &aom_highbd_10_masked_variance16x8_c, AOM_BITS_10),
+ make_tuple(&aom_highbd_10_masked_variance8x16_ssse3,
+ &aom_highbd_10_masked_variance8x16_c, AOM_BITS_10),
+ make_tuple(&aom_highbd_10_masked_variance8x8_ssse3,
+ &aom_highbd_10_masked_variance8x8_c, AOM_BITS_10),
+ make_tuple(&aom_highbd_10_masked_variance8x4_ssse3,
+ &aom_highbd_10_masked_variance8x4_c, AOM_BITS_10),
+ make_tuple(&aom_highbd_10_masked_variance4x8_ssse3,
+ &aom_highbd_10_masked_variance4x8_c, AOM_BITS_10),
+ make_tuple(&aom_highbd_10_masked_variance4x4_ssse3,
+ &aom_highbd_10_masked_variance4x4_c, AOM_BITS_10),
#if CONFIG_EXT_PARTITION
- make_tuple(&vpx_highbd_12_masked_variance128x128_ssse3,
- &vpx_highbd_12_masked_variance128x128_c, VPX_BITS_12),
- make_tuple(&vpx_highbd_12_masked_variance128x64_ssse3,
- &vpx_highbd_12_masked_variance128x64_c, VPX_BITS_12),
- make_tuple(&vpx_highbd_12_masked_variance64x128_ssse3,
- &vpx_highbd_12_masked_variance64x128_c, VPX_BITS_12),
+ make_tuple(&aom_highbd_12_masked_variance128x128_ssse3,
+ &aom_highbd_12_masked_variance128x128_c, AOM_BITS_12),
+ make_tuple(&aom_highbd_12_masked_variance128x64_ssse3,
+ &aom_highbd_12_masked_variance128x64_c, AOM_BITS_12),
+ make_tuple(&aom_highbd_12_masked_variance64x128_ssse3,
+ &aom_highbd_12_masked_variance64x128_c, AOM_BITS_12),
#endif // CONFIG_EXT_PARTITION
- make_tuple(&vpx_highbd_12_masked_variance64x64_ssse3,
- &vpx_highbd_12_masked_variance64x64_c, VPX_BITS_12),
- make_tuple(&vpx_highbd_12_masked_variance64x32_ssse3,
- &vpx_highbd_12_masked_variance64x32_c, VPX_BITS_12),
- make_tuple(&vpx_highbd_12_masked_variance32x64_ssse3,
- &vpx_highbd_12_masked_variance32x64_c, VPX_BITS_12),
- make_tuple(&vpx_highbd_12_masked_variance32x32_ssse3,
- &vpx_highbd_12_masked_variance32x32_c, VPX_BITS_12),
- make_tuple(&vpx_highbd_12_masked_variance32x16_ssse3,
- &vpx_highbd_12_masked_variance32x16_c, VPX_BITS_12),
- make_tuple(&vpx_highbd_12_masked_variance16x32_ssse3,
- &vpx_highbd_12_masked_variance16x32_c, VPX_BITS_12),
- make_tuple(&vpx_highbd_12_masked_variance16x16_ssse3,
- &vpx_highbd_12_masked_variance16x16_c, VPX_BITS_12),
- make_tuple(&vpx_highbd_12_masked_variance16x8_ssse3,
- &vpx_highbd_12_masked_variance16x8_c, VPX_BITS_12),
- make_tuple(&vpx_highbd_12_masked_variance8x16_ssse3,
- &vpx_highbd_12_masked_variance8x16_c, VPX_BITS_12),
- make_tuple(&vpx_highbd_12_masked_variance8x8_ssse3,
- &vpx_highbd_12_masked_variance8x8_c, VPX_BITS_12),
- make_tuple(&vpx_highbd_12_masked_variance8x4_ssse3,
- &vpx_highbd_12_masked_variance8x4_c, VPX_BITS_12),
- make_tuple(&vpx_highbd_12_masked_variance4x8_ssse3,
- &vpx_highbd_12_masked_variance4x8_c, VPX_BITS_12),
- make_tuple(&vpx_highbd_12_masked_variance4x4_ssse3,
- &vpx_highbd_12_masked_variance4x4_c, VPX_BITS_12)));
+ make_tuple(&aom_highbd_12_masked_variance64x64_ssse3,
+ &aom_highbd_12_masked_variance64x64_c, AOM_BITS_12),
+ make_tuple(&aom_highbd_12_masked_variance64x32_ssse3,
+ &aom_highbd_12_masked_variance64x32_c, AOM_BITS_12),
+ make_tuple(&aom_highbd_12_masked_variance32x64_ssse3,
+ &aom_highbd_12_masked_variance32x64_c, AOM_BITS_12),
+ make_tuple(&aom_highbd_12_masked_variance32x32_ssse3,
+ &aom_highbd_12_masked_variance32x32_c, AOM_BITS_12),
+ make_tuple(&aom_highbd_12_masked_variance32x16_ssse3,
+ &aom_highbd_12_masked_variance32x16_c, AOM_BITS_12),
+ make_tuple(&aom_highbd_12_masked_variance16x32_ssse3,
+ &aom_highbd_12_masked_variance16x32_c, AOM_BITS_12),
+ make_tuple(&aom_highbd_12_masked_variance16x16_ssse3,
+ &aom_highbd_12_masked_variance16x16_c, AOM_BITS_12),
+ make_tuple(&aom_highbd_12_masked_variance16x8_ssse3,
+ &aom_highbd_12_masked_variance16x8_c, AOM_BITS_12),
+ make_tuple(&aom_highbd_12_masked_variance8x16_ssse3,
+ &aom_highbd_12_masked_variance8x16_c, AOM_BITS_12),
+ make_tuple(&aom_highbd_12_masked_variance8x8_ssse3,
+ &aom_highbd_12_masked_variance8x8_c, AOM_BITS_12),
+ make_tuple(&aom_highbd_12_masked_variance8x4_ssse3,
+ &aom_highbd_12_masked_variance8x4_c, AOM_BITS_12),
+ make_tuple(&aom_highbd_12_masked_variance4x8_ssse3,
+ &aom_highbd_12_masked_variance4x8_c, AOM_BITS_12),
+ make_tuple(&aom_highbd_12_masked_variance4x4_ssse3,
+ &aom_highbd_12_masked_variance4x4_c, AOM_BITS_12)));
INSTANTIATE_TEST_CASE_P(
SSSE3_C_COMPARE, HighbdMaskedSubPixelVarianceTest,
::testing::Values(
#if CONFIG_EXT_PARTITION
- make_tuple(&vpx_highbd_masked_sub_pixel_variance128x128_ssse3,
- &vpx_highbd_masked_sub_pixel_variance128x128_c, VPX_BITS_8),
- make_tuple(&vpx_highbd_masked_sub_pixel_variance128x64_ssse3,
- &vpx_highbd_masked_sub_pixel_variance128x64_c, VPX_BITS_8),
- make_tuple(&vpx_highbd_masked_sub_pixel_variance64x128_ssse3,
- &vpx_highbd_masked_sub_pixel_variance64x128_c, VPX_BITS_8),
+ make_tuple(&aom_highbd_masked_sub_pixel_variance128x128_ssse3,
+ &aom_highbd_masked_sub_pixel_variance128x128_c, AOM_BITS_8),
+ make_tuple(&aom_highbd_masked_sub_pixel_variance128x64_ssse3,
+ &aom_highbd_masked_sub_pixel_variance128x64_c, AOM_BITS_8),
+ make_tuple(&aom_highbd_masked_sub_pixel_variance64x128_ssse3,
+ &aom_highbd_masked_sub_pixel_variance64x128_c, AOM_BITS_8),
#endif // CONFIG_EXT_PARTITION
- make_tuple(&vpx_highbd_masked_sub_pixel_variance64x64_ssse3,
- &vpx_highbd_masked_sub_pixel_variance64x64_c, VPX_BITS_8),
- make_tuple(&vpx_highbd_masked_sub_pixel_variance64x32_ssse3,
- &vpx_highbd_masked_sub_pixel_variance64x32_c, VPX_BITS_8),
- make_tuple(&vpx_highbd_masked_sub_pixel_variance32x64_ssse3,
- &vpx_highbd_masked_sub_pixel_variance32x64_c, VPX_BITS_8),
- make_tuple(&vpx_highbd_masked_sub_pixel_variance32x32_ssse3,
- &vpx_highbd_masked_sub_pixel_variance32x32_c, VPX_BITS_8),
- make_tuple(&vpx_highbd_masked_sub_pixel_variance32x16_ssse3,
- &vpx_highbd_masked_sub_pixel_variance32x16_c, VPX_BITS_8),
- make_tuple(&vpx_highbd_masked_sub_pixel_variance16x32_ssse3,
- &vpx_highbd_masked_sub_pixel_variance16x32_c, VPX_BITS_8),
- make_tuple(&vpx_highbd_masked_sub_pixel_variance16x16_ssse3,
- &vpx_highbd_masked_sub_pixel_variance16x16_c, VPX_BITS_8),
- make_tuple(&vpx_highbd_masked_sub_pixel_variance16x8_ssse3,
- &vpx_highbd_masked_sub_pixel_variance16x8_c, VPX_BITS_8),
- make_tuple(&vpx_highbd_masked_sub_pixel_variance8x16_ssse3,
- &vpx_highbd_masked_sub_pixel_variance8x16_c, VPX_BITS_8),
- make_tuple(&vpx_highbd_masked_sub_pixel_variance8x8_ssse3,
- &vpx_highbd_masked_sub_pixel_variance8x8_c, VPX_BITS_8),
- make_tuple(&vpx_highbd_masked_sub_pixel_variance8x4_ssse3,
- &vpx_highbd_masked_sub_pixel_variance8x4_c, VPX_BITS_8),
- make_tuple(&vpx_highbd_masked_sub_pixel_variance4x8_ssse3,
- &vpx_highbd_masked_sub_pixel_variance4x8_c, VPX_BITS_8),
- make_tuple(&vpx_highbd_masked_sub_pixel_variance4x4_ssse3,
- &vpx_highbd_masked_sub_pixel_variance4x4_c, VPX_BITS_8),
+ make_tuple(&aom_highbd_masked_sub_pixel_variance64x64_ssse3,
+ &aom_highbd_masked_sub_pixel_variance64x64_c, AOM_BITS_8),
+ make_tuple(&aom_highbd_masked_sub_pixel_variance64x32_ssse3,
+ &aom_highbd_masked_sub_pixel_variance64x32_c, AOM_BITS_8),
+ make_tuple(&aom_highbd_masked_sub_pixel_variance32x64_ssse3,
+ &aom_highbd_masked_sub_pixel_variance32x64_c, AOM_BITS_8),
+ make_tuple(&aom_highbd_masked_sub_pixel_variance32x32_ssse3,
+ &aom_highbd_masked_sub_pixel_variance32x32_c, AOM_BITS_8),
+ make_tuple(&aom_highbd_masked_sub_pixel_variance32x16_ssse3,
+ &aom_highbd_masked_sub_pixel_variance32x16_c, AOM_BITS_8),
+ make_tuple(&aom_highbd_masked_sub_pixel_variance16x32_ssse3,
+ &aom_highbd_masked_sub_pixel_variance16x32_c, AOM_BITS_8),
+ make_tuple(&aom_highbd_masked_sub_pixel_variance16x16_ssse3,
+ &aom_highbd_masked_sub_pixel_variance16x16_c, AOM_BITS_8),
+ make_tuple(&aom_highbd_masked_sub_pixel_variance16x8_ssse3,
+ &aom_highbd_masked_sub_pixel_variance16x8_c, AOM_BITS_8),
+ make_tuple(&aom_highbd_masked_sub_pixel_variance8x16_ssse3,
+ &aom_highbd_masked_sub_pixel_variance8x16_c, AOM_BITS_8),
+ make_tuple(&aom_highbd_masked_sub_pixel_variance8x8_ssse3,
+ &aom_highbd_masked_sub_pixel_variance8x8_c, AOM_BITS_8),
+ make_tuple(&aom_highbd_masked_sub_pixel_variance8x4_ssse3,
+ &aom_highbd_masked_sub_pixel_variance8x4_c, AOM_BITS_8),
+ make_tuple(&aom_highbd_masked_sub_pixel_variance4x8_ssse3,
+ &aom_highbd_masked_sub_pixel_variance4x8_c, AOM_BITS_8),
+ make_tuple(&aom_highbd_masked_sub_pixel_variance4x4_ssse3,
+ &aom_highbd_masked_sub_pixel_variance4x4_c, AOM_BITS_8),
#if CONFIG_EXT_PARTITION
- make_tuple(&vpx_highbd_10_masked_sub_pixel_variance128x128_ssse3,
- &vpx_highbd_10_masked_sub_pixel_variance128x128_c,
- VPX_BITS_10),
- make_tuple(&vpx_highbd_10_masked_sub_pixel_variance128x64_ssse3,
- &vpx_highbd_10_masked_sub_pixel_variance128x64_c,
- VPX_BITS_10),
- make_tuple(&vpx_highbd_10_masked_sub_pixel_variance64x128_ssse3,
- &vpx_highbd_10_masked_sub_pixel_variance64x128_c,
- VPX_BITS_10),
+ make_tuple(&aom_highbd_10_masked_sub_pixel_variance128x128_ssse3,
+ &aom_highbd_10_masked_sub_pixel_variance128x128_c,
+ AOM_BITS_10),
+ make_tuple(&aom_highbd_10_masked_sub_pixel_variance128x64_ssse3,
+ &aom_highbd_10_masked_sub_pixel_variance128x64_c,
+ AOM_BITS_10),
+ make_tuple(&aom_highbd_10_masked_sub_pixel_variance64x128_ssse3,
+ &aom_highbd_10_masked_sub_pixel_variance64x128_c,
+ AOM_BITS_10),
#endif // CONFIG_EXT_PARTITION
- make_tuple(&vpx_highbd_10_masked_sub_pixel_variance64x64_ssse3,
- &vpx_highbd_10_masked_sub_pixel_variance64x64_c,
- VPX_BITS_10),
- make_tuple(&vpx_highbd_10_masked_sub_pixel_variance64x32_ssse3,
- &vpx_highbd_10_masked_sub_pixel_variance64x32_c,
- VPX_BITS_10),
- make_tuple(&vpx_highbd_10_masked_sub_pixel_variance32x64_ssse3,
- &vpx_highbd_10_masked_sub_pixel_variance32x64_c,
- VPX_BITS_10),
- make_tuple(&vpx_highbd_10_masked_sub_pixel_variance32x32_ssse3,
- &vpx_highbd_10_masked_sub_pixel_variance32x32_c,
- VPX_BITS_10),
- make_tuple(&vpx_highbd_10_masked_sub_pixel_variance32x16_ssse3,
- &vpx_highbd_10_masked_sub_pixel_variance32x16_c,
- VPX_BITS_10),
- make_tuple(&vpx_highbd_10_masked_sub_pixel_variance16x32_ssse3,
- &vpx_highbd_10_masked_sub_pixel_variance16x32_c,
- VPX_BITS_10),
- make_tuple(&vpx_highbd_10_masked_sub_pixel_variance16x16_ssse3,
- &vpx_highbd_10_masked_sub_pixel_variance16x16_c,
- VPX_BITS_10),
- make_tuple(&vpx_highbd_10_masked_sub_pixel_variance16x8_ssse3,
- &vpx_highbd_10_masked_sub_pixel_variance16x8_c, VPX_BITS_10),
- make_tuple(&vpx_highbd_10_masked_sub_pixel_variance8x16_ssse3,
- &vpx_highbd_10_masked_sub_pixel_variance8x16_c, VPX_BITS_10),
- make_tuple(&vpx_highbd_10_masked_sub_pixel_variance8x8_ssse3,
- &vpx_highbd_10_masked_sub_pixel_variance8x8_c, VPX_BITS_10),
- make_tuple(&vpx_highbd_10_masked_sub_pixel_variance8x4_ssse3,
- &vpx_highbd_10_masked_sub_pixel_variance8x4_c, VPX_BITS_10),
- make_tuple(&vpx_highbd_10_masked_sub_pixel_variance4x8_ssse3,
- &vpx_highbd_10_masked_sub_pixel_variance4x8_c, VPX_BITS_10),
- make_tuple(&vpx_highbd_10_masked_sub_pixel_variance4x4_ssse3,
- &vpx_highbd_10_masked_sub_pixel_variance4x4_c, VPX_BITS_10),
+ make_tuple(&aom_highbd_10_masked_sub_pixel_variance64x64_ssse3,
+ &aom_highbd_10_masked_sub_pixel_variance64x64_c,
+ AOM_BITS_10),
+ make_tuple(&aom_highbd_10_masked_sub_pixel_variance64x32_ssse3,
+ &aom_highbd_10_masked_sub_pixel_variance64x32_c,
+ AOM_BITS_10),
+ make_tuple(&aom_highbd_10_masked_sub_pixel_variance32x64_ssse3,
+ &aom_highbd_10_masked_sub_pixel_variance32x64_c,
+ AOM_BITS_10),
+ make_tuple(&aom_highbd_10_masked_sub_pixel_variance32x32_ssse3,
+ &aom_highbd_10_masked_sub_pixel_variance32x32_c,
+ AOM_BITS_10),
+ make_tuple(&aom_highbd_10_masked_sub_pixel_variance32x16_ssse3,
+ &aom_highbd_10_masked_sub_pixel_variance32x16_c,
+ AOM_BITS_10),
+ make_tuple(&aom_highbd_10_masked_sub_pixel_variance16x32_ssse3,
+ &aom_highbd_10_masked_sub_pixel_variance16x32_c,
+ AOM_BITS_10),
+ make_tuple(&aom_highbd_10_masked_sub_pixel_variance16x16_ssse3,
+ &aom_highbd_10_masked_sub_pixel_variance16x16_c,
+ AOM_BITS_10),
+ make_tuple(&aom_highbd_10_masked_sub_pixel_variance16x8_ssse3,
+ &aom_highbd_10_masked_sub_pixel_variance16x8_c, AOM_BITS_10),
+ make_tuple(&aom_highbd_10_masked_sub_pixel_variance8x16_ssse3,
+ &aom_highbd_10_masked_sub_pixel_variance8x16_c, AOM_BITS_10),
+ make_tuple(&aom_highbd_10_masked_sub_pixel_variance8x8_ssse3,
+ &aom_highbd_10_masked_sub_pixel_variance8x8_c, AOM_BITS_10),
+ make_tuple(&aom_highbd_10_masked_sub_pixel_variance8x4_ssse3,
+ &aom_highbd_10_masked_sub_pixel_variance8x4_c, AOM_BITS_10),
+ make_tuple(&aom_highbd_10_masked_sub_pixel_variance4x8_ssse3,
+ &aom_highbd_10_masked_sub_pixel_variance4x8_c, AOM_BITS_10),
+ make_tuple(&aom_highbd_10_masked_sub_pixel_variance4x4_ssse3,
+ &aom_highbd_10_masked_sub_pixel_variance4x4_c, AOM_BITS_10),
#if CONFIG_EXT_PARTITION
- make_tuple(&vpx_highbd_12_masked_sub_pixel_variance128x128_ssse3,
- &vpx_highbd_12_masked_sub_pixel_variance128x128_c,
- VPX_BITS_12),
- make_tuple(&vpx_highbd_12_masked_sub_pixel_variance128x64_ssse3,
- &vpx_highbd_12_masked_sub_pixel_variance128x64_c,
- VPX_BITS_12),
- make_tuple(&vpx_highbd_12_masked_sub_pixel_variance64x128_ssse3,
- &vpx_highbd_12_masked_sub_pixel_variance64x128_c,
- VPX_BITS_12),
+ make_tuple(&aom_highbd_12_masked_sub_pixel_variance128x128_ssse3,
+ &aom_highbd_12_masked_sub_pixel_variance128x128_c,
+ AOM_BITS_12),
+ make_tuple(&aom_highbd_12_masked_sub_pixel_variance128x64_ssse3,
+ &aom_highbd_12_masked_sub_pixel_variance128x64_c,
+ AOM_BITS_12),
+ make_tuple(&aom_highbd_12_masked_sub_pixel_variance64x128_ssse3,
+ &aom_highbd_12_masked_sub_pixel_variance64x128_c,
+ AOM_BITS_12),
#endif // CONFIG_EXT_PARTITION
- make_tuple(&vpx_highbd_12_masked_sub_pixel_variance64x64_ssse3,
- &vpx_highbd_12_masked_sub_pixel_variance64x64_c,
- VPX_BITS_12),
- make_tuple(&vpx_highbd_12_masked_sub_pixel_variance64x32_ssse3,
- &vpx_highbd_12_masked_sub_pixel_variance64x32_c,
- VPX_BITS_12),
- make_tuple(&vpx_highbd_12_masked_sub_pixel_variance32x64_ssse3,
- &vpx_highbd_12_masked_sub_pixel_variance32x64_c,
- VPX_BITS_12),
- make_tuple(&vpx_highbd_12_masked_sub_pixel_variance32x32_ssse3,
- &vpx_highbd_12_masked_sub_pixel_variance32x32_c,
- VPX_BITS_12),
- make_tuple(&vpx_highbd_12_masked_sub_pixel_variance32x16_ssse3,
- &vpx_highbd_12_masked_sub_pixel_variance32x16_c,
- VPX_BITS_12),
- make_tuple(&vpx_highbd_12_masked_sub_pixel_variance16x32_ssse3,
- &vpx_highbd_12_masked_sub_pixel_variance16x32_c,
- VPX_BITS_12),
- make_tuple(&vpx_highbd_12_masked_sub_pixel_variance16x16_ssse3,
- &vpx_highbd_12_masked_sub_pixel_variance16x16_c,
- VPX_BITS_12),
- make_tuple(&vpx_highbd_12_masked_sub_pixel_variance16x8_ssse3,
- &vpx_highbd_12_masked_sub_pixel_variance16x8_c, VPX_BITS_12),
- make_tuple(&vpx_highbd_12_masked_sub_pixel_variance8x16_ssse3,
- &vpx_highbd_12_masked_sub_pixel_variance8x16_c, VPX_BITS_12),
- make_tuple(&vpx_highbd_12_masked_sub_pixel_variance8x8_ssse3,
- &vpx_highbd_12_masked_sub_pixel_variance8x8_c, VPX_BITS_12),
- make_tuple(&vpx_highbd_12_masked_sub_pixel_variance8x4_ssse3,
- &vpx_highbd_12_masked_sub_pixel_variance8x4_c, VPX_BITS_12),
- make_tuple(&vpx_highbd_12_masked_sub_pixel_variance4x8_ssse3,
- &vpx_highbd_12_masked_sub_pixel_variance4x8_c, VPX_BITS_12),
- make_tuple(&vpx_highbd_12_masked_sub_pixel_variance4x4_ssse3,
- &vpx_highbd_12_masked_sub_pixel_variance4x4_c,
- VPX_BITS_12)));
-#endif // CONFIG_VP9_HIGHBITDEPTH
+ make_tuple(&aom_highbd_12_masked_sub_pixel_variance64x64_ssse3,
+ &aom_highbd_12_masked_sub_pixel_variance64x64_c,
+ AOM_BITS_12),
+ make_tuple(&aom_highbd_12_masked_sub_pixel_variance64x32_ssse3,
+ &aom_highbd_12_masked_sub_pixel_variance64x32_c,
+ AOM_BITS_12),
+ make_tuple(&aom_highbd_12_masked_sub_pixel_variance32x64_ssse3,
+ &aom_highbd_12_masked_sub_pixel_variance32x64_c,
+ AOM_BITS_12),
+ make_tuple(&aom_highbd_12_masked_sub_pixel_variance32x32_ssse3,
+ &aom_highbd_12_masked_sub_pixel_variance32x32_c,
+ AOM_BITS_12),
+ make_tuple(&aom_highbd_12_masked_sub_pixel_variance32x16_ssse3,
+ &aom_highbd_12_masked_sub_pixel_variance32x16_c,
+ AOM_BITS_12),
+ make_tuple(&aom_highbd_12_masked_sub_pixel_variance16x32_ssse3,
+ &aom_highbd_12_masked_sub_pixel_variance16x32_c,
+ AOM_BITS_12),
+ make_tuple(&aom_highbd_12_masked_sub_pixel_variance16x16_ssse3,
+ &aom_highbd_12_masked_sub_pixel_variance16x16_c,
+ AOM_BITS_12),
+ make_tuple(&aom_highbd_12_masked_sub_pixel_variance16x8_ssse3,
+ &aom_highbd_12_masked_sub_pixel_variance16x8_c, AOM_BITS_12),
+ make_tuple(&aom_highbd_12_masked_sub_pixel_variance8x16_ssse3,
+ &aom_highbd_12_masked_sub_pixel_variance8x16_c, AOM_BITS_12),
+ make_tuple(&aom_highbd_12_masked_sub_pixel_variance8x8_ssse3,
+ &aom_highbd_12_masked_sub_pixel_variance8x8_c, AOM_BITS_12),
+ make_tuple(&aom_highbd_12_masked_sub_pixel_variance8x4_ssse3,
+ &aom_highbd_12_masked_sub_pixel_variance8x4_c, AOM_BITS_12),
+ make_tuple(&aom_highbd_12_masked_sub_pixel_variance4x8_ssse3,
+ &aom_highbd_12_masked_sub_pixel_variance4x8_c, AOM_BITS_12),
+ make_tuple(&aom_highbd_12_masked_sub_pixel_variance4x4_ssse3,
+ &aom_highbd_12_masked_sub_pixel_variance4x4_c,
+ AOM_BITS_12)));
+#endif // CONFIG_AOM_HIGHBITDEPTH
#endif // HAVE_SSSE3
} // namespace
diff --git a/test/md5_helper.h b/test/md5_helper.h
index b995619..262dd08 100644
--- a/test/md5_helper.h
+++ b/test/md5_helper.h
@@ -12,14 +12,14 @@
#define TEST_MD5_HELPER_H_
#include "./md5_utils.h"
-#include "aom/vpx_decoder.h"
+#include "aom/aom_decoder.h"
namespace libaom_test {
class MD5 {
public:
MD5() { MD5Init(&md5_); }
- void Add(const vpx_image_t *img) {
+ void Add(const aom_image_t *img) {
for (int plane = 0; plane < 3; ++plane) {
const uint8_t *buf = img->planes[plane];
// Calculate the width and height to do the md5 check. For the chroma
@@ -27,7 +27,7 @@
// we are shifting by 1 (chroma_shift) we add 1 before doing the shift.
// This works only for chroma_shift of 0 and 1.
const int bytes_per_sample =
- (img->fmt & VPX_IMG_FMT_HIGHBITDEPTH) ? 2 : 1;
+ (img->fmt & AOM_IMG_FMT_HIGHBITDEPTH) ? 2 : 1;
const int h =
plane ? (img->d_h + img->y_chroma_shift) >> img->y_chroma_shift
: img->d_h;
diff --git a/test/minmax_test.cc b/test/minmax_test.cc
index 026f79a..735f617 100644
--- a/test/minmax_test.cc
+++ b/test/minmax_test.cc
@@ -13,8 +13,8 @@
#include "third_party/googletest/src/include/gtest/gtest.h"
-#include "./vpx_dsp_rtcd.h"
-#include "aom/vpx_integer.h"
+#include "./aom_dsp_rtcd.h"
+#include "aom/aom_integer.h"
#include "test/acm_random.h"
#include "test/register_state_check.h"
@@ -115,16 +115,16 @@
}
}
-INSTANTIATE_TEST_CASE_P(C, MinMaxTest, ::testing::Values(&vpx_minmax_8x8_c));
+INSTANTIATE_TEST_CASE_P(C, MinMaxTest, ::testing::Values(&aom_minmax_8x8_c));
#if HAVE_SSE2
INSTANTIATE_TEST_CASE_P(SSE2, MinMaxTest,
- ::testing::Values(&vpx_minmax_8x8_sse2));
+ ::testing::Values(&aom_minmax_8x8_sse2));
#endif
#if HAVE_NEON
INSTANTIATE_TEST_CASE_P(NEON, MinMaxTest,
- ::testing::Values(&vpx_minmax_8x8_neon));
+ ::testing::Values(&aom_minmax_8x8_neon));
#endif
} // namespace
diff --git a/test/obmc_sad_test.cc b/test/obmc_sad_test.cc
index c47bd26..40a9ea0 100644
--- a/test/obmc_sad_test.cc
+++ b/test/obmc_sad_test.cc
@@ -13,9 +13,9 @@
#include "test/function_equivalence_test.h"
#include "test/register_state_check.h"
-#include "./vpx_config.h"
-#include "./vpx_dsp_rtcd.h"
-#include "aom/vpx_integer.h"
+#include "./aom_config.h"
+#include "./aom_dsp_rtcd.h"
+#include "aom/aom_integer.h"
#define MAX_SB_SQUARE (MAX_SB_SIZE * MAX_SB_SIZE)
@@ -85,23 +85,23 @@
#if HAVE_SSE4_1
const ObmcSadTest::ParamType sse4_functions[] = {
#if CONFIG_EXT_PARTITION
- TestFuncs(vpx_obmc_sad128x128_c, vpx_obmc_sad128x128_sse4_1),
- TestFuncs(vpx_obmc_sad128x64_c, vpx_obmc_sad128x64_sse4_1),
- TestFuncs(vpx_obmc_sad64x128_c, vpx_obmc_sad64x128_sse4_1),
+ TestFuncs(aom_obmc_sad128x128_c, aom_obmc_sad128x128_sse4_1),
+ TestFuncs(aom_obmc_sad128x64_c, aom_obmc_sad128x64_sse4_1),
+ TestFuncs(aom_obmc_sad64x128_c, aom_obmc_sad64x128_sse4_1),
#endif // CONFIG_EXT_PARTITION
- TestFuncs(vpx_obmc_sad64x64_c, vpx_obmc_sad64x64_sse4_1),
- TestFuncs(vpx_obmc_sad64x32_c, vpx_obmc_sad64x32_sse4_1),
- TestFuncs(vpx_obmc_sad32x64_c, vpx_obmc_sad32x64_sse4_1),
- TestFuncs(vpx_obmc_sad32x32_c, vpx_obmc_sad32x32_sse4_1),
- TestFuncs(vpx_obmc_sad32x16_c, vpx_obmc_sad32x16_sse4_1),
- TestFuncs(vpx_obmc_sad16x32_c, vpx_obmc_sad16x32_sse4_1),
- TestFuncs(vpx_obmc_sad16x16_c, vpx_obmc_sad16x16_sse4_1),
- TestFuncs(vpx_obmc_sad16x8_c, vpx_obmc_sad16x8_sse4_1),
- TestFuncs(vpx_obmc_sad8x16_c, vpx_obmc_sad8x16_sse4_1),
- TestFuncs(vpx_obmc_sad8x8_c, vpx_obmc_sad8x8_sse4_1),
- TestFuncs(vpx_obmc_sad8x4_c, vpx_obmc_sad8x4_sse4_1),
- TestFuncs(vpx_obmc_sad4x8_c, vpx_obmc_sad4x8_sse4_1),
- TestFuncs(vpx_obmc_sad4x4_c, vpx_obmc_sad4x4_sse4_1)
+ TestFuncs(aom_obmc_sad64x64_c, aom_obmc_sad64x64_sse4_1),
+ TestFuncs(aom_obmc_sad64x32_c, aom_obmc_sad64x32_sse4_1),
+ TestFuncs(aom_obmc_sad32x64_c, aom_obmc_sad32x64_sse4_1),
+ TestFuncs(aom_obmc_sad32x32_c, aom_obmc_sad32x32_sse4_1),
+ TestFuncs(aom_obmc_sad32x16_c, aom_obmc_sad32x16_sse4_1),
+ TestFuncs(aom_obmc_sad16x32_c, aom_obmc_sad16x32_sse4_1),
+ TestFuncs(aom_obmc_sad16x16_c, aom_obmc_sad16x16_sse4_1),
+ TestFuncs(aom_obmc_sad16x8_c, aom_obmc_sad16x8_sse4_1),
+ TestFuncs(aom_obmc_sad8x16_c, aom_obmc_sad8x16_sse4_1),
+ TestFuncs(aom_obmc_sad8x8_c, aom_obmc_sad8x8_sse4_1),
+ TestFuncs(aom_obmc_sad8x4_c, aom_obmc_sad8x4_sse4_1),
+ TestFuncs(aom_obmc_sad4x8_c, aom_obmc_sad4x8_sse4_1),
+ TestFuncs(aom_obmc_sad4x4_c, aom_obmc_sad4x4_sse4_1)
};
INSTANTIATE_TEST_CASE_P(SSE4_1_C_COMPARE, ObmcSadTest,
@@ -112,7 +112,7 @@
// High bit-depth
////////////////////////////////////////////////////////////////////////////////
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
class ObmcSadHBDTest : public FunctionEquivalenceTest<ObmcSadF> {};
TEST_P(ObmcSadHBDTest, RandomValues) {
@@ -168,27 +168,27 @@
#if HAVE_SSE4_1
ObmcSadHBDTest::ParamType sse4_functions_hbd[] = {
#if CONFIG_EXT_PARTITION
- TestFuncs(vpx_highbd_obmc_sad128x128_c, vpx_highbd_obmc_sad128x128_sse4_1),
- TestFuncs(vpx_highbd_obmc_sad128x64_c, vpx_highbd_obmc_sad128x64_sse4_1),
- TestFuncs(vpx_highbd_obmc_sad64x128_c, vpx_highbd_obmc_sad64x128_sse4_1),
+ TestFuncs(aom_highbd_obmc_sad128x128_c, aom_highbd_obmc_sad128x128_sse4_1),
+ TestFuncs(aom_highbd_obmc_sad128x64_c, aom_highbd_obmc_sad128x64_sse4_1),
+ TestFuncs(aom_highbd_obmc_sad64x128_c, aom_highbd_obmc_sad64x128_sse4_1),
#endif // CONFIG_EXT_PARTITION
- TestFuncs(vpx_highbd_obmc_sad64x64_c, vpx_highbd_obmc_sad64x64_sse4_1),
- TestFuncs(vpx_highbd_obmc_sad64x32_c, vpx_highbd_obmc_sad64x32_sse4_1),
- TestFuncs(vpx_highbd_obmc_sad32x64_c, vpx_highbd_obmc_sad32x64_sse4_1),
- TestFuncs(vpx_highbd_obmc_sad32x32_c, vpx_highbd_obmc_sad32x32_sse4_1),
- TestFuncs(vpx_highbd_obmc_sad32x16_c, vpx_highbd_obmc_sad32x16_sse4_1),
- TestFuncs(vpx_highbd_obmc_sad16x32_c, vpx_highbd_obmc_sad16x32_sse4_1),
- TestFuncs(vpx_highbd_obmc_sad16x16_c, vpx_highbd_obmc_sad16x16_sse4_1),
- TestFuncs(vpx_highbd_obmc_sad16x8_c, vpx_highbd_obmc_sad16x8_sse4_1),
- TestFuncs(vpx_highbd_obmc_sad8x16_c, vpx_highbd_obmc_sad8x16_sse4_1),
- TestFuncs(vpx_highbd_obmc_sad8x8_c, vpx_highbd_obmc_sad8x8_sse4_1),
- TestFuncs(vpx_highbd_obmc_sad8x4_c, vpx_highbd_obmc_sad8x4_sse4_1),
- TestFuncs(vpx_highbd_obmc_sad4x8_c, vpx_highbd_obmc_sad4x8_sse4_1),
- TestFuncs(vpx_highbd_obmc_sad4x4_c, vpx_highbd_obmc_sad4x4_sse4_1)
+ TestFuncs(aom_highbd_obmc_sad64x64_c, aom_highbd_obmc_sad64x64_sse4_1),
+ TestFuncs(aom_highbd_obmc_sad64x32_c, aom_highbd_obmc_sad64x32_sse4_1),
+ TestFuncs(aom_highbd_obmc_sad32x64_c, aom_highbd_obmc_sad32x64_sse4_1),
+ TestFuncs(aom_highbd_obmc_sad32x32_c, aom_highbd_obmc_sad32x32_sse4_1),
+ TestFuncs(aom_highbd_obmc_sad32x16_c, aom_highbd_obmc_sad32x16_sse4_1),
+ TestFuncs(aom_highbd_obmc_sad16x32_c, aom_highbd_obmc_sad16x32_sse4_1),
+ TestFuncs(aom_highbd_obmc_sad16x16_c, aom_highbd_obmc_sad16x16_sse4_1),
+ TestFuncs(aom_highbd_obmc_sad16x8_c, aom_highbd_obmc_sad16x8_sse4_1),
+ TestFuncs(aom_highbd_obmc_sad8x16_c, aom_highbd_obmc_sad8x16_sse4_1),
+ TestFuncs(aom_highbd_obmc_sad8x8_c, aom_highbd_obmc_sad8x8_sse4_1),
+ TestFuncs(aom_highbd_obmc_sad8x4_c, aom_highbd_obmc_sad8x4_sse4_1),
+ TestFuncs(aom_highbd_obmc_sad4x8_c, aom_highbd_obmc_sad4x8_sse4_1),
+ TestFuncs(aom_highbd_obmc_sad4x4_c, aom_highbd_obmc_sad4x4_sse4_1)
};
INSTANTIATE_TEST_CASE_P(SSE4_1_C_COMPARE, ObmcSadHBDTest,
::testing::ValuesIn(sse4_functions_hbd));
#endif // HAVE_SSE4_1
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#endif // CONFIG_AOM_HIGHBITDEPTH
} // namespace
diff --git a/test/obmc_variance_test.cc b/test/obmc_variance_test.cc
index ff4dd4a..5a6bace 100644
--- a/test/obmc_variance_test.cc
+++ b/test/obmc_variance_test.cc
@@ -14,9 +14,9 @@
#include "test/function_equivalence_test.h"
#include "test/register_state_check.h"
-#include "./vpx_config.h"
-#include "./vpx_dsp_rtcd.h"
-#include "aom/vpx_integer.h"
+#include "./aom_config.h"
+#include "./aom_dsp_rtcd.h"
+#include "aom/aom_integer.h"
#define MAX_SB_SQUARE (MAX_SB_SIZE * MAX_SB_SIZE)
@@ -94,23 +94,23 @@
#if HAVE_SSE4_1
const ObmcVarianceTest::ParamType sse4_functions[] = {
#if CONFIG_EXT_PARTITION
- TestFuncs(vpx_obmc_variance128x128_c, vpx_obmc_variance128x128_sse4_1),
- TestFuncs(vpx_obmc_variance128x64_c, vpx_obmc_variance128x64_sse4_1),
- TestFuncs(vpx_obmc_variance64x128_c, vpx_obmc_variance64x128_sse4_1),
+ TestFuncs(aom_obmc_variance128x128_c, aom_obmc_variance128x128_sse4_1),
+ TestFuncs(aom_obmc_variance128x64_c, aom_obmc_variance128x64_sse4_1),
+ TestFuncs(aom_obmc_variance64x128_c, aom_obmc_variance64x128_sse4_1),
#endif // CONFIG_EXT_PARTITION
- TestFuncs(vpx_obmc_variance64x64_c, vpx_obmc_variance64x64_sse4_1),
- TestFuncs(vpx_obmc_variance64x32_c, vpx_obmc_variance64x32_sse4_1),
- TestFuncs(vpx_obmc_variance32x64_c, vpx_obmc_variance32x64_sse4_1),
- TestFuncs(vpx_obmc_variance32x32_c, vpx_obmc_variance32x32_sse4_1),
- TestFuncs(vpx_obmc_variance32x16_c, vpx_obmc_variance32x16_sse4_1),
- TestFuncs(vpx_obmc_variance16x32_c, vpx_obmc_variance16x32_sse4_1),
- TestFuncs(vpx_obmc_variance16x16_c, vpx_obmc_variance16x16_sse4_1),
- TestFuncs(vpx_obmc_variance16x8_c, vpx_obmc_variance16x8_sse4_1),
- TestFuncs(vpx_obmc_variance8x16_c, vpx_obmc_variance8x16_sse4_1),
- TestFuncs(vpx_obmc_variance8x8_c, vpx_obmc_variance8x8_sse4_1),
- TestFuncs(vpx_obmc_variance8x4_c, vpx_obmc_variance8x4_sse4_1),
- TestFuncs(vpx_obmc_variance4x8_c, vpx_obmc_variance4x8_sse4_1),
- TestFuncs(vpx_obmc_variance4x4_c, vpx_obmc_variance4x4_sse4_1)
+ TestFuncs(aom_obmc_variance64x64_c, aom_obmc_variance64x64_sse4_1),
+ TestFuncs(aom_obmc_variance64x32_c, aom_obmc_variance64x32_sse4_1),
+ TestFuncs(aom_obmc_variance32x64_c, aom_obmc_variance32x64_sse4_1),
+ TestFuncs(aom_obmc_variance32x32_c, aom_obmc_variance32x32_sse4_1),
+ TestFuncs(aom_obmc_variance32x16_c, aom_obmc_variance32x16_sse4_1),
+ TestFuncs(aom_obmc_variance16x32_c, aom_obmc_variance16x32_sse4_1),
+ TestFuncs(aom_obmc_variance16x16_c, aom_obmc_variance16x16_sse4_1),
+ TestFuncs(aom_obmc_variance16x8_c, aom_obmc_variance16x8_sse4_1),
+ TestFuncs(aom_obmc_variance8x16_c, aom_obmc_variance8x16_sse4_1),
+ TestFuncs(aom_obmc_variance8x8_c, aom_obmc_variance8x8_sse4_1),
+ TestFuncs(aom_obmc_variance8x4_c, aom_obmc_variance8x4_sse4_1),
+ TestFuncs(aom_obmc_variance4x8_c, aom_obmc_variance4x8_sse4_1),
+ TestFuncs(aom_obmc_variance4x4_c, aom_obmc_variance4x4_sse4_1)
};
INSTANTIATE_TEST_CASE_P(SSE4_1_C_COMPARE, ObmcVarianceTest,
@@ -121,7 +121,7 @@
// High bit-depth
////////////////////////////////////////////////////////////////////////////////
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
class ObmcVarianceHBDTest : public FunctionEquivalenceTest<ObmcVarF> {};
TEST_P(ObmcVarianceHBDTest, RandomValues) {
@@ -182,111 +182,111 @@
#if HAVE_SSE4_1
ObmcVarianceHBDTest::ParamType sse4_functions_hbd[] = {
#if CONFIG_EXT_PARTITION
- TestFuncs(vpx_highbd_obmc_variance128x128_c,
- vpx_highbd_obmc_variance128x128_sse4_1, 8),
- TestFuncs(vpx_highbd_obmc_variance128x64_c,
- vpx_highbd_obmc_variance128x64_sse4_1, 8),
- TestFuncs(vpx_highbd_obmc_variance64x128_c,
- vpx_highbd_obmc_variance64x128_sse4_1, 8),
+ TestFuncs(aom_highbd_obmc_variance128x128_c,
+ aom_highbd_obmc_variance128x128_sse4_1, 8),
+ TestFuncs(aom_highbd_obmc_variance128x64_c,
+ aom_highbd_obmc_variance128x64_sse4_1, 8),
+ TestFuncs(aom_highbd_obmc_variance64x128_c,
+ aom_highbd_obmc_variance64x128_sse4_1, 8),
#endif // CONFIG_EXT_PARTITION
- TestFuncs(vpx_highbd_obmc_variance64x64_c,
- vpx_highbd_obmc_variance64x64_sse4_1, 8),
- TestFuncs(vpx_highbd_obmc_variance64x32_c,
- vpx_highbd_obmc_variance64x32_sse4_1, 8),
- TestFuncs(vpx_highbd_obmc_variance32x64_c,
- vpx_highbd_obmc_variance32x64_sse4_1, 8),
- TestFuncs(vpx_highbd_obmc_variance32x32_c,
- vpx_highbd_obmc_variance32x32_sse4_1, 8),
- TestFuncs(vpx_highbd_obmc_variance32x16_c,
- vpx_highbd_obmc_variance32x16_sse4_1, 8),
- TestFuncs(vpx_highbd_obmc_variance16x32_c,
- vpx_highbd_obmc_variance16x32_sse4_1, 8),
- TestFuncs(vpx_highbd_obmc_variance16x16_c,
- vpx_highbd_obmc_variance16x16_sse4_1, 8),
- TestFuncs(vpx_highbd_obmc_variance16x8_c, vpx_highbd_obmc_variance16x8_sse4_1,
+ TestFuncs(aom_highbd_obmc_variance64x64_c,
+ aom_highbd_obmc_variance64x64_sse4_1, 8),
+ TestFuncs(aom_highbd_obmc_variance64x32_c,
+ aom_highbd_obmc_variance64x32_sse4_1, 8),
+ TestFuncs(aom_highbd_obmc_variance32x64_c,
+ aom_highbd_obmc_variance32x64_sse4_1, 8),
+ TestFuncs(aom_highbd_obmc_variance32x32_c,
+ aom_highbd_obmc_variance32x32_sse4_1, 8),
+ TestFuncs(aom_highbd_obmc_variance32x16_c,
+ aom_highbd_obmc_variance32x16_sse4_1, 8),
+ TestFuncs(aom_highbd_obmc_variance16x32_c,
+ aom_highbd_obmc_variance16x32_sse4_1, 8),
+ TestFuncs(aom_highbd_obmc_variance16x16_c,
+ aom_highbd_obmc_variance16x16_sse4_1, 8),
+ TestFuncs(aom_highbd_obmc_variance16x8_c, aom_highbd_obmc_variance16x8_sse4_1,
8),
- TestFuncs(vpx_highbd_obmc_variance8x16_c, vpx_highbd_obmc_variance8x16_sse4_1,
+ TestFuncs(aom_highbd_obmc_variance8x16_c, aom_highbd_obmc_variance8x16_sse4_1,
8),
- TestFuncs(vpx_highbd_obmc_variance8x8_c, vpx_highbd_obmc_variance8x8_sse4_1,
+ TestFuncs(aom_highbd_obmc_variance8x8_c, aom_highbd_obmc_variance8x8_sse4_1,
8),
- TestFuncs(vpx_highbd_obmc_variance8x4_c, vpx_highbd_obmc_variance8x4_sse4_1,
+ TestFuncs(aom_highbd_obmc_variance8x4_c, aom_highbd_obmc_variance8x4_sse4_1,
8),
- TestFuncs(vpx_highbd_obmc_variance4x8_c, vpx_highbd_obmc_variance4x8_sse4_1,
+ TestFuncs(aom_highbd_obmc_variance4x8_c, aom_highbd_obmc_variance4x8_sse4_1,
8),
- TestFuncs(vpx_highbd_obmc_variance4x4_c, vpx_highbd_obmc_variance4x4_sse4_1,
+ TestFuncs(aom_highbd_obmc_variance4x4_c, aom_highbd_obmc_variance4x4_sse4_1,
8),
#if CONFIG_EXT_PARTITION
- TestFuncs(vpx_highbd_10_obmc_variance128x128_c,
- vpx_highbd_10_obmc_variance128x128_sse4_1, 10),
- TestFuncs(vpx_highbd_10_obmc_variance128x64_c,
- vpx_highbd_10_obmc_variance128x64_sse4_1, 10),
- TestFuncs(vpx_highbd_10_obmc_variance64x128_c,
- vpx_highbd_10_obmc_variance64x128_sse4_1, 10),
+ TestFuncs(aom_highbd_10_obmc_variance128x128_c,
+ aom_highbd_10_obmc_variance128x128_sse4_1, 10),
+ TestFuncs(aom_highbd_10_obmc_variance128x64_c,
+ aom_highbd_10_obmc_variance128x64_sse4_1, 10),
+ TestFuncs(aom_highbd_10_obmc_variance64x128_c,
+ aom_highbd_10_obmc_variance64x128_sse4_1, 10),
#endif // CONFIG_EXT_PARTITION
- TestFuncs(vpx_highbd_10_obmc_variance64x64_c,
- vpx_highbd_10_obmc_variance64x64_sse4_1, 10),
- TestFuncs(vpx_highbd_10_obmc_variance64x32_c,
- vpx_highbd_10_obmc_variance64x32_sse4_1, 10),
- TestFuncs(vpx_highbd_10_obmc_variance32x64_c,
- vpx_highbd_10_obmc_variance32x64_sse4_1, 10),
- TestFuncs(vpx_highbd_10_obmc_variance32x32_c,
- vpx_highbd_10_obmc_variance32x32_sse4_1, 10),
- TestFuncs(vpx_highbd_10_obmc_variance32x16_c,
- vpx_highbd_10_obmc_variance32x16_sse4_1, 10),
- TestFuncs(vpx_highbd_10_obmc_variance16x32_c,
- vpx_highbd_10_obmc_variance16x32_sse4_1, 10),
- TestFuncs(vpx_highbd_10_obmc_variance16x16_c,
- vpx_highbd_10_obmc_variance16x16_sse4_1, 10),
- TestFuncs(vpx_highbd_10_obmc_variance16x8_c,
- vpx_highbd_10_obmc_variance16x8_sse4_1, 10),
- TestFuncs(vpx_highbd_10_obmc_variance8x16_c,
- vpx_highbd_10_obmc_variance8x16_sse4_1, 10),
- TestFuncs(vpx_highbd_10_obmc_variance8x8_c,
- vpx_highbd_10_obmc_variance8x8_sse4_1, 10),
- TestFuncs(vpx_highbd_10_obmc_variance8x4_c,
- vpx_highbd_10_obmc_variance8x4_sse4_1, 10),
- TestFuncs(vpx_highbd_10_obmc_variance4x8_c,
- vpx_highbd_10_obmc_variance4x8_sse4_1, 10),
- TestFuncs(vpx_highbd_10_obmc_variance4x4_c,
- vpx_highbd_10_obmc_variance4x4_sse4_1, 10),
+ TestFuncs(aom_highbd_10_obmc_variance64x64_c,
+ aom_highbd_10_obmc_variance64x64_sse4_1, 10),
+ TestFuncs(aom_highbd_10_obmc_variance64x32_c,
+ aom_highbd_10_obmc_variance64x32_sse4_1, 10),
+ TestFuncs(aom_highbd_10_obmc_variance32x64_c,
+ aom_highbd_10_obmc_variance32x64_sse4_1, 10),
+ TestFuncs(aom_highbd_10_obmc_variance32x32_c,
+ aom_highbd_10_obmc_variance32x32_sse4_1, 10),
+ TestFuncs(aom_highbd_10_obmc_variance32x16_c,
+ aom_highbd_10_obmc_variance32x16_sse4_1, 10),
+ TestFuncs(aom_highbd_10_obmc_variance16x32_c,
+ aom_highbd_10_obmc_variance16x32_sse4_1, 10),
+ TestFuncs(aom_highbd_10_obmc_variance16x16_c,
+ aom_highbd_10_obmc_variance16x16_sse4_1, 10),
+ TestFuncs(aom_highbd_10_obmc_variance16x8_c,
+ aom_highbd_10_obmc_variance16x8_sse4_1, 10),
+ TestFuncs(aom_highbd_10_obmc_variance8x16_c,
+ aom_highbd_10_obmc_variance8x16_sse4_1, 10),
+ TestFuncs(aom_highbd_10_obmc_variance8x8_c,
+ aom_highbd_10_obmc_variance8x8_sse4_1, 10),
+ TestFuncs(aom_highbd_10_obmc_variance8x4_c,
+ aom_highbd_10_obmc_variance8x4_sse4_1, 10),
+ TestFuncs(aom_highbd_10_obmc_variance4x8_c,
+ aom_highbd_10_obmc_variance4x8_sse4_1, 10),
+ TestFuncs(aom_highbd_10_obmc_variance4x4_c,
+ aom_highbd_10_obmc_variance4x4_sse4_1, 10),
#if CONFIG_EXT_PARTITION
- TestFuncs(vpx_highbd_12_obmc_variance128x128_c,
- vpx_highbd_12_obmc_variance128x128_sse4_1, 12),
- TestFuncs(vpx_highbd_12_obmc_variance128x64_c,
- vpx_highbd_12_obmc_variance128x64_sse4_1, 12),
- TestFuncs(vpx_highbd_12_obmc_variance64x128_c,
- vpx_highbd_12_obmc_variance64x128_sse4_1, 12),
+ TestFuncs(aom_highbd_12_obmc_variance128x128_c,
+ aom_highbd_12_obmc_variance128x128_sse4_1, 12),
+ TestFuncs(aom_highbd_12_obmc_variance128x64_c,
+ aom_highbd_12_obmc_variance128x64_sse4_1, 12),
+ TestFuncs(aom_highbd_12_obmc_variance64x128_c,
+ aom_highbd_12_obmc_variance64x128_sse4_1, 12),
#endif // CONFIG_EXT_PARTITION
- TestFuncs(vpx_highbd_12_obmc_variance64x64_c,
- vpx_highbd_12_obmc_variance64x64_sse4_1, 12),
- TestFuncs(vpx_highbd_12_obmc_variance64x32_c,
- vpx_highbd_12_obmc_variance64x32_sse4_1, 12),
- TestFuncs(vpx_highbd_12_obmc_variance32x64_c,
- vpx_highbd_12_obmc_variance32x64_sse4_1, 12),
- TestFuncs(vpx_highbd_12_obmc_variance32x32_c,
- vpx_highbd_12_obmc_variance32x32_sse4_1, 12),
- TestFuncs(vpx_highbd_12_obmc_variance32x16_c,
- vpx_highbd_12_obmc_variance32x16_sse4_1, 12),
- TestFuncs(vpx_highbd_12_obmc_variance16x32_c,
- vpx_highbd_12_obmc_variance16x32_sse4_1, 12),
- TestFuncs(vpx_highbd_12_obmc_variance16x16_c,
- vpx_highbd_12_obmc_variance16x16_sse4_1, 12),
- TestFuncs(vpx_highbd_12_obmc_variance16x8_c,
- vpx_highbd_12_obmc_variance16x8_sse4_1, 12),
- TestFuncs(vpx_highbd_12_obmc_variance8x16_c,
- vpx_highbd_12_obmc_variance8x16_sse4_1, 12),
- TestFuncs(vpx_highbd_12_obmc_variance8x8_c,
- vpx_highbd_12_obmc_variance8x8_sse4_1, 12),
- TestFuncs(vpx_highbd_12_obmc_variance8x4_c,
- vpx_highbd_12_obmc_variance8x4_sse4_1, 12),
- TestFuncs(vpx_highbd_12_obmc_variance4x8_c,
- vpx_highbd_12_obmc_variance4x8_sse4_1, 12),
- TestFuncs(vpx_highbd_12_obmc_variance4x4_c,
- vpx_highbd_12_obmc_variance4x4_sse4_1, 12)
+ TestFuncs(aom_highbd_12_obmc_variance64x64_c,
+ aom_highbd_12_obmc_variance64x64_sse4_1, 12),
+ TestFuncs(aom_highbd_12_obmc_variance64x32_c,
+ aom_highbd_12_obmc_variance64x32_sse4_1, 12),
+ TestFuncs(aom_highbd_12_obmc_variance32x64_c,
+ aom_highbd_12_obmc_variance32x64_sse4_1, 12),
+ TestFuncs(aom_highbd_12_obmc_variance32x32_c,
+ aom_highbd_12_obmc_variance32x32_sse4_1, 12),
+ TestFuncs(aom_highbd_12_obmc_variance32x16_c,
+ aom_highbd_12_obmc_variance32x16_sse4_1, 12),
+ TestFuncs(aom_highbd_12_obmc_variance16x32_c,
+ aom_highbd_12_obmc_variance16x32_sse4_1, 12),
+ TestFuncs(aom_highbd_12_obmc_variance16x16_c,
+ aom_highbd_12_obmc_variance16x16_sse4_1, 12),
+ TestFuncs(aom_highbd_12_obmc_variance16x8_c,
+ aom_highbd_12_obmc_variance16x8_sse4_1, 12),
+ TestFuncs(aom_highbd_12_obmc_variance8x16_c,
+ aom_highbd_12_obmc_variance8x16_sse4_1, 12),
+ TestFuncs(aom_highbd_12_obmc_variance8x8_c,
+ aom_highbd_12_obmc_variance8x8_sse4_1, 12),
+ TestFuncs(aom_highbd_12_obmc_variance8x4_c,
+ aom_highbd_12_obmc_variance8x4_sse4_1, 12),
+ TestFuncs(aom_highbd_12_obmc_variance4x8_c,
+ aom_highbd_12_obmc_variance4x8_sse4_1, 12),
+ TestFuncs(aom_highbd_12_obmc_variance4x4_c,
+ aom_highbd_12_obmc_variance4x4_sse4_1, 12)
};
INSTANTIATE_TEST_CASE_P(SSE4_1_C_COMPARE, ObmcVarianceHBDTest,
::testing::ValuesIn(sse4_functions_hbd));
#endif // HAVE_SSE4_1
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#endif // CONFIG_AOM_HIGHBITDEPTH
} // namespace
diff --git a/test/partial_idct_test.cc b/test/partial_idct_test.cc
index 8d3bd72..f6c8300 100644
--- a/test/partial_idct_test.cc
+++ b/test/partial_idct_test.cc
@@ -14,15 +14,15 @@
#include "third_party/googletest/src/include/gtest/gtest.h"
-#include "./vp10_rtcd.h"
-#include "./vpx_dsp_rtcd.h"
+#include "./av1_rtcd.h"
+#include "./aom_dsp_rtcd.h"
#include "test/acm_random.h"
#include "test/clear_system_state.h"
#include "test/register_state_check.h"
#include "test/util.h"
#include "av1/common/blockd.h"
#include "av1/common/scan.h"
-#include "aom/vpx_integer.h"
+#include "aom/aom_integer.h"
using libaom_test::ACMRandom;
@@ -101,7 +101,7 @@
// quantization with maximum allowed step sizes
test_coef_block1[0] = (output_ref_block[0] / 1336) * 1336;
for (int j = 1; j < last_nonzero_; ++j)
- test_coef_block1[vp10_default_scan_orders[tx_size_].scan[j]] =
+ test_coef_block1[av1_default_scan_orders[tx_size_].scan[j]] =
(output_ref_block[j] / 1828) * 1828;
}
@@ -152,7 +152,7 @@
max_energy_leftover = 0;
coef = 0;
}
- test_coef_block1[vp10_default_scan_orders[tx_size_].scan[j]] = coef;
+ test_coef_block1[av1_default_scan_orders[tx_size_].scan[j]] = coef;
}
memcpy(test_coef_block2, test_coef_block1,
@@ -175,82 +175,82 @@
INSTANTIATE_TEST_CASE_P(
C, PartialIDctTest,
- ::testing::Values(make_tuple(&vpx_fdct32x32_c, &vpx_idct32x32_1024_add_c,
- &vpx_idct32x32_34_add_c, TX_32X32, 34),
- make_tuple(&vpx_fdct32x32_c, &vpx_idct32x32_1024_add_c,
- &vpx_idct32x32_1_add_c, TX_32X32, 1),
- make_tuple(&vpx_fdct16x16_c, &vpx_idct16x16_256_add_c,
- &vpx_idct16x16_10_add_c, TX_16X16, 10),
- make_tuple(&vpx_fdct16x16_c, &vpx_idct16x16_256_add_c,
- &vpx_idct16x16_1_add_c, TX_16X16, 1),
- make_tuple(&vpx_fdct8x8_c, &vpx_idct8x8_64_add_c,
- &vpx_idct8x8_12_add_c, TX_8X8, 12),
- make_tuple(&vpx_fdct8x8_c, &vpx_idct8x8_64_add_c,
- &vpx_idct8x8_1_add_c, TX_8X8, 1),
- make_tuple(&vpx_fdct4x4_c, &vpx_idct4x4_16_add_c,
- &vpx_idct4x4_1_add_c, TX_4X4, 1)));
+ ::testing::Values(make_tuple(&aom_fdct32x32_c, &aom_idct32x32_1024_add_c,
+ &aom_idct32x32_34_add_c, TX_32X32, 34),
+ make_tuple(&aom_fdct32x32_c, &aom_idct32x32_1024_add_c,
+ &aom_idct32x32_1_add_c, TX_32X32, 1),
+ make_tuple(&aom_fdct16x16_c, &aom_idct16x16_256_add_c,
+ &aom_idct16x16_10_add_c, TX_16X16, 10),
+ make_tuple(&aom_fdct16x16_c, &aom_idct16x16_256_add_c,
+ &aom_idct16x16_1_add_c, TX_16X16, 1),
+ make_tuple(&aom_fdct8x8_c, &aom_idct8x8_64_add_c,
+ &aom_idct8x8_12_add_c, TX_8X8, 12),
+ make_tuple(&aom_fdct8x8_c, &aom_idct8x8_64_add_c,
+ &aom_idct8x8_1_add_c, TX_8X8, 1),
+ make_tuple(&aom_fdct4x4_c, &aom_idct4x4_16_add_c,
+ &aom_idct4x4_1_add_c, TX_4X4, 1)));
-#if HAVE_NEON && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
+#if HAVE_NEON && !CONFIG_AOM_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
INSTANTIATE_TEST_CASE_P(
NEON, PartialIDctTest,
- ::testing::Values(make_tuple(&vpx_fdct32x32_c, &vpx_idct32x32_1024_add_c,
- &vpx_idct32x32_1_add_neon, TX_32X32, 1),
- make_tuple(&vpx_fdct16x16_c, &vpx_idct16x16_256_add_c,
- &vpx_idct16x16_10_add_neon, TX_16X16, 10),
- make_tuple(&vpx_fdct16x16_c, &vpx_idct16x16_256_add_c,
- &vpx_idct16x16_1_add_neon, TX_16X16, 1),
- make_tuple(&vpx_fdct8x8_c, &vpx_idct8x8_64_add_c,
- &vpx_idct8x8_12_add_neon, TX_8X8, 12),
- make_tuple(&vpx_fdct8x8_c, &vpx_idct8x8_64_add_c,
- &vpx_idct8x8_1_add_neon, TX_8X8, 1),
- make_tuple(&vpx_fdct4x4_c, &vpx_idct4x4_16_add_c,
- &vpx_idct4x4_1_add_neon, TX_4X4, 1)));
-#endif // HAVE_NEON && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
+ ::testing::Values(make_tuple(&aom_fdct32x32_c, &aom_idct32x32_1024_add_c,
+ &aom_idct32x32_1_add_neon, TX_32X32, 1),
+ make_tuple(&aom_fdct16x16_c, &aom_idct16x16_256_add_c,
+ &aom_idct16x16_10_add_neon, TX_16X16, 10),
+ make_tuple(&aom_fdct16x16_c, &aom_idct16x16_256_add_c,
+ &aom_idct16x16_1_add_neon, TX_16X16, 1),
+ make_tuple(&aom_fdct8x8_c, &aom_idct8x8_64_add_c,
+ &aom_idct8x8_12_add_neon, TX_8X8, 12),
+ make_tuple(&aom_fdct8x8_c, &aom_idct8x8_64_add_c,
+ &aom_idct8x8_1_add_neon, TX_8X8, 1),
+ make_tuple(&aom_fdct4x4_c, &aom_idct4x4_16_add_c,
+ &aom_idct4x4_1_add_neon, TX_4X4, 1)));
+#endif // HAVE_NEON && !CONFIG_AOM_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
-#if HAVE_SSE2 && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
+#if HAVE_SSE2 && !CONFIG_AOM_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
INSTANTIATE_TEST_CASE_P(
SSE2, PartialIDctTest,
- ::testing::Values(make_tuple(&vpx_fdct32x32_c, &vpx_idct32x32_1024_add_c,
- &vpx_idct32x32_34_add_sse2, TX_32X32, 34),
- make_tuple(&vpx_fdct32x32_c, &vpx_idct32x32_1024_add_c,
- &vpx_idct32x32_1_add_sse2, TX_32X32, 1),
- make_tuple(&vpx_fdct16x16_c, &vpx_idct16x16_256_add_c,
- &vpx_idct16x16_10_add_sse2, TX_16X16, 10),
- make_tuple(&vpx_fdct16x16_c, &vpx_idct16x16_256_add_c,
- &vpx_idct16x16_1_add_sse2, TX_16X16, 1),
- make_tuple(&vpx_fdct8x8_c, &vpx_idct8x8_64_add_c,
- &vpx_idct8x8_12_add_sse2, TX_8X8, 12),
- make_tuple(&vpx_fdct8x8_c, &vpx_idct8x8_64_add_c,
- &vpx_idct8x8_1_add_sse2, TX_8X8, 1),
- make_tuple(&vpx_fdct4x4_c, &vpx_idct4x4_16_add_c,
- &vpx_idct4x4_1_add_sse2, TX_4X4, 1)));
+ ::testing::Values(make_tuple(&aom_fdct32x32_c, &aom_idct32x32_1024_add_c,
+ &aom_idct32x32_34_add_sse2, TX_32X32, 34),
+ make_tuple(&aom_fdct32x32_c, &aom_idct32x32_1024_add_c,
+ &aom_idct32x32_1_add_sse2, TX_32X32, 1),
+ make_tuple(&aom_fdct16x16_c, &aom_idct16x16_256_add_c,
+ &aom_idct16x16_10_add_sse2, TX_16X16, 10),
+ make_tuple(&aom_fdct16x16_c, &aom_idct16x16_256_add_c,
+ &aom_idct16x16_1_add_sse2, TX_16X16, 1),
+ make_tuple(&aom_fdct8x8_c, &aom_idct8x8_64_add_c,
+ &aom_idct8x8_12_add_sse2, TX_8X8, 12),
+ make_tuple(&aom_fdct8x8_c, &aom_idct8x8_64_add_c,
+ &aom_idct8x8_1_add_sse2, TX_8X8, 1),
+ make_tuple(&aom_fdct4x4_c, &aom_idct4x4_16_add_c,
+ &aom_idct4x4_1_add_sse2, TX_4X4, 1)));
#endif
-#if HAVE_SSSE3 && ARCH_X86_64 && !CONFIG_VP9_HIGHBITDEPTH && \
+#if HAVE_SSSE3 && ARCH_X86_64 && !CONFIG_AOM_HIGHBITDEPTH && \
!CONFIG_EMULATE_HARDWARE
INSTANTIATE_TEST_CASE_P(
SSSE3_64, PartialIDctTest,
- ::testing::Values(make_tuple(&vpx_fdct8x8_c, &vpx_idct8x8_64_add_c,
- &vpx_idct8x8_12_add_ssse3, TX_8X8, 12)));
+ ::testing::Values(make_tuple(&aom_fdct8x8_c, &aom_idct8x8_64_add_c,
+ &aom_idct8x8_12_add_ssse3, TX_8X8, 12)));
#endif
-#if HAVE_MSA && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
+#if HAVE_MSA && !CONFIG_AOM_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
INSTANTIATE_TEST_CASE_P(
MSA, PartialIDctTest,
- ::testing::Values(make_tuple(&vpx_fdct32x32_c, &vpx_idct32x32_1024_add_c,
- &vpx_idct32x32_34_add_msa, TX_32X32, 34),
- make_tuple(&vpx_fdct32x32_c, &vpx_idct32x32_1024_add_c,
- &vpx_idct32x32_1_add_msa, TX_32X32, 1),
- make_tuple(&vpx_fdct16x16_c, &vpx_idct16x16_256_add_c,
- &vpx_idct16x16_10_add_msa, TX_16X16, 10),
- make_tuple(&vpx_fdct16x16_c, &vpx_idct16x16_256_add_c,
- &vpx_idct16x16_1_add_msa, TX_16X16, 1),
- make_tuple(&vpx_fdct8x8_c, &vpx_idct8x8_64_add_c,
- &vpx_idct8x8_12_add_msa, TX_8X8, 10),
- make_tuple(&vpx_fdct8x8_c, &vpx_idct8x8_64_add_c,
- &vpx_idct8x8_1_add_msa, TX_8X8, 1),
- make_tuple(&vpx_fdct4x4_c, &vpx_idct4x4_16_add_c,
- &vpx_idct4x4_1_add_msa, TX_4X4, 1)));
-#endif // HAVE_MSA && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
+ ::testing::Values(make_tuple(&aom_fdct32x32_c, &aom_idct32x32_1024_add_c,
+ &aom_idct32x32_34_add_msa, TX_32X32, 34),
+ make_tuple(&aom_fdct32x32_c, &aom_idct32x32_1024_add_c,
+ &aom_idct32x32_1_add_msa, TX_32X32, 1),
+ make_tuple(&aom_fdct16x16_c, &aom_idct16x16_256_add_c,
+ &aom_idct16x16_10_add_msa, TX_16X16, 10),
+ make_tuple(&aom_fdct16x16_c, &aom_idct16x16_256_add_c,
+ &aom_idct16x16_1_add_msa, TX_16X16, 1),
+ make_tuple(&aom_fdct8x8_c, &aom_idct8x8_64_add_c,
+ &aom_idct8x8_12_add_msa, TX_8X8, 10),
+ make_tuple(&aom_fdct8x8_c, &aom_idct8x8_64_add_c,
+ &aom_idct8x8_1_add_msa, TX_8X8, 1),
+ make_tuple(&aom_fdct4x4_c, &aom_idct4x4_16_add_c,
+ &aom_idct4x4_1_add_msa, TX_4X4, 1)));
+#endif // HAVE_MSA && !CONFIG_AOM_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
} // namespace
diff --git a/test/quantize_test.cc b/test/quantize_test.cc
index bfebdc5..f58d862 100644
--- a/test/quantize_test.cc
+++ b/test/quantize_test.cc
@@ -12,7 +12,7 @@
#include "third_party/googletest/src/include/gtest/gtest.h"
-#include "./vpx_config.h"
+#include "./aom_config.h"
#include "test/acm_random.h"
#include "test/clear_system_state.h"
#include "test/register_state_check.h"
@@ -22,8 +22,8 @@
#include "vp8/encoder/block.h"
#include "vp8/encoder/onyx_int.h"
#include "vp8/encoder/quantize.h"
-#include "aom/vpx_integer.h"
-#include "aom_mem/vpx_mem.h"
+#include "aom/aom_integer.h"
+#include "aom_mem/aom_mem.h"
namespace {
#if !CONFIG_AOM_QM
@@ -45,7 +45,7 @@
virtual ~QuantizeTestBase() {
vp8_remove_compressor(&vp8_comp_);
vp8_comp_ = NULL;
- vpx_free(macroblockd_dst_);
+ aom_free(macroblockd_dst_);
macroblockd_dst_ = NULL;
libaom_test::ClearSystemState();
}
@@ -68,7 +68,7 @@
// Copy macroblockd from the reference to get pre-set-up dequant values.
macroblockd_dst_ = reinterpret_cast<MACROBLOCKD *>(
- vpx_memalign(32, sizeof(*macroblockd_dst_)));
+ aom_memalign(32, sizeof(*macroblockd_dst_)));
memcpy(macroblockd_dst_, &vp8_comp_->mb.e_mbd, sizeof(*macroblockd_dst_));
// Fix block pointers - currently they point to the blocks in the reference
// structure.
diff --git a/test/realtime_test.cc b/test/realtime_test.cc
index d48f7fb..0c99291 100644
--- a/test/realtime_test.cc
+++ b/test/realtime_test.cc
@@ -35,12 +35,12 @@
virtual void BeginPassHook(unsigned int /*pass*/) {
// TODO(tomfinegan): We're changing the pass value here to make sure
// we get frames when real time mode is combined with |g_pass| set to
- // VPX_RC_FIRST_PASS. This is necessary because EncoderTest::RunLoop() sets
+ // AOM_RC_FIRST_PASS. This is necessary because EncoderTest::RunLoop() sets
// the pass value based on the mode passed into EncoderTest::SetMode(),
// which overrides the one specified in SetUp() above.
- cfg_.g_pass = VPX_RC_FIRST_PASS;
+ cfg_.g_pass = AOM_RC_FIRST_PASS;
}
- virtual void FramePktHook(const vpx_codec_cx_pkt_t * /*pkt*/) {
+ virtual void FramePktHook(const aom_codec_cx_pkt_t * /*pkt*/) {
frame_packets_++;
}
@@ -55,9 +55,7 @@
EXPECT_EQ(kFramesToEncode, frame_packets_);
}
-VP8_INSTANTIATE_TEST_CASE(RealtimeTest,
- ::testing::Values(::libaom_test::kRealTime));
-VP9_INSTANTIATE_TEST_CASE(RealtimeTest,
+AV1_INSTANTIATE_TEST_CASE(RealtimeTest,
::testing::Values(::libaom_test::kRealTime));
} // namespace
diff --git a/test/reconintra_predictors_test.cc b/test/reconintra_predictors_test.cc
index cddf3c1..a86a6a5 100644
--- a/test/reconintra_predictors_test.cc
+++ b/test/reconintra_predictors_test.cc
@@ -10,7 +10,7 @@
#include "third_party/googletest/src/include/gtest/gtest.h"
-#include "./vp10_rtcd.h"
+#include "./av1_rtcd.h"
#include "test/acm_random.h"
#include "test/clear_system_state.h"
#include "test/register_state_check.h"
@@ -32,7 +32,7 @@
typedef tuple<Predictor, Predictor, int> PredFuncMode;
typedef tuple<PredFuncMode, int> PredParams;
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
typedef void (*HbdPredictor)(uint16_t *dst, ptrdiff_t stride, int bs,
const uint16_t *above, const uint16_t *left,
int bd);
@@ -57,9 +57,9 @@
const int MaxTestNum = 100;
#endif
-class VP10IntraPredOptimzTest : public ::testing::TestWithParam<PredParams> {
+class AV1IntraPredOptimzTest : public ::testing::TestWithParam<PredParams> {
public:
- virtual ~VP10IntraPredOptimzTest() {}
+ virtual ~AV1IntraPredOptimzTest() {}
virtual void SetUp() {
PredFuncMode funcMode = GET_PARAM(0);
predFuncRef_ = std::tr1::get<0>(funcMode);
@@ -148,11 +148,11 @@
uint8_t *predRef_;
};
-#if CONFIG_VP9_HIGHBITDEPTH
-class VP10HbdIntraPredOptimzTest
+#if CONFIG_AOM_HIGHBITDEPTH
+class AV1HbdIntraPredOptimzTest
: public ::testing::TestWithParam<HbdPredParams> {
public:
- virtual ~VP10HbdIntraPredOptimzTest() {}
+ virtual ~AV1HbdIntraPredOptimzTest() {}
virtual void SetUp() {
HbdPredFuncMode funcMode = GET_PARAM(0);
predFuncRef_ = std::tr1::get<0>(funcMode);
@@ -243,87 +243,87 @@
uint16_t *pred_;
uint16_t *predRef_;
};
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#endif // CONFIG_AOM_HIGHBITDEPTH
-TEST_P(VP10IntraPredOptimzTest, BitExactCheck) { RunTest(); }
+TEST_P(AV1IntraPredOptimzTest, BitExactCheck) { RunTest(); }
#if PREDICTORS_SPEED_TEST
-TEST_P(VP10IntraPredOptimzTest, SpeedCheckC) { RunSpeedTestC(); }
+TEST_P(AV1IntraPredOptimzTest, SpeedCheckC) { RunSpeedTestC(); }
-TEST_P(VP10IntraPredOptimzTest, SpeedCheckSSE) { RunSpeedTestSSE(); }
+TEST_P(AV1IntraPredOptimzTest, SpeedCheckSSE) { RunSpeedTestSSE(); }
#endif
-#if CONFIG_VP9_HIGHBITDEPTH
-TEST_P(VP10HbdIntraPredOptimzTest, BitExactCheck) { RunTest(); }
+#if CONFIG_AOM_HIGHBITDEPTH
+TEST_P(AV1HbdIntraPredOptimzTest, BitExactCheck) { RunTest(); }
#if PREDICTORS_SPEED_TEST
-TEST_P(VP10HbdIntraPredOptimzTest, SpeedCheckC) { RunSpeedTestC(); }
+TEST_P(AV1HbdIntraPredOptimzTest, SpeedCheckC) { RunSpeedTestC(); }
-TEST_P(VP10HbdIntraPredOptimzTest, SpeedCheckSSE) { RunSpeedTestSSE(); }
+TEST_P(AV1HbdIntraPredOptimzTest, SpeedCheckSSE) { RunSpeedTestSSE(); }
#endif // PREDICTORS_SPEED_TEST
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#endif // CONFIG_AOM_HIGHBITDEPTH
using std::tr1::make_tuple;
const PredFuncMode kPredFuncMdArray[] = {
- make_tuple(vp10_dc_filter_predictor_c, vp10_dc_filter_predictor_sse4_1,
+ make_tuple(av1_dc_filter_predictor_c, av1_dc_filter_predictor_sse4_1,
DC_PRED),
- make_tuple(vp10_v_filter_predictor_c, vp10_v_filter_predictor_sse4_1, V_PRED),
- make_tuple(vp10_h_filter_predictor_c, vp10_h_filter_predictor_sse4_1, H_PRED),
- make_tuple(vp10_d45_filter_predictor_c, vp10_d45_filter_predictor_sse4_1,
+ make_tuple(av1_v_filter_predictor_c, av1_v_filter_predictor_sse4_1, V_PRED),
+ make_tuple(av1_h_filter_predictor_c, av1_h_filter_predictor_sse4_1, H_PRED),
+ make_tuple(av1_d45_filter_predictor_c, av1_d45_filter_predictor_sse4_1,
D45_PRED),
- make_tuple(vp10_d135_filter_predictor_c, vp10_d135_filter_predictor_sse4_1,
+ make_tuple(av1_d135_filter_predictor_c, av1_d135_filter_predictor_sse4_1,
D135_PRED),
- make_tuple(vp10_d117_filter_predictor_c, vp10_d117_filter_predictor_sse4_1,
+ make_tuple(av1_d117_filter_predictor_c, av1_d117_filter_predictor_sse4_1,
D117_PRED),
- make_tuple(vp10_d153_filter_predictor_c, vp10_d153_filter_predictor_sse4_1,
+ make_tuple(av1_d153_filter_predictor_c, av1_d153_filter_predictor_sse4_1,
D153_PRED),
- make_tuple(vp10_d207_filter_predictor_c, vp10_d207_filter_predictor_sse4_1,
+ make_tuple(av1_d207_filter_predictor_c, av1_d207_filter_predictor_sse4_1,
D207_PRED),
- make_tuple(vp10_d63_filter_predictor_c, vp10_d63_filter_predictor_sse4_1,
+ make_tuple(av1_d63_filter_predictor_c, av1_d63_filter_predictor_sse4_1,
D63_PRED),
- make_tuple(vp10_tm_filter_predictor_c, vp10_tm_filter_predictor_sse4_1,
+ make_tuple(av1_tm_filter_predictor_c, av1_tm_filter_predictor_sse4_1,
TM_PRED),
};
const int kBlkSize[] = { 4, 8, 16, 32 };
INSTANTIATE_TEST_CASE_P(
- SSE4_1, VP10IntraPredOptimzTest,
+ SSE4_1, AV1IntraPredOptimzTest,
::testing::Combine(::testing::ValuesIn(kPredFuncMdArray),
::testing::ValuesIn(kBlkSize)));
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
const HbdPredFuncMode kHbdPredFuncMdArray[] = {
- make_tuple(vp10_highbd_dc_filter_predictor_c,
- vp10_highbd_dc_filter_predictor_sse4_1, DC_PRED),
- make_tuple(vp10_highbd_v_filter_predictor_c,
- vp10_highbd_v_filter_predictor_sse4_1, V_PRED),
- make_tuple(vp10_highbd_h_filter_predictor_c,
- vp10_highbd_h_filter_predictor_sse4_1, H_PRED),
- make_tuple(vp10_highbd_d45_filter_predictor_c,
- vp10_highbd_d45_filter_predictor_sse4_1, D45_PRED),
- make_tuple(vp10_highbd_d135_filter_predictor_c,
- vp10_highbd_d135_filter_predictor_sse4_1, D135_PRED),
- make_tuple(vp10_highbd_d117_filter_predictor_c,
- vp10_highbd_d117_filter_predictor_sse4_1, D117_PRED),
- make_tuple(vp10_highbd_d153_filter_predictor_c,
- vp10_highbd_d153_filter_predictor_sse4_1, D153_PRED),
- make_tuple(vp10_highbd_d207_filter_predictor_c,
- vp10_highbd_d207_filter_predictor_sse4_1, D207_PRED),
- make_tuple(vp10_highbd_d63_filter_predictor_c,
- vp10_highbd_d63_filter_predictor_sse4_1, D63_PRED),
- make_tuple(vp10_highbd_tm_filter_predictor_c,
- vp10_highbd_tm_filter_predictor_sse4_1, TM_PRED),
+ make_tuple(av1_highbd_dc_filter_predictor_c,
+ av1_highbd_dc_filter_predictor_sse4_1, DC_PRED),
+ make_tuple(av1_highbd_v_filter_predictor_c,
+ av1_highbd_v_filter_predictor_sse4_1, V_PRED),
+ make_tuple(av1_highbd_h_filter_predictor_c,
+ av1_highbd_h_filter_predictor_sse4_1, H_PRED),
+ make_tuple(av1_highbd_d45_filter_predictor_c,
+ av1_highbd_d45_filter_predictor_sse4_1, D45_PRED),
+ make_tuple(av1_highbd_d135_filter_predictor_c,
+ av1_highbd_d135_filter_predictor_sse4_1, D135_PRED),
+ make_tuple(av1_highbd_d117_filter_predictor_c,
+ av1_highbd_d117_filter_predictor_sse4_1, D117_PRED),
+ make_tuple(av1_highbd_d153_filter_predictor_c,
+ av1_highbd_d153_filter_predictor_sse4_1, D153_PRED),
+ make_tuple(av1_highbd_d207_filter_predictor_c,
+ av1_highbd_d207_filter_predictor_sse4_1, D207_PRED),
+ make_tuple(av1_highbd_d63_filter_predictor_c,
+ av1_highbd_d63_filter_predictor_sse4_1, D63_PRED),
+ make_tuple(av1_highbd_tm_filter_predictor_c,
+ av1_highbd_tm_filter_predictor_sse4_1, TM_PRED),
};
const int kBd[] = { 10, 12 };
INSTANTIATE_TEST_CASE_P(
- SSE4_1, VP10HbdIntraPredOptimzTest,
+ SSE4_1, AV1HbdIntraPredOptimzTest,
::testing::Combine(::testing::ValuesIn(kHbdPredFuncMdArray),
::testing::ValuesIn(kBlkSize),
::testing::ValuesIn(kBd)));
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#endif // CONFIG_AOM_HIGHBITDEPTH
} // namespace
diff --git a/test/register_state_check.h b/test/register_state_check.h
index 4ec53f4..5c9620d 100644
--- a/test/register_state_check.h
+++ b/test/register_state_check.h
@@ -12,8 +12,8 @@
#define TEST_REGISTER_STATE_CHECK_H_
#include "third_party/googletest/src/include/gtest/gtest.h"
-#include "./vpx_config.h"
-#include "aom/vpx_integer.h"
+#include "./aom_config.h"
+#include "aom/aom_integer.h"
// ASM_REGISTER_STATE_CHECK(asm_function)
// Minimally validates the environment pre & post function execution. This
@@ -88,12 +88,12 @@
} // namespace libaom_test
-#elif defined(CONFIG_SHARED) && defined(HAVE_NEON_ASM) && \
- defined(CONFIG_VP10) && !CONFIG_SHARED && HAVE_NEON_ASM && CONFIG_VP10
+#elif defined(CONFIG_SHARED) && defined(HAVE_NEON_ASM) && !CONFIG_SHARED && \
+ HAVE_NEON_ASM && CONFIG_AV1
extern "C" {
// Save the d8-d15 registers into store.
-void vpx_push_neon(int64_t *store);
+void aom_push_neon(int64_t *store);
}
namespace libaom_test {
@@ -108,7 +108,7 @@
private:
static bool StoreRegisters(int64_t store[8]) {
- vpx_push_neon(store);
+ aom_push_neon(store);
return true;
}
@@ -116,7 +116,7 @@
bool Check() const {
if (!initialized_) return false;
int64_t post_store[8];
- vpx_push_neon(post_store);
+ aom_push_neon(post_store);
for (int i = 0; i < 8; ++i) {
EXPECT_EQ(pre_store_[i], post_store[i]) << "d" << i + 8
<< " has been modified";
diff --git a/test/resize_test.cc b/test/resize_test.cc
index 9b4808b..35253dc 100644
--- a/test/resize_test.cc
+++ b/test/resize_test.cc
@@ -36,7 +36,7 @@
mem[3] = val >> 24;
}
-static void write_ivf_file_header(const vpx_codec_enc_cfg_t *const cfg,
+static void write_ivf_file_header(const aom_codec_enc_cfg_t *const cfg,
int frame_cnt, FILE *const outfile) {
char header[32];
@@ -46,7 +46,7 @@
header[3] = 'F';
mem_put_le16(header + 4, 0); /* version */
mem_put_le16(header + 6, 32); /* headersize */
- mem_put_le32(header + 8, 0x30395056); /* fourcc (vp9) */
+ mem_put_le32(header + 8, 0x30395056); /* fourcc (av1) */
mem_put_le16(header + 12, cfg->g_w); /* width */
mem_put_le16(header + 14, cfg->g_h); /* height */
mem_put_le32(header + 16, cfg->g_timebase.den); /* rate */
@@ -63,12 +63,12 @@
(void)fwrite(header, 1, 4, outfile);
}
-static void write_ivf_frame_header(const vpx_codec_cx_pkt_t *const pkt,
+static void write_ivf_frame_header(const aom_codec_cx_pkt_t *const pkt,
FILE *const outfile) {
char header[12];
- vpx_codec_pts_t pts;
+ aom_codec_pts_t pts;
- if (pkt->kind != VPX_CODEC_CX_FRAME_PKT) return;
+ if (pkt->kind != AOM_CODEC_CX_FRAME_PKT) return;
pts = pkt->data.frame.pts;
mem_put_le32(header, static_cast<unsigned int>(pkt->data.frame.sz));
@@ -83,10 +83,10 @@
const unsigned int kInitialHeight = 240;
struct FrameInfo {
- FrameInfo(vpx_codec_pts_t _pts, unsigned int _w, unsigned int _h)
+ FrameInfo(aom_codec_pts_t _pts, unsigned int _w, unsigned int _h)
: pts(_pts), w(_w), h(_h) {}
- vpx_codec_pts_t pts;
+ aom_codec_pts_t pts;
unsigned int w;
unsigned int h;
};
@@ -231,8 +231,8 @@
return;
}
if (flag_codec == 1) {
- // Cases that only works for VP9.
- // For VP9: Swap width and height of original.
+ // Cases that only works for AV1.
+ // For AV1: Swap width and height of original.
if (frame < 320) {
*w = initial_h;
*h = initial_w;
@@ -277,8 +277,8 @@
SetMode(GET_PARAM(1));
}
- virtual void DecompressedFrameHook(const vpx_image_t &img,
- vpx_codec_pts_t pts) {
+ virtual void DecompressedFrameHook(const aom_image_t &img,
+ aom_codec_pts_t pts) {
frame_info_list_.push_back(FrameInfo(pts, img.d_w, img.d_h));
}
@@ -321,7 +321,7 @@
virtual void BeginPassHook(unsigned int /*pass*/) {
#if WRITE_COMPRESSED_STREAM
- outfile_ = fopen("vp90-2-05-resize.ivf", "wb");
+ outfile_ = fopen("av10-2-05-resize.ivf", "wb");
#endif
}
@@ -341,34 +341,34 @@
if (change_config_) {
int new_q = 60;
if (video->frame() == 0) {
- struct vpx_scaling_mode mode = { VP8E_ONETWO, VP8E_ONETWO };
- encoder->Control(VP8E_SET_SCALEMODE, &mode);
+ struct aom_scaling_mode mode = { AOME_ONETWO, AOME_ONETWO };
+ encoder->Control(AOME_SET_SCALEMODE, &mode);
}
if (video->frame() == 1) {
- struct vpx_scaling_mode mode = { VP8E_NORMAL, VP8E_NORMAL };
- encoder->Control(VP8E_SET_SCALEMODE, &mode);
+ struct aom_scaling_mode mode = { AOME_NORMAL, AOME_NORMAL };
+ encoder->Control(AOME_SET_SCALEMODE, &mode);
cfg_.rc_min_quantizer = cfg_.rc_max_quantizer = new_q;
encoder->Config(&cfg_);
}
} else {
if (video->frame() == kStepDownFrame) {
- struct vpx_scaling_mode mode = { VP8E_FOURFIVE, VP8E_THREEFIVE };
- encoder->Control(VP8E_SET_SCALEMODE, &mode);
+ struct aom_scaling_mode mode = { AOME_FOURFIVE, AOME_THREEFIVE };
+ encoder->Control(AOME_SET_SCALEMODE, &mode);
}
if (video->frame() == kStepUpFrame) {
- struct vpx_scaling_mode mode = { VP8E_NORMAL, VP8E_NORMAL };
- encoder->Control(VP8E_SET_SCALEMODE, &mode);
+ struct aom_scaling_mode mode = { AOME_NORMAL, AOME_NORMAL };
+ encoder->Control(AOME_SET_SCALEMODE, &mode);
}
}
}
- virtual void PSNRPktHook(const vpx_codec_cx_pkt_t *pkt) {
+ virtual void PSNRPktHook(const aom_codec_cx_pkt_t *pkt) {
if (frame0_psnr_ == 0.) frame0_psnr_ = pkt->data.psnr.psnr[0];
EXPECT_NEAR(pkt->data.psnr.psnr[0], frame0_psnr_, 2.0);
}
#if WRITE_COMPRESSED_STREAM
- virtual void FramePktHook(const vpx_codec_cx_pkt_t *pkt) {
+ virtual void FramePktHook(const aom_codec_cx_pkt_t *pkt) {
++out_frames_;
// Write initial file header if first frame.
@@ -391,7 +391,7 @@
TEST_P(ResizeInternalTest, TestInternalResizeWorks) {
::libaom_test::I420VideoSource video("hantro_collage_w352h288.yuv", 352, 288,
30, 1, 0, 10);
- init_flags_ = VPX_CODEC_USE_PSNR;
+ init_flags_ = AOM_CODEC_USE_PSNR;
change_config_ = false;
// q picked such that initial keyframe on this clip is ~30dB PSNR
@@ -406,7 +406,7 @@
for (std::vector<FrameInfo>::const_iterator info = frame_info_list_.begin();
info != frame_info_list_.end(); ++info) {
- const vpx_codec_pts_t pts = info->pts;
+ const aom_codec_pts_t pts = info->pts;
if (pts >= kStepDownFrame && pts < kStepUpFrame) {
ASSERT_EQ(282U, info->w) << "Frame " << pts << " had unexpected width";
ASSERT_EQ(173U, info->h) << "Frame " << pts << " had unexpected height";
@@ -436,8 +436,8 @@
virtual void PreEncodeFrameHook(libaom_test::VideoSource *video,
libaom_test::Encoder *encoder) {
if (video->frame() == 0) {
- encoder->Control(VP9E_SET_AQ_MODE, 3);
- encoder->Control(VP8E_SET_CPUUSED, set_cpu_used_);
+ encoder->Control(AV1E_SET_AQ_MODE, 3);
+ encoder->Control(AOME_SET_CPUUSED, set_cpu_used_);
}
if (change_bitrate_ && video->frame() == 120) {
@@ -453,12 +453,12 @@
set_cpu_used_ = GET_PARAM(2);
}
- virtual void DecompressedFrameHook(const vpx_image_t &img,
- vpx_codec_pts_t pts) {
+ virtual void DecompressedFrameHook(const aom_image_t &img,
+ aom_codec_pts_t pts) {
frame_info_list_.push_back(FrameInfo(pts, img.d_w, img.d_h));
}
- virtual void MismatchHook(const vpx_image_t *img1, const vpx_image_t *img2) {
+ virtual void MismatchHook(const aom_image_t *img1, const aom_image_t *img2) {
double mismatch_psnr = compute_psnr(img1, img2);
mismatch_psnr_ += mismatch_psnr;
++mismatch_nframes_;
@@ -474,8 +474,8 @@
cfg_.rc_max_quantizer = 56;
cfg_.rc_undershoot_pct = 50;
cfg_.rc_overshoot_pct = 50;
- cfg_.rc_end_usage = VPX_CBR;
- cfg_.kf_mode = VPX_KF_AUTO;
+ cfg_.rc_end_usage = AOM_CBR;
+ cfg_.kf_mode = AOM_KF_AUTO;
cfg_.g_lag_in_frames = 0;
cfg_.kf_min_dist = cfg_.kf_max_dist = 3000;
// Enable dropped frames.
@@ -550,12 +550,12 @@
}
}
-#if CONFIG_VP9_DECODER
+#if CONFIG_AV1_DECODER
// Verify that we get 1 resize down event in this test.
ASSERT_EQ(1, resize_count) << "Resizing should occur.";
EXPECT_EQ(static_cast<unsigned int>(0), GetMismatchFrames());
#else
- printf("Warning: VP9 decoder unavailable, unable to check resize count!\n");
+ printf("Warning: AV1 decoder unavailable, unable to check resize count!\n");
#endif
}
@@ -598,19 +598,19 @@
}
}
-#if CONFIG_VP9_DECODER
+#if CONFIG_AV1_DECODER
// Verify that we get 2 resize events in this test.
ASSERT_EQ(resize_count, 2) << "Resizing should occur twice.";
EXPECT_EQ(static_cast<unsigned int>(0), GetMismatchFrames());
#else
- printf("Warning: VP9 decoder unavailable, unable to check resize count!\n");
+ printf("Warning: AV1 decoder unavailable, unable to check resize count!\n");
#endif
}
-vpx_img_fmt_t CspForFrameNumber(int frame) {
- if (frame < 10) return VPX_IMG_FMT_I420;
- if (frame < 20) return VPX_IMG_FMT_I444;
- return VPX_IMG_FMT_I420;
+aom_img_fmt_t CspForFrameNumber(int frame) {
+ if (frame < 10) return AOM_IMG_FMT_I420;
+ if (frame < 20) return AOM_IMG_FMT_I444;
+ return AOM_IMG_FMT_I420;
}
class ResizeCspTest : public ResizeTest {
@@ -626,7 +626,7 @@
virtual void BeginPassHook(unsigned int /*pass*/) {
#if WRITE_COMPRESSED_STREAM
- outfile_ = fopen("vp91-2-05-cspchape.ivf", "wb");
+ outfile_ = fopen("av11-2-05-cspchape.ivf", "wb");
#endif
}
@@ -643,25 +643,25 @@
virtual void PreEncodeFrameHook(libaom_test::VideoSource *video,
libaom_test::Encoder *encoder) {
- if (CspForFrameNumber(video->frame()) != VPX_IMG_FMT_I420 &&
+ if (CspForFrameNumber(video->frame()) != AOM_IMG_FMT_I420 &&
cfg_.g_profile != 1) {
cfg_.g_profile = 1;
encoder->Config(&cfg_);
}
- if (CspForFrameNumber(video->frame()) == VPX_IMG_FMT_I420 &&
+ if (CspForFrameNumber(video->frame()) == AOM_IMG_FMT_I420 &&
cfg_.g_profile != 0) {
cfg_.g_profile = 0;
encoder->Config(&cfg_);
}
}
- virtual void PSNRPktHook(const vpx_codec_cx_pkt_t *pkt) {
+ virtual void PSNRPktHook(const aom_codec_cx_pkt_t *pkt) {
if (frame0_psnr_ == 0.) frame0_psnr_ = pkt->data.psnr.psnr[0];
EXPECT_NEAR(pkt->data.psnr.psnr[0], frame0_psnr_, 2.0);
}
#if WRITE_COMPRESSED_STREAM
- virtual void FramePktHook(const vpx_codec_cx_pkt_t *pkt) {
+ virtual void FramePktHook(const aom_codec_cx_pkt_t *pkt) {
++out_frames_;
// Write initial file header if first frame.
@@ -699,19 +699,19 @@
TEST_P(ResizeCspTest, TestResizeCspWorks) {
ResizingCspVideoSource video;
- init_flags_ = VPX_CODEC_USE_PSNR;
+ init_flags_ = AOM_CODEC_USE_PSNR;
cfg_.rc_min_quantizer = cfg_.rc_max_quantizer = 48;
cfg_.g_lag_in_frames = 0;
ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
}
-VP10_INSTANTIATE_TEST_CASE(ResizeTest,
- ::testing::Values(::libaom_test::kRealTime));
-VP10_INSTANTIATE_TEST_CASE(ResizeInternalTest,
- ::testing::Values(::libaom_test::kOnePassBest));
-VP10_INSTANTIATE_TEST_CASE(ResizeRealtimeTest,
- ::testing::Values(::libaom_test::kRealTime),
- ::testing::Range(5, 9));
-VP10_INSTANTIATE_TEST_CASE(ResizeCspTest,
- ::testing::Values(::libaom_test::kRealTime));
+AV1_INSTANTIATE_TEST_CASE(ResizeTest,
+ ::testing::Values(::libaom_test::kRealTime));
+AV1_INSTANTIATE_TEST_CASE(ResizeInternalTest,
+ ::testing::Values(::libaom_test::kOnePassBest));
+AV1_INSTANTIATE_TEST_CASE(ResizeRealtimeTest,
+ ::testing::Values(::libaom_test::kRealTime),
+ ::testing::Range(5, 9));
+AV1_INSTANTIATE_TEST_CASE(ResizeCspTest,
+ ::testing::Values(::libaom_test::kRealTime));
} // namespace
diff --git a/test/resize_util.sh b/test/resize_util.sh
index 0c5851d..e8993e5 100755
--- a/test/resize_util.sh
+++ b/test/resize_util.sh
@@ -18,7 +18,7 @@
# Environment check: $YUV_RAW_INPUT is required.
resize_util_verify_environment() {
if [ ! -e "${YUV_RAW_INPUT}" ]; then
- echo "Libvpx test data must exist in LIBVPX_TEST_DATA_PATH."
+ echo "Libaom test data must exist in LIBVPX_TEST_DATA_PATH."
return 1
fi
}
@@ -26,19 +26,19 @@
# Resizes $YUV_RAW_INPUT using the resize_util example. $1 is the output
# dimensions that will be passed to resize_util.
resize_util() {
- local resizer="${LIBAOM_BIN_PATH}/resize_util${VPX_TEST_EXE_SUFFIX}"
- local output_file="${VPX_TEST_OUTPUT_DIR}/resize_util.raw"
+ local resizer="${LIBAOM_BIN_PATH}/resize_util${AOM_TEST_EXE_SUFFIX}"
+ local output_file="${AOM_TEST_OUTPUT_DIR}/resize_util.raw"
local frames_to_resize="10"
local target_dimensions="$1"
# resize_util is available only when CONFIG_SHARED is disabled.
- if [ -z "$(vpx_config_option_enabled CONFIG_SHARED)" ]; then
+ if [ -z "$(aom_config_option_enabled CONFIG_SHARED)" ]; then
if [ ! -x "${resizer}" ]; then
elog "${resizer} does not exist or is not executable."
return 1
fi
- eval "${VPX_TEST_PREFIX}" "${resizer}" "${YUV_RAW_INPUT}" \
+ eval "${AOM_TEST_PREFIX}" "${resizer}" "${YUV_RAW_INPUT}" \
"${YUV_RAW_INPUT_WIDTH}x${YUV_RAW_INPUT_HEIGHT}" \
"${target_dimensions}" "${output_file}" ${frames_to_resize} \
${devnull}
diff --git a/test/sad_test.cc b/test/sad_test.cc
index 8276cd4..875b40b 100644
--- a/test/sad_test.cc
+++ b/test/sad_test.cc
@@ -14,14 +14,14 @@
#include "third_party/googletest/src/include/gtest/gtest.h"
-#include "./vpx_config.h"
-#include "./vpx_dsp_rtcd.h"
+#include "./aom_config.h"
+#include "./aom_dsp_rtcd.h"
#include "test/acm_random.h"
#include "test/clear_system_state.h"
#include "test/register_state_check.h"
#include "test/util.h"
-#include "aom/vpx_codec.h"
-#include "aom_mem/vpx_mem.h"
+#include "aom/aom_codec.h"
+#include "aom_mem/aom_mem.h"
#include "aom_ports/mem.h"
typedef unsigned int (*SadMxNFunc)(const uint8_t *src_ptr, int src_stride,
@@ -48,31 +48,31 @@
static void SetUpTestCase() {
source_data8_ = reinterpret_cast<uint8_t *>(
- vpx_memalign(kDataAlignment, kDataBlockSize));
+ aom_memalign(kDataAlignment, kDataBlockSize));
reference_data8_ = reinterpret_cast<uint8_t *>(
- vpx_memalign(kDataAlignment, kDataBufferSize));
+ aom_memalign(kDataAlignment, kDataBufferSize));
second_pred8_ =
- reinterpret_cast<uint8_t *>(vpx_memalign(kDataAlignment, 128 * 128));
+ reinterpret_cast<uint8_t *>(aom_memalign(kDataAlignment, 128 * 128));
source_data16_ = reinterpret_cast<uint16_t *>(
- vpx_memalign(kDataAlignment, kDataBlockSize * sizeof(uint16_t)));
+ aom_memalign(kDataAlignment, kDataBlockSize * sizeof(uint16_t)));
reference_data16_ = reinterpret_cast<uint16_t *>(
- vpx_memalign(kDataAlignment, kDataBufferSize * sizeof(uint16_t)));
+ aom_memalign(kDataAlignment, kDataBufferSize * sizeof(uint16_t)));
second_pred16_ = reinterpret_cast<uint16_t *>(
- vpx_memalign(kDataAlignment, 128 * 128 * sizeof(uint16_t)));
+ aom_memalign(kDataAlignment, 128 * 128 * sizeof(uint16_t)));
}
static void TearDownTestCase() {
- vpx_free(source_data8_);
+ aom_free(source_data8_);
source_data8_ = NULL;
- vpx_free(reference_data8_);
+ aom_free(reference_data8_);
reference_data8_ = NULL;
- vpx_free(second_pred8_);
+ aom_free(second_pred8_);
second_pred8_ = NULL;
- vpx_free(source_data16_);
+ aom_free(source_data16_);
source_data16_ = NULL;
- vpx_free(reference_data16_);
+ aom_free(reference_data16_);
reference_data16_ = NULL;
- vpx_free(second_pred16_);
+ aom_free(second_pred16_);
second_pred16_ = NULL;
}
@@ -87,18 +87,18 @@
virtual void SetUp() {
if (bd_ == -1) {
use_high_bit_depth_ = false;
- bit_depth_ = VPX_BITS_8;
+ bit_depth_ = AOM_BITS_8;
source_data_ = source_data8_;
reference_data_ = reference_data8_;
second_pred_ = second_pred8_;
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
} else {
use_high_bit_depth_ = true;
- bit_depth_ = static_cast<vpx_bit_depth_t>(bd_);
+ bit_depth_ = static_cast<aom_bit_depth_t>(bd_);
source_data_ = CONVERT_TO_BYTEPTR(source_data16_);
reference_data_ = CONVERT_TO_BYTEPTR(reference_data16_);
second_pred_ = CONVERT_TO_BYTEPTR(second_pred16_);
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#endif // CONFIG_AOM_HIGHBITDEPTH
}
mask_ = (1 << bit_depth_) - 1;
source_stride_ = (width_ + 31) & ~31;
@@ -107,11 +107,11 @@
}
virtual uint8_t *GetReference(int block_idx) {
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
if (use_high_bit_depth_)
return CONVERT_TO_BYTEPTR(CONVERT_TO_SHORTPTR(reference_data_) +
block_idx * kDataBlockSize);
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#endif // CONFIG_AOM_HIGHBITDEPTH
return reference_data_ + block_idx * kDataBlockSize;
}
@@ -121,21 +121,21 @@
unsigned int sad = 0;
const uint8_t *const reference8 = GetReference(block_idx);
const uint8_t *const source8 = source_data_;
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
const uint16_t *const reference16 =
CONVERT_TO_SHORTPTR(GetReference(block_idx));
const uint16_t *const source16 = CONVERT_TO_SHORTPTR(source_data_);
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#endif // CONFIG_AOM_HIGHBITDEPTH
for (int h = 0; h < height_; ++h) {
for (int w = 0; w < width_; ++w) {
if (!use_high_bit_depth_) {
sad += abs(source8[h * source_stride_ + w] -
reference8[h * reference_stride_ + w]);
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
} else {
sad += abs(source16[h * source_stride_ + w] -
reference16[h * reference_stride_ + w]);
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#endif // CONFIG_AOM_HIGHBITDEPTH
}
}
}
@@ -150,12 +150,12 @@
const uint8_t *const reference8 = GetReference(block_idx);
const uint8_t *const source8 = source_data_;
const uint8_t *const second_pred8 = second_pred_;
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
const uint16_t *const reference16 =
CONVERT_TO_SHORTPTR(GetReference(block_idx));
const uint16_t *const source16 = CONVERT_TO_SHORTPTR(source_data_);
const uint16_t *const second_pred16 = CONVERT_TO_SHORTPTR(second_pred_);
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#endif // CONFIG_AOM_HIGHBITDEPTH
for (int h = 0; h < height_; ++h) {
for (int w = 0; w < width_; ++w) {
if (!use_high_bit_depth_) {
@@ -163,13 +163,13 @@
reference8[h * reference_stride_ + w];
const uint8_t comp_pred = ROUND_POWER_OF_TWO(tmp, 1);
sad += abs(source8[h * source_stride_ + w] - comp_pred);
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
} else {
const int tmp = second_pred16[h * width_ + w] +
reference16[h * reference_stride_ + w];
const uint16_t comp_pred = ROUND_POWER_OF_TWO(tmp, 1);
sad += abs(source16[h * source_stride_ + w] - comp_pred);
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#endif // CONFIG_AOM_HIGHBITDEPTH
}
}
}
@@ -178,17 +178,17 @@
void FillConstant(uint8_t *data, int stride, uint16_t fill_constant) {
uint8_t *data8 = data;
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
uint16_t *data16 = CONVERT_TO_SHORTPTR(data);
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#endif // CONFIG_AOM_HIGHBITDEPTH
for (int h = 0; h < height_; ++h) {
for (int w = 0; w < width_; ++w) {
if (!use_high_bit_depth_) {
data8[h * stride + w] = static_cast<uint8_t>(fill_constant);
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
} else {
data16[h * stride + w] = fill_constant;
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#endif // CONFIG_AOM_HIGHBITDEPTH
}
}
}
@@ -196,24 +196,24 @@
void FillRandom(uint8_t *data, int stride) {
uint8_t *data8 = data;
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
uint16_t *data16 = CONVERT_TO_SHORTPTR(data);
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#endif // CONFIG_AOM_HIGHBITDEPTH
for (int h = 0; h < height_; ++h) {
for (int w = 0; w < width_; ++w) {
if (!use_high_bit_depth_) {
data8[h * stride + w] = rnd_.Rand8();
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
} else {
data16[h * stride + w] = rnd_.Rand16() & mask_;
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#endif // CONFIG_AOM_HIGHBITDEPTH
}
}
}
}
int width_, height_, mask_, bd_;
- vpx_bit_depth_t bit_depth_;
+ aom_bit_depth_t bit_depth_;
static uint8_t *source_data_;
static uint8_t *reference_data_;
static uint8_t *second_pred_;
@@ -472,236 +472,236 @@
//------------------------------------------------------------------------------
// C functions
const SadMxNParam c_tests[] = {
-#if CONFIG_VP10 && CONFIG_EXT_PARTITION
- make_tuple(128, 128, &vpx_sad128x128_c, -1),
- make_tuple(128, 64, &vpx_sad128x64_c, -1),
- make_tuple(64, 128, &vpx_sad64x128_c, -1),
-#endif // CONFIG_VP10 && CONFIG_EXT_PARTITION
- make_tuple(64, 64, &vpx_sad64x64_c, -1),
- make_tuple(64, 32, &vpx_sad64x32_c, -1),
- make_tuple(32, 64, &vpx_sad32x64_c, -1),
- make_tuple(32, 32, &vpx_sad32x32_c, -1),
- make_tuple(32, 16, &vpx_sad32x16_c, -1),
- make_tuple(16, 32, &vpx_sad16x32_c, -1),
- make_tuple(16, 16, &vpx_sad16x16_c, -1),
- make_tuple(16, 8, &vpx_sad16x8_c, -1),
- make_tuple(8, 16, &vpx_sad8x16_c, -1),
- make_tuple(8, 8, &vpx_sad8x8_c, -1),
- make_tuple(8, 4, &vpx_sad8x4_c, -1),
- make_tuple(4, 8, &vpx_sad4x8_c, -1),
- make_tuple(4, 4, &vpx_sad4x4_c, -1),
-#if CONFIG_VP9_HIGHBITDEPTH
-#if CONFIG_VP10 && CONFIG_EXT_PARTITION
- make_tuple(128, 128, &vpx_highbd_sad128x128_c, 8),
- make_tuple(128, 64, &vpx_highbd_sad128x64_c, 8),
- make_tuple(64, 128, &vpx_highbd_sad64x128_c, 8),
-#endif // CONFIG_VP10 && CONFIG_EXT_PARTITION
- make_tuple(64, 64, &vpx_highbd_sad64x64_c, 8),
- make_tuple(64, 32, &vpx_highbd_sad64x32_c, 8),
- make_tuple(32, 64, &vpx_highbd_sad32x64_c, 8),
- make_tuple(32, 32, &vpx_highbd_sad32x32_c, 8),
- make_tuple(32, 16, &vpx_highbd_sad32x16_c, 8),
- make_tuple(16, 32, &vpx_highbd_sad16x32_c, 8),
- make_tuple(16, 16, &vpx_highbd_sad16x16_c, 8),
- make_tuple(16, 8, &vpx_highbd_sad16x8_c, 8),
- make_tuple(8, 16, &vpx_highbd_sad8x16_c, 8),
- make_tuple(8, 8, &vpx_highbd_sad8x8_c, 8),
- make_tuple(8, 4, &vpx_highbd_sad8x4_c, 8),
- make_tuple(4, 8, &vpx_highbd_sad4x8_c, 8),
- make_tuple(4, 4, &vpx_highbd_sad4x4_c, 8),
-#if CONFIG_VP10 && CONFIG_EXT_PARTITION
- make_tuple(128, 128, &vpx_highbd_sad128x128_c, 10),
- make_tuple(128, 64, &vpx_highbd_sad128x64_c, 10),
- make_tuple(64, 128, &vpx_highbd_sad64x128_c, 10),
-#endif // CONFIG_VP10 && CONFIG_EXT_PARTITION
- make_tuple(64, 64, &vpx_highbd_sad64x64_c, 10),
- make_tuple(64, 32, &vpx_highbd_sad64x32_c, 10),
- make_tuple(32, 64, &vpx_highbd_sad32x64_c, 10),
- make_tuple(32, 32, &vpx_highbd_sad32x32_c, 10),
- make_tuple(32, 16, &vpx_highbd_sad32x16_c, 10),
- make_tuple(16, 32, &vpx_highbd_sad16x32_c, 10),
- make_tuple(16, 16, &vpx_highbd_sad16x16_c, 10),
- make_tuple(16, 8, &vpx_highbd_sad16x8_c, 10),
- make_tuple(8, 16, &vpx_highbd_sad8x16_c, 10),
- make_tuple(8, 8, &vpx_highbd_sad8x8_c, 10),
- make_tuple(8, 4, &vpx_highbd_sad8x4_c, 10),
- make_tuple(4, 8, &vpx_highbd_sad4x8_c, 10),
- make_tuple(4, 4, &vpx_highbd_sad4x4_c, 10),
-#if CONFIG_VP10 && CONFIG_EXT_PARTITION
- make_tuple(128, 128, &vpx_highbd_sad128x128_c, 12),
- make_tuple(128, 64, &vpx_highbd_sad128x64_c, 12),
- make_tuple(64, 128, &vpx_highbd_sad64x128_c, 12),
-#endif // CONFIG_VP10 && CONFIG_EXT_PARTITION
- make_tuple(64, 64, &vpx_highbd_sad64x64_c, 12),
- make_tuple(64, 32, &vpx_highbd_sad64x32_c, 12),
- make_tuple(32, 64, &vpx_highbd_sad32x64_c, 12),
- make_tuple(32, 32, &vpx_highbd_sad32x32_c, 12),
- make_tuple(32, 16, &vpx_highbd_sad32x16_c, 12),
- make_tuple(16, 32, &vpx_highbd_sad16x32_c, 12),
- make_tuple(16, 16, &vpx_highbd_sad16x16_c, 12),
- make_tuple(16, 8, &vpx_highbd_sad16x8_c, 12),
- make_tuple(8, 16, &vpx_highbd_sad8x16_c, 12),
- make_tuple(8, 8, &vpx_highbd_sad8x8_c, 12),
- make_tuple(8, 4, &vpx_highbd_sad8x4_c, 12),
- make_tuple(4, 8, &vpx_highbd_sad4x8_c, 12),
- make_tuple(4, 4, &vpx_highbd_sad4x4_c, 12),
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AV1 && CONFIG_EXT_PARTITION
+ make_tuple(128, 128, &aom_sad128x128_c, -1),
+ make_tuple(128, 64, &aom_sad128x64_c, -1),
+ make_tuple(64, 128, &aom_sad64x128_c, -1),
+#endif // CONFIG_AV1 && CONFIG_EXT_PARTITION
+ make_tuple(64, 64, &aom_sad64x64_c, -1),
+ make_tuple(64, 32, &aom_sad64x32_c, -1),
+ make_tuple(32, 64, &aom_sad32x64_c, -1),
+ make_tuple(32, 32, &aom_sad32x32_c, -1),
+ make_tuple(32, 16, &aom_sad32x16_c, -1),
+ make_tuple(16, 32, &aom_sad16x32_c, -1),
+ make_tuple(16, 16, &aom_sad16x16_c, -1),
+ make_tuple(16, 8, &aom_sad16x8_c, -1),
+ make_tuple(8, 16, &aom_sad8x16_c, -1),
+ make_tuple(8, 8, &aom_sad8x8_c, -1),
+ make_tuple(8, 4, &aom_sad8x4_c, -1),
+ make_tuple(4, 8, &aom_sad4x8_c, -1),
+ make_tuple(4, 4, &aom_sad4x4_c, -1),
+#if CONFIG_AOM_HIGHBITDEPTH
+#if CONFIG_AV1 && CONFIG_EXT_PARTITION
+ make_tuple(128, 128, &aom_highbd_sad128x128_c, 8),
+ make_tuple(128, 64, &aom_highbd_sad128x64_c, 8),
+ make_tuple(64, 128, &aom_highbd_sad64x128_c, 8),
+#endif // CONFIG_AV1 && CONFIG_EXT_PARTITION
+ make_tuple(64, 64, &aom_highbd_sad64x64_c, 8),
+ make_tuple(64, 32, &aom_highbd_sad64x32_c, 8),
+ make_tuple(32, 64, &aom_highbd_sad32x64_c, 8),
+ make_tuple(32, 32, &aom_highbd_sad32x32_c, 8),
+ make_tuple(32, 16, &aom_highbd_sad32x16_c, 8),
+ make_tuple(16, 32, &aom_highbd_sad16x32_c, 8),
+ make_tuple(16, 16, &aom_highbd_sad16x16_c, 8),
+ make_tuple(16, 8, &aom_highbd_sad16x8_c, 8),
+ make_tuple(8, 16, &aom_highbd_sad8x16_c, 8),
+ make_tuple(8, 8, &aom_highbd_sad8x8_c, 8),
+ make_tuple(8, 4, &aom_highbd_sad8x4_c, 8),
+ make_tuple(4, 8, &aom_highbd_sad4x8_c, 8),
+ make_tuple(4, 4, &aom_highbd_sad4x4_c, 8),
+#if CONFIG_AV1 && CONFIG_EXT_PARTITION
+ make_tuple(128, 128, &aom_highbd_sad128x128_c, 10),
+ make_tuple(128, 64, &aom_highbd_sad128x64_c, 10),
+ make_tuple(64, 128, &aom_highbd_sad64x128_c, 10),
+#endif // CONFIG_AV1 && CONFIG_EXT_PARTITION
+ make_tuple(64, 64, &aom_highbd_sad64x64_c, 10),
+ make_tuple(64, 32, &aom_highbd_sad64x32_c, 10),
+ make_tuple(32, 64, &aom_highbd_sad32x64_c, 10),
+ make_tuple(32, 32, &aom_highbd_sad32x32_c, 10),
+ make_tuple(32, 16, &aom_highbd_sad32x16_c, 10),
+ make_tuple(16, 32, &aom_highbd_sad16x32_c, 10),
+ make_tuple(16, 16, &aom_highbd_sad16x16_c, 10),
+ make_tuple(16, 8, &aom_highbd_sad16x8_c, 10),
+ make_tuple(8, 16, &aom_highbd_sad8x16_c, 10),
+ make_tuple(8, 8, &aom_highbd_sad8x8_c, 10),
+ make_tuple(8, 4, &aom_highbd_sad8x4_c, 10),
+ make_tuple(4, 8, &aom_highbd_sad4x8_c, 10),
+ make_tuple(4, 4, &aom_highbd_sad4x4_c, 10),
+#if CONFIG_AV1 && CONFIG_EXT_PARTITION
+ make_tuple(128, 128, &aom_highbd_sad128x128_c, 12),
+ make_tuple(128, 64, &aom_highbd_sad128x64_c, 12),
+ make_tuple(64, 128, &aom_highbd_sad64x128_c, 12),
+#endif // CONFIG_AV1 && CONFIG_EXT_PARTITION
+ make_tuple(64, 64, &aom_highbd_sad64x64_c, 12),
+ make_tuple(64, 32, &aom_highbd_sad64x32_c, 12),
+ make_tuple(32, 64, &aom_highbd_sad32x64_c, 12),
+ make_tuple(32, 32, &aom_highbd_sad32x32_c, 12),
+ make_tuple(32, 16, &aom_highbd_sad32x16_c, 12),
+ make_tuple(16, 32, &aom_highbd_sad16x32_c, 12),
+ make_tuple(16, 16, &aom_highbd_sad16x16_c, 12),
+ make_tuple(16, 8, &aom_highbd_sad16x8_c, 12),
+ make_tuple(8, 16, &aom_highbd_sad8x16_c, 12),
+ make_tuple(8, 8, &aom_highbd_sad8x8_c, 12),
+ make_tuple(8, 4, &aom_highbd_sad8x4_c, 12),
+ make_tuple(4, 8, &aom_highbd_sad4x8_c, 12),
+ make_tuple(4, 4, &aom_highbd_sad4x4_c, 12),
+#endif // CONFIG_AOM_HIGHBITDEPTH
};
INSTANTIATE_TEST_CASE_P(C, SADTest, ::testing::ValuesIn(c_tests));
const SadMxNAvgParam avg_c_tests[] = {
-#if CONFIG_VP10 && CONFIG_EXT_PARTITION
- make_tuple(128, 128, &vpx_sad128x128_avg_c, -1),
- make_tuple(128, 64, &vpx_sad128x64_avg_c, -1),
- make_tuple(64, 128, &vpx_sad64x128_avg_c, -1),
-#endif // CONFIG_VP10 && CONFIG_EXT_PARTITION
- make_tuple(64, 64, &vpx_sad64x64_avg_c, -1),
- make_tuple(64, 32, &vpx_sad64x32_avg_c, -1),
- make_tuple(32, 64, &vpx_sad32x64_avg_c, -1),
- make_tuple(32, 32, &vpx_sad32x32_avg_c, -1),
- make_tuple(32, 16, &vpx_sad32x16_avg_c, -1),
- make_tuple(16, 32, &vpx_sad16x32_avg_c, -1),
- make_tuple(16, 16, &vpx_sad16x16_avg_c, -1),
- make_tuple(16, 8, &vpx_sad16x8_avg_c, -1),
- make_tuple(8, 16, &vpx_sad8x16_avg_c, -1),
- make_tuple(8, 8, &vpx_sad8x8_avg_c, -1),
- make_tuple(8, 4, &vpx_sad8x4_avg_c, -1),
- make_tuple(4, 8, &vpx_sad4x8_avg_c, -1),
- make_tuple(4, 4, &vpx_sad4x4_avg_c, -1),
-#if CONFIG_VP9_HIGHBITDEPTH
-#if CONFIG_VP10 && CONFIG_EXT_PARTITION
- make_tuple(128, 128, &vpx_highbd_sad128x128_avg_c, 8),
- make_tuple(128, 64, &vpx_highbd_sad128x64_avg_c, 8),
- make_tuple(64, 128, &vpx_highbd_sad64x128_avg_c, 8),
-#endif // CONFIG_VP10 && CONFIG_EXT_PARTITION
- make_tuple(64, 64, &vpx_highbd_sad64x64_avg_c, 8),
- make_tuple(64, 32, &vpx_highbd_sad64x32_avg_c, 8),
- make_tuple(32, 64, &vpx_highbd_sad32x64_avg_c, 8),
- make_tuple(32, 32, &vpx_highbd_sad32x32_avg_c, 8),
- make_tuple(32, 16, &vpx_highbd_sad32x16_avg_c, 8),
- make_tuple(16, 32, &vpx_highbd_sad16x32_avg_c, 8),
- make_tuple(16, 16, &vpx_highbd_sad16x16_avg_c, 8),
- make_tuple(16, 8, &vpx_highbd_sad16x8_avg_c, 8),
- make_tuple(8, 16, &vpx_highbd_sad8x16_avg_c, 8),
- make_tuple(8, 8, &vpx_highbd_sad8x8_avg_c, 8),
- make_tuple(8, 4, &vpx_highbd_sad8x4_avg_c, 8),
- make_tuple(4, 8, &vpx_highbd_sad4x8_avg_c, 8),
- make_tuple(4, 4, &vpx_highbd_sad4x4_avg_c, 8),
-#if CONFIG_VP10 && CONFIG_EXT_PARTITION
- make_tuple(128, 128, &vpx_highbd_sad128x128_avg_c, 10),
- make_tuple(128, 64, &vpx_highbd_sad128x64_avg_c, 10),
- make_tuple(64, 128, &vpx_highbd_sad64x128_avg_c, 10),
-#endif // CONFIG_VP10 && CONFIG_EXT_PARTITION
- make_tuple(64, 64, &vpx_highbd_sad64x64_avg_c, 10),
- make_tuple(64, 32, &vpx_highbd_sad64x32_avg_c, 10),
- make_tuple(32, 64, &vpx_highbd_sad32x64_avg_c, 10),
- make_tuple(32, 32, &vpx_highbd_sad32x32_avg_c, 10),
- make_tuple(32, 16, &vpx_highbd_sad32x16_avg_c, 10),
- make_tuple(16, 32, &vpx_highbd_sad16x32_avg_c, 10),
- make_tuple(16, 16, &vpx_highbd_sad16x16_avg_c, 10),
- make_tuple(16, 8, &vpx_highbd_sad16x8_avg_c, 10),
- make_tuple(8, 16, &vpx_highbd_sad8x16_avg_c, 10),
- make_tuple(8, 8, &vpx_highbd_sad8x8_avg_c, 10),
- make_tuple(8, 4, &vpx_highbd_sad8x4_avg_c, 10),
- make_tuple(4, 8, &vpx_highbd_sad4x8_avg_c, 10),
- make_tuple(4, 4, &vpx_highbd_sad4x4_avg_c, 10),
-#if CONFIG_VP10 && CONFIG_EXT_PARTITION
- make_tuple(128, 128, &vpx_highbd_sad128x128_avg_c, 12),
- make_tuple(128, 64, &vpx_highbd_sad128x64_avg_c, 12),
- make_tuple(64, 128, &vpx_highbd_sad64x128_avg_c, 12),
-#endif // CONFIG_VP10 && CONFIG_EXT_PARTITION
- make_tuple(64, 64, &vpx_highbd_sad64x64_avg_c, 12),
- make_tuple(64, 32, &vpx_highbd_sad64x32_avg_c, 12),
- make_tuple(32, 64, &vpx_highbd_sad32x64_avg_c, 12),
- make_tuple(32, 32, &vpx_highbd_sad32x32_avg_c, 12),
- make_tuple(32, 16, &vpx_highbd_sad32x16_avg_c, 12),
- make_tuple(16, 32, &vpx_highbd_sad16x32_avg_c, 12),
- make_tuple(16, 16, &vpx_highbd_sad16x16_avg_c, 12),
- make_tuple(16, 8, &vpx_highbd_sad16x8_avg_c, 12),
- make_tuple(8, 16, &vpx_highbd_sad8x16_avg_c, 12),
- make_tuple(8, 8, &vpx_highbd_sad8x8_avg_c, 12),
- make_tuple(8, 4, &vpx_highbd_sad8x4_avg_c, 12),
- make_tuple(4, 8, &vpx_highbd_sad4x8_avg_c, 12),
- make_tuple(4, 4, &vpx_highbd_sad4x4_avg_c, 12),
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AV1 && CONFIG_EXT_PARTITION
+ make_tuple(128, 128, &aom_sad128x128_avg_c, -1),
+ make_tuple(128, 64, &aom_sad128x64_avg_c, -1),
+ make_tuple(64, 128, &aom_sad64x128_avg_c, -1),
+#endif // CONFIG_AV1 && CONFIG_EXT_PARTITION
+ make_tuple(64, 64, &aom_sad64x64_avg_c, -1),
+ make_tuple(64, 32, &aom_sad64x32_avg_c, -1),
+ make_tuple(32, 64, &aom_sad32x64_avg_c, -1),
+ make_tuple(32, 32, &aom_sad32x32_avg_c, -1),
+ make_tuple(32, 16, &aom_sad32x16_avg_c, -1),
+ make_tuple(16, 32, &aom_sad16x32_avg_c, -1),
+ make_tuple(16, 16, &aom_sad16x16_avg_c, -1),
+ make_tuple(16, 8, &aom_sad16x8_avg_c, -1),
+ make_tuple(8, 16, &aom_sad8x16_avg_c, -1),
+ make_tuple(8, 8, &aom_sad8x8_avg_c, -1),
+ make_tuple(8, 4, &aom_sad8x4_avg_c, -1),
+ make_tuple(4, 8, &aom_sad4x8_avg_c, -1),
+ make_tuple(4, 4, &aom_sad4x4_avg_c, -1),
+#if CONFIG_AOM_HIGHBITDEPTH
+#if CONFIG_AV1 && CONFIG_EXT_PARTITION
+ make_tuple(128, 128, &aom_highbd_sad128x128_avg_c, 8),
+ make_tuple(128, 64, &aom_highbd_sad128x64_avg_c, 8),
+ make_tuple(64, 128, &aom_highbd_sad64x128_avg_c, 8),
+#endif // CONFIG_AV1 && CONFIG_EXT_PARTITION
+ make_tuple(64, 64, &aom_highbd_sad64x64_avg_c, 8),
+ make_tuple(64, 32, &aom_highbd_sad64x32_avg_c, 8),
+ make_tuple(32, 64, &aom_highbd_sad32x64_avg_c, 8),
+ make_tuple(32, 32, &aom_highbd_sad32x32_avg_c, 8),
+ make_tuple(32, 16, &aom_highbd_sad32x16_avg_c, 8),
+ make_tuple(16, 32, &aom_highbd_sad16x32_avg_c, 8),
+ make_tuple(16, 16, &aom_highbd_sad16x16_avg_c, 8),
+ make_tuple(16, 8, &aom_highbd_sad16x8_avg_c, 8),
+ make_tuple(8, 16, &aom_highbd_sad8x16_avg_c, 8),
+ make_tuple(8, 8, &aom_highbd_sad8x8_avg_c, 8),
+ make_tuple(8, 4, &aom_highbd_sad8x4_avg_c, 8),
+ make_tuple(4, 8, &aom_highbd_sad4x8_avg_c, 8),
+ make_tuple(4, 4, &aom_highbd_sad4x4_avg_c, 8),
+#if CONFIG_AV1 && CONFIG_EXT_PARTITION
+ make_tuple(128, 128, &aom_highbd_sad128x128_avg_c, 10),
+ make_tuple(128, 64, &aom_highbd_sad128x64_avg_c, 10),
+ make_tuple(64, 128, &aom_highbd_sad64x128_avg_c, 10),
+#endif // CONFIG_AV1 && CONFIG_EXT_PARTITION
+ make_tuple(64, 64, &aom_highbd_sad64x64_avg_c, 10),
+ make_tuple(64, 32, &aom_highbd_sad64x32_avg_c, 10),
+ make_tuple(32, 64, &aom_highbd_sad32x64_avg_c, 10),
+ make_tuple(32, 32, &aom_highbd_sad32x32_avg_c, 10),
+ make_tuple(32, 16, &aom_highbd_sad32x16_avg_c, 10),
+ make_tuple(16, 32, &aom_highbd_sad16x32_avg_c, 10),
+ make_tuple(16, 16, &aom_highbd_sad16x16_avg_c, 10),
+ make_tuple(16, 8, &aom_highbd_sad16x8_avg_c, 10),
+ make_tuple(8, 16, &aom_highbd_sad8x16_avg_c, 10),
+ make_tuple(8, 8, &aom_highbd_sad8x8_avg_c, 10),
+ make_tuple(8, 4, &aom_highbd_sad8x4_avg_c, 10),
+ make_tuple(4, 8, &aom_highbd_sad4x8_avg_c, 10),
+ make_tuple(4, 4, &aom_highbd_sad4x4_avg_c, 10),
+#if CONFIG_AV1 && CONFIG_EXT_PARTITION
+ make_tuple(128, 128, &aom_highbd_sad128x128_avg_c, 12),
+ make_tuple(128, 64, &aom_highbd_sad128x64_avg_c, 12),
+ make_tuple(64, 128, &aom_highbd_sad64x128_avg_c, 12),
+#endif // CONFIG_AV1 && CONFIG_EXT_PARTITION
+ make_tuple(64, 64, &aom_highbd_sad64x64_avg_c, 12),
+ make_tuple(64, 32, &aom_highbd_sad64x32_avg_c, 12),
+ make_tuple(32, 64, &aom_highbd_sad32x64_avg_c, 12),
+ make_tuple(32, 32, &aom_highbd_sad32x32_avg_c, 12),
+ make_tuple(32, 16, &aom_highbd_sad32x16_avg_c, 12),
+ make_tuple(16, 32, &aom_highbd_sad16x32_avg_c, 12),
+ make_tuple(16, 16, &aom_highbd_sad16x16_avg_c, 12),
+ make_tuple(16, 8, &aom_highbd_sad16x8_avg_c, 12),
+ make_tuple(8, 16, &aom_highbd_sad8x16_avg_c, 12),
+ make_tuple(8, 8, &aom_highbd_sad8x8_avg_c, 12),
+ make_tuple(8, 4, &aom_highbd_sad8x4_avg_c, 12),
+ make_tuple(4, 8, &aom_highbd_sad4x8_avg_c, 12),
+ make_tuple(4, 4, &aom_highbd_sad4x4_avg_c, 12),
+#endif // CONFIG_AOM_HIGHBITDEPTH
};
INSTANTIATE_TEST_CASE_P(C, SADavgTest, ::testing::ValuesIn(avg_c_tests));
const SadMxNx4Param x4d_c_tests[] = {
-#if CONFIG_VP10 && CONFIG_EXT_PARTITION
- make_tuple(128, 128, &vpx_sad128x128x4d_c, -1),
- make_tuple(128, 64, &vpx_sad128x64x4d_c, -1),
- make_tuple(64, 128, &vpx_sad64x128x4d_c, -1),
-#endif // CONFIG_VP10 && CONFIG_EXT_PARTITION
- make_tuple(64, 64, &vpx_sad64x64x4d_c, -1),
- make_tuple(64, 32, &vpx_sad64x32x4d_c, -1),
- make_tuple(32, 64, &vpx_sad32x64x4d_c, -1),
- make_tuple(32, 32, &vpx_sad32x32x4d_c, -1),
- make_tuple(32, 16, &vpx_sad32x16x4d_c, -1),
- make_tuple(16, 32, &vpx_sad16x32x4d_c, -1),
- make_tuple(16, 16, &vpx_sad16x16x4d_c, -1),
- make_tuple(16, 8, &vpx_sad16x8x4d_c, -1),
- make_tuple(8, 16, &vpx_sad8x16x4d_c, -1),
- make_tuple(8, 8, &vpx_sad8x8x4d_c, -1),
- make_tuple(8, 4, &vpx_sad8x4x4d_c, -1),
- make_tuple(4, 8, &vpx_sad4x8x4d_c, -1),
- make_tuple(4, 4, &vpx_sad4x4x4d_c, -1),
-#if CONFIG_VP9_HIGHBITDEPTH
-#if CONFIG_VP10 && CONFIG_EXT_PARTITION
- make_tuple(128, 128, &vpx_highbd_sad128x128x4d_c, 8),
- make_tuple(128, 64, &vpx_highbd_sad128x64x4d_c, 8),
- make_tuple(64, 128, &vpx_highbd_sad64x128x4d_c, 8),
-#endif // CONFIG_VP10 && CONFIG_EXT_PARTITION
- make_tuple(64, 64, &vpx_highbd_sad64x64x4d_c, 8),
- make_tuple(64, 32, &vpx_highbd_sad64x32x4d_c, 8),
- make_tuple(32, 64, &vpx_highbd_sad32x64x4d_c, 8),
- make_tuple(32, 32, &vpx_highbd_sad32x32x4d_c, 8),
- make_tuple(32, 16, &vpx_highbd_sad32x16x4d_c, 8),
- make_tuple(16, 32, &vpx_highbd_sad16x32x4d_c, 8),
- make_tuple(16, 16, &vpx_highbd_sad16x16x4d_c, 8),
- make_tuple(16, 8, &vpx_highbd_sad16x8x4d_c, 8),
- make_tuple(8, 16, &vpx_highbd_sad8x16x4d_c, 8),
- make_tuple(8, 8, &vpx_highbd_sad8x8x4d_c, 8),
- make_tuple(8, 4, &vpx_highbd_sad8x4x4d_c, 8),
- make_tuple(4, 8, &vpx_highbd_sad4x8x4d_c, 8),
- make_tuple(4, 4, &vpx_highbd_sad4x4x4d_c, 8),
-#if CONFIG_VP10 && CONFIG_EXT_PARTITION
- make_tuple(128, 128, &vpx_highbd_sad128x128x4d_c, 10),
- make_tuple(128, 64, &vpx_highbd_sad128x64x4d_c, 10),
- make_tuple(64, 128, &vpx_highbd_sad64x128x4d_c, 10),
-#endif // CONFIG_VP10 && CONFIG_EXT_PARTITION
- make_tuple(64, 64, &vpx_highbd_sad64x64x4d_c, 10),
- make_tuple(64, 32, &vpx_highbd_sad64x32x4d_c, 10),
- make_tuple(32, 64, &vpx_highbd_sad32x64x4d_c, 10),
- make_tuple(32, 32, &vpx_highbd_sad32x32x4d_c, 10),
- make_tuple(32, 16, &vpx_highbd_sad32x16x4d_c, 10),
- make_tuple(16, 32, &vpx_highbd_sad16x32x4d_c, 10),
- make_tuple(16, 16, &vpx_highbd_sad16x16x4d_c, 10),
- make_tuple(16, 8, &vpx_highbd_sad16x8x4d_c, 10),
- make_tuple(8, 16, &vpx_highbd_sad8x16x4d_c, 10),
- make_tuple(8, 8, &vpx_highbd_sad8x8x4d_c, 10),
- make_tuple(8, 4, &vpx_highbd_sad8x4x4d_c, 10),
- make_tuple(4, 8, &vpx_highbd_sad4x8x4d_c, 10),
- make_tuple(4, 4, &vpx_highbd_sad4x4x4d_c, 10),
-#if CONFIG_VP10 && CONFIG_EXT_PARTITION
- make_tuple(128, 128, &vpx_highbd_sad128x128x4d_c, 12),
- make_tuple(128, 64, &vpx_highbd_sad128x64x4d_c, 12),
- make_tuple(64, 128, &vpx_highbd_sad64x128x4d_c, 12),
-#endif // CONFIG_VP10 && CONFIG_EXT_PARTITION
- make_tuple(64, 64, &vpx_highbd_sad64x64x4d_c, 12),
- make_tuple(64, 32, &vpx_highbd_sad64x32x4d_c, 12),
- make_tuple(32, 64, &vpx_highbd_sad32x64x4d_c, 12),
- make_tuple(32, 32, &vpx_highbd_sad32x32x4d_c, 12),
- make_tuple(32, 16, &vpx_highbd_sad32x16x4d_c, 12),
- make_tuple(16, 32, &vpx_highbd_sad16x32x4d_c, 12),
- make_tuple(16, 16, &vpx_highbd_sad16x16x4d_c, 12),
- make_tuple(16, 8, &vpx_highbd_sad16x8x4d_c, 12),
- make_tuple(8, 16, &vpx_highbd_sad8x16x4d_c, 12),
- make_tuple(8, 8, &vpx_highbd_sad8x8x4d_c, 12),
- make_tuple(8, 4, &vpx_highbd_sad8x4x4d_c, 12),
- make_tuple(4, 8, &vpx_highbd_sad4x8x4d_c, 12),
- make_tuple(4, 4, &vpx_highbd_sad4x4x4d_c, 12),
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AV1 && CONFIG_EXT_PARTITION
+ make_tuple(128, 128, &aom_sad128x128x4d_c, -1),
+ make_tuple(128, 64, &aom_sad128x64x4d_c, -1),
+ make_tuple(64, 128, &aom_sad64x128x4d_c, -1),
+#endif // CONFIG_AV1 && CONFIG_EXT_PARTITION
+ make_tuple(64, 64, &aom_sad64x64x4d_c, -1),
+ make_tuple(64, 32, &aom_sad64x32x4d_c, -1),
+ make_tuple(32, 64, &aom_sad32x64x4d_c, -1),
+ make_tuple(32, 32, &aom_sad32x32x4d_c, -1),
+ make_tuple(32, 16, &aom_sad32x16x4d_c, -1),
+ make_tuple(16, 32, &aom_sad16x32x4d_c, -1),
+ make_tuple(16, 16, &aom_sad16x16x4d_c, -1),
+ make_tuple(16, 8, &aom_sad16x8x4d_c, -1),
+ make_tuple(8, 16, &aom_sad8x16x4d_c, -1),
+ make_tuple(8, 8, &aom_sad8x8x4d_c, -1),
+ make_tuple(8, 4, &aom_sad8x4x4d_c, -1),
+ make_tuple(4, 8, &aom_sad4x8x4d_c, -1),
+ make_tuple(4, 4, &aom_sad4x4x4d_c, -1),
+#if CONFIG_AOM_HIGHBITDEPTH
+#if CONFIG_AV1 && CONFIG_EXT_PARTITION
+ make_tuple(128, 128, &aom_highbd_sad128x128x4d_c, 8),
+ make_tuple(128, 64, &aom_highbd_sad128x64x4d_c, 8),
+ make_tuple(64, 128, &aom_highbd_sad64x128x4d_c, 8),
+#endif // CONFIG_AV1 && CONFIG_EXT_PARTITION
+ make_tuple(64, 64, &aom_highbd_sad64x64x4d_c, 8),
+ make_tuple(64, 32, &aom_highbd_sad64x32x4d_c, 8),
+ make_tuple(32, 64, &aom_highbd_sad32x64x4d_c, 8),
+ make_tuple(32, 32, &aom_highbd_sad32x32x4d_c, 8),
+ make_tuple(32, 16, &aom_highbd_sad32x16x4d_c, 8),
+ make_tuple(16, 32, &aom_highbd_sad16x32x4d_c, 8),
+ make_tuple(16, 16, &aom_highbd_sad16x16x4d_c, 8),
+ make_tuple(16, 8, &aom_highbd_sad16x8x4d_c, 8),
+ make_tuple(8, 16, &aom_highbd_sad8x16x4d_c, 8),
+ make_tuple(8, 8, &aom_highbd_sad8x8x4d_c, 8),
+ make_tuple(8, 4, &aom_highbd_sad8x4x4d_c, 8),
+ make_tuple(4, 8, &aom_highbd_sad4x8x4d_c, 8),
+ make_tuple(4, 4, &aom_highbd_sad4x4x4d_c, 8),
+#if CONFIG_AV1 && CONFIG_EXT_PARTITION
+ make_tuple(128, 128, &aom_highbd_sad128x128x4d_c, 10),
+ make_tuple(128, 64, &aom_highbd_sad128x64x4d_c, 10),
+ make_tuple(64, 128, &aom_highbd_sad64x128x4d_c, 10),
+#endif // CONFIG_AV1 && CONFIG_EXT_PARTITION
+ make_tuple(64, 64, &aom_highbd_sad64x64x4d_c, 10),
+ make_tuple(64, 32, &aom_highbd_sad64x32x4d_c, 10),
+ make_tuple(32, 64, &aom_highbd_sad32x64x4d_c, 10),
+ make_tuple(32, 32, &aom_highbd_sad32x32x4d_c, 10),
+ make_tuple(32, 16, &aom_highbd_sad32x16x4d_c, 10),
+ make_tuple(16, 32, &aom_highbd_sad16x32x4d_c, 10),
+ make_tuple(16, 16, &aom_highbd_sad16x16x4d_c, 10),
+ make_tuple(16, 8, &aom_highbd_sad16x8x4d_c, 10),
+ make_tuple(8, 16, &aom_highbd_sad8x16x4d_c, 10),
+ make_tuple(8, 8, &aom_highbd_sad8x8x4d_c, 10),
+ make_tuple(8, 4, &aom_highbd_sad8x4x4d_c, 10),
+ make_tuple(4, 8, &aom_highbd_sad4x8x4d_c, 10),
+ make_tuple(4, 4, &aom_highbd_sad4x4x4d_c, 10),
+#if CONFIG_AV1 && CONFIG_EXT_PARTITION
+ make_tuple(128, 128, &aom_highbd_sad128x128x4d_c, 12),
+ make_tuple(128, 64, &aom_highbd_sad128x64x4d_c, 12),
+ make_tuple(64, 128, &aom_highbd_sad64x128x4d_c, 12),
+#endif // CONFIG_AV1 && CONFIG_EXT_PARTITION
+ make_tuple(64, 64, &aom_highbd_sad64x64x4d_c, 12),
+ make_tuple(64, 32, &aom_highbd_sad64x32x4d_c, 12),
+ make_tuple(32, 64, &aom_highbd_sad32x64x4d_c, 12),
+ make_tuple(32, 32, &aom_highbd_sad32x32x4d_c, 12),
+ make_tuple(32, 16, &aom_highbd_sad32x16x4d_c, 12),
+ make_tuple(16, 32, &aom_highbd_sad16x32x4d_c, 12),
+ make_tuple(16, 16, &aom_highbd_sad16x16x4d_c, 12),
+ make_tuple(16, 8, &aom_highbd_sad16x8x4d_c, 12),
+ make_tuple(8, 16, &aom_highbd_sad8x16x4d_c, 12),
+ make_tuple(8, 8, &aom_highbd_sad8x8x4d_c, 12),
+ make_tuple(8, 4, &aom_highbd_sad8x4x4d_c, 12),
+ make_tuple(4, 8, &aom_highbd_sad4x8x4d_c, 12),
+ make_tuple(4, 4, &aom_highbd_sad4x4x4d_c, 12),
+#endif // CONFIG_AOM_HIGHBITDEPTH
};
INSTANTIATE_TEST_CASE_P(C, SADx4Test, ::testing::ValuesIn(x4d_c_tests));
@@ -709,27 +709,27 @@
// ARM functions
#if HAVE_MEDIA
const SadMxNParam media_tests[] = {
- make_tuple(16, 16, &vpx_sad16x16_media, -1),
+ make_tuple(16, 16, &aom_sad16x16_media, -1),
};
INSTANTIATE_TEST_CASE_P(MEDIA, SADTest, ::testing::ValuesIn(media_tests));
#endif // HAVE_MEDIA
#if HAVE_NEON
const SadMxNParam neon_tests[] = {
- make_tuple(64, 64, &vpx_sad64x64_neon, -1),
- make_tuple(32, 32, &vpx_sad32x32_neon, -1),
- make_tuple(16, 16, &vpx_sad16x16_neon, -1),
- make_tuple(16, 8, &vpx_sad16x8_neon, -1),
- make_tuple(8, 16, &vpx_sad8x16_neon, -1),
- make_tuple(8, 8, &vpx_sad8x8_neon, -1),
- make_tuple(4, 4, &vpx_sad4x4_neon, -1),
+ make_tuple(64, 64, &aom_sad64x64_neon, -1),
+ make_tuple(32, 32, &aom_sad32x32_neon, -1),
+ make_tuple(16, 16, &aom_sad16x16_neon, -1),
+ make_tuple(16, 8, &aom_sad16x8_neon, -1),
+ make_tuple(8, 16, &aom_sad8x16_neon, -1),
+ make_tuple(8, 8, &aom_sad8x8_neon, -1),
+ make_tuple(4, 4, &aom_sad4x4_neon, -1),
};
INSTANTIATE_TEST_CASE_P(NEON, SADTest, ::testing::ValuesIn(neon_tests));
const SadMxNx4Param x4d_neon_tests[] = {
- make_tuple(64, 64, &vpx_sad64x64x4d_neon, -1),
- make_tuple(32, 32, &vpx_sad32x32x4d_neon, -1),
- make_tuple(16, 16, &vpx_sad16x16x4d_neon, -1),
+ make_tuple(64, 64, &aom_sad64x64x4d_neon, -1),
+ make_tuple(32, 32, &aom_sad32x32x4d_neon, -1),
+ make_tuple(16, 16, &aom_sad16x16x4d_neon, -1),
};
INSTANTIATE_TEST_CASE_P(NEON, SADx4Test, ::testing::ValuesIn(x4d_neon_tests));
#endif // HAVE_NEON
@@ -738,179 +738,179 @@
// x86 functions
#if HAVE_SSE2
const SadMxNParam sse2_tests[] = {
-#if CONFIG_VP10 && CONFIG_EXT_PARTITION
- make_tuple(128, 128, &vpx_sad128x128_sse2, -1),
- make_tuple(128, 64, &vpx_sad128x64_sse2, -1),
- make_tuple(64, 128, &vpx_sad64x128_sse2, -1),
-#endif // CONFIG_VP10 && CONFIG_EXT_PARTITION
- make_tuple(64, 64, &vpx_sad64x64_sse2, -1),
- make_tuple(64, 32, &vpx_sad64x32_sse2, -1),
- make_tuple(32, 64, &vpx_sad32x64_sse2, -1),
- make_tuple(32, 32, &vpx_sad32x32_sse2, -1),
- make_tuple(32, 16, &vpx_sad32x16_sse2, -1),
- make_tuple(16, 32, &vpx_sad16x32_sse2, -1),
- make_tuple(16, 16, &vpx_sad16x16_sse2, -1),
- make_tuple(16, 8, &vpx_sad16x8_sse2, -1),
- make_tuple(8, 16, &vpx_sad8x16_sse2, -1),
- make_tuple(8, 8, &vpx_sad8x8_sse2, -1),
- make_tuple(8, 4, &vpx_sad8x4_sse2, -1),
- make_tuple(4, 8, &vpx_sad4x8_sse2, -1),
- make_tuple(4, 4, &vpx_sad4x4_sse2, -1),
-#if CONFIG_VP9_HIGHBITDEPTH
- make_tuple(64, 64, &vpx_highbd_sad64x64_sse2, 8),
- make_tuple(64, 32, &vpx_highbd_sad64x32_sse2, 8),
- make_tuple(32, 64, &vpx_highbd_sad32x64_sse2, 8),
- make_tuple(32, 32, &vpx_highbd_sad32x32_sse2, 8),
- make_tuple(32, 16, &vpx_highbd_sad32x16_sse2, 8),
- make_tuple(16, 32, &vpx_highbd_sad16x32_sse2, 8),
- make_tuple(16, 16, &vpx_highbd_sad16x16_sse2, 8),
- make_tuple(16, 8, &vpx_highbd_sad16x8_sse2, 8),
- make_tuple(8, 16, &vpx_highbd_sad8x16_sse2, 8),
- make_tuple(8, 8, &vpx_highbd_sad8x8_sse2, 8),
- make_tuple(8, 4, &vpx_highbd_sad8x4_sse2, 8),
- make_tuple(64, 64, &vpx_highbd_sad64x64_sse2, 10),
- make_tuple(64, 32, &vpx_highbd_sad64x32_sse2, 10),
- make_tuple(32, 64, &vpx_highbd_sad32x64_sse2, 10),
- make_tuple(32, 32, &vpx_highbd_sad32x32_sse2, 10),
- make_tuple(32, 16, &vpx_highbd_sad32x16_sse2, 10),
- make_tuple(16, 32, &vpx_highbd_sad16x32_sse2, 10),
- make_tuple(16, 16, &vpx_highbd_sad16x16_sse2, 10),
- make_tuple(16, 8, &vpx_highbd_sad16x8_sse2, 10),
- make_tuple(8, 16, &vpx_highbd_sad8x16_sse2, 10),
- make_tuple(8, 8, &vpx_highbd_sad8x8_sse2, 10),
- make_tuple(8, 4, &vpx_highbd_sad8x4_sse2, 10),
- make_tuple(64, 64, &vpx_highbd_sad64x64_sse2, 12),
- make_tuple(64, 32, &vpx_highbd_sad64x32_sse2, 12),
- make_tuple(32, 64, &vpx_highbd_sad32x64_sse2, 12),
- make_tuple(32, 32, &vpx_highbd_sad32x32_sse2, 12),
- make_tuple(32, 16, &vpx_highbd_sad32x16_sse2, 12),
- make_tuple(16, 32, &vpx_highbd_sad16x32_sse2, 12),
- make_tuple(16, 16, &vpx_highbd_sad16x16_sse2, 12),
- make_tuple(16, 8, &vpx_highbd_sad16x8_sse2, 12),
- make_tuple(8, 16, &vpx_highbd_sad8x16_sse2, 12),
- make_tuple(8, 8, &vpx_highbd_sad8x8_sse2, 12),
- make_tuple(8, 4, &vpx_highbd_sad8x4_sse2, 12),
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AV1 && CONFIG_EXT_PARTITION
+ make_tuple(128, 128, &aom_sad128x128_sse2, -1),
+ make_tuple(128, 64, &aom_sad128x64_sse2, -1),
+ make_tuple(64, 128, &aom_sad64x128_sse2, -1),
+#endif // CONFIG_AV1 && CONFIG_EXT_PARTITION
+ make_tuple(64, 64, &aom_sad64x64_sse2, -1),
+ make_tuple(64, 32, &aom_sad64x32_sse2, -1),
+ make_tuple(32, 64, &aom_sad32x64_sse2, -1),
+ make_tuple(32, 32, &aom_sad32x32_sse2, -1),
+ make_tuple(32, 16, &aom_sad32x16_sse2, -1),
+ make_tuple(16, 32, &aom_sad16x32_sse2, -1),
+ make_tuple(16, 16, &aom_sad16x16_sse2, -1),
+ make_tuple(16, 8, &aom_sad16x8_sse2, -1),
+ make_tuple(8, 16, &aom_sad8x16_sse2, -1),
+ make_tuple(8, 8, &aom_sad8x8_sse2, -1),
+ make_tuple(8, 4, &aom_sad8x4_sse2, -1),
+ make_tuple(4, 8, &aom_sad4x8_sse2, -1),
+ make_tuple(4, 4, &aom_sad4x4_sse2, -1),
+#if CONFIG_AOM_HIGHBITDEPTH
+ make_tuple(64, 64, &aom_highbd_sad64x64_sse2, 8),
+ make_tuple(64, 32, &aom_highbd_sad64x32_sse2, 8),
+ make_tuple(32, 64, &aom_highbd_sad32x64_sse2, 8),
+ make_tuple(32, 32, &aom_highbd_sad32x32_sse2, 8),
+ make_tuple(32, 16, &aom_highbd_sad32x16_sse2, 8),
+ make_tuple(16, 32, &aom_highbd_sad16x32_sse2, 8),
+ make_tuple(16, 16, &aom_highbd_sad16x16_sse2, 8),
+ make_tuple(16, 8, &aom_highbd_sad16x8_sse2, 8),
+ make_tuple(8, 16, &aom_highbd_sad8x16_sse2, 8),
+ make_tuple(8, 8, &aom_highbd_sad8x8_sse2, 8),
+ make_tuple(8, 4, &aom_highbd_sad8x4_sse2, 8),
+ make_tuple(64, 64, &aom_highbd_sad64x64_sse2, 10),
+ make_tuple(64, 32, &aom_highbd_sad64x32_sse2, 10),
+ make_tuple(32, 64, &aom_highbd_sad32x64_sse2, 10),
+ make_tuple(32, 32, &aom_highbd_sad32x32_sse2, 10),
+ make_tuple(32, 16, &aom_highbd_sad32x16_sse2, 10),
+ make_tuple(16, 32, &aom_highbd_sad16x32_sse2, 10),
+ make_tuple(16, 16, &aom_highbd_sad16x16_sse2, 10),
+ make_tuple(16, 8, &aom_highbd_sad16x8_sse2, 10),
+ make_tuple(8, 16, &aom_highbd_sad8x16_sse2, 10),
+ make_tuple(8, 8, &aom_highbd_sad8x8_sse2, 10),
+ make_tuple(8, 4, &aom_highbd_sad8x4_sse2, 10),
+ make_tuple(64, 64, &aom_highbd_sad64x64_sse2, 12),
+ make_tuple(64, 32, &aom_highbd_sad64x32_sse2, 12),
+ make_tuple(32, 64, &aom_highbd_sad32x64_sse2, 12),
+ make_tuple(32, 32, &aom_highbd_sad32x32_sse2, 12),
+ make_tuple(32, 16, &aom_highbd_sad32x16_sse2, 12),
+ make_tuple(16, 32, &aom_highbd_sad16x32_sse2, 12),
+ make_tuple(16, 16, &aom_highbd_sad16x16_sse2, 12),
+ make_tuple(16, 8, &aom_highbd_sad16x8_sse2, 12),
+ make_tuple(8, 16, &aom_highbd_sad8x16_sse2, 12),
+ make_tuple(8, 8, &aom_highbd_sad8x8_sse2, 12),
+ make_tuple(8, 4, &aom_highbd_sad8x4_sse2, 12),
+#endif // CONFIG_AOM_HIGHBITDEPTH
};
INSTANTIATE_TEST_CASE_P(SSE2, SADTest, ::testing::ValuesIn(sse2_tests));
const SadMxNAvgParam avg_sse2_tests[] = {
-#if CONFIG_VP10 && CONFIG_EXT_PARTITION
- make_tuple(128, 128, &vpx_sad128x128_avg_sse2, -1),
- make_tuple(128, 64, &vpx_sad128x64_avg_sse2, -1),
- make_tuple(64, 128, &vpx_sad64x128_avg_sse2, -1),
-#endif // CONFIG_VP10 && CONFIG_EXT_PARTITION
- make_tuple(64, 64, &vpx_sad64x64_avg_sse2, -1),
- make_tuple(64, 32, &vpx_sad64x32_avg_sse2, -1),
- make_tuple(32, 64, &vpx_sad32x64_avg_sse2, -1),
- make_tuple(32, 32, &vpx_sad32x32_avg_sse2, -1),
- make_tuple(32, 16, &vpx_sad32x16_avg_sse2, -1),
- make_tuple(16, 32, &vpx_sad16x32_avg_sse2, -1),
- make_tuple(16, 16, &vpx_sad16x16_avg_sse2, -1),
- make_tuple(16, 8, &vpx_sad16x8_avg_sse2, -1),
- make_tuple(8, 16, &vpx_sad8x16_avg_sse2, -1),
- make_tuple(8, 8, &vpx_sad8x8_avg_sse2, -1),
- make_tuple(8, 4, &vpx_sad8x4_avg_sse2, -1),
- make_tuple(4, 8, &vpx_sad4x8_avg_sse2, -1),
- make_tuple(4, 4, &vpx_sad4x4_avg_sse2, -1),
-#if CONFIG_VP9_HIGHBITDEPTH
- make_tuple(64, 64, &vpx_highbd_sad64x64_avg_sse2, 8),
- make_tuple(64, 32, &vpx_highbd_sad64x32_avg_sse2, 8),
- make_tuple(32, 64, &vpx_highbd_sad32x64_avg_sse2, 8),
- make_tuple(32, 32, &vpx_highbd_sad32x32_avg_sse2, 8),
- make_tuple(32, 16, &vpx_highbd_sad32x16_avg_sse2, 8),
- make_tuple(16, 32, &vpx_highbd_sad16x32_avg_sse2, 8),
- make_tuple(16, 16, &vpx_highbd_sad16x16_avg_sse2, 8),
- make_tuple(16, 8, &vpx_highbd_sad16x8_avg_sse2, 8),
- make_tuple(8, 16, &vpx_highbd_sad8x16_avg_sse2, 8),
- make_tuple(8, 8, &vpx_highbd_sad8x8_avg_sse2, 8),
- make_tuple(8, 4, &vpx_highbd_sad8x4_avg_sse2, 8),
- make_tuple(64, 64, &vpx_highbd_sad64x64_avg_sse2, 10),
- make_tuple(64, 32, &vpx_highbd_sad64x32_avg_sse2, 10),
- make_tuple(32, 64, &vpx_highbd_sad32x64_avg_sse2, 10),
- make_tuple(32, 32, &vpx_highbd_sad32x32_avg_sse2, 10),
- make_tuple(32, 16, &vpx_highbd_sad32x16_avg_sse2, 10),
- make_tuple(16, 32, &vpx_highbd_sad16x32_avg_sse2, 10),
- make_tuple(16, 16, &vpx_highbd_sad16x16_avg_sse2, 10),
- make_tuple(16, 8, &vpx_highbd_sad16x8_avg_sse2, 10),
- make_tuple(8, 16, &vpx_highbd_sad8x16_avg_sse2, 10),
- make_tuple(8, 8, &vpx_highbd_sad8x8_avg_sse2, 10),
- make_tuple(8, 4, &vpx_highbd_sad8x4_avg_sse2, 10),
- make_tuple(64, 64, &vpx_highbd_sad64x64_avg_sse2, 12),
- make_tuple(64, 32, &vpx_highbd_sad64x32_avg_sse2, 12),
- make_tuple(32, 64, &vpx_highbd_sad32x64_avg_sse2, 12),
- make_tuple(32, 32, &vpx_highbd_sad32x32_avg_sse2, 12),
- make_tuple(32, 16, &vpx_highbd_sad32x16_avg_sse2, 12),
- make_tuple(16, 32, &vpx_highbd_sad16x32_avg_sse2, 12),
- make_tuple(16, 16, &vpx_highbd_sad16x16_avg_sse2, 12),
- make_tuple(16, 8, &vpx_highbd_sad16x8_avg_sse2, 12),
- make_tuple(8, 16, &vpx_highbd_sad8x16_avg_sse2, 12),
- make_tuple(8, 8, &vpx_highbd_sad8x8_avg_sse2, 12),
- make_tuple(8, 4, &vpx_highbd_sad8x4_avg_sse2, 12),
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AV1 && CONFIG_EXT_PARTITION
+ make_tuple(128, 128, &aom_sad128x128_avg_sse2, -1),
+ make_tuple(128, 64, &aom_sad128x64_avg_sse2, -1),
+ make_tuple(64, 128, &aom_sad64x128_avg_sse2, -1),
+#endif // CONFIG_AV1 && CONFIG_EXT_PARTITION
+ make_tuple(64, 64, &aom_sad64x64_avg_sse2, -1),
+ make_tuple(64, 32, &aom_sad64x32_avg_sse2, -1),
+ make_tuple(32, 64, &aom_sad32x64_avg_sse2, -1),
+ make_tuple(32, 32, &aom_sad32x32_avg_sse2, -1),
+ make_tuple(32, 16, &aom_sad32x16_avg_sse2, -1),
+ make_tuple(16, 32, &aom_sad16x32_avg_sse2, -1),
+ make_tuple(16, 16, &aom_sad16x16_avg_sse2, -1),
+ make_tuple(16, 8, &aom_sad16x8_avg_sse2, -1),
+ make_tuple(8, 16, &aom_sad8x16_avg_sse2, -1),
+ make_tuple(8, 8, &aom_sad8x8_avg_sse2, -1),
+ make_tuple(8, 4, &aom_sad8x4_avg_sse2, -1),
+ make_tuple(4, 8, &aom_sad4x8_avg_sse2, -1),
+ make_tuple(4, 4, &aom_sad4x4_avg_sse2, -1),
+#if CONFIG_AOM_HIGHBITDEPTH
+ make_tuple(64, 64, &aom_highbd_sad64x64_avg_sse2, 8),
+ make_tuple(64, 32, &aom_highbd_sad64x32_avg_sse2, 8),
+ make_tuple(32, 64, &aom_highbd_sad32x64_avg_sse2, 8),
+ make_tuple(32, 32, &aom_highbd_sad32x32_avg_sse2, 8),
+ make_tuple(32, 16, &aom_highbd_sad32x16_avg_sse2, 8),
+ make_tuple(16, 32, &aom_highbd_sad16x32_avg_sse2, 8),
+ make_tuple(16, 16, &aom_highbd_sad16x16_avg_sse2, 8),
+ make_tuple(16, 8, &aom_highbd_sad16x8_avg_sse2, 8),
+ make_tuple(8, 16, &aom_highbd_sad8x16_avg_sse2, 8),
+ make_tuple(8, 8, &aom_highbd_sad8x8_avg_sse2, 8),
+ make_tuple(8, 4, &aom_highbd_sad8x4_avg_sse2, 8),
+ make_tuple(64, 64, &aom_highbd_sad64x64_avg_sse2, 10),
+ make_tuple(64, 32, &aom_highbd_sad64x32_avg_sse2, 10),
+ make_tuple(32, 64, &aom_highbd_sad32x64_avg_sse2, 10),
+ make_tuple(32, 32, &aom_highbd_sad32x32_avg_sse2, 10),
+ make_tuple(32, 16, &aom_highbd_sad32x16_avg_sse2, 10),
+ make_tuple(16, 32, &aom_highbd_sad16x32_avg_sse2, 10),
+ make_tuple(16, 16, &aom_highbd_sad16x16_avg_sse2, 10),
+ make_tuple(16, 8, &aom_highbd_sad16x8_avg_sse2, 10),
+ make_tuple(8, 16, &aom_highbd_sad8x16_avg_sse2, 10),
+ make_tuple(8, 8, &aom_highbd_sad8x8_avg_sse2, 10),
+ make_tuple(8, 4, &aom_highbd_sad8x4_avg_sse2, 10),
+ make_tuple(64, 64, &aom_highbd_sad64x64_avg_sse2, 12),
+ make_tuple(64, 32, &aom_highbd_sad64x32_avg_sse2, 12),
+ make_tuple(32, 64, &aom_highbd_sad32x64_avg_sse2, 12),
+ make_tuple(32, 32, &aom_highbd_sad32x32_avg_sse2, 12),
+ make_tuple(32, 16, &aom_highbd_sad32x16_avg_sse2, 12),
+ make_tuple(16, 32, &aom_highbd_sad16x32_avg_sse2, 12),
+ make_tuple(16, 16, &aom_highbd_sad16x16_avg_sse2, 12),
+ make_tuple(16, 8, &aom_highbd_sad16x8_avg_sse2, 12),
+ make_tuple(8, 16, &aom_highbd_sad8x16_avg_sse2, 12),
+ make_tuple(8, 8, &aom_highbd_sad8x8_avg_sse2, 12),
+ make_tuple(8, 4, &aom_highbd_sad8x4_avg_sse2, 12),
+#endif // CONFIG_AOM_HIGHBITDEPTH
};
INSTANTIATE_TEST_CASE_P(SSE2, SADavgTest, ::testing::ValuesIn(avg_sse2_tests));
const SadMxNx4Param x4d_sse2_tests[] = {
-#if CONFIG_VP10 && CONFIG_EXT_PARTITION
- make_tuple(128, 128, &vpx_sad128x128x4d_sse2, -1),
- make_tuple(128, 64, &vpx_sad128x64x4d_sse2, -1),
- make_tuple(64, 128, &vpx_sad64x128x4d_sse2, -1),
-#endif // CONFIG_VP10 && CONFIG_EXT_PARTITION
- make_tuple(64, 64, &vpx_sad64x64x4d_sse2, -1),
- make_tuple(64, 32, &vpx_sad64x32x4d_sse2, -1),
- make_tuple(32, 64, &vpx_sad32x64x4d_sse2, -1),
- make_tuple(32, 32, &vpx_sad32x32x4d_sse2, -1),
- make_tuple(32, 16, &vpx_sad32x16x4d_sse2, -1),
- make_tuple(16, 32, &vpx_sad16x32x4d_sse2, -1),
- make_tuple(16, 16, &vpx_sad16x16x4d_sse2, -1),
- make_tuple(16, 8, &vpx_sad16x8x4d_sse2, -1),
- make_tuple(8, 16, &vpx_sad8x16x4d_sse2, -1),
- make_tuple(8, 8, &vpx_sad8x8x4d_sse2, -1),
- make_tuple(8, 4, &vpx_sad8x4x4d_sse2, -1),
- make_tuple(4, 8, &vpx_sad4x8x4d_sse2, -1),
- make_tuple(4, 4, &vpx_sad4x4x4d_sse2, -1),
-#if CONFIG_VP9_HIGHBITDEPTH
- make_tuple(64, 64, &vpx_highbd_sad64x64x4d_sse2, 8),
- make_tuple(64, 32, &vpx_highbd_sad64x32x4d_sse2, 8),
- make_tuple(32, 64, &vpx_highbd_sad32x64x4d_sse2, 8),
- make_tuple(32, 32, &vpx_highbd_sad32x32x4d_sse2, 8),
- make_tuple(32, 16, &vpx_highbd_sad32x16x4d_sse2, 8),
- make_tuple(16, 32, &vpx_highbd_sad16x32x4d_sse2, 8),
- make_tuple(16, 16, &vpx_highbd_sad16x16x4d_sse2, 8),
- make_tuple(16, 8, &vpx_highbd_sad16x8x4d_sse2, 8),
- make_tuple(8, 16, &vpx_highbd_sad8x16x4d_sse2, 8),
- make_tuple(8, 8, &vpx_highbd_sad8x8x4d_sse2, 8),
- make_tuple(8, 4, &vpx_highbd_sad8x4x4d_sse2, 8),
- make_tuple(4, 8, &vpx_highbd_sad4x8x4d_sse2, 8),
- make_tuple(4, 4, &vpx_highbd_sad4x4x4d_sse2, 8),
- make_tuple(64, 64, &vpx_highbd_sad64x64x4d_sse2, 10),
- make_tuple(64, 32, &vpx_highbd_sad64x32x4d_sse2, 10),
- make_tuple(32, 64, &vpx_highbd_sad32x64x4d_sse2, 10),
- make_tuple(32, 32, &vpx_highbd_sad32x32x4d_sse2, 10),
- make_tuple(32, 16, &vpx_highbd_sad32x16x4d_sse2, 10),
- make_tuple(16, 32, &vpx_highbd_sad16x32x4d_sse2, 10),
- make_tuple(16, 16, &vpx_highbd_sad16x16x4d_sse2, 10),
- make_tuple(16, 8, &vpx_highbd_sad16x8x4d_sse2, 10),
- make_tuple(8, 16, &vpx_highbd_sad8x16x4d_sse2, 10),
- make_tuple(8, 8, &vpx_highbd_sad8x8x4d_sse2, 10),
- make_tuple(8, 4, &vpx_highbd_sad8x4x4d_sse2, 10),
- make_tuple(4, 8, &vpx_highbd_sad4x8x4d_sse2, 10),
- make_tuple(4, 4, &vpx_highbd_sad4x4x4d_sse2, 10),
- make_tuple(64, 64, &vpx_highbd_sad64x64x4d_sse2, 12),
- make_tuple(64, 32, &vpx_highbd_sad64x32x4d_sse2, 12),
- make_tuple(32, 64, &vpx_highbd_sad32x64x4d_sse2, 12),
- make_tuple(32, 32, &vpx_highbd_sad32x32x4d_sse2, 12),
- make_tuple(32, 16, &vpx_highbd_sad32x16x4d_sse2, 12),
- make_tuple(16, 32, &vpx_highbd_sad16x32x4d_sse2, 12),
- make_tuple(16, 16, &vpx_highbd_sad16x16x4d_sse2, 12),
- make_tuple(16, 8, &vpx_highbd_sad16x8x4d_sse2, 12),
- make_tuple(8, 16, &vpx_highbd_sad8x16x4d_sse2, 12),
- make_tuple(8, 8, &vpx_highbd_sad8x8x4d_sse2, 12),
- make_tuple(8, 4, &vpx_highbd_sad8x4x4d_sse2, 12),
- make_tuple(4, 8, &vpx_highbd_sad4x8x4d_sse2, 12),
- make_tuple(4, 4, &vpx_highbd_sad4x4x4d_sse2, 12),
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AV1 && CONFIG_EXT_PARTITION
+ make_tuple(128, 128, &aom_sad128x128x4d_sse2, -1),
+ make_tuple(128, 64, &aom_sad128x64x4d_sse2, -1),
+ make_tuple(64, 128, &aom_sad64x128x4d_sse2, -1),
+#endif // CONFIG_AV1 && CONFIG_EXT_PARTITION
+ make_tuple(64, 64, &aom_sad64x64x4d_sse2, -1),
+ make_tuple(64, 32, &aom_sad64x32x4d_sse2, -1),
+ make_tuple(32, 64, &aom_sad32x64x4d_sse2, -1),
+ make_tuple(32, 32, &aom_sad32x32x4d_sse2, -1),
+ make_tuple(32, 16, &aom_sad32x16x4d_sse2, -1),
+ make_tuple(16, 32, &aom_sad16x32x4d_sse2, -1),
+ make_tuple(16, 16, &aom_sad16x16x4d_sse2, -1),
+ make_tuple(16, 8, &aom_sad16x8x4d_sse2, -1),
+ make_tuple(8, 16, &aom_sad8x16x4d_sse2, -1),
+ make_tuple(8, 8, &aom_sad8x8x4d_sse2, -1),
+ make_tuple(8, 4, &aom_sad8x4x4d_sse2, -1),
+ make_tuple(4, 8, &aom_sad4x8x4d_sse2, -1),
+ make_tuple(4, 4, &aom_sad4x4x4d_sse2, -1),
+#if CONFIG_AOM_HIGHBITDEPTH
+ make_tuple(64, 64, &aom_highbd_sad64x64x4d_sse2, 8),
+ make_tuple(64, 32, &aom_highbd_sad64x32x4d_sse2, 8),
+ make_tuple(32, 64, &aom_highbd_sad32x64x4d_sse2, 8),
+ make_tuple(32, 32, &aom_highbd_sad32x32x4d_sse2, 8),
+ make_tuple(32, 16, &aom_highbd_sad32x16x4d_sse2, 8),
+ make_tuple(16, 32, &aom_highbd_sad16x32x4d_sse2, 8),
+ make_tuple(16, 16, &aom_highbd_sad16x16x4d_sse2, 8),
+ make_tuple(16, 8, &aom_highbd_sad16x8x4d_sse2, 8),
+ make_tuple(8, 16, &aom_highbd_sad8x16x4d_sse2, 8),
+ make_tuple(8, 8, &aom_highbd_sad8x8x4d_sse2, 8),
+ make_tuple(8, 4, &aom_highbd_sad8x4x4d_sse2, 8),
+ make_tuple(4, 8, &aom_highbd_sad4x8x4d_sse2, 8),
+ make_tuple(4, 4, &aom_highbd_sad4x4x4d_sse2, 8),
+ make_tuple(64, 64, &aom_highbd_sad64x64x4d_sse2, 10),
+ make_tuple(64, 32, &aom_highbd_sad64x32x4d_sse2, 10),
+ make_tuple(32, 64, &aom_highbd_sad32x64x4d_sse2, 10),
+ make_tuple(32, 32, &aom_highbd_sad32x32x4d_sse2, 10),
+ make_tuple(32, 16, &aom_highbd_sad32x16x4d_sse2, 10),
+ make_tuple(16, 32, &aom_highbd_sad16x32x4d_sse2, 10),
+ make_tuple(16, 16, &aom_highbd_sad16x16x4d_sse2, 10),
+ make_tuple(16, 8, &aom_highbd_sad16x8x4d_sse2, 10),
+ make_tuple(8, 16, &aom_highbd_sad8x16x4d_sse2, 10),
+ make_tuple(8, 8, &aom_highbd_sad8x8x4d_sse2, 10),
+ make_tuple(8, 4, &aom_highbd_sad8x4x4d_sse2, 10),
+ make_tuple(4, 8, &aom_highbd_sad4x8x4d_sse2, 10),
+ make_tuple(4, 4, &aom_highbd_sad4x4x4d_sse2, 10),
+ make_tuple(64, 64, &aom_highbd_sad64x64x4d_sse2, 12),
+ make_tuple(64, 32, &aom_highbd_sad64x32x4d_sse2, 12),
+ make_tuple(32, 64, &aom_highbd_sad32x64x4d_sse2, 12),
+ make_tuple(32, 32, &aom_highbd_sad32x32x4d_sse2, 12),
+ make_tuple(32, 16, &aom_highbd_sad32x16x4d_sse2, 12),
+ make_tuple(16, 32, &aom_highbd_sad16x32x4d_sse2, 12),
+ make_tuple(16, 16, &aom_highbd_sad16x16x4d_sse2, 12),
+ make_tuple(16, 8, &aom_highbd_sad16x8x4d_sse2, 12),
+ make_tuple(8, 16, &aom_highbd_sad8x16x4d_sse2, 12),
+ make_tuple(8, 8, &aom_highbd_sad8x8x4d_sse2, 12),
+ make_tuple(8, 4, &aom_highbd_sad8x4x4d_sse2, 12),
+ make_tuple(4, 8, &aom_highbd_sad4x8x4d_sse2, 12),
+ make_tuple(4, 4, &aom_highbd_sad4x4x4d_sse2, 12),
+#endif // CONFIG_AOM_HIGHBITDEPTH
};
INSTANTIATE_TEST_CASE_P(SSE2, SADx4Test, ::testing::ValuesIn(x4d_sse2_tests));
#endif // HAVE_SSE2
@@ -929,26 +929,26 @@
#if HAVE_AVX2
const SadMxNParam avx2_tests[] = {
- make_tuple(64, 64, &vpx_sad64x64_avx2, -1),
- make_tuple(64, 32, &vpx_sad64x32_avx2, -1),
- make_tuple(32, 64, &vpx_sad32x64_avx2, -1),
- make_tuple(32, 32, &vpx_sad32x32_avx2, -1),
- make_tuple(32, 16, &vpx_sad32x16_avx2, -1),
+ make_tuple(64, 64, &aom_sad64x64_avx2, -1),
+ make_tuple(64, 32, &aom_sad64x32_avx2, -1),
+ make_tuple(32, 64, &aom_sad32x64_avx2, -1),
+ make_tuple(32, 32, &aom_sad32x32_avx2, -1),
+ make_tuple(32, 16, &aom_sad32x16_avx2, -1),
};
INSTANTIATE_TEST_CASE_P(AVX2, SADTest, ::testing::ValuesIn(avx2_tests));
const SadMxNAvgParam avg_avx2_tests[] = {
- make_tuple(64, 64, &vpx_sad64x64_avg_avx2, -1),
- make_tuple(64, 32, &vpx_sad64x32_avg_avx2, -1),
- make_tuple(32, 64, &vpx_sad32x64_avg_avx2, -1),
- make_tuple(32, 32, &vpx_sad32x32_avg_avx2, -1),
- make_tuple(32, 16, &vpx_sad32x16_avg_avx2, -1),
+ make_tuple(64, 64, &aom_sad64x64_avg_avx2, -1),
+ make_tuple(64, 32, &aom_sad64x32_avg_avx2, -1),
+ make_tuple(32, 64, &aom_sad32x64_avg_avx2, -1),
+ make_tuple(32, 32, &aom_sad32x32_avg_avx2, -1),
+ make_tuple(32, 16, &aom_sad32x16_avg_avx2, -1),
};
INSTANTIATE_TEST_CASE_P(AVX2, SADavgTest, ::testing::ValuesIn(avg_avx2_tests));
const SadMxNx4Param x4d_avx2_tests[] = {
- make_tuple(64, 64, &vpx_sad64x64x4d_avx2, -1),
- make_tuple(32, 32, &vpx_sad32x32x4d_avx2, -1),
+ make_tuple(64, 64, &aom_sad64x64x4d_avx2, -1),
+ make_tuple(32, 32, &aom_sad32x32x4d_avx2, -1),
};
INSTANTIATE_TEST_CASE_P(AVX2, SADx4Test, ::testing::ValuesIn(x4d_avx2_tests));
#endif // HAVE_AVX2
@@ -957,53 +957,53 @@
// MIPS functions
#if HAVE_MSA
const SadMxNParam msa_tests[] = {
- make_tuple(64, 64, &vpx_sad64x64_msa, -1),
- make_tuple(64, 32, &vpx_sad64x32_msa, -1),
- make_tuple(32, 64, &vpx_sad32x64_msa, -1),
- make_tuple(32, 32, &vpx_sad32x32_msa, -1),
- make_tuple(32, 16, &vpx_sad32x16_msa, -1),
- make_tuple(16, 32, &vpx_sad16x32_msa, -1),
- make_tuple(16, 16, &vpx_sad16x16_msa, -1),
- make_tuple(16, 8, &vpx_sad16x8_msa, -1),
- make_tuple(8, 16, &vpx_sad8x16_msa, -1),
- make_tuple(8, 8, &vpx_sad8x8_msa, -1),
- make_tuple(8, 4, &vpx_sad8x4_msa, -1),
- make_tuple(4, 8, &vpx_sad4x8_msa, -1),
- make_tuple(4, 4, &vpx_sad4x4_msa, -1),
+ make_tuple(64, 64, &aom_sad64x64_msa, -1),
+ make_tuple(64, 32, &aom_sad64x32_msa, -1),
+ make_tuple(32, 64, &aom_sad32x64_msa, -1),
+ make_tuple(32, 32, &aom_sad32x32_msa, -1),
+ make_tuple(32, 16, &aom_sad32x16_msa, -1),
+ make_tuple(16, 32, &aom_sad16x32_msa, -1),
+ make_tuple(16, 16, &aom_sad16x16_msa, -1),
+ make_tuple(16, 8, &aom_sad16x8_msa, -1),
+ make_tuple(8, 16, &aom_sad8x16_msa, -1),
+ make_tuple(8, 8, &aom_sad8x8_msa, -1),
+ make_tuple(8, 4, &aom_sad8x4_msa, -1),
+ make_tuple(4, 8, &aom_sad4x8_msa, -1),
+ make_tuple(4, 4, &aom_sad4x4_msa, -1),
};
INSTANTIATE_TEST_CASE_P(MSA, SADTest, ::testing::ValuesIn(msa_tests));
const SadMxNAvgParam avg_msa_tests[] = {
- make_tuple(64, 64, &vpx_sad64x64_avg_msa, -1),
- make_tuple(64, 32, &vpx_sad64x32_avg_msa, -1),
- make_tuple(32, 64, &vpx_sad32x64_avg_msa, -1),
- make_tuple(32, 32, &vpx_sad32x32_avg_msa, -1),
- make_tuple(32, 16, &vpx_sad32x16_avg_msa, -1),
- make_tuple(16, 32, &vpx_sad16x32_avg_msa, -1),
- make_tuple(16, 16, &vpx_sad16x16_avg_msa, -1),
- make_tuple(16, 8, &vpx_sad16x8_avg_msa, -1),
- make_tuple(8, 16, &vpx_sad8x16_avg_msa, -1),
- make_tuple(8, 8, &vpx_sad8x8_avg_msa, -1),
- make_tuple(8, 4, &vpx_sad8x4_avg_msa, -1),
- make_tuple(4, 8, &vpx_sad4x8_avg_msa, -1),
- make_tuple(4, 4, &vpx_sad4x4_avg_msa, -1),
+ make_tuple(64, 64, &aom_sad64x64_avg_msa, -1),
+ make_tuple(64, 32, &aom_sad64x32_avg_msa, -1),
+ make_tuple(32, 64, &aom_sad32x64_avg_msa, -1),
+ make_tuple(32, 32, &aom_sad32x32_avg_msa, -1),
+ make_tuple(32, 16, &aom_sad32x16_avg_msa, -1),
+ make_tuple(16, 32, &aom_sad16x32_avg_msa, -1),
+ make_tuple(16, 16, &aom_sad16x16_avg_msa, -1),
+ make_tuple(16, 8, &aom_sad16x8_avg_msa, -1),
+ make_tuple(8, 16, &aom_sad8x16_avg_msa, -1),
+ make_tuple(8, 8, &aom_sad8x8_avg_msa, -1),
+ make_tuple(8, 4, &aom_sad8x4_avg_msa, -1),
+ make_tuple(4, 8, &aom_sad4x8_avg_msa, -1),
+ make_tuple(4, 4, &aom_sad4x4_avg_msa, -1),
};
INSTANTIATE_TEST_CASE_P(MSA, SADavgTest, ::testing::ValuesIn(avg_msa_tests));
const SadMxNx4Param x4d_msa_tests[] = {
- make_tuple(64, 64, &vpx_sad64x64x4d_msa, -1),
- make_tuple(64, 32, &vpx_sad64x32x4d_msa, -1),
- make_tuple(32, 64, &vpx_sad32x64x4d_msa, -1),
- make_tuple(32, 32, &vpx_sad32x32x4d_msa, -1),
- make_tuple(32, 16, &vpx_sad32x16x4d_msa, -1),
- make_tuple(16, 32, &vpx_sad16x32x4d_msa, -1),
- make_tuple(16, 16, &vpx_sad16x16x4d_msa, -1),
- make_tuple(16, 8, &vpx_sad16x8x4d_msa, -1),
- make_tuple(8, 16, &vpx_sad8x16x4d_msa, -1),
- make_tuple(8, 8, &vpx_sad8x8x4d_msa, -1),
- make_tuple(8, 4, &vpx_sad8x4x4d_msa, -1),
- make_tuple(4, 8, &vpx_sad4x8x4d_msa, -1),
- make_tuple(4, 4, &vpx_sad4x4x4d_msa, -1),
+ make_tuple(64, 64, &aom_sad64x64x4d_msa, -1),
+ make_tuple(64, 32, &aom_sad64x32x4d_msa, -1),
+ make_tuple(32, 64, &aom_sad32x64x4d_msa, -1),
+ make_tuple(32, 32, &aom_sad32x32x4d_msa, -1),
+ make_tuple(32, 16, &aom_sad32x16x4d_msa, -1),
+ make_tuple(16, 32, &aom_sad16x32x4d_msa, -1),
+ make_tuple(16, 16, &aom_sad16x16x4d_msa, -1),
+ make_tuple(16, 8, &aom_sad16x8x4d_msa, -1),
+ make_tuple(8, 16, &aom_sad8x16x4d_msa, -1),
+ make_tuple(8, 8, &aom_sad8x8x4d_msa, -1),
+ make_tuple(8, 4, &aom_sad8x4x4d_msa, -1),
+ make_tuple(4, 8, &aom_sad4x8x4d_msa, -1),
+ make_tuple(4, 4, &aom_sad4x4x4d_msa, -1),
};
INSTANTIATE_TEST_CASE_P(MSA, SADx4Test, ::testing::ValuesIn(x4d_msa_tests));
#endif // HAVE_MSA
diff --git a/test/set_maps.sh b/test/set_maps.sh
index b50453e..174dc4a 100755
--- a/test/set_maps.sh
+++ b/test/set_maps.sh
@@ -19,10 +19,10 @@
# $LIBAOM_BIN_PATH.
set_maps_verify_environment() {
if [ ! -e "${YUV_RAW_INPUT}" ]; then
- echo "Libvpx test data must exist in LIBVPX_TEST_DATA_PATH."
+ echo "Libaom test data must exist in LIBVPX_TEST_DATA_PATH."
return 1
fi
- if [ -z "$(vpx_tool_path set_maps)" ]; then
+ if [ -z "$(aom_tool_path set_maps)" ]; then
elog "set_maps not found. It must exist in LIBAOM_BIN_PATH or its parent."
return 1
fi
@@ -30,30 +30,30 @@
# Runs set_maps using the codec specified by $1.
set_maps() {
- local encoder="$(vpx_tool_path set_maps)"
+ local encoder="$(aom_tool_path set_maps)"
local codec="$1"
- local output_file="${VPX_TEST_OUTPUT_DIR}/set_maps_${codec}.ivf"
+ local output_file="${AOM_TEST_OUTPUT_DIR}/set_maps_${codec}.ivf"
- eval "${VPX_TEST_PREFIX}" "${encoder}" "${codec}" "${YUV_RAW_INPUT_WIDTH}" \
+ eval "${AOM_TEST_PREFIX}" "${encoder}" "${codec}" "${YUV_RAW_INPUT_WIDTH}" \
"${YUV_RAW_INPUT_HEIGHT}" "${YUV_RAW_INPUT}" "${output_file}" \
${devnull}
[ -e "${output_file}" ] || return 1
}
-set_maps_vp8() {
- if [ "$(vp8_encode_available)" = "yes" ]; then
- set_maps vp8 || return 1
+set_maps_aom() {
+ if [ "$(aom_encode_available)" = "yes" ]; then
+ set_maps aom || return 1
fi
}
-set_maps_vp9() {
- if [ "$(vp9_encode_available)" = "yes" ]; then
- set_maps vp9 || return 1
+set_maps_av1() {
+ if [ "$(av1_encode_available)" = "yes" ]; then
+ set_maps av1 || return 1
fi
}
-set_maps_tests="set_maps_vp8
- set_maps_vp9"
+set_maps_tests="set_maps_aom
+ set_maps_av1"
run_tests set_maps_verify_environment "${set_maps_tests}"
diff --git a/test/simple_decoder.sh b/test/simple_decoder.sh
index 0955c92..08f8fb0 100755
--- a/test/simple_decoder.sh
+++ b/test/simple_decoder.sh
@@ -16,10 +16,10 @@
. $(dirname $0)/tools_common.sh
# Environment check: Make sure input is available:
-# $VP8_IVF_FILE and $VP9_IVF_FILE are required.
+# $AOM_IVF_FILE and $AV1_IVF_FILE are required.
simple_decoder_verify_environment() {
- if [ ! -e "${VP8_IVF_FILE}" ] || [ ! -e "${VP9_IVF_FILE}" ]; then
- echo "Libvpx test data must exist in LIBVPX_TEST_DATA_PATH."
+ if [ ! -e "${AOM_IVF_FILE}" ] || [ ! -e "${AV1_IVF_FILE}" ]; then
+ echo "Libaom test data must exist in LIBVPX_TEST_DATA_PATH."
return 1
fi
}
@@ -27,35 +27,35 @@
# Runs simple_decoder using $1 as input file. $2 is the codec name, and is used
# solely to name the output file.
simple_decoder() {
- local decoder="${LIBAOM_BIN_PATH}/simple_decoder${VPX_TEST_EXE_SUFFIX}"
+ local decoder="${LIBAOM_BIN_PATH}/simple_decoder${AOM_TEST_EXE_SUFFIX}"
local input_file="$1"
local codec="$2"
- local output_file="${VPX_TEST_OUTPUT_DIR}/simple_decoder_${codec}.raw"
+ local output_file="${AOM_TEST_OUTPUT_DIR}/simple_decoder_${codec}.raw"
if [ ! -x "${decoder}" ]; then
elog "${decoder} does not exist or is not executable."
return 1
fi
- eval "${VPX_TEST_PREFIX}" "${decoder}" "${input_file}" "${output_file}" \
+ eval "${AOM_TEST_PREFIX}" "${decoder}" "${input_file}" "${output_file}" \
${devnull}
[ -e "${output_file}" ] || return 1
}
-simple_decoder_vp8() {
- if [ "$(vp8_decode_available)" = "yes" ]; then
- simple_decoder "${VP8_IVF_FILE}" vp8 || return 1
+simple_decoder_aom() {
+ if [ "$(aom_decode_available)" = "yes" ]; then
+ simple_decoder "${AOM_IVF_FILE}" aom || return 1
fi
}
-simple_decoder_vp9() {
- if [ "$(vp9_decode_available)" = "yes" ]; then
- simple_decoder "${VP9_IVF_FILE}" vp9 || return 1
+simple_decoder_av1() {
+ if [ "$(av1_decode_available)" = "yes" ]; then
+ simple_decoder "${AV1_IVF_FILE}" av1 || return 1
fi
}
-simple_decoder_tests="simple_decoder_vp8
- simple_decoder_vp9"
+simple_decoder_tests="simple_decoder_aom
+ simple_decoder_av1"
run_tests simple_decoder_verify_environment "${simple_decoder_tests}"
diff --git a/test/simple_encoder.sh b/test/simple_encoder.sh
index e0da0ec..25208c9 100755
--- a/test/simple_encoder.sh
+++ b/test/simple_encoder.sh
@@ -18,42 +18,45 @@
# Environment check: $YUV_RAW_INPUT is required.
simple_encoder_verify_environment() {
if [ ! -e "${YUV_RAW_INPUT}" ]; then
- echo "Libvpx test data must exist in LIBVPX_TEST_DATA_PATH."
+ echo "Libaom test data must exist in LIBVPX_TEST_DATA_PATH."
return 1
fi
}
# Runs simple_encoder using the codec specified by $1 with a frame limit of 100.
simple_encoder() {
- local encoder="${LIBAOM_BIN_PATH}/simple_encoder${VPX_TEST_EXE_SUFFIX}"
+ local encoder="${LIBAOM_BIN_PATH}/simple_encoder${AOM_TEST_EXE_SUFFIX}"
local codec="$1"
- local output_file="${VPX_TEST_OUTPUT_DIR}/simple_encoder_${codec}.ivf"
+ local output_file="${AOM_TEST_OUTPUT_DIR}/simple_encoder_${codec}.ivf"
if [ ! -x "${encoder}" ]; then
elog "${encoder} does not exist or is not executable."
return 1
fi
- eval "${VPX_TEST_PREFIX}" "${encoder}" "${codec}" "${YUV_RAW_INPUT_WIDTH}" \
+ eval "${AOM_TEST_PREFIX}" "${encoder}" "${codec}" "${YUV_RAW_INPUT_WIDTH}" \
"${YUV_RAW_INPUT_HEIGHT}" "${YUV_RAW_INPUT}" "${output_file}" 9999 0 100 \
${devnull}
[ -e "${output_file}" ] || return 1
}
-simple_encoder_vp8() {
- if [ "$(vp8_encode_available)" = "yes" ]; then
- simple_encoder vp8 || return 1
+simple_encoder_aom() {
+ if [ "$(aom_encode_available)" = "yes" ]; then
+ simple_encoder aom || return 1
fi
}
-simple_encoder_vp9() {
- if [ "$(vp9_encode_available)" = "yes" ]; then
- simple_encoder vp9 || return 1
+# TODO(tomfinegan): Add a frame limit param to simple_encoder and enable this
+# test. AV1 is just too slow right now: This test takes 4m30s+ on a fast
+# machine.
+DISABLED_simple_encoder_av1() {
+ if [ "$(av1_encode_available)" = "yes" ]; then
+ simple_encoder av1 || return 1
fi
}
-simple_encoder_tests="simple_encoder_vp8
- simple_encoder_vp9"
+simple_encoder_tests="simple_encoder_aom
+ DISABLED_simple_encoder_av1"
run_tests simple_encoder_verify_environment "${simple_encoder_tests}"
diff --git a/test/subtract_test.cc b/test/subtract_test.cc
index a6ba557..e1bf16c 100644
--- a/test/subtract_test.cc
+++ b/test/subtract_test.cc
@@ -10,16 +10,16 @@
#include "third_party/googletest/src/include/gtest/gtest.h"
-#include "./vpx_config.h"
-#include "./vpx_dsp_rtcd.h"
+#include "./aom_config.h"
+#include "./aom_dsp_rtcd.h"
#include "test/acm_random.h"
#include "test/clear_system_state.h"
#include "test/register_state_check.h"
#include "test/util.h"
-#if CONFIG_VP10
+#if CONFIG_AV1
#include "av1/common/blockd.h"
#endif
-#include "aom_mem/vpx_mem.h"
+#include "aom_mem/aom_mem.h"
#include "aom_ports/mem.h"
#define USE_SPEED_TEST (0)
@@ -31,14 +31,14 @@
namespace {
-class VP9SubtractBlockTest : public ::testing::TestWithParam<SubtractFunc> {
+class AV1SubtractBlockTest : public ::testing::TestWithParam<SubtractFunc> {
public:
virtual void TearDown() { libaom_test::ClearSystemState(); }
};
using libaom_test::ACMRandom;
-TEST_P(VP9SubtractBlockTest, SimpleSubtract) {
+TEST_P(AV1SubtractBlockTest, SimpleSubtract) {
ACMRandom rnd(ACMRandom::DeterministicSeed());
// FIXME(rbultje) split in its own file
@@ -47,11 +47,11 @@
const int block_width = 4 * num_4x4_blocks_wide_lookup[bsize];
const int block_height = 4 * num_4x4_blocks_high_lookup[bsize];
int16_t *diff = reinterpret_cast<int16_t *>(
- vpx_memalign(16, sizeof(*diff) * block_width * block_height * 2));
+ aom_memalign(16, sizeof(*diff) * block_width * block_height * 2));
uint8_t *pred = reinterpret_cast<uint8_t *>(
- vpx_memalign(16, block_width * block_height * 2));
+ aom_memalign(16, block_width * block_height * 2));
uint8_t *src = reinterpret_cast<uint8_t *>(
- vpx_memalign(16, block_width * block_height * 2));
+ aom_memalign(16, block_width * block_height * 2));
for (int n = 0; n < 100; n++) {
for (int r = 0; r < block_height; ++r) {
@@ -84,26 +84,26 @@
}
}
}
- vpx_free(diff);
- vpx_free(pred);
- vpx_free(src);
+ aom_free(diff);
+ aom_free(pred);
+ aom_free(src);
}
}
-INSTANTIATE_TEST_CASE_P(C, VP9SubtractBlockTest,
- ::testing::Values(vpx_subtract_block_c));
+INSTANTIATE_TEST_CASE_P(C, AV1SubtractBlockTest,
+ ::testing::Values(aom_subtract_block_c));
#if HAVE_SSE2
-INSTANTIATE_TEST_CASE_P(SSE2, VP9SubtractBlockTest,
- ::testing::Values(vpx_subtract_block_sse2));
+INSTANTIATE_TEST_CASE_P(SSE2, AV1SubtractBlockTest,
+ ::testing::Values(aom_subtract_block_sse2));
#endif
#if HAVE_NEON
-INSTANTIATE_TEST_CASE_P(NEON, VP9SubtractBlockTest,
- ::testing::Values(vpx_subtract_block_neon));
+INSTANTIATE_TEST_CASE_P(NEON, AV1SubtractBlockTest,
+ ::testing::Values(aom_subtract_block_neon));
#endif
#if HAVE_MSA
-INSTANTIATE_TEST_CASE_P(MSA, VP9SubtractBlockTest,
- ::testing::Values(vpx_subtract_block_msa));
+INSTANTIATE_TEST_CASE_P(MSA, AV1SubtractBlockTest,
+ ::testing::Values(aom_subtract_block_msa));
#endif
typedef void (*HBDSubtractFunc)(int rows, int cols, int16_t *diff_ptr,
@@ -118,13 +118,13 @@
// <width, height, bit_dpeth, subtract>
typedef tuple<int, int, int, HBDSubtractFunc> Params;
-#if CONFIG_VP9_HIGHBITDEPTH
-class VP10HBDSubtractBlockTest : public ::testing::TestWithParam<Params> {
+#if CONFIG_AOM_HIGHBITDEPTH
+class AV1HBDSubtractBlockTest : public ::testing::TestWithParam<Params> {
public:
virtual void SetUp() {
block_width_ = GET_PARAM(0);
block_height_ = GET_PARAM(1);
- bit_depth_ = static_cast<vpx_bit_depth_t>(GET_PARAM(2));
+ bit_depth_ = static_cast<aom_bit_depth_t>(GET_PARAM(2));
func_ = GET_PARAM(3);
rnd_.Reset(ACMRandom::DeterministicSeed());
@@ -132,17 +132,17 @@
const size_t max_width = 128;
const size_t max_block_size = max_width * max_width;
src_ = CONVERT_TO_BYTEPTR(reinterpret_cast<uint16_t *>(
- vpx_memalign(16, max_block_size * sizeof(uint16_t))));
+ aom_memalign(16, max_block_size * sizeof(uint16_t))));
pred_ = CONVERT_TO_BYTEPTR(reinterpret_cast<uint16_t *>(
- vpx_memalign(16, max_block_size * sizeof(uint16_t))));
+ aom_memalign(16, max_block_size * sizeof(uint16_t))));
diff_ = reinterpret_cast<int16_t *>(
- vpx_memalign(16, max_block_size * sizeof(int16_t)));
+ aom_memalign(16, max_block_size * sizeof(int16_t)));
}
virtual void TearDown() {
- vpx_free(CONVERT_TO_SHORTPTR(src_));
- vpx_free(CONVERT_TO_SHORTPTR(pred_));
- vpx_free(diff_);
+ aom_free(CONVERT_TO_SHORTPTR(src_));
+ aom_free(CONVERT_TO_SHORTPTR(pred_));
+ aom_free(diff_);
}
protected:
@@ -153,14 +153,14 @@
ACMRandom rnd_;
int block_height_;
int block_width_;
- vpx_bit_depth_t bit_depth_;
+ aom_bit_depth_t bit_depth_;
HBDSubtractFunc func_;
uint8_t *src_;
uint8_t *pred_;
int16_t *diff_;
};
-void VP10HBDSubtractBlockTest::RunForSpeed() {
+void AV1HBDSubtractBlockTest::RunForSpeed() {
const int test_num = 200000;
const int max_width = 128;
const int max_block_size = max_width * max_width;
@@ -178,7 +178,7 @@
}
}
-void VP10HBDSubtractBlockTest::CheckResult() {
+void AV1HBDSubtractBlockTest::CheckResult() {
const int test_num = 100;
const int max_width = 128;
const int max_block_size = max_width * max_width;
@@ -205,47 +205,47 @@
}
}
-TEST_P(VP10HBDSubtractBlockTest, CheckResult) { CheckResult(); }
+TEST_P(AV1HBDSubtractBlockTest, CheckResult) { CheckResult(); }
#if USE_SPEED_TEST
-TEST_P(VP10HBDSubtractBlockTest, CheckSpeed) { RunForSpeed(); }
+TEST_P(AV1HBDSubtractBlockTest, CheckSpeed) { RunForSpeed(); }
#endif // USE_SPEED_TEST
#if HAVE_SSE2
INSTANTIATE_TEST_CASE_P(
- SSE2, VP10HBDSubtractBlockTest,
- ::testing::Values(make_tuple(4, 4, 12, vpx_highbd_subtract_block_sse2),
- make_tuple(4, 4, 12, vpx_highbd_subtract_block_c),
- make_tuple(4, 8, 12, vpx_highbd_subtract_block_sse2),
- make_tuple(4, 8, 12, vpx_highbd_subtract_block_c),
- make_tuple(8, 4, 12, vpx_highbd_subtract_block_sse2),
- make_tuple(8, 4, 12, vpx_highbd_subtract_block_c),
- make_tuple(8, 8, 12, vpx_highbd_subtract_block_sse2),
- make_tuple(8, 8, 12, vpx_highbd_subtract_block_c),
- make_tuple(8, 16, 12, vpx_highbd_subtract_block_sse2),
- make_tuple(8, 16, 12, vpx_highbd_subtract_block_c),
- make_tuple(16, 8, 12, vpx_highbd_subtract_block_sse2),
- make_tuple(16, 8, 12, vpx_highbd_subtract_block_c),
- make_tuple(16, 16, 12, vpx_highbd_subtract_block_sse2),
- make_tuple(16, 16, 12, vpx_highbd_subtract_block_c),
- make_tuple(16, 32, 12, vpx_highbd_subtract_block_sse2),
- make_tuple(16, 32, 12, vpx_highbd_subtract_block_c),
- make_tuple(32, 16, 12, vpx_highbd_subtract_block_sse2),
- make_tuple(32, 16, 12, vpx_highbd_subtract_block_c),
- make_tuple(32, 32, 12, vpx_highbd_subtract_block_sse2),
- make_tuple(32, 32, 12, vpx_highbd_subtract_block_c),
- make_tuple(32, 64, 12, vpx_highbd_subtract_block_sse2),
- make_tuple(32, 64, 12, vpx_highbd_subtract_block_c),
- make_tuple(64, 32, 12, vpx_highbd_subtract_block_sse2),
- make_tuple(64, 32, 12, vpx_highbd_subtract_block_c),
- make_tuple(64, 64, 12, vpx_highbd_subtract_block_sse2),
- make_tuple(64, 64, 12, vpx_highbd_subtract_block_c),
- make_tuple(64, 128, 12, vpx_highbd_subtract_block_sse2),
- make_tuple(64, 128, 12, vpx_highbd_subtract_block_c),
- make_tuple(128, 64, 12, vpx_highbd_subtract_block_sse2),
- make_tuple(128, 64, 12, vpx_highbd_subtract_block_c),
- make_tuple(128, 128, 12, vpx_highbd_subtract_block_sse2),
- make_tuple(128, 128, 12, vpx_highbd_subtract_block_c)));
+ SSE2, AV1HBDSubtractBlockTest,
+ ::testing::Values(make_tuple(4, 4, 12, aom_highbd_subtract_block_sse2),
+ make_tuple(4, 4, 12, aom_highbd_subtract_block_c),
+ make_tuple(4, 8, 12, aom_highbd_subtract_block_sse2),
+ make_tuple(4, 8, 12, aom_highbd_subtract_block_c),
+ make_tuple(8, 4, 12, aom_highbd_subtract_block_sse2),
+ make_tuple(8, 4, 12, aom_highbd_subtract_block_c),
+ make_tuple(8, 8, 12, aom_highbd_subtract_block_sse2),
+ make_tuple(8, 8, 12, aom_highbd_subtract_block_c),
+ make_tuple(8, 16, 12, aom_highbd_subtract_block_sse2),
+ make_tuple(8, 16, 12, aom_highbd_subtract_block_c),
+ make_tuple(16, 8, 12, aom_highbd_subtract_block_sse2),
+ make_tuple(16, 8, 12, aom_highbd_subtract_block_c),
+ make_tuple(16, 16, 12, aom_highbd_subtract_block_sse2),
+ make_tuple(16, 16, 12, aom_highbd_subtract_block_c),
+ make_tuple(16, 32, 12, aom_highbd_subtract_block_sse2),
+ make_tuple(16, 32, 12, aom_highbd_subtract_block_c),
+ make_tuple(32, 16, 12, aom_highbd_subtract_block_sse2),
+ make_tuple(32, 16, 12, aom_highbd_subtract_block_c),
+ make_tuple(32, 32, 12, aom_highbd_subtract_block_sse2),
+ make_tuple(32, 32, 12, aom_highbd_subtract_block_c),
+ make_tuple(32, 64, 12, aom_highbd_subtract_block_sse2),
+ make_tuple(32, 64, 12, aom_highbd_subtract_block_c),
+ make_tuple(64, 32, 12, aom_highbd_subtract_block_sse2),
+ make_tuple(64, 32, 12, aom_highbd_subtract_block_c),
+ make_tuple(64, 64, 12, aom_highbd_subtract_block_sse2),
+ make_tuple(64, 64, 12, aom_highbd_subtract_block_c),
+ make_tuple(64, 128, 12, aom_highbd_subtract_block_sse2),
+ make_tuple(64, 128, 12, aom_highbd_subtract_block_c),
+ make_tuple(128, 64, 12, aom_highbd_subtract_block_sse2),
+ make_tuple(128, 64, 12, aom_highbd_subtract_block_c),
+ make_tuple(128, 128, 12, aom_highbd_subtract_block_sse2),
+ make_tuple(128, 128, 12, aom_highbd_subtract_block_c)));
#endif // HAVE_SSE2
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#endif // CONFIG_AOM_HIGHBITDEPTH
} // namespace
diff --git a/test/sum_squares_test.cc b/test/sum_squares_test.cc
index c4ddf57..d651072 100644
--- a/test/sum_squares_test.cc
+++ b/test/sum_squares_test.cc
@@ -14,8 +14,8 @@
#include "third_party/googletest/src/include/gtest/gtest.h"
-#include "./vpx_config.h"
-#include "./vpx_dsp_rtcd.h"
+#include "./aom_config.h"
+#include "./aom_dsp_rtcd.h"
#include "aom_ports/mem.h"
#include "test/acm_random.h"
#include "test/clear_system_state.h"
@@ -120,8 +120,8 @@
INSTANTIATE_TEST_CASE_P(
SSE2, SumSquaresTest,
- ::testing::Values(TestFuncs(&vpx_sum_squares_2d_i16_c,
- &vpx_sum_squares_2d_i16_sse2)));
+ ::testing::Values(TestFuncs(&aom_sum_squares_2d_i16_c,
+ &aom_sum_squares_2d_i16_sse2)));
#endif // HAVE_SSE2
@@ -180,7 +180,7 @@
#if HAVE_SSE2
INSTANTIATE_TEST_CASE_P(SSE2, SumSquares1DTest,
::testing::Values(TestFuncs1D(
- vpx_sum_squares_i16_c, vpx_sum_squares_i16_sse2)));
+ aom_sum_squares_i16_c, aom_sum_squares_i16_sse2)));
#endif // HAVE_SSE2
} // namespace
diff --git a/test/superframe_test.cc b/test/superframe_test.cc
index 2f7132a..0eae40a 100644
--- a/test/superframe_test.cc
+++ b/test/superframe_test.cc
@@ -40,7 +40,7 @@
SetMode(mode);
sf_count_ = 0;
sf_count_max_ = INT_MAX;
- is_vp10_style_superframe_ = syntax;
+ is_av1_style_superframe_ = syntax;
n_tile_cols_ = std::tr1::get<kTileCols>(input);
n_tile_rows_ = std::tr1::get<kTileRows>(input);
}
@@ -50,23 +50,22 @@
virtual void PreEncodeFrameHook(libaom_test::VideoSource *video,
libaom_test::Encoder *encoder) {
if (video->frame() == 1) {
- encoder->Control(VP8E_SET_ENABLEAUTOALTREF, 1);
- encoder->Control(VP8E_SET_CPUUSED, 2);
- encoder->Control(VP9E_SET_TILE_COLUMNS, n_tile_cols_);
- encoder->Control(VP9E_SET_TILE_ROWS, n_tile_rows_);
+ encoder->Control(AOME_SET_ENABLEAUTOALTREF, 1);
+ encoder->Control(AOME_SET_CPUUSED, 2);
+ encoder->Control(AV1E_SET_TILE_COLUMNS, n_tile_cols_);
+ encoder->Control(AV1E_SET_TILE_ROWS, n_tile_rows_);
}
}
- virtual const vpx_codec_cx_pkt_t *MutateEncoderOutputHook(
- const vpx_codec_cx_pkt_t *pkt) {
- if (pkt->kind != VPX_CODEC_CX_FRAME_PKT) return pkt;
+ virtual const aom_codec_cx_pkt_t *MutateEncoderOutputHook(
+ const aom_codec_cx_pkt_t *pkt) {
+ if (pkt->kind != AOM_CODEC_CX_FRAME_PKT) return pkt;
const uint8_t *buffer = reinterpret_cast<uint8_t *>(pkt->data.frame.buf);
const uint8_t marker = buffer[pkt->data.frame.sz - 1];
const int frames = (marker & 0x7) + 1;
const int mag = ((marker >> 3) & 3) + 1;
- const unsigned int index_sz =
- 2 + mag * (frames - is_vp10_style_superframe_);
+ const unsigned int index_sz = 2 + mag * (frames - is_av1_style_superframe_);
if ((marker & 0xe0) == 0xc0 && pkt->data.frame.sz >= index_sz &&
buffer[pkt->data.frame.sz - index_sz] == marker) {
// frame is a superframe. strip off the index.
@@ -88,12 +87,12 @@
return pkt;
}
- int is_vp10_style_superframe_;
+ int is_av1_style_superframe_;
int sf_count_;
int sf_count_max_;
- vpx_codec_cx_pkt_t modified_pkt_;
+ aom_codec_cx_pkt_t modified_pkt_;
uint8_t *modified_buf_;
- vpx_codec_pts_t last_sf_pts_;
+ aom_codec_pts_t last_sf_pts_;
private:
int n_tile_cols_;
@@ -126,7 +125,7 @@
const int tile_col_values[] = { 1, 2, 32 };
#endif
const int tile_row_values[] = { 1, 2, 32 };
-VP10_INSTANTIATE_TEST_CASE(
+AV1_INSTANTIATE_TEST_CASE(
SuperframeTest,
::testing::Combine(::testing::Values(::libaom_test::kTwoPassGood),
::testing::Values(1),
@@ -134,7 +133,7 @@
::testing::ValuesIn(tile_row_values)));
#else
#if !CONFIG_ANS
-VP10_INSTANTIATE_TEST_CASE(
+AV1_INSTANTIATE_TEST_CASE(
SuperframeTest,
::testing::Combine(::testing::Values(::libaom_test::kTwoPassGood),
::testing::Values(1), ::testing::Values(0),
diff --git a/test/test-data.mk b/test/test-data.mk
index fd33627..3936024 100644
--- a/test/test-data.mk
+++ b/test/test-data.mk
@@ -18,99 +18,49 @@
LIBAOM_TEST_DATA-$(CONFIG_ENCODERS) += park_joy_90p_8_444.y4m
LIBAOM_TEST_DATA-$(CONFIG_ENCODERS) += park_joy_90p_8_440.yuv
-LIBAOM_TEST_DATA-$(CONFIG_VP10_ENCODER) += desktop_credits.y4m
-LIBAOM_TEST_DATA-$(CONFIG_VP10_ENCODER) += niklas_1280_720_30.y4m
-LIBAOM_TEST_DATA-$(CONFIG_VP10_ENCODER) += rush_hour_444.y4m
-LIBAOM_TEST_DATA-$(CONFIG_VP10_ENCODER) += screendata.y4m
+LIBAOM_TEST_DATA-$(CONFIG_AV1_ENCODER) += desktop_credits.y4m
+LIBAOM_TEST_DATA-$(CONFIG_AV1_ENCODER) += niklas_1280_720_30.y4m
+LIBAOM_TEST_DATA-$(CONFIG_AV1_ENCODER) += rush_hour_444.y4m
+LIBAOM_TEST_DATA-$(CONFIG_AV1_ENCODER) += screendata.y4m
ifeq ($(CONFIG_DECODE_PERF_TESTS),yes)
# Encode / Decode test
-LIBAOM_TEST_DATA-$(CONFIG_VP10_ENCODER) += niklas_1280_720_30.yuv
-# BBB VP9 streams
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-bbb_426x240_tile_1x1_180kbps.webm
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-bbb_640x360_tile_1x2_337kbps.webm
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-bbb_854x480_tile_1x2_651kbps.webm
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-bbb_1280x720_tile_1x4_1310kbps.webm
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-bbb_1920x1080_tile_1x1_2581kbps.webm
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-bbb_1920x1080_tile_1x4_2586kbps.webm
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-bbb_1920x1080_tile_1x4_fpm_2304kbps.webm
-# Sintel VP9 streams
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-sintel_426x182_tile_1x1_171kbps.webm
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-sintel_640x272_tile_1x2_318kbps.webm
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-sintel_854x364_tile_1x2_621kbps.webm
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-sintel_1280x546_tile_1x4_1257kbps.webm
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-sintel_1920x818_tile_1x4_fpm_2279kbps.webm
-# TOS VP9 streams
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-tos_426x178_tile_1x1_181kbps.webm
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-tos_640x266_tile_1x2_336kbps.webm
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-tos_854x356_tile_1x2_656kbps.webm
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-tos_854x356_tile_1x2_fpm_546kbps.webm
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-tos_1280x534_tile_1x4_1306kbps.webm
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-tos_1280x534_tile_1x4_fpm_952kbps.webm
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-tos_1920x800_tile_1x4_fpm_2335kbps.webm
+LIBAOM_TEST_DATA-$(CONFIG_AV1_ENCODER) += niklas_1280_720_30.yuv
+# BBB AV1 streams
+LIBAOM_TEST_DATA-$(CONFIG_AV1_DECODER) += av10-2-bbb_426x240_tile_1x1_180kbps.webm
+LIBAOM_TEST_DATA-$(CONFIG_AV1_DECODER) += av10-2-bbb_640x360_tile_1x2_337kbps.webm
+LIBAOM_TEST_DATA-$(CONFIG_AV1_DECODER) += av10-2-bbb_854x480_tile_1x2_651kbps.webm
+LIBAOM_TEST_DATA-$(CONFIG_AV1_DECODER) += av10-2-bbb_1280x720_tile_1x4_1310kbps.webm
+LIBAOM_TEST_DATA-$(CONFIG_AV1_DECODER) += av10-2-bbb_1920x1080_tile_1x1_2581kbps.webm
+LIBAOM_TEST_DATA-$(CONFIG_AV1_DECODER) += av10-2-bbb_1920x1080_tile_1x4_2586kbps.webm
+LIBAOM_TEST_DATA-$(CONFIG_AV1_DECODER) += av10-2-bbb_1920x1080_tile_1x4_fpm_2304kbps.webm
+# Sintel AV1 streams
+LIBAOM_TEST_DATA-$(CONFIG_AV1_DECODER) += av10-2-sintel_426x182_tile_1x1_171kbps.webm
+LIBAOM_TEST_DATA-$(CONFIG_AV1_DECODER) += av10-2-sintel_640x272_tile_1x2_318kbps.webm
+LIBAOM_TEST_DATA-$(CONFIG_AV1_DECODER) += av10-2-sintel_854x364_tile_1x2_621kbps.webm
+LIBAOM_TEST_DATA-$(CONFIG_AV1_DECODER) += av10-2-sintel_1280x546_tile_1x4_1257kbps.webm
+LIBAOM_TEST_DATA-$(CONFIG_AV1_DECODER) += av10-2-sintel_1920x818_tile_1x4_fpm_2279kbps.webm
+# TOS AV1 streams
+LIBAOM_TEST_DATA-$(CONFIG_AV1_DECODER) += av10-2-tos_426x178_tile_1x1_181kbps.webm
+LIBAOM_TEST_DATA-$(CONFIG_AV1_DECODER) += av10-2-tos_640x266_tile_1x2_336kbps.webm
+LIBAOM_TEST_DATA-$(CONFIG_AV1_DECODER) += av10-2-tos_854x356_tile_1x2_656kbps.webm
+LIBAOM_TEST_DATA-$(CONFIG_AV1_DECODER) += av10-2-tos_854x356_tile_1x2_fpm_546kbps.webm
+LIBAOM_TEST_DATA-$(CONFIG_AV1_DECODER) += av10-2-tos_1280x534_tile_1x4_1306kbps.webm
+LIBAOM_TEST_DATA-$(CONFIG_AV1_DECODER) += av10-2-tos_1280x534_tile_1x4_fpm_952kbps.webm
+LIBAOM_TEST_DATA-$(CONFIG_AV1_DECODER) += av10-2-tos_1920x800_tile_1x4_fpm_2335kbps.webm
endif # CONFIG_DECODE_PERF_TESTS
ifeq ($(CONFIG_ENCODE_PERF_TESTS),yes)
-LIBAOM_TEST_DATA-$(CONFIG_VP10_ENCODER) += desktop_640_360_30.yuv
-LIBAOM_TEST_DATA-$(CONFIG_VP10_ENCODER) += kirland_640_480_30.yuv
-LIBAOM_TEST_DATA-$(CONFIG_VP10_ENCODER) += macmarcomoving_640_480_30.yuv
-LIBAOM_TEST_DATA-$(CONFIG_VP10_ENCODER) += macmarcostationary_640_480_30.yuv
-LIBAOM_TEST_DATA-$(CONFIG_VP10_ENCODER) += niklas_1280_720_30.yuv
-LIBAOM_TEST_DATA-$(CONFIG_VP10_ENCODER) += niklas_640_480_30.yuv
-LIBAOM_TEST_DATA-$(CONFIG_VP10_ENCODER) += tacomanarrows_640_480_30.yuv
-LIBAOM_TEST_DATA-$(CONFIG_VP10_ENCODER) += tacomasmallcameramovement_640_480_30.yuv
-LIBAOM_TEST_DATA-$(CONFIG_VP10_ENCODER) += thaloundeskmtg_640_480_30.yuv
+LIBAOM_TEST_DATA-$(CONFIG_AV1_ENCODER) += desktop_640_360_30.yuv
+LIBAOM_TEST_DATA-$(CONFIG_AV1_ENCODER) += kirland_640_480_30.yuv
+LIBAOM_TEST_DATA-$(CONFIG_AV1_ENCODER) += macmarcomoving_640_480_30.yuv
+LIBAOM_TEST_DATA-$(CONFIG_AV1_ENCODER) += macmarcostationary_640_480_30.yuv
+LIBAOM_TEST_DATA-$(CONFIG_AV1_ENCODER) += niklas_1280_720_30.yuv
+LIBAOM_TEST_DATA-$(CONFIG_AV1_ENCODER) += niklas_640_480_30.yuv
+LIBAOM_TEST_DATA-$(CONFIG_AV1_ENCODER) += tacomanarrows_640_480_30.yuv
+LIBAOM_TEST_DATA-$(CONFIG_AV1_ENCODER) += tacomasmallcameramovement_640_480_30.yuv
+LIBAOM_TEST_DATA-$(CONFIG_AV1_ENCODER) += thaloundeskmtg_640_480_30.yuv
endif # CONFIG_ENCODE_PERF_TESTS
# sort and remove duplicates
LIBAOM_TEST_DATA-yes := $(sort $(LIBAOM_TEST_DATA-yes))
-
-# VP9 dynamic resizing test (decoder)
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-21-resize_inter_320x180_5_1-2.webm
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-21-resize_inter_320x180_5_1-2.webm.md5
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-21-resize_inter_320x180_5_3-4.webm
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-21-resize_inter_320x180_5_3-4.webm.md5
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-21-resize_inter_320x180_7_1-2.webm
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-21-resize_inter_320x180_7_1-2.webm.md5
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-21-resize_inter_320x180_7_3-4.webm
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-21-resize_inter_320x180_7_3-4.webm.md5
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-21-resize_inter_320x240_5_1-2.webm
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-21-resize_inter_320x240_5_1-2.webm.md5
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-21-resize_inter_320x240_5_3-4.webm
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-21-resize_inter_320x240_5_3-4.webm.md5
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-21-resize_inter_320x240_7_1-2.webm
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-21-resize_inter_320x240_7_1-2.webm.md5
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-21-resize_inter_320x240_7_3-4.webm
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-21-resize_inter_320x240_7_3-4.webm.md5
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-21-resize_inter_640x360_5_1-2.webm
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-21-resize_inter_640x360_5_1-2.webm.md5
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-21-resize_inter_640x360_5_3-4.webm
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-21-resize_inter_640x360_5_3-4.webm.md5
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-21-resize_inter_640x360_7_1-2.webm
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-21-resize_inter_640x360_7_1-2.webm.md5
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-21-resize_inter_640x360_7_3-4.webm
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-21-resize_inter_640x360_7_3-4.webm.md5
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-21-resize_inter_640x480_5_1-2.webm
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-21-resize_inter_640x480_5_1-2.webm.md5
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-21-resize_inter_640x480_5_3-4.webm
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-21-resize_inter_640x480_5_3-4.webm.md5
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-21-resize_inter_640x480_7_1-2.webm
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-21-resize_inter_640x480_7_1-2.webm.md5
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-21-resize_inter_640x480_7_3-4.webm
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-21-resize_inter_640x480_7_3-4.webm.md5
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-21-resize_inter_1280x720_5_1-2.webm
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-21-resize_inter_1280x720_5_1-2.webm.md5
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-21-resize_inter_1280x720_5_3-4.webm
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-21-resize_inter_1280x720_5_3-4.webm.md5
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-21-resize_inter_1280x720_7_1-2.webm
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-21-resize_inter_1280x720_7_1-2.webm.md5
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-21-resize_inter_1280x720_7_3-4.webm
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-21-resize_inter_1280x720_7_3-4.webm.md5
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-21-resize_inter_1920x1080_5_1-2.webm
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-21-resize_inter_1920x1080_5_1-2.webm.md5
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-21-resize_inter_1920x1080_5_3-4.webm
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-21-resize_inter_1920x1080_5_3-4.webm.md5
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-21-resize_inter_1920x1080_7_1-2.webm
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-21-resize_inter_1920x1080_7_1-2.webm.md5
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-21-resize_inter_1920x1080_7_3-4.webm
-LIBAOM_TEST_DATA-$(CONFIG_VP9_DECODER) += vp90-2-21-resize_inter_1920x1080_7_3-4.webm.md5
diff --git a/test/test-data.sha1 b/test/test-data.sha1
index c958444..ac4e506 100644
--- a/test/test-data.sha1
+++ b/test/test-data.sha1
@@ -1,19 +1,19 @@
d5dfb0151c9051f8c85999255645d7a23916d3c0 *hantro_collage_w352h288.yuv
b87815bf86020c592ccc7a846ba2e28ec8043902 *hantro_odd.yuv
-76024eb753cdac6a5e5703aaea189d35c3c30ac7 *invalid-vp90-2-00-quantizer-00.webm.ivf.s5861_r01-05_b6-.v2.ivf
-7448d8798a4380162d4b56f9b452e2f6f9e24e7a *invalid-vp90-2-00-quantizer-00.webm.ivf.s5861_r01-05_b6-.v2.ivf.res
-83f50908c8dc0ef8760595447a2ff7727489542e *invalid-vp90-2-00-quantizer-11.webm.ivf.s52984_r01-05_b6-.ivf
-456d1493e52d32a5c30edf44a27debc1fa6b253a *invalid-vp90-2-00-quantizer-11.webm.ivf.s52984_r01-05_b6-.ivf.res
-c123d1f9f02fb4143abb5e271916e3a3080de8f6 *invalid-vp90-2-00-quantizer-11.webm.ivf.s52984_r01-05_b6-z.ivf
-456d1493e52d32a5c30edf44a27debc1fa6b253a *invalid-vp90-2-00-quantizer-11.webm.ivf.s52984_r01-05_b6-z.ivf.res
-fe346136b9b8c1e6f6084cc106485706915795e4 *invalid-vp90-01-v3.webm
-5d9474c0309b7ca09a182d888f73b37a8fe1362c *invalid-vp90-01-v3.webm.res
-d78e2fceba5ac942246503ec8366f879c4775ca5 *invalid-vp90-02-v2.webm
-8e2eff4af87d2b561cce2365713269e301457ef3 *invalid-vp90-02-v2.webm.res
-df1a1453feb3c00d7d89746c7003b4163523bff3 *invalid-vp90-03-v3.webm
-4935c62becc68c13642a03db1e6d3e2331c1c612 *invalid-vp90-03-v3.webm.res
-d637297561dd904eb2c97a9015deeb31c4a1e8d2 *invalid-vp90-2-08-tile_1x4_frame_parallel_all_key.webm
-3a204bdbeaa3c6458b77bcebb8366d107267f55d *invalid-vp90-2-08-tile_1x4_frame_parallel_all_key.webm.res
+76024eb753cdac6a5e5703aaea189d35c3c30ac7 *invalid-av10-2-00-quantizer-00.webm.ivf.s5861_r01-05_b6-.v2.ivf
+7448d8798a4380162d4b56f9b452e2f6f9e24e7a *invalid-av10-2-00-quantizer-00.webm.ivf.s5861_r01-05_b6-.v2.ivf.res
+83f50908c8dc0ef8760595447a2ff7727489542e *invalid-av10-2-00-quantizer-11.webm.ivf.s52984_r01-05_b6-.ivf
+456d1493e52d32a5c30edf44a27debc1fa6b253a *invalid-av10-2-00-quantizer-11.webm.ivf.s52984_r01-05_b6-.ivf.res
+c123d1f9f02fb4143abb5e271916e3a3080de8f6 *invalid-av10-2-00-quantizer-11.webm.ivf.s52984_r01-05_b6-z.ivf
+456d1493e52d32a5c30edf44a27debc1fa6b253a *invalid-av10-2-00-quantizer-11.webm.ivf.s52984_r01-05_b6-z.ivf.res
+fe346136b9b8c1e6f6084cc106485706915795e4 *invalid-av10-01-v3.webm
+5d9474c0309b7ca09a182d888f73b37a8fe1362c *invalid-av10-01-v3.webm.res
+d78e2fceba5ac942246503ec8366f879c4775ca5 *invalid-av10-02-v2.webm
+8e2eff4af87d2b561cce2365713269e301457ef3 *invalid-av10-02-v2.webm.res
+df1a1453feb3c00d7d89746c7003b4163523bff3 *invalid-av10-03-v3.webm
+4935c62becc68c13642a03db1e6d3e2331c1c612 *invalid-av10-03-v3.webm.res
+d637297561dd904eb2c97a9015deeb31c4a1e8d2 *invalid-av10-2-08-tile_1x4_frame_parallel_all_key.webm
+3a204bdbeaa3c6458b77bcebb8366d107267f55d *invalid-av10-2-08-tile_1x4_frame_parallel_all_key.webm.res
a432f96ff0a787268e2f94a8092ab161a18d1b06 *park_joy_90p_10_420.y4m
0b194cc312c3a2e84d156a221b0a5eb615dfddc5 *park_joy_90p_10_422.y4m
ff0e0a21dc2adc95b8c1b37902713700655ced17 *park_joy_90p_10_444.y4m
@@ -38,30 +38,30 @@
9a70e8b7d14fba9234d0e51dce876635413ce444 *thaloundeskmtg_640_480_30.yuv
e7d315dbf4f3928779e0dc624311196d44491d32 *niklas_1280_720_30.yuv
717da707afcaa1f692ff1946f291054eb75a4f06 *screendata.y4m
-b7c1296630cdf1a7ef493d15ff4f9eb2999202f6 *invalid-vp90-2-08-tile_1x2_frame_parallel.webm.ivf.s47039_r01-05_b6-.ivf
-0a3884edb3fd8f9d9b500223e650f7de257b67d8 *invalid-vp90-2-08-tile_1x2_frame_parallel.webm.ivf.s47039_r01-05_b6-.ivf.res
-359e138dfb66863828397b77000ea7a83c844d02 *invalid-vp90-2-08-tile_1x8_frame_parallel.webm.ivf.s288_r01-05_b6-.ivf
-bbd33de01c17b165b4ce00308e8a19a942023ab8 *invalid-vp90-2-08-tile_1x8_frame_parallel.webm.ivf.s288_r01-05_b6-.ivf.res
-fac89b5735be8a86b0dc05159f996a5c3208ae32 *invalid-vp90-2-09-aq2.webm.ivf.s3984_r01-05_b6-.v2.ivf
-0a3884edb3fd8f9d9b500223e650f7de257b67d8 *invalid-vp90-2-09-aq2.webm.ivf.s3984_r01-05_b6-.v2.ivf.res
-4506dfdcdf8ee4250924b075a0dcf1f070f72e5a *invalid-vp90-2-09-subpixel-00.ivf.s19552_r01-05_b6-.v2.ivf
-bcdedaf168ac225575468fda77502d2dc9fd5baa *invalid-vp90-2-09-subpixel-00.ivf.s19552_r01-05_b6-.v2.ivf.res
-b03c408cf23158638da18dbc3323b99a1635c68a *invalid-vp90-2-12-droppable_1.ivf.s3676_r01-05_b6-.ivf
-0a3884edb3fd8f9d9b500223e650f7de257b67d8 *invalid-vp90-2-12-droppable_1.ivf.s3676_r01-05_b6-.ivf.res
-5e67e24e7f53fd189e565513cef8519b1bd6c712 *invalid-vp90-2-05-resize.ivf.s59293_r01-05_b6-.ivf
-741158f67c0d9d23726624d06bdc482ad368afc9 *invalid-vp90-2-05-resize.ivf.s59293_r01-05_b6-.ivf.res
-8b1f7bf7e86c0976d277f60e8fcd9539e75a079a *invalid-vp90-2-09-subpixel-00.ivf.s20492_r01-05_b6-.v2.ivf
-9c6bdf048fb2e66f07d4b4db5b32e6f303bd6109 *invalid-vp90-2-09-subpixel-00.ivf.s20492_r01-05_b6-.v2.ivf.res
-552e372e9b78127389fb06b34545df2cec15ba6d *invalid-vp91-2-mixedrefcsp-444to420.ivf
-a61774cf03fc584bd9f0904fc145253bb8ea6c4c *invalid-vp91-2-mixedrefcsp-444to420.ivf.res
-812d05a64a0d83c1b504d0519927ddc5a2cdb273 *invalid-vp90-2-12-droppable_1.ivf.s73804_r01-05_b6-.ivf
-1e472baaf5f6113459f0399a38a5a5e68d17799d *invalid-vp90-2-12-droppable_1.ivf.s73804_r01-05_b6-.ivf.res
-efd5a51d175cfdacd169ed23477729dc558030dc *invalid-vp90-2-07-frame_parallel-1.webm
-9f912712ec418be69adb910e2ca886a63c4cec08 *invalid-vp90-2-07-frame_parallel-2.webm
-445f5a53ca9555341852997ccdd480a51540bd14 *invalid-vp90-2-07-frame_parallel-3.webm
-d18c90709a0d03c82beadf10898b27d88fff719c *invalid-vp90-2-03-size-224x196.webm.ivf.s44156_r01-05_b6-.ivf
-d06285d109ecbaef63b0cbcc44d70a129186f51c *invalid-vp90-2-03-size-224x196.webm.ivf.s44156_r01-05_b6-.ivf.res
-e60d859b0ef2b331b21740cf6cb83fabe469b079 *invalid-vp90-2-03-size-202x210.webm.ivf.s113306_r01-05_b6-.ivf
-0ae808dca4d3c1152a9576e14830b6faa39f1b4a *invalid-vp90-2-03-size-202x210.webm.ivf.s113306_r01-05_b6-.ivf.res
+b7c1296630cdf1a7ef493d15ff4f9eb2999202f6 *invalid-av10-2-08-tile_1x2_frame_parallel.webm.ivf.s47039_r01-05_b6-.ivf
+0a3884edb3fd8f9d9b500223e650f7de257b67d8 *invalid-av10-2-08-tile_1x2_frame_parallel.webm.ivf.s47039_r01-05_b6-.ivf.res
+359e138dfb66863828397b77000ea7a83c844d02 *invalid-av10-2-08-tile_1x8_frame_parallel.webm.ivf.s288_r01-05_b6-.ivf
+bbd33de01c17b165b4ce00308e8a19a942023ab8 *invalid-av10-2-08-tile_1x8_frame_parallel.webm.ivf.s288_r01-05_b6-.ivf.res
+fac89b5735be8a86b0dc05159f996a5c3208ae32 *invalid-av10-2-09-aq2.webm.ivf.s3984_r01-05_b6-.v2.ivf
+0a3884edb3fd8f9d9b500223e650f7de257b67d8 *invalid-av10-2-09-aq2.webm.ivf.s3984_r01-05_b6-.v2.ivf.res
+4506dfdcdf8ee4250924b075a0dcf1f070f72e5a *invalid-av10-2-09-subpixel-00.ivf.s19552_r01-05_b6-.v2.ivf
+bcdedaf168ac225575468fda77502d2dc9fd5baa *invalid-av10-2-09-subpixel-00.ivf.s19552_r01-05_b6-.v2.ivf.res
+b03c408cf23158638da18dbc3323b99a1635c68a *invalid-av10-2-12-droppable_1.ivf.s3676_r01-05_b6-.ivf
+0a3884edb3fd8f9d9b500223e650f7de257b67d8 *invalid-av10-2-12-droppable_1.ivf.s3676_r01-05_b6-.ivf.res
+5e67e24e7f53fd189e565513cef8519b1bd6c712 *invalid-av10-2-05-resize.ivf.s59293_r01-05_b6-.ivf
+741158f67c0d9d23726624d06bdc482ad368afc9 *invalid-av10-2-05-resize.ivf.s59293_r01-05_b6-.ivf.res
+8b1f7bf7e86c0976d277f60e8fcd9539e75a079a *invalid-av10-2-09-subpixel-00.ivf.s20492_r01-05_b6-.v2.ivf
+9c6bdf048fb2e66f07d4b4db5b32e6f303bd6109 *invalid-av10-2-09-subpixel-00.ivf.s20492_r01-05_b6-.v2.ivf.res
+552e372e9b78127389fb06b34545df2cec15ba6d *invalid-av11-2-mixedrefcsp-444to420.ivf
+a61774cf03fc584bd9f0904fc145253bb8ea6c4c *invalid-av11-2-mixedrefcsp-444to420.ivf.res
+812d05a64a0d83c1b504d0519927ddc5a2cdb273 *invalid-av10-2-12-droppable_1.ivf.s73804_r01-05_b6-.ivf
+1e472baaf5f6113459f0399a38a5a5e68d17799d *invalid-av10-2-12-droppable_1.ivf.s73804_r01-05_b6-.ivf.res
+efd5a51d175cfdacd169ed23477729dc558030dc *invalid-av10-2-07-frame_parallel-1.webm
+9f912712ec418be69adb910e2ca886a63c4cec08 *invalid-av10-2-07-frame_parallel-2.webm
+445f5a53ca9555341852997ccdd480a51540bd14 *invalid-av10-2-07-frame_parallel-3.webm
+d18c90709a0d03c82beadf10898b27d88fff719c *invalid-av10-2-03-size-224x196.webm.ivf.s44156_r01-05_b6-.ivf
+d06285d109ecbaef63b0cbcc44d70a129186f51c *invalid-av10-2-03-size-224x196.webm.ivf.s44156_r01-05_b6-.ivf.res
+e60d859b0ef2b331b21740cf6cb83fabe469b079 *invalid-av10-2-03-size-202x210.webm.ivf.s113306_r01-05_b6-.ivf
+0ae808dca4d3c1152a9576e14830b6faa39f1b4a *invalid-av10-2-03-size-202x210.webm.ivf.s113306_r01-05_b6-.ivf.res
9cfc855459e7549fd015c79e8eca512b2f2cb7e3 *niklas_1280_720_30.y4m
5b5763b388b1b52a81bb82b39f7ec25c4bd3d0e1 *desktop_credits.y4m
diff --git a/test/test.mk b/test/test.mk
index d7f2391..ba41e26 100644
--- a/test/test.mk
+++ b/test/test.mk
@@ -4,7 +4,7 @@
LIBAOM_TEST_SRCS-yes += md5_helper.h
LIBAOM_TEST_SRCS-yes += register_state_check.h
LIBAOM_TEST_SRCS-yes += test.mk
-LIBAOM_TEST_SRCS-yes += test_libvpx.cc
+LIBAOM_TEST_SRCS-yes += test_libaom.cc
LIBAOM_TEST_SRCS-yes += util.h
LIBAOM_TEST_SRCS-yes += video_source.h
LIBAOM_TEST_SRCS-yes += transform_test_base.h
@@ -29,14 +29,14 @@
LIBAOM_TEST_SRCS-$(CONFIG_ENCODERS) += y4m_video_source.h
LIBAOM_TEST_SRCS-$(CONFIG_ENCODERS) += yuv_video_source.h
-#LIBAOM_TEST_SRCS-$(CONFIG_VP10_ENCODER) += level_test.cc
-LIBAOM_TEST_SRCS-$(CONFIG_VP10_ENCODER) += active_map_refresh_test.cc
-LIBAOM_TEST_SRCS-$(CONFIG_VP10_ENCODER) += active_map_test.cc
-LIBAOM_TEST_SRCS-$(CONFIG_VP10_ENCODER) += borders_test.cc
-LIBAOM_TEST_SRCS-$(CONFIG_VP10_ENCODER) += cpu_speed_test.cc
-LIBAOM_TEST_SRCS-$(CONFIG_VP10_ENCODER) += frame_size_tests.cc
-LIBAOM_TEST_SRCS-$(CONFIG_VP10_ENCODER) += lossless_test.cc
-LIBAOM_TEST_SRCS-$(CONFIG_VP10_ENCODER) += ethread_test.cc
+#LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += level_test.cc
+LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += active_map_refresh_test.cc
+LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += active_map_test.cc
+LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += borders_test.cc
+LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += cpu_speed_test.cc
+LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += frame_size_tests.cc
+LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += lossless_test.cc
+LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += ethread_test.cc
LIBAOM_TEST_SRCS-yes += decode_test_driver.cc
LIBAOM_TEST_SRCS-yes += decode_test_driver.h
@@ -64,20 +64,20 @@
LIBAOM_TEST_SRCS-$(CONFIG_DECODERS) += decode_api_test.cc
-# Currently we only support decoder perf tests for vp9. Also they read from WebM
+# Currently we only support decoder perf tests for av1. Also they read from WebM
# files, so WebM IO is required.
-ifeq ($(CONFIG_DECODE_PERF_TESTS)$(CONFIG_VP10_DECODER)$(CONFIG_WEBM_IO), \
+ifeq ($(CONFIG_DECODE_PERF_TESTS)$(CONFIG_AV1_DECODER)$(CONFIG_WEBM_IO), \
yesyesyes)
LIBAOM_TEST_SRCS-yes += decode_perf_test.cc
endif
-# encode perf tests are vp9 only
-ifeq ($(CONFIG_ENCODE_PERF_TESTS)$(CONFIG_VP10_ENCODER), yesyes)
+# encode perf tests are av1 only
+ifeq ($(CONFIG_ENCODE_PERF_TESTS)$(CONFIG_AV1_ENCODER), yesyes)
LIBAOM_TEST_SRCS-yes += encode_perf_test.cc
endif
## Multi-codec / unconditional black box tests.
-ifeq ($(findstring yes,$(CONFIG_VP10_ENCODER)),yes)
+ifeq ($(findstring yes,$(CONFIG_AV1_ENCODER)),yes)
LIBAOM_TEST_SRCS-yes += active_map_refresh_test.cc
LIBAOM_TEST_SRCS-yes += active_map_test.cc
LIBAOM_TEST_SRCS-yes += end_to_end_test.cc
@@ -91,11 +91,11 @@
##
ifeq ($(CONFIG_SHARED),)
-## VP10
-ifeq ($(CONFIG_VP10),yes)
+## AV1
+ifeq ($(CONFIG_AV1),yes)
# These tests require both the encoder and decoder to be built.
-ifeq ($(CONFIG_VP10_ENCODER)$(CONFIG_VP10_DECODER),yesyes)
+ifeq ($(CONFIG_AV1_ENCODER)$(CONFIG_AV1_DECODER),yesyes)
# IDCT test currently depends on FDCT function
LIBAOM_TEST_SRCS-yes += idct8x8_test.cc
LIBAOM_TEST_SRCS-yes += partial_idct_test.cc
@@ -109,41 +109,41 @@
#LIBAOM_TEST_SRCS-yes += convolve_test.cc
LIBAOM_TEST_SRCS-yes += lpf_8_test.cc
LIBAOM_TEST_SRCS-yes += intrapred_test.cc
-#LIBAOM_TEST_SRCS-$(CONFIG_VP10_DECODER) += vp9_thread_test.cc
-LIBAOM_TEST_SRCS-$(CONFIG_VP10_ENCODER) += dct16x16_test.cc
-LIBAOM_TEST_SRCS-$(CONFIG_VP10_ENCODER) += dct32x32_test.cc
-LIBAOM_TEST_SRCS-$(CONFIG_VP10_ENCODER) += fdct4x4_test.cc
-LIBAOM_TEST_SRCS-$(CONFIG_VP10_ENCODER) += fdct8x8_test.cc
-LIBAOM_TEST_SRCS-$(CONFIG_VP10_ENCODER) += hadamard_test.cc
-LIBAOM_TEST_SRCS-$(CONFIG_VP10_ENCODER) += minmax_test.cc
-LIBAOM_TEST_SRCS-$(CONFIG_VP10_ENCODER) += variance_test.cc
-LIBAOM_TEST_SRCS-$(CONFIG_VP10_ENCODER) += error_block_test.cc
-#LIBAOM_TEST_SRCS-$(CONFIG_VP10_ENCODER) += vp9_quantize_test.cc
-LIBAOM_TEST_SRCS-$(CONFIG_VP10_ENCODER) += subtract_test.cc
+#LIBAOM_TEST_SRCS-$(CONFIG_AV1_DECODER) += av1_thread_test.cc
+LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += dct16x16_test.cc
+LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += dct32x32_test.cc
+LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += fdct4x4_test.cc
+LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += fdct8x8_test.cc
+LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += hadamard_test.cc
+LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += minmax_test.cc
+LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += variance_test.cc
+LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += error_block_test.cc
+#LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += av1_quantize_test.cc
+LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += subtract_test.cc
-ifeq ($(CONFIG_VP10_ENCODER)$(CONFIG_VP10_TEMPORAL_DENOISING),yesyes)
-LIBAOM_TEST_SRCS-$(HAVE_SSE2) += denoiser_sse2_test.cc
+ifeq ($(CONFIG_AV1_ENCODER)$(CONFIG_AV1_TEMPORAL_DENOISING),yesyes)
+#LIBAOM_TEST_SRCS-$(HAVE_SSE2) += denoiser_sse2_test.cc
endif
-LIBAOM_TEST_SRCS-$(CONFIG_VP10_ENCODER) += arf_freq_test.cc
+LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += arf_freq_test.cc
-LIBAOM_TEST_SRCS-$(CONFIG_VP10_ENCODER) += vp10_inv_txfm_test.cc
-LIBAOM_TEST_SRCS-$(CONFIG_VP10_ENCODER) += vp10_dct_test.cc
-LIBAOM_TEST_SRCS-$(CONFIG_VP10_ENCODER) += vp10_fht4x4_test.cc
-LIBAOM_TEST_SRCS-$(CONFIG_VP10_ENCODER) += vp10_fht8x8_test.cc
-LIBAOM_TEST_SRCS-$(CONFIG_VP10_ENCODER) += vp10_fht16x16_test.cc
-LIBAOM_TEST_SRCS-$(CONFIG_ANS) += vp10_ans_test.cc
-LIBAOM_TEST_SRCS-$(CONFIG_EXT_TILE) += vp10_ext_tile_test.cc
+LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += av1_inv_txfm_test.cc
+LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += av1_dct_test.cc
+LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += av1_fht4x4_test.cc
+LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += av1_fht8x8_test.cc
+LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += av1_fht16x16_test.cc
+LIBAOM_TEST_SRCS-$(CONFIG_ANS) += av1_ans_test.cc
+LIBAOM_TEST_SRCS-$(CONFIG_EXT_TILE) += av1_ext_tile_test.cc
-LIBAOM_TEST_SRCS-$(CONFIG_VP10_ENCODER) += sum_squares_test.cc
-LIBAOM_TEST_SRCS-$(CONFIG_VP10_ENCODER) += subtract_test.cc
-LIBAOM_TEST_SRCS-$(CONFIG_VP10_ENCODER) += blend_a64_mask_test.cc
-LIBAOM_TEST_SRCS-$(CONFIG_VP10_ENCODER) += blend_a64_mask_1d_test.cc
+LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += sum_squares_test.cc
+LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += subtract_test.cc
+LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += blend_a64_mask_test.cc
+LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += blend_a64_mask_1d_test.cc
ifeq ($(CONFIG_EXT_INTER),yes)
LIBAOM_TEST_SRCS-$(HAVE_SSSE3) += masked_variance_test.cc
LIBAOM_TEST_SRCS-$(HAVE_SSSE3) += masked_sad_test.cc
-LIBAOM_TEST_SRCS-$(CONFIG_VP10_ENCODER) += vp10_wedge_utils_test.cc
+LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += av1_wedge_utils_test.cc
endif
ifeq ($(CONFIG_EXT_INTRA),yes)
@@ -151,33 +151,33 @@
endif
ifeq ($(CONFIG_OBMC),yes)
-LIBAOM_TEST_SRCS-$(CONFIG_VP10_ENCODER) += obmc_sad_test.cc
-LIBAOM_TEST_SRCS-$(CONFIG_VP10_ENCODER) += obmc_variance_test.cc
+LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += obmc_sad_test.cc
+LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += obmc_variance_test.cc
endif
-ifeq ($(CONFIG_VP9_HIGHBITDEPTH),yes)
-LIBAOM_TEST_SRCS-$(HAVE_SSE4_1) += vp10_quantize_test.cc
-LIBAOM_TEST_SRCS-$(HAVE_SSE4_1) += vp10_highbd_iht_test.cc
-endif # CONFIG_VP9_HIGHBITDEPTH
-endif # VP10
+ifeq ($(CONFIG_AOM_HIGHBITDEPTH),yes)
+LIBAOM_TEST_SRCS-$(HAVE_SSE4_1) += av1_quantize_test.cc
+LIBAOM_TEST_SRCS-$(HAVE_SSE4_1) += av1_highbd_iht_test.cc
+endif # CONFIG_AOM_HIGHBITDEPTH
+endif # AV1
## Multi-codec / unconditional whitebox tests.
-ifeq ($(CONFIG_VP10_ENCODER),yes)
+ifeq ($(CONFIG_AV1_ENCODER),yes)
LIBAOM_TEST_SRCS-yes += avg_test.cc
endif
ifeq ($(CONFIG_INTERNAL_STATS),yes)
-LIBAOM_TEST_SRCS-$(CONFIG_VP9_HIGHBITDEPTH) += hbd_metrics_test.cc
+LIBAOM_TEST_SRCS-$(CONFIG_AOM_HIGHBITDEPTH) += hbd_metrics_test.cc
endif
LIBAOM_TEST_SRCS-$(CONFIG_ENCODERS) += sad_test.cc
-LIBAOM_TEST_SRCS-$(CONFIG_VP10) += vp10_txfm_test.h
-LIBAOM_TEST_SRCS-$(CONFIG_VP10) += vp10_txfm_test.cc
-LIBAOM_TEST_SRCS-$(CONFIG_VP10) += vp10_fwd_txfm1d_test.cc
-LIBAOM_TEST_SRCS-$(CONFIG_VP10) += vp10_inv_txfm1d_test.cc
-LIBAOM_TEST_SRCS-$(CONFIG_VP10) += vp10_fwd_txfm2d_test.cc
-LIBAOM_TEST_SRCS-$(CONFIG_VP10) += vp10_inv_txfm2d_test.cc
-LIBAOM_TEST_SRCS-$(CONFIG_VP10) += vp10_convolve_test.cc
-LIBAOM_TEST_SRCS-$(CONFIG_VP10) += vp10_convolve_optimz_test.cc
+LIBAOM_TEST_SRCS-$(CONFIG_AV1) += av1_txfm_test.h
+LIBAOM_TEST_SRCS-$(CONFIG_AV1) += av1_txfm_test.cc
+LIBAOM_TEST_SRCS-$(CONFIG_AV1) += av1_fwd_txfm1d_test.cc
+LIBAOM_TEST_SRCS-$(CONFIG_AV1) += av1_inv_txfm1d_test.cc
+LIBAOM_TEST_SRCS-$(CONFIG_AV1) += av1_fwd_txfm2d_test.cc
+LIBAOM_TEST_SRCS-$(CONFIG_AV1) += av1_inv_txfm2d_test.cc
+LIBAOM_TEST_SRCS-$(CONFIG_AV1) += av1_convolve_test.cc
+LIBAOM_TEST_SRCS-$(CONFIG_AV1) += av1_convolve_optimz_test.cc
TEST_INTRA_PRED_SPEED_SRCS-yes := test_intra_pred_speed.cc
TEST_INTRA_PRED_SPEED_SRCS-yes += ../md5_utils.h ../md5_utils.c
diff --git a/test/test_intra_pred_speed.cc b/test/test_intra_pred_speed.cc
index 41bc4ec..5f08dec 100644
--- a/test/test_intra_pred_speed.cc
+++ b/test/test_intra_pred_speed.cc
@@ -7,36 +7,36 @@
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
-// Test and time VPX intra-predictor functions
+// Test and time AOM intra-predictor functions
#include <stdio.h>
#include <string.h>
#include "third_party/googletest/src/include/gtest/gtest.h"
-#include "./vpx_dsp_rtcd.h"
+#include "./aom_dsp_rtcd.h"
#include "test/acm_random.h"
#include "test/clear_system_state.h"
#include "test/md5_helper.h"
-#include "aom/vpx_integer.h"
+#include "aom/aom_integer.h"
#include "aom_ports/mem.h"
-#include "aom_ports/vpx_timer.h"
+#include "aom_ports/aom_timer.h"
// -----------------------------------------------------------------------------
namespace {
-typedef void (*VpxPredFunc)(uint8_t *dst, ptrdiff_t y_stride,
+typedef void (*AvxPredFunc)(uint8_t *dst, ptrdiff_t y_stride,
const uint8_t *above, const uint8_t *left);
-const int kNumVp9IntraPredFuncs = 13;
-const char *kVp9IntraPredNames[kNumVp9IntraPredFuncs] = {
+const int kNumAv1IntraPredFuncs = 13;
+const char *kAv1IntraPredNames[kNumAv1IntraPredFuncs] = {
"DC_PRED", "DC_LEFT_PRED", "DC_TOP_PRED", "DC_128_PRED", "V_PRED",
"H_PRED", "D45_PRED", "D135_PRED", "D117_PRED", "D153_PRED",
"D207_PRED", "D63_PRED", "TM_PRED"
};
-void TestIntraPred(const char name[], VpxPredFunc const *pred_funcs,
+void TestIntraPred(const char name[], AvxPredFunc const *pred_funcs,
const char *const pred_func_names[], int num_funcs,
const char *const signatures[], int block_size,
int num_pixels_per_test) {
@@ -62,15 +62,15 @@
for (int k = 0; k < num_funcs; ++k) {
if (pred_funcs[k] == NULL) continue;
memcpy(src, ref_src, sizeof(src));
- vpx_usec_timer timer;
- vpx_usec_timer_start(&timer);
+ aom_usec_timer timer;
+ aom_usec_timer_start(&timer);
for (int num_tests = 0; num_tests < kNumTests; ++num_tests) {
pred_funcs[k](src, kBPS, above, left);
}
libaom_test::ClearSystemState();
- vpx_usec_timer_mark(&timer);
+ aom_usec_timer_mark(&timer);
const int elapsed_time =
- static_cast<int>(vpx_usec_timer_elapsed(&timer) / 1000);
+ static_cast<int>(aom_usec_timer_elapsed(&timer) / 1000);
libaom_test::MD5 md5;
md5.Add(src, sizeof(src));
printf("Mode %s[%12s]: %5d ms MD5: %s\n", name, pred_func_names[k],
@@ -79,9 +79,9 @@
}
}
-void TestIntraPred4(VpxPredFunc const *pred_funcs) {
- static const int kNumVp9IntraFuncs = 13;
- static const char *const kSignatures[kNumVp9IntraFuncs] = {
+void TestIntraPred4(AvxPredFunc const *pred_funcs) {
+ static const int kNumAv1IntraFuncs = 13;
+ static const char *const kSignatures[kNumAv1IntraFuncs] = {
"4334156168b34ab599d9b5b30f522fe9", "bc4649d5ba47c7ff178d92e475960fb0",
"8d316e5933326dcac24e1064794b5d12", "a27270fed024eafd762c95de85f4da51",
"c33dff000d4256c2b8f3bf9e9bab14d2", "44d8cddc2ad8f79b8ed3306051722b4f",
@@ -90,13 +90,13 @@
"c56d5e8c729e46825f46dd5d3b5d508a", "c0889e2039bcf7bcb5d2f33cdca69adc",
"309a618577b27c648f9c5ee45252bc8f",
};
- TestIntraPred("Intra4", pred_funcs, kVp9IntraPredNames, kNumVp9IntraFuncs,
- kSignatures, 4, 4 * 4 * kNumVp9IntraFuncs);
+ TestIntraPred("Intra4", pred_funcs, kAv1IntraPredNames, kNumAv1IntraFuncs,
+ kSignatures, 4, 4 * 4 * kNumAv1IntraFuncs);
}
-void TestIntraPred8(VpxPredFunc const *pred_funcs) {
- static const int kNumVp9IntraFuncs = 13;
- static const char *const kSignatures[kNumVp9IntraFuncs] = {
+void TestIntraPred8(AvxPredFunc const *pred_funcs) {
+ static const int kNumAv1IntraFuncs = 13;
+ static const char *const kSignatures[kNumAv1IntraFuncs] = {
"7694ddeeefed887faf9d339d18850928", "7d726b1213591b99f736be6dec65065b",
"19c5711281357a485591aaf9c96c0a67", "ba6b66877a089e71cd938e3b8c40caac",
"802440c93317e0f8ba93fab02ef74265", "9e09a47a15deb0b9d8372824f9805080",
@@ -105,13 +105,13 @@
"08323400005a297f16d7e57e7fe1eaac", "95f7bfc262329a5849eda66d8f7c68ce",
"815b75c8e0d91cc1ae766dc5d3e445a3",
};
- TestIntraPred("Intra8", pred_funcs, kVp9IntraPredNames, kNumVp9IntraFuncs,
- kSignatures, 8, 8 * 8 * kNumVp9IntraFuncs);
+ TestIntraPred("Intra8", pred_funcs, kAv1IntraPredNames, kNumAv1IntraFuncs,
+ kSignatures, 8, 8 * 8 * kNumAv1IntraFuncs);
}
-void TestIntraPred16(VpxPredFunc const *pred_funcs) {
- static const int kNumVp9IntraFuncs = 13;
- static const char *const kSignatures[kNumVp9IntraFuncs] = {
+void TestIntraPred16(AvxPredFunc const *pred_funcs) {
+ static const int kNumAv1IntraFuncs = 13;
+ static const char *const kSignatures[kNumAv1IntraFuncs] = {
"b40dbb555d5d16a043dc361e6694fe53", "fb08118cee3b6405d64c1fd68be878c6",
"6c190f341475c837cc38c2e566b64875", "db5c34ccbe2c7f595d9b08b0dc2c698c",
"a62cbfd153a1f0b9fed13e62b8408a7a", "143df5b4c89335e281103f610f5052e4",
@@ -120,13 +120,13 @@
"b9f69fa6532b372c545397dcb78ef311", "a8fe1c70432f09d0c20c67bdb6432c4d",
"b8a41aa968ec108af447af4217cba91b",
};
- TestIntraPred("Intra16", pred_funcs, kVp9IntraPredNames, kNumVp9IntraFuncs,
- kSignatures, 16, 16 * 16 * kNumVp9IntraFuncs);
+ TestIntraPred("Intra16", pred_funcs, kAv1IntraPredNames, kNumAv1IntraFuncs,
+ kSignatures, 16, 16 * 16 * kNumAv1IntraFuncs);
}
-void TestIntraPred32(VpxPredFunc const *pred_funcs) {
- static const int kNumVp9IntraFuncs = 13;
- static const char *const kSignatures[kNumVp9IntraFuncs] = {
+void TestIntraPred32(AvxPredFunc const *pred_funcs) {
+ static const int kNumAv1IntraFuncs = 13;
+ static const char *const kSignatures[kNumAv1IntraFuncs] = {
"558541656d84f9ae7896db655826febe", "b3587a1f9a01495fa38c8cd3c8e2a1bf",
"4c6501e64f25aacc55a2a16c7e8f0255", "b3b01379ba08916ef6b1b35f7d9ad51c",
"0f1eb38b6cbddb3d496199ef9f329071", "911c06efb9ed1c3b4c104b232b55812f",
@@ -135,8 +135,8 @@
"ed012a4a5da71f36c2393023184a0e59", "f162b51ed618d28b936974cff4391da5",
"9e1370c6d42e08d357d9612c93a71cfc",
};
- TestIntraPred("Intra32", pred_funcs, kVp9IntraPredNames, kNumVp9IntraFuncs,
- kSignatures, 32, 32 * 32 * kNumVp9IntraFuncs);
+ TestIntraPred("Intra32", pred_funcs, kAv1IntraPredNames, kNumAv1IntraFuncs,
+ kSignatures, 32, 32 * 32 * kNumAv1IntraFuncs);
}
} // namespace
@@ -146,201 +146,201 @@
#define INTRA_PRED_TEST(arch, test_func, dc, dc_left, dc_top, dc_128, v, h, \
d45, d135, d117, d153, d207, d63, tm) \
TEST(arch, test_func) { \
- static const VpxPredFunc vpx_intra_pred[] = { \
+ static const AvxPredFunc aom_intra_pred[] = { \
dc, dc_left, dc_top, dc_128, v, h, d45, d135, d117, d153, d207, d63, tm \
}; \
- test_func(vpx_intra_pred); \
+ test_func(aom_intra_pred); \
}
// -----------------------------------------------------------------------------
// 4x4
-INTRA_PRED_TEST(C, TestIntraPred4, vpx_dc_predictor_4x4_c,
- vpx_dc_left_predictor_4x4_c, vpx_dc_top_predictor_4x4_c,
- vpx_dc_128_predictor_4x4_c, vpx_v_predictor_4x4_c,
- vpx_h_predictor_4x4_c, vpx_d45_predictor_4x4_c,
- vpx_d135_predictor_4x4_c, vpx_d117_predictor_4x4_c,
- vpx_d153_predictor_4x4_c, vpx_d207_predictor_4x4_c,
- vpx_d63_predictor_4x4_c, vpx_tm_predictor_4x4_c)
+INTRA_PRED_TEST(C, TestIntraPred4, aom_dc_predictor_4x4_c,
+ aom_dc_left_predictor_4x4_c, aom_dc_top_predictor_4x4_c,
+ aom_dc_128_predictor_4x4_c, aom_v_predictor_4x4_c,
+ aom_h_predictor_4x4_c, aom_d45_predictor_4x4_c,
+ aom_d135_predictor_4x4_c, aom_d117_predictor_4x4_c,
+ aom_d153_predictor_4x4_c, aom_d207_predictor_4x4_c,
+ aom_d63_predictor_4x4_c, aom_tm_predictor_4x4_c)
#if HAVE_SSE2
-INTRA_PRED_TEST(SSE2, TestIntraPred4, vpx_dc_predictor_4x4_sse2,
- vpx_dc_left_predictor_4x4_sse2, vpx_dc_top_predictor_4x4_sse2,
- vpx_dc_128_predictor_4x4_sse2, vpx_v_predictor_4x4_sse2,
- vpx_h_predictor_4x4_sse2, vpx_d45_predictor_4x4_sse2, NULL,
- NULL, NULL, vpx_d207_predictor_4x4_sse2, NULL,
- vpx_tm_predictor_4x4_sse2)
+INTRA_PRED_TEST(SSE2, TestIntraPred4, aom_dc_predictor_4x4_sse2,
+ aom_dc_left_predictor_4x4_sse2, aom_dc_top_predictor_4x4_sse2,
+ aom_dc_128_predictor_4x4_sse2, aom_v_predictor_4x4_sse2,
+ aom_h_predictor_4x4_sse2, aom_d45_predictor_4x4_sse2, NULL,
+ NULL, NULL, aom_d207_predictor_4x4_sse2, NULL,
+ aom_tm_predictor_4x4_sse2)
#endif // HAVE_SSE2
#if HAVE_SSSE3
INTRA_PRED_TEST(SSSE3, TestIntraPred4, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
- NULL, NULL, vpx_d153_predictor_4x4_ssse3, NULL,
- vpx_d63_predictor_4x4_ssse3, NULL)
+ NULL, NULL, aom_d153_predictor_4x4_ssse3, NULL,
+ aom_d63_predictor_4x4_ssse3, NULL)
#endif // HAVE_SSSE3
#if HAVE_DSPR2
-INTRA_PRED_TEST(DSPR2, TestIntraPred4, vpx_dc_predictor_4x4_dspr2, NULL, NULL,
- NULL, NULL, vpx_h_predictor_4x4_dspr2, NULL, NULL, NULL, NULL,
- NULL, NULL, vpx_tm_predictor_4x4_dspr2)
+INTRA_PRED_TEST(DSPR2, TestIntraPred4, aom_dc_predictor_4x4_dspr2, NULL, NULL,
+ NULL, NULL, aom_h_predictor_4x4_dspr2, NULL, NULL, NULL, NULL,
+ NULL, NULL, aom_tm_predictor_4x4_dspr2)
#endif // HAVE_DSPR2
#if HAVE_NEON
-INTRA_PRED_TEST(NEON, TestIntraPred4, vpx_dc_predictor_4x4_neon,
- vpx_dc_left_predictor_4x4_neon, vpx_dc_top_predictor_4x4_neon,
- vpx_dc_128_predictor_4x4_neon, vpx_v_predictor_4x4_neon,
- vpx_h_predictor_4x4_neon, vpx_d45_predictor_4x4_neon,
- vpx_d135_predictor_4x4_neon, NULL, NULL, NULL, NULL,
- vpx_tm_predictor_4x4_neon)
+INTRA_PRED_TEST(NEON, TestIntraPred4, aom_dc_predictor_4x4_neon,
+ aom_dc_left_predictor_4x4_neon, aom_dc_top_predictor_4x4_neon,
+ aom_dc_128_predictor_4x4_neon, aom_v_predictor_4x4_neon,
+ aom_h_predictor_4x4_neon, aom_d45_predictor_4x4_neon,
+ aom_d135_predictor_4x4_neon, NULL, NULL, NULL, NULL,
+ aom_tm_predictor_4x4_neon)
#endif // HAVE_NEON
#if HAVE_MSA
-INTRA_PRED_TEST(MSA, TestIntraPred4, vpx_dc_predictor_4x4_msa,
- vpx_dc_left_predictor_4x4_msa, vpx_dc_top_predictor_4x4_msa,
- vpx_dc_128_predictor_4x4_msa, vpx_v_predictor_4x4_msa,
- vpx_h_predictor_4x4_msa, NULL, NULL, NULL, NULL, NULL, NULL,
- vpx_tm_predictor_4x4_msa)
+INTRA_PRED_TEST(MSA, TestIntraPred4, aom_dc_predictor_4x4_msa,
+ aom_dc_left_predictor_4x4_msa, aom_dc_top_predictor_4x4_msa,
+ aom_dc_128_predictor_4x4_msa, aom_v_predictor_4x4_msa,
+ aom_h_predictor_4x4_msa, NULL, NULL, NULL, NULL, NULL, NULL,
+ aom_tm_predictor_4x4_msa)
#endif // HAVE_MSA
// -----------------------------------------------------------------------------
// 8x8
-INTRA_PRED_TEST(C, TestIntraPred8, vpx_dc_predictor_8x8_c,
- vpx_dc_left_predictor_8x8_c, vpx_dc_top_predictor_8x8_c,
- vpx_dc_128_predictor_8x8_c, vpx_v_predictor_8x8_c,
- vpx_h_predictor_8x8_c, vpx_d45_predictor_8x8_c,
- vpx_d135_predictor_8x8_c, vpx_d117_predictor_8x8_c,
- vpx_d153_predictor_8x8_c, vpx_d207_predictor_8x8_c,
- vpx_d63_predictor_8x8_c, vpx_tm_predictor_8x8_c)
+INTRA_PRED_TEST(C, TestIntraPred8, aom_dc_predictor_8x8_c,
+ aom_dc_left_predictor_8x8_c, aom_dc_top_predictor_8x8_c,
+ aom_dc_128_predictor_8x8_c, aom_v_predictor_8x8_c,
+ aom_h_predictor_8x8_c, aom_d45_predictor_8x8_c,
+ aom_d135_predictor_8x8_c, aom_d117_predictor_8x8_c,
+ aom_d153_predictor_8x8_c, aom_d207_predictor_8x8_c,
+ aom_d63_predictor_8x8_c, aom_tm_predictor_8x8_c)
#if HAVE_SSE2
-INTRA_PRED_TEST(SSE2, TestIntraPred8, vpx_dc_predictor_8x8_sse2,
- vpx_dc_left_predictor_8x8_sse2, vpx_dc_top_predictor_8x8_sse2,
- vpx_dc_128_predictor_8x8_sse2, vpx_v_predictor_8x8_sse2,
- vpx_h_predictor_8x8_sse2, vpx_d45_predictor_8x8_sse2, NULL,
- NULL, NULL, NULL, NULL, vpx_tm_predictor_8x8_sse2)
+INTRA_PRED_TEST(SSE2, TestIntraPred8, aom_dc_predictor_8x8_sse2,
+ aom_dc_left_predictor_8x8_sse2, aom_dc_top_predictor_8x8_sse2,
+ aom_dc_128_predictor_8x8_sse2, aom_v_predictor_8x8_sse2,
+ aom_h_predictor_8x8_sse2, aom_d45_predictor_8x8_sse2, NULL,
+ NULL, NULL, NULL, NULL, aom_tm_predictor_8x8_sse2)
#endif // HAVE_SSE2
#if HAVE_SSSE3
INTRA_PRED_TEST(SSSE3, TestIntraPred8, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
- NULL, NULL, vpx_d153_predictor_8x8_ssse3,
- vpx_d207_predictor_8x8_ssse3, vpx_d63_predictor_8x8_ssse3, NULL)
+ NULL, NULL, aom_d153_predictor_8x8_ssse3,
+ aom_d207_predictor_8x8_ssse3, aom_d63_predictor_8x8_ssse3, NULL)
#endif // HAVE_SSSE3
#if HAVE_DSPR2
-INTRA_PRED_TEST(DSPR2, TestIntraPred8, vpx_dc_predictor_8x8_dspr2, NULL, NULL,
- NULL, NULL, vpx_h_predictor_8x8_dspr2, NULL, NULL, NULL, NULL,
- NULL, NULL, vpx_tm_predictor_8x8_dspr2)
+INTRA_PRED_TEST(DSPR2, TestIntraPred8, aom_dc_predictor_8x8_dspr2, NULL, NULL,
+ NULL, NULL, aom_h_predictor_8x8_dspr2, NULL, NULL, NULL, NULL,
+ NULL, NULL, aom_tm_predictor_8x8_dspr2)
#endif // HAVE_DSPR2
#if HAVE_NEON
-INTRA_PRED_TEST(NEON, TestIntraPred8, vpx_dc_predictor_8x8_neon,
- vpx_dc_left_predictor_8x8_neon, vpx_dc_top_predictor_8x8_neon,
- vpx_dc_128_predictor_8x8_neon, vpx_v_predictor_8x8_neon,
- vpx_h_predictor_8x8_neon, vpx_d45_predictor_8x8_neon, NULL,
- NULL, NULL, NULL, NULL, vpx_tm_predictor_8x8_neon)
+INTRA_PRED_TEST(NEON, TestIntraPred8, aom_dc_predictor_8x8_neon,
+ aom_dc_left_predictor_8x8_neon, aom_dc_top_predictor_8x8_neon,
+ aom_dc_128_predictor_8x8_neon, aom_v_predictor_8x8_neon,
+ aom_h_predictor_8x8_neon, aom_d45_predictor_8x8_neon, NULL,
+ NULL, NULL, NULL, NULL, aom_tm_predictor_8x8_neon)
#endif // HAVE_NEON
#if HAVE_MSA
-INTRA_PRED_TEST(MSA, TestIntraPred8, vpx_dc_predictor_8x8_msa,
- vpx_dc_left_predictor_8x8_msa, vpx_dc_top_predictor_8x8_msa,
- vpx_dc_128_predictor_8x8_msa, vpx_v_predictor_8x8_msa,
- vpx_h_predictor_8x8_msa, NULL, NULL, NULL, NULL, NULL, NULL,
- vpx_tm_predictor_8x8_msa)
+INTRA_PRED_TEST(MSA, TestIntraPred8, aom_dc_predictor_8x8_msa,
+ aom_dc_left_predictor_8x8_msa, aom_dc_top_predictor_8x8_msa,
+ aom_dc_128_predictor_8x8_msa, aom_v_predictor_8x8_msa,
+ aom_h_predictor_8x8_msa, NULL, NULL, NULL, NULL, NULL, NULL,
+ aom_tm_predictor_8x8_msa)
#endif // HAVE_MSA
// -----------------------------------------------------------------------------
// 16x16
-INTRA_PRED_TEST(C, TestIntraPred16, vpx_dc_predictor_16x16_c,
- vpx_dc_left_predictor_16x16_c, vpx_dc_top_predictor_16x16_c,
- vpx_dc_128_predictor_16x16_c, vpx_v_predictor_16x16_c,
- vpx_h_predictor_16x16_c, vpx_d45_predictor_16x16_c,
- vpx_d135_predictor_16x16_c, vpx_d117_predictor_16x16_c,
- vpx_d153_predictor_16x16_c, vpx_d207_predictor_16x16_c,
- vpx_d63_predictor_16x16_c, vpx_tm_predictor_16x16_c)
+INTRA_PRED_TEST(C, TestIntraPred16, aom_dc_predictor_16x16_c,
+ aom_dc_left_predictor_16x16_c, aom_dc_top_predictor_16x16_c,
+ aom_dc_128_predictor_16x16_c, aom_v_predictor_16x16_c,
+ aom_h_predictor_16x16_c, aom_d45_predictor_16x16_c,
+ aom_d135_predictor_16x16_c, aom_d117_predictor_16x16_c,
+ aom_d153_predictor_16x16_c, aom_d207_predictor_16x16_c,
+ aom_d63_predictor_16x16_c, aom_tm_predictor_16x16_c)
#if HAVE_SSE2
-INTRA_PRED_TEST(SSE2, TestIntraPred16, vpx_dc_predictor_16x16_sse2,
- vpx_dc_left_predictor_16x16_sse2,
- vpx_dc_top_predictor_16x16_sse2,
- vpx_dc_128_predictor_16x16_sse2, vpx_v_predictor_16x16_sse2,
- vpx_h_predictor_16x16_sse2, NULL, NULL, NULL, NULL, NULL, NULL,
- vpx_tm_predictor_16x16_sse2)
+INTRA_PRED_TEST(SSE2, TestIntraPred16, aom_dc_predictor_16x16_sse2,
+ aom_dc_left_predictor_16x16_sse2,
+ aom_dc_top_predictor_16x16_sse2,
+ aom_dc_128_predictor_16x16_sse2, aom_v_predictor_16x16_sse2,
+ aom_h_predictor_16x16_sse2, NULL, NULL, NULL, NULL, NULL, NULL,
+ aom_tm_predictor_16x16_sse2)
#endif // HAVE_SSE2
#if HAVE_SSSE3
INTRA_PRED_TEST(SSSE3, TestIntraPred16, NULL, NULL, NULL, NULL, NULL, NULL,
- vpx_d45_predictor_16x16_ssse3, NULL, NULL,
- vpx_d153_predictor_16x16_ssse3, vpx_d207_predictor_16x16_ssse3,
- vpx_d63_predictor_16x16_ssse3, NULL)
+ aom_d45_predictor_16x16_ssse3, NULL, NULL,
+ aom_d153_predictor_16x16_ssse3, aom_d207_predictor_16x16_ssse3,
+ aom_d63_predictor_16x16_ssse3, NULL)
#endif // HAVE_SSSE3
#if HAVE_DSPR2
-INTRA_PRED_TEST(DSPR2, TestIntraPred16, vpx_dc_predictor_16x16_dspr2, NULL,
- NULL, NULL, NULL, vpx_h_predictor_16x16_dspr2, NULL, NULL, NULL,
+INTRA_PRED_TEST(DSPR2, TestIntraPred16, aom_dc_predictor_16x16_dspr2, NULL,
+ NULL, NULL, NULL, aom_h_predictor_16x16_dspr2, NULL, NULL, NULL,
NULL, NULL, NULL, NULL)
#endif // HAVE_DSPR2
#if HAVE_NEON
-INTRA_PRED_TEST(NEON, TestIntraPred16, vpx_dc_predictor_16x16_neon,
- vpx_dc_left_predictor_16x16_neon,
- vpx_dc_top_predictor_16x16_neon,
- vpx_dc_128_predictor_16x16_neon, vpx_v_predictor_16x16_neon,
- vpx_h_predictor_16x16_neon, vpx_d45_predictor_16x16_neon, NULL,
- NULL, NULL, NULL, NULL, vpx_tm_predictor_16x16_neon)
+INTRA_PRED_TEST(NEON, TestIntraPred16, aom_dc_predictor_16x16_neon,
+ aom_dc_left_predictor_16x16_neon,
+ aom_dc_top_predictor_16x16_neon,
+ aom_dc_128_predictor_16x16_neon, aom_v_predictor_16x16_neon,
+ aom_h_predictor_16x16_neon, aom_d45_predictor_16x16_neon, NULL,
+ NULL, NULL, NULL, NULL, aom_tm_predictor_16x16_neon)
#endif // HAVE_NEON
#if HAVE_MSA
-INTRA_PRED_TEST(MSA, TestIntraPred16, vpx_dc_predictor_16x16_msa,
- vpx_dc_left_predictor_16x16_msa, vpx_dc_top_predictor_16x16_msa,
- vpx_dc_128_predictor_16x16_msa, vpx_v_predictor_16x16_msa,
- vpx_h_predictor_16x16_msa, NULL, NULL, NULL, NULL, NULL, NULL,
- vpx_tm_predictor_16x16_msa)
+INTRA_PRED_TEST(MSA, TestIntraPred16, aom_dc_predictor_16x16_msa,
+ aom_dc_left_predictor_16x16_msa, aom_dc_top_predictor_16x16_msa,
+ aom_dc_128_predictor_16x16_msa, aom_v_predictor_16x16_msa,
+ aom_h_predictor_16x16_msa, NULL, NULL, NULL, NULL, NULL, NULL,
+ aom_tm_predictor_16x16_msa)
#endif // HAVE_MSA
// -----------------------------------------------------------------------------
// 32x32
-INTRA_PRED_TEST(C, TestIntraPred32, vpx_dc_predictor_32x32_c,
- vpx_dc_left_predictor_32x32_c, vpx_dc_top_predictor_32x32_c,
- vpx_dc_128_predictor_32x32_c, vpx_v_predictor_32x32_c,
- vpx_h_predictor_32x32_c, vpx_d45_predictor_32x32_c,
- vpx_d135_predictor_32x32_c, vpx_d117_predictor_32x32_c,
- vpx_d153_predictor_32x32_c, vpx_d207_predictor_32x32_c,
- vpx_d63_predictor_32x32_c, vpx_tm_predictor_32x32_c)
+INTRA_PRED_TEST(C, TestIntraPred32, aom_dc_predictor_32x32_c,
+ aom_dc_left_predictor_32x32_c, aom_dc_top_predictor_32x32_c,
+ aom_dc_128_predictor_32x32_c, aom_v_predictor_32x32_c,
+ aom_h_predictor_32x32_c, aom_d45_predictor_32x32_c,
+ aom_d135_predictor_32x32_c, aom_d117_predictor_32x32_c,
+ aom_d153_predictor_32x32_c, aom_d207_predictor_32x32_c,
+ aom_d63_predictor_32x32_c, aom_tm_predictor_32x32_c)
#if HAVE_SSE2
-INTRA_PRED_TEST(SSE2, TestIntraPred32, vpx_dc_predictor_32x32_sse2,
- vpx_dc_left_predictor_32x32_sse2,
- vpx_dc_top_predictor_32x32_sse2,
- vpx_dc_128_predictor_32x32_sse2, vpx_v_predictor_32x32_sse2,
- vpx_h_predictor_32x32_sse2, NULL, NULL, NULL, NULL, NULL, NULL,
- vpx_tm_predictor_32x32_sse2)
+INTRA_PRED_TEST(SSE2, TestIntraPred32, aom_dc_predictor_32x32_sse2,
+ aom_dc_left_predictor_32x32_sse2,
+ aom_dc_top_predictor_32x32_sse2,
+ aom_dc_128_predictor_32x32_sse2, aom_v_predictor_32x32_sse2,
+ aom_h_predictor_32x32_sse2, NULL, NULL, NULL, NULL, NULL, NULL,
+ aom_tm_predictor_32x32_sse2)
#endif // HAVE_SSE2
#if HAVE_SSSE3
INTRA_PRED_TEST(SSSE3, TestIntraPred32, NULL, NULL, NULL, NULL, NULL, NULL,
- vpx_d45_predictor_32x32_ssse3, NULL, NULL,
- vpx_d153_predictor_32x32_ssse3, vpx_d207_predictor_32x32_ssse3,
- vpx_d63_predictor_32x32_ssse3, NULL)
+ aom_d45_predictor_32x32_ssse3, NULL, NULL,
+ aom_d153_predictor_32x32_ssse3, aom_d207_predictor_32x32_ssse3,
+ aom_d63_predictor_32x32_ssse3, NULL)
#endif // HAVE_SSSE3
#if HAVE_NEON
-INTRA_PRED_TEST(NEON, TestIntraPred32, vpx_dc_predictor_32x32_neon,
- vpx_dc_left_predictor_32x32_neon,
- vpx_dc_top_predictor_32x32_neon,
- vpx_dc_128_predictor_32x32_neon, vpx_v_predictor_32x32_neon,
- vpx_h_predictor_32x32_neon, NULL, NULL, NULL, NULL, NULL, NULL,
- vpx_tm_predictor_32x32_neon)
+INTRA_PRED_TEST(NEON, TestIntraPred32, aom_dc_predictor_32x32_neon,
+ aom_dc_left_predictor_32x32_neon,
+ aom_dc_top_predictor_32x32_neon,
+ aom_dc_128_predictor_32x32_neon, aom_v_predictor_32x32_neon,
+ aom_h_predictor_32x32_neon, NULL, NULL, NULL, NULL, NULL, NULL,
+ aom_tm_predictor_32x32_neon)
#endif // HAVE_NEON
#if HAVE_MSA
-INTRA_PRED_TEST(MSA, TestIntraPred32, vpx_dc_predictor_32x32_msa,
- vpx_dc_left_predictor_32x32_msa, vpx_dc_top_predictor_32x32_msa,
- vpx_dc_128_predictor_32x32_msa, vpx_v_predictor_32x32_msa,
- vpx_h_predictor_32x32_msa, NULL, NULL, NULL, NULL, NULL, NULL,
- vpx_tm_predictor_32x32_msa)
+INTRA_PRED_TEST(MSA, TestIntraPred32, aom_dc_predictor_32x32_msa,
+ aom_dc_left_predictor_32x32_msa, aom_dc_top_predictor_32x32_msa,
+ aom_dc_128_predictor_32x32_msa, aom_v_predictor_32x32_msa,
+ aom_h_predictor_32x32_msa, NULL, NULL, NULL, NULL, NULL, NULL,
+ aom_tm_predictor_32x32_msa)
#endif // HAVE_MSA
-#include "test/test_libvpx.cc"
+#include "test/test_libaom.cc"
diff --git a/test/test_libvpx.cc b/test/test_libaom.cc
similarity index 88%
rename from test/test_libvpx.cc
rename to test/test_libaom.cc
index 3f650ab..c8ea59b 100644
--- a/test/test_libvpx.cc
+++ b/test/test_libaom.cc
@@ -11,16 +11,16 @@
#include "third_party/googletest/src/include/gtest/gtest.h"
-#include "./vpx_config.h"
+#include "./aom_config.h"
#if ARCH_X86 || ARCH_X86_64
#include "aom_ports/x86.h"
#endif
extern "C" {
-#if CONFIG_VP10
-extern void vp10_rtcd();
-#endif // CONFIG_VP10
-extern void vpx_dsp_rtcd();
-extern void vpx_scale_rtcd();
+#if CONFIG_AV1
+extern void av1_rtcd();
+#endif // CONFIG_AV1
+extern void aom_dsp_rtcd();
+extern void aom_scale_rtcd();
}
#if ARCH_X86 || ARCH_X86_64
@@ -54,11 +54,11 @@
// Shared library builds don't support whitebox tests
// that exercise internal symbols.
-#if CONFIG_VP10
- vp10_rtcd();
-#endif // CONFIG_VP10
- vpx_dsp_rtcd();
- vpx_scale_rtcd();
+#if CONFIG_AV1
+ av1_rtcd();
+#endif // CONFIG_AV1
+ aom_dsp_rtcd();
+ aom_scale_rtcd();
#endif // !CONFIG_SHARED
return RUN_ALL_TESTS();
diff --git a/test/tile_independence_test.cc b/test/tile_independence_test.cc
index 4cb50c3..cda69cd 100644
--- a/test/tile_independence_test.cc
+++ b/test/tile_independence_test.cc
@@ -17,7 +17,7 @@
#include "test/i420_video_source.h"
#include "test/util.h"
#include "test/md5_helper.h"
-#include "aom_mem/vpx_mem.h"
+#include "aom_mem/aom_mem.h"
namespace {
class TileIndependenceTest
@@ -27,21 +27,21 @@
TileIndependenceTest()
: EncoderTest(GET_PARAM(0)), md5_fw_order_(), md5_inv_order_(),
n_tile_cols_(GET_PARAM(1)), n_tile_rows_(GET_PARAM(2)) {
- init_flags_ = VPX_CODEC_USE_PSNR;
- vpx_codec_dec_cfg_t cfg = vpx_codec_dec_cfg_t();
+ init_flags_ = AOM_CODEC_USE_PSNR;
+ aom_codec_dec_cfg_t cfg = aom_codec_dec_cfg_t();
cfg.w = 704;
cfg.h = 144;
cfg.threads = 1;
fw_dec_ = codec_->CreateDecoder(cfg, 0);
inv_dec_ = codec_->CreateDecoder(cfg, 0);
- inv_dec_->Control(VP9_INVERT_TILE_DECODE_ORDER, 1);
+ inv_dec_->Control(AV1_INVERT_TILE_DECODE_ORDER, 1);
-#if CONFIG_VP10 && CONFIG_EXT_TILE
- if (fw_dec_->IsVP10() && inv_dec_->IsVP10()) {
- fw_dec_->Control(VP10_SET_DECODE_TILE_ROW, -1);
- fw_dec_->Control(VP10_SET_DECODE_TILE_COL, -1);
- inv_dec_->Control(VP10_SET_DECODE_TILE_ROW, -1);
- inv_dec_->Control(VP10_SET_DECODE_TILE_COL, -1);
+#if CONFIG_AV1 && CONFIG_EXT_TILE
+ if (fw_dec_->IsAV1() && inv_dec_->IsAV1()) {
+ fw_dec_->Control(AV1_SET_DECODE_TILE_ROW, -1);
+ fw_dec_->Control(AV1_SET_DECODE_TILE_COL, -1);
+ inv_dec_->Control(AV1_SET_DECODE_TILE_ROW, -1);
+ inv_dec_->Control(AV1_SET_DECODE_TILE_COL, -1);
}
#endif
}
@@ -59,40 +59,40 @@
virtual void PreEncodeFrameHook(libaom_test::VideoSource *video,
libaom_test::Encoder *encoder) {
if (video->frame() == 1) {
- encoder->Control(VP9E_SET_TILE_COLUMNS, n_tile_cols_);
- encoder->Control(VP9E_SET_TILE_ROWS, n_tile_rows_);
+ encoder->Control(AV1E_SET_TILE_COLUMNS, n_tile_cols_);
+ encoder->Control(AV1E_SET_TILE_ROWS, n_tile_rows_);
SetCpuUsed(encoder);
}
}
virtual void SetCpuUsed(libaom_test::Encoder *encoder) {
static const int kCpuUsed = 3;
- encoder->Control(VP8E_SET_CPUUSED, kCpuUsed);
+ encoder->Control(AOME_SET_CPUUSED, kCpuUsed);
}
- void UpdateMD5(::libaom_test::Decoder *dec, const vpx_codec_cx_pkt_t *pkt,
+ void UpdateMD5(::libaom_test::Decoder *dec, const aom_codec_cx_pkt_t *pkt,
::libaom_test::MD5 *md5) {
- const vpx_codec_err_t res = dec->DecodeFrame(
+ const aom_codec_err_t res = dec->DecodeFrame(
reinterpret_cast<uint8_t *>(pkt->data.frame.buf), pkt->data.frame.sz);
- if (res != VPX_CODEC_OK) {
+ if (res != AOM_CODEC_OK) {
abort_ = true;
- ASSERT_EQ(VPX_CODEC_OK, res);
+ ASSERT_EQ(AOM_CODEC_OK, res);
}
- const vpx_image_t *img = dec->GetDxData().Next();
+ const aom_image_t *img = dec->GetDxData().Next();
md5->Add(img);
}
- virtual void FramePktHook(const vpx_codec_cx_pkt_t *pkt) {
+ virtual void FramePktHook(const aom_codec_cx_pkt_t *pkt) {
UpdateMD5(fw_dec_, pkt, &md5_fw_order_);
UpdateMD5(inv_dec_, pkt, &md5_inv_order_);
}
void DoTest() {
- const vpx_rational timebase = { 33333333, 1000000000 };
+ const aom_rational timebase = { 33333333, 1000000000 };
cfg_.g_timebase = timebase;
cfg_.rc_target_bitrate = 500;
cfg_.g_lag_in_frames = 12;
- cfg_.rc_end_usage = VPX_VBR;
+ cfg_.rc_end_usage = AOM_VBR;
libaom_test::I420VideoSource video("hantro_collage_w352h288.yuv", 704, 576,
timebase.den, timebase.num, 0, 5);
@@ -119,22 +119,22 @@
class TileIndependenceTestLarge : public TileIndependenceTest {
virtual void SetCpuUsed(libaom_test::Encoder *encoder) {
static const int kCpuUsed = 0;
- encoder->Control(VP8E_SET_CPUUSED, kCpuUsed);
+ encoder->Control(AOME_SET_CPUUSED, kCpuUsed);
}
};
TEST_P(TileIndependenceTestLarge, MD5Match) { DoTest(); }
#if CONFIG_EXT_TILE
-VP10_INSTANTIATE_TEST_CASE(TileIndependenceTest, ::testing::Values(1, 2, 32),
- ::testing::Values(1, 2, 32));
-VP10_INSTANTIATE_TEST_CASE(TileIndependenceTestLarge,
- ::testing::Values(1, 2, 32),
- ::testing::Values(1, 2, 32));
+AV1_INSTANTIATE_TEST_CASE(TileIndependenceTest, ::testing::Values(1, 2, 32),
+ ::testing::Values(1, 2, 32));
+AV1_INSTANTIATE_TEST_CASE(TileIndependenceTestLarge,
+ ::testing::Values(1, 2, 32),
+ ::testing::Values(1, 2, 32));
#else
-VP10_INSTANTIATE_TEST_CASE(TileIndependenceTest, ::testing::Values(0, 1),
- ::testing::Values(0, 1));
-VP10_INSTANTIATE_TEST_CASE(TileIndependenceTestLarge, ::testing::Values(0, 1),
- ::testing::Values(0, 1));
+AV1_INSTANTIATE_TEST_CASE(TileIndependenceTest, ::testing::Values(0, 1),
+ ::testing::Values(0, 1));
+AV1_INSTANTIATE_TEST_CASE(TileIndependenceTestLarge, ::testing::Values(0, 1),
+ ::testing::Values(0, 1));
#endif // CONFIG_EXT_TILE
} // namespace
diff --git a/test/tools_common.sh b/test/tools_common.sh
index 2e10437..2e4ea30 100755
--- a/test/tools_common.sh
+++ b/test/tools_common.sh
@@ -10,59 +10,59 @@
##
## This file contains shell code shared by test scripts for libaom tools.
-# Use $VPX_TEST_TOOLS_COMMON_SH as a pseudo include guard.
-if [ -z "${VPX_TEST_TOOLS_COMMON_SH}" ]; then
-VPX_TEST_TOOLS_COMMON_SH=included
+# Use $AOM_TEST_TOOLS_COMMON_SH as a pseudo include guard.
+if [ -z "${AOM_TEST_TOOLS_COMMON_SH}" ]; then
+AOM_TEST_TOOLS_COMMON_SH=included
set -e
devnull='> /dev/null 2>&1'
-VPX_TEST_PREFIX=""
+AOM_TEST_PREFIX=""
elog() {
echo "$@" 1>&2
}
vlog() {
- if [ "${VPX_TEST_VERBOSE_OUTPUT}" = "yes" ]; then
+ if [ "${AOM_TEST_VERBOSE_OUTPUT}" = "yes" ]; then
echo "$@"
fi
}
-# Sets $VPX_TOOL_TEST to the name specified by positional parameter one.
+# Sets $AOM_TOOL_TEST to the name specified by positional parameter one.
test_begin() {
- VPX_TOOL_TEST="${1}"
+ AOM_TOOL_TEST="${1}"
}
-# Clears the VPX_TOOL_TEST variable after confirming that $VPX_TOOL_TEST matches
+# Clears the AOM_TOOL_TEST variable after confirming that $AOM_TOOL_TEST matches
# positional parameter one.
test_end() {
- if [ "$1" != "${VPX_TOOL_TEST}" ]; then
+ if [ "$1" != "${AOM_TOOL_TEST}" ]; then
echo "FAIL completed test mismatch!."
echo " completed test: ${1}"
- echo " active test: ${VPX_TOOL_TEST}."
+ echo " active test: ${AOM_TOOL_TEST}."
return 1
fi
- VPX_TOOL_TEST='<unset>'
+ AOM_TOOL_TEST='<unset>'
}
# Echoes the target configuration being tested.
test_configuration_target() {
- vpx_config_mk="${LIBAOM_CONFIG_PATH}/config.mk"
+ aom_config_mk="${LIBAOM_CONFIG_PATH}/config.mk"
# Find the TOOLCHAIN line, split it using ':=' as the field separator, and
# print the last field to get the value. Then pipe the value to tr to consume
# any leading/trailing spaces while allowing tr to echo the output to stdout.
- awk -F ':=' '/TOOLCHAIN/ { print $NF }' "${vpx_config_mk}" | tr -d ' '
+ awk -F ':=' '/TOOLCHAIN/ { print $NF }' "${aom_config_mk}" | tr -d ' '
}
# Trap function used for failure reports and tool output directory removal.
-# When the contents of $VPX_TOOL_TEST do not match the string '<unset>', reports
-# failure of test stored in $VPX_TOOL_TEST.
+# When the contents of $AOM_TOOL_TEST do not match the string '<unset>', reports
+# failure of test stored in $AOM_TOOL_TEST.
cleanup() {
- if [ -n "${VPX_TOOL_TEST}" ] && [ "${VPX_TOOL_TEST}" != '<unset>' ]; then
- echo "FAIL: $VPX_TOOL_TEST"
+ if [ -n "${AOM_TOOL_TEST}" ] && [ "${AOM_TOOL_TEST}" != '<unset>' ]; then
+ echo "FAIL: $AOM_TOOL_TEST"
fi
- if [ -n "${VPX_TEST_OUTPUT_DIR}" ] && [ -d "${VPX_TEST_OUTPUT_DIR}" ]; then
- rm -rf "${VPX_TEST_OUTPUT_DIR}"
+ if [ -n "${AOM_TEST_OUTPUT_DIR}" ] && [ -d "${AOM_TEST_OUTPUT_DIR}" ]; then
+ rm -rf "${AOM_TEST_OUTPUT_DIR}"
fi
}
@@ -70,17 +70,17 @@
# $LIBAOM_CONFIG_PATH/config.mk to stdout, or the version number string when
# no git hash is contained in VERSION_STRING.
config_hash() {
- vpx_config_mk="${LIBAOM_CONFIG_PATH}/config.mk"
+ aom_config_mk="${LIBAOM_CONFIG_PATH}/config.mk"
# Find VERSION_STRING line, split it with "-g" and print the last field to
# output the git hash to stdout.
- vpx_version=$(awk -F -g '/VERSION_STRING/ {print $NF}' "${vpx_config_mk}")
+ aom_version=$(awk -F -g '/VERSION_STRING/ {print $NF}' "${aom_config_mk}")
# Handle two situations here:
- # 1. The default case: $vpx_version is a git hash, so echo it unchanged.
+ # 1. The default case: $aom_version is a git hash, so echo it unchanged.
# 2. When being run a non-dev tree, the -g portion is not present in the
# version string: It's only the version number.
- # In this case $vpx_version is something like 'VERSION_STRING=v1.3.0', so
+ # In this case $aom_version is something like 'VERSION_STRING=v1.3.0', so
# we echo only what is after the '='.
- echo "${vpx_version##*=}"
+ echo "${aom_version##*=}"
}
# Echoes the short form of the current git hash.
@@ -95,7 +95,7 @@
fi
}
-# Echoes warnings to stdout when git hash in vpx_config.h does not match the
+# Echoes warnings to stdout when git hash in aom_config.h does not match the
# current git hash.
check_git_hashes() {
hash_at_configure_time=$(config_hash)
@@ -120,19 +120,19 @@
# This script requires that the LIBAOM_BIN_PATH, LIBAOM_CONFIG_PATH, and
# LIBVPX_TEST_DATA_PATH variables are in the environment: Confirm that
# the variables are set and that they all evaluate to directory paths.
-verify_vpx_test_environment() {
+verify_aom_test_environment() {
test_env_var_dir "LIBAOM_BIN_PATH" \
&& test_env_var_dir "LIBAOM_CONFIG_PATH" \
&& test_env_var_dir "LIBVPX_TEST_DATA_PATH"
}
-# Greps vpx_config.h in LIBAOM_CONFIG_PATH for positional parameter one, which
+# Greps aom_config.h in LIBAOM_CONFIG_PATH for positional parameter one, which
# should be a LIBAOM preprocessor flag. Echoes yes to stdout when the feature
# is available.
-vpx_config_option_enabled() {
- vpx_config_option="${1}"
- vpx_config_file="${LIBAOM_CONFIG_PATH}/vpx_config.h"
- config_line=$(grep "${vpx_config_option}" "${vpx_config_file}")
+aom_config_option_enabled() {
+ aom_config_option="${1}"
+ aom_config_file="${LIBAOM_CONFIG_PATH}/aom_config.h"
+ config_line=$(grep "${aom_config_option}" "${aom_config_file}")
if echo "${config_line}" | egrep -q '1$'; then
echo yes
fi
@@ -149,13 +149,13 @@
# Echoes path to $1 when it's executable and exists in ${LIBAOM_BIN_PATH}, or an
# empty string. Caller is responsible for testing the string once the function
# returns.
-vpx_tool_path() {
+aom_tool_path() {
local readonly tool_name="$1"
- local tool_path="${LIBAOM_BIN_PATH}/${tool_name}${VPX_TEST_EXE_SUFFIX}"
+ local tool_path="${LIBAOM_BIN_PATH}/${tool_name}${AOM_TEST_EXE_SUFFIX}"
if [ ! -x "${tool_path}" ]; then
# Try one directory up: when running via examples.sh the tool could be in
# the parent directory of $LIBAOM_BIN_PATH.
- tool_path="${LIBAOM_BIN_PATH}/../${tool_name}${VPX_TEST_EXE_SUFFIX}"
+ tool_path="${LIBAOM_BIN_PATH}/../${tool_name}${AOM_TEST_EXE_SUFFIX}"
fi
if [ ! -x "${tool_path}" ]; then
@@ -166,28 +166,28 @@
# Echoes yes to stdout when the file named by positional parameter one exists
# in LIBAOM_BIN_PATH, and is executable.
-vpx_tool_available() {
+aom_tool_available() {
local tool_name="$1"
- local tool="${LIBAOM_BIN_PATH}/${tool_name}${VPX_TEST_EXE_SUFFIX}"
+ local tool="${LIBAOM_BIN_PATH}/${tool_name}${AOM_TEST_EXE_SUFFIX}"
[ -x "${tool}" ] && echo yes
}
-# Echoes yes to stdout when vpx_config_option_enabled() reports yes for
-# CONFIG_VP10_DECODER.
-vp10_decode_available() {
- [ "$(vpx_config_option_enabled CONFIG_VP10_DECODER)" = "yes" ] && echo yes
+# Echoes yes to stdout when aom_config_option_enabled() reports yes for
+# CONFIG_AV1_DECODER.
+av1_decode_available() {
+ [ "$(aom_config_option_enabled CONFIG_AV1_DECODER)" = "yes" ] && echo yes
}
-# Echoes yes to stdout when vpx_config_option_enabled() reports yes for
-# CONFIG_VP10_ENCODER.
-vp10_encode_available() {
- [ "$(vpx_config_option_enabled CONFIG_VP10_ENCODER)" = "yes" ] && echo yes
+# Echoes yes to stdout when aom_config_option_enabled() reports yes for
+# CONFIG_AV1_ENCODER.
+av1_encode_available() {
+ [ "$(aom_config_option_enabled CONFIG_AV1_ENCODER)" = "yes" ] && echo yes
}
-# Echoes yes to stdout when vpx_config_option_enabled() reports yes for
+# Echoes yes to stdout when aom_config_option_enabled() reports yes for
# CONFIG_WEBM_IO.
webm_io_available() {
- [ "$(vpx_config_option_enabled CONFIG_WEBM_IO)" = "yes" ] && echo yes
+ [ "$(aom_config_option_enabled CONFIG_WEBM_IO)" = "yes" ] && echo yes
}
# Filters strings from $1 using the filter specified by $2. Filter behavior
@@ -223,28 +223,28 @@
# Runs user test functions passed via positional parameters one and two.
# Functions in positional parameter one are treated as environment verification
# functions and are run unconditionally. Functions in positional parameter two
-# are run according to the rules specified in vpx_test_usage().
+# are run according to the rules specified in aom_test_usage().
run_tests() {
- local env_tests="verify_vpx_test_environment $1"
+ local env_tests="verify_aom_test_environment $1"
local tests_to_filter="$2"
- local test_name="${VPX_TEST_NAME}"
+ local test_name="${AOM_TEST_NAME}"
if [ -z "${test_name}" ]; then
test_name="$(basename "${0%.*}")"
fi
- if [ "${VPX_TEST_RUN_DISABLED_TESTS}" != "yes" ]; then
+ if [ "${AOM_TEST_RUN_DISABLED_TESTS}" != "yes" ]; then
# Filter out DISABLED tests.
tests_to_filter=$(filter_strings "${tests_to_filter}" ^DISABLED exclude)
fi
- if [ -n "${VPX_TEST_FILTER}" ]; then
+ if [ -n "${AOM_TEST_FILTER}" ]; then
# Remove tests not matching the user's filter.
- tests_to_filter=$(filter_strings "${tests_to_filter}" ${VPX_TEST_FILTER})
+ tests_to_filter=$(filter_strings "${tests_to_filter}" ${AOM_TEST_FILTER})
fi
# User requested test listing: Dump test names and return.
- if [ "${VPX_TEST_LIST_TESTS}" = "yes" ]; then
+ if [ "${AOM_TEST_LIST_TESTS}" = "yes" ]; then
for test_name in $tests_to_filter; do
echo ${test_name}
done
@@ -272,7 +272,7 @@
echo "${test_name}: Done, all tests pass for ${tested_config}."
}
-vpx_test_usage() {
+aom_test_usage() {
cat << EOF
Usage: ${0##*/} [arguments]
--bin-path <path to libaom binaries directory>
@@ -301,7 +301,7 @@
# Returns non-zero (failure) when required environment variables are empty
# strings.
-vpx_test_check_environment() {
+aom_test_check_environment() {
if [ -z "${LIBAOM_BIN_PATH}" ] || \
[ -z "${LIBAOM_CONFIG_PATH}" ] || \
[ -z "${LIBVPX_TEST_DATA_PATH}" ]; then
@@ -321,14 +321,14 @@
shift
;;
--filter)
- VPX_TEST_FILTER="$2"
+ AOM_TEST_FILTER="$2"
shift
;;
--run-disabled-tests)
- VPX_TEST_RUN_DISABLED_TESTS=yes
+ AOM_TEST_RUN_DISABLED_TESTS=yes
;;
--help)
- vpx_test_usage
+ aom_test_usage
exit
;;
--test-data-path)
@@ -336,20 +336,20 @@
shift
;;
--prefix)
- VPX_TEST_PREFIX="$2"
+ AOM_TEST_PREFIX="$2"
shift
;;
--verbose)
- VPX_TEST_VERBOSE_OUTPUT=yes
+ AOM_TEST_VERBOSE_OUTPUT=yes
;;
--show-program-output)
devnull=
;;
--list-tests)
- VPX_TEST_LIST_TESTS=yes
+ AOM_TEST_LIST_TESTS=yes
;;
*)
- vpx_test_usage
+ aom_test_usage
exit 1
;;
esac
@@ -364,33 +364,33 @@
# Create a temporary directory for output files, and a trap to clean it up.
if [ -n "${TMPDIR}" ]; then
- VPX_TEST_TEMP_ROOT="${TMPDIR}"
+ AOM_TEST_TEMP_ROOT="${TMPDIR}"
elif [ -n "${TEMPDIR}" ]; then
- VPX_TEST_TEMP_ROOT="${TEMPDIR}"
+ AOM_TEST_TEMP_ROOT="${TEMPDIR}"
else
- VPX_TEST_TEMP_ROOT=/tmp
+ AOM_TEST_TEMP_ROOT=/tmp
fi
-VPX_TEST_OUTPUT_DIR="${VPX_TEST_TEMP_ROOT}/vpx_test_$$"
+AOM_TEST_OUTPUT_DIR="${AOM_TEST_TEMP_ROOT}/aom_test_$$"
-if ! mkdir -p "${VPX_TEST_OUTPUT_DIR}" || \
- [ ! -d "${VPX_TEST_OUTPUT_DIR}" ]; then
+if ! mkdir -p "${AOM_TEST_OUTPUT_DIR}" || \
+ [ ! -d "${AOM_TEST_OUTPUT_DIR}" ]; then
echo "${0##*/}: Cannot create output directory, giving up."
- echo "${0##*/}: VPX_TEST_OUTPUT_DIR=${VPX_TEST_OUTPUT_DIR}"
+ echo "${0##*/}: AOM_TEST_OUTPUT_DIR=${AOM_TEST_OUTPUT_DIR}"
exit 1
fi
if [ "$(is_windows_target)" = "yes" ]; then
- VPX_TEST_EXE_SUFFIX=".exe"
+ AOM_TEST_EXE_SUFFIX=".exe"
fi
# Variables shared by tests.
VP8_IVF_FILE="${LIBVPX_TEST_DATA_PATH}/vp80-00-comprehensive-001.ivf"
-VP9_IVF_FILE="${LIBVPX_TEST_DATA_PATH}/vp90-2-09-subpixel-00.ivf"
+AV1_IVF_FILE="${LIBVPX_TEST_DATA_PATH}/vp90-2-09-subpixel-00.ivf"
-VP9_WEBM_FILE="${LIBVPX_TEST_DATA_PATH}/vp90-2-00-quantizer-00.webm"
-VP9_FPM_WEBM_FILE="${LIBVPX_TEST_DATA_PATH}/vp90-2-07-frame_parallel-1.webm"
-VP9_LT_50_FRAMES_WEBM_FILE="${LIBVPX_TEST_DATA_PATH}/vp90-2-02-size-32x08.webm"
+AV1_WEBM_FILE="${LIBVPX_TEST_DATA_PATH}/vp90-2-00-quantizer-00.webm"
+AV1_FPM_WEBM_FILE="${LIBVPX_TEST_DATA_PATH}/vp90-2-07-frame_parallel-1.webm"
+AV1_LT_50_FRAMES_WEBM_FILE="${LIBVPX_TEST_DATA_PATH}/vp90-2-02-size-32x08.webm"
YUV_RAW_INPUT="${LIBVPX_TEST_DATA_PATH}/hantro_collage_w352h288.yuv"
YUV_RAW_INPUT_WIDTH=352
@@ -406,21 +406,21 @@
LIBAOM_BIN_PATH=${LIBAOM_BIN_PATH}
LIBAOM_CONFIG_PATH=${LIBAOM_CONFIG_PATH}
LIBVPX_TEST_DATA_PATH=${LIBVPX_TEST_DATA_PATH}
- VP8_IVF_FILE=${VP8_IVF_FILE}
- VP9_IVF_FILE=${VP9_IVF_FILE}
- VP9_WEBM_FILE=${VP9_WEBM_FILE}
- VPX_TEST_EXE_SUFFIX=${VPX_TEST_EXE_SUFFIX}
- VPX_TEST_FILTER=${VPX_TEST_FILTER}
- VPX_TEST_LIST_TESTS=${VPX_TEST_LIST_TESTS}
- VPX_TEST_OUTPUT_DIR=${VPX_TEST_OUTPUT_DIR}
- VPX_TEST_PREFIX=${VPX_TEST_PREFIX}
- VPX_TEST_RUN_DISABLED_TESTS=${VPX_TEST_RUN_DISABLED_TESTS}
- VPX_TEST_SHOW_PROGRAM_OUTPUT=${VPX_TEST_SHOW_PROGRAM_OUTPUT}
- VPX_TEST_TEMP_ROOT=${VPX_TEST_TEMP_ROOT}
- VPX_TEST_VERBOSE_OUTPUT=${VPX_TEST_VERBOSE_OUTPUT}
+ AOM_IVF_FILE=${AOM_IVF_FILE}
+ AV1_IVF_FILE=${AV1_IVF_FILE}
+ AV1_WEBM_FILE=${AV1_WEBM_FILE}
+ AOM_TEST_EXE_SUFFIX=${AOM_TEST_EXE_SUFFIX}
+ AOM_TEST_FILTER=${AOM_TEST_FILTER}
+ AOM_TEST_LIST_TESTS=${AOM_TEST_LIST_TESTS}
+ AOM_TEST_OUTPUT_DIR=${AOM_TEST_OUTPUT_DIR}
+ AOM_TEST_PREFIX=${AOM_TEST_PREFIX}
+ AOM_TEST_RUN_DISABLED_TESTS=${AOM_TEST_RUN_DISABLED_TESTS}
+ AOM_TEST_SHOW_PROGRAM_OUTPUT=${AOM_TEST_SHOW_PROGRAM_OUTPUT}
+ AOM_TEST_TEMP_ROOT=${AOM_TEST_TEMP_ROOT}
+ AOM_TEST_VERBOSE_OUTPUT=${AOM_TEST_VERBOSE_OUTPUT}
YUV_RAW_INPUT=${YUV_RAW_INPUT}
YUV_RAW_INPUT_WIDTH=${YUV_RAW_INPUT_WIDTH}
YUV_RAW_INPUT_HEIGHT=${YUV_RAW_INPUT_HEIGHT}
Y4M_NOSQ_PAR_INPUT=${Y4M_NOSQ_PAR_INPUT}"
-fi # End $VPX_TEST_TOOLS_COMMON_SH pseudo include guard.
+fi # End $AOM_TEST_TOOLS_COMMON_SH pseudo include guard.
diff --git a/test/transform_test_base.h b/test/transform_test_base.h
index a09897c..a128b3b 100644
--- a/test/transform_test_base.h
+++ b/test/transform_test_base.h
@@ -10,19 +10,19 @@
#ifndef TEST_TRANSFORM_TEST_BASE_H_
#define TEST_TRANSFORM_TEST_BASE_H_
-#include "./vpx_config.h"
-#include "aom_mem/vpx_mem.h"
-#include "aom/vpx_codec.h"
+#include "./aom_config.h"
+#include "aom_mem/aom_mem.h"
+#include "aom/aom_codec.h"
namespace libaom_test {
// Note:
-// Same constant are defined in vp9/common/vp9_entropy.h and
+// Same constant are defined in av1/common/av1_entropy.h and
// av1/common/entropy.h. Goal is to make this base class
// to use for future codec transform testing. But including
// either of them would lead to compiling error when we do
// unit test for another codec. Suggest to move the definition
-// to a vpx header file.
+// to a aom header file.
const int kDctMaxValue = 16384;
typedef void (*FhtFunc)(const int16_t *in, tran_low_t *out, int stride,
@@ -44,28 +44,28 @@
const int count_test_block = 10000;
int16_t *test_input_block = reinterpret_cast<int16_t *>(
- vpx_memalign(16, sizeof(int16_t) * num_coeffs_));
+ aom_memalign(16, sizeof(int16_t) * num_coeffs_));
tran_low_t *test_temp_block = reinterpret_cast<tran_low_t *>(
- vpx_memalign(16, sizeof(tran_low_t) * num_coeffs_));
+ aom_memalign(16, sizeof(tran_low_t) * num_coeffs_));
uint8_t *dst = reinterpret_cast<uint8_t *>(
- vpx_memalign(16, sizeof(uint8_t) * num_coeffs_));
+ aom_memalign(16, sizeof(uint8_t) * num_coeffs_));
uint8_t *src = reinterpret_cast<uint8_t *>(
- vpx_memalign(16, sizeof(uint8_t) * num_coeffs_));
-#if CONFIG_VP9_HIGHBITDEPTH
+ aom_memalign(16, sizeof(uint8_t) * num_coeffs_));
+#if CONFIG_AOM_HIGHBITDEPTH
uint16_t *dst16 = reinterpret_cast<uint16_t *>(
- vpx_memalign(16, sizeof(uint16_t) * num_coeffs_));
+ aom_memalign(16, sizeof(uint16_t) * num_coeffs_));
uint16_t *src16 = reinterpret_cast<uint16_t *>(
- vpx_memalign(16, sizeof(uint16_t) * num_coeffs_));
+ aom_memalign(16, sizeof(uint16_t) * num_coeffs_));
#endif
for (int i = 0; i < count_test_block; ++i) {
// Initialize a test block with input range [-255, 255].
for (int j = 0; j < num_coeffs_; ++j) {
- if (bit_depth_ == VPX_BITS_8) {
+ if (bit_depth_ == AOM_BITS_8) {
src[j] = rnd.Rand8();
dst[j] = rnd.Rand8();
test_input_block[j] = src[j] - dst[j];
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
} else {
src16[j] = rnd.Rand16() & mask_;
dst16[j] = rnd.Rand16() & mask_;
@@ -76,9 +76,9 @@
ASM_REGISTER_STATE_CHECK(
RunFwdTxfm(test_input_block, test_temp_block, pitch_));
- if (bit_depth_ == VPX_BITS_8) {
+ if (bit_depth_ == AOM_BITS_8) {
ASM_REGISTER_STATE_CHECK(RunInvTxfm(test_temp_block, dst, pitch_));
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
} else {
ASM_REGISTER_STATE_CHECK(
RunInvTxfm(test_temp_block, CONVERT_TO_BYTEPTR(dst16), pitch_));
@@ -86,11 +86,11 @@
}
for (int j = 0; j < num_coeffs_; ++j) {
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
const uint32_t diff =
- bit_depth_ == VPX_BITS_8 ? dst[j] - src[j] : dst16[j] - src16[j];
+ bit_depth_ == AOM_BITS_8 ? dst[j] - src[j] : dst16[j] - src16[j];
#else
- ASSERT_EQ(VPX_BITS_8, bit_depth_);
+ ASSERT_EQ(AOM_BITS_8, bit_depth_);
const uint32_t diff = dst[j] - src[j];
#endif
const uint32_t error = diff * diff;
@@ -106,13 +106,13 @@
<< "Error: 4x4 FHT/IHT has average round trip error > " << limit
<< " per block";
- vpx_free(test_input_block);
- vpx_free(test_temp_block);
- vpx_free(dst);
- vpx_free(src);
-#if CONFIG_VP9_HIGHBITDEPTH
- vpx_free(dst16);
- vpx_free(src16);
+ aom_free(test_input_block);
+ aom_free(test_temp_block);
+ aom_free(dst);
+ aom_free(src);
+#if CONFIG_AOM_HIGHBITDEPTH
+ aom_free(dst16);
+ aom_free(src16);
#endif
}
@@ -121,11 +121,11 @@
const int count_test_block = 5000;
int16_t *input_block = reinterpret_cast<int16_t *>(
- vpx_memalign(16, sizeof(int16_t) * num_coeffs_));
+ aom_memalign(16, sizeof(int16_t) * num_coeffs_));
tran_low_t *output_ref_block = reinterpret_cast<tran_low_t *>(
- vpx_memalign(16, sizeof(tran_low_t) * num_coeffs_));
+ aom_memalign(16, sizeof(tran_low_t) * num_coeffs_));
tran_low_t *output_block = reinterpret_cast<tran_low_t *>(
- vpx_memalign(16, sizeof(tran_low_t) * num_coeffs_));
+ aom_memalign(16, sizeof(tran_low_t) * num_coeffs_));
for (int i = 0; i < count_test_block; ++i) {
// Initialize a test block with input range [-mask_, mask_].
@@ -142,9 +142,9 @@
<< " at test block: " << i;
}
}
- vpx_free(input_block);
- vpx_free(output_ref_block);
- vpx_free(output_block);
+ aom_free(input_block);
+ aom_free(output_ref_block);
+ aom_free(output_block);
}
void RunMemCheck() {
@@ -152,11 +152,11 @@
const int count_test_block = 5000;
int16_t *input_extreme_block = reinterpret_cast<int16_t *>(
- vpx_memalign(16, sizeof(int16_t) * num_coeffs_));
+ aom_memalign(16, sizeof(int16_t) * num_coeffs_));
tran_low_t *output_ref_block = reinterpret_cast<tran_low_t *>(
- vpx_memalign(16, sizeof(tran_low_t) * num_coeffs_));
+ aom_memalign(16, sizeof(tran_low_t) * num_coeffs_));
tran_low_t *output_block = reinterpret_cast<tran_low_t *>(
- vpx_memalign(16, sizeof(tran_low_t) * num_coeffs_));
+ aom_memalign(16, sizeof(tran_low_t) * num_coeffs_));
for (int i = 0; i < count_test_block; ++i) {
// Initialize a test block with input range [-mask_, mask_].
@@ -182,9 +182,9 @@
<< "Error: NxN FDCT has coefficient larger than N*DCT_MAX_VALUE";
}
}
- vpx_free(input_extreme_block);
- vpx_free(output_ref_block);
- vpx_free(output_block);
+ aom_free(input_extreme_block);
+ aom_free(output_ref_block);
+ aom_free(output_block);
}
void RunInvAccuracyCheck(int limit) {
@@ -192,29 +192,29 @@
const int count_test_block = 1000;
int16_t *in = reinterpret_cast<int16_t *>(
- vpx_memalign(16, sizeof(int16_t) * num_coeffs_));
+ aom_memalign(16, sizeof(int16_t) * num_coeffs_));
tran_low_t *coeff = reinterpret_cast<tran_low_t *>(
- vpx_memalign(16, sizeof(tran_low_t) * num_coeffs_));
+ aom_memalign(16, sizeof(tran_low_t) * num_coeffs_));
uint8_t *dst = reinterpret_cast<uint8_t *>(
- vpx_memalign(16, sizeof(uint8_t) * num_coeffs_));
+ aom_memalign(16, sizeof(uint8_t) * num_coeffs_));
uint8_t *src = reinterpret_cast<uint8_t *>(
- vpx_memalign(16, sizeof(uint8_t) * num_coeffs_));
+ aom_memalign(16, sizeof(uint8_t) * num_coeffs_));
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
uint16_t *dst16 = reinterpret_cast<uint16_t *>(
- vpx_memalign(16, sizeof(uint16_t) * num_coeffs_));
+ aom_memalign(16, sizeof(uint16_t) * num_coeffs_));
uint16_t *src16 = reinterpret_cast<uint16_t *>(
- vpx_memalign(16, sizeof(uint16_t) * num_coeffs_));
+ aom_memalign(16, sizeof(uint16_t) * num_coeffs_));
#endif
for (int i = 0; i < count_test_block; ++i) {
// Initialize a test block with input range [-mask_, mask_].
for (int j = 0; j < num_coeffs_; ++j) {
- if (bit_depth_ == VPX_BITS_8) {
+ if (bit_depth_ == AOM_BITS_8) {
src[j] = rnd.Rand8();
dst[j] = rnd.Rand8();
in[j] = src[j] - dst[j];
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
} else {
src16[j] = rnd.Rand16() & mask_;
dst16[j] = rnd.Rand16() & mask_;
@@ -225,9 +225,9 @@
fwd_txfm_ref(in, coeff, pitch_, tx_type_);
- if (bit_depth_ == VPX_BITS_8) {
+ if (bit_depth_ == AOM_BITS_8) {
ASM_REGISTER_STATE_CHECK(RunInvTxfm(coeff, dst, pitch_));
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
} else {
ASM_REGISTER_STATE_CHECK(
RunInvTxfm(coeff, CONVERT_TO_BYTEPTR(dst16), pitch_));
@@ -235,9 +235,9 @@
}
for (int j = 0; j < num_coeffs_; ++j) {
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
const uint32_t diff =
- bit_depth_ == VPX_BITS_8 ? dst[j] - src[j] : dst16[j] - src16[j];
+ bit_depth_ == AOM_BITS_8 ? dst[j] - src[j] : dst16[j] - src16[j];
#else
const uint32_t diff = dst[j] - src[j];
#endif
@@ -246,20 +246,20 @@
<< "Error: 4x4 IDCT has error " << error << " at index " << j;
}
}
- vpx_free(in);
- vpx_free(coeff);
- vpx_free(dst);
- vpx_free(src);
-#if CONFIG_VP9_HIGHBITDEPTH
- vpx_free(src16);
- vpx_free(dst16);
+ aom_free(in);
+ aom_free(coeff);
+ aom_free(dst);
+ aom_free(src);
+#if CONFIG_AOM_HIGHBITDEPTH
+ aom_free(src16);
+ aom_free(dst16);
#endif
}
int pitch_;
int tx_type_;
FhtFunc fwd_txfm_ref;
- vpx_bit_depth_t bit_depth_;
+ aom_bit_depth_t bit_depth_;
int mask_;
int num_coeffs_;
diff --git a/test/twopass_encoder.sh b/test/twopass_encoder.sh
index 222f170..5e2a97b 100755
--- a/test/twopass_encoder.sh
+++ b/test/twopass_encoder.sh
@@ -18,7 +18,7 @@
# Environment check: $YUV_RAW_INPUT is required.
twopass_encoder_verify_environment() {
if [ ! -e "${YUV_RAW_INPUT}" ]; then
- echo "Libvpx test data must exist in LIBVPX_TEST_DATA_PATH."
+ echo "Libaom test data must exist in LIBVPX_TEST_DATA_PATH."
return 1
fi
}
@@ -26,35 +26,38 @@
# Runs twopass_encoder using the codec specified by $1 with a frame limit of
# 100.
twopass_encoder() {
- local encoder="${LIBAOM_BIN_PATH}/twopass_encoder${VPX_TEST_EXE_SUFFIX}"
+ local encoder="${LIBAOM_BIN_PATH}/twopass_encoder${AOM_TEST_EXE_SUFFIX}"
local codec="$1"
- local output_file="${VPX_TEST_OUTPUT_DIR}/twopass_encoder_${codec}.ivf"
+ local output_file="${AOM_TEST_OUTPUT_DIR}/twopass_encoder_${codec}.ivf"
if [ ! -x "${encoder}" ]; then
elog "${encoder} does not exist or is not executable."
return 1
fi
- eval "${VPX_TEST_PREFIX}" "${encoder}" "${codec}" "${YUV_RAW_INPUT_WIDTH}" \
+ eval "${AOM_TEST_PREFIX}" "${encoder}" "${codec}" "${YUV_RAW_INPUT_WIDTH}" \
"${YUV_RAW_INPUT_HEIGHT}" "${YUV_RAW_INPUT}" "${output_file}" 100 \
${devnull}
[ -e "${output_file}" ] || return 1
}
-twopass_encoder_vp8() {
- if [ "$(vp8_encode_available)" = "yes" ]; then
- twopass_encoder vp8 || return 1
+twopass_encoder_aom() {
+ if [ "$(aom_encode_available)" = "yes" ]; then
+ twopass_encoder aom || return 1
fi
}
-twopass_encoder_vp9() {
- if [ "$(vp9_encode_available)" = "yes" ]; then
- twopass_encoder vp9 || return 1
+# TODO(tomfinegan): Add a frame limit param to twopass_encoder and enable this
+# test. AV1 is just too slow right now: This test takes 31m16s+ on a fast
+# machine.
+DISABLED_twopass_encoder_av1() {
+ if [ "$(av1_encode_available)" = "yes" ]; then
+ twopass_encoder av1 || return 1
fi
}
-twopass_encoder_tests="twopass_encoder_vp8
- twopass_encoder_vp9"
+twopass_encoder_tests="twopass_encoder_aom
+ DISABLED_twopass_encoder_av1"
run_tests twopass_encoder_verify_environment "${twopass_encoder_tests}"
diff --git a/test/user_priv_test.cc b/test/user_priv_test.cc
index 7e8d398..54d4ee6 100644
--- a/test/user_priv_test.cc
+++ b/test/user_priv_test.cc
@@ -12,7 +12,7 @@
#include <cstdlib>
#include <string>
#include "third_party/googletest/src/include/gtest/gtest.h"
-#include "./vpx_config.h"
+#include "./aom_config.h"
#include "test/acm_random.h"
#include "test/codec_factory.h"
#include "test/decode_test_driver.h"
@@ -22,8 +22,8 @@
#if CONFIG_WEBM_IO
#include "test/webm_video_source.h"
#endif
-#include "aom_mem/vpx_mem.h"
-#include "aom/vp8.h"
+#include "aom_mem/aom_mem.h"
+#include "aom/aom.h"
namespace {
@@ -47,23 +47,23 @@
libaom_test::WebMVideoSource video(filename);
video.Init();
- vpx_codec_dec_cfg_t cfg = vpx_codec_dec_cfg_t();
- libaom_test::VP9Decoder decoder(cfg, 0);
+ aom_codec_dec_cfg_t cfg = aom_codec_dec_cfg_t();
+ libaom_test::AV1Decoder decoder(cfg, 0);
libaom_test::MD5 md5;
int frame_num = 0;
for (video.Begin(); !::testing::Test::HasFailure() && video.cxdata();
video.Next()) {
void *user_priv = reinterpret_cast<void *>(&frame_num);
- const vpx_codec_err_t res =
+ const aom_codec_err_t res =
decoder.DecodeFrame(video.cxdata(), video.frame_size(),
(frame_num == 0) ? NULL : user_priv);
- if (res != VPX_CODEC_OK) {
- EXPECT_EQ(VPX_CODEC_OK, res) << decoder.DecodeError();
+ if (res != AOM_CODEC_OK) {
+ EXPECT_EQ(AOM_CODEC_OK, res) << decoder.DecodeError();
break;
}
libaom_test::DxDataIterator dec_iter = decoder.GetDxData();
- const vpx_image_t *img = NULL;
+ const aom_image_t *img = NULL;
// Get decompressed data.
while ((img = dec_iter.Next())) {
@@ -73,10 +73,10 @@
CheckUserPrivateData(img->user_priv, &frame_num);
// Also test ctrl_get_reference api.
- struct vp9_ref_frame ref;
+ struct av1_ref_frame ref;
// Randomly fetch a reference frame.
ref.idx = rnd.Rand8() % 3;
- decoder.Control(VP9_GET_REFERENCE, &ref);
+ decoder.Control(AV1_GET_REFERENCE, &ref);
CheckUserPrivateData(ref.img.user_priv, NULL);
}
@@ -92,7 +92,7 @@
// no tiles or frame parallel; this exercises the decoding to test the
// user_priv.
EXPECT_STREQ("b35a1b707b28e82be025d960aba039bc",
- DecodeFile("vp90-2-03-size-226x226.webm").c_str());
+ DecodeFile("av10-2-03-size-226x226.webm").c_str());
}
#endif // CONFIG_WEBM_IO
diff --git a/test/util.h b/test/util.h
index 6567253..1704473 100644
--- a/test/util.h
+++ b/test/util.h
@@ -14,12 +14,12 @@
#include <stdio.h>
#include <math.h>
#include "third_party/googletest/src/include/gtest/gtest.h"
-#include "aom/vpx_image.h"
+#include "aom/aom_image.h"
// Macros
#define GET_PARAM(k) std::tr1::get<k>(GetParam())
-inline double compute_psnr(const vpx_image_t *img1, const vpx_image_t *img2) {
+inline double compute_psnr(const aom_image_t *img1, const aom_image_t *img2) {
assert((img1->fmt == img2->fmt) && (img1->d_w == img2->d_w) &&
(img1->d_h == img2->d_h));
@@ -30,8 +30,8 @@
int64_t sqrerr = 0;
for (i = 0; i < height_y; ++i)
for (j = 0; j < width_y; ++j) {
- int64_t d = img1->planes[VPX_PLANE_Y][i * img1->stride[VPX_PLANE_Y] + j] -
- img2->planes[VPX_PLANE_Y][i * img2->stride[VPX_PLANE_Y] + j];
+ int64_t d = img1->planes[AOM_PLANE_Y][i * img1->stride[AOM_PLANE_Y] + j] -
+ img2->planes[AOM_PLANE_Y][i * img2->stride[AOM_PLANE_Y] + j];
sqrerr += d * d;
}
double mse = static_cast<double>(sqrerr) / (width_y * height_y);
diff --git a/test/variance_test.cc b/test/variance_test.cc
index 1541f8e..432ab32 100644
--- a/test/variance_test.cc
+++ b/test/variance_test.cc
@@ -13,14 +13,14 @@
#include "third_party/googletest/src/include/gtest/gtest.h"
-#include "./vpx_config.h"
-#include "./vpx_dsp_rtcd.h"
+#include "./aom_config.h"
+#include "./aom_dsp_rtcd.h"
#include "test/acm_random.h"
#include "test/clear_system_state.h"
#include "test/register_state_check.h"
-#include "aom/vpx_codec.h"
-#include "aom/vpx_integer.h"
-#include "aom_mem/vpx_mem.h"
+#include "aom/aom_codec.h"
+#include "aom/aom_integer.h"
+#include "aom_mem/aom_mem.h"
#include "aom_ports/mem.h"
namespace {
@@ -48,15 +48,15 @@
// (bit_depth - 8) for se
static void RoundHighBitDepth(int bit_depth, int64_t *se, uint64_t *sse) {
switch (bit_depth) {
- case VPX_BITS_12:
+ case AOM_BITS_12:
*sse = (*sse + 128) >> 8;
*se = (*se + 8) >> 4;
break;
- case VPX_BITS_10:
+ case AOM_BITS_10:
*sse = (*sse + 8) >> 4;
*se = (*se + 2) >> 2;
break;
- case VPX_BITS_8:
+ case AOM_BITS_8:
default: break;
}
}
@@ -76,7 +76,7 @@
static uint32_t variance_ref(const uint8_t *src, const uint8_t *ref, int l2w,
int l2h, int src_stride, int ref_stride,
uint32_t *sse_ptr, bool use_high_bit_depth_,
- vpx_bit_depth_t bit_depth) {
+ aom_bit_depth_t bit_depth) {
int64_t se = 0;
uint64_t sse = 0;
const int w = 1 << l2w;
@@ -88,13 +88,13 @@
diff = src[y * src_stride + x] - ref[y * ref_stride + x];
se += diff;
sse += diff * diff;
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
} else {
diff = CONVERT_TO_SHORTPTR(src)[y * src_stride + x] -
CONVERT_TO_SHORTPTR(ref)[y * ref_stride + x];
se += diff;
sse += diff * diff;
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#endif // CONFIG_AOM_HIGHBITDEPTH
}
}
}
@@ -113,7 +113,7 @@
static uint32_t subpel_variance_ref(const uint8_t *ref, const uint8_t *src,
int l2w, int l2h, int xoff, int yoff,
uint32_t *sse_ptr, bool use_high_bit_depth_,
- vpx_bit_depth_t bit_depth) {
+ aom_bit_depth_t bit_depth) {
int64_t se = 0;
uint64_t sse = 0;
const int w = 1 << l2w;
@@ -136,7 +136,7 @@
const int diff = r - src[w * y + x];
se += diff;
sse += diff * diff;
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
} else {
uint16_t *ref16 = CONVERT_TO_SHORTPTR(ref);
uint16_t *src16 = CONVERT_TO_SHORTPTR(src);
@@ -150,7 +150,7 @@
const int diff = r - src16[w * y + x];
se += diff;
sse += diff * diff;
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#endif // CONFIG_AOM_HIGHBITDEPTH
}
}
}
@@ -165,7 +165,7 @@
int l2h, int xoff, int yoff,
uint32_t *sse_ptr,
bool use_high_bit_depth,
- vpx_bit_depth_t bit_depth) {
+ aom_bit_depth_t bit_depth) {
int64_t se = 0;
uint64_t sse = 0;
const int w = 1 << l2w;
@@ -189,7 +189,7 @@
((r + second_pred[w * y + x] + 1) >> 1) - src[w * y + x];
se += diff;
sse += diff * diff;
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
} else {
const uint16_t *ref16 = CONVERT_TO_SHORTPTR(ref);
const uint16_t *src16 = CONVERT_TO_SHORTPTR(src);
@@ -204,7 +204,7 @@
const int diff = ((r + sec16[w * y + x] + 1) >> 1) - src16[w * y + x];
se += diff;
sse += diff * diff;
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#endif // CONFIG_AOM_HIGHBITDEPTH
}
}
}
@@ -268,9 +268,9 @@
: log2width(log2w), log2height(log2h), func(function) {
use_high_bit_depth = (bit_depth_value > 0);
if (use_high_bit_depth) {
- bit_depth = static_cast<vpx_bit_depth_t>(bit_depth_value);
+ bit_depth = static_cast<aom_bit_depth_t>(bit_depth_value);
} else {
- bit_depth = VPX_BITS_8;
+ bit_depth = AOM_BITS_8;
}
width = 1 << log2width;
height = 1 << log2height;
@@ -282,7 +282,7 @@
int width, height;
int block_size;
Func func;
- vpx_bit_depth_t bit_depth;
+ aom_bit_depth_t bit_depth;
bool use_high_bit_depth;
uint32_t mask;
};
@@ -305,11 +305,11 @@
rnd_.Reset(ACMRandom::DeterministicSeed());
const size_t unit =
use_high_bit_depth() ? sizeof(uint16_t) : sizeof(uint8_t);
- src_ = reinterpret_cast<uint8_t *>(vpx_memalign(16, block_size() * unit));
+ src_ = reinterpret_cast<uint8_t *>(aom_memalign(16, block_size() * unit));
ref_ = new uint8_t[block_size() * unit];
ASSERT_TRUE(src_ != NULL);
ASSERT_TRUE(ref_ != NULL);
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
if (use_high_bit_depth()) {
// TODO(skal): remove!
src_ = CONVERT_TO_BYTEPTR(src_);
@@ -319,7 +319,7 @@
}
virtual void TearDown() {
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
if (use_high_bit_depth()) {
// TODO(skal): remove!
src_ = reinterpret_cast<uint8_t *>(CONVERT_TO_SHORTPTR(src_));
@@ -327,7 +327,7 @@
}
#endif
- vpx_free(src_);
+ aom_free(src_);
delete[] ref_;
src_ = NULL;
ref_ = NULL;
@@ -400,11 +400,11 @@
if (!use_high_bit_depth()) {
src_[j] = rnd_.Rand8();
ref_[j] = rnd_.Rand8();
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
} else {
CONVERT_TO_SHORTPTR(src_)[j] = rnd_.Rand16() & mask();
CONVERT_TO_SHORTPTR(ref_)[j] = rnd_.Rand16() & mask();
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#endif // CONFIG_AOM_HIGHBITDEPTH
}
}
unsigned int sse1, sse2, var1, var2;
@@ -430,11 +430,11 @@
if (!use_high_bit_depth()) {
src_[src_ind] = rnd_.Rand8();
ref_[ref_ind] = rnd_.Rand8();
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
} else {
CONVERT_TO_SHORTPTR(src_)[src_ind] = rnd_.Rand16() & mask();
CONVERT_TO_SHORTPTR(ref_)[ref_ind] = rnd_.Rand16() & mask();
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#endif // CONFIG_AOM_HIGHBITDEPTH
}
}
unsigned int sse1, sse2;
@@ -457,12 +457,12 @@
memset(src_, 255, block_size());
memset(ref_, 255, half);
memset(ref_ + half, 0, half);
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
} else {
- vpx_memset16(CONVERT_TO_SHORTPTR(src_), 255 << byte_shift(), block_size());
- vpx_memset16(CONVERT_TO_SHORTPTR(ref_), 255 << byte_shift(), half);
- vpx_memset16(CONVERT_TO_SHORTPTR(ref_) + half, 0, half);
-#endif // CONFIG_VP9_HIGHBITDEPTH
+ aom_memset16(CONVERT_TO_SHORTPTR(src_), 255 << byte_shift(), block_size());
+ aom_memset16(CONVERT_TO_SHORTPTR(ref_), 255 << byte_shift(), half);
+ aom_memset16(CONVERT_TO_SHORTPTR(ref_) + half, 0, half);
+#endif // CONFIG_AOM_HIGHBITDEPTH
}
unsigned int sse, var, expected;
ASM_REGISTER_STATE_CHECK(
@@ -485,7 +485,7 @@
const int stride = width();
ASM_REGISTER_STATE_CHECK(params_.func(src_, stride, ref_, stride, &sse1));
variance_ref(src_, ref_, params_.log2width, params_.log2height, stride,
- stride, &sse2, false, VPX_BITS_8);
+ stride, &sse2, false, AOM_BITS_8);
EXPECT_EQ(sse1, sse2);
}
}
@@ -502,7 +502,7 @@
const int stride = width();
ASM_REGISTER_STATE_CHECK(var1 = params_.func(src_, stride, ref_, stride));
variance_ref(src_, ref_, params_.log2width, params_.log2height, stride,
- stride, &sse2, false, VPX_BITS_8);
+ stride, &sse2, false, AOM_BITS_8);
EXPECT_EQ(var1, sse2);
}
}
@@ -547,10 +547,10 @@
height_ = 1 << log2height_;
subpel_variance_ = get<2>(params);
if (get<3>(params)) {
- bit_depth_ = (vpx_bit_depth_t)get<3>(params);
+ bit_depth_ = (aom_bit_depth_t)get<3>(params);
use_high_bit_depth_ = true;
} else {
- bit_depth_ = VPX_BITS_8;
+ bit_depth_ = AOM_BITS_8;
use_high_bit_depth_ = false;
}
mask_ = (1 << bit_depth_) - 1;
@@ -558,18 +558,18 @@
rnd_.Reset(ACMRandom::DeterministicSeed());
block_size_ = width_ * height_;
if (!use_high_bit_depth_) {
- src_ = reinterpret_cast<uint8_t *>(vpx_memalign(16, block_size_));
- sec_ = reinterpret_cast<uint8_t *>(vpx_memalign(16, block_size_));
+ src_ = reinterpret_cast<uint8_t *>(aom_memalign(16, block_size_));
+ sec_ = reinterpret_cast<uint8_t *>(aom_memalign(16, block_size_));
ref_ = new uint8_t[block_size_ + width_ + height_ + 1];
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
} else {
src_ = CONVERT_TO_BYTEPTR(reinterpret_cast<uint16_t *>(
- vpx_memalign(16, block_size_ * sizeof(uint16_t))));
+ aom_memalign(16, block_size_ * sizeof(uint16_t))));
sec_ = CONVERT_TO_BYTEPTR(reinterpret_cast<uint16_t *>(
- vpx_memalign(16, block_size_ * sizeof(uint16_t))));
+ aom_memalign(16, block_size_ * sizeof(uint16_t))));
ref_ =
CONVERT_TO_BYTEPTR(new uint16_t[block_size_ + width_ + height_ + 1]);
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#endif // CONFIG_AOM_HIGHBITDEPTH
}
ASSERT_TRUE(src_ != NULL);
ASSERT_TRUE(sec_ != NULL);
@@ -578,15 +578,15 @@
virtual void TearDown() {
if (!use_high_bit_depth_) {
- vpx_free(src_);
+ aom_free(src_);
delete[] ref_;
- vpx_free(sec_);
-#if CONFIG_VP9_HIGHBITDEPTH
+ aom_free(sec_);
+#if CONFIG_AOM_HIGHBITDEPTH
} else {
- vpx_free(CONVERT_TO_SHORTPTR(src_));
+ aom_free(CONVERT_TO_SHORTPTR(src_));
delete[] CONVERT_TO_SHORTPTR(ref_);
- vpx_free(CONVERT_TO_SHORTPTR(sec_));
-#endif // CONFIG_VP9_HIGHBITDEPTH
+ aom_free(CONVERT_TO_SHORTPTR(sec_));
+#endif // CONFIG_AOM_HIGHBITDEPTH
}
libaom_test::ClearSystemState();
}
@@ -600,7 +600,7 @@
uint8_t *ref_;
uint8_t *sec_;
bool use_high_bit_depth_;
- vpx_bit_depth_t bit_depth_;
+ aom_bit_depth_t bit_depth_;
int width_, log2width_;
int height_, log2height_;
int block_size_, mask_;
@@ -618,7 +618,7 @@
for (int j = 0; j < block_size_ + width_ + height_ + 1; j++) {
ref_[j] = rnd_.Rand8();
}
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
} else {
for (int j = 0; j < block_size_; j++) {
CONVERT_TO_SHORTPTR(src_)[j] = rnd_.Rand16() & mask_;
@@ -626,7 +626,7 @@
for (int j = 0; j < block_size_ + width_ + height_ + 1; j++) {
CONVERT_TO_SHORTPTR(ref_)[j] = rnd_.Rand16() & mask_;
}
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#endif // CONFIG_AOM_HIGHBITDEPTH
}
unsigned int sse1, sse2;
unsigned int var1;
@@ -654,14 +654,14 @@
memset(src_ + half, 255, half);
memset(ref_, 255, half);
memset(ref_ + half, 0, half + width_ + height_ + 1);
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
} else {
- vpx_memset16(CONVERT_TO_SHORTPTR(src_), mask_, half);
- vpx_memset16(CONVERT_TO_SHORTPTR(src_) + half, 0, half);
- vpx_memset16(CONVERT_TO_SHORTPTR(ref_), 0, half);
- vpx_memset16(CONVERT_TO_SHORTPTR(ref_) + half, mask_,
+ aom_memset16(CONVERT_TO_SHORTPTR(src_), mask_, half);
+ aom_memset16(CONVERT_TO_SHORTPTR(src_) + half, 0, half);
+ aom_memset16(CONVERT_TO_SHORTPTR(ref_), 0, half);
+ aom_memset16(CONVERT_TO_SHORTPTR(ref_) + half, mask_,
half + width_ + height_ + 1);
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#endif // CONFIG_AOM_HIGHBITDEPTH
}
unsigned int sse1, sse2;
unsigned int var1;
@@ -688,7 +688,7 @@
for (int j = 0; j < block_size_ + width_ + height_ + 1; j++) {
ref_[j] = rnd_.Rand8();
}
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
} else {
for (int j = 0; j < block_size_; j++) {
CONVERT_TO_SHORTPTR(src_)[j] = rnd_.Rand16() & mask_;
@@ -697,7 +697,7 @@
for (int j = 0; j < block_size_ + width_ + height_ + 1; j++) {
CONVERT_TO_SHORTPTR(ref_)[j] = rnd_.Rand16() & mask_;
}
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#endif // CONFIG_AOM_HIGHBITDEPTH
}
uint32_t sse1, sse2;
uint32_t var1, var2;
@@ -706,682 +706,682 @@
src_, width_, &sse1, sec_));
var2 = subpel_avg_variance_ref(ref_, src_, sec_, log2width_, log2height_,
x, y, &sse2, use_high_bit_depth_,
- static_cast<vpx_bit_depth_t>(bit_depth_));
+ static_cast<aom_bit_depth_t>(bit_depth_));
EXPECT_EQ(sse1, sse2) << "at position " << x << ", " << y;
EXPECT_EQ(var1, var2) << "at position " << x << ", " << y;
}
}
}
-typedef MainTestClass<Get4x4SseFunc> VpxSseTest;
-typedef MainTestClass<VarianceMxNFunc> VpxMseTest;
-typedef MainTestClass<VarianceMxNFunc> VpxVarianceTest;
-typedef SubpelVarianceTest<SubpixVarMxNFunc> VpxSubpelVarianceTest;
-typedef SubpelVarianceTest<SubpixAvgVarMxNFunc> VpxSubpelAvgVarianceTest;
+typedef MainTestClass<Get4x4SseFunc> AvxSseTest;
+typedef MainTestClass<VarianceMxNFunc> AvxMseTest;
+typedef MainTestClass<VarianceMxNFunc> AvxVarianceTest;
+typedef SubpelVarianceTest<SubpixVarMxNFunc> AvxSubpelVarianceTest;
+typedef SubpelVarianceTest<SubpixAvgVarMxNFunc> AvxSubpelAvgVarianceTest;
-TEST_P(VpxSseTest, RefSse) { RefTestSse(); }
-TEST_P(VpxSseTest, MaxSse) { MaxTestSse(); }
-TEST_P(VpxMseTest, RefMse) { RefTestMse(); }
-TEST_P(VpxMseTest, MaxMse) { MaxTestMse(); }
-TEST_P(VpxVarianceTest, Zero) { ZeroTest(); }
-TEST_P(VpxVarianceTest, Ref) { RefTest(); }
-TEST_P(VpxVarianceTest, RefStride) { RefStrideTest(); }
-TEST_P(VpxVarianceTest, OneQuarter) { OneQuarterTest(); }
+TEST_P(AvxSseTest, RefSse) { RefTestSse(); }
+TEST_P(AvxSseTest, MaxSse) { MaxTestSse(); }
+TEST_P(AvxMseTest, RefMse) { RefTestMse(); }
+TEST_P(AvxMseTest, MaxMse) { MaxTestMse(); }
+TEST_P(AvxVarianceTest, Zero) { ZeroTest(); }
+TEST_P(AvxVarianceTest, Ref) { RefTest(); }
+TEST_P(AvxVarianceTest, RefStride) { RefStrideTest(); }
+TEST_P(AvxVarianceTest, OneQuarter) { OneQuarterTest(); }
TEST_P(SumOfSquaresTest, Const) { ConstTest(); }
TEST_P(SumOfSquaresTest, Ref) { RefTest(); }
-TEST_P(VpxSubpelVarianceTest, Ref) { RefTest(); }
-TEST_P(VpxSubpelVarianceTest, ExtremeRef) { ExtremeRefTest(); }
-TEST_P(VpxSubpelAvgVarianceTest, Ref) { RefTest(); }
+TEST_P(AvxSubpelVarianceTest, Ref) { RefTest(); }
+TEST_P(AvxSubpelVarianceTest, ExtremeRef) { ExtremeRefTest(); }
+TEST_P(AvxSubpelAvgVarianceTest, Ref) { RefTest(); }
INSTANTIATE_TEST_CASE_P(C, SumOfSquaresTest,
- ::testing::Values(vpx_get_mb_ss_c));
+ ::testing::Values(aom_get_mb_ss_c));
typedef TestParams<Get4x4SseFunc> SseParams;
-INSTANTIATE_TEST_CASE_P(C, VpxSseTest,
+INSTANTIATE_TEST_CASE_P(C, AvxSseTest,
::testing::Values(SseParams(2, 2,
- &vpx_get4x4sse_cs_c)));
+ &aom_get4x4sse_cs_c)));
typedef TestParams<VarianceMxNFunc> MseParams;
-INSTANTIATE_TEST_CASE_P(C, VpxMseTest,
- ::testing::Values(MseParams(4, 4, &vpx_mse16x16_c),
- MseParams(4, 3, &vpx_mse16x8_c),
- MseParams(3, 4, &vpx_mse8x16_c),
- MseParams(3, 3, &vpx_mse8x8_c)));
+INSTANTIATE_TEST_CASE_P(C, AvxMseTest,
+ ::testing::Values(MseParams(4, 4, &aom_mse16x16_c),
+ MseParams(4, 3, &aom_mse16x8_c),
+ MseParams(3, 4, &aom_mse8x16_c),
+ MseParams(3, 3, &aom_mse8x8_c)));
typedef TestParams<VarianceMxNFunc> VarianceParams;
INSTANTIATE_TEST_CASE_P(
- C, VpxVarianceTest,
- ::testing::Values(VarianceParams(6, 6, &vpx_variance64x64_c),
- VarianceParams(6, 5, &vpx_variance64x32_c),
- VarianceParams(5, 6, &vpx_variance32x64_c),
- VarianceParams(5, 5, &vpx_variance32x32_c),
- VarianceParams(5, 4, &vpx_variance32x16_c),
- VarianceParams(4, 5, &vpx_variance16x32_c),
- VarianceParams(4, 4, &vpx_variance16x16_c),
- VarianceParams(4, 3, &vpx_variance16x8_c),
- VarianceParams(3, 4, &vpx_variance8x16_c),
- VarianceParams(3, 3, &vpx_variance8x8_c),
- VarianceParams(3, 2, &vpx_variance8x4_c),
- VarianceParams(2, 3, &vpx_variance4x8_c),
- VarianceParams(2, 2, &vpx_variance4x4_c)));
+ C, AvxVarianceTest,
+ ::testing::Values(VarianceParams(6, 6, &aom_variance64x64_c),
+ VarianceParams(6, 5, &aom_variance64x32_c),
+ VarianceParams(5, 6, &aom_variance32x64_c),
+ VarianceParams(5, 5, &aom_variance32x32_c),
+ VarianceParams(5, 4, &aom_variance32x16_c),
+ VarianceParams(4, 5, &aom_variance16x32_c),
+ VarianceParams(4, 4, &aom_variance16x16_c),
+ VarianceParams(4, 3, &aom_variance16x8_c),
+ VarianceParams(3, 4, &aom_variance8x16_c),
+ VarianceParams(3, 3, &aom_variance8x8_c),
+ VarianceParams(3, 2, &aom_variance8x4_c),
+ VarianceParams(2, 3, &aom_variance4x8_c),
+ VarianceParams(2, 2, &aom_variance4x4_c)));
INSTANTIATE_TEST_CASE_P(
- C, VpxSubpelVarianceTest,
- ::testing::Values(make_tuple(6, 6, &vpx_sub_pixel_variance64x64_c, 0),
- make_tuple(6, 5, &vpx_sub_pixel_variance64x32_c, 0),
- make_tuple(5, 6, &vpx_sub_pixel_variance32x64_c, 0),
- make_tuple(5, 5, &vpx_sub_pixel_variance32x32_c, 0),
- make_tuple(5, 4, &vpx_sub_pixel_variance32x16_c, 0),
- make_tuple(4, 5, &vpx_sub_pixel_variance16x32_c, 0),
- make_tuple(4, 4, &vpx_sub_pixel_variance16x16_c, 0),
- make_tuple(4, 3, &vpx_sub_pixel_variance16x8_c, 0),
- make_tuple(3, 4, &vpx_sub_pixel_variance8x16_c, 0),
- make_tuple(3, 3, &vpx_sub_pixel_variance8x8_c, 0),
- make_tuple(3, 2, &vpx_sub_pixel_variance8x4_c, 0),
- make_tuple(2, 3, &vpx_sub_pixel_variance4x8_c, 0),
- make_tuple(2, 2, &vpx_sub_pixel_variance4x4_c, 0)));
+ C, AvxSubpelVarianceTest,
+ ::testing::Values(make_tuple(6, 6, &aom_sub_pixel_variance64x64_c, 0),
+ make_tuple(6, 5, &aom_sub_pixel_variance64x32_c, 0),
+ make_tuple(5, 6, &aom_sub_pixel_variance32x64_c, 0),
+ make_tuple(5, 5, &aom_sub_pixel_variance32x32_c, 0),
+ make_tuple(5, 4, &aom_sub_pixel_variance32x16_c, 0),
+ make_tuple(4, 5, &aom_sub_pixel_variance16x32_c, 0),
+ make_tuple(4, 4, &aom_sub_pixel_variance16x16_c, 0),
+ make_tuple(4, 3, &aom_sub_pixel_variance16x8_c, 0),
+ make_tuple(3, 4, &aom_sub_pixel_variance8x16_c, 0),
+ make_tuple(3, 3, &aom_sub_pixel_variance8x8_c, 0),
+ make_tuple(3, 2, &aom_sub_pixel_variance8x4_c, 0),
+ make_tuple(2, 3, &aom_sub_pixel_variance4x8_c, 0),
+ make_tuple(2, 2, &aom_sub_pixel_variance4x4_c, 0)));
INSTANTIATE_TEST_CASE_P(
- C, VpxSubpelAvgVarianceTest,
- ::testing::Values(make_tuple(6, 6, &vpx_sub_pixel_avg_variance64x64_c, 0),
- make_tuple(6, 5, &vpx_sub_pixel_avg_variance64x32_c, 0),
- make_tuple(5, 6, &vpx_sub_pixel_avg_variance32x64_c, 0),
- make_tuple(5, 5, &vpx_sub_pixel_avg_variance32x32_c, 0),
- make_tuple(5, 4, &vpx_sub_pixel_avg_variance32x16_c, 0),
- make_tuple(4, 5, &vpx_sub_pixel_avg_variance16x32_c, 0),
- make_tuple(4, 4, &vpx_sub_pixel_avg_variance16x16_c, 0),
- make_tuple(4, 3, &vpx_sub_pixel_avg_variance16x8_c, 0),
- make_tuple(3, 4, &vpx_sub_pixel_avg_variance8x16_c, 0),
- make_tuple(3, 3, &vpx_sub_pixel_avg_variance8x8_c, 0),
- make_tuple(3, 2, &vpx_sub_pixel_avg_variance8x4_c, 0),
- make_tuple(2, 3, &vpx_sub_pixel_avg_variance4x8_c, 0),
- make_tuple(2, 2, &vpx_sub_pixel_avg_variance4x4_c, 0)));
+ C, AvxSubpelAvgVarianceTest,
+ ::testing::Values(make_tuple(6, 6, &aom_sub_pixel_avg_variance64x64_c, 0),
+ make_tuple(6, 5, &aom_sub_pixel_avg_variance64x32_c, 0),
+ make_tuple(5, 6, &aom_sub_pixel_avg_variance32x64_c, 0),
+ make_tuple(5, 5, &aom_sub_pixel_avg_variance32x32_c, 0),
+ make_tuple(5, 4, &aom_sub_pixel_avg_variance32x16_c, 0),
+ make_tuple(4, 5, &aom_sub_pixel_avg_variance16x32_c, 0),
+ make_tuple(4, 4, &aom_sub_pixel_avg_variance16x16_c, 0),
+ make_tuple(4, 3, &aom_sub_pixel_avg_variance16x8_c, 0),
+ make_tuple(3, 4, &aom_sub_pixel_avg_variance8x16_c, 0),
+ make_tuple(3, 3, &aom_sub_pixel_avg_variance8x8_c, 0),
+ make_tuple(3, 2, &aom_sub_pixel_avg_variance8x4_c, 0),
+ make_tuple(2, 3, &aom_sub_pixel_avg_variance4x8_c, 0),
+ make_tuple(2, 2, &aom_sub_pixel_avg_variance4x4_c, 0)));
-#if CONFIG_VP9_HIGHBITDEPTH
-typedef MainTestClass<VarianceMxNFunc> VpxHBDMseTest;
-typedef MainTestClass<VarianceMxNFunc> VpxHBDVarianceTest;
-typedef SubpelVarianceTest<SubpixVarMxNFunc> VpxHBDSubpelVarianceTest;
-typedef SubpelVarianceTest<SubpixAvgVarMxNFunc> VpxHBDSubpelAvgVarianceTest;
+#if CONFIG_AOM_HIGHBITDEPTH
+typedef MainTestClass<VarianceMxNFunc> AvxHBDMseTest;
+typedef MainTestClass<VarianceMxNFunc> AvxHBDVarianceTest;
+typedef SubpelVarianceTest<SubpixVarMxNFunc> AvxHBDSubpelVarianceTest;
+typedef SubpelVarianceTest<SubpixAvgVarMxNFunc> AvxHBDSubpelAvgVarianceTest;
-TEST_P(VpxHBDMseTest, RefMse) { RefTestMse(); }
-TEST_P(VpxHBDMseTest, MaxMse) { MaxTestMse(); }
-TEST_P(VpxHBDVarianceTest, Zero) { ZeroTest(); }
-TEST_P(VpxHBDVarianceTest, Ref) { RefTest(); }
-TEST_P(VpxHBDVarianceTest, RefStride) { RefStrideTest(); }
-TEST_P(VpxHBDVarianceTest, OneQuarter) { OneQuarterTest(); }
-TEST_P(VpxHBDSubpelVarianceTest, Ref) { RefTest(); }
-TEST_P(VpxHBDSubpelVarianceTest, ExtremeRef) { ExtremeRefTest(); }
-TEST_P(VpxHBDSubpelAvgVarianceTest, Ref) { RefTest(); }
+TEST_P(AvxHBDMseTest, RefMse) { RefTestMse(); }
+TEST_P(AvxHBDMseTest, MaxMse) { MaxTestMse(); }
+TEST_P(AvxHBDVarianceTest, Zero) { ZeroTest(); }
+TEST_P(AvxHBDVarianceTest, Ref) { RefTest(); }
+TEST_P(AvxHBDVarianceTest, RefStride) { RefStrideTest(); }
+TEST_P(AvxHBDVarianceTest, OneQuarter) { OneQuarterTest(); }
+TEST_P(AvxHBDSubpelVarianceTest, Ref) { RefTest(); }
+TEST_P(AvxHBDSubpelVarianceTest, ExtremeRef) { ExtremeRefTest(); }
+TEST_P(AvxHBDSubpelAvgVarianceTest, Ref) { RefTest(); }
/* TODO(debargha): This test does not support the highbd version
INSTANTIATE_TEST_CASE_P(
- C, VpxHBDMseTest,
- ::testing::Values(make_tuple(4, 4, &vpx_highbd_12_mse16x16_c),
- make_tuple(4, 4, &vpx_highbd_12_mse16x8_c),
- make_tuple(4, 4, &vpx_highbd_12_mse8x16_c),
- make_tuple(4, 4, &vpx_highbd_12_mse8x8_c),
- make_tuple(4, 4, &vpx_highbd_10_mse16x16_c),
- make_tuple(4, 4, &vpx_highbd_10_mse16x8_c),
- make_tuple(4, 4, &vpx_highbd_10_mse8x16_c),
- make_tuple(4, 4, &vpx_highbd_10_mse8x8_c),
- make_tuple(4, 4, &vpx_highbd_8_mse16x16_c),
- make_tuple(4, 4, &vpx_highbd_8_mse16x8_c),
- make_tuple(4, 4, &vpx_highbd_8_mse8x16_c),
- make_tuple(4, 4, &vpx_highbd_8_mse8x8_c)));
+ C, AvxHBDMseTest,
+ ::testing::Values(make_tuple(4, 4, &aom_highbd_12_mse16x16_c),
+ make_tuple(4, 4, &aom_highbd_12_mse16x8_c),
+ make_tuple(4, 4, &aom_highbd_12_mse8x16_c),
+ make_tuple(4, 4, &aom_highbd_12_mse8x8_c),
+ make_tuple(4, 4, &aom_highbd_10_mse16x16_c),
+ make_tuple(4, 4, &aom_highbd_10_mse16x8_c),
+ make_tuple(4, 4, &aom_highbd_10_mse8x16_c),
+ make_tuple(4, 4, &aom_highbd_10_mse8x8_c),
+ make_tuple(4, 4, &aom_highbd_8_mse16x16_c),
+ make_tuple(4, 4, &aom_highbd_8_mse16x8_c),
+ make_tuple(4, 4, &aom_highbd_8_mse8x16_c),
+ make_tuple(4, 4, &aom_highbd_8_mse8x8_c)));
*/
const VarianceParams kArrayHBDVariance_c[] = {
-#if CONFIG_VP10 && CONFIG_EXT_PARTITION
- VarianceParams(7, 7, &vpx_highbd_12_variance128x128_c, 12),
- VarianceParams(7, 6, &vpx_highbd_12_variance128x64_c, 12),
- VarianceParams(6, 7, &vpx_highbd_12_variance64x128_c, 12),
-#endif // CONFIG_VP10 && CONFIG_EXT_PARTITION
- VarianceParams(6, 6, &vpx_highbd_12_variance64x64_c, 12),
- VarianceParams(6, 5, &vpx_highbd_12_variance64x32_c, 12),
- VarianceParams(5, 6, &vpx_highbd_12_variance32x64_c, 12),
- VarianceParams(5, 5, &vpx_highbd_12_variance32x32_c, 12),
- VarianceParams(5, 4, &vpx_highbd_12_variance32x16_c, 12),
- VarianceParams(4, 5, &vpx_highbd_12_variance16x32_c, 12),
- VarianceParams(4, 4, &vpx_highbd_12_variance16x16_c, 12),
- VarianceParams(4, 3, &vpx_highbd_12_variance16x8_c, 12),
- VarianceParams(3, 4, &vpx_highbd_12_variance8x16_c, 12),
- VarianceParams(3, 3, &vpx_highbd_12_variance8x8_c, 12),
- VarianceParams(3, 2, &vpx_highbd_12_variance8x4_c, 12),
- VarianceParams(2, 3, &vpx_highbd_12_variance4x8_c, 12),
- VarianceParams(2, 2, &vpx_highbd_12_variance4x4_c, 12),
-#if CONFIG_VP10 && CONFIG_EXT_PARTITION
- VarianceParams(7, 7, &vpx_highbd_10_variance128x128_c, 10),
- VarianceParams(7, 6, &vpx_highbd_10_variance128x64_c, 10),
- VarianceParams(6, 7, &vpx_highbd_10_variance64x128_c, 10),
-#endif // CONFIG_VP10 && CONFIG_EXT_PARTITION
- VarianceParams(6, 6, &vpx_highbd_10_variance64x64_c, 10),
- VarianceParams(6, 5, &vpx_highbd_10_variance64x32_c, 10),
- VarianceParams(5, 6, &vpx_highbd_10_variance32x64_c, 10),
- VarianceParams(5, 5, &vpx_highbd_10_variance32x32_c, 10),
- VarianceParams(5, 4, &vpx_highbd_10_variance32x16_c, 10),
- VarianceParams(4, 5, &vpx_highbd_10_variance16x32_c, 10),
- VarianceParams(4, 4, &vpx_highbd_10_variance16x16_c, 10),
- VarianceParams(4, 3, &vpx_highbd_10_variance16x8_c, 10),
- VarianceParams(3, 4, &vpx_highbd_10_variance8x16_c, 10),
- VarianceParams(3, 3, &vpx_highbd_10_variance8x8_c, 10),
- VarianceParams(3, 2, &vpx_highbd_10_variance8x4_c, 10),
- VarianceParams(2, 3, &vpx_highbd_10_variance4x8_c, 10),
- VarianceParams(2, 2, &vpx_highbd_10_variance4x4_c, 10),
-#if CONFIG_VP10 && CONFIG_EXT_PARTITION
- VarianceParams(7, 7, &vpx_highbd_8_variance128x128_c, 8),
- VarianceParams(7, 6, &vpx_highbd_8_variance128x64_c, 8),
- VarianceParams(6, 7, &vpx_highbd_8_variance64x128_c, 8),
-#endif // CONFIG_VP10 && CONFIG_EXT_PARTITION
- VarianceParams(6, 6, &vpx_highbd_8_variance64x64_c, 8),
- VarianceParams(6, 5, &vpx_highbd_8_variance64x32_c, 8),
- VarianceParams(5, 6, &vpx_highbd_8_variance32x64_c, 8),
- VarianceParams(5, 5, &vpx_highbd_8_variance32x32_c, 8),
- VarianceParams(5, 4, &vpx_highbd_8_variance32x16_c, 8),
- VarianceParams(4, 5, &vpx_highbd_8_variance16x32_c, 8),
- VarianceParams(4, 4, &vpx_highbd_8_variance16x16_c, 8),
- VarianceParams(4, 3, &vpx_highbd_8_variance16x8_c, 8),
- VarianceParams(3, 4, &vpx_highbd_8_variance8x16_c, 8),
- VarianceParams(3, 3, &vpx_highbd_8_variance8x8_c, 8),
- VarianceParams(3, 2, &vpx_highbd_8_variance8x4_c, 8),
- VarianceParams(2, 3, &vpx_highbd_8_variance4x8_c, 8),
- VarianceParams(2, 2, &vpx_highbd_8_variance4x4_c, 8)
+#if CONFIG_AV1 && CONFIG_EXT_PARTITION
+ VarianceParams(7, 7, &aom_highbd_12_variance128x128_c, 12),
+ VarianceParams(7, 6, &aom_highbd_12_variance128x64_c, 12),
+ VarianceParams(6, 7, &aom_highbd_12_variance64x128_c, 12),
+#endif // CONFIG_AV1 && CONFIG_EXT_PARTITION
+ VarianceParams(6, 6, &aom_highbd_12_variance64x64_c, 12),
+ VarianceParams(6, 5, &aom_highbd_12_variance64x32_c, 12),
+ VarianceParams(5, 6, &aom_highbd_12_variance32x64_c, 12),
+ VarianceParams(5, 5, &aom_highbd_12_variance32x32_c, 12),
+ VarianceParams(5, 4, &aom_highbd_12_variance32x16_c, 12),
+ VarianceParams(4, 5, &aom_highbd_12_variance16x32_c, 12),
+ VarianceParams(4, 4, &aom_highbd_12_variance16x16_c, 12),
+ VarianceParams(4, 3, &aom_highbd_12_variance16x8_c, 12),
+ VarianceParams(3, 4, &aom_highbd_12_variance8x16_c, 12),
+ VarianceParams(3, 3, &aom_highbd_12_variance8x8_c, 12),
+ VarianceParams(3, 2, &aom_highbd_12_variance8x4_c, 12),
+ VarianceParams(2, 3, &aom_highbd_12_variance4x8_c, 12),
+ VarianceParams(2, 2, &aom_highbd_12_variance4x4_c, 12),
+#if CONFIG_AV1 && CONFIG_EXT_PARTITION
+ VarianceParams(7, 7, &aom_highbd_10_variance128x128_c, 10),
+ VarianceParams(7, 6, &aom_highbd_10_variance128x64_c, 10),
+ VarianceParams(6, 7, &aom_highbd_10_variance64x128_c, 10),
+#endif // CONFIG_AV1 && CONFIG_EXT_PARTITION
+ VarianceParams(6, 6, &aom_highbd_10_variance64x64_c, 10),
+ VarianceParams(6, 5, &aom_highbd_10_variance64x32_c, 10),
+ VarianceParams(5, 6, &aom_highbd_10_variance32x64_c, 10),
+ VarianceParams(5, 5, &aom_highbd_10_variance32x32_c, 10),
+ VarianceParams(5, 4, &aom_highbd_10_variance32x16_c, 10),
+ VarianceParams(4, 5, &aom_highbd_10_variance16x32_c, 10),
+ VarianceParams(4, 4, &aom_highbd_10_variance16x16_c, 10),
+ VarianceParams(4, 3, &aom_highbd_10_variance16x8_c, 10),
+ VarianceParams(3, 4, &aom_highbd_10_variance8x16_c, 10),
+ VarianceParams(3, 3, &aom_highbd_10_variance8x8_c, 10),
+ VarianceParams(3, 2, &aom_highbd_10_variance8x4_c, 10),
+ VarianceParams(2, 3, &aom_highbd_10_variance4x8_c, 10),
+ VarianceParams(2, 2, &aom_highbd_10_variance4x4_c, 10),
+#if CONFIG_AV1 && CONFIG_EXT_PARTITION
+ VarianceParams(7, 7, &aom_highbd_8_variance128x128_c, 8),
+ VarianceParams(7, 6, &aom_highbd_8_variance128x64_c, 8),
+ VarianceParams(6, 7, &aom_highbd_8_variance64x128_c, 8),
+#endif // CONFIG_AV1 && CONFIG_EXT_PARTITION
+ VarianceParams(6, 6, &aom_highbd_8_variance64x64_c, 8),
+ VarianceParams(6, 5, &aom_highbd_8_variance64x32_c, 8),
+ VarianceParams(5, 6, &aom_highbd_8_variance32x64_c, 8),
+ VarianceParams(5, 5, &aom_highbd_8_variance32x32_c, 8),
+ VarianceParams(5, 4, &aom_highbd_8_variance32x16_c, 8),
+ VarianceParams(4, 5, &aom_highbd_8_variance16x32_c, 8),
+ VarianceParams(4, 4, &aom_highbd_8_variance16x16_c, 8),
+ VarianceParams(4, 3, &aom_highbd_8_variance16x8_c, 8),
+ VarianceParams(3, 4, &aom_highbd_8_variance8x16_c, 8),
+ VarianceParams(3, 3, &aom_highbd_8_variance8x8_c, 8),
+ VarianceParams(3, 2, &aom_highbd_8_variance8x4_c, 8),
+ VarianceParams(2, 3, &aom_highbd_8_variance4x8_c, 8),
+ VarianceParams(2, 2, &aom_highbd_8_variance4x4_c, 8)
};
-INSTANTIATE_TEST_CASE_P(C, VpxHBDVarianceTest,
+INSTANTIATE_TEST_CASE_P(C, AvxHBDVarianceTest,
::testing::ValuesIn(kArrayHBDVariance_c));
-#if HAVE_SSE4_1 && CONFIG_VP9_HIGHBITDEPTH
+#if HAVE_SSE4_1 && CONFIG_AOM_HIGHBITDEPTH
INSTANTIATE_TEST_CASE_P(
- SSE4_1, VpxHBDVarianceTest,
+ SSE4_1, AvxHBDVarianceTest,
::testing::Values(
- VarianceParams(2, 2, &vpx_highbd_8_variance4x4_sse4_1, 8),
- VarianceParams(2, 2, &vpx_highbd_10_variance4x4_sse4_1, 10),
- VarianceParams(2, 2, &vpx_highbd_12_variance4x4_sse4_1, 12)));
-#endif // HAVE_SSE4_1 && CONFIG_VP9_HIGHBITDEPTH
+ VarianceParams(2, 2, &aom_highbd_8_variance4x4_sse4_1, 8),
+ VarianceParams(2, 2, &aom_highbd_10_variance4x4_sse4_1, 10),
+ VarianceParams(2, 2, &aom_highbd_12_variance4x4_sse4_1, 12)));
+#endif // HAVE_SSE4_1 && CONFIG_AOM_HIGHBITDEPTH
-const VpxHBDSubpelVarianceTest::ParamType kArrayHBDSubpelVariance_c[] = {
-#if CONFIG_VP10 && CONFIG_EXT_PARTITION
- make_tuple(7, 7, &vpx_highbd_8_sub_pixel_variance128x128_c, 8),
- make_tuple(7, 6, &vpx_highbd_8_sub_pixel_variance128x64_c, 8),
- make_tuple(6, 7, &vpx_highbd_8_sub_pixel_variance64x128_c, 8),
-#endif // CONFIG_VP10 && CONFIG_EXT_PARTITION
- make_tuple(6, 6, &vpx_highbd_8_sub_pixel_variance64x64_c, 8),
- make_tuple(6, 5, &vpx_highbd_8_sub_pixel_variance64x32_c, 8),
- make_tuple(5, 6, &vpx_highbd_8_sub_pixel_variance32x64_c, 8),
- make_tuple(5, 5, &vpx_highbd_8_sub_pixel_variance32x32_c, 8),
- make_tuple(5, 4, &vpx_highbd_8_sub_pixel_variance32x16_c, 8),
- make_tuple(4, 5, &vpx_highbd_8_sub_pixel_variance16x32_c, 8),
- make_tuple(4, 4, &vpx_highbd_8_sub_pixel_variance16x16_c, 8),
- make_tuple(4, 3, &vpx_highbd_8_sub_pixel_variance16x8_c, 8),
- make_tuple(3, 4, &vpx_highbd_8_sub_pixel_variance8x16_c, 8),
- make_tuple(3, 3, &vpx_highbd_8_sub_pixel_variance8x8_c, 8),
- make_tuple(3, 2, &vpx_highbd_8_sub_pixel_variance8x4_c, 8),
- make_tuple(2, 3, &vpx_highbd_8_sub_pixel_variance4x8_c, 8),
- make_tuple(2, 2, &vpx_highbd_8_sub_pixel_variance4x4_c, 8),
-#if CONFIG_VP10 && CONFIG_EXT_PARTITION
- make_tuple(7, 7, &vpx_highbd_10_sub_pixel_variance128x128_c, 10),
- make_tuple(7, 6, &vpx_highbd_10_sub_pixel_variance128x64_c, 10),
- make_tuple(6, 7, &vpx_highbd_10_sub_pixel_variance64x128_c, 10),
-#endif // CONFIG_VP10 && CONFIG_EXT_PARTITION
- make_tuple(6, 6, &vpx_highbd_10_sub_pixel_variance64x64_c, 10),
- make_tuple(6, 5, &vpx_highbd_10_sub_pixel_variance64x32_c, 10),
- make_tuple(5, 6, &vpx_highbd_10_sub_pixel_variance32x64_c, 10),
- make_tuple(5, 5, &vpx_highbd_10_sub_pixel_variance32x32_c, 10),
- make_tuple(5, 4, &vpx_highbd_10_sub_pixel_variance32x16_c, 10),
- make_tuple(4, 5, &vpx_highbd_10_sub_pixel_variance16x32_c, 10),
- make_tuple(4, 4, &vpx_highbd_10_sub_pixel_variance16x16_c, 10),
- make_tuple(4, 3, &vpx_highbd_10_sub_pixel_variance16x8_c, 10),
- make_tuple(3, 4, &vpx_highbd_10_sub_pixel_variance8x16_c, 10),
- make_tuple(3, 3, &vpx_highbd_10_sub_pixel_variance8x8_c, 10),
- make_tuple(3, 2, &vpx_highbd_10_sub_pixel_variance8x4_c, 10),
- make_tuple(2, 3, &vpx_highbd_10_sub_pixel_variance4x8_c, 10),
- make_tuple(2, 2, &vpx_highbd_10_sub_pixel_variance4x4_c, 10),
-#if CONFIG_VP10 && CONFIG_EXT_PARTITION
- make_tuple(7, 7, &vpx_highbd_12_sub_pixel_variance128x128_c, 12),
- make_tuple(7, 6, &vpx_highbd_12_sub_pixel_variance128x64_c, 12),
- make_tuple(6, 7, &vpx_highbd_12_sub_pixel_variance64x128_c, 12),
-#endif // CONFIG_VP10 && CONFIG_EXT_PARTITION
- make_tuple(6, 6, &vpx_highbd_12_sub_pixel_variance64x64_c, 12),
- make_tuple(6, 5, &vpx_highbd_12_sub_pixel_variance64x32_c, 12),
- make_tuple(5, 6, &vpx_highbd_12_sub_pixel_variance32x64_c, 12),
- make_tuple(5, 5, &vpx_highbd_12_sub_pixel_variance32x32_c, 12),
- make_tuple(5, 4, &vpx_highbd_12_sub_pixel_variance32x16_c, 12),
- make_tuple(4, 5, &vpx_highbd_12_sub_pixel_variance16x32_c, 12),
- make_tuple(4, 4, &vpx_highbd_12_sub_pixel_variance16x16_c, 12),
- make_tuple(4, 3, &vpx_highbd_12_sub_pixel_variance16x8_c, 12),
- make_tuple(3, 4, &vpx_highbd_12_sub_pixel_variance8x16_c, 12),
- make_tuple(3, 3, &vpx_highbd_12_sub_pixel_variance8x8_c, 12),
- make_tuple(3, 2, &vpx_highbd_12_sub_pixel_variance8x4_c, 12),
- make_tuple(2, 3, &vpx_highbd_12_sub_pixel_variance4x8_c, 12),
- make_tuple(2, 2, &vpx_highbd_12_sub_pixel_variance4x4_c, 12),
+const AvxHBDSubpelVarianceTest::ParamType kArrayHBDSubpelVariance_c[] = {
+#if CONFIG_AV1 && CONFIG_EXT_PARTITION
+ make_tuple(7, 7, &aom_highbd_8_sub_pixel_variance128x128_c, 8),
+ make_tuple(7, 6, &aom_highbd_8_sub_pixel_variance128x64_c, 8),
+ make_tuple(6, 7, &aom_highbd_8_sub_pixel_variance64x128_c, 8),
+#endif // CONFIG_AV1 && CONFIG_EXT_PARTITION
+ make_tuple(6, 6, &aom_highbd_8_sub_pixel_variance64x64_c, 8),
+ make_tuple(6, 5, &aom_highbd_8_sub_pixel_variance64x32_c, 8),
+ make_tuple(5, 6, &aom_highbd_8_sub_pixel_variance32x64_c, 8),
+ make_tuple(5, 5, &aom_highbd_8_sub_pixel_variance32x32_c, 8),
+ make_tuple(5, 4, &aom_highbd_8_sub_pixel_variance32x16_c, 8),
+ make_tuple(4, 5, &aom_highbd_8_sub_pixel_variance16x32_c, 8),
+ make_tuple(4, 4, &aom_highbd_8_sub_pixel_variance16x16_c, 8),
+ make_tuple(4, 3, &aom_highbd_8_sub_pixel_variance16x8_c, 8),
+ make_tuple(3, 4, &aom_highbd_8_sub_pixel_variance8x16_c, 8),
+ make_tuple(3, 3, &aom_highbd_8_sub_pixel_variance8x8_c, 8),
+ make_tuple(3, 2, &aom_highbd_8_sub_pixel_variance8x4_c, 8),
+ make_tuple(2, 3, &aom_highbd_8_sub_pixel_variance4x8_c, 8),
+ make_tuple(2, 2, &aom_highbd_8_sub_pixel_variance4x4_c, 8),
+#if CONFIG_AV1 && CONFIG_EXT_PARTITION
+ make_tuple(7, 7, &aom_highbd_10_sub_pixel_variance128x128_c, 10),
+ make_tuple(7, 6, &aom_highbd_10_sub_pixel_variance128x64_c, 10),
+ make_tuple(6, 7, &aom_highbd_10_sub_pixel_variance64x128_c, 10),
+#endif // CONFIG_AV1 && CONFIG_EXT_PARTITION
+ make_tuple(6, 6, &aom_highbd_10_sub_pixel_variance64x64_c, 10),
+ make_tuple(6, 5, &aom_highbd_10_sub_pixel_variance64x32_c, 10),
+ make_tuple(5, 6, &aom_highbd_10_sub_pixel_variance32x64_c, 10),
+ make_tuple(5, 5, &aom_highbd_10_sub_pixel_variance32x32_c, 10),
+ make_tuple(5, 4, &aom_highbd_10_sub_pixel_variance32x16_c, 10),
+ make_tuple(4, 5, &aom_highbd_10_sub_pixel_variance16x32_c, 10),
+ make_tuple(4, 4, &aom_highbd_10_sub_pixel_variance16x16_c, 10),
+ make_tuple(4, 3, &aom_highbd_10_sub_pixel_variance16x8_c, 10),
+ make_tuple(3, 4, &aom_highbd_10_sub_pixel_variance8x16_c, 10),
+ make_tuple(3, 3, &aom_highbd_10_sub_pixel_variance8x8_c, 10),
+ make_tuple(3, 2, &aom_highbd_10_sub_pixel_variance8x4_c, 10),
+ make_tuple(2, 3, &aom_highbd_10_sub_pixel_variance4x8_c, 10),
+ make_tuple(2, 2, &aom_highbd_10_sub_pixel_variance4x4_c, 10),
+#if CONFIG_AV1 && CONFIG_EXT_PARTITION
+ make_tuple(7, 7, &aom_highbd_12_sub_pixel_variance128x128_c, 12),
+ make_tuple(7, 6, &aom_highbd_12_sub_pixel_variance128x64_c, 12),
+ make_tuple(6, 7, &aom_highbd_12_sub_pixel_variance64x128_c, 12),
+#endif // CONFIG_AV1 && CONFIG_EXT_PARTITION
+ make_tuple(6, 6, &aom_highbd_12_sub_pixel_variance64x64_c, 12),
+ make_tuple(6, 5, &aom_highbd_12_sub_pixel_variance64x32_c, 12),
+ make_tuple(5, 6, &aom_highbd_12_sub_pixel_variance32x64_c, 12),
+ make_tuple(5, 5, &aom_highbd_12_sub_pixel_variance32x32_c, 12),
+ make_tuple(5, 4, &aom_highbd_12_sub_pixel_variance32x16_c, 12),
+ make_tuple(4, 5, &aom_highbd_12_sub_pixel_variance16x32_c, 12),
+ make_tuple(4, 4, &aom_highbd_12_sub_pixel_variance16x16_c, 12),
+ make_tuple(4, 3, &aom_highbd_12_sub_pixel_variance16x8_c, 12),
+ make_tuple(3, 4, &aom_highbd_12_sub_pixel_variance8x16_c, 12),
+ make_tuple(3, 3, &aom_highbd_12_sub_pixel_variance8x8_c, 12),
+ make_tuple(3, 2, &aom_highbd_12_sub_pixel_variance8x4_c, 12),
+ make_tuple(2, 3, &aom_highbd_12_sub_pixel_variance4x8_c, 12),
+ make_tuple(2, 2, &aom_highbd_12_sub_pixel_variance4x4_c, 12),
};
-INSTANTIATE_TEST_CASE_P(C, VpxHBDSubpelVarianceTest,
+INSTANTIATE_TEST_CASE_P(C, AvxHBDSubpelVarianceTest,
::testing::ValuesIn(kArrayHBDSubpelVariance_c));
-const VpxHBDSubpelAvgVarianceTest::ParamType kArrayHBDSubpelAvgVariance_c[] = {
-#if CONFIG_VP10 && CONFIG_EXT_PARTITION
- make_tuple(7, 7, &vpx_highbd_8_sub_pixel_avg_variance128x128_c, 8),
- make_tuple(7, 6, &vpx_highbd_8_sub_pixel_avg_variance128x64_c, 8),
- make_tuple(6, 7, &vpx_highbd_8_sub_pixel_avg_variance64x128_c, 8),
-#endif // CONFIG_VP10 && CONFIG_EXT_PARTITION
- make_tuple(6, 6, &vpx_highbd_8_sub_pixel_avg_variance64x64_c, 8),
- make_tuple(6, 5, &vpx_highbd_8_sub_pixel_avg_variance64x32_c, 8),
- make_tuple(5, 6, &vpx_highbd_8_sub_pixel_avg_variance32x64_c, 8),
- make_tuple(5, 5, &vpx_highbd_8_sub_pixel_avg_variance32x32_c, 8),
- make_tuple(5, 4, &vpx_highbd_8_sub_pixel_avg_variance32x16_c, 8),
- make_tuple(4, 5, &vpx_highbd_8_sub_pixel_avg_variance16x32_c, 8),
- make_tuple(4, 4, &vpx_highbd_8_sub_pixel_avg_variance16x16_c, 8),
- make_tuple(4, 3, &vpx_highbd_8_sub_pixel_avg_variance16x8_c, 8),
- make_tuple(3, 4, &vpx_highbd_8_sub_pixel_avg_variance8x16_c, 8),
- make_tuple(3, 3, &vpx_highbd_8_sub_pixel_avg_variance8x8_c, 8),
- make_tuple(3, 2, &vpx_highbd_8_sub_pixel_avg_variance8x4_c, 8),
- make_tuple(2, 3, &vpx_highbd_8_sub_pixel_avg_variance4x8_c, 8),
- make_tuple(2, 2, &vpx_highbd_8_sub_pixel_avg_variance4x4_c, 8),
-#if CONFIG_VP10 && CONFIG_EXT_PARTITION
- make_tuple(7, 7, &vpx_highbd_10_sub_pixel_avg_variance128x128_c, 10),
- make_tuple(7, 6, &vpx_highbd_10_sub_pixel_avg_variance128x64_c, 10),
- make_tuple(6, 7, &vpx_highbd_10_sub_pixel_avg_variance64x128_c, 10),
-#endif // CONFIG_VP10 && CONFIG_EXT_PARTITION
- make_tuple(6, 6, &vpx_highbd_10_sub_pixel_avg_variance64x64_c, 10),
- make_tuple(6, 5, &vpx_highbd_10_sub_pixel_avg_variance64x32_c, 10),
- make_tuple(5, 6, &vpx_highbd_10_sub_pixel_avg_variance32x64_c, 10),
- make_tuple(5, 5, &vpx_highbd_10_sub_pixel_avg_variance32x32_c, 10),
- make_tuple(5, 4, &vpx_highbd_10_sub_pixel_avg_variance32x16_c, 10),
- make_tuple(4, 5, &vpx_highbd_10_sub_pixel_avg_variance16x32_c, 10),
- make_tuple(4, 4, &vpx_highbd_10_sub_pixel_avg_variance16x16_c, 10),
- make_tuple(4, 3, &vpx_highbd_10_sub_pixel_avg_variance16x8_c, 10),
- make_tuple(3, 4, &vpx_highbd_10_sub_pixel_avg_variance8x16_c, 10),
- make_tuple(3, 3, &vpx_highbd_10_sub_pixel_avg_variance8x8_c, 10),
- make_tuple(3, 2, &vpx_highbd_10_sub_pixel_avg_variance8x4_c, 10),
- make_tuple(2, 3, &vpx_highbd_10_sub_pixel_avg_variance4x8_c, 10),
- make_tuple(2, 2, &vpx_highbd_10_sub_pixel_avg_variance4x4_c, 10),
-#if CONFIG_VP10 && CONFIG_EXT_PARTITION
- make_tuple(7, 7, &vpx_highbd_12_sub_pixel_avg_variance128x128_c, 12),
- make_tuple(7, 6, &vpx_highbd_12_sub_pixel_avg_variance128x64_c, 12),
- make_tuple(6, 7, &vpx_highbd_12_sub_pixel_avg_variance64x128_c, 12),
-#endif // CONFIG_VP10 && CONFIG_EXT_PARTITION
- make_tuple(6, 6, &vpx_highbd_12_sub_pixel_avg_variance64x64_c, 12),
- make_tuple(6, 5, &vpx_highbd_12_sub_pixel_avg_variance64x32_c, 12),
- make_tuple(5, 6, &vpx_highbd_12_sub_pixel_avg_variance32x64_c, 12),
- make_tuple(5, 5, &vpx_highbd_12_sub_pixel_avg_variance32x32_c, 12),
- make_tuple(5, 4, &vpx_highbd_12_sub_pixel_avg_variance32x16_c, 12),
- make_tuple(4, 5, &vpx_highbd_12_sub_pixel_avg_variance16x32_c, 12),
- make_tuple(4, 4, &vpx_highbd_12_sub_pixel_avg_variance16x16_c, 12),
- make_tuple(4, 3, &vpx_highbd_12_sub_pixel_avg_variance16x8_c, 12),
- make_tuple(3, 4, &vpx_highbd_12_sub_pixel_avg_variance8x16_c, 12),
- make_tuple(3, 3, &vpx_highbd_12_sub_pixel_avg_variance8x8_c, 12),
- make_tuple(3, 2, &vpx_highbd_12_sub_pixel_avg_variance8x4_c, 12),
- make_tuple(2, 3, &vpx_highbd_12_sub_pixel_avg_variance4x8_c, 12),
- make_tuple(2, 2, &vpx_highbd_12_sub_pixel_avg_variance4x4_c, 12)
+const AvxHBDSubpelAvgVarianceTest::ParamType kArrayHBDSubpelAvgVariance_c[] = {
+#if CONFIG_AV1 && CONFIG_EXT_PARTITION
+ make_tuple(7, 7, &aom_highbd_8_sub_pixel_avg_variance128x128_c, 8),
+ make_tuple(7, 6, &aom_highbd_8_sub_pixel_avg_variance128x64_c, 8),
+ make_tuple(6, 7, &aom_highbd_8_sub_pixel_avg_variance64x128_c, 8),
+#endif // CONFIG_AV1 && CONFIG_EXT_PARTITION
+ make_tuple(6, 6, &aom_highbd_8_sub_pixel_avg_variance64x64_c, 8),
+ make_tuple(6, 5, &aom_highbd_8_sub_pixel_avg_variance64x32_c, 8),
+ make_tuple(5, 6, &aom_highbd_8_sub_pixel_avg_variance32x64_c, 8),
+ make_tuple(5, 5, &aom_highbd_8_sub_pixel_avg_variance32x32_c, 8),
+ make_tuple(5, 4, &aom_highbd_8_sub_pixel_avg_variance32x16_c, 8),
+ make_tuple(4, 5, &aom_highbd_8_sub_pixel_avg_variance16x32_c, 8),
+ make_tuple(4, 4, &aom_highbd_8_sub_pixel_avg_variance16x16_c, 8),
+ make_tuple(4, 3, &aom_highbd_8_sub_pixel_avg_variance16x8_c, 8),
+ make_tuple(3, 4, &aom_highbd_8_sub_pixel_avg_variance8x16_c, 8),
+ make_tuple(3, 3, &aom_highbd_8_sub_pixel_avg_variance8x8_c, 8),
+ make_tuple(3, 2, &aom_highbd_8_sub_pixel_avg_variance8x4_c, 8),
+ make_tuple(2, 3, &aom_highbd_8_sub_pixel_avg_variance4x8_c, 8),
+ make_tuple(2, 2, &aom_highbd_8_sub_pixel_avg_variance4x4_c, 8),
+#if CONFIG_AV1 && CONFIG_EXT_PARTITION
+ make_tuple(7, 7, &aom_highbd_10_sub_pixel_avg_variance128x128_c, 10),
+ make_tuple(7, 6, &aom_highbd_10_sub_pixel_avg_variance128x64_c, 10),
+ make_tuple(6, 7, &aom_highbd_10_sub_pixel_avg_variance64x128_c, 10),
+#endif // CONFIG_AV1 && CONFIG_EXT_PARTITION
+ make_tuple(6, 6, &aom_highbd_10_sub_pixel_avg_variance64x64_c, 10),
+ make_tuple(6, 5, &aom_highbd_10_sub_pixel_avg_variance64x32_c, 10),
+ make_tuple(5, 6, &aom_highbd_10_sub_pixel_avg_variance32x64_c, 10),
+ make_tuple(5, 5, &aom_highbd_10_sub_pixel_avg_variance32x32_c, 10),
+ make_tuple(5, 4, &aom_highbd_10_sub_pixel_avg_variance32x16_c, 10),
+ make_tuple(4, 5, &aom_highbd_10_sub_pixel_avg_variance16x32_c, 10),
+ make_tuple(4, 4, &aom_highbd_10_sub_pixel_avg_variance16x16_c, 10),
+ make_tuple(4, 3, &aom_highbd_10_sub_pixel_avg_variance16x8_c, 10),
+ make_tuple(3, 4, &aom_highbd_10_sub_pixel_avg_variance8x16_c, 10),
+ make_tuple(3, 3, &aom_highbd_10_sub_pixel_avg_variance8x8_c, 10),
+ make_tuple(3, 2, &aom_highbd_10_sub_pixel_avg_variance8x4_c, 10),
+ make_tuple(2, 3, &aom_highbd_10_sub_pixel_avg_variance4x8_c, 10),
+ make_tuple(2, 2, &aom_highbd_10_sub_pixel_avg_variance4x4_c, 10),
+#if CONFIG_AV1 && CONFIG_EXT_PARTITION
+ make_tuple(7, 7, &aom_highbd_12_sub_pixel_avg_variance128x128_c, 12),
+ make_tuple(7, 6, &aom_highbd_12_sub_pixel_avg_variance128x64_c, 12),
+ make_tuple(6, 7, &aom_highbd_12_sub_pixel_avg_variance64x128_c, 12),
+#endif // CONFIG_AV1 && CONFIG_EXT_PARTITION
+ make_tuple(6, 6, &aom_highbd_12_sub_pixel_avg_variance64x64_c, 12),
+ make_tuple(6, 5, &aom_highbd_12_sub_pixel_avg_variance64x32_c, 12),
+ make_tuple(5, 6, &aom_highbd_12_sub_pixel_avg_variance32x64_c, 12),
+ make_tuple(5, 5, &aom_highbd_12_sub_pixel_avg_variance32x32_c, 12),
+ make_tuple(5, 4, &aom_highbd_12_sub_pixel_avg_variance32x16_c, 12),
+ make_tuple(4, 5, &aom_highbd_12_sub_pixel_avg_variance16x32_c, 12),
+ make_tuple(4, 4, &aom_highbd_12_sub_pixel_avg_variance16x16_c, 12),
+ make_tuple(4, 3, &aom_highbd_12_sub_pixel_avg_variance16x8_c, 12),
+ make_tuple(3, 4, &aom_highbd_12_sub_pixel_avg_variance8x16_c, 12),
+ make_tuple(3, 3, &aom_highbd_12_sub_pixel_avg_variance8x8_c, 12),
+ make_tuple(3, 2, &aom_highbd_12_sub_pixel_avg_variance8x4_c, 12),
+ make_tuple(2, 3, &aom_highbd_12_sub_pixel_avg_variance4x8_c, 12),
+ make_tuple(2, 2, &aom_highbd_12_sub_pixel_avg_variance4x4_c, 12)
};
-INSTANTIATE_TEST_CASE_P(C, VpxHBDSubpelAvgVarianceTest,
+INSTANTIATE_TEST_CASE_P(C, AvxHBDSubpelAvgVarianceTest,
::testing::ValuesIn(kArrayHBDSubpelAvgVariance_c));
-#endif // CONFIG_VP9_HIGHBITDEPTH
+#endif // CONFIG_AOM_HIGHBITDEPTH
#if HAVE_SSE2
INSTANTIATE_TEST_CASE_P(SSE2, SumOfSquaresTest,
- ::testing::Values(vpx_get_mb_ss_sse2));
+ ::testing::Values(aom_get_mb_ss_sse2));
-INSTANTIATE_TEST_CASE_P(SSE2, VpxMseTest,
- ::testing::Values(MseParams(4, 4, &vpx_mse16x16_sse2),
- MseParams(4, 3, &vpx_mse16x8_sse2),
- MseParams(3, 4, &vpx_mse8x16_sse2),
- MseParams(3, 3, &vpx_mse8x8_sse2)));
+INSTANTIATE_TEST_CASE_P(SSE2, AvxMseTest,
+ ::testing::Values(MseParams(4, 4, &aom_mse16x16_sse2),
+ MseParams(4, 3, &aom_mse16x8_sse2),
+ MseParams(3, 4, &aom_mse8x16_sse2),
+ MseParams(3, 3, &aom_mse8x8_sse2)));
INSTANTIATE_TEST_CASE_P(
- SSE2, VpxVarianceTest,
- ::testing::Values(VarianceParams(6, 6, &vpx_variance64x64_sse2),
- VarianceParams(6, 5, &vpx_variance64x32_sse2),
- VarianceParams(5, 6, &vpx_variance32x64_sse2),
- VarianceParams(5, 5, &vpx_variance32x32_sse2),
- VarianceParams(5, 4, &vpx_variance32x16_sse2),
- VarianceParams(4, 5, &vpx_variance16x32_sse2),
- VarianceParams(4, 4, &vpx_variance16x16_sse2),
- VarianceParams(4, 3, &vpx_variance16x8_sse2),
- VarianceParams(3, 4, &vpx_variance8x16_sse2),
- VarianceParams(3, 3, &vpx_variance8x8_sse2),
- VarianceParams(3, 2, &vpx_variance8x4_sse2),
- VarianceParams(2, 3, &vpx_variance4x8_sse2),
- VarianceParams(2, 2, &vpx_variance4x4_sse2)));
+ SSE2, AvxVarianceTest,
+ ::testing::Values(VarianceParams(6, 6, &aom_variance64x64_sse2),
+ VarianceParams(6, 5, &aom_variance64x32_sse2),
+ VarianceParams(5, 6, &aom_variance32x64_sse2),
+ VarianceParams(5, 5, &aom_variance32x32_sse2),
+ VarianceParams(5, 4, &aom_variance32x16_sse2),
+ VarianceParams(4, 5, &aom_variance16x32_sse2),
+ VarianceParams(4, 4, &aom_variance16x16_sse2),
+ VarianceParams(4, 3, &aom_variance16x8_sse2),
+ VarianceParams(3, 4, &aom_variance8x16_sse2),
+ VarianceParams(3, 3, &aom_variance8x8_sse2),
+ VarianceParams(3, 2, &aom_variance8x4_sse2),
+ VarianceParams(2, 3, &aom_variance4x8_sse2),
+ VarianceParams(2, 2, &aom_variance4x4_sse2)));
INSTANTIATE_TEST_CASE_P(
- SSE2, VpxSubpelVarianceTest,
- ::testing::Values(make_tuple(6, 6, &vpx_sub_pixel_variance64x64_sse2, 0),
- make_tuple(6, 5, &vpx_sub_pixel_variance64x32_sse2, 0),
- make_tuple(5, 6, &vpx_sub_pixel_variance32x64_sse2, 0),
- make_tuple(5, 5, &vpx_sub_pixel_variance32x32_sse2, 0),
- make_tuple(5, 4, &vpx_sub_pixel_variance32x16_sse2, 0),
- make_tuple(4, 5, &vpx_sub_pixel_variance16x32_sse2, 0),
- make_tuple(4, 4, &vpx_sub_pixel_variance16x16_sse2, 0),
- make_tuple(4, 3, &vpx_sub_pixel_variance16x8_sse2, 0),
- make_tuple(3, 4, &vpx_sub_pixel_variance8x16_sse2, 0),
- make_tuple(3, 3, &vpx_sub_pixel_variance8x8_sse2, 0),
- make_tuple(3, 2, &vpx_sub_pixel_variance8x4_sse2, 0),
- make_tuple(2, 3, &vpx_sub_pixel_variance4x8_sse2, 0),
- make_tuple(2, 2, &vpx_sub_pixel_variance4x4_sse2, 0)));
+ SSE2, AvxSubpelVarianceTest,
+ ::testing::Values(make_tuple(6, 6, &aom_sub_pixel_variance64x64_sse2, 0),
+ make_tuple(6, 5, &aom_sub_pixel_variance64x32_sse2, 0),
+ make_tuple(5, 6, &aom_sub_pixel_variance32x64_sse2, 0),
+ make_tuple(5, 5, &aom_sub_pixel_variance32x32_sse2, 0),
+ make_tuple(5, 4, &aom_sub_pixel_variance32x16_sse2, 0),
+ make_tuple(4, 5, &aom_sub_pixel_variance16x32_sse2, 0),
+ make_tuple(4, 4, &aom_sub_pixel_variance16x16_sse2, 0),
+ make_tuple(4, 3, &aom_sub_pixel_variance16x8_sse2, 0),
+ make_tuple(3, 4, &aom_sub_pixel_variance8x16_sse2, 0),
+ make_tuple(3, 3, &aom_sub_pixel_variance8x8_sse2, 0),
+ make_tuple(3, 2, &aom_sub_pixel_variance8x4_sse2, 0),
+ make_tuple(2, 3, &aom_sub_pixel_variance4x8_sse2, 0),
+ make_tuple(2, 2, &aom_sub_pixel_variance4x4_sse2, 0)));
INSTANTIATE_TEST_CASE_P(
- SSE2, VpxSubpelAvgVarianceTest,
+ SSE2, AvxSubpelAvgVarianceTest,
::testing::Values(
- make_tuple(6, 6, &vpx_sub_pixel_avg_variance64x64_sse2, 0),
- make_tuple(6, 5, &vpx_sub_pixel_avg_variance64x32_sse2, 0),
- make_tuple(5, 6, &vpx_sub_pixel_avg_variance32x64_sse2, 0),
- make_tuple(5, 5, &vpx_sub_pixel_avg_variance32x32_sse2, 0),
- make_tuple(5, 4, &vpx_sub_pixel_avg_variance32x16_sse2, 0),
- make_tuple(4, 5, &vpx_sub_pixel_avg_variance16x32_sse2, 0),
- make_tuple(4, 4, &vpx_sub_pixel_avg_variance16x16_sse2, 0),
- make_tuple(4, 3, &vpx_sub_pixel_avg_variance16x8_sse2, 0),
- make_tuple(3, 4, &vpx_sub_pixel_avg_variance8x16_sse2, 0),
- make_tuple(3, 3, &vpx_sub_pixel_avg_variance8x8_sse2, 0),
- make_tuple(3, 2, &vpx_sub_pixel_avg_variance8x4_sse2, 0),
- make_tuple(2, 3, &vpx_sub_pixel_avg_variance4x8_sse2, 0),
- make_tuple(2, 2, &vpx_sub_pixel_avg_variance4x4_sse2, 0)));
+ make_tuple(6, 6, &aom_sub_pixel_avg_variance64x64_sse2, 0),
+ make_tuple(6, 5, &aom_sub_pixel_avg_variance64x32_sse2, 0),
+ make_tuple(5, 6, &aom_sub_pixel_avg_variance32x64_sse2, 0),
+ make_tuple(5, 5, &aom_sub_pixel_avg_variance32x32_sse2, 0),
+ make_tuple(5, 4, &aom_sub_pixel_avg_variance32x16_sse2, 0),
+ make_tuple(4, 5, &aom_sub_pixel_avg_variance16x32_sse2, 0),
+ make_tuple(4, 4, &aom_sub_pixel_avg_variance16x16_sse2, 0),
+ make_tuple(4, 3, &aom_sub_pixel_avg_variance16x8_sse2, 0),
+ make_tuple(3, 4, &aom_sub_pixel_avg_variance8x16_sse2, 0),
+ make_tuple(3, 3, &aom_sub_pixel_avg_variance8x8_sse2, 0),
+ make_tuple(3, 2, &aom_sub_pixel_avg_variance8x4_sse2, 0),
+ make_tuple(2, 3, &aom_sub_pixel_avg_variance4x8_sse2, 0),
+ make_tuple(2, 2, &aom_sub_pixel_avg_variance4x4_sse2, 0)));
-#if HAVE_SSE4_1 && CONFIG_VP9_HIGHBITDEPTH
+#if HAVE_SSE4_1 && CONFIG_AOM_HIGHBITDEPTH
INSTANTIATE_TEST_CASE_P(
- SSE4_1, VpxSubpelVarianceTest,
+ SSE4_1, AvxSubpelVarianceTest,
::testing::Values(
- make_tuple(2, 2, &vpx_highbd_8_sub_pixel_variance4x4_sse4_1, 8),
- make_tuple(2, 2, &vpx_highbd_10_sub_pixel_variance4x4_sse4_1, 10),
- make_tuple(2, 2, &vpx_highbd_12_sub_pixel_variance4x4_sse4_1, 12)));
+ make_tuple(2, 2, &aom_highbd_8_sub_pixel_variance4x4_sse4_1, 8),
+ make_tuple(2, 2, &aom_highbd_10_sub_pixel_variance4x4_sse4_1, 10),
+ make_tuple(2, 2, &aom_highbd_12_sub_pixel_variance4x4_sse4_1, 12)));
INSTANTIATE_TEST_CASE_P(
- SSE4_1, VpxSubpelAvgVarianceTest,
+ SSE4_1, AvxSubpelAvgVarianceTest,
::testing::Values(
- make_tuple(2, 2, &vpx_highbd_8_sub_pixel_avg_variance4x4_sse4_1, 8),
- make_tuple(2, 2, &vpx_highbd_10_sub_pixel_avg_variance4x4_sse4_1, 10),
- make_tuple(2, 2, &vpx_highbd_12_sub_pixel_avg_variance4x4_sse4_1, 12)));
-#endif // HAVE_SSE4_1 && CONFIG_VP9_HIGHBITDEPTH
+ make_tuple(2, 2, &aom_highbd_8_sub_pixel_avg_variance4x4_sse4_1, 8),
+ make_tuple(2, 2, &aom_highbd_10_sub_pixel_avg_variance4x4_sse4_1, 10),
+ make_tuple(2, 2, &aom_highbd_12_sub_pixel_avg_variance4x4_sse4_1, 12)));
+#endif // HAVE_SSE4_1 && CONFIG_AOM_HIGHBITDEPTH
-#if CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_AOM_HIGHBITDEPTH
/* TODO(debargha): This test does not support the highbd version
INSTANTIATE_TEST_CASE_P(
- SSE2, VpxHBDMseTest,
- ::testing::Values(MseParams(4, 4, &vpx_highbd_12_mse16x16_sse2),
- MseParams(4, 3, &vpx_highbd_12_mse16x8_sse2),
- MseParams(3, 4, &vpx_highbd_12_mse8x16_sse2),
- MseParams(3, 3, &vpx_highbd_12_mse8x8_sse2),
- MseParams(4, 4, &vpx_highbd_10_mse16x16_sse2),
- MseParams(4, 3, &vpx_highbd_10_mse16x8_sse2),
- MseParams(3, 4, &vpx_highbd_10_mse8x16_sse2),
- MseParams(3, 3, &vpx_highbd_10_mse8x8_sse2),
- MseParams(4, 4, &vpx_highbd_8_mse16x16_sse2),
- MseParams(4, 3, &vpx_highbd_8_mse16x8_sse2),
- MseParams(3, 4, &vpx_highbd_8_mse8x16_sse2),
- MseParams(3, 3, &vpx_highbd_8_mse8x8_sse2)));
+ SSE2, AvxHBDMseTest,
+ ::testing::Values(MseParams(4, 4, &aom_highbd_12_mse16x16_sse2),
+ MseParams(4, 3, &aom_highbd_12_mse16x8_sse2),
+ MseParams(3, 4, &aom_highbd_12_mse8x16_sse2),
+ MseParams(3, 3, &aom_highbd_12_mse8x8_sse2),
+ MseParams(4, 4, &aom_highbd_10_mse16x16_sse2),
+ MseParams(4, 3, &aom_highbd_10_mse16x8_sse2),
+ MseParams(3, 4, &aom_highbd_10_mse8x16_sse2),
+ MseParams(3, 3, &aom_highbd_10_mse8x8_sse2),
+ MseParams(4, 4, &aom_highbd_8_mse16x16_sse2),
+ MseParams(4, 3, &aom_highbd_8_mse16x8_sse2),
+ MseParams(3, 4, &aom_highbd_8_mse8x16_sse2),
+ MseParams(3, 3, &aom_highbd_8_mse8x8_sse2)));
*/
INSTANTIATE_TEST_CASE_P(
- SSE2, VpxHBDVarianceTest,
+ SSE2, AvxHBDVarianceTest,
::testing::Values(
- VarianceParams(6, 6, &vpx_highbd_12_variance64x64_sse2, 12),
- VarianceParams(6, 5, &vpx_highbd_12_variance64x32_sse2, 12),
- VarianceParams(5, 6, &vpx_highbd_12_variance32x64_sse2, 12),
- VarianceParams(5, 5, &vpx_highbd_12_variance32x32_sse2, 12),
- VarianceParams(5, 4, &vpx_highbd_12_variance32x16_sse2, 12),
- VarianceParams(4, 5, &vpx_highbd_12_variance16x32_sse2, 12),
- VarianceParams(4, 4, &vpx_highbd_12_variance16x16_sse2, 12),
- VarianceParams(4, 3, &vpx_highbd_12_variance16x8_sse2, 12),
- VarianceParams(3, 4, &vpx_highbd_12_variance8x16_sse2, 12),
- VarianceParams(3, 3, &vpx_highbd_12_variance8x8_sse2, 12),
- VarianceParams(6, 6, &vpx_highbd_10_variance64x64_sse2, 10),
- VarianceParams(6, 5, &vpx_highbd_10_variance64x32_sse2, 10),
- VarianceParams(5, 6, &vpx_highbd_10_variance32x64_sse2, 10),
- VarianceParams(5, 5, &vpx_highbd_10_variance32x32_sse2, 10),
- VarianceParams(5, 4, &vpx_highbd_10_variance32x16_sse2, 10),
- VarianceParams(4, 5, &vpx_highbd_10_variance16x32_sse2, 10),
- VarianceParams(4, 4, &vpx_highbd_10_variance16x16_sse2, 10),
- VarianceParams(4, 3, &vpx_highbd_10_variance16x8_sse2, 10),
- VarianceParams(3, 4, &vpx_highbd_10_variance8x16_sse2, 10),
- VarianceParams(3, 3, &vpx_highbd_10_variance8x8_sse2, 10),
- VarianceParams(6, 6, &vpx_highbd_8_variance64x64_sse2, 8),
- VarianceParams(6, 5, &vpx_highbd_8_variance64x32_sse2, 8),
- VarianceParams(5, 6, &vpx_highbd_8_variance32x64_sse2, 8),
- VarianceParams(5, 5, &vpx_highbd_8_variance32x32_sse2, 8),
- VarianceParams(5, 4, &vpx_highbd_8_variance32x16_sse2, 8),
- VarianceParams(4, 5, &vpx_highbd_8_variance16x32_sse2, 8),
- VarianceParams(4, 4, &vpx_highbd_8_variance16x16_sse2, 8),
- VarianceParams(4, 3, &vpx_highbd_8_variance16x8_sse2, 8),
- VarianceParams(3, 4, &vpx_highbd_8_variance8x16_sse2, 8),
- VarianceParams(3, 3, &vpx_highbd_8_variance8x8_sse2, 8)));
+ VarianceParams(6, 6, &aom_highbd_12_variance64x64_sse2, 12),
+ VarianceParams(6, 5, &aom_highbd_12_variance64x32_sse2, 12),
+ VarianceParams(5, 6, &aom_highbd_12_variance32x64_sse2, 12),
+ VarianceParams(5, 5, &aom_highbd_12_variance32x32_sse2, 12),
+ VarianceParams(5, 4, &aom_highbd_12_variance32x16_sse2, 12),
+ VarianceParams(4, 5, &aom_highbd_12_variance16x32_sse2, 12),
+ VarianceParams(4, 4, &aom_highbd_12_variance16x16_sse2, 12),
+ VarianceParams(4, 3, &aom_highbd_12_variance16x8_sse2, 12),
+ VarianceParams(3, 4, &aom_highbd_12_variance8x16_sse2, 12),
+ VarianceParams(3, 3, &aom_highbd_12_variance8x8_sse2, 12),
+ VarianceParams(6, 6, &aom_highbd_10_variance64x64_sse2, 10),
+ VarianceParams(6, 5, &aom_highbd_10_variance64x32_sse2, 10),
+ VarianceParams(5, 6, &aom_highbd_10_variance32x64_sse2, 10),
+ VarianceParams(5, 5, &aom_highbd_10_variance32x32_sse2, 10),
+ VarianceParams(5, 4, &aom_highbd_10_variance32x16_sse2, 10),
+ VarianceParams(4, 5, &aom_highbd_10_variance16x32_sse2, 10),
+ VarianceParams(4, 4, &aom_highbd_10_variance16x16_sse2, 10),
+ VarianceParams(4, 3, &aom_highbd_10_variance16x8_sse2, 10),
+ VarianceParams(3, 4, &aom_highbd_10_variance8x16_sse2, 10),
+ VarianceParams(3, 3, &aom_highbd_10_variance8x8_sse2, 10),
+ VarianceParams(6, 6, &aom_highbd_8_variance64x64_sse2, 8),
+ VarianceParams(6, 5, &aom_highbd_8_variance64x32_sse2, 8),
+ VarianceParams(5, 6, &aom_highbd_8_variance32x64_sse2, 8),
+ VarianceParams(5, 5, &aom_highbd_8_variance32x32_sse2, 8),
+ VarianceParams(5, 4, &aom_highbd_8_variance32x16_sse2, 8),
+ VarianceParams(4, 5, &aom_highbd_8_variance16x32_sse2, 8),
+ VarianceParams(4, 4, &aom_highbd_8_variance16x16_sse2, 8),
+ VarianceParams(4, 3, &aom_highbd_8_variance16x8_sse2, 8),
+ VarianceParams(3, 4, &aom_highbd_8_variance8x16_sse2, 8),
+ VarianceParams(3, 3, &aom_highbd_8_variance8x8_sse2, 8)));
INSTANTIATE_TEST_CASE_P(
- SSE2, VpxHBDSubpelVarianceTest,
+ SSE2, AvxHBDSubpelVarianceTest,
::testing::Values(
- make_tuple(6, 6, &vpx_highbd_12_sub_pixel_variance64x64_sse2, 12),
- make_tuple(6, 5, &vpx_highbd_12_sub_pixel_variance64x32_sse2, 12),
- make_tuple(5, 6, &vpx_highbd_12_sub_pixel_variance32x64_sse2, 12),
- make_tuple(5, 5, &vpx_highbd_12_sub_pixel_variance32x32_sse2, 12),
- make_tuple(5, 4, &vpx_highbd_12_sub_pixel_variance32x16_sse2, 12),
- make_tuple(4, 5, &vpx_highbd_12_sub_pixel_variance16x32_sse2, 12),
- make_tuple(4, 4, &vpx_highbd_12_sub_pixel_variance16x16_sse2, 12),
- make_tuple(4, 3, &vpx_highbd_12_sub_pixel_variance16x8_sse2, 12),
- make_tuple(3, 4, &vpx_highbd_12_sub_pixel_variance8x16_sse2, 12),
- make_tuple(3, 3, &vpx_highbd_12_sub_pixel_variance8x8_sse2, 12),
- make_tuple(3, 2, &vpx_highbd_12_sub_pixel_variance8x4_sse2, 12),
- make_tuple(6, 6, &vpx_highbd_10_sub_pixel_variance64x64_sse2, 10),
- make_tuple(6, 5, &vpx_highbd_10_sub_pixel_variance64x32_sse2, 10),
- make_tuple(5, 6, &vpx_highbd_10_sub_pixel_variance32x64_sse2, 10),
- make_tuple(5, 5, &vpx_highbd_10_sub_pixel_variance32x32_sse2, 10),
- make_tuple(5, 4, &vpx_highbd_10_sub_pixel_variance32x16_sse2, 10),
- make_tuple(4, 5, &vpx_highbd_10_sub_pixel_variance16x32_sse2, 10),
- make_tuple(4, 4, &vpx_highbd_10_sub_pixel_variance16x16_sse2, 10),
- make_tuple(4, 3, &vpx_highbd_10_sub_pixel_variance16x8_sse2, 10),
- make_tuple(3, 4, &vpx_highbd_10_sub_pixel_variance8x16_sse2, 10),
- make_tuple(3, 3, &vpx_highbd_10_sub_pixel_variance8x8_sse2, 10),
- make_tuple(3, 2, &vpx_highbd_10_sub_pixel_variance8x4_sse2, 10),
- make_tuple(6, 6, &vpx_highbd_8_sub_pixel_variance64x64_sse2, 8),
- make_tuple(6, 5, &vpx_highbd_8_sub_pixel_variance64x32_sse2, 8),
- make_tuple(5, 6, &vpx_highbd_8_sub_pixel_variance32x64_sse2, 8),
- make_tuple(5, 5, &vpx_highbd_8_sub_pixel_variance32x32_sse2, 8),
- make_tuple(5, 4, &vpx_highbd_8_sub_pixel_variance32x16_sse2, 8),
- make_tuple(4, 5, &vpx_highbd_8_sub_pixel_variance16x32_sse2, 8),
- make_tuple(4, 4, &vpx_highbd_8_sub_pixel_variance16x16_sse2, 8),
- make_tuple(4, 3, &vpx_highbd_8_sub_pixel_variance16x8_sse2, 8),
- make_tuple(3, 4, &vpx_highbd_8_sub_pixel_variance8x16_sse2, 8),
- make_tuple(3, 3, &vpx_highbd_8_sub_pixel_variance8x8_sse2, 8),
- make_tuple(3, 2, &vpx_highbd_8_sub_pixel_variance8x4_sse2, 8)));
+ make_tuple(6, 6, &aom_highbd_12_sub_pixel_variance64x64_sse2, 12),
+ make_tuple(6, 5, &aom_highbd_12_sub_pixel_variance64x32_sse2, 12),
+ make_tuple(5, 6, &aom_highbd_12_sub_pixel_variance32x64_sse2, 12),
+ make_tuple(5, 5, &aom_highbd_12_sub_pixel_variance32x32_sse2, 12),
+ make_tuple(5, 4, &aom_highbd_12_sub_pixel_variance32x16_sse2, 12),
+ make_tuple(4, 5, &aom_highbd_12_sub_pixel_variance16x32_sse2, 12),
+ make_tuple(4, 4, &aom_highbd_12_sub_pixel_variance16x16_sse2, 12),
+ make_tuple(4, 3, &aom_highbd_12_sub_pixel_variance16x8_sse2, 12),
+ make_tuple(3, 4, &aom_highbd_12_sub_pixel_variance8x16_sse2, 12),
+ make_tuple(3, 3, &aom_highbd_12_sub_pixel_variance8x8_sse2, 12),
+ make_tuple(3, 2, &aom_highbd_12_sub_pixel_variance8x4_sse2, 12),
+ make_tuple(6, 6, &aom_highbd_10_sub_pixel_variance64x64_sse2, 10),
+ make_tuple(6, 5, &aom_highbd_10_sub_pixel_variance64x32_sse2, 10),
+ make_tuple(5, 6, &aom_highbd_10_sub_pixel_variance32x64_sse2, 10),
+ make_tuple(5, 5, &aom_highbd_10_sub_pixel_variance32x32_sse2, 10),
+ make_tuple(5, 4, &aom_highbd_10_sub_pixel_variance32x16_sse2, 10),
+ make_tuple(4, 5, &aom_highbd_10_sub_pixel_variance16x32_sse2, 10),
+ make_tuple(4, 4, &aom_highbd_10_sub_pixel_variance16x16_sse2, 10),
+ make_tuple(4, 3, &aom_highbd_10_sub_pixel_variance16x8_sse2, 10),
+ make_tuple(3, 4, &aom_highbd_10_sub_pixel_variance8x16_sse2, 10),
+ make_tuple(3, 3, &aom_highbd_10_sub_pixel_variance8x8_sse2, 10),
+ make_tuple(3, 2, &aom_highbd_10_sub_pixel_variance8x4_sse2, 10),
+ make_tuple(6, 6, &aom_highbd_8_sub_pixel_variance64x64_sse2, 8),
+ make_tuple(6, 5, &aom_highbd_8_sub_pixel_variance64x32_sse2, 8),
+ make_tuple(5, 6, &aom_highbd_8_sub_pixel_variance32x64_sse2, 8),
+ make_tuple(5, 5, &aom_highbd_8_sub_pixel_variance32x32_sse2, 8),
+ make_tuple(5, 4, &aom_highbd_8_sub_pixel_variance32x16_sse2, 8),
+ make_tuple(4, 5, &aom_highbd_8_sub_pixel_variance16x32_sse2, 8),
+ make_tuple(4, 4, &aom_highbd_8_sub_pixel_variance16x16_sse2, 8),
+ make_tuple(4, 3, &aom_highbd_8_sub_pixel_variance16x8_sse2, 8),
+ make_tuple(3, 4, &aom_highbd_8_sub_pixel_variance8x16_sse2, 8),
+ make_tuple(3, 3, &aom_highbd_8_sub_pixel_variance8x8_sse2, 8),
+ make_tuple(3, 2, &aom_highbd_8_sub_pixel_variance8x4_sse2, 8)));
INSTANTIATE_TEST_CASE_P(
- SSE2, VpxHBDSubpelAvgVarianceTest,
+ SSE2, AvxHBDSubpelAvgVarianceTest,
::testing::Values(
- make_tuple(6, 6, &vpx_highbd_12_sub_pixel_avg_variance64x64_sse2, 12),
- make_tuple(6, 5, &vpx_highbd_12_sub_pixel_avg_variance64x32_sse2, 12),
- make_tuple(5, 6, &vpx_highbd_12_sub_pixel_avg_variance32x64_sse2, 12),
- make_tuple(5, 5, &vpx_highbd_12_sub_pixel_avg_variance32x32_sse2, 12),
- make_tuple(5, 4, &vpx_highbd_12_sub_pixel_avg_variance32x16_sse2, 12),
- make_tuple(4, 5, &vpx_highbd_12_sub_pixel_avg_variance16x32_sse2, 12),
- make_tuple(4, 4, &vpx_highbd_12_sub_pixel_avg_variance16x16_sse2, 12),
- make_tuple(4, 3, &vpx_highbd_12_sub_pixel_avg_variance16x8_sse2, 12),
- make_tuple(3, 4, &vpx_highbd_12_sub_pixel_avg_variance8x16_sse2, 12),
- make_tuple(3, 3, &vpx_highbd_12_sub_pixel_avg_variance8x8_sse2, 12),
- make_tuple(3, 2, &vpx_highbd_12_sub_pixel_avg_variance8x4_sse2, 12),
- make_tuple(6, 6, &vpx_highbd_10_sub_pixel_avg_variance64x64_sse2, 10),
- make_tuple(6, 5, &vpx_highbd_10_sub_pixel_avg_variance64x32_sse2, 10),
- make_tuple(5, 6, &vpx_highbd_10_sub_pixel_avg_variance32x64_sse2, 10),
- make_tuple(5, 5, &vpx_highbd_10_sub_pixel_avg_variance32x32_sse2, 10),
- make_tuple(5, 4, &vpx_highbd_10_sub_pixel_avg_variance32x16_sse2, 10),
- make_tuple(4, 5, &vpx_highbd_10_sub_pixel_avg_variance16x32_sse2, 10),
- make_tuple(4, 4, &vpx_highbd_10_sub_pixel_avg_variance16x16_sse2, 10),
- make_tuple(4, 3, &vpx_highbd_10_sub_pixel_avg_variance16x8_sse2, 10),
- make_tuple(3, 4, &vpx_highbd_10_sub_pixel_avg_variance8x16_sse2, 10),
- make_tuple(3, 3, &vpx_highbd_10_sub_pixel_avg_variance8x8_sse2, 10),
- make_tuple(3, 2, &vpx_highbd_10_sub_pixel_avg_variance8x4_sse2, 10),
- make_tuple(6, 6, &vpx_highbd_8_sub_pixel_avg_variance64x64_sse2, 8),
- make_tuple(6, 5, &vpx_highbd_8_sub_pixel_avg_variance64x32_sse2, 8),
- make_tuple(5, 6, &vpx_highbd_8_sub_pixel_avg_variance32x64_sse2, 8),
- make_tuple(5, 5, &vpx_highbd_8_sub_pixel_avg_variance32x32_sse2, 8),
- make_tuple(5, 4, &vpx_highbd_8_sub_pixel_avg_variance32x16_sse2, 8),
- make_tuple(4, 5, &vpx_highbd_8_sub_pixel_avg_variance16x32_sse2, 8),
- make_tuple(4, 4, &vpx_highbd_8_sub_pixel_avg_variance16x16_sse2, 8),
- make_tuple(4, 3, &vpx_highbd_8_sub_pixel_avg_variance16x8_sse2, 8),
- make_tuple(3, 4, &vpx_highbd_8_sub_pixel_avg_variance8x16_sse2, 8),
- make_tuple(3, 3, &vpx_highbd_8_sub_pixel_avg_variance8x8_sse2, 8),
- make_tuple(3, 2, &vpx_highbd_8_sub_pixel_avg_variance8x4_sse2, 8)));
-#endif // CONFIG_VP9_HIGHBITDEPTH
+ make_tuple(6, 6, &aom_highbd_12_sub_pixel_avg_variance64x64_sse2, 12),
+ make_tuple(6, 5, &aom_highbd_12_sub_pixel_avg_variance64x32_sse2, 12),
+ make_tuple(5, 6, &aom_highbd_12_sub_pixel_avg_variance32x64_sse2, 12),
+ make_tuple(5, 5, &aom_highbd_12_sub_pixel_avg_variance32x32_sse2, 12),
+ make_tuple(5, 4, &aom_highbd_12_sub_pixel_avg_variance32x16_sse2, 12),
+ make_tuple(4, 5, &aom_highbd_12_sub_pixel_avg_variance16x32_sse2, 12),
+ make_tuple(4, 4, &aom_highbd_12_sub_pixel_avg_variance16x16_sse2, 12),
+ make_tuple(4, 3, &aom_highbd_12_sub_pixel_avg_variance16x8_sse2, 12),
+ make_tuple(3, 4, &aom_highbd_12_sub_pixel_avg_variance8x16_sse2, 12),
+ make_tuple(3, 3, &aom_highbd_12_sub_pixel_avg_variance8x8_sse2, 12),
+ make_tuple(3, 2, &aom_highbd_12_sub_pixel_avg_variance8x4_sse2, 12),
+ make_tuple(6, 6, &aom_highbd_10_sub_pixel_avg_variance64x64_sse2, 10),
+ make_tuple(6, 5, &aom_highbd_10_sub_pixel_avg_variance64x32_sse2, 10),
+ make_tuple(5, 6, &aom_highbd_10_sub_pixel_avg_variance32x64_sse2, 10),
+ make_tuple(5, 5, &aom_highbd_10_sub_pixel_avg_variance32x32_sse2, 10),
+ make_tuple(5, 4, &aom_highbd_10_sub_pixel_avg_variance32x16_sse2, 10),
+ make_tuple(4, 5, &aom_highbd_10_sub_pixel_avg_variance16x32_sse2, 10),
+ make_tuple(4, 4, &aom_highbd_10_sub_pixel_avg_variance16x16_sse2, 10),
+ make_tuple(4, 3, &aom_highbd_10_sub_pixel_avg_variance16x8_sse2, 10),
+ make_tuple(3, 4, &aom_highbd_10_sub_pixel_avg_variance8x16_sse2, 10),
+ make_tuple(3, 3, &aom_highbd_10_sub_pixel_avg_variance8x8_sse2, 10),
+ make_tuple(3, 2, &aom_highbd_10_sub_pixel_avg_variance8x4_sse2, 10),
+ make_tuple(6, 6, &aom_highbd_8_sub_pixel_avg_variance64x64_sse2, 8),
+ make_tuple(6, 5, &aom_highbd_8_sub_pixel_avg_variance64x32_sse2, 8),
+ make_tuple(5, 6, &aom_highbd_8_sub_pixel_avg_variance32x64_sse2, 8),
+ make_tuple(5, 5, &aom_highbd_8_sub_pixel_avg_variance32x32_sse2, 8),
+ make_tuple(5, 4, &aom_highbd_8_sub_pixel_avg_variance32x16_sse2, 8),
+ make_tuple(4, 5, &aom_highbd_8_sub_pixel_avg_variance16x32_sse2, 8),
+ make_tuple(4, 4, &aom_highbd_8_sub_pixel_avg_variance16x16_sse2, 8),
+ make_tuple(4, 3, &aom_highbd_8_sub_pixel_avg_variance16x8_sse2, 8),
+ make_tuple(3, 4, &aom_highbd_8_sub_pixel_avg_variance8x16_sse2, 8),
+ make_tuple(3, 3, &aom_highbd_8_sub_pixel_avg_variance8x8_sse2, 8),
+ make_tuple(3, 2, &aom_highbd_8_sub_pixel_avg_variance8x4_sse2, 8)));
+#endif // CONFIG_AOM_HIGHBITDEPTH
#endif // HAVE_SSE2
#if HAVE_SSSE3
INSTANTIATE_TEST_CASE_P(
- SSSE3, VpxSubpelVarianceTest,
- ::testing::Values(make_tuple(6, 6, &vpx_sub_pixel_variance64x64_ssse3, 0),
- make_tuple(6, 5, &vpx_sub_pixel_variance64x32_ssse3, 0),
- make_tuple(5, 6, &vpx_sub_pixel_variance32x64_ssse3, 0),
- make_tuple(5, 5, &vpx_sub_pixel_variance32x32_ssse3, 0),
- make_tuple(5, 4, &vpx_sub_pixel_variance32x16_ssse3, 0),
- make_tuple(4, 5, &vpx_sub_pixel_variance16x32_ssse3, 0),
- make_tuple(4, 4, &vpx_sub_pixel_variance16x16_ssse3, 0),
- make_tuple(4, 3, &vpx_sub_pixel_variance16x8_ssse3, 0),
- make_tuple(3, 4, &vpx_sub_pixel_variance8x16_ssse3, 0),
- make_tuple(3, 3, &vpx_sub_pixel_variance8x8_ssse3, 0),
- make_tuple(3, 2, &vpx_sub_pixel_variance8x4_ssse3, 0),
- make_tuple(2, 3, &vpx_sub_pixel_variance4x8_ssse3, 0),
- make_tuple(2, 2, &vpx_sub_pixel_variance4x4_ssse3, 0)));
+ SSSE3, AvxSubpelVarianceTest,
+ ::testing::Values(make_tuple(6, 6, &aom_sub_pixel_variance64x64_ssse3, 0),
+ make_tuple(6, 5, &aom_sub_pixel_variance64x32_ssse3, 0),
+ make_tuple(5, 6, &aom_sub_pixel_variance32x64_ssse3, 0),
+ make_tuple(5, 5, &aom_sub_pixel_variance32x32_ssse3, 0),
+ make_tuple(5, 4, &aom_sub_pixel_variance32x16_ssse3, 0),
+ make_tuple(4, 5, &aom_sub_pixel_variance16x32_ssse3, 0),
+ make_tuple(4, 4, &aom_sub_pixel_variance16x16_ssse3, 0),
+ make_tuple(4, 3, &aom_sub_pixel_variance16x8_ssse3, 0),
+ make_tuple(3, 4, &aom_sub_pixel_variance8x16_ssse3, 0),
+ make_tuple(3, 3, &aom_sub_pixel_variance8x8_ssse3, 0),
+ make_tuple(3, 2, &aom_sub_pixel_variance8x4_ssse3, 0),
+ make_tuple(2, 3, &aom_sub_pixel_variance4x8_ssse3, 0),
+ make_tuple(2, 2, &aom_sub_pixel_variance4x4_ssse3, 0)));
INSTANTIATE_TEST_CASE_P(
- SSSE3, VpxSubpelAvgVarianceTest,
+ SSSE3, AvxSubpelAvgVarianceTest,
::testing::Values(
- make_tuple(6, 6, &vpx_sub_pixel_avg_variance64x64_ssse3, 0),
- make_tuple(6, 5, &vpx_sub_pixel_avg_variance64x32_ssse3, 0),
- make_tuple(5, 6, &vpx_sub_pixel_avg_variance32x64_ssse3, 0),
- make_tuple(5, 5, &vpx_sub_pixel_avg_variance32x32_ssse3, 0),
- make_tuple(5, 4, &vpx_sub_pixel_avg_variance32x16_ssse3, 0),
- make_tuple(4, 5, &vpx_sub_pixel_avg_variance16x32_ssse3, 0),
- make_tuple(4, 4, &vpx_sub_pixel_avg_variance16x16_ssse3, 0),
- make_tuple(4, 3, &vpx_sub_pixel_avg_variance16x8_ssse3, 0),
- make_tuple(3, 4, &vpx_sub_pixel_avg_variance8x16_ssse3, 0),
- make_tuple(3, 3, &vpx_sub_pixel_avg_variance8x8_ssse3, 0),
- make_tuple(3, 2, &vpx_sub_pixel_avg_variance8x4_ssse3, 0),
- make_tuple(2, 3, &vpx_sub_pixel_avg_variance4x8_ssse3, 0),
- make_tuple(2, 2, &vpx_sub_pixel_avg_variance4x4_ssse3, 0)));
+ make_tuple(6, 6, &aom_sub_pixel_avg_variance64x64_ssse3, 0),
+ make_tuple(6, 5, &aom_sub_pixel_avg_variance64x32_ssse3, 0),
+ make_tuple(5, 6, &aom_sub_pixel_avg_variance32x64_ssse3, 0),
+ make_tuple(5, 5, &aom_sub_pixel_avg_variance32x32_ssse3, 0),
+ make_tuple(5, 4, &aom_sub_pixel_avg_variance32x16_ssse3, 0),
+ make_tuple(4, 5, &aom_sub_pixel_avg_variance16x32_ssse3, 0),
+ make_tuple(4, 4, &aom_sub_pixel_avg_variance16x16_ssse3, 0),
+ make_tuple(4, 3, &aom_sub_pixel_avg_variance16x8_ssse3, 0),
+ make_tuple(3, 4, &aom_sub_pixel_avg_variance8x16_ssse3, 0),
+ make_tuple(3, 3, &aom_sub_pixel_avg_variance8x8_ssse3, 0),
+ make_tuple(3, 2, &aom_sub_pixel_avg_variance8x4_ssse3, 0),
+ make_tuple(2, 3, &aom_sub_pixel_avg_variance4x8_ssse3, 0),
+ make_tuple(2, 2, &aom_sub_pixel_avg_variance4x4_ssse3, 0)));
#endif // HAVE_SSSE3
#if HAVE_AVX2
-INSTANTIATE_TEST_CASE_P(AVX2, VpxMseTest,
- ::testing::Values(MseParams(4, 4, &vpx_mse16x16_avx2)));
+INSTANTIATE_TEST_CASE_P(AVX2, AvxMseTest,
+ ::testing::Values(MseParams(4, 4, &aom_mse16x16_avx2)));
INSTANTIATE_TEST_CASE_P(
- AVX2, VpxVarianceTest,
- ::testing::Values(VarianceParams(6, 6, &vpx_variance64x64_avx2),
- VarianceParams(6, 5, &vpx_variance64x32_avx2),
- VarianceParams(5, 5, &vpx_variance32x32_avx2),
- VarianceParams(5, 4, &vpx_variance32x16_avx2),
- VarianceParams(4, 4, &vpx_variance16x16_avx2)));
+ AVX2, AvxVarianceTest,
+ ::testing::Values(VarianceParams(6, 6, &aom_variance64x64_avx2),
+ VarianceParams(6, 5, &aom_variance64x32_avx2),
+ VarianceParams(5, 5, &aom_variance32x32_avx2),
+ VarianceParams(5, 4, &aom_variance32x16_avx2),
+ VarianceParams(4, 4, &aom_variance16x16_avx2)));
INSTANTIATE_TEST_CASE_P(
- AVX2, VpxSubpelVarianceTest,
- ::testing::Values(make_tuple(6, 6, &vpx_sub_pixel_variance64x64_avx2, 0),
- make_tuple(5, 5, &vpx_sub_pixel_variance32x32_avx2, 0)));
+ AVX2, AvxSubpelVarianceTest,
+ ::testing::Values(make_tuple(6, 6, &aom_sub_pixel_variance64x64_avx2, 0),
+ make_tuple(5, 5, &aom_sub_pixel_variance32x32_avx2, 0)));
INSTANTIATE_TEST_CASE_P(
- AVX2, VpxSubpelAvgVarianceTest,
+ AVX2, AvxSubpelAvgVarianceTest,
::testing::Values(
- make_tuple(6, 6, &vpx_sub_pixel_avg_variance64x64_avx2, 0),
- make_tuple(5, 5, &vpx_sub_pixel_avg_variance32x32_avx2, 0)));
+ make_tuple(6, 6, &aom_sub_pixel_avg_variance64x64_avx2, 0),
+ make_tuple(5, 5, &aom_sub_pixel_avg_variance32x32_avx2, 0)));
#endif // HAVE_AVX2
#if HAVE_MEDIA
-INSTANTIATE_TEST_CASE_P(MEDIA, VpxMseTest,
+INSTANTIATE_TEST_CASE_P(MEDIA, AvxMseTest,
::testing::Values(MseParams(4, 4,
- &vpx_mse16x16_media)));
+ &aom_mse16x16_media)));
INSTANTIATE_TEST_CASE_P(
- MEDIA, VpxVarianceTest,
- ::testing::Values(VarianceParams(4, 4, &vpx_variance16x16_media),
- VarianceParams(3, 3, &vpx_variance8x8_media)));
+ MEDIA, AvxVarianceTest,
+ ::testing::Values(VarianceParams(4, 4, &aom_variance16x16_media),
+ VarianceParams(3, 3, &aom_variance8x8_media)));
INSTANTIATE_TEST_CASE_P(
- MEDIA, VpxSubpelVarianceTest,
- ::testing::Values(make_tuple(4, 4, &vpx_sub_pixel_variance16x16_media, 0),
- make_tuple(3, 3, &vpx_sub_pixel_variance8x8_media, 0)));
+ MEDIA, AvxSubpelVarianceTest,
+ ::testing::Values(make_tuple(4, 4, &aom_sub_pixel_variance16x16_media, 0),
+ make_tuple(3, 3, &aom_sub_pixel_variance8x8_media, 0)));
#endif // HAVE_MEDIA
#if HAVE_NEON
-INSTANTIATE_TEST_CASE_P(NEON, VpxSseTest,
+INSTANTIATE_TEST_CASE_P(NEON, AvxSseTest,
::testing::Values(SseParams(2, 2,
- &vpx_get4x4sse_cs_neon)));
+ &aom_get4x4sse_cs_neon)));
-INSTANTIATE_TEST_CASE_P(NEON, VpxMseTest,
- ::testing::Values(MseParams(4, 4, &vpx_mse16x16_neon)));
+INSTANTIATE_TEST_CASE_P(NEON, AvxMseTest,
+ ::testing::Values(MseParams(4, 4, &aom_mse16x16_neon)));
INSTANTIATE_TEST_CASE_P(
- NEON, VpxVarianceTest,
- ::testing::Values(VarianceParams(6, 6, &vpx_variance64x64_neon),
- VarianceParams(6, 5, &vpx_variance64x32_neon),
- VarianceParams(5, 6, &vpx_variance32x64_neon),
- VarianceParams(5, 5, &vpx_variance32x32_neon),
- VarianceParams(4, 4, &vpx_variance16x16_neon),
- VarianceParams(4, 3, &vpx_variance16x8_neon),
- VarianceParams(3, 4, &vpx_variance8x16_neon),
- VarianceParams(3, 3, &vpx_variance8x8_neon)));
+ NEON, AvxVarianceTest,
+ ::testing::Values(VarianceParams(6, 6, &aom_variance64x64_neon),
+ VarianceParams(6, 5, &aom_variance64x32_neon),
+ VarianceParams(5, 6, &aom_variance32x64_neon),
+ VarianceParams(5, 5, &aom_variance32x32_neon),
+ VarianceParams(4, 4, &aom_variance16x16_neon),
+ VarianceParams(4, 3, &aom_variance16x8_neon),
+ VarianceParams(3, 4, &aom_variance8x16_neon),
+ VarianceParams(3, 3, &aom_variance8x8_neon)));
INSTANTIATE_TEST_CASE_P(
- NEON, VpxSubpelVarianceTest,
- ::testing::Values(make_tuple(6, 6, &vpx_sub_pixel_variance64x64_neon, 0),
- make_tuple(5, 5, &vpx_sub_pixel_variance32x32_neon, 0),
- make_tuple(4, 4, &vpx_sub_pixel_variance16x16_neon, 0),
- make_tuple(3, 3, &vpx_sub_pixel_variance8x8_neon, 0)));
+ NEON, AvxSubpelVarianceTest,
+ ::testing::Values(make_tuple(6, 6, &aom_sub_pixel_variance64x64_neon, 0),
+ make_tuple(5, 5, &aom_sub_pixel_variance32x32_neon, 0),
+ make_tuple(4, 4, &aom_sub_pixel_variance16x16_neon, 0),
+ make_tuple(3, 3, &aom_sub_pixel_variance8x8_neon, 0)));
#endif // HAVE_NEON
#if HAVE_MSA
INSTANTIATE_TEST_CASE_P(MSA, SumOfSquaresTest,
- ::testing::Values(vpx_get_mb_ss_msa));
+ ::testing::Values(aom_get_mb_ss_msa));
-INSTANTIATE_TEST_CASE_P(MSA, VpxSseTest,
+INSTANTIATE_TEST_CASE_P(MSA, AvxSseTest,
::testing::Values(SseParams(2, 2,
- &vpx_get4x4sse_cs_msa)));
+ &aom_get4x4sse_cs_msa)));
-INSTANTIATE_TEST_CASE_P(MSA, VpxMseTest,
- ::testing::Values(MseParams(4, 4, &vpx_mse16x16_msa),
- MseParams(4, 3, &vpx_mse16x8_msa),
- MseParams(3, 4, &vpx_mse8x16_msa),
- MseParams(3, 3, &vpx_mse8x8_msa)));
+INSTANTIATE_TEST_CASE_P(MSA, AvxMseTest,
+ ::testing::Values(MseParams(4, 4, &aom_mse16x16_msa),
+ MseParams(4, 3, &aom_mse16x8_msa),
+ MseParams(3, 4, &aom_mse8x16_msa),
+ MseParams(3, 3, &aom_mse8x8_msa)));
INSTANTIATE_TEST_CASE_P(
- MSA, VpxVarianceTest,
- ::testing::Values(VarianceParams(6, 6, &vpx_variance64x64_msa),
- VarianceParams(6, 5, &vpx_variance64x32_msa),
- VarianceParams(5, 6, &vpx_variance32x64_msa),
- VarianceParams(5, 5, &vpx_variance32x32_msa),
- VarianceParams(5, 4, &vpx_variance32x16_msa),
- VarianceParams(4, 5, &vpx_variance16x32_msa),
- VarianceParams(4, 4, &vpx_variance16x16_msa),
- VarianceParams(4, 3, &vpx_variance16x8_msa),
- VarianceParams(3, 4, &vpx_variance8x16_msa),
- VarianceParams(3, 3, &vpx_variance8x8_msa),
- VarianceParams(3, 2, &vpx_variance8x4_msa),
- VarianceParams(2, 3, &vpx_variance4x8_msa),
- VarianceParams(2, 2, &vpx_variance4x4_msa)));
+ MSA, AvxVarianceTest,
+ ::testing::Values(VarianceParams(6, 6, &aom_variance64x64_msa),
+ VarianceParams(6, 5, &aom_variance64x32_msa),
+ VarianceParams(5, 6, &aom_variance32x64_msa),
+ VarianceParams(5, 5, &aom_variance32x32_msa),
+ VarianceParams(5, 4, &aom_variance32x16_msa),
+ VarianceParams(4, 5, &aom_variance16x32_msa),
+ VarianceParams(4, 4, &aom_variance16x16_msa),
+ VarianceParams(4, 3, &aom_variance16x8_msa),
+ VarianceParams(3, 4, &aom_variance8x16_msa),
+ VarianceParams(3, 3, &aom_variance8x8_msa),
+ VarianceParams(3, 2, &aom_variance8x4_msa),
+ VarianceParams(2, 3, &aom_variance4x8_msa),
+ VarianceParams(2, 2, &aom_variance4x4_msa)));
INSTANTIATE_TEST_CASE_P(
- MSA, VpxSubpelVarianceTest,
- ::testing::Values(make_tuple(2, 2, &vpx_sub_pixel_variance4x4_msa, 0),
- make_tuple(2, 3, &vpx_sub_pixel_variance4x8_msa, 0),
- make_tuple(3, 2, &vpx_sub_pixel_variance8x4_msa, 0),
- make_tuple(3, 3, &vpx_sub_pixel_variance8x8_msa, 0),
- make_tuple(3, 4, &vpx_sub_pixel_variance8x16_msa, 0),
- make_tuple(4, 3, &vpx_sub_pixel_variance16x8_msa, 0),
- make_tuple(4, 4, &vpx_sub_pixel_variance16x16_msa, 0),
- make_tuple(4, 5, &vpx_sub_pixel_variance16x32_msa, 0),
- make_tuple(5, 4, &vpx_sub_pixel_variance32x16_msa, 0),
- make_tuple(5, 5, &vpx_sub_pixel_variance32x32_msa, 0),
- make_tuple(5, 6, &vpx_sub_pixel_variance32x64_msa, 0),
- make_tuple(6, 5, &vpx_sub_pixel_variance64x32_msa, 0),
- make_tuple(6, 6, &vpx_sub_pixel_variance64x64_msa, 0)));
+ MSA, AvxSubpelVarianceTest,
+ ::testing::Values(make_tuple(2, 2, &aom_sub_pixel_variance4x4_msa, 0),
+ make_tuple(2, 3, &aom_sub_pixel_variance4x8_msa, 0),
+ make_tuple(3, 2, &aom_sub_pixel_variance8x4_msa, 0),
+ make_tuple(3, 3, &aom_sub_pixel_variance8x8_msa, 0),
+ make_tuple(3, 4, &aom_sub_pixel_variance8x16_msa, 0),
+ make_tuple(4, 3, &aom_sub_pixel_variance16x8_msa, 0),
+ make_tuple(4, 4, &aom_sub_pixel_variance16x16_msa, 0),
+ make_tuple(4, 5, &aom_sub_pixel_variance16x32_msa, 0),
+ make_tuple(5, 4, &aom_sub_pixel_variance32x16_msa, 0),
+ make_tuple(5, 5, &aom_sub_pixel_variance32x32_msa, 0),
+ make_tuple(5, 6, &aom_sub_pixel_variance32x64_msa, 0),
+ make_tuple(6, 5, &aom_sub_pixel_variance64x32_msa, 0),
+ make_tuple(6, 6, &aom_sub_pixel_variance64x64_msa, 0)));
INSTANTIATE_TEST_CASE_P(
- MSA, VpxSubpelAvgVarianceTest,
- ::testing::Values(make_tuple(6, 6, &vpx_sub_pixel_avg_variance64x64_msa, 0),
- make_tuple(6, 5, &vpx_sub_pixel_avg_variance64x32_msa, 0),
- make_tuple(5, 6, &vpx_sub_pixel_avg_variance32x64_msa, 0),
- make_tuple(5, 5, &vpx_sub_pixel_avg_variance32x32_msa, 0),
- make_tuple(5, 4, &vpx_sub_pixel_avg_variance32x16_msa, 0),
- make_tuple(4, 5, &vpx_sub_pixel_avg_variance16x32_msa, 0),
- make_tuple(4, 4, &vpx_sub_pixel_avg_variance16x16_msa, 0),
- make_tuple(4, 3, &vpx_sub_pixel_avg_variance16x8_msa, 0),
- make_tuple(3, 4, &vpx_sub_pixel_avg_variance8x16_msa, 0),
- make_tuple(3, 3, &vpx_sub_pixel_avg_variance8x8_msa, 0),
- make_tuple(3, 2, &vpx_sub_pixel_avg_variance8x4_msa, 0),
- make_tuple(2, 3, &vpx_sub_pixel_avg_variance4x8_msa, 0),
- make_tuple(2, 2, &vpx_sub_pixel_avg_variance4x4_msa, 0)));
+ MSA, AvxSubpelAvgVarianceTest,
+ ::testing::Values(make_tuple(6, 6, &aom_sub_pixel_avg_variance64x64_msa, 0),
+ make_tuple(6, 5, &aom_sub_pixel_avg_variance64x32_msa, 0),
+ make_tuple(5, 6, &aom_sub_pixel_avg_variance32x64_msa, 0),
+ make_tuple(5, 5, &aom_sub_pixel_avg_variance32x32_msa, 0),
+ make_tuple(5, 4, &aom_sub_pixel_avg_variance32x16_msa, 0),
+ make_tuple(4, 5, &aom_sub_pixel_avg_variance16x32_msa, 0),
+ make_tuple(4, 4, &aom_sub_pixel_avg_variance16x16_msa, 0),
+ make_tuple(4, 3, &aom_sub_pixel_avg_variance16x8_msa, 0),
+ make_tuple(3, 4, &aom_sub_pixel_avg_variance8x16_msa, 0),
+ make_tuple(3, 3, &aom_sub_pixel_avg_variance8x8_msa, 0),
+ make_tuple(3, 2, &aom_sub_pixel_avg_variance8x4_msa, 0),
+ make_tuple(2, 3, &aom_sub_pixel_avg_variance4x8_msa, 0),
+ make_tuple(2, 2, &aom_sub_pixel_avg_variance4x4_msa, 0)));
#endif // HAVE_MSA
} // namespace
diff --git a/test/video_source.h b/test/video_source.h
index 7fde59c..d46bde3 100644
--- a/test/video_source.h
+++ b/test/video_source.h
@@ -20,7 +20,7 @@
#include <cstdlib>
#include <string>
#include "test/acm_random.h"
-#include "aom/vpx_encoder.h"
+#include "aom/aom_encoder.h"
namespace libaom_test {
@@ -98,7 +98,7 @@
};
// Abstract base class for test video sources, which provide a stream of
-// vpx_image_t images with associated timestamps and duration.
+// aom_image_t images with associated timestamps and duration.
class VideoSource {
public:
virtual ~VideoSource() {}
@@ -110,16 +110,16 @@
virtual void Next() = 0;
// Get the current video frame, or NULL on End-Of-Stream.
- virtual vpx_image_t *img() const = 0;
+ virtual aom_image_t *img() const = 0;
// Get the presentation timestamp of the current frame.
- virtual vpx_codec_pts_t pts() const = 0;
+ virtual aom_codec_pts_t pts() const = 0;
// Get the current frame's duration
virtual unsigned long duration() const = 0;
// Get the timebase for the stream
- virtual vpx_rational_t timebase() const = 0;
+ virtual aom_rational_t timebase() const = 0;
// Get the current frame counter, starting at 0.
virtual unsigned int frame() const = 0;
@@ -132,11 +132,11 @@
public:
DummyVideoSource()
: img_(NULL), limit_(100), width_(80), height_(64),
- format_(VPX_IMG_FMT_I420) {
+ format_(AOM_IMG_FMT_I420) {
ReallocImage();
}
- virtual ~DummyVideoSource() { vpx_img_free(img_); }
+ virtual ~DummyVideoSource() { aom_img_free(img_); }
virtual void Begin() {
frame_ = 0;
@@ -148,15 +148,15 @@
FillFrame();
}
- virtual vpx_image_t *img() const { return (frame_ < limit_) ? img_ : NULL; }
+ virtual aom_image_t *img() const { return (frame_ < limit_) ? img_ : NULL; }
// Models a stream where Timebase = 1/FPS, so pts == frame.
- virtual vpx_codec_pts_t pts() const { return frame_; }
+ virtual aom_codec_pts_t pts() const { return frame_; }
virtual unsigned long duration() const { return 1; }
- virtual vpx_rational_t timebase() const {
- const vpx_rational_t t = { 1, 30 };
+ virtual aom_rational_t timebase() const {
+ const aom_rational_t t = { 1, 30 };
return t;
}
@@ -174,7 +174,7 @@
}
}
- void SetImageFormat(vpx_img_fmt_t format) {
+ void SetImageFormat(aom_img_fmt_t format) {
if (format_ != format) {
format_ = format;
ReallocImage();
@@ -187,18 +187,18 @@
}
void ReallocImage() {
- vpx_img_free(img_);
- img_ = vpx_img_alloc(NULL, format_, width_, height_, 32);
+ aom_img_free(img_);
+ img_ = aom_img_alloc(NULL, format_, width_, height_, 32);
raw_sz_ = ((img_->w + 31) & ~31) * img_->h * img_->bps / 8;
}
- vpx_image_t *img_;
+ aom_image_t *img_;
size_t raw_sz_;
unsigned int limit_;
unsigned int frame_;
unsigned int width_;
unsigned int height_;
- vpx_img_fmt_t format_;
+ aom_img_fmt_t format_;
};
class RandomVideoSource : public DummyVideoSource {
diff --git a/test/vp10_fht16x16_test.cc b/test/vp10_fht16x16_test.cc
deleted file mode 100644
index 40884f3..0000000
--- a/test/vp10_fht16x16_test.cc
+++ /dev/null
@@ -1,220 +0,0 @@
-/*
- * Copyright (c) 2016 The WebM project authors. All Rights Reserved.
- *
- * Use of this source code is governed by a BSD-style license
- * that can be found in the LICENSE file in the root of the source
- * tree. An additional intellectual property rights grant can be found
- * in the file PATENTS. All contributing project authors may
- * be found in the AUTHORS file in the root of the source tree.
- */
-
-#include "third_party/googletest/src/include/gtest/gtest.h"
-
-#include "./vp10_rtcd.h"
-#include "./vpx_dsp_rtcd.h"
-
-#include "test/acm_random.h"
-#include "test/clear_system_state.h"
-#include "test/register_state_check.h"
-#include "test/transform_test_base.h"
-#include "test/util.h"
-#include "aom_ports/mem.h"
-
-using libaom_test::ACMRandom;
-
-namespace {
-typedef void (*IhtFunc)(const tran_low_t *in, uint8_t *out, int stride,
- int tx_type);
-using std::tr1::tuple;
-using libaom_test::FhtFunc;
-typedef tuple<FhtFunc, IhtFunc, int, vpx_bit_depth_t, int> Ht16x16Param;
-
-void fht16x16_ref(const int16_t *in, tran_low_t *out, int stride, int tx_type) {
- vp10_fht16x16_c(in, out, stride, tx_type);
-}
-
-#if CONFIG_VP9_HIGHBITDEPTH
-typedef void (*IHbdHtFunc)(const tran_low_t *in, uint8_t *out, int stride,
- int tx_type, int bd);
-typedef void (*HbdHtFunc)(const int16_t *input, int32_t *output, int stride,
- int tx_type, int bd);
-
-// Target optimized function, tx_type, bit depth
-typedef tuple<HbdHtFunc, int, int> HighbdHt16x16Param;
-
-void highbd_fht16x16_ref(const int16_t *in, int32_t *out, int stride,
- int tx_type, int bd) {
- vp10_fwd_txfm2d_16x16_c(in, out, stride, tx_type, bd);
-}
-#endif // CONFIG_VP9_HIGHBITDEPTH
-
-class VP10Trans16x16HT : public libaom_test::TransformTestBase,
- public ::testing::TestWithParam<Ht16x16Param> {
- public:
- virtual ~VP10Trans16x16HT() {}
-
- virtual void SetUp() {
- fwd_txfm_ = GET_PARAM(0);
- inv_txfm_ = GET_PARAM(1);
- tx_type_ = GET_PARAM(2);
- pitch_ = 16;
- fwd_txfm_ref = fht16x16_ref;
- bit_depth_ = GET_PARAM(3);
- mask_ = (1 << bit_depth_) - 1;
- num_coeffs_ = GET_PARAM(4);
- }
- virtual void TearDown() { libaom_test::ClearSystemState(); }
-
- protected:
- void RunFwdTxfm(const int16_t *in, tran_low_t *out, int stride) {
- fwd_txfm_(in, out, stride, tx_type_);
- }
-
- void RunInvTxfm(const tran_low_t *out, uint8_t *dst, int stride) {
- inv_txfm_(out, dst, stride, tx_type_);
- }
-
- FhtFunc fwd_txfm_;
- IhtFunc inv_txfm_;
-};
-
-TEST_P(VP10Trans16x16HT, CoeffCheck) { RunCoeffCheck(); }
-
-#if CONFIG_VP9_HIGHBITDEPTH
-class VP10HighbdTrans16x16HT
- : public ::testing::TestWithParam<HighbdHt16x16Param> {
- public:
- virtual ~VP10HighbdTrans16x16HT() {}
-
- virtual void SetUp() {
- fwd_txfm_ = GET_PARAM(0);
- fwd_txfm_ref_ = highbd_fht16x16_ref;
- tx_type_ = GET_PARAM(1);
- bit_depth_ = GET_PARAM(2);
- mask_ = (1 << bit_depth_) - 1;
- num_coeffs_ = 256;
-
- input_ = reinterpret_cast<int16_t *>(
- vpx_memalign(16, sizeof(int16_t) * num_coeffs_));
- output_ = reinterpret_cast<int32_t *>(
- vpx_memalign(16, sizeof(int32_t) * num_coeffs_));
- output_ref_ = reinterpret_cast<int32_t *>(
- vpx_memalign(16, sizeof(int32_t) * num_coeffs_));
- }
-
- virtual void TearDown() {
- vpx_free(input_);
- vpx_free(output_);
- vpx_free(output_ref_);
- libaom_test::ClearSystemState();
- }
-
- protected:
- void RunBitexactCheck();
-
- private:
- HbdHtFunc fwd_txfm_;
- HbdHtFunc fwd_txfm_ref_;
- int tx_type_;
- int bit_depth_;
- int mask_;
- int num_coeffs_;
- int16_t *input_;
- int32_t *output_;
- int32_t *output_ref_;
-};
-
-void VP10HighbdTrans16x16HT::RunBitexactCheck() {
- ACMRandom rnd(ACMRandom::DeterministicSeed());
- int i, j;
- const int stride = 16;
- const int num_tests = 1000;
-
- for (i = 0; i < num_tests; ++i) {
- for (j = 0; j < num_coeffs_; ++j) {
- input_[j] = (rnd.Rand16() & mask_) - (rnd.Rand16() & mask_);
- }
-
- fwd_txfm_ref_(input_, output_ref_, stride, tx_type_, bit_depth_);
- ASM_REGISTER_STATE_CHECK(
- fwd_txfm_(input_, output_, stride, tx_type_, bit_depth_));
-
- for (j = 0; j < num_coeffs_; ++j) {
- EXPECT_EQ(output_ref_[j], output_[j])
- << "Not bit-exact result at index: " << j << " at test block: " << i;
- }
- }
-}
-
-TEST_P(VP10HighbdTrans16x16HT, HighbdCoeffCheck) { RunBitexactCheck(); }
-#endif // CONFIG_VP9_HIGHBITDEPTH
-
-using std::tr1::make_tuple;
-
-#if HAVE_SSE2
-const Ht16x16Param kArrayHt16x16Param_sse2[] = {
- make_tuple(&vp10_fht16x16_sse2, &vp10_iht16x16_256_add_sse2, 0, VPX_BITS_8,
- 256),
- make_tuple(&vp10_fht16x16_sse2, &vp10_iht16x16_256_add_sse2, 1, VPX_BITS_8,
- 256),
- make_tuple(&vp10_fht16x16_sse2, &vp10_iht16x16_256_add_sse2, 2, VPX_BITS_8,
- 256),
- make_tuple(&vp10_fht16x16_sse2, &vp10_iht16x16_256_add_sse2, 3, VPX_BITS_8,
- 256),
-#if CONFIG_EXT_TX
- make_tuple(&vp10_fht16x16_sse2, &vp10_iht16x16_256_add_sse2, 4, VPX_BITS_8,
- 256),
- make_tuple(&vp10_fht16x16_sse2, &vp10_iht16x16_256_add_sse2, 5, VPX_BITS_8,
- 256),
- make_tuple(&vp10_fht16x16_sse2, &vp10_iht16x16_256_add_sse2, 6, VPX_BITS_8,
- 256),
- make_tuple(&vp10_fht16x16_sse2, &vp10_iht16x16_256_add_sse2, 7, VPX_BITS_8,
- 256),
- make_tuple(&vp10_fht16x16_sse2, &vp10_iht16x16_256_add_sse2, 8, VPX_BITS_8,
- 256),
- make_tuple(&vp10_fht16x16_sse2, &vp10_iht16x16_256_add_sse2, 10, VPX_BITS_8,
- 256),
- make_tuple(&vp10_fht16x16_sse2, &vp10_iht16x16_256_add_sse2, 11, VPX_BITS_8,
- 256),
- make_tuple(&vp10_fht16x16_sse2, &vp10_iht16x16_256_add_sse2, 12, VPX_BITS_8,
- 256),
- make_tuple(&vp10_fht16x16_sse2, &vp10_iht16x16_256_add_sse2, 13, VPX_BITS_8,
- 256),
- make_tuple(&vp10_fht16x16_sse2, &vp10_iht16x16_256_add_sse2, 14, VPX_BITS_8,
- 256),
- make_tuple(&vp10_fht16x16_sse2, &vp10_iht16x16_256_add_sse2, 15, VPX_BITS_8,
- 256)
-#endif // CONFIG_EXT_TX
-};
-INSTANTIATE_TEST_CASE_P(SSE2, VP10Trans16x16HT,
- ::testing::ValuesIn(kArrayHt16x16Param_sse2));
-#endif // HAVE_SSE2
-
-#if HAVE_SSE4_1 && CONFIG_VP9_HIGHBITDEPTH
-const HighbdHt16x16Param kArrayHBDHt16x16Param_sse4_1[] = {
- make_tuple(&vp10_fwd_txfm2d_16x16_sse4_1, 0, 10),
- make_tuple(&vp10_fwd_txfm2d_16x16_sse4_1, 0, 12),
- make_tuple(&vp10_fwd_txfm2d_16x16_sse4_1, 1, 10),
- make_tuple(&vp10_fwd_txfm2d_16x16_sse4_1, 1, 12),
- make_tuple(&vp10_fwd_txfm2d_16x16_sse4_1, 2, 10),
- make_tuple(&vp10_fwd_txfm2d_16x16_sse4_1, 2, 12),
- make_tuple(&vp10_fwd_txfm2d_16x16_sse4_1, 3, 10),
- make_tuple(&vp10_fwd_txfm2d_16x16_sse4_1, 3, 12),
-#if CONFIG_EXT_TX
- make_tuple(&vp10_fwd_txfm2d_16x16_sse4_1, 4, 10),
- make_tuple(&vp10_fwd_txfm2d_16x16_sse4_1, 4, 12),
- make_tuple(&vp10_fwd_txfm2d_16x16_sse4_1, 5, 10),
- make_tuple(&vp10_fwd_txfm2d_16x16_sse4_1, 5, 12),
- make_tuple(&vp10_fwd_txfm2d_16x16_sse4_1, 6, 10),
- make_tuple(&vp10_fwd_txfm2d_16x16_sse4_1, 6, 12),
- make_tuple(&vp10_fwd_txfm2d_16x16_sse4_1, 7, 10),
- make_tuple(&vp10_fwd_txfm2d_16x16_sse4_1, 7, 12),
- make_tuple(&vp10_fwd_txfm2d_16x16_sse4_1, 8, 10),
- make_tuple(&vp10_fwd_txfm2d_16x16_sse4_1, 8, 12),
-#endif // CONFIG_EXT_TX
-};
-INSTANTIATE_TEST_CASE_P(SSE4_1, VP10HighbdTrans16x16HT,
- ::testing::ValuesIn(kArrayHBDHt16x16Param_sse4_1));
-#endif // HAVE_SSE4_1 && CONFIG_VP9_HIGHBITDEPTH
-
-} // namespace
diff --git a/test/vp10_fht4x4_test.cc b/test/vp10_fht4x4_test.cc
deleted file mode 100644
index 1f4aa1e..0000000
--- a/test/vp10_fht4x4_test.cc
+++ /dev/null
@@ -1,207 +0,0 @@
-/*
- * Copyright (c) 2016 The WebM project authors. All Rights Reserved.
- *
- * Use of this source code is governed by a BSD-style license
- * that can be found in the LICENSE file in the root of the source
- * tree. An additional intellectual property rights grant can be found
- * in the file PATENTS. All contributing project authors may
- * be found in the AUTHORS file in the root of the source tree.
- */
-
-#include "third_party/googletest/src/include/gtest/gtest.h"
-
-#include "./vp10_rtcd.h"
-#include "./vpx_dsp_rtcd.h"
-
-#include "test/acm_random.h"
-#include "test/clear_system_state.h"
-#include "test/register_state_check.h"
-#include "test/transform_test_base.h"
-#include "test/util.h"
-#include "aom_ports/mem.h"
-
-using libaom_test::ACMRandom;
-
-namespace {
-typedef void (*IhtFunc)(const tran_low_t *in, uint8_t *out, int stride,
- int tx_type);
-using std::tr1::tuple;
-using libaom_test::FhtFunc;
-typedef tuple<FhtFunc, IhtFunc, int, vpx_bit_depth_t, int> Ht4x4Param;
-
-void fht4x4_ref(const int16_t *in, tran_low_t *out, int stride, int tx_type) {
- vp10_fht4x4_c(in, out, stride, tx_type);
-}
-
-#if CONFIG_VP9_HIGHBITDEPTH
-typedef void (*IhighbdHtFunc)(const tran_low_t *in, uint8_t *out, int stride,
- int tx_type, int bd);
-typedef void (*HBDFhtFunc)(const int16_t *input, int32_t *output, int stride,
- int tx_type, int bd);
-
-// HighbdHt4x4Param argument list:
-// <Target optimized function, tx_type, bit depth>
-typedef tuple<HBDFhtFunc, int, int> HighbdHt4x4Param;
-
-void highbe_fht4x4_ref(const int16_t *in, int32_t *out, int stride, int tx_type,
- int bd) {
- vp10_fwd_txfm2d_4x4_c(in, out, stride, tx_type, bd);
-}
-#endif // CONFIG_VP9_HIGHBITDEPTH
-
-class VP10Trans4x4HT : public libaom_test::TransformTestBase,
- public ::testing::TestWithParam<Ht4x4Param> {
- public:
- virtual ~VP10Trans4x4HT() {}
-
- virtual void SetUp() {
- fwd_txfm_ = GET_PARAM(0);
- inv_txfm_ = GET_PARAM(1);
- tx_type_ = GET_PARAM(2);
- pitch_ = 4;
- fwd_txfm_ref = fht4x4_ref;
- bit_depth_ = GET_PARAM(3);
- mask_ = (1 << bit_depth_) - 1;
- num_coeffs_ = GET_PARAM(4);
- }
- virtual void TearDown() { libaom_test::ClearSystemState(); }
-
- protected:
- void RunFwdTxfm(const int16_t *in, tran_low_t *out, int stride) {
- fwd_txfm_(in, out, stride, tx_type_);
- }
-
- void RunInvTxfm(const tran_low_t *out, uint8_t *dst, int stride) {
- inv_txfm_(out, dst, stride, tx_type_);
- }
-
- FhtFunc fwd_txfm_;
- IhtFunc inv_txfm_;
-};
-
-TEST_P(VP10Trans4x4HT, CoeffCheck) { RunCoeffCheck(); }
-
-#if CONFIG_VP9_HIGHBITDEPTH
-class VP10HighbdTrans4x4HT : public ::testing::TestWithParam<HighbdHt4x4Param> {
- public:
- virtual ~VP10HighbdTrans4x4HT() {}
-
- virtual void SetUp() {
- fwd_txfm_ = GET_PARAM(0);
- fwd_txfm_ref_ = highbe_fht4x4_ref;
- tx_type_ = GET_PARAM(1);
- bit_depth_ = GET_PARAM(2);
- mask_ = (1 << bit_depth_) - 1;
- num_coeffs_ = 16;
-
- input_ = reinterpret_cast<int16_t *>(
- vpx_memalign(16, sizeof(int16_t) * num_coeffs_));
- output_ = reinterpret_cast<int32_t *>(
- vpx_memalign(16, sizeof(int32_t) * num_coeffs_));
- output_ref_ = reinterpret_cast<int32_t *>(
- vpx_memalign(16, sizeof(int32_t) * num_coeffs_));
- }
-
- virtual void TearDown() {
- vpx_free(input_);
- vpx_free(output_);
- vpx_free(output_ref_);
- libaom_test::ClearSystemState();
- }
-
- protected:
- void RunBitexactCheck();
-
- private:
- HBDFhtFunc fwd_txfm_;
- HBDFhtFunc fwd_txfm_ref_;
- int tx_type_;
- int bit_depth_;
- int mask_;
- int num_coeffs_;
- int16_t *input_;
- int32_t *output_;
- int32_t *output_ref_;
-};
-
-void VP10HighbdTrans4x4HT::RunBitexactCheck() {
- ACMRandom rnd(ACMRandom::DeterministicSeed());
- int i, j;
- const int stride = 4;
- const int num_tests = 1000;
- const int num_coeffs = 16;
-
- for (i = 0; i < num_tests; ++i) {
- for (j = 0; j < num_coeffs; ++j) {
- input_[j] = (rnd.Rand16() & mask_) - (rnd.Rand16() & mask_);
- }
-
- fwd_txfm_ref_(input_, output_ref_, stride, tx_type_, bit_depth_);
- fwd_txfm_(input_, output_, stride, tx_type_, bit_depth_);
-
- for (j = 0; j < num_coeffs; ++j) {
- EXPECT_EQ(output_[j], output_ref_[j])
- << "Not bit-exact result at index: " << j << " at test block: " << i;
- }
- }
-}
-
-TEST_P(VP10HighbdTrans4x4HT, HighbdCoeffCheck) { RunBitexactCheck(); }
-#endif // CONFIG_VP9_HIGHBITDEPTH
-
-using std::tr1::make_tuple;
-
-#if HAVE_SSE2
-const Ht4x4Param kArrayHt4x4Param_sse2[] = {
- make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_sse2, 0, VPX_BITS_8, 16),
- make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_sse2, 1, VPX_BITS_8, 16),
- make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_sse2, 2, VPX_BITS_8, 16),
- make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_sse2, 3, VPX_BITS_8, 16),
-#if CONFIG_EXT_TX
- make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_sse2, 4, VPX_BITS_8, 16),
- make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_sse2, 5, VPX_BITS_8, 16),
- make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_sse2, 6, VPX_BITS_8, 16),
- make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_sse2, 7, VPX_BITS_8, 16),
- make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_sse2, 8, VPX_BITS_8, 16),
- make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_sse2, 10, VPX_BITS_8, 16),
- make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_sse2, 11, VPX_BITS_8, 16),
- make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_sse2, 12, VPX_BITS_8, 16),
- make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_sse2, 13, VPX_BITS_8, 16),
- make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_sse2, 14, VPX_BITS_8, 16),
- make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_sse2, 15, VPX_BITS_8, 16)
-#endif // CONFIG_EXT_TX
-};
-INSTANTIATE_TEST_CASE_P(SSE2, VP10Trans4x4HT,
- ::testing::ValuesIn(kArrayHt4x4Param_sse2));
-#endif // HAVE_SSE2
-
-#if HAVE_SSE4_1 && CONFIG_VP9_HIGHBITDEPTH
-const HighbdHt4x4Param kArrayHighbdHt4x4Param[] = {
- make_tuple(&vp10_fwd_txfm2d_4x4_sse4_1, 0, 10),
- make_tuple(&vp10_fwd_txfm2d_4x4_sse4_1, 0, 12),
- make_tuple(&vp10_fwd_txfm2d_4x4_sse4_1, 1, 10),
- make_tuple(&vp10_fwd_txfm2d_4x4_sse4_1, 1, 12),
- make_tuple(&vp10_fwd_txfm2d_4x4_sse4_1, 2, 10),
- make_tuple(&vp10_fwd_txfm2d_4x4_sse4_1, 2, 12),
- make_tuple(&vp10_fwd_txfm2d_4x4_sse4_1, 3, 10),
- make_tuple(&vp10_fwd_txfm2d_4x4_sse4_1, 3, 12),
-#if CONFIG_EXT_TX
- make_tuple(&vp10_fwd_txfm2d_4x4_sse4_1, 4, 10),
- make_tuple(&vp10_fwd_txfm2d_4x4_sse4_1, 4, 12),
- make_tuple(&vp10_fwd_txfm2d_4x4_sse4_1, 5, 10),
- make_tuple(&vp10_fwd_txfm2d_4x4_sse4_1, 5, 12),
- make_tuple(&vp10_fwd_txfm2d_4x4_sse4_1, 6, 10),
- make_tuple(&vp10_fwd_txfm2d_4x4_sse4_1, 6, 12),
- make_tuple(&vp10_fwd_txfm2d_4x4_sse4_1, 7, 10),
- make_tuple(&vp10_fwd_txfm2d_4x4_sse4_1, 7, 12),
- make_tuple(&vp10_fwd_txfm2d_4x4_sse4_1, 8, 10),
- make_tuple(&vp10_fwd_txfm2d_4x4_sse4_1, 8, 12),
-#endif // CONFIG_EXT_TX
-};
-
-INSTANTIATE_TEST_CASE_P(SSE4_1, VP10HighbdTrans4x4HT,
- ::testing::ValuesIn(kArrayHighbdHt4x4Param));
-
-#endif // HAVE_SSE4_1 && CONFIG_VP9_HIGHBITDEPTH
-
-} // namespace
diff --git a/test/vp10_fht8x8_test.cc b/test/vp10_fht8x8_test.cc
deleted file mode 100644
index 3990bd5..0000000
--- a/test/vp10_fht8x8_test.cc
+++ /dev/null
@@ -1,205 +0,0 @@
-/*
- * Copyright (c) 2016 The WebM project authors. All Rights Reserved.
- *
- * Use of this source code is governed by a BSD-style license
- * that can be found in the LICENSE file in the root of the source
- * tree. An additional intellectual property rights grant can be found
- * in the file PATENTS. All contributing project authors may
- * be found in the AUTHORS file in the root of the source tree.
- */
-
-#include "third_party/googletest/src/include/gtest/gtest.h"
-
-#include "./vp10_rtcd.h"
-#include "./vpx_dsp_rtcd.h"
-
-#include "test/acm_random.h"
-#include "test/clear_system_state.h"
-#include "test/register_state_check.h"
-#include "test/transform_test_base.h"
-#include "test/util.h"
-#include "aom_ports/mem.h"
-
-using libaom_test::ACMRandom;
-
-namespace {
-typedef void (*IhtFunc)(const tran_low_t *in, uint8_t *out, int stride,
- int tx_type);
-
-using libaom_test::FhtFunc;
-using std::tr1::tuple;
-typedef tuple<FhtFunc, IhtFunc, int, vpx_bit_depth_t, int> Ht8x8Param;
-
-void fht8x8_ref(const int16_t *in, tran_low_t *out, int stride, int tx_type) {
- vp10_fht8x8_c(in, out, stride, tx_type);
-}
-
-#if CONFIG_VP9_HIGHBITDEPTH
-typedef void (*IHbdHtFunc)(const tran_low_t *in, uint8_t *out, int stride,
- int tx_type, int bd);
-typedef void (*HbdHtFunc)(const int16_t *input, int32_t *output, int stride,
- int tx_type, int bd);
-// Target optimized function, tx_type, bit depth
-typedef tuple<HbdHtFunc, int, int> HighbdHt8x8Param;
-
-void highbd_fht8x8_ref(const int16_t *in, int32_t *out, int stride, int tx_type,
- int bd) {
- vp10_fwd_txfm2d_8x8_c(in, out, stride, tx_type, bd);
-}
-#endif // CONFIG_VP9_HIGHBITDEPTH
-
-class VP10Trans8x8HT : public libaom_test::TransformTestBase,
- public ::testing::TestWithParam<Ht8x8Param> {
- public:
- virtual ~VP10Trans8x8HT() {}
-
- virtual void SetUp() {
- fwd_txfm_ = GET_PARAM(0);
- inv_txfm_ = GET_PARAM(1);
- tx_type_ = GET_PARAM(2);
- pitch_ = 8;
- fwd_txfm_ref = fht8x8_ref;
- bit_depth_ = GET_PARAM(3);
- mask_ = (1 << bit_depth_) - 1;
- num_coeffs_ = GET_PARAM(4);
- }
- virtual void TearDown() { libaom_test::ClearSystemState(); }
-
- protected:
- void RunFwdTxfm(const int16_t *in, tran_low_t *out, int stride) {
- fwd_txfm_(in, out, stride, tx_type_);
- }
-
- void RunInvTxfm(const tran_low_t *out, uint8_t *dst, int stride) {
- inv_txfm_(out, dst, stride, tx_type_);
- }
-
- FhtFunc fwd_txfm_;
- IhtFunc inv_txfm_;
-};
-
-TEST_P(VP10Trans8x8HT, CoeffCheck) { RunCoeffCheck(); }
-
-#if CONFIG_VP9_HIGHBITDEPTH
-class VP10HighbdTrans8x8HT : public ::testing::TestWithParam<HighbdHt8x8Param> {
- public:
- virtual ~VP10HighbdTrans8x8HT() {}
-
- virtual void SetUp() {
- fwd_txfm_ = GET_PARAM(0);
- fwd_txfm_ref_ = highbd_fht8x8_ref;
- tx_type_ = GET_PARAM(1);
- bit_depth_ = GET_PARAM(2);
- mask_ = (1 << bit_depth_) - 1;
- num_coeffs_ = 64;
-
- input_ = reinterpret_cast<int16_t *>(
- vpx_memalign(16, sizeof(int16_t) * num_coeffs_));
- output_ = reinterpret_cast<int32_t *>(
- vpx_memalign(16, sizeof(int32_t) * num_coeffs_));
- output_ref_ = reinterpret_cast<int32_t *>(
- vpx_memalign(16, sizeof(int32_t) * num_coeffs_));
- }
-
- virtual void TearDown() {
- vpx_free(input_);
- vpx_free(output_);
- vpx_free(output_ref_);
- libaom_test::ClearSystemState();
- }
-
- protected:
- void RunBitexactCheck();
-
- private:
- HbdHtFunc fwd_txfm_;
- HbdHtFunc fwd_txfm_ref_;
- int tx_type_;
- int bit_depth_;
- int mask_;
- int num_coeffs_;
- int16_t *input_;
- int32_t *output_;
- int32_t *output_ref_;
-};
-
-void VP10HighbdTrans8x8HT::RunBitexactCheck() {
- ACMRandom rnd(ACMRandom::DeterministicSeed());
- int i, j;
- const int stride = 8;
- const int num_tests = 1000;
- const int num_coeffs = 64;
-
- for (i = 0; i < num_tests; ++i) {
- for (j = 0; j < num_coeffs; ++j) {
- input_[j] = (rnd.Rand16() & mask_) - (rnd.Rand16() & mask_);
- }
-
- fwd_txfm_ref_(input_, output_ref_, stride, tx_type_, bit_depth_);
- ASM_REGISTER_STATE_CHECK(
- fwd_txfm_(input_, output_, stride, tx_type_, bit_depth_));
-
- for (j = 0; j < num_coeffs; ++j) {
- EXPECT_EQ(output_ref_[j], output_[j])
- << "Not bit-exact result at index: " << j << " at test block: " << i;
- }
- }
-}
-
-TEST_P(VP10HighbdTrans8x8HT, HighbdCoeffCheck) { RunBitexactCheck(); }
-#endif // CONFIG_VP9_HIGHBITDEPTH
-
-using std::tr1::make_tuple;
-
-#if HAVE_SSE2
-const Ht8x8Param kArrayHt8x8Param_sse2[] = {
- make_tuple(&vp10_fht8x8_sse2, &vp10_iht8x8_64_add_sse2, 0, VPX_BITS_8, 64),
- make_tuple(&vp10_fht8x8_sse2, &vp10_iht8x8_64_add_sse2, 1, VPX_BITS_8, 64),
- make_tuple(&vp10_fht8x8_sse2, &vp10_iht8x8_64_add_sse2, 2, VPX_BITS_8, 64),
- make_tuple(&vp10_fht8x8_sse2, &vp10_iht8x8_64_add_sse2, 3, VPX_BITS_8, 64),
-#if CONFIG_EXT_TX
- make_tuple(&vp10_fht8x8_sse2, &vp10_iht8x8_64_add_sse2, 4, VPX_BITS_8, 64),
- make_tuple(&vp10_fht8x8_sse2, &vp10_iht8x8_64_add_sse2, 5, VPX_BITS_8, 64),
- make_tuple(&vp10_fht8x8_sse2, &vp10_iht8x8_64_add_sse2, 6, VPX_BITS_8, 64),
- make_tuple(&vp10_fht8x8_sse2, &vp10_iht8x8_64_add_sse2, 7, VPX_BITS_8, 64),
- make_tuple(&vp10_fht8x8_sse2, &vp10_iht8x8_64_add_sse2, 8, VPX_BITS_8, 64),
- make_tuple(&vp10_fht8x8_sse2, &vp10_iht8x8_64_add_sse2, 10, VPX_BITS_8, 64),
- make_tuple(&vp10_fht8x8_sse2, &vp10_iht8x8_64_add_sse2, 11, VPX_BITS_8, 64),
- make_tuple(&vp10_fht8x8_sse2, &vp10_iht8x8_64_add_sse2, 12, VPX_BITS_8, 64),
- make_tuple(&vp10_fht8x8_sse2, &vp10_iht8x8_64_add_sse2, 13, VPX_BITS_8, 64),
- make_tuple(&vp10_fht8x8_sse2, &vp10_iht8x8_64_add_sse2, 14, VPX_BITS_8, 64),
- make_tuple(&vp10_fht8x8_sse2, &vp10_iht8x8_64_add_sse2, 15, VPX_BITS_8, 64)
-#endif // CONFIG_EXT_TX
-};
-INSTANTIATE_TEST_CASE_P(SSE2, VP10Trans8x8HT,
- ::testing::ValuesIn(kArrayHt8x8Param_sse2));
-#endif // HAVE_SSE2
-
-#if HAVE_SSE4_1 && CONFIG_VP9_HIGHBITDEPTH
-const HighbdHt8x8Param kArrayHBDHt8x8Param_sse4_1[] = {
- make_tuple(&vp10_fwd_txfm2d_8x8_sse4_1, 0, 10),
- make_tuple(&vp10_fwd_txfm2d_8x8_sse4_1, 0, 12),
- make_tuple(&vp10_fwd_txfm2d_8x8_sse4_1, 1, 10),
- make_tuple(&vp10_fwd_txfm2d_8x8_sse4_1, 1, 12),
- make_tuple(&vp10_fwd_txfm2d_8x8_sse4_1, 2, 10),
- make_tuple(&vp10_fwd_txfm2d_8x8_sse4_1, 2, 12),
- make_tuple(&vp10_fwd_txfm2d_8x8_sse4_1, 3, 10),
- make_tuple(&vp10_fwd_txfm2d_8x8_sse4_1, 3, 12),
-#if CONFIG_EXT_TX
- make_tuple(&vp10_fwd_txfm2d_8x8_sse4_1, 4, 10),
- make_tuple(&vp10_fwd_txfm2d_8x8_sse4_1, 4, 12),
- make_tuple(&vp10_fwd_txfm2d_8x8_sse4_1, 5, 10),
- make_tuple(&vp10_fwd_txfm2d_8x8_sse4_1, 5, 12),
- make_tuple(&vp10_fwd_txfm2d_8x8_sse4_1, 6, 10),
- make_tuple(&vp10_fwd_txfm2d_8x8_sse4_1, 6, 12),
- make_tuple(&vp10_fwd_txfm2d_8x8_sse4_1, 7, 10),
- make_tuple(&vp10_fwd_txfm2d_8x8_sse4_1, 7, 12),
- make_tuple(&vp10_fwd_txfm2d_8x8_sse4_1, 8, 10),
- make_tuple(&vp10_fwd_txfm2d_8x8_sse4_1, 8, 12),
-#endif // CONFIG_EXT_TX
-};
-INSTANTIATE_TEST_CASE_P(SSE4_1, VP10HighbdTrans8x8HT,
- ::testing::ValuesIn(kArrayHBDHt8x8Param_sse4_1));
-#endif // HAVE_SSE4_1 && CONFIG_VP9_HIGHBITDEPTH
-
-} // namespace
diff --git a/test/vp10_fwd_txfm2d_test.cc b/test/vp10_fwd_txfm2d_test.cc
deleted file mode 100644
index 7dbb922..0000000
--- a/test/vp10_fwd_txfm2d_test.cc
+++ /dev/null
@@ -1,178 +0,0 @@
-/*
- * Copyright (c) 2015 The WebM project authors. All Rights Reserved.
- *
- * Use of this source code is governed by a BSD-style license
- * that can be found in the LICENSE file in the root of the source
- * tree. An additional intellectual property rights grant can be found
- * in the file PATENTS. All contributing project authors may
- * be found in the AUTHORS file in the root of the source tree.
- */
-
-#include <math.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include "test/acm_random.h"
-#include "test/util.h"
-#include "test/vp10_txfm_test.h"
-#include "av1/common/vp10_txfm.h"
-#include "./vp10_rtcd.h"
-
-using libaom_test::ACMRandom;
-using libaom_test::input_base;
-using libaom_test::bd;
-using libaom_test::compute_avg_abs_error;
-using libaom_test::Fwd_Txfm2d_Func;
-using libaom_test::TYPE_TXFM;
-
-namespace {
-#if CONFIG_VP9_HIGHBITDEPTH
-// tx_type_, tx_size_, max_error_, max_avg_error_
-typedef std::tr1::tuple<TX_TYPE, TX_SIZE, double, double> VP10FwdTxfm2dParam;
-
-class VP10FwdTxfm2d : public ::testing::TestWithParam<VP10FwdTxfm2dParam> {
- public:
- virtual void SetUp() {
- tx_type_ = GET_PARAM(0);
- tx_size_ = GET_PARAM(1);
- max_error_ = GET_PARAM(2);
- max_avg_error_ = GET_PARAM(3);
- count_ = 500;
- TXFM_2D_FLIP_CFG fwd_txfm_flip_cfg =
- vp10_get_fwd_txfm_cfg(tx_type_, tx_size_);
- const TXFM_2D_CFG *fwd_txfm_cfg = fwd_txfm_flip_cfg.cfg;
- int amplify_bit = fwd_txfm_cfg->shift[0] + fwd_txfm_cfg->shift[1] +
- fwd_txfm_cfg->shift[2];
- ud_flip_ = fwd_txfm_flip_cfg.ud_flip;
- lr_flip_ = fwd_txfm_flip_cfg.lr_flip;
- amplify_factor_ =
- amplify_bit >= 0 ? (1 << amplify_bit) : (1.0 / (1 << -amplify_bit));
-
- fwd_txfm_ = libaom_test::fwd_txfm_func_ls[tx_size_];
- txfm1d_size_ = libaom_test::get_txfm1d_size(tx_size_);
- txfm2d_size_ = txfm1d_size_ * txfm1d_size_;
- get_txfm1d_type(tx_type_, &type0_, &type1_);
- input_ = reinterpret_cast<int16_t *>(
- vpx_memalign(16, sizeof(input_[0]) * txfm2d_size_));
- output_ = reinterpret_cast<int32_t *>(
- vpx_memalign(16, sizeof(output_[0]) * txfm2d_size_));
- ref_input_ = reinterpret_cast<double *>(
- vpx_memalign(16, sizeof(ref_input_[0]) * txfm2d_size_));
- ref_output_ = reinterpret_cast<double *>(
- vpx_memalign(16, sizeof(ref_output_[0]) * txfm2d_size_));
- }
-
- void RunFwdAccuracyCheck() {
- ACMRandom rnd(ACMRandom::DeterministicSeed());
- double avg_abs_error = 0;
- for (int ci = 0; ci < count_; ci++) {
- for (int ni = 0; ni < txfm2d_size_; ++ni) {
- input_[ni] = rnd.Rand16() % input_base;
- ref_input_[ni] = static_cast<double>(input_[ni]);
- output_[ni] = 0;
- ref_output_[ni] = 0;
- }
-
- fwd_txfm_(input_, output_, txfm1d_size_, tx_type_, bd);
-
- if (lr_flip_ && ud_flip_)
- libaom_test::fliplrud(ref_input_, txfm1d_size_, txfm1d_size_);
- else if (lr_flip_)
- libaom_test::fliplr(ref_input_, txfm1d_size_, txfm1d_size_);
- else if (ud_flip_)
- libaom_test::flipud(ref_input_, txfm1d_size_, txfm1d_size_);
-
- reference_hybrid_2d(ref_input_, ref_output_, txfm1d_size_, type0_,
- type1_);
-
- for (int ni = 0; ni < txfm2d_size_; ++ni) {
- ref_output_[ni] = round(ref_output_[ni] * amplify_factor_);
- EXPECT_GE(max_error_,
- fabs(output_[ni] - ref_output_[ni]) / amplify_factor_);
- }
- avg_abs_error += compute_avg_abs_error<int32_t, double>(
- output_, ref_output_, txfm2d_size_);
- }
-
- avg_abs_error /= amplify_factor_;
- avg_abs_error /= count_;
- // max_abs_avg_error comes from upper bound of avg_abs_error
- // printf("type0: %d type1: %d txfm_size: %d accuracy_avg_abs_error:
- // %f\n", type0_, type1_, txfm1d_size_, avg_abs_error);
- EXPECT_GE(max_avg_error_, avg_abs_error);
- }
-
- virtual void TearDown() {
- vpx_free(input_);
- vpx_free(output_);
- vpx_free(ref_input_);
- vpx_free(ref_output_);
- }
-
- private:
- double max_error_;
- double max_avg_error_;
- int count_;
- double amplify_factor_;
- TX_TYPE tx_type_;
- TX_SIZE tx_size_;
- int txfm1d_size_;
- int txfm2d_size_;
- Fwd_Txfm2d_Func fwd_txfm_;
- TYPE_TXFM type0_;
- TYPE_TXFM type1_;
- int16_t *input_;
- int32_t *output_;
- double *ref_input_;
- double *ref_output_;
- int ud_flip_; // flip upside down
- int lr_flip_; // flip left to right
-};
-
-TEST_P(VP10FwdTxfm2d, RunFwdAccuracyCheck) { RunFwdAccuracyCheck(); }
-const VP10FwdTxfm2dParam vp10_fwd_txfm2d_param_c[] = {
-#if CONFIG_EXT_TX
- VP10FwdTxfm2dParam(FLIPADST_DCT, TX_4X4, 2, 0.2),
- VP10FwdTxfm2dParam(DCT_FLIPADST, TX_4X4, 2, 0.2),
- VP10FwdTxfm2dParam(FLIPADST_FLIPADST, TX_4X4, 2, 0.2),
- VP10FwdTxfm2dParam(ADST_FLIPADST, TX_4X4, 2, 0.2),
- VP10FwdTxfm2dParam(FLIPADST_ADST, TX_4X4, 2, 0.2),
- VP10FwdTxfm2dParam(FLIPADST_DCT, TX_8X8, 5, 0.6),
- VP10FwdTxfm2dParam(DCT_FLIPADST, TX_8X8, 5, 0.6),
- VP10FwdTxfm2dParam(FLIPADST_FLIPADST, TX_8X8, 5, 0.6),
- VP10FwdTxfm2dParam(ADST_FLIPADST, TX_8X8, 5, 0.6),
- VP10FwdTxfm2dParam(FLIPADST_ADST, TX_8X8, 5, 0.6),
- VP10FwdTxfm2dParam(FLIPADST_DCT, TX_16X16, 11, 1.5),
- VP10FwdTxfm2dParam(DCT_FLIPADST, TX_16X16, 11, 1.5),
- VP10FwdTxfm2dParam(FLIPADST_FLIPADST, TX_16X16, 11, 1.5),
- VP10FwdTxfm2dParam(ADST_FLIPADST, TX_16X16, 11, 1.5),
- VP10FwdTxfm2dParam(FLIPADST_ADST, TX_16X16, 11, 1.5),
- VP10FwdTxfm2dParam(FLIPADST_DCT, TX_32X32, 70, 7),
- VP10FwdTxfm2dParam(DCT_FLIPADST, TX_32X32, 70, 7),
- VP10FwdTxfm2dParam(FLIPADST_FLIPADST, TX_32X32, 70, 7),
- VP10FwdTxfm2dParam(ADST_FLIPADST, TX_32X32, 70, 7),
- VP10FwdTxfm2dParam(FLIPADST_ADST, TX_32X32, 70, 7),
-#endif
- VP10FwdTxfm2dParam(DCT_DCT, TX_4X4, 2, 0.2),
- VP10FwdTxfm2dParam(ADST_DCT, TX_4X4, 2, 0.2),
- VP10FwdTxfm2dParam(DCT_ADST, TX_4X4, 2, 0.2),
- VP10FwdTxfm2dParam(ADST_ADST, TX_4X4, 2, 0.2),
- VP10FwdTxfm2dParam(DCT_DCT, TX_8X8, 5, 0.6),
- VP10FwdTxfm2dParam(ADST_DCT, TX_8X8, 5, 0.6),
- VP10FwdTxfm2dParam(DCT_ADST, TX_8X8, 5, 0.6),
- VP10FwdTxfm2dParam(ADST_ADST, TX_8X8, 5, 0.6),
- VP10FwdTxfm2dParam(DCT_DCT, TX_16X16, 11, 1.5),
- VP10FwdTxfm2dParam(ADST_DCT, TX_16X16, 11, 1.5),
- VP10FwdTxfm2dParam(DCT_ADST, TX_16X16, 11, 1.5),
- VP10FwdTxfm2dParam(ADST_ADST, TX_16X16, 11, 1.5),
- VP10FwdTxfm2dParam(DCT_DCT, TX_32X32, 70, 7),
- VP10FwdTxfm2dParam(ADST_DCT, TX_32X32, 70, 7),
- VP10FwdTxfm2dParam(DCT_ADST, TX_32X32, 70, 7),
- VP10FwdTxfm2dParam(ADST_ADST, TX_32X32, 70, 7)
-};
-
-INSTANTIATE_TEST_CASE_P(C, VP10FwdTxfm2d,
- ::testing::ValuesIn(vp10_fwd_txfm2d_param_c));
-
-#endif // CONFIG_VP9_HIGHBITDEPTH
-} // namespace
diff --git a/test/vp10_inv_txfm2d_test.cc b/test/vp10_inv_txfm2d_test.cc
deleted file mode 100644
index bbd0aaf..0000000
--- a/test/vp10_inv_txfm2d_test.cc
+++ /dev/null
@@ -1,157 +0,0 @@
-/*
- * Copyright (c) 2015 The WebM project authors. All Rights Reserved.
- *
- * Use of this source code is governed by a BSD-style license
- * that can be found in the LICENSE file in the root of the source
- * tree. An additional intellectual property rights grant can be found
- * in the file PATENTS. All contributing project authors may
- * be found in the AUTHORS file in the root of the source tree.
- */
-
-#include <math.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include "./vp10_rtcd.h"
-#include "test/acm_random.h"
-#include "test/util.h"
-#include "test/vp10_txfm_test.h"
-#include "av1/common/vp10_inv_txfm2d_cfg.h"
-
-using libaom_test::ACMRandom;
-using libaom_test::input_base;
-using libaom_test::bd;
-using libaom_test::compute_avg_abs_error;
-using libaom_test::Fwd_Txfm2d_Func;
-using libaom_test::Inv_Txfm2d_Func;
-
-namespace {
-
-#if CONFIG_VP9_HIGHBITDEPTH
-// VP10InvTxfm2dParam argument list:
-// tx_type_, tx_size_, max_error_, max_avg_error_
-typedef std::tr1::tuple<TX_TYPE, TX_SIZE, int, double> VP10InvTxfm2dParam;
-
-class VP10InvTxfm2d : public ::testing::TestWithParam<VP10InvTxfm2dParam> {
- public:
- virtual void SetUp() {
- tx_type_ = GET_PARAM(0);
- tx_size_ = GET_PARAM(1);
- max_error_ = GET_PARAM(2);
- max_avg_error_ = GET_PARAM(3);
- txfm1d_size_ = libaom_test::get_txfm1d_size(tx_size_);
- txfm2d_size_ = txfm1d_size_ * txfm1d_size_;
- count_ = 500;
-
- input_ = reinterpret_cast<int16_t *>(
- vpx_memalign(16, sizeof(int16_t) * txfm2d_size_));
- ref_input_ = reinterpret_cast<uint16_t *>(
- vpx_memalign(16, sizeof(uint16_t) * txfm2d_size_));
- output_ = reinterpret_cast<int32_t *>(
- vpx_memalign(16, sizeof(int32_t) * txfm2d_size_));
- }
-
- void RunRoundtripCheck() {
- const Fwd_Txfm2d_Func fwd_txfm_func =
- libaom_test::fwd_txfm_func_ls[tx_size_];
- const Inv_Txfm2d_Func inv_txfm_func =
- libaom_test::inv_txfm_func_ls[tx_size_];
- double avg_abs_error = 0;
- ACMRandom rnd(ACMRandom::DeterministicSeed());
- for (int ci = 0; ci < count_; ci++) {
- for (int ni = 0; ni < txfm2d_size_; ++ni) {
- if (ci == 0) {
- int extreme_input = input_base - 1;
- input_[ni] = extreme_input; // extreme case
- ref_input_[ni] = 0;
- } else {
- input_[ni] = rnd.Rand16() % input_base;
- ref_input_[ni] = 0;
- }
- }
-
- fwd_txfm_func(input_, output_, txfm1d_size_, tx_type_, bd);
- inv_txfm_func(output_, ref_input_, txfm1d_size_, tx_type_, bd);
-
- for (int ni = 0; ni < txfm2d_size_; ++ni) {
- EXPECT_GE(max_error_, abs(input_[ni] - ref_input_[ni]));
- }
- avg_abs_error += compute_avg_abs_error<int16_t, uint16_t>(
- input_, ref_input_, txfm2d_size_);
- }
-
- avg_abs_error /= count_;
- // max_abs_avg_error comes from upper bound of
- // printf("txfm1d_size: %d accuracy_avg_abs_error: %f\n",
- // txfm1d_size_, avg_abs_error);
- EXPECT_GE(max_avg_error_, avg_abs_error);
- }
-
- virtual void TearDown() {
- vpx_free(input_);
- vpx_free(output_);
- vpx_free(ref_input_);
- }
-
- private:
- int count_;
- int max_error_;
- double max_avg_error_;
- TX_TYPE tx_type_;
- TX_SIZE tx_size_;
- int txfm1d_size_;
- int txfm2d_size_;
- int16_t *input_;
- uint16_t *ref_input_;
- int32_t *output_;
-};
-
-TEST_P(VP10InvTxfm2d, RunRoundtripCheck) { RunRoundtripCheck(); }
-
-const VP10InvTxfm2dParam vp10_inv_txfm2d_param[] = {
-#if CONFIG_EXT_TX
- VP10InvTxfm2dParam(FLIPADST_DCT, TX_4X4, 2, 0.002),
- VP10InvTxfm2dParam(DCT_FLIPADST, TX_4X4, 2, 0.002),
- VP10InvTxfm2dParam(FLIPADST_FLIPADST, TX_4X4, 2, 0.002),
- VP10InvTxfm2dParam(ADST_FLIPADST, TX_4X4, 2, 0.002),
- VP10InvTxfm2dParam(FLIPADST_ADST, TX_4X4, 2, 0.002),
- VP10InvTxfm2dParam(FLIPADST_DCT, TX_8X8, 2, 0.02),
- VP10InvTxfm2dParam(DCT_FLIPADST, TX_8X8, 2, 0.02),
- VP10InvTxfm2dParam(FLIPADST_FLIPADST, TX_8X8, 2, 0.02),
- VP10InvTxfm2dParam(ADST_FLIPADST, TX_8X8, 2, 0.02),
- VP10InvTxfm2dParam(FLIPADST_ADST, TX_8X8, 2, 0.02),
- VP10InvTxfm2dParam(FLIPADST_DCT, TX_16X16, 2, 0.04),
- VP10InvTxfm2dParam(DCT_FLIPADST, TX_16X16, 2, 0.04),
- VP10InvTxfm2dParam(FLIPADST_FLIPADST, TX_16X16, 11, 0.04),
- VP10InvTxfm2dParam(ADST_FLIPADST, TX_16X16, 2, 0.04),
- VP10InvTxfm2dParam(FLIPADST_ADST, TX_16X16, 2, 0.04),
- VP10InvTxfm2dParam(FLIPADST_DCT, TX_32X32, 4, 0.4),
- VP10InvTxfm2dParam(DCT_FLIPADST, TX_32X32, 4, 0.4),
- VP10InvTxfm2dParam(FLIPADST_FLIPADST, TX_32X32, 4, 0.4),
- VP10InvTxfm2dParam(ADST_FLIPADST, TX_32X32, 4, 0.4),
- VP10InvTxfm2dParam(FLIPADST_ADST, TX_32X32, 4, 0.4),
-#endif
- VP10InvTxfm2dParam(DCT_DCT, TX_4X4, 2, 0.002),
- VP10InvTxfm2dParam(ADST_DCT, TX_4X4, 2, 0.002),
- VP10InvTxfm2dParam(DCT_ADST, TX_4X4, 2, 0.002),
- VP10InvTxfm2dParam(ADST_ADST, TX_4X4, 2, 0.002),
- VP10InvTxfm2dParam(DCT_DCT, TX_8X8, 2, 0.02),
- VP10InvTxfm2dParam(ADST_DCT, TX_8X8, 2, 0.02),
- VP10InvTxfm2dParam(DCT_ADST, TX_8X8, 2, 0.02),
- VP10InvTxfm2dParam(ADST_ADST, TX_8X8, 2, 0.02),
- VP10InvTxfm2dParam(DCT_DCT, TX_16X16, 2, 0.04),
- VP10InvTxfm2dParam(ADST_DCT, TX_16X16, 2, 0.04),
- VP10InvTxfm2dParam(DCT_ADST, TX_16X16, 2, 0.04),
- VP10InvTxfm2dParam(ADST_ADST, TX_16X16, 2, 0.04),
- VP10InvTxfm2dParam(DCT_DCT, TX_32X32, 4, 0.4),
- VP10InvTxfm2dParam(ADST_DCT, TX_32X32, 4, 0.4),
- VP10InvTxfm2dParam(DCT_ADST, TX_32X32, 4, 0.4),
- VP10InvTxfm2dParam(ADST_ADST, TX_32X32, 4, 0.4)
-};
-
-INSTANTIATE_TEST_CASE_P(C, VP10InvTxfm2d,
- ::testing::ValuesIn(vp10_inv_txfm2d_param));
-
-#endif // CONFIG_VP9_HIGHBITDEPTH
-
-} // namespace
diff --git a/test/vp8_multi_resolution_encoder.sh b/test/vp8_multi_resolution_encoder.sh
index 9b09daa..35121b8 100755
--- a/test/vp8_multi_resolution_encoder.sh
+++ b/test/vp8_multi_resolution_encoder.sh
@@ -17,13 +17,13 @@
# Environment check: $YUV_RAW_INPUT is required.
vp8_multi_resolution_encoder_verify_environment() {
- if [ "$(vpx_config_option_enabled CONFIG_MULTI_RES_ENCODING)" = "yes" ]; then
+ if [ "$(aom_config_option_enabled CONFIG_MULTI_RES_ENCODING)" = "yes" ]; then
if [ ! -e "${YUV_RAW_INPUT}" ]; then
- elog "Libvpx test data must exist in LIBVPX_TEST_DATA_PATH."
+ elog "Libaom test data must exist in LIBVPX_TEST_DATA_PATH."
return 1
fi
local readonly app="vp8_multi_resolution_encoder"
- if [ -z "$(vpx_tool_path "${app}")" ]; then
+ if [ -z "$(aom_tool_path "${app}")" ]; then
elog "${app} not found. It must exist in LIBAOM_BIN_PATH or its parent."
return 1
fi
@@ -33,21 +33,21 @@
# Runs vp8_multi_resolution_encoder. Simply forwards all arguments to
# vp8_multi_resolution_encoder after building path to the executable.
vp8_mre() {
- local readonly encoder="$(vpx_tool_path vp8_multi_resolution_encoder)"
+ local readonly encoder="$(aom_tool_path vp8_multi_resolution_encoder)"
if [ ! -x "${encoder}" ]; then
elog "${encoder} does not exist or is not executable."
return 1
fi
- eval "${VPX_TEST_PREFIX}" "${encoder}" "$@" ${devnull}
+ eval "${AOM_TEST_PREFIX}" "${encoder}" "$@" ${devnull}
}
vp8_multi_resolution_encoder_three_formats() {
- local readonly output_files="${VPX_TEST_OUTPUT_DIR}/vp8_mre_0.ivf
- ${VPX_TEST_OUTPUT_DIR}/vp8_mre_1.ivf
- ${VPX_TEST_OUTPUT_DIR}/vp8_mre_2.ivf"
+ local readonly output_files="${AOM_TEST_OUTPUT_DIR}/vp8_mre_0.ivf
+ ${AOM_TEST_OUTPUT_DIR}/vp8_mre_1.ivf
+ ${AOM_TEST_OUTPUT_DIR}/vp8_mre_2.ivf"
- if [ "$(vpx_config_option_enabled CONFIG_MULTI_RES_ENCODING)" = "yes" ]; then
+ if [ "$(aom_config_option_enabled CONFIG_MULTI_RES_ENCODING)" = "yes" ]; then
if [ "$(vp8_encode_available)" = "yes" ]; then
# Param order:
# Input width
diff --git a/test/vpxdec.sh b/test/vpxdec.sh
index 8b213ea..7c5169d 100755
--- a/test/vpxdec.sh
+++ b/test/vpxdec.sh
@@ -8,97 +8,97 @@
## in the file PATENTS. All contributing project authors may
## be found in the AUTHORS file in the root of the source tree.
##
-## This file tests vpxdec. To add new tests to this file, do the following:
+## This file tests aomdec. To add new tests to this file, do the following:
## 1. Write a shell function (this is your test).
-## 2. Add the function to vpxdec_tests (on a new line).
+## 2. Add the function to aomdec_tests (on a new line).
##
. $(dirname $0)/tools_common.sh
# Environment check: Make sure input is available.
-vpxdec_verify_environment() {
- if [ ! -e "${VP8_IVF_FILE}" ] || [ ! -e "${VP9_WEBM_FILE}" ] || \
- [ ! -e "${VP9_FPM_WEBM_FILE}" ] || \
- [ ! -e "${VP9_LT_50_FRAMES_WEBM_FILE}" ] ; then
- elog "Libvpx test data must exist in LIBVPX_TEST_DATA_PATH."
+aomdec_verify_environment() {
+ if [ ! -e "${VP8_IVF_FILE}" ] || [ ! -e "${AV1_WEBM_FILE}" ] || \
+ [ ! -e "${AV1_FPM_WEBM_FILE}" ] || \
+ [ ! -e "${AV1_LT_50_FRAMES_WEBM_FILE}" ] ; then
+ elog "Libaom test data must exist in LIBVPX_TEST_DATA_PATH."
return 1
fi
- if [ -z "$(vpx_tool_path vpxdec)" ]; then
- elog "vpxdec not found. It must exist in LIBAOM_BIN_PATH or its parent."
+ if [ -z "$(aom_tool_path aomdec)" ]; then
+ elog "aomdec not found. It must exist in LIBAOM_BIN_PATH or its parent."
return 1
fi
}
-# Wrapper function for running vpxdec with pipe input. Requires that
-# LIBAOM_BIN_PATH points to the directory containing vpxdec. $1 is used as the
+# Wrapper function for running aomdec with pipe input. Requires that
+# LIBAOM_BIN_PATH points to the directory containing aomdec. $1 is used as the
# input file path and shifted away. All remaining parameters are passed through
-# to vpxdec.
-vpxdec_pipe() {
- local readonly decoder="$(vpx_tool_path vpxdec)"
+# to aomdec.
+aomdec_pipe() {
+ local readonly decoder="$(aom_tool_path aomdec)"
local readonly input="$1"
shift
- cat "${input}" | eval "${VPX_TEST_PREFIX}" "${decoder}" - "$@" ${devnull}
+ cat "${input}" | eval "${AOM_TEST_PREFIX}" "${decoder}" - "$@" ${devnull}
}
-# Wrapper function for running vpxdec. Requires that LIBAOM_BIN_PATH points to
-# the directory containing vpxdec. $1 one is used as the input file path and
-# shifted away. All remaining parameters are passed through to vpxdec.
-vpxdec() {
- local readonly decoder="$(vpx_tool_path vpxdec)"
+# Wrapper function for running aomdec. Requires that LIBAOM_BIN_PATH points to
+# the directory containing aomdec. $1 one is used as the input file path and
+# shifted away. All remaining parameters are passed through to aomdec.
+aomdec() {
+ local readonly decoder="$(aom_tool_path aomdec)"
local readonly input="$1"
shift
- eval "${VPX_TEST_PREFIX}" "${decoder}" "$input" "$@" ${devnull}
+ eval "${AOM_TEST_PREFIX}" "${decoder}" "$input" "$@" ${devnull}
}
-vpxdec_can_decode_vp8() {
+aomdec_can_decode_vp8() {
if [ "$(vp8_decode_available)" = "yes" ]; then
echo yes
fi
}
-vpxdec_can_decode_vp9() {
+aomdec_can_decode_vp9() {
if [ "$(vp9_decode_available)" = "yes" ]; then
echo yes
fi
}
-vpxdec_vp8_ivf() {
- if [ "$(vpxdec_can_decode_vp8)" = "yes" ]; then
- vpxdec "${VP8_IVF_FILE}" --summary --noblit
+aomdec_vp8_ivf() {
+ if [ "$(aomdec_can_decode_vp8)" = "yes" ]; then
+ aomdec "${VP8_IVF_FILE}" --summary --noblit
fi
}
-vpxdec_vp8_ivf_pipe_input() {
- if [ "$(vpxdec_can_decode_vp8)" = "yes" ]; then
- vpxdec_pipe "${VP8_IVF_FILE}" --summary --noblit
+aomdec_vp8_ivf_pipe_input() {
+ if [ "$(aomdec_can_decode_vp8)" = "yes" ]; then
+ aomdec_pipe "${VP8_IVF_FILE}" --summary --noblit
fi
}
-vpxdec_vp9_webm() {
- if [ "$(vpxdec_can_decode_vp9)" = "yes" ] && \
+aomdec_vp9_webm() {
+ if [ "$(aomdec_can_decode_vp9)" = "yes" ] && \
[ "$(webm_io_available)" = "yes" ]; then
- vpxdec "${VP9_WEBM_FILE}" --summary --noblit
+ aomdec "${AV1_WEBM_FILE}" --summary --noblit
fi
}
-vpxdec_vp9_webm_frame_parallel() {
- if [ "$(vpxdec_can_decode_vp9)" = "yes" ] && \
+aomdec_vp9_webm_frame_parallel() {
+ if [ "$(aomdec_can_decode_vp9)" = "yes" ] && \
[ "$(webm_io_available)" = "yes" ]; then
for threads in 2 3 4 5 6 7 8; do
- vpxdec "${VP9_FPM_WEBM_FILE}" --summary --noblit --threads=$threads \
+ aomdec "${AV1_FPM_WEBM_FILE}" --summary --noblit --threads=$threads \
--frame-parallel
done
fi
}
-vpxdec_vp9_webm_less_than_50_frames() {
+aomdec_vp9_webm_less_than_50_frames() {
# ensure that reaching eof in webm_guess_framerate doesn't result in invalid
# frames in actual webm_read_frame calls.
- if [ "$(vpxdec_can_decode_vp9)" = "yes" ] && \
+ if [ "$(aomdec_can_decode_vp9)" = "yes" ] && \
[ "$(webm_io_available)" = "yes" ]; then
- local readonly decoder="$(vpx_tool_path vpxdec)"
+ local readonly decoder="$(aom_tool_path aomdec)"
local readonly expected=10
- local readonly num_frames=$(${VPX_TEST_PREFIX} "${decoder}" \
- "${VP9_LT_50_FRAMES_WEBM_FILE}" --summary --noblit 2>&1 \
+ local readonly num_frames=$(${AOM_TEST_PREFIX} "${decoder}" \
+ "${AV1_LT_50_FRAMES_WEBM_FILE}" --summary --noblit 2>&1 \
| awk '/^[0-9]+ decoded frames/ { print $1 }')
if [ "$num_frames" -ne "$expected" ]; then
elog "Output frames ($num_frames) != expected ($expected)"
@@ -107,10 +107,10 @@
fi
}
-vpxdec_tests="vpxdec_vp8_ivf
- vpxdec_vp8_ivf_pipe_input
- vpxdec_vp9_webm
- vpxdec_vp9_webm_frame_parallel
- vpxdec_vp9_webm_less_than_50_frames"
+aomdec_tests="aomdec_vp8_ivf
+ aomdec_vp8_ivf_pipe_input
+ aomdec_vp9_webm
+ aomdec_vp9_webm_frame_parallel
+ aomdec_vp9_webm_less_than_50_frames"
-run_tests vpxdec_verify_environment "${vpxdec_tests}"
+run_tests aomdec_verify_environment "${aomdec_tests}"
diff --git a/test/vpxenc.sh b/test/vpxenc.sh
deleted file mode 100755
index 20e147f..0000000
--- a/test/vpxenc.sh
+++ /dev/null
@@ -1,429 +0,0 @@
-#!/bin/sh
-##
-## Copyright (c) 2014 The WebM project authors. All Rights Reserved.
-##
-## Use of this source code is governed by a BSD-style license
-## that can be found in the LICENSE file in the root of the source
-## tree. An additional intellectual property rights grant can be found
-## in the file PATENTS. All contributing project authors may
-## be found in the AUTHORS file in the root of the source tree.
-##
-## This file tests vpxenc using hantro_collage_w352h288.yuv as input. To add
-## new tests to this file, do the following:
-## 1. Write a shell function (this is your test).
-## 2. Add the function to vpxenc_tests (on a new line).
-##
-. $(dirname $0)/tools_common.sh
-
-readonly TEST_FRAMES=10
-
-# Environment check: Make sure input is available.
-vpxenc_verify_environment() {
- if [ ! -e "${YUV_RAW_INPUT}" ]; then
- elog "The file ${YUV_RAW_INPUT##*/} must exist in LIBVPX_TEST_DATA_PATH."
- return 1
- fi
- if [ "$(vpxenc_can_encode_vp9)" = "yes" ]; then
- if [ ! -e "${Y4M_NOSQ_PAR_INPUT}" ]; then
- elog "The file ${Y4M_NOSQ_PAR_INPUT##*/} must exist in"
- elog "LIBVPX_TEST_DATA_PATH."
- return 1
- fi
- fi
- if [ -z "$(vpx_tool_path vpxenc)" ]; then
- elog "vpxenc not found. It must exist in LIBAOM_BIN_PATH or its parent."
- return 1
- fi
-}
-
-vpxenc_can_encode_vp8() {
- if [ "$(vp8_encode_available)" = "yes" ]; then
- echo yes
- fi
-}
-
-vpxenc_can_encode_vp9() {
- if [ "$(vp9_encode_available)" = "yes" ]; then
- echo yes
- fi
-}
-
-# Echo vpxenc command line parameters allowing use of
-# hantro_collage_w352h288.yuv as input.
-yuv_input_hantro_collage() {
- echo ""${YUV_RAW_INPUT}"
- --width="${YUV_RAW_INPUT_WIDTH}"
- --height="${YUV_RAW_INPUT_HEIGHT}""
-}
-
-y4m_input_non_square_par() {
- echo ""${Y4M_NOSQ_PAR_INPUT}""
-}
-
-y4m_input_720p() {
- echo ""${Y4M_720P_INPUT}""
-}
-
-# Echo default vpxenc real time encoding params. $1 is the codec, which defaults
-# to vp8 if unspecified.
-vpxenc_rt_params() {
- local readonly codec="${1:-vp8}"
- echo "--codec=${codec}
- --buf-initial-sz=500
- --buf-optimal-sz=600
- --buf-sz=1000
- --cpu-used=-6
- --end-usage=cbr
- --error-resilient=1
- --kf-max-dist=90000
- --lag-in-frames=0
- --max-intra-rate=300
- --max-q=56
- --min-q=2
- --noise-sensitivity=0
- --overshoot-pct=50
- --passes=1
- --profile=0
- --resize-allowed=0
- --rt
- --static-thresh=0
- --undershoot-pct=50"
-}
-
-# Wrapper function for running vpxenc with pipe input. Requires that
-# LIBAOM_BIN_PATH points to the directory containing vpxenc. $1 is used as the
-# input file path and shifted away. All remaining parameters are passed through
-# to vpxenc.
-vpxenc_pipe() {
- local readonly encoder="$(vpx_tool_path vpxenc)"
- local readonly input="$1"
- shift
- cat "${input}" | eval "${VPX_TEST_PREFIX}" "${encoder}" - \
- --test-decode=fatal \
- "$@" ${devnull}
-}
-
-# Wrapper function for running vpxenc. Requires that LIBAOM_BIN_PATH points to
-# the directory containing vpxenc. $1 one is used as the input file path and
-# shifted away. All remaining parameters are passed through to vpxenc.
-vpxenc() {
- local readonly encoder="$(vpx_tool_path vpxenc)"
- local readonly input="$1"
- shift
- eval "${VPX_TEST_PREFIX}" "${encoder}" "${input}" \
- --test-decode=fatal \
- "$@" ${devnull}
-}
-
-vpxenc_vp8_ivf() {
- if [ "$(vpxenc_can_encode_vp8)" = "yes" ]; then
- local readonly output="${VPX_TEST_OUTPUT_DIR}/vp8.ivf"
- vpxenc $(yuv_input_hantro_collage) \
- --codec=vp8 \
- --limit="${TEST_FRAMES}" \
- --ivf \
- --output="${output}"
-
- if [ ! -e "${output}" ]; then
- elog "Output file does not exist."
- return 1
- fi
- fi
-}
-
-vpxenc_vp8_webm() {
- if [ "$(vpxenc_can_encode_vp8)" = "yes" ] && \
- [ "$(webm_io_available)" = "yes" ]; then
- local readonly output="${VPX_TEST_OUTPUT_DIR}/vp8.webm"
- vpxenc $(yuv_input_hantro_collage) \
- --codec=vp8 \
- --limit="${TEST_FRAMES}" \
- --output="${output}"
-
- if [ ! -e "${output}" ]; then
- elog "Output file does not exist."
- return 1
- fi
- fi
-}
-
-vpxenc_vp8_webm_rt() {
- if [ "$(vpxenc_can_encode_vp8)" = "yes" ] && \
- [ "$(webm_io_available)" = "yes" ]; then
- local readonly output="${VPX_TEST_OUTPUT_DIR}/vp8_rt.webm"
- vpxenc $(yuv_input_hantro_collage) \
- $(vpxenc_rt_params vp8) \
- --output="${output}"
- if [ ! -e "${output}" ]; then
- elog "Output file does not exist."
- return 1
- fi
- fi
-}
-
-vpxenc_vp8_webm_2pass() {
- if [ "$(vpxenc_can_encode_vp8)" = "yes" ] && \
- [ "$(webm_io_available)" = "yes" ]; then
- local readonly output="${VPX_TEST_OUTPUT_DIR}/vp8.webm"
- vpxenc $(yuv_input_hantro_collage) \
- --codec=vp8 \
- --limit="${TEST_FRAMES}" \
- --output="${output}" \
- --passes=2
-
- if [ ! -e "${output}" ]; then
- elog "Output file does not exist."
- return 1
- fi
- fi
-}
-
-vpxenc_vp8_webm_lag10_frames20() {
- if [ "$(vpxenc_can_encode_vp8)" = "yes" ] && \
- [ "$(webm_io_available)" = "yes" ]; then
- local readonly lag_total_frames=20
- local readonly lag_frames=10
- local readonly output="${VPX_TEST_OUTPUT_DIR}/vp8_lag10_frames20.webm"
- vpxenc $(yuv_input_hantro_collage) \
- --codec=vp8 \
- --limit="${lag_total_frames}" \
- --lag-in-frames="${lag_frames}" \
- --output="${output}" \
- --auto-alt-ref=1 \
- --passes=2
-
- if [ ! -e "${output}" ]; then
- elog "Output file does not exist."
- return 1
- fi
- fi
-}
-
-vpxenc_vp8_ivf_piped_input() {
- if [ "$(vpxenc_can_encode_vp8)" = "yes" ]; then
- local readonly output="${VPX_TEST_OUTPUT_DIR}/vp8_piped_input.ivf"
- vpxenc_pipe $(yuv_input_hantro_collage) \
- --codec=vp8 \
- --limit="${TEST_FRAMES}" \
- --ivf \
- --output="${output}"
-
- if [ ! -e "${output}" ]; then
- elog "Output file does not exist."
- return 1
- fi
- fi
-}
-
-vpxenc_vp9_ivf() {
- if [ "$(vpxenc_can_encode_vp9)" = "yes" ]; then
- local readonly output="${VPX_TEST_OUTPUT_DIR}/vp9.ivf"
- vpxenc $(yuv_input_hantro_collage) \
- --codec=vp9 \
- --limit="${TEST_FRAMES}" \
- --ivf \
- --output="${output}"
-
- if [ ! -e "${output}" ]; then
- elog "Output file does not exist."
- return 1
- fi
- fi
-}
-
-vpxenc_vp9_webm() {
- if [ "$(vpxenc_can_encode_vp9)" = "yes" ] && \
- [ "$(webm_io_available)" = "yes" ]; then
- local readonly output="${VPX_TEST_OUTPUT_DIR}/vp9.webm"
- vpxenc $(yuv_input_hantro_collage) \
- --codec=vp9 \
- --limit="${TEST_FRAMES}" \
- --output="${output}"
-
- if [ ! -e "${output}" ]; then
- elog "Output file does not exist."
- return 1
- fi
- fi
-}
-
-vpxenc_vp9_webm_rt() {
- if [ "$(vpxenc_can_encode_vp9)" = "yes" ] && \
- [ "$(webm_io_available)" = "yes" ]; then
- local readonly output="${VPX_TEST_OUTPUT_DIR}/vp9_rt.webm"
- vpxenc $(yuv_input_hantro_collage) \
- $(vpxenc_rt_params vp9) \
- --output="${output}"
-
- if [ ! -e "${output}" ]; then
- elog "Output file does not exist."
- return 1
- fi
- fi
-}
-
-vpxenc_vp9_webm_rt_multithread_tiled() {
- if [ "$(vpxenc_can_encode_vp9)" = "yes" ] && \
- [ "$(webm_io_available)" = "yes" ]; then
- local readonly output="${VPX_TEST_OUTPUT_DIR}/vp9_rt_multithread_tiled.webm"
- local readonly tilethread_min=2
- local readonly tilethread_max=4
- local readonly num_threads="$(seq ${tilethread_min} ${tilethread_max})"
- local readonly num_tile_cols="$(seq ${tilethread_min} ${tilethread_max})"
-
- for threads in ${num_threads}; do
- for tile_cols in ${num_tile_cols}; do
- vpxenc $(y4m_input_720p) \
- $(vpxenc_rt_params vp9) \
- --threads=${threads} \
- --tile-columns=${tile_cols} \
- --output="${output}"
- done
- done
-
- if [ ! -e "${output}" ]; then
- elog "Output file does not exist."
- return 1
- fi
-
- rm "${output}"
- fi
-}
-
-vpxenc_vp9_webm_rt_multithread_tiled_frameparallel() {
- if [ "$(vpxenc_can_encode_vp9)" = "yes" ] && \
- [ "$(webm_io_available)" = "yes" ]; then
- local readonly output="${VPX_TEST_OUTPUT_DIR}/vp9_rt_mt_t_fp.webm"
- local readonly tilethread_min=2
- local readonly tilethread_max=4
- local readonly num_threads="$(seq ${tilethread_min} ${tilethread_max})"
- local readonly num_tile_cols="$(seq ${tilethread_min} ${tilethread_max})"
-
- for threads in ${num_threads}; do
- for tile_cols in ${num_tile_cols}; do
- vpxenc $(y4m_input_720p) \
- $(vpxenc_rt_params vp9) \
- --threads=${threads} \
- --tile-columns=${tile_cols} \
- --frame-parallel=1 \
- --output="${output}"
- done
- done
-
- if [ ! -e "${output}" ]; then
- elog "Output file does not exist."
- return 1
- fi
-
- rm "${output}"
- fi
-}
-
-vpxenc_vp9_webm_2pass() {
- if [ "$(vpxenc_can_encode_vp9)" = "yes" ] && \
- [ "$(webm_io_available)" = "yes" ]; then
- local readonly output="${VPX_TEST_OUTPUT_DIR}/vp9.webm"
- vpxenc $(yuv_input_hantro_collage) \
- --codec=vp9 \
- --limit="${TEST_FRAMES}" \
- --output="${output}" \
- --passes=2
-
- if [ ! -e "${output}" ]; then
- elog "Output file does not exist."
- return 1
- fi
- fi
-}
-
-vpxenc_vp9_ivf_lossless() {
- if [ "$(vpxenc_can_encode_vp9)" = "yes" ]; then
- local readonly output="${VPX_TEST_OUTPUT_DIR}/vp9_lossless.ivf"
- vpxenc $(yuv_input_hantro_collage) \
- --codec=vp9 \
- --limit="${TEST_FRAMES}" \
- --ivf \
- --output="${output}" \
- --lossless=1
-
- if [ ! -e "${output}" ]; then
- elog "Output file does not exist."
- return 1
- fi
- fi
-}
-
-vpxenc_vp9_ivf_minq0_maxq0() {
- if [ "$(vpxenc_can_encode_vp9)" = "yes" ]; then
- local readonly output="${VPX_TEST_OUTPUT_DIR}/vp9_lossless_minq0_maxq0.ivf"
- vpxenc $(yuv_input_hantro_collage) \
- --codec=vp9 \
- --limit="${TEST_FRAMES}" \
- --ivf \
- --output="${output}" \
- --min-q=0 \
- --max-q=0
-
- if [ ! -e "${output}" ]; then
- elog "Output file does not exist."
- return 1
- fi
- fi
-}
-
-vpxenc_vp9_webm_lag10_frames20() {
- if [ "$(vpxenc_can_encode_vp9)" = "yes" ] && \
- [ "$(webm_io_available)" = "yes" ]; then
- local readonly lag_total_frames=20
- local readonly lag_frames=10
- local readonly output="${VPX_TEST_OUTPUT_DIR}/vp9_lag10_frames20.webm"
- vpxenc $(yuv_input_hantro_collage) \
- --codec=vp9 \
- --limit="${lag_total_frames}" \
- --lag-in-frames="${lag_frames}" \
- --output="${output}" \
- --passes=2 \
- --auto-alt-ref=1
-
- if [ ! -e "${output}" ]; then
- elog "Output file does not exist."
- return 1
- fi
- fi
-}
-
-# TODO(fgalligan): Test that DisplayWidth is different than video width.
-vpxenc_vp9_webm_non_square_par() {
- if [ "$(vpxenc_can_encode_vp9)" = "yes" ] && \
- [ "$(webm_io_available)" = "yes" ]; then
- local readonly output="${VPX_TEST_OUTPUT_DIR}/vp9_non_square_par.webm"
- vpxenc $(y4m_input_non_square_par) \
- --codec=vp9 \
- --limit="${TEST_FRAMES}" \
- --output="${output}"
-
- if [ ! -e "${output}" ]; then
- elog "Output file does not exist."
- return 1
- fi
- fi
-}
-
-vpxenc_tests="vpxenc_vp8_ivf
- vpxenc_vp8_webm
- vpxenc_vp8_webm_rt
- vpxenc_vp8_webm_2pass
- vpxenc_vp8_webm_lag10_frames20
- vpxenc_vp8_ivf_piped_input
- vpxenc_vp9_ivf
- vpxenc_vp9_webm
- vpxenc_vp9_webm_rt
- vpxenc_vp9_webm_rt_multithread_tiled
- vpxenc_vp9_webm_rt_multithread_tiled_frameparallel
- vpxenc_vp9_webm_2pass
- vpxenc_vp9_ivf_lossless
- vpxenc_vp9_ivf_minq0_maxq0
- vpxenc_vp9_webm_lag10_frames20
- vpxenc_vp9_webm_non_square_par"
-
-run_tests vpxenc_verify_environment "${vpxenc_tests}"
diff --git a/test/webm_video_source.h b/test/webm_video_source.h
index c0e1cb1..e5c34bb 100644
--- a/test/webm_video_source.h
+++ b/test/webm_video_source.h
@@ -25,25 +25,25 @@
class WebMVideoSource : public CompressedVideoSource {
public:
explicit WebMVideoSource(const std::string &file_name)
- : file_name_(file_name), vpx_ctx_(new VpxInputContext()),
+ : file_name_(file_name), aom_ctx_(new AvxInputContext()),
webm_ctx_(new WebmInputContext()), buf_(NULL), buf_sz_(0), frame_(0),
end_of_file_(false) {}
virtual ~WebMVideoSource() {
- if (vpx_ctx_->file != NULL) fclose(vpx_ctx_->file);
+ if (aom_ctx_->file != NULL) fclose(aom_ctx_->file);
webm_free(webm_ctx_);
- delete vpx_ctx_;
+ delete aom_ctx_;
delete webm_ctx_;
}
virtual void Init() {}
virtual void Begin() {
- vpx_ctx_->file = OpenTestDataFile(file_name_);
- ASSERT_TRUE(vpx_ctx_->file != NULL) << "Input file open failed. Filename: "
+ aom_ctx_->file = OpenTestDataFile(file_name_);
+ ASSERT_TRUE(aom_ctx_->file != NULL) << "Input file open failed. Filename: "
<< file_name_;
- ASSERT_EQ(file_is_webm(webm_ctx_, vpx_ctx_), 1) << "file is not WebM";
+ ASSERT_EQ(file_is_webm(webm_ctx_, aom_ctx_), 1) << "file is not WebM";
FillFrame();
}
@@ -54,7 +54,7 @@
}
void FillFrame() {
- ASSERT_TRUE(vpx_ctx_->file != NULL);
+ ASSERT_TRUE(aom_ctx_->file != NULL);
const int status = webm_read_frame(webm_ctx_, &buf_, &buf_sz_);
ASSERT_GE(status, 0) << "webm_read_frame failed";
if (status == 1) {
@@ -63,7 +63,7 @@
}
void SeekToNextKeyFrame() {
- ASSERT_TRUE(vpx_ctx_->file != NULL);
+ ASSERT_TRUE(aom_ctx_->file != NULL);
do {
const int status = webm_read_frame(webm_ctx_, &buf_, &buf_sz_);
ASSERT_GE(status, 0) << "webm_read_frame failed";
@@ -80,7 +80,7 @@
protected:
std::string file_name_;
- VpxInputContext *vpx_ctx_;
+ AvxInputContext *aom_ctx_;
WebmInputContext *webm_ctx_;
uint8_t *buf_;
size_t buf_sz_;
diff --git a/test/y4m_test.cc b/test/y4m_test.cc
index d68d3d1..c3c4ac6 100644
--- a/test/y4m_test.cc
+++ b/test/y4m_test.cc
@@ -12,7 +12,7 @@
#include "third_party/googletest/src/include/gtest/gtest.h"
-#include "./vpx_config.h"
+#include "./aom_config.h"
#include "./y4menc.h"
#include "test/md5_helper.h"
#include "test/util.h"
@@ -29,37 +29,37 @@
struct Y4mTestParam {
const char *filename;
unsigned int bit_depth;
- vpx_img_fmt format;
+ aom_img_fmt format;
const char *md5raw;
};
const Y4mTestParam kY4mTestVectors[] = {
- { "park_joy_90p_8_420.y4m", 8, VPX_IMG_FMT_I420,
+ { "park_joy_90p_8_420.y4m", 8, AOM_IMG_FMT_I420,
"e5406275b9fc6bb3436c31d4a05c1cab" },
- { "park_joy_90p_8_422.y4m", 8, VPX_IMG_FMT_I422,
+ { "park_joy_90p_8_422.y4m", 8, AOM_IMG_FMT_I422,
"284a47a47133b12884ec3a14e959a0b6" },
- { "park_joy_90p_8_444.y4m", 8, VPX_IMG_FMT_I444,
+ { "park_joy_90p_8_444.y4m", 8, AOM_IMG_FMT_I444,
"90517ff33843d85de712fd4fe60dbed0" },
- { "park_joy_90p_10_420.y4m", 10, VPX_IMG_FMT_I42016,
+ { "park_joy_90p_10_420.y4m", 10, AOM_IMG_FMT_I42016,
"63f21f9f717d8b8631bd2288ee87137b" },
- { "park_joy_90p_10_422.y4m", 10, VPX_IMG_FMT_I42216,
+ { "park_joy_90p_10_422.y4m", 10, AOM_IMG_FMT_I42216,
"48ab51fb540aed07f7ff5af130c9b605" },
- { "park_joy_90p_10_444.y4m", 10, VPX_IMG_FMT_I44416,
+ { "park_joy_90p_10_444.y4m", 10, AOM_IMG_FMT_I44416,
"067bfd75aa85ff9bae91fa3e0edd1e3e" },
- { "park_joy_90p_12_420.y4m", 12, VPX_IMG_FMT_I42016,
+ { "park_joy_90p_12_420.y4m", 12, AOM_IMG_FMT_I42016,
"9e6d8f6508c6e55625f6b697bc461cef" },
- { "park_joy_90p_12_422.y4m", 12, VPX_IMG_FMT_I42216,
+ { "park_joy_90p_12_422.y4m", 12, AOM_IMG_FMT_I42216,
"b239c6b301c0b835485be349ca83a7e3" },
- { "park_joy_90p_12_444.y4m", 12, VPX_IMG_FMT_I44416,
+ { "park_joy_90p_12_444.y4m", 12, AOM_IMG_FMT_I44416,
"5a6481a550821dab6d0192f5c63845e9" },
};
-static void write_image_file(const vpx_image_t *img, FILE *file) {
+static void write_image_file(const aom_image_t *img, FILE *file) {
int plane, y;
for (plane = 0; plane < 3; ++plane) {
const unsigned char *buf = img->planes[plane];
const int stride = img->stride[plane];
- const int bytes_per_sample = (img->fmt & VPX_IMG_FMT_HIGHBITDEPTH) ? 2 : 1;
+ const int bytes_per_sample = (img->fmt & AOM_IMG_FMT_HIGHBITDEPTH) ? 2 : 1;
const int h =
(plane ? (img->d_h + img->y_chroma_shift) >> img->y_chroma_shift
: img->d_h);
@@ -89,25 +89,25 @@
}
// Checks y4m header information
- void HeaderChecks(unsigned int bit_depth, vpx_img_fmt_t fmt) {
+ void HeaderChecks(unsigned int bit_depth, aom_img_fmt_t fmt) {
ASSERT_TRUE(input_file_ != NULL);
ASSERT_EQ(y4m_.pic_w, (int)kWidth);
ASSERT_EQ(y4m_.pic_h, (int)kHeight);
ASSERT_EQ(img()->d_w, kWidth);
ASSERT_EQ(img()->d_h, kHeight);
ASSERT_EQ(y4m_.bit_depth, bit_depth);
- ASSERT_EQ(y4m_.vpx_fmt, fmt);
- if (fmt == VPX_IMG_FMT_I420 || fmt == VPX_IMG_FMT_I42016) {
+ ASSERT_EQ(y4m_.aom_fmt, fmt);
+ if (fmt == AOM_IMG_FMT_I420 || fmt == AOM_IMG_FMT_I42016) {
ASSERT_EQ(y4m_.bps, (int)y4m_.bit_depth * 3 / 2);
ASSERT_EQ(img()->x_chroma_shift, 1U);
ASSERT_EQ(img()->y_chroma_shift, 1U);
}
- if (fmt == VPX_IMG_FMT_I422 || fmt == VPX_IMG_FMT_I42216) {
+ if (fmt == AOM_IMG_FMT_I422 || fmt == AOM_IMG_FMT_I42216) {
ASSERT_EQ(y4m_.bps, (int)y4m_.bit_depth * 2);
ASSERT_EQ(img()->x_chroma_shift, 1U);
ASSERT_EQ(img()->y_chroma_shift, 0U);
}
- if (fmt == VPX_IMG_FMT_I444 || fmt == VPX_IMG_FMT_I44416) {
+ if (fmt == AOM_IMG_FMT_I444 || fmt == AOM_IMG_FMT_I44416) {
ASSERT_EQ(y4m_.bps, (int)y4m_.bit_depth * 3);
ASSERT_EQ(img()->x_chroma_shift, 0U);
ASSERT_EQ(img()->y_chroma_shift, 0U);
@@ -157,11 +157,11 @@
void WriteY4mAndReadBack() {
ASSERT_TRUE(input_file_ != NULL);
char buf[Y4M_BUFFER_SIZE] = { 0 };
- const struct VpxRational framerate = { y4m_.fps_n, y4m_.fps_d };
+ const struct AvxRational framerate = { y4m_.fps_n, y4m_.fps_d };
tmpfile_ = new libaom_test::TempOutFile;
ASSERT_TRUE(tmpfile_->file() != NULL);
y4m_write_file_header(buf, sizeof(buf), kWidth, kHeight, &framerate,
- y4m_.vpx_fmt, y4m_.bit_depth);
+ y4m_.aom_fmt, y4m_.bit_depth);
fputs(buf, tmpfile_->file());
for (unsigned int i = start_; i < limit_; i++) {
y4m_write_frame_header(buf, sizeof(buf));
diff --git a/test/y4m_video_source.h b/test/y4m_video_source.h
index 094cdbe..b5a1ba5 100644
--- a/test/y4m_video_source.h
+++ b/test/y4m_video_source.h
@@ -22,12 +22,12 @@
class Y4mVideoSource : public VideoSource {
public:
Y4mVideoSource(const std::string &file_name, unsigned int start, int limit)
- : file_name_(file_name), input_file_(NULL), img_(new vpx_image_t()),
+ : file_name_(file_name), input_file_(NULL), img_(new aom_image_t()),
start_(start), limit_(limit), frame_(0), framerate_numerator_(0),
framerate_denominator_(0), y4m_() {}
virtual ~Y4mVideoSource() {
- vpx_img_free(img_.get());
+ aom_img_free(img_.get());
CloseSource();
}
@@ -60,17 +60,17 @@
FillFrame();
}
- virtual vpx_image_t *img() const {
+ virtual aom_image_t *img() const {
return (frame_ < limit_) ? img_.get() : NULL;
}
// Models a stream where Timebase = 1/FPS, so pts == frame.
- virtual vpx_codec_pts_t pts() const { return frame_; }
+ virtual aom_codec_pts_t pts() const { return frame_; }
virtual unsigned long duration() const { return 1; }
- virtual vpx_rational_t timebase() const {
- const vpx_rational_t t = { framerate_denominator_, framerate_numerator_ };
+ virtual aom_rational_t timebase() const {
+ const aom_rational_t t = { framerate_denominator_, framerate_numerator_ };
return t;
}
@@ -86,11 +86,11 @@
// Swap buffers with another y4m source. This allows reading a new frame
// while keeping the old frame around. A whole Y4mSource is required and
- // not just a vpx_image_t because of how the y4m reader manipulates
- // vpx_image_t internals,
+ // not just a aom_image_t because of how the y4m reader manipulates
+ // aom_image_t internals,
void SwapBuffers(Y4mVideoSource *other) {
std::swap(other->y4m_.dst_buf, y4m_.dst_buf);
- vpx_image_t *tmp;
+ aom_image_t *tmp;
tmp = other->img_.release();
other->img_.reset(img_.release());
img_.reset(tmp);
@@ -108,7 +108,7 @@
std::string file_name_;
FILE *input_file_;
- testing::internal::scoped_ptr<vpx_image_t> img_;
+ testing::internal::scoped_ptr<aom_image_t> img_;
unsigned int start_;
unsigned int limit_;
unsigned int frame_;
diff --git a/test/yuv_video_source.h b/test/yuv_video_source.h
index 33a31d4..a0eabce 100644
--- a/test/yuv_video_source.h
+++ b/test/yuv_video_source.h
@@ -15,7 +15,7 @@
#include <string>
#include "test/video_source.h"
-#include "aom/vpx_image.h"
+#include "aom/aom_image.h"
namespace libaom_test {
@@ -24,19 +24,19 @@
// do actual file encodes.
class YUVVideoSource : public VideoSource {
public:
- YUVVideoSource(const std::string &file_name, vpx_img_fmt format,
+ YUVVideoSource(const std::string &file_name, aom_img_fmt format,
unsigned int width, unsigned int height, int rate_numerator,
int rate_denominator, unsigned int start, int limit)
: file_name_(file_name), input_file_(NULL), img_(NULL), start_(start),
limit_(limit), frame_(0), width_(0), height_(0),
- format_(VPX_IMG_FMT_NONE), framerate_numerator_(rate_numerator),
+ format_(AOM_IMG_FMT_NONE), framerate_numerator_(rate_numerator),
framerate_denominator_(rate_denominator) {
// This initializes format_, raw_size_, width_, height_ and allocates img.
SetSize(width, height, format);
}
virtual ~YUVVideoSource() {
- vpx_img_free(img_);
+ aom_img_free(img_);
if (input_file_) fclose(input_file_);
}
@@ -57,15 +57,15 @@
FillFrame();
}
- virtual vpx_image_t *img() const { return (frame_ < limit_) ? img_ : NULL; }
+ virtual aom_image_t *img() const { return (frame_ < limit_) ? img_ : NULL; }
// Models a stream where Timebase = 1/FPS, so pts == frame.
- virtual vpx_codec_pts_t pts() const { return frame_; }
+ virtual aom_codec_pts_t pts() const { return frame_; }
virtual unsigned long duration() const { return 1; }
- virtual vpx_rational_t timebase() const {
- const vpx_rational_t t = { framerate_denominator_, framerate_numerator_ };
+ virtual aom_rational_t timebase() const {
+ const aom_rational_t t = { framerate_denominator_, framerate_numerator_ };
return t;
}
@@ -74,23 +74,23 @@
virtual unsigned int limit() const { return limit_; }
virtual void SetSize(unsigned int width, unsigned int height,
- vpx_img_fmt format) {
+ aom_img_fmt format) {
if (width != width_ || height != height_ || format != format_) {
- vpx_img_free(img_);
- img_ = vpx_img_alloc(NULL, format, width, height, 1);
+ aom_img_free(img_);
+ img_ = aom_img_alloc(NULL, format, width, height, 1);
ASSERT_TRUE(img_ != NULL);
width_ = width;
height_ = height;
format_ = format;
switch (format) {
- case VPX_IMG_FMT_I420: raw_size_ = width * height * 3 / 2; break;
- case VPX_IMG_FMT_I422: raw_size_ = width * height * 2; break;
- case VPX_IMG_FMT_I440: raw_size_ = width * height * 2; break;
- case VPX_IMG_FMT_I444: raw_size_ = width * height * 3; break;
- case VPX_IMG_FMT_I42016: raw_size_ = width * height * 3; break;
- case VPX_IMG_FMT_I42216: raw_size_ = width * height * 4; break;
- case VPX_IMG_FMT_I44016: raw_size_ = width * height * 4; break;
- case VPX_IMG_FMT_I44416: raw_size_ = width * height * 6; break;
+ case AOM_IMG_FMT_I420: raw_size_ = width * height * 3 / 2; break;
+ case AOM_IMG_FMT_I422: raw_size_ = width * height * 2; break;
+ case AOM_IMG_FMT_I440: raw_size_ = width * height * 2; break;
+ case AOM_IMG_FMT_I444: raw_size_ = width * height * 3; break;
+ case AOM_IMG_FMT_I42016: raw_size_ = width * height * 3; break;
+ case AOM_IMG_FMT_I42216: raw_size_ = width * height * 4; break;
+ case AOM_IMG_FMT_I44016: raw_size_ = width * height * 4; break;
+ case AOM_IMG_FMT_I44416: raw_size_ = width * height * 6; break;
default: ASSERT_TRUE(0);
}
}
@@ -107,14 +107,14 @@
protected:
std::string file_name_;
FILE *input_file_;
- vpx_image_t *img_;
+ aom_image_t *img_;
size_t raw_size_;
unsigned int start_;
unsigned int limit_;
unsigned int frame_;
unsigned int width_;
unsigned int height_;
- vpx_img_fmt format_;
+ aom_img_fmt format_;
int framerate_numerator_;
int framerate_denominator_;
};
