vea_unittest - Control the rate of input frames.

content/common/gpu/media/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 "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/time/time.h"
+#include "base/timer/timer.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"
@@ skipping 430 matching lines @@
   } else {
     LOG(FATAL) << "Unsupported profile: " << profile;
   }
 
   return validator.Pass();
 }
 
 class VEAClient : public VideoEncodeAccelerator::Client {
  public:
   VEAClient(TestStream* test_stream,
+            double input_fps,

[Pawel Osciak, 2014/12/16 10:56:40]

Would it make more sense to make it an argument per test stream?

[Owen Lin, 2014/12/17 05:27:29]

Sound reasonable. Done.

             ClientStateNotification<ClientState>* note,
             bool save_to_file,
             unsigned int keyframe_period,
             bool force_bitrate,
             bool test_perf,
             bool mid_stream_bitrate_switch,
             bool mid_stream_framerate_switch);
   virtual ~VEAClient();
   void CreateEncoder();
   void DestroyEncoder();
@@ skipping 14 matching lines @@
   bool has_encoder() { return encoder_.get(); }
 
   void SetState(ClientState new_state);
 
   // Set current stream parameters to given |bitrate| at |framerate|.
   void SetStreamParameters(unsigned int bitrate, unsigned int framerate);
 
   // Called when encoder is done with a VideoFrame.
   void InputNoLongerNeededCallback(int32 input_id);
 
-  // Ensure encoder has at least as many inputs as it asked for
-  // via RequireBitstreamBuffers().
-  void FeedEncoderWithInputs();
+  // Feed the encoder with one input frame unless it has more input buffers
+  // than it asked for via RequireBitstreamBuffers(). Return false if no input

[Pawel Osciak, 2014/12/16 10:56:40]

I think you meant unless it has as many buffers as it asked, not more.

[Owen Lin, 2014/12/17 05:27:29]

Done.

+  // frame was fed.
+  bool FeedEncoderWithOneInput();
 
   // Provide the encoder with a new output buffer.
   void FeedEncoderWithOutput(base::SharedMemory* shm);
 
   // Called on finding a complete frame (with |keyframe| set to true for
   // keyframes) in the stream, to perform codec-independent, per-frame checks
   // and accounting. Returns false once we have collected all frames we needed.
   bool HandleEncodedFrame(bool keyframe);
 
   // Verify that stream bitrate has been close to current_requested_bitrate_,
@@ skipping 12 matching lines @@
 
   // Update the parameters according to |mid_stream_bitrate_switch| and
   // |mid_stream_framerate_switch|.
   void UpdateTestStreamData(bool mid_stream_bitrate_switch,
                             bool mid_stream_framerate_switch);
 
   ClientState state_;
   scoped_ptr<VideoEncodeAccelerator> encoder_;
 
   TestStream* test_stream_;
+
   // Used to notify another thread about the state. VEAClient does not own this.
   ClientStateNotification<ClientState>* note_;
 
   // Ids assigned to VideoFrames (start at 1 for easy comparison with
   // num_encoded_frames_).
   std::set<int32> inputs_at_client_;
   int32 next_input_id_;
 
   // Ids for output BitstreamBuffers.
   typedef std::map<int32, base::SharedMemory*> IdToSHM;
@@ skipping 61 matching lines @@
   unsigned int requested_bitrate_;
 
   // Requested initial framerate.
   unsigned int requested_framerate_;
 
   // Bitrate to switch to in the middle of the stream.
   unsigned int requested_subsequent_bitrate_;
 
   // Framerate to switch to in the middle of the stream.
   unsigned int requested_subsequent_framerate_;
+
+  // The timer used to feed the encoder with the input frames.
+  scoped_ptr<base::RepeatingTimer<VEAClient>> input_timer_;
+
+  // The interval between two input frames.
+  base::TimeDelta input_duration_;
 };
 
 VEAClient::VEAClient(TestStream* test_stream,
+                     double input_fps,
                      ClientStateNotification<ClientState>* note,
                      bool save_to_file,
                      unsigned int keyframe_period,
                      bool force_bitrate,
                      bool test_perf,
                      bool mid_stream_bitrate_switch,
                      bool mid_stream_framerate_switch)
     : state_(CS_CREATED),
       test_stream_(test_stream),
       note_(note),
@@ skipping 20 matching lines @@
       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)));
 
   CHECK(validator_.get());
 
+  if (input_fps > 0)
+    input_duration_ = base::TimeDelta::FromSeconds(1) / input_fps;
+
   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);
@@ skipping 30 matching lines @@
 
   SetStreamParameters(requested_bitrate_, requested_framerate_);
   SetState(CS_INITIALIZED);
 }
 
 void VEAClient::DestroyEncoder() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!has_encoder())
     return;
   encoder_.reset();
+  input_timer_.reset();
 }
 
 void VEAClient::UpdateTestStreamData(bool mid_stream_bitrate_switch,
                                      bool mid_stream_framerate_switch) {
   // Use defaults for bitrate/framerate if they are not provided.
   if (test_stream_->requested_bitrate == 0)
     requested_bitrate_ = kDefaultBitrate;
   else
     requested_bitrate_ = test_stream_->requested_bitrate;
 
@@ skipping 66 matching lines @@
   ASSERT_GT(output_buffer_size_, 0UL);
 
   for (unsigned int i = 0; i < kNumOutputBuffers; ++i) {
     base::SharedMemory* shm = new base::SharedMemory();
     CHECK(shm->CreateAndMapAnonymous(output_buffer_size_));
     output_shms_.push_back(shm);
     FeedEncoderWithOutput(shm);
   }
 
   encode_start_time_ = base::TimeTicks::Now();
-  FeedEncoderWithInputs();
+  if (input_duration_ == base::TimeDelta()) {
+    while (FeedEncoderWithOneInput())
+      ;
+  } else {
+    input_timer_.reset(new base::RepeatingTimer<VEAClient>());
+    input_timer_->Start(
+        FROM_HERE, input_duration_,
+        base::Bind(base::IgnoreResult(&VEAClient::FeedEncoderWithOneInput),
+                   base::Unretained(this)));
+  }
 }
 
 void VEAClient::BitstreamBufferReady(int32 bitstream_buffer_id,
                                      size_t payload_size,
                                      bool key_frame) {
   DCHECK(thread_checker_.CalledOnValidThread());
   ASSERT_LE(payload_size, output_buffer_size_);
 
   IdToSHM::iterator it = output_buffers_at_client_.find(bitstream_buffer_id);
   ASSERT_NE(it, output_buffers_at_client_.end());
@@ skipping 43 matching lines @@
   encoder_->RequestEncodingParametersChange(current_requested_bitrate_,
                                             current_framerate_);
   DVLOG(1) << "Switched parameters to " << current_requested_bitrate_
            << " bps @ " << current_framerate_ << " FPS";
 }
 
 void VEAClient::InputNoLongerNeededCallback(int32 input_id) {
   std::set<int32>::iterator it = inputs_at_client_.find(input_id);
   ASSERT_NE(it, inputs_at_client_.end());
   inputs_at_client_.erase(it);
-  FeedEncoderWithInputs();
+  if (input_duration_ == base::TimeDelta())
+    DCHECK(FeedEncoderWithOneInput());

[Pawel Osciak, 2014/12/16 10:56:40]

Isn't this basically a DCHECK on whether the encoder is fast enough or not? This
makes it pretty indeterministic. I would prefer not having this.

[Owen Lin, 2014/12/17 05:27:29]

No, this callback called when the encoder free an input buffer. So, it is
expected we can feed one input buffer to the encoder. However, I have refactored
the code and FeedEncoderWithOneInput no longer return bool, so I removed the
DCHECK as well.

 }
 
 scoped_refptr<media::VideoFrame> VEAClient::PrepareInputFrame(off_t position) {
   CHECK_LE(position + test_stream_->aligned_buffer_size,
            test_stream_->mapped_aligned_in_file.length());
 
   uint8* frame_data_y = const_cast<uint8*>(
       test_stream_->mapped_aligned_in_file.data() + position);
   uint8* frame_data_u = frame_data_y + test_stream_->aligned_plane_size[0];
   uint8* frame_data_v = frame_data_u + test_stream_->aligned_plane_size[1];
@@ skipping 18 matching lines @@
               base::Bind(&VEAClient::InputNoLongerNeededCallback,
                          base::Unretained(this),
                          next_input_id_)));
 
   CHECK(inputs_at_client_.insert(next_input_id_).second);
   ++next_input_id_;
 
   return frame;
 }
 
-void VEAClient::FeedEncoderWithInputs() {
-  if (!has_encoder())
-    return;
+bool VEAClient::FeedEncoderWithOneInput() {
+  if (!has_encoder() || state_ != CS_ENCODING) {
+    // Destructor will also stop the timer.

[Pawel Osciak, 2014/12/16 10:56:40]

If so, do we need to do this here as well?

[Owen Lin, 2014/12/17 05:27:29]

I would prefer to cancel the timer as early as we don't need it. But it should
make no harm of removing it excepts this function will continue being called
until the encoder gets destroyed.

[Pawel Osciak, 2014/12/18 04:54:10]

Ok, then the comment is confusing. It suggests that we are doing something
superficial here. It would have been better to say what you explained above, or
not have a comment at all.

[Owen Lin, 2014/12/18 08:38:11]

Done.

+    input_timer_.reset();
+    return false;
+  }
 
-  if (state_ != CS_ENCODING)
-    return;
+  size_t bytes_left =
+      test_stream_->mapped_aligned_in_file.length() - 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;
+  }
 
-  while (inputs_at_client_.size() <
-         num_required_input_buffers_ + kNumExtraInputFrames) {
-    size_t bytes_left =
-        test_stream_->mapped_aligned_in_file.length() - 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;
-      continue;
-    }
+  if (inputs_at_client_.size() >=

[Pawel Osciak, 2014/12/16 10:56:41]

I'd extract this out from here and have the while loop in the caller.

[Owen Lin, 2014/12/17 05:27:29]

Done. I have moved this out to the while loop in the caller. Due to this change
we need another callback function for the |input_timer_|.

+      num_required_input_buffers_ + kNumExtraInputFrames) {
+    DVLOG(1) << "Drop input frame: " + pos_in_input_stream_;

[Pawel Osciak, 2014/12/16 10:56:40]

s/Drop/Dropping/

[Owen Lin, 2014/12/17 05:27:29]

Done.

+    pos_in_input_stream_ += test_stream_->aligned_buffer_size;
+    return false;
+  }
 
-    bool force_keyframe = false;
-    if (keyframe_period_ && next_input_id_ % keyframe_period_ == 0) {
-      keyframe_requested_at_ = next_input_id_;
-      force_keyframe = true;
-    }
+  bool force_keyframe = false;
+  if (keyframe_period_ && next_input_id_ % keyframe_period_ == 0) {
+    keyframe_requested_at_ = next_input_id_;
+    force_keyframe = true;
+  }
 
-    scoped_refptr<media::VideoFrame> video_frame =
-        PrepareInputFrame(pos_in_input_stream_);
-    pos_in_input_stream_ += test_stream_->aligned_buffer_size;
+  scoped_refptr<media::VideoFrame> video_frame =
+      PrepareInputFrame(pos_in_input_stream_);
+  pos_in_input_stream_ += test_stream_->aligned_buffer_size;
 
-    encoder_->Encode(video_frame, force_keyframe);
-  }
+  encoder_->Encode(video_frame, force_keyframe);
+  return true;
 }
 
 void VEAClient::FeedEncoderWithOutput(base::SharedMemory* shm) {
   if (!has_encoder())
     return;
 
   if (state_ != CS_ENCODING)
     return;
 
   base::SharedMemoryHandle dup_handle;
@@ skipping 76 matching lines @@
                 current_requested_bitrate_,
                 kBitrateTolerance * current_requested_bitrate_);
   }
 }
 
 // Setup test stream data and delete temporary aligned files at the beginning
 // and end of unittest. We only need to setup once for all test cases.
 class VideoEncodeAcceleratorTestEnvironment : public ::testing::Environment {
  public:
   VideoEncodeAcceleratorTestEnvironment(
-      scoped_ptr<base::FilePath::StringType> data) {
+      scoped_ptr<base::FilePath::StringType> data,
+      double input_fps) {
     test_stream_data_ = data.Pass();
+    input_fps_ = input_fps;
   }
 
   virtual void SetUp() {
     ParseAndReadTestStreamData(*test_stream_data_, &test_streams_);
   }
 
   virtual void TearDown() {
     for (size_t i = 0; i < test_streams_.size(); i++) {
       base::DeleteFile(test_streams_[i]->aligned_in_file, false);
     }
   }
 
   ScopedVector<TestStream> test_streams_;
 
+  // The input frame rate to the encoder.
+  double input_fps_;
+
  private:
   scoped_ptr<base::FilePath::StringType> test_stream_data_;
 };
 
 // Test parameters:
 // - Number of concurrent encoders.
 // - If true, save output to file (provided an output filename was supplied).
 // - Force a keyframe every n frames.
 // - Force bitrate; the actual required value is provided as a property
 //   of the input stream, because it depends on stream type/resolution/etc.
@@ skipping 20 matching lines @@
 
   // Create all encoders.
   for (size_t i = 0; i < num_concurrent_encoders; i++) {
     size_t test_stream_index = i % g_env->test_streams_.size();
     // Disregard save_to_file if we didn't get an output filename.
     bool encoder_save_to_file =
         (save_to_file &&
          !g_env->test_streams_[test_stream_index]->out_filename.empty());
 
     notes.push_back(new ClientStateNotification<ClientState>());
-    clients.push_back(new VEAClient(g_env->test_streams_[test_stream_index],
-                                    notes.back(),
-                                    encoder_save_to_file,
-                                    keyframe_period,
-                                    force_bitrate,
-                                    test_perf,
-                                    mid_stream_bitrate_switch,
-                                    mid_stream_framerate_switch));
+    clients.push_back(new VEAClient(
+        g_env->test_streams_[test_stream_index], g_env->input_fps_,

[Pawel Osciak, 2014/12/16 10:56:40]

Uh... did git cl format do this? The previous version was much more readable...

[Owen Lin, 2014/12/17 05:27:29]

I feel the same way, but it's git cl format. Due to refactoring, this code is no
longer changed.

+        notes.back(), encoder_save_to_file, keyframe_period, force_bitrate,
+        test_perf, mid_stream_bitrate_switch, mid_stream_framerate_switch));
 
     encoder_thread.message_loop()->PostTask(
         FROM_HERE,
         base::Bind(&VEAClient::CreateEncoder,
                    base::Unretained(clients.back())));
   }
 
   // All encoders must pass through states in this order.
   enum ClientState state_transitions[] = {CS_ENCODER_SET, CS_INITIALIZED,
                                           CS_ENCODING, CS_FINISHED};
@@ skipping 76 matching lines @@
           content::g_default_in_parameters));
 
   // Needed to enable DVLOG through --vmodule.
   logging::LoggingSettings settings;
   settings.logging_dest = logging::LOG_TO_SYSTEM_DEBUG_LOG;
   CHECK(logging::InitLogging(settings));
 
   const base::CommandLine* cmd_line = base::CommandLine::ForCurrentProcess();
   DCHECK(cmd_line);
 
+  double input_fps = 0;
   base::CommandLine::SwitchMap switches = cmd_line->GetSwitches();
   for (base::CommandLine::SwitchMap::const_iterator it = switches.begin();
        it != switches.end();
        ++it) {
     if (it->first == "test_stream_data") {
       test_stream_data->assign(it->second.c_str());
       continue;
     }
+    if (it->first == "input_fps") {
+      // On Windows, CommandLine::StringType is wstring. We need to convert
+      // it to std::string first
+      std::string input(it->second.begin(), it->second.end());
+      CHECK(base::StringToDouble(input, &input_fps));
+      continue;
+    }
     if (it->first == "v" || it->first == "vmodule")
       continue;
     LOG(FATAL) << "Unexpected switch: " << it->first << ":" << it->second;
   }
 
   content::g_env =
       reinterpret_cast<content::VideoEncodeAcceleratorTestEnvironment*>(
           testing::AddGlobalTestEnvironment(
               new content::VideoEncodeAcceleratorTestEnvironment(
-                  test_stream_data.Pass())));
+                  test_stream_data.Pass(), input_fps)));
 
   return RUN_ALL_TESTS();
 }