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