admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[Adaptation] Remove deg.prefs from ResourceAdaptationProcessor

Browse Source 
Changes in effective degradation preference is now done directly
on the VideoStreamAdapter. This means that the
DegradationPreferenceListener class can be removed.

Bug: webrtc:11700
Change-Id: I9ce4b627de0279df5ef2e5a38435a6d352fbb135
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/178609
Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org>
Reviewed-by: Henrik Boström <hbos@webrtc.org>
Commit-Queue: Evan Shrubsole <eshr@google.com>
Cr-Commit-Position: refs/heads/master@{#31642}
This commit is contained in:
Evan Shrubsole 2020-07-07 09:04:34 +02:00 committed by Commit Bot
parent c2128738a8
commit 3444a49d77
10 changed files with 99 additions and 155 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
call/adaptation/BUILD.gn
View File

@ -16,8 +16,6 @@ rtc_library("resource_adaptation") {
"adaptation_listener.h",
"broadcast_resource_listener.cc",
"broadcast_resource_listener.h",
"degradation_preference_listener.cc",
"degradation_preference_listener.h",
"degradation_preference_provider.cc",
"degradation_preference_provider.h",
"encoder_settings.cc",

17
call/adaptation/degradation_preference_listener.cc
View File

@ -1,17 +0,0 @@
/*
* 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 "call/adaptation/degradation_preference_listener.h"
namespace webrtc {
DegradationPreferenceListener::~DegradationPreferenceListener() = default;
} // namespace webrtc

28
call/adaptation/degradation_preference_listener.h
View File

@ -1,28 +0,0 @@
/*
* 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 CALL_ADAPTATION_DEGRADATION_PREFERENCE_LISTENER_H_
#define CALL_ADAPTATION_DEGRADATION_PREFERENCE_LISTENER_H_
#include "api/rtp_parameters.h"
namespace webrtc {
class DegradationPreferenceListener {
public:
virtual ~DegradationPreferenceListener();
virtual void OnDegradationPreferenceUpdated(
DegradationPreference degradation_preference) = 0;
};
} // namespace webrtc
#endif // CALL_ADAPTATION_DEGRADATION_PREFERENCE_LISTENER_H_

30
call/adaptation/resource_adaptation_processor.cc
View File

@ -75,7 +75,6 @@ ResourceAdaptationProcessor::ResourceAdaptationProcessor(
new rtc::RefCountedObject<ResourceListenerDelegate>(this)),
encoder_stats_observer_(encoder_stats_observer),
resources_(),
effective_degradation_preference_(DegradationPreference::DISABLED),
stream_adapter_(stream_adapter),
last_reported_source_restrictions_(),
previous_mitigation_results_(),
@ -201,23 +200,6 @@ void ResourceAdaptationProcessor::RemoveAdaptationListener(
adaptation_listeners_.erase(it);
}
void ResourceAdaptationProcessor::OnDegradationPreferenceUpdated(
DegradationPreference degradation_preference) {
if (!resource_adaptation_queue_->IsCurrent()) {
resource_adaptation_queue_->PostTask(
ToQueuedTask([this, degradation_preference]() {
OnDegradationPreferenceUpdated(degradation_preference);
}));
return;
}
RTC_DCHECK_RUN_ON(resource_adaptation_queue_);
if (degradation_preference == effective_degradation_preference_) {
return;
}
effective_degradation_preference_ = degradation_preference;
stream_adapter_->SetDegradationPreference(effective_degradation_preference_);
}
void ResourceAdaptationProcessor::OnResourceUsageStateMeasured(
rtc::scoped_refptr<Resource> resource,
ResourceUsageState usage_state) {
@ -263,12 +245,6 @@ ResourceAdaptationProcessor::OnResourceUnderuse(
RTC_DCHECK_RUN_ON(resource_adaptation_queue_);
RTC_DCHECK(!processing_in_progress_);
processing_in_progress_ = true;
if (effective_degradation_preference_ == DegradationPreference::DISABLED) {
processing_in_progress_ = false;
return MitigationResultAndLogMessage(
MitigationResult::kDisabled,
"Not adapting up because DegradationPreference is disabled");
}
// How can this stream be adapted up?
Adaptation adaptation = stream_adapter_->GetAdaptationUp();
if (adaptation.status() != Adaptation::Status::kValid) {
@ -351,12 +327,6 @@ ResourceAdaptationProcessor::OnResourceOveruse(
RTC_DCHECK_RUN_ON(resource_adaptation_queue_);
RTC_DCHECK(!processing_in_progress_);
processing_in_progress_ = true;
if (effective_degradation_preference_ == DegradationPreference::DISABLED) {
processing_in_progress_ = false;
return MitigationResultAndLogMessage(
MitigationResult::kDisabled,
"Not adapting down because DegradationPreference is disabled");
}
// How can this stream be adapted up?
Adaptation adaptation = stream_adapter_->GetAdaptationDown();
if (adaptation.min_pixel_limit_reached()) {

15
call/adaptation/resource_adaptation_processor.h
View File

@ -27,7 +27,6 @@
#include "api/video/video_stream_encoder_observer.h"
#include "call/adaptation/adaptation_constraint.h"
#include "call/adaptation/adaptation_listener.h"
#include "call/adaptation/degradation_preference_listener.h"
#include "call/adaptation/resource_adaptation_processor_interface.h"
#include "call/adaptation/video_source_restrictions.h"
#include "call/adaptation/video_stream_adapter.h"
@ -54,8 +53,7 @@ namespace webrtc {
// i.e. the "resource adaptation task queue".
class ResourceAdaptationProcessor : public ResourceAdaptationProcessorInterface,
public VideoSourceRestrictionsListener,
public ResourceListener,
public DegradationPreferenceListener {
public ResourceListener {
public:
ResourceAdaptationProcessor(
VideoStreamEncoderObserver* encoder_stats_observer,
@ -92,9 +90,6 @@ class ResourceAdaptationProcessor : public ResourceAdaptationProcessorInterface,
const VideoAdaptationCounters& adaptation_counters,
rtc::scoped_refptr<Resource> reason,
const VideoSourceRestrictions& unfiltered_restrictions) override;
// DegradationPreferenceListener implementation.
void OnDegradationPreferenceUpdated(
DegradationPreference degradation_preference) override;
private:
// If resource usage measurements happens off the adaptation task queue, this
@ -119,7 +114,6 @@ class ResourceAdaptationProcessor : public ResourceAdaptationProcessorInterface,
};
enum class MitigationResult {
kDisabled,
kNotMostLimitedResource,
kSharedMostLimitedResource,
kRejectedByAdapter,
@ -142,10 +136,6 @@ class ResourceAdaptationProcessor : public ResourceAdaptationProcessorInterface,
MitigationResultAndLogMessage OnResourceOveruse(
rtc::scoped_refptr<Resource> reason_resource);
// Needs to be invoked any time |degradation_preference_| or |is_screenshare_|
// changes to ensure |effective_degradation_preference_| is up-to-date.
void MaybeUpdateEffectiveDegradationPreference();
void UpdateResourceLimitations(rtc::scoped_refptr<Resource> reason_resource,
const VideoSourceRestrictions& restrictions,
const VideoAdaptationCounters& counters)
@ -182,9 +172,6 @@ class ResourceAdaptationProcessor : public ResourceAdaptationProcessorInterface,
VideoStreamAdapter::RestrictionsWithCounters>
adaptation_limits_by_resources_
RTC_GUARDED_BY(resource_adaptation_queue_);
// Adaptation strategy settings.
DegradationPreference effective_degradation_preference_
RTC_GUARDED_BY(resource_adaptation_queue_);
// Responsible for generating and applying possible adaptations.
VideoStreamAdapter* const stream_adapter_
RTC_GUARDED_BY(resource_adaptation_queue_);

66
call/adaptation/resource_adaptation_processor_unittest.cc
View File

@ -163,7 +163,7 @@ TEST_F(ResourceAdaptationProcessorTest, DisabledByDefault) {
}
TEST_F(ResourceAdaptationProcessorTest, InsufficientInput) {
processor_->OnDegradationPreferenceUpdated(
video_stream_adapter_->SetDegradationPreference(
DegradationPreference::MAINTAIN_FRAMERATE);
// Adaptation does not happen if input is insufficient.
// When frame size is missing (OnFrameSizeObserved not called yet).
@ -183,7 +183,7 @@ TEST_F(ResourceAdaptationProcessorTest, InsufficientInput) {
// restrictions. For that, see video_stream_adapter_unittest.cc.
TEST_F(ResourceAdaptationProcessorTest,
OveruseTriggersRestrictingResolutionInMaintainFrameRate) {
processor_->OnDegradationPreferenceUpdated(
video_stream_adapter_->SetDegradationPreference(
DegradationPreference::MAINTAIN_FRAMERATE);
SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
resource_->SetUsageState(ResourceUsageState::kOveruse);
@ -194,7 +194,7 @@ TEST_F(ResourceAdaptationProcessorTest,
TEST_F(ResourceAdaptationProcessorTest,
OveruseTriggersRestrictingFrameRateInMaintainResolution) {
processor_->OnDegradationPreferenceUpdated(
video_stream_adapter_->SetDegradationPreference(
DegradationPreference::MAINTAIN_RESOLUTION);
SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
resource_->SetUsageState(ResourceUsageState::kOveruse);
@ -205,7 +205,8 @@ TEST_F(ResourceAdaptationProcessorTest,
TEST_F(ResourceAdaptationProcessorTest,
OveruseTriggersRestrictingFrameRateAndResolutionInBalanced) {
processor_->OnDegradationPreferenceUpdated(DegradationPreference::BALANCED);
video_stream_adapter_->SetDegradationPreference(
DegradationPreference::BALANCED);
SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
// Adapting multiple times eventually resticts both frame rate and
// resolution. Exactly many times we need to adapt depends on
@ -223,7 +224,7 @@ TEST_F(ResourceAdaptationProcessorTest,
}
TEST_F(ResourceAdaptationProcessorTest, AwaitingPreviousAdaptation) {
processor_->OnDegradationPreferenceUpdated(
video_stream_adapter_->SetDegradationPreference(
DegradationPreference::MAINTAIN_FRAMERATE);
SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
resource_->SetUsageState(ResourceUsageState::kOveruse);
@ -235,7 +236,7 @@ TEST_F(ResourceAdaptationProcessorTest, AwaitingPreviousAdaptation) {
}
TEST_F(ResourceAdaptationProcessorTest, CannotAdaptUpWhenUnrestricted) {
processor_->OnDegradationPreferenceUpdated(
video_stream_adapter_->SetDegradationPreference(
DegradationPreference::MAINTAIN_FRAMERATE);
SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
resource_->SetUsageState(ResourceUsageState::kUnderuse);
@ -243,7 +244,7 @@ TEST_F(ResourceAdaptationProcessorTest, CannotAdaptUpWhenUnrestricted) {
}
TEST_F(ResourceAdaptationProcessorTest, UnderuseTakesUsBackToUnrestricted) {
processor_->OnDegradationPreferenceUpdated(
video_stream_adapter_->SetDegradationPreference(
DegradationPreference::MAINTAIN_FRAMERATE);
SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
resource_->SetUsageState(ResourceUsageState::kOveruse);
@ -255,7 +256,7 @@ TEST_F(ResourceAdaptationProcessorTest, UnderuseTakesUsBackToUnrestricted) {
}
TEST_F(ResourceAdaptationProcessorTest, ResourcesCanPreventAdaptingUp) {
processor_->OnDegradationPreferenceUpdated(
video_stream_adapter_->SetDegradationPreference(
DegradationPreference::MAINTAIN_FRAMERATE);
SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
// Adapt down so that we can adapt up.
@ -270,7 +271,7 @@ TEST_F(ResourceAdaptationProcessorTest, ResourcesCanPreventAdaptingUp) {
TEST_F(ResourceAdaptationProcessorTest,
ResourcesCanNotAdaptUpIfNeverAdaptedDown) {
processor_->OnDegradationPreferenceUpdated(
video_stream_adapter_->SetDegradationPreference(
DegradationPreference::MAINTAIN_FRAMERATE);
SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
resource_->SetUsageState(ResourceUsageState::kOveruse);
@ -284,7 +285,7 @@ TEST_F(ResourceAdaptationProcessorTest,
TEST_F(ResourceAdaptationProcessorTest,
ResourcesCanNotAdaptUpIfNotAdaptedDownAfterReset) {
processor_->OnDegradationPreferenceUpdated(
video_stream_adapter_->SetDegradationPreference(
DegradationPreference::MAINTAIN_FRAMERATE);
SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
resource_->SetUsageState(ResourceUsageState::kOveruse);
@ -303,7 +304,7 @@ TEST_F(ResourceAdaptationProcessorTest,
}
TEST_F(ResourceAdaptationProcessorTest, OnlyMostLimitedResourceMayAdaptUp) {
processor_->OnDegradationPreferenceUpdated(
video_stream_adapter_->SetDegradationPreference(
DegradationPreference::MAINTAIN_FRAMERATE);
SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
resource_->SetUsageState(ResourceUsageState::kOveruse);
@ -333,7 +334,7 @@ TEST_F(ResourceAdaptationProcessorTest, OnlyMostLimitedResourceMayAdaptUp) {
TEST_F(ResourceAdaptationProcessorTest,
MultipleResourcesCanTriggerMultipleAdaptations) {
processor_->OnDegradationPreferenceUpdated(
video_stream_adapter_->SetDegradationPreference(
DegradationPreference::MAINTAIN_FRAMERATE);
SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
resource_->SetUsageState(ResourceUsageState::kOveruse);
@ -391,7 +392,7 @@ TEST_F(ResourceAdaptationProcessorTest,
TEST_F(ResourceAdaptationProcessorTest,
MostLimitedResourceAdaptationWorksAfterChangingDegradataionPreference) {
processor_->OnDegradationPreferenceUpdated(
video_stream_adapter_->SetDegradationPreference(
DegradationPreference::MAINTAIN_FRAMERATE);
SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
// Adapt down until we can't anymore.
@ -407,7 +408,7 @@ TEST_F(ResourceAdaptationProcessorTest,
RestrictSource(restrictions_listener_.restrictions());
int last_total = restrictions_listener_.adaptation_counters().Total();
processor_->OnDegradationPreferenceUpdated(
video_stream_adapter_->SetDegradationPreference(
DegradationPreference::MAINTAIN_RESOLUTION);
// resource_ can not adapt up since we have never reduced FPS.
resource_->SetUsageState(ResourceUsageState::kUnderuse);
@ -423,7 +424,7 @@ TEST_F(ResourceAdaptationProcessorTest,
}
TEST_F(ResourceAdaptationProcessorTest, AdaptingTriggersOnAdaptationApplied) {
processor_->OnDegradationPreferenceUpdated(
video_stream_adapter_->SetDegradationPreference(
DegradationPreference::MAINTAIN_FRAMERATE);
SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
resource_->SetUsageState(ResourceUsageState::kOveruse);
@ -432,7 +433,7 @@ TEST_F(ResourceAdaptationProcessorTest, AdaptingTriggersOnAdaptationApplied) {
TEST_F(ResourceAdaptationProcessorTest,
AdaptsDownWhenOtherResourceIsAlwaysUnderused) {
processor_->OnDegradationPreferenceUpdated(
video_stream_adapter_->SetDegradationPreference(
DegradationPreference::MAINTAIN_FRAMERATE);
SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
other_resource_->SetUsageState(ResourceUsageState::kUnderuse);
@ -453,7 +454,7 @@ TEST_F(ResourceAdaptationProcessorTest,
TEST_F(ResourceAdaptationProcessorTest,
TriggerOveruseNotOnAdaptationTaskQueue) {
processor_->OnDegradationPreferenceUpdated(
video_stream_adapter_->SetDegradationPreference(
DegradationPreference::MAINTAIN_FRAMERATE);
SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
@ -467,7 +468,7 @@ TEST_F(ResourceAdaptationProcessorTest,
TEST_F(ResourceAdaptationProcessorTest,
DestroyProcessorWhileResourceListenerDelegateHasTaskInFlight) {
processor_->OnDegradationPreferenceUpdated(
video_stream_adapter_->SetDegradationPreference(
DegradationPreference::MAINTAIN_FRAMERATE);
SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
@ -491,7 +492,7 @@ TEST_F(ResourceAdaptationProcessorTest,
TEST_F(ResourceAdaptationProcessorTest,
ResourceOveruseIgnoredWhenSignalledDuringRemoval) {
processor_->OnDegradationPreferenceUpdated(
video_stream_adapter_->SetDegradationPreference(
DegradationPreference::MAINTAIN_FRAMERATE);
SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
@ -520,7 +521,7 @@ TEST_F(ResourceAdaptationProcessorTest,
TEST_F(ResourceAdaptationProcessorTest,
RemovingOnlyAdaptedResourceResetsAdaptation) {
processor_->OnDegradationPreferenceUpdated(
video_stream_adapter_->SetDegradationPreference(
DegradationPreference::MAINTAIN_FRAMERATE);
SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
@ -537,7 +538,8 @@ TEST_F(ResourceAdaptationProcessorTest,
TEST_F(ResourceAdaptationProcessorTest,
RemovingMostLimitedResourceSetsAdaptationToNextLimitedLevel) {
processor_->OnDegradationPreferenceUpdated(DegradationPreference::BALANCED);
video_stream_adapter_->SetDegradationPreference(
DegradationPreference::BALANCED);
SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
other_resource_->SetUsageState(ResourceUsageState::kOveruse);
@ -565,7 +567,7 @@ TEST_F(ResourceAdaptationProcessorTest,
TEST_F(ResourceAdaptationProcessorTest,
RemovingMostLimitedResourceSetsAdaptationIfInputStateUnchanged) {
processor_->OnDegradationPreferenceUpdated(
video_stream_adapter_->SetDegradationPreference(
DegradationPreference::MAINTAIN_FRAMERATE);
SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
@ -602,7 +604,8 @@ TEST_F(ResourceAdaptationProcessorTest,
TEST_F(ResourceAdaptationProcessorTest,
RemovingResourceNotMostLimitedHasNoEffectOnLimitations) {
processor_->OnDegradationPreferenceUpdated(DegradationPreference::BALANCED);
video_stream_adapter_->SetDegradationPreference(
DegradationPreference::BALANCED);
SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
other_resource_->SetUsageState(ResourceUsageState::kOveruse);
@ -628,7 +631,7 @@ TEST_F(ResourceAdaptationProcessorTest,
TEST_F(ResourceAdaptationProcessorTest,
RemovingMostLimitedResourceAfterSwitchingDegradationPreferences) {
processor_->OnDegradationPreferenceUpdated(
video_stream_adapter_->SetDegradationPreference(
DegradationPreference::MAINTAIN_FRAMERATE);
SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
@ -640,7 +643,7 @@ TEST_F(ResourceAdaptationProcessorTest,
VideoAdaptationCounters next_limited_counters =
restrictions_listener_.adaptation_counters();
processor_->OnDegradationPreferenceUpdated(
video_stream_adapter_->SetDegradationPreference(
DegradationPreference::MAINTAIN_RESOLUTION);
resource_->SetUsageState(ResourceUsageState::kOveruse);
RestrictSource(restrictions_listener_.restrictions());
@ -654,7 +657,7 @@ TEST_F(ResourceAdaptationProcessorTest,
// After switching back to MAINTAIN_FRAMERATE, the next most limited settings
// are restored.
processor_->OnDegradationPreferenceUpdated(
video_stream_adapter_->SetDegradationPreference(
DegradationPreference::MAINTAIN_FRAMERATE);
EXPECT_EQ(next_limited_restrictions, restrictions_listener_.restrictions());
@ -664,7 +667,7 @@ TEST_F(ResourceAdaptationProcessorTest,
TEST_F(ResourceAdaptationProcessorTest,
RemovingMostLimitedResourceSetsNextLimitationsInDisabled) {
processor_->OnDegradationPreferenceUpdated(
video_stream_adapter_->SetDegradationPreference(
DegradationPreference::MAINTAIN_FRAMERATE);
SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
@ -679,7 +682,8 @@ TEST_F(ResourceAdaptationProcessorTest,
RestrictSource(restrictions_listener_.restrictions());
EXPECT_EQ(2, restrictions_listener_.adaptation_counters().Total());
processor_->OnDegradationPreferenceUpdated(DegradationPreference::DISABLED);
video_stream_adapter_->SetDegradationPreference(
DegradationPreference::DISABLED);
// Revert to |other_resource_| when removing |resource_| even though the
// current degradataion preference is disabled.
@ -687,7 +691,7 @@ TEST_F(ResourceAdaptationProcessorTest,
// After switching back to MAINTAIN_FRAMERATE, the next most limited settings
// are restored.
processor_->OnDegradationPreferenceUpdated(
video_stream_adapter_->SetDegradationPreference(
DegradationPreference::MAINTAIN_FRAMERATE);
EXPECT_EQ(next_limited_restrictions, restrictions_listener_.restrictions());
EXPECT_EQ(next_limited_counters,
@ -699,7 +703,7 @@ TEST_F(ResourceAdaptationProcessorTest,
TEST_F(ResourceAdaptationProcessorTest,
RemovedResourceSignalsIgnoredByProcessor) {
processor_->OnDegradationPreferenceUpdated(
video_stream_adapter_->SetDegradationPreference(
DegradationPreference::MAINTAIN_FRAMERATE);
SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
@ -713,7 +717,7 @@ TEST_F(ResourceAdaptationProcessorTest,
TEST_F(ResourceAdaptationProcessorTest,
RemovingResourceWhenMultipleMostLimtedHasNoEffect) {
processor_->OnDegradationPreferenceUpdated(
video_stream_adapter_->SetDegradationPreference(
DegradationPreference::MAINTAIN_FRAMERATE);
SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);

19
call/adaptation/video_stream_adapter.cc
View File

@ -151,6 +151,8 @@ const char* Adaptation::StatusToString(Adaptation::Status status) {
return "kAwaitingPreviousAdaptation";
case Status::kInsufficientInput:
return "kInsufficientInput";
case Status::kAdaptationDisabled:
return "kAdaptationDisabled";
}
}
@ -305,7 +307,6 @@ Adaptation VideoStreamAdapter::GetAdaptationUp(
Adaptation VideoStreamAdapter::GetAdaptationUp() {
RTC_DCHECK_RUN_ON(&sequence_checker_);
RTC_DCHECK_NE(degradation_preference_, DegradationPreference::DISABLED);
VideoStreamInputState input_state = input_state_provider_->InputState();
++adaptation_validation_id_;
Adaptation adaptation = GetAdaptationUp(input_state);
@ -348,14 +349,12 @@ VideoStreamAdapter::RestrictionsOrState VideoStreamAdapter::GetAdaptationUpStep(
return IncreaseFramerate(input_state, current_restrictions_);
}
case DegradationPreference::DISABLED:
RTC_NOTREACHED();
return Adaptation::Status::kLimitReached;
return Adaptation::Status::kAdaptationDisabled;
}
}
Adaptation VideoStreamAdapter::GetAdaptationDown() {
RTC_DCHECK_RUN_ON(&sequence_checker_);
RTC_DCHECK_NE(degradation_preference_, DegradationPreference::DISABLED);
VideoStreamInputState input_state = input_state_provider_->InputState();
++adaptation_validation_id_;
return RestrictionsOrStateToAdaptation(GetAdaptationDownStep(input_state),
@ -397,8 +396,7 @@ VideoStreamAdapter::GetAdaptationDownStep(
return DecreaseFramerate(input_state, current_restrictions_);
}
case DegradationPreference::DISABLED:
RTC_NOTREACHED();
return Adaptation::Status::kLimitReached;
return Adaptation::Status::kAdaptationDisabled;
}
}
@ -526,10 +524,11 @@ Adaptation VideoStreamAdapter::GetAdaptDownResolution() {
VideoStreamInputState input_state = input_state_provider_->InputState();
switch (degradation_preference_) {
case DegradationPreference::DISABLED:
case DegradationPreference::MAINTAIN_RESOLUTION: {
return Adaptation(adaptation_validation_id_,
Adaptation::Status::kLimitReached, input_state, false);
}
return RestrictionsOrStateToAdaptation(
Adaptation::Status::kAdaptationDisabled, input_state);
case DegradationPreference::MAINTAIN_RESOLUTION:
return RestrictionsOrStateToAdaptation(Adaptation::Status::kLimitReached,
input_state);
case DegradationPreference::MAINTAIN_FRAMERATE:
return GetAdaptationDown();
case DegradationPreference::BALANCED: {

2
call/adaptation/video_stream_adapter.h
View File

@ -74,6 +74,8 @@ class Adaptation final {
kAwaitingPreviousAdaptation,
// Not enough input.
kInsufficientInput,
// Adaptation disabled via degradation preference.
kAdaptationDisabled,
};
static const char* StatusToString(Status status);

22
call/adaptation/video_stream_adapter_unittest.cc
View File

@ -794,15 +794,14 @@ TEST_F(VideoStreamAdapterTest,
EXPECT_EQ(0, adaptation.counters().fps_adaptations);
}
TEST_F(
VideoStreamAdapterTest,
GetAdaptDownResolutionReturnsLimitReachedInDisabledAndMaintainResolution) {
TEST_F(VideoStreamAdapterTest,
GetAdaptDownResolutionReturnsWithStatusInDisabledAndMaintainResolution) {
adapter_.SetDegradationPreference(DegradationPreference::DISABLED);
input_state_provider_.SetInputState(1280 * 720, 30,
kDefaultMinPixelsPerFrame);
EXPECT_EQ(Adaptation::Status::kLimitReached,
EXPECT_EQ(Adaptation::Status::kAdaptationDisabled,
adapter_.GetAdaptDownResolution().status());
adapter_.SetDegradationPreference(DegradationPreference::DISABLED);
adapter_.SetDegradationPreference(DegradationPreference::MAINTAIN_RESOLUTION);
EXPECT_EQ(Adaptation::Status::kLimitReached,
adapter_.GetAdaptDownResolution().status());
}
@ -858,6 +857,19 @@ TEST_F(VideoStreamAdapterTest,
EXPECT_EQ(1, adaptation.counters().fps_adaptations);
}
TEST_F(VideoStreamAdapterTest,
AdaptationDisabledStatusAlwaysWhenDegradationPreferenceDisabled) {
adapter_.SetDegradationPreference(DegradationPreference::DISABLED);
input_state_provider_.SetInputState(1280 * 720, 30,
kDefaultMinPixelsPerFrame);
EXPECT_EQ(Adaptation::Status::kAdaptationDisabled,
adapter_.GetAdaptationDown().status());
EXPECT_EQ(Adaptation::Status::kAdaptationDisabled,
adapter_.GetAdaptationUp().status());
EXPECT_EQ(Adaptation::Status::kAdaptationDisabled,
adapter_.GetAdaptDownResolution().status());
}
// Death tests.
// Disabled on Android because death tests misbehave on Android, see
// base/test/gtest_util.h.

53
video/video_stream_encoder.cc
View File

@ -19,6 +19,8 @@
#include "absl/algorithm/container.h"
#include "absl/types/optional.h"
#include "api/task_queue/queued_task.h"
#include "api/task_queue/task_queue_base.h"
#include "api/video/encoded_image.h"
#include "api/video/i420_buffer.h"
#include "api/video/video_adaptation_reason.h"
@ -26,15 +28,19 @@
#include "api/video/video_codec_constants.h"
#include "api/video_codecs/video_encoder.h"
#include "call/adaptation/resource_adaptation_processor.h"
#include "call/adaptation/video_stream_adapter.h"
#include "modules/video_coding/codecs/vp9/svc_rate_allocator.h"
#include "modules/video_coding/include/video_codec_initializer.h"
#include "rtc_base/arraysize.h"
#include "rtc_base/checks.h"
#include "rtc_base/constructor_magic.h"
#include "rtc_base/experiments/alr_experiment.h"
#include "rtc_base/experiments/rate_control_settings.h"
#include "rtc_base/location.h"
#include "rtc_base/logging.h"
#include "rtc_base/strings/string_builder.h"
#include "rtc_base/synchronization/sequence_checker.h"
#include "rtc_base/thread_annotations.h"
#include "rtc_base/time_utils.h"
#include "rtc_base/trace_event.h"
#include "system_wrappers/include/field_trial.h"
@ -209,7 +215,9 @@ class VideoStreamEncoder::DegradationPreferenceManager
is_screenshare_(false),
effective_degradation_preference_(DegradationPreference::DISABLED) {}
~DegradationPreferenceManager() override { RTC_DCHECK(listeners_.empty()); }
~DegradationPreferenceManager() override {
RTC_DCHECK(!video_stream_adapter_);
}
DegradationPreference degradation_preference() const override {
rtc::CritScope crit(&lock_);
@ -228,17 +236,17 @@ class VideoStreamEncoder::DegradationPreferenceManager
MaybeUpdateEffectiveDegradationPreference();
}
void AddListener(DegradationPreferenceListener* listener) {
rtc::CritScope crit(&lock_);
RTC_DCHECK(absl::c_find(listeners_, listener) == listeners_.end());
listeners_.push_back(listener);
void SetVideoStreamAdapterQueue(
TaskQueueBase* video_stream_adapter_task_queue) {
RTC_DCHECK(!video_stream_adapter_task_queue_);
RTC_DCHECK(video_stream_adapter_task_queue);
RTC_DCHECK_RUN_ON(video_stream_adapter_task_queue);
video_stream_adapter_task_queue_ = video_stream_adapter_task_queue;
}
void RemoveListener(DegradationPreferenceListener* listener) {
rtc::CritScope crit(&lock_);
auto it = absl::c_find(listeners_, listener);
RTC_DCHECK(it != listeners_.end());
listeners_.erase(it);
void SetVideoStreamAdapter(VideoStreamAdapter* video_stream_adapter) {
RTC_DCHECK_RUN_ON(video_stream_adapter_task_queue_);
video_stream_adapter_ = video_stream_adapter;
}
private:
@ -252,9 +260,15 @@ class VideoStreamEncoder::DegradationPreferenceManager
if (effective_degradation_preference != effective_degradation_preference_) {
effective_degradation_preference_ = effective_degradation_preference;
for (auto& listener : listeners_) {
listener->OnDegradationPreferenceUpdated(
effective_degradation_preference_);
if (video_stream_adapter_task_queue_) {
video_stream_adapter_task_queue_->PostTask(
ToQueuedTask([this, effective_degradation_preference]() {
RTC_DCHECK_RUN_ON(video_stream_adapter_task_queue_);
if (video_stream_adapter_) {
video_stream_adapter_->SetDegradationPreference(
effective_degradation_preference);
}
}));
}
}
}
@ -264,7 +278,9 @@ class VideoStreamEncoder::DegradationPreferenceManager
bool is_screenshare_ RTC_GUARDED_BY(&lock_);
DegradationPreference effective_degradation_preference_
RTC_GUARDED_BY(&lock_);
std::vector<DegradationPreferenceListener*> listeners_ RTC_GUARDED_BY(&lock_);
TaskQueueBase* video_stream_adapter_task_queue_ = nullptr;
VideoStreamAdapter* video_stream_adapter_
RTC_GUARDED_BY(&video_stream_adapter_task_queue_);
};
VideoStreamEncoder::VideoStreamEncoder(
@ -363,8 +379,10 @@ VideoStreamEncoder::VideoStreamEncoder(
&stream_resource_manager_);
video_stream_adapter_->AddRestrictionsListener(&stream_resource_manager_);
video_stream_adapter_->AddRestrictionsListener(this);
degradation_preference_manager_->AddListener(
resource_adaptation_processor_.get());
degradation_preference_manager_->SetVideoStreamAdapterQueue(
resource_adaptation_queue_.Get());
degradation_preference_manager_->SetVideoStreamAdapter(
video_stream_adapter_.get());
// Add the stream resource manager's resources to the processor.
adaptation_constraints_ = stream_resource_manager_.AdaptationConstraints();
@ -413,8 +431,7 @@ void VideoStreamEncoder::Stop() {
resource_adaptation_processor_->RemoveResourceLimitationsListener(
&stream_resource_manager_);
stream_resource_manager_.SetAdaptationProcessor(nullptr, nullptr);
degradation_preference_manager_->RemoveListener(
resource_adaptation_processor_.get());
degradation_preference_manager_->SetVideoStreamAdapter(nullptr);
resource_adaptation_processor_.reset();
}
shutdown_adaptation_processor_event.Set();