Add statistics gathering for packet loss.

webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc

 /*
  *  Copyright (c) 2012 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 91 matching lines @@
 
   // TODO(pwestin) move to constructors of each rtp/rtcp sender/receiver object.
   rtcp_sender_.RegisterSendTransport(configuration.outgoing_transport);
 
   // Make sure that RTCP objects are aware of our SSRC.
   uint32_t SSRC = rtp_sender_.SSRC();
   rtcp_sender_.SetSSRC(SSRC);
   SetRtcpReceiverSsrcs(SSRC);
 }
 
+ModuleRtpRtcpImpl::~ModuleRtpRtcpImpl() {
+  for (auto loss_stats : receive_loss_stats_) {
+    delete loss_stats.second;
+  }
+}
+
 // Returns the number of milliseconds until the module want a worker thread
 // to call Process.
 int64_t ModuleRtpRtcpImpl::TimeUntilNextProcess() {
   const int64_t now = clock_->TimeInMilliseconds();
   const int64_t kRtpRtcpMaxIdleTimeProcessMs = 5;
   return kRtpRtcpMaxIdleTimeProcessMs - (now - last_process_time_);
 }
 
 // Process any pending tasks such as timeouts (non time critical events).
 int32_t ModuleRtpRtcpImpl::Process() {
@@ skipping 482 matching lines @@
   }
   return 0;
 }
 
 void ModuleRtpRtcpImpl::GetSendStreamDataCounters(
     StreamDataCounters* rtp_counters,
     StreamDataCounters* rtx_counters) const {
   rtp_sender_.GetDataCounters(rtp_counters, rtx_counters);
 }
 
+void ModuleRtpRtcpImpl::GetRtpPacketLossStats(
+    bool outgoing,
+    uint32_t ssrc,
+    struct RtpPacketLossStats* loss_stats) const {
+  if (!loss_stats) return;
+  const PacketLossStats* stats_source = NULL;
+  if (outgoing) {
+    if (SSRC() == ssrc) {
+      stats_source = &send_loss_stats_;
+    }
+  } else {
+    auto it = receive_loss_stats_.find(ssrc);
+    if (it != receive_loss_stats_.end()) {
+      stats_source = it->second;
+    }
+  }
+  if (stats_source) {
+    loss_stats->single_packet_loss_count =
+        stats_source->GetSingleLossCount();
+    loss_stats->multiple_packet_loss_event_count =
+        stats_source->GetMultipleLossEventCount();
+    loss_stats->multiple_packet_loss_packet_count =
+        stats_source->GetMultipleLossPacketCount();
+  }
+}
+
 int32_t ModuleRtpRtcpImpl::RemoteRTCPStat(RTCPSenderInfo* sender_info) {
   return rtcp_receiver_.SenderInfoReceived(sender_info);
 }
 
 // Received RTCP report.
 int32_t ModuleRtpRtcpImpl::RemoteRTCPStat(
     std::vector<RTCPReportBlock>* receive_blocks) const {
   return rtcp_receiver_.StatisticsReceived(receive_blocks);
 }
 
@@ skipping 53 matching lines @@
 
 // Enable or disable a retransmission mode, which decides which packets will
 // be retransmitted if NACKed.
 int ModuleRtpRtcpImpl::SetSelectiveRetransmissions(uint8_t settings) {
   return rtp_sender_.SetSelectiveRetransmissions(settings);
 }
 
 // Send a Negative acknowledgment packet.
 int32_t ModuleRtpRtcpImpl::SendNACK(const uint16_t* nack_list,
                                     const uint16_t size) {
+  uint32_t remote_ssrc = rtcp_receiver_.RemoteSSRC();
+  auto it = receive_loss_stats_.find(remote_ssrc);

[åsapersson, 2015/07/06 13:57:24]

The remote_ssrc is the SSRC of the received media stream on this module (which
will stay the same throughout a call?).

Is the intention to handle received NACK requests from multiple receivers for
one sent stream? If so, please see RTCPReceiver::HandleNACK and
rtcpPacket.NACK.SenderSSRC which shows who a NACK request is from (and could be
used as the key for the map?).

[bcornell, 2015/07/08 18:28:12]

You're right, I had confused myself into thinking that you could get multiple
receive streams here, but you can't, so there's no need for multiple packet loss
counters.

+  PacketLossStats* receive_stats;
+  if (it == receive_loss_stats_.end()) {
+    receive_stats = new PacketLossStats();
+    receive_loss_stats_[remote_ssrc] = receive_stats;
+  } else {
+    receive_stats = it->second;
+  }
+  for (int i = 0; i < size; ++i) {
+    receive_stats->AddLostPacket(nack_list[i]);
+  }

[stefan-webrtc, 2015/07/06 14:13:36]

Is this new functionality supposed to track how often a packet is nacked, or to
track loss rates? We have a separate ReceiveStatistics class
(webrtc/modules/rtp_rtcp/interface/receive_statistics.h) which is used for this
very purpose, so this looks a bit misplaced.

[bcornell, 2015/07/08 18:28:12]

It uses how often a packet is NACKed as an approximation of loss rates for both
receive and send. If it were purely for receive, ReceiveStatistics would make
sense, but this also tracks packet loss on the outgoing stream (approximated by
which packets it receives NACKs for). As such I thought it made more sense to
put it in a common location.

[åsapersson, 2015/07/09 06:26:54]

If this is for tracking packet loss, there is a class ReportBlockStats which is
used in ViE for packet loss statistics for sent/received streams based on
received/sent RTCP report blocks.

Maybe this class could be used? 

   uint16_t nack_length = size;
   uint16_t start_id = 0;
   int64_t now = clock_->TimeInMilliseconds();
   if (TimeToSendFullNackList(now)) {
     nack_last_time_sent_full_ = now;
     nack_last_time_sent_full_prev_ = now;
   } else {
     // Only send extended list.
     if (nack_last_seq_number_sent_ == nack_list[size - 1]) {
       // Last sequence number is the same, do not send list.
@@ skipping 195 matching lines @@
   return rtcp_sender_.SendTimeOfSendReport(send_report);
 }
 
 bool ModuleRtpRtcpImpl::SendTimeOfXrRrReport(
     uint32_t mid_ntp, int64_t* time_ms) const {
   return rtcp_sender_.SendTimeOfXrRrReport(mid_ntp, time_ms);
 }
 
 void ModuleRtpRtcpImpl::OnReceivedNACK(
     const std::list<uint16_t>& nack_sequence_numbers) {
+  for (uint16_t nack_sequence_number : nack_sequence_numbers) {
+    send_loss_stats_.AddLostPacket(nack_sequence_number);
+  }
   if (!rtp_sender_.StorePackets() ||
       nack_sequence_numbers.size() == 0) {
     return;
   }
   // Use RTT from RtcpRttStats class if provided.
   int64_t rtt = rtt_ms();
   if (rtt == 0) {
     rtcp_receiver_.RTT(rtcp_receiver_.RemoteSSRC(), NULL, &rtt, NULL, NULL);
   }
   rtp_sender_.OnReceivedNACK(nack_sequence_numbers, rtt);
@@ skipping 64 matching lines @@
 void ModuleRtpRtcpImpl::RegisterSendChannelRtpStatisticsCallback(
     StreamDataCountersCallback* callback) {
   rtp_sender_.RegisterRtpStatisticsCallback(callback);
 }
 
 StreamDataCountersCallback*
     ModuleRtpRtcpImpl::GetSendChannelRtpStatisticsCallback() const {
   return rtp_sender_.GetRtpStatisticsCallback();
 }
 }  // namespace webrtc