Logging basic bad call detection

webrtc/video/receive_statistics_proxy.cc

 /*
  *  Copyright (c) 2013 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/receive_statistics_proxy.h"
 
 #include <cmath>
 
 #include "webrtc/base/checks.h"
+#include "webrtc/base/logging.h"
 #include "webrtc/modules/video_coding/include/video_codec_interface.h"
 #include "webrtc/system_wrappers/include/clock.h"
 #include "webrtc/system_wrappers/include/metrics.h"
 
 namespace webrtc {
 
+const int kNumMeasurements = 10;
+const float kBadFraction = 0.8f;
+const int kFpsThreshold = 13;
+const int kDefaultFps = 15;
+const int kQpThreshold = 60;
+const int kDefaultQp = 20;
+
 ReceiveStatisticsProxy::ReceiveStatisticsProxy(
     const VideoReceiveStream::Config* config,
     Clock* clock)
     : clock_(clock),
       config_(*config),
       start_ms_(clock->TimeInMilliseconds()),
       // 1000ms window, scale 1000 for ms to s.
+      last_sample_time_(clock->TimeInMilliseconds()),
+      fps_threshold_(kFpsThreshold,
+                     kDefaultFps,
+                     kBadFraction,
+                     kNumMeasurements),
+      qp_threshold_(kQpThreshold, kDefaultQp, kBadFraction, kNumMeasurements),
       decode_fps_estimator_(1000, 1000),
       renders_fps_estimator_(1000, 1000),
       render_fps_tracker_(100, 10u),
       render_pixel_tracker_(100, 10u) {
   stats_.ssrc = config_.rtp.remote_ssrc;
   for (auto it : config_.rtp.rtx)
     rtx_stats_[it.second.ssrc] = StreamDataCounters();
 }
 
 ReceiveStatisticsProxy::~ReceiveStatisticsProxy() {
@@ skipping 104 matching lines @@
                                counters.fir_packets * 60 / elapsed_sec);
     RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.PliPacketsSentPerMinute",
                                counters.pli_packets * 60 / elapsed_sec);
     if (counters.nack_requests > 0) {
       RTC_HISTOGRAM_PERCENTAGE("WebRTC.Video.UniqueNackRequestsSentInPercent",
                                counters.UniqueNackRequestsInPercent());
     }
   }
 }
 
+void ReceiveStatisticsProxy::BadCallSample() {
+  uint64_t now = clock_->TimeInMilliseconds();
+
+  double fps =
+      render_fps_tracker_.ComputeRateForInterval(now - last_sample_time_);
+  int qp = qp_sample_.Avg(1);
+
+  BadCallThreshold::BadCallState fps_state = fps_threshold_.AddMeasurement(fps);
+  BadCallThreshold::BadCallState qp_state = qp_threshold_.AddMeasurement(qp);
+
+  switch (fps_state) {
+    case BadCallThreshold::NEWLY_HIGH:
+      LOG(LS_WARNING) << "Bad call (fps) end";
+      break;
+    case BadCallThreshold::NEWLY_LOW:
+      LOG(LS_WARNING) << "Bad call (fps) start";
+      break;
+    default:
+      break;
+  }
+
+  switch (qp_state) {
+    case BadCallThreshold::NEWLY_HIGH:
+      LOG(LS_WARNING) << "Bad call (qp) start";
+      break;
+    case BadCallThreshold::NEWLY_LOW:
+      LOG(LS_WARNING) << "Bad call (qp) end";
+      break;
+    default:
+      break;
+  }
+
+  std::string fpsBad;
+  switch (fps_state) {
+    case BadCallThreshold::NEWLY_LOW:
+      fpsBad = "NEWLY_LOW";
+      break;
+    case BadCallThreshold::STILL_LOW:
+      fpsBad = "STILL_LOW";
+      break;
+    case BadCallThreshold::NEWLY_HIGH:
+      fpsBad = "NEWLY_HIGH";
+      break;
+    case BadCallThreshold::STILL_HIGH:
+      fpsBad = "STILL_HIGH";
+      break;
+    default:
+      fpsBad = "WAT";
+  }
+
+  std::string qpBad;
+  switch (qp_state) {
+    case BadCallThreshold::NEWLY_LOW:
+      qpBad = "NEWLY_LOW";
+      break;
+    case BadCallThreshold::STILL_LOW:
+      qpBad = "STILL_LOW";
+      break;
+    case BadCallThreshold::NEWLY_HIGH:
+      qpBad = "NEWLY_HIGH";
+      break;
+    case BadCallThreshold::STILL_HIGH:
+      qpBad = "STILL_HIGH";
+      break;
+    default:
+      qpBad = "WAT";
+  }
+
+  LOG(LS_INFO) << "SAMPLE: sample_length: " << (now - last_sample_time_)
+               << " fps: " << fps << " fpsBad: " << fpsBad << " qp: " << qp
+               << " qpBad: " << qpBad;
+
+  last_sample_time_ = now;
+  qp_sample_.Reset();
+}
+
 VideoReceiveStream::Stats ReceiveStatisticsProxy::GetStats() const {
   rtc::CritScope lock(&crit_);
   return stats_;
 }
 
 void ReceiveStatisticsProxy::OnIncomingPayloadType(int payload_type) {
   rtc::CritScope lock(&crit_);
   stats_.current_payload_type = payload_type;
 }
 
 void ReceiveStatisticsProxy::OnDecoderImplementationName(
     const char* implementation_name) {
   rtc::CritScope lock(&crit_);
   stats_.decoder_implementation_name = implementation_name;
 }
 void ReceiveStatisticsProxy::OnIncomingRate(unsigned int framerate,
                                             unsigned int bitrate_bps) {
   rtc::CritScope lock(&crit_);
+  BadCallSample();
   stats_.network_frame_rate = framerate;
   stats_.total_bitrate_bps = bitrate_bps;
 }
 
 void ReceiveStatisticsProxy::OnDecoderTiming(int decode_ms,
                                              int max_decode_ms,
                                              int current_delay_ms,
                                              int target_delay_ms,
                                              int jitter_buffer_ms,
                                              int min_playout_delay_ms,
@@ skipping 116 matching lines @@
 }
 
 void ReceiveStatisticsProxy::OnPreDecode(
     const EncodedImage& encoded_image,
     const CodecSpecificInfo* codec_specific_info) {
   if (!codec_specific_info || encoded_image.qp_ == -1) {
     return;
   }
   if (codec_specific_info->codecType == kVideoCodecVP8) {
     qp_counters_.vp8.Add(encoded_image.qp_);
+    rtc::CritScope lock(&crit_);
+    qp_sample_.Add(encoded_image.qp_);
   }
 }
 
 void ReceiveStatisticsProxy::SampleCounter::Add(int sample) {
   sum += sample;
   ++num_samples;
 }
 
 int ReceiveStatisticsProxy::SampleCounter::Avg(int min_required_samples) const {
   if (num_samples < min_required_samples || num_samples == 0)
     return -1;
   return sum / num_samples;
 }
 
+void ReceiveStatisticsProxy::SampleCounter::Reset() {
+  num_samples = 0;
+  sum = 0;
+}
+
 }  // namespace webrtc