Unify FillAudioEncoderTimeSeries and Pointwise.

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 95 matching lines @@
   default_map.Register<AbsoluteSendTime>(
       webrtc::RtpExtension::kAbsSendTimeDefaultId);
   return default_map;
 }
 
 constexpr float kLeftMargin = 0.01f;
 constexpr float kRightMargin = 0.02f;
 constexpr float kBottomMargin = 0.02f;
 constexpr float kTopMargin = 0.05f;
 
-class PacketSizeBytes {
+template <typename SampleDataType, typename ExtractedType>
+class Pointwise {
  public:
-  using DataType = LoggedRtpPacket;
-  using ResultType = size_t;
-  size_t operator()(const LoggedRtpPacket& packet) {
-    return packet.total_length;
+  using DataType = SampleDataType;
+  using ResultType = ExtractedType;
+  using FunctionType =
+      rtc::FunctionView<rtc::Optional<ResultType>(const DataType& data)>;
+
+  explicit Pointwise(FunctionType get_sample) : get_sample_(get_sample) {}
+
+  rtc::Optional<ResultType> operator()(DataType data) {
+    return get_sample_(data);
   }
+
+ private:
+  FunctionType get_sample_;
 };
 
-class SequenceNumberDiff {
+template <typename SampleDataType, typename ExtractedType>
+class Pairwise {
  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);
+  using DataType = SampleDataType;
+  using ResultType = ExtractedType;
+  using FunctionType =
+      rtc::FunctionView<rtc::Optional<ResultType>(const DataType& last_sample,
+                                                  const DataType& sample)>;
+  explicit Pairwise(FunctionType get_samples)
+      : get_samples_(get_samples) {}
+  rtc::Optional<ResultType> operator()(DataType sample) {
+    auto result = last_sample_ ? get_samples_(*last_sample_, sample)
+                               : rtc::Optional<ResultType>();
+    last_sample_ = rtc::Optional<DataType>(sample);
+    return result;
   }
-};
 
-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) {
-        int64_t send_time_diff = WrappingDifference(
-            new_packet.header.extension.absoluteSendTime,
-            old_packet.header.extension.absoluteSendTime, 1ul << 24);
-        int64_t recv_time_diff = new_packet.timestamp - old_packet.timestamp;
-        return static_cast<double>(recv_time_diff -
-                                   AbsSendTimeToMicroseconds(send_time_diff)) /
-               1000;
-      } else {
-        return 0;
-      }
-    }
-  };
-
-  class CaptureTime {
-   public:
-    using DataType = LoggedRtpPacket;
-    using ResultType = double;
-    double operator()(const LoggedRtpPacket& old_packet,
-                      const LoggedRtpPacket& new_packet) {
-      int64_t send_time_diff = WrappingDifference(
-          new_packet.header.timestamp, old_packet.header.timestamp, 1ull << 32);
-      int64_t recv_time_diff = new_packet.timestamp - old_packet.timestamp;
-
-      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;
-    }
-  };
+ private:
+  FunctionType get_samples_;
+  rtc::Optional<DataType> last_sample_;
 };
 
 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;
+  using FunctionType = typename Extractor::FunctionType;
+  explicit Accumulated(FunctionType get_sample) : extract(get_sample) {}
+  rtc::Optional<ResultType> operator()(const DataType& sample) {
+    auto result = extract(sample);
+    if (result)
+      sum += *result;
+    return rtc::Optional<ResultType>(sum);
   }
 
  private:
   Extractor extract;
   ResultType sum = 0;
 };
 
+rtc::Optional<double> NetworkDelayAbsSendTime(
+    const LoggedRtpPacket& old_packet,
+    const LoggedRtpPacket& new_packet) {
+  if (old_packet.header.extension.hasAbsoluteSendTime &&
+      new_packet.header.extension.hasAbsoluteSendTime) {
+    int64_t send_time_diff = WrappingDifference(
+        new_packet.header.extension.absoluteSendTime,
+        old_packet.header.extension.absoluteSendTime, 1ul << 24);
+    int64_t recv_time_diff = new_packet.timestamp - old_packet.timestamp;
+    return rtc::Optional<double>(
+        static_cast<double>(recv_time_diff -
+                            AbsSendTimeToMicroseconds(send_time_diff)) /
+        1000);
+  } else {
+    return rtc::Optional<double>(0.0);
+  }
+}
+
+rtc::Optional<double> NetworkDelayDiffCaptureTime(
+    const LoggedRtpPacket& old_packet,
+    const LoggedRtpPacket& new_packet) {
+  int64_t send_time_diff = WrappingDifference(
+      new_packet.header.timestamp, old_packet.header.timestamp, 1ull << 32);
+  int64_t recv_time_diff = new_packet.timestamp - old_packet.timestamp;
+
+  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 rtc::Optional<double>(delay_change);
+}
+
 // 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);
+void Process(const std::vector<typename Extractor::DataType>& data,
+             uint64_t begin_time,
+             TimeSeries* result,
+             typename Extractor::FunctionType get_sample) {
+  Extractor extract(get_sample);
+  for (auto& sample : data) {
+    float x = static_cast<float>(sample.timestamp - begin_time) / 1000000;
+    auto y = extract(sample);
+    if (y)
+      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) {
+                   TimeSeries* result,
+                   typename Extractor::FunctionType get_sample) {
   size_t window_index_begin = 0;
   size_t window_index_end = 0;
   typename Extractor::ResultType sum_in_window = 0;
-  Extractor extract;
+  Extractor extract(get_sample);
 
   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]);
+      auto sample = extract(data[window_index_end]);
       ++window_index_end;
+      if (sample)
+        sum_in_window += *sample;
     }
     while (window_index_begin < data.size() &&
            data[window_index_begin].timestamp < t - window_duration_us) {
-      sum_in_window -= extract(data[window_index_begin]);
+      auto sample = extract(data[window_index_begin]);
       ++window_index_begin;
+      if (sample)
+        sum_in_window -= *sample;
     }
     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
 
@@ skipping 251 matching lines @@
     name << "RTX ";
   if (stream_id.GetDirection() == kIncomingPacket) {
     name << "(In) ";
   } else {
     name << "(Out) ";
   }
   name << SsrcToString(stream_id.GetSsrc());
   return name.str();
 }
 
-void EventLogAnalyzer::FillAudioEncoderTimeSeries(
-    Plot* plot,
-    rtc::FunctionView<rtc::Optional<float>(
-        const AudioNetworkAdaptationEvent& ana_event)> get_y) const {
-  plot->series_list_.push_back(TimeSeries());
-  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::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;
     }
 
     TimeSeries time_series;
     time_series.label = GetStreamName(stream_id);
     time_series.style = BAR_GRAPH;
-    Pointwise<PacketSizeBytes>(packet_stream, begin_time_, &time_series);
+
+    Process<Pointwise<LoggedRtpPacket, float>>(
+        packet_stream, begin_time_, &time_series,
+        [](const LoggedRtpPacket& packet) {
+          return rtc::Optional<float>(packet.total_length);
+        });
     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 125 matching lines @@
     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;
     }
 
     TimeSeries time_series;
     time_series.label = GetStreamName(stream_id);
     time_series.style = BAR_GRAPH;
-    Pairwise<SequenceNumberDiff>(packet_stream, begin_time_, &time_series);
+
+    Process<Pairwise<LoggedRtpPacket, float>>(
+        packet_stream, begin_time_, &time_series,
+        [](const LoggedRtpPacket& last_sample, const LoggedRtpPacket& sample) {
+          return rtc::Optional<float>(static_cast<float>(WrappingDifference(
+              sample.header.sequenceNumber, last_sample.header.sequenceNumber,
+              1ul << 16)));
+        });
     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::CreateIncomingPacketLossGraph(Plot* plot) {
@@ skipping 63 matching lines @@
     if (stream_id.GetDirection() != kIncomingPacket ||
         !MatchingSsrc(stream_id.GetSsrc(), desired_ssrc_) ||
         IsAudioSsrc(stream_id) || !IsVideoSsrc(stream_id) ||
         IsRtxSsrc(stream_id)) {
       continue;
     }
 
     TimeSeries capture_time_data;
     capture_time_data.label = GetStreamName(stream_id) + " capture-time";
     capture_time_data.style = BAR_GRAPH;
-    Pairwise<NetworkDelayDiff::CaptureTime>(packet_stream, begin_time_,
-                                            &capture_time_data);
+
+    Process<Pairwise<LoggedRtpPacket, double>>(
+        packet_stream, begin_time_, &capture_time_data,
+        NetworkDelayDiffCaptureTime);
     plot->series_list_.push_back(std::move(capture_time_data));
 
     TimeSeries send_time_data;
     send_time_data.label = GetStreamName(stream_id) + " abs-send-time";
     send_time_data.style = BAR_GRAPH;
-    Pairwise<NetworkDelayDiff::AbsSendTime>(packet_stream, begin_time_,
-                                            &send_time_data);
+
+    Process<Pairwise<LoggedRtpPacket, double>>(
+        packet_stream, begin_time_, &send_time_data, NetworkDelayAbsSendTime);
+
     plot->series_list_.push_back(std::move(send_time_data));
   }
 
   plot->SetXAxis(0, call_duration_s_, "Time (s)", kLeftMargin, kRightMargin);
   plot->SetSuggestedYAxis(0, 1, "Latency change (ms)", kBottomMargin,
                           kTopMargin);
   plot->SetTitle("Network latency change between consecutive packets");
 }
 
 void EventLogAnalyzer::CreateAccumulatedDelayChangeGraph(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() != kIncomingPacket ||
         !MatchingSsrc(stream_id.GetSsrc(), desired_ssrc_) ||
         IsAudioSsrc(stream_id) || !IsVideoSsrc(stream_id) ||
         IsRtxSsrc(stream_id)) {
       continue;
     }
 
     TimeSeries capture_time_data;
     capture_time_data.label = GetStreamName(stream_id) + " capture-time";
     capture_time_data.style = LINE_GRAPH;
-    Pairwise<Accumulated<NetworkDelayDiff::CaptureTime>>(
-        packet_stream, begin_time_, &capture_time_data);
+
+    Process<Accumulated<Pairwise<LoggedRtpPacket, double>>>(
+        packet_stream, begin_time_, &capture_time_data,
+        NetworkDelayDiffCaptureTime);
+
     plot->series_list_.push_back(std::move(capture_time_data));
 
     TimeSeries send_time_data;
     send_time_data.label = GetStreamName(stream_id) + " abs-send-time";
     send_time_data.style = LINE_GRAPH;
-    Pairwise<Accumulated<NetworkDelayDiff::AbsSendTime>>(
-        packet_stream, begin_time_, &send_time_data);
+    Process<Accumulated<Pairwise<LoggedRtpPacket, double>>>(
+        packet_stream, begin_time_, &send_time_data, NetworkDelayAbsSendTime);
     plot->series_list_.push_back(std::move(send_time_data));
   }
 
   plot->SetXAxis(0, call_duration_s_, "Time (s)", kLeftMargin, kRightMargin);
   plot->SetSuggestedYAxis(0, 1, "Latency change (ms)", kBottomMargin,
                           kTopMargin);
   plot->SetTitle("Accumulated network latency change");
 }
 
 // Plot the fraction of packets lost (as perceived by the loss-based BWE).
@@ skipping 104 matching lines @@
     // Filter on direction and SSRC.
     if (stream_id.GetDirection() != desired_direction ||
         !MatchingSsrc(stream_id.GetSsrc(), desired_ssrc_)) {
       continue;
     }
 
     TimeSeries time_series;
     time_series.label = GetStreamName(stream_id);
     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);
+
+    MovingAverage<Pointwise<LoggedRtpPacket, float>>(
+        packet_stream, begin_time_, end_time_, window_duration_, step_,
+        bytes_to_kilobits, &time_series, [](const LoggedRtpPacket& packet) {
+          return rtc::Optional<float>(packet.total_length);
+        });
     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 312 matching lines @@
       }
     }
   }
 
   plot->SetXAxis(0, call_duration_s_, "Time (s)", kLeftMargin, kRightMargin);
   plot->SetSuggestedYAxis(0, 1, "Timestamp (90khz)", kBottomMargin, kTopMargin);
   plot->SetTitle("Timestamps");
 }
 
 void EventLogAnalyzer::CreateAudioEncoderTargetBitrateGraph(Plot* plot) {
-  FillAudioEncoderTimeSeries(
-      plot, [](const AudioNetworkAdaptationEvent& ana_event) {
+  plot->series_list_.push_back(TimeSeries());
+  plot->series_list_.back().style = LINE_DOT_GRAPH;
+  Process<Pointwise<AudioNetworkAdaptationEvent, float>>(
+      audio_network_adaptation_events_, begin_time_, &plot->series_list_.back(),
+      [](const AudioNetworkAdaptationEvent& ana_event) {
         if (ana_event.config.bitrate_bps)
           return rtc::Optional<float>(
               static_cast<float>(*ana_event.config.bitrate_bps));
         return rtc::Optional<float>();
       });
   plot->series_list_.back().label = "Audio encoder target bitrate";
   plot->SetXAxis(0, call_duration_s_, "Time (s)", kLeftMargin, kRightMargin);
   plot->SetSuggestedYAxis(0, 1, "Bitrate (bps)", kBottomMargin, kTopMargin);
   plot->SetTitle("Reported audio encoder target bitrate");
 }
 
 void EventLogAnalyzer::CreateAudioEncoderFrameLengthGraph(Plot* plot) {
-  FillAudioEncoderTimeSeries(
-      plot, [](const AudioNetworkAdaptationEvent& ana_event) {
+  plot->series_list_.push_back(TimeSeries());
+  plot->series_list_.back().style = LINE_DOT_GRAPH;
+  Process<Pointwise<AudioNetworkAdaptationEvent, float>>(
+      audio_network_adaptation_events_, begin_time_, &plot->series_list_.back(),
+      [](const AudioNetworkAdaptationEvent& ana_event) {
         if (ana_event.config.frame_length_ms)
           return rtc::Optional<float>(
               static_cast<float>(*ana_event.config.frame_length_ms));
         return rtc::Optional<float>();
       });
   plot->series_list_.back().label = "Audio encoder frame length";
   plot->SetXAxis(0, call_duration_s_, "Time (s)", kLeftMargin, kRightMargin);
   plot->SetSuggestedYAxis(0, 1, "Frame length (ms)", kBottomMargin, kTopMargin);
   plot->SetTitle("Reported audio encoder frame length");
 }
 
 void EventLogAnalyzer::CreateAudioEncoderUplinkPacketLossFractionGraph(
     Plot* plot) {
-  FillAudioEncoderTimeSeries(
-      plot, [&](const AudioNetworkAdaptationEvent& ana_event) {
+  plot->series_list_.push_back(TimeSeries());
+  plot->series_list_.back().style = LINE_DOT_GRAPH;
+  Process<Pointwise<AudioNetworkAdaptationEvent, float>>(
+      audio_network_adaptation_events_, begin_time_, &plot->series_list_.back(),
+      [&](const AudioNetworkAdaptationEvent& ana_event) {
         if (ana_event.config.uplink_packet_loss_fraction)
           return rtc::Optional<float>(static_cast<float>(
               *ana_event.config.uplink_packet_loss_fraction));
         return rtc::Optional<float>();
       });
   plot->series_list_.back().label = "Audio encoder uplink packet loss fraction";
   plot->SetXAxis(0, call_duration_s_, "Time (s)", kLeftMargin, kRightMargin);
   plot->SetSuggestedYAxis(0, 10, "Percent lost packets", kBottomMargin,
                           kTopMargin);
   plot->SetTitle("Reported audio encoder lost packets");
 }
 
 void EventLogAnalyzer::CreateAudioEncoderEnableFecGraph(Plot* plot) {
-  FillAudioEncoderTimeSeries(
-      plot, [&](const AudioNetworkAdaptationEvent& ana_event) {
+  plot->series_list_.push_back(TimeSeries());
+  plot->series_list_.back().style = LINE_DOT_GRAPH;
+  Process<Pointwise<AudioNetworkAdaptationEvent, float>>(
+      audio_network_adaptation_events_, begin_time_, &plot->series_list_.back(),
+      [&](const AudioNetworkAdaptationEvent& ana_event) {
         if (ana_event.config.enable_fec)
           return rtc::Optional<float>(
               static_cast<float>(*ana_event.config.enable_fec));
         return rtc::Optional<float>();
       });
   plot->series_list_.back().label = "Audio encoder FEC";
   plot->SetXAxis(0, call_duration_s_, "Time (s)", kLeftMargin, kRightMargin);
   plot->SetSuggestedYAxis(0, 1, "FEC (false/true)", kBottomMargin, kTopMargin);
   plot->SetTitle("Reported audio encoder FEC");
 }
 
 void EventLogAnalyzer::CreateAudioEncoderEnableDtxGraph(Plot* plot) {
-  FillAudioEncoderTimeSeries(
-      plot, [&](const AudioNetworkAdaptationEvent& ana_event) {
+  plot->series_list_.push_back(TimeSeries());
+  plot->series_list_.back().style = LINE_DOT_GRAPH;
+  Process<Pointwise<AudioNetworkAdaptationEvent, float>>(
+      audio_network_adaptation_events_, begin_time_, &plot->series_list_.back(),
+      [&](const AudioNetworkAdaptationEvent& ana_event) {
         if (ana_event.config.enable_dtx)
           return rtc::Optional<float>(
               static_cast<float>(*ana_event.config.enable_dtx));
         return rtc::Optional<float>();
       });
   plot->series_list_.back().label = "Audio encoder DTX";
   plot->SetXAxis(0, call_duration_s_, "Time (s)", kLeftMargin, kRightMargin);
   plot->SetSuggestedYAxis(0, 1, "DTX (false/true)", kBottomMargin, kTopMargin);
   plot->SetTitle("Reported audio encoder DTX");
 }
 
 void EventLogAnalyzer::CreateAudioEncoderNumChannelsGraph(Plot* plot) {
-  FillAudioEncoderTimeSeries(
-      plot, [&](const AudioNetworkAdaptationEvent& ana_event) {
+  plot->series_list_.push_back(TimeSeries());
+  plot->series_list_.back().style = LINE_DOT_GRAPH;
+  Process<Pointwise<AudioNetworkAdaptationEvent, float>>(
+      audio_network_adaptation_events_, begin_time_, &plot->series_list_.back(),
+      [&](const AudioNetworkAdaptationEvent& ana_event) {
         if (ana_event.config.num_channels)
           return rtc::Optional<float>(
               static_cast<float>(*ana_event.config.num_channels));
         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