Moving src/webrtc into src/.

In order to eliminate the WebRTC Subtree mirror in Chromium, WebRTC is moving the content of the src/webrtc directory up to the src/ directory. NOPRESUBMIT=true NOTREECHECKS=true NOTRY=true TBR=tommi@webrtc.org Bug: chromium:611808 Change-Id: Iac59c5b51b950f174119565bac87955a7994bc38 Reviewed-on: https://webrtc-review.googlesource.com/1560 Commit-Queue: Mirko Bonadei <mbonadei@webrtc.org> Reviewed-by: Henrik Kjellander <kjellander@webrtc.org> Cr-Commit-Position: refs/heads/master@{#19845}
2017-09-15 06:15:48 +02:00
parent 6674846b4a
commit bb547203bf
4576 changed files with 1092 additions and 1196 deletions
--- a/modules/rtp_rtcp/source/receive_statistics_impl.cc
+++ b/modules/rtp_rtcp/source/receive_statistics_impl.cc
@ -0,0 +1,514 @@
+/*
+ *  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(
+    uint32_t ssrc,
+    Clock* clock,
+    RtcpStatisticsCallback* rtcp_callback,
+    StreamDataCountersCallback* rtp_callback)
+    : ssrc_(ssrc),
+      clock_(clock),
+      incoming_bitrate_(kStatisticsProcessIntervalMs,
+                        RateStatistics::kBpsScale),
+      max_reordering_threshold_(kDefaultMaxReorderingThreshold),
+      jitter_q4_(0),
+      cumulative_loss_(0),
+      jitter_q4_transmission_time_offset_(0),
+      last_receive_time_ms_(0),
+      last_received_timestamp_(0),
+      last_received_transmission_time_offset_(0),
+      received_seq_first_(0),
+      received_seq_max_(0),
+      received_seq_wraps_(0),
+      received_packet_overhead_(12),
+      last_report_inorder_packets_(0),
+      last_report_old_packets_(0),
+      last_report_seq_max_(0),
+      rtcp_callback_(rtcp_callback),
+      rtp_callback_(rtp_callback) {}
+
+void StreamStatisticianImpl::IncomingPacket(const RTPHeader& header,
+                                            size_t packet_length,
+                                            bool retransmitted) {
+  auto counters = UpdateCounters(header, packet_length, retransmitted);
+  rtp_callback_->DataCountersUpdated(counters, ssrc_);
+}
+
+StreamDataCounters StreamStatisticianImpl::UpdateCounters(
+    const RTPHeader& header,
+    size_t packet_length,
+    bool retransmitted) {
+  rtc::CritScope cs(&stream_lock_);
+  bool in_order = InOrderPacketInternal(header.sequenceNumber);
+  RTC_DCHECK_EQ(ssrc_, header.ssrc);
+  incoming_bitrate_.Update(packet_length, clock_->TimeInMilliseconds());
+  receive_counters_.transmitted.AddPacket(packet_length, header);
+  if (!in_order && retransmitted) {
+    receive_counters_.retransmitted.AddPacket(packet_length, header);
+  }
+
+  if (receive_counters_.transmitted.packets == 1) {
+    received_seq_first_ = header.sequenceNumber;
+    receive_counters_.first_packet_time_ms = clock_->TimeInMilliseconds();
+  }
+
+  // Count only the new packets received. That is, if packets 1, 2, 3, 5, 4, 6
+  // are received, 4 will be ignored.
+  if (in_order) {
+    // Current time in samples.
+    NtpTime receive_time = clock_->CurrentNtpTime();
+
+    // Wrong if we use RetransmitOfOldPacket.
+    if (receive_counters_.transmitted.packets > 1 &&
+        received_seq_max_ > header.sequenceNumber) {
+      // Wrap around detected.
+      received_seq_wraps_++;
+    }
+    // New max.
+    received_seq_max_ = header.sequenceNumber;
+
+    // If new time stamp and more than one in-order packet received, calculate
+    // new jitter statistics.
+    if (header.timestamp != last_received_timestamp_ &&
+        (receive_counters_.transmitted.packets -
+         receive_counters_.retransmitted.packets) > 1) {
+      UpdateJitter(header, receive_time);
+    }
+    last_received_timestamp_ = header.timestamp;
+    last_receive_time_ntp_ = receive_time;
+    last_receive_time_ms_ = clock_->TimeInMilliseconds();
+  }
+
+  size_t packet_oh = header.headerLength + header.paddingLength;
+
+  // Our measured overhead. Filter from RFC 5104 4.2.1.2:
+  // avg_OH (new) = 15/16*avg_OH (old) + 1/16*pckt_OH,
+  received_packet_overhead_ = (15 * received_packet_overhead_ + packet_oh) >> 4;
+  return receive_counters_;
+}
+
+void StreamStatisticianImpl::UpdateJitter(const RTPHeader& header,
+                                          NtpTime receive_time) {
+  uint32_t receive_time_rtp =
+      NtpToRtp(receive_time, header.payload_type_frequency);
+  uint32_t last_receive_time_rtp =
+      NtpToRtp(last_receive_time_ntp_, header.payload_type_frequency);
+  int32_t time_diff_samples = (receive_time_rtp - last_receive_time_rtp) -
+      (header.timestamp - last_received_timestamp_);
+
+  time_diff_samples = std::abs(time_diff_samples);
+
+  // lib_jingle sometimes deliver crazy jumps in TS for the same stream.
+  // If this happens, don't update jitter value. Use 5 secs video frequency
+  // as the threshold.
+  if (time_diff_samples < 450000) {
+    // Note we calculate in Q4 to avoid using float.
+    int32_t jitter_diff_q4 = (time_diff_samples << 4) - jitter_q4_;
+    jitter_q4_ += ((jitter_diff_q4 + 8) >> 4);
+  }
+
+  // Extended jitter report, RFC 5450.
+  // Actual network jitter, excluding the source-introduced jitter.
+  int32_t time_diff_samples_ext =
+    (receive_time_rtp - last_receive_time_rtp) -
+    ((header.timestamp +
+      header.extension.transmissionTimeOffset) -
+     (last_received_timestamp_ +
+      last_received_transmission_time_offset_));
+
+  time_diff_samples_ext = std::abs(time_diff_samples_ext);
+
+  if (time_diff_samples_ext < 450000) {
+    int32_t jitter_diffQ4TransmissionTimeOffset =
+      (time_diff_samples_ext << 4) - jitter_q4_transmission_time_offset_;
+    jitter_q4_transmission_time_offset_ +=
+      ((jitter_diffQ4TransmissionTimeOffset + 8) >> 4);
+  }
+}
+
+void StreamStatisticianImpl::FecPacketReceived(const RTPHeader& header,
+                                               size_t packet_length) {
+  StreamDataCounters counters;
+  {
+    rtc::CritScope cs(&stream_lock_);
+    receive_counters_.fec.AddPacket(packet_length, header);
+    counters = receive_counters_;
+  }
+  rtp_callback_->DataCountersUpdated(counters, ssrc_);
+}
+
+void StreamStatisticianImpl::SetMaxReorderingThreshold(
+    int max_reordering_threshold) {
+  rtc::CritScope cs(&stream_lock_);
+  max_reordering_threshold_ = max_reordering_threshold;
+}
+
+bool StreamStatisticianImpl::GetStatistics(RtcpStatistics* statistics,
+                                           bool reset) {
+  {
+    rtc::CritScope cs(&stream_lock_);
+    if (received_seq_first_ == 0 &&
+        receive_counters_.transmitted.payload_bytes == 0) {
+      // We have not received anything.
+      return false;
+    }
+
+    if (!reset) {
+      if (last_report_inorder_packets_ == 0) {
+        // No report.
+        return false;
+      }
+      // Just get last report.
+      *statistics = last_reported_statistics_;
+      return true;
+    }
+
+    *statistics = CalculateRtcpStatistics();
+  }
+
+  rtcp_callback_->StatisticsUpdated(*statistics, ssrc_);
+  return true;
+}
+
+RtcpStatistics StreamStatisticianImpl::CalculateRtcpStatistics() {
+  RtcpStatistics stats;
+
+  if (last_report_inorder_packets_ == 0) {
+    // First time we send a report.
+    last_report_seq_max_ = received_seq_first_ - 1;
+  }
+
+  // Calculate fraction lost.
+  uint16_t exp_since_last = (received_seq_max_ - last_report_seq_max_);
+
+  if (last_report_seq_max_ > received_seq_max_) {
+    // Can we assume that the seq_num can't go decrease over a full RTCP period?
+    exp_since_last = 0;
+  }
+
+  // Number of received RTP packets since last report, counts all packets but
+  // not re-transmissions.
+  uint32_t rec_since_last =
+      (receive_counters_.transmitted.packets -
+       receive_counters_.retransmitted.packets) - last_report_inorder_packets_;
+
+  // With NACK we don't know the expected retransmissions during the last
+  // second. We know how many "old" packets we have received. We just count
+  // the number of old received to estimate the loss, but it still does not
+  // guarantee an exact number since we run this based on time triggered by
+  // sending of an RTP packet. This should have a minimum effect.
+
+  // With NACK we don't count old packets as received since they are
+  // re-transmitted. We use RTT to decide if a packet is re-ordered or
+  // re-transmitted.
+  uint32_t retransmitted_packets =
+      receive_counters_.retransmitted.packets - last_report_old_packets_;
+  rec_since_last += retransmitted_packets;
+
+  int32_t missing = 0;
+  if (exp_since_last > rec_since_last) {
+    missing = (exp_since_last - rec_since_last);
+  }
+  uint8_t local_fraction_lost = 0;
+  if (exp_since_last) {
+    // Scale 0 to 255, where 255 is 100% loss.
+    local_fraction_lost =
+        static_cast<uint8_t>(255 * missing / exp_since_last);
+  }
+  stats.fraction_lost = local_fraction_lost;
+
+  // We need a counter for cumulative loss too.
+  // TODO(danilchap): Ensure cumulative loss is below maximum value of 2^24.
+  cumulative_loss_ += missing;
+  stats.packets_lost = cumulative_loss_;
+  stats.extended_highest_sequence_number =
+      (received_seq_wraps_ << 16) + received_seq_max_;
+  // Note: internal jitter value is in Q4 and needs to be scaled by 1/16.
+  stats.jitter = jitter_q4_ >> 4;
+
+  // Store this report.
+  last_reported_statistics_ = stats;
+
+  // Only for report blocks in RTCP SR and RR.
+  last_report_inorder_packets_ =
+      receive_counters_.transmitted.packets -
+      receive_counters_.retransmitted.packets;
+  last_report_old_packets_ = receive_counters_.retransmitted.packets;
+  last_report_seq_max_ = received_seq_max_;
+  BWE_TEST_LOGGING_PLOT_WITH_SSRC(1, "cumulative_loss_pkts",
+                                  clock_->TimeInMilliseconds(),
+                                  cumulative_loss_, ssrc_);
+  BWE_TEST_LOGGING_PLOT_WITH_SSRC(
+      1, "received_seq_max_pkts", clock_->TimeInMilliseconds(),
+      (received_seq_max_ - received_seq_first_), ssrc_);
+
+  return stats;
+}
+
+void StreamStatisticianImpl::GetDataCounters(
+    size_t* bytes_received, uint32_t* packets_received) const {
+  rtc::CritScope cs(&stream_lock_);
+  if (bytes_received) {
+    *bytes_received = receive_counters_.transmitted.payload_bytes +
+                      receive_counters_.transmitted.header_bytes +
+                      receive_counters_.transmitted.padding_bytes;
+  }
+  if (packets_received) {
+    *packets_received = receive_counters_.transmitted.packets;
+  }
+}
+
+void StreamStatisticianImpl::GetReceiveStreamDataCounters(
+    StreamDataCounters* data_counters) const {
+  rtc::CritScope cs(&stream_lock_);
+  *data_counters = receive_counters_;
+}
+
+uint32_t StreamStatisticianImpl::BitrateReceived() const {
+  rtc::CritScope cs(&stream_lock_);
+  return incoming_bitrate_.Rate(clock_->TimeInMilliseconds()).value_or(0);
+}
+
+void StreamStatisticianImpl::LastReceiveTimeNtp(uint32_t* secs,
+                                                uint32_t* frac) const {
+  rtc::CritScope cs(&stream_lock_);
+  *secs = last_receive_time_ntp_.seconds();
+  *frac = last_receive_time_ntp_.fractions();
+}
+
+bool StreamStatisticianImpl::IsRetransmitOfOldPacket(
+    const RTPHeader& header, int64_t min_rtt) const {
+  rtc::CritScope cs(&stream_lock_);
+  if (InOrderPacketInternal(header.sequenceNumber)) {
+    return false;
+  }
+  uint32_t frequency_khz = header.payload_type_frequency / 1000;
+  assert(frequency_khz > 0);
+
+  int64_t time_diff_ms = clock_->TimeInMilliseconds() -
+      last_receive_time_ms_;
+
+  // Diff in time stamp since last received in order.
+  uint32_t timestamp_diff = header.timestamp - last_received_timestamp_;
+  uint32_t rtp_time_stamp_diff_ms = timestamp_diff / frequency_khz;
+
+  int64_t max_delay_ms = 0;
+  if (min_rtt == 0) {
+    // Jitter standard deviation in samples.
+    float jitter_std = sqrt(static_cast<float>(jitter_q4_ >> 4));
+
+    // 2 times the standard deviation => 95% confidence.
+    // And transform to milliseconds by dividing by the frequency in kHz.
+    max_delay_ms = static_cast<int64_t>((2 * jitter_std) / frequency_khz);
+
+    // Min max_delay_ms is 1.
+    if (max_delay_ms == 0) {
+      max_delay_ms = 1;
+    }
+  } else {
+    max_delay_ms = (min_rtt / 3) + 1;
+  }
+  return time_diff_ms > rtp_time_stamp_diff_ms + max_delay_ms;
+}
+
+bool StreamStatisticianImpl::IsPacketInOrder(uint16_t sequence_number) const {
+  rtc::CritScope cs(&stream_lock_);
+  return InOrderPacketInternal(sequence_number);
+}
+
+bool StreamStatisticianImpl::InOrderPacketInternal(
+    uint16_t sequence_number) const {
+  // First packet is always in order.
+  if (last_receive_time_ms_ == 0)
+    return true;
+
+  if (IsNewerSequenceNumber(sequence_number, received_seq_max_)) {
+    return true;
+  } else {
+    // If we have a restart of the remote side this packet is still in order.
+    return !IsNewerSequenceNumber(sequence_number, received_seq_max_ -
+                                  max_reordering_threshold_);
+  }
+}
+
+ReceiveStatistics* ReceiveStatistics::Create(Clock* clock) {
+  return new ReceiveStatisticsImpl(clock);
+}
+
+ReceiveStatisticsImpl::ReceiveStatisticsImpl(Clock* clock)
+    : clock_(clock),
+      rtcp_stats_callback_(NULL),
+      rtp_stats_callback_(NULL) {}
+
+ReceiveStatisticsImpl::~ReceiveStatisticsImpl() {
+  while (!statisticians_.empty()) {
+    delete statisticians_.begin()->second;
+    statisticians_.erase(statisticians_.begin());
+  }
+}
+
+void ReceiveStatisticsImpl::IncomingPacket(const RTPHeader& header,
+                                           size_t packet_length,
+                                           bool retransmitted) {
+  StreamStatisticianImpl* impl;
+  {
+    rtc::CritScope cs(&receive_statistics_lock_);
+    StatisticianImplMap::iterator it = statisticians_.find(header.ssrc);
+    if (it != statisticians_.end()) {
+      impl = it->second;
+    } else {
+      impl = new StreamStatisticianImpl(header.ssrc, clock_, this, this);
+      statisticians_[header.ssrc] = impl;
+    }
+  }
+  // StreamStatisticianImpl instance is created once and only destroyed when
+  // this whole ReceiveStatisticsImpl is destroyed. StreamStatisticianImpl has
+  // it's own locking so don't hold receive_statistics_lock_ (potential
+  // deadlock).
+  impl->IncomingPacket(header, packet_length, retransmitted);
+}
+
+void ReceiveStatisticsImpl::FecPacketReceived(const RTPHeader& header,
+                                              size_t packet_length) {
+  StreamStatisticianImpl* impl;
+  {
+    rtc::CritScope cs(&receive_statistics_lock_);
+    StatisticianImplMap::iterator it = statisticians_.find(header.ssrc);
+    // Ignore FEC if it is the first packet.
+    if (it == statisticians_.end())
+      return;
+    impl = it->second;
+  }
+  impl->FecPacketReceived(header, packet_length);
+}
+
+StatisticianMap ReceiveStatisticsImpl::GetActiveStatisticians() const {
+  StatisticianMap active_statisticians;
+  rtc::CritScope cs(&receive_statistics_lock_);
+  for (StatisticianImplMap::const_iterator it = statisticians_.begin();
+       it != statisticians_.end(); ++it) {
+    uint32_t secs;
+    uint32_t frac;
+    it->second->LastReceiveTimeNtp(&secs, &frac);
+    if (clock_->CurrentNtpInMilliseconds() -
+        Clock::NtpToMs(secs, frac) < kStatisticsTimeoutMs) {
+      active_statisticians[it->first] = it->second;
+    }
+  }
+  return active_statisticians;
+}
+
+StreamStatistician* ReceiveStatisticsImpl::GetStatistician(
+    uint32_t ssrc) const {
+  rtc::CritScope cs(&receive_statistics_lock_);
+  StatisticianImplMap::const_iterator it = statisticians_.find(ssrc);
+  if (it == statisticians_.end())
+    return NULL;
+  return it->second;
+}
+
+void ReceiveStatisticsImpl::SetMaxReorderingThreshold(
+    int max_reordering_threshold) {
+  rtc::CritScope cs(&receive_statistics_lock_);
+  for (StatisticianImplMap::iterator it = statisticians_.begin();
+       it != statisticians_.end(); ++it) {
+    it->second->SetMaxReorderingThreshold(max_reordering_threshold);
+  }
+}
+
+void ReceiveStatisticsImpl::RegisterRtcpStatisticsCallback(
+    RtcpStatisticsCallback* callback) {
+  rtc::CritScope cs(&receive_statistics_lock_);
+  if (callback != NULL)
+    assert(rtcp_stats_callback_ == NULL);
+  rtcp_stats_callback_ = callback;
+}
+
+void ReceiveStatisticsImpl::StatisticsUpdated(const RtcpStatistics& statistics,
+                                              uint32_t ssrc) {
+  rtc::CritScope cs(&receive_statistics_lock_);
+  if (rtcp_stats_callback_)
+    rtcp_stats_callback_->StatisticsUpdated(statistics, ssrc);
+}
+
+void ReceiveStatisticsImpl::CNameChanged(const char* cname, uint32_t ssrc) {
+  rtc::CritScope cs(&receive_statistics_lock_);
+  if (rtcp_stats_callback_)
+    rtcp_stats_callback_->CNameChanged(cname, ssrc);
+}
+
+void ReceiveStatisticsImpl::RegisterRtpStatisticsCallback(
+    StreamDataCountersCallback* callback) {
+  rtc::CritScope cs(&receive_statistics_lock_);
+  if (callback != NULL)
+    assert(rtp_stats_callback_ == NULL);
+  rtp_stats_callback_ = callback;
+}
+
+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> ReceiveStatisticsImpl::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.packets_lost)) {
+      LOG(LS_WARNING) << "Cumulative lost is oversized.";
+      result.pop_back();
+      continue;
+    }
+    block.SetExtHighestSeqNum(stats.extended_highest_sequence_number);
+    block.SetJitter(stats.jitter);
+  }
+  return result;
+}
+
+}  // namespace webrtc