[Adaptation] Rename the processor "VideoStreamEncoderResourceManager". This CL is part of the Call-Level Adaptation Processing design doc: https://docs.google.com/document/d/1ZyC26yOCknrrcYa839ZWLxD6o6Gig5A3lVTh4E41074/edit?usp=sharing This CL is a pure rename CL. The next CL split this class up into a "Manager" part and a "Processor" part. By doing the renaming separately, reviewing of the next CL should be easier. Bug: webrtc:11172 Change-Id: I2d5bac049b4bb88d4f947f8c4dc61e2131164a59 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/173020 Commit-Queue: Henrik Boström <hbos@webrtc.org> Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org> Reviewed-by: Evan Shrubsole <eshr@google.com> Cr-Commit-Position: refs/heads/master@{#31104}
diff --git a/video/adaptation/BUILD.gn b/video/adaptation/BUILD.gn index e9fbbdb..1224586 100644 --- a/video/adaptation/BUILD.gn +++ b/video/adaptation/BUILD.gn
@@ -16,8 +16,8 @@ "overuse_frame_detector.h", "quality_scaler_resource.cc", "quality_scaler_resource.h", - "resource_adaptation_processor.cc", - "resource_adaptation_processor.h", + "video_stream_encoder_resource_manager.cc", + "video_stream_encoder_resource_manager.h", ] deps = [ @@ -57,7 +57,7 @@ defines = [] sources = [ "overuse_frame_detector_unittest.cc", - "resource_adaptation_processor_unittest.cc", + "video_stream_encoder_resource_manager_unittest.cc", ] deps = [ ":video_adaptation",
diff --git a/video/adaptation/resource_adaptation_processor.cc b/video/adaptation/video_stream_encoder_resource_manager.cc similarity index 87% rename from video/adaptation/resource_adaptation_processor.cc rename to video/adaptation/video_stream_encoder_resource_manager.cc index 0e329af..f219d37 100644 --- a/video/adaptation/resource_adaptation_processor.cc +++ b/video/adaptation/video_stream_encoder_resource_manager.cc
@@ -8,7 +8,7 @@ * be found in the AUTHORS file in the root of the source tree. */ -#include "video/adaptation/resource_adaptation_processor.h" +#include "video/adaptation/video_stream_encoder_resource_manager.h" #include <algorithm> #include <cmath> @@ -66,7 +66,7 @@ } // namespace -class ResourceAdaptationProcessor::InitialFrameDropper { +class VideoStreamEncoderResourceManager::InitialFrameDropper { public: explicit InitialFrameDropper(QualityScalerResource* quality_scaler_resource) : quality_scaler_resource_(quality_scaler_resource), @@ -137,17 +137,17 @@ int initial_framedrop_; }; -ResourceAdaptationProcessor::PreventAdaptUpDueToActiveCounts:: - PreventAdaptUpDueToActiveCounts(ResourceAdaptationProcessor* processor) - : processor_(processor) {} +VideoStreamEncoderResourceManager::PreventAdaptUpDueToActiveCounts:: + PreventAdaptUpDueToActiveCounts(VideoStreamEncoderResourceManager* manager) + : manager_(manager) {} -bool ResourceAdaptationProcessor::PreventAdaptUpDueToActiveCounts:: +bool VideoStreamEncoderResourceManager::PreventAdaptUpDueToActiveCounts:: IsAdaptationUpAllowed(const VideoStreamInputState& input_state, const VideoSourceRestrictions& restrictions_before, const VideoSourceRestrictions& restrictions_after, const Resource& reason_resource) const { VideoAdaptationReason reason = - processor_->GetReasonFromResource(reason_resource); + manager_->GetReasonFromResource(reason_resource); // We can't adapt up if we're already at the highest setting. // Note that this only includes counts relevant to the current degradation // preference. e.g. we previously adapted resolution, now prefer adpating fps, @@ -156,36 +156,37 @@ // want us to go up it should prevent us from doing so itself rather than to // have this catch-all reason- and stats-based approach. int num_downgrades = FilterVideoAdaptationCountersByDegradationPreference( - processor_->active_counts_[reason], - processor_->effective_degradation_preference()) + manager_->active_counts_[reason], + manager_->effective_degradation_preference()) .Total(); RTC_DCHECK_GE(num_downgrades, 0); return num_downgrades > 0; } -ResourceAdaptationProcessor::PreventIncreaseResolutionDueToBitrateResource:: - PreventIncreaseResolutionDueToBitrateResource( - ResourceAdaptationProcessor* processor) - : processor_(processor) {} +VideoStreamEncoderResourceManager:: + PreventIncreaseResolutionDueToBitrateResource:: + PreventIncreaseResolutionDueToBitrateResource( + VideoStreamEncoderResourceManager* manager) + : manager_(manager) {} -bool ResourceAdaptationProcessor:: +bool VideoStreamEncoderResourceManager:: PreventIncreaseResolutionDueToBitrateResource::IsAdaptationUpAllowed( const VideoStreamInputState& input_state, const VideoSourceRestrictions& restrictions_before, const VideoSourceRestrictions& restrictions_after, const Resource& reason_resource) const { VideoAdaptationReason reason = - processor_->GetReasonFromResource(reason_resource); + manager_->GetReasonFromResource(reason_resource); // If increasing resolution due to kQuality, make sure bitrate limits are not // violated. // TODO(hbos): Why are we allowing violating bitrate constraints if adapting // due to CPU? Shouldn't this condition be checked regardless of reason? if (reason == VideoAdaptationReason::kQuality && DidIncreaseResolution(restrictions_before, restrictions_after)) { - uint32_t bitrate_bps = processor_->encoder_target_bitrate_bps_.value_or(0); + uint32_t bitrate_bps = manager_->encoder_target_bitrate_bps_.value_or(0); absl::optional<VideoEncoder::ResolutionBitrateLimits> bitrate_limits = - processor_->encoder_settings_.has_value() - ? processor_->encoder_settings_->encoder_info() + manager_->encoder_settings_.has_value() + ? manager_->encoder_settings_->encoder_info() .GetEncoderBitrateLimitsForResolution( // Need some sort of expected resulting pixels to be used // instead of unrestricted. @@ -202,42 +203,42 @@ return true; } -ResourceAdaptationProcessor::PreventAdaptUpInBalancedResource:: - PreventAdaptUpInBalancedResource(ResourceAdaptationProcessor* processor) - : processor_(processor) {} +VideoStreamEncoderResourceManager::PreventAdaptUpInBalancedResource:: + PreventAdaptUpInBalancedResource(VideoStreamEncoderResourceManager* manager) + : manager_(manager) {} -bool ResourceAdaptationProcessor::PreventAdaptUpInBalancedResource:: +bool VideoStreamEncoderResourceManager::PreventAdaptUpInBalancedResource:: IsAdaptationUpAllowed(const VideoStreamInputState& input_state, const VideoSourceRestrictions& restrictions_before, const VideoSourceRestrictions& restrictions_after, const Resource& reason_resource) const { VideoAdaptationReason reason = - processor_->GetReasonFromResource(reason_resource); + manager_->GetReasonFromResource(reason_resource); // Don't adapt if BalancedDegradationSettings applies and determines this will // exceed bitrate constraints. // TODO(hbos): Why are we allowing violating balanced settings if adapting due // CPU? Shouldn't this condition be checked regardless of reason? if (reason == VideoAdaptationReason::kQuality && - processor_->effective_degradation_preference() == + manager_->effective_degradation_preference() == DegradationPreference::BALANCED && - !processor_->stream_adapter_->balanced_settings().CanAdaptUp( + !manager_->stream_adapter_->balanced_settings().CanAdaptUp( input_state.video_codec_type(), input_state.frame_size_pixels().value(), - processor_->encoder_target_bitrate_bps_.value_or(0))) { + manager_->encoder_target_bitrate_bps_.value_or(0))) { return false; } if (reason == VideoAdaptationReason::kQuality && DidIncreaseResolution(restrictions_before, restrictions_after) && - !processor_->stream_adapter_->balanced_settings().CanAdaptUpResolution( + !manager_->stream_adapter_->balanced_settings().CanAdaptUpResolution( input_state.video_codec_type(), input_state.frame_size_pixels().value(), - processor_->encoder_target_bitrate_bps_.value_or(0))) { + manager_->encoder_target_bitrate_bps_.value_or(0))) { return false; } return true; } -ResourceAdaptationProcessor::ResourceAdaptationProcessor( +VideoStreamEncoderResourceManager::VideoStreamEncoderResourceManager( VideoStreamInputStateProvider* input_state_provider, Clock* clock, bool experiment_cpu_load_estimator, @@ -278,11 +279,11 @@ AddResource(&quality_scaler_resource_, VideoAdaptationReason::kQuality); } -ResourceAdaptationProcessor::~ResourceAdaptationProcessor() { +VideoStreamEncoderResourceManager::~VideoStreamEncoderResourceManager() { RTC_DCHECK_EQ(state_, State::kStopped); } -void ResourceAdaptationProcessor::StartResourceAdaptation( +void VideoStreamEncoderResourceManager::StartResourceAdaptation( ResourceAdaptationProcessorListener* adaptation_listener) { RTC_DCHECK_EQ(state_, State::kStopped); RTC_DCHECK(encoder_settings_.has_value()); @@ -297,7 +298,7 @@ state_ = State::kStarted; } -void ResourceAdaptationProcessor::StopResourceAdaptation() { +void VideoStreamEncoderResourceManager::StopResourceAdaptation() { encode_usage_resource_.StopCheckForOveruse(); quality_scaler_resource_.StopCheckForOveruse(); for (auto& resource_and_reason : resources_) { @@ -306,12 +307,13 @@ state_ = State::kStopped; } -void ResourceAdaptationProcessor::AddResource(Resource* resource) { +void VideoStreamEncoderResourceManager::AddResource(Resource* resource) { return AddResource(resource, VideoAdaptationReason::kCpu); } -void ResourceAdaptationProcessor::AddResource(Resource* resource, - VideoAdaptationReason reason) { +void VideoStreamEncoderResourceManager::AddResource( + Resource* resource, + VideoAdaptationReason reason) { RTC_DCHECK(resource); RTC_DCHECK(absl::c_find_if(resources_, [resource](const ResourceAndReason& r) { @@ -321,14 +323,14 @@ resources_.emplace_back(resource, reason); } -void ResourceAdaptationProcessor::SetDegradationPreference( +void VideoStreamEncoderResourceManager::SetDegradationPreference( DegradationPreference degradation_preference) { degradation_preference_ = degradation_preference; UpdateStatsAdaptationSettings(); MaybeUpdateEffectiveDegradationPreference(); } -void ResourceAdaptationProcessor::SetEncoderSettings( +void VideoStreamEncoderResourceManager::SetEncoderSettings( EncoderSettings encoder_settings) { encoder_settings_ = std::move(encoder_settings); MaybeUpdateEffectiveDegradationPreference(); @@ -339,31 +341,33 @@ MaybeUpdateTargetFrameRate(); } -void ResourceAdaptationProcessor::SetStartBitrate(DataRate start_bitrate) { +void VideoStreamEncoderResourceManager::SetStartBitrate( + DataRate start_bitrate) { if (!start_bitrate.IsZero()) encoder_target_bitrate_bps_ = start_bitrate.bps(); initial_frame_dropper_->SetStartBitrate(start_bitrate, clock_->TimeInMicroseconds()); } -void ResourceAdaptationProcessor::SetTargetBitrate(DataRate target_bitrate) { +void VideoStreamEncoderResourceManager::SetTargetBitrate( + DataRate target_bitrate) { if (!target_bitrate.IsZero()) encoder_target_bitrate_bps_ = target_bitrate.bps(); initial_frame_dropper_->SetTargetBitrate(target_bitrate, clock_->TimeInMilliseconds()); } -void ResourceAdaptationProcessor::SetEncoderRates( +void VideoStreamEncoderResourceManager::SetEncoderRates( const VideoEncoder::RateControlParameters& encoder_rates) { encoder_rates_ = encoder_rates; } -void ResourceAdaptationProcessor::ResetVideoSourceRestrictions() { +void VideoStreamEncoderResourceManager::ResetVideoSourceRestrictions() { stream_adapter_->ClearRestrictions(); MaybeUpdateVideoSourceRestrictions(nullptr); } -void ResourceAdaptationProcessor::OnFrameDroppedDueToSize() { +void VideoStreamEncoderResourceManager::OnFrameDroppedDueToSize() { VideoAdaptationCounters counters_before = stream_adapter_->adaptation_counters(); OnResourceOveruse(quality_scaler_resource_); @@ -380,14 +384,14 @@ initial_frame_dropper_->OnFrameDroppedDueToSize(); } -void ResourceAdaptationProcessor::OnEncodeStarted( +void VideoStreamEncoderResourceManager::OnEncodeStarted( const VideoFrame& cropped_frame, int64_t time_when_first_seen_us) { encode_usage_resource_.OnEncodeStarted(cropped_frame, time_when_first_seen_us); } -void ResourceAdaptationProcessor::OnEncodeCompleted( +void VideoStreamEncoderResourceManager::OnEncodeCompleted( const EncodedImage& encoded_image, int64_t time_sent_in_us, absl::optional<int> encode_duration_us) { @@ -401,21 +405,21 @@ quality_scaler_resource_.OnEncodeCompleted(encoded_image, time_sent_in_us); } -void ResourceAdaptationProcessor::OnFrameDropped( +void VideoStreamEncoderResourceManager::OnFrameDropped( EncodedImageCallback::DropReason reason) { quality_scaler_resource_.OnFrameDropped(reason); } -bool ResourceAdaptationProcessor::DropInitialFrames() const { +bool VideoStreamEncoderResourceManager::DropInitialFrames() const { return initial_frame_dropper_->DropInitialFrames(); } -void ResourceAdaptationProcessor::OnMaybeEncodeFrame() { +void VideoStreamEncoderResourceManager::OnMaybeEncodeFrame() { initial_frame_dropper_->OnMaybeEncodeFrame(); MaybePerformQualityRampupExperiment(); } -void ResourceAdaptationProcessor::UpdateQualityScalerSettings( +void VideoStreamEncoderResourceManager::UpdateQualityScalerSettings( absl::optional<VideoEncoder::QpThresholds> qp_thresholds) { if (qp_thresholds.has_value()) { quality_scaler_resource_.StopCheckForOveruse(); @@ -426,7 +430,7 @@ initial_frame_dropper_->OnQualityScalerSettingsUpdated(); } -void ResourceAdaptationProcessor::ConfigureQualityScaler( +void VideoStreamEncoderResourceManager::ConfigureQualityScaler( const VideoEncoder::EncoderInfo& encoder_info) { const auto scaling_settings = encoder_info.scaling_settings; const bool quality_scaling_allowed = @@ -468,7 +472,7 @@ } ResourceListenerResponse -ResourceAdaptationProcessor::OnResourceUsageStateMeasured( +VideoStreamEncoderResourceManager::OnResourceUsageStateMeasured( const Resource& resource) { switch (resource.usage_state()) { case ResourceUsageState::kOveruse: @@ -483,7 +487,7 @@ } } -bool ResourceAdaptationProcessor::HasSufficientInputForAdaptation( +bool VideoStreamEncoderResourceManager::HasSufficientInputForAdaptation( const VideoStreamInputState& input_state) const { return input_state.HasInputFrameSizeAndFramesPerSecond() && (effective_degradation_preference_ != @@ -491,7 +495,7 @@ input_state.frames_per_second() >= kMinFrameRateFps); } -VideoAdaptationReason ResourceAdaptationProcessor::GetReasonFromResource( +VideoAdaptationReason VideoStreamEncoderResourceManager::GetReasonFromResource( const Resource& resource) const { const auto& registered_resource = absl::c_find_if(resources_, [&resource](const ResourceAndReason& r) { @@ -502,7 +506,7 @@ return registered_resource->reason; } -void ResourceAdaptationProcessor::OnResourceUnderuse( +void VideoStreamEncoderResourceManager::OnResourceUnderuse( const Resource& reason_resource) { VideoStreamInputState input_state = input_state_provider_->InputState(); if (effective_degradation_preference_ == DegradationPreference::DISABLED || @@ -536,7 +540,7 @@ MaybeUpdateVideoSourceRestrictions(&reason_resource); } -ResourceListenerResponse ResourceAdaptationProcessor::OnResourceOveruse( +ResourceListenerResponse VideoStreamEncoderResourceManager::OnResourceOveruse( const Resource& reason_resource) { VideoStreamInputState input_state = input_state_provider_->InputState(); if (!input_state.has_input()) { @@ -567,7 +571,8 @@ // pipelining encoders better (multiple input frames before something comes // out). This should effectively turn off CPU adaptations for systems that // remotely cope with the load right now. -CpuOveruseOptions ResourceAdaptationProcessor::GetCpuOveruseOptions() const { +CpuOveruseOptions VideoStreamEncoderResourceManager::GetCpuOveruseOptions() + const { // This is already ensured by the only caller of this method: // StartResourceAdaptation(). RTC_DCHECK(encoder_settings_.has_value()); @@ -584,12 +589,13 @@ return options; } -int ResourceAdaptationProcessor::LastInputFrameSizeOrDefault() const { +int VideoStreamEncoderResourceManager::LastInputFrameSizeOrDefault() const { return input_state_provider_->InputState().frame_size_pixels().value_or( kDefaultInputPixelsWidth * kDefaultInputPixelsHeight); } -void ResourceAdaptationProcessor::MaybeUpdateEffectiveDegradationPreference() { +void VideoStreamEncoderResourceManager:: + MaybeUpdateEffectiveDegradationPreference() { bool is_screenshare = encoder_settings_.has_value() && encoder_settings_->encoder_config().content_type == VideoEncoderConfig::ContentType::kScreen; @@ -602,7 +608,7 @@ MaybeUpdateVideoSourceRestrictions(nullptr); } -void ResourceAdaptationProcessor::MaybeUpdateVideoSourceRestrictions( +void VideoStreamEncoderResourceManager::MaybeUpdateVideoSourceRestrictions( const Resource* reason_resource) { VideoSourceRestrictions new_restrictions = FilterRestrictionsByDegradationPreference( @@ -621,7 +627,7 @@ } } -void ResourceAdaptationProcessor::OnVideoSourceRestrictionsUpdated( +void VideoStreamEncoderResourceManager::OnVideoSourceRestrictionsUpdated( VideoSourceRestrictions restrictions, const VideoAdaptationCounters& adaptation_counters, const Resource* reason) { @@ -651,7 +657,7 @@ MaybeUpdateTargetFrameRate(); } -void ResourceAdaptationProcessor::MaybeUpdateTargetFrameRate() { +void VideoStreamEncoderResourceManager::MaybeUpdateTargetFrameRate() { absl::optional<double> codec_max_frame_rate = encoder_settings_.has_value() ? absl::optional<double>( @@ -671,7 +677,7 @@ encode_usage_resource_.SetTargetFrameRate(target_frame_rate); } -void ResourceAdaptationProcessor::OnAdaptationCountChanged( +void VideoStreamEncoderResourceManager::OnAdaptationCountChanged( const VideoAdaptationCounters& adaptation_count, VideoAdaptationCounters* active_count, VideoAdaptationCounters* other_active) { @@ -734,7 +740,7 @@ RTC_DCHECK_GE(other_active->fps_adaptations, 0); } -void ResourceAdaptationProcessor::UpdateAdaptationStats( +void VideoStreamEncoderResourceManager::UpdateAdaptationStats( const VideoAdaptationCounters& total_counts, VideoAdaptationReason reason) { // Update active counts @@ -748,7 +754,7 @@ active_counts_[VideoAdaptationReason::kQuality]); } -void ResourceAdaptationProcessor::UpdateStatsAdaptationSettings() const { +void VideoStreamEncoderResourceManager::UpdateStatsAdaptationSettings() const { VideoStreamEncoderObserver::AdaptationSettings cpu_settings( IsResolutionScalingEnabled(degradation_preference_), IsFramerateScalingEnabled(degradation_preference_)); @@ -761,7 +767,7 @@ quality_settings); } -void ResourceAdaptationProcessor::MaybePerformQualityRampupExperiment() { +void VideoStreamEncoderResourceManager::MaybePerformQualityRampupExperiment() { if (!quality_scaler_resource_.is_started()) return; @@ -797,13 +803,13 @@ } } -void ResourceAdaptationProcessor::ResetActiveCounts() { +void VideoStreamEncoderResourceManager::ResetActiveCounts() { active_counts_.clear(); active_counts_[VideoAdaptationReason::kCpu] = VideoAdaptationCounters(); active_counts_[VideoAdaptationReason::kQuality] = VideoAdaptationCounters(); } -std::string ResourceAdaptationProcessor::ActiveCountsToString() const { +std::string VideoStreamEncoderResourceManager::ActiveCountsToString() const { RTC_DCHECK_EQ(2, active_counts_.size()); rtc::StringBuilder ss;
diff --git a/video/adaptation/resource_adaptation_processor.h b/video/adaptation/video_stream_encoder_resource_manager.h similarity index 93% rename from video/adaptation/resource_adaptation_processor.h rename to video/adaptation/video_stream_encoder_resource_manager.h index 0037ab5..d99b6ec 100644 --- a/video/adaptation/resource_adaptation_processor.h +++ b/video/adaptation/video_stream_encoder_resource_manager.h
@@ -8,8 +8,8 @@ * be found in the AUTHORS file in the root of the source tree. */ -#ifndef VIDEO_ADAPTATION_RESOURCE_ADAPTATION_PROCESSOR_H_ -#define VIDEO_ADAPTATION_RESOURCE_ADAPTATION_PROCESSOR_H_ +#ifndef VIDEO_ADAPTATION_VIDEO_STREAM_ENCODER_RESOURCE_MANAGER_H_ +#define VIDEO_ADAPTATION_VIDEO_STREAM_ENCODER_RESOURCE_MANAGER_H_ #include <map> #include <memory> @@ -58,20 +58,21 @@ // TODO(hbos): Add unittests specific to this class, it is currently only tested // indirectly in video_stream_encoder_unittest.cc and other tests exercising // VideoStreamEncoder. -class ResourceAdaptationProcessor : public ResourceAdaptationProcessorInterface, - public ResourceListener, - public ResourceAdaptationProcessorListener { +class VideoStreamEncoderResourceManager + : public ResourceAdaptationProcessorInterface, + public ResourceListener, + public ResourceAdaptationProcessorListener { public: // The processor can be constructed on any sequence, but must be initialized // and used on a single sequence, e.g. the encoder queue. - ResourceAdaptationProcessor( + VideoStreamEncoderResourceManager( VideoStreamInputStateProvider* input_state_provider, Clock* clock, bool experiment_cpu_load_estimator, std::unique_ptr<OveruseFrameDetector> overuse_detector, VideoStreamEncoderObserver* encoder_stats_observer, ResourceAdaptationProcessorListener* adaptation_listener); - ~ResourceAdaptationProcessor() override; + ~VideoStreamEncoderResourceManager() override; DegradationPreference degradation_preference() const { return degradation_preference_; @@ -192,7 +193,7 @@ class PreventAdaptUpDueToActiveCounts final : public Resource { public: explicit PreventAdaptUpDueToActiveCounts( - ResourceAdaptationProcessor* processor); + VideoStreamEncoderResourceManager* manager); ~PreventAdaptUpDueToActiveCounts() override = default; std::string name() const override { @@ -206,14 +207,14 @@ const Resource& reason_resource) const override; private: - ResourceAdaptationProcessor* processor_; + VideoStreamEncoderResourceManager* manager_; } prevent_adapt_up_due_to_active_counts_; // Does not trigger adaptations, only prevents adapting up resolution. class PreventIncreaseResolutionDueToBitrateResource final : public Resource { public: explicit PreventIncreaseResolutionDueToBitrateResource( - ResourceAdaptationProcessor* processor); + VideoStreamEncoderResourceManager* manager); ~PreventIncreaseResolutionDueToBitrateResource() override = default; std::string name() const override { @@ -227,14 +228,14 @@ const Resource& reason_resource) const override; private: - ResourceAdaptationProcessor* processor_; + VideoStreamEncoderResourceManager* manager_; } prevent_increase_resolution_due_to_bitrate_resource_; // Does not trigger adaptations, only prevents adapting up in BALANCED. class PreventAdaptUpInBalancedResource final : public Resource { public: explicit PreventAdaptUpInBalancedResource( - ResourceAdaptationProcessor* processor); + VideoStreamEncoderResourceManager* manager); ~PreventAdaptUpInBalancedResource() override = default; std::string name() const override { @@ -248,7 +249,7 @@ const Resource& reason_resource) const override; private: - ResourceAdaptationProcessor* processor_; + VideoStreamEncoderResourceManager* manager_; } prevent_adapt_up_in_balanced_resource_; EncodeUsageResource encode_usage_resource_; @@ -299,4 +300,4 @@ } // namespace webrtc -#endif // VIDEO_ADAPTATION_RESOURCE_ADAPTATION_PROCESSOR_H_ +#endif // VIDEO_ADAPTATION_VIDEO_STREAM_ENCODER_RESOURCE_MANAGER_H_
diff --git a/video/adaptation/resource_adaptation_processor_unittest.cc b/video/adaptation/video_stream_encoder_resource_manager_unittest.cc similarity index 71% rename from video/adaptation/resource_adaptation_processor_unittest.cc rename to video/adaptation/video_stream_encoder_resource_manager_unittest.cc index 448ca70..38ebba6 100644 --- a/video/adaptation/resource_adaptation_processor_unittest.cc +++ b/video/adaptation/video_stream_encoder_resource_manager_unittest.cc
@@ -8,7 +8,7 @@ * be found in the AUTHORS file in the root of the source tree. */ -#include "video/adaptation/resource_adaptation_processor.h" +#include "video/adaptation/video_stream_encoder_resource_manager.h" #include "api/video/video_adaptation_counters.h" #include "test/gmock.h" @@ -16,55 +16,55 @@ namespace webrtc { -TEST(ResourceAdaptationProcessorTest, FirstAdaptationDown_Fps) { +TEST(VideoStreamEncoderResourceManagerTest, FirstAdaptationDown_Fps) { VideoAdaptationCounters cpu; VideoAdaptationCounters qp; VideoAdaptationCounters total(0, 1); - ResourceAdaptationProcessor::OnAdaptationCountChanged(total, &cpu, &qp); + VideoStreamEncoderResourceManager::OnAdaptationCountChanged(total, &cpu, &qp); VideoAdaptationCounters expected_cpu(0, 1); VideoAdaptationCounters expected_qp; EXPECT_EQ(expected_cpu, cpu); EXPECT_EQ(expected_qp, qp); } -TEST(ResourceAdaptationProcessorTest, FirstAdaptationDown_Resolution) { +TEST(VideoStreamEncoderResourceManagerTest, FirstAdaptationDown_Resolution) { VideoAdaptationCounters cpu; VideoAdaptationCounters qp; VideoAdaptationCounters total(1, 0); - ResourceAdaptationProcessor::OnAdaptationCountChanged(total, &cpu, &qp); + VideoStreamEncoderResourceManager::OnAdaptationCountChanged(total, &cpu, &qp); VideoAdaptationCounters expected_cpu(1, 0); VideoAdaptationCounters expected_qp; EXPECT_EQ(expected_cpu, cpu); EXPECT_EQ(expected_qp, qp); } -TEST(ResourceAdaptationProcessorTest, LastAdaptUp_Fps) { +TEST(VideoStreamEncoderResourceManagerTest, LastAdaptUp_Fps) { VideoAdaptationCounters cpu(0, 1); VideoAdaptationCounters qp; VideoAdaptationCounters total; - ResourceAdaptationProcessor::OnAdaptationCountChanged(total, &cpu, &qp); + VideoStreamEncoderResourceManager::OnAdaptationCountChanged(total, &cpu, &qp); VideoAdaptationCounters expected_cpu; VideoAdaptationCounters expected_qp; EXPECT_EQ(expected_cpu, cpu); EXPECT_EQ(expected_qp, qp); } -TEST(ResourceAdaptationProcessorTest, LastAdaptUp_Resolution) { +TEST(VideoStreamEncoderResourceManagerTest, LastAdaptUp_Resolution) { VideoAdaptationCounters cpu(1, 0); VideoAdaptationCounters qp; VideoAdaptationCounters total; - ResourceAdaptationProcessor::OnAdaptationCountChanged(total, &cpu, &qp); + VideoStreamEncoderResourceManager::OnAdaptationCountChanged(total, &cpu, &qp); VideoAdaptationCounters expected_cpu; VideoAdaptationCounters expected_qp; EXPECT_EQ(expected_cpu, cpu); EXPECT_EQ(expected_qp, qp); } -TEST(ResourceAdaptationProcessorTest, AdaptUpWithBorrow_Resolution) { +TEST(VideoStreamEncoderResourceManagerTest, AdaptUpWithBorrow_Resolution) { VideoAdaptationCounters cpu(0, 1); VideoAdaptationCounters qp(1, 0); VideoAdaptationCounters total(0, 1); @@ -72,7 +72,7 @@ // CPU adaptation for resolution, but no resolution adaptation left from CPU. // We then borrow the resolution adaptation from qp, and give qp the fps // adaptation from CPU. - ResourceAdaptationProcessor::OnAdaptationCountChanged(total, &cpu, &qp); + VideoStreamEncoderResourceManager::OnAdaptationCountChanged(total, &cpu, &qp); VideoAdaptationCounters expected_cpu(0, 0); VideoAdaptationCounters expected_qp(0, 1); @@ -80,14 +80,14 @@ EXPECT_EQ(expected_qp, qp); } -TEST(ResourceAdaptationProcessorTest, AdaptUpWithBorrow_Fps) { +TEST(VideoStreamEncoderResourceManagerTest, AdaptUpWithBorrow_Fps) { VideoAdaptationCounters cpu(1, 0); VideoAdaptationCounters qp(0, 1); VideoAdaptationCounters total(1, 0); // CPU adaptation for fps, but no fps adaptation left from CPU. We then borrow // the fps adaptation from qp, and give qp the resolution adaptation from CPU. - ResourceAdaptationProcessor::OnAdaptationCountChanged(total, &cpu, &qp); + VideoStreamEncoderResourceManager::OnAdaptationCountChanged(total, &cpu, &qp); VideoAdaptationCounters expected_cpu(0, 0); VideoAdaptationCounters expected_qp(1, 0);
diff --git a/video/video_stream_encoder.cc b/video/video_stream_encoder.cc index 5922601..d82b240 100644 --- a/video/video_stream_encoder.cc +++ b/video/video_stream_encoder.cc
@@ -37,7 +37,7 @@ #include "rtc_base/time_utils.h" #include "rtc_base/trace_event.h" #include "system_wrappers/include/field_trial.h" -#include "video/adaptation/resource_adaptation_processor.h" +#include "video/adaptation/video_stream_encoder_resource_manager.h" namespace webrtc { @@ -260,8 +260,8 @@ /*source=*/nullptr)), input_state_provider_(std::make_unique<VideoStreamInputStateProvider>( encoder_stats_observer)), - resource_adaptation_processor_( - std::make_unique<ResourceAdaptationProcessor>( + stream_resource_manager_( + std::make_unique<VideoStreamEncoderResourceManager>( input_state_provider_.get(), clock_, settings_.experiment_cpu_load_estimator, @@ -289,7 +289,7 @@ video_source_sink_controller_->SetSource(nullptr); encoder_queue_.PostTask([this] { RTC_DCHECK_RUN_ON(&encoder_queue_); - resource_adaptation_processor_->StopResourceAdaptation(); + stream_resource_manager_->StopResourceAdaptation(); rate_allocator_ = nullptr; bitrate_observer_ = nullptr; ReleaseEncoder(); @@ -329,10 +329,9 @@ encoder_queue_.PostTask([this, source, degradation_preference] { RTC_DCHECK_RUN_ON(&encoder_queue_); input_state_provider_->OnHasInputChanged(source); - resource_adaptation_processor_->SetDegradationPreference( - degradation_preference); + stream_resource_manager_->SetDegradationPreference(degradation_preference); if (encoder_) - resource_adaptation_processor_->ConfigureQualityScaler( + stream_resource_manager_->ConfigureQualityScaler( encoder_->GetEncoderInfo()); }); } @@ -352,7 +351,7 @@ encoder_target_bitrate_bps_ = start_bitrate_bps != 0 ? absl::optional<uint32_t>(start_bitrate_bps) : absl::nullopt; - resource_adaptation_processor_->SetStartBitrate( + stream_resource_manager_->SetStartBitrate( DataRate::BitsPerSec(start_bitrate_bps)); }); } @@ -657,8 +656,8 @@ } if (pending_encoder_creation_) { - resource_adaptation_processor_->StopResourceAdaptation(); - resource_adaptation_processor_->StartResourceAdaptation(this); + stream_resource_manager_->StopResourceAdaptation(); + stream_resource_manager_->StartResourceAdaptation(this); pending_encoder_creation_ = false; } @@ -731,14 +730,14 @@ std::move(streams), is_svc, encoder_config_.content_type, encoder_config_.min_transmit_bitrate_bps); - resource_adaptation_processor_->ConfigureQualityScaler(info); + stream_resource_manager_->ConfigureQualityScaler(info); } void VideoStreamEncoder::OnEncoderSettingsChanged() { EncoderSettings encoder_settings(encoder_->GetEncoderInfo(), encoder_config_.Copy(), send_codec_); input_state_provider_->OnEncoderSettingsChanged(encoder_settings); - resource_adaptation_processor_->SetEncoderSettings(encoder_settings); + stream_resource_manager_->SetEncoderSettings(encoder_settings); } void VideoStreamEncoder::OnFrame(const VideoFrame& video_frame) { @@ -975,7 +974,7 @@ frame_encode_metadata_writer_.OnSetRates( rate_settings.rate_control.bitrate, static_cast<uint32_t>(rate_settings.rate_control.framerate_fps + 0.5)); - resource_adaptation_processor_->SetEncoderRates(rate_settings.rate_control); + stream_resource_manager_->SetEncoderRates(rate_settings.rate_control); } } @@ -1044,7 +1043,7 @@ if (DropDueToSize(video_frame.size())) { RTC_LOG(LS_INFO) << "Dropping frame. Too large for target bitrate."; - resource_adaptation_processor_->OnFrameDroppedDueToSize(); + stream_resource_manager_->OnFrameDroppedDueToSize(); // Storing references to a native buffer risks blocking frame capture. if (video_frame.video_frame_buffer()->type() != VideoFrameBuffer::Type::kNative) { @@ -1058,7 +1057,7 @@ } return; } - resource_adaptation_processor_->OnMaybeEncodeFrame(); + stream_resource_manager_->OnMaybeEncodeFrame(); if (EncoderPaused()) { // Storing references to a native buffer risks blocking frame capture. @@ -1241,8 +1240,7 @@ TRACE_EVENT_ASYNC_STEP0("webrtc", "Video", video_frame.render_time_ms(), "Encode"); - resource_adaptation_processor_->OnEncodeStarted(out_frame, - time_when_posted_us); + stream_resource_manager_->OnEncodeStarted(out_frame, time_when_posted_us); RTC_DCHECK_LE(send_codec_.width, out_frame.width()); RTC_DCHECK_LE(send_codec_.height, out_frame.height()); @@ -1517,7 +1515,7 @@ sink_->OnDroppedFrame(reason); encoder_queue_.PostTask([this, reason] { RTC_DCHECK_RUN_ON(&encoder_queue_); - resource_adaptation_processor_->OnFrameDropped(reason); + stream_resource_manager_->OnFrameDropped(reason); }); } @@ -1616,7 +1614,7 @@ if (target_bitrate.bps() != 0) encoder_target_bitrate_bps_ = target_bitrate.bps(); - resource_adaptation_processor_->SetTargetBitrate(target_bitrate); + stream_resource_manager_->SetTargetBitrate(target_bitrate); if (video_suspension_changed) { RTC_LOG(LS_INFO) << "Video suspend state changed to: " @@ -1633,7 +1631,7 @@ } bool VideoStreamEncoder::DropDueToSize(uint32_t pixel_count) const { - if (!resource_adaptation_processor_->DropInitialFrames() || + if (!stream_resource_manager_->DropInitialFrames() || !encoder_target_bitrate_bps_.has_value()) { return false; } @@ -1707,8 +1705,8 @@ } } - resource_adaptation_processor_->OnEncodeCompleted(encoded_image, time_sent_us, - encode_duration_us); + stream_resource_manager_->OnEncodeCompleted(encoded_image, time_sent_us, + encode_duration_us); if (bitrate_adjuster_) { bitrate_adjuster_->OnEncodedFrame(encoded_image, temporal_index); } @@ -1863,7 +1861,7 @@ if (!automatic_animation_detection_experiment_.enabled || encoder_config_.content_type != VideoEncoderConfig::ContentType::kScreen || - resource_adaptation_processor_->degradation_preference() != + stream_resource_manager_->degradation_preference() != DegradationPreference::BALANCED) { return; } @@ -1930,7 +1928,7 @@ void VideoStreamEncoder::InjectAdaptationResource( Resource* resource, VideoAdaptationReason reason) { - resource_adaptation_processor_->AddResource(resource, reason); + stream_resource_manager_->AddResource(resource, reason); } } // namespace webrtc
diff --git a/video/video_stream_encoder.h b/video/video_stream_encoder.h index 1bb3bcf..4ad7edc 100644 --- a/video/video_stream_encoder.h +++ b/video/video_stream_encoder.h
@@ -39,7 +39,7 @@ #include "rtc_base/synchronization/sequence_checker.h" #include "rtc_base/task_queue.h" #include "system_wrappers/include/clock.h" -#include "video/adaptation/resource_adaptation_processor.h" +#include "video/adaptation/video_stream_encoder_resource_manager.h" #include "video/encoder_bitrate_adjuster.h" #include "video/frame_encode_metadata_writer.h" #include "video/video_source_sink_controller.h" @@ -412,7 +412,7 @@ std::unique_ptr<VideoSourceSinkController> video_source_sink_controller_; std::unique_ptr<VideoStreamInputStateProvider> input_state_provider_ RTC_GUARDED_BY(&encoder_queue_); - std::unique_ptr<ResourceAdaptationProcessor> resource_adaptation_processor_ + std::unique_ptr<VideoStreamEncoderResourceManager> stream_resource_manager_ RTC_GUARDED_BY(&encoder_queue_); // All public methods are proxied to |encoder_queue_|. It must must be