Adds fake hardware video encoder.

content/common/gpu/media/video_encode_accelerator_unittest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.

[wuchengli, 2014/12/09 14:29:24]

The change description should have a summary followed by a blank line because
the summary will become git title. Usually each line of the summary and the
detailed description should be <= 75 characters.

It's still nice to associate the CL with a bug. Also please add TEST=. You can
test by running cast and vea unittests.

[hellner1, 2014/12/10 22:38:59]

Done.

I did run vea unittests. But since cast_unittests doesn't seem to work, even
without any changes, testing it with the changes make little sense.

I was planning to rope in a reviewer of cast (hclam) for helping me figure out
why ToT cast unittest is not working.

 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #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/memory/scoped_vector.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/sys_byteorder.h"
 #include "base/time/time.h"
 #include "content/common/gpu/media/video_accelerator_unittest_helpers.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/bitstream_buffer.h"
 #include "media/base/test_data_util.h"
 #include "media/filters/h264_parser.h"
 #include "media/video/video_encode_accelerator.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(USE_X11)
 #include "ui/gfx/x/x11_types.h"
 #endif
 
+#include "media/video/fake_video_encode_accelerator.h"

[wuchengli, 2014/12/09 14:29:24]

move this before #include "media/video/video_encode_accelerator.h"

[hellner1, 2014/12/10 22:38:59]

Done.

+
 #if defined(OS_CHROMEOS) && defined(ARCH_CPU_ARMEL)
 #include "content/common/gpu/media/v4l2_video_encode_accelerator.h"
 #elif defined(OS_CHROMEOS) && defined(ARCH_CPU_X86_FAMILY) && defined(USE_X11)
 #include "content/common/gpu/media/vaapi_video_encode_accelerator.h"
 #else
 #error The VideoEncodeAcceleratorUnittest is not supported on this platform.
 #endif
 
 using media::VideoEncodeAccelerator;
 
@@ skipping 82 matching lines @@
   uint64_t timestamp;   // 64-bit presentation timestamp
 } __attribute__((packed));
 
 struct TestStream {
   TestStream()
       : num_frames(0),
         aligned_buffer_size(0),
         requested_bitrate(0),
         requested_framerate(0),
         requested_subsequent_bitrate(0),
-        requested_subsequent_framerate(0) {}
+        requested_subsequent_framerate(0),
+        fake_encoder(0) {}

[wuchengli, 2014/12/09 14:29:24]

Do you want to use different encoders for different TestStream? If not,
fake_encoder should be a command line argument, stored in
VideoEncodeAcceleratorTestEnvironment, and passed to VEAClient.

[hellner1, 2014/12/10 22:38:58]

I made fake_encoder selection a command line argument.

   ~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 temporary file used to prepare aligned input buffers of |in_filename|.
   // The file makes sure starting address of YUV planes are 64 byte-aligned.
   base::FilePath aligned_in_file;
 
   // The memory mapping of |aligned_in_file|
   base::MemoryMappedFile mapped_aligned_in_file;
 
   // Byte size of a frame of |aligned_in_file|.
   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;
+  int fake_encoder;

[wuchengli, 2014/12/09 14:29:24]

Use bool.

[hellner1, 2014/12/10 22:38:58]

Done.

 };
 
 inline static size_t Align64Bytes(size_t value) {
   return (value + 63) & ~63;
 }
 
 // Write |data| of |size| bytes at |offset| bytes into |file|.
 static bool WriteFile(base::File* file,
                       const off_t offset,
                       const uint8* data,
@@ skipping 126 matching lines @@
   // Split the string to individual test stream data.
   std::vector<base::FilePath::StringType> test_streams_data;
   base::SplitString(data, ';', &test_streams_data);
   CHECK_GE(test_streams_data.size(), 1U) << data;
 
   // Parse each test stream data and read the input file.
   for (size_t index = 0; index < test_streams_data.size(); ++index) {
     std::vector<base::FilePath::StringType> fields;
     base::SplitString(test_streams_data[index], ':', &fields);
     CHECK_GE(fields.size(), 4U) << data;
-    CHECK_LE(fields.size(), 9U) << data;
+    CHECK_LE(fields.size(), 10U) << data;
     TestStream* test_stream = new TestStream();
 
     test_stream->in_filename = fields[0];
     int width, height;
     CHECK(base::StringToInt(fields[1], &width));
     CHECK(base::StringToInt(fields[2], &height));
     test_stream->visible_size = gfx::Size(width, height);
     CHECK(!test_stream->visible_size.IsEmpty());
     int profile;
     CHECK(base::StringToInt(fields[3], &profile));
@@ skipping 13 matching lines @@
 
     if (fields.size() >= 8 && !fields[7].empty()) {
       CHECK(base::StringToUint(fields[7],
                                &test_stream->requested_subsequent_bitrate));
     }
 
     if (fields.size() >= 9 && !fields[8].empty()) {
       CHECK(base::StringToUint(fields[8],
                                &test_stream->requested_subsequent_framerate));
     }
+    if (fields.size() >= 10 && !fields[9].empty()) {
+      CHECK(base::StringToInt(fields[9], &test_stream->fake_encoder));
+    }
     test_streams->push_back(test_stream);
   }
 }
 
 enum ClientState {
   CS_CREATED,
   CS_ENCODER_SET,
   CS_INITIALIZED,
   CS_ENCODING,
   CS_FINISHED,
   CS_ERROR,
 };
 
 // Performs basic, codec-specific sanity checks on the stream buffers passed
 // to ProcessStreamBuffer(): whether we've seen keyframes before non-keyframes,
 // correct sequences of H.264 NALUs (SPS before PPS and before slices), etc.
 // Calls given FrameFoundCallback when a complete frame is found while
 // processing.
 class StreamValidator {
  public:
   // To be called when a complete frame is found while processing a stream
   // buffer, passing true if the frame is a keyframe. Returns false if we
   // are not interested in more frames and further processing should be aborted.
   typedef base::Callback<bool(bool)> FrameFoundCallback;
 
   virtual ~StreamValidator() {}
 
   // Provide a StreamValidator instance for the given |profile|.
   static scoped_ptr<StreamValidator> Create(media::VideoCodecProfile profile,
-                                            const FrameFoundCallback& frame_cb);
+                                            const FrameFoundCallback& frame_cb,
+                                            bool fake_stream);
 
   // Process and verify contents of a bitstream buffer.
   virtual void ProcessStreamBuffer(const uint8* stream, size_t size) = 0;
 
  protected:
   explicit StreamValidator(const FrameFoundCallback& frame_cb)
       : frame_cb_(frame_cb) {}
 
   FrameFoundCallback frame_cb_;
 };
 
+class PassThroughValidator : public StreamValidator {
+ public:
+  explicit PassThroughValidator(const FrameFoundCallback& frame_cb)
+      : StreamValidator(frame_cb) {}
+  void ProcessStreamBuffer(const uint8* stream, size_t size) override;
+};
+
+void PassThroughValidator::ProcessStreamBuffer(
+    const uint8* stream,
+    size_t size) {
+  const bool keyframe = !(stream[0] & 0x01);

[wuchengli, 2014/12/09 14:29:25]

This is a hidden dependency to FakeVideoEncodeAccelerator. Add a bool
FakeVideoEncodeAccelerator::IsKeyFrame(const uint8* stream, size_t size) for
this.

[hellner1, 2014/12/10 22:38:58]

Removed the need for this as suggested in other comment. PTAL.

+  frame_cb_.Run(keyframe);
+}
+
 class H264Validator : public StreamValidator {
  public:
   explicit H264Validator(const FrameFoundCallback& frame_cb)
       : StreamValidator(frame_cb),
         seen_sps_(false),
         seen_pps_(false),
         seen_idr_(false) {}
 
   virtual void ProcessStreamBuffer(const uint8* stream, size_t size) override;
 
@@ skipping 78 matching lines @@
 
   frame_cb_.Run(keyframe);
   // TODO(posciak): We could be getting more frames in the buffer, but there is
   // no simple way to detect this. We'd need to parse the frames and go through
   // partition numbers/sizes. For now assume one frame per buffer.
 }
 
 // static
 scoped_ptr<StreamValidator> StreamValidator::Create(
     media::VideoCodecProfile profile,
-    const FrameFoundCallback& frame_cb) {
+    const FrameFoundCallback& frame_cb,
+    bool fake_stream) {
   scoped_ptr<StreamValidator> validator;
 
-  if (IsH264(profile)) {
+  if (fake_stream) {
+    validator.reset(new PassThroughValidator(frame_cb));
+  } else if (IsH264(profile)) {
     validator.reset(new H264Validator(frame_cb));
   } else if (IsVP8(profile)) {
     validator.reset(new VP8Validator(frame_cb));
   } else {
     LOG(FATAL) << "Unsupported profile: " << profile;
   }
 
   return validator.Pass();
 }
 
@@ skipping 188 matching lines @@
       test_perf_(test_perf),
       requested_bitrate_(0),
       requested_framerate_(0),
       requested_subsequent_bitrate_(0),
       requested_subsequent_framerate_(0) {
   if (keyframe_period_)
     CHECK_LT(kMaxKeyframeDelay, keyframe_period_);
 
   validator_ = StreamValidator::Create(
       test_stream_->requested_profile,
-      base::Bind(&VEAClient::HandleEncodedFrame, base::Unretained(this)));
+      base::Bind(&VEAClient::HandleEncodedFrame, base::Unretained(this)),
+      test_stream_->fake_encoder);
 
   CHECK(validator_.get());
 
   if (save_to_file_) {
     CHECK(!test_stream_->out_filename.empty());
     base::FilePath out_filename(test_stream_->out_filename);
     // This creates or truncates out_filename.
     // Without it, AppendToFile() will not work.
     EXPECT_EQ(0, base::WriteFile(out_filename, NULL, 0));
   }
 
   // Initialize the parameters of the test streams.
   UpdateTestStreamData(mid_stream_bitrate_switch, mid_stream_framerate_switch);
 
   thread_checker_.DetachFromThread();
 }
 
 VEAClient::~VEAClient() { CHECK(!has_encoder()); }
 
 void VEAClient::CreateEncoder() {
   DCHECK(thread_checker_.CalledOnValidThread());
   CHECK(!has_encoder());
 
+
+  if (test_stream_->fake_encoder) {
+    std::vector<uint32> no_stored_bitrates;
+    encoder_.reset(
+        new media::FakeVideoEncodeAccelerator(
+            scoped_refptr<base::SingleThreadTaskRunner>(
+                base::MessageLoopProxy::current()),
+            no_stored_bitrates));
+  } else {
 #if defined(OS_CHROMEOS) && defined(ARCH_CPU_ARMEL)
-  scoped_ptr<V4L2Device> device = V4L2Device::Create(V4L2Device::kEncoder);
-  encoder_.reset(new V4L2VideoEncodeAccelerator(device.Pass()));
+    scoped_ptr<V4L2Device> device = V4L2Device::Create(V4L2Device::kEncoder);
+    encoder_.reset(new V4L2VideoEncodeAccelerator(device.Pass()));
 #elif defined(OS_CHROMEOS) && defined(ARCH_CPU_X86_FAMILY) && defined(USE_X11)
-  encoder_.reset(new VaapiVideoEncodeAccelerator(gfx::GetXDisplay()));
+    encoder_.reset(new VaapiVideoEncodeAccelerator(gfx::GetXDisplay()));
 #endif
+  }
 
   SetState(CS_ENCODER_SET);
 
   DVLOG(1) << "Profile: " << test_stream_->requested_profile
            << ", initial bitrate: " << requested_bitrate_;
   if (!encoder_->Initialize(kInputFormat,
                             test_stream_->visible_size,
                             test_stream_->requested_profile,
                             requested_bitrate_,
                             this)) {
@@ skipping 113 matching lines @@
   base::SharedMemory* shm = it->second;
   output_buffers_at_client_.erase(it);
 
   if (state_ == CS_FINISHED)
     return;
 
   encoded_stream_size_since_last_check_ += payload_size;
 
   const uint8* stream_ptr = static_cast<const uint8*>(shm->memory());
   if (payload_size > 0) {
     validator_->ProcessStreamBuffer(stream_ptr, payload_size);

[wuchengli, 2014/12/09 14:29:24]

I think it's simpler to set |validator_| to NULL if fake encoder is used.  Since
it's a fake encoder, there's no need to validate the output.
PassThroughValidator can be removed. Here the code can be:
if (validator_)
  validator_->ProcessStreamBuffer();
else
  HandleEncodedFrame(key_frame);

[hellner1, 2014/12/10 22:38:58]

Good suggestion! Done.

 
     if (save_to_file_) {
       if (IsVP8(test_stream_->requested_profile))
         WriteIvfFrameHeader(num_encoded_frames_ - 1, payload_size);
 
       EXPECT_TRUE(base::AppendToFile(
           base::FilePath::FromUTF8Unsafe(test_stream_->out_filename),
           static_cast<char*>(shm->memory()),
           base::checked_cast<int>(payload_size)));
     }
@@ skipping 409 matching lines @@
   }
 
   content::g_env =
       reinterpret_cast<content::VideoEncodeAcceleratorTestEnvironment*>(
           testing::AddGlobalTestEnvironment(
               new content::VideoEncodeAcceleratorTestEnvironment(
                   test_stream_data.Pass())));
 
   return RUN_ALL_TESTS();
 }