Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2020 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | |
| 17 | #pragma once |
| 18 | |
Dominik Laskowski | f6b4ba6 | 2021-11-09 12:46:10 -0800 | [diff] [blame] | 19 | #include <chrono> |
| 20 | #include <deque> |
| 21 | #include <optional> |
| 22 | #include <string> |
| 23 | #include <unordered_map> |
| 24 | |
Ady Abraham | bdda8f0 | 2021-04-01 16:06:11 -0700 | [diff] [blame] | 25 | #include <ui/Transform.h> |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 26 | #include <utils/Timers.h> |
| 27 | |
Rachel Lee | ce6e004 | 2023-06-27 11:22:54 -0700 | [diff] [blame] | 28 | #include <scheduler/Fps.h> |
Dominik Laskowski | f6b4ba6 | 2021-11-09 12:46:10 -0800 | [diff] [blame] | 29 | #include <scheduler/Seamlessness.h> |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 30 | |
| 31 | #include "LayerHistory.h" |
Dominik Laskowski | d82e0f0 | 2022-10-26 15:23:04 -0400 | [diff] [blame] | 32 | #include "RefreshRateSelector.h" |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 33 | |
| 34 | namespace android { |
| 35 | |
| 36 | class Layer; |
| 37 | |
| 38 | namespace scheduler { |
| 39 | |
| 40 | using namespace std::chrono_literals; |
Vishnu Nair | ef68d6d | 2023-02-28 06:18:27 +0000 | [diff] [blame] | 41 | struct LayerProps; |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 42 | // Maximum period between presents for a layer to be considered active. |
| 43 | constexpr std::chrono::nanoseconds MAX_ACTIVE_LAYER_PERIOD_NS = 1200ms; |
| 44 | |
| 45 | // Earliest present time for a layer to be considered active. |
| 46 | constexpr nsecs_t getActiveLayerThreshold(nsecs_t now) { |
| 47 | return now - MAX_ACTIVE_LAYER_PERIOD_NS.count(); |
| 48 | } |
| 49 | |
| 50 | // Stores history of present times and refresh rates for a layer. |
Marin Shalamanov | 1bc43ee | 2020-11-20 16:56:52 +0100 | [diff] [blame] | 51 | class LayerInfo { |
Ady Abraham | 5def733 | 2020-05-29 16:13:47 -0700 | [diff] [blame] | 52 | using LayerUpdateType = LayerHistory::LayerUpdateType; |
| 53 | |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 54 | // Layer is considered frequent if the earliest value in the window of most recent present times |
| 55 | // is within a threshold. If a layer is infrequent, its average refresh rate is disregarded in |
| 56 | // favor of a low refresh rate. |
Ady Abraham | 86ac5c5 | 2023-01-11 15:24:03 -0800 | [diff] [blame] | 57 | static constexpr size_t kFrequentLayerWindowSize = 4; |
Dominik Laskowski | 6eab42d | 2021-09-13 14:34:13 -0700 | [diff] [blame] | 58 | static constexpr Fps kMinFpsForFrequentLayer = 10_Hz; |
Marin Shalamanov | 2045d5b | 2020-12-28 18:11:41 +0100 | [diff] [blame] | 59 | static constexpr auto kMaxPeriodForFrequentLayerNs = |
| 60 | std::chrono::nanoseconds(kMinFpsForFrequentLayer.getPeriodNsecs()) + 1ms; |
Arthur Hung | c70bee2 | 2023-06-02 01:35:52 +0000 | [diff] [blame] | 61 | static constexpr size_t kNumSmallDirtyThreshold = 2; |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 62 | |
Marin Shalamanov | 1bc43ee | 2020-11-20 16:56:52 +0100 | [diff] [blame] | 63 | friend class LayerHistoryTest; |
Marin Shalamanov | 2045d5b | 2020-12-28 18:11:41 +0100 | [diff] [blame] | 64 | friend class LayerInfoTest; |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 65 | |
| 66 | public: |
Marin Shalamanov | 4608442 | 2020-10-13 12:33:42 +0200 | [diff] [blame] | 67 | // Holds information about the layer vote |
| 68 | struct LayerVote { |
| 69 | LayerHistory::LayerVoteType type = LayerHistory::LayerVoteType::Heuristic; |
Dominik Laskowski | 6eab42d | 2021-09-13 14:34:13 -0700 | [diff] [blame] | 70 | Fps fps; |
Marin Shalamanov | 53fc11d | 2020-11-20 14:00:13 +0100 | [diff] [blame] | 71 | Seamlessness seamlessness = Seamlessness::Default; |
Rachel Lee | ce6e004 | 2023-06-27 11:22:54 -0700 | [diff] [blame] | 72 | // Category is in effect if fps is not specified. |
| 73 | FrameRateCategory category = FrameRateCategory::Default; |
| 74 | |
| 75 | // Returns true if the layer explicitly should contribute to frame rate scoring. |
Rachel Lee | d0694bc | 2023-09-12 14:57:58 -0700 | [diff] [blame] | 76 | bool isNoVote() const { return RefreshRateSelector::isNoVote(type); } |
Marin Shalamanov | 4608442 | 2020-10-13 12:33:42 +0200 | [diff] [blame] | 77 | }; |
| 78 | |
Rachel Lee | ce6e004 | 2023-06-27 11:22:54 -0700 | [diff] [blame] | 79 | using RefreshRateVotes = ftl::SmallVector<LayerInfo::LayerVote, 2>; |
| 80 | |
Ady Abraham | bdda8f0 | 2021-04-01 16:06:11 -0700 | [diff] [blame] | 81 | // FrameRateCompatibility specifies how we should interpret the frame rate associated with |
| 82 | // the layer. |
| 83 | enum class FrameRateCompatibility { |
| 84 | Default, // Layer didn't specify any specific handling strategy |
| 85 | |
Andy Labrada | 096227e | 2022-06-15 16:58:11 +0000 | [diff] [blame] | 86 | Min, // Layer needs the minimum frame rate. |
| 87 | |
Ady Abraham | bdda8f0 | 2021-04-01 16:06:11 -0700 | [diff] [blame] | 88 | Exact, // Layer needs the exact frame rate. |
| 89 | |
| 90 | ExactOrMultiple, // Layer needs the exact frame rate (or a multiple of it) to present the |
| 91 | // content properly. Any other value will result in a pull down. |
| 92 | |
| 93 | NoVote, // Layer doesn't have any requirements for the refresh rate and |
| 94 | // should not be considered when the display refresh rate is determined. |
Dominik Laskowski | f5d0ea5 | 2021-09-26 17:27:01 -0700 | [diff] [blame] | 95 | |
| 96 | ftl_last = NoVote |
Ady Abraham | bdda8f0 | 2021-04-01 16:06:11 -0700 | [diff] [blame] | 97 | }; |
| 98 | |
Rachel Lee | 58cc90d | 2023-09-05 18:50:20 -0700 | [diff] [blame^] | 99 | enum class FrameRateSelectionStrategy { |
| 100 | Self, |
| 101 | OverrideChildren, |
| 102 | |
| 103 | ftl_last = OverrideChildren |
| 104 | }; |
| 105 | |
Rachel Lee | ce6e004 | 2023-06-27 11:22:54 -0700 | [diff] [blame] | 106 | // Encapsulates the frame rate specifications of the layer. This information will be used |
Ady Abraham | bdda8f0 | 2021-04-01 16:06:11 -0700 | [diff] [blame] | 107 | // when the display refresh rate is determined. |
| 108 | struct FrameRate { |
| 109 | using Seamlessness = scheduler::Seamlessness; |
| 110 | |
Rachel Lee | ce6e004 | 2023-06-27 11:22:54 -0700 | [diff] [blame] | 111 | // Information related to a specific desired frame rate vote. |
| 112 | struct FrameRateVote { |
| 113 | Fps rate; |
| 114 | FrameRateCompatibility type = FrameRateCompatibility::Default; |
| 115 | Seamlessness seamlessness = Seamlessness::Default; |
| 116 | |
| 117 | bool operator==(const FrameRateVote& other) const { |
| 118 | return isApproxEqual(rate, other.rate) && type == other.type && |
| 119 | seamlessness == other.seamlessness; |
| 120 | } |
| 121 | |
| 122 | FrameRateVote() = default; |
| 123 | |
| 124 | FrameRateVote(Fps rate, FrameRateCompatibility type, |
| 125 | Seamlessness seamlessness = Seamlessness::OnlySeamless) |
| 126 | : rate(rate), type(type), seamlessness(getSeamlessness(rate, seamlessness)) {} |
| 127 | } vote; |
| 128 | |
| 129 | FrameRateCategory category = FrameRateCategory::Default; |
Ady Abraham | bdda8f0 | 2021-04-01 16:06:11 -0700 | [diff] [blame] | 130 | |
Dominik Laskowski | 6eab42d | 2021-09-13 14:34:13 -0700 | [diff] [blame] | 131 | FrameRate() = default; |
| 132 | |
Ady Abraham | bdda8f0 | 2021-04-01 16:06:11 -0700 | [diff] [blame] | 133 | FrameRate(Fps rate, FrameRateCompatibility type, |
Rachel Lee | ce6e004 | 2023-06-27 11:22:54 -0700 | [diff] [blame] | 134 | Seamlessness seamlessness = Seamlessness::OnlySeamless, |
| 135 | FrameRateCategory category = FrameRateCategory::Default) |
| 136 | : vote(FrameRateVote(rate, type, seamlessness)), category(category) {} |
Ady Abraham | bdda8f0 | 2021-04-01 16:06:11 -0700 | [diff] [blame] | 137 | |
| 138 | bool operator==(const FrameRate& other) const { |
Rachel Lee | ce6e004 | 2023-06-27 11:22:54 -0700 | [diff] [blame] | 139 | return vote == other.vote && category == other.category; |
Ady Abraham | bdda8f0 | 2021-04-01 16:06:11 -0700 | [diff] [blame] | 140 | } |
| 141 | |
| 142 | bool operator!=(const FrameRate& other) const { return !(*this == other); } |
| 143 | |
| 144 | // Convert an ANATIVEWINDOW_FRAME_RATE_COMPATIBILITY_* value to a |
| 145 | // Layer::FrameRateCompatibility. Logs fatal if the compatibility value is invalid. |
| 146 | static FrameRateCompatibility convertCompatibility(int8_t compatibility); |
Rachel Lee | ce6e004 | 2023-06-27 11:22:54 -0700 | [diff] [blame] | 147 | |
| 148 | // Convert an ANATIVEWINDOW_CHANGE_FRAME_RATE_* value to a scheduler::Seamlessness. |
Rachel Lee | 58cc90d | 2023-09-05 18:50:20 -0700 | [diff] [blame^] | 149 | // Logs fatal if the strategy value is invalid. |
Ady Abraham | bdda8f0 | 2021-04-01 16:06:11 -0700 | [diff] [blame] | 150 | static scheduler::Seamlessness convertChangeFrameRateStrategy(int8_t strategy); |
| 151 | |
Rachel Lee | ce6e004 | 2023-06-27 11:22:54 -0700 | [diff] [blame] | 152 | // Convert an ANATIVEWINDOW_FRAME_RATE_CATEGORY_* value to a FrameRateCategory. |
Rachel Lee | 58cc90d | 2023-09-05 18:50:20 -0700 | [diff] [blame^] | 153 | // Logs fatal if the category value is invalid. |
Rachel Lee | ce6e004 | 2023-06-27 11:22:54 -0700 | [diff] [blame] | 154 | static FrameRateCategory convertCategory(int8_t category); |
| 155 | |
| 156 | // True if the FrameRate has explicit frame rate specifications. |
| 157 | bool isValid() const; |
| 158 | |
| 159 | // Returns true if the FrameRate explicitly instructs to not contribute to frame rate |
| 160 | // selection. |
| 161 | bool isNoVote() const; |
| 162 | |
Ady Abraham | bdda8f0 | 2021-04-01 16:06:11 -0700 | [diff] [blame] | 163 | private: |
| 164 | static Seamlessness getSeamlessness(Fps rate, Seamlessness seamlessness) { |
| 165 | if (!rate.isValid()) { |
| 166 | // Refresh rate of 0 is a special value which should reset the vote to |
| 167 | // its default value. |
| 168 | return Seamlessness::Default; |
| 169 | } |
| 170 | return seamlessness; |
| 171 | } |
| 172 | }; |
| 173 | |
Rachel Lee | 58cc90d | 2023-09-05 18:50:20 -0700 | [diff] [blame^] | 174 | // Convert an ANATIVEWINDOW_FRAME_RATE_SELECTION_STRATEGY_* value to FrameRateSelectionStrategy. |
| 175 | // Logs fatal if the strategy value is invalid. |
| 176 | static FrameRateSelectionStrategy convertFrameRateSelectionStrategy(int8_t strategy); |
| 177 | |
Ady Abraham | 0ccd79b | 2020-06-10 10:11:17 -0700 | [diff] [blame] | 178 | static void setTraceEnabled(bool enabled) { sTraceEnabled = enabled; } |
| 179 | |
Ady Abraham | bdda8f0 | 2021-04-01 16:06:11 -0700 | [diff] [blame] | 180 | LayerInfo(const std::string& name, uid_t ownerUid, LayerHistory::LayerVoteType defaultVote); |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 181 | |
Marin Shalamanov | 1bc43ee | 2020-11-20 16:56:52 +0100 | [diff] [blame] | 182 | LayerInfo(const LayerInfo&) = delete; |
| 183 | LayerInfo& operator=(const LayerInfo&) = delete; |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 184 | |
| 185 | // Records the last requested present time. It also stores information about when |
| 186 | // the layer was last updated. If the present time is farther in the future than the |
| 187 | // updated time, the updated time is the present time. |
Ady Abraham | 5def733 | 2020-05-29 16:13:47 -0700 | [diff] [blame] | 188 | void setLastPresentTime(nsecs_t lastPresentTime, nsecs_t now, LayerUpdateType updateType, |
Vishnu Nair | ef68d6d | 2023-02-28 06:18:27 +0000 | [diff] [blame] | 189 | bool pendingModeChange, const LayerProps& props); |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 190 | |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 191 | // Sets an explicit layer vote. This usually comes directly from the application via |
| 192 | // ANativeWindow_setFrameRate API |
Marin Shalamanov | 4608442 | 2020-10-13 12:33:42 +0200 | [diff] [blame] | 193 | void setLayerVote(LayerVote vote) { mLayerVote = vote; } |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 194 | |
| 195 | // Sets the default layer vote. This will be the layer vote after calling to resetLayerVote(). |
| 196 | // This is used for layers that called to setLayerVote() and then removed the vote, so that the |
| 197 | // layer can go back to whatever vote it had before the app voted for it. |
| 198 | void setDefaultLayerVote(LayerHistory::LayerVoteType type) { mDefaultVote = type; } |
| 199 | |
| 200 | // Resets the layer vote to its default. |
Rachel Lee | ce6e004 | 2023-06-27 11:22:54 -0700 | [diff] [blame] | 201 | void resetLayerVote() { |
| 202 | mLayerVote = {mDefaultVote, Fps(), Seamlessness::Default, FrameRateCategory::Default}; |
| 203 | } |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 204 | |
Ady Abraham | bdda8f0 | 2021-04-01 16:06:11 -0700 | [diff] [blame] | 205 | std::string getName() const { return mName; } |
| 206 | |
| 207 | uid_t getOwnerUid() const { return mOwnerUid; } |
| 208 | |
Rachel Lee | ce6e004 | 2023-06-27 11:22:54 -0700 | [diff] [blame] | 209 | RefreshRateVotes getRefreshRateVote(const RefreshRateSelector&, nsecs_t now); |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 210 | |
| 211 | // Return the last updated time. If the present time is farther in the future than the |
| 212 | // updated time, the updated time is the present time. |
| 213 | nsecs_t getLastUpdatedTime() const { return mLastUpdatedTime; } |
| 214 | |
Vishnu Nair | ef68d6d | 2023-02-28 06:18:27 +0000 | [diff] [blame] | 215 | FrameRate getSetFrameRateVote() const; |
| 216 | bool isVisible() const; |
| 217 | int32_t getFrameRateSelectionPriority() const; |
| 218 | FloatRect getBounds() const; |
| 219 | ui::Transform getTransform() const; |
Ady Abraham | bdda8f0 | 2021-04-01 16:06:11 -0700 | [diff] [blame] | 220 | |
Ady Abraham | 0ccd79b | 2020-06-10 10:11:17 -0700 | [diff] [blame] | 221 | // Returns a C string for tracing a vote |
| 222 | const char* getTraceTag(LayerHistory::LayerVoteType type) const; |
| 223 | |
Nathaniel Nifong | 1303d91 | 2021-10-06 09:41:24 -0400 | [diff] [blame] | 224 | // Return the framerate of this layer. |
| 225 | Fps getFps(nsecs_t now) const; |
| 226 | |
Ady Abraham | 983e568 | 2020-05-28 16:49:18 -0700 | [diff] [blame] | 227 | void onLayerInactive(nsecs_t now) { |
Ady Abraham | dfb63ba | 2020-05-27 20:05:05 +0000 | [diff] [blame] | 228 | // Mark mFrameTimeValidSince to now to ignore all previous frame times. |
| 229 | // We are not deleting the old frame to keep track of whether we should treat the first |
| 230 | // buffer as Max as we don't know anything about this layer or Min as this layer is |
| 231 | // posting infrequent updates. |
Ady Abraham | 983e568 | 2020-05-28 16:49:18 -0700 | [diff] [blame] | 232 | const auto timePoint = std::chrono::nanoseconds(now); |
| 233 | mFrameTimeValidSince = std::chrono::time_point<std::chrono::steady_clock>(timePoint); |
Ady Abraham | b1b9d41 | 2020-06-01 19:53:52 -0700 | [diff] [blame] | 234 | mLastRefreshRate = {}; |
Ady Abraham | 0ccd79b | 2020-06-10 10:11:17 -0700 | [diff] [blame] | 235 | mRefreshRateHistory.clear(); |
ramindani | 63db24e | 2023-04-03 10:56:05 -0700 | [diff] [blame] | 236 | mIsFrequencyConclusive = true; |
Ady Abraham | a61edcb | 2020-01-30 18:32:03 -0800 | [diff] [blame] | 237 | } |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 238 | |
Ady Abraham | 983e568 | 2020-05-28 16:49:18 -0700 | [diff] [blame] | 239 | void clearHistory(nsecs_t now) { |
| 240 | onLayerInactive(now); |
| 241 | mFrameTimes.clear(); |
| 242 | } |
| 243 | |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 244 | private: |
Ady Abraham | a61edcb | 2020-01-30 18:32:03 -0800 | [diff] [blame] | 245 | // Used to store the layer timestamps |
| 246 | struct FrameTimeData { |
Marin Shalamanov | 2045d5b | 2020-12-28 18:11:41 +0100 | [diff] [blame] | 247 | nsecs_t presentTime; // desiredPresentTime, if provided |
Ady Abraham | a61edcb | 2020-01-30 18:32:03 -0800 | [diff] [blame] | 248 | nsecs_t queueTime; // buffer queue time |
Marin Shalamanov | a7fe304 | 2021-01-29 21:02:08 +0100 | [diff] [blame] | 249 | bool pendingModeChange; |
Arthur Hung | c70bee2 | 2023-06-02 01:35:52 +0000 | [diff] [blame] | 250 | bool isSmallDirty; |
Ady Abraham | a61edcb | 2020-01-30 18:32:03 -0800 | [diff] [blame] | 251 | }; |
| 252 | |
Ady Abraham | 0ccd79b | 2020-06-10 10:11:17 -0700 | [diff] [blame] | 253 | // Holds information about the calculated and reported refresh rate |
| 254 | struct RefreshRateHeuristicData { |
| 255 | // Rate calculated on the layer |
Dominik Laskowski | 6eab42d | 2021-09-13 14:34:13 -0700 | [diff] [blame] | 256 | Fps calculated; |
Marin Shalamanov | 1bc43ee | 2020-11-20 16:56:52 +0100 | [diff] [blame] | 257 | // Last reported rate for LayerInfo::getRefreshRate() |
Dominik Laskowski | 6eab42d | 2021-09-13 14:34:13 -0700 | [diff] [blame] | 258 | Fps reported; |
Marin Shalamanov | 1bc43ee | 2020-11-20 16:56:52 +0100 | [diff] [blame] | 259 | // Whether the last reported rate for LayerInfo::getRefreshRate() |
Ady Abraham | 0ccd79b | 2020-06-10 10:11:17 -0700 | [diff] [blame] | 260 | // was due to animation or infrequent updates |
Ady Abraham | 86ac5c5 | 2023-01-11 15:24:03 -0800 | [diff] [blame] | 261 | bool animating = false; |
| 262 | // Whether the last reported rate for LayerInfo::getRefreshRate() |
| 263 | // was due to infrequent updates |
| 264 | bool infrequent = false; |
Ady Abraham | 0ccd79b | 2020-06-10 10:11:17 -0700 | [diff] [blame] | 265 | }; |
| 266 | |
Ady Abraham | 0ccd79b | 2020-06-10 10:11:17 -0700 | [diff] [blame] | 267 | // Class to store past calculated refresh rate and determine whether |
| 268 | // the refresh rate calculated is consistent with past values |
| 269 | class RefreshRateHistory { |
| 270 | public: |
| 271 | static constexpr auto HISTORY_SIZE = 90; |
| 272 | static constexpr std::chrono::nanoseconds HISTORY_DURATION = 2s; |
| 273 | |
| 274 | RefreshRateHistory(const std::string& name) : mName(name) {} |
| 275 | |
| 276 | // Clears History |
| 277 | void clear(); |
| 278 | |
| 279 | // Adds a new refresh rate and returns true if it is consistent |
Marin Shalamanov | e8a663d | 2020-11-24 17:48:00 +0100 | [diff] [blame] | 280 | bool add(Fps refreshRate, nsecs_t now); |
Ady Abraham | 0ccd79b | 2020-06-10 10:11:17 -0700 | [diff] [blame] | 281 | |
| 282 | private: |
Marin Shalamanov | 1bc43ee | 2020-11-20 16:56:52 +0100 | [diff] [blame] | 283 | friend class LayerHistoryTest; |
Ady Abraham | 0ccd79b | 2020-06-10 10:11:17 -0700 | [diff] [blame] | 284 | |
| 285 | // Holds the refresh rate when it was calculated |
| 286 | struct RefreshRateData { |
Dominik Laskowski | 6eab42d | 2021-09-13 14:34:13 -0700 | [diff] [blame] | 287 | Fps refreshRate; |
Ady Abraham | 0ccd79b | 2020-06-10 10:11:17 -0700 | [diff] [blame] | 288 | nsecs_t timestamp = 0; |
Ady Abraham | 0ccd79b | 2020-06-10 10:11:17 -0700 | [diff] [blame] | 289 | }; |
| 290 | |
| 291 | // Holds tracing strings |
| 292 | struct HeuristicTraceTagData { |
| 293 | std::string min; |
| 294 | std::string max; |
| 295 | std::string consistent; |
| 296 | std::string average; |
| 297 | }; |
| 298 | |
| 299 | bool isConsistent() const; |
| 300 | HeuristicTraceTagData makeHeuristicTraceTagData() const; |
| 301 | |
| 302 | const std::string mName; |
| 303 | mutable std::optional<HeuristicTraceTagData> mHeuristicTraceTagData; |
| 304 | std::deque<RefreshRateData> mRefreshRates; |
Marin Shalamanov | e8a663d | 2020-11-24 17:48:00 +0100 | [diff] [blame] | 305 | static constexpr float MARGIN_CONSISTENT_FPS = 1.0; |
Ady Abraham | 0ccd79b | 2020-06-10 10:11:17 -0700 | [diff] [blame] | 306 | }; |
| 307 | |
ramindani | 63db24e | 2023-04-03 10:56:05 -0700 | [diff] [blame] | 308 | // Represents whether we were able to determine either layer is frequent or infrequent |
| 309 | bool mIsFrequencyConclusive = true; |
| 310 | struct Frequent { |
| 311 | bool isFrequent; |
| 312 | bool clearHistory; |
| 313 | // Represents whether we were able to determine isFrequent conclusively |
| 314 | bool isConclusive; |
Arthur Hung | c70bee2 | 2023-06-02 01:35:52 +0000 | [diff] [blame] | 315 | // Represents whether the latest frames are small dirty. |
| 316 | bool isSmallDirty = false; |
ramindani | 63db24e | 2023-04-03 10:56:05 -0700 | [diff] [blame] | 317 | }; |
| 318 | Frequent isFrequent(nsecs_t now) const; |
Ady Abraham | 5def733 | 2020-05-29 16:13:47 -0700 | [diff] [blame] | 319 | bool isAnimating(nsecs_t now) const; |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 320 | bool hasEnoughDataForHeuristic() const; |
Dominik Laskowski | d82e0f0 | 2022-10-26 15:23:04 -0400 | [diff] [blame] | 321 | std::optional<Fps> calculateRefreshRateIfPossible(const RefreshRateSelector&, nsecs_t now); |
Ady Abraham | 0ccd79b | 2020-06-10 10:11:17 -0700 | [diff] [blame] | 322 | std::optional<nsecs_t> calculateAverageFrameTime() const; |
Ady Abraham | dfb63ba | 2020-05-27 20:05:05 +0000 | [diff] [blame] | 323 | bool isFrameTimeValid(const FrameTimeData&) const; |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 324 | |
Ady Abraham | a6b676e | 2020-05-27 14:29:09 -0700 | [diff] [blame] | 325 | const std::string mName; |
Ady Abraham | bdda8f0 | 2021-04-01 16:06:11 -0700 | [diff] [blame] | 326 | const uid_t mOwnerUid; |
Ady Abraham | a6b676e | 2020-05-27 14:29:09 -0700 | [diff] [blame] | 327 | |
Marin Shalamanov | 4ad8b30 | 2020-12-11 15:50:08 +0100 | [diff] [blame] | 328 | // Used for sanitizing the heuristic data. If two frames are less than |
| 329 | // this period apart from each other they'll be considered as duplicates. |
Dominik Laskowski | 6eab42d | 2021-09-13 14:34:13 -0700 | [diff] [blame] | 330 | static constexpr nsecs_t kMinPeriodBetweenFrames = (240_Hz).getPeriodNsecs(); |
Marin Shalamanov | 2045d5b | 2020-12-28 18:11:41 +0100 | [diff] [blame] | 331 | // Used for sanitizing the heuristic data. If two frames are more than |
| 332 | // this period apart from each other, the interval between them won't be |
| 333 | // taken into account when calculating average frame rate. |
| 334 | static constexpr nsecs_t kMaxPeriodBetweenFrames = kMinFpsForFrequentLayer.getPeriodNsecs(); |
Arthur Hung | c70bee2 | 2023-06-02 01:35:52 +0000 | [diff] [blame] | 335 | // Used for sanitizing the heuristic data. If frames are small dirty updating and are less |
| 336 | // than this period apart from each other, the interval between them won't be |
| 337 | // taken into account when calculating average frame rate. |
| 338 | static constexpr nsecs_t kMinPeriodBetweenSmallDirtyFrames = (60_Hz).getPeriodNsecs(); |
| 339 | |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 340 | LayerHistory::LayerVoteType mDefaultVote; |
| 341 | |
Ady Abraham | 0ccd79b | 2020-06-10 10:11:17 -0700 | [diff] [blame] | 342 | LayerVote mLayerVote; |
| 343 | |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 344 | nsecs_t mLastUpdatedTime = 0; |
| 345 | |
Ady Abraham | 5def733 | 2020-05-29 16:13:47 -0700 | [diff] [blame] | 346 | nsecs_t mLastAnimationTime = 0; |
| 347 | |
Ady Abraham | b1b9d41 | 2020-06-01 19:53:52 -0700 | [diff] [blame] | 348 | RefreshRateHeuristicData mLastRefreshRate; |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 349 | |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 350 | std::deque<FrameTimeData> mFrameTimes; |
Ady Abraham | dfb63ba | 2020-05-27 20:05:05 +0000 | [diff] [blame] | 351 | std::chrono::time_point<std::chrono::steady_clock> mFrameTimeValidSince = |
| 352 | std::chrono::steady_clock::now(); |
Ady Abraham | 0ccd79b | 2020-06-10 10:11:17 -0700 | [diff] [blame] | 353 | static constexpr size_t HISTORY_SIZE = RefreshRateHistory::HISTORY_SIZE; |
Arthur Hung | c70bee2 | 2023-06-02 01:35:52 +0000 | [diff] [blame] | 354 | static constexpr std::chrono::nanoseconds HISTORY_DURATION = LayerHistory::kMaxPeriodForHistory; |
Ady Abraham | 0ccd79b | 2020-06-10 10:11:17 -0700 | [diff] [blame] | 355 | |
Vishnu Nair | ef68d6d | 2023-02-28 06:18:27 +0000 | [diff] [blame] | 356 | std::unique_ptr<LayerProps> mLayerProps; |
Ady Abraham | bdda8f0 | 2021-04-01 16:06:11 -0700 | [diff] [blame] | 357 | |
Ady Abraham | 0ccd79b | 2020-06-10 10:11:17 -0700 | [diff] [blame] | 358 | RefreshRateHistory mRefreshRateHistory; |
| 359 | |
| 360 | mutable std::unordered_map<LayerHistory::LayerVoteType, std::string> mTraceTags; |
Ady Abraham | b1b9d41 | 2020-06-01 19:53:52 -0700 | [diff] [blame] | 361 | |
| 362 | // Shared for all LayerInfo instances |
Ady Abraham | 0ccd79b | 2020-06-10 10:11:17 -0700 | [diff] [blame] | 363 | static bool sTraceEnabled; |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 364 | }; |
| 365 | |
Vishnu Nair | ef68d6d | 2023-02-28 06:18:27 +0000 | [diff] [blame] | 366 | struct LayerProps { |
| 367 | bool visible = false; |
| 368 | FloatRect bounds; |
| 369 | ui::Transform transform; |
| 370 | LayerInfo::FrameRate setFrameRateVote; |
| 371 | int32_t frameRateSelectionPriority = -1; |
Arthur Hung | c70bee2 | 2023-06-02 01:35:52 +0000 | [diff] [blame] | 372 | bool isSmallDirty = false; |
Vishnu Nair | ef68d6d | 2023-02-28 06:18:27 +0000 | [diff] [blame] | 373 | }; |
| 374 | |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 375 | } // namespace scheduler |
| 376 | } // namespace android |