Fix issue with zero rtt reports when using FlexFEC and add perf test.

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 137 matching lines @@
                 const std::string& graph_title,
                 uint32_t ssrc_to_analyze,
                 uint32_t rtx_ssrc_to_analyze,
                 size_t selected_stream,
                 int selected_sl,
                 int selected_tl,
                 bool is_quick_test_enabled,
                 Clock* clock)
       : transport_(transport),
         receiver_(nullptr),
+        call_(nullptr),
         send_stream_(nullptr),
         receive_stream_(nullptr),
         captured_frame_forwarder_(this, clock),
         test_label_(test_label),
         graph_data_output_file_(graph_data_output_file),
         graph_title_(graph_title),
         ssrc_to_analyze_(ssrc_to_analyze),
         rtx_ssrc_to_analyze_(rtx_ssrc_to_analyze),
         selected_stream_(selected_stream),
         selected_sl_(selected_sl),
         selected_tl_(selected_tl),
         pre_encode_proxy_(this),
         encode_timing_proxy_(this),
+        last_fec_bytes_(0),
         frames_to_process_(duration_frames),
         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),
         total_media_bytes_(0),
         first_sending_time_(0),
@@ skipping 42 matching lines @@
 
   virtual void SetReceiver(PacketReceiver* receiver) { receiver_ = receiver; }
 
   void SetSource(test::VideoCapturer* video_capturer, bool respect_sink_wants) {
     if (respect_sink_wants)
       captured_frame_forwarder_.SetSource(video_capturer);
     rtc::VideoSinkWants wants;
     video_capturer->AddOrUpdateSink(InputInterface(), wants);
   }
 
+  void SetCall(Call* call) {
+    rtc::CritScope lock(&crit_);
+    RTC_DCHECK(!call_);
+    call_ = call;
+  }
+
   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;
@@ skipping 400 matching lines @@
   }
 
   static void PollStatsThread(void* obj) {
     static_cast<VideoAnalyzer*>(obj)->PollStats();
   }
 
   void PollStats() {
     while (!done_.Wait(kSendStatsPollingIntervalMs)) {
       rtc::CritScope crit(&comparison_lock_);
 
+      Call::Stats call_stats = call_->GetStats();
+      send_bandwidth_bps_.AddSample(call_stats.send_bandwidth_bps);
+
       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 (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);
+      size_t fec_bytes = 0;
+      for (auto kv : send_stats.substreams) {
+        fec_bytes += kv.second.rtp_stats.fec.payload_bytes +
+                     kv.second.rtp_stats.fec.padding_bytes;
+      }
+      fec_bitrate_bps_.AddSample((fec_bytes - last_fec_bytes_) * 8);
+      last_fec_bytes_ = fec_bytes;
 
       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);
       }
 
       memory_usage_.AddSample(rtc::GetProcessResidentSizeBytes());
@@ skipping 83 matching lines @@
     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("encode_frame_rate", encode_frame_rate_, " fps");
     PrintResult("encode_time", encode_time_ms_, " ms");
     PrintResult("media_bitrate", media_bitrate_bps_, " bps");
+    PrintResult("fec_bitrate", fec_bitrate_bps_, " bps");
+    PrintResult("send_bandwidth", send_bandwidth_bps_, " bps");
 
     if (receive_stream_ != nullptr) {
       PrintResult("decode_time", decode_time_ms_, " ms");
     }
 
     printf("RESULT dropped_frames: %s = %d frames\n", test_label_.c_str(),
            dropped_frames_);
     printf("RESULT cpu_usage: %s = %lf %%\n", test_label_.c_str(),
            GetCpuUsagePercent());
 
@@ skipping 185 matching lines @@
     rtc::VideoSinkInterface<VideoFrame>* send_stream_input_ GUARDED_BY(crit_);
     test::VideoCapturer* video_capturer_;
     Clock* clock_;
   };
 
   void AddCapturedFrameForComparison(const VideoFrame& video_frame) {
     rtc::CritScope lock(&crit_);
     frames_.push_back(video_frame);
   }
 
+  Call* call_;
   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_;
   const uint32_t rtx_ssrc_to_analyze_;
   const size_t selected_stream_;
   const int selected_sl_;
   const int selected_tl_;
   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 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_);
+  test::Statistics fec_bitrate_bps_ GUARDED_BY(comparison_lock_);
+  test::Statistics send_bandwidth_bps_ GUARDED_BY(comparison_lock_);
   test::Statistics memory_usage_ GUARDED_BY(comparison_lock_);
 
+  size_t last_fec_bytes_;
 
   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_;
   int64_t total_media_bytes_;
@@ skipping 698 matching lines @@
       &send_transport, params_.analyzer.test_label,
       params_.analyzer.avg_psnr_threshold, params_.analyzer.avg_ssim_threshold,
       is_quick_test_enabled
           ? kFramesSentInQuickTest
           : params_.analyzer.test_durations_secs * params_.video.fps,
       graph_data_output_file, graph_title,
       kVideoSendSsrcs[params_.ss.selected_stream],
       kSendRtxSsrcs[params_.ss.selected_stream],
       static_cast<size_t>(params_.ss.selected_stream), params.ss.selected_sl,
       params_.video.selected_tl, is_quick_test_enabled, clock_);
+  analyzer.SetCall(sender_call_.get());
   analyzer.SetReceiver(receiver_call_->Receiver());
   send_transport.SetReceiver(&analyzer);
   recv_transport.SetReceiver(sender_call_->Receiver());
 
   SetupVideo(&analyzer, &recv_transport);
   SetupThumbnails(&analyzer, &recv_transport);
   video_receive_configs_[params_.ss.selected_stream].renderer = &analyzer;
   video_send_config_.pre_encode_callback = analyzer.pre_encode_proxy();
   RTC_DCHECK(!video_send_config_.post_encode_callback);
   video_send_config_.post_encode_callback = analyzer.encode_timing_proxy();
@@ skipping 289 matching lines @@
   if (!params_.video.encoded_frame_base_path.empty()) {
     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