| /* |
| * Copyright (c) 2016 The WebRTC project authors. All Rights Reserved. |
| * |
| * Use of this source code is governed by a BSD-style license |
| * that can be found in the LICENSE file in the root of the source |
| * tree. An additional intellectual property rights grant can be found |
| * in the file PATENTS. All contributing project authors may |
| * be found in the AUTHORS file in the root of the source tree. |
| */ |
| |
| #include "video/video_stream_encoder.h" |
| |
| #include <algorithm> |
| #include <limits> |
| #include <memory> |
| #include <tuple> |
| #include <utility> |
| |
| #include "absl/memory/memory.h" |
| #include "api/task_queue/default_task_queue_factory.h" |
| #include "api/test/mock_fec_controller_override.h" |
| #include "api/test/mock_video_encoder.h" |
| #include "api/test/mock_video_encoder_factory.h" |
| #include "api/video/builtin_video_bitrate_allocator_factory.h" |
| #include "api/video/i420_buffer.h" |
| #include "api/video/nv12_buffer.h" |
| #include "api/video/video_adaptation_reason.h" |
| #include "api/video/video_bitrate_allocation.h" |
| #include "api/video_codecs/sdp_video_format.h" |
| #include "api/video_codecs/video_encoder.h" |
| #include "api/video_codecs/vp8_temporal_layers.h" |
| #include "api/video_codecs/vp8_temporal_layers_factory.h" |
| #include "call/adaptation/test/fake_adaptation_constraint.h" |
| #include "call/adaptation/test/fake_resource.h" |
| #include "common_video/h264/h264_common.h" |
| #include "common_video/include/video_frame_buffer.h" |
| #include "media/base/video_adapter.h" |
| #include "media/engine/webrtc_video_engine.h" |
| #include "modules/video_coding/codecs/av1/libaom_av1_encoder.h" |
| #include "modules/video_coding/codecs/h264/include/h264.h" |
| #include "modules/video_coding/codecs/multiplex/include/multiplex_encoder_adapter.h" |
| #include "modules/video_coding/codecs/vp8/include/vp8.h" |
| #include "modules/video_coding/codecs/vp9/include/vp9.h" |
| #include "modules/video_coding/codecs/vp9/include/vp9_globals.h" |
| #include "modules/video_coding/codecs/vp9/svc_config.h" |
| #include "modules/video_coding/utility/quality_scaler.h" |
| #include "modules/video_coding/utility/simulcast_rate_allocator.h" |
| #include "rtc_base/event.h" |
| #include "rtc_base/experiments/encoder_info_settings.h" |
| #include "rtc_base/gunit.h" |
| #include "rtc_base/logging.h" |
| #include "rtc_base/ref_counted_object.h" |
| #include "rtc_base/synchronization/mutex.h" |
| #include "system_wrappers/include/field_trial.h" |
| #include "system_wrappers/include/metrics.h" |
| #include "test/encoder_settings.h" |
| #include "test/fake_encoder.h" |
| #include "test/field_trial.h" |
| #include "test/frame_forwarder.h" |
| #include "test/gmock.h" |
| #include "test/gtest.h" |
| #include "test/mappable_native_buffer.h" |
| #include "test/time_controller/simulated_time_controller.h" |
| #include "test/video_encoder_proxy_factory.h" |
| #include "video/send_statistics_proxy.h" |
| |
| namespace webrtc { |
| |
| using ::testing::_; |
| using ::testing::AllOf; |
| using ::testing::AtLeast; |
| using ::testing::Eq; |
| using ::testing::Field; |
| using ::testing::Ge; |
| using ::testing::Gt; |
| using ::testing::Le; |
| using ::testing::Lt; |
| using ::testing::Matcher; |
| using ::testing::NiceMock; |
| using ::testing::Return; |
| using ::testing::SizeIs; |
| using ::testing::StrictMock; |
| |
| namespace { |
| const int kMinPixelsPerFrame = 320 * 180; |
| const int kQpLow = 1; |
| const int kQpHigh = 2; |
| const int kMinFramerateFps = 2; |
| const int kMinBalancedFramerateFps = 7; |
| const int64_t kFrameTimeoutMs = 100; |
| const size_t kMaxPayloadLength = 1440; |
| const uint32_t kTargetBitrateBps = 1000000; |
| const uint32_t kStartBitrateBps = 600000; |
| const uint32_t kSimulcastTargetBitrateBps = 3150000; |
| const uint32_t kLowTargetBitrateBps = kTargetBitrateBps / 10; |
| const int kMaxInitialFramedrop = 4; |
| const int kDefaultFramerate = 30; |
| const int64_t kFrameIntervalMs = rtc::kNumMillisecsPerSec / kDefaultFramerate; |
| const int64_t kProcessIntervalMs = 1000; |
| const VideoEncoder::ResolutionBitrateLimits |
| kEncoderBitrateLimits540p(960 * 540, 100 * 1000, 100 * 1000, 2000 * 1000); |
| const VideoEncoder::ResolutionBitrateLimits |
| kEncoderBitrateLimits720p(1280 * 720, 200 * 1000, 200 * 1000, 4000 * 1000); |
| |
| uint8_t optimal_sps[] = {0, 0, 0, 1, H264::NaluType::kSps, |
| 0x00, 0x00, 0x03, 0x03, 0xF4, |
| 0x05, 0x03, 0xC7, 0xE0, 0x1B, |
| 0x41, 0x10, 0x8D, 0x00}; |
| |
| const uint8_t kCodedFrameVp8Qp25[] = { |
| 0x10, 0x02, 0x00, 0x9d, 0x01, 0x2a, 0x10, 0x00, 0x10, 0x00, |
| 0x02, 0x47, 0x08, 0x85, 0x85, 0x88, 0x85, 0x84, 0x88, 0x0c, |
| 0x82, 0x00, 0x0c, 0x0d, 0x60, 0x00, 0xfe, 0xfc, 0x5c, 0xd0}; |
| |
| class TestBuffer : public webrtc::I420Buffer { |
| public: |
| TestBuffer(rtc::Event* event, int width, int height) |
| : I420Buffer(width, height), event_(event) {} |
| |
| private: |
| friend class rtc::RefCountedObject<TestBuffer>; |
| ~TestBuffer() override { |
| if (event_) |
| event_->Set(); |
| } |
| rtc::Event* const event_; |
| }; |
| |
| // A fake native buffer that can't be converted to I420. Upon scaling, it |
| // produces another FakeNativeBuffer. |
| class FakeNativeBuffer : public webrtc::VideoFrameBuffer { |
| public: |
| FakeNativeBuffer(rtc::Event* event, int width, int height) |
| : event_(event), width_(width), height_(height) {} |
| webrtc::VideoFrameBuffer::Type type() const override { return Type::kNative; } |
| int width() const override { return width_; } |
| int height() const override { return height_; } |
| rtc::scoped_refptr<webrtc::I420BufferInterface> ToI420() override { |
| return nullptr; |
| } |
| rtc::scoped_refptr<VideoFrameBuffer> CropAndScale( |
| int offset_x, |
| int offset_y, |
| int crop_width, |
| int crop_height, |
| int scaled_width, |
| int scaled_height) override { |
| return rtc::make_ref_counted<FakeNativeBuffer>(nullptr, scaled_width, |
| scaled_height); |
| } |
| |
| private: |
| friend class rtc::RefCountedObject<FakeNativeBuffer>; |
| ~FakeNativeBuffer() override { |
| if (event_) |
| event_->Set(); |
| } |
| rtc::Event* const event_; |
| const int width_; |
| const int height_; |
| }; |
| |
| // A fake native buffer that is backed by an NV12 buffer. |
| class FakeNV12NativeBuffer : public webrtc::VideoFrameBuffer { |
| public: |
| FakeNV12NativeBuffer(rtc::Event* event, int width, int height) |
| : nv12_buffer_(NV12Buffer::Create(width, height)), event_(event) {} |
| |
| webrtc::VideoFrameBuffer::Type type() const override { return Type::kNative; } |
| int width() const override { return nv12_buffer_->width(); } |
| int height() const override { return nv12_buffer_->height(); } |
| rtc::scoped_refptr<webrtc::I420BufferInterface> ToI420() override { |
| return nv12_buffer_->ToI420(); |
| } |
| rtc::scoped_refptr<VideoFrameBuffer> GetMappedFrameBuffer( |
| rtc::ArrayView<VideoFrameBuffer::Type> types) override { |
| if (absl::c_find(types, Type::kNV12) != types.end()) { |
| return nv12_buffer_; |
| } |
| return nullptr; |
| } |
| const NV12BufferInterface* GetNV12() const { return nv12_buffer_; } |
| |
| private: |
| friend class rtc::RefCountedObject<FakeNV12NativeBuffer>; |
| ~FakeNV12NativeBuffer() override { |
| if (event_) |
| event_->Set(); |
| } |
| rtc::scoped_refptr<NV12Buffer> nv12_buffer_; |
| rtc::Event* const event_; |
| }; |
| |
| class CpuOveruseDetectorProxy : public OveruseFrameDetector { |
| public: |
| explicit CpuOveruseDetectorProxy(CpuOveruseMetricsObserver* metrics_observer) |
| : OveruseFrameDetector(metrics_observer), |
| last_target_framerate_fps_(-1), |
| framerate_updated_event_(true /* manual_reset */, |
| false /* initially_signaled */) {} |
| virtual ~CpuOveruseDetectorProxy() {} |
| |
| void OnTargetFramerateUpdated(int framerate_fps) override { |
| MutexLock lock(&lock_); |
| last_target_framerate_fps_ = framerate_fps; |
| OveruseFrameDetector::OnTargetFramerateUpdated(framerate_fps); |
| framerate_updated_event_.Set(); |
| } |
| |
| int GetLastTargetFramerate() { |
| MutexLock lock(&lock_); |
| return last_target_framerate_fps_; |
| } |
| |
| CpuOveruseOptions GetOptions() { return options_; } |
| |
| rtc::Event* framerate_updated_event() { return &framerate_updated_event_; } |
| |
| private: |
| Mutex lock_; |
| int last_target_framerate_fps_ RTC_GUARDED_BY(lock_); |
| rtc::Event framerate_updated_event_; |
| }; |
| |
| class FakeVideoSourceRestrictionsListener |
| : public VideoSourceRestrictionsListener { |
| public: |
| FakeVideoSourceRestrictionsListener() |
| : was_restrictions_updated_(false), restrictions_updated_event_() {} |
| ~FakeVideoSourceRestrictionsListener() override { |
| RTC_DCHECK(was_restrictions_updated_); |
| } |
| |
| rtc::Event* restrictions_updated_event() { |
| return &restrictions_updated_event_; |
| } |
| |
| // VideoSourceRestrictionsListener implementation. |
| void OnVideoSourceRestrictionsUpdated( |
| VideoSourceRestrictions restrictions, |
| const VideoAdaptationCounters& adaptation_counters, |
| rtc::scoped_refptr<Resource> reason, |
| const VideoSourceRestrictions& unfiltered_restrictions) override { |
| was_restrictions_updated_ = true; |
| restrictions_updated_event_.Set(); |
| } |
| |
| private: |
| bool was_restrictions_updated_; |
| rtc::Event restrictions_updated_event_; |
| }; |
| |
| auto WantsFps(Matcher<int> fps_matcher) { |
| return Field("max_framerate_fps", &rtc::VideoSinkWants::max_framerate_fps, |
| fps_matcher); |
| } |
| |
| auto WantsMaxPixels(Matcher<int> max_pixel_matcher) { |
| return Field("max_pixel_count", &rtc::VideoSinkWants::max_pixel_count, |
| AllOf(max_pixel_matcher, Gt(0))); |
| } |
| |
| auto ResolutionMax() { |
| return AllOf( |
| WantsMaxPixels(Eq(std::numeric_limits<int>::max())), |
| Field("target_pixel_count", &rtc::VideoSinkWants::target_pixel_count, |
| Eq(absl::nullopt))); |
| } |
| |
| auto FpsMax() { |
| return WantsFps(Eq(kDefaultFramerate)); |
| } |
| |
| auto FpsUnlimited() { |
| return WantsFps(Eq(std::numeric_limits<int>::max())); |
| } |
| |
| auto FpsMatchesResolutionMax(Matcher<int> fps_matcher) { |
| return AllOf(WantsFps(fps_matcher), ResolutionMax()); |
| } |
| |
| auto FpsMaxResolutionMatches(Matcher<int> pixel_matcher) { |
| return AllOf(FpsMax(), WantsMaxPixels(pixel_matcher)); |
| } |
| |
| auto FpsMaxResolutionMax() { |
| return AllOf(FpsMax(), ResolutionMax()); |
| } |
| |
| auto UnlimitedSinkWants() { |
| return AllOf(FpsUnlimited(), ResolutionMax()); |
| } |
| |
| auto FpsInRangeForPixelsInBalanced(int last_frame_pixels) { |
| Matcher<int> fps_range_matcher; |
| |
| if (last_frame_pixels <= 320 * 240) { |
| fps_range_matcher = AllOf(Ge(7), Le(10)); |
| } else if (last_frame_pixels <= 480 * 360) { |
| fps_range_matcher = AllOf(Ge(10), Le(15)); |
| } else if (last_frame_pixels <= 640 * 480) { |
| fps_range_matcher = Ge(15); |
| } else { |
| fps_range_matcher = Eq(kDefaultFramerate); |
| } |
| return Field("max_framerate_fps", &rtc::VideoSinkWants::max_framerate_fps, |
| fps_range_matcher); |
| } |
| |
| auto FpsEqResolutionEqTo(const rtc::VideoSinkWants& other_wants) { |
| return AllOf(WantsFps(Eq(other_wants.max_framerate_fps)), |
| WantsMaxPixels(Eq(other_wants.max_pixel_count))); |
| } |
| |
| auto FpsMaxResolutionLt(const rtc::VideoSinkWants& other_wants) { |
| return AllOf(FpsMax(), WantsMaxPixels(Lt(other_wants.max_pixel_count))); |
| } |
| |
| auto FpsMaxResolutionGt(const rtc::VideoSinkWants& other_wants) { |
| return AllOf(FpsMax(), WantsMaxPixels(Gt(other_wants.max_pixel_count))); |
| } |
| |
| auto FpsLtResolutionEq(const rtc::VideoSinkWants& other_wants) { |
| return AllOf(WantsFps(Lt(other_wants.max_framerate_fps)), |
| WantsMaxPixels(Eq(other_wants.max_pixel_count))); |
| } |
| |
| auto FpsGtResolutionEq(const rtc::VideoSinkWants& other_wants) { |
| return AllOf(WantsFps(Gt(other_wants.max_framerate_fps)), |
| WantsMaxPixels(Eq(other_wants.max_pixel_count))); |
| } |
| |
| auto FpsEqResolutionLt(const rtc::VideoSinkWants& other_wants) { |
| return AllOf(WantsFps(Eq(other_wants.max_framerate_fps)), |
| WantsMaxPixels(Lt(other_wants.max_pixel_count))); |
| } |
| |
| auto FpsEqResolutionGt(const rtc::VideoSinkWants& other_wants) { |
| return AllOf(WantsFps(Eq(other_wants.max_framerate_fps)), |
| WantsMaxPixels(Gt(other_wants.max_pixel_count))); |
| } |
| |
| class VideoStreamEncoderUnderTest : public VideoStreamEncoder { |
| public: |
| VideoStreamEncoderUnderTest(TimeController* time_controller, |
| TaskQueueFactory* task_queue_factory, |
| SendStatisticsProxy* stats_proxy, |
| const VideoStreamEncoderSettings& settings, |
| VideoStreamEncoder::BitrateAllocationCallbackType |
| allocation_callback_type) |
| : VideoStreamEncoder(time_controller->GetClock(), |
| 1 /* number_of_cores */, |
| stats_proxy, |
| settings, |
| std::unique_ptr<OveruseFrameDetector>( |
| overuse_detector_proxy_ = |
| new CpuOveruseDetectorProxy(stats_proxy)), |
| task_queue_factory, |
| allocation_callback_type), |
| time_controller_(time_controller), |
| fake_cpu_resource_(FakeResource::Create("FakeResource[CPU]")), |
| fake_quality_resource_(FakeResource::Create("FakeResource[QP]")), |
| fake_adaptation_constraint_("FakeAdaptationConstraint") { |
| InjectAdaptationResource(fake_quality_resource_, |
| VideoAdaptationReason::kQuality); |
| InjectAdaptationResource(fake_cpu_resource_, VideoAdaptationReason::kCpu); |
| InjectAdaptationConstraint(&fake_adaptation_constraint_); |
| } |
| |
| void SetSourceAndWaitForRestrictionsUpdated( |
| rtc::VideoSourceInterface<VideoFrame>* source, |
| const DegradationPreference& degradation_preference) { |
| FakeVideoSourceRestrictionsListener listener; |
| AddRestrictionsListenerForTesting(&listener); |
| SetSource(source, degradation_preference); |
| listener.restrictions_updated_event()->Wait(5000); |
| RemoveRestrictionsListenerForTesting(&listener); |
| } |
| |
| void SetSourceAndWaitForFramerateUpdated( |
| rtc::VideoSourceInterface<VideoFrame>* source, |
| const DegradationPreference& degradation_preference) { |
| overuse_detector_proxy_->framerate_updated_event()->Reset(); |
| SetSource(source, degradation_preference); |
| overuse_detector_proxy_->framerate_updated_event()->Wait(5000); |
| } |
| |
| void OnBitrateUpdatedAndWaitForManagedResources( |
| DataRate target_bitrate, |
| DataRate stable_target_bitrate, |
| DataRate link_allocation, |
| uint8_t fraction_lost, |
| int64_t round_trip_time_ms, |
| double cwnd_reduce_ratio) { |
| OnBitrateUpdated(target_bitrate, stable_target_bitrate, link_allocation, |
| fraction_lost, round_trip_time_ms, cwnd_reduce_ratio); |
| // Bitrate is updated on the encoder queue. |
| WaitUntilTaskQueueIsIdle(); |
| } |
| |
| // This is used as a synchronisation mechanism, to make sure that the |
| // encoder queue is not blocked before we start sending it frames. |
| void WaitUntilTaskQueueIsIdle() { |
| rtc::Event event; |
| encoder_queue()->PostTask([&event] { event.Set(); }); |
| ASSERT_TRUE(event.Wait(5000)); |
| } |
| |
| // Triggers resource usage measurements on the fake CPU resource. |
| void TriggerCpuOveruse() { |
| rtc::Event event; |
| encoder_queue()->PostTask([this, &event] { |
| fake_cpu_resource_->SetUsageState(ResourceUsageState::kOveruse); |
| event.Set(); |
| }); |
| ASSERT_TRUE(event.Wait(5000)); |
| time_controller_->AdvanceTime(TimeDelta::Millis(0)); |
| } |
| |
| void TriggerCpuUnderuse() { |
| rtc::Event event; |
| encoder_queue()->PostTask([this, &event] { |
| fake_cpu_resource_->SetUsageState(ResourceUsageState::kUnderuse); |
| event.Set(); |
| }); |
| ASSERT_TRUE(event.Wait(5000)); |
| time_controller_->AdvanceTime(TimeDelta::Millis(0)); |
| } |
| |
| // Triggers resource usage measurements on the fake quality resource. |
| void TriggerQualityLow() { |
| rtc::Event event; |
| encoder_queue()->PostTask([this, &event] { |
| fake_quality_resource_->SetUsageState(ResourceUsageState::kOveruse); |
| event.Set(); |
| }); |
| ASSERT_TRUE(event.Wait(5000)); |
| time_controller_->AdvanceTime(TimeDelta::Millis(0)); |
| } |
| void TriggerQualityHigh() { |
| rtc::Event event; |
| encoder_queue()->PostTask([this, &event] { |
| fake_quality_resource_->SetUsageState(ResourceUsageState::kUnderuse); |
| event.Set(); |
| }); |
| ASSERT_TRUE(event.Wait(5000)); |
| time_controller_->AdvanceTime(TimeDelta::Millis(0)); |
| } |
| |
| TimeController* const time_controller_; |
| CpuOveruseDetectorProxy* overuse_detector_proxy_; |
| rtc::scoped_refptr<FakeResource> fake_cpu_resource_; |
| rtc::scoped_refptr<FakeResource> fake_quality_resource_; |
| FakeAdaptationConstraint fake_adaptation_constraint_; |
| }; |
| |
| // Simulates simulcast behavior and makes highest stream resolutions divisible |
| // by 4. |
| class CroppingVideoStreamFactory |
| : public VideoEncoderConfig::VideoStreamFactoryInterface { |
| public: |
| CroppingVideoStreamFactory() {} |
| |
| private: |
| std::vector<VideoStream> CreateEncoderStreams( |
| int width, |
| int height, |
| const VideoEncoderConfig& encoder_config) override { |
| std::vector<VideoStream> streams = test::CreateVideoStreams( |
| width - width % 4, height - height % 4, encoder_config); |
| return streams; |
| } |
| }; |
| |
| class AdaptingFrameForwarder : public test::FrameForwarder { |
| public: |
| explicit AdaptingFrameForwarder(TimeController* time_controller) |
| : time_controller_(time_controller), adaptation_enabled_(false) {} |
| ~AdaptingFrameForwarder() override {} |
| |
| void set_adaptation_enabled(bool enabled) { |
| MutexLock lock(&mutex_); |
| adaptation_enabled_ = enabled; |
| } |
| |
| bool adaption_enabled() const { |
| MutexLock lock(&mutex_); |
| return adaptation_enabled_; |
| } |
| |
| // The "last wants" is a snapshot of the previous rtc::VideoSinkWants where |
| // the resolution or frame rate was different than it is currently. If |
| // something else is modified, such as encoder resolutions, but the resolution |
| // and frame rate stays the same, last wants is not updated. |
| rtc::VideoSinkWants last_wants() const { |
| MutexLock lock(&mutex_); |
| return last_wants_; |
| } |
| |
| absl::optional<int> last_sent_width() const { return last_width_; } |
| absl::optional<int> last_sent_height() const { return last_height_; } |
| |
| void IncomingCapturedFrame(const VideoFrame& video_frame) override { |
| RTC_DCHECK(time_controller_->GetMainThread()->IsCurrent()); |
| time_controller_->AdvanceTime(TimeDelta::Millis(0)); |
| |
| int cropped_width = 0; |
| int cropped_height = 0; |
| int out_width = 0; |
| int out_height = 0; |
| if (adaption_enabled()) { |
| RTC_DLOG(INFO) << "IncomingCapturedFrame: AdaptFrameResolution()" |
| << "w=" << video_frame.width() |
| << "h=" << video_frame.height(); |
| if (adapter_.AdaptFrameResolution( |
| video_frame.width(), video_frame.height(), |
| video_frame.timestamp_us() * 1000, &cropped_width, |
| &cropped_height, &out_width, &out_height)) { |
| VideoFrame adapted_frame = |
| VideoFrame::Builder() |
| .set_video_frame_buffer(rtc::make_ref_counted<TestBuffer>( |
| nullptr, out_width, out_height)) |
| .set_ntp_time_ms(video_frame.ntp_time_ms()) |
| .set_timestamp_ms(99) |
| .set_rotation(kVideoRotation_0) |
| .build(); |
| if (video_frame.has_update_rect()) { |
| adapted_frame.set_update_rect( |
| video_frame.update_rect().ScaleWithFrame( |
| video_frame.width(), video_frame.height(), 0, 0, |
| video_frame.width(), video_frame.height(), out_width, |
| out_height)); |
| } |
| test::FrameForwarder::IncomingCapturedFrame(adapted_frame); |
| last_width_.emplace(adapted_frame.width()); |
| last_height_.emplace(adapted_frame.height()); |
| } else { |
| last_width_ = absl::nullopt; |
| last_height_ = absl::nullopt; |
| } |
| } else { |
| RTC_DLOG(INFO) << "IncomingCapturedFrame: adaptation not enabled"; |
| test::FrameForwarder::IncomingCapturedFrame(video_frame); |
| last_width_.emplace(video_frame.width()); |
| last_height_.emplace(video_frame.height()); |
| } |
| } |
| |
| void AddOrUpdateSink(rtc::VideoSinkInterface<VideoFrame>* sink, |
| const rtc::VideoSinkWants& wants) override { |
| MutexLock lock(&mutex_); |
| rtc::VideoSinkWants prev_wants = sink_wants_locked(); |
| bool did_adapt = |
| prev_wants.max_pixel_count != wants.max_pixel_count || |
| prev_wants.target_pixel_count != wants.target_pixel_count || |
| prev_wants.max_framerate_fps != wants.max_framerate_fps; |
| if (did_adapt) { |
| last_wants_ = prev_wants; |
| } |
| adapter_.OnSinkWants(wants); |
| test::FrameForwarder::AddOrUpdateSinkLocked(sink, wants); |
| } |
| |
| TimeController* const time_controller_; |
| cricket::VideoAdapter adapter_; |
| bool adaptation_enabled_ RTC_GUARDED_BY(mutex_); |
| rtc::VideoSinkWants last_wants_ RTC_GUARDED_BY(mutex_); |
| absl::optional<int> last_width_; |
| absl::optional<int> last_height_; |
| }; |
| |
| // TODO(nisse): Mock only VideoStreamEncoderObserver. |
| class MockableSendStatisticsProxy : public SendStatisticsProxy { |
| public: |
| MockableSendStatisticsProxy(Clock* clock, |
| const VideoSendStream::Config& config, |
| VideoEncoderConfig::ContentType content_type) |
| : SendStatisticsProxy(clock, config, content_type) {} |
| |
| VideoSendStream::Stats GetStats() override { |
| MutexLock lock(&lock_); |
| if (mock_stats_) |
| return *mock_stats_; |
| return SendStatisticsProxy::GetStats(); |
| } |
| |
| int GetInputFrameRate() const override { |
| MutexLock lock(&lock_); |
| if (mock_stats_) |
| return mock_stats_->input_frame_rate; |
| return SendStatisticsProxy::GetInputFrameRate(); |
| } |
| void SetMockStats(const VideoSendStream::Stats& stats) { |
| MutexLock lock(&lock_); |
| mock_stats_.emplace(stats); |
| } |
| |
| void ResetMockStats() { |
| MutexLock lock(&lock_); |
| mock_stats_.reset(); |
| } |
| |
| void SetDroppedFrameCallback(std::function<void(DropReason)> callback) { |
| on_frame_dropped_ = std::move(callback); |
| } |
| |
| private: |
| void OnFrameDropped(DropReason reason) override { |
| SendStatisticsProxy::OnFrameDropped(reason); |
| if (on_frame_dropped_) |
| on_frame_dropped_(reason); |
| } |
| |
| mutable Mutex lock_; |
| absl::optional<VideoSendStream::Stats> mock_stats_ RTC_GUARDED_BY(lock_); |
| std::function<void(DropReason)> on_frame_dropped_; |
| }; |
| |
| class MockEncoderSelector |
| : public VideoEncoderFactory::EncoderSelectorInterface { |
| public: |
| MOCK_METHOD(void, |
| OnCurrentEncoder, |
| (const SdpVideoFormat& format), |
| (override)); |
| MOCK_METHOD(absl::optional<SdpVideoFormat>, |
| OnAvailableBitrate, |
| (const DataRate& rate), |
| (override)); |
| MOCK_METHOD(absl::optional<SdpVideoFormat>, OnEncoderBroken, (), (override)); |
| }; |
| |
| } // namespace |
| |
| class VideoStreamEncoderTest : public ::testing::Test { |
| public: |
| static const int kDefaultTimeoutMs = 1000; |
| |
| VideoStreamEncoderTest() |
| : video_send_config_(VideoSendStream::Config(nullptr)), |
| codec_width_(320), |
| codec_height_(240), |
| max_framerate_(kDefaultFramerate), |
| fake_encoder_(&time_controller_), |
| encoder_factory_(&fake_encoder_), |
| stats_proxy_(new MockableSendStatisticsProxy( |
| time_controller_.GetClock(), |
| video_send_config_, |
| webrtc::VideoEncoderConfig::ContentType::kRealtimeVideo)), |
| sink_(&time_controller_, &fake_encoder_) {} |
| |
| void SetUp() override { |
| metrics::Reset(); |
| video_send_config_ = VideoSendStream::Config(nullptr); |
| video_send_config_.encoder_settings.encoder_factory = &encoder_factory_; |
| video_send_config_.encoder_settings.bitrate_allocator_factory = |
| &bitrate_allocator_factory_; |
| video_send_config_.rtp.payload_name = "FAKE"; |
| video_send_config_.rtp.payload_type = 125; |
| |
| VideoEncoderConfig video_encoder_config; |
| test::FillEncoderConfiguration(kVideoCodecVP8, 1, &video_encoder_config); |
| EXPECT_EQ(1u, video_encoder_config.simulcast_layers.size()); |
| video_encoder_config.simulcast_layers[0].num_temporal_layers = 1; |
| video_encoder_config.simulcast_layers[0].max_framerate = max_framerate_; |
| video_encoder_config_ = video_encoder_config.Copy(); |
| |
| ConfigureEncoder(std::move(video_encoder_config)); |
| } |
| |
| void ConfigureEncoder( |
| VideoEncoderConfig video_encoder_config, |
| VideoStreamEncoder::BitrateAllocationCallbackType |
| allocation_callback_type = |
| VideoStreamEncoder::BitrateAllocationCallbackType:: |
| kVideoBitrateAllocationWhenScreenSharing) { |
| if (video_stream_encoder_) |
| video_stream_encoder_->Stop(); |
| video_stream_encoder_.reset(new VideoStreamEncoderUnderTest( |
| &time_controller_, GetTaskQueueFactory(), stats_proxy_.get(), |
| video_send_config_.encoder_settings, allocation_callback_type)); |
| video_stream_encoder_->SetSink(&sink_, false /* rotation_applied */); |
| video_stream_encoder_->SetSource( |
| &video_source_, webrtc::DegradationPreference::MAINTAIN_FRAMERATE); |
| video_stream_encoder_->SetStartBitrate(kTargetBitrateBps); |
| video_stream_encoder_->ConfigureEncoder(std::move(video_encoder_config), |
| kMaxPayloadLength); |
| video_stream_encoder_->WaitUntilTaskQueueIsIdle(); |
| } |
| |
| void ResetEncoder(const std::string& payload_name, |
| size_t num_streams, |
| size_t num_temporal_layers, |
| unsigned char num_spatial_layers, |
| bool screenshare, |
| VideoStreamEncoder::BitrateAllocationCallbackType |
| allocation_callback_type = |
| VideoStreamEncoder::BitrateAllocationCallbackType:: |
| kVideoBitrateAllocationWhenScreenSharing) { |
| video_send_config_.rtp.payload_name = payload_name; |
| |
| VideoEncoderConfig video_encoder_config; |
| test::FillEncoderConfiguration(PayloadStringToCodecType(payload_name), |
| num_streams, &video_encoder_config); |
| for (auto& layer : video_encoder_config.simulcast_layers) { |
| layer.num_temporal_layers = num_temporal_layers; |
| layer.max_framerate = kDefaultFramerate; |
| } |
| video_encoder_config.max_bitrate_bps = |
| num_streams == 1 ? kTargetBitrateBps : kSimulcastTargetBitrateBps; |
| video_encoder_config.content_type = |
| screenshare ? VideoEncoderConfig::ContentType::kScreen |
| : VideoEncoderConfig::ContentType::kRealtimeVideo; |
| if (payload_name == "VP9") { |
| VideoCodecVP9 vp9_settings = VideoEncoder::GetDefaultVp9Settings(); |
| vp9_settings.numberOfSpatialLayers = num_spatial_layers; |
| vp9_settings.automaticResizeOn = num_spatial_layers <= 1; |
| video_encoder_config.encoder_specific_settings = |
| rtc::make_ref_counted<VideoEncoderConfig::Vp9EncoderSpecificSettings>( |
| vp9_settings); |
| } |
| ConfigureEncoder(std::move(video_encoder_config), allocation_callback_type); |
| } |
| |
| VideoFrame CreateFrame(int64_t ntp_time_ms, |
| rtc::Event* destruction_event) const { |
| return VideoFrame::Builder() |
| .set_video_frame_buffer(rtc::make_ref_counted<TestBuffer>( |
| destruction_event, codec_width_, codec_height_)) |
| .set_ntp_time_ms(ntp_time_ms) |
| .set_timestamp_ms(99) |
| .set_rotation(kVideoRotation_0) |
| .build(); |
| } |
| |
| VideoFrame CreateFrameWithUpdatedPixel(int64_t ntp_time_ms, |
| rtc::Event* destruction_event, |
| int offset_x) const { |
| return VideoFrame::Builder() |
| .set_video_frame_buffer(rtc::make_ref_counted<TestBuffer>( |
| destruction_event, codec_width_, codec_height_)) |
| .set_ntp_time_ms(ntp_time_ms) |
| .set_timestamp_ms(99) |
| .set_rotation(kVideoRotation_0) |
| .set_update_rect(VideoFrame::UpdateRect{offset_x, 0, 1, 1}) |
| .build(); |
| } |
| |
| VideoFrame CreateFrame(int64_t ntp_time_ms, int width, int height) const { |
| auto buffer = rtc::make_ref_counted<TestBuffer>(nullptr, width, height); |
| I420Buffer::SetBlack(buffer.get()); |
| return VideoFrame::Builder() |
| .set_video_frame_buffer(std::move(buffer)) |
| .set_ntp_time_ms(ntp_time_ms) |
| .set_timestamp_ms(ntp_time_ms) |
| .set_rotation(kVideoRotation_0) |
| .build(); |
| } |
| |
| VideoFrame CreateNV12Frame(int64_t ntp_time_ms, int width, int height) const { |
| return VideoFrame::Builder() |
| .set_video_frame_buffer(NV12Buffer::Create(width, height)) |
| .set_ntp_time_ms(ntp_time_ms) |
| .set_timestamp_ms(ntp_time_ms) |
| .set_rotation(kVideoRotation_0) |
| .build(); |
| } |
| |
| VideoFrame CreateFakeNativeFrame(int64_t ntp_time_ms, |
| rtc::Event* destruction_event, |
| int width, |
| int height) const { |
| return VideoFrame::Builder() |
| .set_video_frame_buffer(rtc::make_ref_counted<FakeNativeBuffer>( |
| destruction_event, width, height)) |
| .set_ntp_time_ms(ntp_time_ms) |
| .set_timestamp_ms(99) |
| .set_rotation(kVideoRotation_0) |
| .build(); |
| } |
| |
| VideoFrame CreateFakeNV12NativeFrame(int64_t ntp_time_ms, |
| rtc::Event* destruction_event, |
| int width, |
| int height) const { |
| return VideoFrame::Builder() |
| .set_video_frame_buffer(rtc::make_ref_counted<FakeNV12NativeBuffer>( |
| destruction_event, width, height)) |
| .set_ntp_time_ms(ntp_time_ms) |
| .set_timestamp_ms(99) |
| .set_rotation(kVideoRotation_0) |
| .build(); |
| } |
| |
| VideoFrame CreateFakeNativeFrame(int64_t ntp_time_ms, |
| rtc::Event* destruction_event) const { |
| return CreateFakeNativeFrame(ntp_time_ms, destruction_event, codec_width_, |
| codec_height_); |
| } |
| |
| void VerifyAllocatedBitrate(const VideoBitrateAllocation& expected_bitrate) { |
| video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources( |
| DataRate::BitsPerSec(kTargetBitrateBps), |
| DataRate::BitsPerSec(kTargetBitrateBps), |
| DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0); |
| |
| video_source_.IncomingCapturedFrame( |
| CreateFrame(1, codec_width_, codec_height_)); |
| WaitForEncodedFrame(1); |
| EXPECT_EQ(expected_bitrate, sink_.GetLastVideoBitrateAllocation()); |
| } |
| |
| void WaitForEncodedFrame(int64_t expected_ntp_time) { |
| sink_.WaitForEncodedFrame(expected_ntp_time); |
| AdvanceTime(TimeDelta::Seconds(1) / max_framerate_); |
| } |
| |
| bool TimedWaitForEncodedFrame(int64_t expected_ntp_time, int64_t timeout_ms) { |
| bool ok = sink_.TimedWaitForEncodedFrame(expected_ntp_time, timeout_ms); |
| AdvanceTime(TimeDelta::Seconds(1) / max_framerate_); |
| return ok; |
| } |
| |
| void WaitForEncodedFrame(uint32_t expected_width, uint32_t expected_height) { |
| sink_.WaitForEncodedFrame(expected_width, expected_height); |
| AdvanceTime(TimeDelta::Seconds(1) / max_framerate_); |
| } |
| |
| void ExpectDroppedFrame() { |
| sink_.ExpectDroppedFrame(); |
| AdvanceTime(TimeDelta::Seconds(1) / max_framerate_); |
| } |
| |
| bool WaitForFrame(int64_t timeout_ms) { |
| bool ok = sink_.WaitForFrame(timeout_ms); |
| AdvanceTime(TimeDelta::Seconds(1) / max_framerate_); |
| return ok; |
| } |
| |
| class TestEncoder : public test::FakeEncoder { |
| public: |
| explicit TestEncoder(TimeController* time_controller) |
| : FakeEncoder(time_controller->GetClock()), |
| time_controller_(time_controller) { |
| RTC_DCHECK(time_controller_); |
| } |
| |
| VideoCodec codec_config() const { |
| MutexLock lock(&mutex_); |
| return config_; |
| } |
| |
| void BlockNextEncode() { |
| MutexLock lock(&local_mutex_); |
| block_next_encode_ = true; |
| } |
| |
| VideoEncoder::EncoderInfo GetEncoderInfo() const override { |
| MutexLock lock(&local_mutex_); |
| EncoderInfo info = FakeEncoder::GetEncoderInfo(); |
| if (initialized_ == EncoderState::kInitialized) { |
| if (quality_scaling_) { |
| info.scaling_settings = VideoEncoder::ScalingSettings( |
| kQpLow, kQpHigh, kMinPixelsPerFrame); |
| } |
| info.is_hardware_accelerated = is_hardware_accelerated_; |
| for (int i = 0; i < kMaxSpatialLayers; ++i) { |
| if (temporal_layers_supported_[i]) { |
| info.fps_allocation[i].clear(); |
| int num_layers = temporal_layers_supported_[i].value() ? 2 : 1; |
| for (int tid = 0; tid < num_layers; ++tid) |
| info.fps_allocation[i].push_back(255 / (num_layers - tid)); |
| } |
| } |
| } |
| |
| info.resolution_bitrate_limits = resolution_bitrate_limits_; |
| info.requested_resolution_alignment = requested_resolution_alignment_; |
| info.apply_alignment_to_all_simulcast_layers = |
| apply_alignment_to_all_simulcast_layers_; |
| info.preferred_pixel_formats = preferred_pixel_formats_; |
| return info; |
| } |
| |
| int32_t RegisterEncodeCompleteCallback( |
| EncodedImageCallback* callback) override { |
| MutexLock lock(&local_mutex_); |
| encoded_image_callback_ = callback; |
| return FakeEncoder::RegisterEncodeCompleteCallback(callback); |
| } |
| |
| void ContinueEncode() { continue_encode_event_.Set(); } |
| |
| void CheckLastTimeStampsMatch(int64_t ntp_time_ms, |
| uint32_t timestamp) const { |
| MutexLock lock(&local_mutex_); |
| EXPECT_EQ(timestamp_, timestamp); |
| EXPECT_EQ(ntp_time_ms_, ntp_time_ms); |
| } |
| |
| void SetQualityScaling(bool b) { |
| MutexLock lock(&local_mutex_); |
| quality_scaling_ = b; |
| } |
| |
| void SetRequestedResolutionAlignment(int requested_resolution_alignment) { |
| MutexLock lock(&local_mutex_); |
| requested_resolution_alignment_ = requested_resolution_alignment; |
| } |
| |
| void SetApplyAlignmentToAllSimulcastLayers(bool b) { |
| MutexLock lock(&local_mutex_); |
| apply_alignment_to_all_simulcast_layers_ = b; |
| } |
| |
| void SetIsHardwareAccelerated(bool is_hardware_accelerated) { |
| MutexLock lock(&local_mutex_); |
| is_hardware_accelerated_ = is_hardware_accelerated; |
| } |
| |
| void SetTemporalLayersSupported(size_t spatial_idx, bool supported) { |
| RTC_DCHECK_LT(spatial_idx, kMaxSpatialLayers); |
| MutexLock lock(&local_mutex_); |
| temporal_layers_supported_[spatial_idx] = supported; |
| } |
| |
| void SetResolutionBitrateLimits( |
| std::vector<ResolutionBitrateLimits> thresholds) { |
| MutexLock lock(&local_mutex_); |
| resolution_bitrate_limits_ = thresholds; |
| } |
| |
| void ForceInitEncodeFailure(bool force_failure) { |
| MutexLock lock(&local_mutex_); |
| force_init_encode_failed_ = force_failure; |
| } |
| |
| void SimulateOvershoot(double rate_factor) { |
| MutexLock lock(&local_mutex_); |
| rate_factor_ = rate_factor; |
| } |
| |
| uint32_t GetLastFramerate() const { |
| MutexLock lock(&local_mutex_); |
| return last_framerate_; |
| } |
| |
| VideoFrame::UpdateRect GetLastUpdateRect() const { |
| MutexLock lock(&local_mutex_); |
| return last_update_rect_; |
| } |
| |
| const std::vector<VideoFrameType>& LastFrameTypes() const { |
| MutexLock lock(&local_mutex_); |
| return last_frame_types_; |
| } |
| |
| void InjectFrame(const VideoFrame& input_image, bool keyframe) { |
| const std::vector<VideoFrameType> frame_type = { |
| keyframe ? VideoFrameType::kVideoFrameKey |
| : VideoFrameType::kVideoFrameDelta}; |
| { |
| MutexLock lock(&local_mutex_); |
| last_frame_types_ = frame_type; |
| } |
| FakeEncoder::Encode(input_image, &frame_type); |
| } |
| |
| void InjectEncodedImage(const EncodedImage& image, |
| const CodecSpecificInfo* codec_specific_info) { |
| MutexLock lock(&local_mutex_); |
| encoded_image_callback_->OnEncodedImage(image, codec_specific_info); |
| } |
| |
| void SetEncodedImageData( |
| rtc::scoped_refptr<EncodedImageBufferInterface> encoded_image_data) { |
| MutexLock lock(&local_mutex_); |
| encoded_image_data_ = encoded_image_data; |
| } |
| |
| void ExpectNullFrame() { |
| MutexLock lock(&local_mutex_); |
| expect_null_frame_ = true; |
| } |
| |
| absl::optional<VideoEncoder::RateControlParameters> |
| GetAndResetLastRateControlSettings() { |
| auto settings = last_rate_control_settings_; |
| last_rate_control_settings_.reset(); |
| return settings; |
| } |
| |
| int GetLastInputWidth() const { |
| MutexLock lock(&local_mutex_); |
| return last_input_width_; |
| } |
| |
| int GetLastInputHeight() const { |
| MutexLock lock(&local_mutex_); |
| return last_input_height_; |
| } |
| |
| absl::optional<VideoFrameBuffer::Type> GetLastInputPixelFormat() { |
| MutexLock lock(&local_mutex_); |
| return last_input_pixel_format_; |
| } |
| |
| int GetNumEncoderInitializations() const { |
| MutexLock lock(&local_mutex_); |
| return num_encoder_initializations_; |
| } |
| |
| int GetNumSetRates() const { |
| MutexLock lock(&local_mutex_); |
| return num_set_rates_; |
| } |
| |
| VideoCodec video_codec() const { |
| MutexLock lock(&local_mutex_); |
| return video_codec_; |
| } |
| |
| void SetPreferredPixelFormats( |
| absl::InlinedVector<VideoFrameBuffer::Type, kMaxPreferredPixelFormats> |
| pixel_formats) { |
| MutexLock lock(&local_mutex_); |
| preferred_pixel_formats_ = std::move(pixel_formats); |
| } |
| |
| private: |
| int32_t Encode(const VideoFrame& input_image, |
| const std::vector<VideoFrameType>* frame_types) override { |
| bool block_encode; |
| { |
| MutexLock lock(&local_mutex_); |
| if (expect_null_frame_) { |
| EXPECT_EQ(input_image.timestamp(), 0u); |
| EXPECT_EQ(input_image.width(), 1); |
| last_frame_types_ = *frame_types; |
| expect_null_frame_ = false; |
| } else { |
| EXPECT_GT(input_image.timestamp(), timestamp_); |
| EXPECT_GT(input_image.ntp_time_ms(), ntp_time_ms_); |
| EXPECT_EQ(input_image.timestamp(), input_image.ntp_time_ms() * 90); |
| } |
| |
| timestamp_ = input_image.timestamp(); |
| ntp_time_ms_ = input_image.ntp_time_ms(); |
| last_input_width_ = input_image.width(); |
| last_input_height_ = input_image.height(); |
| block_encode = block_next_encode_; |
| block_next_encode_ = false; |
| last_update_rect_ = input_image.update_rect(); |
| last_frame_types_ = *frame_types; |
| last_input_pixel_format_ = input_image.video_frame_buffer()->type(); |
| } |
| int32_t result = FakeEncoder::Encode(input_image, frame_types); |
| if (block_encode) |
| EXPECT_TRUE(continue_encode_event_.Wait(kDefaultTimeoutMs)); |
| |
| return result; |
| } |
| |
| CodecSpecificInfo EncodeHook( |
| EncodedImage& encoded_image, |
| rtc::scoped_refptr<EncodedImageBuffer> buffer) override { |
| CodecSpecificInfo codec_specific; |
| { |
| MutexLock lock(&mutex_); |
| codec_specific.codecType = config_.codecType; |
| } |
| MutexLock lock(&local_mutex_); |
| if (encoded_image_data_) { |
| encoded_image.SetEncodedData(encoded_image_data_); |
| } |
| return codec_specific; |
| } |
| |
| int32_t InitEncode(const VideoCodec* config, |
| const Settings& settings) override { |
| int res = FakeEncoder::InitEncode(config, settings); |
| |
| MutexLock lock(&local_mutex_); |
| EXPECT_EQ(initialized_, EncoderState::kUninitialized); |
| |
| ++num_encoder_initializations_; |
| video_codec_ = *config; |
| |
| if (config->codecType == kVideoCodecVP8) { |
| // Simulate setting up temporal layers, in order to validate the life |
| // cycle of these objects. |
| Vp8TemporalLayersFactory factory; |
| frame_buffer_controller_ = |
| factory.Create(*config, settings, &fec_controller_override_); |
| } |
| if (force_init_encode_failed_) { |
| initialized_ = EncoderState::kInitializationFailed; |
| return -1; |
| } |
| |
| initialized_ = EncoderState::kInitialized; |
| return res; |
| } |
| |
| int32_t Release() override { |
| MutexLock lock(&local_mutex_); |
| EXPECT_NE(initialized_, EncoderState::kUninitialized); |
| initialized_ = EncoderState::kUninitialized; |
| return FakeEncoder::Release(); |
| } |
| |
| void SetRates(const RateControlParameters& parameters) { |
| MutexLock lock(&local_mutex_); |
| num_set_rates_++; |
| VideoBitrateAllocation adjusted_rate_allocation; |
| for (size_t si = 0; si < kMaxSpatialLayers; ++si) { |
| for (size_t ti = 0; ti < kMaxTemporalStreams; ++ti) { |
| if (parameters.bitrate.HasBitrate(si, ti)) { |
| adjusted_rate_allocation.SetBitrate( |
| si, ti, |
| static_cast<uint32_t>(parameters.bitrate.GetBitrate(si, ti) * |
| rate_factor_)); |
| } |
| } |
| } |
| last_framerate_ = static_cast<uint32_t>(parameters.framerate_fps + 0.5); |
| last_rate_control_settings_ = parameters; |
| RateControlParameters adjusted_paramters = parameters; |
| adjusted_paramters.bitrate = adjusted_rate_allocation; |
| FakeEncoder::SetRates(adjusted_paramters); |
| } |
| |
| TimeController* const time_controller_; |
| mutable Mutex local_mutex_; |
| enum class EncoderState { |
| kUninitialized, |
| kInitializationFailed, |
| kInitialized |
| } initialized_ RTC_GUARDED_BY(local_mutex_) = EncoderState::kUninitialized; |
| bool block_next_encode_ RTC_GUARDED_BY(local_mutex_) = false; |
| rtc::Event continue_encode_event_; |
| uint32_t timestamp_ RTC_GUARDED_BY(local_mutex_) = 0; |
| int64_t ntp_time_ms_ RTC_GUARDED_BY(local_mutex_) = 0; |
| int last_input_width_ RTC_GUARDED_BY(local_mutex_) = 0; |
| int last_input_height_ RTC_GUARDED_BY(local_mutex_) = 0; |
| bool quality_scaling_ RTC_GUARDED_BY(local_mutex_) = true; |
| int requested_resolution_alignment_ RTC_GUARDED_BY(local_mutex_) = 1; |
| bool apply_alignment_to_all_simulcast_layers_ RTC_GUARDED_BY(local_mutex_) = |
| false; |
| bool is_hardware_accelerated_ RTC_GUARDED_BY(local_mutex_) = false; |
| rtc::scoped_refptr<EncodedImageBufferInterface> encoded_image_data_ |
| RTC_GUARDED_BY(local_mutex_); |
| std::unique_ptr<Vp8FrameBufferController> frame_buffer_controller_ |
| RTC_GUARDED_BY(local_mutex_); |
| absl::optional<bool> |
| temporal_layers_supported_[kMaxSpatialLayers] RTC_GUARDED_BY( |
| local_mutex_); |
| bool force_init_encode_failed_ RTC_GUARDED_BY(local_mutex_) = false; |
| double rate_factor_ RTC_GUARDED_BY(local_mutex_) = 1.0; |
| uint32_t last_framerate_ RTC_GUARDED_BY(local_mutex_) = 0; |
| absl::optional<VideoEncoder::RateControlParameters> |
| last_rate_control_settings_; |
| VideoFrame::UpdateRect last_update_rect_ RTC_GUARDED_BY(local_mutex_) = { |
| 0, 0, 0, 0}; |
| std::vector<VideoFrameType> last_frame_types_; |
| bool expect_null_frame_ = false; |
| EncodedImageCallback* encoded_image_callback_ RTC_GUARDED_BY(local_mutex_) = |
| nullptr; |
| NiceMock<MockFecControllerOverride> fec_controller_override_; |
| int num_encoder_initializations_ RTC_GUARDED_BY(local_mutex_) = 0; |
| std::vector<ResolutionBitrateLimits> resolution_bitrate_limits_ |
| RTC_GUARDED_BY(local_mutex_); |
| int num_set_rates_ RTC_GUARDED_BY(local_mutex_) = 0; |
| VideoCodec video_codec_ RTC_GUARDED_BY(local_mutex_); |
| absl::optional<VideoFrameBuffer::Type> last_input_pixel_format_ |
| RTC_GUARDED_BY(local_mutex_); |
| absl::InlinedVector<VideoFrameBuffer::Type, kMaxPreferredPixelFormats> |
| preferred_pixel_formats_ RTC_GUARDED_BY(local_mutex_); |
| }; |
| |
| class TestSink : public VideoStreamEncoder::EncoderSink { |
| public: |
| TestSink(TimeController* time_controller, TestEncoder* test_encoder) |
| : time_controller_(time_controller), test_encoder_(test_encoder) { |
| RTC_DCHECK(time_controller_); |
| } |
| |
| void WaitForEncodedFrame(int64_t expected_ntp_time) { |
| EXPECT_TRUE( |
| TimedWaitForEncodedFrame(expected_ntp_time, kDefaultTimeoutMs)); |
| } |
| |
| bool TimedWaitForEncodedFrame(int64_t expected_ntp_time, |
| int64_t timeout_ms) { |
| uint32_t timestamp = 0; |
| if (!WaitForFrame(timeout_ms)) |
| return false; |
| { |
| MutexLock lock(&mutex_); |
| timestamp = last_timestamp_; |
| } |
| test_encoder_->CheckLastTimeStampsMatch(expected_ntp_time, timestamp); |
| return true; |
| } |
| |
| void WaitForEncodedFrame(uint32_t expected_width, |
| uint32_t expected_height) { |
| EXPECT_TRUE(WaitForFrame(kDefaultTimeoutMs)); |
| CheckLastFrameSizeMatches(expected_width, expected_height); |
| } |
| |
| void CheckLastFrameSizeMatches(uint32_t expected_width, |
| uint32_t expected_height) { |
| uint32_t width = 0; |
| uint32_t height = 0; |
| { |
| MutexLock lock(&mutex_); |
| width = last_width_; |
| height = last_height_; |
| } |
| EXPECT_EQ(expected_height, height); |
| EXPECT_EQ(expected_width, width); |
| } |
| |
| void CheckLastFrameRotationMatches(VideoRotation expected_rotation) { |
| VideoRotation rotation; |
| { |
| MutexLock lock(&mutex_); |
| rotation = last_rotation_; |
| } |
| EXPECT_EQ(expected_rotation, rotation); |
| } |
| |
| void ExpectDroppedFrame() { EXPECT_FALSE(WaitForFrame(100)); } |
| |
| bool WaitForFrame(int64_t timeout_ms) { |
| RTC_DCHECK(time_controller_->GetMainThread()->IsCurrent()); |
| bool ret = encoded_frame_event_.Wait(timeout_ms); |
| time_controller_->AdvanceTime(TimeDelta::Millis(0)); |
| return ret; |
| } |
| |
| void SetExpectNoFrames() { |
| MutexLock lock(&mutex_); |
| expect_frames_ = false; |
| } |
| |
| int number_of_reconfigurations() const { |
| MutexLock lock(&mutex_); |
| return number_of_reconfigurations_; |
| } |
| |
| int last_min_transmit_bitrate() const { |
| MutexLock lock(&mutex_); |
| return min_transmit_bitrate_bps_; |
| } |
| |
| void SetNumExpectedLayers(size_t num_layers) { |
| MutexLock lock(&mutex_); |
| num_expected_layers_ = num_layers; |
| } |
| |
| int64_t GetLastCaptureTimeMs() const { |
| MutexLock lock(&mutex_); |
| return last_capture_time_ms_; |
| } |
| |
| const EncodedImage& GetLastEncodedImage() { |
| MutexLock lock(&mutex_); |
| return last_encoded_image_; |
| } |
| |
| std::vector<uint8_t> GetLastEncodedImageData() { |
| MutexLock lock(&mutex_); |
| return std::move(last_encoded_image_data_); |
| } |
| |
| VideoBitrateAllocation GetLastVideoBitrateAllocation() { |
| MutexLock lock(&mutex_); |
| return last_bitrate_allocation_; |
| } |
| |
| int number_of_bitrate_allocations() const { |
| MutexLock lock(&mutex_); |
| return number_of_bitrate_allocations_; |
| } |
| |
| VideoLayersAllocation GetLastVideoLayersAllocation() { |
| MutexLock lock(&mutex_); |
| return last_layers_allocation_; |
| } |
| |
| int number_of_layers_allocations() const { |
| MutexLock lock(&mutex_); |
| return number_of_layers_allocations_; |
| } |
| |
| private: |
| Result OnEncodedImage( |
| const EncodedImage& encoded_image, |
| const CodecSpecificInfo* codec_specific_info) override { |
| MutexLock lock(&mutex_); |
| EXPECT_TRUE(expect_frames_); |
| last_encoded_image_ = EncodedImage(encoded_image); |
| last_encoded_image_data_ = std::vector<uint8_t>( |
| encoded_image.data(), encoded_image.data() + encoded_image.size()); |
| uint32_t timestamp = encoded_image.Timestamp(); |
| if (last_timestamp_ != timestamp) { |
| num_received_layers_ = 1; |
| last_width_ = encoded_image._encodedWidth; |
| last_height_ = encoded_image._encodedHeight; |
| } else { |
| ++num_received_layers_; |
| last_width_ = std::max(encoded_image._encodedWidth, last_width_); |
| last_height_ = std::max(encoded_image._encodedHeight, last_height_); |
| } |
| last_timestamp_ = timestamp; |
| last_capture_time_ms_ = encoded_image.capture_time_ms_; |
| last_rotation_ = encoded_image.rotation_; |
| if (num_received_layers_ == num_expected_layers_) { |
| encoded_frame_event_.Set(); |
| } |
| return Result(Result::OK, last_timestamp_); |
| } |
| |
| void OnEncoderConfigurationChanged( |
| std::vector<VideoStream> streams, |
| bool is_svc, |
| VideoEncoderConfig::ContentType content_type, |
| int min_transmit_bitrate_bps) override { |
| MutexLock lock(&mutex_); |
| ++number_of_reconfigurations_; |
| min_transmit_bitrate_bps_ = min_transmit_bitrate_bps; |
| } |
| |
| void OnBitrateAllocationUpdated( |
| const VideoBitrateAllocation& allocation) override { |
| MutexLock lock(&mutex_); |
| ++number_of_bitrate_allocations_; |
| last_bitrate_allocation_ = allocation; |
| } |
| |
| void OnVideoLayersAllocationUpdated( |
| VideoLayersAllocation allocation) override { |
| MutexLock lock(&mutex_); |
| ++number_of_layers_allocations_; |
| last_layers_allocation_ = allocation; |
| rtc::StringBuilder log; |
| for (const auto& layer : allocation.active_spatial_layers) { |
| log << layer.width << "x" << layer.height << "@" << layer.frame_rate_fps |
| << "["; |
| for (const auto target_bitrate : |
| layer.target_bitrate_per_temporal_layer) { |
| log << target_bitrate.kbps() << ","; |
| } |
| log << "]"; |
| } |
| RTC_DLOG(INFO) << "OnVideoLayersAllocationUpdated " << log.str(); |
| } |
| |
| TimeController* const time_controller_; |
| mutable Mutex mutex_; |
| TestEncoder* test_encoder_; |
| rtc::Event encoded_frame_event_; |
| EncodedImage last_encoded_image_; |
| std::vector<uint8_t> last_encoded_image_data_; |
| uint32_t last_timestamp_ = 0; |
| int64_t last_capture_time_ms_ = 0; |
| uint32_t last_height_ = 0; |
| uint32_t last_width_ = 0; |
| VideoRotation last_rotation_ = kVideoRotation_0; |
| size_t num_expected_layers_ = 1; |
| size_t num_received_layers_ = 0; |
| bool expect_frames_ = true; |
| int number_of_reconfigurations_ = 0; |
| int min_transmit_bitrate_bps_ = 0; |
| VideoBitrateAllocation last_bitrate_allocation_ RTC_GUARDED_BY(&mutex_); |
| int number_of_bitrate_allocations_ RTC_GUARDED_BY(&mutex_) = 0; |
| VideoLayersAllocation last_layers_allocation_ RTC_GUARDED_BY(&mutex_); |
| int number_of_layers_allocations_ RTC_GUARDED_BY(&mutex_) = 0; |
| }; |
| |
| class VideoBitrateAllocatorProxyFactory |
| : public VideoBitrateAllocatorFactory { |
| public: |
| VideoBitrateAllocatorProxyFactory() |
| : bitrate_allocator_factory_( |
| CreateBuiltinVideoBitrateAllocatorFactory()) {} |
| |
| std::unique_ptr<VideoBitrateAllocator> CreateVideoBitrateAllocator( |
| const VideoCodec& codec) override { |
| MutexLock lock(&mutex_); |
| codec_config_ = codec; |
| return bitrate_allocator_factory_->CreateVideoBitrateAllocator(codec); |
| } |
| |
| VideoCodec codec_config() const { |
| MutexLock lock(&mutex_); |
| return codec_config_; |
| } |
| |
| private: |
| std::unique_ptr<VideoBitrateAllocatorFactory> bitrate_allocator_factory_; |
| |
| mutable Mutex mutex_; |
| VideoCodec codec_config_ RTC_GUARDED_BY(mutex_); |
| }; |
| |
| Clock* clock() { return time_controller_.GetClock(); } |
| void AdvanceTime(TimeDelta duration) { |
| time_controller_.AdvanceTime(duration); |
| } |
| |
| int64_t CurrentTimeMs() { return clock()->CurrentTime().ms(); } |
| |
| protected: |
| virtual TaskQueueFactory* GetTaskQueueFactory() { |
| return time_controller_.GetTaskQueueFactory(); |
| } |
| |
| GlobalSimulatedTimeController time_controller_{Timestamp::Micros(1234)}; |
| VideoSendStream::Config video_send_config_; |
| VideoEncoderConfig video_encoder_config_; |
| int codec_width_; |
| int codec_height_; |
| int max_framerate_; |
| TestEncoder fake_encoder_; |
| test::VideoEncoderProxyFactory encoder_factory_; |
| VideoBitrateAllocatorProxyFactory bitrate_allocator_factory_; |
| std::unique_ptr<MockableSendStatisticsProxy> stats_proxy_; |
| TestSink sink_; |
| AdaptingFrameForwarder video_source_{&time_controller_}; |
| std::unique_ptr<VideoStreamEncoderUnderTest> video_stream_encoder_; |
| }; |
| |
| TEST_F(VideoStreamEncoderTest, EncodeOneFrame) { |
| video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources( |
| DataRate::BitsPerSec(kTargetBitrateBps), |
| DataRate::BitsPerSec(kTargetBitrateBps), |
| DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0); |
| rtc::Event frame_destroyed_event; |
| video_source_.IncomingCapturedFrame(CreateFrame(1, &frame_destroyed_event)); |
| WaitForEncodedFrame(1); |
| EXPECT_TRUE(frame_destroyed_event.Wait(kDefaultTimeoutMs)); |
| video_stream_encoder_->Stop(); |
| } |
| |
| TEST_F(VideoStreamEncoderTest, DropsFramesBeforeFirstOnBitrateUpdated) { |
| // Dropped since no target bitrate has been set. |
| rtc::Event frame_destroyed_event; |
| // The encoder will cache up to one frame for a short duration. Adding two |
| // frames means that the first frame will be dropped and the second frame will |
| // be sent when the encoder is enabled. |
| video_source_.IncomingCapturedFrame(CreateFrame(1, &frame_destroyed_event)); |
| AdvanceTime(TimeDelta::Millis(10)); |
| video_source_.IncomingCapturedFrame(CreateFrame(2, nullptr)); |
| EXPECT_TRUE(frame_destroyed_event.Wait(kDefaultTimeoutMs)); |
| |
| video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources( |
| DataRate::BitsPerSec(kTargetBitrateBps), |
| DataRate::BitsPerSec(kTargetBitrateBps), |
| DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0); |
| |
| // The pending frame should be received. |
| WaitForEncodedFrame(2); |
| video_source_.IncomingCapturedFrame(CreateFrame(3, nullptr)); |
| |
| WaitForEncodedFrame(3); |
| video_stream_encoder_->Stop(); |
| } |
| |
| TEST_F(VideoStreamEncoderTest, DropsFramesWhenRateSetToZero) { |
| video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources( |
| DataRate::BitsPerSec(kTargetBitrateBps), |
| DataRate::BitsPerSec(kTargetBitrateBps), |
| DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0); |
| video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr)); |
| WaitForEncodedFrame(1); |
| |
| video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources( |
| DataRate::BitsPerSec(0), DataRate::BitsPerSec(0), DataRate::BitsPerSec(0), |
| 0, 0, 0); |
| // The encoder will cache up to one frame for a short duration. Adding two |
| // frames means that the first frame will be dropped and the second frame will |
| // be sent when the encoder is resumed. |
| video_source_.IncomingCapturedFrame(CreateFrame(2, nullptr)); |
| video_source_.IncomingCapturedFrame(CreateFrame(3, nullptr)); |
| |
| video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources( |
| DataRate::BitsPerSec(kTargetBitrateBps), |
| DataRate::BitsPerSec(kTargetBitrateBps), |
| DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0); |
| WaitForEncodedFrame(3); |
| video_source_.IncomingCapturedFrame(CreateFrame(4, nullptr)); |
| WaitForEncodedFrame(4); |
| video_stream_encoder_->Stop(); |
| } |
| |
| TEST_F(VideoStreamEncoderTest, DropsFramesWithSameOrOldNtpTimestamp) { |
| video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources( |
| DataRate::BitsPerSec(kTargetBitrateBps), |
| DataRate::BitsPerSec(kTargetBitrateBps), |
| DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0); |
| video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr)); |
| WaitForEncodedFrame(1); |
| |
| // This frame will be dropped since it has the same ntp timestamp. |
| video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr)); |
| |
| video_source_.IncomingCapturedFrame(CreateFrame(2, nullptr)); |
| WaitForEncodedFrame(2); |
| video_stream_encoder_->Stop(); |
| } |
| |
| TEST_F(VideoStreamEncoderTest, DropsFrameAfterStop) { |
| video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources( |
| DataRate::BitsPerSec(kTargetBitrateBps), |
| DataRate::BitsPerSec(kTargetBitrateBps), |
| DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0); |
| |
| video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr)); |
| WaitForEncodedFrame(1); |
| |
| video_stream_encoder_->Stop(); |
| sink_.SetExpectNoFrames(); |
| rtc::Event frame_destroyed_event; |
| video_source_.IncomingCapturedFrame(CreateFrame(2, &frame_destroyed_event)); |
| EXPECT_TRUE(frame_destroyed_event.Wait(kDefaultTimeoutMs)); |
| } |
| |
| class VideoStreamEncoderBlockedTest : public VideoStreamEncoderTest { |
| public: |
| VideoStreamEncoderBlockedTest() {} |
| |
| TaskQueueFactory* GetTaskQueueFactory() override { |
| return task_queue_factory_.get(); |
| } |
| |
| private: |
| std::unique_ptr<TaskQueueFactory> task_queue_factory_ = |
| CreateDefaultTaskQueueFactory(); |
| }; |
| |
| TEST_F(VideoStreamEncoderBlockedTest, DropsPendingFramesOnSlowEncode) { |
| video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources( |
| DataRate::BitsPerSec(kTargetBitrateBps), |
| DataRate::BitsPerSec(kTargetBitrateBps), |
| DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0); |
| |
| int dropped_count = 0; |
| stats_proxy_->SetDroppedFrameCallback( |
| [&dropped_count](VideoStreamEncoderObserver::DropReason) { |
| ++dropped_count; |
| }); |
| |
| fake_encoder_.BlockNextEncode(); |
| video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr)); |
| WaitForEncodedFrame(1); |
| // Here, the encoder thread will be blocked in the TestEncoder waiting for a |
| // call to ContinueEncode. |
| video_source_.IncomingCapturedFrame(CreateFrame(2, nullptr)); |
| video_source_.IncomingCapturedFrame(CreateFrame(3, nullptr)); |
| fake_encoder_.ContinueEncode(); |
| WaitForEncodedFrame(3); |
| |
| video_stream_encoder_->Stop(); |
| |
| EXPECT_EQ(1, dropped_count); |
| } |
| |
| TEST_F(VideoStreamEncoderTest, NativeFrameWithoutI420SupportGetsDelivered) { |
| video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources( |
| DataRate::BitsPerSec(kTargetBitrateBps), |
| DataRate::BitsPerSec(kTargetBitrateBps), |
| DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0); |
| |
| rtc::Event frame_destroyed_event; |
| video_source_.IncomingCapturedFrame( |
| CreateFakeNativeFrame(1, &frame_destroyed_event)); |
| WaitForEncodedFrame(1); |
| EXPECT_EQ(VideoFrameBuffer::Type::kNative, |
| fake_encoder_.GetLastInputPixelFormat()); |
| EXPECT_EQ(fake_encoder_.codec_config().width, |
| fake_encoder_.GetLastInputWidth()); |
| EXPECT_EQ(fake_encoder_.codec_config().height, |
| fake_encoder_.GetLastInputHeight()); |
| video_stream_encoder_->Stop(); |
| } |
| |
| TEST_F(VideoStreamEncoderTest, |
| NativeFrameWithoutI420SupportGetsCroppedIfNecessary) { |
| // Use the cropping factory. |
| video_encoder_config_.video_stream_factory = |
| rtc::make_ref_counted<CroppingVideoStreamFactory>(); |
| video_stream_encoder_->ConfigureEncoder(std::move(video_encoder_config_), |
| kMaxPayloadLength); |
| video_stream_encoder_->WaitUntilTaskQueueIsIdle(); |
| |
| // Capture a frame at codec_width_/codec_height_. |
| video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources( |
| DataRate::BitsPerSec(kTargetBitrateBps), |
| DataRate::BitsPerSec(kTargetBitrateBps), |
| DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0); |
| video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr)); |
| WaitForEncodedFrame(1); |
| // The encoder will have been configured once. |
| EXPECT_EQ(1, sink_.number_of_reconfigurations()); |
| EXPECT_EQ(codec_width_, fake_encoder_.codec_config().width); |
| EXPECT_EQ(codec_height_, fake_encoder_.codec_config().height); |
| |
| // Now send in a fake frame that needs to be cropped as the width/height |
| // aren't divisible by 4 (see CreateEncoderStreams above). |
| rtc::Event frame_destroyed_event; |
| video_source_.IncomingCapturedFrame(CreateFakeNativeFrame( |
| 2, &frame_destroyed_event, codec_width_ + 1, codec_height_ + 1)); |
| WaitForEncodedFrame(2); |
| EXPECT_EQ(VideoFrameBuffer::Type::kNative, |
| fake_encoder_.GetLastInputPixelFormat()); |
| EXPECT_EQ(fake_encoder_.codec_config().width, |
| fake_encoder_.GetLastInputWidth()); |
| EXPECT_EQ(fake_encoder_.codec_config().height, |
| fake_encoder_.GetLastInputHeight()); |
| video_stream_encoder_->Stop(); |
| } |
| |
| TEST_F(VideoStreamEncoderTest, NonI420FramesShouldNotBeConvertedToI420) { |
| video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources( |
| DataRate::BitsPerSec(kTargetBitrateBps), |
| DataRate::BitsPerSec(kTargetBitrateBps), |
| DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0); |
| |
| video_source_.IncomingCapturedFrame( |
| CreateNV12Frame(1, codec_width_, codec_height_)); |
| WaitForEncodedFrame(1); |
| EXPECT_EQ(VideoFrameBuffer::Type::kNV12, |
| fake_encoder_.GetLastInputPixelFormat()); |
| video_stream_encoder_->Stop(); |
| } |
| |
| TEST_F(VideoStreamEncoderTest, NativeFrameGetsDelivered_NoFrameTypePreference) { |
| video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources( |
| DataRate::BitsPerSec(kTargetBitrateBps), |
| DataRate::BitsPerSec(kTargetBitrateBps), |
| DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0); |
| |
| fake_encoder_.SetPreferredPixelFormats({}); |
| |
| rtc::Event frame_destroyed_event; |
| video_source_.IncomingCapturedFrame(CreateFakeNV12NativeFrame( |
| 1, &frame_destroyed_event, codec_width_, codec_height_)); |
| WaitForEncodedFrame(1); |
| EXPECT_EQ(VideoFrameBuffer::Type::kNative, |
| fake_encoder_.GetLastInputPixelFormat()); |
| video_stream_encoder_->Stop(); |
| } |
| |
| TEST_F(VideoStreamEncoderTest, |
| NativeFrameGetsDelivered_PixelFormatPreferenceMatches) { |
| video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources( |
| DataRate::BitsPerSec(kTargetBitrateBps), |
| DataRate::BitsPerSec(kTargetBitrateBps), |
| DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0); |
| |
| fake_encoder_.SetPreferredPixelFormats({VideoFrameBuffer::Type::kNV12}); |
| |
| rtc::Event frame_destroyed_event; |
| video_source_.IncomingCapturedFrame(CreateFakeNV12NativeFrame( |
| 1, &frame_destroyed_event, codec_width_, codec_height_)); |
| WaitForEncodedFrame(1); |
| EXPECT_EQ(VideoFrameBuffer::Type::kNative, |
| fake_encoder_.GetLastInputPixelFormat()); |
| video_stream_encoder_->Stop(); |
| } |
| |
| TEST_F(VideoStreamEncoderTest, NativeFrameGetsDelivered_MappingIsNotFeasible) { |
| video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources( |
| DataRate::BitsPerSec(kTargetBitrateBps), |
| DataRate::BitsPerSec(kTargetBitrateBps), |
| DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0); |
| |
| // Fake NV12 native frame does not allow mapping to I444. |
| fake_encoder_.SetPreferredPixelFormats({VideoFrameBuffer::Type::kI444}); |
| |
| rtc::Event frame_destroyed_event; |
| video_source_.IncomingCapturedFrame(CreateFakeNV12NativeFrame( |
| 1, &frame_destroyed_event, codec_width_, codec_height_)); |
| WaitForEncodedFrame(1); |
| EXPECT_EQ(VideoFrameBuffer::Type::kNative, |
| fake_encoder_.GetLastInputPixelFormat()); |
| video_stream_encoder_->Stop(); |
| } |
| |
| TEST_F(VideoStreamEncoderTest, NativeFrameGetsDelivered_BackedByNV12) { |
| video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources( |
| DataRate::BitsPerSec(kTargetBitrateBps), |
| DataRate::BitsPerSec(kTargetBitrateBps), |
| DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0); |
| |
| rtc::Event frame_destroyed_event; |
| video_source_.IncomingCapturedFrame(CreateFakeNV12NativeFrame( |
| 1, &frame_destroyed_event, codec_width_, codec_height_)); |
| WaitForEncodedFrame(1); |
| EXPECT_EQ(VideoFrameBuffer::Type::kNative, |
| fake_encoder_.GetLastInputPixelFormat()); |
| video_stream_encoder_->Stop(); |
| } |
| |
| TEST_F(VideoStreamEncoderTest, DropsFramesWhenCongestionWindowPushbackSet) { |
| video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources( |
| DataRate::BitsPerSec(kTargetBitrateBps), |
| DataRate::BitsPerSec(kTargetBitrateBps), |
| DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0); |
| video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr)); |
| WaitForEncodedFrame(1); |
| |
| video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources( |
| DataRate::BitsPerSec(kTargetBitrateBps), |
| DataRate::BitsPerSec(kTargetBitrateBps), |
| DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0.5); |
| // The congestion window pushback is set to 0.5, which will drop 1/2 of |
| // frames. Adding two frames means that the first frame will be dropped and |
| // the second frame will be sent to the encoder. |
| video_source_.IncomingCapturedFrame(CreateFrame(2, nullptr)); |
| video_source_.IncomingCapturedFrame(CreateFrame(3, nullptr)); |
| WaitForEncodedFrame(3); |
| video_source_.IncomingCapturedFrame(CreateFrame(4, nullptr)); |
| video_source_.IncomingCapturedFrame(CreateFrame(5, nullptr)); |
| WaitForEncodedFrame(5); |
| EXPECT_EQ(2u, stats_proxy_->GetStats().frames_dropped_by_congestion_window); |
| video_stream_encoder_->Stop(); |
| } |
| |
| TEST_F(VideoStreamEncoderTest, |
| ConfigureEncoderTriggersOnEncoderConfigurationChanged) { |
| video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources( |
| DataRate::BitsPerSec(kTargetBitrateBps), |
| DataRate::BitsPerSec(kTargetBitrateBps), |
| DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0); |
| EXPECT_EQ(0, sink_.number_of_reconfigurations()); |
| |
| // Capture a frame and wait for it to synchronize with the encoder thread. |
| video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr)); |
| WaitForEncodedFrame(1); |
| // The encoder will have been configured once when the first frame is |
| // received. |
| EXPECT_EQ(1, sink_.number_of_reconfigurations()); |
| |
| VideoEncoderConfig video_encoder_config; |
| test::FillEncoderConfiguration(kVideoCodecVP8, 1, &video_encoder_config); |
| video_encoder_config.min_transmit_bitrate_bps = 9999; |
| video_stream_encoder_->ConfigureEncoder(std::move(video_encoder_config), |
| kMaxPayloadLength); |
| |
| // Capture a frame and wait for it to synchronize with the encoder thread. |
| video_source_.IncomingCapturedFrame(CreateFrame(2, nullptr)); |
| WaitForEncodedFrame(2); |
| EXPECT_EQ(2, sink_.number_of_reconfigurations()); |
| EXPECT_EQ(9999, sink_.last_min_transmit_bitrate()); |
| |
| video_stream_encoder_->Stop(); |
| } |
| |
| TEST_F(VideoStreamEncoderTest, FrameResolutionChangeReconfigureEncoder) { |
| video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources( |
| DataRate::BitsPerSec(kTargetBitrateBps), |
| DataRate::BitsPerSec(kTargetBitrateBps), |
| DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0); |
| |
| // Capture a frame and wait for it to synchronize with the encoder thread. |
| video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr)); |
| WaitForEncodedFrame(1); |
| // The encoder will have been configured once. |
| EXPECT_EQ(1, sink_.number_of_reconfigurations()); |
| EXPECT_EQ(codec_width_, fake_encoder_.codec_config().width); |
| EXPECT_EQ(codec_height_, fake_encoder_.codec_config().height); |
| |
| codec_width_ *= 2; |
| codec_height_ *= 2; |
| // Capture a frame with a higher resolution and wait for it to synchronize |
| // with the encoder thread. |
| video_source_.IncomingCapturedFrame(CreateFrame(2, nullptr)); |
| WaitForEncodedFrame(2); |
| EXPECT_EQ(codec_width_, fake_encoder_.codec_config().width); |
| EXPECT_EQ(codec_height_, fake_encoder_.codec_config().height); |
| EXPECT_EQ(2, sink_.number_of_reconfigurations()); |
| |
| video_stream_encoder_->Stop(); |
| } |
| |
| TEST_F(VideoStreamEncoderTest, |
| EncoderInstanceDestroyedBeforeAnotherInstanceCreated) { |
| video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources( |
| DataRate::BitsPerSec(kTargetBitrateBps), |
| DataRate::BitsPerSec(kTargetBitrateBps), |
| DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0); |
| |
| // Capture a frame and wait for it to synchronize with the encoder thread. |
| video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr)); |
| WaitForEncodedFrame(1); |
| |
| VideoEncoderConfig video_encoder_config; |
| test::FillEncoderConfiguration(kVideoCodecVP8, 1, &video_encoder_config); |
| // Changing the max payload data length recreates encoder. |
| video_stream_encoder_->ConfigureEncoder(std::move(video_encoder_config), |
| kMaxPayloadLength / 2); |
| |
| // Capture a frame and wait for it to synchronize with the encoder thread. |
| video_source_.IncomingCapturedFrame(CreateFrame(2, nullptr)); |
| WaitForEncodedFrame(2); |
| EXPECT_EQ(1, encoder_factory_.GetMaxNumberOfSimultaneousEncoderInstances()); |
| |
| video_stream_encoder_->Stop(); |
| } |
| |
| TEST_F(VideoStreamEncoderTest, BitrateLimitsChangeReconfigureRateAllocator) { |
| video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources( |
| DataRate::BitsPerSec(kTargetBitrateBps), |
| DataRate::BitsPerSec(kTargetBitrateBps), |
| DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0); |
| |
| VideoEncoderConfig video_encoder_config; |
| test::FillEncoderConfiguration(kVideoCodecVP8, 1, &video_encoder_config); |
| video_encoder_config.max_bitrate_bps = kTargetBitrateBps; |
| video_stream_encoder_->SetStartBitrate(kStartBitrateBps); |
| video_stream_encoder_->ConfigureEncoder(video_encoder_config.Copy(), |
| kMaxPayloadLength); |
| |
| // Capture a frame and wait for it to synchronize with the encoder thread. |
| video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr)); |
| WaitForEncodedFrame(1); |
| // The encoder will have been configured once when the first frame is |
| // received. |
| EXPECT_EQ(1, sink_.number_of_reconfigurations()); |
| EXPECT_EQ(kTargetBitrateBps, |
| bitrate_allocator_factory_.codec_config().maxBitrate * 1000); |
| EXPECT_EQ(kStartBitrateBps, |
| bitrate_allocator_factory_.codec_config().startBitrate * 1000); |
| |
| test::FillEncoderConfiguration(kVideoCodecVP8, 1, |
| &video_encoder_config); //??? |
| video_encoder_config.max_bitrate_bps = kTargetBitrateBps * 2; |
| video_stream_encoder_->SetStartBitrate(kStartBitrateBps * 2); |
| video_stream_encoder_->ConfigureEncoder(std::move(video_encoder_config), |
| kMaxPayloadLength); |
| |
| // Capture a frame and wait for it to synchronize with the encoder thread. |
| video_source_.IncomingCapturedFrame(CreateFrame(2, nullptr)); |
| WaitForEncodedFrame(2); |
| EXPECT_EQ(2, sink_.number_of_reconfigurations()); |
| // Bitrate limits have changed - rate allocator should be reconfigured, |
| // encoder should not be reconfigured. |
| EXPECT_EQ(kTargetBitrateBps * 2, |
| bitrate_allocator_factory_.codec_config().maxBitrate * 1000); |
| EXPECT_EQ(kStartBitrateBps * 2, |
| bitrate_allocator_factory_.codec_config().startBitrate * 1000); |
| EXPECT_EQ(1, fake_encoder_.GetNumEncoderInitializations()); |
| |
| video_stream_encoder_->Stop(); |
| } |
| |
| TEST_F(VideoStreamEncoderTest, |
| IntersectionOfEncoderAndAppBitrateLimitsUsedWhenBothProvided) { |
| video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources( |
| DataRate::BitsPerSec(kTargetBitrateBps), |
| DataRate::BitsPerSec(kTargetBitrateBps), |
| DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0); |
| |
| const uint32_t kMinEncBitrateKbps = 100; |
| const uint32_t kMaxEncBitrateKbps = 1000; |
| const VideoEncoder::ResolutionBitrateLimits encoder_bitrate_limits( |
| /*frame_size_pixels=*/codec_width_ * codec_height_, |
| /*min_start_bitrate_bps=*/0, |
| /*min_bitrate_bps=*/kMinEncBitrateKbps * 1000, |
| /*max_bitrate_bps=*/kMaxEncBitrateKbps * 1000); |
| fake_encoder_.SetResolutionBitrateLimits({encoder_bitrate_limits}); |
| |
| VideoEncoderConfig video_encoder_config; |
| test::FillEncoderConfiguration(kVideoCodecVP8, 1, &video_encoder_config); |
| video_encoder_config.max_bitrate_bps = (kMaxEncBitrateKbps + 1) * 1000; |
| video_encoder_config.simulcast_layers[0].min_bitrate_bps = |
| (kMinEncBitrateKbps + 1) * 1000; |
| video_stream_encoder_->ConfigureEncoder(video_encoder_config.Copy(), |
| kMaxPayloadLength); |
| |
| // When both encoder and app provide bitrate limits, the intersection of |
| // provided sets should be used. |
| video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr)); |
| WaitForEncodedFrame(1); |
| EXPECT_EQ(kMaxEncBitrateKbps, |
| bitrate_allocator_factory_.codec_config().maxBitrate); |
| EXPECT_EQ(kMinEncBitrateKbps + 1, |
| bitrate_allocator_factory_.codec_config().minBitrate); |
| |
| video_encoder_config.max_bitrate_bps = (kMaxEncBitrateKbps - 1) * 1000; |
| video_encoder_config.simulcast_layers[0].min_bitrate_bps = |
| (kMinEncBitrateKbps - 1) * 1000; |
| video_stream_encoder_->ConfigureEncoder(video_encoder_config.Copy(), |
| kMaxPayloadLength); |
| video_source_.IncomingCapturedFrame(CreateFrame(2, nullptr)); |
| WaitForEncodedFrame(2); |
| EXPECT_EQ(kMaxEncBitrateKbps - 1, |
| bitrate_allocator_factory_.codec_config().maxBitrate); |
| EXPECT_EQ(kMinEncBitrateKbps, |
| bitrate_allocator_factory_.codec_config().minBitrate); |
| |
| video_stream_encoder_->Stop(); |
| } |
| |
| TEST_F(VideoStreamEncoderTest, |
| EncoderAndAppLimitsDontIntersectEncoderLimitsIgnored) { |
| video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources( |
| DataRate::BitsPerSec(kTargetBitrateBps), |
| DataRate::BitsPerSec(kTargetBitrateBps), |
| DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0); |
| |
| const uint32_t kMinAppBitrateKbps = 100; |
| const uint32_t kMaxAppBitrateKbps = 200; |
| const uint32_t kMinEncBitrateKbps = kMaxAppBitrateKbps + 1; |
| const uint32_t kMaxEncBitrateKbps = kMaxAppBitrateKbps * 2; |
| const VideoEncoder::ResolutionBitrateLimits encoder_bitrate_limits( |
| /*frame_size_pixels=*/codec_width_ * codec_height_, |
| /*min_start_bitrate_bps=*/0, |
| /*min_bitrate_bps=*/kMinEncBitrateKbps * 1000, |
| /*max_bitrate_bps=*/kMaxEncBitrateKbps * 1000); |
| fake_encoder_.SetResolutionBitrateLimits({encoder_bitrate_limits}); |
| |
| VideoEncoderConfig video_encoder_config; |
| test::FillEncoderConfiguration(kVideoCodecVP8, 1, &video_encoder_config); |
| video_encoder_config.max_bitrate_bps = kMaxAppBitrateKbps * 1000; |
| video_encoder_config.simulcast_layers[0].min_bitrate_bps = |
| kMinAppBitrateKbps * 1000; |
| video_stream_encoder_->ConfigureEncoder(video_encoder_config.Copy(), |
| kMaxPayloadLength); |
| |
| video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr)); |
| WaitForEncodedFrame(1); |
| EXPECT_EQ(kMaxAppBitrateKbps, |
| bitrate_allocator_factory_.codec_config().maxBitrate); |
| EXPECT_EQ(kMinAppBitrateKbps, |
| bitrate_allocator_factory_.codec_config().minBitrate); |
| |
| video_stream_encoder_->Stop(); |
| } |
| |
| TEST_F(VideoStreamEncoderTest, |
| EncoderRecommendedMaxAndMinBitratesUsedForGivenResolution) { |
| video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources( |
| DataRate::BitsPerSec(kTargetBitrateBps), |
| DataRate::BitsPerSec(kTargetBitrateBps), |
| DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0); |
| |
| const VideoEncoder::ResolutionBitrateLimits encoder_bitrate_limits_270p( |
| 480 * 270, 34 * 1000, 12 * 1000, 1234 * 1000); |
| const VideoEncoder::ResolutionBitrateLimits encoder_bitrate_limits_360p( |
| 640 * 360, 43 * 1000, 21 * 1000, 2345 * 1000); |
| fake_encoder_.SetResolutionBitrateLimits( |
| {encoder_bitrate_limits_270p, encoder_bitrate_limits_360p}); |
| |
| VideoEncoderConfig video_encoder_config; |
| test::FillEncoderConfiguration(kVideoCodecVP8, 1, &video_encoder_config); |
| video_encoder_config.max_bitrate_bps = 0; |
| video_stream_encoder_->ConfigureEncoder(video_encoder_config.Copy(), |
| kMaxPayloadLength); |
| |
| // 270p. The bitrate limits recommended by encoder for 270p should be used. |
| video_source_.IncomingCapturedFrame(CreateFrame(1, 480, 270)); |
| WaitForEncodedFrame(1); |
| EXPECT_EQ(static_cast<uint32_t>(encoder_bitrate_limits_270p.min_bitrate_bps), |
| bitrate_allocator_factory_.codec_config().minBitrate * 1000); |
| EXPECT_EQ(static_cast<uint32_t>(encoder_bitrate_limits_270p.max_bitrate_bps), |
| bitrate_allocator_factory_.codec_config().maxBitrate * 1000); |
| |
| // 360p. The bitrate limits recommended by encoder for 360p should be used. |
| video_source_.IncomingCapturedFrame(CreateFrame(2, 640, 360)); |
| WaitForEncodedFrame(2); |
| EXPECT_EQ(static_cast<uint32_t>(encoder_bitrate_limits_360p.min_bitrate_bps), |
| bitrate_allocator_factory_.codec_config().minBitrate * 1000); |
| EXPECT_EQ(static_cast<uint32_t>(encoder_bitrate_limits_360p.max_bitrate_bps), |
| bitrate_allocator_factory_.codec_config().maxBitrate * 1000); |
| |
| // Resolution between 270p and 360p. The bitrate limits recommended by |
| // encoder for 360p should be used. |
| video_source_.IncomingCapturedFrame( |
| CreateFrame(3, (640 + 480) / 2, (360 + 270) / 2)); |
| WaitForEncodedFrame(3); |
| EXPECT_EQ(static_cast<uint32_t>(encoder_bitrate_limits_360p.min_bitrate_bps), |
| bitrate_allocator_factory_.codec_config().minBitrate * 1000); |
| EXPECT_EQ(static_cast<uint32_t>(encoder_bitrate_limits_360p.max_bitrate_bps), |
| bitrate_allocator_factory_.codec_config().maxBitrate * 1000); |
| |
| // Resolution higher than 360p. The caps recommended by encoder should be |
| // ignored. |
| video_source_.IncomingCapturedFrame(CreateFrame(4, 960, 540)); |
| WaitForEncodedFrame(4); |
| EXPECT_NE(static_cast<uint32_t>(encoder_bitrate_limits_270p.min_bitrate_bps), |
| bitrate_allocator_factory_.codec_config().minBitrate * 1000); |
| EXPECT_NE(static_cast<uint32_t>(encoder_bitrate_limits_270p.max_bitrate_bps), |
| bitrate_allocator_factory_.codec_config().maxBitrate * 1000); |
| EXPECT_NE(static_cast<uint32_t>(encoder_bitrate_limits_360p.min_bitrate_bps), |
| bitrate_allocator_factory_.codec_config().minBitrate * 1000); |
| EXPECT_NE(static_cast<uint32_t>(encoder_bitrate_limits_360p.max_bitrate_bps), |
| bitrate_allocator_factory_.codec_config().maxBitrate * 1000); |
| |
| // Resolution lower than 270p. The max bitrate limit recommended by encoder |
| // for 270p should be used. |
| video_source_.IncomingCapturedFrame(CreateFrame(5, 320, 180)); |
| WaitForEncodedFrame(5); |
| EXPECT_EQ(static_cast<uint32_t>(encoder_bitrate_limits_270p.min_bitrate_bps), |
| bitrate_allocator_factory_.codec_config().minBitrate * 1000); |
| EXPECT_EQ(static_cast<uint32_t>(encoder_bitrate_limits_270p.max_bitrate_bps), |
| bitrate_allocator_factory_.codec_config().maxBitrate * 1000); |
| |
| video_stream_encoder_->Stop(); |
| } |
| |
| TEST_F(VideoStreamEncoderTest, EncoderRecommendedMaxBitrateCapsTargetBitrate) { |
| video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources( |
| DataRate::BitsPerSec(kTargetBitrateBps), |
| DataRate::BitsPerSec(kTargetBitrateBps), |
| DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0); |
| |
| VideoEncoderConfig video_encoder_config; |
| test::FillEncoderConfiguration(kVideoCodecVP8, 1, &video_encoder_config); |
| video_encoder_config.max_bitrate_bps = 0; |
| video_stream_encoder_->ConfigureEncoder(video_encoder_config.Copy(), |
| kMaxPayloadLength); |
| |
| // Encode 720p frame to get the default encoder target bitrate. |
| video_source_.IncomingCapturedFrame(CreateFrame(1, 1280, 720)); |
| WaitForEncodedFrame(1); |
| const uint32_t kDefaultTargetBitrateFor720pKbps = |
| bitrate_allocator_factory_.codec_config() |
| .simulcastStream[0] |
| .targetBitrate; |
| |
| // Set the max recommended encoder bitrate to something lower than the default |
| // target bitrate. |
| const VideoEncoder::ResolutionBitrateLimits encoder_bitrate_limits( |
| 1280 * 720, 10 * 1000, 10 * 1000, |
| kDefaultTargetBitrateFor720pKbps / 2 * 1000); |
| fake_encoder_.SetResolutionBitrateLimits({encoder_bitrate_limits}); |
| |
| // Change resolution to trigger encoder reinitialization. |
| video_source_.IncomingCapturedFrame(CreateFrame(2, 640, 360)); |
| WaitForEncodedFrame(2); |
| video_source_.IncomingCapturedFrame(CreateFrame(3, 1280, 720)); |
| WaitForEncodedFrame(3); |
| |
| // Ensure the target bitrate is capped by the max bitrate. |
| EXPECT_EQ(bitrate_allocator_factory_.codec_config().maxBitrate * 1000, |
| static_cast<uint32_t>(encoder_bitrate_limits.max_bitrate_bps)); |
| EXPECT_EQ(bitrate_allocator_factory_.codec_config() |
| .simulcastStream[0] |
| .targetBitrate * |
| 1000, |
| static_cast<uint32_t>(encoder_bitrate_limits.max_bitrate_bps)); |
| |
| video_stream_encoder_->Stop(); |
| } |
| |
| TEST_F(VideoStreamEncoderTest, |
| EncoderMaxAndMinBitratesUsedForTwoStreamsHighestActive) { |
| const VideoEncoder::ResolutionBitrateLimits kEncoderLimits270p( |
| 480 * 270, 34 * 1000, 12 * 1000, 1234 * 1000); |
| const VideoEncoder::ResolutionBitrateLimits kEncoderLimits360p( |
| 640 * 360, 43 * 1000, 21 * 1000, 2345 * 1000); |
| fake_encoder_.SetResolutionBitrateLimits( |
| {kEncoderLimits270p, kEncoderLimits360p}); |
| |
| // Two streams, highest stream active. |
| VideoEncoderConfig config; |
| const int kNumStreams = 2; |
| test::FillEncoderConfiguration(kVideoCodecVP8, kNumStreams, &config); |
| config.max_bitrate_bps = 0; |
| config.simulcast_layers[0].active = false; |
| config.simulcast_layers[1].active = true; |
| config.video_stream_factory = |
| rtc::make_ref_counted<cricket::EncoderStreamFactory>( |
| "VP8", /*max qp*/ 56, /*screencast*/ false, |
| /*screenshare enabled*/ false); |
| video_stream_encoder_->ConfigureEncoder(config.Copy(), kMaxPayloadLength); |
| |
| // The encoder bitrate limits for 270p should be used. |
| video_source_.IncomingCapturedFrame(CreateFrame(1, 480, 270)); |
| EXPECT_FALSE(WaitForFrame(1000)); |
| EXPECT_EQ(fake_encoder_.video_codec().numberOfSimulcastStreams, kNumStreams); |
| EXPECT_EQ(static_cast<uint32_t>(kEncoderLimits270p.min_bitrate_bps), |
| fake_encoder_.video_codec().simulcastStream[1].minBitrate * 1000); |
| EXPECT_EQ(static_cast<uint32_t>(kEncoderLimits270p.max_bitrate_bps), |
| fake_encoder_.video_codec().simulcastStream[1].maxBitrate * 1000); |
| |
| // The encoder bitrate limits for 360p should be used. |
| video_source_.IncomingCapturedFrame(CreateFrame(2, 640, 360)); |
| EXPECT_FALSE(WaitForFrame(1000)); |
| EXPECT_EQ(static_cast<uint32_t>(kEncoderLimits360p.min_bitrate_bps), |
| fake_encoder_.video_codec().simulcastStream[1].minBitrate * 1000); |
| EXPECT_EQ(static_cast<uint32_t>(kEncoderLimits360p.max_bitrate_bps), |
| fake_encoder_.video_codec().simulcastStream[1].maxBitrate * 1000); |
| |
| // Resolution b/w 270p and 360p. The encoder limits for 360p should be used. |
| video_source_.IncomingCapturedFrame( |
| CreateFrame(3, (640 + 480) / 2, (360 + 270) / 2)); |
| EXPECT_FALSE(WaitForFrame(1000)); |
| EXPECT_EQ(static_cast<uint32_t>(kEncoderLimits360p.min_bitrate_bps), |
| fake_encoder_.video_codec().simulcastStream[1].minBitrate * 1000); |
| EXPECT_EQ(static_cast<uint32_t>(kEncoderLimits360p.max_bitrate_bps), |
| fake_encoder_.video_codec().simulcastStream[1].maxBitrate * 1000); |
| |
| // Resolution higher than 360p. Encoder limits should be ignored. |
| video_source_.IncomingCapturedFrame(CreateFrame(4, 960, 540)); |
| EXPECT_FALSE(WaitForFrame(1000)); |
| EXPECT_NE(static_cast<uint32_t>(kEncoderLimits270p.min_bitrate_bps), |
| fake_encoder_.video_codec().simulcastStream[1].minBitrate * 1000); |
| EXPECT_NE(static_cast<uint32_t>(kEncoderLimits270p.max_bitrate_bps), |
| fake_encoder_.video_codec().simulcastStream[1].maxBitrate * 1000); |
| EXPECT_NE(static_cast<uint32_t>(kEncoderLimits360p.min_bitrate_bps), |
| fake_encoder_.video_codec().simulcastStream[1].minBitrate * 1000); |
| EXPECT_NE(static_cast<uint32_t>(kEncoderLimits360p.max_bitrate_bps), |
| fake_encoder_.video_codec().simulcastStream[1].maxBitrate * 1000); |
| |
| // Resolution lower than 270p. The encoder limits for 270p should be used. |
| video_source_.IncomingCapturedFrame(CreateFrame(5, 320, 180)); |
| EXPECT_FALSE(WaitForFrame(1000)); |
| EXPECT_EQ(static_cast<uint32_t>(kEncoderLimits270p.min_bitrate_bps), |
| fake_encoder_.video_codec().simulcastStream[1].minBitrate * 1000); |
| EXPECT_EQ(static_cast<uint32_t>(kEncoderLimits270p.max_bitrate_bps), |
| fake_encoder_.video_codec().simulcastStream[1].maxBitrate * 1000); |
| |
| video_stream_encoder_->Stop(); |
| } |
| |
| TEST_F(VideoStreamEncoderTest, |
| DefaultEncoderMaxAndMinBitratesUsedForTwoStreamsHighestActive) { |
| // Two streams, highest stream active. |
| VideoEncoderConfig config; |
| const int kNumStreams = 2; |
| test::FillEncoderConfiguration(kVideoCodecVP8, kNumStreams, &config); |
| config.max_bitrate_bps = 0; |
| config.simulcast_layers[0].active = false; |
| config.simulcast_layers[1].active = true; |
| config.video_stream_factory = |
| rtc::make_ref_counted<cricket::EncoderStreamFactory>( |
| "VP8", /*max qp*/ 56, /*screencast*/ false, |
| /*screenshare enabled*/ false); |
| video_stream_encoder_->ConfigureEncoder(config.Copy(), kMaxPayloadLength); |
| |
| // Default bitrate limits for 270p should be used. |
| const absl::optional<VideoEncoder::ResolutionBitrateLimits> |
| kDefaultLimits270p = |
| EncoderInfoSettings::GetDefaultSinglecastBitrateLimitsForResolution( |
| kVideoCodecVP8, 480 * 270); |
| video_source_.IncomingCapturedFrame(CreateFrame(1, 480, 270)); |
| EXPECT_FALSE(WaitForFrame(1000)); |
| EXPECT_EQ(fake_encoder_.video_codec().numberOfSimulcastStreams, kNumStreams); |
| EXPECT_EQ(static_cast<uint32_t>(kDefaultLimits270p->min_bitrate_bps), |
| fake_encoder_.video_codec().simulcastStream[1].minBitrate * 1000); |
| EXPECT_EQ(static_cast<uint32_t>(kDefaultLimits270p->max_bitrate_bps), |
| fake_encoder_.video_codec().simulcastStream[1].maxBitrate * 1000); |
| |
| // Default bitrate limits for 360p should be used. |
| const absl::optional<VideoEncoder::ResolutionBitrateLimits> |
| kDefaultLimits360p = |
| EncoderInfoSettings::GetDefaultSinglecastBitrateLimitsForResolution( |
| kVideoCodecVP8, 640 * 360); |
| video_source_.IncomingCapturedFrame(CreateFrame(2, 640, 360)); |
| EXPECT_FALSE(WaitForFrame(1000)); |
| EXPECT_EQ(static_cast<uint32_t>(kDefaultLimits360p->min_bitrate_bps), |
| fake_encoder_.video_codec().simulcastStream[1].minBitrate * 1000); |
| EXPECT_EQ(static_cast<uint32_t>(kDefaultLimits360p->max_bitrate_bps), |
| fake_encoder_.video_codec().simulcastStream[1].maxBitrate * 1000); |
| |
| // Resolution b/w 270p and 360p. The default limits for 360p should be used. |
| video_source_.IncomingCapturedFrame( |
| CreateFrame(3, (640 + 480) / 2, (360 + 270) / 2)); |
| EXPECT_FALSE(WaitForFrame(1000)); |
| EXPECT_EQ(static_cast<uint32_t>(kDefaultLimits360p->min_bitrate_bps), |
| fake_encoder_.video_codec().simulcastStream[1].minBitrate * 1000); |
| EXPECT_EQ(static_cast<uint32_t>(kDefaultLimits360p->max_bitrate_bps), |
| fake_encoder_.video_codec().simulcastStream[1].maxBitrate * 1000); |
| |
| // Default bitrate limits for 540p should be used. |
| const absl::optional<VideoEncoder::ResolutionBitrateLimits> |
| kDefaultLimits540p = |
| EncoderInfoSettings::GetDefaultSinglecastBitrateLimitsForResolution( |
| kVideoCodecVP8, 960 * 540); |
| video_source_.IncomingCapturedFrame(CreateFrame(4, 960, 540)); |
| EXPECT_FALSE(WaitForFrame(1000)); |
| EXPECT_EQ(static_cast<uint32_t>(kDefaultLimits540p->min_bitrate_bps), |
| fake_encoder_.video_codec().simulcastStream[1].minBitrate * 1000); |
| EXPECT_EQ(static_cast<uint32_t>(kDefaultLimits540p->max_bitrate_bps), |
| fake_encoder_.video_codec().simulcastStream[1].maxBitrate * 1000); |
| |
| video_stream_encoder_->Stop(); |
| } |
| |
| TEST_F(VideoStreamEncoderTest, |
| EncoderMaxAndMinBitratesUsedForThreeStreamsMiddleActive) { |
| const VideoEncoder::ResolutionBitrateLimits kEncoderLimits270p( |
| 480 * 270, 34 * 1000, 12 * 1000, 1234 * 1000); |
| const VideoEncoder::ResolutionBitrateLimits kEncoderLimits360p( |
| 640 * 360, 43 * 1000, 21 * 1000, 2345 * 1000); |
| const VideoEncoder::ResolutionBitrateLimits kEncoderLimits720p( |
| 1280 * 720, 54 * 1000, 31 * 1000, 3456 * 1000); |
| fake_encoder_.SetResolutionBitrateLimits( |
| {kEncoderLimits270p, kEncoderLimits360p, kEncoderLimits720p}); |
| |
| // Three streams, middle stream active. |
| VideoEncoderConfig config; |
| const int kNumStreams = 3; |
| test::FillEncoderConfiguration(kVideoCodecVP8, kNumStreams, &config); |
| config.simulcast_layers[0].active = false; |
| config.simulcast_layers[1].active = true; |
| config.simulcast_layers[2].active = false; |
| config.video_stream_factory = |
| rtc::make_ref_counted<cricket::EncoderStreamFactory>( |
| "VP8", /*max qp*/ 56, /*screencast*/ false, |
| /*screenshare enabled*/ false); |
| video_stream_encoder_->ConfigureEncoder(config.Copy(), kMaxPayloadLength); |
| |
| // The encoder bitrate limits for 360p should be used. |
| video_source_.IncomingCapturedFrame(CreateFrame(1, 1280, 720)); |
| EXPECT_FALSE(WaitForFrame(1000)); |
| EXPECT_EQ(fake_encoder_.video_codec().numberOfSimulcastStreams, kNumStreams); |
| EXPECT_EQ(static_cast<uint32_t>(kEncoderLimits360p.min_bitrate_bps), |
| fake_encoder_.video_codec().simulcastStream[1].minBitrate * 1000); |
| EXPECT_EQ(static_cast<uint32_t>(kEncoderLimits360p.max_bitrate_bps), |
| fake_encoder_.video_codec().simulcastStream[1].maxBitrate * 1000); |
| |
| // The encoder bitrate limits for 270p should be used. |
| video_source_.IncomingCapturedFrame(CreateFrame(2, 960, 540)); |
| EXPECT_FALSE(WaitForFrame(1000)); |
| EXPECT_EQ(static_cast<uint32_t>(kEncoderLimits270p.min_bitrate_bps), |
| fake_encoder_.video_codec().simulcastStream[1].minBitrate * 1000); |
| EXPECT_EQ(static_cast<uint32_t>(kEncoderLimits270p.max_bitrate_bps), |
| fake_encoder_.video_codec().simulcastStream[1].maxBitrate * 1000); |
| |
| video_stream_encoder_->Stop(); |
| } |
| |
| TEST_F(VideoStreamEncoderTest, |
| EncoderMaxAndMinBitratesNotUsedForThreeStreamsLowestActive) { |
| const VideoEncoder::ResolutionBitrateLimits kEncoderLimits270p( |
| 480 * 270, 34 * 1000, 12 * 1000, 1234 * 1000); |
| const VideoEncoder::ResolutionBitrateLimits kEncoderLimits360p( |
| 640 * 360, 43 * 1000, 21 * 1000, 2345 * 1000); |
| const VideoEncoder::ResolutionBitrateLimits kEncoderLimits720p( |
| 1280 * 720, 54 * 1000, 31 * 1000, 3456 * 1000); |
| fake_encoder_.SetResolutionBitrateLimits( |
| {kEncoderLimits270p, kEncoderLimits360p, kEncoderLimits720p}); |
| |
| // Three streams, lowest stream active. |
| VideoEncoderConfig config; |
| const int kNumStreams = 3; |
| test::FillEncoderConfiguration(kVideoCodecVP8, kNumStreams, &config); |
| config.simulcast_layers[0].active = true; |
| config.simulcast_layers[1].active = false; |
| config.simulcast_layers[2].active = false; |
| config.video_stream_factory = |
| rtc::make_ref_counted<cricket::EncoderStreamFactory>( |
| "VP8", /*max qp*/ 56, /*screencast*/ false, |
| /*screenshare enabled*/ false); |
| video_stream_encoder_->ConfigureEncoder(config.Copy(), kMaxPayloadLength); |
| |
| // Resolution on lowest stream lower than 270p. The encoder limits not applied |
| // on lowest stream, limits for 270p should not be used |
| video_source_.IncomingCapturedFrame(CreateFrame(1, 1280, 720)); |
| EXPECT_FALSE(WaitForFrame(1000)); |
| EXPECT_EQ(fake_encoder_.video_codec().numberOfSimulcastStreams, kNumStreams); |
| EXPECT_NE(static_cast<uint32_t>(kEncoderLimits270p.min_bitrate_bps), |
| fake_encoder_.video_codec().simulcastStream[1].minBitrate * 1000); |
| EXPECT_NE(static_cast<uint32_t>(kEncoderLimits270p.max_bitrate_bps), |
| fake_encoder_.video_codec().simulcastStream[1].maxBitrate * 1000); |
| |
| video_stream_encoder_->Stop(); |
| } |
| |
| TEST_F(VideoStreamEncoderTest, |
| EncoderMaxBitrateCappedByConfigForTwoStreamsHighestActive) { |
| const VideoEncoder::ResolutionBitrateLimits kEncoderLimits270p( |
| 480 * 270, 34 * 1000, 12 * 1000, 1234 * 1000); |
| const VideoEncoder::ResolutionBitrateLimits kEncoderLimits360p( |
| 640 * 360, 43 * 1000, 21 * 1000, 2345 * 1000); |
| fake_encoder_.SetResolutionBitrateLimits( |
| {kEncoderLimits270p, kEncoderLimits360p}); |
| const int kMaxBitrateBps = kEncoderLimits360p.max_bitrate_bps - 100 * 1000; |
| |
| // Two streams, highest stream active. |
| VideoEncoderConfig config; |
| const int kNumStreams = 2; |
| test::FillEncoderConfiguration(kVideoCodecVP8, kNumStreams, &config); |
| config.simulcast_layers[0].active = false; |
| config.simulcast_layers[1].active = true; |
| config.simulcast_layers[1].max_bitrate_bps = kMaxBitrateBps; |
| config.video_stream_factory = |
| rtc::make_ref_counted<cricket::EncoderStreamFactory>( |
| "VP8", /*max qp*/ 56, /*screencast*/ false, |
| /*screenshare enabled*/ false); |
| video_stream_encoder_->ConfigureEncoder(config.Copy(), kMaxPayloadLength); |
| |
| // The encoder bitrate limits for 270p should be used. |
| video_source_.IncomingCapturedFrame(CreateFrame(1, 480, 270)); |
| EXPECT_FALSE(WaitForFrame(1000)); |
| EXPECT_EQ(fake_encoder_.video_codec().numberOfSimulcastStreams, kNumStreams); |
| EXPECT_EQ(static_cast<uint32_t>(kEncoderLimits270p.min_bitrate_bps), |
| fake_encoder_.video_codec().simulcastStream[1].minBitrate * 1000); |
| EXPECT_EQ(static_cast<uint32_t>(kEncoderLimits270p.max_bitrate_bps), |
| fake_encoder_.video_codec().simulcastStream[1].maxBitrate * 1000); |
| |
| // The max configured bitrate is less than the encoder limit for 360p. |
| video_source_.IncomingCapturedFrame(CreateFrame(2, 640, 360)); |
| EXPECT_FALSE(WaitForFrame(1000)); |
| EXPECT_EQ(static_cast<uint32_t>(kEncoderLimits360p.min_bitrate_bps), |
| fake_encoder_.video_codec().simulcastStream[1].minBitrate * 1000); |
| EXPECT_EQ(static_cast<uint32_t>(kMaxBitrateBps), |
| fake_encoder_.video_codec().simulcastStream[1].maxBitrate * 1000); |
| |
| video_stream_encoder_->Stop(); |
| } |
| |
| TEST_F(VideoStreamEncoderTest, SwitchSourceDeregisterEncoderAsSink) { |
| EXPECT_TRUE(video_source_.has_sinks()); |
| test::FrameForwarder new_video_source; |
| video_stream_encoder_->SetSource( |
| &new_video_source, webrtc::DegradationPreference::MAINTAIN_FRAMERATE); |
| EXPECT_FALSE(video_source_.has_sinks()); |
| EXPECT_TRUE(new_video_source.has_sinks()); |
| |
| video_stream_encoder_->Stop(); |
| } |
| |
| TEST_F(VideoStreamEncoderTest, SinkWantsRotationApplied) { |
| EXPECT_FALSE(video_source_.sink_wants().rotation_applied); |
| video_stream_encoder_->SetSink(&sink_, true /*rotation_applied*/); |
| EXPECT_TRUE(video_source_.sink_wants().rotation_applied); |
| video_stream_encoder_->Stop(); |
| } |
| |
| class ResolutionAlignmentTest |
| : public VideoStreamEncoderTest, |
| public ::testing::WithParamInterface< |
| ::testing::tuple<int, std::vector<double>>> { |
| public: |
| ResolutionAlignmentTest() |
| : requested_alignment_(::testing::get<0>(GetParam())), |
| scale_factors_(::testing::get<1>(GetParam())) {} |
| |
| protected: |
| const int requested_alignment_; |
| const std::vector<double> scale_factors_; |
| }; |
| |
| INSTANTIATE_TEST_SUITE_P( |
| AlignmentAndScaleFactors, |
| ResolutionAlignmentTest, |
| ::testing::Combine( |
| ::testing::Values(1, 2, 3, 4, 5, 6, 16, 22), // requested_alignment_ |
| ::testing::Values(std::vector<double>{-1.0}, // scale_factors_ |
| std::vector<double>{-1.0, -1.0}, |
| std::vector<double>{-1.0, -1.0, -1.0}, |
| std::vector<double>{4.0, 2.0, 1.0}, |
| std::vector<double>{9999.0, -1.0, 1.0}, |
| std::vector<double>{3.99, 2.01, 1.0}, |
| std::vector<double>{4.9, 1.7, 1.25}, |
| std::vector<double>{10.0, 4.0, 3.0}, |
| std::vector<double>{1.75, 3.5}, |
| std::vector<double>{1.5, 2.5}, |
| std::vector<double>{1.3, 1.0}))); |
| |
| TEST_P(ResolutionAlignmentTest, SinkWantsAlignmentApplied) { |
| // Set requested resolution alignment. |
| video_source_.set_adaptation_enabled(true); |
| fake_encoder_.SetRequestedResolutionAlignment(requested_alignment_); |
| fake_encoder_.SetApplyAlignmentToAllSimulcastLayers(true); |
| |
| // Fill config with the scaling factor by which to reduce encoding size. |
| const int num_streams = scale_factors_.size(); |
| VideoEncoderConfig config; |
| test::FillEncoderConfiguration(kVideoCodecVP8, num_streams, &config); |
| for (int i = 0; i < num_streams; ++i) { |
| config.simulcast_layers[i].scale_resolution_down_by = scale_factors_[i]; |
| } |
| config.video_stream_factory = |
| rtc::make_ref_counted<cricket::EncoderStreamFactory>( |
| "VP8", /*max qp*/ 56, /*screencast*/ false, |
| /*screenshare enabled*/ false); |
| video_stream_encoder_->ConfigureEncoder(std::move(config), kMaxPayloadLength); |
| |
| video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources( |
| DataRate::BitsPerSec(kSimulcastTargetBitrateBps), |
| DataRate::BitsPerSec(kSimulcastTargetBitrateBps), |
| DataRate::BitsPerSec(kSimulcastTargetBitrateBps), 0, 0, 0); |
| // Wait for all layers before triggering event. |
| sink_.SetNumExpectedLayers(num_streams); |
| |
| // On the 1st frame, we should have initialized the encoder and |
| // asked for its resolution requirements. |
| int64_t timestamp_ms = kFrameIntervalMs; |
| video_source_.IncomingCapturedFrame(CreateFrame(timestamp_ms, 1280, 720)); |
| WaitForEncodedFrame(timestamp_ms); |
| EXPECT_EQ(1, fake_encoder_.GetNumEncoderInitializations()); |
| |
| // On the 2nd frame, we should be receiving a correctly aligned resolution. |
| // (It's up the to the encoder to potentially drop the previous frame, |
| // to avoid coding back-to-back keyframes.) |
| timestamp_ms += kFrameIntervalMs; |
| video_source_.IncomingCapturedFrame(CreateFrame(timestamp_ms, 1280, 720)); |
| WaitForEncodedFrame(timestamp_ms); |
| EXPECT_GE(fake_encoder_.GetNumEncoderInitializations(), 1); |
| |
| VideoCodec codec = fake_encoder_.video_codec(); |
| EXPECT_EQ(codec.numberOfSimulcastStreams, num_streams); |
| // Frame size should be a multiple of the requested alignment. |
| for (int i = 0; i < codec.numberOfSimulcastStreams; ++i) { |
| EXPECT_EQ(codec.simulcastStream[i].width % requested_alignment_, 0); |
| EXPECT_EQ(codec.simulcastStream[i].height % requested_alignment_, 0); |
| // Aspect ratio should match. |
| EXPECT_EQ(codec.width * codec.simulcastStream[i].height, |
| codec.height * codec.simulcastStream[i].width); |
| } |
| |
| video_stream_encoder_->Stop(); |
| } |
| |
| TEST_F(VideoStreamEncoderTest, TestCpuDowngrades_BalancedMode) { |
| const int kFramerateFps = 30; |
| const int kWidth = 1280; |
| const int kHeight = 720; |
| |
| // We rely on the automatic resolution adaptation, but we handle framerate |
| // adaptation manually by mocking the stats proxy. |
| video_source_.set_adaptation_enabled(true); |
| |
| // Enable BALANCED preference, no initial limitation. |
| video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources( |
| DataRate::BitsPerSec(kTargetBitrateBps), |
| DataRate::BitsPerSec(kTargetBitrateBps), |
| DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0); |
| video_stream_encoder_->SetSource(&video_source_, |
| webrtc::DegradationPreference::BALANCED); |
| EXPECT_THAT(video_source_.sink_wants(), UnlimitedSinkWants()); |
| EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_resolution); |
| EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_framerate); |
| EXPECT_EQ(0, stats_proxy_->GetStats().number_of_cpu_adapt_changes); |
| |
| // Adapt down as far as possible. |
| rtc::VideoSinkWants last_wants; |
| int64_t t = 1; |
| int loop_count = 0; |
| do { |
| ++loop_count; |
| last_wants = video_source_.sink_wants(); |
| |
| // Simulate the framerate we've been asked to adapt to. |
| const int fps = std::min(kFramerateFps, last_wants.max_framerate_fps); |
| const int frame_interval_ms = rtc::kNumMillisecsPerSec / fps; |
| VideoSendStream::Stats mock_stats = stats_proxy_->GetStats(); |
| mock_stats.input_frame_rate = fps; |
| stats_proxy_->SetMockStats(mock_stats); |
| |
| video_source_.IncomingCapturedFrame(CreateFrame(t, kWidth, kHeight)); |
| sink_.WaitForEncodedFrame(t); |
| t += frame_interval_ms; |
| |
| video_stream_encoder_->TriggerCpuOveruse(); |
| EXPECT_THAT( |
| video_source_.sink_wants(), |
| FpsInRangeForPixelsInBalanced(*video_source_.last_sent_width() * |
| *video_source_.last_sent_height())); |
| } while (video_source_.sink_wants().max_pixel_count < |
| last_wants.max_pixel_count || |
| video_source_.sink_wants().max_framerate_fps < |
| last_wants.max_framerate_fps); |
| |
| // Verify that we've adapted all the way down. |
| stats_proxy_->ResetMockStats(); |
| EXPECT_TRUE(stats_proxy_->GetStats().cpu_limited_resolution); |
| EXPECT_TRUE(stats_proxy_->GetStats().cpu_limited_framerate); |
| EXPECT_EQ(loop_count - 1, |
| stats_proxy_->GetStats().number_of_cpu_adapt_changes); |
| EXPECT_EQ(kMinPixelsPerFrame, *video_source_.last_sent_width() * |
| *video_source_.last_sent_height()); |
| EXPECT_EQ(kMinBalancedFramerateFps, |
| video_source_.sink_wants().max_framerate_fps); |
| |
| // Adapt back up the same number of times we adapted down. |
| for (int i = 0; i < loop_count - 1; ++i) { |
| last_wants = video_source_.sink_wants(); |
| |
| // Simulate the framerate we've been asked to adapt to. |
| const int fps = std::min(kFramerateFps, last_wants.max_framerate_fps); |
| const int frame_interval_ms = rtc::kNumMillisecsPerSec / fps; |
| VideoSendStream::Stats mock_stats = stats_proxy_->GetStats(); |
| mock_stats.input_frame_rate = fps; |
| stats_proxy_->SetMockStats(mock_stats); |
| |
| video_source_.IncomingCapturedFrame(CreateFrame(t, kWidth, kHeight)); |
| sink_.WaitForEncodedFrame(t); |
| t += frame_interval_ms; |
| |
| video_stream_encoder_->TriggerCpuUnderuse(); |
| EXPECT_THAT( |
| video_source_.sink_wants(), |
| FpsInRangeForPixelsInBalanced(*video_source_.last_sent_width() * |
| *video_source_.last_sent_height())); |
| EXPECT_TRUE(video_source_.sink_wants().max_pixel_count > |
| last_wants.max_pixel_count || |
| video_source_.sink_wants().max_framerate_fps > |
| last_wants.max_framerate_fps); |
| } |
| |
| EXPECT_THAT(video_source_.sink_wants(), FpsMaxResolutionMax()); |
| stats_proxy_->ResetMockStats(); |
| EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_resolution); |
| EXPECT_FALSE(stats_proxy_->GetStats().cpu_limited_framerate); |
| EXPECT_EQ((loop_count - 1) * 2, |
| stats_proxy_->GetStats().number_of_cpu_adapt_changes); |
| |
| video_stream_encoder_->Stop(); |
| } |
| |
| TEST_F(VideoStreamEncoderTest, |
| SinkWantsNotChangedByResourceLimitedBeforeDegradationPreferenceChange) { |
| video_stream_encoder_->OnBitrateUpdated( |
| DataRate::BitsPerSec(kTargetBitrateBps), |
| DataRate::BitsPerSec(kTargetBitrateBps), |
| DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0); |
| EXPECT_THAT(video_source_.sink_wants(), UnlimitedSinkWants()); |
| |
| const int kFrameWidth = 1280; |
| const int kFrameHeight = 720; |
| |
| int64_t ntp_time = kFrameIntervalMs; |
| |
| // Force an input frame rate to be available, or the adaptation call won't |
| // know what framerate to adapt form. |
| const int kInputFps = 30; |
| VideoSendStream::Stats stats = stats_proxy_->GetStats(); |
| stats.input_frame_rate = kInputFps; |
| stats_proxy_->SetMockStats(stats); |
| |
| video_source_.set_adaptation_enabled(true); |
| video_stream_encoder_->SetSource( |
| &video_source_, webrtc::DegradationPreference::MAINTAIN_RESOLUTION); |
| EXPECT_THAT(video_source_.sink_wants(), UnlimitedSinkWants()); |
| video_source_.IncomingCapturedFrame( |
| CreateFrame(ntp_time, kFrameWidth, kFrameHeight)); |
| sink_.WaitForEncodedFrame(ntp_time); |
| ntp_time += kFrameIntervalMs; |
| |
| // Trigger CPU overuse. |
| video_stream_encoder_->TriggerCpuOveruse(); |
| video_source_.IncomingCapturedFrame( |
| CreateFrame(ntp_time, kFrameWidth, kFrameHeight)); |
| sink_.WaitForEncodedFrame(ntp_time); |
| ntp_time += kFrameIntervalMs; |
| |
| EXPECT_FALSE(video_source_.sink_wants().target_pixel_count); |
| EXPECT_EQ(std::numeric_limits<int>::max(), |
| video_source_.sink_wants().max_pixel_count); |
| // Some framerate constraint should be set. |
| int restricted_fps = video_source_.sink_wants().max_framerate_fps; |
| EXPECT_LT(restricted_fps, kInputFps); |
| video_source_.IncomingCapturedFrame( |
| CreateFrame(ntp_time, kFrameWidth, kFrameHeight)); |
| sink_.WaitForEncodedFrame(ntp_time); |
| ntp_time += 100; |
| |
| video_stream_encoder_->SetSourceAndWaitForRestrictionsUpdated( |
| &video_source_, webrtc::DegradationPreference::MAINTAIN_FRAMERATE); |
| // Give the encoder queue time to process the change in degradation preference |
| // by waiting for an encoded frame. |
| video_source_.IncomingCapturedFrame( |
| CreateFrame(ntp_time, kFrameWidth, kFrameHeight)); |
| sink_.WaitForEncodedFrame(ntp_time); |
| ntp_time += kFrameIntervalMs; |
| |
| video_stream_encoder_->TriggerQualityLow(); |
| video_source_.IncomingCapturedFrame( |
| CreateFrame(ntp_time, kFrameWidth, kFrameHeight)); |
| sink_.WaitForEncodedFrame(ntp_time); |
| ntp_time += kFrameIntervalMs; |
| |
| // Some resolution constraint should be set. |
| EXPECT_FALSE(video_source_.sink_wants().target_pixel_count); |
| EXPECT_LT(video_source_.sink_wants().max_pixel_count, |
| kFrameWidth * kFrameHeight); |
| EXPECT_EQ(video_source_.sink_wants().max_framerate_fps, kInputFps); |
| |
| int pixel_count = video_source_.sink_wants().max_pixel_count; |
| // Triggering a CPU underuse should not change the sink wants since it has |
| // not been overused for resolution since we changed degradation preference. |
| video_stream_encoder_->TriggerCpuUnderuse(); |
| video_source_.IncomingCapturedFrame( |
| CreateFrame(ntp_time, kFrameWidth, kFrameHeight)); |
| sink_.WaitForEncodedFrame(ntp_time); |
| ntp_time += kFrameIntervalMs; |
| EXPECT_EQ(video_source_.sink_wants().max_pixel_count, pixel_count); |
| EXPECT_EQ(video_source_.sink_wants().max_framerate_fps, kInputFps); |
| |
| // Change the degradation preference back. CPU underuse should not adapt since |
| // QP is most limited. |
| video_stream_encoder_->SetSourceAndWaitForRestrictionsUpdated( |
| &video_source_, webrtc::DegradationPreference::MAINTAIN_RESOLUTION); |
| video_source_.IncomingCapturedFrame( |
| CreateFrame(ntp_time, kFrameWidth, kFrameHeight)); |
| sink_.WaitForEncodedFrame(ntp_time); |
| ntp_time += 100; |
| // Resolution adaptations is gone after changing degradation preference. |
| EXPECT_FALSE(video_source_.sink_wants().target_pixel_count); |
| EXPECT_EQ(std::numeric_limits<int>::max(), |
| video_source_.sink_wants().max_pixel_count); |
| // The fps adaptation from above is now back. |
| EXPECT_EQ(video_source_.sink_wants().max_framerate_fps, restricted_fps); |
| |
| // Trigger CPU underuse. |
| video_stream_encoder_->TriggerCpuUnderuse(); |
| video_source_.IncomingCapturedFrame( |
| CreateFrame(ntp_time, kFrameWidth, kFrameHeight)); |
| sink_.WaitForEncodedFrame(ntp_time); |
| ntp_time += kFrameIntervalMs; |
| EXPECT_EQ(video_source_.sink_wants().max_framerate_fps, restricted_fps); |
| |
| // Trigger QP underuse, fps should return to normal. |
| video_stream_encoder_->TriggerQualityHigh(); |
| video_source_.IncomingCapturedFrame( |
| CreateFrame(ntp_time, kFrameWidth, kFrameHeight)); |
| sink_.WaitForEncodedFrame(ntp_time); |
| ntp_time += kFrameIntervalMs; |
| EXPECT_THAT(video_source_.sink_wants(), FpsMax()); |
| |
| video_stream_encoder_->Stop(); |
| } |
| |
| TEST_F(VideoStreamEncoderTest, SinkWantsStoredByDegradationPreference) { |
| video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources( |
| DataRate::BitsPerSec(kTargetBitrateBps), |
| DataRate::BitsPerSec(kTargetBitrateBps), |
| DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0); |
| EXPECT_THAT(video_source_.sink_wants(), UnlimitedSinkWants()); |
| |
| const int kFrameWidth = 1280; |
| const int kFrameHeight = 720; |
| |
| int64_t frame_timestamp = 1; |
| |
| video_source_.IncomingCapturedFrame( |
| CreateFrame(frame_timestamp, kFrameWidth, kFrameHeight)); |
| WaitForEncodedFrame(frame_timestamp); |
| frame_timestamp += kFrameIntervalMs; |
| |
| // Trigger CPU overuse. |
| video_stream_encoder_->TriggerCpuOveruse(); |
| video_source_.IncomingCapturedFrame( |
| CreateFrame(frame_timestamp, kFrameWidth, kFrameHeight)); |
| WaitForEncodedFrame(frame_timestamp); |
| frame_timestamp += kFrameIntervalMs; |
| |
| // Default degradation preference is maintain-framerate, so will lower max |
| // wanted resolution. |
| EXPECT_FALSE(video_source_.sink_wants().target_pixel_count); |
| EXPECT_LT(video_source_.sink_wants().max_pixel_count, |
| kFrameWidth * kFrameHeight); |
| EXPECT_EQ(kDefaultFramerate, video_source_.sink_wants().max_framerate_fps); |
| |
| // Set new source, switch to maintain-resolution. |
| test::FrameForwarder new_video_source; |
| video_stream_encoder_->SetSourceAndWaitForRestrictionsUpdated( |
| &new_video_source, webrtc::DegradationPreference::MAINTAIN_RESOLUTION); |
| // Give the encoder queue time to process the change in degradation preference |
| // by waiting for an encoded frame. |
| new_video_source.IncomingCapturedFrame( |
| CreateFrame(frame_timestamp, kFrameWidth, kFrameWidth)); |
| sink_.WaitForEncodedFrame(frame_timestamp); |
| frame_timestamp += kFrameIntervalMs; |
| // Initially no degradation registered. |
| EXPECT_THAT(new_video_source.sink_wants(), FpsMaxResolutionMax()); |
| |
| // Force an input frame rate to be available, or the adaptation call won't |
| // know what framerate to adapt form. |
| const int kInputFps = 30; |
| VideoSendStream::Stats stats = stats_proxy_->GetStats(); |
| stats.input_frame_rate = kInputFps; |
| stats_proxy_->SetMockStats(stats); |
| |
| video_stream_encoder_->TriggerCpuOveruse(); |
| new_video_source.IncomingCapturedFrame( |
| CreateFrame(frame_timestamp, kFrameWidth, kFrameHeight)); |
| WaitForEncodedFrame(frame_timestamp); |
| frame_timestamp += kFrameIntervalMs; |
| |
| // Some framerate constraint should be set. |
| EXPECT_FALSE(new_video_source.sink_wants().target_pixel_count); |
| EXPECT_EQ(std::numeric_limits<int>::max(), |
| new_video_source.sink_wants().max_pixel_count); |
| EXPECT_LT(new_video_source.sink_wants().max_framerate_fps, kInputFps); |
| |
| // Turn off degradation completely. |
| video_stream_encoder_->SetSourceAndWaitForRestrictionsUpdated( |
| &new_video_source, webrtc::DegradationPreference::DISABLED); |
| // Give the encoder queue time to process the change in degradation preference |
| // by waiting for an encoded frame. |
| new_video_source.IncomingCapturedFrame( |
| CreateFrame(frame_timestamp, kFrameWidth, kFrameWidth)); |
| sink_.WaitForEncodedFrame(frame_timestamp); |
| frame_timestamp += kFrameIntervalMs; |
| EXPECT_THAT(new_video_source.sink_wants(), FpsMaxResolutionMax()); |
| |
| video_stream_encoder_->TriggerCpuOveruse(); |
| new_video_source.IncomingCapturedFrame( |
| CreateFrame(frame_timestamp, kFrameWidth, kFrameHeight)); |
| WaitForEncodedFrame(frame_timestamp); |
| frame_timestamp += kFrameIntervalMs; |
| |
| // Still no degradation. |
| EXPECT_THAT(new_video_source.sink_wants(), FpsMaxResolutionMax()); |
| |
| // Calling SetSource with resolution scaling enabled apply the old SinkWants. |
| video_stream_encoder_->SetSourceAndWaitForRestrictionsUpdated( |
| &new_video_source, webrtc::DegradationPreference::MAINTAIN_FRAMERATE); |
| // Give the encoder queue time to process the change in degradation preference |
| // by waiting for an encoded frame. |
| new_video_source.IncomingCapturedFrame( |
| CreateFrame(frame_timestamp, kFrameWidth, kFrameWidth)); |
| sink_.WaitForEncodedFrame(frame_timestamp); |
| frame_timestamp += kFrameIntervalMs; |
| EXPECT_LT(new_video_source.sink_wants().max_pixel_count, |
| kFrameWidth * kFrameHeight); |
| EXPECT_FALSE(new_video_source.sink_wants().target_pixel_count); |
| EXPECT_EQ(kDefaultFramerate, new_video_source.sink_wants().max_framerate_fps); |
| |
| // Calling SetSource with framerate scaling enabled apply the old SinkWants. |
| video_stream_encoder_->SetSourceAndWaitForRestrictionsUpdated( |
| &new_video_source, webrtc::DegradationPreference::MAINTAIN_RESOLUTION); |
| // Give the encoder queue time to process the change in degradation preference |
| // by waiting for an encoded frame. |
| new_video_source.IncomingCapturedFrame( |
| CreateFrame(frame_timestamp, kFrameWidth, kFrameWidth)); |
| sink_.WaitForEncodedFrame(frame_timestamp); |
| frame_timestamp += kFrameIntervalMs; |
| EXPECT_FALSE(new_video_source.sink_wants().target_pixel_count); |
| EXPECT_EQ(std::numeric_limits<int>::max(), |
| new_video_source.sink_wants().max_pixel_count); |
| EXPECT_LT(new_video_source.sink_wants().max_framerate_fps, kInputFps); |
| |
| video_stream_encoder_->Stop(); |
| } |
| |
| TEST_F(VideoStreamEncoderTest, StatsTracksQualityAdaptationStats) { |
| video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources( |
| DataRate::BitsPerSec(kTargetBitrateBps), |
| DataRate::BitsPerSec(kTargetBitrateBps), |
| DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0); |
| |
| const int kWidth = 1280; |
| const int kHeight = 720; |
| video_source_.IncomingCapturedFrame(CreateFrame(1, kWidth, kHeight)); |
| WaitForEncodedFrame(1); |
| VideoSendStream::Stats stats = stats_proxy_->GetStats(); |
| EXPECT_FALSE(stats.bw_limited_resolution); |
| EXPECT_EQ(0, stats.number_of_quality_adapt_changes); |
| |
| // Trigger adapt down. |
| video_stream_encoder_->TriggerQualityLow(); |
| video_source_.IncomingCapturedFrame(CreateFrame(2, kWidth, kHeight)); |
| WaitForEncodedFrame(2); |
| |
| stats = stats_proxy_->GetStats(); |
| EXPECT_TRUE(stats.bw_limited_resolution); |
| EXPECT_EQ(1, stats.number_of_quality_adapt_changes); |
| |
| // Trigger adapt up. |
| video_stream_encoder_->TriggerQualityHigh(); |
| video_source_.IncomingCapturedFrame(CreateFrame(
|