[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}
This commit is contained in:
Henrik Boström
Commit Bot
parent
d2930c6c2b
commit
de8d551b95
@ -16,8 +16,8 @@ rtc_library("video_adaptation") {
|
||||
"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 @@ if (rtc_include_tests) {
|
||||
defines = []
|
||||
sources = [
|
||||
"overuse_frame_detector_unittest.cc",
|
||||
"resource_adaptation_processor_unittest.cc",
|
||||
"video_stream_encoder_resource_manager_unittest.cc",
|
||||
]
|
||||
deps = [
|
||||
":video_adaptation",
|
||||
|
||||
@ -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 @@ VideoAdaptationReason OtherReason(VideoAdaptationReason reason) {
|
||||
|
||||
} // namespace
|
||||
|
||||
class ResourceAdaptationProcessor::InitialFrameDropper {
|
||||
class VideoStreamEncoderResourceManager::InitialFrameDropper {
|
||||
public:
|
||||
explicit InitialFrameDropper(QualityScalerResource* quality_scaler_resource)
|
||||
: quality_scaler_resource_(quality_scaler_resource),
|
||||
@ -137,17 +137,17 @@ class ResourceAdaptationProcessor::InitialFrameDropper {
|
||||
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 @@ bool ResourceAdaptationProcessor::PreventAdaptUpDueToActiveCounts::
|
||||
// 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 @@ bool ResourceAdaptationProcessor::
|
||||
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 @@ ResourceAdaptationProcessor::ResourceAdaptationProcessor(
|
||||
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 @@ void ResourceAdaptationProcessor::StartResourceAdaptation(
|
||||
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 @@ void ResourceAdaptationProcessor::StopResourceAdaptation() {
|
||||
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 @@ void ResourceAdaptationProcessor::AddResource(Resource* resource,
|
||||
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 @@ void ResourceAdaptationProcessor::SetEncoderSettings(
|
||||
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 @@ void ResourceAdaptationProcessor::OnFrameDroppedDueToSize() {
|
||||
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 @@ void ResourceAdaptationProcessor::OnEncodeCompleted(
|
||||
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 @@ void ResourceAdaptationProcessor::UpdateQualityScalerSettings(
|
||||
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 @@ void ResourceAdaptationProcessor::ConfigureQualityScaler(
|
||||
}
|
||||
|
||||
ResourceListenerResponse
|
||||
ResourceAdaptationProcessor::OnResourceUsageStateMeasured(
|
||||
VideoStreamEncoderResourceManager::OnResourceUsageStateMeasured(
|
||||
const Resource& resource) {
|
||||
switch (resource.usage_state()) {
|
||||
case ResourceUsageState::kOveruse:
|
||||
@ -483,7 +487,7 @@ ResourceAdaptationProcessor::OnResourceUsageStateMeasured(
|
||||
}
|
||||
}
|
||||
|
||||
bool ResourceAdaptationProcessor::HasSufficientInputForAdaptation(
|
||||
bool VideoStreamEncoderResourceManager::HasSufficientInputForAdaptation(
|
||||
const VideoStreamInputState& input_state) const {
|
||||
return input_state.HasInputFrameSizeAndFramesPerSecond() &&
|
||||
(effective_degradation_preference_ !=
|
||||
@ -491,7 +495,7 @@ bool ResourceAdaptationProcessor::HasSufficientInputForAdaptation(
|
||||
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 @@ VideoAdaptationReason ResourceAdaptationProcessor::GetReasonFromResource(
|
||||
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 @@ void ResourceAdaptationProcessor::OnResourceUnderuse(
|
||||
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 @@ ResourceListenerResponse ResourceAdaptationProcessor::OnResourceOveruse(
|
||||
// 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 @@ CpuOveruseOptions ResourceAdaptationProcessor::GetCpuOveruseOptions() const {
|
||||
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 @@ void ResourceAdaptationProcessor::MaybeUpdateEffectiveDegradationPreference() {
|
||||
MaybeUpdateVideoSourceRestrictions(nullptr);
|
||||
}
|
||||
|
||||
void ResourceAdaptationProcessor::MaybeUpdateVideoSourceRestrictions(
|
||||
void VideoStreamEncoderResourceManager::MaybeUpdateVideoSourceRestrictions(
|
||||
const Resource* reason_resource) {
|
||||
VideoSourceRestrictions new_restrictions =
|
||||
FilterRestrictionsByDegradationPreference(
|
||||
@ -621,7 +627,7 @@ void ResourceAdaptationProcessor::MaybeUpdateVideoSourceRestrictions(
|
||||
}
|
||||
}
|
||||
|
||||
void ResourceAdaptationProcessor::OnVideoSourceRestrictionsUpdated(
|
||||
void VideoStreamEncoderResourceManager::OnVideoSourceRestrictionsUpdated(
|
||||
VideoSourceRestrictions restrictions,
|
||||
const VideoAdaptationCounters& adaptation_counters,
|
||||
const Resource* reason) {
|
||||
@ -651,7 +657,7 @@ void ResourceAdaptationProcessor::OnVideoSourceRestrictionsUpdated(
|
||||
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 @@ void ResourceAdaptationProcessor::MaybeUpdateTargetFrameRate() {
|
||||
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 @@ void ResourceAdaptationProcessor::OnAdaptationCountChanged(
|
||||
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 @@ void ResourceAdaptationProcessor::UpdateAdaptationStats(
|
||||
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 @@ void ResourceAdaptationProcessor::UpdateStatsAdaptationSettings() const {
|
||||
quality_settings);
|
||||
}
|
||||
|
||||
void ResourceAdaptationProcessor::MaybePerformQualityRampupExperiment() {
|
||||
void VideoStreamEncoderResourceManager::MaybePerformQualityRampupExperiment() {
|
||||
if (!quality_scaler_resource_.is_started())
|
||||
return;
|
||||
|
||||
@ -797,13 +803,13 @@ void ResourceAdaptationProcessor::MaybePerformQualityRampupExperiment() {
|
||||
}
|
||||
}
|
||||
|
||||
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;
|
||||
|
||||
@ -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 @@ extern const int kDefaultInputPixelsHeight;
|
||||
// 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 ResourceAdaptationProcessor : public ResourceAdaptationProcessorInterface,
|
||||
class PreventAdaptUpDueToActiveCounts final : public Resource {
|
||||
public:
|
||||
explicit PreventAdaptUpDueToActiveCounts(
|
||||
ResourceAdaptationProcessor* processor);
|
||||
VideoStreamEncoderResourceManager* manager);
|
||||
~PreventAdaptUpDueToActiveCounts() override = default;
|
||||
|
||||
std::string name() const override {
|
||||
@ -206,14 +207,14 @@ class ResourceAdaptationProcessor : public ResourceAdaptationProcessorInterface,
|
||||
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 @@ class ResourceAdaptationProcessor : public ResourceAdaptationProcessorInterface,
|
||||
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 @@ class ResourceAdaptationProcessor : public ResourceAdaptationProcessorInterface,
|
||||
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 @@ class ResourceAdaptationProcessor : public ResourceAdaptationProcessorInterface,
|
||||
|
||||
} // namespace webrtc
|
||||
|
||||
#endif // VIDEO_ADAPTATION_RESOURCE_ADAPTATION_PROCESSOR_H_
|
||||
#endif // VIDEO_ADAPTATION_VIDEO_STREAM_ENCODER_RESOURCE_MANAGER_H_
|
||||
@ -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 @@ TEST(ResourceAdaptationProcessorTest, AdaptUpWithBorrow_Resolution) {
|
||||
// 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 @@ TEST(ResourceAdaptationProcessorTest, AdaptUpWithBorrow_Resolution) {
|
||||
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);
|
||||
@ -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 @@ VideoStreamEncoder::VideoStreamEncoder(
|
||||
/*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 @@ void VideoStreamEncoder::Stop() {
|
||||
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 @@ void VideoStreamEncoder::SetSource(
|
||||
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 @@ void VideoStreamEncoder::SetStartBitrate(int start_bitrate_bps) {
|
||||
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 @@ void VideoStreamEncoder::ReconfigureEncoder() {
|
||||
}
|
||||
|
||||
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 @@ void VideoStreamEncoder::ReconfigureEncoder() {
|
||||
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 @@ void VideoStreamEncoder::SetEncoderRates(
|
||||
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 @@ void VideoStreamEncoder::MaybeEncodeVideoFrame(const VideoFrame& video_frame,
|
||||
|
||||
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 @@ void VideoStreamEncoder::MaybeEncodeVideoFrame(const VideoFrame& video_frame,
|
||||
}
|
||||
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 @@ void VideoStreamEncoder::EncodeVideoFrame(const VideoFrame& video_frame,
|
||||
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 @@ void VideoStreamEncoder::OnDroppedFrame(DropReason reason) {
|
||||
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 @@ void VideoStreamEncoder::OnBitrateUpdated(DataRate target_bitrate,
|
||||
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 @@ void VideoStreamEncoder::OnBitrateUpdated(DataRate target_bitrate,
|
||||
}
|
||||
|
||||
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 @@ void VideoStreamEncoder::RunPostEncode(const EncodedImage& encoded_image,
|
||||
}
|
||||
}
|
||||
|
||||
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 @@ void VideoStreamEncoder::CheckForAnimatedContent(
|
||||
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::CheckForAnimatedContent(
|
||||
void VideoStreamEncoder::InjectAdaptationResource(
|
||||
Resource* resource,
|
||||
VideoAdaptationReason reason) {
|
||||
resource_adaptation_processor_->AddResource(resource, reason);
|
||||
stream_resource_manager_->AddResource(resource, reason);
|
||||
}
|
||||
|
||||
} // namespace webrtc
|
||||
|
||||
@ -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 @@ class VideoStreamEncoder : public VideoStreamEncoderInterface,
|
||||
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
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user