Ady Abraham | b4b1e0a | 2019-11-20 18:25:35 -0800 | [diff] [blame] | 1 | /* |
| 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 Abraham | 2139f73 | 2019-11-13 18:56:40 -0800 | [diff] [blame] | 16 | |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 17 | // #define LOG_NDEBUG 0 |
| 18 | #define ATRACE_TAG ATRACE_TAG_GRAPHICS |
| 19 | |
Marin Shalamanov | bed7fd3 | 2020-12-21 20:02:20 +0100 | [diff] [blame] | 20 | // TODO(b/129481165): remove the #pragma below and fix conversion issues |
| 21 | #pragma clang diagnostic push |
| 22 | #pragma clang diagnostic ignored "-Wextra" |
| 23 | |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 24 | #include <chrono> |
| 25 | #include <cmath> |
Dominik Laskowski | 530d6bd | 2022-10-10 16:55:54 -0400 | [diff] [blame] | 26 | #include <deque> |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 27 | #include <map> |
Dominik Laskowski | f5d0ea5 | 2021-09-26 17:27:01 -0700 | [diff] [blame] | 28 | |
| 29 | #include <android-base/properties.h> |
| 30 | #include <android-base/stringprintf.h> |
| 31 | #include <ftl/enum.h> |
Dominik Laskowski | f8734e0 | 2022-08-26 09:06:59 -0700 | [diff] [blame] | 32 | #include <ftl/fake_guard.h> |
Dominik Laskowski | 36dced8 | 2022-09-02 09:24:00 -0700 | [diff] [blame] | 33 | #include <ftl/match.h> |
Ady Abraham | 8ca643a | 2022-10-18 18:26:47 -0700 | [diff] [blame] | 34 | #include <ftl/unit.h> |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 35 | #include <scheduler/FrameRateMode.h> |
Dominik Laskowski | f5d0ea5 | 2021-09-26 17:27:01 -0700 | [diff] [blame] | 36 | #include <utils/Trace.h> |
| 37 | |
Ady Abraham | 4899ff8 | 2021-01-06 13:53:29 -0800 | [diff] [blame] | 38 | #include "../SurfaceFlingerProperties.h" |
Dominik Laskowski | d82e0f0 | 2022-10-26 15:23:04 -0400 | [diff] [blame] | 39 | #include "RefreshRateSelector.h" |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 40 | |
Ady Abraham | 5b8afb5a | 2020-03-06 14:57:26 -0800 | [diff] [blame] | 41 | #undef LOG_TAG |
Dominik Laskowski | d82e0f0 | 2022-10-26 15:23:04 -0400 | [diff] [blame] | 42 | #define LOG_TAG "RefreshRateSelector" |
Ady Abraham | 5b8afb5a | 2020-03-06 14:57:26 -0800 | [diff] [blame] | 43 | |
Ady Abraham | b4b1e0a | 2019-11-20 18:25:35 -0800 | [diff] [blame] | 44 | namespace android::scheduler { |
Marin Shalamanov | 53fc11d | 2020-11-20 14:00:13 +0100 | [diff] [blame] | 45 | namespace { |
Dominik Laskowski | f5d0ea5 | 2021-09-26 17:27:01 -0700 | [diff] [blame] | 46 | |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 47 | struct RefreshRateScore { |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 48 | FrameRateMode frameRateMode; |
Ady Abraham | ae2e3c7 | 2022-08-13 05:12:13 +0000 | [diff] [blame] | 49 | float overallScore; |
| 50 | struct { |
Ady Abraham | 62f51d9 | 2022-08-24 22:20:22 +0000 | [diff] [blame] | 51 | float modeBelowThreshold; |
| 52 | float modeAboveThreshold; |
| 53 | } fixedRateBelowThresholdLayersScore; |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 54 | }; |
| 55 | |
Dominik Laskowski | d82e0f0 | 2022-10-26 15:23:04 -0400 | [diff] [blame] | 56 | constexpr RefreshRateSelector::GlobalSignals kNoSignals; |
Dominik Laskowski | a8626ec | 2021-12-15 18:13:30 -0800 | [diff] [blame] | 57 | |
Dominik Laskowski | d82e0f0 | 2022-10-26 15:23:04 -0400 | [diff] [blame] | 58 | std::string formatLayerInfo(const RefreshRateSelector::LayerRequirement& layer, float weight) { |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 59 | return base::StringPrintf("%s (type=%s, weight=%.2f, seamlessness=%s) %s", layer.name.c_str(), |
Dominik Laskowski | f5d0ea5 | 2021-09-26 17:27:01 -0700 | [diff] [blame] | 60 | ftl::enum_string(layer.vote).c_str(), weight, |
| 61 | ftl::enum_string(layer.seamlessness).c_str(), |
Marin Shalamanov | e8a663d | 2020-11-24 17:48:00 +0100 | [diff] [blame] | 62 | to_string(layer.desiredRefreshRate).c_str()); |
Marin Shalamanov | 53fc11d | 2020-11-20 14:00:13 +0100 | [diff] [blame] | 63 | } |
Marin Shalamanov | eadf2e7 | 2020-12-10 15:35:28 +0100 | [diff] [blame] | 64 | |
Marin Shalamanov | a7fe304 | 2021-01-29 21:02:08 +0100 | [diff] [blame] | 65 | std::vector<Fps> constructKnownFrameRates(const DisplayModes& modes) { |
Dominik Laskowski | 6eab42d | 2021-09-13 14:34:13 -0700 | [diff] [blame] | 66 | std::vector<Fps> knownFrameRates = {24_Hz, 30_Hz, 45_Hz, 60_Hz, 72_Hz}; |
Marin Shalamanov | a7fe304 | 2021-01-29 21:02:08 +0100 | [diff] [blame] | 67 | knownFrameRates.reserve(knownFrameRates.size() + modes.size()); |
Marin Shalamanov | eadf2e7 | 2020-12-10 15:35:28 +0100 | [diff] [blame] | 68 | |
Dominik Laskowski | 6eab42d | 2021-09-13 14:34:13 -0700 | [diff] [blame] | 69 | // Add all supported refresh rates. |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 70 | for (const auto& [id, mode] : modes) { |
| 71 | knownFrameRates.push_back(mode->getFps()); |
Marin Shalamanov | eadf2e7 | 2020-12-10 15:35:28 +0100 | [diff] [blame] | 72 | } |
| 73 | |
Dominik Laskowski | 6eab42d | 2021-09-13 14:34:13 -0700 | [diff] [blame] | 74 | // Sort and remove duplicates. |
| 75 | std::sort(knownFrameRates.begin(), knownFrameRates.end(), isStrictlyLess); |
Marin Shalamanov | eadf2e7 | 2020-12-10 15:35:28 +0100 | [diff] [blame] | 76 | knownFrameRates.erase(std::unique(knownFrameRates.begin(), knownFrameRates.end(), |
Dominik Laskowski | 6eab42d | 2021-09-13 14:34:13 -0700 | [diff] [blame] | 77 | isApproxEqual), |
Marin Shalamanov | eadf2e7 | 2020-12-10 15:35:28 +0100 | [diff] [blame] | 78 | knownFrameRates.end()); |
| 79 | return knownFrameRates; |
| 80 | } |
| 81 | |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 82 | std::vector<DisplayModeIterator> sortByRefreshRate(const DisplayModes& modes) { |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 83 | std::vector<DisplayModeIterator> sortedModes; |
| 84 | sortedModes.reserve(modes.size()); |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 85 | for (auto it = modes.begin(); it != modes.end(); ++it) { |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 86 | sortedModes.push_back(it); |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 87 | } |
| 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 Shalamanov | 4608442 | 2020-10-13 12:33:42 +0200 | [diff] [blame] | 101 | } |
| 102 | |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 103 | std::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 Abraham | 08048ce | 2022-11-30 18:08:00 -0800 | [diff] [blame] | 110 | // 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 Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 112 | const auto end = fps / |
| 113 | std::max(range.min, RefreshRateSelector::kMinSupportedFrameRate, |
| 114 | fps_approx_ops::operator<); |
| 115 | |
| 116 | return {start, end}; |
| 117 | } |
| 118 | |
Ady Abraham | 8ca643a | 2022-10-18 18:26:47 -0700 | [diff] [blame] | 119 | bool shouldEnableFrameRateOverride(const std::vector<DisplayModeIterator>& sortedModes) { |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 120 | 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 Laskowski | d82e0f0 | 2022-10-26 15:23:04 -0400 | [diff] [blame] | 125 | if (RefreshRateSelector::getFrameRateDivisor(mode1->getFps(), mode2->getFps()) >= 2) { |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 126 | return true; |
| 127 | } |
| 128 | } |
| 129 | } |
| 130 | return false; |
| 131 | } |
| 132 | |
Dominik Laskowski | d82e0f0 | 2022-10-26 15:23:04 -0400 | [diff] [blame] | 133 | std::string toString(const RefreshRateSelector::PolicyVariant& policy) { |
Dominik Laskowski | 36dced8 | 2022-09-02 09:24:00 -0700 | [diff] [blame] | 134 | using namespace std::string_literals; |
| 135 | |
| 136 | return ftl::match( |
| 137 | policy, |
Dominik Laskowski | d82e0f0 | 2022-10-26 15:23:04 -0400 | [diff] [blame] | 138 | [](const RefreshRateSelector::DisplayManagerPolicy& policy) { |
Dominik Laskowski | 36dced8 | 2022-09-02 09:24:00 -0700 | [diff] [blame] | 139 | return "DisplayManagerPolicy"s + policy.toString(); |
| 140 | }, |
Dominik Laskowski | d82e0f0 | 2022-10-26 15:23:04 -0400 | [diff] [blame] | 141 | [](const RefreshRateSelector::OverridePolicy& policy) { |
Dominik Laskowski | 36dced8 | 2022-09-02 09:24:00 -0700 | [diff] [blame] | 142 | return "OverridePolicy"s + policy.toString(); |
| 143 | }, |
Dominik Laskowski | d82e0f0 | 2022-10-26 15:23:04 -0400 | [diff] [blame] | 144 | [](RefreshRateSelector::NoOverridePolicy) { return "NoOverridePolicy"s; }); |
Dominik Laskowski | 36dced8 | 2022-09-02 09:24:00 -0700 | [diff] [blame] | 145 | } |
| 146 | |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 147 | } // namespace |
| 148 | |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 149 | auto 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 Abraham | dc0b3a7 | 2023-01-04 16:58:27 -0800 | [diff] [blame] | 183 | if (divisor > 1 && fps < kMinSupportedFrameRate) { |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 184 | 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 Abraham | ace3d05 | 2022-11-17 16:25:05 -0800 | [diff] [blame] | 217 | frameRateModes.emplace_back(FrameRateMode{key.fps, ftl::as_non_null(mode->second)}); |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 218 | } |
| 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 Laskowski | d82e0f0 | 2022-10-26 15:23:04 -0400 | [diff] [blame] | 233 | struct RefreshRateSelector::RefreshRateScoreComparator { |
ramindani | d72ba16 | 2022-09-09 21:33:40 +0000 | [diff] [blame] | 234 | bool operator()(const RefreshRateScore& lhs, const RefreshRateScore& rhs) const { |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 235 | const auto& [frameRateMode, overallScore, _] = lhs; |
ramindani | d72ba16 | 2022-09-09 21:33:40 +0000 | [diff] [blame] | 236 | |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 237 | std::string name = to_string(frameRateMode); |
| 238 | |
ramindani | d72ba16 | 2022-09-09 21:33:40 +0000 | [diff] [blame] | 239 | ALOGV("%s sorting scores %.2f", name.c_str(), overallScore); |
ramindani | d72ba16 | 2022-09-09 21:33:40 +0000 | [diff] [blame] | 240 | ATRACE_INT(name.c_str(), static_cast<int>(std::round(overallScore * 100))); |
| 241 | |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 242 | if (!ScoredFrameRate::scoresEqual(overallScore, rhs.overallScore)) { |
ramindani | d72ba16 | 2022-09-09 21:33:40 +0000 | [diff] [blame] | 243 | return overallScore > rhs.overallScore; |
| 244 | } |
| 245 | |
ramindani | d72ba16 | 2022-09-09 21:33:40 +0000 | [diff] [blame] | 246 | if (refreshRateOrder == RefreshRateOrder::Descending) { |
| 247 | using fps_approx_ops::operator>; |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 248 | return frameRateMode.fps > rhs.frameRateMode.fps; |
ramindani | d72ba16 | 2022-09-09 21:33:40 +0000 | [diff] [blame] | 249 | } else { |
| 250 | using fps_approx_ops::operator<; |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 251 | return frameRateMode.fps < rhs.frameRateMode.fps; |
ramindani | d72ba16 | 2022-09-09 21:33:40 +0000 | [diff] [blame] | 252 | } |
| 253 | } |
| 254 | |
| 255 | const RefreshRateOrder refreshRateOrder; |
| 256 | }; |
| 257 | |
Dominik Laskowski | d82e0f0 | 2022-10-26 15:23:04 -0400 | [diff] [blame] | 258 | std::string RefreshRateSelector::Policy::toString() const { |
Dominik Laskowski | 0acc384 | 2022-04-07 11:23:42 -0700 | [diff] [blame] | 259 | return base::StringPrintf("{defaultModeId=%d, allowGroupSwitching=%s" |
Ady Abraham | 285f8c1 | 2022-10-11 17:12:14 -0700 | [diff] [blame] | 260 | ", primaryRanges=%s, appRequestRanges=%s}", |
Dominik Laskowski | 0acc384 | 2022-04-07 11:23:42 -0700 | [diff] [blame] | 261 | defaultMode.value(), allowGroupSwitching ? "true" : "false", |
Ady Abraham | 285f8c1 | 2022-10-11 17:12:14 -0700 | [diff] [blame] | 262 | to_string(primaryRanges).c_str(), |
| 263 | to_string(appRequestRanges).c_str()); |
Marin Shalamanov | 30b0b3c | 2020-10-13 19:15:06 +0200 | [diff] [blame] | 264 | } |
| 265 | |
Dominik Laskowski | d82e0f0 | 2022-10-26 15:23:04 -0400 | [diff] [blame] | 266 | std::pair<nsecs_t, nsecs_t> RefreshRateSelector::getDisplayFrames(nsecs_t layerPeriod, |
| 267 | nsecs_t displayPeriod) const { |
Ady Abraham | 62a0be2 | 2020-12-08 16:54:10 -0800 | [diff] [blame] | 268 | 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 Abraham | 4ccdcb4 | 2020-02-11 17:34:34 -0800 | [diff] [blame] | 273 | } |
| 274 | |
Ady Abraham | 62a0be2 | 2020-12-08 16:54:10 -0800 | [diff] [blame] | 275 | return {quotient, remainder}; |
Ady Abraham | 4ccdcb4 | 2020-02-11 17:34:34 -0800 | [diff] [blame] | 276 | } |
| 277 | |
Dominik Laskowski | d82e0f0 | 2022-10-26 15:23:04 -0400 | [diff] [blame] | 278 | float RefreshRateSelector::calculateNonExactMatchingLayerScoreLocked(const LayerRequirement& layer, |
| 279 | Fps refreshRate) const { |
Marin Shalamanov | 15a0fc6 | 2021-08-16 18:20:21 +0200 | [diff] [blame] | 280 | constexpr float kScoreForFractionalPairs = .8f; |
| 281 | |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 282 | const auto displayPeriod = refreshRate.getPeriodNsecs(); |
Ady Abraham | 62a0be2 | 2020-12-08 16:54:10 -0800 | [diff] [blame] | 283 | const auto layerPeriod = layer.desiredRefreshRate.getPeriodNsecs(); |
| 284 | if (layer.vote == LayerVoteType::ExplicitDefault) { |
| 285 | // Find the actual rate the layer will render, assuming |
Marin Shalamanov | 15a0fc6 | 2021-08-16 18:20:21 +0200 | [diff] [blame] | 286 | // 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 Abraham | 62a0be2 | 2020-12-08 16:54:10 -0800 | [diff] [blame] | 290 | auto actualLayerPeriod = displayPeriod; |
| 291 | int multiplier = 1; |
| 292 | while (layerPeriod > actualLayerPeriod + MARGIN_FOR_PERIOD_CALCULATION) { |
| 293 | multiplier++; |
| 294 | actualLayerPeriod = displayPeriod * multiplier; |
| 295 | } |
Marin Shalamanov | 15a0fc6 | 2021-08-16 18:20:21 +0200 | [diff] [blame] | 296 | |
| 297 | // Because of the threshold we used above it's possible that score is slightly |
| 298 | // above 1. |
Ady Abraham | 62a0be2 | 2020-12-08 16:54:10 -0800 | [diff] [blame] | 299 | 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 Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 305 | 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 Abraham | 05243be | 2021-09-16 15:58:52 -0700 | [diff] [blame] | 314 | return kScoreForFractionalPairs; |
Marin Shalamanov | 15a0fc6 | 2021-08-16 18:20:21 +0200 | [diff] [blame] | 315 | } |
| 316 | |
Ady Abraham | 62a0be2 | 2020-12-08 16:54:10 -0800 | [diff] [blame] | 317 | // 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 Abraham | 05243be | 2021-09-16 15:58:52 -0700 | [diff] [blame] | 324 | return 1.0f; |
Ady Abraham | 62a0be2 | 2020-12-08 16:54:10 -0800 | [diff] [blame] | 325 | } |
| 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 Abraham | 05243be | 2021-09-16 15:58:52 -0700 | [diff] [blame] | 342 | return (1.0f / iter); |
| 343 | } |
| 344 | |
| 345 | return 0; |
| 346 | } |
| 347 | |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 348 | float RefreshRateSelector::calculateDistanceScoreFromMax(Fps refreshRate) const { |
| 349 | const auto& maxFps = mAppRequestFrameRates.back().fps; |
| 350 | const float ratio = refreshRate.getValue() / maxFps.getValue(); |
ramindani | d72ba16 | 2022-09-09 21:33:40 +0000 | [diff] [blame] | 351 | // Use ratio^2 to get a lower score the more we get further from peak |
| 352 | return ratio * ratio; |
| 353 | } |
| 354 | |
Dominik Laskowski | d82e0f0 | 2022-10-26 15:23:04 -0400 | [diff] [blame] | 355 | float RefreshRateSelector::calculateLayerScoreLocked(const LayerRequirement& layer, Fps refreshRate, |
| 356 | bool isSeamlessSwitch) const { |
Ady Abraham | 73c3df5 | 2023-01-12 18:09:31 -0800 | [diff] [blame^] | 357 | ATRACE_CALL(); |
Ady Abraham | 05243be | 2021-09-16 15:58:52 -0700 | [diff] [blame] | 358 | // Slightly prefer seamless switches. |
| 359 | constexpr float kSeamedSwitchPenalty = 0.95f; |
| 360 | const float seamlessness = isSeamlessSwitch ? 1.0f : kSeamedSwitchPenalty; |
| 361 | |
| 362 | // If the layer wants Max, give higher score to the higher refresh rate |
| 363 | if (layer.vote == LayerVoteType::Max) { |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 364 | return calculateDistanceScoreFromMax(refreshRate); |
Ady Abraham | 62a0be2 | 2020-12-08 16:54:10 -0800 | [diff] [blame] | 365 | } |
| 366 | |
Ady Abraham | dd5bfa9 | 2021-01-07 17:56:08 -0800 | [diff] [blame] | 367 | if (layer.vote == LayerVoteType::ExplicitExact) { |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 368 | const int divisor = getFrameRateDivisor(refreshRate, layer.desiredRefreshRate); |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 369 | if (supportsAppFrameRateOverrideByContent()) { |
Ady Abraham | dd5bfa9 | 2021-01-07 17:56:08 -0800 | [diff] [blame] | 370 | // Since we support frame rate override, allow refresh rates which are |
| 371 | // multiples of the layer's request, as those apps would be throttled |
| 372 | // down to run at the desired refresh rate. |
Ady Abraham | cc31549 | 2022-02-17 17:06:39 -0800 | [diff] [blame] | 373 | return divisor > 0; |
Ady Abraham | dd5bfa9 | 2021-01-07 17:56:08 -0800 | [diff] [blame] | 374 | } |
| 375 | |
Ady Abraham | cc31549 | 2022-02-17 17:06:39 -0800 | [diff] [blame] | 376 | return divisor == 1; |
Ady Abraham | dd5bfa9 | 2021-01-07 17:56:08 -0800 | [diff] [blame] | 377 | } |
| 378 | |
Ady Abraham | cc31549 | 2022-02-17 17:06:39 -0800 | [diff] [blame] | 379 | // If the layer frame rate is a divisor of the refresh rate it should score |
Ady Abraham | 05243be | 2021-09-16 15:58:52 -0700 | [diff] [blame] | 380 | // the highest score. |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 381 | if (getFrameRateDivisor(refreshRate, layer.desiredRefreshRate) > 0) { |
Ady Abraham | 05243be | 2021-09-16 15:58:52 -0700 | [diff] [blame] | 382 | return 1.0f * seamlessness; |
| 383 | } |
| 384 | |
Ady Abraham | cc31549 | 2022-02-17 17:06:39 -0800 | [diff] [blame] | 385 | // The layer frame rate is not a divisor of the refresh rate, |
Ady Abraham | 05243be | 2021-09-16 15:58:52 -0700 | [diff] [blame] | 386 | // there is a small penalty attached to the score to favor the frame rates |
| 387 | // the exactly matches the display refresh rate or a multiple. |
Ady Abraham | 1c59550 | 2022-01-13 21:58:32 -0800 | [diff] [blame] | 388 | constexpr float kNonExactMatchingPenalty = 0.95f; |
Ady Abraham | 05243be | 2021-09-16 15:58:52 -0700 | [diff] [blame] | 389 | return calculateNonExactMatchingLayerScoreLocked(layer, refreshRate) * seamlessness * |
| 390 | kNonExactMatchingPenalty; |
Ady Abraham | 62a0be2 | 2020-12-08 16:54:10 -0800 | [diff] [blame] | 391 | } |
| 392 | |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 393 | auto RefreshRateSelector::getRankedFrameRates(const std::vector<LayerRequirement>& layers, |
| 394 | GlobalSignals signals) const -> RankedFrameRates { |
Marin Shalamanov | 4c7831e | 2021-06-08 20:44:06 +0200 | [diff] [blame] | 395 | std::lock_guard lock(mLock); |
| 396 | |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 397 | if (mGetRankedFrameRatesCache && |
| 398 | mGetRankedFrameRatesCache->arguments == std::make_pair(layers, signals)) { |
| 399 | return mGetRankedFrameRatesCache->result; |
Marin Shalamanov | 4c7831e | 2021-06-08 20:44:06 +0200 | [diff] [blame] | 400 | } |
| 401 | |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 402 | const auto result = getRankedFrameRatesLocked(layers, signals); |
| 403 | mGetRankedFrameRatesCache = GetRankedFrameRatesCache{{layers, signals}, result}; |
Marin Shalamanov | 4c7831e | 2021-06-08 20:44:06 +0200 | [diff] [blame] | 404 | return result; |
| 405 | } |
| 406 | |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 407 | auto RefreshRateSelector::getRankedFrameRatesLocked(const std::vector<LayerRequirement>& layers, |
| 408 | GlobalSignals signals) const |
| 409 | -> RankedFrameRates { |
Ady Abraham | ae2e3c7 | 2022-08-13 05:12:13 +0000 | [diff] [blame] | 410 | using namespace fps_approx_ops; |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 411 | ATRACE_CALL(); |
Dominik Laskowski | a8626ec | 2021-12-15 18:13:30 -0800 | [diff] [blame] | 412 | ALOGV("%s: %zu layers", __func__, layers.size()); |
Ady Abraham | dfd6216 | 2020-06-10 16:11:56 -0700 | [diff] [blame] | 413 | |
Ady Abraham | ace3d05 | 2022-11-17 16:25:05 -0800 | [diff] [blame] | 414 | const auto& activeMode = *getActiveModeLocked().modePtr; |
ramindani | 38c8498 | 2022-08-29 18:02:57 +0000 | [diff] [blame] | 415 | |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 416 | // Keep the display at max frame rate for the duration of powering on the display. |
ramindani | 38c8498 | 2022-08-29 18:02:57 +0000 | [diff] [blame] | 417 | if (signals.powerOnImminent) { |
| 418 | ALOGV("Power On Imminent"); |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 419 | return {rankFrameRates(activeMode.getGroup(), RefreshRateOrder::Descending), |
ramindani | d72ba16 | 2022-09-09 21:33:40 +0000 | [diff] [blame] | 420 | GlobalSignals{.powerOnImminent = true}}; |
ramindani | 38c8498 | 2022-08-29 18:02:57 +0000 | [diff] [blame] | 421 | } |
| 422 | |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 423 | int noVoteLayers = 0; |
| 424 | int minVoteLayers = 0; |
| 425 | int maxVoteLayers = 0; |
Ady Abraham | 71c437d | 2020-01-31 15:56:57 -0800 | [diff] [blame] | 426 | int explicitDefaultVoteLayers = 0; |
| 427 | int explicitExactOrMultipleVoteLayers = 0; |
Ady Abraham | dd5bfa9 | 2021-01-07 17:56:08 -0800 | [diff] [blame] | 428 | int explicitExact = 0; |
Marin Shalamanov | ae0b535 | 2021-03-24 12:56:08 +0100 | [diff] [blame] | 429 | int seamedFocusedLayers = 0; |
Dominik Laskowski | a8626ec | 2021-12-15 18:13:30 -0800 | [diff] [blame] | 430 | |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 431 | for (const auto& layer : layers) { |
Ady Abraham | dd5bfa9 | 2021-01-07 17:56:08 -0800 | [diff] [blame] | 432 | switch (layer.vote) { |
| 433 | case LayerVoteType::NoVote: |
| 434 | noVoteLayers++; |
| 435 | break; |
| 436 | case LayerVoteType::Min: |
| 437 | minVoteLayers++; |
| 438 | break; |
| 439 | case LayerVoteType::Max: |
| 440 | maxVoteLayers++; |
| 441 | break; |
| 442 | case LayerVoteType::ExplicitDefault: |
| 443 | explicitDefaultVoteLayers++; |
Ady Abraham | dd5bfa9 | 2021-01-07 17:56:08 -0800 | [diff] [blame] | 444 | break; |
| 445 | case LayerVoteType::ExplicitExactOrMultiple: |
| 446 | explicitExactOrMultipleVoteLayers++; |
Ady Abraham | dd5bfa9 | 2021-01-07 17:56:08 -0800 | [diff] [blame] | 447 | break; |
| 448 | case LayerVoteType::ExplicitExact: |
| 449 | explicitExact++; |
Ady Abraham | dd5bfa9 | 2021-01-07 17:56:08 -0800 | [diff] [blame] | 450 | break; |
| 451 | case LayerVoteType::Heuristic: |
| 452 | break; |
Ady Abraham | 6fb599b | 2020-03-05 13:48:22 -0800 | [diff] [blame] | 453 | } |
Marin Shalamanov | 4608442 | 2020-10-13 12:33:42 +0200 | [diff] [blame] | 454 | |
Marin Shalamanov | ae0b535 | 2021-03-24 12:56:08 +0100 | [diff] [blame] | 455 | if (layer.seamlessness == Seamlessness::SeamedAndSeamless && layer.focused) { |
| 456 | seamedFocusedLayers++; |
Marin Shalamanov | 4608442 | 2020-10-13 12:33:42 +0200 | [diff] [blame] | 457 | } |
Ady Abraham | 6fb599b | 2020-03-05 13:48:22 -0800 | [diff] [blame] | 458 | } |
| 459 | |
Ady Abraham | dd5bfa9 | 2021-01-07 17:56:08 -0800 | [diff] [blame] | 460 | const bool hasExplicitVoteLayers = explicitDefaultVoteLayers > 0 || |
| 461 | explicitExactOrMultipleVoteLayers > 0 || explicitExact > 0; |
Alec Mouri | 11232a2 | 2020-05-14 18:06:25 -0700 | [diff] [blame] | 462 | |
Marin Shalamanov | 8cd8a99 | 2021-09-14 23:22:49 +0200 | [diff] [blame] | 463 | const Policy* policy = getCurrentPolicyLocked(); |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 464 | const auto& defaultMode = mDisplayModes.get(policy->defaultMode)->get(); |
Dominik Laskowski | f8734e0 | 2022-08-26 09:06:59 -0700 | [diff] [blame] | 465 | |
Marin Shalamanov | 8cd8a99 | 2021-09-14 23:22:49 +0200 | [diff] [blame] | 466 | // If the default mode group is different from the group of current mode, |
| 467 | // this means a layer requesting a seamed mode switch just disappeared and |
| 468 | // we should switch back to the default group. |
| 469 | // However if a seamed layer is still present we anchor around the group |
| 470 | // of the current mode, in order to prevent unnecessary seamed mode switches |
| 471 | // (e.g. when pausing a video playback). |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 472 | const auto anchorGroup = |
Dominik Laskowski | f8734e0 | 2022-08-26 09:06:59 -0700 | [diff] [blame] | 473 | seamedFocusedLayers > 0 ? activeMode.getGroup() : defaultMode->getGroup(); |
Marin Shalamanov | 8cd8a99 | 2021-09-14 23:22:49 +0200 | [diff] [blame] | 474 | |
Steven Thomas | f734df4 | 2020-04-13 21:09:28 -0700 | [diff] [blame] | 475 | // Consider the touch event if there are no Explicit* layers. Otherwise wait until after we've |
| 476 | // selected a refresh rate to see if we should apply touch boost. |
Dominik Laskowski | a8626ec | 2021-12-15 18:13:30 -0800 | [diff] [blame] | 477 | if (signals.touch && !hasExplicitVoteLayers) { |
ramindani | d72ba16 | 2022-09-09 21:33:40 +0000 | [diff] [blame] | 478 | ALOGV("Touch Boost"); |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 479 | return {rankFrameRates(anchorGroup, RefreshRateOrder::Descending), |
ramindani | d72ba16 | 2022-09-09 21:33:40 +0000 | [diff] [blame] | 480 | GlobalSignals{.touch = true}}; |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 481 | } |
| 482 | |
Alec Mouri | 11232a2 | 2020-05-14 18:06:25 -0700 | [diff] [blame] | 483 | // If the primary range consists of a single refresh rate then we can only |
| 484 | // move out the of range if layers explicitly request a different refresh |
| 485 | // rate. |
Marin Shalamanov | e8a663d | 2020-11-24 17:48:00 +0100 | [diff] [blame] | 486 | const bool primaryRangeIsSingleRate = |
Ady Abraham | 285f8c1 | 2022-10-11 17:12:14 -0700 | [diff] [blame] | 487 | isApproxEqual(policy->primaryRanges.physical.min, policy->primaryRanges.physical.max); |
Alec Mouri | 11232a2 | 2020-05-14 18:06:25 -0700 | [diff] [blame] | 488 | |
Dominik Laskowski | a8626ec | 2021-12-15 18:13:30 -0800 | [diff] [blame] | 489 | if (!signals.touch && signals.idle && !(primaryRangeIsSingleRate && hasExplicitVoteLayers)) { |
ramindani | d72ba16 | 2022-09-09 21:33:40 +0000 | [diff] [blame] | 490 | ALOGV("Idle"); |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 491 | return {rankFrameRates(activeMode.getGroup(), RefreshRateOrder::Ascending), |
ramindani | d72ba16 | 2022-09-09 21:33:40 +0000 | [diff] [blame] | 492 | GlobalSignals{.idle = true}}; |
Steven Thomas | bb37432 | 2020-04-28 22:47:16 -0700 | [diff] [blame] | 493 | } |
| 494 | |
Steven Thomas | debafed | 2020-05-18 17:30:35 -0700 | [diff] [blame] | 495 | if (layers.empty() || noVoteLayers == layers.size()) { |
ramindani | d72ba16 | 2022-09-09 21:33:40 +0000 | [diff] [blame] | 496 | ALOGV("No layers with votes"); |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 497 | return {rankFrameRates(anchorGroup, RefreshRateOrder::Descending), kNoSignals}; |
Steven Thomas | bb37432 | 2020-04-28 22:47:16 -0700 | [diff] [blame] | 498 | } |
| 499 | |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 500 | // Only if all layers want Min we should return Min |
| 501 | if (noVoteLayers + minVoteLayers == layers.size()) { |
ramindani | d72ba16 | 2022-09-09 21:33:40 +0000 | [diff] [blame] | 502 | ALOGV("All layers Min"); |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 503 | return {rankFrameRates(activeMode.getGroup(), RefreshRateOrder::Ascending), kNoSignals}; |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 504 | } |
| 505 | |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 506 | // Find the best refresh rate based on score |
Ady Abraham | 62a0be2 | 2020-12-08 16:54:10 -0800 | [diff] [blame] | 507 | std::vector<RefreshRateScore> scores; |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 508 | scores.reserve(mAppRequestFrameRates.size()); |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 509 | |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 510 | for (const FrameRateMode& it : mAppRequestFrameRates) { |
| 511 | scores.emplace_back(RefreshRateScore{it, 0.0f}); |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 512 | } |
| 513 | |
| 514 | for (const auto& layer : layers) { |
rnlee | 3bd61066 | 2021-06-23 16:27:57 -0700 | [diff] [blame] | 515 | ALOGV("Calculating score for %s (%s, weight %.2f, desired %.2f) ", layer.name.c_str(), |
Dominik Laskowski | f5d0ea5 | 2021-09-26 17:27:01 -0700 | [diff] [blame] | 516 | ftl::enum_string(layer.vote).c_str(), layer.weight, |
rnlee | 3bd61066 | 2021-06-23 16:27:57 -0700 | [diff] [blame] | 517 | layer.desiredRefreshRate.getValue()); |
Ady Abraham | 4ccdcb4 | 2020-02-11 17:34:34 -0800 | [diff] [blame] | 518 | if (layer.vote == LayerVoteType::NoVote || layer.vote == LayerVoteType::Min) { |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 519 | continue; |
| 520 | } |
| 521 | |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 522 | const auto weight = layer.weight; |
Ady Abraham | 71c437d | 2020-01-31 15:56:57 -0800 | [diff] [blame] | 523 | |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 524 | for (auto& [mode, overallScore, fixedRateBelowThresholdLayersScore] : scores) { |
| 525 | const auto& [fps, modePtr] = mode; |
| 526 | const bool isSeamlessSwitch = modePtr->getGroup() == activeMode.getGroup(); |
Marin Shalamanov | 4608442 | 2020-10-13 12:33:42 +0200 | [diff] [blame] | 527 | |
Marin Shalamanov | 53fc11d | 2020-11-20 14:00:13 +0100 | [diff] [blame] | 528 | if (layer.seamlessness == Seamlessness::OnlySeamless && !isSeamlessSwitch) { |
Marin Shalamanov | a7fe304 | 2021-01-29 21:02:08 +0100 | [diff] [blame] | 529 | ALOGV("%s ignores %s to avoid non-seamless switch. Current mode = %s", |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 530 | formatLayerInfo(layer, weight).c_str(), to_string(*modePtr).c_str(), |
Dominik Laskowski | f8734e0 | 2022-08-26 09:06:59 -0700 | [diff] [blame] | 531 | to_string(activeMode).c_str()); |
Marin Shalamanov | 4608442 | 2020-10-13 12:33:42 +0200 | [diff] [blame] | 532 | continue; |
| 533 | } |
| 534 | |
Marin Shalamanov | 53fc11d | 2020-11-20 14:00:13 +0100 | [diff] [blame] | 535 | if (layer.seamlessness == Seamlessness::SeamedAndSeamless && !isSeamlessSwitch && |
| 536 | !layer.focused) { |
| 537 | ALOGV("%s ignores %s because it's not focused and the switch is going to be seamed." |
Marin Shalamanov | a7fe304 | 2021-01-29 21:02:08 +0100 | [diff] [blame] | 538 | " Current mode = %s", |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 539 | formatLayerInfo(layer, weight).c_str(), to_string(*modePtr).c_str(), |
Dominik Laskowski | f8734e0 | 2022-08-26 09:06:59 -0700 | [diff] [blame] | 540 | to_string(activeMode).c_str()); |
Marin Shalamanov | 53fc11d | 2020-11-20 14:00:13 +0100 | [diff] [blame] | 541 | continue; |
| 542 | } |
| 543 | |
Marin Shalamanov | a7fe304 | 2021-01-29 21:02:08 +0100 | [diff] [blame] | 544 | // Layers with default seamlessness vote for the current mode group if |
Marin Shalamanov | 53fc11d | 2020-11-20 14:00:13 +0100 | [diff] [blame] | 545 | // there are layers with seamlessness=SeamedAndSeamless and for the default |
Marin Shalamanov | a7fe304 | 2021-01-29 21:02:08 +0100 | [diff] [blame] | 546 | // mode group otherwise. In second case, if the current mode group is different |
Marin Shalamanov | 53fc11d | 2020-11-20 14:00:13 +0100 | [diff] [blame] | 547 | // from the default, this means a layer with seamlessness=SeamedAndSeamless has just |
| 548 | // disappeared. |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 549 | const bool isInPolicyForDefault = modePtr->getGroup() == anchorGroup; |
Marin Shalamanov | ae0b535 | 2021-03-24 12:56:08 +0100 | [diff] [blame] | 550 | if (layer.seamlessness == Seamlessness::Default && !isInPolicyForDefault) { |
Marin Shalamanov | a7fe304 | 2021-01-29 21:02:08 +0100 | [diff] [blame] | 551 | ALOGV("%s ignores %s. Current mode = %s", formatLayerInfo(layer, weight).c_str(), |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 552 | to_string(*modePtr).c_str(), to_string(activeMode).c_str()); |
Marin Shalamanov | 4608442 | 2020-10-13 12:33:42 +0200 | [diff] [blame] | 553 | continue; |
| 554 | } |
| 555 | |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 556 | const bool inPrimaryRange = policy->primaryRanges.physical.includes(modePtr->getFps()); |
Alec Mouri | 11232a2 | 2020-05-14 18:06:25 -0700 | [diff] [blame] | 557 | if ((primaryRangeIsSingleRate || !inPrimaryRange) && |
Ady Abraham | dd5bfa9 | 2021-01-07 17:56:08 -0800 | [diff] [blame] | 558 | !(layer.focused && |
| 559 | (layer.vote == LayerVoteType::ExplicitDefault || |
| 560 | layer.vote == LayerVoteType::ExplicitExact))) { |
Ady Abraham | 20c029c | 2020-07-06 12:58:05 -0700 | [diff] [blame] | 561 | // Only focused layers with ExplicitDefault frame rate settings are allowed to score |
Ady Abraham | aae5ed5 | 2020-06-26 09:32:43 -0700 | [diff] [blame] | 562 | // refresh rates outside the primary range. |
Steven Thomas | f734df4 | 2020-04-13 21:09:28 -0700 | [diff] [blame] | 563 | continue; |
| 564 | } |
| 565 | |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 566 | const float layerScore = calculateLayerScoreLocked(layer, fps, isSeamlessSwitch); |
Ady Abraham | ae2e3c7 | 2022-08-13 05:12:13 +0000 | [diff] [blame] | 567 | const float weightedLayerScore = weight * layerScore; |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 568 | |
Ady Abraham | 13cfb36 | 2022-08-13 05:12:13 +0000 | [diff] [blame] | 569 | // Layer with fixed source has a special consideration which depends on the |
Ady Abraham | ae2e3c7 | 2022-08-13 05:12:13 +0000 | [diff] [blame] | 570 | // mConfig.frameRateMultipleThreshold. We don't want these layers to score |
| 571 | // refresh rates above the threshold, but we also don't want to favor the lower |
| 572 | // ones by having a greater number of layers scoring them. Instead, we calculate |
| 573 | // the score independently for these layers and later decide which |
| 574 | // refresh rates to add it. For example, desired 24 fps with 120 Hz threshold should not |
| 575 | // score 120 Hz, but desired 60 fps should contribute to the score. |
| 576 | const bool fixedSourceLayer = [](LayerVoteType vote) { |
| 577 | switch (vote) { |
| 578 | case LayerVoteType::ExplicitExactOrMultiple: |
| 579 | case LayerVoteType::Heuristic: |
| 580 | return true; |
| 581 | case LayerVoteType::NoVote: |
| 582 | case LayerVoteType::Min: |
| 583 | case LayerVoteType::Max: |
| 584 | case LayerVoteType::ExplicitDefault: |
| 585 | case LayerVoteType::ExplicitExact: |
| 586 | return false; |
| 587 | } |
| 588 | }(layer.vote); |
Ady Abraham | 62f51d9 | 2022-08-24 22:20:22 +0000 | [diff] [blame] | 589 | const bool layerBelowThreshold = mConfig.frameRateMultipleThreshold != 0 && |
Ady Abraham | ae2e3c7 | 2022-08-13 05:12:13 +0000 | [diff] [blame] | 590 | layer.desiredRefreshRate < |
| 591 | Fps::fromValue(mConfig.frameRateMultipleThreshold / 2); |
Ady Abraham | 62f51d9 | 2022-08-24 22:20:22 +0000 | [diff] [blame] | 592 | if (fixedSourceLayer && layerBelowThreshold) { |
Ady Abraham | 13cfb36 | 2022-08-13 05:12:13 +0000 | [diff] [blame] | 593 | const bool modeAboveThreshold = |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 594 | modePtr->getFps() >= Fps::fromValue(mConfig.frameRateMultipleThreshold); |
Ady Abraham | 62f51d9 | 2022-08-24 22:20:22 +0000 | [diff] [blame] | 595 | if (modeAboveThreshold) { |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 596 | ALOGV("%s gives %s (%s) fixed source (above threshold) score of %.4f", |
| 597 | formatLayerInfo(layer, weight).c_str(), to_string(fps).c_str(), |
| 598 | to_string(modePtr->getFps()).c_str(), layerScore); |
Ady Abraham | 62f51d9 | 2022-08-24 22:20:22 +0000 | [diff] [blame] | 599 | fixedRateBelowThresholdLayersScore.modeAboveThreshold += weightedLayerScore; |
Ady Abraham | ae2e3c7 | 2022-08-13 05:12:13 +0000 | [diff] [blame] | 600 | } else { |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 601 | ALOGV("%s gives %s (%s) fixed source (below threshold) score of %.4f", |
| 602 | formatLayerInfo(layer, weight).c_str(), to_string(fps).c_str(), |
| 603 | to_string(modePtr->getFps()).c_str(), layerScore); |
Ady Abraham | 62f51d9 | 2022-08-24 22:20:22 +0000 | [diff] [blame] | 604 | fixedRateBelowThresholdLayersScore.modeBelowThreshold += weightedLayerScore; |
Ady Abraham | ae2e3c7 | 2022-08-13 05:12:13 +0000 | [diff] [blame] | 605 | } |
| 606 | } else { |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 607 | ALOGV("%s gives %s (%s) score of %.4f", formatLayerInfo(layer, weight).c_str(), |
| 608 | to_string(fps).c_str(), to_string(modePtr->getFps()).c_str(), layerScore); |
Ady Abraham | ae2e3c7 | 2022-08-13 05:12:13 +0000 | [diff] [blame] | 609 | overallScore += weightedLayerScore; |
| 610 | } |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 611 | } |
| 612 | } |
| 613 | |
Ady Abraham | ae2e3c7 | 2022-08-13 05:12:13 +0000 | [diff] [blame] | 614 | // We want to find the best refresh rate without the fixed source layers, |
Ady Abraham | 62f51d9 | 2022-08-24 22:20:22 +0000 | [diff] [blame] | 615 | // so we could know whether we should add the modeAboveThreshold scores or not. |
Ady Abraham | ae2e3c7 | 2022-08-13 05:12:13 +0000 | [diff] [blame] | 616 | // If the best refresh rate is already above the threshold, it means that |
| 617 | // some non-fixed source layers already scored it, so we can just add the score |
| 618 | // for all fixed source layers, even the ones that are above the threshold. |
| 619 | const bool maxScoreAboveThreshold = [&] { |
| 620 | if (mConfig.frameRateMultipleThreshold == 0 || scores.empty()) { |
| 621 | return false; |
| 622 | } |
| 623 | |
| 624 | const auto maxScoreIt = |
| 625 | std::max_element(scores.begin(), scores.end(), |
| 626 | [](RefreshRateScore max, RefreshRateScore current) { |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 627 | return current.overallScore > max.overallScore; |
Ady Abraham | ae2e3c7 | 2022-08-13 05:12:13 +0000 | [diff] [blame] | 628 | }); |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 629 | ALOGV("%s (%s) is the best refresh rate without fixed source layers. It is %s the " |
| 630 | "threshold for " |
Ady Abraham | ae2e3c7 | 2022-08-13 05:12:13 +0000 | [diff] [blame] | 631 | "refresh rate multiples", |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 632 | to_string(maxScoreIt->frameRateMode.fps).c_str(), |
| 633 | to_string(maxScoreIt->frameRateMode.modePtr->getFps()).c_str(), |
Ady Abraham | ae2e3c7 | 2022-08-13 05:12:13 +0000 | [diff] [blame] | 634 | maxScoreAboveThreshold ? "above" : "below"); |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 635 | return maxScoreIt->frameRateMode.modePtr->getFps() >= |
Ady Abraham | ae2e3c7 | 2022-08-13 05:12:13 +0000 | [diff] [blame] | 636 | Fps::fromValue(mConfig.frameRateMultipleThreshold); |
| 637 | }(); |
| 638 | |
| 639 | // Now we can add the fixed rate layers score |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 640 | for (auto& [frameRateMode, overallScore, fixedRateBelowThresholdLayersScore] : scores) { |
Ady Abraham | 62f51d9 | 2022-08-24 22:20:22 +0000 | [diff] [blame] | 641 | overallScore += fixedRateBelowThresholdLayersScore.modeBelowThreshold; |
Ady Abraham | ae2e3c7 | 2022-08-13 05:12:13 +0000 | [diff] [blame] | 642 | if (maxScoreAboveThreshold) { |
Ady Abraham | 62f51d9 | 2022-08-24 22:20:22 +0000 | [diff] [blame] | 643 | overallScore += fixedRateBelowThresholdLayersScore.modeAboveThreshold; |
Ady Abraham | ae2e3c7 | 2022-08-13 05:12:13 +0000 | [diff] [blame] | 644 | } |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 645 | ALOGV("%s (%s) adjusted overallScore is %.4f", to_string(frameRateMode.fps).c_str(), |
| 646 | to_string(frameRateMode.modePtr->getFps()).c_str(), overallScore); |
Ady Abraham | ae2e3c7 | 2022-08-13 05:12:13 +0000 | [diff] [blame] | 647 | } |
| 648 | |
| 649 | // Now that we scored all the refresh rates we need to pick the one that got the highest |
ramindani | d72ba16 | 2022-09-09 21:33:40 +0000 | [diff] [blame] | 650 | // overallScore. Sort the scores based on their overallScore in descending order of priority. |
| 651 | const RefreshRateOrder refreshRateOrder = |
| 652 | maxVoteLayers > 0 ? RefreshRateOrder::Descending : RefreshRateOrder::Ascending; |
| 653 | std::sort(scores.begin(), scores.end(), |
| 654 | RefreshRateScoreComparator{.refreshRateOrder = refreshRateOrder}); |
ramindani | d72ba16 | 2022-09-09 21:33:40 +0000 | [diff] [blame] | 655 | |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 656 | FrameRateRanking ranking; |
Dominik Laskowski | 530d6bd | 2022-10-10 16:55:54 -0400 | [diff] [blame] | 657 | ranking.reserve(scores.size()); |
| 658 | |
| 659 | std::transform(scores.begin(), scores.end(), back_inserter(ranking), |
ramindani | d72ba16 | 2022-09-09 21:33:40 +0000 | [diff] [blame] | 660 | [](const RefreshRateScore& score) { |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 661 | return ScoredFrameRate{score.frameRateMode, score.overallScore}; |
ramindani | d72ba16 | 2022-09-09 21:33:40 +0000 | [diff] [blame] | 662 | }); |
Ady Abraham | 3470210 | 2020-02-10 14:12:05 -0800 | [diff] [blame] | 663 | |
Ady Abraham | 37d4692 | 2022-10-05 13:08:51 -0700 | [diff] [blame] | 664 | const bool noLayerScore = std::all_of(scores.begin(), scores.end(), [](RefreshRateScore score) { |
| 665 | return score.overallScore == 0; |
| 666 | }); |
| 667 | |
Alec Mouri | 11232a2 | 2020-05-14 18:06:25 -0700 | [diff] [blame] | 668 | if (primaryRangeIsSingleRate) { |
| 669 | // If we never scored any layers, then choose the rate from the primary |
| 670 | // range instead of picking a random score from the app range. |
Ady Abraham | 37d4692 | 2022-10-05 13:08:51 -0700 | [diff] [blame] | 671 | if (noLayerScore) { |
ramindani | d72ba16 | 2022-09-09 21:33:40 +0000 | [diff] [blame] | 672 | ALOGV("Layers not scored"); |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 673 | return {rankFrameRates(anchorGroup, RefreshRateOrder::Descending), kNoSignals}; |
Alec Mouri | 11232a2 | 2020-05-14 18:06:25 -0700 | [diff] [blame] | 674 | } else { |
Dominik Laskowski | 530d6bd | 2022-10-10 16:55:54 -0400 | [diff] [blame] | 675 | return {ranking, kNoSignals}; |
Alec Mouri | 11232a2 | 2020-05-14 18:06:25 -0700 | [diff] [blame] | 676 | } |
| 677 | } |
| 678 | |
Steven Thomas | f734df4 | 2020-04-13 21:09:28 -0700 | [diff] [blame] | 679 | // Consider the touch event if there are no ExplicitDefault layers. ExplicitDefault are mostly |
| 680 | // interactive (as opposed to ExplicitExactOrMultiple) and therefore if those posted an explicit |
| 681 | // vote we should not change it if we get a touch event. Only apply touch boost if it will |
| 682 | // actually increase the refresh rate over the normal selection. |
Ady Abraham | 5e4e983 | 2021-06-14 13:40:56 -0700 | [diff] [blame] | 683 | const bool touchBoostForExplicitExact = [&] { |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 684 | if (supportsAppFrameRateOverrideByContent()) { |
Ady Abraham | 5e4e983 | 2021-06-14 13:40:56 -0700 | [diff] [blame] | 685 | // Enable touch boost if there are other layers besides exact |
| 686 | return explicitExact + noVoteLayers != layers.size(); |
| 687 | } else { |
| 688 | // Enable touch boost if there are no exact layers |
| 689 | return explicitExact == 0; |
| 690 | } |
| 691 | }(); |
Dominik Laskowski | 6eab42d | 2021-09-13 14:34:13 -0700 | [diff] [blame] | 692 | |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 693 | const auto touchRefreshRates = rankFrameRates(anchorGroup, RefreshRateOrder::Descending); |
Dominik Laskowski | 6eab42d | 2021-09-13 14:34:13 -0700 | [diff] [blame] | 694 | using fps_approx_ops::operator<; |
| 695 | |
Dominik Laskowski | a8626ec | 2021-12-15 18:13:30 -0800 | [diff] [blame] | 696 | if (signals.touch && explicitDefaultVoteLayers == 0 && touchBoostForExplicitExact && |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 697 | scores.front().frameRateMode.fps < touchRefreshRates.front().frameRateMode.fps) { |
ramindani | d72ba16 | 2022-09-09 21:33:40 +0000 | [diff] [blame] | 698 | ALOGV("Touch Boost"); |
| 699 | return {touchRefreshRates, GlobalSignals{.touch = true}}; |
Steven Thomas | f734df4 | 2020-04-13 21:09:28 -0700 | [diff] [blame] | 700 | } |
| 701 | |
Ady Abraham | 37d4692 | 2022-10-05 13:08:51 -0700 | [diff] [blame] | 702 | // If we never scored any layers, and we don't favor high refresh rates, prefer to stay with the |
| 703 | // current config |
| 704 | if (noLayerScore && refreshRateOrder == RefreshRateOrder::Ascending) { |
| 705 | const auto preferredDisplayMode = activeMode.getId(); |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 706 | return {rankFrameRates(anchorGroup, RefreshRateOrder::Ascending, preferredDisplayMode), |
Ady Abraham | 37d4692 | 2022-10-05 13:08:51 -0700 | [diff] [blame] | 707 | kNoSignals}; |
| 708 | } |
| 709 | |
Dominik Laskowski | 530d6bd | 2022-10-10 16:55:54 -0400 | [diff] [blame] | 710 | return {ranking, kNoSignals}; |
Ady Abraham | 3470210 | 2020-02-10 14:12:05 -0800 | [diff] [blame] | 711 | } |
| 712 | |
Dominik Laskowski | d82e0f0 | 2022-10-26 15:23:04 -0400 | [diff] [blame] | 713 | using LayerRequirementPtrs = std::vector<const RefreshRateSelector::LayerRequirement*>; |
| 714 | using PerUidLayerRequirements = std::unordered_map<uid_t, LayerRequirementPtrs>; |
| 715 | |
| 716 | PerUidLayerRequirements groupLayersByUid( |
| 717 | const std::vector<RefreshRateSelector::LayerRequirement>& layers) { |
| 718 | PerUidLayerRequirements layersByUid; |
Ady Abraham | 62a0be2 | 2020-12-08 16:54:10 -0800 | [diff] [blame] | 719 | for (const auto& layer : layers) { |
Dominik Laskowski | d82e0f0 | 2022-10-26 15:23:04 -0400 | [diff] [blame] | 720 | const auto it = layersByUid.emplace(layer.ownerUid, LayerRequirementPtrs()).first; |
| 721 | auto& layersWithSameUid = it->second; |
Ady Abraham | 62a0be2 | 2020-12-08 16:54:10 -0800 | [diff] [blame] | 722 | layersWithSameUid.push_back(&layer); |
| 723 | } |
| 724 | |
| 725 | // Remove uids that can't have a frame rate override |
Dominik Laskowski | d82e0f0 | 2022-10-26 15:23:04 -0400 | [diff] [blame] | 726 | for (auto it = layersByUid.begin(); it != layersByUid.end();) { |
| 727 | const auto& layersWithSameUid = it->second; |
Ady Abraham | 62a0be2 | 2020-12-08 16:54:10 -0800 | [diff] [blame] | 728 | bool skipUid = false; |
| 729 | for (const auto& layer : layersWithSameUid) { |
Dominik Laskowski | d82e0f0 | 2022-10-26 15:23:04 -0400 | [diff] [blame] | 730 | using LayerVoteType = RefreshRateSelector::LayerVoteType; |
| 731 | |
| 732 | if (layer->vote == LayerVoteType::Max || layer->vote == LayerVoteType::Heuristic) { |
Ady Abraham | 62a0be2 | 2020-12-08 16:54:10 -0800 | [diff] [blame] | 733 | skipUid = true; |
| 734 | break; |
| 735 | } |
| 736 | } |
| 737 | if (skipUid) { |
Dominik Laskowski | d82e0f0 | 2022-10-26 15:23:04 -0400 | [diff] [blame] | 738 | it = layersByUid.erase(it); |
Ady Abraham | 62a0be2 | 2020-12-08 16:54:10 -0800 | [diff] [blame] | 739 | } else { |
Dominik Laskowski | d82e0f0 | 2022-10-26 15:23:04 -0400 | [diff] [blame] | 740 | ++it; |
Ady Abraham | 62a0be2 | 2020-12-08 16:54:10 -0800 | [diff] [blame] | 741 | } |
| 742 | } |
| 743 | |
| 744 | return layersByUid; |
| 745 | } |
| 746 | |
Dominik Laskowski | d82e0f0 | 2022-10-26 15:23:04 -0400 | [diff] [blame] | 747 | auto RefreshRateSelector::getFrameRateOverrides(const std::vector<LayerRequirement>& layers, |
| 748 | Fps displayRefreshRate, |
| 749 | GlobalSignals globalSignals) const |
| 750 | -> UidToFrameRateOverride { |
Ady Abraham | 62a0be2 | 2020-12-08 16:54:10 -0800 | [diff] [blame] | 751 | ATRACE_CALL(); |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 752 | if (mConfig.enableFrameRateOverride == Config::FrameRateOverride::Disabled) { |
| 753 | return {}; |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 754 | } |
| 755 | |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 756 | ALOGV("%s: %zu layers", __func__, layers.size()); |
| 757 | std::lock_guard lock(mLock); |
| 758 | |
Ady Abraham | 8ca643a | 2022-10-18 18:26:47 -0700 | [diff] [blame] | 759 | const auto* policyPtr = getCurrentPolicyLocked(); |
| 760 | // We don't want to run lower than 30fps |
| 761 | const Fps minFrameRate = std::max(policyPtr->appRequestRanges.render.min, 30_Hz, isApproxLess); |
| 762 | |
| 763 | using fps_approx_ops::operator/; |
| 764 | const unsigned numMultiples = displayRefreshRate / minFrameRate; |
| 765 | |
| 766 | std::vector<std::pair<Fps, float>> scoredFrameRates; |
| 767 | scoredFrameRates.reserve(numMultiples); |
| 768 | |
| 769 | for (unsigned n = numMultiples; n > 0; n--) { |
| 770 | const Fps divisor = displayRefreshRate / n; |
| 771 | if (mConfig.enableFrameRateOverride == |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 772 | Config::FrameRateOverride::AppOverrideNativeRefreshRates && |
| 773 | !isNativeRefreshRate(divisor)) { |
Ady Abraham | 8ca643a | 2022-10-18 18:26:47 -0700 | [diff] [blame] | 774 | continue; |
| 775 | } |
| 776 | |
| 777 | if (policyPtr->appRequestRanges.render.includes(divisor)) { |
| 778 | ALOGV("%s: adding %s as a potential frame rate", __func__, to_string(divisor).c_str()); |
| 779 | scoredFrameRates.emplace_back(divisor, 0); |
| 780 | } |
| 781 | } |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 782 | |
Dominik Laskowski | d82e0f0 | 2022-10-26 15:23:04 -0400 | [diff] [blame] | 783 | const auto layersByUid = groupLayersByUid(layers); |
Ady Abraham | 62a0be2 | 2020-12-08 16:54:10 -0800 | [diff] [blame] | 784 | UidToFrameRateOverride frameRateOverrides; |
| 785 | for (const auto& [uid, layersWithSameUid] : layersByUid) { |
Ady Abraham | dd5bfa9 | 2021-01-07 17:56:08 -0800 | [diff] [blame] | 786 | // Layers with ExplicitExactOrMultiple expect touch boost |
| 787 | const bool hasExplicitExactOrMultiple = |
| 788 | std::any_of(layersWithSameUid.cbegin(), layersWithSameUid.cend(), |
| 789 | [](const auto& layer) { |
| 790 | return layer->vote == LayerVoteType::ExplicitExactOrMultiple; |
| 791 | }); |
| 792 | |
Dominik Laskowski | 6eab42d | 2021-09-13 14:34:13 -0700 | [diff] [blame] | 793 | if (globalSignals.touch && hasExplicitExactOrMultiple) { |
Ady Abraham | dd5bfa9 | 2021-01-07 17:56:08 -0800 | [diff] [blame] | 794 | continue; |
| 795 | } |
| 796 | |
Ady Abraham | 8ca643a | 2022-10-18 18:26:47 -0700 | [diff] [blame] | 797 | for (auto& [_, score] : scoredFrameRates) { |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 798 | score = 0; |
Ady Abraham | 62a0be2 | 2020-12-08 16:54:10 -0800 | [diff] [blame] | 799 | } |
| 800 | |
| 801 | for (const auto& layer : layersWithSameUid) { |
| 802 | if (layer->vote == LayerVoteType::NoVote || layer->vote == LayerVoteType::Min) { |
| 803 | continue; |
| 804 | } |
| 805 | |
| 806 | LOG_ALWAYS_FATAL_IF(layer->vote != LayerVoteType::ExplicitDefault && |
Ady Abraham | dd5bfa9 | 2021-01-07 17:56:08 -0800 | [diff] [blame] | 807 | layer->vote != LayerVoteType::ExplicitExactOrMultiple && |
| 808 | layer->vote != LayerVoteType::ExplicitExact); |
Ady Abraham | 8ca643a | 2022-10-18 18:26:47 -0700 | [diff] [blame] | 809 | for (auto& [fps, score] : scoredFrameRates) { |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 810 | constexpr bool isSeamlessSwitch = true; |
Ady Abraham | 8ca643a | 2022-10-18 18:26:47 -0700 | [diff] [blame] | 811 | const auto layerScore = calculateLayerScoreLocked(*layer, fps, isSeamlessSwitch); |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 812 | score += layer->weight * layerScore; |
Ady Abraham | 62a0be2 | 2020-12-08 16:54:10 -0800 | [diff] [blame] | 813 | } |
| 814 | } |
| 815 | |
Ady Abraham | 62a0be2 | 2020-12-08 16:54:10 -0800 | [diff] [blame] | 816 | // If we never scored any layers, we don't have a preferred frame rate |
Ady Abraham | 8ca643a | 2022-10-18 18:26:47 -0700 | [diff] [blame] | 817 | if (std::all_of(scoredFrameRates.begin(), scoredFrameRates.end(), |
| 818 | [](const auto& scoredFrameRate) { |
| 819 | const auto [_, score] = scoredFrameRate; |
| 820 | return score == 0; |
| 821 | })) { |
Ady Abraham | 62a0be2 | 2020-12-08 16:54:10 -0800 | [diff] [blame] | 822 | continue; |
| 823 | } |
| 824 | |
ramindani | d72ba16 | 2022-09-09 21:33:40 +0000 | [diff] [blame] | 825 | // Now that we scored all the refresh rates we need to pick the lowest refresh rate |
| 826 | // that got the highest score. |
Ady Abraham | 8ca643a | 2022-10-18 18:26:47 -0700 | [diff] [blame] | 827 | const auto [overrideFps, _] = |
| 828 | *std::max_element(scoredFrameRates.begin(), scoredFrameRates.end(), |
| 829 | [](const auto& lhsPair, const auto& rhsPair) { |
| 830 | const float lhs = lhsPair.second; |
| 831 | const float rhs = rhsPair.second; |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 832 | return lhs < rhs && !ScoredFrameRate::scoresEqual(lhs, rhs); |
Ady Abraham | 8ca643a | 2022-10-18 18:26:47 -0700 | [diff] [blame] | 833 | }); |
| 834 | ALOGV("%s: overriding to %s for uid=%d", __func__, to_string(overrideFps).c_str(), uid); |
| 835 | frameRateOverrides.emplace(uid, overrideFps); |
Ady Abraham | 62a0be2 | 2020-12-08 16:54:10 -0800 | [diff] [blame] | 836 | } |
| 837 | |
| 838 | return frameRateOverrides; |
| 839 | } |
| 840 | |
Ady Abraham | 0aa373a | 2022-11-22 13:56:50 -0800 | [diff] [blame] | 841 | ftl::Optional<FrameRateMode> RefreshRateSelector::onKernelTimerChanged( |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 842 | std::optional<DisplayModeId> desiredActiveModeId, bool timerExpired) const { |
Ady Abraham | 2139f73 | 2019-11-13 18:56:40 -0800 | [diff] [blame] | 843 | std::lock_guard lock(mLock); |
Marin Shalamanov | eadf2e7 | 2020-12-10 15:35:28 +0100 | [diff] [blame] | 844 | |
Ady Abraham | 0aa373a | 2022-11-22 13:56:50 -0800 | [diff] [blame] | 845 | const auto current = [&]() REQUIRES(mLock) -> FrameRateMode { |
| 846 | if (desiredActiveModeId) { |
| 847 | const auto& modePtr = mDisplayModes.get(*desiredActiveModeId)->get(); |
| 848 | return FrameRateMode{modePtr->getFps(), ftl::as_non_null(modePtr)}; |
| 849 | } |
| 850 | |
| 851 | return getActiveModeLocked(); |
| 852 | }(); |
Marin Shalamanov | eadf2e7 | 2020-12-10 15:35:28 +0100 | [diff] [blame] | 853 | |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 854 | const DisplayModePtr& min = mMinRefreshRateModeIt->second; |
Ady Abraham | 0aa373a | 2022-11-22 13:56:50 -0800 | [diff] [blame] | 855 | if (current.modePtr->getId() == min->getId()) { |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 856 | return {}; |
Marin Shalamanov | eadf2e7 | 2020-12-10 15:35:28 +0100 | [diff] [blame] | 857 | } |
| 858 | |
Ady Abraham | 0aa373a | 2022-11-22 13:56:50 -0800 | [diff] [blame] | 859 | return timerExpired ? FrameRateMode{min->getFps(), ftl::as_non_null(min)} : current; |
Steven Thomas | f734df4 | 2020-04-13 21:09:28 -0700 | [diff] [blame] | 860 | } |
| 861 | |
Dominik Laskowski | d82e0f0 | 2022-10-26 15:23:04 -0400 | [diff] [blame] | 862 | const DisplayModePtr& RefreshRateSelector::getMinRefreshRateByPolicyLocked() const { |
Ady Abraham | ace3d05 | 2022-11-17 16:25:05 -0800 | [diff] [blame] | 863 | const auto& activeMode = *getActiveModeLocked().modePtr; |
Dominik Laskowski | f8734e0 | 2022-08-26 09:06:59 -0700 | [diff] [blame] | 864 | |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 865 | for (const FrameRateMode& mode : mPrimaryFrameRates) { |
| 866 | if (activeMode.getGroup() == mode.modePtr->getGroup()) { |
Ady Abraham | ace3d05 | 2022-11-17 16:25:05 -0800 | [diff] [blame] | 867 | return mode.modePtr.get(); |
Marin Shalamanov | 4608442 | 2020-10-13 12:33:42 +0200 | [diff] [blame] | 868 | } |
| 869 | } |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 870 | |
Dominik Laskowski | f8734e0 | 2022-08-26 09:06:59 -0700 | [diff] [blame] | 871 | ALOGE("Can't find min refresh rate by policy with the same mode group as the current mode %s", |
| 872 | to_string(activeMode).c_str()); |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 873 | |
| 874 | // Default to the lowest refresh rate. |
Ady Abraham | ace3d05 | 2022-11-17 16:25:05 -0800 | [diff] [blame] | 875 | return mPrimaryFrameRates.front().modePtr.get(); |
Ady Abraham | 2139f73 | 2019-11-13 18:56:40 -0800 | [diff] [blame] | 876 | } |
| 877 | |
Dominik Laskowski | d82e0f0 | 2022-10-26 15:23:04 -0400 | [diff] [blame] | 878 | const DisplayModePtr& RefreshRateSelector::getMaxRefreshRateByPolicyLocked(int anchorGroup) const { |
Ady Abraham | ace3d05 | 2022-11-17 16:25:05 -0800 | [diff] [blame] | 879 | const ftl::NonNull<DisplayModePtr>* maxByAnchor = &mPrimaryFrameRates.back().modePtr; |
| 880 | const ftl::NonNull<DisplayModePtr>* max = &mPrimaryFrameRates.back().modePtr; |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 881 | |
| 882 | bool maxByAnchorFound = false; |
| 883 | for (auto it = mPrimaryFrameRates.rbegin(); it != mPrimaryFrameRates.rend(); ++it) { |
| 884 | using namespace fps_approx_ops; |
| 885 | if (it->modePtr->getFps() > (*max)->getFps()) { |
| 886 | max = &it->modePtr; |
Marin Shalamanov | 4608442 | 2020-10-13 12:33:42 +0200 | [diff] [blame] | 887 | } |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 888 | |
| 889 | if (anchorGroup == it->modePtr->getGroup() && |
| 890 | it->modePtr->getFps() >= (*maxByAnchor)->getFps()) { |
| 891 | maxByAnchorFound = true; |
| 892 | maxByAnchor = &it->modePtr; |
| 893 | } |
| 894 | } |
| 895 | |
| 896 | if (maxByAnchorFound) { |
Ady Abraham | ace3d05 | 2022-11-17 16:25:05 -0800 | [diff] [blame] | 897 | return maxByAnchor->get(); |
Marin Shalamanov | 4608442 | 2020-10-13 12:33:42 +0200 | [diff] [blame] | 898 | } |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 899 | |
ramindani | d72ba16 | 2022-09-09 21:33:40 +0000 | [diff] [blame] | 900 | ALOGE("Can't find max refresh rate by policy with the same group %d", anchorGroup); |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 901 | |
| 902 | // Default to the highest refresh rate. |
Ady Abraham | ace3d05 | 2022-11-17 16:25:05 -0800 | [diff] [blame] | 903 | return max->get(); |
Ady Abraham | 2139f73 | 2019-11-13 18:56:40 -0800 | [diff] [blame] | 904 | } |
| 905 | |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 906 | auto RefreshRateSelector::rankFrameRates(std::optional<int> anchorGroupOpt, |
| 907 | RefreshRateOrder refreshRateOrder, |
| 908 | std::optional<DisplayModeId> preferredDisplayModeOpt) const |
| 909 | -> FrameRateRanking { |
| 910 | const char* const whence = __func__; |
| 911 | std::deque<ScoredFrameRate> ranking; |
| 912 | const auto rankFrameRate = [&](const FrameRateMode& frameRateMode) REQUIRES(mLock) { |
| 913 | const auto& modePtr = frameRateMode.modePtr; |
| 914 | if (anchorGroupOpt && modePtr->getGroup() != anchorGroupOpt) { |
Ady Abraham | 37d4692 | 2022-10-05 13:08:51 -0700 | [diff] [blame] | 915 | return; |
ramindani | d72ba16 | 2022-09-09 21:33:40 +0000 | [diff] [blame] | 916 | } |
Ady Abraham | 37d4692 | 2022-10-05 13:08:51 -0700 | [diff] [blame] | 917 | |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 918 | float score = calculateDistanceScoreFromMax(frameRateMode.fps); |
Ady Abraham | 37d4692 | 2022-10-05 13:08:51 -0700 | [diff] [blame] | 919 | const bool inverseScore = (refreshRateOrder == RefreshRateOrder::Ascending); |
| 920 | if (inverseScore) { |
| 921 | score = 1.0f / score; |
| 922 | } |
| 923 | if (preferredDisplayModeOpt) { |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 924 | if (*preferredDisplayModeOpt == modePtr->getId()) { |
Dominik Laskowski | 530d6bd | 2022-10-10 16:55:54 -0400 | [diff] [blame] | 925 | constexpr float kScore = std::numeric_limits<float>::max(); |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 926 | ranking.emplace_front(ScoredFrameRate{frameRateMode, kScore}); |
Ady Abraham | 37d4692 | 2022-10-05 13:08:51 -0700 | [diff] [blame] | 927 | return; |
| 928 | } |
| 929 | constexpr float kNonPreferredModePenalty = 0.95f; |
| 930 | score *= kNonPreferredModePenalty; |
| 931 | } |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 932 | ALOGV("%s(%s) %s (%s) scored %.2f", whence, ftl::enum_string(refreshRateOrder).c_str(), |
| 933 | to_string(frameRateMode.fps).c_str(), to_string(modePtr->getFps()).c_str(), score); |
| 934 | ranking.emplace_back(ScoredFrameRate{frameRateMode, score}); |
ramindani | d72ba16 | 2022-09-09 21:33:40 +0000 | [diff] [blame] | 935 | }; |
| 936 | |
| 937 | if (refreshRateOrder == RefreshRateOrder::Ascending) { |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 938 | std::for_each(mPrimaryFrameRates.begin(), mPrimaryFrameRates.end(), rankFrameRate); |
ramindani | d72ba16 | 2022-09-09 21:33:40 +0000 | [diff] [blame] | 939 | } else { |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 940 | std::for_each(mPrimaryFrameRates.rbegin(), mPrimaryFrameRates.rend(), rankFrameRate); |
ramindani | d72ba16 | 2022-09-09 21:33:40 +0000 | [diff] [blame] | 941 | } |
| 942 | |
Dominik Laskowski | 530d6bd | 2022-10-10 16:55:54 -0400 | [diff] [blame] | 943 | if (!ranking.empty() || !anchorGroupOpt) { |
| 944 | return {ranking.begin(), ranking.end()}; |
ramindani | d72ba16 | 2022-09-09 21:33:40 +0000 | [diff] [blame] | 945 | } |
| 946 | |
| 947 | ALOGW("Can't find %s refresh rate by policy with the same mode group" |
| 948 | " as the mode group %d", |
| 949 | refreshRateOrder == RefreshRateOrder::Ascending ? "min" : "max", anchorGroupOpt.value()); |
| 950 | |
Dominik Laskowski | 530d6bd | 2022-10-10 16:55:54 -0400 | [diff] [blame] | 951 | constexpr std::optional<int> kNoAnchorGroup = std::nullopt; |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 952 | return rankFrameRates(kNoAnchorGroup, refreshRateOrder, preferredDisplayModeOpt); |
ramindani | d72ba16 | 2022-09-09 21:33:40 +0000 | [diff] [blame] | 953 | } |
| 954 | |
Ady Abraham | ace3d05 | 2022-11-17 16:25:05 -0800 | [diff] [blame] | 955 | FrameRateMode RefreshRateSelector::getActiveMode() const { |
Ady Abraham | 2139f73 | 2019-11-13 18:56:40 -0800 | [diff] [blame] | 956 | std::lock_guard lock(mLock); |
Ady Abraham | ace3d05 | 2022-11-17 16:25:05 -0800 | [diff] [blame] | 957 | return getActiveModeLocked(); |
Dominik Laskowski | f8734e0 | 2022-08-26 09:06:59 -0700 | [diff] [blame] | 958 | } |
| 959 | |
Ady Abraham | ace3d05 | 2022-11-17 16:25:05 -0800 | [diff] [blame] | 960 | const FrameRateMode& RefreshRateSelector::getActiveModeLocked() const { |
| 961 | return *mActiveModeOpt; |
Dominik Laskowski | f8734e0 | 2022-08-26 09:06:59 -0700 | [diff] [blame] | 962 | } |
| 963 | |
Ady Abraham | ace3d05 | 2022-11-17 16:25:05 -0800 | [diff] [blame] | 964 | void RefreshRateSelector::setActiveMode(DisplayModeId modeId, Fps renderFrameRate) { |
Ady Abraham | 2139f73 | 2019-11-13 18:56:40 -0800 | [diff] [blame] | 965 | std::lock_guard lock(mLock); |
Marin Shalamanov | 4c7831e | 2021-06-08 20:44:06 +0200 | [diff] [blame] | 966 | |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 967 | // Invalidate the cached invocation to getRankedFrameRates. This forces |
| 968 | // the refresh rate to be recomputed on the next call to getRankedFrameRates. |
| 969 | mGetRankedFrameRatesCache.reset(); |
Marin Shalamanov | 4c7831e | 2021-06-08 20:44:06 +0200 | [diff] [blame] | 970 | |
Ady Abraham | ace3d05 | 2022-11-17 16:25:05 -0800 | [diff] [blame] | 971 | const auto activeModeOpt = mDisplayModes.get(modeId); |
| 972 | LOG_ALWAYS_FATAL_IF(!activeModeOpt); |
| 973 | |
| 974 | mActiveModeOpt.emplace(FrameRateMode{renderFrameRate, ftl::as_non_null(activeModeOpt->get())}); |
Ady Abraham | b4b1e0a | 2019-11-20 18:25:35 -0800 | [diff] [blame] | 975 | } |
| 976 | |
Dominik Laskowski | d82e0f0 | 2022-10-26 15:23:04 -0400 | [diff] [blame] | 977 | RefreshRateSelector::RefreshRateSelector(DisplayModes modes, DisplayModeId activeModeId, |
| 978 | Config config) |
rnlee | 3bd61066 | 2021-06-23 16:27:57 -0700 | [diff] [blame] | 979 | : mKnownFrameRates(constructKnownFrameRates(modes)), mConfig(config) { |
Ady Abraham | 9a2ea34 | 2021-09-03 17:32:34 -0700 | [diff] [blame] | 980 | initializeIdleTimer(); |
Dominik Laskowski | f8734e0 | 2022-08-26 09:06:59 -0700 | [diff] [blame] | 981 | FTL_FAKE_GUARD(kMainThreadContext, updateDisplayModes(std::move(modes), activeModeId)); |
Marin Shalamanov | eadf2e7 | 2020-12-10 15:35:28 +0100 | [diff] [blame] | 982 | } |
| 983 | |
Dominik Laskowski | d82e0f0 | 2022-10-26 15:23:04 -0400 | [diff] [blame] | 984 | void RefreshRateSelector::initializeIdleTimer() { |
ramindani | 32cf060 | 2022-03-02 02:30:29 +0000 | [diff] [blame] | 985 | if (mConfig.idleTimerTimeout > 0ms) { |
Ady Abraham | 9a2ea34 | 2021-09-03 17:32:34 -0700 | [diff] [blame] | 986 | mIdleTimer.emplace( |
ramindani | 32cf060 | 2022-03-02 02:30:29 +0000 | [diff] [blame] | 987 | "IdleTimer", mConfig.idleTimerTimeout, |
Dominik Laskowski | 83bd771 | 2022-01-07 14:30:53 -0800 | [diff] [blame] | 988 | [this] { |
| 989 | std::scoped_lock lock(mIdleTimerCallbacksMutex); |
| 990 | if (const auto callbacks = getIdleTimerCallbacks()) { |
| 991 | callbacks->onReset(); |
| 992 | } |
Ady Abraham | 9a2ea34 | 2021-09-03 17:32:34 -0700 | [diff] [blame] | 993 | }, |
Dominik Laskowski | 83bd771 | 2022-01-07 14:30:53 -0800 | [diff] [blame] | 994 | [this] { |
| 995 | std::scoped_lock lock(mIdleTimerCallbacksMutex); |
| 996 | if (const auto callbacks = getIdleTimerCallbacks()) { |
| 997 | callbacks->onExpired(); |
| 998 | } |
Ady Abraham | 9a2ea34 | 2021-09-03 17:32:34 -0700 | [diff] [blame] | 999 | }); |
Ady Abraham | 9a2ea34 | 2021-09-03 17:32:34 -0700 | [diff] [blame] | 1000 | } |
| 1001 | } |
| 1002 | |
Dominik Laskowski | d82e0f0 | 2022-10-26 15:23:04 -0400 | [diff] [blame] | 1003 | void RefreshRateSelector::updateDisplayModes(DisplayModes modes, DisplayModeId activeModeId) { |
Marin Shalamanov | eadf2e7 | 2020-12-10 15:35:28 +0100 | [diff] [blame] | 1004 | std::lock_guard lock(mLock); |
Marin Shalamanov | 4c7831e | 2021-06-08 20:44:06 +0200 | [diff] [blame] | 1005 | |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 1006 | // Invalidate the cached invocation to getRankedFrameRates. This forces |
| 1007 | // the refresh rate to be recomputed on the next call to getRankedFrameRates. |
| 1008 | mGetRankedFrameRatesCache.reset(); |
Marin Shalamanov | 4c7831e | 2021-06-08 20:44:06 +0200 | [diff] [blame] | 1009 | |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 1010 | mDisplayModes = std::move(modes); |
Ady Abraham | ace3d05 | 2022-11-17 16:25:05 -0800 | [diff] [blame] | 1011 | const auto activeModeOpt = mDisplayModes.get(activeModeId); |
| 1012 | LOG_ALWAYS_FATAL_IF(!activeModeOpt); |
| 1013 | mActiveModeOpt = |
| 1014 | FrameRateMode{activeModeOpt->get()->getFps(), ftl::as_non_null(activeModeOpt->get())}; |
Ady Abraham | abc2760 | 2020-04-08 17:20:29 -0700 | [diff] [blame] | 1015 | |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 1016 | const auto sortedModes = sortByRefreshRate(mDisplayModes); |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 1017 | mMinRefreshRateModeIt = sortedModes.front(); |
| 1018 | mMaxRefreshRateModeIt = sortedModes.back(); |
| 1019 | |
Marin Shalamanov | 75f3725 | 2021-02-10 21:43:57 +0100 | [diff] [blame] | 1020 | // Reset the policy because the old one may no longer be valid. |
| 1021 | mDisplayManagerPolicy = {}; |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 1022 | mDisplayManagerPolicy.defaultMode = activeModeId; |
Ady Abraham | 64c2fc0 | 2020-12-29 12:07:50 -0800 | [diff] [blame] | 1023 | |
Ady Abraham | 8ca643a | 2022-10-18 18:26:47 -0700 | [diff] [blame] | 1024 | mFrameRateOverrideConfig = [&] { |
| 1025 | switch (mConfig.enableFrameRateOverride) { |
| 1026 | case Config::FrameRateOverride::Disabled: |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 1027 | case Config::FrameRateOverride::AppOverride: |
Ady Abraham | 8ca643a | 2022-10-18 18:26:47 -0700 | [diff] [blame] | 1028 | case Config::FrameRateOverride::Enabled: |
| 1029 | return mConfig.enableFrameRateOverride; |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 1030 | case Config::FrameRateOverride::AppOverrideNativeRefreshRates: |
Ady Abraham | 8ca643a | 2022-10-18 18:26:47 -0700 | [diff] [blame] | 1031 | return shouldEnableFrameRateOverride(sortedModes) |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 1032 | ? Config::FrameRateOverride::AppOverrideNativeRefreshRates |
Ady Abraham | 8ca643a | 2022-10-18 18:26:47 -0700 | [diff] [blame] | 1033 | : Config::FrameRateOverride::Disabled; |
| 1034 | } |
| 1035 | }(); |
Ady Abraham | 4899ff8 | 2021-01-06 13:53:29 -0800 | [diff] [blame] | 1036 | |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 1037 | if (mConfig.enableFrameRateOverride == |
| 1038 | Config::FrameRateOverride::AppOverrideNativeRefreshRates) { |
| 1039 | for (const auto& [_, mode] : mDisplayModes) { |
| 1040 | mAppOverrideNativeRefreshRates.try_emplace(mode->getFps(), ftl::unit); |
| 1041 | } |
| 1042 | } |
| 1043 | |
Ady Abraham | abc2760 | 2020-04-08 17:20:29 -0700 | [diff] [blame] | 1044 | constructAvailableRefreshRates(); |
Ady Abraham | b4b1e0a | 2019-11-20 18:25:35 -0800 | [diff] [blame] | 1045 | } |
| 1046 | |
Dominik Laskowski | d82e0f0 | 2022-10-26 15:23:04 -0400 | [diff] [blame] | 1047 | bool RefreshRateSelector::isPolicyValidLocked(const Policy& policy) const { |
Marin Shalamanov | a7fe304 | 2021-01-29 21:02:08 +0100 | [diff] [blame] | 1048 | // defaultMode must be a valid mode, and within the given refresh rate range. |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 1049 | if (const auto mode = mDisplayModes.get(policy.defaultMode)) { |
Ady Abraham | 285f8c1 | 2022-10-11 17:12:14 -0700 | [diff] [blame] | 1050 | if (!policy.primaryRanges.physical.includes(mode->get()->getFps())) { |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 1051 | ALOGE("Default mode is not in the primary range."); |
| 1052 | return false; |
| 1053 | } |
| 1054 | } else { |
Marin Shalamanov | a7fe304 | 2021-01-29 21:02:08 +0100 | [diff] [blame] | 1055 | ALOGE("Default mode is not found."); |
Steven Thomas | d407190 | 2020-03-24 16:02:53 -0700 | [diff] [blame] | 1056 | return false; |
| 1057 | } |
Dominik Laskowski | 6eab42d | 2021-09-13 14:34:13 -0700 | [diff] [blame] | 1058 | |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 1059 | const auto& primaryRanges = policy.primaryRanges; |
| 1060 | const auto& appRequestRanges = policy.appRequestRanges; |
| 1061 | ALOGE_IF(!appRequestRanges.physical.includes(primaryRanges.physical), |
Ady Abraham | 08048ce | 2022-11-30 18:08:00 -0800 | [diff] [blame] | 1062 | "Physical range is invalid: primary: %s appRequest: %s", |
| 1063 | to_string(primaryRanges.physical).c_str(), |
| 1064 | to_string(appRequestRanges.physical).c_str()); |
| 1065 | ALOGE_IF(!appRequestRanges.render.includes(primaryRanges.render), |
| 1066 | "Render range is invalid: primary: %s appRequest: %s", |
| 1067 | to_string(primaryRanges.render).c_str(), to_string(appRequestRanges.render).c_str()); |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 1068 | |
| 1069 | return primaryRanges.valid() && appRequestRanges.valid(); |
Steven Thomas | d407190 | 2020-03-24 16:02:53 -0700 | [diff] [blame] | 1070 | } |
| 1071 | |
Dominik Laskowski | d82e0f0 | 2022-10-26 15:23:04 -0400 | [diff] [blame] | 1072 | auto RefreshRateSelector::setPolicy(const PolicyVariant& policy) -> SetPolicyResult { |
Dominik Laskowski | 36dced8 | 2022-09-02 09:24:00 -0700 | [diff] [blame] | 1073 | Policy oldPolicy; |
Ady Abraham | ace3d05 | 2022-11-17 16:25:05 -0800 | [diff] [blame] | 1074 | PhysicalDisplayId displayId; |
Dominik Laskowski | 36dced8 | 2022-09-02 09:24:00 -0700 | [diff] [blame] | 1075 | { |
| 1076 | std::lock_guard lock(mLock); |
| 1077 | oldPolicy = *getCurrentPolicyLocked(); |
Ana Krulec | ed3a8cc | 2019-11-14 00:55:07 +0100 | [diff] [blame] | 1078 | |
Dominik Laskowski | 36dced8 | 2022-09-02 09:24:00 -0700 | [diff] [blame] | 1079 | const bool valid = ftl::match( |
| 1080 | policy, |
| 1081 | [this](const auto& policy) { |
| 1082 | ftl::FakeGuard guard(mLock); |
| 1083 | if (!isPolicyValidLocked(policy)) { |
| 1084 | ALOGE("Invalid policy: %s", policy.toString().c_str()); |
| 1085 | return false; |
| 1086 | } |
| 1087 | |
| 1088 | using T = std::decay_t<decltype(policy)>; |
| 1089 | |
| 1090 | if constexpr (std::is_same_v<T, DisplayManagerPolicy>) { |
| 1091 | mDisplayManagerPolicy = policy; |
| 1092 | } else { |
| 1093 | static_assert(std::is_same_v<T, OverridePolicy>); |
| 1094 | mOverridePolicy = policy; |
| 1095 | } |
| 1096 | return true; |
| 1097 | }, |
| 1098 | [this](NoOverridePolicy) { |
| 1099 | ftl::FakeGuard guard(mLock); |
| 1100 | mOverridePolicy.reset(); |
| 1101 | return true; |
| 1102 | }); |
| 1103 | |
| 1104 | if (!valid) { |
| 1105 | return SetPolicyResult::Invalid; |
| 1106 | } |
| 1107 | |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 1108 | mGetRankedFrameRatesCache.reset(); |
Dominik Laskowski | 36dced8 | 2022-09-02 09:24:00 -0700 | [diff] [blame] | 1109 | |
| 1110 | if (*getCurrentPolicyLocked() == oldPolicy) { |
| 1111 | return SetPolicyResult::Unchanged; |
| 1112 | } |
| 1113 | constructAvailableRefreshRates(); |
Ady Abraham | ace3d05 | 2022-11-17 16:25:05 -0800 | [diff] [blame] | 1114 | |
| 1115 | displayId = getActiveModeLocked().modePtr->getPhysicalDisplayId(); |
Steven Thomas | d407190 | 2020-03-24 16:02:53 -0700 | [diff] [blame] | 1116 | } |
Dominik Laskowski | 36dced8 | 2022-09-02 09:24:00 -0700 | [diff] [blame] | 1117 | |
Dominik Laskowski | 36dced8 | 2022-09-02 09:24:00 -0700 | [diff] [blame] | 1118 | const unsigned numModeChanges = std::exchange(mNumModeSwitchesInPolicy, 0u); |
| 1119 | |
| 1120 | ALOGI("Display %s policy changed\n" |
| 1121 | "Previous: %s\n" |
| 1122 | "Current: %s\n" |
| 1123 | "%u mode changes were performed under the previous policy", |
| 1124 | to_string(displayId).c_str(), oldPolicy.toString().c_str(), toString(policy).c_str(), |
| 1125 | numModeChanges); |
| 1126 | |
| 1127 | return SetPolicyResult::Changed; |
Steven Thomas | d407190 | 2020-03-24 16:02:53 -0700 | [diff] [blame] | 1128 | } |
| 1129 | |
Dominik Laskowski | d82e0f0 | 2022-10-26 15:23:04 -0400 | [diff] [blame] | 1130 | auto RefreshRateSelector::getCurrentPolicyLocked() const -> const Policy* { |
Steven Thomas | d407190 | 2020-03-24 16:02:53 -0700 | [diff] [blame] | 1131 | return mOverridePolicy ? &mOverridePolicy.value() : &mDisplayManagerPolicy; |
| 1132 | } |
| 1133 | |
Dominik Laskowski | d82e0f0 | 2022-10-26 15:23:04 -0400 | [diff] [blame] | 1134 | auto RefreshRateSelector::getCurrentPolicy() const -> Policy { |
Steven Thomas | d407190 | 2020-03-24 16:02:53 -0700 | [diff] [blame] | 1135 | std::lock_guard lock(mLock); |
| 1136 | return *getCurrentPolicyLocked(); |
| 1137 | } |
| 1138 | |
Dominik Laskowski | d82e0f0 | 2022-10-26 15:23:04 -0400 | [diff] [blame] | 1139 | auto RefreshRateSelector::getDisplayManagerPolicy() const -> Policy { |
Steven Thomas | d407190 | 2020-03-24 16:02:53 -0700 | [diff] [blame] | 1140 | std::lock_guard lock(mLock); |
| 1141 | return mDisplayManagerPolicy; |
Ana Krulec | ed3a8cc | 2019-11-14 00:55:07 +0100 | [diff] [blame] | 1142 | } |
| 1143 | |
Ady Abraham | ace3d05 | 2022-11-17 16:25:05 -0800 | [diff] [blame] | 1144 | bool RefreshRateSelector::isModeAllowed(const FrameRateMode& mode) const { |
Ana Krulec | ed3a8cc | 2019-11-14 00:55:07 +0100 | [diff] [blame] | 1145 | std::lock_guard lock(mLock); |
Ady Abraham | ace3d05 | 2022-11-17 16:25:05 -0800 | [diff] [blame] | 1146 | return std::find(mAppRequestFrameRates.begin(), mAppRequestFrameRates.end(), mode) != |
| 1147 | mAppRequestFrameRates.end(); |
Ady Abraham | 2139f73 | 2019-11-13 18:56:40 -0800 | [diff] [blame] | 1148 | } |
| 1149 | |
Dominik Laskowski | d82e0f0 | 2022-10-26 15:23:04 -0400 | [diff] [blame] | 1150 | void RefreshRateSelector::constructAvailableRefreshRates() { |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 1151 | // Filter modes based on current policy and sort on refresh rate. |
Steven Thomas | d407190 | 2020-03-24 16:02:53 -0700 | [diff] [blame] | 1152 | const Policy* policy = getCurrentPolicyLocked(); |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 1153 | ALOGV("%s: %s ", __func__, policy->toString().c_str()); |
Ady Abraham | abc2760 | 2020-04-08 17:20:29 -0700 | [diff] [blame] | 1154 | |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 1155 | const auto& defaultMode = mDisplayModes.get(policy->defaultMode)->get(); |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 1156 | |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 1157 | const auto filterRefreshRates = [&](const FpsRanges& ranges, |
| 1158 | const char* rangeName) REQUIRES(mLock) { |
| 1159 | const auto filterModes = [&](const DisplayMode& mode) { |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 1160 | return mode.getResolution() == defaultMode->getResolution() && |
| 1161 | mode.getDpi() == defaultMode->getDpi() && |
| 1162 | (policy->allowGroupSwitching || mode.getGroup() == defaultMode->getGroup()) && |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 1163 | ranges.physical.includes(mode.getFps()) && |
| 1164 | (supportsFrameRateOverride() || ranges.render.includes(mode.getFps())); |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 1165 | }; |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 1166 | |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 1167 | const auto frameRateModes = createFrameRateModes(filterModes, ranges.render); |
| 1168 | LOG_ALWAYS_FATAL_IF(frameRateModes.empty(), |
Ady Abraham | 08048ce | 2022-11-30 18:08:00 -0800 | [diff] [blame] | 1169 | "No matching frame rate modes for %s range. policy: %s", rangeName, |
| 1170 | policy->toString().c_str()); |
Dominik Laskowski | 953b7fd | 2022-01-08 19:34:59 -0800 | [diff] [blame] | 1171 | |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 1172 | const auto stringifyModes = [&] { |
| 1173 | std::string str; |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 1174 | for (const auto& frameRateMode : frameRateModes) { |
| 1175 | str += to_string(frameRateMode) + " "; |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 1176 | } |
| 1177 | return str; |
| 1178 | }; |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 1179 | ALOGV("%s render rates: %s", rangeName, stringifyModes().c_str()); |
Steven Thomas | f734df4 | 2020-04-13 21:09:28 -0700 | [diff] [blame] | 1180 | |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 1181 | return frameRateModes; |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 1182 | }; |
| 1183 | |
Ady Abraham | 6863606 | 2022-11-16 17:07:25 -0800 | [diff] [blame] | 1184 | mPrimaryFrameRates = filterRefreshRates(policy->primaryRanges, "primary"); |
| 1185 | mAppRequestFrameRates = filterRefreshRates(policy->appRequestRanges, "app request"); |
Ady Abraham | 2139f73 | 2019-11-13 18:56:40 -0800 | [diff] [blame] | 1186 | } |
| 1187 | |
Dominik Laskowski | d82e0f0 | 2022-10-26 15:23:04 -0400 | [diff] [blame] | 1188 | Fps RefreshRateSelector::findClosestKnownFrameRate(Fps frameRate) const { |
Dominik Laskowski | 6eab42d | 2021-09-13 14:34:13 -0700 | [diff] [blame] | 1189 | using namespace fps_approx_ops; |
| 1190 | |
| 1191 | if (frameRate <= mKnownFrameRates.front()) { |
| 1192 | return mKnownFrameRates.front(); |
Ady Abraham | b1b9d41 | 2020-06-01 19:53:52 -0700 | [diff] [blame] | 1193 | } |
| 1194 | |
Dominik Laskowski | 6eab42d | 2021-09-13 14:34:13 -0700 | [diff] [blame] | 1195 | if (frameRate >= mKnownFrameRates.back()) { |
| 1196 | return mKnownFrameRates.back(); |
Ady Abraham | b1b9d41 | 2020-06-01 19:53:52 -0700 | [diff] [blame] | 1197 | } |
| 1198 | |
Marin Shalamanov | e8a663d | 2020-11-24 17:48:00 +0100 | [diff] [blame] | 1199 | auto lowerBound = std::lower_bound(mKnownFrameRates.begin(), mKnownFrameRates.end(), frameRate, |
Dominik Laskowski | 6eab42d | 2021-09-13 14:34:13 -0700 | [diff] [blame] | 1200 | isStrictlyLess); |
Ady Abraham | b1b9d41 | 2020-06-01 19:53:52 -0700 | [diff] [blame] | 1201 | |
Dominik Laskowski | 6eab42d | 2021-09-13 14:34:13 -0700 | [diff] [blame] | 1202 | const auto distance1 = std::abs(frameRate.getValue() - lowerBound->getValue()); |
| 1203 | const auto distance2 = std::abs(frameRate.getValue() - std::prev(lowerBound)->getValue()); |
Ady Abraham | b1b9d41 | 2020-06-01 19:53:52 -0700 | [diff] [blame] | 1204 | return distance1 < distance2 ? *lowerBound : *std::prev(lowerBound); |
| 1205 | } |
| 1206 | |
Dominik Laskowski | d82e0f0 | 2022-10-26 15:23:04 -0400 | [diff] [blame] | 1207 | auto RefreshRateSelector::getIdleTimerAction() const -> KernelIdleTimerAction { |
Ana Krulec | b9afd79 | 2020-06-11 13:16:15 -0700 | [diff] [blame] | 1208 | std::lock_guard lock(mLock); |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 1209 | |
| 1210 | const Fps deviceMinFps = mMinRefreshRateModeIt->second->getFps(); |
| 1211 | const DisplayModePtr& minByPolicy = getMinRefreshRateByPolicyLocked(); |
Ana Krulec | b9afd79 | 2020-06-11 13:16:15 -0700 | [diff] [blame] | 1212 | |
| 1213 | // Kernel idle timer will set the refresh rate to the device min. If DisplayManager says that |
| 1214 | // the min allowed refresh rate is higher than the device min, we do not want to enable the |
| 1215 | // timer. |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 1216 | if (isStrictlyLess(deviceMinFps, minByPolicy->getFps())) { |
| 1217 | return KernelIdleTimerAction::TurnOff; |
Ana Krulec | b9afd79 | 2020-06-11 13:16:15 -0700 | [diff] [blame] | 1218 | } |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 1219 | |
ramindani | d72ba16 | 2022-09-09 21:33:40 +0000 | [diff] [blame] | 1220 | const DisplayModePtr& maxByPolicy = |
Ady Abraham | ace3d05 | 2022-11-17 16:25:05 -0800 | [diff] [blame] | 1221 | getMaxRefreshRateByPolicyLocked(getActiveModeLocked().modePtr->getGroup()); |
Ana Krulec | b9afd79 | 2020-06-11 13:16:15 -0700 | [diff] [blame] | 1222 | if (minByPolicy == maxByPolicy) { |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 1223 | // Turn on the timer when the min of the primary range is below the device min. |
| 1224 | if (const Policy* currentPolicy = getCurrentPolicyLocked(); |
Ady Abraham | 285f8c1 | 2022-10-11 17:12:14 -0700 | [diff] [blame] | 1225 | isApproxLess(currentPolicy->primaryRanges.physical.min, deviceMinFps)) { |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 1226 | return KernelIdleTimerAction::TurnOn; |
Ana Krulec | b9afd79 | 2020-06-11 13:16:15 -0700 | [diff] [blame] | 1227 | } |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 1228 | return KernelIdleTimerAction::TurnOff; |
Ana Krulec | b9afd79 | 2020-06-11 13:16:15 -0700 | [diff] [blame] | 1229 | } |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 1230 | |
Ana Krulec | b9afd79 | 2020-06-11 13:16:15 -0700 | [diff] [blame] | 1231 | // Turn on the timer in all other cases. |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 1232 | return KernelIdleTimerAction::TurnOn; |
Ana Krulec | b9afd79 | 2020-06-11 13:16:15 -0700 | [diff] [blame] | 1233 | } |
| 1234 | |
Dominik Laskowski | d82e0f0 | 2022-10-26 15:23:04 -0400 | [diff] [blame] | 1235 | int RefreshRateSelector::getFrameRateDivisor(Fps displayRefreshRate, Fps layerFrameRate) { |
Ady Abraham | 62f216c | 2020-10-13 19:07:23 -0700 | [diff] [blame] | 1236 | // This calculation needs to be in sync with the java code |
| 1237 | // in DisplayManagerService.getDisplayInfoForFrameRateOverride |
Marin Shalamanov | 15a0fc6 | 2021-08-16 18:20:21 +0200 | [diff] [blame] | 1238 | |
| 1239 | // The threshold must be smaller than 0.001 in order to differentiate |
| 1240 | // between the fractional pairs (e.g. 59.94 and 60). |
| 1241 | constexpr float kThreshold = 0.0009f; |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 1242 | const auto numPeriods = displayRefreshRate.getValue() / layerFrameRate.getValue(); |
Ady Abraham | 0bb6a47 | 2020-10-12 10:22:13 -0700 | [diff] [blame] | 1243 | const auto numPeriodsRounded = std::round(numPeriods); |
| 1244 | if (std::abs(numPeriods - numPeriodsRounded) > kThreshold) { |
Ady Abraham | 62a0be2 | 2020-12-08 16:54:10 -0800 | [diff] [blame] | 1245 | return 0; |
Ady Abraham | 0bb6a47 | 2020-10-12 10:22:13 -0700 | [diff] [blame] | 1246 | } |
| 1247 | |
Ady Abraham | 62f216c | 2020-10-13 19:07:23 -0700 | [diff] [blame] | 1248 | return static_cast<int>(numPeriodsRounded); |
| 1249 | } |
| 1250 | |
Dominik Laskowski | d82e0f0 | 2022-10-26 15:23:04 -0400 | [diff] [blame] | 1251 | bool RefreshRateSelector::isFractionalPairOrMultiple(Fps smaller, Fps bigger) { |
Dominik Laskowski | 6eab42d | 2021-09-13 14:34:13 -0700 | [diff] [blame] | 1252 | if (isStrictlyLess(bigger, smaller)) { |
Marin Shalamanov | 15a0fc6 | 2021-08-16 18:20:21 +0200 | [diff] [blame] | 1253 | return isFractionalPairOrMultiple(bigger, smaller); |
| 1254 | } |
| 1255 | |
| 1256 | const auto multiplier = std::round(bigger.getValue() / smaller.getValue()); |
| 1257 | constexpr float kCoef = 1000.f / 1001.f; |
Dominik Laskowski | 6eab42d | 2021-09-13 14:34:13 -0700 | [diff] [blame] | 1258 | return isApproxEqual(bigger, Fps::fromValue(smaller.getValue() * multiplier / kCoef)) || |
| 1259 | isApproxEqual(bigger, Fps::fromValue(smaller.getValue() * multiplier * kCoef)); |
Marin Shalamanov | 15a0fc6 | 2021-08-16 18:20:21 +0200 | [diff] [blame] | 1260 | } |
| 1261 | |
Dominik Laskowski | d82e0f0 | 2022-10-26 15:23:04 -0400 | [diff] [blame] | 1262 | void RefreshRateSelector::dump(utils::Dumper& dumper) const { |
Dominik Laskowski | e70461a | 2022-08-30 14:42:01 -0700 | [diff] [blame] | 1263 | using namespace std::string_view_literals; |
Dominik Laskowski | 0acc384 | 2022-04-07 11:23:42 -0700 | [diff] [blame] | 1264 | |
Marin Shalamanov | ba421a8 | 2020-11-10 21:49:26 +0100 | [diff] [blame] | 1265 | std::lock_guard lock(mLock); |
Marin Shalamanov | ba421a8 | 2020-11-10 21:49:26 +0100 | [diff] [blame] | 1266 | |
Ady Abraham | ace3d05 | 2022-11-17 16:25:05 -0800 | [diff] [blame] | 1267 | const auto activeMode = getActiveModeLocked(); |
| 1268 | dumper.dump("activeMode"sv, to_string(activeMode)); |
Marin Shalamanov | ba421a8 | 2020-11-10 21:49:26 +0100 | [diff] [blame] | 1269 | |
Dominik Laskowski | e70461a | 2022-08-30 14:42:01 -0700 | [diff] [blame] | 1270 | dumper.dump("displayModes"sv); |
| 1271 | { |
| 1272 | utils::Dumper::Indent indent(dumper); |
| 1273 | for (const auto& [id, mode] : mDisplayModes) { |
| 1274 | dumper.dump({}, to_string(*mode)); |
| 1275 | } |
Marin Shalamanov | ba421a8 | 2020-11-10 21:49:26 +0100 | [diff] [blame] | 1276 | } |
| 1277 | |
Dominik Laskowski | e70461a | 2022-08-30 14:42:01 -0700 | [diff] [blame] | 1278 | dumper.dump("displayManagerPolicy"sv, mDisplayManagerPolicy.toString()); |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 1279 | |
Dominik Laskowski | 0acc384 | 2022-04-07 11:23:42 -0700 | [diff] [blame] | 1280 | if (const Policy& currentPolicy = *getCurrentPolicyLocked(); |
| 1281 | mOverridePolicy && currentPolicy != mDisplayManagerPolicy) { |
Dominik Laskowski | e70461a | 2022-08-30 14:42:01 -0700 | [diff] [blame] | 1282 | dumper.dump("overridePolicy"sv, currentPolicy.toString()); |
ramindani | 32cf060 | 2022-03-02 02:30:29 +0000 | [diff] [blame] | 1283 | } |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 1284 | |
Ady Abraham | 8ca643a | 2022-10-18 18:26:47 -0700 | [diff] [blame] | 1285 | dumper.dump("frameRateOverrideConfig"sv, *ftl::enum_name(mFrameRateOverrideConfig)); |
Dominik Laskowski | 0acc384 | 2022-04-07 11:23:42 -0700 | [diff] [blame] | 1286 | |
Dominik Laskowski | 03cfce8 | 2022-11-02 12:13:29 -0400 | [diff] [blame] | 1287 | dumper.dump("idleTimer"sv); |
| 1288 | { |
| 1289 | utils::Dumper::Indent indent(dumper); |
| 1290 | dumper.dump("interval"sv, mIdleTimer.transform(&OneShotTimer::interval)); |
| 1291 | dumper.dump("controller"sv, |
| 1292 | mConfig.kernelIdleTimerController |
| 1293 | .and_then(&ftl::enum_name<KernelIdleTimerController>) |
| 1294 | .value_or("Platform"sv)); |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 1295 | } |
Marin Shalamanov | ba421a8 | 2020-11-10 21:49:26 +0100 | [diff] [blame] | 1296 | } |
| 1297 | |
Dominik Laskowski | d82e0f0 | 2022-10-26 15:23:04 -0400 | [diff] [blame] | 1298 | std::chrono::milliseconds RefreshRateSelector::getIdleTimerTimeout() { |
ramindani | 32cf060 | 2022-03-02 02:30:29 +0000 | [diff] [blame] | 1299 | return mConfig.idleTimerTimeout; |
| 1300 | } |
| 1301 | |
Ady Abraham | 2139f73 | 2019-11-13 18:56:40 -0800 | [diff] [blame] | 1302 | } // namespace android::scheduler |
Marin Shalamanov | bed7fd3 | 2020-12-21 20:02:20 +0100 | [diff] [blame] | 1303 | |
| 1304 | // TODO(b/129481165): remove the #pragma below and fix conversion issues |
Ady Abraham | dd5bfa9 | 2021-01-07 17:56:08 -0800 | [diff] [blame] | 1305 | #pragma clang diagnostic pop // ignored "-Wextra" |