Move NetEq and ANA plotting to a separate file.
Bug: webrtc:11566 Change-Id: I6d6176ff72a158a1629e14b539de2e928e7d02a9 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176510 Reviewed-by: Mirko Bonadei <mbonadei@webrtc.org> Reviewed-by: Mirko Bonadei <mbonadei@google.com> Commit-Queue: Björn Terelius <terelius@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31472}
This commit is contained in:
Bjorn Terelius
committed by
Commit Bot
Commit Bot
parent
571e130ce2
commit
c186e1498b
@ -325,6 +325,8 @@ if (!build_with_chromium) {
|
||||
sources = [
|
||||
"rtc_event_log_visualizer/alerts.cc",
|
||||
"rtc_event_log_visualizer/alerts.h",
|
||||
"rtc_event_log_visualizer/analyze_audio.cc",
|
||||
"rtc_event_log_visualizer/analyze_audio.h",
|
||||
"rtc_event_log_visualizer/analyzer.cc",
|
||||
"rtc_event_log_visualizer/analyzer.h",
|
||||
"rtc_event_log_visualizer/analyzer_common.cc",
|
||||
@ -371,6 +373,7 @@ if (!build_with_chromium) {
|
||||
absl_deps = [
|
||||
"//third_party/abseil-cpp/absl/algorithm:container",
|
||||
"//third_party/abseil-cpp/absl/strings",
|
||||
"//third_party/abseil-cpp/absl/types:optional",
|
||||
]
|
||||
}
|
||||
}
|
||||
|
||||
503
rtc_tools/rtc_event_log_visualizer/analyze_audio.cc
Normal file
503
rtc_tools/rtc_event_log_visualizer/analyze_audio.cc
Normal file
@ -0,0 +1,503 @@
|
||||
/*
|
||||
* Copyright (c) 2020 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/analyze_audio.h"
|
||||
|
||||
#include <memory>
|
||||
#include <set>
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
|
||||
#include "modules/audio_coding/neteq/tools/audio_sink.h"
|
||||
#include "modules/audio_coding/neteq/tools/fake_decode_from_file.h"
|
||||
#include "modules/audio_coding/neteq/tools/neteq_delay_analyzer.h"
|
||||
#include "modules/audio_coding/neteq/tools/neteq_replacement_input.h"
|
||||
#include "modules/audio_coding/neteq/tools/neteq_test.h"
|
||||
#include "modules/audio_coding/neteq/tools/resample_input_audio_file.h"
|
||||
#include "rtc_base/ref_counted_object.h"
|
||||
|
||||
namespace webrtc {
|
||||
|
||||
void CreateAudioEncoderTargetBitrateGraph(const ParsedRtcEventLog& parsed_log,
|
||||
const AnalyzerConfig& config,
|
||||
Plot* plot) {
|
||||
TimeSeries time_series("Audio encoder target bitrate", LineStyle::kLine,
|
||||
PointStyle::kHighlight);
|
||||
auto GetAnaBitrateBps = [](const LoggedAudioNetworkAdaptationEvent& ana_event)
|
||||
-> absl::optional<float> {
|
||||
if (ana_event.config.bitrate_bps)
|
||||
return absl::optional<float>(
|
||||
static_cast<float>(*ana_event.config.bitrate_bps));
|
||||
return absl::nullopt;
|
||||
};
|
||||
auto ToCallTime = [config](const LoggedAudioNetworkAdaptationEvent& packet) {
|
||||
return config.GetCallTimeSec(packet.log_time_us());
|
||||
};
|
||||
ProcessPoints<LoggedAudioNetworkAdaptationEvent>(
|
||||
ToCallTime, GetAnaBitrateBps,
|
||||
parsed_log.audio_network_adaptation_events(), &time_series);
|
||||
plot->AppendTimeSeries(std::move(time_series));
|
||||
plot->SetXAxis(config.CallBeginTimeSec(), config.CallEndTimeSec(), "Time (s)",
|
||||
kLeftMargin, kRightMargin);
|
||||
plot->SetSuggestedYAxis(0, 1, "Bitrate (bps)", kBottomMargin, kTopMargin);
|
||||
plot->SetTitle("Reported audio encoder target bitrate");
|
||||
}
|
||||
|
||||
void CreateAudioEncoderFrameLengthGraph(const ParsedRtcEventLog& parsed_log,
|
||||
const AnalyzerConfig& config,
|
||||
Plot* plot) {
|
||||
TimeSeries time_series("Audio encoder frame length", LineStyle::kLine,
|
||||
PointStyle::kHighlight);
|
||||
auto GetAnaFrameLengthMs =
|
||||
[](const LoggedAudioNetworkAdaptationEvent& ana_event) {
|
||||
if (ana_event.config.frame_length_ms)
|
||||
return absl::optional<float>(
|
||||
static_cast<float>(*ana_event.config.frame_length_ms));
|
||||
return absl::optional<float>();
|
||||
};
|
||||
auto ToCallTime = [config](const LoggedAudioNetworkAdaptationEvent& packet) {
|
||||
return config.GetCallTimeSec(packet.log_time_us());
|
||||
};
|
||||
ProcessPoints<LoggedAudioNetworkAdaptationEvent>(
|
||||
ToCallTime, GetAnaFrameLengthMs,
|
||||
parsed_log.audio_network_adaptation_events(), &time_series);
|
||||
plot->AppendTimeSeries(std::move(time_series));
|
||||
plot->SetXAxis(config.CallBeginTimeSec(), config.CallEndTimeSec(), "Time (s)",
|
||||
kLeftMargin, kRightMargin);
|
||||
plot->SetSuggestedYAxis(0, 1, "Frame length (ms)", kBottomMargin, kTopMargin);
|
||||
plot->SetTitle("Reported audio encoder frame length");
|
||||
}
|
||||
|
||||
void CreateAudioEncoderPacketLossGraph(const ParsedRtcEventLog& parsed_log,
|
||||
const AnalyzerConfig& config,
|
||||
Plot* plot) {
|
||||
TimeSeries time_series("Audio encoder uplink packet loss fraction",
|
||||
LineStyle::kLine, PointStyle::kHighlight);
|
||||
auto GetAnaPacketLoss =
|
||||
[](const LoggedAudioNetworkAdaptationEvent& ana_event) {
|
||||
if (ana_event.config.uplink_packet_loss_fraction)
|
||||
return absl::optional<float>(static_cast<float>(
|
||||
*ana_event.config.uplink_packet_loss_fraction));
|
||||
return absl::optional<float>();
|
||||
};
|
||||
auto ToCallTime = [config](const LoggedAudioNetworkAdaptationEvent& packet) {
|
||||
return config.GetCallTimeSec(packet.log_time_us());
|
||||
};
|
||||
ProcessPoints<LoggedAudioNetworkAdaptationEvent>(
|
||||
ToCallTime, GetAnaPacketLoss,
|
||||
parsed_log.audio_network_adaptation_events(), &time_series);
|
||||
plot->AppendTimeSeries(std::move(time_series));
|
||||
plot->SetXAxis(config.CallBeginTimeSec(), config.CallEndTimeSec(), "Time (s)",
|
||||
kLeftMargin, kRightMargin);
|
||||
plot->SetSuggestedYAxis(0, 10, "Percent lost packets", kBottomMargin,
|
||||
kTopMargin);
|
||||
plot->SetTitle("Reported audio encoder lost packets");
|
||||
}
|
||||
|
||||
void CreateAudioEncoderEnableFecGraph(const ParsedRtcEventLog& parsed_log,
|
||||
const AnalyzerConfig& config,
|
||||
Plot* plot) {
|
||||
TimeSeries time_series("Audio encoder FEC", LineStyle::kLine,
|
||||
PointStyle::kHighlight);
|
||||
auto GetAnaFecEnabled =
|
||||
[](const LoggedAudioNetworkAdaptationEvent& ana_event) {
|
||||
if (ana_event.config.enable_fec)
|
||||
return absl::optional<float>(
|
||||
static_cast<float>(*ana_event.config.enable_fec));
|
||||
return absl::optional<float>();
|
||||
};
|
||||
auto ToCallTime = [config](const LoggedAudioNetworkAdaptationEvent& packet) {
|
||||
return config.GetCallTimeSec(packet.log_time_us());
|
||||
};
|
||||
ProcessPoints<LoggedAudioNetworkAdaptationEvent>(
|
||||
ToCallTime, GetAnaFecEnabled,
|
||||
parsed_log.audio_network_adaptation_events(), &time_series);
|
||||
plot->AppendTimeSeries(std::move(time_series));
|
||||
plot->SetXAxis(config.CallBeginTimeSec(), config.CallEndTimeSec(), "Time (s)",
|
||||
kLeftMargin, kRightMargin);
|
||||
plot->SetSuggestedYAxis(0, 1, "FEC (false/true)", kBottomMargin, kTopMargin);
|
||||
plot->SetTitle("Reported audio encoder FEC");
|
||||
}
|
||||
|
||||
void CreateAudioEncoderEnableDtxGraph(const ParsedRtcEventLog& parsed_log,
|
||||
const AnalyzerConfig& config,
|
||||
Plot* plot) {
|
||||
TimeSeries time_series("Audio encoder DTX", LineStyle::kLine,
|
||||
PointStyle::kHighlight);
|
||||
auto GetAnaDtxEnabled =
|
||||
[](const LoggedAudioNetworkAdaptationEvent& ana_event) {
|
||||
if (ana_event.config.enable_dtx)
|
||||
return absl::optional<float>(
|
||||
static_cast<float>(*ana_event.config.enable_dtx));
|
||||
return absl::optional<float>();
|
||||
};
|
||||
auto ToCallTime = [config](const LoggedAudioNetworkAdaptationEvent& packet) {
|
||||
return config.GetCallTimeSec(packet.log_time_us());
|
||||
};
|
||||
ProcessPoints<LoggedAudioNetworkAdaptationEvent>(
|
||||
ToCallTime, GetAnaDtxEnabled,
|
||||
parsed_log.audio_network_adaptation_events(), &time_series);
|
||||
plot->AppendTimeSeries(std::move(time_series));
|
||||
plot->SetXAxis(config.CallBeginTimeSec(), config.CallEndTimeSec(), "Time (s)",
|
||||
kLeftMargin, kRightMargin);
|
||||
plot->SetSuggestedYAxis(0, 1, "DTX (false/true)", kBottomMargin, kTopMargin);
|
||||
plot->SetTitle("Reported audio encoder DTX");
|
||||
}
|
||||
|
||||
void CreateAudioEncoderNumChannelsGraph(const ParsedRtcEventLog& parsed_log,
|
||||
const AnalyzerConfig& config,
|
||||
Plot* plot) {
|
||||
TimeSeries time_series("Audio encoder number of channels", LineStyle::kLine,
|
||||
PointStyle::kHighlight);
|
||||
auto GetAnaNumChannels =
|
||||
[](const LoggedAudioNetworkAdaptationEvent& ana_event) {
|
||||
if (ana_event.config.num_channels)
|
||||
return absl::optional<float>(
|
||||
static_cast<float>(*ana_event.config.num_channels));
|
||||
return absl::optional<float>();
|
||||
};
|
||||
auto ToCallTime = [config](const LoggedAudioNetworkAdaptationEvent& packet) {
|
||||
return config.GetCallTimeSec(packet.log_time_us());
|
||||
};
|
||||
ProcessPoints<LoggedAudioNetworkAdaptationEvent>(
|
||||
ToCallTime, GetAnaNumChannels,
|
||||
parsed_log.audio_network_adaptation_events(), &time_series);
|
||||
plot->AppendTimeSeries(std::move(time_series));
|
||||
plot->SetXAxis(config.CallBeginTimeSec(), config.CallEndTimeSec(), "Time (s)",
|
||||
kLeftMargin, kRightMargin);
|
||||
plot->SetSuggestedYAxis(0, 1, "Number of channels (1 (mono)/2 (stereo))",
|
||||
kBottomMargin, kTopMargin);
|
||||
plot->SetTitle("Reported audio encoder number of channels");
|
||||
}
|
||||
|
||||
class NetEqStreamInput : public test::NetEqInput {
|
||||
public:
|
||||
// Does not take any ownership, and all pointers must refer to valid objects
|
||||
// that outlive the one constructed.
|
||||
NetEqStreamInput(const std::vector<LoggedRtpPacketIncoming>* packet_stream,
|
||||
const std::vector<LoggedAudioPlayoutEvent>* output_events,
|
||||
absl::optional<int64_t> end_time_ms)
|
||||
: packet_stream_(*packet_stream),
|
||||
packet_stream_it_(packet_stream_.begin()),
|
||||
output_events_it_(output_events->begin()),
|
||||
output_events_end_(output_events->end()),
|
||||
end_time_ms_(end_time_ms) {
|
||||
RTC_DCHECK(packet_stream);
|
||||
RTC_DCHECK(output_events);
|
||||
}
|
||||
|
||||
absl::optional<int64_t> NextPacketTime() const override {
|
||||
if (packet_stream_it_ == packet_stream_.end()) {
|
||||
return absl::nullopt;
|
||||
}
|
||||
if (end_time_ms_ && packet_stream_it_->rtp.log_time_ms() > *end_time_ms_) {
|
||||
return absl::nullopt;
|
||||
}
|
||||
return packet_stream_it_->rtp.log_time_ms();
|
||||
}
|
||||
|
||||
absl::optional<int64_t> NextOutputEventTime() const override {
|
||||
if (output_events_it_ == output_events_end_) {
|
||||
return absl::nullopt;
|
||||
}
|
||||
if (end_time_ms_ && output_events_it_->log_time_ms() > *end_time_ms_) {
|
||||
return absl::nullopt;
|
||||
}
|
||||
return output_events_it_->log_time_ms();
|
||||
}
|
||||
|
||||
std::unique_ptr<PacketData> PopPacket() override {
|
||||
if (packet_stream_it_ == packet_stream_.end()) {
|
||||
return std::unique_ptr<PacketData>();
|
||||
}
|
||||
std::unique_ptr<PacketData> packet_data(new PacketData());
|
||||
packet_data->header = packet_stream_it_->rtp.header;
|
||||
packet_data->time_ms = packet_stream_it_->rtp.log_time_ms();
|
||||
|
||||
// This is a header-only "dummy" packet. Set the payload to all zeros, with
|
||||
// length according to the virtual length.
|
||||
packet_data->payload.SetSize(packet_stream_it_->rtp.total_length -
|
||||
packet_stream_it_->rtp.header_length);
|
||||
std::fill_n(packet_data->payload.data(), packet_data->payload.size(), 0);
|
||||
|
||||
++packet_stream_it_;
|
||||
return packet_data;
|
||||
}
|
||||
|
||||
void AdvanceOutputEvent() override {
|
||||
if (output_events_it_ != output_events_end_) {
|
||||
++output_events_it_;
|
||||
}
|
||||
}
|
||||
|
||||
bool ended() const override { return !NextEventTime(); }
|
||||
|
||||
absl::optional<RTPHeader> NextHeader() const override {
|
||||
if (packet_stream_it_ == packet_stream_.end()) {
|
||||
return absl::nullopt;
|
||||
}
|
||||
return packet_stream_it_->rtp.header;
|
||||
}
|
||||
|
||||
private:
|
||||
const std::vector<LoggedRtpPacketIncoming>& packet_stream_;
|
||||
std::vector<LoggedRtpPacketIncoming>::const_iterator packet_stream_it_;
|
||||
std::vector<LoggedAudioPlayoutEvent>::const_iterator output_events_it_;
|
||||
const std::vector<LoggedAudioPlayoutEvent>::const_iterator output_events_end_;
|
||||
const absl::optional<int64_t> end_time_ms_;
|
||||
};
|
||||
|
||||
namespace {
|
||||
|
||||
// Factory to create a "replacement decoder" that produces the decoded audio
|
||||
// by reading from a file rather than from the encoded payloads.
|
||||
class ReplacementAudioDecoderFactory : public AudioDecoderFactory {
|
||||
public:
|
||||
ReplacementAudioDecoderFactory(const absl::string_view replacement_file_name,
|
||||
int file_sample_rate_hz)
|
||||
: replacement_file_name_(replacement_file_name),
|
||||
file_sample_rate_hz_(file_sample_rate_hz) {}
|
||||
|
||||
std::vector<AudioCodecSpec> GetSupportedDecoders() override {
|
||||
RTC_NOTREACHED();
|
||||
return {};
|
||||
}
|
||||
|
||||
bool IsSupportedDecoder(const SdpAudioFormat& format) override {
|
||||
return true;
|
||||
}
|
||||
|
||||
std::unique_ptr<AudioDecoder> MakeAudioDecoder(
|
||||
const SdpAudioFormat& format,
|
||||
absl::optional<AudioCodecPairId> codec_pair_id) override {
|
||||
auto replacement_file = std::make_unique<test::ResampleInputAudioFile>(
|
||||
replacement_file_name_, file_sample_rate_hz_);
|
||||
replacement_file->set_output_rate_hz(48000);
|
||||
return std::make_unique<test::FakeDecodeFromFile>(
|
||||
std::move(replacement_file), 48000, false);
|
||||
}
|
||||
|
||||
private:
|
||||
const std::string replacement_file_name_;
|
||||
const int file_sample_rate_hz_;
|
||||
};
|
||||
|
||||
// Creates a NetEq test object and all necessary input and output helpers. Runs
|
||||
// the test and returns the NetEqDelayAnalyzer object that was used to
|
||||
// instrument the test.
|
||||
std::unique_ptr<test::NetEqStatsGetter> CreateNetEqTestAndRun(
|
||||
const std::vector<LoggedRtpPacketIncoming>* packet_stream,
|
||||
const std::vector<LoggedAudioPlayoutEvent>* output_events,
|
||||
absl::optional<int64_t> end_time_ms,
|
||||
const std::string& replacement_file_name,
|
||||
int file_sample_rate_hz) {
|
||||
std::unique_ptr<test::NetEqInput> input(
|
||||
new NetEqStreamInput(packet_stream, output_events, end_time_ms));
|
||||
|
||||
constexpr int kReplacementPt = 127;
|
||||
std::set<uint8_t> cn_types;
|
||||
std::set<uint8_t> forbidden_types;
|
||||
input.reset(new test::NetEqReplacementInput(std::move(input), kReplacementPt,
|
||||
cn_types, forbidden_types));
|
||||
|
||||
NetEq::Config config;
|
||||
config.max_packets_in_buffer = 200;
|
||||
config.enable_fast_accelerate = true;
|
||||
|
||||
std::unique_ptr<test::VoidAudioSink> output(new test::VoidAudioSink());
|
||||
|
||||
rtc::scoped_refptr<AudioDecoderFactory> decoder_factory =
|
||||
new rtc::RefCountedObject<ReplacementAudioDecoderFactory>(
|
||||
replacement_file_name, file_sample_rate_hz);
|
||||
|
||||
test::NetEqTest::DecoderMap codecs = {
|
||||
{kReplacementPt, SdpAudioFormat("l16", 48000, 1)}};
|
||||
|
||||
std::unique_ptr<test::NetEqDelayAnalyzer> delay_cb(
|
||||
new test::NetEqDelayAnalyzer);
|
||||
std::unique_ptr<test::NetEqStatsGetter> neteq_stats_getter(
|
||||
new test::NetEqStatsGetter(std::move(delay_cb)));
|
||||
test::DefaultNetEqTestErrorCallback error_cb;
|
||||
test::NetEqTest::Callbacks callbacks;
|
||||
callbacks.error_callback = &error_cb;
|
||||
callbacks.post_insert_packet = neteq_stats_getter->delay_analyzer();
|
||||
callbacks.get_audio_callback = neteq_stats_getter.get();
|
||||
|
||||
test::NetEqTest test(config, decoder_factory, codecs, /*text_log=*/nullptr,
|
||||
/*factory=*/nullptr, std::move(input), std::move(output),
|
||||
callbacks);
|
||||
test.Run();
|
||||
return neteq_stats_getter;
|
||||
}
|
||||
} // namespace
|
||||
|
||||
NetEqStatsGetterMap SimulateNetEq(const ParsedRtcEventLog& parsed_log,
|
||||
const AnalyzerConfig& config,
|
||||
const std::string& replacement_file_name,
|
||||
int file_sample_rate_hz) {
|
||||
NetEqStatsGetterMap neteq_stats;
|
||||
|
||||
for (const auto& stream : parsed_log.incoming_rtp_packets_by_ssrc()) {
|
||||
const uint32_t ssrc = stream.ssrc;
|
||||
if (!IsAudioSsrc(parsed_log, kIncomingPacket, ssrc))
|
||||
continue;
|
||||
const std::vector<LoggedRtpPacketIncoming>* audio_packets =
|
||||
&stream.incoming_packets;
|
||||
if (audio_packets == nullptr) {
|
||||
// No incoming audio stream found.
|
||||
continue;
|
||||
}
|
||||
|
||||
RTC_DCHECK(neteq_stats.find(ssrc) == neteq_stats.end());
|
||||
|
||||
std::map<uint32_t, std::vector<LoggedAudioPlayoutEvent>>::const_iterator
|
||||
output_events_it = parsed_log.audio_playout_events().find(ssrc);
|
||||
if (output_events_it == parsed_log.audio_playout_events().end()) {
|
||||
// Could not find output events with SSRC matching the input audio stream.
|
||||
// Using the first available stream of output events.
|
||||
output_events_it = parsed_log.audio_playout_events().cbegin();
|
||||
}
|
||||
|
||||
int64_t end_time_ms = parsed_log.first_log_segment().stop_time_ms();
|
||||
|
||||
neteq_stats[ssrc] = CreateNetEqTestAndRun(
|
||||
audio_packets, &output_events_it->second, end_time_ms,
|
||||
replacement_file_name, file_sample_rate_hz);
|
||||
}
|
||||
|
||||
return neteq_stats;
|
||||
}
|
||||
|
||||
// Given a NetEqStatsGetter and the SSRC that the NetEqStatsGetter was created
|
||||
// for, this method generates a plot for the jitter buffer delay profile.
|
||||
void CreateAudioJitterBufferGraph(const ParsedRtcEventLog& parsed_log,
|
||||
const AnalyzerConfig& config,
|
||||
uint32_t ssrc,
|
||||
const test::NetEqStatsGetter* stats_getter,
|
||||
Plot* plot) {
|
||||
test::NetEqDelayAnalyzer::Delays arrival_delay_ms;
|
||||
test::NetEqDelayAnalyzer::Delays corrected_arrival_delay_ms;
|
||||
test::NetEqDelayAnalyzer::Delays playout_delay_ms;
|
||||
test::NetEqDelayAnalyzer::Delays target_delay_ms;
|
||||
|
||||
stats_getter->delay_analyzer()->CreateGraphs(
|
||||
&arrival_delay_ms, &corrected_arrival_delay_ms, &playout_delay_ms,
|
||||
&target_delay_ms);
|
||||
|
||||
TimeSeries time_series_packet_arrival("packet arrival delay",
|
||||
LineStyle::kLine);
|
||||
TimeSeries time_series_relative_packet_arrival(
|
||||
"Relative packet arrival delay", LineStyle::kLine);
|
||||
TimeSeries time_series_play_time("Playout delay", LineStyle::kLine);
|
||||
TimeSeries time_series_target_time("Target delay", LineStyle::kLine,
|
||||
PointStyle::kHighlight);
|
||||
|
||||
for (const auto& data : arrival_delay_ms) {
|
||||
const float x = config.GetCallTimeSec(data.first * 1000); // ms to us.
|
||||
const float y = data.second;
|
||||
time_series_packet_arrival.points.emplace_back(TimeSeriesPoint(x, y));
|
||||
}
|
||||
for (const auto& data : corrected_arrival_delay_ms) {
|
||||
const float x = config.GetCallTimeSec(data.first * 1000); // ms to us.
|
||||
const float y = data.second;
|
||||
time_series_relative_packet_arrival.points.emplace_back(
|
||||
TimeSeriesPoint(x, y));
|
||||
}
|
||||
for (const auto& data : playout_delay_ms) {
|
||||
const float x = config.GetCallTimeSec(data.first * 1000); // ms to us.
|
||||
const float y = data.second;
|
||||
time_series_play_time.points.emplace_back(TimeSeriesPoint(x, y));
|
||||
}
|
||||
for (const auto& data : target_delay_ms) {
|
||||
const float x = config.GetCallTimeSec(data.first * 1000); // ms to us.
|
||||
const float y = data.second;
|
||||
time_series_target_time.points.emplace_back(TimeSeriesPoint(x, y));
|
||||
}
|
||||
|
||||
plot->AppendTimeSeries(std::move(time_series_packet_arrival));
|
||||
plot->AppendTimeSeries(std::move(time_series_relative_packet_arrival));
|
||||
plot->AppendTimeSeries(std::move(time_series_play_time));
|
||||
plot->AppendTimeSeries(std::move(time_series_target_time));
|
||||
|
||||
plot->SetXAxis(config.CallBeginTimeSec(), config.CallEndTimeSec(), "Time (s)",
|
||||
kLeftMargin, kRightMargin);
|
||||
plot->SetSuggestedYAxis(0, 1, "Relative delay (ms)", kBottomMargin,
|
||||
kTopMargin);
|
||||
plot->SetTitle("NetEq timing for " +
|
||||
GetStreamName(parsed_log, kIncomingPacket, ssrc));
|
||||
}
|
||||
|
||||
template <typename NetEqStatsType>
|
||||
void CreateNetEqStatsGraphInternal(
|
||||
const ParsedRtcEventLog& parsed_log,
|
||||
const AnalyzerConfig& config,
|
||||
const NetEqStatsGetterMap& neteq_stats,
|
||||
rtc::FunctionView<const std::vector<std::pair<int64_t, NetEqStatsType>>*(
|
||||
const test::NetEqStatsGetter*)> data_extractor,
|
||||
rtc::FunctionView<float(const NetEqStatsType&)> stats_extractor,
|
||||
const std::string& plot_name,
|
||||
Plot* plot) {
|
||||
std::map<uint32_t, TimeSeries> time_series;
|
||||
|
||||
for (const auto& st : neteq_stats) {
|
||||
const uint32_t ssrc = st.first;
|
||||
const std::vector<std::pair<int64_t, NetEqStatsType>>* data_vector =
|
||||
data_extractor(st.second.get());
|
||||
for (const auto& data : *data_vector) {
|
||||
const float time = config.GetCallTimeSec(data.first * 1000); // ms to us.
|
||||
const float value = stats_extractor(data.second);
|
||||
time_series[ssrc].points.emplace_back(TimeSeriesPoint(time, value));
|
||||
}
|
||||
}
|
||||
|
||||
for (auto& series : time_series) {
|
||||
series.second.label =
|
||||
GetStreamName(parsed_log, kIncomingPacket, series.first);
|
||||
series.second.line_style = LineStyle::kLine;
|
||||
plot->AppendTimeSeries(std::move(series.second));
|
||||
}
|
||||
|
||||
plot->SetXAxis(config.CallBeginTimeSec(), config.CallEndTimeSec(), "Time (s)",
|
||||
kLeftMargin, kRightMargin);
|
||||
plot->SetSuggestedYAxis(0, 1, plot_name, kBottomMargin, kTopMargin);
|
||||
plot->SetTitle(plot_name);
|
||||
}
|
||||
|
||||
void CreateNetEqNetworkStatsGraph(
|
||||
const ParsedRtcEventLog& parsed_log,
|
||||
const AnalyzerConfig& config,
|
||||
const NetEqStatsGetterMap& neteq_stats,
|
||||
rtc::FunctionView<float(const NetEqNetworkStatistics&)> stats_extractor,
|
||||
const std::string& plot_name,
|
||||
Plot* plot) {
|
||||
CreateNetEqStatsGraphInternal<NetEqNetworkStatistics>(
|
||||
parsed_log, config, neteq_stats,
|
||||
[](const test::NetEqStatsGetter* stats_getter) {
|
||||
return stats_getter->stats();
|
||||
},
|
||||
stats_extractor, plot_name, plot);
|
||||
}
|
||||
|
||||
void CreateNetEqLifetimeStatsGraph(
|
||||
const ParsedRtcEventLog& parsed_log,
|
||||
const AnalyzerConfig& config,
|
||||
const NetEqStatsGetterMap& neteq_stats,
|
||||
rtc::FunctionView<float(const NetEqLifetimeStatistics&)> stats_extractor,
|
||||
const std::string& plot_name,
|
||||
Plot* plot) {
|
||||
CreateNetEqStatsGraphInternal<NetEqLifetimeStatistics>(
|
||||
parsed_log, config, neteq_stats,
|
||||
[](const test::NetEqStatsGetter* stats_getter) {
|
||||
return stats_getter->lifetime_stats();
|
||||
},
|
||||
stats_extractor, plot_name, plot);
|
||||
}
|
||||
|
||||
} // namespace webrtc
|
||||
75
rtc_tools/rtc_event_log_visualizer/analyze_audio.h
Normal file
75
rtc_tools/rtc_event_log_visualizer/analyze_audio.h
Normal file
@ -0,0 +1,75 @@
|
||||
/*
|
||||
* Copyright (c) 2020 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.
|
||||
*/
|
||||
|
||||
#ifndef RTC_TOOLS_RTC_EVENT_LOG_VISUALIZER_ANALYZE_AUDIO_H_
|
||||
#define RTC_TOOLS_RTC_EVENT_LOG_VISUALIZER_ANALYZE_AUDIO_H_
|
||||
|
||||
#include <cstdint>
|
||||
#include <map>
|
||||
#include <memory>
|
||||
#include <string>
|
||||
|
||||
#include "api/function_view.h"
|
||||
#include "logging/rtc_event_log/rtc_event_log_parser.h"
|
||||
#include "modules/audio_coding/neteq/tools/neteq_stats_getter.h"
|
||||
#include "rtc_tools/rtc_event_log_visualizer/analyzer_common.h"
|
||||
#include "rtc_tools/rtc_event_log_visualizer/plot_base.h"
|
||||
|
||||
namespace webrtc {
|
||||
|
||||
void CreateAudioEncoderTargetBitrateGraph(const ParsedRtcEventLog& parsed_log,
|
||||
const AnalyzerConfig& config,
|
||||
Plot* plot);
|
||||
void CreateAudioEncoderFrameLengthGraph(const ParsedRtcEventLog& parsed_log,
|
||||
const AnalyzerConfig& config,
|
||||
Plot* plot);
|
||||
void CreateAudioEncoderPacketLossGraph(const ParsedRtcEventLog& parsed_log,
|
||||
const AnalyzerConfig& config,
|
||||
Plot* plot);
|
||||
void CreateAudioEncoderEnableFecGraph(const ParsedRtcEventLog& parsed_log,
|
||||
const AnalyzerConfig& config,
|
||||
Plot* plot);
|
||||
void CreateAudioEncoderEnableDtxGraph(const ParsedRtcEventLog& parsed_log,
|
||||
const AnalyzerConfig& config,
|
||||
Plot* plot);
|
||||
void CreateAudioEncoderNumChannelsGraph(const ParsedRtcEventLog& parsed_log,
|
||||
const AnalyzerConfig& config,
|
||||
Plot* plot);
|
||||
|
||||
using NetEqStatsGetterMap =
|
||||
std::map<uint32_t, std::unique_ptr<test::NetEqStatsGetter>>;
|
||||
NetEqStatsGetterMap SimulateNetEq(const ParsedRtcEventLog& parsed_log,
|
||||
const AnalyzerConfig& config,
|
||||
const std::string& replacement_file_name,
|
||||
int file_sample_rate_hz);
|
||||
|
||||
void CreateAudioJitterBufferGraph(const ParsedRtcEventLog& parsed_log,
|
||||
const AnalyzerConfig& config,
|
||||
uint32_t ssrc,
|
||||
const test::NetEqStatsGetter* stats_getter,
|
||||
Plot* plot);
|
||||
void CreateNetEqNetworkStatsGraph(
|
||||
const ParsedRtcEventLog& parsed_log,
|
||||
const AnalyzerConfig& config,
|
||||
const NetEqStatsGetterMap& neteq_stats_getters,
|
||||
rtc::FunctionView<float(const NetEqNetworkStatistics&)> stats_extractor,
|
||||
const std::string& plot_name,
|
||||
Plot* plot);
|
||||
void CreateNetEqLifetimeStatsGraph(
|
||||
const ParsedRtcEventLog& parsed_log,
|
||||
const AnalyzerConfig& config,
|
||||
const NetEqStatsGetterMap& neteq_stats_getters,
|
||||
rtc::FunctionView<float(const NetEqLifetimeStatistics&)> stats_extractor,
|
||||
const std::string& plot_name,
|
||||
Plot* plot);
|
||||
|
||||
} // namespace webrtc
|
||||
|
||||
#endif // RTC_TOOLS_RTC_EVENT_LOG_VISUALIZER_ANALYZE_AUDIO_H_
|
||||
@ -31,12 +31,6 @@
|
||||
#include "logging/rtc_event_log/rtc_event_processor.h"
|
||||
#include "logging/rtc_event_log/rtc_stream_config.h"
|
||||
#include "modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor.h"
|
||||
#include "modules/audio_coding/neteq/tools/audio_sink.h"
|
||||
#include "modules/audio_coding/neteq/tools/fake_decode_from_file.h"
|
||||
#include "modules/audio_coding/neteq/tools/neteq_delay_analyzer.h"
|
||||
#include "modules/audio_coding/neteq/tools/neteq_replacement_input.h"
|
||||
#include "modules/audio_coding/neteq/tools/neteq_test.h"
|
||||
#include "modules/audio_coding/neteq/tools/resample_input_audio_file.h"
|
||||
#include "modules/congestion_controller/goog_cc/acknowledged_bitrate_estimator.h"
|
||||
#include "modules/congestion_controller/goog_cc/bitrate_estimator.h"
|
||||
#include "modules/congestion_controller/goog_cc/delay_based_bwe.h"
|
||||
@ -71,8 +65,6 @@ namespace webrtc {
|
||||
|
||||
namespace {
|
||||
|
||||
const int kNumMicrosecsPerSec = 1000000;
|
||||
|
||||
std::string SsrcToString(uint32_t ssrc) {
|
||||
rtc::StringBuilder ss;
|
||||
ss << "SSRC " << ssrc;
|
||||
@ -168,11 +160,6 @@ absl::optional<uint32_t> EstimateRtpClockFrequency(
|
||||
return absl::nullopt;
|
||||
}
|
||||
|
||||
constexpr float kLeftMargin = 0.01f;
|
||||
constexpr float kRightMargin = 0.02f;
|
||||
constexpr float kBottomMargin = 0.02f;
|
||||
constexpr float kTopMargin = 0.05f;
|
||||
|
||||
absl::optional<double> NetworkDelayDiff_AbsSendTime(
|
||||
const LoggedRtpPacketIncoming& old_packet,
|
||||
const LoggedRtpPacketIncoming& new_packet) {
|
||||
@ -222,99 +209,6 @@ absl::optional<double> NetworkDelayDiff_CaptureTime(
|
||||
return delay_change;
|
||||
}
|
||||
|
||||
// For each element in data_view, use |f()| to extract a y-coordinate and
|
||||
// store the result in a TimeSeries.
|
||||
template <typename DataType, typename IterableType>
|
||||
void ProcessPoints(rtc::FunctionView<float(const DataType&)> fx,
|
||||
rtc::FunctionView<absl::optional<float>(const DataType&)> fy,
|
||||
const IterableType& data_view,
|
||||
TimeSeries* result) {
|
||||
for (size_t i = 0; i < data_view.size(); i++) {
|
||||
const DataType& elem = data_view[i];
|
||||
float x = fx(elem);
|
||||
absl::optional<float> y = fy(elem);
|
||||
if (y)
|
||||
result->points.emplace_back(x, *y);
|
||||
}
|
||||
}
|
||||
|
||||
// For each pair of adjacent elements in |data|, use |f()| to extract a
|
||||
// y-coordinate and store the result in a TimeSeries. Note that the x-coordinate
|
||||
// will be the time of the second element in the pair.
|
||||
template <typename DataType, typename ResultType, typename IterableType>
|
||||
void ProcessPairs(
|
||||
rtc::FunctionView<float(const DataType&)> fx,
|
||||
rtc::FunctionView<absl::optional<ResultType>(const DataType&,
|
||||
const DataType&)> fy,
|
||||
const IterableType& data,
|
||||
TimeSeries* result) {
|
||||
for (size_t i = 1; i < data.size(); i++) {
|
||||
float x = fx(data[i]);
|
||||
absl::optional<ResultType> y = fy(data[i - 1], data[i]);
|
||||
if (y)
|
||||
result->points.emplace_back(x, static_cast<float>(*y));
|
||||
}
|
||||
}
|
||||
|
||||
// For each pair of adjacent elements in |data|, use |f()| to extract a
|
||||
// y-coordinate and store the result in a TimeSeries. Note that the x-coordinate
|
||||
// will be the time of the second element in the pair.
|
||||
template <typename DataType, typename ResultType, typename IterableType>
|
||||
void AccumulatePairs(
|
||||
rtc::FunctionView<float(const DataType&)> fx,
|
||||
rtc::FunctionView<absl::optional<ResultType>(const DataType&,
|
||||
const DataType&)> fy,
|
||||
const IterableType& data,
|
||||
TimeSeries* result) {
|
||||
ResultType sum = 0;
|
||||
for (size_t i = 1; i < data.size(); i++) {
|
||||
float x = fx(data[i]);
|
||||
absl::optional<ResultType> y = fy(data[i - 1], data[i]);
|
||||
if (y) {
|
||||
sum += *y;
|
||||
result->points.emplace_back(x, static_cast<float>(sum));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Calculates a moving average of |data| and stores the result in a TimeSeries.
|
||||
// A data point is generated every |step| microseconds from |begin_time|
|
||||
// to |end_time|. The value of each data point is the average of the data
|
||||
// during the preceding |window_duration_us| microseconds.
|
||||
template <typename DataType, typename ResultType, typename IterableType>
|
||||
void MovingAverage(
|
||||
rtc::FunctionView<absl::optional<ResultType>(const DataType&)> fy,
|
||||
const IterableType& data_view,
|
||||
AnalyzerConfig config,
|
||||
TimeSeries* result) {
|
||||
size_t window_index_begin = 0;
|
||||
size_t window_index_end = 0;
|
||||
ResultType sum_in_window = 0;
|
||||
|
||||
for (int64_t t = config.begin_time_; t < config.end_time_ + config.step_;
|
||||
t += config.step_) {
|
||||
while (window_index_end < data_view.size() &&
|
||||
data_view[window_index_end].log_time_us() < t) {
|
||||
absl::optional<ResultType> value = fy(data_view[window_index_end]);
|
||||
if (value)
|
||||
sum_in_window += *value;
|
||||
++window_index_end;
|
||||
}
|
||||
while (window_index_begin < data_view.size() &&
|
||||
data_view[window_index_begin].log_time_us() <
|
||||
t - config.window_duration_) {
|
||||
absl::optional<ResultType> value = fy(data_view[window_index_begin]);
|
||||
if (value)
|
||||
sum_in_window -= *value;
|
||||
++window_index_begin;
|
||||
}
|
||||
float window_duration_s =
|
||||
static_cast<float>(config.window_duration_) / kNumMicrosecsPerSec;
|
||||
float x = config.GetCallTimeSec(t);
|
||||
float y = sum_in_window / window_duration_s;
|
||||
result->points.emplace_back(x, y);
|
||||
}
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
TimeSeries CreateRtcpTypeTimeSeries(const std::vector<T>& rtcp_list,
|
||||
@ -1725,462 +1619,6 @@ void EventLogAnalyzer::CreateSenderAndReceiverReportPlot(
|
||||
plot->SetTitle(title);
|
||||
}
|
||||
|
||||
void EventLogAnalyzer::CreateAudioEncoderTargetBitrateGraph(Plot* plot) {
|
||||
TimeSeries time_series("Audio encoder target bitrate", LineStyle::kLine,
|
||||
PointStyle::kHighlight);
|
||||
auto GetAnaBitrateBps = [](const LoggedAudioNetworkAdaptationEvent& ana_event)
|
||||
-> absl::optional<float> {
|
||||
if (ana_event.config.bitrate_bps)
|
||||
return absl::optional<float>(
|
||||
static_cast<float>(*ana_event.config.bitrate_bps));
|
||||
return absl::nullopt;
|
||||
};
|
||||
auto ToCallTime = [this](const LoggedAudioNetworkAdaptationEvent& packet) {
|
||||
return this->config_.GetCallTimeSec(packet.log_time_us());
|
||||
};
|
||||
ProcessPoints<LoggedAudioNetworkAdaptationEvent>(
|
||||
ToCallTime, GetAnaBitrateBps,
|
||||
parsed_log_.audio_network_adaptation_events(), &time_series);
|
||||
plot->AppendTimeSeries(std::move(time_series));
|
||||
plot->SetXAxis(config_.CallBeginTimeSec(), config_.CallEndTimeSec(),
|
||||
"Time (s)", kLeftMargin, kRightMargin);
|
||||
plot->SetSuggestedYAxis(0, 1, "Bitrate (bps)", kBottomMargin, kTopMargin);
|
||||
plot->SetTitle("Reported audio encoder target bitrate");
|
||||
}
|
||||
|
||||
void EventLogAnalyzer::CreateAudioEncoderFrameLengthGraph(Plot* plot) {
|
||||
TimeSeries time_series("Audio encoder frame length", LineStyle::kLine,
|
||||
PointStyle::kHighlight);
|
||||
auto GetAnaFrameLengthMs =
|
||||
[](const LoggedAudioNetworkAdaptationEvent& ana_event) {
|
||||
if (ana_event.config.frame_length_ms)
|
||||
return absl::optional<float>(
|
||||
static_cast<float>(*ana_event.config.frame_length_ms));
|
||||
return absl::optional<float>();
|
||||
};
|
||||
auto ToCallTime = [this](const LoggedAudioNetworkAdaptationEvent& packet) {
|
||||
return this->config_.GetCallTimeSec(packet.log_time_us());
|
||||
};
|
||||
ProcessPoints<LoggedAudioNetworkAdaptationEvent>(
|
||||
ToCallTime, GetAnaFrameLengthMs,
|
||||
parsed_log_.audio_network_adaptation_events(), &time_series);
|
||||
plot->AppendTimeSeries(std::move(time_series));
|
||||
plot->SetXAxis(config_.CallBeginTimeSec(), config_.CallEndTimeSec(),
|
||||
"Time (s)", kLeftMargin, kRightMargin);
|
||||
plot->SetSuggestedYAxis(0, 1, "Frame length (ms)", kBottomMargin, kTopMargin);
|
||||
plot->SetTitle("Reported audio encoder frame length");
|
||||
}
|
||||
|
||||
void EventLogAnalyzer::CreateAudioEncoderPacketLossGraph(Plot* plot) {
|
||||
TimeSeries time_series("Audio encoder uplink packet loss fraction",
|
||||
LineStyle::kLine, PointStyle::kHighlight);
|
||||
auto GetAnaPacketLoss =
|
||||
[](const LoggedAudioNetworkAdaptationEvent& ana_event) {
|
||||
if (ana_event.config.uplink_packet_loss_fraction)
|
||||
return absl::optional<float>(static_cast<float>(
|
||||
*ana_event.config.uplink_packet_loss_fraction));
|
||||
return absl::optional<float>();
|
||||
};
|
||||
auto ToCallTime = [this](const LoggedAudioNetworkAdaptationEvent& packet) {
|
||||
return this->config_.GetCallTimeSec(packet.log_time_us());
|
||||
};
|
||||
ProcessPoints<LoggedAudioNetworkAdaptationEvent>(
|
||||
ToCallTime, GetAnaPacketLoss,
|
||||
parsed_log_.audio_network_adaptation_events(), &time_series);
|
||||
plot->AppendTimeSeries(std::move(time_series));
|
||||
plot->SetXAxis(config_.CallBeginTimeSec(), config_.CallEndTimeSec(),
|
||||
"Time (s)", kLeftMargin, kRightMargin);
|
||||
plot->SetSuggestedYAxis(0, 10, "Percent lost packets", kBottomMargin,
|
||||
kTopMargin);
|
||||
plot->SetTitle("Reported audio encoder lost packets");
|
||||
}
|
||||
|
||||
void EventLogAnalyzer::CreateAudioEncoderEnableFecGraph(Plot* plot) {
|
||||
TimeSeries time_series("Audio encoder FEC", LineStyle::kLine,
|
||||
PointStyle::kHighlight);
|
||||
auto GetAnaFecEnabled =
|
||||
[](const LoggedAudioNetworkAdaptationEvent& ana_event) {
|
||||
if (ana_event.config.enable_fec)
|
||||
return absl::optional<float>(
|
||||
static_cast<float>(*ana_event.config.enable_fec));
|
||||
return absl::optional<float>();
|
||||
};
|
||||
auto ToCallTime = [this](const LoggedAudioNetworkAdaptationEvent& packet) {
|
||||
return this->config_.GetCallTimeSec(packet.log_time_us());
|
||||
};
|
||||
ProcessPoints<LoggedAudioNetworkAdaptationEvent>(
|
||||
ToCallTime, GetAnaFecEnabled,
|
||||
parsed_log_.audio_network_adaptation_events(), &time_series);
|
||||
plot->AppendTimeSeries(std::move(time_series));
|
||||
plot->SetXAxis(config_.CallBeginTimeSec(), config_.CallEndTimeSec(),
|
||||
"Time (s)", kLeftMargin, kRightMargin);
|
||||
plot->SetSuggestedYAxis(0, 1, "FEC (false/true)", kBottomMargin, kTopMargin);
|
||||
plot->SetTitle("Reported audio encoder FEC");
|
||||
}
|
||||
|
||||
void EventLogAnalyzer::CreateAudioEncoderEnableDtxGraph(Plot* plot) {
|
||||
TimeSeries time_series("Audio encoder DTX", LineStyle::kLine,
|
||||
PointStyle::kHighlight);
|
||||
auto GetAnaDtxEnabled =
|
||||
[](const LoggedAudioNetworkAdaptationEvent& ana_event) {
|
||||
if (ana_event.config.enable_dtx)
|
||||
return absl::optional<float>(
|
||||
static_cast<float>(*ana_event.config.enable_dtx));
|
||||
return absl::optional<float>();
|
||||
};
|
||||
auto ToCallTime = [this](const LoggedAudioNetworkAdaptationEvent& packet) {
|
||||
return this->config_.GetCallTimeSec(packet.log_time_us());
|
||||
};
|
||||
ProcessPoints<LoggedAudioNetworkAdaptationEvent>(
|
||||
ToCallTime, GetAnaDtxEnabled,
|
||||
parsed_log_.audio_network_adaptation_events(), &time_series);
|
||||
plot->AppendTimeSeries(std::move(time_series));
|
||||
plot->SetXAxis(config_.CallBeginTimeSec(), config_.CallEndTimeSec(),
|
||||
"Time (s)", kLeftMargin, kRightMargin);
|
||||
plot->SetSuggestedYAxis(0, 1, "DTX (false/true)", kBottomMargin, kTopMargin);
|
||||
plot->SetTitle("Reported audio encoder DTX");
|
||||
}
|
||||
|
||||
void EventLogAnalyzer::CreateAudioEncoderNumChannelsGraph(Plot* plot) {
|
||||
TimeSeries time_series("Audio encoder number of channels", LineStyle::kLine,
|
||||
PointStyle::kHighlight);
|
||||
auto GetAnaNumChannels =
|
||||
[](const LoggedAudioNetworkAdaptationEvent& ana_event) {
|
||||
if (ana_event.config.num_channels)
|
||||
return absl::optional<float>(
|
||||
static_cast<float>(*ana_event.config.num_channels));
|
||||
return absl::optional<float>();
|
||||
};
|
||||
auto ToCallTime = [this](const LoggedAudioNetworkAdaptationEvent& packet) {
|
||||
return this->config_.GetCallTimeSec(packet.log_time_us());
|
||||
};
|
||||
ProcessPoints<LoggedAudioNetworkAdaptationEvent>(
|
||||
ToCallTime, GetAnaNumChannels,
|
||||
parsed_log_.audio_network_adaptation_events(), &time_series);
|
||||
plot->AppendTimeSeries(std::move(time_series));
|
||||
plot->SetXAxis(config_.CallBeginTimeSec(), config_.CallEndTimeSec(),
|
||||
"Time (s)", kLeftMargin, kRightMargin);
|
||||
plot->SetSuggestedYAxis(0, 1, "Number of channels (1 (mono)/2 (stereo))",
|
||||
kBottomMargin, kTopMargin);
|
||||
plot->SetTitle("Reported audio encoder number of channels");
|
||||
}
|
||||
|
||||
class NetEqStreamInput : public test::NetEqInput {
|
||||
public:
|
||||
// Does not take any ownership, and all pointers must refer to valid objects
|
||||
// that outlive the one constructed.
|
||||
NetEqStreamInput(const std::vector<LoggedRtpPacketIncoming>* packet_stream,
|
||||
const std::vector<LoggedAudioPlayoutEvent>* output_events,
|
||||
absl::optional<int64_t> end_time_ms)
|
||||
: packet_stream_(*packet_stream),
|
||||
packet_stream_it_(packet_stream_.begin()),
|
||||
output_events_it_(output_events->begin()),
|
||||
output_events_end_(output_events->end()),
|
||||
end_time_ms_(end_time_ms) {
|
||||
RTC_DCHECK(packet_stream);
|
||||
RTC_DCHECK(output_events);
|
||||
}
|
||||
|
||||
absl::optional<int64_t> NextPacketTime() const override {
|
||||
if (packet_stream_it_ == packet_stream_.end()) {
|
||||
return absl::nullopt;
|
||||
}
|
||||
if (end_time_ms_ && packet_stream_it_->rtp.log_time_ms() > *end_time_ms_) {
|
||||
return absl::nullopt;
|
||||
}
|
||||
return packet_stream_it_->rtp.log_time_ms();
|
||||
}
|
||||
|
||||
absl::optional<int64_t> NextOutputEventTime() const override {
|
||||
if (output_events_it_ == output_events_end_) {
|
||||
return absl::nullopt;
|
||||
}
|
||||
if (end_time_ms_ && output_events_it_->log_time_ms() > *end_time_ms_) {
|
||||
return absl::nullopt;
|
||||
}
|
||||
return output_events_it_->log_time_ms();
|
||||
}
|
||||
|
||||
std::unique_ptr<PacketData> PopPacket() override {
|
||||
if (packet_stream_it_ == packet_stream_.end()) {
|
||||
return std::unique_ptr<PacketData>();
|
||||
}
|
||||
std::unique_ptr<PacketData> packet_data(new PacketData());
|
||||
packet_data->header = packet_stream_it_->rtp.header;
|
||||
packet_data->time_ms = packet_stream_it_->rtp.log_time_ms();
|
||||
|
||||
// This is a header-only "dummy" packet. Set the payload to all zeros, with
|
||||
// length according to the virtual length.
|
||||
packet_data->payload.SetSize(packet_stream_it_->rtp.total_length -
|
||||
packet_stream_it_->rtp.header_length);
|
||||
std::fill_n(packet_data->payload.data(), packet_data->payload.size(), 0);
|
||||
|
||||
++packet_stream_it_;
|
||||
return packet_data;
|
||||
}
|
||||
|
||||
void AdvanceOutputEvent() override {
|
||||
if (output_events_it_ != output_events_end_) {
|
||||
++output_events_it_;
|
||||
}
|
||||
}
|
||||
|
||||
bool ended() const override { return !NextEventTime(); }
|
||||
|
||||
absl::optional<RTPHeader> NextHeader() const override {
|
||||
if (packet_stream_it_ == packet_stream_.end()) {
|
||||
return absl::nullopt;
|
||||
}
|
||||
return packet_stream_it_->rtp.header;
|
||||
}
|
||||
|
||||
private:
|
||||
const std::vector<LoggedRtpPacketIncoming>& packet_stream_;
|
||||
std::vector<LoggedRtpPacketIncoming>::const_iterator packet_stream_it_;
|
||||
std::vector<LoggedAudioPlayoutEvent>::const_iterator output_events_it_;
|
||||
const std::vector<LoggedAudioPlayoutEvent>::const_iterator output_events_end_;
|
||||
const absl::optional<int64_t> end_time_ms_;
|
||||
};
|
||||
|
||||
namespace {
|
||||
|
||||
// Factory to create a "replacement decoder" that produces the decoded audio
|
||||
// by reading from a file rather than from the encoded payloads.
|
||||
class ReplacementAudioDecoderFactory : public AudioDecoderFactory {
|
||||
public:
|
||||
ReplacementAudioDecoderFactory(const absl::string_view replacement_file_name,
|
||||
int file_sample_rate_hz)
|
||||
: replacement_file_name_(replacement_file_name),
|
||||
file_sample_rate_hz_(file_sample_rate_hz) {}
|
||||
|
||||
std::vector<AudioCodecSpec> GetSupportedDecoders() override {
|
||||
RTC_NOTREACHED();
|
||||
return {};
|
||||
}
|
||||
|
||||
bool IsSupportedDecoder(const SdpAudioFormat& format) override {
|
||||
return true;
|
||||
}
|
||||
|
||||
std::unique_ptr<AudioDecoder> MakeAudioDecoder(
|
||||
const SdpAudioFormat& format,
|
||||
absl::optional<AudioCodecPairId> codec_pair_id) override {
|
||||
auto replacement_file = std::make_unique<test::ResampleInputAudioFile>(
|
||||
replacement_file_name_, file_sample_rate_hz_);
|
||||
replacement_file->set_output_rate_hz(48000);
|
||||
return std::make_unique<test::FakeDecodeFromFile>(
|
||||
std::move(replacement_file), 48000, false);
|
||||
}
|
||||
|
||||
private:
|
||||
const std::string replacement_file_name_;
|
||||
const int file_sample_rate_hz_;
|
||||
};
|
||||
|
||||
// Creates a NetEq test object and all necessary input and output helpers. Runs
|
||||
// the test and returns the NetEqDelayAnalyzer object that was used to
|
||||
// instrument the test.
|
||||
std::unique_ptr<test::NetEqStatsGetter> CreateNetEqTestAndRun(
|
||||
const std::vector<LoggedRtpPacketIncoming>* packet_stream,
|
||||
const std::vector<LoggedAudioPlayoutEvent>* output_events,
|
||||
absl::optional<int64_t> end_time_ms,
|
||||
const std::string& replacement_file_name,
|
||||
int file_sample_rate_hz) {
|
||||
std::unique_ptr<test::NetEqInput> input(
|
||||
new NetEqStreamInput(packet_stream, output_events, end_time_ms));
|
||||
|
||||
constexpr int kReplacementPt = 127;
|
||||
std::set<uint8_t> cn_types;
|
||||
std::set<uint8_t> forbidden_types;
|
||||
input.reset(new test::NetEqReplacementInput(std::move(input), kReplacementPt,
|
||||
cn_types, forbidden_types));
|
||||
|
||||
NetEq::Config config;
|
||||
config.max_packets_in_buffer = 200;
|
||||
config.enable_fast_accelerate = true;
|
||||
|
||||
std::unique_ptr<test::VoidAudioSink> output(new test::VoidAudioSink());
|
||||
|
||||
rtc::scoped_refptr<AudioDecoderFactory> decoder_factory =
|
||||
new rtc::RefCountedObject<ReplacementAudioDecoderFactory>(
|
||||
replacement_file_name, file_sample_rate_hz);
|
||||
|
||||
test::NetEqTest::DecoderMap codecs = {
|
||||
{kReplacementPt, SdpAudioFormat("l16", 48000, 1)}};
|
||||
|
||||
std::unique_ptr<test::NetEqDelayAnalyzer> delay_cb(
|
||||
new test::NetEqDelayAnalyzer);
|
||||
std::unique_ptr<test::NetEqStatsGetter> neteq_stats_getter(
|
||||
new test::NetEqStatsGetter(std::move(delay_cb)));
|
||||
test::DefaultNetEqTestErrorCallback error_cb;
|
||||
test::NetEqTest::Callbacks callbacks;
|
||||
callbacks.error_callback = &error_cb;
|
||||
callbacks.post_insert_packet = neteq_stats_getter->delay_analyzer();
|
||||
callbacks.get_audio_callback = neteq_stats_getter.get();
|
||||
|
||||
test::NetEqTest test(config, decoder_factory, codecs, /*text_log=*/nullptr,
|
||||
/*factory=*/nullptr, std::move(input), std::move(output),
|
||||
callbacks);
|
||||
test.Run();
|
||||
return neteq_stats_getter;
|
||||
}
|
||||
} // namespace
|
||||
|
||||
EventLogAnalyzer::NetEqStatsGetterMap EventLogAnalyzer::SimulateNetEq(
|
||||
const std::string& replacement_file_name,
|
||||
int file_sample_rate_hz) const {
|
||||
NetEqStatsGetterMap neteq_stats;
|
||||
|
||||
for (const auto& stream : parsed_log_.incoming_rtp_packets_by_ssrc()) {
|
||||
const uint32_t ssrc = stream.ssrc;
|
||||
if (!IsAudioSsrc(parsed_log_, kIncomingPacket, ssrc))
|
||||
continue;
|
||||
const std::vector<LoggedRtpPacketIncoming>* audio_packets =
|
||||
&stream.incoming_packets;
|
||||
if (audio_packets == nullptr) {
|
||||
// No incoming audio stream found.
|
||||
continue;
|
||||
}
|
||||
|
||||
RTC_DCHECK(neteq_stats.find(ssrc) == neteq_stats.end());
|
||||
|
||||
std::map<uint32_t, std::vector<LoggedAudioPlayoutEvent>>::const_iterator
|
||||
output_events_it = parsed_log_.audio_playout_events().find(ssrc);
|
||||
if (output_events_it == parsed_log_.audio_playout_events().end()) {
|
||||
// Could not find output events with SSRC matching the input audio stream.
|
||||
// Using the first available stream of output events.
|
||||
output_events_it = parsed_log_.audio_playout_events().cbegin();
|
||||
}
|
||||
|
||||
int64_t end_time_ms = parsed_log_.first_log_segment().stop_time_ms();
|
||||
|
||||
neteq_stats[ssrc] = CreateNetEqTestAndRun(
|
||||
audio_packets, &output_events_it->second, end_time_ms,
|
||||
replacement_file_name, file_sample_rate_hz);
|
||||
}
|
||||
|
||||
return neteq_stats;
|
||||
}
|
||||
|
||||
// Given a NetEqStatsGetter and the SSRC that the NetEqStatsGetter was created
|
||||
// for, this method generates a plot for the jitter buffer delay profile.
|
||||
void EventLogAnalyzer::CreateAudioJitterBufferGraph(
|
||||
uint32_t ssrc,
|
||||
const test::NetEqStatsGetter* stats_getter,
|
||||
Plot* plot) const {
|
||||
test::NetEqDelayAnalyzer::Delays arrival_delay_ms;
|
||||
test::NetEqDelayAnalyzer::Delays corrected_arrival_delay_ms;
|
||||
test::NetEqDelayAnalyzer::Delays playout_delay_ms;
|
||||
test::NetEqDelayAnalyzer::Delays target_delay_ms;
|
||||
|
||||
stats_getter->delay_analyzer()->CreateGraphs(
|
||||
&arrival_delay_ms, &corrected_arrival_delay_ms, &playout_delay_ms,
|
||||
&target_delay_ms);
|
||||
|
||||
TimeSeries time_series_packet_arrival("packet arrival delay",
|
||||
LineStyle::kLine);
|
||||
TimeSeries time_series_relative_packet_arrival(
|
||||
"Relative packet arrival delay", LineStyle::kLine);
|
||||
TimeSeries time_series_play_time("Playout delay", LineStyle::kLine);
|
||||
TimeSeries time_series_target_time("Target delay", LineStyle::kLine,
|
||||
PointStyle::kHighlight);
|
||||
|
||||
for (const auto& data : arrival_delay_ms) {
|
||||
const float x = config_.GetCallTimeSec(data.first * 1000); // ms to us.
|
||||
const float y = data.second;
|
||||
time_series_packet_arrival.points.emplace_back(TimeSeriesPoint(x, y));
|
||||
}
|
||||
for (const auto& data : corrected_arrival_delay_ms) {
|
||||
const float x = config_.GetCallTimeSec(data.first * 1000); // ms to us.
|
||||
const float y = data.second;
|
||||
time_series_relative_packet_arrival.points.emplace_back(
|
||||
TimeSeriesPoint(x, y));
|
||||
}
|
||||
for (const auto& data : playout_delay_ms) {
|
||||
const float x = config_.GetCallTimeSec(data.first * 1000); // ms to us.
|
||||
const float y = data.second;
|
||||
time_series_play_time.points.emplace_back(TimeSeriesPoint(x, y));
|
||||
}
|
||||
for (const auto& data : target_delay_ms) {
|
||||
const float x = config_.GetCallTimeSec(data.first * 1000); // ms to us.
|
||||
const float y = data.second;
|
||||
time_series_target_time.points.emplace_back(TimeSeriesPoint(x, y));
|
||||
}
|
||||
|
||||
plot->AppendTimeSeries(std::move(time_series_packet_arrival));
|
||||
plot->AppendTimeSeries(std::move(time_series_relative_packet_arrival));
|
||||
plot->AppendTimeSeries(std::move(time_series_play_time));
|
||||
plot->AppendTimeSeries(std::move(time_series_target_time));
|
||||
|
||||
plot->SetXAxis(config_.CallBeginTimeSec(), config_.CallEndTimeSec(),
|
||||
"Time (s)", kLeftMargin, kRightMargin);
|
||||
plot->SetSuggestedYAxis(0, 1, "Relative delay (ms)", kBottomMargin,
|
||||
kTopMargin);
|
||||
plot->SetTitle("NetEq timing for " +
|
||||
GetStreamName(parsed_log_, kIncomingPacket, ssrc));
|
||||
}
|
||||
|
||||
template <typename NetEqStatsType>
|
||||
void EventLogAnalyzer::CreateNetEqStatsGraphInternal(
|
||||
const NetEqStatsGetterMap& neteq_stats,
|
||||
rtc::FunctionView<const std::vector<std::pair<int64_t, NetEqStatsType>>*(
|
||||
const test::NetEqStatsGetter*)> data_extractor,
|
||||
rtc::FunctionView<float(const NetEqStatsType&)> stats_extractor,
|
||||
const std::string& plot_name,
|
||||
Plot* plot) const {
|
||||
std::map<uint32_t, TimeSeries> time_series;
|
||||
|
||||
for (const auto& st : neteq_stats) {
|
||||
const uint32_t ssrc = st.first;
|
||||
const std::vector<std::pair<int64_t, NetEqStatsType>>* data_vector =
|
||||
data_extractor(st.second.get());
|
||||
for (const auto& data : *data_vector) {
|
||||
const float time =
|
||||
config_.GetCallTimeSec(data.first * 1000); // ms to us.
|
||||
const float value = stats_extractor(data.second);
|
||||
time_series[ssrc].points.emplace_back(TimeSeriesPoint(time, value));
|
||||
}
|
||||
}
|
||||
|
||||
for (auto& series : time_series) {
|
||||
series.second.label =
|
||||
GetStreamName(parsed_log_, kIncomingPacket, series.first);
|
||||
series.second.line_style = LineStyle::kLine;
|
||||
plot->AppendTimeSeries(std::move(series.second));
|
||||
}
|
||||
|
||||
plot->SetXAxis(config_.CallBeginTimeSec(), config_.CallEndTimeSec(),
|
||||
"Time (s)", kLeftMargin, kRightMargin);
|
||||
plot->SetSuggestedYAxis(0, 1, plot_name, kBottomMargin, kTopMargin);
|
||||
plot->SetTitle(plot_name);
|
||||
}
|
||||
|
||||
void EventLogAnalyzer::CreateNetEqNetworkStatsGraph(
|
||||
const NetEqStatsGetterMap& neteq_stats,
|
||||
rtc::FunctionView<float(const NetEqNetworkStatistics&)> stats_extractor,
|
||||
const std::string& plot_name,
|
||||
Plot* plot) const {
|
||||
CreateNetEqStatsGraphInternal<NetEqNetworkStatistics>(
|
||||
neteq_stats,
|
||||
[](const test::NetEqStatsGetter* stats_getter) {
|
||||
return stats_getter->stats();
|
||||
},
|
||||
stats_extractor, plot_name, plot);
|
||||
}
|
||||
|
||||
void EventLogAnalyzer::CreateNetEqLifetimeStatsGraph(
|
||||
const NetEqStatsGetterMap& neteq_stats,
|
||||
rtc::FunctionView<float(const NetEqLifetimeStatistics&)> stats_extractor,
|
||||
const std::string& plot_name,
|
||||
Plot* plot) const {
|
||||
CreateNetEqStatsGraphInternal<NetEqLifetimeStatistics>(
|
||||
neteq_stats,
|
||||
[](const test::NetEqStatsGetter* stats_getter) {
|
||||
return stats_getter->lifetime_stats();
|
||||
},
|
||||
stats_extractor, plot_name, plot);
|
||||
}
|
||||
|
||||
void EventLogAnalyzer::CreateIceCandidatePairConfigGraph(Plot* plot) {
|
||||
std::map<uint32_t, TimeSeries> configs_by_cp_id;
|
||||
for (const auto& config : parsed_log_.ice_candidate_pair_configs()) {
|
||||
|
||||
@ -79,32 +79,6 @@ class EventLogAnalyzer {
|
||||
std::string yaxis_label,
|
||||
Plot* plot);
|
||||
|
||||
void CreateAudioEncoderTargetBitrateGraph(Plot* plot);
|
||||
void CreateAudioEncoderFrameLengthGraph(Plot* plot);
|
||||
void CreateAudioEncoderPacketLossGraph(Plot* plot);
|
||||
void CreateAudioEncoderEnableFecGraph(Plot* plot);
|
||||
void CreateAudioEncoderEnableDtxGraph(Plot* plot);
|
||||
void CreateAudioEncoderNumChannelsGraph(Plot* plot);
|
||||
|
||||
using NetEqStatsGetterMap =
|
||||
std::map<uint32_t, std::unique_ptr<test::NetEqStatsGetter>>;
|
||||
NetEqStatsGetterMap SimulateNetEq(const std::string& replacement_file_name,
|
||||
int file_sample_rate_hz) const;
|
||||
|
||||
void CreateAudioJitterBufferGraph(uint32_t ssrc,
|
||||
const test::NetEqStatsGetter* stats_getter,
|
||||
Plot* plot) const;
|
||||
void CreateNetEqNetworkStatsGraph(
|
||||
const NetEqStatsGetterMap& neteq_stats_getters,
|
||||
rtc::FunctionView<float(const NetEqNetworkStatistics&)> stats_extractor,
|
||||
const std::string& plot_name,
|
||||
Plot* plot) const;
|
||||
void CreateNetEqLifetimeStatsGraph(
|
||||
const NetEqStatsGetterMap& neteq_stats_getters,
|
||||
rtc::FunctionView<float(const NetEqLifetimeStatistics&)> stats_extractor,
|
||||
const std::string& plot_name,
|
||||
Plot* plot) const;
|
||||
|
||||
void CreateIceCandidatePairConfigGraph(Plot* plot);
|
||||
void CreateIceConnectivityCheckGraph(Plot* plot);
|
||||
|
||||
@ -115,15 +89,6 @@ class EventLogAnalyzer {
|
||||
void PrintNotifications(FILE* file);
|
||||
|
||||
private:
|
||||
template <typename NetEqStatsType>
|
||||
void CreateNetEqStatsGraphInternal(
|
||||
const NetEqStatsGetterMap& neteq_stats,
|
||||
rtc::FunctionView<const std::vector<std::pair<int64_t, NetEqStatsType>>*(
|
||||
const test::NetEqStatsGetter*)> data_extractor,
|
||||
rtc::FunctionView<float(const NetEqStatsType&)> stats_extractor,
|
||||
const std::string& plot_name,
|
||||
Plot* plot) const;
|
||||
|
||||
template <typename IterableType>
|
||||
void CreateAccumulatedPacketsTimeSeries(Plot* plot,
|
||||
const IterableType& packets,
|
||||
|
||||
@ -14,10 +14,19 @@
|
||||
#include <cstdint>
|
||||
#include <string>
|
||||
|
||||
#include "absl/types/optional.h"
|
||||
#include "api/function_view.h"
|
||||
#include "logging/rtc_event_log/rtc_event_log_parser.h"
|
||||
#include "rtc_tools/rtc_event_log_visualizer/plot_base.h"
|
||||
|
||||
namespace webrtc {
|
||||
|
||||
constexpr int kNumMicrosecsPerSec = 1000000;
|
||||
constexpr float kLeftMargin = 0.01f;
|
||||
constexpr float kRightMargin = 0.02f;
|
||||
constexpr float kBottomMargin = 0.02f;
|
||||
constexpr float kTopMargin = 0.05f;
|
||||
|
||||
class AnalyzerConfig {
|
||||
public:
|
||||
float GetCallTimeSec(int64_t timestamp_us) const {
|
||||
@ -74,6 +83,100 @@ std::string GetStreamName(const ParsedRtcEventLog& parsed_log,
|
||||
uint32_t ssrc);
|
||||
std::string GetLayerName(LayerDescription layer);
|
||||
|
||||
// For each element in data_view, use |f()| to extract a y-coordinate and
|
||||
// store the result in a TimeSeries.
|
||||
template <typename DataType, typename IterableType>
|
||||
void ProcessPoints(rtc::FunctionView<float(const DataType&)> fx,
|
||||
rtc::FunctionView<absl::optional<float>(const DataType&)> fy,
|
||||
const IterableType& data_view,
|
||||
TimeSeries* result) {
|
||||
for (size_t i = 0; i < data_view.size(); i++) {
|
||||
const DataType& elem = data_view[i];
|
||||
float x = fx(elem);
|
||||
absl::optional<float> y = fy(elem);
|
||||
if (y)
|
||||
result->points.emplace_back(x, *y);
|
||||
}
|
||||
}
|
||||
|
||||
// For each pair of adjacent elements in |data|, use |f()| to extract a
|
||||
// y-coordinate and store the result in a TimeSeries. Note that the x-coordinate
|
||||
// will be the time of the second element in the pair.
|
||||
template <typename DataType, typename ResultType, typename IterableType>
|
||||
void ProcessPairs(
|
||||
rtc::FunctionView<float(const DataType&)> fx,
|
||||
rtc::FunctionView<absl::optional<ResultType>(const DataType&,
|
||||
const DataType&)> fy,
|
||||
const IterableType& data,
|
||||
TimeSeries* result) {
|
||||
for (size_t i = 1; i < data.size(); i++) {
|
||||
float x = fx(data[i]);
|
||||
absl::optional<ResultType> y = fy(data[i - 1], data[i]);
|
||||
if (y)
|
||||
result->points.emplace_back(x, static_cast<float>(*y));
|
||||
}
|
||||
}
|
||||
|
||||
// For each pair of adjacent elements in |data|, use |f()| to extract a
|
||||
// y-coordinate and store the result in a TimeSeries. Note that the x-coordinate
|
||||
// will be the time of the second element in the pair.
|
||||
template <typename DataType, typename ResultType, typename IterableType>
|
||||
void AccumulatePairs(
|
||||
rtc::FunctionView<float(const DataType&)> fx,
|
||||
rtc::FunctionView<absl::optional<ResultType>(const DataType&,
|
||||
const DataType&)> fy,
|
||||
const IterableType& data,
|
||||
TimeSeries* result) {
|
||||
ResultType sum = 0;
|
||||
for (size_t i = 1; i < data.size(); i++) {
|
||||
float x = fx(data[i]);
|
||||
absl::optional<ResultType> y = fy(data[i - 1], data[i]);
|
||||
if (y) {
|
||||
sum += *y;
|
||||
result->points.emplace_back(x, static_cast<float>(sum));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Calculates a moving average of |data| and stores the result in a TimeSeries.
|
||||
// A data point is generated every |step| microseconds from |begin_time|
|
||||
// to |end_time|. The value of each data point is the average of the data
|
||||
// during the preceding |window_duration_us| microseconds.
|
||||
template <typename DataType, typename ResultType, typename IterableType>
|
||||
void MovingAverage(
|
||||
rtc::FunctionView<absl::optional<ResultType>(const DataType&)> fy,
|
||||
const IterableType& data_view,
|
||||
AnalyzerConfig config,
|
||||
TimeSeries* result) {
|
||||
size_t window_index_begin = 0;
|
||||
size_t window_index_end = 0;
|
||||
ResultType sum_in_window = 0;
|
||||
|
||||
for (int64_t t = config.begin_time_; t < config.end_time_ + config.step_;
|
||||
t += config.step_) {
|
||||
while (window_index_end < data_view.size() &&
|
||||
data_view[window_index_end].log_time_us() < t) {
|
||||
absl::optional<ResultType> value = fy(data_view[window_index_end]);
|
||||
if (value)
|
||||
sum_in_window += *value;
|
||||
++window_index_end;
|
||||
}
|
||||
while (window_index_begin < data_view.size() &&
|
||||
data_view[window_index_begin].log_time_us() <
|
||||
t - config.window_duration_) {
|
||||
absl::optional<ResultType> value = fy(data_view[window_index_begin]);
|
||||
if (value)
|
||||
sum_in_window -= *value;
|
||||
++window_index_begin;
|
||||
}
|
||||
float window_duration_s =
|
||||
static_cast<float>(config.window_duration_) / kNumMicrosecsPerSec;
|
||||
float x = config.GetCallTimeSec(t);
|
||||
float y = sum_in_window / window_duration_s;
|
||||
result->points.emplace_back(x, y);
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace webrtc
|
||||
|
||||
#endif // RTC_TOOLS_RTC_EVENT_LOG_VISUALIZER_ANALYZER_COMMON_H_
|
||||
|
||||
@ -31,6 +31,7 @@
|
||||
#include "rtc_base/checks.h"
|
||||
#include "rtc_base/logging.h"
|
||||
#include "rtc_tools/rtc_event_log_visualizer/alerts.h"
|
||||
#include "rtc_tools/rtc_event_log_visualizer/analyze_audio.h"
|
||||
#include "rtc_tools/rtc_event_log_visualizer/analyzer.h"
|
||||
#include "rtc_tools/rtc_event_log_visualizer/plot_base.h"
|
||||
#include "rtc_tools/rtc_event_log_visualizer/plot_protobuf.h"
|
||||
@ -436,22 +437,22 @@ int main(int argc, char* argv[]) {
|
||||
plots.RegisterPlot("pacer_delay",
|
||||
[&](Plot* plot) { analyzer.CreatePacerDelayGraph(plot); });
|
||||
plots.RegisterPlot("audio_encoder_bitrate", [&](Plot* plot) {
|
||||
analyzer.CreateAudioEncoderTargetBitrateGraph(plot);
|
||||
CreateAudioEncoderTargetBitrateGraph(parsed_log, config, plot);
|
||||
});
|
||||
plots.RegisterPlot("audio_encoder_frame_length", [&](Plot* plot) {
|
||||
analyzer.CreateAudioEncoderFrameLengthGraph(plot);
|
||||
CreateAudioEncoderFrameLengthGraph(parsed_log, config, plot);
|
||||
});
|
||||
plots.RegisterPlot("audio_encoder_packet_loss", [&](Plot* plot) {
|
||||
analyzer.CreateAudioEncoderPacketLossGraph(plot);
|
||||
CreateAudioEncoderPacketLossGraph(parsed_log, config, plot);
|
||||
});
|
||||
plots.RegisterPlot("audio_encoder_fec", [&](Plot* plot) {
|
||||
analyzer.CreateAudioEncoderEnableFecGraph(plot);
|
||||
CreateAudioEncoderEnableFecGraph(parsed_log, config, plot);
|
||||
});
|
||||
plots.RegisterPlot("audio_encoder_dtx", [&](Plot* plot) {
|
||||
analyzer.CreateAudioEncoderEnableDtxGraph(plot);
|
||||
CreateAudioEncoderEnableDtxGraph(parsed_log, config, plot);
|
||||
});
|
||||
plots.RegisterPlot("audio_encoder_num_channels", [&](Plot* plot) {
|
||||
analyzer.CreateAudioEncoderNumChannelsGraph(plot);
|
||||
CreateAudioEncoderNumChannelsGraph(parsed_log, config, plot);
|
||||
});
|
||||
|
||||
plots.RegisterPlot("ice_candidate_pair_config", [&](Plot* plot) {
|
||||
@ -474,14 +475,14 @@ int main(int argc, char* argv[]) {
|
||||
wav_path = webrtc::test::ResourcePath(
|
||||
"audio_processing/conversational_speech/EN_script2_F_sp2_B1", "wav");
|
||||
}
|
||||
absl::optional<webrtc::EventLogAnalyzer::NetEqStatsGetterMap> neteq_stats;
|
||||
absl::optional<webrtc::NetEqStatsGetterMap> neteq_stats;
|
||||
|
||||
plots.RegisterPlot("simulated_neteq_expand_rate", [&](Plot* plot) {
|
||||
if (!neteq_stats) {
|
||||
neteq_stats = analyzer.SimulateNetEq(wav_path, 48000);
|
||||
neteq_stats = webrtc::SimulateNetEq(parsed_log, config, wav_path, 48000);
|
||||
}
|
||||
analyzer.CreateNetEqNetworkStatsGraph(
|
||||
*neteq_stats,
|
||||
webrtc::CreateNetEqNetworkStatsGraph(
|
||||
parsed_log, config, *neteq_stats,
|
||||
[](const webrtc::NetEqNetworkStatistics& stats) {
|
||||
return stats.expand_rate / 16384.f;
|
||||
},
|
||||
@ -490,10 +491,10 @@ int main(int argc, char* argv[]) {
|
||||
|
||||
plots.RegisterPlot("simulated_neteq_speech_expand_rate", [&](Plot* plot) {
|
||||
if (!neteq_stats) {
|
||||
neteq_stats = analyzer.SimulateNetEq(wav_path, 48000);
|
||||
neteq_stats = webrtc::SimulateNetEq(parsed_log, config, wav_path, 48000);
|
||||
}
|
||||
analyzer.CreateNetEqNetworkStatsGraph(
|
||||
*neteq_stats,
|
||||
webrtc::CreateNetEqNetworkStatsGraph(
|
||||
parsed_log, config, *neteq_stats,
|
||||
[](const webrtc::NetEqNetworkStatistics& stats) {
|
||||
return stats.speech_expand_rate / 16384.f;
|
||||
},
|
||||
@ -502,10 +503,10 @@ int main(int argc, char* argv[]) {
|
||||
|
||||
plots.RegisterPlot("simulated_neteq_accelerate_rate", [&](Plot* plot) {
|
||||
if (!neteq_stats) {
|
||||
neteq_stats = analyzer.SimulateNetEq(wav_path, 48000);
|
||||
neteq_stats = webrtc::SimulateNetEq(parsed_log, config, wav_path, 48000);
|
||||
}
|
||||
analyzer.CreateNetEqNetworkStatsGraph(
|
||||
*neteq_stats,
|
||||
webrtc::CreateNetEqNetworkStatsGraph(
|
||||
parsed_log, config, *neteq_stats,
|
||||
[](const webrtc::NetEqNetworkStatistics& stats) {
|
||||
return stats.accelerate_rate / 16384.f;
|
||||
},
|
||||
@ -514,10 +515,10 @@ int main(int argc, char* argv[]) {
|
||||
|
||||
plots.RegisterPlot("simulated_neteq_preemptive_rate", [&](Plot* plot) {
|
||||
if (!neteq_stats) {
|
||||
neteq_stats = analyzer.SimulateNetEq(wav_path, 48000);
|
||||
neteq_stats = webrtc::SimulateNetEq(parsed_log, config, wav_path, 48000);
|
||||
}
|
||||
analyzer.CreateNetEqNetworkStatsGraph(
|
||||
*neteq_stats,
|
||||
webrtc::CreateNetEqNetworkStatsGraph(
|
||||
parsed_log, config, *neteq_stats,
|
||||
[](const webrtc::NetEqNetworkStatistics& stats) {
|
||||
return stats.preemptive_rate / 16384.f;
|
||||
},
|
||||
@ -526,10 +527,10 @@ int main(int argc, char* argv[]) {
|
||||
|
||||
plots.RegisterPlot("simulated_neteq_packet_loss_rate", [&](Plot* plot) {
|
||||
if (!neteq_stats) {
|
||||
neteq_stats = analyzer.SimulateNetEq(wav_path, 48000);
|
||||
neteq_stats = webrtc::SimulateNetEq(parsed_log, config, wav_path, 48000);
|
||||
}
|
||||
analyzer.CreateNetEqNetworkStatsGraph(
|
||||
*neteq_stats,
|
||||
webrtc::CreateNetEqNetworkStatsGraph(
|
||||
parsed_log, config, *neteq_stats,
|
||||
[](const webrtc::NetEqNetworkStatistics& stats) {
|
||||
return stats.packet_loss_rate / 16384.f;
|
||||
},
|
||||
@ -538,10 +539,10 @@ int main(int argc, char* argv[]) {
|
||||
|
||||
plots.RegisterPlot("simulated_neteq_concealment_events", [&](Plot* plot) {
|
||||
if (!neteq_stats) {
|
||||
neteq_stats = analyzer.SimulateNetEq(wav_path, 48000);
|
||||
neteq_stats = webrtc::SimulateNetEq(parsed_log, config, wav_path, 48000);
|
||||
}
|
||||
analyzer.CreateNetEqLifetimeStatsGraph(
|
||||
*neteq_stats,
|
||||
webrtc::CreateNetEqLifetimeStatsGraph(
|
||||
parsed_log, config, *neteq_stats,
|
||||
[](const webrtc::NetEqLifetimeStatistics& stats) {
|
||||
return static_cast<float>(stats.concealment_events);
|
||||
},
|
||||
@ -550,10 +551,10 @@ int main(int argc, char* argv[]) {
|
||||
|
||||
plots.RegisterPlot("simulated_neteq_preferred_buffer_size", [&](Plot* plot) {
|
||||
if (!neteq_stats) {
|
||||
neteq_stats = analyzer.SimulateNetEq(wav_path, 48000);
|
||||
neteq_stats = webrtc::SimulateNetEq(parsed_log, config, wav_path, 48000);
|
||||
}
|
||||
analyzer.CreateNetEqNetworkStatsGraph(
|
||||
*neteq_stats,
|
||||
webrtc::CreateNetEqNetworkStatsGraph(
|
||||
parsed_log, config, *neteq_stats,
|
||||
[](const webrtc::NetEqNetworkStatistics& stats) {
|
||||
return stats.preferred_buffer_size_ms;
|
||||
},
|
||||
@ -614,13 +615,13 @@ int main(int argc, char* argv[]) {
|
||||
if (absl::c_find(plot_flags, "simulated_neteq_jitter_buffer_delay") !=
|
||||
plot_flags.end()) {
|
||||
if (!neteq_stats) {
|
||||
neteq_stats = analyzer.SimulateNetEq(wav_path, 48000);
|
||||
neteq_stats = webrtc::SimulateNetEq(parsed_log, config, wav_path, 48000);
|
||||
}
|
||||
for (webrtc::EventLogAnalyzer::NetEqStatsGetterMap::const_iterator it =
|
||||
neteq_stats->cbegin();
|
||||
for (webrtc::NetEqStatsGetterMap::const_iterator it = neteq_stats->cbegin();
|
||||
it != neteq_stats->cend(); ++it) {
|
||||
analyzer.CreateAudioJitterBufferGraph(it->first, it->second.get(),
|
||||
collection->AppendNewPlot());
|
||||
webrtc::CreateAudioJitterBufferGraph(parsed_log, config, it->first,
|
||||
it->second.get(),
|
||||
collection->AppendNewPlot());
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user