blob: b3da5e978aee71ac01fd4c255b0e43006a4294ff [file] [log] [blame]
sprang@webrtc.orgccd42842014-01-07 09:54:34 +00001/*
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
11// This file includes unit tests for SendStatisticsProxy.
12#include "webrtc/video/send_statistics_proxy.h"
13
14#include <map>
15#include <string>
16#include <vector>
17
18#include "testing/gtest/include/gtest/gtest.h"
sprang07fb9be2016-02-24 07:55:00 -080019#include "webrtc/system_wrappers/include/metrics.h"
asapersson59bac1a2016-01-07 23:36:00 -080020#include "webrtc/test/histogram.h"
sprang@webrtc.orgccd42842014-01-07 09:54:34 +000021
22namespace webrtc {
23
sprang07fb9be2016-02-24 07:55:00 -080024static const uint32_t kFirstSsrc = 17;
25static const uint32_t kSecondSsrc = 42;
26static const uint32_t kFirstRtxSsrc = 18;
27static const uint32_t kSecondRtxSsrc = 43;
28
stefan@webrtc.org168f23f2014-07-11 13:44:02 +000029class SendStatisticsProxyTest : public ::testing::Test {
sprang@webrtc.orgccd42842014-01-07 09:54:34 +000030 public:
pbos@webrtc.org273a4142014-12-01 15:23:21 +000031 SendStatisticsProxyTest()
solenberg4fbae2b2015-08-28 04:07:10 -070032 : fake_clock_(1234), config_(GetTestConfig()), avg_delay_ms_(0),
33 max_delay_ms_(0) {}
sprang@webrtc.orgccd42842014-01-07 09:54:34 +000034 virtual ~SendStatisticsProxyTest() {}
35
36 protected:
37 virtual void SetUp() {
sprangb4a1ae52015-12-03 08:10:08 -080038 statistics_proxy_.reset(new SendStatisticsProxy(
39 &fake_clock_, GetTestConfig(),
40 VideoEncoderConfig::ContentType::kRealtimeVideo));
sprang@webrtc.orgccd42842014-01-07 09:54:34 +000041 expected_ = VideoSendStream::Stats();
42 }
43
44 VideoSendStream::Config GetTestConfig() {
solenberg4fbae2b2015-08-28 04:07:10 -070045 VideoSendStream::Config config(nullptr);
sprang07fb9be2016-02-24 07:55:00 -080046 config.rtp.ssrcs.push_back(kFirstSsrc);
47 config.rtp.ssrcs.push_back(kSecondSsrc);
48 config.rtp.rtx.ssrcs.push_back(kFirstRtxSsrc);
49 config.rtp.rtx.ssrcs.push_back(kSecondRtxSsrc);
Erik Språng22c2b482016-03-01 09:40:42 +010050 config.rtp.fec.red_payload_type = 17;
sprang@webrtc.orgccd42842014-01-07 09:54:34 +000051 return config;
52 }
53
sprang@webrtc.org09315702014-02-07 12:06:29 +000054 void ExpectEqual(VideoSendStream::Stats one, VideoSendStream::Stats other) {
sprang@webrtc.org09315702014-02-07 12:06:29 +000055 EXPECT_EQ(one.input_frame_rate, other.input_frame_rate);
56 EXPECT_EQ(one.encode_frame_rate, other.encode_frame_rate);
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +000057 EXPECT_EQ(one.media_bitrate_bps, other.media_bitrate_bps);
henrik.lundin@webrtc.orgb10363f2014-03-13 13:31:21 +000058 EXPECT_EQ(one.suspended, other.suspended);
sprang@webrtc.org09315702014-02-07 12:06:29 +000059
60 EXPECT_EQ(one.substreams.size(), other.substreams.size());
pbos@webrtc.org09c77b92015-02-25 10:42:16 +000061 for (std::map<uint32_t, VideoSendStream::StreamStats>::const_iterator it =
sprang@webrtc.org09315702014-02-07 12:06:29 +000062 one.substreams.begin();
pbos@webrtc.org09c77b92015-02-25 10:42:16 +000063 it != one.substreams.end(); ++it) {
64 std::map<uint32_t, VideoSendStream::StreamStats>::const_iterator
65 corresponding_it = other.substreams.find(it->first);
sprang@webrtc.org09315702014-02-07 12:06:29 +000066 ASSERT_TRUE(corresponding_it != other.substreams.end());
pbos@webrtc.org09c77b92015-02-25 10:42:16 +000067 const VideoSendStream::StreamStats& a = it->second;
68 const VideoSendStream::StreamStats& b = corresponding_it->second;
sprang@webrtc.org09315702014-02-07 12:06:29 +000069
pbos@webrtc.orgce4e9a32014-12-18 13:50:16 +000070 EXPECT_EQ(a.frame_counts.key_frames, b.frame_counts.key_frames);
71 EXPECT_EQ(a.frame_counts.delta_frames, b.frame_counts.delta_frames);
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +000072 EXPECT_EQ(a.total_bitrate_bps, b.total_bitrate_bps);
stefan@webrtc.org168f23f2014-07-11 13:44:02 +000073 EXPECT_EQ(a.avg_delay_ms, b.avg_delay_ms);
74 EXPECT_EQ(a.max_delay_ms, b.max_delay_ms);
sprang@webrtc.org09315702014-02-07 12:06:29 +000075
asapersson@webrtc.orgcfd82df2015-01-22 09:39:59 +000076 EXPECT_EQ(a.rtp_stats.transmitted.payload_bytes,
77 b.rtp_stats.transmitted.payload_bytes);
78 EXPECT_EQ(a.rtp_stats.transmitted.header_bytes,
79 b.rtp_stats.transmitted.header_bytes);
80 EXPECT_EQ(a.rtp_stats.transmitted.padding_bytes,
81 b.rtp_stats.transmitted.padding_bytes);
82 EXPECT_EQ(a.rtp_stats.transmitted.packets,
83 b.rtp_stats.transmitted.packets);
84 EXPECT_EQ(a.rtp_stats.retransmitted.packets,
85 b.rtp_stats.retransmitted.packets);
86 EXPECT_EQ(a.rtp_stats.fec.packets, b.rtp_stats.fec.packets);
sprang@webrtc.org09315702014-02-07 12:06:29 +000087
88 EXPECT_EQ(a.rtcp_stats.fraction_lost, b.rtcp_stats.fraction_lost);
89 EXPECT_EQ(a.rtcp_stats.cumulative_lost, b.rtcp_stats.cumulative_lost);
90 EXPECT_EQ(a.rtcp_stats.extended_max_sequence_number,
91 b.rtcp_stats.extended_max_sequence_number);
92 EXPECT_EQ(a.rtcp_stats.jitter, b.rtcp_stats.jitter);
93 }
94 }
95
pbos@webrtc.org273a4142014-12-01 15:23:21 +000096 SimulatedClock fake_clock_;
sprang07fb9be2016-02-24 07:55:00 -080097 rtc::scoped_ptr<SendStatisticsProxy> statistics_proxy_;
sprang@webrtc.orgccd42842014-01-07 09:54:34 +000098 VideoSendStream::Config config_;
99 int avg_delay_ms_;
100 int max_delay_ms_;
sprang@webrtc.orgccd42842014-01-07 09:54:34 +0000101 VideoSendStream::Stats expected_;
pbos@webrtc.org09c77b92015-02-25 10:42:16 +0000102 typedef std::map<uint32_t, VideoSendStream::StreamStats>::const_iterator
103 StreamIterator;
sprang@webrtc.orgccd42842014-01-07 09:54:34 +0000104};
105
106TEST_F(SendStatisticsProxyTest, RtcpStatistics) {
107 RtcpStatisticsCallback* callback = statistics_proxy_.get();
108 for (std::vector<uint32_t>::const_iterator it = config_.rtp.ssrcs.begin();
109 it != config_.rtp.ssrcs.end();
110 ++it) {
111 const uint32_t ssrc = *it;
pbos@webrtc.org09c77b92015-02-25 10:42:16 +0000112 VideoSendStream::StreamStats& ssrc_stats = expected_.substreams[ssrc];
sprang@webrtc.orgccd42842014-01-07 09:54:34 +0000113
114 // Add statistics with some arbitrary, but unique, numbers.
115 uint32_t offset = ssrc * sizeof(RtcpStatistics);
116 ssrc_stats.rtcp_stats.cumulative_lost = offset;
117 ssrc_stats.rtcp_stats.extended_max_sequence_number = offset + 1;
118 ssrc_stats.rtcp_stats.fraction_lost = offset + 2;
119 ssrc_stats.rtcp_stats.jitter = offset + 3;
120 callback->StatisticsUpdated(ssrc_stats.rtcp_stats, ssrc);
121 }
stefan@webrtc.org58e2d262014-08-14 15:10:49 +0000122 for (std::vector<uint32_t>::const_iterator it = config_.rtp.rtx.ssrcs.begin();
123 it != config_.rtp.rtx.ssrcs.end();
124 ++it) {
125 const uint32_t ssrc = *it;
pbos@webrtc.org09c77b92015-02-25 10:42:16 +0000126 VideoSendStream::StreamStats& ssrc_stats = expected_.substreams[ssrc];
sprang@webrtc.orgccd42842014-01-07 09:54:34 +0000127
stefan@webrtc.org58e2d262014-08-14 15:10:49 +0000128 // Add statistics with some arbitrary, but unique, numbers.
129 uint32_t offset = ssrc * sizeof(RtcpStatistics);
130 ssrc_stats.rtcp_stats.cumulative_lost = offset;
131 ssrc_stats.rtcp_stats.extended_max_sequence_number = offset + 1;
132 ssrc_stats.rtcp_stats.fraction_lost = offset + 2;
133 ssrc_stats.rtcp_stats.jitter = offset + 3;
134 callback->StatisticsUpdated(ssrc_stats.rtcp_stats, ssrc);
135 }
sprang@webrtc.orgccd42842014-01-07 09:54:34 +0000136 VideoSendStream::Stats stats = statistics_proxy_->GetStats();
sprang@webrtc.org09315702014-02-07 12:06:29 +0000137 ExpectEqual(expected_, stats);
sprang@webrtc.orgccd42842014-01-07 09:54:34 +0000138}
139
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +0000140TEST_F(SendStatisticsProxyTest, EncodedBitrateAndFramerate) {
Peter Boström7083e112015-09-22 16:28:51 +0200141 int media_bitrate_bps = 500;
142 int encode_fps = 29;
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +0000143
Peter Boström7083e112015-09-22 16:28:51 +0200144 statistics_proxy_->OnOutgoingRate(encode_fps, media_bitrate_bps);
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +0000145
146 VideoSendStream::Stats stats = statistics_proxy_->GetStats();
147 EXPECT_EQ(media_bitrate_bps, stats.media_bitrate_bps);
sprang@webrtc.orgccd42842014-01-07 09:54:34 +0000148 EXPECT_EQ(encode_fps, stats.encode_frame_rate);
149}
150
henrik.lundin@webrtc.orgb10363f2014-03-13 13:31:21 +0000151TEST_F(SendStatisticsProxyTest, Suspended) {
152 // Verify that the value is false by default.
153 EXPECT_FALSE(statistics_proxy_->GetStats().suspended);
154
155 // Verify that we can set it to true.
Peter Boström7083e112015-09-22 16:28:51 +0200156 statistics_proxy_->OnSuspendChange(true);
henrik.lundin@webrtc.orgb10363f2014-03-13 13:31:21 +0000157 EXPECT_TRUE(statistics_proxy_->GetStats().suspended);
158
159 // Verify that we can set it back to false again.
Peter Boström7083e112015-09-22 16:28:51 +0200160 statistics_proxy_->OnSuspendChange(false);
henrik.lundin@webrtc.orgb10363f2014-03-13 13:31:21 +0000161 EXPECT_FALSE(statistics_proxy_->GetStats().suspended);
162}
163
sprang@webrtc.orgccd42842014-01-07 09:54:34 +0000164TEST_F(SendStatisticsProxyTest, FrameCounts) {
165 FrameCountObserver* observer = statistics_proxy_.get();
166 for (std::vector<uint32_t>::const_iterator it = config_.rtp.ssrcs.begin();
167 it != config_.rtp.ssrcs.end();
168 ++it) {
169 const uint32_t ssrc = *it;
170 // Add statistics with some arbitrary, but unique, numbers.
pbos@webrtc.org09c77b92015-02-25 10:42:16 +0000171 VideoSendStream::StreamStats& stats = expected_.substreams[ssrc];
172 uint32_t offset = ssrc * sizeof(VideoSendStream::StreamStats);
pbos@webrtc.orgce4e9a32014-12-18 13:50:16 +0000173 FrameCounts frame_counts;
174 frame_counts.key_frames = offset;
175 frame_counts.delta_frames = offset + 1;
176 stats.frame_counts = frame_counts;
177 observer->FrameCountUpdated(frame_counts, ssrc);
sprang@webrtc.orgccd42842014-01-07 09:54:34 +0000178 }
stefan@webrtc.org58e2d262014-08-14 15:10:49 +0000179 for (std::vector<uint32_t>::const_iterator it = config_.rtp.rtx.ssrcs.begin();
180 it != config_.rtp.rtx.ssrcs.end();
181 ++it) {
182 const uint32_t ssrc = *it;
183 // Add statistics with some arbitrary, but unique, numbers.
pbos@webrtc.org09c77b92015-02-25 10:42:16 +0000184 VideoSendStream::StreamStats& stats = expected_.substreams[ssrc];
185 uint32_t offset = ssrc * sizeof(VideoSendStream::StreamStats);
pbos@webrtc.orgce4e9a32014-12-18 13:50:16 +0000186 FrameCounts frame_counts;
187 frame_counts.key_frames = offset;
188 frame_counts.delta_frames = offset + 1;
189 stats.frame_counts = frame_counts;
190 observer->FrameCountUpdated(frame_counts, ssrc);
stefan@webrtc.org58e2d262014-08-14 15:10:49 +0000191 }
sprang@webrtc.orgccd42842014-01-07 09:54:34 +0000192
193 VideoSendStream::Stats stats = statistics_proxy_->GetStats();
sprang@webrtc.org09315702014-02-07 12:06:29 +0000194 ExpectEqual(expected_, stats);
sprang@webrtc.orgccd42842014-01-07 09:54:34 +0000195}
196
197TEST_F(SendStatisticsProxyTest, DataCounters) {
198 StreamDataCountersCallback* callback = statistics_proxy_.get();
199 for (std::vector<uint32_t>::const_iterator it = config_.rtp.ssrcs.begin();
200 it != config_.rtp.ssrcs.end();
201 ++it) {
202 const uint32_t ssrc = *it;
203 StreamDataCounters& counters = expected_.substreams[ssrc].rtp_stats;
204 // Add statistics with some arbitrary, but unique, numbers.
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +0000205 size_t offset = ssrc * sizeof(StreamDataCounters);
206 uint32_t offset_uint32 = static_cast<uint32_t>(offset);
asapersson@webrtc.orgcfd82df2015-01-22 09:39:59 +0000207 counters.transmitted.payload_bytes = offset;
208 counters.transmitted.header_bytes = offset + 1;
209 counters.fec.packets = offset_uint32 + 2;
210 counters.transmitted.padding_bytes = offset + 3;
211 counters.retransmitted.packets = offset_uint32 + 4;
212 counters.transmitted.packets = offset_uint32 + 5;
sprang@webrtc.orgccd42842014-01-07 09:54:34 +0000213 callback->DataCountersUpdated(counters, ssrc);
214 }
stefan@webrtc.org58e2d262014-08-14 15:10:49 +0000215 for (std::vector<uint32_t>::const_iterator it = config_.rtp.rtx.ssrcs.begin();
216 it != config_.rtp.rtx.ssrcs.end();
217 ++it) {
218 const uint32_t ssrc = *it;
219 StreamDataCounters& counters = expected_.substreams[ssrc].rtp_stats;
220 // Add statistics with some arbitrary, but unique, numbers.
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +0000221 size_t offset = ssrc * sizeof(StreamDataCounters);
222 uint32_t offset_uint32 = static_cast<uint32_t>(offset);
asapersson@webrtc.orgcfd82df2015-01-22 09:39:59 +0000223 counters.transmitted.payload_bytes = offset;
224 counters.transmitted.header_bytes = offset + 1;
225 counters.fec.packets = offset_uint32 + 2;
226 counters.transmitted.padding_bytes = offset + 3;
227 counters.retransmitted.packets = offset_uint32 + 4;
228 counters.transmitted.packets = offset_uint32 + 5;
stefan@webrtc.org58e2d262014-08-14 15:10:49 +0000229 callback->DataCountersUpdated(counters, ssrc);
230 }
sprang@webrtc.orgccd42842014-01-07 09:54:34 +0000231
232 VideoSendStream::Stats stats = statistics_proxy_->GetStats();
sprang@webrtc.org09315702014-02-07 12:06:29 +0000233 ExpectEqual(expected_, stats);
sprang@webrtc.orgccd42842014-01-07 09:54:34 +0000234}
235
236TEST_F(SendStatisticsProxyTest, Bitrate) {
237 BitrateStatisticsObserver* observer = statistics_proxy_.get();
238 for (std::vector<uint32_t>::const_iterator it = config_.rtp.ssrcs.begin();
239 it != config_.rtp.ssrcs.end();
240 ++it) {
241 const uint32_t ssrc = *it;
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +0000242 BitrateStatistics total;
243 BitrateStatistics retransmit;
stefan@webrtc.org168f23f2014-07-11 13:44:02 +0000244 // Use ssrc as bitrate_bps to get a unique value for each stream.
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +0000245 total.bitrate_bps = ssrc;
246 retransmit.bitrate_bps = ssrc + 1;
247 observer->Notify(total, retransmit, ssrc);
248 expected_.substreams[ssrc].total_bitrate_bps = total.bitrate_bps;
249 expected_.substreams[ssrc].retransmit_bitrate_bps = retransmit.bitrate_bps;
sprang@webrtc.orgccd42842014-01-07 09:54:34 +0000250 }
stefan@webrtc.org58e2d262014-08-14 15:10:49 +0000251 for (std::vector<uint32_t>::const_iterator it = config_.rtp.rtx.ssrcs.begin();
252 it != config_.rtp.rtx.ssrcs.end();
253 ++it) {
254 const uint32_t ssrc = *it;
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +0000255 BitrateStatistics total;
256 BitrateStatistics retransmit;
stefan@webrtc.org58e2d262014-08-14 15:10:49 +0000257 // Use ssrc as bitrate_bps to get a unique value for each stream.
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +0000258 total.bitrate_bps = ssrc;
259 retransmit.bitrate_bps = ssrc + 1;
260 observer->Notify(total, retransmit, ssrc);
261 expected_.substreams[ssrc].total_bitrate_bps = total.bitrate_bps;
262 expected_.substreams[ssrc].retransmit_bitrate_bps = retransmit.bitrate_bps;
stefan@webrtc.org58e2d262014-08-14 15:10:49 +0000263 }
sprang@webrtc.orgccd42842014-01-07 09:54:34 +0000264
265 VideoSendStream::Stats stats = statistics_proxy_->GetStats();
sprang@webrtc.org09315702014-02-07 12:06:29 +0000266 ExpectEqual(expected_, stats);
sprang@webrtc.orgccd42842014-01-07 09:54:34 +0000267}
268
stefan@webrtc.org168f23f2014-07-11 13:44:02 +0000269TEST_F(SendStatisticsProxyTest, SendSideDelay) {
270 SendSideDelayObserver* observer = statistics_proxy_.get();
271 for (std::vector<uint32_t>::const_iterator it = config_.rtp.ssrcs.begin();
272 it != config_.rtp.ssrcs.end();
273 ++it) {
274 const uint32_t ssrc = *it;
275 // Use ssrc as avg_delay_ms and max_delay_ms to get a unique value for each
276 // stream.
277 int avg_delay_ms = ssrc;
278 int max_delay_ms = ssrc + 1;
279 observer->SendSideDelayUpdated(avg_delay_ms, max_delay_ms, ssrc);
280 expected_.substreams[ssrc].avg_delay_ms = avg_delay_ms;
281 expected_.substreams[ssrc].max_delay_ms = max_delay_ms;
282 }
stefan@webrtc.org58e2d262014-08-14 15:10:49 +0000283 for (std::vector<uint32_t>::const_iterator it = config_.rtp.rtx.ssrcs.begin();
284 it != config_.rtp.rtx.ssrcs.end();
285 ++it) {
286 const uint32_t ssrc = *it;
287 // Use ssrc as avg_delay_ms and max_delay_ms to get a unique value for each
288 // stream.
289 int avg_delay_ms = ssrc;
290 int max_delay_ms = ssrc + 1;
291 observer->SendSideDelayUpdated(avg_delay_ms, max_delay_ms, ssrc);
292 expected_.substreams[ssrc].avg_delay_ms = avg_delay_ms;
293 expected_.substreams[ssrc].max_delay_ms = max_delay_ms;
294 }
sprang@webrtc.orgccd42842014-01-07 09:54:34 +0000295 VideoSendStream::Stats stats = statistics_proxy_->GetStats();
stefan@webrtc.org168f23f2014-07-11 13:44:02 +0000296 ExpectEqual(expected_, stats);
sprang@webrtc.orgccd42842014-01-07 09:54:34 +0000297}
298
Peter Boströme4499152016-02-05 11:13:28 +0100299TEST_F(SendStatisticsProxyTest, OnEncodedFrameTimeMeasured) {
asapersson1aa420b2015-12-07 03:12:22 -0800300 const int kEncodeTimeMs = 11;
Peter Boströme4499152016-02-05 11:13:28 +0100301 CpuOveruseMetrics metrics;
302 metrics.encode_usage_percent = 80;
303 statistics_proxy_->OnEncodedFrameTimeMeasured(kEncodeTimeMs, metrics);
asapersson1aa420b2015-12-07 03:12:22 -0800304
305 VideoSendStream::Stats stats = statistics_proxy_->GetStats();
306 EXPECT_EQ(kEncodeTimeMs, stats.avg_encode_time_ms);
Peter Boströme4499152016-02-05 11:13:28 +0100307 EXPECT_EQ(metrics.encode_usage_percent, stats.encode_usage_percent);
asapersson1aa420b2015-12-07 03:12:22 -0800308}
309
asapersson59bac1a2016-01-07 23:36:00 -0800310TEST_F(SendStatisticsProxyTest, SwitchContentTypeUpdatesHistograms) {
311 test::ClearHistograms();
312 const int kMinRequiredSamples = 200;
313 const int kWidth = 640;
314 const int kHeight = 480;
315
316 for (int i = 0; i < kMinRequiredSamples; ++i)
317 statistics_proxy_->OnIncomingFrame(kWidth, kHeight);
318
319 // No switch, stats not should be updated.
320 statistics_proxy_->SetContentType(
321 VideoEncoderConfig::ContentType::kRealtimeVideo);
322 EXPECT_EQ(0, test::NumHistogramSamples("WebRTC.Video.InputWidthInPixels"));
323
324 // Switch to screenshare, real-time stats should be updated.
325 statistics_proxy_->SetContentType(VideoEncoderConfig::ContentType::kScreen);
326 EXPECT_EQ(1, test::NumHistogramSamples("WebRTC.Video.InputWidthInPixels"));
327}
328
sprang@webrtc.orgccd42842014-01-07 09:54:34 +0000329TEST_F(SendStatisticsProxyTest, NoSubstreams) {
pbos@webrtc.org49096de2015-02-24 22:37:52 +0000330 uint32_t excluded_ssrc =
stefan@webrtc.org58e2d262014-08-14 15:10:49 +0000331 std::max(
332 *std::max_element(config_.rtp.ssrcs.begin(), config_.rtp.ssrcs.end()),
333 *std::max_element(config_.rtp.rtx.ssrcs.begin(),
334 config_.rtp.rtx.ssrcs.end())) +
335 1;
sprang@webrtc.orgccd42842014-01-07 09:54:34 +0000336 // From RtcpStatisticsCallback.
337 RtcpStatistics rtcp_stats;
338 RtcpStatisticsCallback* rtcp_callback = statistics_proxy_.get();
pbos@webrtc.org49096de2015-02-24 22:37:52 +0000339 rtcp_callback->StatisticsUpdated(rtcp_stats, excluded_ssrc);
sprang@webrtc.orgccd42842014-01-07 09:54:34 +0000340
341 // From BitrateStatisticsObserver.
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +0000342 BitrateStatistics total;
343 BitrateStatistics retransmit;
sprang@webrtc.orgccd42842014-01-07 09:54:34 +0000344 BitrateStatisticsObserver* bitrate_observer = statistics_proxy_.get();
pbos@webrtc.org49096de2015-02-24 22:37:52 +0000345 bitrate_observer->Notify(total, retransmit, excluded_ssrc);
sprang@webrtc.orgccd42842014-01-07 09:54:34 +0000346
347 // From FrameCountObserver.
348 FrameCountObserver* fps_observer = statistics_proxy_.get();
pbos@webrtc.orgce4e9a32014-12-18 13:50:16 +0000349 FrameCounts frame_counts;
350 frame_counts.key_frames = 1;
pbos@webrtc.org49096de2015-02-24 22:37:52 +0000351 fps_observer->FrameCountUpdated(frame_counts, excluded_ssrc);
sprang@webrtc.orgccd42842014-01-07 09:54:34 +0000352
353 VideoSendStream::Stats stats = statistics_proxy_->GetStats();
354 EXPECT_TRUE(stats.substreams.empty());
355}
356
pbos@webrtc.org273a4142014-12-01 15:23:21 +0000357TEST_F(SendStatisticsProxyTest, EncodedResolutionTimesOut) {
358 static const int kEncodedWidth = 123;
359 static const int kEncodedHeight = 81;
360 EncodedImage encoded_image;
361 encoded_image._encodedWidth = kEncodedWidth;
362 encoded_image._encodedHeight = kEncodedHeight;
363
364 RTPVideoHeader rtp_video_header;
365
366 rtp_video_header.simulcastIdx = 0;
367 statistics_proxy_->OnSendEncodedImage(encoded_image, &rtp_video_header);
368 rtp_video_header.simulcastIdx = 1;
369 statistics_proxy_->OnSendEncodedImage(encoded_image, &rtp_video_header);
370
371 VideoSendStream::Stats stats = statistics_proxy_->GetStats();
pbos@webrtc.org09c77b92015-02-25 10:42:16 +0000372 EXPECT_EQ(kEncodedWidth, stats.substreams[config_.rtp.ssrcs[0]].width);
373 EXPECT_EQ(kEncodedHeight, stats.substreams[config_.rtp.ssrcs[0]].height);
374 EXPECT_EQ(kEncodedWidth, stats.substreams[config_.rtp.ssrcs[1]].width);
375 EXPECT_EQ(kEncodedHeight, stats.substreams[config_.rtp.ssrcs[1]].height);
pbos@webrtc.org273a4142014-12-01 15:23:21 +0000376
377 // Forward almost to timeout, this should not have removed stats.
378 fake_clock_.AdvanceTimeMilliseconds(SendStatisticsProxy::kStatsTimeoutMs - 1);
379 stats = statistics_proxy_->GetStats();
pbos@webrtc.org09c77b92015-02-25 10:42:16 +0000380 EXPECT_EQ(kEncodedWidth, stats.substreams[config_.rtp.ssrcs[0]].width);
381 EXPECT_EQ(kEncodedHeight, stats.substreams[config_.rtp.ssrcs[0]].height);
pbos@webrtc.org273a4142014-12-01 15:23:21 +0000382
383 // Update the first SSRC with bogus RTCP stats to make sure that encoded
384 // resolution still times out (no global timeout for all stats).
385 RtcpStatistics rtcp_statistics;
386 RtcpStatisticsCallback* rtcp_stats = statistics_proxy_.get();
387 rtcp_stats->StatisticsUpdated(rtcp_statistics, config_.rtp.ssrcs[0]);
388
389 // Report stats for second SSRC to make sure it's not outdated along with the
390 // first SSRC.
391 rtp_video_header.simulcastIdx = 1;
392 statistics_proxy_->OnSendEncodedImage(encoded_image, &rtp_video_header);
393
394 // Forward 1 ms, reach timeout, substream 0 should have no resolution
395 // reported, but substream 1 should.
396 fake_clock_.AdvanceTimeMilliseconds(1);
397 stats = statistics_proxy_->GetStats();
pbos@webrtc.org09c77b92015-02-25 10:42:16 +0000398 EXPECT_EQ(0, stats.substreams[config_.rtp.ssrcs[0]].width);
399 EXPECT_EQ(0, stats.substreams[config_.rtp.ssrcs[0]].height);
400 EXPECT_EQ(kEncodedWidth, stats.substreams[config_.rtp.ssrcs[1]].width);
401 EXPECT_EQ(kEncodedHeight, stats.substreams[config_.rtp.ssrcs[1]].height);
pbos@webrtc.org273a4142014-12-01 15:23:21 +0000402}
403
Peter Boström20f3f942015-05-15 11:33:39 +0200404TEST_F(SendStatisticsProxyTest, ClearsResolutionFromInactiveSsrcs) {
405 static const int kEncodedWidth = 123;
406 static const int kEncodedHeight = 81;
407 EncodedImage encoded_image;
408 encoded_image._encodedWidth = kEncodedWidth;
409 encoded_image._encodedHeight = kEncodedHeight;
410
411 RTPVideoHeader rtp_video_header;
412
413 rtp_video_header.simulcastIdx = 0;
414 statistics_proxy_->OnSendEncodedImage(encoded_image, &rtp_video_header);
415 rtp_video_header.simulcastIdx = 1;
416 statistics_proxy_->OnSendEncodedImage(encoded_image, &rtp_video_header);
417
418 statistics_proxy_->OnInactiveSsrc(config_.rtp.ssrcs[1]);
419 VideoSendStream::Stats stats = statistics_proxy_->GetStats();
420 EXPECT_EQ(kEncodedWidth, stats.substreams[config_.rtp.ssrcs[0]].width);
421 EXPECT_EQ(kEncodedHeight, stats.substreams[config_.rtp.ssrcs[0]].height);
422 EXPECT_EQ(0, stats.substreams[config_.rtp.ssrcs[1]].width);
423 EXPECT_EQ(0, stats.substreams[config_.rtp.ssrcs[1]].height);
424}
425
426TEST_F(SendStatisticsProxyTest, ClearsBitratesFromInactiveSsrcs) {
427 BitrateStatistics bitrate;
428 bitrate.bitrate_bps = 42;
429 BitrateStatisticsObserver* observer = statistics_proxy_.get();
430 observer->Notify(bitrate, bitrate, config_.rtp.ssrcs[0]);
431 observer->Notify(bitrate, bitrate, config_.rtp.ssrcs[1]);
432
433 statistics_proxy_->OnInactiveSsrc(config_.rtp.ssrcs[1]);
434
435 VideoSendStream::Stats stats = statistics_proxy_->GetStats();
436 EXPECT_EQ(static_cast<int>(bitrate.bitrate_bps),
437 stats.substreams[config_.rtp.ssrcs[0]].total_bitrate_bps);
438 EXPECT_EQ(static_cast<int>(bitrate.bitrate_bps),
439 stats.substreams[config_.rtp.ssrcs[0]].retransmit_bitrate_bps);
440 EXPECT_EQ(0, stats.substreams[config_.rtp.ssrcs[1]].total_bitrate_bps);
441 EXPECT_EQ(0, stats.substreams[config_.rtp.ssrcs[1]].retransmit_bitrate_bps);
442}
443
sprang07fb9be2016-02-24 07:55:00 -0800444TEST_F(SendStatisticsProxyTest, ResetsRtcpCountersOnContentChange) {
445 RtcpPacketTypeCounterObserver* proxy =
446 static_cast<RtcpPacketTypeCounterObserver*>(statistics_proxy_.get());
447 RtcpPacketTypeCounter counters;
448 counters.first_packet_time_ms = fake_clock_.TimeInMilliseconds();
449 proxy->RtcpPacketTypesCounterUpdated(kFirstSsrc, counters);
450 proxy->RtcpPacketTypesCounterUpdated(kSecondSsrc, counters);
451
452 fake_clock_.AdvanceTimeMilliseconds(1000 * metrics::kMinRunTimeInSeconds);
453
454 counters.nack_packets += 1 * metrics::kMinRunTimeInSeconds;
455 counters.fir_packets += 2 * metrics::kMinRunTimeInSeconds;
456 counters.pli_packets += 3 * metrics::kMinRunTimeInSeconds;
457 counters.unique_nack_requests += 4 * metrics::kMinRunTimeInSeconds;
458 counters.nack_requests += 5 * metrics::kMinRunTimeInSeconds;
459
460 proxy->RtcpPacketTypesCounterUpdated(kFirstSsrc, counters);
461 proxy->RtcpPacketTypesCounterUpdated(kSecondSsrc, counters);
462
463 // Changing content type causes histograms to be reported.
464 statistics_proxy_->SetContentType(VideoEncoderConfig::ContentType::kScreen);
465
466 EXPECT_EQ(1, test::NumHistogramSamples(
467 "WebRTC.Video.NackPacketsReceivedPerMinute"));
468 EXPECT_EQ(
469 1, test::NumHistogramSamples("WebRTC.Video.FirPacketsReceivedPerMinute"));
470 EXPECT_EQ(
471 1, test::NumHistogramSamples("WebRTC.Video.PliPacketsReceivedPerMinute"));
472 EXPECT_EQ(1, test::NumHistogramSamples(
473 "WebRTC.Video.UniqueNackRequestsReceivedInPercent"));
474
475 const int kRate = 60 * 2; // Packets per minute with two streams.
476
477 EXPECT_EQ(1 * kRate, test::LastHistogramSample(
478 "WebRTC.Video.NackPacketsReceivedPerMinute"));
479 EXPECT_EQ(2 * kRate, test::LastHistogramSample(
480 "WebRTC.Video.FirPacketsReceivedPerMinute"));
481 EXPECT_EQ(3 * kRate, test::LastHistogramSample(
482 "WebRTC.Video.PliPacketsReceivedPerMinute"));
483 EXPECT_EQ(4 * 100 / 5,
484 test::LastHistogramSample(
485 "WebRTC.Video.UniqueNackRequestsReceivedInPercent"));
486
487 // New start time but same counter values.
488 proxy->RtcpPacketTypesCounterUpdated(kFirstSsrc, counters);
489 proxy->RtcpPacketTypesCounterUpdated(kSecondSsrc, counters);
490
491 fake_clock_.AdvanceTimeMilliseconds(1000 * metrics::kMinRunTimeInSeconds);
492
493 counters.nack_packets += 1 * metrics::kMinRunTimeInSeconds;
494 counters.fir_packets += 2 * metrics::kMinRunTimeInSeconds;
495 counters.pli_packets += 3 * metrics::kMinRunTimeInSeconds;
496 counters.unique_nack_requests += 4 * metrics::kMinRunTimeInSeconds;
497 counters.nack_requests += 5 * metrics::kMinRunTimeInSeconds;
498
499 proxy->RtcpPacketTypesCounterUpdated(kFirstSsrc, counters);
500 proxy->RtcpPacketTypesCounterUpdated(kSecondSsrc, counters);
501
502 SetUp(); // Reset stats proxy also causes histograms to be reported.
503
504 EXPECT_EQ(1, test::NumHistogramSamples(
505 "WebRTC.Video.Screenshare.NackPacketsReceivedPerMinute"));
506 EXPECT_EQ(1, test::NumHistogramSamples(
507 "WebRTC.Video.Screenshare.FirPacketsReceivedPerMinute"));
508 EXPECT_EQ(1, test::NumHistogramSamples(
509 "WebRTC.Video.Screenshare.PliPacketsReceivedPerMinute"));
510 EXPECT_EQ(
511 1, test::NumHistogramSamples(
512 "WebRTC.Video.Screenshare.UniqueNackRequestsReceivedInPercent"));
513
514 EXPECT_EQ(1 * kRate,
515 test::LastHistogramSample(
516 "WebRTC.Video.Screenshare.NackPacketsReceivedPerMinute"));
517 EXPECT_EQ(2 * kRate,
518 test::LastHistogramSample(
519 "WebRTC.Video.Screenshare.FirPacketsReceivedPerMinute"));
520 EXPECT_EQ(3 * kRate,
521 test::LastHistogramSample(
522 "WebRTC.Video.Screenshare.PliPacketsReceivedPerMinute"));
523 EXPECT_EQ(
524 4 * 100 / 5,
525 test::LastHistogramSample(
526 "WebRTC.Video.Screenshare.UniqueNackRequestsReceivedInPercent"));
527}
528
Erik Språng22c2b482016-03-01 09:40:42 +0100529TEST_F(SendStatisticsProxyTest, ResetsRtpCountersOnContentChange) {
530 StreamDataCountersCallback* proxy =
531 static_cast<StreamDataCountersCallback*>(statistics_proxy_.get());
532 StreamDataCounters counters;
533 StreamDataCounters rtx_counters;
534 counters.first_packet_time_ms = fake_clock_.TimeInMilliseconds();
535 proxy->DataCountersUpdated(counters, kFirstSsrc);
536 proxy->DataCountersUpdated(counters, kSecondSsrc);
537 proxy->DataCountersUpdated(rtx_counters, kFirstRtxSsrc);
538 proxy->DataCountersUpdated(rtx_counters, kSecondRtxSsrc);
539
540 counters.transmitted.header_bytes = 400;
541 counters.transmitted.packets = 20;
542 counters.transmitted.padding_bytes = 1000;
543 counters.transmitted.payload_bytes = 2000;
544
545 counters.retransmitted.header_bytes = 40;
546 counters.retransmitted.packets = 2;
547 counters.retransmitted.padding_bytes = 100;
548 counters.retransmitted.payload_bytes = 200;
549
550 counters.fec = counters.retransmitted;
551
552 rtx_counters.transmitted = counters.transmitted;
553
554 fake_clock_.AdvanceTimeMilliseconds(1000 * metrics::kMinRunTimeInSeconds);
555 proxy->DataCountersUpdated(counters, kFirstSsrc);
556 proxy->DataCountersUpdated(counters, kSecondSsrc);
557 proxy->DataCountersUpdated(rtx_counters, kFirstRtxSsrc);
558 proxy->DataCountersUpdated(rtx_counters, kSecondRtxSsrc);
559
560 // Changing content type causes histograms to be reported.
561 statistics_proxy_->SetContentType(VideoEncoderConfig::ContentType::kScreen);
562
563 EXPECT_EQ(1, test::NumHistogramSamples("WebRTC.Video.BitrateSentInKbps"));
564 EXPECT_EQ(static_cast<int>((counters.transmitted.TotalBytes() * 4 * 8) /
565 metrics::kMinRunTimeInSeconds / 1000),
566 test::LastHistogramSample("WebRTC.Video.BitrateSentInKbps"));
567
568 EXPECT_EQ(1,
569 test::NumHistogramSamples("WebRTC.Video.MediaBitrateSentInKbps"));
570 EXPECT_EQ(static_cast<int>((counters.MediaPayloadBytes() * 2 * 8) /
571 metrics::kMinRunTimeInSeconds / 1000),
572 test::LastHistogramSample("WebRTC.Video.MediaBitrateSentInKbps"));
573
574 EXPECT_EQ(1,
575 test::NumHistogramSamples("WebRTC.Video.PaddingBitrateSentInKbps"));
576 EXPECT_EQ(static_cast<int>((counters.transmitted.padding_bytes * 4 * 8) /
577 metrics::kMinRunTimeInSeconds / 1000),
578 test::LastHistogramSample("WebRTC.Video.PaddingBitrateSentInKbps"));
579
580 EXPECT_EQ(1, test::NumHistogramSamples(
581 "WebRTC.Video.RetransmittedBitrateSentInKbps"));
582 EXPECT_EQ(
583 static_cast<int>((counters.retransmitted.TotalBytes() * 2 * 8) /
584 metrics::kMinRunTimeInSeconds / 1000),
585 test::LastHistogramSample("WebRTC.Video.RetransmittedBitrateSentInKbps"));
586
587 EXPECT_EQ(1, test::NumHistogramSamples("WebRTC.Video.RtxBitrateSentInKbps"));
588 EXPECT_EQ(static_cast<int>((rtx_counters.transmitted.TotalBytes() * 2 * 8) /
589 metrics::kMinRunTimeInSeconds / 1000),
590 test::LastHistogramSample("WebRTC.Video.RtxBitrateSentInKbps"));
591
592 EXPECT_EQ(1, test::NumHistogramSamples("WebRTC.Video.FecBitrateSentInKbps"));
593 EXPECT_EQ(static_cast<int>((rtx_counters.fec.TotalBytes() * 2 * 8) /
594 metrics::kMinRunTimeInSeconds / 1000),
595 test::LastHistogramSample("WebRTC.Video.FecBitrateSentInKbps"));
596
597 // New start time but same counter values.
598 proxy->DataCountersUpdated(counters, kFirstSsrc);
599 proxy->DataCountersUpdated(counters, kSecondSsrc);
600 proxy->DataCountersUpdated(rtx_counters, kFirstRtxSsrc);
601 proxy->DataCountersUpdated(rtx_counters, kSecondRtxSsrc);
602
603 // Double counter values, this should result in the same counts as before but
604 // with new histogram names.
605 StreamDataCounters new_counters = counters;
606 new_counters.Add(counters);
607 StreamDataCounters new_rtx_counters = rtx_counters;
608 new_rtx_counters.Add(rtx_counters);
609
610 fake_clock_.AdvanceTimeMilliseconds(1000 * metrics::kMinRunTimeInSeconds);
611 proxy->DataCountersUpdated(new_counters, kFirstSsrc);
612 proxy->DataCountersUpdated(new_counters, kSecondSsrc);
613 proxy->DataCountersUpdated(new_rtx_counters, kFirstRtxSsrc);
614 proxy->DataCountersUpdated(new_rtx_counters, kSecondRtxSsrc);
615
616 SetUp(); // Reset stats proxy also causes histograms to be reported.
617
618 EXPECT_EQ(1, test::NumHistogramSamples(
619 "WebRTC.Video.Screenshare.BitrateSentInKbps"));
620 EXPECT_EQ(
621 static_cast<int>((counters.transmitted.TotalBytes() * 4 * 8) /
622 metrics::kMinRunTimeInSeconds / 1000),
623 test::LastHistogramSample("WebRTC.Video.Screenshare.BitrateSentInKbps"));
624
625 EXPECT_EQ(1, test::NumHistogramSamples(
626 "WebRTC.Video.Screenshare.MediaBitrateSentInKbps"));
627 EXPECT_EQ(static_cast<int>((counters.MediaPayloadBytes() * 2 * 8) /
628 metrics::kMinRunTimeInSeconds / 1000),
629 test::LastHistogramSample(
630 "WebRTC.Video.Screenshare.MediaBitrateSentInKbps"));
631
632 EXPECT_EQ(1, test::NumHistogramSamples(
633 "WebRTC.Video.Screenshare.PaddingBitrateSentInKbps"));
634 EXPECT_EQ(static_cast<int>((counters.transmitted.padding_bytes * 4 * 8) /
635 metrics::kMinRunTimeInSeconds / 1000),
636 test::LastHistogramSample(
637 "WebRTC.Video.Screenshare.PaddingBitrateSentInKbps"));
638
639 EXPECT_EQ(1, test::NumHistogramSamples(
640 "WebRTC.Video.Screenshare.RetransmittedBitrateSentInKbps"));
641 EXPECT_EQ(static_cast<int>((counters.retransmitted.TotalBytes() * 2 * 8) /
642 metrics::kMinRunTimeInSeconds / 1000),
643 test::LastHistogramSample(
644 "WebRTC.Video.Screenshare.RetransmittedBitrateSentInKbps"));
645
646 EXPECT_EQ(1, test::NumHistogramSamples(
647 "WebRTC.Video.Screenshare.RtxBitrateSentInKbps"));
648 EXPECT_EQ(static_cast<int>((rtx_counters.transmitted.TotalBytes() * 2 * 8) /
649 metrics::kMinRunTimeInSeconds / 1000),
650 test::LastHistogramSample(
651 "WebRTC.Video.Screenshare.RtxBitrateSentInKbps"));
652
653 EXPECT_EQ(1, test::NumHistogramSamples(
654 "WebRTC.Video.Screenshare.FecBitrateSentInKbps"));
655 EXPECT_EQ(static_cast<int>((rtx_counters.fec.TotalBytes() * 2 * 8) /
656 metrics::kMinRunTimeInSeconds / 1000),
657 test::LastHistogramSample(
658 "WebRTC.Video.Screenshare.FecBitrateSentInKbps"));
659}
660
sprang@webrtc.orgccd42842014-01-07 09:54:34 +0000661} // namespace webrtc