remove row.h from unittests

unit_test/scale_argb_test.cc

 /*
  *  Copyright 2011 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 <time.h>
 
 #include "libyuv/convert_argb.h"
 #include "libyuv/cpu_id.h"
-#include "libyuv/row.h"   // For align_buffer_64
 #include "libyuv/scale_argb.h"
 #include "libyuv/video_common.h"
 #include "../unit_test/unit_test.h"
 
 namespace libyuv {
 
 #define STRINGIZE(line) #line
 #define FILELINESTR(file, line) file ":" STRINGIZE(line)
 
 // Test scaling with C vs Opt and return maximum pixel difference. 0 = exact.
@@ skipping 122 matching lines @@
                               FilterMode f, int benchmark_iterations) {
   if (!SizeValid(src_width, src_height, dst_width, dst_height)) {
     return 0;
   }
 
   const int b = 128;
   int64 src_argb_plane_size = (Abs(src_width) + b * 2) *
       (Abs(src_height) + b * 2) * 4;
   int src_stride_argb = (b * 2 + Abs(src_width)) * 4;
 
-  align_buffer_64(src_argb, src_argb_plane_size);
+  align_buffer_page_end(src_argb, src_argb_plane_size);
   if (!src_argb) {
     printf("Skipped.  Alloc failed " FILELINESTR(__FILE__, __LINE__) "\n");
     return 0;
   }
   memset(src_argb, 1, src_argb_plane_size);
 
   int64 dst_argb_plane_size = (dst_width + b * 2) * (dst_height + b * 2) * 4;
   int dst_stride_argb = (b * 2 + dst_width) * 4;
 
   int i, j;
   for (i = b; i < (Abs(src_height) + b); ++i) {
     for (j = b; j < (Abs(src_width) + b) * 4; ++j) {
       src_argb[(i * src_stride_argb) + j] = (fastrand() & 0xff);
     }
   }
 
-  align_buffer_64(dst_argb_c, dst_argb_plane_size);
-  align_buffer_64(dst_argb_opt, dst_argb_plane_size);
+  align_buffer_page_end(dst_argb_c, dst_argb_plane_size);
+  align_buffer_page_end(dst_argb_opt, dst_argb_plane_size);
   if (!dst_argb_c || !dst_argb_opt) {
     printf("Skipped.  Alloc failed " FILELINESTR(__FILE__, __LINE__) "\n");
     return 0;
   }
   memset(dst_argb_c, 2, dst_argb_plane_size);
   memset(dst_argb_opt, 3, dst_argb_plane_size);
 
   // Do full image, no clipping.
   double c_time = get_time();
   ARGBScale(src_argb + (src_stride_argb * b) + b * 4, src_stride_argb,
@@ skipping 21 matching lines @@
   for (i = b; i < (dst_height + b); ++i) {
     for (j = b * 4; j < (dst_width + b) * 4; ++j) {
       int abs_diff = Abs(dst_argb_c[(i * dst_stride_argb) + j] -
                          dst_argb_opt[(i * dst_stride_argb) + j]);
       if (abs_diff > max_diff) {
         max_diff = abs_diff;
       }
     }
   }
 
-  free_aligned_buffer_64(dst_argb_c);
-  free_aligned_buffer_64(dst_argb_opt);
-  free_aligned_buffer_64(src_argb);
+  free_aligned_buffer_page_end(dst_argb_c);
+  free_aligned_buffer_page_end(dst_argb_opt);
+  free_aligned_buffer_page_end(src_argb);
   return max_diff;
 }
 
 // The following adjustments in dimensions ensure the scale factor will be
 // exactly achieved.
 #define DX(x, nom, denom) static_cast<int>((Abs(x) / nom) * nom)
 #define SX(x, nom, denom) static_cast<int>((x / nom) * denom)
 
 #define TEST_FACTOR1(name, filter, nom, denom, max_diff)                       \
     TEST_F(LibYUVScaleTest, ARGBScaleDownBy##name##_##filter) {                \
@@ skipping 83 matching lines @@
                              const uint8* src_u, int src_stride_u,
                              const uint8* src_v, int src_stride_v,
                              uint32 src_fourcc,
                              int src_width, int src_height,
                              uint8* dst_argb, int dst_stride_argb,
                              uint32 dst_fourcc,
                              int dst_width, int dst_height,
                              int clip_x, int clip_y,
                              int clip_width, int clip_height,
                              enum FilterMode filtering) {
-
-  uint8* argb_buffer = (uint8*)malloc(src_width * src_height * 4);
+  uint8* argb_buffer = static_cast<uint8*>(malloc(src_width * src_height * 4));
   int r;
   I420ToARGB(src_y, src_stride_y,
              src_u, src_stride_u,
              src_v, src_stride_v,
              argb_buffer, src_width * 4,
              src_width, src_height);
 
   r = ARGBScaleClip(argb_buffer, src_width * 4,
                     src_width, src_height,
                     dst_argb, dst_stride_argb,
@@ skipping 118 matching lines @@
                                  benchmark_height_ * 3 / 2,
                                  benchmark_width_, benchmark_height_,
                                  libyuv::kFilterBilinear,
                                  benchmark_iterations_,
                                  disable_cpu_flags_, benchmark_cpu_info_);
   EXPECT_LE(diff, 10);
 }
 
 
 }  // namespace libyuv