remove row.h from unittests

unit_test/color_test.cc

 /*
  *  Copyright 2015 The LibYuv 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 <stdlib.h>
 
+#include "libyuv/basic_types.h"
 #include "libyuv/convert.h"
 #include "libyuv/convert_argb.h"
 #include "libyuv/convert_from.h"
 #include "libyuv/convert_from_argb.h"
 #include "libyuv/cpu_id.h"
-#include "libyuv/row.h"  // For Sobel
 #include "../unit_test/unit_test.h"
 
 namespace libyuv {
 
 // TODO(fbarchard): Port high accuracy YUV to RGB to Neon.
 #if !defined(LIBYUV_DISABLE_NEON) && \
     (defined(__aarch64__) || defined(__ARM_NEON__) || defined(LIBYUV_NEON))
 #define ERROR_R 1
 #define ERROR_G 1
 #define ERROR_B 3
 #define ERROR_FULL 6
 #define ERROR_J420 5
 #else
 #define ERROR_R 1
 #define ERROR_G 1
 #define ERROR_B 3
 #define ERROR_FULL 5
 #define ERROR_J420 3
 #endif
 
 #define TESTCS(TESTNAME, YUVTOARGB, ARGBTOYUV, HS1, HS, HN, DIFF)              \
   TEST_F(LibYUVColorTest, TESTNAME) {                                          \
   const int kPixels = benchmark_width_ * benchmark_height_;                    \
   const int kHalfPixels = ((benchmark_width_ + 1) / 2) *                       \
       ((benchmark_height_ + HS1) / HS);                                        \
-  align_buffer_64(orig_y, kPixels);                                            \
-  align_buffer_64(orig_u, kHalfPixels);                                        \
-  align_buffer_64(orig_v, kHalfPixels);                                        \
-  align_buffer_64(orig_pixels, kPixels * 4);                                   \
-  align_buffer_64(temp_y, kPixels);                                            \
-  align_buffer_64(temp_u, kHalfPixels);                                        \
-  align_buffer_64(temp_v, kHalfPixels);                                        \
-  align_buffer_64(dst_pixels_opt, kPixels * 4);                                \
-  align_buffer_64(dst_pixels_c, kPixels * 4);                                  \
+  align_buffer_page_end(orig_y, kPixels);                                      \
+  align_buffer_page_end(orig_u, kHalfPixels);                                  \
+  align_buffer_page_end(orig_v, kHalfPixels);                                  \
+  align_buffer_page_end(orig_pixels, kPixels * 4);                             \
+  align_buffer_page_end(temp_y, kPixels);                                      \
+  align_buffer_page_end(temp_u, kHalfPixels);                                  \
+  align_buffer_page_end(temp_v, kHalfPixels);                                  \
+  align_buffer_page_end(dst_pixels_opt, kPixels * 4);                          \
+  align_buffer_page_end(dst_pixels_c, kPixels * 4);                            \
                                                                                \
   MemRandomize(orig_pixels, kPixels * 4);                                      \
   MemRandomize(orig_y, kPixels);                                               \
   MemRandomize(orig_u, kHalfPixels);                                           \
   MemRandomize(orig_v, kHalfPixels);                                           \
   MemRandomize(temp_y, kPixels);                                               \
   MemRandomize(temp_u, kHalfPixels);                                           \
   MemRandomize(temp_v, kHalfPixels);                                           \
   MemRandomize(dst_pixels_opt, kPixels * 4);                                   \
   MemRandomize(dst_pixels_c, kPixels * 4);                                     \
@@ skipping 62 matching lines @@
   /* Test C and SIMD match. */                                                 \
   for (int i = 0; i < kPixels * 4; ++i) {                                      \
     EXPECT_EQ(dst_pixels_c[i], dst_pixels_opt[i]);                             \
   }                                                                            \
   /* Test SIMD is close to original. */                                        \
   for (int i = 0; i < kPixels * 4; ++i) {                                      \
     EXPECT_NEAR(static_cast<int>(orig_pixels[i]),                              \
                 static_cast<int>(dst_pixels_opt[i]), DIFF);                    \
   }                                                                            \
                                                                                \
-  free_aligned_buffer_64(orig_pixels);                                         \
-  free_aligned_buffer_64(orig_y);                                              \
-  free_aligned_buffer_64(orig_u);                                              \
-  free_aligned_buffer_64(orig_v);                                              \
-  free_aligned_buffer_64(temp_y);                                              \
-  free_aligned_buffer_64(temp_u);                                              \
-  free_aligned_buffer_64(temp_v);                                              \
-  free_aligned_buffer_64(dst_pixels_opt);                                      \
-  free_aligned_buffer_64(dst_pixels_c);                                        \
+  free_aligned_buffer_page_end(orig_pixels);                                   \
+  free_aligned_buffer_page_end(orig_y);                                        \
+  free_aligned_buffer_page_end(orig_u);                                        \
+  free_aligned_buffer_page_end(orig_v);                                        \
+  free_aligned_buffer_page_end(temp_y);                                        \
+  free_aligned_buffer_page_end(temp_u);                                        \
+  free_aligned_buffer_page_end(temp_v);                                        \
+  free_aligned_buffer_page_end(dst_pixels_opt);                                \
+  free_aligned_buffer_page_end(dst_pixels_c);                                  \
 }                                                                              \
 
 TESTCS(TestI420, I420ToARGB, ARGBToI420, 1, 2, benchmark_width_, ERROR_FULL)
 TESTCS(TestI422, I422ToARGB, ARGBToI422, 0, 1, 0, ERROR_FULL)
 TESTCS(TestJ420, J420ToARGB, ARGBToJ420, 1, 2, benchmark_width_, ERROR_J420)
 TESTCS(TestJ422, J422ToARGB, ARGBToJ422, 0, 1, 0, 3)
 
 static void YUVToRGB(int y, int u, int v, int* r, int* g, int* b) {
   const int kWidth = 16;
   const int kHeight = 1;
@@ skipping 407 matching lines @@
     EXPECT_EQ(r0, r1);
     EXPECT_EQ(g0, g1);
     EXPECT_EQ(b0, b1);
     EXPECT_EQ(r0, r2);
     EXPECT_EQ(g0, g2);
     EXPECT_EQ(b0, b2);
   }
 }
 
 }  // namespace libyuv