blob: 6c83f8bfc5f743d3e8451e73d58d8a822ce05890 [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
Ana Krulec4593b692019-01-11 22:07:25 -080027#include "DisplayHardware/HWComposer.h"
Marin Shalamanove8a663d2020-11-24 17:48:00 +010028#include "Fps.h"
Ady Abraham2139f732019-11-13 18:56:40 -080029#include "HwcStrongTypes.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 =
56 std::chrono::nanoseconds(800us).count();
57
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:
67 RefreshRate(HwcConfigIndexType configId,
Marin Shalamanove8a663d2020-11-24 17:48:00 +010068 std::shared_ptr<const HWC2::Display::Config> config, Fps fps, ConstructorTag)
69 : configId(configId), hwcConfig(config), fps(std::move(fps)) {}
Ady Abraham2e1dd892020-03-05 13:48:36 -080070
71 RefreshRate(const RefreshRate&) = delete;
Ady Abrahamabc27602020-04-08 17:20:29 -070072
73 HwcConfigIndexType getConfigId() const { return configId; }
74 nsecs_t getVsyncPeriod() const { return hwcConfig->getVsyncPeriod(); }
75 int32_t getConfigGroup() const { return hwcConfig->getConfigGroup(); }
Marin Shalamanove8a663d2020-11-24 17:48:00 +010076 std::string getName() const { return to_string(fps); }
77 Fps getFps() const { return fps; }
Ady Abraham2139f732019-11-13 18:56:40 -080078
Ana Krulec72f0d6e2020-01-06 15:24:47 -080079 // Checks whether the fps of this RefreshRate struct is within a given min and max refresh
Marin Shalamanove8a663d2020-11-24 17:48:00 +010080 // rate passed in. Margin of error is applied to the boundaries for approximation.
81 bool inPolicy(Fps minRefreshRate, Fps maxRefreshRate) const {
82 return minRefreshRate.lessThanOrEqualWithMargin(fps) &&
83 fps.lessThanOrEqualWithMargin(maxRefreshRate);
Ana Krulec72f0d6e2020-01-06 15:24:47 -080084 }
85
Ady Abraham2139f732019-11-13 18:56:40 -080086 bool operator!=(const RefreshRate& other) const {
Ady Abrahamabc27602020-04-08 17:20:29 -070087 return configId != other.configId || hwcConfig != other.hwcConfig;
Ady Abraham2139f732019-11-13 18:56:40 -080088 }
89
Marin Shalamanove8a663d2020-11-24 17:48:00 +010090 bool operator<(const RefreshRate& other) const {
91 return getFps().getValue() < other.getFps().getValue();
92 }
Ana Krulecb9afd792020-06-11 13:16:15 -070093
Ady Abraham2139f732019-11-13 18:56:40 -080094 bool operator==(const RefreshRate& other) const { return !(*this != other); }
Ady Abrahamabc27602020-04-08 17:20:29 -070095
Marin Shalamanov46084422020-10-13 12:33:42 +020096 std::string toString() const;
97
Ady Abrahamabc27602020-04-08 17:20:29 -070098 private:
99 friend RefreshRateConfigs;
Ady Abrahamb1b9d412020-06-01 19:53:52 -0700100 friend class RefreshRateConfigsTest;
Ady Abrahamabc27602020-04-08 17:20:29 -0700101
Ady Abrahamabc27602020-04-08 17:20:29 -0700102 // This config ID corresponds to the position of the config in the vector that is stored
103 // on the device.
104 const HwcConfigIndexType configId;
105 // The config itself
106 std::shared_ptr<const HWC2::Display::Config> hwcConfig;
Ady Abrahamabc27602020-04-08 17:20:29 -0700107 // Refresh rate in frames per second
Marin Shalamanove8a663d2020-11-24 17:48:00 +0100108 const Fps fps{0.0f};
Ana Krulecb43429d2019-01-09 14:28:51 -0800109 };
110
Ady Abraham2e1dd892020-03-05 13:48:36 -0800111 using AllRefreshRatesMapType =
112 std::unordered_map<HwcConfigIndexType, std::unique_ptr<const RefreshRate>>;
Ady Abraham2139f732019-11-13 18:56:40 -0800113
Steven Thomasd4071902020-03-24 16:02:53 -0700114 struct Policy {
Marin Shalamanov30b0b3c2020-10-13 19:15:06 +0200115 private:
116 static constexpr int kAllowGroupSwitchingDefault = false;
117
118 public:
Steven Thomasf734df42020-04-13 21:09:28 -0700119 struct Range {
Marin Shalamanove8a663d2020-11-24 17:48:00 +0100120 Fps min{0.0f};
121 Fps max{std::numeric_limits<float>::max()};
Steven Thomasf734df42020-04-13 21:09:28 -0700122
123 bool operator==(const Range& other) const {
Marin Shalamanove8a663d2020-11-24 17:48:00 +0100124 return min.equalsWithMargin(other.min) && max.equalsWithMargin(other.max);
Steven Thomasf734df42020-04-13 21:09:28 -0700125 }
126
127 bool operator!=(const Range& other) const { return !(*this == other); }
Marin Shalamanove8a663d2020-11-24 17:48:00 +0100128
129 std::string toString() const {
130 return base::StringPrintf("[%s %s]", to_string(min).c_str(),
131 to_string(max).c_str());
132 }
Steven Thomasf734df42020-04-13 21:09:28 -0700133 };
134
Steven Thomasd4071902020-03-24 16:02:53 -0700135 // The default config, used to ensure we only initiate display config switches within the
136 // same config group as defaultConfigId's group.
137 HwcConfigIndexType defaultConfig;
Marin Shalamanov30b0b3c2020-10-13 19:15:06 +0200138 // Whether or not we switch config groups to get the best frame rate.
139 bool allowGroupSwitching = kAllowGroupSwitchingDefault;
Steven Thomasf734df42020-04-13 21:09:28 -0700140 // The primary refresh rate range represents display manager's general guidance on the
141 // display configs we'll consider when switching refresh rates. Unless we get an explicit
142 // signal from an app, we should stay within this range.
143 Range primaryRange;
144 // The app request refresh rate range allows us to consider more display configs when
145 // switching refresh rates. Although we should generally stay within the primary range,
146 // specific considerations, such as layer frame rate settings specified via the
147 // setFrameRate() api, may cause us to go outside the primary range. We never go outside the
148 // app request range. The app request range will be greater than or equal to the primary
149 // refresh rate range, never smaller.
150 Range appRequestRange;
Steven Thomasd4071902020-03-24 16:02:53 -0700151
Steven Thomasf734df42020-04-13 21:09:28 -0700152 Policy() = default;
Marin Shalamanov30b0b3c2020-10-13 19:15:06 +0200153
Steven Thomasf734df42020-04-13 21:09:28 -0700154 Policy(HwcConfigIndexType defaultConfig, const Range& range)
Marin Shalamanov30b0b3c2020-10-13 19:15:06 +0200155 : Policy(defaultConfig, kAllowGroupSwitchingDefault, range, range) {}
156
157 Policy(HwcConfigIndexType defaultConfig, bool allowGroupSwitching, const Range& range)
158 : Policy(defaultConfig, allowGroupSwitching, range, range) {}
159
Steven Thomasf734df42020-04-13 21:09:28 -0700160 Policy(HwcConfigIndexType defaultConfig, const Range& primaryRange,
161 const Range& appRequestRange)
Marin Shalamanov30b0b3c2020-10-13 19:15:06 +0200162 : Policy(defaultConfig, kAllowGroupSwitchingDefault, primaryRange, appRequestRange) {}
163
164 Policy(HwcConfigIndexType defaultConfig, bool allowGroupSwitching,
165 const Range& primaryRange, const Range& appRequestRange)
Steven Thomasf734df42020-04-13 21:09:28 -0700166 : defaultConfig(defaultConfig),
Marin Shalamanov30b0b3c2020-10-13 19:15:06 +0200167 allowGroupSwitching(allowGroupSwitching),
Steven Thomasf734df42020-04-13 21:09:28 -0700168 primaryRange(primaryRange),
169 appRequestRange(appRequestRange) {}
170
Steven Thomasd4071902020-03-24 16:02:53 -0700171 bool operator==(const Policy& other) const {
Steven Thomasf734df42020-04-13 21:09:28 -0700172 return defaultConfig == other.defaultConfig && primaryRange == other.primaryRange &&
173 appRequestRange == other.appRequestRange &&
Steven Thomasd4071902020-03-24 16:02:53 -0700174 allowGroupSwitching == other.allowGroupSwitching;
175 }
176
177 bool operator!=(const Policy& other) const { return !(*this == other); }
Marin Shalamanovb6674e72020-11-06 13:05:57 +0100178 std::string toString() const;
Steven Thomasd4071902020-03-24 16:02:53 -0700179 };
180
181 // Return code set*Policy() to indicate the current policy is unchanged.
182 static constexpr int CURRENT_POLICY_UNCHANGED = 1;
183
184 // We maintain the display manager policy and the override policy separately. The override
185 // policy is used by CTS tests to get a consistent device state for testing. While the override
186 // policy is set, it takes precedence over the display manager policy. Once the override policy
187 // is cleared, we revert to using the display manager policy.
188
189 // Sets the display manager policy to choose refresh rates. The return value will be:
190 // - A negative value if the policy is invalid or another error occurred.
191 // - NO_ERROR if the policy was successfully updated, and the current policy is different from
192 // what it was before the call.
193 // - CURRENT_POLICY_UNCHANGED if the policy was successfully updated, but the current policy
194 // is the same as it was before the call.
195 status_t setDisplayManagerPolicy(const Policy& policy) EXCLUDES(mLock);
196 // Sets the override policy. See setDisplayManagerPolicy() for the meaning of the return value.
197 status_t setOverridePolicy(const std::optional<Policy>& policy) EXCLUDES(mLock);
198 // Gets the current policy, which will be the override policy if active, and the display manager
199 // policy otherwise.
200 Policy getCurrentPolicy() const EXCLUDES(mLock);
201 // Gets the display manager policy, regardless of whether an override policy is active.
202 Policy getDisplayManagerPolicy() const EXCLUDES(mLock);
Ana Kruleced3a8cc2019-11-14 00:55:07 +0100203
204 // Returns true if config is allowed by the current policy.
205 bool isConfigAllowed(HwcConfigIndexType config) const EXCLUDES(mLock);
Ady Abraham2139f732019-11-13 18:56:40 -0800206
Ady Abraham8a82ba62020-01-17 12:43:17 -0800207 // Describes the different options the layer voted for refresh rate
208 enum class LayerVoteType {
Ady Abraham71c437d2020-01-31 15:56:57 -0800209 NoVote, // Doesn't care about the refresh rate
210 Min, // Minimal refresh rate available
211 Max, // Maximal refresh rate available
212 Heuristic, // Specific refresh rate that was calculated by platform using a heuristic
213 ExplicitDefault, // Specific refresh rate that was provided by the app with Default
214 // compatibility
215 ExplicitExactOrMultiple // Specific refresh rate that was provided by the app with
216 // ExactOrMultiple compatibility
Ady Abraham8a82ba62020-01-17 12:43:17 -0800217 };
218
219 // Captures the layer requirements for a refresh rate. This will be used to determine the
220 // display refresh rate.
221 struct LayerRequirement {
Ady Abrahamaae5ed52020-06-26 09:32:43 -0700222 // Layer's name. Used for debugging purposes.
223 std::string name;
Ady Abraham62a0be22020-12-08 16:54:10 -0800224 // Layer's owner uid
225 uid_t ownerUid = static_cast<uid_t>(-1);
Ady Abrahamaae5ed52020-06-26 09:32:43 -0700226 // Layer vote type.
227 LayerVoteType vote = LayerVoteType::NoVote;
228 // Layer's desired refresh rate, if applicable.
Marin Shalamanove8a663d2020-11-24 17:48:00 +0100229 Fps desiredRefreshRate{0.0f};
Marin Shalamanov46084422020-10-13 12:33:42 +0200230 // If a seamless mode switch is required.
Marin Shalamanov53fc11d2020-11-20 14:00:13 +0100231 Seamlessness seamlessness = Seamlessness::Default;
Ady Abrahamaae5ed52020-06-26 09:32:43 -0700232 // Layer's weight in the range of [0, 1]. The higher the weight the more impact this layer
233 // would have on choosing the refresh rate.
234 float weight = 0.0f;
235 // Whether layer is in focus or not based on WindowManager's state
236 bool focused = false;
Ady Abraham8a82ba62020-01-17 12:43:17 -0800237
238 bool operator==(const LayerRequirement& other) const {
239 return name == other.name && vote == other.vote &&
Marin Shalamanove8a663d2020-11-24 17:48:00 +0100240 desiredRefreshRate.equalsWithMargin(other.desiredRefreshRate) &&
Marin Shalamanovbe97cfa2020-12-01 16:02:07 +0100241 seamlessness == other.seamlessness && weight == other.weight &&
Ady Abrahamaae5ed52020-06-26 09:32:43 -0700242 focused == other.focused;
Ady Abraham8a82ba62020-01-17 12:43:17 -0800243 }
244
245 bool operator!=(const LayerRequirement& other) const { return !(*this == other); }
246 };
247
Ady Abrahamdfd62162020-06-10 16:11:56 -0700248 // Global state describing signals that affect refresh rate choice.
249 struct GlobalSignals {
250 // Whether the user touched the screen recently. Used to apply touch boost.
251 bool touch = false;
252 // True if the system hasn't seen any buffers posted to layers recently.
253 bool idle = false;
254 };
255
Steven Thomasbb374322020-04-28 22:47:16 -0700256 // Returns the refresh rate that fits best to the given layers.
257 // layers - The layer requirements to consider.
Ady Abrahamdfd62162020-06-10 16:11:56 -0700258 // globalSignals - global state of touch and idle
259 // outSignalsConsidered - An output param that tells the caller whether the refresh rate was
260 // chosen based on touch boost and/or idle timer.
Steven Thomasbb374322020-04-28 22:47:16 -0700261 const RefreshRate& getBestRefreshRate(const std::vector<LayerRequirement>& layers,
Ady Abrahamdfd62162020-06-10 16:11:56 -0700262 const GlobalSignals& globalSignals,
263 GlobalSignals* outSignalsConsidered = nullptr) const
Ady Abraham6fb599b2020-03-05 13:48:22 -0800264 EXCLUDES(mLock);
Ana Krulecb43429d2019-01-09 14:28:51 -0800265
Ady Abraham2139f732019-11-13 18:56:40 -0800266 // Returns the lowest refresh rate supported by the device. This won't change at runtime.
267 const RefreshRate& getMinRefreshRate() const { return *mMinSupportedRefreshRate; }
Steven Thomas2bbaabe2019-08-28 16:08:35 -0700268
Steven Thomasf734df42020-04-13 21:09:28 -0700269 // Returns the lowest refresh rate according to the current policy. May change at runtime. Only
270 // uses the primary range, not the app request range.
Ady Abraham2139f732019-11-13 18:56:40 -0800271 const RefreshRate& getMinRefreshRateByPolicy() const EXCLUDES(mLock);
Steven Thomas2bbaabe2019-08-28 16:08:35 -0700272
Ady Abraham2139f732019-11-13 18:56:40 -0800273 // Returns the highest refresh rate supported by the device. This won't change at runtime.
274 const RefreshRate& getMaxRefreshRate() const { return *mMaxSupportedRefreshRate; }
Steven Thomas2bbaabe2019-08-28 16:08:35 -0700275
Steven Thomasf734df42020-04-13 21:09:28 -0700276 // Returns the highest refresh rate according to the current policy. May change at runtime. Only
277 // uses the primary range, not the app request range.
Ady Abraham2139f732019-11-13 18:56:40 -0800278 const RefreshRate& getMaxRefreshRateByPolicy() const EXCLUDES(mLock);
279
280 // Returns the current refresh rate
281 const RefreshRate& getCurrentRefreshRate() const EXCLUDES(mLock);
282
Ana Krulec5d477912020-02-07 12:02:38 -0800283 // Returns the current refresh rate, if allowed. Otherwise the default that is allowed by
284 // the policy.
285 const RefreshRate& getCurrentRefreshRateByPolicy() const;
286
Ady Abraham2139f732019-11-13 18:56:40 -0800287 // Returns the refresh rate that corresponds to a HwcConfigIndexType. This won't change at
288 // runtime.
289 const RefreshRate& getRefreshRateFromConfigId(HwcConfigIndexType configId) const {
Ady Abraham2e1dd892020-03-05 13:48:36 -0800290 return *mRefreshRates.at(configId);
Ady Abraham2139f732019-11-13 18:56:40 -0800291 };
292
293 // Stores the current configId the device operates at
294 void setCurrentConfigId(HwcConfigIndexType configId) EXCLUDES(mLock);
Dominik Laskowski22488f62019-03-28 09:53:04 -0700295
Ady Abrahama6b676e2020-05-27 14:29:09 -0700296 // Returns a string that represents the layer vote type
297 static std::string layerVoteTypeString(LayerVoteType vote);
298
Ady Abrahamb1b9d412020-06-01 19:53:52 -0700299 // Returns a known frame rate that is the closest to frameRate
Marin Shalamanove8a663d2020-11-24 17:48:00 +0100300 Fps findClosestKnownFrameRate(Fps frameRate) const;
Ady Abrahamb1b9d412020-06-01 19:53:52 -0700301
Ana Krulec3f6a2062020-01-23 15:48:01 -0800302 RefreshRateConfigs(const std::vector<std::shared_ptr<const HWC2::Display::Config>>& configs,
Ady Abraham2139f732019-11-13 18:56:40 -0800303 HwcConfigIndexType currentConfigId);
Ana Krulec4593b692019-01-11 22:07:25 -0800304
Dominik Laskowski983f2b52020-06-25 16:54:06 -0700305 // Returns whether switching configs (refresh rate or resolution) is possible.
306 // TODO(b/158780872): Consider HAL support, and skip frame rate detection if the configs only
307 // differ in resolution.
308 bool canSwitch() const { return mRefreshRates.size() > 1; }
309
Ana Krulecb9afd792020-06-11 13:16:15 -0700310 // Class to enumerate options around toggling the kernel timer on and off. We have an option
311 // for no change to avoid extra calls to kernel.
312 enum class KernelIdleTimerAction {
313 NoChange, // Do not change the idle timer.
314 TurnOff, // Turn off the idle timer.
315 TurnOn // Turn on the idle timer.
316 };
317 // Checks whether kernel idle timer should be active depending the policy decisions around
318 // refresh rates.
319 KernelIdleTimerAction getIdleTimerAction() const;
320
Ady Abrahamdbb6dcf2020-12-28 22:22:12 +0000321 // Returns a divider for the current refresh rate
Ady Abraham62a0be22020-12-08 16:54:10 -0800322 int getRefreshRateDivider(Fps frameRate) const EXCLUDES(mLock);
323
324 // Returns the frame rate override for each uid
325 using UidToFrameRateOverride = std::map<uid_t, Fps>;
326 UidToFrameRateOverride getFrameRateOverrides(const std::vector<LayerRequirement>& layers,
327 Fps displayFrameRate) const EXCLUDES(mLock);
Ady Abraham0bb6a472020-10-12 10:22:13 -0700328
Marin Shalamanovba421a82020-11-10 21:49:26 +0100329 void dump(std::string& result) const EXCLUDES(mLock);
330
Dominik Laskowski22488f62019-03-28 09:53:04 -0700331private:
Ady Abrahamb1b9d412020-06-01 19:53:52 -0700332 friend class RefreshRateConfigsTest;
333
Ady Abraham2139f732019-11-13 18:56:40 -0800334 void constructAvailableRefreshRates() REQUIRES(mLock);
Marin Shalamanove8a663d2020-11-24 17:48:00 +0100335 static std::vector<Fps> constructKnownFrameRates(
Ady Abrahamb1b9d412020-06-01 19:53:52 -0700336 const std::vector<std::shared_ptr<const HWC2::Display::Config>>& configs);
Ady Abraham2139f732019-11-13 18:56:40 -0800337
338 void getSortedRefreshRateList(
339 const std::function<bool(const RefreshRate&)>& shouldAddRefreshRate,
340 std::vector<const RefreshRate*>* outRefreshRates);
341
Ady Abraham34702102020-02-10 14:12:05 -0800342 // Returns the refresh rate with the highest score in the collection specified from begin
343 // to end. If there are more than one with the same highest refresh rate, the first one is
344 // returned.
345 template <typename Iter>
346 const RefreshRate* getBestRefreshRate(Iter begin, Iter end) const;
347
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800348 // Returns number of display frames and remainder when dividing the layer refresh period by
349 // display refresh period.
350 std::pair<nsecs_t, nsecs_t> getDisplayFrames(nsecs_t layerPeriod, nsecs_t displayPeriod) const;
351
Steven Thomasf734df42020-04-13 21:09:28 -0700352 // Returns the lowest refresh rate according to the current policy. May change at runtime. Only
353 // uses the primary range, not the app request range.
354 const RefreshRate& getMinRefreshRateByPolicyLocked() const REQUIRES(mLock);
355
356 // Returns the highest refresh rate according to the current policy. May change at runtime. Only
357 // uses the primary range, not the app request range.
358 const RefreshRate& getMaxRefreshRateByPolicyLocked() const REQUIRES(mLock);
359
Ana Krulec3d367c82020-02-25 15:02:01 -0800360 // Returns the current refresh rate, if allowed. Otherwise the default that is allowed by
361 // the policy.
362 const RefreshRate& getCurrentRefreshRateByPolicyLocked() const REQUIRES(mLock);
363
Steven Thomasd4071902020-03-24 16:02:53 -0700364 const Policy* getCurrentPolicyLocked() const REQUIRES(mLock);
365 bool isPolicyValid(const Policy& policy);
366
Ady Abraham62a0be22020-12-08 16:54:10 -0800367 // Return the display refresh rate divider to match the layer
368 // frame rate, or 0 if the display refresh rate is not a multiple of the
369 // layer refresh rate.
370 static int getFrameRateDivider(Fps displayFrameRate, Fps layerFrameRate);
371
372 // calculates a score for a layer. Used to determine the display refresh rate
373 // and the frame rate override for certains applications.
374 float calculateLayerScoreLocked(const LayerRequirement&, const RefreshRate&,
375 bool isSeamlessSwitch) const REQUIRES(mLock);
376
Steven Thomas2bbaabe2019-08-28 16:08:35 -0700377 // The list of refresh rates, indexed by display config ID. This must not change after this
378 // object is initialized.
Ady Abraham2139f732019-11-13 18:56:40 -0800379 AllRefreshRatesMapType mRefreshRates;
380
Steven Thomasf734df42020-04-13 21:09:28 -0700381 // The list of refresh rates in the primary range of the current policy, ordered by vsyncPeriod
382 // (the first element is the lowest refresh rate).
383 std::vector<const RefreshRate*> mPrimaryRefreshRates GUARDED_BY(mLock);
384
385 // The list of refresh rates in the app request range of the current policy, ordered by
386 // vsyncPeriod (the first element is the lowest refresh rate).
387 std::vector<const RefreshRate*> mAppRequestRefreshRates GUARDED_BY(mLock);
Ady Abraham2139f732019-11-13 18:56:40 -0800388
389 // The current config. This will change at runtime. This is set by SurfaceFlinger on
390 // the main thread, and read by the Scheduler (and other objects) on other threads.
391 const RefreshRate* mCurrentRefreshRate GUARDED_BY(mLock);
392
Steven Thomasd4071902020-03-24 16:02:53 -0700393 // The policy values will change at runtime. They're set by SurfaceFlinger on the main thread,
394 // and read by the Scheduler (and other objects) on other threads.
395 Policy mDisplayManagerPolicy GUARDED_BY(mLock);
396 std::optional<Policy> mOverridePolicy GUARDED_BY(mLock);
Ady Abraham2139f732019-11-13 18:56:40 -0800397
398 // The min and max refresh rates supported by the device.
399 // This will not change at runtime.
400 const RefreshRate* mMinSupportedRefreshRate;
401 const RefreshRate* mMaxSupportedRefreshRate;
402
Ady Abraham2139f732019-11-13 18:56:40 -0800403 mutable std::mutex mLock;
Ady Abrahamb1b9d412020-06-01 19:53:52 -0700404
405 // A sorted list of known frame rates that a Heuristic layer will choose
406 // from based on the closest value.
Marin Shalamanove8a663d2020-11-24 17:48:00 +0100407 const std::vector<Fps> mKnownFrameRates;
Ana Krulecb43429d2019-01-09 14:28:51 -0800408};
409
Dominik Laskowski98041832019-08-01 18:35:59 -0700410} // namespace android::scheduler