Merge "Deduplicate some high bit depth tables"
diff --git a/.mailmap b/.mailmap
index 0bfda12..42f3617 100644
--- a/.mailmap
+++ b/.mailmap
@@ -1,14 +1,21 @@
Adrian Grange <agrange@google.com>
-Alex Converse <aconverse@google.com> <alex.converse@gmail.com>
+Adrian Grange <agrange@google.com> <agrange@agrange-macbookpro.roam.corp.google.com>
+Aℓex Converse <aconverse@google.com>
+Aℓex Converse <aconverse@google.com> <alex.converse@gmail.com>
Alexis Ballier <aballier@gentoo.org> <alexis.ballier@gmail.com>
Alpha Lam <hclam@google.com> <hclam@chromium.org>
Deb Mukherjee <debargha@google.com>
Erik Niemeyer <erik.a.niemeyer@intel.com> <erik.a.niemeyer@gmail.com>
Guillaume Martres <gmartres@google.com> <smarter3@gmail.com>
Hangyu Kuang <hkuang@google.com>
+Hangyu Kuang <hkuang@google.com> <hkuang@hkuang-macbookpro.roam.corp.google.com>
+Hui Su <huisu@google.com>
+Jacky Chen <jackychen@google.com>
Jim Bankoski <jimbankoski@google.com>
Johann Koenig <johannkoenig@google.com>
Johann Koenig <johannkoenig@google.com> <johann.koenig@duck.com>
+Johann Koenig <johannkoenig@google.com> <johannkoenig@dhcp-172-19-7-52.mtv.corp.google.com>
+Johann Koenig <johannkoenig@google.com> <johann.koenig@gmail.com>
John Koleszar <jkoleszar@google.com>
Joshua Litt <joshualitt@google.com> <joshualitt@chromium.org>
Marco Paniconi <marpan@google.com>
@@ -17,10 +24,13 @@
Paul Wilkins <paulwilkins@google.com>
Ralph Giles <giles@xiph.org> <giles@entropywave.com>
Ralph Giles <giles@xiph.org> <giles@mozilla.com>
+Ronald S. Bultje <rsbultje@gmail.com> <rbultje@google.com>
Sami Pietilä <samipietila@google.com>
Tamar Levy <tamar.levy@intel.com>
Tamar Levy <tamar.levy@intel.com> <levytamar82@gmail.com>
Tero Rintaluoma <teror@google.com> <tero.rintaluoma@on2.com>
Timothy B. Terriberry <tterribe@xiph.org> Tim Terriberry <tterriberry@mozilla.com>
Tom Finegan <tomfinegan@google.com>
+Tom Finegan <tomfinegan@google.com> <tomfinegan@chromium.org>
Yaowu Xu <yaowu@google.com> <yaowu@xuyaowu.com>
+Yaowu Xu <yaowu@google.com> <yaowu@YAOWU2-W.ad.corp.google.com>
diff --git a/AUTHORS b/AUTHORS
index 2f63d7c..f89b677 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -5,9 +5,9 @@
Abo Talib Mahfoodh <ab.mahfoodh@gmail.com>
Adam Xu <adam@xuyaowu.com>
Adrian Grange <agrange@google.com>
+Aℓex Converse <aconverse@google.com>
Ahmad Sharif <asharif@google.com>
Alexander Voronov <avoronov@graphics.cs.msu.ru>
-Alex Converse <aconverse@google.com>
Alexis Ballier <aballier@gentoo.org>
Alok Ahuja <waveletcoeff@gmail.com>
Alpha Lam <hclam@google.com>
@@ -16,8 +16,10 @@
Andoni Morales Alastruey <ylatuya@gmail.com>
Andres Mejia <mcitadel@gmail.com>
Andrew Russell <anrussell@google.com>
+Angie Chiang <angiebird@google.com>
Aron Rosenberg <arosenberg@logitech.com>
Attila Nagy <attilanagy@google.com>
+Brion Vibber <bvibber@wikimedia.org>
changjun.yang <changjun.yang@intel.com>
Charles 'Buck' Krasic <ckrasic@google.com>
chm <chm@rock-chips.com>
@@ -27,6 +29,7 @@
Dim Temp <dimtemp0@gmail.com>
Dmitry Kovalev <dkovalev@google.com>
Dragan Mrdjan <dmrdjan@mips.com>
+Ed Baker <edward.baker@intel.com>
Ehsan Akhgari <ehsan.akhgari@gmail.com>
Erik Niemeyer <erik.a.niemeyer@intel.com>
Fabio Pedretti <fabio.ped@libero.it>
@@ -34,6 +37,8 @@
Fredrik Söderquist <fs@opera.com>
Fritz Koenig <frkoenig@google.com>
Gaute Strokkenes <gaute.strokkenes@broadcom.com>
+Geza Lore <gezalore@gmail.com>
+Ghislain MARY <ghislainmary2@gmail.com>
Giuseppe Scrivano <gscrivano@gnu.org>
Gordana Cmiljanovic <gordana.cmiljanovic@imgtec.com>
Guillaume Martres <gmartres@google.com>
@@ -44,7 +49,7 @@
Hui Su <huisu@google.com>
Ivan Maltz <ivanmaltz@google.com>
Jacek Caban <cjacek@gmail.com>
-JackyChen <jackychen@google.com>
+Jacky Chen <jackychen@google.com>
James Berry <jamesberry@google.com>
James Yu <james.yu@linaro.org>
James Zern <jzern@google.com>
@@ -60,9 +65,11 @@
Joey Parrish <joeyparrish@google.com>
Johann Koenig <johannkoenig@google.com>
John Koleszar <jkoleszar@google.com>
+Johnny Klonaris <google@jawknee.com>
John Stark <jhnstrk@gmail.com>
Joshua Bleecher Snyder <josh@treelinelabs.com>
Joshua Litt <joshualitt@google.com>
+Julia Robson <juliamrobson@gmail.com>
Justin Clift <justin@salasaga.org>
Justin Lebar <justin.lebar@gmail.com>
KO Myung-Hun <komh@chollian.net>
@@ -82,6 +89,7 @@
Mikhal Shemer <mikhal@google.com>
Minghai Shang <minghai@google.com>
Morton Jonuschat <yabawock@gmail.com>
+Nico Weber <thakis@chromium.org>
Parag Salasakar <img.mips1@gmail.com>
Pascal Massimino <pascal.massimino@gmail.com>
Patrik Westin <patrik.westin@gmail.com>
@@ -96,7 +104,7 @@
Rafaël Carré <funman@videolan.org>
Ralph Giles <giles@xiph.org>
Rob Bradford <rob@linux.intel.com>
-Ronald S. Bultje <rbultje@google.com>
+Ronald S. Bultje <rsbultje@gmail.com>
Rui Ueyama <ruiu@google.com>
Sami Pietilä <samipietila@google.com>
Scott Graham <scottmg@chromium.org>
@@ -104,6 +112,7 @@
Sean McGovern <gseanmcg@gmail.com>
Sergey Ulanov <sergeyu@chromium.org>
Shimon Doodkin <helpmepro1@gmail.com>
+Shunyao Li <shunyaoli@google.com>
Stefan Holmer <holmer@google.com>
Suman Sunkara <sunkaras@google.com>
Taekhyun Kim <takim@nvidia.com>
diff --git a/CHANGELOG b/CHANGELOG
index b0d3064..7746cc6 100644
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -1,7 +1,19 @@
-xxxx-yy-zz v1.4.0 "Changes for next release"
- vpxenc is changed to use VP9 by default.
- Encoder controls added for 1 pass SVC.
- Decoder control to toggle on/off loopfilter.
+2015-11-09 v1.5.0 "Javan Whistling Duck"
+ This release improves upon the VP9 encoder and speeds up the encoding and
+ decoding processes.
+
+ - Upgrading:
+ This release is ABI incompatible with 1.4.0. It drops deprecated VP8
+ controls and adds a variety of VP9 controls for testing.
+
+ The vpxenc utility now prefers VP9 by default.
+
+ - Enhancements:
+ Faster VP9 encoding and decoding
+ Smaller library size by combining functions used by VP8 and VP9
+
+ - Bug Fixes:
+ A variety of fuzzing issues
2015-04-03 v1.4.0 "Indian Runner Duck"
This release includes significant improvements to the VP9 codec.
diff --git a/libs.mk b/libs.mk
index c65df6b..e6fb068 100644
--- a/libs.mk
+++ b/libs.mk
@@ -260,7 +260,7 @@
LIBS-$(if yes,$(CONFIG_STATIC)) += $(BUILD_PFX)libvpx.a $(BUILD_PFX)libvpx_g.a
$(BUILD_PFX)libvpx_g.a: $(LIBVPX_OBJS)
-SO_VERSION_MAJOR := 2
+SO_VERSION_MAJOR := 3
SO_VERSION_MINOR := 0
SO_VERSION_PATCH := 0
ifeq ($(filter darwin%,$(TGT_OS)),$(TGT_OS))
@@ -429,12 +429,10 @@
if [ -n "$${sha1sum}" ]; then\
set -e;\
echo "Checking test data:";\
- if [ -n "$(LIBVPX_TEST_DATA)" ]; then\
- for f in $(call enabled,LIBVPX_TEST_DATA); do\
- grep $$f $(SRC_PATH_BARE)/test/test-data.sha1 |\
- (cd $(LIBVPX_TEST_DATA_PATH); $${sha1sum} -c);\
- done; \
- fi; \
+ for f in $(call enabled,LIBVPX_TEST_DATA); do\
+ grep $$f $(SRC_PATH_BARE)/test/test-data.sha1 |\
+ (cd $(LIBVPX_TEST_DATA_PATH); $${sha1sum} -c);\
+ done; \
else\
echo "Skipping test data integrity check, sha1sum not found.";\
fi
diff --git a/test/datarate_test.cc b/test/datarate_test.cc
index b6cae79..cec6d09 100644
--- a/test/datarate_test.cc
+++ b/test/datarate_test.cc
@@ -538,7 +538,7 @@
<< " The first dropped frame for drop_thresh " << i
<< " > first dropped frame for drop_thresh "
<< i - kDropFrameThreshTestStep;
- ASSERT_GE(num_drops_, last_num_drops * 0.90)
+ ASSERT_GE(num_drops_, last_num_drops * 0.85)
<< " The number of dropped frames for drop_thresh " << i
<< " < number of dropped frames for drop_thresh "
<< i - kDropFrameThreshTestStep;
@@ -770,7 +770,7 @@
::libvpx_test::Encoder *encoder) {
if (video->frame() == 0) {
int i;
- for (i = 0; i < 2; ++i) {
+ for (i = 0; i < VPX_MAX_LAYERS; ++i) {
svc_params_.max_quantizers[i] = 63;
svc_params_.min_quantizers[i] = 0;
}
diff --git a/test/resize_test.cc b/test/resize_test.cc
index 98b6f87..bc91fe2 100644
--- a/test/resize_test.cc
+++ b/test/resize_test.cc
@@ -286,11 +286,11 @@
ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
}
-class ResizeInternalRealtimeTest : public ::libvpx_test::EncoderTest,
+class ResizeRealtimeTest : public ::libvpx_test::EncoderTest,
public ::libvpx_test::CodecTestWith2Params<libvpx_test::TestMode, int> {
protected:
- ResizeInternalRealtimeTest() : EncoderTest(GET_PARAM(0)) {}
- virtual ~ResizeInternalRealtimeTest() {}
+ ResizeRealtimeTest() : EncoderTest(GET_PARAM(0)) {}
+ virtual ~ResizeRealtimeTest() {}
virtual void PreEncodeFrameHook(libvpx_test::VideoSource *video,
libvpx_test::Encoder *encoder) {
@@ -318,8 +318,6 @@
}
void DefaultConfig() {
- cfg_.g_w = 352;
- cfg_.g_h = 288;
cfg_.rc_buf_initial_sz = 500;
cfg_.rc_buf_optimal_sz = 600;
cfg_.rc_buf_sz = 1000;
@@ -346,13 +344,34 @@
bool change_bitrate_;
};
+TEST_P(ResizeRealtimeTest, TestExternalResizeWorks) {
+ ResizingVideoSource video;
+ DefaultConfig();
+ change_bitrate_ = false;
+ ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
+
+ for (std::vector<FrameInfo>::const_iterator info = frame_info_list_.begin();
+ info != frame_info_list_.end(); ++info) {
+ const unsigned int frame = static_cast<unsigned>(info->pts);
+ const unsigned int expected_w = ScaleForFrameNumber(frame, kInitialWidth);
+ const unsigned int expected_h = ScaleForFrameNumber(frame, kInitialHeight);
+
+ EXPECT_EQ(expected_w, info->w)
+ << "Frame " << frame << " had unexpected width";
+ EXPECT_EQ(expected_h, info->h)
+ << "Frame " << frame << " had unexpected height";
+ }
+}
+
// Verify the dynamic resizer behavior for real time, 1 pass CBR mode.
// Run at low bitrate, with resize_allowed = 1, and verify that we get
// one resize down event.
-TEST_P(ResizeInternalRealtimeTest, TestInternalResizeDown) {
+TEST_P(ResizeRealtimeTest, TestInternalResizeDown) {
::libvpx_test::I420VideoSource video("hantro_collage_w352h288.yuv", 352, 288,
30, 1, 0, 299);
DefaultConfig();
+ cfg_.g_w = 352;
+ cfg_.g_h = 288;
change_bitrate_ = false;
ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
@@ -378,15 +397,17 @@
// Verify the dynamic resizer behavior for real time, 1 pass CBR mode.
// Start at low target bitrate, raise the bitrate in the middle of the clip,
// scaling-up should occur after bitrate changed.
-TEST_P(ResizeInternalRealtimeTest, TestInternalResizeDownUpChangeBitRate) {
+TEST_P(ResizeRealtimeTest, TestInternalResizeDownUpChangeBitRate) {
::libvpx_test::I420VideoSource video("hantro_collage_w352h288.yuv", 352, 288,
- 30, 1, 0, 299);
+ 30, 1, 0, 359);
DefaultConfig();
+ cfg_.g_w = 352;
+ cfg_.g_h = 288;
change_bitrate_ = true;
// Disable dropped frames.
cfg_.rc_dropframe_thresh = 0;
// Starting bitrate low.
- cfg_.rc_target_bitrate = 100;
+ cfg_.rc_target_bitrate = 80;
ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
unsigned int last_w = cfg_.g_w;
@@ -411,7 +432,7 @@
}
// Verify that we get 2 resize events in this test.
- ASSERT_EQ(2, resize_count) << "Resizing should occur twice.";
+ ASSERT_EQ(resize_count, 2) << "Resizing should occur twice.";
}
vpx_img_fmt_t CspForFrameNumber(int frame) {
@@ -524,7 +545,7 @@
::testing::Values(::libvpx_test::kRealTime));
VP9_INSTANTIATE_TEST_CASE(ResizeInternalTest,
::testing::Values(::libvpx_test::kOnePassBest));
-VP9_INSTANTIATE_TEST_CASE(ResizeInternalRealtimeTest,
+VP9_INSTANTIATE_TEST_CASE(ResizeRealtimeTest,
::testing::Values(::libvpx_test::kRealTime),
::testing::Range(5, 9));
VP9_INSTANTIATE_TEST_CASE(ResizeCspTest,
diff --git a/test/sad_test.cc b/test/sad_test.cc
index e6a5e0b..9dec3cb 100644
--- a/test/sad_test.cc
+++ b/test/sad_test.cc
@@ -484,260 +484,176 @@
//------------------------------------------------------------------------------
// C functions
-const SadMxNFunc sad64x64_c = vpx_sad64x64_c;
-const SadMxNFunc sad64x32_c = vpx_sad64x32_c;
-const SadMxNFunc sad32x64_c = vpx_sad32x64_c;
-const SadMxNFunc sad32x32_c = vpx_sad32x32_c;
-const SadMxNFunc sad32x16_c = vpx_sad32x16_c;
-const SadMxNFunc sad16x32_c = vpx_sad16x32_c;
-const SadMxNFunc sad16x16_c = vpx_sad16x16_c;
-const SadMxNFunc sad16x8_c = vpx_sad16x8_c;
-const SadMxNFunc sad8x16_c = vpx_sad8x16_c;
-const SadMxNFunc sad8x8_c = vpx_sad8x8_c;
-const SadMxNFunc sad8x4_c = vpx_sad8x4_c;
-const SadMxNFunc sad4x8_c = vpx_sad4x8_c;
-const SadMxNFunc sad4x4_c = vpx_sad4x4_c;
-#if CONFIG_VP9_HIGHBITDEPTH
-const SadMxNFunc highbd_sad64x64_c = vpx_highbd_sad64x64_c;
-const SadMxNFunc highbd_sad64x32_c = vpx_highbd_sad64x32_c;
-const SadMxNFunc highbd_sad32x64_c = vpx_highbd_sad32x64_c;
-const SadMxNFunc highbd_sad32x32_c = vpx_highbd_sad32x32_c;
-const SadMxNFunc highbd_sad32x16_c = vpx_highbd_sad32x16_c;
-const SadMxNFunc highbd_sad16x32_c = vpx_highbd_sad16x32_c;
-const SadMxNFunc highbd_sad16x16_c = vpx_highbd_sad16x16_c;
-const SadMxNFunc highbd_sad16x8_c = vpx_highbd_sad16x8_c;
-const SadMxNFunc highbd_sad8x16_c = vpx_highbd_sad8x16_c;
-const SadMxNFunc highbd_sad8x8_c = vpx_highbd_sad8x8_c;
-const SadMxNFunc highbd_sad8x4_c = vpx_highbd_sad8x4_c;
-const SadMxNFunc highbd_sad4x8_c = vpx_highbd_sad4x8_c;
-const SadMxNFunc highbd_sad4x4_c = vpx_highbd_sad4x4_c;
-#endif // CONFIG_VP9_HIGHBITDEPTH
const SadMxNParam c_tests[] = {
- make_tuple(64, 64, sad64x64_c, -1),
- make_tuple(64, 32, sad64x32_c, -1),
- make_tuple(32, 64, sad32x64_c, -1),
- make_tuple(32, 32, sad32x32_c, -1),
- make_tuple(32, 16, sad32x16_c, -1),
- make_tuple(16, 32, sad16x32_c, -1),
- make_tuple(16, 16, sad16x16_c, -1),
- make_tuple(16, 8, sad16x8_c, -1),
- make_tuple(8, 16, sad8x16_c, -1),
- make_tuple(8, 8, sad8x8_c, -1),
- make_tuple(8, 4, sad8x4_c, -1),
- make_tuple(4, 8, sad4x8_c, -1),
- make_tuple(4, 4, sad4x4_c, -1),
+ 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
- make_tuple(64, 64, highbd_sad64x64_c, 8),
- make_tuple(64, 32, highbd_sad64x32_c, 8),
- make_tuple(32, 64, highbd_sad32x64_c, 8),
- make_tuple(32, 32, highbd_sad32x32_c, 8),
- make_tuple(32, 16, highbd_sad32x16_c, 8),
- make_tuple(16, 32, highbd_sad16x32_c, 8),
- make_tuple(16, 16, highbd_sad16x16_c, 8),
- make_tuple(16, 8, highbd_sad16x8_c, 8),
- make_tuple(8, 16, highbd_sad8x16_c, 8),
- make_tuple(8, 8, highbd_sad8x8_c, 8),
- make_tuple(8, 4, highbd_sad8x4_c, 8),
- make_tuple(4, 8, highbd_sad4x8_c, 8),
- make_tuple(4, 4, highbd_sad4x4_c, 8),
- make_tuple(64, 64, highbd_sad64x64_c, 10),
- make_tuple(64, 32, highbd_sad64x32_c, 10),
- make_tuple(32, 64, highbd_sad32x64_c, 10),
- make_tuple(32, 32, highbd_sad32x32_c, 10),
- make_tuple(32, 16, highbd_sad32x16_c, 10),
- make_tuple(16, 32, highbd_sad16x32_c, 10),
- make_tuple(16, 16, highbd_sad16x16_c, 10),
- make_tuple(16, 8, highbd_sad16x8_c, 10),
- make_tuple(8, 16, highbd_sad8x16_c, 10),
- make_tuple(8, 8, highbd_sad8x8_c, 10),
- make_tuple(8, 4, highbd_sad8x4_c, 10),
- make_tuple(4, 8, highbd_sad4x8_c, 10),
- make_tuple(4, 4, highbd_sad4x4_c, 10),
- make_tuple(64, 64, highbd_sad64x64_c, 12),
- make_tuple(64, 32, highbd_sad64x32_c, 12),
- make_tuple(32, 64, highbd_sad32x64_c, 12),
- make_tuple(32, 32, highbd_sad32x32_c, 12),
- make_tuple(32, 16, highbd_sad32x16_c, 12),
- make_tuple(16, 32, highbd_sad16x32_c, 12),
- make_tuple(16, 16, highbd_sad16x16_c, 12),
- make_tuple(16, 8, highbd_sad16x8_c, 12),
- make_tuple(8, 16, highbd_sad8x16_c, 12),
- make_tuple(8, 8, highbd_sad8x8_c, 12),
- make_tuple(8, 4, highbd_sad8x4_c, 12),
- make_tuple(4, 8, highbd_sad4x8_c, 12),
- make_tuple(4, 4, highbd_sad4x4_c, 12),
+ 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),
+ 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),
+ 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
};
INSTANTIATE_TEST_CASE_P(C, SADTest, ::testing::ValuesIn(c_tests));
-const SadMxNAvgFunc sad64x64_avg_c = vpx_sad64x64_avg_c;
-const SadMxNAvgFunc sad64x32_avg_c = vpx_sad64x32_avg_c;
-const SadMxNAvgFunc sad32x64_avg_c = vpx_sad32x64_avg_c;
-const SadMxNAvgFunc sad32x32_avg_c = vpx_sad32x32_avg_c;
-const SadMxNAvgFunc sad32x16_avg_c = vpx_sad32x16_avg_c;
-const SadMxNAvgFunc sad16x32_avg_c = vpx_sad16x32_avg_c;
-const SadMxNAvgFunc sad16x16_avg_c = vpx_sad16x16_avg_c;
-const SadMxNAvgFunc sad16x8_avg_c = vpx_sad16x8_avg_c;
-const SadMxNAvgFunc sad8x16_avg_c = vpx_sad8x16_avg_c;
-const SadMxNAvgFunc sad8x8_avg_c = vpx_sad8x8_avg_c;
-const SadMxNAvgFunc sad8x4_avg_c = vpx_sad8x4_avg_c;
-const SadMxNAvgFunc sad4x8_avg_c = vpx_sad4x8_avg_c;
-const SadMxNAvgFunc sad4x4_avg_c = vpx_sad4x4_avg_c;
-#if CONFIG_VP9_HIGHBITDEPTH
-const SadMxNAvgFunc highbd_sad64x64_avg_c = vpx_highbd_sad64x64_avg_c;
-const SadMxNAvgFunc highbd_sad64x32_avg_c = vpx_highbd_sad64x32_avg_c;
-const SadMxNAvgFunc highbd_sad32x64_avg_c = vpx_highbd_sad32x64_avg_c;
-const SadMxNAvgFunc highbd_sad32x32_avg_c = vpx_highbd_sad32x32_avg_c;
-const SadMxNAvgFunc highbd_sad32x16_avg_c = vpx_highbd_sad32x16_avg_c;
-const SadMxNAvgFunc highbd_sad16x32_avg_c = vpx_highbd_sad16x32_avg_c;
-const SadMxNAvgFunc highbd_sad16x16_avg_c = vpx_highbd_sad16x16_avg_c;
-const SadMxNAvgFunc highbd_sad16x8_avg_c = vpx_highbd_sad16x8_avg_c;
-const SadMxNAvgFunc highbd_sad8x16_avg_c = vpx_highbd_sad8x16_avg_c;
-const SadMxNAvgFunc highbd_sad8x8_avg_c = vpx_highbd_sad8x8_avg_c;
-const SadMxNAvgFunc highbd_sad8x4_avg_c = vpx_highbd_sad8x4_avg_c;
-const SadMxNAvgFunc highbd_sad4x8_avg_c = vpx_highbd_sad4x8_avg_c;
-const SadMxNAvgFunc highbd_sad4x4_avg_c = vpx_highbd_sad4x4_avg_c;
-#endif // CONFIG_VP9_HIGHBITDEPTH
const SadMxNAvgParam avg_c_tests[] = {
- make_tuple(64, 64, sad64x64_avg_c, -1),
- make_tuple(64, 32, sad64x32_avg_c, -1),
- make_tuple(32, 64, sad32x64_avg_c, -1),
- make_tuple(32, 32, sad32x32_avg_c, -1),
- make_tuple(32, 16, sad32x16_avg_c, -1),
- make_tuple(16, 32, sad16x32_avg_c, -1),
- make_tuple(16, 16, sad16x16_avg_c, -1),
- make_tuple(16, 8, sad16x8_avg_c, -1),
- make_tuple(8, 16, sad8x16_avg_c, -1),
- make_tuple(8, 8, sad8x8_avg_c, -1),
- make_tuple(8, 4, sad8x4_avg_c, -1),
- make_tuple(4, 8, sad4x8_avg_c, -1),
- make_tuple(4, 4, sad4x4_avg_c, -1),
+ 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
- make_tuple(64, 64, highbd_sad64x64_avg_c, 8),
- make_tuple(64, 32, highbd_sad64x32_avg_c, 8),
- make_tuple(32, 64, highbd_sad32x64_avg_c, 8),
- make_tuple(32, 32, highbd_sad32x32_avg_c, 8),
- make_tuple(32, 16, highbd_sad32x16_avg_c, 8),
- make_tuple(16, 32, highbd_sad16x32_avg_c, 8),
- make_tuple(16, 16, highbd_sad16x16_avg_c, 8),
- make_tuple(16, 8, highbd_sad16x8_avg_c, 8),
- make_tuple(8, 16, highbd_sad8x16_avg_c, 8),
- make_tuple(8, 8, highbd_sad8x8_avg_c, 8),
- make_tuple(8, 4, highbd_sad8x4_avg_c, 8),
- make_tuple(4, 8, highbd_sad4x8_avg_c, 8),
- make_tuple(4, 4, highbd_sad4x4_avg_c, 8),
- make_tuple(64, 64, highbd_sad64x64_avg_c, 10),
- make_tuple(64, 32, highbd_sad64x32_avg_c, 10),
- make_tuple(32, 64, highbd_sad32x64_avg_c, 10),
- make_tuple(32, 32, highbd_sad32x32_avg_c, 10),
- make_tuple(32, 16, highbd_sad32x16_avg_c, 10),
- make_tuple(16, 32, highbd_sad16x32_avg_c, 10),
- make_tuple(16, 16, highbd_sad16x16_avg_c, 10),
- make_tuple(16, 8, highbd_sad16x8_avg_c, 10),
- make_tuple(8, 16, highbd_sad8x16_avg_c, 10),
- make_tuple(8, 8, highbd_sad8x8_avg_c, 10),
- make_tuple(8, 4, highbd_sad8x4_avg_c, 10),
- make_tuple(4, 8, highbd_sad4x8_avg_c, 10),
- make_tuple(4, 4, highbd_sad4x4_avg_c, 10),
- make_tuple(64, 64, highbd_sad64x64_avg_c, 12),
- make_tuple(64, 32, highbd_sad64x32_avg_c, 12),
- make_tuple(32, 64, highbd_sad32x64_avg_c, 12),
- make_tuple(32, 32, highbd_sad32x32_avg_c, 12),
- make_tuple(32, 16, highbd_sad32x16_avg_c, 12),
- make_tuple(16, 32, highbd_sad16x32_avg_c, 12),
- make_tuple(16, 16, highbd_sad16x16_avg_c, 12),
- make_tuple(16, 8, highbd_sad16x8_avg_c, 12),
- make_tuple(8, 16, highbd_sad8x16_avg_c, 12),
- make_tuple(8, 8, highbd_sad8x8_avg_c, 12),
- make_tuple(8, 4, highbd_sad8x4_avg_c, 12),
- make_tuple(4, 8, highbd_sad4x8_avg_c, 12),
- make_tuple(4, 4, highbd_sad4x4_avg_c, 12),
+ 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),
+ 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),
+ 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
};
INSTANTIATE_TEST_CASE_P(C, SADavgTest, ::testing::ValuesIn(avg_c_tests));
-const SadMxNx4Func sad64x64x4d_c = vpx_sad64x64x4d_c;
-const SadMxNx4Func sad64x32x4d_c = vpx_sad64x32x4d_c;
-const SadMxNx4Func sad32x64x4d_c = vpx_sad32x64x4d_c;
-const SadMxNx4Func sad32x32x4d_c = vpx_sad32x32x4d_c;
-const SadMxNx4Func sad32x16x4d_c = vpx_sad32x16x4d_c;
-const SadMxNx4Func sad16x32x4d_c = vpx_sad16x32x4d_c;
-const SadMxNx4Func sad16x16x4d_c = vpx_sad16x16x4d_c;
-const SadMxNx4Func sad16x8x4d_c = vpx_sad16x8x4d_c;
-const SadMxNx4Func sad8x16x4d_c = vpx_sad8x16x4d_c;
-const SadMxNx4Func sad8x8x4d_c = vpx_sad8x8x4d_c;
-const SadMxNx4Func sad8x4x4d_c = vpx_sad8x4x4d_c;
-const SadMxNx4Func sad4x8x4d_c = vpx_sad4x8x4d_c;
-const SadMxNx4Func sad4x4x4d_c = vpx_sad4x4x4d_c;
-#if CONFIG_VP9_HIGHBITDEPTH
-const SadMxNx4Func highbd_sad64x64x4d_c = vpx_highbd_sad64x64x4d_c;
-const SadMxNx4Func highbd_sad64x32x4d_c = vpx_highbd_sad64x32x4d_c;
-const SadMxNx4Func highbd_sad32x64x4d_c = vpx_highbd_sad32x64x4d_c;
-const SadMxNx4Func highbd_sad32x32x4d_c = vpx_highbd_sad32x32x4d_c;
-const SadMxNx4Func highbd_sad32x16x4d_c = vpx_highbd_sad32x16x4d_c;
-const SadMxNx4Func highbd_sad16x32x4d_c = vpx_highbd_sad16x32x4d_c;
-const SadMxNx4Func highbd_sad16x16x4d_c = vpx_highbd_sad16x16x4d_c;
-const SadMxNx4Func highbd_sad16x8x4d_c = vpx_highbd_sad16x8x4d_c;
-const SadMxNx4Func highbd_sad8x16x4d_c = vpx_highbd_sad8x16x4d_c;
-const SadMxNx4Func highbd_sad8x8x4d_c = vpx_highbd_sad8x8x4d_c;
-const SadMxNx4Func highbd_sad8x4x4d_c = vpx_highbd_sad8x4x4d_c;
-const SadMxNx4Func highbd_sad4x8x4d_c = vpx_highbd_sad4x8x4d_c;
-const SadMxNx4Func highbd_sad4x4x4d_c = vpx_highbd_sad4x4x4d_c;
-#endif // CONFIG_VP9_HIGHBITDEPTH
const SadMxNx4Param x4d_c_tests[] = {
- make_tuple(64, 64, sad64x64x4d_c, -1),
- make_tuple(64, 32, sad64x32x4d_c, -1),
- make_tuple(32, 64, sad32x64x4d_c, -1),
- make_tuple(32, 32, sad32x32x4d_c, -1),
- make_tuple(32, 16, sad32x16x4d_c, -1),
- make_tuple(16, 32, sad16x32x4d_c, -1),
- make_tuple(16, 16, sad16x16x4d_c, -1),
- make_tuple(16, 8, sad16x8x4d_c, -1),
- make_tuple(8, 16, sad8x16x4d_c, -1),
- make_tuple(8, 8, sad8x8x4d_c, -1),
- make_tuple(8, 4, sad8x4x4d_c, -1),
- make_tuple(4, 8, sad4x8x4d_c, -1),
- make_tuple(4, 4, sad4x4x4d_c, -1),
+ 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
- make_tuple(64, 64, highbd_sad64x64x4d_c, 8),
- make_tuple(64, 32, highbd_sad64x32x4d_c, 8),
- make_tuple(32, 64, highbd_sad32x64x4d_c, 8),
- make_tuple(32, 32, highbd_sad32x32x4d_c, 8),
- make_tuple(32, 16, highbd_sad32x16x4d_c, 8),
- make_tuple(16, 32, highbd_sad16x32x4d_c, 8),
- make_tuple(16, 16, highbd_sad16x16x4d_c, 8),
- make_tuple(16, 8, highbd_sad16x8x4d_c, 8),
- make_tuple(8, 16, highbd_sad8x16x4d_c, 8),
- make_tuple(8, 8, highbd_sad8x8x4d_c, 8),
- make_tuple(8, 4, highbd_sad8x4x4d_c, 8),
- make_tuple(4, 8, highbd_sad4x8x4d_c, 8),
- make_tuple(4, 4, highbd_sad4x4x4d_c, 8),
- make_tuple(64, 64, highbd_sad64x64x4d_c, 10),
- make_tuple(64, 32, highbd_sad64x32x4d_c, 10),
- make_tuple(32, 64, highbd_sad32x64x4d_c, 10),
- make_tuple(32, 32, highbd_sad32x32x4d_c, 10),
- make_tuple(32, 16, highbd_sad32x16x4d_c, 10),
- make_tuple(16, 32, highbd_sad16x32x4d_c, 10),
- make_tuple(16, 16, highbd_sad16x16x4d_c, 10),
- make_tuple(16, 8, highbd_sad16x8x4d_c, 10),
- make_tuple(8, 16, highbd_sad8x16x4d_c, 10),
- make_tuple(8, 8, highbd_sad8x8x4d_c, 10),
- make_tuple(8, 4, highbd_sad8x4x4d_c, 10),
- make_tuple(4, 8, highbd_sad4x8x4d_c, 10),
- make_tuple(4, 4, highbd_sad4x4x4d_c, 10),
- make_tuple(64, 64, highbd_sad64x64x4d_c, 12),
- make_tuple(64, 32, highbd_sad64x32x4d_c, 12),
- make_tuple(32, 64, highbd_sad32x64x4d_c, 12),
- make_tuple(32, 32, highbd_sad32x32x4d_c, 12),
- make_tuple(32, 16, highbd_sad32x16x4d_c, 12),
- make_tuple(16, 32, highbd_sad16x32x4d_c, 12),
- make_tuple(16, 16, highbd_sad16x16x4d_c, 12),
- make_tuple(16, 8, highbd_sad16x8x4d_c, 12),
- make_tuple(8, 16, highbd_sad8x16x4d_c, 12),
- make_tuple(8, 8, highbd_sad8x8x4d_c, 12),
- make_tuple(8, 4, highbd_sad8x4x4d_c, 12),
- make_tuple(4, 8, highbd_sad4x8x4d_c, 12),
- make_tuple(4, 4, highbd_sad4x4x4d_c, 12),
+ 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),
+ 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),
+ 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
};
INSTANTIATE_TEST_CASE_P(C, SADx4Test, ::testing::ValuesIn(x4d_c_tests));
@@ -745,40 +661,28 @@
//------------------------------------------------------------------------------
// ARM functions
#if HAVE_MEDIA
-const SadMxNFunc sad16x16_media = vpx_sad16x16_media;
const SadMxNParam media_tests[] = {
- make_tuple(16, 16, sad16x16_media, -1),
+ make_tuple(16, 16, &vpx_sad16x16_media, -1),
};
INSTANTIATE_TEST_CASE_P(MEDIA, SADTest, ::testing::ValuesIn(media_tests));
#endif // HAVE_MEDIA
#if HAVE_NEON
-const SadMxNFunc sad64x64_neon = vpx_sad64x64_neon;
-const SadMxNFunc sad32x32_neon = vpx_sad32x32_neon;
-const SadMxNFunc sad16x16_neon = vpx_sad16x16_neon;
-const SadMxNFunc sad16x8_neon = vpx_sad16x8_neon;
-const SadMxNFunc sad8x16_neon = vpx_sad8x16_neon;
-const SadMxNFunc sad8x8_neon = vpx_sad8x8_neon;
-const SadMxNFunc sad4x4_neon = vpx_sad4x4_neon;
-
const SadMxNParam neon_tests[] = {
- make_tuple(64, 64, sad64x64_neon, -1),
- make_tuple(32, 32, sad32x32_neon, -1),
- make_tuple(16, 16, sad16x16_neon, -1),
- make_tuple(16, 8, sad16x8_neon, -1),
- make_tuple(8, 16, sad8x16_neon, -1),
- make_tuple(8, 8, sad8x8_neon, -1),
- make_tuple(4, 4, sad4x4_neon, -1),
+ 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),
};
INSTANTIATE_TEST_CASE_P(NEON, SADTest, ::testing::ValuesIn(neon_tests));
-const SadMxNx4Func sad64x64x4d_neon = vpx_sad64x64x4d_neon;
-const SadMxNx4Func sad32x32x4d_neon = vpx_sad32x32x4d_neon;
-const SadMxNx4Func sad16x16x4d_neon = vpx_sad16x16x4d_neon;
const SadMxNx4Param x4d_neon_tests[] = {
- make_tuple(64, 64, sad64x64x4d_neon, -1),
- make_tuple(32, 32, sad32x32x4d_neon, -1),
- make_tuple(16, 16, sad16x16x4d_neon, -1),
+ make_tuple(64, 64, &vpx_sad64x64x4d_neon, -1),
+ make_tuple(32, 32, &vpx_sad32x32x4d_neon, -1),
+ make_tuple(16, 16, &vpx_sad16x16x4d_neon, -1),
};
INSTANTIATE_TEST_CASE_P(NEON, SADx4Test, ::testing::ValuesIn(x4d_neon_tests));
#endif // HAVE_NEON
@@ -786,44 +690,33 @@
//------------------------------------------------------------------------------
// x86 functions
#if HAVE_MMX
-const SadMxNFunc sad16x16_mmx = vpx_sad16x16_mmx;
-const SadMxNFunc sad16x8_mmx = vpx_sad16x8_mmx;
-const SadMxNFunc sad8x16_mmx = vpx_sad8x16_mmx;
-const SadMxNFunc sad8x8_mmx = vpx_sad8x8_mmx;
-const SadMxNFunc sad4x4_mmx = vpx_sad4x4_mmx;
const SadMxNParam mmx_tests[] = {
- make_tuple(16, 16, sad16x16_mmx, -1),
- make_tuple(16, 8, sad16x8_mmx, -1),
- make_tuple(8, 16, sad8x16_mmx, -1),
- make_tuple(8, 8, sad8x8_mmx, -1),
- make_tuple(4, 4, sad4x4_mmx, -1),
+ make_tuple(16, 16, &vpx_sad16x16_mmx, -1),
+ make_tuple(16, 8, &vpx_sad16x8_mmx, -1),
+ make_tuple(8, 16, &vpx_sad8x16_mmx, -1),
+ make_tuple(8, 8, &vpx_sad8x8_mmx, -1),
+ make_tuple(4, 4, &vpx_sad4x4_mmx, -1),
};
INSTANTIATE_TEST_CASE_P(MMX, SADTest, ::testing::ValuesIn(mmx_tests));
#endif // HAVE_MMX
#if HAVE_SSE
#if CONFIG_USE_X86INC
-const SadMxNFunc sad4x8_sse = vpx_sad4x8_sse;
-const SadMxNFunc sad4x4_sse = vpx_sad4x4_sse;
const SadMxNParam sse_tests[] = {
- make_tuple(4, 8, sad4x8_sse, -1),
- make_tuple(4, 4, sad4x4_sse, -1),
+ make_tuple(4, 8, &vpx_sad4x8_sse, -1),
+ make_tuple(4, 4, &vpx_sad4x4_sse, -1),
};
INSTANTIATE_TEST_CASE_P(SSE, SADTest, ::testing::ValuesIn(sse_tests));
-const SadMxNAvgFunc sad4x8_avg_sse = vpx_sad4x8_avg_sse;
-const SadMxNAvgFunc sad4x4_avg_sse = vpx_sad4x4_avg_sse;
const SadMxNAvgParam avg_sse_tests[] = {
- make_tuple(4, 8, sad4x8_avg_sse, -1),
- make_tuple(4, 4, sad4x4_avg_sse, -1),
+ make_tuple(4, 8, &vpx_sad4x8_avg_sse, -1),
+ make_tuple(4, 4, &vpx_sad4x4_avg_sse, -1),
};
INSTANTIATE_TEST_CASE_P(SSE, SADavgTest, ::testing::ValuesIn(avg_sse_tests));
-const SadMxNx4Func sad4x8x4d_sse = vpx_sad4x8x4d_sse;
-const SadMxNx4Func sad4x4x4d_sse = vpx_sad4x4x4d_sse;
const SadMxNx4Param x4d_sse_tests[] = {
- make_tuple(4, 8, sad4x8x4d_sse, -1),
- make_tuple(4, 4, sad4x4x4d_sse, -1),
+ make_tuple(4, 8, &vpx_sad4x8x4d_sse, -1),
+ make_tuple(4, 4, &vpx_sad4x4x4d_sse, -1),
};
INSTANTIATE_TEST_CASE_P(SSE, SADx4Test, ::testing::ValuesIn(x4d_sse_tests));
#endif // CONFIG_USE_X86INC
@@ -831,232 +724,158 @@
#if HAVE_SSE2
#if CONFIG_USE_X86INC
-const SadMxNFunc sad64x64_sse2 = vpx_sad64x64_sse2;
-const SadMxNFunc sad64x32_sse2 = vpx_sad64x32_sse2;
-const SadMxNFunc sad32x64_sse2 = vpx_sad32x64_sse2;
-const SadMxNFunc sad32x32_sse2 = vpx_sad32x32_sse2;
-const SadMxNFunc sad32x16_sse2 = vpx_sad32x16_sse2;
-const SadMxNFunc sad16x32_sse2 = vpx_sad16x32_sse2;
-const SadMxNFunc sad16x16_sse2 = vpx_sad16x16_sse2;
-const SadMxNFunc sad16x8_sse2 = vpx_sad16x8_sse2;
-const SadMxNFunc sad8x16_sse2 = vpx_sad8x16_sse2;
-const SadMxNFunc sad8x8_sse2 = vpx_sad8x8_sse2;
-const SadMxNFunc sad8x4_sse2 = vpx_sad8x4_sse2;
-#if CONFIG_VP9_HIGHBITDEPTH
-const SadMxNFunc highbd_sad64x64_sse2 = vpx_highbd_sad64x64_sse2;
-const SadMxNFunc highbd_sad64x32_sse2 = vpx_highbd_sad64x32_sse2;
-const SadMxNFunc highbd_sad32x64_sse2 = vpx_highbd_sad32x64_sse2;
-const SadMxNFunc highbd_sad32x32_sse2 = vpx_highbd_sad32x32_sse2;
-const SadMxNFunc highbd_sad32x16_sse2 = vpx_highbd_sad32x16_sse2;
-const SadMxNFunc highbd_sad16x32_sse2 = vpx_highbd_sad16x32_sse2;
-const SadMxNFunc highbd_sad16x16_sse2 = vpx_highbd_sad16x16_sse2;
-const SadMxNFunc highbd_sad16x8_sse2 = vpx_highbd_sad16x8_sse2;
-const SadMxNFunc highbd_sad8x16_sse2 = vpx_highbd_sad8x16_sse2;
-const SadMxNFunc highbd_sad8x8_sse2 = vpx_highbd_sad8x8_sse2;
-const SadMxNFunc highbd_sad8x4_sse2 = vpx_highbd_sad8x4_sse2;
-#endif // CONFIG_VP9_HIGHBITDEPTH
const SadMxNParam sse2_tests[] = {
- make_tuple(64, 64, sad64x64_sse2, -1),
- make_tuple(64, 32, sad64x32_sse2, -1),
- make_tuple(32, 64, sad32x64_sse2, -1),
- make_tuple(32, 32, sad32x32_sse2, -1),
- make_tuple(32, 16, sad32x16_sse2, -1),
- make_tuple(16, 32, sad16x32_sse2, -1),
- make_tuple(16, 16, sad16x16_sse2, -1),
- make_tuple(16, 8, sad16x8_sse2, -1),
- make_tuple(8, 16, sad8x16_sse2, -1),
- make_tuple(8, 8, sad8x8_sse2, -1),
- make_tuple(8, 4, sad8x4_sse2, -1),
+ 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),
#if CONFIG_VP9_HIGHBITDEPTH
- make_tuple(64, 64, highbd_sad64x64_sse2, 8),
- make_tuple(64, 32, highbd_sad64x32_sse2, 8),
- make_tuple(32, 64, highbd_sad32x64_sse2, 8),
- make_tuple(32, 32, highbd_sad32x32_sse2, 8),
- make_tuple(32, 16, highbd_sad32x16_sse2, 8),
- make_tuple(16, 32, highbd_sad16x32_sse2, 8),
- make_tuple(16, 16, highbd_sad16x16_sse2, 8),
- make_tuple(16, 8, highbd_sad16x8_sse2, 8),
- make_tuple(8, 16, highbd_sad8x16_sse2, 8),
- make_tuple(8, 8, highbd_sad8x8_sse2, 8),
- make_tuple(8, 4, highbd_sad8x4_sse2, 8),
- make_tuple(64, 64, highbd_sad64x64_sse2, 10),
- make_tuple(64, 32, highbd_sad64x32_sse2, 10),
- make_tuple(32, 64, highbd_sad32x64_sse2, 10),
- make_tuple(32, 32, highbd_sad32x32_sse2, 10),
- make_tuple(32, 16, highbd_sad32x16_sse2, 10),
- make_tuple(16, 32, highbd_sad16x32_sse2, 10),
- make_tuple(16, 16, highbd_sad16x16_sse2, 10),
- make_tuple(16, 8, highbd_sad16x8_sse2, 10),
- make_tuple(8, 16, highbd_sad8x16_sse2, 10),
- make_tuple(8, 8, highbd_sad8x8_sse2, 10),
- make_tuple(8, 4, highbd_sad8x4_sse2, 10),
- make_tuple(64, 64, highbd_sad64x64_sse2, 12),
- make_tuple(64, 32, highbd_sad64x32_sse2, 12),
- make_tuple(32, 64, highbd_sad32x64_sse2, 12),
- make_tuple(32, 32, highbd_sad32x32_sse2, 12),
- make_tuple(32, 16, highbd_sad32x16_sse2, 12),
- make_tuple(16, 32, highbd_sad16x32_sse2, 12),
- make_tuple(16, 16, highbd_sad16x16_sse2, 12),
- make_tuple(16, 8, highbd_sad16x8_sse2, 12),
- make_tuple(8, 16, highbd_sad8x16_sse2, 12),
- make_tuple(8, 8, highbd_sad8x8_sse2, 12),
- make_tuple(8, 4, highbd_sad8x4_sse2, 12),
+ 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
};
INSTANTIATE_TEST_CASE_P(SSE2, SADTest, ::testing::ValuesIn(sse2_tests));
-const SadMxNAvgFunc sad64x64_avg_sse2 = vpx_sad64x64_avg_sse2;
-const SadMxNAvgFunc sad64x32_avg_sse2 = vpx_sad64x32_avg_sse2;
-const SadMxNAvgFunc sad32x64_avg_sse2 = vpx_sad32x64_avg_sse2;
-const SadMxNAvgFunc sad32x32_avg_sse2 = vpx_sad32x32_avg_sse2;
-const SadMxNAvgFunc sad32x16_avg_sse2 = vpx_sad32x16_avg_sse2;
-const SadMxNAvgFunc sad16x32_avg_sse2 = vpx_sad16x32_avg_sse2;
-const SadMxNAvgFunc sad16x16_avg_sse2 = vpx_sad16x16_avg_sse2;
-const SadMxNAvgFunc sad16x8_avg_sse2 = vpx_sad16x8_avg_sse2;
-const SadMxNAvgFunc sad8x16_avg_sse2 = vpx_sad8x16_avg_sse2;
-const SadMxNAvgFunc sad8x8_avg_sse2 = vpx_sad8x8_avg_sse2;
-const SadMxNAvgFunc sad8x4_avg_sse2 = vpx_sad8x4_avg_sse2;
-#if CONFIG_VP9_HIGHBITDEPTH
-const SadMxNAvgFunc highbd_sad64x64_avg_sse2 = vpx_highbd_sad64x64_avg_sse2;
-const SadMxNAvgFunc highbd_sad64x32_avg_sse2 = vpx_highbd_sad64x32_avg_sse2;
-const SadMxNAvgFunc highbd_sad32x64_avg_sse2 = vpx_highbd_sad32x64_avg_sse2;
-const SadMxNAvgFunc highbd_sad32x32_avg_sse2 = vpx_highbd_sad32x32_avg_sse2;
-const SadMxNAvgFunc highbd_sad32x16_avg_sse2 = vpx_highbd_sad32x16_avg_sse2;
-const SadMxNAvgFunc highbd_sad16x32_avg_sse2 = vpx_highbd_sad16x32_avg_sse2;
-const SadMxNAvgFunc highbd_sad16x16_avg_sse2 = vpx_highbd_sad16x16_avg_sse2;
-const SadMxNAvgFunc highbd_sad16x8_avg_sse2 = vpx_highbd_sad16x8_avg_sse2;
-const SadMxNAvgFunc highbd_sad8x16_avg_sse2 = vpx_highbd_sad8x16_avg_sse2;
-const SadMxNAvgFunc highbd_sad8x8_avg_sse2 = vpx_highbd_sad8x8_avg_sse2;
-const SadMxNAvgFunc highbd_sad8x4_avg_sse2 = vpx_highbd_sad8x4_avg_sse2;
-#endif // CONFIG_VP9_HIGHBITDEPTH
const SadMxNAvgParam avg_sse2_tests[] = {
- make_tuple(64, 64, sad64x64_avg_sse2, -1),
- make_tuple(64, 32, sad64x32_avg_sse2, -1),
- make_tuple(32, 64, sad32x64_avg_sse2, -1),
- make_tuple(32, 32, sad32x32_avg_sse2, -1),
- make_tuple(32, 16, sad32x16_avg_sse2, -1),
- make_tuple(16, 32, sad16x32_avg_sse2, -1),
- make_tuple(16, 16, sad16x16_avg_sse2, -1),
- make_tuple(16, 8, sad16x8_avg_sse2, -1),
- make_tuple(8, 16, sad8x16_avg_sse2, -1),
- make_tuple(8, 8, sad8x8_avg_sse2, -1),
- make_tuple(8, 4, sad8x4_avg_sse2, -1),
+ 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),
#if CONFIG_VP9_HIGHBITDEPTH
- make_tuple(64, 64, highbd_sad64x64_avg_sse2, 8),
- make_tuple(64, 32, highbd_sad64x32_avg_sse2, 8),
- make_tuple(32, 64, highbd_sad32x64_avg_sse2, 8),
- make_tuple(32, 32, highbd_sad32x32_avg_sse2, 8),
- make_tuple(32, 16, highbd_sad32x16_avg_sse2, 8),
- make_tuple(16, 32, highbd_sad16x32_avg_sse2, 8),
- make_tuple(16, 16, highbd_sad16x16_avg_sse2, 8),
- make_tuple(16, 8, highbd_sad16x8_avg_sse2, 8),
- make_tuple(8, 16, highbd_sad8x16_avg_sse2, 8),
- make_tuple(8, 8, highbd_sad8x8_avg_sse2, 8),
- make_tuple(8, 4, highbd_sad8x4_avg_sse2, 8),
- make_tuple(64, 64, highbd_sad64x64_avg_sse2, 10),
- make_tuple(64, 32, highbd_sad64x32_avg_sse2, 10),
- make_tuple(32, 64, highbd_sad32x64_avg_sse2, 10),
- make_tuple(32, 32, highbd_sad32x32_avg_sse2, 10),
- make_tuple(32, 16, highbd_sad32x16_avg_sse2, 10),
- make_tuple(16, 32, highbd_sad16x32_avg_sse2, 10),
- make_tuple(16, 16, highbd_sad16x16_avg_sse2, 10),
- make_tuple(16, 8, highbd_sad16x8_avg_sse2, 10),
- make_tuple(8, 16, highbd_sad8x16_avg_sse2, 10),
- make_tuple(8, 8, highbd_sad8x8_avg_sse2, 10),
- make_tuple(8, 4, highbd_sad8x4_avg_sse2, 10),
- make_tuple(64, 64, highbd_sad64x64_avg_sse2, 12),
- make_tuple(64, 32, highbd_sad64x32_avg_sse2, 12),
- make_tuple(32, 64, highbd_sad32x64_avg_sse2, 12),
- make_tuple(32, 32, highbd_sad32x32_avg_sse2, 12),
- make_tuple(32, 16, highbd_sad32x16_avg_sse2, 12),
- make_tuple(16, 32, highbd_sad16x32_avg_sse2, 12),
- make_tuple(16, 16, highbd_sad16x16_avg_sse2, 12),
- make_tuple(16, 8, highbd_sad16x8_avg_sse2, 12),
- make_tuple(8, 16, highbd_sad8x16_avg_sse2, 12),
- make_tuple(8, 8, highbd_sad8x8_avg_sse2, 12),
- make_tuple(8, 4, highbd_sad8x4_avg_sse2, 12),
+ 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
};
INSTANTIATE_TEST_CASE_P(SSE2, SADavgTest, ::testing::ValuesIn(avg_sse2_tests));
-const SadMxNx4Func sad64x64x4d_sse2 = vpx_sad64x64x4d_sse2;
-const SadMxNx4Func sad64x32x4d_sse2 = vpx_sad64x32x4d_sse2;
-const SadMxNx4Func sad32x64x4d_sse2 = vpx_sad32x64x4d_sse2;
-const SadMxNx4Func sad32x32x4d_sse2 = vpx_sad32x32x4d_sse2;
-const SadMxNx4Func sad32x16x4d_sse2 = vpx_sad32x16x4d_sse2;
-const SadMxNx4Func sad16x32x4d_sse2 = vpx_sad16x32x4d_sse2;
-const SadMxNx4Func sad16x16x4d_sse2 = vpx_sad16x16x4d_sse2;
-const SadMxNx4Func sad16x8x4d_sse2 = vpx_sad16x8x4d_sse2;
-const SadMxNx4Func sad8x16x4d_sse2 = vpx_sad8x16x4d_sse2;
-const SadMxNx4Func sad8x8x4d_sse2 = vpx_sad8x8x4d_sse2;
-const SadMxNx4Func sad8x4x4d_sse2 = vpx_sad8x4x4d_sse2;
-#if CONFIG_VP9_HIGHBITDEPTH
-const SadMxNx4Func highbd_sad64x64x4d_sse2 = vpx_highbd_sad64x64x4d_sse2;
-const SadMxNx4Func highbd_sad64x32x4d_sse2 = vpx_highbd_sad64x32x4d_sse2;
-const SadMxNx4Func highbd_sad32x64x4d_sse2 = vpx_highbd_sad32x64x4d_sse2;
-const SadMxNx4Func highbd_sad32x32x4d_sse2 = vpx_highbd_sad32x32x4d_sse2;
-const SadMxNx4Func highbd_sad32x16x4d_sse2 = vpx_highbd_sad32x16x4d_sse2;
-const SadMxNx4Func highbd_sad16x32x4d_sse2 = vpx_highbd_sad16x32x4d_sse2;
-const SadMxNx4Func highbd_sad16x16x4d_sse2 = vpx_highbd_sad16x16x4d_sse2;
-const SadMxNx4Func highbd_sad16x8x4d_sse2 = vpx_highbd_sad16x8x4d_sse2;
-const SadMxNx4Func highbd_sad8x16x4d_sse2 = vpx_highbd_sad8x16x4d_sse2;
-const SadMxNx4Func highbd_sad8x8x4d_sse2 = vpx_highbd_sad8x8x4d_sse2;
-const SadMxNx4Func highbd_sad8x4x4d_sse2 = vpx_highbd_sad8x4x4d_sse2;
-const SadMxNx4Func highbd_sad4x8x4d_sse2 = vpx_highbd_sad4x8x4d_sse2;
-const SadMxNx4Func highbd_sad4x4x4d_sse2 = vpx_highbd_sad4x4x4d_sse2;
-#endif // CONFIG_VP9_HIGHBITDEPTH
const SadMxNx4Param x4d_sse2_tests[] = {
- make_tuple(64, 64, sad64x64x4d_sse2, -1),
- make_tuple(64, 32, sad64x32x4d_sse2, -1),
- make_tuple(32, 64, sad32x64x4d_sse2, -1),
- make_tuple(32, 32, sad32x32x4d_sse2, -1),
- make_tuple(32, 16, sad32x16x4d_sse2, -1),
- make_tuple(16, 32, sad16x32x4d_sse2, -1),
- make_tuple(16, 16, sad16x16x4d_sse2, -1),
- make_tuple(16, 8, sad16x8x4d_sse2, -1),
- make_tuple(8, 16, sad8x16x4d_sse2, -1),
- make_tuple(8, 8, sad8x8x4d_sse2, -1),
- make_tuple(8, 4, sad8x4x4d_sse2, -1),
+ 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),
#if CONFIG_VP9_HIGHBITDEPTH
- make_tuple(64, 64, highbd_sad64x64x4d_sse2, 8),
- make_tuple(64, 32, highbd_sad64x32x4d_sse2, 8),
- make_tuple(32, 64, highbd_sad32x64x4d_sse2, 8),
- make_tuple(32, 32, highbd_sad32x32x4d_sse2, 8),
- make_tuple(32, 16, highbd_sad32x16x4d_sse2, 8),
- make_tuple(16, 32, highbd_sad16x32x4d_sse2, 8),
- make_tuple(16, 16, highbd_sad16x16x4d_sse2, 8),
- make_tuple(16, 8, highbd_sad16x8x4d_sse2, 8),
- make_tuple(8, 16, highbd_sad8x16x4d_sse2, 8),
- make_tuple(8, 8, highbd_sad8x8x4d_sse2, 8),
- make_tuple(8, 4, highbd_sad8x4x4d_sse2, 8),
- make_tuple(4, 8, highbd_sad4x8x4d_sse2, 8),
- make_tuple(4, 4, highbd_sad4x4x4d_sse2, 8),
- make_tuple(64, 64, highbd_sad64x64x4d_sse2, 10),
- make_tuple(64, 32, highbd_sad64x32x4d_sse2, 10),
- make_tuple(32, 64, highbd_sad32x64x4d_sse2, 10),
- make_tuple(32, 32, highbd_sad32x32x4d_sse2, 10),
- make_tuple(32, 16, highbd_sad32x16x4d_sse2, 10),
- make_tuple(16, 32, highbd_sad16x32x4d_sse2, 10),
- make_tuple(16, 16, highbd_sad16x16x4d_sse2, 10),
- make_tuple(16, 8, highbd_sad16x8x4d_sse2, 10),
- make_tuple(8, 16, highbd_sad8x16x4d_sse2, 10),
- make_tuple(8, 8, highbd_sad8x8x4d_sse2, 10),
- make_tuple(8, 4, highbd_sad8x4x4d_sse2, 10),
- make_tuple(4, 8, highbd_sad4x8x4d_sse2, 10),
- make_tuple(4, 4, highbd_sad4x4x4d_sse2, 10),
- make_tuple(64, 64, highbd_sad64x64x4d_sse2, 12),
- make_tuple(64, 32, highbd_sad64x32x4d_sse2, 12),
- make_tuple(32, 64, highbd_sad32x64x4d_sse2, 12),
- make_tuple(32, 32, highbd_sad32x32x4d_sse2, 12),
- make_tuple(32, 16, highbd_sad32x16x4d_sse2, 12),
- make_tuple(16, 32, highbd_sad16x32x4d_sse2, 12),
- make_tuple(16, 16, highbd_sad16x16x4d_sse2, 12),
- make_tuple(16, 8, highbd_sad16x8x4d_sse2, 12),
- make_tuple(8, 16, highbd_sad8x16x4d_sse2, 12),
- make_tuple(8, 8, highbd_sad8x8x4d_sse2, 12),
- make_tuple(8, 4, highbd_sad8x4x4d_sse2, 12),
- make_tuple(4, 8, highbd_sad4x8x4d_sse2, 12),
- make_tuple(4, 4, highbd_sad4x4x4d_sse2, 12),
+ 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
};
INSTANTIATE_TEST_CASE_P(SSE2, SADx4Test, ::testing::ValuesIn(x4d_sse2_tests));
@@ -1076,39 +895,27 @@
#endif // HAVE_SSE4_1
#if HAVE_AVX2
-const SadMxNFunc sad64x64_avx2 = vpx_sad64x64_avx2;
-const SadMxNFunc sad64x32_avx2 = vpx_sad64x32_avx2;
-const SadMxNFunc sad32x64_avx2 = vpx_sad32x64_avx2;
-const SadMxNFunc sad32x32_avx2 = vpx_sad32x32_avx2;
-const SadMxNFunc sad32x16_avx2 = vpx_sad32x16_avx2;
const SadMxNParam avx2_tests[] = {
- make_tuple(64, 64, sad64x64_avx2, -1),
- make_tuple(64, 32, sad64x32_avx2, -1),
- make_tuple(32, 64, sad32x64_avx2, -1),
- make_tuple(32, 32, sad32x32_avx2, -1),
- make_tuple(32, 16, sad32x16_avx2, -1),
+ 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),
};
INSTANTIATE_TEST_CASE_P(AVX2, SADTest, ::testing::ValuesIn(avx2_tests));
-const SadMxNAvgFunc sad64x64_avg_avx2 = vpx_sad64x64_avg_avx2;
-const SadMxNAvgFunc sad64x32_avg_avx2 = vpx_sad64x32_avg_avx2;
-const SadMxNAvgFunc sad32x64_avg_avx2 = vpx_sad32x64_avg_avx2;
-const SadMxNAvgFunc sad32x32_avg_avx2 = vpx_sad32x32_avg_avx2;
-const SadMxNAvgFunc sad32x16_avg_avx2 = vpx_sad32x16_avg_avx2;
const SadMxNAvgParam avg_avx2_tests[] = {
- make_tuple(64, 64, sad64x64_avg_avx2, -1),
- make_tuple(64, 32, sad64x32_avg_avx2, -1),
- make_tuple(32, 64, sad32x64_avg_avx2, -1),
- make_tuple(32, 32, sad32x32_avg_avx2, -1),
- make_tuple(32, 16, sad32x16_avg_avx2, -1),
+ 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),
};
INSTANTIATE_TEST_CASE_P(AVX2, SADavgTest, ::testing::ValuesIn(avg_avx2_tests));
-const SadMxNx4Func sad64x64x4d_avx2 = vpx_sad64x64x4d_avx2;
-const SadMxNx4Func sad32x32x4d_avx2 = vpx_sad32x32x4d_avx2;
const SadMxNx4Param x4d_avx2_tests[] = {
- make_tuple(64, 64, sad64x64x4d_avx2, -1),
- make_tuple(32, 32, sad32x32x4d_avx2, -1),
+ make_tuple(64, 64, &vpx_sad64x64x4d_avx2, -1),
+ make_tuple(32, 32, &vpx_sad32x32x4d_avx2, -1),
};
INSTANTIATE_TEST_CASE_P(AVX2, SADx4Test, ::testing::ValuesIn(x4d_avx2_tests));
#endif // HAVE_AVX2
@@ -1116,93 +923,54 @@
//------------------------------------------------------------------------------
// MIPS functions
#if HAVE_MSA
-const SadMxNFunc sad64x64_msa = vpx_sad64x64_msa;
-const SadMxNFunc sad64x32_msa = vpx_sad64x32_msa;
-const SadMxNFunc sad32x64_msa = vpx_sad32x64_msa;
-const SadMxNFunc sad32x32_msa = vpx_sad32x32_msa;
-const SadMxNFunc sad32x16_msa = vpx_sad32x16_msa;
-const SadMxNFunc sad16x32_msa = vpx_sad16x32_msa;
-const SadMxNFunc sad16x16_msa = vpx_sad16x16_msa;
-const SadMxNFunc sad16x8_msa = vpx_sad16x8_msa;
-const SadMxNFunc sad8x16_msa = vpx_sad8x16_msa;
-const SadMxNFunc sad8x8_msa = vpx_sad8x8_msa;
-const SadMxNFunc sad8x4_msa = vpx_sad8x4_msa;
-const SadMxNFunc sad4x8_msa = vpx_sad4x8_msa;
-const SadMxNFunc sad4x4_msa = vpx_sad4x4_msa;
const SadMxNParam msa_tests[] = {
- make_tuple(64, 64, sad64x64_msa, -1),
- make_tuple(64, 32, sad64x32_msa, -1),
- make_tuple(32, 64, sad32x64_msa, -1),
- make_tuple(32, 32, sad32x32_msa, -1),
- make_tuple(32, 16, sad32x16_msa, -1),
- make_tuple(16, 32, sad16x32_msa, -1),
- make_tuple(16, 16, sad16x16_msa, -1),
- make_tuple(16, 8, sad16x8_msa, -1),
- make_tuple(8, 16, sad8x16_msa, -1),
- make_tuple(8, 8, sad8x8_msa, -1),
- make_tuple(8, 4, sad8x4_msa, -1),
- make_tuple(4, 8, sad4x8_msa, -1),
- make_tuple(4, 4, sad4x4_msa, -1),
+ 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),
};
INSTANTIATE_TEST_CASE_P(MSA, SADTest, ::testing::ValuesIn(msa_tests));
-const SadMxNAvgFunc sad64x64_avg_msa = vpx_sad64x64_avg_msa;
-const SadMxNAvgFunc sad64x32_avg_msa = vpx_sad64x32_avg_msa;
-const SadMxNAvgFunc sad32x64_avg_msa = vpx_sad32x64_avg_msa;
-const SadMxNAvgFunc sad32x32_avg_msa = vpx_sad32x32_avg_msa;
-const SadMxNAvgFunc sad32x16_avg_msa = vpx_sad32x16_avg_msa;
-const SadMxNAvgFunc sad16x32_avg_msa = vpx_sad16x32_avg_msa;
-const SadMxNAvgFunc sad16x16_avg_msa = vpx_sad16x16_avg_msa;
-const SadMxNAvgFunc sad16x8_avg_msa = vpx_sad16x8_avg_msa;
-const SadMxNAvgFunc sad8x16_avg_msa = vpx_sad8x16_avg_msa;
-const SadMxNAvgFunc sad8x8_avg_msa = vpx_sad8x8_avg_msa;
-const SadMxNAvgFunc sad8x4_avg_msa = vpx_sad8x4_avg_msa;
-const SadMxNAvgFunc sad4x8_avg_msa = vpx_sad4x8_avg_msa;
-const SadMxNAvgFunc sad4x4_avg_msa = vpx_sad4x4_avg_msa;
const SadMxNAvgParam avg_msa_tests[] = {
- make_tuple(64, 64, sad64x64_avg_msa, -1),
- make_tuple(64, 32, sad64x32_avg_msa, -1),
- make_tuple(32, 64, sad32x64_avg_msa, -1),
- make_tuple(32, 32, sad32x32_avg_msa, -1),
- make_tuple(32, 16, sad32x16_avg_msa, -1),
- make_tuple(16, 32, sad16x32_avg_msa, -1),
- make_tuple(16, 16, sad16x16_avg_msa, -1),
- make_tuple(16, 8, sad16x8_avg_msa, -1),
- make_tuple(8, 16, sad8x16_avg_msa, -1),
- make_tuple(8, 8, sad8x8_avg_msa, -1),
- make_tuple(8, 4, sad8x4_avg_msa, -1),
- make_tuple(4, 8, sad4x8_avg_msa, -1),
- make_tuple(4, 4, sad4x4_avg_msa, -1),
+ 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),
};
INSTANTIATE_TEST_CASE_P(MSA, SADavgTest, ::testing::ValuesIn(avg_msa_tests));
-const SadMxNx4Func sad64x64x4d_msa = vpx_sad64x64x4d_msa;
-const SadMxNx4Func sad64x32x4d_msa = vpx_sad64x32x4d_msa;
-const SadMxNx4Func sad32x64x4d_msa = vpx_sad32x64x4d_msa;
-const SadMxNx4Func sad32x32x4d_msa = vpx_sad32x32x4d_msa;
-const SadMxNx4Func sad32x16x4d_msa = vpx_sad32x16x4d_msa;
-const SadMxNx4Func sad16x32x4d_msa = vpx_sad16x32x4d_msa;
-const SadMxNx4Func sad16x16x4d_msa = vpx_sad16x16x4d_msa;
-const SadMxNx4Func sad16x8x4d_msa = vpx_sad16x8x4d_msa;
-const SadMxNx4Func sad8x16x4d_msa = vpx_sad8x16x4d_msa;
-const SadMxNx4Func sad8x8x4d_msa = vpx_sad8x8x4d_msa;
-const SadMxNx4Func sad8x4x4d_msa = vpx_sad8x4x4d_msa;
-const SadMxNx4Func sad4x8x4d_msa = vpx_sad4x8x4d_msa;
-const SadMxNx4Func sad4x4x4d_msa = vpx_sad4x4x4d_msa;
const SadMxNx4Param x4d_msa_tests[] = {
- make_tuple(64, 64, sad64x64x4d_msa, -1),
- make_tuple(64, 32, sad64x32x4d_msa, -1),
- make_tuple(32, 64, sad32x64x4d_msa, -1),
- make_tuple(32, 32, sad32x32x4d_msa, -1),
- make_tuple(32, 16, sad32x16x4d_msa, -1),
- make_tuple(16, 32, sad16x32x4d_msa, -1),
- make_tuple(16, 16, sad16x16x4d_msa, -1),
- make_tuple(16, 8, sad16x8x4d_msa, -1),
- make_tuple(8, 16, sad8x16x4d_msa, -1),
- make_tuple(8, 8, sad8x8x4d_msa, -1),
- make_tuple(8, 4, sad8x4x4d_msa, -1),
- make_tuple(4, 8, sad4x8x4d_msa, -1),
- make_tuple(4, 4, sad4x4x4d_msa, -1),
+ 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),
};
INSTANTIATE_TEST_CASE_P(MSA, SADx4Test, ::testing::ValuesIn(x4d_msa_tests));
#endif // HAVE_MSA
diff --git a/test/sixtap_predict_test.cc b/test/sixtap_predict_test.cc
index 1e682e7..304a148 100644
--- a/test/sixtap_predict_test.cc
+++ b/test/sixtap_predict_test.cc
@@ -186,70 +186,48 @@
using std::tr1::make_tuple;
-const SixtapPredictFunc sixtap_16x16_c = vp8_sixtap_predict16x16_c;
-const SixtapPredictFunc sixtap_8x8_c = vp8_sixtap_predict8x8_c;
-const SixtapPredictFunc sixtap_8x4_c = vp8_sixtap_predict8x4_c;
-const SixtapPredictFunc sixtap_4x4_c = vp8_sixtap_predict4x4_c;
INSTANTIATE_TEST_CASE_P(
C, SixtapPredictTest, ::testing::Values(
- make_tuple(16, 16, sixtap_16x16_c),
- make_tuple(8, 8, sixtap_8x8_c),
- make_tuple(8, 4, sixtap_8x4_c),
- make_tuple(4, 4, sixtap_4x4_c)));
+ make_tuple(16, 16, &vp8_sixtap_predict16x16_c),
+ make_tuple(8, 8, &vp8_sixtap_predict8x8_c),
+ make_tuple(8, 4, &vp8_sixtap_predict8x4_c),
+ make_tuple(4, 4, &vp8_sixtap_predict4x4_c)));
#if HAVE_NEON
-const SixtapPredictFunc sixtap_16x16_neon = vp8_sixtap_predict16x16_neon;
-const SixtapPredictFunc sixtap_8x8_neon = vp8_sixtap_predict8x8_neon;
-const SixtapPredictFunc sixtap_8x4_neon = vp8_sixtap_predict8x4_neon;
INSTANTIATE_TEST_CASE_P(
NEON, SixtapPredictTest, ::testing::Values(
- make_tuple(16, 16, sixtap_16x16_neon),
- make_tuple(8, 8, sixtap_8x8_neon),
- make_tuple(8, 4, sixtap_8x4_neon)));
+ make_tuple(16, 16, &vp8_sixtap_predict16x16_neon),
+ make_tuple(8, 8, &vp8_sixtap_predict8x8_neon),
+ make_tuple(8, 4, &vp8_sixtap_predict8x4_neon)));
#endif
#if HAVE_MMX
-const SixtapPredictFunc sixtap_16x16_mmx = vp8_sixtap_predict16x16_mmx;
-const SixtapPredictFunc sixtap_8x8_mmx = vp8_sixtap_predict8x8_mmx;
-const SixtapPredictFunc sixtap_8x4_mmx = vp8_sixtap_predict8x4_mmx;
-const SixtapPredictFunc sixtap_4x4_mmx = vp8_sixtap_predict4x4_mmx;
INSTANTIATE_TEST_CASE_P(
MMX, SixtapPredictTest, ::testing::Values(
- make_tuple(16, 16, sixtap_16x16_mmx),
- make_tuple(8, 8, sixtap_8x8_mmx),
- make_tuple(8, 4, sixtap_8x4_mmx),
- make_tuple(4, 4, sixtap_4x4_mmx)));
+ make_tuple(16, 16, &vp8_sixtap_predict16x16_mmx),
+ make_tuple(8, 8, &vp8_sixtap_predict8x8_mmx),
+ make_tuple(8, 4, &vp8_sixtap_predict8x4_mmx),
+ make_tuple(4, 4, &vp8_sixtap_predict4x4_mmx)));
#endif
#if HAVE_SSE2
-const SixtapPredictFunc sixtap_16x16_sse2 = vp8_sixtap_predict16x16_sse2;
-const SixtapPredictFunc sixtap_8x8_sse2 = vp8_sixtap_predict8x8_sse2;
-const SixtapPredictFunc sixtap_8x4_sse2 = vp8_sixtap_predict8x4_sse2;
INSTANTIATE_TEST_CASE_P(
SSE2, SixtapPredictTest, ::testing::Values(
- make_tuple(16, 16, sixtap_16x16_sse2),
- make_tuple(8, 8, sixtap_8x8_sse2),
- make_tuple(8, 4, sixtap_8x4_sse2)));
+ make_tuple(16, 16, &vp8_sixtap_predict16x16_sse2),
+ make_tuple(8, 8, &vp8_sixtap_predict8x8_sse2),
+ make_tuple(8, 4, &vp8_sixtap_predict8x4_sse2)));
#endif
#if HAVE_SSSE3
-const SixtapPredictFunc sixtap_16x16_ssse3 = vp8_sixtap_predict16x16_ssse3;
-const SixtapPredictFunc sixtap_8x8_ssse3 = vp8_sixtap_predict8x8_ssse3;
-const SixtapPredictFunc sixtap_8x4_ssse3 = vp8_sixtap_predict8x4_ssse3;
-const SixtapPredictFunc sixtap_4x4_ssse3 = vp8_sixtap_predict4x4_ssse3;
INSTANTIATE_TEST_CASE_P(
SSSE3, SixtapPredictTest, ::testing::Values(
- make_tuple(16, 16, sixtap_16x16_ssse3),
- make_tuple(8, 8, sixtap_8x8_ssse3),
- make_tuple(8, 4, sixtap_8x4_ssse3),
- make_tuple(4, 4, sixtap_4x4_ssse3)));
+ make_tuple(16, 16, &vp8_sixtap_predict16x16_ssse3),
+ make_tuple(8, 8, &vp8_sixtap_predict8x8_ssse3),
+ make_tuple(8, 4, &vp8_sixtap_predict8x4_ssse3),
+ make_tuple(4, 4, &vp8_sixtap_predict4x4_ssse3)));
#endif
#if HAVE_MSA
-const SixtapPredictFunc sixtap_16x16_msa = vp8_sixtap_predict16x16_msa;
-const SixtapPredictFunc sixtap_8x8_msa = vp8_sixtap_predict8x8_msa;
-const SixtapPredictFunc sixtap_8x4_msa = vp8_sixtap_predict8x4_msa;
-const SixtapPredictFunc sixtap_4x4_msa = vp8_sixtap_predict4x4_msa;
INSTANTIATE_TEST_CASE_P(
MSA, SixtapPredictTest, ::testing::Values(
- make_tuple(16, 16, sixtap_16x16_msa),
- make_tuple(8, 8, sixtap_8x8_msa),
- make_tuple(8, 4, sixtap_8x4_msa),
- make_tuple(4, 4, sixtap_4x4_msa)));
+ make_tuple(16, 16, &vp8_sixtap_predict16x16_msa),
+ make_tuple(8, 8, &vp8_sixtap_predict8x8_msa),
+ make_tuple(8, 4, &vp8_sixtap_predict8x4_msa),
+ make_tuple(4, 4, &vp8_sixtap_predict4x4_msa)));
#endif
} // namespace
diff --git a/test/test_intra_pred_speed.cc b/test/test_intra_pred_speed.cc
index 5d59e83..d44a64a 100644
--- a/test/test_intra_pred_speed.cc
+++ b/test/test_intra_pred_speed.cc
@@ -191,9 +191,14 @@
INTRA_PRED_TEST(SSE, TestIntraPred4, vpx_dc_predictor_4x4_sse,
vpx_dc_left_predictor_4x4_sse, vpx_dc_top_predictor_4x4_sse,
vpx_dc_128_predictor_4x4_sse, vpx_v_predictor_4x4_sse, NULL,
- NULL, NULL, NULL, NULL, NULL, NULL, vpx_tm_predictor_4x4_sse)
+ NULL, NULL, NULL, NULL, NULL, NULL, NULL)
#endif // HAVE_SSE && CONFIG_USE_X86INC
+#if HAVE_SSE2 && CONFIG_USE_X86INC
+INTRA_PRED_TEST(SSE2, TestIntraPred4, NULL, NULL, NULL, NULL, NULL, NULL,
+ NULL, NULL, NULL, NULL, NULL, NULL, vpx_tm_predictor_4x4_sse2)
+#endif // HAVE_SSE2 && CONFIG_USE_X86INC
+
#if HAVE_SSSE3 && CONFIG_USE_X86INC
INTRA_PRED_TEST(SSSE3, TestIntraPred4, NULL, NULL, NULL, NULL, NULL,
vpx_h_predictor_4x4_ssse3, vpx_d45_predictor_4x4_ssse3, NULL,
diff --git a/test/variance_test.cc b/test/variance_test.cc
index 7a34db6..6f50f78 100644
--- a/test/variance_test.cc
+++ b/test/variance_test.cc
@@ -747,115 +747,63 @@
INSTANTIATE_TEST_CASE_P(C, SumOfSquaresTest,
::testing::Values(vpx_get_mb_ss_c));
-const Get4x4SseFunc get4x4sse_cs_c = vpx_get4x4sse_cs_c;
INSTANTIATE_TEST_CASE_P(C, VpxSseTest,
- ::testing::Values(make_tuple(2, 2, get4x4sse_cs_c)));
+ ::testing::Values(make_tuple(2, 2,
+ &vpx_get4x4sse_cs_c)));
-const VarianceMxNFunc mse16x16_c = vpx_mse16x16_c;
-const VarianceMxNFunc mse16x8_c = vpx_mse16x8_c;
-const VarianceMxNFunc mse8x16_c = vpx_mse8x16_c;
-const VarianceMxNFunc mse8x8_c = vpx_mse8x8_c;
INSTANTIATE_TEST_CASE_P(C, VpxMseTest,
- ::testing::Values(make_tuple(4, 4, mse16x16_c),
- make_tuple(4, 3, mse16x8_c),
- make_tuple(3, 4, mse8x16_c),
- make_tuple(3, 3, mse8x8_c)));
+ ::testing::Values(make_tuple(4, 4, &vpx_mse16x16_c),
+ make_tuple(4, 3, &vpx_mse16x8_c),
+ make_tuple(3, 4, &vpx_mse8x16_c),
+ make_tuple(3, 3, &vpx_mse8x8_c)));
-const VarianceMxNFunc variance64x64_c = vpx_variance64x64_c;
-const VarianceMxNFunc variance64x32_c = vpx_variance64x32_c;
-const VarianceMxNFunc variance32x64_c = vpx_variance32x64_c;
-const VarianceMxNFunc variance32x32_c = vpx_variance32x32_c;
-const VarianceMxNFunc variance32x16_c = vpx_variance32x16_c;
-const VarianceMxNFunc variance16x32_c = vpx_variance16x32_c;
-const VarianceMxNFunc variance16x16_c = vpx_variance16x16_c;
-const VarianceMxNFunc variance16x8_c = vpx_variance16x8_c;
-const VarianceMxNFunc variance8x16_c = vpx_variance8x16_c;
-const VarianceMxNFunc variance8x8_c = vpx_variance8x8_c;
-const VarianceMxNFunc variance8x4_c = vpx_variance8x4_c;
-const VarianceMxNFunc variance4x8_c = vpx_variance4x8_c;
-const VarianceMxNFunc variance4x4_c = vpx_variance4x4_c;
INSTANTIATE_TEST_CASE_P(
C, VpxVarianceTest,
- ::testing::Values(make_tuple(6, 6, variance64x64_c, 0),
- make_tuple(6, 5, variance64x32_c, 0),
- make_tuple(5, 6, variance32x64_c, 0),
- make_tuple(5, 5, variance32x32_c, 0),
- make_tuple(5, 4, variance32x16_c, 0),
- make_tuple(4, 5, variance16x32_c, 0),
- make_tuple(4, 4, variance16x16_c, 0),
- make_tuple(4, 3, variance16x8_c, 0),
- make_tuple(3, 4, variance8x16_c, 0),
- make_tuple(3, 3, variance8x8_c, 0),
- make_tuple(3, 2, variance8x4_c, 0),
- make_tuple(2, 3, variance4x8_c, 0),
- make_tuple(2, 2, variance4x4_c, 0)));
+ ::testing::Values(make_tuple(6, 6, &vpx_variance64x64_c, 0),
+ make_tuple(6, 5, &vpx_variance64x32_c, 0),
+ make_tuple(5, 6, &vpx_variance32x64_c, 0),
+ make_tuple(5, 5, &vpx_variance32x32_c, 0),
+ make_tuple(5, 4, &vpx_variance32x16_c, 0),
+ make_tuple(4, 5, &vpx_variance16x32_c, 0),
+ make_tuple(4, 4, &vpx_variance16x16_c, 0),
+ make_tuple(4, 3, &vpx_variance16x8_c, 0),
+ make_tuple(3, 4, &vpx_variance8x16_c, 0),
+ make_tuple(3, 3, &vpx_variance8x8_c, 0),
+ make_tuple(3, 2, &vpx_variance8x4_c, 0),
+ make_tuple(2, 3, &vpx_variance4x8_c, 0),
+ make_tuple(2, 2, &vpx_variance4x4_c, 0)));
-const SubpixVarMxNFunc subpel_var64x64_c = vpx_sub_pixel_variance64x64_c;
-const SubpixVarMxNFunc subpel_var64x32_c = vpx_sub_pixel_variance64x32_c;
-const SubpixVarMxNFunc subpel_var32x64_c = vpx_sub_pixel_variance32x64_c;
-const SubpixVarMxNFunc subpel_var32x32_c = vpx_sub_pixel_variance32x32_c;
-const SubpixVarMxNFunc subpel_var32x16_c = vpx_sub_pixel_variance32x16_c;
-const SubpixVarMxNFunc subpel_var16x32_c = vpx_sub_pixel_variance16x32_c;
-const SubpixVarMxNFunc subpel_var16x16_c = vpx_sub_pixel_variance16x16_c;
-const SubpixVarMxNFunc subpel_var16x8_c = vpx_sub_pixel_variance16x8_c;
-const SubpixVarMxNFunc subpel_var8x16_c = vpx_sub_pixel_variance8x16_c;
-const SubpixVarMxNFunc subpel_var8x8_c = vpx_sub_pixel_variance8x8_c;
-const SubpixVarMxNFunc subpel_var8x4_c = vpx_sub_pixel_variance8x4_c;
-const SubpixVarMxNFunc subpel_var4x8_c = vpx_sub_pixel_variance4x8_c;
-const SubpixVarMxNFunc subpel_var4x4_c = vpx_sub_pixel_variance4x4_c;
INSTANTIATE_TEST_CASE_P(
C, VpxSubpelVarianceTest,
- ::testing::Values(make_tuple(6, 6, subpel_var64x64_c, 0),
- make_tuple(6, 5, subpel_var64x32_c, 0),
- make_tuple(5, 6, subpel_var32x64_c, 0),
- make_tuple(5, 5, subpel_var32x32_c, 0),
- make_tuple(5, 4, subpel_var32x16_c, 0),
- make_tuple(4, 5, subpel_var16x32_c, 0),
- make_tuple(4, 4, subpel_var16x16_c, 0),
- make_tuple(4, 3, subpel_var16x8_c, 0),
- make_tuple(3, 4, subpel_var8x16_c, 0),
- make_tuple(3, 3, subpel_var8x8_c, 0),
- make_tuple(3, 2, subpel_var8x4_c, 0),
- make_tuple(2, 3, subpel_var4x8_c, 0),
- make_tuple(2, 2, subpel_var4x4_c, 0)));
+ ::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)));
-const SubpixAvgVarMxNFunc subpel_avg_var64x64_c =
- vpx_sub_pixel_avg_variance64x64_c;
-const SubpixAvgVarMxNFunc subpel_avg_var64x32_c =
- vpx_sub_pixel_avg_variance64x32_c;
-const SubpixAvgVarMxNFunc subpel_avg_var32x64_c =
- vpx_sub_pixel_avg_variance32x64_c;
-const SubpixAvgVarMxNFunc subpel_avg_var32x32_c =
- vpx_sub_pixel_avg_variance32x32_c;
-const SubpixAvgVarMxNFunc subpel_avg_var32x16_c =
- vpx_sub_pixel_avg_variance32x16_c;
-const SubpixAvgVarMxNFunc subpel_avg_var16x32_c =
- vpx_sub_pixel_avg_variance16x32_c;
-const SubpixAvgVarMxNFunc subpel_avg_var16x16_c =
- vpx_sub_pixel_avg_variance16x16_c;
-const SubpixAvgVarMxNFunc subpel_avg_var16x8_c =
- vpx_sub_pixel_avg_variance16x8_c;
-const SubpixAvgVarMxNFunc subpel_avg_var8x16_c =
- vpx_sub_pixel_avg_variance8x16_c;
-const SubpixAvgVarMxNFunc subpel_avg_var8x8_c = vpx_sub_pixel_avg_variance8x8_c;
-const SubpixAvgVarMxNFunc subpel_avg_var8x4_c = vpx_sub_pixel_avg_variance8x4_c;
-const SubpixAvgVarMxNFunc subpel_avg_var4x8_c = vpx_sub_pixel_avg_variance4x8_c;
-const SubpixAvgVarMxNFunc subpel_avg_var4x4_c = vpx_sub_pixel_avg_variance4x4_c;
INSTANTIATE_TEST_CASE_P(
C, VpxSubpelAvgVarianceTest,
- ::testing::Values(make_tuple(6, 6, subpel_avg_var64x64_c, 0),
- make_tuple(6, 5, subpel_avg_var64x32_c, 0),
- make_tuple(5, 6, subpel_avg_var32x64_c, 0),
- make_tuple(5, 5, subpel_avg_var32x32_c, 0),
- make_tuple(5, 4, subpel_avg_var32x16_c, 0),
- make_tuple(4, 5, subpel_avg_var16x32_c, 0),
- make_tuple(4, 4, subpel_avg_var16x16_c, 0),
- make_tuple(4, 3, subpel_avg_var16x8_c, 0),
- make_tuple(3, 4, subpel_avg_var8x16_c, 0),
- make_tuple(3, 3, subpel_avg_var8x8_c, 0),
- make_tuple(3, 2, subpel_avg_var8x4_c, 0),
- make_tuple(2, 3, subpel_avg_var4x8_c, 0),
- make_tuple(2, 2, subpel_avg_var4x4_c, 0)));
+ ::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)));
#if CONFIG_VP9_HIGHBITDEPTH
typedef MseTest<VarianceMxNFunc> VpxHBDMseTest;
@@ -875,1166 +823,531 @@
TEST_P(VpxHBDSubpelAvgVarianceTest, Ref) { RefTest(); }
/* TODO(debargha): This test does not support the highbd version
-const VarianceMxNFunc highbd_12_mse16x16_c = vpx_highbd_12_mse16x16_c;
-const VarianceMxNFunc highbd_12_mse16x8_c = vpx_highbd_12_mse16x8_c;
-const VarianceMxNFunc highbd_12_mse8x16_c = vpx_highbd_12_mse8x16_c;
-const VarianceMxNFunc highbd_12_mse8x8_c = vpx_highbd_12_mse8x8_c;
-
-const VarianceMxNFunc highbd_10_mse16x16_c = vpx_highbd_10_mse16x16_c;
-const VarianceMxNFunc highbd_10_mse16x8_c = vpx_highbd_10_mse16x8_c;
-const VarianceMxNFunc highbd_10_mse8x16_c = vpx_highbd_10_mse8x16_c;
-const VarianceMxNFunc highbd_10_mse8x8_c = vpx_highbd_10_mse8x8_c;
-
-const VarianceMxNFunc highbd_8_mse16x16_c = vpx_highbd_8_mse16x16_c;
-const VarianceMxNFunc highbd_8_mse16x8_c = vpx_highbd_8_mse16x8_c;
-const VarianceMxNFunc highbd_8_mse8x16_c = vpx_highbd_8_mse8x16_c;
-const VarianceMxNFunc highbd_8_mse8x8_c = vpx_highbd_8_mse8x8_c;
INSTANTIATE_TEST_CASE_P(
- C, VpxHBDMseTest, ::testing::Values(make_tuple(4, 4, highbd_12_mse16x16_c),
- make_tuple(4, 4, highbd_12_mse16x8_c),
- make_tuple(4, 4, highbd_12_mse8x16_c),
- make_tuple(4, 4, highbd_12_mse8x8_c),
- make_tuple(4, 4, highbd_10_mse16x16_c),
- make_tuple(4, 4, highbd_10_mse16x8_c),
- make_tuple(4, 4, highbd_10_mse8x16_c),
- make_tuple(4, 4, highbd_10_mse8x8_c),
- make_tuple(4, 4, highbd_8_mse16x16_c),
- make_tuple(4, 4, highbd_8_mse16x8_c),
- make_tuple(4, 4, highbd_8_mse8x16_c),
- make_tuple(4, 4, highbd_8_mse8x8_c)));
+ 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)));
*/
-const VarianceMxNFunc highbd_12_variance64x64_c = vpx_highbd_12_variance64x64_c;
-const VarianceMxNFunc highbd_12_variance64x32_c = vpx_highbd_12_variance64x32_c;
-const VarianceMxNFunc highbd_12_variance32x64_c = vpx_highbd_12_variance32x64_c;
-const VarianceMxNFunc highbd_12_variance32x32_c = vpx_highbd_12_variance32x32_c;
-const VarianceMxNFunc highbd_12_variance32x16_c = vpx_highbd_12_variance32x16_c;
-const VarianceMxNFunc highbd_12_variance16x32_c = vpx_highbd_12_variance16x32_c;
-const VarianceMxNFunc highbd_12_variance16x16_c = vpx_highbd_12_variance16x16_c;
-const VarianceMxNFunc highbd_12_variance16x8_c = vpx_highbd_12_variance16x8_c;
-const VarianceMxNFunc highbd_12_variance8x16_c = vpx_highbd_12_variance8x16_c;
-const VarianceMxNFunc highbd_12_variance8x8_c = vpx_highbd_12_variance8x8_c;
-const VarianceMxNFunc highbd_12_variance8x4_c = vpx_highbd_12_variance8x4_c;
-const VarianceMxNFunc highbd_12_variance4x8_c = vpx_highbd_12_variance4x8_c;
-const VarianceMxNFunc highbd_12_variance4x4_c = vpx_highbd_12_variance4x4_c;
-const VarianceMxNFunc highbd_10_variance64x64_c = vpx_highbd_10_variance64x64_c;
-const VarianceMxNFunc highbd_10_variance64x32_c = vpx_highbd_10_variance64x32_c;
-const VarianceMxNFunc highbd_10_variance32x64_c = vpx_highbd_10_variance32x64_c;
-const VarianceMxNFunc highbd_10_variance32x32_c = vpx_highbd_10_variance32x32_c;
-const VarianceMxNFunc highbd_10_variance32x16_c = vpx_highbd_10_variance32x16_c;
-const VarianceMxNFunc highbd_10_variance16x32_c = vpx_highbd_10_variance16x32_c;
-const VarianceMxNFunc highbd_10_variance16x16_c = vpx_highbd_10_variance16x16_c;
-const VarianceMxNFunc highbd_10_variance16x8_c = vpx_highbd_10_variance16x8_c;
-const VarianceMxNFunc highbd_10_variance8x16_c = vpx_highbd_10_variance8x16_c;
-const VarianceMxNFunc highbd_10_variance8x8_c = vpx_highbd_10_variance8x8_c;
-const VarianceMxNFunc highbd_10_variance8x4_c = vpx_highbd_10_variance8x4_c;
-const VarianceMxNFunc highbd_10_variance4x8_c = vpx_highbd_10_variance4x8_c;
-const VarianceMxNFunc highbd_10_variance4x4_c = vpx_highbd_10_variance4x4_c;
-const VarianceMxNFunc highbd_8_variance64x64_c = vpx_highbd_8_variance64x64_c;
-const VarianceMxNFunc highbd_8_variance64x32_c = vpx_highbd_8_variance64x32_c;
-const VarianceMxNFunc highbd_8_variance32x64_c = vpx_highbd_8_variance32x64_c;
-const VarianceMxNFunc highbd_8_variance32x32_c = vpx_highbd_8_variance32x32_c;
-const VarianceMxNFunc highbd_8_variance32x16_c = vpx_highbd_8_variance32x16_c;
-const VarianceMxNFunc highbd_8_variance16x32_c = vpx_highbd_8_variance16x32_c;
-const VarianceMxNFunc highbd_8_variance16x16_c = vpx_highbd_8_variance16x16_c;
-const VarianceMxNFunc highbd_8_variance16x8_c = vpx_highbd_8_variance16x8_c;
-const VarianceMxNFunc highbd_8_variance8x16_c = vpx_highbd_8_variance8x16_c;
-const VarianceMxNFunc highbd_8_variance8x8_c = vpx_highbd_8_variance8x8_c;
-const VarianceMxNFunc highbd_8_variance8x4_c = vpx_highbd_8_variance8x4_c;
-const VarianceMxNFunc highbd_8_variance4x8_c = vpx_highbd_8_variance4x8_c;
-const VarianceMxNFunc highbd_8_variance4x4_c = vpx_highbd_8_variance4x4_c;
INSTANTIATE_TEST_CASE_P(
C, VpxHBDVarianceTest,
- ::testing::Values(make_tuple(6, 6, highbd_12_variance64x64_c, 12),
- make_tuple(6, 5, highbd_12_variance64x32_c, 12),
- make_tuple(5, 6, highbd_12_variance32x64_c, 12),
- make_tuple(5, 5, highbd_12_variance32x32_c, 12),
- make_tuple(5, 4, highbd_12_variance32x16_c, 12),
- make_tuple(4, 5, highbd_12_variance16x32_c, 12),
- make_tuple(4, 4, highbd_12_variance16x16_c, 12),
- make_tuple(4, 3, highbd_12_variance16x8_c, 12),
- make_tuple(3, 4, highbd_12_variance8x16_c, 12),
- make_tuple(3, 3, highbd_12_variance8x8_c, 12),
- make_tuple(3, 2, highbd_12_variance8x4_c, 12),
- make_tuple(2, 3, highbd_12_variance4x8_c, 12),
- make_tuple(2, 2, highbd_12_variance4x4_c, 12),
- make_tuple(6, 6, highbd_10_variance64x64_c, 10),
- make_tuple(6, 5, highbd_10_variance64x32_c, 10),
- make_tuple(5, 6, highbd_10_variance32x64_c, 10),
- make_tuple(5, 5, highbd_10_variance32x32_c, 10),
- make_tuple(5, 4, highbd_10_variance32x16_c, 10),
- make_tuple(4, 5, highbd_10_variance16x32_c, 10),
- make_tuple(4, 4, highbd_10_variance16x16_c, 10),
- make_tuple(4, 3, highbd_10_variance16x8_c, 10),
- make_tuple(3, 4, highbd_10_variance8x16_c, 10),
- make_tuple(3, 3, highbd_10_variance8x8_c, 10),
- make_tuple(3, 2, highbd_10_variance8x4_c, 10),
- make_tuple(2, 3, highbd_10_variance4x8_c, 10),
- make_tuple(2, 2, highbd_10_variance4x4_c, 10),
- make_tuple(6, 6, highbd_8_variance64x64_c, 8),
- make_tuple(6, 5, highbd_8_variance64x32_c, 8),
- make_tuple(5, 6, highbd_8_variance32x64_c, 8),
- make_tuple(5, 5, highbd_8_variance32x32_c, 8),
- make_tuple(5, 4, highbd_8_variance32x16_c, 8),
- make_tuple(4, 5, highbd_8_variance16x32_c, 8),
- make_tuple(4, 4, highbd_8_variance16x16_c, 8),
- make_tuple(4, 3, highbd_8_variance16x8_c, 8),
- make_tuple(3, 4, highbd_8_variance8x16_c, 8),
- make_tuple(3, 3, highbd_8_variance8x8_c, 8),
- make_tuple(3, 2, highbd_8_variance8x4_c, 8),
- make_tuple(2, 3, highbd_8_variance4x8_c, 8),
- make_tuple(2, 2, highbd_8_variance4x4_c, 8)));
+ ::testing::Values(make_tuple(6, 6, &vpx_highbd_12_variance64x64_c, 12),
+ make_tuple(6, 5, &vpx_highbd_12_variance64x32_c, 12),
+ make_tuple(5, 6, &vpx_highbd_12_variance32x64_c, 12),
+ make_tuple(5, 5, &vpx_highbd_12_variance32x32_c, 12),
+ make_tuple(5, 4, &vpx_highbd_12_variance32x16_c, 12),
+ make_tuple(4, 5, &vpx_highbd_12_variance16x32_c, 12),
+ make_tuple(4, 4, &vpx_highbd_12_variance16x16_c, 12),
+ make_tuple(4, 3, &vpx_highbd_12_variance16x8_c, 12),
+ make_tuple(3, 4, &vpx_highbd_12_variance8x16_c, 12),
+ make_tuple(3, 3, &vpx_highbd_12_variance8x8_c, 12),
+ make_tuple(3, 2, &vpx_highbd_12_variance8x4_c, 12),
+ make_tuple(2, 3, &vpx_highbd_12_variance4x8_c, 12),
+ make_tuple(2, 2, &vpx_highbd_12_variance4x4_c, 12),
+ make_tuple(6, 6, &vpx_highbd_10_variance64x64_c, 10),
+ make_tuple(6, 5, &vpx_highbd_10_variance64x32_c, 10),
+ make_tuple(5, 6, &vpx_highbd_10_variance32x64_c, 10),
+ make_tuple(5, 5, &vpx_highbd_10_variance32x32_c, 10),
+ make_tuple(5, 4, &vpx_highbd_10_variance32x16_c, 10),
+ make_tuple(4, 5, &vpx_highbd_10_variance16x32_c, 10),
+ make_tuple(4, 4, &vpx_highbd_10_variance16x16_c, 10),
+ make_tuple(4, 3, &vpx_highbd_10_variance16x8_c, 10),
+ make_tuple(3, 4, &vpx_highbd_10_variance8x16_c, 10),
+ make_tuple(3, 3, &vpx_highbd_10_variance8x8_c, 10),
+ make_tuple(3, 2, &vpx_highbd_10_variance8x4_c, 10),
+ make_tuple(2, 3, &vpx_highbd_10_variance4x8_c, 10),
+ make_tuple(2, 2, &vpx_highbd_10_variance4x4_c, 10),
+ make_tuple(6, 6, &vpx_highbd_8_variance64x64_c, 8),
+ make_tuple(6, 5, &vpx_highbd_8_variance64x32_c, 8),
+ make_tuple(5, 6, &vpx_highbd_8_variance32x64_c, 8),
+ make_tuple(5, 5, &vpx_highbd_8_variance32x32_c, 8),
+ make_tuple(5, 4, &vpx_highbd_8_variance32x16_c, 8),
+ make_tuple(4, 5, &vpx_highbd_8_variance16x32_c, 8),
+ make_tuple(4, 4, &vpx_highbd_8_variance16x16_c, 8),
+ make_tuple(4, 3, &vpx_highbd_8_variance16x8_c, 8),
+ make_tuple(3, 4, &vpx_highbd_8_variance8x16_c, 8),
+ make_tuple(3, 3, &vpx_highbd_8_variance8x8_c, 8),
+ make_tuple(3, 2, &vpx_highbd_8_variance8x4_c, 8),
+ make_tuple(2, 3, &vpx_highbd_8_variance4x8_c, 8),
+ make_tuple(2, 2, &vpx_highbd_8_variance4x4_c, 8)));
-const SubpixVarMxNFunc highbd_8_subpel_var64x64_c =
- vpx_highbd_8_sub_pixel_variance64x64_c;
-const SubpixVarMxNFunc highbd_8_subpel_var64x32_c =
- vpx_highbd_8_sub_pixel_variance64x32_c;
-const SubpixVarMxNFunc highbd_8_subpel_var32x64_c =
- vpx_highbd_8_sub_pixel_variance32x64_c;
-const SubpixVarMxNFunc highbd_8_subpel_var32x32_c =
- vpx_highbd_8_sub_pixel_variance32x32_c;
-const SubpixVarMxNFunc highbd_8_subpel_var32x16_c =
- vpx_highbd_8_sub_pixel_variance32x16_c;
-const SubpixVarMxNFunc highbd_8_subpel_var16x32_c =
- vpx_highbd_8_sub_pixel_variance16x32_c;
-const SubpixVarMxNFunc highbd_8_subpel_var16x16_c =
- vpx_highbd_8_sub_pixel_variance16x16_c;
-const SubpixVarMxNFunc highbd_8_subpel_var16x8_c =
- vpx_highbd_8_sub_pixel_variance16x8_c;
-const SubpixVarMxNFunc highbd_8_subpel_var8x16_c =
- vpx_highbd_8_sub_pixel_variance8x16_c;
-const SubpixVarMxNFunc highbd_8_subpel_var8x8_c =
- vpx_highbd_8_sub_pixel_variance8x8_c;
-const SubpixVarMxNFunc highbd_8_subpel_var8x4_c =
- vpx_highbd_8_sub_pixel_variance8x4_c;
-const SubpixVarMxNFunc highbd_8_subpel_var4x8_c =
- vpx_highbd_8_sub_pixel_variance4x8_c;
-const SubpixVarMxNFunc highbd_8_subpel_var4x4_c =
- vpx_highbd_8_sub_pixel_variance4x4_c;
-const SubpixVarMxNFunc highbd_10_subpel_var64x64_c =
- vpx_highbd_10_sub_pixel_variance64x64_c;
-const SubpixVarMxNFunc highbd_10_subpel_var64x32_c =
- vpx_highbd_10_sub_pixel_variance64x32_c;
-const SubpixVarMxNFunc highbd_10_subpel_var32x64_c =
- vpx_highbd_10_sub_pixel_variance32x64_c;
-const SubpixVarMxNFunc highbd_10_subpel_var32x32_c =
- vpx_highbd_10_sub_pixel_variance32x32_c;
-const SubpixVarMxNFunc highbd_10_subpel_var32x16_c =
- vpx_highbd_10_sub_pixel_variance32x16_c;
-const SubpixVarMxNFunc highbd_10_subpel_var16x32_c =
- vpx_highbd_10_sub_pixel_variance16x32_c;
-const SubpixVarMxNFunc highbd_10_subpel_var16x16_c =
- vpx_highbd_10_sub_pixel_variance16x16_c;
-const SubpixVarMxNFunc highbd_10_subpel_var16x8_c =
- vpx_highbd_10_sub_pixel_variance16x8_c;
-const SubpixVarMxNFunc highbd_10_subpel_var8x16_c =
- vpx_highbd_10_sub_pixel_variance8x16_c;
-const SubpixVarMxNFunc highbd_10_subpel_var8x8_c =
- vpx_highbd_10_sub_pixel_variance8x8_c;
-const SubpixVarMxNFunc highbd_10_subpel_var8x4_c =
- vpx_highbd_10_sub_pixel_variance8x4_c;
-const SubpixVarMxNFunc highbd_10_subpel_var4x8_c =
- vpx_highbd_10_sub_pixel_variance4x8_c;
-const SubpixVarMxNFunc highbd_10_subpel_var4x4_c =
- vpx_highbd_10_sub_pixel_variance4x4_c;
-const SubpixVarMxNFunc highbd_12_subpel_var64x64_c =
- vpx_highbd_12_sub_pixel_variance64x64_c;
-const SubpixVarMxNFunc highbd_12_subpel_var64x32_c =
- vpx_highbd_12_sub_pixel_variance64x32_c;
-const SubpixVarMxNFunc highbd_12_subpel_var32x64_c =
- vpx_highbd_12_sub_pixel_variance32x64_c;
-const SubpixVarMxNFunc highbd_12_subpel_var32x32_c =
- vpx_highbd_12_sub_pixel_variance32x32_c;
-const SubpixVarMxNFunc highbd_12_subpel_var32x16_c =
- vpx_highbd_12_sub_pixel_variance32x16_c;
-const SubpixVarMxNFunc highbd_12_subpel_var16x32_c =
- vpx_highbd_12_sub_pixel_variance16x32_c;
-const SubpixVarMxNFunc highbd_12_subpel_var16x16_c =
- vpx_highbd_12_sub_pixel_variance16x16_c;
-const SubpixVarMxNFunc highbd_12_subpel_var16x8_c =
- vpx_highbd_12_sub_pixel_variance16x8_c;
-const SubpixVarMxNFunc highbd_12_subpel_var8x16_c =
- vpx_highbd_12_sub_pixel_variance8x16_c;
-const SubpixVarMxNFunc highbd_12_subpel_var8x8_c =
- vpx_highbd_12_sub_pixel_variance8x8_c;
-const SubpixVarMxNFunc highbd_12_subpel_var8x4_c =
- vpx_highbd_12_sub_pixel_variance8x4_c;
-const SubpixVarMxNFunc highbd_12_subpel_var4x8_c =
- vpx_highbd_12_sub_pixel_variance4x8_c;
-const SubpixVarMxNFunc highbd_12_subpel_var4x4_c =
- vpx_highbd_12_sub_pixel_variance4x4_c;
INSTANTIATE_TEST_CASE_P(
C, VpxHBDSubpelVarianceTest,
- ::testing::Values(make_tuple(6, 6, highbd_8_subpel_var64x64_c, 8),
- make_tuple(6, 5, highbd_8_subpel_var64x32_c, 8),
- make_tuple(5, 6, highbd_8_subpel_var32x64_c, 8),
- make_tuple(5, 5, highbd_8_subpel_var32x32_c, 8),
- make_tuple(5, 4, highbd_8_subpel_var32x16_c, 8),
- make_tuple(4, 5, highbd_8_subpel_var16x32_c, 8),
- make_tuple(4, 4, highbd_8_subpel_var16x16_c, 8),
- make_tuple(4, 3, highbd_8_subpel_var16x8_c, 8),
- make_tuple(3, 4, highbd_8_subpel_var8x16_c, 8),
- make_tuple(3, 3, highbd_8_subpel_var8x8_c, 8),
- make_tuple(3, 2, highbd_8_subpel_var8x4_c, 8),
- make_tuple(2, 3, highbd_8_subpel_var4x8_c, 8),
- make_tuple(2, 2, highbd_8_subpel_var4x4_c, 8),
- make_tuple(6, 6, highbd_10_subpel_var64x64_c, 10),
- make_tuple(6, 5, highbd_10_subpel_var64x32_c, 10),
- make_tuple(5, 6, highbd_10_subpel_var32x64_c, 10),
- make_tuple(5, 5, highbd_10_subpel_var32x32_c, 10),
- make_tuple(5, 4, highbd_10_subpel_var32x16_c, 10),
- make_tuple(4, 5, highbd_10_subpel_var16x32_c, 10),
- make_tuple(4, 4, highbd_10_subpel_var16x16_c, 10),
- make_tuple(4, 3, highbd_10_subpel_var16x8_c, 10),
- make_tuple(3, 4, highbd_10_subpel_var8x16_c, 10),
- make_tuple(3, 3, highbd_10_subpel_var8x8_c, 10),
- make_tuple(3, 2, highbd_10_subpel_var8x4_c, 10),
- make_tuple(2, 3, highbd_10_subpel_var4x8_c, 10),
- make_tuple(2, 2, highbd_10_subpel_var4x4_c, 10),
- make_tuple(6, 6, highbd_12_subpel_var64x64_c, 12),
- make_tuple(6, 5, highbd_12_subpel_var64x32_c, 12),
- make_tuple(5, 6, highbd_12_subpel_var32x64_c, 12),
- make_tuple(5, 5, highbd_12_subpel_var32x32_c, 12),
- make_tuple(5, 4, highbd_12_subpel_var32x16_c, 12),
- make_tuple(4, 5, highbd_12_subpel_var16x32_c, 12),
- make_tuple(4, 4, highbd_12_subpel_var16x16_c, 12),
- make_tuple(4, 3, highbd_12_subpel_var16x8_c, 12),
- make_tuple(3, 4, highbd_12_subpel_var8x16_c, 12),
- make_tuple(3, 3, highbd_12_subpel_var8x8_c, 12),
- make_tuple(3, 2, highbd_12_subpel_var8x4_c, 12),
- make_tuple(2, 3, highbd_12_subpel_var4x8_c, 12),
- make_tuple(2, 2, highbd_12_subpel_var4x4_c, 12)));
+ ::testing::Values(
+ 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),
+ 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),
+ 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 SubpixAvgVarMxNFunc highbd_8_subpel_avg_var64x64_c =
- vpx_highbd_8_sub_pixel_avg_variance64x64_c;
-const SubpixAvgVarMxNFunc highbd_8_subpel_avg_var64x32_c =
- vpx_highbd_8_sub_pixel_avg_variance64x32_c;
-const SubpixAvgVarMxNFunc highbd_8_subpel_avg_var32x64_c =
- vpx_highbd_8_sub_pixel_avg_variance32x64_c;
-const SubpixAvgVarMxNFunc highbd_8_subpel_avg_var32x32_c =
- vpx_highbd_8_sub_pixel_avg_variance32x32_c;
-const SubpixAvgVarMxNFunc highbd_8_subpel_avg_var32x16_c =
- vpx_highbd_8_sub_pixel_avg_variance32x16_c;
-const SubpixAvgVarMxNFunc highbd_8_subpel_avg_var16x32_c =
- vpx_highbd_8_sub_pixel_avg_variance16x32_c;
-const SubpixAvgVarMxNFunc highbd_8_subpel_avg_var16x16_c =
- vpx_highbd_8_sub_pixel_avg_variance16x16_c;
-const SubpixAvgVarMxNFunc highbd_8_subpel_avg_var16x8_c =
- vpx_highbd_8_sub_pixel_avg_variance16x8_c;
-const SubpixAvgVarMxNFunc highbd_8_subpel_avg_var8x16_c =
- vpx_highbd_8_sub_pixel_avg_variance8x16_c;
-const SubpixAvgVarMxNFunc highbd_8_subpel_avg_var8x8_c =
- vpx_highbd_8_sub_pixel_avg_variance8x8_c;
-const SubpixAvgVarMxNFunc highbd_8_subpel_avg_var8x4_c =
- vpx_highbd_8_sub_pixel_avg_variance8x4_c;
-const SubpixAvgVarMxNFunc highbd_8_subpel_avg_var4x8_c =
- vpx_highbd_8_sub_pixel_avg_variance4x8_c;
-const SubpixAvgVarMxNFunc highbd_8_subpel_avg_var4x4_c =
- vpx_highbd_8_sub_pixel_avg_variance4x4_c;
-const SubpixAvgVarMxNFunc highbd_10_subpel_avg_var64x64_c =
- vpx_highbd_10_sub_pixel_avg_variance64x64_c;
-const SubpixAvgVarMxNFunc highbd_10_subpel_avg_var64x32_c =
- vpx_highbd_10_sub_pixel_avg_variance64x32_c;
-const SubpixAvgVarMxNFunc highbd_10_subpel_avg_var32x64_c =
- vpx_highbd_10_sub_pixel_avg_variance32x64_c;
-const SubpixAvgVarMxNFunc highbd_10_subpel_avg_var32x32_c =
- vpx_highbd_10_sub_pixel_avg_variance32x32_c;
-const SubpixAvgVarMxNFunc highbd_10_subpel_avg_var32x16_c =
- vpx_highbd_10_sub_pixel_avg_variance32x16_c;
-const SubpixAvgVarMxNFunc highbd_10_subpel_avg_var16x32_c =
- vpx_highbd_10_sub_pixel_avg_variance16x32_c;
-const SubpixAvgVarMxNFunc highbd_10_subpel_avg_var16x16_c =
- vpx_highbd_10_sub_pixel_avg_variance16x16_c;
-const SubpixAvgVarMxNFunc highbd_10_subpel_avg_var16x8_c =
- vpx_highbd_10_sub_pixel_avg_variance16x8_c;
-const SubpixAvgVarMxNFunc highbd_10_subpel_avg_var8x16_c =
- vpx_highbd_10_sub_pixel_avg_variance8x16_c;
-const SubpixAvgVarMxNFunc highbd_10_subpel_avg_var8x8_c =
- vpx_highbd_10_sub_pixel_avg_variance8x8_c;
-const SubpixAvgVarMxNFunc highbd_10_subpel_avg_var8x4_c =
- vpx_highbd_10_sub_pixel_avg_variance8x4_c;
-const SubpixAvgVarMxNFunc highbd_10_subpel_avg_var4x8_c =
- vpx_highbd_10_sub_pixel_avg_variance4x8_c;
-const SubpixAvgVarMxNFunc highbd_10_subpel_avg_var4x4_c =
- vpx_highbd_10_sub_pixel_avg_variance4x4_c;
-const SubpixAvgVarMxNFunc highbd_12_subpel_avg_var64x64_c =
- vpx_highbd_12_sub_pixel_avg_variance64x64_c;
-const SubpixAvgVarMxNFunc highbd_12_subpel_avg_var64x32_c =
- vpx_highbd_12_sub_pixel_avg_variance64x32_c;
-const SubpixAvgVarMxNFunc highbd_12_subpel_avg_var32x64_c =
- vpx_highbd_12_sub_pixel_avg_variance32x64_c;
-const SubpixAvgVarMxNFunc highbd_12_subpel_avg_var32x32_c =
- vpx_highbd_12_sub_pixel_avg_variance32x32_c;
-const SubpixAvgVarMxNFunc highbd_12_subpel_avg_var32x16_c =
- vpx_highbd_12_sub_pixel_avg_variance32x16_c;
-const SubpixAvgVarMxNFunc highbd_12_subpel_avg_var16x32_c =
- vpx_highbd_12_sub_pixel_avg_variance16x32_c;
-const SubpixAvgVarMxNFunc highbd_12_subpel_avg_var16x16_c =
- vpx_highbd_12_sub_pixel_avg_variance16x16_c;
-const SubpixAvgVarMxNFunc highbd_12_subpel_avg_var16x8_c =
- vpx_highbd_12_sub_pixel_avg_variance16x8_c;
-const SubpixAvgVarMxNFunc highbd_12_subpel_avg_var8x16_c =
- vpx_highbd_12_sub_pixel_avg_variance8x16_c;
-const SubpixAvgVarMxNFunc highbd_12_subpel_avg_var8x8_c =
- vpx_highbd_12_sub_pixel_avg_variance8x8_c;
-const SubpixAvgVarMxNFunc highbd_12_subpel_avg_var8x4_c =
- vpx_highbd_12_sub_pixel_avg_variance8x4_c;
-const SubpixAvgVarMxNFunc highbd_12_subpel_avg_var4x8_c =
- vpx_highbd_12_sub_pixel_avg_variance4x8_c;
-const SubpixAvgVarMxNFunc highbd_12_subpel_avg_var4x4_c =
- vpx_highbd_12_sub_pixel_avg_variance4x4_c;
INSTANTIATE_TEST_CASE_P(
C, VpxHBDSubpelAvgVarianceTest,
::testing::Values(
- make_tuple(6, 6, highbd_8_subpel_avg_var64x64_c, 8),
- make_tuple(6, 5, highbd_8_subpel_avg_var64x32_c, 8),
- make_tuple(5, 6, highbd_8_subpel_avg_var32x64_c, 8),
- make_tuple(5, 5, highbd_8_subpel_avg_var32x32_c, 8),
- make_tuple(5, 4, highbd_8_subpel_avg_var32x16_c, 8),
- make_tuple(4, 5, highbd_8_subpel_avg_var16x32_c, 8),
- make_tuple(4, 4, highbd_8_subpel_avg_var16x16_c, 8),
- make_tuple(4, 3, highbd_8_subpel_avg_var16x8_c, 8),
- make_tuple(3, 4, highbd_8_subpel_avg_var8x16_c, 8),
- make_tuple(3, 3, highbd_8_subpel_avg_var8x8_c, 8),
- make_tuple(3, 2, highbd_8_subpel_avg_var8x4_c, 8),
- make_tuple(2, 3, highbd_8_subpel_avg_var4x8_c, 8),
- make_tuple(2, 2, highbd_8_subpel_avg_var4x4_c, 8),
- make_tuple(6, 6, highbd_10_subpel_avg_var64x64_c, 10),
- make_tuple(6, 5, highbd_10_subpel_avg_var64x32_c, 10),
- make_tuple(5, 6, highbd_10_subpel_avg_var32x64_c, 10),
- make_tuple(5, 5, highbd_10_subpel_avg_var32x32_c, 10),
- make_tuple(5, 4, highbd_10_subpel_avg_var32x16_c, 10),
- make_tuple(4, 5, highbd_10_subpel_avg_var16x32_c, 10),
- make_tuple(4, 4, highbd_10_subpel_avg_var16x16_c, 10),
- make_tuple(4, 3, highbd_10_subpel_avg_var16x8_c, 10),
- make_tuple(3, 4, highbd_10_subpel_avg_var8x16_c, 10),
- make_tuple(3, 3, highbd_10_subpel_avg_var8x8_c, 10),
- make_tuple(3, 2, highbd_10_subpel_avg_var8x4_c, 10),
- make_tuple(2, 3, highbd_10_subpel_avg_var4x8_c, 10),
- make_tuple(2, 2, highbd_10_subpel_avg_var4x4_c, 10),
- make_tuple(6, 6, highbd_12_subpel_avg_var64x64_c, 12),
- make_tuple(6, 5, highbd_12_subpel_avg_var64x32_c, 12),
- make_tuple(5, 6, highbd_12_subpel_avg_var32x64_c, 12),
- make_tuple(5, 5, highbd_12_subpel_avg_var32x32_c, 12),
- make_tuple(5, 4, highbd_12_subpel_avg_var32x16_c, 12),
- make_tuple(4, 5, highbd_12_subpel_avg_var16x32_c, 12),
- make_tuple(4, 4, highbd_12_subpel_avg_var16x16_c, 12),
- make_tuple(4, 3, highbd_12_subpel_avg_var16x8_c, 12),
- make_tuple(3, 4, highbd_12_subpel_avg_var8x16_c, 12),
- make_tuple(3, 3, highbd_12_subpel_avg_var8x8_c, 12),
- make_tuple(3, 2, highbd_12_subpel_avg_var8x4_c, 12),
- make_tuple(2, 3, highbd_12_subpel_avg_var4x8_c, 12),
- make_tuple(2, 2, highbd_12_subpel_avg_var4x4_c, 12)));
+ 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),
+ 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),
+ 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)));
#endif // CONFIG_VP9_HIGHBITDEPTH
#if HAVE_MMX
-const VarianceMxNFunc mse16x16_mmx = vpx_mse16x16_mmx;
INSTANTIATE_TEST_CASE_P(MMX, VpxMseTest,
- ::testing::Values(make_tuple(4, 4, mse16x16_mmx)));
+ ::testing::Values(make_tuple(4, 4, &vpx_mse16x16_mmx)));
INSTANTIATE_TEST_CASE_P(MMX, SumOfSquaresTest,
::testing::Values(vpx_get_mb_ss_mmx));
-const VarianceMxNFunc variance16x16_mmx = vpx_variance16x16_mmx;
-const VarianceMxNFunc variance16x8_mmx = vpx_variance16x8_mmx;
-const VarianceMxNFunc variance8x16_mmx = vpx_variance8x16_mmx;
-const VarianceMxNFunc variance8x8_mmx = vpx_variance8x8_mmx;
-const VarianceMxNFunc variance4x4_mmx = vpx_variance4x4_mmx;
INSTANTIATE_TEST_CASE_P(
MMX, VpxVarianceTest,
- ::testing::Values(make_tuple(4, 4, variance16x16_mmx, 0),
- make_tuple(4, 3, variance16x8_mmx, 0),
- make_tuple(3, 4, variance8x16_mmx, 0),
- make_tuple(3, 3, variance8x8_mmx, 0),
- make_tuple(2, 2, variance4x4_mmx, 0)));
+ ::testing::Values(make_tuple(4, 4, &vpx_variance16x16_mmx, 0),
+ make_tuple(4, 3, &vpx_variance16x8_mmx, 0),
+ make_tuple(3, 4, &vpx_variance8x16_mmx, 0),
+ make_tuple(3, 3, &vpx_variance8x8_mmx, 0),
+ make_tuple(2, 2, &vpx_variance4x4_mmx, 0)));
-const SubpixVarMxNFunc subpel_var16x16_mmx = vpx_sub_pixel_variance16x16_mmx;
-const SubpixVarMxNFunc subpel_var16x8_mmx = vpx_sub_pixel_variance16x8_mmx;
-const SubpixVarMxNFunc subpel_var8x16_mmx = vpx_sub_pixel_variance8x16_mmx;
-const SubpixVarMxNFunc subpel_var8x8_mmx = vpx_sub_pixel_variance8x8_mmx;
-const SubpixVarMxNFunc subpel_var4x4_mmx = vpx_sub_pixel_variance4x4_mmx;
INSTANTIATE_TEST_CASE_P(
MMX, VpxSubpelVarianceTest,
- ::testing::Values(make_tuple(4, 4, subpel_var16x16_mmx, 0),
- make_tuple(4, 3, subpel_var16x8_mmx, 0),
- make_tuple(3, 4, subpel_var8x16_mmx, 0),
- make_tuple(3, 3, subpel_var8x8_mmx, 0),
- make_tuple(2, 2, subpel_var4x4_mmx, 0)));
+ ::testing::Values(make_tuple(4, 4, &vpx_sub_pixel_variance16x16_mmx, 0),
+ make_tuple(4, 3, &vpx_sub_pixel_variance16x8_mmx, 0),
+ make_tuple(3, 4, &vpx_sub_pixel_variance8x16_mmx, 0),
+ make_tuple(3, 3, &vpx_sub_pixel_variance8x8_mmx, 0),
+ make_tuple(2, 2, &vpx_sub_pixel_variance4x4_mmx, 0)));
#endif // HAVE_MMX
#if HAVE_SSE2
INSTANTIATE_TEST_CASE_P(SSE2, SumOfSquaresTest,
::testing::Values(vpx_get_mb_ss_sse2));
-const VarianceMxNFunc mse16x16_sse2 = vpx_mse16x16_sse2;
-const VarianceMxNFunc mse16x8_sse2 = vpx_mse16x8_sse2;
-const VarianceMxNFunc mse8x16_sse2 = vpx_mse8x16_sse2;
-const VarianceMxNFunc mse8x8_sse2 = vpx_mse8x8_sse2;
INSTANTIATE_TEST_CASE_P(SSE2, VpxMseTest,
- ::testing::Values(make_tuple(4, 4, mse16x16_sse2),
- make_tuple(4, 3, mse16x8_sse2),
- make_tuple(3, 4, mse8x16_sse2),
- make_tuple(3, 3, mse8x8_sse2)));
+ ::testing::Values(make_tuple(4, 4, &vpx_mse16x16_sse2),
+ make_tuple(4, 3, &vpx_mse16x8_sse2),
+ make_tuple(3, 4, &vpx_mse8x16_sse2),
+ make_tuple(3, 3, &vpx_mse8x8_sse2)));
-const VarianceMxNFunc variance64x64_sse2 = vpx_variance64x64_sse2;
-const VarianceMxNFunc variance64x32_sse2 = vpx_variance64x32_sse2;
-const VarianceMxNFunc variance32x64_sse2 = vpx_variance32x64_sse2;
-const VarianceMxNFunc variance32x32_sse2 = vpx_variance32x32_sse2;
-const VarianceMxNFunc variance32x16_sse2 = vpx_variance32x16_sse2;
-const VarianceMxNFunc variance16x32_sse2 = vpx_variance16x32_sse2;
-const VarianceMxNFunc variance16x16_sse2 = vpx_variance16x16_sse2;
-const VarianceMxNFunc variance16x8_sse2 = vpx_variance16x8_sse2;
-const VarianceMxNFunc variance8x16_sse2 = vpx_variance8x16_sse2;
-const VarianceMxNFunc variance8x8_sse2 = vpx_variance8x8_sse2;
-const VarianceMxNFunc variance8x4_sse2 = vpx_variance8x4_sse2;
-const VarianceMxNFunc variance4x8_sse2 = vpx_variance4x8_sse2;
-const VarianceMxNFunc variance4x4_sse2 = vpx_variance4x4_sse2;
INSTANTIATE_TEST_CASE_P(
SSE2, VpxVarianceTest,
- ::testing::Values(make_tuple(6, 6, variance64x64_sse2, 0),
- make_tuple(6, 5, variance64x32_sse2, 0),
- make_tuple(5, 6, variance32x64_sse2, 0),
- make_tuple(5, 5, variance32x32_sse2, 0),
- make_tuple(5, 4, variance32x16_sse2, 0),
- make_tuple(4, 5, variance16x32_sse2, 0),
- make_tuple(4, 4, variance16x16_sse2, 0),
- make_tuple(4, 3, variance16x8_sse2, 0),
- make_tuple(3, 4, variance8x16_sse2, 0),
- make_tuple(3, 3, variance8x8_sse2, 0),
- make_tuple(3, 2, variance8x4_sse2, 0),
- make_tuple(2, 3, variance4x8_sse2, 0),
- make_tuple(2, 2, variance4x4_sse2, 0)));
+ ::testing::Values(make_tuple(6, 6, &vpx_variance64x64_sse2, 0),
+ make_tuple(6, 5, &vpx_variance64x32_sse2, 0),
+ make_tuple(5, 6, &vpx_variance32x64_sse2, 0),
+ make_tuple(5, 5, &vpx_variance32x32_sse2, 0),
+ make_tuple(5, 4, &vpx_variance32x16_sse2, 0),
+ make_tuple(4, 5, &vpx_variance16x32_sse2, 0),
+ make_tuple(4, 4, &vpx_variance16x16_sse2, 0),
+ make_tuple(4, 3, &vpx_variance16x8_sse2, 0),
+ make_tuple(3, 4, &vpx_variance8x16_sse2, 0),
+ make_tuple(3, 3, &vpx_variance8x8_sse2, 0),
+ make_tuple(3, 2, &vpx_variance8x4_sse2, 0),
+ make_tuple(2, 3, &vpx_variance4x8_sse2, 0),
+ make_tuple(2, 2, &vpx_variance4x4_sse2, 0)));
#if CONFIG_USE_X86INC
-const SubpixVarMxNFunc subpel_variance64x64_sse2 =
- vpx_sub_pixel_variance64x64_sse2;
-const SubpixVarMxNFunc subpel_variance64x32_sse2 =
- vpx_sub_pixel_variance64x32_sse2;
-const SubpixVarMxNFunc subpel_variance32x64_sse2 =
- vpx_sub_pixel_variance32x64_sse2;
-const SubpixVarMxNFunc subpel_variance32x32_sse2 =
- vpx_sub_pixel_variance32x32_sse2;
-const SubpixVarMxNFunc subpel_variance32x16_sse2 =
- vpx_sub_pixel_variance32x16_sse2;
-const SubpixVarMxNFunc subpel_variance16x32_sse2 =
- vpx_sub_pixel_variance16x32_sse2;
-const SubpixVarMxNFunc subpel_variance16x16_sse2 =
- vpx_sub_pixel_variance16x16_sse2;
-const SubpixVarMxNFunc subpel_variance16x8_sse2 =
- vpx_sub_pixel_variance16x8_sse2;
-const SubpixVarMxNFunc subpel_variance8x16_sse2 =
- vpx_sub_pixel_variance8x16_sse2;
-const SubpixVarMxNFunc subpel_variance8x8_sse2 = vpx_sub_pixel_variance8x8_sse2;
-const SubpixVarMxNFunc subpel_variance8x4_sse2 = vpx_sub_pixel_variance8x4_sse2;
-const SubpixVarMxNFunc subpel_variance4x8_sse = vpx_sub_pixel_variance4x8_sse;
-const SubpixVarMxNFunc subpel_variance4x4_sse = vpx_sub_pixel_variance4x4_sse;
INSTANTIATE_TEST_CASE_P(
SSE2, VpxSubpelVarianceTest,
- ::testing::Values(make_tuple(6, 6, subpel_variance64x64_sse2, 0),
- make_tuple(6, 5, subpel_variance64x32_sse2, 0),
- make_tuple(5, 6, subpel_variance32x64_sse2, 0),
- make_tuple(5, 5, subpel_variance32x32_sse2, 0),
- make_tuple(5, 4, subpel_variance32x16_sse2, 0),
- make_tuple(4, 5, subpel_variance16x32_sse2, 0),
- make_tuple(4, 4, subpel_variance16x16_sse2, 0),
- make_tuple(4, 3, subpel_variance16x8_sse2, 0),
- make_tuple(3, 4, subpel_variance8x16_sse2, 0),
- make_tuple(3, 3, subpel_variance8x8_sse2, 0),
- make_tuple(3, 2, subpel_variance8x4_sse2, 0),
- make_tuple(2, 3, subpel_variance4x8_sse, 0),
- make_tuple(2, 2, subpel_variance4x4_sse, 0)));
+ ::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_sse, 0),
+ make_tuple(2, 2, &vpx_sub_pixel_variance4x4_sse, 0)));
-const SubpixAvgVarMxNFunc subpel_avg_variance64x64_sse2 =
- vpx_sub_pixel_avg_variance64x64_sse2;
-const SubpixAvgVarMxNFunc subpel_avg_variance64x32_sse2 =
- vpx_sub_pixel_avg_variance64x32_sse2;
-const SubpixAvgVarMxNFunc subpel_avg_variance32x64_sse2 =
- vpx_sub_pixel_avg_variance32x64_sse2;
-const SubpixAvgVarMxNFunc subpel_avg_variance32x32_sse2 =
- vpx_sub_pixel_avg_variance32x32_sse2;
-const SubpixAvgVarMxNFunc subpel_avg_variance32x16_sse2 =
- vpx_sub_pixel_avg_variance32x16_sse2;
-const SubpixAvgVarMxNFunc subpel_avg_variance16x32_sse2 =
- vpx_sub_pixel_avg_variance16x32_sse2;
-const SubpixAvgVarMxNFunc subpel_avg_variance16x16_sse2 =
- vpx_sub_pixel_avg_variance16x16_sse2;
-const SubpixAvgVarMxNFunc subpel_avg_variance16x8_sse2 =
- vpx_sub_pixel_avg_variance16x8_sse2;
-const SubpixAvgVarMxNFunc subpel_avg_variance8x16_sse2 =
- vpx_sub_pixel_avg_variance8x16_sse2;
-const SubpixAvgVarMxNFunc subpel_avg_variance8x8_sse2 =
- vpx_sub_pixel_avg_variance8x8_sse2;
-const SubpixAvgVarMxNFunc subpel_avg_variance8x4_sse2 =
- vpx_sub_pixel_avg_variance8x4_sse2;
-const SubpixAvgVarMxNFunc subpel_avg_variance4x8_sse =
- vpx_sub_pixel_avg_variance4x8_sse;
-const SubpixAvgVarMxNFunc subpel_avg_variance4x4_sse =
- vpx_sub_pixel_avg_variance4x4_sse;
INSTANTIATE_TEST_CASE_P(
SSE2, VpxSubpelAvgVarianceTest,
::testing::Values(
- make_tuple(6, 6, subpel_avg_variance64x64_sse2, 0),
- make_tuple(6, 5, subpel_avg_variance64x32_sse2, 0),
- make_tuple(5, 6, subpel_avg_variance32x64_sse2, 0),
- make_tuple(5, 5, subpel_avg_variance32x32_sse2, 0),
- make_tuple(5, 4, subpel_avg_variance32x16_sse2, 0),
- make_tuple(4, 5, subpel_avg_variance16x32_sse2, 0),
- make_tuple(4, 4, subpel_avg_variance16x16_sse2, 0),
- make_tuple(4, 3, subpel_avg_variance16x8_sse2, 0),
- make_tuple(3, 4, subpel_avg_variance8x16_sse2, 0),
- make_tuple(3, 3, subpel_avg_variance8x8_sse2, 0),
- make_tuple(3, 2, subpel_avg_variance8x4_sse2, 0),
- make_tuple(2, 3, subpel_avg_variance4x8_sse, 0),
- make_tuple(2, 2, subpel_avg_variance4x4_sse, 0)));
+ 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_sse, 0),
+ make_tuple(2, 2, &vpx_sub_pixel_avg_variance4x4_sse, 0)));
#endif // CONFIG_USE_X86INC
#if CONFIG_VP9_HIGHBITDEPTH
/* TODO(debargha): This test does not support the highbd version
-const VarianceMxNFunc highbd_12_mse16x16_sse2 = vpx_highbd_12_mse16x16_sse2;
-const VarianceMxNFunc highbd_12_mse16x8_sse2 = vpx_highbd_12_mse16x8_sse2;
-const VarianceMxNFunc highbd_12_mse8x16_sse2 = vpx_highbd_12_mse8x16_sse2;
-const VarianceMxNFunc highbd_12_mse8x8_sse2 = vpx_highbd_12_mse8x8_sse2;
-
-const VarianceMxNFunc highbd_10_mse16x16_sse2 = vpx_highbd_10_mse16x16_sse2;
-const VarianceMxNFunc highbd_10_mse16x8_sse2 = vpx_highbd_10_mse16x8_sse2;
-const VarianceMxNFunc highbd_10_mse8x16_sse2 = vpx_highbd_10_mse8x16_sse2;
-const VarianceMxNFunc highbd_10_mse8x8_sse2 = vpx_highbd_10_mse8x8_sse2;
-
-const VarianceMxNFunc highbd_8_mse16x16_sse2 = vpx_highbd_8_mse16x16_sse2;
-const VarianceMxNFunc highbd_8_mse16x8_sse2 = vpx_highbd_8_mse16x8_sse2;
-const VarianceMxNFunc highbd_8_mse8x16_sse2 = vpx_highbd_8_mse8x16_sse2;
-const VarianceMxNFunc highbd_8_mse8x8_sse2 = vpx_highbd_8_mse8x8_sse2;
INSTANTIATE_TEST_CASE_P(
- SSE2, VpxHBDMseTest, ::testing::Values(make_tuple(4, 4, highbd_12_mse16x16_sse2),
- make_tuple(4, 3, highbd_12_mse16x8_sse2),
- make_tuple(3, 4, highbd_12_mse8x16_sse2),
- make_tuple(3, 3, highbd_12_mse8x8_sse2),
- make_tuple(4, 4, highbd_10_mse16x16_sse2),
- make_tuple(4, 3, highbd_10_mse16x8_sse2),
- make_tuple(3, 4, highbd_10_mse8x16_sse2),
- make_tuple(3, 3, highbd_10_mse8x8_sse2),
- make_tuple(4, 4, highbd_8_mse16x16_sse2),
- make_tuple(4, 3, highbd_8_mse16x8_sse2),
- make_tuple(3, 4, highbd_8_mse8x16_sse2),
- make_tuple(3, 3, highbd_8_mse8x8_sse2)));
+ SSE2, VpxHBDMseTest,
+ ::testing::Values(make_tuple(4, 4, &vpx_highbd_12_mse16x16_sse2),
+ make_tuple(4, 3, &vpx_highbd_12_mse16x8_sse2),
+ make_tuple(3, 4, &vpx_highbd_12_mse8x16_sse2),
+ make_tuple(3, 3, &vpx_highbd_12_mse8x8_sse2),
+ make_tuple(4, 4, &vpx_highbd_10_mse16x16_sse2),
+ make_tuple(4, 3, &vpx_highbd_10_mse16x8_sse2),
+ make_tuple(3, 4, &vpx_highbd_10_mse8x16_sse2),
+ make_tuple(3, 3, &vpx_highbd_10_mse8x8_sse2),
+ make_tuple(4, 4, &vpx_highbd_8_mse16x16_sse2),
+ make_tuple(4, 3, &vpx_highbd_8_mse16x8_sse2),
+ make_tuple(3, 4, &vpx_highbd_8_mse8x16_sse2),
+ make_tuple(3, 3, &vpx_highbd_8_mse8x8_sse2)));
*/
-const VarianceMxNFunc highbd_12_variance64x64_sse2 =
- vpx_highbd_12_variance64x64_sse2;
-const VarianceMxNFunc highbd_12_variance64x32_sse2 =
- vpx_highbd_12_variance64x32_sse2;
-const VarianceMxNFunc highbd_12_variance32x64_sse2 =
- vpx_highbd_12_variance32x64_sse2;
-const VarianceMxNFunc highbd_12_variance32x32_sse2 =
- vpx_highbd_12_variance32x32_sse2;
-const VarianceMxNFunc highbd_12_variance32x16_sse2 =
- vpx_highbd_12_variance32x16_sse2;
-const VarianceMxNFunc highbd_12_variance16x32_sse2 =
- vpx_highbd_12_variance16x32_sse2;
-const VarianceMxNFunc highbd_12_variance16x16_sse2 =
- vpx_highbd_12_variance16x16_sse2;
-const VarianceMxNFunc highbd_12_variance16x8_sse2 =
- vpx_highbd_12_variance16x8_sse2;
-const VarianceMxNFunc highbd_12_variance8x16_sse2 =
- vpx_highbd_12_variance8x16_sse2;
-const VarianceMxNFunc highbd_12_variance8x8_sse2 =
- vpx_highbd_12_variance8x8_sse2;
-const VarianceMxNFunc highbd_10_variance64x64_sse2 =
- vpx_highbd_10_variance64x64_sse2;
-const VarianceMxNFunc highbd_10_variance64x32_sse2 =
- vpx_highbd_10_variance64x32_sse2;
-const VarianceMxNFunc highbd_10_variance32x64_sse2 =
- vpx_highbd_10_variance32x64_sse2;
-const VarianceMxNFunc highbd_10_variance32x32_sse2 =
- vpx_highbd_10_variance32x32_sse2;
-const VarianceMxNFunc highbd_10_variance32x16_sse2 =
- vpx_highbd_10_variance32x16_sse2;
-const VarianceMxNFunc highbd_10_variance16x32_sse2 =
- vpx_highbd_10_variance16x32_sse2;
-const VarianceMxNFunc highbd_10_variance16x16_sse2 =
- vpx_highbd_10_variance16x16_sse2;
-const VarianceMxNFunc highbd_10_variance16x8_sse2 =
- vpx_highbd_10_variance16x8_sse2;
-const VarianceMxNFunc highbd_10_variance8x16_sse2 =
- vpx_highbd_10_variance8x16_sse2;
-const VarianceMxNFunc highbd_10_variance8x8_sse2 =
- vpx_highbd_10_variance8x8_sse2;
-const VarianceMxNFunc highbd_8_variance64x64_sse2 =
- vpx_highbd_8_variance64x64_sse2;
-const VarianceMxNFunc highbd_8_variance64x32_sse2 =
- vpx_highbd_8_variance64x32_sse2;
-const VarianceMxNFunc highbd_8_variance32x64_sse2 =
- vpx_highbd_8_variance32x64_sse2;
-const VarianceMxNFunc highbd_8_variance32x32_sse2 =
- vpx_highbd_8_variance32x32_sse2;
-const VarianceMxNFunc highbd_8_variance32x16_sse2 =
- vpx_highbd_8_variance32x16_sse2;
-const VarianceMxNFunc highbd_8_variance16x32_sse2 =
- vpx_highbd_8_variance16x32_sse2;
-const VarianceMxNFunc highbd_8_variance16x16_sse2 =
- vpx_highbd_8_variance16x16_sse2;
-const VarianceMxNFunc highbd_8_variance16x8_sse2 =
- vpx_highbd_8_variance16x8_sse2;
-const VarianceMxNFunc highbd_8_variance8x16_sse2 =
- vpx_highbd_8_variance8x16_sse2;
-const VarianceMxNFunc highbd_8_variance8x8_sse2 =
- vpx_highbd_8_variance8x8_sse2;
-
INSTANTIATE_TEST_CASE_P(
SSE2, VpxHBDVarianceTest,
- ::testing::Values(make_tuple(6, 6, highbd_12_variance64x64_sse2, 12),
- make_tuple(6, 5, highbd_12_variance64x32_sse2, 12),
- make_tuple(5, 6, highbd_12_variance32x64_sse2, 12),
- make_tuple(5, 5, highbd_12_variance32x32_sse2, 12),
- make_tuple(5, 4, highbd_12_variance32x16_sse2, 12),
- make_tuple(4, 5, highbd_12_variance16x32_sse2, 12),
- make_tuple(4, 4, highbd_12_variance16x16_sse2, 12),
- make_tuple(4, 3, highbd_12_variance16x8_sse2, 12),
- make_tuple(3, 4, highbd_12_variance8x16_sse2, 12),
- make_tuple(3, 3, highbd_12_variance8x8_sse2, 12),
- make_tuple(6, 6, highbd_10_variance64x64_sse2, 10),
- make_tuple(6, 5, highbd_10_variance64x32_sse2, 10),
- make_tuple(5, 6, highbd_10_variance32x64_sse2, 10),
- make_tuple(5, 5, highbd_10_variance32x32_sse2, 10),
- make_tuple(5, 4, highbd_10_variance32x16_sse2, 10),
- make_tuple(4, 5, highbd_10_variance16x32_sse2, 10),
- make_tuple(4, 4, highbd_10_variance16x16_sse2, 10),
- make_tuple(4, 3, highbd_10_variance16x8_sse2, 10),
- make_tuple(3, 4, highbd_10_variance8x16_sse2, 10),
- make_tuple(3, 3, highbd_10_variance8x8_sse2, 10),
- make_tuple(6, 6, highbd_8_variance64x64_sse2, 8),
- make_tuple(6, 5, highbd_8_variance64x32_sse2, 8),
- make_tuple(5, 6, highbd_8_variance32x64_sse2, 8),
- make_tuple(5, 5, highbd_8_variance32x32_sse2, 8),
- make_tuple(5, 4, highbd_8_variance32x16_sse2, 8),
- make_tuple(4, 5, highbd_8_variance16x32_sse2, 8),
- make_tuple(4, 4, highbd_8_variance16x16_sse2, 8),
- make_tuple(4, 3, highbd_8_variance16x8_sse2, 8),
- make_tuple(3, 4, highbd_8_variance8x16_sse2, 8),
- make_tuple(3, 3, highbd_8_variance8x8_sse2, 8)));
+ ::testing::Values(make_tuple(6, 6, &vpx_highbd_12_variance64x64_sse2, 12),
+ make_tuple(6, 5, &vpx_highbd_12_variance64x32_sse2, 12),
+ make_tuple(5, 6, &vpx_highbd_12_variance32x64_sse2, 12),
+ make_tuple(5, 5, &vpx_highbd_12_variance32x32_sse2, 12),
+ make_tuple(5, 4, &vpx_highbd_12_variance32x16_sse2, 12),
+ make_tuple(4, 5, &vpx_highbd_12_variance16x32_sse2, 12),
+ make_tuple(4, 4, &vpx_highbd_12_variance16x16_sse2, 12),
+ make_tuple(4, 3, &vpx_highbd_12_variance16x8_sse2, 12),
+ make_tuple(3, 4, &vpx_highbd_12_variance8x16_sse2, 12),
+ make_tuple(3, 3, &vpx_highbd_12_variance8x8_sse2, 12),
+ make_tuple(6, 6, &vpx_highbd_10_variance64x64_sse2, 10),
+ make_tuple(6, 5, &vpx_highbd_10_variance64x32_sse2, 10),
+ make_tuple(5, 6, &vpx_highbd_10_variance32x64_sse2, 10),
+ make_tuple(5, 5, &vpx_highbd_10_variance32x32_sse2, 10),
+ make_tuple(5, 4, &vpx_highbd_10_variance32x16_sse2, 10),
+ make_tuple(4, 5, &vpx_highbd_10_variance16x32_sse2, 10),
+ make_tuple(4, 4, &vpx_highbd_10_variance16x16_sse2, 10),
+ make_tuple(4, 3, &vpx_highbd_10_variance16x8_sse2, 10),
+ make_tuple(3, 4, &vpx_highbd_10_variance8x16_sse2, 10),
+ make_tuple(3, 3, &vpx_highbd_10_variance8x8_sse2, 10),
+ make_tuple(6, 6, &vpx_highbd_8_variance64x64_sse2, 8),
+ make_tuple(6, 5, &vpx_highbd_8_variance64x32_sse2, 8),
+ make_tuple(5, 6, &vpx_highbd_8_variance32x64_sse2, 8),
+ make_tuple(5, 5, &vpx_highbd_8_variance32x32_sse2, 8),
+ make_tuple(5, 4, &vpx_highbd_8_variance32x16_sse2, 8),
+ make_tuple(4, 5, &vpx_highbd_8_variance16x32_sse2, 8),
+ make_tuple(4, 4, &vpx_highbd_8_variance16x16_sse2, 8),
+ make_tuple(4, 3, &vpx_highbd_8_variance16x8_sse2, 8),
+ make_tuple(3, 4, &vpx_highbd_8_variance8x16_sse2, 8),
+ make_tuple(3, 3, &vpx_highbd_8_variance8x8_sse2, 8)));
#if CONFIG_USE_X86INC
-const SubpixVarMxNFunc highbd_12_subpel_variance64x64_sse2 =
- vpx_highbd_12_sub_pixel_variance64x64_sse2;
-const SubpixVarMxNFunc highbd_12_subpel_variance64x32_sse2 =
- vpx_highbd_12_sub_pixel_variance64x32_sse2;
-const SubpixVarMxNFunc highbd_12_subpel_variance32x64_sse2 =
- vpx_highbd_12_sub_pixel_variance32x64_sse2;
-const SubpixVarMxNFunc highbd_12_subpel_variance32x32_sse2 =
- vpx_highbd_12_sub_pixel_variance32x32_sse2;
-const SubpixVarMxNFunc highbd_12_subpel_variance32x16_sse2 =
- vpx_highbd_12_sub_pixel_variance32x16_sse2;
-const SubpixVarMxNFunc highbd_12_subpel_variance16x32_sse2 =
- vpx_highbd_12_sub_pixel_variance16x32_sse2;
-const SubpixVarMxNFunc highbd_12_subpel_variance16x16_sse2 =
- vpx_highbd_12_sub_pixel_variance16x16_sse2;
-const SubpixVarMxNFunc highbd_12_subpel_variance16x8_sse2 =
- vpx_highbd_12_sub_pixel_variance16x8_sse2;
-const SubpixVarMxNFunc highbd_12_subpel_variance8x16_sse2 =
- vpx_highbd_12_sub_pixel_variance8x16_sse2;
-const SubpixVarMxNFunc highbd_12_subpel_variance8x8_sse2 =
- vpx_highbd_12_sub_pixel_variance8x8_sse2;
-const SubpixVarMxNFunc highbd_12_subpel_variance8x4_sse2 =
- vpx_highbd_12_sub_pixel_variance8x4_sse2;
-const SubpixVarMxNFunc highbd_10_subpel_variance64x64_sse2 =
- vpx_highbd_10_sub_pixel_variance64x64_sse2;
-const SubpixVarMxNFunc highbd_10_subpel_variance64x32_sse2 =
- vpx_highbd_10_sub_pixel_variance64x32_sse2;
-const SubpixVarMxNFunc highbd_10_subpel_variance32x64_sse2 =
- vpx_highbd_10_sub_pixel_variance32x64_sse2;
-const SubpixVarMxNFunc highbd_10_subpel_variance32x32_sse2 =
- vpx_highbd_10_sub_pixel_variance32x32_sse2;
-const SubpixVarMxNFunc highbd_10_subpel_variance32x16_sse2 =
- vpx_highbd_10_sub_pixel_variance32x16_sse2;
-const SubpixVarMxNFunc highbd_10_subpel_variance16x32_sse2 =
- vpx_highbd_10_sub_pixel_variance16x32_sse2;
-const SubpixVarMxNFunc highbd_10_subpel_variance16x16_sse2 =
- vpx_highbd_10_sub_pixel_variance16x16_sse2;
-const SubpixVarMxNFunc highbd_10_subpel_variance16x8_sse2 =
- vpx_highbd_10_sub_pixel_variance16x8_sse2;
-const SubpixVarMxNFunc highbd_10_subpel_variance8x16_sse2 =
- vpx_highbd_10_sub_pixel_variance8x16_sse2;
-const SubpixVarMxNFunc highbd_10_subpel_variance8x8_sse2 =
- vpx_highbd_10_sub_pixel_variance8x8_sse2;
-const SubpixVarMxNFunc highbd_10_subpel_variance8x4_sse2 =
- vpx_highbd_10_sub_pixel_variance8x4_sse2;
-const SubpixVarMxNFunc highbd_8_subpel_variance64x64_sse2 =
- vpx_highbd_8_sub_pixel_variance64x64_sse2;
-const SubpixVarMxNFunc highbd_8_subpel_variance64x32_sse2 =
- vpx_highbd_8_sub_pixel_variance64x32_sse2;
-const SubpixVarMxNFunc highbd_8_subpel_variance32x64_sse2 =
- vpx_highbd_8_sub_pixel_variance32x64_sse2;
-const SubpixVarMxNFunc highbd_8_subpel_variance32x32_sse2 =
- vpx_highbd_8_sub_pixel_variance32x32_sse2;
-const SubpixVarMxNFunc highbd_8_subpel_variance32x16_sse2 =
- vpx_highbd_8_sub_pixel_variance32x16_sse2;
-const SubpixVarMxNFunc highbd_8_subpel_variance16x32_sse2 =
- vpx_highbd_8_sub_pixel_variance16x32_sse2;
-const SubpixVarMxNFunc highbd_8_subpel_variance16x16_sse2 =
- vpx_highbd_8_sub_pixel_variance16x16_sse2;
-const SubpixVarMxNFunc highbd_8_subpel_variance16x8_sse2 =
- vpx_highbd_8_sub_pixel_variance16x8_sse2;
-const SubpixVarMxNFunc highbd_8_subpel_variance8x16_sse2 =
- vpx_highbd_8_sub_pixel_variance8x16_sse2;
-const SubpixVarMxNFunc highbd_8_subpel_variance8x8_sse2 =
- vpx_highbd_8_sub_pixel_variance8x8_sse2;
-const SubpixVarMxNFunc highbd_8_subpel_variance8x4_sse2 =
- vpx_highbd_8_sub_pixel_variance8x4_sse2;
INSTANTIATE_TEST_CASE_P(
SSE2, VpxHBDSubpelVarianceTest,
- ::testing::Values(make_tuple(6, 6, highbd_12_subpel_variance64x64_sse2, 12),
- make_tuple(6, 5, highbd_12_subpel_variance64x32_sse2, 12),
- make_tuple(5, 6, highbd_12_subpel_variance32x64_sse2, 12),
- make_tuple(5, 5, highbd_12_subpel_variance32x32_sse2, 12),
- make_tuple(5, 4, highbd_12_subpel_variance32x16_sse2, 12),
- make_tuple(4, 5, highbd_12_subpel_variance16x32_sse2, 12),
- make_tuple(4, 4, highbd_12_subpel_variance16x16_sse2, 12),
- make_tuple(4, 3, highbd_12_subpel_variance16x8_sse2, 12),
- make_tuple(3, 4, highbd_12_subpel_variance8x16_sse2, 12),
- make_tuple(3, 3, highbd_12_subpel_variance8x8_sse2, 12),
- make_tuple(3, 2, highbd_12_subpel_variance8x4_sse2, 12),
- make_tuple(6, 6, highbd_10_subpel_variance64x64_sse2, 10),
- make_tuple(6, 5, highbd_10_subpel_variance64x32_sse2, 10),
- make_tuple(5, 6, highbd_10_subpel_variance32x64_sse2, 10),
- make_tuple(5, 5, highbd_10_subpel_variance32x32_sse2, 10),
- make_tuple(5, 4, highbd_10_subpel_variance32x16_sse2, 10),
- make_tuple(4, 5, highbd_10_subpel_variance16x32_sse2, 10),
- make_tuple(4, 4, highbd_10_subpel_variance16x16_sse2, 10),
- make_tuple(4, 3, highbd_10_subpel_variance16x8_sse2, 10),
- make_tuple(3, 4, highbd_10_subpel_variance8x16_sse2, 10),
- make_tuple(3, 3, highbd_10_subpel_variance8x8_sse2, 10),
- make_tuple(3, 2, highbd_10_subpel_variance8x4_sse2, 10),
- make_tuple(6, 6, highbd_8_subpel_variance64x64_sse2, 8),
- make_tuple(6, 5, highbd_8_subpel_variance64x32_sse2, 8),
- make_tuple(5, 6, highbd_8_subpel_variance32x64_sse2, 8),
- make_tuple(5, 5, highbd_8_subpel_variance32x32_sse2, 8),
- make_tuple(5, 4, highbd_8_subpel_variance32x16_sse2, 8),
- make_tuple(4, 5, highbd_8_subpel_variance16x32_sse2, 8),
- make_tuple(4, 4, highbd_8_subpel_variance16x16_sse2, 8),
- make_tuple(4, 3, highbd_8_subpel_variance16x8_sse2, 8),
- make_tuple(3, 4, highbd_8_subpel_variance8x16_sse2, 8),
- make_tuple(3, 3, highbd_8_subpel_variance8x8_sse2, 8),
- make_tuple(3, 2, highbd_8_subpel_variance8x4_sse2, 8)));
+ ::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)));
-const SubpixAvgVarMxNFunc highbd_12_subpel_avg_variance64x64_sse2 =
- vpx_highbd_12_sub_pixel_avg_variance64x64_sse2;
-const SubpixAvgVarMxNFunc highbd_12_subpel_avg_variance64x32_sse2 =
- vpx_highbd_12_sub_pixel_avg_variance64x32_sse2;
-const SubpixAvgVarMxNFunc highbd_12_subpel_avg_variance32x64_sse2 =
- vpx_highbd_12_sub_pixel_avg_variance32x64_sse2;
-const SubpixAvgVarMxNFunc highbd_12_subpel_avg_variance32x32_sse2 =
- vpx_highbd_12_sub_pixel_avg_variance32x32_sse2;
-const SubpixAvgVarMxNFunc highbd_12_subpel_avg_variance32x16_sse2 =
- vpx_highbd_12_sub_pixel_avg_variance32x16_sse2;
-const SubpixAvgVarMxNFunc highbd_12_subpel_avg_variance16x32_sse2 =
- vpx_highbd_12_sub_pixel_avg_variance16x32_sse2;
-const SubpixAvgVarMxNFunc highbd_12_subpel_avg_variance16x16_sse2 =
- vpx_highbd_12_sub_pixel_avg_variance16x16_sse2;
-const SubpixAvgVarMxNFunc highbd_12_subpel_avg_variance16x8_sse2 =
- vpx_highbd_12_sub_pixel_avg_variance16x8_sse2;
-const SubpixAvgVarMxNFunc highbd_12_subpel_avg_variance8x16_sse2 =
- vpx_highbd_12_sub_pixel_avg_variance8x16_sse2;
-const SubpixAvgVarMxNFunc highbd_12_subpel_avg_variance8x8_sse2 =
- vpx_highbd_12_sub_pixel_avg_variance8x8_sse2;
-const SubpixAvgVarMxNFunc highbd_12_subpel_avg_variance8x4_sse2 =
- vpx_highbd_12_sub_pixel_avg_variance8x4_sse2;
-const SubpixAvgVarMxNFunc highbd_10_subpel_avg_variance64x64_sse2 =
- vpx_highbd_10_sub_pixel_avg_variance64x64_sse2;
-const SubpixAvgVarMxNFunc highbd_10_subpel_avg_variance64x32_sse2 =
- vpx_highbd_10_sub_pixel_avg_variance64x32_sse2;
-const SubpixAvgVarMxNFunc highbd_10_subpel_avg_variance32x64_sse2 =
- vpx_highbd_10_sub_pixel_avg_variance32x64_sse2;
-const SubpixAvgVarMxNFunc highbd_10_subpel_avg_variance32x32_sse2 =
- vpx_highbd_10_sub_pixel_avg_variance32x32_sse2;
-const SubpixAvgVarMxNFunc highbd_10_subpel_avg_variance32x16_sse2 =
- vpx_highbd_10_sub_pixel_avg_variance32x16_sse2;
-const SubpixAvgVarMxNFunc highbd_10_subpel_avg_variance16x32_sse2 =
- vpx_highbd_10_sub_pixel_avg_variance16x32_sse2;
-const SubpixAvgVarMxNFunc highbd_10_subpel_avg_variance16x16_sse2 =
- vpx_highbd_10_sub_pixel_avg_variance16x16_sse2;
-const SubpixAvgVarMxNFunc highbd_10_subpel_avg_variance16x8_sse2 =
- vpx_highbd_10_sub_pixel_avg_variance16x8_sse2;
-const SubpixAvgVarMxNFunc highbd_10_subpel_avg_variance8x16_sse2 =
- vpx_highbd_10_sub_pixel_avg_variance8x16_sse2;
-const SubpixAvgVarMxNFunc highbd_10_subpel_avg_variance8x8_sse2 =
- vpx_highbd_10_sub_pixel_avg_variance8x8_sse2;
-const SubpixAvgVarMxNFunc highbd_10_subpel_avg_variance8x4_sse2 =
- vpx_highbd_10_sub_pixel_avg_variance8x4_sse2;
-const SubpixAvgVarMxNFunc highbd_8_subpel_avg_variance64x64_sse2 =
- vpx_highbd_8_sub_pixel_avg_variance64x64_sse2;
-const SubpixAvgVarMxNFunc highbd_8_subpel_avg_variance64x32_sse2 =
- vpx_highbd_8_sub_pixel_avg_variance64x32_sse2;
-const SubpixAvgVarMxNFunc highbd_8_subpel_avg_variance32x64_sse2 =
- vpx_highbd_8_sub_pixel_avg_variance32x64_sse2;
-const SubpixAvgVarMxNFunc highbd_8_subpel_avg_variance32x32_sse2 =
- vpx_highbd_8_sub_pixel_avg_variance32x32_sse2;
-const SubpixAvgVarMxNFunc highbd_8_subpel_avg_variance32x16_sse2 =
- vpx_highbd_8_sub_pixel_avg_variance32x16_sse2;
-const SubpixAvgVarMxNFunc highbd_8_subpel_avg_variance16x32_sse2 =
- vpx_highbd_8_sub_pixel_avg_variance16x32_sse2;
-const SubpixAvgVarMxNFunc highbd_8_subpel_avg_variance16x16_sse2 =
- vpx_highbd_8_sub_pixel_avg_variance16x16_sse2;
-const SubpixAvgVarMxNFunc highbd_8_subpel_avg_variance16x8_sse2 =
- vpx_highbd_8_sub_pixel_avg_variance16x8_sse2;
-const SubpixAvgVarMxNFunc highbd_8_subpel_avg_variance8x16_sse2 =
- vpx_highbd_8_sub_pixel_avg_variance8x16_sse2;
-const SubpixAvgVarMxNFunc highbd_8_subpel_avg_variance8x8_sse2 =
- vpx_highbd_8_sub_pixel_avg_variance8x8_sse2;
-const SubpixAvgVarMxNFunc highbd_8_subpel_avg_variance8x4_sse2 =
- vpx_highbd_8_sub_pixel_avg_variance8x4_sse2;
INSTANTIATE_TEST_CASE_P(
SSE2, VpxHBDSubpelAvgVarianceTest,
::testing::Values(
- make_tuple(6, 6, highbd_12_subpel_avg_variance64x64_sse2, 12),
- make_tuple(6, 5, highbd_12_subpel_avg_variance64x32_sse2, 12),
- make_tuple(5, 6, highbd_12_subpel_avg_variance32x64_sse2, 12),
- make_tuple(5, 5, highbd_12_subpel_avg_variance32x32_sse2, 12),
- make_tuple(5, 4, highbd_12_subpel_avg_variance32x16_sse2, 12),
- make_tuple(4, 5, highbd_12_subpel_avg_variance16x32_sse2, 12),
- make_tuple(4, 4, highbd_12_subpel_avg_variance16x16_sse2, 12),
- make_tuple(4, 3, highbd_12_subpel_avg_variance16x8_sse2, 12),
- make_tuple(3, 4, highbd_12_subpel_avg_variance8x16_sse2, 12),
- make_tuple(3, 3, highbd_12_subpel_avg_variance8x8_sse2, 12),
- make_tuple(3, 2, highbd_12_subpel_avg_variance8x4_sse2, 12),
- make_tuple(6, 6, highbd_10_subpel_avg_variance64x64_sse2, 10),
- make_tuple(6, 5, highbd_10_subpel_avg_variance64x32_sse2, 10),
- make_tuple(5, 6, highbd_10_subpel_avg_variance32x64_sse2, 10),
- make_tuple(5, 5, highbd_10_subpel_avg_variance32x32_sse2, 10),
- make_tuple(5, 4, highbd_10_subpel_avg_variance32x16_sse2, 10),
- make_tuple(4, 5, highbd_10_subpel_avg_variance16x32_sse2, 10),
- make_tuple(4, 4, highbd_10_subpel_avg_variance16x16_sse2, 10),
- make_tuple(4, 3, highbd_10_subpel_avg_variance16x8_sse2, 10),
- make_tuple(3, 4, highbd_10_subpel_avg_variance8x16_sse2, 10),
- make_tuple(3, 3, highbd_10_subpel_avg_variance8x8_sse2, 10),
- make_tuple(3, 2, highbd_10_subpel_avg_variance8x4_sse2, 10),
- make_tuple(6, 6, highbd_8_subpel_avg_variance64x64_sse2, 8),
- make_tuple(6, 5, highbd_8_subpel_avg_variance64x32_sse2, 8),
- make_tuple(5, 6, highbd_8_subpel_avg_variance32x64_sse2, 8),
- make_tuple(5, 5, highbd_8_subpel_avg_variance32x32_sse2, 8),
- make_tuple(5, 4, highbd_8_subpel_avg_variance32x16_sse2, 8),
- make_tuple(4, 5, highbd_8_subpel_avg_variance16x32_sse2, 8),
- make_tuple(4, 4, highbd_8_subpel_avg_variance16x16_sse2, 8),
- make_tuple(4, 3, highbd_8_subpel_avg_variance16x8_sse2, 8),
- make_tuple(3, 4, highbd_8_subpel_avg_variance8x16_sse2, 8),
- make_tuple(3, 3, highbd_8_subpel_avg_variance8x8_sse2, 8),
- make_tuple(3, 2, highbd_8_subpel_avg_variance8x4_sse2, 8)));
+ 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_USE_X86INC
#endif // CONFIG_VP9_HIGHBITDEPTH
#endif // HAVE_SSE2
#if HAVE_SSSE3
#if CONFIG_USE_X86INC
-const SubpixVarMxNFunc subpel_variance64x64_ssse3 =
- vpx_sub_pixel_variance64x64_ssse3;
-const SubpixVarMxNFunc subpel_variance64x32_ssse3 =
- vpx_sub_pixel_variance64x32_ssse3;
-const SubpixVarMxNFunc subpel_variance32x64_ssse3 =
- vpx_sub_pixel_variance32x64_ssse3;
-const SubpixVarMxNFunc subpel_variance32x32_ssse3 =
- vpx_sub_pixel_variance32x32_ssse3;
-const SubpixVarMxNFunc subpel_variance32x16_ssse3 =
- vpx_sub_pixel_variance32x16_ssse3;
-const SubpixVarMxNFunc subpel_variance16x32_ssse3 =
- vpx_sub_pixel_variance16x32_ssse3;
-const SubpixVarMxNFunc subpel_variance16x16_ssse3 =
- vpx_sub_pixel_variance16x16_ssse3;
-const SubpixVarMxNFunc subpel_variance16x8_ssse3 =
- vpx_sub_pixel_variance16x8_ssse3;
-const SubpixVarMxNFunc subpel_variance8x16_ssse3 =
- vpx_sub_pixel_variance8x16_ssse3;
-const SubpixVarMxNFunc subpel_variance8x8_ssse3 =
- vpx_sub_pixel_variance8x8_ssse3;
-const SubpixVarMxNFunc subpel_variance8x4_ssse3 =
- vpx_sub_pixel_variance8x4_ssse3;
-const SubpixVarMxNFunc subpel_variance4x8_ssse3 =
- vpx_sub_pixel_variance4x8_ssse3;
-const SubpixVarMxNFunc subpel_variance4x4_ssse3 =
- vpx_sub_pixel_variance4x4_ssse3;
INSTANTIATE_TEST_CASE_P(
SSSE3, VpxSubpelVarianceTest,
- ::testing::Values(make_tuple(6, 6, subpel_variance64x64_ssse3, 0),
- make_tuple(6, 5, subpel_variance64x32_ssse3, 0),
- make_tuple(5, 6, subpel_variance32x64_ssse3, 0),
- make_tuple(5, 5, subpel_variance32x32_ssse3, 0),
- make_tuple(5, 4, subpel_variance32x16_ssse3, 0),
- make_tuple(4, 5, subpel_variance16x32_ssse3, 0),
- make_tuple(4, 4, subpel_variance16x16_ssse3, 0),
- make_tuple(4, 3, subpel_variance16x8_ssse3, 0),
- make_tuple(3, 4, subpel_variance8x16_ssse3, 0),
- make_tuple(3, 3, subpel_variance8x8_ssse3, 0),
- make_tuple(3, 2, subpel_variance8x4_ssse3, 0),
- make_tuple(2, 3, subpel_variance4x8_ssse3, 0),
- make_tuple(2, 2, subpel_variance4x4_ssse3, 0)));
+ ::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)));
-const SubpixAvgVarMxNFunc subpel_avg_variance64x64_ssse3 =
- vpx_sub_pixel_avg_variance64x64_ssse3;
-const SubpixAvgVarMxNFunc subpel_avg_variance64x32_ssse3 =
- vpx_sub_pixel_avg_variance64x32_ssse3;
-const SubpixAvgVarMxNFunc subpel_avg_variance32x64_ssse3 =
- vpx_sub_pixel_avg_variance32x64_ssse3;
-const SubpixAvgVarMxNFunc subpel_avg_variance32x32_ssse3 =
- vpx_sub_pixel_avg_variance32x32_ssse3;
-const SubpixAvgVarMxNFunc subpel_avg_variance32x16_ssse3 =
- vpx_sub_pixel_avg_variance32x16_ssse3;
-const SubpixAvgVarMxNFunc subpel_avg_variance16x32_ssse3 =
- vpx_sub_pixel_avg_variance16x32_ssse3;
-const SubpixAvgVarMxNFunc subpel_avg_variance16x16_ssse3 =
- vpx_sub_pixel_avg_variance16x16_ssse3;
-const SubpixAvgVarMxNFunc subpel_avg_variance16x8_ssse3 =
- vpx_sub_pixel_avg_variance16x8_ssse3;
-const SubpixAvgVarMxNFunc subpel_avg_variance8x16_ssse3 =
- vpx_sub_pixel_avg_variance8x16_ssse3;
-const SubpixAvgVarMxNFunc subpel_avg_variance8x8_ssse3 =
- vpx_sub_pixel_avg_variance8x8_ssse3;
-const SubpixAvgVarMxNFunc subpel_avg_variance8x4_ssse3 =
- vpx_sub_pixel_avg_variance8x4_ssse3;
-const SubpixAvgVarMxNFunc subpel_avg_variance4x8_ssse3 =
- vpx_sub_pixel_avg_variance4x8_ssse3;
-const SubpixAvgVarMxNFunc subpel_avg_variance4x4_ssse3 =
- vpx_sub_pixel_avg_variance4x4_ssse3;
INSTANTIATE_TEST_CASE_P(
SSSE3, VpxSubpelAvgVarianceTest,
- ::testing::Values(make_tuple(6, 6, subpel_avg_variance64x64_ssse3, 0),
- make_tuple(6, 5, subpel_avg_variance64x32_ssse3, 0),
- make_tuple(5, 6, subpel_avg_variance32x64_ssse3, 0),
- make_tuple(5, 5, subpel_avg_variance32x32_ssse3, 0),
- make_tuple(5, 4, subpel_avg_variance32x16_ssse3, 0),
- make_tuple(4, 5, subpel_avg_variance16x32_ssse3, 0),
- make_tuple(4, 4, subpel_avg_variance16x16_ssse3, 0),
- make_tuple(4, 3, subpel_avg_variance16x8_ssse3, 0),
- make_tuple(3, 4, subpel_avg_variance8x16_ssse3, 0),
- make_tuple(3, 3, subpel_avg_variance8x8_ssse3, 0),
- make_tuple(3, 2, subpel_avg_variance8x4_ssse3, 0),
- make_tuple(2, 3, subpel_avg_variance4x8_ssse3, 0),
- make_tuple(2, 2, subpel_avg_variance4x4_ssse3, 0)));
+ ::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)));
#endif // CONFIG_USE_X86INC
#endif // HAVE_SSSE3
#if HAVE_AVX2
-const VarianceMxNFunc mse16x16_avx2 = vpx_mse16x16_avx2;
INSTANTIATE_TEST_CASE_P(AVX2, VpxMseTest,
- ::testing::Values(make_tuple(4, 4, mse16x16_avx2)));
+ ::testing::Values(make_tuple(4, 4,
+ &vpx_mse16x16_avx2)));
-const VarianceMxNFunc variance64x64_avx2 = vpx_variance64x64_avx2;
-const VarianceMxNFunc variance64x32_avx2 = vpx_variance64x32_avx2;
-const VarianceMxNFunc variance32x32_avx2 = vpx_variance32x32_avx2;
-const VarianceMxNFunc variance32x16_avx2 = vpx_variance32x16_avx2;
-const VarianceMxNFunc variance16x16_avx2 = vpx_variance16x16_avx2;
INSTANTIATE_TEST_CASE_P(
AVX2, VpxVarianceTest,
- ::testing::Values(make_tuple(6, 6, variance64x64_avx2, 0),
- make_tuple(6, 5, variance64x32_avx2, 0),
- make_tuple(5, 5, variance32x32_avx2, 0),
- make_tuple(5, 4, variance32x16_avx2, 0),
- make_tuple(4, 4, variance16x16_avx2, 0)));
+ ::testing::Values(make_tuple(6, 6, &vpx_variance64x64_avx2, 0),
+ make_tuple(6, 5, &vpx_variance64x32_avx2, 0),
+ make_tuple(5, 5, &vpx_variance32x32_avx2, 0),
+ make_tuple(5, 4, &vpx_variance32x16_avx2, 0),
+ make_tuple(4, 4, &vpx_variance16x16_avx2, 0)));
-const SubpixVarMxNFunc subpel_variance64x64_avx2 =
- vpx_sub_pixel_variance64x64_avx2;
-const SubpixVarMxNFunc subpel_variance32x32_avx2 =
- vpx_sub_pixel_variance32x32_avx2;
INSTANTIATE_TEST_CASE_P(
AVX2, VpxSubpelVarianceTest,
- ::testing::Values(make_tuple(6, 6, subpel_variance64x64_avx2, 0),
- make_tuple(5, 5, subpel_variance32x32_avx2, 0)));
+ ::testing::Values(make_tuple(6, 6, &vpx_sub_pixel_variance64x64_avx2, 0),
+ make_tuple(5, 5, &vpx_sub_pixel_variance32x32_avx2, 0)));
-const SubpixAvgVarMxNFunc subpel_avg_variance64x64_avx2 =
- vpx_sub_pixel_avg_variance64x64_avx2;
-const SubpixAvgVarMxNFunc subpel_avg_variance32x32_avx2 =
- vpx_sub_pixel_avg_variance32x32_avx2;
INSTANTIATE_TEST_CASE_P(
AVX2, VpxSubpelAvgVarianceTest,
- ::testing::Values(make_tuple(6, 6, subpel_avg_variance64x64_avx2, 0),
- make_tuple(5, 5, subpel_avg_variance32x32_avx2, 0)));
+ ::testing::Values(
+ make_tuple(6, 6, &vpx_sub_pixel_avg_variance64x64_avx2, 0),
+ make_tuple(5, 5, &vpx_sub_pixel_avg_variance32x32_avx2, 0)));
#endif // HAVE_AVX2
#if HAVE_MEDIA
-const VarianceMxNFunc mse16x16_media = vpx_mse16x16_media;
INSTANTIATE_TEST_CASE_P(MEDIA, VpxMseTest,
- ::testing::Values(make_tuple(4, 4, mse16x16_media)));
+ ::testing::Values(make_tuple(4, 4,
+ &vpx_mse16x16_media)));
-const VarianceMxNFunc variance16x16_media = vpx_variance16x16_media;
-const VarianceMxNFunc variance8x8_media = vpx_variance8x8_media;
INSTANTIATE_TEST_CASE_P(
MEDIA, VpxVarianceTest,
- ::testing::Values(make_tuple(4, 4, variance16x16_media, 0),
- make_tuple(3, 3, variance8x8_media, 0)));
+ ::testing::Values(make_tuple(4, 4, &vpx_variance16x16_media, 0),
+ make_tuple(3, 3, &vpx_variance8x8_media, 0)));
-const SubpixVarMxNFunc subpel_variance16x16_media =
- vpx_sub_pixel_variance16x16_media;
-const SubpixVarMxNFunc subpel_variance8x8_media =
- vpx_sub_pixel_variance8x8_media;
INSTANTIATE_TEST_CASE_P(
MEDIA, VpxSubpelVarianceTest,
- ::testing::Values(make_tuple(4, 4, subpel_variance16x16_media, 0),
- make_tuple(3, 3, subpel_variance8x8_media, 0)));
+ ::testing::Values(make_tuple(4, 4, &vpx_sub_pixel_variance16x16_media, 0),
+ make_tuple(3, 3, &vpx_sub_pixel_variance8x8_media, 0)));
#endif // HAVE_MEDIA
#if HAVE_NEON
-const Get4x4SseFunc get4x4sse_cs_neon = vpx_get4x4sse_cs_neon;
INSTANTIATE_TEST_CASE_P(NEON, VpxSseTest,
- ::testing::Values(make_tuple(2, 2, get4x4sse_cs_neon)));
+ ::testing::Values(make_tuple(2, 2,
+ &vpx_get4x4sse_cs_neon)));
-const VarianceMxNFunc mse16x16_neon = vpx_mse16x16_neon;
INSTANTIATE_TEST_CASE_P(NEON, VpxMseTest,
- ::testing::Values(make_tuple(4, 4, mse16x16_neon)));
+ ::testing::Values(make_tuple(4, 4,
+ &vpx_mse16x16_neon)));
-const VarianceMxNFunc variance64x64_neon = vpx_variance64x64_neon;
-const VarianceMxNFunc variance64x32_neon = vpx_variance64x32_neon;
-const VarianceMxNFunc variance32x64_neon = vpx_variance32x64_neon;
-const VarianceMxNFunc variance32x32_neon = vpx_variance32x32_neon;
-const VarianceMxNFunc variance16x16_neon = vpx_variance16x16_neon;
-const VarianceMxNFunc variance16x8_neon = vpx_variance16x8_neon;
-const VarianceMxNFunc variance8x16_neon = vpx_variance8x16_neon;
-const VarianceMxNFunc variance8x8_neon = vpx_variance8x8_neon;
INSTANTIATE_TEST_CASE_P(
NEON, VpxVarianceTest,
- ::testing::Values(make_tuple(6, 6, variance64x64_neon, 0),
- make_tuple(6, 5, variance64x32_neon, 0),
- make_tuple(5, 6, variance32x64_neon, 0),
- make_tuple(5, 5, variance32x32_neon, 0),
- make_tuple(4, 4, variance16x16_neon, 0),
- make_tuple(4, 3, variance16x8_neon, 0),
- make_tuple(3, 4, variance8x16_neon, 0),
- make_tuple(3, 3, variance8x8_neon, 0)));
+ ::testing::Values(make_tuple(6, 6, &vpx_variance64x64_neon, 0),
+ make_tuple(6, 5, &vpx_variance64x32_neon, 0),
+ make_tuple(5, 6, &vpx_variance32x64_neon, 0),
+ make_tuple(5, 5, &vpx_variance32x32_neon, 0),
+ make_tuple(4, 4, &vpx_variance16x16_neon, 0),
+ make_tuple(4, 3, &vpx_variance16x8_neon, 0),
+ make_tuple(3, 4, &vpx_variance8x16_neon, 0),
+ make_tuple(3, 3, &vpx_variance8x8_neon, 0)));
-const SubpixVarMxNFunc subpel_variance64x64_neon =
- vpx_sub_pixel_variance64x64_neon;
-const SubpixVarMxNFunc subpel_variance32x32_neon =
- vpx_sub_pixel_variance32x32_neon;
-const SubpixVarMxNFunc subpel_variance16x16_neon =
- vpx_sub_pixel_variance16x16_neon;
-const SubpixVarMxNFunc subpel_variance8x8_neon = vpx_sub_pixel_variance8x8_neon;
INSTANTIATE_TEST_CASE_P(
NEON, VpxSubpelVarianceTest,
- ::testing::Values(make_tuple(6, 6, subpel_variance64x64_neon, 0),
- make_tuple(5, 5, subpel_variance32x32_neon, 0),
- make_tuple(4, 4, subpel_variance16x16_neon, 0),
- make_tuple(3, 3, subpel_variance8x8_neon, 0)));
+ ::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)));
#endif // HAVE_NEON
#if HAVE_MSA
INSTANTIATE_TEST_CASE_P(MSA, SumOfSquaresTest,
::testing::Values(vpx_get_mb_ss_msa));
-const Get4x4SseFunc get4x4sse_cs_msa = vpx_get4x4sse_cs_msa;
INSTANTIATE_TEST_CASE_P(MSA, VpxSseTest,
- ::testing::Values(make_tuple(2, 2, get4x4sse_cs_msa)));
+ ::testing::Values(make_tuple(2, 2,
+ &vpx_get4x4sse_cs_msa)));
-const VarianceMxNFunc mse16x16_msa = vpx_mse16x16_msa;
-const VarianceMxNFunc mse16x8_msa = vpx_mse16x8_msa;
-const VarianceMxNFunc mse8x16_msa = vpx_mse8x16_msa;
-const VarianceMxNFunc mse8x8_msa = vpx_mse8x8_msa;
INSTANTIATE_TEST_CASE_P(MSA, VpxMseTest,
- ::testing::Values(make_tuple(4, 4, mse16x16_msa),
- make_tuple(4, 3, mse16x8_msa),
- make_tuple(3, 4, mse8x16_msa),
- make_tuple(3, 3, mse8x8_msa)));
+ ::testing::Values(make_tuple(4, 4, &vpx_mse16x16_msa),
+ make_tuple(4, 3, &vpx_mse16x8_msa),
+ make_tuple(3, 4, &vpx_mse8x16_msa),
+ make_tuple(3, 3, &vpx_mse8x8_msa)));
-const VarianceMxNFunc variance64x64_msa = vpx_variance64x64_msa;
-const VarianceMxNFunc variance64x32_msa = vpx_variance64x32_msa;
-const VarianceMxNFunc variance32x64_msa = vpx_variance32x64_msa;
-const VarianceMxNFunc variance32x32_msa = vpx_variance32x32_msa;
-const VarianceMxNFunc variance32x16_msa = vpx_variance32x16_msa;
-const VarianceMxNFunc variance16x32_msa = vpx_variance16x32_msa;
-const VarianceMxNFunc variance16x16_msa = vpx_variance16x16_msa;
-const VarianceMxNFunc variance16x8_msa = vpx_variance16x8_msa;
-const VarianceMxNFunc variance8x16_msa = vpx_variance8x16_msa;
-const VarianceMxNFunc variance8x8_msa = vpx_variance8x8_msa;
-const VarianceMxNFunc variance8x4_msa = vpx_variance8x4_msa;
-const VarianceMxNFunc variance4x8_msa = vpx_variance4x8_msa;
-const VarianceMxNFunc variance4x4_msa = vpx_variance4x4_msa;
INSTANTIATE_TEST_CASE_P(
MSA, VpxVarianceTest,
- ::testing::Values(make_tuple(6, 6, variance64x64_msa, 0),
- make_tuple(6, 5, variance64x32_msa, 0),
- make_tuple(5, 6, variance32x64_msa, 0),
- make_tuple(5, 5, variance32x32_msa, 0),
- make_tuple(5, 4, variance32x16_msa, 0),
- make_tuple(4, 5, variance16x32_msa, 0),
- make_tuple(4, 4, variance16x16_msa, 0),
- make_tuple(4, 3, variance16x8_msa, 0),
- make_tuple(3, 4, variance8x16_msa, 0),
- make_tuple(3, 3, variance8x8_msa, 0),
- make_tuple(3, 2, variance8x4_msa, 0),
- make_tuple(2, 3, variance4x8_msa, 0),
- make_tuple(2, 2, variance4x4_msa, 0)));
+ ::testing::Values(make_tuple(6, 6, &vpx_variance64x64_msa, 0),
+ make_tuple(6, 5, &vpx_variance64x32_msa, 0),
+ make_tuple(5, 6, &vpx_variance32x64_msa, 0),
+ make_tuple(5, 5, &vpx_variance32x32_msa, 0),
+ make_tuple(5, 4, &vpx_variance32x16_msa, 0),
+ make_tuple(4, 5, &vpx_variance16x32_msa, 0),
+ make_tuple(4, 4, &vpx_variance16x16_msa, 0),
+ make_tuple(4, 3, &vpx_variance16x8_msa, 0),
+ make_tuple(3, 4, &vpx_variance8x16_msa, 0),
+ make_tuple(3, 3, &vpx_variance8x8_msa, 0),
+ make_tuple(3, 2, &vpx_variance8x4_msa, 0),
+ make_tuple(2, 3, &vpx_variance4x8_msa, 0),
+ make_tuple(2, 2, &vpx_variance4x4_msa, 0)));
-const SubpixVarMxNFunc subpel_variance4x4_msa = vpx_sub_pixel_variance4x4_msa;
-const SubpixVarMxNFunc subpel_variance4x8_msa = vpx_sub_pixel_variance4x8_msa;
-const SubpixVarMxNFunc subpel_variance8x4_msa = vpx_sub_pixel_variance8x4_msa;
-const SubpixVarMxNFunc subpel_variance8x8_msa = vpx_sub_pixel_variance8x8_msa;
-const SubpixVarMxNFunc subpel_variance8x16_msa = vpx_sub_pixel_variance8x16_msa;
-const SubpixVarMxNFunc subpel_variance16x8_msa = vpx_sub_pixel_variance16x8_msa;
-const SubpixVarMxNFunc subpel_variance16x16_msa =
- vpx_sub_pixel_variance16x16_msa;
-const SubpixVarMxNFunc subpel_variance16x32_msa =
- vpx_sub_pixel_variance16x32_msa;
-const SubpixVarMxNFunc subpel_variance32x16_msa =
- vpx_sub_pixel_variance32x16_msa;
-const SubpixVarMxNFunc subpel_variance32x32_msa =
- vpx_sub_pixel_variance32x32_msa;
-const SubpixVarMxNFunc subpel_variance32x64_msa =
- vpx_sub_pixel_variance32x64_msa;
-const SubpixVarMxNFunc subpel_variance64x32_msa =
- vpx_sub_pixel_variance64x32_msa;
-const SubpixVarMxNFunc subpel_variance64x64_msa =
- vpx_sub_pixel_variance64x64_msa;
INSTANTIATE_TEST_CASE_P(
MSA, VpxSubpelVarianceTest,
- ::testing::Values(make_tuple(2, 2, subpel_variance4x4_msa, 0),
- make_tuple(2, 3, subpel_variance4x8_msa, 0),
- make_tuple(3, 2, subpel_variance8x4_msa, 0),
- make_tuple(3, 3, subpel_variance8x8_msa, 0),
- make_tuple(3, 4, subpel_variance8x16_msa, 0),
- make_tuple(4, 3, subpel_variance16x8_msa, 0),
- make_tuple(4, 4, subpel_variance16x16_msa, 0),
- make_tuple(4, 5, subpel_variance16x32_msa, 0),
- make_tuple(5, 4, subpel_variance32x16_msa, 0),
- make_tuple(5, 5, subpel_variance32x32_msa, 0),
- make_tuple(5, 6, subpel_variance32x64_msa, 0),
- make_tuple(6, 5, subpel_variance64x32_msa, 0),
- make_tuple(6, 6, subpel_variance64x64_msa, 0)));
+ ::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)));
-const SubpixAvgVarMxNFunc subpel_avg_variance64x64_msa =
- vpx_sub_pixel_avg_variance64x64_msa;
-const SubpixAvgVarMxNFunc subpel_avg_variance64x32_msa =
- vpx_sub_pixel_avg_variance64x32_msa;
-const SubpixAvgVarMxNFunc subpel_avg_variance32x64_msa =
- vpx_sub_pixel_avg_variance32x64_msa;
-const SubpixAvgVarMxNFunc subpel_avg_variance32x32_msa =
- vpx_sub_pixel_avg_variance32x32_msa;
-const SubpixAvgVarMxNFunc subpel_avg_variance32x16_msa =
- vpx_sub_pixel_avg_variance32x16_msa;
-const SubpixAvgVarMxNFunc subpel_avg_variance16x32_msa =
- vpx_sub_pixel_avg_variance16x32_msa;
-const SubpixAvgVarMxNFunc subpel_avg_variance16x16_msa =
- vpx_sub_pixel_avg_variance16x16_msa;
-const SubpixAvgVarMxNFunc subpel_avg_variance16x8_msa =
- vpx_sub_pixel_avg_variance16x8_msa;
-const SubpixAvgVarMxNFunc subpel_avg_variance8x16_msa =
- vpx_sub_pixel_avg_variance8x16_msa;
-const SubpixAvgVarMxNFunc subpel_avg_variance8x8_msa =
- vpx_sub_pixel_avg_variance8x8_msa;
-const SubpixAvgVarMxNFunc subpel_avg_variance8x4_msa =
- vpx_sub_pixel_avg_variance8x4_msa;
-const SubpixAvgVarMxNFunc subpel_avg_variance4x8_msa =
- vpx_sub_pixel_avg_variance4x8_msa;
-const SubpixAvgVarMxNFunc subpel_avg_variance4x4_msa =
- vpx_sub_pixel_avg_variance4x4_msa;
INSTANTIATE_TEST_CASE_P(
MSA, VpxSubpelAvgVarianceTest,
- ::testing::Values(make_tuple(6, 6, subpel_avg_variance64x64_msa, 0),
- make_tuple(6, 5, subpel_avg_variance64x32_msa, 0),
- make_tuple(5, 6, subpel_avg_variance32x64_msa, 0),
- make_tuple(5, 5, subpel_avg_variance32x32_msa, 0),
- make_tuple(5, 4, subpel_avg_variance32x16_msa, 0),
- make_tuple(4, 5, subpel_avg_variance16x32_msa, 0),
- make_tuple(4, 4, subpel_avg_variance16x16_msa, 0),
- make_tuple(4, 3, subpel_avg_variance16x8_msa, 0),
- make_tuple(3, 4, subpel_avg_variance8x16_msa, 0),
- make_tuple(3, 3, subpel_avg_variance8x8_msa, 0),
- make_tuple(3, 2, subpel_avg_variance8x4_msa, 0),
- make_tuple(2, 3, subpel_avg_variance4x8_msa, 0),
- make_tuple(2, 2, subpel_avg_variance4x4_msa, 0)));
+ ::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)));
#endif // HAVE_MSA
} // namespace
diff --git a/test/vp9_spatial_svc_encoder.sh b/test/vp9_spatial_svc_encoder.sh
index 6dd5f17..6503107 100755
--- a/test/vp9_spatial_svc_encoder.sh
+++ b/test/vp9_spatial_svc_encoder.sh
@@ -54,7 +54,7 @@
if [ "$(vp9_encode_available)" = "yes" ]; then
local readonly test_name="vp9_spatial_svc"
for layers in $(seq 1 ${vp9_ssvc_test_layers}); do
- vp9_spatial_svc_encoder "${test_name}" -l ${layers}
+ vp9_spatial_svc_encoder "${test_name}" -sl ${layers}
done
fi
}
diff --git a/vp10/common/reconintra.c b/vp10/common/reconintra.c
index 28665c6..14af7eb 100644
--- a/vp10/common/reconintra.c
+++ b/vp10/common/reconintra.c
@@ -305,6 +305,9 @@
int x0, y0;
const struct macroblockd_plane *const pd = &xd->plane[plane];
#endif
+ const int need_left = extend_modes[mode] & NEED_LEFT;
+ const int need_above = extend_modes[mode] & NEED_ABOVE;
+ const int need_aboveright = extend_modes[mode] & NEED_ABOVERIGHT;
int base = 128 << (bd - 8);
// 127 127 127 .. 127 127 127 127 127 127
// 129 A B .. Y Z
@@ -316,6 +319,9 @@
(void) x;
(void) y;
(void) plane;
+ (void) need_left;
+ (void) need_above;
+ (void) need_aboveright;
// NEED_LEFT
if (extend_modes[mode] & NEED_LEFT) {
@@ -372,79 +378,110 @@
x0 = (-xd->mb_to_left_edge >> (3 + pd->subsampling_x)) + x;
y0 = (-xd->mb_to_top_edge >> (3 + pd->subsampling_y)) + y;
- // left
- if (left_available) {
- if (xd->mb_to_bottom_edge < 0) {
- /* slower path if the block needs border extension */
- if (y0 + bs <= frame_height) {
+ // NEED_LEFT
+ if (need_left) {
+ if (left_available) {
+ if (xd->mb_to_bottom_edge < 0) {
+ /* slower path if the block needs border extension */
+ if (y0 + bs <= frame_height) {
+ for (i = 0; i < bs; ++i)
+ left_col[i] = ref[i * ref_stride - 1];
+ } else {
+ const int extend_bottom = frame_height - y0;
+ for (i = 0; i < extend_bottom; ++i)
+ left_col[i] = ref[i * ref_stride - 1];
+ for (; i < bs; ++i)
+ left_col[i] = ref[(extend_bottom - 1) * ref_stride - 1];
+ }
+ } else {
+ /* faster path if the block does not need extension */
for (i = 0; i < bs; ++i)
left_col[i] = ref[i * ref_stride - 1];
- } else {
- const int extend_bottom = frame_height - y0;
- for (i = 0; i < extend_bottom; ++i)
- left_col[i] = ref[i * ref_stride - 1];
- for (; i < bs; ++i)
- left_col[i] = ref[(extend_bottom - 1) * ref_stride - 1];
}
} else {
- /* faster path if the block does not need extension */
- for (i = 0; i < bs; ++i)
- left_col[i] = ref[i * ref_stride - 1];
+ // TODO(Peter): this value should probably change for high bitdepth
+ vpx_memset16(left_col, base + 1, bs);
}
- } else {
- // TODO(Peter): this value should probably change for high bitdepth
- vpx_memset16(left_col, base + 1, bs);
}
- // TODO(hkuang) do not extend 2*bs pixels for all modes.
- // above
- if (up_available) {
- const uint16_t *above_ref = ref - ref_stride;
- if (xd->mb_to_right_edge < 0) {
- /* slower path if the block needs border extension */
- if (x0 + 2 * bs <= frame_width) {
- if (right_available && bs == 4) {
- memcpy(above_row, above_ref, 2 * bs * sizeof(above_row[0]));
+ // NEED_ABOVE
+ if (need_above) {
+ if (up_available) {
+ const uint16_t *above_ref = ref - ref_stride;
+ if (xd->mb_to_right_edge < 0) {
+ /* slower path if the block needs border extension */
+ if (x0 + bs <= frame_width) {
+ memcpy(above_row, above_ref, bs * sizeof(above_row[0]));
+ } else if (x0 <= frame_width) {
+ const int r = frame_width - x0;
+ memcpy(above_row, above_ref, r * sizeof(above_row[0]));
+ vpx_memset16(above_row + r, above_row[r - 1], x0 + bs - frame_width);
+ }
+ } else {
+ /* faster path if the block does not need extension */
+ if (bs == 4 && right_available && left_available) {
+ const_above_row = above_ref;
} else {
memcpy(above_row, above_ref, bs * sizeof(above_row[0]));
- vpx_memset16(above_row + bs, above_row[bs - 1], bs);
}
- } else if (x0 + bs <= frame_width) {
- const int r = frame_width - x0;
- if (right_available && bs == 4) {
+ }
+ above_row[-1] = left_available ? above_ref[-1] : (base + 1);
+ } else {
+ vpx_memset16(above_row, base - 1, bs);
+ above_row[-1] = base - 1;
+ }
+ }
+
+ // NEED_ABOVERIGHT
+ if (need_aboveright) {
+ if (up_available) {
+ const uint16_t *above_ref = ref - ref_stride;
+ if (xd->mb_to_right_edge < 0) {
+ /* slower path if the block needs border extension */
+ if (x0 + 2 * bs <= frame_width) {
+ if (right_available && bs == 4) {
+ memcpy(above_row, above_ref, 2 * bs * sizeof(above_row[0]));
+ } else {
+ memcpy(above_row, above_ref, bs * sizeof(above_row[0]));
+ vpx_memset16(above_row + bs, above_row[bs - 1], bs);
+ }
+ } else if (x0 + bs <= frame_width) {
+ const int r = frame_width - x0;
+ if (right_available && bs == 4) {
+ memcpy(above_row, above_ref, r * sizeof(above_row[0]));
+ vpx_memset16(above_row + r, above_row[r - 1],
+ x0 + 2 * bs - frame_width);
+ } else {
+ memcpy(above_row, above_ref, bs * sizeof(above_row[0]));
+ vpx_memset16(above_row + bs, above_row[bs - 1], bs);
+ }
+ } else if (x0 <= frame_width) {
+ const int r = frame_width - x0;
memcpy(above_row, above_ref, r * sizeof(above_row[0]));
vpx_memset16(above_row + r, above_row[r - 1],
x0 + 2 * bs - frame_width);
+ }
+ // TODO(Peter) this value should probably change for high bitdepth
+ above_row[-1] = left_available ? above_ref[-1] : (base + 1);
+ } else {
+ /* faster path if the block does not need extension */
+ if (bs == 4 && right_available && left_available) {
+ const_above_row = above_ref;
} else {
memcpy(above_row, above_ref, bs * sizeof(above_row[0]));
- vpx_memset16(above_row + bs, above_row[bs - 1], bs);
+ if (bs == 4 && right_available)
+ memcpy(above_row + bs, above_ref + bs, bs * sizeof(above_row[0]));
+ else
+ vpx_memset16(above_row + bs, above_row[bs - 1], bs);
+ // TODO(Peter): this value should probably change for high bitdepth
+ above_row[-1] = left_available ? above_ref[-1] : (base + 1);
}
- } else if (x0 <= frame_width) {
- const int r = frame_width - x0;
- memcpy(above_row, above_ref, r * sizeof(above_row[0]));
- vpx_memset16(above_row + r, above_row[r - 1],
- x0 + 2 * bs - frame_width);
}
- // TODO(Peter) this value should probably change for high bitdepth
- above_row[-1] = left_available ? above_ref[-1] : (base+1);
} else {
- /* faster path if the block does not need extension */
- if (bs == 4 && right_available && left_available) {
- const_above_row = above_ref;
- } else {
- memcpy(above_row, above_ref, bs * sizeof(above_row[0]));
- if (bs == 4 && right_available)
- memcpy(above_row + bs, above_ref + bs, bs * sizeof(above_row[0]));
- else
- vpx_memset16(above_row + bs, above_row[bs - 1], bs);
- // TODO(Peter): this value should probably change for high bitdepth
- above_row[-1] = left_available ? above_ref[-1] : (base+1);
- }
+ vpx_memset16(above_row, base - 1, bs * 2);
+ // TODO(Peter): this value should probably change for high bitdepth
+ above_row[-1] = base - 1;
}
- } else {
- vpx_memset16(above_row, base - 1, bs * 2);
- // TODO(Peter): this value should probably change for high bitdepth
- above_row[-1] = base - 1;
}
#endif
diff --git a/vp10/encoder/encoder.h b/vp10/encoder/encoder.h
index bac6b36..7028803 100644
--- a/vp10/encoder/encoder.h
+++ b/vp10/encoder/encoder.h
@@ -456,7 +456,7 @@
int mbmode_cost[INTRA_MODES];
unsigned int inter_mode_cost[INTER_MODE_CONTEXTS][INTER_MODES];
- int intra_uv_mode_cost[INTRA_MODES];
+ int intra_uv_mode_cost[INTRA_MODES][INTRA_MODES];
int y_mode_costs[INTRA_MODES][INTRA_MODES][INTRA_MODES];
int switchable_interp_costs[SWITCHABLE_FILTER_CONTEXTS][SWITCHABLE_FILTERS];
int partition_cost[PARTITION_CONTEXTS][PARTITION_TYPES];
diff --git a/vp10/encoder/rd.c b/vp10/encoder/rd.c
index 9e35097..4ed1ae2 100644
--- a/vp10/encoder/rd.c
+++ b/vp10/encoder/rd.c
@@ -76,8 +76,9 @@
vp10_intra_mode_tree);
vp10_cost_tokens(cpi->mbmode_cost, fc->y_mode_prob[1], vp10_intra_mode_tree);
- vp10_cost_tokens(cpi->intra_uv_mode_cost,
- fc->uv_mode_prob[TM_PRED], vp10_intra_mode_tree);
+ for (i = 0; i < INTRA_MODES; ++i)
+ vp10_cost_tokens(cpi->intra_uv_mode_cost[i],
+ fc->uv_mode_prob[i], vp10_intra_mode_tree);
for (i = 0; i < SWITCHABLE_FILTER_CONTEXTS; ++i)
vp10_cost_tokens(cpi->switchable_interp_costs[i],
diff --git a/vp10/encoder/rdopt.c b/vp10/encoder/rdopt.c
index cecc59c..d87d164 100644
--- a/vp10/encoder/rdopt.c
+++ b/vp10/encoder/rdopt.c
@@ -1369,7 +1369,8 @@
if (!super_block_uvrd(cpi, x, &this_rate_tokenonly,
&this_distortion, &s, &this_sse, bsize, best_rd))
continue;
- this_rate = this_rate_tokenonly + cpi->intra_uv_mode_cost[mode];
+ this_rate = this_rate_tokenonly +
+ cpi->intra_uv_mode_cost[xd->mi[0]->mbmi.mode][mode];
this_rd = RDCOST(x->rdmult, x->rddiv, this_rate, this_distortion);
if (this_rd < best_rd) {
@@ -1398,7 +1399,8 @@
memset(x->skip_txfm, SKIP_TXFM_NONE, sizeof(x->skip_txfm));
super_block_uvrd(cpi, x, rate_tokenonly, distortion,
skippable, &unused, bsize, INT64_MAX);
- *rate = *rate_tokenonly + cpi->intra_uv_mode_cost[DC_PRED];
+ *rate = *rate_tokenonly +
+ cpi->intra_uv_mode_cost[x->e_mbd.mi[0]->mbmi.mode][DC_PRED];
return RDCOST(x->rdmult, x->rddiv, *rate, *distortion);
}
@@ -3015,9 +3017,9 @@
? (source_variance - recon_variance)
: (recon_variance - source_variance);
- var_error = (200 * source_variance * recon_variance) /
- ((source_variance * source_variance) +
- (recon_variance * recon_variance));
+ var_error = ((int64_t)200 * source_variance * recon_variance) /
+ (((int64_t)source_variance * source_variance) +
+ ((int64_t)recon_variance * recon_variance));
var_error = 100 - var_error;
}
diff --git a/vp9/common/vp9_reconintra.c b/vp9/common/vp9_reconintra.c
index 3d84a28..13a95ae 100644
--- a/vp9/common/vp9_reconintra.c
+++ b/vp9/common/vp9_reconintra.c
@@ -133,6 +133,9 @@
int frame_width, frame_height;
int x0, y0;
const struct macroblockd_plane *const pd = &xd->plane[plane];
+ const int need_left = extend_modes[mode] & NEED_LEFT;
+ const int need_above = extend_modes[mode] & NEED_ABOVE;
+ const int need_aboveright = extend_modes[mode] & NEED_ABOVERIGHT;
int base = 128 << (bd - 8);
// 127 127 127 .. 127 127 127 127 127 127
// 129 A B .. Y Z
@@ -153,79 +156,110 @@
x0 = (-xd->mb_to_left_edge >> (3 + pd->subsampling_x)) + x;
y0 = (-xd->mb_to_top_edge >> (3 + pd->subsampling_y)) + y;
- // left
- if (left_available) {
- if (xd->mb_to_bottom_edge < 0) {
- /* slower path if the block needs border extension */
- if (y0 + bs <= frame_height) {
+ // NEED_LEFT
+ if (need_left) {
+ if (left_available) {
+ if (xd->mb_to_bottom_edge < 0) {
+ /* slower path if the block needs border extension */
+ if (y0 + bs <= frame_height) {
+ for (i = 0; i < bs; ++i)
+ left_col[i] = ref[i * ref_stride - 1];
+ } else {
+ const int extend_bottom = frame_height - y0;
+ for (i = 0; i < extend_bottom; ++i)
+ left_col[i] = ref[i * ref_stride - 1];
+ for (; i < bs; ++i)
+ left_col[i] = ref[(extend_bottom - 1) * ref_stride - 1];
+ }
+ } else {
+ /* faster path if the block does not need extension */
for (i = 0; i < bs; ++i)
left_col[i] = ref[i * ref_stride - 1];
- } else {
- const int extend_bottom = frame_height - y0;
- for (i = 0; i < extend_bottom; ++i)
- left_col[i] = ref[i * ref_stride - 1];
- for (; i < bs; ++i)
- left_col[i] = ref[(extend_bottom - 1) * ref_stride - 1];
}
} else {
- /* faster path if the block does not need extension */
- for (i = 0; i < bs; ++i)
- left_col[i] = ref[i * ref_stride - 1];
+ // TODO(Peter): this value should probably change for high bitdepth
+ vpx_memset16(left_col, base + 1, bs);
}
- } else {
- // TODO(Peter): this value should probably change for high bitdepth
- vpx_memset16(left_col, base + 1, bs);
}
- // TODO(hkuang) do not extend 2*bs pixels for all modes.
- // above
- if (up_available) {
- const uint16_t *above_ref = ref - ref_stride;
- if (xd->mb_to_right_edge < 0) {
- /* slower path if the block needs border extension */
- if (x0 + 2 * bs <= frame_width) {
- if (right_available && bs == 4) {
- memcpy(above_row, above_ref, 2 * bs * sizeof(above_row[0]));
+ // NEED_ABOVE
+ if (need_above) {
+ if (up_available) {
+ const uint16_t *above_ref = ref - ref_stride;
+ if (xd->mb_to_right_edge < 0) {
+ /* slower path if the block needs border extension */
+ if (x0 + bs <= frame_width) {
+ memcpy(above_row, above_ref, bs * sizeof(above_row[0]));
+ } else if (x0 <= frame_width) {
+ const int r = frame_width - x0;
+ memcpy(above_row, above_ref, r * sizeof(above_row[0]));
+ vpx_memset16(above_row + r, above_row[r - 1], x0 + bs - frame_width);
+ }
+ } else {
+ /* faster path if the block does not need extension */
+ if (bs == 4 && right_available && left_available) {
+ const_above_row = above_ref;
} else {
memcpy(above_row, above_ref, bs * sizeof(above_row[0]));
- vpx_memset16(above_row + bs, above_row[bs - 1], bs);
}
- } else if (x0 + bs <= frame_width) {
- const int r = frame_width - x0;
- if (right_available && bs == 4) {
+ }
+ above_row[-1] = left_available ? above_ref[-1] : (base + 1);
+ } else {
+ vpx_memset16(above_row, base - 1, bs);
+ above_row[-1] = base - 1;
+ }
+ }
+
+ // NEED_ABOVERIGHT
+ if (need_aboveright) {
+ if (up_available) {
+ const uint16_t *above_ref = ref - ref_stride;
+ if (xd->mb_to_right_edge < 0) {
+ /* slower path if the block needs border extension */
+ if (x0 + 2 * bs <= frame_width) {
+ if (right_available && bs == 4) {
+ memcpy(above_row, above_ref, 2 * bs * sizeof(above_row[0]));
+ } else {
+ memcpy(above_row, above_ref, bs * sizeof(above_row[0]));
+ vpx_memset16(above_row + bs, above_row[bs - 1], bs);
+ }
+ } else if (x0 + bs <= frame_width) {
+ const int r = frame_width - x0;
+ if (right_available && bs == 4) {
+ memcpy(above_row, above_ref, r * sizeof(above_row[0]));
+ vpx_memset16(above_row + r, above_row[r - 1],
+ x0 + 2 * bs - frame_width);
+ } else {
+ memcpy(above_row, above_ref, bs * sizeof(above_row[0]));
+ vpx_memset16(above_row + bs, above_row[bs - 1], bs);
+ }
+ } else if (x0 <= frame_width) {
+ const int r = frame_width - x0;
memcpy(above_row, above_ref, r * sizeof(above_row[0]));
vpx_memset16(above_row + r, above_row[r - 1],
x0 + 2 * bs - frame_width);
+ }
+ // TODO(Peter) this value should probably change for high bitdepth
+ above_row[-1] = left_available ? above_ref[-1] : (base + 1);
+ } else {
+ /* faster path if the block does not need extension */
+ if (bs == 4 && right_available && left_available) {
+ const_above_row = above_ref;
} else {
memcpy(above_row, above_ref, bs * sizeof(above_row[0]));
- vpx_memset16(above_row + bs, above_row[bs - 1], bs);
+ if (bs == 4 && right_available)
+ memcpy(above_row + bs, above_ref + bs, bs * sizeof(above_row[0]));
+ else
+ vpx_memset16(above_row + bs, above_row[bs - 1], bs);
+ // TODO(Peter): this value should probably change for high bitdepth
+ above_row[-1] = left_available ? above_ref[-1] : (base + 1);
}
- } else if (x0 <= frame_width) {
- const int r = frame_width - x0;
- memcpy(above_row, above_ref, r * sizeof(above_row[0]));
- vpx_memset16(above_row + r, above_row[r - 1],
- x0 + 2 * bs - frame_width);
}
- // TODO(Peter) this value should probably change for high bitdepth
- above_row[-1] = left_available ? above_ref[-1] : (base+1);
} else {
- /* faster path if the block does not need extension */
- if (bs == 4 && right_available && left_available) {
- const_above_row = above_ref;
- } else {
- memcpy(above_row, above_ref, bs * sizeof(above_row[0]));
- if (bs == 4 && right_available)
- memcpy(above_row + bs, above_ref + bs, bs * sizeof(above_row[0]));
- else
- vpx_memset16(above_row + bs, above_row[bs - 1], bs);
- // TODO(Peter): this value should probably change for high bitdepth
- above_row[-1] = left_available ? above_ref[-1] : (base+1);
- }
+ vpx_memset16(above_row, base - 1, bs * 2);
+ // TODO(Peter): this value should probably change for high bitdepth
+ above_row[-1] = base - 1;
}
- } else {
- vpx_memset16(above_row, base - 1, bs * 2);
- // TODO(Peter): this value should probably change for high bitdepth
- above_row[-1] = base - 1;
}
// predict
diff --git a/vp9/common/vp9_rtcd_defs.pl b/vp9/common/vp9_rtcd_defs.pl
index 5bf71ef..890b638 100644
--- a/vp9/common/vp9_rtcd_defs.pl
+++ b/vp9/common/vp9_rtcd_defs.pl
@@ -312,10 +312,7 @@
$vp9_full_search_sad_sse4_1=vp9_full_search_sadx8;
add_proto qw/int vp9_diamond_search_sad/, "const struct macroblock *x, const struct search_site_config *cfg, struct mv *ref_mv, struct mv *best_mv, int search_param, int sad_per_bit, int *num00, const struct vp9_variance_vtable *fn_ptr, const struct mv *center_mv";
-specialize qw/vp9_diamond_search_sad/;
-
-add_proto qw/int vp9_full_range_search/, "const struct macroblock *x, const struct search_site_config *cfg, struct mv *ref_mv, struct mv *best_mv, int search_param, int sad_per_bit, int *num00, const struct vp9_variance_vtable *fn_ptr, const struct mv *center_mv";
-specialize qw/vp9_full_range_search/;
+specialize qw/vp9_diamond_search_sad avx/;
add_proto qw/void vp9_temporal_filter_apply/, "uint8_t *frame1, unsigned int stride, uint8_t *frame2, unsigned int block_width, unsigned int block_height, int strength, int filter_weight, unsigned int *accumulator, uint16_t *count";
specialize qw/vp9_temporal_filter_apply sse2 msa/;
diff --git a/vp9/decoder/vp9_decodeframe.c b/vp9/decoder/vp9_decodeframe.c
index f191663..39e4dcf 100644
--- a/vp9/decoder/vp9_decodeframe.c
+++ b/vp9/decoder/vp9_decodeframe.c
@@ -1979,6 +1979,8 @@
if (!cm->error_resilient_mode) {
cm->refresh_frame_context = vpx_rb_read_bit(rb);
cm->frame_parallel_decoding_mode = vpx_rb_read_bit(rb);
+ if (!cm->frame_parallel_decoding_mode)
+ vp9_zero(cm->counts);
} else {
cm->refresh_frame_context = 0;
cm->frame_parallel_decoding_mode = 1;
@@ -2082,43 +2084,6 @@
return vpx_reader_has_error(&r);
}
-#ifdef NDEBUG
-#define debug_check_frame_counts(cm) (void)0
-#else // !NDEBUG
-// Counts should only be incremented when frame_parallel_decoding_mode and
-// error_resilient_mode are disabled.
-static void debug_check_frame_counts(const VP9_COMMON *const cm) {
- FRAME_COUNTS zero_counts;
- vp9_zero(zero_counts);
- assert(cm->frame_parallel_decoding_mode || cm->error_resilient_mode);
- assert(!memcmp(cm->counts.y_mode, zero_counts.y_mode,
- sizeof(cm->counts.y_mode)));
- assert(!memcmp(cm->counts.uv_mode, zero_counts.uv_mode,
- sizeof(cm->counts.uv_mode)));
- assert(!memcmp(cm->counts.partition, zero_counts.partition,
- sizeof(cm->counts.partition)));
- assert(!memcmp(cm->counts.coef, zero_counts.coef,
- sizeof(cm->counts.coef)));
- assert(!memcmp(cm->counts.eob_branch, zero_counts.eob_branch,
- sizeof(cm->counts.eob_branch)));
- assert(!memcmp(cm->counts.switchable_interp, zero_counts.switchable_interp,
- sizeof(cm->counts.switchable_interp)));
- assert(!memcmp(cm->counts.inter_mode, zero_counts.inter_mode,
- sizeof(cm->counts.inter_mode)));
- assert(!memcmp(cm->counts.intra_inter, zero_counts.intra_inter,
- sizeof(cm->counts.intra_inter)));
- assert(!memcmp(cm->counts.comp_inter, zero_counts.comp_inter,
- sizeof(cm->counts.comp_inter)));
- assert(!memcmp(cm->counts.single_ref, zero_counts.single_ref,
- sizeof(cm->counts.single_ref)));
- assert(!memcmp(cm->counts.comp_ref, zero_counts.comp_ref,
- sizeof(cm->counts.comp_ref)));
- assert(!memcmp(&cm->counts.tx, &zero_counts.tx, sizeof(cm->counts.tx)));
- assert(!memcmp(cm->counts.skip, zero_counts.skip, sizeof(cm->counts.skip)));
- assert(!memcmp(&cm->counts.mv, &zero_counts.mv, sizeof(cm->counts.mv)));
-}
-#endif // NDEBUG
-
static struct vpx_read_bit_buffer *init_read_bit_buffer(
VP9Decoder *pbi,
struct vpx_read_bit_buffer *rb,
@@ -2202,8 +2167,6 @@
vpx_internal_error(&cm->error, VPX_CODEC_CORRUPT_FRAME,
"Uninitialized entropy context.");
- vp9_zero(cm->counts);
-
xd->corrupted = 0;
new_fb->corrupted = read_compressed_header(pbi, data, first_partition_size);
if (new_fb->corrupted)
@@ -2259,8 +2222,6 @@
vp9_adapt_mode_probs(cm);
vp9_adapt_mv_probs(cm, cm->allow_high_precision_mv);
}
- } else {
- debug_check_frame_counts(cm);
}
} else {
vpx_internal_error(&cm->error, VPX_CODEC_CORRUPT_FRAME,
diff --git a/vp9/decoder/vp9_decoder.c b/vp9/decoder/vp9_decoder.c
index 4e88819..f5da07e 100644
--- a/vp9/decoder/vp9_decoder.c
+++ b/vp9/decoder/vp9_decoder.c
@@ -243,7 +243,7 @@
decrease_ref_count(old_idx, frame_bufs, pool);
// Release the reference frame in reference map.
- if ((mask & 1) && old_idx >= 0) {
+ if (mask & 1) {
decrease_ref_count(old_idx, frame_bufs, pool);
}
cm->ref_frame_map[ref_index] = cm->next_ref_frame_map[ref_index];
@@ -350,7 +350,7 @@
decrease_ref_count(old_idx, frame_bufs, pool);
// Release the reference frame in reference map.
- if ((mask & 1) && old_idx >= 0) {
+ if (mask & 1) {
decrease_ref_count(old_idx, frame_bufs, pool);
}
++ref_index;
diff --git a/vp9/decoder/vp9_decoder.h b/vp9/decoder/vp9_decoder.h
index 4a5188f..afa4009 100644
--- a/vp9/decoder/vp9_decoder.h
+++ b/vp9/decoder/vp9_decoder.h
@@ -128,7 +128,7 @@
static INLINE void decrease_ref_count(int idx, RefCntBuffer *const frame_bufs,
BufferPool *const pool) {
- if (idx >= 0) {
+ if (idx >= 0 && frame_bufs[idx].ref_count > 0) {
--frame_bufs[idx].ref_count;
// A worker may only get a free framebuffer index when calling get_free_fb.
// But the private buffer is not set up until finish decoding header.
diff --git a/vp9/encoder/vp9_aq_cyclicrefresh.c b/vp9/encoder/vp9_aq_cyclicrefresh.c
index f221cb3..0def2cf 100644
--- a/vp9/encoder/vp9_aq_cyclicrefresh.c
+++ b/vp9/encoder/vp9_aq_cyclicrefresh.c
@@ -412,8 +412,11 @@
assert(cr->sb_index < sbs_in_frame);
i = cr->sb_index;
cr->target_num_seg_blocks = 0;
- if (cpi->oxcf.content != VP9E_CONTENT_SCREEN)
+ if (cpi->oxcf.content != VP9E_CONTENT_SCREEN) {
consec_zero_mv_thresh = 100;
+ if (cpi->noise_estimate.enabled && cpi->noise_estimate.level >= kMedium)
+ consec_zero_mv_thresh = 80;
+ }
qindex_thresh =
cpi->oxcf.content == VP9E_CONTENT_SCREEN
? vp9_get_qindex(&cm->seg, CR_SEGMENT_ID_BOOST2, cm->base_qindex)
diff --git a/vp9/encoder/vp9_bitstream.c b/vp9/encoder/vp9_bitstream.c
index 4615554..1a14ea9 100644
--- a/vp9/encoder/vp9_bitstream.c
+++ b/vp9/encoder/vp9_bitstream.c
@@ -123,72 +123,66 @@
static void pack_mb_tokens(vpx_writer *w,
TOKENEXTRA **tp, const TOKENEXTRA *const stop,
vpx_bit_depth_t bit_depth) {
- TOKENEXTRA *p = *tp;
-
- while (p < stop && p->token != EOSB_TOKEN) {
- const int t = p->token;
- const struct vp9_token *const a = &vp9_coef_encodings[t];
- int i = 0;
- int v = a->value;
- int n = a->len;
+ const TOKENEXTRA *p;
+ const vp9_extra_bit *const extra_bits =
#if CONFIG_VP9_HIGHBITDEPTH
- const vp9_extra_bit *b;
- if (bit_depth == VPX_BITS_12)
- b = &vp9_extra_bits_high12[t];
- else if (bit_depth == VPX_BITS_10)
- b = &vp9_extra_bits_high10[t];
- else
- b = &vp9_extra_bits[t];
+ (bit_depth == VPX_BITS_12) ? vp9_extra_bits_high12 :
+ (bit_depth == VPX_BITS_10) ? vp9_extra_bits_high10 :
+ vp9_extra_bits;
#else
- const vp9_extra_bit *const b = &vp9_extra_bits[t];
+ vp9_extra_bits;
(void) bit_depth;
#endif // CONFIG_VP9_HIGHBITDEPTH
- /* skip one or two nodes */
- if (p->skip_eob_node) {
- n -= p->skip_eob_node;
- i = 2 * p->skip_eob_node;
+ for (p = *tp; p < stop && p->token != EOSB_TOKEN; ++p) {
+ if (p->token == EOB_TOKEN) {
+ vpx_write(w, 0, p->context_tree[0]);
+ continue;
}
-
- // TODO(jbb): expanding this can lead to big gains. It allows
- // much better branch prediction and would enable us to avoid numerous
- // lookups and compares.
-
- // If we have a token that's in the constrained set, the coefficient tree
- // is split into two treed writes. The first treed write takes care of the
- // unconstrained nodes. The second treed write takes care of the
- // constrained nodes.
- if (t >= TWO_TOKEN && t < EOB_TOKEN) {
- int len = UNCONSTRAINED_NODES - p->skip_eob_node;
- int bits = v >> (n - len);
- vp9_write_tree(w, vp9_coef_tree, p->context_tree, bits, len, i);
- vp9_write_tree(w, vp9_coef_con_tree,
- vp9_pareto8_full[p->context_tree[PIVOT_NODE] - 1],
- v, n - len, 0);
- } else {
- vp9_write_tree(w, vp9_coef_tree, p->context_tree, v, n, i);
- }
-
- if (b->base_val) {
- const int e = p->extra, l = b->len;
-
- if (l) {
- const unsigned char *pb = b->prob;
- int v = e >> 1;
- int n = l; /* number of bits in v, assumed nonzero */
-
- do {
- const int bb = (v >> --n) & 1;
- vpx_write(w, bb, *pb++);
- } while (n);
+ vpx_write(w, 1, p->context_tree[0]);
+ while (p->token == ZERO_TOKEN) {
+ vpx_write(w, 0, p->context_tree[1]);
+ ++p;
+ if (p == stop || p->token == EOSB_TOKEN) {
+ *tp = (TOKENEXTRA*)(uintptr_t)p + (p->token == EOSB_TOKEN);
+ return;
}
-
- vpx_write_bit(w, e & 1);
}
- ++p;
- }
- *tp = p + (p->token == EOSB_TOKEN);
+ {
+ const int t = p->token;
+ const vpx_prob *const context_tree = p->context_tree;
+ assert(t != ZERO_TOKEN);
+ assert(t != EOB_TOKEN);
+ assert(t != EOSB_TOKEN);
+ vpx_write(w, 1, context_tree[1]);
+ if (t == ONE_TOKEN) {
+ vpx_write(w, 0, context_tree[2]);
+ vpx_write_bit(w, p->extra & 1);
+ } else { // t >= TWO_TOKEN && t < EOB_TOKEN
+ const struct vp9_token *const a = &vp9_coef_encodings[t];
+ const int v = a->value;
+ const int n = a->len;
+ const int e = p->extra;
+ vpx_write(w, 1, context_tree[2]);
+ vp9_write_tree(w, vp9_coef_con_tree,
+ vp9_pareto8_full[context_tree[PIVOT_NODE] - 1], v,
+ n - UNCONSTRAINED_NODES, 0);
+ if (t >= CATEGORY1_TOKEN) {
+ const vp9_extra_bit *const b = &extra_bits[t];
+ const unsigned char *pb = b->prob;
+ int v = e >> 1;
+ int n = b->len; // number of bits in v, assumed nonzero
+ do {
+ const int bb = (v >> --n) & 1;
+ vpx_write(w, bb, *pb++);
+ } while (n);
+ }
+ vpx_write_bit(w, e & 1);
+ }
+ }
+ }
+ *tp = (TOKENEXTRA*)(uintptr_t)p + (p->token == EOSB_TOKEN);
}
static void write_segment_id(vpx_writer *w, const struct segmentation *seg,
diff --git a/vp9/encoder/vp9_block.h b/vp9/encoder/vp9_block.h
index fc34786..ca5d746 100644
--- a/vp9/encoder/vp9_block.h
+++ b/vp9/encoder/vp9_block.h
@@ -71,6 +71,8 @@
int rddiv;
int rdmult;
int mb_energy;
+ int * m_search_count_ptr;
+ int * ex_search_count_ptr;
// These are set to their default values at the beginning, and then adjusted
// further in the encoding process.
diff --git a/vp9/encoder/vp9_context_tree.h b/vp9/encoder/vp9_context_tree.h
index 8e365ce..86ba03d 100644
--- a/vp9/encoder/vp9_context_tree.h
+++ b/vp9/encoder/vp9_context_tree.h
@@ -60,6 +60,7 @@
#if CONFIG_VP9_TEMPORAL_DENOISING
unsigned int newmv_sse;
unsigned int zeromv_sse;
+ unsigned int zeromv_lastref_sse;
PREDICTION_MODE best_sse_inter_mode;
int_mv best_sse_mv;
MV_REFERENCE_FRAME best_reference_frame;
diff --git a/vp9/encoder/vp9_denoiser.c b/vp9/encoder/vp9_denoiser.c
index c592832..e87a12e 100644
--- a/vp9/encoder/vp9_denoiser.c
+++ b/vp9/encoder/vp9_denoiser.c
@@ -224,14 +224,19 @@
} else {
// Otherwise, use the zero reference frame.
frame = ctx->best_zeromv_reference_frame;
-
- mbmi->ref_frame[0] = ctx->best_zeromv_reference_frame;
+ ctx->newmv_sse = ctx->zeromv_sse;
+ // Bias to last reference.
+ if (frame != LAST_FRAME &&
+ ((ctx->zeromv_lastref_sse < (5 * ctx->zeromv_sse) >> 2) ||
+ denoiser->denoising_level >= kDenHigh)) {
+ frame = LAST_FRAME;
+ ctx->newmv_sse = ctx->zeromv_lastref_sse;
+ }
+ mbmi->ref_frame[0] = frame;
mbmi->mode = ZEROMV;
mbmi->mv[0].as_int = 0;
-
ctx->best_sse_inter_mode = ZEROMV;
ctx->best_sse_mv.as_int = 0;
- ctx->newmv_sse = ctx->zeromv_sse;
}
if (ctx->newmv_sse > sse_thresh(bs, increase_denoising)) {
@@ -323,7 +328,7 @@
struct buf_2d src = mb->plane[0].src;
int is_skin = 0;
- if (bs <= BLOCK_16X16 && denoiser->denoising_level >= kDenMedium) {
+ if (bs <= BLOCK_16X16 && denoiser->denoising_level >= kDenLow) {
// Take center pixel in block to determine is_skin.
const int y_width_shift = (4 << b_width_log2_lookup[bs]) >> 1;
const int y_height_shift = (4 << b_height_log2_lookup[bs]) >> 1;
@@ -349,7 +354,7 @@
denoiser->increase_denoising = 0;
}
- if (denoiser->denoising_level >= kDenMedium)
+ if (denoiser->denoising_level >= kDenLow)
decision = perform_motion_compensation(denoiser, mb, bs,
denoiser->increase_denoising,
mi_row, mi_col, ctx,
@@ -462,6 +467,8 @@
if (mbmi->mv[0].as_int == 0 && sse < ctx->zeromv_sse) {
ctx->zeromv_sse = sse;
ctx->best_zeromv_reference_frame = mbmi->ref_frame[0];
+ if (mbmi->ref_frame[0] == LAST_FRAME)
+ ctx->zeromv_lastref_sse = sse;
}
if (mbmi->mv[0].as_int != 0 && sse < ctx->newmv_sse) {
@@ -524,6 +531,7 @@
#endif
denoiser->increase_denoising = 0;
denoiser->frame_buffer_initialized = 1;
+ denoiser->denoising_level = kDenLow;
return 0;
}
diff --git a/vp9/encoder/vp9_denoiser.h b/vp9/encoder/vp9_denoiser.h
index 8bed9e8..bc676e9 100644
--- a/vp9/encoder/vp9_denoiser.h
+++ b/vp9/encoder/vp9_denoiser.h
@@ -27,6 +27,7 @@
} VP9_DENOISER_DECISION;
typedef enum vp9_denoiser_level {
+ kDenLowLow,
kDenLow,
kDenMedium,
kDenHigh
diff --git a/vp9/encoder/vp9_encodeframe.c b/vp9/encoder/vp9_encodeframe.c
index 9d66839..f9c28f6 100644
--- a/vp9/encoder/vp9_encodeframe.c
+++ b/vp9/encoder/vp9_encodeframe.c
@@ -492,14 +492,14 @@
// Increase base variance threshold if estimated noise level is high.
if (cpi->noise_estimate.enabled) {
if (cpi->noise_estimate.level == kHigh)
- threshold_base = threshold_base << 2;
+ threshold_base = 3 * threshold_base;
else
if (cpi->noise_estimate.level == kMedium)
threshold_base = threshold_base << 1;
}
- thresholds[1] = threshold_base;
if (cm->width <= 352 && cm->height <= 288) {
- thresholds[0] = threshold_base >> 2;
+ thresholds[0] = threshold_base >> 3;
+ thresholds[1] = threshold_base >> 1;
thresholds[2] = threshold_base << 3;
} else {
thresholds[0] = threshold_base;
@@ -526,7 +526,7 @@
cpi->vbp_bsize_min = BLOCK_8X8;
} else {
if (cm->width <= 352 && cm->height <= 288)
- cpi->vbp_threshold_sad = 100;
+ cpi->vbp_threshold_sad = 10;
else
cpi->vbp_threshold_sad = (cpi->y_dequant[q][1] << 1) > 1000 ?
(cpi->y_dequant[q][1] << 1) : 1000;
@@ -3839,6 +3839,10 @@
TOKENEXTRA *tok = cpi->tile_tok[tile_row][tile_col];
int mi_row;
+ // Set up pointers to per thread motion search counters.
+ td->mb.m_search_count_ptr = &td->rd_counts.m_search_count;
+ td->mb.ex_search_count_ptr = &td->rd_counts.ex_search_count;
+
for (mi_row = tile_info->mi_row_start; mi_row < tile_info->mi_row_end;
mi_row += MI_BLOCK_SIZE) {
if (cpi->sf.use_nonrd_pick_mode)
@@ -3895,6 +3899,9 @@
vp9_zero(rdc->coef_counts);
vp9_zero(rdc->comp_pred_diff);
vp9_zero(rdc->filter_diff);
+ rdc->m_search_count = 0; // Count of motion search hits.
+ rdc->ex_search_count = 0; // Exhaustive mesh search hits.
+
xd->lossless = cm->base_qindex == 0 &&
cm->y_dc_delta_q == 0 &&
diff --git a/vp9/encoder/vp9_encoder.c b/vp9/encoder/vp9_encoder.c
index d86a7a7..a57cf87 100644
--- a/vp9/encoder/vp9_encoder.c
+++ b/vp9/encoder/vp9_encoder.c
@@ -1570,7 +1570,30 @@
#endif
#define log2f(x) (log (x) / (float) M_LOG2_E)
+/***********************************************************************
+ * Read before modifying 'cal_nmvjointsadcost' or 'cal_nmvsadcosts' *
+ ***********************************************************************
+ * The following 2 functions ('cal_nmvjointsadcost' and *
+ * 'cal_nmvsadcosts') are used to calculate cost lookup tables *
+ * used by 'vp9_diamond_search_sad'. The C implementation of the *
+ * function is generic, but the AVX intrinsics optimised version *
+ * relies on the following properties of the computed tables: *
+ * For cal_nmvjointsadcost: *
+ * - mvjointsadcost[1] == mvjointsadcost[2] == mvjointsadcost[3] *
+ * For cal_nmvsadcosts: *
+ * - For all i: mvsadcost[0][i] == mvsadcost[1][i] *
+ * (Equal costs for both components) *
+ * - For all i: mvsadcost[0][i] == mvsadcost[0][-i] *
+ * (Cost function is even) *
+ * If these do not hold, then the AVX optimised version of the *
+ * 'vp9_diamond_search_sad' function cannot be used as it is, in which *
+ * case you can revert to using the C function instead. *
+ ***********************************************************************/
+
static void cal_nmvjointsadcost(int *mvjointsadcost) {
+ /*********************************************************************
+ * Warning: Read the comments above before modifying this function *
+ *********************************************************************/
mvjointsadcost[0] = 600;
mvjointsadcost[1] = 300;
mvjointsadcost[2] = 300;
@@ -1578,6 +1601,9 @@
}
static void cal_nmvsadcosts(int *mvsadcost[2]) {
+ /*********************************************************************
+ * Warning: Read the comments above before modifying this function *
+ *********************************************************************/
int i = 1;
mvsadcost[0][0] = 0;
@@ -1739,6 +1765,10 @@
cpi->first_time_stamp_ever = INT64_MAX;
+ /*********************************************************************
+ * Warning: Read the comments around 'cal_nmvjointsadcost' and *
+ * 'cal_nmvsadcosts' before modifying how these tables are computed. *
+ *********************************************************************/
cal_nmvjointsadcost(cpi->td.mb.nmvjointsadcost);
cpi->td.mb.nmvcost[0] = &cpi->nmvcosts[0][MV_MAX];
cpi->td.mb.nmvcost[1] = &cpi->nmvcosts[1][MV_MAX];
@@ -2965,7 +2995,7 @@
recon_err = vp9_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
if (cpi->twopass.total_left_stats.coded_error != 0.0)
- fprintf(f, "%10u %dx%d %d %d %10d %10d %10d %10d"
+ fprintf(f, "%10u %dx%d %10d %10d %d %d %10d %10d %10d %10d"
"%10"PRId64" %10"PRId64" %5d %5d %10"PRId64" "
"%10"PRId64" %10"PRId64" %10d "
"%7.2lf %7.2lf %7.2lf %7.2lf %7.2lf"
@@ -2974,6 +3004,8 @@
"%10lf %8u %10"PRId64" %10d %10d %10d\n",
cpi->common.current_video_frame,
cm->width, cm->height,
+ cpi->td.rd_counts.m_search_count,
+ cpi->td.rd_counts.ex_search_count,
cpi->rc.source_alt_ref_pending,
cpi->rc.source_alt_ref_active,
cpi->rc.this_frame_target,
diff --git a/vp9/encoder/vp9_encoder.h b/vp9/encoder/vp9_encoder.h
index 3f3f896..f6d8931 100644
--- a/vp9/encoder/vp9_encoder.h
+++ b/vp9/encoder/vp9_encoder.h
@@ -260,6 +260,8 @@
vp9_coeff_count coef_counts[TX_SIZES][PLANE_TYPES];
int64_t comp_pred_diff[REFERENCE_MODES];
int64_t filter_diff[SWITCHABLE_FILTER_CONTEXTS];
+ int m_search_count;
+ int ex_search_count;
} RD_COUNTS;
typedef struct ThreadData {
@@ -470,7 +472,7 @@
int mbmode_cost[INTRA_MODES];
unsigned int inter_mode_cost[INTER_MODE_CONTEXTS][INTER_MODES];
- int intra_uv_mode_cost[FRAME_TYPES][INTRA_MODES];
+ int intra_uv_mode_cost[FRAME_TYPES][INTRA_MODES][INTRA_MODES];
int y_mode_costs[INTRA_MODES][INTRA_MODES][INTRA_MODES];
int switchable_interp_costs[SWITCHABLE_FILTER_CONTEXTS][SWITCHABLE_FILTERS];
int partition_cost[PARTITION_CONTEXTS][PARTITION_TYPES];
diff --git a/vp9/encoder/vp9_ethread.c b/vp9/encoder/vp9_ethread.c
index ad25712..1d1926c 100644
--- a/vp9/encoder/vp9_ethread.c
+++ b/vp9/encoder/vp9_ethread.c
@@ -30,6 +30,10 @@
for (n = 0; n < ENTROPY_TOKENS; n++)
td->rd_counts.coef_counts[i][j][k][l][m][n] +=
td_t->rd_counts.coef_counts[i][j][k][l][m][n];
+
+ // Counts of all motion searches and exhuastive mesh searches.
+ td->rd_counts.m_search_count += td_t->rd_counts.m_search_count;
+ td->rd_counts.ex_search_count += td_t->rd_counts.ex_search_count;
}
static int enc_worker_hook(EncWorkerData *const thread_data, void *unused) {
diff --git a/vp9/encoder/vp9_mcomp.c b/vp9/encoder/vp9_mcomp.c
index 9744e43..327ac19 100644
--- a/vp9/encoder/vp9_mcomp.c
+++ b/vp9/encoder/vp9_mcomp.c
@@ -101,11 +101,8 @@
}
void vp9_init_dsmotion_compensation(search_site_config *cfg, int stride) {
- int len, ss_count = 1;
-
- cfg->ss_mv[0].col = 0;
- cfg->ss_mv[0].row = 0;
- cfg->ss_os[0] = 0;
+ int len;
+ int ss_count = 0;
for (len = MAX_FIRST_STEP; len > 0; len /= 2) {
// Generate offsets for 4 search sites per step.
@@ -117,16 +114,13 @@
}
}
- cfg->ss_count = ss_count;
cfg->searches_per_step = 4;
+ cfg->total_steps = ss_count / cfg->searches_per_step;
}
void vp9_init3smotion_compensation(search_site_config *cfg, int stride) {
- int len, ss_count = 1;
-
- cfg->ss_mv[0].col = 0;
- cfg->ss_mv[0].row = 0;
- cfg->ss_os[0] = 0;
+ int len;
+ int ss_count = 0;
for (len = MAX_FIRST_STEP; len > 0; len /= 2) {
// Generate offsets for 8 search sites per step.
@@ -141,8 +135,8 @@
}
}
- cfg->ss_count = ss_count;
cfg->searches_per_step = 8;
+ cfg->total_steps = ss_count / cfg->searches_per_step;
}
/*
@@ -1523,69 +1517,83 @@
#undef CHECK_BETTER
-int vp9_full_range_search_c(const MACROBLOCK *x,
- const search_site_config *cfg,
- MV *ref_mv, MV *best_mv,
- int search_param, int sad_per_bit, int *num00,
- const vp9_variance_fn_ptr_t *fn_ptr,
- const MV *center_mv) {
+// Exhuastive motion search around a given centre position with a given
+// step size.
+static int exhuastive_mesh_search(const MACROBLOCK *x,
+ MV *ref_mv, MV *best_mv,
+ int range, int step, int sad_per_bit,
+ const vp9_variance_fn_ptr_t *fn_ptr,
+ const MV *center_mv) {
const MACROBLOCKD *const xd = &x->e_mbd;
const struct buf_2d *const what = &x->plane[0].src;
const struct buf_2d *const in_what = &xd->plane[0].pre[0];
- const int range = 64;
- const MV fcenter_mv = {center_mv->row >> 3, center_mv->col >> 3};
+ MV fcenter_mv = {center_mv->row, center_mv->col};
unsigned int best_sad = INT_MAX;
int r, c, i;
int start_col, end_col, start_row, end_row;
+ int col_step = (step > 1) ? step : 4;
- // The cfg and search_param parameters are not used in this search variant
- (void)cfg;
- (void)search_param;
+ assert(step >= 1);
- clamp_mv(ref_mv, x->mv_col_min, x->mv_col_max, x->mv_row_min, x->mv_row_max);
- *best_mv = *ref_mv;
- *num00 = 11;
+ clamp_mv(&fcenter_mv, x->mv_col_min, x->mv_col_max,
+ x->mv_row_min, x->mv_row_max);
+ *best_mv = fcenter_mv;
best_sad = fn_ptr->sdf(what->buf, what->stride,
- get_buf_from_mv(in_what, ref_mv), in_what->stride) +
- mvsad_err_cost(x, ref_mv, &fcenter_mv, sad_per_bit);
- start_row = VPXMAX(-range, x->mv_row_min - ref_mv->row);
- start_col = VPXMAX(-range, x->mv_col_min - ref_mv->col);
- end_row = VPXMIN(range, x->mv_row_max - ref_mv->row);
- end_col = VPXMIN(range, x->mv_col_max - ref_mv->col);
+ get_buf_from_mv(in_what, &fcenter_mv), in_what->stride) +
+ mvsad_err_cost(x, &fcenter_mv, ref_mv, sad_per_bit);
+ start_row = VPXMAX(-range, x->mv_row_min - fcenter_mv.row);
+ start_col = VPXMAX(-range, x->mv_col_min - fcenter_mv.col);
+ end_row = VPXMIN(range, x->mv_row_max - fcenter_mv.row);
+ end_col = VPXMIN(range, x->mv_col_max - fcenter_mv.col);
- for (r = start_row; r <= end_row; ++r) {
- for (c = start_col; c <= end_col; c += 4) {
- if (c + 3 <= end_col) {
- unsigned int sads[4];
- const uint8_t *addrs[4];
- for (i = 0; i < 4; ++i) {
- const MV mv = {ref_mv->row + r, ref_mv->col + c + i};
- addrs[i] = get_buf_from_mv(in_what, &mv);
- }
-
- fn_ptr->sdx4df(what->buf, what->stride, addrs, in_what->stride, sads);
-
- for (i = 0; i < 4; ++i) {
- if (sads[i] < best_sad) {
- const MV mv = {ref_mv->row + r, ref_mv->col + c + i};
- const unsigned int sad = sads[i] +
- mvsad_err_cost(x, &mv, &fcenter_mv, sad_per_bit);
- if (sad < best_sad) {
- best_sad = sad;
- *best_mv = mv;
- }
+ for (r = start_row; r <= end_row; r += step) {
+ for (c = start_col; c <= end_col; c += col_step) {
+ // Step > 1 means we are not checking every location in this pass.
+ if (step > 1) {
+ const MV mv = {fcenter_mv.row + r, fcenter_mv.col + c};
+ unsigned int sad = fn_ptr->sdf(what->buf, what->stride,
+ get_buf_from_mv(in_what, &mv), in_what->stride);
+ if (sad < best_sad) {
+ sad += mvsad_err_cost(x, &mv, ref_mv, sad_per_bit);
+ if (sad < best_sad) {
+ best_sad = sad;
+ *best_mv = mv;
}
}
} else {
- for (i = 0; i < end_col - c; ++i) {
- const MV mv = {ref_mv->row + r, ref_mv->col + c + i};
- unsigned int sad = fn_ptr->sdf(what->buf, what->stride,
- get_buf_from_mv(in_what, &mv), in_what->stride);
- if (sad < best_sad) {
- sad += mvsad_err_cost(x, &mv, &fcenter_mv, sad_per_bit);
+ // 4 sads in a single call if we are checking every location
+ if (c + 3 <= end_col) {
+ unsigned int sads[4];
+ const uint8_t *addrs[4];
+ for (i = 0; i < 4; ++i) {
+ const MV mv = {fcenter_mv.row + r, fcenter_mv.col + c + i};
+ addrs[i] = get_buf_from_mv(in_what, &mv);
+ }
+ fn_ptr->sdx4df(what->buf, what->stride, addrs,
+ in_what->stride, sads);
+
+ for (i = 0; i < 4; ++i) {
+ if (sads[i] < best_sad) {
+ const MV mv = {fcenter_mv.row + r, fcenter_mv.col + c + i};
+ const unsigned int sad = sads[i] +
+ mvsad_err_cost(x, &mv, ref_mv, sad_per_bit);
+ if (sad < best_sad) {
+ best_sad = sad;
+ *best_mv = mv;
+ }
+ }
+ }
+ } else {
+ for (i = 0; i < end_col - c; ++i) {
+ const MV mv = {fcenter_mv.row + r, fcenter_mv.col + c + i};
+ unsigned int sad = fn_ptr->sdf(what->buf, what->stride,
+ get_buf_from_mv(in_what, &mv), in_what->stride);
if (sad < best_sad) {
- best_sad = sad;
- *best_mv = mv;
+ sad += mvsad_err_cost(x, &mv, ref_mv, sad_per_bit);
+ if (sad < best_sad) {
+ best_sad = sad;
+ *best_mv = mv;
+ }
}
}
}
@@ -1612,8 +1620,8 @@
const uint8_t *best_address;
unsigned int bestsad = INT_MAX;
- int best_site = 0;
- int last_site = 0;
+ int best_site = -1;
+ int last_site = -1;
int ref_row;
int ref_col;
@@ -1626,7 +1634,7 @@
// const search_site *ss = &cfg->ss[search_param * cfg->searches_per_step];
const MV *ss_mv = &cfg->ss_mv[search_param * cfg->searches_per_step];
const intptr_t *ss_os = &cfg->ss_os[search_param * cfg->searches_per_step];
- const int tot_steps = (cfg->ss_count / cfg->searches_per_step) - search_param;
+ const int tot_steps = cfg->total_steps - search_param;
const MV fcenter_mv = {center_mv->row >> 3, center_mv->col >> 3};
clamp_mv(ref_mv, x->mv_col_min, x->mv_col_max, x->mv_row_min, x->mv_row_max);
@@ -1644,7 +1652,7 @@
bestsad = fn_ptr->sdf(what, what_stride, in_what, in_what_stride)
+ mvsad_err_cost(x, best_mv, &fcenter_mv, sad_per_bit);
- i = 1;
+ i = 0;
for (step = 0; step < tot_steps; step++) {
int all_in = 1, t;
@@ -2017,6 +2025,70 @@
return bestsme;
}
+#define MIN_RANGE 7
+#define MAX_RANGE 256
+#define MIN_INTERVAL 1
+// Runs an limited range exhaustive mesh search using a pattern set
+// according to the encode speed profile.
+static int full_pixel_exhaustive(VP9_COMP *cpi, MACROBLOCK *x,
+ MV *centre_mv_full, int sadpb, int *cost_list,
+ const vp9_variance_fn_ptr_t *fn_ptr,
+ const MV *ref_mv, MV *dst_mv) {
+ const SPEED_FEATURES *const sf = &cpi->sf;
+ MV temp_mv = {centre_mv_full->row, centre_mv_full->col};
+ MV f_ref_mv = {ref_mv->row >> 3, ref_mv->col >> 3};
+ int bestsme;
+ int i;
+ int interval = sf->mesh_patterns[0].interval;
+ int range = sf->mesh_patterns[0].range;
+ int baseline_interval_divisor;
+
+ // Keep track of number of exhaustive calls (this frame in this thread).
+ ++(*x->ex_search_count_ptr);
+
+ // Trap illegal values for interval and range for this function.
+ if ((range < MIN_RANGE) || (range > MAX_RANGE) ||
+ (interval < MIN_INTERVAL) || (interval > range))
+ return INT_MAX;
+
+ baseline_interval_divisor = range / interval;
+
+ // Check size of proposed first range against magnitude of the centre
+ // value used as a starting point.
+ range = VPXMAX(range, (5 * VPXMAX(abs(temp_mv.row), abs(temp_mv.col))) / 4);
+ range = VPXMIN(range, MAX_RANGE);
+ interval = VPXMAX(interval, range / baseline_interval_divisor);
+
+ // initial search
+ bestsme = exhuastive_mesh_search(x, &f_ref_mv, &temp_mv, range,
+ interval, sadpb, fn_ptr, &temp_mv);
+
+ if ((interval > MIN_INTERVAL) && (range > MIN_RANGE)) {
+ // Progressive searches with range and step size decreasing each time
+ // till we reach a step size of 1. Then break out.
+ for (i = 1; i < MAX_MESH_STEP; ++i) {
+ // First pass with coarser step and longer range
+ bestsme = exhuastive_mesh_search(x, &f_ref_mv, &temp_mv,
+ sf->mesh_patterns[i].range,
+ sf->mesh_patterns[i].interval,
+ sadpb, fn_ptr, &temp_mv);
+
+ if (sf->mesh_patterns[i].interval == 1)
+ break;
+ }
+ }
+
+ if (bestsme < INT_MAX)
+ bestsme = vp9_get_mvpred_var(x, &temp_mv, ref_mv, fn_ptr, 1);
+ *dst_mv = temp_mv;
+
+ // Return cost list.
+ if (cost_list) {
+ calc_int_cost_list(x, ref_mv, sadpb, fn_ptr, dst_mv, cost_list);
+ }
+ return bestsme;
+}
+
int vp9_full_search_sad_c(const MACROBLOCK *x, const MV *ref_mv,
int sad_per_bit, int distance,
const vp9_variance_fn_ptr_t *fn_ptr,
@@ -2330,6 +2402,18 @@
return best_sad;
}
+#define MIN_EX_SEARCH_LIMIT 128
+static int is_exhaustive_allowed(VP9_COMP *cpi, MACROBLOCK *x) {
+ const SPEED_FEATURES *const sf = &cpi->sf;
+ const int max_ex = VPXMAX(MIN_EX_SEARCH_LIMIT,
+ (*x->m_search_count_ptr * sf->max_exaustive_pct) / 100);
+
+ return sf->allow_exhaustive_searches &&
+ (sf->exhaustive_searches_thresh < INT_MAX) &&
+ (*x->ex_search_count_ptr <= max_ex) &&
+ !cpi->rc.is_src_frame_alt_ref;
+}
+
int vp9_full_pixel_search(VP9_COMP *cpi, MACROBLOCK *x,
BLOCK_SIZE bsize, MV *mvp_full,
int step_param, int error_per_bit,
@@ -2348,6 +2432,9 @@
cost_list[4] = INT_MAX;
}
+ // Keep track of number of searches (this frame in this thread).
+ ++(*x->m_search_count_ptr);
+
switch (method) {
case FAST_DIAMOND:
var = fast_dia_search(x, mvp_full, step_param, error_per_bit, 0,
@@ -2373,6 +2460,27 @@
var = full_pixel_diamond(cpi, x, mvp_full, step_param, error_per_bit,
MAX_MVSEARCH_STEPS - 1 - step_param,
1, cost_list, fn_ptr, ref_mv, tmp_mv);
+
+ // Should we allow a follow on exhaustive search?
+ if (is_exhaustive_allowed(cpi, x)) {
+ int64_t exhuastive_thr = sf->exhaustive_searches_thresh;
+ exhuastive_thr >>= 8 - (b_width_log2_lookup[bsize] +
+ b_height_log2_lookup[bsize]);
+
+ // Threshold variance for an exhaustive full search.
+ if (var > exhuastive_thr) {
+ int var_ex;
+ MV tmp_mv_ex;
+ var_ex = full_pixel_exhaustive(cpi, x, tmp_mv,
+ error_per_bit, cost_list, fn_ptr,
+ ref_mv, &tmp_mv_ex);
+
+ if (var_ex < var) {
+ var = var_ex;
+ *tmp_mv = tmp_mv_ex;
+ }
+ }
+ }
break;
default:
assert(0 && "Invalid search method.");
diff --git a/vp9/encoder/vp9_mcomp.h b/vp9/encoder/vp9_mcomp.h
index e48259f..1c101f2 100644
--- a/vp9/encoder/vp9_mcomp.h
+++ b/vp9/encoder/vp9_mcomp.h
@@ -33,10 +33,10 @@
typedef struct search_site_config {
// motion search sites
- MV ss_mv[8 * MAX_MVSEARCH_STEPS + 1]; // Motion vector
- intptr_t ss_os[8 * MAX_MVSEARCH_STEPS + 1]; // Offset
- int ss_count;
+ MV ss_mv[8 * MAX_MVSEARCH_STEPS]; // Motion vector
+ intptr_t ss_os[8 * MAX_MVSEARCH_STEPS]; // Offset
int searches_per_step;
+ int total_steps;
} search_site_config;
void vp9_init_dsmotion_compensation(search_site_config *cfg, int stride);
diff --git a/vp9/encoder/vp9_noise_estimate.c b/vp9/encoder/vp9_noise_estimate.c
index 3df3dfc..b41ffd0 100644
--- a/vp9/encoder/vp9_noise_estimate.c
+++ b/vp9/encoder/vp9_noise_estimate.c
@@ -28,12 +28,15 @@
ne->level = kLow;
ne->value = 0;
ne->count = 0;
- ne->thresh = 20;
+ ne->thresh = 90;
+ ne->last_w = 0;
+ ne->last_h = 0;
if (width * height >= 1920 * 1080) {
- ne->thresh = 70;
+ ne->thresh = 200;
} else if (width * height >= 1280 * 720) {
- ne->thresh = 40;
+ ne->thresh = 130;
}
+ ne->num_frames_estimate = 20;
}
int enable_noise_estimation(VP9_COMP *const cpi) {
@@ -53,10 +56,11 @@
cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ &&
cpi->oxcf.speed >= 5 &&
cpi->resize_state == ORIG &&
+ cpi->resize_pending == 0 &&
!cpi->use_svc &&
cpi->oxcf.content != VP9E_CONTENT_SCREEN &&
- cpi->common.width > 352 &&
- cpi->common.height > 288)
+ cpi->common.width >= 640 &&
+ cpi->common.height >= 480)
return 1;
else
return 0;
@@ -85,8 +89,9 @@
// Estimate of noise level every frame_period frames.
int frame_period = 10;
int thresh_consec_zeromv = 8;
- unsigned int thresh_sum_diff = 128;
- int num_frames_estimate = 20;
+ unsigned int thresh_sum_diff = 100;
+ unsigned int thresh_sum_spatial = (200 * 200) << 8;
+ unsigned int thresh_spatial_var = (32 * 32) << 8;
int min_blocks_estimate = cm->mi_rows * cm->mi_cols >> 7;
// Estimate is between current source and last source.
YV12_BUFFER_CONFIG *last_source = cpi->Last_Source;
@@ -97,19 +102,24 @@
ne->enabled = enable_noise_estimation(cpi);
if (!ne->enabled ||
cm->current_video_frame % frame_period != 0 ||
- last_source == NULL) {
+ last_source == NULL ||
+ ne->last_w != cm->width ||
+ ne->last_h != cm->height) {
#if CONFIG_VP9_TEMPORAL_DENOISING
if (cpi->oxcf.noise_sensitivity > 0)
copy_frame(&cpi->denoiser.last_source, cpi->Source);
#endif
+ if (last_source != NULL) {
+ ne->last_w = cm->width;
+ ne->last_h = cm->height;
+ }
return;
} else {
int num_samples = 0;
uint64_t avg_est = 0;
int bsize = BLOCK_16X16;
static const unsigned char const_source[16] = {
- 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
- 128, 128};
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
// Loop over sub-sample of 16x16 blocks of frame, and for blocks that have
// been encoded as zero/small mv at least x consecutive frames, compute
// the variance to update estimate of noise in the source.
@@ -125,6 +135,17 @@
const int uv_width_shift = y_width_shift >> 1;
const int uv_height_shift = y_height_shift >> 1;
int mi_row, mi_col;
+ int num_low_motion = 0;
+ int frame_low_motion = 1;
+ for (mi_row = 0; mi_row < cm->mi_rows; mi_row++) {
+ for (mi_col = 0; mi_col < cm->mi_cols; mi_col++) {
+ int bl_index = mi_row * cm->mi_cols + mi_col;
+ if (cr->consec_zero_mv[bl_index] > thresh_consec_zeromv)
+ num_low_motion++;
+ }
+ }
+ if (num_low_motion < ((3 * cm->mi_rows * cm->mi_cols) >> 3))
+ frame_low_motion = 0;
for (mi_row = 0; mi_row < cm->mi_rows; mi_row++) {
for (mi_col = 0; mi_col < cm->mi_cols; mi_col++) {
// 16x16 blocks, 1/4 sample of frame.
@@ -144,7 +165,8 @@
const uint8_t vsource =
src_v[uv_height_shift * src_uvstride + uv_width_shift];
int is_skin = vp9_skin_pixel(ysource, usource, vsource);
- if (cr->consec_zero_mv[bl_index] > thresh_consec_zeromv &&
+ if (frame_low_motion &&
+ cr->consec_zero_mv[bl_index] > thresh_consec_zeromv &&
cr->consec_zero_mv[bl_index1] > thresh_consec_zeromv &&
cr->consec_zero_mv[bl_index2] > thresh_consec_zeromv &&
cr->consec_zero_mv[bl_index3] > thresh_consec_zeromv &&
@@ -164,8 +186,12 @@
const unsigned int spatial_variance =
cpi->fn_ptr[bsize].vf(src_y, src_ystride, const_source,
0, &sse2);
- avg_est += variance / (10 + spatial_variance);
- num_samples++;
+ // Avoid blocks with high brightness and high spatial variance.
+ if ((sse2 - spatial_variance) < thresh_sum_spatial &&
+ spatial_variance < thresh_spatial_var) {
+ avg_est += variance / ((spatial_variance >> 9) + 1);
+ num_samples++;
+ }
}
}
}
@@ -179,25 +205,30 @@
src_u += (src_uvstride << 2) - (cm->mi_cols << 2);
src_v += (src_uvstride << 2) - (cm->mi_cols << 2);
}
+ ne->last_w = cm->width;
+ ne->last_h = cm->height;
// Update noise estimate if we have at a minimum number of block samples,
// and avg_est > 0 (avg_est == 0 can happen if the application inputs
// duplicate frames).
if (num_samples > min_blocks_estimate && avg_est > 0) {
// Normalize.
- avg_est = (avg_est << 8) / num_samples;
+ avg_est = avg_est / num_samples;
// Update noise estimate.
- ne->value = (3 * ne->value + avg_est) >> 2;
+ ne->value = (int)((15 * ne->value + avg_est) >> 4);
ne->count++;
- if (ne->count == num_frames_estimate) {
+ if (ne->count == ne->num_frames_estimate) {
// Reset counter and check noise level condition.
+ ne->num_frames_estimate = 30;
ne->count = 0;
if (ne->value > (ne->thresh << 1))
ne->level = kHigh;
else
if (ne->value > ne->thresh)
ne->level = kMedium;
- else
+ else if (ne->value > (ne->thresh >> 1))
ne->level = kLow;
+ else
+ ne->level = kLowLow;
}
}
}
diff --git a/vp9/encoder/vp9_noise_estimate.h b/vp9/encoder/vp9_noise_estimate.h
index 2acc2ea..0d22ef0 100644
--- a/vp9/encoder/vp9_noise_estimate.h
+++ b/vp9/encoder/vp9_noise_estimate.h
@@ -24,6 +24,7 @@
#endif
typedef enum noise_level {
+ kLowLow,
kLow,
kMedium,
kHigh
@@ -35,6 +36,9 @@
int value;
int thresh;
int count;
+ int last_w;
+ int last_h;
+ int num_frames_estimate;
} NOISE_ESTIMATE;
struct VP9_COMP;
diff --git a/vp9/encoder/vp9_pickmode.c b/vp9/encoder/vp9_pickmode.c
index 867b435..9db044f 100644
--- a/vp9/encoder/vp9_pickmode.c
+++ b/vp9/encoder/vp9_pickmode.c
@@ -779,14 +779,20 @@
struct buf_2d yv12_mb[][MAX_MB_PLANE],
int *rate, int64_t *dist) {
MACROBLOCKD *xd = &x->e_mbd;
-
+ MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi;
const BLOCK_SIZE uv_size = get_plane_block_size(bsize, &xd->plane[1]);
unsigned int var = var_y, sse = sse_y;
// Skipping threshold for ac.
unsigned int thresh_ac;
// Skipping threshold for dc.
unsigned int thresh_dc;
- if (x->encode_breakout > 0) {
+ int motion_low = 1;
+ if (mbmi->mv[0].as_mv.row > 64 ||
+ mbmi->mv[0].as_mv.row < -64 ||
+ mbmi->mv[0].as_mv.col > 64 ||
+ mbmi->mv[0].as_mv.col < -64)
+ motion_low = 0;
+ if (x->encode_breakout > 0 && motion_low == 1) {
// Set a maximum for threshold to avoid big PSNR loss in low bit rate
// case. Use extreme low threshold for static frames to limit
// skipping.
@@ -1477,6 +1483,32 @@
this_rdc.rate += ref_frame_cost[ref_frame];
this_rdc.rdcost = RDCOST(x->rdmult, x->rddiv, this_rdc.rate, this_rdc.dist);
+ if (cpi->oxcf.speed >= 5 &&
+ cpi->oxcf.content != VP9E_CONTENT_SCREEN) {
+ // Bias against non-zero (above some threshold) motion for large blocks.
+ // This is temporary fix to avoid selection of large mv for big blocks.
+ if (frame_mv[this_mode][ref_frame].as_mv.row > 64 ||
+ frame_mv[this_mode][ref_frame].as_mv.row < -64 ||
+ frame_mv[this_mode][ref_frame].as_mv.col > 64 ||
+ frame_mv[this_mode][ref_frame].as_mv.col < -64) {
+ if (bsize == BLOCK_64X64)
+ this_rdc.rdcost = this_rdc.rdcost << 1;
+ else if (bsize >= BLOCK_32X32)
+ this_rdc.rdcost = 3 * this_rdc.rdcost >> 1;
+ }
+ // If noise estimation is enabled, and estimated level is above threshold,
+ // add a bias to LAST reference with small motion, for large blocks.
+ if (cpi->noise_estimate.enabled &&
+ cpi->noise_estimate.level >= kMedium &&
+ bsize >= BLOCK_32X32 &&
+ ref_frame == LAST_FRAME &&
+ frame_mv[this_mode][ref_frame].as_mv.row < 8 &&
+ frame_mv[this_mode][ref_frame].as_mv.row > -8 &&
+ frame_mv[this_mode][ref_frame].as_mv.col < 8 &&
+ frame_mv[this_mode][ref_frame].as_mv.col > -8)
+ this_rdc.rdcost = 7 * this_rdc.rdcost >> 3;
+ }
+
// Skipping checking: test to see if this block can be reconstructed by
// prediction only.
if (cpi->allow_encode_breakout) {
diff --git a/vp9/encoder/vp9_ratectrl.c b/vp9/encoder/vp9_ratectrl.c
index c6fe76c..fdff363 100644
--- a/vp9/encoder/vp9_ratectrl.c
+++ b/vp9/encoder/vp9_ratectrl.c
@@ -1558,7 +1558,7 @@
VP9_COMMON *const cm = &cpi->common;
RATE_CONTROL *const rc = &cpi->rc;
int target = rc->avg_frame_bandwidth;
- const int layer = LAYER_IDS_TO_IDX(cpi->svc.spatial_layer_id,
+ int layer = LAYER_IDS_TO_IDX(cpi->svc.spatial_layer_id,
cpi->svc.temporal_layer_id, cpi->svc.number_temporal_layers);
if ((cm->current_video_frame == 0) ||
@@ -1573,8 +1573,10 @@
cpi->ref_frame_flags &=
(~VP9_LAST_FLAG & ~VP9_GOLD_FLAG & ~VP9_ALT_FLAG);
} else if (is_one_pass_cbr_svc(cpi)) {
- cpi->svc.layer_context[layer].is_key_frame = 1;
reset_temporal_layer_to_zero(cpi);
+ layer = LAYER_IDS_TO_IDX(cpi->svc.spatial_layer_id,
+ cpi->svc.temporal_layer_id, cpi->svc.number_temporal_layers);
+ cpi->svc.layer_context[layer].is_key_frame = 1;
cpi->ref_frame_flags &=
(~VP9_LAST_FLAG & ~VP9_GOLD_FLAG & ~VP9_ALT_FLAG);
// Assumption here is that LAST_FRAME is being updated for a keyframe.
@@ -1873,7 +1875,7 @@
// Resize based on average buffer underflow and QP over some window.
// Ignore samples close to key frame, since QP is usually high after key.
- if (cpi->rc.frames_since_key > 1 * cpi->framerate) {
+ if (cpi->rc.frames_since_key > 2 * cpi->framerate) {
const int window = (int)(4 * cpi->framerate);
cpi->resize_avg_qp += cm->base_qindex;
if (cpi->rc.buffer_level < (int)(30 * rc->optimal_buffer_level / 100))
diff --git a/vp9/encoder/vp9_rd.c b/vp9/encoder/vp9_rd.c
index b085c7a..eda7743 100644
--- a/vp9/encoder/vp9_rd.c
+++ b/vp9/encoder/vp9_rd.c
@@ -76,10 +76,12 @@
vp9_intra_mode_tree);
vp9_cost_tokens(cpi->mbmode_cost, fc->y_mode_prob[1], vp9_intra_mode_tree);
- vp9_cost_tokens(cpi->intra_uv_mode_cost[KEY_FRAME],
- vp9_kf_uv_mode_prob[TM_PRED], vp9_intra_mode_tree);
- vp9_cost_tokens(cpi->intra_uv_mode_cost[INTER_FRAME],
- fc->uv_mode_prob[TM_PRED], vp9_intra_mode_tree);
+ for (i = 0; i < INTRA_MODES; ++i) {
+ vp9_cost_tokens(cpi->intra_uv_mode_cost[KEY_FRAME][i],
+ vp9_kf_uv_mode_prob[i], vp9_intra_mode_tree);
+ vp9_cost_tokens(cpi->intra_uv_mode_cost[INTER_FRAME][i],
+ fc->uv_mode_prob[i], vp9_intra_mode_tree);
+ }
for (i = 0; i < SWITCHABLE_FILTER_CONTEXTS; ++i)
vp9_cost_tokens(cpi->switchable_interp_costs[i],
diff --git a/vp9/encoder/vp9_rdopt.c b/vp9/encoder/vp9_rdopt.c
index 4f3a06e..2a6b707 100644
--- a/vp9/encoder/vp9_rdopt.c
+++ b/vp9/encoder/vp9_rdopt.c
@@ -1199,7 +1199,8 @@
&this_distortion, &s, &this_sse, bsize, best_rd))
continue;
this_rate = this_rate_tokenonly +
- cpi->intra_uv_mode_cost[cpi->common.frame_type][mode];
+ cpi->intra_uv_mode_cost[cpi->common.frame_type]
+ [xd->mi[0]->mbmi.mode][mode];
this_rd = RDCOST(x->rdmult, x->rddiv, this_rate, this_distortion);
if (this_rd < best_rd) {
@@ -1229,7 +1230,9 @@
memset(x->skip_txfm, SKIP_TXFM_NONE, sizeof(x->skip_txfm));
super_block_uvrd(cpi, x, rate_tokenonly, distortion,
skippable, &unused, bsize, INT64_MAX);
- *rate = *rate_tokenonly + cpi->intra_uv_mode_cost[cm->frame_type][DC_PRED];
+ *rate = *rate_tokenonly +
+ cpi->intra_uv_mode_cost[cm->frame_type]
+ [x->e_mbd.mi[0]->mbmi.mode][DC_PRED];
return RDCOST(x->rdmult, x->rddiv, *rate, *distortion);
}
@@ -1747,8 +1750,9 @@
const int num_4x4_blocks_high = num_4x4_blocks_high_lookup[bsize];
ENTROPY_CONTEXT t_above[2], t_left[2];
int subpelmv = 1, have_ref = 0;
+ SPEED_FEATURES *const sf = &cpi->sf;
const int has_second_rf = has_second_ref(mbmi);
- const int inter_mode_mask = cpi->sf.inter_mode_mask[bsize];
+ const int inter_mode_mask = sf->inter_mode_mask[bsize];
MB_MODE_INFO_EXT *const mbmi_ext = x->mbmi_ext;
vp9_zero(*bsi);
@@ -1817,7 +1821,7 @@
seg_mvs[i][mbmi->ref_frame[0]].as_int == INVALID_MV) {
MV *const new_mv = &mode_mv[NEWMV][0].as_mv;
int step_param = 0;
- int thissme, bestsme = INT_MAX;
+ int bestsme = INT_MAX;
int sadpb = x->sadperbit4;
MV mvp_full;
int max_mv;
@@ -1842,7 +1846,7 @@
max_mv =
VPXMAX(abs(bsi->mvp.as_mv.row), abs(bsi->mvp.as_mv.col)) >> 3;
- if (cpi->sf.mv.auto_mv_step_size && cm->show_frame) {
+ if (sf->mv.auto_mv_step_size && cm->show_frame) {
// Take wtd average of the step_params based on the last frame's
// max mv magnitude and the best ref mvs of the current block for
// the given reference.
@@ -1855,7 +1859,7 @@
mvp_full.row = bsi->mvp.as_mv.row >> 3;
mvp_full.col = bsi->mvp.as_mv.col >> 3;
- if (cpi->sf.adaptive_motion_search) {
+ if (sf->adaptive_motion_search) {
mvp_full.row = x->pred_mv[mbmi->ref_frame[0]].row >> 3;
mvp_full.col = x->pred_mv[mbmi->ref_frame[0]].col >> 3;
step_param = VPXMAX(step_param, 8);
@@ -1868,31 +1872,10 @@
bestsme = vp9_full_pixel_search(
cpi, x, bsize, &mvp_full, step_param, sadpb,
- cpi->sf.mv.subpel_search_method != SUBPEL_TREE ? cost_list : NULL,
+ sf->mv.subpel_search_method != SUBPEL_TREE ? cost_list : NULL,
&bsi->ref_mv[0]->as_mv, new_mv,
INT_MAX, 1);
- // Should we do a full search (best quality only)
- if (cpi->oxcf.mode == BEST) {
- int_mv *const best_mv = &mi->bmi[i].as_mv[0];
- /* Check if mvp_full is within the range. */
- clamp_mv(&mvp_full, x->mv_col_min, x->mv_col_max,
- x->mv_row_min, x->mv_row_max);
- thissme = cpi->full_search_sad(x, &mvp_full,
- sadpb, 16, &cpi->fn_ptr[bsize],
- &bsi->ref_mv[0]->as_mv,
- &best_mv->as_mv);
- cost_list[1] = cost_list[2] = cost_list[3] = cost_list[4] = INT_MAX;
- if (thissme < bestsme) {
- bestsme = thissme;
- *new_mv = best_mv->as_mv;
- } else {
- // The full search result is actually worse so re-instate the
- // previous best vector
- best_mv->as_mv = *new_mv;
- }
- }
-
if (bestsme < INT_MAX) {
int distortion;
cpi->find_fractional_mv_step(
@@ -1901,8 +1884,8 @@
&bsi->ref_mv[0]->as_mv,
cm->allow_high_precision_mv,
x->errorperbit, &cpi->fn_ptr[bsize],
- cpi->sf.mv.subpel_force_stop,
- cpi->sf.mv.subpel_iters_per_step,
+ sf->mv.subpel_force_stop,
+ sf->mv.subpel_iters_per_step,
cond_cost_list(cpi, cost_list),
x->nmvjointcost, x->mvcost,
&distortion,
@@ -1913,7 +1896,7 @@
seg_mvs[i][mbmi->ref_frame[0]].as_mv = *new_mv;
}
- if (cpi->sf.adaptive_motion_search)
+ if (sf->adaptive_motion_search)
x->pred_mv[mbmi->ref_frame[0]] = *new_mv;
// restore src pointers
@@ -1930,7 +1913,7 @@
mbmi->interp_filter == EIGHTTAP) {
// adjust src pointers
mi_buf_shift(x, i);
- if (cpi->sf.comp_inter_joint_search_thresh <= bsize) {
+ if (sf->comp_inter_joint_search_thresh <= bsize) {
int rate_mv;
joint_motion_search(cpi, x, bsize, frame_mv[this_mode],
mi_row, mi_col, seg_mvs[i],
@@ -2848,9 +2831,9 @@
? (source_variance - recon_variance)
: (recon_variance - source_variance);
- var_error = (200 * source_variance * recon_variance) /
- ((source_variance * source_variance) +
- (recon_variance * recon_variance));
+ var_error = ((int64_t)200 * source_variance * recon_variance) /
+ (((int64_t)source_variance * source_variance) +
+ ((int64_t)recon_variance * recon_variance));
var_error = 100 - var_error;
}
diff --git a/vp9/encoder/vp9_speed_features.c b/vp9/encoder/vp9_speed_features.c
index a539629..318d810 100644
--- a/vp9/encoder/vp9_speed_features.c
+++ b/vp9/encoder/vp9_speed_features.c
@@ -15,6 +15,22 @@
#include "vp9/encoder/vp9_rdopt.h"
#include "vpx_dsp/vpx_dsp_common.h"
+// Mesh search patters for various speed settings
+static MESH_PATTERN best_quality_mesh_pattern[MAX_MESH_STEP] =
+ {{64, 4}, {28, 2}, {15, 1}, {7, 1}};
+
+#define MAX_MESH_SPEED 5 // Max speed setting for mesh motion method
+static MESH_PATTERN good_quality_mesh_patterns[MAX_MESH_SPEED + 1]
+ [MAX_MESH_STEP] =
+ {{{64, 8}, {28, 4}, {15, 1}, {7, 1}},
+ {{64, 8}, {28, 4}, {15, 1}, {7, 1}},
+ {{64, 8}, {14, 2}, {7, 1}, {7, 1}},
+ {{64, 16}, {24, 8}, {12, 4}, {7, 1}},
+ {{64, 16}, {24, 8}, {12, 4}, {7, 1}},
+ {{64, 16}, {24, 8}, {12, 4}, {7, 1}},
+ };
+static unsigned char good_quality_max_mesh_pct[MAX_MESH_SPEED + 1] =
+ {50, 25, 15, 5, 1, 1};
// Intra only frames, golden frames (except alt ref overlays) and
// alt ref frames tend to be coded at a higher than ambient quality
@@ -259,6 +275,8 @@
sf->static_segmentation = 0;
sf->adaptive_rd_thresh = 1;
sf->use_fast_coef_costing = 1;
+ sf->allow_exhaustive_searches = 0;
+ sf->exhaustive_searches_thresh = INT_MAX;
if (speed >= 1) {
sf->use_square_partition_only = !frame_is_intra_only(cm);
@@ -460,7 +478,6 @@
sf->mv.auto_mv_step_size = 0;
sf->mv.fullpel_search_step_param = 6;
sf->comp_inter_joint_search_thresh = BLOCK_4X4;
- sf->adaptive_rd_thresh = 0;
sf->tx_size_search_method = USE_FULL_RD;
sf->use_lp32x32fdct = 0;
sf->adaptive_motion_search = 0;
@@ -516,19 +533,50 @@
// Recode loop tolerance %.
sf->recode_tolerance = 25;
sf->default_interp_filter = SWITCHABLE;
- sf->tx_size_search_breakout = 0;
- sf->partition_search_breakout_dist_thr = 0;
- sf->partition_search_breakout_rate_thr = 0;
sf->simple_model_rd_from_var = 0;
+ // Some speed-up features even for best quality as minimal impact on quality.
+ sf->adaptive_rd_thresh = 1;
+ sf->tx_size_search_breakout = 1;
+ sf->partition_search_breakout_dist_thr = (1 << 19);
+ sf->partition_search_breakout_rate_thr = 80;
+
if (oxcf->mode == REALTIME)
set_rt_speed_feature(cpi, sf, oxcf->speed, oxcf->content);
else if (oxcf->mode == GOOD)
set_good_speed_feature(cpi, cm, sf, oxcf->speed);
cpi->full_search_sad = vp9_full_search_sad;
- cpi->diamond_search_sad = oxcf->mode == BEST ? vp9_full_range_search
- : vp9_diamond_search_sad;
+ cpi->diamond_search_sad = vp9_diamond_search_sad;
+
+ sf->allow_exhaustive_searches = 1;
+ if (oxcf->mode == BEST) {
+ if (cpi->twopass.fr_content_type == FC_GRAPHICS_ANIMATION)
+ sf->exhaustive_searches_thresh = (1 << 20);
+ else
+ sf->exhaustive_searches_thresh = (1 << 21);
+ sf->max_exaustive_pct = 100;
+ for (i = 0; i < MAX_MESH_STEP; ++i) {
+ sf->mesh_patterns[i].range = best_quality_mesh_pattern[i].range;
+ sf->mesh_patterns[i].interval = best_quality_mesh_pattern[i].interval;
+ }
+ } else {
+ int speed = (oxcf->speed > MAX_MESH_SPEED) ? MAX_MESH_SPEED : oxcf->speed;
+ if (cpi->twopass.fr_content_type == FC_GRAPHICS_ANIMATION)
+ sf->exhaustive_searches_thresh = (1 << 22);
+ else
+ sf->exhaustive_searches_thresh = (1 << 23);
+ sf->max_exaustive_pct = good_quality_max_mesh_pct[speed];
+ if (speed > 0)
+ sf->exhaustive_searches_thresh = sf->exhaustive_searches_thresh << 1;
+
+ for (i = 0; i < MAX_MESH_STEP; ++i) {
+ sf->mesh_patterns[i].range =
+ good_quality_mesh_patterns[speed][i].range;
+ sf->mesh_patterns[i].interval =
+ good_quality_mesh_patterns[speed][i].interval;
+ }
+ }
// Slow quant, dct and trellis not worthwhile for first pass
// so make sure they are always turned off.
diff --git a/vp9/encoder/vp9_speed_features.h b/vp9/encoder/vp9_speed_features.h
index 575e98c..ad7b64a 100644
--- a/vp9/encoder/vp9_speed_features.h
+++ b/vp9/encoder/vp9_speed_features.h
@@ -195,6 +195,13 @@
int fullpel_search_step_param;
} MV_SPEED_FEATURES;
+#define MAX_MESH_STEP 4
+
+typedef struct MESH_PATTERN {
+ int range;
+ int interval;
+} MESH_PATTERN;
+
typedef struct SPEED_FEATURES {
MV_SPEED_FEATURES mv;
@@ -299,6 +306,18 @@
// point for this motion search and limits the search range around it.
int adaptive_motion_search;
+ // Flag for allowing some use of exhaustive searches;
+ int allow_exhaustive_searches;
+
+ // Threshold for allowing exhaistive motion search.
+ int exhaustive_searches_thresh;
+
+ // Maximum number of exhaustive searches for a frame.
+ int max_exaustive_pct;
+
+ // Pattern to be used for any exhaustive mesh searches.
+ MESH_PATTERN mesh_patterns[MAX_MESH_STEP];
+
int schedule_mode_search;
// Allows sub 8x8 modes to use the prediction filter that was determined
diff --git a/vp9/encoder/vp9_svc_layercontext.c b/vp9/encoder/vp9_svc_layercontext.c
index 1dfc45c..13da155 100644
--- a/vp9/encoder/vp9_svc_layercontext.c
+++ b/vp9/encoder/vp9_svc_layercontext.c
@@ -278,7 +278,8 @@
cpi->alt_ref_source = lc->alt_ref_source;
// Reset the frames_since_key and frames_to_key counters to their values
// before the layer restore. Keep these defined for the stream (not layer).
- if (cpi->svc.number_temporal_layers > 1) {
+ if (cpi->svc.number_temporal_layers > 1 ||
+ cpi->svc.number_spatial_layers > 1) {
cpi->rc.frames_since_key = old_frame_since_key;
cpi->rc.frames_to_key = old_frame_to_key;
}
diff --git a/vp9/encoder/x86/vp9_diamond_search_sad_avx.c b/vp9/encoder/x86/vp9_diamond_search_sad_avx.c
new file mode 100644
index 0000000..2ed3f1a
--- /dev/null
+++ b/vp9/encoder/x86/vp9_diamond_search_sad_avx.c
@@ -0,0 +1,322 @@
+/*
+ * 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.
+ */
+
+#if defined(_MSC_VER)
+# include <intrin.h>
+#endif
+#include <emmintrin.h>
+#include <smmintrin.h>
+
+#include "vpx_dsp/vpx_dsp_common.h"
+#include "vp9/encoder/vp9_encoder.h"
+#include "vpx_ports/mem.h"
+
+#ifdef __GNUC__
+# define __likely__(v) __builtin_expect(v, 1)
+# define __unlikely__(v) __builtin_expect(v, 0)
+#else
+# define __likely__(v) (v)
+# define __unlikely__(v) (v)
+#endif
+
+static INLINE int_mv pack_int_mv(int16_t row, int16_t col) {
+ int_mv result;
+ result.as_mv.row = row;
+ result.as_mv.col = col;
+ return result;
+}
+
+static INLINE MV_JOINT_TYPE get_mv_joint(const int_mv mv) {
+ // This is simplified from the C implementation to utilise that
+ // x->nmvjointsadcost[1] == x->nmvjointsadcost[2] and
+ // x->nmvjointsadcost[1] == x->nmvjointsadcost[3]
+ return mv.as_int == 0 ? 0 : 1;
+}
+
+static INLINE int mv_cost(const int_mv mv,
+ const int *joint_cost, int *const comp_cost[2]) {
+ return joint_cost[get_mv_joint(mv)] +
+ comp_cost[0][mv.as_mv.row] + comp_cost[1][mv.as_mv.col];
+}
+
+static int mvsad_err_cost(const MACROBLOCK *x, const int_mv mv, const MV *ref,
+ int error_per_bit) {
+ const int_mv diff = pack_int_mv(mv.as_mv.row - ref->row,
+ mv.as_mv.col - ref->col);
+ return ROUND_POWER_OF_TWO(mv_cost(diff, x->nmvjointsadcost,
+ x->nmvsadcost) * error_per_bit, 8);
+}
+
+/*****************************************************************************
+ * This function utilises 3 properties of the cost function lookup tables, *
+ * constructed in using 'cal_nmvjointsadcost' and 'cal_nmvsadcosts' in *
+ * vp9_encoder.c. *
+ * For the joint cost: *
+ * - mvjointsadcost[1] == mvjointsadcost[2] == mvjointsadcost[3] *
+ * For the component costs: *
+ * - For all i: mvsadcost[0][i] == mvsadcost[1][i] *
+ * (Equal costs for both components) *
+ * - For all i: mvsadcost[0][i] == mvsadcost[0][-i] *
+ * (Cost function is even) *
+ * If these do not hold, then this function cannot be used without *
+ * modification, in which case you can revert to using the C implementation, *
+ * which does not rely on these properties. *
+ *****************************************************************************/
+int vp9_diamond_search_sad_avx(const MACROBLOCK *x,
+ const search_site_config *cfg,
+ MV *ref_mv, MV *best_mv, int search_param,
+ int sad_per_bit, int *num00,
+ const vp9_variance_fn_ptr_t *fn_ptr,
+ const MV *center_mv) {
+ const int_mv maxmv = pack_int_mv(x->mv_row_max, x->mv_col_max);
+ const __m128i v_max_mv_w = _mm_set1_epi32(maxmv.as_int);
+ const int_mv minmv = pack_int_mv(x->mv_row_min, x->mv_col_min);
+ const __m128i v_min_mv_w = _mm_set1_epi32(minmv.as_int);
+
+ const __m128i v_spb_d = _mm_set1_epi32(sad_per_bit);
+
+ const __m128i v_joint_cost_0_d = _mm_set1_epi32(x->nmvjointsadcost[0]);
+ const __m128i v_joint_cost_1_d = _mm_set1_epi32(x->nmvjointsadcost[1]);
+
+ // search_param determines the length of the initial step and hence the number
+ // of iterations.
+ // 0 = initial step (MAX_FIRST_STEP) pel
+ // 1 = (MAX_FIRST_STEP/2) pel,
+ // 2 = (MAX_FIRST_STEP/4) pel...
+ const MV *ss_mv = &cfg->ss_mv[cfg->searches_per_step * search_param];
+ const intptr_t *ss_os = &cfg->ss_os[cfg->searches_per_step * search_param];
+ const int tot_steps = cfg->total_steps - search_param;
+
+ const int_mv fcenter_mv = pack_int_mv(center_mv->row >> 3,
+ center_mv->col >> 3);
+ const __m128i vfcmv = _mm_set1_epi32(fcenter_mv.as_int);
+
+ const int ref_row = clamp(ref_mv->row, minmv.as_mv.row, maxmv.as_mv.row);
+ const int ref_col = clamp(ref_mv->col, minmv.as_mv.col, maxmv.as_mv.col);
+
+ int_mv bmv = pack_int_mv(ref_row, ref_col);
+ int_mv new_bmv = bmv;
+ __m128i v_bmv_w = _mm_set1_epi32(bmv.as_int);
+
+ const int what_stride = x->plane[0].src.stride;
+ const int in_what_stride = x->e_mbd.plane[0].pre[0].stride;
+ const uint8_t *const what = x->plane[0].src.buf;
+ const uint8_t *const in_what = x->e_mbd.plane[0].pre[0].buf +
+ ref_row * in_what_stride + ref_col;
+
+ // Work out the start point for the search
+ const uint8_t *best_address = in_what;
+ const uint8_t *new_best_address = best_address;
+#if ARCH_X86_64
+ __m128i v_ba_q = _mm_set1_epi64x((intptr_t)best_address);
+#else
+ __m128i v_ba_d = _mm_set1_epi32((intptr_t)best_address);
+#endif
+
+ unsigned int best_sad;
+
+ int i;
+ int j;
+ int step;
+
+ // Check the prerequisite cost function properties that are easy to check
+ // in an assert. See the function-level documentation for details on all
+ // prerequisites.
+ assert(x->nmvjointsadcost[1] == x->nmvjointsadcost[2]);
+ assert(x->nmvjointsadcost[1] == x->nmvjointsadcost[3]);
+
+ // Check the starting position
+ best_sad = fn_ptr->sdf(what, what_stride, in_what, in_what_stride);
+ best_sad += mvsad_err_cost(x, bmv, &fcenter_mv.as_mv, sad_per_bit);
+
+ *num00 = 0;
+
+ for (i = 0, step = 0; step < tot_steps; step++) {
+ for (j = 0; j < cfg->searches_per_step; j += 4, i += 4) {
+ __m128i v_sad_d;
+ __m128i v_cost_d;
+ __m128i v_outside_d;
+ __m128i v_inside_d;
+ __m128i v_diff_mv_w;
+#if ARCH_X86_64
+ __m128i v_blocka[2];
+#else
+ __m128i v_blocka[1];
+#endif
+
+ // Compute the candidate motion vectors
+ const __m128i v_ss_mv_w = _mm_loadu_si128((const __m128i*)&ss_mv[i]);
+ const __m128i v_these_mv_w = _mm_add_epi16(v_bmv_w, v_ss_mv_w);
+ // Clamp them to the search bounds
+ __m128i v_these_mv_clamp_w = v_these_mv_w;
+ v_these_mv_clamp_w = _mm_min_epi16(v_these_mv_clamp_w, v_max_mv_w);
+ v_these_mv_clamp_w = _mm_max_epi16(v_these_mv_clamp_w, v_min_mv_w);
+ // The ones that did not change are inside the search area
+ v_inside_d = _mm_cmpeq_epi32(v_these_mv_clamp_w, v_these_mv_w);
+
+ // If none of them are inside, then move on
+ if (__likely__(_mm_test_all_zeros(v_inside_d, v_inside_d))) {
+ continue;
+ }
+
+ // The inverse mask indicates which of the MVs are outside
+ v_outside_d = _mm_xor_si128(v_inside_d, _mm_set1_epi8(0xff));
+ // Shift right to keep the sign bit clear, we will use this later
+ // to set the cost to the maximum value.
+ v_outside_d = _mm_srli_epi32(v_outside_d, 1);
+
+ // Compute the difference MV
+ v_diff_mv_w = _mm_sub_epi16(v_these_mv_clamp_w, vfcmv);
+ // We utilise the fact that the cost function is even, and use the
+ // absolute difference. This allows us to use unsigned indexes later
+ // and reduces cache pressure somewhat as only a half of the table
+ // is ever referenced.
+ v_diff_mv_w = _mm_abs_epi16(v_diff_mv_w);
+
+ // Compute the SIMD pointer offsets.
+ {
+#if ARCH_X86_64 // sizeof(intptr_t) == 8
+ // Load the offsets
+ __m128i v_bo10_q = _mm_loadu_si128((const __m128i*)&ss_os[i+0]);
+ __m128i v_bo32_q = _mm_loadu_si128((const __m128i*)&ss_os[i+2]);
+ // Set the ones falling outside to zero
+ v_bo10_q = _mm_and_si128(v_bo10_q,
+ _mm_cvtepi32_epi64(v_inside_d));
+ v_bo32_q = _mm_and_si128(v_bo32_q,
+ _mm_unpackhi_epi32(v_inside_d, v_inside_d));
+ // Compute the candidate addresses
+ v_blocka[0] = _mm_add_epi64(v_ba_q, v_bo10_q);
+ v_blocka[1] = _mm_add_epi64(v_ba_q, v_bo32_q);
+#else // ARCH_X86 // sizeof(intptr_t) == 4
+ __m128i v_bo_d = _mm_loadu_si128((const __m128i*)&ss_os[i]);
+ v_bo_d = _mm_and_si128(v_bo_d, v_inside_d);
+ v_blocka[0] = _mm_add_epi32(v_ba_d, v_bo_d);
+#endif
+ }
+
+ fn_ptr->sdx4df(what, what_stride,
+ (const uint8_t **)&v_blocka[0], in_what_stride,
+ (uint32_t*)&v_sad_d);
+
+ // Look up the component cost of the residual motion vector
+ {
+ const int32_t row0 = _mm_extract_epi16(v_diff_mv_w, 0);
+ const int32_t col0 = _mm_extract_epi16(v_diff_mv_w, 1);
+ const int32_t row1 = _mm_extract_epi16(v_diff_mv_w, 2);
+ const int32_t col1 = _mm_extract_epi16(v_diff_mv_w, 3);
+ const int32_t row2 = _mm_extract_epi16(v_diff_mv_w, 4);
+ const int32_t col2 = _mm_extract_epi16(v_diff_mv_w, 5);
+ const int32_t row3 = _mm_extract_epi16(v_diff_mv_w, 6);
+ const int32_t col3 = _mm_extract_epi16(v_diff_mv_w, 7);
+
+ // Note: This is a use case for vpgather in AVX2
+ const uint32_t cost0 = x->nmvsadcost[0][row0] + x->nmvsadcost[0][col0];
+ const uint32_t cost1 = x->nmvsadcost[0][row1] + x->nmvsadcost[0][col1];
+ const uint32_t cost2 = x->nmvsadcost[0][row2] + x->nmvsadcost[0][col2];
+ const uint32_t cost3 = x->nmvsadcost[0][row3] + x->nmvsadcost[0][col3];
+
+ __m128i v_cost_10_d, v_cost_32_d;
+
+ v_cost_10_d = _mm_cvtsi32_si128(cost0);
+ v_cost_10_d = _mm_insert_epi32(v_cost_10_d, cost1, 1);
+
+ v_cost_32_d = _mm_cvtsi32_si128(cost2);
+ v_cost_32_d = _mm_insert_epi32(v_cost_32_d, cost3, 1);
+
+ v_cost_d = _mm_unpacklo_epi64(v_cost_10_d, v_cost_32_d);
+ }
+
+ // Now add in the joint cost
+ {
+ const __m128i v_sel_d = _mm_cmpeq_epi32(v_diff_mv_w,
+ _mm_setzero_si128());
+ const __m128i v_joint_cost_d = _mm_blendv_epi8(v_joint_cost_1_d,
+ v_joint_cost_0_d,
+ v_sel_d);
+ v_cost_d = _mm_add_epi32(v_cost_d, v_joint_cost_d);
+ }
+
+ // Multiply by sad_per_bit
+ v_cost_d = _mm_mullo_epi32(v_cost_d, v_spb_d);
+ // ROUND_POWER_OF_TWO(v_cost_d, 8)
+ v_cost_d = _mm_add_epi32(v_cost_d, _mm_set1_epi32(0x80));
+ v_cost_d = _mm_srai_epi32(v_cost_d, 8);
+ // Add the cost to the sad
+ v_sad_d = _mm_add_epi32(v_sad_d, v_cost_d);
+
+ // Make the motion vectors outside the search area have max cost
+ // by or'ing in the comparison mask, this way the minimum search won't
+ // pick them.
+ v_sad_d = _mm_or_si128(v_sad_d, v_outside_d);
+
+ // Find the minimum value and index horizontally in v_sad_d
+ {
+ // Try speculatively on 16 bits, so we can use the minpos intrinsic
+ const __m128i v_sad_w = _mm_packus_epi32(v_sad_d, v_sad_d);
+ const __m128i v_minp_w = _mm_minpos_epu16(v_sad_w);
+
+ uint32_t local_best_sad = _mm_extract_epi16(v_minp_w, 0);
+ uint32_t local_best_idx = _mm_extract_epi16(v_minp_w, 1);
+
+ // If the local best value is not saturated, just use it, otherwise
+ // find the horizontal minimum again the hard way on 32 bits.
+ // This is executed rarely.
+ if (__unlikely__(local_best_sad == 0xffff)) {
+ __m128i v_loval_d, v_hival_d, v_loidx_d, v_hiidx_d, v_sel_d;
+
+ v_loval_d = v_sad_d;
+ v_loidx_d = _mm_set_epi32(3, 2, 1, 0);
+ v_hival_d = _mm_srli_si128(v_loval_d, 8);
+ v_hiidx_d = _mm_srli_si128(v_loidx_d, 8);
+
+ v_sel_d = _mm_cmplt_epi32(v_hival_d, v_loval_d);
+
+ v_loval_d = _mm_blendv_epi8(v_loval_d, v_hival_d, v_sel_d);
+ v_loidx_d = _mm_blendv_epi8(v_loidx_d, v_hiidx_d, v_sel_d);
+ v_hival_d = _mm_srli_si128(v_loval_d, 4);
+ v_hiidx_d = _mm_srli_si128(v_loidx_d, 4);
+
+ v_sel_d = _mm_cmplt_epi32(v_hival_d, v_loval_d);
+
+ v_loval_d = _mm_blendv_epi8(v_loval_d, v_hival_d, v_sel_d);
+ v_loidx_d = _mm_blendv_epi8(v_loidx_d, v_hiidx_d, v_sel_d);
+
+ local_best_sad = _mm_extract_epi32(v_loval_d, 0);
+ local_best_idx = _mm_extract_epi32(v_loidx_d, 0);
+ }
+
+ // Update the global minimum if the local minimum is smaller
+ if (__likely__(local_best_sad < best_sad)) {
+ new_bmv = ((const int_mv *)&v_these_mv_w)[local_best_idx];
+ new_best_address = ((const uint8_t **)v_blocka)[local_best_idx];
+
+ best_sad = local_best_sad;
+ }
+ }
+ }
+
+ bmv = new_bmv;
+ best_address = new_best_address;
+
+ v_bmv_w = _mm_set1_epi32(bmv.as_int);
+#if ARCH_X86_64
+ v_ba_q = _mm_set1_epi64x((intptr_t)best_address);
+#else
+ v_ba_d = _mm_set1_epi32((intptr_t)best_address);
+#endif
+
+ if (__unlikely__(best_address == in_what)) {
+ (*num00)++;
+ }
+ }
+
+ *best_mv = bmv.as_mv;
+ return best_sad;
+}
diff --git a/vp9/vp9_cx_iface.c b/vp9/vp9_cx_iface.c
index 6ccba0f..db7f537 100644
--- a/vp9/vp9_cx_iface.c
+++ b/vp9/vp9_cx_iface.c
@@ -1393,8 +1393,8 @@
LAYER_IDS_TO_IDX(sl, tl, cpi->svc.number_temporal_layers);
LAYER_CONTEXT *lc =
&cpi->svc.layer_context[layer];
- lc->max_q = params->max_quantizers[sl];
- lc->min_q = params->min_quantizers[sl];
+ lc->max_q = params->max_quantizers[layer];
+ lc->min_q = params->min_quantizers[layer];
lc->scaling_factor_num = params->scaling_factor_num[sl];
lc->scaling_factor_den = params->scaling_factor_den[sl];
}
diff --git a/vp9/vp9cx.mk b/vp9/vp9cx.mk
index 3f3bdef..5918240 100644
--- a/vp9/vp9cx.mk
+++ b/vp9/vp9cx.mk
@@ -96,6 +96,7 @@
VP9_CX_SRCS-$(HAVE_SSE2) += encoder/x86/vp9_avg_intrin_sse2.c
VP9_CX_SRCS-$(HAVE_SSE2) += encoder/x86/vp9_temporal_filter_apply_sse2.asm
VP9_CX_SRCS-$(HAVE_SSE2) += encoder/x86/vp9_quantize_sse2.c
+VP9_CX_SRCS-$(HAVE_AVX) += encoder/x86/vp9_diamond_search_sad_avx.c
ifeq ($(CONFIG_VP9_HIGHBITDEPTH),yes)
VP9_CX_SRCS-$(HAVE_SSE2) += encoder/x86/vp9_highbd_block_error_intrin_sse2.c
endif
diff --git a/vpx/src/svc_encodeframe.c b/vpx/src/svc_encodeframe.c
index ff7c10a..68d1d8d 100644
--- a/vpx/src/svc_encodeframe.c
+++ b/vpx/src/svc_encodeframe.c
@@ -385,7 +385,7 @@
vpx_codec_iface_t *iface,
vpx_codec_enc_cfg_t *enc_cfg) {
vpx_codec_err_t res;
- int i;
+ int i, sl , tl;
SvcInternal_t *const si = get_svc_internal(svc_ctx);
if (svc_ctx == NULL || codec_ctx == NULL || iface == NULL ||
enc_cfg == NULL) {
@@ -423,11 +423,14 @@
svc_ctx->temporal_layers = 2;
}
- for (i = 0; i < VPX_SS_MAX_LAYERS; ++i) {
- si->svc_params.max_quantizers[i] = MAX_QUANTIZER;
- si->svc_params.min_quantizers[i] = 0;
- si->svc_params.scaling_factor_num[i] = DEFAULT_SCALE_FACTORS_NUM[i];
- si->svc_params.scaling_factor_den[i] = DEFAULT_SCALE_FACTORS_DEN[i];
+ for (tl = 0; tl < svc_ctx->temporal_layers; ++tl) {
+ for (sl = 0; sl < svc_ctx->spatial_layers; ++sl) {
+ i = sl * svc_ctx->temporal_layers + tl;
+ si->svc_params.max_quantizers[i] = MAX_QUANTIZER;
+ si->svc_params.min_quantizers[i] = 0;
+ si->svc_params.scaling_factor_num[sl] = DEFAULT_SCALE_FACTORS_NUM[sl];
+ si->svc_params.scaling_factor_den[sl] = DEFAULT_SCALE_FACTORS_DEN[sl];
+ }
}
// Parse aggregate command line options. Options must start with
diff --git a/vpx_dsp/bitreader_buffer.c b/vpx_dsp/bitreader_buffer.c
index bb91726..d7b55cf 100644
--- a/vpx_dsp/bitreader_buffer.c
+++ b/vpx_dsp/bitreader_buffer.c
@@ -45,7 +45,7 @@
int bits) {
#if CONFIG_MISC_FIXES
const int nbits = sizeof(unsigned) * 8 - bits - 1;
- const unsigned value = vpx_rb_read_literal(rb, bits + 1) << nbits;
+ const unsigned value = (unsigned)vpx_rb_read_literal(rb, bits + 1) << nbits;
return ((int) value) >> nbits;
#else
return vpx_rb_read_signed_literal(rb, bits);
diff --git a/vpx_dsp/vpx_dsp_rtcd_defs.pl b/vpx_dsp/vpx_dsp_rtcd_defs.pl
index b369b05..4de85a4 100644
--- a/vpx_dsp/vpx_dsp_rtcd_defs.pl
+++ b/vpx_dsp/vpx_dsp_rtcd_defs.pl
@@ -97,7 +97,7 @@
specialize qw/vpx_ve_predictor_4x4/;
add_proto qw/void vpx_tm_predictor_4x4/, "uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left";
-specialize qw/vpx_tm_predictor_4x4 neon dspr2 msa/, "$sse_x86inc";
+specialize qw/vpx_tm_predictor_4x4 neon dspr2 msa/, "$sse2_x86inc";
add_proto qw/void vpx_dc_predictor_4x4/, "uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left";
specialize qw/vpx_dc_predictor_4x4 dspr2 msa neon/, "$sse_x86inc";
@@ -893,7 +893,7 @@
specialize qw/vpx_idct32x32_1024_add sse2 neon dspr2 msa/;
add_proto qw/void vpx_idct32x32_34_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride";
- specialize qw/vpx_idct32x32_34_add sse2 neon_asm dspr2 msa/;
+ specialize qw/vpx_idct32x32_34_add sse2 neon_asm dspr2 msa/, "$ssse3_x86_64_x86inc";
# Need to add 34 eob idct32x32 neon implementation.
$vpx_idct32x32_34_add_neon_asm=vpx_idct32x32_1024_add_neon;
diff --git a/vpx_dsp/x86/intrapred_sse2.asm b/vpx_dsp/x86/intrapred_sse2.asm
index 22b5731..04b39a5 100644
--- a/vpx_dsp/x86/intrapred_sse2.asm
+++ b/vpx_dsp/x86/intrapred_sse2.asm
@@ -515,35 +515,34 @@
jnz .loop
REP_RET
-INIT_MMX sse
-cglobal tm_predictor_4x4, 4, 4, 4, dst, stride, above, left
+INIT_XMM sse2
+cglobal tm_predictor_4x4, 4, 4, 5, dst, stride, above, left
pxor m1, m1
- movd m2, [aboveq-1]
- movd m0, [aboveq]
- punpcklbw m2, m1
+ movq m0, [aboveq-1]; [63:0] tl t1 t2 t3 t4 x x x
punpcklbw m0, m1
- pshufw m2, m2, 0x0
- DEFINE_ARGS dst, stride, line, left
- mov lineq, -2
- add leftq, 4
- psubw m0, m2
-.loop:
- movd m2, [leftq+lineq*2]
- movd m3, [leftq+lineq*2+1]
+ pshuflw m2, m0, 0x0 ; [63:0] tl tl tl tl [word]
+ psrldq m0, 2
+ psubw m0, m2 ; [63:0] t1-tl t2-tl t3-tl t4-tl [word]
+ movd m2, [leftq]
punpcklbw m2, m1
- punpcklbw m3, m1
- pshufw m2, m2, 0x0
- pshufw m3, m3, 0x0
- paddw m2, m0
+ pshuflw m4, m2, 0x0 ; [63:0] l1 l1 l1 l1 [word]
+ pshuflw m3, m2, 0x55 ; [63:0] l2 l2 l2 l2 [word]
+ paddw m4, m0
paddw m3, m0
- packuswb m2, m2
+ packuswb m4, m4
packuswb m3, m3
- movd [dstq ], m2
+ movd [dstq ], m4
movd [dstq+strideq], m3
lea dstq, [dstq+strideq*2]
- inc lineq
- jnz .loop
- REP_RET
+ pshuflw m4, m2, 0xaa
+ pshuflw m3, m2, 0xff
+ paddw m4, m0
+ paddw m3, m0
+ packuswb m4, m4
+ packuswb m3, m3
+ movd [dstq ], m4
+ movd [dstq+strideq], m3
+ RET
INIT_XMM sse2
cglobal tm_predictor_8x8, 4, 4, 4, dst, stride, above, left
diff --git a/vpx_dsp/x86/inv_txfm_ssse3_x86_64.asm b/vpx_dsp/x86/inv_txfm_ssse3_x86_64.asm
index 68e7fa4..2675eab 100644
--- a/vpx_dsp/x86/inv_txfm_ssse3_x86_64.asm
+++ b/vpx_dsp/x86/inv_txfm_ssse3_x86_64.asm
@@ -17,18 +17,46 @@
SECTION_RODATA
pw_11585x2: times 8 dw 23170
+
+pw_m2404x2: times 8 dw -2404*2
+pw_m4756x2: times 8 dw -4756*2
+pw_m5520x2: times 8 dw -5520*2
+
+pw_16364x2: times 8 dw 16364*2
+pw_16305x2: times 8 dw 16305*2
+pw_16207x2: times 8 dw 16207*2
+pw_16069x2: times 8 dw 16069*2
+pw_15893x2: times 8 dw 15893*2
+pw_15679x2: times 8 dw 15679*2
+pw_15426x2: times 8 dw 15426*2
+pw__3981x2: times 8 dw 3981*2
+pw__3196x2: times 8 dw 3196*2
+pw__1606x2: times 8 dw 1606*2
+pw___804x2: times 8 dw 804*2
+
pd_8192: times 4 dd 8192
+pw_32: times 8 dw 32
pw_16: times 8 dw 16
%macro TRANSFORM_COEFFS 2
pw_%1_%2: dw %1, %2, %1, %2, %1, %2, %1, %2
pw_m%2_%1: dw -%2, %1, -%2, %1, -%2, %1, -%2, %1
+pw_m%1_m%2: dw -%1, -%2, -%1, -%2, -%1, -%2, -%1, -%2
%endmacro
TRANSFORM_COEFFS 6270, 15137
TRANSFORM_COEFFS 3196, 16069
TRANSFORM_COEFFS 13623, 9102
+; constants for 32x32_34
+TRANSFORM_COEFFS 804, 16364
+TRANSFORM_COEFFS 15426, 5520
+TRANSFORM_COEFFS 3981, 15893
+TRANSFORM_COEFFS 16207, 2404
+TRANSFORM_COEFFS 1606, 16305
+TRANSFORM_COEFFS 15679, 4756
+TRANSFORM_COEFFS 11585, 11585
+
%macro PAIR_PP_COEFFS 2
dpw_%1_%2: dw %1, %1, %1, %1, %2, %2, %2, %2
%endmacro
@@ -80,6 +108,15 @@
packssdw m%2, m%6
%endmacro
+%macro BUTTERFLY_4Xmm 7 ; dst1, dst2, coef1, coef2, round, tmp1, tmp2
+ punpckhwd m%6, m%2, m%1
+ MUL_ADD_2X %7, %6, %6, %5, [pw_m%4_%3], [pw_m%3_m%4]
+ punpcklwd m%2, m%1
+ MUL_ADD_2X %1, %2, %2, %5, [pw_m%4_%3], [pw_m%3_m%4]
+ packssdw m%1, m%7
+ packssdw m%2, m%6
+%endmacro
+
; matrix transpose
%macro INTERLEAVE_2X 4
punpckh%1 m%4, m%2, m%3
@@ -298,4 +335,452 @@
RET
+%define idx0 16 * 0
+%define idx1 16 * 1
+%define idx2 16 * 2
+%define idx3 16 * 3
+%define idx4 16 * 4
+%define idx5 16 * 5
+%define idx6 16 * 6
+%define idx7 16 * 7
+%define idx8 16 * 0
+%define idx9 16 * 1
+%define idx10 16 * 2
+%define idx11 16 * 3
+%define idx12 16 * 4
+%define idx13 16 * 5
+%define idx14 16 * 6
+%define idx15 16 * 7
+%define idx16 16 * 0
+%define idx17 16 * 1
+%define idx18 16 * 2
+%define idx19 16 * 3
+%define idx20 16 * 4
+%define idx21 16 * 5
+%define idx22 16 * 6
+%define idx23 16 * 7
+%define idx24 16 * 0
+%define idx25 16 * 1
+%define idx26 16 * 2
+%define idx27 16 * 3
+%define idx28 16 * 4
+%define idx29 16 * 5
+%define idx30 16 * 6
+%define idx31 16 * 7
+
+%macro IDCT32X32_34 4
+ ; FROM idct32x32_add_neon.asm
+ ;
+ ; Instead of doing the transforms stage by stage, it is done by loading
+ ; some input values and doing as many stages as possible to minimize the
+ ; storing/loading of intermediate results. To fit within registers, the
+ ; final coefficients are cut into four blocks:
+ ; BLOCK A: 16-19,28-31
+ ; BLOCK B: 20-23,24-27
+ ; BLOCK C: 8-11,12-15
+ ; BLOCK D: 0-3,4-7
+ ; Blocks A and C are straight calculation through the various stages. In
+ ; block B, further calculations are performed using the results from
+ ; block A. In block D, further calculations are performed using the results
+ ; from block C and then the final calculations are done using results from
+ ; block A and B which have been combined at the end of block B.
+ ;
+ ; BLOCK A STAGE 1 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ mova m11, m1
+ pmulhrsw m1, [pw___804x2] ; stp1_16
+ mova [r4 + 0], m0
+ pmulhrsw m11, [pw_16364x2] ; stp2_31
+ mova [r4 + 16 * 2], m2
+ mova m12, m7
+ pmulhrsw m7, [pw_15426x2] ; stp1_28
+ mova [r4 + 16 * 4], m4
+ pmulhrsw m12, [pw_m5520x2] ; stp2_19
+ mova [r4 + 16 * 6], m6
+
+ ; BLOCK A STAGE 2 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ mova m2, m1 ; stp1_16
+ mova m0, m11 ; stp1_31
+ mova m4, m7 ; stp1_28
+ mova m15, m12 ; stp1_19
+
+ ; BLOCK A STAGE 3 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ BUTTERFLY_4X 0, 2, 3196, 16069, m8, 9, 10 ; stp1_17, stp1_30
+ BUTTERFLY_4Xmm 4, 15, 3196, 16069, m8, 9, 10 ; stp1_29, stp1_18
+
+ ; BLOCK A STAGE 4 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ SUM_SUB 1, 12, 9 ; stp2_16, stp2_19
+ SUM_SUB 0, 15, 9 ; stp2_17, stp2_18
+ SUM_SUB 11, 7, 9 ; stp2_31, stp2_28
+ SUM_SUB 2, 4, 9 ; stp2_30, stp2_29
+
+ ; BLOCK A STAGE 5 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ BUTTERFLY_4X 4, 15, 6270, 15137, m8, 9, 10 ; stp1_18, stp1_29
+ BUTTERFLY_4X 7, 12, 6270, 15137, m8, 9, 10 ; stp1_19, stp1_28
+
+ ; BLOCK B STAGE 1 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ mova m6, m5
+ pmulhrsw m5, [pw__3981x2] ; stp1_20
+ mova [stp + %4 + idx28], m12
+ mova [stp + %4 + idx29], m15
+ pmulhrsw m6, [pw_15893x2] ; stp2_27
+ mova [stp + %4 + idx30], m2
+ mova m2, m3
+ pmulhrsw m3, [pw_m2404x2] ; stp1_23
+ mova [stp + %4 + idx31], m11
+ pmulhrsw m2, [pw_16207x2] ; stp2_24
+
+ ; BLOCK B STAGE 2 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ mova m13, m5 ; stp1_20
+ mova m14, m6 ; stp1_27
+ mova m15, m3 ; stp1_23
+ mova m11, m2 ; stp1_24
+
+ ; BLOCK B STAGE 3 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ BUTTERFLY_4X 14, 13, 13623, 9102, m8, 9, 10 ; stp1_21, stp1_26
+ BUTTERFLY_4Xmm 11, 15, 13623, 9102, m8, 9, 10 ; stp1_25, stp1_22
+
+ ; BLOCK B STAGE 4 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ SUM_SUB 3, 5, 9 ; stp2_23, stp2_20
+ SUM_SUB 15, 14, 9 ; stp2_22, stp2_21
+ SUM_SUB 2, 6, 9 ; stp2_24, stp2_27
+ SUM_SUB 11, 13, 9 ; stp2_25, stp2_26
+
+ ; BLOCK B STAGE 5 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ BUTTERFLY_4Xmm 6, 5, 6270, 15137, m8, 9, 10 ; stp1_27, stp1_20
+ BUTTERFLY_4Xmm 13, 14, 6270, 15137, m8, 9, 10 ; stp1_26, stp1_21
+
+ ; BLOCK B STAGE 6 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ SUM_SUB 1, 3, 9 ; stp2_16, stp2_23
+ SUM_SUB 0, 15, 9 ; stp2_17, stp2_22
+ SUM_SUB 4, 14, 9 ; stp2_18, stp2_21
+ SUM_SUB 7, 5, 9 ; stp2_19, stp2_20
+ mova [stp + %3 + idx16], m1
+ mova [stp + %3 + idx17], m0
+ mova [stp + %3 + idx18], m4
+ mova [stp + %3 + idx19], m7
+
+ mova m4, [stp + %4 + idx28]
+ mova m7, [stp + %4 + idx29]
+ mova m10, [stp + %4 + idx30]
+ mova m12, [stp + %4 + idx31]
+ SUM_SUB 4, 6, 9 ; stp2_28, stp2_27
+ SUM_SUB 7, 13, 9 ; stp2_29, stp2_26
+ SUM_SUB 10, 11, 9 ; stp2_30, stp2_25
+ SUM_SUB 12, 2, 9 ; stp2_31, stp2_24
+ mova [stp + %4 + idx28], m4
+ mova [stp + %4 + idx29], m7
+ mova [stp + %4 + idx30], m10
+ mova [stp + %4 + idx31], m12
+
+ ; BLOCK B STAGE 7 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+%if 0 ; overflow occurs in SUM_SUB when using test streams
+ mova m10, [pw_11585x2]
+ SUM_SUB 6, 5, 9
+ pmulhrsw m6, m10 ; stp1_27
+ pmulhrsw m5, m10 ; stp1_20
+ SUM_SUB 13, 14, 9
+ pmulhrsw m13, m10 ; stp1_26
+ pmulhrsw m14, m10 ; stp1_21
+ SUM_SUB 11, 15, 9
+ pmulhrsw m11, m10 ; stp1_25
+ pmulhrsw m15, m10 ; stp1_22
+ SUM_SUB 2, 3, 9
+ pmulhrsw m2, m10 ; stp1_24
+ pmulhrsw m3, m10 ; stp1_23
+%else
+ BUTTERFLY_4X 6, 5, 11585, 11585, m8, 9, 10 ; stp1_20, stp1_27
+ SWAP 6, 5
+ BUTTERFLY_4X 13, 14, 11585, 11585, m8, 9, 10 ; stp1_21, stp1_26
+ SWAP 13, 14
+ BUTTERFLY_4X 11, 15, 11585, 11585, m8, 9, 10 ; stp1_22, stp1_25
+ SWAP 11, 15
+ BUTTERFLY_4X 2, 3, 11585, 11585, m8, 9, 10 ; stp1_23, stp1_24
+ SWAP 2, 3
+%endif
+
+ mova [stp + %4 + idx24], m2
+ mova [stp + %4 + idx25], m11
+ mova [stp + %4 + idx26], m13
+ mova [stp + %4 + idx27], m6
+
+ ; BLOCK C STAGE 1 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ ;
+ ; BLOCK C STAGE 2 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ mova m0, [rsp + transposed_in + 16 * 2]
+ mova m6, [rsp + transposed_in + 16 * 6]
+
+ mova m1, m0
+ pmulhrsw m0, [pw__1606x2] ; stp1_8
+ mova [stp + %3 + idx20], m5
+ mova [stp + %3 + idx21], m14
+ pmulhrsw m1, [pw_16305x2] ; stp2_15
+ mova [stp + %3 + idx22], m15
+ mova m7, m6
+ pmulhrsw m7, [pw_m4756x2] ; stp2_11
+ mova [stp + %3 + idx23], m3
+ pmulhrsw m6, [pw_15679x2] ; stp1_12
+
+ ; BLOCK C STAGE 3 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ mova m3, m0 ; stp1_8
+ mova m2, m1 ; stp1_15
+
+ ; BLOCK C STAGE 4 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ BUTTERFLY_4X 2, 3, 6270, 15137, m8, 9, 10 ; stp1_9, stp1_14
+ mova m4, m7 ; stp1_11
+ mova m5, m6 ; stp1_12
+ BUTTERFLY_4Xmm 5, 4, 6270, 15137, m8, 9, 10 ; stp1_13, stp1_10
+
+ ; BLOCK C STAGE 5 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ SUM_SUB 0, 7, 9 ; stp1_8, stp1_11
+ SUM_SUB 2, 4, 9 ; stp1_9, stp1_10
+ SUM_SUB 1, 6, 9 ; stp1_15, stp1_12
+ SUM_SUB 3, 5, 9 ; stp1_14, stp1_13
+
+ ; BLOCK C STAGE 6 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+%if 0 ; overflow occurs in SUM_SUB when using test streams
+ mova m10, [pw_11585x2]
+ SUM_SUB 5, 4, 9
+ pmulhrsw m5, m10 ; stp1_13
+ pmulhrsw m4, m10 ; stp1_10
+ SUM_SUB 6, 7, 9
+ pmulhrsw m6, m10 ; stp1_12
+ pmulhrsw m7, m10 ; stp1_11
+%else
+ BUTTERFLY_4X 5, 4, 11585, 11585, m8, 9, 10 ; stp1_10, stp1_13
+ SWAP 5, 4
+ BUTTERFLY_4X 6, 7, 11585, 11585, m8, 9, 10 ; stp1_11, stp1_12
+ SWAP 6, 7
+%endif
+
+ ; BLOCK C STAGE 7 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ mova [stp + %2 + idx8], m0
+ mova [stp + %2 + idx9], m2
+ mova [stp + %2 + idx10], m4
+ mova [stp + %2 + idx11], m7
+
+ ; BLOCK D STAGE 1 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ ;
+ ; BLOCK D STAGE 2 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ ;
+ ; BLOCK D STAGE 3 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ mova m11, [rsp + transposed_in + 16 * 4]
+ mova m12, m11
+ pmulhrsw m11, [pw__3196x2] ; stp1_4
+ pmulhrsw m12, [pw_16069x2] ; stp1_7
+
+ ; BLOCK D STAGE 4 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ mova m0, [rsp + transposed_in + 16 * 0]
+ mova m10, [pw_11585x2]
+ pmulhrsw m0, m10 ; stp1_1
+
+ mova m14, m11 ; stp1_4
+ mova m13, m12 ; stp1_7
+
+ ; BLOCK D STAGE 5 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+%if 0 ; overflow occurs in SUM_SUB when using test streams
+ SUM_SUB 13, 14, 9
+ pmulhrsw m13, m10 ; stp1_6
+ pmulhrsw m14, m10 ; stp1_5
+%else
+ BUTTERFLY_4X 13, 14, 11585, 11585, m8, 9, 10 ; stp1_5, stp1_6
+ SWAP 13, 14
+%endif
+ mova m7, m0 ; stp1_0 = stp1_1
+ mova m4, m0 ; stp1_1
+ mova m2, m7 ; stp1_0
+
+ ; BLOCK D STAGE 6 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ SUM_SUB 0, 12, 9 ; stp1_0, stp1_7
+ SUM_SUB 7, 13, 9 ; stp1_1, stp1_6
+ SUM_SUB 2, 14, 9 ; stp1_2, stp1_5
+ SUM_SUB 4, 11, 9 ; stp1_3, stp1_4
+
+ ; BLOCK D STAGE 7 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ SUM_SUB 0, 1, 9 ; stp1_0, stp1_15
+ SUM_SUB 7, 3, 9 ; stp1_1, stp1_14
+ SUM_SUB 2, 5, 9 ; stp1_2, stp1_13
+ SUM_SUB 4, 6, 9 ; stp1_3, stp1_12
+
+ ; 0-3, 28-31 final stage
+ mova m15, [stp + %4 + idx30]
+ mova m10, [stp + %4 + idx31]
+ SUM_SUB 0, 10, 9 ; stp1_0, stp1_31
+ SUM_SUB 7, 15, 9 ; stp1_1, stp1_30
+ mova [stp + %1 + idx0], m0
+ mova [stp + %1 + idx1], m7
+ mova [stp + %4 + idx30], m15
+ mova [stp + %4 + idx31], m10
+ mova m7, [stp + %4 + idx28]
+ mova m0, [stp + %4 + idx29]
+ SUM_SUB 2, 0, 9 ; stp1_2, stp1_29
+ SUM_SUB 4, 7, 9 ; stp1_3, stp1_28
+ mova [stp + %1 + idx2], m2
+ mova [stp + %1 + idx3], m4
+ mova [stp + %4 + idx28], m7
+ mova [stp + %4 + idx29], m0
+
+ ; 12-15, 16-19 final stage
+ mova m0, [stp + %3 + idx16]
+ mova m7, [stp + %3 + idx17]
+ mova m2, [stp + %3 + idx18]
+ mova m4, [stp + %3 + idx19]
+ SUM_SUB 1, 0, 9 ; stp1_15, stp1_16
+ SUM_SUB 3, 7, 9 ; stp1_14, stp1_17
+ SUM_SUB 5, 2, 9 ; stp1_13, stp1_18
+ SUM_SUB 6, 4, 9 ; stp1_12, stp1_19
+ mova [stp + %2 + idx12], m6
+ mova [stp + %2 + idx13], m5
+ mova [stp + %2 + idx14], m3
+ mova [stp + %2 + idx15], m1
+ mova [stp + %3 + idx16], m0
+ mova [stp + %3 + idx17], m7
+ mova [stp + %3 + idx18], m2
+ mova [stp + %3 + idx19], m4
+
+ mova m4, [stp + %2 + idx8]
+ mova m5, [stp + %2 + idx9]
+ mova m6, [stp + %2 + idx10]
+ mova m7, [stp + %2 + idx11]
+ SUM_SUB 11, 7, 9 ; stp1_4, stp1_11
+ SUM_SUB 14, 6, 9 ; stp1_5, stp1_10
+ SUM_SUB 13, 5, 9 ; stp1_6, stp1_9
+ SUM_SUB 12, 4, 9 ; stp1_7, stp1_8
+
+ ; 4-7, 24-27 final stage
+ mova m0, [stp + %4 + idx27]
+ mova m1, [stp + %4 + idx26]
+ mova m2, [stp + %4 + idx25]
+ mova m3, [stp + %4 + idx24]
+ SUM_SUB 11, 0, 9 ; stp1_4, stp1_27
+ SUM_SUB 14, 1, 9 ; stp1_5, stp1_26
+ SUM_SUB 13, 2, 9 ; stp1_6, stp1_25
+ SUM_SUB 12, 3, 9 ; stp1_7, stp1_24
+ mova [stp + %4 + idx27], m0
+ mova [stp + %4 + idx26], m1
+ mova [stp + %4 + idx25], m2
+ mova [stp + %4 + idx24], m3
+ mova [stp + %1 + idx4], m11
+ mova [stp + %1 + idx5], m14
+ mova [stp + %1 + idx6], m13
+ mova [stp + %1 + idx7], m12
+
+ ; 8-11, 20-23 final stage
+ mova m0, [stp + %3 + idx20]
+ mova m1, [stp + %3 + idx21]
+ mova m2, [stp + %3 + idx22]
+ mova m3, [stp + %3 + idx23]
+ SUM_SUB 7, 0, 9 ; stp1_11, stp_20
+ SUM_SUB 6, 1, 9 ; stp1_10, stp_21
+ SUM_SUB 5, 2, 9 ; stp1_9, stp_22
+ SUM_SUB 4, 3, 9 ; stp1_8, stp_23
+ mova [stp + %2 + idx8], m4
+ mova [stp + %2 + idx9], m5
+ mova [stp + %2 + idx10], m6
+ mova [stp + %2 + idx11], m7
+ mova [stp + %3 + idx20], m0
+ mova [stp + %3 + idx21], m1
+ mova [stp + %3 + idx22], m2
+ mova [stp + %3 + idx23], m3
+%endmacro
+
+%macro RECON_AND_STORE 1
+ mova m11, [pw_32]
+ lea stp, [rsp + %1]
+ mov r6, 32
+ pxor m8, m8
+%%recon_and_store:
+ mova m0, [stp + 16 * 32 * 0]
+ mova m1, [stp + 16 * 32 * 1]
+ mova m2, [stp + 16 * 32 * 2]
+ mova m3, [stp + 16 * 32 * 3]
+ add stp, 16
+
+ paddw m0, m11
+ paddw m1, m11
+ paddw m2, m11
+ paddw m3, m11
+ psraw m0, 6
+ psraw m1, 6
+ psraw m2, 6
+ psraw m3, 6
+ movh m4, [outputq + 0]
+ movh m5, [outputq + 8]
+ movh m6, [outputq + 16]
+ movh m7, [outputq + 24]
+ punpcklbw m4, m8
+ punpcklbw m5, m8
+ punpcklbw m6, m8
+ punpcklbw m7, m8
+ paddw m0, m4
+ paddw m1, m5
+ paddw m2, m6
+ paddw m3, m7
+ packuswb m0, m1
+ packuswb m2, m3
+ mova [outputq + 0], m0
+ mova [outputq + 16], m2
+ lea outputq, [outputq + strideq]
+ dec r6
+ jnz %%recon_and_store
+%endmacro
+
+%define i32x32_size 16*32*5
+%define pass_two_start 16*32*0
+%define transposed_in 16*32*4
+%define pass_one_start 16*32*0
+%define stp r8
+
+INIT_XMM ssse3
+cglobal idct32x32_34_add, 3, 11, 16, i32x32_size, input, output, stride
+ mova m8, [pd_8192]
+ lea stp, [rsp + pass_one_start]
+
+idct32x32_34:
+ mov r3, inputq
+ lea r4, [rsp + transposed_in]
+
+idct32x32_34_transpose:
+ mova m0, [r3 + 0]
+ mova m1, [r3 + 16 * 4]
+ mova m2, [r3 + 16 * 8]
+ mova m3, [r3 + 16 * 12]
+ mova m4, [r3 + 16 * 16]
+ mova m5, [r3 + 16 * 20]
+ mova m6, [r3 + 16 * 24]
+ mova m7, [r3 + 16 * 28]
+
+ TRANSPOSE8X8 0, 1, 2, 3, 4, 5, 6, 7, 9
+
+ IDCT32X32_34 16*0, 16*32, 16*64, 16*96
+ lea stp, [stp + 16 * 8]
+ mov r6, 4
+ lea stp, [rsp + pass_one_start]
+ lea r9, [rsp + pass_one_start]
+
+idct32x32_34_2:
+ lea r4, [rsp + transposed_in]
+ mov r3, r9
+
+idct32x32_34_transpose_2:
+ mova m0, [r3 + 0]
+ mova m1, [r3 + 16 * 1]
+ mova m2, [r3 + 16 * 2]
+ mova m3, [r3 + 16 * 3]
+ mova m4, [r3 + 16 * 4]
+ mova m5, [r3 + 16 * 5]
+ mova m6, [r3 + 16 * 6]
+ mova m7, [r3 + 16 * 7]
+
+ TRANSPOSE8X8 0, 1, 2, 3, 4, 5, 6, 7, 9
+
+ IDCT32X32_34 16*0, 16*8, 16*16, 16*24
+
+ lea stp, [stp + 16 * 32]
+ add r9, 16 * 32
+ dec r6
+ jnz idct32x32_34_2
+
+ RECON_AND_STORE pass_two_start
+
+ RET
%endif
diff --git a/vpx_dsp/x86/vpx_convolve_copy_sse2.asm b/vpx_dsp/x86/vpx_convolve_copy_sse2.asm
index 9c5b414..abc0270 100644
--- a/vpx_dsp/x86/vpx_convolve_copy_sse2.asm
+++ b/vpx_dsp/x86/vpx_convolve_copy_sse2.asm
@@ -13,15 +13,21 @@
SECTION .text
%macro convolve_fn 1-2
-INIT_XMM sse2
+%ifidn %1, avg
+%define AUX_XMM_REGS 4
+%else
+%define AUX_XMM_REGS 0
+%endif
%ifidn %2, highbd
%define pavg pavgw
-cglobal %2_convolve_%1, 4, 7, 4, src, src_stride, dst, dst_stride, \
- fx, fxs, fy, fys, w, h, bd
+cglobal %2_convolve_%1, 4, 7, 4+AUX_XMM_REGS, src, src_stride, \
+ dst, dst_stride, \
+ fx, fxs, fy, fys, w, h, bd
%else
%define pavg pavgb
-cglobal convolve_%1, 4, 7, 4, src, src_stride, dst, dst_stride, \
- fx, fxs, fy, fys, w, h
+cglobal convolve_%1, 4, 7, 4+AUX_XMM_REGS, src, src_stride, \
+ dst, dst_stride, \
+ fx, fxs, fy, fys, w, h
%endif
mov r4d, dword wm
%ifidn %2, highbd
@@ -152,38 +158,11 @@
jnz .loop16
RET
-INIT_MMX sse
.w8:
mov r4d, dword hm
lea r5q, [src_strideq*3]
lea r6q, [dst_strideq*3]
.loop8:
- movu m0, [srcq]
- movu m1, [srcq+src_strideq]
- movu m2, [srcq+src_strideq*2]
- movu m3, [srcq+r5q]
- lea srcq, [srcq+src_strideq*4]
-%ifidn %1, avg
- pavg m0, [dstq]
- pavg m1, [dstq+dst_strideq]
- pavg m2, [dstq+dst_strideq*2]
- pavg m3, [dstq+r6q]
-%endif
- mova [dstq ], m0
- mova [dstq+dst_strideq ], m1
- mova [dstq+dst_strideq*2], m2
- mova [dstq+r6q ], m3
- lea dstq, [dstq+dst_strideq*4]
- sub r4d, 4
- jnz .loop8
- RET
-
-%ifnidn %2, highbd
-.w4:
- mov r4d, dword hm
- lea r5q, [src_strideq*3]
- lea r6q, [dst_strideq*3]
-.loop4:
movh m0, [srcq]
movh m1, [srcq+src_strideq]
movh m2, [srcq+src_strideq*2]
@@ -205,11 +184,42 @@
movh [dstq+r6q ], m3
lea dstq, [dstq+dst_strideq*4]
sub r4d, 4
+ jnz .loop8
+ RET
+
+%ifnidn %2, highbd
+.w4:
+ mov r4d, dword hm
+ lea r5q, [src_strideq*3]
+ lea r6q, [dst_strideq*3]
+.loop4:
+ movd m0, [srcq]
+ movd m1, [srcq+src_strideq]
+ movd m2, [srcq+src_strideq*2]
+ movd m3, [srcq+r5q]
+ lea srcq, [srcq+src_strideq*4]
+%ifidn %1, avg
+ movd m4, [dstq]
+ movd m5, [dstq+dst_strideq]
+ movd m6, [dstq+dst_strideq*2]
+ movd m7, [dstq+r6q]
+ pavg m0, m4
+ pavg m1, m5
+ pavg m2, m6
+ pavg m3, m7
+%endif
+ movd [dstq ], m0
+ movd [dstq+dst_strideq ], m1
+ movd [dstq+dst_strideq*2], m2
+ movd [dstq+r6q ], m3
+ lea dstq, [dstq+dst_strideq*4]
+ sub r4d, 4
jnz .loop4
RET
%endif
%endmacro
+INIT_XMM sse2
convolve_fn copy
convolve_fn avg
%if CONFIG_VP9_HIGHBITDEPTH
diff --git a/vpx_ports/vpx_once.h b/vpx_ports/vpx_once.h
index f1df394..da04db4 100644
--- a/vpx_ports/vpx_once.h
+++ b/vpx_ports/vpx_once.h
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2011 The WebM project authors. All Rights Reserved.
+ * 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
@@ -13,63 +13,83 @@
#include "vpx_config.h"
+/* Implement a function wrapper to guarantee initialization
+ * thread-safety for library singletons.
+ *
+ * NOTE: These functions use static locks, and can only be
+ * used with one common argument per compilation unit. So
+ *
+ * file1.c:
+ * vpx_once(foo);
+ * ...
+ * vpx_once(foo);
+ *
+ * file2.c:
+ * vpx_once(bar);
+ *
+ * will ensure foo() and bar() are each called only once, but in
+ *
+ * file1.c:
+ * vpx_once(foo);
+ * vpx_once(bar):
+ *
+ * bar() will never be called because the lock is used up
+ * by the call to foo().
+ */
+
#if CONFIG_MULTITHREAD && defined(_WIN32)
#include <windows.h>
#include <stdlib.h>
+/* Declare a per-compilation-unit state variable to track the progress
+ * of calling func() only once. This must be at global scope because
+ * local initializers are not thread-safe in MSVC prior to Visual
+ * Studio 2015.
+ *
+ * As a static, once_state will be zero-initialized as program start.
+ */
+static LONG once_state;
static void once(void (*func)(void))
{
- static CRITICAL_SECTION *lock;
- static LONG waiters;
- static int done;
- void *lock_ptr = &lock;
-
- /* If the initialization is complete, return early. This isn't just an
- * optimization, it prevents races on the destruction of the global
- * lock.
+ /* Try to advance once_state from its initial value of 0 to 1.
+ * Only one thread can succeed in doing so.
*/
- if(done)
- return;
-
- InterlockedIncrement(&waiters);
-
- /* Get a lock. We create one and try to make it the one-true-lock,
- * throwing it away if we lost the race.
- */
-
- {
- /* Scope to protect access to new_lock */
- CRITICAL_SECTION *new_lock = malloc(sizeof(CRITICAL_SECTION));
- InitializeCriticalSection(new_lock);
- if (InterlockedCompareExchangePointer(lock_ptr, new_lock, NULL) != NULL)
- {
- DeleteCriticalSection(new_lock);
- free(new_lock);
- }
- }
-
- /* At this point, we have a lock that can be synchronized on. We don't
- * care which thread actually performed the allocation.
- */
-
- EnterCriticalSection(lock);
-
- if (!done)
- {
+ if (InterlockedCompareExchange(&once_state, 1, 0) == 0) {
+ /* We're the winning thread, having set once_state to 1.
+ * Call our function. */
func();
- done = 1;
+ /* Now advance once_state to 2, unblocking any other threads. */
+ InterlockedIncrement(&once_state);
+ return;
}
- LeaveCriticalSection(lock);
-
- /* Last one out should free resources. The destructed objects are
- * protected by checking if(done) above.
+ /* We weren't the winning thread, but we want to block on
+ * the state variable so we don't return before func()
+ * has finished executing elsewhere.
+ *
+ * Try to advance once_state from 2 to 2, which is only possible
+ * after the winning thead advances it from 1 to 2.
*/
- if(!InterlockedDecrement(&waiters))
- {
- DeleteCriticalSection(lock);
- free(lock);
- lock = NULL;
+ while (InterlockedCompareExchange(&once_state, 2, 2) != 2) {
+ /* State isn't yet 2. Try again.
+ *
+ * We are used for singleton initialization functions,
+ * which should complete quickly. Contention will likewise
+ * be rare, so it's worthwhile to use a simple but cpu-
+ * intensive busy-wait instead of successive backoff,
+ * waiting on a kernel object, or another heavier-weight scheme.
+ *
+ * We can at least yield our timeslice.
+ */
+ Sleep(0);
}
+
+ /* We've seen once_state advance to 2, so we know func()
+ * has been called. And we've left once_state as we found it,
+ * so other threads will have the same experience.
+ *
+ * It's safe to return now.
+ */
+ return;
}
