Make VEA test support videos with different coded size and visible size

content/common/gpu/media/video_encode_accelerator_unittest.cc

Index: content/common/gpu/media/video_encode_accelerator_unittest.cc
diff --git a/content/common/gpu/media/video_encode_accelerator_unittest.cc b/content/common/gpu/media/video_encode_accelerator_unittest.cc
index 9d1e3b69dc7c9edccf56b2fab6021bc0fb20f23b..27b4097cf1e7fccb69749ba378f832cd30e71685 100644
--- a/content/common/gpu/media/video_encode_accelerator_unittest.cc
+++ b/content/common/gpu/media/video_encode_accelerator_unittest.cc
@@ -33,6 +33,8 @@
 #error The VideoEncodeAcceleratorUnittest is not supported on this platform.
 #endif
 
+#define ALIGN_64_BYTES(x) (((x) + 63) & ~63)
+
 using media::VideoEncodeAccelerator;
 
 namespace content {
@@ -96,21 +98,139 @@ base::FilePath::StringType* g_test_stream_data;
 
 struct TestStream {
   TestStream()
-      : requested_bitrate(0),
-        requested_framerate(0),
-        requested_subsequent_bitrate(0),
-        requested_subsequent_framerate(0) {}
+      : default_requested_bitrate(0),
+        default_requested_framerate(0),
+        default_requested_subsequent_bitrate(0),
+        default_requested_subsequent_framerate(0) {}
   ~TestStream() {}
 
   gfx::Size size;
+
+  // Input file name and the file must be an I420 (YUV planar) raw stream.
+  std::string in_filename;
+
+  // The memory mapped of |temp_file|
   base::MemoryMappedFile input_file;
-  media::VideoCodecProfile requested_profile;
+
+  // A temporary file used to prepare input buffers.
+  base::FilePath temp_file;
+
   std::string out_filename;
+  media::VideoCodecProfile requested_profile;
+  unsigned int default_requested_bitrate;

[wuchengli, 2014/09/04 03:34:29]

We really should not mix global variables and testcase variables in the same
object. The four non-default variables should be moved out of this struct.
Modify UpdateTestStreamData so it returns bitrate and framerate in other ways.
Change VEAClient constructor so you can pass these four variables.

[henryhsu, 2014/09/04 08:06:19]

Done.

+  unsigned int default_requested_framerate;
+  unsigned int default_requested_subsequent_bitrate;
+  unsigned int default_requested_subsequent_framerate;
   unsigned int requested_bitrate;
   unsigned int requested_framerate;
   unsigned int requested_subsequent_bitrate;
   unsigned int requested_subsequent_framerate;
 };
+ScopedVector<TestStream> g_test_streams;

[wuchengli, 2014/09/04 03:34:29]

This has indeterminate order of destruction. Use an array of plain pointer and
destruct them in VideoEncodeAcceleratorEnvironment.

See
http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Static_and_Glo...

[henryhsu, 2014/09/04 08:06:19]

Done.

+
+static bool WriteFile(base::File *file,
+                      const off_t offset,
+                      const char* data,
+                      size_t size) {
+  size_t write_bytes = 0;

[wuchengli, 2014/09/04 03:34:29]

s/write_bytes/written_bytes/

[henryhsu, 2014/09/04 08:06:19]

Done.

+  while (write_bytes < size) {
+    int bytes = file->Write(
+        offset + write_bytes, data + write_bytes, size - write_bytes);
+    if (!bytes) return false;

[wuchengli, 2014/09/04 03:34:30]

Should this be if (bytes == -1)?

The function comments says "Returns the number of bytes written, or -1 on
error." 
https://code.google.com/p/chromium/codesearch#chromium/src/base/files/file.h&...

[henryhsu, 2014/09/04 08:06:19]

Done.

+    write_bytes += bytes;
+  }
+  return true;
+}
+
+// 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.
+// Since we are just mmapping and passing chunks of the input file, to ensure
+// alignment, if the starting virtual addresses of YUV planes of the frames
+// in it were not 64 byte-aligned, we'd have to prepare a memory with 64
+// byte-aligned starting address and make sure the addresses of YUV planes of
+// each frame are 64 byte-aligned before sending to the encoder.
+// Now we test resolutions different from coded size and prepare chunks before
+// encoding to avoid performance impact.
+// Use |visible_size| and |coded_size| to copy YUV data into memory from

[wuchengli, 2014/09/04 03:34:29]

YUV data are copied to file directly. Use |visible_size| and |coded_size| to
write YUV data from |in_filename| to |input_file|.

[henryhsu, 2014/09/04 08:06:19]

Done.

+// |in_filename|. The copied result will be saved in |input_file|. Also
+// calculate the byte size of an input frame and set it to |coded_buffer_size|.
+// |temp_file| is used to prepare input buffers and will be deleted after test
+// finished.
+static void PrepareInputBuffers(const gfx::Size& visible_size,
+                                const gfx::Size& coded_size,
+                                const std::string in_filename,
+                                base::MemoryMappedFile* input_file,
+                                base::FilePath* temp_file,
+                                size_t* coded_buffer_size) {
+  size_t input_num_planes = media::VideoFrame::NumPlanes(kInputFormat);
+  std::vector<size_t> padding_sizes(input_num_planes);
+  std::vector<size_t> coded_bpl(input_num_planes);
+  std::vector<size_t> visible_bpl(input_num_planes);
+  std::vector<size_t> visible_plane_rows(input_num_planes);
+
+  // YUV plane starting address should be 64 bytes alignment. Calculate padding
+  // size for each plane, and frame allocation size for coded size. Also store
+  // bytes per line information of coded size and visible size.
+  *coded_buffer_size = 0;
+  for (off_t i = 0; i < input_num_planes; i++) {
+    size_t size =
+        media::VideoFrame::PlaneAllocationSize(kInputFormat, i, coded_size);
+    size_t padding_bytes = ALIGN_64_BYTES(size) - size;
+    *coded_buffer_size += ALIGN_64_BYTES(size);
+
+    coded_bpl[i] =
+        media::VideoFrame::RowBytes(i, kInputFormat, coded_size.width());
+    visible_bpl[i] =
+        media::VideoFrame::RowBytes(i, kInputFormat, visible_size.width());
+    visible_plane_rows[i] =
+        media::VideoFrame::Rows(i, kInputFormat, visible_size.height());
+    size_t padding_rows =
+        media::VideoFrame::Rows(i, kInputFormat, coded_size.height()) -
+        visible_plane_rows[i];
+    padding_sizes[i] = padding_rows * coded_bpl[i] + padding_bytes;
+  }
+
+  // Test case may have many encoders and memory should be prepared once.
+  if (input_file->IsValid())
+    return;
+
+  base::MemoryMappedFile src_file;
+  CHECK(base::CreateTemporaryFile(temp_file));
+  CHECK(src_file.Initialize(base::FilePath(in_filename)));
+
+  size_t visible_buffer_size =
+      media::VideoFrame::AllocationSize(kInputFormat, visible_size);
+  size_t num_frames = src_file.length() / visible_buffer_size;
+  uint32 flags = base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE |
+                 base::File::FLAG_READ;
+
+  // Create a temporary file with coded_size length.
+  base::File file(*temp_file, flags);

[wuchengli, 2014/09/04 03:34:30]

s/file/dest_file/ is more readable.

[henryhsu, 2014/09/04 08:06:19]

Done.

+  file.SetLength(*coded_buffer_size * num_frames);
+
+  off_t src_offset = 0, dest_offset = 0;
+  while (src_offset < static_cast<off_t>(src_file.length())) {
+    for (off_t i = 0; i < input_num_planes; i++) {
+#if defined(ARCH_CPU_ARMEL)
+      // Assert that each plane of frame starts at 64-byte boundary.
+      const uint8* ptr = input_file->data() + dest_offset;

[wuchengli, 2014/09/04 03:34:30]

Is it valid to access data() before Initialize?

[henryhsu, 2014/09/04 08:06:19]

IsValid function will check data_ != NULL.

[wuchengli, 2014/09/04 08:24:39]

So if the code reaches here, data_ is NULL and you are checking the wrong
address. Right?

+      ASSERT_EQ(reinterpret_cast<off_t>(ptr) & 63, 0)
+          << "Planes of frame should be mapped at a 64 byte boundary";
+#endif
+      for (off_t j = 0; j < visible_plane_rows[i]; j++) {
+        const char* src =
+            reinterpret_cast<const char*>(src_file.data() + src_offset);
+        CHECK(WriteFile(&file, dest_offset, src, visible_bpl[i]));
+        src_offset += visible_bpl[i];
+        dest_offset += coded_bpl[i];
+      }
+      dest_offset += padding_sizes[i];
+    }
+  }
+  CHECK(input_file->Initialize(file.Pass()));
+}
 
 // Parse |data| into its constituent parts, set the various output fields
 // accordingly, read in video stream, and store them to |test_streams|.
@@ -129,7 +249,7 @@ static void ParseAndReadTestStreamData(const base::FilePath::StringType& data,
     CHECK_LE(fields.size(), 9U) << data;
     TestStream* test_stream = new TestStream();
 
-    base::FilePath::StringType filename = fields[0];
+    test_stream->in_filename = fields[0];
     int width, height;
     CHECK(base::StringToInt(fields[1], &width));
     CHECK(base::StringToInt(fields[2], &height));
@@ -146,22 +266,23 @@ static void ParseAndReadTestStreamData(const base::FilePath::StringType& data,
       test_stream->out_filename = fields[4];
 
     if (fields.size() >= 6 && !fields[5].empty())
-      CHECK(base::StringToUint(fields[5], &test_stream->requested_bitrate));
+      CHECK(base::StringToUint(
+          fields[5], &test_stream->default_requested_bitrate));
 
     if (fields.size() >= 7 && !fields[6].empty())
-      CHECK(base::StringToUint(fields[6], &test_stream->requested_framerate));
+      CHECK(base::StringToUint(
+          fields[6], &test_stream->default_requested_framerate));
 
     if (fields.size() >= 8 && !fields[7].empty()) {
-      CHECK(base::StringToUint(fields[7],
-                               &test_stream->requested_subsequent_bitrate));
+      CHECK(base::StringToUint(
+          fields[7], &test_stream->default_requested_subsequent_bitrate));
     }
 
     if (fields.size() >= 9 && !fields[8].empty()) {
-      CHECK(base::StringToUint(fields[8],
-                               &test_stream->requested_subsequent_framerate));
+      CHECK(base::StringToUint(
+          fields[8], &test_stream->default_requested_subsequent_framerate));
     }
 
-    CHECK(test_stream->input_file.Initialize(base::FilePath(filename)));
     test_streams->push_back(test_stream);
   }
 }
@@ -174,21 +295,29 @@ static void UpdateTestStreamData(bool mid_stream_bitrate_switch,
   for (size_t i = 0; i < test_streams->size(); i++) {
     TestStream* test_stream = (*test_streams)[i];
     // Use defaults for bitrate/framerate if they are not provided.
-    if (test_stream->requested_bitrate == 0)
+    if (test_stream->default_requested_bitrate == 0)
       test_stream->requested_bitrate = kDefaultBitrate;
+    else
+      test_stream->requested_bitrate = test_stream->default_requested_bitrate;
 
-    if (test_stream->requested_framerate == 0)
+    if (test_stream->default_requested_framerate == 0)
       test_stream->requested_framerate = kDefaultFramerate;
+    else
+      test_stream->requested_framerate =
+          test_stream->default_requested_framerate;
 
     // If bitrate/framerate switch is requested, use the subsequent values if
     // provided, or, if not, calculate them from their initial values using
     // the default ratios.
     // Otherwise, if a switch is not requested, keep the initial values.
+    test_stream->requested_subsequent_bitrate = 0;
     if (mid_stream_bitrate_switch) {
-      if (test_stream->requested_subsequent_bitrate == 0) {
+      if (test_stream->default_requested_subsequent_bitrate == 0)
         test_stream->requested_subsequent_bitrate =
             test_stream->requested_bitrate * kDefaultSubsequentBitrateRatio;
-      }
+      else
+        test_stream->requested_subsequent_bitrate =
+            test_stream->default_requested_subsequent_bitrate;
     } else {
       test_stream->requested_subsequent_bitrate =
           test_stream->requested_bitrate;
@@ -196,11 +325,14 @@ static void UpdateTestStreamData(bool mid_stream_bitrate_switch,
     if (test_stream->requested_subsequent_bitrate == 0)
       test_stream->requested_subsequent_bitrate = 1;
 
+    test_stream->requested_subsequent_framerate = 0;
     if (mid_stream_framerate_switch) {
-      if (test_stream->requested_subsequent_framerate == 0) {
+      if (test_stream->default_requested_subsequent_framerate == 0)
         test_stream->requested_subsequent_framerate =
             test_stream->requested_framerate * kDefaultSubsequentFramerateRatio;
-      }
+      else
+        test_stream->requested_subsequent_framerate =
+            test_stream->default_requested_subsequent_framerate;
     } else {
       test_stream->requested_subsequent_framerate =
           test_stream->requested_framerate;
@@ -368,7 +500,7 @@ scoped_ptr<StreamValidator> StreamValidator::Create(
 
 class VEAClient : public VideoEncodeAccelerator::Client {
  public:
-  VEAClient(const TestStream& test_stream,
+  VEAClient(TestStream& test_stream,
             ClientStateNotification<ClientState>* note,
             bool save_to_file,
             unsigned int keyframe_period,
@@ -430,7 +562,7 @@ class VEAClient : public VideoEncodeAccelerator::Client {
   ClientState state_;
   scoped_ptr<VideoEncodeAccelerator> encoder_;
 
-  const TestStream& test_stream_;
+  TestStream& test_stream_;
   // Used to notify another thread about the state. VEAClient does not own this.
   ClientStateNotification<ClientState>* note_;
 
@@ -507,7 +639,7 @@ class VEAClient : public VideoEncodeAccelerator::Client {
   base::ThreadChecker thread_checker_;
 };
 
-VEAClient::VEAClient(const TestStream& test_stream,
+VEAClient::VEAClient(TestStream& test_stream,
                      ClientStateNotification<ClientState>* note,
                      bool save_to_file,
                      unsigned int keyframe_period,
@@ -552,29 +684,6 @@ VEAClient::VEAClient(const TestStream& test_stream,
     EXPECT_EQ(0, base::WriteFile(out_filename, NULL, 0));
   }
 
-  input_buffer_size_ =
-      media::VideoFrame::AllocationSize(kInputFormat, test_stream.size);
-  CHECK_GT(input_buffer_size_, 0UL);
-
-  // Calculate the number of frames in the input stream by dividing its length
-  // in bytes by frame size in bytes.
-  CHECK_EQ(test_stream_.input_file.length() % input_buffer_size_, 0U)
-      << "Stream byte size is not a product of calculated frame byte size";
-  num_frames_in_stream_ = test_stream_.input_file.length() / input_buffer_size_;
-  CHECK_GT(num_frames_in_stream_, 0UL);
-  CHECK_LE(num_frames_in_stream_, kMaxFrameNum);
-
-  // We may need to loop over the stream more than once if more frames than
-  // provided is required for bitrate tests.
-  if (force_bitrate_ && num_frames_in_stream_ < kMinFramesForBitrateTests) {
-    DVLOG(1) << "Stream too short for bitrate test (" << num_frames_in_stream_
-             << " frames), will loop it to reach " << kMinFramesForBitrateTests
-             << " frames";
-    num_frames_to_encode_ = kMinFramesForBitrateTests;
-  } else {
-    num_frames_to_encode_ = num_frames_in_stream_;
-  }
-
   thread_checker_.DetachFromThread();
 }
 
@@ -629,35 +738,34 @@ void VEAClient::RequireBitstreamBuffers(unsigned int input_count,
   ASSERT_EQ(state_, CS_INITIALIZED);
   SetState(CS_ENCODING);
 
-  // TODO(posciak): For now we only support input streams that meet encoder
-  // size requirements exactly (i.e. coded size == visible size), so that we
-  // can simply mmap the stream file and feed the encoder directly with chunks
-  // of that, instead of memcpying from mmapped file into a separate set of
-  // input buffers that would meet the coded size and alignment requirements.
-  // If/when this is changed, the ARM-specific alignment check below should be
-  // redone as well.
-  input_coded_size_ = input_coded_size;
-  ASSERT_EQ(input_coded_size_, test_stream_.size);
-#if defined(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.
-  // Since we are just mmapping and passing chunks of the input file, to ensure
-  // alignment, if the starting virtual addresses of the frames in it were not
-  // 64 byte-aligned, we'd have to use a separate set of input buffers and copy
-  // the frames into them before sending to the encoder. It would have been an
-  // overkill here though, because, for now at least, we only test resolutions
-  // that result in proper alignment, and it would have also interfered with
-  // performance testing. So just assert that the frame size is a multiple of
-  // 64 bytes. This ensures all frames start at 64-byte boundary, because
-  // MemoryMappedFile should be mmapp()ed at virtual page start as well.
-  ASSERT_EQ(input_buffer_size_ & 63, 0u)
-      << "Frame size has to be a multiple of 64 bytes";
-  ASSERT_EQ(reinterpret_cast<off_t>(test_stream_.input_file.data()) & 63, 0)
-      << "Mapped file should be mapped at a 64 byte boundary";
-#endif
+  PrepareInputBuffers(test_stream_.size,
+                      input_coded_size,
+                      test_stream_.in_filename,
+                      &test_stream_.input_file,
+                      &test_stream_.temp_file,
+                      &input_buffer_size_);
+  CHECK_GT(input_buffer_size_, 0UL);
 
+  // Calculate the number of frames in the input stream by dividing its length
+  // in bytes by frame size in bytes.
+  CHECK_EQ(test_stream_.input_file.length() % input_buffer_size_, 0U)
+      << "Stream byte size is not a product of calculated frame byte size";
+  num_frames_in_stream_ = test_stream_.input_file.length() / input_buffer_size_;
+  CHECK_GT(num_frames_in_stream_, 0UL);
+  CHECK_LE(num_frames_in_stream_, kMaxFrameNum);
+
+  // We may need to loop over the stream more than once if more frames than
+  // provided is required for bitrate tests.
+  if (force_bitrate_ && num_frames_in_stream_ < kMinFramesForBitrateTests) {
+    DVLOG(1) << "Stream too short for bitrate test (" << num_frames_in_stream_
+             << " frames), will loop it to reach " << kMinFramesForBitrateTests
+             << " frames";
+    num_frames_to_encode_ = kMinFramesForBitrateTests;
+  } else {
+    num_frames_to_encode_ = num_frames_in_stream_;
+  }
+
+  input_coded_size_ = input_coded_size;
   num_required_input_buffers_ = input_count;
   ASSERT_GT(num_required_input_buffers_, 0UL);
 
@@ -743,8 +851,14 @@ void VEAClient::InputNoLongerNeededCallback(int32 input_id) {
 scoped_refptr<media::VideoFrame> VEAClient::PrepareInputFrame(off_t position) {
   CHECK_LE(position + input_buffer_size_, test_stream_.input_file.length());
 
-  uint8* frame_data =
+  uint8* frame_data_y =
       const_cast<uint8*>(test_stream_.input_file.data() + position);
+  uint8* frame_data_u =
+      frame_data_y + ALIGN_64_BYTES(media::VideoFrame::PlaneAllocationSize(
+                         kInputFormat, 0, input_coded_size_));
+  uint8* frame_data_v =
+      frame_data_u + ALIGN_64_BYTES(media::VideoFrame::PlaneAllocationSize(
+                         kInputFormat, 1, input_coded_size_));
 
   CHECK_GT(current_framerate_, 0U);
   scoped_refptr<media::VideoFrame> frame =
@@ -756,9 +870,9 @@ scoped_refptr<media::VideoFrame> VEAClient::PrepareInputFrame(off_t position) {
           input_coded_size_.width(),
           input_coded_size_.width() / 2,
           input_coded_size_.width() / 2,
-          frame_data,
-          frame_data + input_coded_size_.GetArea(),
-          frame_data + (input_coded_size_.GetArea() * 5 / 4),
+          frame_data_y,
+          frame_data_u,
+          frame_data_v,
           base::TimeDelta().FromMilliseconds(
               next_input_id_ * base::Time::kMillisecondsPerSecond /
               current_framerate_),
@@ -897,6 +1011,14 @@ void VEAClient::VerifyStreamProperties() {
   }
 }
 
+class VideoEncodeAcceleratorEnvironment : public ::testing::Environment {

[wuchengli, 2014/09/04 03:34:29]

s/VideoEncodeAcceleratorEnvironment/VideoEncodeAcceleratorTestEnvironment/

[henryhsu, 2014/09/04 08:06:19]

Done.

+  public:
+    virtual void TearDown() {
+      for (size_t i = 0; i < g_test_streams.size(); i++)
+        base::DeleteFile(g_test_streams[i]->temp_file, false);
+    }
+};
+
 // Test parameters:
 // - Number of concurrent encoders.
 // - If true, save output to file (provided an output filename was supplied).
@@ -920,10 +1042,8 @@ TEST_P(VideoEncodeAcceleratorTest, TestSimpleEncode) {
   const bool mid_stream_framerate_switch = GetParam().g;
 
   // Initialize the test streams.
-  ScopedVector<TestStream> test_streams;
-  ParseAndReadTestStreamData(*g_test_stream_data, &test_streams);
   UpdateTestStreamData(
-      mid_stream_bitrate_switch, mid_stream_framerate_switch, &test_streams);
+      mid_stream_bitrate_switch, mid_stream_framerate_switch, &g_test_streams);
 
   ScopedVector<ClientStateNotification<ClientState> > notes;
   ScopedVector<VEAClient> clients;
@@ -932,14 +1052,14 @@ TEST_P(VideoEncodeAcceleratorTest, TestSimpleEncode) {
 
   // Create all encoders.
   for (size_t i = 0; i < num_concurrent_encoders; i++) {
-    size_t test_stream_index = i % test_streams.size();
+    size_t test_stream_index = i % g_test_streams.size();
     // Disregard save_to_file if we didn't get an output filename.
     bool encoder_save_to_file =
         (save_to_file &&
-         !test_streams[test_stream_index]->out_filename.empty());
+         !g_test_streams[test_stream_index]->out_filename.empty());
 
     notes.push_back(new ClientStateNotification<ClientState>());
-    clients.push_back(new VEAClient(*test_streams[test_stream_index],
+    clients.push_back(new VEAClient(*g_test_streams[test_stream_index],
                                     notes.back(),
                                     encoder_save_to_file,
                                     keyframe_period,
@@ -975,6 +1095,7 @@ TEST_P(VideoEncodeAcceleratorTest, TestSimpleEncode) {
 
   // This ensures all tasks have finished.
   encoder_thread.Stop();
+

[wuchengli, 2014/09/04 03:34:29]

remove blank line

[henryhsu, 2014/09/04 08:06:19]

Done.

 }
 
 INSTANTIATE_TEST_CASE_P(
@@ -1028,6 +1149,8 @@ INSTANTIATE_TEST_CASE_P(
 }  // namespace content
 
 int main(int argc, char** argv) {
+  testing::AddGlobalTestEnvironment(
+      new content::VideoEncodeAcceleratorEnvironment);
   testing::InitGoogleTest(&argc, argv);  // Removes gtest-specific args.
   base::CommandLine::Init(argc, argv);
 
@@ -1058,6 +1181,7 @@ int main(int argc, char** argv) {
       continue;
     LOG(FATAL) << "Unexpected switch: " << it->first << ":" << it->second;
   }
-
+  content::ParseAndReadTestStreamData(*content::g_test_stream_data,
+                                      &content::g_test_streams);
   return RUN_ALL_TESTS();
 }