Add sent framerates to histogram stats:

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 <map>
 
 #include "webrtc/base/checks.h"
 
 #include "webrtc/system_wrappers/interface/critical_section_wrapper.h"
 #include "webrtc/system_wrappers/interface/logging.h"
+#include "webrtc/system_wrappers/interface/metrics.h"
 
 namespace webrtc {
 
 const int SendStatisticsProxy::kStatsTimeoutMs = 5000;
 
 SendStatisticsProxy::SendStatisticsProxy(Clock* clock,
                                          const VideoSendStream::Config& config)
     : clock_(clock),
-      config_(config) {
+      config_(config),
+      last_sent_frame_timestamp_(0) {
 }
 
-SendStatisticsProxy::~SendStatisticsProxy() {}
+SendStatisticsProxy::~SendStatisticsProxy() {
+  UpdateHistograms();
+}
+
+void SendStatisticsProxy::UpdateHistograms() {

[pbos-webrtc, 2015/06/12 13:03:47]

See if EXCLUSIVE_LOCKS_REQUIRED(crit_) means that you can run this from the
destructor without taking crit_ inside this function.

+  int input_fps;
+  int sent_fps;
+  {
+    rtc::CritScope lock(&crit_);
+    input_fps =
+        static_cast<int>(input_frame_rate_tracker_total_.units_second());
+    sent_fps = static_cast<int>(sent_frame_rate_tracker_total_.units_second());
+  }
+  if (input_fps > 0)
+    RTC_HISTOGRAM_COUNTS_100("WebRTC.Video.InputFramesPerSecond", input_fps);
+  if (sent_fps > 0)
+    RTC_HISTOGRAM_COUNTS_100("WebRTC.Video.SentFramesPerSecond", sent_fps);
+}
 
 void SendStatisticsProxy::OutgoingRate(const int video_channel,
                                        const unsigned int framerate,
                                        const unsigned int bitrate) {
   rtc::CritScope lock(&crit_);
   stats_.encode_frame_rate = framerate;
   stats_.media_bitrate_bps = bitrate;
 }
 
 void SendStatisticsProxy::CpuOveruseMetricsUpdated(
@@ skipping 77 matching lines @@
   uint32_t ssrc = config_.rtp.ssrcs[simulcast_idx];
 
   rtc::CritScope lock(&crit_);
   VideoSendStream::StreamStats* stats = GetStatsEntry(ssrc);
   if (stats == nullptr)
     return;
 
   stats->width = encoded_image._encodedWidth;
   stats->height = encoded_image._encodedHeight;
   update_times_[ssrc].resolution_update_ms = clock_->TimeInMilliseconds();
+  if (encoded_image._timeStamp != last_sent_frame_timestamp_) {
+    last_sent_frame_timestamp_ = encoded_image._timeStamp;
+    sent_frame_rate_tracker_total_.Update(1);
+  }
 }
 
 void SendStatisticsProxy::OnIncomingFrame() {
   rtc::CritScope lock(&crit_);
   input_frame_rate_tracker_.Update(1);
+  input_frame_rate_tracker_total_.Update(1);
 }
 
 void SendStatisticsProxy::RtcpPacketTypesCounterUpdated(
     uint32_t ssrc,
     const RtcpPacketTypeCounter& packet_counter) {
   rtc::CritScope lock(&crit_);
   VideoSendStream::StreamStats* stats = GetStatsEntry(ssrc);
   if (stats == nullptr)
     return;
 
@@ skipping 51 matching lines @@
                                                uint32_t ssrc) {
   rtc::CritScope lock(&crit_);
   VideoSendStream::StreamStats* stats = GetStatsEntry(ssrc);
   if (stats == nullptr)
     return;
   stats->avg_delay_ms = avg_delay_ms;
   stats->max_delay_ms = max_delay_ms;
 }
 
 }  // namespace webrtc