Take smaller interface for RtpRtcp::Configuration::receive_statistics

webrtc/modules/rtp_rtcp/source/receive_statistics_impl.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/modules/rtp_rtcp/source/receive_statistics_impl.h"
 
 #include <math.h>
 
 #include <cstdlib>
+#include <vector>
 
 #include "webrtc/modules/remote_bitrate_estimator/test/bwe_test_logging.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_rtcp_config.h"
 #include "webrtc/modules/rtp_rtcp/source/time_util.h"
+#include "webrtc/rtc_base/logging.h"
 #include "webrtc/system_wrappers/include/clock.h"
 
 namespace webrtc {
 
 const int64_t kStatisticsTimeoutMs = 8000;
 const int64_t kStatisticsProcessIntervalMs = 1000;
 
 StreamStatistician::~StreamStatistician() {}
 
 StreamStatisticianImpl::StreamStatisticianImpl(
@@ skipping 455 matching lines @@
 }
 
 void ReceiveStatisticsImpl::DataCountersUpdated(const StreamDataCounters& stats,
                                                 uint32_t ssrc) {
   rtc::CritScope cs(&receive_statistics_lock_);
   if (rtp_stats_callback_) {
     rtp_stats_callback_->DataCountersUpdated(stats, ssrc);
   }
 }
 
+std::vector<rtcp::ReportBlock> ReceiveStatistics::RtcpReportBlocks(
+    size_t max_blocks) {
+  StatisticianMap statisticians = GetActiveStatisticians();
+  std::vector<rtcp::ReportBlock> result;
+  result.reserve(std::min(max_blocks, statisticians.size()));
+  for (auto& statistician : statisticians) {
+    // TODO(danilchap): Select statistician subset across multiple calls using
+    // round-robin, as described in rfc3550 section 6.4 when single
+    // rtcp_module/receive_statistics will be used for more rtp streams.
+    if (result.size() == max_blocks)
+      break;
+
+    // Do we have receive statistics to send?
+    RtcpStatistics stats;
+    if (!statistician.second->GetStatistics(&stats, true))
+      continue;
+    result.emplace_back();
+    rtcp::ReportBlock& block = result.back();
+    block.SetMediaSsrc(statistician.first);
+    block.SetFractionLost(stats.fraction_lost);
+    if (!block.SetCumulativeLost(stats.cumulative_lost)) {
+      LOG(LS_WARNING) << "Cumulative lost is oversized.";

[eladalon, 2017/07/27 09:07:31]

Would logging the value be useful?

[danilchap, 2017/07/27 10:04:32]

may be. I have a TODO in ReceiveStatistics to handle oversized values better,
but since it is theoretical issue so far, didn't put much thoughts into it.
(i.e. it is out of scope of this CL)

+      result.pop_back();
+      continue;
+    }
+    block.SetExtHighestSeqNum(stats.extended_max_sequence_number);
+    block.SetJitter(stats.jitter);
+  }
+  return result;
+}
+
 void NullReceiveStatistics::IncomingPacket(const RTPHeader& rtp_header,
                                            size_t packet_length,
                                            bool retransmitted) {}
 
 void NullReceiveStatistics::FecPacketReceived(const RTPHeader& header,
                                               size_t packet_length) {}
 
 StatisticianMap NullReceiveStatistics::GetActiveStatisticians() const {
   return StatisticianMap();
 }
 
 StreamStatistician* NullReceiveStatistics::GetStatistician(
     uint32_t ssrc) const {
   return NULL;
 }
 
 void NullReceiveStatistics::SetMaxReorderingThreshold(
     int max_reordering_threshold) {}
 
 void NullReceiveStatistics::RegisterRtcpStatisticsCallback(
     RtcpStatisticsCallback* callback) {}
 
 void NullReceiveStatistics::RegisterRtpStatisticsCallback(
     StreamDataCountersCallback* callback) {}
 
 }  // namespace webrtc