blob: 21f5c6848fbe593b81040607d992b048e730c731 [file] [log] [blame]
Ady Abrahamb4b1e0a2019-11-20 18:25:35 -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 */
Ady Abraham2139f732019-11-13 18:56:40 -080016
Ady Abraham8a82ba62020-01-17 12:43:17 -080017// #define LOG_NDEBUG 0
18#define ATRACE_TAG ATRACE_TAG_GRAPHICS
19
Marin Shalamanovbed7fd32020-12-21 20:02:20 +010020// TODO(b/129481165): remove the #pragma below and fix conversion issues
21#pragma clang diagnostic push
22#pragma clang diagnostic ignored "-Wextra"
23
Ady Abraham8a82ba62020-01-17 12:43:17 -080024#include <chrono>
25#include <cmath>
Dominik Laskowski530d6bd2022-10-10 16:55:54 -040026#include <deque>
Ady Abraham68636062022-11-16 17:07:25 -080027#include <map>
Dominik Laskowskif5d0ea52021-09-26 17:27:01 -070028
29#include <android-base/properties.h>
30#include <android-base/stringprintf.h>
31#include <ftl/enum.h>
Dominik Laskowskif8734e02022-08-26 09:06:59 -070032#include <ftl/fake_guard.h>
Dominik Laskowski36dced82022-09-02 09:24:00 -070033#include <ftl/match.h>
Ady Abraham8ca643a2022-10-18 18:26:47 -070034#include <ftl/unit.h>
Ady Abraham68636062022-11-16 17:07:25 -080035#include <scheduler/FrameRateMode.h>
Dominik Laskowskif5d0ea52021-09-26 17:27:01 -070036#include <utils/Trace.h>
37
Ady Abraham4899ff82021-01-06 13:53:29 -080038#include "../SurfaceFlingerProperties.h"
Dominik Laskowskid82e0f02022-10-26 15:23:04 -040039#include "RefreshRateSelector.h"
Ady Abraham8a82ba62020-01-17 12:43:17 -080040
Ady Abraham5b8afb5a2020-03-06 14:57:26 -080041#undef LOG_TAG
Dominik Laskowskid82e0f02022-10-26 15:23:04 -040042#define LOG_TAG "RefreshRateSelector"
Ady Abraham5b8afb5a2020-03-06 14:57:26 -080043
Ady Abrahamb4b1e0a2019-11-20 18:25:35 -080044namespace android::scheduler {
Marin Shalamanov53fc11d2020-11-20 14:00:13 +010045namespace {
Dominik Laskowskif5d0ea52021-09-26 17:27:01 -070046
Dominik Laskowskib0054a22022-03-03 09:03:06 -080047struct RefreshRateScore {
Ady Abraham68636062022-11-16 17:07:25 -080048 FrameRateMode frameRateMode;
Ady Abrahamae2e3c72022-08-13 05:12:13 +000049 float overallScore;
50 struct {
Ady Abraham62f51d92022-08-24 22:20:22 +000051 float modeBelowThreshold;
52 float modeAboveThreshold;
53 } fixedRateBelowThresholdLayersScore;
Dominik Laskowskib0054a22022-03-03 09:03:06 -080054};
55
Dominik Laskowskid82e0f02022-10-26 15:23:04 -040056constexpr RefreshRateSelector::GlobalSignals kNoSignals;
Dominik Laskowskia8626ec2021-12-15 18:13:30 -080057
Dominik Laskowskid82e0f02022-10-26 15:23:04 -040058std::string formatLayerInfo(const RefreshRateSelector::LayerRequirement& layer, float weight) {
Dominik Laskowskib0054a22022-03-03 09:03:06 -080059 return base::StringPrintf("%s (type=%s, weight=%.2f, seamlessness=%s) %s", layer.name.c_str(),
Dominik Laskowskif5d0ea52021-09-26 17:27:01 -070060 ftl::enum_string(layer.vote).c_str(), weight,
61 ftl::enum_string(layer.seamlessness).c_str(),
Marin Shalamanove8a663d2020-11-24 17:48:00 +010062 to_string(layer.desiredRefreshRate).c_str());
Marin Shalamanov53fc11d2020-11-20 14:00:13 +010063}
Marin Shalamanoveadf2e72020-12-10 15:35:28 +010064
Marin Shalamanova7fe3042021-01-29 21:02:08 +010065std::vector<Fps> constructKnownFrameRates(const DisplayModes& modes) {
Dominik Laskowski6eab42d2021-09-13 14:34:13 -070066 std::vector<Fps> knownFrameRates = {24_Hz, 30_Hz, 45_Hz, 60_Hz, 72_Hz};
Marin Shalamanova7fe3042021-01-29 21:02:08 +010067 knownFrameRates.reserve(knownFrameRates.size() + modes.size());
Marin Shalamanoveadf2e72020-12-10 15:35:28 +010068
Dominik Laskowski6eab42d2021-09-13 14:34:13 -070069 // Add all supported refresh rates.
Dominik Laskowskib0054a22022-03-03 09:03:06 -080070 for (const auto& [id, mode] : modes) {
71 knownFrameRates.push_back(mode->getFps());
Marin Shalamanoveadf2e72020-12-10 15:35:28 +010072 }
73
Dominik Laskowski6eab42d2021-09-13 14:34:13 -070074 // Sort and remove duplicates.
75 std::sort(knownFrameRates.begin(), knownFrameRates.end(), isStrictlyLess);
Marin Shalamanoveadf2e72020-12-10 15:35:28 +010076 knownFrameRates.erase(std::unique(knownFrameRates.begin(), knownFrameRates.end(),
Dominik Laskowski6eab42d2021-09-13 14:34:13 -070077 isApproxEqual),
Marin Shalamanoveadf2e72020-12-10 15:35:28 +010078 knownFrameRates.end());
79 return knownFrameRates;
80}
81
Ady Abraham68636062022-11-16 17:07:25 -080082std::vector<DisplayModeIterator> sortByRefreshRate(const DisplayModes& modes) {
Dominik Laskowskib0054a22022-03-03 09:03:06 -080083 std::vector<DisplayModeIterator> sortedModes;
84 sortedModes.reserve(modes.size());
Dominik Laskowskib0054a22022-03-03 09:03:06 -080085 for (auto it = modes.begin(); it != modes.end(); ++it) {
Ady Abraham68636062022-11-16 17:07:25 -080086 sortedModes.push_back(it);
Dominik Laskowskib0054a22022-03-03 09:03:06 -080087 }
88
89 std::sort(sortedModes.begin(), sortedModes.end(), [](auto it1, auto it2) {
90 const auto& mode1 = it1->second;
91 const auto& mode2 = it2->second;
92
93 if (mode1->getVsyncPeriod() == mode2->getVsyncPeriod()) {
94 return mode1->getGroup() > mode2->getGroup();
95 }
96
97 return mode1->getVsyncPeriod() > mode2->getVsyncPeriod();
98 });
99
100 return sortedModes;
Marin Shalamanov46084422020-10-13 12:33:42 +0200101}
102
Ady Abraham68636062022-11-16 17:07:25 -0800103std::pair<unsigned, unsigned> divisorRange(Fps fps, FpsRange range,
104 RefreshRateSelector::Config::FrameRateOverride config) {
105 if (config != RefreshRateSelector::Config::FrameRateOverride::Enabled) {
106 return {1, 1};
107 }
108
109 using fps_approx_ops::operator/;
Ady Abraham08048ce2022-11-30 18:08:00 -0800110 // use signed type as `fps / range.max` might be 0
111 const auto start = std::max(1, static_cast<int>(fps / range.max) - 1);
Ady Abraham68636062022-11-16 17:07:25 -0800112 const auto end = fps /
113 std::max(range.min, RefreshRateSelector::kMinSupportedFrameRate,
114 fps_approx_ops::operator<);
115
116 return {start, end};
117}
118
Ady Abraham8ca643a2022-10-18 18:26:47 -0700119bool shouldEnableFrameRateOverride(const std::vector<DisplayModeIterator>& sortedModes) {
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800120 for (const auto it1 : sortedModes) {
121 const auto& mode1 = it1->second;
122 for (const auto it2 : sortedModes) {
123 const auto& mode2 = it2->second;
124
Dominik Laskowskid82e0f02022-10-26 15:23:04 -0400125 if (RefreshRateSelector::getFrameRateDivisor(mode1->getFps(), mode2->getFps()) >= 2) {
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800126 return true;
127 }
128 }
129 }
130 return false;
131}
132
Dominik Laskowskid82e0f02022-10-26 15:23:04 -0400133std::string toString(const RefreshRateSelector::PolicyVariant& policy) {
Dominik Laskowski36dced82022-09-02 09:24:00 -0700134 using namespace std::string_literals;
135
136 return ftl::match(
137 policy,
Dominik Laskowskid82e0f02022-10-26 15:23:04 -0400138 [](const RefreshRateSelector::DisplayManagerPolicy& policy) {
Dominik Laskowski36dced82022-09-02 09:24:00 -0700139 return "DisplayManagerPolicy"s + policy.toString();
140 },
Dominik Laskowskid82e0f02022-10-26 15:23:04 -0400141 [](const RefreshRateSelector::OverridePolicy& policy) {
Dominik Laskowski36dced82022-09-02 09:24:00 -0700142 return "OverridePolicy"s + policy.toString();
143 },
Dominik Laskowskid82e0f02022-10-26 15:23:04 -0400144 [](RefreshRateSelector::NoOverridePolicy) { return "NoOverridePolicy"s; });
Dominik Laskowski36dced82022-09-02 09:24:00 -0700145}
146
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800147} // namespace
148
Ady Abraham68636062022-11-16 17:07:25 -0800149auto RefreshRateSelector::createFrameRateModes(
150 std::function<bool(const DisplayMode&)>&& filterModes, const FpsRange& renderRange) const
151 -> std::vector<FrameRateMode> {
152 struct Key {
153 Fps fps;
154 int32_t group;
155 };
156
157 struct KeyLess {
158 bool operator()(const Key& a, const Key& b) const {
159 using namespace fps_approx_ops;
160 if (a.fps != b.fps) {
161 return a.fps < b.fps;
162 }
163
164 // For the same fps the order doesn't really matter, but we still
165 // want the behaviour of a strictly less operator.
166 // We use the group id as the secondary ordering for that.
167 return a.group < b.group;
168 }
169 };
170
171 std::map<Key, DisplayModeIterator, KeyLess> ratesMap;
172 for (auto it = mDisplayModes.begin(); it != mDisplayModes.end(); ++it) {
173 const auto& [id, mode] = *it;
174
175 if (!filterModes(*mode)) {
176 continue;
177 }
178 const auto [start, end] =
179 divisorRange(mode->getFps(), renderRange, mConfig.enableFrameRateOverride);
180 for (auto divisor = start; divisor <= end; divisor++) {
181 const auto fps = mode->getFps() / divisor;
182 using fps_approx_ops::operator<;
Ady Abrahamdc0b3a72023-01-04 16:58:27 -0800183 if (divisor > 1 && fps < kMinSupportedFrameRate) {
Ady Abraham68636062022-11-16 17:07:25 -0800184 break;
185 }
186
187 if (mConfig.enableFrameRateOverride == Config::FrameRateOverride::Enabled &&
188 !renderRange.includes(fps)) {
189 continue;
190 }
191
192 if (mConfig.enableFrameRateOverride ==
193 Config::FrameRateOverride::AppOverrideNativeRefreshRates &&
194 !isNativeRefreshRate(fps)) {
195 continue;
196 }
197
198 const auto [existingIter, emplaceHappened] =
199 ratesMap.try_emplace(Key{fps, mode->getGroup()}, it);
200 if (emplaceHappened) {
201 ALOGV("%s: including %s (%s)", __func__, to_string(fps).c_str(),
202 to_string(mode->getFps()).c_str());
203 } else {
204 // We might need to update the map as we found a lower refresh rate
205 if (isStrictlyLess(mode->getFps(), existingIter->second->second->getFps())) {
206 existingIter->second = it;
207 ALOGV("%s: changing %s (%s)", __func__, to_string(fps).c_str(),
208 to_string(mode->getFps()).c_str());
209 }
210 }
211 }
212 }
213
214 std::vector<FrameRateMode> frameRateModes;
215 frameRateModes.reserve(ratesMap.size());
216 for (const auto& [key, mode] : ratesMap) {
Ady Abrahamace3d052022-11-17 16:25:05 -0800217 frameRateModes.emplace_back(FrameRateMode{key.fps, ftl::as_non_null(mode->second)});
Ady Abraham68636062022-11-16 17:07:25 -0800218 }
219
220 // We always want that the lowest frame rate will be corresponding to the
221 // lowest mode for power saving.
222 const auto lowestRefreshRateIt =
223 std::min_element(frameRateModes.begin(), frameRateModes.end(),
224 [](const FrameRateMode& lhs, const FrameRateMode& rhs) {
225 return isStrictlyLess(lhs.modePtr->getFps(),
226 rhs.modePtr->getFps());
227 });
228 frameRateModes.erase(frameRateModes.begin(), lowestRefreshRateIt);
229
230 return frameRateModes;
231}
232
Dominik Laskowskid82e0f02022-10-26 15:23:04 -0400233struct RefreshRateSelector::RefreshRateScoreComparator {
ramindanid72ba162022-09-09 21:33:40 +0000234 bool operator()(const RefreshRateScore& lhs, const RefreshRateScore& rhs) const {
Ady Abraham68636062022-11-16 17:07:25 -0800235 const auto& [frameRateMode, overallScore, _] = lhs;
ramindanid72ba162022-09-09 21:33:40 +0000236
Ady Abraham68636062022-11-16 17:07:25 -0800237 std::string name = to_string(frameRateMode);
238
ramindanid72ba162022-09-09 21:33:40 +0000239 ALOGV("%s sorting scores %.2f", name.c_str(), overallScore);
ramindanid72ba162022-09-09 21:33:40 +0000240 ATRACE_INT(name.c_str(), static_cast<int>(std::round(overallScore * 100)));
241
Ady Abraham68636062022-11-16 17:07:25 -0800242 if (!ScoredFrameRate::scoresEqual(overallScore, rhs.overallScore)) {
ramindanid72ba162022-09-09 21:33:40 +0000243 return overallScore > rhs.overallScore;
244 }
245
ramindanid72ba162022-09-09 21:33:40 +0000246 if (refreshRateOrder == RefreshRateOrder::Descending) {
247 using fps_approx_ops::operator>;
Ady Abraham68636062022-11-16 17:07:25 -0800248 return frameRateMode.fps > rhs.frameRateMode.fps;
ramindanid72ba162022-09-09 21:33:40 +0000249 } else {
250 using fps_approx_ops::operator<;
Ady Abraham68636062022-11-16 17:07:25 -0800251 return frameRateMode.fps < rhs.frameRateMode.fps;
ramindanid72ba162022-09-09 21:33:40 +0000252 }
253 }
254
255 const RefreshRateOrder refreshRateOrder;
256};
257
Dominik Laskowskid82e0f02022-10-26 15:23:04 -0400258std::string RefreshRateSelector::Policy::toString() const {
Dominik Laskowski0acc3842022-04-07 11:23:42 -0700259 return base::StringPrintf("{defaultModeId=%d, allowGroupSwitching=%s"
Ady Abraham285f8c12022-10-11 17:12:14 -0700260 ", primaryRanges=%s, appRequestRanges=%s}",
Dominik Laskowski0acc3842022-04-07 11:23:42 -0700261 defaultMode.value(), allowGroupSwitching ? "true" : "false",
Ady Abraham285f8c12022-10-11 17:12:14 -0700262 to_string(primaryRanges).c_str(),
263 to_string(appRequestRanges).c_str());
Marin Shalamanov30b0b3c2020-10-13 19:15:06 +0200264}
265
Dominik Laskowskid82e0f02022-10-26 15:23:04 -0400266std::pair<nsecs_t, nsecs_t> RefreshRateSelector::getDisplayFrames(nsecs_t layerPeriod,
267 nsecs_t displayPeriod) const {
Ady Abraham62a0be22020-12-08 16:54:10 -0800268 auto [quotient, remainder] = std::div(layerPeriod, displayPeriod);
269 if (remainder <= MARGIN_FOR_PERIOD_CALCULATION ||
270 std::abs(remainder - displayPeriod) <= MARGIN_FOR_PERIOD_CALCULATION) {
271 quotient++;
272 remainder = 0;
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800273 }
274
Ady Abraham62a0be22020-12-08 16:54:10 -0800275 return {quotient, remainder};
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800276}
277
Dominik Laskowskid82e0f02022-10-26 15:23:04 -0400278float RefreshRateSelector::calculateNonExactMatchingLayerScoreLocked(const LayerRequirement& layer,
279 Fps refreshRate) const {
Marin Shalamanov15a0fc62021-08-16 18:20:21 +0200280 constexpr float kScoreForFractionalPairs = .8f;
281
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800282 const auto displayPeriod = refreshRate.getPeriodNsecs();
Ady Abraham62a0be22020-12-08 16:54:10 -0800283 const auto layerPeriod = layer.desiredRefreshRate.getPeriodNsecs();
284 if (layer.vote == LayerVoteType::ExplicitDefault) {
285 // Find the actual rate the layer will render, assuming
Marin Shalamanov15a0fc62021-08-16 18:20:21 +0200286 // that layerPeriod is the minimal period to render a frame.
287 // For example if layerPeriod is 20ms and displayPeriod is 16ms,
288 // then the actualLayerPeriod will be 32ms, because it is the
289 // smallest multiple of the display period which is >= layerPeriod.
Ady Abraham62a0be22020-12-08 16:54:10 -0800290 auto actualLayerPeriod = displayPeriod;
291 int multiplier = 1;
292 while (layerPeriod > actualLayerPeriod + MARGIN_FOR_PERIOD_CALCULATION) {
293 multiplier++;
294 actualLayerPeriod = displayPeriod * multiplier;
295 }
Marin Shalamanov15a0fc62021-08-16 18:20:21 +0200296
297 // Because of the threshold we used above it's possible that score is slightly
298 // above 1.
Ady Abraham62a0be22020-12-08 16:54:10 -0800299 return std::min(1.0f,
300 static_cast<float>(layerPeriod) / static_cast<float>(actualLayerPeriod));
301 }
302
303 if (layer.vote == LayerVoteType::ExplicitExactOrMultiple ||
304 layer.vote == LayerVoteType::Heuristic) {
Ady Abraham68636062022-11-16 17:07:25 -0800305 const float multiplier = refreshRate.getValue() / layer.desiredRefreshRate.getValue();
306
307 // We only want to score this layer as a fractional pair if the content is not
308 // significantly faster than the display rate, at it would cause a significant frame drop.
309 // It is more appropriate to choose a higher display rate even if
310 // a pull-down will be required.
311 constexpr float kMinMultiplier = 0.25f;
312 if (multiplier >= kMinMultiplier &&
313 isFractionalPairOrMultiple(refreshRate, layer.desiredRefreshRate)) {
Ady Abraham05243be2021-09-16 15:58:52 -0700314 return kScoreForFractionalPairs;
Marin Shalamanov15a0fc62021-08-16 18:20:21 +0200315 }
316
Ady Abraham62a0be22020-12-08 16:54:10 -0800317 // Calculate how many display vsyncs we need to present a single frame for this
318 // layer
319 const auto [displayFramesQuotient, displayFramesRemainder] =
320 getDisplayFrames(layerPeriod, displayPeriod);
321 static constexpr size_t MAX_FRAMES_TO_FIT = 10; // Stop calculating when score < 0.1
322 if (displayFramesRemainder == 0) {
323 // Layer desired refresh rate matches the display rate.
Ady Abraham05243be2021-09-16 15:58:52 -0700324 return 1.0f;
Ady Abraham62a0be22020-12-08 16:54:10 -0800325 }
326
327 if (displayFramesQuotient == 0) {
328 // Layer desired refresh rate is higher than the display rate.
329 return (static_cast<float>(layerPeriod) / static_cast<float>(displayPeriod)) *
330 (1.0f / (MAX_FRAMES_TO_FIT + 1));
331 }
332
333 // Layer desired refresh rate is lower than the display rate. Check how well it fits
334 // the cadence.
335 auto diff = std::abs(displayFramesRemainder - (displayPeriod - displayFramesRemainder));
336 int iter = 2;
337 while (diff > MARGIN_FOR_PERIOD_CALCULATION && iter < MAX_FRAMES_TO_FIT) {
338 diff = diff - (displayPeriod - diff);
339 iter++;
340 }
341
Ady Abraham05243be2021-09-16 15:58:52 -0700342 return (1.0f / iter);
343 }
344
345 return 0;
346}
347
Ady Abraham68636062022-11-16 17:07:25 -0800348float RefreshRateSelector::calculateDistanceScoreFromMax(Fps refreshRate) const {
349 const auto& maxFps = mAppRequestFrameRates.back().fps;
350 const float ratio = refreshRate.getValue() / maxFps.getValue();
ramindanid72ba162022-09-09 21:33:40 +0000351 // Use ratio^2 to get a lower score the more we get further from peak
352 return ratio * ratio;
353}
354
Dominik Laskowskid82e0f02022-10-26 15:23:04 -0400355float RefreshRateSelector::calculateLayerScoreLocked(const LayerRequirement& layer, Fps refreshRate,
356 bool isSeamlessSwitch) const {
Ady Abraham05243be2021-09-16 15:58:52 -0700357 // Slightly prefer seamless switches.
358 constexpr float kSeamedSwitchPenalty = 0.95f;
359 const float seamlessness = isSeamlessSwitch ? 1.0f : kSeamedSwitchPenalty;
360
361 // If the layer wants Max, give higher score to the higher refresh rate
362 if (layer.vote == LayerVoteType::Max) {
Ady Abraham68636062022-11-16 17:07:25 -0800363 return calculateDistanceScoreFromMax(refreshRate);
Ady Abraham62a0be22020-12-08 16:54:10 -0800364 }
365
Ady Abrahamdd5bfa92021-01-07 17:56:08 -0800366 if (layer.vote == LayerVoteType::ExplicitExact) {
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800367 const int divisor = getFrameRateDivisor(refreshRate, layer.desiredRefreshRate);
Ady Abraham68636062022-11-16 17:07:25 -0800368 if (supportsAppFrameRateOverrideByContent()) {
Ady Abrahamdd5bfa92021-01-07 17:56:08 -0800369 // Since we support frame rate override, allow refresh rates which are
370 // multiples of the layer's request, as those apps would be throttled
371 // down to run at the desired refresh rate.
Ady Abrahamcc315492022-02-17 17:06:39 -0800372 return divisor > 0;
Ady Abrahamdd5bfa92021-01-07 17:56:08 -0800373 }
374
Ady Abrahamcc315492022-02-17 17:06:39 -0800375 return divisor == 1;
Ady Abrahamdd5bfa92021-01-07 17:56:08 -0800376 }
377
Ady Abrahamcc315492022-02-17 17:06:39 -0800378 // If the layer frame rate is a divisor of the refresh rate it should score
Ady Abraham05243be2021-09-16 15:58:52 -0700379 // the highest score.
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800380 if (getFrameRateDivisor(refreshRate, layer.desiredRefreshRate) > 0) {
Ady Abraham05243be2021-09-16 15:58:52 -0700381 return 1.0f * seamlessness;
382 }
383
Ady Abrahamcc315492022-02-17 17:06:39 -0800384 // The layer frame rate is not a divisor of the refresh rate,
Ady Abraham05243be2021-09-16 15:58:52 -0700385 // there is a small penalty attached to the score to favor the frame rates
386 // the exactly matches the display refresh rate or a multiple.
Ady Abraham1c595502022-01-13 21:58:32 -0800387 constexpr float kNonExactMatchingPenalty = 0.95f;
Ady Abraham05243be2021-09-16 15:58:52 -0700388 return calculateNonExactMatchingLayerScoreLocked(layer, refreshRate) * seamlessness *
389 kNonExactMatchingPenalty;
Ady Abraham62a0be22020-12-08 16:54:10 -0800390}
391
Ady Abraham68636062022-11-16 17:07:25 -0800392auto RefreshRateSelector::getRankedFrameRates(const std::vector<LayerRequirement>& layers,
393 GlobalSignals signals) const -> RankedFrameRates {
Marin Shalamanov4c7831e2021-06-08 20:44:06 +0200394 std::lock_guard lock(mLock);
395
Ady Abraham68636062022-11-16 17:07:25 -0800396 if (mGetRankedFrameRatesCache &&
397 mGetRankedFrameRatesCache->arguments == std::make_pair(layers, signals)) {
398 return mGetRankedFrameRatesCache->result;
Marin Shalamanov4c7831e2021-06-08 20:44:06 +0200399 }
400
Ady Abraham68636062022-11-16 17:07:25 -0800401 const auto result = getRankedFrameRatesLocked(layers, signals);
402 mGetRankedFrameRatesCache = GetRankedFrameRatesCache{{layers, signals}, result};
Marin Shalamanov4c7831e2021-06-08 20:44:06 +0200403 return result;
404}
405
Ady Abraham68636062022-11-16 17:07:25 -0800406auto RefreshRateSelector::getRankedFrameRatesLocked(const std::vector<LayerRequirement>& layers,
407 GlobalSignals signals) const
408 -> RankedFrameRates {
Ady Abrahamae2e3c72022-08-13 05:12:13 +0000409 using namespace fps_approx_ops;
Ady Abraham8a82ba62020-01-17 12:43:17 -0800410 ATRACE_CALL();
Dominik Laskowskia8626ec2021-12-15 18:13:30 -0800411 ALOGV("%s: %zu layers", __func__, layers.size());
Ady Abrahamdfd62162020-06-10 16:11:56 -0700412
Ady Abrahamace3d052022-11-17 16:25:05 -0800413 const auto& activeMode = *getActiveModeLocked().modePtr;
ramindani38c84982022-08-29 18:02:57 +0000414
Ady Abraham68636062022-11-16 17:07:25 -0800415 // Keep the display at max frame rate for the duration of powering on the display.
ramindani38c84982022-08-29 18:02:57 +0000416 if (signals.powerOnImminent) {
417 ALOGV("Power On Imminent");
Ady Abraham68636062022-11-16 17:07:25 -0800418 return {rankFrameRates(activeMode.getGroup(), RefreshRateOrder::Descending),
ramindanid72ba162022-09-09 21:33:40 +0000419 GlobalSignals{.powerOnImminent = true}};
ramindani38c84982022-08-29 18:02:57 +0000420 }
421
Ady Abraham8a82ba62020-01-17 12:43:17 -0800422 int noVoteLayers = 0;
423 int minVoteLayers = 0;
424 int maxVoteLayers = 0;
Ady Abraham71c437d2020-01-31 15:56:57 -0800425 int explicitDefaultVoteLayers = 0;
426 int explicitExactOrMultipleVoteLayers = 0;
Ady Abrahamdd5bfa92021-01-07 17:56:08 -0800427 int explicitExact = 0;
Marin Shalamanovae0b5352021-03-24 12:56:08 +0100428 int seamedFocusedLayers = 0;
Dominik Laskowskia8626ec2021-12-15 18:13:30 -0800429
Ady Abraham8a82ba62020-01-17 12:43:17 -0800430 for (const auto& layer : layers) {
Ady Abrahamdd5bfa92021-01-07 17:56:08 -0800431 switch (layer.vote) {
432 case LayerVoteType::NoVote:
433 noVoteLayers++;
434 break;
435 case LayerVoteType::Min:
436 minVoteLayers++;
437 break;
438 case LayerVoteType::Max:
439 maxVoteLayers++;
440 break;
441 case LayerVoteType::ExplicitDefault:
442 explicitDefaultVoteLayers++;
Ady Abrahamdd5bfa92021-01-07 17:56:08 -0800443 break;
444 case LayerVoteType::ExplicitExactOrMultiple:
445 explicitExactOrMultipleVoteLayers++;
Ady Abrahamdd5bfa92021-01-07 17:56:08 -0800446 break;
447 case LayerVoteType::ExplicitExact:
448 explicitExact++;
Ady Abrahamdd5bfa92021-01-07 17:56:08 -0800449 break;
450 case LayerVoteType::Heuristic:
451 break;
Ady Abraham6fb599b2020-03-05 13:48:22 -0800452 }
Marin Shalamanov46084422020-10-13 12:33:42 +0200453
Marin Shalamanovae0b5352021-03-24 12:56:08 +0100454 if (layer.seamlessness == Seamlessness::SeamedAndSeamless && layer.focused) {
455 seamedFocusedLayers++;
Marin Shalamanov46084422020-10-13 12:33:42 +0200456 }
Ady Abraham6fb599b2020-03-05 13:48:22 -0800457 }
458
Ady Abrahamdd5bfa92021-01-07 17:56:08 -0800459 const bool hasExplicitVoteLayers = explicitDefaultVoteLayers > 0 ||
460 explicitExactOrMultipleVoteLayers > 0 || explicitExact > 0;
Alec Mouri11232a22020-05-14 18:06:25 -0700461
Marin Shalamanov8cd8a992021-09-14 23:22:49 +0200462 const Policy* policy = getCurrentPolicyLocked();
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800463 const auto& defaultMode = mDisplayModes.get(policy->defaultMode)->get();
Dominik Laskowskif8734e02022-08-26 09:06:59 -0700464
Marin Shalamanov8cd8a992021-09-14 23:22:49 +0200465 // If the default mode group is different from the group of current mode,
466 // this means a layer requesting a seamed mode switch just disappeared and
467 // we should switch back to the default group.
468 // However if a seamed layer is still present we anchor around the group
469 // of the current mode, in order to prevent unnecessary seamed mode switches
470 // (e.g. when pausing a video playback).
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800471 const auto anchorGroup =
Dominik Laskowskif8734e02022-08-26 09:06:59 -0700472 seamedFocusedLayers > 0 ? activeMode.getGroup() : defaultMode->getGroup();
Marin Shalamanov8cd8a992021-09-14 23:22:49 +0200473
Steven Thomasf734df42020-04-13 21:09:28 -0700474 // Consider the touch event if there are no Explicit* layers. Otherwise wait until after we've
475 // selected a refresh rate to see if we should apply touch boost.
Dominik Laskowskia8626ec2021-12-15 18:13:30 -0800476 if (signals.touch && !hasExplicitVoteLayers) {
ramindanid72ba162022-09-09 21:33:40 +0000477 ALOGV("Touch Boost");
Ady Abraham68636062022-11-16 17:07:25 -0800478 return {rankFrameRates(anchorGroup, RefreshRateOrder::Descending),
ramindanid72ba162022-09-09 21:33:40 +0000479 GlobalSignals{.touch = true}};
Ady Abraham8a82ba62020-01-17 12:43:17 -0800480 }
481
Alec Mouri11232a22020-05-14 18:06:25 -0700482 // If the primary range consists of a single refresh rate then we can only
483 // move out the of range if layers explicitly request a different refresh
484 // rate.
Marin Shalamanove8a663d2020-11-24 17:48:00 +0100485 const bool primaryRangeIsSingleRate =
Ady Abraham285f8c12022-10-11 17:12:14 -0700486 isApproxEqual(policy->primaryRanges.physical.min, policy->primaryRanges.physical.max);
Alec Mouri11232a22020-05-14 18:06:25 -0700487
Dominik Laskowskia8626ec2021-12-15 18:13:30 -0800488 if (!signals.touch && signals.idle && !(primaryRangeIsSingleRate && hasExplicitVoteLayers)) {
ramindanid72ba162022-09-09 21:33:40 +0000489 ALOGV("Idle");
Ady Abraham68636062022-11-16 17:07:25 -0800490 return {rankFrameRates(activeMode.getGroup(), RefreshRateOrder::Ascending),
ramindanid72ba162022-09-09 21:33:40 +0000491 GlobalSignals{.idle = true}};
Steven Thomasbb374322020-04-28 22:47:16 -0700492 }
493
Steven Thomasdebafed2020-05-18 17:30:35 -0700494 if (layers.empty() || noVoteLayers == layers.size()) {
ramindanid72ba162022-09-09 21:33:40 +0000495 ALOGV("No layers with votes");
Ady Abraham68636062022-11-16 17:07:25 -0800496 return {rankFrameRates(anchorGroup, RefreshRateOrder::Descending), kNoSignals};
Steven Thomasbb374322020-04-28 22:47:16 -0700497 }
498
Ady Abraham8a82ba62020-01-17 12:43:17 -0800499 // Only if all layers want Min we should return Min
500 if (noVoteLayers + minVoteLayers == layers.size()) {
ramindanid72ba162022-09-09 21:33:40 +0000501 ALOGV("All layers Min");
Ady Abraham68636062022-11-16 17:07:25 -0800502 return {rankFrameRates(activeMode.getGroup(), RefreshRateOrder::Ascending), kNoSignals};
Ady Abraham8a82ba62020-01-17 12:43:17 -0800503 }
504
Ady Abraham8a82ba62020-01-17 12:43:17 -0800505 // Find the best refresh rate based on score
Ady Abraham62a0be22020-12-08 16:54:10 -0800506 std::vector<RefreshRateScore> scores;
Ady Abraham68636062022-11-16 17:07:25 -0800507 scores.reserve(mAppRequestFrameRates.size());
Ady Abraham8a82ba62020-01-17 12:43:17 -0800508
Ady Abraham68636062022-11-16 17:07:25 -0800509 for (const FrameRateMode& it : mAppRequestFrameRates) {
510 scores.emplace_back(RefreshRateScore{it, 0.0f});
Ady Abraham8a82ba62020-01-17 12:43:17 -0800511 }
512
513 for (const auto& layer : layers) {
rnlee3bd610662021-06-23 16:27:57 -0700514 ALOGV("Calculating score for %s (%s, weight %.2f, desired %.2f) ", layer.name.c_str(),
Dominik Laskowskif5d0ea52021-09-26 17:27:01 -0700515 ftl::enum_string(layer.vote).c_str(), layer.weight,
rnlee3bd610662021-06-23 16:27:57 -0700516 layer.desiredRefreshRate.getValue());
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800517 if (layer.vote == LayerVoteType::NoVote || layer.vote == LayerVoteType::Min) {
Ady Abraham8a82ba62020-01-17 12:43:17 -0800518 continue;
519 }
520
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800521 const auto weight = layer.weight;
Ady Abraham71c437d2020-01-31 15:56:57 -0800522
Ady Abraham68636062022-11-16 17:07:25 -0800523 for (auto& [mode, overallScore, fixedRateBelowThresholdLayersScore] : scores) {
524 const auto& [fps, modePtr] = mode;
525 const bool isSeamlessSwitch = modePtr->getGroup() == activeMode.getGroup();
Marin Shalamanov46084422020-10-13 12:33:42 +0200526
Marin Shalamanov53fc11d2020-11-20 14:00:13 +0100527 if (layer.seamlessness == Seamlessness::OnlySeamless && !isSeamlessSwitch) {
Marin Shalamanova7fe3042021-01-29 21:02:08 +0100528 ALOGV("%s ignores %s to avoid non-seamless switch. Current mode = %s",
Ady Abraham68636062022-11-16 17:07:25 -0800529 formatLayerInfo(layer, weight).c_str(), to_string(*modePtr).c_str(),
Dominik Laskowskif8734e02022-08-26 09:06:59 -0700530 to_string(activeMode).c_str());
Marin Shalamanov46084422020-10-13 12:33:42 +0200531 continue;
532 }
533
Marin Shalamanov53fc11d2020-11-20 14:00:13 +0100534 if (layer.seamlessness == Seamlessness::SeamedAndSeamless && !isSeamlessSwitch &&
535 !layer.focused) {
536 ALOGV("%s ignores %s because it's not focused and the switch is going to be seamed."
Marin Shalamanova7fe3042021-01-29 21:02:08 +0100537 " Current mode = %s",
Ady Abraham68636062022-11-16 17:07:25 -0800538 formatLayerInfo(layer, weight).c_str(), to_string(*modePtr).c_str(),
Dominik Laskowskif8734e02022-08-26 09:06:59 -0700539 to_string(activeMode).c_str());
Marin Shalamanov53fc11d2020-11-20 14:00:13 +0100540 continue;
541 }
542
Marin Shalamanova7fe3042021-01-29 21:02:08 +0100543 // Layers with default seamlessness vote for the current mode group if
Marin Shalamanov53fc11d2020-11-20 14:00:13 +0100544 // there are layers with seamlessness=SeamedAndSeamless and for the default
Marin Shalamanova7fe3042021-01-29 21:02:08 +0100545 // mode group otherwise. In second case, if the current mode group is different
Marin Shalamanov53fc11d2020-11-20 14:00:13 +0100546 // from the default, this means a layer with seamlessness=SeamedAndSeamless has just
547 // disappeared.
Ady Abraham68636062022-11-16 17:07:25 -0800548 const bool isInPolicyForDefault = modePtr->getGroup() == anchorGroup;
Marin Shalamanovae0b5352021-03-24 12:56:08 +0100549 if (layer.seamlessness == Seamlessness::Default && !isInPolicyForDefault) {
Marin Shalamanova7fe3042021-01-29 21:02:08 +0100550 ALOGV("%s ignores %s. Current mode = %s", formatLayerInfo(layer, weight).c_str(),
Ady Abraham68636062022-11-16 17:07:25 -0800551 to_string(*modePtr).c_str(), to_string(activeMode).c_str());
Marin Shalamanov46084422020-10-13 12:33:42 +0200552 continue;
553 }
554
Ady Abraham68636062022-11-16 17:07:25 -0800555 const bool inPrimaryRange = policy->primaryRanges.physical.includes(modePtr->getFps());
Alec Mouri11232a22020-05-14 18:06:25 -0700556 if ((primaryRangeIsSingleRate || !inPrimaryRange) &&
Ady Abrahamdd5bfa92021-01-07 17:56:08 -0800557 !(layer.focused &&
558 (layer.vote == LayerVoteType::ExplicitDefault ||
559 layer.vote == LayerVoteType::ExplicitExact))) {
Ady Abraham20c029c2020-07-06 12:58:05 -0700560 // Only focused layers with ExplicitDefault frame rate settings are allowed to score
Ady Abrahamaae5ed52020-06-26 09:32:43 -0700561 // refresh rates outside the primary range.
Steven Thomasf734df42020-04-13 21:09:28 -0700562 continue;
563 }
564
Ady Abraham68636062022-11-16 17:07:25 -0800565 const float layerScore = calculateLayerScoreLocked(layer, fps, isSeamlessSwitch);
Ady Abrahamae2e3c72022-08-13 05:12:13 +0000566 const float weightedLayerScore = weight * layerScore;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800567
Ady Abraham13cfb362022-08-13 05:12:13 +0000568 // Layer with fixed source has a special consideration which depends on the
Ady Abrahamae2e3c72022-08-13 05:12:13 +0000569 // mConfig.frameRateMultipleThreshold. We don't want these layers to score
570 // refresh rates above the threshold, but we also don't want to favor the lower
571 // ones by having a greater number of layers scoring them. Instead, we calculate
572 // the score independently for these layers and later decide which
573 // refresh rates to add it. For example, desired 24 fps with 120 Hz threshold should not
574 // score 120 Hz, but desired 60 fps should contribute to the score.
575 const bool fixedSourceLayer = [](LayerVoteType vote) {
576 switch (vote) {
577 case LayerVoteType::ExplicitExactOrMultiple:
578 case LayerVoteType::Heuristic:
579 return true;
580 case LayerVoteType::NoVote:
581 case LayerVoteType::Min:
582 case LayerVoteType::Max:
583 case LayerVoteType::ExplicitDefault:
584 case LayerVoteType::ExplicitExact:
585 return false;
586 }
587 }(layer.vote);
Ady Abraham62f51d92022-08-24 22:20:22 +0000588 const bool layerBelowThreshold = mConfig.frameRateMultipleThreshold != 0 &&
Ady Abrahamae2e3c72022-08-13 05:12:13 +0000589 layer.desiredRefreshRate <
590 Fps::fromValue(mConfig.frameRateMultipleThreshold / 2);
Ady Abraham62f51d92022-08-24 22:20:22 +0000591 if (fixedSourceLayer && layerBelowThreshold) {
Ady Abraham13cfb362022-08-13 05:12:13 +0000592 const bool modeAboveThreshold =
Ady Abraham68636062022-11-16 17:07:25 -0800593 modePtr->getFps() >= Fps::fromValue(mConfig.frameRateMultipleThreshold);
Ady Abraham62f51d92022-08-24 22:20:22 +0000594 if (modeAboveThreshold) {
Ady Abraham68636062022-11-16 17:07:25 -0800595 ALOGV("%s gives %s (%s) fixed source (above threshold) score of %.4f",
596 formatLayerInfo(layer, weight).c_str(), to_string(fps).c_str(),
597 to_string(modePtr->getFps()).c_str(), layerScore);
Ady Abraham62f51d92022-08-24 22:20:22 +0000598 fixedRateBelowThresholdLayersScore.modeAboveThreshold += weightedLayerScore;
Ady Abrahamae2e3c72022-08-13 05:12:13 +0000599 } else {
Ady Abraham68636062022-11-16 17:07:25 -0800600 ALOGV("%s gives %s (%s) fixed source (below threshold) score of %.4f",
601 formatLayerInfo(layer, weight).c_str(), to_string(fps).c_str(),
602 to_string(modePtr->getFps()).c_str(), layerScore);
Ady Abraham62f51d92022-08-24 22:20:22 +0000603 fixedRateBelowThresholdLayersScore.modeBelowThreshold += weightedLayerScore;
Ady Abrahamae2e3c72022-08-13 05:12:13 +0000604 }
605 } else {
Ady Abraham68636062022-11-16 17:07:25 -0800606 ALOGV("%s gives %s (%s) score of %.4f", formatLayerInfo(layer, weight).c_str(),
607 to_string(fps).c_str(), to_string(modePtr->getFps()).c_str(), layerScore);
Ady Abrahamae2e3c72022-08-13 05:12:13 +0000608 overallScore += weightedLayerScore;
609 }
Ady Abraham8a82ba62020-01-17 12:43:17 -0800610 }
611 }
612
Ady Abrahamae2e3c72022-08-13 05:12:13 +0000613 // We want to find the best refresh rate without the fixed source layers,
Ady Abraham62f51d92022-08-24 22:20:22 +0000614 // so we could know whether we should add the modeAboveThreshold scores or not.
Ady Abrahamae2e3c72022-08-13 05:12:13 +0000615 // If the best refresh rate is already above the threshold, it means that
616 // some non-fixed source layers already scored it, so we can just add the score
617 // for all fixed source layers, even the ones that are above the threshold.
618 const bool maxScoreAboveThreshold = [&] {
619 if (mConfig.frameRateMultipleThreshold == 0 || scores.empty()) {
620 return false;
621 }
622
623 const auto maxScoreIt =
624 std::max_element(scores.begin(), scores.end(),
625 [](RefreshRateScore max, RefreshRateScore current) {
Ady Abraham68636062022-11-16 17:07:25 -0800626 return current.overallScore > max.overallScore;
Ady Abrahamae2e3c72022-08-13 05:12:13 +0000627 });
Ady Abraham68636062022-11-16 17:07:25 -0800628 ALOGV("%s (%s) is the best refresh rate without fixed source layers. It is %s the "
629 "threshold for "
Ady Abrahamae2e3c72022-08-13 05:12:13 +0000630 "refresh rate multiples",
Ady Abraham68636062022-11-16 17:07:25 -0800631 to_string(maxScoreIt->frameRateMode.fps).c_str(),
632 to_string(maxScoreIt->frameRateMode.modePtr->getFps()).c_str(),
Ady Abrahamae2e3c72022-08-13 05:12:13 +0000633 maxScoreAboveThreshold ? "above" : "below");
Ady Abraham68636062022-11-16 17:07:25 -0800634 return maxScoreIt->frameRateMode.modePtr->getFps() >=
Ady Abrahamae2e3c72022-08-13 05:12:13 +0000635 Fps::fromValue(mConfig.frameRateMultipleThreshold);
636 }();
637
638 // Now we can add the fixed rate layers score
Ady Abraham68636062022-11-16 17:07:25 -0800639 for (auto& [frameRateMode, overallScore, fixedRateBelowThresholdLayersScore] : scores) {
Ady Abraham62f51d92022-08-24 22:20:22 +0000640 overallScore += fixedRateBelowThresholdLayersScore.modeBelowThreshold;
Ady Abrahamae2e3c72022-08-13 05:12:13 +0000641 if (maxScoreAboveThreshold) {
Ady Abraham62f51d92022-08-24 22:20:22 +0000642 overallScore += fixedRateBelowThresholdLayersScore.modeAboveThreshold;
Ady Abrahamae2e3c72022-08-13 05:12:13 +0000643 }
Ady Abraham68636062022-11-16 17:07:25 -0800644 ALOGV("%s (%s) adjusted overallScore is %.4f", to_string(frameRateMode.fps).c_str(),
645 to_string(frameRateMode.modePtr->getFps()).c_str(), overallScore);
Ady Abrahamae2e3c72022-08-13 05:12:13 +0000646 }
647
648 // Now that we scored all the refresh rates we need to pick the one that got the highest
ramindanid72ba162022-09-09 21:33:40 +0000649 // overallScore. Sort the scores based on their overallScore in descending order of priority.
650 const RefreshRateOrder refreshRateOrder =
651 maxVoteLayers > 0 ? RefreshRateOrder::Descending : RefreshRateOrder::Ascending;
652 std::sort(scores.begin(), scores.end(),
653 RefreshRateScoreComparator{.refreshRateOrder = refreshRateOrder});
ramindanid72ba162022-09-09 21:33:40 +0000654
Ady Abraham68636062022-11-16 17:07:25 -0800655 FrameRateRanking ranking;
Dominik Laskowski530d6bd2022-10-10 16:55:54 -0400656 ranking.reserve(scores.size());
657
658 std::transform(scores.begin(), scores.end(), back_inserter(ranking),
ramindanid72ba162022-09-09 21:33:40 +0000659 [](const RefreshRateScore& score) {
Ady Abraham68636062022-11-16 17:07:25 -0800660 return ScoredFrameRate{score.frameRateMode, score.overallScore};
ramindanid72ba162022-09-09 21:33:40 +0000661 });
Ady Abraham34702102020-02-10 14:12:05 -0800662
Ady Abraham37d46922022-10-05 13:08:51 -0700663 const bool noLayerScore = std::all_of(scores.begin(), scores.end(), [](RefreshRateScore score) {
664 return score.overallScore == 0;
665 });
666
Alec Mouri11232a22020-05-14 18:06:25 -0700667 if (primaryRangeIsSingleRate) {
668 // If we never scored any layers, then choose the rate from the primary
669 // range instead of picking a random score from the app range.
Ady Abraham37d46922022-10-05 13:08:51 -0700670 if (noLayerScore) {
ramindanid72ba162022-09-09 21:33:40 +0000671 ALOGV("Layers not scored");
Ady Abraham68636062022-11-16 17:07:25 -0800672 return {rankFrameRates(anchorGroup, RefreshRateOrder::Descending), kNoSignals};
Alec Mouri11232a22020-05-14 18:06:25 -0700673 } else {
Dominik Laskowski530d6bd2022-10-10 16:55:54 -0400674 return {ranking, kNoSignals};
Alec Mouri11232a22020-05-14 18:06:25 -0700675 }
676 }
677
Steven Thomasf734df42020-04-13 21:09:28 -0700678 // Consider the touch event if there are no ExplicitDefault layers. ExplicitDefault are mostly
679 // interactive (as opposed to ExplicitExactOrMultiple) and therefore if those posted an explicit
680 // vote we should not change it if we get a touch event. Only apply touch boost if it will
681 // actually increase the refresh rate over the normal selection.
Ady Abraham5e4e9832021-06-14 13:40:56 -0700682 const bool touchBoostForExplicitExact = [&] {
Ady Abraham68636062022-11-16 17:07:25 -0800683 if (supportsAppFrameRateOverrideByContent()) {
Ady Abraham5e4e9832021-06-14 13:40:56 -0700684 // Enable touch boost if there are other layers besides exact
685 return explicitExact + noVoteLayers != layers.size();
686 } else {
687 // Enable touch boost if there are no exact layers
688 return explicitExact == 0;
689 }
690 }();
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700691
Ady Abraham68636062022-11-16 17:07:25 -0800692 const auto touchRefreshRates = rankFrameRates(anchorGroup, RefreshRateOrder::Descending);
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700693 using fps_approx_ops::operator<;
694
Dominik Laskowskia8626ec2021-12-15 18:13:30 -0800695 if (signals.touch && explicitDefaultVoteLayers == 0 && touchBoostForExplicitExact &&
Ady Abraham68636062022-11-16 17:07:25 -0800696 scores.front().frameRateMode.fps < touchRefreshRates.front().frameRateMode.fps) {
ramindanid72ba162022-09-09 21:33:40 +0000697 ALOGV("Touch Boost");
698 return {touchRefreshRates, GlobalSignals{.touch = true}};
Steven Thomasf734df42020-04-13 21:09:28 -0700699 }
700
Ady Abraham37d46922022-10-05 13:08:51 -0700701 // If we never scored any layers, and we don't favor high refresh rates, prefer to stay with the
702 // current config
703 if (noLayerScore && refreshRateOrder == RefreshRateOrder::Ascending) {
704 const auto preferredDisplayMode = activeMode.getId();
Ady Abraham68636062022-11-16 17:07:25 -0800705 return {rankFrameRates(anchorGroup, RefreshRateOrder::Ascending, preferredDisplayMode),
Ady Abraham37d46922022-10-05 13:08:51 -0700706 kNoSignals};
707 }
708
Dominik Laskowski530d6bd2022-10-10 16:55:54 -0400709 return {ranking, kNoSignals};
Ady Abraham34702102020-02-10 14:12:05 -0800710}
711
Dominik Laskowskid82e0f02022-10-26 15:23:04 -0400712using LayerRequirementPtrs = std::vector<const RefreshRateSelector::LayerRequirement*>;
713using PerUidLayerRequirements = std::unordered_map<uid_t, LayerRequirementPtrs>;
714
715PerUidLayerRequirements groupLayersByUid(
716 const std::vector<RefreshRateSelector::LayerRequirement>& layers) {
717 PerUidLayerRequirements layersByUid;
Ady Abraham62a0be22020-12-08 16:54:10 -0800718 for (const auto& layer : layers) {
Dominik Laskowskid82e0f02022-10-26 15:23:04 -0400719 const auto it = layersByUid.emplace(layer.ownerUid, LayerRequirementPtrs()).first;
720 auto& layersWithSameUid = it->second;
Ady Abraham62a0be22020-12-08 16:54:10 -0800721 layersWithSameUid.push_back(&layer);
722 }
723
724 // Remove uids that can't have a frame rate override
Dominik Laskowskid82e0f02022-10-26 15:23:04 -0400725 for (auto it = layersByUid.begin(); it != layersByUid.end();) {
726 const auto& layersWithSameUid = it->second;
Ady Abraham62a0be22020-12-08 16:54:10 -0800727 bool skipUid = false;
728 for (const auto& layer : layersWithSameUid) {
Dominik Laskowskid82e0f02022-10-26 15:23:04 -0400729 using LayerVoteType = RefreshRateSelector::LayerVoteType;
730
731 if (layer->vote == LayerVoteType::Max || layer->vote == LayerVoteType::Heuristic) {
Ady Abraham62a0be22020-12-08 16:54:10 -0800732 skipUid = true;
733 break;
734 }
735 }
736 if (skipUid) {
Dominik Laskowskid82e0f02022-10-26 15:23:04 -0400737 it = layersByUid.erase(it);
Ady Abraham62a0be22020-12-08 16:54:10 -0800738 } else {
Dominik Laskowskid82e0f02022-10-26 15:23:04 -0400739 ++it;
Ady Abraham62a0be22020-12-08 16:54:10 -0800740 }
741 }
742
743 return layersByUid;
744}
745
Dominik Laskowskid82e0f02022-10-26 15:23:04 -0400746auto RefreshRateSelector::getFrameRateOverrides(const std::vector<LayerRequirement>& layers,
747 Fps displayRefreshRate,
748 GlobalSignals globalSignals) const
749 -> UidToFrameRateOverride {
Ady Abraham62a0be22020-12-08 16:54:10 -0800750 ATRACE_CALL();
Ady Abraham68636062022-11-16 17:07:25 -0800751 if (mConfig.enableFrameRateOverride == Config::FrameRateOverride::Disabled) {
752 return {};
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800753 }
754
Ady Abraham68636062022-11-16 17:07:25 -0800755 ALOGV("%s: %zu layers", __func__, layers.size());
756 std::lock_guard lock(mLock);
757
Ady Abraham8ca643a2022-10-18 18:26:47 -0700758 const auto* policyPtr = getCurrentPolicyLocked();
759 // We don't want to run lower than 30fps
760 const Fps minFrameRate = std::max(policyPtr->appRequestRanges.render.min, 30_Hz, isApproxLess);
761
762 using fps_approx_ops::operator/;
763 const unsigned numMultiples = displayRefreshRate / minFrameRate;
764
765 std::vector<std::pair<Fps, float>> scoredFrameRates;
766 scoredFrameRates.reserve(numMultiples);
767
768 for (unsigned n = numMultiples; n > 0; n--) {
769 const Fps divisor = displayRefreshRate / n;
770 if (mConfig.enableFrameRateOverride ==
Ady Abraham68636062022-11-16 17:07:25 -0800771 Config::FrameRateOverride::AppOverrideNativeRefreshRates &&
772 !isNativeRefreshRate(divisor)) {
Ady Abraham8ca643a2022-10-18 18:26:47 -0700773 continue;
774 }
775
776 if (policyPtr->appRequestRanges.render.includes(divisor)) {
777 ALOGV("%s: adding %s as a potential frame rate", __func__, to_string(divisor).c_str());
778 scoredFrameRates.emplace_back(divisor, 0);
779 }
780 }
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800781
Dominik Laskowskid82e0f02022-10-26 15:23:04 -0400782 const auto layersByUid = groupLayersByUid(layers);
Ady Abraham62a0be22020-12-08 16:54:10 -0800783 UidToFrameRateOverride frameRateOverrides;
784 for (const auto& [uid, layersWithSameUid] : layersByUid) {
Ady Abrahamdd5bfa92021-01-07 17:56:08 -0800785 // Layers with ExplicitExactOrMultiple expect touch boost
786 const bool hasExplicitExactOrMultiple =
787 std::any_of(layersWithSameUid.cbegin(), layersWithSameUid.cend(),
788 [](const auto& layer) {
789 return layer->vote == LayerVoteType::ExplicitExactOrMultiple;
790 });
791
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700792 if (globalSignals.touch && hasExplicitExactOrMultiple) {
Ady Abrahamdd5bfa92021-01-07 17:56:08 -0800793 continue;
794 }
795
Ady Abraham8ca643a2022-10-18 18:26:47 -0700796 for (auto& [_, score] : scoredFrameRates) {
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800797 score = 0;
Ady Abraham62a0be22020-12-08 16:54:10 -0800798 }
799
800 for (const auto& layer : layersWithSameUid) {
801 if (layer->vote == LayerVoteType::NoVote || layer->vote == LayerVoteType::Min) {
802 continue;
803 }
804
805 LOG_ALWAYS_FATAL_IF(layer->vote != LayerVoteType::ExplicitDefault &&
Ady Abrahamdd5bfa92021-01-07 17:56:08 -0800806 layer->vote != LayerVoteType::ExplicitExactOrMultiple &&
807 layer->vote != LayerVoteType::ExplicitExact);
Ady Abraham8ca643a2022-10-18 18:26:47 -0700808 for (auto& [fps, score] : scoredFrameRates) {
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800809 constexpr bool isSeamlessSwitch = true;
Ady Abraham8ca643a2022-10-18 18:26:47 -0700810 const auto layerScore = calculateLayerScoreLocked(*layer, fps, isSeamlessSwitch);
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800811 score += layer->weight * layerScore;
Ady Abraham62a0be22020-12-08 16:54:10 -0800812 }
813 }
814
Ady Abraham62a0be22020-12-08 16:54:10 -0800815 // If we never scored any layers, we don't have a preferred frame rate
Ady Abraham8ca643a2022-10-18 18:26:47 -0700816 if (std::all_of(scoredFrameRates.begin(), scoredFrameRates.end(),
817 [](const auto& scoredFrameRate) {
818 const auto [_, score] = scoredFrameRate;
819 return score == 0;
820 })) {
Ady Abraham62a0be22020-12-08 16:54:10 -0800821 continue;
822 }
823
ramindanid72ba162022-09-09 21:33:40 +0000824 // Now that we scored all the refresh rates we need to pick the lowest refresh rate
825 // that got the highest score.
Ady Abraham8ca643a2022-10-18 18:26:47 -0700826 const auto [overrideFps, _] =
827 *std::max_element(scoredFrameRates.begin(), scoredFrameRates.end(),
828 [](const auto& lhsPair, const auto& rhsPair) {
829 const float lhs = lhsPair.second;
830 const float rhs = rhsPair.second;
Ady Abraham68636062022-11-16 17:07:25 -0800831 return lhs < rhs && !ScoredFrameRate::scoresEqual(lhs, rhs);
Ady Abraham8ca643a2022-10-18 18:26:47 -0700832 });
833 ALOGV("%s: overriding to %s for uid=%d", __func__, to_string(overrideFps).c_str(), uid);
834 frameRateOverrides.emplace(uid, overrideFps);
Ady Abraham62a0be22020-12-08 16:54:10 -0800835 }
836
837 return frameRateOverrides;
838}
839
Ady Abraham0aa373a2022-11-22 13:56:50 -0800840ftl::Optional<FrameRateMode> RefreshRateSelector::onKernelTimerChanged(
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800841 std::optional<DisplayModeId> desiredActiveModeId, bool timerExpired) const {
Ady Abraham2139f732019-11-13 18:56:40 -0800842 std::lock_guard lock(mLock);
Marin Shalamanoveadf2e72020-12-10 15:35:28 +0100843
Ady Abraham0aa373a2022-11-22 13:56:50 -0800844 const auto current = [&]() REQUIRES(mLock) -> FrameRateMode {
845 if (desiredActiveModeId) {
846 const auto& modePtr = mDisplayModes.get(*desiredActiveModeId)->get();
847 return FrameRateMode{modePtr->getFps(), ftl::as_non_null(modePtr)};
848 }
849
850 return getActiveModeLocked();
851 }();
Marin Shalamanoveadf2e72020-12-10 15:35:28 +0100852
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800853 const DisplayModePtr& min = mMinRefreshRateModeIt->second;
Ady Abraham0aa373a2022-11-22 13:56:50 -0800854 if (current.modePtr->getId() == min->getId()) {
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800855 return {};
Marin Shalamanoveadf2e72020-12-10 15:35:28 +0100856 }
857
Ady Abraham0aa373a2022-11-22 13:56:50 -0800858 return timerExpired ? FrameRateMode{min->getFps(), ftl::as_non_null(min)} : current;
Steven Thomasf734df42020-04-13 21:09:28 -0700859}
860
Dominik Laskowskid82e0f02022-10-26 15:23:04 -0400861const DisplayModePtr& RefreshRateSelector::getMinRefreshRateByPolicyLocked() const {
Ady Abrahamace3d052022-11-17 16:25:05 -0800862 const auto& activeMode = *getActiveModeLocked().modePtr;
Dominik Laskowskif8734e02022-08-26 09:06:59 -0700863
Ady Abraham68636062022-11-16 17:07:25 -0800864 for (const FrameRateMode& mode : mPrimaryFrameRates) {
865 if (activeMode.getGroup() == mode.modePtr->getGroup()) {
Ady Abrahamace3d052022-11-17 16:25:05 -0800866 return mode.modePtr.get();
Marin Shalamanov46084422020-10-13 12:33:42 +0200867 }
868 }
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800869
Dominik Laskowskif8734e02022-08-26 09:06:59 -0700870 ALOGE("Can't find min refresh rate by policy with the same mode group as the current mode %s",
871 to_string(activeMode).c_str());
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800872
873 // Default to the lowest refresh rate.
Ady Abrahamace3d052022-11-17 16:25:05 -0800874 return mPrimaryFrameRates.front().modePtr.get();
Ady Abraham2139f732019-11-13 18:56:40 -0800875}
876
Dominik Laskowskid82e0f02022-10-26 15:23:04 -0400877const DisplayModePtr& RefreshRateSelector::getMaxRefreshRateByPolicyLocked(int anchorGroup) const {
Ady Abrahamace3d052022-11-17 16:25:05 -0800878 const ftl::NonNull<DisplayModePtr>* maxByAnchor = &mPrimaryFrameRates.back().modePtr;
879 const ftl::NonNull<DisplayModePtr>* max = &mPrimaryFrameRates.back().modePtr;
Ady Abraham68636062022-11-16 17:07:25 -0800880
881 bool maxByAnchorFound = false;
882 for (auto it = mPrimaryFrameRates.rbegin(); it != mPrimaryFrameRates.rend(); ++it) {
883 using namespace fps_approx_ops;
884 if (it->modePtr->getFps() > (*max)->getFps()) {
885 max = &it->modePtr;
Marin Shalamanov46084422020-10-13 12:33:42 +0200886 }
Ady Abraham68636062022-11-16 17:07:25 -0800887
888 if (anchorGroup == it->modePtr->getGroup() &&
889 it->modePtr->getFps() >= (*maxByAnchor)->getFps()) {
890 maxByAnchorFound = true;
891 maxByAnchor = &it->modePtr;
892 }
893 }
894
895 if (maxByAnchorFound) {
Ady Abrahamace3d052022-11-17 16:25:05 -0800896 return maxByAnchor->get();
Marin Shalamanov46084422020-10-13 12:33:42 +0200897 }
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800898
ramindanid72ba162022-09-09 21:33:40 +0000899 ALOGE("Can't find max refresh rate by policy with the same group %d", anchorGroup);
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800900
901 // Default to the highest refresh rate.
Ady Abrahamace3d052022-11-17 16:25:05 -0800902 return max->get();
Ady Abraham2139f732019-11-13 18:56:40 -0800903}
904
Ady Abraham68636062022-11-16 17:07:25 -0800905auto RefreshRateSelector::rankFrameRates(std::optional<int> anchorGroupOpt,
906 RefreshRateOrder refreshRateOrder,
907 std::optional<DisplayModeId> preferredDisplayModeOpt) const
908 -> FrameRateRanking {
909 const char* const whence = __func__;
910 std::deque<ScoredFrameRate> ranking;
911 const auto rankFrameRate = [&](const FrameRateMode& frameRateMode) REQUIRES(mLock) {
912 const auto& modePtr = frameRateMode.modePtr;
913 if (anchorGroupOpt && modePtr->getGroup() != anchorGroupOpt) {
Ady Abraham37d46922022-10-05 13:08:51 -0700914 return;
ramindanid72ba162022-09-09 21:33:40 +0000915 }
Ady Abraham37d46922022-10-05 13:08:51 -0700916
Ady Abraham68636062022-11-16 17:07:25 -0800917 float score = calculateDistanceScoreFromMax(frameRateMode.fps);
Ady Abraham37d46922022-10-05 13:08:51 -0700918 const bool inverseScore = (refreshRateOrder == RefreshRateOrder::Ascending);
919 if (inverseScore) {
920 score = 1.0f / score;
921 }
922 if (preferredDisplayModeOpt) {
Ady Abraham68636062022-11-16 17:07:25 -0800923 if (*preferredDisplayModeOpt == modePtr->getId()) {
Dominik Laskowski530d6bd2022-10-10 16:55:54 -0400924 constexpr float kScore = std::numeric_limits<float>::max();
Ady Abraham68636062022-11-16 17:07:25 -0800925 ranking.emplace_front(ScoredFrameRate{frameRateMode, kScore});
Ady Abraham37d46922022-10-05 13:08:51 -0700926 return;
927 }
928 constexpr float kNonPreferredModePenalty = 0.95f;
929 score *= kNonPreferredModePenalty;
930 }
Ady Abraham68636062022-11-16 17:07:25 -0800931 ALOGV("%s(%s) %s (%s) scored %.2f", whence, ftl::enum_string(refreshRateOrder).c_str(),
932 to_string(frameRateMode.fps).c_str(), to_string(modePtr->getFps()).c_str(), score);
933 ranking.emplace_back(ScoredFrameRate{frameRateMode, score});
ramindanid72ba162022-09-09 21:33:40 +0000934 };
935
936 if (refreshRateOrder == RefreshRateOrder::Ascending) {
Ady Abraham68636062022-11-16 17:07:25 -0800937 std::for_each(mPrimaryFrameRates.begin(), mPrimaryFrameRates.end(), rankFrameRate);
ramindanid72ba162022-09-09 21:33:40 +0000938 } else {
Ady Abraham68636062022-11-16 17:07:25 -0800939 std::for_each(mPrimaryFrameRates.rbegin(), mPrimaryFrameRates.rend(), rankFrameRate);
ramindanid72ba162022-09-09 21:33:40 +0000940 }
941
Dominik Laskowski530d6bd2022-10-10 16:55:54 -0400942 if (!ranking.empty() || !anchorGroupOpt) {
943 return {ranking.begin(), ranking.end()};
ramindanid72ba162022-09-09 21:33:40 +0000944 }
945
946 ALOGW("Can't find %s refresh rate by policy with the same mode group"
947 " as the mode group %d",
948 refreshRateOrder == RefreshRateOrder::Ascending ? "min" : "max", anchorGroupOpt.value());
949
Dominik Laskowski530d6bd2022-10-10 16:55:54 -0400950 constexpr std::optional<int> kNoAnchorGroup = std::nullopt;
Ady Abraham68636062022-11-16 17:07:25 -0800951 return rankFrameRates(kNoAnchorGroup, refreshRateOrder, preferredDisplayModeOpt);
ramindanid72ba162022-09-09 21:33:40 +0000952}
953
Ady Abrahamace3d052022-11-17 16:25:05 -0800954FrameRateMode RefreshRateSelector::getActiveMode() const {
Ady Abraham2139f732019-11-13 18:56:40 -0800955 std::lock_guard lock(mLock);
Ady Abrahamace3d052022-11-17 16:25:05 -0800956 return getActiveModeLocked();
Dominik Laskowskif8734e02022-08-26 09:06:59 -0700957}
958
Ady Abrahamace3d052022-11-17 16:25:05 -0800959const FrameRateMode& RefreshRateSelector::getActiveModeLocked() const {
960 return *mActiveModeOpt;
Dominik Laskowskif8734e02022-08-26 09:06:59 -0700961}
962
Ady Abrahamace3d052022-11-17 16:25:05 -0800963void RefreshRateSelector::setActiveMode(DisplayModeId modeId, Fps renderFrameRate) {
Ady Abraham2139f732019-11-13 18:56:40 -0800964 std::lock_guard lock(mLock);
Marin Shalamanov4c7831e2021-06-08 20:44:06 +0200965
Ady Abraham68636062022-11-16 17:07:25 -0800966 // Invalidate the cached invocation to getRankedFrameRates. This forces
967 // the refresh rate to be recomputed on the next call to getRankedFrameRates.
968 mGetRankedFrameRatesCache.reset();
Marin Shalamanov4c7831e2021-06-08 20:44:06 +0200969
Ady Abrahamace3d052022-11-17 16:25:05 -0800970 const auto activeModeOpt = mDisplayModes.get(modeId);
971 LOG_ALWAYS_FATAL_IF(!activeModeOpt);
972
973 mActiveModeOpt.emplace(FrameRateMode{renderFrameRate, ftl::as_non_null(activeModeOpt->get())});
Ady Abrahamb4b1e0a2019-11-20 18:25:35 -0800974}
975
Dominik Laskowskid82e0f02022-10-26 15:23:04 -0400976RefreshRateSelector::RefreshRateSelector(DisplayModes modes, DisplayModeId activeModeId,
977 Config config)
rnlee3bd610662021-06-23 16:27:57 -0700978 : mKnownFrameRates(constructKnownFrameRates(modes)), mConfig(config) {
Ady Abraham9a2ea342021-09-03 17:32:34 -0700979 initializeIdleTimer();
Dominik Laskowskif8734e02022-08-26 09:06:59 -0700980 FTL_FAKE_GUARD(kMainThreadContext, updateDisplayModes(std::move(modes), activeModeId));
Marin Shalamanoveadf2e72020-12-10 15:35:28 +0100981}
982
Dominik Laskowskid82e0f02022-10-26 15:23:04 -0400983void RefreshRateSelector::initializeIdleTimer() {
ramindani32cf0602022-03-02 02:30:29 +0000984 if (mConfig.idleTimerTimeout > 0ms) {
Ady Abraham9a2ea342021-09-03 17:32:34 -0700985 mIdleTimer.emplace(
ramindani32cf0602022-03-02 02:30:29 +0000986 "IdleTimer", mConfig.idleTimerTimeout,
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800987 [this] {
988 std::scoped_lock lock(mIdleTimerCallbacksMutex);
989 if (const auto callbacks = getIdleTimerCallbacks()) {
990 callbacks->onReset();
991 }
Ady Abraham9a2ea342021-09-03 17:32:34 -0700992 },
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800993 [this] {
994 std::scoped_lock lock(mIdleTimerCallbacksMutex);
995 if (const auto callbacks = getIdleTimerCallbacks()) {
996 callbacks->onExpired();
997 }
Ady Abraham9a2ea342021-09-03 17:32:34 -0700998 });
Ady Abraham9a2ea342021-09-03 17:32:34 -0700999 }
1000}
1001
Dominik Laskowskid82e0f02022-10-26 15:23:04 -04001002void RefreshRateSelector::updateDisplayModes(DisplayModes modes, DisplayModeId activeModeId) {
Marin Shalamanoveadf2e72020-12-10 15:35:28 +01001003 std::lock_guard lock(mLock);
Marin Shalamanov4c7831e2021-06-08 20:44:06 +02001004
Ady Abraham68636062022-11-16 17:07:25 -08001005 // Invalidate the cached invocation to getRankedFrameRates. This forces
1006 // the refresh rate to be recomputed on the next call to getRankedFrameRates.
1007 mGetRankedFrameRatesCache.reset();
Marin Shalamanov4c7831e2021-06-08 20:44:06 +02001008
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001009 mDisplayModes = std::move(modes);
Ady Abrahamace3d052022-11-17 16:25:05 -08001010 const auto activeModeOpt = mDisplayModes.get(activeModeId);
1011 LOG_ALWAYS_FATAL_IF(!activeModeOpt);
1012 mActiveModeOpt =
1013 FrameRateMode{activeModeOpt->get()->getFps(), ftl::as_non_null(activeModeOpt->get())};
Ady Abrahamabc27602020-04-08 17:20:29 -07001014
Ady Abraham68636062022-11-16 17:07:25 -08001015 const auto sortedModes = sortByRefreshRate(mDisplayModes);
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001016 mMinRefreshRateModeIt = sortedModes.front();
1017 mMaxRefreshRateModeIt = sortedModes.back();
1018
Marin Shalamanov75f37252021-02-10 21:43:57 +01001019 // Reset the policy because the old one may no longer be valid.
1020 mDisplayManagerPolicy = {};
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001021 mDisplayManagerPolicy.defaultMode = activeModeId;
Ady Abraham64c2fc02020-12-29 12:07:50 -08001022
Ady Abraham8ca643a2022-10-18 18:26:47 -07001023 mFrameRateOverrideConfig = [&] {
1024 switch (mConfig.enableFrameRateOverride) {
1025 case Config::FrameRateOverride::Disabled:
Ady Abraham68636062022-11-16 17:07:25 -08001026 case Config::FrameRateOverride::AppOverride:
Ady Abraham8ca643a2022-10-18 18:26:47 -07001027 case Config::FrameRateOverride::Enabled:
1028 return mConfig.enableFrameRateOverride;
Ady Abraham68636062022-11-16 17:07:25 -08001029 case Config::FrameRateOverride::AppOverrideNativeRefreshRates:
Ady Abraham8ca643a2022-10-18 18:26:47 -07001030 return shouldEnableFrameRateOverride(sortedModes)
Ady Abraham68636062022-11-16 17:07:25 -08001031 ? Config::FrameRateOverride::AppOverrideNativeRefreshRates
Ady Abraham8ca643a2022-10-18 18:26:47 -07001032 : Config::FrameRateOverride::Disabled;
1033 }
1034 }();
Ady Abraham4899ff82021-01-06 13:53:29 -08001035
Ady Abraham68636062022-11-16 17:07:25 -08001036 if (mConfig.enableFrameRateOverride ==
1037 Config::FrameRateOverride::AppOverrideNativeRefreshRates) {
1038 for (const auto& [_, mode] : mDisplayModes) {
1039 mAppOverrideNativeRefreshRates.try_emplace(mode->getFps(), ftl::unit);
1040 }
1041 }
1042
Ady Abrahamabc27602020-04-08 17:20:29 -07001043 constructAvailableRefreshRates();
Ady Abrahamb4b1e0a2019-11-20 18:25:35 -08001044}
1045
Dominik Laskowskid82e0f02022-10-26 15:23:04 -04001046bool RefreshRateSelector::isPolicyValidLocked(const Policy& policy) const {
Marin Shalamanova7fe3042021-01-29 21:02:08 +01001047 // defaultMode must be a valid mode, and within the given refresh rate range.
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001048 if (const auto mode = mDisplayModes.get(policy.defaultMode)) {
Ady Abraham285f8c12022-10-11 17:12:14 -07001049 if (!policy.primaryRanges.physical.includes(mode->get()->getFps())) {
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001050 ALOGE("Default mode is not in the primary range.");
1051 return false;
1052 }
1053 } else {
Marin Shalamanova7fe3042021-01-29 21:02:08 +01001054 ALOGE("Default mode is not found.");
Steven Thomasd4071902020-03-24 16:02:53 -07001055 return false;
1056 }
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001057
Ady Abraham68636062022-11-16 17:07:25 -08001058 const auto& primaryRanges = policy.primaryRanges;
1059 const auto& appRequestRanges = policy.appRequestRanges;
1060 ALOGE_IF(!appRequestRanges.physical.includes(primaryRanges.physical),
Ady Abraham08048ce2022-11-30 18:08:00 -08001061 "Physical range is invalid: primary: %s appRequest: %s",
1062 to_string(primaryRanges.physical).c_str(),
1063 to_string(appRequestRanges.physical).c_str());
1064 ALOGE_IF(!appRequestRanges.render.includes(primaryRanges.render),
1065 "Render range is invalid: primary: %s appRequest: %s",
1066 to_string(primaryRanges.render).c_str(), to_string(appRequestRanges.render).c_str());
Ady Abraham68636062022-11-16 17:07:25 -08001067
1068 return primaryRanges.valid() && appRequestRanges.valid();
Steven Thomasd4071902020-03-24 16:02:53 -07001069}
1070
Dominik Laskowskid82e0f02022-10-26 15:23:04 -04001071auto RefreshRateSelector::setPolicy(const PolicyVariant& policy) -> SetPolicyResult {
Dominik Laskowski36dced82022-09-02 09:24:00 -07001072 Policy oldPolicy;
Ady Abrahamace3d052022-11-17 16:25:05 -08001073 PhysicalDisplayId displayId;
Dominik Laskowski36dced82022-09-02 09:24:00 -07001074 {
1075 std::lock_guard lock(mLock);
1076 oldPolicy = *getCurrentPolicyLocked();
Ana Kruleced3a8cc2019-11-14 00:55:07 +01001077
Dominik Laskowski36dced82022-09-02 09:24:00 -07001078 const bool valid = ftl::match(
1079 policy,
1080 [this](const auto& policy) {
1081 ftl::FakeGuard guard(mLock);
1082 if (!isPolicyValidLocked(policy)) {
1083 ALOGE("Invalid policy: %s", policy.toString().c_str());
1084 return false;
1085 }
1086
1087 using T = std::decay_t<decltype(policy)>;
1088
1089 if constexpr (std::is_same_v<T, DisplayManagerPolicy>) {
1090 mDisplayManagerPolicy = policy;
1091 } else {
1092 static_assert(std::is_same_v<T, OverridePolicy>);
1093 mOverridePolicy = policy;
1094 }
1095 return true;
1096 },
1097 [this](NoOverridePolicy) {
1098 ftl::FakeGuard guard(mLock);
1099 mOverridePolicy.reset();
1100 return true;
1101 });
1102
1103 if (!valid) {
1104 return SetPolicyResult::Invalid;
1105 }
1106
Ady Abraham68636062022-11-16 17:07:25 -08001107 mGetRankedFrameRatesCache.reset();
Dominik Laskowski36dced82022-09-02 09:24:00 -07001108
1109 if (*getCurrentPolicyLocked() == oldPolicy) {
1110 return SetPolicyResult::Unchanged;
1111 }
1112 constructAvailableRefreshRates();
Ady Abrahamace3d052022-11-17 16:25:05 -08001113
1114 displayId = getActiveModeLocked().modePtr->getPhysicalDisplayId();
Steven Thomasd4071902020-03-24 16:02:53 -07001115 }
Dominik Laskowski36dced82022-09-02 09:24:00 -07001116
Dominik Laskowski36dced82022-09-02 09:24:00 -07001117 const unsigned numModeChanges = std::exchange(mNumModeSwitchesInPolicy, 0u);
1118
1119 ALOGI("Display %s policy changed\n"
1120 "Previous: %s\n"
1121 "Current: %s\n"
1122 "%u mode changes were performed under the previous policy",
1123 to_string(displayId).c_str(), oldPolicy.toString().c_str(), toString(policy).c_str(),
1124 numModeChanges);
1125
1126 return SetPolicyResult::Changed;
Steven Thomasd4071902020-03-24 16:02:53 -07001127}
1128
Dominik Laskowskid82e0f02022-10-26 15:23:04 -04001129auto RefreshRateSelector::getCurrentPolicyLocked() const -> const Policy* {
Steven Thomasd4071902020-03-24 16:02:53 -07001130 return mOverridePolicy ? &mOverridePolicy.value() : &mDisplayManagerPolicy;
1131}
1132
Dominik Laskowskid82e0f02022-10-26 15:23:04 -04001133auto RefreshRateSelector::getCurrentPolicy() const -> Policy {
Steven Thomasd4071902020-03-24 16:02:53 -07001134 std::lock_guard lock(mLock);
1135 return *getCurrentPolicyLocked();
1136}
1137
Dominik Laskowskid82e0f02022-10-26 15:23:04 -04001138auto RefreshRateSelector::getDisplayManagerPolicy() const -> Policy {
Steven Thomasd4071902020-03-24 16:02:53 -07001139 std::lock_guard lock(mLock);
1140 return mDisplayManagerPolicy;
Ana Kruleced3a8cc2019-11-14 00:55:07 +01001141}
1142
Ady Abrahamace3d052022-11-17 16:25:05 -08001143bool RefreshRateSelector::isModeAllowed(const FrameRateMode& mode) const {
Ana Kruleced3a8cc2019-11-14 00:55:07 +01001144 std::lock_guard lock(mLock);
Ady Abrahamace3d052022-11-17 16:25:05 -08001145 return std::find(mAppRequestFrameRates.begin(), mAppRequestFrameRates.end(), mode) !=
1146 mAppRequestFrameRates.end();
Ady Abraham2139f732019-11-13 18:56:40 -08001147}
1148
Dominik Laskowskid82e0f02022-10-26 15:23:04 -04001149void RefreshRateSelector::constructAvailableRefreshRates() {
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001150 // Filter modes based on current policy and sort on refresh rate.
Steven Thomasd4071902020-03-24 16:02:53 -07001151 const Policy* policy = getCurrentPolicyLocked();
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001152 ALOGV("%s: %s ", __func__, policy->toString().c_str());
Ady Abrahamabc27602020-04-08 17:20:29 -07001153
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001154 const auto& defaultMode = mDisplayModes.get(policy->defaultMode)->get();
Ady Abraham8a82ba62020-01-17 12:43:17 -08001155
Ady Abraham68636062022-11-16 17:07:25 -08001156 const auto filterRefreshRates = [&](const FpsRanges& ranges,
1157 const char* rangeName) REQUIRES(mLock) {
1158 const auto filterModes = [&](const DisplayMode& mode) {
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001159 return mode.getResolution() == defaultMode->getResolution() &&
1160 mode.getDpi() == defaultMode->getDpi() &&
1161 (policy->allowGroupSwitching || mode.getGroup() == defaultMode->getGroup()) &&
Ady Abraham68636062022-11-16 17:07:25 -08001162 ranges.physical.includes(mode.getFps()) &&
1163 (supportsFrameRateOverride() || ranges.render.includes(mode.getFps()));
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001164 };
Ady Abraham8a82ba62020-01-17 12:43:17 -08001165
Ady Abraham68636062022-11-16 17:07:25 -08001166 const auto frameRateModes = createFrameRateModes(filterModes, ranges.render);
1167 LOG_ALWAYS_FATAL_IF(frameRateModes.empty(),
Ady Abraham08048ce2022-11-30 18:08:00 -08001168 "No matching frame rate modes for %s range. policy: %s", rangeName,
1169 policy->toString().c_str());
Dominik Laskowski953b7fd2022-01-08 19:34:59 -08001170
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001171 const auto stringifyModes = [&] {
1172 std::string str;
Ady Abraham68636062022-11-16 17:07:25 -08001173 for (const auto& frameRateMode : frameRateModes) {
1174 str += to_string(frameRateMode) + " ";
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001175 }
1176 return str;
1177 };
Ady Abraham68636062022-11-16 17:07:25 -08001178 ALOGV("%s render rates: %s", rangeName, stringifyModes().c_str());
Steven Thomasf734df42020-04-13 21:09:28 -07001179
Ady Abraham68636062022-11-16 17:07:25 -08001180 return frameRateModes;
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001181 };
1182
Ady Abraham68636062022-11-16 17:07:25 -08001183 mPrimaryFrameRates = filterRefreshRates(policy->primaryRanges, "primary");
1184 mAppRequestFrameRates = filterRefreshRates(policy->appRequestRanges, "app request");
Ady Abraham2139f732019-11-13 18:56:40 -08001185}
1186
Dominik Laskowskid82e0f02022-10-26 15:23:04 -04001187Fps RefreshRateSelector::findClosestKnownFrameRate(Fps frameRate) const {
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001188 using namespace fps_approx_ops;
1189
1190 if (frameRate <= mKnownFrameRates.front()) {
1191 return mKnownFrameRates.front();
Ady Abrahamb1b9d412020-06-01 19:53:52 -07001192 }
1193
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001194 if (frameRate >= mKnownFrameRates.back()) {
1195 return mKnownFrameRates.back();
Ady Abrahamb1b9d412020-06-01 19:53:52 -07001196 }
1197
Marin Shalamanove8a663d2020-11-24 17:48:00 +01001198 auto lowerBound = std::lower_bound(mKnownFrameRates.begin(), mKnownFrameRates.end(), frameRate,
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001199 isStrictlyLess);
Ady Abrahamb1b9d412020-06-01 19:53:52 -07001200
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001201 const auto distance1 = std::abs(frameRate.getValue() - lowerBound->getValue());
1202 const auto distance2 = std::abs(frameRate.getValue() - std::prev(lowerBound)->getValue());
Ady Abrahamb1b9d412020-06-01 19:53:52 -07001203 return distance1 < distance2 ? *lowerBound : *std::prev(lowerBound);
1204}
1205
Dominik Laskowskid82e0f02022-10-26 15:23:04 -04001206auto RefreshRateSelector::getIdleTimerAction() const -> KernelIdleTimerAction {
Ana Krulecb9afd792020-06-11 13:16:15 -07001207 std::lock_guard lock(mLock);
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001208
1209 const Fps deviceMinFps = mMinRefreshRateModeIt->second->getFps();
1210 const DisplayModePtr& minByPolicy = getMinRefreshRateByPolicyLocked();
Ana Krulecb9afd792020-06-11 13:16:15 -07001211
1212 // Kernel idle timer will set the refresh rate to the device min. If DisplayManager says that
1213 // the min allowed refresh rate is higher than the device min, we do not want to enable the
1214 // timer.
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001215 if (isStrictlyLess(deviceMinFps, minByPolicy->getFps())) {
1216 return KernelIdleTimerAction::TurnOff;
Ana Krulecb9afd792020-06-11 13:16:15 -07001217 }
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001218
ramindanid72ba162022-09-09 21:33:40 +00001219 const DisplayModePtr& maxByPolicy =
Ady Abrahamace3d052022-11-17 16:25:05 -08001220 getMaxRefreshRateByPolicyLocked(getActiveModeLocked().modePtr->getGroup());
Ana Krulecb9afd792020-06-11 13:16:15 -07001221 if (minByPolicy == maxByPolicy) {
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001222 // Turn on the timer when the min of the primary range is below the device min.
1223 if (const Policy* currentPolicy = getCurrentPolicyLocked();
Ady Abraham285f8c12022-10-11 17:12:14 -07001224 isApproxLess(currentPolicy->primaryRanges.physical.min, deviceMinFps)) {
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001225 return KernelIdleTimerAction::TurnOn;
Ana Krulecb9afd792020-06-11 13:16:15 -07001226 }
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001227 return KernelIdleTimerAction::TurnOff;
Ana Krulecb9afd792020-06-11 13:16:15 -07001228 }
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001229
Ana Krulecb9afd792020-06-11 13:16:15 -07001230 // Turn on the timer in all other cases.
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001231 return KernelIdleTimerAction::TurnOn;
Ana Krulecb9afd792020-06-11 13:16:15 -07001232}
1233
Dominik Laskowskid82e0f02022-10-26 15:23:04 -04001234int RefreshRateSelector::getFrameRateDivisor(Fps displayRefreshRate, Fps layerFrameRate) {
Ady Abraham62f216c2020-10-13 19:07:23 -07001235 // This calculation needs to be in sync with the java code
1236 // in DisplayManagerService.getDisplayInfoForFrameRateOverride
Marin Shalamanov15a0fc62021-08-16 18:20:21 +02001237
1238 // The threshold must be smaller than 0.001 in order to differentiate
1239 // between the fractional pairs (e.g. 59.94 and 60).
1240 constexpr float kThreshold = 0.0009f;
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001241 const auto numPeriods = displayRefreshRate.getValue() / layerFrameRate.getValue();
Ady Abraham0bb6a472020-10-12 10:22:13 -07001242 const auto numPeriodsRounded = std::round(numPeriods);
1243 if (std::abs(numPeriods - numPeriodsRounded) > kThreshold) {
Ady Abraham62a0be22020-12-08 16:54:10 -08001244 return 0;
Ady Abraham0bb6a472020-10-12 10:22:13 -07001245 }
1246
Ady Abraham62f216c2020-10-13 19:07:23 -07001247 return static_cast<int>(numPeriodsRounded);
1248}
1249
Dominik Laskowskid82e0f02022-10-26 15:23:04 -04001250bool RefreshRateSelector::isFractionalPairOrMultiple(Fps smaller, Fps bigger) {
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001251 if (isStrictlyLess(bigger, smaller)) {
Marin Shalamanov15a0fc62021-08-16 18:20:21 +02001252 return isFractionalPairOrMultiple(bigger, smaller);
1253 }
1254
1255 const auto multiplier = std::round(bigger.getValue() / smaller.getValue());
1256 constexpr float kCoef = 1000.f / 1001.f;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001257 return isApproxEqual(bigger, Fps::fromValue(smaller.getValue() * multiplier / kCoef)) ||
1258 isApproxEqual(bigger, Fps::fromValue(smaller.getValue() * multiplier * kCoef));
Marin Shalamanov15a0fc62021-08-16 18:20:21 +02001259}
1260
Dominik Laskowskid82e0f02022-10-26 15:23:04 -04001261void RefreshRateSelector::dump(utils::Dumper& dumper) const {
Dominik Laskowskie70461a2022-08-30 14:42:01 -07001262 using namespace std::string_view_literals;
Dominik Laskowski0acc3842022-04-07 11:23:42 -07001263
Marin Shalamanovba421a82020-11-10 21:49:26 +01001264 std::lock_guard lock(mLock);
Marin Shalamanovba421a82020-11-10 21:49:26 +01001265
Ady Abrahamace3d052022-11-17 16:25:05 -08001266 const auto activeMode = getActiveModeLocked();
1267 dumper.dump("activeMode"sv, to_string(activeMode));
Marin Shalamanovba421a82020-11-10 21:49:26 +01001268
Dominik Laskowskie70461a2022-08-30 14:42:01 -07001269 dumper.dump("displayModes"sv);
1270 {
1271 utils::Dumper::Indent indent(dumper);
1272 for (const auto& [id, mode] : mDisplayModes) {
1273 dumper.dump({}, to_string(*mode));
1274 }
Marin Shalamanovba421a82020-11-10 21:49:26 +01001275 }
1276
Dominik Laskowskie70461a2022-08-30 14:42:01 -07001277 dumper.dump("displayManagerPolicy"sv, mDisplayManagerPolicy.toString());
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001278
Dominik Laskowski0acc3842022-04-07 11:23:42 -07001279 if (const Policy& currentPolicy = *getCurrentPolicyLocked();
1280 mOverridePolicy && currentPolicy != mDisplayManagerPolicy) {
Dominik Laskowskie70461a2022-08-30 14:42:01 -07001281 dumper.dump("overridePolicy"sv, currentPolicy.toString());
ramindani32cf0602022-03-02 02:30:29 +00001282 }
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001283
Ady Abraham8ca643a2022-10-18 18:26:47 -07001284 dumper.dump("frameRateOverrideConfig"sv, *ftl::enum_name(mFrameRateOverrideConfig));
Dominik Laskowski0acc3842022-04-07 11:23:42 -07001285
Dominik Laskowski03cfce82022-11-02 12:13:29 -04001286 dumper.dump("idleTimer"sv);
1287 {
1288 utils::Dumper::Indent indent(dumper);
1289 dumper.dump("interval"sv, mIdleTimer.transform(&OneShotTimer::interval));
1290 dumper.dump("controller"sv,
1291 mConfig.kernelIdleTimerController
1292 .and_then(&ftl::enum_name<KernelIdleTimerController>)
1293 .value_or("Platform"sv));
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001294 }
Marin Shalamanovba421a82020-11-10 21:49:26 +01001295}
1296
Dominik Laskowskid82e0f02022-10-26 15:23:04 -04001297std::chrono::milliseconds RefreshRateSelector::getIdleTimerTimeout() {
ramindani32cf0602022-03-02 02:30:29 +00001298 return mConfig.idleTimerTimeout;
1299}
1300
Ady Abraham2139f732019-11-13 18:56:40 -08001301} // namespace android::scheduler
Marin Shalamanovbed7fd32020-12-21 20:02:20 +01001302
1303// TODO(b/129481165): remove the #pragma below and fix conversion issues
Ady Abrahamdd5bfa92021-01-07 17:56:08 -08001304#pragma clang diagnostic pop // ignored "-Wextra"