diff options
Diffstat (limited to 'video')
| -rw-r--r-- | video/adaptation/BUILD.gn | 3 | ||||
| -rw-r--r-- | video/adaptation/encode_usage_resource.cc | 16 | ||||
| -rw-r--r-- | video/adaptation/encode_usage_resource.h | 10 | ||||
| -rw-r--r-- | video/adaptation/quality_scaler_resource.cc | 21 | ||||
| -rw-r--r-- | video/adaptation/quality_scaler_resource.h | 16 | ||||
| -rw-r--r-- | video/adaptation/quality_scaler_resource_unittest.cc | 7 | ||||
| -rw-r--r-- | video/adaptation/video_stream_encoder_resource.cc | 112 | ||||
| -rw-r--r-- | video/adaptation/video_stream_encoder_resource.h | 86 | ||||
| -rw-r--r-- | video/adaptation/video_stream_encoder_resource_manager.cc | 52 | ||||
| -rw-r--r-- | video/adaptation/video_stream_encoder_resource_manager.h | 16 | ||||
| -rw-r--r-- | video/video_stream_encoder.cc | 2 | ||||
| -rw-r--r-- | video/video_stream_encoder_unittest.cc | 12 |
12 files changed, 291 insertions, 62 deletions
diff --git a/video/adaptation/BUILD.gn b/video/adaptation/BUILD.gn index 51e6a2d84e..e27e5b5297 100644 --- a/video/adaptation/BUILD.gn +++ b/video/adaptation/BUILD.gn @@ -16,6 +16,8 @@ rtc_library("video_adaptation") { "overuse_frame_detector.h", "quality_scaler_resource.cc", "quality_scaler_resource.h", + "video_stream_encoder_resource.cc", + "video_stream_encoder_resource.h", "video_stream_encoder_resource_manager.cc", "video_stream_encoder_resource_manager.h", ] @@ -44,6 +46,7 @@ rtc_library("video_adaptation") { "../../rtc_base/experiments:quality_scaler_settings", "../../rtc_base/synchronization:sequence_checker", "../../rtc_base/task_utils:repeating_task", + "../../rtc_base/task_utils:to_queued_task", "../../system_wrappers:field_trial", "../../system_wrappers:system_wrappers", "//third_party/abseil-cpp/absl/algorithm:container", diff --git a/video/adaptation/encode_usage_resource.cc b/video/adaptation/encode_usage_resource.cc index 49531a3aa4..d6f2334fa1 100644 --- a/video/adaptation/encode_usage_resource.cc +++ b/video/adaptation/encode_usage_resource.cc @@ -15,18 +15,28 @@ #include "api/video/video_adaptation_reason.h" #include "rtc_base/checks.h" +#include "rtc_base/ref_counted_object.h" namespace webrtc { +// static +rtc::scoped_refptr<EncodeUsageResource> EncodeUsageResource::Create( + std::unique_ptr<OveruseFrameDetector> overuse_detector) { + return new rtc::RefCountedObject<EncodeUsageResource>( + std::move(overuse_detector)); +} + EncodeUsageResource::EncodeUsageResource( std::unique_ptr<OveruseFrameDetector> overuse_detector) - : rtc::RefCountedObject<Resource>(), + : VideoStreamEncoderResource("EncoderUsageResource"), overuse_detector_(std::move(overuse_detector)), is_started_(false), target_frame_rate_(absl::nullopt) { RTC_DCHECK(overuse_detector_); } +EncodeUsageResource::~EncodeUsageResource() {} + bool EncodeUsageResource::is_started() const { RTC_DCHECK_RUN_ON(encoder_queue()); return is_started_; @@ -81,7 +91,7 @@ void EncodeUsageResource::AdaptUp() { RTC_DCHECK_RUN_ON(encoder_queue()); // Reference counting guarantees that this object is still alive by the time // the task is executed. - resource_adaptation_queue()->PostTask( + MaybePostTaskToResourceAdaptationQueue( [this_ref = rtc::scoped_refptr<EncodeUsageResource>(this)] { RTC_DCHECK_RUN_ON(this_ref->resource_adaptation_queue()); this_ref->OnResourceUsageStateMeasured(ResourceUsageState::kUnderuse); @@ -92,7 +102,7 @@ void EncodeUsageResource::AdaptDown() { RTC_DCHECK_RUN_ON(encoder_queue()); // Reference counting guarantees that this object is still alive by the time // the task is executed. - resource_adaptation_queue()->PostTask( + MaybePostTaskToResourceAdaptationQueue( [this_ref = rtc::scoped_refptr<EncodeUsageResource>(this)] { RTC_DCHECK_RUN_ON(this_ref->resource_adaptation_queue()); this_ref->OnResourceUsageStateMeasured(ResourceUsageState::kOveruse); diff --git a/video/adaptation/encode_usage_resource.h b/video/adaptation/encode_usage_resource.h index 3c6f02b243..6fcd0ebd97 100644 --- a/video/adaptation/encode_usage_resource.h +++ b/video/adaptation/encode_usage_resource.h @@ -15,11 +15,13 @@ #include <string> #include "absl/types/optional.h" +#include "api/scoped_refptr.h" #include "api/video/video_adaptation_reason.h" #include "call/adaptation/resource.h" #include "rtc_base/ref_counted_object.h" #include "rtc_base/task_queue.h" #include "video/adaptation/overuse_frame_detector.h" +#include "video/adaptation/video_stream_encoder_resource.h" namespace webrtc { @@ -28,11 +30,15 @@ namespace webrtc { // indirectly by usage in the ResourceAdaptationProcessor (which is only tested // because of its usage in VideoStreamEncoder); all tests are currently in // video_stream_encoder_unittest.cc. -class EncodeUsageResource : public rtc::RefCountedObject<Resource>, +class EncodeUsageResource : public VideoStreamEncoderResource, public OveruseFrameDetectorObserverInterface { public: + static rtc::scoped_refptr<EncodeUsageResource> Create( + std::unique_ptr<OveruseFrameDetector> overuse_detector); + explicit EncodeUsageResource( std::unique_ptr<OveruseFrameDetector> overuse_detector); + ~EncodeUsageResource() override; bool is_started() const; @@ -51,8 +57,6 @@ class EncodeUsageResource : public rtc::RefCountedObject<Resource>, void AdaptUp() override; void AdaptDown() override; - std::string name() const override { return "EncoderUsageResource"; } - private: int TargetFrameRateAsInt(); diff --git a/video/adaptation/quality_scaler_resource.cc b/video/adaptation/quality_scaler_resource.cc index c88bfa208f..514a2d765f 100644 --- a/video/adaptation/quality_scaler_resource.cc +++ b/video/adaptation/quality_scaler_resource.cc @@ -13,6 +13,8 @@ #include <utility> #include "rtc_base/experiments/balanced_degradation_settings.h" +#include "rtc_base/ref_counted_object.h" +#include "rtc_base/task_utils/to_queued_task.h" #include "rtc_base/time_utils.h" namespace webrtc { @@ -23,8 +25,13 @@ const int64_t kUnderuseDueToDisabledCooldownMs = 1000; } // namespace +// static +rtc::scoped_refptr<QualityScalerResource> QualityScalerResource::Create() { + return new rtc::RefCountedObject<QualityScalerResource>(); +} + QualityScalerResource::QualityScalerResource() - : rtc::RefCountedObject<Resource>(), + : VideoStreamEncoderResource("QualityScalerResource"), quality_scaler_(nullptr), last_underuse_due_to_disabled_timestamp_ms_(absl::nullopt), num_handled_callbacks_(0), @@ -95,7 +102,7 @@ void QualityScalerResource::OnEncodeCompleted(const EncodedImage& encoded_image, timestamp_ms - last_underuse_due_to_disabled_timestamp_ms_.value() >= kUnderuseDueToDisabledCooldownMs) { last_underuse_due_to_disabled_timestamp_ms_ = timestamp_ms; - resource_adaptation_queue()->PostTask( + MaybePostTaskToResourceAdaptationQueue( [this_ref = rtc::scoped_refptr<QualityScalerResource>(this)] { RTC_DCHECK_RUN_ON(this_ref->resource_adaptation_queue()); this_ref->OnResourceUsageStateMeasured( @@ -126,7 +133,7 @@ void QualityScalerResource::OnReportQpUsageHigh( size_t callback_id = QueuePendingCallback(callback); // Reference counting guarantees that this object is still alive by the time // the task is executed. - resource_adaptation_queue()->PostTask( + MaybePostTaskToResourceAdaptationQueue( [this_ref = rtc::scoped_refptr<QualityScalerResource>(this), callback_id] { RTC_DCHECK_RUN_ON(this_ref->resource_adaptation_queue()); @@ -146,7 +153,7 @@ void QualityScalerResource::OnReportQpUsageLow( size_t callback_id = QueuePendingCallback(callback); // Reference counting guarantees that this object is still alive by the time // the task is executed. - resource_adaptation_queue()->PostTask( + MaybePostTaskToResourceAdaptationQueue( [this_ref = rtc::scoped_refptr<QualityScalerResource>(this), callback_id] { RTC_DCHECK_RUN_ON(this_ref->resource_adaptation_queue()); @@ -206,8 +213,8 @@ void QualityScalerResource::HandlePendingCallback(size_t callback_id, // Reference counting guarantees that this object is still alive by the time // the task is executed. encoder_queue()->PostTask( - [this_ref = rtc::scoped_refptr<QualityScalerResource>(this), callback_id, - clear_qp_samples] { + ToQueuedTask([this_ref = rtc::scoped_refptr<QualityScalerResource>(this), + callback_id, clear_qp_samples] { RTC_DCHECK_RUN_ON(this_ref->encoder_queue()); if (this_ref->num_handled_callbacks_ >= callback_id) { // The callback with this ID has already been handled. @@ -220,7 +227,7 @@ void QualityScalerResource::HandlePendingCallback(size_t callback_id, clear_qp_samples); ++this_ref->num_handled_callbacks_; this_ref->pending_callbacks_.pop(); - }); + })); } void QualityScalerResource::AbortPendingCallbacks() { diff --git a/video/adaptation/quality_scaler_resource.h b/video/adaptation/quality_scaler_resource.h index 2632f2e124..43e99e7ed1 100644 --- a/video/adaptation/quality_scaler_resource.h +++ b/video/adaptation/quality_scaler_resource.h @@ -16,6 +16,7 @@ #include <string> #include "absl/types/optional.h" +#include "api/scoped_refptr.h" #include "api/video/video_adaptation_reason.h" #include "api/video_codecs/video_encoder.h" #include "call/adaptation/resource.h" @@ -24,13 +25,16 @@ #include "rtc_base/critical_section.h" #include "rtc_base/ref_counted_object.h" #include "rtc_base/task_queue.h" +#include "video/adaptation/video_stream_encoder_resource.h" namespace webrtc { // Handles interaction with the QualityScaler. -class QualityScalerResource : public rtc::RefCountedObject<Resource>, +class QualityScalerResource : public VideoStreamEncoderResource, public QualityScalerQpUsageHandlerInterface { public: + static rtc::scoped_refptr<QualityScalerResource> Create(); + QualityScalerResource(); ~QualityScalerResource() override; @@ -56,9 +60,7 @@ class QualityScalerResource : public rtc::RefCountedObject<Resource>, rtc::scoped_refptr<QualityScalerQpUsageHandlerCallbackInterface> callback) override; - std::string name() const override { return "QualityScalerResource"; } - - // Resource implementation. + // VideoStreamEncoderResource implementation. void OnAdaptationApplied( const VideoStreamInputState& input_state, const VideoSourceRestrictions& restrictions_before, @@ -81,9 +83,9 @@ class QualityScalerResource : public rtc::RefCountedObject<Resource>, absl::optional<int64_t> last_underuse_due_to_disabled_timestamp_ms_ RTC_GUARDED_BY(encoder_queue()); // Every OnReportQpUsageHigh/Low() operation has a callback that MUST be - // invoked on the |encoder_queue_|. Because usage measurements are reported on - // the |encoder_queue_| but handled by the processor on the the - // |resource_adaptation_queue_|, handling a measurement entails a task queue + // invoked on the encoder_queue(). Because usage measurements are reported on + // the encoder_queue() but handled by the processor on the the + // resource_adaptation_queue_(), handling a measurement entails a task queue // "ping" round-trip. Multiple callbacks in-flight is thus possible. size_t num_handled_callbacks_ RTC_GUARDED_BY(encoder_queue()); std::queue<rtc::scoped_refptr<QualityScalerQpUsageHandlerCallbackInterface>> diff --git a/video/adaptation/quality_scaler_resource_unittest.cc b/video/adaptation/quality_scaler_resource_unittest.cc index 66f4e13870..e2098d71b7 100644 --- a/video/adaptation/quality_scaler_resource_unittest.cc +++ b/video/adaptation/quality_scaler_resource_unittest.cc @@ -74,9 +74,10 @@ class QualityScalerResourceTest : public ::testing::Test { encoder_queue_(task_queue_factory_->CreateTaskQueue( "EncoderQueue", TaskQueueFactory::Priority::NORMAL)), - quality_scaler_resource_(new QualityScalerResource()) { - quality_scaler_resource_->Initialize(&encoder_queue_, - &resource_adaptation_queue_); + quality_scaler_resource_(QualityScalerResource::Create()) { + quality_scaler_resource_->RegisterEncoderTaskQueue(encoder_queue_.Get()); + quality_scaler_resource_->RegisterAdaptationTaskQueue( + resource_adaptation_queue_.Get()); rtc::Event event; encoder_queue_.PostTask([this, &event] { quality_scaler_resource_->StartCheckForOveruse( diff --git a/video/adaptation/video_stream_encoder_resource.cc b/video/adaptation/video_stream_encoder_resource.cc new file mode 100644 index 0000000000..db5a15534c --- /dev/null +++ b/video/adaptation/video_stream_encoder_resource.cc @@ -0,0 +1,112 @@ +/* + * Copyright 2020 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/adaptation/video_stream_encoder_resource.h" + +#include <algorithm> +#include <utility> + +namespace webrtc { + +VideoStreamEncoderResource::VideoStreamEncoderResource(std::string name) + : lock_(), + name_(std::move(name)), + encoder_queue_(nullptr), + resource_adaptation_queue_(nullptr), + usage_state_(absl::nullopt), + listener_(nullptr) {} + +VideoStreamEncoderResource::~VideoStreamEncoderResource() { + RTC_DCHECK(!listener_) + << "There is a listener depending on a VideoStreamEncoderResource being " + << "destroyed."; +} + +void VideoStreamEncoderResource::RegisterEncoderTaskQueue( + TaskQueueBase* encoder_queue) { + RTC_DCHECK(!encoder_queue_); + RTC_DCHECK(encoder_queue); + encoder_queue_ = encoder_queue; +} + +void VideoStreamEncoderResource::RegisterAdaptationTaskQueue( + TaskQueueBase* resource_adaptation_queue) { + rtc::CritScope crit(&lock_); + RTC_DCHECK(!resource_adaptation_queue_); + RTC_DCHECK(resource_adaptation_queue); + resource_adaptation_queue_ = resource_adaptation_queue; +} + +void VideoStreamEncoderResource::UnregisterAdaptationTaskQueue() { + rtc::CritScope crit(&lock_); + RTC_DCHECK(resource_adaptation_queue_); + RTC_DCHECK_RUN_ON(resource_adaptation_queue_); + resource_adaptation_queue_ = nullptr; +} + +void VideoStreamEncoderResource::SetResourceListener( + ResourceListener* listener) { + RTC_DCHECK_RUN_ON(resource_adaptation_queue()); + // If you want to change listener you need to unregister the old listener by + // setting it to null first. + RTC_DCHECK(!listener_ || !listener) << "A listener is already set"; + listener_ = listener; +} + +std::string VideoStreamEncoderResource::Name() const { + return name_; +} + +absl::optional<ResourceUsageState> VideoStreamEncoderResource::UsageState() + const { + RTC_DCHECK_RUN_ON(resource_adaptation_queue()); + return usage_state_; +} + +void VideoStreamEncoderResource::ClearUsageState() { + RTC_DCHECK_RUN_ON(resource_adaptation_queue()); + usage_state_ = absl::nullopt; +} + +bool VideoStreamEncoderResource::IsAdaptationUpAllowed( + const VideoStreamInputState& input_state, + const VideoSourceRestrictions& restrictions_before, + const VideoSourceRestrictions& restrictions_after, + rtc::scoped_refptr<Resource> reason_resource) const { + return true; +} + +void VideoStreamEncoderResource::OnAdaptationApplied( + const VideoStreamInputState& input_state, + const VideoSourceRestrictions& restrictions_before, + const VideoSourceRestrictions& restrictions_after, + rtc::scoped_refptr<Resource> reason_resource) {} + +void VideoStreamEncoderResource::OnResourceUsageStateMeasured( + ResourceUsageState usage_state) { + RTC_DCHECK_RUN_ON(resource_adaptation_queue()); + usage_state_ = usage_state; + if (listener_) { + listener_->OnResourceUsageStateMeasured(this); + } +} + +TaskQueueBase* VideoStreamEncoderResource::encoder_queue() const { + return encoder_queue_; +} + +TaskQueueBase* VideoStreamEncoderResource::resource_adaptation_queue() const { + rtc::CritScope crit(&lock_); + RTC_DCHECK(resource_adaptation_queue_); + RTC_DCHECK_RUN_ON(resource_adaptation_queue_); + return resource_adaptation_queue_; +} + +} // namespace webrtc diff --git a/video/adaptation/video_stream_encoder_resource.h b/video/adaptation/video_stream_encoder_resource.h new file mode 100644 index 0000000000..fe66040512 --- /dev/null +++ b/video/adaptation/video_stream_encoder_resource.h @@ -0,0 +1,86 @@ +/* + * Copyright 2020 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. + */ + +#ifndef VIDEO_ADAPTATION_VIDEO_STREAM_ENCODER_RESOURCE_H_ +#define VIDEO_ADAPTATION_VIDEO_STREAM_ENCODER_RESOURCE_H_ + +#include <string> +#include <vector> + +#include "absl/types/optional.h" +#include "api/task_queue/task_queue_base.h" +#include "call/adaptation/resource.h" +#include "rtc_base/critical_section.h" +#include "rtc_base/synchronization/sequence_checker.h" + +namespace webrtc { + +class VideoStreamEncoderResource : public Resource { + public: + ~VideoStreamEncoderResource() override; + + // Registering task queues must be performed as part of initialization. + void RegisterEncoderTaskQueue(TaskQueueBase* encoder_queue); + + // Resource implementation. + void RegisterAdaptationTaskQueue( + TaskQueueBase* resource_adaptation_queue) override; + void UnregisterAdaptationTaskQueue() override; + void SetResourceListener(ResourceListener* listener) override; + std::string Name() const override; + absl::optional<ResourceUsageState> UsageState() const override; + void ClearUsageState() override; + // Default implementations, may be overriden again by child classes. + bool IsAdaptationUpAllowed( + const VideoStreamInputState& input_state, + const VideoSourceRestrictions& restrictions_before, + const VideoSourceRestrictions& restrictions_after, + rtc::scoped_refptr<Resource> reason_resource) const override; + void OnAdaptationApplied( + const VideoStreamInputState& input_state, + const VideoSourceRestrictions& restrictions_before, + const VideoSourceRestrictions& restrictions_after, + rtc::scoped_refptr<Resource> reason_resource) override; + + protected: + explicit VideoStreamEncoderResource(std::string name); + + void OnResourceUsageStateMeasured(ResourceUsageState usage_state); + + // The caller is responsible for ensuring the task queue is still valid. + TaskQueueBase* encoder_queue() const; + // Validity of returned pointer is ensured by only allowing this method to be + // called on the adaptation task queue. Designed for use with RTC_GUARDED_BY. + // For posting from a different queue, use + // MaybePostTaskToResourceAdaptationQueue() instead, which only posts if the + // task queue is currently registered. + TaskQueueBase* resource_adaptation_queue() const; + template <typename Closure> + void MaybePostTaskToResourceAdaptationQueue(Closure&& closure) { + rtc::CritScope crit(&lock_); + if (!resource_adaptation_queue_) + return; + resource_adaptation_queue_->PostTask(ToQueuedTask(closure)); + } + + private: + rtc::CriticalSection lock_; + const std::string name_; + // Treated as const after initialization. + TaskQueueBase* encoder_queue_; + TaskQueueBase* resource_adaptation_queue_ RTC_GUARDED_BY(lock_); + absl::optional<ResourceUsageState> usage_state_ + RTC_GUARDED_BY(resource_adaptation_queue()); + ResourceListener* listener_ RTC_GUARDED_BY(resource_adaptation_queue()); +}; + +} // namespace webrtc + +#endif // VIDEO_ADAPTATION_VIDEO_STREAM_ENCODER_RESOURCE_H_ diff --git a/video/adaptation/video_stream_encoder_resource_manager.cc b/video/adaptation/video_stream_encoder_resource_manager.cc index b309dd3455..c88c6333e2 100644 --- a/video/adaptation/video_stream_encoder_resource_manager.cc +++ b/video/adaptation/video_stream_encoder_resource_manager.cc @@ -26,6 +26,7 @@ #include "call/adaptation/video_source_restrictions.h" #include "rtc_base/logging.h" #include "rtc_base/numerics/safe_conversions.h" +#include "rtc_base/ref_counted_object.h" #include "rtc_base/strings/string_builder.h" #include "rtc_base/time_utils.h" @@ -140,7 +141,8 @@ class VideoStreamEncoderResourceManager::InitialFrameDropper { VideoStreamEncoderResourceManager::PreventAdaptUpDueToActiveCounts:: PreventAdaptUpDueToActiveCounts(VideoStreamEncoderResourceManager* manager) - : rtc::RefCountedObject<Resource>(), + : rtc::RefCountedObject<VideoStreamEncoderResource>( + "PreventAdaptUpDueToActiveCounts"), manager_(manager), adaptation_processor_(nullptr) {} @@ -187,7 +189,8 @@ VideoStreamEncoderResourceManager:: PreventIncreaseResolutionDueToBitrateResource:: PreventIncreaseResolutionDueToBitrateResource( VideoStreamEncoderResourceManager* manager) - : rtc::RefCountedObject<Resource>(), + : rtc::RefCountedObject<VideoStreamEncoderResource>( + "PreventIncreaseResolutionDueToBitrateResource"), manager_(manager), encoder_settings_(absl::nullopt), encoder_target_bitrate_bps_(absl::nullopt) {} @@ -196,7 +199,7 @@ void VideoStreamEncoderResourceManager:: PreventIncreaseResolutionDueToBitrateResource::OnEncoderSettingsUpdated( absl::optional<EncoderSettings> encoder_settings) { RTC_DCHECK_RUN_ON(encoder_queue()); - resource_adaptation_queue()->PostTask( + MaybePostTaskToResourceAdaptationQueue( [this_ref = rtc::scoped_refptr<PreventIncreaseResolutionDueToBitrateResource>( this), @@ -211,7 +214,7 @@ void VideoStreamEncoderResourceManager:: OnEncoderTargetBitrateUpdated( absl::optional<uint32_t> encoder_target_bitrate_bps) { RTC_DCHECK_RUN_ON(encoder_queue()); - resource_adaptation_queue()->PostTask( + MaybePostTaskToResourceAdaptationQueue( [this_ref = rtc::scoped_refptr<PreventIncreaseResolutionDueToBitrateResource>( this), @@ -258,7 +261,8 @@ bool VideoStreamEncoderResourceManager:: VideoStreamEncoderResourceManager::PreventAdaptUpInBalancedResource:: PreventAdaptUpInBalancedResource(VideoStreamEncoderResourceManager* manager) - : rtc::RefCountedObject<Resource>(), + : rtc::RefCountedObject<VideoStreamEncoderResource>( + "PreventAdaptUpInBalancedResource"), manager_(manager), adaptation_processor_(nullptr), encoder_target_bitrate_bps_(absl::nullopt) {} @@ -274,7 +278,7 @@ void VideoStreamEncoderResourceManager::PreventAdaptUpInBalancedResource:: OnEncoderTargetBitrateUpdated( absl::optional<uint32_t> encoder_target_bitrate_bps) { RTC_DCHECK_RUN_ON(encoder_queue()); - resource_adaptation_queue()->PostTask( + MaybePostTaskToResourceAdaptationQueue( [this_ref = rtc::scoped_refptr<PreventAdaptUpInBalancedResource>(this), encoder_target_bitrate_bps] { RTC_DCHECK_RUN_ON(this_ref->resource_adaptation_queue()); @@ -328,8 +332,8 @@ VideoStreamEncoderResourceManager::VideoStreamEncoderResourceManager( prevent_adapt_up_in_balanced_resource_( new PreventAdaptUpInBalancedResource(this)), encode_usage_resource_( - new EncodeUsageResource(std::move(overuse_detector))), - quality_scaler_resource_(new QualityScalerResource()), + EncodeUsageResource::Create(std::move(overuse_detector))), + quality_scaler_resource_(QualityScalerResource::Create()), encoder_queue_(nullptr), resource_adaptation_queue_(nullptr), input_state_provider_(input_state_provider), @@ -370,16 +374,24 @@ void VideoStreamEncoderResourceManager::Initialize( RTC_DCHECK(resource_adaptation_queue); encoder_queue_ = encoder_queue; resource_adaptation_queue_ = resource_adaptation_queue; - prevent_adapt_up_due_to_active_counts_->Initialize( - encoder_queue_, resource_adaptation_queue_); - prevent_increase_resolution_due_to_bitrate_resource_->Initialize( - encoder_queue_, resource_adaptation_queue_); - prevent_adapt_up_in_balanced_resource_->Initialize( - encoder_queue_, resource_adaptation_queue_); - encode_usage_resource_->Initialize(encoder_queue_, - resource_adaptation_queue_); - quality_scaler_resource_->Initialize(encoder_queue_, - resource_adaptation_queue_); + prevent_adapt_up_due_to_active_counts_->RegisterEncoderTaskQueue( + encoder_queue_->Get()); + prevent_adapt_up_due_to_active_counts_->RegisterAdaptationTaskQueue( + resource_adaptation_queue_->Get()); + prevent_increase_resolution_due_to_bitrate_resource_ + ->RegisterEncoderTaskQueue(encoder_queue_->Get()); + prevent_increase_resolution_due_to_bitrate_resource_ + ->RegisterAdaptationTaskQueue(resource_adaptation_queue_->Get()); + prevent_adapt_up_in_balanced_resource_->RegisterEncoderTaskQueue( + encoder_queue_->Get()); + prevent_adapt_up_in_balanced_resource_->RegisterAdaptationTaskQueue( + resource_adaptation_queue_->Get()); + encode_usage_resource_->RegisterEncoderTaskQueue(encoder_queue_->Get()); + encode_usage_resource_->RegisterAdaptationTaskQueue( + resource_adaptation_queue_->Get()); + quality_scaler_resource_->RegisterEncoderTaskQueue(encoder_queue_->Get()); + quality_scaler_resource_->RegisterAdaptationTaskQueue( + resource_adaptation_queue_->Get()); } void VideoStreamEncoderResourceManager::SetAdaptationProcessor( @@ -428,7 +440,7 @@ void VideoStreamEncoderResourceManager::MapResourceToReason( [resource](const ResourceAndReason& r) { return r.resource == resource; }) == resources_.end()) - << "Resource " << resource->name() << " already was inserted"; + << "Resource " << resource->Name() << " already was inserted"; resources_.emplace_back(resource, reason); } @@ -616,7 +628,7 @@ VideoAdaptationReason VideoStreamEncoderResourceManager::GetReasonFromResource( return r.resource == resource; }); RTC_DCHECK(registered_resource != resources_.end()) - << resource->name() << " not found."; + << resource->Name() << " not found."; return registered_resource->reason; } diff --git a/video/adaptation/video_stream_encoder_resource_manager.h b/video/adaptation/video_stream_encoder_resource_manager.h index d028e5049a..4563b74212 100644 --- a/video/adaptation/video_stream_encoder_resource_manager.h +++ b/video/adaptation/video_stream_encoder_resource_manager.h @@ -43,6 +43,7 @@ #include "video/adaptation/encode_usage_resource.h" #include "video/adaptation/overuse_frame_detector.h" #include "video/adaptation/quality_scaler_resource.h" +#include "video/adaptation/video_stream_encoder_resource.h" namespace webrtc { @@ -178,7 +179,7 @@ class VideoStreamEncoderResourceManager // Does not trigger adaptations, only prevents adapting up based on // |active_counts_|. class PreventAdaptUpDueToActiveCounts final - : public rtc::RefCountedObject<Resource> { + : public rtc::RefCountedObject<VideoStreamEncoderResource> { public: explicit PreventAdaptUpDueToActiveCounts( VideoStreamEncoderResourceManager* manager); @@ -188,9 +189,6 @@ class VideoStreamEncoderResourceManager ResourceAdaptationProcessorInterface* adaptation_processor); // Resource overrides. - std::string name() const override { - return "PreventAdaptUpDueToActiveCounts"; - } bool IsAdaptationUpAllowed( const VideoStreamInputState& input_state, const VideoSourceRestrictions& restrictions_before, @@ -207,7 +205,7 @@ class VideoStreamEncoderResourceManager // Does not trigger adaptations, only prevents adapting up resolution. class PreventIncreaseResolutionDueToBitrateResource final - : public rtc::RefCountedObject<Resource> { + : public rtc::RefCountedObject<VideoStreamEncoderResource> { public: explicit PreventIncreaseResolutionDueToBitrateResource( VideoStreamEncoderResourceManager* manager); @@ -219,9 +217,6 @@ class VideoStreamEncoderResourceManager absl::optional<uint32_t> encoder_target_bitrate_bps); // Resource overrides. - std::string name() const override { - return "PreventIncreaseResolutionDueToBitrateResource"; - } bool IsAdaptationUpAllowed( const VideoStreamInputState& input_state, const VideoSourceRestrictions& restrictions_before, @@ -240,7 +235,7 @@ class VideoStreamEncoderResourceManager // Does not trigger adaptations, only prevents adapting up in BALANCED. class PreventAdaptUpInBalancedResource final - : public rtc::RefCountedObject<Resource> { + : public rtc::RefCountedObject<VideoStreamEncoderResource> { public: explicit PreventAdaptUpInBalancedResource( VideoStreamEncoderResourceManager* manager); @@ -252,9 +247,6 @@ class VideoStreamEncoderResourceManager absl::optional<uint32_t> encoder_target_bitrate_bps); // Resource overrides. - std::string name() const override { - return "PreventAdaptUpInBalancedResource"; - } bool IsAdaptationUpAllowed( const VideoStreamInputState& input_state, const VideoSourceRestrictions& restrictions_before, diff --git a/video/video_stream_encoder.cc b/video/video_stream_encoder.cc index 6d148cd62a..95c6055970 100644 --- a/video/video_stream_encoder.cc +++ b/video/video_stream_encoder.cc @@ -1698,7 +1698,7 @@ void VideoStreamEncoder::OnVideoSourceRestrictionsUpdated( const VideoAdaptationCounters& adaptation_counters, rtc::scoped_refptr<Resource> reason) { RTC_DCHECK_RUN_ON(&resource_adaptation_queue_); - std::string resource_name = reason ? reason->name() : "<null>"; + std::string resource_name = reason ? reason->Name() : "<null>"; RTC_LOG(INFO) << "Updating sink restrictions from " << resource_name << " to " << restrictions.ToString(); video_source_sink_controller_.SetRestrictions(std::move(restrictions)); diff --git a/video/video_stream_encoder_unittest.cc b/video/video_stream_encoder_unittest.cc index 277c00b701..69a966bff7 100644 --- a/video/video_stream_encoder_unittest.cc +++ b/video/video_stream_encoder_unittest.cc @@ -316,12 +316,12 @@ class VideoStreamEncoderUnderTest : public VideoStreamEncoder { overuse_detector_proxy_ = new CpuOveruseDetectorProxy(stats_proxy)), task_queue_factory), - fake_cpu_resource_(new FakeResource("FakeResource[CPU]")), - fake_quality_resource_(new FakeResource("FakeResource[QP]")) { - fake_cpu_resource_->Initialize(encoder_queue(), - resource_adaptation_queue()); - fake_quality_resource_->Initialize(encoder_queue(), - resource_adaptation_queue()); + fake_cpu_resource_(FakeResource::Create("FakeResource[CPU]")), + fake_quality_resource_(FakeResource::Create("FakeResource[QP]")) { + fake_cpu_resource_->RegisterAdaptationTaskQueue( + resource_adaptation_queue()->Get()); + fake_quality_resource_->RegisterAdaptationTaskQueue( + resource_adaptation_queue()->Get()); InjectAdaptationResource(fake_quality_resource_, VideoAdaptationReason::kQuality); InjectAdaptationResource(fake_cpu_resource_, VideoAdaptationReason::kCpu); |