media: VEA unittest: make sure allocated memory is 64byte aligned

media/gpu/video_encode_accelerator_unittest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <inttypes.h>
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <memory>
 #include <queue>
 #include <string>
 #include <utility>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
+#include "base/bits.h"
 #include "base/command_line.h"
 #include "base/files/file_util.h"
-#include "base/files/memory_mapped_file.h"
 #include "base/macros.h"
+#include "base/memory/aligned_memory.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/process/process_handle.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_checker.h"
 #include "base/time/time.h"
@@ skipping 110 matching lines @@
 bool g_fake_encoder = false;
 
 // Environment to store test stream data for all test cases.
 class VideoEncodeAcceleratorTestEnvironment;
 VideoEncodeAcceleratorTestEnvironment* g_env;
 
 // The number of frames to be encoded. This variable is set by the switch
 // "--num_frames_to_encode". Ignored if 0.
 int g_num_frames_to_encode = 0;
 
+// An aligned STL allocator.
+template <typename T, size_t ByteAlignment>
+class AlignedAllocator : public std::allocator<T> {
+ public:
+  typedef size_t size_type;
+  typedef T* pointer;
+
+  template <class T1>
+  struct rebind {
+    typedef AlignedAllocator<T1, ByteAlignment> other;
+  };
+
+  AlignedAllocator() {}
+  explicit AlignedAllocator(const AlignedAllocator&) {}
+  template <class T1>
+  explicit AlignedAllocator(const AlignedAllocator<T1, ByteAlignment>&) {}
+  ~AlignedAllocator() {}
+
+  pointer allocate(size_type n, const void* = 0) {
+    return static_cast<pointer>(base::AlignedAlloc(n, ByteAlignment));
+  }
+
+  void deallocate(pointer p, size_type n) {
+    base::AlignedFree(static_cast<void*>(p));
+  }
+
+  size_type max_size() const {
+    return std::numeric_limits<size_t>::max() / sizeof(T);
+  }
+};
+
 struct TestStream {
   TestStream()
       : num_frames(0),
         aligned_buffer_size(0),
         requested_bitrate(0),
         requested_framerate(0),
         requested_subsequent_bitrate(0),
         requested_subsequent_framerate(0) {}
   ~TestStream() {}
 
   gfx::Size visible_size;
   gfx::Size coded_size;
   unsigned int num_frames;
 
   // Original unaligned input file name provided as an argument to the test.
   // And the file must be an I420 (YUV planar) raw stream.
   std::string in_filename;
 
   // A vector used to prepare aligned input buffers of |in_filename|. This
   // makes sure starting address of YUV planes are 64 bytes-aligned.
-  std::vector<char> aligned_in_file_data;
+  std::vector<char, AlignedAllocator<char, 64>> aligned_in_file_data;
 
   // Byte size of a frame of |aligned_in_file_data|.
   size_t aligned_buffer_size;
 
   // Byte size for each aligned plane of a frame.
   std::vector<size_t> aligned_plane_size;
 
   std::string out_filename;
   media::VideoCodecProfile requested_profile;
   unsigned int requested_bitrate;
   unsigned int requested_framerate;
   unsigned int requested_subsequent_bitrate;
   unsigned int requested_subsequent_framerate;
 };
 
 inline static size_t Align64Bytes(size_t value) {
-  return (value + 63) & ~63;
+  return base::bits::Align(value, 64);
 }
 
 // Return the |percentile| from a sorted vector.
 static base::TimeDelta Percentile(
     const std::vector<base::TimeDelta>& sorted_values,
     unsigned int percentile) {
   size_t size = sorted_values.size();
   LOG_ASSERT(size > 0UL);
   LOG_ASSERT(percentile <= 100UL);
   // Use Nearest Rank method in http://en.wikipedia.org/wiki/Percentile.
@@ skipping 1587 matching lines @@
 
   media::g_env =
       reinterpret_cast<media::VideoEncodeAcceleratorTestEnvironment*>(
           testing::AddGlobalTestEnvironment(
               new media::VideoEncodeAcceleratorTestEnvironment(
                   std::move(test_stream_data), log_path, run_at_fps,
                   needs_encode_latency, verify_all_output)));
 
   return RUN_ALL_TESTS();
 }