Add receive bitrate UMA stats.

webrtc/call/call.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.
  */
 
@@ skipping 15 matching lines @@
 #include "webrtc/call/congestion_controller.h"
 #include "webrtc/call/rtc_event_log.h"
 #include "webrtc/common.h"
 #include "webrtc/config.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_header_parser.h"
 #include "webrtc/modules/rtp_rtcp/source/byte_io.h"
 #include "webrtc/modules/utility/include/process_thread.h"
 #include "webrtc/system_wrappers/include/cpu_info.h"
 #include "webrtc/system_wrappers/include/critical_section_wrapper.h"
 #include "webrtc/system_wrappers/include/logging.h"
+#include "webrtc/system_wrappers/include/metrics.h"
 #include "webrtc/system_wrappers/include/rw_lock_wrapper.h"
 #include "webrtc/system_wrappers/include/trace.h"
 #include "webrtc/video/video_receive_stream.h"
 #include "webrtc/video/video_send_stream.h"
 #include "webrtc/video_engine/call_stats.h"
 #include "webrtc/voice_engine/include/voe_codec.h"
 
 namespace webrtc {
 
 const int Call::Config::kDefaultStartBitrateBps = 300000;
@@ skipping 52 matching lines @@
 
   VoiceEngine* voice_engine() {
     internal::AudioState* audio_state =
         static_cast<internal::AudioState*>(config_.audio_state.get());
     if (audio_state)
       return audio_state->voice_engine();
     else
       return nullptr;
   }
 
+  void UpdateHistograms();
+
+  const Clock* const clock_;
+
   const int num_cpu_cores_;
   const rtc::scoped_ptr<ProcessThread> module_process_thread_;
   const rtc::scoped_ptr<CallStats> call_stats_;
   const rtc::scoped_ptr<CongestionController> congestion_controller_;
   Call::Config config_;
   rtc::ThreadChecker configuration_thread_checker_;
 
  bool network_enabled_;
 
   rtc::scoped_ptr<RWLockWrapper> receive_crit_;
@@ skipping 10 matching lines @@
   rtc::scoped_ptr<RWLockWrapper> send_crit_;
   // Audio and Video send streams are owned by the client that creates them.
   std::map<uint32_t, AudioSendStream*> audio_send_ssrcs_ GUARDED_BY(send_crit_);
   std::map<uint32_t, VideoSendStream*> video_send_ssrcs_ GUARDED_BY(send_crit_);
   std::set<VideoSendStream*> video_send_streams_ GUARDED_BY(send_crit_);
 
   VideoSendStream::RtpStateMap suspended_video_send_ssrcs_;
 
   RtcEventLog* event_log_ = nullptr;
 
+  // The RateTrackers are only accessed (exclusively) from DeliverRtp or
+  // DeliverRtcp, and from the destructor, and therefore doesn't need any
+  // explicit synchronization.
+  rtc::RateTracker received_video_bytes_per_sec_;
+  rtc::RateTracker received_audio_bytes_per_sec_;
+  rtc::RateTracker received_rtcp_bytes_per_sec_;
+  int64_t first_rtp_packet_received_ms_;

[pbos-webrtc, 2015/11/11 16:24:29]

(I assume the corner case where RTCP arrives first isn't very interesting.)

[stefan-webrtc, 2015/11/11 18:15:22]

Its a very slim corner case. If rtcp arrives first, and the stream is 20 secs
from that rtcp, we will not record the stats, since we measure from first rtp...

+
   RTC_DISALLOW_COPY_AND_ASSIGN(Call);
 };
 }  // namespace internal
 
 Call* Call::Create(const Call::Config& config) {
   return new internal::Call(config);
 }
 
 namespace internal {
 
 Call::Call(const Call::Config& config)
-    : num_cpu_cores_(CpuInfo::DetectNumberOfCores()),
+    : clock_(Clock::GetRealTimeClock()),
+      num_cpu_cores_(CpuInfo::DetectNumberOfCores()),
       module_process_thread_(ProcessThread::Create("ModuleProcessThread")),
       call_stats_(new CallStats()),
-      congestion_controller_(new CongestionController(
-          module_process_thread_.get(), call_stats_.get())),
+      congestion_controller_(
+          new CongestionController(module_process_thread_.get(),
+                                   call_stats_.get())),
       config_(config),
       network_enabled_(true),
       receive_crit_(RWLockWrapper::CreateRWLock()),
-      send_crit_(RWLockWrapper::CreateRWLock()) {
+      send_crit_(RWLockWrapper::CreateRWLock()),
+      received_video_bytes_per_sec_(1000, 1),
+      received_audio_bytes_per_sec_(1000, 1),
+      received_rtcp_bytes_per_sec_(1000, 1),
+      first_rtp_packet_received_ms_(-1) {
   RTC_DCHECK_GE(config.bitrate_config.min_bitrate_bps, 0);
   RTC_DCHECK_GE(config.bitrate_config.start_bitrate_bps,
                 config.bitrate_config.min_bitrate_bps);
   if (config.bitrate_config.max_bitrate_bps != -1) {
     RTC_DCHECK_GE(config.bitrate_config.max_bitrate_bps,
                   config.bitrate_config.start_bitrate_bps);
   }
   if (config.audio_state.get()) {
     ScopedVoEInterface<VoECodec> voe_codec(voice_engine());
     event_log_ = voe_codec->GetEventLog();
   }
 
   Trace::CreateTrace();
   module_process_thread_->Start();
   module_process_thread_->RegisterModule(call_stats_.get());
 
   congestion_controller_->SetBweBitrates(
       config_.bitrate_config.min_bitrate_bps,
       config_.bitrate_config.start_bitrate_bps,
       config_.bitrate_config.max_bitrate_bps);
 
   congestion_controller_->GetBitrateController()->SetEventLog(event_log_);
 }
 
 Call::~Call() {
+  UpdateHistograms();
   RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
   RTC_CHECK(audio_send_ssrcs_.empty());
   RTC_CHECK(video_send_ssrcs_.empty());
   RTC_CHECK(video_send_streams_.empty());
   RTC_CHECK(audio_receive_ssrcs_.empty());
   RTC_CHECK(video_receive_ssrcs_.empty());
   RTC_CHECK(video_receive_streams_.empty());
 
   module_process_thread_->DeRegisterModule(call_stats_.get());
   module_process_thread_->Stop();
   Trace::ReturnTrace();
 }
 
+void Call::UpdateHistograms() {
+  if (first_rtp_packet_received_ms_ == -1)
+    return;
+  int64_t elapsed_sec =
+      (clock_->TimeInMilliseconds() - first_rtp_packet_received_ms_) / 1000;
+  if (elapsed_sec < metrics::kMinRunTimeInSeconds)
+    return;
+  int audio_bitrate_kbps =
+      received_audio_bytes_per_sec_.ComputeTotalRate() * 8 / 1000;
+  int video_bitrate_kbps =
+      received_video_bytes_per_sec_.ComputeTotalRate() * 8 / 1000;
+  int rtcp_bitrate_bps = received_rtcp_bytes_per_sec_.ComputeTotalRate() * 8;
+  if (video_bitrate_kbps > 0) {
+    RTC_HISTOGRAM_COUNTS_100000("WebRTC.Call.VideoBitrateReceivedInKbps",
+                                video_bitrate_kbps);
+  }
+  if (audio_bitrate_kbps > 0) {
+    RTC_HISTOGRAM_COUNTS_100000("WebRTC.Call.AudioBitrateReceivedInKbps",
+                                audio_bitrate_kbps);
+  }
+  if (rtcp_bitrate_bps > 0) {
+    RTC_HISTOGRAM_COUNTS_100000("WebRTC.Call.RtcpBitrateReceivedInBps",
+                                rtcp_bitrate_bps);
+  }
+  RTC_HISTOGRAM_COUNTS_100000(
+      "WebRTC.Call.BitrateReceivedInKbps",
+      audio_bitrate_kbps + video_bitrate_kbps + rtcp_bitrate_bps / 1000);
+}
+
 PacketReceiver* Call::Receiver() {
   // TODO(solenberg): Some test cases in EndToEndTest use this from a different
   // thread. Re-enable once that is fixed.
   // RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
   return this;
 }
 
 webrtc::AudioSendStream* Call::CreateAudioSendStream(
     const webrtc::AudioSendStream::Config& config) {
   TRACE_EVENT0("webrtc", "Call::CreateAudioSendStream");
@@ skipping 314 matching lines @@
   }
 }
 
 PacketReceiver::DeliveryStatus Call::DeliverRtcp(MediaType media_type,
                                                  const uint8_t* packet,
                                                  size_t length) {
   // TODO(pbos): Figure out what channel needs it actually.
   //             Do NOT broadcast! Also make sure it's a valid packet.
   //             Return DELIVERY_UNKNOWN_SSRC if it can be determined that
   //             there's no receiver of the packet.
+  received_rtcp_bytes_per_sec_.AddSamples(length);
   bool rtcp_delivered = false;
   if (media_type == MediaType::ANY || media_type == MediaType::VIDEO) {
     ReadLockScoped read_lock(*receive_crit_);
     for (VideoReceiveStream* stream : video_receive_streams_) {
       if (stream->DeliverRtcp(packet, length)) {
         rtcp_delivered = true;
         if (event_log_)
           event_log_->LogRtcpPacket(true, media_type, packet, length);
       }
     }
@@ skipping 12 matching lines @@
 }
 
 PacketReceiver::DeliveryStatus Call::DeliverRtp(MediaType media_type,
                                                 const uint8_t* packet,
                                                 size_t length,
                                                 const PacketTime& packet_time) {
   // Minimum RTP header size.
   if (length < 12)
     return DELIVERY_PACKET_ERROR;
 
+  if (first_rtp_packet_received_ms_ == -1)
+    first_rtp_packet_received_ms_ = clock_->TimeInMilliseconds();
+
   uint32_t ssrc = ByteReader<uint32_t>::ReadBigEndian(&packet[8]);
-
   ReadLockScoped read_lock(*receive_crit_);
   if (media_type == MediaType::ANY || media_type == MediaType::AUDIO) {
     auto it = audio_receive_ssrcs_.find(ssrc);
     if (it != audio_receive_ssrcs_.end()) {
+      received_audio_bytes_per_sec_.AddSamples(length);
       auto status = it->second->DeliverRtp(packet, length, packet_time)
                         ? DELIVERY_OK
                         : DELIVERY_PACKET_ERROR;
       if (status == DELIVERY_OK && event_log_)
         event_log_->LogRtpHeader(true, media_type, packet, length);
       return status;
     }
   }
   if (media_type == MediaType::ANY || media_type == MediaType::VIDEO) {
     auto it = video_receive_ssrcs_.find(ssrc);
     if (it != video_receive_ssrcs_.end()) {
+      received_video_bytes_per_sec_.AddSamples(length);
       auto status = it->second->DeliverRtp(packet, length, packet_time)
                         ? DELIVERY_OK
                         : DELIVERY_PACKET_ERROR;
       if (status == DELIVERY_OK && event_log_)
         event_log_->LogRtpHeader(true, media_type, packet, length);
       return status;
     }
   }
   return DELIVERY_UNKNOWN_SSRC;

[pbos-webrtc, 2015/11/11 16:24:29]

Do you wanna track unknown bitrate as well?

[stefan-webrtc, 2015/11/11 18:15:22]

We can add that later if we see a need.

 }
 
 PacketReceiver::DeliveryStatus Call::DeliverPacket(
     MediaType media_type,
     const uint8_t* packet,
     size_t length,
     const PacketTime& packet_time) {
   // TODO(solenberg): Tests call this function on a network thread, libjingle
   // calls on the worker thread. We should move towards always using a network
   // thread. Then this check can be enabled.
   // RTC_DCHECK(!configuration_thread_checker_.CalledOnValidThread());
   if (RtpHeaderParser::IsRtcp(packet, length))
     return DeliverRtcp(media_type, packet, length);
 
   return DeliverRtp(media_type, packet, length, packet_time);
 }
 
 }  // namespace internal
 }  // namespace webrtc