Add histogram stats for send delay for a sent video stream.

webrtc/video/send_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/send_statistics_proxy.h"
 
 #include <algorithm>
 #include <cmath>
 #include <map>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/system_wrappers/include/critical_section_wrapper.h"
 #include "webrtc/system_wrappers/include/metrics.h"
 
 namespace webrtc {
 namespace {
 const float kEncodeTimeWeigthFactor = 0.5f;
 
+// Packet with a larger delay are removed and excluded from the delay stats.
+// Set to larger than max histogram delay which is 10000.
+const int64_t kMaxSentPacketDelayMs = 11000;
+const size_t kMaxSendPacketMapSize = 2000;
+
 // Used by histograms. Values of entries should not be changed.
 enum HistogramCodecType {
   kVideoUnknown = 0,
   kVideoVp8 = 1,
   kVideoVp9 = 2,
   kVideoH264 = 3,
   kVideoMax = 64,
 };
 
 const char* GetUmaPrefix(VideoEncoderConfig::ContentType content_type) {
@@ skipping 106 matching lines @@
   }
   int delay_ms = delay_counter_.Avg(kMinRequiredSamples);
   if (delay_ms != -1)
     RTC_HISTOGRAM_COUNTS_100000(uma_prefix_ + "SendSideDelayInMs", delay_ms);
 
   int max_delay_ms = max_delay_counter_.Avg(kMinRequiredSamples);
   if (max_delay_ms != -1) {
     RTC_HISTOGRAM_COUNTS_100000(uma_prefix_ + "SendSideDelayMaxInMs",
                                 max_delay_ms);
   }
+  for (const auto& it : send_delay_counters_) {
+    int send_delay_ms = it.second.Avg(kMinRequiredSamples);
+    if (send_delay_ms != -1)
+      RTC_HISTOGRAM_COUNTS_10000(uma_prefix_ + "SendDelayInMs", send_delay_ms);
+  }
 }
 
 void SendStatisticsProxy::SetContentType(
     VideoEncoderConfig::ContentType content_type) {
   rtc::CritScope lock(&crit_);
   if (content_type_ != content_type) {
     uma_container_->UpdateHistograms();
     uma_container_.reset(new UmaSamplesContainer(GetUmaPrefix(content_type)));
     content_type_ = content_type;
   }
@@ skipping 214 matching lines @@
   VideoSendStream::StreamStats* stats = GetStatsEntry(ssrc);
   if (stats == nullptr)
     return;
   stats->avg_delay_ms = avg_delay_ms;
   stats->max_delay_ms = max_delay_ms;
 
   uma_container_->delay_counter_.Add(avg_delay_ms);
   uma_container_->max_delay_counter_.Add(max_delay_ms);
 }
 
+void SendStatisticsProxy::OnSendPacket(uint16_t packet_id,
+                                       int64_t capture_time_ms,
+                                       uint32_t ssrc) {
+  rtc::CritScope lock(&crit_);
+  VideoSendStream::StreamStats* stats = GetStatsEntry(ssrc);
+  if (stats == nullptr)
+    return;
+
+  int64_t now = clock_->TimeInMilliseconds();
+  RemoveOld(now, &packets_);
+
+  if (packets_.size() > kMaxSendPacketMapSize)
+    return;
+
+  packets_.insert(
+      std::make_pair(packet_id, Packet(ssrc, capture_time_ms, now)));
+}
+
+bool SendStatisticsProxy::OnSentPacket(int packet_id) {
+  if (packet_id == -1)
+    return false;
+
+  rtc::CritScope lock(&crit_);
+  auto it = packets_.find(packet_id);
+  if (it == packets_.end())
+    return false;
+
+  // TODO(asapersson): Update delay_counter_ here (capture -> sent).
+  int diff_send = clock_->TimeInMilliseconds() - it->second.send_time_ms_;
+  uma_container_->send_delay_counters_[it->second.ssrc_].Add(diff_send);
+  packets_.erase(it);
+  return true;
+}
+
+void SendStatisticsProxy::RemoveOld(int64_t now, PacketMap* packets) {
+  while (!packets->empty()) {
+    auto it = packets->begin();
+    if (now - it->second.capture_time_ms_ < kMaxSentPacketDelayMs) {

[stefan-webrtc, 2016/01/18 19:48:25]

Feel free to remove {}

[åsapersson, 2016/04/06 14:52:37]

Done.

+      break;
+    }
+    packets->erase(it);
+  }
+}
+
 void SendStatisticsProxy::SampleCounter::Add(int sample) {
   sum += sample;
   ++num_samples;
 }
 
 int SendStatisticsProxy::SampleCounter::Avg(int min_required_samples) const {
   if (num_samples < min_required_samples || num_samples == 0)
     return -1;
   return (sum + (num_samples / 2)) / num_samples;
 }
@@ skipping 14 matching lines @@
   return Fraction(min_required_samples, 1000.0f);
 }
 
 int SendStatisticsProxy::BoolSampleCounter::Fraction(
     int min_required_samples, float multiplier) const {
   if (num_samples < min_required_samples || num_samples == 0)
     return -1;
   return static_cast<int>((sum * multiplier / num_samples) + 0.5f);
 }
 }  // namespace webrtc