RTC Video Encoder: Use capturer timestamp

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 <vector>
 
 #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/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/numerics/safe_conversions.h"
@@ skipping 777 matching lines @@
   ~VEAClient() override;
   void CreateEncoder();
   void DestroyEncoder();
 
   // VideoDecodeAccelerator::Client implementation.
   void RequireBitstreamBuffers(unsigned int input_count,
                                const gfx::Size& input_coded_size,
                                size_t output_buffer_size) override;
   void BitstreamBufferReady(int32_t bitstream_buffer_id,
                             size_t payload_size,
-                            bool key_frame) override;
+                            bool key_frame,
+                            base::TimeDelta timestamp) override;
   void NotifyError(VideoEncodeAccelerator::Error error) override;
 
  private:
   bool has_encoder() { return encoder_.get(); }
 
   // Return the number of encoded frames per second.
   double frames_per_second();
 
   std::unique_ptr<media::VideoEncodeAccelerator> CreateFakeVEA();
   std::unique_ptr<media::VideoEncodeAccelerator> CreateV4L2VEA();
@@ skipping 160 matching lines @@
   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.
   std::unique_ptr<base::RepeatingTimer> input_timer_;
+
+  // The timestamps for each frame in the order of CreateFrame() invocation.
+  std::vector<base::TimeDelta> frame_timestamps_;
+
+  // The counter to keep track of which timestamp in |frame_timestamps| we are
+  // checking now.
+  unsigned int output_frame_count_;

[Pawel Osciak, 2016/05/26 07:39:23]

Perhaps we could use a queue for frame_timestamps_ and just pop each time,
without having to maintain the counter?

[shenghao, 2016/05/26 10:38:20]

Done.

 };
 
 VEAClient::VEAClient(TestStream* test_stream,
                      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,
@@ skipping 16 matching lines @@
       next_keyframe_at_(0),
       force_bitrate_(force_bitrate),
       current_requested_bitrate_(0),
       current_framerate_(0),
       encoded_stream_size_since_last_check_(0),
       test_perf_(test_perf),
       verify_output_(verify_output),
       requested_bitrate_(0),
       requested_framerate_(0),
       requested_subsequent_bitrate_(0),
-      requested_subsequent_framerate_(0) {
+      requested_subsequent_framerate_(0),
+      output_frame_count_(0) {
   if (keyframe_period_)
     LOG_ASSERT(kMaxKeyframeDelay < keyframe_period_);
 
   // Fake encoder produces an invalid stream, so skip validating it.
   if (!g_fake_encoder) {
     stream_validator_ = StreamValidator::Create(
         test_stream_->requested_profile,
         base::Bind(&VEAClient::HandleEncodedFrame, base::Unretained(this)));
     CHECK(stream_validator_);
   }
@@ skipping 204 matching lines @@
         base::Bind(&VEAClient::OnInputTimer, base::Unretained(this)));
   } else {
     while (inputs_at_client_.size() <
            num_required_input_buffers_ + kNumExtraInputFrames)
       FeedEncoderWithOneInput();
   }
 }
 
 void VEAClient::BitstreamBufferReady(int32_t bitstream_buffer_id,
                                      size_t payload_size,
-                                     bool key_frame) {
+                                     bool key_frame,
+                                     base::TimeDelta timestamp) {
   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());
   base::SharedMemory* shm = it->second;
   output_buffers_at_client_.erase(it);
 
   if (state_ == CS_FINISHED || state_ == CS_VALIDATED)
     return;
 
+  ASSERT_GT(frame_timestamps_.size(), output_frame_count_);
+  ASSERT_EQ(timestamp, frame_timestamps_[output_frame_count_]);
+  ++output_frame_count_;
+
   encoded_stream_size_since_last_check_ += payload_size;
 
   const uint8_t* stream_ptr = static_cast<const uint8_t*>(shm->memory());
   if (payload_size > 0) {
     if (stream_validator_) {
       stream_validator_->ProcessStreamBuffer(stream_ptr, payload_size);
     } else {
       HandleEncodedFrame(key_frame);
     }
 
@@ skipping 118 matching lines @@
     // we require for bitrate tests.
     pos_in_input_stream_ = 0;
   }
 
   if (quality_validator_)
     quality_validator_->AddOriginalFrame(CreateFrame(pos_in_input_stream_));
 
   int32_t input_id;
   scoped_refptr<media::VideoFrame> video_frame =
       PrepareInputFrame(pos_in_input_stream_, &input_id);
+  frame_timestamps_.push_back(video_frame->timestamp());
   pos_in_input_stream_ += test_stream_->aligned_buffer_size;
 
   bool force_keyframe = false;
   if (keyframe_period_ && input_id % keyframe_period_ == 0) {
     force_keyframe = true;
     ++num_keyframes_requested_;
   }
 
   if (input_id == 0) {
     first_frame_start_time_ = base::TimeTicks::Now();
@@ skipping 403 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();
 }