admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
webrtc_m130/call/adaptation/resource_adaptation_processor_unittest.cc

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

738 lines
32 KiB
C++
Raw Normal View History

[Adaptation] Misc tests for processor, input provider and restrictions. This CL adds miscellaneous unit tests for the ResourceAdaptationProcessor, the VideoSourceRestrictions comparators and the VideoStreamInputStateProvider. Bug: webrtc:11172 Change-Id: If95f69644aaf2b43e3b19d5729bedef0b438c77b Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/174101 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@{#31147}
2020-04-29 16:46:30 +02:00
/*
* Copyright (c) 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/resource_adaptation_processor.h"
[Adaptation] Move Resource to api/ folder. This is a prerequisite to implementing it externally. Bug: webrtc:11525 Change-Id: I9cb3b4418396485d3eb9f25cafa51cbff6db7817 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176401 Commit-Queue: Henrik Boström <hbos@webrtc.org> Reviewed-by: Stefan Holmer <stefan@webrtc.org> Reviewed-by: Evan Shrubsole <eshr@google.com> Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31418}
2020-06-03 09:24:06 +02:00
#include "api/adaptation/resource.h"
[Adaptation] Make Resources reference counted and add more DCHECKs. In a future CL, adaptation processing and stream encoder resource management will happen on different task queues. When this is the case, asynchronous tasks will be posted in both directions and some resources will have internal states used on multiple threads. This CL makes the Resource class reference counted in order to support posting tasks to a different threads without risk of use-after-free when a posted task is executed with a delay. This is preferred over WeakPtr strategies because WeakPtrs are single-threaded and preferred over raw pointer usage because the reference counted approach enables more compile-time and run-time assurance. This is also "future proof"; when resources can be injected through public APIs, ownership needs to be shared between libwebrtc and the application (e.g. Chrome). To reduce the risk of making mistakes in the future CL, sequence checkers and task queue DCHECKs are added as well as other DCHECKs to make sure things have been cleaned up before destruction, e.g: - Processor gets a sequence checker. It is entirely single-threaded. - Processor must not have any attached listeners or resources on destruction. - Resources must not have any listeners on destruction. - The Manager, EncodeUsageResource and QualityScalerResource DCHECKs they are running on the encoder queue. - TODOs are added illustrating where we want to add PostTasks in the future CL. Lastly, upon VideoStreamEncoder::Stop() we delete the ResourceAdaptationProcessor. Because the Processor is already used in posted tasks, some if statements are added to ensure the Processor is not used after destruction. Bug: webrtc:11542, webrtc:11520 Change-Id: Ibaa8a61d86d87a71f477d1075a117c28d9d2d285 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/174760 Commit-Queue: Henrik Boström <hbos@webrtc.org> Reviewed-by: Evan Shrubsole <eshr@google.com> Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31217}
2020-05-11 16:29:22 +02:00
#include "api/scoped_refptr.h"
[Adaptation] Misc tests for processor, input provider and restrictions. This CL adds miscellaneous unit tests for the ResourceAdaptationProcessor, the VideoSourceRestrictions comparators and the VideoStreamInputStateProvider. Bug: webrtc:11172 Change-Id: If95f69644aaf2b43e3b19d5729bedef0b438c77b Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/174101 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@{#31147}
2020-04-29 16:46:30 +02:00
#include "api/video/video_adaptation_counters.h"
#include "call/adaptation/resource_adaptation_processor_interface.h"
#include "call/adaptation/test/fake_frame_rate_provider.h"
#include "call/adaptation/test/fake_resource.h"
#include "call/adaptation/video_source_restrictions.h"
#include "call/adaptation/video_stream_input_state_provider.h"
[Adaptation] Move adaptation logic to a separate task queue. This CL unblocks future Call-Level Mitigation strategies by moving the ResourceAdaptationProcessor to a separate task queue. This signifies a major milestone in the new resource adaptation architecture because with this CL the threading model is in place and moving the Processor to the Call and increasing its responsibilities is made possible. In this CL, we still have one Processor per VideoStreamEncoder and the VideoStreamEncoder is responsible for the creation and the destruction of its Processor and that Processor's task queue. But the PostTasks are in place and the decision-making is executed on a separate queue. This CL: - Moves ResourceAdaptationProcessor to an adaptation task queue. It continues to be entirely single-threaded, but now operates on a separate task queue. - Makes Resources thread-safe: Interaction with the Processor, i.e. OnResourceUsageStateMeasured() and IsAdaptationUpAllowed(), happens on the adaptation task queue. State updates are pushed from the encoder task queue with PostTasks. - QualityScalerResource operates on both task queues; the QP usage callbacks are invoked asynchronously. - The VideoStreamEncoderResourceManager operates on the encoder task queue with the following exceptions: 1) Its resources are accessible on any thread (using a mutex). This is OK because resources are reference counted and thread safe. This aids adding and removing resources to the Processor on the adaptation task queue. 2) |active_counts_| is moved to the adaptation task queue. This makes it possible for PreventAdaptUpDueToActiveCounts to run IsAdaptationUpAllowed() on the adaptation task queue. A side-effect of this is that some stats reporting now happen on the adaptation task queue, but that is OK because VideoStreamEncoderObserver is thread-safe. The Manager is updated to take the new threading model into account: - OnFrameDroppedDueToSize() posts to the adaptation task queue to invoke the Processor. - OnVideoSourceRestrictionsUpdated(), now invoked on the adaptation task queue, updates |active_counts_| synchronously but posts to the encoder task queue to update video source restrictions (which it only uses to calculate target frame rate). - MaybePerformQualityRampupExperiment() posts to the adaptation task queue to maybe reset video source restrictions on the Processor. |quality_rampup_done_| is made std::atomic. Bug: webrtc:11542, webrtc:11520 Change-Id: I1cfd76e0cd42f006a6d2527f5aa2aeb5266ba6d6 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/174441 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@{#31231}
2020-05-12 18:49:07 +02:00
#include "rtc_base/event.h"
[Adaptation] Remove Resource::UsageState() and ClearUsageState(). ResourceListener::OnResourceUsageStateMeasured() now takes ResourceUsageState as argument, making Resource::UsageState() superfluous. With the existing "fire-and-forget" behavior of always clearing usage state on reacting to a signal, there is no longer a need to call ClearUsageState() so this too is removed. (We may want to have a callback in the future to hint to the Resource that it is a good idea to clear internal measurement samples, i.e. because the load of the system is about to change, but we can revisit that when we need it.) Moving the usage state to the callback has the benefit of getting rid of the assumption that UsageState() has to return the same value every time it is called in the same task. This CL is also the final nail in the coffin for Resource needing to know about the adaptation task queue: ResourceAdaptationProcessor's ResourceListener now takes care of posting to the adaptation task queue. To support this, the processor's SequenceChecker is replaced by a TaskQueueBase pointer. Bug: webrtc:11525, webrtc:11618 Change-Id: I2277e71cc3759c85b62465020935603f03792c94 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176376 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@{#31416}
2020-06-03 09:21:34 +02:00
#include "rtc_base/gunit.h"
Migrate call/ to webrtc::Mutex. Bug: webrtc:11567 Change-Id: Iab7142c77bc0c1a026cf5121b756094e05bccefe Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176742 Commit-Queue: Markus Handell <handellm@webrtc.org> Reviewed-by: Sebastian Jansson <srte@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31636}
2020-07-06 17:41:35 +02:00
#include "rtc_base/synchronization/mutex.h"
[Adaptation] Move adaptation logic to a separate task queue. This CL unblocks future Call-Level Mitigation strategies by moving the ResourceAdaptationProcessor to a separate task queue. This signifies a major milestone in the new resource adaptation architecture because with this CL the threading model is in place and moving the Processor to the Call and increasing its responsibilities is made possible. In this CL, we still have one Processor per VideoStreamEncoder and the VideoStreamEncoder is responsible for the creation and the destruction of its Processor and that Processor's task queue. But the PostTasks are in place and the decision-making is executed on a separate queue. This CL: - Moves ResourceAdaptationProcessor to an adaptation task queue. It continues to be entirely single-threaded, but now operates on a separate task queue. - Makes Resources thread-safe: Interaction with the Processor, i.e. OnResourceUsageStateMeasured() and IsAdaptationUpAllowed(), happens on the adaptation task queue. State updates are pushed from the encoder task queue with PostTasks. - QualityScalerResource operates on both task queues; the QP usage callbacks are invoked asynchronously. - The VideoStreamEncoderResourceManager operates on the encoder task queue with the following exceptions: 1) Its resources are accessible on any thread (using a mutex). This is OK because resources are reference counted and thread safe. This aids adding and removing resources to the Processor on the adaptation task queue. 2) |active_counts_| is moved to the adaptation task queue. This makes it possible for PreventAdaptUpDueToActiveCounts to run IsAdaptationUpAllowed() on the adaptation task queue. A side-effect of this is that some stats reporting now happen on the adaptation task queue, but that is OK because VideoStreamEncoderObserver is thread-safe. The Manager is updated to take the new threading model into account: - OnFrameDroppedDueToSize() posts to the adaptation task queue to invoke the Processor. - OnVideoSourceRestrictionsUpdated(), now invoked on the adaptation task queue, updates |active_counts_| synchronously but posts to the encoder task queue to update video source restrictions (which it only uses to calculate target frame rate). - MaybePerformQualityRampupExperiment() posts to the adaptation task queue to maybe reset video source restrictions on the Processor. |quality_rampup_done_| is made std::atomic. Bug: webrtc:11542, webrtc:11520 Change-Id: I1cfd76e0cd42f006a6d2527f5aa2aeb5266ba6d6 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/174441 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@{#31231}
2020-05-12 18:49:07 +02:00
#include "rtc_base/task_queue_for_test.h"
[Adaptation] Misc tests for processor, input provider and restrictions. This CL adds miscellaneous unit tests for the ResourceAdaptationProcessor, the VideoSourceRestrictions comparators and the VideoStreamInputStateProvider. Bug: webrtc:11172 Change-Id: If95f69644aaf2b43e3b19d5729bedef0b438c77b Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/174101 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@{#31147}
2020-04-29 16:46:30 +02:00
#include "test/gtest.h"
namespace webrtc {
namespace {
const int kDefaultFrameRate = 30;
const int kDefaultFrameSize = 1280 * 720;
[Adaptation] Remove Resource::UsageState() and ClearUsageState(). ResourceListener::OnResourceUsageStateMeasured() now takes ResourceUsageState as argument, making Resource::UsageState() superfluous. With the existing "fire-and-forget" behavior of always clearing usage state on reacting to a signal, there is no longer a need to call ClearUsageState() so this too is removed. (We may want to have a callback in the future to hint to the Resource that it is a good idea to clear internal measurement samples, i.e. because the load of the system is about to change, but we can revisit that when we need it.) Moving the usage state to the callback has the benefit of getting rid of the assumption that UsageState() has to return the same value every time it is called in the same task. This CL is also the final nail in the coffin for Resource needing to know about the adaptation task queue: ResourceAdaptationProcessor's ResourceListener now takes care of posting to the adaptation task queue. To support this, the processor's SequenceChecker is replaced by a TaskQueueBase pointer. Bug: webrtc:11525, webrtc:11618 Change-Id: I2277e71cc3759c85b62465020935603f03792c94 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176376 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@{#31416}
2020-06-03 09:21:34 +02:00
const int kDefaultTimeoutMs = 5000;
[Adaptation] Misc tests for processor, input provider and restrictions. This CL adds miscellaneous unit tests for the ResourceAdaptationProcessor, the VideoSourceRestrictions comparators and the VideoStreamInputStateProvider. Bug: webrtc:11172 Change-Id: If95f69644aaf2b43e3b19d5729bedef0b438c77b Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/174101 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@{#31147}
2020-04-29 16:46:30 +02:00
[Adaptation] Move IsAdaptationUpAllowed/OnAdaptationApplied out of API. IsAdaptationUpAllowed is moved from Resource to AdaptationConstraint. OnAdaptationApplied is moved from Resource to AdaptationListener. In a future CL, Resource will be moved to api/, but AdaptationConstraint and AdaptationListener will stay in call/. The processor, encode stream and manager are updated to keep track of both resources, constraints and listeners. Fakes and tests are updated. After this CL, the manager's inner classes that prevent adaptation implement AdaptationConstraint instead of Resource. Bug: webrtc:11525 Change-Id: Ie9cd5b1ba7d8e161951e131ab8f6bd9d5cf765bf Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176368 Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org> Reviewed-by: Evan Shrubsole <eshr@google.com> Commit-Queue: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31409}
2020-06-02 13:02:36 +02:00
class VideoSourceRestrictionsListenerForTesting
: public VideoSourceRestrictionsListener {
[Adaptation] Misc tests for processor, input provider and restrictions. This CL adds miscellaneous unit tests for the ResourceAdaptationProcessor, the VideoSourceRestrictions comparators and the VideoStreamInputStateProvider. Bug: webrtc:11172 Change-Id: If95f69644aaf2b43e3b19d5729bedef0b438c77b Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/174101 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@{#31147}
2020-04-29 16:46:30 +02:00
public:
[Adaptation] Move IsAdaptationUpAllowed/OnAdaptationApplied out of API. IsAdaptationUpAllowed is moved from Resource to AdaptationConstraint. OnAdaptationApplied is moved from Resource to AdaptationListener. In a future CL, Resource will be moved to api/, but AdaptationConstraint and AdaptationListener will stay in call/. The processor, encode stream and manager are updated to keep track of both resources, constraints and listeners. Fakes and tests are updated. After this CL, the manager's inner classes that prevent adaptation implement AdaptationConstraint instead of Resource. Bug: webrtc:11525 Change-Id: Ie9cd5b1ba7d8e161951e131ab8f6bd9d5cf765bf Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176368 Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org> Reviewed-by: Evan Shrubsole <eshr@google.com> Commit-Queue: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31409}
2020-06-02 13:02:36 +02:00
VideoSourceRestrictionsListenerForTesting()
[Adaptation] Misc tests for processor, input provider and restrictions. This CL adds miscellaneous unit tests for the ResourceAdaptationProcessor, the VideoSourceRestrictions comparators and the VideoStreamInputStateProvider. Bug: webrtc:11172 Change-Id: If95f69644aaf2b43e3b19d5729bedef0b438c77b Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/174101 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@{#31147}
2020-04-29 16:46:30 +02:00
: restrictions_updated_count_(0),
restrictions_(),
adaptation_counters_(),
reason_(nullptr) {}
[Adaptation] Move IsAdaptationUpAllowed/OnAdaptationApplied out of API. IsAdaptationUpAllowed is moved from Resource to AdaptationConstraint. OnAdaptationApplied is moved from Resource to AdaptationListener. In a future CL, Resource will be moved to api/, but AdaptationConstraint and AdaptationListener will stay in call/. The processor, encode stream and manager are updated to keep track of both resources, constraints and listeners. Fakes and tests are updated. After this CL, the manager's inner classes that prevent adaptation implement AdaptationConstraint instead of Resource. Bug: webrtc:11525 Change-Id: Ie9cd5b1ba7d8e161951e131ab8f6bd9d5cf765bf Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176368 Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org> Reviewed-by: Evan Shrubsole <eshr@google.com> Commit-Queue: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31409}
2020-06-02 13:02:36 +02:00
~VideoSourceRestrictionsListenerForTesting() override {}
[Adaptation] Misc tests for processor, input provider and restrictions. This CL adds miscellaneous unit tests for the ResourceAdaptationProcessor, the VideoSourceRestrictions comparators and the VideoStreamInputStateProvider. Bug: webrtc:11172 Change-Id: If95f69644aaf2b43e3b19d5729bedef0b438c77b Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/174101 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@{#31147}
2020-04-29 16:46:30 +02:00
size_t restrictions_updated_count() const {
[Adaptation] Implement remove for most limited resources. When a resource is removed from the ResourceAdaptationProcessor, and the resource is the most limited resource, we reset the current adaptation to the next most limited resource level. In the case that this resource is the only adapted resource then we reset all adaptations. Bug: webrtc:11636 Change-Id: I29acc5a3934f42f00db79b3bb2171156b1313937 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176406 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org> Reviewed-by: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31520}
2020-06-12 16:00:03 +02:00
RTC_DCHECK_RUN_ON(&sequence_checker_);
[Adaptation] Misc tests for processor, input provider and restrictions. This CL adds miscellaneous unit tests for the ResourceAdaptationProcessor, the VideoSourceRestrictions comparators and the VideoStreamInputStateProvider. Bug: webrtc:11172 Change-Id: If95f69644aaf2b43e3b19d5729bedef0b438c77b Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/174101 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@{#31147}
2020-04-29 16:46:30 +02:00
return restrictions_updated_count_;
}
[Adaptation] Remove Resource::UsageState() and ClearUsageState(). ResourceListener::OnResourceUsageStateMeasured() now takes ResourceUsageState as argument, making Resource::UsageState() superfluous. With the existing "fire-and-forget" behavior of always clearing usage state on reacting to a signal, there is no longer a need to call ClearUsageState() so this too is removed. (We may want to have a callback in the future to hint to the Resource that it is a good idea to clear internal measurement samples, i.e. because the load of the system is about to change, but we can revisit that when we need it.) Moving the usage state to the callback has the benefit of getting rid of the assumption that UsageState() has to return the same value every time it is called in the same task. This CL is also the final nail in the coffin for Resource needing to know about the adaptation task queue: ResourceAdaptationProcessor's ResourceListener now takes care of posting to the adaptation task queue. To support this, the processor's SequenceChecker is replaced by a TaskQueueBase pointer. Bug: webrtc:11525, webrtc:11618 Change-Id: I2277e71cc3759c85b62465020935603f03792c94 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176376 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@{#31416}
2020-06-03 09:21:34 +02:00
VideoSourceRestrictions restrictions() const {
[Adaptation] Implement remove for most limited resources. When a resource is removed from the ResourceAdaptationProcessor, and the resource is the most limited resource, we reset the current adaptation to the next most limited resource level. In the case that this resource is the only adapted resource then we reset all adaptations. Bug: webrtc:11636 Change-Id: I29acc5a3934f42f00db79b3bb2171156b1313937 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176406 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org> Reviewed-by: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31520}
2020-06-12 16:00:03 +02:00
RTC_DCHECK_RUN_ON(&sequence_checker_);
[Adaptation] Remove Resource::UsageState() and ClearUsageState(). ResourceListener::OnResourceUsageStateMeasured() now takes ResourceUsageState as argument, making Resource::UsageState() superfluous. With the existing "fire-and-forget" behavior of always clearing usage state on reacting to a signal, there is no longer a need to call ClearUsageState() so this too is removed. (We may want to have a callback in the future to hint to the Resource that it is a good idea to clear internal measurement samples, i.e. because the load of the system is about to change, but we can revisit that when we need it.) Moving the usage state to the callback has the benefit of getting rid of the assumption that UsageState() has to return the same value every time it is called in the same task. This CL is also the final nail in the coffin for Resource needing to know about the adaptation task queue: ResourceAdaptationProcessor's ResourceListener now takes care of posting to the adaptation task queue. To support this, the processor's SequenceChecker is replaced by a TaskQueueBase pointer. Bug: webrtc:11525, webrtc:11618 Change-Id: I2277e71cc3759c85b62465020935603f03792c94 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176376 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@{#31416}
2020-06-03 09:21:34 +02:00
return restrictions_;
}
VideoAdaptationCounters adaptation_counters() const {
[Adaptation] Implement remove for most limited resources. When a resource is removed from the ResourceAdaptationProcessor, and the resource is the most limited resource, we reset the current adaptation to the next most limited resource level. In the case that this resource is the only adapted resource then we reset all adaptations. Bug: webrtc:11636 Change-Id: I29acc5a3934f42f00db79b3bb2171156b1313937 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176406 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org> Reviewed-by: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31520}
2020-06-12 16:00:03 +02:00
RTC_DCHECK_RUN_ON(&sequence_checker_);
[Adaptation] Misc tests for processor, input provider and restrictions. This CL adds miscellaneous unit tests for the ResourceAdaptationProcessor, the VideoSourceRestrictions comparators and the VideoStreamInputStateProvider. Bug: webrtc:11172 Change-Id: If95f69644aaf2b43e3b19d5729bedef0b438c77b Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/174101 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@{#31147}
2020-04-29 16:46:30 +02:00
return adaptation_counters_;
}
[Adaptation] Remove Resource::UsageState() and ClearUsageState(). ResourceListener::OnResourceUsageStateMeasured() now takes ResourceUsageState as argument, making Resource::UsageState() superfluous. With the existing "fire-and-forget" behavior of always clearing usage state on reacting to a signal, there is no longer a need to call ClearUsageState() so this too is removed. (We may want to have a callback in the future to hint to the Resource that it is a good idea to clear internal measurement samples, i.e. because the load of the system is about to change, but we can revisit that when we need it.) Moving the usage state to the callback has the benefit of getting rid of the assumption that UsageState() has to return the same value every time it is called in the same task. This CL is also the final nail in the coffin for Resource needing to know about the adaptation task queue: ResourceAdaptationProcessor's ResourceListener now takes care of posting to the adaptation task queue. To support this, the processor's SequenceChecker is replaced by a TaskQueueBase pointer. Bug: webrtc:11525, webrtc:11618 Change-Id: I2277e71cc3759c85b62465020935603f03792c94 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176376 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@{#31416}
2020-06-03 09:21:34 +02:00
rtc::scoped_refptr<Resource> reason() const {
[Adaptation] Implement remove for most limited resources. When a resource is removed from the ResourceAdaptationProcessor, and the resource is the most limited resource, we reset the current adaptation to the next most limited resource level. In the case that this resource is the only adapted resource then we reset all adaptations. Bug: webrtc:11636 Change-Id: I29acc5a3934f42f00db79b3bb2171156b1313937 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176406 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org> Reviewed-by: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31520}
2020-06-12 16:00:03 +02:00
RTC_DCHECK_RUN_ON(&sequence_checker_);
[Adaptation] Remove Resource::UsageState() and ClearUsageState(). ResourceListener::OnResourceUsageStateMeasured() now takes ResourceUsageState as argument, making Resource::UsageState() superfluous. With the existing "fire-and-forget" behavior of always clearing usage state on reacting to a signal, there is no longer a need to call ClearUsageState() so this too is removed. (We may want to have a callback in the future to hint to the Resource that it is a good idea to clear internal measurement samples, i.e. because the load of the system is about to change, but we can revisit that when we need it.) Moving the usage state to the callback has the benefit of getting rid of the assumption that UsageState() has to return the same value every time it is called in the same task. This CL is also the final nail in the coffin for Resource needing to know about the adaptation task queue: ResourceAdaptationProcessor's ResourceListener now takes care of posting to the adaptation task queue. To support this, the processor's SequenceChecker is replaced by a TaskQueueBase pointer. Bug: webrtc:11525, webrtc:11618 Change-Id: I2277e71cc3759c85b62465020935603f03792c94 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176376 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@{#31416}
2020-06-03 09:21:34 +02:00
return reason_;
}
[Adaptation] Misc tests for processor, input provider and restrictions. This CL adds miscellaneous unit tests for the ResourceAdaptationProcessor, the VideoSourceRestrictions comparators and the VideoStreamInputStateProvider. Bug: webrtc:11172 Change-Id: If95f69644aaf2b43e3b19d5729bedef0b438c77b Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/174101 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@{#31147}
2020-04-29 16:46:30 +02:00
[Adaptation] Move IsAdaptationUpAllowed/OnAdaptationApplied out of API. IsAdaptationUpAllowed is moved from Resource to AdaptationConstraint. OnAdaptationApplied is moved from Resource to AdaptationListener. In a future CL, Resource will be moved to api/, but AdaptationConstraint and AdaptationListener will stay in call/. The processor, encode stream and manager are updated to keep track of both resources, constraints and listeners. Fakes and tests are updated. After this CL, the manager's inner classes that prevent adaptation implement AdaptationConstraint instead of Resource. Bug: webrtc:11525 Change-Id: Ie9cd5b1ba7d8e161951e131ab8f6bd9d5cf765bf Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176368 Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org> Reviewed-by: Evan Shrubsole <eshr@google.com> Commit-Queue: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31409}
2020-06-02 13:02:36 +02:00
// VideoSourceRestrictionsListener implementation.
[Adaptation] Misc tests for processor, input provider and restrictions. This CL adds miscellaneous unit tests for the ResourceAdaptationProcessor, the VideoSourceRestrictions comparators and the VideoStreamInputStateProvider. Bug: webrtc:11172 Change-Id: If95f69644aaf2b43e3b19d5729bedef0b438c77b Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/174101 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@{#31147}
2020-04-29 16:46:30 +02:00
void OnVideoSourceRestrictionsUpdated(
VideoSourceRestrictions restrictions,
const VideoAdaptationCounters& adaptation_counters,
[Adaptation] VideoStreamAdapter broadcasts adaptations This moves this responsibility from the ResourceAdaptaitonProcessor to the VideoStreamAdapter. A new interface for listening to adaptation changes was added, and the ResourceAdaptationProcessor now listens on the VideoStreamAdapter for those changes. This means that going forward, 1. We can do adaptations outside of resource limitations, like setting prior adaptations on a resource like initial frame dropper is designed to. 2. Adaptations can be on a different queue than the ResourceAdaptaitonProcessor's queue since updates are pushed through the listener. Bug: webrtc:11700 Change-Id: I6de0dec748dba095e702f0b9893c5afa50b51aa9 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176859 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@{#31615}
2020-07-01 11:47:46 +02:00
rtc::scoped_refptr<Resource> reason,
const VideoSourceRestrictions& unfiltered_restrictions) override {
[Adaptation] Implement remove for most limited resources. When a resource is removed from the ResourceAdaptationProcessor, and the resource is the most limited resource, we reset the current adaptation to the next most limited resource level. In the case that this resource is the only adapted resource then we reset all adaptations. Bug: webrtc:11636 Change-Id: I29acc5a3934f42f00db79b3bb2171156b1313937 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176406 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org> Reviewed-by: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31520}
2020-06-12 16:00:03 +02:00
RTC_DCHECK_RUN_ON(&sequence_checker_);
[Adaptation] Misc tests for processor, input provider and restrictions. This CL adds miscellaneous unit tests for the ResourceAdaptationProcessor, the VideoSourceRestrictions comparators and the VideoStreamInputStateProvider. Bug: webrtc:11172 Change-Id: If95f69644aaf2b43e3b19d5729bedef0b438c77b Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/174101 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@{#31147}
2020-04-29 16:46:30 +02:00
++restrictions_updated_count_;
restrictions_ = restrictions;
adaptation_counters_ = adaptation_counters;
reason_ = reason;
}
private:
[Adaptation] Implement remove for most limited resources. When a resource is removed from the ResourceAdaptationProcessor, and the resource is the most limited resource, we reset the current adaptation to the next most limited resource level. In the case that this resource is the only adapted resource then we reset all adaptations. Bug: webrtc:11636 Change-Id: I29acc5a3934f42f00db79b3bb2171156b1313937 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176406 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org> Reviewed-by: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31520}
2020-06-12 16:00:03 +02:00
SequenceChecker sequence_checker_;
size_t restrictions_updated_count_ RTC_GUARDED_BY(&sequence_checker_);
VideoSourceRestrictions restrictions_ RTC_GUARDED_BY(&sequence_checker_);
VideoAdaptationCounters adaptation_counters_
RTC_GUARDED_BY(&sequence_checker_);
rtc::scoped_refptr<Resource> reason_ RTC_GUARDED_BY(&sequence_checker_);
[Adaptation] Misc tests for processor, input provider and restrictions. This CL adds miscellaneous unit tests for the ResourceAdaptationProcessor, the VideoSourceRestrictions comparators and the VideoStreamInputStateProvider. Bug: webrtc:11172 Change-Id: If95f69644aaf2b43e3b19d5729bedef0b438c77b Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/174101 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@{#31147}
2020-04-29 16:46:30 +02:00
};
class ResourceAdaptationProcessorTest : public ::testing::Test {
public:
ResourceAdaptationProcessorTest()
Clean resource_adaptation_processor_unittest use of TaskQueueForTest Use the current task queue in the test instead. R=hbos@webrtc.org Bug: None Change-Id: I266796df3de675a808bcf2da08901411fadc86ae Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176414 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31439}
2020-06-03 14:09:09 +02:00
: frame_rate_provider_(),
[Adaptation] Misc tests for processor, input provider and restrictions. This CL adds miscellaneous unit tests for the ResourceAdaptationProcessor, the VideoSourceRestrictions comparators and the VideoStreamInputStateProvider. Bug: webrtc:11172 Change-Id: If95f69644aaf2b43e3b19d5729bedef0b438c77b Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/174101 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@{#31147}
2020-04-29 16:46:30 +02:00
input_state_provider_(&frame_rate_provider_),
[Adaptation] Prep Resource for api/ move. Introduce VSE-Resource. This CL is in preparation for moving Resource to the api/ folder. It does not move it, but makes it such that the moving CL can be a pure move. In order to do this, we must stop depending on rtc_base/rtc::TaskQueue in favor of api/webrtc::TaskQueueBase. There are also other rtc_base/ dependencies that we do not want to expose to the api/ folder, like critical sections and thread annotations which are not publically exposed. To get around this, we make Resource an abstract interface and move all of the base class functionality into a new non-api/ class: VideoStreamEncoderResource. The Resource now has Register/UnregisterAdaptationTaskQueue() methods. By explicitly unregistering, we can ensure validity of the pointer even if the Resource outlives the PeerConnection. While public interface methods are only to be called on the adaptation task queue, posting to the task queue happens off-queue, so a |lock_| is introduced to guard it. Bug: webrtc:11525 Change-Id: I50b3a30960cdec9032016c779b47001c01dad32f Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176320 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@{#31402}
2020-06-01 17:59:05 +02:00
resource_(FakeResource::Create("FakeResource")),
other_resource_(FakeResource::Create("OtherFakeResource")),
[Adaptation] Move input state into VideoStreamAdapter Bug: webrtc:11700 Change-Id: I81a060b914f91f6724f13a9b672234c9c4a65fae Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/177104 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@{#31616}
2020-07-02 14:42:09 +02:00
video_stream_adapter_(
[Adaptation] Move min pixel limit logic out of adaptation processor This is in preperation for eventual multi-stream and multi-mitigation adaptation. This logic only applied to a single stream and thus is better fit in the VideoStreamAdapter. Bug: webrtc:11754 Change-Id: Icc5c7920038c82b574f4b5f7efbc92698691076f Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/181585 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31944}
2020-08-17 11:10:45 +02:00
std::make_unique<VideoStreamAdapter>(&input_state_provider_,
&frame_rate_provider_)),
[Adaptation] Move adaptation logic to a separate task queue. This CL unblocks future Call-Level Mitigation strategies by moving the ResourceAdaptationProcessor to a separate task queue. This signifies a major milestone in the new resource adaptation architecture because with this CL the threading model is in place and moving the Processor to the Call and increasing its responsibilities is made possible. In this CL, we still have one Processor per VideoStreamEncoder and the VideoStreamEncoder is responsible for the creation and the destruction of its Processor and that Processor's task queue. But the PostTasks are in place and the decision-making is executed on a separate queue. This CL: - Moves ResourceAdaptationProcessor to an adaptation task queue. It continues to be entirely single-threaded, but now operates on a separate task queue. - Makes Resources thread-safe: Interaction with the Processor, i.e. OnResourceUsageStateMeasured() and IsAdaptationUpAllowed(), happens on the adaptation task queue. State updates are pushed from the encoder task queue with PostTasks. - QualityScalerResource operates on both task queues; the QP usage callbacks are invoked asynchronously. - The VideoStreamEncoderResourceManager operates on the encoder task queue with the following exceptions: 1) Its resources are accessible on any thread (using a mutex). This is OK because resources are reference counted and thread safe. This aids adding and removing resources to the Processor on the adaptation task queue. 2) |active_counts_| is moved to the adaptation task queue. This makes it possible for PreventAdaptUpDueToActiveCounts to run IsAdaptationUpAllowed() on the adaptation task queue. A side-effect of this is that some stats reporting now happen on the adaptation task queue, but that is OK because VideoStreamEncoderObserver is thread-safe. The Manager is updated to take the new threading model into account: - OnFrameDroppedDueToSize() posts to the adaptation task queue to invoke the Processor. - OnVideoSourceRestrictionsUpdated(), now invoked on the adaptation task queue, updates |active_counts_| synchronously but posts to the encoder task queue to update video source restrictions (which it only uses to calculate target frame rate). - MaybePerformQualityRampupExperiment() posts to the adaptation task queue to maybe reset video source restrictions on the Processor. |quality_rampup_done_| is made std::atomic. Bug: webrtc:11542, webrtc:11520 Change-Id: I1cfd76e0cd42f006a6d2527f5aa2aeb5266ba6d6 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/174441 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@{#31231}
2020-05-12 18:49:07 +02:00
processor_(std::make_unique<ResourceAdaptationProcessor>(
[Adaptation] VideoStreamAdapter broadcasts adaptations This moves this responsibility from the ResourceAdaptaitonProcessor to the VideoStreamAdapter. A new interface for listening to adaptation changes was added, and the ResourceAdaptationProcessor now listens on the VideoStreamAdapter for those changes. This means that going forward, 1. We can do adaptations outside of resource limitations, like setting prior adaptations on a resource like initial frame dropper is designed to. 2. Adaptations can be on a different queue than the ResourceAdaptaitonProcessor's queue since updates are pushed through the listener. Bug: webrtc:11700 Change-Id: I6de0dec748dba095e702f0b9893c5afa50b51aa9 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176859 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@{#31615}
2020-07-01 11:47:46 +02:00
video_stream_adapter_.get())) {
[Adaptation] Remove resource adaptation queue Resource adaptation needs refactoring for async adaptations. For now the resource adaptation processor can work on the encoder thread, until it is refactored to support async adaptation. Bug: webrtc:11867 Change-Id: I9c46da356db19c0fd52748c999ccb216f2ca923b Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/182040 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org> Reviewed-by: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31991}
2020-08-25 13:12:12 +02:00
processor_->SetTaskQueue(TaskQueueBase::Current());
[Adaptation] VideoStreamAdapter broadcasts adaptations This moves this responsibility from the ResourceAdaptaitonProcessor to the VideoStreamAdapter. A new interface for listening to adaptation changes was added, and the ResourceAdaptationProcessor now listens on the VideoStreamAdapter for those changes. This means that going forward, 1. We can do adaptations outside of resource limitations, like setting prior adaptations on a resource like initial frame dropper is designed to. 2. Adaptations can be on a different queue than the ResourceAdaptaitonProcessor's queue since updates are pushed through the listener. Bug: webrtc:11700 Change-Id: I6de0dec748dba095e702f0b9893c5afa50b51aa9 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176859 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@{#31615}
2020-07-01 11:47:46 +02:00
video_stream_adapter_->AddRestrictionsListener(&restrictions_listener_);
Clean resource_adaptation_processor_unittest use of TaskQueueForTest Use the current task queue in the test instead. R=hbos@webrtc.org Bug: None Change-Id: I266796df3de675a808bcf2da08901411fadc86ae Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176414 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31439}
2020-06-03 14:09:09 +02:00
processor_->AddResource(resource_);
processor_->AddResource(other_resource_);
[Adaptation] Misc tests for processor, input provider and restrictions. This CL adds miscellaneous unit tests for the ResourceAdaptationProcessor, the VideoSourceRestrictions comparators and the VideoStreamInputStateProvider. Bug: webrtc:11172 Change-Id: If95f69644aaf2b43e3b19d5729bedef0b438c77b Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/174101 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@{#31147}
2020-04-29 16:46:30 +02:00
}
~ResourceAdaptationProcessorTest() override {
Clean resource_adaptation_processor_unittest use of TaskQueueForTest Use the current task queue in the test instead. R=hbos@webrtc.org Bug: None Change-Id: I266796df3de675a808bcf2da08901411fadc86ae Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176414 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31439}
2020-06-03 14:09:09 +02:00
if (processor_) {
DestroyProcessor();
}
[Adaptation] Misc tests for processor, input provider and restrictions. This CL adds miscellaneous unit tests for the ResourceAdaptationProcessor, the VideoSourceRestrictions comparators and the VideoStreamInputStateProvider. Bug: webrtc:11172 Change-Id: If95f69644aaf2b43e3b19d5729bedef0b438c77b Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/174101 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@{#31147}
2020-04-29 16:46:30 +02:00
}
void SetInputStates(bool has_input, int fps, int frame_size) {
input_state_provider_.OnHasInputChanged(has_input);
frame_rate_provider_.set_fps(fps);
input_state_provider_.OnFrameSizeObserved(frame_size);
}
void RestrictSource(VideoSourceRestrictions restrictions) {
SetInputStates(
true, restrictions.max_frame_rate().value_or(kDefaultFrameRate),
restrictions.target_pixels_per_frame().has_value()
? restrictions.target_pixels_per_frame().value()
: restrictions.max_pixels_per_frame().value_or(kDefaultFrameSize));
}
[Adaptation] Remove Resource::UsageState() and ClearUsageState(). ResourceListener::OnResourceUsageStateMeasured() now takes ResourceUsageState as argument, making Resource::UsageState() superfluous. With the existing "fire-and-forget" behavior of always clearing usage state on reacting to a signal, there is no longer a need to call ClearUsageState() so this too is removed. (We may want to have a callback in the future to hint to the Resource that it is a good idea to clear internal measurement samples, i.e. because the load of the system is about to change, but we can revisit that when we need it.) Moving the usage state to the callback has the benefit of getting rid of the assumption that UsageState() has to return the same value every time it is called in the same task. This CL is also the final nail in the coffin for Resource needing to know about the adaptation task queue: ResourceAdaptationProcessor's ResourceListener now takes care of posting to the adaptation task queue. To support this, the processor's SequenceChecker is replaced by a TaskQueueBase pointer. Bug: webrtc:11525, webrtc:11618 Change-Id: I2277e71cc3759c85b62465020935603f03792c94 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176376 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@{#31416}
2020-06-03 09:21:34 +02:00
void DestroyProcessor() {
[Adaptation] Implement remove for most limited resources. When a resource is removed from the ResourceAdaptationProcessor, and the resource is the most limited resource, we reset the current adaptation to the next most limited resource level. In the case that this resource is the only adapted resource then we reset all adaptations. Bug: webrtc:11636 Change-Id: I29acc5a3934f42f00db79b3bb2171156b1313937 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176406 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org> Reviewed-by: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31520}
2020-06-12 16:00:03 +02:00
if (resource_) {
processor_->RemoveResource(resource_);
}
if (other_resource_) {
processor_->RemoveResource(other_resource_);
}
[Adaptation] VideoStreamAdapter broadcasts adaptations This moves this responsibility from the ResourceAdaptaitonProcessor to the VideoStreamAdapter. A new interface for listening to adaptation changes was added, and the ResourceAdaptationProcessor now listens on the VideoStreamAdapter for those changes. This means that going forward, 1. We can do adaptations outside of resource limitations, like setting prior adaptations on a resource like initial frame dropper is designed to. 2. Adaptations can be on a different queue than the ResourceAdaptaitonProcessor's queue since updates are pushed through the listener. Bug: webrtc:11700 Change-Id: I6de0dec748dba095e702f0b9893c5afa50b51aa9 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176859 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@{#31615}
2020-07-01 11:47:46 +02:00
video_stream_adapter_->RemoveRestrictionsListener(&restrictions_listener_);
[Adaptation] Remove Resource::UsageState() and ClearUsageState(). ResourceListener::OnResourceUsageStateMeasured() now takes ResourceUsageState as argument, making Resource::UsageState() superfluous. With the existing "fire-and-forget" behavior of always clearing usage state on reacting to a signal, there is no longer a need to call ClearUsageState() so this too is removed. (We may want to have a callback in the future to hint to the Resource that it is a good idea to clear internal measurement samples, i.e. because the load of the system is about to change, but we can revisit that when we need it.) Moving the usage state to the callback has the benefit of getting rid of the assumption that UsageState() has to return the same value every time it is called in the same task. This CL is also the final nail in the coffin for Resource needing to know about the adaptation task queue: ResourceAdaptationProcessor's ResourceListener now takes care of posting to the adaptation task queue. To support this, the processor's SequenceChecker is replaced by a TaskQueueBase pointer. Bug: webrtc:11525, webrtc:11618 Change-Id: I2277e71cc3759c85b62465020935603f03792c94 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176376 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@{#31416}
2020-06-03 09:21:34 +02:00
processor_.reset();
}
[Adaptation] Implement remove for most limited resources. When a resource is removed from the ResourceAdaptationProcessor, and the resource is the most limited resource, we reset the current adaptation to the next most limited resource level. In the case that this resource is the only adapted resource then we reset all adaptations. Bug: webrtc:11636 Change-Id: I29acc5a3934f42f00db79b3bb2171156b1313937 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176406 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org> Reviewed-by: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31520}
2020-06-12 16:00:03 +02:00
static void WaitUntilTaskQueueIdle() {
ASSERT_TRUE(rtc::Thread::Current()->ProcessMessages(0));
}
[Adaptation] Misc tests for processor, input provider and restrictions. This CL adds miscellaneous unit tests for the ResourceAdaptationProcessor, the VideoSourceRestrictions comparators and the VideoStreamInputStateProvider. Bug: webrtc:11172 Change-Id: If95f69644aaf2b43e3b19d5729bedef0b438c77b Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/174101 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@{#31147}
2020-04-29 16:46:30 +02:00
protected:
FakeFrameRateProvider frame_rate_provider_;
VideoStreamInputStateProvider input_state_provider_;
[Adaptation] Make Resources reference counted and add more DCHECKs. In a future CL, adaptation processing and stream encoder resource management will happen on different task queues. When this is the case, asynchronous tasks will be posted in both directions and some resources will have internal states used on multiple threads. This CL makes the Resource class reference counted in order to support posting tasks to a different threads without risk of use-after-free when a posted task is executed with a delay. This is preferred over WeakPtr strategies because WeakPtrs are single-threaded and preferred over raw pointer usage because the reference counted approach enables more compile-time and run-time assurance. This is also "future proof"; when resources can be injected through public APIs, ownership needs to be shared between libwebrtc and the application (e.g. Chrome). To reduce the risk of making mistakes in the future CL, sequence checkers and task queue DCHECKs are added as well as other DCHECKs to make sure things have been cleaned up before destruction, e.g: - Processor gets a sequence checker. It is entirely single-threaded. - Processor must not have any attached listeners or resources on destruction. - Resources must not have any listeners on destruction. - The Manager, EncodeUsageResource and QualityScalerResource DCHECKs they are running on the encoder queue. - TODOs are added illustrating where we want to add PostTasks in the future CL. Lastly, upon VideoStreamEncoder::Stop() we delete the ResourceAdaptationProcessor. Because the Processor is already used in posted tasks, some if statements are added to ensure the Processor is not used after destruction. Bug: webrtc:11542, webrtc:11520 Change-Id: Ibaa8a61d86d87a71f477d1075a117c28d9d2d285 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/174760 Commit-Queue: Henrik Boström <hbos@webrtc.org> Reviewed-by: Evan Shrubsole <eshr@google.com> Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31217}
2020-05-11 16:29:22 +02:00
rtc::scoped_refptr<FakeResource> resource_;
rtc::scoped_refptr<FakeResource> other_resource_;
[Adaptation] VideoStreamAdapter broadcasts adaptations This moves this responsibility from the ResourceAdaptaitonProcessor to the VideoStreamAdapter. A new interface for listening to adaptation changes was added, and the ResourceAdaptationProcessor now listens on the VideoStreamAdapter for those changes. This means that going forward, 1. We can do adaptations outside of resource limitations, like setting prior adaptations on a resource like initial frame dropper is designed to. 2. Adaptations can be on a different queue than the ResourceAdaptaitonProcessor's queue since updates are pushed through the listener. Bug: webrtc:11700 Change-Id: I6de0dec748dba095e702f0b9893c5afa50b51aa9 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176859 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@{#31615}
2020-07-01 11:47:46 +02:00
std::unique_ptr<VideoStreamAdapter> video_stream_adapter_;
[Adaptation] Move adaptation logic to a separate task queue. This CL unblocks future Call-Level Mitigation strategies by moving the ResourceAdaptationProcessor to a separate task queue. This signifies a major milestone in the new resource adaptation architecture because with this CL the threading model is in place and moving the Processor to the Call and increasing its responsibilities is made possible. In this CL, we still have one Processor per VideoStreamEncoder and the VideoStreamEncoder is responsible for the creation and the destruction of its Processor and that Processor's task queue. But the PostTasks are in place and the decision-making is executed on a separate queue. This CL: - Moves ResourceAdaptationProcessor to an adaptation task queue. It continues to be entirely single-threaded, but now operates on a separate task queue. - Makes Resources thread-safe: Interaction with the Processor, i.e. OnResourceUsageStateMeasured() and IsAdaptationUpAllowed(), happens on the adaptation task queue. State updates are pushed from the encoder task queue with PostTasks. - QualityScalerResource operates on both task queues; the QP usage callbacks are invoked asynchronously. - The VideoStreamEncoderResourceManager operates on the encoder task queue with the following exceptions: 1) Its resources are accessible on any thread (using a mutex). This is OK because resources are reference counted and thread safe. This aids adding and removing resources to the Processor on the adaptation task queue. 2) |active_counts_| is moved to the adaptation task queue. This makes it possible for PreventAdaptUpDueToActiveCounts to run IsAdaptationUpAllowed() on the adaptation task queue. A side-effect of this is that some stats reporting now happen on the adaptation task queue, but that is OK because VideoStreamEncoderObserver is thread-safe. The Manager is updated to take the new threading model into account: - OnFrameDroppedDueToSize() posts to the adaptation task queue to invoke the Processor. - OnVideoSourceRestrictionsUpdated(), now invoked on the adaptation task queue, updates |active_counts_| synchronously but posts to the encoder task queue to update video source restrictions (which it only uses to calculate target frame rate). - MaybePerformQualityRampupExperiment() posts to the adaptation task queue to maybe reset video source restrictions on the Processor. |quality_rampup_done_| is made std::atomic. Bug: webrtc:11542, webrtc:11520 Change-Id: I1cfd76e0cd42f006a6d2527f5aa2aeb5266ba6d6 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/174441 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@{#31231}
2020-05-12 18:49:07 +02:00
std::unique_ptr<ResourceAdaptationProcessor> processor_;
[Adaptation] Move IsAdaptationUpAllowed/OnAdaptationApplied out of API. IsAdaptationUpAllowed is moved from Resource to AdaptationConstraint. OnAdaptationApplied is moved from Resource to AdaptationListener. In a future CL, Resource will be moved to api/, but AdaptationConstraint and AdaptationListener will stay in call/. The processor, encode stream and manager are updated to keep track of both resources, constraints and listeners. Fakes and tests are updated. After this CL, the manager's inner classes that prevent adaptation implement AdaptationConstraint instead of Resource. Bug: webrtc:11525 Change-Id: Ie9cd5b1ba7d8e161951e131ab8f6bd9d5cf765bf Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176368 Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org> Reviewed-by: Evan Shrubsole <eshr@google.com> Commit-Queue: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31409}
2020-06-02 13:02:36 +02:00
VideoSourceRestrictionsListenerForTesting restrictions_listener_;
[Adaptation] Misc tests for processor, input provider and restrictions. This CL adds miscellaneous unit tests for the ResourceAdaptationProcessor, the VideoSourceRestrictions comparators and the VideoStreamInputStateProvider. Bug: webrtc:11172 Change-Id: If95f69644aaf2b43e3b19d5729bedef0b438c77b Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/174101 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@{#31147}
2020-04-29 16:46:30 +02:00
};
} // namespace
TEST_F(ResourceAdaptationProcessorTest, DisabledByDefault) {
Clean resource_adaptation_processor_unittest use of TaskQueueForTest Use the current task queue in the test instead. R=hbos@webrtc.org Bug: None Change-Id: I266796df3de675a808bcf2da08901411fadc86ae Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176414 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31439}
2020-06-03 14:09:09 +02:00
SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
// Adaptation does not happen when disabled.
resource_->SetUsageState(ResourceUsageState::kOveruse);
EXPECT_EQ(0u, restrictions_listener_.restrictions_updated_count());
[Adaptation] Misc tests for processor, input provider and restrictions. This CL adds miscellaneous unit tests for the ResourceAdaptationProcessor, the VideoSourceRestrictions comparators and the VideoStreamInputStateProvider. Bug: webrtc:11172 Change-Id: If95f69644aaf2b43e3b19d5729bedef0b438c77b Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/174101 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@{#31147}
2020-04-29 16:46:30 +02:00
}
TEST_F(ResourceAdaptationProcessorTest, InsufficientInput) {
[Adaptation] Remove deg.prefs from ResourceAdaptationProcessor 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}
2020-07-07 09:04:34 +02:00
video_stream_adapter_->SetDegradationPreference(
Clean resource_adaptation_processor_unittest use of TaskQueueForTest Use the current task queue in the test instead. R=hbos@webrtc.org Bug: None Change-Id: I266796df3de675a808bcf2da08901411fadc86ae Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176414 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31439}
2020-06-03 14:09:09 +02:00
DegradationPreference::MAINTAIN_FRAMERATE);
// Adaptation does not happen if input is insufficient.
// When frame size is missing (OnFrameSizeObserved not called yet).
input_state_provider_.OnHasInputChanged(true);
resource_->SetUsageState(ResourceUsageState::kOveruse);
EXPECT_EQ(0u, restrictions_listener_.restrictions_updated_count());
// When "has input" is missing.
SetInputStates(false, kDefaultFrameRate, kDefaultFrameSize);
resource_->SetUsageState(ResourceUsageState::kOveruse);
EXPECT_EQ(0u, restrictions_listener_.restrictions_updated_count());
// Note: frame rate cannot be missing, if unset it is 0.
[Adaptation] Misc tests for processor, input provider and restrictions. This CL adds miscellaneous unit tests for the ResourceAdaptationProcessor, the VideoSourceRestrictions comparators and the VideoStreamInputStateProvider. Bug: webrtc:11172 Change-Id: If95f69644aaf2b43e3b19d5729bedef0b438c77b Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/174101 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@{#31147}
2020-04-29 16:46:30 +02:00
}
// These tests verify that restrictions are applied, but not exactly how much
// the source is restricted. This ensures that the VideoStreamAdapter is wired
// up correctly but not exactly how the VideoStreamAdapter generates
// restrictions. For that, see video_stream_adapter_unittest.cc.
TEST_F(ResourceAdaptationProcessorTest,
OveruseTriggersRestrictingResolutionInMaintainFrameRate) {
[Adaptation] Remove deg.prefs from ResourceAdaptationProcessor 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}
2020-07-07 09:04:34 +02:00
video_stream_adapter_->SetDegradationPreference(
Clean resource_adaptation_processor_unittest use of TaskQueueForTest Use the current task queue in the test instead. R=hbos@webrtc.org Bug: None Change-Id: I266796df3de675a808bcf2da08901411fadc86ae Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176414 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31439}
2020-06-03 14:09:09 +02:00
DegradationPreference::MAINTAIN_FRAMERATE);
SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
resource_->SetUsageState(ResourceUsageState::kOveruse);
EXPECT_EQ(1u, restrictions_listener_.restrictions_updated_count());
EXPECT_TRUE(
restrictions_listener_.restrictions().max_pixels_per_frame().has_value());
[Adaptation] Misc tests for processor, input provider and restrictions. This CL adds miscellaneous unit tests for the ResourceAdaptationProcessor, the VideoSourceRestrictions comparators and the VideoStreamInputStateProvider. Bug: webrtc:11172 Change-Id: If95f69644aaf2b43e3b19d5729bedef0b438c77b Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/174101 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@{#31147}
2020-04-29 16:46:30 +02:00
}
TEST_F(ResourceAdaptationProcessorTest,
OveruseTriggersRestrictingFrameRateInMaintainResolution) {
[Adaptation] Remove deg.prefs from ResourceAdaptationProcessor 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}
2020-07-07 09:04:34 +02:00
video_stream_adapter_->SetDegradationPreference(
Clean resource_adaptation_processor_unittest use of TaskQueueForTest Use the current task queue in the test instead. R=hbos@webrtc.org Bug: None Change-Id: I266796df3de675a808bcf2da08901411fadc86ae Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176414 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31439}
2020-06-03 14:09:09 +02:00
DegradationPreference::MAINTAIN_RESOLUTION);
SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
resource_->SetUsageState(ResourceUsageState::kOveruse);
EXPECT_EQ(1u, restrictions_listener_.restrictions_updated_count());
EXPECT_TRUE(
restrictions_listener_.restrictions().max_frame_rate().has_value());
[Adaptation] Misc tests for processor, input provider and restrictions. This CL adds miscellaneous unit tests for the ResourceAdaptationProcessor, the VideoSourceRestrictions comparators and the VideoStreamInputStateProvider. Bug: webrtc:11172 Change-Id: If95f69644aaf2b43e3b19d5729bedef0b438c77b Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/174101 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@{#31147}
2020-04-29 16:46:30 +02:00
}
TEST_F(ResourceAdaptationProcessorTest,
OveruseTriggersRestrictingFrameRateAndResolutionInBalanced) {
[Adaptation] Remove deg.prefs from ResourceAdaptationProcessor 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}
2020-07-07 09:04:34 +02:00
video_stream_adapter_->SetDegradationPreference(
DegradationPreference::BALANCED);
Clean resource_adaptation_processor_unittest use of TaskQueueForTest Use the current task queue in the test instead. R=hbos@webrtc.org Bug: None Change-Id: I266796df3de675a808bcf2da08901411fadc86ae Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176414 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31439}
2020-06-03 14:09:09 +02:00
SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
// Adapting multiple times eventually resticts both frame rate and
// resolution. Exactly many times we need to adapt depends on
// BalancedDegradationSettings, VideoStreamAdapter and default input
// states. This test requires it to be achieved within 4 adaptations.
for (size_t i = 0; i < 4; ++i) {
resource_->SetUsageState(ResourceUsageState::kOveruse);
EXPECT_EQ(i + 1, restrictions_listener_.restrictions_updated_count());
RestrictSource(restrictions_listener_.restrictions());
}
EXPECT_TRUE(
restrictions_listener_.restrictions().max_pixels_per_frame().has_value());
EXPECT_TRUE(
restrictions_listener_.restrictions().max_frame_rate().has_value());
[Adaptation] Misc tests for processor, input provider and restrictions. This CL adds miscellaneous unit tests for the ResourceAdaptationProcessor, the VideoSourceRestrictions comparators and the VideoStreamInputStateProvider. Bug: webrtc:11172 Change-Id: If95f69644aaf2b43e3b19d5729bedef0b438c77b Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/174101 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@{#31147}
2020-04-29 16:46:30 +02:00
}
TEST_F(ResourceAdaptationProcessorTest, AwaitingPreviousAdaptation) {
[Adaptation] Remove deg.prefs from ResourceAdaptationProcessor 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}
2020-07-07 09:04:34 +02:00
video_stream_adapter_->SetDegradationPreference(
Clean resource_adaptation_processor_unittest use of TaskQueueForTest Use the current task queue in the test instead. R=hbos@webrtc.org Bug: None Change-Id: I266796df3de675a808bcf2da08901411fadc86ae Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176414 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31439}
2020-06-03 14:09:09 +02:00
DegradationPreference::MAINTAIN_FRAMERATE);
SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
resource_->SetUsageState(ResourceUsageState::kOveruse);
EXPECT_EQ(1u, restrictions_listener_.restrictions_updated_count());
// If we don't restrict the source then adaptation will not happen again
// due to "awaiting previous adaptation". This prevents "double-adapt".
resource_->SetUsageState(ResourceUsageState::kOveruse);
EXPECT_EQ(1u, restrictions_listener_.restrictions_updated_count());
[Adaptation] Misc tests for processor, input provider and restrictions. This CL adds miscellaneous unit tests for the ResourceAdaptationProcessor, the VideoSourceRestrictions comparators and the VideoStreamInputStateProvider. Bug: webrtc:11172 Change-Id: If95f69644aaf2b43e3b19d5729bedef0b438c77b Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/174101 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@{#31147}
2020-04-29 16:46:30 +02:00
}
TEST_F(ResourceAdaptationProcessorTest, CannotAdaptUpWhenUnrestricted) {
[Adaptation] Remove deg.prefs from ResourceAdaptationProcessor 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}
2020-07-07 09:04:34 +02:00
video_stream_adapter_->SetDegradationPreference(
Clean resource_adaptation_processor_unittest use of TaskQueueForTest Use the current task queue in the test instead. R=hbos@webrtc.org Bug: None Change-Id: I266796df3de675a808bcf2da08901411fadc86ae Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176414 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31439}
2020-06-03 14:09:09 +02:00
DegradationPreference::MAINTAIN_FRAMERATE);
SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
resource_->SetUsageState(ResourceUsageState::kUnderuse);
EXPECT_EQ(0u, restrictions_listener_.restrictions_updated_count());
[Adaptation] Misc tests for processor, input provider and restrictions. This CL adds miscellaneous unit tests for the ResourceAdaptationProcessor, the VideoSourceRestrictions comparators and the VideoStreamInputStateProvider. Bug: webrtc:11172 Change-Id: If95f69644aaf2b43e3b19d5729bedef0b438c77b Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/174101 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@{#31147}
2020-04-29 16:46:30 +02:00
}
TEST_F(ResourceAdaptationProcessorTest, UnderuseTakesUsBackToUnrestricted) {
[Adaptation] Remove deg.prefs from ResourceAdaptationProcessor 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}
2020-07-07 09:04:34 +02:00
video_stream_adapter_->SetDegradationPreference(
Clean resource_adaptation_processor_unittest use of TaskQueueForTest Use the current task queue in the test instead. R=hbos@webrtc.org Bug: None Change-Id: I266796df3de675a808bcf2da08901411fadc86ae Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176414 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31439}
2020-06-03 14:09:09 +02:00
DegradationPreference::MAINTAIN_FRAMERATE);
SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
resource_->SetUsageState(ResourceUsageState::kOveruse);
EXPECT_EQ(1u, restrictions_listener_.restrictions_updated_count());
RestrictSource(restrictions_listener_.restrictions());
resource_->SetUsageState(ResourceUsageState::kUnderuse);
EXPECT_EQ(2u, restrictions_listener_.restrictions_updated_count());
EXPECT_EQ(VideoSourceRestrictions(), restrictions_listener_.restrictions());
[Adaptation] Misc tests for processor, input provider and restrictions. This CL adds miscellaneous unit tests for the ResourceAdaptationProcessor, the VideoSourceRestrictions comparators and the VideoStreamInputStateProvider. Bug: webrtc:11172 Change-Id: If95f69644aaf2b43e3b19d5729bedef0b438c77b Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/174101 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@{#31147}
2020-04-29 16:46:30 +02:00
}
[Adaptation] Adapt up requires previous underuse The problem is that a resource that signals Underuse would be able to trigger an adapt up when it was never limited in the past. This means that an underused resource would be able to negate the adaptations made for an overused one. For example, consider a fast CPU on a bad link. The QP for the image is high but the CPU is underused. Without requiring previous underuse, everytime the QP would signal overuse and trigger an adpatation down, the CPU would signal underuse and trigger an adaptation up. This works today as we want by using the active counts in the VideoStreamEncoderResourceManager. This change makes it a normal behaviour independant of active counts. The problem with active counts is that is only works with 2 resources. When resources are injectable it no longer works as expected. Bug: webrtc:11522, webrtc:11523 Change-Id: I140636ce206d74e00a6b6f8558162bb8afffda1c Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/174482 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31181}
2020-05-07 13:45:14 +02:00
TEST_F(ResourceAdaptationProcessorTest,
ResourcesCanNotAdaptUpIfNeverAdaptedDown) {
[Adaptation] Remove deg.prefs from ResourceAdaptationProcessor 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}
2020-07-07 09:04:34 +02:00
video_stream_adapter_->SetDegradationPreference(
Clean resource_adaptation_processor_unittest use of TaskQueueForTest Use the current task queue in the test instead. R=hbos@webrtc.org Bug: None Change-Id: I266796df3de675a808bcf2da08901411fadc86ae Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176414 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31439}
2020-06-03 14:09:09 +02:00
DegradationPreference::MAINTAIN_FRAMERATE);
SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
resource_->SetUsageState(ResourceUsageState::kOveruse);
EXPECT_EQ(1u, restrictions_listener_.restrictions_updated_count());
RestrictSource(restrictions_listener_.restrictions());
// Other resource signals under-use
other_resource_->SetUsageState(ResourceUsageState::kUnderuse);
EXPECT_EQ(1u, restrictions_listener_.restrictions_updated_count());
[Adaptation] Adapt up requires previous underuse The problem is that a resource that signals Underuse would be able to trigger an adapt up when it was never limited in the past. This means that an underused resource would be able to negate the adaptations made for an overused one. For example, consider a fast CPU on a bad link. The QP for the image is high but the CPU is underused. Without requiring previous underuse, everytime the QP would signal overuse and trigger an adpatation down, the CPU would signal underuse and trigger an adaptation up. This works today as we want by using the active counts in the VideoStreamEncoderResourceManager. This change makes it a normal behaviour independant of active counts. The problem with active counts is that is only works with 2 resources. When resources are injectable it no longer works as expected. Bug: webrtc:11522, webrtc:11523 Change-Id: I140636ce206d74e00a6b6f8558162bb8afffda1c Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/174482 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31181}
2020-05-07 13:45:14 +02:00
}
TEST_F(ResourceAdaptationProcessorTest,
ResourcesCanNotAdaptUpIfNotAdaptedDownAfterReset) {
[Adaptation] Remove deg.prefs from ResourceAdaptationProcessor 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}
2020-07-07 09:04:34 +02:00
video_stream_adapter_->SetDegradationPreference(
Clean resource_adaptation_processor_unittest use of TaskQueueForTest Use the current task queue in the test instead. R=hbos@webrtc.org Bug: None Change-Id: I266796df3de675a808bcf2da08901411fadc86ae Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176414 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31439}
2020-06-03 14:09:09 +02:00
DegradationPreference::MAINTAIN_FRAMERATE);
SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
resource_->SetUsageState(ResourceUsageState::kOveruse);
EXPECT_EQ(1u, restrictions_listener_.restrictions_updated_count());
[Adaptation] VideoStreamAdapter broadcasts adaptations This moves this responsibility from the ResourceAdaptaitonProcessor to the VideoStreamAdapter. A new interface for listening to adaptation changes was added, and the ResourceAdaptationProcessor now listens on the VideoStreamAdapter for those changes. This means that going forward, 1. We can do adaptations outside of resource limitations, like setting prior adaptations on a resource like initial frame dropper is designed to. 2. Adaptations can be on a different queue than the ResourceAdaptaitonProcessor's queue since updates are pushed through the listener. Bug: webrtc:11700 Change-Id: I6de0dec748dba095e702f0b9893c5afa50b51aa9 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176859 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@{#31615}
2020-07-01 11:47:46 +02:00
video_stream_adapter_->ClearRestrictions();
Clean resource_adaptation_processor_unittest use of TaskQueueForTest Use the current task queue in the test instead. R=hbos@webrtc.org Bug: None Change-Id: I266796df3de675a808bcf2da08901411fadc86ae Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176414 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31439}
2020-06-03 14:09:09 +02:00
EXPECT_EQ(0, restrictions_listener_.adaptation_counters().Total());
other_resource_->SetUsageState(ResourceUsageState::kOveruse);
EXPECT_EQ(1, restrictions_listener_.adaptation_counters().Total());
RestrictSource(restrictions_listener_.restrictions());
// resource_ did not overuse after we reset the restrictions, so adapt
// up should be disallowed.
resource_->SetUsageState(ResourceUsageState::kUnderuse);
EXPECT_EQ(1, restrictions_listener_.adaptation_counters().Total());
[Adaptation] Adapt up requires previous underuse The problem is that a resource that signals Underuse would be able to trigger an adapt up when it was never limited in the past. This means that an underused resource would be able to negate the adaptations made for an overused one. For example, consider a fast CPU on a bad link. The QP for the image is high but the CPU is underused. Without requiring previous underuse, everytime the QP would signal overuse and trigger an adpatation down, the CPU would signal underuse and trigger an adaptation up. This works today as we want by using the active counts in the VideoStreamEncoderResourceManager. This change makes it a normal behaviour independant of active counts. The problem with active counts is that is only works with 2 resources. When resources are injectable it no longer works as expected. Bug: webrtc:11522, webrtc:11523 Change-Id: I140636ce206d74e00a6b6f8558162bb8afffda1c Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/174482 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31181}
2020-05-07 13:45:14 +02:00
}
Only allow most limited resource to trigger adapt up A more detailed explaination is in the bug, but this changes the way that adaptation happens when multiple resources are limited. Only the one that is most limited can trigger an adaptation up. If multiple resources are most limited both need to underuse to adapt up. Some of the changes in this patch to make it all work: * VideoStreamEncoder unittests that did not reflect this new behaviour have been changed. * PeekNextRestrictions returns the adaptation counters as well as the restrictions. * Adaptation statstics have changed so that when adapting up all resources are tagged as triggering the adaptation. Additionally the statistics for the current adaptation is now the total number of adaptations per reason, rather then the number of adaptations due to that reason. * PreventAdaptUpDueToActiveCounts is removed as most limited resource is a strong implementation of that. Bug: webrtc:11553 Change-Id: If1545a201c8e019598edf82657a1befde8b05268 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176128 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Henrik Boström <hbos@webrtc.org> Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31497}
2020-06-11 10:45:29 +02:00
TEST_F(ResourceAdaptationProcessorTest, OnlyMostLimitedResourceMayAdaptUp) {
[Adaptation] Remove deg.prefs from ResourceAdaptationProcessor 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}
2020-07-07 09:04:34 +02:00
video_stream_adapter_->SetDegradationPreference(
Only allow most limited resource to trigger adapt up A more detailed explaination is in the bug, but this changes the way that adaptation happens when multiple resources are limited. Only the one that is most limited can trigger an adaptation up. If multiple resources are most limited both need to underuse to adapt up. Some of the changes in this patch to make it all work: * VideoStreamEncoder unittests that did not reflect this new behaviour have been changed. * PeekNextRestrictions returns the adaptation counters as well as the restrictions. * Adaptation statstics have changed so that when adapting up all resources are tagged as triggering the adaptation. Additionally the statistics for the current adaptation is now the total number of adaptations per reason, rather then the number of adaptations due to that reason. * PreventAdaptUpDueToActiveCounts is removed as most limited resource is a strong implementation of that. Bug: webrtc:11553 Change-Id: If1545a201c8e019598edf82657a1befde8b05268 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176128 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Henrik Boström <hbos@webrtc.org> Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31497}
2020-06-11 10:45:29 +02:00
DegradationPreference::MAINTAIN_FRAMERATE);
SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
resource_->SetUsageState(ResourceUsageState::kOveruse);
EXPECT_EQ(1, restrictions_listener_.adaptation_counters().Total());
RestrictSource(restrictions_listener_.restrictions());
other_resource_->SetUsageState(ResourceUsageState::kOveruse);
EXPECT_EQ(2, restrictions_listener_.adaptation_counters().Total());
RestrictSource(restrictions_listener_.restrictions());
// |other_resource_| is most limited, resource_ can't adapt up.
resource_->SetUsageState(ResourceUsageState::kUnderuse);
EXPECT_EQ(2, restrictions_listener_.adaptation_counters().Total());
RestrictSource(restrictions_listener_.restrictions());
other_resource_->SetUsageState(ResourceUsageState::kUnderuse);
EXPECT_EQ(1, restrictions_listener_.adaptation_counters().Total());
RestrictSource(restrictions_listener_.restrictions());
// |resource_| and |other_resource_| are now most limited, so both must
// signal underuse to adapt up.
other_resource_->SetUsageState(ResourceUsageState::kUnderuse);
EXPECT_EQ(1, restrictions_listener_.adaptation_counters().Total());
RestrictSource(restrictions_listener_.restrictions());
resource_->SetUsageState(ResourceUsageState::kUnderuse);
EXPECT_EQ(0, restrictions_listener_.adaptation_counters().Total());
RestrictSource(restrictions_listener_.restrictions());
}
[Adaptation] Adapt up requires previous underuse The problem is that a resource that signals Underuse would be able to trigger an adapt up when it was never limited in the past. This means that an underused resource would be able to negate the adaptations made for an overused one. For example, consider a fast CPU on a bad link. The QP for the image is high but the CPU is underused. Without requiring previous underuse, everytime the QP would signal overuse and trigger an adpatation down, the CPU would signal underuse and trigger an adaptation up. This works today as we want by using the active counts in the VideoStreamEncoderResourceManager. This change makes it a normal behaviour independant of active counts. The problem with active counts is that is only works with 2 resources. When resources are injectable it no longer works as expected. Bug: webrtc:11522, webrtc:11523 Change-Id: I140636ce206d74e00a6b6f8558162bb8afffda1c Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/174482 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31181}
2020-05-07 13:45:14 +02:00
TEST_F(ResourceAdaptationProcessorTest,
MultipleResourcesCanTriggerMultipleAdaptations) {
[Adaptation] Remove deg.prefs from ResourceAdaptationProcessor 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}
2020-07-07 09:04:34 +02:00
video_stream_adapter_->SetDegradationPreference(
Clean resource_adaptation_processor_unittest use of TaskQueueForTest Use the current task queue in the test instead. R=hbos@webrtc.org Bug: None Change-Id: I266796df3de675a808bcf2da08901411fadc86ae Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176414 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31439}
2020-06-03 14:09:09 +02:00
DegradationPreference::MAINTAIN_FRAMERATE);
SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
resource_->SetUsageState(ResourceUsageState::kOveruse);
EXPECT_EQ(1, restrictions_listener_.adaptation_counters().Total());
RestrictSource(restrictions_listener_.restrictions());
other_resource_->SetUsageState(ResourceUsageState::kOveruse);
EXPECT_EQ(2, restrictions_listener_.adaptation_counters().Total());
RestrictSource(restrictions_listener_.restrictions());
other_resource_->SetUsageState(ResourceUsageState::kOveruse);
EXPECT_EQ(3, restrictions_listener_.adaptation_counters().Total());
RestrictSource(restrictions_listener_.restrictions());
Only allow most limited resource to trigger adapt up A more detailed explaination is in the bug, but this changes the way that adaptation happens when multiple resources are limited. Only the one that is most limited can trigger an adaptation up. If multiple resources are most limited both need to underuse to adapt up. Some of the changes in this patch to make it all work: * VideoStreamEncoder unittests that did not reflect this new behaviour have been changed. * PeekNextRestrictions returns the adaptation counters as well as the restrictions. * Adaptation statstics have changed so that when adapting up all resources are tagged as triggering the adaptation. Additionally the statistics for the current adaptation is now the total number of adaptations per reason, rather then the number of adaptations due to that reason. * PreventAdaptUpDueToActiveCounts is removed as most limited resource is a strong implementation of that. Bug: webrtc:11553 Change-Id: If1545a201c8e019598edf82657a1befde8b05268 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176128 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Henrik Boström <hbos@webrtc.org> Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31497}
2020-06-11 10:45:29 +02:00
// resource_ is not most limited so can't adapt from underuse.
Clean resource_adaptation_processor_unittest use of TaskQueueForTest Use the current task queue in the test instead. R=hbos@webrtc.org Bug: None Change-Id: I266796df3de675a808bcf2da08901411fadc86ae Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176414 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31439}
2020-06-03 14:09:09 +02:00
resource_->SetUsageState(ResourceUsageState::kUnderuse);
Only allow most limited resource to trigger adapt up A more detailed explaination is in the bug, but this changes the way that adaptation happens when multiple resources are limited. Only the one that is most limited can trigger an adaptation up. If multiple resources are most limited both need to underuse to adapt up. Some of the changes in this patch to make it all work: * VideoStreamEncoder unittests that did not reflect this new behaviour have been changed. * PeekNextRestrictions returns the adaptation counters as well as the restrictions. * Adaptation statstics have changed so that when adapting up all resources are tagged as triggering the adaptation. Additionally the statistics for the current adaptation is now the total number of adaptations per reason, rather then the number of adaptations due to that reason. * PreventAdaptUpDueToActiveCounts is removed as most limited resource is a strong implementation of that. Bug: webrtc:11553 Change-Id: If1545a201c8e019598edf82657a1befde8b05268 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176128 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Henrik Boström <hbos@webrtc.org> Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31497}
2020-06-11 10:45:29 +02:00
EXPECT_EQ(3, restrictions_listener_.adaptation_counters().Total());
RestrictSource(restrictions_listener_.restrictions());
other_resource_->SetUsageState(ResourceUsageState::kUnderuse);
Clean resource_adaptation_processor_unittest use of TaskQueueForTest Use the current task queue in the test instead. R=hbos@webrtc.org Bug: None Change-Id: I266796df3de675a808bcf2da08901411fadc86ae Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176414 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31439}
2020-06-03 14:09:09 +02:00
EXPECT_EQ(2, restrictions_listener_.adaptation_counters().Total());
RestrictSource(restrictions_listener_.restrictions());
Only allow most limited resource to trigger adapt up A more detailed explaination is in the bug, but this changes the way that adaptation happens when multiple resources are limited. Only the one that is most limited can trigger an adaptation up. If multiple resources are most limited both need to underuse to adapt up. Some of the changes in this patch to make it all work: * VideoStreamEncoder unittests that did not reflect this new behaviour have been changed. * PeekNextRestrictions returns the adaptation counters as well as the restrictions. * Adaptation statstics have changed so that when adapting up all resources are tagged as triggering the adaptation. Additionally the statistics for the current adaptation is now the total number of adaptations per reason, rather then the number of adaptations due to that reason. * PreventAdaptUpDueToActiveCounts is removed as most limited resource is a strong implementation of that. Bug: webrtc:11553 Change-Id: If1545a201c8e019598edf82657a1befde8b05268 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176128 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Henrik Boström <hbos@webrtc.org> Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31497}
2020-06-11 10:45:29 +02:00
// resource_ is still not most limited so can't adapt from underuse.
Clean resource_adaptation_processor_unittest use of TaskQueueForTest Use the current task queue in the test instead. R=hbos@webrtc.org Bug: None Change-Id: I266796df3de675a808bcf2da08901411fadc86ae Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176414 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31439}
2020-06-03 14:09:09 +02:00
resource_->SetUsageState(ResourceUsageState::kUnderuse);
EXPECT_EQ(2, restrictions_listener_.adaptation_counters().Total());
RestrictSource(restrictions_listener_.restrictions());
Only allow most limited resource to trigger adapt up A more detailed explaination is in the bug, but this changes the way that adaptation happens when multiple resources are limited. Only the one that is most limited can trigger an adaptation up. If multiple resources are most limited both need to underuse to adapt up. Some of the changes in this patch to make it all work: * VideoStreamEncoder unittests that did not reflect this new behaviour have been changed. * PeekNextRestrictions returns the adaptation counters as well as the restrictions. * Adaptation statstics have changed so that when adapting up all resources are tagged as triggering the adaptation. Additionally the statistics for the current adaptation is now the total number of adaptations per reason, rather then the number of adaptations due to that reason. * PreventAdaptUpDueToActiveCounts is removed as most limited resource is a strong implementation of that. Bug: webrtc:11553 Change-Id: If1545a201c8e019598edf82657a1befde8b05268 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176128 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Henrik Boström <hbos@webrtc.org> Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31497}
2020-06-11 10:45:29 +02:00
// However it will be after overuse
resource_->SetUsageState(ResourceUsageState::kOveruse);
EXPECT_EQ(3, restrictions_listener_.adaptation_counters().Total());
RestrictSource(restrictions_listener_.restrictions());
// Now other_resource_ can't adapt up as it is not most restricted.
other_resource_->SetUsageState(ResourceUsageState::kUnderuse);
EXPECT_EQ(3, restrictions_listener_.adaptation_counters().Total());
RestrictSource(restrictions_listener_.restrictions());
// resource_ is limited at 3 adaptations and other_resource_ 2.
// With the most limited resource signalling underuse in the following
// order we get back to unrestricted video.
resource_->SetUsageState(ResourceUsageState::kUnderuse);
EXPECT_EQ(2, restrictions_listener_.adaptation_counters().Total());
RestrictSource(restrictions_listener_.restrictions());
// Both resource_ and other_resource_ are most limited.
Clean resource_adaptation_processor_unittest use of TaskQueueForTest Use the current task queue in the test instead. R=hbos@webrtc.org Bug: None Change-Id: I266796df3de675a808bcf2da08901411fadc86ae Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176414 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31439}
2020-06-03 14:09:09 +02:00
other_resource_->SetUsageState(ResourceUsageState::kUnderuse);
Only allow most limited resource to trigger adapt up A more detailed explaination is in the bug, but this changes the way that adaptation happens when multiple resources are limited. Only the one that is most limited can trigger an adaptation up. If multiple resources are most limited both need to underuse to adapt up. Some of the changes in this patch to make it all work: * VideoStreamEncoder unittests that did not reflect this new behaviour have been changed. * PeekNextRestrictions returns the adaptation counters as well as the restrictions. * Adaptation statstics have changed so that when adapting up all resources are tagged as triggering the adaptation. Additionally the statistics for the current adaptation is now the total number of adaptations per reason, rather then the number of adaptations due to that reason. * PreventAdaptUpDueToActiveCounts is removed as most limited resource is a strong implementation of that. Bug: webrtc:11553 Change-Id: If1545a201c8e019598edf82657a1befde8b05268 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176128 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Henrik Boström <hbos@webrtc.org> Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31497}
2020-06-11 10:45:29 +02:00
EXPECT_EQ(2, restrictions_listener_.adaptation_counters().Total());
RestrictSource(restrictions_listener_.restrictions());
resource_->SetUsageState(ResourceUsageState::kUnderuse);
EXPECT_EQ(1, restrictions_listener_.adaptation_counters().Total());
RestrictSource(restrictions_listener_.restrictions());
// Again both are most limited.
resource_->SetUsageState(ResourceUsageState::kUnderuse);
Clean resource_adaptation_processor_unittest use of TaskQueueForTest Use the current task queue in the test instead. R=hbos@webrtc.org Bug: None Change-Id: I266796df3de675a808bcf2da08901411fadc86ae Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176414 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31439}
2020-06-03 14:09:09 +02:00
EXPECT_EQ(1, restrictions_listener_.adaptation_counters().Total());
RestrictSource(restrictions_listener_.restrictions());
other_resource_->SetUsageState(ResourceUsageState::kUnderuse);
EXPECT_EQ(0, restrictions_listener_.adaptation_counters().Total());
Only allow most limited resource to trigger adapt up A more detailed explaination is in the bug, but this changes the way that adaptation happens when multiple resources are limited. Only the one that is most limited can trigger an adaptation up. If multiple resources are most limited both need to underuse to adapt up. Some of the changes in this patch to make it all work: * VideoStreamEncoder unittests that did not reflect this new behaviour have been changed. * PeekNextRestrictions returns the adaptation counters as well as the restrictions. * Adaptation statstics have changed so that when adapting up all resources are tagged as triggering the adaptation. Additionally the statistics for the current adaptation is now the total number of adaptations per reason, rather then the number of adaptations due to that reason. * PreventAdaptUpDueToActiveCounts is removed as most limited resource is a strong implementation of that. Bug: webrtc:11553 Change-Id: If1545a201c8e019598edf82657a1befde8b05268 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176128 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Henrik Boström <hbos@webrtc.org> Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31497}
2020-06-11 10:45:29 +02:00
}
TEST_F(ResourceAdaptationProcessorTest,
MostLimitedResourceAdaptationWorksAfterChangingDegradataionPreference) {
[Adaptation] Remove deg.prefs from ResourceAdaptationProcessor 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}
2020-07-07 09:04:34 +02:00
video_stream_adapter_->SetDegradationPreference(
Only allow most limited resource to trigger adapt up A more detailed explaination is in the bug, but this changes the way that adaptation happens when multiple resources are limited. Only the one that is most limited can trigger an adaptation up. If multiple resources are most limited both need to underuse to adapt up. Some of the changes in this patch to make it all work: * VideoStreamEncoder unittests that did not reflect this new behaviour have been changed. * PeekNextRestrictions returns the adaptation counters as well as the restrictions. * Adaptation statstics have changed so that when adapting up all resources are tagged as triggering the adaptation. Additionally the statistics for the current adaptation is now the total number of adaptations per reason, rather then the number of adaptations due to that reason. * PreventAdaptUpDueToActiveCounts is removed as most limited resource is a strong implementation of that. Bug: webrtc:11553 Change-Id: If1545a201c8e019598edf82657a1befde8b05268 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176128 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Henrik Boström <hbos@webrtc.org> Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31497}
2020-06-11 10:45:29 +02:00
DegradationPreference::MAINTAIN_FRAMERATE);
SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
// Adapt down until we can't anymore.
resource_->SetUsageState(ResourceUsageState::kOveruse);
RestrictSource(restrictions_listener_.restrictions());
resource_->SetUsageState(ResourceUsageState::kOveruse);
RestrictSource(restrictions_listener_.restrictions());
resource_->SetUsageState(ResourceUsageState::kOveruse);
RestrictSource(restrictions_listener_.restrictions());
resource_->SetUsageState(ResourceUsageState::kOveruse);
RestrictSource(restrictions_listener_.restrictions());
resource_->SetUsageState(ResourceUsageState::kOveruse);
Clean resource_adaptation_processor_unittest use of TaskQueueForTest Use the current task queue in the test instead. R=hbos@webrtc.org Bug: None Change-Id: I266796df3de675a808bcf2da08901411fadc86ae Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176414 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31439}
2020-06-03 14:09:09 +02:00
RestrictSource(restrictions_listener_.restrictions());
Only allow most limited resource to trigger adapt up A more detailed explaination is in the bug, but this changes the way that adaptation happens when multiple resources are limited. Only the one that is most limited can trigger an adaptation up. If multiple resources are most limited both need to underuse to adapt up. Some of the changes in this patch to make it all work: * VideoStreamEncoder unittests that did not reflect this new behaviour have been changed. * PeekNextRestrictions returns the adaptation counters as well as the restrictions. * Adaptation statstics have changed so that when adapting up all resources are tagged as triggering the adaptation. Additionally the statistics for the current adaptation is now the total number of adaptations per reason, rather then the number of adaptations due to that reason. * PreventAdaptUpDueToActiveCounts is removed as most limited resource is a strong implementation of that. Bug: webrtc:11553 Change-Id: If1545a201c8e019598edf82657a1befde8b05268 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176128 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Henrik Boström <hbos@webrtc.org> Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31497}
2020-06-11 10:45:29 +02:00
int last_total = restrictions_listener_.adaptation_counters().Total();
[Adaptation] Remove deg.prefs from ResourceAdaptationProcessor 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}
2020-07-07 09:04:34 +02:00
video_stream_adapter_->SetDegradationPreference(
Only allow most limited resource to trigger adapt up A more detailed explaination is in the bug, but this changes the way that adaptation happens when multiple resources are limited. Only the one that is most limited can trigger an adaptation up. If multiple resources are most limited both need to underuse to adapt up. Some of the changes in this patch to make it all work: * VideoStreamEncoder unittests that did not reflect this new behaviour have been changed. * PeekNextRestrictions returns the adaptation counters as well as the restrictions. * Adaptation statstics have changed so that when adapting up all resources are tagged as triggering the adaptation. Additionally the statistics for the current adaptation is now the total number of adaptations per reason, rather then the number of adaptations due to that reason. * PreventAdaptUpDueToActiveCounts is removed as most limited resource is a strong implementation of that. Bug: webrtc:11553 Change-Id: If1545a201c8e019598edf82657a1befde8b05268 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176128 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Henrik Boström <hbos@webrtc.org> Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31497}
2020-06-11 10:45:29 +02:00
DegradationPreference::MAINTAIN_RESOLUTION);
// resource_ can not adapt up since we have never reduced FPS.
resource_->SetUsageState(ResourceUsageState::kUnderuse);
EXPECT_EQ(last_total, restrictions_listener_.adaptation_counters().Total());
other_resource_->SetUsageState(ResourceUsageState::kOveruse);
EXPECT_EQ(last_total + 1,
restrictions_listener_.adaptation_counters().Total());
RestrictSource(restrictions_listener_.restrictions());
// other_resource_ is most limited so should be able to adapt up.
other_resource_->SetUsageState(ResourceUsageState::kUnderuse);
EXPECT_EQ(last_total, restrictions_listener_.adaptation_counters().Total());
[Adaptation] Adapt up requires previous underuse The problem is that a resource that signals Underuse would be able to trigger an adapt up when it was never limited in the past. This means that an underused resource would be able to negate the adaptations made for an overused one. For example, consider a fast CPU on a bad link. The QP for the image is high but the CPU is underused. Without requiring previous underuse, everytime the QP would signal overuse and trigger an adpatation down, the CPU would signal underuse and trigger an adaptation up. This works today as we want by using the active counts in the VideoStreamEncoderResourceManager. This change makes it a normal behaviour independant of active counts. The problem with active counts is that is only works with 2 resources. When resources are injectable it no longer works as expected. Bug: webrtc:11522, webrtc:11523 Change-Id: I140636ce206d74e00a6b6f8558162bb8afffda1c Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/174482 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31181}
2020-05-07 13:45:14 +02:00
}
[Adaptation] Remove Resource::UsageState() and ClearUsageState(). ResourceListener::OnResourceUsageStateMeasured() now takes ResourceUsageState as argument, making Resource::UsageState() superfluous. With the existing "fire-and-forget" behavior of always clearing usage state on reacting to a signal, there is no longer a need to call ClearUsageState() so this too is removed. (We may want to have a callback in the future to hint to the Resource that it is a good idea to clear internal measurement samples, i.e. because the load of the system is about to change, but we can revisit that when we need it.) Moving the usage state to the callback has the benefit of getting rid of the assumption that UsageState() has to return the same value every time it is called in the same task. This CL is also the final nail in the coffin for Resource needing to know about the adaptation task queue: ResourceAdaptationProcessor's ResourceListener now takes care of posting to the adaptation task queue. To support this, the processor's SequenceChecker is replaced by a TaskQueueBase pointer. Bug: webrtc:11525, webrtc:11618 Change-Id: I2277e71cc3759c85b62465020935603f03792c94 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176376 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@{#31416}
2020-06-03 09:21:34 +02:00
TEST_F(ResourceAdaptationProcessorTest,
AdaptsDownWhenOtherResourceIsAlwaysUnderused) {
[Adaptation] Remove deg.prefs from ResourceAdaptationProcessor 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}
2020-07-07 09:04:34 +02:00
video_stream_adapter_->SetDegradationPreference(
Clean resource_adaptation_processor_unittest use of TaskQueueForTest Use the current task queue in the test instead. R=hbos@webrtc.org Bug: None Change-Id: I266796df3de675a808bcf2da08901411fadc86ae Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176414 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31439}
2020-06-03 14:09:09 +02:00
DegradationPreference::MAINTAIN_FRAMERATE);
SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
other_resource_->SetUsageState(ResourceUsageState::kUnderuse);
// Does not trigger adapataion because there's no restriction.
EXPECT_EQ(0, restrictions_listener_.adaptation_counters().Total());
RestrictSource(restrictions_listener_.restrictions());
resource_->SetUsageState(ResourceUsageState::kOveruse);
// Adapts down even if other resource asked for adapting up.
EXPECT_EQ(1, restrictions_listener_.adaptation_counters().Total());
RestrictSource(restrictions_listener_.restrictions());
other_resource_->SetUsageState(ResourceUsageState::kUnderuse);
// Doesn't adapt up because adaptation is due to another resource.
EXPECT_EQ(1, restrictions_listener_.adaptation_counters().Total());
RestrictSource(restrictions_listener_.restrictions());
[Adaptation] Misc tests for processor, input provider and restrictions. This CL adds miscellaneous unit tests for the ResourceAdaptationProcessor, the VideoSourceRestrictions comparators and the VideoStreamInputStateProvider. Bug: webrtc:11172 Change-Id: If95f69644aaf2b43e3b19d5729bedef0b438c77b Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/174101 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@{#31147}
2020-04-29 16:46:30 +02:00
}
TEST_F(ResourceAdaptationProcessorTest,
[Adaptation] Remove Resource::UsageState() and ClearUsageState(). ResourceListener::OnResourceUsageStateMeasured() now takes ResourceUsageState as argument, making Resource::UsageState() superfluous. With the existing "fire-and-forget" behavior of always clearing usage state on reacting to a signal, there is no longer a need to call ClearUsageState() so this too is removed. (We may want to have a callback in the future to hint to the Resource that it is a good idea to clear internal measurement samples, i.e. because the load of the system is about to change, but we can revisit that when we need it.) Moving the usage state to the callback has the benefit of getting rid of the assumption that UsageState() has to return the same value every time it is called in the same task. This CL is also the final nail in the coffin for Resource needing to know about the adaptation task queue: ResourceAdaptationProcessor's ResourceListener now takes care of posting to the adaptation task queue. To support this, the processor's SequenceChecker is replaced by a TaskQueueBase pointer. Bug: webrtc:11525, webrtc:11618 Change-Id: I2277e71cc3759c85b62465020935603f03792c94 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176376 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@{#31416}
2020-06-03 09:21:34 +02:00
TriggerOveruseNotOnAdaptationTaskQueue) {
[Adaptation] Remove deg.prefs from ResourceAdaptationProcessor 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}
2020-07-07 09:04:34 +02:00
video_stream_adapter_->SetDegradationPreference(
Clean resource_adaptation_processor_unittest use of TaskQueueForTest Use the current task queue in the test instead. R=hbos@webrtc.org Bug: None Change-Id: I266796df3de675a808bcf2da08901411fadc86ae Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176414 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31439}
2020-06-03 14:09:09 +02:00
DegradationPreference::MAINTAIN_FRAMERATE);
SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
TaskQueueForTest resource_task_queue("ResourceTaskQueue");
resource_task_queue.PostTask(ToQueuedTask(
[&]() { resource_->SetUsageState(ResourceUsageState::kOveruse); }));
[Adaptation] Remove Resource::UsageState() and ClearUsageState(). ResourceListener::OnResourceUsageStateMeasured() now takes ResourceUsageState as argument, making Resource::UsageState() superfluous. With the existing "fire-and-forget" behavior of always clearing usage state on reacting to a signal, there is no longer a need to call ClearUsageState() so this too is removed. (We may want to have a callback in the future to hint to the Resource that it is a good idea to clear internal measurement samples, i.e. because the load of the system is about to change, but we can revisit that when we need it.) Moving the usage state to the callback has the benefit of getting rid of the assumption that UsageState() has to return the same value every time it is called in the same task. This CL is also the final nail in the coffin for Resource needing to know about the adaptation task queue: ResourceAdaptationProcessor's ResourceListener now takes care of posting to the adaptation task queue. To support this, the processor's SequenceChecker is replaced by a TaskQueueBase pointer. Bug: webrtc:11525, webrtc:11618 Change-Id: I2277e71cc3759c85b62465020935603f03792c94 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176376 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@{#31416}
2020-06-03 09:21:34 +02:00
EXPECT_EQ_WAIT(1u, restrictions_listener_.restrictions_updated_count(),
kDefaultTimeoutMs);
[Adaptation] Misc tests for processor, input provider and restrictions. This CL adds miscellaneous unit tests for the ResourceAdaptationProcessor, the VideoSourceRestrictions comparators and the VideoStreamInputStateProvider. Bug: webrtc:11172 Change-Id: If95f69644aaf2b43e3b19d5729bedef0b438c77b Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/174101 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@{#31147}
2020-04-29 16:46:30 +02:00
}
[Adaptation] Make QuailtyScalerResourse to report underuse if quality scaling is off Bug: chromium:1080789 Change-Id: I3aefb746fd6f4adae4b32db322af6b787e8ede1d Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/174804 Commit-Queue: Ilya Nikolaevskiy <ilnik@webrtc.org> Commit-Queue: Henrik Boström <hbos@webrtc.org> Reviewed-by: Henrik Boström <hbos@webrtc.org> Reviewed-by: Evan Shrubsole <eshr@google.com> Cr-Commit-Position: refs/heads/master@{#31213}
2020-05-11 15:33:23 +02:00
TEST_F(ResourceAdaptationProcessorTest,
[Adaptation] Remove Resource::UsageState() and ClearUsageState(). ResourceListener::OnResourceUsageStateMeasured() now takes ResourceUsageState as argument, making Resource::UsageState() superfluous. With the existing "fire-and-forget" behavior of always clearing usage state on reacting to a signal, there is no longer a need to call ClearUsageState() so this too is removed. (We may want to have a callback in the future to hint to the Resource that it is a good idea to clear internal measurement samples, i.e. because the load of the system is about to change, but we can revisit that when we need it.) Moving the usage state to the callback has the benefit of getting rid of the assumption that UsageState() has to return the same value every time it is called in the same task. This CL is also the final nail in the coffin for Resource needing to know about the adaptation task queue: ResourceAdaptationProcessor's ResourceListener now takes care of posting to the adaptation task queue. To support this, the processor's SequenceChecker is replaced by a TaskQueueBase pointer. Bug: webrtc:11525, webrtc:11618 Change-Id: I2277e71cc3759c85b62465020935603f03792c94 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176376 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@{#31416}
2020-06-03 09:21:34 +02:00
DestroyProcessorWhileResourceListenerDelegateHasTaskInFlight) {
[Adaptation] Remove deg.prefs from ResourceAdaptationProcessor 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}
2020-07-07 09:04:34 +02:00
video_stream_adapter_->SetDegradationPreference(
Clean resource_adaptation_processor_unittest use of TaskQueueForTest Use the current task queue in the test instead. R=hbos@webrtc.org Bug: None Change-Id: I266796df3de675a808bcf2da08901411fadc86ae Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176414 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31439}
2020-06-03 14:09:09 +02:00
DegradationPreference::MAINTAIN_FRAMERATE);
SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
// Wait for |resource_| to signal oversue first so we know that the delegate
// has passed it on to the processor's task queue.
rtc::Event resource_event;
TaskQueueForTest resource_task_queue("ResourceTaskQueue");
resource_task_queue.PostTask(ToQueuedTask([&]() {
resource_->SetUsageState(ResourceUsageState::kOveruse);
resource_event.Set();
}));
EXPECT_TRUE(resource_event.Wait(kDefaultTimeoutMs));
// Now destroy the processor while handling the overuse is in flight.
DestroyProcessor();
[Adaptation] Remove Resource::UsageState() and ClearUsageState(). ResourceListener::OnResourceUsageStateMeasured() now takes ResourceUsageState as argument, making Resource::UsageState() superfluous. With the existing "fire-and-forget" behavior of always clearing usage state on reacting to a signal, there is no longer a need to call ClearUsageState() so this too is removed. (We may want to have a callback in the future to hint to the Resource that it is a good idea to clear internal measurement samples, i.e. because the load of the system is about to change, but we can revisit that when we need it.) Moving the usage state to the callback has the benefit of getting rid of the assumption that UsageState() has to return the same value every time it is called in the same task. This CL is also the final nail in the coffin for Resource needing to know about the adaptation task queue: ResourceAdaptationProcessor's ResourceListener now takes care of posting to the adaptation task queue. To support this, the processor's SequenceChecker is replaced by a TaskQueueBase pointer. Bug: webrtc:11525, webrtc:11618 Change-Id: I2277e71cc3759c85b62465020935603f03792c94 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176376 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@{#31416}
2020-06-03 09:21:34 +02:00
// Because the processor was destroyed by the time the delegate's task ran,
// the overuse signal must not have been handled.
EXPECT_EQ(0u, restrictions_listener_.restrictions_updated_count());
[Adaptation] Make QuailtyScalerResourse to report underuse if quality scaling is off Bug: chromium:1080789 Change-Id: I3aefb746fd6f4adae4b32db322af6b787e8ede1d Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/174804 Commit-Queue: Ilya Nikolaevskiy <ilnik@webrtc.org> Commit-Queue: Henrik Boström <hbos@webrtc.org> Reviewed-by: Henrik Boström <hbos@webrtc.org> Reviewed-by: Evan Shrubsole <eshr@google.com> Cr-Commit-Position: refs/heads/master@{#31213}
2020-05-11 15:33:23 +02:00
}
[Adaptation] Implement remove for most limited resources. When a resource is removed from the ResourceAdaptationProcessor, and the resource is the most limited resource, we reset the current adaptation to the next most limited resource level. In the case that this resource is the only adapted resource then we reset all adaptations. Bug: webrtc:11636 Change-Id: I29acc5a3934f42f00db79b3bb2171156b1313937 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176406 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org> Reviewed-by: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31520}
2020-06-12 16:00:03 +02:00
TEST_F(ResourceAdaptationProcessorTest,
ResourceOveruseIgnoredWhenSignalledDuringRemoval) {
[Adaptation] Remove deg.prefs from ResourceAdaptationProcessor 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}
2020-07-07 09:04:34 +02:00
video_stream_adapter_->SetDegradationPreference(
[Adaptation] Implement remove for most limited resources. When a resource is removed from the ResourceAdaptationProcessor, and the resource is the most limited resource, we reset the current adaptation to the next most limited resource level. In the case that this resource is the only adapted resource then we reset all adaptations. Bug: webrtc:11636 Change-Id: I29acc5a3934f42f00db79b3bb2171156b1313937 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176406 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org> Reviewed-by: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31520}
2020-06-12 16:00:03 +02:00
DegradationPreference::MAINTAIN_FRAMERATE);
SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
rtc::Event overuse_event;
TaskQueueForTest resource_task_queue("ResourceTaskQueue");
// Queues task for |resource_| overuse while |processor_| is still listening.
resource_task_queue.PostTask(ToQueuedTask([&]() {
resource_->SetUsageState(ResourceUsageState::kOveruse);
overuse_event.Set();
}));
EXPECT_TRUE(overuse_event.Wait(kDefaultTimeoutMs));
// Once we know the overuse task is queued, remove |resource_| so that
// |processor_| is not listening to it.
processor_->RemoveResource(resource_);
// Runs the queued task so |processor_| gets signalled kOveruse from
// |resource_| even though |processor_| was not listening.
WaitUntilTaskQueueIdle();
// No restrictions should change even though |resource_| signaled |kOveruse|.
EXPECT_EQ(0u, restrictions_listener_.restrictions_updated_count());
// Delete |resource_| for cleanup.
resource_ = nullptr;
}
TEST_F(ResourceAdaptationProcessorTest,
RemovingOnlyAdaptedResourceResetsAdaptation) {
[Adaptation] Remove deg.prefs from ResourceAdaptationProcessor 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}
2020-07-07 09:04:34 +02:00
video_stream_adapter_->SetDegradationPreference(
[Adaptation] Implement remove for most limited resources. When a resource is removed from the ResourceAdaptationProcessor, and the resource is the most limited resource, we reset the current adaptation to the next most limited resource level. In the case that this resource is the only adapted resource then we reset all adaptations. Bug: webrtc:11636 Change-Id: I29acc5a3934f42f00db79b3bb2171156b1313937 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176406 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org> Reviewed-by: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31520}
2020-06-12 16:00:03 +02:00
DegradationPreference::MAINTAIN_FRAMERATE);
SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
resource_->SetUsageState(ResourceUsageState::kOveruse);
EXPECT_EQ(1, restrictions_listener_.adaptation_counters().Total());
RestrictSource(restrictions_listener_.restrictions());
processor_->RemoveResource(resource_);
EXPECT_EQ(0, restrictions_listener_.adaptation_counters().Total());
// Delete |resource_| for cleanup.
resource_ = nullptr;
}
TEST_F(ResourceAdaptationProcessorTest,
RemovingMostLimitedResourceSetsAdaptationToNextLimitedLevel) {
[Adaptation] Remove deg.prefs from ResourceAdaptationProcessor 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}
2020-07-07 09:04:34 +02:00
video_stream_adapter_->SetDegradationPreference(
DegradationPreference::BALANCED);
[Adaptation] Implement remove for most limited resources. When a resource is removed from the ResourceAdaptationProcessor, and the resource is the most limited resource, we reset the current adaptation to the next most limited resource level. In the case that this resource is the only adapted resource then we reset all adaptations. Bug: webrtc:11636 Change-Id: I29acc5a3934f42f00db79b3bb2171156b1313937 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176406 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org> Reviewed-by: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31520}
2020-06-12 16:00:03 +02:00
SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
other_resource_->SetUsageState(ResourceUsageState::kOveruse);
RestrictSource(restrictions_listener_.restrictions());
EXPECT_EQ(1, restrictions_listener_.adaptation_counters().Total());
VideoSourceRestrictions next_limited_restrictions =
restrictions_listener_.restrictions();
VideoAdaptationCounters next_limited_counters =
restrictions_listener_.adaptation_counters();
resource_->SetUsageState(ResourceUsageState::kOveruse);
RestrictSource(restrictions_listener_.restrictions());
EXPECT_EQ(2, restrictions_listener_.adaptation_counters().Total());
// Removing most limited |resource_| should revert us back to
processor_->RemoveResource(resource_);
EXPECT_EQ(1, restrictions_listener_.adaptation_counters().Total());
EXPECT_EQ(next_limited_restrictions, restrictions_listener_.restrictions());
EXPECT_EQ(next_limited_counters,
restrictions_listener_.adaptation_counters());
// Delete |resource_| for cleanup.
resource_ = nullptr;
}
TEST_F(ResourceAdaptationProcessorTest,
RemovingMostLimitedResourceSetsAdaptationIfInputStateUnchanged) {
[Adaptation] Remove deg.prefs from ResourceAdaptationProcessor 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}
2020-07-07 09:04:34 +02:00
video_stream_adapter_->SetDegradationPreference(
[Adaptation] Implement remove for most limited resources. When a resource is removed from the ResourceAdaptationProcessor, and the resource is the most limited resource, we reset the current adaptation to the next most limited resource level. In the case that this resource is the only adapted resource then we reset all adaptations. Bug: webrtc:11636 Change-Id: I29acc5a3934f42f00db79b3bb2171156b1313937 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176406 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org> Reviewed-by: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31520}
2020-06-12 16:00:03 +02:00
DegradationPreference::MAINTAIN_FRAMERATE);
SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
other_resource_->SetUsageState(ResourceUsageState::kOveruse);
RestrictSource(restrictions_listener_.restrictions());
EXPECT_EQ(1, restrictions_listener_.adaptation_counters().Total());
VideoSourceRestrictions next_limited_restrictions =
restrictions_listener_.restrictions();
VideoAdaptationCounters next_limited_counters =
restrictions_listener_.adaptation_counters();
// Overuse twice and underuse once. After the underuse we don't restrict the
// source. Normally this would block future underuses.
resource_->SetUsageState(ResourceUsageState::kOveruse);
RestrictSource(restrictions_listener_.restrictions());
resource_->SetUsageState(ResourceUsageState::kOveruse);
RestrictSource(restrictions_listener_.restrictions());
resource_->SetUsageState(ResourceUsageState::kUnderuse);
EXPECT_EQ(2, restrictions_listener_.adaptation_counters().Total());
// Removing most limited |resource_| should revert us back to, even though we
// did not call RestrictSource() after |resource_| was overused. Normally
// adaptation for MAINTAIN_FRAMERATE would be blocked here but for removal we
// allow this anyways.
processor_->RemoveResource(resource_);
EXPECT_EQ(1, restrictions_listener_.adaptation_counters().Total());
EXPECT_EQ(next_limited_restrictions, restrictions_listener_.restrictions());
EXPECT_EQ(next_limited_counters,
restrictions_listener_.adaptation_counters());
// Delete |resource_| for cleanup.
resource_ = nullptr;
}
TEST_F(ResourceAdaptationProcessorTest,
RemovingResourceNotMostLimitedHasNoEffectOnLimitations) {
[Adaptation] Remove deg.prefs from ResourceAdaptationProcessor 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}
2020-07-07 09:04:34 +02:00
video_stream_adapter_->SetDegradationPreference(
DegradationPreference::BALANCED);
[Adaptation] Implement remove for most limited resources. When a resource is removed from the ResourceAdaptationProcessor, and the resource is the most limited resource, we reset the current adaptation to the next most limited resource level. In the case that this resource is the only adapted resource then we reset all adaptations. Bug: webrtc:11636 Change-Id: I29acc5a3934f42f00db79b3bb2171156b1313937 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176406 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org> Reviewed-by: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31520}
2020-06-12 16:00:03 +02:00
SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
other_resource_->SetUsageState(ResourceUsageState::kOveruse);
RestrictSource(restrictions_listener_.restrictions());
EXPECT_EQ(1, restrictions_listener_.adaptation_counters().Total());
resource_->SetUsageState(ResourceUsageState::kOveruse);
RestrictSource(restrictions_listener_.restrictions());
VideoSourceRestrictions current_restrictions =
restrictions_listener_.restrictions();
VideoAdaptationCounters current_counters =
restrictions_listener_.adaptation_counters();
EXPECT_EQ(2, restrictions_listener_.adaptation_counters().Total());
// Removing most limited |resource_| should revert us back to
processor_->RemoveResource(other_resource_);
EXPECT_EQ(current_restrictions, restrictions_listener_.restrictions());
EXPECT_EQ(current_counters, restrictions_listener_.adaptation_counters());
// Delete |other_resource_| for cleanup.
other_resource_ = nullptr;
}
TEST_F(ResourceAdaptationProcessorTest,
RemovingMostLimitedResourceAfterSwitchingDegradationPreferences) {
[Adaptation] Remove deg.prefs from ResourceAdaptationProcessor 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}
2020-07-07 09:04:34 +02:00
video_stream_adapter_->SetDegradationPreference(
[Adaptation] Implement remove for most limited resources. When a resource is removed from the ResourceAdaptationProcessor, and the resource is the most limited resource, we reset the current adaptation to the next most limited resource level. In the case that this resource is the only adapted resource then we reset all adaptations. Bug: webrtc:11636 Change-Id: I29acc5a3934f42f00db79b3bb2171156b1313937 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176406 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org> Reviewed-by: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31520}
2020-06-12 16:00:03 +02:00
DegradationPreference::MAINTAIN_FRAMERATE);
SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
other_resource_->SetUsageState(ResourceUsageState::kOveruse);
RestrictSource(restrictions_listener_.restrictions());
EXPECT_EQ(1, restrictions_listener_.adaptation_counters().Total());
VideoSourceRestrictions next_limited_restrictions =
restrictions_listener_.restrictions();
VideoAdaptationCounters next_limited_counters =
restrictions_listener_.adaptation_counters();
[Adaptation] Remove deg.prefs from ResourceAdaptationProcessor 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}
2020-07-07 09:04:34 +02:00
video_stream_adapter_->SetDegradationPreference(
[Adaptation] Implement remove for most limited resources. When a resource is removed from the ResourceAdaptationProcessor, and the resource is the most limited resource, we reset the current adaptation to the next most limited resource level. In the case that this resource is the only adapted resource then we reset all adaptations. Bug: webrtc:11636 Change-Id: I29acc5a3934f42f00db79b3bb2171156b1313937 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176406 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org> Reviewed-by: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31520}
2020-06-12 16:00:03 +02:00
DegradationPreference::MAINTAIN_RESOLUTION);
resource_->SetUsageState(ResourceUsageState::kOveruse);
RestrictSource(restrictions_listener_.restrictions());
EXPECT_EQ(2, restrictions_listener_.adaptation_counters().Total());
// Revert to |other_resource_| when removing |resource_| even though the
// degradation preference was different when it was overused.
processor_->RemoveResource(resource_);
EXPECT_EQ(next_limited_counters,
restrictions_listener_.adaptation_counters());
// After switching back to MAINTAIN_FRAMERATE, the next most limited settings
// are restored.
[Adaptation] Remove deg.prefs from ResourceAdaptationProcessor 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}
2020-07-07 09:04:34 +02:00
video_stream_adapter_->SetDegradationPreference(
[Adaptation] Implement remove for most limited resources. When a resource is removed from the ResourceAdaptationProcessor, and the resource is the most limited resource, we reset the current adaptation to the next most limited resource level. In the case that this resource is the only adapted resource then we reset all adaptations. Bug: webrtc:11636 Change-Id: I29acc5a3934f42f00db79b3bb2171156b1313937 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176406 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org> Reviewed-by: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31520}
2020-06-12 16:00:03 +02:00
DegradationPreference::MAINTAIN_FRAMERATE);
EXPECT_EQ(next_limited_restrictions, restrictions_listener_.restrictions());
// Delete |resource_| for cleanup.
resource_ = nullptr;
}
TEST_F(ResourceAdaptationProcessorTest,
RemovingMostLimitedResourceSetsNextLimitationsInDisabled) {
[Adaptation] Remove deg.prefs from ResourceAdaptationProcessor 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}
2020-07-07 09:04:34 +02:00
video_stream_adapter_->SetDegradationPreference(
[Adaptation] Implement remove for most limited resources. When a resource is removed from the ResourceAdaptationProcessor, and the resource is the most limited resource, we reset the current adaptation to the next most limited resource level. In the case that this resource is the only adapted resource then we reset all adaptations. Bug: webrtc:11636 Change-Id: I29acc5a3934f42f00db79b3bb2171156b1313937 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176406 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org> Reviewed-by: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31520}
2020-06-12 16:00:03 +02:00
DegradationPreference::MAINTAIN_FRAMERATE);
SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
other_resource_->SetUsageState(ResourceUsageState::kOveruse);
RestrictSource(restrictions_listener_.restrictions());
VideoSourceRestrictions next_limited_restrictions =
restrictions_listener_.restrictions();
VideoAdaptationCounters next_limited_counters =
restrictions_listener_.adaptation_counters();
EXPECT_EQ(1, restrictions_listener_.adaptation_counters().Total());
resource_->SetUsageState(ResourceUsageState::kOveruse);
RestrictSource(restrictions_listener_.restrictions());
EXPECT_EQ(2, restrictions_listener_.adaptation_counters().Total());
[Adaptation] Remove deg.prefs from ResourceAdaptationProcessor 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}
2020-07-07 09:04:34 +02:00
video_stream_adapter_->SetDegradationPreference(
DegradationPreference::DISABLED);
[Adaptation] Implement remove for most limited resources. When a resource is removed from the ResourceAdaptationProcessor, and the resource is the most limited resource, we reset the current adaptation to the next most limited resource level. In the case that this resource is the only adapted resource then we reset all adaptations. Bug: webrtc:11636 Change-Id: I29acc5a3934f42f00db79b3bb2171156b1313937 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176406 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org> Reviewed-by: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31520}
2020-06-12 16:00:03 +02:00
// Revert to |other_resource_| when removing |resource_| even though the
// current degradataion preference is disabled.
processor_->RemoveResource(resource_);
// After switching back to MAINTAIN_FRAMERATE, the next most limited settings
// are restored.
[Adaptation] Remove deg.prefs from ResourceAdaptationProcessor 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}
2020-07-07 09:04:34 +02:00
video_stream_adapter_->SetDegradationPreference(
[Adaptation] Implement remove for most limited resources. When a resource is removed from the ResourceAdaptationProcessor, and the resource is the most limited resource, we reset the current adaptation to the next most limited resource level. In the case that this resource is the only adapted resource then we reset all adaptations. Bug: webrtc:11636 Change-Id: I29acc5a3934f42f00db79b3bb2171156b1313937 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176406 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org> Reviewed-by: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31520}
2020-06-12 16:00:03 +02:00
DegradationPreference::MAINTAIN_FRAMERATE);
EXPECT_EQ(next_limited_restrictions, restrictions_listener_.restrictions());
EXPECT_EQ(next_limited_counters,
restrictions_listener_.adaptation_counters());
// Delete |resource_| for cleanup.
resource_ = nullptr;
}
TEST_F(ResourceAdaptationProcessorTest,
RemovedResourceSignalsIgnoredByProcessor) {
[Adaptation] Remove deg.prefs from ResourceAdaptationProcessor 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}
2020-07-07 09:04:34 +02:00
video_stream_adapter_->SetDegradationPreference(
[Adaptation] Implement remove for most limited resources. When a resource is removed from the ResourceAdaptationProcessor, and the resource is the most limited resource, we reset the current adaptation to the next most limited resource level. In the case that this resource is the only adapted resource then we reset all adaptations. Bug: webrtc:11636 Change-Id: I29acc5a3934f42f00db79b3bb2171156b1313937 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176406 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org> Reviewed-by: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31520}
2020-06-12 16:00:03 +02:00
DegradationPreference::MAINTAIN_FRAMERATE);
SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
processor_->RemoveResource(resource_);
resource_->SetUsageState(ResourceUsageState::kOveruse);
EXPECT_EQ(0u, restrictions_listener_.restrictions_updated_count());
// Delete |resource_| for cleanup.
resource_ = nullptr;
}
TEST_F(ResourceAdaptationProcessorTest,
RemovingResourceWhenMultipleMostLimtedHasNoEffect) {
[Adaptation] Remove deg.prefs from ResourceAdaptationProcessor 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}
2020-07-07 09:04:34 +02:00
video_stream_adapter_->SetDegradationPreference(
[Adaptation] Implement remove for most limited resources. When a resource is removed from the ResourceAdaptationProcessor, and the resource is the most limited resource, we reset the current adaptation to the next most limited resource level. In the case that this resource is the only adapted resource then we reset all adaptations. Bug: webrtc:11636 Change-Id: I29acc5a3934f42f00db79b3bb2171156b1313937 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176406 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org> Reviewed-by: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31520}
2020-06-12 16:00:03 +02:00
DegradationPreference::MAINTAIN_FRAMERATE);
SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
other_resource_->SetUsageState(ResourceUsageState::kOveruse);
RestrictSource(restrictions_listener_.restrictions());
EXPECT_EQ(1, restrictions_listener_.adaptation_counters().Total());
// Adapt |resource_| up and then down so that both resource's are most
// limited at 1 adaptation.
resource_->SetUsageState(ResourceUsageState::kOveruse);
RestrictSource(restrictions_listener_.restrictions());
resource_->SetUsageState(ResourceUsageState::kUnderuse);
RestrictSource(restrictions_listener_.restrictions());
EXPECT_EQ(1, restrictions_listener_.adaptation_counters().Total());
// Removing |resource_| has no effect since both |resource_| and
// |other_resource_| are most limited.
processor_->RemoveResource(resource_);
EXPECT_EQ(1, restrictions_listener_.adaptation_counters().Total());
// Delete |resource_| for cleanup.
resource_ = nullptr;
}
[Adaptation] Make resource most limited if kLimitReached hit This occurs when a resource causes an adaptation down but the current adaptations can not be adapted any more. Any further adaptation will result in the status kLimitReached, and so any resource that adapts down should also be most limited. Bug: webrtc:11695 Change-Id: Idfdf23f482b1b4a132cec49a9be76adc0aec4361 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/181586 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31933}
2020-08-14 10:08:54 +02:00
TEST_F(ResourceAdaptationProcessorTest,
ResourceOverusedAtLimitReachedWillShareMostLimited) {
video_stream_adapter_->SetDegradationPreference(
DegradationPreference::MAINTAIN_FRAMERATE);
SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
bool has_reached_min_pixels = false;
ON_CALL(frame_rate_provider_, OnMinPixelLimitReached())
.WillByDefault(testing::Assign(&has_reached_min_pixels, true));
// Adapt 10 times, which should make us hit the limit.
for (int i = 0; i < 10; ++i) {
resource_->SetUsageState(ResourceUsageState::kOveruse);
RestrictSource(restrictions_listener_.restrictions());
}
EXPECT_TRUE(has_reached_min_pixels);
auto last_update_count = restrictions_listener_.restrictions_updated_count();
other_resource_->SetUsageState(ResourceUsageState::kOveruse);
// Now both |resource_| and |other_resource_| are most limited. Underuse of
// |resource_| will not adapt up.
resource_->SetUsageState(ResourceUsageState::kUnderuse);
EXPECT_EQ(last_update_count,
restrictions_listener_.restrictions_updated_count());
}
[Adaptation] Misc tests for processor, input provider and restrictions. This CL adds miscellaneous unit tests for the ResourceAdaptationProcessor, the VideoSourceRestrictions comparators and the VideoStreamInputStateProvider. Bug: webrtc:11172 Change-Id: If95f69644aaf2b43e3b19d5729bedef0b438c77b Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/174101 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@{#31147}
2020-04-29 16:46:30 +02:00
} // namespace webrtc
Reference in New Issue Copy Permalink