Initialize/configure video encoders asychronously.

webrtc/video/video_quality_test.cc

Index: webrtc/video/video_quality_test.cc
diff --git a/webrtc/video/video_quality_test.cc b/webrtc/video/video_quality_test.cc
index 84dbb5104e7c970a0634857cdb82b018e56c02a7..5be9f1ba5745769369082a01011549192e1a28d7 100644
--- a/webrtc/video/video_quality_test.cc
+++ b/webrtc/video/video_quality_test.cc
@@ -43,6 +43,7 @@ static const int kPayloadTypeVP9 = 124;
 
 class VideoAnalyzer : public PacketReceiver,
                       public Transport,
+                      public I420FrameCallback,
                       public VideoRenderer,
                       public VideoCaptureInput,
                       public EncodedFrameObserver {
@@ -68,6 +69,8 @@ class VideoAnalyzer : public PacketReceiver,
         frames_recorded_(0),
         frames_processed_(0),
         dropped_frames_(0),
+        dropped_frames_before_first_encode_(0),
+        dropped_frames_before_rendering_(0),
         last_render_time_(0),
         rtp_timestamp_delta_(0),
         avg_psnr_threshold_(avg_psnr_threshold),
@@ -136,18 +139,26 @@ class VideoAnalyzer : public PacketReceiver,
   void IncomingCapturedFrame(const VideoFrame& video_frame) override {
     VideoFrame copy = video_frame;
     copy.set_timestamp(copy.ntp_time_ms() * 90);
-
     {
       rtc::CritScope lock(&crit_);
-      if (first_send_frame_.IsZeroSize() && rtp_timestamp_delta_ == 0)
-        first_send_frame_ = copy;
-
       frames_.push_back(copy);
     }
 
     input_->IncomingCapturedFrame(video_frame);
   }
 
+  void FrameCallback(VideoFrame* video_frame) {
+    rtc::CritScope lock(&crit_);
+    if (first_send_frame_.IsZeroSize() && rtp_timestamp_delta_ == 0) {
+      while (frames_.front().timestamp() != video_frame->timestamp()) {
+        ++dropped_frames_before_first_encode_;
+        frames_.pop_front();
+        RTC_CHECK(!frames_.empty());
+      }
+      first_send_frame_ = *video_frame;
+    }
+  }
+
   bool SendRtp(const uint8_t* packet,
                size_t length,
                const PacketOptions& options) override {
@@ -162,7 +173,7 @@ class VideoAnalyzer : public PacketReceiver,
       rtc::CritScope lock(&crit_);
       int64_t timestamp = wrap_handler_.Unwrap(header.timestamp);
 
-      if (rtp_timestamp_delta_ == 0) {
+      if (!first_send_frame_.IsZeroSize()) {
         rtp_timestamp_delta_ = timestamp - first_send_frame_.timestamp();
         first_send_frame_.Reset();
       }
@@ -195,10 +206,19 @@ class VideoAnalyzer : public PacketReceiver,
 
     rtc::CritScope lock(&crit_);
 
-    while (frames_.front().timestamp() < send_timestamp) {
+    while (frames_.front().timestamp() != send_timestamp) {
+      if (last_rendered_frame_.IsZeroSize()) {
+        // No previous frame rendered, this one was dropped after sending but
+        // before rendering.
+        ++dropped_frames_before_rendering_;
+        frames_.pop_front();
+        RTC_CHECK(!frames_.empty());
+        continue;
+      }
       AddFrameComparison(frames_.front(), last_rendered_frame_, true,
                          render_time_ms);
       frames_.pop_front();
+      RTC_DCHECK(!frames_.empty());
     }
 
     VideoFrame reference_frame = frames_.front();
@@ -349,6 +369,7 @@ class VideoAnalyzer : public PacketReceiver,
                           bool dropped,
                           int64_t render_time_ms)
       EXCLUSIVE_LOCKS_REQUIRED(crit_) {
+    RTC_DCHECK(!render.IsZeroSize());
     int64_t reference_timestamp = wrap_handler_.Unwrap(reference.timestamp());
     int64_t send_time_ms = send_times_[reference_timestamp];
     send_times_.erase(reference_timestamp);
@@ -483,6 +504,10 @@ class VideoAnalyzer : public PacketReceiver,
     PrintResult("sender_time", sender_time_, " ms");
     printf("RESULT dropped_frames: %s = %d frames\n", test_label_.c_str(),
            dropped_frames_);
+    printf("RESULT dropped_frames_before_first_encode: %s = %d frames\n",
+           test_label_.c_str(), dropped_frames_before_first_encode_);
+    printf("RESULT dropped_frames_before_rendering: %s = %d frames\n",
+           test_label_.c_str(), dropped_frames_before_rendering_);

[stefan-webrtc, 2016/03/14 13:14:03]

It's a bit weird that we mix PrintResult with printfs. Could you please align
(either way)?

[pbos-webrtc, 2016/03/14 15:12:58]

Done.

     PrintResult("receiver_time", receiver_time_, " ms");
     PrintResult("total_delay_incl_network", end_to_end_, " ms");
     PrintResult("time_between_rendered_frames", rendered_delta_, " ms");
@@ -606,6 +631,8 @@ class VideoAnalyzer : public PacketReceiver,
   int frames_recorded_;
   int frames_processed_;
   int dropped_frames_;
+  int dropped_frames_before_first_encode_;
+  int dropped_frames_before_rendering_;
   int64_t last_render_time_;
   uint32_t rtp_timestamp_delta_;
 
@@ -999,6 +1026,7 @@ void VideoQualityTest::RunWithAnalyzer(const Params& params) {
 
   SetupCommon(&analyzer, &recv_transport);
   video_receive_configs_[params_.ss.selected_stream].renderer = &analyzer;
+  video_send_config_.pre_encode_callback = &analyzer;
   for (auto& config : video_receive_configs_)
     config.pre_decode_callback = &analyzer;
   RTC_DCHECK(!video_send_config_.post_encode_callback);