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 | #undef LOG_TAG |
Marin Shalamanov | 1bc43ee | 2020-11-20 16:56:52 +0100 | [diff] [blame] | 18 | #define LOG_TAG "LayerHistory" |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 19 | #define ATRACE_TAG ATRACE_TAG_GRAPHICS |
| 20 | |
| 21 | #include "LayerHistory.h" |
| 22 | |
Dominik Laskowski | 983f2b5 | 2020-06-25 16:54:06 -0700 | [diff] [blame] | 23 | #include <android-base/stringprintf.h> |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 24 | #include <cutils/properties.h> |
Ady Abraham | 73c3df5 | 2023-01-12 18:09:31 -0800 | [diff] [blame^] | 25 | #include <gui/TraceUtils.h> |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 26 | #include <utils/Log.h> |
| 27 | #include <utils/Timers.h> |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 28 | |
| 29 | #include <algorithm> |
| 30 | #include <cmath> |
| 31 | #include <string> |
| 32 | #include <utility> |
| 33 | |
| 34 | #include "../Layer.h" |
Marin Shalamanov | 1bc43ee | 2020-11-20 16:56:52 +0100 | [diff] [blame] | 35 | #include "LayerInfo.h" |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 36 | |
Marin Shalamanov | 1bc43ee | 2020-11-20 16:56:52 +0100 | [diff] [blame] | 37 | namespace android::scheduler { |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 38 | |
| 39 | namespace { |
| 40 | |
Ady Abraham | bdda8f0 | 2021-04-01 16:06:11 -0700 | [diff] [blame] | 41 | bool isLayerActive(const LayerInfo& info, nsecs_t threshold) { |
Ady Abraham | 89089c9 | 2020-04-15 18:24:41 -0700 | [diff] [blame] | 42 | // Layers with an explicit vote are always kept active |
Ady Abraham | bdda8f0 | 2021-04-01 16:06:11 -0700 | [diff] [blame] | 43 | if (info.getSetFrameRateVote().rate.isValid()) { |
Ady Abraham | 89089c9 | 2020-04-15 18:24:41 -0700 | [diff] [blame] | 44 | return true; |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 45 | } |
Ady Abraham | 89089c9 | 2020-04-15 18:24:41 -0700 | [diff] [blame] | 46 | |
Ady Abraham | bdda8f0 | 2021-04-01 16:06:11 -0700 | [diff] [blame] | 47 | return info.isVisible() && info.getLastUpdatedTime() >= threshold; |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 48 | } |
| 49 | |
| 50 | bool traceEnabled() { |
| 51 | return property_get_bool("debug.sf.layer_history_trace", false); |
| 52 | } |
| 53 | |
| 54 | bool useFrameRatePriority() { |
| 55 | char value[PROPERTY_VALUE_MAX]; |
| 56 | property_get("debug.sf.use_frame_rate_priority", value, "1"); |
| 57 | return atoi(value); |
| 58 | } |
| 59 | |
Ady Abraham | bdda8f0 | 2021-04-01 16:06:11 -0700 | [diff] [blame] | 60 | void trace(const LayerInfo& info, LayerHistory::LayerVoteType type, int fps) { |
Ady Abraham | 0ccd79b | 2020-06-10 10:11:17 -0700 | [diff] [blame] | 61 | const auto traceType = [&](LayerHistory::LayerVoteType checkedType, int value) { |
| 62 | ATRACE_INT(info.getTraceTag(checkedType), type == checkedType ? value : 0); |
Ady Abraham | a6b676e | 2020-05-27 14:29:09 -0700 | [diff] [blame] | 63 | }; |
| 64 | |
Ady Abraham | 0ccd79b | 2020-06-10 10:11:17 -0700 | [diff] [blame] | 65 | traceType(LayerHistory::LayerVoteType::NoVote, 1); |
| 66 | traceType(LayerHistory::LayerVoteType::Heuristic, fps); |
| 67 | traceType(LayerHistory::LayerVoteType::ExplicitDefault, fps); |
| 68 | traceType(LayerHistory::LayerVoteType::ExplicitExactOrMultiple, fps); |
Ady Abraham | dd5bfa9 | 2021-01-07 17:56:08 -0800 | [diff] [blame] | 69 | traceType(LayerHistory::LayerVoteType::ExplicitExact, fps); |
Ady Abraham | 0ccd79b | 2020-06-10 10:11:17 -0700 | [diff] [blame] | 70 | traceType(LayerHistory::LayerVoteType::Min, 1); |
| 71 | traceType(LayerHistory::LayerVoteType::Max, 1); |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 72 | |
Ady Abraham | bdda8f0 | 2021-04-01 16:06:11 -0700 | [diff] [blame] | 73 | ALOGD("%s: %s @ %d Hz", __FUNCTION__, info.getName().c_str(), fps); |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 74 | } |
Andy Labrada | 096227e | 2022-06-15 16:58:11 +0000 | [diff] [blame] | 75 | |
| 76 | LayerHistory::LayerVoteType getVoteType(LayerInfo::FrameRateCompatibility compatibility, |
| 77 | bool contentDetectionEnabled) { |
| 78 | LayerHistory::LayerVoteType voteType; |
| 79 | if (!contentDetectionEnabled || compatibility == LayerInfo::FrameRateCompatibility::NoVote) { |
| 80 | voteType = LayerHistory::LayerVoteType::NoVote; |
| 81 | } else if (compatibility == LayerInfo::FrameRateCompatibility::Min) { |
| 82 | voteType = LayerHistory::LayerVoteType::Min; |
| 83 | } else { |
| 84 | voteType = LayerHistory::LayerVoteType::Heuristic; |
| 85 | } |
| 86 | return voteType; |
| 87 | } |
| 88 | |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 89 | } // namespace |
| 90 | |
Ady Abraham | 3efa394 | 2021-06-24 19:01:25 -0700 | [diff] [blame] | 91 | LayerHistory::LayerHistory() |
Ady Abraham | b1b9d41 | 2020-06-01 19:53:52 -0700 | [diff] [blame] | 92 | : mTraceEnabled(traceEnabled()), mUseFrameRatePriority(useFrameRatePriority()) { |
Marin Shalamanov | 1bc43ee | 2020-11-20 16:56:52 +0100 | [diff] [blame] | 93 | LayerInfo::setTraceEnabled(mTraceEnabled); |
Ady Abraham | b1b9d41 | 2020-06-01 19:53:52 -0700 | [diff] [blame] | 94 | } |
| 95 | |
Marin Shalamanov | 1bc43ee | 2020-11-20 16:56:52 +0100 | [diff] [blame] | 96 | LayerHistory::~LayerHistory() = default; |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 97 | |
Andy Labrada | 096227e | 2022-06-15 16:58:11 +0000 | [diff] [blame] | 98 | void LayerHistory::registerLayer(Layer* layer, bool contentDetectionEnabled) { |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 99 | std::lock_guard lock(mLock); |
Dominik Laskowski | 0c41ffa | 2021-12-24 16:45:12 -0800 | [diff] [blame] | 100 | LOG_ALWAYS_FATAL_IF(findLayer(layer->getSequence()).first != LayerStatus::NotFound, |
Nathaniel Nifong | 1303d91 | 2021-10-06 09:41:24 -0400 | [diff] [blame] | 101 | "%s already registered", layer->getName().c_str()); |
Andy Labrada | 096227e | 2022-06-15 16:58:11 +0000 | [diff] [blame] | 102 | LayerVoteType type = |
| 103 | getVoteType(layer->getDefaultFrameRateCompatibility(), contentDetectionEnabled); |
Ady Abraham | be09aad | 2021-05-03 18:59:38 -0700 | [diff] [blame] | 104 | auto info = std::make_unique<LayerInfo>(layer->getName(), layer->getOwnerUid(), type); |
Nathaniel Nifong | 1303d91 | 2021-10-06 09:41:24 -0400 | [diff] [blame] | 105 | |
| 106 | // The layer can be placed on either map, it is assumed that partitionLayers() will be called |
| 107 | // to correct them. |
| 108 | mInactiveLayerInfos.insert({layer->getSequence(), std::make_pair(layer, std::move(info))}); |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 109 | } |
| 110 | |
Ady Abraham | bdda8f0 | 2021-04-01 16:06:11 -0700 | [diff] [blame] | 111 | void LayerHistory::deregisterLayer(Layer* layer) { |
| 112 | std::lock_guard lock(mLock); |
Nathaniel Nifong | 1303d91 | 2021-10-06 09:41:24 -0400 | [diff] [blame] | 113 | if (!mActiveLayerInfos.erase(layer->getSequence())) { |
| 114 | if (!mInactiveLayerInfos.erase(layer->getSequence())) { |
| 115 | LOG_ALWAYS_FATAL("%s: unknown layer %p", __FUNCTION__, layer); |
| 116 | } |
Ady Abraham | bdda8f0 | 2021-04-01 16:06:11 -0700 | [diff] [blame] | 117 | } |
Ady Abraham | bdda8f0 | 2021-04-01 16:06:11 -0700 | [diff] [blame] | 118 | } |
| 119 | |
Marin Shalamanov | 1bc43ee | 2020-11-20 16:56:52 +0100 | [diff] [blame] | 120 | void LayerHistory::record(Layer* layer, nsecs_t presentTime, nsecs_t now, |
| 121 | LayerUpdateType updateType) { |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 122 | std::lock_guard lock(mLock); |
Nathaniel Nifong | 1303d91 | 2021-10-06 09:41:24 -0400 | [diff] [blame] | 123 | auto id = layer->getSequence(); |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 124 | |
Nathaniel Nifong | 1303d91 | 2021-10-06 09:41:24 -0400 | [diff] [blame] | 125 | auto [found, layerPair] = findLayer(id); |
Dominik Laskowski | 0c41ffa | 2021-12-24 16:45:12 -0800 | [diff] [blame] | 126 | if (found == LayerStatus::NotFound) { |
Ady Abraham | be09aad | 2021-05-03 18:59:38 -0700 | [diff] [blame] | 127 | // Offscreen layer |
Dominik Laskowski | 0c41ffa | 2021-12-24 16:45:12 -0800 | [diff] [blame] | 128 | ALOGV("%s: %s not registered", __func__, layer->getName().c_str()); |
Ady Abraham | be09aad | 2021-05-03 18:59:38 -0700 | [diff] [blame] | 129 | return; |
| 130 | } |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 131 | |
Nathaniel Nifong | 1303d91 | 2021-10-06 09:41:24 -0400 | [diff] [blame] | 132 | const auto& info = layerPair->second; |
Ady Abraham | bdda8f0 | 2021-04-01 16:06:11 -0700 | [diff] [blame] | 133 | const auto layerProps = LayerInfo::LayerProps{ |
| 134 | .visible = layer->isVisible(), |
| 135 | .bounds = layer->getBounds(), |
| 136 | .transform = layer->getTransform(), |
| 137 | .setFrameRateVote = layer->getFrameRateForLayerTree(), |
| 138 | .frameRateSelectionPriority = layer->getFrameRateSelectionPriority(), |
| 139 | }; |
| 140 | |
| 141 | info->setLastPresentTime(presentTime, now, updateType, mModeChangePending, layerProps); |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 142 | |
| 143 | // Activate layer if inactive. |
Dominik Laskowski | 0c41ffa | 2021-12-24 16:45:12 -0800 | [diff] [blame] | 144 | if (found == LayerStatus::LayerInInactiveMap) { |
Nathaniel Nifong | 1303d91 | 2021-10-06 09:41:24 -0400 | [diff] [blame] | 145 | mActiveLayerInfos.insert( |
| 146 | {id, std::make_pair(layerPair->first, std::move(layerPair->second))}); |
| 147 | mInactiveLayerInfos.erase(id); |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 148 | } |
| 149 | } |
| 150 | |
Andy Labrada | 096227e | 2022-06-15 16:58:11 +0000 | [diff] [blame] | 151 | void LayerHistory::setDefaultFrameRateCompatibility(Layer* layer, bool contentDetectionEnabled) { |
| 152 | std::lock_guard lock(mLock); |
| 153 | auto id = layer->getSequence(); |
| 154 | |
| 155 | auto [found, layerPair] = findLayer(id); |
| 156 | if (found == LayerStatus::NotFound) { |
| 157 | // Offscreen layer |
| 158 | ALOGV("%s: %s not registered", __func__, layer->getName().c_str()); |
| 159 | return; |
| 160 | } |
| 161 | |
| 162 | const auto& info = layerPair->second; |
| 163 | info->setDefaultLayerVote( |
| 164 | getVoteType(layer->getDefaultFrameRateCompatibility(), contentDetectionEnabled)); |
| 165 | } |
| 166 | |
Dominik Laskowski | d82e0f0 | 2022-10-26 15:23:04 -0400 | [diff] [blame] | 167 | auto LayerHistory::summarize(const RefreshRateSelector& selector, nsecs_t now) -> Summary { |
Ady Abraham | 73c3df5 | 2023-01-12 18:09:31 -0800 | [diff] [blame^] | 168 | ATRACE_CALL(); |
Dominik Laskowski | 0c41ffa | 2021-12-24 16:45:12 -0800 | [diff] [blame] | 169 | Summary summary; |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 170 | |
| 171 | std::lock_guard lock(mLock); |
| 172 | |
| 173 | partitionLayers(now); |
| 174 | |
Nathaniel Nifong | 1303d91 | 2021-10-06 09:41:24 -0400 | [diff] [blame] | 175 | for (const auto& [key, value] : mActiveLayerInfos) { |
| 176 | auto& info = value.second; |
Ady Abraham | bdda8f0 | 2021-04-01 16:06:11 -0700 | [diff] [blame] | 177 | const auto frameRateSelectionPriority = info->getFrameRateSelectionPriority(); |
Ady Abraham | aae5ed5 | 2020-06-26 09:32:43 -0700 | [diff] [blame] | 178 | const auto layerFocused = Layer::isLayerFocusedBasedOnPriority(frameRateSelectionPriority); |
Ady Abraham | bdda8f0 | 2021-04-01 16:06:11 -0700 | [diff] [blame] | 179 | ALOGV("%s has priority: %d %s focused", info->getName().c_str(), frameRateSelectionPriority, |
| 180 | layerFocused ? "" : "not"); |
Ana Krulec | 3803b8d | 2020-02-03 16:35:46 -0800 | [diff] [blame] | 181 | |
Ady Abraham | 73c3df5 | 2023-01-12 18:09:31 -0800 | [diff] [blame^] | 182 | ATRACE_FORMAT("%s", info->getName().c_str()); |
Dominik Laskowski | d82e0f0 | 2022-10-26 15:23:04 -0400 | [diff] [blame] | 183 | const auto vote = info->getRefreshRateVote(selector, now); |
Ady Abraham | 89089c9 | 2020-04-15 18:24:41 -0700 | [diff] [blame] | 184 | // Skip NoVote layer as those don't have any requirements |
Dominik Laskowski | 0c41ffa | 2021-12-24 16:45:12 -0800 | [diff] [blame] | 185 | if (vote.type == LayerVoteType::NoVote) { |
Ady Abraham | 89089c9 | 2020-04-15 18:24:41 -0700 | [diff] [blame] | 186 | continue; |
| 187 | } |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 188 | |
Ady Abraham | 89089c9 | 2020-04-15 18:24:41 -0700 | [diff] [blame] | 189 | // Compute the layer's position on the screen |
Ady Abraham | bdda8f0 | 2021-04-01 16:06:11 -0700 | [diff] [blame] | 190 | const Rect bounds = Rect(info->getBounds()); |
| 191 | const ui::Transform transform = info->getTransform(); |
Ady Abraham | 89089c9 | 2020-04-15 18:24:41 -0700 | [diff] [blame] | 192 | constexpr bool roundOutwards = true; |
| 193 | Rect transformed = transform.transform(bounds, roundOutwards); |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 194 | |
Ady Abraham | 89089c9 | 2020-04-15 18:24:41 -0700 | [diff] [blame] | 195 | const float layerArea = transformed.getWidth() * transformed.getHeight(); |
| 196 | float weight = mDisplayArea ? layerArea / mDisplayArea : 0.0f; |
Ady Abraham | 73c3df5 | 2023-01-12 18:09:31 -0800 | [diff] [blame^] | 197 | ATRACE_FORMAT_INSTANT("%s %s (%d%)", ftl::enum_string(vote.type).c_str(), |
| 198 | to_string(vote.fps).c_str(), weight * 100); |
Ady Abraham | bdda8f0 | 2021-04-01 16:06:11 -0700 | [diff] [blame] | 199 | summary.push_back({info->getName(), info->getOwnerUid(), vote.type, vote.fps, |
Ady Abraham | 62a0be2 | 2020-12-08 16:54:10 -0800 | [diff] [blame] | 200 | vote.seamlessness, weight, layerFocused}); |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 201 | |
Ady Abraham | 89089c9 | 2020-04-15 18:24:41 -0700 | [diff] [blame] | 202 | if (CC_UNLIKELY(mTraceEnabled)) { |
Ady Abraham | bdda8f0 | 2021-04-01 16:06:11 -0700 | [diff] [blame] | 203 | trace(*info, vote.type, vote.fps.getIntValue()); |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 204 | } |
| 205 | } |
| 206 | |
| 207 | return summary; |
| 208 | } |
| 209 | |
Marin Shalamanov | 1bc43ee | 2020-11-20 16:56:52 +0100 | [diff] [blame] | 210 | void LayerHistory::partitionLayers(nsecs_t now) { |
Ady Abraham | 73c3df5 | 2023-01-12 18:09:31 -0800 | [diff] [blame^] | 211 | ATRACE_CALL(); |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 212 | const nsecs_t threshold = getActiveLayerThreshold(now); |
| 213 | |
Nathaniel Nifong | 1303d91 | 2021-10-06 09:41:24 -0400 | [diff] [blame] | 214 | // iterate over inactive map |
| 215 | LayerInfos::iterator it = mInactiveLayerInfos.begin(); |
| 216 | while (it != mInactiveLayerInfos.end()) { |
| 217 | auto& [layerUnsafe, info] = it->second; |
Ady Abraham | bdda8f0 | 2021-04-01 16:06:11 -0700 | [diff] [blame] | 218 | if (isLayerActive(*info, threshold)) { |
Nathaniel Nifong | 1303d91 | 2021-10-06 09:41:24 -0400 | [diff] [blame] | 219 | // move this to the active map |
| 220 | |
| 221 | mActiveLayerInfos.insert({it->first, std::move(it->second)}); |
| 222 | it = mInactiveLayerInfos.erase(it); |
| 223 | } else { |
| 224 | if (CC_UNLIKELY(mTraceEnabled)) { |
Dominik Laskowski | 0c41ffa | 2021-12-24 16:45:12 -0800 | [diff] [blame] | 225 | trace(*info, LayerVoteType::NoVote, 0); |
Nathaniel Nifong | 1303d91 | 2021-10-06 09:41:24 -0400 | [diff] [blame] | 226 | } |
| 227 | info->onLayerInactive(now); |
| 228 | it++; |
| 229 | } |
| 230 | } |
| 231 | |
| 232 | // iterate over active map |
| 233 | it = mActiveLayerInfos.begin(); |
| 234 | while (it != mActiveLayerInfos.end()) { |
| 235 | auto& [layerUnsafe, info] = it->second; |
| 236 | if (isLayerActive(*info, threshold)) { |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 237 | // Set layer vote if set |
Ady Abraham | bdda8f0 | 2021-04-01 16:06:11 -0700 | [diff] [blame] | 238 | const auto frameRate = info->getSetFrameRateVote(); |
Ady Abraham | 71c437d | 2020-01-31 15:56:57 -0800 | [diff] [blame] | 239 | const auto voteType = [&]() { |
| 240 | switch (frameRate.type) { |
| 241 | case Layer::FrameRateCompatibility::Default: |
| 242 | return LayerVoteType::ExplicitDefault; |
Andy Labrada | 096227e | 2022-06-15 16:58:11 +0000 | [diff] [blame] | 243 | case Layer::FrameRateCompatibility::Min: |
| 244 | return LayerVoteType::Min; |
Ady Abraham | 71c437d | 2020-01-31 15:56:57 -0800 | [diff] [blame] | 245 | case Layer::FrameRateCompatibility::ExactOrMultiple: |
| 246 | return LayerVoteType::ExplicitExactOrMultiple; |
| 247 | case Layer::FrameRateCompatibility::NoVote: |
| 248 | return LayerVoteType::NoVote; |
Ady Abraham | dd5bfa9 | 2021-01-07 17:56:08 -0800 | [diff] [blame] | 249 | case Layer::FrameRateCompatibility::Exact: |
| 250 | return LayerVoteType::ExplicitExact; |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 251 | } |
Ady Abraham | 71c437d | 2020-01-31 15:56:57 -0800 | [diff] [blame] | 252 | }(); |
Ady Abraham | 5dde597 | 2020-05-13 10:50:54 -0700 | [diff] [blame] | 253 | |
Marin Shalamanov | e8a663d | 2020-11-24 17:48:00 +0100 | [diff] [blame] | 254 | if (frameRate.rate.isValid() || voteType == LayerVoteType::NoVote) { |
Ady Abraham | bdda8f0 | 2021-04-01 16:06:11 -0700 | [diff] [blame] | 255 | const auto type = info->isVisible() ? voteType : LayerVoteType::NoVote; |
Marin Shalamanov | 53fc11d | 2020-11-20 14:00:13 +0100 | [diff] [blame] | 256 | info->setLayerVote({type, frameRate.rate, frameRate.seamlessness}); |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 257 | } else { |
| 258 | info->resetLayerVote(); |
| 259 | } |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 260 | |
Nathaniel Nifong | 1303d91 | 2021-10-06 09:41:24 -0400 | [diff] [blame] | 261 | it++; |
| 262 | } else { |
| 263 | if (CC_UNLIKELY(mTraceEnabled)) { |
Dominik Laskowski | 0c41ffa | 2021-12-24 16:45:12 -0800 | [diff] [blame] | 264 | trace(*info, LayerVoteType::NoVote, 0); |
Nathaniel Nifong | 1303d91 | 2021-10-06 09:41:24 -0400 | [diff] [blame] | 265 | } |
| 266 | info->onLayerInactive(now); |
| 267 | // move this to the inactive map |
| 268 | mInactiveLayerInfos.insert({it->first, std::move(it->second)}); |
| 269 | it = mActiveLayerInfos.erase(it); |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 270 | } |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 271 | } |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 272 | } |
| 273 | |
Marin Shalamanov | 1bc43ee | 2020-11-20 16:56:52 +0100 | [diff] [blame] | 274 | void LayerHistory::clear() { |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 275 | std::lock_guard lock(mLock); |
Nathaniel Nifong | 1303d91 | 2021-10-06 09:41:24 -0400 | [diff] [blame] | 276 | for (const auto& [key, value] : mActiveLayerInfos) { |
| 277 | value.second->clearHistory(systemTime()); |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 278 | } |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 279 | } |
Ady Abraham | 0ccd79b | 2020-06-10 10:11:17 -0700 | [diff] [blame] | 280 | |
Marin Shalamanov | 1bc43ee | 2020-11-20 16:56:52 +0100 | [diff] [blame] | 281 | std::string LayerHistory::dump() const { |
Dominik Laskowski | 983f2b5 | 2020-06-25 16:54:06 -0700 | [diff] [blame] | 282 | std::lock_guard lock(mLock); |
Dominik Laskowski | 03cfce8 | 2022-11-02 12:13:29 -0400 | [diff] [blame] | 283 | return base::StringPrintf("{size=%zu, active=%zu}", |
Nathaniel Nifong | 1303d91 | 2021-10-06 09:41:24 -0400 | [diff] [blame] | 284 | mActiveLayerInfos.size() + mInactiveLayerInfos.size(), |
| 285 | mActiveLayerInfos.size()); |
| 286 | } |
| 287 | |
| 288 | float LayerHistory::getLayerFramerate(nsecs_t now, int32_t id) const { |
| 289 | std::lock_guard lock(mLock); |
| 290 | auto [found, layerPair] = findLayer(id); |
Dominik Laskowski | 0c41ffa | 2021-12-24 16:45:12 -0800 | [diff] [blame] | 291 | if (found != LayerStatus::NotFound) { |
Nathaniel Nifong | 1303d91 | 2021-10-06 09:41:24 -0400 | [diff] [blame] | 292 | return layerPair->second->getFps(now).getValue(); |
| 293 | } |
| 294 | return 0.f; |
| 295 | } |
| 296 | |
Dominik Laskowski | 0c41ffa | 2021-12-24 16:45:12 -0800 | [diff] [blame] | 297 | auto LayerHistory::findLayer(int32_t id) -> std::pair<LayerStatus, LayerPair*> { |
Nathaniel Nifong | 1303d91 | 2021-10-06 09:41:24 -0400 | [diff] [blame] | 298 | // the layer could be in either the active or inactive map, try both |
| 299 | auto it = mActiveLayerInfos.find(id); |
| 300 | if (it != mActiveLayerInfos.end()) { |
Dominik Laskowski | 0c41ffa | 2021-12-24 16:45:12 -0800 | [diff] [blame] | 301 | return {LayerStatus::LayerInActiveMap, &(it->second)}; |
Nathaniel Nifong | 1303d91 | 2021-10-06 09:41:24 -0400 | [diff] [blame] | 302 | } |
| 303 | it = mInactiveLayerInfos.find(id); |
| 304 | if (it != mInactiveLayerInfos.end()) { |
Dominik Laskowski | 0c41ffa | 2021-12-24 16:45:12 -0800 | [diff] [blame] | 305 | return {LayerStatus::LayerInInactiveMap, &(it->second)}; |
Nathaniel Nifong | 1303d91 | 2021-10-06 09:41:24 -0400 | [diff] [blame] | 306 | } |
Dominik Laskowski | 0c41ffa | 2021-12-24 16:45:12 -0800 | [diff] [blame] | 307 | return {LayerStatus::NotFound, nullptr}; |
Dominik Laskowski | 983f2b5 | 2020-06-25 16:54:06 -0700 | [diff] [blame] | 308 | } |
| 309 | |
Marin Shalamanov | 1bc43ee | 2020-11-20 16:56:52 +0100 | [diff] [blame] | 310 | } // namespace android::scheduler |