From 26a029d407be480d791972afb5975cf62c9360a6 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Fri, 19 Apr 2024 02:47:55 +0200 Subject: Adding upstream version 124.0.1. Signed-off-by: Daniel Baumann --- .../rtc_event_log_visualizer/analyzer_bindings.cc | 140 +++++++++++++++++++++ 1 file changed, 140 insertions(+) create mode 100644 third_party/libwebrtc/rtc_tools/rtc_event_log_visualizer/analyzer_bindings.cc (limited to 'third_party/libwebrtc/rtc_tools/rtc_event_log_visualizer/analyzer_bindings.cc') diff --git a/third_party/libwebrtc/rtc_tools/rtc_event_log_visualizer/analyzer_bindings.cc b/third_party/libwebrtc/rtc_tools/rtc_event_log_visualizer/analyzer_bindings.cc new file mode 100644 index 0000000000..829591323f --- /dev/null +++ b/third_party/libwebrtc/rtc_tools/rtc_event_log_visualizer/analyzer_bindings.cc @@ -0,0 +1,140 @@ +/* + * Copyright (c) 2023 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 "rtc_tools/rtc_event_log_visualizer/analyzer_bindings.h" + +#include +#include +#include +#include + +#include "absl/strings/match.h" +#include "absl/strings/string_view.h" +#include "api/units/time_delta.h" +#include "logging/rtc_event_log/rtc_event_log_parser.h" +#include "rtc_base/numerics/safe_conversions.h" +#include "rtc_base/protobuf_utils.h" +#include "rtc_tools/rtc_event_log_visualizer/analyzer.h" +#include "rtc_tools/rtc_event_log_visualizer/analyzer_common.h" +#include "rtc_tools/rtc_event_log_visualizer/plot_base.h" + +#ifdef WEBRTC_ANDROID_PLATFORM_BUILD +#include "external/webrtc/webrtc/rtc_tools/rtc_event_log_visualizer/proto/chart.pb.h" +#else +#include "rtc_tools/rtc_event_log_visualizer/proto/chart.pb.h" +#endif + +using webrtc::PacketDirection; + +void analyze_rtc_event_log(const char* log_contents, + size_t log_size, + const char* selection, + size_t selection_size, + char* output, + uint32_t* output_size) { + webrtc::ParsedRtcEventLog parsed_log( + webrtc::ParsedRtcEventLog::UnconfiguredHeaderExtensions::kDontParse, + /*allow_incomplete_logs*/ false); + + absl::string_view log_view(log_contents, log_size); + auto status = parsed_log.ParseString(log_view); + if (!status.ok()) { + std::cerr << "Failed to parse log: " << status.message() << std::endl; + *output_size = 0; + return; + } + + webrtc::AnalyzerConfig config; + config.window_duration_ = webrtc::TimeDelta::Millis(250); + config.step_ = webrtc::TimeDelta::Millis(10); + if (!parsed_log.start_log_events().empty()) { + config.rtc_to_utc_offset_ = parsed_log.start_log_events()[0].utc_time() - + parsed_log.start_log_events()[0].log_time(); + } + config.normalize_time_ = true; + config.begin_time_ = parsed_log.first_timestamp(); + config.end_time_ = parsed_log.last_timestamp(); + if (config.end_time_ < config.begin_time_) { + std::cerr << "Log end time " << config.end_time_.ms() + << " not after begin time " << config.begin_time_.ms() + << ". Nothing to analyze. Is the log broken?"; + *output_size = 0; + return; + } + + absl::string_view selection_view(selection, selection_size); + webrtc::EventLogAnalyzer analyzer(parsed_log, config); + webrtc::PlotCollection collection; + collection.SetCallTimeToUtcOffsetMs(config.CallTimeToUtcOffsetMs()); + + // Outgoing + if (absl::StrContains(selection_view, "outgoing_packet_sizes")) { + analyzer.CreatePacketGraph( + PacketDirection::kOutgoingPacket, + collection.AppendNewPlot("outgoing_packet_sizes")); + } + if (absl::StrContains(selection_view, "outgoing_stream_bitrate")) { + analyzer.CreateStreamBitrateGraph( + PacketDirection::kOutgoingPacket, + collection.AppendNewPlot("outgoing_stream_bitrate")); + } + if (absl::StrContains(selection_view, "outgoing_bitrate")) { + analyzer.CreateTotalOutgoingBitrateGraph( + collection.AppendNewPlot("outgoing_bitrate"), + /*show_detector_state*/ true, + /*show_alr_state*/ false, + /*show_link_capacity*/ true); + } + if (absl::StrContains(selection_view, "network_delay_feedback")) { + analyzer.CreateNetworkDelayFeedbackGraph( + collection.AppendNewPlot("network_delay_feedback")); + } + if (absl::StrContains(selection_view, "fraction_loss_feedback")) { + analyzer.CreateFractionLossGraph( + collection.AppendNewPlot("fraction_loss_feedback")); + } + + // Incoming + if (absl::StrContains(selection_view, "incoming_packet_sizes")) { + analyzer.CreatePacketGraph( + PacketDirection::kIncomingPacket, + collection.AppendNewPlot("incoming_packet_sizes")); + } + if (absl::StrContains(selection_view, "incoming_stream_bitrate")) { + analyzer.CreateStreamBitrateGraph( + PacketDirection::kIncomingPacket, + collection.AppendNewPlot("incoming_stream_bitrate")); + } + if (absl::StrContains(selection_view, "incoming_bitrate")) { + analyzer.CreateTotalIncomingBitrateGraph( + collection.AppendNewPlot("incoming_bitrate")); + } + if (absl::StrContains(selection_view, "incoming_delay")) { + analyzer.CreateIncomingDelayGraph( + collection.AppendNewPlot("incoming_delay")); + } + if (absl::StrContains(selection_view, "incoming_loss_rate")) { + analyzer.CreateIncomingPacketLossGraph( + collection.AppendNewPlot("incoming_loss_rate")); + } + + webrtc::analytics::ChartCollection proto_charts; + collection.ExportProtobuf(&proto_charts); + std::string serialized_charts = proto_charts.SerializeAsString(); + if (rtc::checked_cast(serialized_charts.size()) > *output_size) { + std::cerr << "Serialized charts larger than available output buffer: " + << serialized_charts.size() << " vs " << *output_size; + *output_size = 0; + return; + } + + memcpy(output, serialized_charts.data(), serialized_charts.size()); + *output_size = rtc::checked_cast(serialized_charts.size()); +} -- cgit v1.2.3