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 {
+// 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,
 };
 
 HistogramCodecType PayloadNameToHistogramCodecType(
@@ skipping 84 matching lines @@
   }
   int delay_ms = delay_counter_.Avg(kMinRequiredSamples);
   if (delay_ms != -1)
     RTC_HISTOGRAM_COUNTS_100000("WebRTC.Video.SendSideDelayInMs", delay_ms);
 
   int max_delay_ms = max_delay_counter_.Avg(kMinRequiredSamples);
   if (max_delay_ms != -1) {
     RTC_HISTOGRAM_COUNTS_100000(
         "WebRTC.Video.SendSideDelayMaxInMs", max_delay_ms);
   }
+  int send_delay_ms = send_delay_counter_.Avg(kMinRequiredSamples);
+  if (send_delay_ms != -1) {
+    RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.SendDelayInMs", send_delay_ms);
+  }
 }
 
 void SendStatisticsProxy::OnOutgoingRate(uint32_t framerate, uint32_t bitrate) {
   rtc::CritScope lock(&crit_);
   stats_.encode_frame_rate = framerate;
   stats_.media_bitrate_bps = bitrate;
 }
 
 void SendStatisticsProxy::CpuOveruseMetricsUpdated(
     const CpuOveruseMetrics& metrics) {
@@ skipping 201 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;
 
   delay_counter_.Add(avg_delay_ms);
   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;
+
+  Packet packet;
+  packet.cap_time_ms = capture_time_ms;
+  packet.send_time_ms = now;
+  packets_[packet_id] = packet;
+}
+
+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): Use diff to cap_time_ms to update delay_counter_.
+  int diff_send = clock_->TimeInMilliseconds() - it->second.send_time_ms;
+  send_delay_counter_.Add(diff_send);
+  packets_.erase(it);

[pbos-webrtc, 2015/12/07 06:05:52]

This means that we can't update packets' send time from both webrtc and talk/
right?

[åsapersson, 2015/12/08 12:50:15]

OnSendPacket is called from webrtc
OnSentPacket is called from talk

Will think of a better name for OnSendPacket.

+  return true;
+}
+
+void SendStatisticsProxy::RemoveOld(int64_t now, PacketMap* packets) {
+  while (!packets->empty()) {
+    auto it = packets->begin();
+    if (now - it->second.cap_time_ms < kMaxSentPacketDelayMs) {
+      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 15 matching lines @@
 }
 
 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