Implement fake PixelLimitResource for TestBed.
This CL implements a Resource that aggressively reports overuse or
underuse until the encoded stream has the max pixels specified. The
pixel limit is controlled with a field trial, e.g:
--force-fieldtrials="WebRTC-PixelLimitResource/Enabled-307200/"
This caps the resolution to 307200 (=640x480). This can be used by the
TestBed to simulate being CPU limited. Note that the resource doesn't
care about degradation preference at the moment, so if the degradation
preference would be set to "maintain-resolution" the PixelLimitResource
would never stop reporting overuse and we would quickly get a low-FPS
stream.
PixelLimitResource runs a repeating task and reports overuse, underuse
or neither every 5 seconds. This ensures we quickly reach the desired
resolution.
Unit tests are added. I did not add any integration tests (I think
that's overkill for a testing-only resource) but I have manually
verified that this works as intended.
This CL also moves the FakeVideoStreamInputStateProvider into a test/
folder and exposes video_stream_adapter.cc's GetLowerResolutionThan().
Bug: webrtc:12261
Change-Id: Ifbf7c4c05e9dd2843543589bebef3f49b18c38c0
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/195600
Reviewed-by: Evan Shrubsole <eshr@google.com>
Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org>
Commit-Queue: Henrik Boström <hbos@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#32771}
diff --git a/call/adaptation/BUILD.gn b/call/adaptation/BUILD.gn
index 3ecfbec..f782a8d 100644
--- a/call/adaptation/BUILD.gn
+++ b/call/adaptation/BUILD.gn
@@ -101,6 +101,8 @@
"test/fake_frame_rate_provider.h",
"test/fake_resource.cc",
"test/fake_resource.h",
+ "test/fake_video_stream_input_state_provider.cc",
+ "test/fake_video_stream_input_state_provider.h",
"test/mock_resource_listener.h",
]
deps = [
diff --git a/call/adaptation/test/fake_video_stream_input_state_provider.cc b/call/adaptation/test/fake_video_stream_input_state_provider.cc
new file mode 100644
index 0000000..ce92dfb
--- /dev/null
+++ b/call/adaptation/test/fake_video_stream_input_state_provider.cc
@@ -0,0 +1,35 @@
+/*
+ * 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/test/fake_video_stream_input_state_provider.h"
+
+namespace webrtc {
+
+FakeVideoStreamInputStateProvider::FakeVideoStreamInputStateProvider()
+ : VideoStreamInputStateProvider(nullptr) {}
+
+FakeVideoStreamInputStateProvider::~FakeVideoStreamInputStateProvider() =
+ default;
+
+void FakeVideoStreamInputStateProvider::SetInputState(
+ int input_pixels,
+ int input_fps,
+ int min_pixels_per_frame) {
+ fake_input_state_.set_has_input(true);
+ fake_input_state_.set_frame_size_pixels(input_pixels);
+ fake_input_state_.set_frames_per_second(input_fps);
+ fake_input_state_.set_min_pixels_per_frame(min_pixels_per_frame);
+}
+
+VideoStreamInputState FakeVideoStreamInputStateProvider::InputState() {
+ return fake_input_state_;
+}
+
+} // namespace webrtc
diff --git a/call/adaptation/test/fake_video_stream_input_state_provider.h b/call/adaptation/test/fake_video_stream_input_state_provider.h
new file mode 100644
index 0000000..93f7dba
--- /dev/null
+++ b/call/adaptation/test/fake_video_stream_input_state_provider.h
@@ -0,0 +1,32 @@
+/*
+ * 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_TEST_FAKE_VIDEO_STREAM_INPUT_STATE_PROVIDER_H_
+#define CALL_ADAPTATION_TEST_FAKE_VIDEO_STREAM_INPUT_STATE_PROVIDER_H_
+
+#include "call/adaptation/video_stream_input_state_provider.h"
+
+namespace webrtc {
+
+class FakeVideoStreamInputStateProvider : public VideoStreamInputStateProvider {
+ public:
+ FakeVideoStreamInputStateProvider();
+ virtual ~FakeVideoStreamInputStateProvider();
+
+ void SetInputState(int input_pixels, int input_fps, int min_pixels_per_frame);
+ VideoStreamInputState InputState() override;
+
+ private:
+ VideoStreamInputState fake_input_state_;
+};
+
+} // namespace webrtc
+
+#endif // CALL_ADAPTATION_TEST_FAKE_VIDEO_STREAM_INPUT_STATE_PROVIDER_H_
diff --git a/call/adaptation/video_stream_adapter.cc b/call/adaptation/video_stream_adapter.cc
index 4fc4743..13eb034 100644
--- a/call/adaptation/video_stream_adapter.cc
+++ b/call/adaptation/video_stream_adapter.cc
@@ -45,19 +45,6 @@
: std::numeric_limits<int>::max();
}
-// For resolution, the steps we take are 3/5 (down) and 5/3 (up).
-// Notice the asymmetry of which restriction property is set depending on if
-// we are adapting up or down:
-// - VideoSourceRestrictor::DecreaseResolution() sets the max_pixels_per_frame()
-// to the desired target and target_pixels_per_frame() to null.
-// - VideoSourceRestrictor::IncreaseResolutionTo() sets the
-// target_pixels_per_frame() to the desired target, and max_pixels_per_frame()
-// is set according to VideoSourceRestrictor::GetIncreasedMaxPixelsWanted().
-int GetLowerResolutionThan(int pixel_count) {
- RTC_DCHECK(pixel_count != std::numeric_limits<int>::max());
- return (pixel_count * 3) / 5;
-}
-
int GetIncreasedMaxPixelsWanted(int target_pixels) {
if (target_pixels == std::numeric_limits<int>::max())
return std::numeric_limits<int>::max();
@@ -139,6 +126,19 @@
return source_restrictions;
}
+// For resolution, the steps we take are 3/5 (down) and 5/3 (up).
+// Notice the asymmetry of which restriction property is set depending on if
+// we are adapting up or down:
+// - VideoSourceRestrictor::DecreaseResolution() sets the max_pixels_per_frame()
+// to the desired target and target_pixels_per_frame() to null.
+// - VideoSourceRestrictor::IncreaseResolutionTo() sets the
+// target_pixels_per_frame() to the desired target, and max_pixels_per_frame()
+// is set according to VideoSourceRestrictor::GetIncreasedMaxPixelsWanted().
+int GetLowerResolutionThan(int pixel_count) {
+ RTC_DCHECK(pixel_count != std::numeric_limits<int>::max());
+ return (pixel_count * 3) / 5;
+}
+
// TODO(hbos): Use absl::optional<> instead?
int GetHigherResolutionThan(int pixel_count) {
return pixel_count != std::numeric_limits<int>::max()
diff --git a/call/adaptation/video_stream_adapter.h b/call/adaptation/video_stream_adapter.h
index a4e93e4..2b55c3d 100644
--- a/call/adaptation/video_stream_adapter.h
+++ b/call/adaptation/video_stream_adapter.h
@@ -57,6 +57,7 @@
VideoSourceRestrictions source_restrictions,
DegradationPreference degradation_preference);
+int GetLowerResolutionThan(int pixel_count);
int GetHigherResolutionThan(int pixel_count);
// Either represents the next VideoSourceRestrictions the VideoStreamAdapter
diff --git a/call/adaptation/video_stream_adapter_unittest.cc b/call/adaptation/video_stream_adapter_unittest.cc
index 534be61..aba9cf1 100644
--- a/call/adaptation/video_stream_adapter_unittest.cc
+++ b/call/adaptation/video_stream_adapter_unittest.cc
@@ -23,6 +23,7 @@
#include "call/adaptation/encoder_settings.h"
#include "call/adaptation/test/fake_frame_rate_provider.h"
#include "call/adaptation/test/fake_resource.h"
+#include "call/adaptation/test/fake_video_stream_input_state_provider.h"
#include "call/adaptation/video_source_restrictions.h"
#include "call/adaptation/video_stream_input_state.h"
#include "rtc_base/string_encode.h"
@@ -59,28 +60,6 @@
rtc::ToString(kBalancedHighFrameRateFps) + "/";
}
-class FakeVideoStreamInputStateProvider : public VideoStreamInputStateProvider {
- public:
- FakeVideoStreamInputStateProvider()
- : VideoStreamInputStateProvider(nullptr) {}
- virtual ~FakeVideoStreamInputStateProvider() = default;
-
- void SetInputState(int input_pixels,
- int input_fps,
- int min_pixels_per_frame) {
- VideoStreamInputState input_state;
- input_state.set_has_input(true);
- input_state.set_frame_size_pixels(input_pixels);
- input_state.set_frames_per_second(input_fps);
- input_state.set_min_pixels_per_frame(min_pixels_per_frame);
- fake_input_state_ = input_state;
- }
- VideoStreamInputState InputState() override { return fake_input_state_; }
-
- private:
- VideoStreamInputState fake_input_state_;
-};
-
// Responsible for adjusting the inputs to VideoStreamAdapter (SetInput), such
// as pixels and frame rate, according to the most recent source restrictions.
// This helps tests that apply adaptations multiple times: if the input is not
diff --git a/video/adaptation/BUILD.gn b/video/adaptation/BUILD.gn
index 755e2f6..c5afb02 100644
--- a/video/adaptation/BUILD.gn
+++ b/video/adaptation/BUILD.gn
@@ -18,6 +18,8 @@
"encode_usage_resource.h",
"overuse_frame_detector.cc",
"overuse_frame_detector.h",
+ "pixel_limit_resource.cc",
+ "pixel_limit_resource.h",
"quality_rampup_experiment_helper.cc",
"quality_rampup_experiment_helper.h",
"quality_scaler_resource.cc",
@@ -34,6 +36,7 @@
"../../api/adaptation:resource_adaptation_api",
"../../api/task_queue:task_queue",
"../../api/units:data_rate",
+ "../../api/units:time_delta",
"../../api/video:video_adaptation",
"../../api/video:video_frame",
"../../api/video:video_stream_encoder",
@@ -73,12 +76,15 @@
defines = []
sources = [
"overuse_frame_detector_unittest.cc",
+ "pixel_limit_resource_unittest.cc",
"quality_scaler_resource_unittest.cc",
]
deps = [
":video_adaptation",
"../../api:scoped_refptr",
"../../api/task_queue:task_queue",
+ "../../api/units:time_delta",
+ "../../api/units:timestamp",
"../../api/video:encoded_image",
"../../api/video:video_adaptation",
"../../api/video:video_frame",
@@ -94,10 +100,11 @@
"../../rtc_base:rtc_numerics",
"../../rtc_base:rtc_task_queue",
"../../rtc_base:task_queue_for_test",
+ "../../rtc_base/task_utils:to_queued_task",
"../../test:field_trial",
- "//test:rtc_expect_death",
- "//test:test_support",
- "//testing/gtest",
+ "../../test:rtc_expect_death",
+ "../../test:test_support",
+ "../../test/time_controller:time_controller",
]
absl_deps = [ "//third_party/abseil-cpp/absl/types:optional" ]
}
diff --git a/video/adaptation/pixel_limit_resource.cc b/video/adaptation/pixel_limit_resource.cc
new file mode 100644
index 0000000..96c8cac
--- /dev/null
+++ b/video/adaptation/pixel_limit_resource.cc
@@ -0,0 +1,102 @@
+/*
+ * Copyright 2020 The WebRTC Project Authors. All rights reserved.
+ *
+ * Use of this source code is governed by a BSD-style license
+ * that can be found in the LICENSE file in the root of the source
+ * tree. An additional intellectual property rights grant can be found
+ * in the file PATENTS. All contributing project authors may
+ * be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "video/adaptation/pixel_limit_resource.h"
+
+#include "api/units/time_delta.h"
+#include "call/adaptation/video_stream_adapter.h"
+#include "rtc_base/checks.h"
+#include "rtc_base/ref_counted_object.h"
+#include "rtc_base/synchronization/sequence_checker.h"
+
+namespace webrtc {
+
+namespace {
+
+constexpr TimeDelta kResourceUsageCheckIntervalMs = TimeDelta::Seconds(5);
+
+} // namespace
+
+// static
+rtc::scoped_refptr<PixelLimitResource> PixelLimitResource::Create(
+ TaskQueueBase* task_queue,
+ VideoStreamInputStateProvider* input_state_provider) {
+ return new rtc::RefCountedObject<PixelLimitResource>(task_queue,
+ input_state_provider);
+}
+
+PixelLimitResource::PixelLimitResource(
+ TaskQueueBase* task_queue,
+ VideoStreamInputStateProvider* input_state_provider)
+ : task_queue_(task_queue),
+ input_state_provider_(input_state_provider),
+ max_pixels_(absl::nullopt) {
+ RTC_DCHECK(task_queue_);
+ RTC_DCHECK(input_state_provider_);
+}
+
+PixelLimitResource::~PixelLimitResource() {
+ RTC_DCHECK(!listener_);
+ 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;
+ }
+ absl::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(this,
+ ResourceUsageState::kOveruse);
+ } else if (current_pixels < target_pixels_lower_bounds) {
+ listener_->OnResourceUsageStateMeasured(this,
+ ResourceUsageState::kUnderuse);
+ }
+ return kResourceUsageCheckIntervalMs;
+ });
+ } else {
+ repeating_task_.Stop();
+ }
+ // The task must be running if we have a listener.
+ RTC_DCHECK(repeating_task_.Running() || !listener_);
+}
+
+} // namespace webrtc
diff --git a/video/adaptation/pixel_limit_resource.h b/video/adaptation/pixel_limit_resource.h
new file mode 100644
index 0000000..b42f924
--- /dev/null
+++ b/video/adaptation/pixel_limit_resource.h
@@ -0,0 +1,60 @@
+/*
+ * Copyright 2020 The WebRTC Project Authors. All rights reserved.
+ *
+ * Use of this source code is governed by a BSD-style license
+ * that can be found in the LICENSE file in the root of the source
+ * tree. An additional intellectual property rights grant can be found
+ * in the file PATENTS. All contributing project authors may
+ * be found in the AUTHORS file in the root of the source tree.
+ */
+
+#ifndef VIDEO_ADAPTATION_PIXEL_LIMIT_RESOURCE_H_
+#define VIDEO_ADAPTATION_PIXEL_LIMIT_RESOURCE_H_
+
+#include <string>
+
+#include "absl/types/optional.h"
+#include "api/adaptation/resource.h"
+#include "api/scoped_refptr.h"
+#include "call/adaptation/video_stream_input_state_provider.h"
+#include "rtc_base/task_utils/repeating_task.h"
+#include "rtc_base/thread_annotations.h"
+
+namespace webrtc {
+
+// An adaptation resource designed to be used in the TestBed. Used to simulate
+// being CPU limited.
+//
+// Periodically reports "overuse" or "underuse" (every 5 seconds) until the
+// stream is within the bounds specified in terms of a maximum resolution and
+// one resolution step lower than that (this avoids toggling when this is the
+// only resource in play). When multiple resources come in to play some amount
+// of toggling is still possible in edge cases but that is OK for testing
+// purposes.
+class PixelLimitResource : public Resource {
+ public:
+ static rtc::scoped_refptr<PixelLimitResource> Create(
+ TaskQueueBase* task_queue,
+ VideoStreamInputStateProvider* input_state_provider);
+
+ PixelLimitResource(TaskQueueBase* task_queue,
+ VideoStreamInputStateProvider* input_state_provider);
+ ~PixelLimitResource() override;
+
+ void SetMaxPixels(int max_pixels);
+
+ // Resource implementation.
+ std::string Name() const override { return "PixelLimitResource"; }
+ void SetResourceListener(ResourceListener* listener) override;
+
+ private:
+ TaskQueueBase* const task_queue_;
+ VideoStreamInputStateProvider* const input_state_provider_;
+ absl::optional<int> max_pixels_ RTC_GUARDED_BY(task_queue_);
+ webrtc::ResourceListener* listener_ RTC_GUARDED_BY(task_queue_);
+ RepeatingTaskHandle repeating_task_ RTC_GUARDED_BY(task_queue_);
+};
+
+} // namespace webrtc
+
+#endif // VIDEO_ADAPTATION_PIXEL_LIMIT_RESOURCE_H_
diff --git a/video/adaptation/pixel_limit_resource_unittest.cc b/video/adaptation/pixel_limit_resource_unittest.cc
new file mode 100644
index 0000000..7b633b3
--- /dev/null
+++ b/video/adaptation/pixel_limit_resource_unittest.cc
@@ -0,0 +1,147 @@
+/*
+ * Copyright 2020 The WebRTC Project Authors. All rights reserved.
+ *
+ * Use of this source code is governed by a BSD-style license
+ * that can be found in the LICENSE file in the root of the source
+ * tree. An additional intellectual property rights grant can be found
+ * in the file PATENTS. All contributing project authors may
+ * be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "video/adaptation/pixel_limit_resource.h"
+
+#include <memory>
+#include <utility>
+
+#include "api/units/timestamp.h"
+#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 "rtc_base/task_queue_for_test.h"
+#include "rtc_base/task_utils/to_queued_task.h"
+#include "test/gmock.h"
+#include "test/gtest.h"
+#include "test/time_controller/simulated_time_controller.h"
+
+using testing::_;
+
+namespace webrtc {
+
+namespace {
+
+constexpr TimeDelta kResourceUsageCheckIntervalMs = TimeDelta::Seconds(5);
+
+} // namespace
+
+class PixelLimitResourceTest : public ::testing::Test {
+ public:
+ PixelLimitResourceTest()
+ : time_controller_(Timestamp::Micros(1234)),
+ task_queue_(time_controller_.GetTaskQueueFactory()->CreateTaskQueue(
+ "TestQueue",
+ TaskQueueFactory::Priority::NORMAL)),
+ input_state_provider_() {}
+
+ void SetCurrentPixels(int current_pixels) {
+ input_state_provider_.SetInputState(current_pixels, 30, current_pixels);
+ }
+
+ void RunTaskOnTaskQueue(std::unique_ptr<QueuedTask> task) {
+ task_queue_->PostTask(std::move(task));
+ time_controller_.AdvanceTime(TimeDelta::Millis(0));
+ }
+
+ protected:
+ // Posted tasks, including repeated tasks, are executed when simulated time is
+ // advanced by time_controller_.AdvanceTime().
+ GlobalSimulatedTimeController time_controller_;
+ std::unique_ptr<TaskQueueBase, TaskQueueDeleter> task_queue_;
+ FakeVideoStreamInputStateProvider input_state_provider_;
+};
+
+TEST_F(PixelLimitResourceTest, ResourceIsSilentByDefault) {
+ // Because our mock is strick, the test would fail if
+ // OnResourceUsageStateMeasured() is invoked.
+ testing::StrictMock<MockResourceListener> resource_listener;
+ RunTaskOnTaskQueue(ToQueuedTask([&]() {
+ rtc::scoped_refptr<PixelLimitResource> pixel_limit_resource =
+ PixelLimitResource::Create(task_queue_.get(), &input_state_provider_);
+ 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);
+ pixel_limit_resource->SetResourceListener(nullptr);
+ }));
+}
+
+TEST_F(PixelLimitResourceTest,
+ OveruseIsReportedWhileCurrentPixelsIsGreaterThanMaxPixels) {
+ constexpr int kMaxPixels = 640 * 480;
+ testing::StrictMock<MockResourceListener> resource_listener;
+ RunTaskOnTaskQueue(ToQueuedTask([&]() {
+ rtc::scoped_refptr<PixelLimitResource> pixel_limit_resource =
+ PixelLimitResource::Create(task_queue_.get(), &input_state_provider_);
+ pixel_limit_resource->SetResourceListener(&resource_listener);
+ time_controller_.AdvanceTime(TimeDelta::Millis(0));
+
+ pixel_limit_resource->SetMaxPixels(kMaxPixels);
+ SetCurrentPixels(kMaxPixels + 1);
+ EXPECT_CALL(resource_listener,
+ OnResourceUsageStateMeasured(_, ResourceUsageState::kOveruse))
+ .Times(1);
+ time_controller_.AdvanceTime(kResourceUsageCheckIntervalMs);
+
+ // 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);
+
+ // 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);
+
+ pixel_limit_resource->SetResourceListener(nullptr);
+ }));
+}
+
+TEST_F(PixelLimitResourceTest,
+ UnderuseIsReportedWhileCurrentPixelsIsLessThanMinPixels) {
+ constexpr int kMaxPixels = 640 * 480;
+ const int kMinPixels = GetLowerResolutionThan(kMaxPixels);
+ testing::StrictMock<MockResourceListener> resource_listener;
+ RunTaskOnTaskQueue(ToQueuedTask([&]() {
+ rtc::scoped_refptr<PixelLimitResource> pixel_limit_resource =
+ PixelLimitResource::Create(task_queue_.get(), &input_state_provider_);
+ pixel_limit_resource->SetResourceListener(&resource_listener);
+ time_controller_.AdvanceTime(TimeDelta::Millis(0));
+
+ pixel_limit_resource->SetMaxPixels(kMaxPixels);
+ SetCurrentPixels(kMinPixels - 1);
+ EXPECT_CALL(resource_listener,
+ OnResourceUsageStateMeasured(_, ResourceUsageState::kUnderuse))
+ .Times(1);
+ time_controller_.AdvanceTime(kResourceUsageCheckIntervalMs);
+
+ // 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);
+
+ // 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);
+
+ pixel_limit_resource->SetResourceListener(nullptr);
+ }));
+}
+
+} // namespace webrtc
diff --git a/video/adaptation/video_stream_encoder_resource_manager.cc b/video/adaptation/video_stream_encoder_resource_manager.cc
index 340b2e8..8d532f3 100644
--- a/video/adaptation/video_stream_encoder_resource_manager.cc
+++ b/video/adaptation/video_stream_encoder_resource_manager.cc
@@ -10,6 +10,7 @@
#include "video/adaptation/video_stream_encoder_resource_manager.h"
+#include <stdio.h>
#include <algorithm>
#include <cmath>
#include <limits>
@@ -30,6 +31,7 @@
#include "rtc_base/strings/string_builder.h"
#include "rtc_base/synchronization/sequence_checker.h"
#include "rtc_base/time_utils.h"
+#include "system_wrappers/include/field_trial.h"
#include "video/adaptation/quality_scaler_resource.h"
namespace webrtc {
@@ -39,6 +41,9 @@
namespace {
+constexpr const char* kPixelLimitResourceFieldTrialName =
+ "WebRTC-PixelLimitResource";
+
bool IsResolutionScalingEnabled(DegradationPreference degradation_preference) {
return degradation_preference == DegradationPreference::MAINTAIN_FRAMERATE ||
degradation_preference == DegradationPreference::BALANCED;
@@ -234,6 +239,7 @@
encode_usage_resource_(
EncodeUsageResource::Create(std::move(overuse_detector))),
quality_scaler_resource_(QualityScalerResource::Create()),
+ pixel_limit_resource_(nullptr),
encoder_queue_(nullptr),
input_state_provider_(input_state_provider),
adaptation_processor_(nullptr),
@@ -298,6 +304,34 @@
encode_usage_resource_->StartCheckForOveruse(GetCpuOveruseOptions());
}
+void VideoStreamEncoderResourceManager::MaybeInitializePixelLimitResource() {
+ RTC_DCHECK_RUN_ON(encoder_queue_);
+ RTC_DCHECK(adaptation_processor_);
+ RTC_DCHECK(!pixel_limit_resource_);
+ if (!field_trial::IsEnabled(kPixelLimitResourceFieldTrialName)) {
+ // The field trial is not running.
+ return;
+ }
+ int max_pixels = 0;
+ std::string pixel_limit_field_trial =
+ field_trial::FindFullName(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;
+ }
+ 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_->Get(), input_state_provider_);
+ pixel_limit_resource_->SetMaxPixels(max_pixels);
+ AddResource(pixel_limit_resource_, VideoAdaptationReason::kCpu);
+}
+
void VideoStreamEncoderResourceManager::StopManagedResources() {
RTC_DCHECK_RUN_ON(encoder_queue_);
RTC_DCHECK(adaptation_processor_);
@@ -309,6 +343,10 @@
quality_scaler_resource_->StopCheckForOveruse();
RemoveResource(quality_scaler_resource_);
}
+ if (pixel_limit_resource_) {
+ RemoveResource(pixel_limit_resource_);
+ pixel_limit_resource_ = nullptr;
+ }
}
void VideoStreamEncoderResourceManager::AddResource(
diff --git a/video/adaptation/video_stream_encoder_resource_manager.h b/video/adaptation/video_stream_encoder_resource_manager.h
index 623d17a..30bab53 100644
--- a/video/adaptation/video_stream_encoder_resource_manager.h
+++ b/video/adaptation/video_stream_encoder_resource_manager.h
@@ -46,6 +46,7 @@
#include "video/adaptation/bitrate_constraint.h"
#include "video/adaptation/encode_usage_resource.h"
#include "video/adaptation/overuse_frame_detector.h"
+#include "video/adaptation/pixel_limit_resource.h"
#include "video/adaptation/quality_rampup_experiment_helper.h"
#include "video/adaptation/quality_scaler_resource.h"
#include "video/adaptation/video_stream_encoder_resource.h"
@@ -92,7 +93,11 @@
DegradationPreference degradation_preference() const;
void EnsureEncodeUsageResourceStarted();
+ // Initializes the pixel limit resource if the "WebRTC-PixelLimitResource"
+ // field trial is enabled. This can be used for testing.
+ void MaybeInitializePixelLimitResource();
// Stops the encode usage and quality scaler resources if not already stopped.
+ // If the pixel limit resource was created it is also stopped and nulled.
void StopManagedResources();
// Settings that affect the VideoStreamEncoder-specific resources.
@@ -171,6 +176,7 @@
RTC_GUARDED_BY(encoder_queue_);
const rtc::scoped_refptr<EncodeUsageResource> encode_usage_resource_;
const rtc::scoped_refptr<QualityScalerResource> quality_scaler_resource_;
+ rtc::scoped_refptr<PixelLimitResource> pixel_limit_resource_;
rtc::TaskQueue* encoder_queue_;
VideoStreamInputStateProvider* const input_state_provider_
diff --git a/video/video_stream_encoder.cc b/video/video_stream_encoder.cc
index 14f3566..22d4ac5 100644
--- a/video/video_stream_encoder.cc
+++ b/video/video_stream_encoder.cc
@@ -448,6 +448,7 @@
&stream_resource_manager_);
video_stream_adapter_->AddRestrictionsListener(&stream_resource_manager_);
video_stream_adapter_->AddRestrictionsListener(this);
+ stream_resource_manager_.MaybeInitializePixelLimitResource();
// Add the stream resource manager's resources to the processor.
adaptation_constraints_ = stream_resource_manager_.AdaptationConstraints();
