blob: 5fc19daf85ff940523e3ece327425a52fe93d906 [file] [log] [blame]
Ana Krulecb43429d2019-01-09 14:28:51 -08001/*
2 * Copyright 2019 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#pragma once
18
Dominik Laskowski98041832019-08-01 18:35:59 -070019#include <android-base/stringprintf.h>
Ady Abraham62f216c2020-10-13 19:07:23 -070020#include <gui/DisplayEventReceiver.h>
Dominik Laskowski98041832019-08-01 18:35:59 -070021
Ana Krulecb43429d2019-01-09 14:28:51 -080022#include <algorithm>
23#include <numeric>
Steven Thomasd4071902020-03-24 16:02:53 -070024#include <optional>
Dominik Laskowski98041832019-08-01 18:35:59 -070025#include <type_traits>
Ana Krulecb43429d2019-01-09 14:28:51 -080026
Marin Shalamanov3ea1d602020-12-16 19:59:39 +010027#include "DisplayHardware/DisplayMode.h"
Ana Krulec4593b692019-01-11 22:07:25 -080028#include "DisplayHardware/HWComposer.h"
Marin Shalamanove8a663d2020-11-24 17:48:00 +010029#include "Fps.h"
Ana Krulec4593b692019-01-11 22:07:25 -080030#include "Scheduler/SchedulerUtils.h"
Marin Shalamanov53fc11d2020-11-20 14:00:13 +010031#include "Scheduler/Seamlessness.h"
Ady Abraham2139f732019-11-13 18:56:40 -080032#include "Scheduler/StrongTyping.h"
Ana Krulec4593b692019-01-11 22:07:25 -080033
Dominik Laskowski98041832019-08-01 18:35:59 -070034namespace android::scheduler {
Ady Abrahamabc27602020-04-08 17:20:29 -070035
Ady Abraham4ccdcb42020-02-11 17:34:34 -080036using namespace std::chrono_literals;
Dominik Laskowski98041832019-08-01 18:35:59 -070037
38enum class RefreshRateConfigEvent : unsigned { None = 0b0, Changed = 0b1 };
39
40inline RefreshRateConfigEvent operator|(RefreshRateConfigEvent lhs, RefreshRateConfigEvent rhs) {
41 using T = std::underlying_type_t<RefreshRateConfigEvent>;
42 return static_cast<RefreshRateConfigEvent>(static_cast<T>(lhs) | static_cast<T>(rhs));
43}
Ana Krulecb43429d2019-01-09 14:28:51 -080044
Ady Abraham62f216c2020-10-13 19:07:23 -070045using FrameRateOverride = DisplayEventReceiver::Event::FrameRateOverride;
46
Ana Krulecb43429d2019-01-09 14:28:51 -080047/**
Ady Abraham1902d072019-03-01 17:18:59 -080048 * This class is used to encapsulate configuration for refresh rates. It holds information
Ana Krulecb43429d2019-01-09 14:28:51 -080049 * about available refresh rates on the device, and the mapping between the numbers and human
50 * readable names.
51 */
52class RefreshRateConfigs {
53public:
Ady Abraham4ccdcb42020-02-11 17:34:34 -080054 // Margin used when matching refresh rates to the content desired ones.
55 static constexpr nsecs_t MARGIN_FOR_PERIOD_CALCULATION =
rnlee3bd610662021-06-23 16:27:57 -070056 std::chrono::nanoseconds(800us).count();
Ady Abraham4ccdcb42020-02-11 17:34:34 -080057
Ady Abrahamabc27602020-04-08 17:20:29 -070058 class RefreshRate {
59 private:
60 // Effectively making the constructor private while allowing
61 // std::make_unique to create the object
62 struct ConstructorTag {
63 explicit ConstructorTag(int) {}
64 };
Ana Krulec72f0d6e2020-01-06 15:24:47 -080065
Ady Abrahamabc27602020-04-08 17:20:29 -070066 public:
Ady Abraham6b7ad652021-06-23 17:34:57 -070067 RefreshRate(DisplayModePtr mode, ConstructorTag) : mode(mode) {}
Ady Abraham2e1dd892020-03-05 13:48:36 -080068
Ady Abraham6b7ad652021-06-23 17:34:57 -070069 DisplayModeId getModeId() const { return mode->getId(); }
Marin Shalamanova7fe3042021-01-29 21:02:08 +010070 nsecs_t getVsyncPeriod() const { return mode->getVsyncPeriod(); }
71 int32_t getModeGroup() const { return mode->getGroup(); }
Ady Abraham6b7ad652021-06-23 17:34:57 -070072 std::string getName() const { return to_string(getFps()); }
73 Fps getFps() const { return mode->getFps(); }
Ady Abraham2139f732019-11-13 18:56:40 -080074
Ana Krulec72f0d6e2020-01-06 15:24:47 -080075 // Checks whether the fps of this RefreshRate struct is within a given min and max refresh
Marin Shalamanove8a663d2020-11-24 17:48:00 +010076 // rate passed in. Margin of error is applied to the boundaries for approximation.
77 bool inPolicy(Fps minRefreshRate, Fps maxRefreshRate) const {
Ady Abraham6b7ad652021-06-23 17:34:57 -070078 return minRefreshRate.lessThanOrEqualWithMargin(getFps()) &&
79 getFps().lessThanOrEqualWithMargin(maxRefreshRate);
Ana Krulec72f0d6e2020-01-06 15:24:47 -080080 }
81
Ady Abraham6b7ad652021-06-23 17:34:57 -070082 bool operator!=(const RefreshRate& other) const { return mode != other.mode; }
Ady Abraham2139f732019-11-13 18:56:40 -080083
Marin Shalamanove8a663d2020-11-24 17:48:00 +010084 bool operator<(const RefreshRate& other) const {
85 return getFps().getValue() < other.getFps().getValue();
86 }
Ana Krulecb9afd792020-06-11 13:16:15 -070087
Ady Abraham2139f732019-11-13 18:56:40 -080088 bool operator==(const RefreshRate& other) const { return !(*this != other); }
Ady Abrahamabc27602020-04-08 17:20:29 -070089
Marin Shalamanov46084422020-10-13 12:33:42 +020090 std::string toString() const;
Marin Shalamanov65ce5512021-01-22 20:57:13 +010091 friend std::ostream& operator<<(std::ostream& os, const RefreshRate& refreshRate) {
92 return os << refreshRate.toString();
93 }
Marin Shalamanov46084422020-10-13 12:33:42 +020094
Ady Abrahamabc27602020-04-08 17:20:29 -070095 private:
96 friend RefreshRateConfigs;
Ady Abrahamb1b9d412020-06-01 19:53:52 -070097 friend class RefreshRateConfigsTest;
Ady Abrahamabc27602020-04-08 17:20:29 -070098
Marin Shalamanova7fe3042021-01-29 21:02:08 +010099 DisplayModePtr mode;
Ana Krulecb43429d2019-01-09 14:28:51 -0800100 };
101
Ady Abraham2e1dd892020-03-05 13:48:36 -0800102 using AllRefreshRatesMapType =
Marin Shalamanov23c44202020-12-22 19:09:20 +0100103 std::unordered_map<DisplayModeId, std::unique_ptr<const RefreshRate>>;
Ady Abraham2139f732019-11-13 18:56:40 -0800104
Marin Shalamanoveadf2e72020-12-10 15:35:28 +0100105 struct FpsRange {
106 Fps min{0.0f};
107 Fps max{std::numeric_limits<float>::max()};
108
109 bool operator==(const FpsRange& other) const {
110 return min.equalsWithMargin(other.min) && max.equalsWithMargin(other.max);
111 }
112
113 bool operator!=(const FpsRange& other) const { return !(*this == other); }
114
115 std::string toString() const {
116 return base::StringPrintf("[%s %s]", to_string(min).c_str(), to_string(max).c_str());
117 }
118 };
119
Steven Thomasd4071902020-03-24 16:02:53 -0700120 struct Policy {
Marin Shalamanov30b0b3c2020-10-13 19:15:06 +0200121 private:
122 static constexpr int kAllowGroupSwitchingDefault = false;
123
124 public:
Marin Shalamanova7fe3042021-01-29 21:02:08 +0100125 // The default mode, used to ensure we only initiate display mode switches within the
126 // same mode group as defaultMode's group.
127 DisplayModeId defaultMode;
128 // Whether or not we switch mode groups to get the best frame rate.
Marin Shalamanov30b0b3c2020-10-13 19:15:06 +0200129 bool allowGroupSwitching = kAllowGroupSwitchingDefault;
Steven Thomasf734df42020-04-13 21:09:28 -0700130 // The primary refresh rate range represents display manager's general guidance on the
Marin Shalamanova7fe3042021-01-29 21:02:08 +0100131 // display modes we'll consider when switching refresh rates. Unless we get an explicit
Steven Thomasf734df42020-04-13 21:09:28 -0700132 // signal from an app, we should stay within this range.
Marin Shalamanoveadf2e72020-12-10 15:35:28 +0100133 FpsRange primaryRange;
Marin Shalamanova7fe3042021-01-29 21:02:08 +0100134 // The app request refresh rate range allows us to consider more display modes when
Steven Thomasf734df42020-04-13 21:09:28 -0700135 // switching refresh rates. Although we should generally stay within the primary range,
136 // specific considerations, such as layer frame rate settings specified via the
137 // setFrameRate() api, may cause us to go outside the primary range. We never go outside the
138 // app request range. The app request range will be greater than or equal to the primary
139 // refresh rate range, never smaller.
Marin Shalamanoveadf2e72020-12-10 15:35:28 +0100140 FpsRange appRequestRange;
Steven Thomasd4071902020-03-24 16:02:53 -0700141
Steven Thomasf734df42020-04-13 21:09:28 -0700142 Policy() = default;
Marin Shalamanov30b0b3c2020-10-13 19:15:06 +0200143
Marin Shalamanova7fe3042021-01-29 21:02:08 +0100144 Policy(DisplayModeId defaultMode, const FpsRange& range)
145 : Policy(defaultMode, kAllowGroupSwitchingDefault, range, range) {}
Marin Shalamanov30b0b3c2020-10-13 19:15:06 +0200146
Marin Shalamanova7fe3042021-01-29 21:02:08 +0100147 Policy(DisplayModeId defaultMode, bool allowGroupSwitching, const FpsRange& range)
148 : Policy(defaultMode, allowGroupSwitching, range, range) {}
Marin Shalamanov30b0b3c2020-10-13 19:15:06 +0200149
Marin Shalamanova7fe3042021-01-29 21:02:08 +0100150 Policy(DisplayModeId defaultMode, const FpsRange& primaryRange,
Marin Shalamanoveadf2e72020-12-10 15:35:28 +0100151 const FpsRange& appRequestRange)
Marin Shalamanova7fe3042021-01-29 21:02:08 +0100152 : Policy(defaultMode, kAllowGroupSwitchingDefault, primaryRange, appRequestRange) {}
Marin Shalamanov30b0b3c2020-10-13 19:15:06 +0200153
Marin Shalamanova7fe3042021-01-29 21:02:08 +0100154 Policy(DisplayModeId defaultMode, bool allowGroupSwitching, const FpsRange& primaryRange,
Marin Shalamanov23c44202020-12-22 19:09:20 +0100155 const FpsRange& appRequestRange)
Marin Shalamanova7fe3042021-01-29 21:02:08 +0100156 : defaultMode(defaultMode),
Marin Shalamanov30b0b3c2020-10-13 19:15:06 +0200157 allowGroupSwitching(allowGroupSwitching),
Steven Thomasf734df42020-04-13 21:09:28 -0700158 primaryRange(primaryRange),
159 appRequestRange(appRequestRange) {}
160
Steven Thomasd4071902020-03-24 16:02:53 -0700161 bool operator==(const Policy& other) const {
Marin Shalamanova7fe3042021-01-29 21:02:08 +0100162 return defaultMode == other.defaultMode && primaryRange == other.primaryRange &&
Steven Thomasf734df42020-04-13 21:09:28 -0700163 appRequestRange == other.appRequestRange &&
Steven Thomasd4071902020-03-24 16:02:53 -0700164 allowGroupSwitching == other.allowGroupSwitching;
165 }
166
167 bool operator!=(const Policy& other) const { return !(*this == other); }
Marin Shalamanovb6674e72020-11-06 13:05:57 +0100168 std::string toString() const;
Steven Thomasd4071902020-03-24 16:02:53 -0700169 };
170
171 // Return code set*Policy() to indicate the current policy is unchanged.
172 static constexpr int CURRENT_POLICY_UNCHANGED = 1;
173
174 // We maintain the display manager policy and the override policy separately. The override
175 // policy is used by CTS tests to get a consistent device state for testing. While the override
176 // policy is set, it takes precedence over the display manager policy. Once the override policy
177 // is cleared, we revert to using the display manager policy.
178
179 // Sets the display manager policy to choose refresh rates. The return value will be:
180 // - A negative value if the policy is invalid or another error occurred.
181 // - NO_ERROR if the policy was successfully updated, and the current policy is different from
182 // what it was before the call.
183 // - CURRENT_POLICY_UNCHANGED if the policy was successfully updated, but the current policy
184 // is the same as it was before the call.
185 status_t setDisplayManagerPolicy(const Policy& policy) EXCLUDES(mLock);
186 // Sets the override policy. See setDisplayManagerPolicy() for the meaning of the return value.
187 status_t setOverridePolicy(const std::optional<Policy>& policy) EXCLUDES(mLock);
188 // Gets the current policy, which will be the override policy if active, and the display manager
189 // policy otherwise.
190 Policy getCurrentPolicy() const EXCLUDES(mLock);
191 // Gets the display manager policy, regardless of whether an override policy is active.
192 Policy getDisplayManagerPolicy() const EXCLUDES(mLock);
Ana Kruleced3a8cc2019-11-14 00:55:07 +0100193
Marin Shalamanova7fe3042021-01-29 21:02:08 +0100194 // Returns true if mode is allowed by the current policy.
195 bool isModeAllowed(DisplayModeId) const EXCLUDES(mLock);
Ady Abraham2139f732019-11-13 18:56:40 -0800196
Ady Abraham8a82ba62020-01-17 12:43:17 -0800197 // Describes the different options the layer voted for refresh rate
198 enum class LayerVoteType {
Ady Abraham71c437d2020-01-31 15:56:57 -0800199 NoVote, // Doesn't care about the refresh rate
200 Min, // Minimal refresh rate available
201 Max, // Maximal refresh rate available
202 Heuristic, // Specific refresh rate that was calculated by platform using a heuristic
203 ExplicitDefault, // Specific refresh rate that was provided by the app with Default
204 // compatibility
Ady Abrahamdd5bfa92021-01-07 17:56:08 -0800205 ExplicitExactOrMultiple, // Specific refresh rate that was provided by the app with
206 // ExactOrMultiple compatibility
207 ExplicitExact, // Specific refresh rate that was provided by the app with
208 // Exact compatibility
209
Ady Abraham8a82ba62020-01-17 12:43:17 -0800210 };
211
212 // Captures the layer requirements for a refresh rate. This will be used to determine the
213 // display refresh rate.
214 struct LayerRequirement {
Ady Abrahamaae5ed52020-06-26 09:32:43 -0700215 // Layer's name. Used for debugging purposes.
216 std::string name;
Ady Abraham62a0be22020-12-08 16:54:10 -0800217 // Layer's owner uid
218 uid_t ownerUid = static_cast<uid_t>(-1);
Ady Abrahamaae5ed52020-06-26 09:32:43 -0700219 // Layer vote type.
220 LayerVoteType vote = LayerVoteType::NoVote;
221 // Layer's desired refresh rate, if applicable.
Marin Shalamanove8a663d2020-11-24 17:48:00 +0100222 Fps desiredRefreshRate{0.0f};
Marin Shalamanov46084422020-10-13 12:33:42 +0200223 // If a seamless mode switch is required.
Marin Shalamanov53fc11d2020-11-20 14:00:13 +0100224 Seamlessness seamlessness = Seamlessness::Default;
Ady Abrahamaae5ed52020-06-26 09:32:43 -0700225 // Layer's weight in the range of [0, 1]. The higher the weight the more impact this layer
226 // would have on choosing the refresh rate.
227 float weight = 0.0f;
228 // Whether layer is in focus or not based on WindowManager's state
229 bool focused = false;
Ady Abraham8a82ba62020-01-17 12:43:17 -0800230
231 bool operator==(const LayerRequirement& other) const {
232 return name == other.name && vote == other.vote &&
Marin Shalamanove8a663d2020-11-24 17:48:00 +0100233 desiredRefreshRate.equalsWithMargin(other.desiredRefreshRate) &&
Marin Shalamanovbe97cfa2020-12-01 16:02:07 +0100234 seamlessness == other.seamlessness && weight == other.weight &&
Ady Abrahamaae5ed52020-06-26 09:32:43 -0700235 focused == other.focused;
Ady Abraham8a82ba62020-01-17 12:43:17 -0800236 }
237
238 bool operator!=(const LayerRequirement& other) const { return !(*this == other); }
239 };
240
Ady Abrahamdfd62162020-06-10 16:11:56 -0700241 // Global state describing signals that affect refresh rate choice.
242 struct GlobalSignals {
243 // Whether the user touched the screen recently. Used to apply touch boost.
244 bool touch = false;
245 // True if the system hasn't seen any buffers posted to layers recently.
246 bool idle = false;
Marin Shalamanov4c7831e2021-06-08 20:44:06 +0200247
248 bool operator==(const GlobalSignals& other) const {
249 return touch == other.touch && idle == other.idle;
250 }
Ady Abrahamdfd62162020-06-10 16:11:56 -0700251 };
252
Steven Thomasbb374322020-04-28 22:47:16 -0700253 // Returns the refresh rate that fits best to the given layers.
254 // layers - The layer requirements to consider.
Ady Abrahamdfd62162020-06-10 16:11:56 -0700255 // globalSignals - global state of touch and idle
256 // outSignalsConsidered - An output param that tells the caller whether the refresh rate was
257 // chosen based on touch boost and/or idle timer.
Marin Shalamanoveadf2e72020-12-10 15:35:28 +0100258 RefreshRate getBestRefreshRate(const std::vector<LayerRequirement>& layers,
259 const GlobalSignals& globalSignals,
260 GlobalSignals* outSignalsConsidered = nullptr) const
Ady Abraham6fb599b2020-03-05 13:48:22 -0800261 EXCLUDES(mLock);
Ana Krulecb43429d2019-01-09 14:28:51 -0800262
Marin Shalamanoveadf2e72020-12-10 15:35:28 +0100263 FpsRange getSupportedRefreshRateRange() const EXCLUDES(mLock) {
264 std::lock_guard lock(mLock);
265 return {mMinSupportedRefreshRate->getFps(), mMaxSupportedRefreshRate->getFps()};
266 }
Steven Thomas2bbaabe2019-08-28 16:08:35 -0700267
Marin Shalamanova7fe3042021-01-29 21:02:08 +0100268 std::optional<Fps> onKernelTimerChanged(std::optional<DisplayModeId> desiredActiveModeId,
Marin Shalamanoveadf2e72020-12-10 15:35:28 +0100269 bool timerExpired) const EXCLUDES(mLock);
Steven Thomas2bbaabe2019-08-28 16:08:35 -0700270
Steven Thomasf734df42020-04-13 21:09:28 -0700271 // Returns the highest refresh rate according to the current policy. May change at runtime. Only
272 // uses the primary range, not the app request range.
Marin Shalamanoveadf2e72020-12-10 15:35:28 +0100273 RefreshRate getMaxRefreshRateByPolicy() const EXCLUDES(mLock);
Ady Abraham2139f732019-11-13 18:56:40 -0800274
275 // Returns the current refresh rate
Marin Shalamanoveadf2e72020-12-10 15:35:28 +0100276 RefreshRate getCurrentRefreshRate() const EXCLUDES(mLock);
Ady Abraham2139f732019-11-13 18:56:40 -0800277
Ana Krulec5d477912020-02-07 12:02:38 -0800278 // Returns the current refresh rate, if allowed. Otherwise the default that is allowed by
279 // the policy.
Marin Shalamanoveadf2e72020-12-10 15:35:28 +0100280 RefreshRate getCurrentRefreshRateByPolicy() const;
Ana Krulec5d477912020-02-07 12:02:38 -0800281
Marin Shalamanov23c44202020-12-22 19:09:20 +0100282 // Returns the refresh rate that corresponds to a DisplayModeId. This may change at
Ady Abraham2139f732019-11-13 18:56:40 -0800283 // runtime.
Marin Shalamanova7fe3042021-01-29 21:02:08 +0100284 // TODO(b/159590486) An invalid mode id may be given here if the dipslay modes have changed.
285 RefreshRate getRefreshRateFromModeId(DisplayModeId modeId) const EXCLUDES(mLock) {
Marin Shalamanoveadf2e72020-12-10 15:35:28 +0100286 std::lock_guard lock(mLock);
Marin Shalamanova7fe3042021-01-29 21:02:08 +0100287 return *mRefreshRates.at(modeId);
Ady Abraham2139f732019-11-13 18:56:40 -0800288 };
289
Marin Shalamanova7fe3042021-01-29 21:02:08 +0100290 // Stores the current modeId the device operates at
291 void setCurrentModeId(DisplayModeId) EXCLUDES(mLock);
Dominik Laskowski22488f62019-03-28 09:53:04 -0700292
Ady Abrahama6b676e2020-05-27 14:29:09 -0700293 // Returns a string that represents the layer vote type
294 static std::string layerVoteTypeString(LayerVoteType vote);
295
Ady Abrahamb1b9d412020-06-01 19:53:52 -0700296 // Returns a known frame rate that is the closest to frameRate
Marin Shalamanove8a663d2020-11-24 17:48:00 +0100297 Fps findClosestKnownFrameRate(Fps frameRate) const;
Ady Abrahamb1b9d412020-06-01 19:53:52 -0700298
rnlee3bd610662021-06-23 16:27:57 -0700299 // Configuration flags.
300 struct Config {
301 bool enableFrameRateOverride = false;
302
303 // Specifies the upper refresh rate threshold (inclusive) for layer vote types of multiple
304 // or heuristic, such that refresh rates higher than this value will not be voted for. 0 if
305 // no threshold is set.
306 int frameRateMultipleThreshold = 0;
307 };
308
Marin Shalamanova7fe3042021-01-29 21:02:08 +0100309 RefreshRateConfigs(const DisplayModes& modes, DisplayModeId currentModeId,
rnlee3bd610662021-06-23 16:27:57 -0700310 Config config = {.enableFrameRateOverride = false,
311 .frameRateMultipleThreshold = 0});
Ana Krulec4593b692019-01-11 22:07:25 -0800312
Marin Shalamanova7fe3042021-01-29 21:02:08 +0100313 // Returns whether switching modes (refresh rate or resolution) is possible.
314 // TODO(b/158780872): Consider HAL support, and skip frame rate detection if the modes only
Dominik Laskowski983f2b52020-06-25 16:54:06 -0700315 // differ in resolution.
Marin Shalamanoveadf2e72020-12-10 15:35:28 +0100316 bool canSwitch() const EXCLUDES(mLock) {
317 std::lock_guard lock(mLock);
318 return mRefreshRates.size() > 1;
319 }
Dominik Laskowski983f2b52020-06-25 16:54:06 -0700320
TreeHugger Robot758ab612021-06-22 19:17:29 +0000321 // Class to enumerate options around toggling the kernel timer on and off.
Ana Krulecb9afd792020-06-11 13:16:15 -0700322 enum class KernelIdleTimerAction {
Ana Krulecb9afd792020-06-11 13:16:15 -0700323 TurnOff, // Turn off the idle timer.
324 TurnOn // Turn on the idle timer.
325 };
326 // Checks whether kernel idle timer should be active depending the policy decisions around
327 // refresh rates.
328 KernelIdleTimerAction getIdleTimerAction() const;
329
Ady Abraham64c2fc02020-12-29 12:07:50 -0800330 bool supportsFrameRateOverride() const { return mSupportsFrameRateOverride; }
331
Ady Abraham5cc2e262021-03-25 13:09:17 -0700332 // Return the display refresh rate divider to match the layer
333 // frame rate, or 0 if the display refresh rate is not a multiple of the
334 // layer refresh rate.
335 static int getFrameRateDivider(Fps displayFrameRate, Fps layerFrameRate);
Ady Abraham62a0be22020-12-08 16:54:10 -0800336
Ady Abraham62a0be22020-12-08 16:54:10 -0800337 using UidToFrameRateOverride = std::map<uid_t, Fps>;
Ady Abrahamdd5bfa92021-01-07 17:56:08 -0800338 // Returns the frame rate override for each uid.
339 //
340 // @param layers list of visible layers
341 // @param displayFrameRate the display frame rate
342 // @param touch whether touch timer is active (i.e. user touched the screen recently)
Ady Abraham62a0be22020-12-08 16:54:10 -0800343 UidToFrameRateOverride getFrameRateOverrides(const std::vector<LayerRequirement>& layers,
Ady Abrahamdd5bfa92021-01-07 17:56:08 -0800344 Fps displayFrameRate, bool touch) const
345 EXCLUDES(mLock);
Ady Abraham0bb6a472020-10-12 10:22:13 -0700346
Marin Shalamanovba421a82020-11-10 21:49:26 +0100347 void dump(std::string& result) const EXCLUDES(mLock);
348
Ady Abraham3efa3942021-06-24 19:01:25 -0700349 RefreshRateConfigs(const RefreshRateConfigs&) = delete;
350 void operator=(const RefreshRateConfigs&) = delete;
351
Dominik Laskowski22488f62019-03-28 09:53:04 -0700352private:
Ady Abrahamb1b9d412020-06-01 19:53:52 -0700353 friend class RefreshRateConfigsTest;
354
Ady Abraham2139f732019-11-13 18:56:40 -0800355 void constructAvailableRefreshRates() REQUIRES(mLock);
356
Marin Shalamanoveadf2e72020-12-10 15:35:28 +0100357 void getSortedRefreshRateListLocked(
Ady Abraham2139f732019-11-13 18:56:40 -0800358 const std::function<bool(const RefreshRate&)>& shouldAddRefreshRate,
Marin Shalamanoveadf2e72020-12-10 15:35:28 +0100359 std::vector<const RefreshRate*>* outRefreshRates) REQUIRES(mLock);
Ady Abraham2139f732019-11-13 18:56:40 -0800360
Marin Shalamanov4c7831e2021-06-08 20:44:06 +0200361 std::optional<RefreshRate> getCachedBestRefreshRate(const std::vector<LayerRequirement>& layers,
362 const GlobalSignals& globalSignals,
363 GlobalSignals* outSignalsConsidered) const
364 REQUIRES(mLock);
365
366 RefreshRate getBestRefreshRateLocked(const std::vector<LayerRequirement>& layers,
367 const GlobalSignals& globalSignals,
368 GlobalSignals* outSignalsConsidered) const REQUIRES(mLock);
369
Ady Abraham34702102020-02-10 14:12:05 -0800370 // Returns the refresh rate with the highest score in the collection specified from begin
371 // to end. If there are more than one with the same highest refresh rate, the first one is
372 // returned.
373 template <typename Iter>
374 const RefreshRate* getBestRefreshRate(Iter begin, Iter end) const;
375
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800376 // Returns number of display frames and remainder when dividing the layer refresh period by
377 // display refresh period.
378 std::pair<nsecs_t, nsecs_t> getDisplayFrames(nsecs_t layerPeriod, nsecs_t displayPeriod) const;
379
Steven Thomasf734df42020-04-13 21:09:28 -0700380 // Returns the lowest refresh rate according to the current policy. May change at runtime. Only
381 // uses the primary range, not the app request range.
382 const RefreshRate& getMinRefreshRateByPolicyLocked() const REQUIRES(mLock);
383
384 // Returns the highest refresh rate according to the current policy. May change at runtime. Only
385 // uses the primary range, not the app request range.
386 const RefreshRate& getMaxRefreshRateByPolicyLocked() const REQUIRES(mLock);
387
Ana Krulec3d367c82020-02-25 15:02:01 -0800388 // Returns the current refresh rate, if allowed. Otherwise the default that is allowed by
389 // the policy.
390 const RefreshRate& getCurrentRefreshRateByPolicyLocked() const REQUIRES(mLock);
391
Steven Thomasd4071902020-03-24 16:02:53 -0700392 const Policy* getCurrentPolicyLocked() const REQUIRES(mLock);
Marin Shalamanoveadf2e72020-12-10 15:35:28 +0100393 bool isPolicyValidLocked(const Policy& policy) const REQUIRES(mLock);
Steven Thomasd4071902020-03-24 16:02:53 -0700394
rnlee3bd610662021-06-23 16:27:57 -0700395 // Returns whether the layer is allowed to vote for the given refresh rate.
396 bool isVoteAllowed(const LayerRequirement&, const RefreshRate&) const;
397
Ady Abraham62a0be22020-12-08 16:54:10 -0800398 // calculates a score for a layer. Used to determine the display refresh rate
399 // and the frame rate override for certains applications.
400 float calculateLayerScoreLocked(const LayerRequirement&, const RefreshRate&,
401 bool isSeamlessSwitch) const REQUIRES(mLock);
402
Ady Abraham3efa3942021-06-24 19:01:25 -0700403 void updateDisplayModes(const DisplayModes& mode, DisplayModeId currentModeId) EXCLUDES(mLock);
404
Marin Shalamanova7fe3042021-01-29 21:02:08 +0100405 // The list of refresh rates, indexed by display modes ID. This may change after this
Steven Thomas2bbaabe2019-08-28 16:08:35 -0700406 // object is initialized.
Marin Shalamanoveadf2e72020-12-10 15:35:28 +0100407 AllRefreshRatesMapType mRefreshRates GUARDED_BY(mLock);
Ady Abraham2139f732019-11-13 18:56:40 -0800408
Steven Thomasf734df42020-04-13 21:09:28 -0700409 // The list of refresh rates in the primary range of the current policy, ordered by vsyncPeriod
410 // (the first element is the lowest refresh rate).
411 std::vector<const RefreshRate*> mPrimaryRefreshRates GUARDED_BY(mLock);
412
413 // The list of refresh rates in the app request range of the current policy, ordered by
414 // vsyncPeriod (the first element is the lowest refresh rate).
415 std::vector<const RefreshRate*> mAppRequestRefreshRates GUARDED_BY(mLock);
Ady Abraham2139f732019-11-13 18:56:40 -0800416
Marin Shalamanova7fe3042021-01-29 21:02:08 +0100417 // The current display mode. This will change at runtime. This is set by SurfaceFlinger on
Ady Abraham2139f732019-11-13 18:56:40 -0800418 // the main thread, and read by the Scheduler (and other objects) on other threads.
419 const RefreshRate* mCurrentRefreshRate GUARDED_BY(mLock);
420
Steven Thomasd4071902020-03-24 16:02:53 -0700421 // The policy values will change at runtime. They're set by SurfaceFlinger on the main thread,
422 // and read by the Scheduler (and other objects) on other threads.
423 Policy mDisplayManagerPolicy GUARDED_BY(mLock);
424 std::optional<Policy> mOverridePolicy GUARDED_BY(mLock);
Ady Abraham2139f732019-11-13 18:56:40 -0800425
426 // The min and max refresh rates supported by the device.
Marin Shalamanoveadf2e72020-12-10 15:35:28 +0100427 // This may change at runtime.
428 const RefreshRate* mMinSupportedRefreshRate GUARDED_BY(mLock);
429 const RefreshRate* mMaxSupportedRefreshRate GUARDED_BY(mLock);
Ady Abraham2139f732019-11-13 18:56:40 -0800430
Ady Abraham2139f732019-11-13 18:56:40 -0800431 mutable std::mutex mLock;
Ady Abrahamb1b9d412020-06-01 19:53:52 -0700432
433 // A sorted list of known frame rates that a Heuristic layer will choose
434 // from based on the closest value.
Marin Shalamanove8a663d2020-11-24 17:48:00 +0100435 const std::vector<Fps> mKnownFrameRates;
Ady Abraham64c2fc02020-12-29 12:07:50 -0800436
rnlee3bd610662021-06-23 16:27:57 -0700437 const Config mConfig;
Ady Abraham64c2fc02020-12-29 12:07:50 -0800438 bool mSupportsFrameRateOverride;
Marin Shalamanov4c7831e2021-06-08 20:44:06 +0200439
440 struct GetBestRefreshRateInvocation {
441 std::vector<LayerRequirement> layerRequirements;
442 GlobalSignals globalSignals;
443 GlobalSignals outSignalsConsidered;
444 RefreshRate resultingBestRefreshRate;
445 };
446 mutable std::optional<GetBestRefreshRateInvocation> lastBestRefreshRateInvocation
447 GUARDED_BY(mLock);
Ana Krulecb43429d2019-01-09 14:28:51 -0800448};
449
Dominik Laskowski98041832019-08-01 18:35:59 -0700450} // namespace android::scheduler