Add task queue to Call.

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.
  */
 
@@ skipping 57 matching lines @@
 }  // namespace
 
 
 const int SendStatisticsProxy::kStatsTimeoutMs = 5000;
 
 SendStatisticsProxy::SendStatisticsProxy(
     Clock* clock,
     const VideoSendStream::Config& config,
     VideoEncoderConfig::ContentType content_type)
     : clock_(clock),
-      config_(config),
+      payload_name_(config.encoder_settings.payload_name),
+      rtp_config_(config.rtp),
       content_type_(content_type),
       start_ms_(clock->TimeInMilliseconds()),
       last_sent_frame_timestamp_(0),
       encode_time_(kEncodeTimeWeigthFactor),
       uma_container_(
           new UmaSamplesContainer(GetUmaPrefix(content_type_), stats_, clock)) {
 }
 
 SendStatisticsProxy::~SendStatisticsProxy() {
   rtc::CritScope lock(&crit_);
-  uma_container_->UpdateHistograms(config_, stats_);
+  uma_container_->UpdateHistograms(rtp_config_, stats_);
 
   int64_t elapsed_sec = (clock_->TimeInMilliseconds() - start_ms_) / 1000;
   RTC_LOGGED_HISTOGRAM_COUNTS_100000("WebRTC.Video.SendStreamLifetimeInSeconds",
                                      elapsed_sec);
 
   if (elapsed_sec >= metrics::kMinRunTimeInSeconds)
-    UpdateCodecTypeHistogram(config_.encoder_settings.payload_name);
+    UpdateCodecTypeHistogram(payload_name_);
 }
 
 SendStatisticsProxy::UmaSamplesContainer::UmaSamplesContainer(
     const char* prefix,
     const VideoSendStream::Stats& stats,
     Clock* const clock)
     : uma_prefix_(prefix),
       clock_(clock),
       max_sent_width_per_timestamp_(0),
       max_sent_height_per_timestamp_(0),
       input_frame_rate_tracker_(100, 10u),
       sent_frame_rate_tracker_(100, 10u),
       first_rtcp_stats_time_ms_(-1),
       first_rtp_stats_time_ms_(-1),
       start_stats_(stats) {}
 
 SendStatisticsProxy::UmaSamplesContainer::~UmaSamplesContainer() {}
 
-void AccumulateRtpStats(const VideoSendStream::Stats& stats,
-                        const VideoSendStream::Config& config,
+void AccumulateRtxStats(const VideoSendStream::Stats& stats,
+                        const std::vector<uint32_t>& rtx_ssrcs,
                         StreamDataCounters* total_rtp_stats,
                         StreamDataCounters* rtx_stats) {
   for (auto it : stats.substreams) {
-    const std::vector<uint32_t> rtx_ssrcs = config.rtp.rtx.ssrcs;
     if (std::find(rtx_ssrcs.begin(), rtx_ssrcs.end(), it.first) !=
         rtx_ssrcs.end()) {
       rtx_stats->Add(it.second.rtp_stats);
     } else {
       total_rtp_stats->Add(it.second.rtp_stats);
     }
   }
 }
 
 void SendStatisticsProxy::UmaSamplesContainer::UpdateHistograms(
-    const VideoSendStream::Config& config,
+    const VideoSendStream::Config::Rtp& rtp_config,
     const VideoSendStream::Stats& current_stats) {
   RTC_DCHECK(uma_prefix_ == kRealtimePrefix || uma_prefix_ == kScreenPrefix);
   const int kIndex = uma_prefix_ == kScreenPrefix ? 1 : 0;
   const int kMinRequiredSamples = 200;
   int in_width = input_width_counter_.Avg(kMinRequiredSamples);
   int in_height = input_height_counter_.Avg(kMinRequiredSamples);
   int in_fps = round(input_frame_rate_tracker_.ComputeTotalRate());
   if (in_width != -1) {
     RTC_LOGGED_HISTOGRAMS_COUNTS_10000(
         kIndex, uma_prefix_ + "InputWidthInPixels", in_width);
@@ skipping 113 matching lines @@
       }
 
       // The RTCP packet type counters, delivered via the
       // RtcpPacketTypeCounterObserver interface, are aggregates over the entire
       // life of the send stream and are not reset when switching content type.
       // For the purpose of these statistics though, we want new counts when
       // switching since we switch histogram name. On every reset of the
       // UmaSamplesContainer, we save the initial state of the counters, so that
       // we can calculate the delta here and aggregate over all ssrcs.
       RtcpPacketTypeCounter counters;
-      for (uint32_t ssrc : config.rtp.ssrcs) {
+      for (uint32_t ssrc : rtp_config.ssrcs) {
         auto kv = current_stats.substreams.find(ssrc);
         if (kv == current_stats.substreams.end())
           continue;
 
         RtcpPacketTypeCounter stream_counters =
             kv->second.rtcp_packet_type_counts;
         kv = start_stats_.substreams.find(ssrc);
         if (kv != start_stats_.substreams.end())
           stream_counters.Subtract(kv->second.rtcp_packet_type_counts);
 
@@ skipping 15 matching lines @@
       }
     }
   }
 
   if (first_rtp_stats_time_ms_ != -1) {
     int64_t elapsed_sec =
         (clock_->TimeInMilliseconds() - first_rtp_stats_time_ms_) / 1000;
     if (elapsed_sec >= metrics::kMinRunTimeInSeconds) {
       StreamDataCounters rtp;
       StreamDataCounters rtx;
-      AccumulateRtpStats(current_stats, config, &rtp, &rtx);
+      AccumulateRtxStats(current_stats, rtp_config.rtx.ssrcs, &rtp, &rtx);
       StreamDataCounters start_rtp;
       StreamDataCounters start_rtx;
-      AccumulateRtpStats(start_stats_, config, &start_rtp, &start_rtx);
+      AccumulateRtxStats(start_stats_, rtp_config.rtx.ssrcs, &start_rtp,
+                         &start_rtx);
       rtp.Subtract(start_rtp);
       rtx.Subtract(start_rtx);
       StreamDataCounters rtp_rtx = rtp;
       rtp_rtx.Add(rtx);
 
       RTC_LOGGED_HISTOGRAMS_COUNTS_10000(
           kIndex, uma_prefix_ + "BitrateSentInKbps",
           static_cast<int>(rtp_rtx.transmitted.TotalBytes() * 8 / elapsed_sec /
                            1000));
       RTC_LOGGED_HISTOGRAMS_COUNTS_10000(
           kIndex, uma_prefix_ + "MediaBitrateSentInKbps",
           static_cast<int>(rtp.MediaPayloadBytes() * 8 / elapsed_sec / 1000));
       RTC_LOGGED_HISTOGRAMS_COUNTS_10000(
           kIndex, uma_prefix_ + "PaddingBitrateSentInKbps",
           static_cast<int>(rtp_rtx.transmitted.padding_bytes * 8 / elapsed_sec /
                            1000));
       RTC_LOGGED_HISTOGRAMS_COUNTS_10000(
           kIndex, uma_prefix_ + "RetransmittedBitrateSentInKbps",
           static_cast<int>(rtp_rtx.retransmitted.TotalBytes() * 8 /
                            elapsed_sec / 1000));
-      if (!config.rtp.rtx.ssrcs.empty()) {
+      if (!rtp_config.rtx.ssrcs.empty()) {
         RTC_LOGGED_HISTOGRAMS_COUNTS_10000(
             kIndex, uma_prefix_ + "RtxBitrateSentInKbps",
             static_cast<int>(rtx.transmitted.TotalBytes() * 8 / elapsed_sec /
                              1000));
       }
-      if (config.rtp.fec.red_payload_type != -1) {
+      if (rtp_config.fec.red_payload_type != -1) {
         RTC_LOGGED_HISTOGRAMS_COUNTS_10000(
             kIndex, uma_prefix_ + "FecBitrateSentInKbps",
             static_cast<int>(rtp_rtx.fec.TotalBytes() * 8 / elapsed_sec /
                              1000));
       }
     }
   }
 }
 
 void SendStatisticsProxy::SetContentType(
     VideoEncoderConfig::ContentType content_type) {
   rtc::CritScope lock(&crit_);
   if (content_type_ != content_type) {
-    uma_container_->UpdateHistograms(config_, stats_);
+    uma_container_->UpdateHistograms(rtp_config_, stats_);
     uma_container_.reset(
         new UmaSamplesContainer(GetUmaPrefix(content_type), stats_, clock_));
     content_type_ = content_type;
   }
 }
 
 void SendStatisticsProxy::OnEncoderStatsUpdate(
     uint32_t framerate,
     uint32_t bitrate,
     const std::string& encoder_name) {
@@ skipping 40 matching lines @@
 }
 
 VideoSendStream::StreamStats* SendStatisticsProxy::GetStatsEntry(
     uint32_t ssrc) {
   std::map<uint32_t, VideoSendStream::StreamStats>::iterator it =
       stats_.substreams.find(ssrc);
   if (it != stats_.substreams.end())
     return &it->second;
 
   bool is_rtx = false;
-  if (std::find(config_.rtp.ssrcs.begin(), config_.rtp.ssrcs.end(), ssrc) ==
-      config_.rtp.ssrcs.end()) {
-    if (std::find(config_.rtp.rtx.ssrcs.begin(), config_.rtp.rtx.ssrcs.end(),
-                  ssrc) == config_.rtp.rtx.ssrcs.end()) {
+  if (std::find(rtp_config_.ssrcs.begin(), rtp_config_.ssrcs.end(), ssrc) ==
+      rtp_config_.ssrcs.end()) {
+    if (std::find(rtp_config_.rtx.ssrcs.begin(), rtp_config_.rtx.ssrcs.end(),
+                  ssrc) == rtp_config_.rtx.ssrcs.end()) {
       return nullptr;
     }
     is_rtx = true;
   }
 
   // Insert new entry and return ptr.
   VideoSendStream::StreamStats* entry = &stats_.substreams[ssrc];
   entry->is_rtx = is_rtx;
 
   return entry;
@@ skipping 22 matching lines @@
   size_t simulcast_idx = 0;
 
   if (codec_info) {
     if (codec_info->codecType == kVideoCodecVP8) {
       simulcast_idx = codec_info->codecSpecific.VP8.simulcastIdx;
     } else if (codec_info->codecType == kVideoCodecGeneric) {
       simulcast_idx = codec_info->codecSpecific.generic.simulcast_idx;
     }
   }
 
-  if (simulcast_idx >= config_.rtp.ssrcs.size()) {
+  if (simulcast_idx >= rtp_config_.ssrcs.size()) {
     LOG(LS_ERROR) << "Encoded image outside simulcast range (" << simulcast_idx
-                  << " >= " << config_.rtp.ssrcs.size() << ").";
+                  << " >= " << rtp_config_.ssrcs.size() << ").";
     return;
   }
-  uint32_t ssrc = config_.rtp.ssrcs[simulcast_idx];
+  uint32_t ssrc = rtp_config_.ssrcs[simulcast_idx];
 
   rtc::CritScope lock(&crit_);
   VideoSendStream::StreamStats* stats = GetStatsEntry(ssrc);
   if (!stats)
     return;
 
   stats->width = encoded_image._encodedWidth;
   stats->height = encoded_image._encodedHeight;
   update_times_[ssrc].resolution_update_ms = clock_->TimeInMilliseconds();
 
@@ skipping 17 matching lines @@
     bool bw_limited = encoded_image.adapt_reason_.bw_resolutions_disabled > 0;
     uma_container_->bw_limited_frame_counter_.Add(bw_limited);
     if (bw_limited) {
       uma_container_->bw_resolutions_disabled_counter_.Add(
           encoded_image.adapt_reason_.bw_resolutions_disabled);
     }
   }
 
   if (encoded_image.qp_ != -1 && codec_info) {
     if (codec_info->codecType == kVideoCodecVP8) {
-      int spatial_idx = (config_.rtp.ssrcs.size() == 1)
+      int spatial_idx = (rtp_config_.ssrcs.size() == 1)
                             ? -1
                             : static_cast<int>(simulcast_idx);
       uma_container_->qp_counters_[spatial_idx].vp8.Add(encoded_image.qp_);
     } else if (codec_info->codecType == kVideoCodecVP9) {
       int spatial_idx = (codec_info->codecSpecific.VP9.num_spatial_layers == 1)
                             ? -1
                             : codec_info->codecSpecific.VP9.spatial_idx;
       uma_container_->qp_counters_[spatial_idx].vp9.Add(encoded_image.qp_);
     }
   }
@@ skipping 134 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