Fix memory alignment of VEA

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/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/single_thread_task_runner.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"
@@ skipping 127 matching lines @@
   ~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;
+  // An aligned memory used to prepare aligned input buffers of |in_filename|.
+  // This makes sure starting address of YUV planes are 64 bytes-aligned.
+  char* 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;
@@ skipping 32 matching lines @@
 // Otherwise newer kernels will refuse to accept them, and on older kernels
 // we'll be treating ourselves to random corruption.
 // 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.
 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())
+      test_stream->aligned_in_file_data)
     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() ||
+  ASSERT_TRUE(!test_stream->aligned_in_file_data ||
               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
@@ skipping 24 matching lines @@
   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 = 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);
+  test_stream->aligned_in_file_data = reinterpret_cast<char*>(
+      base::AlignedAlloc(
+          test_stream->aligned_buffer_size * test_stream->num_frames, 64));
 
   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], 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";
       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 += coded_bpl[i];
       }
       dest_offset += padding_sizes[i];
     }
     src_offset += visible_buffer_size;
   }
   src.Close();
 
   // 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)
+  ASSERT_EQ(reinterpret_cast<off_t>(test_stream->aligned_in_file_data) & 63, 0)
       << "File should be mapped at a 64 byte boundary";
 
   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.
@@ skipping 18 matching lines @@
     result = base::StringToInt(fields[2], &height);
     LOG_ASSERT(result);
     test_stream->visible_size = gfx::Size(width, height);
     LOG_ASSERT(!test_stream->visible_size.IsEmpty());
     int profile;
     result = base::StringToInt(fields[3], &profile);
     LOG_ASSERT(result);
     LOG_ASSERT(profile > VIDEO_CODEC_PROFILE_UNKNOWN);
     LOG_ASSERT(profile <= VIDEO_CODEC_PROFILE_MAX);
     test_stream->requested_profile = static_cast<VideoCodecProfile>(profile);
+    test_stream->aligned_in_file_data = NULL;
 
     if (fields.size() >= 5 && !fields[4].empty())
       test_stream->out_filename = fields[4];
 
     if (fields.size() >= 6 && !fields[5].empty())
       LOG_ASSERT(
           base::StringToUint(fields[5], &test_stream->requested_bitrate));
 
     if (fields.size() >= 7 && !fields[6].empty())
       LOG_ASSERT(
@@ skipping 35 matching lines @@
   virtual void SetUp() {
     if (!log_path_.empty()) {
       log_file_.reset(new base::File(
           log_path_, base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE));
       LOG_ASSERT(log_file_->IsValid());
     }
     ParseAndReadTestStreamData(*test_stream_data_, &test_streams_);
   }
 
   virtual void TearDown() {
+    for (size_t i = 0; i < test_streams_.size(); i++) {
+      base::AlignedFree(test_streams_[i]->aligned_in_file_data);
+    }
     log_file_.reset();
   }
 
   // Log one entry of machine-readable data to file and LOG(INFO).
   // The log has one data entry per line in the format of "<key>: <value>".
   // Note that Chrome OS video_VEAPerf autotest parses the output key and value
   // pairs. Be sure to keep the autotest in sync.
   void LogToFile(const std::string& key, const std::string& value) {
     std::string s = base::StringPrintf("%s: %s\n", key.c_str(), value.c_str());
     LOG(INFO) << s;
@@ skipping 884 matching lines @@
 void VEAClient::InputNoLongerNeededCallback(int32_t input_id) {
   std::set<int32_t>::iterator it = inputs_at_client_.find(input_id);
   ASSERT_NE(it, inputs_at_client_.end());
   inputs_at_client_.erase(it);
   if (!g_env->run_at_fps())
     FeedEncoderWithOneInput();
 }
 
 scoped_refptr<VideoFrame> VEAClient::CreateFrame(off_t position) {
   uint8_t* frame_data_y =
-      reinterpret_cast<uint8_t*>(&test_stream_->aligned_in_file_data[0]) +
+      reinterpret_cast<uint8_t*>(test_stream_->aligned_in_file_data) +
       position;
   uint8_t* frame_data_u = frame_data_y + test_stream_->aligned_plane_size[0];
   uint8_t* frame_data_v = frame_data_u + test_stream_->aligned_plane_size[1];
   CHECK_GT(current_framerate_, 0U);
 
   scoped_refptr<VideoFrame> video_frame = VideoFrame::WrapExternalYuvData(
       kInputFormat, input_coded_size_, gfx::Rect(test_stream_->visible_size),
       test_stream_->visible_size, input_coded_size_.width(),
       input_coded_size_.width() / 2, input_coded_size_.width() / 2,
       frame_data_y, frame_data_u, frame_data_v,
       base::TimeDelta().FromMilliseconds(next_input_id_ *
                                          base::Time::kMillisecondsPerSecond /
                                          current_framerate_));
   EXPECT_NE(nullptr, video_frame.get());
   return video_frame;
 }
 
 scoped_refptr<VideoFrame> VEAClient::PrepareInputFrame(off_t position,
                                                        int32_t* input_id) {
   CHECK_LE(position + test_stream_->aligned_buffer_size,
-           test_stream_->aligned_in_file_data.size());
+           test_stream_->aligned_buffer_size * test_stream_->num_frames);
 
   scoped_refptr<VideoFrame> frame = CreateFrame(position);
   EXPECT_TRUE(frame);
   frame->AddDestructionObserver(
       BindToCurrentLoop(base::Bind(&VEAClient::InputNoLongerNeededCallback,
                                    base::Unretained(this), next_input_id_)));
 
   LOG_ASSERT(inputs_at_client_.insert(next_input_id_).second);
 
   *input_id = next_input_id_++;
   return frame;
 }
 
 void VEAClient::OnInputTimer() {
   if (!has_encoder() || state_ != CS_ENCODING)
     input_timer_.reset();
   else if (inputs_at_client_.size() <
            num_required_input_buffers_ + kNumExtraInputFrames)
     FeedEncoderWithOneInput();
   else
     DVLOG(1) << "Dropping input frame";
 }
 
 void VEAClient::FeedEncoderWithOneInput() {
   if (!has_encoder() || state_ != CS_ENCODING)
     return;
 
   size_t bytes_left =
-      test_stream_->aligned_in_file_data.size() - pos_in_input_stream_;
+      test_stream_->aligned_buffer_size * test_stream_->num_frames -
+      pos_in_input_stream_;
   if (bytes_left < test_stream_->aligned_buffer_size) {
     DCHECK_EQ(bytes_left, 0UL);
     // Rewind if at the end of stream and we are still encoding.
     // This is to flush the encoder with additional frames from the beginning
     // of the stream, or if the stream is shorter that the number of frames
     // we require for bitrate tests.
     pos_in_input_stream_ = 0;
   }
 
   if (quality_validator_)
@@ skipping 417 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();
 }