sprang@webrtc.org | ccd4284 | 2014-01-07 09:54:34 +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 | #ifndef VIDEO_SEND_STATISTICS_PROXY_H_ |
| 12 | #define VIDEO_SEND_STATISTICS_PROXY_H_ |
sprang@webrtc.org | ccd4284 | 2014-01-07 09:54:34 +0000 | [diff] [blame] | 13 | |
Evan Shrubsole | cc62b16 | 2019-09-09 11:26:45 +0200 | [diff] [blame] | 14 | #include <array> |
mflodman | d1590b2 | 2015-12-09 07:07:59 -0800 | [diff] [blame] | 15 | #include <map> |
kwiberg | 27f982b | 2016-03-01 11:52:33 -0800 | [diff] [blame] | 16 | #include <memory> |
sprang@webrtc.org | ccd4284 | 2014-01-07 09:54:34 +0000 | [diff] [blame] | 17 | #include <string> |
Per | a48ddb7 | 2016-09-29 11:48:50 +0200 | [diff] [blame] | 18 | #include <vector> |
sprang@webrtc.org | ccd4284 | 2014-01-07 09:54:34 +0000 | [diff] [blame] | 19 | |
Evan Shrubsole | cc62b16 | 2019-09-09 11:26:45 +0200 | [diff] [blame] | 20 | #include "api/video/video_codec_constants.h" |
Niels Möller | 213618e | 2018-07-24 09:29:58 +0200 | [diff] [blame] | 21 | #include "api/video/video_stream_encoder_observer.h" |
Evan Shrubsole | cc62b16 | 2019-09-09 11:26:45 +0200 | [diff] [blame] | 22 | #include "api/video_codecs/video_encoder_config.h" |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 23 | #include "call/video_send_stream.h" |
Danil Chapovalov | 7c06777 | 2019-10-07 12:56:24 +0200 | [diff] [blame] | 24 | #include "modules/include/module_common_types_public.h" |
Henrik Boström | 87e3f9d | 2019-05-27 10:44:24 +0200 | [diff] [blame] | 25 | #include "modules/rtp_rtcp/include/report_block_data.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 26 | #include "modules/video_coding/include/video_codec_interface.h" |
| 27 | #include "modules/video_coding/include/video_coding_defines.h" |
Steve Anton | 10542f2 | 2019-01-11 09:11:00 -0800 | [diff] [blame] | 28 | #include "rtc_base/critical_section.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 29 | #include "rtc_base/numerics/exp_filter.h" |
Steve Anton | 10542f2 | 2019-01-11 09:11:00 -0800 | [diff] [blame] | 30 | #include "rtc_base/rate_tracker.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 31 | #include "rtc_base/thread_annotations.h" |
| 32 | #include "system_wrappers/include/clock.h" |
Henrik Boström | ce33b6a | 2019-05-28 17:42:38 +0200 | [diff] [blame] | 33 | #include "video/quality_limitation_reason_tracker.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 34 | #include "video/report_block_stats.h" |
| 35 | #include "video/stats_counter.h" |
sprang@webrtc.org | ccd4284 | 2014-01-07 09:54:34 +0000 | [diff] [blame] | 36 | |
| 37 | namespace webrtc { |
| 38 | |
Niels Möller | 213618e | 2018-07-24 09:29:58 +0200 | [diff] [blame] | 39 | class SendStatisticsProxy : public VideoStreamEncoderObserver, |
pbos@webrtc.org | 3e6e271 | 2015-02-26 12:19:31 +0000 | [diff] [blame] | 40 | public RtcpStatisticsCallback, |
Henrik Boström | 87e3f9d | 2019-05-27 10:44:24 +0200 | [diff] [blame] | 41 | public ReportBlockDataObserver, |
pbos@webrtc.org | 1d0fa5d | 2015-02-19 12:47:00 +0000 | [diff] [blame] | 42 | public RtcpPacketTypeCounterObserver, |
sprang@webrtc.org | ccd4284 | 2014-01-07 09:54:34 +0000 | [diff] [blame] | 43 | public StreamDataCountersCallback, |
| 44 | public BitrateStatisticsObserver, |
| 45 | public FrameCountObserver, |
stefan@webrtc.org | 168f23f | 2014-07-11 13:44:02 +0000 | [diff] [blame] | 46 | public SendSideDelayObserver { |
sprang@webrtc.org | ccd4284 | 2014-01-07 09:54:34 +0000 | [diff] [blame] | 47 | public: |
pbos@webrtc.org | 273a414 | 2014-12-01 15:23:21 +0000 | [diff] [blame] | 48 | static const int kStatsTimeoutMs; |
perkj | 803d97f | 2016-11-01 11:45:46 -0700 | [diff] [blame] | 49 | // Number of required samples to be collected before a metric is added |
| 50 | // to a rtc histogram. |
| 51 | static const int kMinRequiredMetricsSamples = 200; |
pbos@webrtc.org | 273a414 | 2014-12-01 15:23:21 +0000 | [diff] [blame] | 52 | |
sprang | b4a1ae5 | 2015-12-03 08:10:08 -0800 | [diff] [blame] | 53 | SendStatisticsProxy(Clock* clock, |
| 54 | const VideoSendStream::Config& config, |
| 55 | VideoEncoderConfig::ContentType content_type); |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 56 | ~SendStatisticsProxy() override; |
sprang@webrtc.org | ccd4284 | 2014-01-07 09:54:34 +0000 | [diff] [blame] | 57 | |
sprang | c5d62e2 | 2017-04-02 23:53:04 -0700 | [diff] [blame] | 58 | virtual VideoSendStream::Stats GetStats(); |
pbos@webrtc.org | 273a414 | 2014-12-01 15:23:21 +0000 | [diff] [blame] | 59 | |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 60 | void OnSendEncodedImage(const EncodedImage& encoded_image, |
Niels Möller | 213618e | 2018-07-24 09:29:58 +0200 | [diff] [blame] | 61 | const CodecSpecificInfo* codec_info) override; |
Erik Språng | e2fd86a | 2018-10-24 11:32:39 +0200 | [diff] [blame] | 62 | |
| 63 | void OnEncoderImplementationChanged( |
| 64 | const std::string& implementation_name) override; |
| 65 | |
perkj@webrtc.org | af612d5 | 2015-03-18 09:51:05 +0000 | [diff] [blame] | 66 | // Used to update incoming frame rate. |
Niels Möller | 213618e | 2018-07-24 09:29:58 +0200 | [diff] [blame] | 67 | void OnIncomingFrame(int width, int height) override; |
sprang@webrtc.org | ccd4284 | 2014-01-07 09:54:34 +0000 | [diff] [blame] | 68 | |
Ilya Nikolaevskiy | d79314f | 2017-10-23 10:45:37 +0200 | [diff] [blame] | 69 | // Dropped frame stats. |
Niels Möller | 213618e | 2018-07-24 09:29:58 +0200 | [diff] [blame] | 70 | void OnFrameDropped(DropReason) override; |
Ilya Nikolaevskiy | d79314f | 2017-10-23 10:45:37 +0200 | [diff] [blame] | 71 | |
asapersson | 09f0561 | 2017-05-15 23:40:18 -0700 | [diff] [blame] | 72 | // Adaptation stats. |
Niels Möller | 213618e | 2018-07-24 09:29:58 +0200 | [diff] [blame] | 73 | void OnAdaptationChanged(AdaptationReason reason, |
| 74 | const AdaptationSteps& cpu_counts, |
| 75 | const AdaptationSteps& quality_counts) override; |
perkj | 803d97f | 2016-11-01 11:45:46 -0700 | [diff] [blame] | 76 | |
Evan Shrubsole | cc62b16 | 2019-09-09 11:26:45 +0200 | [diff] [blame] | 77 | void OnBitrateAllocationUpdated( |
| 78 | const VideoCodec& codec, |
| 79 | const VideoBitrateAllocation& allocation) override; |
| 80 | |
Niels Möller | 213618e | 2018-07-24 09:29:58 +0200 | [diff] [blame] | 81 | void OnMinPixelLimitReached() override; |
| 82 | void OnInitialQualityResolutionAdaptDown() override; |
| 83 | |
| 84 | void OnSuspendChange(bool is_suspended) override; |
Peter Boström | 20f3f94 | 2015-05-15 11:33:39 +0200 | [diff] [blame] | 85 | void OnInactiveSsrc(uint32_t ssrc); |
| 86 | |
sprang | b4a1ae5 | 2015-12-03 08:10:08 -0800 | [diff] [blame] | 87 | // Used to indicate change in content type, which may require a change in |
Niels Möller | 97e0488 | 2018-05-25 09:43:26 +0200 | [diff] [blame] | 88 | // how stats are collected. |
Per | a48ddb7 | 2016-09-29 11:48:50 +0200 | [diff] [blame] | 89 | void OnEncoderReconfigured(const VideoEncoderConfig& encoder_config, |
Niels Möller | 213618e | 2018-07-24 09:29:58 +0200 | [diff] [blame] | 90 | const std::vector<VideoStream>& streams) override; |
sprang | b4a1ae5 | 2015-12-03 08:10:08 -0800 | [diff] [blame] | 91 | |
perkj | f5b2e51 | 2016-07-05 08:34:04 -0700 | [diff] [blame] | 92 | // Used to update the encoder target rate. |
| 93 | void OnSetEncoderTargetRate(uint32_t bitrate_bps); |
Peter Boström | e449915 | 2016-02-05 11:13:28 +0100 | [diff] [blame] | 94 | |
| 95 | // Implements CpuOveruseMetricsObserver. |
| 96 | void OnEncodedFrameTimeMeasured(int encode_time_ms, |
Niels Möller | 213618e | 2018-07-24 09:29:58 +0200 | [diff] [blame] | 97 | int encode_usage_percent) override; |
Peter Boström | e449915 | 2016-02-05 11:13:28 +0100 | [diff] [blame] | 98 | |
Niels Möller | 213618e | 2018-07-24 09:29:58 +0200 | [diff] [blame] | 99 | int GetInputFrameRate() const override; |
Per | 69b332d | 2016-06-02 15:45:42 +0200 | [diff] [blame] | 100 | int GetSendFrameRate() const; |
| 101 | |
sprang@webrtc.org | ccd4284 | 2014-01-07 09:54:34 +0000 | [diff] [blame] | 102 | protected: |
| 103 | // From RtcpStatisticsCallback. |
kjellander@webrtc.org | 14665ff | 2015-03-04 12:58:35 +0000 | [diff] [blame] | 104 | void StatisticsUpdated(const RtcpStatistics& statistics, |
| 105 | uint32_t ssrc) override; |
Henrik Boström | 87e3f9d | 2019-05-27 10:44:24 +0200 | [diff] [blame] | 106 | // From ReportBlockDataObserver. |
| 107 | void OnReportBlockDataUpdated(ReportBlockData report_block_data) override; |
asapersson | d89920b | 2015-07-22 06:52:00 -0700 | [diff] [blame] | 108 | // From RtcpPacketTypeCounterObserver. |
kjellander@webrtc.org | 14665ff | 2015-03-04 12:58:35 +0000 | [diff] [blame] | 109 | void RtcpPacketTypesCounterUpdated( |
pbos@webrtc.org | 1d0fa5d | 2015-02-19 12:47:00 +0000 | [diff] [blame] | 110 | uint32_t ssrc, |
kjellander@webrtc.org | 14665ff | 2015-03-04 12:58:35 +0000 | [diff] [blame] | 111 | const RtcpPacketTypeCounter& packet_counter) override; |
sprang@webrtc.org | ccd4284 | 2014-01-07 09:54:34 +0000 | [diff] [blame] | 112 | // From StreamDataCountersCallback. |
kjellander@webrtc.org | 14665ff | 2015-03-04 12:58:35 +0000 | [diff] [blame] | 113 | void DataCountersUpdated(const StreamDataCounters& counters, |
| 114 | uint32_t ssrc) override; |
sprang@webrtc.org | ccd4284 | 2014-01-07 09:54:34 +0000 | [diff] [blame] | 115 | |
| 116 | // From BitrateStatisticsObserver. |
sprang | cd349d9 | 2016-07-13 09:11:28 -0700 | [diff] [blame] | 117 | void Notify(uint32_t total_bitrate_bps, |
| 118 | uint32_t retransmit_bitrate_bps, |
kjellander@webrtc.org | 14665ff | 2015-03-04 12:58:35 +0000 | [diff] [blame] | 119 | uint32_t ssrc) override; |
sprang@webrtc.org | ccd4284 | 2014-01-07 09:54:34 +0000 | [diff] [blame] | 120 | |
| 121 | // From FrameCountObserver. |
kjellander@webrtc.org | 14665ff | 2015-03-04 12:58:35 +0000 | [diff] [blame] | 122 | void FrameCountUpdated(const FrameCounts& frame_counts, |
| 123 | uint32_t ssrc) override; |
sprang@webrtc.org | ccd4284 | 2014-01-07 09:54:34 +0000 | [diff] [blame] | 124 | |
kjellander@webrtc.org | 14665ff | 2015-03-04 12:58:35 +0000 | [diff] [blame] | 125 | void SendSideDelayUpdated(int avg_delay_ms, |
| 126 | int max_delay_ms, |
Henrik Boström | 9fe1834 | 2019-05-16 18:38:20 +0200 | [diff] [blame] | 127 | uint64_t total_delay_ms, |
kjellander@webrtc.org | 14665ff | 2015-03-04 12:58:35 +0000 | [diff] [blame] | 128 | uint32_t ssrc) override; |
stefan@webrtc.org | 168f23f | 2014-07-11 13:44:02 +0000 | [diff] [blame] | 129 | |
sprang@webrtc.org | ccd4284 | 2014-01-07 09:54:34 +0000 | [diff] [blame] | 130 | private: |
asapersson | da535c4 | 2015-10-19 23:32:41 -0700 | [diff] [blame] | 131 | class SampleCounter { |
| 132 | public: |
asapersson | d89920b | 2015-07-22 06:52:00 -0700 | [diff] [blame] | 133 | SampleCounter() : sum(0), num_samples(0) {} |
asapersson | da535c4 | 2015-10-19 23:32:41 -0700 | [diff] [blame] | 134 | ~SampleCounter() {} |
asapersson | d89920b | 2015-07-22 06:52:00 -0700 | [diff] [blame] | 135 | void Add(int sample); |
asapersson | 66d4b37 | 2016-12-19 06:50:53 -0800 | [diff] [blame] | 136 | int Avg(int64_t min_required_samples) const; |
asapersson | d89920b | 2015-07-22 06:52:00 -0700 | [diff] [blame] | 137 | |
| 138 | private: |
asapersson | 66d4b37 | 2016-12-19 06:50:53 -0800 | [diff] [blame] | 139 | int64_t sum; |
| 140 | int64_t num_samples; |
asapersson | d89920b | 2015-07-22 06:52:00 -0700 | [diff] [blame] | 141 | }; |
asapersson | da535c4 | 2015-10-19 23:32:41 -0700 | [diff] [blame] | 142 | class BoolSampleCounter { |
| 143 | public: |
asapersson | dec5ebf | 2015-10-05 02:36:17 -0700 | [diff] [blame] | 144 | BoolSampleCounter() : sum(0), num_samples(0) {} |
asapersson | da535c4 | 2015-10-19 23:32:41 -0700 | [diff] [blame] | 145 | ~BoolSampleCounter() {} |
asapersson | dec5ebf | 2015-10-05 02:36:17 -0700 | [diff] [blame] | 146 | void Add(bool sample); |
asapersson | 66d4b37 | 2016-12-19 06:50:53 -0800 | [diff] [blame] | 147 | void Add(bool sample, int64_t count); |
| 148 | int Percent(int64_t min_required_samples) const; |
| 149 | int Permille(int64_t min_required_samples) const; |
asapersson | dec5ebf | 2015-10-05 02:36:17 -0700 | [diff] [blame] | 150 | |
| 151 | private: |
asapersson | 66d4b37 | 2016-12-19 06:50:53 -0800 | [diff] [blame] | 152 | int Fraction(int64_t min_required_samples, float multiplier) const; |
| 153 | int64_t sum; |
| 154 | int64_t num_samples; |
asapersson | dec5ebf | 2015-10-05 02:36:17 -0700 | [diff] [blame] | 155 | }; |
pbos@webrtc.org | 273a414 | 2014-12-01 15:23:21 +0000 | [diff] [blame] | 156 | struct StatsUpdateTimes { |
sprang | b4a1ae5 | 2015-12-03 08:10:08 -0800 | [diff] [blame] | 157 | StatsUpdateTimes() : resolution_update_ms(0), bitrate_update_ms(0) {} |
pbos@webrtc.org | 273a414 | 2014-12-01 15:23:21 +0000 | [diff] [blame] | 158 | int64_t resolution_update_ms; |
Peter Boström | 20f3f94 | 2015-05-15 11:33:39 +0200 | [diff] [blame] | 159 | int64_t bitrate_update_ms; |
pbos@webrtc.org | 273a414 | 2014-12-01 15:23:21 +0000 | [diff] [blame] | 160 | }; |
asapersson | 66d4b37 | 2016-12-19 06:50:53 -0800 | [diff] [blame] | 161 | struct TargetRateUpdates { |
| 162 | TargetRateUpdates() |
| 163 | : pause_resume_events(0), last_paused_or_resumed(false), last_ms(-1) {} |
| 164 | int pause_resume_events; |
| 165 | bool last_paused_or_resumed; |
| 166 | int64_t last_ms; |
| 167 | }; |
asapersson | 8d75ac7 | 2017-09-15 06:41:15 -0700 | [diff] [blame] | 168 | struct FallbackEncoderInfo { |
Mirko Bonadei | 8fdcac3 | 2018-08-28 16:30:18 +0200 | [diff] [blame] | 169 | FallbackEncoderInfo(); |
asapersson | 8d75ac7 | 2017-09-15 06:41:15 -0700 | [diff] [blame] | 170 | bool is_possible = true; |
| 171 | bool is_active = false; |
| 172 | int on_off_events = 0; |
| 173 | int64_t elapsed_ms = 0; |
Danil Chapovalov | b9b146c | 2018-06-15 12:28:07 +0200 | [diff] [blame] | 174 | absl::optional<int64_t> last_update_ms; |
asapersson | 8d75ac7 | 2017-09-15 06:41:15 -0700 | [diff] [blame] | 175 | const int max_frame_diff_ms = 2000; |
| 176 | }; |
Åsa Persson | c3ed630 | 2017-11-16 14:04:52 +0100 | [diff] [blame] | 177 | struct FallbackEncoderInfoDisabled { |
| 178 | bool is_possible = true; |
| 179 | bool min_pixel_limit_reached = false; |
| 180 | }; |
asapersson | 6eca98b | 2017-04-04 23:40:50 -0700 | [diff] [blame] | 181 | struct StatsTimer { |
| 182 | void Start(int64_t now_ms); |
| 183 | void Stop(int64_t now_ms); |
| 184 | void Restart(int64_t now_ms); |
| 185 | int64_t start_ms = -1; |
| 186 | int64_t total_ms = 0; |
| 187 | }; |
asapersson | 118ef00 | 2016-03-31 00:00:19 -0700 | [diff] [blame] | 188 | struct QpCounters { |
asapersson | 6eca98b | 2017-04-04 23:40:50 -0700 | [diff] [blame] | 189 | SampleCounter vp8; // QP range: 0-127. |
| 190 | SampleCounter vp9; // QP range: 0-255. |
| 191 | SampleCounter h264; // QP range: 0-51. |
asapersson | 118ef00 | 2016-03-31 00:00:19 -0700 | [diff] [blame] | 192 | }; |
Åsa Persson | 875841d | 2018-01-08 08:49:53 +0100 | [diff] [blame] | 193 | struct AdaptChanges { |
| 194 | int down = 0; |
| 195 | int up = 0; |
| 196 | }; |
Åsa Persson | 0122e84 | 2017-10-16 12:19:23 +0200 | [diff] [blame] | 197 | |
| 198 | // Map holding encoded frames (mapped by timestamp). |
| 199 | // If simulcast layers are encoded on different threads, there is no guarantee |
| 200 | // that one frame of all layers are encoded before the next start. |
| 201 | struct TimestampOlderThan { |
| 202 | bool operator()(uint32_t ts1, uint32_t ts2) const { |
| 203 | return IsNewerTimestamp(ts2, ts1); |
| 204 | } |
| 205 | }; |
| 206 | struct Frame { |
Niels Möller | d3b8c63 | 2018-08-27 15:33:42 +0200 | [diff] [blame] | 207 | Frame(int64_t send_ms, uint32_t width, uint32_t height, int simulcast_idx) |
Åsa Persson | aa329e7 | 2017-12-15 15:54:44 +0100 | [diff] [blame] | 208 | : send_ms(send_ms), |
| 209 | max_width(width), |
| 210 | max_height(height), |
| 211 | max_simulcast_idx(simulcast_idx) {} |
Åsa Persson | 0122e84 | 2017-10-16 12:19:23 +0200 | [diff] [blame] | 212 | const int64_t |
| 213 | send_ms; // Time when first frame with this timestamp is sent. |
| 214 | uint32_t max_width; // Max width with this timestamp. |
| 215 | uint32_t max_height; // Max height with this timestamp. |
Niels Möller | d3b8c63 | 2018-08-27 15:33:42 +0200 | [diff] [blame] | 216 | int max_simulcast_idx; // Max simulcast index with this timestamp. |
Åsa Persson | 0122e84 | 2017-10-16 12:19:23 +0200 | [diff] [blame] | 217 | }; |
| 218 | typedef std::map<uint32_t, Frame, TimestampOlderThan> EncodedFrameMap; |
| 219 | |
danilchap | a37de39 | 2017-09-09 04:17:22 -0700 | [diff] [blame] | 220 | void PurgeOldStats() RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_); |
pbos@webrtc.org | 09c77b9 | 2015-02-25 10:42:16 +0000 | [diff] [blame] | 221 | VideoSendStream::StreamStats* GetStatsEntry(uint32_t ssrc) |
danilchap | a37de39 | 2017-09-09 04:17:22 -0700 | [diff] [blame] | 222 | RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_); |
sprang@webrtc.org | ccd4284 | 2014-01-07 09:54:34 +0000 | [diff] [blame] | 223 | |
Niels Möller | 213618e | 2018-07-24 09:29:58 +0200 | [diff] [blame] | 224 | void SetAdaptTimer(const AdaptationSteps& counts, StatsTimer* timer) |
| 225 | RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_); |
Ilya Nikolaevskiy | 5963c7c | 2019-10-09 18:06:58 +0200 | [diff] [blame] | 226 | void UpdateAdaptationStats() RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_); |
Åsa Persson | 875841d | 2018-01-08 08:49:53 +0100 | [diff] [blame] | 227 | void TryUpdateInitialQualityResolutionAdaptUp( |
Niels Möller | 213618e | 2018-07-24 09:29:58 +0200 | [diff] [blame] | 228 | const AdaptationSteps& quality_counts) |
Åsa Persson | 875841d | 2018-01-08 08:49:53 +0100 | [diff] [blame] | 229 | RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_); |
asapersson | 09f0561 | 2017-05-15 23:40:18 -0700 | [diff] [blame] | 230 | |
Åsa Persson | 45bbc8a | 2017-11-13 10:16:47 +0100 | [diff] [blame] | 231 | void UpdateEncoderFallbackStats(const CodecSpecificInfo* codec_info, |
Niels Möller | d3b8c63 | 2018-08-27 15:33:42 +0200 | [diff] [blame] | 232 | int pixels, |
| 233 | int simulcast_index) |
asapersson | 8d75ac7 | 2017-09-15 06:41:15 -0700 | [diff] [blame] | 234 | RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_); |
Åsa Persson | c3ed630 | 2017-11-16 14:04:52 +0100 | [diff] [blame] | 235 | void UpdateFallbackDisabledStats(const CodecSpecificInfo* codec_info, |
Niels Möller | d3b8c63 | 2018-08-27 15:33:42 +0200 | [diff] [blame] | 236 | int pixels, |
| 237 | int simulcast_index) |
Åsa Persson | c3ed630 | 2017-11-16 14:04:52 +0100 | [diff] [blame] | 238 | RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_); |
asapersson | 8d75ac7 | 2017-09-15 06:41:15 -0700 | [diff] [blame] | 239 | |
pbos@webrtc.org | 273a414 | 2014-12-01 15:23:21 +0000 | [diff] [blame] | 240 | Clock* const clock_; |
perkj | 26091b1 | 2016-09-01 01:17:40 -0700 | [diff] [blame] | 241 | const std::string payload_name_; |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 242 | const RtpConfig rtp_config_; |
Danil Chapovalov | b9b146c | 2018-06-15 12:28:07 +0200 | [diff] [blame] | 243 | const absl::optional<int> fallback_max_pixels_; |
| 244 | const absl::optional<int> fallback_max_pixels_disabled_; |
pbos | 5ad935c | 2016-01-25 03:52:44 -0800 | [diff] [blame] | 245 | rtc::CriticalSection crit_; |
danilchap | a37de39 | 2017-09-09 04:17:22 -0700 | [diff] [blame] | 246 | VideoEncoderConfig::ContentType content_type_ RTC_GUARDED_BY(crit_); |
asapersson | 4374a09 | 2016-07-27 00:39:09 -0700 | [diff] [blame] | 247 | const int64_t start_ms_; |
danilchap | a37de39 | 2017-09-09 04:17:22 -0700 | [diff] [blame] | 248 | VideoSendStream::Stats stats_ RTC_GUARDED_BY(crit_); |
danilchap | a37de39 | 2017-09-09 04:17:22 -0700 | [diff] [blame] | 249 | std::map<uint32_t, StatsUpdateTimes> update_times_ RTC_GUARDED_BY(crit_); |
| 250 | rtc::ExpFilter encode_time_ RTC_GUARDED_BY(crit_); |
| 251 | int quality_downscales_ RTC_GUARDED_BY(crit_); |
| 252 | int cpu_downscales_ RTC_GUARDED_BY(crit_); |
Henrik Boström | ce33b6a | 2019-05-28 17:42:38 +0200 | [diff] [blame] | 253 | QualityLimitationReasonTracker quality_limitation_reason_tracker_ |
| 254 | RTC_GUARDED_BY(crit_); |
Åsa Persson | 0122e84 | 2017-10-16 12:19:23 +0200 | [diff] [blame] | 255 | rtc::RateTracker media_byte_rate_tracker_ RTC_GUARDED_BY(crit_); |
| 256 | rtc::RateTracker encoded_frame_rate_tracker_ RTC_GUARDED_BY(crit_); |
asapersson | d89920b | 2015-07-22 06:52:00 -0700 | [diff] [blame] | 257 | |
Danil Chapovalov | b9b146c | 2018-06-15 12:28:07 +0200 | [diff] [blame] | 258 | absl::optional<int64_t> last_outlier_timestamp_ RTC_GUARDED_BY(crit_); |
Ilya Nikolaevskiy | 70473fc | 2018-02-28 16:35:03 +0100 | [diff] [blame] | 259 | |
Evan Shrubsole | cc62b16 | 2019-09-09 11:26:45 +0200 | [diff] [blame] | 260 | int last_num_spatial_layers_ RTC_GUARDED_BY(crit_); |
| 261 | int last_num_simulcast_streams_ RTC_GUARDED_BY(crit_); |
| 262 | std::array<bool, kMaxSpatialLayers> last_spatial_layer_use_ |
| 263 | RTC_GUARDED_BY(crit_); |
Ilya Nikolaevskiy | 5963c7c | 2019-10-09 18:06:58 +0200 | [diff] [blame] | 264 | // Indicates if the latest bitrate allocation had layers disabled by low |
| 265 | // available bandwidth. |
| 266 | bool bw_limited_layers_ RTC_GUARDED_BY(crit_); |
| 267 | AdaptationSteps cpu_counts_ RTC_GUARDED_BY(crit_); |
| 268 | AdaptationSteps quality_counts_ RTC_GUARDED_BY(crit_); |
Evan Shrubsole | cc62b16 | 2019-09-09 11:26:45 +0200 | [diff] [blame] | 269 | |
Erik Språng | e2fd86a | 2018-10-24 11:32:39 +0200 | [diff] [blame] | 270 | struct EncoderChangeEvent { |
| 271 | std::string previous_encoder_implementation; |
| 272 | std::string new_encoder_implementation; |
| 273 | }; |
| 274 | // Stores the last change in encoder implementation in an optional, so that |
| 275 | // the event can be consumed. |
| 276 | absl::optional<EncoderChangeEvent> encoder_changed_; |
| 277 | |
sprang | b4a1ae5 | 2015-12-03 08:10:08 -0800 | [diff] [blame] | 278 | // Contains stats used for UMA histograms. These stats will be reset if |
| 279 | // content type changes between real-time video and screenshare, since these |
| 280 | // will be reported separately. |
| 281 | struct UmaSamplesContainer { |
sprang | 07fb9be | 2016-02-24 07:55:00 -0800 | [diff] [blame] | 282 | UmaSamplesContainer(const char* prefix, |
| 283 | const VideoSendStream::Stats& start_stats, |
| 284 | Clock* clock); |
sprang | b4a1ae5 | 2015-12-03 08:10:08 -0800 | [diff] [blame] | 285 | ~UmaSamplesContainer(); |
| 286 | |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 287 | void UpdateHistograms(const RtpConfig& rtp_config, |
sprang | 07fb9be | 2016-02-24 07:55:00 -0800 | [diff] [blame] | 288 | const VideoSendStream::Stats& current_stats); |
sprang | b4a1ae5 | 2015-12-03 08:10:08 -0800 | [diff] [blame] | 289 | |
asapersson | 93e1e23 | 2017-02-06 05:18:35 -0800 | [diff] [blame] | 290 | void InitializeBitrateCounters(const VideoSendStream::Stats& stats); |
| 291 | |
Åsa Persson | aa329e7 | 2017-12-15 15:54:44 +0100 | [diff] [blame] | 292 | bool InsertEncodedFrame(const EncodedImage& encoded_frame, |
Ilya Nikolaevskiy | 840394c | 2019-11-26 17:20:50 +0100 | [diff] [blame] | 293 | int simulcast_idx); |
| 294 | void RemoveOld(int64_t now_ms); |
Åsa Persson | 0122e84 | 2017-10-16 12:19:23 +0200 | [diff] [blame] | 295 | |
sprang | b4a1ae5 | 2015-12-03 08:10:08 -0800 | [diff] [blame] | 296 | const std::string uma_prefix_; |
sprang | 07fb9be | 2016-02-24 07:55:00 -0800 | [diff] [blame] | 297 | Clock* const clock_; |
sprang | b4a1ae5 | 2015-12-03 08:10:08 -0800 | [diff] [blame] | 298 | SampleCounter input_width_counter_; |
| 299 | SampleCounter input_height_counter_; |
| 300 | SampleCounter sent_width_counter_; |
| 301 | SampleCounter sent_height_counter_; |
| 302 | SampleCounter encode_time_counter_; |
| 303 | BoolSampleCounter key_frame_counter_; |
| 304 | BoolSampleCounter quality_limited_frame_counter_; |
| 305 | SampleCounter quality_downscales_counter_; |
perkj | 803d97f | 2016-11-01 11:45:46 -0700 | [diff] [blame] | 306 | BoolSampleCounter cpu_limited_frame_counter_; |
sprang | b4a1ae5 | 2015-12-03 08:10:08 -0800 | [diff] [blame] | 307 | BoolSampleCounter bw_limited_frame_counter_; |
| 308 | SampleCounter bw_resolutions_disabled_counter_; |
| 309 | SampleCounter delay_counter_; |
| 310 | SampleCounter max_delay_counter_; |
| 311 | rtc::RateTracker input_frame_rate_tracker_; |
asapersson | 320e45a | 2016-11-29 01:40:35 -0800 | [diff] [blame] | 312 | RateCounter input_fps_counter_; |
| 313 | RateCounter sent_fps_counter_; |
asapersson | 93e1e23 | 2017-02-06 05:18:35 -0800 | [diff] [blame] | 314 | RateAccCounter total_byte_counter_; |
| 315 | RateAccCounter media_byte_counter_; |
| 316 | RateAccCounter rtx_byte_counter_; |
| 317 | RateAccCounter padding_byte_counter_; |
| 318 | RateAccCounter retransmit_byte_counter_; |
| 319 | RateAccCounter fec_byte_counter_; |
sprang | e2d83d6 | 2016-02-19 09:03:26 -0800 | [diff] [blame] | 320 | int64_t first_rtcp_stats_time_ms_; |
Erik Språng | 22c2b48 | 2016-03-01 09:40:42 +0100 | [diff] [blame] | 321 | int64_t first_rtp_stats_time_ms_; |
asapersson | 09f0561 | 2017-05-15 23:40:18 -0700 | [diff] [blame] | 322 | StatsTimer cpu_adapt_timer_; |
| 323 | StatsTimer quality_adapt_timer_; |
asapersson | 66d4b37 | 2016-12-19 06:50:53 -0800 | [diff] [blame] | 324 | BoolSampleCounter paused_time_counter_; |
| 325 | TargetRateUpdates target_rate_updates_; |
asapersson | 8d75ac7 | 2017-09-15 06:41:15 -0700 | [diff] [blame] | 326 | BoolSampleCounter fallback_active_counter_; |
| 327 | FallbackEncoderInfo fallback_info_; |
Åsa Persson | c3ed630 | 2017-11-16 14:04:52 +0100 | [diff] [blame] | 328 | FallbackEncoderInfoDisabled fallback_info_disabled_; |
sprang | e2d83d6 | 2016-02-19 09:03:26 -0800 | [diff] [blame] | 329 | ReportBlockStats report_block_stats_; |
sprang | 07fb9be | 2016-02-24 07:55:00 -0800 | [diff] [blame] | 330 | const VideoSendStream::Stats start_stats_; |
Åsa Persson | aa329e7 | 2017-12-15 15:54:44 +0100 | [diff] [blame] | 331 | size_t num_streams_; // Number of configured streams to encoder. |
| 332 | size_t num_pixels_highest_stream_; |
Åsa Persson | 0122e84 | 2017-10-16 12:19:23 +0200 | [diff] [blame] | 333 | EncodedFrameMap encoded_frames_; |
Åsa Persson | 875841d | 2018-01-08 08:49:53 +0100 | [diff] [blame] | 334 | AdaptChanges initial_quality_changes_; |
sprang | c5d62e2 | 2017-04-02 23:53:04 -0700 | [diff] [blame] | 335 | |
asapersson | 118ef00 | 2016-03-31 00:00:19 -0700 | [diff] [blame] | 336 | std::map<int, QpCounters> |
| 337 | qp_counters_; // QP counters mapped by spatial idx. |
sprang | b4a1ae5 | 2015-12-03 08:10:08 -0800 | [diff] [blame] | 338 | }; |
| 339 | |
danilchap | a37de39 | 2017-09-09 04:17:22 -0700 | [diff] [blame] | 340 | std::unique_ptr<UmaSamplesContainer> uma_container_ RTC_GUARDED_BY(crit_); |
sprang@webrtc.org | ccd4284 | 2014-01-07 09:54:34 +0000 | [diff] [blame] | 341 | }; |
| 342 | |
| 343 | } // namespace webrtc |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 344 | #endif // VIDEO_SEND_STATISTICS_PROXY_H_ |