Run all filters through convolve test

Updates the convolve test to verify that all filters match the
reference implementation. This verifies commit 30f866f, which
fixed some problems with the SSE3 version of the filters for
the vp9_sub_pel_filters_8s and vp9_sub_pel_filters_8lp banks
due to overflow and order of operations.

Change-Id: I6b5fe1a41bc20062e2e64633b1355ae58c9c592c

diff --git a/test/convolve_test.cc b/test/convolve_test.cc
index 83e0e3cce138377a13ca5bf65102ba181bc97ac6..88ae6846bf01eab7374dfb5bb08e58ef605d99cf 100644 (file)
--- a/test/convolve_test.cc
+++ b/test/convolve_test.cc
@@ -12,6 +12,7 @@
 extern "C" {
 #include "./vpx_config.h"
 #include "./vp9_rtcd.h"
+#include "vp9/common/vp9_filter.h"
 #include "vpx_mem/vpx_mem.h"
 #include "vpx_ports/mem.h"
 }
@@ -300,62 +301,58 @@ TEST_P(ConvolveTest, Copy2D) {
           << "(" << x << "," << y << ")";
 }
 
+const int16_t (*kTestFilterList[])[8] = {
+  vp9_bilinear_filters,
+  vp9_sub_pel_filters_6,
+  vp9_sub_pel_filters_8,
+  vp9_sub_pel_filters_8s,
+  vp9_sub_pel_filters_8lp
+};
+
 TEST_P(ConvolveTest, MatchesReferenceSubpixelFilter) {
   uint8_t* const in = input();
   uint8_t* const out = output();
   uint8_t ref[kOutputStride * kMaxDimension];
 
-  const int16_t filters[][8] = {
-    { 0,   0,   0, 128,   0,   0,   0,  0},
-    { 0,   1,  -5, 126,   8,  -3,   1,  0},
-    { -1,   3, -10, 122,  18,  -6,   2,  0},
-    { -1,   4, -13, 118,  27,  -9,   3, -1},
-    { -1,   4, -16, 112,  37, -11,   4, -1},
-    { -1,   5, -18, 105,  48, -14,   4, -1},
-    { -1,   5, -19,  97,  58, -16,   5, -1},
-    { -1,   6, -19,  88,  68, -18,   5, -1},
-    { -1,   6, -19,  78,  78, -19,   6, -1},
-    { -1,   5, -18,  68,  88, -19,   6, -1},
-    { -1,   5, -16,  58,  97, -19,   5, -1},
-    { -1,   4, -14,  48, 105, -18,   5, -1},
-    { -1,   4, -11,  37, 112, -16,   4, -1},
-    { -1,   3,  -9,  27, 118, -13,   4, -1},
-    { 0,   2,  -6,  18, 122, -10,   3, -1},
-    { 0,   1,  -3,   8, 126,  -5,   1,  0}
-  };
-
-  const int kNumFilters = sizeof(filters) / sizeof(filters[0]);
-
-  for (int filter_x = 0; filter_x < kNumFilters; ++filter_x) {
-    for (int filter_y = 0; filter_y < kNumFilters; ++filter_y) {
-      filter_block2d_8_c(in, kInputStride,
-                         filters[filter_x], filters[filter_y],
-                         ref, kOutputStride,
-                         Width(), Height());
-
-      if (filter_x && filter_y)
-        REGISTER_STATE_CHECK(
-            UUT_->hv8_(in, kInputStride, out, kOutputStride,
-                       filters[filter_x], 16, filters[filter_y], 16,
-                       Width(), Height()));
-      else if (filter_y)
-        REGISTER_STATE_CHECK(
-            UUT_->v8_(in, kInputStride, out, kOutputStride,
-                      filters[filter_x], 16, filters[filter_y], 16,
-                      Width(), Height()));
-      else
-        REGISTER_STATE_CHECK(
-            UUT_->h8_(in, kInputStride, out, kOutputStride,
-                      filters[filter_x], 16, filters[filter_y], 16,
-                      Width(), Height()));
-
-      CheckGuardBlocks();
-
-      for (int y = 0; y < Height(); ++y)
-        for (int x = 0; x < Width(); ++x)
-          ASSERT_EQ(ref[y * kOutputStride + x], out[y * kOutputStride + x])
-              << "mismatch at (" << x << "," << y << "), "
-              << "filters (" << filter_x << "," << filter_y << ")";
+  const int kNumFilterBanks = sizeof(kTestFilterList) /
+      sizeof(kTestFilterList[0]);
+
+  for (int filter_bank = 0; filter_bank < kNumFilterBanks; ++filter_bank) {
+    const int16_t (*filters)[8] = kTestFilterList[filter_bank];
+    const int kNumFilters = 16;
+
+    for (int filter_x = 0; filter_x < kNumFilters; ++filter_x) {
+      for (int filter_y = 0; filter_y < kNumFilters; ++filter_y) {
+        filter_block2d_8_c(in, kInputStride,
+                           filters[filter_x], filters[filter_y],
+                           ref, kOutputStride,
+                           Width(), Height());
+
+        if (filters == vp9_sub_pel_filters_8lp || (filter_x && filter_y))
+          REGISTER_STATE_CHECK(
+              UUT_->hv8_(in, kInputStride, out, kOutputStride,
+                         filters[filter_x], 16, filters[filter_y], 16,
+                         Width(), Height()));
+        else if (filter_y)
+          REGISTER_STATE_CHECK(
+              UUT_->v8_(in, kInputStride, out, kOutputStride,
+                        filters[filter_x], 16, filters[filter_y], 16,
+                        Width(), Height()));
+        else
+          REGISTER_STATE_CHECK(
+              UUT_->h8_(in, kInputStride, out, kOutputStride,
+                        filters[filter_x], 16, filters[filter_y], 16,
+                        Width(), Height()));
+
+        CheckGuardBlocks();
+
+        for (int y = 0; y < Height(); ++y)
+          for (int x = 0; x < Width(); ++x)
+            ASSERT_EQ(ref[y * kOutputStride + x], out[y * kOutputStride + x])
+                << "mismatch at (" << x << "," << y << "), "
+                << "filters (" << filter_bank << ","
+                << filter_x << "," << filter_y << ")";
+      }
     }
   }
 }
@@ -376,57 +373,45 @@ TEST_P(ConvolveTest, MatchesReferenceAveragingSubpixelFilter) {
     }
   }
 
-  const int16_t filters[][8] = {
-    { 0,   0,   0, 128,   0,   0,   0,  0},
-    { 0,   1,  -5, 126,   8,  -3,   1,  0},
-    { -1,   3, -10, 122,  18,  -6,   2,  0},
-    { -1,   4, -13, 118,  27,  -9,   3, -1},
-    { -1,   4, -16, 112,  37, -11,   4, -1},
-    { -1,   5, -18, 105,  48, -14,   4, -1},
-    { -1,   5, -19,  97,  58, -16,   5, -1},
-    { -1,   6, -19,  88,  68, -18,   5, -1},
-    { -1,   6, -19,  78,  78, -19,   6, -1},
-    { -1,   5, -18,  68,  88, -19,   6, -1},
-    { -1,   5, -16,  58,  97, -19,   5, -1},
-    { -1,   4, -14,  48, 105, -18,   5, -1},
-    { -1,   4, -11,  37, 112, -16,   4, -1},
-    { -1,   3,  -9,  27, 118, -13,   4, -1},
-    { 0,   2,  -6,  18, 122, -10,   3, -1},
-    { 0,   1,  -3,   8, 126,  -5,   1,  0}
-  };
-
-  const int kNumFilters = sizeof(filters) / sizeof(filters[0]);
-
-  for (int filter_x = 0; filter_x < kNumFilters; ++filter_x) {
-    for (int filter_y = 0; filter_y < kNumFilters; ++filter_y) {
-      filter_average_block2d_8_c(in, kInputStride,
-                                 filters[filter_x], filters[filter_y],
-                                 ref, kOutputStride,
-                                 Width(), Height());
-
-      if (filter_x && filter_y)
-        REGISTER_STATE_CHECK(
-            UUT_->hv8_avg_(in, kInputStride, out, kOutputStride,
-                           filters[filter_x], 16, filters[filter_y], 16,
-                           Width(), Height()));
-      else if (filter_y)
-        REGISTER_STATE_CHECK(
-            UUT_->v8_avg_(in, kInputStride, out, kOutputStride,
-                          filters[filter_x], 16, filters[filter_y], 16,
-                          Width(), Height()));
-      else
-        REGISTER_STATE_CHECK(
-            UUT_->h8_avg_(in, kInputStride, out, kOutputStride,
-                          filters[filter_x], 16, filters[filter_y], 16,
-                          Width(), Height()));
-
-      CheckGuardBlocks();
-
-      for (int y = 0; y < Height(); ++y)
-        for (int x = 0; x < Width(); ++x)
-          ASSERT_EQ(ref[y * kOutputStride + x], out[y * kOutputStride + x])
-              << "mismatch at (" << x << "," << y << "), "
-              << "filters (" << filter_x << "," << filter_y << ")";
+  const int kNumFilterBanks = sizeof(kTestFilterList) /
+      sizeof(kTestFilterList[0]);
+
+  for (int filter_bank = 0; filter_bank < kNumFilterBanks; ++filter_bank) {
+    const int16_t (*filters)[8] = kTestFilterList[filter_bank];
+    const int kNumFilters = 16;
+
+    for (int filter_x = 0; filter_x < kNumFilters; ++filter_x) {
+      for (int filter_y = 0; filter_y < kNumFilters; ++filter_y) {
+        filter_average_block2d_8_c(in, kInputStride,
+                                   filters[filter_x], filters[filter_y],
+                                   ref, kOutputStride,
+                                   Width(), Height());
+
+        if (filters == vp9_sub_pel_filters_8lp || (filter_x && filter_y))
+          REGISTER_STATE_CHECK(
+              UUT_->hv8_avg_(in, kInputStride, out, kOutputStride,
+                             filters[filter_x], 16, filters[filter_y], 16,
+                             Width(), Height()));
+        else if (filter_y)
+          REGISTER_STATE_CHECK(
+              UUT_->v8_avg_(in, kInputStride, out, kOutputStride,
+                            filters[filter_x], 16, filters[filter_y], 16,
+                            Width(), Height()));
+        else
+          REGISTER_STATE_CHECK(
+              UUT_->h8_avg_(in, kInputStride, out, kOutputStride,
+                            filters[filter_x], 16, filters[filter_y], 16,
+                            Width(), Height()));
+
+        CheckGuardBlocks();
+
+        for (int y = 0; y < Height(); ++y)
+          for (int x = 0; x < Width(); ++x)
+            ASSERT_EQ(ref[y * kOutputStride + x], out[y * kOutputStride + x])
+                << "mismatch at (" << x << "," << y << "), "
+                << "filters (" << filter_bank << ","
+                << filter_x << "," << filter_y << ")";
+      }
     }
   }
 }