sprang@webrtc.org | 0931570 | 2014-02-07 12:06:29 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (c) 2013 The WebRTC project authors. All Rights Reserved. |
| 3 | * |
| 4 | * Use of this source code is governed by a BSD-style license |
| 5 | * that can be found in the LICENSE file in the root of the source |
| 6 | * tree. An additional intellectual property rights grant can be found |
| 7 | * in the file PATENTS. All contributing project authors may |
| 8 | * be found in the AUTHORS file in the root of the source tree. |
| 9 | */ |
| 10 | |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 11 | #include "video/receive_statistics_proxy.h" |
sprang@webrtc.org | 0931570 | 2014-02-07 12:06:29 +0000 | [diff] [blame] | 12 | |
philipel | a45102f | 2017-02-22 05:30:39 -0800 | [diff] [blame] | 13 | #include <algorithm> |
asapersson | f839dcc | 2015-10-08 00:41:59 -0700 | [diff] [blame] | 14 | #include <cmath> |
philipel | a45102f | 2017-02-22 05:30:39 -0800 | [diff] [blame] | 15 | #include <utility> |
asapersson | f839dcc | 2015-10-08 00:41:59 -0700 | [diff] [blame] | 16 | |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 17 | #include "modules/video_coding/include/video_codec_interface.h" |
| 18 | #include "rtc_base/checks.h" |
| 19 | #include "rtc_base/logging.h" |
Tommi | fef0500 | 2018-02-27 13:51:08 +0100 | [diff] [blame] | 20 | #include "rtc_base/strings/string_builder.h" |
Steve Anton | 10542f2 | 2019-01-11 09:11:00 -0800 | [diff] [blame] | 21 | #include "rtc_base/time_utils.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 22 | #include "system_wrappers/include/clock.h" |
Johannes Kron | e76b3ab | 2019-10-22 13:22:26 +0200 | [diff] [blame] | 23 | #include "system_wrappers/include/field_trial.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 24 | #include "system_wrappers/include/metrics.h" |
sprang@webrtc.org | 0931570 | 2014-02-07 12:06:29 +0000 | [diff] [blame] | 25 | |
| 26 | namespace webrtc { |
asapersson | de9e5ff | 2016-11-02 07:14:03 -0700 | [diff] [blame] | 27 | namespace { |
| 28 | // Periodic time interval for processing samples for |freq_offset_counter_|. |
| 29 | const int64_t kFreqOffsetProcessIntervalMs = 40000; |
palmkvist | 349092b | 2016-12-13 02:45:57 -0800 | [diff] [blame] | 30 | |
| 31 | // Configuration for bad call detection. |
palmkvist | a40672a | 2017-01-13 05:58:34 -0800 | [diff] [blame] | 32 | const int kBadCallMinRequiredSamples = 10; |
palmkvist | 349092b | 2016-12-13 02:45:57 -0800 | [diff] [blame] | 33 | const int kMinSampleLengthMs = 990; |
| 34 | const int kNumMeasurements = 10; |
| 35 | const int kNumMeasurementsVariance = kNumMeasurements * 1.5; |
| 36 | const float kBadFraction = 0.8f; |
| 37 | // For fps: |
| 38 | // Low means low enough to be bad, high means high enough to be good |
| 39 | const int kLowFpsThreshold = 12; |
| 40 | const int kHighFpsThreshold = 14; |
| 41 | // For qp and fps variance: |
| 42 | // Low means low enough to be good, high means high enough to be bad |
| 43 | const int kLowQpThresholdVp8 = 60; |
| 44 | const int kHighQpThresholdVp8 = 70; |
| 45 | const int kLowVarianceThreshold = 1; |
| 46 | const int kHighVarianceThreshold = 2; |
philipel | a45102f | 2017-02-22 05:30:39 -0800 | [diff] [blame] | 47 | |
ilnik | a79cc28 | 2017-08-23 05:24:10 -0700 | [diff] [blame] | 48 | // Some metrics are reported as a maximum over this period. |
Ilya Nikolaevskiy | b06b358 | 2017-10-16 17:59:12 +0200 | [diff] [blame] | 49 | // This should be synchronized with a typical getStats polling interval in |
| 50 | // the clients. |
| 51 | const int kMovingMaxWindowMs = 1000; |
ilnik | a79cc28 | 2017-08-23 05:24:10 -0700 | [diff] [blame] | 52 | |
philipel | a45102f | 2017-02-22 05:30:39 -0800 | [diff] [blame] | 53 | // How large window we use to calculate the framerate/bitrate. |
| 54 | const int kRateStatisticsWindowSizeMs = 1000; |
ilnik | 6d5b4d6 | 2017-08-30 03:32:14 -0700 | [diff] [blame] | 55 | |
Ilya Nikolaevskiy | daa4f7a | 2017-10-06 12:29:47 +0200 | [diff] [blame] | 56 | // Some sane ballpark estimate for maximum common value of inter-frame delay. |
| 57 | // Values below that will be stored explicitly in the array, |
| 58 | // values above - in the map. |
| 59 | const int kMaxCommonInterframeDelayMs = 500; |
| 60 | |
Tommi | fef0500 | 2018-02-27 13:51:08 +0100 | [diff] [blame] | 61 | const char* UmaPrefixForContentType(VideoContentType content_type) { |
| 62 | if (videocontenttypehelpers::IsScreenshare(content_type)) |
| 63 | return "WebRTC.Video.Screenshare"; |
| 64 | return "WebRTC.Video"; |
ilnik | 6d5b4d6 | 2017-08-30 03:32:14 -0700 | [diff] [blame] | 65 | } |
| 66 | |
| 67 | std::string UmaSuffixForContentType(VideoContentType content_type) { |
Karl Wiberg | 881f168 | 2018-03-08 15:03:23 +0100 | [diff] [blame] | 68 | char ss_buf[1024]; |
| 69 | rtc::SimpleStringBuilder ss(ss_buf); |
ilnik | 6d5b4d6 | 2017-08-30 03:32:14 -0700 | [diff] [blame] | 70 | int simulcast_id = videocontenttypehelpers::GetSimulcastId(content_type); |
| 71 | if (simulcast_id > 0) { |
| 72 | ss << ".S" << simulcast_id - 1; |
| 73 | } |
| 74 | int experiment_id = videocontenttypehelpers::GetExperimentId(content_type); |
| 75 | if (experiment_id > 0) { |
| 76 | ss << ".ExperimentGroup" << experiment_id - 1; |
| 77 | } |
| 78 | return ss.str(); |
| 79 | } |
Tommi | fef0500 | 2018-02-27 13:51:08 +0100 | [diff] [blame] | 80 | |
asapersson | de9e5ff | 2016-11-02 07:14:03 -0700 | [diff] [blame] | 81 | } // namespace |
sprang@webrtc.org | 0931570 | 2014-02-07 12:06:29 +0000 | [diff] [blame] | 82 | |
sprang | 0ab8e81 | 2016-02-24 01:35:40 -0800 | [diff] [blame] | 83 | ReceiveStatisticsProxy::ReceiveStatisticsProxy( |
Tommi | 733b547 | 2016-06-10 17:58:01 +0200 | [diff] [blame] | 84 | const VideoReceiveStream::Config* config, |
sprang | 0ab8e81 | 2016-02-24 01:35:40 -0800 | [diff] [blame] | 85 | Clock* clock) |
pbos@webrtc.org | 5570769 | 2014-12-19 15:45:03 +0000 | [diff] [blame] | 86 | : clock_(clock), |
Tommi | 733b547 | 2016-06-10 17:58:01 +0200 | [diff] [blame] | 87 | config_(*config), |
asapersson | 4374a09 | 2016-07-27 00:39:09 -0700 | [diff] [blame] | 88 | start_ms_(clock->TimeInMilliseconds()), |
Johannes Kron | e76b3ab | 2019-10-22 13:22:26 +0200 | [diff] [blame] | 89 | enable_decode_time_histograms_( |
| 90 | !field_trial::IsEnabled("WebRTC-DecodeTimeHistogramsKillSwitch")), |
palmkvist | 349092b | 2016-12-13 02:45:57 -0800 | [diff] [blame] | 91 | last_sample_time_(clock->TimeInMilliseconds()), |
| 92 | fps_threshold_(kLowFpsThreshold, |
| 93 | kHighFpsThreshold, |
| 94 | kBadFraction, |
| 95 | kNumMeasurements), |
| 96 | qp_threshold_(kLowQpThresholdVp8, |
| 97 | kHighQpThresholdVp8, |
| 98 | kBadFraction, |
| 99 | kNumMeasurements), |
| 100 | variance_threshold_(kLowVarianceThreshold, |
| 101 | kHighVarianceThreshold, |
| 102 | kBadFraction, |
| 103 | kNumMeasurementsVariance), |
palmkvist | a40672a | 2017-01-13 05:58:34 -0800 | [diff] [blame] | 104 | num_bad_states_(0), |
| 105 | num_certain_states_(0), |
sprang@webrtc.org | 0931570 | 2014-02-07 12:06:29 +0000 | [diff] [blame] | 106 | // 1000ms window, scale 1000 for ms to s. |
| 107 | decode_fps_estimator_(1000, 1000), |
Tim Psiaki | 6304626 | 2015-09-14 10:38:08 -0700 | [diff] [blame] | 108 | renders_fps_estimator_(1000, 1000), |
Honghai Zhang | 82d7862 | 2016-05-06 11:29:15 -0700 | [diff] [blame] | 109 | render_fps_tracker_(100, 10u), |
asapersson | de9e5ff | 2016-11-02 07:14:03 -0700 | [diff] [blame] | 110 | render_pixel_tracker_(100, 10u), |
Ilya Nikolaevskiy | 94150ee | 2018-05-23 11:53:19 +0200 | [diff] [blame] | 111 | video_quality_observer_( |
| 112 | new VideoQualityObserver(VideoContentType::UNSPECIFIED)), |
ilnik | a79cc28 | 2017-08-23 05:24:10 -0700 | [diff] [blame] | 113 | interframe_delay_max_moving_(kMovingMaxWindowMs), |
asapersson | 0c43f77 | 2016-11-30 01:42:26 -0800 | [diff] [blame] | 114 | freq_offset_counter_(clock, nullptr, kFreqOffsetProcessIntervalMs), |
ilnik | 00d802b | 2017-04-11 10:34:31 -0700 | [diff] [blame] | 115 | avg_rtt_ms_(0), |
ilnik | 75204c5 | 2017-09-04 03:35:40 -0700 | [diff] [blame] | 116 | last_content_type_(VideoContentType::UNSPECIFIED), |
Ilya Nikolaevskiy | 94150ee | 2018-05-23 11:53:19 +0200 | [diff] [blame] | 117 | last_codec_type_(kVideoCodecVP8), |
Åsa Persson | 81327d5 | 2018-06-05 13:34:33 +0200 | [diff] [blame] | 118 | num_delayed_frames_rendered_(0), |
| 119 | sum_missed_render_deadline_ms_(0), |
ilnik | 75204c5 | 2017-09-04 03:35:40 -0700 | [diff] [blame] | 120 | timing_frame_info_counter_(kMovingMaxWindowMs) { |
Sebastian Jansson | c01367d | 2019-04-08 15:20:44 +0200 | [diff] [blame] | 121 | decode_thread_.Detach(); |
| 122 | network_thread_.Detach(); |
Tommi | 733b547 | 2016-06-10 17:58:01 +0200 | [diff] [blame] | 123 | stats_.ssrc = config_.rtp.remote_ssrc; |
sprang@webrtc.org | 0931570 | 2014-02-07 12:06:29 +0000 | [diff] [blame] | 124 | } |
| 125 | |
Niels Möller | 9a9f18a | 2019-08-02 13:52:37 +0200 | [diff] [blame] | 126 | void ReceiveStatisticsProxy::UpdateHistograms( |
Niels Möller | d781965 | 2019-08-13 14:43:02 +0200 | [diff] [blame] | 127 | absl::optional<int> fraction_lost, |
| 128 | const StreamDataCounters& rtp_stats, |
| 129 | const StreamDataCounters* rtx_stats) { |
Niels Möller | 9a9f18a | 2019-08-02 13:52:37 +0200 | [diff] [blame] | 130 | // Not actually running on the decoder thread, but must be called after |
| 131 | // DecoderThreadStopped, which detaches the thread checker. It is therefore |
| 132 | // safe to access |qp_counters_|, which were updated on the decode thread |
| 133 | // earlier. |
Tommi | 132e28e | 2018-02-24 17:57:33 +0100 | [diff] [blame] | 134 | RTC_DCHECK_RUN_ON(&decode_thread_); |
Niels Möller | 9a9f18a | 2019-08-02 13:52:37 +0200 | [diff] [blame] | 135 | |
| 136 | rtc::CritScope lock(&crit_); |
| 137 | |
Karl Wiberg | 881f168 | 2018-03-08 15:03:23 +0100 | [diff] [blame] | 138 | char log_stream_buf[8 * 1024]; |
| 139 | rtc::SimpleStringBuilder log_stream(log_stream_buf); |
ilnik | 6d5b4d6 | 2017-08-30 03:32:14 -0700 | [diff] [blame] | 140 | int stream_duration_sec = (clock_->TimeInMilliseconds() - start_ms_) / 1000; |
| 141 | if (stats_.frame_counts.key_frames > 0 || |
| 142 | stats_.frame_counts.delta_frames > 0) { |
| 143 | RTC_HISTOGRAM_COUNTS_100000("WebRTC.Video.ReceiveStreamLifetimeInSeconds", |
| 144 | stream_duration_sec); |
Tommi | fef0500 | 2018-02-27 13:51:08 +0100 | [diff] [blame] | 145 | log_stream << "WebRTC.Video.ReceiveStreamLifetimeInSeconds " |
| 146 | << stream_duration_sec << '\n'; |
ilnik | 6d5b4d6 | 2017-08-30 03:32:14 -0700 | [diff] [blame] | 147 | } |
asapersson | 4374a09 | 2016-07-27 00:39:09 -0700 | [diff] [blame] | 148 | |
Ilya Nikolaevskiy | 94150ee | 2018-05-23 11:53:19 +0200 | [diff] [blame] | 149 | log_stream << "Frames decoded " << stats_.frames_decoded << '\n'; |
Ilya Nikolaevskiy | d397a0d | 2018-02-21 15:57:09 +0100 | [diff] [blame] | 150 | |
| 151 | if (num_unique_frames_) { |
| 152 | int num_dropped_frames = *num_unique_frames_ - stats_.frames_decoded; |
| 153 | RTC_HISTOGRAM_COUNTS_1000("WebRTC.Video.DroppedFrames.Receiver", |
| 154 | num_dropped_frames); |
Ilya Nikolaevskiy | 94150ee | 2018-05-23 11:53:19 +0200 | [diff] [blame] | 155 | log_stream << "WebRTC.Video.DroppedFrames.Receiver " << num_dropped_frames |
| 156 | << '\n'; |
Ilya Nikolaevskiy | d397a0d | 2018-02-21 15:57:09 +0100 | [diff] [blame] | 157 | } |
| 158 | |
Niels Möller | 9a9f18a | 2019-08-02 13:52:37 +0200 | [diff] [blame] | 159 | if (fraction_lost && stream_duration_sec >= metrics::kMinRunTimeInSeconds) { |
| 160 | RTC_HISTOGRAM_PERCENTAGE("WebRTC.Video.ReceivedPacketsLostInPercent", |
| 161 | *fraction_lost); |
| 162 | log_stream << "WebRTC.Video.ReceivedPacketsLostInPercent " << *fraction_lost |
| 163 | << '\n'; |
Åsa Persson | 3c391cb | 2015-04-27 10:09:49 +0200 | [diff] [blame] | 164 | } |
asapersson | 0c43f77 | 2016-11-30 01:42:26 -0800 | [diff] [blame] | 165 | |
Åsa Persson | b9b07ea | 2018-01-24 17:04:07 +0100 | [diff] [blame] | 166 | if (first_decoded_frame_time_ms_) { |
| 167 | const int64_t elapsed_ms = |
| 168 | (clock_->TimeInMilliseconds() - *first_decoded_frame_time_ms_); |
| 169 | if (elapsed_ms >= |
| 170 | metrics::kMinRunTimeInSeconds * rtc::kNumMillisecsPerSec) { |
Åsa Persson | afb8d5c | 2019-05-21 14:42:29 +0200 | [diff] [blame] | 171 | int decoded_fps = static_cast<int>( |
| 172 | (stats_.frames_decoded * 1000.0f / elapsed_ms) + 0.5f); |
| 173 | RTC_HISTOGRAM_COUNTS_100("WebRTC.Video.DecodedFramesPerSecond", |
| 174 | decoded_fps); |
| 175 | log_stream << "WebRTC.Video.DecodedFramesPerSecond " << decoded_fps |
| 176 | << '\n'; |
Åsa Persson | 81327d5 | 2018-06-05 13:34:33 +0200 | [diff] [blame] | 177 | |
| 178 | const uint32_t frames_rendered = stats_.frames_rendered; |
| 179 | if (frames_rendered > 0) { |
| 180 | RTC_HISTOGRAM_PERCENTAGE("WebRTC.Video.DelayedFramesToRenderer", |
| 181 | static_cast<int>(num_delayed_frames_rendered_ * |
| 182 | 100 / frames_rendered)); |
| 183 | if (num_delayed_frames_rendered_ > 0) { |
| 184 | RTC_HISTOGRAM_COUNTS_1000( |
| 185 | "WebRTC.Video.DelayedFramesToRenderer_AvgDelayInMs", |
| 186 | static_cast<int>(sum_missed_render_deadline_ms_ / |
| 187 | num_delayed_frames_rendered_)); |
| 188 | } |
| 189 | } |
Åsa Persson | b9b07ea | 2018-01-24 17:04:07 +0100 | [diff] [blame] | 190 | } |
| 191 | } |
| 192 | |
asapersson | 6718e97 | 2015-07-24 00:20:58 -0700 | [diff] [blame] | 193 | const int kMinRequiredSamples = 200; |
asapersson | f839dcc | 2015-10-08 00:41:59 -0700 | [diff] [blame] | 194 | int samples = static_cast<int>(render_fps_tracker_.TotalSampleCount()); |
asapersson | 2077f2f | 2017-05-11 05:37:35 -0700 | [diff] [blame] | 195 | if (samples >= kMinRequiredSamples) { |
Åsa Persson | afb8d5c | 2019-05-21 14:42:29 +0200 | [diff] [blame] | 196 | int rendered_fps = round(render_fps_tracker_.ComputeTotalRate()); |
asapersson | 1d02d3e | 2016-09-09 22:40:25 -0700 | [diff] [blame] | 197 | RTC_HISTOGRAM_COUNTS_100("WebRTC.Video.RenderFramesPerSecond", |
Åsa Persson | afb8d5c | 2019-05-21 14:42:29 +0200 | [diff] [blame] | 198 | rendered_fps); |
| 199 | log_stream << "WebRTC.Video.RenderFramesPerSecond " << rendered_fps << '\n'; |
asapersson | 1d02d3e | 2016-09-09 22:40:25 -0700 | [diff] [blame] | 200 | RTC_HISTOGRAM_COUNTS_100000( |
asapersson | 28ba927 | 2016-01-25 05:58:23 -0800 | [diff] [blame] | 201 | "WebRTC.Video.RenderSqrtPixelsPerSecond", |
Tim Psiaki | ad13d2f | 2015-11-10 16:34:50 -0800 | [diff] [blame] | 202 | round(render_pixel_tracker_.ComputeTotalRate())); |
asapersson | f839dcc | 2015-10-08 00:41:59 -0700 | [diff] [blame] | 203 | } |
ilnik | 6d5b4d6 | 2017-08-30 03:32:14 -0700 | [diff] [blame] | 204 | |
Danil Chapovalov | b9b146c | 2018-06-15 12:28:07 +0200 | [diff] [blame] | 205 | absl::optional<int> sync_offset_ms = |
Ilya Nikolaevskiy | 0beed5d | 2018-05-22 10:54:30 +0200 | [diff] [blame] | 206 | sync_offset_counter_.Avg(kMinRequiredSamples); |
| 207 | if (sync_offset_ms) { |
| 208 | RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.AVSyncOffsetInMs", |
| 209 | *sync_offset_ms); |
| 210 | log_stream << "WebRTC.Video.AVSyncOffsetInMs " << *sync_offset_ms << '\n'; |
pbos | 35fdb2a | 2016-05-03 03:32:10 -0700 | [diff] [blame] | 211 | } |
asapersson | de9e5ff | 2016-11-02 07:14:03 -0700 | [diff] [blame] | 212 | AggregatedStats freq_offset_stats = freq_offset_counter_.GetStats(); |
| 213 | if (freq_offset_stats.num_samples > 0) { |
| 214 | RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.RtpToNtpFreqOffsetInKhz", |
| 215 | freq_offset_stats.average); |
Tommi | fef0500 | 2018-02-27 13:51:08 +0100 | [diff] [blame] | 216 | log_stream << "WebRTC.Video.RtpToNtpFreqOffsetInKhz " |
| 217 | << freq_offset_stats.ToString() << '\n'; |
asapersson | de9e5ff | 2016-11-02 07:14:03 -0700 | [diff] [blame] | 218 | } |
asapersson | f8cdd18 | 2016-03-15 01:00:47 -0700 | [diff] [blame] | 219 | |
asapersson | b99baf8 | 2017-04-20 04:05:43 -0700 | [diff] [blame] | 220 | int num_total_frames = |
| 221 | stats_.frame_counts.key_frames + stats_.frame_counts.delta_frames; |
| 222 | if (num_total_frames >= kMinRequiredSamples) { |
| 223 | int num_key_frames = stats_.frame_counts.key_frames; |
philipel | a45102f | 2017-02-22 05:30:39 -0800 | [diff] [blame] | 224 | int key_frames_permille = |
asapersson | b99baf8 | 2017-04-20 04:05:43 -0700 | [diff] [blame] | 225 | (num_key_frames * 1000 + num_total_frames / 2) / num_total_frames; |
philipel | a45102f | 2017-02-22 05:30:39 -0800 | [diff] [blame] | 226 | RTC_HISTOGRAM_COUNTS_1000("WebRTC.Video.KeyFramesReceivedInPermille", |
| 227 | key_frames_permille); |
Tommi | fef0500 | 2018-02-27 13:51:08 +0100 | [diff] [blame] | 228 | log_stream << "WebRTC.Video.KeyFramesReceivedInPermille " |
| 229 | << key_frames_permille << '\n'; |
philipel | a45102f | 2017-02-22 05:30:39 -0800 | [diff] [blame] | 230 | } |
| 231 | |
Danil Chapovalov | b9b146c | 2018-06-15 12:28:07 +0200 | [diff] [blame] | 232 | absl::optional<int> qp = qp_counters_.vp8.Avg(kMinRequiredSamples); |
Ilya Nikolaevskiy | 0beed5d | 2018-05-22 10:54:30 +0200 | [diff] [blame] | 233 | if (qp) { |
| 234 | RTC_HISTOGRAM_COUNTS_200("WebRTC.Video.Decoded.Vp8.Qp", *qp); |
| 235 | log_stream << "WebRTC.Video.Decoded.Vp8.Qp " << *qp << '\n'; |
asapersson | 2077f2f | 2017-05-11 05:37:35 -0700 | [diff] [blame] | 236 | } |
Danil Chapovalov | b9b146c | 2018-06-15 12:28:07 +0200 | [diff] [blame] | 237 | absl::optional<int> decode_ms = decode_time_counter_.Avg(kMinRequiredSamples); |
Ilya Nikolaevskiy | 0beed5d | 2018-05-22 10:54:30 +0200 | [diff] [blame] | 238 | if (decode_ms) { |
| 239 | RTC_HISTOGRAM_COUNTS_1000("WebRTC.Video.DecodeTimeInMs", *decode_ms); |
| 240 | log_stream << "WebRTC.Video.DecodeTimeInMs " << *decode_ms << '\n'; |
asapersson | 2077f2f | 2017-05-11 05:37:35 -0700 | [diff] [blame] | 241 | } |
Danil Chapovalov | b9b146c | 2018-06-15 12:28:07 +0200 | [diff] [blame] | 242 | absl::optional<int> jb_delay_ms = |
Ilya Nikolaevskiy | 0beed5d | 2018-05-22 10:54:30 +0200 | [diff] [blame] | 243 | jitter_buffer_delay_counter_.Avg(kMinRequiredSamples); |
| 244 | if (jb_delay_ms) { |
philipel | a45102f | 2017-02-22 05:30:39 -0800 | [diff] [blame] | 245 | RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.JitterBufferDelayInMs", |
Ilya Nikolaevskiy | 0beed5d | 2018-05-22 10:54:30 +0200 | [diff] [blame] | 246 | *jb_delay_ms); |
| 247 | log_stream << "WebRTC.Video.JitterBufferDelayInMs " << *jb_delay_ms << '\n'; |
asapersson | 8688a4e | 2016-04-27 23:42:35 -0700 | [diff] [blame] | 248 | } |
philipel | a45102f | 2017-02-22 05:30:39 -0800 | [diff] [blame] | 249 | |
Danil Chapovalov | b9b146c | 2018-06-15 12:28:07 +0200 | [diff] [blame] | 250 | absl::optional<int> target_delay_ms = |
Ilya Nikolaevskiy | 0beed5d | 2018-05-22 10:54:30 +0200 | [diff] [blame] | 251 | target_delay_counter_.Avg(kMinRequiredSamples); |
| 252 | if (target_delay_ms) { |
| 253 | RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.TargetDelayInMs", |
| 254 | *target_delay_ms); |
| 255 | log_stream << "WebRTC.Video.TargetDelayInMs " << *target_delay_ms << '\n'; |
asapersson | 8688a4e | 2016-04-27 23:42:35 -0700 | [diff] [blame] | 256 | } |
Danil Chapovalov | b9b146c | 2018-06-15 12:28:07 +0200 | [diff] [blame] | 257 | absl::optional<int> current_delay_ms = |
Ilya Nikolaevskiy | 0beed5d | 2018-05-22 10:54:30 +0200 | [diff] [blame] | 258 | current_delay_counter_.Avg(kMinRequiredSamples); |
| 259 | if (current_delay_ms) { |
asapersson | 1d02d3e | 2016-09-09 22:40:25 -0700 | [diff] [blame] | 260 | RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.CurrentDelayInMs", |
Ilya Nikolaevskiy | 0beed5d | 2018-05-22 10:54:30 +0200 | [diff] [blame] | 261 | *current_delay_ms); |
| 262 | log_stream << "WebRTC.Video.CurrentDelayInMs " << *current_delay_ms << '\n'; |
asapersson | 8688a4e | 2016-04-27 23:42:35 -0700 | [diff] [blame] | 263 | } |
Danil Chapovalov | b9b146c | 2018-06-15 12:28:07 +0200 | [diff] [blame] | 264 | absl::optional<int> delay_ms = delay_counter_.Avg(kMinRequiredSamples); |
Ilya Nikolaevskiy | 0beed5d | 2018-05-22 10:54:30 +0200 | [diff] [blame] | 265 | if (delay_ms) |
| 266 | RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.OnewayDelayInMs", *delay_ms); |
sprang | 0ab8e81 | 2016-02-24 01:35:40 -0800 | [diff] [blame] | 267 | |
ilnik | 6d5b4d6 | 2017-08-30 03:32:14 -0700 | [diff] [blame] | 268 | // Aggregate content_specific_stats_ by removing experiment or simulcast |
| 269 | // information; |
| 270 | std::map<VideoContentType, ContentSpecificStats> aggregated_stats; |
Mirko Bonadei | 739baf0 | 2019-01-27 17:29:42 +0100 | [diff] [blame] | 271 | for (const auto& it : content_specific_stats_) { |
ilnik | 6d5b4d6 | 2017-08-30 03:32:14 -0700 | [diff] [blame] | 272 | // Calculate simulcast specific metrics (".S0" ... ".S2" suffixes). |
| 273 | VideoContentType content_type = it.first; |
| 274 | if (videocontenttypehelpers::GetSimulcastId(content_type) > 0) { |
| 275 | // Aggregate on experiment id. |
| 276 | videocontenttypehelpers::SetExperimentId(&content_type, 0); |
| 277 | aggregated_stats[content_type].Add(it.second); |
| 278 | } |
| 279 | // Calculate experiment specific metrics (".ExperimentGroup[0-7]" suffixes). |
| 280 | content_type = it.first; |
| 281 | if (videocontenttypehelpers::GetExperimentId(content_type) > 0) { |
| 282 | // Aggregate on simulcast id. |
| 283 | videocontenttypehelpers::SetSimulcastId(&content_type, 0); |
| 284 | aggregated_stats[content_type].Add(it.second); |
| 285 | } |
| 286 | // Calculate aggregated metrics (no suffixes. Aggregated on everything). |
| 287 | content_type = it.first; |
| 288 | videocontenttypehelpers::SetSimulcastId(&content_type, 0); |
| 289 | videocontenttypehelpers::SetExperimentId(&content_type, 0); |
| 290 | aggregated_stats[content_type].Add(it.second); |
ilnik | 00d802b | 2017-04-11 10:34:31 -0700 | [diff] [blame] | 291 | } |
| 292 | |
Mirko Bonadei | 739baf0 | 2019-01-27 17:29:42 +0100 | [diff] [blame] | 293 | for (const auto& it : aggregated_stats) { |
ilnik | 6d5b4d6 | 2017-08-30 03:32:14 -0700 | [diff] [blame] | 294 | // For the metric Foo we report the following slices: |
| 295 | // WebRTC.Video.Foo, |
| 296 | // WebRTC.Video.Screenshare.Foo, |
| 297 | // WebRTC.Video.Foo.S[0-3], |
| 298 | // WebRTC.Video.Foo.ExperimentGroup[0-7], |
| 299 | // WebRTC.Video.Screenshare.Foo.S[0-3], |
| 300 | // WebRTC.Video.Screenshare.Foo.ExperimentGroup[0-7]. |
| 301 | auto content_type = it.first; |
| 302 | auto stats = it.second; |
| 303 | std::string uma_prefix = UmaPrefixForContentType(content_type); |
| 304 | std::string uma_suffix = UmaSuffixForContentType(content_type); |
| 305 | // Metrics can be sliced on either simulcast id or experiment id but not |
| 306 | // both. |
| 307 | RTC_DCHECK(videocontenttypehelpers::GetExperimentId(content_type) == 0 || |
| 308 | videocontenttypehelpers::GetSimulcastId(content_type) == 0); |
ilnik | 00d802b | 2017-04-11 10:34:31 -0700 | [diff] [blame] | 309 | |
Danil Chapovalov | b9b146c | 2018-06-15 12:28:07 +0200 | [diff] [blame] | 310 | absl::optional<int> e2e_delay_ms = |
Ilya Nikolaevskiy | 0beed5d | 2018-05-22 10:54:30 +0200 | [diff] [blame] | 311 | stats.e2e_delay_counter.Avg(kMinRequiredSamples); |
| 312 | if (e2e_delay_ms) { |
ilnik | 6d5b4d6 | 2017-08-30 03:32:14 -0700 | [diff] [blame] | 313 | RTC_HISTOGRAM_COUNTS_SPARSE_10000( |
Ilya Nikolaevskiy | 0beed5d | 2018-05-22 10:54:30 +0200 | [diff] [blame] | 314 | uma_prefix + ".EndToEndDelayInMs" + uma_suffix, *e2e_delay_ms); |
Tommi | fef0500 | 2018-02-27 13:51:08 +0100 | [diff] [blame] | 315 | log_stream << uma_prefix << ".EndToEndDelayInMs" << uma_suffix << " " |
Ilya Nikolaevskiy | 0beed5d | 2018-05-22 10:54:30 +0200 | [diff] [blame] | 316 | << *e2e_delay_ms << '\n'; |
ilnik | 6d5b4d6 | 2017-08-30 03:32:14 -0700 | [diff] [blame] | 317 | } |
Danil Chapovalov | b9b146c | 2018-06-15 12:28:07 +0200 | [diff] [blame] | 318 | absl::optional<int> e2e_delay_max_ms = stats.e2e_delay_counter.Max(); |
Ilya Nikolaevskiy | 0beed5d | 2018-05-22 10:54:30 +0200 | [diff] [blame] | 319 | if (e2e_delay_max_ms && e2e_delay_ms) { |
ilnik | 6d5b4d6 | 2017-08-30 03:32:14 -0700 | [diff] [blame] | 320 | RTC_HISTOGRAM_COUNTS_SPARSE_100000( |
Ilya Nikolaevskiy | 0beed5d | 2018-05-22 10:54:30 +0200 | [diff] [blame] | 321 | uma_prefix + ".EndToEndDelayMaxInMs" + uma_suffix, *e2e_delay_max_ms); |
Tommi | fef0500 | 2018-02-27 13:51:08 +0100 | [diff] [blame] | 322 | log_stream << uma_prefix << ".EndToEndDelayMaxInMs" << uma_suffix << " " |
Ilya Nikolaevskiy | 0beed5d | 2018-05-22 10:54:30 +0200 | [diff] [blame] | 323 | << *e2e_delay_max_ms << '\n'; |
ilnik | 6d5b4d6 | 2017-08-30 03:32:14 -0700 | [diff] [blame] | 324 | } |
Danil Chapovalov | b9b146c | 2018-06-15 12:28:07 +0200 | [diff] [blame] | 325 | absl::optional<int> interframe_delay_ms = |
ilnik | 6d5b4d6 | 2017-08-30 03:32:14 -0700 | [diff] [blame] | 326 | stats.interframe_delay_counter.Avg(kMinRequiredSamples); |
Ilya Nikolaevskiy | 0beed5d | 2018-05-22 10:54:30 +0200 | [diff] [blame] | 327 | if (interframe_delay_ms) { |
ilnik | 6d5b4d6 | 2017-08-30 03:32:14 -0700 | [diff] [blame] | 328 | RTC_HISTOGRAM_COUNTS_SPARSE_10000( |
| 329 | uma_prefix + ".InterframeDelayInMs" + uma_suffix, |
Ilya Nikolaevskiy | 0beed5d | 2018-05-22 10:54:30 +0200 | [diff] [blame] | 330 | *interframe_delay_ms); |
Tommi | fef0500 | 2018-02-27 13:51:08 +0100 | [diff] [blame] | 331 | log_stream << uma_prefix << ".InterframeDelayInMs" << uma_suffix << " " |
Ilya Nikolaevskiy | 0beed5d | 2018-05-22 10:54:30 +0200 | [diff] [blame] | 332 | << *interframe_delay_ms << '\n'; |
ilnik | 6d5b4d6 | 2017-08-30 03:32:14 -0700 | [diff] [blame] | 333 | } |
Danil Chapovalov | b9b146c | 2018-06-15 12:28:07 +0200 | [diff] [blame] | 334 | absl::optional<int> interframe_delay_max_ms = |
Ilya Nikolaevskiy | 0beed5d | 2018-05-22 10:54:30 +0200 | [diff] [blame] | 335 | stats.interframe_delay_counter.Max(); |
| 336 | if (interframe_delay_max_ms && interframe_delay_ms) { |
ilnik | 6d5b4d6 | 2017-08-30 03:32:14 -0700 | [diff] [blame] | 337 | RTC_HISTOGRAM_COUNTS_SPARSE_10000( |
| 338 | uma_prefix + ".InterframeDelayMaxInMs" + uma_suffix, |
Ilya Nikolaevskiy | 0beed5d | 2018-05-22 10:54:30 +0200 | [diff] [blame] | 339 | *interframe_delay_max_ms); |
Tommi | fef0500 | 2018-02-27 13:51:08 +0100 | [diff] [blame] | 340 | log_stream << uma_prefix << ".InterframeDelayMaxInMs" << uma_suffix << " " |
Ilya Nikolaevskiy | 0beed5d | 2018-05-22 10:54:30 +0200 | [diff] [blame] | 341 | << *interframe_delay_max_ms << '\n'; |
ilnik | 6d5b4d6 | 2017-08-30 03:32:14 -0700 | [diff] [blame] | 342 | } |
ilnik | 00d802b | 2017-04-11 10:34:31 -0700 | [diff] [blame] | 343 | |
Danil Chapovalov | b9b146c | 2018-06-15 12:28:07 +0200 | [diff] [blame] | 344 | absl::optional<uint32_t> interframe_delay_95p_ms = |
Ilya Nikolaevskiy | daa4f7a | 2017-10-06 12:29:47 +0200 | [diff] [blame] | 345 | stats.interframe_delay_percentiles.GetPercentile(0.95f); |
| 346 | if (interframe_delay_95p_ms && interframe_delay_ms != -1) { |
| 347 | RTC_HISTOGRAM_COUNTS_SPARSE_10000( |
| 348 | uma_prefix + ".InterframeDelay95PercentileInMs" + uma_suffix, |
| 349 | *interframe_delay_95p_ms); |
Tommi | fef0500 | 2018-02-27 13:51:08 +0100 | [diff] [blame] | 350 | log_stream << uma_prefix << ".InterframeDelay95PercentileInMs" |
| 351 | << uma_suffix << " " << *interframe_delay_95p_ms << '\n'; |
Ilya Nikolaevskiy | daa4f7a | 2017-10-06 12:29:47 +0200 | [diff] [blame] | 352 | } |
| 353 | |
Danil Chapovalov | b9b146c | 2018-06-15 12:28:07 +0200 | [diff] [blame] | 354 | absl::optional<int> width = stats.received_width.Avg(kMinRequiredSamples); |
Ilya Nikolaevskiy | 0beed5d | 2018-05-22 10:54:30 +0200 | [diff] [blame] | 355 | if (width) { |
ilnik | 6d5b4d6 | 2017-08-30 03:32:14 -0700 | [diff] [blame] | 356 | RTC_HISTOGRAM_COUNTS_SPARSE_10000( |
Ilya Nikolaevskiy | 0beed5d | 2018-05-22 10:54:30 +0200 | [diff] [blame] | 357 | uma_prefix + ".ReceivedWidthInPixels" + uma_suffix, *width); |
Tommi | fef0500 | 2018-02-27 13:51:08 +0100 | [diff] [blame] | 358 | log_stream << uma_prefix << ".ReceivedWidthInPixels" << uma_suffix << " " |
Ilya Nikolaevskiy | 0beed5d | 2018-05-22 10:54:30 +0200 | [diff] [blame] | 359 | << *width << '\n'; |
ilnik | 6d5b4d6 | 2017-08-30 03:32:14 -0700 | [diff] [blame] | 360 | } |
asapersson | 1490f7a | 2016-09-23 02:09:46 -0700 | [diff] [blame] | 361 | |
Danil Chapovalov | b9b146c | 2018-06-15 12:28:07 +0200 | [diff] [blame] | 362 | absl::optional<int> height = stats.received_height.Avg(kMinRequiredSamples); |
Ilya Nikolaevskiy | 0beed5d | 2018-05-22 10:54:30 +0200 | [diff] [blame] | 363 | if (height) { |
ilnik | 6d5b4d6 | 2017-08-30 03:32:14 -0700 | [diff] [blame] | 364 | RTC_HISTOGRAM_COUNTS_SPARSE_10000( |
Ilya Nikolaevskiy | 0beed5d | 2018-05-22 10:54:30 +0200 | [diff] [blame] | 365 | uma_prefix + ".ReceivedHeightInPixels" + uma_suffix, *height); |
Tommi | fef0500 | 2018-02-27 13:51:08 +0100 | [diff] [blame] | 366 | log_stream << uma_prefix << ".ReceivedHeightInPixels" << uma_suffix << " " |
Ilya Nikolaevskiy | 0beed5d | 2018-05-22 10:54:30 +0200 | [diff] [blame] | 367 | << *height << '\n'; |
ilnik | 6d5b4d6 | 2017-08-30 03:32:14 -0700 | [diff] [blame] | 368 | } |
ilnik | 4257ab2 | 2017-07-03 01:15:58 -0700 | [diff] [blame] | 369 | |
ilnik | 6d5b4d6 | 2017-08-30 03:32:14 -0700 | [diff] [blame] | 370 | if (content_type != VideoContentType::UNSPECIFIED) { |
| 371 | // Don't report these 3 metrics unsliced, as more precise variants |
| 372 | // are reported separately in this method. |
| 373 | float flow_duration_sec = stats.flow_duration_ms / 1000.0; |
| 374 | if (flow_duration_sec >= metrics::kMinRunTimeInSeconds) { |
| 375 | int media_bitrate_kbps = static_cast<int>(stats.total_media_bytes * 8 / |
| 376 | flow_duration_sec / 1000); |
| 377 | RTC_HISTOGRAM_COUNTS_SPARSE_10000( |
| 378 | uma_prefix + ".MediaBitrateReceivedInKbps" + uma_suffix, |
| 379 | media_bitrate_kbps); |
Tommi | fef0500 | 2018-02-27 13:51:08 +0100 | [diff] [blame] | 380 | log_stream << uma_prefix << ".MediaBitrateReceivedInKbps" << uma_suffix |
| 381 | << " " << media_bitrate_kbps << '\n'; |
ilnik | 6d5b4d6 | 2017-08-30 03:32:14 -0700 | [diff] [blame] | 382 | } |
| 383 | |
| 384 | int num_total_frames = |
| 385 | stats.frame_counts.key_frames + stats.frame_counts.delta_frames; |
| 386 | if (num_total_frames >= kMinRequiredSamples) { |
| 387 | int num_key_frames = stats.frame_counts.key_frames; |
| 388 | int key_frames_permille = |
| 389 | (num_key_frames * 1000 + num_total_frames / 2) / num_total_frames; |
| 390 | RTC_HISTOGRAM_COUNTS_SPARSE_1000( |
| 391 | uma_prefix + ".KeyFramesReceivedInPermille" + uma_suffix, |
| 392 | key_frames_permille); |
Tommi | fef0500 | 2018-02-27 13:51:08 +0100 | [diff] [blame] | 393 | log_stream << uma_prefix << ".KeyFramesReceivedInPermille" << uma_suffix |
| 394 | << " " << key_frames_permille << '\n'; |
ilnik | 6d5b4d6 | 2017-08-30 03:32:14 -0700 | [diff] [blame] | 395 | } |
| 396 | |
Danil Chapovalov | b9b146c | 2018-06-15 12:28:07 +0200 | [diff] [blame] | 397 | absl::optional<int> qp = stats.qp_counter.Avg(kMinRequiredSamples); |
Ilya Nikolaevskiy | 0beed5d | 2018-05-22 10:54:30 +0200 | [diff] [blame] | 398 | if (qp) { |
ilnik | 6d5b4d6 | 2017-08-30 03:32:14 -0700 | [diff] [blame] | 399 | RTC_HISTOGRAM_COUNTS_SPARSE_200( |
Ilya Nikolaevskiy | 0beed5d | 2018-05-22 10:54:30 +0200 | [diff] [blame] | 400 | uma_prefix + ".Decoded.Vp8.Qp" + uma_suffix, *qp); |
| 401 | log_stream << uma_prefix << ".Decoded.Vp8.Qp" << uma_suffix << " " |
| 402 | << *qp << '\n'; |
ilnik | 6d5b4d6 | 2017-08-30 03:32:14 -0700 | [diff] [blame] | 403 | } |
| 404 | } |
ilnik | 4257ab2 | 2017-07-03 01:15:58 -0700 | [diff] [blame] | 405 | } |
| 406 | |
Niels Möller | d781965 | 2019-08-13 14:43:02 +0200 | [diff] [blame] | 407 | StreamDataCounters rtp_rtx_stats = rtp_stats; |
| 408 | if (rtx_stats) |
| 409 | rtp_rtx_stats.Add(*rtx_stats); |
sprang | 0ab8e81 | 2016-02-24 01:35:40 -0800 | [diff] [blame] | 410 | int64_t elapsed_sec = |
Niels Möller | d781965 | 2019-08-13 14:43:02 +0200 | [diff] [blame] | 411 | rtp_rtx_stats.TimeSinceFirstPacketInMs(clock_->TimeInMilliseconds()) / |
| 412 | 1000; |
asapersson | 2077f2f | 2017-05-11 05:37:35 -0700 | [diff] [blame] | 413 | if (elapsed_sec >= metrics::kMinRunTimeInSeconds) { |
asapersson | 1d02d3e | 2016-09-09 22:40:25 -0700 | [diff] [blame] | 414 | RTC_HISTOGRAM_COUNTS_10000( |
sprang | 0ab8e81 | 2016-02-24 01:35:40 -0800 | [diff] [blame] | 415 | "WebRTC.Video.BitrateReceivedInKbps", |
Niels Möller | d781965 | 2019-08-13 14:43:02 +0200 | [diff] [blame] | 416 | static_cast<int>(rtp_rtx_stats.transmitted.TotalBytes() * 8 / |
| 417 | elapsed_sec / 1000)); |
| 418 | int media_bitrate_kbs = static_cast<int>(rtp_stats.MediaPayloadBytes() * 8 / |
| 419 | elapsed_sec / 1000); |
ilnik | 6d5b4d6 | 2017-08-30 03:32:14 -0700 | [diff] [blame] | 420 | RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.MediaBitrateReceivedInKbps", |
| 421 | media_bitrate_kbs); |
Tommi | fef0500 | 2018-02-27 13:51:08 +0100 | [diff] [blame] | 422 | log_stream << "WebRTC.Video.MediaBitrateReceivedInKbps " |
| 423 | << media_bitrate_kbs << '\n'; |
asapersson | 1d02d3e | 2016-09-09 22:40:25 -0700 | [diff] [blame] | 424 | RTC_HISTOGRAM_COUNTS_10000( |
sprang | 0ab8e81 | 2016-02-24 01:35:40 -0800 | [diff] [blame] | 425 | "WebRTC.Video.PaddingBitrateReceivedInKbps", |
Niels Möller | d781965 | 2019-08-13 14:43:02 +0200 | [diff] [blame] | 426 | static_cast<int>(rtp_rtx_stats.transmitted.padding_bytes * 8 / |
| 427 | elapsed_sec / 1000)); |
asapersson | 1d02d3e | 2016-09-09 22:40:25 -0700 | [diff] [blame] | 428 | RTC_HISTOGRAM_COUNTS_10000( |
sprang | 0ab8e81 | 2016-02-24 01:35:40 -0800 | [diff] [blame] | 429 | "WebRTC.Video.RetransmittedBitrateReceivedInKbps", |
Niels Möller | d781965 | 2019-08-13 14:43:02 +0200 | [diff] [blame] | 430 | static_cast<int>(rtp_rtx_stats.retransmitted.TotalBytes() * 8 / |
| 431 | elapsed_sec / 1000)); |
| 432 | if (rtx_stats) { |
| 433 | RTC_HISTOGRAM_COUNTS_10000( |
| 434 | "WebRTC.Video.RtxBitrateReceivedInKbps", |
| 435 | static_cast<int>(rtx_stats->transmitted.TotalBytes() * 8 / |
| 436 | elapsed_sec / 1000)); |
sprang | 0ab8e81 | 2016-02-24 01:35:40 -0800 | [diff] [blame] | 437 | } |
sprang | 07fb9be | 2016-02-24 07:55:00 -0800 | [diff] [blame] | 438 | const RtcpPacketTypeCounter& counters = stats_.rtcp_packet_type_counts; |
asapersson | 1d02d3e | 2016-09-09 22:40:25 -0700 | [diff] [blame] | 439 | RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.NackPacketsSentPerMinute", |
| 440 | counters.nack_packets * 60 / elapsed_sec); |
| 441 | RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.FirPacketsSentPerMinute", |
| 442 | counters.fir_packets * 60 / elapsed_sec); |
| 443 | RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.PliPacketsSentPerMinute", |
| 444 | counters.pli_packets * 60 / elapsed_sec); |
sprang | 07fb9be | 2016-02-24 07:55:00 -0800 | [diff] [blame] | 445 | if (counters.nack_requests > 0) { |
asapersson | 1d02d3e | 2016-09-09 22:40:25 -0700 | [diff] [blame] | 446 | RTC_HISTOGRAM_PERCENTAGE("WebRTC.Video.UniqueNackRequestsSentInPercent", |
| 447 | counters.UniqueNackRequestsInPercent()); |
sprang | 07fb9be | 2016-02-24 07:55:00 -0800 | [diff] [blame] | 448 | } |
sprang | 0ab8e81 | 2016-02-24 01:35:40 -0800 | [diff] [blame] | 449 | } |
palmkvist | a40672a | 2017-01-13 05:58:34 -0800 | [diff] [blame] | 450 | |
| 451 | if (num_certain_states_ >= kBadCallMinRequiredSamples) { |
| 452 | RTC_HISTOGRAM_PERCENTAGE("WebRTC.Video.BadCall.Any", |
| 453 | 100 * num_bad_states_ / num_certain_states_); |
| 454 | } |
Danil Chapovalov | b9b146c | 2018-06-15 12:28:07 +0200 | [diff] [blame] | 455 | absl::optional<double> fps_fraction = |
palmkvist | a40672a | 2017-01-13 05:58:34 -0800 | [diff] [blame] | 456 | fps_threshold_.FractionHigh(kBadCallMinRequiredSamples); |
| 457 | if (fps_fraction) { |
| 458 | RTC_HISTOGRAM_PERCENTAGE("WebRTC.Video.BadCall.FrameRate", |
| 459 | static_cast<int>(100 * (1 - *fps_fraction))); |
| 460 | } |
Danil Chapovalov | b9b146c | 2018-06-15 12:28:07 +0200 | [diff] [blame] | 461 | absl::optional<double> variance_fraction = |
palmkvist | a40672a | 2017-01-13 05:58:34 -0800 | [diff] [blame] | 462 | variance_threshold_.FractionHigh(kBadCallMinRequiredSamples); |
| 463 | if (variance_fraction) { |
| 464 | RTC_HISTOGRAM_PERCENTAGE("WebRTC.Video.BadCall.FrameRateVariance", |
| 465 | static_cast<int>(100 * *variance_fraction)); |
| 466 | } |
Danil Chapovalov | b9b146c | 2018-06-15 12:28:07 +0200 | [diff] [blame] | 467 | absl::optional<double> qp_fraction = |
palmkvist | a40672a | 2017-01-13 05:58:34 -0800 | [diff] [blame] | 468 | qp_threshold_.FractionHigh(kBadCallMinRequiredSamples); |
| 469 | if (qp_fraction) { |
| 470 | RTC_HISTOGRAM_PERCENTAGE("WebRTC.Video.BadCall.Qp", |
| 471 | static_cast<int>(100 * *qp_fraction)); |
| 472 | } |
Tommi | fef0500 | 2018-02-27 13:51:08 +0100 | [diff] [blame] | 473 | |
| 474 | RTC_LOG(LS_INFO) << log_stream.str(); |
Niels Möller | 9a9f18a | 2019-08-02 13:52:37 +0200 | [diff] [blame] | 475 | video_quality_observer_->UpdateHistograms(); |
Åsa Persson | 3c391cb | 2015-04-27 10:09:49 +0200 | [diff] [blame] | 476 | } |
sprang@webrtc.org | 0931570 | 2014-02-07 12:06:29 +0000 | [diff] [blame] | 477 | |
palmkvist | 349092b | 2016-12-13 02:45:57 -0800 | [diff] [blame] | 478 | void ReceiveStatisticsProxy::QualitySample() { |
| 479 | int64_t now = clock_->TimeInMilliseconds(); |
| 480 | if (last_sample_time_ + kMinSampleLengthMs > now) |
| 481 | return; |
| 482 | |
| 483 | double fps = |
| 484 | render_fps_tracker_.ComputeRateForInterval(now - last_sample_time_); |
Danil Chapovalov | b9b146c | 2018-06-15 12:28:07 +0200 | [diff] [blame] | 485 | absl::optional<int> qp = qp_sample_.Avg(1); |
palmkvist | 349092b | 2016-12-13 02:45:57 -0800 | [diff] [blame] | 486 | |
| 487 | bool prev_fps_bad = !fps_threshold_.IsHigh().value_or(true); |
| 488 | bool prev_qp_bad = qp_threshold_.IsHigh().value_or(false); |
| 489 | bool prev_variance_bad = variance_threshold_.IsHigh().value_or(false); |
| 490 | bool prev_any_bad = prev_fps_bad || prev_qp_bad || prev_variance_bad; |
| 491 | |
| 492 | fps_threshold_.AddMeasurement(static_cast<int>(fps)); |
Ilya Nikolaevskiy | 0beed5d | 2018-05-22 10:54:30 +0200 | [diff] [blame] | 493 | if (qp) |
| 494 | qp_threshold_.AddMeasurement(*qp); |
Danil Chapovalov | b9b146c | 2018-06-15 12:28:07 +0200 | [diff] [blame] | 495 | absl::optional<double> fps_variance_opt = fps_threshold_.CalculateVariance(); |
palmkvist | 349092b | 2016-12-13 02:45:57 -0800 | [diff] [blame] | 496 | double fps_variance = fps_variance_opt.value_or(0); |
| 497 | if (fps_variance_opt) { |
| 498 | variance_threshold_.AddMeasurement(static_cast<int>(fps_variance)); |
| 499 | } |
| 500 | |
| 501 | bool fps_bad = !fps_threshold_.IsHigh().value_or(true); |
| 502 | bool qp_bad = qp_threshold_.IsHigh().value_or(false); |
| 503 | bool variance_bad = variance_threshold_.IsHigh().value_or(false); |
| 504 | bool any_bad = fps_bad || qp_bad || variance_bad; |
| 505 | |
| 506 | if (!prev_any_bad && any_bad) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 507 | RTC_LOG(LS_INFO) << "Bad call (any) start: " << now; |
palmkvist | 349092b | 2016-12-13 02:45:57 -0800 | [diff] [blame] | 508 | } else if (prev_any_bad && !any_bad) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 509 | RTC_LOG(LS_INFO) << "Bad call (any) end: " << now; |
palmkvist | 349092b | 2016-12-13 02:45:57 -0800 | [diff] [blame] | 510 | } |
| 511 | |
| 512 | if (!prev_fps_bad && fps_bad) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 513 | RTC_LOG(LS_INFO) << "Bad call (fps) start: " << now; |
palmkvist | 349092b | 2016-12-13 02:45:57 -0800 | [diff] [blame] | 514 | } else if (prev_fps_bad && !fps_bad) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 515 | RTC_LOG(LS_INFO) << "Bad call (fps) end: " << now; |
palmkvist | 349092b | 2016-12-13 02:45:57 -0800 | [diff] [blame] | 516 | } |
| 517 | |
| 518 | if (!prev_qp_bad && qp_bad) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 519 | RTC_LOG(LS_INFO) << "Bad call (qp) start: " << now; |
palmkvist | 349092b | 2016-12-13 02:45:57 -0800 | [diff] [blame] | 520 | } else if (prev_qp_bad && !qp_bad) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 521 | RTC_LOG(LS_INFO) << "Bad call (qp) end: " << now; |
palmkvist | 349092b | 2016-12-13 02:45:57 -0800 | [diff] [blame] | 522 | } |
| 523 | |
| 524 | if (!prev_variance_bad && variance_bad) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 525 | RTC_LOG(LS_INFO) << "Bad call (variance) start: " << now; |
palmkvist | 349092b | 2016-12-13 02:45:57 -0800 | [diff] [blame] | 526 | } else if (prev_variance_bad && !variance_bad) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 527 | RTC_LOG(LS_INFO) << "Bad call (variance) end: " << now; |
palmkvist | 349092b | 2016-12-13 02:45:57 -0800 | [diff] [blame] | 528 | } |
| 529 | |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 530 | RTC_LOG(LS_VERBOSE) << "SAMPLE: sample_length: " << (now - last_sample_time_) |
| 531 | << " fps: " << fps << " fps_bad: " << fps_bad |
Ilya Nikolaevskiy | 0beed5d | 2018-05-22 10:54:30 +0200 | [diff] [blame] | 532 | << " qp: " << qp.value_or(-1) << " qp_bad: " << qp_bad |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 533 | << " variance_bad: " << variance_bad |
| 534 | << " fps_variance: " << fps_variance; |
palmkvist | 349092b | 2016-12-13 02:45:57 -0800 | [diff] [blame] | 535 | |
| 536 | last_sample_time_ = now; |
| 537 | qp_sample_.Reset(); |
palmkvist | a40672a | 2017-01-13 05:58:34 -0800 | [diff] [blame] | 538 | |
| 539 | if (fps_threshold_.IsHigh() || variance_threshold_.IsHigh() || |
| 540 | qp_threshold_.IsHigh()) { |
| 541 | if (any_bad) |
| 542 | ++num_bad_states_; |
| 543 | ++num_certain_states_; |
| 544 | } |
palmkvist | 349092b | 2016-12-13 02:45:57 -0800 | [diff] [blame] | 545 | } |
| 546 | |
asapersson | 0255acb | 2017-03-28 02:44:58 -0700 | [diff] [blame] | 547 | void ReceiveStatisticsProxy::UpdateFramerate(int64_t now_ms) const { |
philipel | a45102f | 2017-02-22 05:30:39 -0800 | [diff] [blame] | 548 | int64_t old_frames_ms = now_ms - kRateStatisticsWindowSizeMs; |
| 549 | while (!frame_window_.empty() && |
| 550 | frame_window_.begin()->first < old_frames_ms) { |
philipel | a45102f | 2017-02-22 05:30:39 -0800 | [diff] [blame] | 551 | frame_window_.erase(frame_window_.begin()); |
| 552 | } |
| 553 | |
| 554 | size_t framerate = |
| 555 | (frame_window_.size() * 1000 + 500) / kRateStatisticsWindowSizeMs; |
philipel | a45102f | 2017-02-22 05:30:39 -0800 | [diff] [blame] | 556 | stats_.network_frame_rate = static_cast<int>(framerate); |
philipel | a45102f | 2017-02-22 05:30:39 -0800 | [diff] [blame] | 557 | } |
| 558 | |
Johannes Kron | e76b3ab | 2019-10-22 13:22:26 +0200 | [diff] [blame] | 559 | void ReceiveStatisticsProxy::UpdateDecodeTimeHistograms( |
| 560 | int width, |
| 561 | int height, |
| 562 | int decode_time_ms) const { |
| 563 | bool is_4k = (width == 3840 || width == 4096) && height == 2160; |
| 564 | bool is_hd = width == 1920 && height == 1080; |
| 565 | // Only update histograms for 4k/HD and VP9/H264. |
| 566 | if ((is_4k || is_hd) && (last_codec_type_ == kVideoCodecVP9 || |
| 567 | last_codec_type_ == kVideoCodecH264)) { |
| 568 | const std::string kDecodeTimeUmaPrefix = |
| 569 | "WebRTC.Video.DecodeTimePerFrameInMs."; |
| 570 | |
| 571 | // Each histogram needs its own line for it to not be reused in the wrong |
| 572 | // way when the format changes. |
| 573 | if (last_codec_type_ == kVideoCodecVP9) { |
| 574 | bool is_sw_decoder = |
| 575 | stats_.decoder_implementation_name.compare(0, 6, "libvpx") == 0; |
| 576 | if (is_4k) { |
| 577 | if (is_sw_decoder) |
| 578 | RTC_HISTOGRAM_COUNTS_1000(kDecodeTimeUmaPrefix + "Vp9.4k.Sw", |
| 579 | decode_time_ms); |
| 580 | else |
| 581 | RTC_HISTOGRAM_COUNTS_1000(kDecodeTimeUmaPrefix + "Vp9.4k.Hw", |
| 582 | decode_time_ms); |
| 583 | } else { |
| 584 | if (is_sw_decoder) |
| 585 | RTC_HISTOGRAM_COUNTS_1000(kDecodeTimeUmaPrefix + "Vp9.Hd.Sw", |
| 586 | decode_time_ms); |
| 587 | else |
| 588 | RTC_HISTOGRAM_COUNTS_1000(kDecodeTimeUmaPrefix + "Vp9.Hd.Hw", |
| 589 | decode_time_ms); |
| 590 | } |
| 591 | } else { |
| 592 | bool is_sw_decoder = |
| 593 | stats_.decoder_implementation_name.compare(0, 6, "FFmpeg") == 0; |
| 594 | if (is_4k) { |
| 595 | if (is_sw_decoder) |
| 596 | RTC_HISTOGRAM_COUNTS_1000(kDecodeTimeUmaPrefix + "H264.4k.Sw", |
| 597 | decode_time_ms); |
| 598 | else |
| 599 | RTC_HISTOGRAM_COUNTS_1000(kDecodeTimeUmaPrefix + "H264.4k.Hw", |
| 600 | decode_time_ms); |
| 601 | |
| 602 | } else { |
| 603 | if (is_sw_decoder) |
| 604 | RTC_HISTOGRAM_COUNTS_1000(kDecodeTimeUmaPrefix + "H264.Hd.Sw", |
| 605 | decode_time_ms); |
| 606 | else |
| 607 | RTC_HISTOGRAM_COUNTS_1000(kDecodeTimeUmaPrefix + "H264.Hd.Hw", |
| 608 | decode_time_ms); |
| 609 | } |
| 610 | } |
| 611 | } |
| 612 | } |
| 613 | |
Åsa Persson | fcf79cc | 2019-10-22 15:23:44 +0200 | [diff] [blame] | 614 | absl::optional<int64_t> |
| 615 | ReceiveStatisticsProxy::GetCurrentEstimatedPlayoutNtpTimestampMs( |
| 616 | int64_t now_ms) const { |
| 617 | if (!last_estimated_playout_ntp_timestamp_ms_ || |
| 618 | !last_estimated_playout_time_ms_) { |
| 619 | return absl::nullopt; |
| 620 | } |
| 621 | int64_t elapsed_ms = now_ms - *last_estimated_playout_time_ms_; |
| 622 | return *last_estimated_playout_ntp_timestamp_ms_ + elapsed_ms; |
| 623 | } |
| 624 | |
sprang@webrtc.org | 0931570 | 2014-02-07 12:06:29 +0000 | [diff] [blame] | 625 | VideoReceiveStream::Stats ReceiveStatisticsProxy::GetStats() const { |
Peter Boström | f2f8283 | 2015-05-01 13:00:41 +0200 | [diff] [blame] | 626 | rtc::CritScope lock(&crit_); |
sprang | 948b275 | 2017-05-04 02:47:13 -0700 | [diff] [blame] | 627 | // Get current frame rates here, as only updating them on new frames prevents |
| 628 | // us from ever correctly displaying frame rate of 0. |
| 629 | int64_t now_ms = clock_->TimeInMilliseconds(); |
| 630 | UpdateFramerate(now_ms); |
| 631 | stats_.render_frame_rate = renders_fps_estimator_.Rate(now_ms).value_or(0); |
| 632 | stats_.decode_frame_rate = decode_fps_estimator_.Rate(now_ms).value_or(0); |
ilnik | a79cc28 | 2017-08-23 05:24:10 -0700 | [diff] [blame] | 633 | stats_.interframe_delay_max_ms = |
| 634 | interframe_delay_max_moving_.Max(now_ms).value_or(-1); |
Sergey Silkin | 0237106 | 2019-01-31 16:45:42 +0100 | [diff] [blame] | 635 | stats_.freeze_count = video_quality_observer_->NumFreezes(); |
| 636 | stats_.pause_count = video_quality_observer_->NumPauses(); |
| 637 | stats_.total_freezes_duration_ms = |
| 638 | video_quality_observer_->TotalFreezesDurationMs(); |
| 639 | stats_.total_pauses_duration_ms = |
| 640 | video_quality_observer_->TotalPausesDurationMs(); |
| 641 | stats_.total_frames_duration_ms = |
| 642 | video_quality_observer_->TotalFramesDurationMs(); |
| 643 | stats_.sum_squared_frame_durations = |
| 644 | video_quality_observer_->SumSquaredFrameDurationsSec(); |
ilnik | 2e1b40b | 2017-09-04 07:57:17 -0700 | [diff] [blame] | 645 | stats_.content_type = last_content_type_; |
Sergey Silkin | 0237106 | 2019-01-31 16:45:42 +0100 | [diff] [blame] | 646 | stats_.timing_frame_info = timing_frame_info_counter_.Max(now_ms); |
Guido Urdaneta | 6737841 | 2019-05-28 17:38:08 +0200 | [diff] [blame] | 647 | stats_.jitter_buffer_delay_seconds = |
| 648 | static_cast<double>(current_delay_counter_.Sum(1).value_or(0)) / |
| 649 | rtc::kNumMillisecsPerSec; |
| 650 | stats_.jitter_buffer_emitted_count = current_delay_counter_.NumSamples(); |
Åsa Persson | fcf79cc | 2019-10-22 15:23:44 +0200 | [diff] [blame] | 651 | stats_.estimated_playout_ntp_timestamp_ms = |
| 652 | GetCurrentEstimatedPlayoutNtpTimestampMs(now_ms); |
pbos@webrtc.org | 5570769 | 2014-12-19 15:45:03 +0000 | [diff] [blame] | 653 | return stats_; |
sprang@webrtc.org | 0931570 | 2014-02-07 12:06:29 +0000 | [diff] [blame] | 654 | } |
| 655 | |
pbos | f42376c | 2015-08-28 07:35:32 -0700 | [diff] [blame] | 656 | void ReceiveStatisticsProxy::OnIncomingPayloadType(int payload_type) { |
| 657 | rtc::CritScope lock(&crit_); |
| 658 | stats_.current_payload_type = payload_type; |
| 659 | } |
| 660 | |
Peter Boström | b7d9a97 | 2015-12-18 16:01:11 +0100 | [diff] [blame] | 661 | void ReceiveStatisticsProxy::OnDecoderImplementationName( |
| 662 | const char* implementation_name) { |
| 663 | rtc::CritScope lock(&crit_); |
| 664 | stats_.decoder_implementation_name = implementation_name; |
| 665 | } |
sprang@webrtc.org | 0931570 | 2014-02-07 12:06:29 +0000 | [diff] [blame] | 666 | |
philipel | a45102f | 2017-02-22 05:30:39 -0800 | [diff] [blame] | 667 | void ReceiveStatisticsProxy::OnFrameBufferTimingsUpdated( |
philipel | a45102f | 2017-02-22 05:30:39 -0800 | [diff] [blame] | 668 | int max_decode_ms, |
| 669 | int current_delay_ms, |
| 670 | int target_delay_ms, |
| 671 | int jitter_buffer_ms, |
| 672 | int min_playout_delay_ms, |
| 673 | int render_delay_ms) { |
Peter Boström | f2f8283 | 2015-05-01 13:00:41 +0200 | [diff] [blame] | 674 | rtc::CritScope lock(&crit_); |
pbos@webrtc.org | 09c77b9 | 2015-02-25 10:42:16 +0000 | [diff] [blame] | 675 | stats_.max_decode_ms = max_decode_ms; |
| 676 | stats_.current_delay_ms = current_delay_ms; |
| 677 | stats_.target_delay_ms = target_delay_ms; |
| 678 | stats_.jitter_buffer_ms = jitter_buffer_ms; |
| 679 | stats_.min_playout_delay_ms = min_playout_delay_ms; |
| 680 | stats_.render_delay_ms = render_delay_ms; |
asapersson | 8688a4e | 2016-04-27 23:42:35 -0700 | [diff] [blame] | 681 | jitter_buffer_delay_counter_.Add(jitter_buffer_ms); |
| 682 | target_delay_counter_.Add(target_delay_ms); |
| 683 | current_delay_counter_.Add(current_delay_ms); |
asapersson | a186288 | 2016-04-18 00:41:05 -0700 | [diff] [blame] | 684 | // Network delay (rtt/2) + target_delay_ms (jitter delay + decode time + |
| 685 | // render delay). |
philipel | a45102f | 2017-02-22 05:30:39 -0800 | [diff] [blame] | 686 | delay_counter_.Add(target_delay_ms + avg_rtt_ms_ / 2); |
pbos@webrtc.org | 98c04b3 | 2014-12-18 13:12:52 +0000 | [diff] [blame] | 687 | } |
| 688 | |
Ilya Nikolaevskiy | d397a0d | 2018-02-21 15:57:09 +0100 | [diff] [blame] | 689 | void ReceiveStatisticsProxy::OnUniqueFramesCounted(int num_unique_frames) { |
| 690 | rtc::CritScope lock(&crit_); |
| 691 | num_unique_frames_.emplace(num_unique_frames); |
| 692 | } |
| 693 | |
ilnik | 2edc684 | 2017-07-06 03:06:50 -0700 | [diff] [blame] | 694 | void ReceiveStatisticsProxy::OnTimingFrameInfoUpdated( |
| 695 | const TimingFrameInfo& info) { |
| 696 | rtc::CritScope lock(&crit_); |
Benjamin Wright | 3f10ca8 | 2018-12-07 03:45:19 -0800 | [diff] [blame] | 697 | if (info.flags != VideoSendTiming::kInvalid) { |
| 698 | int64_t now_ms = clock_->TimeInMilliseconds(); |
| 699 | timing_frame_info_counter_.Add(info, now_ms); |
| 700 | } |
Benjamin Wright | 514f084 | 2018-12-10 09:55:17 -0800 | [diff] [blame] | 701 | |
| 702 | // Measure initial decoding latency between the first frame arriving and the |
| 703 | // first frame being decoded. |
| 704 | if (!first_frame_received_time_ms_.has_value()) { |
| 705 | first_frame_received_time_ms_ = info.receive_finish_ms; |
| 706 | } |
| 707 | if (stats_.first_frame_received_to_decoded_ms == -1 && |
| 708 | first_decoded_frame_time_ms_) { |
| 709 | stats_.first_frame_received_to_decoded_ms = |
| 710 | *first_decoded_frame_time_ms_ - *first_frame_received_time_ms_; |
| 711 | } |
ilnik | 2edc684 | 2017-07-06 03:06:50 -0700 | [diff] [blame] | 712 | } |
| 713 | |
pbos@webrtc.org | 1d0fa5d | 2015-02-19 12:47:00 +0000 | [diff] [blame] | 714 | void ReceiveStatisticsProxy::RtcpPacketTypesCounterUpdated( |
| 715 | uint32_t ssrc, |
| 716 | const RtcpPacketTypeCounter& packet_counter) { |
Peter Boström | f2f8283 | 2015-05-01 13:00:41 +0200 | [diff] [blame] | 717 | rtc::CritScope lock(&crit_); |
pbos@webrtc.org | 1d0fa5d | 2015-02-19 12:47:00 +0000 | [diff] [blame] | 718 | if (stats_.ssrc != ssrc) |
| 719 | return; |
| 720 | stats_.rtcp_packet_type_counts = packet_counter; |
| 721 | } |
| 722 | |
Niels Möller | 4d7c405 | 2019-08-05 12:45:19 +0200 | [diff] [blame] | 723 | void ReceiveStatisticsProxy::OnCname(uint32_t ssrc, absl::string_view cname) { |
Peter Boström | f2f8283 | 2015-05-01 13:00:41 +0200 | [diff] [blame] | 724 | rtc::CritScope lock(&crit_); |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 725 | // TODO(pbos): Handle both local and remote ssrcs here and RTC_DCHECK that we |
pbos@webrtc.org | 1d0fa5d | 2015-02-19 12:47:00 +0000 | [diff] [blame] | 726 | // receive stats from one of them. |
| 727 | if (stats_.ssrc != ssrc) |
| 728 | return; |
Niels Möller | 4d7c405 | 2019-08-05 12:45:19 +0200 | [diff] [blame] | 729 | stats_.c_name = std::string(cname); |
pbos@webrtc.org | ce4e9a3 | 2014-12-18 13:50:16 +0000 | [diff] [blame] | 730 | } |
| 731 | |
Sergey Silkin | 278f825 | 2019-01-09 14:37:40 +0100 | [diff] [blame] | 732 | void ReceiveStatisticsProxy::OnDecodedFrame(const VideoFrame& frame, |
| 733 | absl::optional<uint8_t> qp, |
Johannes Kron | bfd343b | 2019-07-01 10:07:50 +0200 | [diff] [blame] | 734 | int32_t decode_time_ms, |
Ilya Nikolaevskiy | 94150ee | 2018-05-23 11:53:19 +0200 | [diff] [blame] | 735 | VideoContentType content_type) { |
Peter Boström | f2f8283 | 2015-05-01 13:00:41 +0200 | [diff] [blame] | 736 | rtc::CritScope lock(&crit_); |
ilnik | 6d5b4d6 | 2017-08-30 03:32:14 -0700 | [diff] [blame] | 737 | |
Sergey Silkin | 278f825 | 2019-01-09 14:37:40 +0100 | [diff] [blame] | 738 | uint64_t now_ms = clock_->TimeInMilliseconds(); |
Ilya Nikolaevskiy | 3f670e0 | 2017-10-10 11:18:49 +0200 | [diff] [blame] | 739 | |
Ilya Nikolaevskiy | 94150ee | 2018-05-23 11:53:19 +0200 | [diff] [blame] | 740 | if (videocontenttypehelpers::IsScreenshare(content_type) != |
| 741 | videocontenttypehelpers::IsScreenshare(last_content_type_)) { |
Niels Möller | 9a9f18a | 2019-08-02 13:52:37 +0200 | [diff] [blame] | 742 | // Reset the quality observer if content type is switched. But first report |
| 743 | // stats for the previous part of the call. |
| 744 | video_quality_observer_->UpdateHistograms(); |
Ilya Nikolaevskiy | 94150ee | 2018-05-23 11:53:19 +0200 | [diff] [blame] | 745 | video_quality_observer_.reset(new VideoQualityObserver(content_type)); |
| 746 | } |
| 747 | |
Sergey Silkin | 278f825 | 2019-01-09 14:37:40 +0100 | [diff] [blame] | 748 | video_quality_observer_->OnDecodedFrame(frame, qp, last_codec_type_); |
Ilya Nikolaevskiy | 94150ee | 2018-05-23 11:53:19 +0200 | [diff] [blame] | 749 | |
ilnik | 6d5b4d6 | 2017-08-30 03:32:14 -0700 | [diff] [blame] | 750 | ContentSpecificStats* content_specific_stats = |
| 751 | &content_specific_stats_[content_type]; |
sakal | e5ba44e | 2016-10-26 07:09:24 -0700 | [diff] [blame] | 752 | ++stats_.frames_decoded; |
sakal | cc452e1 | 2017-02-09 04:53:45 -0800 | [diff] [blame] | 753 | if (qp) { |
| 754 | if (!stats_.qp_sum) { |
| 755 | if (stats_.frames_decoded != 1) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 756 | RTC_LOG(LS_WARNING) |
sakal | cc452e1 | 2017-02-09 04:53:45 -0800 | [diff] [blame] | 757 | << "Frames decoded was not 1 when first qp value was received."; |
sakal | cc452e1 | 2017-02-09 04:53:45 -0800 | [diff] [blame] | 758 | } |
Oskar Sundbom | 8e07c13 | 2018-01-08 16:45:42 +0100 | [diff] [blame] | 759 | stats_.qp_sum = 0; |
sakal | cc452e1 | 2017-02-09 04:53:45 -0800 | [diff] [blame] | 760 | } |
| 761 | *stats_.qp_sum += *qp; |
ilnik | 6d5b4d6 | 2017-08-30 03:32:14 -0700 | [diff] [blame] | 762 | content_specific_stats->qp_counter.Add(*qp); |
sakal | cc452e1 | 2017-02-09 04:53:45 -0800 | [diff] [blame] | 763 | } else if (stats_.qp_sum) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 764 | RTC_LOG(LS_WARNING) |
sakal | cc452e1 | 2017-02-09 04:53:45 -0800 | [diff] [blame] | 765 | << "QP sum was already set and no QP was given for a frame."; |
Mirta Dvornicic | 608083b | 2019-10-03 15:52:36 +0200 | [diff] [blame] | 766 | stats_.qp_sum.reset(); |
sakal | cc452e1 | 2017-02-09 04:53:45 -0800 | [diff] [blame] | 767 | } |
Johannes Kron | bfd343b | 2019-07-01 10:07:50 +0200 | [diff] [blame] | 768 | decode_time_counter_.Add(decode_time_ms); |
| 769 | stats_.decode_ms = decode_time_ms; |
| 770 | stats_.total_decode_time_ms += decode_time_ms; |
Johannes Kron | e76b3ab | 2019-10-22 13:22:26 +0200 | [diff] [blame] | 771 | if (enable_decode_time_histograms_) { |
| 772 | UpdateDecodeTimeHistograms(frame.width(), frame.height(), decode_time_ms); |
| 773 | } |
| 774 | |
ilnik | 00d802b | 2017-04-11 10:34:31 -0700 | [diff] [blame] | 775 | last_content_type_ = content_type; |
Sergey Silkin | 278f825 | 2019-01-09 14:37:40 +0100 | [diff] [blame] | 776 | decode_fps_estimator_.Update(1, now_ms); |
ilnik | 4257ab2 | 2017-07-03 01:15:58 -0700 | [diff] [blame] | 777 | if (last_decoded_frame_time_ms_) { |
Sergey Silkin | 278f825 | 2019-01-09 14:37:40 +0100 | [diff] [blame] | 778 | int64_t interframe_delay_ms = now_ms - *last_decoded_frame_time_ms_; |
ilnik | 4257ab2 | 2017-07-03 01:15:58 -0700 | [diff] [blame] | 779 | RTC_DCHECK_GE(interframe_delay_ms, 0); |
Johannes Kron | 00376e1 | 2019-11-25 10:25:42 +0100 | [diff] [blame] | 780 | double interframe_delay = interframe_delay_ms / 1000.0; |
| 781 | stats_.total_inter_frame_delay += interframe_delay; |
| 782 | stats_.total_squared_inter_frame_delay += |
| 783 | interframe_delay * interframe_delay; |
Sergey Silkin | 278f825 | 2019-01-09 14:37:40 +0100 | [diff] [blame] | 784 | interframe_delay_max_moving_.Add(interframe_delay_ms, now_ms); |
ilnik | 6d5b4d6 | 2017-08-30 03:32:14 -0700 | [diff] [blame] | 785 | content_specific_stats->interframe_delay_counter.Add(interframe_delay_ms); |
Ilya Nikolaevskiy | daa4f7a | 2017-10-06 12:29:47 +0200 | [diff] [blame] | 786 | content_specific_stats->interframe_delay_percentiles.Add( |
| 787 | interframe_delay_ms); |
ilnik | 6d5b4d6 | 2017-08-30 03:32:14 -0700 | [diff] [blame] | 788 | content_specific_stats->flow_duration_ms += interframe_delay_ms; |
ilnik | 4257ab2 | 2017-07-03 01:15:58 -0700 | [diff] [blame] | 789 | } |
Benjamin Wright | 514f084 | 2018-12-10 09:55:17 -0800 | [diff] [blame] | 790 | if (stats_.frames_decoded == 1) { |
Sergey Silkin | 278f825 | 2019-01-09 14:37:40 +0100 | [diff] [blame] | 791 | first_decoded_frame_time_ms_.emplace(now_ms); |
Benjamin Wright | 514f084 | 2018-12-10 09:55:17 -0800 | [diff] [blame] | 792 | } |
Sergey Silkin | 278f825 | 2019-01-09 14:37:40 +0100 | [diff] [blame] | 793 | last_decoded_frame_time_ms_.emplace(now_ms); |
sprang@webrtc.org | 0931570 | 2014-02-07 12:06:29 +0000 | [diff] [blame] | 794 | } |
| 795 | |
asapersson | 1490f7a | 2016-09-23 02:09:46 -0700 | [diff] [blame] | 796 | void ReceiveStatisticsProxy::OnRenderedFrame(const VideoFrame& frame) { |
| 797 | int width = frame.width(); |
| 798 | int height = frame.height(); |
asapersson | f839dcc | 2015-10-08 00:41:59 -0700 | [diff] [blame] | 799 | RTC_DCHECK_GT(width, 0); |
| 800 | RTC_DCHECK_GT(height, 0); |
Åsa Persson | 81327d5 | 2018-06-05 13:34:33 +0200 | [diff] [blame] | 801 | int64_t now_ms = clock_->TimeInMilliseconds(); |
Peter Boström | f2f8283 | 2015-05-01 13:00:41 +0200 | [diff] [blame] | 802 | rtc::CritScope lock(&crit_); |
Ilya Nikolaevskiy | cdc959f | 2018-10-10 13:15:09 +0200 | [diff] [blame] | 803 | |
Sergey Silkin | 278f825 | 2019-01-09 14:37:40 +0100 | [diff] [blame] | 804 | video_quality_observer_->OnRenderedFrame(frame, now_ms); |
Ilya Nikolaevskiy | cdc959f | 2018-10-10 13:15:09 +0200 | [diff] [blame] | 805 | |
ilnik | 6d5b4d6 | 2017-08-30 03:32:14 -0700 | [diff] [blame] | 806 | ContentSpecificStats* content_specific_stats = |
| 807 | &content_specific_stats_[last_content_type_]; |
Åsa Persson | 81327d5 | 2018-06-05 13:34:33 +0200 | [diff] [blame] | 808 | renders_fps_estimator_.Update(1, now_ms); |
hbos | 50cfe1f | 2017-01-23 07:21:55 -0800 | [diff] [blame] | 809 | ++stats_.frames_rendered; |
asapersson | 2e5cfcd | 2016-08-11 08:41:18 -0700 | [diff] [blame] | 810 | stats_.width = width; |
| 811 | stats_.height = height; |
Tim Psiaki | 6304626 | 2015-09-14 10:38:08 -0700 | [diff] [blame] | 812 | render_fps_tracker_.AddSamples(1); |
asapersson | f839dcc | 2015-10-08 00:41:59 -0700 | [diff] [blame] | 813 | render_pixel_tracker_.AddSamples(sqrt(width * height)); |
ilnik | 6d5b4d6 | 2017-08-30 03:32:14 -0700 | [diff] [blame] | 814 | content_specific_stats->received_width.Add(width); |
| 815 | content_specific_stats->received_height.Add(height); |
asapersson | 1490f7a | 2016-09-23 02:09:46 -0700 | [diff] [blame] | 816 | |
Åsa Persson | 81327d5 | 2018-06-05 13:34:33 +0200 | [diff] [blame] | 817 | // Consider taking stats_.render_delay_ms into account. |
| 818 | const int64_t time_until_rendering_ms = frame.render_time_ms() - now_ms; |
| 819 | if (time_until_rendering_ms < 0) { |
| 820 | sum_missed_render_deadline_ms_ += -time_until_rendering_ms; |
| 821 | ++num_delayed_frames_rendered_; |
| 822 | } |
| 823 | |
asapersson | 1490f7a | 2016-09-23 02:09:46 -0700 | [diff] [blame] | 824 | if (frame.ntp_time_ms() > 0) { |
| 825 | int64_t delay_ms = clock_->CurrentNtpInMilliseconds() - frame.ntp_time_ms(); |
ilnik | 00d802b | 2017-04-11 10:34:31 -0700 | [diff] [blame] | 826 | if (delay_ms >= 0) { |
ilnik | 6d5b4d6 | 2017-08-30 03:32:14 -0700 | [diff] [blame] | 827 | content_specific_stats->e2e_delay_counter.Add(delay_ms); |
ilnik | 00d802b | 2017-04-11 10:34:31 -0700 | [diff] [blame] | 828 | } |
asapersson | 1490f7a | 2016-09-23 02:09:46 -0700 | [diff] [blame] | 829 | } |
Niels Möller | 9b0b1e0 | 2019-03-22 13:56:46 +0100 | [diff] [blame] | 830 | QualitySample(); |
sprang@webrtc.org | 0931570 | 2014-02-07 12:06:29 +0000 | [diff] [blame] | 831 | } |
| 832 | |
Åsa Persson | fcf79cc | 2019-10-22 15:23:44 +0200 | [diff] [blame] | 833 | void ReceiveStatisticsProxy::OnSyncOffsetUpdated(int64_t video_playout_ntp_ms, |
| 834 | int64_t sync_offset_ms, |
asapersson | de9e5ff | 2016-11-02 07:14:03 -0700 | [diff] [blame] | 835 | double estimated_freq_khz) { |
asapersson | f8cdd18 | 2016-03-15 01:00:47 -0700 | [diff] [blame] | 836 | rtc::CritScope lock(&crit_); |
| 837 | sync_offset_counter_.Add(std::abs(sync_offset_ms)); |
| 838 | stats_.sync_offset_ms = sync_offset_ms; |
Åsa Persson | fcf79cc | 2019-10-22 15:23:44 +0200 | [diff] [blame] | 839 | last_estimated_playout_ntp_timestamp_ms_ = video_playout_ntp_ms; |
| 840 | last_estimated_playout_time_ms_ = clock_->TimeInMilliseconds(); |
asapersson | de9e5ff | 2016-11-02 07:14:03 -0700 | [diff] [blame] | 841 | |
| 842 | const double kMaxFreqKhz = 10000.0; |
| 843 | int offset_khz = kMaxFreqKhz; |
| 844 | // Should not be zero or negative. If so, report max. |
| 845 | if (estimated_freq_khz < kMaxFreqKhz && estimated_freq_khz > 0.0) |
| 846 | offset_khz = static_cast<int>(std::fabs(estimated_freq_khz - 90.0) + 0.5); |
| 847 | |
| 848 | freq_offset_counter_.Add(offset_khz); |
asapersson | f8cdd18 | 2016-03-15 01:00:47 -0700 | [diff] [blame] | 849 | } |
| 850 | |
philipel | a45102f | 2017-02-22 05:30:39 -0800 | [diff] [blame] | 851 | void ReceiveStatisticsProxy::OnCompleteFrame(bool is_keyframe, |
ilnik | 6d5b4d6 | 2017-08-30 03:32:14 -0700 | [diff] [blame] | 852 | size_t size_bytes, |
| 853 | VideoContentType content_type) { |
philipel | a45102f | 2017-02-22 05:30:39 -0800 | [diff] [blame] | 854 | rtc::CritScope lock(&crit_); |
ilnik | 6d5b4d6 | 2017-08-30 03:32:14 -0700 | [diff] [blame] | 855 | if (is_keyframe) { |
philipel | a45102f | 2017-02-22 05:30:39 -0800 | [diff] [blame] | 856 | ++stats_.frame_counts.key_frames; |
ilnik | 6d5b4d6 | 2017-08-30 03:32:14 -0700 | [diff] [blame] | 857 | } else { |
philipel | a45102f | 2017-02-22 05:30:39 -0800 | [diff] [blame] | 858 | ++stats_.frame_counts.delta_frames; |
ilnik | 6d5b4d6 | 2017-08-30 03:32:14 -0700 | [diff] [blame] | 859 | } |
| 860 | |
Ilya Nikolaevskiy | f203d73 | 2018-10-17 14:41:52 +0200 | [diff] [blame] | 861 | // Content type extension is set only for keyframes and should be propagated |
| 862 | // for all the following delta frames. Here we may receive frames out of order |
| 863 | // and miscategorise some delta frames near the layer switch. |
| 864 | // This may slightly offset calculated bitrate and keyframes permille metrics. |
| 865 | VideoContentType propagated_content_type = |
| 866 | is_keyframe ? content_type : last_content_type_; |
| 867 | |
ilnik | 6d5b4d6 | 2017-08-30 03:32:14 -0700 | [diff] [blame] | 868 | ContentSpecificStats* content_specific_stats = |
Ilya Nikolaevskiy | f203d73 | 2018-10-17 14:41:52 +0200 | [diff] [blame] | 869 | &content_specific_stats_[propagated_content_type]; |
ilnik | 6d5b4d6 | 2017-08-30 03:32:14 -0700 | [diff] [blame] | 870 | |
| 871 | content_specific_stats->total_media_bytes += size_bytes; |
| 872 | if (is_keyframe) { |
| 873 | ++content_specific_stats->frame_counts.key_frames; |
| 874 | } else { |
| 875 | ++content_specific_stats->frame_counts.delta_frames; |
| 876 | } |
philipel | a45102f | 2017-02-22 05:30:39 -0800 | [diff] [blame] | 877 | |
| 878 | int64_t now_ms = clock_->TimeInMilliseconds(); |
philipel | a45102f | 2017-02-22 05:30:39 -0800 | [diff] [blame] | 879 | frame_window_.insert(std::make_pair(now_ms, size_bytes)); |
asapersson | 0255acb | 2017-03-28 02:44:58 -0700 | [diff] [blame] | 880 | UpdateFramerate(now_ms); |
philipel | a45102f | 2017-02-22 05:30:39 -0800 | [diff] [blame] | 881 | } |
| 882 | |
Johannes Kron | 0c141c5 | 2019-08-26 15:04:43 +0200 | [diff] [blame] | 883 | void ReceiveStatisticsProxy::OnDroppedFrames(uint32_t frames_dropped) { |
| 884 | rtc::CritScope lock(&crit_); |
| 885 | stats_.frames_dropped += frames_dropped; |
| 886 | } |
| 887 | |
Niels Möller | 147013a | 2018-10-01 15:56:33 +0200 | [diff] [blame] | 888 | void ReceiveStatisticsProxy::OnPreDecode(VideoCodecType codec_type, int qp) { |
Tommi | 132e28e | 2018-02-24 17:57:33 +0100 | [diff] [blame] | 889 | RTC_DCHECK_RUN_ON(&decode_thread_); |
Ilya Nikolaevskiy | 94150ee | 2018-05-23 11:53:19 +0200 | [diff] [blame] | 890 | rtc::CritScope lock(&crit_); |
Niels Möller | 147013a | 2018-10-01 15:56:33 +0200 | [diff] [blame] | 891 | last_codec_type_ = codec_type; |
| 892 | if (last_codec_type_ == kVideoCodecVP8 && qp != -1) { |
| 893 | qp_counters_.vp8.Add(qp); |
| 894 | qp_sample_.Add(qp); |
asapersson | 86b0160 | 2015-10-20 23:55:26 -0700 | [diff] [blame] | 895 | } |
| 896 | } |
| 897 | |
sprang | 3e86e7e | 2017-08-22 09:23:28 -0700 | [diff] [blame] | 898 | void ReceiveStatisticsProxy::OnStreamInactive() { |
| 899 | // TODO(sprang): Figure out any other state that should be reset. |
| 900 | |
| 901 | rtc::CritScope lock(&crit_); |
| 902 | // Don't report inter-frame delay if stream was paused. |
| 903 | last_decoded_frame_time_ms_.reset(); |
Ilya Nikolaevskiy | 94150ee | 2018-05-23 11:53:19 +0200 | [diff] [blame] | 904 | video_quality_observer_->OnStreamInactive(); |
sprang | 3e86e7e | 2017-08-22 09:23:28 -0700 | [diff] [blame] | 905 | } |
| 906 | |
philipel | a45102f | 2017-02-22 05:30:39 -0800 | [diff] [blame] | 907 | void ReceiveStatisticsProxy::OnRttUpdate(int64_t avg_rtt_ms, |
| 908 | int64_t max_rtt_ms) { |
| 909 | rtc::CritScope lock(&crit_); |
| 910 | avg_rtt_ms_ = avg_rtt_ms; |
| 911 | } |
| 912 | |
Tommi | 132e28e | 2018-02-24 17:57:33 +0100 | [diff] [blame] | 913 | void ReceiveStatisticsProxy::DecoderThreadStarting() { |
| 914 | RTC_DCHECK_RUN_ON(&main_thread_); |
| 915 | } |
| 916 | |
| 917 | void ReceiveStatisticsProxy::DecoderThreadStopped() { |
| 918 | RTC_DCHECK_RUN_ON(&main_thread_); |
Sebastian Jansson | c01367d | 2019-04-08 15:20:44 +0200 | [diff] [blame] | 919 | decode_thread_.Detach(); |
Tommi | 132e28e | 2018-02-24 17:57:33 +0100 | [diff] [blame] | 920 | } |
| 921 | |
Ilya Nikolaevskiy | daa4f7a | 2017-10-06 12:29:47 +0200 | [diff] [blame] | 922 | ReceiveStatisticsProxy::ContentSpecificStats::ContentSpecificStats() |
| 923 | : interframe_delay_percentiles(kMaxCommonInterframeDelayMs) {} |
| 924 | |
Mirko Bonadei | 8fdcac3 | 2018-08-28 16:30:18 +0200 | [diff] [blame] | 925 | ReceiveStatisticsProxy::ContentSpecificStats::~ContentSpecificStats() = default; |
| 926 | |
ilnik | 6d5b4d6 | 2017-08-30 03:32:14 -0700 | [diff] [blame] | 927 | void ReceiveStatisticsProxy::ContentSpecificStats::Add( |
| 928 | const ContentSpecificStats& other) { |
| 929 | e2e_delay_counter.Add(other.e2e_delay_counter); |
| 930 | interframe_delay_counter.Add(other.interframe_delay_counter); |
| 931 | flow_duration_ms += other.flow_duration_ms; |
| 932 | total_media_bytes += other.total_media_bytes; |
| 933 | received_height.Add(other.received_height); |
| 934 | received_width.Add(other.received_width); |
| 935 | qp_counter.Add(other.qp_counter); |
| 936 | frame_counts.key_frames += other.frame_counts.key_frames; |
| 937 | frame_counts.delta_frames += other.frame_counts.delta_frames; |
Ilya Nikolaevskiy | daa4f7a | 2017-10-06 12:29:47 +0200 | [diff] [blame] | 938 | interframe_delay_percentiles.Add(other.interframe_delay_percentiles); |
ilnik | 6d5b4d6 | 2017-08-30 03:32:14 -0700 | [diff] [blame] | 939 | } |
sprang@webrtc.org | 0931570 | 2014-02-07 12:06:29 +0000 | [diff] [blame] | 940 | } // namespace webrtc |