commit 4d430ba7811074133f558f10ccbaaced9bc55e80
parent 5e71af26df2234615d7f9c1c511bb8d1b03ecd59
Author: Dan Baker <dbaker@mozilla.com>
Date: Tue, 2 Dec 2025 00:07:09 -0700
Bug 2000941 - Vendor libwebrtc from 928102e64d
Upstream commit: https://webrtc.googlesource.com/src/+/928102e64d3c6a7355e5e0e264701d804e54dbf1
Add ability to toggle PixelLimitResource "on" and "off" periodically.
PixelLimitResource is a testing-only resource that influences adaptation
by periodically signaling kOveruse (= "adapt down please") and kUnderuse
(= "adapt up please") in order to try to achieve a target resolution
(expressed as pixel count). The old way to enable it was, for example:
--force-fieldtrials=WebRTC-PixelLimitResource/Enabled-230400/
This CL parameterizes it and adds a new parameters, for example:
--force-fieldtrials=WebRTC-PixelLimitResource/
target_pixels:230400,interval:1s,toggle:5s/
Explanation:
- target_pixels: Is the target pixel count, same as the old behavior.
- interval: The interval at which to check if kOveruse/kUnderuse needs
to be reported. This was previously hard-coded to 5s but by allowing
overriding this value you can make the resource faster or slower.
- toggle: If specified, toggles "on" or "off" at this interval. If not
specified we don't toggle which was the old behavior.
By toggling we can test not just what happens when we adapt down, but
also that we can recover once a resource is no longer overused.
In addition to unit tests, also tested manually at
https://henbos.github.io/codec-quality/src/index.html using parameters
"target_pixels:64800,interval:1s,toggle:10s". Result is rapidly
toggling between QVGA (cpu-limited) and HD (no adaptation) every 10s.
Bug: webrtc:447037084
Change-Id: I56fe4a9c14abf38de55b4b631f401ca84656a094
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/411581
Reviewed-by: Guido Urdaneta <guidou@webrtc.org>
Commit-Queue: Henrik Boström <hbos@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#45727}
Diffstat:
7 files changed, 216 insertions(+), 103 deletions(-)
diff --git a/third_party/libwebrtc/README.mozilla.last-vendor b/third_party/libwebrtc/README.mozilla.last-vendor
@@ -1,4 +1,4 @@
# ./mach python dom/media/webrtc/third_party_build/vendor-libwebrtc.py --from-local /Users/danielbaker/elm/.moz-fast-forward/moz-libwebrtc --commit mozpatches libwebrtc
-libwebrtc updated from /Users/danielbaker/elm/.moz-fast-forward/moz-libwebrtc commit mozpatches on 2025-12-02T07:04:37.889536+00:00.
+libwebrtc updated from /Users/danielbaker/elm/.moz-fast-forward/moz-libwebrtc commit mozpatches on 2025-12-02T07:06:55.460672+00:00.
# base of lastest vendoring
-1d37b71540
+928102e64d
diff --git a/third_party/libwebrtc/video/adaptation/BUILD.gn b/third_party/libwebrtc/video/adaptation/BUILD.gn
@@ -90,6 +90,7 @@ if (rtc_include_tests) {
":video_adaptation",
"..:video_stream_encoder_interface",
"../../api:array_view",
+ "../../api:field_trials",
"../../api:field_trials_view",
"../../api:rtp_parameters",
"../../api:scoped_refptr",
@@ -119,6 +120,7 @@ if (rtc_include_tests) {
"../../rtc_base:timeutils",
"../../system_wrappers",
"../../test:create_test_environment",
+ "../../test:create_test_field_trials",
"../../test:rtc_expect_death",
"../../test:test_support",
"../../test/time_controller",
diff --git a/third_party/libwebrtc/video/adaptation/pixel_limit_resource.cc b/third_party/libwebrtc/video/adaptation/pixel_limit_resource.cc
@@ -11,8 +11,10 @@
#include "video/adaptation/pixel_limit_resource.h"
#include <optional>
+#include <string>
#include "api/adaptation/resource.h"
+#include "api/field_trials_view.h"
#include "api/make_ref_counted.h"
#include "api/scoped_refptr.h"
#include "api/sequence_checker.h"
@@ -21,29 +23,91 @@
#include "call/adaptation/video_stream_adapter.h"
#include "call/adaptation/video_stream_input_state_provider.h"
#include "rtc_base/checks.h"
+#include "rtc_base/experiments/field_trial_parser.h"
+#include "rtc_base/logging.h"
#include "rtc_base/task_utils/repeating_task.h"
namespace webrtc {
namespace {
-constexpr TimeDelta kResourceUsageCheckIntervalMs = TimeDelta::Seconds(5);
+// How to enable the PixelLimitResource, example:
+// --force-fieldtrials=WebRTC-PixelLimitResource/target_pixels:230400,
+// interval:5s,toggle:5s/
+//
+// "target_pixels" is the encoder input video size (e.g. 640x360 = 230400) that
+// the PixelLimitResource will try to achieve by signaling kOveruse or kUnderuse
+// whenever the current input pixel count is too high or too low relative to
+// this. Defaults to 0.
+//
+// "interval" is the interval at which PixelLimitResource checks whether it
+// it should report kOveruse or kUnderuse, impacting how quickly adaptation
+// converges on the target. Defaults to 5s.
+//
+// If "toggle" is specified, then PixelLimitResource will turn "on" and "off"
+// every specified amount of time. By turning "off" we mean that it will
+// repeatedly signal kUnderuse as to remove any existing adaptation pressure.
+// If not specified the PixelLimitResource is always "on".
+struct PixelLimitResourceParams {
+ static std::optional<PixelLimitResourceParams> Parse(
+ const FieldTrialsView& field_trials) {
+ std::string params_str = field_trials.Lookup("WebRTC-PixelLimitResource");
+ if (params_str.empty()) {
+ return std::nullopt;
+ }
+ PixelLimitResourceParams params;
+ ParseFieldTrial({¶ms.target_pixels, ¶ms.interval, ¶ms.toggle},
+ params_str);
+ return params;
+ }
+
+ PixelLimitResourceParams()
+ : target_pixels("target_pixels", 0),
+ interval("interval", TimeDelta::Seconds(5)),
+ toggle("toggle") {}
+
+ FieldTrialParameter<int> target_pixels;
+ FieldTrialParameter<TimeDelta> interval;
+ FieldTrialOptional<TimeDelta> toggle;
+};
} // namespace
// static
-scoped_refptr<PixelLimitResource> PixelLimitResource::Create(
+scoped_refptr<PixelLimitResource> PixelLimitResource::CreateIfFieldTrialEnabled(
+ const FieldTrialsView& field_trials,
TaskQueueBase* task_queue,
VideoStreamInputStateProvider* input_state_provider) {
- return make_ref_counted<PixelLimitResource>(task_queue, input_state_provider);
+ std::optional<PixelLimitResourceParams> params =
+ PixelLimitResourceParams::Parse(field_trials);
+ if (!params.has_value()) {
+ return nullptr;
+ }
+ auto pixel_limit_resource = make_ref_counted<PixelLimitResource>(
+ task_queue, input_state_provider, params->target_pixels.Get(),
+ params->interval.Get(), params->toggle.GetOptional());
+ RTC_LOG(LS_INFO) << "Running with PixelLimitResource {target_pixels:"
+ << params->target_pixels.Get()
+ << ", interval: " << params->interval.Get() << ", toggle:"
+ << (params->toggle ? ToString(*params->toggle)
+ : std::string("N/A"))
+ << "}";
+ return pixel_limit_resource;
}
PixelLimitResource::PixelLimitResource(
TaskQueueBase* task_queue,
- VideoStreamInputStateProvider* input_state_provider)
+ VideoStreamInputStateProvider* input_state_provider,
+ int target_pixels,
+ TimeDelta interval,
+ std::optional<TimeDelta> toggle_interval)
: task_queue_(task_queue),
input_state_provider_(input_state_provider),
- max_pixels_(std::nullopt) {
+ target_pixels_(target_pixels),
+ interval_(interval),
+ toggle_interval_(toggle_interval),
+ is_enabled_(true),
+ time_since_last_toggle_(TimeDelta::Zero()) {
RTC_DCHECK(task_queue_);
RTC_DCHECK(input_state_provider_);
}
@@ -53,51 +117,57 @@ PixelLimitResource::~PixelLimitResource() {
RTC_DCHECK(!repeating_task_.Running());
}
-void PixelLimitResource::SetMaxPixels(int max_pixels) {
- RTC_DCHECK_RUN_ON(task_queue_);
- max_pixels_ = max_pixels;
-}
-
void PixelLimitResource::SetResourceListener(ResourceListener* listener) {
RTC_DCHECK_RUN_ON(task_queue_);
listener_ = listener;
if (listener_) {
repeating_task_.Stop();
- repeating_task_ = RepeatingTaskHandle::Start(task_queue_, [&] {
- RTC_DCHECK_RUN_ON(task_queue_);
- if (!listener_) {
- // We don't have a listener so resource adaptation must not be running,
- // try again later.
- return kResourceUsageCheckIntervalMs;
- }
- if (!max_pixels_.has_value()) {
- // No pixel limit configured yet, try again later.
- return kResourceUsageCheckIntervalMs;
- }
- std::optional<int> frame_size_pixels =
- input_state_provider_->InputState().frame_size_pixels();
- if (!frame_size_pixels.has_value()) {
- // We haven't observed a frame yet so we don't know if it's going to be
- // too big or too small, try again later.
- return kResourceUsageCheckIntervalMs;
- }
- int current_pixels = frame_size_pixels.value();
- int target_pixel_upper_bounds = max_pixels_.value();
- // To avoid toggling, we allow any resolutions between
- // `target_pixel_upper_bounds` and video_stream_adapter.h's
- // GetLowerResolutionThan(). This is the pixels we end up if we adapt down
- // from `target_pixel_upper_bounds`.
- int target_pixels_lower_bounds =
- GetLowerResolutionThan(target_pixel_upper_bounds);
- if (current_pixels > target_pixel_upper_bounds) {
- listener_->OnResourceUsageStateMeasured(scoped_refptr<Resource>(this),
- ResourceUsageState::kOveruse);
- } else if (current_pixels < target_pixels_lower_bounds) {
- listener_->OnResourceUsageStateMeasured(scoped_refptr<Resource>(this),
- ResourceUsageState::kUnderuse);
- }
- return kResourceUsageCheckIntervalMs;
- });
+ repeating_task_ =
+ RepeatingTaskHandle::DelayedStart(task_queue_, interval_, [&] {
+ RTC_DCHECK_RUN_ON(task_queue_);
+ if (!listener_) {
+ // We don't have a listener so resource adaptation must not be
+ // running, try again later.
+ return interval_;
+ }
+ if (is_enabled_) {
+ // When "enabled", we try to influence the input pixels to gravitate
+ // towards our `target_pixels_`. NO-OP if we don't know current
+ // pixels.
+ std::optional<int> current_pixels =
+ input_state_provider_->InputState().frame_size_pixels();
+ if (current_pixels.has_value()) {
+ // Use lower bounds that is one step lower than `target_pixels_`
+ // to avoid risk of flip-flopping up and down.
+ int target_pixels_lower_bounds =
+ GetLowerResolutionThan(target_pixels_);
+ if (*current_pixels > target_pixels_) {
+ listener_->OnResourceUsageStateMeasured(
+ scoped_refptr<Resource>(this),
+ ResourceUsageState::kOveruse);
+ } else if (*current_pixels < target_pixels_lower_bounds) {
+ listener_->OnResourceUsageStateMeasured(
+ scoped_refptr<Resource>(this),
+ ResourceUsageState::kUnderuse);
+ }
+ }
+ } else {
+ // When "disabled", we always signal kUnderuse.
+ listener_->OnResourceUsageStateMeasured(
+ scoped_refptr<Resource>(this), ResourceUsageState::kUnderuse);
+ }
+ // Maybe toggle "on" or "off".
+ if (toggle_interval_.has_value()) {
+ time_since_last_toggle_ += interval_;
+ if (time_since_last_toggle_ >= toggle_interval_.value()) {
+ is_enabled_ = !is_enabled_;
+ RTC_LOG(LS_INFO) << "PixelLimitResource toggled "
+ << (is_enabled_ ? "on" : "off");
+ time_since_last_toggle_ = TimeDelta::Zero();
+ }
+ }
+ return interval_;
+ });
} else {
repeating_task_.Stop();
}
diff --git a/third_party/libwebrtc/video/adaptation/pixel_limit_resource.h b/third_party/libwebrtc/video/adaptation/pixel_limit_resource.h
@@ -15,8 +15,10 @@
#include <string>
#include "api/adaptation/resource.h"
+#include "api/field_trials_view.h"
#include "api/scoped_refptr.h"
#include "api/task_queue/task_queue_base.h"
+#include "api/units/time_delta.h"
#include "call/adaptation/video_stream_input_state_provider.h"
#include "rtc_base/task_utils/repeating_task.h"
#include "rtc_base/thread_annotations.h"
@@ -34,16 +36,18 @@ namespace webrtc {
// purposes.
class PixelLimitResource : public Resource {
public:
- static scoped_refptr<PixelLimitResource> Create(
+ static scoped_refptr<PixelLimitResource> CreateIfFieldTrialEnabled(
+ const FieldTrialsView& field_trials,
TaskQueueBase* task_queue,
VideoStreamInputStateProvider* input_state_provider);
PixelLimitResource(TaskQueueBase* task_queue,
- VideoStreamInputStateProvider* input_state_provider);
+ VideoStreamInputStateProvider* input_state_provider,
+ int target_pixels,
+ TimeDelta interval,
+ std::optional<TimeDelta> duration);
~PixelLimitResource() override;
- void SetMaxPixels(int max_pixels);
-
// Resource implementation.
std::string Name() const override { return "PixelLimitResource"; }
void SetResourceListener(ResourceListener* listener) override;
@@ -51,7 +55,12 @@ class PixelLimitResource : public Resource {
private:
TaskQueueBase* const task_queue_;
VideoStreamInputStateProvider* const input_state_provider_;
- std::optional<int> max_pixels_ RTC_GUARDED_BY(task_queue_);
+ const int target_pixels_;
+ const TimeDelta interval_;
+ const std::optional<TimeDelta> toggle_interval_;
+ // If `toggle_interval_` was specified, we cyclically toggle "on" or "off".
+ bool is_enabled_ RTC_GUARDED_BY(task_queue_);
+ TimeDelta time_since_last_toggle_ RTC_GUARDED_BY(task_queue_);
ResourceListener* listener_ RTC_GUARDED_BY(task_queue_);
RepeatingTaskHandle repeating_task_ RTC_GUARDED_BY(task_queue_);
};
diff --git a/third_party/libwebrtc/video/adaptation/pixel_limit_resource_unittest.cc b/third_party/libwebrtc/video/adaptation/pixel_limit_resource_unittest.cc
@@ -11,10 +11,12 @@
#include "video/adaptation/pixel_limit_resource.h"
#include <memory>
+#include <string>
#include <utility>
#include "absl/functional/any_invocable.h"
#include "api/adaptation/resource.h"
+#include "api/field_trials.h"
#include "api/scoped_refptr.h"
#include "api/task_queue/task_queue_base.h"
#include "api/task_queue/task_queue_factory.h"
@@ -23,6 +25,7 @@
#include "call/adaptation/test/fake_video_stream_input_state_provider.h"
#include "call/adaptation/test/mock_resource_listener.h"
#include "call/adaptation/video_stream_adapter.h"
+#include "test/create_test_field_trials.h"
#include "test/gmock.h"
#include "test/gtest.h"
#include "test/time_controller/simulated_time_controller.h"
@@ -33,7 +36,7 @@ namespace webrtc {
namespace {
-constexpr TimeDelta kResourceUsageCheckIntervalMs = TimeDelta::Seconds(5);
+constexpr TimeDelta kInterval = TimeDelta::Seconds(1);
} // namespace
@@ -52,7 +55,6 @@ class PixelLimitResourceTest : public ::testing::Test {
void RunTaskOnTaskQueue(absl::AnyInvocable<void() &&> task) {
task_queue_->PostTask(std::move(task));
- time_controller_.AdvanceTime(TimeDelta::Zero());
}
protected:
@@ -63,18 +65,29 @@ class PixelLimitResourceTest : public ::testing::Test {
FakeVideoStreamInputStateProvider input_state_provider_;
};
-TEST_F(PixelLimitResourceTest, ResourceIsSilentByDefault) {
+TEST_F(PixelLimitResourceTest, ResourceNotCreatedIfFieldTrialMissing) {
+ FieldTrials field_trials = CreateTestFieldTrials("");
+ EXPECT_FALSE(PixelLimitResource::CreateIfFieldTrialEnabled(
+ field_trials, task_queue_.get(), &input_state_provider_));
+}
+
+TEST_F(PixelLimitResourceTest,
+ NothingIsReportedWhileCurrentPixelsIsMissingOrEqualToMaxPixels) {
+ constexpr int kMaxPixels = 640 * 480;
+ FieldTrials field_trials = CreateTestFieldTrials(
+ "WebRTC-PixelLimitResource/target_pixels:" + std::to_string(kMaxPixels) +
+ ",interval:" + ToString(kInterval) + "/");
// Because our mock is strick, the test would fail if
// OnResourceUsageStateMeasured() is invoked.
testing::StrictMock<MockResourceListener> resource_listener;
RunTaskOnTaskQueue([&]() {
- scoped_refptr<PixelLimitResource> pixel_limit_resource =
- PixelLimitResource::Create(task_queue_.get(), &input_state_provider_);
+ auto pixel_limit_resource = PixelLimitResource::CreateIfFieldTrialEnabled(
+ field_trials, task_queue_.get(), &input_state_provider_);
+ ASSERT_TRUE(pixel_limit_resource);
pixel_limit_resource->SetResourceListener(&resource_listener);
- // Set a current pixel count.
- SetCurrentPixels(1280 * 720);
- // Advance a significant amount of time.
- time_controller_.AdvanceTime(kResourceUsageCheckIntervalMs * 10);
+ time_controller_.AdvanceTime(kInterval * 10);
+ SetCurrentPixels(kMaxPixels);
+ time_controller_.AdvanceTime(kInterval * 10);
pixel_limit_resource->SetResourceListener(nullptr);
});
}
@@ -82,32 +95,34 @@ TEST_F(PixelLimitResourceTest, ResourceIsSilentByDefault) {
TEST_F(PixelLimitResourceTest,
OveruseIsReportedWhileCurrentPixelsIsGreaterThanMaxPixels) {
constexpr int kMaxPixels = 640 * 480;
+ FieldTrials field_trials = CreateTestFieldTrials(
+ "WebRTC-PixelLimitResource/target_pixels:" + std::to_string(kMaxPixels) +
+ ",interval:" + ToString(kInterval) + "/");
testing::StrictMock<MockResourceListener> resource_listener;
RunTaskOnTaskQueue([&]() {
- scoped_refptr<PixelLimitResource> pixel_limit_resource =
- PixelLimitResource::Create(task_queue_.get(), &input_state_provider_);
+ auto pixel_limit_resource = PixelLimitResource::CreateIfFieldTrialEnabled(
+ field_trials, task_queue_.get(), &input_state_provider_);
+ ASSERT_TRUE(pixel_limit_resource);
pixel_limit_resource->SetResourceListener(&resource_listener);
- time_controller_.AdvanceTime(TimeDelta::Zero());
- pixel_limit_resource->SetMaxPixels(kMaxPixels);
SetCurrentPixels(kMaxPixels + 1);
EXPECT_CALL(resource_listener,
OnResourceUsageStateMeasured(_, ResourceUsageState::kOveruse))
.Times(1);
- time_controller_.AdvanceTime(kResourceUsageCheckIntervalMs);
+ time_controller_.AdvanceTime(kInterval);
// As long as the current pixels has not updated, the overuse signal is
// repeated at a fixed interval.
EXPECT_CALL(resource_listener,
OnResourceUsageStateMeasured(_, ResourceUsageState::kOveruse))
.Times(3);
- time_controller_.AdvanceTime(kResourceUsageCheckIntervalMs * 3);
+ time_controller_.AdvanceTime(kInterval * 3);
// When the overuse signal has resulted in a lower resolution, the overuse
// signals stops.
SetCurrentPixels(kMaxPixels);
EXPECT_CALL(resource_listener, OnResourceUsageStateMeasured(_, _)).Times(0);
- time_controller_.AdvanceTime(kResourceUsageCheckIntervalMs * 3);
+ time_controller_.AdvanceTime(kInterval * 3);
pixel_limit_resource->SetResourceListener(nullptr);
});
@@ -116,33 +131,74 @@ TEST_F(PixelLimitResourceTest,
TEST_F(PixelLimitResourceTest,
UnderuseIsReportedWhileCurrentPixelsIsLessThanMinPixels) {
constexpr int kMaxPixels = 640 * 480;
+ FieldTrials field_trials = CreateTestFieldTrials(
+ "WebRTC-PixelLimitResource/target_pixels:" + std::to_string(kMaxPixels) +
+ ",interval:" + ToString(kInterval) + "/");
const int kMinPixels = GetLowerResolutionThan(kMaxPixels);
testing::StrictMock<MockResourceListener> resource_listener;
RunTaskOnTaskQueue([&]() {
- scoped_refptr<PixelLimitResource> pixel_limit_resource =
- PixelLimitResource::Create(task_queue_.get(), &input_state_provider_);
+ auto pixel_limit_resource = PixelLimitResource::CreateIfFieldTrialEnabled(
+ field_trials, task_queue_.get(), &input_state_provider_);
+ ASSERT_TRUE(pixel_limit_resource);
pixel_limit_resource->SetResourceListener(&resource_listener);
- time_controller_.AdvanceTime(TimeDelta::Zero());
- pixel_limit_resource->SetMaxPixels(kMaxPixels);
SetCurrentPixels(kMinPixels - 1);
EXPECT_CALL(resource_listener,
OnResourceUsageStateMeasured(_, ResourceUsageState::kUnderuse))
.Times(1);
- time_controller_.AdvanceTime(kResourceUsageCheckIntervalMs);
+ time_controller_.AdvanceTime(kInterval);
// As long as the current pixels has not updated, the underuse signal is
// repeated at a fixed interval.
EXPECT_CALL(resource_listener,
OnResourceUsageStateMeasured(_, ResourceUsageState::kUnderuse))
.Times(3);
- time_controller_.AdvanceTime(kResourceUsageCheckIntervalMs * 3);
+ time_controller_.AdvanceTime(kInterval * 3);
// When the underuse signal has resulted in a higher resolution, the
// underuse signals stops.
SetCurrentPixels(kMinPixels);
EXPECT_CALL(resource_listener, OnResourceUsageStateMeasured(_, _)).Times(0);
- time_controller_.AdvanceTime(kResourceUsageCheckIntervalMs * 3);
+ time_controller_.AdvanceTime(kInterval * 3);
+
+ pixel_limit_resource->SetResourceListener(nullptr);
+ });
+}
+
+TEST_F(PixelLimitResourceTest, PeriodicallyAdaptsUpWhenToggling) {
+ constexpr int kMaxPixels = 640 * 360;
+ constexpr TimeDelta kToggleInterval = kInterval * 2;
+ FieldTrials field_trials = CreateTestFieldTrials(
+ "WebRTC-PixelLimitResource/target_pixels:" + std::to_string(kMaxPixels) +
+ ",interval:" + ToString(kInterval) +
+ ",toggle:" + ToString(kToggleInterval) + "/");
+ testing::StrictMock<MockResourceListener> resource_listener;
+ RunTaskOnTaskQueue([&]() {
+ auto pixel_limit_resource = PixelLimitResource::CreateIfFieldTrialEnabled(
+ field_trials, task_queue_.get(), &input_state_provider_);
+ ASSERT_TRUE(pixel_limit_resource);
+ pixel_limit_resource->SetResourceListener(&resource_listener);
+ SetCurrentPixels(1280 * 720);
+
+ // Since kToggleInterval is kInterval * 2, we should see two signals per
+ // toggle.
+ EXPECT_CALL(resource_listener,
+ OnResourceUsageStateMeasured(_, ResourceUsageState::kOveruse))
+ .Times(2);
+ time_controller_.AdvanceTime(kToggleInterval);
+ EXPECT_CALL(resource_listener,
+ OnResourceUsageStateMeasured(_, ResourceUsageState::kUnderuse))
+ .Times(2);
+ time_controller_.AdvanceTime(kToggleInterval);
+ EXPECT_CALL(resource_listener,
+ OnResourceUsageStateMeasured(_, ResourceUsageState::kOveruse))
+ .Times(2);
+ time_controller_.AdvanceTime(kToggleInterval);
+ EXPECT_CALL(resource_listener,
+ OnResourceUsageStateMeasured(_, ResourceUsageState::kUnderuse))
+ .Times(2);
+ time_controller_.AdvanceTime(kToggleInterval);
+ // And so on...
pixel_limit_resource->SetResourceListener(nullptr);
});
diff --git a/third_party/libwebrtc/video/adaptation/video_stream_encoder_resource_manager.cc b/third_party/libwebrtc/video/adaptation/video_stream_encoder_resource_manager.cc
@@ -69,9 +69,6 @@ const int kDefaultInputPixelsHeight = 144;
namespace {
-constexpr const char* kPixelLimitResourceFieldTrialName =
- "WebRTC-PixelLimitResource";
-
bool IsResolutionScalingEnabled(DegradationPreference degradation_preference) {
return degradation_preference == DegradationPreference::MAINTAIN_FRAMERATE ||
degradation_preference == DegradationPreference::BALANCED;
@@ -297,8 +294,6 @@ VideoStreamEncoderResourceManager::VideoStreamEncoderResourceManager(
field_trials)),
quality_scaling_experiment_enabled_(
QualityScalingExperiment::Enabled(field_trials_)),
- pixel_limit_resource_experiment_enabled_(
- field_trials.IsEnabled(kPixelLimitResourceFieldTrialName)),
encoder_target_bitrate_bps_(std::nullopt),
encoder_settings_(std::nullopt) {
TRACE_EVENT0(
@@ -358,28 +353,11 @@ void VideoStreamEncoderResourceManager::MaybeInitializePixelLimitResource() {
RTC_DCHECK_RUN_ON(encoder_queue_);
RTC_DCHECK(adaptation_processor_);
RTC_DCHECK(!pixel_limit_resource_);
- if (!pixel_limit_resource_experiment_enabled_) {
- // The field trial is not running.
- return;
- }
- int max_pixels = 0;
- std::string pixel_limit_field_trial =
- field_trials_.Lookup(kPixelLimitResourceFieldTrialName);
- if (sscanf(pixel_limit_field_trial.c_str(), "Enabled-%d", &max_pixels) != 1) {
- RTC_LOG(LS_ERROR) << "Couldn't parse " << kPixelLimitResourceFieldTrialName
- << " trial config: " << pixel_limit_field_trial;
- return;
+ pixel_limit_resource_ = PixelLimitResource::CreateIfFieldTrialEnabled(
+ field_trials_, encoder_queue_, input_state_provider_);
+ if (pixel_limit_resource_) {
+ AddResource(pixel_limit_resource_, VideoAdaptationReason::kCpu);
}
- RTC_LOG(LS_INFO) << "Running field trial "
- << kPixelLimitResourceFieldTrialName << " configured to "
- << max_pixels << " max pixels";
- // Configure the specified max pixels from the field trial. The pixel limit
- // resource is active for the lifetme of the stream (until
- // StopManagedResources() is called).
- pixel_limit_resource_ =
- PixelLimitResource::Create(encoder_queue_, input_state_provider_);
- pixel_limit_resource_->SetMaxPixels(max_pixels);
- AddResource(pixel_limit_resource_, VideoAdaptationReason::kCpu);
}
void VideoStreamEncoderResourceManager::StopManagedResources() {
diff --git a/third_party/libwebrtc/video/adaptation/video_stream_encoder_resource_manager.h b/third_party/libwebrtc/video/adaptation/video_stream_encoder_resource_manager.h
@@ -213,8 +213,6 @@ class VideoStreamEncoderResourceManager
const std::unique_ptr<InitialFrameDropper> initial_frame_dropper_
RTC_GUARDED_BY(encoder_queue_);
const bool quality_scaling_experiment_enabled_ RTC_GUARDED_BY(encoder_queue_);
- const bool pixel_limit_resource_experiment_enabled_
- RTC_GUARDED_BY(encoder_queue_);
std::optional<uint32_t> encoder_target_bitrate_bps_
RTC_GUARDED_BY(encoder_queue_);
std::optional<VideoEncoder::RateControlParameters> encoder_rates_
