Use webrtc::VideoFrame timestamp in RTCVideoEncoder

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>
@@ skipping 946 matching lines @@
   unsigned int num_required_input_buffers_;
   size_t output_buffer_size_;
 
   // Number of frames to encode. This may differ from the number of frames in
   // stream if we need more frames for bitrate tests.
   unsigned int num_frames_to_encode_;
 
   // Number of encoded frames we've got from the encoder thus far.
   unsigned int num_encoded_frames_;
 
+  // Number of encoded nal units.
+  unsigned int num_encoded_nalus_;
+
   // Frames since last bitrate verification.
   unsigned int num_frames_since_last_check_;
 
   // True if received a keyframe while processing current bitstream buffer.
   bool seen_keyframe_in_this_buffer_;
 
   // True if we are to save the encoded stream to a file.
   bool save_to_file_;
 
   // Request a keyframe every keyframe_period_ frames.
@@ skipping 77 matching lines @@
     : state_(CS_CREATED),
       test_stream_(test_stream),
       note_(note),
       next_input_id_(0),
       next_output_buffer_id_(0),
       pos_in_input_stream_(0),
       num_required_input_buffers_(0),
       output_buffer_size_(0),
       num_frames_to_encode_(0),
       num_encoded_frames_(0),
+      num_encoded_nalus_(0),
       num_frames_since_last_check_(0),
       seen_keyframe_in_this_buffer_(false),
       save_to_file_(save_to_file),
       keyframe_period_(keyframe_period),
       num_keyframes_requested_(0),
       next_keyframe_at_(0),
       force_bitrate_(force_bitrate),
       current_requested_bitrate_(0),
       current_framerate_(0),
       encoded_stream_size_since_last_check_(0),
@@ skipping 452 matching lines @@
 
   last_frame_ready_time_ = base::TimeTicks::Now();
 
   if (g_env->needs_encode_latency()) {
     LOG_ASSERT(num_encoded_frames_ < encode_start_time_.size());
     base::TimeTicks start_time = encode_start_time_[num_encoded_frames_];
     LOG_ASSERT(!start_time.is_null());
     encode_latencies_.push_back(last_frame_ready_time_ - start_time);
   }
 
-  ++num_encoded_frames_;
+  // H264 encoder sends multiple NAL units, 2 per frame.
+  if (test_stream_->requested_profile == H264PROFILE_BASELINE) {
+    ++num_encoded_nalus_;
+    num_encoded_frames_ = num_encoded_nalus_ / 2;

[wuchengli, 2016/08/03 14:03:57]

Hmm. Maybe we should increase num_encoded_frames_ only when BitstreamBufferReady
returns a timestamp different from the last one. Let me discuss with Pawel
tomorrow.

[wuchengli, 2016/08/05 02:10:28]

I discussed with Pawel. Normally we get one slice NAL. Sometimes we may get
multiple. But in general this may be any number of NALUs. We can't make any
assumptions about this. For example, we could get 20 type 6 NALUs or 10 SPSes in
a row. All is valid and up to spec.

The solution is we should only increase num_encoded_frames_ when the timestamps
of BitstreamBufferReady is different from the last one. In
VEAClient::CreateFrame (line 1433), we make sure the timestamps of every input
buffer is different. We can count the number of timestamps of
BitstreamBufferReady to know num_encoded_frames_.

The increment of num_encoded_frames_ should be moved to
VEAClient::BitstreamBufferReady because we have timetsamps information there.

+  } else {
+    ++num_encoded_frames_;
+  }
   ++num_frames_since_last_check_;
 
   // Because the keyframe behavior requirements are loose, we give
   // the encoder more freedom here. It could either deliver a keyframe
   // immediately after we requested it, which could be for a frame number
   // before the one we requested it for (if the keyframe request
   // is asynchronous, i.e. not bound to any concrete frame, and because
   // the pipeline can be deeper than one frame), at that frame, or after.
   // So the only constraints we put here is that we get a keyframe not
   // earlier than we requested one (in time), and not later than
@@ skipping 282 matching lines @@
                         VideoEncodeAcceleratorTest,
                         ::testing::Values(std::make_tuple(3,
                                                           false,
                                                           0,
                                                           false,
                                                           false,
                                                           false,
                                                           false,
                                                           false,
                                                           false)));
+
+#if defined(OS_MACOSX)
+INSTANTIATE_TEST_CASE_P(
+    VerifyTimestamp,
+    VideoEncodeAcceleratorTest,
+    ::testing::Values(
+        std::make_tuple(1, false, 0, false, false, false, false, false, true)));
+#endif  // defined(OS_MACOSX)
+
 #if defined(OS_WIN)
 INSTANTIATE_TEST_CASE_P(
     ForceBitrate,
     VideoEncodeAcceleratorTest,
     ::testing::Values(
         std::make_tuple(1, false, 0, true, false, false, false, false, false)));
 #endif  // defined(OS_WIN)
 
 #endif  // defined(OS_CHROMEOS)
 
@@ skipping 85 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();
 }