Add time line for acked bitrate.

R=philipel@webrtc.org

Review URL: https://codereview.webrtc.org/2310943002 .

Cr-Commit-Position: refs/heads/master@{#14098}

webrtc/modules/remote_bitrate_estimator/transport_feedback_adapter.cc

@@ -70,7 +70,7 @@ void TransportFeedbackAdapter::OnSentPacket(uint16_t sequence_number,
   send_time_history_.OnSentPacket(sequence_number, send_time_ms);
 }
 
-const std::vector<PacketInfo> TransportFeedbackAdapter::GetPacketFeedbackVector(
+std::vector<PacketInfo> TransportFeedbackAdapter::GetPacketFeedbackVector(
     const rtcp::TransportFeedback& feedback) {
   int64_t timestamp_us = feedback.GetBaseTimeUs();
   // Add timestamp deltas to a local time base selected on first packet arrival.
@@ -130,10 +130,15 @@ const std::vector<PacketInfo> TransportFeedbackAdapter::GetPacketFeedbackVector(
 
 void TransportFeedbackAdapter::OnTransportFeedback(
     const rtcp::TransportFeedback& feedback) {
-  const std::vector<PacketInfo> packet_feedback_vector =
-      GetPacketFeedbackVector(feedback);
-  RTC_DCHECK(bitrate_estimator_.get() != nullptr);
-  bitrate_estimator_->IncomingPacketFeedbackVector(packet_feedback_vector);
+  last_packet_feedback_vector_ = GetPacketFeedbackVector(feedback);
+  if (bitrate_estimator_.get())
+    bitrate_estimator_->IncomingPacketFeedbackVector(
+        last_packet_feedback_vector_);
+}
+
+std::vector<PacketInfo> TransportFeedbackAdapter::GetTransportFeedbackVector()
+    const {
+  return last_packet_feedback_vector_;
 }
 
 void TransportFeedbackAdapter::OnReceiveBitrateChanged(

webrtc/modules/remote_bitrate_estimator/transport_feedback_adapter.h

@@ -44,9 +44,8 @@ class TransportFeedbackAdapter : public TransportFeedbackObserver,
                  int probe_cluster_id) override;
   void OnSentPacket(uint16_t sequence_number, int64_t send_time_ms);
 
-  const std::vector<PacketInfo> GetPacketFeedbackVector(
-      const rtcp::TransportFeedback& feedback);
   void OnTransportFeedback(const rtcp::TransportFeedback& feedback) override;
+  std::vector<PacketInfo> GetTransportFeedbackVector() const override;
 
   // Implements CallStatsObserver.
   void OnRttUpdate(int64_t avg_rtt_ms, int64_t max_rtt_ms) override;
@@ -58,6 +57,9 @@ class TransportFeedbackAdapter : public TransportFeedbackObserver,
 
   void OnProbeBitrate(uint32_t bitrate) override;
 
+  std::vector<PacketInfo> GetPacketFeedbackVector(
+      const rtcp::TransportFeedback& feedback);
+
   rtc::CriticalSection lock_;
   SendTimeHistory send_time_history_ GUARDED_BY(&lock_);
   BitrateController* bitrate_controller_;
@@ -65,6 +67,7 @@ class TransportFeedbackAdapter : public TransportFeedbackObserver,
   Clock* const clock_;
   int64_t current_offset_ms_;
   int64_t last_timestamp_us_;
+  std::vector<PacketInfo> last_packet_feedback_vector_;
 };
 
 }  // namespace webrtc

webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h

@@ -13,6 +13,7 @@
 
 #include <stddef.h>
 #include <list>
+#include <vector>
 
 #include "webrtc/modules/include/module_common_types.h"
 #include "webrtc/system_wrappers/include/clock.h"
@@ -310,6 +311,8 @@ class TransportFeedbackObserver {
                          int probe_cluster_id) = 0;
 
   virtual void OnTransportFeedback(const rtcp::TransportFeedback& feedback) = 0;
+
+  virtual std::vector<PacketInfo> GetTransportFeedbackVector() const = 0;
 };
 
 class RtcpRttStats {

webrtc/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc

@@ -77,6 +77,7 @@ class MockTransportFeedbackObserver : public TransportFeedbackObserver {
  public:
   MOCK_METHOD3(AddPacket, void(uint16_t, size_t, int));
   MOCK_METHOD1(OnTransportFeedback, void(const rtcp::TransportFeedback&));
+  MOCK_CONST_METHOD0(GetTransportFeedbackVector, std::vector<PacketInfo>());
 };
 
 class MockRtcpBandwidthObserver : public RtcpBandwidthObserver {

webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc

@@ -137,6 +137,7 @@ class MockTransportFeedbackObserver : public TransportFeedbackObserver {
  public:
   MOCK_METHOD3(AddPacket, void(uint16_t, size_t, int));
   MOCK_METHOD1(OnTransportFeedback, void(const rtcp::TransportFeedback&));
+  MOCK_CONST_METHOD0(GetTransportFeedbackVector, std::vector<PacketInfo>());
 };
 
 class RtpSenderTest : public ::testing::Test {

webrtc/tools/event_log_visualizer/analyzer.cc

@@ -21,6 +21,7 @@
 #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"
@@ -835,6 +836,9 @@ void EventLogAnalyzer::CreateBweSimulationGraph(Plot* plot) {
   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();
@@ -860,6 +864,8 @@ void EventLogAnalyzer::CreateBweSimulationGraph(Plot* plot) {
     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());
@@ -867,8 +873,23 @@ void EventLogAnalyzer::CreateBweSimulationGraph(Plot* plot) {
       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()));
+        TransportFeedbackObserver* observer = cc.GetTransportFeedbackObserver();
+        observer->OnTransportFeedback(*static_cast<rtcp::TransportFeedback*>(
+            rtcp.packet.get()));
+        std::vector<PacketInfo> feedback =
+            observer->GetTransportFeedbackVector();
+        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;
     }
@@ -900,6 +921,7 @@ void EventLogAnalyzer::CreateBweSimulationGraph(Plot* plot) {
   }
   // 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);
@@ -955,9 +977,10 @@ void EventLogAnalyzer::CreateNetworkDelayFeedbackGraph(Plot* plot) {
       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<PacketInfo> feedback =
-            feedback_adapter.GetPacketFeedbackVector(
-                *static_cast<rtcp::TransportFeedback*>(rtcp.packet.get()));
+          feedback_adapter.GetTransportFeedbackVector();
         for (const PacketInfo& packet : feedback) {
           int64_t y = packet.arrival_time_ms - packet.send_time_ms;
           float x =

webrtc/voice_engine/channel.cc

@@ -169,8 +169,11 @@ class TransportFeedbackProxy : public TransportFeedbackObserver {
   void OnTransportFeedback(const rtcp::TransportFeedback& feedback) override {
     RTC_DCHECK(network_thread_.CalledOnValidThread());
     rtc::CritScope lock(&crit_);
-    if (feedback_observer_)
-      feedback_observer_->OnTransportFeedback(feedback);
+    feedback_observer_->OnTransportFeedback(feedback);
+  }
+  std::vector<PacketInfo> GetTransportFeedbackVector() const override {
+    RTC_NOTREACHED();
+    return std::vector<PacketInfo>();
   }
 
  private: