Add metric for decode time and max decode time in video quality tests.

webrtc/video/video_quality_test.cc

 /*
  *  Copyright (c) 2015 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 #include "webrtc/video/video_quality_test.h"
@@ skipping 119 matching lines @@
                 const std::string& test_label,
                 double avg_psnr_threshold,
                 double avg_ssim_threshold,
                 int duration_frames,
                 FILE* graph_data_output_file,
                 const std::string& graph_title,
                 uint32_t ssrc_to_analyze)
       : transport_(transport),
         receiver_(nullptr),
         send_stream_(nullptr),
+        receive_stream_(nullptr),
         captured_frame_forwarder_(this),
         test_label_(test_label),
         graph_data_output_file_(graph_data_output_file),
         graph_title_(graph_title),
         ssrc_to_analyze_(ssrc_to_analyze),
         pre_encode_proxy_(this),
         encode_timing_proxy_(this),
         frames_to_process_(duration_frames),
         frames_recorded_(0),
         frames_processed_(0),
@@ skipping 42 matching lines @@
   }
 
   virtual void SetReceiver(PacketReceiver* receiver) { receiver_ = receiver; }
 
   void SetSendStream(VideoSendStream* stream) {
     rtc::CritScope lock(&crit_);
     RTC_DCHECK(!send_stream_);
     send_stream_ = stream;
   }
 
+  void SetReceiveStream(VideoReceiveStream* stream) {
+    rtc::CritScope lock(&crit_);
+    RTC_DCHECK(!receive_stream_);
+    receive_stream_ = stream;
+  }
+
   rtc::VideoSinkInterface<VideoFrame>* InputInterface() {
     return &captured_frame_forwarder_;
   }
   rtc::VideoSourceInterface<VideoFrame>* OutputInterface() {
     return &captured_frame_forwarder_;
   }
 
   DeliveryStatus DeliverPacket(MediaType media_type,
                                const uint8_t* packet,
                                size_t length,
@@ skipping 313 matching lines @@
   }
 
   static bool PollStatsThread(void* obj) {
     return static_cast<VideoAnalyzer*>(obj)->PollStats();
   }
 
   bool PollStats() {
     if (done_.Wait(kSendStatsPollingIntervalMs))
       return false;
 
-    VideoSendStream::Stats stats = send_stream_->GetStats();
+    rtc::CritScope crit(&comparison_lock_);

[sprang_webrtc, 2017/01/19 12:09:30]

Why move the lock to include getting the send stats?

[philipel, 2017/01/19 15:11:39]

I did it to avoid one null check. If we get the stats before we take the lock
then we would need a null check here and the one below.

 
-    rtc::CritScope crit(&comparison_lock_);
+    VideoSendStream::Stats send_stats = send_stream_->GetStats();
     // It's not certain that we yet have estimates for any of these stats. Check
     // that they are positive before mixing them in.
-    if (stats.encode_frame_rate > 0)
-      encode_frame_rate_.AddSample(stats.encode_frame_rate);
-    if (stats.avg_encode_time_ms > 0)
-      encode_time_ms.AddSample(stats.avg_encode_time_ms);
-    if (stats.encode_usage_percent > 0)
-      encode_usage_percent.AddSample(stats.encode_usage_percent);
-    if (stats.media_bitrate_bps > 0)
-      media_bitrate_bps.AddSample(stats.media_bitrate_bps);
+    if (send_stats.encode_frame_rate > 0)
+      encode_frame_rate_.AddSample(send_stats.encode_frame_rate);
+    if (send_stats.avg_encode_time_ms > 0)
+      encode_time_ms_.AddSample(send_stats.avg_encode_time_ms);
+    if (send_stats.encode_usage_percent > 0)
+      encode_usage_percent_.AddSample(send_stats.encode_usage_percent);
+    if (send_stats.media_bitrate_bps > 0)
+      media_bitrate_bps_.AddSample(send_stats.media_bitrate_bps);
+
+    if (receive_stream_ != nullptr) {
+      VideoReceiveStream::Stats receive_stats = receive_stream_->GetStats();
+      if (receive_stats.decode_ms > 0)
+        decode_time_ms_.AddSample(receive_stats.decode_ms);
+      if (receive_stats.max_decode_ms > 0)
+        decode_time_max_ms_.AddSample(receive_stats.max_decode_ms);
+    }
 
     return true;
   }
 
   static bool FrameComparisonThread(void* obj) {
     return static_cast<VideoAnalyzer*>(obj)->CompareFrames();
   }
 
   bool CompareFrames() {
     if (AllFramesRecorded())
@@ skipping 68 matching lines @@
   void PrintResults() {
     rtc::CritScope crit(&comparison_lock_);
     PrintResult("psnr", psnr_, " dB");
     PrintResult("ssim", ssim_, " score");
     PrintResult("sender_time", sender_time_, " ms");
     PrintResult("receiver_time", receiver_time_, " ms");
     PrintResult("total_delay_incl_network", end_to_end_, " ms");
     PrintResult("time_between_rendered_frames", rendered_delta_, " ms");
     PrintResult("encoded_frame_size", encoded_frame_size_, " bytes");
     PrintResult("encode_frame_rate", encode_frame_rate_, " fps");
-    PrintResult("encode_time", encode_time_ms, " ms");
-    PrintResult("encode_usage_percent", encode_usage_percent, " percent");
-    PrintResult("media_bitrate", media_bitrate_bps, " bps");
+    PrintResult("encode_time", encode_time_ms_, " ms");
+    PrintResult("encode_usage_percent", encode_usage_percent_, " percent");
+    PrintResult("media_bitrate", media_bitrate_bps_, " bps");
+
+    if (receive_stream_ != nullptr) {
+      PrintResult("decode_time", decode_time_ms_, " ms");
+      PrintResult("decode_time_max", decode_time_max_ms_, " 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_);
 
     EXPECT_GT(psnr_.Mean(), avg_psnr_threshold_);
     EXPECT_GT(ssim_.Mean(), avg_ssim_threshold_);
@@ skipping 150 matching lines @@
     rtc::CritScope lock(&crit_);
     RTC_DCHECK_EQ(0, video_frame.timestamp());
     // Frames from the capturer does not have a rtp timestamp. Create one so it
     // can be used for comparison.
     VideoFrame copy = video_frame;
     copy.set_timestamp(copy.ntp_time_ms() * 90);
     frames_.push_back(copy);
   }
 
   VideoSendStream* send_stream_;
+  VideoReceiveStream* receive_stream_;
   CapturedFrameForwarder captured_frame_forwarder_;
   const std::string test_label_;
   FILE* const graph_data_output_file_;
   const std::string graph_title_;
   const uint32_t ssrc_to_analyze_;
   PreEncodeProxy pre_encode_proxy_;
   OnEncodeTimingProxy encode_timing_proxy_;
   std::vector<Sample> samples_ GUARDED_BY(comparison_lock_);
   std::map<int64_t, int> samples_encode_time_ms_ GUARDED_BY(comparison_lock_);
   test::Statistics sender_time_ GUARDED_BY(comparison_lock_);
   test::Statistics receiver_time_ GUARDED_BY(comparison_lock_);
   test::Statistics psnr_ GUARDED_BY(comparison_lock_);
   test::Statistics ssim_ GUARDED_BY(comparison_lock_);
   test::Statistics end_to_end_ GUARDED_BY(comparison_lock_);
   test::Statistics rendered_delta_ GUARDED_BY(comparison_lock_);
   test::Statistics encoded_frame_size_ GUARDED_BY(comparison_lock_);
   test::Statistics encode_frame_rate_ GUARDED_BY(comparison_lock_);
-  test::Statistics encode_time_ms GUARDED_BY(comparison_lock_);
-  test::Statistics encode_usage_percent GUARDED_BY(comparison_lock_);
-  test::Statistics media_bitrate_bps GUARDED_BY(comparison_lock_);
+  test::Statistics encode_time_ms_ GUARDED_BY(comparison_lock_);
+  test::Statistics encode_usage_percent_ GUARDED_BY(comparison_lock_);
+  test::Statistics decode_time_ms_ GUARDED_BY(comparison_lock_);
+  test::Statistics decode_time_max_ms_ GUARDED_BY(comparison_lock_);
+  test::Statistics media_bitrate_bps_ GUARDED_BY(comparison_lock_);
 
   const int frames_to_process_;
   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_;
 
@@ skipping 463 matching lines @@
     config.pre_decode_callback = &analyzer;
   RTC_DCHECK(!video_send_config_.post_encode_callback);
   video_send_config_.post_encode_callback = analyzer.encode_timing_proxy();
 
   if (params_.screenshare.enabled)
     SetupScreenshare();
 
   CreateFlexfecStreams();
   CreateVideoStreams();
   analyzer.SetSendStream(video_send_stream_);
+  if (video_receive_streams_.size() == 1)
+    analyzer.SetReceiveStream(video_receive_streams_[0]);
   video_send_stream_->SetSource(
       analyzer.OutputInterface(),
       VideoSendStream::DegradationPreference::kBalanced);
 
   CreateCapturer();
   rtc::VideoSinkWants wants;
   video_capturer_->AddOrUpdateSink(analyzer.InputInterface(), wants);
 
   StartEncodedFrameLogs(video_send_stream_);
   StartEncodedFrameLogs(video_receive_streams_[0]);
@@ skipping 215 matching lines @@
     std::ostringstream str;
     str << receive_logs_++;
     std::string path =
         params_.video.encoded_frame_base_path + "." + str.str() + ".recv.ivf";
     stream->EnableEncodedFrameRecording(rtc::CreatePlatformFile(path),
                                         10000000);
   }
 }
 
 }  // namespace webrtc