OLD | NEW |
| (Empty) |
1 /* | |
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 | |
11 #include <algorithm> | |
12 #include <limits> | |
13 #include <utility> | |
14 | |
15 #include "webrtc/api/video/i420_buffer.h" | |
16 #include "webrtc/media/base/videoadapter.h" | |
17 #include "webrtc/modules/video_coding/codecs/vp8/temporal_layers.h" | |
18 #include "webrtc/modules/video_coding/utility/default_video_bitrate_allocator.h" | |
19 #include "webrtc/rtc_base/fakeclock.h" | |
20 #include "webrtc/rtc_base/logging.h" | |
21 #include "webrtc/system_wrappers/include/metrics_default.h" | |
22 #include "webrtc/system_wrappers/include/sleep.h" | |
23 #include "webrtc/test/encoder_settings.h" | |
24 #include "webrtc/test/fake_encoder.h" | |
25 #include "webrtc/test/frame_generator.h" | |
26 #include "webrtc/test/gmock.h" | |
27 #include "webrtc/test/gtest.h" | |
28 #include "webrtc/video/send_statistics_proxy.h" | |
29 #include "webrtc/video/vie_encoder.h" | |
30 | |
31 namespace { | |
32 // TODO(kthelgason): Lower this limit when better testing | |
33 // on MediaCodec and fallback implementations are in place. | |
34 const int kMinPixelsPerFrame = 320 * 180; | |
35 const int kMinFramerateFps = 2; | |
36 const int64_t kFrameTimeoutMs = 100; | |
37 } // namespace | |
38 | |
39 namespace webrtc { | |
40 | |
41 using DegredationPreference = VideoSendStream::DegradationPreference; | |
42 using ScaleReason = AdaptationObserverInterface::AdaptReason; | |
43 using ::testing::_; | |
44 using ::testing::Return; | |
45 | |
46 namespace { | |
47 const size_t kMaxPayloadLength = 1440; | |
48 const int kTargetBitrateBps = 1000000; | |
49 const int kLowTargetBitrateBps = kTargetBitrateBps / 10; | |
50 const int kMaxInitialFramedrop = 4; | |
51 const int kDefaultFramerate = 30; | |
52 | |
53 class TestBuffer : public webrtc::I420Buffer { | |
54 public: | |
55 TestBuffer(rtc::Event* event, int width, int height) | |
56 : I420Buffer(width, height), event_(event) {} | |
57 | |
58 private: | |
59 friend class rtc::RefCountedObject<TestBuffer>; | |
60 ~TestBuffer() override { | |
61 if (event_) | |
62 event_->Set(); | |
63 } | |
64 rtc::Event* const event_; | |
65 }; | |
66 | |
67 class CpuOveruseDetectorProxy : public OveruseFrameDetector { | |
68 public: | |
69 CpuOveruseDetectorProxy(const CpuOveruseOptions& options, | |
70 AdaptationObserverInterface* overuse_observer, | |
71 EncodedFrameObserver* encoder_timing_, | |
72 CpuOveruseMetricsObserver* metrics_observer) | |
73 : OveruseFrameDetector(options, | |
74 overuse_observer, | |
75 encoder_timing_, | |
76 metrics_observer), | |
77 last_target_framerate_fps_(-1) {} | |
78 virtual ~CpuOveruseDetectorProxy() {} | |
79 | |
80 void OnTargetFramerateUpdated(int framerate_fps) override { | |
81 rtc::CritScope cs(&lock_); | |
82 last_target_framerate_fps_ = framerate_fps; | |
83 OveruseFrameDetector::OnTargetFramerateUpdated(framerate_fps); | |
84 } | |
85 | |
86 int GetLastTargetFramerate() { | |
87 rtc::CritScope cs(&lock_); | |
88 return last_target_framerate_fps_; | |
89 } | |
90 | |
91 private: | |
92 rtc::CriticalSection lock_; | |
93 int last_target_framerate_fps_ GUARDED_BY(lock_); | |
94 }; | |
95 | |
96 class ViEEncoderUnderTest : public ViEEncoder { | |
97 public: | |
98 ViEEncoderUnderTest(SendStatisticsProxy* stats_proxy, | |
99 const VideoSendStream::Config::EncoderSettings& settings) | |
100 : ViEEncoder(1 /* number_of_cores */, | |
101 stats_proxy, | |
102 settings, | |
103 nullptr /* pre_encode_callback */, | |
104 nullptr /* encoder_timing */, | |
105 std::unique_ptr<OveruseFrameDetector>( | |
106 overuse_detector_proxy_ = new CpuOveruseDetectorProxy( | |
107 GetCpuOveruseOptions(settings.full_overuse_time), | |
108 this, | |
109 nullptr, | |
110 stats_proxy))) {} | |
111 | |
112 void PostTaskAndWait(bool down, AdaptReason reason) { | |
113 rtc::Event event(false, false); | |
114 encoder_queue()->PostTask([this, &event, reason, down] { | |
115 down ? AdaptDown(reason) : AdaptUp(reason); | |
116 event.Set(); | |
117 }); | |
118 ASSERT_TRUE(event.Wait(5000)); | |
119 } | |
120 | |
121 // This is used as a synchronisation mechanism, to make sure that the | |
122 // encoder queue is not blocked before we start sending it frames. | |
123 void WaitUntilTaskQueueIsIdle() { | |
124 rtc::Event event(false, false); | |
125 encoder_queue()->PostTask([&event] { | |
126 event.Set(); | |
127 }); | |
128 ASSERT_TRUE(event.Wait(5000)); | |
129 } | |
130 | |
131 void TriggerCpuOveruse() { PostTaskAndWait(true, AdaptReason::kCpu); } | |
132 | |
133 void TriggerCpuNormalUsage() { PostTaskAndWait(false, AdaptReason::kCpu); } | |
134 | |
135 void TriggerQualityLow() { PostTaskAndWait(true, AdaptReason::kQuality); } | |
136 | |
137 void TriggerQualityHigh() { PostTaskAndWait(false, AdaptReason::kQuality); } | |
138 | |
139 CpuOveruseDetectorProxy* overuse_detector_proxy_; | |
140 }; | |
141 | |
142 class VideoStreamFactory | |
143 : public VideoEncoderConfig::VideoStreamFactoryInterface { | |
144 public: | |
145 explicit VideoStreamFactory(size_t num_temporal_layers, int framerate) | |
146 : num_temporal_layers_(num_temporal_layers), framerate_(framerate) { | |
147 EXPECT_GT(num_temporal_layers, 0u); | |
148 EXPECT_GT(framerate, 0); | |
149 } | |
150 | |
151 private: | |
152 std::vector<VideoStream> CreateEncoderStreams( | |
153 int width, | |
154 int height, | |
155 const VideoEncoderConfig& encoder_config) override { | |
156 std::vector<VideoStream> streams = | |
157 test::CreateVideoStreams(width, height, encoder_config); | |
158 for (VideoStream& stream : streams) { | |
159 stream.temporal_layer_thresholds_bps.resize(num_temporal_layers_ - 1); | |
160 stream.max_framerate = framerate_; | |
161 } | |
162 return streams; | |
163 } | |
164 | |
165 const size_t num_temporal_layers_; | |
166 const int framerate_; | |
167 }; | |
168 | |
169 | |
170 class AdaptingFrameForwarder : public test::FrameForwarder { | |
171 public: | |
172 AdaptingFrameForwarder() : adaptation_enabled_(false) {} | |
173 ~AdaptingFrameForwarder() override {} | |
174 | |
175 void set_adaptation_enabled(bool enabled) { | |
176 rtc::CritScope cs(&crit_); | |
177 adaptation_enabled_ = enabled; | |
178 } | |
179 | |
180 bool adaption_enabled() const { | |
181 rtc::CritScope cs(&crit_); | |
182 return adaptation_enabled_; | |
183 } | |
184 | |
185 rtc::VideoSinkWants last_wants() const { | |
186 rtc::CritScope cs(&crit_); | |
187 return last_wants_; | |
188 } | |
189 | |
190 void IncomingCapturedFrame(const VideoFrame& video_frame) override { | |
191 int cropped_width = 0; | |
192 int cropped_height = 0; | |
193 int out_width = 0; | |
194 int out_height = 0; | |
195 if (adaption_enabled()) { | |
196 if (adapter_.AdaptFrameResolution( | |
197 video_frame.width(), video_frame.height(), | |
198 video_frame.timestamp_us() * 1000, &cropped_width, | |
199 &cropped_height, &out_width, &out_height)) { | |
200 VideoFrame adapted_frame(new rtc::RefCountedObject<TestBuffer>( | |
201 nullptr, out_width, out_height), | |
202 99, 99, kVideoRotation_0); | |
203 adapted_frame.set_ntp_time_ms(video_frame.ntp_time_ms()); | |
204 test::FrameForwarder::IncomingCapturedFrame(adapted_frame); | |
205 } | |
206 } else { | |
207 test::FrameForwarder::IncomingCapturedFrame(video_frame); | |
208 } | |
209 } | |
210 | |
211 void AddOrUpdateSink(rtc::VideoSinkInterface<VideoFrame>* sink, | |
212 const rtc::VideoSinkWants& wants) override { | |
213 rtc::CritScope cs(&crit_); | |
214 last_wants_ = sink_wants(); | |
215 adapter_.OnResolutionFramerateRequest(wants.target_pixel_count, | |
216 wants.max_pixel_count, | |
217 wants.max_framerate_fps); | |
218 test::FrameForwarder::AddOrUpdateSink(sink, wants); | |
219 } | |
220 cricket::VideoAdapter adapter_; | |
221 bool adaptation_enabled_ GUARDED_BY(crit_); | |
222 rtc::VideoSinkWants last_wants_ GUARDED_BY(crit_); | |
223 }; | |
224 | |
225 class MockableSendStatisticsProxy : public SendStatisticsProxy { | |
226 public: | |
227 MockableSendStatisticsProxy(Clock* clock, | |
228 const VideoSendStream::Config& config, | |
229 VideoEncoderConfig::ContentType content_type) | |
230 : SendStatisticsProxy(clock, config, content_type) {} | |
231 | |
232 VideoSendStream::Stats GetStats() override { | |
233 rtc::CritScope cs(&lock_); | |
234 if (mock_stats_) | |
235 return *mock_stats_; | |
236 return SendStatisticsProxy::GetStats(); | |
237 } | |
238 | |
239 void SetMockStats(const VideoSendStream::Stats& stats) { | |
240 rtc::CritScope cs(&lock_); | |
241 mock_stats_.emplace(stats); | |
242 } | |
243 | |
244 void ResetMockStats() { | |
245 rtc::CritScope cs(&lock_); | |
246 mock_stats_.reset(); | |
247 } | |
248 | |
249 private: | |
250 rtc::CriticalSection lock_; | |
251 rtc::Optional<VideoSendStream::Stats> mock_stats_ GUARDED_BY(lock_); | |
252 }; | |
253 | |
254 class MockBitrateObserver : public VideoBitrateAllocationObserver { | |
255 public: | |
256 MOCK_METHOD1(OnBitrateAllocationUpdated, void(const BitrateAllocation&)); | |
257 }; | |
258 | |
259 } // namespace | |
260 | |
261 class ViEEncoderTest : public ::testing::Test { | |
262 public: | |
263 static const int kDefaultTimeoutMs = 30 * 1000; | |
264 | |
265 ViEEncoderTest() | |
266 : video_send_config_(VideoSendStream::Config(nullptr)), | |
267 codec_width_(320), | |
268 codec_height_(240), | |
269 max_framerate_(30), | |
270 fake_encoder_(), | |
271 stats_proxy_(new MockableSendStatisticsProxy( | |
272 Clock::GetRealTimeClock(), | |
273 video_send_config_, | |
274 webrtc::VideoEncoderConfig::ContentType::kRealtimeVideo)), | |
275 sink_(&fake_encoder_) {} | |
276 | |
277 void SetUp() override { | |
278 metrics::Reset(); | |
279 video_send_config_ = VideoSendStream::Config(nullptr); | |
280 video_send_config_.encoder_settings.encoder = &fake_encoder_; | |
281 video_send_config_.encoder_settings.payload_name = "FAKE"; | |
282 video_send_config_.encoder_settings.payload_type = 125; | |
283 | |
284 VideoEncoderConfig video_encoder_config; | |
285 test::FillEncoderConfiguration(1, &video_encoder_config); | |
286 video_encoder_config.video_stream_factory = | |
287 new rtc::RefCountedObject<VideoStreamFactory>(1, max_framerate_); | |
288 video_encoder_config_ = video_encoder_config.Copy(); | |
289 | |
290 // Framerate limit is specified by the VideoStreamFactory. | |
291 std::vector<VideoStream> streams = | |
292 video_encoder_config.video_stream_factory->CreateEncoderStreams( | |
293 codec_width_, codec_height_, video_encoder_config); | |
294 max_framerate_ = streams[0].max_framerate; | |
295 fake_clock_.SetTimeMicros(1234); | |
296 | |
297 ConfigureEncoder(std::move(video_encoder_config), true /* nack_enabled */); | |
298 } | |
299 | |
300 void ConfigureEncoder(VideoEncoderConfig video_encoder_config, | |
301 bool nack_enabled) { | |
302 if (vie_encoder_) | |
303 vie_encoder_->Stop(); | |
304 vie_encoder_.reset(new ViEEncoderUnderTest( | |
305 stats_proxy_.get(), video_send_config_.encoder_settings)); | |
306 vie_encoder_->SetSink(&sink_, false /* rotation_applied */); | |
307 vie_encoder_->SetSource( | |
308 &video_source_, | |
309 VideoSendStream::DegradationPreference::kMaintainFramerate); | |
310 vie_encoder_->SetStartBitrate(kTargetBitrateBps); | |
311 vie_encoder_->ConfigureEncoder(std::move(video_encoder_config), | |
312 kMaxPayloadLength, nack_enabled); | |
313 vie_encoder_->WaitUntilTaskQueueIsIdle(); | |
314 } | |
315 | |
316 void ResetEncoder(const std::string& payload_name, | |
317 size_t num_streams, | |
318 size_t num_temporal_layers, | |
319 bool nack_enabled, | |
320 bool screenshare) { | |
321 video_send_config_.encoder_settings.payload_name = payload_name; | |
322 | |
323 VideoEncoderConfig video_encoder_config; | |
324 video_encoder_config.number_of_streams = num_streams; | |
325 video_encoder_config.max_bitrate_bps = kTargetBitrateBps; | |
326 video_encoder_config.video_stream_factory = | |
327 new rtc::RefCountedObject<VideoStreamFactory>(num_temporal_layers, | |
328 kDefaultFramerate); | |
329 video_encoder_config.content_type = | |
330 screenshare ? VideoEncoderConfig::ContentType::kScreen | |
331 : VideoEncoderConfig::ContentType::kRealtimeVideo; | |
332 ConfigureEncoder(std::move(video_encoder_config), nack_enabled); | |
333 } | |
334 | |
335 VideoFrame CreateFrame(int64_t ntp_time_ms, | |
336 rtc::Event* destruction_event) const { | |
337 VideoFrame frame(new rtc::RefCountedObject<TestBuffer>( | |
338 destruction_event, codec_width_, codec_height_), | |
339 99, 99, kVideoRotation_0); | |
340 frame.set_ntp_time_ms(ntp_time_ms); | |
341 return frame; | |
342 } | |
343 | |
344 VideoFrame CreateFrame(int64_t ntp_time_ms, int width, int height) const { | |
345 VideoFrame frame( | |
346 new rtc::RefCountedObject<TestBuffer>(nullptr, width, height), 99, 99, | |
347 kVideoRotation_0); | |
348 frame.set_ntp_time_ms(ntp_time_ms); | |
349 frame.set_timestamp_us(ntp_time_ms * 1000); | |
350 return frame; | |
351 } | |
352 | |
353 void VerifyNoLimitation(const rtc::VideoSinkWants& wants) { | |
354 EXPECT_EQ(std::numeric_limits<int>::max(), wants.max_framerate_fps); | |
355 EXPECT_EQ(std::numeric_limits<int>::max(), wants.max_pixel_count); | |
356 EXPECT_FALSE(wants.target_pixel_count); | |
357 } | |
358 | |
359 void VerifyFpsEqResolutionEq(const rtc::VideoSinkWants& wants1, | |
360 const rtc::VideoSinkWants& wants2) { | |
361 EXPECT_EQ(wants1.max_framerate_fps, wants2.max_framerate_fps); | |
362 EXPECT_EQ(wants1.max_pixel_count, wants2.max_pixel_count); | |
363 } | |
364 | |
365 void VerifyFpsMaxResolutionLt(const rtc::VideoSinkWants& wants1, | |
366 const rtc::VideoSinkWants& wants2) { | |
367 EXPECT_EQ(std::numeric_limits<int>::max(), wants1.max_framerate_fps); | |
368 EXPECT_LT(wants1.max_pixel_count, wants2.max_pixel_count); | |
369 EXPECT_GT(wants1.max_pixel_count, 0); | |
370 } | |
371 | |
372 void VerifyFpsMaxResolutionGt(const rtc::VideoSinkWants& wants1, | |
373 const rtc::VideoSinkWants& wants2) { | |
374 EXPECT_EQ(std::numeric_limits<int>::max(), wants1.max_framerate_fps); | |
375 EXPECT_GT(wants1.max_pixel_count, wants2.max_pixel_count); | |
376 } | |
377 | |
378 void VerifyFpsMaxResolutionEq(const rtc::VideoSinkWants& wants1, | |
379 const rtc::VideoSinkWants& wants2) { | |
380 EXPECT_EQ(std::numeric_limits<int>::max(), wants1.max_framerate_fps); | |
381 EXPECT_EQ(wants1.max_pixel_count, wants2.max_pixel_count); | |
382 } | |
383 | |
384 void VerifyFpsLtResolutionEq(const rtc::VideoSinkWants& wants1, | |
385 const rtc::VideoSinkWants& wants2) { | |
386 EXPECT_LT(wants1.max_framerate_fps, wants2.max_framerate_fps); | |
387 EXPECT_EQ(wants1.max_pixel_count, wants2.max_pixel_count); | |
388 } | |
389 | |
390 void VerifyFpsGtResolutionEq(const rtc::VideoSinkWants& wants1, | |
391 const rtc::VideoSinkWants& wants2) { | |
392 EXPECT_GT(wants1.max_framerate_fps, wants2.max_framerate_fps); | |
393 EXPECT_EQ(wants1.max_pixel_count, wants2.max_pixel_count); | |
394 } | |
395 | |
396 void VerifyFpsEqResolutionLt(const rtc::VideoSinkWants& wants1, | |
397 const rtc::VideoSinkWants& wants2) { | |
398 EXPECT_EQ(wants1.max_framerate_fps, wants2.max_framerate_fps); | |
399 EXPECT_LT(wants1.max_pixel_count, wants2.max_pixel_count); | |
400 EXPECT_GT(wants1.max_pixel_count, 0); | |
401 } | |
402 | |
403 void VerifyFpsEqResolutionGt(const rtc::VideoSinkWants& wants1, | |
404 const rtc::VideoSinkWants& wants2) { | |
405 EXPECT_EQ(wants1.max_framerate_fps, wants2.max_framerate_fps); | |
406 EXPECT_GT(wants1.max_pixel_count, wants2.max_pixel_count); | |
407 } | |
408 | |
409 void VerifyFpsMaxResolutionLt(const rtc::VideoSinkWants& wants, | |
410 int pixel_count) { | |
411 EXPECT_EQ(std::numeric_limits<int>::max(), wants.max_framerate_fps); | |
412 EXPECT_LT(wants.max_pixel_count, pixel_count); | |
413 EXPECT_GT(wants.max_pixel_count, 0); | |
414 } | |
415 | |
416 void VerifyFpsLtResolutionMax(const rtc::VideoSinkWants& wants, int fps) { | |
417 EXPECT_LT(wants.max_framerate_fps, fps); | |
418 EXPECT_EQ(std::numeric_limits<int>::max(), wants.max_pixel_count); | |
419 EXPECT_FALSE(wants.target_pixel_count); | |
420 } | |
421 | |
422 void VerifyFpsEqResolutionMax(const rtc::VideoSinkWants& wants, | |
423 int expected_fps) { | |
424 EXPECT_EQ(expected_fps, wants.max_framerate_fps); | |
425 EXPECT_EQ(std::numeric_limits<int>::max(), wants.max_pixel_count); | |
426 EXPECT_FALSE(wants.target_pixel_count); | |
427 } | |
428 | |
429 void WaitForEncodedFrame(int64_t expected_ntp_time) { | |
430 sink_.WaitForEncodedFrame(expected_ntp_time); | |
431 fake_clock_.AdvanceTimeMicros(rtc::kNumMicrosecsPerSec / max_framerate_); | |
432 } | |
433 | |
434 bool TimedWaitForEncodedFrame(int64_t expected_ntp_time, int64_t timeout_ms) { | |
435 bool ok = sink_.TimedWaitForEncodedFrame(expected_ntp_time, timeout_ms); | |
436 fake_clock_.AdvanceTimeMicros(rtc::kNumMicrosecsPerSec / max_framerate_); | |
437 return ok; | |
438 } | |
439 | |
440 void WaitForEncodedFrame(uint32_t expected_width, uint32_t expected_height) { | |
441 sink_.WaitForEncodedFrame(expected_width, expected_height); | |
442 fake_clock_.AdvanceTimeMicros(rtc::kNumMicrosecsPerSec / max_framerate_); | |
443 } | |
444 | |
445 void ExpectDroppedFrame() { | |
446 sink_.ExpectDroppedFrame(); | |
447 fake_clock_.AdvanceTimeMicros(rtc::kNumMicrosecsPerSec / max_framerate_); | |
448 } | |
449 | |
450 bool WaitForFrame(int64_t timeout_ms) { | |
451 bool ok = sink_.WaitForFrame(timeout_ms); | |
452 fake_clock_.AdvanceTimeMicros(rtc::kNumMicrosecsPerSec / max_framerate_); | |
453 return ok; | |
454 } | |
455 | |
456 class TestEncoder : public test::FakeEncoder { | |
457 public: | |
458 TestEncoder() | |
459 : FakeEncoder(Clock::GetRealTimeClock()), | |
460 continue_encode_event_(false, false) {} | |
461 | |
462 VideoCodec codec_config() const { | |
463 rtc::CritScope lock(&crit_sect_); | |
464 return config_; | |
465 } | |
466 | |
467 void BlockNextEncode() { | |
468 rtc::CritScope lock(&local_crit_sect_); | |
469 block_next_encode_ = true; | |
470 } | |
471 | |
472 VideoEncoder::ScalingSettings GetScalingSettings() const override { | |
473 rtc::CritScope lock(&local_crit_sect_); | |
474 if (quality_scaling_) | |
475 return VideoEncoder::ScalingSettings(true, 1, 2); | |
476 return VideoEncoder::ScalingSettings(false); | |
477 } | |
478 | |
479 void ContinueEncode() { continue_encode_event_.Set(); } | |
480 | |
481 void CheckLastTimeStampsMatch(int64_t ntp_time_ms, | |
482 uint32_t timestamp) const { | |
483 rtc::CritScope lock(&local_crit_sect_); | |
484 EXPECT_EQ(timestamp_, timestamp); | |
485 EXPECT_EQ(ntp_time_ms_, ntp_time_ms); | |
486 } | |
487 | |
488 void SetQualityScaling(bool b) { | |
489 rtc::CritScope lock(&local_crit_sect_); | |
490 quality_scaling_ = b; | |
491 } | |
492 | |
493 void ForceInitEncodeFailure(bool force_failure) { | |
494 rtc::CritScope lock(&local_crit_sect_); | |
495 force_init_encode_failed_ = force_failure; | |
496 } | |
497 | |
498 private: | |
499 int32_t Encode(const VideoFrame& input_image, | |
500 const CodecSpecificInfo* codec_specific_info, | |
501 const std::vector<FrameType>* frame_types) override { | |
502 bool block_encode; | |
503 { | |
504 rtc::CritScope lock(&local_crit_sect_); | |
505 EXPECT_GT(input_image.timestamp(), timestamp_); | |
506 EXPECT_GT(input_image.ntp_time_ms(), ntp_time_ms_); | |
507 EXPECT_EQ(input_image.timestamp(), input_image.ntp_time_ms() * 90); | |
508 | |
509 timestamp_ = input_image.timestamp(); | |
510 ntp_time_ms_ = input_image.ntp_time_ms(); | |
511 last_input_width_ = input_image.width(); | |
512 last_input_height_ = input_image.height(); | |
513 block_encode = block_next_encode_; | |
514 block_next_encode_ = false; | |
515 } | |
516 int32_t result = | |
517 FakeEncoder::Encode(input_image, codec_specific_info, frame_types); | |
518 if (block_encode) | |
519 EXPECT_TRUE(continue_encode_event_.Wait(kDefaultTimeoutMs)); | |
520 return result; | |
521 } | |
522 | |
523 int32_t InitEncode(const VideoCodec* config, | |
524 int32_t number_of_cores, | |
525 size_t max_payload_size) override { | |
526 int res = | |
527 FakeEncoder::InitEncode(config, number_of_cores, max_payload_size); | |
528 rtc::CritScope lock(&local_crit_sect_); | |
529 if (config->codecType == kVideoCodecVP8 && config->VP8().tl_factory) { | |
530 // Simulate setting up temporal layers, in order to validate the life | |
531 // cycle of these objects. | |
532 int num_streams = std::max<int>(1, config->numberOfSimulcastStreams); | |
533 int num_temporal_layers = | |
534 std::max<int>(1, config->VP8().numberOfTemporalLayers); | |
535 for (int i = 0; i < num_streams; ++i) { | |
536 allocated_temporal_layers_.emplace_back( | |
537 config->VP8().tl_factory->Create(i, num_temporal_layers, 42)); | |
538 } | |
539 } | |
540 if (force_init_encode_failed_) | |
541 return -1; | |
542 return res; | |
543 } | |
544 | |
545 rtc::CriticalSection local_crit_sect_; | |
546 bool block_next_encode_ GUARDED_BY(local_crit_sect_) = false; | |
547 rtc::Event continue_encode_event_; | |
548 uint32_t timestamp_ GUARDED_BY(local_crit_sect_) = 0; | |
549 int64_t ntp_time_ms_ GUARDED_BY(local_crit_sect_) = 0; | |
550 int last_input_width_ GUARDED_BY(local_crit_sect_) = 0; | |
551 int last_input_height_ GUARDED_BY(local_crit_sect_) = 0; | |
552 bool quality_scaling_ GUARDED_BY(local_crit_sect_) = true; | |
553 std::vector<std::unique_ptr<TemporalLayers>> allocated_temporal_layers_ | |
554 GUARDED_BY(local_crit_sect_); | |
555 bool force_init_encode_failed_ GUARDED_BY(local_crit_sect_) = false; | |
556 }; | |
557 | |
558 class TestSink : public ViEEncoder::EncoderSink { | |
559 public: | |
560 explicit TestSink(TestEncoder* test_encoder) | |
561 : test_encoder_(test_encoder), encoded_frame_event_(false, false) {} | |
562 | |
563 void WaitForEncodedFrame(int64_t expected_ntp_time) { | |
564 EXPECT_TRUE( | |
565 TimedWaitForEncodedFrame(expected_ntp_time, kDefaultTimeoutMs)); | |
566 } | |
567 | |
568 bool TimedWaitForEncodedFrame(int64_t expected_ntp_time, | |
569 int64_t timeout_ms) { | |
570 uint32_t timestamp = 0; | |
571 if (!encoded_frame_event_.Wait(timeout_ms)) | |
572 return false; | |
573 { | |
574 rtc::CritScope lock(&crit_); | |
575 timestamp = last_timestamp_; | |
576 } | |
577 test_encoder_->CheckLastTimeStampsMatch(expected_ntp_time, timestamp); | |
578 return true; | |
579 } | |
580 | |
581 void WaitForEncodedFrame(uint32_t expected_width, | |
582 uint32_t expected_height) { | |
583 EXPECT_TRUE(encoded_frame_event_.Wait(kDefaultTimeoutMs)); | |
584 CheckLastFrameSizeMathces(expected_width, expected_height); | |
585 } | |
586 | |
587 void CheckLastFrameSizeMathces(uint32_t expected_width, | |
588 uint32_t expected_height) { | |
589 uint32_t width = 0; | |
590 uint32_t height = 0; | |
591 { | |
592 rtc::CritScope lock(&crit_); | |
593 width = last_width_; | |
594 height = last_height_; | |
595 } | |
596 EXPECT_EQ(expected_height, height); | |
597 EXPECT_EQ(expected_width, width); | |
598 } | |
599 | |
600 void ExpectDroppedFrame() { EXPECT_FALSE(encoded_frame_event_.Wait(100)); } | |
601 | |
602 bool WaitForFrame(int64_t timeout_ms) { | |
603 return encoded_frame_event_.Wait(timeout_ms); | |
604 } | |
605 | |
606 void SetExpectNoFrames() { | |
607 rtc::CritScope lock(&crit_); | |
608 expect_frames_ = false; | |
609 } | |
610 | |
611 int number_of_reconfigurations() const { | |
612 rtc::CritScope lock(&crit_); | |
613 return number_of_reconfigurations_; | |
614 } | |
615 | |
616 int last_min_transmit_bitrate() const { | |
617 rtc::CritScope lock(&crit_); | |
618 return min_transmit_bitrate_bps_; | |
619 } | |
620 | |
621 private: | |
622 Result OnEncodedImage( | |
623 const EncodedImage& encoded_image, | |
624 const CodecSpecificInfo* codec_specific_info, | |
625 const RTPFragmentationHeader* fragmentation) override { | |
626 rtc::CritScope lock(&crit_); | |
627 EXPECT_TRUE(expect_frames_); | |
628 last_timestamp_ = encoded_image._timeStamp; | |
629 last_width_ = encoded_image._encodedWidth; | |
630 last_height_ = encoded_image._encodedHeight; | |
631 encoded_frame_event_.Set(); | |
632 return Result(Result::OK, last_timestamp_); | |
633 } | |
634 | |
635 void OnEncoderConfigurationChanged(std::vector<VideoStream> streams, | |
636 int min_transmit_bitrate_bps) override { | |
637 rtc::CriticalSection crit_; | |
638 ++number_of_reconfigurations_; | |
639 min_transmit_bitrate_bps_ = min_transmit_bitrate_bps; | |
640 } | |
641 | |
642 rtc::CriticalSection crit_; | |
643 TestEncoder* test_encoder_; | |
644 rtc::Event encoded_frame_event_; | |
645 uint32_t last_timestamp_ = 0; | |
646 uint32_t last_height_ = 0; | |
647 uint32_t last_width_ = 0; | |
648 bool expect_frames_ = true; | |
649 int number_of_reconfigurations_ = 0; | |
650 int min_transmit_bitrate_bps_ = 0; | |
651 }; | |
652 | |
653 VideoSendStream::Config video_send_config_; | |
654 VideoEncoderConfig video_encoder_config_; | |
655 int codec_width_; | |
656 int codec_height_; | |
657 int max_framerate_; | |
658 TestEncoder fake_encoder_; | |
659 std::unique_ptr<MockableSendStatisticsProxy> stats_proxy_; | |
660 TestSink sink_; | |
661 AdaptingFrameForwarder video_source_; | |
662 std::unique_ptr<ViEEncoderUnderTest> vie_encoder_; | |
663 rtc::ScopedFakeClock fake_clock_; | |
664 }; | |
665 | |
666 TEST_F(ViEEncoderTest, EncodeOneFrame) { | |
667 vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0); | |
668 rtc::Event frame_destroyed_event(false, false); | |
669 video_source_.IncomingCapturedFrame(CreateFrame(1, &frame_destroyed_event)); | |
670 WaitForEncodedFrame(1); | |
671 EXPECT_TRUE(frame_destroyed_event.Wait(kDefaultTimeoutMs)); | |
672 vie_encoder_->Stop(); | |
673 } | |
674 | |
675 TEST_F(ViEEncoderTest, DropsFramesBeforeFirstOnBitrateUpdated) { | |
676 // Dropped since no target bitrate has been set. | |
677 rtc::Event frame_destroyed_event(false, false); | |
678 video_source_.IncomingCapturedFrame(CreateFrame(1, &frame_destroyed_event)); | |
679 EXPECT_TRUE(frame_destroyed_event.Wait(kDefaultTimeoutMs)); | |
680 | |
681 vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0); | |
682 | |
683 video_source_.IncomingCapturedFrame(CreateFrame(2, nullptr)); | |
684 WaitForEncodedFrame(2); | |
685 vie_encoder_->Stop(); | |
686 } | |
687 | |
688 TEST_F(ViEEncoderTest, DropsFramesWhenRateSetToZero) { | |
689 vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0); | |
690 video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr)); | |
691 WaitForEncodedFrame(1); | |
692 | |
693 vie_encoder_->OnBitrateUpdated(0, 0, 0); | |
694 // Dropped since bitrate is zero. | |
695 video_source_.IncomingCapturedFrame(CreateFrame(2, nullptr)); | |
696 | |
697 vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0); | |
698 video_source_.IncomingCapturedFrame(CreateFrame(3, nullptr)); | |
699 WaitForEncodedFrame(3); | |
700 vie_encoder_->Stop(); | |
701 } | |
702 | |
703 TEST_F(ViEEncoderTest, DropsFramesWithSameOrOldNtpTimestamp) { | |
704 vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0); | |
705 video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr)); | |
706 WaitForEncodedFrame(1); | |
707 | |
708 // This frame will be dropped since it has the same ntp timestamp. | |
709 video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr)); | |
710 | |
711 video_source_.IncomingCapturedFrame(CreateFrame(2, nullptr)); | |
712 WaitForEncodedFrame(2); | |
713 vie_encoder_->Stop(); | |
714 } | |
715 | |
716 TEST_F(ViEEncoderTest, DropsFrameAfterStop) { | |
717 vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0); | |
718 | |
719 video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr)); | |
720 WaitForEncodedFrame(1); | |
721 | |
722 vie_encoder_->Stop(); | |
723 sink_.SetExpectNoFrames(); | |
724 rtc::Event frame_destroyed_event(false, false); | |
725 video_source_.IncomingCapturedFrame(CreateFrame(2, &frame_destroyed_event)); | |
726 EXPECT_TRUE(frame_destroyed_event.Wait(kDefaultTimeoutMs)); | |
727 } | |
728 | |
729 TEST_F(ViEEncoderTest, DropsPendingFramesOnSlowEncode) { | |
730 vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0); | |
731 | |
732 fake_encoder_.BlockNextEncode(); | |
733 video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr)); | |
734 WaitForEncodedFrame(1); | |
735 // Here, the encoder thread will be blocked in the TestEncoder waiting for a | |
736 // call to ContinueEncode. | |
737 video_source_.IncomingCapturedFrame(CreateFrame(2, nullptr)); | |
738 video_source_.IncomingCapturedFrame(CreateFrame(3, nullptr)); | |
739 fake_encoder_.ContinueEncode(); | |
740 WaitForEncodedFrame(3); | |
741 | |
742 vie_encoder_->Stop(); | |
743 } | |
744 | |
745 TEST_F(ViEEncoderTest, ConfigureEncoderTriggersOnEncoderConfigurationChanged) { | |
746 vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0); | |
747 EXPECT_EQ(0, sink_.number_of_reconfigurations()); | |
748 | |
749 // Capture a frame and wait for it to synchronize with the encoder thread. | |
750 video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr)); | |
751 WaitForEncodedFrame(1); | |
752 // The encoder will have been configured once when the first frame is | |
753 // received. | |
754 EXPECT_EQ(1, sink_.number_of_reconfigurations()); | |
755 | |
756 VideoEncoderConfig video_encoder_config; | |
757 test::FillEncoderConfiguration(1, &video_encoder_config); | |
758 video_encoder_config.min_transmit_bitrate_bps = 9999; | |
759 vie_encoder_->ConfigureEncoder(std::move(video_encoder_config), | |
760 kMaxPayloadLength, true /* nack_enabled */); | |
761 | |
762 // Capture a frame and wait for it to synchronize with the encoder thread. | |
763 video_source_.IncomingCapturedFrame(CreateFrame(2, nullptr)); | |
764 WaitForEncodedFrame(2); | |
765 EXPECT_EQ(2, sink_.number_of_reconfigurations()); | |
766 EXPECT_EQ(9999, sink_.last_min_transmit_bitrate()); | |
767 | |
768 vie_encoder_->Stop(); | |
769 } | |
770 | |
771 TEST_F(ViEEncoderTest, FrameResolutionChangeReconfigureEncoder) { | |
772 vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0); | |
773 | |
774 // Capture a frame and wait for it to synchronize with the encoder thread. | |
775 video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr)); | |
776 WaitForEncodedFrame(1); | |
777 // The encoder will have been configured once. | |
778 EXPECT_EQ(1, sink_.number_of_reconfigurations()); | |
779 EXPECT_EQ(codec_width_, fake_encoder_.codec_config().width); | |
780 EXPECT_EQ(codec_height_, fake_encoder_.codec_config().height); | |
781 | |
782 codec_width_ *= 2; | |
783 codec_height_ *= 2; | |
784 // Capture a frame with a higher resolution and wait for it to synchronize | |
785 // with the encoder thread. | |
786 video_source_.IncomingCapturedFrame(CreateFrame(2, nullptr)); | |
787 WaitForEncodedFrame(2); | |
788 EXPECT_EQ(codec_width_, fake_encoder_.codec_config().width); | |
789 EXPECT_EQ(codec_height_, fake_encoder_.codec_config().height); | |
790 EXPECT_EQ(2, sink_.number_of_reconfigurations()); | |
791 | |
792 vie_encoder_->Stop(); | |
793 } | |
794 | |
795 TEST_F(ViEEncoderTest, Vp8ResilienceIsOffFor1S1TLWithNackEnabled) { | |
796 const bool kNackEnabled = true; | |
797 const size_t kNumStreams = 1; | |
798 const size_t kNumTl = 1; | |
799 ResetEncoder("VP8", kNumStreams, kNumTl, kNackEnabled, false); | |
800 vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0); | |
801 | |
802 // Capture a frame and wait for it to synchronize with the encoder thread. | |
803 video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr)); | |
804 WaitForEncodedFrame(1); | |
805 // The encoder have been configured once when the first frame is received. | |
806 EXPECT_EQ(1, sink_.number_of_reconfigurations()); | |
807 EXPECT_EQ(kVideoCodecVP8, fake_encoder_.codec_config().codecType); | |
808 EXPECT_EQ(kNumStreams, fake_encoder_.codec_config().numberOfSimulcastStreams); | |
809 EXPECT_EQ(kNumTl, fake_encoder_.codec_config().VP8()->numberOfTemporalLayers); | |
810 // Resilience is off for no temporal layers with nack on. | |
811 EXPECT_EQ(kResilienceOff, fake_encoder_.codec_config().VP8()->resilience); | |
812 vie_encoder_->Stop(); | |
813 } | |
814 | |
815 TEST_F(ViEEncoderTest, Vp8ResilienceIsOffFor2S1TlWithNackEnabled) { | |
816 const bool kNackEnabled = true; | |
817 const size_t kNumStreams = 2; | |
818 const size_t kNumTl = 1; | |
819 ResetEncoder("VP8", kNumStreams, kNumTl, kNackEnabled, false); | |
820 vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0); | |
821 | |
822 // Capture a frame and wait for it to synchronize with the encoder thread. | |
823 video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr)); | |
824 WaitForEncodedFrame(1); | |
825 // The encoder have been configured once when the first frame is received. | |
826 EXPECT_EQ(1, sink_.number_of_reconfigurations()); | |
827 EXPECT_EQ(kVideoCodecVP8, fake_encoder_.codec_config().codecType); | |
828 EXPECT_EQ(kNumStreams, fake_encoder_.codec_config().numberOfSimulcastStreams); | |
829 EXPECT_EQ(kNumTl, fake_encoder_.codec_config().VP8()->numberOfTemporalLayers); | |
830 // Resilience is off for no temporal layers and >1 streams with nack on. | |
831 EXPECT_EQ(kResilienceOff, fake_encoder_.codec_config().VP8()->resilience); | |
832 vie_encoder_->Stop(); | |
833 } | |
834 | |
835 TEST_F(ViEEncoderTest, Vp8ResilienceIsOnFor1S1TLWithNackDisabled) { | |
836 const bool kNackEnabled = false; | |
837 const size_t kNumStreams = 1; | |
838 const size_t kNumTl = 1; | |
839 ResetEncoder("VP8", kNumStreams, kNumTl, kNackEnabled, false); | |
840 vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0); | |
841 | |
842 // Capture a frame and wait for it to synchronize with the encoder thread. | |
843 video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr)); | |
844 WaitForEncodedFrame(1); | |
845 // The encoder have been configured once when the first frame is received. | |
846 EXPECT_EQ(1, sink_.number_of_reconfigurations()); | |
847 EXPECT_EQ(kVideoCodecVP8, fake_encoder_.codec_config().codecType); | |
848 EXPECT_EQ(kNumStreams, fake_encoder_.codec_config().numberOfSimulcastStreams); | |
849 EXPECT_EQ(kNumTl, fake_encoder_.codec_config().VP8()->numberOfTemporalLayers); | |
850 // Resilience is on for no temporal layers with nack off. | |
851 EXPECT_EQ(kResilientStream, fake_encoder_.codec_config().VP8()->resilience); | |
852 vie_encoder_->Stop(); | |
853 } | |
854 | |
855 TEST_F(ViEEncoderTest, Vp8ResilienceIsOnFor1S2TlWithNackEnabled) { | |
856 const bool kNackEnabled = true; | |
857 const size_t kNumStreams = 1; | |
858 const size_t kNumTl = 2; | |
859 ResetEncoder("VP8", kNumStreams, kNumTl, kNackEnabled, false); | |
860 vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0); | |
861 | |
862 // Capture a frame and wait for it to synchronize with the encoder thread. | |
863 video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr)); | |
864 WaitForEncodedFrame(1); | |
865 // The encoder have been configured once when the first frame is received. | |
866 EXPECT_EQ(1, sink_.number_of_reconfigurations()); | |
867 EXPECT_EQ(kVideoCodecVP8, fake_encoder_.codec_config().codecType); | |
868 EXPECT_EQ(kNumStreams, fake_encoder_.codec_config().numberOfSimulcastStreams); | |
869 EXPECT_EQ(kNumTl, fake_encoder_.codec_config().VP8()->numberOfTemporalLayers); | |
870 // Resilience is on for temporal layers. | |
871 EXPECT_EQ(kResilientStream, fake_encoder_.codec_config().VP8()->resilience); | |
872 vie_encoder_->Stop(); | |
873 } | |
874 | |
875 TEST_F(ViEEncoderTest, SwitchSourceDeregisterEncoderAsSink) { | |
876 EXPECT_TRUE(video_source_.has_sinks()); | |
877 test::FrameForwarder new_video_source; | |
878 vie_encoder_->SetSource( | |
879 &new_video_source, | |
880 VideoSendStream::DegradationPreference::kMaintainFramerate); | |
881 EXPECT_FALSE(video_source_.has_sinks()); | |
882 EXPECT_TRUE(new_video_source.has_sinks()); | |
883 | |
884 vie_encoder_->Stop(); | |
885 } | |
886 | |
887 TEST_F(ViEEncoderTest, SinkWantsRotationApplied) { | |
888 EXPECT_FALSE(video_source_.sink_wants().rotation_applied); | |
889 vie_encoder_->SetSink(&sink_, true /*rotation_applied*/); | |
890 EXPECT_TRUE(video_source_.sink_wants().rotation_applied); | |
891 vie_encoder_->Stop(); | |
892 } | |
893 | |
894 TEST_F(ViEEncoderTest, SinkWantsFromOveruseDetector) { | |
895 const int kMaxDowngrades = ViEEncoder::kMaxCpuResolutionDowngrades; | |
896 vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0); | |
897 | |
898 VerifyNoLimitation(video_source_.sink_wants()); | |
899 | |
900 int frame_width = 1280; | |
901 int frame_height = 720; | |
902 | |
903 // Trigger CPU overuse kMaxCpuDowngrades times. Every time, ViEEncoder should | |
904 // request lower resolution. | |
905 for (int i = 1; i <= kMaxDowngrades; ++i) { | |
906 video_source_.IncomingCapturedFrame( | |
907 CreateFrame(i, frame_width, frame_height)); | |
908 WaitForEncodedFrame(i); | |
909 | |
910 vie_encoder_->TriggerCpuOveruse(); | |
911 | |
912 EXPECT_FALSE(video_source_.sink_wants().target_pixel_count); | |
913 EXPECT_LT(video_source_.sink_wants().max_pixel_count, | |
914 frame_width * frame_height); | |
915 EXPECT_TRUE(stats_proxy_->GetStats().cpu_limited_resolution); | |
916 EXPECT_EQ(i, stats_proxy_->GetStats().number_of_cpu_adapt_changes); | |
917 | |
918 frame_width /= 2; | |
919 frame_height /= 2; | |
920 } | |
921 | |
922 // Trigger CPU overuse one more time. This should not trigger a request for | |
923 // lower resolution. | |
924 rtc::VideoSinkWants current_wants = video_source_.sink_wants(); | |
925 video_source_.IncomingCapturedFrame( | |
926 CreateFrame(kMaxDowngrades + 1, frame_width, frame_height)); | |
927 WaitForEncodedFrame(kMaxDowngrades + 1); | |
928 vie_encoder_->TriggerCpuOveruse(); | |
929 EXPECT_EQ(video_source_.sink_wants().target_pixel_count, | |
930 current_wants.target_pixel_count); | |
931 EXPECT_EQ(video_source_.sink_wants().max_pixel_count, | |
932 current_wants.max_pixel_count); | |
933 EXPECT_TRUE(stats_proxy_->GetStats().cpu_limited_resolution); | |
934 EXPECT_EQ(kMaxDowngrades, | |
935 stats_proxy_->GetStats().number_of_cpu_adapt_changes); | |
936 | |
937 // Trigger CPU normal use. | |
938 vie_encoder_->TriggerCpuNormalUsage(); | |
939 EXPECT_EQ(frame_width * frame_height * 5 / 3, | |
940 video_source_.sink_wants().target_pixel_count.value_or(0)); | |
941 EXPECT_EQ(frame_width * frame_height * 4, | |
942 video_source_.sink_wants().max_pixel_count); | |
943 EXPECT_TRUE(stats_proxy_->GetStats().cpu_limited_resolution); | |
944 EXPECT_EQ(kMaxDowngrades + 1, | |
945 stats_proxy_->GetStats().number_of_cpu_adapt_changes); | |
946 | |
947 vie_encoder_->Stop(); | |
948 } | |
949 | |
950 TEST_F(ViEEncoderTest, TestMaxCpuResolutionDowngrades_BalancedMode_NoFpsLimit) { | |
951 const int kMaxDowngrades = ViEEncoder::kMaxCpuResolutionDowngrades; | |
952 const int kWidth = 1280; | |
953 const int kHeight = 720; | |
954 vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0); | |
955 | |
956 // Enable kBalanced preference, no initial limitation. | |
957 AdaptingFrameForwarder source; | |
958 source.set_adaptation_enabled(true); | |
959 vie_encoder_->SetSource(&source, | |
960 VideoSendStream::DegradationPreference::kBalanced); | |
961 VerifyNoLimitation(source.sink_wants()); | |
962 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_resolution); | |
963 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_cpu_adapt_changes); | |
964 | |
965 // Trigger adapt down kMaxCpuDowngrades times. | |
966 int t = 1; | |
967 for (int i = 1; i <= kMaxDowngrades; ++i) { | |
968 source.IncomingCapturedFrame(CreateFrame(t, kWidth, kHeight)); | |
969 sink_.WaitForEncodedFrame(t++); | |
970 vie_encoder_->TriggerCpuOveruse(); | |
971 VerifyFpsMaxResolutionLt(source.sink_wants(), source.last_wants()); | |
972 EXPECT_TRUE(stats_proxy_->GetStats().cpu_limited_resolution); | |
973 EXPECT_EQ(i, stats_proxy_->GetStats().number_of_cpu_adapt_changes); | |
974 } | |
975 | |
976 // Trigger adapt down, max cpu downgrades reach, expect no change. | |
977 rtc::VideoSinkWants last_wants = source.sink_wants(); | |
978 source.IncomingCapturedFrame(CreateFrame(t, kWidth, kHeight)); | |
979 sink_.WaitForEncodedFrame(t++); | |
980 vie_encoder_->TriggerCpuOveruse(); | |
981 VerifyFpsEqResolutionEq(source.sink_wants(), last_wants); | |
982 EXPECT_EQ(last_wants.max_pixel_count, source.sink_wants().max_pixel_count); | |
983 EXPECT_TRUE(stats_proxy_->GetStats().cpu_limited_resolution); | |
984 EXPECT_EQ(kMaxDowngrades, | |
985 stats_proxy_->GetStats().number_of_cpu_adapt_changes); | |
986 | |
987 // Trigger adapt up kMaxCpuDowngrades times. | |
988 for (int i = 1; i <= kMaxDowngrades; ++i) { | |
989 source.IncomingCapturedFrame(CreateFrame(t, kWidth, kHeight)); | |
990 sink_.WaitForEncodedFrame(t++); | |
991 vie_encoder_->TriggerCpuNormalUsage(); | |
992 VerifyFpsMaxResolutionGt(source.sink_wants(), source.last_wants()); | |
993 EXPECT_GT(source.sink_wants().max_pixel_count, last_wants.max_pixel_count); | |
994 EXPECT_EQ(kMaxDowngrades + i, | |
995 stats_proxy_->GetStats().number_of_cpu_adapt_changes); | |
996 } | |
997 | |
998 VerifyNoLimitation(source.sink_wants()); | |
999 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_resolution); | |
1000 | |
1001 vie_encoder_->Stop(); | |
1002 } | |
1003 TEST_F(ViEEncoderTest, SinkWantsStoredByDegradationPreference) { | |
1004 vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0); | |
1005 VerifyNoLimitation(video_source_.sink_wants()); | |
1006 | |
1007 const int kFrameWidth = 1280; | |
1008 const int kFrameHeight = 720; | |
1009 const int kFrameIntervalMs = 1000 / 30; | |
1010 | |
1011 int frame_timestamp = 1; | |
1012 | |
1013 video_source_.IncomingCapturedFrame( | |
1014 CreateFrame(frame_timestamp, kFrameWidth, kFrameHeight)); | |
1015 WaitForEncodedFrame(frame_timestamp); | |
1016 frame_timestamp += kFrameIntervalMs; | |
1017 | |
1018 // Trigger CPU overuse. | |
1019 vie_encoder_->TriggerCpuOveruse(); | |
1020 video_source_.IncomingCapturedFrame( | |
1021 CreateFrame(frame_timestamp, kFrameWidth, kFrameHeight)); | |
1022 WaitForEncodedFrame(frame_timestamp); | |
1023 frame_timestamp += kFrameIntervalMs; | |
1024 | |
1025 // Default degradation preference is maintain-framerate, so will lower max | |
1026 // wanted resolution. | |
1027 EXPECT_FALSE(video_source_.sink_wants().target_pixel_count); | |
1028 EXPECT_LT(video_source_.sink_wants().max_pixel_count, | |
1029 kFrameWidth * kFrameHeight); | |
1030 EXPECT_EQ(std::numeric_limits<int>::max(), | |
1031 video_source_.sink_wants().max_framerate_fps); | |
1032 | |
1033 // Set new source, switch to maintain-resolution. | |
1034 test::FrameForwarder new_video_source; | |
1035 vie_encoder_->SetSource( | |
1036 &new_video_source, | |
1037 VideoSendStream::DegradationPreference::kMaintainResolution); | |
1038 | |
1039 // Initially no degradation registered. | |
1040 VerifyNoLimitation(new_video_source.sink_wants()); | |
1041 | |
1042 // Force an input frame rate to be available, or the adaptation call won't | |
1043 // know what framerate to adapt form. | |
1044 const int kInputFps = 30; | |
1045 VideoSendStream::Stats stats = stats_proxy_->GetStats(); | |
1046 stats.input_frame_rate = kInputFps; | |
1047 stats_proxy_->SetMockStats(stats); | |
1048 | |
1049 vie_encoder_->TriggerCpuOveruse(); | |
1050 new_video_source.IncomingCapturedFrame( | |
1051 CreateFrame(frame_timestamp, kFrameWidth, kFrameHeight)); | |
1052 WaitForEncodedFrame(frame_timestamp); | |
1053 frame_timestamp += kFrameIntervalMs; | |
1054 | |
1055 // Some framerate constraint should be set. | |
1056 EXPECT_FALSE(new_video_source.sink_wants().target_pixel_count); | |
1057 EXPECT_EQ(std::numeric_limits<int>::max(), | |
1058 new_video_source.sink_wants().max_pixel_count); | |
1059 EXPECT_LT(new_video_source.sink_wants().max_framerate_fps, kInputFps); | |
1060 | |
1061 // Turn off degradation completely. | |
1062 vie_encoder_->SetSource( | |
1063 &new_video_source, | |
1064 VideoSendStream::DegradationPreference::kDegradationDisabled); | |
1065 VerifyNoLimitation(new_video_source.sink_wants()); | |
1066 | |
1067 vie_encoder_->TriggerCpuOveruse(); | |
1068 new_video_source.IncomingCapturedFrame( | |
1069 CreateFrame(frame_timestamp, kFrameWidth, kFrameHeight)); | |
1070 WaitForEncodedFrame(frame_timestamp); | |
1071 frame_timestamp += kFrameIntervalMs; | |
1072 | |
1073 // Still no degradation. | |
1074 VerifyNoLimitation(new_video_source.sink_wants()); | |
1075 | |
1076 // Calling SetSource with resolution scaling enabled apply the old SinkWants. | |
1077 vie_encoder_->SetSource( | |
1078 &new_video_source, | |
1079 VideoSendStream::DegradationPreference::kMaintainFramerate); | |
1080 EXPECT_LT(new_video_source.sink_wants().max_pixel_count, | |
1081 kFrameWidth * kFrameHeight); | |
1082 EXPECT_FALSE(new_video_source.sink_wants().target_pixel_count); | |
1083 EXPECT_EQ(std::numeric_limits<int>::max(), | |
1084 new_video_source.sink_wants().max_framerate_fps); | |
1085 | |
1086 // Calling SetSource with framerate scaling enabled apply the old SinkWants. | |
1087 vie_encoder_->SetSource( | |
1088 &new_video_source, | |
1089 VideoSendStream::DegradationPreference::kMaintainResolution); | |
1090 EXPECT_FALSE(new_video_source.sink_wants().target_pixel_count); | |
1091 EXPECT_EQ(std::numeric_limits<int>::max(), | |
1092 new_video_source.sink_wants().max_pixel_count); | |
1093 EXPECT_LT(new_video_source.sink_wants().max_framerate_fps, kInputFps); | |
1094 | |
1095 vie_encoder_->Stop(); | |
1096 } | |
1097 | |
1098 TEST_F(ViEEncoderTest, StatsTracksQualityAdaptationStats) { | |
1099 vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0); | |
1100 | |
1101 const int kWidth = 1280; | |
1102 const int kHeight = 720; | |
1103 video_source_.IncomingCapturedFrame(CreateFrame(1, kWidth, kHeight)); | |
1104 WaitForEncodedFrame(1); | |
1105 VideoSendStream::Stats stats = stats_proxy_->GetStats(); | |
1106 EXPECT_FALSE(stats.bw_limited_resolution); | |
1107 EXPECT_EQ(0, stats.number_of_quality_adapt_changes); | |
1108 | |
1109 // Trigger adapt down. | |
1110 vie_encoder_->TriggerQualityLow(); | |
1111 video_source_.IncomingCapturedFrame(CreateFrame(2, kWidth, kHeight)); | |
1112 WaitForEncodedFrame(2); | |
1113 | |
1114 stats = stats_proxy_->GetStats(); | |
1115 EXPECT_TRUE(stats.bw_limited_resolution); | |
1116 EXPECT_EQ(1, stats.number_of_quality_adapt_changes); | |
1117 | |
1118 // Trigger adapt up. | |
1119 vie_encoder_->TriggerQualityHigh(); | |
1120 video_source_.IncomingCapturedFrame(CreateFrame(3, kWidth, kHeight)); | |
1121 WaitForEncodedFrame(3); | |
1122 | |
1123 stats = stats_proxy_->GetStats(); | |
1124 EXPECT_FALSE(stats.bw_limited_resolution); | |
1125 EXPECT_EQ(2, stats.number_of_quality_adapt_changes); | |
1126 EXPECT_EQ(0, stats.number_of_cpu_adapt_changes); | |
1127 | |
1128 vie_encoder_->Stop(); | |
1129 } | |
1130 | |
1131 TEST_F(ViEEncoderTest, StatsTracksCpuAdaptationStats) { | |
1132 vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0); | |
1133 | |
1134 const int kWidth = 1280; | |
1135 const int kHeight = 720; | |
1136 video_source_.IncomingCapturedFrame(CreateFrame(1, kWidth, kHeight)); | |
1137 WaitForEncodedFrame(1); | |
1138 VideoSendStream::Stats stats = stats_proxy_->GetStats(); | |
1139 EXPECT_FALSE(stats.cpu_limited_resolution); | |
1140 EXPECT_EQ(0, stats.number_of_cpu_adapt_changes); | |
1141 | |
1142 // Trigger CPU overuse. | |
1143 vie_encoder_->TriggerCpuOveruse(); | |
1144 video_source_.IncomingCapturedFrame(CreateFrame(2, kWidth, kHeight)); | |
1145 WaitForEncodedFrame(2); | |
1146 | |
1147 stats = stats_proxy_->GetStats(); | |
1148 EXPECT_TRUE(stats.cpu_limited_resolution); | |
1149 EXPECT_EQ(1, stats.number_of_cpu_adapt_changes); | |
1150 | |
1151 // Trigger CPU normal use. | |
1152 vie_encoder_->TriggerCpuNormalUsage(); | |
1153 video_source_.IncomingCapturedFrame(CreateFrame(3, kWidth, kHeight)); | |
1154 WaitForEncodedFrame(3); | |
1155 | |
1156 stats = stats_proxy_->GetStats(); | |
1157 EXPECT_FALSE(stats.cpu_limited_resolution); | |
1158 EXPECT_EQ(2, stats.number_of_cpu_adapt_changes); | |
1159 EXPECT_EQ(0, stats.number_of_quality_adapt_changes); | |
1160 | |
1161 vie_encoder_->Stop(); | |
1162 } | |
1163 | |
1164 TEST_F(ViEEncoderTest, SwitchingSourceKeepsCpuAdaptation) { | |
1165 vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0); | |
1166 | |
1167 const int kWidth = 1280; | |
1168 const int kHeight = 720; | |
1169 video_source_.IncomingCapturedFrame(CreateFrame(1, kWidth, kHeight)); | |
1170 WaitForEncodedFrame(1); | |
1171 VideoSendStream::Stats stats = stats_proxy_->GetStats(); | |
1172 EXPECT_FALSE(stats.bw_limited_resolution); | |
1173 EXPECT_FALSE(stats.cpu_limited_resolution); | |
1174 EXPECT_EQ(0, stats.number_of_cpu_adapt_changes); | |
1175 | |
1176 // Trigger CPU overuse. | |
1177 vie_encoder_->TriggerCpuOveruse(); | |
1178 video_source_.IncomingCapturedFrame(CreateFrame(2, kWidth, kHeight)); | |
1179 WaitForEncodedFrame(2); | |
1180 stats = stats_proxy_->GetStats(); | |
1181 EXPECT_FALSE(stats.bw_limited_resolution); | |
1182 EXPECT_TRUE(stats.cpu_limited_resolution); | |
1183 EXPECT_EQ(1, stats.number_of_cpu_adapt_changes); | |
1184 | |
1185 // Set new source with adaptation still enabled. | |
1186 test::FrameForwarder new_video_source; | |
1187 vie_encoder_->SetSource( | |
1188 &new_video_source, | |
1189 VideoSendStream::DegradationPreference::kMaintainFramerate); | |
1190 | |
1191 new_video_source.IncomingCapturedFrame(CreateFrame(3, kWidth, kHeight)); | |
1192 WaitForEncodedFrame(3); | |
1193 stats = stats_proxy_->GetStats(); | |
1194 EXPECT_FALSE(stats.bw_limited_resolution); | |
1195 EXPECT_TRUE(stats.cpu_limited_resolution); | |
1196 EXPECT_EQ(1, stats.number_of_cpu_adapt_changes); | |
1197 | |
1198 // Set adaptation disabled. | |
1199 vie_encoder_->SetSource( | |
1200 &new_video_source, | |
1201 VideoSendStream::DegradationPreference::kDegradationDisabled); | |
1202 | |
1203 new_video_source.IncomingCapturedFrame(CreateFrame(4, kWidth, kHeight)); | |
1204 WaitForEncodedFrame(4); | |
1205 stats = stats_proxy_->GetStats(); | |
1206 EXPECT_FALSE(stats.bw_limited_resolution); | |
1207 EXPECT_FALSE(stats.cpu_limited_resolution); | |
1208 EXPECT_EQ(1, stats.number_of_cpu_adapt_changes); | |
1209 | |
1210 // Set adaptation back to enabled. | |
1211 vie_encoder_->SetSource( | |
1212 &new_video_source, | |
1213 VideoSendStream::DegradationPreference::kMaintainFramerate); | |
1214 | |
1215 new_video_source.IncomingCapturedFrame(CreateFrame(5, kWidth, kHeight)); | |
1216 WaitForEncodedFrame(5); | |
1217 stats = stats_proxy_->GetStats(); | |
1218 EXPECT_FALSE(stats.bw_limited_resolution); | |
1219 EXPECT_TRUE(stats.cpu_limited_resolution); | |
1220 EXPECT_EQ(1, stats.number_of_cpu_adapt_changes); | |
1221 | |
1222 // Trigger CPU normal use. | |
1223 vie_encoder_->TriggerCpuNormalUsage(); | |
1224 new_video_source.IncomingCapturedFrame(CreateFrame(6, kWidth, kHeight)); | |
1225 WaitForEncodedFrame(6); | |
1226 stats = stats_proxy_->GetStats(); | |
1227 EXPECT_FALSE(stats.bw_limited_resolution); | |
1228 EXPECT_FALSE(stats.cpu_limited_resolution); | |
1229 EXPECT_EQ(2, stats.number_of_cpu_adapt_changes); | |
1230 EXPECT_EQ(0, stats.number_of_quality_adapt_changes); | |
1231 | |
1232 vie_encoder_->Stop(); | |
1233 } | |
1234 | |
1235 TEST_F(ViEEncoderTest, SwitchingSourceKeepsQualityAdaptation) { | |
1236 vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0); | |
1237 | |
1238 const int kWidth = 1280; | |
1239 const int kHeight = 720; | |
1240 video_source_.IncomingCapturedFrame(CreateFrame(1, kWidth, kHeight)); | |
1241 WaitForEncodedFrame(1); | |
1242 VideoSendStream::Stats stats = stats_proxy_->GetStats(); | |
1243 EXPECT_FALSE(stats.bw_limited_resolution); | |
1244 EXPECT_FALSE(stats.bw_limited_framerate); | |
1245 EXPECT_EQ(0, stats.number_of_quality_adapt_changes); | |
1246 | |
1247 // Set new source with adaptation still enabled. | |
1248 test::FrameForwarder new_video_source; | |
1249 vie_encoder_->SetSource(&new_video_source, | |
1250 VideoSendStream::DegradationPreference::kBalanced); | |
1251 | |
1252 new_video_source.IncomingCapturedFrame(CreateFrame(2, kWidth, kHeight)); | |
1253 WaitForEncodedFrame(2); | |
1254 stats = stats_proxy_->GetStats(); | |
1255 EXPECT_FALSE(stats.bw_limited_resolution); | |
1256 EXPECT_FALSE(stats.bw_limited_framerate); | |
1257 EXPECT_EQ(0, stats.number_of_quality_adapt_changes); | |
1258 | |
1259 // Trigger adapt down. | |
1260 vie_encoder_->TriggerQualityLow(); | |
1261 new_video_source.IncomingCapturedFrame(CreateFrame(3, kWidth, kHeight)); | |
1262 WaitForEncodedFrame(3); | |
1263 stats = stats_proxy_->GetStats(); | |
1264 EXPECT_TRUE(stats.bw_limited_resolution); | |
1265 EXPECT_FALSE(stats.bw_limited_framerate); | |
1266 EXPECT_EQ(1, stats.number_of_quality_adapt_changes); | |
1267 | |
1268 // Set new source with adaptation still enabled. | |
1269 vie_encoder_->SetSource(&new_video_source, | |
1270 VideoSendStream::DegradationPreference::kBalanced); | |
1271 | |
1272 new_video_source.IncomingCapturedFrame(CreateFrame(4, kWidth, kHeight)); | |
1273 WaitForEncodedFrame(4); | |
1274 stats = stats_proxy_->GetStats(); | |
1275 EXPECT_TRUE(stats.bw_limited_resolution); | |
1276 EXPECT_FALSE(stats.bw_limited_framerate); | |
1277 EXPECT_EQ(1, stats.number_of_quality_adapt_changes); | |
1278 | |
1279 // Disable resolution scaling. | |
1280 vie_encoder_->SetSource( | |
1281 &new_video_source, | |
1282 VideoSendStream::DegradationPreference::kMaintainResolution); | |
1283 | |
1284 new_video_source.IncomingCapturedFrame(CreateFrame(5, kWidth, kHeight)); | |
1285 WaitForEncodedFrame(5); | |
1286 stats = stats_proxy_->GetStats(); | |
1287 EXPECT_FALSE(stats.bw_limited_resolution); | |
1288 EXPECT_FALSE(stats.bw_limited_framerate); | |
1289 EXPECT_EQ(1, stats.number_of_quality_adapt_changes); | |
1290 EXPECT_EQ(0, stats.number_of_cpu_adapt_changes); | |
1291 | |
1292 vie_encoder_->Stop(); | |
1293 } | |
1294 | |
1295 TEST_F(ViEEncoderTest, QualityAdaptationStatsAreResetWhenScalerIsDisabled) { | |
1296 vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0); | |
1297 | |
1298 const int kWidth = 1280; | |
1299 const int kHeight = 720; | |
1300 video_source_.set_adaptation_enabled(true); | |
1301 video_source_.IncomingCapturedFrame(CreateFrame(1, kWidth, kHeight)); | |
1302 WaitForEncodedFrame(1); | |
1303 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_resolution); | |
1304 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution); | |
1305 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_cpu_adapt_changes); | |
1306 | |
1307 // Trigger adapt down. | |
1308 vie_encoder_->TriggerQualityLow(); | |
1309 video_source_.IncomingCapturedFrame(CreateFrame(2, kWidth, kHeight)); | |
1310 WaitForEncodedFrame(2); | |
1311 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_resolution); | |
1312 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution); | |
1313 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_cpu_adapt_changes); | |
1314 | |
1315 // Trigger overuse. | |
1316 vie_encoder_->TriggerCpuOveruse(); | |
1317 video_source_.IncomingCapturedFrame(CreateFrame(3, kWidth, kHeight)); | |
1318 WaitForEncodedFrame(3); | |
1319 EXPECT_TRUE(stats_proxy_->GetStats().cpu_limited_resolution); | |
1320 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution); | |
1321 EXPECT_EQ(1, stats_proxy_->GetStats().number_of_cpu_adapt_changes); | |
1322 | |
1323 // Set source with adaptation still enabled but quality scaler is off. | |
1324 fake_encoder_.SetQualityScaling(false); | |
1325 vie_encoder_->SetSource( | |
1326 &video_source_, | |
1327 VideoSendStream::DegradationPreference::kMaintainFramerate); | |
1328 | |
1329 video_source_.IncomingCapturedFrame(CreateFrame(4, kWidth, kHeight)); | |
1330 WaitForEncodedFrame(4); | |
1331 EXPECT_TRUE(stats_proxy_->GetStats().cpu_limited_resolution); | |
1332 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution); | |
1333 EXPECT_EQ(1, stats_proxy_->GetStats().number_of_cpu_adapt_changes); | |
1334 | |
1335 vie_encoder_->Stop(); | |
1336 } | |
1337 | |
1338 TEST_F(ViEEncoderTest, StatsTracksCpuAdaptationStatsWhenSwitchingSource) { | |
1339 vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0); | |
1340 | |
1341 const int kWidth = 1280; | |
1342 const int kHeight = 720; | |
1343 int sequence = 1; | |
1344 | |
1345 video_source_.IncomingCapturedFrame(CreateFrame(sequence, kWidth, kHeight)); | |
1346 WaitForEncodedFrame(sequence++); | |
1347 VideoSendStream::Stats stats = stats_proxy_->GetStats(); | |
1348 EXPECT_FALSE(stats.cpu_limited_resolution); | |
1349 EXPECT_FALSE(stats.cpu_limited_framerate); | |
1350 EXPECT_EQ(0, stats.number_of_cpu_adapt_changes); | |
1351 | |
1352 // Trigger CPU overuse, should now adapt down. | |
1353 vie_encoder_->TriggerCpuOveruse(); | |
1354 video_source_.IncomingCapturedFrame(CreateFrame(sequence, kWidth, kHeight)); | |
1355 WaitForEncodedFrame(sequence++); | |
1356 stats = stats_proxy_->GetStats(); | |
1357 EXPECT_TRUE(stats.cpu_limited_resolution); | |
1358 EXPECT_FALSE(stats.cpu_limited_framerate); | |
1359 EXPECT_EQ(1, stats.number_of_cpu_adapt_changes); | |
1360 | |
1361 // Set new source with adaptation still enabled. | |
1362 test::FrameForwarder new_video_source; | |
1363 vie_encoder_->SetSource( | |
1364 &new_video_source, | |
1365 VideoSendStream::DegradationPreference::kMaintainFramerate); | |
1366 | |
1367 new_video_source.IncomingCapturedFrame( | |
1368 CreateFrame(sequence, kWidth, kHeight)); | |
1369 WaitForEncodedFrame(sequence++); | |
1370 stats = stats_proxy_->GetStats(); | |
1371 EXPECT_TRUE(stats.cpu_limited_resolution); | |
1372 EXPECT_FALSE(stats.cpu_limited_framerate); | |
1373 EXPECT_EQ(1, stats.number_of_cpu_adapt_changes); | |
1374 | |
1375 // Set cpu adaptation by frame dropping. | |
1376 vie_encoder_->SetSource( | |
1377 &new_video_source, | |
1378 VideoSendStream::DegradationPreference::kMaintainResolution); | |
1379 new_video_source.IncomingCapturedFrame( | |
1380 CreateFrame(sequence, kWidth, kHeight)); | |
1381 WaitForEncodedFrame(sequence++); | |
1382 stats = stats_proxy_->GetStats(); | |
1383 // Not adapted at first. | |
1384 EXPECT_FALSE(stats.cpu_limited_resolution); | |
1385 EXPECT_FALSE(stats.cpu_limited_framerate); | |
1386 EXPECT_EQ(1, stats.number_of_cpu_adapt_changes); | |
1387 | |
1388 // Force an input frame rate to be available, or the adaptation call won't | |
1389 // know what framerate to adapt from. | |
1390 VideoSendStream::Stats mock_stats = stats_proxy_->GetStats(); | |
1391 mock_stats.input_frame_rate = 30; | |
1392 stats_proxy_->SetMockStats(mock_stats); | |
1393 vie_encoder_->TriggerCpuOveruse(); | |
1394 stats_proxy_->ResetMockStats(); | |
1395 | |
1396 new_video_source.IncomingCapturedFrame( | |
1397 CreateFrame(sequence, kWidth, kHeight)); | |
1398 WaitForEncodedFrame(sequence++); | |
1399 | |
1400 // Framerate now adapted. | |
1401 stats = stats_proxy_->GetStats(); | |
1402 EXPECT_FALSE(stats.cpu_limited_resolution); | |
1403 EXPECT_TRUE(stats.cpu_limited_framerate); | |
1404 EXPECT_EQ(2, stats.number_of_cpu_adapt_changes); | |
1405 | |
1406 // Disable CPU adaptation. | |
1407 vie_encoder_->SetSource( | |
1408 &new_video_source, | |
1409 VideoSendStream::DegradationPreference::kDegradationDisabled); | |
1410 new_video_source.IncomingCapturedFrame( | |
1411 CreateFrame(sequence, kWidth, kHeight)); | |
1412 WaitForEncodedFrame(sequence++); | |
1413 | |
1414 stats = stats_proxy_->GetStats(); | |
1415 EXPECT_FALSE(stats.cpu_limited_resolution); | |
1416 EXPECT_FALSE(stats.cpu_limited_framerate); | |
1417 EXPECT_EQ(2, stats.number_of_cpu_adapt_changes); | |
1418 | |
1419 // Try to trigger overuse. Should not succeed. | |
1420 stats_proxy_->SetMockStats(mock_stats); | |
1421 vie_encoder_->TriggerCpuOveruse(); | |
1422 stats_proxy_->ResetMockStats(); | |
1423 | |
1424 stats = stats_proxy_->GetStats(); | |
1425 EXPECT_FALSE(stats.cpu_limited_resolution); | |
1426 EXPECT_FALSE(stats.cpu_limited_framerate); | |
1427 EXPECT_EQ(2, stats.number_of_cpu_adapt_changes); | |
1428 | |
1429 // Switch back the source with resolution adaptation enabled. | |
1430 vie_encoder_->SetSource( | |
1431 &video_source_, | |
1432 VideoSendStream::DegradationPreference::kMaintainFramerate); | |
1433 video_source_.IncomingCapturedFrame(CreateFrame(sequence, kWidth, kHeight)); | |
1434 WaitForEncodedFrame(sequence++); | |
1435 stats = stats_proxy_->GetStats(); | |
1436 EXPECT_TRUE(stats.cpu_limited_resolution); | |
1437 EXPECT_FALSE(stats.cpu_limited_framerate); | |
1438 EXPECT_EQ(2, stats.number_of_cpu_adapt_changes); | |
1439 | |
1440 // Trigger CPU normal usage. | |
1441 vie_encoder_->TriggerCpuNormalUsage(); | |
1442 video_source_.IncomingCapturedFrame(CreateFrame(sequence, kWidth, kHeight)); | |
1443 WaitForEncodedFrame(sequence++); | |
1444 stats = stats_proxy_->GetStats(); | |
1445 EXPECT_FALSE(stats.cpu_limited_resolution); | |
1446 EXPECT_FALSE(stats.cpu_limited_framerate); | |
1447 EXPECT_EQ(3, stats.number_of_cpu_adapt_changes); | |
1448 | |
1449 // Back to the source with adaptation off, set it back to maintain-resolution. | |
1450 vie_encoder_->SetSource( | |
1451 &new_video_source, | |
1452 VideoSendStream::DegradationPreference::kMaintainResolution); | |
1453 new_video_source.IncomingCapturedFrame( | |
1454 CreateFrame(sequence, kWidth, kHeight)); | |
1455 WaitForEncodedFrame(sequence++); | |
1456 stats = stats_proxy_->GetStats(); | |
1457 // Disabled, since we previously switched the source to disabled. | |
1458 EXPECT_FALSE(stats.cpu_limited_resolution); | |
1459 EXPECT_TRUE(stats.cpu_limited_framerate); | |
1460 EXPECT_EQ(3, stats.number_of_cpu_adapt_changes); | |
1461 | |
1462 // Trigger CPU normal usage. | |
1463 vie_encoder_->TriggerCpuNormalUsage(); | |
1464 new_video_source.IncomingCapturedFrame( | |
1465 CreateFrame(sequence, kWidth, kHeight)); | |
1466 WaitForEncodedFrame(sequence++); | |
1467 stats = stats_proxy_->GetStats(); | |
1468 EXPECT_FALSE(stats.cpu_limited_resolution); | |
1469 EXPECT_FALSE(stats.cpu_limited_framerate); | |
1470 EXPECT_EQ(4, stats.number_of_cpu_adapt_changes); | |
1471 EXPECT_EQ(0, stats.number_of_quality_adapt_changes); | |
1472 | |
1473 vie_encoder_->Stop(); | |
1474 } | |
1475 | |
1476 TEST_F(ViEEncoderTest, StatsTracksPreferredBitrate) { | |
1477 vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0); | |
1478 | |
1479 const int kWidth = 1280; | |
1480 const int kHeight = 720; | |
1481 video_source_.IncomingCapturedFrame(CreateFrame(1, kWidth, kHeight)); | |
1482 WaitForEncodedFrame(1); | |
1483 | |
1484 VideoSendStream::Stats stats = stats_proxy_->GetStats(); | |
1485 EXPECT_EQ(video_encoder_config_.max_bitrate_bps, | |
1486 stats.preferred_media_bitrate_bps); | |
1487 | |
1488 vie_encoder_->Stop(); | |
1489 } | |
1490 | |
1491 TEST_F(ViEEncoderTest, ScalingUpAndDownDoesNothingWithMaintainResolution) { | |
1492 const int kWidth = 1280; | |
1493 const int kHeight = 720; | |
1494 vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0); | |
1495 | |
1496 // Expect no scaling to begin with. | |
1497 VerifyNoLimitation(video_source_.sink_wants()); | |
1498 | |
1499 video_source_.IncomingCapturedFrame(CreateFrame(1, kWidth, kHeight)); | |
1500 WaitForEncodedFrame(1); | |
1501 | |
1502 // Trigger scale down. | |
1503 vie_encoder_->TriggerQualityLow(); | |
1504 | |
1505 video_source_.IncomingCapturedFrame(CreateFrame(2, kWidth, kHeight)); | |
1506 WaitForEncodedFrame(2); | |
1507 | |
1508 // Expect a scale down. | |
1509 EXPECT_TRUE(video_source_.sink_wants().max_pixel_count); | |
1510 EXPECT_LT(video_source_.sink_wants().max_pixel_count, kWidth * kHeight); | |
1511 | |
1512 // Set resolution scaling disabled. | |
1513 test::FrameForwarder new_video_source; | |
1514 vie_encoder_->SetSource( | |
1515 &new_video_source, | |
1516 VideoSendStream::DegradationPreference::kMaintainResolution); | |
1517 | |
1518 // Trigger scale down. | |
1519 vie_encoder_->TriggerQualityLow(); | |
1520 new_video_source.IncomingCapturedFrame(CreateFrame(3, kWidth, kHeight)); | |
1521 WaitForEncodedFrame(3); | |
1522 | |
1523 // Expect no scaling. | |
1524 EXPECT_EQ(std::numeric_limits<int>::max(), | |
1525 new_video_source.sink_wants().max_pixel_count); | |
1526 | |
1527 // Trigger scale up. | |
1528 vie_encoder_->TriggerQualityHigh(); | |
1529 new_video_source.IncomingCapturedFrame(CreateFrame(4, kWidth, kHeight)); | |
1530 WaitForEncodedFrame(4); | |
1531 | |
1532 // Expect nothing to change, still no scaling. | |
1533 EXPECT_EQ(std::numeric_limits<int>::max(), | |
1534 new_video_source.sink_wants().max_pixel_count); | |
1535 | |
1536 vie_encoder_->Stop(); | |
1537 } | |
1538 | |
1539 TEST_F(ViEEncoderTest, SkipsSameAdaptDownRequest_MaintainFramerateMode) { | |
1540 const int kWidth = 1280; | |
1541 const int kHeight = 720; | |
1542 vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0); | |
1543 | |
1544 // Enable kMaintainFramerate preference, no initial limitation. | |
1545 test::FrameForwarder source; | |
1546 vie_encoder_->SetSource( | |
1547 &source, VideoSendStream::DegradationPreference::kMaintainFramerate); | |
1548 | |
1549 source.IncomingCapturedFrame(CreateFrame(1, kWidth, kHeight)); | |
1550 WaitForEncodedFrame(1); | |
1551 VerifyNoLimitation(source.sink_wants()); | |
1552 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_resolution); | |
1553 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_cpu_adapt_changes); | |
1554 | |
1555 // Trigger adapt down, expect scaled down resolution. | |
1556 vie_encoder_->TriggerCpuOveruse(); | |
1557 VerifyFpsMaxResolutionLt(source.sink_wants(), kWidth * kHeight); | |
1558 const int kLastMaxPixelCount = source.sink_wants().max_pixel_count; | |
1559 EXPECT_TRUE(stats_proxy_->GetStats().cpu_limited_resolution); | |
1560 EXPECT_EQ(1, stats_proxy_->GetStats().number_of_cpu_adapt_changes); | |
1561 | |
1562 // Trigger adapt down for same input resolution, expect no change. | |
1563 vie_encoder_->TriggerCpuOveruse(); | |
1564 EXPECT_EQ(kLastMaxPixelCount, source.sink_wants().max_pixel_count); | |
1565 EXPECT_TRUE(stats_proxy_->GetStats().cpu_limited_resolution); | |
1566 EXPECT_EQ(1, stats_proxy_->GetStats().number_of_cpu_adapt_changes); | |
1567 | |
1568 vie_encoder_->Stop(); | |
1569 } | |
1570 | |
1571 TEST_F(ViEEncoderTest, SkipsSameOrLargerAdaptDownRequest_BalancedMode) { | |
1572 const int kWidth = 1280; | |
1573 const int kHeight = 720; | |
1574 vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0); | |
1575 | |
1576 // Enable kBalanced preference, no initial limitation. | |
1577 test::FrameForwarder source; | |
1578 vie_encoder_->SetSource(&source, | |
1579 VideoSendStream::DegradationPreference::kBalanced); | |
1580 source.IncomingCapturedFrame(CreateFrame(1, kWidth, kHeight)); | |
1581 sink_.WaitForEncodedFrame(1); | |
1582 VerifyNoLimitation(source.sink_wants()); | |
1583 | |
1584 // Trigger adapt down, expect scaled down resolution. | |
1585 vie_encoder_->TriggerQualityLow(); | |
1586 VerifyFpsMaxResolutionLt(source.sink_wants(), kWidth * kHeight); | |
1587 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution); | |
1588 EXPECT_EQ(1, stats_proxy_->GetStats().number_of_quality_adapt_changes); | |
1589 const int kLastMaxPixelCount = source.sink_wants().max_pixel_count; | |
1590 | |
1591 // Trigger adapt down for same input resolution, expect no change. | |
1592 source.IncomingCapturedFrame(CreateFrame(2, kWidth, kHeight)); | |
1593 sink_.WaitForEncodedFrame(2); | |
1594 vie_encoder_->TriggerQualityLow(); | |
1595 EXPECT_EQ(kLastMaxPixelCount, source.sink_wants().max_pixel_count); | |
1596 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution); | |
1597 EXPECT_EQ(1, stats_proxy_->GetStats().number_of_quality_adapt_changes); | |
1598 | |
1599 // Trigger adapt down for larger input resolution, expect no change. | |
1600 source.IncomingCapturedFrame(CreateFrame(3, kWidth + 1, kHeight + 1)); | |
1601 sink_.WaitForEncodedFrame(3); | |
1602 vie_encoder_->TriggerQualityLow(); | |
1603 EXPECT_EQ(kLastMaxPixelCount, source.sink_wants().max_pixel_count); | |
1604 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution); | |
1605 EXPECT_EQ(1, stats_proxy_->GetStats().number_of_quality_adapt_changes); | |
1606 | |
1607 vie_encoder_->Stop(); | |
1608 } | |
1609 | |
1610 TEST_F(ViEEncoderTest, NoChangeForInitialNormalUsage_MaintainFramerateMode) { | |
1611 const int kWidth = 1280; | |
1612 const int kHeight = 720; | |
1613 vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0); | |
1614 | |
1615 // Enable kMaintainFramerate preference, no initial limitation. | |
1616 test::FrameForwarder source; | |
1617 vie_encoder_->SetSource( | |
1618 &source, VideoSendStream::DegradationPreference::kMaintainFramerate); | |
1619 | |
1620 source.IncomingCapturedFrame(CreateFrame(1, kWidth, kHeight)); | |
1621 WaitForEncodedFrame(kWidth, kHeight); | |
1622 VerifyNoLimitation(source.sink_wants()); | |
1623 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_resolution); | |
1624 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_cpu_adapt_changes); | |
1625 | |
1626 // Trigger adapt up, expect no change. | |
1627 vie_encoder_->TriggerCpuNormalUsage(); | |
1628 VerifyNoLimitation(source.sink_wants()); | |
1629 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_resolution); | |
1630 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_cpu_adapt_changes); | |
1631 | |
1632 vie_encoder_->Stop(); | |
1633 } | |
1634 | |
1635 TEST_F(ViEEncoderTest, NoChangeForInitialNormalUsage_MaintainResolutionMode) { | |
1636 const int kWidth = 1280; | |
1637 const int kHeight = 720; | |
1638 vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0); | |
1639 | |
1640 // Enable kMaintainResolution preference, no initial limitation. | |
1641 test::FrameForwarder source; | |
1642 vie_encoder_->SetSource( | |
1643 &source, VideoSendStream::DegradationPreference::kMaintainResolution); | |
1644 | |
1645 source.IncomingCapturedFrame(CreateFrame(1, kWidth, kHeight)); | |
1646 WaitForEncodedFrame(kWidth, kHeight); | |
1647 VerifyNoLimitation(source.sink_wants()); | |
1648 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_framerate); | |
1649 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_cpu_adapt_changes); | |
1650 | |
1651 // Trigger adapt up, expect no change. | |
1652 vie_encoder_->TriggerCpuNormalUsage(); | |
1653 VerifyNoLimitation(source.sink_wants()); | |
1654 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_framerate); | |
1655 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_cpu_adapt_changes); | |
1656 | |
1657 vie_encoder_->Stop(); | |
1658 } | |
1659 | |
1660 TEST_F(ViEEncoderTest, NoChangeForInitialNormalUsage_BalancedMode) { | |
1661 const int kWidth = 1280; | |
1662 const int kHeight = 720; | |
1663 vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0); | |
1664 | |
1665 // Enable kBalanced preference, no initial limitation. | |
1666 test::FrameForwarder source; | |
1667 vie_encoder_->SetSource(&source, | |
1668 VideoSendStream::DegradationPreference::kBalanced); | |
1669 | |
1670 source.IncomingCapturedFrame(CreateFrame(1, kWidth, kHeight)); | |
1671 sink_.WaitForEncodedFrame(kWidth, kHeight); | |
1672 VerifyNoLimitation(source.sink_wants()); | |
1673 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution); | |
1674 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_framerate); | |
1675 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_quality_adapt_changes); | |
1676 | |
1677 // Trigger adapt up, expect no change. | |
1678 vie_encoder_->TriggerQualityHigh(); | |
1679 VerifyNoLimitation(source.sink_wants()); | |
1680 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution); | |
1681 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_framerate); | |
1682 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_quality_adapt_changes); | |
1683 | |
1684 vie_encoder_->Stop(); | |
1685 } | |
1686 | |
1687 TEST_F(ViEEncoderTest, NoChangeForInitialNormalUsage_DisabledMode) { | |
1688 const int kWidth = 1280; | |
1689 const int kHeight = 720; | |
1690 vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0); | |
1691 | |
1692 // Enable kDegradationDisabled preference, no initial limitation. | |
1693 test::FrameForwarder source; | |
1694 vie_encoder_->SetSource( | |
1695 &source, VideoSendStream::DegradationPreference::kDegradationDisabled); | |
1696 | |
1697 source.IncomingCapturedFrame(CreateFrame(1, kWidth, kHeight)); | |
1698 sink_.WaitForEncodedFrame(kWidth, kHeight); | |
1699 VerifyNoLimitation(source.sink_wants()); | |
1700 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution); | |
1701 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_framerate); | |
1702 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_quality_adapt_changes); | |
1703 | |
1704 // Trigger adapt up, expect no change. | |
1705 vie_encoder_->TriggerQualityHigh(); | |
1706 VerifyNoLimitation(source.sink_wants()); | |
1707 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution); | |
1708 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_framerate); | |
1709 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_quality_adapt_changes); | |
1710 | |
1711 vie_encoder_->Stop(); | |
1712 } | |
1713 | |
1714 TEST_F(ViEEncoderTest, AdaptsResolutionForLowQuality_MaintainFramerateMode) { | |
1715 const int kWidth = 1280; | |
1716 const int kHeight = 720; | |
1717 vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0); | |
1718 | |
1719 // Enable kMaintainFramerate preference, no initial limitation. | |
1720 AdaptingFrameForwarder source; | |
1721 source.set_adaptation_enabled(true); | |
1722 vie_encoder_->SetSource( | |
1723 &source, VideoSendStream::DegradationPreference::kMaintainFramerate); | |
1724 | |
1725 source.IncomingCapturedFrame(CreateFrame(1, kWidth, kHeight)); | |
1726 WaitForEncodedFrame(1); | |
1727 VerifyNoLimitation(source.sink_wants()); | |
1728 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution); | |
1729 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_quality_adapt_changes); | |
1730 | |
1731 // Trigger adapt down, expect scaled down resolution. | |
1732 vie_encoder_->TriggerQualityLow(); | |
1733 source.IncomingCapturedFrame(CreateFrame(2, kWidth, kHeight)); | |
1734 WaitForEncodedFrame(2); | |
1735 VerifyFpsMaxResolutionLt(source.sink_wants(), kWidth * kHeight); | |
1736 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution); | |
1737 EXPECT_EQ(1, stats_proxy_->GetStats().number_of_quality_adapt_changes); | |
1738 | |
1739 // Trigger adapt up, expect no restriction. | |
1740 vie_encoder_->TriggerQualityHigh(); | |
1741 VerifyNoLimitation(source.sink_wants()); | |
1742 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution); | |
1743 EXPECT_EQ(2, stats_proxy_->GetStats().number_of_quality_adapt_changes); | |
1744 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_cpu_adapt_changes); | |
1745 | |
1746 vie_encoder_->Stop(); | |
1747 } | |
1748 | |
1749 TEST_F(ViEEncoderTest, AdaptsFramerateForLowQuality_MaintainResolutionMode) { | |
1750 const int kWidth = 1280; | |
1751 const int kHeight = 720; | |
1752 const int kInputFps = 30; | |
1753 vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0); | |
1754 | |
1755 VideoSendStream::Stats stats = stats_proxy_->GetStats(); | |
1756 stats.input_frame_rate = kInputFps; | |
1757 stats_proxy_->SetMockStats(stats); | |
1758 | |
1759 // Expect no scaling to begin with (preference: kMaintainFramerate). | |
1760 video_source_.IncomingCapturedFrame(CreateFrame(1, kWidth, kHeight)); | |
1761 sink_.WaitForEncodedFrame(1); | |
1762 VerifyNoLimitation(video_source_.sink_wants()); | |
1763 | |
1764 // Trigger adapt down, expect scaled down resolution. | |
1765 vie_encoder_->TriggerQualityLow(); | |
1766 video_source_.IncomingCapturedFrame(CreateFrame(2, kWidth, kHeight)); | |
1767 sink_.WaitForEncodedFrame(2); | |
1768 VerifyFpsMaxResolutionLt(video_source_.sink_wants(), kWidth * kHeight); | |
1769 | |
1770 // Enable kMaintainResolution preference. | |
1771 test::FrameForwarder new_video_source; | |
1772 vie_encoder_->SetSource( | |
1773 &new_video_source, | |
1774 VideoSendStream::DegradationPreference::kMaintainResolution); | |
1775 VerifyNoLimitation(new_video_source.sink_wants()); | |
1776 | |
1777 // Trigger adapt down, expect reduced framerate. | |
1778 vie_encoder_->TriggerQualityLow(); | |
1779 new_video_source.IncomingCapturedFrame(CreateFrame(3, kWidth, kHeight)); | |
1780 sink_.WaitForEncodedFrame(3); | |
1781 VerifyFpsLtResolutionMax(new_video_source.sink_wants(), kInputFps); | |
1782 | |
1783 // Trigger adapt up, expect no restriction. | |
1784 vie_encoder_->TriggerQualityHigh(); | |
1785 VerifyNoLimitation(new_video_source.sink_wants()); | |
1786 | |
1787 vie_encoder_->Stop(); | |
1788 } | |
1789 | |
1790 TEST_F(ViEEncoderTest, DoesNotScaleBelowSetResolutionLimit) { | |
1791 const int kWidth = 1280; | |
1792 const int kHeight = 720; | |
1793 const size_t kNumFrames = 10; | |
1794 | |
1795 vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0); | |
1796 | |
1797 // Enable adapter, expected input resolutions when downscaling: | |
1798 // 1280x720 -> 960x540 -> 640x360 -> 480x270 -> 320x180 (min resolution limit) | |
1799 video_source_.set_adaptation_enabled(true); | |
1800 | |
1801 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution); | |
1802 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_quality_adapt_changes); | |
1803 | |
1804 int downscales = 0; | |
1805 for (size_t i = 1; i <= kNumFrames; i++) { | |
1806 video_source_.IncomingCapturedFrame(CreateFrame(i, kWidth, kHeight)); | |
1807 WaitForEncodedFrame(i); | |
1808 | |
1809 // Trigger scale down. | |
1810 rtc::VideoSinkWants last_wants = video_source_.sink_wants(); | |
1811 vie_encoder_->TriggerQualityLow(); | |
1812 EXPECT_GE(video_source_.sink_wants().max_pixel_count, kMinPixelsPerFrame); | |
1813 | |
1814 if (video_source_.sink_wants().max_pixel_count < last_wants.max_pixel_count) | |
1815 ++downscales; | |
1816 | |
1817 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution); | |
1818 EXPECT_EQ(downscales, | |
1819 stats_proxy_->GetStats().number_of_quality_adapt_changes); | |
1820 EXPECT_GT(downscales, 0); | |
1821 } | |
1822 vie_encoder_->Stop(); | |
1823 } | |
1824 | |
1825 TEST_F(ViEEncoderTest, | |
1826 AdaptsResolutionUpAndDownTwiceOnOveruse_MaintainFramerateMode) { | |
1827 const int kWidth = 1280; | |
1828 const int kHeight = 720; | |
1829 vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0); | |
1830 | |
1831 // Enable kMaintainFramerate preference, no initial limitation. | |
1832 AdaptingFrameForwarder source; | |
1833 source.set_adaptation_enabled(true); | |
1834 vie_encoder_->SetSource( | |
1835 &source, VideoSendStream::DegradationPreference::kMaintainFramerate); | |
1836 | |
1837 source.IncomingCapturedFrame(CreateFrame(1, kWidth, kHeight)); | |
1838 WaitForEncodedFrame(kWidth, kHeight); | |
1839 VerifyNoLimitation(source.sink_wants()); | |
1840 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_resolution); | |
1841 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_cpu_adapt_changes); | |
1842 | |
1843 // Trigger adapt down, expect scaled down resolution. | |
1844 vie_encoder_->TriggerCpuOveruse(); | |
1845 source.IncomingCapturedFrame(CreateFrame(2, kWidth, kHeight)); | |
1846 WaitForEncodedFrame(2); | |
1847 VerifyFpsMaxResolutionLt(source.sink_wants(), kWidth * kHeight); | |
1848 EXPECT_TRUE(stats_proxy_->GetStats().cpu_limited_resolution); | |
1849 EXPECT_EQ(1, stats_proxy_->GetStats().number_of_cpu_adapt_changes); | |
1850 | |
1851 // Trigger adapt up, expect no restriction. | |
1852 vie_encoder_->TriggerCpuNormalUsage(); | |
1853 source.IncomingCapturedFrame(CreateFrame(3, kWidth, kHeight)); | |
1854 WaitForEncodedFrame(kWidth, kHeight); | |
1855 VerifyNoLimitation(source.sink_wants()); | |
1856 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_resolution); | |
1857 EXPECT_EQ(2, stats_proxy_->GetStats().number_of_cpu_adapt_changes); | |
1858 | |
1859 // Trigger adapt down, expect scaled down resolution. | |
1860 vie_encoder_->TriggerCpuOveruse(); | |
1861 source.IncomingCapturedFrame(CreateFrame(4, kWidth, kHeight)); | |
1862 WaitForEncodedFrame(4); | |
1863 VerifyFpsMaxResolutionLt(source.sink_wants(), kWidth * kHeight); | |
1864 EXPECT_TRUE(stats_proxy_->GetStats().cpu_limited_resolution); | |
1865 EXPECT_EQ(3, stats_proxy_->GetStats().number_of_cpu_adapt_changes); | |
1866 | |
1867 // Trigger adapt up, expect no restriction. | |
1868 vie_encoder_->TriggerCpuNormalUsage(); | |
1869 source.IncomingCapturedFrame(CreateFrame(5, kWidth, kHeight)); | |
1870 sink_.WaitForEncodedFrame(kWidth, kHeight); | |
1871 VerifyNoLimitation(source.sink_wants()); | |
1872 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_resolution); | |
1873 EXPECT_EQ(4, stats_proxy_->GetStats().number_of_cpu_adapt_changes); | |
1874 | |
1875 vie_encoder_->Stop(); | |
1876 } | |
1877 | |
1878 TEST_F(ViEEncoderTest, | |
1879 AdaptsResolutionUpAndDownTwiceForLowQuality_BalancedMode_NoFpsLimit) { | |
1880 const int kWidth = 1280; | |
1881 const int kHeight = 720; | |
1882 vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0); | |
1883 | |
1884 // Enable kBalanced preference, no initial limitation. | |
1885 AdaptingFrameForwarder source; | |
1886 source.set_adaptation_enabled(true); | |
1887 vie_encoder_->SetSource(&source, | |
1888 VideoSendStream::DegradationPreference::kBalanced); | |
1889 | |
1890 source.IncomingCapturedFrame(CreateFrame(1, kWidth, kHeight)); | |
1891 sink_.WaitForEncodedFrame(kWidth, kHeight); | |
1892 VerifyNoLimitation(source.sink_wants()); | |
1893 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution); | |
1894 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_quality_adapt_changes); | |
1895 | |
1896 // Trigger adapt down, expect scaled down resolution. | |
1897 vie_encoder_->TriggerQualityLow(); | |
1898 source.IncomingCapturedFrame(CreateFrame(2, kWidth, kHeight)); | |
1899 sink_.WaitForEncodedFrame(2); | |
1900 VerifyFpsMaxResolutionLt(source.sink_wants(), kWidth * kHeight); | |
1901 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution); | |
1902 EXPECT_EQ(1, stats_proxy_->GetStats().number_of_quality_adapt_changes); | |
1903 | |
1904 // Trigger adapt up, expect no restriction. | |
1905 vie_encoder_->TriggerQualityHigh(); | |
1906 source.IncomingCapturedFrame(CreateFrame(3, kWidth, kHeight)); | |
1907 sink_.WaitForEncodedFrame(kWidth, kHeight); | |
1908 VerifyNoLimitation(source.sink_wants()); | |
1909 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution); | |
1910 EXPECT_EQ(2, stats_proxy_->GetStats().number_of_quality_adapt_changes); | |
1911 | |
1912 // Trigger adapt down, expect scaled down resolution. | |
1913 vie_encoder_->TriggerQualityLow(); | |
1914 source.IncomingCapturedFrame(CreateFrame(4, kWidth, kHeight)); | |
1915 sink_.WaitForEncodedFrame(4); | |
1916 VerifyFpsMaxResolutionLt(source.sink_wants(), kWidth * kHeight); | |
1917 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution); | |
1918 EXPECT_EQ(3, stats_proxy_->GetStats().number_of_quality_adapt_changes); | |
1919 | |
1920 // Trigger adapt up, expect no restriction. | |
1921 vie_encoder_->TriggerQualityHigh(); | |
1922 source.IncomingCapturedFrame(CreateFrame(5, kWidth, kHeight)); | |
1923 sink_.WaitForEncodedFrame(kWidth, kHeight); | |
1924 VerifyNoLimitation(source.sink_wants()); | |
1925 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution); | |
1926 EXPECT_EQ(4, stats_proxy_->GetStats().number_of_quality_adapt_changes); | |
1927 | |
1928 vie_encoder_->Stop(); | |
1929 } | |
1930 | |
1931 TEST_F(ViEEncoderTest, | |
1932 AdaptsResolutionOnOveruseAndLowQuality_MaintainFramerateMode) { | |
1933 const int kWidth = 1280; | |
1934 const int kHeight = 720; | |
1935 vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0); | |
1936 | |
1937 // Enable kMaintainFramerate preference, no initial limitation. | |
1938 AdaptingFrameForwarder source; | |
1939 source.set_adaptation_enabled(true); | |
1940 vie_encoder_->SetSource( | |
1941 &source, VideoSendStream::DegradationPreference::kMaintainFramerate); | |
1942 | |
1943 source.IncomingCapturedFrame(CreateFrame(1, kWidth, kHeight)); | |
1944 WaitForEncodedFrame(kWidth, kHeight); | |
1945 VerifyNoLimitation(source.sink_wants()); | |
1946 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_resolution); | |
1947 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution); | |
1948 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_cpu_adapt_changes); | |
1949 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_quality_adapt_changes); | |
1950 | |
1951 // Trigger cpu adapt down, expect scaled down resolution (960x540). | |
1952 vie_encoder_->TriggerCpuOveruse(); | |
1953 source.IncomingCapturedFrame(CreateFrame(2, kWidth, kHeight)); | |
1954 WaitForEncodedFrame(2); | |
1955 VerifyFpsMaxResolutionLt(source.sink_wants(), kWidth * kHeight); | |
1956 EXPECT_TRUE(stats_proxy_->GetStats().cpu_limited_resolution); | |
1957 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution); | |
1958 EXPECT_EQ(1, stats_proxy_->GetStats().number_of_cpu_adapt_changes); | |
1959 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_quality_adapt_changes); | |
1960 | |
1961 // Trigger cpu adapt down, expect scaled down resolution (640x360). | |
1962 vie_encoder_->TriggerCpuOveruse(); | |
1963 source.IncomingCapturedFrame(CreateFrame(3, kWidth, kHeight)); | |
1964 WaitForEncodedFrame(3); | |
1965 VerifyFpsMaxResolutionLt(source.sink_wants(), source.last_wants()); | |
1966 rtc::VideoSinkWants last_wants = source.sink_wants(); | |
1967 EXPECT_TRUE(stats_proxy_->GetStats().cpu_limited_resolution); | |
1968 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution); | |
1969 EXPECT_EQ(2, stats_proxy_->GetStats().number_of_cpu_adapt_changes); | |
1970 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_quality_adapt_changes); | |
1971 | |
1972 // Trigger cpu adapt down, max cpu downgrades reached, expect no change. | |
1973 vie_encoder_->TriggerCpuOveruse(); | |
1974 source.IncomingCapturedFrame(CreateFrame(4, kWidth, kHeight)); | |
1975 WaitForEncodedFrame(4); | |
1976 VerifyFpsEqResolutionEq(source.sink_wants(), last_wants); | |
1977 EXPECT_TRUE(stats_proxy_->GetStats().cpu_limited_resolution); | |
1978 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution); | |
1979 EXPECT_EQ(2, stats_proxy_->GetStats().number_of_cpu_adapt_changes); | |
1980 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_quality_adapt_changes); | |
1981 | |
1982 // Trigger quality adapt down, expect scaled down resolution (480x270). | |
1983 vie_encoder_->TriggerQualityLow(); | |
1984 source.IncomingCapturedFrame(CreateFrame(5, kWidth, kHeight)); | |
1985 WaitForEncodedFrame(5); | |
1986 VerifyFpsMaxResolutionLt(source.sink_wants(), source.last_wants()); | |
1987 EXPECT_TRUE(stats_proxy_->GetStats().cpu_limited_resolution); | |
1988 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution); | |
1989 EXPECT_EQ(2, stats_proxy_->GetStats().number_of_cpu_adapt_changes); | |
1990 EXPECT_EQ(1, stats_proxy_->GetStats().number_of_quality_adapt_changes); | |
1991 | |
1992 // Trigger cpu adapt up, expect upscaled resolution (640x360). | |
1993 vie_encoder_->TriggerCpuNormalUsage(); | |
1994 source.IncomingCapturedFrame(CreateFrame(6, kWidth, kHeight)); | |
1995 WaitForEncodedFrame(6); | |
1996 VerifyFpsMaxResolutionGt(source.sink_wants(), source.last_wants()); | |
1997 EXPECT_TRUE(stats_proxy_->GetStats().cpu_limited_resolution); | |
1998 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution); | |
1999 EXPECT_EQ(3, stats_proxy_->GetStats().number_of_cpu_adapt_changes); | |
2000 EXPECT_EQ(1, stats_proxy_->GetStats().number_of_quality_adapt_changes); | |
2001 | |
2002 // Trigger cpu adapt up, expect upscaled resolution (960x540). | |
2003 vie_encoder_->TriggerCpuNormalUsage(); | |
2004 source.IncomingCapturedFrame(CreateFrame(7, kWidth, kHeight)); | |
2005 WaitForEncodedFrame(7); | |
2006 VerifyFpsMaxResolutionGt(source.sink_wants(), source.last_wants()); | |
2007 last_wants = source.sink_wants(); | |
2008 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_resolution); | |
2009 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution); | |
2010 EXPECT_EQ(4, stats_proxy_->GetStats().number_of_cpu_adapt_changes); | |
2011 EXPECT_EQ(1, stats_proxy_->GetStats().number_of_quality_adapt_changes); | |
2012 | |
2013 // Trigger cpu adapt up, no cpu downgrades, expect no change (960x540). | |
2014 vie_encoder_->TriggerCpuNormalUsage(); | |
2015 source.IncomingCapturedFrame(CreateFrame(8, kWidth, kHeight)); | |
2016 WaitForEncodedFrame(8); | |
2017 VerifyFpsEqResolutionEq(source.sink_wants(), last_wants); | |
2018 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_resolution); | |
2019 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution); | |
2020 EXPECT_EQ(4, stats_proxy_->GetStats().number_of_cpu_adapt_changes); | |
2021 EXPECT_EQ(1, stats_proxy_->GetStats().number_of_quality_adapt_changes); | |
2022 | |
2023 // Trigger quality adapt up, expect no restriction (1280x720). | |
2024 vie_encoder_->TriggerQualityHigh(); | |
2025 source.IncomingCapturedFrame(CreateFrame(9, kWidth, kHeight)); | |
2026 WaitForEncodedFrame(kWidth, kHeight); | |
2027 VerifyFpsMaxResolutionGt(source.sink_wants(), source.last_wants()); | |
2028 VerifyNoLimitation(source.sink_wants()); | |
2029 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_resolution); | |
2030 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution); | |
2031 EXPECT_EQ(4, stats_proxy_->GetStats().number_of_cpu_adapt_changes); | |
2032 EXPECT_EQ(2, stats_proxy_->GetStats().number_of_quality_adapt_changes); | |
2033 | |
2034 vie_encoder_->Stop(); | |
2035 } | |
2036 | |
2037 TEST_F(ViEEncoderTest, CpuLimitedHistogramIsReported) { | |
2038 const int kWidth = 640; | |
2039 const int kHeight = 360; | |
2040 | |
2041 vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0); | |
2042 | |
2043 for (int i = 1; i <= SendStatisticsProxy::kMinRequiredMetricsSamples; ++i) { | |
2044 video_source_.IncomingCapturedFrame(CreateFrame(i, kWidth, kHeight)); | |
2045 WaitForEncodedFrame(i); | |
2046 } | |
2047 | |
2048 vie_encoder_->TriggerCpuOveruse(); | |
2049 for (int i = 1; i <= SendStatisticsProxy::kMinRequiredMetricsSamples; ++i) { | |
2050 video_source_.IncomingCapturedFrame(CreateFrame( | |
2051 SendStatisticsProxy::kMinRequiredMetricsSamples + i, kWidth, kHeight)); | |
2052 WaitForEncodedFrame(SendStatisticsProxy::kMinRequiredMetricsSamples + i); | |
2053 } | |
2054 | |
2055 vie_encoder_->Stop(); | |
2056 vie_encoder_.reset(); | |
2057 stats_proxy_.reset(); | |
2058 | |
2059 EXPECT_EQ(1, | |
2060 metrics::NumSamples("WebRTC.Video.CpuLimitedResolutionInPercent")); | |
2061 EXPECT_EQ( | |
2062 1, metrics::NumEvents("WebRTC.Video.CpuLimitedResolutionInPercent", 50)); | |
2063 } | |
2064 | |
2065 TEST_F(ViEEncoderTest, CpuLimitedHistogramIsNotReportedForDisabledDegradation) { | |
2066 vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0); | |
2067 const int kWidth = 640; | |
2068 const int kHeight = 360; | |
2069 | |
2070 vie_encoder_->SetSource( | |
2071 &video_source_, | |
2072 VideoSendStream::DegradationPreference::kDegradationDisabled); | |
2073 | |
2074 for (int i = 1; i <= SendStatisticsProxy::kMinRequiredMetricsSamples; ++i) { | |
2075 video_source_.IncomingCapturedFrame(CreateFrame(i, kWidth, kHeight)); | |
2076 WaitForEncodedFrame(i); | |
2077 } | |
2078 | |
2079 vie_encoder_->Stop(); | |
2080 vie_encoder_.reset(); | |
2081 stats_proxy_.reset(); | |
2082 | |
2083 EXPECT_EQ(0, | |
2084 metrics::NumSamples("WebRTC.Video.CpuLimitedResolutionInPercent")); | |
2085 } | |
2086 | |
2087 TEST_F(ViEEncoderTest, CallsBitrateObserver) { | |
2088 MockBitrateObserver bitrate_observer; | |
2089 vie_encoder_->SetBitrateObserver(&bitrate_observer); | |
2090 | |
2091 const int kDefaultFps = 30; | |
2092 const BitrateAllocation expected_bitrate = | |
2093 DefaultVideoBitrateAllocator(fake_encoder_.codec_config()) | |
2094 .GetAllocation(kLowTargetBitrateBps, kDefaultFps); | |
2095 | |
2096 // First called on bitrate updated, then again on first frame. | |
2097 EXPECT_CALL(bitrate_observer, OnBitrateAllocationUpdated(expected_bitrate)) | |
2098 .Times(2); | |
2099 vie_encoder_->OnBitrateUpdated(kLowTargetBitrateBps, 0, 0); | |
2100 | |
2101 const int64_t kStartTimeMs = 1; | |
2102 video_source_.IncomingCapturedFrame( | |
2103 CreateFrame(kStartTimeMs, codec_width_, codec_height_)); | |
2104 WaitForEncodedFrame(kStartTimeMs); | |
2105 | |
2106 // Not called on second frame. | |
2107 EXPECT_CALL(bitrate_observer, OnBitrateAllocationUpdated(expected_bitrate)) | |
2108 .Times(0); | |
2109 video_source_.IncomingCapturedFrame( | |
2110 CreateFrame(kStartTimeMs + 1, codec_width_, codec_height_)); | |
2111 WaitForEncodedFrame(kStartTimeMs + 1); | |
2112 | |
2113 // Called after a process interval. | |
2114 const int64_t kProcessIntervalMs = | |
2115 vcm::VCMProcessTimer::kDefaultProcessIntervalMs; | |
2116 fake_clock_.AdvanceTimeMicros(rtc::kNumMicrosecsPerMillisec * | |
2117 (kProcessIntervalMs + (1000 / kDefaultFps))); | |
2118 EXPECT_CALL(bitrate_observer, OnBitrateAllocationUpdated(expected_bitrate)) | |
2119 .Times(1); | |
2120 video_source_.IncomingCapturedFrame(CreateFrame( | |
2121 kStartTimeMs + kProcessIntervalMs, codec_width_, codec_height_)); | |
2122 WaitForEncodedFrame(kStartTimeMs + kProcessIntervalMs); | |
2123 | |
2124 vie_encoder_->Stop(); | |
2125 } | |
2126 | |
2127 TEST_F(ViEEncoderTest, OveruseDetectorUpdatedOnReconfigureAndAdaption) { | |
2128 const int kFrameWidth = 1280; | |
2129 const int kFrameHeight = 720; | |
2130 const int kFramerate = 24; | |
2131 | |
2132 vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0); | |
2133 test::FrameForwarder source; | |
2134 vie_encoder_->SetSource( | |
2135 &source, VideoSendStream::DegradationPreference::kMaintainResolution); | |
2136 | |
2137 // Insert a single frame, triggering initial configuration. | |
2138 source.IncomingCapturedFrame(CreateFrame(1, kFrameWidth, kFrameHeight)); | |
2139 vie_encoder_->WaitUntilTaskQueueIsIdle(); | |
2140 | |
2141 EXPECT_EQ(vie_encoder_->overuse_detector_proxy_->GetLastTargetFramerate(), | |
2142 kDefaultFramerate); | |
2143 | |
2144 // Trigger reconfigure encoder (without resetting the entire instance). | |
2145 VideoEncoderConfig video_encoder_config; | |
2146 video_encoder_config.max_bitrate_bps = kTargetBitrateBps; | |
2147 video_encoder_config.number_of_streams = 1; | |
2148 video_encoder_config.video_stream_factory = | |
2149 new rtc::RefCountedObject<VideoStreamFactory>(1, kFramerate); | |
2150 vie_encoder_->ConfigureEncoder(std::move(video_encoder_config), | |
2151 kMaxPayloadLength, false); | |
2152 vie_encoder_->WaitUntilTaskQueueIsIdle(); | |
2153 | |
2154 // Detector should be updated with fps limit from codec config. | |
2155 EXPECT_EQ(vie_encoder_->overuse_detector_proxy_->GetLastTargetFramerate(), | |
2156 kFramerate); | |
2157 | |
2158 // Trigger overuse, max framerate should be reduced. | |
2159 VideoSendStream::Stats stats = stats_proxy_->GetStats(); | |
2160 stats.input_frame_rate = kFramerate; | |
2161 stats_proxy_->SetMockStats(stats); | |
2162 vie_encoder_->TriggerCpuOveruse(); | |
2163 vie_encoder_->WaitUntilTaskQueueIsIdle(); | |
2164 int adapted_framerate = | |
2165 vie_encoder_->overuse_detector_proxy_->GetLastTargetFramerate(); | |
2166 EXPECT_LT(adapted_framerate, kFramerate); | |
2167 | |
2168 // Trigger underuse, max framerate should go back to codec configured fps. | |
2169 // Set extra low fps, to make sure it's actually reset, not just incremented. | |
2170 stats = stats_proxy_->GetStats(); | |
2171 stats.input_frame_rate = adapted_framerate / 2; | |
2172 stats_proxy_->SetMockStats(stats); | |
2173 vie_encoder_->TriggerCpuNormalUsage(); | |
2174 vie_encoder_->WaitUntilTaskQueueIsIdle(); | |
2175 EXPECT_EQ(vie_encoder_->overuse_detector_proxy_->GetLastTargetFramerate(), | |
2176 kFramerate); | |
2177 | |
2178 vie_encoder_->Stop(); | |
2179 } | |
2180 | |
2181 TEST_F(ViEEncoderTest, OveruseDetectorUpdatedRespectsFramerateAfterUnderuse) { | |
2182 const int kFrameWidth = 1280; | |
2183 const int kFrameHeight = 720; | |
2184 const int kLowFramerate = 15; | |
2185 const int kHighFramerate = 25; | |
2186 | |
2187 vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0); | |
2188 test::FrameForwarder source; | |
2189 vie_encoder_->SetSource( | |
2190 &source, VideoSendStream::DegradationPreference::kMaintainResolution); | |
2191 | |
2192 // Trigger initial configuration. | |
2193 VideoEncoderConfig video_encoder_config; | |
2194 video_encoder_config.max_bitrate_bps = kTargetBitrateBps; | |
2195 video_encoder_config.number_of_streams = 1; | |
2196 video_encoder_config.video_stream_factory = | |
2197 new rtc::RefCountedObject<VideoStreamFactory>(1, kLowFramerate); | |
2198 source.IncomingCapturedFrame(CreateFrame(1, kFrameWidth, kFrameHeight)); | |
2199 vie_encoder_->ConfigureEncoder(std::move(video_encoder_config), | |
2200 kMaxPayloadLength, false); | |
2201 vie_encoder_->WaitUntilTaskQueueIsIdle(); | |
2202 | |
2203 EXPECT_EQ(vie_encoder_->overuse_detector_proxy_->GetLastTargetFramerate(), | |
2204 kLowFramerate); | |
2205 | |
2206 // Trigger overuse, max framerate should be reduced. | |
2207 VideoSendStream::Stats stats = stats_proxy_->GetStats(); | |
2208 stats.input_frame_rate = kLowFramerate; | |
2209 stats_proxy_->SetMockStats(stats); | |
2210 vie_encoder_->TriggerCpuOveruse(); | |
2211 vie_encoder_->WaitUntilTaskQueueIsIdle(); | |
2212 int adapted_framerate = | |
2213 vie_encoder_->overuse_detector_proxy_->GetLastTargetFramerate(); | |
2214 EXPECT_LT(adapted_framerate, kLowFramerate); | |
2215 | |
2216 // Reconfigure the encoder with a new (higher max framerate), max fps should | |
2217 // still respect the adaptation. | |
2218 video_encoder_config.video_stream_factory = | |
2219 new rtc::RefCountedObject<VideoStreamFactory>(1, kHighFramerate); | |
2220 source.IncomingCapturedFrame(CreateFrame(1, kFrameWidth, kFrameHeight)); | |
2221 vie_encoder_->ConfigureEncoder(std::move(video_encoder_config), | |
2222 kMaxPayloadLength, false); | |
2223 vie_encoder_->WaitUntilTaskQueueIsIdle(); | |
2224 | |
2225 EXPECT_EQ(vie_encoder_->overuse_detector_proxy_->GetLastTargetFramerate(), | |
2226 adapted_framerate); | |
2227 | |
2228 // Trigger underuse, max framerate should go back to codec configured fps. | |
2229 stats = stats_proxy_->GetStats(); | |
2230 stats.input_frame_rate = adapted_framerate; | |
2231 stats_proxy_->SetMockStats(stats); | |
2232 vie_encoder_->TriggerCpuNormalUsage(); | |
2233 vie_encoder_->WaitUntilTaskQueueIsIdle(); | |
2234 EXPECT_EQ(vie_encoder_->overuse_detector_proxy_->GetLastTargetFramerate(), | |
2235 kHighFramerate); | |
2236 | |
2237 vie_encoder_->Stop(); | |
2238 } | |
2239 | |
2240 TEST_F(ViEEncoderTest, OveruseDetectorUpdatedOnDegradationPreferenceChange) { | |
2241 const int kFrameWidth = 1280; | |
2242 const int kFrameHeight = 720; | |
2243 const int kFramerate = 24; | |
2244 | |
2245 vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0); | |
2246 test::FrameForwarder source; | |
2247 vie_encoder_->SetSource( | |
2248 &source, VideoSendStream::DegradationPreference::kMaintainResolution); | |
2249 | |
2250 // Trigger initial configuration. | |
2251 VideoEncoderConfig video_encoder_config; | |
2252 video_encoder_config.max_bitrate_bps = kTargetBitrateBps; | |
2253 video_encoder_config.number_of_streams = 1; | |
2254 video_encoder_config.video_stream_factory = | |
2255 new rtc::RefCountedObject<VideoStreamFactory>(1, kFramerate); | |
2256 source.IncomingCapturedFrame(CreateFrame(1, kFrameWidth, kFrameHeight)); | |
2257 vie_encoder_->ConfigureEncoder(std::move(video_encoder_config), | |
2258 kMaxPayloadLength, false); | |
2259 vie_encoder_->WaitUntilTaskQueueIsIdle(); | |
2260 | |
2261 EXPECT_EQ(vie_encoder_->overuse_detector_proxy_->GetLastTargetFramerate(), | |
2262 kFramerate); | |
2263 | |
2264 // Trigger overuse, max framerate should be reduced. | |
2265 VideoSendStream::Stats stats = stats_proxy_->GetStats(); | |
2266 stats.input_frame_rate = kFramerate; | |
2267 stats_proxy_->SetMockStats(stats); | |
2268 vie_encoder_->TriggerCpuOveruse(); | |
2269 vie_encoder_->WaitUntilTaskQueueIsIdle(); | |
2270 int adapted_framerate = | |
2271 vie_encoder_->overuse_detector_proxy_->GetLastTargetFramerate(); | |
2272 EXPECT_LT(adapted_framerate, kFramerate); | |
2273 | |
2274 // Change degradation preference to not enable framerate scaling. Target | |
2275 // framerate should be changed to codec defined limit. | |
2276 vie_encoder_->SetSource( | |
2277 &source, VideoSendStream::DegradationPreference::kMaintainFramerate); | |
2278 vie_encoder_->WaitUntilTaskQueueIsIdle(); | |
2279 EXPECT_EQ(vie_encoder_->overuse_detector_proxy_->GetLastTargetFramerate(), | |
2280 kFramerate); | |
2281 | |
2282 vie_encoder_->Stop(); | |
2283 } | |
2284 | |
2285 TEST_F(ViEEncoderTest, DropsFramesAndScalesWhenBitrateIsTooLow) { | |
2286 const int kTooLowBitrateForFrameSizeBps = 10000; | |
2287 vie_encoder_->OnBitrateUpdated(kTooLowBitrateForFrameSizeBps, 0, 0); | |
2288 const int kWidth = 640; | |
2289 const int kHeight = 360; | |
2290 | |
2291 video_source_.IncomingCapturedFrame(CreateFrame(1, kWidth, kHeight)); | |
2292 | |
2293 // Expect to drop this frame, the wait should time out. | |
2294 ExpectDroppedFrame(); | |
2295 | |
2296 // Expect the sink_wants to specify a scaled frame. | |
2297 EXPECT_LT(video_source_.sink_wants().max_pixel_count, kWidth * kHeight); | |
2298 | |
2299 int last_pixel_count = video_source_.sink_wants().max_pixel_count; | |
2300 | |
2301 // Next frame is scaled. | |
2302 video_source_.IncomingCapturedFrame( | |
2303 CreateFrame(2, kWidth * 3 / 4, kHeight * 3 / 4)); | |
2304 | |
2305 // Expect to drop this frame, the wait should time out. | |
2306 ExpectDroppedFrame(); | |
2307 | |
2308 EXPECT_LT(video_source_.sink_wants().max_pixel_count, last_pixel_count); | |
2309 | |
2310 vie_encoder_->Stop(); | |
2311 } | |
2312 | |
2313 TEST_F(ViEEncoderTest, NumberOfDroppedFramesLimitedWhenBitrateIsTooLow) { | |
2314 const int kTooLowBitrateForFrameSizeBps = 10000; | |
2315 vie_encoder_->OnBitrateUpdated(kTooLowBitrateForFrameSizeBps, 0, 0); | |
2316 const int kWidth = 640; | |
2317 const int kHeight = 360; | |
2318 | |
2319 // We expect the n initial frames to get dropped. | |
2320 int i; | |
2321 for (i = 1; i <= kMaxInitialFramedrop; ++i) { | |
2322 video_source_.IncomingCapturedFrame(CreateFrame(i, kWidth, kHeight)); | |
2323 ExpectDroppedFrame(); | |
2324 } | |
2325 // The n+1th frame should not be dropped, even though it's size is too large. | |
2326 video_source_.IncomingCapturedFrame(CreateFrame(i, kWidth, kHeight)); | |
2327 WaitForEncodedFrame(i); | |
2328 | |
2329 // Expect the sink_wants to specify a scaled frame. | |
2330 EXPECT_LT(video_source_.sink_wants().max_pixel_count, kWidth * kHeight); | |
2331 | |
2332 vie_encoder_->Stop(); | |
2333 } | |
2334 | |
2335 TEST_F(ViEEncoderTest, InitialFrameDropOffWithMaintainResolutionPreference) { | |
2336 const int kWidth = 640; | |
2337 const int kHeight = 360; | |
2338 vie_encoder_->OnBitrateUpdated(kLowTargetBitrateBps, 0, 0); | |
2339 | |
2340 // Set degradation preference. | |
2341 vie_encoder_->SetSource( | |
2342 &video_source_, | |
2343 VideoSendStream::DegradationPreference::kMaintainResolution); | |
2344 | |
2345 video_source_.IncomingCapturedFrame(CreateFrame(1, kWidth, kHeight)); | |
2346 // Frame should not be dropped, even if it's too large. | |
2347 WaitForEncodedFrame(1); | |
2348 | |
2349 vie_encoder_->Stop(); | |
2350 } | |
2351 | |
2352 TEST_F(ViEEncoderTest, InitialFrameDropOffWhenEncoderDisabledScaling) { | |
2353 const int kWidth = 640; | |
2354 const int kHeight = 360; | |
2355 fake_encoder_.SetQualityScaling(false); | |
2356 vie_encoder_->OnBitrateUpdated(kLowTargetBitrateBps, 0, 0); | |
2357 | |
2358 // Force quality scaler reconfiguration by resetting the source. | |
2359 vie_encoder_->SetSource(&video_source_, | |
2360 VideoSendStream::DegradationPreference::kBalanced); | |
2361 | |
2362 video_source_.IncomingCapturedFrame(CreateFrame(1, kWidth, kHeight)); | |
2363 // Frame should not be dropped, even if it's too large. | |
2364 WaitForEncodedFrame(1); | |
2365 | |
2366 vie_encoder_->Stop(); | |
2367 fake_encoder_.SetQualityScaling(true); | |
2368 } | |
2369 | |
2370 TEST_F(ViEEncoderTest, | |
2371 ResolutionNotAdaptedForTooSmallFrame_MaintainFramerateMode) { | |
2372 const int kTooSmallWidth = 10; | |
2373 const int kTooSmallHeight = 10; | |
2374 vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0); | |
2375 | |
2376 // Enable kMaintainFramerate preference, no initial limitation. | |
2377 test::FrameForwarder source; | |
2378 vie_encoder_->SetSource( | |
2379 &source, VideoSendStream::DegradationPreference::kMaintainFramerate); | |
2380 VerifyNoLimitation(source.sink_wants()); | |
2381 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_resolution); | |
2382 | |
2383 // Trigger adapt down, too small frame, expect no change. | |
2384 source.IncomingCapturedFrame(CreateFrame(1, kTooSmallWidth, kTooSmallHeight)); | |
2385 WaitForEncodedFrame(1); | |
2386 vie_encoder_->TriggerCpuOveruse(); | |
2387 VerifyNoLimitation(source.sink_wants()); | |
2388 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_resolution); | |
2389 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_cpu_adapt_changes); | |
2390 | |
2391 vie_encoder_->Stop(); | |
2392 } | |
2393 | |
2394 TEST_F(ViEEncoderTest, ResolutionNotAdaptedForTooSmallFrame_BalancedMode) { | |
2395 const int kTooSmallWidth = 10; | |
2396 const int kTooSmallHeight = 10; | |
2397 const int kFpsLimit = 7; | |
2398 vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0); | |
2399 | |
2400 // Enable kBalanced preference, no initial limitation. | |
2401 test::FrameForwarder source; | |
2402 vie_encoder_->SetSource(&source, | |
2403 VideoSendStream::DegradationPreference::kBalanced); | |
2404 VerifyNoLimitation(source.sink_wants()); | |
2405 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution); | |
2406 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_framerate); | |
2407 | |
2408 // Trigger adapt down, expect limited framerate. | |
2409 source.IncomingCapturedFrame(CreateFrame(1, kTooSmallWidth, kTooSmallHeight)); | |
2410 WaitForEncodedFrame(1); | |
2411 vie_encoder_->TriggerQualityLow(); | |
2412 VerifyFpsEqResolutionMax(source.sink_wants(), kFpsLimit); | |
2413 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution); | |
2414 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_framerate); | |
2415 EXPECT_EQ(1, stats_proxy_->GetStats().number_of_quality_adapt_changes); | |
2416 | |
2417 // Trigger adapt down, too small frame, expect no change. | |
2418 source.IncomingCapturedFrame(CreateFrame(2, kTooSmallWidth, kTooSmallHeight)); | |
2419 WaitForEncodedFrame(2); | |
2420 vie_encoder_->TriggerQualityLow(); | |
2421 VerifyFpsEqResolutionMax(source.sink_wants(), kFpsLimit); | |
2422 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution); | |
2423 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_framerate); | |
2424 EXPECT_EQ(1, stats_proxy_->GetStats().number_of_quality_adapt_changes); | |
2425 | |
2426 vie_encoder_->Stop(); | |
2427 } | |
2428 | |
2429 TEST_F(ViEEncoderTest, FailingInitEncodeDoesntCauseCrash) { | |
2430 fake_encoder_.ForceInitEncodeFailure(true); | |
2431 vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0); | |
2432 ResetEncoder("VP8", 2, 1, true, false); | |
2433 const int kFrameWidth = 1280; | |
2434 const int kFrameHeight = 720; | |
2435 video_source_.IncomingCapturedFrame( | |
2436 CreateFrame(1, kFrameWidth, kFrameHeight)); | |
2437 ExpectDroppedFrame(); | |
2438 vie_encoder_->Stop(); | |
2439 } | |
2440 | |
2441 // TODO(sprang): Extend this with fps throttling and any "balanced" extensions. | |
2442 TEST_F(ViEEncoderTest, AdaptsResolutionOnOveruse_MaintainFramerateMode) { | |
2443 vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0); | |
2444 | |
2445 const int kFrameWidth = 1280; | |
2446 const int kFrameHeight = 720; | |
2447 // Enabled default VideoAdapter downscaling. First step is 3/4, not 3/5 as | |
2448 // requested by ViEEncoder::VideoSourceProxy::RequestResolutionLowerThan(). | |
2449 video_source_.set_adaptation_enabled(true); | |
2450 | |
2451 video_source_.IncomingCapturedFrame( | |
2452 CreateFrame(1, kFrameWidth, kFrameHeight)); | |
2453 WaitForEncodedFrame(kFrameWidth, kFrameHeight); | |
2454 | |
2455 // Trigger CPU overuse, downscale by 3/4. | |
2456 vie_encoder_->TriggerCpuOveruse(); | |
2457 video_source_.IncomingCapturedFrame( | |
2458 CreateFrame(2, kFrameWidth, kFrameHeight)); | |
2459 WaitForEncodedFrame((kFrameWidth * 3) / 4, (kFrameHeight * 3) / 4); | |
2460 | |
2461 // Trigger CPU normal use, return to original resolution. | |
2462 vie_encoder_->TriggerCpuNormalUsage(); | |
2463 video_source_.IncomingCapturedFrame( | |
2464 CreateFrame(3, kFrameWidth, kFrameHeight)); | |
2465 WaitForEncodedFrame(kFrameWidth, kFrameHeight); | |
2466 | |
2467 vie_encoder_->Stop(); | |
2468 } | |
2469 | |
2470 TEST_F(ViEEncoderTest, AdaptsFramerateOnOveruse_MaintainResolutionMode) { | |
2471 const int kFrameWidth = 1280; | |
2472 const int kFrameHeight = 720; | |
2473 int kFrameIntervalMs = rtc::kNumMillisecsPerSec / max_framerate_; | |
2474 | |
2475 vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0); | |
2476 vie_encoder_->SetSource( | |
2477 &video_source_, | |
2478 VideoSendStream::DegradationPreference::kMaintainResolution); | |
2479 video_source_.set_adaptation_enabled(true); | |
2480 | |
2481 int64_t timestamp_ms = fake_clock_.TimeNanos() / rtc::kNumNanosecsPerMillisec; | |
2482 | |
2483 video_source_.IncomingCapturedFrame( | |
2484 CreateFrame(timestamp_ms, kFrameWidth, kFrameHeight)); | |
2485 WaitForEncodedFrame(timestamp_ms); | |
2486 | |
2487 // Try to trigger overuse. No fps estimate available => no effect. | |
2488 vie_encoder_->TriggerCpuOveruse(); | |
2489 | |
2490 // Insert frames for one second to get a stable estimate. | |
2491 for (int i = 0; i < max_framerate_; ++i) { | |
2492 timestamp_ms += kFrameIntervalMs; | |
2493 video_source_.IncomingCapturedFrame( | |
2494 CreateFrame(timestamp_ms, kFrameWidth, kFrameHeight)); | |
2495 WaitForEncodedFrame(timestamp_ms); | |
2496 } | |
2497 | |
2498 // Trigger CPU overuse, reduce framerate by 2/3. | |
2499 vie_encoder_->TriggerCpuOveruse(); | |
2500 int num_frames_dropped = 0; | |
2501 for (int i = 0; i < max_framerate_; ++i) { | |
2502 timestamp_ms += kFrameIntervalMs; | |
2503 video_source_.IncomingCapturedFrame( | |
2504 CreateFrame(timestamp_ms, kFrameWidth, kFrameHeight)); | |
2505 if (!WaitForFrame(kFrameTimeoutMs)) { | |
2506 ++num_frames_dropped; | |
2507 } else { | |
2508 sink_.CheckLastFrameSizeMathces(kFrameWidth, kFrameHeight); | |
2509 } | |
2510 } | |
2511 | |
2512 // Add some slack to account for frames dropped by the frame dropper. | |
2513 const int kErrorMargin = 1; | |
2514 EXPECT_NEAR(num_frames_dropped, max_framerate_ - (max_framerate_ * 2 / 3), | |
2515 kErrorMargin); | |
2516 | |
2517 // Trigger CPU overuse, reduce framerate by 2/3 again. | |
2518 vie_encoder_->TriggerCpuOveruse(); | |
2519 num_frames_dropped = 0; | |
2520 for (int i = 0; i < max_framerate_; ++i) { | |
2521 timestamp_ms += kFrameIntervalMs; | |
2522 video_source_.IncomingCapturedFrame( | |
2523 CreateFrame(timestamp_ms, kFrameWidth, kFrameHeight)); | |
2524 if (!WaitForFrame(kFrameTimeoutMs)) { | |
2525 ++num_frames_dropped; | |
2526 } else { | |
2527 sink_.CheckLastFrameSizeMathces(kFrameWidth, kFrameHeight); | |
2528 } | |
2529 } | |
2530 EXPECT_NEAR(num_frames_dropped, max_framerate_ - (max_framerate_ * 4 / 9), | |
2531 kErrorMargin); | |
2532 | |
2533 // Go back up one step. | |
2534 vie_encoder_->TriggerCpuNormalUsage(); | |
2535 num_frames_dropped = 0; | |
2536 for (int i = 0; i < max_framerate_; ++i) { | |
2537 timestamp_ms += kFrameIntervalMs; | |
2538 video_source_.IncomingCapturedFrame( | |
2539 CreateFrame(timestamp_ms, kFrameWidth, kFrameHeight)); | |
2540 if (!WaitForFrame(kFrameTimeoutMs)) { | |
2541 ++num_frames_dropped; | |
2542 } else { | |
2543 sink_.CheckLastFrameSizeMathces(kFrameWidth, kFrameHeight); | |
2544 } | |
2545 } | |
2546 EXPECT_NEAR(num_frames_dropped, max_framerate_ - (max_framerate_ * 2 / 3), | |
2547 kErrorMargin); | |
2548 | |
2549 // Go back up to original mode. | |
2550 vie_encoder_->TriggerCpuNormalUsage(); | |
2551 num_frames_dropped = 0; | |
2552 for (int i = 0; i < max_framerate_; ++i) { | |
2553 timestamp_ms += kFrameIntervalMs; | |
2554 video_source_.IncomingCapturedFrame( | |
2555 CreateFrame(timestamp_ms, kFrameWidth, kFrameHeight)); | |
2556 if (!WaitForFrame(kFrameTimeoutMs)) { | |
2557 ++num_frames_dropped; | |
2558 } else { | |
2559 sink_.CheckLastFrameSizeMathces(kFrameWidth, kFrameHeight); | |
2560 } | |
2561 } | |
2562 EXPECT_NEAR(num_frames_dropped, 0, kErrorMargin); | |
2563 | |
2564 vie_encoder_->Stop(); | |
2565 } | |
2566 | |
2567 TEST_F(ViEEncoderTest, DoesntAdaptDownPastMinFramerate) { | |
2568 const int kFramerateFps = 5; | |
2569 const int kFrameIntervalMs = rtc::kNumMillisecsPerSec / kFramerateFps; | |
2570 const int kMinFpsFrameInterval = rtc::kNumMillisecsPerSec / kMinFramerateFps; | |
2571 const int kFrameWidth = 1280; | |
2572 const int kFrameHeight = 720; | |
2573 | |
2574 // Reconfigure encoder with two temporal layers and screensharing, which will | |
2575 // disable frame dropping and make testing easier. | |
2576 ResetEncoder("VP8", 1, 2, true, true); | |
2577 | |
2578 vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0); | |
2579 vie_encoder_->SetSource( | |
2580 &video_source_, | |
2581 VideoSendStream::DegradationPreference::kMaintainResolution); | |
2582 video_source_.set_adaptation_enabled(true); | |
2583 | |
2584 int64_t timestamp_ms = fake_clock_.TimeNanos() / rtc::kNumNanosecsPerMillisec; | |
2585 | |
2586 // Trigger overuse as much as we can. | |
2587 for (int i = 0; i < ViEEncoder::kMaxCpuResolutionDowngrades; ++i) { | |
2588 // Insert frames to get a new fps estimate... | |
2589 for (int j = 0; j < kFramerateFps; ++j) { | |
2590 video_source_.IncomingCapturedFrame( | |
2591 CreateFrame(timestamp_ms, kFrameWidth, kFrameHeight)); | |
2592 timestamp_ms += kFrameIntervalMs; | |
2593 } | |
2594 // ...and then try to adapt again. | |
2595 vie_encoder_->TriggerCpuOveruse(); | |
2596 } | |
2597 | |
2598 // Drain any frame in the pipeline. | |
2599 WaitForFrame(kDefaultTimeoutMs); | |
2600 | |
2601 // Insert frames at min fps, all should go through. | |
2602 for (int i = 0; i < 10; ++i) { | |
2603 timestamp_ms += kMinFpsFrameInterval; | |
2604 video_source_.IncomingCapturedFrame( | |
2605 CreateFrame(timestamp_ms, kFrameWidth, kFrameHeight)); | |
2606 WaitForEncodedFrame(timestamp_ms); | |
2607 } | |
2608 | |
2609 vie_encoder_->Stop(); | |
2610 } | |
2611 | |
2612 TEST_F(ViEEncoderTest, AdaptsResolutionAndFramerateForLowQuality_BalancedMode) { | |
2613 const int kWidth = 1280; | |
2614 const int kHeight = 720; | |
2615 const int64_t kFrameIntervalMs = 150; | |
2616 int64_t timestamp_ms = kFrameIntervalMs; | |
2617 vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0); | |
2618 | |
2619 // Enable kBalanced preference, no initial limitation. | |
2620 AdaptingFrameForwarder source; | |
2621 source.set_adaptation_enabled(true); | |
2622 vie_encoder_->SetSource(&source, | |
2623 VideoSendStream::DegradationPreference::kBalanced); | |
2624 timestamp_ms += kFrameIntervalMs; | |
2625 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight)); | |
2626 WaitForEncodedFrame(kWidth, kHeight); | |
2627 VerifyNoLimitation(source.sink_wants()); | |
2628 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution); | |
2629 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_framerate); | |
2630 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_quality_adapt_changes); | |
2631 | |
2632 // Trigger adapt down, expect scaled down resolution (960x540@30fps). | |
2633 vie_encoder_->TriggerQualityLow(); | |
2634 timestamp_ms += kFrameIntervalMs; | |
2635 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight)); | |
2636 WaitForEncodedFrame(timestamp_ms); | |
2637 VerifyFpsMaxResolutionLt(source.sink_wants(), kWidth * kHeight); | |
2638 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution); | |
2639 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_framerate); | |
2640 EXPECT_EQ(1, stats_proxy_->GetStats().number_of_quality_adapt_changes); | |
2641 | |
2642 // Trigger adapt down, expect scaled down resolution (640x360@30fps). | |
2643 vie_encoder_->TriggerQualityLow(); | |
2644 timestamp_ms += kFrameIntervalMs; | |
2645 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight)); | |
2646 WaitForEncodedFrame(timestamp_ms); | |
2647 VerifyFpsMaxResolutionLt(source.sink_wants(), source.last_wants()); | |
2648 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution); | |
2649 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_framerate); | |
2650 EXPECT_EQ(2, stats_proxy_->GetStats().number_of_quality_adapt_changes); | |
2651 | |
2652 // Trigger adapt down, expect reduced fps (640x360@15fps). | |
2653 vie_encoder_->TriggerQualityLow(); | |
2654 timestamp_ms += kFrameIntervalMs; | |
2655 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight)); | |
2656 WaitForEncodedFrame(timestamp_ms); | |
2657 VerifyFpsLtResolutionEq(source.sink_wants(), source.last_wants()); | |
2658 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution); | |
2659 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_framerate); | |
2660 EXPECT_EQ(3, stats_proxy_->GetStats().number_of_quality_adapt_changes); | |
2661 | |
2662 // Trigger adapt down, expect scaled down resolution (480x270@15fps). | |
2663 vie_encoder_->TriggerQualityLow(); | |
2664 timestamp_ms += kFrameIntervalMs; | |
2665 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight)); | |
2666 WaitForEncodedFrame(timestamp_ms); | |
2667 VerifyFpsEqResolutionLt(source.sink_wants(), source.last_wants()); | |
2668 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution); | |
2669 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_framerate); | |
2670 EXPECT_EQ(4, stats_proxy_->GetStats().number_of_quality_adapt_changes); | |
2671 | |
2672 // Restrict bitrate, trigger adapt down, expect reduced fps (480x270@10fps). | |
2673 vie_encoder_->TriggerQualityLow(); | |
2674 timestamp_ms += kFrameIntervalMs; | |
2675 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight)); | |
2676 WaitForEncodedFrame(timestamp_ms); | |
2677 VerifyFpsLtResolutionEq(source.sink_wants(), source.last_wants()); | |
2678 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution); | |
2679 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_framerate); | |
2680 EXPECT_EQ(5, stats_proxy_->GetStats().number_of_quality_adapt_changes); | |
2681 | |
2682 // Trigger adapt down, expect scaled down resolution (320x180@10fps). | |
2683 vie_encoder_->TriggerQualityLow(); | |
2684 timestamp_ms += kFrameIntervalMs; | |
2685 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight)); | |
2686 WaitForEncodedFrame(timestamp_ms); | |
2687 VerifyFpsEqResolutionLt(source.sink_wants(), source.last_wants()); | |
2688 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution); | |
2689 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_framerate); | |
2690 EXPECT_EQ(6, stats_proxy_->GetStats().number_of_quality_adapt_changes); | |
2691 | |
2692 // Trigger adapt down, expect reduced fps (320x180@7fps). | |
2693 vie_encoder_->TriggerQualityLow(); | |
2694 timestamp_ms += kFrameIntervalMs; | |
2695 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight)); | |
2696 WaitForEncodedFrame(timestamp_ms); | |
2697 VerifyFpsLtResolutionEq(source.sink_wants(), source.last_wants()); | |
2698 rtc::VideoSinkWants last_wants = source.sink_wants(); | |
2699 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution); | |
2700 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_framerate); | |
2701 EXPECT_EQ(7, stats_proxy_->GetStats().number_of_quality_adapt_changes); | |
2702 | |
2703 // Trigger adapt down, min resolution reached, expect no change. | |
2704 vie_encoder_->TriggerQualityLow(); | |
2705 timestamp_ms += kFrameIntervalMs; | |
2706 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight)); | |
2707 WaitForEncodedFrame(timestamp_ms); | |
2708 VerifyFpsEqResolutionEq(source.sink_wants(), last_wants); | |
2709 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution); | |
2710 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_framerate); | |
2711 EXPECT_EQ(7, stats_proxy_->GetStats().number_of_quality_adapt_changes); | |
2712 | |
2713 // Trigger adapt down, expect expect increased fps (320x180@10fps). | |
2714 vie_encoder_->TriggerQualityHigh(); | |
2715 timestamp_ms += kFrameIntervalMs; | |
2716 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight)); | |
2717 WaitForEncodedFrame(timestamp_ms); | |
2718 VerifyFpsGtResolutionEq(source.sink_wants(), source.last_wants()); | |
2719 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution); | |
2720 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_framerate); | |
2721 EXPECT_EQ(8, stats_proxy_->GetStats().number_of_quality_adapt_changes); | |
2722 | |
2723 // Trigger adapt up, expect upscaled resolution (480x270@10fps). | |
2724 vie_encoder_->TriggerQualityHigh(); | |
2725 timestamp_ms += kFrameIntervalMs; | |
2726 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight)); | |
2727 WaitForEncodedFrame(timestamp_ms); | |
2728 VerifyFpsEqResolutionGt(source.sink_wants(), source.last_wants()); | |
2729 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution); | |
2730 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_framerate); | |
2731 EXPECT_EQ(9, stats_proxy_->GetStats().number_of_quality_adapt_changes); | |
2732 | |
2733 // Increase bitrate, trigger adapt up, expect increased fps (480x270@15fps). | |
2734 vie_encoder_->TriggerQualityHigh(); | |
2735 timestamp_ms += kFrameIntervalMs; | |
2736 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight)); | |
2737 WaitForEncodedFrame(timestamp_ms); | |
2738 VerifyFpsGtResolutionEq(source.sink_wants(), source.last_wants()); | |
2739 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution); | |
2740 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_framerate); | |
2741 EXPECT_EQ(10, stats_proxy_->GetStats().number_of_quality_adapt_changes); | |
2742 | |
2743 // Trigger adapt up, expect upscaled resolution (640x360@15fps). | |
2744 vie_encoder_->TriggerQualityHigh(); | |
2745 timestamp_ms += kFrameIntervalMs; | |
2746 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight)); | |
2747 WaitForEncodedFrame(timestamp_ms); | |
2748 VerifyFpsEqResolutionGt(source.sink_wants(), source.last_wants()); | |
2749 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution); | |
2750 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_framerate); | |
2751 EXPECT_EQ(11, stats_proxy_->GetStats().number_of_quality_adapt_changes); | |
2752 | |
2753 // Trigger adapt up, expect increased fps (640x360@30fps). | |
2754 vie_encoder_->TriggerQualityHigh(); | |
2755 timestamp_ms += kFrameIntervalMs; | |
2756 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight)); | |
2757 WaitForEncodedFrame(timestamp_ms); | |
2758 VerifyFpsMaxResolutionEq(source.sink_wants(), source.last_wants()); | |
2759 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution); | |
2760 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_framerate); | |
2761 EXPECT_EQ(12, stats_proxy_->GetStats().number_of_quality_adapt_changes); | |
2762 | |
2763 // Trigger adapt up, expect upscaled resolution (960x540@30fps). | |
2764 vie_encoder_->TriggerQualityHigh(); | |
2765 timestamp_ms += kFrameIntervalMs; | |
2766 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight)); | |
2767 WaitForEncodedFrame(timestamp_ms); | |
2768 VerifyFpsMaxResolutionGt(source.sink_wants(), source.last_wants()); | |
2769 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution); | |
2770 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_framerate); | |
2771 EXPECT_EQ(13, stats_proxy_->GetStats().number_of_quality_adapt_changes); | |
2772 | |
2773 // Trigger adapt up, expect no restriction (1280x720fps@30fps). | |
2774 vie_encoder_->TriggerQualityHigh(); | |
2775 timestamp_ms += kFrameIntervalMs; | |
2776 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight)); | |
2777 WaitForEncodedFrame(kWidth, kHeight); | |
2778 VerifyFpsMaxResolutionGt(source.sink_wants(), source.last_wants()); | |
2779 VerifyNoLimitation(source.sink_wants()); | |
2780 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution); | |
2781 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_framerate); | |
2782 EXPECT_EQ(14, stats_proxy_->GetStats().number_of_quality_adapt_changes); | |
2783 | |
2784 // Trigger adapt up, expect no change. | |
2785 vie_encoder_->TriggerQualityHigh(); | |
2786 VerifyNoLimitation(source.sink_wants()); | |
2787 EXPECT_EQ(14, stats_proxy_->GetStats().number_of_quality_adapt_changes); | |
2788 | |
2789 vie_encoder_->Stop(); | |
2790 } | |
2791 | |
2792 TEST_F(ViEEncoderTest, AdaptWithTwoReasonsAndDifferentOrder_Framerate) { | |
2793 const int kWidth = 1280; | |
2794 const int kHeight = 720; | |
2795 const int64_t kFrameIntervalMs = 150; | |
2796 int64_t timestamp_ms = kFrameIntervalMs; | |
2797 vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0); | |
2798 | |
2799 // Enable kBalanced preference, no initial limitation. | |
2800 AdaptingFrameForwarder source; | |
2801 source.set_adaptation_enabled(true); | |
2802 vie_encoder_->SetSource(&source, | |
2803 VideoSendStream::DegradationPreference::kBalanced); | |
2804 timestamp_ms += kFrameIntervalMs; | |
2805 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight)); | |
2806 WaitForEncodedFrame(kWidth, kHeight); | |
2807 VerifyNoLimitation(source.sink_wants()); | |
2808 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution); | |
2809 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_framerate); | |
2810 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_resolution); | |
2811 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_framerate); | |
2812 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_cpu_adapt_changes); | |
2813 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_quality_adapt_changes); | |
2814 | |
2815 // Trigger cpu adapt down, expect scaled down resolution (960x540@30fps). | |
2816 vie_encoder_->TriggerCpuOveruse(); | |
2817 timestamp_ms += kFrameIntervalMs; | |
2818 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight)); | |
2819 WaitForEncodedFrame(timestamp_ms); | |
2820 VerifyFpsMaxResolutionLt(source.sink_wants(), kWidth * kHeight); | |
2821 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution); | |
2822 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_framerate); | |
2823 EXPECT_TRUE(stats_proxy_->GetStats().cpu_limited_resolution); | |
2824 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_framerate); | |
2825 EXPECT_EQ(1, stats_proxy_->GetStats().number_of_cpu_adapt_changes); | |
2826 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_quality_adapt_changes); | |
2827 | |
2828 // Trigger cpu adapt down, expect scaled down resolution (640x360@30fps). | |
2829 vie_encoder_->TriggerCpuOveruse(); | |
2830 timestamp_ms += kFrameIntervalMs; | |
2831 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight)); | |
2832 WaitForEncodedFrame(timestamp_ms); | |
2833 VerifyFpsMaxResolutionLt(source.sink_wants(), source.last_wants()); | |
2834 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution); | |
2835 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_framerate); | |
2836 EXPECT_TRUE(stats_proxy_->GetStats().cpu_limited_resolution); | |
2837 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_framerate); | |
2838 EXPECT_EQ(2, stats_proxy_->GetStats().number_of_cpu_adapt_changes); | |
2839 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_quality_adapt_changes); | |
2840 | |
2841 // Trigger quality adapt down, expect reduced fps (640x360@15fps). | |
2842 vie_encoder_->TriggerQualityLow(); | |
2843 timestamp_ms += kFrameIntervalMs; | |
2844 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight)); | |
2845 WaitForEncodedFrame(timestamp_ms); | |
2846 VerifyFpsLtResolutionEq(source.sink_wants(), source.last_wants()); | |
2847 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution); | |
2848 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_framerate); | |
2849 EXPECT_TRUE(stats_proxy_->GetStats().cpu_limited_resolution); | |
2850 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_framerate); | |
2851 EXPECT_EQ(2, stats_proxy_->GetStats().number_of_cpu_adapt_changes); | |
2852 EXPECT_EQ(1, stats_proxy_->GetStats().number_of_quality_adapt_changes); | |
2853 | |
2854 // Trigger cpu adapt up, expect increased fps (640x360@30fps). | |
2855 vie_encoder_->TriggerCpuNormalUsage(); | |
2856 timestamp_ms += kFrameIntervalMs; | |
2857 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight)); | |
2858 WaitForEncodedFrame(timestamp_ms); | |
2859 VerifyFpsMaxResolutionEq(source.sink_wants(), source.last_wants()); | |
2860 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution); | |
2861 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_framerate); | |
2862 EXPECT_TRUE(stats_proxy_->GetStats().cpu_limited_resolution); | |
2863 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_framerate); | |
2864 EXPECT_EQ(3, stats_proxy_->GetStats().number_of_cpu_adapt_changes); | |
2865 EXPECT_EQ(1, stats_proxy_->GetStats().number_of_quality_adapt_changes); | |
2866 | |
2867 // Trigger quality adapt up, expect upscaled resolution (960x540@30fps). | |
2868 vie_encoder_->TriggerQualityHigh(); | |
2869 timestamp_ms += kFrameIntervalMs; | |
2870 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight)); | |
2871 WaitForEncodedFrame(timestamp_ms); | |
2872 VerifyFpsMaxResolutionGt(source.sink_wants(), source.last_wants()); | |
2873 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution); | |
2874 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_framerate); | |
2875 EXPECT_TRUE(stats_proxy_->GetStats().cpu_limited_resolution); | |
2876 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_framerate); | |
2877 EXPECT_EQ(3, stats_proxy_->GetStats().number_of_cpu_adapt_changes); | |
2878 EXPECT_EQ(2, stats_proxy_->GetStats().number_of_quality_adapt_changes); | |
2879 | |
2880 // Trigger cpu adapt up, expect no restriction (1280x720fps@30fps). | |
2881 vie_encoder_->TriggerCpuNormalUsage(); | |
2882 timestamp_ms += kFrameIntervalMs; | |
2883 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight)); | |
2884 WaitForEncodedFrame(kWidth, kHeight); | |
2885 VerifyFpsMaxResolutionGt(source.sink_wants(), source.last_wants()); | |
2886 VerifyNoLimitation(source.sink_wants()); | |
2887 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution); | |
2888 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_framerate); | |
2889 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_resolution); | |
2890 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_framerate); | |
2891 EXPECT_EQ(4, stats_proxy_->GetStats().number_of_cpu_adapt_changes); | |
2892 EXPECT_EQ(2, stats_proxy_->GetStats().number_of_quality_adapt_changes); | |
2893 | |
2894 // Trigger adapt up, expect no change. | |
2895 vie_encoder_->TriggerQualityHigh(); | |
2896 VerifyNoLimitation(source.sink_wants()); | |
2897 EXPECT_EQ(4, stats_proxy_->GetStats().number_of_cpu_adapt_changes); | |
2898 EXPECT_EQ(2, stats_proxy_->GetStats().number_of_quality_adapt_changes); | |
2899 | |
2900 vie_encoder_->Stop(); | |
2901 } | |
2902 | |
2903 TEST_F(ViEEncoderTest, AdaptWithTwoReasonsAndDifferentOrder_Resolution) { | |
2904 const int kWidth = 640; | |
2905 const int kHeight = 360; | |
2906 const int kFpsLimit = 15; | |
2907 const int64_t kFrameIntervalMs = 150; | |
2908 int64_t timestamp_ms = kFrameIntervalMs; | |
2909 vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0); | |
2910 | |
2911 // Enable kBalanced preference, no initial limitation. | |
2912 AdaptingFrameForwarder source; | |
2913 source.set_adaptation_enabled(true); | |
2914 vie_encoder_->SetSource(&source, | |
2915 VideoSendStream::DegradationPreference::kBalanced); | |
2916 timestamp_ms += kFrameIntervalMs; | |
2917 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight)); | |
2918 WaitForEncodedFrame(kWidth, kHeight); | |
2919 VerifyNoLimitation(source.sink_wants()); | |
2920 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution); | |
2921 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_framerate); | |
2922 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_resolution); | |
2923 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_framerate); | |
2924 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_cpu_adapt_changes); | |
2925 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_quality_adapt_changes); | |
2926 | |
2927 // Trigger cpu adapt down, expect scaled down framerate (640x360@15fps). | |
2928 vie_encoder_->TriggerCpuOveruse(); | |
2929 timestamp_ms += kFrameIntervalMs; | |
2930 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight)); | |
2931 WaitForEncodedFrame(timestamp_ms); | |
2932 VerifyFpsEqResolutionMax(source.sink_wants(), kFpsLimit); | |
2933 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution); | |
2934 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_framerate); | |
2935 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_resolution); | |
2936 EXPECT_TRUE(stats_proxy_->GetStats().cpu_limited_framerate); | |
2937 EXPECT_EQ(1, stats_proxy_->GetStats().number_of_cpu_adapt_changes); | |
2938 EXPECT_EQ(0, stats_proxy_->GetStats().number_of_quality_adapt_changes); | |
2939 | |
2940 // Trigger quality adapt down, expect scaled down resolution (480x270@15fps). | |
2941 vie_encoder_->TriggerQualityLow(); | |
2942 timestamp_ms += kFrameIntervalMs; | |
2943 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight)); | |
2944 WaitForEncodedFrame(timestamp_ms); | |
2945 VerifyFpsEqResolutionLt(source.sink_wants(), source.last_wants()); | |
2946 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_resolution); | |
2947 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_framerate); | |
2948 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_resolution); | |
2949 EXPECT_TRUE(stats_proxy_->GetStats().cpu_limited_framerate); | |
2950 EXPECT_EQ(1, stats_proxy_->GetStats().number_of_cpu_adapt_changes); | |
2951 EXPECT_EQ(1, stats_proxy_->GetStats().number_of_quality_adapt_changes); | |
2952 | |
2953 // Trigger cpu adapt up, expect upscaled resolution (640x360@15fps). | |
2954 vie_encoder_->TriggerCpuNormalUsage(); | |
2955 timestamp_ms += kFrameIntervalMs; | |
2956 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight)); | |
2957 WaitForEncodedFrame(timestamp_ms); | |
2958 VerifyFpsEqResolutionGt(source.sink_wants(), source.last_wants()); | |
2959 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution); | |
2960 EXPECT_TRUE(stats_proxy_->GetStats().bw_limited_framerate); | |
2961 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_resolution); | |
2962 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_framerate); | |
2963 EXPECT_EQ(2, stats_proxy_->GetStats().number_of_cpu_adapt_changes); | |
2964 EXPECT_EQ(1, stats_proxy_->GetStats().number_of_quality_adapt_changes); | |
2965 | |
2966 // Trigger quality adapt up, expect increased fps (640x360@30fps). | |
2967 vie_encoder_->TriggerQualityHigh(); | |
2968 timestamp_ms += kFrameIntervalMs; | |
2969 source.IncomingCapturedFrame(CreateFrame(timestamp_ms, kWidth, kHeight)); | |
2970 WaitForEncodedFrame(timestamp_ms); | |
2971 VerifyNoLimitation(source.sink_wants()); | |
2972 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_resolution); | |
2973 EXPECT_FALSE(stats_proxy_->GetStats().bw_limited_framerate); | |
2974 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_resolution); | |
2975 EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_framerate); | |
2976 EXPECT_EQ(2, stats_proxy_->GetStats().number_of_cpu_adapt_changes); | |
2977 EXPECT_EQ(2, stats_proxy_->GetStats().number_of_quality_adapt_changes); | |
2978 | |
2979 // Trigger adapt up, expect no change. | |
2980 vie_encoder_->TriggerQualityHigh(); | |
2981 VerifyNoLimitation(source.sink_wants()); | |
2982 EXPECT_EQ(2, stats_proxy_->GetStats().number_of_cpu_adapt_changes); | |
2983 EXPECT_EQ(2, stats_proxy_->GetStats().number_of_quality_adapt_changes); | |
2984 | |
2985 vie_encoder_->Stop(); | |
2986 } | |
2987 | |
2988 TEST_F(ViEEncoderTest, AcceptsFullHdAdaptedDownSimulcastFrames) { | |
2989 // Simulates simulcast behavior and makes highest stream resolutions divisible | |
2990 // by 4. | |
2991 class CroppingVideoStreamFactory | |
2992 : public VideoEncoderConfig::VideoStreamFactoryInterface { | |
2993 public: | |
2994 explicit CroppingVideoStreamFactory(size_t num_temporal_layers, | |
2995 int framerate) | |
2996 : num_temporal_layers_(num_temporal_layers), framerate_(framerate) { | |
2997 EXPECT_GT(num_temporal_layers, 0u); | |
2998 EXPECT_GT(framerate, 0); | |
2999 } | |
3000 | |
3001 private: | |
3002 std::vector<VideoStream> CreateEncoderStreams( | |
3003 int width, | |
3004 int height, | |
3005 const VideoEncoderConfig& encoder_config) override { | |
3006 std::vector<VideoStream> streams = | |
3007 test::CreateVideoStreams(width - width % 4, height - height % 4, | |
3008 encoder_config); | |
3009 for (VideoStream& stream : streams) { | |
3010 stream.temporal_layer_thresholds_bps.resize(num_temporal_layers_ - 1); | |
3011 stream.max_framerate = framerate_; | |
3012 } | |
3013 return streams; | |
3014 } | |
3015 | |
3016 const size_t num_temporal_layers_; | |
3017 const int framerate_; | |
3018 }; | |
3019 | |
3020 const int kFrameWidth = 1920; | |
3021 const int kFrameHeight = 1080; | |
3022 // 3/4 of 1920. | |
3023 const int kAdaptedFrameWidth = 1440; | |
3024 // 3/4 of 1080 rounded down to multiple of 4. | |
3025 const int kAdaptedFrameHeight = 808; | |
3026 const int kFramerate = 24; | |
3027 | |
3028 vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0); | |
3029 // Trigger reconfigure encoder (without resetting the entire instance). | |
3030 VideoEncoderConfig video_encoder_config; | |
3031 video_encoder_config.max_bitrate_bps = kTargetBitrateBps; | |
3032 video_encoder_config.number_of_streams = 1; | |
3033 video_encoder_config.video_stream_factory = | |
3034 new rtc::RefCountedObject<CroppingVideoStreamFactory>(1, kFramerate); | |
3035 vie_encoder_->ConfigureEncoder(std::move(video_encoder_config), | |
3036 kMaxPayloadLength, false); | |
3037 vie_encoder_->WaitUntilTaskQueueIsIdle(); | |
3038 | |
3039 video_source_.set_adaptation_enabled(true); | |
3040 | |
3041 video_source_.IncomingCapturedFrame( | |
3042 CreateFrame(1, kFrameWidth, kFrameHeight)); | |
3043 WaitForEncodedFrame(kFrameWidth, kFrameHeight); | |
3044 | |
3045 // Trigger CPU overuse, downscale by 3/4. | |
3046 vie_encoder_->TriggerCpuOveruse(); | |
3047 video_source_.IncomingCapturedFrame( | |
3048 CreateFrame(2, kFrameWidth, kFrameHeight)); | |
3049 WaitForEncodedFrame(kAdaptedFrameWidth, kAdaptedFrameHeight); | |
3050 | |
3051 vie_encoder_->Stop(); | |
3052 } | |
3053 | |
3054 TEST_F(ViEEncoderTest, PeriodicallyUpdatesChannelParameters) { | |
3055 const int kFrameWidth = 1280; | |
3056 const int kFrameHeight = 720; | |
3057 const int kLowFps = 2; | |
3058 const int kHighFps = 30; | |
3059 | |
3060 vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0); | |
3061 | |
3062 int64_t timestamp_ms = fake_clock_.TimeNanos() / rtc::kNumNanosecsPerMillisec; | |
3063 max_framerate_ = kLowFps; | |
3064 | |
3065 // Insert 2 seconds of 2fps video. | |
3066 for (int i = 0; i < kLowFps * 2; ++i) { | |
3067 video_source_.IncomingCapturedFrame( | |
3068 CreateFrame(timestamp_ms, kFrameWidth, kFrameHeight)); | |
3069 WaitForEncodedFrame(timestamp_ms); | |
3070 timestamp_ms += 1000 / kLowFps; | |
3071 } | |
3072 | |
3073 // Make sure encoder is updated with new target. | |
3074 vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0); | |
3075 video_source_.IncomingCapturedFrame( | |
3076 CreateFrame(timestamp_ms, kFrameWidth, kFrameHeight)); | |
3077 WaitForEncodedFrame(timestamp_ms); | |
3078 timestamp_ms += 1000 / kLowFps; | |
3079 | |
3080 EXPECT_EQ(kLowFps, fake_encoder_.GetConfiguredInputFramerate()); | |
3081 | |
3082 // Insert 30fps frames for just a little more than the forced update period. | |
3083 const int kVcmTimerIntervalFrames = | |
3084 (vcm::VCMProcessTimer::kDefaultProcessIntervalMs * kHighFps) / 1000; | |
3085 const int kFrameIntervalMs = 1000 / kHighFps; | |
3086 max_framerate_ = kHighFps; | |
3087 for (int i = 0; i < kVcmTimerIntervalFrames + 2; ++i) { | |
3088 video_source_.IncomingCapturedFrame( | |
3089 CreateFrame(timestamp_ms, kFrameWidth, kFrameHeight)); | |
3090 // Wait for encoded frame, but skip ahead if it doesn't arrive as it might | |
3091 // be dropped if the encoder hans't been updated with the new higher target | |
3092 // framerate yet, causing it to overshoot the target bitrate and then | |
3093 // suffering the wrath of the media optimizer. | |
3094 TimedWaitForEncodedFrame(timestamp_ms, 2 * kFrameIntervalMs); | |
3095 timestamp_ms += kFrameIntervalMs; | |
3096 } | |
3097 | |
3098 // Don expect correct measurement just yet, but it should be higher than | |
3099 // before. | |
3100 EXPECT_GT(fake_encoder_.GetConfiguredInputFramerate(), kLowFps); | |
3101 | |
3102 vie_encoder_->Stop(); | |
3103 } | |
3104 | |
3105 TEST_F(ViEEncoderTest, DoesNotUpdateBitrateAllocationWhenSuspended) { | |
3106 const int kFrameWidth = 1280; | |
3107 const int kFrameHeight = 720; | |
3108 const int kTargetBitrateBps = 1000000; | |
3109 | |
3110 MockBitrateObserver bitrate_observer; | |
3111 vie_encoder_->SetBitrateObserver(&bitrate_observer); | |
3112 | |
3113 EXPECT_CALL(bitrate_observer, OnBitrateAllocationUpdated(_)).Times(1); | |
3114 // Initial bitrate update. | |
3115 vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0); | |
3116 vie_encoder_->WaitUntilTaskQueueIsIdle(); | |
3117 | |
3118 // Insert a first video frame, causes another bitrate update. | |
3119 int64_t timestamp_ms = fake_clock_.TimeNanos() / rtc::kNumNanosecsPerMillisec; | |
3120 EXPECT_CALL(bitrate_observer, OnBitrateAllocationUpdated(_)).Times(1); | |
3121 video_source_.IncomingCapturedFrame( | |
3122 CreateFrame(timestamp_ms, kFrameWidth, kFrameHeight)); | |
3123 WaitForEncodedFrame(timestamp_ms); | |
3124 | |
3125 // Next, simulate video suspension due to pacer queue overrun. | |
3126 vie_encoder_->OnBitrateUpdated(0, 0, 1); | |
3127 | |
3128 // Skip ahead until a new periodic parameter update should have occured. | |
3129 timestamp_ms += vcm::VCMProcessTimer::kDefaultProcessIntervalMs; | |
3130 fake_clock_.AdvanceTimeMicros( | |
3131 vcm::VCMProcessTimer::kDefaultProcessIntervalMs * | |
3132 rtc::kNumMicrosecsPerMillisec); | |
3133 | |
3134 // Bitrate observer should not be called. | |
3135 EXPECT_CALL(bitrate_observer, OnBitrateAllocationUpdated(_)).Times(0); | |
3136 video_source_.IncomingCapturedFrame( | |
3137 CreateFrame(timestamp_ms, kFrameWidth, kFrameHeight)); | |
3138 ExpectDroppedFrame(); | |
3139 | |
3140 vie_encoder_->Stop(); | |
3141 } | |
3142 | |
3143 } // namespace webrtc | |
OLD | NEW |