Add time line for acked bitrate.

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.
  */
 
 #include "webrtc/tools/event_log_visualizer/analyzer.h"
 
 #include <algorithm>
 #include <limits>
 #include <map>
 #include <sstream>
 #include <string>
 #include <utility>
 
 #include "webrtc/api/call/audio_receive_stream.h"
 #include "webrtc/api/call/audio_send_stream.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
+#include "webrtc/base/rate_statistics.h"
 #include "webrtc/call.h"
 #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"
@@ skipping 747 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 = "Delay-based estimate";
   time_series.style = LINE_DOT_GRAPH;
+  TimeSeries acked_time_series;
+  acked_time_series.label = "Acked bitrate";
+  acked_time_series.style = LINE_DOT_GRAPH;
 
   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();
   };
 
   auto NextRtcpTime = [&]() {
     if (rtcp_iterator != incoming_rtcp.end())
       return static_cast<int64_t>(rtcp_iterator->first);
     return std::numeric_limits<int64_t>::max();
   };
 
   auto NextProcessTime = [&]() {
     if (rtcp_iterator != incoming_rtcp.end() ||
         rtp_iterator != outgoing_rtp.end()) {
       return clock.TimeInMicroseconds() +
              std::max<int64_t>(cc.TimeUntilNextProcess() * 1000, 0);
     }
     return std::numeric_limits<int64_t>::max();
   };
 
+  RateStatistics acked_bitrate(1000, 8000);
+
   int64_t time_us = std::min(NextRtpTime(), NextRtcpTime());
   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) {
-        cc.GetTransportFeedbackObserver()->OnTransportFeedback(
-            *static_cast<rtcp::TransportFeedback*>(rtcp.packet.get()));
+        std::vector<PacketInfo> feedback =
+            cc.GetTransportFeedbackObserver()->OnTransportFeedback(

[philipel, 2016/09/05 13:30:05]

I think it's cleaner if you call both
TransportFeedbackAdapted::OnTransportFeedback to simulate the bwe behavior and
then call TransportFeedbackAdapater::GetPacketFeedbackVector to get the vector
of PacketInfos.

[stefan-webrtc, 2016/09/05 14:03:39]

Done.

[philipel, 2016/09/05 14:56:25]

Maybe something even cleaner would be to add a GetTransportFeedbackAdapter to
CongestionController.

Then you would only have to change CongestionController and in EventLogAnalyzer
all you have to do is:

TransportFeedbackAdapter* a = cc.GetTransportFeedbackAdapter();
std::vector<PacketInfo> pi =
a->OnTransportFeedback(*static_cast<rtcp::TransportFeedback*>(rtcp.packet.get());
a->GetBitrateEstimator()->IncomingPacketFeedbackVector(pi);

WDYT?

[stefan-webrtc, 2016/09/06 11:53:11]

I want to get rid of the GetBitrateEstimator() api (and at some point also
GetTransportFeedbackObserver()), so I want to rely as little as possible on
those.

+                *static_cast<rtcp::TransportFeedback*>(rtcp.packet.get()));
+        rtc::Optional<uint32_t> bitrate_bps;
+        if (!feedback.empty()) {
+          for (const PacketInfo& 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_) /
+                  1000000;
+        acked_time_series.points.emplace_back(x, y);
       }
       ++rtcp_iterator;
     }
     if (clock.TimeInMicroseconds() >= NextRtpTime()) {
       RTC_DCHECK_EQ(clock.TimeInMicroseconds(), NextRtpTime());
       const LoggedRtpPacket& rtp = *rtp_iterator->second;
       if (rtp.header.extension.hasTransportSequenceNumber) {
         RTC_DCHECK(rtp.header.extension.hasTransportSequenceNumber);
         cc.GetTransportFeedbackObserver()->AddPacket(
             rtp.header.extension.transportSequenceNumber, rtp.total_length,
@@ skipping 11 matching lines @@
     if (observer.GetAndResetBitrateUpdated()) {
       uint32_t y = observer.last_bitrate_bps() / 1000;
       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_list_.push_back(std::move(time_series));
+  plot->series_list_.push_back(std::move(acked_time_series));
 
   plot->SetXAxis(0, call_duration_s_, "Time (s)", kLeftMargin, kRightMargin);
   plot->SetSuggestedYAxis(0, 10, "Bitrate (kbps)", kBottomMargin, kTopMargin);
   plot->SetTitle("Simulated BWE behavior");
 }
 
 void EventLogAnalyzer::CreateNetworkDelayFeedbackGraph(Plot* plot) {
   std::map<uint64_t, const LoggedRtpPacket*> outgoing_rtp;
   std::map<uint64_t, const LoggedRtcpPacket*> incoming_rtcp;
 
@@ skipping 36 matching lines @@
   };
 
   int64_t time_us = std::min(NextRtpTime(), NextRtcpTime());
   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) {
         std::vector<PacketInfo> feedback =
-            feedback_adapter.GetPacketFeedbackVector(
+            feedback_adapter.OnTransportFeedback(
                 *static_cast<rtcp::TransportFeedback*>(rtcp.packet.get()));
         for (const PacketInfo& 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);
         }
       }
@@ skipping 19 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