blob: c70c3e829fefda5c692bacb4a1917fd6e3234116 [file] [log] [blame]
perkj26091b12016-09-01 01:17:40 -07001/*
2 * Copyright (c) 2016 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
Erik Språng4529fbc2018-10-12 10:30:31 +020011#include "video/video_stream_encoder.h"
12
sprangfe627f32017-03-29 08:24:59 -070013#include <algorithm>
perkj803d97f2016-11-01 11:45:46 -070014#include <limits>
Danil Chapovalovd3ba2362019-04-10 17:01:23 +020015#include <memory>
Per512ecb32016-09-23 15:52:06 +020016#include <utility>
17
Mirta Dvornicic28f0eb22019-05-28 16:30:16 +020018#include "absl/memory/memory.h"
Danil Chapovalovd3ba2362019-04-10 17:01:23 +020019#include "api/task_queue/default_task_queue_factory.h"
Elad Alon45befc52019-07-02 11:20:09 +020020#include "api/test/mock_fec_controller_override.h"
Jiawei Ouc2ebe212018-11-08 10:02:56 -080021#include "api/video/builtin_video_bitrate_allocator_factory.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020022#include "api/video/i420_buffer.h"
Erik Språngf93eda12019-01-16 17:10:57 +010023#include "api/video/video_bitrate_allocation.h"
Elad Alon370f93a2019-06-11 14:57:57 +020024#include "api/video_codecs/video_encoder.h"
Erik Språng4529fbc2018-10-12 10:30:31 +020025#include "api/video_codecs/vp8_temporal_layers.h"
Elad Aloncde8ab22019-03-20 11:56:20 +010026#include "api/video_codecs/vp8_temporal_layers_factory.h"
Mirta Dvornicic28f0eb22019-05-28 16:30:16 +020027#include "common_video/h264/h264_common.h"
Noah Richards51db4212019-06-12 06:59:12 -070028#include "common_video/include/video_frame_buffer.h"
Steve Anton10542f22019-01-11 09:11:00 -080029#include "media/base/video_adapter.h"
Sergey Silkin86684962018-03-28 19:32:37 +020030#include "modules/video_coding/codecs/vp9/include/vp9_globals.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020031#include "modules/video_coding/utility/default_video_bitrate_allocator.h"
Åsa Perssonc29cb2c2019-03-25 12:06:59 +010032#include "modules/video_coding/utility/simulcast_rate_allocator.h"
Steve Anton10542f22019-01-11 09:11:00 -080033#include "rtc_base/fake_clock.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020034#include "rtc_base/logging.h"
Steve Anton10542f22019-01-11 09:11:00 -080035#include "rtc_base/ref_counted_object.h"
Erik Språng7ca375c2019-02-06 16:20:17 +010036#include "system_wrappers/include/field_trial.h"
Mirko Bonadei17f48782018-09-28 08:51:10 +020037#include "system_wrappers/include/metrics.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020038#include "system_wrappers/include/sleep.h"
39#include "test/encoder_settings.h"
40#include "test/fake_encoder.h"
Kári Tristan Helgason639602a2018-08-02 10:51:40 +020041#include "test/field_trial.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020042#include "test/frame_generator.h"
43#include "test/gmock.h"
44#include "test/gtest.h"
Niels Möllercbcbc222018-09-28 09:07:24 +020045#include "test/video_encoder_proxy_factory.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020046#include "video/send_statistics_proxy.h"
perkj26091b12016-09-01 01:17:40 -070047
48namespace webrtc {
49
sprangb1ca0732017-02-01 08:38:12 -080050using ScaleReason = AdaptationObserverInterface::AdaptReason;
sprang57c2fff2017-01-16 06:24:02 -080051using ::testing::_;
kthelgason876222f2016-11-29 01:44:11 -080052
perkj803d97f2016-11-01 11:45:46 -070053namespace {
Åsa Persson8c1bf952018-09-13 10:42:19 +020054const int kMinPixelsPerFrame = 320 * 180;
55const int kMinFramerateFps = 2;
56const int kMinBalancedFramerateFps = 7;
57const int64_t kFrameTimeoutMs = 100;
asapersson5f7226f2016-11-25 04:37:00 -080058const size_t kMaxPayloadLength = 1440;
Erik Språngd7329ca2019-02-21 21:19:53 +010059const uint32_t kTargetBitrateBps = 1000000;
Sergey Silkin5ee69672019-07-02 14:18:34 +020060const uint32_t kStartBitrateBps = 600000;
Erik Språngd7329ca2019-02-21 21:19:53 +010061const uint32_t kSimulcastTargetBitrateBps = 3150000;
62const uint32_t kLowTargetBitrateBps = kTargetBitrateBps / 10;
kthelgason2bc68642017-02-07 07:02:22 -080063const int kMaxInitialFramedrop = 4;
sprangfda496a2017-06-15 04:21:07 -070064const int kDefaultFramerate = 30;
Åsa Persson8c1bf952018-09-13 10:42:19 +020065const int64_t kFrameIntervalMs = rtc::kNumMillisecsPerSec / kDefaultFramerate;
asapersson5f7226f2016-11-25 04:37:00 -080066
Mirta Dvornicic28f0eb22019-05-28 16:30:16 +020067uint8_t optimal_sps[] = {0, 0, 0, 1, H264::NaluType::kSps,
68 0x00, 0x00, 0x03, 0x03, 0xF4,
69 0x05, 0x03, 0xC7, 0xE0, 0x1B,
70 0x41, 0x10, 0x8D, 0x00};
71
perkj803d97f2016-11-01 11:45:46 -070072class TestBuffer : public webrtc::I420Buffer {
73 public:
74 TestBuffer(rtc::Event* event, int width, int height)
75 : I420Buffer(width, height), event_(event) {}
76
77 private:
78 friend class rtc::RefCountedObject<TestBuffer>;
79 ~TestBuffer() override {
80 if (event_)
81 event_->Set();
82 }
83 rtc::Event* const event_;
84};
85
Noah Richards51db4212019-06-12 06:59:12 -070086// A fake native buffer that can't be converted to I420.
87class FakeNativeBuffer : public webrtc::VideoFrameBuffer {
88 public:
89 FakeNativeBuffer(rtc::Event* event, int width, int height)
90 : event_(event), width_(width), height_(height) {}
91 webrtc::VideoFrameBuffer::Type type() const override { return Type::kNative; }
92 int width() const override { return width_; }
93 int height() const override { return height_; }
94 rtc::scoped_refptr<webrtc::I420BufferInterface> ToI420() override {
95 return nullptr;
96 }
97
98 private:
99 friend class rtc::RefCountedObject<FakeNativeBuffer>;
100 ~FakeNativeBuffer() override {
101 if (event_)
102 event_->Set();
103 }
104 rtc::Event* const event_;
105 const int width_;
106 const int height_;
107};
108
Niels Möller7dc26b72017-12-06 10:27:48 +0100109class CpuOveruseDetectorProxy : public OveruseFrameDetector {
110 public:
Niels Möllerd1f7eb62018-03-28 16:40:58 +0200111 explicit CpuOveruseDetectorProxy(CpuOveruseMetricsObserver* metrics_observer)
112 : OveruseFrameDetector(metrics_observer),
Niels Möller7dc26b72017-12-06 10:27:48 +0100113 last_target_framerate_fps_(-1) {}
114 virtual ~CpuOveruseDetectorProxy() {}
115
116 void OnTargetFramerateUpdated(int framerate_fps) override {
117 rtc::CritScope cs(&lock_);
118 last_target_framerate_fps_ = framerate_fps;
119 OveruseFrameDetector::OnTargetFramerateUpdated(framerate_fps);
120 }
121
122 int GetLastTargetFramerate() {
123 rtc::CritScope cs(&lock_);
124 return last_target_framerate_fps_;
125 }
126
Niels Möller4db138e2018-04-19 09:04:13 +0200127 CpuOveruseOptions GetOptions() { return options_; }
128
Niels Möller7dc26b72017-12-06 10:27:48 +0100129 private:
130 rtc::CriticalSection lock_;
131 int last_target_framerate_fps_ RTC_GUARDED_BY(lock_);
132};
133
mflodmancc3d4422017-08-03 08:27:51 -0700134class VideoStreamEncoderUnderTest : public VideoStreamEncoder {
perkj803d97f2016-11-01 11:45:46 -0700135 public:
Niels Möller213618e2018-07-24 09:29:58 +0200136 VideoStreamEncoderUnderTest(SendStatisticsProxy* stats_proxy,
Danil Chapovalovd3ba2362019-04-10 17:01:23 +0200137 const VideoStreamEncoderSettings& settings,
138 TaskQueueFactory* task_queue_factory)
Sebastian Jansson572c60f2019-03-04 18:30:41 +0100139 : VideoStreamEncoder(Clock::GetRealTimeClock(),
140 1 /* number_of_cores */,
Yves Gerey665174f2018-06-19 15:03:05 +0200141 stats_proxy,
142 settings,
Yves Gerey665174f2018-06-19 15:03:05 +0200143 std::unique_ptr<OveruseFrameDetector>(
144 overuse_detector_proxy_ =
Sebastian Jansson74682c12019-03-01 11:50:20 +0100145 new CpuOveruseDetectorProxy(stats_proxy)),
Danil Chapovalovd3ba2362019-04-10 17:01:23 +0200146 task_queue_factory) {}
perkj803d97f2016-11-01 11:45:46 -0700147
sprangb1ca0732017-02-01 08:38:12 -0800148 void PostTaskAndWait(bool down, AdaptReason reason) {
Niels Möllerc572ff32018-11-07 08:43:50 +0100149 rtc::Event event;
kthelgason876222f2016-11-29 01:44:11 -0800150 encoder_queue()->PostTask([this, &event, reason, down] {
sprangb1ca0732017-02-01 08:38:12 -0800151 down ? AdaptDown(reason) : AdaptUp(reason);
perkj803d97f2016-11-01 11:45:46 -0700152 event.Set();
153 });
perkj070ba852017-02-16 15:46:27 -0800154 ASSERT_TRUE(event.Wait(5000));
perkj803d97f2016-11-01 11:45:46 -0700155 }
156
kthelgason2fc52542017-03-03 00:24:41 -0800157 // This is used as a synchronisation mechanism, to make sure that the
158 // encoder queue is not blocked before we start sending it frames.
159 void WaitUntilTaskQueueIsIdle() {
Niels Möllerc572ff32018-11-07 08:43:50 +0100160 rtc::Event event;
Yves Gerey665174f2018-06-19 15:03:05 +0200161 encoder_queue()->PostTask([&event] { event.Set(); });
kthelgason2fc52542017-03-03 00:24:41 -0800162 ASSERT_TRUE(event.Wait(5000));
163 }
164
sprangb1ca0732017-02-01 08:38:12 -0800165 void TriggerCpuOveruse() { PostTaskAndWait(true, AdaptReason::kCpu); }
kthelgason876222f2016-11-29 01:44:11 -0800166
sprangb1ca0732017-02-01 08:38:12 -0800167 void TriggerCpuNormalUsage() { PostTaskAndWait(false, AdaptReason::kCpu); }
kthelgason876222f2016-11-29 01:44:11 -0800168
sprangb1ca0732017-02-01 08:38:12 -0800169 void TriggerQualityLow() { PostTaskAndWait(true, AdaptReason::kQuality); }
kthelgason876222f2016-11-29 01:44:11 -0800170
sprangb1ca0732017-02-01 08:38:12 -0800171 void TriggerQualityHigh() { PostTaskAndWait(false, AdaptReason::kQuality); }
sprangfda496a2017-06-15 04:21:07 -0700172
Niels Möller7dc26b72017-12-06 10:27:48 +0100173 CpuOveruseDetectorProxy* overuse_detector_proxy_;
perkj803d97f2016-11-01 11:45:46 -0700174};
175
asapersson5f7226f2016-11-25 04:37:00 -0800176class VideoStreamFactory
177 : public VideoEncoderConfig::VideoStreamFactoryInterface {
178 public:
sprangfda496a2017-06-15 04:21:07 -0700179 explicit VideoStreamFactory(size_t num_temporal_layers, int framerate)
180 : num_temporal_layers_(num_temporal_layers), framerate_(framerate) {
asapersson5f7226f2016-11-25 04:37:00 -0800181 EXPECT_GT(num_temporal_layers, 0u);
sprangfda496a2017-06-15 04:21:07 -0700182 EXPECT_GT(framerate, 0);
asapersson5f7226f2016-11-25 04:37:00 -0800183 }
184
185 private:
186 std::vector<VideoStream> CreateEncoderStreams(
187 int width,
188 int height,
189 const VideoEncoderConfig& encoder_config) override {
190 std::vector<VideoStream> streams =
191 test::CreateVideoStreams(width, height, encoder_config);
192 for (VideoStream& stream : streams) {
Sergey Silkina796a7e2018-03-01 15:11:29 +0100193 stream.num_temporal_layers = num_temporal_layers_;
sprangfda496a2017-06-15 04:21:07 -0700194 stream.max_framerate = framerate_;
asapersson5f7226f2016-11-25 04:37:00 -0800195 }
196 return streams;
197 }
sprangfda496a2017-06-15 04:21:07 -0700198
asapersson5f7226f2016-11-25 04:37:00 -0800199 const size_t num_temporal_layers_;
sprangfda496a2017-06-15 04:21:07 -0700200 const int framerate_;
asapersson5f7226f2016-11-25 04:37:00 -0800201};
202
Noah Richards51db4212019-06-12 06:59:12 -0700203// Simulates simulcast behavior and makes highest stream resolutions divisible
204// by 4.
205class CroppingVideoStreamFactory
206 : public VideoEncoderConfig::VideoStreamFactoryInterface {
207 public:
208 explicit CroppingVideoStreamFactory(size_t num_temporal_layers, int framerate)
209 : num_temporal_layers_(num_temporal_layers), framerate_(framerate) {
210 EXPECT_GT(num_temporal_layers, 0u);
211 EXPECT_GT(framerate, 0);
212 }
213
214 private:
215 std::vector<VideoStream> CreateEncoderStreams(
216 int width,
217 int height,
218 const VideoEncoderConfig& encoder_config) override {
219 std::vector<VideoStream> streams = test::CreateVideoStreams(
220 width - width % 4, height - height % 4, encoder_config);
221 for (VideoStream& stream : streams) {
222 stream.num_temporal_layers = num_temporal_layers_;
223 stream.max_framerate = framerate_;
224 }
225 return streams;
226 }
227
228 const size_t num_temporal_layers_;
229 const int framerate_;
230};
231
sprangb1ca0732017-02-01 08:38:12 -0800232class AdaptingFrameForwarder : public test::FrameForwarder {
233 public:
234 AdaptingFrameForwarder() : adaptation_enabled_(false) {}
asaperssonfab67072017-04-04 05:51:49 -0700235 ~AdaptingFrameForwarder() override {}
sprangb1ca0732017-02-01 08:38:12 -0800236
237 void set_adaptation_enabled(bool enabled) {
238 rtc::CritScope cs(&crit_);
239 adaptation_enabled_ = enabled;
240 }
241
asaperssonfab67072017-04-04 05:51:49 -0700242 bool adaption_enabled() const {
sprangb1ca0732017-02-01 08:38:12 -0800243 rtc::CritScope cs(&crit_);
244 return adaptation_enabled_;
245 }
246
asapersson09f05612017-05-15 23:40:18 -0700247 rtc::VideoSinkWants last_wants() const {
248 rtc::CritScope cs(&crit_);
249 return last_wants_;
250 }
251
Danil Chapovalovb9b146c2018-06-15 12:28:07 +0200252 absl::optional<int> last_sent_width() const { return last_width_; }
253 absl::optional<int> last_sent_height() const { return last_height_; }
Jonathan Yubc771b72017-12-08 17:04:29 -0800254
sprangb1ca0732017-02-01 08:38:12 -0800255 void IncomingCapturedFrame(const VideoFrame& video_frame) override {
256 int cropped_width = 0;
257 int cropped_height = 0;
258 int out_width = 0;
259 int out_height = 0;
sprangc5d62e22017-04-02 23:53:04 -0700260 if (adaption_enabled()) {
261 if (adapter_.AdaptFrameResolution(
262 video_frame.width(), video_frame.height(),
263 video_frame.timestamp_us() * 1000, &cropped_width,
264 &cropped_height, &out_width, &out_height)) {
Artem Titov1ebfb6a2019-01-03 23:49:37 +0100265 VideoFrame adapted_frame =
266 VideoFrame::Builder()
267 .set_video_frame_buffer(new rtc::RefCountedObject<TestBuffer>(
268 nullptr, out_width, out_height))
269 .set_timestamp_rtp(99)
270 .set_timestamp_ms(99)
271 .set_rotation(kVideoRotation_0)
272 .build();
sprangc5d62e22017-04-02 23:53:04 -0700273 adapted_frame.set_ntp_time_ms(video_frame.ntp_time_ms());
274 test::FrameForwarder::IncomingCapturedFrame(adapted_frame);
Jonathan Yubc771b72017-12-08 17:04:29 -0800275 last_width_.emplace(adapted_frame.width());
276 last_height_.emplace(adapted_frame.height());
277 } else {
Danil Chapovalovb9b146c2018-06-15 12:28:07 +0200278 last_width_ = absl::nullopt;
279 last_height_ = absl::nullopt;
sprangc5d62e22017-04-02 23:53:04 -0700280 }
sprangb1ca0732017-02-01 08:38:12 -0800281 } else {
282 test::FrameForwarder::IncomingCapturedFrame(video_frame);
Jonathan Yubc771b72017-12-08 17:04:29 -0800283 last_width_.emplace(video_frame.width());
284 last_height_.emplace(video_frame.height());
sprangb1ca0732017-02-01 08:38:12 -0800285 }
286 }
287
288 void AddOrUpdateSink(rtc::VideoSinkInterface<VideoFrame>* sink,
289 const rtc::VideoSinkWants& wants) override {
290 rtc::CritScope cs(&crit_);
asapersson09f05612017-05-15 23:40:18 -0700291 last_wants_ = sink_wants();
sprangc5d62e22017-04-02 23:53:04 -0700292 adapter_.OnResolutionFramerateRequest(wants.target_pixel_count,
293 wants.max_pixel_count,
294 wants.max_framerate_fps);
sprangb1ca0732017-02-01 08:38:12 -0800295 test::FrameForwarder::AddOrUpdateSink(sink, wants);
296 }
sprangb1ca0732017-02-01 08:38:12 -0800297 cricket::VideoAdapter adapter_;
danilchapa37de392017-09-09 04:17:22 -0700298 bool adaptation_enabled_ RTC_GUARDED_BY(crit_);
299 rtc::VideoSinkWants last_wants_ RTC_GUARDED_BY(crit_);
Danil Chapovalovb9b146c2018-06-15 12:28:07 +0200300 absl::optional<int> last_width_;
301 absl::optional<int> last_height_;
sprangb1ca0732017-02-01 08:38:12 -0800302};
sprangc5d62e22017-04-02 23:53:04 -0700303
Niels Möller213618e2018-07-24 09:29:58 +0200304// TODO(nisse): Mock only VideoStreamEncoderObserver.
sprangc5d62e22017-04-02 23:53:04 -0700305class MockableSendStatisticsProxy : public SendStatisticsProxy {
306 public:
307 MockableSendStatisticsProxy(Clock* clock,
308 const VideoSendStream::Config& config,
309 VideoEncoderConfig::ContentType content_type)
310 : SendStatisticsProxy(clock, config, content_type) {}
311
312 VideoSendStream::Stats GetStats() override {
313 rtc::CritScope cs(&lock_);
314 if (mock_stats_)
315 return *mock_stats_;
316 return SendStatisticsProxy::GetStats();
317 }
318
Niels Möller213618e2018-07-24 09:29:58 +0200319 int GetInputFrameRate() const override {
320 rtc::CritScope cs(&lock_);
321 if (mock_stats_)
322 return mock_stats_->input_frame_rate;
323 return SendStatisticsProxy::GetInputFrameRate();
324 }
sprangc5d62e22017-04-02 23:53:04 -0700325 void SetMockStats(const VideoSendStream::Stats& stats) {
326 rtc::CritScope cs(&lock_);
327 mock_stats_.emplace(stats);
328 }
329
330 void ResetMockStats() {
331 rtc::CritScope cs(&lock_);
332 mock_stats_.reset();
333 }
334
335 private:
336 rtc::CriticalSection lock_;
Danil Chapovalovb9b146c2018-06-15 12:28:07 +0200337 absl::optional<VideoSendStream::Stats> mock_stats_ RTC_GUARDED_BY(lock_);
sprangc5d62e22017-04-02 23:53:04 -0700338};
339
sprang4847ae62017-06-27 07:06:52 -0700340class MockBitrateObserver : public VideoBitrateAllocationObserver {
341 public:
Erik Språng566124a2018-04-23 12:32:22 +0200342 MOCK_METHOD1(OnBitrateAllocationUpdated, void(const VideoBitrateAllocation&));
sprang4847ae62017-06-27 07:06:52 -0700343};
344
perkj803d97f2016-11-01 11:45:46 -0700345} // namespace
346
mflodmancc3d4422017-08-03 08:27:51 -0700347class VideoStreamEncoderTest : public ::testing::Test {
perkj26091b12016-09-01 01:17:40 -0700348 public:
349 static const int kDefaultTimeoutMs = 30 * 1000;
350
mflodmancc3d4422017-08-03 08:27:51 -0700351 VideoStreamEncoderTest()
perkj26091b12016-09-01 01:17:40 -0700352 : video_send_config_(VideoSendStream::Config(nullptr)),
perkjfa10b552016-10-02 23:45:26 -0700353 codec_width_(320),
354 codec_height_(240),
Åsa Persson8c1bf952018-09-13 10:42:19 +0200355 max_framerate_(kDefaultFramerate),
Danil Chapovalovd3ba2362019-04-10 17:01:23 +0200356 task_queue_factory_(CreateDefaultTaskQueueFactory()),
perkj26091b12016-09-01 01:17:40 -0700357 fake_encoder_(),
Niels Möller4db138e2018-04-19 09:04:13 +0200358 encoder_factory_(&fake_encoder_),
sprangc5d62e22017-04-02 23:53:04 -0700359 stats_proxy_(new MockableSendStatisticsProxy(
perkj803d97f2016-11-01 11:45:46 -0700360 Clock::GetRealTimeClock(),
361 video_send_config_,
362 webrtc::VideoEncoderConfig::ContentType::kRealtimeVideo)),
perkj26091b12016-09-01 01:17:40 -0700363 sink_(&fake_encoder_) {}
364
365 void SetUp() override {
perkj803d97f2016-11-01 11:45:46 -0700366 metrics::Reset();
perkj26091b12016-09-01 01:17:40 -0700367 video_send_config_ = VideoSendStream::Config(nullptr);
Niels Möller4db138e2018-04-19 09:04:13 +0200368 video_send_config_.encoder_settings.encoder_factory = &encoder_factory_;
Jiawei Ouc2ebe212018-11-08 10:02:56 -0800369 video_send_config_.encoder_settings.bitrate_allocator_factory =
Sergey Silkin5ee69672019-07-02 14:18:34 +0200370 &bitrate_allocator_factory_;
Niels Möller259a4972018-04-05 15:36:51 +0200371 video_send_config_.rtp.payload_name = "FAKE";
372 video_send_config_.rtp.payload_type = 125;
perkj26091b12016-09-01 01:17:40 -0700373
Per512ecb32016-09-23 15:52:06 +0200374 VideoEncoderConfig video_encoder_config;
Niels Möller259a4972018-04-05 15:36:51 +0200375 test::FillEncoderConfiguration(kVideoCodecVP8, 1, &video_encoder_config);
sprang4847ae62017-06-27 07:06:52 -0700376 video_encoder_config.video_stream_factory =
377 new rtc::RefCountedObject<VideoStreamFactory>(1, max_framerate_);
Erik Språng08127a92016-11-16 16:41:30 +0100378 video_encoder_config_ = video_encoder_config.Copy();
sprang4847ae62017-06-27 07:06:52 -0700379
380 // Framerate limit is specified by the VideoStreamFactory.
381 std::vector<VideoStream> streams =
382 video_encoder_config.video_stream_factory->CreateEncoderStreams(
383 codec_width_, codec_height_, video_encoder_config);
384 max_framerate_ = streams[0].max_framerate;
Sebastian Jansson40889f32019-04-17 12:11:20 +0200385 fake_clock_.SetTime(Timestamp::us(1234));
sprang4847ae62017-06-27 07:06:52 -0700386
Niels Möllerf1338562018-04-26 09:51:47 +0200387 ConfigureEncoder(std::move(video_encoder_config));
asapersson5f7226f2016-11-25 04:37:00 -0800388 }
389
Niels Möllerf1338562018-04-26 09:51:47 +0200390 void ConfigureEncoder(VideoEncoderConfig video_encoder_config) {
mflodmancc3d4422017-08-03 08:27:51 -0700391 if (video_stream_encoder_)
392 video_stream_encoder_->Stop();
393 video_stream_encoder_.reset(new VideoStreamEncoderUnderTest(
Danil Chapovalovd3ba2362019-04-10 17:01:23 +0200394 stats_proxy_.get(), video_send_config_.encoder_settings,
395 task_queue_factory_.get()));
mflodmancc3d4422017-08-03 08:27:51 -0700396 video_stream_encoder_->SetSink(&sink_, false /* rotation_applied */);
397 video_stream_encoder_->SetSource(
Taylor Brandstetter49fcc102018-05-16 14:20:41 -0700398 &video_source_, webrtc::DegradationPreference::MAINTAIN_FRAMERATE);
mflodmancc3d4422017-08-03 08:27:51 -0700399 video_stream_encoder_->SetStartBitrate(kTargetBitrateBps);
400 video_stream_encoder_->ConfigureEncoder(std::move(video_encoder_config),
Niels Möllerf1338562018-04-26 09:51:47 +0200401 kMaxPayloadLength);
mflodmancc3d4422017-08-03 08:27:51 -0700402 video_stream_encoder_->WaitUntilTaskQueueIsIdle();
asapersson5f7226f2016-11-25 04:37:00 -0800403 }
404
405 void ResetEncoder(const std::string& payload_name,
406 size_t num_streams,
407 size_t num_temporal_layers,
emircanbbcc3562017-08-18 00:28:40 -0700408 unsigned char num_spatial_layers,
sprang4847ae62017-06-27 07:06:52 -0700409 bool screenshare) {
Niels Möller259a4972018-04-05 15:36:51 +0200410 video_send_config_.rtp.payload_name = payload_name;
asapersson5f7226f2016-11-25 04:37:00 -0800411
412 VideoEncoderConfig video_encoder_config;
Niels Möller259a4972018-04-05 15:36:51 +0200413 video_encoder_config.codec_type = PayloadStringToCodecType(payload_name);
asapersson5f7226f2016-11-25 04:37:00 -0800414 video_encoder_config.number_of_streams = num_streams;
Erik Språngd7329ca2019-02-21 21:19:53 +0100415 video_encoder_config.max_bitrate_bps =
416 num_streams == 1 ? kTargetBitrateBps : kSimulcastTargetBitrateBps;
asapersson5f7226f2016-11-25 04:37:00 -0800417 video_encoder_config.video_stream_factory =
sprangfda496a2017-06-15 04:21:07 -0700418 new rtc::RefCountedObject<VideoStreamFactory>(num_temporal_layers,
419 kDefaultFramerate);
sprang4847ae62017-06-27 07:06:52 -0700420 video_encoder_config.content_type =
421 screenshare ? VideoEncoderConfig::ContentType::kScreen
422 : VideoEncoderConfig::ContentType::kRealtimeVideo;
emircanbbcc3562017-08-18 00:28:40 -0700423 if (payload_name == "VP9") {
424 VideoCodecVP9 vp9_settings = VideoEncoder::GetDefaultVp9Settings();
425 vp9_settings.numberOfSpatialLayers = num_spatial_layers;
426 video_encoder_config.encoder_specific_settings =
427 new rtc::RefCountedObject<
428 VideoEncoderConfig::Vp9EncoderSpecificSettings>(vp9_settings);
429 }
Niels Möllerf1338562018-04-26 09:51:47 +0200430 ConfigureEncoder(std::move(video_encoder_config));
perkj26091b12016-09-01 01:17:40 -0700431 }
432
sprang57c2fff2017-01-16 06:24:02 -0800433 VideoFrame CreateFrame(int64_t ntp_time_ms,
434 rtc::Event* destruction_event) const {
Artem Titov1ebfb6a2019-01-03 23:49:37 +0100435 VideoFrame frame =
436 VideoFrame::Builder()
437 .set_video_frame_buffer(new rtc::RefCountedObject<TestBuffer>(
438 destruction_event, codec_width_, codec_height_))
439 .set_timestamp_rtp(99)
440 .set_timestamp_ms(99)
441 .set_rotation(kVideoRotation_0)
442 .build();
sprang57c2fff2017-01-16 06:24:02 -0800443 frame.set_ntp_time_ms(ntp_time_ms);
perkj26091b12016-09-01 01:17:40 -0700444 return frame;
445 }
446
Ilya Nikolaevskiy71aee3a2019-02-18 13:01:26 +0100447 VideoFrame CreateFrameWithUpdatedPixel(int64_t ntp_time_ms,
448 rtc::Event* destruction_event,
449 int offset_x) const {
450 VideoFrame frame =
451 VideoFrame::Builder()
452 .set_video_frame_buffer(new rtc::RefCountedObject<TestBuffer>(
453 destruction_event, codec_width_, codec_height_))
454 .set_timestamp_rtp(99)
455 .set_timestamp_ms(99)
456 .set_rotation(kVideoRotation_0)
457 .set_update_rect({offset_x, 0, 1, 1})
458 .build();
459 frame.set_ntp_time_ms(ntp_time_ms);
460 return frame;
461 }
462
sprang57c2fff2017-01-16 06:24:02 -0800463 VideoFrame CreateFrame(int64_t ntp_time_ms, int width, int height) const {
Artem Titov1ebfb6a2019-01-03 23:49:37 +0100464 VideoFrame frame =
465 VideoFrame::Builder()
466 .set_video_frame_buffer(
467 new rtc::RefCountedObject<TestBuffer>(nullptr, width, height))
468 .set_timestamp_rtp(99)
469 .set_timestamp_ms(99)
470 .set_rotation(kVideoRotation_0)
471 .build();
sprang57c2fff2017-01-16 06:24:02 -0800472 frame.set_ntp_time_ms(ntp_time_ms);
sprangc5d62e22017-04-02 23:53:04 -0700473 frame.set_timestamp_us(ntp_time_ms * 1000);
perkj803d97f2016-11-01 11:45:46 -0700474 return frame;
475 }
476
Noah Richards51db4212019-06-12 06:59:12 -0700477 VideoFrame CreateFakeNativeFrame(int64_t ntp_time_ms,
478 rtc::Event* destruction_event,
479 int width,
480 int height) const {
481 VideoFrame frame =
482 VideoFrame::Builder()
483 .set_video_frame_buffer(new rtc::RefCountedObject<FakeNativeBuffer>(
484 destruction_event, width, height))
485 .set_timestamp_rtp(99)
486 .set_timestamp_ms(99)
487 .set_rotation(kVideoRotation_0)
488 .build();
489 frame.set_ntp_time_ms(ntp_time_ms);
490 return frame;
491 }
492
493 VideoFrame CreateFakeNativeFrame(int64_t ntp_time_ms,
494 rtc::Event* destruction_event) const {
495 return CreateFakeNativeFrame(ntp_time_ms, destruction_event, codec_width_,
496 codec_height_);
497 }
498
Åsa Perssonc29cb2c2019-03-25 12:06:59 +0100499 void VerifyAllocatedBitrate(const VideoBitrateAllocation& expected_bitrate) {
500 MockBitrateObserver bitrate_observer;
501 video_stream_encoder_->SetBitrateAllocationObserver(&bitrate_observer);
502
503 EXPECT_CALL(bitrate_observer, OnBitrateAllocationUpdated(expected_bitrate))
504 .Times(1);
505 video_stream_encoder_->OnBitrateUpdated(DataRate::bps(kTargetBitrateBps),
Erik Språng4c6ca302019-04-08 15:14:01 +0200506 DataRate::bps(kTargetBitrateBps), 0,
507 0);
Åsa Perssonc29cb2c2019-03-25 12:06:59 +0100508
509 video_source_.IncomingCapturedFrame(
510 CreateFrame(1, codec_width_, codec_height_));
511 WaitForEncodedFrame(1);
512 }
513
asapersson02465b82017-04-10 01:12:52 -0700514 void VerifyNoLimitation(const rtc::VideoSinkWants& wants) {
asapersson02465b82017-04-10 01:12:52 -0700515 EXPECT_EQ(std::numeric_limits<int>::max(), wants.max_framerate_fps);
asapersson09f05612017-05-15 23:40:18 -0700516 EXPECT_EQ(std::numeric_limits<int>::max(), wants.max_pixel_count);
517 EXPECT_FALSE(wants.target_pixel_count);
asapersson02465b82017-04-10 01:12:52 -0700518 }
519
asapersson09f05612017-05-15 23:40:18 -0700520 void VerifyFpsEqResolutionEq(const rtc::VideoSinkWants& wants1,
521 const rtc::VideoSinkWants& wants2) {
522 EXPECT_EQ(wants1.max_framerate_fps, wants2.max_framerate_fps);
523 EXPECT_EQ(wants1.max_pixel_count, wants2.max_pixel_count);
524 }
525
Åsa Persson8c1bf952018-09-13 10:42:19 +0200526 void VerifyFpsMaxResolutionMax(const rtc::VideoSinkWants& wants) {
527 EXPECT_EQ(kDefaultFramerate, wants.max_framerate_fps);
528 EXPECT_EQ(std::numeric_limits<int>::max(), wants.max_pixel_count);
529 EXPECT_FALSE(wants.target_pixel_count);
530 }
531
asapersson09f05612017-05-15 23:40:18 -0700532 void VerifyFpsMaxResolutionLt(const rtc::VideoSinkWants& wants1,
533 const rtc::VideoSinkWants& wants2) {
Åsa Persson8c1bf952018-09-13 10:42:19 +0200534 EXPECT_EQ(kDefaultFramerate, wants1.max_framerate_fps);
asapersson09f05612017-05-15 23:40:18 -0700535 EXPECT_LT(wants1.max_pixel_count, wants2.max_pixel_count);
536 EXPECT_GT(wants1.max_pixel_count, 0);
537 }
538
539 void VerifyFpsMaxResolutionGt(const rtc::VideoSinkWants& wants1,
540 const rtc::VideoSinkWants& wants2) {
Åsa Persson8c1bf952018-09-13 10:42:19 +0200541 EXPECT_EQ(kDefaultFramerate, wants1.max_framerate_fps);
asapersson09f05612017-05-15 23:40:18 -0700542 EXPECT_GT(wants1.max_pixel_count, wants2.max_pixel_count);
543 }
544
asaperssonf7e294d2017-06-13 23:25:22 -0700545 void VerifyFpsMaxResolutionEq(const rtc::VideoSinkWants& wants1,
546 const rtc::VideoSinkWants& wants2) {
Åsa Persson8c1bf952018-09-13 10:42:19 +0200547 EXPECT_EQ(kDefaultFramerate, wants1.max_framerate_fps);
asaperssonf7e294d2017-06-13 23:25:22 -0700548 EXPECT_EQ(wants1.max_pixel_count, wants2.max_pixel_count);
549 }
550
551 void VerifyFpsLtResolutionEq(const rtc::VideoSinkWants& wants1,
552 const rtc::VideoSinkWants& wants2) {
553 EXPECT_LT(wants1.max_framerate_fps, wants2.max_framerate_fps);
554 EXPECT_EQ(wants1.max_pixel_count, wants2.max_pixel_count);
555 }
556
557 void VerifyFpsGtResolutionEq(const rtc::VideoSinkWants& wants1,
558 const rtc::VideoSinkWants& wants2) {
559 EXPECT_GT(wants1.max_framerate_fps, wants2.max_framerate_fps);
560 EXPECT_EQ(wants1.max_pixel_count, wants2.max_pixel_count);
561 }
562
563 void VerifyFpsEqResolutionLt(const rtc::VideoSinkWants& wants1,
564 const rtc::VideoSinkWants& wants2) {
565 EXPECT_EQ(wants1.max_framerate_fps, wants2.max_framerate_fps);
566 EXPECT_LT(wants1.max_pixel_count, wants2.max_pixel_count);
567 EXPECT_GT(wants1.max_pixel_count, 0);
568 }
569
570 void VerifyFpsEqResolutionGt(const rtc::VideoSinkWants& wants1,
571 const rtc::VideoSinkWants& wants2) {
572 EXPECT_EQ(wants1.max_framerate_fps, wants2.max_framerate_fps);
573 EXPECT_GT(wants1.max_pixel_count, wants2.max_pixel_count);
574 }
575
asapersson09f05612017-05-15 23:40:18 -0700576 void VerifyFpsMaxResolutionLt(const rtc::VideoSinkWants& wants,
577 int pixel_count) {
Åsa Persson8c1bf952018-09-13 10:42:19 +0200578 EXPECT_EQ(kDefaultFramerate, wants.max_framerate_fps);
asapersson02465b82017-04-10 01:12:52 -0700579 EXPECT_LT(wants.max_pixel_count, pixel_count);
580 EXPECT_GT(wants.max_pixel_count, 0);
asapersson09f05612017-05-15 23:40:18 -0700581 }
582
583 void VerifyFpsLtResolutionMax(const rtc::VideoSinkWants& wants, int fps) {
584 EXPECT_LT(wants.max_framerate_fps, fps);
585 EXPECT_EQ(std::numeric_limits<int>::max(), wants.max_pixel_count);
586 EXPECT_FALSE(wants.target_pixel_count);
asapersson02465b82017-04-10 01:12:52 -0700587 }
588
asaperssonf7e294d2017-06-13 23:25:22 -0700589 void VerifyFpsEqResolutionMax(const rtc::VideoSinkWants& wants,
590 int expected_fps) {
591 EXPECT_EQ(expected_fps, wants.max_framerate_fps);
592 EXPECT_EQ(std::numeric_limits<int>::max(), wants.max_pixel_count);
593 EXPECT_FALSE(wants.target_pixel_count);
594 }
595
Jonathan Yubc771b72017-12-08 17:04:29 -0800596 void VerifyBalancedModeFpsRange(const rtc::VideoSinkWants& wants,
597 int last_frame_pixels) {
598 // Balanced mode should always scale FPS to the desired range before
599 // attempting to scale resolution.
600 int fps_limit = wants.max_framerate_fps;
601 if (last_frame_pixels <= 320 * 240) {
602 EXPECT_TRUE(7 <= fps_limit && fps_limit <= 10);
603 } else if (last_frame_pixels <= 480 * 270) {
604 EXPECT_TRUE(10 <= fps_limit && fps_limit <= 15);
605 } else if (last_frame_pixels <= 640 * 480) {
606 EXPECT_LE(15, fps_limit);
607 } else {
Åsa Persson8c1bf952018-09-13 10:42:19 +0200608 EXPECT_EQ(kDefaultFramerate, fps_limit);
Jonathan Yubc771b72017-12-08 17:04:29 -0800609 }
610 }
611
sprang4847ae62017-06-27 07:06:52 -0700612 void WaitForEncodedFrame(int64_t expected_ntp_time) {
613 sink_.WaitForEncodedFrame(expected_ntp_time);
Sebastian Jansson40889f32019-04-17 12:11:20 +0200614 fake_clock_.AdvanceTime(TimeDelta::seconds(1) / max_framerate_);
sprang4847ae62017-06-27 07:06:52 -0700615 }
616
617 bool TimedWaitForEncodedFrame(int64_t expected_ntp_time, int64_t timeout_ms) {
618 bool ok = sink_.TimedWaitForEncodedFrame(expected_ntp_time, timeout_ms);
Sebastian Jansson40889f32019-04-17 12:11:20 +0200619 fake_clock_.AdvanceTime(TimeDelta::seconds(1) / max_framerate_);
sprang4847ae62017-06-27 07:06:52 -0700620 return ok;
621 }
622
623 void WaitForEncodedFrame(uint32_t expected_width, uint32_t expected_height) {
624 sink_.WaitForEncodedFrame(expected_width, expected_height);
Sebastian Jansson40889f32019-04-17 12:11:20 +0200625 fake_clock_.AdvanceTime(TimeDelta::seconds(1) / max_framerate_);
sprang4847ae62017-06-27 07:06:52 -0700626 }
627
628 void ExpectDroppedFrame() {
629 sink_.ExpectDroppedFrame();
Sebastian Jansson40889f32019-04-17 12:11:20 +0200630 fake_clock_.AdvanceTime(TimeDelta::seconds(1) / max_framerate_);
sprang4847ae62017-06-27 07:06:52 -0700631 }
632
633 bool WaitForFrame(int64_t timeout_ms) {
634 bool ok = sink_.WaitForFrame(timeout_ms);
Sebastian Jansson40889f32019-04-17 12:11:20 +0200635 fake_clock_.AdvanceTime(TimeDelta::seconds(1) / max_framerate_);
sprang4847ae62017-06-27 07:06:52 -0700636 return ok;
637 }
638
perkj26091b12016-09-01 01:17:40 -0700639 class TestEncoder : public test::FakeEncoder {
640 public:
Niels Möllerc572ff32018-11-07 08:43:50 +0100641 TestEncoder() : FakeEncoder(Clock::GetRealTimeClock()) {}
perkj26091b12016-09-01 01:17:40 -0700642
asaperssonfab67072017-04-04 05:51:49 -0700643 VideoCodec codec_config() const {
brandtre78d2662017-01-16 05:57:16 -0800644 rtc::CritScope lock(&crit_sect_);
perkjfa10b552016-10-02 23:45:26 -0700645 return config_;
646 }
647
648 void BlockNextEncode() {
brandtre78d2662017-01-16 05:57:16 -0800649 rtc::CritScope lock(&local_crit_sect_);
perkjfa10b552016-10-02 23:45:26 -0700650 block_next_encode_ = true;
651 }
652
Erik Språngaed30702018-11-05 12:57:17 +0100653 VideoEncoder::EncoderInfo GetEncoderInfo() const override {
kthelgason2fc52542017-03-03 00:24:41 -0800654 rtc::CritScope lock(&local_crit_sect_);
Mirta Dvornicicccc1b572019-01-15 12:42:18 +0100655 EncoderInfo info;
Erik Språngb7cb7b52019-02-26 15:52:33 +0100656 if (initialized_ == EncoderState::kInitialized) {
Mirta Dvornicicccc1b572019-01-15 12:42:18 +0100657 if (quality_scaling_) {
658 info.scaling_settings =
659 VideoEncoder::ScalingSettings(1, 2, kMinPixelsPerFrame);
660 }
661 info.is_hardware_accelerated = is_hardware_accelerated_;
Åsa Perssonc29cb2c2019-03-25 12:06:59 +0100662 for (int i = 0; i < kMaxSpatialLayers; ++i) {
663 if (temporal_layers_supported_[i]) {
664 int num_layers = temporal_layers_supported_[i].value() ? 2 : 1;
665 info.fps_allocation[i].resize(num_layers);
666 }
667 }
Erik Språngaed30702018-11-05 12:57:17 +0100668 }
Sergey Silkin6456e352019-07-08 17:56:40 +0200669
670 info.resolution_bitrate_limits = resolution_bitrate_limits_;
Erik Språngaed30702018-11-05 12:57:17 +0100671 return info;
kthelgason876222f2016-11-29 01:44:11 -0800672 }
673
Erik Språngb7cb7b52019-02-26 15:52:33 +0100674 int32_t RegisterEncodeCompleteCallback(
675 EncodedImageCallback* callback) override {
676 rtc::CritScope lock(&local_crit_sect_);
677 encoded_image_callback_ = callback;
678 return FakeEncoder::RegisterEncodeCompleteCallback(callback);
679 }
680
perkjfa10b552016-10-02 23:45:26 -0700681 void ContinueEncode() { continue_encode_event_.Set(); }
682
683 void CheckLastTimeStampsMatch(int64_t ntp_time_ms,
684 uint32_t timestamp) const {
brandtre78d2662017-01-16 05:57:16 -0800685 rtc::CritScope lock(&local_crit_sect_);
perkjfa10b552016-10-02 23:45:26 -0700686 EXPECT_EQ(timestamp_, timestamp);
687 EXPECT_EQ(ntp_time_ms_, ntp_time_ms);
688 }
689
kthelgason2fc52542017-03-03 00:24:41 -0800690 void SetQualityScaling(bool b) {
691 rtc::CritScope lock(&local_crit_sect_);
692 quality_scaling_ = b;
693 }
kthelgasonad9010c2017-02-14 00:46:51 -0800694
Mirta Dvornicicccc1b572019-01-15 12:42:18 +0100695 void SetIsHardwareAccelerated(bool is_hardware_accelerated) {
696 rtc::CritScope lock(&local_crit_sect_);
697 is_hardware_accelerated_ = is_hardware_accelerated;
698 }
699
Åsa Perssonc29cb2c2019-03-25 12:06:59 +0100700 void SetTemporalLayersSupported(size_t spatial_idx, bool supported) {
701 RTC_DCHECK_LT(spatial_idx, kMaxSpatialLayers);
702 rtc::CritScope lock(&local_crit_sect_);
703 temporal_layers_supported_[spatial_idx] = supported;
704 }
705
Sergey Silkin6456e352019-07-08 17:56:40 +0200706 void SetResolutionBitrateLimits(
707 std::vector<ResolutionBitrateLimits> thresholds) {
708 rtc::CritScope cs(&local_crit_sect_);
709 resolution_bitrate_limits_ = thresholds;
710 }
711
sprangfe627f32017-03-29 08:24:59 -0700712 void ForceInitEncodeFailure(bool force_failure) {
713 rtc::CritScope lock(&local_crit_sect_);
714 force_init_encode_failed_ = force_failure;
715 }
716
Niels Möller6bb5ab92019-01-11 11:11:10 +0100717 void SimulateOvershoot(double rate_factor) {
718 rtc::CritScope lock(&local_crit_sect_);
719 rate_factor_ = rate_factor;
720 }
721
Erik Språngd7329ca2019-02-21 21:19:53 +0100722 uint32_t GetLastFramerate() const {
Niels Möller6bb5ab92019-01-11 11:11:10 +0100723 rtc::CritScope lock(&local_crit_sect_);
724 return last_framerate_;
725 }
726
Erik Språngd7329ca2019-02-21 21:19:53 +0100727 VideoFrame::UpdateRect GetLastUpdateRect() const {
Ilya Nikolaevskiy71aee3a2019-02-18 13:01:26 +0100728 rtc::CritScope lock(&local_crit_sect_);
729 return last_update_rect_;
730 }
731
Niels Möller87e2d782019-03-07 10:18:23 +0100732 const std::vector<VideoFrameType>& LastFrameTypes() const {
Erik Språngd7329ca2019-02-21 21:19:53 +0100733 rtc::CritScope lock(&local_crit_sect_);
734 return last_frame_types_;
735 }
736
737 void InjectFrame(const VideoFrame& input_image, bool keyframe) {
Niels Möller87e2d782019-03-07 10:18:23 +0100738 const std::vector<VideoFrameType> frame_type = {
Niels Möller8f7ce222019-03-21 15:43:58 +0100739 keyframe ? VideoFrameType::kVideoFrameKey
740 : VideoFrameType::kVideoFrameDelta};
Erik Språngd7329ca2019-02-21 21:19:53 +0100741 {
742 rtc::CritScope lock(&local_crit_sect_);
743 last_frame_types_ = frame_type;
744 }
Niels Möllerb859b322019-03-07 12:40:01 +0100745 FakeEncoder::Encode(input_image, &frame_type);
Erik Språngd7329ca2019-02-21 21:19:53 +0100746 }
747
Erik Språngb7cb7b52019-02-26 15:52:33 +0100748 void InjectEncodedImage(const EncodedImage& image) {
749 rtc::CritScope lock(&local_crit_sect_);
750 encoded_image_callback_->OnEncodedImage(image, nullptr, nullptr);
751 }
752
Mirta Dvornicic28f0eb22019-05-28 16:30:16 +0200753 void InjectEncodedImage(const EncodedImage& image,
754 const CodecSpecificInfo* codec_specific_info,
755 const RTPFragmentationHeader* fragmentation) {
756 rtc::CritScope lock(&local_crit_sect_);
757 encoded_image_callback_->OnEncodedImage(image, codec_specific_info,
758 fragmentation);
759 }
760
Erik Språngd7329ca2019-02-21 21:19:53 +0100761 void ExpectNullFrame() {
762 rtc::CritScope lock(&local_crit_sect_);
763 expect_null_frame_ = true;
764 }
765
766 absl::optional<VideoBitrateAllocation> GetAndResetLastBitrateAllocation() {
767 auto allocation = last_bitrate_allocation_;
768 last_bitrate_allocation_.reset();
769 return allocation;
770 }
771
Sergey Silkin5ee69672019-07-02 14:18:34 +0200772 int GetNumEncoderInitializations() const {
773 rtc::CritScope lock(&local_crit_sect_);
774 return num_encoder_initializations_;
775 }
776
perkjfa10b552016-10-02 23:45:26 -0700777 private:
perkj26091b12016-09-01 01:17:40 -0700778 int32_t Encode(const VideoFrame& input_image,
Niels Möller87e2d782019-03-07 10:18:23 +0100779 const std::vector<VideoFrameType>* frame_types) override {
perkj26091b12016-09-01 01:17:40 -0700780 bool block_encode;
781 {
brandtre78d2662017-01-16 05:57:16 -0800782 rtc::CritScope lock(&local_crit_sect_);
Erik Språngd7329ca2019-02-21 21:19:53 +0100783 if (expect_null_frame_) {
784 EXPECT_EQ(input_image.timestamp(), 0u);
785 EXPECT_EQ(input_image.width(), 1);
786 last_frame_types_ = *frame_types;
787 expect_null_frame_ = false;
788 } else {
789 EXPECT_GT(input_image.timestamp(), timestamp_);
790 EXPECT_GT(input_image.ntp_time_ms(), ntp_time_ms_);
791 EXPECT_EQ(input_image.timestamp(), input_image.ntp_time_ms() * 90);
792 }
perkj26091b12016-09-01 01:17:40 -0700793
794 timestamp_ = input_image.timestamp();
795 ntp_time_ms_ = input_image.ntp_time_ms();
perkj803d97f2016-11-01 11:45:46 -0700796 last_input_width_ = input_image.width();
797 last_input_height_ = input_image.height();
perkj26091b12016-09-01 01:17:40 -0700798 block_encode = block_next_encode_;
799 block_next_encode_ = false;
Ilya Nikolaevskiy71aee3a2019-02-18 13:01:26 +0100800 last_update_rect_ = input_image.update_rect();
Erik Språngd7329ca2019-02-21 21:19:53 +0100801 last_frame_types_ = *frame_types;
perkj26091b12016-09-01 01:17:40 -0700802 }
Niels Möllerb859b322019-03-07 12:40:01 +0100803 int32_t result = FakeEncoder::Encode(input_image, frame_types);
perkj26091b12016-09-01 01:17:40 -0700804 if (block_encode)
perkja49cbd32016-09-16 07:53:41 -0700805 EXPECT_TRUE(continue_encode_event_.Wait(kDefaultTimeoutMs));
perkj26091b12016-09-01 01:17:40 -0700806 return result;
807 }
808
sprangfe627f32017-03-29 08:24:59 -0700809 int32_t InitEncode(const VideoCodec* config,
Elad Alon370f93a2019-06-11 14:57:57 +0200810 const Settings& settings) override {
811 int res = FakeEncoder::InitEncode(config, settings);
Sergey Silkin5ee69672019-07-02 14:18:34 +0200812
sprangfe627f32017-03-29 08:24:59 -0700813 rtc::CritScope lock(&local_crit_sect_);
Erik Språngb7cb7b52019-02-26 15:52:33 +0100814 EXPECT_EQ(initialized_, EncoderState::kUninitialized);
Sergey Silkin5ee69672019-07-02 14:18:34 +0200815
816 ++num_encoder_initializations_;
817
Erik Språng82fad3d2018-03-21 09:57:23 +0100818 if (config->codecType == kVideoCodecVP8) {
sprangfe627f32017-03-29 08:24:59 -0700819 // Simulate setting up temporal layers, in order to validate the life
820 // cycle of these objects.
Elad Aloncde8ab22019-03-20 11:56:20 +0100821 Vp8TemporalLayersFactory factory;
Elad Alon45befc52019-07-02 11:20:09 +0200822 frame_buffer_controller_ =
823 factory.Create(*config, settings, &fec_controller_override_);
sprangfe627f32017-03-29 08:24:59 -0700824 }
Erik Språngb7cb7b52019-02-26 15:52:33 +0100825 if (force_init_encode_failed_) {
826 initialized_ = EncoderState::kInitializationFailed;
sprangfe627f32017-03-29 08:24:59 -0700827 return -1;
Erik Språngb7cb7b52019-02-26 15:52:33 +0100828 }
Mirta Dvornicicccc1b572019-01-15 12:42:18 +0100829
Erik Språngb7cb7b52019-02-26 15:52:33 +0100830 initialized_ = EncoderState::kInitialized;
sprangfe627f32017-03-29 08:24:59 -0700831 return res;
832 }
833
Erik Språngb7cb7b52019-02-26 15:52:33 +0100834 int32_t Release() override {
835 rtc::CritScope lock(&local_crit_sect_);
836 EXPECT_NE(initialized_, EncoderState::kUninitialized);
837 initialized_ = EncoderState::kUninitialized;
838 return FakeEncoder::Release();
839 }
840
Erik Språng16cb8f52019-04-12 13:59:09 +0200841 void SetRates(const RateControlParameters& parameters) {
Niels Möller6bb5ab92019-01-11 11:11:10 +0100842 rtc::CritScope lock(&local_crit_sect_);
843 VideoBitrateAllocation adjusted_rate_allocation;
844 for (size_t si = 0; si < kMaxSpatialLayers; ++si) {
845 for (size_t ti = 0; ti < kMaxTemporalStreams; ++ti) {
Erik Språng16cb8f52019-04-12 13:59:09 +0200846 if (parameters.bitrate.HasBitrate(si, ti)) {
Niels Möller6bb5ab92019-01-11 11:11:10 +0100847 adjusted_rate_allocation.SetBitrate(
848 si, ti,
Erik Språng16cb8f52019-04-12 13:59:09 +0200849 static_cast<uint32_t>(parameters.bitrate.GetBitrate(si, ti) *
Niels Möller6bb5ab92019-01-11 11:11:10 +0100850 rate_factor_));
851 }
852 }
853 }
Erik Språng16cb8f52019-04-12 13:59:09 +0200854 last_framerate_ = static_cast<uint32_t>(parameters.framerate_fps + 0.5);
855 last_bitrate_allocation_ = parameters.bitrate;
856 RateControlParameters adjusted_paramters = parameters;
857 adjusted_paramters.bitrate = adjusted_rate_allocation;
858 FakeEncoder::SetRates(adjusted_paramters);
Niels Möller6bb5ab92019-01-11 11:11:10 +0100859 }
860
brandtre78d2662017-01-16 05:57:16 -0800861 rtc::CriticalSection local_crit_sect_;
Erik Språngb7cb7b52019-02-26 15:52:33 +0100862 enum class EncoderState {
863 kUninitialized,
864 kInitializationFailed,
865 kInitialized
866 } initialized_ RTC_GUARDED_BY(local_crit_sect_) =
867 EncoderState::kUninitialized;
danilchapa37de392017-09-09 04:17:22 -0700868 bool block_next_encode_ RTC_GUARDED_BY(local_crit_sect_) = false;
perkj26091b12016-09-01 01:17:40 -0700869 rtc::Event continue_encode_event_;
danilchapa37de392017-09-09 04:17:22 -0700870 uint32_t timestamp_ RTC_GUARDED_BY(local_crit_sect_) = 0;
871 int64_t ntp_time_ms_ RTC_GUARDED_BY(local_crit_sect_) = 0;
872 int last_input_width_ RTC_GUARDED_BY(local_crit_sect_) = 0;
873 int last_input_height_ RTC_GUARDED_BY(local_crit_sect_) = 0;
874 bool quality_scaling_ RTC_GUARDED_BY(local_crit_sect_) = true;
Mirta Dvornicicccc1b572019-01-15 12:42:18 +0100875 bool is_hardware_accelerated_ RTC_GUARDED_BY(local_crit_sect_) = false;
Elad Aloncde8ab22019-03-20 11:56:20 +0100876 std::unique_ptr<Vp8FrameBufferController> frame_buffer_controller_
danilchapa37de392017-09-09 04:17:22 -0700877 RTC_GUARDED_BY(local_crit_sect_);
Åsa Perssonc29cb2c2019-03-25 12:06:59 +0100878 absl::optional<bool>
879 temporal_layers_supported_[kMaxSpatialLayers] RTC_GUARDED_BY(
880 local_crit_sect_);
danilchapa37de392017-09-09 04:17:22 -0700881 bool force_init_encode_failed_ RTC_GUARDED_BY(local_crit_sect_) = false;
Niels Möller6bb5ab92019-01-11 11:11:10 +0100882 double rate_factor_ RTC_GUARDED_BY(local_crit_sect_) = 1.0;
883 uint32_t last_framerate_ RTC_GUARDED_BY(local_crit_sect_) = 0;
Erik Språngd7329ca2019-02-21 21:19:53 +0100884 absl::optional<VideoBitrateAllocation> last_bitrate_allocation_;
Ilya Nikolaevskiy71aee3a2019-02-18 13:01:26 +0100885 VideoFrame::UpdateRect last_update_rect_
886 RTC_GUARDED_BY(local_crit_sect_) = {0, 0, 0, 0};
Niels Möller87e2d782019-03-07 10:18:23 +0100887 std::vector<VideoFrameType> last_frame_types_;
Erik Språngd7329ca2019-02-21 21:19:53 +0100888 bool expect_null_frame_ = false;
Erik Språngb7cb7b52019-02-26 15:52:33 +0100889 EncodedImageCallback* encoded_image_callback_
890 RTC_GUARDED_BY(local_crit_sect_) = nullptr;
Elad Alon45befc52019-07-02 11:20:09 +0200891 MockFecControllerOverride fec_controller_override_;
Sergey Silkin5ee69672019-07-02 14:18:34 +0200892 int num_encoder_initializations_ RTC_GUARDED_BY(local_crit_sect_) = 0;
Sergey Silkin6456e352019-07-08 17:56:40 +0200893 std::vector<ResolutionBitrateLimits> resolution_bitrate_limits_
894 RTC_GUARDED_BY(local_crit_sect_);
perkj26091b12016-09-01 01:17:40 -0700895 };
896
mflodmancc3d4422017-08-03 08:27:51 -0700897 class TestSink : public VideoStreamEncoder::EncoderSink {
perkj26091b12016-09-01 01:17:40 -0700898 public:
899 explicit TestSink(TestEncoder* test_encoder)
Niels Möllerc572ff32018-11-07 08:43:50 +0100900 : test_encoder_(test_encoder) {}
perkj26091b12016-09-01 01:17:40 -0700901
perkj26091b12016-09-01 01:17:40 -0700902 void WaitForEncodedFrame(int64_t expected_ntp_time) {
sprang4847ae62017-06-27 07:06:52 -0700903 EXPECT_TRUE(
904 TimedWaitForEncodedFrame(expected_ntp_time, kDefaultTimeoutMs));
905 }
906
907 bool TimedWaitForEncodedFrame(int64_t expected_ntp_time,
908 int64_t timeout_ms) {
perkj26091b12016-09-01 01:17:40 -0700909 uint32_t timestamp = 0;
sprang4847ae62017-06-27 07:06:52 -0700910 if (!encoded_frame_event_.Wait(timeout_ms))
911 return false;
perkj26091b12016-09-01 01:17:40 -0700912 {
913 rtc::CritScope lock(&crit_);
sprangb1ca0732017-02-01 08:38:12 -0800914 timestamp = last_timestamp_;
perkj26091b12016-09-01 01:17:40 -0700915 }
916 test_encoder_->CheckLastTimeStampsMatch(expected_ntp_time, timestamp);
sprang4847ae62017-06-27 07:06:52 -0700917 return true;
perkj26091b12016-09-01 01:17:40 -0700918 }
919
sprangb1ca0732017-02-01 08:38:12 -0800920 void WaitForEncodedFrame(uint32_t expected_width,
921 uint32_t expected_height) {
sprangc5d62e22017-04-02 23:53:04 -0700922 EXPECT_TRUE(encoded_frame_event_.Wait(kDefaultTimeoutMs));
Åsa Perssonc74d8da2017-12-04 14:13:56 +0100923 CheckLastFrameSizeMatches(expected_width, expected_height);
sprangc5d62e22017-04-02 23:53:04 -0700924 }
925
Åsa Perssonc74d8da2017-12-04 14:13:56 +0100926 void CheckLastFrameSizeMatches(uint32_t expected_width,
sprangc5d62e22017-04-02 23:53:04 -0700927 uint32_t expected_height) {
sprangb1ca0732017-02-01 08:38:12 -0800928 uint32_t width = 0;
929 uint32_t height = 0;
sprangb1ca0732017-02-01 08:38:12 -0800930 {
931 rtc::CritScope lock(&crit_);
932 width = last_width_;
933 height = last_height_;
934 }
935 EXPECT_EQ(expected_height, height);
936 EXPECT_EQ(expected_width, width);
937 }
938
Ilya Nikolaevskiyba96e2f2019-06-04 15:15:14 +0200939 void CheckLastFrameRotationMatches(VideoRotation expected_rotation) {
940 VideoRotation rotation;
941 {
942 rtc::CritScope lock(&crit_);
943 rotation = last_rotation_;
944 }
945 EXPECT_EQ(expected_rotation, rotation);
946 }
947
kthelgason2fc52542017-03-03 00:24:41 -0800948 void ExpectDroppedFrame() { EXPECT_FALSE(encoded_frame_event_.Wait(100)); }
kthelgason2bc68642017-02-07 07:02:22 -0800949
sprangc5d62e22017-04-02 23:53:04 -0700950 bool WaitForFrame(int64_t timeout_ms) {
951 return encoded_frame_event_.Wait(timeout_ms);
952 }
953
perkj26091b12016-09-01 01:17:40 -0700954 void SetExpectNoFrames() {
955 rtc::CritScope lock(&crit_);
956 expect_frames_ = false;
957 }
958
asaperssonfab67072017-04-04 05:51:49 -0700959 int number_of_reconfigurations() const {
Per512ecb32016-09-23 15:52:06 +0200960 rtc::CritScope lock(&crit_);
961 return number_of_reconfigurations_;
962 }
963
asaperssonfab67072017-04-04 05:51:49 -0700964 int last_min_transmit_bitrate() const {
Per512ecb32016-09-23 15:52:06 +0200965 rtc::CritScope lock(&crit_);
966 return min_transmit_bitrate_bps_;
967 }
968
Erik Språngd7329ca2019-02-21 21:19:53 +0100969 void SetNumExpectedLayers(size_t num_layers) {
970 rtc::CritScope lock(&crit_);
971 num_expected_layers_ = num_layers;
972 }
973
Erik Språngb7cb7b52019-02-26 15:52:33 +0100974 int64_t GetLastCaptureTimeMs() const {
975 rtc::CritScope lock(&crit_);
976 return last_capture_time_ms_;
977 }
978
Mirta Dvornicic28f0eb22019-05-28 16:30:16 +0200979 std::vector<uint8_t> GetLastEncodedImageData() {
980 rtc::CritScope lock(&crit_);
981 return std::move(last_encoded_image_data_);
982 }
983
984 RTPFragmentationHeader GetLastFragmentation() {
985 rtc::CritScope lock(&crit_);
986 return std::move(last_fragmentation_);
987 }
988
perkj26091b12016-09-01 01:17:40 -0700989 private:
sergeyu2cb155a2016-11-04 11:39:29 -0700990 Result OnEncodedImage(
991 const EncodedImage& encoded_image,
992 const CodecSpecificInfo* codec_specific_info,
993 const RTPFragmentationHeader* fragmentation) override {
Per512ecb32016-09-23 15:52:06 +0200994 rtc::CritScope lock(&crit_);
995 EXPECT_TRUE(expect_frames_);
Mirta Dvornicic28f0eb22019-05-28 16:30:16 +0200996 last_encoded_image_data_ = std::vector<uint8_t>(
997 encoded_image.data(), encoded_image.data() + encoded_image.size());
998 if (fragmentation) {
999 last_fragmentation_.CopyFrom(*fragmentation);
1000 }
Erik Språngd7329ca2019-02-21 21:19:53 +01001001 uint32_t timestamp = encoded_image.Timestamp();
1002 if (last_timestamp_ != timestamp) {
1003 num_received_layers_ = 1;
1004 } else {
1005 ++num_received_layers_;
1006 }
1007 last_timestamp_ = timestamp;
Erik Språngb7cb7b52019-02-26 15:52:33 +01001008 last_capture_time_ms_ = encoded_image.capture_time_ms_;
sprangb1ca0732017-02-01 08:38:12 -08001009 last_width_ = encoded_image._encodedWidth;
1010 last_height_ = encoded_image._encodedHeight;
Ilya Nikolaevskiyba96e2f2019-06-04 15:15:14 +02001011 last_rotation_ = encoded_image.rotation_;
Erik Språngd7329ca2019-02-21 21:19:53 +01001012 if (num_received_layers_ == num_expected_layers_) {
1013 encoded_frame_event_.Set();
1014 }
sprangb1ca0732017-02-01 08:38:12 -08001015 return Result(Result::OK, last_timestamp_);
Per512ecb32016-09-23 15:52:06 +02001016 }
1017
Rasmus Brandtc402dbe2019-02-04 11:09:46 +01001018 void OnEncoderConfigurationChanged(
1019 std::vector<VideoStream> streams,
1020 VideoEncoderConfig::ContentType content_type,
1021 int min_transmit_bitrate_bps) override {
Sergey Silkin5ee69672019-07-02 14:18:34 +02001022 rtc::CritScope lock(&crit_);
Per512ecb32016-09-23 15:52:06 +02001023 ++number_of_reconfigurations_;
1024 min_transmit_bitrate_bps_ = min_transmit_bitrate_bps;
1025 }
1026
perkj26091b12016-09-01 01:17:40 -07001027 rtc::CriticalSection crit_;
1028 TestEncoder* test_encoder_;
1029 rtc::Event encoded_frame_event_;
Mirta Dvornicic28f0eb22019-05-28 16:30:16 +02001030 std::vector<uint8_t> last_encoded_image_data_;
1031 RTPFragmentationHeader last_fragmentation_;
sprangb1ca0732017-02-01 08:38:12 -08001032 uint32_t last_timestamp_ = 0;
Erik Språngb7cb7b52019-02-26 15:52:33 +01001033 int64_t last_capture_time_ms_ = 0;
sprangb1ca0732017-02-01 08:38:12 -08001034 uint32_t last_height_ = 0;
1035 uint32_t last_width_ = 0;
Ilya Nikolaevskiyba96e2f2019-06-04 15:15:14 +02001036 VideoRotation last_rotation_ = kVideoRotation_0;
Erik Språngd7329ca2019-02-21 21:19:53 +01001037 size_t num_expected_layers_ = 1;
1038 size_t num_received_layers_ = 0;
perkj26091b12016-09-01 01:17:40 -07001039 bool expect_frames_ = true;
Per512ecb32016-09-23 15:52:06 +02001040 int number_of_reconfigurations_ = 0;
1041 int min_transmit_bitrate_bps_ = 0;
perkj26091b12016-09-01 01:17:40 -07001042 };
1043
Sergey Silkin5ee69672019-07-02 14:18:34 +02001044 class VideoBitrateAllocatorProxyFactory
1045 : public VideoBitrateAllocatorFactory {
1046 public:
1047 VideoBitrateAllocatorProxyFactory()
1048 : bitrate_allocator_factory_(
1049 CreateBuiltinVideoBitrateAllocatorFactory()) {}
1050
1051 std::unique_ptr<VideoBitrateAllocator> CreateVideoBitrateAllocator(
1052 const VideoCodec& codec) override {
1053 rtc::CritScope lock(&crit_);
1054 codec_config_ = codec;
1055 return bitrate_allocator_factory_->CreateVideoBitrateAllocator(codec);
1056 }
1057
1058 VideoCodec codec_config() const {
1059 rtc::CritScope lock(&crit_);
1060 return codec_config_;
1061 }
1062
1063 private:
1064 std::unique_ptr<VideoBitrateAllocatorFactory> bitrate_allocator_factory_;
1065
1066 rtc::CriticalSection crit_;
1067 VideoCodec codec_config_ RTC_GUARDED_BY(crit_);
1068 };
1069
perkj26091b12016-09-01 01:17:40 -07001070 VideoSendStream::Config video_send_config_;
Erik Språng08127a92016-11-16 16:41:30 +01001071 VideoEncoderConfig video_encoder_config_;
Per512ecb32016-09-23 15:52:06 +02001072 int codec_width_;
1073 int codec_height_;
sprang4847ae62017-06-27 07:06:52 -07001074 int max_framerate_;
Danil Chapovalovd3ba2362019-04-10 17:01:23 +02001075 const std::unique_ptr<TaskQueueFactory> task_queue_factory_;
perkj26091b12016-09-01 01:17:40 -07001076 TestEncoder fake_encoder_;
Niels Möllercbcbc222018-09-28 09:07:24 +02001077 test::VideoEncoderProxyFactory encoder_factory_;
Sergey Silkin5ee69672019-07-02 14:18:34 +02001078 VideoBitrateAllocatorProxyFactory bitrate_allocator_factory_;
sprangc5d62e22017-04-02 23:53:04 -07001079 std::unique_ptr<MockableSendStatisticsProxy> stats_proxy_;
perkj26091b12016-09-01 01:17:40 -07001080 TestSink sink_;
sprangb1ca0732017-02-01 08:38:12 -08001081 AdaptingFrameForwarder video_source_;
mflodmancc3d4422017-08-03 08:27:51 -07001082 std::unique_ptr<VideoStreamEncoderUnderTest> video_stream_encoder_;
sprang4847ae62017-06-27 07:06:52 -07001083 rtc::ScopedFakeClock fake_clock_;
perkj26091b12016-09-01 01:17:40 -07001084};
1085
mflodmancc3d4422017-08-03 08:27:51 -07001086TEST_F(VideoStreamEncoderTest, EncodeOneFrame) {
Erik Språng4c6ca302019-04-08 15:14:01 +02001087 video_stream_encoder_->OnBitrateUpdated(
1088 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
Niels Möllerc572ff32018-11-07 08:43:50 +01001089 rtc::Event frame_destroyed_event;
perkja49cbd32016-09-16 07:53:41 -07001090 video_source_.IncomingCapturedFrame(CreateFrame(1, &frame_destroyed_event));
sprang4847ae62017-06-27 07:06:52 -07001091 WaitForEncodedFrame(1);
perkja49cbd32016-09-16 07:53:41 -07001092 EXPECT_TRUE(frame_destroyed_event.Wait(kDefaultTimeoutMs));
mflodmancc3d4422017-08-03 08:27:51 -07001093 video_stream_encoder_->Stop();
perkj26091b12016-09-01 01:17:40 -07001094}
1095
mflodmancc3d4422017-08-03 08:27:51 -07001096TEST_F(VideoStreamEncoderTest, DropsFramesBeforeFirstOnBitrateUpdated) {
perkj26091b12016-09-01 01:17:40 -07001097 // Dropped since no target bitrate has been set.
Niels Möllerc572ff32018-11-07 08:43:50 +01001098 rtc::Event frame_destroyed_event;
Sebastian Janssona3177052018-04-10 13:05:49 +02001099 // The encoder will cache up to one frame for a short duration. Adding two
1100 // frames means that the first frame will be dropped and the second frame will
1101 // be sent when the encoder is enabled.
perkja49cbd32016-09-16 07:53:41 -07001102 video_source_.IncomingCapturedFrame(CreateFrame(1, &frame_destroyed_event));
Sebastian Janssona3177052018-04-10 13:05:49 +02001103 video_source_.IncomingCapturedFrame(CreateFrame(2, nullptr));
perkja49cbd32016-09-16 07:53:41 -07001104 EXPECT_TRUE(frame_destroyed_event.Wait(kDefaultTimeoutMs));
perkj26091b12016-09-01 01:17:40 -07001105
Erik Språng4c6ca302019-04-08 15:14:01 +02001106 video_stream_encoder_->OnBitrateUpdated(
1107 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
perkj26091b12016-09-01 01:17:40 -07001108
Sebastian Janssona3177052018-04-10 13:05:49 +02001109 // The pending frame should be received.
sprang4847ae62017-06-27 07:06:52 -07001110 WaitForEncodedFrame(2);
Sebastian Janssona3177052018-04-10 13:05:49 +02001111 video_source_.IncomingCapturedFrame(CreateFrame(3, nullptr));
1112
1113 WaitForEncodedFrame(3);
mflodmancc3d4422017-08-03 08:27:51 -07001114 video_stream_encoder_->Stop();
perkj26091b12016-09-01 01:17:40 -07001115}
1116
mflodmancc3d4422017-08-03 08:27:51 -07001117TEST_F(VideoStreamEncoderTest, DropsFramesWhenRateSetToZero) {
Erik Språng4c6ca302019-04-08 15:14:01 +02001118 video_stream_encoder_->OnBitrateUpdated(
1119 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
perkja49cbd32016-09-16 07:53:41 -07001120 video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr));
sprang4847ae62017-06-27 07:06:52 -07001121 WaitForEncodedFrame(1);
perkj26091b12016-09-01 01:17:40 -07001122
Erik Språng4c6ca302019-04-08 15:14:01 +02001123 video_stream_encoder_->OnBitrateUpdated(DataRate::bps(0), DataRate::bps(0), 0,
Erik Språng610c7632019-03-06 15:37:33 +01001124 0);
Sebastian Janssona3177052018-04-10 13:05:49 +02001125 // The encoder will cache up to one frame for a short duration. Adding two
1126 // frames means that the first frame will be dropped and the second frame will
1127 // be sent when the encoder is resumed.
perkja49cbd32016-09-16 07:53:41 -07001128 video_source_.IncomingCapturedFrame(CreateFrame(2, nullptr));
Sebastian Janssona3177052018-04-10 13:05:49 +02001129 video_source_.IncomingCapturedFrame(CreateFrame(3, nullptr));
perkj26091b12016-09-01 01:17:40 -07001130
Erik Språng4c6ca302019-04-08 15:14:01 +02001131 video_stream_encoder_->OnBitrateUpdated(
1132 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
sprang4847ae62017-06-27 07:06:52 -07001133 WaitForEncodedFrame(3);
Sebastian Janssona3177052018-04-10 13:05:49 +02001134 video_source_.IncomingCapturedFrame(CreateFrame(4, nullptr));
1135 WaitForEncodedFrame(4);
mflodmancc3d4422017-08-03 08:27:51 -07001136 video_stream_encoder_->Stop();
perkj26091b12016-09-01 01:17:40 -07001137}
1138
mflodmancc3d4422017-08-03 08:27:51 -07001139TEST_F(VideoStreamEncoderTest, DropsFramesWithSameOrOldNtpTimestamp) {
Erik Språng4c6ca302019-04-08 15:14:01 +02001140 video_stream_encoder_->OnBitrateUpdated(
1141 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
perkja49cbd32016-09-16 07:53:41 -07001142 video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr));
sprang4847ae62017-06-27 07:06:52 -07001143 WaitForEncodedFrame(1);
perkj26091b12016-09-01 01:17:40 -07001144
1145 // This frame will be dropped since it has the same ntp timestamp.
perkja49cbd32016-09-16 07:53:41 -07001146 video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr));
perkj26091b12016-09-01 01:17:40 -07001147
perkja49cbd32016-09-16 07:53:41 -07001148 video_source_.IncomingCapturedFrame(CreateFrame(2, nullptr));
sprang4847ae62017-06-27 07:06:52 -07001149 WaitForEncodedFrame(2);
mflodmancc3d4422017-08-03 08:27:51 -07001150 video_stream_encoder_->Stop();
perkj26091b12016-09-01 01:17:40 -07001151}
1152
mflodmancc3d4422017-08-03 08:27:51 -07001153TEST_F(VideoStreamEncoderTest, DropsFrameAfterStop) {
Erik Språng4c6ca302019-04-08 15:14:01 +02001154 video_stream_encoder_->OnBitrateUpdated(
1155 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
perkj26091b12016-09-01 01:17:40 -07001156
perkja49cbd32016-09-16 07:53:41 -07001157 video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr));
sprang4847ae62017-06-27 07:06:52 -07001158 WaitForEncodedFrame(1);
perkj26091b12016-09-01 01:17:40 -07001159
mflodmancc3d4422017-08-03 08:27:51 -07001160 video_stream_encoder_->Stop();
perkj26091b12016-09-01 01:17:40 -07001161 sink_.SetExpectNoFrames();
Niels Möllerc572ff32018-11-07 08:43:50 +01001162 rtc::Event frame_destroyed_event;
perkja49cbd32016-09-16 07:53:41 -07001163 video_source_.IncomingCapturedFrame(CreateFrame(2, &frame_destroyed_event));
1164 EXPECT_TRUE(frame_destroyed_event.Wait(kDefaultTimeoutMs));
perkj26091b12016-09-01 01:17:40 -07001165}
1166
mflodmancc3d4422017-08-03 08:27:51 -07001167TEST_F(VideoStreamEncoderTest, DropsPendingFramesOnSlowEncode) {
Erik Språng4c6ca302019-04-08 15:14:01 +02001168 video_stream_encoder_->OnBitrateUpdated(
1169 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
perkj26091b12016-09-01 01:17:40 -07001170
1171 fake_encoder_.BlockNextEncode();
perkja49cbd32016-09-16 07:53:41 -07001172 video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr));
sprang4847ae62017-06-27 07:06:52 -07001173 WaitForEncodedFrame(1);
perkj26091b12016-09-01 01:17:40 -07001174 // Here, the encoder thread will be blocked in the TestEncoder waiting for a
1175 // call to ContinueEncode.
perkja49cbd32016-09-16 07:53:41 -07001176 video_source_.IncomingCapturedFrame(CreateFrame(2, nullptr));
1177 video_source_.IncomingCapturedFrame(CreateFrame(3, nullptr));
perkj26091b12016-09-01 01:17:40 -07001178 fake_encoder_.ContinueEncode();
sprang4847ae62017-06-27 07:06:52 -07001179 WaitForEncodedFrame(3);
perkj26091b12016-09-01 01:17:40 -07001180
mflodmancc3d4422017-08-03 08:27:51 -07001181 video_stream_encoder_->Stop();
perkj26091b12016-09-01 01:17:40 -07001182}
1183
Noah Richards51db4212019-06-12 06:59:12 -07001184TEST_F(VideoStreamEncoderTest, DropFrameWithFailedI420Conversion) {
1185 video_stream_encoder_->OnBitrateUpdated(
1186 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
1187
1188 rtc::Event frame_destroyed_event;
1189 video_source_.IncomingCapturedFrame(
1190 CreateFakeNativeFrame(1, &frame_destroyed_event));
1191 ExpectDroppedFrame();
1192 EXPECT_TRUE(frame_destroyed_event.Wait(kDefaultTimeoutMs));
1193 video_stream_encoder_->Stop();
1194}
1195
1196TEST_F(VideoStreamEncoderTest, DropFrameWithFailedI420ConversionWithCrop) {
1197 // Use the cropping factory.
1198 video_encoder_config_.video_stream_factory =
1199 new rtc::RefCountedObject<CroppingVideoStreamFactory>(1, 30);
1200 video_stream_encoder_->ConfigureEncoder(std::move(video_encoder_config_),
1201 kMaxPayloadLength);
1202 video_stream_encoder_->WaitUntilTaskQueueIsIdle();
1203
1204 // Capture a frame at codec_width_/codec_height_.
1205 video_stream_encoder_->OnBitrateUpdated(
1206 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
1207 video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr));
1208 WaitForEncodedFrame(1);
1209 // The encoder will have been configured once.
1210 EXPECT_EQ(1, sink_.number_of_reconfigurations());
1211 EXPECT_EQ(codec_width_, fake_encoder_.codec_config().width);
1212 EXPECT_EQ(codec_height_, fake_encoder_.codec_config().height);
1213
1214 // Now send in a fake frame that needs to be cropped as the width/height
1215 // aren't divisible by 4 (see CreateEncoderStreams above).
1216 rtc::Event frame_destroyed_event;
1217 video_source_.IncomingCapturedFrame(CreateFakeNativeFrame(
1218 2, &frame_destroyed_event, codec_width_ + 1, codec_height_ + 1));
1219 ExpectDroppedFrame();
1220 EXPECT_TRUE(frame_destroyed_event.Wait(kDefaultTimeoutMs));
1221 video_stream_encoder_->Stop();
1222}
1223
mflodmancc3d4422017-08-03 08:27:51 -07001224TEST_F(VideoStreamEncoderTest,
1225 ConfigureEncoderTriggersOnEncoderConfigurationChanged) {
Erik Språng4c6ca302019-04-08 15:14:01 +02001226 video_stream_encoder_->OnBitrateUpdated(
1227 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
Per21d45d22016-10-30 21:37:57 +01001228 EXPECT_EQ(0, sink_.number_of_reconfigurations());
Per512ecb32016-09-23 15:52:06 +02001229
1230 // Capture a frame and wait for it to synchronize with the encoder thread.
Perf8c5f2b2016-09-23 16:24:55 +02001231 video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr));
sprang4847ae62017-06-27 07:06:52 -07001232 WaitForEncodedFrame(1);
Per21d45d22016-10-30 21:37:57 +01001233 // The encoder will have been configured once when the first frame is
1234 // received.
1235 EXPECT_EQ(1, sink_.number_of_reconfigurations());
Per512ecb32016-09-23 15:52:06 +02001236
1237 VideoEncoderConfig video_encoder_config;
Niels Möller259a4972018-04-05 15:36:51 +02001238 test::FillEncoderConfiguration(kVideoCodecVP8, 1, &video_encoder_config);
Per512ecb32016-09-23 15:52:06 +02001239 video_encoder_config.min_transmit_bitrate_bps = 9999;
mflodmancc3d4422017-08-03 08:27:51 -07001240 video_stream_encoder_->ConfigureEncoder(std::move(video_encoder_config),
Niels Möllerf1338562018-04-26 09:51:47 +02001241 kMaxPayloadLength);
Per512ecb32016-09-23 15:52:06 +02001242
1243 // Capture a frame and wait for it to synchronize with the encoder thread.
Perf8c5f2b2016-09-23 16:24:55 +02001244 video_source_.IncomingCapturedFrame(CreateFrame(2, nullptr));
sprang4847ae62017-06-27 07:06:52 -07001245 WaitForEncodedFrame(2);
Per21d45d22016-10-30 21:37:57 +01001246 EXPECT_EQ(2, sink_.number_of_reconfigurations());
perkj3b703ed2016-09-29 23:25:40 -07001247 EXPECT_EQ(9999, sink_.last_min_transmit_bitrate());
perkj26105b42016-09-29 22:39:10 -07001248
mflodmancc3d4422017-08-03 08:27:51 -07001249 video_stream_encoder_->Stop();
perkj26105b42016-09-29 22:39:10 -07001250}
1251
mflodmancc3d4422017-08-03 08:27:51 -07001252TEST_F(VideoStreamEncoderTest, FrameResolutionChangeReconfigureEncoder) {
Erik Språng4c6ca302019-04-08 15:14:01 +02001253 video_stream_encoder_->OnBitrateUpdated(
1254 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
perkjfa10b552016-10-02 23:45:26 -07001255
1256 // Capture a frame and wait for it to synchronize with the encoder thread.
1257 video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr));
sprang4847ae62017-06-27 07:06:52 -07001258 WaitForEncodedFrame(1);
Per21d45d22016-10-30 21:37:57 +01001259 // The encoder will have been configured once.
1260 EXPECT_EQ(1, sink_.number_of_reconfigurations());
perkjfa10b552016-10-02 23:45:26 -07001261 EXPECT_EQ(codec_width_, fake_encoder_.codec_config().width);
1262 EXPECT_EQ(codec_height_, fake_encoder_.codec_config().height);
1263
1264 codec_width_ *= 2;
1265 codec_height_ *= 2;
1266 // Capture a frame with a higher resolution and wait for it to synchronize
1267 // with the encoder thread.
1268 video_source_.IncomingCapturedFrame(CreateFrame(2, nullptr));
sprang4847ae62017-06-27 07:06:52 -07001269 WaitForEncodedFrame(2);
perkjfa10b552016-10-02 23:45:26 -07001270 EXPECT_EQ(codec_width_, fake_encoder_.codec_config().width);
1271 EXPECT_EQ(codec_height_, fake_encoder_.codec_config().height);
Per21d45d22016-10-30 21:37:57 +01001272 EXPECT_EQ(2, sink_.number_of_reconfigurations());
perkjfa10b552016-10-02 23:45:26 -07001273
mflodmancc3d4422017-08-03 08:27:51 -07001274 video_stream_encoder_->Stop();
perkjfa10b552016-10-02 23:45:26 -07001275}
1276
Sergey Silkin443b7ee2019-06-28 12:53:07 +02001277TEST_F(VideoStreamEncoderTest,
1278 EncoderInstanceDestroyedBeforeAnotherInstanceCreated) {
1279 video_stream_encoder_->OnBitrateUpdated(
1280 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
1281
1282 // Capture a frame and wait for it to synchronize with the encoder thread.
1283 video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr));
1284 WaitForEncodedFrame(1);
1285
1286 VideoEncoderConfig video_encoder_config;
1287 test::FillEncoderConfiguration(kVideoCodecVP8, 1, &video_encoder_config);
1288 // Changing the max payload data length recreates encoder.
1289 video_stream_encoder_->ConfigureEncoder(std::move(video_encoder_config),
1290 kMaxPayloadLength / 2);
1291
1292 // Capture a frame and wait for it to synchronize with the encoder thread.
1293 video_source_.IncomingCapturedFrame(CreateFrame(2, nullptr));
1294 WaitForEncodedFrame(2);
1295 EXPECT_EQ(1, encoder_factory_.GetMaxNumberOfSimultaneousEncoderInstances());
1296
1297 video_stream_encoder_->Stop();
1298}
1299
Sergey Silkin5ee69672019-07-02 14:18:34 +02001300TEST_F(VideoStreamEncoderTest, BitrateLimitsChangeReconfigureRateAllocator) {
1301 video_stream_encoder_->OnBitrateUpdated(
1302 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
1303
1304 VideoEncoderConfig video_encoder_config;
1305 test::FillEncoderConfiguration(kVideoCodecVP8, 1, &video_encoder_config);
1306 video_encoder_config.max_bitrate_bps = kTargetBitrateBps;
1307 video_stream_encoder_->SetStartBitrate(kStartBitrateBps);
1308 video_stream_encoder_->ConfigureEncoder(video_encoder_config.Copy(),
1309 kMaxPayloadLength);
1310
1311 // Capture a frame and wait for it to synchronize with the encoder thread.
1312 video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr));
1313 WaitForEncodedFrame(1);
1314 // The encoder will have been configured once when the first frame is
1315 // received.
1316 EXPECT_EQ(1, sink_.number_of_reconfigurations());
1317 EXPECT_EQ(kTargetBitrateBps,
1318 bitrate_allocator_factory_.codec_config().maxBitrate * 1000);
1319 EXPECT_EQ(kStartBitrateBps,
1320 bitrate_allocator_factory_.codec_config().startBitrate * 1000);
1321
Sergey Silkin6456e352019-07-08 17:56:40 +02001322 test::FillEncoderConfiguration(kVideoCodecVP8, 1,
1323 &video_encoder_config); //???
Sergey Silkin5ee69672019-07-02 14:18:34 +02001324 video_encoder_config.max_bitrate_bps = kTargetBitrateBps * 2;
1325 video_stream_encoder_->SetStartBitrate(kStartBitrateBps * 2);
1326 video_stream_encoder_->ConfigureEncoder(std::move(video_encoder_config),
1327 kMaxPayloadLength);
1328
1329 // Capture a frame and wait for it to synchronize with the encoder thread.
1330 video_source_.IncomingCapturedFrame(CreateFrame(2, nullptr));
1331 WaitForEncodedFrame(2);
1332 EXPECT_EQ(2, sink_.number_of_reconfigurations());
1333 // Bitrate limits have changed - rate allocator should be reconfigured,
1334 // encoder should not be reconfigured.
1335 EXPECT_EQ(kTargetBitrateBps * 2,
1336 bitrate_allocator_factory_.codec_config().maxBitrate * 1000);
1337 EXPECT_EQ(kStartBitrateBps * 2,
1338 bitrate_allocator_factory_.codec_config().startBitrate * 1000);
1339 EXPECT_EQ(1, fake_encoder_.GetNumEncoderInitializations());
1340
1341 video_stream_encoder_->Stop();
1342}
1343
Sergey Silkin6456e352019-07-08 17:56:40 +02001344TEST_F(VideoStreamEncoderTest,
1345 EncoderConfigMaxBitrateOverridesMaxBitrateRecommendedByEncoder) {
1346 video_stream_encoder_->OnBitrateUpdated(
1347 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
1348
1349 const VideoEncoder::ResolutionBitrateLimits encoder_bitrate_limits(
1350 codec_width_ * codec_height_, 0, 0, kTargetBitrateBps + 123 * 1000);
1351 fake_encoder_.SetResolutionBitrateLimits({encoder_bitrate_limits});
1352
1353 VideoEncoderConfig video_encoder_config;
1354 test::FillEncoderConfiguration(kVideoCodecVP8, 1, &video_encoder_config);
1355 video_encoder_config.max_bitrate_bps = 0;
1356 video_stream_encoder_->ConfigureEncoder(video_encoder_config.Copy(),
1357 kMaxPayloadLength);
1358
1359 video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr));
1360 WaitForEncodedFrame(1);
1361 // VideoEncoderConfig::max_bitrate_bps is set to 0 - the max bitrate
1362 // recommended by encoder should be used.
1363 EXPECT_EQ(static_cast<uint32_t>(encoder_bitrate_limits.max_bitrate_bps),
1364 bitrate_allocator_factory_.codec_config().maxBitrate * 1000);
1365
1366 video_encoder_config.max_bitrate_bps = kTargetBitrateBps;
1367 video_stream_encoder_->ConfigureEncoder(std::move(video_encoder_config),
1368 kMaxPayloadLength);
1369 video_source_.IncomingCapturedFrame(CreateFrame(2, nullptr));
1370 WaitForEncodedFrame(2);
1371
1372 // When VideoEncoderConfig::max_bitrate_bps is set it should override the max
1373 // bitrate limits recommended by encoder.
1374 EXPECT_EQ(kTargetBitrateBps,
1375 bitrate_allocator_factory_.codec_config().maxBitrate * 1000);
1376
1377 video_stream_encoder_->Stop();
1378}
1379
1380TEST_F(VideoStreamEncoderTest,
1381 EncoderRecommendedMaxBitrateUsedForGivenResolution) {
1382 video_stream_encoder_->OnBitrateUpdated(
1383 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
1384
1385 const VideoEncoder::ResolutionBitrateLimits encoder_bitrate_limits_270p(
1386 480 * 270, 0, 0, kTargetBitrateBps + 270 * 1000);
1387 const VideoEncoder::ResolutionBitrateLimits encoder_bitrate_limits_360p(
1388 640 * 360, 0, 0, kTargetBitrateBps + 360 * 1000);
1389 fake_encoder_.SetResolutionBitrateLimits(
1390 {encoder_bitrate_limits_270p, encoder_bitrate_limits_360p});
1391
1392 VideoEncoderConfig video_encoder_config;
1393 test::FillEncoderConfiguration(kVideoCodecVP8, 1, &video_encoder_config);
1394 video_encoder_config.max_bitrate_bps = 0;
1395 video_stream_encoder_->ConfigureEncoder(video_encoder_config.Copy(),
1396 kMaxPayloadLength);
1397
1398 // 270p. The max bitrate limit recommended by encoder for 270p should be used.
1399 video_source_.IncomingCapturedFrame(CreateFrame(1, 480, 270));
1400 WaitForEncodedFrame(1);
1401 EXPECT_EQ(static_cast<uint32_t>(encoder_bitrate_limits_270p.max_bitrate_bps),
1402 bitrate_allocator_factory_.codec_config().maxBitrate * 1000);
1403
1404 // 360p. The max bitrate limit recommended by encoder for 360p should be used.
1405 video_source_.IncomingCapturedFrame(CreateFrame(2, 640, 360));
1406 WaitForEncodedFrame(2);
1407 EXPECT_EQ(static_cast<uint32_t>(encoder_bitrate_limits_360p.max_bitrate_bps),
1408 bitrate_allocator_factory_.codec_config().maxBitrate * 1000);
1409
1410 // Resolution between 270p and 360p. The max bitrate limit recommended by
1411 // encoder for 360p should be used.
1412 video_source_.IncomingCapturedFrame(
1413 CreateFrame(3, (640 + 480) / 2, (360 + 270) / 2));
1414 WaitForEncodedFrame(3);
1415 EXPECT_EQ(static_cast<uint32_t>(encoder_bitrate_limits_360p.max_bitrate_bps),
1416 bitrate_allocator_factory_.codec_config().maxBitrate * 1000);
1417
1418 // Resolution higher than 360p. The caps recommenended by encoder should be
1419 // ignored.
1420 video_source_.IncomingCapturedFrame(CreateFrame(4, 960, 540));
1421 WaitForEncodedFrame(4);
1422 EXPECT_NE(static_cast<uint32_t>(encoder_bitrate_limits_270p.max_bitrate_bps),
1423 bitrate_allocator_factory_.codec_config().maxBitrate * 1000);
1424 EXPECT_NE(static_cast<uint32_t>(encoder_bitrate_limits_360p.max_bitrate_bps),
1425 bitrate_allocator_factory_.codec_config().maxBitrate * 1000);
1426
1427 // Resolution lower than 270p. The max bitrate limit recommended by encoder
1428 // for 270p should be used.
1429 video_source_.IncomingCapturedFrame(CreateFrame(5, 320, 180));
1430 WaitForEncodedFrame(5);
1431 EXPECT_EQ(static_cast<uint32_t>(encoder_bitrate_limits_270p.max_bitrate_bps),
1432 bitrate_allocator_factory_.codec_config().maxBitrate * 1000);
1433
1434 video_stream_encoder_->Stop();
1435}
1436
mflodmancc3d4422017-08-03 08:27:51 -07001437TEST_F(VideoStreamEncoderTest, SwitchSourceDeregisterEncoderAsSink) {
perkj803d97f2016-11-01 11:45:46 -07001438 EXPECT_TRUE(video_source_.has_sinks());
1439 test::FrameForwarder new_video_source;
mflodmancc3d4422017-08-03 08:27:51 -07001440 video_stream_encoder_->SetSource(
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07001441 &new_video_source, webrtc::DegradationPreference::MAINTAIN_FRAMERATE);
perkj803d97f2016-11-01 11:45:46 -07001442 EXPECT_FALSE(video_source_.has_sinks());
1443 EXPECT_TRUE(new_video_source.has_sinks());
1444
mflodmancc3d4422017-08-03 08:27:51 -07001445 video_stream_encoder_->Stop();
perkj803d97f2016-11-01 11:45:46 -07001446}
1447
mflodmancc3d4422017-08-03 08:27:51 -07001448TEST_F(VideoStreamEncoderTest, SinkWantsRotationApplied) {
perkj803d97f2016-11-01 11:45:46 -07001449 EXPECT_FALSE(video_source_.sink_wants().rotation_applied);
mflodmancc3d4422017-08-03 08:27:51 -07001450 video_stream_encoder_->SetSink(&sink_, true /*rotation_applied*/);
perkj803d97f2016-11-01 11:45:46 -07001451 EXPECT_TRUE(video_source_.sink_wants().rotation_applied);
mflodmancc3d4422017-08-03 08:27:51 -07001452 video_stream_encoder_->Stop();
perkj803d97f2016-11-01 11:45:46 -07001453}
1454
Jonathan Yubc771b72017-12-08 17:04:29 -08001455TEST_F(VideoStreamEncoderTest, TestCpuDowngrades_BalancedMode) {
1456 const int kFramerateFps = 30;
asaperssonf7e294d2017-06-13 23:25:22 -07001457 const int kWidth = 1280;
1458 const int kHeight = 720;
Jonathan Yubc771b72017-12-08 17:04:29 -08001459
1460 // We rely on the automatic resolution adaptation, but we handle framerate
1461 // adaptation manually by mocking the stats proxy.
1462 video_source_.set_adaptation_enabled(true);
asaperssonf7e294d2017-06-13 23:25:22 -07001463
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07001464 // Enable BALANCED preference, no initial limitation.
Erik Språng4c6ca302019-04-08 15:14:01 +02001465 video_stream_encoder_->OnBitrateUpdated(
1466 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07001467 video_stream_encoder_->SetSource(&video_source_,
1468 webrtc::DegradationPreference::BALANCED);
Jonathan Yubc771b72017-12-08 17:04:29 -08001469 VerifyNoLimitation(video_source_.sink_wants());
asaperssonf7e294d2017-06-13 23:25:22 -07001470 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_resolution);
Jonathan Yubc771b72017-12-08 17:04:29 -08001471 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_framerate);
asaperssonf7e294d2017-06-13 23:25:22 -07001472 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_cpu_adapt_changes);
1473
Jonathan Yubc771b72017-12-08 17:04:29 -08001474 // Adapt down as far as possible.
1475 rtc::VideoSinkWants last_wants;
1476 int64_t t = 1;
1477 int loop_count = 0;
1478 do {
1479 ++loop_count;
1480 last_wants = video_source_.sink_wants();
1481
1482 // Simulate the framerate we've been asked to adapt to.
1483 const int fps = std::min(kFramerateFps, last_wants.max_framerate_fps);
1484 const int frame_interval_ms = rtc::kNumMillisecsPerSec / fps;
1485 VideoSendStream::Stats mock_stats = stats_proxy_->GetStats();
1486 mock_stats.input_frame_rate = fps;
1487 stats_proxy_->SetMockStats(mock_stats);
1488
1489 video_source_.IncomingCapturedFrame(CreateFrame(t, kWidth, kHeight));
1490 sink_.WaitForEncodedFrame(t);
1491 t += frame_interval_ms;
1492
mflodmancc3d4422017-08-03 08:27:51 -07001493 video_stream_encoder_->TriggerCpuOveruse();
Jonathan Yubc771b72017-12-08 17:04:29 -08001494 VerifyBalancedModeFpsRange(
1495 video_source_.sink_wants(),
1496 *video_source_.last_sent_width() * *video_source_.last_sent_height());
1497 } while (video_source_.sink_wants().max_pixel_count <
1498 last_wants.max_pixel_count ||
1499 video_source_.sink_wants().max_framerate_fps <
1500 last_wants.max_framerate_fps);
asaperssonf7e294d2017-06-13 23:25:22 -07001501
Jonathan Yubc771b72017-12-08 17:04:29 -08001502 // Verify that we've adapted all the way down.
1503 stats_proxy_->ResetMockStats();
asaperssonf7e294d2017-06-13 23:25:22 -07001504 EXPECT_TRUE(stats_proxy_->GetStats().cpu_limited_resolution);
Jonathan Yubc771b72017-12-08 17:04:29 -08001505 EXPECT_TRUE(stats_proxy_->GetStats().cpu_limited_framerate);
1506 EXPECT_EQ(loop_count - 1,
asaperssonf7e294d2017-06-13 23:25:22 -07001507 stats_proxy_->GetStats().number_of_cpu_adapt_changes);
Jonathan Yubc771b72017-12-08 17:04:29 -08001508 EXPECT_EQ(kMinPixelsPerFrame, *video_source_.last_sent_width() *
1509 *video_source_.last_sent_height());
1510 EXPECT_EQ(kMinBalancedFramerateFps,
1511 video_source_.sink_wants().max_framerate_fps);
asaperssonf7e294d2017-06-13 23:25:22 -07001512
Jonathan Yubc771b72017-12-08 17:04:29 -08001513 // Adapt back up the same number of times we adapted down.
1514 for (int i = 0; i < loop_count - 1; ++i) {
1515 last_wants = video_source_.sink_wants();
1516
1517 // Simulate the framerate we've been asked to adapt to.
1518 const int fps = std::min(kFramerateFps, last_wants.max_framerate_fps);
1519 const int frame_interval_ms = rtc::kNumMillisecsPerSec / fps;
1520 VideoSendStream::Stats mock_stats = stats_proxy_->GetStats();
1521 mock_stats.input_frame_rate = fps;
1522 stats_proxy_->SetMockStats(mock_stats);
1523
1524 video_source_.IncomingCapturedFrame(CreateFrame(t, kWidth, kHeight));
1525 sink_.WaitForEncodedFrame(t);
1526 t += frame_interval_ms;
1527
mflodmancc3d4422017-08-03 08:27:51 -07001528 video_stream_encoder_->TriggerCpuNormalUsage();
Jonathan Yubc771b72017-12-08 17:04:29 -08001529 VerifyBalancedModeFpsRange(
1530 video_source_.sink_wants(),
1531 *video_source_.last_sent_width() * *video_source_.last_sent_height());
1532 EXPECT_TRUE(video_source_.sink_wants().max_pixel_count >
1533 last_wants.max_pixel_count ||
1534 video_source_.sink_wants().max_framerate_fps >
1535 last_wants.max_framerate_fps);
asaperssonf7e294d2017-06-13 23:25:22 -07001536 }
1537
Åsa Persson8c1bf952018-09-13 10:42:19 +02001538 VerifyFpsMaxResolutionMax(video_source_.sink_wants());
Jonathan Yubc771b72017-12-08 17:04:29 -08001539 stats_proxy_->ResetMockStats();
asaperssonf7e294d2017-06-13 23:25:22 -07001540 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_resolution);
Jonathan Yubc771b72017-12-08 17:04:29 -08001541 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_framerate);
1542 EXPECT_EQ((loop_count - 1) * 2,
1543 stats_proxy_->GetStats().number_of_cpu_adapt_changes);
asaperssonf7e294d2017-06-13 23:25:22 -07001544
mflodmancc3d4422017-08-03 08:27:51 -07001545 video_stream_encoder_->Stop();
asaperssonf7e294d2017-06-13 23:25:22 -07001546}
mflodmancc3d4422017-08-03 08:27:51 -07001547TEST_F(VideoStreamEncoderTest, SinkWantsStoredByDegradationPreference) {
Erik Språng4c6ca302019-04-08 15:14:01 +02001548 video_stream_encoder_->OnBitrateUpdated(
1549 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
asapersson02465b82017-04-10 01:12:52 -07001550 VerifyNoLimitation(video_source_.sink_wants());
perkj803d97f2016-11-01 11:45:46 -07001551
sprangc5d62e22017-04-02 23:53:04 -07001552 const int kFrameWidth = 1280;
1553 const int kFrameHeight = 720;
sprangc5d62e22017-04-02 23:53:04 -07001554
Åsa Persson8c1bf952018-09-13 10:42:19 +02001555 int64_t frame_timestamp = 1;
perkj803d97f2016-11-01 11:45:46 -07001556
kthelgason5e13d412016-12-01 03:59:51 -08001557 video_source_.IncomingCapturedFrame(
sprangc5d62e22017-04-02 23:53:04 -07001558 CreateFrame(frame_timestamp, kFrameWidth, kFrameHeight));
sprang4847ae62017-06-27 07:06:52 -07001559 WaitForEncodedFrame(frame_timestamp);
sprangc5d62e22017-04-02 23:53:04 -07001560 frame_timestamp += kFrameIntervalMs;
1561
perkj803d97f2016-11-01 11:45:46 -07001562 // Trigger CPU overuse.
mflodmancc3d4422017-08-03 08:27:51 -07001563 video_stream_encoder_->TriggerCpuOveruse();
perkj803d97f2016-11-01 11:45:46 -07001564 video_source_.IncomingCapturedFrame(
sprangc5d62e22017-04-02 23:53:04 -07001565 CreateFrame(frame_timestamp, kFrameWidth, kFrameHeight));
sprang4847ae62017-06-27 07:06:52 -07001566 WaitForEncodedFrame(frame_timestamp);
sprangc5d62e22017-04-02 23:53:04 -07001567 frame_timestamp += kFrameIntervalMs;
sprang3ea3c772017-03-30 07:23:48 -07001568
asapersson0944a802017-04-07 00:57:58 -07001569 // Default degradation preference is maintain-framerate, so will lower max
sprangc5d62e22017-04-02 23:53:04 -07001570 // wanted resolution.
1571 EXPECT_FALSE(video_source_.sink_wants().target_pixel_count);
1572 EXPECT_LT(video_source_.sink_wants().max_pixel_count,
1573 kFrameWidth * kFrameHeight);
Åsa Persson8c1bf952018-09-13 10:42:19 +02001574 EXPECT_EQ(kDefaultFramerate, video_source_.sink_wants().max_framerate_fps);
sprangc5d62e22017-04-02 23:53:04 -07001575
1576 // Set new source, switch to maintain-resolution.
perkj803d97f2016-11-01 11:45:46 -07001577 test::FrameForwarder new_video_source;
mflodmancc3d4422017-08-03 08:27:51 -07001578 video_stream_encoder_->SetSource(
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07001579 &new_video_source, webrtc::DegradationPreference::MAINTAIN_RESOLUTION);
perkj803d97f2016-11-01 11:45:46 -07001580
sprangc5d62e22017-04-02 23:53:04 -07001581 // Initially no degradation registered.
Åsa Persson8c1bf952018-09-13 10:42:19 +02001582 VerifyFpsMaxResolutionMax(new_video_source.sink_wants());
perkj803d97f2016-11-01 11:45:46 -07001583
sprangc5d62e22017-04-02 23:53:04 -07001584 // Force an input frame rate to be available, or the adaptation call won't
1585 // know what framerate to adapt form.
asapersson02465b82017-04-10 01:12:52 -07001586 const int kInputFps = 30;
sprangc5d62e22017-04-02 23:53:04 -07001587 VideoSendStream::Stats stats = stats_proxy_->GetStats();
asapersson02465b82017-04-10 01:12:52 -07001588 stats.input_frame_rate = kInputFps;
sprangc5d62e22017-04-02 23:53:04 -07001589 stats_proxy_->SetMockStats(stats);
1590
mflodmancc3d4422017-08-03 08:27:51 -07001591 video_stream_encoder_->TriggerCpuOveruse();
perkj803d97f2016-11-01 11:45:46 -07001592 new_video_source.IncomingCapturedFrame(
sprangc5d62e22017-04-02 23:53:04 -07001593 CreateFrame(frame_timestamp, kFrameWidth, kFrameHeight));
sprang4847ae62017-06-27 07:06:52 -07001594 WaitForEncodedFrame(frame_timestamp);
sprangc5d62e22017-04-02 23:53:04 -07001595 frame_timestamp += kFrameIntervalMs;
1596
1597 // Some framerate constraint should be set.
sprang84a37592017-02-10 07:04:27 -08001598 EXPECT_FALSE(new_video_source.sink_wants().target_pixel_count);
sprangc5d62e22017-04-02 23:53:04 -07001599 EXPECT_EQ(std::numeric_limits<int>::max(),
1600 new_video_source.sink_wants().max_pixel_count);
asapersson02465b82017-04-10 01:12:52 -07001601 EXPECT_LT(new_video_source.sink_wants().max_framerate_fps, kInputFps);
sprangc5d62e22017-04-02 23:53:04 -07001602
asapersson02465b82017-04-10 01:12:52 -07001603 // Turn off degradation completely.
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07001604 video_stream_encoder_->SetSource(&new_video_source,
1605 webrtc::DegradationPreference::DISABLED);
Åsa Persson8c1bf952018-09-13 10:42:19 +02001606 VerifyFpsMaxResolutionMax(new_video_source.sink_wants());
sprangc5d62e22017-04-02 23:53:04 -07001607
mflodmancc3d4422017-08-03 08:27:51 -07001608 video_stream_encoder_->TriggerCpuOveruse();
sprangc5d62e22017-04-02 23:53:04 -07001609 new_video_source.IncomingCapturedFrame(
1610 CreateFrame(frame_timestamp, kFrameWidth, kFrameHeight));
sprang4847ae62017-06-27 07:06:52 -07001611 WaitForEncodedFrame(frame_timestamp);
sprangc5d62e22017-04-02 23:53:04 -07001612 frame_timestamp += kFrameIntervalMs;
1613
1614 // Still no degradation.
Åsa Persson8c1bf952018-09-13 10:42:19 +02001615 VerifyFpsMaxResolutionMax(new_video_source.sink_wants());
perkj803d97f2016-11-01 11:45:46 -07001616
1617 // Calling SetSource with resolution scaling enabled apply the old SinkWants.
mflodmancc3d4422017-08-03 08:27:51 -07001618 video_stream_encoder_->SetSource(
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07001619 &new_video_source, webrtc::DegradationPreference::MAINTAIN_FRAMERATE);
sprangc5d62e22017-04-02 23:53:04 -07001620 EXPECT_LT(new_video_source.sink_wants().max_pixel_count,
1621 kFrameWidth * kFrameHeight);
sprang84a37592017-02-10 07:04:27 -08001622 EXPECT_FALSE(new_video_source.sink_wants().target_pixel_count);
Åsa Persson8c1bf952018-09-13 10:42:19 +02001623 EXPECT_EQ(kDefaultFramerate, new_video_source.sink_wants().max_framerate_fps);
sprangc5d62e22017-04-02 23:53:04 -07001624
1625 // Calling SetSource with framerate scaling enabled apply the old SinkWants.
mflodmancc3d4422017-08-03 08:27:51 -07001626 video_stream_encoder_->SetSource(
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07001627 &new_video_source, webrtc::DegradationPreference::MAINTAIN_RESOLUTION);
sprangc5d62e22017-04-02 23:53:04 -07001628 EXPECT_FALSE(new_video_source.sink_wants().target_pixel_count);
1629 EXPECT_EQ(std::numeric_limits<int>::max(),
1630 new_video_source.sink_wants().max_pixel_count);
asapersson02465b82017-04-10 01:12:52 -07001631 EXPECT_LT(new_video_source.sink_wants().max_framerate_fps, kInputFps);
perkj803d97f2016-11-01 11:45:46 -07001632
mflodmancc3d4422017-08-03 08:27:51 -07001633 video_stream_encoder_->Stop();
perkj803d97f2016-11-01 11:45:46 -07001634}
1635
mflodmancc3d4422017-08-03 08:27:51 -07001636TEST_F(VideoStreamEncoderTest, StatsTracksQualityAdaptationStats) {
Erik Språng4c6ca302019-04-08 15:14:01 +02001637 video_stream_encoder_->OnBitrateUpdated(
1638 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
perkj803d97f2016-11-01 11:45:46 -07001639
asaperssonfab67072017-04-04 05:51:49 -07001640 const int kWidth = 1280;
1641 const int kHeight = 720;
asaperssonfab67072017-04-04 05:51:49 -07001642 video_source_.IncomingCapturedFrame(CreateFrame(1, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07001643 WaitForEncodedFrame(1);
asaperssonfab67072017-04-04 05:51:49 -07001644 VideoSendStream::Stats stats = stats_proxy_->GetStats();
1645 EXPECT_FALSE(stats.bw_limited_resolution);
1646 EXPECT_EQ(0, stats.number_of_quality_adapt_changes);
1647
1648 // Trigger adapt down.
mflodmancc3d4422017-08-03 08:27:51 -07001649 video_stream_encoder_->TriggerQualityLow();
asaperssonfab67072017-04-04 05:51:49 -07001650 video_source_.IncomingCapturedFrame(CreateFrame(2, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07001651 WaitForEncodedFrame(2);
asaperssonfab67072017-04-04 05:51:49 -07001652
1653 stats = stats_proxy_->GetStats();
1654 EXPECT_TRUE(stats.bw_limited_resolution);
1655 EXPECT_EQ(1, stats.number_of_quality_adapt_changes);
1656
1657 // Trigger adapt up.
mflodmancc3d4422017-08-03 08:27:51 -07001658 video_stream_encoder_->TriggerQualityHigh();
asaperssonfab67072017-04-04 05:51:49 -07001659 video_source_.IncomingCapturedFrame(CreateFrame(3, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07001660 WaitForEncodedFrame(3);
asaperssonfab67072017-04-04 05:51:49 -07001661
1662 stats = stats_proxy_->GetStats();
1663 EXPECT_FALSE(stats.bw_limited_resolution);
1664 EXPECT_EQ(2, stats.number_of_quality_adapt_changes);
1665 EXPECT_EQ(0, stats.number_of_cpu_adapt_changes);
1666
mflodmancc3d4422017-08-03 08:27:51 -07001667 video_stream_encoder_->Stop();
asaperssonfab67072017-04-04 05:51:49 -07001668}
1669
mflodmancc3d4422017-08-03 08:27:51 -07001670TEST_F(VideoStreamEncoderTest, StatsTracksCpuAdaptationStats) {
Erik Språng4c6ca302019-04-08 15:14:01 +02001671 video_stream_encoder_->OnBitrateUpdated(
1672 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
asaperssonfab67072017-04-04 05:51:49 -07001673
1674 const int kWidth = 1280;
1675 const int kHeight = 720;
asaperssonfab67072017-04-04 05:51:49 -07001676 video_source_.IncomingCapturedFrame(CreateFrame(1, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07001677 WaitForEncodedFrame(1);
perkj803d97f2016-11-01 11:45:46 -07001678 VideoSendStream::Stats stats = stats_proxy_->GetStats();
1679 EXPECT_FALSE(stats.cpu_limited_resolution);
1680 EXPECT_EQ(0, stats.number_of_cpu_adapt_changes);
1681
1682 // Trigger CPU overuse.
mflodmancc3d4422017-08-03 08:27:51 -07001683 video_stream_encoder_->TriggerCpuOveruse();
asaperssonfab67072017-04-04 05:51:49 -07001684 video_source_.IncomingCapturedFrame(CreateFrame(2, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07001685 WaitForEncodedFrame(2);
perkj803d97f2016-11-01 11:45:46 -07001686
1687 stats = stats_proxy_->GetStats();
1688 EXPECT_TRUE(stats.cpu_limited_resolution);
1689 EXPECT_EQ(1, stats.number_of_cpu_adapt_changes);
1690
1691 // Trigger CPU normal use.
mflodmancc3d4422017-08-03 08:27:51 -07001692 video_stream_encoder_->TriggerCpuNormalUsage();
asaperssonfab67072017-04-04 05:51:49 -07001693 video_source_.IncomingCapturedFrame(CreateFrame(3, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07001694 WaitForEncodedFrame(3);
perkj803d97f2016-11-01 11:45:46 -07001695
1696 stats = stats_proxy_->GetStats();
1697 EXPECT_FALSE(stats.cpu_limited_resolution);
1698 EXPECT_EQ(2, stats.number_of_cpu_adapt_changes);
asaperssonfab67072017-04-04 05:51:49 -07001699 EXPECT_EQ(0, stats.number_of_quality_adapt_changes);
perkj803d97f2016-11-01 11:45:46 -07001700
mflodmancc3d4422017-08-03 08:27:51 -07001701 video_stream_encoder_->Stop();
perkj803d97f2016-11-01 11:45:46 -07001702}
1703
mflodmancc3d4422017-08-03 08:27:51 -07001704TEST_F(VideoStreamEncoderTest, SwitchingSourceKeepsCpuAdaptation) {
Erik Språng4c6ca302019-04-08 15:14:01 +02001705 video_stream_encoder_->OnBitrateUpdated(
1706 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
kthelgason876222f2016-11-29 01:44:11 -08001707
asaperssonfab67072017-04-04 05:51:49 -07001708 const int kWidth = 1280;
1709 const int kHeight = 720;
1710 video_source_.IncomingCapturedFrame(CreateFrame(1, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07001711 WaitForEncodedFrame(1);
kthelgason876222f2016-11-29 01:44:11 -08001712 VideoSendStream::Stats stats = stats_proxy_->GetStats();
asapersson09f05612017-05-15 23:40:18 -07001713 EXPECT_FALSE(stats.bw_limited_resolution);
kthelgason876222f2016-11-29 01:44:11 -08001714 EXPECT_FALSE(stats.cpu_limited_resolution);
1715 EXPECT_EQ(0, stats.number_of_cpu_adapt_changes);
1716
asaperssonfab67072017-04-04 05:51:49 -07001717 // Trigger CPU overuse.
mflodmancc3d4422017-08-03 08:27:51 -07001718 video_stream_encoder_->TriggerCpuOveruse();
asaperssonfab67072017-04-04 05:51:49 -07001719 video_source_.IncomingCapturedFrame(CreateFrame(2, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07001720 WaitForEncodedFrame(2);
kthelgason876222f2016-11-29 01:44:11 -08001721 stats = stats_proxy_->GetStats();
asapersson09f05612017-05-15 23:40:18 -07001722 EXPECT_FALSE(stats.bw_limited_resolution);
kthelgason876222f2016-11-29 01:44:11 -08001723 EXPECT_TRUE(stats.cpu_limited_resolution);
1724 EXPECT_EQ(1, stats.number_of_cpu_adapt_changes);
1725
1726 // Set new source with adaptation still enabled.
1727 test::FrameForwarder new_video_source;
mflodmancc3d4422017-08-03 08:27:51 -07001728 video_stream_encoder_->SetSource(
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07001729 &new_video_source, webrtc::DegradationPreference::MAINTAIN_FRAMERATE);
kthelgason876222f2016-11-29 01:44:11 -08001730
asaperssonfab67072017-04-04 05:51:49 -07001731 new_video_source.IncomingCapturedFrame(CreateFrame(3, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07001732 WaitForEncodedFrame(3);
kthelgason876222f2016-11-29 01:44:11 -08001733 stats = stats_proxy_->GetStats();
asapersson09f05612017-05-15 23:40:18 -07001734 EXPECT_FALSE(stats.bw_limited_resolution);
kthelgason876222f2016-11-29 01:44:11 -08001735 EXPECT_TRUE(stats.cpu_limited_resolution);
1736 EXPECT_EQ(1, stats.number_of_cpu_adapt_changes);
1737
1738 // Set adaptation disabled.
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07001739 video_stream_encoder_->SetSource(&new_video_source,
1740 webrtc::DegradationPreference::DISABLED);
kthelgason876222f2016-11-29 01:44:11 -08001741
asaperssonfab67072017-04-04 05:51:49 -07001742 new_video_source.IncomingCapturedFrame(CreateFrame(4, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07001743 WaitForEncodedFrame(4);
kthelgason876222f2016-11-29 01:44:11 -08001744 stats = stats_proxy_->GetStats();
asapersson09f05612017-05-15 23:40:18 -07001745 EXPECT_FALSE(stats.bw_limited_resolution);
kthelgason876222f2016-11-29 01:44:11 -08001746 EXPECT_FALSE(stats.cpu_limited_resolution);
1747 EXPECT_EQ(1, stats.number_of_cpu_adapt_changes);
1748
1749 // Set adaptation back to enabled.
mflodmancc3d4422017-08-03 08:27:51 -07001750 video_stream_encoder_->SetSource(
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07001751 &new_video_source, webrtc::DegradationPreference::MAINTAIN_FRAMERATE);
kthelgason876222f2016-11-29 01:44:11 -08001752
asaperssonfab67072017-04-04 05:51:49 -07001753 new_video_source.IncomingCapturedFrame(CreateFrame(5, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07001754 WaitForEncodedFrame(5);
kthelgason876222f2016-11-29 01:44:11 -08001755 stats = stats_proxy_->GetStats();
asapersson09f05612017-05-15 23:40:18 -07001756 EXPECT_FALSE(stats.bw_limited_resolution);
kthelgason876222f2016-11-29 01:44:11 -08001757 EXPECT_TRUE(stats.cpu_limited_resolution);
1758 EXPECT_EQ(1, stats.number_of_cpu_adapt_changes);
1759
asaperssonfab67072017-04-04 05:51:49 -07001760 // Trigger CPU normal use.
mflodmancc3d4422017-08-03 08:27:51 -07001761 video_stream_encoder_->TriggerCpuNormalUsage();
asaperssonfab67072017-04-04 05:51:49 -07001762 new_video_source.IncomingCapturedFrame(CreateFrame(6, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07001763 WaitForEncodedFrame(6);
kthelgason876222f2016-11-29 01:44:11 -08001764 stats = stats_proxy_->GetStats();
asapersson09f05612017-05-15 23:40:18 -07001765 EXPECT_FALSE(stats.bw_limited_resolution);
kthelgason876222f2016-11-29 01:44:11 -08001766 EXPECT_FALSE(stats.cpu_limited_resolution);
1767 EXPECT_EQ(2, stats.number_of_cpu_adapt_changes);
asapersson02465b82017-04-10 01:12:52 -07001768 EXPECT_EQ(0, stats.number_of_quality_adapt_changes);
kthelgason876222f2016-11-29 01:44:11 -08001769
mflodmancc3d4422017-08-03 08:27:51 -07001770 video_stream_encoder_->Stop();
kthelgason876222f2016-11-29 01:44:11 -08001771}
1772
mflodmancc3d4422017-08-03 08:27:51 -07001773TEST_F(VideoStreamEncoderTest, SwitchingSourceKeepsQualityAdaptation) {
Erik Språng4c6ca302019-04-08 15:14:01 +02001774 video_stream_encoder_->OnBitrateUpdated(
1775 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
kthelgason876222f2016-11-29 01:44:11 -08001776
asaperssonfab67072017-04-04 05:51:49 -07001777 const int kWidth = 1280;
1778 const int kHeight = 720;
1779 video_source_.IncomingCapturedFrame(CreateFrame(1, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07001780 WaitForEncodedFrame(1);
kthelgason876222f2016-11-29 01:44:11 -08001781 VideoSendStream::Stats stats = stats_proxy_->GetStats();
kthelgason876222f2016-11-29 01:44:11 -08001782 EXPECT_FALSE(stats.bw_limited_resolution);
asapersson13874762017-06-07 00:01:02 -07001783 EXPECT_FALSE(stats.bw_limited_framerate);
asaperssonfab67072017-04-04 05:51:49 -07001784 EXPECT_EQ(0, stats.number_of_quality_adapt_changes);
kthelgason876222f2016-11-29 01:44:11 -08001785
1786 // Set new source with adaptation still enabled.
1787 test::FrameForwarder new_video_source;
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07001788 video_stream_encoder_->SetSource(&new_video_source,
1789 webrtc::DegradationPreference::BALANCED);
kthelgason876222f2016-11-29 01:44:11 -08001790
asaperssonfab67072017-04-04 05:51:49 -07001791 new_video_source.IncomingCapturedFrame(CreateFrame(2, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07001792 WaitForEncodedFrame(2);
kthelgason876222f2016-11-29 01:44:11 -08001793 stats = stats_proxy_->GetStats();
kthelgason876222f2016-11-29 01:44:11 -08001794 EXPECT_FALSE(stats.bw_limited_resolution);
asapersson13874762017-06-07 00:01:02 -07001795 EXPECT_FALSE(stats.bw_limited_framerate);
asaperssonfab67072017-04-04 05:51:49 -07001796 EXPECT_EQ(0, stats.number_of_quality_adapt_changes);
kthelgason876222f2016-11-29 01:44:11 -08001797
asaperssonfab67072017-04-04 05:51:49 -07001798 // Trigger adapt down.
mflodmancc3d4422017-08-03 08:27:51 -07001799 video_stream_encoder_->TriggerQualityLow();
asaperssonfab67072017-04-04 05:51:49 -07001800 new_video_source.IncomingCapturedFrame(CreateFrame(3, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07001801 WaitForEncodedFrame(3);
kthelgason876222f2016-11-29 01:44:11 -08001802 stats = stats_proxy_->GetStats();
kthelgason876222f2016-11-29 01:44:11 -08001803 EXPECT_TRUE(stats.bw_limited_resolution);
asapersson13874762017-06-07 00:01:02 -07001804 EXPECT_FALSE(stats.bw_limited_framerate);
asaperssonfab67072017-04-04 05:51:49 -07001805 EXPECT_EQ(1, stats.number_of_quality_adapt_changes);
kthelgason876222f2016-11-29 01:44:11 -08001806
asaperssonfab67072017-04-04 05:51:49 -07001807 // Set new source with adaptation still enabled.
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07001808 video_stream_encoder_->SetSource(&new_video_source,
1809 webrtc::DegradationPreference::BALANCED);
kthelgason876222f2016-11-29 01:44:11 -08001810
asaperssonfab67072017-04-04 05:51:49 -07001811 new_video_source.IncomingCapturedFrame(CreateFrame(4, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07001812 WaitForEncodedFrame(4);
kthelgason876222f2016-11-29 01:44:11 -08001813 stats = stats_proxy_->GetStats();
kthelgason876222f2016-11-29 01:44:11 -08001814 EXPECT_TRUE(stats.bw_limited_resolution);
asapersson13874762017-06-07 00:01:02 -07001815 EXPECT_FALSE(stats.bw_limited_framerate);
asaperssonfab67072017-04-04 05:51:49 -07001816 EXPECT_EQ(1, stats.number_of_quality_adapt_changes);
kthelgason876222f2016-11-29 01:44:11 -08001817
asapersson02465b82017-04-10 01:12:52 -07001818 // Disable resolution scaling.
mflodmancc3d4422017-08-03 08:27:51 -07001819 video_stream_encoder_->SetSource(
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07001820 &new_video_source, webrtc::DegradationPreference::MAINTAIN_RESOLUTION);
kthelgason876222f2016-11-29 01:44:11 -08001821
asaperssonfab67072017-04-04 05:51:49 -07001822 new_video_source.IncomingCapturedFrame(CreateFrame(5, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07001823 WaitForEncodedFrame(5);
kthelgason876222f2016-11-29 01:44:11 -08001824 stats = stats_proxy_->GetStats();
kthelgason876222f2016-11-29 01:44:11 -08001825 EXPECT_FALSE(stats.bw_limited_resolution);
asapersson13874762017-06-07 00:01:02 -07001826 EXPECT_FALSE(stats.bw_limited_framerate);
asaperssonfab67072017-04-04 05:51:49 -07001827 EXPECT_EQ(1, stats.number_of_quality_adapt_changes);
1828 EXPECT_EQ(0, stats.number_of_cpu_adapt_changes);
kthelgason876222f2016-11-29 01:44:11 -08001829
mflodmancc3d4422017-08-03 08:27:51 -07001830 video_stream_encoder_->Stop();
kthelgason876222f2016-11-29 01:44:11 -08001831}
1832
mflodmancc3d4422017-08-03 08:27:51 -07001833TEST_F(VideoStreamEncoderTest,
1834 QualityAdaptationStatsAreResetWhenScalerIsDisabled) {
Erik Språng4c6ca302019-04-08 15:14:01 +02001835 video_stream_encoder_->OnBitrateUpdated(
1836 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
asapersson36e9eb42017-03-31 05:29:12 -07001837
1838 const int kWidth = 1280;
1839 const int kHeight = 720;
Åsa Persson8c1bf952018-09-13 10:42:19 +02001840 int64_t timestamp_ms = kFrameIntervalMs;
asapersson36e9eb42017-03-31 05:29:12 -07001841 video_source_.set_adaptation_enabled(true);
Åsa Persson8c1bf952018-09-13 10:42:19 +02001842 video_source_.IncomingCapturedFrame(
1843 CreateFrame(timestamp_ms, kWidth, kHeight));
1844 WaitForEncodedFrame(timestamp_ms);
asapersson36e9eb42017-03-31 05:29:12 -07001845 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_resolution);
1846 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution);
1847 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_cpu_adapt_changes);
1848
1849 // Trigger adapt down.
mflodmancc3d4422017-08-03 08:27:51 -07001850 video_stream_encoder_->TriggerQualityLow();
Åsa Persson8c1bf952018-09-13 10:42:19 +02001851 timestamp_ms += kFrameIntervalMs;
1852 video_source_.IncomingCapturedFrame(
1853 CreateFrame(timestamp_ms, kWidth, kHeight));
1854 WaitForEncodedFrame(timestamp_ms);
asapersson36e9eb42017-03-31 05:29:12 -07001855 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_resolution);
1856 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution);
1857 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_cpu_adapt_changes);
1858
1859 // Trigger overuse.
mflodmancc3d4422017-08-03 08:27:51 -07001860 video_stream_encoder_->TriggerCpuOveruse();
Åsa Persson8c1bf952018-09-13 10:42:19 +02001861 timestamp_ms += kFrameIntervalMs;
1862 video_source_.IncomingCapturedFrame(
1863 CreateFrame(timestamp_ms, kWidth, kHeight));
1864 WaitForEncodedFrame(timestamp_ms);
asapersson36e9eb42017-03-31 05:29:12 -07001865 EXPECT_TRUE(stats_proxy_->GetStats().cpu_limited_resolution);
1866 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution);
1867 EXPECT_EQ(1, stats_proxy_->GetStats().number_of_cpu_adapt_changes);
1868
Niels Möller4db138e2018-04-19 09:04:13 +02001869 // Leave source unchanged, but disable quality scaler.
asapersson36e9eb42017-03-31 05:29:12 -07001870 fake_encoder_.SetQualityScaling(false);
Niels Möller4db138e2018-04-19 09:04:13 +02001871
1872 VideoEncoderConfig video_encoder_config;
1873 test::FillEncoderConfiguration(kVideoCodecVP8, 1, &video_encoder_config);
1874 // Make format different, to force recreation of encoder.
1875 video_encoder_config.video_format.parameters["foo"] = "foo";
1876 video_stream_encoder_->ConfigureEncoder(std::move(video_encoder_config),
Niels Möllerf1338562018-04-26 09:51:47 +02001877 kMaxPayloadLength);
Åsa Persson8c1bf952018-09-13 10:42:19 +02001878 timestamp_ms += kFrameIntervalMs;
1879 video_source_.IncomingCapturedFrame(
1880 CreateFrame(timestamp_ms, kWidth, kHeight));
1881 WaitForEncodedFrame(timestamp_ms);
asapersson36e9eb42017-03-31 05:29:12 -07001882 EXPECT_TRUE(stats_proxy_->GetStats().cpu_limited_resolution);
1883 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution);
1884 EXPECT_EQ(1, stats_proxy_->GetStats().number_of_cpu_adapt_changes);
1885
mflodmancc3d4422017-08-03 08:27:51 -07001886 video_stream_encoder_->Stop();
asapersson36e9eb42017-03-31 05:29:12 -07001887}
1888
mflodmancc3d4422017-08-03 08:27:51 -07001889TEST_F(VideoStreamEncoderTest,
1890 StatsTracksCpuAdaptationStatsWhenSwitchingSource) {
Erik Språng4c6ca302019-04-08 15:14:01 +02001891 video_stream_encoder_->OnBitrateUpdated(
1892 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
perkj803d97f2016-11-01 11:45:46 -07001893
asapersson0944a802017-04-07 00:57:58 -07001894 const int kWidth = 1280;
1895 const int kHeight = 720;
sprang84a37592017-02-10 07:04:27 -08001896 int sequence = 1;
perkj803d97f2016-11-01 11:45:46 -07001897
asaperssonfab67072017-04-04 05:51:49 -07001898 video_source_.IncomingCapturedFrame(CreateFrame(sequence, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07001899 WaitForEncodedFrame(sequence++);
perkj803d97f2016-11-01 11:45:46 -07001900 VideoSendStream::Stats stats = stats_proxy_->GetStats();
sprang84a37592017-02-10 07:04:27 -08001901 EXPECT_FALSE(stats.cpu_limited_resolution);
asapersson13874762017-06-07 00:01:02 -07001902 EXPECT_FALSE(stats.cpu_limited_framerate);
sprang84a37592017-02-10 07:04:27 -08001903 EXPECT_EQ(0, stats.number_of_cpu_adapt_changes);
1904
asapersson02465b82017-04-10 01:12:52 -07001905 // Trigger CPU overuse, should now adapt down.
mflodmancc3d4422017-08-03 08:27:51 -07001906 video_stream_encoder_->TriggerCpuOveruse();
asaperssonfab67072017-04-04 05:51:49 -07001907 video_source_.IncomingCapturedFrame(CreateFrame(sequence, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07001908 WaitForEncodedFrame(sequence++);
sprang84a37592017-02-10 07:04:27 -08001909 stats = stats_proxy_->GetStats();
perkj803d97f2016-11-01 11:45:46 -07001910 EXPECT_TRUE(stats.cpu_limited_resolution);
asapersson13874762017-06-07 00:01:02 -07001911 EXPECT_FALSE(stats.cpu_limited_framerate);
perkj803d97f2016-11-01 11:45:46 -07001912 EXPECT_EQ(1, stats.number_of_cpu_adapt_changes);
1913
1914 // Set new source with adaptation still enabled.
1915 test::FrameForwarder new_video_source;
mflodmancc3d4422017-08-03 08:27:51 -07001916 video_stream_encoder_->SetSource(
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07001917 &new_video_source, webrtc::DegradationPreference::MAINTAIN_FRAMERATE);
perkj803d97f2016-11-01 11:45:46 -07001918
1919 new_video_source.IncomingCapturedFrame(
asaperssonfab67072017-04-04 05:51:49 -07001920 CreateFrame(sequence, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07001921 WaitForEncodedFrame(sequence++);
perkj803d97f2016-11-01 11:45:46 -07001922 stats = stats_proxy_->GetStats();
1923 EXPECT_TRUE(stats.cpu_limited_resolution);
asapersson09f05612017-05-15 23:40:18 -07001924 EXPECT_FALSE(stats.cpu_limited_framerate);
perkj803d97f2016-11-01 11:45:46 -07001925 EXPECT_EQ(1, stats.number_of_cpu_adapt_changes);
1926
sprangc5d62e22017-04-02 23:53:04 -07001927 // Set cpu adaptation by frame dropping.
mflodmancc3d4422017-08-03 08:27:51 -07001928 video_stream_encoder_->SetSource(
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07001929 &new_video_source, webrtc::DegradationPreference::MAINTAIN_RESOLUTION);
perkj803d97f2016-11-01 11:45:46 -07001930 new_video_source.IncomingCapturedFrame(
asaperssonfab67072017-04-04 05:51:49 -07001931 CreateFrame(sequence, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07001932 WaitForEncodedFrame(sequence++);
perkj803d97f2016-11-01 11:45:46 -07001933 stats = stats_proxy_->GetStats();
sprangc5d62e22017-04-02 23:53:04 -07001934 // Not adapted at first.
perkj803d97f2016-11-01 11:45:46 -07001935 EXPECT_FALSE(stats.cpu_limited_resolution);
asapersson09f05612017-05-15 23:40:18 -07001936 EXPECT_FALSE(stats.cpu_limited_framerate);
perkj803d97f2016-11-01 11:45:46 -07001937 EXPECT_EQ(1, stats.number_of_cpu_adapt_changes);
1938
sprangc5d62e22017-04-02 23:53:04 -07001939 // Force an input frame rate to be available, or the adaptation call won't
asapersson09f05612017-05-15 23:40:18 -07001940 // know what framerate to adapt from.
sprangc5d62e22017-04-02 23:53:04 -07001941 VideoSendStream::Stats mock_stats = stats_proxy_->GetStats();
1942 mock_stats.input_frame_rate = 30;
1943 stats_proxy_->SetMockStats(mock_stats);
mflodmancc3d4422017-08-03 08:27:51 -07001944 video_stream_encoder_->TriggerCpuOveruse();
sprangc5d62e22017-04-02 23:53:04 -07001945 stats_proxy_->ResetMockStats();
1946
1947 new_video_source.IncomingCapturedFrame(
asaperssonfab67072017-04-04 05:51:49 -07001948 CreateFrame(sequence, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07001949 WaitForEncodedFrame(sequence++);
sprangc5d62e22017-04-02 23:53:04 -07001950
1951 // Framerate now adapted.
1952 stats = stats_proxy_->GetStats();
asapersson09f05612017-05-15 23:40:18 -07001953 EXPECT_FALSE(stats.cpu_limited_resolution);
1954 EXPECT_TRUE(stats.cpu_limited_framerate);
sprangc5d62e22017-04-02 23:53:04 -07001955 EXPECT_EQ(2, stats.number_of_cpu_adapt_changes);
1956
1957 // Disable CPU adaptation.
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07001958 video_stream_encoder_->SetSource(&new_video_source,
1959 webrtc::DegradationPreference::DISABLED);
sprangc5d62e22017-04-02 23:53:04 -07001960 new_video_source.IncomingCapturedFrame(
asaperssonfab67072017-04-04 05:51:49 -07001961 CreateFrame(sequence, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07001962 WaitForEncodedFrame(sequence++);
sprangc5d62e22017-04-02 23:53:04 -07001963
1964 stats = stats_proxy_->GetStats();
1965 EXPECT_FALSE(stats.cpu_limited_resolution);
asapersson13874762017-06-07 00:01:02 -07001966 EXPECT_FALSE(stats.cpu_limited_framerate);
sprangc5d62e22017-04-02 23:53:04 -07001967 EXPECT_EQ(2, stats.number_of_cpu_adapt_changes);
1968
1969 // Try to trigger overuse. Should not succeed.
1970 stats_proxy_->SetMockStats(mock_stats);
mflodmancc3d4422017-08-03 08:27:51 -07001971 video_stream_encoder_->TriggerCpuOveruse();
sprangc5d62e22017-04-02 23:53:04 -07001972 stats_proxy_->ResetMockStats();
1973
1974 stats = stats_proxy_->GetStats();
1975 EXPECT_FALSE(stats.cpu_limited_resolution);
asapersson13874762017-06-07 00:01:02 -07001976 EXPECT_FALSE(stats.cpu_limited_framerate);
sprangc5d62e22017-04-02 23:53:04 -07001977 EXPECT_EQ(2, stats.number_of_cpu_adapt_changes);
1978
1979 // Switch back the source with resolution adaptation enabled.
mflodmancc3d4422017-08-03 08:27:51 -07001980 video_stream_encoder_->SetSource(
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07001981 &video_source_, webrtc::DegradationPreference::MAINTAIN_FRAMERATE);
asaperssonfab67072017-04-04 05:51:49 -07001982 video_source_.IncomingCapturedFrame(CreateFrame(sequence, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07001983 WaitForEncodedFrame(sequence++);
perkj803d97f2016-11-01 11:45:46 -07001984 stats = stats_proxy_->GetStats();
1985 EXPECT_TRUE(stats.cpu_limited_resolution);
asapersson13874762017-06-07 00:01:02 -07001986 EXPECT_FALSE(stats.cpu_limited_framerate);
sprangc5d62e22017-04-02 23:53:04 -07001987 EXPECT_EQ(2, stats.number_of_cpu_adapt_changes);
perkj803d97f2016-11-01 11:45:46 -07001988
1989 // Trigger CPU normal usage.
mflodmancc3d4422017-08-03 08:27:51 -07001990 video_stream_encoder_->TriggerCpuNormalUsage();
asaperssonfab67072017-04-04 05:51:49 -07001991 video_source_.IncomingCapturedFrame(CreateFrame(sequence, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07001992 WaitForEncodedFrame(sequence++);
perkj803d97f2016-11-01 11:45:46 -07001993 stats = stats_proxy_->GetStats();
1994 EXPECT_FALSE(stats.cpu_limited_resolution);
asapersson13874762017-06-07 00:01:02 -07001995 EXPECT_FALSE(stats.cpu_limited_framerate);
sprangc5d62e22017-04-02 23:53:04 -07001996 EXPECT_EQ(3, stats.number_of_cpu_adapt_changes);
1997
1998 // Back to the source with adaptation off, set it back to maintain-resolution.
mflodmancc3d4422017-08-03 08:27:51 -07001999 video_stream_encoder_->SetSource(
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07002000 &new_video_source, webrtc::DegradationPreference::MAINTAIN_RESOLUTION);
sprangc5d62e22017-04-02 23:53:04 -07002001 new_video_source.IncomingCapturedFrame(
asaperssonfab67072017-04-04 05:51:49 -07002002 CreateFrame(sequence, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07002003 WaitForEncodedFrame(sequence++);
sprangc5d62e22017-04-02 23:53:04 -07002004 stats = stats_proxy_->GetStats();
asapersson13874762017-06-07 00:01:02 -07002005 // Disabled, since we previously switched the source to disabled.
sprangc5d62e22017-04-02 23:53:04 -07002006 EXPECT_FALSE(stats.cpu_limited_resolution);
asapersson13874762017-06-07 00:01:02 -07002007 EXPECT_TRUE(stats.cpu_limited_framerate);
sprangc5d62e22017-04-02 23:53:04 -07002008 EXPECT_EQ(3, stats.number_of_cpu_adapt_changes);
2009
2010 // Trigger CPU normal usage.
mflodmancc3d4422017-08-03 08:27:51 -07002011 video_stream_encoder_->TriggerCpuNormalUsage();
sprangc5d62e22017-04-02 23:53:04 -07002012 new_video_source.IncomingCapturedFrame(
asaperssonfab67072017-04-04 05:51:49 -07002013 CreateFrame(sequence, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07002014 WaitForEncodedFrame(sequence++);
sprangc5d62e22017-04-02 23:53:04 -07002015 stats = stats_proxy_->GetStats();
2016 EXPECT_FALSE(stats.cpu_limited_resolution);
asapersson13874762017-06-07 00:01:02 -07002017 EXPECT_FALSE(stats.cpu_limited_framerate);
sprangc5d62e22017-04-02 23:53:04 -07002018 EXPECT_EQ(4, stats.number_of_cpu_adapt_changes);
asapersson02465b82017-04-10 01:12:52 -07002019 EXPECT_EQ(0, stats.number_of_quality_adapt_changes);
perkj803d97f2016-11-01 11:45:46 -07002020
mflodmancc3d4422017-08-03 08:27:51 -07002021 video_stream_encoder_->Stop();
perkj803d97f2016-11-01 11:45:46 -07002022}
2023
mflodmancc3d4422017-08-03 08:27:51 -07002024TEST_F(VideoStreamEncoderTest,
2025 ScalingUpAndDownDoesNothingWithMaintainResolution) {
asaperssonfab67072017-04-04 05:51:49 -07002026 const int kWidth = 1280;
2027 const int kHeight = 720;
Erik Språng4c6ca302019-04-08 15:14:01 +02002028 video_stream_encoder_->OnBitrateUpdated(
2029 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
kthelgason876222f2016-11-29 01:44:11 -08002030
asaperssonfab67072017-04-04 05:51:49 -07002031 // Expect no scaling to begin with.
asapersson02465b82017-04-10 01:12:52 -07002032 VerifyNoLimitation(video_source_.sink_wants());
kthelgason876222f2016-11-29 01:44:11 -08002033
asaperssonfab67072017-04-04 05:51:49 -07002034 video_source_.IncomingCapturedFrame(CreateFrame(1, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07002035 WaitForEncodedFrame(1);
kthelgason876222f2016-11-29 01:44:11 -08002036
asaperssonfab67072017-04-04 05:51:49 -07002037 // Trigger scale down.
mflodmancc3d4422017-08-03 08:27:51 -07002038 video_stream_encoder_->TriggerQualityLow();
kthelgason5e13d412016-12-01 03:59:51 -08002039
asaperssonfab67072017-04-04 05:51:49 -07002040 video_source_.IncomingCapturedFrame(CreateFrame(2, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07002041 WaitForEncodedFrame(2);
kthelgason5e13d412016-12-01 03:59:51 -08002042
kthelgason876222f2016-11-29 01:44:11 -08002043 // Expect a scale down.
2044 EXPECT_TRUE(video_source_.sink_wants().max_pixel_count);
asaperssonfab67072017-04-04 05:51:49 -07002045 EXPECT_LT(video_source_.sink_wants().max_pixel_count, kWidth * kHeight);
kthelgason876222f2016-11-29 01:44:11 -08002046
asapersson02465b82017-04-10 01:12:52 -07002047 // Set resolution scaling disabled.
kthelgason876222f2016-11-29 01:44:11 -08002048 test::FrameForwarder new_video_source;
mflodmancc3d4422017-08-03 08:27:51 -07002049 video_stream_encoder_->SetSource(
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07002050 &new_video_source, webrtc::DegradationPreference::MAINTAIN_RESOLUTION);
kthelgason876222f2016-11-29 01:44:11 -08002051
asaperssonfab67072017-04-04 05:51:49 -07002052 // Trigger scale down.
mflodmancc3d4422017-08-03 08:27:51 -07002053 video_stream_encoder_->TriggerQualityLow();
asaperssonfab67072017-04-04 05:51:49 -07002054 new_video_source.IncomingCapturedFrame(CreateFrame(3, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07002055 WaitForEncodedFrame(3);
kthelgason876222f2016-11-29 01:44:11 -08002056
asaperssonfab67072017-04-04 05:51:49 -07002057 // Expect no scaling.
sprangc5d62e22017-04-02 23:53:04 -07002058 EXPECT_EQ(std::numeric_limits<int>::max(),
2059 new_video_source.sink_wants().max_pixel_count);
kthelgason876222f2016-11-29 01:44:11 -08002060
asaperssonfab67072017-04-04 05:51:49 -07002061 // Trigger scale up.
mflodmancc3d4422017-08-03 08:27:51 -07002062 video_stream_encoder_->TriggerQualityHigh();
asaperssonfab67072017-04-04 05:51:49 -07002063 new_video_source.IncomingCapturedFrame(CreateFrame(4, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07002064 WaitForEncodedFrame(4);
kthelgason876222f2016-11-29 01:44:11 -08002065
asapersson02465b82017-04-10 01:12:52 -07002066 // Expect nothing to change, still no scaling.
sprangc5d62e22017-04-02 23:53:04 -07002067 EXPECT_EQ(std::numeric_limits<int>::max(),
2068 new_video_source.sink_wants().max_pixel_count);
kthelgason876222f2016-11-29 01:44:11 -08002069
mflodmancc3d4422017-08-03 08:27:51 -07002070 video_stream_encoder_->Stop();
kthelgason876222f2016-11-29 01:44:11 -08002071}
2072
mflodmancc3d4422017-08-03 08:27:51 -07002073TEST_F(VideoStreamEncoderTest,
2074 SkipsSameAdaptDownRequest_MaintainFramerateMode) {
asapersson02465b82017-04-10 01:12:52 -07002075 const int kWidth = 1280;
2076 const int kHeight = 720;
Erik Språng4c6ca302019-04-08 15:14:01 +02002077 video_stream_encoder_->OnBitrateUpdated(
2078 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
asapersson02465b82017-04-10 01:12:52 -07002079
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07002080 // Enable MAINTAIN_FRAMERATE preference, no initial limitation.
asapersson02465b82017-04-10 01:12:52 -07002081 test::FrameForwarder source;
mflodmancc3d4422017-08-03 08:27:51 -07002082 video_stream_encoder_->SetSource(
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07002083 &source, webrtc::DegradationPreference::MAINTAIN_FRAMERATE);
asapersson02465b82017-04-10 01:12:52 -07002084
2085 source.IncomingCapturedFrame(CreateFrame(1, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07002086 WaitForEncodedFrame(1);
Åsa Persson8c1bf952018-09-13 10:42:19 +02002087 VerifyFpsMaxResolutionMax(source.sink_wants());
asapersson02465b82017-04-10 01:12:52 -07002088 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_resolution);
2089 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_cpu_adapt_changes);
2090
2091 // Trigger adapt down, expect scaled down resolution.
mflodmancc3d4422017-08-03 08:27:51 -07002092 video_stream_encoder_->TriggerCpuOveruse();
asapersson09f05612017-05-15 23:40:18 -07002093 VerifyFpsMaxResolutionLt(source.sink_wants(), kWidth * kHeight);
asapersson02465b82017-04-10 01:12:52 -07002094 const int kLastMaxPixelCount = source.sink_wants().max_pixel_count;
2095 EXPECT_TRUE(stats_proxy_->GetStats().cpu_limited_resolution);
2096 EXPECT_EQ(1, stats_proxy_->GetStats().number_of_cpu_adapt_changes);
2097
2098 // Trigger adapt down for same input resolution, expect no change.
mflodmancc3d4422017-08-03 08:27:51 -07002099 video_stream_encoder_->TriggerCpuOveruse();
asapersson02465b82017-04-10 01:12:52 -07002100 EXPECT_EQ(kLastMaxPixelCount, source.sink_wants().max_pixel_count);
2101 EXPECT_TRUE(stats_proxy_->GetStats().cpu_limited_resolution);
2102 EXPECT_EQ(1, stats_proxy_->GetStats().number_of_cpu_adapt_changes);
2103
mflodmancc3d4422017-08-03 08:27:51 -07002104 video_stream_encoder_->Stop();
asapersson02465b82017-04-10 01:12:52 -07002105}
2106
mflodmancc3d4422017-08-03 08:27:51 -07002107TEST_F(VideoStreamEncoderTest, SkipsSameOrLargerAdaptDownRequest_BalancedMode) {
asaperssonf7e294d2017-06-13 23:25:22 -07002108 const int kWidth = 1280;
2109 const int kHeight = 720;
Erik Språng4c6ca302019-04-08 15:14:01 +02002110 video_stream_encoder_->OnBitrateUpdated(
2111 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
asaperssonf7e294d2017-06-13 23:25:22 -07002112
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07002113 // Enable BALANCED preference, no initial limitation.
asaperssonf7e294d2017-06-13 23:25:22 -07002114 test::FrameForwarder source;
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07002115 video_stream_encoder_->SetSource(&source,
2116 webrtc::DegradationPreference::BALANCED);
asaperssonf7e294d2017-06-13 23:25:22 -07002117 source.IncomingCapturedFrame(CreateFrame(1, kWidth, kHeight));
2118 sink_.WaitForEncodedFrame(1);
Åsa Persson8c1bf952018-09-13 10:42:19 +02002119 VerifyFpsMaxResolutionMax(source.sink_wants());
asaperssonf7e294d2017-06-13 23:25:22 -07002120
2121 // Trigger adapt down, expect scaled down resolution.
mflodmancc3d4422017-08-03 08:27:51 -07002122 video_stream_encoder_->TriggerQualityLow();
asaperssonf7e294d2017-06-13 23:25:22 -07002123 VerifyFpsMaxResolutionLt(source.sink_wants(), kWidth * kHeight);
2124 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution);
2125 EXPECT_EQ(1, stats_proxy_->GetStats().number_of_quality_adapt_changes);
2126 const int kLastMaxPixelCount = source.sink_wants().max_pixel_count;
2127
2128 // Trigger adapt down for same input resolution, expect no change.
2129 source.IncomingCapturedFrame(CreateFrame(2, kWidth, kHeight));
2130 sink_.WaitForEncodedFrame(2);
mflodmancc3d4422017-08-03 08:27:51 -07002131 video_stream_encoder_->TriggerQualityLow();
asaperssonf7e294d2017-06-13 23:25:22 -07002132 EXPECT_EQ(kLastMaxPixelCount, source.sink_wants().max_pixel_count);
2133 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution);
2134 EXPECT_EQ(1, stats_proxy_->GetStats().number_of_quality_adapt_changes);
2135
2136 // Trigger adapt down for larger input resolution, expect no change.
2137 source.IncomingCapturedFrame(CreateFrame(3, kWidth + 1, kHeight + 1));
2138 sink_.WaitForEncodedFrame(3);
mflodmancc3d4422017-08-03 08:27:51 -07002139 video_stream_encoder_->TriggerQualityLow();
asaperssonf7e294d2017-06-13 23:25:22 -07002140 EXPECT_EQ(kLastMaxPixelCount, source.sink_wants().max_pixel_count);
2141 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution);
2142 EXPECT_EQ(1, stats_proxy_->GetStats().number_of_quality_adapt_changes);
2143
mflodmancc3d4422017-08-03 08:27:51 -07002144 video_stream_encoder_->Stop();
asaperssonf7e294d2017-06-13 23:25:22 -07002145}
2146
mflodmancc3d4422017-08-03 08:27:51 -07002147TEST_F(VideoStreamEncoderTest,
2148 NoChangeForInitialNormalUsage_MaintainFramerateMode) {
asapersson02465b82017-04-10 01:12:52 -07002149 const int kWidth = 1280;
2150 const int kHeight = 720;
Erik Språng4c6ca302019-04-08 15:14:01 +02002151 video_stream_encoder_->OnBitrateUpdated(
2152 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
asapersson02465b82017-04-10 01:12:52 -07002153
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07002154 // Enable MAINTAIN_FRAMERATE preference, no initial limitation.
asapersson02465b82017-04-10 01:12:52 -07002155 test::FrameForwarder source;
mflodmancc3d4422017-08-03 08:27:51 -07002156 video_stream_encoder_->SetSource(
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07002157 &source, webrtc::DegradationPreference::MAINTAIN_FRAMERATE);
asapersson02465b82017-04-10 01:12:52 -07002158
2159 source.IncomingCapturedFrame(CreateFrame(1, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07002160 WaitForEncodedFrame(kWidth, kHeight);
Åsa Persson8c1bf952018-09-13 10:42:19 +02002161 VerifyFpsMaxResolutionMax(source.sink_wants());
asapersson02465b82017-04-10 01:12:52 -07002162 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_resolution);
2163 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_cpu_adapt_changes);
2164
2165 // Trigger adapt up, expect no change.
mflodmancc3d4422017-08-03 08:27:51 -07002166 video_stream_encoder_->TriggerCpuNormalUsage();
Åsa Persson8c1bf952018-09-13 10:42:19 +02002167 VerifyFpsMaxResolutionMax(source.sink_wants());
asapersson02465b82017-04-10 01:12:52 -07002168 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_resolution);
2169 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_cpu_adapt_changes);
2170
mflodmancc3d4422017-08-03 08:27:51 -07002171 video_stream_encoder_->Stop();
asapersson02465b82017-04-10 01:12:52 -07002172}
2173
mflodmancc3d4422017-08-03 08:27:51 -07002174TEST_F(VideoStreamEncoderTest,
2175 NoChangeForInitialNormalUsage_MaintainResolutionMode) {
asapersson02465b82017-04-10 01:12:52 -07002176 const int kWidth = 1280;
2177 const int kHeight = 720;
Erik Språng4c6ca302019-04-08 15:14:01 +02002178 video_stream_encoder_->OnBitrateUpdated(
2179 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
asapersson02465b82017-04-10 01:12:52 -07002180
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07002181 // Enable MAINTAIN_RESOLUTION preference, no initial limitation.
asapersson02465b82017-04-10 01:12:52 -07002182 test::FrameForwarder source;
mflodmancc3d4422017-08-03 08:27:51 -07002183 video_stream_encoder_->SetSource(
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07002184 &source, webrtc::DegradationPreference::MAINTAIN_RESOLUTION);
asapersson02465b82017-04-10 01:12:52 -07002185
2186 source.IncomingCapturedFrame(CreateFrame(1, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07002187 WaitForEncodedFrame(kWidth, kHeight);
Åsa Persson8c1bf952018-09-13 10:42:19 +02002188 VerifyFpsMaxResolutionMax(source.sink_wants());
asapersson09f05612017-05-15 23:40:18 -07002189 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_framerate);
asapersson02465b82017-04-10 01:12:52 -07002190 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_cpu_adapt_changes);
2191
2192 // Trigger adapt up, expect no change.
mflodmancc3d4422017-08-03 08:27:51 -07002193 video_stream_encoder_->TriggerCpuNormalUsage();
Åsa Persson8c1bf952018-09-13 10:42:19 +02002194 VerifyFpsMaxResolutionMax(source.sink_wants());
asapersson09f05612017-05-15 23:40:18 -07002195 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_framerate);
asapersson02465b82017-04-10 01:12:52 -07002196 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_cpu_adapt_changes);
2197
mflodmancc3d4422017-08-03 08:27:51 -07002198 video_stream_encoder_->Stop();
asapersson02465b82017-04-10 01:12:52 -07002199}
2200
mflodmancc3d4422017-08-03 08:27:51 -07002201TEST_F(VideoStreamEncoderTest, NoChangeForInitialNormalUsage_BalancedMode) {
asaperssonf7e294d2017-06-13 23:25:22 -07002202 const int kWidth = 1280;
2203 const int kHeight = 720;
Erik Språng4c6ca302019-04-08 15:14:01 +02002204 video_stream_encoder_->OnBitrateUpdated(
2205 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
asaperssonf7e294d2017-06-13 23:25:22 -07002206
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07002207 // Enable BALANCED preference, no initial limitation.
asaperssonf7e294d2017-06-13 23:25:22 -07002208 test::FrameForwarder source;
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07002209 video_stream_encoder_->SetSource(&source,
2210 webrtc::DegradationPreference::BALANCED);
asaperssonf7e294d2017-06-13 23:25:22 -07002211
2212 source.IncomingCapturedFrame(CreateFrame(1, kWidth, kHeight));
2213 sink_.WaitForEncodedFrame(kWidth, kHeight);
Åsa Persson8c1bf952018-09-13 10:42:19 +02002214 VerifyFpsMaxResolutionMax(source.sink_wants());
asaperssonf7e294d2017-06-13 23:25:22 -07002215 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution);
2216 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_framerate);
2217 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_quality_adapt_changes);
2218
2219 // Trigger adapt up, expect no change.
mflodmancc3d4422017-08-03 08:27:51 -07002220 video_stream_encoder_->TriggerQualityHigh();
Åsa Persson8c1bf952018-09-13 10:42:19 +02002221 VerifyFpsMaxResolutionMax(source.sink_wants());
asaperssonf7e294d2017-06-13 23:25:22 -07002222 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution);
2223 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_framerate);
2224 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_quality_adapt_changes);
2225
mflodmancc3d4422017-08-03 08:27:51 -07002226 video_stream_encoder_->Stop();
asaperssonf7e294d2017-06-13 23:25:22 -07002227}
2228
mflodmancc3d4422017-08-03 08:27:51 -07002229TEST_F(VideoStreamEncoderTest, NoChangeForInitialNormalUsage_DisabledMode) {
asapersson09f05612017-05-15 23:40:18 -07002230 const int kWidth = 1280;
2231 const int kHeight = 720;
Erik Språng4c6ca302019-04-08 15:14:01 +02002232 video_stream_encoder_->OnBitrateUpdated(
2233 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
asapersson09f05612017-05-15 23:40:18 -07002234
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07002235 // Enable DISABLED preference, no initial limitation.
asapersson09f05612017-05-15 23:40:18 -07002236 test::FrameForwarder source;
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07002237 video_stream_encoder_->SetSource(&source,
2238 webrtc::DegradationPreference::DISABLED);
asapersson09f05612017-05-15 23:40:18 -07002239
2240 source.IncomingCapturedFrame(CreateFrame(1, kWidth, kHeight));
2241 sink_.WaitForEncodedFrame(kWidth, kHeight);
Åsa Persson8c1bf952018-09-13 10:42:19 +02002242 VerifyFpsMaxResolutionMax(source.sink_wants());
asapersson09f05612017-05-15 23:40:18 -07002243 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution);
2244 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_framerate);
2245 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_quality_adapt_changes);
2246
2247 // Trigger adapt up, expect no change.
mflodmancc3d4422017-08-03 08:27:51 -07002248 video_stream_encoder_->TriggerQualityHigh();
Åsa Persson8c1bf952018-09-13 10:42:19 +02002249 VerifyFpsMaxResolutionMax(source.sink_wants());
asapersson09f05612017-05-15 23:40:18 -07002250 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution);
2251 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_framerate);
2252 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_quality_adapt_changes);
2253
mflodmancc3d4422017-08-03 08:27:51 -07002254 video_stream_encoder_->Stop();
asapersson09f05612017-05-15 23:40:18 -07002255}
2256
mflodmancc3d4422017-08-03 08:27:51 -07002257TEST_F(VideoStreamEncoderTest,
2258 AdaptsResolutionForLowQuality_MaintainFramerateMode) {
asapersson02465b82017-04-10 01:12:52 -07002259 const int kWidth = 1280;
2260 const int kHeight = 720;
Erik Språng4c6ca302019-04-08 15:14:01 +02002261 video_stream_encoder_->OnBitrateUpdated(
2262 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
asapersson02465b82017-04-10 01:12:52 -07002263
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07002264 // Enable MAINTAIN_FRAMERATE preference, no initial limitation.
asapersson02465b82017-04-10 01:12:52 -07002265 AdaptingFrameForwarder source;
2266 source.set_adaptation_enabled(true);
mflodmancc3d4422017-08-03 08:27:51 -07002267 video_stream_encoder_->SetSource(
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07002268 &source, webrtc::DegradationPreference::MAINTAIN_FRAMERATE);
asapersson02465b82017-04-10 01:12:52 -07002269
2270 source.IncomingCapturedFrame(CreateFrame(1, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07002271 WaitForEncodedFrame(1);
Åsa Persson8c1bf952018-09-13 10:42:19 +02002272 VerifyFpsMaxResolutionMax(source.sink_wants());
asapersson02465b82017-04-10 01:12:52 -07002273 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution);
2274 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_quality_adapt_changes);
2275
2276 // Trigger adapt down, expect scaled down resolution.
mflodmancc3d4422017-08-03 08:27:51 -07002277 video_stream_encoder_->TriggerQualityLow();
asapersson02465b82017-04-10 01:12:52 -07002278 source.IncomingCapturedFrame(CreateFrame(2, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07002279 WaitForEncodedFrame(2);
asapersson09f05612017-05-15 23:40:18 -07002280 VerifyFpsMaxResolutionLt(source.sink_wants(), kWidth * kHeight);
asapersson02465b82017-04-10 01:12:52 -07002281 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution);
2282 EXPECT_EQ(1, stats_proxy_->GetStats().number_of_quality_adapt_changes);
2283
2284 // Trigger adapt up, expect no restriction.
mflodmancc3d4422017-08-03 08:27:51 -07002285 video_stream_encoder_->TriggerQualityHigh();
Åsa Persson8c1bf952018-09-13 10:42:19 +02002286 VerifyFpsMaxResolutionMax(source.sink_wants());
asapersson02465b82017-04-10 01:12:52 -07002287 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution);
2288 EXPECT_EQ(2, stats_proxy_->GetStats().number_of_quality_adapt_changes);
2289 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_cpu_adapt_changes);
2290
mflodmancc3d4422017-08-03 08:27:51 -07002291 video_stream_encoder_->Stop();
asapersson02465b82017-04-10 01:12:52 -07002292}
2293
mflodmancc3d4422017-08-03 08:27:51 -07002294TEST_F(VideoStreamEncoderTest,
2295 AdaptsFramerateForLowQuality_MaintainResolutionMode) {
asapersson09f05612017-05-15 23:40:18 -07002296 const int kWidth = 1280;
2297 const int kHeight = 720;
2298 const int kInputFps = 30;
Erik Språng4c6ca302019-04-08 15:14:01 +02002299 video_stream_encoder_->OnBitrateUpdated(
2300 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
asapersson09f05612017-05-15 23:40:18 -07002301
2302 VideoSendStream::Stats stats = stats_proxy_->GetStats();
2303 stats.input_frame_rate = kInputFps;
2304 stats_proxy_->SetMockStats(stats);
2305
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07002306 // Expect no scaling to begin with (preference: MAINTAIN_FRAMERATE).
asapersson09f05612017-05-15 23:40:18 -07002307 video_source_.IncomingCapturedFrame(CreateFrame(1, kWidth, kHeight));
2308 sink_.WaitForEncodedFrame(1);
Åsa Persson8c1bf952018-09-13 10:42:19 +02002309 VerifyFpsMaxResolutionMax(video_source_.sink_wants());
asapersson09f05612017-05-15 23:40:18 -07002310
2311 // Trigger adapt down, expect scaled down resolution.
mflodmancc3d4422017-08-03 08:27:51 -07002312 video_stream_encoder_->TriggerQualityLow();
asapersson09f05612017-05-15 23:40:18 -07002313 video_source_.IncomingCapturedFrame(CreateFrame(2, kWidth, kHeight));
2314 sink_.WaitForEncodedFrame(2);
2315 VerifyFpsMaxResolutionLt(video_source_.sink_wants(), kWidth * kHeight);
2316
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07002317 // Enable MAINTAIN_RESOLUTION preference.
asapersson09f05612017-05-15 23:40:18 -07002318 test::FrameForwarder new_video_source;
mflodmancc3d4422017-08-03 08:27:51 -07002319 video_stream_encoder_->SetSource(
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07002320 &new_video_source, webrtc::DegradationPreference::MAINTAIN_RESOLUTION);
Åsa Persson8c1bf952018-09-13 10:42:19 +02002321 VerifyFpsMaxResolutionMax(new_video_source.sink_wants());
asapersson09f05612017-05-15 23:40:18 -07002322
2323 // Trigger adapt down, expect reduced framerate.
mflodmancc3d4422017-08-03 08:27:51 -07002324 video_stream_encoder_->TriggerQualityLow();
asapersson09f05612017-05-15 23:40:18 -07002325 new_video_source.IncomingCapturedFrame(CreateFrame(3, kWidth, kHeight));
2326 sink_.WaitForEncodedFrame(3);
2327 VerifyFpsLtResolutionMax(new_video_source.sink_wants(), kInputFps);
2328
2329 // Trigger adapt up, expect no restriction.
mflodmancc3d4422017-08-03 08:27:51 -07002330 video_stream_encoder_->TriggerQualityHigh();
Åsa Persson8c1bf952018-09-13 10:42:19 +02002331 VerifyFpsMaxResolutionMax(new_video_source.sink_wants());
asapersson09f05612017-05-15 23:40:18 -07002332
mflodmancc3d4422017-08-03 08:27:51 -07002333 video_stream_encoder_->Stop();
asapersson09f05612017-05-15 23:40:18 -07002334}
2335
mflodmancc3d4422017-08-03 08:27:51 -07002336TEST_F(VideoStreamEncoderTest, DoesNotScaleBelowSetResolutionLimit) {
asaperssond0de2952017-04-21 01:47:31 -07002337 const int kWidth = 1280;
2338 const int kHeight = 720;
2339 const size_t kNumFrames = 10;
2340
Erik Språng4c6ca302019-04-08 15:14:01 +02002341 video_stream_encoder_->OnBitrateUpdated(
2342 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
kthelgason5e13d412016-12-01 03:59:51 -08002343
asaperssond0de2952017-04-21 01:47:31 -07002344 // Enable adapter, expected input resolutions when downscaling:
asapersson142fcc92017-08-17 08:58:54 -07002345 // 1280x720 -> 960x540 -> 640x360 -> 480x270 -> 320x180 (kMinPixelsPerFrame)
asaperssond0de2952017-04-21 01:47:31 -07002346 video_source_.set_adaptation_enabled(true);
2347
2348 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution);
2349 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_quality_adapt_changes);
2350
2351 int downscales = 0;
2352 for (size_t i = 1; i <= kNumFrames; i++) {
Åsa Persson8c1bf952018-09-13 10:42:19 +02002353 video_source_.IncomingCapturedFrame(
2354 CreateFrame(i * kFrameIntervalMs, kWidth, kHeight));
2355 WaitForEncodedFrame(i * kFrameIntervalMs);
asaperssond0de2952017-04-21 01:47:31 -07002356
asaperssonfab67072017-04-04 05:51:49 -07002357 // Trigger scale down.
asaperssond0de2952017-04-21 01:47:31 -07002358 rtc::VideoSinkWants last_wants = video_source_.sink_wants();
mflodmancc3d4422017-08-03 08:27:51 -07002359 video_stream_encoder_->TriggerQualityLow();
sprangc5d62e22017-04-02 23:53:04 -07002360 EXPECT_GE(video_source_.sink_wants().max_pixel_count, kMinPixelsPerFrame);
asaperssond0de2952017-04-21 01:47:31 -07002361
2362 if (video_source_.sink_wants().max_pixel_count < last_wants.max_pixel_count)
2363 ++downscales;
2364
2365 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution);
2366 EXPECT_EQ(downscales,
2367 stats_proxy_->GetStats().number_of_quality_adapt_changes);
2368 EXPECT_GT(downscales, 0);
kthelgason5e13d412016-12-01 03:59:51 -08002369 }
mflodmancc3d4422017-08-03 08:27:51 -07002370 video_stream_encoder_->Stop();
asaperssond0de2952017-04-21 01:47:31 -07002371}
2372
mflodmancc3d4422017-08-03 08:27:51 -07002373TEST_F(VideoStreamEncoderTest,
asaperssond0de2952017-04-21 01:47:31 -07002374 AdaptsResolutionUpAndDownTwiceOnOveruse_MaintainFramerateMode) {
2375 const int kWidth = 1280;
2376 const int kHeight = 720;
Erik Språng4c6ca302019-04-08 15:14:01 +02002377 video_stream_encoder_->OnBitrateUpdated(
2378 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
asaperssond0de2952017-04-21 01:47:31 -07002379
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07002380 // Enable MAINTAIN_FRAMERATE preference, no initial limitation.
asaperssond0de2952017-04-21 01:47:31 -07002381 AdaptingFrameForwarder source;
2382 source.set_adaptation_enabled(true);
mflodmancc3d4422017-08-03 08:27:51 -07002383 video_stream_encoder_->SetSource(
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07002384 &source, webrtc::DegradationPreference::MAINTAIN_FRAMERATE);
asaperssond0de2952017-04-21 01:47:31 -07002385
Åsa Persson8c1bf952018-09-13 10:42:19 +02002386 int64_t timestamp_ms = kFrameIntervalMs;
2387 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07002388 WaitForEncodedFrame(kWidth, kHeight);
Åsa Persson8c1bf952018-09-13 10:42:19 +02002389 VerifyFpsMaxResolutionMax(source.sink_wants());
asaperssond0de2952017-04-21 01:47:31 -07002390 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_resolution);
2391 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_cpu_adapt_changes);
2392
2393 // Trigger adapt down, expect scaled down resolution.
mflodmancc3d4422017-08-03 08:27:51 -07002394 video_stream_encoder_->TriggerCpuOveruse();
Åsa Persson8c1bf952018-09-13 10:42:19 +02002395 timestamp_ms += kFrameIntervalMs;
2396 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight));
2397 WaitForEncodedFrame(timestamp_ms);
asapersson09f05612017-05-15 23:40:18 -07002398 VerifyFpsMaxResolutionLt(source.sink_wants(), kWidth * kHeight);
asaperssond0de2952017-04-21 01:47:31 -07002399 EXPECT_TRUE(stats_proxy_->GetStats().cpu_limited_resolution);
2400 EXPECT_EQ(1, stats_proxy_->GetStats().number_of_cpu_adapt_changes);
2401
2402 // Trigger adapt up, expect no restriction.
mflodmancc3d4422017-08-03 08:27:51 -07002403 video_stream_encoder_->TriggerCpuNormalUsage();
Åsa Persson8c1bf952018-09-13 10:42:19 +02002404 timestamp_ms += kFrameIntervalMs;
2405 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07002406 WaitForEncodedFrame(kWidth, kHeight);
Åsa Persson8c1bf952018-09-13 10:42:19 +02002407 VerifyFpsMaxResolutionMax(source.sink_wants());
asaperssond0de2952017-04-21 01:47:31 -07002408 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_resolution);
2409 EXPECT_EQ(2, stats_proxy_->GetStats().number_of_cpu_adapt_changes);
2410
2411 // Trigger adapt down, expect scaled down resolution.
mflodmancc3d4422017-08-03 08:27:51 -07002412 video_stream_encoder_->TriggerCpuOveruse();
Åsa Persson8c1bf952018-09-13 10:42:19 +02002413 timestamp_ms += kFrameIntervalMs;
2414 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight));
2415 WaitForEncodedFrame(timestamp_ms);
asapersson09f05612017-05-15 23:40:18 -07002416 VerifyFpsMaxResolutionLt(source.sink_wants(), kWidth * kHeight);
asaperssond0de2952017-04-21 01:47:31 -07002417 EXPECT_TRUE(stats_proxy_->GetStats().cpu_limited_resolution);
2418 EXPECT_EQ(3, stats_proxy_->GetStats().number_of_cpu_adapt_changes);
2419
2420 // Trigger adapt up, expect no restriction.
mflodmancc3d4422017-08-03 08:27:51 -07002421 video_stream_encoder_->TriggerCpuNormalUsage();
Åsa Persson8c1bf952018-09-13 10:42:19 +02002422 timestamp_ms += kFrameIntervalMs;
2423 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight));
asapersson09f05612017-05-15 23:40:18 -07002424 sink_.WaitForEncodedFrame(kWidth, kHeight);
Åsa Persson8c1bf952018-09-13 10:42:19 +02002425 VerifyFpsMaxResolutionMax(source.sink_wants());
asaperssond0de2952017-04-21 01:47:31 -07002426 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_resolution);
2427 EXPECT_EQ(4, stats_proxy_->GetStats().number_of_cpu_adapt_changes);
2428
mflodmancc3d4422017-08-03 08:27:51 -07002429 video_stream_encoder_->Stop();
asaperssond0de2952017-04-21 01:47:31 -07002430}
2431
mflodmancc3d4422017-08-03 08:27:51 -07002432TEST_F(VideoStreamEncoderTest,
asaperssonf7e294d2017-06-13 23:25:22 -07002433 AdaptsResolutionUpAndDownTwiceForLowQuality_BalancedMode_NoFpsLimit) {
2434 const int kWidth = 1280;
2435 const int kHeight = 720;
Erik Språng4c6ca302019-04-08 15:14:01 +02002436 video_stream_encoder_->OnBitrateUpdated(
2437 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
asaperssonf7e294d2017-06-13 23:25:22 -07002438
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07002439 // Enable BALANCED preference, no initial limitation.
asaperssonf7e294d2017-06-13 23:25:22 -07002440 AdaptingFrameForwarder source;
2441 source.set_adaptation_enabled(true);
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07002442 video_stream_encoder_->SetSource(&source,
2443 webrtc::DegradationPreference::BALANCED);
asaperssonf7e294d2017-06-13 23:25:22 -07002444
Åsa Persson8c1bf952018-09-13 10:42:19 +02002445 int64_t timestamp_ms = kFrameIntervalMs;
2446 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight));
asaperssonf7e294d2017-06-13 23:25:22 -07002447 sink_.WaitForEncodedFrame(kWidth, kHeight);
Åsa Persson8c1bf952018-09-13 10:42:19 +02002448 VerifyFpsMaxResolutionMax(source.sink_wants());
asaperssonf7e294d2017-06-13 23:25:22 -07002449 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution);
2450 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_quality_adapt_changes);
2451
2452 // Trigger adapt down, expect scaled down resolution.
mflodmancc3d4422017-08-03 08:27:51 -07002453 video_stream_encoder_->TriggerQualityLow();
Åsa Persson8c1bf952018-09-13 10:42:19 +02002454 timestamp_ms += kFrameIntervalMs;
2455 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight));
2456 sink_.WaitForEncodedFrame(timestamp_ms);
asaperssonf7e294d2017-06-13 23:25:22 -07002457 VerifyFpsMaxResolutionLt(source.sink_wants(), kWidth * kHeight);
2458 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution);
2459 EXPECT_EQ(1, stats_proxy_->GetStats().number_of_quality_adapt_changes);
2460
2461 // Trigger adapt up, expect no restriction.
mflodmancc3d4422017-08-03 08:27:51 -07002462 video_stream_encoder_->TriggerQualityHigh();
Åsa Persson8c1bf952018-09-13 10:42:19 +02002463 timestamp_ms += kFrameIntervalMs;
2464 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight));
asaperssonf7e294d2017-06-13 23:25:22 -07002465 sink_.WaitForEncodedFrame(kWidth, kHeight);
Åsa Persson8c1bf952018-09-13 10:42:19 +02002466 VerifyFpsMaxResolutionMax(source.sink_wants());
asaperssonf7e294d2017-06-13 23:25:22 -07002467 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution);
2468 EXPECT_EQ(2, stats_proxy_->GetStats().number_of_quality_adapt_changes);
2469
2470 // Trigger adapt down, expect scaled down resolution.
mflodmancc3d4422017-08-03 08:27:51 -07002471 video_stream_encoder_->TriggerQualityLow();
Åsa Persson8c1bf952018-09-13 10:42:19 +02002472 timestamp_ms += kFrameIntervalMs;
2473 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight));
2474 sink_.WaitForEncodedFrame(timestamp_ms);
asaperssonf7e294d2017-06-13 23:25:22 -07002475 VerifyFpsMaxResolutionLt(source.sink_wants(), kWidth * kHeight);
2476 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution);
2477 EXPECT_EQ(3, stats_proxy_->GetStats().number_of_quality_adapt_changes);
2478
2479 // Trigger adapt up, expect no restriction.
mflodmancc3d4422017-08-03 08:27:51 -07002480 video_stream_encoder_->TriggerQualityHigh();
Åsa Persson8c1bf952018-09-13 10:42:19 +02002481 timestamp_ms += kFrameIntervalMs;
2482 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight));
asaperssonf7e294d2017-06-13 23:25:22 -07002483 sink_.WaitForEncodedFrame(kWidth, kHeight);
Åsa Persson8c1bf952018-09-13 10:42:19 +02002484 VerifyFpsMaxResolutionMax(source.sink_wants());
asaperssonf7e294d2017-06-13 23:25:22 -07002485 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution);
2486 EXPECT_EQ(4, stats_proxy_->GetStats().number_of_quality_adapt_changes);
2487
mflodmancc3d4422017-08-03 08:27:51 -07002488 video_stream_encoder_->Stop();
asaperssonf7e294d2017-06-13 23:25:22 -07002489}
2490
mflodmancc3d4422017-08-03 08:27:51 -07002491TEST_F(VideoStreamEncoderTest,
asaperssond0de2952017-04-21 01:47:31 -07002492 AdaptsResolutionOnOveruseAndLowQuality_MaintainFramerateMode) {
2493 const int kWidth = 1280;
2494 const int kHeight = 720;
Erik Språng4c6ca302019-04-08 15:14:01 +02002495 video_stream_encoder_->OnBitrateUpdated(
2496 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
asaperssond0de2952017-04-21 01:47:31 -07002497
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07002498 // Enable MAINTAIN_FRAMERATE preference, no initial limitation.
asaperssond0de2952017-04-21 01:47:31 -07002499 AdaptingFrameForwarder source;
2500 source.set_adaptation_enabled(true);
mflodmancc3d4422017-08-03 08:27:51 -07002501 video_stream_encoder_->SetSource(
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07002502 &source, webrtc::DegradationPreference::MAINTAIN_FRAMERATE);
asaperssond0de2952017-04-21 01:47:31 -07002503
Åsa Persson8c1bf952018-09-13 10:42:19 +02002504 int64_t timestamp_ms = kFrameIntervalMs;
2505 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07002506 WaitForEncodedFrame(kWidth, kHeight);
Åsa Persson8c1bf952018-09-13 10:42:19 +02002507 VerifyFpsMaxResolutionMax(source.sink_wants());
asaperssond0de2952017-04-21 01:47:31 -07002508 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_resolution);
2509 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution);
2510 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_cpu_adapt_changes);
2511 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_quality_adapt_changes);
2512
2513 // Trigger cpu adapt down, expect scaled down resolution (960x540).
mflodmancc3d4422017-08-03 08:27:51 -07002514 video_stream_encoder_->TriggerCpuOveruse();
Åsa Persson8c1bf952018-09-13 10:42:19 +02002515 timestamp_ms += kFrameIntervalMs;
2516 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight));
2517 WaitForEncodedFrame(timestamp_ms);
asapersson09f05612017-05-15 23:40:18 -07002518 VerifyFpsMaxResolutionLt(source.sink_wants(), kWidth * kHeight);
asaperssond0de2952017-04-21 01:47:31 -07002519 EXPECT_TRUE(stats_proxy_->GetStats().cpu_limited_resolution);
2520 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution);
2521 EXPECT_EQ(1, stats_proxy_->GetStats().number_of_cpu_adapt_changes);
2522 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_quality_adapt_changes);
2523
2524 // Trigger cpu adapt down, expect scaled down resolution (640x360).
mflodmancc3d4422017-08-03 08:27:51 -07002525 video_stream_encoder_->TriggerCpuOveruse();
Åsa Persson8c1bf952018-09-13 10:42:19 +02002526 timestamp_ms += kFrameIntervalMs;
2527 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight));
2528 WaitForEncodedFrame(timestamp_ms);
asapersson09f05612017-05-15 23:40:18 -07002529 VerifyFpsMaxResolutionLt(source.sink_wants(), source.last_wants());
asaperssond0de2952017-04-21 01:47:31 -07002530 EXPECT_TRUE(stats_proxy_->GetStats().cpu_limited_resolution);
2531 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution);
2532 EXPECT_EQ(2, stats_proxy_->GetStats().number_of_cpu_adapt_changes);
2533 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_quality_adapt_changes);
2534
Jonathan Yubc771b72017-12-08 17:04:29 -08002535 // Trigger cpu adapt down, expect scaled down resolution (480x270).
mflodmancc3d4422017-08-03 08:27:51 -07002536 video_stream_encoder_->TriggerCpuOveruse();
Åsa Persson8c1bf952018-09-13 10:42:19 +02002537 timestamp_ms += kFrameIntervalMs;
2538 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight));
2539 WaitForEncodedFrame(timestamp_ms);
Jonathan Yubc771b72017-12-08 17:04:29 -08002540 VerifyFpsMaxResolutionLt(source.sink_wants(), source.last_wants());
asaperssond0de2952017-04-21 01:47:31 -07002541 EXPECT_TRUE(stats_proxy_->GetStats().cpu_limited_resolution);
2542 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution);
Jonathan Yubc771b72017-12-08 17:04:29 -08002543 EXPECT_EQ(3, stats_proxy_->GetStats().number_of_cpu_adapt_changes);
asaperssond0de2952017-04-21 01:47:31 -07002544 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_quality_adapt_changes);
2545
Jonathan Yubc771b72017-12-08 17:04:29 -08002546 // Trigger quality adapt down, expect scaled down resolution (320x180).
mflodmancc3d4422017-08-03 08:27:51 -07002547 video_stream_encoder_->TriggerQualityLow();
Åsa Persson8c1bf952018-09-13 10:42:19 +02002548 timestamp_ms += kFrameIntervalMs;
2549 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight));
2550 WaitForEncodedFrame(timestamp_ms);
asapersson09f05612017-05-15 23:40:18 -07002551 VerifyFpsMaxResolutionLt(source.sink_wants(), source.last_wants());
Jonathan Yubc771b72017-12-08 17:04:29 -08002552 rtc::VideoSinkWants last_wants = source.sink_wants();
asaperssond0de2952017-04-21 01:47:31 -07002553 EXPECT_TRUE(stats_proxy_->GetStats().cpu_limited_resolution);
2554 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution);
2555 EXPECT_EQ(3, stats_proxy_->GetStats().number_of_cpu_adapt_changes);
2556 EXPECT_EQ(1, stats_proxy_->GetStats().number_of_quality_adapt_changes);
2557
Jonathan Yubc771b72017-12-08 17:04:29 -08002558 // Trigger quality adapt down, expect no change (min resolution reached).
2559 video_stream_encoder_->TriggerQualityLow();
Åsa Persson8c1bf952018-09-13 10:42:19 +02002560 timestamp_ms += kFrameIntervalMs;
2561 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight));
2562 WaitForEncodedFrame(timestamp_ms);
Jonathan Yubc771b72017-12-08 17:04:29 -08002563 VerifyFpsMaxResolutionEq(source.sink_wants(), last_wants);
2564 EXPECT_TRUE(stats_proxy_->GetStats().cpu_limited_resolution);
2565 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution);
2566 EXPECT_EQ(3, stats_proxy_->GetStats().number_of_cpu_adapt_changes);
2567 EXPECT_EQ(1, stats_proxy_->GetStats().number_of_quality_adapt_changes);
2568
2569 // Trigger cpu adapt up, expect upscaled resolution (480x270).
mflodmancc3d4422017-08-03 08:27:51 -07002570 video_stream_encoder_->TriggerCpuNormalUsage();
Åsa Persson8c1bf952018-09-13 10:42:19 +02002571 timestamp_ms += kFrameIntervalMs;
2572 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight));
2573 WaitForEncodedFrame(timestamp_ms);
asapersson09f05612017-05-15 23:40:18 -07002574 VerifyFpsMaxResolutionGt(source.sink_wants(), source.last_wants());
Jonathan Yubc771b72017-12-08 17:04:29 -08002575 EXPECT_TRUE(stats_proxy_->GetStats().cpu_limited_resolution);
2576 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution);
2577 EXPECT_EQ(4, stats_proxy_->GetStats().number_of_cpu_adapt_changes);
2578 EXPECT_EQ(1, stats_proxy_->GetStats().number_of_quality_adapt_changes);
2579
2580 // Trigger cpu adapt up, expect upscaled resolution (640x360).
2581 video_stream_encoder_->TriggerCpuNormalUsage();
Åsa Persson8c1bf952018-09-13 10:42:19 +02002582 timestamp_ms += kFrameIntervalMs;
2583 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight));
2584 WaitForEncodedFrame(timestamp_ms);
Jonathan Yubc771b72017-12-08 17:04:29 -08002585 VerifyFpsMaxResolutionGt(source.sink_wants(), source.last_wants());
2586 EXPECT_TRUE(stats_proxy_->GetStats().cpu_limited_resolution);
2587 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution);
2588 EXPECT_EQ(5, stats_proxy_->GetStats().number_of_cpu_adapt_changes);
2589 EXPECT_EQ(1, stats_proxy_->GetStats().number_of_quality_adapt_changes);
2590
2591 // Trigger cpu adapt up, expect upscaled resolution (960x540).
2592 video_stream_encoder_->TriggerCpuNormalUsage();
Åsa Persson8c1bf952018-09-13 10:42:19 +02002593 timestamp_ms += kFrameIntervalMs;
2594 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight));
2595 WaitForEncodedFrame(timestamp_ms);
Jonathan Yubc771b72017-12-08 17:04:29 -08002596 VerifyFpsMaxResolutionGt(source.sink_wants(), source.last_wants());
asaperssond0de2952017-04-21 01:47:31 -07002597 last_wants = source.sink_wants();
2598 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_resolution);
2599 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution);
Jonathan Yubc771b72017-12-08 17:04:29 -08002600 EXPECT_EQ(6, stats_proxy_->GetStats().number_of_cpu_adapt_changes);
asaperssond0de2952017-04-21 01:47:31 -07002601 EXPECT_EQ(1, stats_proxy_->GetStats().number_of_quality_adapt_changes);
2602
2603 // Trigger cpu adapt up, no cpu downgrades, expect no change (960x540).
mflodmancc3d4422017-08-03 08:27:51 -07002604 video_stream_encoder_->TriggerCpuNormalUsage();
Åsa Persson8c1bf952018-09-13 10:42:19 +02002605 timestamp_ms += kFrameIntervalMs;
2606 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight));
2607 WaitForEncodedFrame(timestamp_ms);
asapersson09f05612017-05-15 23:40:18 -07002608 VerifyFpsEqResolutionEq(source.sink_wants(), last_wants);
asaperssond0de2952017-04-21 01:47:31 -07002609 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_resolution);
2610 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution);
Jonathan Yubc771b72017-12-08 17:04:29 -08002611 EXPECT_EQ(6, stats_proxy_->GetStats().number_of_cpu_adapt_changes);
asaperssond0de2952017-04-21 01:47:31 -07002612 EXPECT_EQ(1, stats_proxy_->GetStats().number_of_quality_adapt_changes);
2613
2614 // Trigger quality adapt up, expect no restriction (1280x720).
mflodmancc3d4422017-08-03 08:27:51 -07002615 video_stream_encoder_->TriggerQualityHigh();
Åsa Persson8c1bf952018-09-13 10:42:19 +02002616 timestamp_ms += kFrameIntervalMs;
2617 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07002618 WaitForEncodedFrame(kWidth, kHeight);
asapersson09f05612017-05-15 23:40:18 -07002619 VerifyFpsMaxResolutionGt(source.sink_wants(), source.last_wants());
Åsa Persson8c1bf952018-09-13 10:42:19 +02002620 VerifyFpsMaxResolutionMax(source.sink_wants());
asaperssond0de2952017-04-21 01:47:31 -07002621 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_resolution);
2622 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution);
Jonathan Yubc771b72017-12-08 17:04:29 -08002623 EXPECT_EQ(6, stats_proxy_->GetStats().number_of_cpu_adapt_changes);
asaperssond0de2952017-04-21 01:47:31 -07002624 EXPECT_EQ(2, stats_proxy_->GetStats().number_of_quality_adapt_changes);
kthelgason5e13d412016-12-01 03:59:51 -08002625
mflodmancc3d4422017-08-03 08:27:51 -07002626 video_stream_encoder_->Stop();
kthelgason5e13d412016-12-01 03:59:51 -08002627}
2628
mflodmancc3d4422017-08-03 08:27:51 -07002629TEST_F(VideoStreamEncoderTest, CpuLimitedHistogramIsReported) {
asaperssonfab67072017-04-04 05:51:49 -07002630 const int kWidth = 640;
2631 const int kHeight = 360;
perkj803d97f2016-11-01 11:45:46 -07002632
Erik Språng4c6ca302019-04-08 15:14:01 +02002633 video_stream_encoder_->OnBitrateUpdated(
2634 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
sprang4847ae62017-06-27 07:06:52 -07002635
perkj803d97f2016-11-01 11:45:46 -07002636 for (int i = 1; i <= SendStatisticsProxy::kMinRequiredMetricsSamples; ++i) {
asaperssonfab67072017-04-04 05:51:49 -07002637 video_source_.IncomingCapturedFrame(CreateFrame(i, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07002638 WaitForEncodedFrame(i);
perkj803d97f2016-11-01 11:45:46 -07002639 }
2640
mflodmancc3d4422017-08-03 08:27:51 -07002641 video_stream_encoder_->TriggerCpuOveruse();
perkj803d97f2016-11-01 11:45:46 -07002642 for (int i = 1; i <= SendStatisticsProxy::kMinRequiredMetricsSamples; ++i) {
asaperssonfab67072017-04-04 05:51:49 -07002643 video_source_.IncomingCapturedFrame(CreateFrame(
2644 SendStatisticsProxy::kMinRequiredMetricsSamples + i, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07002645 WaitForEncodedFrame(SendStatisticsProxy::kMinRequiredMetricsSamples + i);
perkj803d97f2016-11-01 11:45:46 -07002646 }
2647
mflodmancc3d4422017-08-03 08:27:51 -07002648 video_stream_encoder_->Stop();
2649 video_stream_encoder_.reset();
perkj803d97f2016-11-01 11:45:46 -07002650 stats_proxy_.reset();
sprangf8ee65e2017-02-28 08:49:33 -08002651
perkj803d97f2016-11-01 11:45:46 -07002652 EXPECT_EQ(1,
2653 metrics::NumSamples("WebRTC.Video.CpuLimitedResolutionInPercent"));
2654 EXPECT_EQ(
2655 1, metrics::NumEvents("WebRTC.Video.CpuLimitedResolutionInPercent", 50));
2656}
2657
mflodmancc3d4422017-08-03 08:27:51 -07002658TEST_F(VideoStreamEncoderTest,
2659 CpuLimitedHistogramIsNotReportedForDisabledDegradation) {
Erik Språng4c6ca302019-04-08 15:14:01 +02002660 video_stream_encoder_->OnBitrateUpdated(
2661 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
asaperssonf4e44af2017-04-19 02:01:06 -07002662 const int kWidth = 640;
2663 const int kHeight = 360;
2664
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07002665 video_stream_encoder_->SetSource(&video_source_,
2666 webrtc::DegradationPreference::DISABLED);
asaperssonf4e44af2017-04-19 02:01:06 -07002667
2668 for (int i = 1; i <= SendStatisticsProxy::kMinRequiredMetricsSamples; ++i) {
2669 video_source_.IncomingCapturedFrame(CreateFrame(i, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07002670 WaitForEncodedFrame(i);
asaperssonf4e44af2017-04-19 02:01:06 -07002671 }
2672
mflodmancc3d4422017-08-03 08:27:51 -07002673 video_stream_encoder_->Stop();
2674 video_stream_encoder_.reset();
asaperssonf4e44af2017-04-19 02:01:06 -07002675 stats_proxy_.reset();
2676
2677 EXPECT_EQ(0,
2678 metrics::NumSamples("WebRTC.Video.CpuLimitedResolutionInPercent"));
2679}
2680
mflodmancc3d4422017-08-03 08:27:51 -07002681TEST_F(VideoStreamEncoderTest, CallsBitrateObserver) {
sprang4847ae62017-06-27 07:06:52 -07002682 MockBitrateObserver bitrate_observer;
Niels Möller0327c2d2018-05-21 14:09:31 +02002683 video_stream_encoder_->SetBitrateAllocationObserver(&bitrate_observer);
sprang57c2fff2017-01-16 06:24:02 -08002684
2685 const int kDefaultFps = 30;
Erik Språng566124a2018-04-23 12:32:22 +02002686 const VideoBitrateAllocation expected_bitrate =
sprang57c2fff2017-01-16 06:24:02 -08002687 DefaultVideoBitrateAllocator(fake_encoder_.codec_config())
kthelgason2bc68642017-02-07 07:02:22 -08002688 .GetAllocation(kLowTargetBitrateBps, kDefaultFps);
sprang57c2fff2017-01-16 06:24:02 -08002689
sprang57c2fff2017-01-16 06:24:02 -08002690 EXPECT_CALL(bitrate_observer, OnBitrateAllocationUpdated(expected_bitrate))
Niels Möller6bb5ab92019-01-11 11:11:10 +01002691 .Times(1);
Erik Språng610c7632019-03-06 15:37:33 +01002692 video_stream_encoder_->OnBitrateUpdated(DataRate::bps(kLowTargetBitrateBps),
Erik Språng4c6ca302019-04-08 15:14:01 +02002693 DataRate::bps(kLowTargetBitrateBps),
2694 0, 0);
sprang57c2fff2017-01-16 06:24:02 -08002695
sprang57c2fff2017-01-16 06:24:02 -08002696 video_source_.IncomingCapturedFrame(
Erik Språngd7329ca2019-02-21 21:19:53 +01002697 CreateFrame(rtc::TimeMillis(), codec_width_, codec_height_));
2698 WaitForEncodedFrame(rtc::TimeMillis());
2699 absl::optional<VideoBitrateAllocation> bitrate_allocation =
2700 fake_encoder_.GetAndResetLastBitrateAllocation();
2701 // Check that encoder has been updated too, not just allocation observer.
2702 EXPECT_EQ(bitrate_allocation->get_sum_bps(), kLowTargetBitrateBps);
Sebastian Jansson40889f32019-04-17 12:11:20 +02002703 // TODO(srte): The use of millisecs here looks like an error, but the tests
2704 // fails using seconds, this should be investigated.
2705 fake_clock_.AdvanceTime(TimeDelta::ms(1) / kDefaultFps);
sprang57c2fff2017-01-16 06:24:02 -08002706
2707 // Not called on second frame.
2708 EXPECT_CALL(bitrate_observer, OnBitrateAllocationUpdated(expected_bitrate))
2709 .Times(0);
2710 video_source_.IncomingCapturedFrame(
Erik Språngd7329ca2019-02-21 21:19:53 +01002711 CreateFrame(rtc::TimeMillis(), codec_width_, codec_height_));
2712 WaitForEncodedFrame(rtc::TimeMillis());
Sebastian Jansson40889f32019-04-17 12:11:20 +02002713 fake_clock_.AdvanceTime(TimeDelta::ms(1) / kDefaultFps);
sprang57c2fff2017-01-16 06:24:02 -08002714
2715 // Called after a process interval.
2716 const int64_t kProcessIntervalMs =
2717 vcm::VCMProcessTimer::kDefaultProcessIntervalMs;
sprang57c2fff2017-01-16 06:24:02 -08002718 EXPECT_CALL(bitrate_observer, OnBitrateAllocationUpdated(expected_bitrate))
2719 .Times(1);
Erik Språngd7329ca2019-02-21 21:19:53 +01002720 const int64_t start_time_ms = rtc::TimeMillis();
2721 while (rtc::TimeMillis() - start_time_ms < kProcessIntervalMs) {
2722 video_source_.IncomingCapturedFrame(
2723 CreateFrame(rtc::TimeMillis(), codec_width_, codec_height_));
2724 WaitForEncodedFrame(rtc::TimeMillis());
Sebastian Jansson40889f32019-04-17 12:11:20 +02002725 fake_clock_.AdvanceTime(TimeDelta::ms(1) / kDefaultFps);
Erik Språngd7329ca2019-02-21 21:19:53 +01002726 }
2727
2728 // Since rates are unchanged, encoder should not be reconfigured.
2729 EXPECT_FALSE(fake_encoder_.GetAndResetLastBitrateAllocation().has_value());
sprang57c2fff2017-01-16 06:24:02 -08002730
mflodmancc3d4422017-08-03 08:27:51 -07002731 video_stream_encoder_->Stop();
sprang57c2fff2017-01-16 06:24:02 -08002732}
2733
Åsa Perssonc29cb2c2019-03-25 12:06:59 +01002734TEST_F(VideoStreamEncoderTest, TemporalLayersNotDisabledIfSupported) {
2735 // 2 TLs configured, temporal layers supported by encoder.
2736 const int kNumTemporalLayers = 2;
2737 ResetEncoder("VP8", 1, kNumTemporalLayers, 1, /*screenshare*/ false);
2738 fake_encoder_.SetTemporalLayersSupported(0, true);
2739
2740 // Bitrate allocated across temporal layers.
2741 const int kTl0Bps = kTargetBitrateBps *
2742 webrtc::SimulcastRateAllocator::GetTemporalRateAllocation(
2743 kNumTemporalLayers, /*temporal_id*/ 0);
2744 const int kTl1Bps = kTargetBitrateBps *
2745 webrtc::SimulcastRateAllocator::GetTemporalRateAllocation(
2746 kNumTemporalLayers, /*temporal_id*/ 1);
2747 VideoBitrateAllocation expected_bitrate;
2748 expected_bitrate.SetBitrate(/*si*/ 0, /*ti*/ 0, kTl0Bps);
2749 expected_bitrate.SetBitrate(/*si*/ 0, /*ti*/ 1, kTl1Bps - kTl0Bps);
2750
2751 VerifyAllocatedBitrate(expected_bitrate);
2752 video_stream_encoder_->Stop();
2753}
2754
2755TEST_F(VideoStreamEncoderTest, TemporalLayersDisabledIfNotSupported) {
2756 // 2 TLs configured, temporal layers not supported by encoder.
2757 ResetEncoder("VP8", 1, /*num_temporal_layers*/ 2, 1, /*screenshare*/ false);
2758 fake_encoder_.SetTemporalLayersSupported(0, false);
2759
2760 // Temporal layers not supported by the encoder.
2761 // Total bitrate should be at ti:0.
2762 VideoBitrateAllocation expected_bitrate;
2763 expected_bitrate.SetBitrate(/*si*/ 0, /*ti*/ 0, kTargetBitrateBps);
2764
2765 VerifyAllocatedBitrate(expected_bitrate);
2766 video_stream_encoder_->Stop();
2767}
2768
2769TEST_F(VideoStreamEncoderTest, VerifyBitrateAllocationForTwoStreams) {
2770 // 2 TLs configured, temporal layers only supported for first stream.
2771 ResetEncoder("VP8", 2, /*num_temporal_layers*/ 2, 1, /*screenshare*/ false);
2772 fake_encoder_.SetTemporalLayersSupported(0, true);
2773 fake_encoder_.SetTemporalLayersSupported(1, false);
2774
2775 const int kS0Bps = 150000;
2776 const int kS0Tl0Bps =
2777 kS0Bps * webrtc::SimulcastRateAllocator::GetTemporalRateAllocation(
2778 /*num_layers*/ 2, /*temporal_id*/ 0);
2779 const int kS0Tl1Bps =
2780 kS0Bps * webrtc::SimulcastRateAllocator::GetTemporalRateAllocation(
2781 /*num_layers*/ 2, /*temporal_id*/ 1);
2782 const int kS1Bps = kTargetBitrateBps - kS0Tl1Bps;
2783 // Temporal layers not supported by si:1.
2784 VideoBitrateAllocation expected_bitrate;
2785 expected_bitrate.SetBitrate(/*si*/ 0, /*ti*/ 0, kS0Tl0Bps);
2786 expected_bitrate.SetBitrate(/*si*/ 0, /*ti*/ 1, kS0Tl1Bps - kS0Tl0Bps);
2787 expected_bitrate.SetBitrate(/*si*/ 1, /*ti*/ 0, kS1Bps);
2788
2789 VerifyAllocatedBitrate(expected_bitrate);
2790 video_stream_encoder_->Stop();
2791}
2792
Niels Möller7dc26b72017-12-06 10:27:48 +01002793TEST_F(VideoStreamEncoderTest, OveruseDetectorUpdatedOnReconfigureAndAdaption) {
2794 const int kFrameWidth = 1280;
2795 const int kFrameHeight = 720;
2796 const int kFramerate = 24;
2797
Erik Språng4c6ca302019-04-08 15:14:01 +02002798 video_stream_encoder_->OnBitrateUpdated(
2799 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
Niels Möller7dc26b72017-12-06 10:27:48 +01002800 test::FrameForwarder source;
2801 video_stream_encoder_->SetSource(
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07002802 &source, webrtc::DegradationPreference::MAINTAIN_RESOLUTION);
Niels Möller7dc26b72017-12-06 10:27:48 +01002803
2804 // Insert a single frame, triggering initial configuration.
2805 source.IncomingCapturedFrame(CreateFrame(1, kFrameWidth, kFrameHeight));
2806 video_stream_encoder_->WaitUntilTaskQueueIsIdle();
2807
2808 EXPECT_EQ(
2809 video_stream_encoder_->overuse_detector_proxy_->GetLastTargetFramerate(),
2810 kDefaultFramerate);
2811
2812 // Trigger reconfigure encoder (without resetting the entire instance).
2813 VideoEncoderConfig video_encoder_config;
Niels Möller259a4972018-04-05 15:36:51 +02002814 video_encoder_config.codec_type = kVideoCodecVP8;
Niels Möller7dc26b72017-12-06 10:27:48 +01002815 video_encoder_config.max_bitrate_bps = kTargetBitrateBps;
2816 video_encoder_config.number_of_streams = 1;
2817 video_encoder_config.video_stream_factory =
2818 new rtc::RefCountedObject<VideoStreamFactory>(1, kFramerate);
2819 video_stream_encoder_->ConfigureEncoder(std::move(video_encoder_config),
Niels Möllerf1338562018-04-26 09:51:47 +02002820 kMaxPayloadLength);
Niels Möller7dc26b72017-12-06 10:27:48 +01002821 video_stream_encoder_->WaitUntilTaskQueueIsIdle();
2822
2823 // Detector should be updated with fps limit from codec config.
2824 EXPECT_EQ(
2825 video_stream_encoder_->overuse_detector_proxy_->GetLastTargetFramerate(),
2826 kFramerate);
2827
2828 // Trigger overuse, max framerate should be reduced.
2829 VideoSendStream::Stats stats = stats_proxy_->GetStats();
2830 stats.input_frame_rate = kFramerate;
2831 stats_proxy_->SetMockStats(stats);
2832 video_stream_encoder_->TriggerCpuOveruse();
2833 video_stream_encoder_->WaitUntilTaskQueueIsIdle();
2834 int adapted_framerate =
2835 video_stream_encoder_->overuse_detector_proxy_->GetLastTargetFramerate();
2836 EXPECT_LT(adapted_framerate, kFramerate);
2837
2838 // Trigger underuse, max framerate should go back to codec configured fps.
2839 // Set extra low fps, to make sure it's actually reset, not just incremented.
2840 stats = stats_proxy_->GetStats();
2841 stats.input_frame_rate = adapted_framerate / 2;
2842 stats_proxy_->SetMockStats(stats);
2843 video_stream_encoder_->TriggerCpuNormalUsage();
2844 video_stream_encoder_->WaitUntilTaskQueueIsIdle();
2845 EXPECT_EQ(
2846 video_stream_encoder_->overuse_detector_proxy_->GetLastTargetFramerate(),
2847 kFramerate);
2848
2849 video_stream_encoder_->Stop();
2850}
2851
2852TEST_F(VideoStreamEncoderTest,
2853 OveruseDetectorUpdatedRespectsFramerateAfterUnderuse) {
2854 const int kFrameWidth = 1280;
2855 const int kFrameHeight = 720;
2856 const int kLowFramerate = 15;
2857 const int kHighFramerate = 25;
2858
Erik Språng4c6ca302019-04-08 15:14:01 +02002859 video_stream_encoder_->OnBitrateUpdated(
2860 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
Niels Möller7dc26b72017-12-06 10:27:48 +01002861 test::FrameForwarder source;
2862 video_stream_encoder_->SetSource(
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07002863 &source, webrtc::DegradationPreference::MAINTAIN_RESOLUTION);
Niels Möller7dc26b72017-12-06 10:27:48 +01002864
2865 // Trigger initial configuration.
2866 VideoEncoderConfig video_encoder_config;
Niels Möller259a4972018-04-05 15:36:51 +02002867 video_encoder_config.codec_type = kVideoCodecVP8;
Niels Möller7dc26b72017-12-06 10:27:48 +01002868 video_encoder_config.max_bitrate_bps = kTargetBitrateBps;
2869 video_encoder_config.number_of_streams = 1;
2870 video_encoder_config.video_stream_factory =
2871 new rtc::RefCountedObject<VideoStreamFactory>(1, kLowFramerate);
2872 source.IncomingCapturedFrame(CreateFrame(1, kFrameWidth, kFrameHeight));
2873 video_stream_encoder_->ConfigureEncoder(std::move(video_encoder_config),
Niels Möllerf1338562018-04-26 09:51:47 +02002874 kMaxPayloadLength);
Niels Möller7dc26b72017-12-06 10:27:48 +01002875 video_stream_encoder_->WaitUntilTaskQueueIsIdle();
2876
2877 EXPECT_EQ(
2878 video_stream_encoder_->overuse_detector_proxy_->GetLastTargetFramerate(),
2879 kLowFramerate);
2880
2881 // Trigger overuse, max framerate should be reduced.
2882 VideoSendStream::Stats stats = stats_proxy_->GetStats();
2883 stats.input_frame_rate = kLowFramerate;
2884 stats_proxy_->SetMockStats(stats);
2885 video_stream_encoder_->TriggerCpuOveruse();
2886 video_stream_encoder_->WaitUntilTaskQueueIsIdle();
2887 int adapted_framerate =
2888 video_stream_encoder_->overuse_detector_proxy_->GetLastTargetFramerate();
2889 EXPECT_LT(adapted_framerate, kLowFramerate);
2890
2891 // Reconfigure the encoder with a new (higher max framerate), max fps should
2892 // still respect the adaptation.
2893 video_encoder_config.video_stream_factory =
2894 new rtc::RefCountedObject<VideoStreamFactory>(1, kHighFramerate);
2895 source.IncomingCapturedFrame(CreateFrame(1, kFrameWidth, kFrameHeight));
2896 video_stream_encoder_->ConfigureEncoder(std::move(video_encoder_config),
Niels Möllerf1338562018-04-26 09:51:47 +02002897 kMaxPayloadLength);
Niels Möller7dc26b72017-12-06 10:27:48 +01002898 video_stream_encoder_->WaitUntilTaskQueueIsIdle();
2899
2900 EXPECT_EQ(
2901 video_stream_encoder_->overuse_detector_proxy_->GetLastTargetFramerate(),
2902 adapted_framerate);
2903
2904 // Trigger underuse, max framerate should go back to codec configured fps.
2905 stats = stats_proxy_->GetStats();
2906 stats.input_frame_rate = adapted_framerate;
2907 stats_proxy_->SetMockStats(stats);
2908 video_stream_encoder_->TriggerCpuNormalUsage();
2909 video_stream_encoder_->WaitUntilTaskQueueIsIdle();
2910 EXPECT_EQ(
2911 video_stream_encoder_->overuse_detector_proxy_->GetLastTargetFramerate(),
2912 kHighFramerate);
2913
2914 video_stream_encoder_->Stop();
2915}
2916
mflodmancc3d4422017-08-03 08:27:51 -07002917TEST_F(VideoStreamEncoderTest,
2918 OveruseDetectorUpdatedOnDegradationPreferenceChange) {
sprangfda496a2017-06-15 04:21:07 -07002919 const int kFrameWidth = 1280;
2920 const int kFrameHeight = 720;
2921 const int kFramerate = 24;
2922
Erik Språng4c6ca302019-04-08 15:14:01 +02002923 video_stream_encoder_->OnBitrateUpdated(
2924 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
sprangfda496a2017-06-15 04:21:07 -07002925 test::FrameForwarder source;
mflodmancc3d4422017-08-03 08:27:51 -07002926 video_stream_encoder_->SetSource(
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07002927 &source, webrtc::DegradationPreference::MAINTAIN_RESOLUTION);
sprangfda496a2017-06-15 04:21:07 -07002928
2929 // Trigger initial configuration.
2930 VideoEncoderConfig video_encoder_config;
Niels Möller259a4972018-04-05 15:36:51 +02002931 video_encoder_config.codec_type = kVideoCodecVP8;
sprangfda496a2017-06-15 04:21:07 -07002932 video_encoder_config.max_bitrate_bps = kTargetBitrateBps;
2933 video_encoder_config.number_of_streams = 1;
2934 video_encoder_config.video_stream_factory =
2935 new rtc::RefCountedObject<VideoStreamFactory>(1, kFramerate);
2936 source.IncomingCapturedFrame(CreateFrame(1, kFrameWidth, kFrameHeight));
mflodmancc3d4422017-08-03 08:27:51 -07002937 video_stream_encoder_->ConfigureEncoder(std::move(video_encoder_config),
Niels Möllerf1338562018-04-26 09:51:47 +02002938 kMaxPayloadLength);
mflodmancc3d4422017-08-03 08:27:51 -07002939 video_stream_encoder_->WaitUntilTaskQueueIsIdle();
sprangfda496a2017-06-15 04:21:07 -07002940
Niels Möller7dc26b72017-12-06 10:27:48 +01002941 EXPECT_EQ(
2942 video_stream_encoder_->overuse_detector_proxy_->GetLastTargetFramerate(),
2943 kFramerate);
sprangfda496a2017-06-15 04:21:07 -07002944
2945 // Trigger overuse, max framerate should be reduced.
2946 VideoSendStream::Stats stats = stats_proxy_->GetStats();
2947 stats.input_frame_rate = kFramerate;
2948 stats_proxy_->SetMockStats(stats);
mflodmancc3d4422017-08-03 08:27:51 -07002949 video_stream_encoder_->TriggerCpuOveruse();
2950 video_stream_encoder_->WaitUntilTaskQueueIsIdle();
Niels Möller7dc26b72017-12-06 10:27:48 +01002951 int adapted_framerate =
2952 video_stream_encoder_->overuse_detector_proxy_->GetLastTargetFramerate();
sprangfda496a2017-06-15 04:21:07 -07002953 EXPECT_LT(adapted_framerate, kFramerate);
2954
2955 // Change degradation preference to not enable framerate scaling. Target
2956 // framerate should be changed to codec defined limit.
mflodmancc3d4422017-08-03 08:27:51 -07002957 video_stream_encoder_->SetSource(
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07002958 &source, webrtc::DegradationPreference::MAINTAIN_FRAMERATE);
mflodmancc3d4422017-08-03 08:27:51 -07002959 video_stream_encoder_->WaitUntilTaskQueueIsIdle();
Niels Möller7dc26b72017-12-06 10:27:48 +01002960 EXPECT_EQ(
2961 video_stream_encoder_->overuse_detector_proxy_->GetLastTargetFramerate(),
2962 kFramerate);
sprangfda496a2017-06-15 04:21:07 -07002963
mflodmancc3d4422017-08-03 08:27:51 -07002964 video_stream_encoder_->Stop();
sprangfda496a2017-06-15 04:21:07 -07002965}
2966
mflodmancc3d4422017-08-03 08:27:51 -07002967TEST_F(VideoStreamEncoderTest, DropsFramesAndScalesWhenBitrateIsTooLow) {
asaperssonfab67072017-04-04 05:51:49 -07002968 const int kTooLowBitrateForFrameSizeBps = 10000;
Erik Språng610c7632019-03-06 15:37:33 +01002969 video_stream_encoder_->OnBitrateUpdated(
Erik Språng4c6ca302019-04-08 15:14:01 +02002970 DataRate::bps(kTooLowBitrateForFrameSizeBps),
2971 DataRate::bps(kTooLowBitrateForFrameSizeBps), 0, 0);
asaperssonfab67072017-04-04 05:51:49 -07002972 const int kWidth = 640;
2973 const int kHeight = 360;
kthelgason2bc68642017-02-07 07:02:22 -08002974
asaperssonfab67072017-04-04 05:51:49 -07002975 video_source_.IncomingCapturedFrame(CreateFrame(1, kWidth, kHeight));
kthelgason2bc68642017-02-07 07:02:22 -08002976
2977 // Expect to drop this frame, the wait should time out.
sprang4847ae62017-06-27 07:06:52 -07002978 ExpectDroppedFrame();
kthelgason2bc68642017-02-07 07:02:22 -08002979
2980 // Expect the sink_wants to specify a scaled frame.
asapersson0944a802017-04-07 00:57:58 -07002981 EXPECT_LT(video_source_.sink_wants().max_pixel_count, kWidth * kHeight);
kthelgason2bc68642017-02-07 07:02:22 -08002982
sprangc5d62e22017-04-02 23:53:04 -07002983 int last_pixel_count = video_source_.sink_wants().max_pixel_count;
kthelgason2bc68642017-02-07 07:02:22 -08002984
asaperssonfab67072017-04-04 05:51:49 -07002985 // Next frame is scaled.
kthelgason2bc68642017-02-07 07:02:22 -08002986 video_source_.IncomingCapturedFrame(
asaperssonfab67072017-04-04 05:51:49 -07002987 CreateFrame(2, kWidth * 3 / 4, kHeight * 3 / 4));
kthelgason2bc68642017-02-07 07:02:22 -08002988
2989 // Expect to drop this frame, the wait should time out.
sprang4847ae62017-06-27 07:06:52 -07002990 ExpectDroppedFrame();
kthelgason2bc68642017-02-07 07:02:22 -08002991
sprangc5d62e22017-04-02 23:53:04 -07002992 EXPECT_LT(video_source_.sink_wants().max_pixel_count, last_pixel_count);
kthelgason2bc68642017-02-07 07:02:22 -08002993
mflodmancc3d4422017-08-03 08:27:51 -07002994 video_stream_encoder_->Stop();
kthelgason2bc68642017-02-07 07:02:22 -08002995}
2996
mflodmancc3d4422017-08-03 08:27:51 -07002997TEST_F(VideoStreamEncoderTest,
2998 NumberOfDroppedFramesLimitedWhenBitrateIsTooLow) {
asaperssonfab67072017-04-04 05:51:49 -07002999 const int kTooLowBitrateForFrameSizeBps = 10000;
Erik Språng610c7632019-03-06 15:37:33 +01003000 video_stream_encoder_->OnBitrateUpdated(
Erik Språng4c6ca302019-04-08 15:14:01 +02003001 DataRate::bps(kTooLowBitrateForFrameSizeBps),
3002 DataRate::bps(kTooLowBitrateForFrameSizeBps), 0, 0);
asaperssonfab67072017-04-04 05:51:49 -07003003 const int kWidth = 640;
3004 const int kHeight = 360;
kthelgason2bc68642017-02-07 07:02:22 -08003005
3006 // We expect the n initial frames to get dropped.
3007 int i;
3008 for (i = 1; i <= kMaxInitialFramedrop; ++i) {
asaperssonfab67072017-04-04 05:51:49 -07003009 video_source_.IncomingCapturedFrame(CreateFrame(i, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07003010 ExpectDroppedFrame();
kthelgason2bc68642017-02-07 07:02:22 -08003011 }
3012 // The n+1th frame should not be dropped, even though it's size is too large.
asaperssonfab67072017-04-04 05:51:49 -07003013 video_source_.IncomingCapturedFrame(CreateFrame(i, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07003014 WaitForEncodedFrame(i);
kthelgason2bc68642017-02-07 07:02:22 -08003015
3016 // Expect the sink_wants to specify a scaled frame.
asaperssonfab67072017-04-04 05:51:49 -07003017 EXPECT_LT(video_source_.sink_wants().max_pixel_count, kWidth * kHeight);
kthelgason2bc68642017-02-07 07:02:22 -08003018
mflodmancc3d4422017-08-03 08:27:51 -07003019 video_stream_encoder_->Stop();
kthelgason2bc68642017-02-07 07:02:22 -08003020}
3021
mflodmancc3d4422017-08-03 08:27:51 -07003022TEST_F(VideoStreamEncoderTest,
3023 InitialFrameDropOffWithMaintainResolutionPreference) {
asaperssonfab67072017-04-04 05:51:49 -07003024 const int kWidth = 640;
3025 const int kHeight = 360;
Erik Språng610c7632019-03-06 15:37:33 +01003026 video_stream_encoder_->OnBitrateUpdated(DataRate::bps(kLowTargetBitrateBps),
Erik Språng4c6ca302019-04-08 15:14:01 +02003027 DataRate::bps(kLowTargetBitrateBps),
3028 0, 0);
kthelgason2bc68642017-02-07 07:02:22 -08003029
3030 // Set degradation preference.
mflodmancc3d4422017-08-03 08:27:51 -07003031 video_stream_encoder_->SetSource(
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07003032 &video_source_, webrtc::DegradationPreference::MAINTAIN_RESOLUTION);
kthelgason2bc68642017-02-07 07:02:22 -08003033
asaperssonfab67072017-04-04 05:51:49 -07003034 video_source_.IncomingCapturedFrame(CreateFrame(1, kWidth, kHeight));
kthelgason2bc68642017-02-07 07:02:22 -08003035 // Frame should not be dropped, even if it's too large.
sprang4847ae62017-06-27 07:06:52 -07003036 WaitForEncodedFrame(1);
kthelgason2bc68642017-02-07 07:02:22 -08003037
mflodmancc3d4422017-08-03 08:27:51 -07003038 video_stream_encoder_->Stop();
kthelgason2bc68642017-02-07 07:02:22 -08003039}
3040
mflodmancc3d4422017-08-03 08:27:51 -07003041TEST_F(VideoStreamEncoderTest, InitialFrameDropOffWhenEncoderDisabledScaling) {
asaperssonfab67072017-04-04 05:51:49 -07003042 const int kWidth = 640;
3043 const int kHeight = 360;
kthelgasonad9010c2017-02-14 00:46:51 -08003044 fake_encoder_.SetQualityScaling(false);
Niels Möller4db138e2018-04-19 09:04:13 +02003045
3046 VideoEncoderConfig video_encoder_config;
3047 test::FillEncoderConfiguration(kVideoCodecVP8, 1, &video_encoder_config);
3048 // Make format different, to force recreation of encoder.
3049 video_encoder_config.video_format.parameters["foo"] = "foo";
3050 video_stream_encoder_->ConfigureEncoder(std::move(video_encoder_config),
Niels Möllerf1338562018-04-26 09:51:47 +02003051 kMaxPayloadLength);
Erik Språng610c7632019-03-06 15:37:33 +01003052 video_stream_encoder_->OnBitrateUpdated(DataRate::bps(kLowTargetBitrateBps),
Erik Språng4c6ca302019-04-08 15:14:01 +02003053 DataRate::bps(kLowTargetBitrateBps),
3054 0, 0);
asapersson09f05612017-05-15 23:40:18 -07003055
kthelgasonb83797b2017-02-14 11:57:25 -08003056 // Force quality scaler reconfiguration by resetting the source.
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07003057 video_stream_encoder_->SetSource(&video_source_,
3058 webrtc::DegradationPreference::BALANCED);
kthelgasonad9010c2017-02-14 00:46:51 -08003059
asaperssonfab67072017-04-04 05:51:49 -07003060 video_source_.IncomingCapturedFrame(CreateFrame(1, kWidth, kHeight));
kthelgasonad9010c2017-02-14 00:46:51 -08003061 // Frame should not be dropped, even if it's too large.
sprang4847ae62017-06-27 07:06:52 -07003062 WaitForEncodedFrame(1);
kthelgasonad9010c2017-02-14 00:46:51 -08003063
mflodmancc3d4422017-08-03 08:27:51 -07003064 video_stream_encoder_->Stop();
kthelgasonad9010c2017-02-14 00:46:51 -08003065 fake_encoder_.SetQualityScaling(true);
3066}
3067
Kári Tristan Helgason639602a2018-08-02 10:51:40 +02003068TEST_F(VideoStreamEncoderTest, InitialFrameDropActivatesWhenBWEstimateReady) {
3069 webrtc::test::ScopedFieldTrials field_trials(
3070 "WebRTC-InitialFramedrop/Enabled/");
3071 // Reset encoder for field trials to take effect.
3072 ConfigureEncoder(video_encoder_config_.Copy());
3073 const int kTooLowBitrateForFrameSizeBps = 10000;
3074 const int kWidth = 640;
3075 const int kHeight = 360;
3076
Erik Språng4c6ca302019-04-08 15:14:01 +02003077 video_stream_encoder_->OnBitrateUpdated(
3078 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
Kári Tristan Helgason639602a2018-08-02 10:51:40 +02003079 video_source_.IncomingCapturedFrame(CreateFrame(1, kWidth, kHeight));
3080 // Frame should not be dropped.
3081 WaitForEncodedFrame(1);
3082
Erik Språng610c7632019-03-06 15:37:33 +01003083 video_stream_encoder_->OnBitrateUpdated(
Erik Språng4c6ca302019-04-08 15:14:01 +02003084 DataRate::bps(kTooLowBitrateForFrameSizeBps),
3085 DataRate::bps(kTooLowBitrateForFrameSizeBps), 0, 0);
Kári Tristan Helgason639602a2018-08-02 10:51:40 +02003086 video_source_.IncomingCapturedFrame(CreateFrame(2, kWidth, kHeight));
3087 // Expect to drop this frame, the wait should time out.
3088 ExpectDroppedFrame();
3089
3090 // Expect the sink_wants to specify a scaled frame.
3091 EXPECT_LT(video_source_.sink_wants().max_pixel_count, kWidth * kHeight);
3092 video_stream_encoder_->Stop();
3093}
3094
mflodmancc3d4422017-08-03 08:27:51 -07003095TEST_F(VideoStreamEncoderTest,
asaperssond0de2952017-04-21 01:47:31 -07003096 ResolutionNotAdaptedForTooSmallFrame_MaintainFramerateMode) {
3097 const int kTooSmallWidth = 10;
3098 const int kTooSmallHeight = 10;
Erik Språng4c6ca302019-04-08 15:14:01 +02003099 video_stream_encoder_->OnBitrateUpdated(
3100 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
asaperssond0de2952017-04-21 01:47:31 -07003101
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07003102 // Enable MAINTAIN_FRAMERATE preference, no initial limitation.
asaperssond0de2952017-04-21 01:47:31 -07003103 test::FrameForwarder source;
mflodmancc3d4422017-08-03 08:27:51 -07003104 video_stream_encoder_->SetSource(
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07003105 &source, webrtc::DegradationPreference::MAINTAIN_FRAMERATE);
asaperssond0de2952017-04-21 01:47:31 -07003106 VerifyNoLimitation(source.sink_wants());
3107 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_resolution);
3108
3109 // Trigger adapt down, too small frame, expect no change.
3110 source.IncomingCapturedFrame(CreateFrame(1, kTooSmallWidth, kTooSmallHeight));
sprang4847ae62017-06-27 07:06:52 -07003111 WaitForEncodedFrame(1);
mflodmancc3d4422017-08-03 08:27:51 -07003112 video_stream_encoder_->TriggerCpuOveruse();
Åsa Persson8c1bf952018-09-13 10:42:19 +02003113 VerifyFpsMaxResolutionMax(source.sink_wants());
asaperssond0de2952017-04-21 01:47:31 -07003114 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_resolution);
3115 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_cpu_adapt_changes);
3116
mflodmancc3d4422017-08-03 08:27:51 -07003117 video_stream_encoder_->Stop();
asaperssond0de2952017-04-21 01:47:31 -07003118}
3119
mflodmancc3d4422017-08-03 08:27:51 -07003120TEST_F(VideoStreamEncoderTest,
3121 ResolutionNotAdaptedForTooSmallFrame_BalancedMode) {
asaperssonf7e294d2017-06-13 23:25:22 -07003122 const int kTooSmallWidth = 10;
3123 const int kTooSmallHeight = 10;
3124 const int kFpsLimit = 7;
Erik Språng4c6ca302019-04-08 15:14:01 +02003125 video_stream_encoder_->OnBitrateUpdated(
3126 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
asaperssonf7e294d2017-06-13 23:25:22 -07003127
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07003128 // Enable BALANCED preference, no initial limitation.
asaperssonf7e294d2017-06-13 23:25:22 -07003129 test::FrameForwarder source;
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07003130 video_stream_encoder_->SetSource(&source,
3131 webrtc::DegradationPreference::BALANCED);
asaperssonf7e294d2017-06-13 23:25:22 -07003132 VerifyNoLimitation(source.sink_wants());
3133 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution);
3134 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_framerate);
3135
3136 // Trigger adapt down, expect limited framerate.
3137 source.IncomingCapturedFrame(CreateFrame(1, kTooSmallWidth, kTooSmallHeight));
sprang4847ae62017-06-27 07:06:52 -07003138 WaitForEncodedFrame(1);
mflodmancc3d4422017-08-03 08:27:51 -07003139 video_stream_encoder_->TriggerQualityLow();
asaperssonf7e294d2017-06-13 23:25:22 -07003140 VerifyFpsEqResolutionMax(source.sink_wants(), kFpsLimit);
3141 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution);
3142 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_framerate);
3143 EXPECT_EQ(1, stats_proxy_->GetStats().number_of_quality_adapt_changes);
3144
3145 // Trigger adapt down, too small frame, expect no change.
3146 source.IncomingCapturedFrame(CreateFrame(2, kTooSmallWidth, kTooSmallHeight));
sprang4847ae62017-06-27 07:06:52 -07003147 WaitForEncodedFrame(2);
mflodmancc3d4422017-08-03 08:27:51 -07003148 video_stream_encoder_->TriggerQualityLow();
asaperssonf7e294d2017-06-13 23:25:22 -07003149 VerifyFpsEqResolutionMax(source.sink_wants(), kFpsLimit);
3150 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution);
3151 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_framerate);
3152 EXPECT_EQ(1, stats_proxy_->GetStats().number_of_quality_adapt_changes);
3153
mflodmancc3d4422017-08-03 08:27:51 -07003154 video_stream_encoder_->Stop();
asaperssonf7e294d2017-06-13 23:25:22 -07003155}
3156
mflodmancc3d4422017-08-03 08:27:51 -07003157TEST_F(VideoStreamEncoderTest, FailingInitEncodeDoesntCauseCrash) {
asapersson02465b82017-04-10 01:12:52 -07003158 fake_encoder_.ForceInitEncodeFailure(true);
Erik Språng4c6ca302019-04-08 15:14:01 +02003159 video_stream_encoder_->OnBitrateUpdated(
3160 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
Niels Möllerf1338562018-04-26 09:51:47 +02003161 ResetEncoder("VP8", 2, 1, 1, false);
asapersson02465b82017-04-10 01:12:52 -07003162 const int kFrameWidth = 1280;
3163 const int kFrameHeight = 720;
3164 video_source_.IncomingCapturedFrame(
3165 CreateFrame(1, kFrameWidth, kFrameHeight));
sprang4847ae62017-06-27 07:06:52 -07003166 ExpectDroppedFrame();
mflodmancc3d4422017-08-03 08:27:51 -07003167 video_stream_encoder_->Stop();
asapersson02465b82017-04-10 01:12:52 -07003168}
3169
sprangb1ca0732017-02-01 08:38:12 -08003170// TODO(sprang): Extend this with fps throttling and any "balanced" extensions.
mflodmancc3d4422017-08-03 08:27:51 -07003171TEST_F(VideoStreamEncoderTest,
3172 AdaptsResolutionOnOveruse_MaintainFramerateMode) {
Erik Språng4c6ca302019-04-08 15:14:01 +02003173 video_stream_encoder_->OnBitrateUpdated(
3174 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
sprangb1ca0732017-02-01 08:38:12 -08003175
3176 const int kFrameWidth = 1280;
3177 const int kFrameHeight = 720;
3178 // Enabled default VideoAdapter downscaling. First step is 3/4, not 3/5 as
mflodmancc3d4422017-08-03 08:27:51 -07003179 // requested by
3180 // VideoStreamEncoder::VideoSourceProxy::RequestResolutionLowerThan().
sprangb1ca0732017-02-01 08:38:12 -08003181 video_source_.set_adaptation_enabled(true);
3182
3183 video_source_.IncomingCapturedFrame(
Åsa Persson8c1bf952018-09-13 10:42:19 +02003184 CreateFrame(1 * kFrameIntervalMs, kFrameWidth, kFrameHeight));
sprang4847ae62017-06-27 07:06:52 -07003185 WaitForEncodedFrame(kFrameWidth, kFrameHeight);
sprangb1ca0732017-02-01 08:38:12 -08003186
3187 // Trigger CPU overuse, downscale by 3/4.
mflodmancc3d4422017-08-03 08:27:51 -07003188 video_stream_encoder_->TriggerCpuOveruse();
sprangb1ca0732017-02-01 08:38:12 -08003189 video_source_.IncomingCapturedFrame(
Åsa Persson8c1bf952018-09-13 10:42:19 +02003190 CreateFrame(2 * kFrameIntervalMs, kFrameWidth, kFrameHeight));
sprang4847ae62017-06-27 07:06:52 -07003191 WaitForEncodedFrame((kFrameWidth * 3) / 4, (kFrameHeight * 3) / 4);
sprangb1ca0732017-02-01 08:38:12 -08003192
asaperssonfab67072017-04-04 05:51:49 -07003193 // Trigger CPU normal use, return to original resolution.
mflodmancc3d4422017-08-03 08:27:51 -07003194 video_stream_encoder_->TriggerCpuNormalUsage();
sprangb1ca0732017-02-01 08:38:12 -08003195 video_source_.IncomingCapturedFrame(
Åsa Persson8c1bf952018-09-13 10:42:19 +02003196 CreateFrame(3 * kFrameIntervalMs, kFrameWidth, kFrameHeight));
sprang4847ae62017-06-27 07:06:52 -07003197 WaitForEncodedFrame(kFrameWidth, kFrameHeight);
sprangb1ca0732017-02-01 08:38:12 -08003198
mflodmancc3d4422017-08-03 08:27:51 -07003199 video_stream_encoder_->Stop();
sprangb1ca0732017-02-01 08:38:12 -08003200}
sprangfe627f32017-03-29 08:24:59 -07003201
mflodmancc3d4422017-08-03 08:27:51 -07003202TEST_F(VideoStreamEncoderTest,
3203 AdaptsFramerateOnOveruse_MaintainResolutionMode) {
sprangc5d62e22017-04-02 23:53:04 -07003204 const int kFrameWidth = 1280;
3205 const int kFrameHeight = 720;
sprangc5d62e22017-04-02 23:53:04 -07003206
Erik Språng4c6ca302019-04-08 15:14:01 +02003207 video_stream_encoder_->OnBitrateUpdated(
3208 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
mflodmancc3d4422017-08-03 08:27:51 -07003209 video_stream_encoder_->SetSource(
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07003210 &video_source_, webrtc::DegradationPreference::MAINTAIN_RESOLUTION);
sprangc5d62e22017-04-02 23:53:04 -07003211 video_source_.set_adaptation_enabled(true);
3212
sprang4847ae62017-06-27 07:06:52 -07003213 int64_t timestamp_ms = fake_clock_.TimeNanos() / rtc::kNumNanosecsPerMillisec;
sprangc5d62e22017-04-02 23:53:04 -07003214
3215 video_source_.IncomingCapturedFrame(
3216 CreateFrame(timestamp_ms, kFrameWidth, kFrameHeight));
sprang4847ae62017-06-27 07:06:52 -07003217 WaitForEncodedFrame(timestamp_ms);
sprangc5d62e22017-04-02 23:53:04 -07003218
3219 // Try to trigger overuse. No fps estimate available => no effect.
mflodmancc3d4422017-08-03 08:27:51 -07003220 video_stream_encoder_->TriggerCpuOveruse();
sprangc5d62e22017-04-02 23:53:04 -07003221
3222 // Insert frames for one second to get a stable estimate.
sprang4847ae62017-06-27 07:06:52 -07003223 for (int i = 0; i < max_framerate_; ++i) {
sprangc5d62e22017-04-02 23:53:04 -07003224 timestamp_ms += kFrameIntervalMs;
sprangc5d62e22017-04-02 23:53:04 -07003225 video_source_.IncomingCapturedFrame(
3226 CreateFrame(timestamp_ms, kFrameWidth, kFrameHeight));
sprang4847ae62017-06-27 07:06:52 -07003227 WaitForEncodedFrame(timestamp_ms);
sprangc5d62e22017-04-02 23:53:04 -07003228 }
3229
3230 // Trigger CPU overuse, reduce framerate by 2/3.
mflodmancc3d4422017-08-03 08:27:51 -07003231 video_stream_encoder_->TriggerCpuOveruse();
sprangc5d62e22017-04-02 23:53:04 -07003232 int num_frames_dropped = 0;
sprang4847ae62017-06-27 07:06:52 -07003233 for (int i = 0; i < max_framerate_; ++i) {
sprangc5d62e22017-04-02 23:53:04 -07003234 timestamp_ms += kFrameIntervalMs;
sprangc5d62e22017-04-02 23:53:04 -07003235 video_source_.IncomingCapturedFrame(
3236 CreateFrame(timestamp_ms, kFrameWidth, kFrameHeight));
sprang4847ae62017-06-27 07:06:52 -07003237 if (!WaitForFrame(kFrameTimeoutMs)) {
sprangc5d62e22017-04-02 23:53:04 -07003238 ++num_frames_dropped;
3239 } else {
Åsa Perssonc74d8da2017-12-04 14:13:56 +01003240 sink_.CheckLastFrameSizeMatches(kFrameWidth, kFrameHeight);
sprangc5d62e22017-04-02 23:53:04 -07003241 }
3242 }
3243
sprang4847ae62017-06-27 07:06:52 -07003244 // Add some slack to account for frames dropped by the frame dropper.
3245 const int kErrorMargin = 1;
3246 EXPECT_NEAR(num_frames_dropped, max_framerate_ - (max_framerate_ * 2 / 3),
sprangc5d62e22017-04-02 23:53:04 -07003247 kErrorMargin);
3248
3249 // Trigger CPU overuse, reduce framerate by 2/3 again.
mflodmancc3d4422017-08-03 08:27:51 -07003250 video_stream_encoder_->TriggerCpuOveruse();
sprangc5d62e22017-04-02 23:53:04 -07003251 num_frames_dropped = 0;
Åsa Persson8c1bf952018-09-13 10:42:19 +02003252 for (int i = 0; i <= max_framerate_; ++i) {
sprangc5d62e22017-04-02 23:53:04 -07003253 timestamp_ms += kFrameIntervalMs;
sprangc5d62e22017-04-02 23:53:04 -07003254 video_source_.IncomingCapturedFrame(
3255 CreateFrame(timestamp_ms, kFrameWidth, kFrameHeight));
sprang4847ae62017-06-27 07:06:52 -07003256 if (!WaitForFrame(kFrameTimeoutMs)) {
sprangc5d62e22017-04-02 23:53:04 -07003257 ++num_frames_dropped;
3258 } else {
Åsa Perssonc74d8da2017-12-04 14:13:56 +01003259 sink_.CheckLastFrameSizeMatches(kFrameWidth, kFrameHeight);
sprangc5d62e22017-04-02 23:53:04 -07003260 }
3261 }
sprang4847ae62017-06-27 07:06:52 -07003262 EXPECT_NEAR(num_frames_dropped, max_framerate_ - (max_framerate_ * 4 / 9),
sprangc5d62e22017-04-02 23:53:04 -07003263 kErrorMargin);
3264
3265 // Go back up one step.
mflodmancc3d4422017-08-03 08:27:51 -07003266 video_stream_encoder_->TriggerCpuNormalUsage();
sprangc5d62e22017-04-02 23:53:04 -07003267 num_frames_dropped = 0;
sprang4847ae62017-06-27 07:06:52 -07003268 for (int i = 0; i < max_framerate_; ++i) {
sprangc5d62e22017-04-02 23:53:04 -07003269 timestamp_ms += kFrameIntervalMs;
sprangc5d62e22017-04-02 23:53:04 -07003270 video_source_.IncomingCapturedFrame(
3271 CreateFrame(timestamp_ms, kFrameWidth, kFrameHeight));
sprang4847ae62017-06-27 07:06:52 -07003272 if (!WaitForFrame(kFrameTimeoutMs)) {
sprangc5d62e22017-04-02 23:53:04 -07003273 ++num_frames_dropped;
3274 } else {
Åsa Perssonc74d8da2017-12-04 14:13:56 +01003275 sink_.CheckLastFrameSizeMatches(kFrameWidth, kFrameHeight);
sprangc5d62e22017-04-02 23:53:04 -07003276 }
3277 }
sprang4847ae62017-06-27 07:06:52 -07003278 EXPECT_NEAR(num_frames_dropped, max_framerate_ - (max_framerate_ * 2 / 3),
sprangc5d62e22017-04-02 23:53:04 -07003279 kErrorMargin);
3280
3281 // Go back up to original mode.
mflodmancc3d4422017-08-03 08:27:51 -07003282 video_stream_encoder_->TriggerCpuNormalUsage();
sprangc5d62e22017-04-02 23:53:04 -07003283 num_frames_dropped = 0;
sprang4847ae62017-06-27 07:06:52 -07003284 for (int i = 0; i < max_framerate_; ++i) {
sprangc5d62e22017-04-02 23:53:04 -07003285 timestamp_ms += kFrameIntervalMs;
sprangc5d62e22017-04-02 23:53:04 -07003286 video_source_.IncomingCapturedFrame(
3287 CreateFrame(timestamp_ms, kFrameWidth, kFrameHeight));
sprang4847ae62017-06-27 07:06:52 -07003288 if (!WaitForFrame(kFrameTimeoutMs)) {
sprangc5d62e22017-04-02 23:53:04 -07003289 ++num_frames_dropped;
3290 } else {
Åsa Perssonc74d8da2017-12-04 14:13:56 +01003291 sink_.CheckLastFrameSizeMatches(kFrameWidth, kFrameHeight);
sprangc5d62e22017-04-02 23:53:04 -07003292 }
3293 }
3294 EXPECT_NEAR(num_frames_dropped, 0, kErrorMargin);
3295
mflodmancc3d4422017-08-03 08:27:51 -07003296 video_stream_encoder_->Stop();
sprangc5d62e22017-04-02 23:53:04 -07003297}
3298
mflodmancc3d4422017-08-03 08:27:51 -07003299TEST_F(VideoStreamEncoderTest, DoesntAdaptDownPastMinFramerate) {
sprangc5d62e22017-04-02 23:53:04 -07003300 const int kFramerateFps = 5;
3301 const int kFrameIntervalMs = rtc::kNumMillisecsPerSec / kFramerateFps;
sprangc5d62e22017-04-02 23:53:04 -07003302 const int kFrameWidth = 1280;
3303 const int kFrameHeight = 720;
3304
sprang4847ae62017-06-27 07:06:52 -07003305 // Reconfigure encoder with two temporal layers and screensharing, which will
3306 // disable frame dropping and make testing easier.
Niels Möllerf1338562018-04-26 09:51:47 +02003307 ResetEncoder("VP8", 1, 2, 1, true);
sprang4847ae62017-06-27 07:06:52 -07003308
Erik Språng4c6ca302019-04-08 15:14:01 +02003309 video_stream_encoder_->OnBitrateUpdated(
3310 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
mflodmancc3d4422017-08-03 08:27:51 -07003311 video_stream_encoder_->SetSource(
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07003312 &video_source_, webrtc::DegradationPreference::MAINTAIN_RESOLUTION);
sprangc5d62e22017-04-02 23:53:04 -07003313 video_source_.set_adaptation_enabled(true);
3314
sprang4847ae62017-06-27 07:06:52 -07003315 int64_t timestamp_ms = fake_clock_.TimeNanos() / rtc::kNumNanosecsPerMillisec;
sprangc5d62e22017-04-02 23:53:04 -07003316
3317 // Trigger overuse as much as we can.
Jonathan Yubc771b72017-12-08 17:04:29 -08003318 rtc::VideoSinkWants last_wants;
3319 do {
3320 last_wants = video_source_.sink_wants();
3321
sprangc5d62e22017-04-02 23:53:04 -07003322 // Insert frames to get a new fps estimate...
3323 for (int j = 0; j < kFramerateFps; ++j) {
3324 video_source_.IncomingCapturedFrame(
3325 CreateFrame(timestamp_ms, kFrameWidth, kFrameHeight));
Jonathan Yubc771b72017-12-08 17:04:29 -08003326 if (video_source_.last_sent_width()) {
3327 sink_.WaitForEncodedFrame(timestamp_ms);
3328 }
sprangc5d62e22017-04-02 23:53:04 -07003329 timestamp_ms += kFrameIntervalMs;
Sebastian Jansson40889f32019-04-17 12:11:20 +02003330 fake_clock_.AdvanceTime(TimeDelta::ms(kFrameIntervalMs));
sprangc5d62e22017-04-02 23:53:04 -07003331 }
3332 // ...and then try to adapt again.
mflodmancc3d4422017-08-03 08:27:51 -07003333 video_stream_encoder_->TriggerCpuOveruse();
Jonathan Yubc771b72017-12-08 17:04:29 -08003334 } while (video_source_.sink_wants().max_framerate_fps <
3335 last_wants.max_framerate_fps);
sprangc5d62e22017-04-02 23:53:04 -07003336
Jonathan Yubc771b72017-12-08 17:04:29 -08003337 VerifyFpsEqResolutionMax(video_source_.sink_wants(), kMinFramerateFps);
asaperssonf7e294d2017-06-13 23:25:22 -07003338
mflodmancc3d4422017-08-03 08:27:51 -07003339 video_stream_encoder_->Stop();
sprangc5d62e22017-04-02 23:53:04 -07003340}
asaperssonf7e294d2017-06-13 23:25:22 -07003341
mflodmancc3d4422017-08-03 08:27:51 -07003342TEST_F(VideoStreamEncoderTest,
3343 AdaptsResolutionAndFramerateForLowQuality_BalancedMode) {
asaperssonf7e294d2017-06-13 23:25:22 -07003344 const int kWidth = 1280;
3345 const int kHeight = 720;
3346 const int64_t kFrameIntervalMs = 150;
3347 int64_t timestamp_ms = kFrameIntervalMs;
Erik Språng4c6ca302019-04-08 15:14:01 +02003348 video_stream_encoder_->OnBitrateUpdated(
3349 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
asaperssonf7e294d2017-06-13 23:25:22 -07003350
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07003351 // Enable BALANCED preference, no initial limitation.
asaperssonf7e294d2017-06-13 23:25:22 -07003352 AdaptingFrameForwarder source;
3353 source.set_adaptation_enabled(true);
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07003354 video_stream_encoder_->SetSource(&source,
3355 webrtc::DegradationPreference::BALANCED);
asaperssonf7e294d2017-06-13 23:25:22 -07003356 timestamp_ms += kFrameIntervalMs;
3357 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07003358 WaitForEncodedFrame(kWidth, kHeight);
Åsa Persson8c1bf952018-09-13 10:42:19 +02003359 VerifyFpsMaxResolutionMax(source.sink_wants());
asaperssonf7e294d2017-06-13 23:25:22 -07003360 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution);
3361 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_framerate);
3362 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_quality_adapt_changes);
3363
3364 // Trigger adapt down, expect scaled down resolution (960x540@30fps).
mflodmancc3d4422017-08-03 08:27:51 -07003365 video_stream_encoder_->TriggerQualityLow();
asaperssonf7e294d2017-06-13 23:25:22 -07003366 timestamp_ms += kFrameIntervalMs;
3367 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07003368 WaitForEncodedFrame(timestamp_ms);
asaperssonf7e294d2017-06-13 23:25:22 -07003369 VerifyFpsMaxResolutionLt(source.sink_wants(), kWidth * kHeight);
3370 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution);
3371 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_framerate);
3372 EXPECT_EQ(1, stats_proxy_->GetStats().number_of_quality_adapt_changes);
3373
3374 // Trigger adapt down, expect scaled down resolution (640x360@30fps).
mflodmancc3d4422017-08-03 08:27:51 -07003375 video_stream_encoder_->TriggerQualityLow();
asaperssonf7e294d2017-06-13 23:25:22 -07003376 timestamp_ms += kFrameIntervalMs;
3377 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07003378 WaitForEncodedFrame(timestamp_ms);
asaperssonf7e294d2017-06-13 23:25:22 -07003379 VerifyFpsMaxResolutionLt(source.sink_wants(), source.last_wants());
3380 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution);
3381 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_framerate);
3382 EXPECT_EQ(2, stats_proxy_->GetStats().number_of_quality_adapt_changes);
3383
3384 // Trigger adapt down, expect reduced fps (640x360@15fps).
mflodmancc3d4422017-08-03 08:27:51 -07003385 video_stream_encoder_->TriggerQualityLow();
asaperssonf7e294d2017-06-13 23:25:22 -07003386 timestamp_ms += kFrameIntervalMs;
3387 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07003388 WaitForEncodedFrame(timestamp_ms);
asaperssonf7e294d2017-06-13 23:25:22 -07003389 VerifyFpsLtResolutionEq(source.sink_wants(), source.last_wants());
3390 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution);
3391 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_framerate);
3392 EXPECT_EQ(3, stats_proxy_->GetStats().number_of_quality_adapt_changes);
3393
3394 // Trigger adapt down, expect scaled down resolution (480x270@15fps).
mflodmancc3d4422017-08-03 08:27:51 -07003395 video_stream_encoder_->TriggerQualityLow();
asaperssonf7e294d2017-06-13 23:25:22 -07003396 timestamp_ms += kFrameIntervalMs;
3397 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07003398 WaitForEncodedFrame(timestamp_ms);
asaperssonf7e294d2017-06-13 23:25:22 -07003399 VerifyFpsEqResolutionLt(source.sink_wants(), source.last_wants());
3400 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution);
3401 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_framerate);
3402 EXPECT_EQ(4, stats_proxy_->GetStats().number_of_quality_adapt_changes);
3403
3404 // Restrict bitrate, trigger adapt down, expect reduced fps (480x270@10fps).
mflodmancc3d4422017-08-03 08:27:51 -07003405 video_stream_encoder_->TriggerQualityLow();
asaperssonf7e294d2017-06-13 23:25:22 -07003406 timestamp_ms += kFrameIntervalMs;
3407 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07003408 WaitForEncodedFrame(timestamp_ms);
asaperssonf7e294d2017-06-13 23:25:22 -07003409 VerifyFpsLtResolutionEq(source.sink_wants(), source.last_wants());
3410 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution);
3411 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_framerate);
3412 EXPECT_EQ(5, stats_proxy_->GetStats().number_of_quality_adapt_changes);
3413
3414 // Trigger adapt down, expect scaled down resolution (320x180@10fps).
mflodmancc3d4422017-08-03 08:27:51 -07003415 video_stream_encoder_->TriggerQualityLow();
asaperssonf7e294d2017-06-13 23:25:22 -07003416 timestamp_ms += kFrameIntervalMs;
3417 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07003418 WaitForEncodedFrame(timestamp_ms);
asaperssonf7e294d2017-06-13 23:25:22 -07003419 VerifyFpsEqResolutionLt(source.sink_wants(), source.last_wants());
3420 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution);
3421 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_framerate);
3422 EXPECT_EQ(6, stats_proxy_->GetStats().number_of_quality_adapt_changes);
3423
3424 // Trigger adapt down, expect reduced fps (320x180@7fps).
mflodmancc3d4422017-08-03 08:27:51 -07003425 video_stream_encoder_->TriggerQualityLow();
asaperssonf7e294d2017-06-13 23:25:22 -07003426 timestamp_ms += kFrameIntervalMs;
3427 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07003428 WaitForEncodedFrame(timestamp_ms);
asaperssonf7e294d2017-06-13 23:25:22 -07003429 VerifyFpsLtResolutionEq(source.sink_wants(), source.last_wants());
3430 rtc::VideoSinkWants last_wants = source.sink_wants();
3431 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution);
3432 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_framerate);
3433 EXPECT_EQ(7, stats_proxy_->GetStats().number_of_quality_adapt_changes);
3434
3435 // Trigger adapt down, min resolution reached, expect no change.
mflodmancc3d4422017-08-03 08:27:51 -07003436 video_stream_encoder_->TriggerQualityLow();
asaperssonf7e294d2017-06-13 23:25:22 -07003437 timestamp_ms += kFrameIntervalMs;
3438 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07003439 WaitForEncodedFrame(timestamp_ms);
asaperssonf7e294d2017-06-13 23:25:22 -07003440 VerifyFpsEqResolutionEq(source.sink_wants(), last_wants);
3441 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution);
3442 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_framerate);
3443 EXPECT_EQ(7, stats_proxy_->GetStats().number_of_quality_adapt_changes);
3444
3445 // Trigger adapt down, expect expect increased fps (320x180@10fps).
mflodmancc3d4422017-08-03 08:27:51 -07003446 video_stream_encoder_->TriggerQualityHigh();
asaperssonf7e294d2017-06-13 23:25:22 -07003447 timestamp_ms += kFrameIntervalMs;
3448 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07003449 WaitForEncodedFrame(timestamp_ms);
asaperssonf7e294d2017-06-13 23:25:22 -07003450 VerifyFpsGtResolutionEq(source.sink_wants(), source.last_wants());
3451 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution);
3452 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_framerate);
3453 EXPECT_EQ(8, stats_proxy_->GetStats().number_of_quality_adapt_changes);
3454
3455 // Trigger adapt up, expect upscaled resolution (480x270@10fps).
mflodmancc3d4422017-08-03 08:27:51 -07003456 video_stream_encoder_->TriggerQualityHigh();
asaperssonf7e294d2017-06-13 23:25:22 -07003457 timestamp_ms += kFrameIntervalMs;
3458 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07003459 WaitForEncodedFrame(timestamp_ms);
asaperssonf7e294d2017-06-13 23:25:22 -07003460 VerifyFpsEqResolutionGt(source.sink_wants(), source.last_wants());
3461 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution);
3462 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_framerate);
3463 EXPECT_EQ(9, stats_proxy_->GetStats().number_of_quality_adapt_changes);
3464
3465 // Increase bitrate, trigger adapt up, expect increased fps (480x270@15fps).
mflodmancc3d4422017-08-03 08:27:51 -07003466 video_stream_encoder_->TriggerQualityHigh();
asaperssonf7e294d2017-06-13 23:25:22 -07003467 timestamp_ms += kFrameIntervalMs;
3468 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07003469 WaitForEncodedFrame(timestamp_ms);
asaperssonf7e294d2017-06-13 23:25:22 -07003470 VerifyFpsGtResolutionEq(source.sink_wants(), source.last_wants());
3471 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution);
3472 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_framerate);
3473 EXPECT_EQ(10, stats_proxy_->GetStats().number_of_quality_adapt_changes);
3474
3475 // Trigger adapt up, expect upscaled resolution (640x360@15fps).
mflodmancc3d4422017-08-03 08:27:51 -07003476 video_stream_encoder_->TriggerQualityHigh();
asaperssonf7e294d2017-06-13 23:25:22 -07003477 timestamp_ms += kFrameIntervalMs;
3478 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07003479 WaitForEncodedFrame(timestamp_ms);
asaperssonf7e294d2017-06-13 23:25:22 -07003480 VerifyFpsEqResolutionGt(source.sink_wants(), source.last_wants());
3481 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution);
3482 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_framerate);
3483 EXPECT_EQ(11, stats_proxy_->GetStats().number_of_quality_adapt_changes);
3484
3485 // Trigger adapt up, expect increased fps (640x360@30fps).
mflodmancc3d4422017-08-03 08:27:51 -07003486 video_stream_encoder_->TriggerQualityHigh();
asaperssonf7e294d2017-06-13 23:25:22 -07003487 timestamp_ms += kFrameIntervalMs;
3488 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07003489 WaitForEncodedFrame(timestamp_ms);
asaperssonf7e294d2017-06-13 23:25:22 -07003490 VerifyFpsMaxResolutionEq(source.sink_wants(), source.last_wants());
3491 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution);
3492 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_framerate);
3493 EXPECT_EQ(12, stats_proxy_->GetStats().number_of_quality_adapt_changes);
3494
3495 // Trigger adapt up, expect upscaled resolution (960x540@30fps).
mflodmancc3d4422017-08-03 08:27:51 -07003496 video_stream_encoder_->TriggerQualityHigh();
asaperssonf7e294d2017-06-13 23:25:22 -07003497 timestamp_ms += kFrameIntervalMs;
3498 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07003499 WaitForEncodedFrame(timestamp_ms);
asaperssonf7e294d2017-06-13 23:25:22 -07003500 VerifyFpsMaxResolutionGt(source.sink_wants(), source.last_wants());
3501 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution);
3502 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_framerate);
3503 EXPECT_EQ(13, stats_proxy_->GetStats().number_of_quality_adapt_changes);
3504
3505 // Trigger adapt up, expect no restriction (1280x720fps@30fps).
mflodmancc3d4422017-08-03 08:27:51 -07003506 video_stream_encoder_->TriggerQualityHigh();
asaperssonf7e294d2017-06-13 23:25:22 -07003507 timestamp_ms += kFrameIntervalMs;
3508 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07003509 WaitForEncodedFrame(kWidth, kHeight);
asaperssonf7e294d2017-06-13 23:25:22 -07003510 VerifyFpsMaxResolutionGt(source.sink_wants(), source.last_wants());
Åsa Persson8c1bf952018-09-13 10:42:19 +02003511 VerifyFpsMaxResolutionMax(source.sink_wants());
asaperssonf7e294d2017-06-13 23:25:22 -07003512 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution);
3513 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_framerate);
3514 EXPECT_EQ(14, stats_proxy_->GetStats().number_of_quality_adapt_changes);
3515
3516 // Trigger adapt up, expect no change.
mflodmancc3d4422017-08-03 08:27:51 -07003517 video_stream_encoder_->TriggerQualityHigh();
Åsa Persson8c1bf952018-09-13 10:42:19 +02003518 VerifyFpsMaxResolutionMax(source.sink_wants());
asaperssonf7e294d2017-06-13 23:25:22 -07003519 EXPECT_EQ(14, stats_proxy_->GetStats().number_of_quality_adapt_changes);
3520
mflodmancc3d4422017-08-03 08:27:51 -07003521 video_stream_encoder_->Stop();
asaperssonf7e294d2017-06-13 23:25:22 -07003522}
3523
mflodmancc3d4422017-08-03 08:27:51 -07003524TEST_F(VideoStreamEncoderTest, AdaptWithTwoReasonsAndDifferentOrder_Framerate) {
asaperssonf7e294d2017-06-13 23:25:22 -07003525 const int kWidth = 1280;
3526 const int kHeight = 720;
3527 const int64_t kFrameIntervalMs = 150;
3528 int64_t timestamp_ms = kFrameIntervalMs;
Erik Språng4c6ca302019-04-08 15:14:01 +02003529 video_stream_encoder_->OnBitrateUpdated(
3530 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
asaperssonf7e294d2017-06-13 23:25:22 -07003531
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07003532 // Enable BALANCED preference, no initial limitation.
asaperssonf7e294d2017-06-13 23:25:22 -07003533 AdaptingFrameForwarder source;
3534 source.set_adaptation_enabled(true);
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07003535 video_stream_encoder_->SetSource(&source,
3536 webrtc::DegradationPreference::BALANCED);
asaperssonf7e294d2017-06-13 23:25:22 -07003537 timestamp_ms += kFrameIntervalMs;
3538 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07003539 WaitForEncodedFrame(kWidth, kHeight);
Åsa Persson8c1bf952018-09-13 10:42:19 +02003540 VerifyFpsMaxResolutionMax(source.sink_wants());
asaperssonf7e294d2017-06-13 23:25:22 -07003541 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution);
3542 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_framerate);
3543 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_resolution);
3544 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_framerate);
3545 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_cpu_adapt_changes);
3546 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_quality_adapt_changes);
3547
3548 // Trigger cpu adapt down, expect scaled down resolution (960x540@30fps).
mflodmancc3d4422017-08-03 08:27:51 -07003549 video_stream_encoder_->TriggerCpuOveruse();
asaperssonf7e294d2017-06-13 23:25:22 -07003550 timestamp_ms += kFrameIntervalMs;
3551 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07003552 WaitForEncodedFrame(timestamp_ms);
asaperssonf7e294d2017-06-13 23:25:22 -07003553 VerifyFpsMaxResolutionLt(source.sink_wants(), kWidth * kHeight);
3554 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution);
3555 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_framerate);
3556 EXPECT_TRUE(stats_proxy_->GetStats().cpu_limited_resolution);
3557 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_framerate);
3558 EXPECT_EQ(1, stats_proxy_->GetStats().number_of_cpu_adapt_changes);
3559 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_quality_adapt_changes);
3560
3561 // Trigger cpu adapt down, expect scaled down resolution (640x360@30fps).
mflodmancc3d4422017-08-03 08:27:51 -07003562 video_stream_encoder_->TriggerCpuOveruse();
asaperssonf7e294d2017-06-13 23:25:22 -07003563 timestamp_ms += kFrameIntervalMs;
3564 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07003565 WaitForEncodedFrame(timestamp_ms);
asaperssonf7e294d2017-06-13 23:25:22 -07003566 VerifyFpsMaxResolutionLt(source.sink_wants(), source.last_wants());
3567 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution);
3568 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_framerate);
3569 EXPECT_TRUE(stats_proxy_->GetStats().cpu_limited_resolution);
3570 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_framerate);
3571 EXPECT_EQ(2, stats_proxy_->GetStats().number_of_cpu_adapt_changes);
3572 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_quality_adapt_changes);
3573
3574 // Trigger quality adapt down, expect reduced fps (640x360@15fps).
mflodmancc3d4422017-08-03 08:27:51 -07003575 video_stream_encoder_->TriggerQualityLow();
asaperssonf7e294d2017-06-13 23:25:22 -07003576 timestamp_ms += kFrameIntervalMs;
3577 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07003578 WaitForEncodedFrame(timestamp_ms);
asaperssonf7e294d2017-06-13 23:25:22 -07003579 VerifyFpsLtResolutionEq(source.sink_wants(), source.last_wants());
3580 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution);
3581 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_framerate);
3582 EXPECT_TRUE(stats_proxy_->GetStats().cpu_limited_resolution);
3583 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_framerate);
3584 EXPECT_EQ(2, stats_proxy_->GetStats().number_of_cpu_adapt_changes);
3585 EXPECT_EQ(1, stats_proxy_->GetStats().number_of_quality_adapt_changes);
3586
3587 // Trigger cpu adapt up, expect increased fps (640x360@30fps).
mflodmancc3d4422017-08-03 08:27:51 -07003588 video_stream_encoder_->TriggerCpuNormalUsage();
asaperssonf7e294d2017-06-13 23:25:22 -07003589 timestamp_ms += kFrameIntervalMs;
3590 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07003591 WaitForEncodedFrame(timestamp_ms);
asaperssonf7e294d2017-06-13 23:25:22 -07003592 VerifyFpsMaxResolutionEq(source.sink_wants(), source.last_wants());
3593 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution);
3594 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_framerate);
3595 EXPECT_TRUE(stats_proxy_->GetStats().cpu_limited_resolution);
3596 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_framerate);
3597 EXPECT_EQ(3, stats_proxy_->GetStats().number_of_cpu_adapt_changes);
3598 EXPECT_EQ(1, stats_proxy_->GetStats().number_of_quality_adapt_changes);
3599
3600 // Trigger quality adapt up, expect upscaled resolution (960x540@30fps).
mflodmancc3d4422017-08-03 08:27:51 -07003601 video_stream_encoder_->TriggerQualityHigh();
asaperssonf7e294d2017-06-13 23:25:22 -07003602 timestamp_ms += kFrameIntervalMs;
3603 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07003604 WaitForEncodedFrame(timestamp_ms);
asaperssonf7e294d2017-06-13 23:25:22 -07003605 VerifyFpsMaxResolutionGt(source.sink_wants(), source.last_wants());
3606 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution);
3607 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_framerate);
3608 EXPECT_TRUE(stats_proxy_->GetStats().cpu_limited_resolution);
3609 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_framerate);
3610 EXPECT_EQ(3, stats_proxy_->GetStats().number_of_cpu_adapt_changes);
3611 EXPECT_EQ(2, stats_proxy_->GetStats().number_of_quality_adapt_changes);
3612
3613 // Trigger cpu adapt up, expect no restriction (1280x720fps@30fps).
mflodmancc3d4422017-08-03 08:27:51 -07003614 video_stream_encoder_->TriggerCpuNormalUsage();
asaperssonf7e294d2017-06-13 23:25:22 -07003615 timestamp_ms += kFrameIntervalMs;
3616 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07003617 WaitForEncodedFrame(kWidth, kHeight);
asaperssonf7e294d2017-06-13 23:25:22 -07003618 VerifyFpsMaxResolutionGt(source.sink_wants(), source.last_wants());
Åsa Persson8c1bf952018-09-13 10:42:19 +02003619 VerifyFpsMaxResolutionMax(source.sink_wants());
asaperssonf7e294d2017-06-13 23:25:22 -07003620 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution);
3621 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_framerate);
3622 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_resolution);
3623 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_framerate);
3624 EXPECT_EQ(4, stats_proxy_->GetStats().number_of_cpu_adapt_changes);
3625 EXPECT_EQ(2, stats_proxy_->GetStats().number_of_quality_adapt_changes);
3626
3627 // Trigger adapt up, expect no change.
mflodmancc3d4422017-08-03 08:27:51 -07003628 video_stream_encoder_->TriggerQualityHigh();
Åsa Persson8c1bf952018-09-13 10:42:19 +02003629 VerifyFpsMaxResolutionMax(source.sink_wants());
asaperssonf7e294d2017-06-13 23:25:22 -07003630 EXPECT_EQ(4, stats_proxy_->GetStats().number_of_cpu_adapt_changes);
3631 EXPECT_EQ(2, stats_proxy_->GetStats().number_of_quality_adapt_changes);
3632
mflodmancc3d4422017-08-03 08:27:51 -07003633 video_stream_encoder_->Stop();
asaperssonf7e294d2017-06-13 23:25:22 -07003634}
3635
mflodmancc3d4422017-08-03 08:27:51 -07003636TEST_F(VideoStreamEncoderTest,
3637 AdaptWithTwoReasonsAndDifferentOrder_Resolution) {
asaperssonf7e294d2017-06-13 23:25:22 -07003638 const int kWidth = 640;
3639 const int kHeight = 360;
3640 const int kFpsLimit = 15;
3641 const int64_t kFrameIntervalMs = 150;
3642 int64_t timestamp_ms = kFrameIntervalMs;
Erik Språng4c6ca302019-04-08 15:14:01 +02003643 video_stream_encoder_->OnBitrateUpdated(
3644 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
asaperssonf7e294d2017-06-13 23:25:22 -07003645
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07003646 // Enable BALANCED preference, no initial limitation.
asaperssonf7e294d2017-06-13 23:25:22 -07003647 AdaptingFrameForwarder source;
3648 source.set_adaptation_enabled(true);
Taylor Brandstetter49fcc102018-05-16 14:20:41 -07003649 video_stream_encoder_->SetSource(&source,
3650 webrtc::DegradationPreference::BALANCED);
asaperssonf7e294d2017-06-13 23:25:22 -07003651 timestamp_ms += kFrameIntervalMs;
3652 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07003653 WaitForEncodedFrame(kWidth, kHeight);
Åsa Persson8c1bf952018-09-13 10:42:19 +02003654 VerifyFpsMaxResolutionMax(source.sink_wants());
asaperssonf7e294d2017-06-13 23:25:22 -07003655 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution);
3656 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_framerate);
3657 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_resolution);
3658 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_framerate);
3659 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_cpu_adapt_changes);
3660 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_quality_adapt_changes);
3661
3662 // Trigger cpu adapt down, expect scaled down framerate (640x360@15fps).
mflodmancc3d4422017-08-03 08:27:51 -07003663 video_stream_encoder_->TriggerCpuOveruse();
asaperssonf7e294d2017-06-13 23:25:22 -07003664 timestamp_ms += kFrameIntervalMs;
3665 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07003666 WaitForEncodedFrame(timestamp_ms);
asaperssonf7e294d2017-06-13 23:25:22 -07003667 VerifyFpsEqResolutionMax(source.sink_wants(), kFpsLimit);
3668 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution);
3669 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_framerate);
3670 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_resolution);
3671 EXPECT_TRUE(stats_proxy_->GetStats().cpu_limited_framerate);
3672 EXPECT_EQ(1, stats_proxy_->GetStats().number_of_cpu_adapt_changes);
3673 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_quality_adapt_changes);
3674
3675 // Trigger quality adapt down, expect scaled down resolution (480x270@15fps).
mflodmancc3d4422017-08-03 08:27:51 -07003676 video_stream_encoder_->TriggerQualityLow();
asaperssonf7e294d2017-06-13 23:25:22 -07003677 timestamp_ms += kFrameIntervalMs;
3678 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07003679 WaitForEncodedFrame(timestamp_ms);
asaperssonf7e294d2017-06-13 23:25:22 -07003680 VerifyFpsEqResolutionLt(source.sink_wants(), source.last_wants());
3681 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution);
3682 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_framerate);
3683 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_resolution);
3684 EXPECT_TRUE(stats_proxy_->GetStats().cpu_limited_framerate);
3685 EXPECT_EQ(1, stats_proxy_->GetStats().number_of_cpu_adapt_changes);
3686 EXPECT_EQ(1, stats_proxy_->GetStats().number_of_quality_adapt_changes);
3687
3688 // Trigger cpu adapt up, expect upscaled resolution (640x360@15fps).
mflodmancc3d4422017-08-03 08:27:51 -07003689 video_stream_encoder_->TriggerCpuNormalUsage();
asaperssonf7e294d2017-06-13 23:25:22 -07003690 timestamp_ms += kFrameIntervalMs;
3691 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07003692 WaitForEncodedFrame(timestamp_ms);
asaperssonf7e294d2017-06-13 23:25:22 -07003693 VerifyFpsEqResolutionGt(source.sink_wants(), source.last_wants());
3694 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution);
3695 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_framerate);
3696 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_resolution);
3697 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_framerate);
3698 EXPECT_EQ(2, stats_proxy_->GetStats().number_of_cpu_adapt_changes);
3699 EXPECT_EQ(1, stats_proxy_->GetStats().number_of_quality_adapt_changes);
3700
3701 // Trigger quality adapt up, expect increased fps (640x360@30fps).
mflodmancc3d4422017-08-03 08:27:51 -07003702 video_stream_encoder_->TriggerQualityHigh();
asaperssonf7e294d2017-06-13 23:25:22 -07003703 timestamp_ms += kFrameIntervalMs;
3704 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight));
sprang4847ae62017-06-27 07:06:52 -07003705 WaitForEncodedFrame(timestamp_ms);
Åsa Persson8c1bf952018-09-13 10:42:19 +02003706 VerifyFpsMaxResolutionMax(source.sink_wants());
asaperssonf7e294d2017-06-13 23:25:22 -07003707 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution);
3708 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_framerate);
3709 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_resolution);
3710 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_framerate);
3711 EXPECT_EQ(2, stats_proxy_->GetStats().number_of_cpu_adapt_changes);
3712 EXPECT_EQ(2, stats_proxy_->GetStats().number_of_quality_adapt_changes);
3713
3714 // Trigger adapt up, expect no change.
mflodmancc3d4422017-08-03 08:27:51 -07003715 video_stream_encoder_->TriggerQualityHigh();
Åsa Persson8c1bf952018-09-13 10:42:19 +02003716 VerifyFpsMaxResolutionMax(source.sink_wants());
asaperssonf7e294d2017-06-13 23:25:22 -07003717 EXPECT_EQ(2, stats_proxy_->GetStats().number_of_cpu_adapt_changes);
3718 EXPECT_EQ(2, stats_proxy_->GetStats().number_of_quality_adapt_changes);
3719
mflodmancc3d4422017-08-03 08:27:51 -07003720 video_stream_encoder_->Stop();
asaperssonf7e294d2017-06-13 23:25:22 -07003721}
3722
mflodmancc3d4422017-08-03 08:27:51 -07003723TEST_F(VideoStreamEncoderTest, AcceptsFullHdAdaptedDownSimulcastFrames) {
ilnik6b826ef2017-06-16 06:53:48 -07003724 const int kFrameWidth = 1920;
3725 const int kFrameHeight = 1080;
3726 // 3/4 of 1920.
3727 const int kAdaptedFrameWidth = 1440;
3728 // 3/4 of 1080 rounded down to multiple of 4.
3729 const int kAdaptedFrameHeight = 808;
3730 const int kFramerate = 24;
3731
Erik Språng4c6ca302019-04-08 15:14:01 +02003732 video_stream_encoder_->OnBitrateUpdated(
3733 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
ilnik6b826ef2017-06-16 06:53:48 -07003734 // Trigger reconfigure encoder (without resetting the entire instance).
3735 VideoEncoderConfig video_encoder_config;
Niels Möller259a4972018-04-05 15:36:51 +02003736 video_encoder_config.codec_type = kVideoCodecVP8;
ilnik6b826ef2017-06-16 06:53:48 -07003737 video_encoder_config.max_bitrate_bps = kTargetBitrateBps;
3738 video_encoder_config.number_of_streams = 1;
3739 video_encoder_config.video_stream_factory =
3740 new rtc::RefCountedObject<CroppingVideoStreamFactory>(1, kFramerate);
mflodmancc3d4422017-08-03 08:27:51 -07003741 video_stream_encoder_->ConfigureEncoder(std::move(video_encoder_config),
Niels Möllerf1338562018-04-26 09:51:47 +02003742 kMaxPayloadLength);
mflodmancc3d4422017-08-03 08:27:51 -07003743 video_stream_encoder_->WaitUntilTaskQueueIsIdle();
ilnik6b826ef2017-06-16 06:53:48 -07003744
3745 video_source_.set_adaptation_enabled(true);
3746
3747 video_source_.IncomingCapturedFrame(
3748 CreateFrame(1, kFrameWidth, kFrameHeight));
sprang4847ae62017-06-27 07:06:52 -07003749 WaitForEncodedFrame(kFrameWidth, kFrameHeight);
ilnik6b826ef2017-06-16 06:53:48 -07003750
3751 // Trigger CPU overuse, downscale by 3/4.
mflodmancc3d4422017-08-03 08:27:51 -07003752 video_stream_encoder_->TriggerCpuOveruse();
ilnik6b826ef2017-06-16 06:53:48 -07003753 video_source_.IncomingCapturedFrame(
3754 CreateFrame(2, kFrameWidth, kFrameHeight));
sprang4847ae62017-06-27 07:06:52 -07003755 WaitForEncodedFrame(kAdaptedFrameWidth, kAdaptedFrameHeight);
ilnik6b826ef2017-06-16 06:53:48 -07003756
mflodmancc3d4422017-08-03 08:27:51 -07003757 video_stream_encoder_->Stop();
ilnik6b826ef2017-06-16 06:53:48 -07003758}
3759
mflodmancc3d4422017-08-03 08:27:51 -07003760TEST_F(VideoStreamEncoderTest, PeriodicallyUpdatesChannelParameters) {
sprang4847ae62017-06-27 07:06:52 -07003761 const int kFrameWidth = 1280;
3762 const int kFrameHeight = 720;
3763 const int kLowFps = 2;
3764 const int kHighFps = 30;
3765
Erik Språng4c6ca302019-04-08 15:14:01 +02003766 video_stream_encoder_->OnBitrateUpdated(
3767 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
sprang4847ae62017-06-27 07:06:52 -07003768
3769 int64_t timestamp_ms = fake_clock_.TimeNanos() / rtc::kNumNanosecsPerMillisec;
3770 max_framerate_ = kLowFps;
3771
3772 // Insert 2 seconds of 2fps video.
3773 for (int i = 0; i < kLowFps * 2; ++i) {
3774 video_source_.IncomingCapturedFrame(
3775 CreateFrame(timestamp_ms, kFrameWidth, kFrameHeight));
3776 WaitForEncodedFrame(timestamp_ms);
3777 timestamp_ms += 1000 / kLowFps;
3778 }
3779
3780 // Make sure encoder is updated with new target.
Erik Språng4c6ca302019-04-08 15:14:01 +02003781 video_stream_encoder_->OnBitrateUpdated(
3782 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
sprang4847ae62017-06-27 07:06:52 -07003783 video_source_.IncomingCapturedFrame(
3784 CreateFrame(timestamp_ms, kFrameWidth, kFrameHeight));
3785 WaitForEncodedFrame(timestamp_ms);
3786 timestamp_ms += 1000 / kLowFps;
3787
3788 EXPECT_EQ(kLowFps, fake_encoder_.GetConfiguredInputFramerate());
3789
3790 // Insert 30fps frames for just a little more than the forced update period.
3791 const int kVcmTimerIntervalFrames =
3792 (vcm::VCMProcessTimer::kDefaultProcessIntervalMs * kHighFps) / 1000;
3793 const int kFrameIntervalMs = 1000 / kHighFps;
3794 max_framerate_ = kHighFps;
3795 for (int i = 0; i < kVcmTimerIntervalFrames + 2; ++i) {
3796 video_source_.IncomingCapturedFrame(
3797 CreateFrame(timestamp_ms, kFrameWidth, kFrameHeight));
3798 // Wait for encoded frame, but skip ahead if it doesn't arrive as it might
3799 // be dropped if the encoder hans't been updated with the new higher target
3800 // framerate yet, causing it to overshoot the target bitrate and then
3801 // suffering the wrath of the media optimizer.
3802 TimedWaitForEncodedFrame(timestamp_ms, 2 * kFrameIntervalMs);
3803 timestamp_ms += kFrameIntervalMs;
3804 }
3805
3806 // Don expect correct measurement just yet, but it should be higher than
3807 // before.
3808 EXPECT_GT(fake_encoder_.GetConfiguredInputFramerate(), kLowFps);
3809
mflodmancc3d4422017-08-03 08:27:51 -07003810 video_stream_encoder_->Stop();
sprang4847ae62017-06-27 07:06:52 -07003811}
3812
mflodmancc3d4422017-08-03 08:27:51 -07003813TEST_F(VideoStreamEncoderTest, DoesNotUpdateBitrateAllocationWhenSuspended) {
sprang4847ae62017-06-27 07:06:52 -07003814 const int kFrameWidth = 1280;
3815 const int kFrameHeight = 720;
3816 const int kTargetBitrateBps = 1000000;
3817
3818 MockBitrateObserver bitrate_observer;
Niels Möller0327c2d2018-05-21 14:09:31 +02003819 video_stream_encoder_->SetBitrateAllocationObserver(&bitrate_observer);
Erik Språng4c6ca302019-04-08 15:14:01 +02003820 video_stream_encoder_->OnBitrateUpdated(
3821 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
mflodmancc3d4422017-08-03 08:27:51 -07003822 video_stream_encoder_->WaitUntilTaskQueueIsIdle();
sprang4847ae62017-06-27 07:06:52 -07003823
3824 // Insert a first video frame, causes another bitrate update.
3825 int64_t timestamp_ms = fake_clock_.TimeNanos() / rtc::kNumNanosecsPerMillisec;
3826 EXPECT_CALL(bitrate_observer, OnBitrateAllocationUpdated(_)).Times(1);
3827 video_source_.IncomingCapturedFrame(
3828 CreateFrame(timestamp_ms, kFrameWidth, kFrameHeight));
3829 WaitForEncodedFrame(timestamp_ms);
3830
3831 // Next, simulate video suspension due to pacer queue overrun.
Erik Språng4c6ca302019-04-08 15:14:01 +02003832 video_stream_encoder_->OnBitrateUpdated(DataRate::bps(0), DataRate::bps(0), 0,
Erik Språng610c7632019-03-06 15:37:33 +01003833 1);
sprang4847ae62017-06-27 07:06:52 -07003834
3835 // Skip ahead until a new periodic parameter update should have occured.
3836 timestamp_ms += vcm::VCMProcessTimer::kDefaultProcessIntervalMs;
Sebastian Jansson40889f32019-04-17 12:11:20 +02003837 fake_clock_.AdvanceTime(
3838 TimeDelta::ms(vcm::VCMProcessTimer::kDefaultProcessIntervalMs));
sprang4847ae62017-06-27 07:06:52 -07003839
3840 // Bitrate observer should not be called.
3841 EXPECT_CALL(bitrate_observer, OnBitrateAllocationUpdated(_)).Times(0);
3842 video_source_.IncomingCapturedFrame(
3843 CreateFrame(timestamp_ms, kFrameWidth, kFrameHeight));
3844 ExpectDroppedFrame();
3845
mflodmancc3d4422017-08-03 08:27:51 -07003846 video_stream_encoder_->Stop();
sprang4847ae62017-06-27 07:06:52 -07003847}
ilnik6b826ef2017-06-16 06:53:48 -07003848
Niels Möller4db138e2018-04-19 09:04:13 +02003849TEST_F(VideoStreamEncoderTest,
3850 DefaultCpuAdaptationThresholdsForSoftwareEncoder) {
3851 const int kFrameWidth = 1280;
3852 const int kFrameHeight = 720;
3853 const CpuOveruseOptions default_options;
Erik Språng4c6ca302019-04-08 15:14:01 +02003854 video_stream_encoder_->OnBitrateUpdated(
3855 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
Niels Möller4db138e2018-04-19 09:04:13 +02003856 video_source_.IncomingCapturedFrame(
3857 CreateFrame(1, kFrameWidth, kFrameHeight));
3858 WaitForEncodedFrame(1);
3859 EXPECT_EQ(video_stream_encoder_->overuse_detector_proxy_->GetOptions()
3860 .low_encode_usage_threshold_percent,
3861 default_options.low_encode_usage_threshold_percent);
3862 EXPECT_EQ(video_stream_encoder_->overuse_detector_proxy_->GetOptions()
3863 .high_encode_usage_threshold_percent,
3864 default_options.high_encode_usage_threshold_percent);
3865 video_stream_encoder_->Stop();
3866}
3867
3868TEST_F(VideoStreamEncoderTest,
3869 HigherCpuAdaptationThresholdsForHardwareEncoder) {
3870 const int kFrameWidth = 1280;
3871 const int kFrameHeight = 720;
3872 CpuOveruseOptions hardware_options;
3873 hardware_options.low_encode_usage_threshold_percent = 150;
3874 hardware_options.high_encode_usage_threshold_percent = 200;
Mirta Dvornicicccc1b572019-01-15 12:42:18 +01003875 fake_encoder_.SetIsHardwareAccelerated(true);
Niels Möller4db138e2018-04-19 09:04:13 +02003876
Erik Språng4c6ca302019-04-08 15:14:01 +02003877 video_stream_encoder_->OnBitrateUpdated(
3878 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
Niels Möller4db138e2018-04-19 09:04:13 +02003879 video_source_.IncomingCapturedFrame(
3880 CreateFrame(1, kFrameWidth, kFrameHeight));
3881 WaitForEncodedFrame(1);
3882 EXPECT_EQ(video_stream_encoder_->overuse_detector_proxy_->GetOptions()
3883 .low_encode_usage_threshold_percent,
3884 hardware_options.low_encode_usage_threshold_percent);
3885 EXPECT_EQ(video_stream_encoder_->overuse_detector_proxy_->GetOptions()
3886 .high_encode_usage_threshold_percent,
3887 hardware_options.high_encode_usage_threshold_percent);
3888 video_stream_encoder_->Stop();
3889}
3890
Niels Möller6bb5ab92019-01-11 11:11:10 +01003891TEST_F(VideoStreamEncoderTest, DropsFramesWhenEncoderOvershoots) {
3892 const int kFrameWidth = 320;
3893 const int kFrameHeight = 240;
3894 const int kFps = 30;
3895 const int kTargetBitrateBps = 120000;
3896 const int kNumFramesInRun = kFps * 5; // Runs of five seconds.
3897
Erik Språng4c6ca302019-04-08 15:14:01 +02003898 video_stream_encoder_->OnBitrateUpdated(
3899 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
Niels Möller6bb5ab92019-01-11 11:11:10 +01003900
3901 int64_t timestamp_ms = fake_clock_.TimeNanos() / rtc::kNumNanosecsPerMillisec;
3902 max_framerate_ = kFps;
3903
3904 // Insert 3 seconds of video, verify number of drops with normal bitrate.
3905 fake_encoder_.SimulateOvershoot(1.0);
3906 int num_dropped = 0;
3907 for (int i = 0; i < kNumFramesInRun; ++i) {
3908 video_source_.IncomingCapturedFrame(
3909 CreateFrame(timestamp_ms, kFrameWidth, kFrameHeight));
3910 // Wait up to two frame durations for a frame to arrive.
3911 if (!TimedWaitForEncodedFrame(timestamp_ms, 2 * 1000 / kFps)) {
3912 ++num_dropped;
3913 }
3914 timestamp_ms += 1000 / kFps;
3915 }
3916
Erik Språnga8d48ab2019-02-08 14:17:40 +01003917 // Framerate should be measured to be near the expected target rate.
3918 EXPECT_NEAR(fake_encoder_.GetLastFramerate(), kFps, 1);
3919
3920 // Frame drops should be within 5% of expected 0%.
3921 EXPECT_NEAR(num_dropped, 0, 5 * kNumFramesInRun / 100);
Niels Möller6bb5ab92019-01-11 11:11:10 +01003922
3923 // Make encoder produce frames at double the expected bitrate during 3 seconds
3924 // of video, verify number of drops. Rate needs to be slightly changed in
3925 // order to force the rate to be reconfigured.
Erik Språng7ca375c2019-02-06 16:20:17 +01003926 double overshoot_factor = 2.0;
3927 if (RateControlSettings::ParseFromFieldTrials().UseEncoderBitrateAdjuster()) {
3928 // With bitrate adjuster, when need to overshoot even more to trigger
3929 // frame dropping.
3930 overshoot_factor *= 2;
3931 }
3932 fake_encoder_.SimulateOvershoot(overshoot_factor);
Erik Språng610c7632019-03-06 15:37:33 +01003933 video_stream_encoder_->OnBitrateUpdated(
Erik Språng4c6ca302019-04-08 15:14:01 +02003934 DataRate::bps(kTargetBitrateBps + 1000),
3935 DataRate::bps(kTargetBitrateBps + 1000), 0, 0);
Niels Möller6bb5ab92019-01-11 11:11:10 +01003936 num_dropped = 0;
3937 for (int i = 0; i < kNumFramesInRun; ++i) {
3938 video_source_.IncomingCapturedFrame(
3939 CreateFrame(timestamp_ms, kFrameWidth, kFrameHeight));
3940 // Wait up to two frame durations for a frame to arrive.
3941 if (!TimedWaitForEncodedFrame(timestamp_ms, 2 * 1000 / kFps)) {
3942 ++num_dropped;
3943 }
3944 timestamp_ms += 1000 / kFps;
3945 }
3946
Erik Språng4c6ca302019-04-08 15:14:01 +02003947 video_stream_encoder_->OnBitrateUpdated(
3948 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
Erik Språnga8d48ab2019-02-08 14:17:40 +01003949
3950 // Target framerate should be still be near the expected target, despite
3951 // the frame drops.
3952 EXPECT_NEAR(fake_encoder_.GetLastFramerate(), kFps, 1);
3953
3954 // Frame drops should be within 5% of expected 50%.
3955 EXPECT_NEAR(num_dropped, kNumFramesInRun / 2, 5 * kNumFramesInRun / 100);
Niels Möller6bb5ab92019-01-11 11:11:10 +01003956
3957 video_stream_encoder_->Stop();
3958}
3959
3960TEST_F(VideoStreamEncoderTest, ConfiguresCorrectFrameRate) {
3961 const int kFrameWidth = 320;
3962 const int kFrameHeight = 240;
3963 const int kActualInputFps = 24;
3964 const int kTargetBitrateBps = 120000;
3965
3966 ASSERT_GT(max_framerate_, kActualInputFps);
3967
3968 int64_t timestamp_ms = fake_clock_.TimeNanos() / rtc::kNumNanosecsPerMillisec;
3969 max_framerate_ = kActualInputFps;
Erik Språng4c6ca302019-04-08 15:14:01 +02003970 video_stream_encoder_->OnBitrateUpdated(
3971 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
Niels Möller6bb5ab92019-01-11 11:11:10 +01003972
3973 // Insert 3 seconds of video, with an input fps lower than configured max.
3974 for (int i = 0; i < kActualInputFps * 3; ++i) {
3975 video_source_.IncomingCapturedFrame(
3976 CreateFrame(timestamp_ms, kFrameWidth, kFrameHeight));
3977 // Wait up to two frame durations for a frame to arrive.
3978 WaitForEncodedFrame(timestamp_ms);
3979 timestamp_ms += 1000 / kActualInputFps;
3980 }
3981
3982 EXPECT_NEAR(kActualInputFps, fake_encoder_.GetLastFramerate(), 1);
3983
3984 video_stream_encoder_->Stop();
3985}
3986
Ilya Nikolaevskiy71aee3a2019-02-18 13:01:26 +01003987TEST_F(VideoStreamEncoderTest, AccumulatesUpdateRectOnDroppedFrames) {
3988 VideoFrame::UpdateRect rect;
Erik Språng4c6ca302019-04-08 15:14:01 +02003989 video_stream_encoder_->OnBitrateUpdated(
3990 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
Ilya Nikolaevskiy71aee3a2019-02-18 13:01:26 +01003991
3992 fake_encoder_.BlockNextEncode();
3993 video_source_.IncomingCapturedFrame(
3994 CreateFrameWithUpdatedPixel(1, nullptr, 0));
3995 WaitForEncodedFrame(1);
3996 // On the very first frame full update should be forced.
3997 rect = fake_encoder_.GetLastUpdateRect();
3998 EXPECT_EQ(rect.offset_x, 0);
3999 EXPECT_EQ(rect.offset_y, 0);
4000 EXPECT_EQ(rect.height, codec_height_);
4001 EXPECT_EQ(rect.width, codec_width_);
4002 // Here, the encoder thread will be blocked in the TestEncoder waiting for a
4003 // call to ContinueEncode.
4004 video_source_.IncomingCapturedFrame(
4005 CreateFrameWithUpdatedPixel(2, nullptr, 1));
4006 ExpectDroppedFrame();
4007 video_source_.IncomingCapturedFrame(
4008 CreateFrameWithUpdatedPixel(3, nullptr, 10));
4009 ExpectDroppedFrame();
4010 fake_encoder_.ContinueEncode();
4011 WaitForEncodedFrame(3);
4012 // Updates to pixels 1 and 10 should be accumulated to one 10x1 rect.
4013 rect = fake_encoder_.GetLastUpdateRect();
4014 EXPECT_EQ(rect.offset_x, 1);
4015 EXPECT_EQ(rect.offset_y, 0);
4016 EXPECT_EQ(rect.width, 10);
4017 EXPECT_EQ(rect.height, 1);
4018
4019 video_source_.IncomingCapturedFrame(
4020 CreateFrameWithUpdatedPixel(4, nullptr, 0));
4021 WaitForEncodedFrame(4);
4022 // Previous frame was encoded, so no accumulation should happen.
4023 rect = fake_encoder_.GetLastUpdateRect();
4024 EXPECT_EQ(rect.offset_x, 0);
4025 EXPECT_EQ(rect.offset_y, 0);
4026 EXPECT_EQ(rect.width, 1);
4027 EXPECT_EQ(rect.height, 1);
4028
4029 video_stream_encoder_->Stop();
4030}
4031
Erik Språngd7329ca2019-02-21 21:19:53 +01004032TEST_F(VideoStreamEncoderTest, SetsFrameTypes) {
Erik Språng4c6ca302019-04-08 15:14:01 +02004033 video_stream_encoder_->OnBitrateUpdated(
4034 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
Erik Språngd7329ca2019-02-21 21:19:53 +01004035
4036 // First frame is always keyframe.
4037 video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr));
4038 WaitForEncodedFrame(1);
Niels Möller8f7ce222019-03-21 15:43:58 +01004039 EXPECT_THAT(
4040 fake_encoder_.LastFrameTypes(),
Mirko Bonadei6a489f22019-04-09 15:11:12 +02004041 ::testing::ElementsAre(VideoFrameType{VideoFrameType::kVideoFrameKey}));
Erik Språngd7329ca2019-02-21 21:19:53 +01004042
4043 // Insert delta frame.
4044 video_source_.IncomingCapturedFrame(CreateFrame(2, nullptr));
4045 WaitForEncodedFrame(2);
Niels Möller8f7ce222019-03-21 15:43:58 +01004046 EXPECT_THAT(
4047 fake_encoder_.LastFrameTypes(),
Mirko Bonadei6a489f22019-04-09 15:11:12 +02004048 ::testing::ElementsAre(VideoFrameType{VideoFrameType::kVideoFrameDelta}));
Erik Språngd7329ca2019-02-21 21:19:53 +01004049
4050 // Request next frame be a key-frame.
4051 video_stream_encoder_->SendKeyFrame();
4052 video_source_.IncomingCapturedFrame(CreateFrame(3, nullptr));
4053 WaitForEncodedFrame(3);
Niels Möller8f7ce222019-03-21 15:43:58 +01004054 EXPECT_THAT(
4055 fake_encoder_.LastFrameTypes(),
Mirko Bonadei6a489f22019-04-09 15:11:12 +02004056 ::testing::ElementsAre(VideoFrameType{VideoFrameType::kVideoFrameKey}));
Erik Språngd7329ca2019-02-21 21:19:53 +01004057
4058 video_stream_encoder_->Stop();
4059}
4060
4061TEST_F(VideoStreamEncoderTest, SetsFrameTypesSimulcast) {
4062 // Setup simulcast with three streams.
4063 ResetEncoder("VP8", 3, 1, 1, false);
Erik Språng610c7632019-03-06 15:37:33 +01004064 video_stream_encoder_->OnBitrateUpdated(
Erik Språng4c6ca302019-04-08 15:14:01 +02004065 DataRate::bps(kSimulcastTargetBitrateBps),
4066 DataRate::bps(kSimulcastTargetBitrateBps), 0, 0);
Erik Språngd7329ca2019-02-21 21:19:53 +01004067 // Wait for all three layers before triggering event.
4068 sink_.SetNumExpectedLayers(3);
4069
4070 // First frame is always keyframe.
4071 video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr));
4072 WaitForEncodedFrame(1);
4073 EXPECT_THAT(fake_encoder_.LastFrameTypes(),
Mirko Bonadei6a489f22019-04-09 15:11:12 +02004074 ::testing::ElementsAreArray({VideoFrameType::kVideoFrameKey,
4075 VideoFrameType::kVideoFrameKey,
4076 VideoFrameType::kVideoFrameKey}));
Erik Språngd7329ca2019-02-21 21:19:53 +01004077
4078 // Insert delta frame.
4079 video_source_.IncomingCapturedFrame(CreateFrame(2, nullptr));
4080 WaitForEncodedFrame(2);
4081 EXPECT_THAT(fake_encoder_.LastFrameTypes(),
Mirko Bonadei6a489f22019-04-09 15:11:12 +02004082 ::testing::ElementsAreArray({VideoFrameType::kVideoFrameDelta,
4083 VideoFrameType::kVideoFrameDelta,
4084 VideoFrameType::kVideoFrameDelta}));
Erik Språngd7329ca2019-02-21 21:19:53 +01004085
4086 // Request next frame be a key-frame.
4087 // Only first stream is configured to produce key-frame.
4088 video_stream_encoder_->SendKeyFrame();
4089 video_source_.IncomingCapturedFrame(CreateFrame(3, nullptr));
4090 WaitForEncodedFrame(3);
Sergey Silkine62a08a2019-05-13 13:45:39 +02004091
4092 // TODO(webrtc:10615): Map keyframe request to spatial layer. Currently
4093 // keyframe request on any layer triggers keyframe on all layers.
Erik Språngd7329ca2019-02-21 21:19:53 +01004094 EXPECT_THAT(fake_encoder_.LastFrameTypes(),
Mirko Bonadei6a489f22019-04-09 15:11:12 +02004095 ::testing::ElementsAreArray({VideoFrameType::kVideoFrameKey,
Sergey Silkine62a08a2019-05-13 13:45:39 +02004096 VideoFrameType::kVideoFrameKey,
4097 VideoFrameType::kVideoFrameKey}));
Erik Språngd7329ca2019-02-21 21:19:53 +01004098
4099 video_stream_encoder_->Stop();
4100}
4101
4102TEST_F(VideoStreamEncoderTest, RequestKeyframeInternalSource) {
4103 // Configure internal source factory and setup test again.
4104 encoder_factory_.SetHasInternalSource(true);
4105 ResetEncoder("VP8", 1, 1, 1, false);
Erik Språng4c6ca302019-04-08 15:14:01 +02004106 video_stream_encoder_->OnBitrateUpdated(
4107 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
Erik Språngd7329ca2019-02-21 21:19:53 +01004108
4109 // Call encoder directly, simulating internal source where encoded frame
4110 // callback in VideoStreamEncoder is called despite no OnFrame().
4111 fake_encoder_.InjectFrame(CreateFrame(1, nullptr), true);
4112 EXPECT_TRUE(WaitForFrame(kDefaultTimeoutMs));
Niels Möller8f7ce222019-03-21 15:43:58 +01004113 EXPECT_THAT(
4114 fake_encoder_.LastFrameTypes(),
Mirko Bonadei6a489f22019-04-09 15:11:12 +02004115 ::testing::ElementsAre(VideoFrameType{VideoFrameType::kVideoFrameKey}));
Erik Språngd7329ca2019-02-21 21:19:53 +01004116
Niels Möller8f7ce222019-03-21 15:43:58 +01004117 const std::vector<VideoFrameType> kDeltaFrame = {
4118 VideoFrameType::kVideoFrameDelta};
Erik Språngd7329ca2019-02-21 21:19:53 +01004119 // Need to set timestamp manually since manually for injected frame.
4120 VideoFrame frame = CreateFrame(101, nullptr);
4121 frame.set_timestamp(101);
4122 fake_encoder_.InjectFrame(frame, false);
4123 EXPECT_TRUE(WaitForFrame(kDefaultTimeoutMs));
Niels Möller8f7ce222019-03-21 15:43:58 +01004124 EXPECT_THAT(
4125 fake_encoder_.LastFrameTypes(),
Mirko Bonadei6a489f22019-04-09 15:11:12 +02004126 ::testing::ElementsAre(VideoFrameType{VideoFrameType::kVideoFrameDelta}));
Erik Språngd7329ca2019-02-21 21:19:53 +01004127
4128 // Request key-frame. The forces a dummy frame down into the encoder.
4129 fake_encoder_.ExpectNullFrame();
4130 video_stream_encoder_->SendKeyFrame();
4131 EXPECT_TRUE(WaitForFrame(kDefaultTimeoutMs));
Niels Möller8f7ce222019-03-21 15:43:58 +01004132 EXPECT_THAT(
4133 fake_encoder_.LastFrameTypes(),
Mirko Bonadei6a489f22019-04-09 15:11:12 +02004134 ::testing::ElementsAre(VideoFrameType{VideoFrameType::kVideoFrameKey}));
Erik Språngd7329ca2019-02-21 21:19:53 +01004135
4136 video_stream_encoder_->Stop();
4137}
Erik Språngb7cb7b52019-02-26 15:52:33 +01004138
4139TEST_F(VideoStreamEncoderTest, AdjustsTimestampInternalSource) {
4140 // Configure internal source factory and setup test again.
4141 encoder_factory_.SetHasInternalSource(true);
4142 ResetEncoder("VP8", 1, 1, 1, false);
Erik Språng4c6ca302019-04-08 15:14:01 +02004143 video_stream_encoder_->OnBitrateUpdated(
4144 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
Erik Språngb7cb7b52019-02-26 15:52:33 +01004145
4146 int64_t timestamp = 1;
4147 EncodedImage image;
Niels Möller4d504c72019-06-18 15:56:56 +02004148 image.SetEncodedData(
4149 EncodedImageBuffer::Create(kTargetBitrateBps / kDefaultFramerate / 8));
Erik Språngb7cb7b52019-02-26 15:52:33 +01004150 image.capture_time_ms_ = ++timestamp;
4151 image.SetTimestamp(static_cast<uint32_t>(timestamp * 90));
4152 const int64_t kEncodeFinishDelayMs = 10;
4153 image.timing_.encode_start_ms = timestamp;
4154 image.timing_.encode_finish_ms = timestamp + kEncodeFinishDelayMs;
4155 fake_encoder_.InjectEncodedImage(image);
4156 // Wait for frame without incrementing clock.
4157 EXPECT_TRUE(sink_.WaitForFrame(kDefaultTimeoutMs));
4158 // Frame is captured kEncodeFinishDelayMs before it's encoded, so restored
4159 // capture timestamp should be kEncodeFinishDelayMs in the past.
4160 EXPECT_EQ(sink_.GetLastCaptureTimeMs(),
4161 fake_clock_.TimeNanos() / rtc::kNumNanosecsPerMillisec -
4162 kEncodeFinishDelayMs);
4163
4164 video_stream_encoder_->Stop();
4165}
Mirta Dvornicic28f0eb22019-05-28 16:30:16 +02004166
4167TEST_F(VideoStreamEncoderTest, DoesNotRewriteH264BitstreamWithOptimalSps) {
4168 // Configure internal source factory and setup test again.
4169 encoder_factory_.SetHasInternalSource(true);
4170 ResetEncoder("H264", 1, 1, 1, false);
4171
4172 EncodedImage image(optimal_sps, sizeof(optimal_sps), sizeof(optimal_sps));
4173 image._frameType = VideoFrameType::kVideoFrameKey;
4174
4175 CodecSpecificInfo codec_specific_info;
4176 codec_specific_info.codecType = kVideoCodecH264;
4177
4178 RTPFragmentationHeader fragmentation;
4179 fragmentation.VerifyAndAllocateFragmentationHeader(1);
4180 fragmentation.fragmentationOffset[0] = 4;
4181 fragmentation.fragmentationLength[0] = sizeof(optimal_sps) - 4;
4182
4183 fake_encoder_.InjectEncodedImage(image, &codec_specific_info, &fragmentation);
4184 EXPECT_TRUE(sink_.WaitForFrame(kDefaultTimeoutMs));
4185
4186 EXPECT_THAT(sink_.GetLastEncodedImageData(),
4187 testing::ElementsAreArray(optimal_sps));
4188 RTPFragmentationHeader last_fragmentation = sink_.GetLastFragmentation();
4189 ASSERT_THAT(last_fragmentation.fragmentationVectorSize, 1U);
4190 EXPECT_EQ(last_fragmentation.fragmentationOffset[0], 4U);
4191 EXPECT_EQ(last_fragmentation.fragmentationLength[0], sizeof(optimal_sps) - 4);
4192
4193 video_stream_encoder_->Stop();
4194}
4195
4196TEST_F(VideoStreamEncoderTest, RewritesH264BitstreamWithNonOptimalSps) {
4197 uint8_t original_sps[] = {0, 0, 0, 1, H264::NaluType::kSps,
4198 0x00, 0x00, 0x03, 0x03, 0xF4,
4199 0x05, 0x03, 0xC7, 0xC0};
4200
4201 // Configure internal source factory and setup test again.
4202 encoder_factory_.SetHasInternalSource(true);
4203 ResetEncoder("H264", 1, 1, 1, false);
4204
4205 EncodedImage image(original_sps, sizeof(original_sps), sizeof(original_sps));
4206 image._frameType = VideoFrameType::kVideoFrameKey;
4207
4208 CodecSpecificInfo codec_specific_info;
4209 codec_specific_info.codecType = kVideoCodecH264;
4210
4211 RTPFragmentationHeader fragmentation;
4212 fragmentation.VerifyAndAllocateFragmentationHeader(1);
4213 fragmentation.fragmentationOffset[0] = 4;
4214 fragmentation.fragmentationLength[0] = sizeof(original_sps) - 4;
4215
4216 fake_encoder_.InjectEncodedImage(image, &codec_specific_info, &fragmentation);
4217 EXPECT_TRUE(sink_.WaitForFrame(kDefaultTimeoutMs));
4218
4219 EXPECT_THAT(sink_.GetLastEncodedImageData(),
4220 testing::ElementsAreArray(optimal_sps));
4221 RTPFragmentationHeader last_fragmentation = sink_.GetLastFragmentation();
4222 ASSERT_THAT(last_fragmentation.fragmentationVectorSize, 1U);
4223 EXPECT_EQ(last_fragmentation.fragmentationOffset[0], 4U);
4224 EXPECT_EQ(last_fragmentation.fragmentationLength[0], sizeof(optimal_sps) - 4);
4225
4226 video_stream_encoder_->Stop();
4227}
4228
Ilya Nikolaevskiyba96e2f2019-06-04 15:15:14 +02004229TEST_F(VideoStreamEncoderTest, CopiesVideoFrameMetadataAfterDownscale) {
4230 const int kFrameWidth = 1280;
4231 const int kFrameHeight = 720;
4232 const int kTargetBitrateBps = 300000; // To low for HD resolution.
4233
4234 video_stream_encoder_->OnBitrateUpdated(
4235 DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
4236 video_stream_encoder_->WaitUntilTaskQueueIsIdle();
4237
4238 // Insert a first video frame. It should be dropped because of downscale in
4239 // resolution.
4240 int64_t timestamp_ms = fake_clock_.TimeNanos() / rtc::kNumNanosecsPerMillisec;
4241 VideoFrame frame = CreateFrame(timestamp_ms, kFrameWidth, kFrameHeight);
4242 frame.set_rotation(kVideoRotation_270);
4243 video_source_.IncomingCapturedFrame(frame);
4244
4245 ExpectDroppedFrame();
4246
4247 // Second frame is downscaled.
4248 timestamp_ms = fake_clock_.TimeNanos() / rtc::kNumNanosecsPerMillisec;
4249 frame = CreateFrame(timestamp_ms, kFrameWidth / 2, kFrameHeight / 2);
4250 frame.set_rotation(kVideoRotation_90);
4251 video_source_.IncomingCapturedFrame(frame);
4252
4253 WaitForEncodedFrame(timestamp_ms);
4254 sink_.CheckLastFrameRotationMatches(kVideoRotation_90);
4255
4256 // Insert another frame, also downscaled.
4257 timestamp_ms = fake_clock_.TimeNanos() / rtc::kNumNanosecsPerMillisec;
4258 frame = CreateFrame(timestamp_ms, kFrameWidth / 2, kFrameHeight / 2);
4259 frame.set_rotation(kVideoRotation_180);
4260 video_source_.IncomingCapturedFrame(frame);
4261
4262 WaitForEncodedFrame(timestamp_ms);
4263 sink_.CheckLastFrameRotationMatches(kVideoRotation_180);
4264
4265 video_stream_encoder_->Stop();
4266}
4267
perkj26091b12016-09-01 01:17:40 -07004268} // namespace webrtc