zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
a15_larch
platform-external-webrtc/video/send_statistics_proxy.cc
Henrik Boström d81992197c [Stats] Update totalPacketSendDelay to only cover time in pacer queue. 
This metric was always supposed to be the spec's answer to
googBucketDelay, and is defined as "The total number of seconds that
packets have spent buffered locally before being transmitted onto the
network." But our implementation measured the time between capture and
send, including encode time. This is incorrect and yields a much larger
value than expected.

This CL updated the metric to do what the spec says. Implementation-wise
we measure the time between pushing and popping each packet from the
queue (in modules/pacing/prioritized_packet_queue.cc).

The spec says to increment the delay counter at the same time as we
increment the packet counter in order for the app to be able to do
"delta totalPacketSendDelay / delta packetSent". For this reason,
`total_packet_delay` is added to RtpPacketCounter. (Previously, the
two counters were incremented on different threads and observers.)

Running Google Meet on a good network, I could observe a 2-3 ms average
send delay per packet with this implementation compared to 20-30 ms
with the old implementation. See b/137014977#comment170 for comparison
with googBucketDelay which is a little bit different by design -
totalPacketSendDelay is clearly better than googBucketDelay.

Since none of this depend on the media kind, we can wire up this metric
for audio as well in a follow-up:
https://webrtc-review.googlesource.com/c/src/+/280523

Bug: webrtc:14593
Change-Id: If8fcd82fee74030d0923ee5df2c2aea2264600d4
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/280443
Reviewed-by: Erik Språng <sprang@webrtc.org>
Commit-Queue: Henrik Boström <hbos@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#38480}
2022-10-26 21:29:20 +00:00

1511 lines
58 KiB
C++
Raw Permalink 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,
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;
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);
}
absl::optional<int> GetFallbackMaxPixels(const std::string& group) {
if (group.empty())
return absl::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 absl::optional<int>();
}
if (min_pixels <= 0 || max_pixels <= 0 || max_pixels < min_pixels)
return absl::optional<int>();
return absl::optional<int>(max_pixels);
}
absl::optional<int> GetFallbackMaxPixelsIfFieldTrialEnabled(
const webrtc::FieldTrialsView& field_trials) {
std::string group = field_trials.Lookup(kVp8ForcedFallbackEncoderFieldTrial);
return (absl::StartsWith(group, "Enabled"))
? GetFallbackMaxPixels(group.substr(7))
: absl::optional<int>();
}
absl::optional<int> GetFallbackMaxPixelsIfFieldTrialDisabled(
const webrtc::FieldTrialsView& field_trials) {
std::string group = field_trials.Lookup(kVp8ForcedFallbackEncoderFieldTrial);
return (absl::StartsWith(group, "Disabled"))
? GetFallbackMaxPixels(group.substr(8))
: absl::optional<int>();
}
} // namespace
const int SendStatisticsProxy::kStatsTimeoutMs = 5000;
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::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.Timestamp()) >
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.Timestamp());
if (it == encoded_frames_.end()) {
// First frame with this timestamp.
encoded_frames_.insert(
std::make_pair(encoded_frame.Timestamp(),
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.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& substream : stats_.substreams) {
uint32_t ssrc = substream.first;
if (encoded_frame_rate_trackers_.count(ssrc) > 0) {
substream.second.encode_frame_rate =
encoded_frame_rate_trackers_[ssrc]->ComputeRate();
}
}
return stats_;
}
void SendStatisticsProxy::PurgeOldStats() {
int64_t old_stats_ms = clock_->TimeInMilliseconds() - kStatsTimeoutMs;
for (std::map<uint32_t, VideoSendStream::StreamStats>::iterator it =
stats_.substreams.begin();
it != stats_.substreams.end(); ++it) {
uint32_t ssrc = it->first;
if (update_times_[ssrc].resolution_update_ms <= old_stats_ms) {
it->second.width = 0;
it->second.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) {
// Simulcast is used for VP8, H264 and Generic.
int simulcast_idx =
(codec_info && (codec_info->codecType == kVideoCodecVP8 ||
codec_info->codecType == kVideoCodecH264 ||
codec_info->codecType == kVideoCodecGeneric))
? encoded_image.SpatialIndex().value_or(0)
: 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;
if (encoded_frame_rate_trackers_.count(ssrc) == 0) {
encoded_frame_rate_trackers_[ssrc] =
std::make_unique<rtc::RateTracker>(kBucketSizeMs, kBucketCount);
}
stats->frames_encoded++;
stats->total_encode_time_ms += encoded_image.timing_.encode_finish_ms -
encoded_image.timing_.encode_start_ms;
// 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;
update_times_[ssrc].resolution_update_ms = clock_->TimeInMilliseconds();
}
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) {
int spatial_idx = encoded_image.SpatialIndex().value_or(-1);
uma_container_->qp_counters_[spatial_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)
encoded_frame_rate_trackers_[ssrc]->AddSamples(1);
absl::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,
implementation.name};
stats_.encoder_implementation_name = implementation.name;
stats_.power_efficient_encoder = implementation.is_hardware_accelerated;
}
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::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();
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(
absl::optional<int> old_quality_downscales,
absl::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_data) {
MutexLock lock(&mutex_);
VideoSendStream::StreamStats* stats =
GetStatsEntry(report_block_data.report_block().source_ssrc);
if (!stats)
return;
const RTCPReportBlock& report_block = report_block_data.report_block();
uma_container_->report_block_stats_.Store(
/*ssrc=*/report_block.source_ssrc,
/*packets_lost=*/report_block.packets_lost,
/*extended_highest_sequence_number=*/
report_block.extended_highest_sequence_number);
stats->report_block_data = std::move(report_block_data);
}
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::SendSideDelayUpdated(int avg_delay_ms,
int max_delay_ms,
uint32_t ssrc) {
MutexLock lock(&mutex_);
VideoSendStream::StreamStats* stats = GetStatsEntry(ssrc);
if (!stats)
return;
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