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

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

132 lines
4.5 KiB
Plaintext
Raw Normal View History

Initial version of ResourceAdaptationProcessor and friends. This CL adds Resource, ResourceConsumer, ResourceConsumerConfiguration and ResourceAdaptationProcessor and implements the algorithm outlined in https://docs.google.com/presentation/d/13jyqCWNpIa873iKT6yDuB5Q5ma-c0CvxBpX--0tCclY/edit?usp=sharing. Simply put, if any resource (such as "CPU") is overusing, the most expensive consumer (e.g. encoded stream) is adapted one step down. If all resources are underusing, the least expensive consumer is adapted one step up. The current resources, consumers and configurations are all fakes; this CL has no effect on the current adaptation algorithms used in practise, but it lays down the foundation for future work in this area. Bug: webrtc:11167, webrtc:11168, webrtc:11169 Change-Id: I4054ec7728a52a49e137eee6fa67fa27debd9254 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/161237 Commit-Queue: Henrik Boström <hbos@webrtc.org> Reviewed-by: Evan Shrubsole <eshr@google.com> Reviewed-by: Stefan Holmer <stefan@webrtc.org> Reviewed-by: Erik Språng <sprang@webrtc.org> Cr-Commit-Position: refs/heads/master@{#30053}
2019-12-10 14:14:09 +01:00
# Copyright (c) 2019 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.
import("../../webrtc.gni")
rtc_library("resource_adaptation") {
sources = [
[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
"adaptation_constraint.cc",
"adaptation_constraint.h",
[Adaptation] Multi-processor support for injected Resources. Because a single Resource only has a single ResourceListener, injected Resources only gets wired up to the stream's ResourceAdaptationProcessor that was last to call SetResourceListener. This could potentially lead to the relevant stream not adapting based on the injected resource because it got wired up to the wrong stream's processor. This CL fixes this issue by introducing BroadcastResourceListener. By listening to 1 resource (the injected one), it can spawn N "adapter" resources that mirror's the injected resource's usage signal, allowing all ResourceAdaptationProcessor's to react to the signal. This is wired up in Call, and tests are updated to verify the signal gets through. Bug: chromium:1101263, webrtc:11720 Change-Id: I8a37284cb9a68f08ca1bdb1ee050b7144c451297 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/178386 Reviewed-by: Stefan Holmer <stefan@webrtc.org> Reviewed-by: Evan Shrubsole <eshr@google.com> Commit-Queue: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31612}
2020-07-01 15:48:46 +02:00
"broadcast_resource_listener.cc",
"broadcast_resource_listener.h",
[Adaptation] Move deg.pref. out of ResourceAdaptationProcessor This patch creates a new class which provides the DegradationPreference thread safe to all classes that need if (BalancedConstraint and QpScalerResource). It also broadcasts to all listeners when the preferences are updated, so the ResourceAdaptationProcessor can update the video if needed. In future work, this could be used to remove the need for two task queues for the VideoStreamEncoder resources. Bug: webrtc:11700 Change-Id: I05480db8b7157b5643f6f86ec9c64850839b3e76 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/177522 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@{#31623}
2020-07-03 13:51:48 +02:00
"degradation_preference_provider.cc",
"degradation_preference_provider.h",
[Overuse] Make VideoStreamAdapter responsible for executing adaptation. This CL moves GetAdaptUpTarget(), GetAdaptDownTarget() and ApplyAdaptationTarget() - and related code - to the VideoStreamAdapter. This includes pieces related to calculating how to adapt, including: - DegradationPreference - BalancedDegradationPreference - AdaptationRequest and last_adaptation_request_ - CanAdaptUpResolution() The VideoStreamAdapter's interface has changed: VideoSourceRestrictor methods are now hidden in favor of methods exposing AdaptationTarget. This CL also does some misc moves: - GetEncoderBitrateLimits is moved and renamed to VideoEncoder::EncoderInfo::GetEncoderBitrateLimitsForResolution. - EncoderSettings moved to a separate file. // For api/video_codecs/video_encoder.[cc/h] changes, which is the // moving of a function. TBR=sprang@webrtc.org Bug: webrtc:11393 Change-Id: Ie6bd8ef644ce927d7eca6ab90a0a7bcace682f3c Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/169842 Reviewed-by: Henrik Boström <hbos@webrtc.org> 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@{#30708}
2020-03-06 13:32:03 +01:00
"encoder_settings.cc",
"encoder_settings.h",
[Adaptation] Introducing call/adaptation/ResourceAdaptationProcessor. This CL is part of the Call-Level Adaptation Processing design doc: https://docs.google.com/document/d/1ZyC26yOCknrrcYa839ZWLxD6o6Gig5A3lVTh4E41074/edit?usp=sharing This gets to the heart of unblocking call-level adaptation, largely made possible due to the previous CLs in the chain. The parts of the code that are responsible for responding to resource usage signals, obtaining adaptations and applying them are moved to ResourceAdaptationProcessor in call/adaptation/. The parts of the code that are responsible for managing VideoStreamEncoder-specific resources stay inside the VideoStreamEncoderResourceManager class in video/adaptation/. After this CL lands it should soon be possible to move the Processor over to a separate task queue and let the Manager stay on the encoder queue if PostTasks are added for communication between the two objects. Bug: webrtc:11172 Change-Id: Ifa212467b4afd16e7ebfb9adfe17d2dca1cb7d67 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/173021 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@{#31105}
2020-04-17 18:36:19 +02:00
"resource_adaptation_processor.cc",
"resource_adaptation_processor.h",
[Adaptation] Rename and move resource adaptation module/processor stuff. Rename: - call/adaptation/resource_adaptation_module_interface.[h/cc] --> call/adaptation/resource_adaptation_processor_interface.[h/cc] - call/adaptation/resource_adaptation_processor.[h/cc] --> call/adaptation/new_resource_adaptation_processor_poc.[h/cc] Move + Rename: - video/overuse_frame_detector_resource_adaptation_module.[h/cc] --> video/adaptation/resource_adaptation_processor.[h/cc] Move: - video/encode_usage_resource.[h/cc] --> video/adaptation/... - video/overuse_frame_detector.[h/cc] --> video/adaptation/... - video/quality_scaler_resource.[h/cc] --> video/adaptation/... Unittests are also moved. In order to avoid a circular dependency, VideoStreamEncoder::kDefaultLastFrameInfo[Width/Height] is moved and renamed to kDefaultInputPixels[Width/Height] in video/adaptation/resource_adaptation_processor.[h/cc]. Bug: webrtc:11222 Change-Id: Icf920e8a7362002b1c63c42b2d9e2e63c990b532 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/170117 Reviewed-by: Evan Shrubsole <eshr@google.com> Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org> Reviewed-by: Niels Moller <nisse@webrtc.org> Commit-Queue: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#30754}
2020-03-10 19:08:05 +01:00
"resource_adaptation_processor_interface.cc",
"resource_adaptation_processor_interface.h",
VideoStreamEncoder configuring source/sink with VideoSourceController. This is part of the work for making VideoStreamEncoder responsible for configuring its source/sink and limiting the responsibility of OveruseFrameDetectorResourceAdaptationModule to only output relevant VideoSourceRestrictions. BEFORE THIS CL Prior to this CL, OveruseFrameDetector was responsible for performing AddOrUpdateSink() on the source, which it did using its nested class VideoSourceProxy. AddOrUpdateSink() could happen for both adaptation and non-adaptation related reasons. For example: - Adaptation related: AdaptUp() or AdaptDown() happens, causing updated VideoSourceRestrictions. - Non-adaptation related: VideoStreamEncoder asks the module to reconfigure the source/sink for it, such as with SetMaxFramerateAndAlignment() or SetWantsRotationApplied(). AFTER THIS CL AddOrUpdateSink() is performed by VideoSourceController, which is owned by VideoStreamEncoder. Any reconfiguration has to go through the VideoStreamEncoder. This means that: - Non-adaptation related settings happen between VideoStreamEncoder and VideoSourceController directly (without going through the adaptation module). - Adaptation related changes can be expressed in terms of VideoSourceRestrictions. OveruseFrameDetectorResourceAdaptationModule only has to output the restrictions and not know or care about other source/sink settings. For now, VideoSourceController has to know about DegradationPreference. In a future CL, the DegradationPreference logic should move back to the adaptation module. The VideoSourceRestrictions are fully capable of expressing all possible source/sink values without the "modifier" that is the degradation preference. Bug: webrtc:11222 Change-Id: I0f058c4700ca108e2d9f212e38b61f6f728aa419 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/162802 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@{#30228}
2020-01-13 11:27:18 +01:00
"video_source_restrictions.cc",
"video_source_restrictions.h",
[Adaptation] Move VideoStreamAdapter to call/adaptation/. This CL is part of the Call-Level Adaptation Processing design doc: https://docs.google.com/document/d/1ZyC26yOCknrrcYa839ZWLxD6o6Gig5A3lVTh4E41074/edit?usp=sharing This is a pure move CL. In the future, the Processor will live in call/adaptation/. This prevents circular dependencies. Bug: webrtc:11172 Change-Id: Ib72503cc20e27ab6425538e3d55930c65e0b4a90 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/172931 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@{#31100}
2020-04-17 14:40:39 +02:00
"video_stream_adapter.cc",
"video_stream_adapter.h",
[Adaptation] Introduce VideoStreamInputState and its Provider. This CL is part of the Call-Level Adaptation Processing design doc: https://docs.google.com/document/d/1ZyC26yOCknrrcYa839ZWLxD6o6Gig5A3lVTh4E41074/edit?usp=sharing The "input state" of a VideoStream, needed for adaptation and decision-making, are: source resolution and frame rate, codec type and min pixels per frame (based on encoder scaling settings). These values are modified on the encoder queue of the VideoStreamEncoder. But in order to unblock call-level adaptation processing, where adaptation and decision making happens off the encoder queue, a snapshot of the input states need to be available at point of processing: introducing the VideoStreamInputState. In this CL, the VideoStreamInputStateProvider is added to provide input state snapshots across threads based on input from VideoStreamEncoder and VideoStreamEncoderObserver. The input state's HasInputFrameSizeAndFramesPerSecond() can now be DCHECKed inside the VideoStreamAdapter in favor of having less Adaptation::Status codes. Whether input is "sufficient" for adaptation is now the responsibility of the Processor. (Goal: adapter is purely a Adaptation generator and apply-er.) Somewhat tangental, this CL also deletes VideoStreamEncoder-specific methods from ResourceAdaptationProcessorInterface making them an implementation detail of ResourceAdaptationProcessor. In a future CL, the "processor" will be split up into a "processor" part and a "video stream encoder resource manager" part - more on that later. Bug: webrtc:11172 Change-Id: Id9b158f569db0140b75360aaf0f7e2e28fb924f4 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/172928 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@{#31098}
2020-04-17 12:10:59 +02:00
"video_stream_input_state.cc",
"video_stream_input_state.h",
"video_stream_input_state_provider.cc",
"video_stream_input_state_provider.h",
Initial version of ResourceAdaptationProcessor and friends. This CL adds Resource, ResourceConsumer, ResourceConsumerConfiguration and ResourceAdaptationProcessor and implements the algorithm outlined in https://docs.google.com/presentation/d/13jyqCWNpIa873iKT6yDuB5Q5ma-c0CvxBpX--0tCclY/edit?usp=sharing. Simply put, if any resource (such as "CPU") is overusing, the most expensive consumer (e.g. encoded stream) is adapted one step down. If all resources are underusing, the least expensive consumer is adapted one step up. The current resources, consumers and configurations are all fakes; this CL has no effect on the current adaptation algorithms used in practise, but it lays down the foundation for future work in this area. Bug: webrtc:11167, webrtc:11168, webrtc:11169 Change-Id: I4054ec7728a52a49e137eee6fa67fa27debd9254 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/161237 Commit-Queue: Henrik Boström <hbos@webrtc.org> Reviewed-by: Evan Shrubsole <eshr@google.com> Reviewed-by: Stefan Holmer <stefan@webrtc.org> Reviewed-by: Erik Språng <sprang@webrtc.org> Cr-Commit-Position: refs/heads/master@{#30053}
2019-12-10 14:14:09 +01:00
]
deps = [
WebRTC-DeprecateGlobalFieldTrialString/Enabled/ - part 12/inf rename WebRtcKeyValueConfig to FieldTrialsView Bug: webrtc:10335 Change-Id: If725bd498c4c3daf144bee638230fa089fdde833 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/256965 Reviewed-by: Mirko Bonadei <mbonadei@webrtc.org> Commit-Queue: Jonas Oreland <jonaso@webrtc.org> Reviewed-by: Harald Alvestrand <hta@webrtc.org> Cr-Commit-Position: refs/heads/main@{#36365}
2022-03-29 11:04:48 +02:00
"../../api:field_trials_view",
ResourceAdaptationModule HasInputVideo+DegradationPreference setters. The "has_input_video_ logic" is simplified to abort AdaptUp() and AdaptDown() directly rather than in each calling place of the VideoSourceRestrictor. The intent is no change in behavior. The degradation_preference_ is removed from the VideoSourceRestrictor as its only usage was DCHECKing (not worth it). ResourceAdaptationModuleInterface gets SetHasInputVideo() and SetDegradationPreference(), making these things controllable without knowing implementation details. StartCheckForOveruse() and StopCheckForOveruse() are renamed to StartResourceAdaptation() and StopResourceAdaptation(). Bug: webrtc:11222 Change-Id: Id2d7f34d427dfb3ecd4831b1a245d07becae6520 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/166173 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@{#30296}
2020-01-16 13:55:29 +01:00
"../../api:rtp_parameters",
[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
"../../api:scoped_refptr",
Use SequenceChecker from public API Bug: webrtc:12419 Change-Id: I00cca16a0ec70246156ba00b97aa7ae5ccbf5364 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/205323 Commit-Queue: Artem Titov <titovartem@webrtc.org> Reviewed-by: Tommi <tommi@webrtc.org> Reviewed-by: Danil Chapovalov <danilchap@webrtc.org> Cr-Commit-Position: refs/heads/master@{#33220}
2021-02-10 14:31:24 +01:00
"../../api:sequence_checker",
[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
"../../api/adaptation:resource_adaptation_api",
[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
"../../api/task_queue:task_queue",
[Adaptation] Move VideoStreamAdapter to call/adaptation/. This CL is part of the Call-Level Adaptation Processing design doc: https://docs.google.com/document/d/1ZyC26yOCknrrcYa839ZWLxD6o6Gig5A3lVTh4E41074/edit?usp=sharing This is a pure move CL. In the future, the Processor will live in call/adaptation/. This prevents circular dependencies. Bug: webrtc:11172 Change-Id: Ib72503cc20e27ab6425538e3d55930c65e0b4a90 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/172931 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@{#31100}
2020-04-17 14:40:39 +02:00
"../../api/video:video_adaptation",
[Overuse] Encoding pipeline as input signals in the abstract interface. This defines the following methods: - OnFrame(), replaces SetLastFramePixelCount(). - OnFrameDroppedDueToSize(), a rename of FrameDroppedDueToSize() to match the other methods. - OnEncodeStarted(), a rename of the incorrectly named FrameCaptured(). - OnEncodeCompleted(), a rename of the poorly named FrameSent(). In order to get rid of SetLastFramePixelCount(), the "we don't know the frame size" use case - which was previously implicitly avoided by invoking SetLastFramePixelCount() with a made-up value for last_frame_info_ - is now avoided using ".value_or()" in LastInputFrameSizeOrDefault(). This does mean that a constant 144p resolution value is referenced in two places, but the fact that this is a magic value is at least made explicit. This may help future improvements. Bug: webrtc:11222 Change-Id: I3b28daa8c5ecf57c6537957d4759f15e24bb2234 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/166961 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@{#30352}
2020-01-22 16:16:04 +01:00
"../../api/video:video_frame",
[Adaptation] Introduce VideoStreamInputState and its Provider. This CL is part of the Call-Level Adaptation Processing design doc: https://docs.google.com/document/d/1ZyC26yOCknrrcYa839ZWLxD6o6Gig5A3lVTh4E41074/edit?usp=sharing The "input state" of a VideoStream, needed for adaptation and decision-making, are: source resolution and frame rate, codec type and min pixels per frame (based on encoder scaling settings). These values are modified on the encoder queue of the VideoStreamEncoder. But in order to unblock call-level adaptation processing, where adaptation and decision making happens off the encoder queue, a snapshot of the input states need to be available at point of processing: introducing the VideoStreamInputState. In this CL, the VideoStreamInputStateProvider is added to provide input state snapshots across threads based on input from VideoStreamEncoder and VideoStreamEncoderObserver. The input state's HasInputFrameSizeAndFramesPerSecond() can now be DCHECKed inside the VideoStreamAdapter in favor of having less Adaptation::Status codes. Whether input is "sufficient" for adaptation is now the responsibility of the Processor. (Goal: adapter is purely a Adaptation generator and apply-er.) Somewhat tangental, this CL also deletes VideoStreamEncoder-specific methods from ResourceAdaptationProcessorInterface making them an implementation detail of ResourceAdaptationProcessor. In a future CL, the "processor" will be split up into a "processor" part and a "video stream encoder resource manager" part - more on that later. Bug: webrtc:11172 Change-Id: Id9b158f569db0140b75360aaf0f7e2e28fb924f4 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/172928 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@{#31098}
2020-04-17 12:10:59 +02:00
"../../api/video:video_stream_encoder",
[Overuse] Setting encoder configurations through the interface. This squashes together several input signals that were spread out through several calls into a single method and calling place: SetEncoderSettings(), invoked from ReconfigureEncoder(). This is added to the abstract interface. This makes the following methods obsolete which are removed: - SetEncoder(): The VideoEncoder was only used for GetEncoderInfo(); the VideoEncoder::EncoderInfo is now part of the EncoderSettings. - SetEncoderConfig(): The VideoEncoderConfig is part of EncoderSettings. The config is used for its codec_type and content_type enums. - SetCodecMaxFrameRate(): The max frame rate was the same as VideoCodec::maxFramerate. VideoCodec is now part of EncoderSettings. There may be some overlap in information between EncoderConfig and VideoCodec, but that is outside the scope of this CL, which only makes sure to bundle encoder settings-like information into one input signal. Bug: webrtc:11222 Change-Id: I67c49c49c0a859cb7d5051939a461593c695a789 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/166602 Reviewed-by: Erik Språng <sprang@webrtc.org> 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@{#30332}
2020-01-21 11:18:06 +01:00
"../../api/video_codecs:video_codecs_api",
[Adaptation] Move VideoStreamAdapter to call/adaptation/. This CL is part of the Call-Level Adaptation Processing design doc: https://docs.google.com/document/d/1ZyC26yOCknrrcYa839ZWLxD6o6Gig5A3lVTh4E41074/edit?usp=sharing This is a pure move CL. In the future, the Processor will live in call/adaptation/. This prevents circular dependencies. Bug: webrtc:11172 Change-Id: Ib72503cc20e27ab6425538e3d55930c65e0b4a90 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/172931 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@{#31100}
2020-04-17 14:40:39 +02:00
"../../modules/video_coding:video_coding_utility",
Initial version of ResourceAdaptationProcessor and friends. This CL adds Resource, ResourceConsumer, ResourceConsumerConfiguration and ResourceAdaptationProcessor and implements the algorithm outlined in https://docs.google.com/presentation/d/13jyqCWNpIa873iKT6yDuB5Q5ma-c0CvxBpX--0tCclY/edit?usp=sharing. Simply put, if any resource (such as "CPU") is overusing, the most expensive consumer (e.g. encoded stream) is adapted one step down. If all resources are underusing, the least expensive consumer is adapted one step up. The current resources, consumers and configurations are all fakes; this CL has no effect on the current adaptation algorithms used in practise, but it lays down the foundation for future work in this area. Bug: webrtc:11167, webrtc:11168, webrtc:11169 Change-Id: I4054ec7728a52a49e137eee6fa67fa27debd9254 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/161237 Commit-Queue: Henrik Boström <hbos@webrtc.org> Reviewed-by: Evan Shrubsole <eshr@google.com> Reviewed-by: Stefan Holmer <stefan@webrtc.org> Reviewed-by: Erik Språng <sprang@webrtc.org> Cr-Commit-Position: refs/heads/master@{#30053}
2019-12-10 14:14:09 +01:00
"../../rtc_base:checks",
Remove //rtc_base:logging from public deps Bug: webrtc:8603 Change-Id: I2704da8618f88032adac7ae9eb2a0f47fce4a836 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/257908 Reviewed-by: Mirko Bonadei <mbonadei@webrtc.org> Auto-Submit: Florent Castelli <orphis@webrtc.org> Commit-Queue: Florent Castelli <orphis@webrtc.org> Cr-Commit-Position: refs/heads/main@{#36443}
2022-04-04 15:06:30 +02:00
"../../rtc_base:logging",
Remove //rtc_base:macromagic from public deps Bug: webrtc:8603 Change-Id: I9708df48c9bde9f86ba2d1a92a278bb0d09f3865 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/257909 Reviewed-by: Mirko Bonadei <mbonadei@webrtc.org> Auto-Submit: Florent Castelli <orphis@webrtc.org> Commit-Queue: Florent Castelli <orphis@webrtc.org> Cr-Commit-Position: refs/heads/main@{#36444}
2022-04-04 15:18:46 +02:00
"../../rtc_base:macromagic",
Remove //rtc_base:refcount from public deps Bug: webrtc:8603 Change-Id: Ib27a107ae809df739492846175f0e9c4af40d21a Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/257910 Reviewed-by: Mirko Bonadei <mbonadei@webrtc.org> Auto-Submit: Florent Castelli <orphis@webrtc.org> Reviewed-by: Florent Castelli <orphis@webrtc.org> Commit-Queue: Florent Castelli <orphis@webrtc.org> Cr-Commit-Position: refs/heads/main@{#36447}
2022-04-05 02:54:12 +02:00
"../../rtc_base:refcount",
Initial version of ResourceAdaptationProcessor and friends. This CL adds Resource, ResourceConsumer, ResourceConsumerConfiguration and ResourceAdaptationProcessor and implements the algorithm outlined in https://docs.google.com/presentation/d/13jyqCWNpIa873iKT6yDuB5Q5ma-c0CvxBpX--0tCclY/edit?usp=sharing. Simply put, if any resource (such as "CPU") is overusing, the most expensive consumer (e.g. encoded stream) is adapted one step down. If all resources are underusing, the least expensive consumer is adapted one step up. The current resources, consumers and configurations are all fakes; this CL has no effect on the current adaptation algorithms used in practise, but it lays down the foundation for future work in this area. Bug: webrtc:11167, webrtc:11168, webrtc:11169 Change-Id: I4054ec7728a52a49e137eee6fa67fa27debd9254 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/161237 Commit-Queue: Henrik Boström <hbos@webrtc.org> Reviewed-by: Evan Shrubsole <eshr@google.com> Reviewed-by: Stefan Holmer <stefan@webrtc.org> Reviewed-by: Erik Språng <sprang@webrtc.org> Cr-Commit-Position: refs/heads/master@{#30053}
2019-12-10 14:14:09 +01:00
"../../rtc_base:rtc_base_approved",
[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_base:rtc_task_queue",
Remove //rtc_base:safe_conversions from public deps Bug: webrtc:8603 Change-Id: I285ac30975039f8fe9882d1673cc8e4a615c8618 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/257912 Reviewed-by: Mirko Bonadei <mbonadei@webrtc.org> Auto-Submit: Florent Castelli <orphis@webrtc.org> Commit-Queue: Florent Castelli <orphis@webrtc.org> Cr-Commit-Position: refs/heads/main@{#36452}
2022-04-04 17:04:37 +02:00
"../../rtc_base:safe_conversions",
Remove //rtc_base:stringutils from public deps Bug: webrtc:8603 Change-Id: Ic2dfbe28d310cb4b35983b73e895fc95e8439669 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/257913 Reviewed-by: Mirko Bonadei <mbonadei@webrtc.org> Auto-Submit: Florent Castelli <orphis@webrtc.org> Commit-Queue: Florent Castelli <orphis@webrtc.org> Cr-Commit-Position: refs/heads/main@{#36453}
2022-04-04 17:14:02 +02:00
"../../rtc_base:stringutils",
[Adaptation] Move VideoStreamAdapter to call/adaptation/. This CL is part of the Call-Level Adaptation Processing design doc: https://docs.google.com/document/d/1ZyC26yOCknrrcYa839ZWLxD6o6Gig5A3lVTh4E41074/edit?usp=sharing This is a pure move CL. In the future, the Processor will live in call/adaptation/. This prevents circular dependencies. Bug: webrtc:11172 Change-Id: Ib72503cc20e27ab6425538e3d55930c65e0b4a90 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/172931 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@{#31100}
2020-04-17 14:40:39 +02:00
"../../rtc_base/experiments:balanced_degradation_settings",
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
"../../rtc_base/synchronization:mutex",
Add RTC_NO_UNIQUE_ADDRESS to webrtc::VideoStreamAdapter. Bug: webrtc:11495 Change-Id: I32a1bc75d7c578753c158a61eb6cb5ea7565629a Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/194564 Reviewed-by: Karl Wiberg <kwiberg@webrtc.org> Commit-Queue: Mirko Bonadei <mbonadei@webrtc.org> Cr-Commit-Position: refs/heads/master@{#32676}
2020-11-23 13:19:32 +01:00
"../../rtc_base/system:no_unique_address",
[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_base/task_utils:to_queued_task",
Use absl_deps in order to preapre to the Abseil component build release. Bug: webrtc:1046390 Change-Id: Ia35545599de23b1a2c2d8be2d53469af7ac16f1d Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176502 Reviewed-by: Karl Wiberg <kwiberg@webrtc.org> Commit-Queue: Mirko Bonadei <mbonadei@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31463}
2020-06-05 14:30:41 +02:00
]
absl_deps = [
Support injecting new Resources for overuse * This replaces the video stream methods for forcing adaptation with a mock resource that triggers overuse. * Resources can now be injected to the Module using the AddResource function. * Resources now have tests for adding and removing callbacks. * Quality/EncoderUse% resources are tracked in the Resource list of the adaptation module. * The adaptation module ties all resources to a reason to keep stats working as expected. BUG=webrtc:11377 Change-Id: I1f5902f7416dc41b4915c0072e6f0da2bb3bb2b7 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/168948 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@{#30610}
2020-02-25 16:26:01 +01:00
"//third_party/abseil-cpp/absl/algorithm:container",
Initial version of ResourceAdaptationProcessor and friends. This CL adds Resource, ResourceConsumer, ResourceConsumerConfiguration and ResourceAdaptationProcessor and implements the algorithm outlined in https://docs.google.com/presentation/d/13jyqCWNpIa873iKT6yDuB5Q5ma-c0CvxBpX--0tCclY/edit?usp=sharing. Simply put, if any resource (such as "CPU") is overusing, the most expensive consumer (e.g. encoded stream) is adapted one step down. If all resources are underusing, the least expensive consumer is adapted one step up. The current resources, consumers and configurations are all fakes; this CL has no effect on the current adaptation algorithms used in practise, but it lays down the foundation for future work in this area. Bug: webrtc:11167, webrtc:11168, webrtc:11169 Change-Id: I4054ec7728a52a49e137eee6fa67fa27debd9254 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/161237 Commit-Queue: Henrik Boström <hbos@webrtc.org> Reviewed-by: Evan Shrubsole <eshr@google.com> Reviewed-by: Stefan Holmer <stefan@webrtc.org> Reviewed-by: Erik Språng <sprang@webrtc.org> Cr-Commit-Position: refs/heads/master@{#30053}
2019-12-10 14:14:09 +01:00
"//third_party/abseil-cpp/absl/types:optional",
[Adaptation] Adaptation holds restrictions This refactoring enables us to do multi-step adaptations instead of the normal single step adaptations. This work is required pre-requisite work to remove the DropDueToSize methods from the ResourceAdaptationProcessorInterface. This work also gives a path to fixing webrtc:11719, since double adaptations can be done in a controlled manner with this API. Bug: webrtc:11700,webrtc:11719 Change-Id: Ic7d27a49c82d0cf7ebaf79d7bdf0bc6f382770ed Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/178200 Commit-Queue: Evan Shrubsole <eshr@google.com> Reviewed-by: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31631}
2020-07-03 15:16:43 +02:00
"//third_party/abseil-cpp/absl/types:variant",
Initial version of ResourceAdaptationProcessor and friends. This CL adds Resource, ResourceConsumer, ResourceConsumerConfiguration and ResourceAdaptationProcessor and implements the algorithm outlined in https://docs.google.com/presentation/d/13jyqCWNpIa873iKT6yDuB5Q5ma-c0CvxBpX--0tCclY/edit?usp=sharing. Simply put, if any resource (such as "CPU") is overusing, the most expensive consumer (e.g. encoded stream) is adapted one step down. If all resources are underusing, the least expensive consumer is adapted one step up. The current resources, consumers and configurations are all fakes; this CL has no effect on the current adaptation algorithms used in practise, but it lays down the foundation for future work in this area. Bug: webrtc:11167, webrtc:11168, webrtc:11169 Change-Id: I4054ec7728a52a49e137eee6fa67fa27debd9254 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/161237 Commit-Queue: Henrik Boström <hbos@webrtc.org> Reviewed-by: Evan Shrubsole <eshr@google.com> Reviewed-by: Stefan Holmer <stefan@webrtc.org> Reviewed-by: Erik Språng <sprang@webrtc.org> Cr-Commit-Position: refs/heads/master@{#30053}
2019-12-10 14:14:09 +01:00
]
}
if (rtc_include_tests) {
rtc_library("resource_adaptation_tests") {
testonly = true
[Adaptation] Move VideoStreamAdapter to call/adaptation/. This CL is part of the Call-Level Adaptation Processing design doc: https://docs.google.com/document/d/1ZyC26yOCknrrcYa839ZWLxD6o6Gig5A3lVTh4E41074/edit?usp=sharing This is a pure move CL. In the future, the Processor will live in call/adaptation/. This prevents circular dependencies. Bug: webrtc:11172 Change-Id: Ib72503cc20e27ab6425538e3d55930c65e0b4a90 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/172931 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@{#31100}
2020-04-17 14:40:39 +02:00
sources = [
[Adaptation] Multi-processor support for injected Resources. Because a single Resource only has a single ResourceListener, injected Resources only gets wired up to the stream's ResourceAdaptationProcessor that was last to call SetResourceListener. This could potentially lead to the relevant stream not adapting based on the injected resource because it got wired up to the wrong stream's processor. This CL fixes this issue by introducing BroadcastResourceListener. By listening to 1 resource (the injected one), it can spawn N "adapter" resources that mirror's the injected resource's usage signal, allowing all ResourceAdaptationProcessor's to react to the signal. This is wired up in Call, and tests are updated to verify the signal gets through. Bug: chromium:1101263, webrtc:11720 Change-Id: I8a37284cb9a68f08ca1bdb1ee050b7144c451297 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/178386 Reviewed-by: Stefan Holmer <stefan@webrtc.org> Reviewed-by: Evan Shrubsole <eshr@google.com> Commit-Queue: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31612}
2020-07-01 15:48:46 +02:00
"broadcast_resource_listener_unittest.cc",
[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
"resource_adaptation_processor_unittest.cc",
[Adaptation] Move VideoStreamAdapter to call/adaptation/. This CL is part of the Call-Level Adaptation Processing design doc: https://docs.google.com/document/d/1ZyC26yOCknrrcYa839ZWLxD6o6Gig5A3lVTh4E41074/edit?usp=sharing This is a pure move CL. In the future, the Processor will live in call/adaptation/. This prevents circular dependencies. Bug: webrtc:11172 Change-Id: Ib72503cc20e27ab6425538e3d55930c65e0b4a90 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/172931 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@{#31100}
2020-04-17 14:40:39 +02:00
"resource_unittest.cc",
[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
"video_source_restrictions_unittest.cc",
[Adaptation] Move VideoStreamAdapter to call/adaptation/. This CL is part of the Call-Level Adaptation Processing design doc: https://docs.google.com/document/d/1ZyC26yOCknrrcYa839ZWLxD6o6Gig5A3lVTh4E41074/edit?usp=sharing This is a pure move CL. In the future, the Processor will live in call/adaptation/. This prevents circular dependencies. Bug: webrtc:11172 Change-Id: Ib72503cc20e27ab6425538e3d55930c65e0b4a90 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/172931 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@{#31100}
2020-04-17 14:40:39 +02:00
"video_stream_adapter_unittest.cc",
[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
"video_stream_input_state_provider_unittest.cc",
[Adaptation] Move VideoStreamAdapter to call/adaptation/. This CL is part of the Call-Level Adaptation Processing design doc: https://docs.google.com/document/d/1ZyC26yOCknrrcYa839ZWLxD6o6Gig5A3lVTh4E41074/edit?usp=sharing This is a pure move CL. In the future, the Processor will live in call/adaptation/. This prevents circular dependencies. Bug: webrtc:11172 Change-Id: Ib72503cc20e27ab6425538e3d55930c65e0b4a90 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/172931 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@{#31100}
2020-04-17 14:40:39 +02:00
]
Initial version of ResourceAdaptationProcessor and friends. This CL adds Resource, ResourceConsumer, ResourceConsumerConfiguration and ResourceAdaptationProcessor and implements the algorithm outlined in https://docs.google.com/presentation/d/13jyqCWNpIa873iKT6yDuB5Q5ma-c0CvxBpX--0tCclY/edit?usp=sharing. Simply put, if any resource (such as "CPU") is overusing, the most expensive consumer (e.g. encoded stream) is adapted one step down. If all resources are underusing, the least expensive consumer is adapted one step up. The current resources, consumers and configurations are all fakes; this CL has no effect on the current adaptation algorithms used in practise, but it lays down the foundation for future work in this area. Bug: webrtc:11167, webrtc:11168, webrtc:11169 Change-Id: I4054ec7728a52a49e137eee6fa67fa27debd9254 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/161237 Commit-Queue: Henrik Boström <hbos@webrtc.org> Reviewed-by: Evan Shrubsole <eshr@google.com> Reviewed-by: Stefan Holmer <stefan@webrtc.org> Reviewed-by: Erik Språng <sprang@webrtc.org> Cr-Commit-Position: refs/heads/master@{#30053}
2019-12-10 14:14:09 +01:00
deps = [
":resource_adaptation",
":resource_adaptation_test_utilities",
[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
"../../api:scoped_refptr",
[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
"../../api/adaptation:resource_adaptation_api",
[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
"../../api/task_queue:default_task_queue_factory",
"../../api/task_queue:task_queue",
[Adaptation] Move VideoStreamAdapter to call/adaptation/. This CL is part of the Call-Level Adaptation Processing design doc: https://docs.google.com/document/d/1ZyC26yOCknrrcYa839ZWLxD6o6Gig5A3lVTh4E41074/edit?usp=sharing This is a pure move CL. In the future, the Processor will live in call/adaptation/. This prevents circular dependencies. Bug: webrtc:11172 Change-Id: Ib72503cc20e27ab6425538e3d55930c65e0b4a90 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/172931 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@{#31100}
2020-04-17 14:40:39 +02:00
"../../api/video:video_adaptation",
"../../api/video_codecs:video_codecs_api",
Initial version of ResourceAdaptationProcessor and friends. This CL adds Resource, ResourceConsumer, ResourceConsumerConfiguration and ResourceAdaptationProcessor and implements the algorithm outlined in https://docs.google.com/presentation/d/13jyqCWNpIa873iKT6yDuB5Q5ma-c0CvxBpX--0tCclY/edit?usp=sharing. Simply put, if any resource (such as "CPU") is overusing, the most expensive consumer (e.g. encoded stream) is adapted one step down. If all resources are underusing, the least expensive consumer is adapted one step up. The current resources, consumers and configurations are all fakes; this CL has no effect on the current adaptation algorithms used in practise, but it lays down the foundation for future work in this area. Bug: webrtc:11167, webrtc:11168, webrtc:11169 Change-Id: I4054ec7728a52a49e137eee6fa67fa27debd9254 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/161237 Commit-Queue: Henrik Boström <hbos@webrtc.org> Reviewed-by: Evan Shrubsole <eshr@google.com> Reviewed-by: Stefan Holmer <stefan@webrtc.org> Reviewed-by: Erik Språng <sprang@webrtc.org> Cr-Commit-Position: refs/heads/master@{#30053}
2019-12-10 14:14:09 +01:00
"../../rtc_base:checks",
[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_base:gunit_helpers",
Initial version of ResourceAdaptationProcessor and friends. This CL adds Resource, ResourceConsumer, ResourceConsumerConfiguration and ResourceAdaptationProcessor and implements the algorithm outlined in https://docs.google.com/presentation/d/13jyqCWNpIa873iKT6yDuB5Q5ma-c0CvxBpX--0tCclY/edit?usp=sharing. Simply put, if any resource (such as "CPU") is overusing, the most expensive consumer (e.g. encoded stream) is adapted one step down. If all resources are underusing, the least expensive consumer is adapted one step up. The current resources, consumers and configurations are all fakes; this CL has no effect on the current adaptation algorithms used in practise, but it lays down the foundation for future work in this area. Bug: webrtc:11167, webrtc:11168, webrtc:11169 Change-Id: I4054ec7728a52a49e137eee6fa67fa27debd9254 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/161237 Commit-Queue: Henrik Boström <hbos@webrtc.org> Reviewed-by: Evan Shrubsole <eshr@google.com> Reviewed-by: Stefan Holmer <stefan@webrtc.org> Reviewed-by: Erik Språng <sprang@webrtc.org> Cr-Commit-Position: refs/heads/master@{#30053}
2019-12-10 14:14:09 +01:00
"../../rtc_base:rtc_base_approved",
Remove //rtc_base:rtc_event from public deps Bug: webrtc:8603 Change-Id: Ib99f43043da17723c939b0fe2aa9f3e515462c93 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/257911 Reviewed-by: Mirko Bonadei <mbonadei@webrtc.org> Auto-Submit: Florent Castelli <orphis@webrtc.org> Commit-Queue: Florent Castelli <orphis@webrtc.org> Cr-Commit-Position: refs/heads/main@{#36450}
2022-04-04 16:57:52 +02:00
"../../rtc_base:rtc_event",
[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
"../../rtc_base:rtc_task_queue",
Remove //rtc_base:stringutils from public deps Bug: webrtc:8603 Change-Id: Ic2dfbe28d310cb4b35983b73e895fc95e8439669 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/257913 Reviewed-by: Mirko Bonadei <mbonadei@webrtc.org> Auto-Submit: Florent Castelli <orphis@webrtc.org> Commit-Queue: Florent Castelli <orphis@webrtc.org> Cr-Commit-Position: refs/heads/main@{#36453}
2022-04-04 17:14:02 +02:00
"../../rtc_base:stringutils",
[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
"../../rtc_base:task_queue_for_test",
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
"../../rtc_base/synchronization:mutex",
[Adaptation] Move VideoStreamAdapter to call/adaptation/. This CL is part of the Call-Level Adaptation Processing design doc: https://docs.google.com/document/d/1ZyC26yOCknrrcYa839ZWLxD6o6Gig5A3lVTh4E41074/edit?usp=sharing This is a pure move CL. In the future, the Processor will live in call/adaptation/. This prevents circular dependencies. Bug: webrtc:11172 Change-Id: Ib72503cc20e27ab6425538e3d55930c65e0b4a90 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/172931 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@{#31100}
2020-04-17 14:40:39 +02:00
"../../test:field_trial",
"../../test:rtc_expect_death",
WebRTC-DeprecateGlobalFieldTrialString/Enabled/ - part 2 convert call/ (and the collaterals) Bug: webrtc:10335 Change-Id: I8f6bc13c032713aa2a947724b464f6f35454d39a Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/254320 Reviewed-by: Mirko Bonadei <mbonadei@webrtc.org> Reviewed-by: Harald Alvestrand <hta@webrtc.org> Commit-Queue: Jonas Oreland <jonaso@webrtc.org> Cr-Commit-Position: refs/heads/main@{#36165}
2022-03-09 15:12:07 +01:00
"../../test:scoped_key_value_config",
Initial version of ResourceAdaptationProcessor and friends. This CL adds Resource, ResourceConsumer, ResourceConsumerConfiguration and ResourceAdaptationProcessor and implements the algorithm outlined in https://docs.google.com/presentation/d/13jyqCWNpIa873iKT6yDuB5Q5ma-c0CvxBpX--0tCclY/edit?usp=sharing. Simply put, if any resource (such as "CPU") is overusing, the most expensive consumer (e.g. encoded stream) is adapted one step down. If all resources are underusing, the least expensive consumer is adapted one step up. The current resources, consumers and configurations are all fakes; this CL has no effect on the current adaptation algorithms used in practise, but it lays down the foundation for future work in this area. Bug: webrtc:11167, webrtc:11168, webrtc:11169 Change-Id: I4054ec7728a52a49e137eee6fa67fa27debd9254 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/161237 Commit-Queue: Henrik Boström <hbos@webrtc.org> Reviewed-by: Evan Shrubsole <eshr@google.com> Reviewed-by: Stefan Holmer <stefan@webrtc.org> Reviewed-by: Erik Språng <sprang@webrtc.org> Cr-Commit-Position: refs/heads/master@{#30053}
2019-12-10 14:14:09 +01:00
"../../test:test_support",
]
Use absl_deps in order to preapre to the Abseil component build release. Bug: webrtc:1046390 Change-Id: Ia35545599de23b1a2c2d8be2d53469af7ac16f1d Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176502 Reviewed-by: Karl Wiberg <kwiberg@webrtc.org> Commit-Queue: Mirko Bonadei <mbonadei@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31463}
2020-06-05 14:30:41 +02:00
absl_deps = [ "//third_party/abseil-cpp/absl/types:optional" ]
Initial version of ResourceAdaptationProcessor and friends. This CL adds Resource, ResourceConsumer, ResourceConsumerConfiguration and ResourceAdaptationProcessor and implements the algorithm outlined in https://docs.google.com/presentation/d/13jyqCWNpIa873iKT6yDuB5Q5ma-c0CvxBpX--0tCclY/edit?usp=sharing. Simply put, if any resource (such as "CPU") is overusing, the most expensive consumer (e.g. encoded stream) is adapted one step down. If all resources are underusing, the least expensive consumer is adapted one step up. The current resources, consumers and configurations are all fakes; this CL has no effect on the current adaptation algorithms used in practise, but it lays down the foundation for future work in this area. Bug: webrtc:11167, webrtc:11168, webrtc:11169 Change-Id: I4054ec7728a52a49e137eee6fa67fa27debd9254 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/161237 Commit-Queue: Henrik Boström <hbos@webrtc.org> Reviewed-by: Evan Shrubsole <eshr@google.com> Reviewed-by: Stefan Holmer <stefan@webrtc.org> Reviewed-by: Erik Språng <sprang@webrtc.org> Cr-Commit-Position: refs/heads/master@{#30053}
2019-12-10 14:14:09 +01:00
}
rtc_source_set("resource_adaptation_test_utilities") {
testonly = true
sources = [
[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
"test/fake_adaptation_constraint.cc",
"test/fake_adaptation_constraint.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
"test/fake_frame_rate_provider.cc",
"test/fake_frame_rate_provider.h",
Initial version of ResourceAdaptationProcessor and friends. This CL adds Resource, ResourceConsumer, ResourceConsumerConfiguration and ResourceAdaptationProcessor and implements the algorithm outlined in https://docs.google.com/presentation/d/13jyqCWNpIa873iKT6yDuB5Q5ma-c0CvxBpX--0tCclY/edit?usp=sharing. Simply put, if any resource (such as "CPU") is overusing, the most expensive consumer (e.g. encoded stream) is adapted one step down. If all resources are underusing, the least expensive consumer is adapted one step up. The current resources, consumers and configurations are all fakes; this CL has no effect on the current adaptation algorithms used in practise, but it lays down the foundation for future work in this area. Bug: webrtc:11167, webrtc:11168, webrtc:11169 Change-Id: I4054ec7728a52a49e137eee6fa67fa27debd9254 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/161237 Commit-Queue: Henrik Boström <hbos@webrtc.org> Reviewed-by: Evan Shrubsole <eshr@google.com> Reviewed-by: Stefan Holmer <stefan@webrtc.org> Reviewed-by: Erik Språng <sprang@webrtc.org> Cr-Commit-Position: refs/heads/master@{#30053}
2019-12-10 14:14:09 +01:00
"test/fake_resource.cc",
"test/fake_resource.h",
Implement fake PixelLimitResource for TestBed. This CL implements a Resource that aggressively reports overuse or underuse until the encoded stream has the max pixels specified. The pixel limit is controlled with a field trial, e.g: --force-fieldtrials="WebRTC-PixelLimitResource/Enabled-307200/" This caps the resolution to 307200 (=640x480). This can be used by the TestBed to simulate being CPU limited. Note that the resource doesn't care about degradation preference at the moment, so if the degradation preference would be set to "maintain-resolution" the PixelLimitResource would never stop reporting overuse and we would quickly get a low-FPS stream. PixelLimitResource runs a repeating task and reports overuse, underuse or neither every 5 seconds. This ensures we quickly reach the desired resolution. Unit tests are added. I did not add any integration tests (I think that's overkill for a testing-only resource) but I have manually verified that this works as intended. This CL also moves the FakeVideoStreamInputStateProvider into a test/ folder and exposes video_stream_adapter.cc's GetLowerResolutionThan(). Bug: webrtc:12261 Change-Id: Ifbf7c4c05e9dd2843543589bebef3f49b18c38c0 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/195600 Reviewed-by: Evan Shrubsole <eshr@google.com> Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org> Commit-Queue: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#32771}
2020-12-04 09:37:47 +01:00
"test/fake_video_stream_input_state_provider.cc",
"test/fake_video_stream_input_state_provider.h",
[Adaptation] Multi-processor support for injected Resources. Because a single Resource only has a single ResourceListener, injected Resources only gets wired up to the stream's ResourceAdaptationProcessor that was last to call SetResourceListener. This could potentially lead to the relevant stream not adapting based on the injected resource because it got wired up to the wrong stream's processor. This CL fixes this issue by introducing BroadcastResourceListener. By listening to 1 resource (the injected one), it can spawn N "adapter" resources that mirror's the injected resource's usage signal, allowing all ResourceAdaptationProcessor's to react to the signal. This is wired up in Call, and tests are updated to verify the signal gets through. Bug: chromium:1101263, webrtc:11720 Change-Id: I8a37284cb9a68f08ca1bdb1ee050b7144c451297 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/178386 Reviewed-by: Stefan Holmer <stefan@webrtc.org> Reviewed-by: Evan Shrubsole <eshr@google.com> Commit-Queue: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31612}
2020-07-01 15:48:46 +02:00
"test/mock_resource_listener.h",
Initial version of ResourceAdaptationProcessor and friends. This CL adds Resource, ResourceConsumer, ResourceConsumerConfiguration and ResourceAdaptationProcessor and implements the algorithm outlined in https://docs.google.com/presentation/d/13jyqCWNpIa873iKT6yDuB5Q5ma-c0CvxBpX--0tCclY/edit?usp=sharing. Simply put, if any resource (such as "CPU") is overusing, the most expensive consumer (e.g. encoded stream) is adapted one step down. If all resources are underusing, the least expensive consumer is adapted one step up. The current resources, consumers and configurations are all fakes; this CL has no effect on the current adaptation algorithms used in practise, but it lays down the foundation for future work in this area. Bug: webrtc:11167, webrtc:11168, webrtc:11169 Change-Id: I4054ec7728a52a49e137eee6fa67fa27debd9254 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/161237 Commit-Queue: Henrik Boström <hbos@webrtc.org> Reviewed-by: Evan Shrubsole <eshr@google.com> Reviewed-by: Stefan Holmer <stefan@webrtc.org> Reviewed-by: Erik Språng <sprang@webrtc.org> Cr-Commit-Position: refs/heads/master@{#30053}
2019-12-10 14:14:09 +01:00
]
deps = [
":resource_adaptation",
[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
"../../api:scoped_refptr",
Use SequenceChecker from public API Bug: webrtc:12419 Change-Id: I00cca16a0ec70246156ba00b97aa7ae5ccbf5364 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/205323 Commit-Queue: Artem Titov <titovartem@webrtc.org> Reviewed-by: Tommi <tommi@webrtc.org> Reviewed-by: Danil Chapovalov <danilchap@webrtc.org> Cr-Commit-Position: refs/heads/master@{#33220}
2021-02-10 14:31:24 +01:00
"../../api:sequence_checker",
[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
"../../api/adaptation:resource_adaptation_api",
[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
"../../api/task_queue:task_queue",
[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
"../../api/video:video_stream_encoder",
Remove //rtc_base:refcount from public deps Bug: webrtc:8603 Change-Id: Ib27a107ae809df739492846175f0e9c4af40d21a Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/257910 Reviewed-by: Mirko Bonadei <mbonadei@webrtc.org> Auto-Submit: Florent Castelli <orphis@webrtc.org> Reviewed-by: Florent Castelli <orphis@webrtc.org> Commit-Queue: Florent Castelli <orphis@webrtc.org> Cr-Commit-Position: refs/heads/main@{#36447}
2022-04-05 02:54:12 +02:00
"../../rtc_base:refcount",
Initial version of ResourceAdaptationProcessor and friends. This CL adds Resource, ResourceConsumer, ResourceConsumerConfiguration and ResourceAdaptationProcessor and implements the algorithm outlined in https://docs.google.com/presentation/d/13jyqCWNpIa873iKT6yDuB5Q5ma-c0CvxBpX--0tCclY/edit?usp=sharing. Simply put, if any resource (such as "CPU") is overusing, the most expensive consumer (e.g. encoded stream) is adapted one step down. If all resources are underusing, the least expensive consumer is adapted one step up. The current resources, consumers and configurations are all fakes; this CL has no effect on the current adaptation algorithms used in practise, but it lays down the foundation for future work in this area. Bug: webrtc:11167, webrtc:11168, webrtc:11169 Change-Id: I4054ec7728a52a49e137eee6fa67fa27debd9254 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/161237 Commit-Queue: Henrik Boström <hbos@webrtc.org> Reviewed-by: Evan Shrubsole <eshr@google.com> Reviewed-by: Stefan Holmer <stefan@webrtc.org> Reviewed-by: Erik Språng <sprang@webrtc.org> Cr-Commit-Position: refs/heads/master@{#30053}
2019-12-10 14:14:09 +01:00
"../../rtc_base:rtc_base_approved",
[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
"../../rtc_base/task_utils:to_queued_task",
[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:test_support",
Initial version of ResourceAdaptationProcessor and friends. This CL adds Resource, ResourceConsumer, ResourceConsumerConfiguration and ResourceAdaptationProcessor and implements the algorithm outlined in https://docs.google.com/presentation/d/13jyqCWNpIa873iKT6yDuB5Q5ma-c0CvxBpX--0tCclY/edit?usp=sharing. Simply put, if any resource (such as "CPU") is overusing, the most expensive consumer (e.g. encoded stream) is adapted one step down. If all resources are underusing, the least expensive consumer is adapted one step up. The current resources, consumers and configurations are all fakes; this CL has no effect on the current adaptation algorithms used in practise, but it lays down the foundation for future work in this area. Bug: webrtc:11167, webrtc:11168, webrtc:11169 Change-Id: I4054ec7728a52a49e137eee6fa67fa27debd9254 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/161237 Commit-Queue: Henrik Boström <hbos@webrtc.org> Reviewed-by: Evan Shrubsole <eshr@google.com> Reviewed-by: Stefan Holmer <stefan@webrtc.org> Reviewed-by: Erik Språng <sprang@webrtc.org> Cr-Commit-Position: refs/heads/master@{#30053}
2019-12-10 14:14:09 +01:00
]
Use absl_deps in order to preapre to the Abseil component build release. Bug: webrtc:1046390 Change-Id: Ia35545599de23b1a2c2d8be2d53469af7ac16f1d Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176502 Reviewed-by: Karl Wiberg <kwiberg@webrtc.org> Commit-Queue: Mirko Bonadei <mbonadei@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31463}
2020-06-05 14:30:41 +02:00
absl_deps = [ "//third_party/abseil-cpp/absl/types:optional" ]
Initial version of ResourceAdaptationProcessor and friends. This CL adds Resource, ResourceConsumer, ResourceConsumerConfiguration and ResourceAdaptationProcessor and implements the algorithm outlined in https://docs.google.com/presentation/d/13jyqCWNpIa873iKT6yDuB5Q5ma-c0CvxBpX--0tCclY/edit?usp=sharing. Simply put, if any resource (such as "CPU") is overusing, the most expensive consumer (e.g. encoded stream) is adapted one step down. If all resources are underusing, the least expensive consumer is adapted one step up. The current resources, consumers and configurations are all fakes; this CL has no effect on the current adaptation algorithms used in practise, but it lays down the foundation for future work in this area. Bug: webrtc:11167, webrtc:11168, webrtc:11169 Change-Id: I4054ec7728a52a49e137eee6fa67fa27debd9254 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/161237 Commit-Queue: Henrik Boström <hbos@webrtc.org> Reviewed-by: Evan Shrubsole <eshr@google.com> Reviewed-by: Stefan Holmer <stefan@webrtc.org> Reviewed-by: Erik Språng <sprang@webrtc.org> Cr-Commit-Position: refs/heads/master@{#30053}
2019-12-10 14:14:09 +01:00
}
}
Reference in New Issue Copy Permalink