admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
webrtc_m130/video/send_statistics_proxy.cc
Henrik Boström fe25b0e928 Report 'outbound-rtp.targetBitrate' correctly and per-RTP stream. 
This CL fixes two issues with the old way targetBitrate was reported:
1. The target is per encoder, i.e. per SSRC, but the old way to report
   it was per sender and was approximately the sum of all encodings'
   targetBitrate in most cases.
2. The old value did not come directly from the VideoBitrateAllocation
   and tended to be greater than the sum of all targets (don't know
   why).

We know the old value was wrong and the new value correct because
the actual bytes produced by the encoder closely matches the configured
target, which wasn't always the case with the old metric implementation.

Tested with unit tests and manually in Chrome by going to
https://henbos.github.io/codec-quality/src/index.html and ensuring
target ~= actual bytes produced. It also matches the debug logging of
video_stream_encoder.cc.

Bug: webrtc:42225524, chromium:392424845
Change-Id: I7a6f69e053ebc3fd972c2c4b7712750e721c0acc
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/376460
Reviewed-by: Danil Chapovalov <danilchap@webrtc.org>
Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org>
Commit-Queue: Henrik Boström <hbos@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#43854}
2025-02-06 09:55:11 -08:00

1578 lines
60 KiB
C++
Raw Blame History

/*
* Copyright (c) 2013 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 "video/send_statistics_proxy.h"
#include <algorithm>
#include <array>
#include <cmath>
#include <limits>
#include <utility>
#include "absl/strings/match.h"
#include "api/video/video_codec_constants.h"
#include "api/video/video_codec_type.h"
#include "api/video_codecs/video_codec.h"
#include "modules/video_coding/include/video_codec_interface.h"
#include "rtc_base/checks.h"
#include "rtc_base/logging.h"
#include "rtc_base/numerics/mod_ops.h"
#include "rtc_base/strings/string_builder.h"
#include "system_wrappers/include/metrics.h"
namespace webrtc {
namespace {
const float kEncodeTimeWeigthFactor = 0.5f;
const size_t kMaxEncodedFrameMapSize = 150;
const int64_t kMaxEncodedFrameWindowMs = 800;
const uint32_t kMaxEncodedFrameTimestampDiff = 900000; // 10 sec.
const int64_t kBucketSizeMs = 100;
const size_t kBucketCount = 10;
const char kVp8ForcedFallbackEncoderFieldTrial[] =
"WebRTC-VP8-Forced-Fallback-Encoder-v2";
const char kVp8SwCodecName[] = "libvpx";
// Used by histograms. Values of entries should not be changed.
enum HistogramCodecType {
kVideoUnknown = 0,
kVideoVp8 = 1,
kVideoVp9 = 2,
kVideoH264 = 3,
kVideoAv1 = 4,
kVideoH265 = 5,
kVideoMax = 64,
};
const char* kRealtimePrefix = "WebRTC.Video.";
const char* kScreenPrefix = "WebRTC.Video.Screenshare.";
const char* GetUmaPrefix(VideoEncoderConfig::ContentType content_type) {
switch (content_type) {
case VideoEncoderConfig::ContentType::kRealtimeVideo:
return kRealtimePrefix;
case VideoEncoderConfig::ContentType::kScreen:
return kScreenPrefix;
}
RTC_DCHECK_NOTREACHED();
return nullptr;
}
HistogramCodecType PayloadNameToHistogramCodecType(
const std::string& payload_name) {
VideoCodecType codecType = PayloadStringToCodecType(payload_name);
switch (codecType) {
case kVideoCodecVP8:
return kVideoVp8;
case kVideoCodecVP9:
return kVideoVp9;
case kVideoCodecH264:
return kVideoH264;
case kVideoCodecAV1:
return kVideoAv1;
case kVideoCodecH265:
return kVideoH265;
default:
return kVideoUnknown;
}
}
void UpdateCodecTypeHistogram(const std::string& payload_name) {
RTC_HISTOGRAM_ENUMERATION("WebRTC.Video.Encoder.CodecType",
PayloadNameToHistogramCodecType(payload_name),
kVideoMax);
}
bool IsForcedFallbackPossible(const CodecSpecificInfo* codec_info,
int simulcast_index) {
return codec_info->codecType == kVideoCodecVP8 && simulcast_index == 0 &&
(codec_info->codecSpecific.VP8.temporalIdx == 0 ||
codec_info->codecSpecific.VP8.temporalIdx == kNoTemporalIdx);
}
std::optional<int> GetFallbackMaxPixels(const std::string& group) {
if (group.empty())
return std::nullopt;
int min_pixels;
int max_pixels;
int min_bps;
if (sscanf(group.c_str(), "-%d,%d,%d", &min_pixels, &max_pixels, &min_bps) !=
3) {
return std::optional<int>();
}
if (min_pixels <= 0 || max_pixels <= 0 || max_pixels < min_pixels)
return std::optional<int>();
return std::optional<int>(max_pixels);
}
std::optional<int> GetFallbackMaxPixelsIfFieldTrialEnabled(
const webrtc::FieldTrialsView& field_trials) {
std::string group = field_trials.Lookup(kVp8ForcedFallbackEncoderFieldTrial);
return (absl::StartsWith(group, "Enabled"))
? GetFallbackMaxPixels(group.substr(7))
: std::optional<int>();
}
std::optional<int> GetFallbackMaxPixelsIfFieldTrialDisabled(
const webrtc::FieldTrialsView& field_trials) {
std::string group = field_trials.Lookup(kVp8ForcedFallbackEncoderFieldTrial);
return (absl::StartsWith(group, "Disabled"))
? GetFallbackMaxPixels(group.substr(8))
: std::optional<int>();
}
} // namespace
SendStatisticsProxy::SendStatisticsProxy(
Clock* clock,
const VideoSendStream::Config& config,
VideoEncoderConfig::ContentType content_type,
const FieldTrialsView& field_trials)
: clock_(clock),
payload_name_(config.rtp.payload_name),
rtp_config_(config.rtp),
fallback_max_pixels_(
GetFallbackMaxPixelsIfFieldTrialEnabled(field_trials)),
fallback_max_pixels_disabled_(
GetFallbackMaxPixelsIfFieldTrialDisabled(field_trials)),
content_type_(content_type),
start_ms_(clock->TimeInMilliseconds()),
encode_time_(kEncodeTimeWeigthFactor),
quality_limitation_reason_tracker_(clock_),
media_byte_rate_tracker_(kBucketSizeMs, kBucketCount),
encoded_frame_rate_tracker_(kBucketSizeMs, kBucketCount),
last_num_spatial_layers_(0),
last_num_simulcast_streams_(0),
last_spatial_layer_use_{},
bw_limited_layers_(false),
internal_encoder_scaler_(false),
uma_container_(
new UmaSamplesContainer(GetUmaPrefix(content_type_), stats_, clock)) {
}
SendStatisticsProxy::~SendStatisticsProxy() {
MutexLock lock(&mutex_);
uma_container_->UpdateHistograms(rtp_config_, stats_);
int64_t elapsed_sec = (clock_->TimeInMilliseconds() - start_ms_) / 1000;
RTC_HISTOGRAM_COUNTS_100000("WebRTC.Video.SendStreamLifetimeInSeconds",
elapsed_sec);
if (elapsed_sec >= metrics::kMinRunTimeInSeconds)
UpdateCodecTypeHistogram(payload_name_);
}
SendStatisticsProxy::FallbackEncoderInfo::FallbackEncoderInfo() = default;
SendStatisticsProxy::Trackers::Trackers()
: encoded_frame_rate(kBucketSizeMs, kBucketCount) {}
SendStatisticsProxy::UmaSamplesContainer::UmaSamplesContainer(
const char* prefix,
const VideoSendStream::Stats& stats,
Clock* const clock)
: uma_prefix_(prefix),
clock_(clock),
input_frame_rate_tracker_(100, 10u),
input_fps_counter_(clock, nullptr, true),
sent_fps_counter_(clock, nullptr, true),
total_byte_counter_(clock, nullptr, true),
media_byte_counter_(clock, nullptr, true),
rtx_byte_counter_(clock, nullptr, true),
padding_byte_counter_(clock, nullptr, true),
retransmit_byte_counter_(clock, nullptr, true),
fec_byte_counter_(clock, nullptr, true),
first_rtcp_stats_time_ms_(-1),
first_rtp_stats_time_ms_(-1),
start_stats_(stats),
num_streams_(0),
num_pixels_highest_stream_(0) {
InitializeBitrateCounters(stats);
static_assert(
kMaxEncodedFrameTimestampDiff < std::numeric_limits<uint32_t>::max() / 2,
"has to be smaller than half range");
}
SendStatisticsProxy::UmaSamplesContainer::~UmaSamplesContainer() {}
void SendStatisticsProxy::UmaSamplesContainer::InitializeBitrateCounters(
const VideoSendStream::Stats& stats) {
for (const auto& it : stats.substreams) {
uint32_t ssrc = it.first;
total_byte_counter_.SetLast(it.second.rtp_stats.transmitted.TotalBytes(),
ssrc);
padding_byte_counter_.SetLast(it.second.rtp_stats.transmitted.padding_bytes,
ssrc);
retransmit_byte_counter_.SetLast(
it.second.rtp_stats.retransmitted.TotalBytes(), ssrc);
fec_byte_counter_.SetLast(it.second.rtp_stats.fec.TotalBytes(), ssrc);
switch (it.second.type) {
case VideoSendStream::StreamStats::StreamType::kMedia:
media_byte_counter_.SetLast(it.second.rtp_stats.MediaPayloadBytes(),
ssrc);
break;
case VideoSendStream::StreamStats::StreamType::kRtx:
rtx_byte_counter_.SetLast(it.second.rtp_stats.transmitted.TotalBytes(),
ssrc);
break;
case VideoSendStream::StreamStats::StreamType::kFlexfec:
break;
}
}
}
void SendStatisticsProxy::UmaSamplesContainer::RemoveOld(int64_t now_ms) {
while (!encoded_frames_.empty()) {
auto it = encoded_frames_.begin();
if (now_ms - it->second.send_ms < kMaxEncodedFrameWindowMs)
break;
// Use max per timestamp.
sent_width_counter_.Add(it->second.max_width);
sent_height_counter_.Add(it->second.max_height);
// Check number of encoded streams per timestamp.
if (num_streams_ > static_cast<size_t>(it->second.max_simulcast_idx)) {
if (num_streams_ > 1) {
int disabled_streams =
static_cast<int>(num_streams_ - 1 - it->second.max_simulcast_idx);
// Can be limited in resolution or framerate.
uint32_t pixels = it->second.max_width * it->second.max_height;
bool bw_limited_resolution =
disabled_streams > 0 && pixels < num_pixels_highest_stream_;
bw_limited_frame_counter_.Add(bw_limited_resolution);
if (bw_limited_resolution) {
bw_resolutions_disabled_counter_.Add(disabled_streams);
}
}
}
encoded_frames_.erase(it);
}
}
bool SendStatisticsProxy::UmaSamplesContainer::InsertEncodedFrame(
const EncodedImage& encoded_frame,
int simulcast_idx) {
int64_t now_ms = clock_->TimeInMilliseconds();
RemoveOld(now_ms);
if (encoded_frames_.size() > kMaxEncodedFrameMapSize) {
encoded_frames_.clear();
}
// Check for jump in timestamp.
if (!encoded_frames_.empty()) {
uint32_t oldest_timestamp = encoded_frames_.begin()->first;
if (ForwardDiff(oldest_timestamp, encoded_frame.RtpTimestamp()) >
kMaxEncodedFrameTimestampDiff) {
// Gap detected, clear frames to have a sequence where newest timestamp
// is not too far away from oldest in order to distinguish old and new.
encoded_frames_.clear();
}
}
auto it = encoded_frames_.find(encoded_frame.RtpTimestamp());
if (it == encoded_frames_.end()) {
// First frame with this timestamp.
encoded_frames_.insert(
std::make_pair(encoded_frame.RtpTimestamp(),
Frame(now_ms, encoded_frame._encodedWidth,
encoded_frame._encodedHeight, simulcast_idx)));
sent_fps_counter_.Add(1);
return true;
}
it->second.max_width =
std::max(it->second.max_width, encoded_frame._encodedWidth);
it->second.max_height =
std::max(it->second.max_height, encoded_frame._encodedHeight);
it->second.max_simulcast_idx =
std::max(it->second.max_simulcast_idx, simulcast_idx);
return false;
}
void SendStatisticsProxy::UmaSamplesContainer::UpdateHistograms(
const RtpConfig& rtp_config,
const VideoSendStream::Stats& current_stats) {
RTC_DCHECK(uma_prefix_ == kRealtimePrefix || uma_prefix_ == kScreenPrefix);
const int kIndex = uma_prefix_ == kScreenPrefix ? 1 : 0;
const int kMinRequiredPeriodicSamples = 6;
char log_stream_buf[8 * 1024];
rtc::SimpleStringBuilder log_stream(log_stream_buf);
int in_width = input_width_counter_.Avg(kMinRequiredMetricsSamples);
int in_height = input_height_counter_.Avg(kMinRequiredMetricsSamples);
if (in_width != -1) {
RTC_HISTOGRAMS_COUNTS_10000(kIndex, uma_prefix_ + "InputWidthInPixels",
in_width);
RTC_HISTOGRAMS_COUNTS_10000(kIndex, uma_prefix_ + "InputHeightInPixels",
in_height);
log_stream << uma_prefix_ << "InputWidthInPixels " << in_width << "\n"
<< uma_prefix_ << "InputHeightInPixels " << in_height << "\n";
}
AggregatedStats in_fps = input_fps_counter_.GetStats();
if (in_fps.num_samples >= kMinRequiredPeriodicSamples) {
RTC_HISTOGRAMS_COUNTS_100(kIndex, uma_prefix_ + "InputFramesPerSecond",
in_fps.average);
log_stream << uma_prefix_ << "InputFramesPerSecond " << in_fps.ToString()
<< "\n";
}
int sent_width = sent_width_counter_.Avg(kMinRequiredMetricsSamples);
int sent_height = sent_height_counter_.Avg(kMinRequiredMetricsSamples);
if (sent_width != -1) {
RTC_HISTOGRAMS_COUNTS_10000(kIndex, uma_prefix_ + "SentWidthInPixels",
sent_width);
RTC_HISTOGRAMS_COUNTS_10000(kIndex, uma_prefix_ + "SentHeightInPixels",
sent_height);
log_stream << uma_prefix_ << "SentWidthInPixels " << sent_width << "\n"
<< uma_prefix_ << "SentHeightInPixels " << sent_height << "\n";
}
AggregatedStats sent_fps = sent_fps_counter_.GetStats();
if (sent_fps.num_samples >= kMinRequiredPeriodicSamples) {
RTC_HISTOGRAMS_COUNTS_100(kIndex, uma_prefix_ + "SentFramesPerSecond",
sent_fps.average);
log_stream << uma_prefix_ << "SentFramesPerSecond " << sent_fps.ToString()
<< "\n";
}
if (in_fps.num_samples > kMinRequiredPeriodicSamples &&
sent_fps.num_samples >= kMinRequiredPeriodicSamples) {
int in_fps_avg = in_fps.average;
if (in_fps_avg > 0) {
int sent_fps_avg = sent_fps.average;
int sent_to_in_fps_ratio_percent =
(100 * sent_fps_avg + in_fps_avg / 2) / in_fps_avg;
// If reported period is small, it may happen that sent_fps is larger than
// input_fps briefly on average. This should be treated as 100% sent to
// input ratio.
if (sent_to_in_fps_ratio_percent > 100)
sent_to_in_fps_ratio_percent = 100;
RTC_HISTOGRAMS_PERCENTAGE(kIndex,
uma_prefix_ + "SentToInputFpsRatioPercent",
sent_to_in_fps_ratio_percent);
log_stream << uma_prefix_ << "SentToInputFpsRatioPercent "
<< sent_to_in_fps_ratio_percent << "\n";
}
}
int encode_ms = encode_time_counter_.Avg(kMinRequiredMetricsSamples);
if (encode_ms != -1) {
RTC_HISTOGRAMS_COUNTS_1000(kIndex, uma_prefix_ + "EncodeTimeInMs",
encode_ms);
log_stream << uma_prefix_ << "EncodeTimeInMs " << encode_ms << "\n";
}
int key_frames_permille =
key_frame_counter_.Permille(kMinRequiredMetricsSamples);
if (key_frames_permille != -1) {
RTC_HISTOGRAMS_COUNTS_1000(kIndex, uma_prefix_ + "KeyFramesSentInPermille",
key_frames_permille);
log_stream << uma_prefix_ << "KeyFramesSentInPermille "
<< key_frames_permille << "\n";
}
int quality_limited =
quality_limited_frame_counter_.Percent(kMinRequiredMetricsSamples);
if (quality_limited != -1) {
RTC_HISTOGRAMS_PERCENTAGE(kIndex,
uma_prefix_ + "QualityLimitedResolutionInPercent",
quality_limited);
log_stream << uma_prefix_ << "QualityLimitedResolutionInPercent "
<< quality_limited << "\n";
}
int downscales = quality_downscales_counter_.Avg(kMinRequiredMetricsSamples);
if (downscales != -1) {
RTC_HISTOGRAMS_ENUMERATION(
kIndex, uma_prefix_ + "QualityLimitedResolutionDownscales", downscales,
20);
}
int cpu_limited =
cpu_limited_frame_counter_.Percent(kMinRequiredMetricsSamples);
if (cpu_limited != -1) {
RTC_HISTOGRAMS_PERCENTAGE(
kIndex, uma_prefix_ + "CpuLimitedResolutionInPercent", cpu_limited);
}
int bw_limited =
bw_limited_frame_counter_.Percent(kMinRequiredMetricsSamples);
if (bw_limited != -1) {
RTC_HISTOGRAMS_PERCENTAGE(
kIndex, uma_prefix_ + "BandwidthLimitedResolutionInPercent",
bw_limited);
}
int num_disabled =
bw_resolutions_disabled_counter_.Avg(kMinRequiredMetricsSamples);
if (num_disabled != -1) {
RTC_HISTOGRAMS_ENUMERATION(
kIndex, uma_prefix_ + "BandwidthLimitedResolutionsDisabled",
num_disabled, 10);
}
int delay_ms = delay_counter_.Avg(kMinRequiredMetricsSamples);
if (delay_ms != -1)
RTC_HISTOGRAMS_COUNTS_100000(kIndex, uma_prefix_ + "SendSideDelayInMs",
delay_ms);
int max_delay_ms = max_delay_counter_.Avg(kMinRequiredMetricsSamples);
if (max_delay_ms != -1) {
RTC_HISTOGRAMS_COUNTS_100000(kIndex, uma_prefix_ + "SendSideDelayMaxInMs",
max_delay_ms);
}
for (const auto& it : qp_counters_) {
int qp_vp8 = it.second.vp8.Avg(kMinRequiredMetricsSamples);
if (qp_vp8 != -1) {
int spatial_idx = it.first;
if (spatial_idx == -1) {
RTC_HISTOGRAMS_COUNTS_200(kIndex, uma_prefix_ + "Encoded.Qp.Vp8",
qp_vp8);
} else if (spatial_idx == 0) {
RTC_HISTOGRAMS_COUNTS_200(kIndex, uma_prefix_ + "Encoded.Qp.Vp8.S0",
qp_vp8);
} else if (spatial_idx == 1) {
RTC_HISTOGRAMS_COUNTS_200(kIndex, uma_prefix_ + "Encoded.Qp.Vp8.S1",
qp_vp8);
} else if (spatial_idx == 2) {
RTC_HISTOGRAMS_COUNTS_200(kIndex, uma_prefix_ + "Encoded.Qp.Vp8.S2",
qp_vp8);
} else {
RTC_LOG(LS_WARNING)
<< "QP stats not recorded for VP8 spatial idx " << spatial_idx;
}
}
int qp_vp9 = it.second.vp9.Avg(kMinRequiredMetricsSamples);
if (qp_vp9 != -1) {
int spatial_idx = it.first;
if (spatial_idx == -1) {
RTC_HISTOGRAMS_COUNTS_500(kIndex, uma_prefix_ + "Encoded.Qp.Vp9",
qp_vp9);
} else if (spatial_idx == 0) {
RTC_HISTOGRAMS_COUNTS_500(kIndex, uma_prefix_ + "Encoded.Qp.Vp9.S0",
qp_vp9);
} else if (spatial_idx == 1) {
RTC_HISTOGRAMS_COUNTS_500(kIndex, uma_prefix_ + "Encoded.Qp.Vp9.S1",
qp_vp9);
} else if (spatial_idx == 2) {
RTC_HISTOGRAMS_COUNTS_500(kIndex, uma_prefix_ + "Encoded.Qp.Vp9.S2",
qp_vp9);
} else {
RTC_LOG(LS_WARNING)
<< "QP stats not recorded for VP9 spatial layer " << spatial_idx;
}
}
int qp_h264 = it.second.h264.Avg(kMinRequiredMetricsSamples);
if (qp_h264 != -1) {
int spatial_idx = it.first;
if (spatial_idx == -1) {
RTC_HISTOGRAMS_COUNTS_200(kIndex, uma_prefix_ + "Encoded.Qp.H264",
qp_h264);
} else if (spatial_idx == 0) {
RTC_HISTOGRAMS_COUNTS_200(kIndex, uma_prefix_ + "Encoded.Qp.H264.S0",
qp_h264);
} else if (spatial_idx == 1) {
RTC_HISTOGRAMS_COUNTS_200(kIndex, uma_prefix_ + "Encoded.Qp.H264.S1",
qp_h264);
} else if (spatial_idx == 2) {
RTC_HISTOGRAMS_COUNTS_200(kIndex, uma_prefix_ + "Encoded.Qp.H264.S2",
qp_h264);
} else {
RTC_LOG(LS_WARNING)
<< "QP stats not recorded for H264 spatial idx " << spatial_idx;
}
}
}
if (first_rtp_stats_time_ms_ != -1) {
quality_adapt_timer_.Stop(clock_->TimeInMilliseconds());
int64_t elapsed_sec = quality_adapt_timer_.total_ms / 1000;
if (elapsed_sec >= metrics::kMinRunTimeInSeconds) {
int quality_changes = current_stats.number_of_quality_adapt_changes -
start_stats_.number_of_quality_adapt_changes;
// Only base stats on changes during a call, discard initial changes.
int initial_changes =
initial_quality_changes_.down + initial_quality_changes_.up;
if (initial_changes <= quality_changes)
quality_changes -= initial_changes;
RTC_HISTOGRAMS_COUNTS_100(kIndex,
uma_prefix_ + "AdaptChangesPerMinute.Quality",
quality_changes * 60 / elapsed_sec);
}
cpu_adapt_timer_.Stop(clock_->TimeInMilliseconds());
elapsed_sec = cpu_adapt_timer_.total_ms / 1000;
if (elapsed_sec >= metrics::kMinRunTimeInSeconds) {
int cpu_changes = current_stats.number_of_cpu_adapt_changes -
start_stats_.number_of_cpu_adapt_changes;
RTC_HISTOGRAMS_COUNTS_100(kIndex,
uma_prefix_ + "AdaptChangesPerMinute.Cpu",
cpu_changes * 60 / elapsed_sec);
}
}
if (first_rtcp_stats_time_ms_ != -1) {
int64_t elapsed_sec =
(clock_->TimeInMilliseconds() - first_rtcp_stats_time_ms_) / 1000;
if (elapsed_sec >= metrics::kMinRunTimeInSeconds) {
int fraction_lost = report_block_stats_.FractionLostInPercent();
if (fraction_lost != -1) {
RTC_HISTOGRAMS_PERCENTAGE(
kIndex, uma_prefix_ + "SentPacketsLostInPercent", fraction_lost);
log_stream << uma_prefix_ << "SentPacketsLostInPercent "
<< fraction_lost << "\n";
}
// The RTCP packet type counters, delivered via the
// RtcpPacketTypeCounterObserver interface, are aggregates over the entire
// life of the send stream and are not reset when switching content type.
// For the purpose of these statistics though, we want new counts when
// switching since we switch histogram name. On every reset of the
// UmaSamplesContainer, we save the initial state of the counters, so that
// we can calculate the delta here and aggregate over all ssrcs.
RtcpPacketTypeCounter counters;
for (uint32_t ssrc : rtp_config.ssrcs) {
auto kv = current_stats.substreams.find(ssrc);
if (kv == current_stats.substreams.end())
continue;
RtcpPacketTypeCounter stream_counters =
kv->second.rtcp_packet_type_counts;
kv = start_stats_.substreams.find(ssrc);
if (kv != start_stats_.substreams.end())
stream_counters.Subtract(kv->second.rtcp_packet_type_counts);
counters.Add(stream_counters);
}
RTC_HISTOGRAMS_COUNTS_10000(kIndex,
uma_prefix_ + "NackPacketsReceivedPerMinute",
counters.nack_packets * 60 / elapsed_sec);
RTC_HISTOGRAMS_COUNTS_10000(kIndex,
uma_prefix_ + "FirPacketsReceivedPerMinute",
counters.fir_packets * 60 / elapsed_sec);
RTC_HISTOGRAMS_COUNTS_10000(kIndex,
uma_prefix_ + "PliPacketsReceivedPerMinute",
counters.pli_packets * 60 / elapsed_sec);
if (counters.nack_requests > 0) {
RTC_HISTOGRAMS_PERCENTAGE(
kIndex, uma_prefix_ + "UniqueNackRequestsReceivedInPercent",
counters.UniqueNackRequestsInPercent());
}
}
}
if (first_rtp_stats_time_ms_ != -1) {
int64_t elapsed_sec =
(clock_->TimeInMilliseconds() - first_rtp_stats_time_ms_) / 1000;
if (elapsed_sec >= metrics::kMinRunTimeInSeconds) {
RTC_HISTOGRAMS_COUNTS_100(kIndex, uma_prefix_ + "NumberOfPauseEvents",
target_rate_updates_.pause_resume_events);
log_stream << uma_prefix_ << "NumberOfPauseEvents "
<< target_rate_updates_.pause_resume_events << "\n";
int paused_time_percent =
paused_time_counter_.Percent(metrics::kMinRunTimeInSeconds * 1000);
if (paused_time_percent != -1) {
RTC_HISTOGRAMS_PERCENTAGE(kIndex, uma_prefix_ + "PausedTimeInPercent",
paused_time_percent);
log_stream << uma_prefix_ << "PausedTimeInPercent "
<< paused_time_percent << "\n";
}
}
}
if (fallback_info_.is_possible) {
// Double interval since there is some time before fallback may occur.
const int kMinRunTimeMs = 2 * metrics::kMinRunTimeInSeconds * 1000;
int64_t elapsed_ms = fallback_info_.elapsed_ms;
int fallback_time_percent = fallback_active_counter_.Percent(kMinRunTimeMs);
if (fallback_time_percent != -1 && elapsed_ms >= kMinRunTimeMs) {
RTC_HISTOGRAMS_PERCENTAGE(
kIndex, uma_prefix_ + "Encoder.ForcedSwFallbackTimeInPercent.Vp8",
fallback_time_percent);
RTC_HISTOGRAMS_COUNTS_100(
kIndex, uma_prefix_ + "Encoder.ForcedSwFallbackChangesPerMinute.Vp8",
fallback_info_.on_off_events * 60 / (elapsed_ms / 1000));
}
}
AggregatedStats total_bytes_per_sec = total_byte_counter_.GetStats();
if (total_bytes_per_sec.num_samples > kMinRequiredPeriodicSamples) {
RTC_HISTOGRAMS_COUNTS_10000(kIndex, uma_prefix_ + "BitrateSentInKbps",
total_bytes_per_sec.average * 8 / 1000);
log_stream << uma_prefix_ << "BitrateSentInBps "
<< total_bytes_per_sec.ToStringWithMultiplier(8) << "\n";
}
AggregatedStats media_bytes_per_sec = media_byte_counter_.GetStats();
if (media_bytes_per_sec.num_samples > kMinRequiredPeriodicSamples) {
RTC_HISTOGRAMS_COUNTS_10000(kIndex, uma_prefix_ + "MediaBitrateSentInKbps",
media_bytes_per_sec.average * 8 / 1000);
log_stream << uma_prefix_ << "MediaBitrateSentInBps "
<< media_bytes_per_sec.ToStringWithMultiplier(8) << "\n";
}
AggregatedStats padding_bytes_per_sec = padding_byte_counter_.GetStats();
if (padding_bytes_per_sec.num_samples > kMinRequiredPeriodicSamples) {
RTC_HISTOGRAMS_COUNTS_10000(kIndex,
uma_prefix_ + "PaddingBitrateSentInKbps",
padding_bytes_per_sec.average * 8 / 1000);
log_stream << uma_prefix_ << "PaddingBitrateSentInBps "
<< padding_bytes_per_sec.ToStringWithMultiplier(8) << "\n";
}
AggregatedStats retransmit_bytes_per_sec =
retransmit_byte_counter_.GetStats();
if (retransmit_bytes_per_sec.num_samples > kMinRequiredPeriodicSamples) {
RTC_HISTOGRAMS_COUNTS_10000(kIndex,
uma_prefix_ + "RetransmittedBitrateSentInKbps",
retransmit_bytes_per_sec.average * 8 / 1000);
log_stream << uma_prefix_ << "RetransmittedBitrateSentInBps "
<< retransmit_bytes_per_sec.ToStringWithMultiplier(8) << "\n";
}
if (!rtp_config.rtx.ssrcs.empty()) {
AggregatedStats rtx_bytes_per_sec = rtx_byte_counter_.GetStats();
int rtx_bytes_per_sec_avg = -1;
if (rtx_bytes_per_sec.num_samples > kMinRequiredPeriodicSamples) {
rtx_bytes_per_sec_avg = rtx_bytes_per_sec.average;
log_stream << uma_prefix_ << "RtxBitrateSentInBps "
<< rtx_bytes_per_sec.ToStringWithMultiplier(8) << "\n";
} else if (total_bytes_per_sec.num_samples > kMinRequiredPeriodicSamples) {
rtx_bytes_per_sec_avg = 0; // RTX enabled but no RTX data sent, record 0.
}
if (rtx_bytes_per_sec_avg != -1) {
RTC_HISTOGRAMS_COUNTS_10000(kIndex, uma_prefix_ + "RtxBitrateSentInKbps",
rtx_bytes_per_sec_avg * 8 / 1000);
}
}
if (rtp_config.flexfec.payload_type != -1 ||
rtp_config.ulpfec.red_payload_type != -1) {
AggregatedStats fec_bytes_per_sec = fec_byte_counter_.GetStats();
if (fec_bytes_per_sec.num_samples > kMinRequiredPeriodicSamples) {
RTC_HISTOGRAMS_COUNTS_10000(kIndex, uma_prefix_ + "FecBitrateSentInKbps",
fec_bytes_per_sec.average * 8 / 1000);
log_stream << uma_prefix_ << "FecBitrateSentInBps "
<< fec_bytes_per_sec.ToStringWithMultiplier(8) << "\n";
}
}
log_stream << "Frames encoded " << current_stats.frames_encoded << "\n"
<< uma_prefix_ << "DroppedFrames.Capturer "
<< current_stats.frames_dropped_by_capturer << "\n";
RTC_HISTOGRAMS_COUNTS_1000(kIndex, uma_prefix_ + "DroppedFrames.Capturer",
current_stats.frames_dropped_by_capturer);
log_stream << uma_prefix_ << "DroppedFrames.BadTimestamp"
<< current_stats.frames_dropped_by_bad_timestamp << "\n";
RTC_HISTOGRAMS_COUNTS_1000(kIndex, uma_prefix_ + "DroppedFrames.BadTimestamp",
current_stats.frames_dropped_by_bad_timestamp);
log_stream << uma_prefix_ << "DroppedFrames.EncoderQueue "
<< current_stats.frames_dropped_by_encoder_queue << "\n";
RTC_HISTOGRAMS_COUNTS_1000(kIndex, uma_prefix_ + "DroppedFrames.EncoderQueue",
current_stats.frames_dropped_by_encoder_queue);
log_stream << uma_prefix_ << "DroppedFrames.Encoder "
<< current_stats.frames_dropped_by_encoder << "\n";
RTC_HISTOGRAMS_COUNTS_1000(kIndex, uma_prefix_ + "DroppedFrames.Encoder",
current_stats.frames_dropped_by_encoder);
log_stream << uma_prefix_ << "DroppedFrames.Ratelimiter "
<< current_stats.frames_dropped_by_rate_limiter << "\n";
RTC_HISTOGRAMS_COUNTS_1000(kIndex, uma_prefix_ + "DroppedFrames.Ratelimiter",
current_stats.frames_dropped_by_rate_limiter);
log_stream << uma_prefix_ << "DroppedFrames.CongestionWindow "
<< current_stats.frames_dropped_by_congestion_window;
RTC_LOG(LS_INFO) << log_stream.str();
}
void SendStatisticsProxy::OnEncoderReconfigured(
const VideoEncoderConfig& config,
const std::vector<VideoStream>& streams) {
// Called on VideoStreamEncoder's encoder_queue_.
MutexLock lock(&mutex_);
if (content_type_ != config.content_type) {
uma_container_->UpdateHistograms(rtp_config_, stats_);
uma_container_.reset(new UmaSamplesContainer(
GetUmaPrefix(config.content_type), stats_, clock_));
content_type_ = config.content_type;
}
uma_container_->encoded_frames_.clear();
uma_container_->num_streams_ = streams.size();
uma_container_->num_pixels_highest_stream_ =
streams.empty() ? 0 : (streams.back().width * streams.back().height);
}
void SendStatisticsProxy::OnEncodedFrameTimeMeasured(int encode_time_ms,
int encode_usage_percent) {
RTC_DCHECK_GE(encode_time_ms, 0);
MutexLock lock(&mutex_);
uma_container_->encode_time_counter_.Add(encode_time_ms);
encode_time_.Apply(1.0f, encode_time_ms);
stats_.avg_encode_time_ms = std::round(encode_time_.filtered());
stats_.total_encode_time_ms += encode_time_ms;
stats_.encode_usage_percent = encode_usage_percent;
}
void SendStatisticsProxy::OnSuspendChange(bool is_suspended) {
int64_t now_ms = clock_->TimeInMilliseconds();
MutexLock lock(&mutex_);
stats_.suspended = is_suspended;
if (is_suspended) {
// Pause framerate (add min pause time since there may be frames/packets
// that are not yet sent).
const int64_t kMinMs = 500;
uma_container_->input_fps_counter_.ProcessAndPauseForDuration(kMinMs);
uma_container_->sent_fps_counter_.ProcessAndPauseForDuration(kMinMs);
// Pause bitrate stats.
uma_container_->total_byte_counter_.ProcessAndPauseForDuration(kMinMs);
uma_container_->media_byte_counter_.ProcessAndPauseForDuration(kMinMs);
uma_container_->rtx_byte_counter_.ProcessAndPauseForDuration(kMinMs);
uma_container_->padding_byte_counter_.ProcessAndPauseForDuration(kMinMs);
uma_container_->retransmit_byte_counter_.ProcessAndPauseForDuration(kMinMs);
uma_container_->fec_byte_counter_.ProcessAndPauseForDuration(kMinMs);
// Stop adaptation stats.
uma_container_->cpu_adapt_timer_.Stop(now_ms);
uma_container_->quality_adapt_timer_.Stop(now_ms);
} else {
// Start adaptation stats if scaling is enabled.
if (adaptation_limitations_.MaskedCpuCounts()
.resolution_adaptations.has_value())
uma_container_->cpu_adapt_timer_.Start(now_ms);
if (adaptation_limitations_.MaskedQualityCounts()
.resolution_adaptations.has_value())
uma_container_->quality_adapt_timer_.Start(now_ms);
// Stop pause explicitly for stats that may be zero/not updated for some
// time.
uma_container_->rtx_byte_counter_.ProcessAndStopPause();
uma_container_->padding_byte_counter_.ProcessAndStopPause();
uma_container_->retransmit_byte_counter_.ProcessAndStopPause();
uma_container_->fec_byte_counter_.ProcessAndStopPause();
}
}
VideoSendStream::Stats SendStatisticsProxy::GetStats() {
MutexLock lock(&mutex_);
PurgeOldStats();
stats_.input_frame_rate =
uma_container_->input_frame_rate_tracker_.ComputeRate();
stats_.frames = uma_container_->input_frame_rate_tracker_.TotalSampleCount();
stats_.content_type =
content_type_ == VideoEncoderConfig::ContentType::kRealtimeVideo
? VideoContentType::UNSPECIFIED
: VideoContentType::SCREENSHARE;
stats_.encode_frame_rate = round(encoded_frame_rate_tracker_.ComputeRate());
stats_.media_bitrate_bps = media_byte_rate_tracker_.ComputeRate() * 8;
stats_.quality_limitation_durations_ms =
quality_limitation_reason_tracker_.DurationsMs();
for (auto& [ssrc, substream] : stats_.substreams) {
if (auto it = trackers_.find(ssrc); it != trackers_.end()) {
substream.encode_frame_rate = it->second.encoded_frame_rate.ComputeRate();
}
}
return stats_;
}
void SendStatisticsProxy::PurgeOldStats() {
Timestamp now = clock_->CurrentTime();
for (auto& [ssrc, substream] : stats_.substreams) {
if (now - trackers_[ssrc].resolution_update >= kStatsTimeout) {
substream.width = 0;
substream.height = 0;
}
}
}
VideoSendStream::StreamStats* SendStatisticsProxy::GetStatsEntry(
uint32_t ssrc) {
std::map<uint32_t, VideoSendStream::StreamStats>::iterator it =
stats_.substreams.find(ssrc);
if (it != stats_.substreams.end())
return &it->second;
bool is_media = rtp_config_.IsMediaSsrc(ssrc);
bool is_flexfec = rtp_config_.flexfec.payload_type != -1 &&
ssrc == rtp_config_.flexfec.ssrc;
bool is_rtx = rtp_config_.IsRtxSsrc(ssrc);
if (!is_media && !is_flexfec && !is_rtx)
return nullptr;
// Insert new entry and return ptr.
VideoSendStream::StreamStats* entry = &stats_.substreams[ssrc];
if (is_media) {
entry->type = VideoSendStream::StreamStats::StreamType::kMedia;
} else if (is_rtx) {
entry->type = VideoSendStream::StreamStats::StreamType::kRtx;
} else if (is_flexfec) {
entry->type = VideoSendStream::StreamStats::StreamType::kFlexfec;
} else {
RTC_DCHECK_NOTREACHED();
}
switch (entry->type) {
case VideoSendStream::StreamStats::StreamType::kMedia:
break;
case VideoSendStream::StreamStats::StreamType::kRtx:
entry->referenced_media_ssrc =
rtp_config_.GetMediaSsrcAssociatedWithRtxSsrc(ssrc);
break;
case VideoSendStream::StreamStats::StreamType::kFlexfec:
entry->referenced_media_ssrc =
rtp_config_.GetMediaSsrcAssociatedWithFlexfecSsrc(ssrc);
break;
}
return entry;
}
void SendStatisticsProxy::OnInactiveSsrc(uint32_t ssrc) {
MutexLock lock(&mutex_);
VideoSendStream::StreamStats* stats = GetStatsEntry(ssrc);
if (!stats)
return;
stats->total_bitrate_bps = 0;
stats->retransmit_bitrate_bps = 0;
stats->height = 0;
stats->width = 0;
}
void SendStatisticsProxy::OnSetEncoderTargetRate(uint32_t bitrate_bps) {
MutexLock lock(&mutex_);
if (uma_container_->target_rate_updates_.last_ms == -1 && bitrate_bps == 0)
return; // Start on first non-zero bitrate, may initially be zero.
int64_t now = clock_->TimeInMilliseconds();
if (uma_container_->target_rate_updates_.last_ms != -1) {
bool was_paused = stats_.target_media_bitrate_bps == 0;
int64_t diff_ms = now - uma_container_->target_rate_updates_.last_ms;
uma_container_->paused_time_counter_.Add(was_paused, diff_ms);
// Use last to not include update when stream is stopped and video disabled.
if (uma_container_->target_rate_updates_.last_paused_or_resumed)
++uma_container_->target_rate_updates_.pause_resume_events;
// Check if video is paused/resumed.
uma_container_->target_rate_updates_.last_paused_or_resumed =
(bitrate_bps == 0) != was_paused;
}
uma_container_->target_rate_updates_.last_ms = now;
stats_.target_media_bitrate_bps = bitrate_bps;
}
void SendStatisticsProxy::UpdateEncoderFallbackStats(
const CodecSpecificInfo* codec_info,
int pixels,
int simulcast_index) {
UpdateFallbackDisabledStats(codec_info, pixels, simulcast_index);
if (!fallback_max_pixels_ || !uma_container_->fallback_info_.is_possible) {
return;
}
if (!IsForcedFallbackPossible(codec_info, simulcast_index)) {
uma_container_->fallback_info_.is_possible = false;
return;
}
FallbackEncoderInfo* fallback_info = &uma_container_->fallback_info_;
const int64_t now_ms = clock_->TimeInMilliseconds();
bool is_active = fallback_info->is_active;
if (encoder_changed_) {
// Implementation changed.
const bool last_was_vp8_software =
encoder_changed_->previous_encoder_implementation == kVp8SwCodecName;
is_active = encoder_changed_->new_encoder_implementation == kVp8SwCodecName;
encoder_changed_.reset();
if (!is_active && !last_was_vp8_software) {
// First or not a VP8 SW change, update stats on next call.
return;
}
if (is_active && (pixels > *fallback_max_pixels_)) {
// Pixels should not be above `fallback_max_pixels_`. If above skip to
// avoid fallbacks due to failure.
fallback_info->is_possible = false;
return;
}
stats_.has_entered_low_resolution = true;
++fallback_info->on_off_events;
}
if (fallback_info->last_update_ms) {
int64_t diff_ms = now_ms - *(fallback_info->last_update_ms);
// If the time diff since last update is greater than `max_frame_diff_ms`,
// video is considered paused/muted and the change is not included.
if (diff_ms < fallback_info->max_frame_diff_ms) {
uma_container_->fallback_active_counter_.Add(fallback_info->is_active,
diff_ms);
fallback_info->elapsed_ms += diff_ms;
}
}
fallback_info->is_active = is_active;
fallback_info->last_update_ms.emplace(now_ms);
}
void SendStatisticsProxy::UpdateFallbackDisabledStats(
const CodecSpecificInfo* codec_info,
int pixels,
int simulcast_index) {
if (!fallback_max_pixels_disabled_ ||
!uma_container_->fallback_info_disabled_.is_possible ||
stats_.has_entered_low_resolution) {
return;
}
if (!IsForcedFallbackPossible(codec_info, simulcast_index) ||
stats_.encoder_implementation_name == kVp8SwCodecName) {
uma_container_->fallback_info_disabled_.is_possible = false;
return;
}
if (pixels <= *fallback_max_pixels_disabled_ ||
uma_container_->fallback_info_disabled_.min_pixel_limit_reached) {
stats_.has_entered_low_resolution = true;
}
}
void SendStatisticsProxy::OnMinPixelLimitReached() {
MutexLock lock(&mutex_);
uma_container_->fallback_info_disabled_.min_pixel_limit_reached = true;
}
void SendStatisticsProxy::OnSendEncodedImage(
const EncodedImage& encoded_image,
const CodecSpecificInfo* codec_info) {
int simulcast_idx = encoded_image.SimulcastIndex().value_or(0);
MutexLock lock(&mutex_);
++stats_.frames_encoded;
// The current encode frame rate is based on previously encoded frames.
double encode_frame_rate = encoded_frame_rate_tracker_.ComputeRate();
// We assume that less than 1 FPS is not a trustworthy estimate - perhaps we
// just started encoding for the first time or after a pause. Assuming frame
// rate is at least 1 FPS is conservative to avoid too large increments.
if (encode_frame_rate < 1.0)
encode_frame_rate = 1.0;
double target_frame_size_bytes =
stats_.target_media_bitrate_bps / (8.0 * encode_frame_rate);
// `stats_.target_media_bitrate_bps` is set in
// SendStatisticsProxy::OnSetEncoderTargetRate.
stats_.total_encoded_bytes_target += round(target_frame_size_bytes);
if (codec_info) {
UpdateEncoderFallbackStats(
codec_info, encoded_image._encodedWidth * encoded_image._encodedHeight,
simulcast_idx);
}
if (static_cast<size_t>(simulcast_idx) >= rtp_config_.ssrcs.size()) {
RTC_LOG(LS_ERROR) << "Encoded image outside simulcast range ("
<< simulcast_idx << " >= " << rtp_config_.ssrcs.size()
<< ").";
return;
}
uint32_t ssrc = rtp_config_.ssrcs[simulcast_idx];
VideoSendStream::StreamStats* stats = GetStatsEntry(ssrc);
if (!stats)
return;
Trackers& track = trackers_[ssrc];
stats->frames_encoded++;
stats->total_encode_time_ms += encoded_image.timing_.encode_finish_ms -
encoded_image.timing_.encode_start_ms;
stats->scalability_mode =
codec_info ? codec_info->scalability_mode : std::nullopt;
// Report resolution of the top spatial layer.
bool is_top_spatial_layer =
codec_info == nullptr || codec_info->end_of_picture;
if (!stats->width || !stats->height || is_top_spatial_layer) {
stats->width = encoded_image._encodedWidth;
stats->height = encoded_image._encodedHeight;
track.resolution_update = clock_->CurrentTime();
}
uma_container_->key_frame_counter_.Add(encoded_image._frameType ==
VideoFrameType::kVideoFrameKey);
if (encoded_image.qp_ != -1) {
if (!stats->qp_sum)
stats->qp_sum = 0;
*stats->qp_sum += encoded_image.qp_;
if (codec_info) {
if (codec_info->codecType == kVideoCodecVP8) {
int spatial_idx = (rtp_config_.ssrcs.size() == 1) ? -1 : simulcast_idx;
uma_container_->qp_counters_[spatial_idx].vp8.Add(encoded_image.qp_);
} else if (codec_info->codecType == kVideoCodecVP9) {
// We could either have simulcast layers or spatial layers.
// TODO(https://crbug.com/webrtc/14891): When its possible to mix
// simulcast and SVC we'll also need to consider what, if anything, to
// report in a "simulcast of SVC streams" setup.
int stream_idx = encoded_image.SpatialIndex().value_or(
encoded_image.SimulcastIndex().value_or(-1));
uma_container_->qp_counters_[stream_idx].vp9.Add(encoded_image.qp_);
} else if (codec_info->codecType == kVideoCodecH264) {
int spatial_idx = (rtp_config_.ssrcs.size() == 1) ? -1 : simulcast_idx;
uma_container_->qp_counters_[spatial_idx].h264.Add(encoded_image.qp_);
}
}
}
// If any of the simulcast streams have a huge frame, it should be counted
// as a single difficult input frame.
// https://w3c.github.io/webrtc-stats/#dom-rtcvideosenderstats-hugeframessent
if (encoded_image.timing_.flags & VideoSendTiming::kTriggeredBySize) {
++stats->huge_frames_sent;
if (!last_outlier_timestamp_ ||
*last_outlier_timestamp_ < encoded_image.capture_time_ms_) {
last_outlier_timestamp_.emplace(encoded_image.capture_time_ms_);
++stats_.huge_frames_sent;
}
}
media_byte_rate_tracker_.AddSamples(encoded_image.size());
if (uma_container_->InsertEncodedFrame(encoded_image, simulcast_idx)) {
// First frame seen with this timestamp, track overall fps.
encoded_frame_rate_tracker_.AddSamples(1);
}
// is_top_spatial_layer pertains only to SVC, will always be true for
// simulcast.
if (is_top_spatial_layer) {
track.encoded_frame_rate.AddSamples(1);
}
std::optional<int> downscales =
adaptation_limitations_.MaskedQualityCounts().resolution_adaptations;
stats_.bw_limited_resolution |=
(downscales.has_value() && downscales.value() > 0);
if (downscales.has_value()) {
uma_container_->quality_limited_frame_counter_.Add(downscales.value() > 0);
if (downscales.value() > 0)
uma_container_->quality_downscales_counter_.Add(downscales.value());
}
}
void SendStatisticsProxy::OnEncoderImplementationChanged(
EncoderImplementation implementation) {
MutexLock lock(&mutex_);
encoder_changed_ =
EncoderChangeEvent{stats_.encoder_implementation_name.value_or("unknown"),
implementation.name};
stats_.encoder_implementation_name = implementation.name;
stats_.power_efficient_encoder = implementation.is_hardware_accelerated;
// Clear cached scalability mode values, they may no longer be accurate.
for (auto& pair : stats_.substreams) {
VideoSendStream::StreamStats& stream_stats = pair.second;
stream_stats.scalability_mode = std::nullopt;
}
}
int SendStatisticsProxy::GetInputFrameRate() const {
MutexLock lock(&mutex_);
return round(uma_container_->input_frame_rate_tracker_.ComputeRate());
}
int SendStatisticsProxy::GetSendFrameRate() const {
MutexLock lock(&mutex_);
return round(encoded_frame_rate_tracker_.ComputeRate());
}
void SendStatisticsProxy::OnIncomingFrame(int width, int height) {
MutexLock lock(&mutex_);
uma_container_->input_frame_rate_tracker_.AddSamples(1);
uma_container_->input_fps_counter_.Add(1);
uma_container_->input_width_counter_.Add(width);
uma_container_->input_height_counter_.Add(height);
if (adaptation_limitations_.MaskedCpuCounts()
.resolution_adaptations.has_value()) {
uma_container_->cpu_limited_frame_counter_.Add(
stats_.cpu_limited_resolution);
}
if (encoded_frame_rate_tracker_.TotalSampleCount() == 0) {
// Set start time now instead of when first key frame is encoded to avoid a
// too high initial estimate.
encoded_frame_rate_tracker_.AddSamples(0);
}
}
void SendStatisticsProxy::OnFrameDropped(DropReason reason) {
MutexLock lock(&mutex_);
switch (reason) {
case DropReason::kSource:
++stats_.frames_dropped_by_capturer;
break;
case DropReason::kBadTimestamp:
++stats_.frames_dropped_by_bad_timestamp;
break;
case DropReason::kEncoderQueue:
++stats_.frames_dropped_by_encoder_queue;
break;
case DropReason::kEncoder:
++stats_.frames_dropped_by_encoder;
break;
case DropReason::kMediaOptimization:
++stats_.frames_dropped_by_rate_limiter;
break;
case DropReason::kCongestionWindow:
++stats_.frames_dropped_by_congestion_window;
break;
}
}
void SendStatisticsProxy::ClearAdaptationStats() {
MutexLock lock(&mutex_);
adaptation_limitations_.set_cpu_counts(VideoAdaptationCounters());
adaptation_limitations_.set_quality_counts(VideoAdaptationCounters());
UpdateAdaptationStats();
}
void SendStatisticsProxy::UpdateAdaptationSettings(
VideoStreamEncoderObserver::AdaptationSettings cpu_settings,
VideoStreamEncoderObserver::AdaptationSettings quality_settings) {
MutexLock lock(&mutex_);
adaptation_limitations_.UpdateMaskingSettings(cpu_settings, quality_settings);
SetAdaptTimer(adaptation_limitations_.MaskedCpuCounts(),
&uma_container_->cpu_adapt_timer_);
SetAdaptTimer(adaptation_limitations_.MaskedQualityCounts(),
&uma_container_->quality_adapt_timer_);
UpdateAdaptationStats();
}
void SendStatisticsProxy::OnAdaptationChanged(
VideoAdaptationReason reason,
const VideoAdaptationCounters& cpu_counters,
const VideoAdaptationCounters& quality_counters) {
MutexLock lock(&mutex_);
MaskedAdaptationCounts receiver =
adaptation_limitations_.MaskedQualityCounts();
adaptation_limitations_.set_cpu_counts(cpu_counters);
adaptation_limitations_.set_quality_counts(quality_counters);
switch (reason) {
case VideoAdaptationReason::kCpu:
++stats_.number_of_cpu_adapt_changes;
break;
case VideoAdaptationReason::kQuality:
TryUpdateInitialQualityResolutionAdaptUp(
receiver.resolution_adaptations,
adaptation_limitations_.MaskedQualityCounts().resolution_adaptations);
++stats_.number_of_quality_adapt_changes;
break;
}
UpdateAdaptationStats();
}
void SendStatisticsProxy::UpdateAdaptationStats() {
auto cpu_counts = adaptation_limitations_.MaskedCpuCounts();
auto quality_counts = adaptation_limitations_.MaskedQualityCounts();
bool is_cpu_limited = cpu_counts.resolution_adaptations > 0 ||
cpu_counts.num_framerate_reductions > 0;
bool is_bandwidth_limited = quality_counts.resolution_adaptations > 0 ||
quality_counts.num_framerate_reductions > 0 ||
bw_limited_layers_ || internal_encoder_scaler_;
if (is_bandwidth_limited) {
// We may be both CPU limited and bandwidth limited at the same time but
// there is no way to express this in standardized stats. Heuristically,
// bandwidth is more likely to be a limiting factor than CPU, and more
// likely to vary over time, so only when we aren't bandwidth limited do we
// want to know about our CPU being the bottleneck.
quality_limitation_reason_tracker_.SetReason(
QualityLimitationReason::kBandwidth);
} else if (is_cpu_limited) {
quality_limitation_reason_tracker_.SetReason(QualityLimitationReason::kCpu);
} else {
quality_limitation_reason_tracker_.SetReason(
QualityLimitationReason::kNone);
}
stats_.cpu_limited_resolution = cpu_counts.resolution_adaptations > 0;
stats_.cpu_limited_framerate = cpu_counts.num_framerate_reductions > 0;
stats_.bw_limited_resolution = quality_counts.resolution_adaptations > 0;
stats_.bw_limited_framerate = quality_counts.num_framerate_reductions > 0;
// If bitrate allocator has disabled some layers frame-rate or resolution are
// limited depending on the encoder configuration.
if (bw_limited_layers_) {
switch (content_type_) {
case VideoEncoderConfig::ContentType::kRealtimeVideo: {
stats_.bw_limited_resolution = true;
break;
}
case VideoEncoderConfig::ContentType::kScreen: {
stats_.bw_limited_framerate = true;
break;
}
}
}
if (internal_encoder_scaler_) {
stats_.bw_limited_resolution = true;
}
stats_.quality_limitation_reason =
quality_limitation_reason_tracker_.current_reason();
// `stats_.quality_limitation_durations_ms` depends on the current time
// when it is polled; it is updated in SendStatisticsProxy::GetStats().
}
void SendStatisticsProxy::OnBitrateAllocationUpdated(
const VideoCodec& codec,
const VideoBitrateAllocation& allocation) {
int num_spatial_layers = 0;
for (int i = 0; i < kMaxSpatialLayers; i++) {
if (codec.spatialLayers[i].active) {
num_spatial_layers++;
}
}
int num_simulcast_streams = 0;
for (int i = 0; i < kMaxSimulcastStreams; i++) {
if (codec.simulcastStream[i].active) {
num_simulcast_streams++;
}
}
std::array<bool, kMaxSpatialLayers> spatial_layers;
for (int i = 0; i < kMaxSpatialLayers; i++) {
spatial_layers[i] = (allocation.GetSpatialLayerSum(i) > 0);
}
MutexLock lock(&mutex_);
bw_limited_layers_ = allocation.is_bw_limited();
UpdateAdaptationStats();
// Store target bitrates per substream stats.
for (auto& [ssrc, substream] : stats_.substreams) {
std::optional<size_t> simulcast_index;
for (size_t i = 0; i < rtp_config_.ssrcs.size(); ++i) {
if (rtp_config_.ssrcs[i] == ssrc) {
simulcast_index = i;
break;
}
}
if (!simulcast_index.has_value()) {
substream.target_bitrate = std::nullopt;
continue;
}
substream.target_bitrate =
DataRate::BitsPerSec(allocation.GetSpatialLayerSum(*simulcast_index));
if (substream.target_bitrate == DataRate::Zero()) {
substream.target_bitrate = std::nullopt;
}
}
if (spatial_layers != last_spatial_layer_use_) {
// If the number of spatial layers has changed, the resolution change is
// not due to quality limitations, it is because the configuration
// changed.
if (last_num_spatial_layers_ == num_spatial_layers &&
last_num_simulcast_streams_ == num_simulcast_streams) {
++stats_.quality_limitation_resolution_changes;
}
last_spatial_layer_use_ = spatial_layers;
}
last_num_spatial_layers_ = num_spatial_layers;
last_num_simulcast_streams_ = num_simulcast_streams;
}
// Informes observer if an internal encoder scaler has reduced video
// resolution or not. `is_scaled` is a flag indicating if the video is scaled
// down.
void SendStatisticsProxy::OnEncoderInternalScalerUpdate(bool is_scaled) {
MutexLock lock(&mutex_);
internal_encoder_scaler_ = is_scaled;
UpdateAdaptationStats();
}
// TODO(asapersson): Include fps changes.
void SendStatisticsProxy::OnInitialQualityResolutionAdaptDown() {
MutexLock lock(&mutex_);
++uma_container_->initial_quality_changes_.down;
}
void SendStatisticsProxy::TryUpdateInitialQualityResolutionAdaptUp(
std::optional<int> old_quality_downscales,
std::optional<int> updated_quality_downscales) {
if (uma_container_->initial_quality_changes_.down == 0)
return;
if (old_quality_downscales.has_value() &&
old_quality_downscales.value() > 0 &&
updated_quality_downscales.value_or(-1) <
old_quality_downscales.value()) {
// Adapting up in quality.
if (uma_container_->initial_quality_changes_.down >
uma_container_->initial_quality_changes_.up) {
++uma_container_->initial_quality_changes_.up;
}
}
}
void SendStatisticsProxy::SetAdaptTimer(const MaskedAdaptationCounts& counts,
StatsTimer* timer) {
if (counts.resolution_adaptations || counts.num_framerate_reductions) {
// Adaptation enabled.
if (!stats_.suspended)
timer->Start(clock_->TimeInMilliseconds());
return;
}
timer->Stop(clock_->TimeInMilliseconds());
}
void SendStatisticsProxy::RtcpPacketTypesCounterUpdated(
uint32_t ssrc,
const RtcpPacketTypeCounter& packet_counter) {
MutexLock lock(&mutex_);
VideoSendStream::StreamStats* stats = GetStatsEntry(ssrc);
if (!stats)
return;
stats->rtcp_packet_type_counts = packet_counter;
if (uma_container_->first_rtcp_stats_time_ms_ == -1)
uma_container_->first_rtcp_stats_time_ms_ = clock_->TimeInMilliseconds();
}
void SendStatisticsProxy::OnReportBlockDataUpdated(
ReportBlockData report_block) {
MutexLock lock(&mutex_);
VideoSendStream::StreamStats* stats =
GetStatsEntry(report_block.source_ssrc());
if (!stats)
return;
uma_container_->report_block_stats_.Store(
/*ssrc=*/report_block.source_ssrc(),
/*packets_lost=*/report_block.cumulative_lost(),
/*extended_highest_sequence_number=*/
report_block.extended_highest_sequence_number());
stats->report_block_data = std::move(report_block);
}
void SendStatisticsProxy::DataCountersUpdated(
const StreamDataCounters& counters,
uint32_t ssrc) {
MutexLock lock(&mutex_);
VideoSendStream::StreamStats* stats = GetStatsEntry(ssrc);
RTC_DCHECK(stats) << "DataCountersUpdated reported for unknown ssrc " << ssrc;
if (stats->type == VideoSendStream::StreamStats::StreamType::kFlexfec) {
// The same counters are reported for both the media ssrc and flexfec ssrc.
// Bitrate stats are summed for all SSRCs. Use fec stats from media update.
return;
}
stats->rtp_stats = counters;
if (uma_container_->first_rtp_stats_time_ms_ == -1) {
int64_t now_ms = clock_->TimeInMilliseconds();
uma_container_->first_rtp_stats_time_ms_ = now_ms;
uma_container_->cpu_adapt_timer_.Restart(now_ms);
uma_container_->quality_adapt_timer_.Restart(now_ms);
}
uma_container_->total_byte_counter_.Set(counters.transmitted.TotalBytes(),
ssrc);
uma_container_->padding_byte_counter_.Set(counters.transmitted.padding_bytes,
ssrc);
uma_container_->retransmit_byte_counter_.Set(
counters.retransmitted.TotalBytes(), ssrc);
uma_container_->fec_byte_counter_.Set(counters.fec.TotalBytes(), ssrc);
switch (stats->type) {
case VideoSendStream::StreamStats::StreamType::kMedia:
uma_container_->media_byte_counter_.Set(counters.MediaPayloadBytes(),
ssrc);
break;
case VideoSendStream::StreamStats::StreamType::kRtx:
uma_container_->rtx_byte_counter_.Set(counters.transmitted.TotalBytes(),
ssrc);
break;
case VideoSendStream::StreamStats::StreamType::kFlexfec:
break;
}
}
void SendStatisticsProxy::Notify(uint32_t total_bitrate_bps,
uint32_t retransmit_bitrate_bps,
uint32_t ssrc) {
MutexLock lock(&mutex_);
VideoSendStream::StreamStats* stats = GetStatsEntry(ssrc);
if (!stats)
return;
stats->total_bitrate_bps = total_bitrate_bps;
stats->retransmit_bitrate_bps = retransmit_bitrate_bps;
}
void SendStatisticsProxy::FrameCountUpdated(const FrameCounts& frame_counts,
uint32_t ssrc) {
MutexLock lock(&mutex_);
VideoSendStream::StreamStats* stats = GetStatsEntry(ssrc);
if (!stats)
return;
stats->frame_counts = frame_counts;
}
void SendStatisticsProxy::Trackers::AddSendDelay(Timestamp now,
TimeDelta send_delay) {
// Add the new measurement.
send_delays.push_back({.when = now, .send_delay = send_delay});
send_delay_sum += send_delay;
if (send_delay_max == nullptr || *send_delay_max <= send_delay) {
send_delay_max = &send_delays.back().send_delay;
}
// Remove old. No need to check for emptiness because newly added entry would
// never be too old.
while (now - send_delays.front().when > TimeDelta::Seconds(1)) {
send_delay_sum -= send_delays.front().send_delay;
if (send_delay_max == &send_delays.front().send_delay) {
send_delay_max = nullptr;
}
send_delays.pop_front();
}
// Check if max value was pushed out from the queue as too old.
if (send_delay_max == nullptr) {
send_delay_max = &send_delays.front().send_delay;
for (const SendDelayEntry& entry : send_delays) {
// Use '>=' rather than '>' to prefer latest maximum as it would be pushed
// out later and thus trigger less recalculations.
if (entry.send_delay >= *send_delay_max) {
send_delay_max = &entry.send_delay;
}
}
}
}
void SendStatisticsProxy::OnSendPacket(uint32_t ssrc, Timestamp capture_time) {
Timestamp now = clock_->CurrentTime();
MutexLock lock(&mutex_);
VideoSendStream::StreamStats* stats = GetStatsEntry(ssrc);
if (!stats)
return;
Trackers& track = trackers_[ssrc];
track.AddSendDelay(now, now - capture_time);
int64_t avg_delay_ms = (track.send_delay_sum / track.send_delays.size()).ms();
int64_t max_delay_ms = track.send_delay_max->ms();
stats->avg_delay_ms = avg_delay_ms;
stats->max_delay_ms = max_delay_ms;
uma_container_->delay_counter_.Add(avg_delay_ms);
uma_container_->max_delay_counter_.Add(max_delay_ms);
}
void SendStatisticsProxy::StatsTimer::Start(int64_t now_ms) {
if (start_ms == -1)
start_ms = now_ms;
}
void SendStatisticsProxy::StatsTimer::Stop(int64_t now_ms) {
if (start_ms != -1) {
total_ms += now_ms - start_ms;
start_ms = -1;
}
}
void SendStatisticsProxy::StatsTimer::Restart(int64_t now_ms) {
total_ms = 0;
if (start_ms != -1)
start_ms = now_ms;
}
void SendStatisticsProxy::SampleCounter::Add(int sample) {
sum += sample;
++num_samples;
}
int SendStatisticsProxy::SampleCounter::Avg(
int64_t min_required_samples) const {
if (num_samples < min_required_samples || num_samples == 0)
return -1;
return static_cast<int>((sum + (num_samples / 2)) / num_samples);
}
void SendStatisticsProxy::BoolSampleCounter::Add(bool sample) {
if (sample)
++sum;
++num_samples;
}
void SendStatisticsProxy::BoolSampleCounter::Add(bool sample, int64_t count) {
if (sample)
sum += count;
num_samples += count;
}
int SendStatisticsProxy::BoolSampleCounter::Percent(
int64_t min_required_samples) const {
return Fraction(min_required_samples, 100.0f);
}
int SendStatisticsProxy::BoolSampleCounter::Permille(
int64_t min_required_samples) const {
return Fraction(min_required_samples, 1000.0f);
}
int SendStatisticsProxy::BoolSampleCounter::Fraction(
int64_t min_required_samples,
float multiplier) const {
if (num_samples < min_required_samples || num_samples == 0)
return -1;
return static_cast<int>((sum * multiplier / num_samples) + 0.5f);
}
SendStatisticsProxy::MaskedAdaptationCounts
SendStatisticsProxy::Adaptations::MaskedCpuCounts() const {
return Mask(cpu_counts_, cpu_settings_);
}
SendStatisticsProxy::MaskedAdaptationCounts
SendStatisticsProxy::Adaptations::MaskedQualityCounts() const {
return Mask(quality_counts_, quality_settings_);
}
void SendStatisticsProxy::Adaptations::set_cpu_counts(
const VideoAdaptationCounters& cpu_counts) {
cpu_counts_ = cpu_counts;
}
void SendStatisticsProxy::Adaptations::set_quality_counts(
const VideoAdaptationCounters& quality_counts) {
quality_counts_ = quality_counts;
}
VideoAdaptationCounters SendStatisticsProxy::Adaptations::cpu_counts() const {
return cpu_counts_;
}
VideoAdaptationCounters SendStatisticsProxy::Adaptations::quality_counts()
const {
return quality_counts_;
}
void SendStatisticsProxy::Adaptations::UpdateMaskingSettings(
VideoStreamEncoderObserver::AdaptationSettings cpu_settings,
VideoStreamEncoderObserver::AdaptationSettings quality_settings) {
cpu_settings_ = std::move(cpu_settings);
quality_settings_ = std::move(quality_settings);
}
SendStatisticsProxy::MaskedAdaptationCounts
SendStatisticsProxy::Adaptations::Mask(
const VideoAdaptationCounters& counters,
const VideoStreamEncoderObserver::AdaptationSettings& settings) const {
MaskedAdaptationCounts masked_counts;
if (settings.resolution_scaling_enabled) {
masked_counts.resolution_adaptations = counters.resolution_adaptations;
}
if (settings.framerate_scaling_enabled) {
masked_counts.num_framerate_reductions = counters.fps_adaptations;
}
return masked_counts;
}
} // namespace webrtc
Reference in New Issue View Git Blame Copy Permalink