Adds function for computing moving average to visualization tool.

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 62 matching lines @@
   int64_t difference =
       static_cast<int64_t>(later) - static_cast<int64_t>(earlier);
   int64_t max_difference = modulus / 2;
   int64_t min_difference = max_difference - modulus + 1;
   if (difference > max_difference) {
     difference -= modulus;
   }
   if (difference < min_difference) {
     difference += modulus;
   }
+  if (difference > max_difference / 2 || difference < min_difference / 2) {
+    LOG(LS_WARNING) << "Difference between" << later << " and " << earlier
+                    << " expected to be in the range (" << min_difference / 2
+                    << "," << max_difference / 2 << ") but is " << difference
+                    << ". Correct unwrapping is uncertain.";
+  }
   return difference;
 }
 
 void RegisterHeaderExtensions(
     const std::vector<webrtc::RtpExtension>& extensions,
     webrtc::RtpHeaderExtensionMap* extension_map) {
   extension_map->Erase();
   for (const webrtc::RtpExtension& extension : extensions) {
     extension_map->Register(webrtc::StringToRtpExtensionType(extension.uri),
                             extension.id);
   }
 }
 
 constexpr float kLeftMargin = 0.01f;
 constexpr float kRightMargin = 0.02f;
 constexpr float kBottomMargin = 0.02f;
 constexpr float kTopMargin = 0.05f;
 
+class PacketSizeBytes {
+ public:
+  using DataType = LoggedRtpPacket;
+  using ResultType = size_t;
+  size_t operator()(const LoggedRtpPacket& packet) {
+    return packet.total_length;
+  }
+};
+
+class SequenceNumberDiff {
+ public:
+  using DataType = LoggedRtpPacket;
+  using ResultType = int64_t;
+  int64_t operator()(const LoggedRtpPacket& old_packet,
+                     const LoggedRtpPacket& new_packet) {
+    return WrappingDifference(new_packet.header.sequenceNumber,
+                              old_packet.header.sequenceNumber, 1ul << 16);
+  }
+};
+
 class NetworkDelayDiff {
  public:
   class AbsSendTime {
    public:
     using DataType = LoggedRtpPacket;
     using ResultType = double;
     double operator()(const LoggedRtpPacket& old_packet,
                       const LoggedRtpPacket& new_packet) {
       if (old_packet.header.extension.hasAbsoluteSendTime &&
           new_packet.header.extension.hasAbsoluteSendTime) {
@@ skipping 22 matching lines @@
 
       const double kVideoSampleRate = 90000;
       // TODO(terelius): We treat all streams as video for now, even though
       // audio might be sampled at e.g. 16kHz, because it is really difficult to
       // figure out the true sampling rate of a stream. The effect is that the
       // delay will be scaled incorrectly for non-video streams.
 
       double delay_change =
           static_cast<double>(recv_time_diff) / 1000 -
           static_cast<double>(send_time_diff) / kVideoSampleRate * 1000;
+      if (delay_change < -10000 || 10000 < delay_change) {
+        LOG(LS_WARNING) << "Very large delay change. Timestamps correct?";
+        LOG(LS_WARNING) << "Old capture time " << old_packet.header.timestamp
+                        << ", received time " << old_packet.timestamp;
+        LOG(LS_WARNING) << "New capture time " << new_packet.header.timestamp
+                        << ", received time " << new_packet.timestamp;
+        LOG(LS_WARNING) << "Receive time difference " << recv_time_diff << " = "
+                        << static_cast<double>(recv_time_diff) / 1000000 << "s";
+        LOG(LS_WARNING) << "Send time difference " << send_time_diff << " = "
+                        << static_cast<double>(send_time_diff) /
+                               kVideoSampleRate
+                        << "s";
+      }
       return delay_change;
     }
   };
 };
 
 template <typename Extractor>
 class Accumulated {
  public:
   using DataType = typename Extractor::DataType;
   using ResultType = typename Extractor::ResultType;
   ResultType operator()(const DataType& old_packet,
                         const DataType& new_packet) {
     sum += extract(old_packet, new_packet);
     return sum;
   }
 
  private:
   Extractor extract;
   ResultType sum = 0;
 };
 
+// For each element in data, use |Extractor| to extract a y-coordinate and
+// store the result in a TimeSeries.
+template <typename Extractor>
+void Pointwise(const std::vector<typename Extractor::DataType>& data,
+               uint64_t begin_time,
+               TimeSeries* result) {
+  Extractor extract;
+  for (size_t i = 0; i < data.size(); i++) {
+    float x = static_cast<float>(data[i].timestamp - begin_time) / 1000000;
+    float y = extract(data[i]);
+    result->points.emplace_back(x, y);
+  }
+}
+
+// For each pair of adjacent elements in |data|, use |Extractor| to extract a
+// y-coordinate and store the result in a TimeSeries. Note that the x-coordinate
+// will be the time of the second element in the pair.
 template <typename Extractor>
 void Pairwise(const std::vector<typename Extractor::DataType>& data,
               uint64_t begin_time,
               TimeSeries* result) {
   Extractor extract;
   for (size_t i = 1; i < data.size(); i++) {
     float x = static_cast<float>(data[i].timestamp - begin_time) / 1000000;
     float y = extract(data[i - 1], data[i]);
     result->points.emplace_back(x, y);
   }
 }
 
+// Calculates a moving average of |data| and stores the result in a TimeSeries.
+// A data point is generated every |step| microseconds from |begin_time|
+// to |end_time|. The value of each data point is the average of the data
+// during the preceeding |window_duration_us| microseconds.
+template <typename Extractor>
+void MovingAverage(const std::vector<typename Extractor::DataType>& data,
+                   uint64_t begin_time,
+                   uint64_t end_time,
+                   uint64_t window_duration_us,
+                   uint64_t step,
+                   float y_scaling,
+                   webrtc::plotting::TimeSeries* result) {
+  size_t window_index_begin = 0;
+  size_t window_index_end = 0;
+  typename Extractor::ResultType sum_in_window = 0;
+  Extractor extract;
+
+  for (uint64_t t = begin_time; t < end_time + step; t += step) {
+    while (window_index_end < data.size() &&
+           data[window_index_end].timestamp < t) {
+      sum_in_window += extract(data[window_index_end]);
+      ++window_index_end;
+    }
+    while (window_index_begin < data.size() &&
+           data[window_index_begin].timestamp < t - window_duration_us) {
+      sum_in_window -= extract(data[window_index_begin]);
+      ++window_index_begin;
+    }
+    float window_duration_s = static_cast<float>(window_duration_us) / 1000000;
+    float x = static_cast<float>(t - begin_time) / 1000000;
+    float y = sum_in_window / window_duration_s * y_scaling;
+    result->points.emplace_back(x, y);
+  }
+}
+
 }  // namespace
 
 EventLogAnalyzer::EventLogAnalyzer(const ParsedRtcEventLog& log)
     : parsed_log_(log), window_duration_(250000), step_(10000) {
   uint64_t first_timestamp = std::numeric_limits<uint64_t>::max();
   uint64_t last_timestamp = std::numeric_limits<uint64_t>::min();
 
   // Maps a stream identifier consisting of ssrc and direction
   // to the header extensions used by that stream,
   std::map<StreamId, RtpHeaderExtensionMap> extension_maps;
@@ skipping 188 matching lines @@
 bool EventLogAnalyzer::IsVideoSsrc(StreamId stream_id) {
   return video_ssrcs_.count(stream_id) == 1;
 }
 
 bool EventLogAnalyzer::IsAudioSsrc(StreamId stream_id) {
   return audio_ssrcs_.count(stream_id) == 1;
 }
 
 void EventLogAnalyzer::CreatePacketGraph(PacketDirection desired_direction,
                                          Plot* plot) {
-  std::map<uint32_t, TimeSeries> time_series;
+  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;
+    }
 
-  PacketDirection direction;
-  MediaType media_type;
-  uint8_t header[IP_PACKET_SIZE];
-  size_t header_length, total_length;
-
-  for (size_t i = 0; i < parsed_log_.GetNumberOfEvents(); i++) {
-    ParsedRtcEventLog::EventType event_type = parsed_log_.GetEventType(i);
-    if (event_type == ParsedRtcEventLog::RTP_EVENT) {
-      parsed_log_.GetRtpHeader(i, &direction, &media_type, header,
-                               &header_length, &total_length);
-      if (direction == desired_direction) {
-        // Parse header to get SSRC.
-        RtpUtility::RtpHeaderParser rtp_parser(header, header_length);
-        RTPHeader parsed_header;
-        rtp_parser.Parse(&parsed_header);
-        // Filter on SSRC.
-        if (MatchingSsrc(parsed_header.ssrc, desired_ssrc_)) {
-          uint64_t timestamp = parsed_log_.GetTimestamp(i);
-          float x = static_cast<float>(timestamp - begin_time_) / 1000000;
-          float y = total_length;
-          time_series[parsed_header.ssrc].points.push_back(
-              TimeSeriesPoint(x, y));
-        }
-      }
-    }
-  }
-
-  // Set labels and put in graph.
-  for (auto& kv : time_series) {
-    kv.second.label = SsrcToString(kv.first);
-    kv.second.style = BAR_GRAPH;
-    plot->series_list_.push_back(std::move(kv.second));
+    TimeSeries time_series;
+    time_series.label = SsrcToString(stream_id.GetSsrc());
+    time_series.style = BAR_GRAPH;
+    Pointwise<PacketSizeBytes>(packet_stream, begin_time_, &time_series);
+    plot->series_list_.push_back(std::move(time_series));
   }
 
   plot->SetXAxis(0, call_duration_s_, "Time (s)", kLeftMargin, kRightMargin);
   plot->SetSuggestedYAxis(0, 1, "Packet size (bytes)", kBottomMargin,
                           kTopMargin);
   if (desired_direction == webrtc::PacketDirection::kIncomingPacket) {
     plot->SetTitle("Incoming RTP packets");
   } else if (desired_direction == webrtc::PacketDirection::kOutgoingPacket) {
     plot->SetTitle("Outgoing RTP packets");
   }
@@ skipping 33 matching lines @@
   }
 
   plot->SetXAxis(0, call_duration_s_, "Time (s)", kLeftMargin, kRightMargin);
   plot->SetSuggestedYAxis(0, 1, "Time since last playout (ms)", kBottomMargin,
                           kTopMargin);
   plot->SetTitle("Audio playout");
 }
 
 // For each SSRC, plot the time between the consecutive playouts.
 void EventLogAnalyzer::CreateSequenceNumberGraph(Plot* plot) {
-  std::map<uint32_t, TimeSeries> time_series;
-  std::map<uint32_t, uint16_t> last_seqno;
+  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() != kIncomingPacket ||
+        !MatchingSsrc(stream_id.GetSsrc(), desired_ssrc_)) {
+      continue;
+    }
 
-  PacketDirection direction;
-  MediaType media_type;
-  uint8_t header[IP_PACKET_SIZE];
-  size_t header_length, total_length;
-
-  for (size_t i = 0; i < parsed_log_.GetNumberOfEvents(); i++) {
-    ParsedRtcEventLog::EventType event_type = parsed_log_.GetEventType(i);
-    if (event_type == ParsedRtcEventLog::RTP_EVENT) {
-      parsed_log_.GetRtpHeader(i, &direction, &media_type, header,
-                               &header_length, &total_length);
-      uint64_t timestamp = parsed_log_.GetTimestamp(i);
-      if (direction == PacketDirection::kIncomingPacket) {
-        // Parse header to get SSRC.
-        RtpUtility::RtpHeaderParser rtp_parser(header, header_length);
-        RTPHeader parsed_header;
-        rtp_parser.Parse(&parsed_header);
-        // Filter on SSRC.
-        if (MatchingSsrc(parsed_header.ssrc, desired_ssrc_)) {
-          float x = static_cast<float>(timestamp - begin_time_) / 1000000;
-          int y = WrappingDifference(parsed_header.sequenceNumber,
-                                     last_seqno[parsed_header.ssrc], 1ul << 16);
-          if (time_series[parsed_header.ssrc].points.size() == 0) {
-            // There were no previusly logged playout for this SSRC.
-            // Generate a point, but place it on the x-axis.
-            y = 0;
-          }
-          time_series[parsed_header.ssrc].points.push_back(
-              TimeSeriesPoint(x, y));
-          last_seqno[parsed_header.ssrc] = parsed_header.sequenceNumber;
-        }
-      }
-    }
-  }
-
-  // Set labels and put in graph.
-  for (auto& kv : time_series) {
-    kv.second.label = SsrcToString(kv.first);
-    kv.second.style = BAR_GRAPH;
-    plot->series_list_.push_back(std::move(kv.second));
+    TimeSeries time_series;
+    time_series.label = SsrcToString(stream_id.GetSsrc());
+    time_series.style = BAR_GRAPH;
+    Pairwise<SequenceNumberDiff>(packet_stream, begin_time_, &time_series);
+    plot->series_list_.push_back(std::move(time_series));
   }
 
   plot->SetXAxis(0, call_duration_s_, "Time (s)", kLeftMargin, kRightMargin);
   plot->SetSuggestedYAxis(0, 1, "Difference since last packet", kBottomMargin,
                           kTopMargin);
   plot->SetTitle("Sequence number");
 }
 
 void EventLogAnalyzer::CreateDelayChangeGraph(Plot* plot) {
   for (auto& kv : rtp_packets_) {
@@ skipping 108 matching lines @@
   size_t window_index_begin = 0;
   size_t window_index_end = 0;
   size_t bytes_in_window = 0;
 
   // Calculate a moving average of the bitrate and store in a TimeSeries.
   plot->series_list_.push_back(TimeSeries());
   for (uint64_t time = begin_time_; time < end_time_ + step_; time += step_) {
     while (window_index_end < packets.size() &&
            packets[window_index_end].timestamp < time) {
       bytes_in_window += packets[window_index_end].size;
-      window_index_end++;
+      ++window_index_end;
     }
     while (window_index_begin < packets.size() &&
            packets[window_index_begin].timestamp < time - window_duration_) {
       RTC_DCHECK_LE(packets[window_index_begin].size, bytes_in_window);
       bytes_in_window -= packets[window_index_begin].size;
-      window_index_begin++;
+      ++window_index_begin;
     }
     float window_duration_in_seconds =
         static_cast<float>(window_duration_) / 1000000;
     float x = static_cast<float>(time - begin_time_) / 1000000;
     float y = bytes_in_window * 8 / window_duration_in_seconds / 1000;
     plot->series_list_.back().points.push_back(TimeSeriesPoint(x, y));
   }
 
   // Set labels.
   if (desired_direction == webrtc::PacketDirection::kIncomingPacket) {
@@ skipping 22 matching lines @@
     plot->SetTitle("Incoming RTP bitrate");
   } else if (desired_direction == webrtc::PacketDirection::kOutgoingPacket) {
     plot->SetTitle("Outgoing RTP bitrate");
   }
 }
 
 // For each SSRC, plot the bandwidth used by that stream.
 void EventLogAnalyzer::CreateStreamBitrateGraph(
     PacketDirection desired_direction,
     Plot* plot) {
-  struct TimestampSize {
-    TimestampSize(uint64_t t, size_t s) : timestamp(t), size(s) {}
-    uint64_t timestamp;
-    size_t size;
-  };
-  std::map<uint32_t, std::vector<TimestampSize>> packets;
-
-  PacketDirection direction;
-  MediaType media_type;
-  uint8_t header[IP_PACKET_SIZE];
-  size_t header_length, total_length;
-
-  // Extract timestamps and sizes for the relevant packets.
-  for (size_t i = 0; i < parsed_log_.GetNumberOfEvents(); i++) {
-    ParsedRtcEventLog::EventType event_type = parsed_log_.GetEventType(i);
-    if (event_type == ParsedRtcEventLog::RTP_EVENT) {
-      parsed_log_.GetRtpHeader(i, &direction, &media_type, header,
-                               &header_length, &total_length);
-      if (direction == desired_direction) {
-        // Parse header to get SSRC.
-        RtpUtility::RtpHeaderParser rtp_parser(header, header_length);
-        RTPHeader parsed_header;
-        rtp_parser.Parse(&parsed_header);
-        // Filter on SSRC.
-        if (MatchingSsrc(parsed_header.ssrc, desired_ssrc_)) {
-          uint64_t timestamp = parsed_log_.GetTimestamp(i);
-          packets[parsed_header.ssrc].push_back(
-              TimestampSize(timestamp, total_length));
-        }
-      }
-    }
-  }
-
-  for (auto& kv : packets) {
-    size_t window_index_begin = 0;
-    size_t window_index_end = 0;
-    size_t bytes_in_window = 0;
-
-    // Calculate a moving average of the bitrate and store in a TimeSeries.
-    plot->series_list_.push_back(TimeSeries());
-    for (uint64_t time = begin_time_; time < end_time_ + step_; time += step_) {
-      while (window_index_end < kv.second.size() &&
-             kv.second[window_index_end].timestamp < time) {
-        bytes_in_window += kv.second[window_index_end].size;
-        window_index_end++;
-      }
-      while (window_index_begin < kv.second.size() &&
-             kv.second[window_index_begin].timestamp <
-                 time - window_duration_) {
-        RTC_DCHECK_LE(kv.second[window_index_begin].size, bytes_in_window);
-        bytes_in_window -= kv.second[window_index_begin].size;
-        window_index_begin++;
-      }
-      float window_duration_in_seconds =
-          static_cast<float>(window_duration_) / 1000000;
-      float x = static_cast<float>(time - begin_time_) / 1000000;
-      float y = bytes_in_window * 8 / window_duration_in_seconds / 1000;
-      plot->series_list_.back().points.push_back(TimeSeriesPoint(x, y));
+  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;
     }
 
-    // Set labels.
-    plot->series_list_.back().label = SsrcToString(kv.first);
-    plot->series_list_.back().style = LINE_GRAPH;
+    TimeSeries time_series;
+    time_series.label = SsrcToString(stream_id.GetSsrc());
+    time_series.style = LINE_GRAPH;
+    double bytes_to_kilobits = 8.0 / 1000;
+    MovingAverage<PacketSizeBytes>(packet_stream, begin_time_, end_time_,
+                                   window_duration_, step_, bytes_to_kilobits,
+                                   &time_series);
+    plot->series_list_.push_back(std::move(time_series));
   }
 
   plot->SetXAxis(0, call_duration_s_, "Time (s)", kLeftMargin, kRightMargin);
   plot->SetSuggestedYAxis(0, 1, "Bitrate (kbps)", kBottomMargin, kTopMargin);
   if (desired_direction == webrtc::PacketDirection::kIncomingPacket) {
     plot->SetTitle("Incoming bitrate per stream");
   } else if (desired_direction == webrtc::PacketDirection::kOutgoingPacket) {
     plot->SetTitle("Outgoing bitrate per stream");
   }
 }
@@ skipping 182 matching lines @@
     point.y -= estimated_base_delay_ms;
   // Add the data set to the plot.
   plot->series_list_.push_back(std::move(time_series));
 
   plot->SetXAxis(0, call_duration_s_, "Time (s)", kLeftMargin, kRightMargin);
   plot->SetSuggestedYAxis(0, 10, "Delay (ms)", kBottomMargin, kTopMargin);
   plot->SetTitle("Network Delay Change.");
 }
 }  // namespace plotting
 }  // namespace webrtc