GetTransportFeedbackVector() includes unreceived packets, sorted by seq-num

webrtc/tools/event_log_visualizer/analyzer.cc

 /*
  *  Copyright (c) 2016 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 25 matching lines @@
 #include "webrtc/modules/rtp_rtcp/source/rtp_header_extensions.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_utility.h"
 #include "webrtc/video_receive_stream.h"
 #include "webrtc/video_send_stream.h"
 
 namespace webrtc {
 namespace plotting {
 
 namespace {
 
+class PacketFeedbackComparator {
+ public:
+  inline bool operator()(const webrtc::PacketFeedback& lhs,
+                         const webrtc::PacketFeedback& rhs) {
+    if (lhs.arrival_time_ms != rhs.arrival_time_ms)
+      return lhs.arrival_time_ms < rhs.arrival_time_ms;
+    if (lhs.send_time_ms != rhs.send_time_ms)
+      return lhs.send_time_ms < rhs.send_time_ms;
+    return lhs.sequence_number < rhs.sequence_number;
+  }
+};
+
 std::string SsrcToString(uint32_t ssrc) {
   std::stringstream ss;
   ss << "SSRC " << ssrc;
   return ss.str();
 }
 
 // Checks whether an SSRC is contained in the list of desired SSRCs.
 // Note that an empty SSRC list matches every SSRC.
 bool MatchingSsrc(uint32_t ssrc, const std::vector<uint32_t>& desired_ssrc) {
   if (desired_ssrc.size() == 0)
@@ skipping 494 matching lines @@
   plot->series_list_.back().style = LINE_DOT_GRAPH;
   for (auto& ana_event : audio_network_adaptation_events_) {
     rtc::Optional<float> y = get_y(ana_event);
     if (y) {
       float x = static_cast<float>(ana_event.timestamp - begin_time_) / 1000000;
       plot->series_list_.back().points.emplace_back(x, *y);
     }
   }
 }
 
+void EventLogAnalyzer::SortPacketFeedbackVector(

[terelius, 2017/03/08 11:59:58]

This method does not appear to use any state in the EventLogAnalyzer. I'd prefer
to make it a normal function in the anonymous namespace.

+    std::vector<PacketFeedback>* vec) const {
+  auto pred = [](const PacketFeedback& packet_feedback) {
+    return packet_feedback.arrival_time_ms == PacketFeedback::kNotReceived;
+  };
+  vec->erase(std::remove_if(vec->begin(), vec->end(), pred), vec->end());
+  std::sort(vec->begin(), vec->end(), PacketFeedbackComparator());
+}
+
 void EventLogAnalyzer::CreatePacketGraph(PacketDirection desired_direction,
                                          Plot* plot) {
   for (auto& kv : rtp_packets_) {
     StreamId stream_id = kv.first;
     const std::vector<LoggedRtpPacket>& packet_stream = kv.second;
     // Filter on direction and SSRC.
     if (stream_id.GetDirection() != desired_direction ||
         !MatchingSsrc(stream_id.GetSsrc(), desired_ssrc_)) {
       continue;
     }
@@ skipping 480 matching lines @@
     clock.AdvanceTimeMicroseconds(time_us - clock.TimeInMicroseconds());
     if (clock.TimeInMicroseconds() >= NextRtcpTime()) {
       RTC_DCHECK_EQ(clock.TimeInMicroseconds(), NextRtcpTime());
       const LoggedRtcpPacket& rtcp = *rtcp_iterator->second;
       if (rtcp.type == kRtcpTransportFeedback) {
         TransportFeedbackObserver* observer = cc.GetTransportFeedbackObserver();
         observer->OnTransportFeedback(*static_cast<rtcp::TransportFeedback*>(
             rtcp.packet.get()));
         std::vector<PacketFeedback> feedback =
             observer->GetTransportFeedbackVector();
+        SortPacketFeedbackVector(&feedback);
         rtc::Optional<uint32_t> bitrate_bps;
         if (!feedback.empty()) {
           for (const PacketFeedback& packet : feedback)
             acked_bitrate.Update(packet.payload_size, packet.arrival_time_ms);
           bitrate_bps = acked_bitrate.Rate(feedback.back().arrival_time_ms);
         }
         uint32_t y = 0;
         if (bitrate_bps)
           y = *bitrate_bps / 1000;
         float x = static_cast<float>(clock.TimeInMicroseconds() - begin_time_) /
@@ skipping 115 matching lines @@
   while (time_us != std::numeric_limits<int64_t>::max()) {
     clock.AdvanceTimeMicroseconds(time_us - clock.TimeInMicroseconds());
     if (clock.TimeInMicroseconds() >= NextRtcpTime()) {
       RTC_DCHECK_EQ(clock.TimeInMicroseconds(), NextRtcpTime());
       const LoggedRtcpPacket& rtcp = *rtcp_iterator->second;
       if (rtcp.type == kRtcpTransportFeedback) {
         feedback_adapter.OnTransportFeedback(
             *static_cast<rtcp::TransportFeedback*>(rtcp.packet.get()));
         std::vector<PacketFeedback> feedback =
             feedback_adapter.GetTransportFeedbackVector();
+        SortPacketFeedbackVector(&feedback);
         for (const PacketFeedback& packet : feedback) {
           int64_t y = packet.arrival_time_ms - packet.send_time_ms;
           float x =
               static_cast<float>(clock.TimeInMicroseconds() - begin_time_) /
               1000000;
           estimated_base_delay_ms = std::min(y, estimated_base_delay_ms);
           time_series.points.emplace_back(x, y);
         }
       }
       ++rtcp_iterator;
@@ skipping 176 matching lines @@
         return rtc::Optional<float>();
       });
   plot->series_list_.back().label = "Audio encoder number of channels";
   plot->SetXAxis(0, call_duration_s_, "Time (s)", kLeftMargin, kRightMargin);
   plot->SetSuggestedYAxis(0, 1, "Number of channels (1 (mono)/2 (stereo))",
                           kBottomMargin, kTopMargin);
   plot->SetTitle("Reported audio encoder number of channels");
 }
 }  // namespace plotting
 }  // namespace webrtc