Merge branch 'master' into nextgenv2 Change-Id: I8811bfd8fc132b9f515707e795bb6308e4bf263b
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/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/vp10/encoder/encoder.h b/vp10/encoder/encoder.h index d63c123..e735a0b 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 d46bb63..cb32252 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 63b2a97..adcd547 100644 --- a/vp10/encoder/rdopt.c +++ b/vp10/encoder/rdopt.c
@@ -2489,7 +2489,7 @@ this_rate = this_rate_tokenonly + vp10_cost_bit(cpi->common.fc->ext_intra_probs[1], 1) + vp10_cost_bit(DR_EXT_INTRA_PROB, 0) + - cpi->intra_uv_mode_cost[mbmi->uv_mode] + + cpi->intra_uv_mode_cost[mbmi->mode][mbmi->uv_mode] + write_uniform_cost(FILTER_INTRA_MODES, mode); this_rd = RDCOST(x->rdmult, x->rddiv, this_rate, this_distortion); if (this_rd < *best_rd) { @@ -2533,7 +2533,7 @@ this_rate = this_rate_tokenonly + vp10_cost_bit(cpi->common.fc->ext_intra_probs[1], 1) + (DR_ONLY ? 0: vp10_cost_bit(DR_EXT_INTRA_PROB, 1)) + - cpi->intra_uv_mode_cost[mbmi->uv_mode] + + cpi->intra_uv_mode_cost[mbmi->mode][mbmi->uv_mode] + write_uniform_cost(EXT_INTRA_ANGLES, angle); this_rd = RDCOST(x->rdmult, x->rddiv, this_rate, this_distortion); if (this_rd < *best_rd) { @@ -2573,7 +2573,7 @@ this_rate = this_rate_tokenonly + vp10_cost_bit(cpi->common.fc->ext_intra_probs[1], 1) + (DR_ONLY ? 0: vp10_cost_bit(DR_EXT_INTRA_PROB, 1)) + - cpi->intra_uv_mode_cost[mbmi->uv_mode] + + cpi->intra_uv_mode_cost[mbmi->mode][mbmi->uv_mode] + write_uniform_cost(EXT_INTRA_ANGLES, angle); this_rd = RDCOST(x->rdmult, x->rddiv, this_rate, this_distortion); if (this_rd < *best_rd) { @@ -2635,7 +2635,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]; #if CONFIG_EXT_INTRA if (mode == DC_PRED) this_rate += vp10_cost_bit(cpi->common.fc->ext_intra_probs[1], 0); @@ -2683,7 +2684,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); }
diff --git a/vp9/common/vp9_rtcd_defs.pl b/vp9/common/vp9_rtcd_defs.pl index f41ee09..5bf71ef 100644 --- a/vp9/common/vp9_rtcd_defs.pl +++ b/vp9/common/vp9_rtcd_defs.pl
@@ -312,7 +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 avx/; +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/;
diff --git a/vp9/encoder/vp9_encoder.c b/vp9/encoder/vp9_encoder.c index eebd7c5..d86a7a7 100644 --- a/vp9/encoder/vp9_encoder.c +++ b/vp9/encoder/vp9_encoder.c
@@ -1570,30 +1570,7 @@ #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; @@ -1601,9 +1578,6 @@ } static void cal_nmvsadcosts(int *mvsadcost[2]) { - /********************************************************************* - * Warning: Read the comments above before modifying this function * - *********************************************************************/ int i = 1; mvsadcost[0][0] = 0; @@ -1765,10 +1739,6 @@ 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];
diff --git a/vp9/encoder/vp9_encoder.h b/vp9/encoder/vp9_encoder.h index 3f3f896..975d9f4 100644 --- a/vp9/encoder/vp9_encoder.h +++ b/vp9/encoder/vp9_encoder.h
@@ -470,7 +470,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_mcomp.c b/vp9/encoder/vp9_mcomp.c index 4071755..9744e43 100644 --- a/vp9/encoder/vp9_mcomp.c +++ b/vp9/encoder/vp9_mcomp.c
@@ -101,8 +101,11 @@ } void vp9_init_dsmotion_compensation(search_site_config *cfg, int stride) { - int len; - int ss_count = 0; + int len, ss_count = 1; + + cfg->ss_mv[0].col = 0; + cfg->ss_mv[0].row = 0; + cfg->ss_os[0] = 0; for (len = MAX_FIRST_STEP; len > 0; len /= 2) { // Generate offsets for 4 search sites per step. @@ -114,13 +117,16 @@ } } + 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; - int ss_count = 0; + int len, ss_count = 1; + + cfg->ss_mv[0].col = 0; + cfg->ss_mv[0].row = 0; + cfg->ss_os[0] = 0; for (len = MAX_FIRST_STEP; len > 0; len /= 2) { // Generate offsets for 8 search sites per step. @@ -135,8 +141,8 @@ } } + cfg->ss_count = ss_count; cfg->searches_per_step = 8; - cfg->total_steps = ss_count / cfg->searches_per_step; } /* @@ -1606,8 +1612,8 @@ const uint8_t *best_address; unsigned int bestsad = INT_MAX; - int best_site = -1; - int last_site = -1; + int best_site = 0; + int last_site = 0; int ref_row; int ref_col; @@ -1620,7 +1626,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->total_steps) - search_param; + const int tot_steps = (cfg->ss_count / cfg->searches_per_step) - 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); @@ -1638,7 +1644,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 = 0; + i = 1; for (step = 0; step < tot_steps; step++) { int all_in = 1, t;
diff --git a/vp9/encoder/vp9_mcomp.h b/vp9/encoder/vp9_mcomp.h index 1c101f2..e48259f 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]; // Motion vector - intptr_t ss_os[8 * MAX_MVSEARCH_STEPS]; // Offset + MV ss_mv[8 * MAX_MVSEARCH_STEPS + 1]; // Motion vector + intptr_t ss_os[8 * MAX_MVSEARCH_STEPS + 1]; // Offset + int ss_count; 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 7bad344..8ba7de7 100644 --- a/vp9/encoder/vp9_noise_estimate.c +++ b/vp9/encoder/vp9_noise_estimate.c
@@ -53,6 +53,7 @@ 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 >= 640 &&
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 3bd5106..d78137a 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); }
diff --git a/vp9/encoder/x86/vp9_diamond_search_sad_avx.c b/vp9/encoder/x86/vp9_diamond_search_sad_avx.c deleted file mode 100644 index f216437..0000000 --- a/vp9/encoder/x86/vp9_diamond_search_sad_avx.c +++ /dev/null
@@ -1,308 +0,0 @@ -/* - * Copyright (c) 2015 The WebM project authors. All Rights Reserved. - * - * Use of this source code is governed by a BSD-style license - * that can be found in the LICENSE file in the root of the source - * tree. An additional intellectual property rights grant can be found - * in the file PATENTS. All contributing project authors may - * be found in the AUTHORS file in the root of the source tree. - */ - -#include <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 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 = { .as_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 = { .as_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 = { .as_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 = { .as_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 = { .as_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 uint8_t * const what = x->plane[0].src.buf; - const int in_what_stride = x->e_mbd.plane[0].pre[0].stride; - 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 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_load_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 (could use _mm_maskload_ps here, instead of the - // extra 'and' but it's slower that way) - __m128i v_bo10_q = _mm_load_si128((const __m128i*)&ss_os[i+0]); - __m128i v_bo32_q = _mm_load_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_load_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; - __m128i 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/vp9cx.mk b/vp9/vp9cx.mk index 5918240..3f3bdef 100644 --- a/vp9/vp9cx.mk +++ b/vp9/vp9cx.mk
@@ -96,7 +96,6 @@ 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