diff --git a/webrtc/modules/remote_bitrate_estimator/transport_feedback_adapter.cc b/webrtc/modules/remote_bitrate_estimator/transport_feedback_adapter.cc index f691198441..b1be50588e 100644 --- a/webrtc/modules/remote_bitrate_estimator/transport_feedback_adapter.cc +++ b/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); } -void TransportFeedbackAdapter::OnTransportFeedback( +const std::vector 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. @@ -125,7 +125,13 @@ void TransportFeedbackAdapter::OnTransportFeedback( << ". Send time history too small?"; } } + return packet_feedback_vector; +} +void TransportFeedbackAdapter::OnTransportFeedback( + const rtcp::TransportFeedback& feedback) { + const std::vector packet_feedback_vector = + GetPacketFeedbackVector(feedback); RTC_DCHECK(bitrate_estimator_.get() != nullptr); bitrate_estimator_->IncomingPacketFeedbackVector(packet_feedback_vector); } diff --git a/webrtc/modules/remote_bitrate_estimator/transport_feedback_adapter.h b/webrtc/modules/remote_bitrate_estimator/transport_feedback_adapter.h index 7e75112ed6..b15185f4a2 100644 --- a/webrtc/modules/remote_bitrate_estimator/transport_feedback_adapter.h +++ b/webrtc/modules/remote_bitrate_estimator/transport_feedback_adapter.h @@ -43,6 +43,9 @@ class TransportFeedbackAdapter : public TransportFeedbackObserver, size_t length, int probe_cluster_id) override; void OnSentPacket(uint16_t sequence_number, int64_t send_time_ms); + + const std::vector GetPacketFeedbackVector( + const rtcp::TransportFeedback& feedback); void OnTransportFeedback(const rtcp::TransportFeedback& feedback) override; // Implements CallStatsObserver. diff --git a/webrtc/tools/event_log_visualizer/analyzer.cc b/webrtc/tools/event_log_visualizer/analyzer.cc index c97a30fc0e..b1f87227a7 100644 --- a/webrtc/tools/event_log_visualizer/analyzer.cc +++ b/webrtc/tools/event_log_visualizer/analyzer.cc @@ -757,8 +757,7 @@ void EventLogAnalyzer::CreateBweGraph(Plot* plot) { while (time_us != std::numeric_limits::max()) { clock.AdvanceTimeMicroseconds(time_us - clock.TimeInMicroseconds()); if (clock.TimeInMicroseconds() >= NextRtcpTime()) { - clock.AdvanceTimeMilliseconds(rtcp_iterator->first / 1000 - - clock.TimeInMilliseconds()); + RTC_DCHECK_EQ(clock.TimeInMicroseconds(), NextRtcpTime()); const LoggedRtcpPacket& rtcp = *rtcp_iterator->second; if (rtcp.type == kRtcpTransportFeedback) { cc.GetTransportFeedbackObserver()->OnTransportFeedback( @@ -767,8 +766,7 @@ void EventLogAnalyzer::CreateBweGraph(Plot* plot) { ++rtcp_iterator; } if (clock.TimeInMicroseconds() >= NextRtpTime()) { - clock.AdvanceTimeMilliseconds(rtp_iterator->first / 1000 - - clock.TimeInMilliseconds()); + RTC_DCHECK_EQ(clock.TimeInMicroseconds(), NextRtpTime()); const LoggedRtpPacket& rtp = *rtp_iterator->second; if (rtp.header.extension.hasTransportSequenceNumber) { RTC_DCHECK(rtp.header.extension.hasTransportSequenceNumber); @@ -780,8 +778,10 @@ void EventLogAnalyzer::CreateBweGraph(Plot* plot) { } ++rtp_iterator; } - if (clock.TimeInMicroseconds() >= NextProcessTime()) + if (clock.TimeInMicroseconds() >= NextProcessTime()) { + RTC_DCHECK_EQ(clock.TimeInMicroseconds(), NextProcessTime()); cc.Process(); + } if (observer.GetAndResetBitrateUpdated()) { uint32_t y = observer.last_bitrate_bps() / 1000; float x = static_cast(clock.TimeInMicroseconds() - begin_time_) / @@ -798,5 +798,93 @@ void EventLogAnalyzer::CreateBweGraph(Plot* plot) { plot->SetTitle("Simulated BWE behavior"); } +void EventLogAnalyzer::CreateNetworkDelayFeebackGraph(Plot* plot) { + std::map outgoing_rtp; + std::map incoming_rtcp; + + for (const auto& kv : rtp_packets_) { + if (kv.first.GetDirection() == PacketDirection::kOutgoingPacket) { + for (const LoggedRtpPacket& rtp_packet : kv.second) + outgoing_rtp.insert(std::make_pair(rtp_packet.timestamp, &rtp_packet)); + } + } + + for (const auto& kv : rtcp_packets_) { + if (kv.first.GetDirection() == PacketDirection::kIncomingPacket) { + for (const LoggedRtcpPacket& rtcp_packet : kv.second) + incoming_rtcp.insert( + std::make_pair(rtcp_packet.timestamp, &rtcp_packet)); + } + } + + SimulatedClock clock(0); + TransportFeedbackAdapter feedback_adapter(nullptr, &clock); + + TimeSeries time_series; + time_series.label = "Network Delay Change"; + time_series.style = LINE_DOT_GRAPH; + int64_t estimated_base_delay_ms = std::numeric_limits::max(); + + auto rtp_iterator = outgoing_rtp.begin(); + auto rtcp_iterator = incoming_rtcp.begin(); + + auto NextRtpTime = [&]() { + if (rtp_iterator != outgoing_rtp.end()) + return static_cast(rtp_iterator->first); + return std::numeric_limits::max(); + }; + + auto NextRtcpTime = [&]() { + if (rtcp_iterator != incoming_rtcp.end()) + return static_cast(rtcp_iterator->first); + return std::numeric_limits::max(); + }; + + int64_t time_us = std::min(NextRtpTime(), NextRtcpTime()); + while (time_us != std::numeric_limits::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 feedback = + feedback_adapter.GetPacketFeedbackVector( + *static_cast(rtcp.packet.get())); + for (const PacketInfo& packet : feedback) { + int64_t y = packet.arrival_time_ms - packet.send_time_ms; + float x = + static_cast(clock.TimeInMicroseconds() - begin_time_) / + 1000000; + estimated_base_delay_ms = std::min(y, estimated_base_delay_ms); + 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); + feedback_adapter.AddPacket(rtp.header.extension.transportSequenceNumber, + rtp.total_length, 0); + feedback_adapter.OnSentPacket( + rtp.header.extension.transportSequenceNumber, rtp.timestamp / 1000); + } + ++rtp_iterator; + } + time_us = std::min(NextRtpTime(), NextRtcpTime()); + } + // We assume that the base network delay (w/o queues) is the min delay + // observed during the call. + for (TimeSeriesPoint& point : time_series.points) + 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 diff --git a/webrtc/tools/event_log_visualizer/analyzer.h b/webrtc/tools/event_log_visualizer/analyzer.h index bb4db2b824..2853e86ad0 100644 --- a/webrtc/tools/event_log_visualizer/analyzer.h +++ b/webrtc/tools/event_log_visualizer/analyzer.h @@ -47,6 +47,8 @@ class EventLogAnalyzer { void CreateBweGraph(Plot* plot); + void CreateNetworkDelayFeebackGraph(Plot* plot); + private: class StreamId { public: diff --git a/webrtc/tools/event_log_visualizer/generate_timeseries.cc b/webrtc/tools/event_log_visualizer/generate_timeseries.cc index 20d369620b..273dcfa337 100644 --- a/webrtc/tools/event_log_visualizer/generate_timeseries.cc +++ b/webrtc/tools/event_log_visualizer/generate_timeseries.cc @@ -47,6 +47,10 @@ DEFINE_bool(plot_bwe, false, "Run the bandwidth estimator with the logged rtp and rtcp and plot " "the output."); +DEFINE_bool(plot_network_delay_feedback, + false, + "Compute network delay based on sent packets and the received " + "transport feedback."); int main(int argc, char* argv[]) { std::string program_name = argv[0]; @@ -140,6 +144,10 @@ int main(int argc, char* argv[]) { analyzer.CreateBweGraph(collection->AppendNewPlot()); } + if (FLAGS_plot_all || FLAGS_plot_network_delay_feedback) { + analyzer.CreateNetworkDelayFeebackGraph(collection->AppendNewPlot()); + } + collection->Draw(); return 0;