Convenience functions to set axis properties in 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 14 matching lines @@
 #include "webrtc/common_types.h"
 #include "webrtc/modules/congestion_controller/include/congestion_controller.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_utility.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
 #include "webrtc/video_receive_stream.h"
 #include "webrtc/video_send_stream.h"
 
+namespace webrtc {
+namespace plotting {
+
 namespace {
 
 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.
@@ skipping 38 matching lines @@
 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);
   }
 }
 
-const double kXMargin = 1.02;
-const double kYMargin = 1.1;
-const double kDefaultXMin = -1;
-const double kDefaultYMin = -1;
+constexpr float kLeftMargin = 0.01f;
+constexpr float kRightMargin = 0.02f;
+constexpr float kBottomMargin = 0.02f;
+constexpr float kTopMargin = 0.05f;
 
 }  // namespace
 
-namespace webrtc {
-namespace plotting {
-
-
 bool EventLogAnalyzer::StreamId::operator<(const StreamId& other) const {
   if (ssrc_ < other.ssrc_) {
     return true;
   }
   if (ssrc_ == other.ssrc_) {
     if (direction_ < other.direction_) {
       return true;
     }
   }
   return false;
@@ skipping 151 matching lines @@
       }
     }
   }
 
   if (last_timestamp < first_timestamp) {
     // No useful events in the log.
     first_timestamp = last_timestamp = 0;
   }
   begin_time_ = first_timestamp;
   end_time_ = last_timestamp;
+  call_duration_s_ = static_cast<float>(end_time_ - begin_time_) / 1000000;
 }
 
 class BitrateObserver : public CongestionController::Observer,
                         public RemoteBitrateObserver {
  public:
   BitrateObserver() : last_bitrate_bps_(0), bitrate_updated_(false) {}
 
   void OnNetworkChanged(uint32_t bitrate_bps,
                         uint8_t fraction_loss,
                         int64_t rtt_ms) override {
@@ skipping 17 matching lines @@
 };
 
 void EventLogAnalyzer::CreatePacketGraph(PacketDirection desired_direction,
                                          Plot* plot) {
   std::map<uint32_t, TimeSeries> time_series;
 
   PacketDirection direction;
   MediaType media_type;
   uint8_t header[IP_PACKET_SIZE];
   size_t header_length, total_length;
-  float max_y = 0;
 
   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;
-          max_y = std::max(max_y, y);
           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.push_back(std::move(kv.second));
+    plot->series_list_.push_back(std::move(kv.second));
   }
 
-  plot->xaxis_min = kDefaultXMin;
-  plot->xaxis_max = (end_time_ - begin_time_) / 1000000 * kXMargin;
-  plot->xaxis_label = "Time (s)";
-  plot->yaxis_min = kDefaultYMin;
-  plot->yaxis_max = max_y * kYMargin;
-  plot->yaxis_label = "Packet size (bytes)";
+  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->title = "Incoming RTP packets";
+    plot->SetTitle("Incoming RTP packets");
   } else if (desired_direction == webrtc::PacketDirection::kOutgoingPacket) {
-    plot->title = "Outgoing RTP packets";
+    plot->SetTitle("Outgoing RTP packets");
   }
 }
 
 // For each SSRC, plot the time between the consecutive playouts.
 void EventLogAnalyzer::CreatePlayoutGraph(Plot* plot) {
   std::map<uint32_t, TimeSeries> time_series;
   std::map<uint32_t, uint64_t> last_playout;
 
   uint32_t ssrc;
-  float max_y = 0;
 
   for (size_t i = 0; i < parsed_log_.GetNumberOfEvents(); i++) {
     ParsedRtcEventLog::EventType event_type = parsed_log_.GetEventType(i);
     if (event_type == ParsedRtcEventLog::AUDIO_PLAYOUT_EVENT) {
       parsed_log_.GetAudioPlayout(i, &ssrc);
       uint64_t timestamp = parsed_log_.GetTimestamp(i);
       if (MatchingSsrc(ssrc, desired_ssrc_)) {
         float x = static_cast<float>(timestamp - begin_time_) / 1000000;
         float y = static_cast<float>(timestamp - last_playout[ssrc]) / 1000;
         if (time_series[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;
         }
-        max_y = std::max(max_y, y);
         time_series[ssrc].points.push_back(TimeSeriesPoint(x, y));
         last_playout[ssrc] = timestamp;
       }
     }
   }
 
   // Set labels and put in graph.
   for (auto& kv : time_series) {
     kv.second.label = SsrcToString(kv.first);
     kv.second.style = BAR_GRAPH;
-    plot->series.push_back(std::move(kv.second));
+    plot->series_list_.push_back(std::move(kv.second));
   }
 
-  plot->xaxis_min = kDefaultXMin;
-  plot->xaxis_max = (end_time_ - begin_time_) / 1000000 * kXMargin;
-  plot->xaxis_label = "Time (s)";
-  plot->yaxis_min = kDefaultYMin;
-  plot->yaxis_max = max_y * kYMargin;
-  plot->yaxis_label = "Time since last playout (ms)";
-  plot->title = "Audio playout";
+  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;
 
   PacketDirection direction;
   MediaType media_type;
   uint8_t header[IP_PACKET_SIZE];
   size_t header_length, total_length;
 
-  int max_y = 1;
-  int min_y = 0;
-
   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;
           }
-          max_y = std::max(max_y, y);
-          min_y = std::min(min_y, y);
           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.push_back(std::move(kv.second));
+    plot->series_list_.push_back(std::move(kv.second));
   }
 
-  plot->xaxis_min = kDefaultXMin;
-  plot->xaxis_max = (end_time_ - begin_time_) / 1000000 * kXMargin;
-  plot->xaxis_label = "Time (s)";
-  plot->yaxis_min = min_y - (kYMargin - 1) / 2 * (max_y - min_y);
-  plot->yaxis_max = max_y + (kYMargin - 1) / 2 * (max_y - min_y);
-  plot->yaxis_label = "Difference since last packet";
-  plot->title = "Sequence number";
+  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) {
-  double max_y = 10;
-  double min_y = 0;
-
   for (auto& kv : rtp_packets_) {
     StreamId stream_id = kv.first;
     // Filter on direction and SSRC.
     if (stream_id.GetDirection() != kIncomingPacket ||
         !MatchingSsrc(stream_id.GetSsrc(), desired_ssrc_)) {
       continue;
     }
 
     TimeSeries time_series;
     time_series.label = SsrcToString(stream_id.GetSsrc());
@@ skipping 14 matching lines @@
         float x = static_cast<float>(packet.timestamp - begin_time_) / 1000000;
         double y =
             static_cast<double>(recv_time_diff -
                                 AbsSendTimeToMicroseconds(send_time_diff)) /
             1000;
         if (time_series.points.size() == 0) {
           // There were no previously logged packets for this SSRC.
           // Generate a point, but place it on the x-axis.
           y = 0;
         }
-        max_y = std::max(max_y, y);
-        min_y = std::min(min_y, y);
         time_series.points.emplace_back(x, y);
       }
     }
     // Add the data set to the plot.
-    plot->series.push_back(std::move(time_series));
+    plot->series_list_.push_back(std::move(time_series));
   }
 
-  plot->xaxis_min = kDefaultXMin;
-  plot->xaxis_max = (end_time_ - begin_time_) / 1000000 * kXMargin;
-  plot->xaxis_label = "Time (s)";
-  plot->yaxis_min = min_y - (kYMargin - 1) / 2 * (max_y - min_y);
-  plot->yaxis_max = max_y + (kYMargin - 1) / 2 * (max_y - min_y);
-  plot->yaxis_label = "Latency change (ms)";
-  plot->title = "Network latency change between consecutive packets";
+  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) {
-  double max_y = 10;
-  double min_y = 0;
-
   for (auto& kv : rtp_packets_) {
     StreamId stream_id = kv.first;
     // Filter on direction and SSRC.
     if (stream_id.GetDirection() != kIncomingPacket ||
         !MatchingSsrc(stream_id.GetSsrc(), desired_ssrc_)) {
       continue;
     }
     TimeSeries time_series;
     time_series.label = SsrcToString(stream_id.GetSsrc());
     time_series.style = LINE_GRAPH;
@@ skipping 14 matching lines @@
         float x = static_cast<float>(packet.timestamp - begin_time_) / 1000000;
         accumulated_delay_ms +=
             static_cast<double>(recv_time_diff -
                                 AbsSendTimeToMicroseconds(send_time_diff)) /
             1000;
         if (time_series.points.size() == 0) {
           // There were no previously logged packets for this SSRC.
           // Generate a point, but place it on the x-axis.
           accumulated_delay_ms = 0;
         }
-        max_y = std::max(max_y, accumulated_delay_ms);
-        min_y = std::min(min_y, accumulated_delay_ms);
         time_series.points.emplace_back(x, accumulated_delay_ms);
       }
     }
     // Add the data set to the plot.
-    plot->series.push_back(std::move(time_series));
+    plot->series_list_.push_back(std::move(time_series));
   }
 
-  plot->xaxis_min = kDefaultXMin;
-  plot->xaxis_max = (end_time_ - begin_time_) / 1000000 * kXMargin;
-  plot->xaxis_label = "Time (s)";
-  plot->yaxis_min = min_y - (kYMargin - 1) / 2 * (max_y - min_y);
-  plot->yaxis_max = max_y + (kYMargin - 1) / 2 * (max_y - min_y);
-  plot->yaxis_label = "Latency change (ms)";
-  plot->title = "Accumulated network latency change";
+  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 total bandwidth used by all RTP streams.
 void EventLogAnalyzer::CreateTotalBitrateGraph(
     PacketDirection desired_direction,
     Plot* plot) {
   struct TimestampSize {
     TimestampSize(uint64_t t, size_t s) : timestamp(t), size(s) {}
     uint64_t timestamp;
     size_t size;
@@ skipping 12 matching lines @@
       if (direction == desired_direction) {
         uint64_t timestamp = parsed_log_.GetTimestamp(i);
         packets.push_back(TimestampSize(timestamp, total_length));
       }
     }
   }
 
   size_t window_index_begin = 0;
   size_t window_index_end = 0;
   size_t bytes_in_window = 0;
-  float max_y = 0;
 
   // Calculate a moving average of the bitrate and store in a TimeSeries.
-  plot->series.push_back(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++;
     }
     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++;
     }
     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;
-    max_y = std::max(max_y, y);
-    plot->series.back().points.push_back(TimeSeriesPoint(x, y));
+    plot->series_list_.back().points.push_back(TimeSeriesPoint(x, y));
   }
 
   // Set labels.
   if (desired_direction == webrtc::PacketDirection::kIncomingPacket) {
-    plot->series.back().label = "Incoming bitrate";
+    plot->series_list_.back().label = "Incoming bitrate";
   } else if (desired_direction == webrtc::PacketDirection::kOutgoingPacket) {
-    plot->series.back().label = "Outgoing bitrate";
+    plot->series_list_.back().label = "Outgoing bitrate";
   }
-  plot->series.back().style = LINE_GRAPH;
+  plot->series_list_.back().style = LINE_GRAPH;
 
   // Overlay the send-side bandwidth estimate over the outgoing bitrate.
   if (desired_direction == kOutgoingPacket) {
-    plot->series.push_back(TimeSeries());
+    plot->series_list_.push_back(TimeSeries());
     for (auto& bwe_update : bwe_loss_updates_) {
       float x =
           static_cast<float>(bwe_update.timestamp - begin_time_) / 1000000;
       float y = static_cast<float>(bwe_update.new_bitrate) / 1000;
-      max_y = std::max(max_y, y);
-      plot->series.back().points.emplace_back(x, y);
+      plot->series_list_.back().points.emplace_back(x, y);
     }
-    plot->series.back().label = "Loss-based estimate";
-    plot->series.back().style = LINE_GRAPH;
+    plot->series_list_.back().label = "Loss-based estimate";
+    plot->series_list_.back().style = LINE_GRAPH;
   }
-
-  plot->xaxis_min = kDefaultXMin;
-  plot->xaxis_max = (end_time_ - begin_time_) / 1000000 * kXMargin;
-  plot->xaxis_label = "Time (s)";
-  plot->yaxis_min = kDefaultYMin;
-  plot->yaxis_max = max_y * kYMargin;
-  plot->yaxis_label = "Bitrate (kbps)";
+  plot->series_list_.back().style = LINE_GRAPH;
+  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->title = "Incoming RTP bitrate";
+    plot->SetTitle("Incoming RTP bitrate");
   } else if (desired_direction == webrtc::PacketDirection::kOutgoingPacket) {
-    plot->title = "Outgoing RTP bitrate";
+    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;
@@ skipping 20 matching lines @@
         // 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));
         }
       }
     }
   }
 
-  float max_y = 0;
-
   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.push_back(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;
-      max_y = std::max(max_y, y);
-      plot->series.back().points.push_back(TimeSeriesPoint(x, y));
+      plot->series_list_.back().points.push_back(TimeSeriesPoint(x, y));
     }
 
     // Set labels.
-    plot->series.back().label = SsrcToString(kv.first);
-    plot->series.back().style = LINE_GRAPH;
+    plot->series_list_.back().label = SsrcToString(kv.first);
+    plot->series_list_.back().style = LINE_GRAPH;
   }
 
-  plot->xaxis_min = kDefaultXMin;
-  plot->xaxis_max = (end_time_ - begin_time_) / 1000000 * kXMargin;
-  plot->xaxis_label = "Time (s)";
-  plot->yaxis_min = kDefaultYMin;
-  plot->yaxis_max = max_y * kYMargin;
-  plot->yaxis_label = "Bitrate (kbps)";
+  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->title = "Incoming bitrate per stream";
+    plot->SetTitle("Incoming bitrate per stream");
   } else if (desired_direction == webrtc::PacketDirection::kOutgoingPacket) {
-    plot->title = "Outgoing bitrate per stream";
+    plot->SetTitle("Outgoing bitrate per stream");
   }
 }
 
 void EventLogAnalyzer::CreateBweGraph(Plot* plot) {
   std::map<uint64_t, const LoggedRtpPacket*> outgoing_rtp;
   std::map<uint64_t, const LoggedRtcpPacket*> incoming_rtcp;
 
   for (const auto& kv : rtp_packets_) {
     if (kv.first.GetDirection() == PacketDirection::kOutgoingPacket) {
       for (const LoggedRtpPacket& rtp_packet : kv.second)
@@ skipping 13 matching lines @@
   BitrateObserver observer;
   RtcEventLogNullImpl null_event_log;
   CongestionController cc(&clock, &observer, &observer, &null_event_log);
   // TODO(holmer): Log the call config and use that here instead.
   static const uint32_t kDefaultStartBitrateBps = 300000;
   cc.SetBweBitrates(0, kDefaultStartBitrateBps, -1);
 
   TimeSeries time_series;
   time_series.label = "BWE";
   time_series.style = LINE_DOT_GRAPH;
-  uint32_t max_y = 10;
-  uint32_t min_y = 0;
 
   auto rtp_iterator = outgoing_rtp.begin();
   auto rtcp_iterator = incoming_rtcp.begin();
 
   auto NextRtpTime = [&]() {
     if (rtp_iterator != outgoing_rtp.end())
       return static_cast<int64_t>(rtp_iterator->first);
     return std::numeric_limits<int64_t>::max();
   };
 
@@ skipping 36 matching lines @@
         rtc::SentPacket sent_packet(
             rtp.header.extension.transportSequenceNumber, rtp.timestamp / 1000);
         cc.OnSentPacket(sent_packet);
       }
       ++rtp_iterator;
     }
     if (clock.TimeInMicroseconds() >= NextProcessTime())
       cc.Process();
     if (observer.GetAndResetBitrateUpdated()) {
       uint32_t y = observer.last_bitrate_bps() / 1000;
-      max_y = std::max(max_y, y);
-      min_y = std::min(min_y, y);
       float x = static_cast<float>(clock.TimeInMicroseconds() - begin_time_) /
                 1000000;
       time_series.points.emplace_back(x, y);
     }
     time_us = std::min({NextRtpTime(), NextRtcpTime(), NextProcessTime()});
   }
   // Add the data set to the plot.
-  plot->series.push_back(std::move(time_series));
+  plot->series_list_.push_back(std::move(time_series));
 
-  plot->xaxis_min = kDefaultXMin;
-  plot->xaxis_max = (end_time_ - begin_time_) / 1000000 * kXMargin;
-  plot->xaxis_label = "Time (s)";
-  plot->yaxis_min = min_y - (kYMargin - 1) / 2 * (max_y - min_y);
-  plot->yaxis_max = max_y + (kYMargin - 1) / 2 * (max_y - min_y);
-  plot->yaxis_label = "Bitrate (kbps)";
-  plot->title = "BWE";
+  plot->SetXAxis(0, call_duration_s_, "Time (s)", kLeftMargin, kRightMargin);
+  plot->SetSuggestedYAxis(0, 10, "Bitrate (kbps)", kBottomMargin, kTopMargin);
+  plot->SetTitle("Simulated BWE behavior");
 }
 
 }  // namespace plotting
 }  // namespace webrtc