Chromium Code Reviews

Unified Diff: webrtc/video/send_statistics_proxy.cc

Issue 1433393002: Add separate send-side UMA stats for screenshare and video. (Closed) Base URL: https://chromium.googlesource.com/external/webrtc.git@master
Patch Set: Addressed comments Created 5 years, 1 month ago
Use n/p to move between diff chunks; N/P to move between comments.
Jump to:
View side-by-side diff with in-line comments
« no previous file with comments | « webrtc/video/send_statistics_proxy.h ('k') | webrtc/video/video_send_stream.cc » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: webrtc/video/send_statistics_proxy.cc
diff --git a/webrtc/video/send_statistics_proxy.cc b/webrtc/video/send_statistics_proxy.cc
index 57189f3175b338e8168ad9006982026fab3726d7..bfc47e7478c5e9226b70ff03f560203437d37750 100644
--- a/webrtc/video/send_statistics_proxy.cc
+++ b/webrtc/video/send_statistics_proxy.cc
@@ -31,6 +31,9 @@ enum HistogramCodecType {
kVideoMax = 64,
};
+const char* kRealtimePrefix = "WebRTC.Video.";
+const char* kScreensharePrefix = "WebRTC.Video.Screenshare.";
+
HistogramCodecType PayloadNameToHistogramCodecType(
const std::string& payload_name) {
if (payload_name == "VP8") {
@@ -57,79 +60,87 @@ SendStatisticsProxy::SendStatisticsProxy(Clock* clock,
const VideoSendStream::Config& config)
: clock_(clock),
config_(config),
- input_frame_rate_tracker_(100u, 10u),
- sent_frame_rate_tracker_(100u, 10u),
- last_sent_frame_timestamp_(0),
- max_sent_width_per_timestamp_(0),
- max_sent_height_per_timestamp_(0) {
+ codec_mode_(kRealtimeVideo),
+ uma_container_(new UmaSamplesContainer(kRealtimePrefix)) {
UpdateCodecTypeHistogram(config_.encoder_settings.payload_name);
}
SendStatisticsProxy::~SendStatisticsProxy() {
- UpdateHistograms();
+ uma_container_->UpdateHistograms();
}
-void SendStatisticsProxy::UpdateHistograms() {
- int input_fps =
- round(input_frame_rate_tracker_.ComputeTotalRate());
- if (input_fps > 0)
- RTC_HISTOGRAM_COUNTS_100("WebRTC.Video.InputFramesPerSecond", input_fps);
- int sent_fps =
- round(sent_frame_rate_tracker_.ComputeTotalRate());
- if (sent_fps > 0)
- RTC_HISTOGRAM_COUNTS_100("WebRTC.Video.SentFramesPerSecond", sent_fps);
+SendStatisticsProxy::UmaSamplesContainer::UmaSamplesContainer(
+ const char* prefix)
+ : uma_prefix_(prefix),
+ input_frame_rate_tracker_(100u, 10u),
+ sent_frame_rate_tracker_(100u, 10u),
+ last_sent_frame_timestamp_(0),
+ max_sent_width_per_timestamp_(0),
+ max_sent_height_per_timestamp_(0) {}
+void SendStatisticsProxy::UmaSamplesContainer::UpdateHistograms() {
const int kMinRequiredSamples = 200;
+ if (input_frame_rate_tracker_.TotalSampleCount() >= kMinRequiredSamples) {
+ int input_fps = round(input_frame_rate_tracker_.ComputeTotalRate());
+ if (input_fps > 0)
+ RTC_HISTOGRAM_COUNTS_100(uma_prefix_ + "InputFramesPerSecond", input_fps);
+ }
+ if (sent_frame_rate_tracker_.TotalSampleCount() >= kMinRequiredSamples) {
+ int sent_fps = round(sent_frame_rate_tracker_.ComputeTotalRate());
+ if (sent_fps > 0)
+ RTC_HISTOGRAM_COUNTS_100(uma_prefix_ + "SentFramesPerSecond", sent_fps);
+ }
+
int in_width = input_width_counter_.Avg(kMinRequiredSamples);
int in_height = input_height_counter_.Avg(kMinRequiredSamples);
if (in_width != -1) {
- RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.InputWidthInPixels", in_width);
- RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.InputHeightInPixels", in_height);
+ RTC_HISTOGRAM_COUNTS_10000(uma_prefix_ + "InputWidthInPixels", in_width);
+ RTC_HISTOGRAM_COUNTS_10000(uma_prefix_ + "InputHeightInPixels", in_height);
}
int sent_width = sent_width_counter_.Avg(kMinRequiredSamples);
int sent_height = sent_height_counter_.Avg(kMinRequiredSamples);
if (sent_width != -1) {
- RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.SentWidthInPixels", sent_width);
- RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.SentHeightInPixels", sent_height);
+ RTC_HISTOGRAM_COUNTS_10000(uma_prefix_ + "SentWidthInPixels", sent_width);
+ RTC_HISTOGRAM_COUNTS_10000(uma_prefix_ + "SentHeightInPixels", sent_height);
}
int encode_ms = encode_time_counter_.Avg(kMinRequiredSamples);
if (encode_ms != -1)
- RTC_HISTOGRAM_COUNTS_1000("WebRTC.Video.EncodeTimeInMs", encode_ms);
+ RTC_HISTOGRAM_COUNTS_1000(uma_prefix_ + "EncodeTimeInMs", encode_ms);
int key_frames_permille = key_frame_counter_.Permille(kMinRequiredSamples);
if (key_frames_permille != -1) {
- RTC_HISTOGRAM_COUNTS_1000("WebRTC.Video.KeyFramesSentInPermille",
- key_frames_permille);
+ RTC_HISTOGRAM_COUNTS_1000(uma_prefix_ + "KeyFramesSentInPermille",
+ key_frames_permille);
}
int quality_limited =
quality_limited_frame_counter_.Percent(kMinRequiredSamples);
if (quality_limited != -1) {
- RTC_HISTOGRAM_PERCENTAGE("WebRTC.Video.QualityLimitedResolutionInPercent",
+ RTC_HISTOGRAM_PERCENTAGE(uma_prefix_ + "QualityLimitedResolutionInPercent",
quality_limited);
}
int downscales = quality_downscales_counter_.Avg(kMinRequiredSamples);
if (downscales != -1) {
- RTC_HISTOGRAM_ENUMERATION("WebRTC.Video.QualityLimitedResolutionDownscales",
- downscales, 20);
+ RTC_HISTOGRAM_ENUMERATION(
+ uma_prefix_ + "QualityLimitedResolutionDownscales", downscales, 20);
}
int bw_limited = bw_limited_frame_counter_.Percent(kMinRequiredSamples);
if (bw_limited != -1) {
- RTC_HISTOGRAM_PERCENTAGE("WebRTC.Video.BandwidthLimitedResolutionInPercent",
- bw_limited);
+ RTC_HISTOGRAM_PERCENTAGE(
+ uma_prefix_ + "BandwidthLimitedResolutionInPercent", bw_limited);
}
int num_disabled = bw_resolutions_disabled_counter_.Avg(kMinRequiredSamples);
if (num_disabled != -1) {
RTC_HISTOGRAM_ENUMERATION(
- "WebRTC.Video.BandwidthLimitedResolutionsDisabled", num_disabled, 10);
+ uma_prefix_ + "BandwidthLimitedResolutionsDisabled", num_disabled, 10);
}
int delay_ms = delay_counter_.Avg(kMinRequiredSamples);
if (delay_ms != -1)
- RTC_HISTOGRAM_COUNTS_100000("WebRTC.Video.SendSideDelayInMs", delay_ms);
+ RTC_HISTOGRAM_COUNTS_100000(uma_prefix_ + "SendSideDelayInMs", delay_ms);
int max_delay_ms = max_delay_counter_.Avg(kMinRequiredSamples);
if (max_delay_ms != -1) {
- RTC_HISTOGRAM_COUNTS_100000(
- "WebRTC.Video.SendSideDelayMaxInMs", max_delay_ms);
+ RTC_HISTOGRAM_COUNTS_100000(uma_prefix_ + "SendSideDelayMaxInMs",
+ max_delay_ms);
}
}
@@ -156,7 +167,7 @@ VideoSendStream::Stats SendStatisticsProxy::GetStats() {
rtc::CritScope lock(&crit_);
PurgeOldStats();
stats_.input_frame_rate =
- round(input_frame_rate_tracker_.ComputeRate());
+ round(uma_container_->input_frame_rate_tracker_.ComputeRate());
return stats_;
}
@@ -166,7 +177,8 @@ void SendStatisticsProxy::PurgeOldStats() {
stats_.substreams.begin();
it != stats_.substreams.end(); ++it) {
uint32_t ssrc = it->first;
- if (update_times_[ssrc].resolution_update_ms <= old_stats_ms) {
+ if (uma_container_->update_times_[ssrc].resolution_update_ms <=
+ old_stats_ms) {
it->second.width = 0;
it->second.height = 0;
}
@@ -227,58 +239,62 @@ void SendStatisticsProxy::OnSendEncodedImage(
stats->width = encoded_image._encodedWidth;
stats->height = encoded_image._encodedHeight;
- update_times_[ssrc].resolution_update_ms = clock_->TimeInMilliseconds();
+ uma_container_->update_times_[ssrc].resolution_update_ms =
+ clock_->TimeInMilliseconds();
- key_frame_counter_.Add(encoded_image._frameType == kVideoFrameKey);
+ uma_container_->key_frame_counter_.Add(encoded_image._frameType ==
+ kVideoFrameKey);
if (encoded_image.adapt_reason_.quality_resolution_downscales != -1) {
bool downscaled =
encoded_image.adapt_reason_.quality_resolution_downscales > 0;
- quality_limited_frame_counter_.Add(downscaled);
+ uma_container_->quality_limited_frame_counter_.Add(downscaled);
if (downscaled) {
- quality_downscales_counter_.Add(
+ uma_container_->quality_downscales_counter_.Add(
encoded_image.adapt_reason_.quality_resolution_downscales);
}
}
if (encoded_image.adapt_reason_.bw_resolutions_disabled != -1) {
bool bw_limited = encoded_image.adapt_reason_.bw_resolutions_disabled > 0;
- bw_limited_frame_counter_.Add(bw_limited);
+ uma_container_->bw_limited_frame_counter_.Add(bw_limited);
if (bw_limited) {
- bw_resolutions_disabled_counter_.Add(
- encoded_image.adapt_reason_.bw_resolutions_disabled);
+ uma_container_->bw_resolutions_disabled_counter_.Add(
+ encoded_image.adapt_reason_.bw_resolutions_disabled);
}
}
// TODO(asapersson): This is incorrect if simulcast layers are encoded on
// different threads and there is no guarantee that one frame of all layers
// are encoded before the next start.
- if (last_sent_frame_timestamp_ > 0 &&
- encoded_image._timeStamp != last_sent_frame_timestamp_) {
- sent_frame_rate_tracker_.AddSamples(1);
- sent_width_counter_.Add(max_sent_width_per_timestamp_);
- sent_height_counter_.Add(max_sent_height_per_timestamp_);
- max_sent_width_per_timestamp_ = 0;
- max_sent_height_per_timestamp_ = 0;
+ if (uma_container_->last_sent_frame_timestamp_ > 0 &&
+ encoded_image._timeStamp != uma_container_->last_sent_frame_timestamp_) {
+ uma_container_->sent_frame_rate_tracker_.AddSamples(1);
+ uma_container_->sent_width_counter_.Add(
+ uma_container_->max_sent_width_per_timestamp_);
+ uma_container_->sent_height_counter_.Add(
+ uma_container_->max_sent_height_per_timestamp_);
+ uma_container_->max_sent_width_per_timestamp_ = 0;
+ uma_container_->max_sent_height_per_timestamp_ = 0;
}
- last_sent_frame_timestamp_ = encoded_image._timeStamp;
- max_sent_width_per_timestamp_ =
- std::max(max_sent_width_per_timestamp_,
+ uma_container_->last_sent_frame_timestamp_ = encoded_image._timeStamp;
+ uma_container_->max_sent_width_per_timestamp_ =
+ std::max(uma_container_->max_sent_width_per_timestamp_,
static_cast<int>(encoded_image._encodedWidth));
- max_sent_height_per_timestamp_ =
- std::max(max_sent_height_per_timestamp_,
+ uma_container_->max_sent_height_per_timestamp_ =
+ std::max(uma_container_->max_sent_height_per_timestamp_,
static_cast<int>(encoded_image._encodedHeight));
}
void SendStatisticsProxy::OnIncomingFrame(int width, int height) {
rtc::CritScope lock(&crit_);
- input_frame_rate_tracker_.AddSamples(1);
- input_width_counter_.Add(width);
- input_height_counter_.Add(height);
+ uma_container_->input_frame_rate_tracker_.AddSamples(1);
+ uma_container_->input_width_counter_.Add(width);
+ uma_container_->input_height_counter_.Add(height);
}
void SendStatisticsProxy::OnEncodedFrame(int encode_time_ms) {
rtc::CritScope lock(&crit_);
- encode_time_counter_.Add(encode_time_ms);
+ uma_container_->encode_time_counter_.Add(encode_time_ms);
}
void SendStatisticsProxy::RtcpPacketTypesCounterUpdated(
@@ -348,8 +364,8 @@ void SendStatisticsProxy::SendSideDelayUpdated(int avg_delay_ms,
stats->avg_delay_ms = avg_delay_ms;
stats->max_delay_ms = max_delay_ms;
- delay_counter_.Add(avg_delay_ms);
- max_delay_counter_.Add(max_delay_ms);
+ uma_container_->delay_counter_.Add(avg_delay_ms);
+ uma_container_->max_delay_counter_.Add(max_delay_ms);
}
void SendStatisticsProxy::SampleCounter::Add(int sample) {
@@ -386,4 +402,14 @@ int SendStatisticsProxy::BoolSampleCounter::Fraction(
return static_cast<int>((sum * multiplier / num_samples) + 0.5f);
}
+void SendStatisticsProxy::SetCodecMode(VideoCodecMode mode) {
+ rtc::CritScope lock(&crit_);
+ if (codec_mode_ != mode) {
pbos-webrtc 2015/11/12 13:54:44 This is racy since pending frames might not have b
+ uma_container_->UpdateHistograms();
+ uma_container_.reset(new UmaSamplesContainer(
+ mode == kRealtimeVideo ? kRealtimePrefix : kScreensharePrefix));
+ codec_mode_ = mode;
+ }
+}
+
} // namespace webrtc
« no previous file with comments | « webrtc/video/send_statistics_proxy.h ('k') | webrtc/video/video_send_stream.cc » ('j') | no next file with comments »

Powered by Google App Engine