VEA unittest: align input buffers to 128-byte boundary on ARM only.

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>
@@ skipping 138 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;
 
+#ifdef ARCH_CPU_ARMEL
+// ARM performs CPU cache management with CPU cache line granularity. We thus
+// need to ensure our buffers are CPU cache line-aligned (64 byte-aligned).
+// Otherwise newer kernels will refuse to accept them, and on older kernels
+// we'll be treating ourselves to random corruption.
+// Moreover, some hardware codecs require 128-byte alignment for physical
+// buffers.
+const size_t kPlatformBufferAlignment = 128;
+#else
+const size_t kPlatformBufferAlignment = 1;
+#endif
+
+inline static size_t AlignToPlatformRequirements(size_t value) {
+  return base::bits::Align(value, kPlatformBufferAlignment);
+}
+
 // 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;
@@ skipping 30 matching lines @@
 
   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, AlignedAllocator<char, 64>> aligned_in_file_data;
+  // makes sure starting addresses of YUV planes are aligned to
+  // kPlatformBufferAlignment bytes.
+  std::vector<char, AlignedAllocator<char, kPlatformBufferAlignment>>
+      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;
   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 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.
   int index =
       std::max(static_cast<int>(ceil(0.01f * percentile * size)) - 1, 0);
@@ skipping 20 matching lines @@
 
 static std::string FilePathStringTypeToString(
     const base::FilePath::StringType& str) {
 #if defined(OS_WIN)
   return base::WideToUTF8(str);
 #else
   return str;
 #endif  // defined(OS_WIN)
 }
 
-// ARM performs CPU cache management with CPU cache line granularity. We thus
-// need to ensure our buffers are CPU cache line-aligned (64 byte-aligned).
-// Otherwise newer kernels will refuse to accept them, and on older kernels
-// we'll be treating ourselves to random corruption.
+// Some platforms may have requirements on physical memory buffer alignment.
 // Since we are just mapping and passing chunks of the input file directly to
-// the VEA as input frames to avoid copying large chunks of raw data on each
-// frame and thus affecting performance measurements, we have to prepare a
-// temporary file with all planes aligned to 64-byte boundaries beforehand.
+// the VEA as input frames, to avoid copying large chunks of raw data on each
+// frame, and thus affecting performance measurements, we have to prepare a
+// temporary file with all planes aligned to the required alignment beforehand.
 static void CreateAlignedInputStreamFile(const gfx::Size& coded_size,
                                          TestStream* test_stream) {
   // Test case may have many encoders and memory should be prepared once.
   if (test_stream->coded_size == coded_size &&
       !test_stream->aligned_in_file_data.empty())
     return;
 
   // All encoders in multiple encoder test reuse the same test_stream, make
   // sure they requested the same coded_size
   ASSERT_TRUE(test_stream->aligned_in_file_data.empty() ||
               coded_size == test_stream->coded_size);
   test_stream->coded_size = coded_size;
 
   size_t num_planes = VideoFrame::NumPlanes(kInputFormat);
   std::vector<size_t> padding_sizes(num_planes);
   std::vector<size_t> coded_bpl(num_planes);
   std::vector<size_t> visible_bpl(num_planes);
   std::vector<size_t> visible_plane_rows(num_planes);
 
   // Calculate padding in bytes to be added after each plane required to keep
-  // starting addresses of all planes at a 64 byte boudnary. This padding will
-  // be added after each plane when copying to the temporary file.
+  // starting addresses of all planes at a byte boundary required by the
+  // platform. This padding will be added after each plane when copying to the
+  // temporary file.
   // At the same time we also need to take into account coded_size requested by
   // the VEA; each row of visible_bpl bytes in the original file needs to be
   // copied into a row of coded_bpl bytes in the aligned file.
   for (size_t i = 0; i < num_planes; i++) {
     const size_t size =
         VideoFrame::PlaneSize(kInputFormat, i, coded_size).GetArea();
-    test_stream->aligned_plane_size.push_back(Align64Bytes(size));
+    test_stream->aligned_plane_size.push_back(
+        AlignToPlatformRequirements(size));
     test_stream->aligned_buffer_size += test_stream->aligned_plane_size.back();
 
     coded_bpl[i] = VideoFrame::RowBytes(i, kInputFormat, coded_size.width());
     visible_bpl[i] = VideoFrame::RowBytes(i, kInputFormat,
                                           test_stream->visible_size.width());
     visible_plane_rows[i] =
         VideoFrame::Rows(i, kInputFormat, test_stream->visible_size.height());
     const size_t padding_rows =
         VideoFrame::Rows(i, kInputFormat, coded_size.height()) -
         visible_plane_rows[i];
-    padding_sizes[i] = padding_rows * coded_bpl[i] + Align64Bytes(size) - size;
+    padding_sizes[i] =
+        padding_rows * coded_bpl[i] + AlignToPlatformRequirements(size) - size;
   }
 
   base::FilePath src_file(StringToFilePathStringType(test_stream->in_filename));
   int64_t src_file_size = 0;
   LOG_ASSERT(base::GetFileSize(src_file, &src_file_size));
 
   size_t visible_buffer_size =
       VideoFrame::AllocationSize(kInputFormat, test_stream->visible_size);
   LOG_ASSERT(src_file_size % visible_buffer_size == 0U)
       << "Stream byte size is not a product of calculated frame byte size";
 
   test_stream->num_frames =
       static_cast<unsigned int>(src_file_size / visible_buffer_size);
 
   LOG_ASSERT(test_stream->aligned_buffer_size > 0UL);
   test_stream->aligned_in_file_data.resize(test_stream->aligned_buffer_size *
                                            test_stream->num_frames);
 
   base::File src(src_file, base::File::FLAG_OPEN | base::File::FLAG_READ);
   std::vector<char> src_data(visible_buffer_size);
   off_t src_offset = 0, dest_offset = 0;
   for (size_t frame = 0; frame < test_stream->num_frames; frame++) {
     LOG_ASSERT(src.Read(src_offset, &src_data[0],
                         static_cast<int>(visible_buffer_size)) ==
                static_cast<int>(visible_buffer_size));
     const char* src_ptr = &src_data[0];
     for (size_t i = 0; i < num_planes; i++) {
-      // Assert that each plane of frame starts at 64 byte boundary.
-      ASSERT_EQ(dest_offset & 63, 0)
-          << "Planes of frame should be mapped at a 64 byte boundary";
+      // Assert that each plane of frame starts at required byte boundary.
+      ASSERT_EQ(dest_offset & (kPlatformBufferAlignment - 1), 0u)
+          << "Planes of frame should be mapped per platform requirements";
       for (size_t j = 0; j < visible_plane_rows[i]; j++) {
         memcpy(&test_stream->aligned_in_file_data[dest_offset], src_ptr,
                visible_bpl[i]);
         src_ptr += visible_bpl[i];
         dest_offset += static_cast<off_t>(coded_bpl[i]);
       }
       dest_offset += static_cast<off_t>(padding_sizes[i]);
     }
     src_offset += static_cast<off_t>(visible_buffer_size);
   }
   src.Close();
 
-#if defined(OS_POSIX)
-  // Assert that memory mapped of file starts at 64 byte boundary. So each
-  // plane of frames also start at 64 byte boundary.
-  ASSERT_EQ(reinterpret_cast<off_t>(&test_stream->aligned_in_file_data[0]) & 63,
-            0)
-      << "File should be mapped at a 64 byte boundary";
-#endif  // defined(OS_POSIX)
-
   LOG_ASSERT(test_stream->num_frames > 0UL);
 }
 
 // Parse |data| into its constituent parts, set the various output fields
 // accordingly, read in video stream, and store them to |test_streams|.
 static void ParseAndReadTestStreamData(const base::FilePath::StringType& data,
                                        ScopedVector<TestStream>* test_streams) {
   // Split the string to individual test stream data.
   std::vector<base::FilePath::StringType> test_streams_data =
       base::SplitString(data, base::FilePath::StringType(1, ';'),
@@ skipping 1556 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();
 }