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 593 matching lines @@
   }
   return 0;
 }
 
 void ModuleRtpRtcpImpl::GetSendStreamDataCounters(
     StreamDataCounters* rtp_counters,
     StreamDataCounters* rtx_counters) const {
   rtp_sender_.GetDataCounters(rtp_counters, rtx_counters);
 }
 
+void ModuleRtpRtcpImpl::GetRtpPacketLossStats(
+    struct RtpPacketLossStats* incoming_loss,
+    struct RtpPacketLossStats* outgoing_loss) const {
+  if (incoming_loss) {
+    incoming_loss->single_packet_loss_count =
+        receive_loss_stats_.GetSingleLossCount();
+    incoming_loss->multiple_packet_loss_event_count =
+        receive_loss_stats_.GetMultipleLossEventCount();
+    incoming_loss->multiple_packet_loss_packet_count =
+        receive_loss_stats_.GetMultipleLossPacketCount();
+  }
+  if (outgoing_loss) {
+    outgoing_loss->single_packet_loss_count =
+        send_loss_stats_.GetSingleLossCount();
+    outgoing_loss->multiple_packet_loss_event_count =
+        send_loss_stats_.GetMultipleLossEventCount();
+    outgoing_loss->multiple_packet_loss_packet_count =
+        send_loss_stats_.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) {
+  for (int i = 0; i < size; ++i) {
+    receive_loss_stats_.AddLostPacket(nack_list[i]);
+  }
   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